Edit detail for SandBoxLinearOperator revision 6 of 15

(1) -> )lib CARTEN MONAL PROP LIN

   )library cannot find the file LIN.
   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

)abbrev domain LAZY LazyLinearOperator
LazyLinearOperator(dim:NNI,gener:OrderedFinite,K:CommutativeRing): Exports == Implementation where
  NNI ==> NonNegativeInteger
  NAT ==> PositiveInteger
  T ==> CartesianTensor(1,dim,K)

  Exports ==> Join(Ring, BiModule(K,K), Monoidal NNI, RetractableTo K) with
    inp: List K -> %
      ++ incoming vector
    inp: List % -> %
    out: List K -> %
      ++ output vector
    out: List % -> %
    arity: % -> Prop %
    basisVectors: () -> List %
    basisForms: () -> 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 %

    -- 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)
      [(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
    basisVectors():List % == [per coerce [0,1,entries(row(1,i)$SquareMatrix(dim,K))::T] for i in 1..dim]
    basisForms():List % == [per coerce [1,0,entries(row(1,i)$SquareMatrix(dim,K))::T] for i in 1..dim]
    ev(n:NAT):% ==
      dx:= basisForms()
      reduce(_+,[ (dx.i)^n * (dx.i)^n for i in 1..dim])
    co(n:NAT):% == 
      Dx:= basisVectors()
      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]

    -- repeated sum (inherit from Ring)
    --(p:NNI * f:%):% ==
    --  p=1 => f
    --  q:=subtractIfCan(p,1)
    --  q case NNI => q*f + f
    --  -- zero map (non-trivial)
    --  per coerce [dom f,cod f,0*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 coerce [0,0,1]
    1:% == per 1
    one?(f:%):Boolean == dat(f).data = 1$T
    -- 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)
      per coerce [#p,#p,reindex(dat(r).data,p3)]
    coerce(p:List None):% == per coerce [0,0,1]
    coerce(x:K):% == 1*x

    -- 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:%):% ==
      --one? f => g
      --one? g => f
      per (rep f * rep g)

    -- repeated product (inherit from Monoid)
    --(f:% ^ p:NNI):% == per rep(f)^p
    --  p=1 => f
    --  q:=subtractIfCan(p,1)
    --  q case NNI => f^q * f
    --  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

      -- optimize leading and trailing identities
      I1 := rep(I)^cod(f)

      nI := hclf(hclf(rep f,rep g),I1)
      nl := nthExpon(nI,1)
      f := per overlap(nI,rep f).rm
      g := per overlap(nI,rep g).rm

      In := hcrf(hcrf(rep f,rep g),I1)
      ln := nthExpon(In,1)
      f := per overlap(rep f,In).lm
      g := per overlap(rep g,In).lm

      nf:=nthExpon(hclf(rep f,I1),1)
      ng:=nthExpon(hclf(rep g,I1),1)
      fn:=nthExpon(hcrf(rep f,I1),1)
      gn:=nthExpon(hcrf(rep g,I1),1)

      if nf>0 and ng>0 then error "either nf or ng or both must be 0"
      output("leading [nl,nf,ng] = ",[nl,nf,ng]::OutputForm)$OutputPackage

      if fn>0 and gn>0 then error "either fn or gn or both must be 0"
      output("trailing [ln,fn,gn] = ",[ln,fn,gn]::OutputForm)$OutputPackage

      -- debugging to defeat optimizations
      --nf:=0; ng:=0
      --fn:=0; gn:=0
      --l1:=0; t1:=0

      if nf=0 and ng=0 then
        if fn=0 and gn=0 then
          output("case 1: no leading and no trailing input or output")$OutputPackage
          f1:Integer:=dom(f)+1
          r:T := contract(cod(f), dat(f).data,f1, dat(g).data,1)
          -- no need to reindex
        else if fn>0 then 
          output("case 2: trailing input, fn=", fn::OutputForm)$OutputPackage
          f1:Integer:=dom(f)+1
          r:T := contract(cod(f), dat(f).data,f1, dat(g).data,1)
          -- no need to reindex
        else
          output("case 3: trailing output, gn=", gn::OutputForm)$OutputPackage
          f1:Integer:=dom(f)+1
          r:T := contract(dom(g), dat(f).data,f1, dat(g).data,1)
          -- all f'f inputs then f's extra outputs after g's outputs
          p:List Integer:=concat [ _
            [i for i in 1..dom(f)], _
            [dom(f)+gn+i for i in 1..cod(g)], _
            [dom(f)+i for i in 1..gn] ]
          print(p::OutputForm)$OutputForm
          r:=reindex(r,p)
      else
        if nf>0 then
          if fn=0 and gn=0 then
            output("case 4: leading input, nf=", nf::OutputForm)$OutputPackage
            r:T := contract(cod(f), dat(f).data,dom(f)+1, dat(g).data,nf+1)
            -- g's extra inputs before f's then all g's outputs
            p:List Integer:=concat [ _
              [dom(f)+i for i in 1..nf], _
              [i for i in 1..dom(f)], _
              [nf+dom(f)+i for i in 1..cod(g)] ]
            print(p::OutputForm)$OutputForm
            r:=reindex(r,p)
          else if fn>0 then
            output("case 5: leading input and trailing input, [nf,fn]=", [nf,fn]::OutputForm)$OutputPackage
            f1:Integer:=dom(f)+1
            r:T := contract(cod(f), dat(f).data,f1, dat(g).data,nf+1)
            p:List Integer:=concat [ _
              [dom(f)+i for i in 1..nf], _
              [i for i in 1..dom(f)], _
              [dom(f)+nf+i for i in 1..fn], _
              [dom(f)+nf+fn+i for i in 1..cod(g)] ]
            print(p::OutputForm)$OutputForm
            r:=reindex(r,p)
          else
            output("case 6: leading input and trailing output, [nf,gn]=", [nf,gn]::OutputForm)$OutputPackage
            f1:Integer:=dom(f)+1
            r:T := contract(cod(f)-gn, dat(f).data,f1, dat(g).data,nf+1)
            -- g's extra inputs before f's inputs, f's extra outputs after g's outputs
            p:List Integer:=concat [ _
              [dom(f)+gn+i for i in 1..nf], _
              [i for i in 1..dom(f)], _
              [dom(f)+nf+gn+i for i in 1..cod(g)], _
              [dom(f)+i for i in 1..gn] ]
            print(p::OutputForm)$OutputForm
            r:=reindex(r,p)
        else
          if fn=0 and gn=0 then
            output("case 7: leading output, ng=", ng::OutputForm)$OutputPackage
            f1:Integer:=dom(f)+1
            r:T := contract(dom(g), dat(f).data,f1+ng, dat(g).data,1)
            -- no need to reindex
          else if fn>0 then
            output("case 8: leading output and trailing input, [ng,fn]=", [ng,fn]::OutputForm)$OutputPackage
            f1:Integer:=dom(f)+1
            r:T := contract(cod(f)-ng, dat(f).data,f1+ng, dat(g).data,1)
            p:List Integer:=concat [ _
              [i for i in 1..dom(f)], _
              [dom(f)+ng+i for i in 1..fn], _
              [dom(f)+i for i in 1..ng], _
              [dom(f)+ng+fn+i for i in 1..cod(g)] ]
            print(p::OutputForm)$OutputForm
            r:=reindex(r,p)
          else
            output("case 9: leading output and trailing output, [ng,gn]::OutputForm")$OutputPackage
            f1:Integer:=dom(f)+1
            r:T := contract(dom(g), dat(f).data,f1+ng, dat(g).data,1)
            p:List Integer:=concat [ _
              [i for i in 1..dom(f)], _
              [dom(f)+i for i in 1..ng], _
              [dom(f)+ng+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)

      per nI * per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * per In

    -- 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]

    -- constructors
    inp(x:List K):% == per coerce [1,0,entries(x)::T]
    inp(x:List %):% ==
      #removeDuplicates([dom(y) for y in x]) ~= 1 or
        #removeDuplicates([cod(y) for y in x]) ~= 1 => error "arity"
      per coerce [dom(first x)+1, cod(first x), [dat(y).data for y in x]::T]$L
    out(x:List K):% == per coerce [0,1,entries(x)::T]
    out(x:List %):% ==
      #removeDuplicates([dom(y) for y in x])~=1 or
        #removeDuplicates([cod(y) for y in x])~=1 => error "arity"
      per coerce [dom(first x), cod(first x)+1, [dat(y).data for y in x]::T]$L

    -- 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

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/674384337385656402-25px002.spad
      using system compiler.
   LAZY abbreviates domain LazyLinearOperator 
------------------------------------------------------------------------
   initializing NRLIB LAZY for LazyLinearOperator 
   compiling into NRLIB LAZY 
   importing List NonNegativeInteger
   importing PositiveInteger
   processing macro definition L ==> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(1,dim,K)) 
