def __init__(self, parent, gen_left, gen_right): """Specify generators on the two sides of the tensor. Both are type D generators because the AA generator in between is assumed. """ # Note tuple initialization is automatic Generator.__init__(self, parent)
def __init__(self, parent, idem1, idem2): """Every generator has two idempotents. idem1 is the type D idempotent on the left. idem2 is the type A idempotent on the right. """ Generator.__init__(self, parent) self.idem1, self.idem2 = idem1, idem2
def __init__(self, parent, source, coeff, target): """Specifies the morphism source -> coeff * target. Note coeff has type TensorDGAlgebra of the two algebras that act on the DD structures. """ Generator.__init__(self, parent) MorObject.__init__(self, source, coeff, target)
def __init__(self, parent, source, coeff, target): """Specifies the morphism source -> coeff * target.""" Generator.__init__(self, parent) MorObject.__init__(self, source, coeff, target) filt = [] if hasattr(source, "filtration"): filt += [1-x for x in source.filtration] if hasattr(target, "filtration"): filt += target.filtration if filt != []: self.filtration = filt
def __init__(self, parent, strands): """Specifies the parent algebra (of type PreStrandAlgebra), and a list of strands. Each element of strands is a pair specifying the starting and ending points. """ Generator.__init__(self, parent) self.pmc = parent.pmc self.strands = tuple(sorted(strands)) self.left_pt_idem = tuple(sorted([s for s, t in self.strands])) self.right_pt_idem = tuple(sorted([t for s, t in self.strands])) self.left_idem = tuple(sorted([self.pmc.pairid[s] for s in self.left_pt_idem])) self.right_idem = tuple(sorted([self.pmc.pairid[s] for s in self.right_pt_idem]))
def __init__(self, parent, coeff_d, coeffs_a, source, target): """Specifies the morphism m(source, coeffs_a) -> coeff_d * target. source and target are generators in two type DA bimodules with same algebra actions. If the bimodules have left type D action by algebra1 and right type A action by algebra2, then as a MorObject coeff is of type TensorDGAlgebra(algebra1, CobarAlgebra(algebra2)). """ Generator.__init__(self, parent) self.coeff_d, self.coeffs_a = coeff_d, coeffs_a cobar_alg = CobarAlgebra(source.parent.algebra2) tensor_alg = TensorDGAlgebra((source.parent.algebra1, cobar_alg)) coeff = TensorGenerator( (coeff_d, TensorStarGenerator(coeffs_a, cobar_alg, source.idem2)), tensor_alg) MorObject.__init__(self, source, coeff, target)
def __init__(self, parent, left_idem, strands, right_idem = None): """Specifies PMC, left idempotent and right idempotent as list of pair ID's, and strands as a list of pairs (start, end). For example, in the split PMC of genus 2, the strand diagram with double horizontal at (1,3) and strand from 2 to 5 would be encoded as: left_idem = [1,2], right_idem = [1,3], strands = [(2,5)], since pair (1,3) has index 1, pair (2,4) has index 2, and pair (5,7) has index 3. """ Generator.__init__(self, parent) self.pmc = parent.pmc self.mult_one = parent.mult_one self.strands = strands if not isinstance(self.strands, Strands): self.strands = Strands(self.pmc, self.strands) # Calculate left idempotent if necessary if left_idem is None: assert right_idem is not None left_idem = self.strands.propagateLeft(right_idem) self.left_idem = left_idem if not isinstance(self.left_idem, Idempotent): self.left_idem = Idempotent(self.pmc, self.left_idem) # Calculate right idempotent if necessary if right_idem is None: right_idem = self.strands.propagateRight(self.left_idem) assert right_idem is not None, \ "Invalid init data for strand diagram: cannot propagate to right." self.right_idem = right_idem if not isinstance(self.right_idem, Idempotent): self.right_idem = Idempotent(self.pmc, self.right_idem) # Enumerate double horizontals self.double_hor = list(self.left_idem) for st in self.strands: self.double_hor.remove(self.pmc.pairid[st[0]]) self.double_hor = tuple(self.double_hor) # Get multiplicity from strands self.multiplicity = self.strands.multiplicity
def opposite_algebra(A_inf): gen_by_name = AttrDict({}) for gen in A_inf.genset: gen_by_name[gen.name + '*'] = Generator(gen.name + '*') new_A_inf_actions = Bunch_of_arrows([]) for action in A_inf.a_inf_actions: new_action = () for element in action: new_action = new_action + (gen_by_name[element.name + '*'], ) new_A_inf_actions[new_action[:-1][::-1] + (new_action[-1], )] += 1 return simpler_A_inf_Algebra(gen_by_name, 'opposite of ' + A_inf.name, new_A_inf_actions)
def rename_generators(A, list_of_tuples_to_rename): new_generators = AttrDict({}) # for t in list_of_tuples_to_rename: # new_generators[t[1]]=Generator(name=t[1], aux_info=A.gen_by_name[t[0]]) for gen in A.gen_by_name.values(): if gen.name in [t[0] for t in list_of_tuples_to_rename]: t = next(t for t in list_of_tuples_to_rename if t[0] == gen.name) new_generators[t[1]] = Generator(name=t[1], aux_info=A.gen_by_name[t[0]]) else: new_generators[gen.name] = Generator(name=gen.name, aux_info=gen) new_A_inf_actions = Bunch_of_arrows({}) for action in A.a_inf_actions: new_action = () for el in action: new_action = new_action + (next(gen for gen in new_generators.values() if gen.aux_info == el), ) new_A_inf_actions[new_action] += 1 return simpler_A_inf_Algebra(new_generators, A.name + '_renamed', new_A_inf_actions)
def __init__(self, parent, left_idem, strands): """Specifies the parent algebra (which contains the local PMC), left idempotent, and strands. Input parameters: - parent: must be an object of LocalStrandAlgebra. - left_idem: tuple containing IDs of occupied pairs. - strands: tuple of pairs specifying strands. """ Generator.__init__(self, parent) self.local_pmc = parent.local_pmc self.left_idem = left_idem if not isinstance(self.left_idem, LocalIdempotent): self.left_idem = LocalIdempotent(self.local_pmc, self.left_idem) if not isinstance(strands, LocalStrands): strands = LocalStrands(self.local_pmc, strands) self.strands = strands # Get right_idem and multiplicity from strands self.right_idem = self.strands.propagateRight(self.left_idem) self.multiplicity = self.strands.multiplicity # Enumerate single and double horizontals self.all_hor = list(self.left_idem) for st in self.strands: start_idem = self.local_pmc.pairid[st[0]] if start_idem != -1: if start_idem not in self.all_hor: print left_idem, strands self.all_hor.remove(start_idem) self.all_hor = tuple(self.all_hor) self.single_hor = tuple([i for i in self.all_hor if len(self.local_pmc.pairs[i]) == 1]) self.double_hor = tuple([i for i in self.all_hor if len(self.local_pmc.pairs[i]) == 2])
def u_i_rename_generators(A): new_generators = AttrDict({}) i = 0 for gen in A.gen_by_name.values(): new_generators["u_" + str(i)] = Generator(name="u_" + str(i), aux_info=gen) i += 1 new_A_inf_actions = Bunch_of_arrows({}) for action in A.a_inf_actions: new_action = () for el in action: new_action = new_action + (next(gen for gen in new_generators.values() if gen.aux_info == el), ) new_A_inf_actions[new_action] += 1 return simpler_A_inf_Algebra(new_generators, A.name + '_renamed', new_A_inf_actions)
def __init__(self, parent, gen_left, gen_right): ''' Specifies generators on the two sides of the tensor.''' # Both are type D generators? ( CB and reread) Generator.__init__(self, parent)
def __init__(self, parent, idem1, idem2): ''' Every generator has two idempotents. idem1: left type D idempotent on the left. idem2: right type A idempotent on the right.''' # cb and check Generator.__init__(self,parent) self.idem1, self.idem2 = idem1, idem2
def __init__(self, parent, idem): ''' Every generator must have an idempotent. ''' Generator.__init__(self, parent) self.idem = idem # ask akram # left idempotent CB and fill in
def base_change_AA_from_fuk(Fuk, generators, left_dg_algebra, right_dg_algebra): def check_validity(x, action): if action[:-1].count(x) == 1 and (action[-1] in generators): index_of_x = action[:-1].index(x) for el in action[:index_of_x]: if not el.name in left_dg_algebra.gen_by_name.keys(): return False for el in action[index_of_x + 1:-1]: if not el.name in right_dg_algebra.gen_by_name.keys(): return False return True else: return False gen_by_name = AttrDict({}) for x in generators: gen_by_name['' + x.name + ''] = Generator('' + x.name + '') # gen_by_name[''+x.name+''].add_idems(x.idem.left, x.idem.right) # adding idempotents for action in [ act for act in Fuk.a_inf_actions if (len(act) == 3 and ( act[0].name in left_dg_algebra.idem_by_name.keys()) and ( x == act[1]) and (x == act[-1])) ]: left_idem = left_dg_algebra.idem_by_name[action[0].name] for action in [ act for act in Fuk.a_inf_actions if (len(act) == 3 and ( act[1].name in right_dg_algebra.idem_by_name.keys()) and ( x == act[0]) and (x == act[-1])) ]: right_idem = right_dg_algebra.idem_by_name[action[1].name] gen_by_name['' + x.name + ''].add_idems(left_idem, right_idem) arrows = Bunch_of_arrows([]) for y in generators: for action in Fuk.a_inf_actions: if (len(action) == 3 and (action[0].name in left_dg_algebra.idem_by_name.keys()) and (y == action[1]) and (y == action[-1])): continue if (len(action) == 3 and (action[1].name in right_dg_algebra.idem_by_name.keys()) and (y == action[0]) and (y == action[-1])): continue if check_validity(y, action): index_of_y = action[:-1].index(y) tuple_from_left = tuple([ (lambda z: left_dg_algebra.gen_by_name[z.name])(z) for z in action[:index_of_y] ]) tuple_from_right = tuple([ (lambda z: right_dg_algebra.gen_by_name[z.name])(z) for z in action[index_of_y + 1:-1] ]) arrows[(tuple_from_left, gen_by_name['' + y.name + ''], tuple_from_right, gen_by_name['' + action[-1].name + ''])] += 1 return AA_bimodule(gen_by_name, arrows, left_dg_algebra, right_dg_algebra, name='AA_from_Fuk', to_check=True)
def __init__(self, parent, sd_left, sd_right): "Specifies the two strand diagrams." "" # Note tuple initialization is automatic Generator.__init__(self, parent)
def __init__(self, parent, idem): """Every generator must have an idempotent.""" Generator.__init__(self, parent) self.idem = idem
def __init__(self, parent, idem1, idem2): """Every generator has two idempotents (for the two type D actions).""" Generator.__init__(self, parent) self.idem1, self.idem2 = idem1, idem2
def __init__(self, parent, idem1, idem2): ''' Every generator has two idempotents. idem1: left type D idempotent on the left. idem2: right type A idempotent on the right.''' # cb and check Generator.__init__(self, parent) self.idem1, self.idem2 = idem1, idem2