login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit

fricas
)lib CARTEN MONAL PROP
CartesianTensor is now explicitly exposed in frame initial CartesianTensor will be automatically loaded when needed from /var/aw/var/LatexWiki/CARTEN.NRLIB/CARTEN Monoidal is now explicitly exposed in frame initial Monoidal will be automatically loaded when needed from /var/aw/var/LatexWiki/MONAL.NRLIB/MONAL Prop is now explicitly exposed in frame initial Prop will be automatically loaded when needed from /var/aw/var/LatexWiki/PROP.NRLIB/PROP

spad
)abbrev domain LOP LinearOperator
LinearOperator(gener:OrderedFinite,K:Field): Exports == Implementation where
  NNI ==> NonNegativeInteger
  NAT ==> PositiveInteger
  T ==> CartesianTensor(1,dim,K)
Exports ==> Join(Ring, VectorSpace K, Monoidal NNI, RetractableTo K) with arity: % -> Prop % basisOut: () -> List % basisIn: () -> List % tensor: % -> T I : () -> % map: (K->K,%) -> % if K has Evalable(K) then Evalable(K) eval: % -> % ravel: % -> List K unravel: (Prop %,List K) -> % coerce:(x:List NAT) -> % ++ identity for composition and permutations of its products coerce:(x:List None) -> % ++ [] = 1 elt: (%,%) -> % elt: (%,NAT) -> % elt: (%,NAT,NAT) -> % elt: (%,NAT,NAT,NAT) -> % _/: (Tuple %,Tuple %) -> % _/: (Tuple %,%) -> % _/: (%,Tuple %) -> % ++ yet another syntax for product ev: NAT -> % ++ (2,0)-tensor for evaluation co: NAT -> % ++ (0,2)-tensor for co-evaluation
Implementation ==> add import List NNI import NAT L ==> Record(domain:NNI, codomain:NNI, data:T) -- FreeMonoid provides unevaluated products Rep ==> FreeMonoid L RR ==> Record(gen:L,exp:NNI) rep(x:%):Rep == x pretend Rep per(x:Rep):% == x pretend %
dim:NNI := size()$gener dimension():CardinalNumber == coerce dim
-- Prop (arity) dom(f:%):NNI == r:NNI := 0 for y in factors(rep f) repeat r:=r+(y.gen.domain)*(y.exp) return r cod(f:%):NNI == r:NNI := 0 for y in factors(rep f) repeat r:=r+(y.gen.codomain)*(y.exp) return r
prod(f:L,g:L):L == r:T := product(f.data,g.data) -- dom(f) + cod(f) + dom(g) + cod(g) p:List Integer := concat _ [[i for i in 1..(f.domain)], _ [(f.domain)+(f.codomain)+i for i in 1..(g.domain)], _ [(f.domain)+i for i in 1..(f.codomain)], _ [(f.domain)+(g.domain)+(f.codomain)+i for i in 1..(g.codomain)]] -- dom(f) + dom(g) + cod(f) + cod(g) --output("prod p = ",p::OutputForm)$OutputPackage [(f.domain)+(g.domain),(f.codomain)+(g.codomain),reindex(r,p)]
dats(fs:List RR):L == r:L := [0,0,1$T] for y in fs repeat t:L:=y.gen for n in 1..y.exp repeat r:=prod(r,t) return r
dat(f:%):L == dats factors rep f
arity(f:%):Prop % == f::Prop %
eval(f:%):% == per coerce dat(f)
retractIfCan(f:%):Union(K,"failed") == dom(f)=0 and cod(f)=0 => retract(dat(f).data)$T return "failed" retract(f:%):K == dom(f)=0 and cod(f)=0 => retract(dat(f).data)$T error "failed"
-- basis basisOut():List % == [per coerce [0,1,entries(row(1,i)$SquareMatrix(dim,K))::T] for i in 1..dim] basisIn():List % == [per coerce [1,0,entries(row(1,i)$SquareMatrix(dim,K))::T] for i in 1..dim] ev(n:NAT):% == reduce(_+,[ dx^n * dx^n for dx in basisIn()])$List(%) -- dx:= basisIn() -- reduce(_+,[ (dx.i)^n * (dx.i)^n for i in 1..dim]) co(n:NAT):% == reduce(_+,[ Dx^n * Dx^n for Dx in basisOut()])$List(%) -- Dx:= basisOut() -- reduce(_+,[ (Dx.i)^n * (Dx.i)^n for i in 1..dim])
-- manipulation map(f:K->K, g:%):% == per coerce [dom g,cod g,unravel(map(f,ravel dat(g).data))$T] if K has Evalable(K) then eval(g:%,f:List Equation K):% == map((x:K):K+->eval(x,f),g) ravel(g:%):List K == ravel dat(g).data unravel(p:Prop %,r:List K):% == dim^(dom(p)+cod(p)) ~= #r => error "failed" per coerce [dom(p),cod(p),unravel(r)$T] tensor(x:%):T == dat(x).data
-- sum (f:% + g:%):% == dat(f).data=0 => g dat(g).data=0 => f dom(f) ~= dom(g) or cod(f) ~= cod(g) => error "arity" per coerce [dom f,cod f,dat(f).data+dat(g).data]
(f:% - g:%):% == dat(f).data=0 => g dat(g).data=0 => f dom(f) ~= dom(f) or cod(g) ~= cod(g) => error "arity" per coerce [dom f, cod f,dat(f).data-dat(g).data]
_-(f:%):% == per coerce [dom f, cod f,-dat(f).data]
-- identity for sum (trivial zero map) 0 == per coerce [0,0,0] zero?(f:%):Boolean == dat(f).data = 0 * dat(f).data -- identity for product 1:% == per 1 one?(f:%):Boolean == one? rep f -- identity for composition I == per coerce [1,1,kroneckerDelta()$T] (x:% = y:%):Boolean == rep eval x = rep eval y
-- permutations and identities coerce(p:List NAT):% == r:=I^#p #p = 1 and p.1 = 1 => return r p1:List Integer:=[i for i in 1..#p] p2:List Integer:=[#p+i for i in p] p3:=concat(p1,p2) --output("coerce p3 = ",p3::OutputForm)$OutputPackage per coerce [#p,#p,reindex(dat(r).data,p3)] coerce(p:List None):% == per coerce [0,0,1] coerce(x:K):% == 1*x
-- tensor product elt(f:%,g:%):% == f * g elt(f:%,g:NAT):% == f * I^g elt(f:%,g1:NAT,g2:NAT):% == f * [g1 @ NAT,g2 @ NAT]::List NAT::% elt(f:%,g1:NAT,g2:NAT,g3:NAT):% == f * [g1 @ NAT,g2 @ NAT,g3 @ NAT]::List NAT::% apply(f:%,g:%):% == f * g (f:% * g:%):% == per (rep f * rep g)
leadI(x:Rep):NNI == r:=hclf(x,rep(I)^size(x)) size(r)=0 => 0 nthExpon(r,1)
trailI(x:Rep):NNI == r:=hcrf(x,rep(I)^size(x)) size(r)=0 => 0 nthExpon(r,1)
-- composition: -- f/g : A^n -> A^p = f:A^n -> A^m / g:A^m -> A^p (ff:% / gg:%):% == g:=gg; f:=ff -- partial application from the left n:=subtractIfCan(cod ff,dom gg) if n case NNI and n>0 then -- apply g on f from the left, pass extra f outputs on the right print(hconcat([message("arity warning: "), _ over(arity(ff)::OutputForm, _ arity(gg)::OutputForm*(arity(I)::OutputForm)^n::OutputForm) ]))$OutputForm g:=gg*I^n m:=subtractIfCan(dom gg, cod ff) -- apply g on f from the left, add extra g inputs on the left if m case NNI and m>0 then print(hconcat([message("arity warning: "), _ over((arity(I)::OutputForm)^m::OutputForm*arity(ff)::OutputForm, _ arity(gg)::OutputForm)]))$OutputForm f:=I^m*ff
-- parallelize composition f/g = (f1/g1)*(f2/g2) if cod(f)>0 then i:Integer:=1 j:Integer:=1 n:NNI:=1 m:NNI:=1 f1 := per coerce nthFactor(rep f,1) g1 := per coerce nthFactor(rep g,1) while cod(f1)~=dom(g1) repeat if cod(f1) < dom(g1) then if n < nthExpon(rep f,i) then n:=n+1 else n:=1 i:=i+1 f1 := f1 * per coerce nthFactor(rep f,i) else if cod(f1) > dom(g1) then if m < nthExpon(rep g,j) then m:=m+1 else n:=1 j:=j+1 g1 := g1 * per coerce nthFactor(rep g,j) f2 := per overlap(rep f1, rep f).rm g2 := per overlap(rep g1,rep g).rm f := f1 g := g1 else f2 := per 1 g2 := per 1
-- factor parallel identites nl := leadI hclf(rep f,rep g) nI := rep(I)^nl f := per overlap(nI,rep f).rm g := per overlap(nI,rep g).rm ln := trailI hcrf(rep f,rep g) In := rep(I)^ln f := per overlap(rep f,In).lm g := per overlap(rep g,In).lm
-- remove leading and trailing identities nf := leadI rep f f := per overlap(rep(I)^nf,rep f).rm ng := leadI rep g g := per overlap(rep(I)^ng,rep g).rm fn := trailI rep f f := per overlap(rep f,rep(I)^fn).lm gn := trailI rep g g := per overlap(rep g,rep(I)^gn).lm
-- Factoring out parallel identities guarantees that: if nf>0 and ng>0 then error "either nf or ng or both must be 0" if fn>0 and gn>0 then error "either fn or gn or both must be 0"
-- Exercise for Reader: -- Prove the following contraction and permutation is correct by -- considering all 9 cases for (nf=0 or ng=0) and (fn=0 or gn=0). -- output("leading [nl,nf,ng] = ",[nl,nf,ng]::OutputForm)$OutputPackage -- output("trailing [ln,fn,gn] = ",[ln,fn,gn]::OutputForm)$OutputPackage r:T := contract(cod(f)-ng-gn, dat(f).data,dom(f)+ng+1, dat(g).data,nf+1) p:List Integer:=concat [ _ [dom(f)+gn+i for i in 1..nf], _ [i for i in 1..dom(f)], _ [dom(f)+nf+ng+i for i in 1..fn], _ [dom(f)+i for i in 1..ng], _ [dom(f)+nf+ng+fn+gn+i for i in 1..cod(g)], _ [dom(f)+ng+i for i in 1..gn] ] --print(p::OutputForm)$OutputForm r:=reindex(r,p)
if f2=1 and g2=1 then return per nI * per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * per In if f2=1 then error "g2 should be 1" if g2=1 then error "f2 should be 1" return per nI * per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * per In * (f2/g2)
-- another notation for composition of products (t:Tuple % / x:%):% == t / construct([x])$PrimitiveArray(%)::Tuple(%) (x:% / t:Tuple %):% == construct([x])$PrimitiveArray(%)::Tuple(%) / t (f:Tuple % / g:Tuple %):% == fs:List % := [select(f,i) for i in 0..length(f)-1] gs:List % := [select(g,i) for i in 0..length(g)-1] fr:=reduce(elt@(%,%)->%,fs,1) gr:=reduce(elt@(%,%)->%,gs,1) fr / gr
(x:K * y:%):% == per coerce [dom y, cod y,x*dat(y).data] (x:% * y:K):% == per coerce [dom x,cod x,dat(x).data*y] (x:Integer * y:%):% == per coerce [dom y,cod y,x*dat(y).data]
-- display operators using basis show(x:%):OutputForm == dom(x)=0 and cod(x)=0 => return (dat(x).data)::OutputForm if size()$gener > 0 then gens:List OutputForm:=[index(i::PositiveInteger)$gener::OutputForm for i in 1..dim] else -- default to numeric indices gens:List OutputForm:=[i::OutputForm for i in 1..dim] -- input basis inps:List OutputForm := [] for i in 1..dom(x) repeat empty? inps => inps:=gens inps:=concat [[(inps.k * gens.j) for j in 1..dim] for k in 1..#inps] -- output basis outs:List OutputForm := [] for i in 1..cod(x) repeat empty? outs => outs:=gens outs:=concat [[(outs.k * gens.j) for j in 1..dim] for k in 1..#outs] -- combine input (superscripts) and/or output(subscripts) to form basis symbols bases:List OutputForm if #inps > 0 and #outs > 0 then bases:=concat([[ scripts(message("|"),[i,j]) for i in outs] for j in inps]) else if #inps > 0 then bases:=[super(message("|"),i) for i in inps] else if #outs > 0 then bases:=[sub(message("|"),j) for j in outs] else bases:List OutputForm:= [] -- merge bases with data to form term list terms:=[(k=1 => base;k::OutputForm*base) for base in bases for k in ravel dat(x).data | k~=0] empty? terms => return 0::OutputForm -- combine the terms return reduce(_+,terms)
coerce(x:%):OutputForm == r:OutputForm := empty() for y in factors(rep x) repeat if y.exp = 1 then if size rep x = 1 then r := show per coerce y.gen else r:=r*paren(list show per coerce y.gen) else r:=r*paren(list show per coerce y.gen)^(y.exp::OutputForm) return r
spad
   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/441813633907872843-25px002.spad
      using old system compiler.
   LOP abbreviates domain LinearOperator 
------------------------------------------------------------------------
   initializing NRLIB LOP for LinearOperator 
   compiling into NRLIB LOP 
   importing List NonNegativeInteger
   importing PositiveInteger
   processing macro definition L ==> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) 
   processing macro definition Rep ==> FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) 
   processing macro definition RR ==> Record(gen: Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),exp: NonNegativeInteger) 
   compiling local rep : $ -> FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
      LOP;rep is replaced by x 
