def getDDStructure(self, abs_gr_info = None):
"""Returns the type DD structure corresponding to this arcslide."""
self.all_idems = self.getIdems()
self.all_chords = []
if self.slide_type == UNDER_SLIDE:
for chord_type in self._UChords:
chord_type(self)
else:
for chord_type in self._OChords:
chord_type(self)
alg1 = self.start_pmc.getAlgebra()
alg2 = self.end_pmc.opp().getAlgebra()
ddstr = DDStrFromChords(alg1, alg2, self.all_idems, self.all_chords)
if abs_gr_info is not None:
self._getAbsGrading(ddstr, abs_gr_info)
else:
for gen in ddstr.getGenerators():
base_gen = gen
break
ddstr.registerHDiagram(getArcslideDiagram(self), base_gen)
return ddstr
def _getAbsGrading(self, ddstr, abs_gr_info, expand_after = True):
"""Find absolute grading for type DD structure (to replace finding a
relative grading). It can be shown that value of expand_after does not
matter.
"""
# Find grading of elements:
# Create Heegaard diagram for the expanded arcslide.
genus = self.start_pmc.genus
if expand_after:
ex_start_pmc = connectSumPMC(self.start_pmc, splitPMC(genus))
ex_slide = Arcslide(ex_start_pmc, self.b1, self.c1)
else:
ex_start_pmc = connectSumPMC(splitPMC(genus), self.start_pmc)
ex_slide = Arcslide(ex_start_pmc, 4*genus+self.b1, 4*genus+self.c1)
ex_end_pmc = ex_slide.end_pmc
ex_hdiagram = getArcslideDiagram(ex_slide)
hgens = ex_hdiagram.getHFGenerators()
# First step, find grading of two extreme generators, using one of
# which as the base generator.
base_idem = [Idempotent(ex_start_pmc, range(2*genus)),
Idempotent(ex_end_pmc.opp(), range(2*genus))]
base_idem2 = [Idempotent(ex_start_pmc, range(2*genus, 4*genus)),
Idempotent(ex_end_pmc.opp(), range(2*genus, 4*genus))]
if abs_gr_info == 0:
base_gen = ex_hdiagram.getGeneratorByIdem(base_idem, True)
else:
base_gen = ex_hdiagram.getGeneratorByIdem(base_idem2, True)
ex_gr_set, ex_grs = ex_hdiagram.computeDDGrading(base_gen)
# Second step
# # print ex_gr_set
# base_gr1 = ex_grs[base_gen]
# base_gr2 = ex_grs[base_gen2]
# # print base_gr1, base_gr2
# spinc11, spinc12 = base_gr1.data[0].spinc, base_gr1.data[1].spinc
# spinc21, spinc22 = base_gr2.data[0].spinc, base_gr2.data[1].spinc
# spincmavg1 = [-(a+b)/Fraction(2) for a,b in zip(spinc11, spinc21)]
# spincmavg2 = [-(a+b)/Fraction(2) for a,b in zip(spinc12, spinc22)]
# maslovavg = base_gr1.data[0].maslov + base_gr2.data[0].maslov + \
# base_gr1.data[1].maslov + base_gr2.data[1].maslov
# mavg1 = SmallGradingElement(
# base_gr1.data[0].parent, -maslovavg, spincmavg1)
# mavg2 = SmallGradingElement(
# base_gr2.data[0].parent, -Fraction(1,16), spincmavg2)
# ex_gr_set, ex_grs = ex_hdiagram.computeDDGrading(base_gen,
# (mavg1, mavg2))
# # print ex_gr_set
# # print ex_grs[base_gen], ex_grs[base_gen2]
# Form the grading set for the original arcslide from the extended one
periodic_domains = []
for ex_gr1, ex_gr2 in ex_gr_set.periodic_domains:
ex_spinc1, ex_spinc2 = ex_gr1.spinc, ex_gr2.spinc
if expand_after:
spinc1, spinc2 = ex_spinc1[0:2*genus], ex_spinc2[2*genus:]
else:
spinc1, spinc2 = ex_spinc1[2*genus:], ex_spinc2[0:2*genus]
if not (all([n == 0 for n in spinc1]) and
all([n == 0 for n in spinc2])):
gr1 = self.start_pmc.small_gr(ex_gr1.maslov, spinc1)
gr2 = self.end_pmc.opp().small_gr(ex_gr2.maslov, spinc2)
periodic_domains.append([gr1, gr2])
ddstr.gr_set = SimpleDbGradingSet(
SmallGradingGroup(self.start_pmc), ACTION_LEFT,
SmallGradingGroup(self.end_pmc.opp()), ACTION_LEFT,
periodic_domains)
# Now obtain the grading of generators
ddstr.grading = dict()
for hgen, ex_gr in ex_grs.items():
ex_idem1, ex_idem2 = hgen.getDIdem()
ex_gr1, ex_gr2 = ex_gr.data
if expand_after:
pairs1 = [n for n in ex_idem1 if n < 2*genus]
pairs2 = [n-2*genus for n in ex_idem2 if n >= 2*genus]
else:
pairs1 = [n-2*genus for n in ex_idem1 if n >= 2*genus]
pairs2 = [n for n in ex_idem2 if n < 2*genus]
if len(pairs1) == genus:
# Get the corresponding generator in ddstr
cur_idem = [Idempotent(self.start_pmc, pairs1),
Idempotent(self.end_pmc.opp(), pairs2)]
cur_gen = [gen for gen in ddstr.getGenerators()
if [gen.idem1, gen.idem2] == cur_idem]
assert len(cur_gen) == 1
cur_gen = cur_gen[0]
# Finally get the grading
ex_spinc1, ex_spinc2 = ex_gr1.spinc, ex_gr2.spinc
if expand_after:
for i in range(2*genus):
assert ex_spinc2[i] == ex_spinc1[4*genus-i-1]
spinc1 = ex_spinc1[0:2*genus]
spinc2 = ex_spinc2[2*genus:]
else:
for i in range(2*genus, 4*genus):
assert ex_spinc2[i] == ex_spinc1[4*genus-i-1]
spinc1 = ex_spinc1[2*genus:]
spinc2 = ex_spinc2[0:2*genus]
gr = SimpleDbGradingSetElement(
ddstr.gr_set,
[self.start_pmc.small_gr(ex_gr1.maslov, spinc1),
self.end_pmc.opp().small_gr(ex_gr2.maslov, spinc2)])
if cur_gen in ddstr.grading:
assert ddstr.grading[cur_gen] == gr
else:
ddstr.grading[cur_gen] = gr
ddstr.checkGrading()
return ddstr
def __init__(self, slide):
"""Specifies the arcslide to use. slide should be of type Arcslide.
In addition to recording slide, construct the following:
local_pmc1, mapping1 - restriction of starting pmc to location of slide.
outer_pmc1, outer_mapping1 - complement of slide in starting pmc.
local_pmc2, mapping2, outer_pmc2, outer_mapping2
- same, but for ending pmc.
Moreover, find pattern_fun and translator as appropriate for the case at
hand.
"""
self.slide = slide
self.pmc1, self.pmc2 = slide.start_pmc, slide.end_pmc
n = self.pmc1.n
b1, c1, c2 = slide.b1, slide.c1, slide.c2
b1p, c1p, c2p = [slide.to_r[p] for p in b1, c1, c2]
# Note intervals (start, end) with start > end are ignored.
# patterns_base specifies one of the four base patterns of arcslides.
# translator gives the mapping between points in the base pattern and
# points in the pattern at hand.
if b1 == c1 + 1: # downward
if c2 == c1 + 2: # short underslide downward
local_cut1, local_cut2 = ([(c1, c2)], [(c1p, c2p)])
patterns_fun = ArcslideDA._short_underslide_down
if c1 == 0:
translator = ([-1, 0, 1, 2, 3], [-1, 0, 1, 2, 3])
elif c2 == n - 1:
translator = ([0, 1, 2, 3, -1], [0, 1, 2, 3, -1])
else:
translator = None
elif c2 > c1: # general underslide downward
local_cut1, local_cut2 = (
[(c1, b1), (c2, c2)], [(c1p, c1p), (b1p, c2p)])
patterns_fun = ArcslideDA._general_underslide_down
if c1 == 0:
translator = ([-1, 0, 1, 2, 3, 4, 5],
[-1, 0, 1, 2, 3, 4, 5])
elif c2 == n - 1:
translator = ([0, 1, 2, 3, 4, 5, -1],
[0, 1, 2, 3, 4, 5, -1])
else:
translator = None
else: # c2 < c1, general overslide downward
local_cut1, local_cut2 = (
[(c2, c2), (c1, b1)], [(b1p, c2p), (c1p, c1p)])
patterns_fun = ArcslideDA._general_underslide_down
if c2 == 0 and b1 == n - 1:
translator = ([2, 3, 4, -1, -1, 0, 1],
[3, 4, -1, -1, 0, 1, 2])
elif c2 == 0:
translator = ([2, 3, 4, 5, -1, 0, 1],
[3, 4, 5, -1, 0, 1, 2])
elif b1 == n - 1:
translator = ([3, 4, 5, -1, 0, 1, 2],
[4, 5, -1, 0, 1, 2, 3])
else:
translator = ([3, 4, 5, 6, 0, 1, 2], [4, 5, 6, 0, 1, 2, 3])
elif b1 == c1 - 1: # upward
if c2 == c1 - 2: # short underslide upward
local_cut1, local_cut2 = ([(c2, c1)], [(c2p, c1p)])
patterns_fun = ArcslideDA._short_underslide_up
if c2 == 0:
translator = ([-1, 0, 1, 2, 3], [-1, 0, 1, 2, 3])
elif c1 == n - 1:
translator = ([0, 1, 2, 3, -1], [0, 1, 2, 3, -1])
else:
translator = None
elif c2 < c1: # general underslide upward
local_cut1, local_cut2 = (
[(c2, c2), (b1, c1)], [(c2p, b1p), (c1p, c1p)])
patterns_fun = ArcslideDA._general_underslide_up
if c2 == 0:
translator = ([-1, 0, 1, 2, 3, 4, 5],
[-1, 0, 1, 2, 3, 4, 5])
elif c1 == n - 1:
translator = ([0, 1, 2, 3, 4, 5, -1],
[0, 1, 2, 3, 4, 5, -1])
else:
translator = None
else: # c2 > c1, general overslide upward
local_cut1, local_cut2 = (
[(b1, c1), (c2, c2)], [(c1p, c1p), (c2p, b1p)])
patterns_fun = ArcslideDA._general_underslide_up
if b1 == 0 and c2 == n - 1:
translator = ([3, 4, -1, -1, 0, 1, 2],
[2, 3, 4, -1, -1, 0, 1])
elif b1 == 0:
translator = ([3, 4, 5, -1, 0, 1, 2],
[2, 3, 4, 5, -1, 0, 1])
elif c2 == n - 1:
translator = ([4, 5, -1, 0, 1, 2, 3],
[3, 4, 5, -1, 0, 1, 2])
else:
translator = ([4, 5, 6, 0, 1, 2, 3], [3, 4, 5, 6, 0, 1, 2])
else:
# All cases are covered. Should not happen.
raise NotImplementedError(
"This slide pattern is not yet implemented.")
self.patterns_fun = patterns_fun
self.translator = translator
# Necesssary to get local DA structure.
self.splitting1 = PMCSplitting(self.pmc1, local_cut1)
self.splitting2 = PMCSplitting(self.pmc2, local_cut2)
self.local_pmc1 = self.splitting1.local_pmc
self.local_pmc2 = self.splitting2.local_pmc
self.mapping1 = self.splitting1.local_mapping
self.mapping2 = self.splitting2.local_mapping
# Required so the left to right transition on the outside can proceed.
assert self.splitting1.outer_pmc == self.splitting2.outer_pmc
# Initiate the ExtendedDAStructure
ExtendedDAStructure.__init__(
self, self.getLocalDAStructure(), self.splitting1, self.splitting2)
# With generators set, add grading. Any generator can serve as base_gen
for gen in self.generators:
base_gen = gen
break
self.registerHDiagram(getArcslideDiagram(self.slide), base_gen)
