From 3797868325f045baed022a1ed1e78b40d885d4b6 Mon Sep 17 00:00:00 2001 From: Cotton Seed Date: Mon, 21 May 2012 10:09:17 -0400 Subject: [PATCH] Fixeds to module reader (not carry unnecessary refcounts?). main checks for homotopy type differences. Added planar_diagram::{show, display}_knottheory. --- algebra/module.h | 25 +- cube_impl.h | 50 ++++ knot_tables.cpp | 6 + main.cpp | 577 +++++++++++++++++++++++++++++++++++++-------- planar_diagram.cpp | 9 +- planar_diagram.h | 5 +- 6 files changed, 565 insertions(+), 107 deletions(-) diff --git a/algebra/module.h b/algebra/module.h index 5ac0ac9..0a5904b 100644 --- a/algebra/module.h +++ b/algebra/module.h @@ -21,7 +21,7 @@ class module : public refcounted static unsigned id_counter; - static basedvector >, 1> id_module; + static map > > reader_id_module; static map, ptr > > direct_sum_idx; @@ -35,9 +35,6 @@ class module : public refcounted { id_counter ++; id = id_counter; - - id_module.append (this); - assert (id_module.size () == id_counter); } module (const module &) = delete; virtual ~module () { } @@ -162,7 +159,7 @@ class module : public refcounted template unsigned module::id_counter = 0; -template basedvector >, 1> module::id_module; +template map > > module::reader_id_module; template map, ptr > > module::direct_sum_idx; @@ -507,7 +504,9 @@ class explicit_module : public module basedvector ann_, basedvector hq_) : r(r_), ann(ann_), hq(hq_) - { } + { + assert (hq.size () == r + ann.size ()); + } explicit explicit_module (unsigned r_, basedvector hq_) : r(r_), hq(hq_) { } ~explicit_module () { } @@ -952,6 +951,7 @@ class mod_map // inj : im -> to ptr > image () const; + ptr > image (basedvector, 1> vs) const; ptr > cokernel () const; @@ -1874,6 +1874,15 @@ mod_map::image () const return impl->to->submodule (span); } +template ptr > +mod_map::image (basedvector, 1> vs) const +{ + mod_span span (impl->from, vs); + ptr > s = impl->from->submodule (span); + mod_map r = restrict_from (s); + return r.image (); +} + template ptr > mod_map::cokernel () const { @@ -2034,11 +2043,13 @@ reader::read_mod () ptr > m = new explicit_module (r, ann, gr); ar->io_id_id.push ((unsigned)(-io_id), m->id); + module::reader_id_module.push (m->id, m); + return m; } else { unsigned id = ar->io_id_id(io_id); - return module::id_module[id]; + return module::reader_id_module(id); } } diff --git a/cube_impl.h b/cube_impl.h index b930d68..0784035 100644 --- a/cube_impl.h +++ b/cube_impl.h @@ -410,11 +410,59 @@ cube::cube (knot_diagram &kd_, bool markedp_only_) // printf ("smoothings:\n"); + unsigned max = 0; + smoothing s (kd); for (unsigned i = 0; i < n_resolutions; i ++) { smallbitset state (n_crossings, i); s.init (kd, state); + +#if 1 + unsigned fromstate = i; + smoothing &from_s = s; + + unsigned n_zerocrossings = n_crossings - unsigned_bitcount (fromstate); + unsigned n_cobordisms = ((unsigned)1) << n_zerocrossings; + for (unsigned j = 0; j < n_cobordisms; j ++) + { + unsigned tostate = unsigned_pack (n_crossings, fromstate, j); + unsigned crossings = tostate & ~fromstate; + + smoothing to_s (kd, smallbitset (n_crossings, tostate)); + + set starting_circles, + ending_circles; + for (unsigned_const_iter k = crossings; k; k ++) + { + unsigned c = k.val (); + + unsigned starting_from = s.ept_circle (kd, kd.crossings[c][2]), + starting_to = s.ept_circle (kd, kd.crossings[c][4]); + starting_circles += starting_from; + starting_circles += starting_to; + + unsigned ending_from = to_s.ept_circle (kd, kd.crossings[c][2]), + ending_to = to_s.ept_circle (kd, kd.crossings[c][4]); + ending_circles += ending_from; + ending_circles += ending_to; + } + if (starting_circles.card () == 1 + && ending_circles.card () == 1) + { + unsigned k = unsigned_bitcount (crossings); + if (k > max) + max = k; + +#if 0 + s.show_self (kd, state); + printf (" crossings "); show (smallbitset (n_crossings, crossings)); + newline (); +#endif + } + } +#endif + resolution_circles[i] = s.n_circles; resolution_generator1[i] = n_generators + 1; n_generators += s.num_generators (markedp_only); @@ -425,6 +473,8 @@ cube::cube (knot_diagram &kd_, bool markedp_only_) #endif } + printf ("max = %d\n", max); + // printf ("(cube) n_generators = %d\n", n_generators); khC = new base_module > (khC_generators (*this)); } diff --git a/knot_tables.cpp b/knot_tables.cpp index 101c8de..a9d8739 100644 --- a/knot_tables.cpp +++ b/knot_tables.cpp @@ -782,6 +782,12 @@ std::string knot_desc::name () const { char buf[1000]; + +#if 0 + sprintf (buf, "knot_desc(%d, %d, %d)", (int)t, i, j); + return buf; +#endif + switch (t) { case ROLFSEN: diff --git a/main.cpp b/main.cpp index 566b553..4796b4c 100644 --- a/main.cpp +++ b/main.cpp @@ -202,6 +202,29 @@ compute_show_kh_sq (knot_desc desc #endif } +unsigned +homological_width (ptr > H) +{ + int maxd = -1000, + mind = 1000; + set gs = H->gradings (); + for (set_const_iter gg = gs; gg; gg ++) + { + grading hq = gg.val (); + int d = 2 * hq.h - hq.q; + if (d < mind) + mind = d; + if (d > maxd) + maxd = d; + } + int dwidth = maxd - mind; + + unsigned hwidth = (dwidth / 2) + 1; + return hwidth; +} + +basedvector hwidth_knots; + void load (map, mod_map > > &knot_kh_sq, @@ -252,6 +275,17 @@ load (map, mod_map > >::const_iter i = m; i; i ++) { + mod_map sq1 = i.val ().first; + ptr > H = sq1.domain (); + unsigned hwidth = homological_width (H); + hwidth_knots[hwidth] ++; + + if (hwidth == 2) + continue; + if (i.key ().t == knot_desc::MT + && i.key ().diagram ().num_components () == 1) + continue; + knot_kh_sq.push (i.key (), i.val ()); } @@ -260,107 +294,71 @@ load (map, mod_map > > knot_kh_sq, + knot_desc desc) { -#if 0 - map, mod_map > > knot_kh_sq; + pair, mod_map > p = knot_kh_sq(desc); - for (unsigned i = 12; i >= 1; i --) - { - if (i <= 10) - { - for (unsigned j = 1; j <= rolfsen_crossing_knots (i); j += block_size) - { - load (knot_kh_sq, knot_desc (knot_desc::ROLFSEN, i, j)); - } - } - - for (unsigned j = 1; j <= htw_knots (i); j += block_size) - { - load (knot_kh_sq, knot_desc (knot_desc::HTW, i, j)); - } - - if (i <= 13) - { - for (unsigned j = 1; j <= mt_links (i); j += block_size) - { - load (knot_kh_sq, knot_desc (knot_desc::MT, i, j)); - } - } - } + mod_map sq1 = p.first; + mod_map sq2 = p.second; - printf ("|knot_kh_sq| = %d\n", knot_kh_sq.card ()); - - for (map, mod_map > >::const_iter i = knot_kh_sq; i; i ++) + printf ("%s ", desc.name ().c_str ()); + + assert (sq1.compose (sq1) == 0); + assert (sq2.compose (sq2) + sq1.compose (sq2).compose (sq1) == 0); + + ptr > H = sq1.domain (); + + map > st; + + bool first = 1; + set gs = H->gradings (); + for (set_const_iter gg = gs; gg; gg ++) { - if (i.key ().t != knot_desc::ROLFSEN) + grading hq = gg.val (), + h1q (hq.h + 1, hq.q), + h2q (hq.h + 2, hq.q); + + ptr > H_hq = H->graded_piece (hq), + H_h1q = H->graded_piece (h1q), + H_h2q = H->graded_piece (h2q); + + mod_map S = sq2.restrict (H_hq, H_h2q), + A = sq1.restrict (H_hq, H_h1q), + B = sq1.restrict (H_h1q, H_h2q); + + ptr > S_im = S.image (), + A_ker = A.kernel (), + B_im = B.image (); + ptr > inter = S_im->intersection (B_im); + + mod_map S_res = S.restrict_from (A_ker); + ptr > S_res_im = S_res.image (); + + ptr > res_inter = S_res_im->intersection (B_im); + + int r1 = S_im->dim (); + int r2 = S_res_im->dim (); + int r3 = inter->dim (); + int r4 = res_inter->dim (); + + if (r1 == 0 + && r2 == 0 + && r3 == 0 + && r4 == 0) continue; - mod_map sq1 = i.val ().first; - mod_map sq2 = i.val ().second; + // printf (" r = (%d, %d, %d, %d)\n", r1, r2, r3, r4); - display ("sq1:\n", sq1); - display ("sq2:\n", sq2); + int s1 = r2 - r4, + s2 = r1 - r2 - r3 + r4, + s3 = r4, + s4 = r3 - r4; - printf ("%s ", i.key ().name ().c_str ()); - - assert (sq1.compose (sq1) == 0); - assert (sq2.compose (sq2) + sq1.compose (sq2).compose (sq1) == 0); - - ptr > H = sq1.domain (); - - map > st; - - bool first = 1; - set gs = H->gradings (); - for (set_const_iter i = gs; i; i ++) + if (s1 != 0) { - grading hq = i.val (), - h1q (hq.h + 1, hq.q), - h2q (hq.h + 2, hq.q); - - // printf ("(%d, %d):\n", hq.h, hq.q); - - ptr > H_hq = H->graded_piece (hq), - H_h1q = H->graded_piece (h1q), - H_h2q = H->graded_piece (h2q); - - mod_map whole = sq2.restrict (H_hq, H_h2q), - tail = sq1.restrict (H_hq, H_h1q), - head = sq1.restrict (H_h1q, H_h2q); - - ptr > whole_im = whole.image (), - tail_ker = tail.kernel (), - head_im = head.image (); - ptr > inter = whole_im->intersection (head_im); - - mod_map whole_res = whole.restrict_from (tail_ker); - ptr > whole_res_im = whole_res.image (); - - ptr > res_inter = whole_res_im->intersection (head_im); - - int r1 = whole_im->dim (); - int r2 = whole_res_im->dim (); - int r3 = inter->dim (); - int r4 = res_inter->dim (); - - if (r1 == 0 - && r2 == 0 - && r3 == 0 - && r4 == 0) - continue; - - // printf (" r = (%d, %d, %d, %d)\n", r1, r2, r3, r4); - -#if 1 - int s1 = r2 - r4, - s2 = r1 - r2 - r3 + r4, - s3 = r4, - s4 = r3 - r4; - if (first) first = 0; else @@ -368,13 +366,406 @@ main () printf ("(%d, %d) -> (%d, %d, %d, %d)", hq.h, hq.q, s1, s2, s3, s4); + } + } + + newline (); +} + +int +main () +{ +#if 0 + knot_diagram kd (mt_link (10, 0, 9)); + cube c (kd); #endif + +#if 0 + for (unsigned i = 1; i <= 10; i ++) + for (unsigned j = 1; j <= mt_links (i, 0); j ++) + { + knot_diagram kd (mt_link (i, 0, j)); + kd.marked_edge = 1; + + cube c (kd, 1); + sseq ss = compute_szabo_sseq (c); + ss.texshow (stdout, kd.name); + } +#endif + +#if 0 +#if 1 + for (unsigned i = 10; i <= 10; i ++) + for (unsigned j = 124; j <= rolfsen_crossing_knots (i); j ++) + { + knot_diagram kd (rolfsen_knot (i, j)); +#endif +#if 0 + for (unsigned i = 1; i <= 10; i ++) + for (unsigned j = 1; j <= mt_links (i, 0); j ++) + { +#endif +#if 0 + for (unsigned i = 11; i <= 11; i ++) + for (unsigned j = 1; j <= htw_knots (i, 0); j ++) + { +#endif + // knot_diagram kd (htw_knot (i, 0, j)); + // knot_diagram kd (mt_link (i, 0, j)); + kd.marked_edge = 1; + + show (kd); newline (); + + cube c (kd, 1); + +#if 0 + mod_map d1 = c.compute_d (1, 0, 0, 0, 0); + + chain_complex_simplifier s (c.khC, d1, 1); + assert (s.new_d == 0); +#endif + + sseq ss = compute_szabo_sseq (c); + + multivariate_laurentpoly Phat = + ss.pages[ss.pages.size ()].delta_poincare_polynomial (ss.bounds); + + typedef spanning_tree_complex::R R; + + spanning_tree_complex spanc (kd); + mod_map d2 = spanc.twisted_d2 (); + mod_map d2U = spanc.twisted_d2Un (1); + + chain_complex_simplifier s2 (spanc.C, d2, 2); + assert (s2.new_d == 0); + + mod_map H_d2U = s2.pi.compose (d2U).compose (s2.iota); + assert (H_d2U.compose (H_d2U) == 0); + + ptr > ker = H_d2U.kernel (); + ptr > quot = s2.new_C->quotient (H_d2U.image ()); + + multivariate_laurentpoly Pminus1 + = ker->free_delta_poincare_polynomial (), + PminusU = quot->free_delta_poincare_polynomial (); + + if (PminusU != Pminus1) + { + display (" HFhat: ", Phat); + // display (" HF-: ", Pminus); + display (" HF- (1): ", Pminus1); + display (" HF- (U): ", PminusU); + } + } +#endif + +#if 1 + hwidth_knots = basedvector (10); + for (unsigned i = 1; i <= hwidth_knots.size (); i ++) + hwidth_knots[i] = 0; + + map, mod_map > > knot_kh_sq; + + for (unsigned i = 14; i >= 1; i --) + { +#if 0 + if (i <= 10) + { + for (unsigned j = 1; j <= rolfsen_crossing_knots (i); j += block_size) + { + load (knot_kh_sq, knot_desc (knot_desc::ROLFSEN, i, j)); + } + } +#endif + + for (unsigned j = 1; j <= htw_knots (i); j += block_size) + { + load (knot_kh_sq, knot_desc (knot_desc::HTW, i, j)); + } + + if (i <= 13) + { + for (unsigned j = 1; j <= mt_links (i); j += block_size) + { + load (knot_kh_sq, knot_desc (knot_desc::MT, i, j)); + } } + if (i == 14) + { + for (unsigned j = 1; j <= mt_links (14, 0); j += block_size) + { + load (knot_kh_sq, knot_desc (knot_desc::MT, 14, mt_links (14, 1) + j)); + } + } } + + unsigned total_knots = 0; + printf ("hwidth_knots:\n"); + for (unsigned i = 1; i <= hwidth_knots.size (); i ++) + { + printf (" % 2d: %d\n", i, hwidth_knots[i]); + total_knots += hwidth_knots[i]; + } + printf ("total_knots = %d\n", total_knots); + + printf ("|knot_kh_sq| = %d\n", knot_kh_sq.card ()); + +#if 1 + map, + map >, + pair > > > P_sq1_knot_st; + + set > Ps; + basedvector collisons (10); + for (unsigned i = 1; i <= 10; i ++) + collisons[i] = 0; + + for (map, mod_map > >::const_iter i = knot_kh_sq; i; i ++) + { + show_st (knot_kh_sq, i.key ()); + + mod_map sq1 = i.val ().first; + mod_map sq2 = i.val ().second; + +#if 0 + display ("sq1:\n", sq1); + display ("sq2:\n", sq2); +#endif + + printf ("%s ", i.key ().name ().c_str ()); + + assert (sq1.compose (sq1) == 0); + assert (sq2.compose (sq2) + sq1.compose (sq2).compose (sq1) == 0); + + ptr > H = sq1.domain (); + unsigned hwidth = homological_width (H); + + map > st; + map sq1_ranks; + + bool first = 1; + + set gs = H->gradings (); + + for (set_const_iter gg = gs; gg; gg ++) + { + grading hq = gg.val (), + h1q (hq.h + 1, hq.q), + h2q (hq.h + 2, hq.q), + h3q (hq.h + 3, hq.q); + + // printf ("(%d, %d):\n", hq.h, hq.q); + + ptr > H_hq = H->graded_piece (hq), + H_h1q = H->graded_piece (h1q), + H_h2q = H->graded_piece (h2q), + H_h3q = H->graded_piece (h3q); + + mod_map S = sq2.restrict (H_hq, H_h2q), + T = sq2.restrict (H_h1q, H_h3q), + A = sq1.restrict (H_hq, H_h1q), + B = sq1.restrict (H_h1q, H_h2q), + C = sq1.restrict (H_h2q, H_h3q); + + ptr > Sker = S.kernel (), + Sim = S.image (), + Tker = T.kernel (), + Tim = T.image (), + Aker = A.kernel (), + Aim = A.image (), + Bker = B.kernel (), + Bim = B.image (), + Cker = C.kernel (), + Cim = C.image (); + + sq1_ranks.push (hq, Aim->dim ()); + + mod_map ArSker = A.restrict_from (Sker); + mod_map SrAker = S.restrict_from (Aker); + + mod_map TrAim = T.restrict_from (Aim); + mod_map TrBker = T.restrict_from (Bker); + mod_map BrTker = B.restrict_from (Tker); + + mod_map CrSim = C.restrict_from (Sim); + + ptr > ArSker_im = ArSker.image (); + ptr > SrAker_im = SrAker.image (); + + ptr > TrAim_im = TrAim.image (); + ptr > TrBker_im = TrBker.image (); + ptr > BrTker_im = BrTker.image (); + + ptr > CrSim_im = CrSim.image (); + + mod_map CrSrAker_im = C.restrict_from (SrAker_im); + mod_map TrArSker_im = T.restrict_from (ArSker_im); + + ptr > CrSrAker_im_im = CrSrAker_im.image (); + ptr > TrArSker_im_im = TrArSker_im.image (); + + ptr > Aker_cap_Sker = Aker->intersection (Sker); + + ptr > Aim_cap_Tker = Aim->intersection (Tker); + ptr > Bker_cap_Tker = Bker->intersection (Tker); + ptr > ArSker_im_cap_Tker = ArSker_im->intersection (Tker); + + ptr > Sim_cap_Bim = Sim->intersection (Bim); + ptr > Sim_cap_BrTker_im = Sim->intersection (BrTker_im); + ptr > Sim_cap_Cker = Sim->intersection (Cker); + ptr > SrAker_im_cap_Bim = SrAker_im->intersection (Bim); + ptr > SrAker_im_cap_BrTker_im = SrAker_im->intersection (BrTker_im); + ptr > SrAker_im_cap_Cker = SrAker_im->intersection (Cker); + + ptr > Tim_cap_Cim = Tim->intersection (Cim); + ptr > TrAim_im_cap_Cim = TrAim_im->intersection (Cim); + ptr > TrBker_im_cap_Cim = TrBker_im->intersection (Cim); + ptr > TrArSker_im_im_cap_Cim = TrBker_im->intersection (Cim); + + ptr > Tim_cap_CrSim_im = Tim->intersection (CrSim_im); + ptr > TrAim_im_cap_CrSim_im = TrAim_im->intersection (CrSim_im); + ptr > TrBker_im_cap_CrSim_im = TrBker_im->intersection (CrSim_im); + ptr > TrArSker_im_im_cap_CrSim_im = TrBker_im->intersection (CrSim_im); + + ptr > Tim_cap_CrSrAker_im_im = Tim->intersection (CrSrAker_im_im); + ptr > TrAim_im_cap_CrSrAker_im_im = TrAim_im->intersection (CrSrAker_im_im); + ptr > TrBker_im_cap_CrSrAker_im_im = TrBker_im->intersection (CrSrAker_im_im); + ptr > TrArSker_im_im_cap_CrSrAker_im_im = TrBker_im->intersection (CrSrAker_im_im); + + basedvector v; + + v.append (Sker->dim ()); + v.append (Sim->dim ()); + v.append (Tker->dim ()); + v.append (Tim->dim ()); + + v.append (Aker->dim ()); + v.append (Aim->dim ()); + v.append (Bker->dim ()); + v.append (Bim->dim ()); + v.append (Cker->dim ()); + v.append (Cim->dim ()); + + v.append (ArSker_im->dim ()); + v.append (SrAker_im->dim ()); + + v.append (TrAim_im->dim ()); + v.append (TrBker_im->dim ()); + v.append (BrTker_im->dim ()); + + v.append (CrSim_im->dim ()); + + v.append (CrSrAker_im_im->dim ()); + v.append (TrArSker_im_im->dim ()); + + v.append (Aker_cap_Sker->dim ()); + + v.append (Aim_cap_Tker->dim ()); + v.append (Bker_cap_Tker->dim ()); + v.append (ArSker_im_cap_Tker->dim ()); + + v.append (Sim_cap_Bim->dim ()); + v.append (Sim_cap_BrTker_im->dim ()); + v.append (Sim_cap_Cker->dim ()); + v.append (SrAker_im_cap_Bim->dim ()); + v.append (SrAker_im_cap_BrTker_im->dim ()); + v.append (SrAker_im_cap_Cker->dim ()); + + v.append (Tim_cap_Cim->dim ()); + v.append (TrAim_im_cap_Cim->dim ()); + v.append (TrBker_im_cap_Cim->dim ()); + v.append (TrArSker_im_im_cap_Cim->dim ()); + + v.append (Tim_cap_CrSim_im->dim ()); + v.append (TrAim_im_cap_CrSim_im->dim ()); + v.append (TrBker_im_cap_CrSim_im->dim ()); + v.append (TrArSker_im_im_cap_CrSim_im->dim ()); + + v.append (Tim_cap_CrSim_im->dim ()); + v.append (TrAim_im_cap_CrSim_im->dim ()); + v.append (TrBker_im_cap_CrSim_im->dim ()); + v.append (TrArSker_im_im_cap_CrSim_im->dim ()); + + st.push (hq, v); + } + newline (); + + multivariate_laurentpoly P = H->free_poincare_polynomial (); + pair > > &, + bool> p = P_sq1_knot_st.find (pair, + map > (P, sq1_ranks)); + if (p.second) + { + collisons[hwidth] ++; + Ps += P; + + if (p.first.second != st) + { + printf ("DIFFER:\n"); + printf ("hwidth = %d\n", hwidth); + + show_st (knot_kh_sq, p.first.first); + show_st (knot_kh_sq, i.key ()); + + printf ("Kh["); + planar_diagram (p.first.first.diagram ()).show_knottheory (); + printf (", Modulus -> Null][q,t] === Kh["); + planar_diagram (i.key ().diagram ()).show_knottheory (); + printf (", Modulus -> Null][q,t]\n"); + +#if 0 + printf ("%s:\n", + p.first.first.name ().c_str ()); + for (map >::const_iter j = p.first.second; j; j ++) + { + printf (" (%d, %d) -> [", + j.key ().h, j.key ().q); + for (unsigned k = 1; k <= j.val ().size (); k ++) + { + if (k > 1) + printf (","); + printf ("%d", j.val ()[k]); + } + newline (); + } + printf ("%s:\n", + i.key ().name ().c_str ()); + for (map >::const_iter j = st; j; j ++) + { + printf (" (%d, %d) -> [", + j.key ().h, j.key ().q); + for (unsigned k = 1; k <= j.val ().size (); k ++) + { + if (k > 1) + printf (","); + printf ("%d", j.val ()[k]); + } + newline (); + } +#endif + } + } + else + { + p.first.first = i.key (); + p.first.second = st; + } + } + + printf ("groups = %d\n", Ps.card ()); + printf ("collisons:\n"); + for (unsigned i = 1; i <= 10; i ++) + printf (" % 2d: %d\n", i, collisons[i]); + +#endif #endif -#if 1 +#if 0 knot_diagram kd (rolfsen_knot (5, 2)); show (kd); newline (); diff --git a/planar_diagram.cpp b/planar_diagram.cpp index 1a23554..650d667 100644 --- a/planar_diagram.cpp +++ b/planar_diagram.cpp @@ -19,21 +19,20 @@ planar_diagram::planar_diagram (const knot_diagram &kd) } void -planar_diagram::display_bohua () const +planar_diagram::show_knottheory () const { - printf ("%s\t[", name.c_str ()); + printf ("PD["); for (unsigned i = 1; i <= crossings.size (); i ++) { if (i > 1) printf (","); - printf ("[%d,%d,%d,%d]", + printf ("X[%d,%d,%d,%d]", crossings[i][1], crossings[i][2], crossings[i][3], crossings[i][4]); } - printf ("]\n"); - + printf ("]"); } void diff --git a/planar_diagram.h b/planar_diagram.h index cd095df..6c32c3a 100644 --- a/planar_diagram.h +++ b/planar_diagram.h @@ -21,8 +21,9 @@ public: { } ~planar_diagram () { } - void display_bohua () const; - + void show_knottheory () const; + void display_knottheory () const { show_knottheory (); newline (); } + void show_self () const { printf ("planar_diagram %s", name.c_str ()); } void display_self () const; };