Time: 0.03 SEC.
compiling local per : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> $ LOP;per is replaced by x Time: 0 SEC.
compiling exported dimension : () -> CardinalNumber Time: 0 SEC.
compiling exported dom : $ -> NonNegativeInteger Time: 0 SEC.
compiling exported cod : $ -> NonNegativeInteger Time: 0 SEC.
compiling local prod : (Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))) -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) Time: 0.02 SEC.
compiling local dats : List Record(gen: Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),exp: NonNegativeInteger) -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) Time: 0 SEC.
compiling local dat : $ -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) Time: 0 SEC.
compiling exported arity : $ -> Prop $ Time: 0 SEC.
compiling exported eval : $ -> $ Time: 0 SEC.
compiling exported retractIfCan : $ -> Union(K,failed) Time: 0 SEC.
compiling exported retract : $ -> K Time: 0.01 SEC.
compiling exported basisOut : () -> List $ Time: 0.01 SEC.
compiling exported basisIn : () -> List $ Time: 0.01 SEC.
compiling exported ev : PositiveInteger -> $ Time: 0.02 SEC.
compiling exported co : PositiveInteger -> $ Time: 0 SEC.
compiling exported map : (K -> K,$) -> $ Time: 0.01 SEC.
****** Domain: K already in scope augmenting K: (Evalable K) compiling exported eval : ($,List Equation K) -> $ Time: 0 SEC.
compiling exported ravel : $ -> List K Time: 0 SEC.
compiling exported unravel : (Prop $,List K) -> $ Time: 0.01 SEC.
compiling exported tensor : $ -> CartesianTensor(One,dim,K) Time: 0.01 SEC.
compiling exported + : ($,$) -> $ Time: 0.01 SEC.
compiling exported - : ($,$) -> $ Time: 0.01 SEC.
compiling exported - : $ -> $ Time: 0 SEC.
compiling exported Zero : () -> $ Time: 0 SEC.
compiling exported zero? : $ -> Boolean Time: 0.02 SEC.
compiling exported One : () -> $ Time: 0 SEC.
compiling exported one? : $ -> Boolean Time: 0 SEC.
compiling exported I : () -> $ Time: 0.01 SEC.
compiling exported = : ($,$) -> Boolean Time: 0 SEC.
compiling exported coerce : List PositiveInteger -> $ Time: 0.02 SEC.
compiling exported coerce : List None -> $ Time: 0 SEC.
compiling exported coerce : K -> $ Time: 0.01 SEC.
compiling exported elt : ($,$) -> $ Time: 0 SEC.
compiling exported elt : ($,PositiveInteger) -> $ Time: 0 SEC.
compiling exported elt : ($,PositiveInteger,PositiveInteger) -> $ Time: 0 SEC.
compiling exported elt : ($,PositiveInteger,PositiveInteger,PositiveInteger) -> $ Time: 0 SEC.
compiling exported apply : ($,$) -> $ Time: 0 SEC.
compiling exported * : ($,$) -> $ Time: 0 SEC.
compiling local leadI : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger Time: 0.01 SEC.
compiling local trailI : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger Time: 0.01 SEC.
compiling exported / : ($,$) -> $ Time: 0.33 SEC.
compiling exported / : (Tuple $,$) -> $ Time: 0.01 SEC.
compiling exported / : ($,Tuple $) -> $ Time: 0.01 SEC.
compiling exported / : (Tuple $,Tuple $) -> $ Time: 0 SEC.
compiling exported * : (K,$) -> $ Time: 0 SEC.
compiling exported * : ($,K) -> $ Time: 0.01 SEC.
compiling exported * : (Integer,$) -> $ Time: 0 SEC.
compiling local show : $ -> OutputForm Time: 0.04 SEC.
compiling exported coerce : $ -> OutputForm Time: 0.01 SEC.
****** Domain: K already in scope augmenting K: (Evalable K) (time taken in buildFunctor: 0)
;;; *** |LinearOperator| REDEFINED
;;; *** |LinearOperator| REDEFINED Time: 0.01 SEC.
Warnings: [1] dom: domain has no value [2] cod: codomain has no value [3] /: i has no value [4] /: j has no value
Cumulative Statistics for Constructor LinearOperator Time: 0.65 seconds
finalizing NRLIB LOP Processing LinearOperator for Browser database: --->-->LinearOperator(constructor): Not documented!!!! --->-->LinearOperator((arity ((Prop %) %))): Not documented!!!! --->-->LinearOperator((basisOut ((List %)))): Not documented!!!! --->-->LinearOperator((basisIn ((List %)))): Not documented!!!! --->-->LinearOperator((tensor ((CartesianTensor (One) dim K) %))): Not documented!!!! --->-->LinearOperator((I (%))): Not documented!!!! --->-->LinearOperator((map (% (Mapping K K) %))): Not documented!!!! --->-->LinearOperator((eval (% %))): Not documented!!!! --->-->LinearOperator((ravel ((List K) %))): Not documented!!!! --->-->LinearOperator((unravel (% (Prop %) (List K)))): Not documented!!!! --------(coerce (% (List (PositiveInteger))))--------- --->-->LinearOperator((coerce (% (List (PositiveInteger))))): Improper first word in comments: identity "identity for composition and permutations of its products" --------(coerce (% (List (None))))--------- --->-->LinearOperator((coerce (% (List (None))))): Improper first word in comments: [] "[] = 1" --->-->LinearOperator((elt (% % %))): Not documented!!!! --->-->LinearOperator((elt (% % (PositiveInteger)))): Not documented!!!! --->-->LinearOperator((elt (% % (PositiveInteger) (PositiveInteger)))): Not documented!!!! --->-->LinearOperator((elt (% % (PositiveInteger) (PositiveInteger) (PositiveInteger)))): Not documented!!!! --->-->LinearOperator((/ (% (Tuple %) (Tuple %)))): Not documented!!!! --->-->LinearOperator((/ (% (Tuple %) %))): Not documented!!!! --------(/ (% % (Tuple %)))--------- --->-->LinearOperator((/ (% % (Tuple %)))): Improper first word in comments: yet "yet another syntax for product" --------(ev (% (PositiveInteger)))--------- --->-->LinearOperator((ev (% (PositiveInteger)))): Improper first word in comments: "(2,{}0)-tensor for evaluation" --------(co (% (PositiveInteger)))--------- --->-->LinearOperator((co (% (PositiveInteger)))): Improper first word in comments: "(0,{}2)-tensor for co-evaluation" --->-->LinearOperator(): Missing Description ; compiling file "/var/aw/var/LatexWiki/LOP.NRLIB/LOP.lsp" (written 26 JUL 2013 06:02:52 PM):
; /var/aw/var/LatexWiki/LOP.NRLIB/LOP.fasl written ; compilation finished in 0:00:00.444 ------------------------------------------------------------------------ LinearOperator is now explicitly exposed in frame initial LinearOperator will be automatically loaded when needed from /var/aw/var/LatexWiki/LOP.NRLIB/LOP

