def reindex(self):
"""Replace the generators by simple generators indexed by integers."""
gen_list = list(self.generators)
new_gen_list = []
translate_dict = dict()
for i in range(len(gen_list)):
new_gen = gen_list[i].toSimpleDDGenerator("g%d"%(i+1))
new_gen_list.append(new_gen)
translate_dict[gen_list[i]] = new_gen
self.generators = set(new_gen_list)
new_delta = dict()
for k, v in self.delta_map.items():
new_v = E0
for (AGen1, AGen2, MGen), coeff in v.items():
target_gen = TensorGenerator(
(AGen1, AGen2, translate_dict[MGen]), self.AAtensorM)
new_v += target_gen.elt(coeff)
new_delta[translate_dict[k]] = new_v
self.delta_map = new_delta
if hasattr(self, "grading"):
new_grading = dict()
for gen, gr in self.grading.items():
if gen in translate_dict: # gen is still in ddstr
new_grading[translate_dict[gen]] = gr
self.grading = new_grading
def addDelta(self, gen_from, gen_to, alg_coeff1, alg_coeff2, ring_coeff):
"""Add ring_coeff * (alg_coeff1, alg_coeff2) * gen_to to the delta of
gen_from. The first four arguments should be generators.
"""
assert gen_from.parent == self and gen_to.parent == self
assert alg_coeff1.getLeftIdem() == gen_from.idem1
assert alg_coeff1.getRightIdem() == gen_to.idem1
assert alg_coeff2.getLeftIdem() == gen_from.idem2
assert alg_coeff2.getRightIdem() == gen_to.idem2
target_gen = TensorGenerator((alg_coeff1, alg_coeff2, gen_to),
self.AAtensorM)
self.delta_map[gen_from] += target_gen.elt(ring_coeff)
def addDelta(self, gen_from, gen_to, coeff_d, coeffs_a, ring_coeff):
"""Add ring_coeff * (coeff_d * gen_to) to the delta of gen_from, with
coeffs_a as A-side inputs. The arguments gen_form, gen_to, and coeff_d
should be generators, and coeff_a should be a list of generators.
"""
assert gen_from.parent == self and gen_to.parent == self
assert DAStructure.idemMatchDA(gen_from, gen_to, coeff_d, coeffs_a)
coeffs_a = tuple(coeffs_a)
target_gen = TensorGenerator((coeff_d, gen_to), self.AtensorM)
if (gen_from, coeffs_a) not in self.da_action:
self.da_action[(gen_from, coeffs_a)] = E0
self.da_action[(gen_from, coeffs_a)] += target_gen.elt(ring_coeff)
# Clean out the zero maps
if self.da_action[(gen_from, coeffs_a)] == 0:
del self.da_action[(gen_from, coeffs_a)]
def rmultiply(self, MGen, AGen):
''' Multiply a generator of DStructure with an algebra generator
means forming a tensor'''
return 1 * TensorGenerator((AGen, MGen), self.AtensorM)
