def i_1(tens,alg):
freeAlgebra = algebra()
B1 = tensorAlgebra([alg] * 3)
K1 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(K1,B1)
def i_1Inner(pT):
return pT
return i_1Inner(tens)
def k_1(tens,alg):
freeAlgebra = algebra()
K1 = tensorAlgebra([alg,freeAlgebra,alg])
K0 = tensorAlgebra([alg,alg])
@bimoduleMapDecorator(K1,K0)
def k_1Inner(pT):
assert isinstance(pT,pureTensor)
generator = pT[1]
return pureTensor([generator,1])-pureTensor([1,generator])
return k_1Inner(tens)
def i_3(tens,alg):
freeAlgebra = algebra()
B3 = tensorAlgebra([alg] * 5)
K3 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(K3,B3)
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
return i_3Inner(tens)
def i_2(tens,alg):
freeAlgebra = algebra()
B2 = tensorAlgebra([alg] * 4)
K2 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(K2,B2)
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
return i_2Inner(tens)
def o1(f,g,alg):
B3 = tensorAlgebra([alg] * 5)
@bimoduleMapDecorator(B3,alg)
def localO(abcde):
intermediate = g(pureTensor([1,abcde[2],abcde[3],1]))
return f(abcde[:2].tensorProduct(intermediate).tensorProduct(abcde[4]))
return localO
def m_2(abcd,alg):
B2 = tensorAlgebra([alg]*4)
freeAlgebra = algebra()
K2 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(B2,K2)
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
return m_2Inner(abcd)
def m_1(abc,alg):
K1 = B1 = tensorAlgebra([alg]*3)
@bimoduleMapDecorator(B1,K1)
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
return m_1Inner(abc)
def k_4(tens,alg):
freeAlgebra = algebra()
K4 = K3 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(K4,K3)
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
return k_4Inner(tens)
def b_n(tens,alg):
tens = tens.clean()
if tens == 0:
return 0
else:
for pure in tens:
domain = tensorAlgebra([alg] * len(pure))
codomain = tensorAlgebra([alg] * (len(pure) - 1))
break
@bimoduleMapDecorator(domain,codomain)
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
return b_nInner(tens)
def k_2(tens,alg):
freeAlgebra = algebra()
K1 = K2 = tensorAlgebra([alg,freeAlgebra,alg])
@bimoduleMapDecorator(K2,K1)
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
return k_2Inner(tens)
def __init__(self, alg, basisOfKn, images):
self.codomain = self.algebra = alg
self.basisOfKn = basisOfKn #This is a basis of the intersection space in the free algebra
freeAlgebra = algebra.algebra()
self.domain = tensorAlgebra.tensorAlgebra([alg,freeAlgebra,alg])
vector.vector.__init__(self,images)
