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]
