def i_3Inner(pT):
answer = tensor()
doublyDefined = pT[1]
for generator, rel in doublyDefined.leftHandRepresentation:
rightHandSide = generator * i_2(pureTensor([1,rel,1]),alg)
answer = answer + pureTensor(1).tensorProduct(rightHandSide)
return answer
def k_4Inner(pT):
answer= tensor()
doublyDefined = pT[1]
for generator, rel in doublyDefined.leftHandRepresentation:
answer = answer + pureTensor((generator,rel,1)).clean()
for rel, generator in doublyDefined.rightHandRepresentation:
answer = answer - pureTensor((1,rel,generator)).clean()
return answer
def i_2Inner(pT):
answer = tensor()
rel = pT[1]
for term in rel.leadingMonomial:
answer = answer + term.coefficient * pureTensor((1,term[0],term[1],1))
for term in rel.lowerOrderTerms:
answer = answer - term.coefficient * pureTensor((1,term[0],term[1],1))
return answer
def k_2Inner(tens):
assert isinstance(tens,pureTensor)
answer= tensor()
rel =tens.monomials[1]
for i in rel.leadingMonomial:
answer = answer + i.coefficient * pureTensor((i.submonomial(0,1),i.submonomial(1,2), 1))
answer = answer + i.coefficient * pureTensor((1,i.submonomial(0,1),i.submonomial(1,2)))
for i in rel.lowerOrderTerms:
answer = answer - i.coefficient * pureTensor((i.submonomial(0,1),i.submonomial(1,2), 1))
answer = answer - i.coefficient * pureTensor((1,i.submonomial(0,1),i.submonomial(1,2)))
return answer
def m_1Inner(b):
b = b[1].clean()
answer = tensor()
if b.degree() != 0:
for i in range(b.degree()):
answer += b.coefficient * pureTensor([b[0:i],b[i],b[i+1:]])
return answer
def pureTensorHelper(polynomials):
assert len(polynomials) > 0
for i in polynomials:
if i.isZero():
return tensor()
pureTensors = []
if len(polynomials) == 1:
for mono in polynomials[0]:
pureTensors.append(pureTensor.pureTensor( (mono,) ))
else:
tempTensors = pureTensorHelper(polynomials[1:])
for mono in polynomials[0]:
for pT in tempTensors:
pureTensors.append(pureTensor.pureTensor( (mono,) ).tensorProduct(pT))
return tuple(pureTensors)
def listOfPolysToTensors(ps):
ps = iter(ps)
pureTensors = [pureTensor.pureTensor(mono) for mono in next(ps)]
for poly in ps:
newPureTensors = []
for mono in poly:
newPureTensors.extend([x.tensorProduct(mono) for x in pureTensors])
pureTensors = newPureTensors
return tensor.tensor(pureTensors)
def b_nInner(tens):
assert isinstance(tens, pureTensor)
assert len(tens) >= 2
tens = tens.clean()
if len(tens) == 2:
return tens[0] * tens[1]
else:
answer = tens.subTensor(1,len(tens) )
answer = answer - pureTensor(1).tensorProduct(tens[1]*tens[2]).tensorProduct(tens.subTensor(3,len(tens)))
if len(tens) != 3:
answer = answer + tens.subTensor(0,2).tensorProduct(b_n(tens.subTensor(2,len(tens)), alg))
return answer
def m_2Inner(PT):
assert isinstance(PT, pureTensor)
assert len(PT) == 4
PT = PT.clean()
w = PT[1] * PT[2]
answer = tensor()
sequence = alg.makeReductionSequence(w)
for reductionFunction, weight in sequence:
answer += PT.coefficient * weight * PT[0] \
* pureTensor([reductionFunction.leftMonomial,
reductionFunction.relation,
reductionFunction.rightMonomial]) * PT[3]
return answer
def wrapped_func(tens):
if tens == 0:
return self.codomain.zero()
tens = tens.clean()
tens = self.domain.reduce(tens)
firstItem = True
for pure in tens:
left =pure[0]
right = pure[-1]
middle = pureTensor.pureTensor(1).tensorProduct(pure.subTensor(1,len(pure)-1)).tensorProduct(1)
if firstItem:
answer = pure.coefficient * left * func(middle) * right
firstItem = False
else:
answer = answer + pure.coefficient * left * func(middle) * right
return self.codomain.reduce(answer)
def zero(self):
return pureTensor.pureTensor([0] * len(self))
def k_1Inner(pT):
assert isinstance(pT,pureTensor)
generator = pT[1]
return pureTensor([generator,1])-pureTensor([1,generator])
def localO(abcde):
intermediate = g(pureTensor([1,abcde[2],abcde[3],1]))
return f(abcde[:2].tensorProduct(intermediate).tensorProduct(abcde[4]))
def localO(abcde):
intermediate = g(pureTensor([1,abcde[1],abcde[2],1]))
return f(pureTensor(abcde[0]).tensorProduct(intermediate).tensorProduct(abcde[3:]))
