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 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 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 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 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 __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)
import re
import socket
from replies import reply, find_in_Replies
from Queue import Queue
from algebra import algebra
from weather import weather
import urllib2
from bs4 import BeautifulSoup
user_queue = Queue()
alg = algebra()
# For sending messages to a specified channel
def sendmsg(chan, msg):
global irc
irc.send("PRIVMSG " + chan + " :" + msg + "\n")
# This is a subroutine which help to join a specified channel
def JoinChan(chan):
global irc
irc.send("JOIN " + chan + "\n")
# This is a subroutine which responds to server pings
def ping():
global irc
irc.send("PONG :pingis\n")