************* USER ERROR **********
available signatures for Rep: 
    NONE
NEED Rep: () -> ?
   Semantic Errors: 
      [1]  OrderedFinite is not a known type

****** comp fails at level 1 with expression: ******
((DEF (|Rep|) (NIL)
  (|FreeMonoid|
   (|Record| (|:| |domain| (|NonNegativeInteger|))
             (|:| |codomain| (|NonNegativeInteger|))
             (|:| |data| (|CartesianTensor| 1 |dim| K))))))
****** level 1  ******
x:= (DEF (Rep) (NIL) (FreeMonoid (Record (: domain (NonNegativeInteger)) (: codomain (NonNegativeInteger)) (: data (CartesianTensor (1) dim K)))))
m:= $EmptyMode
f:=
((((L #) (* #) (+ #) (|1| #) ...)))

   >> Apparent user error:
   unspecified error

Tests

L := LAZY(2,OVAR [],EXPR INT)

   LazyLinearOperator is an unknown constructor and so is unavailable. 
      Did you mean to use -> but type something different instead?

Various special cases of composition

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

   There are 3 exposed and 0 unexposed library operations named 
      equation having 2 argument(s) but none was determined to be 
      applicable. Use HyperDoc Browse, or issue
                            )display op equation
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named 
      equation with argument type(s) 
                        Fraction(Polynomial(Integer))
                            List(PositiveInteger)

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.