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

fricas
(1) -> )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, FramedModule K, Monoidal NNI, RetractableTo K) with dimension: () -> CardinalNumber 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):% == x*1
-- 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 nn:=subtractIfCan(cod ff,dom gg) if nn case NNI and nn>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)^nn::OutputForm) ]))$OutputForm g:=gg*I^nn mm:=subtractIfCan(dom gg, cod ff) -- apply g on f from the left, add extra g inputs on the left if mm case NNI and mm>0 then print(hconcat([message("arity warning: "), _ over((arity(I)::OutputForm)^mm::OutputForm*arity(ff)::OutputForm, _ arity(gg)::OutputForm)]))$OutputForm f:=I^mm*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..#(f)-1] gs:List % := [select(g,i) for i in 0..#(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/5221482899668613588-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.02 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.01 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 SEC.
compiling exported basisOut : () -> List % Time: 0 SEC.
compiling exported basisIn : () -> List % Time: 0 SEC.
compiling exported ev : PositiveInteger -> % Time: 0.01 SEC.
compiling exported co : PositiveInteger -> % Time: 0 SEC.
compiling exported map : (K -> K,%) -> % Time: 0 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 SEC.
compiling exported tensor : % -> CartesianTensor(One,dim,K) Time: 0 SEC.
compiling exported + : (%,%) -> % Time: 0 SEC.
compiling exported - : (%,%) -> % Time: 0 SEC.
compiling exported - : % -> % Time: 0 SEC.
compiling exported Zero : () -> % Time: 0 SEC.
compiling exported zero? : % -> Boolean Time: 0 SEC.
compiling exported One : () -> % Time: 0 SEC.
compiling exported one? : % -> Boolean Time: 0 SEC.
compiling exported I : () -> % Time: 0 SEC.
compiling exported = : (%,%) -> Boolean Time: 0 SEC.
compiling exported coerce : List PositiveInteger -> % Time: 0 SEC.
compiling exported coerce : List None -> % Time: 0 SEC.
compiling exported coerce : K -> % Time: 0 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 SEC.
compiling local trailI : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger Time: 0 SEC.
compiling exported / : (%,%) -> % Time: 0.06 SEC.
compiling exported / : (Tuple %,%) -> % Time: 0 SEC.
compiling exported / : (%,Tuple %) -> % Time: 0 SEC.
compiling exported / : (Tuple %,Tuple %) -> % Time: 0 SEC.
compiling exported * : (K,%) -> % Time: 0 SEC.
compiling exported * : (Integer,%) -> % Time: 0 SEC.
compiling local show : % -> OutputForm Time: 0.01 SEC.
compiling exported coerce : % -> OutputForm Time: 0.02 SEC.
****** Domain: K already in scope augmenting K: (Evalable K) ****** Domain: K already in scope augmenting K: (Finite) ****** Domain: K already in scope augmenting K: (Hashable) (time taken in buildFunctor: 3092)
;;; *** |LinearOperator| REDEFINED
;;; *** |LinearOperator| REDEFINED Time: 0 SEC.
Warnings: [1] dom: gen has no value [2] dom: domain has no value [3] dom: exp has no value [4] cod: gen has no value [5] cod: codomain has no value [6] cod: exp has no value [7] prod: data has no value [8] prod: domain has no value [9] prod: codomain has no value [10] dats: gen has no value [11] dats: exp has no value [12] retractIfCan: data has no value [13] retract: data has no value [14] map: data has no value [15] ravel: data has no value [16] tensor: data has no value [17] +: data has no value [18] -: data has no value [19] zero?: data has no value [20] coerce: data has no value [21] /: i has no value [22] /: j has no value [23] /: data has no value [24] *: data has no value [25] show: data has no value [26] coerce: exp has no value [27] coerce: gen has no value
Cumulative Statistics for Constructor LinearOperator Time: 0.22 seconds
finalizing NRLIB LOP Processing LinearOperator for Browser database: --->-->LinearOperator(constructor): Not documented!!!! --->-->LinearOperator((dimension ((CardinalNumber)))): 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 02 DEC 2024 01:32:31 AM):
; wrote /var/aw/var/LatexWiki/LOP.NRLIB/LOP.fasl ; compilation finished in 0:00:00.552 ------------------------------------------------------------------------ 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}\ } \left({{\hbox{\axiomType{OrderedVariableList}\ } \left({\left[ 1, \: 2 \right]}\right)}, \:{\hbox{\axiomType{Expression}\ } \left({\hbox{\axiomType{Integer}\ }}\right)}}\right)(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
1 - 1 arity warning: ------ 0 1 1 - (-) 0 1

\label{eq5}{3 \ {a_{1}^{1}}\ {|_{1}^{1}}}+{3 \ {a_{2}^{1}}\ {|_{2}^{1}}}+{3 \ {a_{1}^{2}}\ {|_{1}^{2}}}+{3 \ {a_{2}^{2}}\ {|_{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 !!
  ( 15 subscribers )  
Please rate this page: