def testTensorDDandD(self): d1 = zeroTypeD(1) d2 = zeroTypeDAdm(1) d3 = zeroTypeD(2) dd_id = identityDD(splitPMC(1)) dd_id2 = identityDD(splitPMC(2)) dd_slide1 = Arcslide(splitPMC(1), 0, 1).getDDStructure() dstr1 = computeDATensorD(dd_id, d1) dstr2 = computeDATensorD(dd_id, d2) dstr3 = computeDATensorD(dd_slide1, d1) dstr4 = computeDATensorD(dd_id2, d3)
def testAbsoluteGrading(self): assert DEFAULT_GRADING == SMALL_GRADING dd_abs_info = 1 gr_info = [4] d1 = zeroTypeD(1, is_dual = False, abs_gr_info = gr_info) d1d = zeroTypeD(1, is_dual = True, abs_gr_info = gr_info) d2 = infTypeD(1, is_dual = False, abs_gr_info = gr_info) d2d = infTypeD(1, is_dual = True, abs_gr_info = gr_info) cases = [(d1d, [], d2), (d2d, [], d1), (d1d, [(1,0)], d2), # Dehn twist for d1d (d2d, [(2,1)], d1), # Dehn twist for d2d (d1d, [(3,2)], d1), # d1d -> d2d (d2d, [(0,1)], d2), # d2d -> d1d (d2d, [(1,0)], d1), # Dehn twist for d1 (d1d, [(2,1)], d2), # Dehn twist for d2 (d2d, [(3,2)], d2), # d2 -> d1 (d1d, [(0,1)], d1), # d1 -> d2 (d1d, [(3,2),(3,2)], d2), # Case 0 and 1 (d1d, [(2,1),(2,1)], d1), # Hopf link (d1d, [(2,3)]*3, d1), # Trefoil (d1d, [(2,3),(1,0),(2,3)], d1), # Trefoil 2 (d1d, [(2,3),(1,2)]*3, d2), # Boundary dehn twist (d2d, [(2,3),(1,2)]*3, d1), # Boundary dehn twist, #2 (d2d, [(3,2)]*3, d1), # ? (d1d, [(2,1),(1,0),(1,2),(2,3),(2,3)], d1), # Unknot (d1d, [(3,2),(0,1)], d2) ] for start, slides, end in cases[0:10]: slides_dd = [Arcslide(splitPMC(1), b1, c1).\ getDDStructure(dd_abs_info) for b1, c1 in slides] d_mid = start # print "start grading ", d_mid.grading for dd in slides_dd: # print dd.gr_set # for gen, gr in dd.grading.items(): # print gen, gr d_mid = computeATensorDD(d_mid, dd) d_mid.simplify() # print "mid grading ", d_mid.grading # print d_mid.gr_set.simplifiedSet() # for gen in d_mid.getGenerators(): # print gen, d_mid.grading[gen].simplifiedElt() cur_cx = computeATensorD(d_mid, end) cur_cx.simplify() # print cur_cx.gr_set, cur_cx.grading # Alternate way of computing # d_mid = end # for dd in reversed(slides_dd): # d_mid = computeDATensorD(dd, d_mid) # cur_cx = computeATensorD(start, d_mid) cur_abs_gr = cur_cx.getAbsGradingInfo() print [str(n) for n in cur_abs_gr]
def testGrading(self): d1 = zeroTypeD(1) d2 = infTypeD(1) dd_id = identityDD(splitPMC(1)) cx = computeATensorD(d1.dual(), d2) dstr1 = computeDATensorD(dd_id, d1) dstr2 = computeATensorDD(d1, dd_id)
def testTensorDoubleD(self): d1 = zeroTypeD(1) d2 = zeroTypeDAdm(1) d3 = zeroTypeD(2) d4 = zeroTypeDAdm(2) d5 = zeroTypeD(3) d6 = zeroTypeDAdm(3) d7 = zeroTypeD(4) d8 = zeroTypeDAdm(4) tests = [(d1, d2, 2), (d2, d1, 2), (d2, d2, 2), (d3, d4, 4), (d4, d3, 4), (d4, d4, 4), (d5, d6, 8), (d7, d8, 16)] for d_left, d_right, expected_len in tests: cx = computeATensorD(d_left.dual(), d_right) cx.simplify() self.assertEqual(len(cx), expected_len)
def testDATensorD(self): dastr = identityDA(splitPMC(2)) dstr = zeroTypeD(2) dstr_result = dastr.tensorD(dstr) cx = dstr_result.morToD(infTypeD(2)) cx.simplify() # Basic check that dstr_result is still zeroTypeD(2) self.assertEqual(len(cx), 1)
def testDATensorD(self): # So far mostly checking that it will run in a reasonable amount of # time. slide = Arcslide(splitPMC(5), 2, 1) # will change zeroTypeD dastr = ArcslideDA(slide) dstr = zeroTypeD(5) dstr_result = dastr.tensorD(dstr) dstr_result.reindex() self.assertEqual(len(dstr_result), 2)
def testMorToD(self): id2 = identityDD(splitPMC(2)) d = infTypeD(2) d2 = id2.morToD(d) self.assertTrue(d2.testDelta()) d2.simplify() self.assertEqual(len(d2), 1) d3 = zeroTypeD(2) d4 = id2.morToD(d3) self.assertTrue(d4.testDelta()) d4.simplify() self.assertEqual(len(d4), 1)
def openCap(self): """Returns the type D structure corresponding to this handlebody by tensoring type DA bimodules with the genus-1 handlebody. """ assert self.genus > 0 last_move, prev_cap = self.getLastCobordism() if self.genus == 1: if last_move == 0: return zeroTypeD(1) else: return infTypeD(1) else: cur_da = CobordismDALeft(Cobordism(self.genus, last_move, LEFT)) dstr = cur_da.tensorD(prev_cap.openCap()) dstr.simplify() dstr.reindex() return dstr
def testInvolutiveRankS2S1S2S1(self): "Check that the involutive Floer homology of a connect sum of S^2 x S^1 with itself is SOMETHING." P = zeroTypeD(2) cx = involutiveCx(P,P) self.assertTrue(len(cx)==8)
def testInvolutiveRankS2S1(self): "Check that the involutive Floer homology of S^2 x S^1 is F_2^4." P = zeroTypeD(1) cx = involutiveCx(P,P) self.assertTrue(len(cx)==4)
def testInvolutiveRankS3(self): "Check that the involutive Floer homology of S^3 is F_2^2." P = zeroTypeD(1) Q = infTypeD(1) cx = involutiveCx(P,Q) self.assertTrue(len(cx)==2)
def testTensorDandDD(self): d1 = zeroTypeD(1) dd_id = identityDD(splitPMC(1)) dstr1 = computeATensorDD(d1, dd_id)
def testGenus2AbsoluteGrading(self): dd_abs_info = 0 gr_info = [0,0] print gr_info d1 = zeroTypeD(2, is_dual = False, abs_gr_info = gr_info) d1d = zeroTypeD(2, is_dual = True, abs_gr_info = gr_info) d2 = infTypeD(2, is_dual = False, abs_gr_info = gr_info) d2d = infTypeD(2, is_dual = True, abs_gr_info = gr_info) cases = [(d1d, [], d2), (d2d, [], d1), (d1d, [(1,0)], d2), # Dehn twist for d1d (d2d, [(2,1)], d1), # Dehn twist for d2d (d1d, [(3,2),(7,6)], d1), # d1d -> d2d (d2d, [(0,1),(4,5)], d2), # d2d -> d1d (d1d, [(7,6),(0,1)], d1), # mixed (d2d, [(1,0)], d1), # Dehn twist for d1 (d1d, [(2,1)], d2), # Dehn twist for d2 (d2d, [(3,2),(7,6)], d2), # d2 -> d1 (d1d, [(0,1),(4,5)], d1), # d1 -> d2 (d1d, [(3,2),(7,6),(3,4),(6,7),(5,6),(1,2),(3,4),(3,4),(5,6), (5,6),(6,7),(4,3),(5,4),(6,5)], d2), (d2d, [(3,4),(6,7),(5,6),(6,5),(4,3),(4,3),(2,1),(2,1),(1,0), (4,3),(5,4),(6,5)], d2), (d2d, [(3,4),(6,7),(5,6),(6,7),(5,6),(5,6),(3,4),(3,4),(1,2), (4,3),(5,4),(6,5)], d2), (d1d, [(3,4),(6,7),(5,6)] + \ [(6,5),(4,3),(4,3),(2,1),(2,1),(1,0)]*5 + \ [(4,3),(5,4),(6,5)], d2), ] for start, slides, end in cases[0:10]: cur_pmc = splitPMC(2) slides_dd = [] for b1, c1 in slides: arcslide = Arcslide(cur_pmc, b1, c1) cur_pmc = arcslide.end_pmc slides_dd.append(arcslide.getDDStructure(dd_abs_info)) d_mid = start for dd in slides_dd: d_mid = computeATensorDD(d_mid, dd) d_mid.simplify() d_mid.reindex() # print d_mid # print d_mid.gr_set.simplifiedSet() # for gen in d_mid.getGenerators(): # print gen, d_mid.grading[gen].simplifiedElt() cur_cx = computeATensorD(d_mid, end) # dd_mid = slides_dd[0] # for dd in slides_dd[1:]: # dd_mid = computeDATensorDD(dd_mid, dd) # dd_mid.simplify() # dd_mid.reindex() # # print dd_mid # print dd_mid.gr_set.simplifiedSet() # for gen in dd_mid.getGenerators(): # print gen, dd_mid.grading[gen].simplifiedElt() # Alternate way of computing # d_mid = end # for dd in reversed(slides_dd): # d_mid = computeDATensorD(dd, d_mid) # cur_cx = computeATensorD(start, d_mid) cur_abs_gr = cur_cx.getAbsGradingInfo() print [str(n) for n in cur_abs_gr]