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

SandBoxLinearOperator
  
last edited 2 years ago by Bill Page

Edit detail for SandBoxLinearOperator revision 12 of 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Editor: Bill Page
Time: 2011/05/06 10:06:06 GMT-7
Note: rename LOP 
changed:
-)lib CARTEN MONAL PROP LIN
)lib CARTEN MONAL PROP

changed:
-)abbrev domain LAZY LazyLinearOperator
-LazyLinearOperator(dim:NNI,gener:OrderedFinite,K:Field): Exports == Implementation where
)abbrev domain LOP LinearOperator
LinearOperator(gener:OrderedFinite,K:Field): Exports == Implementation where

added:
    dim:NNI := size()$gener

changed:
-L := LAZY(2,OVAR [],EXPR INT)
L := LOP(OVAR ['1,'2],EXPR INT)

added:
-- trace
U:L:=ev(1)
Ω:L:=co(1)
Ω/U

axiom
)lib CARTEN MONAL PROP

   CartesianTensor is now explicitly exposed in frame initial 
   CartesianTensor will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/CARTEN.NRLIB/CARTEN
   Monoidal is now explicitly exposed in frame initial 
   Monoidal will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/MONAL.NRLIB/MONAL
   Prop is now explicitly exposed in frame initial 
   Prop will be automatically loaded when needed from 
      /var/zope2/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
    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/zope2/var/LatexWiki/7884152482127964550-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 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.18 SEC.

   compiling local per : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> $
      LOP;per is replaced by x 
Time: 0.01 SEC.

   compiling exported dimension : () -> CardinalNumber
Time: 0 SEC.

   compiling exported dom : $ -> NonNegativeInteger
Time: 0.02 SEC.

   compiling exported cod : $ -> NonNegativeInteger
Time: 0.02 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.07 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.02 SEC.

   compiling local dat : $ -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
Time: 0.01 SEC.

   compiling exported arity : $ -> Prop $
Time: 0.01 SEC.

   compiling exported eval : $ -> $
Time: 0 SEC.

   compiling exported retractIfCan : $ -> Union(K,failed)
Time: 0.02 SEC.

   compiling exported retract : $ -> K
Time: 0.12 SEC.

   compiling exported basisOut : () -> List $
Time: 0.02 SEC.

   compiling exported basisIn : () -> List $
Time: 0.02 SEC.

   compiling exported ev : PositiveInteger -> $
Time: 0.08 SEC.

   compiling exported co : PositiveInteger -> $
Time: 0.01 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.01 SEC.

   compiling exported ravel : $ -> List K
Time: 0.01 SEC.

   compiling exported unravel : (Prop $,List K) -> $
Time: 0.02 SEC.

   compiling exported tensor : $ -> CartesianTensor(One,dim,K)
Time: 0.01 SEC.

   compiling exported + : ($,$) -> $
Time: 0.02 SEC.

   compiling exported - : ($,$) -> $
Time: 0.03 SEC.

   compiling exported - : $ -> $
Time: 0 SEC.

   compiling exported Zero : () -> $
Time: 0.01 SEC.

   compiling exported zero? : $ -> Boolean
Time: 0.18 SEC.

   compiling exported One : () -> $
Time: 0.01 SEC.

   compiling exported one? : $ -> Boolean
Time: 0 SEC.

   compiling exported = : ($,$) -> Boolean
Time: 0.01 SEC.

   compiling exported coerce : List PositiveInteger -> $
Time: 0.05 SEC.

   compiling exported coerce : List None -> $
Time: 0.01 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.01 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.03 SEC.

   compiling local trailI : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger
Time: 0.02 SEC.

   compiling exported / : ($,$) -> $
Time: 1.96 SEC.

   compiling exported / : (Tuple $,$) -> $
Time: 0.04 SEC.

   compiling exported / : ($,Tuple $) -> $
Time: 0 SEC.

   compiling exported / : (Tuple $,Tuple $) -> $
Time: 0.08 SEC.

   compiling exported * : (K,$) -> $
Time: 0.01 SEC.

   compiling exported * : ($,K) -> $
Time: 0 SEC.

   compiling exported * : (Integer,$) -> $
Time: 0 SEC.

   compiling local show : $ -> OutputForm
Time: 0.08 SEC.

   compiling exported coerce : $ -> OutputForm
Time: 0.04 SEC.

****** Domain: K already in scope
augmenting K: (Evalable K)
(time taken in buildFunctor:  10)

;;;     ***       |LinearOperator| REDEFINED

;;;     ***       |LinearOperator| REDEFINED
Time: 0.02 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: 3.29 seconds

   finalizing NRLIB LOP 
   Processing LinearOperator for Browser database:
