Edit detail for LinearOperator revision 4 of 63

(1) -> <spad>

)abbrev domain LIN LinearOperator
LinearOperator(dim:NonNegativeInteger,K:CommutativeRing): Join(Ring,BiModule(K,K)) with
    arity: % -> DirectProduct(2,NonNegativeInteger)
    elt: (%,%) -> %
    id: ()->%
    inp: List K -> %
    inp: List % -> %
    out: List K -> %
    out: List % -> %
    coerce: SquareMatrix(dim,K) -> %
  == add
    import List NonNegativeInteger
    T == CartesianTensor(1,dim,K)
    Rep == Record(n:NonNegativeInteger, m:NonNegativeInteger, t:T)
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    arity(x:%):DirectProduct(2,NonNegativeInteger) == directProduct [rep(x).n,rep(x).m]
    0 == per [0,0,0]
    (x:% + y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t+rep(y).t]
    (x:% - y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,-rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t-rep(y).t]
    1 == per [0,0,1]
    (x:% * y:%):% ==
      rep(x).n ~= rep(y).n => error "arity"
      r:=product(rep(x).t, rep(y).t)
      u:=1$DirectProduct(dim,K)::T
      ud:=product(u,kroneckerDelta()$T)
      for i in 1..rep(x).n repeat
        --output("rank",rank(r)::OutputForm)$OutputPackage
        --output("n",rep(x).n::OutputForm)$OutputPackage
        r:=contract(contract(ud,1,r,rep(x).n+1),1,rep(x).n+1)
        --output("rank",rank(r)::OutputForm)$OutputPackage
      per [rep(x).n,rep(x).m+rep(y).m,r]
    (x:% + y:%):% ==
      rep(x).m ~= rep(y).m  => error "arity"
      r:=product(rep(x).t, rep(y).t)
      u:=1$DirectProduct(dim,K)::T
      du:=product(kroneckerDelta()$T,u)
      for i in 1..rep(y).m repeat
        --output("rank",rank(r)::OutputForm)$OutputPackage
        --output("m",rep(y).m::OutputForm)$OutputPackage
        r:=contract(contract(du,1,r,rep(y).m+1),1,rep(y).m+1)
        --output("rank",rank(r)::OutputForm)$OutputPackage
      per [rep(x).n+rep(y).m,rep(y).m,r]
    (x:% = y:%):Boolean ==
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      rep(x).t = rep(y).t
    (x:K * y:%):% == per [rep(y).n,rep(y).m,x*rep(y).t]
    (x:% * y:K):% == per [rep(x).n,rep(x).m,rep(x).t*y]
    elt(x:%,y:%):% ==
      r:=product(rep(x).t,rep(y).t)
      yn:=rep(y).n  -- outputs of y
      xm:=rep(x).m  -- inputs of x
      while yn>0 and xm>0 repeat
        output("yn",yn::OutputForm)$OutputPackage
        output("xm",xm::OutputForm)$OutputPackage
        output("rank",rank(r)::OutputForm)$OutputPackage
        r:=contract(r,rep(y).n+xm,yn+rep(y).m)
        yn:=subtractIfCan(yn,1)::NonNegativeInteger
        xm:=subtractIfCan(xm,1)::NonNegativeInteger
      per [rep(x).n+xm,yn+rep(y).m,r]
    id():% == per [1,1,1]
    inp(x:List K):% == per [1,0,entries(x)::T]
    inp(x:List %):% ==
      #removeDuplicates([rep(y).n for y in x])~=1 or
        #removeDuplicates([rep(y).m for y in x])~=1 => error "arity"
      per [rep(first x).n+1,rep(first x).m,[rep(y).t for y in x]::T]$Rep
    out(x:List K):% == per [0,1,entries(x)::T]
    out(x:List %):% ==
      #removeDuplicates([rep(y).n for y in x])~=1 or
        #removeDuplicates([rep(y).m for y in x])~=1 => error "arity"
      per [rep(first x).n,rep(first x).m+1,[rep(y).t for y in x]::T]$Rep
    coerce(x:%):OutputForm == (rep(x).t)::OutputForm</spad>

Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/3626382297542132014-25px001.spad
      using old system compiler.
   LIN abbreviates domain LinearOperator 
------------------------------------------------------------------------
   initializing NRLIB LIN for LinearOperator 
   compiling into NRLIB LIN 
   importing List NonNegativeInteger
************* USER ERROR **********
available signatures for T$: 
    NONE
NEED T$: () -> ?
****** comp fails at level 1 with expression: ******
((DEF (T$) (NIL) (|CartesianTensor| 1 |dim| K)))
****** level 1  ******
x:= (DEF (T$) (NIL) (CartesianTensor (One) dim K))
m:= $EmptyMode
f:=
((((|#| #) (< #) (<= #) (= #) ...)))

   >> Apparent user error:
   unspecified error

L:=LIN(2,FRAC POLY INT)

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

XX1:=X1*X1

(1)

arity(XX1)

   There are 1 exposed and 0 unexposed library operations named arity 
      having 1 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                              )display op arity
      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 arity
      with argument type(s) 
                             Polynomial(Integer)

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

YY1:=Y1*Y1

(2)

arity(YY1)

   There are 1 exposed and 0 unexposed library operations named arity 
      having 1 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                              )display op arity
      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 arity
      with argument type(s) 
                             Polynomial(Integer)

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

Y1X1:=Y1*X1

(3)

arity(Y1X1)

   There are 1 exposed and 0 unexposed library operations named arity 
      having 1 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                              )display op arity
      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 arity
      with argument type(s) 
                             Polynomial(Integer)

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

XY11:=X1 Y1

   There are no library operations named X1 
      Use HyperDoc Browse or issue
                                 )what op X1
      to learn if there is any operation containing " X1 " in its name.

   Cannot find a definition or applicable library operation named X1 
      with argument type(s) 
                                Variable(Y1)

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