Tests

fricas
L := LOP(OVAR ['1,'2],EXPR INT)

\label{eq1}\hbox{\axiomType{LinearOperator}\ } (\hbox{\axiomType{OrderedVariableList}\ } ([ 1, 2 ]) , \hbox{\axiomType{Expression}\ } (\hbox{\axiomType{Integer}\ }))(1)
Type: Type
fricas
dimension()$L

\label{eq2}2(2)
Type: CardinalNumber?
fricas
macro Σ(f,i,b) == reduce(+,[f*b.i for i in 1..#b])
Type: Void
fricas
A:L := Σ( Σ( script(a,[[j],[i]]), i,basisIn()$L), j,basisOut()$L)

\label{eq3}{{a_{1}^{1}}\ {|_{1}^{1}}}+{{a_{2}^{1}}\ {|_{2}^{1}}}+{{a_{1}^{2}}\ {|_{1}^{2}}}+{{a_{2}^{2}}\ {|_{2}^{2}}}(3)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
3*A

\label{eq4}{3 \ {a_{1}^{1}}\ {|_{1}^{1}}}+{3 \ {a_{2}^{1}}\ {|_{2}^{1}}}+{3 \ {a_{1}^{2}}\ {|_{1}^{2}}}+{3 \ {a_{2}^{2}}\ {|_{2}^{2}}}(4)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
A/3

\label{eq5}{{{a_{1}^{1}}\over 3}\ {|_{1}^{1}}}+{{{a_{2}^{1}}\over 3}\ {|_{2}^{1}}}+{{{a_{1}^{2}}\over 3}\ {|_{1}^{2}}}+{{{a_{2}^{2}}\over 3}\ {|_{2}^{2}}}(5)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
I:L := [1]

\label{eq6}{|_{1}^{1}}+{|_{2}^{2}}(6)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
test( I*I = [1,2] )

\label{eq7} \mbox{\rm true} (7)
Type: Boolean
fricas
X:L := [2,1]

\label{eq8}{|_{1 \  1}^{1 \  1}}+{|_{2 \  1}^{1 \  2}}+{|_{1 \  2}^{2 \  1}}+{|_{2 \  2}^{2 \  2}}(8)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- printing
I*X*X*I

\label{eq9}\ {\left({{|_{1}^{1}}+{|_{2}^{2}}}\right)}\ {{\left({{|_{1 \  1}^{1 \  1}}+{|_{2 \  1}^{1 \  2}}+{|_{1 \  2}^{2 \  1}}+{|_{2 \  2}^{2 \  2}}}\right)}^{2}}\ {\left({{|_{1}^{1}}+{|_{2}^{2}}}\right)}(9)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- braid
B3:=(I*X)/(X*I)

\label{eq10}\begin{array}{@{}l}
\displaystyle
{|_{1 \  1 \  1}^{1 \  1 \  1}}+{|_{2 \  1 \  1}^{1 \  1 \  2}}+{|_{1 \  1 \  2}^{1 \  2 \  1}}+{|_{2 \  1 \  2}^{1 \  2 \  2}}+ 
\
\
\displaystyle
{|_{1 \  2 \  1}^{2 \  1 \  1}}+{|_{2 \  2 \  1}^{2 \  1 \  2}}+{|_{1 \  2 \  2}^{2 \  2 \  1}}+{|_{2 \  2 \  2}^{2 \  2 \  2}}
(10)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
test(B3/B3/B3 = I*I*I)

\label{eq11} \mbox{\rm true} (11)
Type: Boolean
fricas
-- parallel
(X*X)/(X*X)

\label{eq12}\ {{\left({{|_{1 \  1}^{1 \  1}}+{|_{1 \  2}^{1 \  2}}+{|_{2 \  1}^{2 \  1}}+{|_{2 \  2}^{2 \  2}}}\right)}^{2}}(12)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- trace
U:L:=ev(1)

\label{eq13}{|_{\ }^{1 \  1}}+{|_{\ }^{2 \  2}}(13)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
Ω:L:=co(1)

\label{eq14}{|_{1 \  1}}+{|_{2 \  2}}(14)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
Ω/U

\label{eq15}2(15)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))

