From b17121cf5ba10cf758a87c4c29e3b060e8dc75fb Mon Sep 17 00:00:00 2001 From: Cotton Seed Date: Sun, 9 Sep 2012 11:18:25 -0400 Subject: [PATCH] Added tests for Kh homotopy type: CP^2, mutation invariance, sq1 and sq2 satisfy adem relations. --- knotkit.h | 7 + main.cpp | 516 +++++++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 444 insertions(+), 79 deletions(-) diff --git a/knotkit.h b/knotkit.h index 63ec89e..f00816d 100644 --- a/knotkit.h +++ b/knotkit.h @@ -86,6 +86,13 @@ class knot_desc std::string name () const; unsigned table_crossing_knots () const; + hash_t hash_self () const + { + return hash_combine (hash ((int)t), + hash_combine (hash (i), + hash (j))); + } + void write_self (writer &w) const; void show_self () const { printf ("%s", name ().c_str ()); } void display_self () const { show_self (); newline (); } diff --git a/main.cpp b/main.cpp index 980ab7f..78f2215 100644 --- a/main.cpp +++ b/main.cpp @@ -219,6 +219,7 @@ homological_width (ptr > H) } int dwidth = maxd - mind; + assert (is_even (dwidth)); unsigned hwidth = (dwidth / 2) + 1; return hwidth; } @@ -346,84 +347,6 @@ load (map, mod_map > > knot_kh_sq, - knot_desc desc) -{ - pair, mod_map > p = knot_kh_sq(desc); - - mod_map sq1 = p.first; - mod_map sq2 = p.second; - - 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 ++) - { - 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; - - // printf (" r = (%d, %d, %d, %d)\n", r1, r2, r3, r4); - - int s1 = r2 - r4, - s2 = r1 - r2 - r3 + r4, - s3 = r4, - s4 = r3 - r4; - - if (s1 != 0) - { - if (first) - first = 0; - else - printf (", "); - printf ("(%d, %d) -> (%d, %d, %d, %d)", - hq.h, hq.q, - s1, s2, s3, s4); - } - } - - newline (); -} - void sage_show (FILE *fp, std::string prefix, @@ -669,6 +592,7 @@ convert_knot_sq () // write (w, knot_sq); } +#if 0 void test_knot_sq () { @@ -697,6 +621,7 @@ compute_kh_sq (const knot_desc &desc) { abort (); } +#endif template pair >, mod_map > FU_complex (ptr > CF, @@ -923,12 +848,445 @@ test_forgetful_ss () } } +/* Kh homotopy type: + - check for CP^2, + - mutation invariance + - K-theory */ + +map > +compute_st (mod_map sq1, + mod_map sq2) +{ + ptr > H = sq1.domain (); + + map > st; + + 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); + + 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 (); + + int s1 = r2 - r4, + s2 = r1 - r2 - r3 + r4, + s3 = r4, + s4 = r3 - r4; + + if (!s1 && !s2 && !s3 && !s4) + continue; + + basedvector s (4); + s[1] = s1; + s[2] = s2; + s[3] = s3; + s[4] = s4; + + st.push (hq, s); + } + + return st; +} + +void +test_knot_sq () +{ + const char *knot_sq_files[] = { + "knot_sq/rolfsen_sq.dat.gz", + "knot_sq/Ksmall_sq.dat.gz", + "knot_sq/K11_sq.dat.gz", + "knot_sq/K12_sq.dat.gz", + "knot_sq/K13_sq.dat.gz", +#if 0 + "knot_sq/K14_sq.dat.gz", + "knot_sq/Lsmall_sq.dat.gz", + "knot_sq/L11_sq.dat.gz", + "knot_sq/L12_sq.dat.gz", + "knot_sq/L13_sq.dat.gz", + "knot_sq/L14_sq.dat.gz", +#endif + 0, + }; + + hashset mutants; + for (unsigned i = 11; i <= 15; i ++) + { + basedvector, 1> groups + = mutant_knot_groups (i); + for (unsigned j = 1; j <= groups.size (); j ++) + { + for (unsigned k = 1; k <= groups[j].size (); k ++) + mutants += knot_desc (knot_desc::HTW, i, groups[j][k]); + } + } + printf ("|mutants| = %d\n", mutants.card ()); + + basedvector width_hist (7); + for (unsigned i = 1; i <= width_hist.size (); i ++) + width_hist[i] = 0; + + hashmap, mod_map > > mutant_knot_sq, + mutant_mknot_sq; + + { + gzfile_reader r ("knot_sq/mut_mknot.dat.gz"); + mutant_mknot_sq = hashmap, mod_map > > (r); + + for (hashmap, mod_map > >::const_iter i = mutant_mknot_sq; i; i ++) + { + knot_desc desc = i.key (); + + // careful: duplicate code! + pair, mod_map > p = i.val (); + + mod_map sq1 = p.first, + sq2 = p.second; + ptr > H = sq1.domain (); + + unsigned w = homological_width (H); + assert (w >= 1 && w <= 7); + width_hist[w] ++; + + assert (sq1.compose (sq1) == 0); + assert (sq2.compose (sq2) == sq1.compose (sq2).compose (sq1)); + + map > st + = compute_st (sq1, sq2); + for (map_const_iter > i = st; i; i ++) + { + if (i.val ()[1] != 0) + { + show (desc); newline (); + printf (" > has CP^2\n"); + } + } + } + } + + for (unsigned i = 0; knot_sq_files[i]; i ++) + { + gzfile_reader r (knot_sq_files[i]); + + printf ("loading %s...\n", knot_sq_files[i]); + + unsigned n = r.read_unsigned (); + for (unsigned i = 1; i <= n; i ++) + { + knot_desc desc (r); + + pair, mod_map > p (r); + if (mutants % desc) + mutant_knot_sq.push (desc, p); + + mod_map sq1 = p.first, + sq2 = p.second; + ptr > H = sq1.domain (); + + unsigned w = homological_width (H); + assert (w >= 1 && w <= 7); + width_hist[w] ++; + + assert (sq1.compose (sq1) == 0); + assert (sq2.compose (sq2) == sq1.compose (sq2).compose (sq1)); + + map > st + = compute_st (sq1, sq2); + for (map_const_iter > i = st; i; i ++) + { + if (i.val ()[1] != 0) + { + show (desc); newline (); + printf (" > has CP^2\n"); + } + } + } + } + + printf ("|mutant_knot_sq| = %d\n", mutant_knot_sq.card ()); + printf ("width_hist:\n"); + for (unsigned i = 1; i <= width_hist.size (); i ++) + { + printf (" % 2d: %d\n", i, width_hist[i]); + } + + unsigned missing = 0, + compared = 0; + for (unsigned i = 11; i <= 15; i ++) + { + basedvector, 1> groups + = mutant_knot_groups (i); + + for (unsigned j = 1; j <= groups.size (); j ++) + { + bool first = 1; + + knot_desc desc_1; + ptr > H_1; + map > st_1; + + for (unsigned k = 1; k <= groups[j].size (); k ++) + { + knot_desc desc (knot_desc::HTW, i, groups[j][k]); + + if (mutant_knot_sq % desc) + { + pair, mod_map > p = mutant_knot_sq(desc); + + mod_map sq1 = p.first, + sq2 = p.second; + ptr > H = sq1.domain (); + + map > st = compute_st (sq1, sq2); + + if (first) + { + first = 0; + desc_1 = desc; + H_1 = H; + st_1 = st; + } + else + { + if (H_1->free_poincare_polynomial () + == H->free_poincare_polynomial ()) + { + if (st_1 != st) + { + printf ("> DIFFER\n"); + display (" ", desc_1); + display (" ", desc); + } + compared ++; + } + else if (mutant_mknot_sq % desc) + { + pair, mod_map > mp = mutant_mknot_sq(desc); + + mod_map msq1 = mp.first, + msq2 = mp.second; + ptr > mH = msq1.domain (); + + assert (H_1->free_poincare_polynomial () + == mH->free_poincare_polynomial ()); + + map > mst + = compute_st (msq1, msq2); + + if (st_1 != mst) + { + printf ("> DIFFER\n"); + display (" ", desc_1); + display (" ", desc); + } + compared ++; + } + else + missing ++; + } + } + else + missing ++; + } + } + } + printf ("missing = %d\n", missing); + printf ("compared = %d\n", compared); +} + +void +compute_mutant_mirrors () +{ + const char *knot_sq_files[] = { + // "knot_sq/K11_sq.dat.gz", + // "knot_sq/K12_sq.dat.gz", + // "knot_sq/K13_sq.dat.gz", + "knot_sq/K14_sq.dat.gz", + 0, + }; + unsigned minn = 14, + maxn = 14; + + hashset mutants; + for (unsigned i = minn; i <= maxn; i ++) + { + basedvector, 1> groups + = mutant_knot_groups (i); + for (unsigned j = 1; j <= groups.size (); j ++) + { + for (unsigned k = 1; k <= groups[j].size (); k ++) + mutants += knot_desc (knot_desc::HTW, i, groups[j][k]); + } + } + printf ("|mutants| = %d\n", mutants.card ()); + + hashmap, mod_map > > mutant_knot_sq; + + for (unsigned i = 0; knot_sq_files[i]; i ++) + { + gzfile_reader r (knot_sq_files[i]); + + printf ("loading %s...\n", knot_sq_files[i]); + + unsigned n = r.read_unsigned (); + for (unsigned i = 1; i <= n; i ++) + { + knot_desc k (r); + + pair, mod_map > p (r); + if (mutants % k) + mutant_knot_sq.push (k, p); + } + } + + printf ("|mutant_knot_sq| = %d\n", mutant_knot_sq.card ()); + + map, mod_map > > mknot_kh_sq; + for (unsigned i = minn; i <= maxn; i ++) + { + basedvector, 1> groups + = mutant_knot_groups (i); + for (unsigned j = 1; j <= groups.size (); j ++) + { + unsigned n = groups[j].size (); + + basedvector >, 1> group_H (n); + for (unsigned k = 1; k <= n; k ++) + { + knot_desc desc (knot_desc::HTW, i, groups[j][k]); + pair, mod_map > p = mutant_knot_sq(desc); + group_H[k] = p.first.domain (); + } + + for (unsigned k = 2; k <= n; k ++) + { + if (group_H[1]->free_poincare_polynomial () + != group_H[k]->free_poincare_polynomial ()) + { + knot_desc desc (knot_desc::HTW, i, groups[j][k]); + show (desc); newline (); + + knot_diagram kd (MIRROR, desc.diagram ()); + + cube c (kd); + mod_map d = c.compute_d (1, 0, 0, 0, 0); + + chain_complex_simplifier s (c.khC, d, 1); + assert (s.new_d == 0); + + steenrod_square sq (c, d, s); + mod_map sq1 = sq.sq1 (); + mod_map sq2 = sq.sq2 (); + + ptr > H = sq1.domain (); + + assert (group_H[1]->free_poincare_polynomial () + == H->free_poincare_polynomial ()); + + char buf[1000]; + assert (desc.t == knot_desc::HTW); + sprintf (buf, "mknot/K%d_%d.dat.gz", desc.i, desc.j); + gzfile_writer w (buf); + write (w, desc); + write (w, sq1); + write (w, sq2); + } + } + } + } +} + +void +convert_mknots () +{ + hashmap, mod_map > > mutant_mknot_sq; + + for (unsigned i = 11; i <= 15; i ++) + { + basedvector, 1> groups + = mutant_knot_groups (i); + for (unsigned j = 1; j <= groups.size (); j ++) + { + unsigned n = groups[j].size (); + for (unsigned k = 1; k <= n; k ++) + { + knot_desc desc (knot_desc::HTW, i, groups[j][k]); + + char buf[1000]; + assert (desc.t == knot_desc::HTW); + sprintf (buf, "mknot/K%d_%d.dat.gz", desc.i, desc.j); + + struct stat stat_buf; + if (stat (buf, &stat_buf) != 0) + { + if (errno != ENOENT) + { + stderror ("stat: %s", buf); + exit (EXIT_FAILURE); + } + } + else + { + printf ("loading %s...\n", buf); + + gzfile_reader r (buf); + + knot_desc desc_2 (r); + assert (desc_2 == desc); + + mod_map sq1 (r); + mod_map sq2 (r); + + mutant_mknot_sq.push (desc, + pair, mod_map > (sq1, sq2)); + } + } + } + } + + gzfile_writer w ("knot_sq/mut_mknot.dat.gz"); + write (w, mutant_mknot_sq); +} + int main () { - test_forgetful_ss (); + compute_mutant_mirrors (); return 0; + test_knot_sq (); + convert_mknots (); + + test_forgetful_ss (); compute_twistedU (); #if 1