--->-->LinearOperator((arity ((Prop %) %))): Not documented!!!!
--->-->LinearOperator((basisOut ((List %)))): Not documented!!!!
--->-->LinearOperator((basisIn ((List %)))): Not documented!!!!
--->-->LinearOperator((tensor (T$ %))): 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 NAT)))---------
--->-->LinearOperator((coerce (% (List NAT)))): 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 (% % NAT))): Not documented!!!!
--->-->LinearOperator((elt (% % NAT NAT))): Not documented!!!!
--->-->LinearOperator((elt (% % NAT NAT NAT))): 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 (% NAT))---------
--->-->LinearOperator((ev (% NAT))): Improper first word in comments: 
"(2,{}0)-tensor for evaluation"
--------(co (% NAT))---------
--->-->LinearOperator((co (% NAT))): Improper first word in comments: 
"(0,{}2)-tensor for co-evaluation"
--->-->LinearOperator(constructor): Not documented!!!!
--->-->LinearOperator(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/LOP.NRLIB/LOP.lsp" (written 15 MAY 2011 11:22:49 AM):

; /var/zope2/var/LatexWiki/LOP.NRLIB/LOP.fasl written
; compilation finished in 0:00:07.530
------------------------------------------------------------------------
   LinearOperator is now explicitly exposed in frame initial 
   LinearOperator will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/LOP.NRLIB/LOP

   >> System error:
   The bounding indices 163 and 162 are bad for a sequence of length 162.
See also:
  The ANSI Standard, Glossary entry for "bounding index designator"
  The ANSI Standard, writeup for Issue SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR

Tests

axiom
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
axiom
dimension()$L
\label{eq2}2(2)
Type: CardinalNumber?
axiom
macro Σ(f,i,b) == reduce(+,[f*b.i for i in 1..#b])
Type: Void
axiom
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))
axiom
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))
axiom
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))
axiom
I:L := [1]
\label{eq6}{|_{1}^{1}}+{|_{2}^{2}}(6)
Type: LinearOperator?(OrderedVariableList?([1,2]),Expression(Integer))
axiom
test( I*I = [1,2] )
\label{eq7} \mbox{\rm true} (7)
Type: Boolean
axiom
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))
axiom
-- 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))
axiom
-- 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))
axiom
test(B3/B3/B3 = I*I*I)
\label{eq11} \mbox{\rm true} (11)
Type: Boolean
axiom
-- 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))
axiom
-- trace
U:L:=ev(1)
\label{eq13}{|_{\ }^{1 \ 1}}+{|_{\ }^{2 \ 2}}(13)
Type: LinearOperator?(OrderedVariableList?([1,2]),Expression(Integer))
axiom
Ω:L:=co(1)
\label{eq14}{|_{1 \ 1}}+{|_{2 \ 2}}(14)
Type: LinearOperator?(OrderedVariableList?([1,2]),Expression(Integer))
axiom
Ω/U
\label{eq15}2(15)
Type: LinearOperator?(OrderedVariableList?([1,2]),Expression(Integer))

Various special cases of composition

axiom
-- case 1
test( X/X = [1,2] )
\label{eq16} \mbox{\rm true} (16)
Type: Boolean
axiom
test( (I*X)/(I*X) = [1,2,3] )
\label{eq17} \mbox{\rm true} (17)
Type: Boolean
axiom
test( (I*X*I)/(I*X*I) = [1,2,3,4] )
\label{eq18} \mbox{\rm true} (18)
Type: Boolean
axiom
-- case 2
test( (X*I*I)/(X*X) = [1,2,4,3] )
\label{eq19} \mbox{\rm true} (19)
Type: Boolean
axiom
-- case 3
test( (X*X)/(X*I*I) = [1,2,4,3] )
\label{eq20} \mbox{\rm true} (20)
Type: Boolean
axiom
-- case 4
test ( (I*I*X)/(X*X) = [2,1,3,4] )
\label{eq21} \mbox{\rm true} (21)
Type: Boolean
axiom
-- case 5
test( (I*X*I)/(X*X) = [3,1,4,2] )
\label{eq22} \mbox{\rm true} (22)
Type: Boolean
axiom
-- case 6
test( (I*I*X)/(X*I*I)=[2,1,4,3] )
\label{eq23} \mbox{\rm true} (23)
Type: Boolean
axiom
test( (I*X)/(X*I) = [3,1,2] )
\label{eq24} \mbox{\rm true} (24)
Type: Boolean
axiom
test( (I*X*I)/(X*I*I)=[3,1,2,4] )
\label{eq25} \mbox{\rm true} (25)
Type: Boolean
axiom
-- case 7
test( (X*X)/(I*I*X) = [2,1,3,4] )
\label{eq26} \mbox{\rm true} (26)
Type: Boolean
axiom
-- case 8
test( (X*I)/(I*X) = [2,3,1] )
\label{eq27} \mbox{\rm true} (27)
Type: Boolean
axiom
-- case 9
test( (X*X)/(I*X*I) = [2,4,1,3] )
\label{eq28} \mbox{\rm true} (28)
Type: Boolean