Various special cases of composition

fricas
-- case 1
test( X/X = [1,2] )

\label{eq16} \mbox{\rm true} (16)
Type: Boolean
fricas
test( (I*X)/(I*X) = [1,2,3] )

\label{eq17} \mbox{\rm true} (17)
Type: Boolean
fricas
test( (I*X*I)/(I*X*I) = [1,2,3,4] )

\label{eq18} \mbox{\rm true} (18)
Type: Boolean
fricas
-- case 2
test( (X*I*I)/(X*X) = [1,2,4,3] )

\label{eq19} \mbox{\rm true} (19)
Type: Boolean
fricas
-- case 3
test( (X*X)/(X*I*I) = [1,2,4,3] )

\label{eq20} \mbox{\rm true} (20)
Type: Boolean
fricas
-- case 4
test ( (I*I*X)/(X*X) = [2,1,3,4] )

\label{eq21} \mbox{\rm true} (21)
Type: Boolean
fricas
-- case 5
test( (I*X*I)/(X*X) = [3,1,4,2] )

\label{eq22} \mbox{\rm true} (22)
Type: Boolean
fricas
-- case 6
test( (I*I*X)/(X*I*I)=[2,1,4,3] )

\label{eq23} \mbox{\rm true} (23)
Type: Boolean
fricas
test( (I*X)/(X*I) = [3,1,2] )

\label{eq24} \mbox{\rm true} (24)
Type: Boolean
fricas
test( (I*X*I)/(X*I*I)=[3,1,2,4] )

\label{eq25} \mbox{\rm true} (25)
Type: Boolean
fricas
-- case 7
test( (X*X)/(I*I*X) = [2,1,3,4] )

\label{eq26} \mbox{\rm true} (26)
Type: Boolean
fricas
-- case 8
test( (X*I)/(I*X) = [2,3,1] )

\label{eq27} \mbox{\rm true} (27)
Type: Boolean
fricas
-- case 9
test( (X*X)/(I*X*I) = [2,4,1,3] )

\label{eq28} \mbox{\rm true} (28)
Type: Boolean




  Subject:   Be Bold !!
  ( 13 subscribers )  
Please rate this page: