help links subscribe changes refresh edit

	FriCAS Algebra
FreeModule ←	↑	→ QuadraticForm

LinearOperator

last edited 4 years ago by Bill Page

Edit detail for LinearOperator revision 5 of 63

	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
Editor: Bill Page Time: 2011/03/08 16:43:14 GMT-8
Note: documentation and tests

added:
Linear transformations (operators) over n-dimensional cartesian vector spaces oveer a commutative ring $K$. Members of this domain are morphisms $K^n \to K^m$. Products, co-products and composition (grafting) of morphisms is implemented.  Operators are represented internally as tensors.

Operator composition and products can be visualized by directed graphs (read from top to bottom) such as::

      n = 3     inputs

      \  |  /         \  /   /         \              |
       \ | /           \/   /           \            / \
        \|/             \  /           / \          /   \
        / \              \/           /   \         \   /
       /   \              \          /   / \         \ /
      /     \              \        /   /   \         |

      m = 2     outputs

Lines (edges) in the graph represent vectors, nodes represent operators. Horizontal juxtaposition represents product. Vertical juxtaposition represents composition.


added:
      ++ incoming vector

added:
      ++ output vector

added:


added:


added:


added:


added:


added:
    ((x:%)^(p:NonNegativeInteger)):% ==
       q:=subtractIfCan(p,1)
       q case NonNegativeInteger => x^q * x
       1$%


added:

    (x:% ** p:NonNegativeInteger):% ==
      q:=subtractIfCan(p,1)
      q case NonNegativeInteger => x**q + x
      0$%


added:


added:


added:


changed:
-    id():% == per [1,1,1]

    id():% == per [1,1,kroneckerDelta()$T]


added:


added:


added:


added:


added:
Construction operators: input and output

changed:
-X1:L:=inp[script(x,[[i]]) for i in 1..2]
-arity X1
-Y1:L:=out[script(y,[[],[i]]) for i in 1..2]
-arity Y1
-Y11:L:=inp[Y1,Y1]
-arity(Y11)
-\end{axiom}
-
-\begin{axiom}
-XX1:=X1*X1
-arity(XX1)
-\end{axiom}
-\begin{axiom}
-YY1:=Y1*Y1
-arity(YY1)
-\end{axiom}
-\begin{axiom}
-Y1X1:=Y1*X1
-arity(Y1X1)
-\end{axiom}
-
-\begin{axiom}
-XY11:=X1 Y1
-arity(XY11)
-YX11:= Y1 X1
-arity(YX11)
A1:L:=inp[script(a,[[1,i]]) for i in 1..2]
arity A1
A2:L:=inp[script(a,[[2,i]]) for i in 1..2]
A:L:=inp[A1,A2]
arity A
B1:L:=out[script(b,[[],[1,i]]) for i in 1..2]
arity B1
B2:L:=out[script(b,[[],[2,i]]) for i in 1..2]
B:L:=out[B1,B2]
arity B
\end{axiom}

Powers
\begin{axiom}
A3p:=(A1*A1)*A1
arity(A3p)
test(A3p=A1*(A1*A1))
test(A3p=A1^3)
\end{axiom}

\begin{axiom}
B3p:=(B1*B1)*B1
arity(B3p)
test(B3p=B1*(B1*B1))
test(B3p=B1^3)
\end{axiom}

Sums
\begin{axiom}
A3s:=(A1+A1)+A1
arity(A3s)
test(A3s=A1*(A1*A1))
test(A3s=A1^3)
\end{axiom}

\begin{axiom}
B3s:=(B1+B1)+B1
arity(B3s)
test(B3s=B1*(B1*B1))
test(B3s=B1^3)
\end{axiom}

Expected error
\begin{axiom}
B1A1:=B1*A1
arity(B1A1)
\end{axiom}

Composition
\begin{axiom}
AB11:=A1 B1
arity(AB11)
BA11:= B1 A1
arity(BA11)
AB := A B
arity(AB)
BA := B A
arity(BA)

changed:
-arity(X2)
-XX21:=X2 X1
-arity(XX21)
XB21:=X2 B1
arity(XB21)

removed:
-arity(Y2)

added:
\end{axiom}

Multiple inputs and outputs
\begin{axiom}

changed:
-WX1:=W X1
-arity(WX1)
-\end{axiom}
WB1:=W B1
arity(WB1)
\end{axiom}

Linear transformations (operators) over n-dimensional cartesian vector spaces oveer a commutative ring . Members of this domain are morphisms $K^n \to K^m$ . Products, co-products and composition (grafting) of morphisms is implemented. Operators are represented internally as tensors.

Operator composition and products can be visualized by directed graphs (read from top to bottom) such as:

      n = 3     inputs

      \  |  /         \  /   /         \              |
       \ | /           \/   /           \            / \
        \|/             \  /           / \          /   \
        / \              \/           /   \         \   /
       /   \              \          /   / \         \ /
      /     \              \        /   /   \         |

      m = 2     outputs

Lines (edges) in the graph represent vectors, nodes represent operators. Horizontal juxtaposition represents product. Vertical juxtaposition represents composition.

fricas

(1) -> <spad>

fricas

)abbrev domain LIN LinearOperator
LinearOperator(dim:NonNegativeInteger,K:CommutativeRing): Join(Ring,BiModule(K,K)) with
    arity: % -> DirectProduct(2,NonNegativeInteger)
    elt: (%,%) -> %
    id: ()->%
    inp: List K -> %
      ++ incoming vector
    inp: List % -> %
    out: List K -> %
      ++ output vector
    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:%)^(p:NonNegativeInteger)):% ==
       q:=subtractIfCan(p,1)
       q case NonNegativeInteger => x^q * x
       1$%

    (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:% ** p:NonNegativeInteger):% ==
      q:=subtractIfCan(p,1)
      q case NonNegativeInteger => x**q + x
      0$%

    (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,kroneckerDelta()$T]

    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>

fricas

Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/74143022208027506-25px001.spad
      using 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 (1) dim K))
m:= $EmptyMode
f:=
((((|#| #) (< #) (<= #) (= #) ...)))

   >> Apparent user error:
   unspecified error

Construction operators: input and output

fricas

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?

Powers

fricas

A3p:=(A1*A1)*A1

$\label{eq1}{A 1}^{3}$

(1)

Type: Polynomial(Integer)

fricas

arity(A3p)

   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.

fricas

B3p:=(B1*B1)*B1

$\label{eq2}{B 1}^{3}$

(2)

Type: Polynomial(Integer)

fricas

arity(B3p)

   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.

Sums

fricas

A3s:=(A1+A1)+A1

$\label{eq3}3 \ A 1$

(3)

Type: Polynomial(Integer)

fricas

arity(A3s)

   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.

fricas

B3s:=(B1+B1)+B1

$\label{eq4}3 \ B 1$

(4)

Type: Polynomial(Integer)

fricas

arity(B3s)

   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.

Expected error

fricas

B1A1:=B1*A1

$\label{eq5}A 1 \ B 1$

(5)

Type: Polynomial(Integer)

fricas

arity(B1A1)

   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.

Composition

fricas

AB11:=A1 B1

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

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

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

Multiple inputs and outputs

fricas

W:L:=out[inp[inp([script(w,[[i,j],[k]]) for j in 1..2])$L for i in 1..2] for k in 1..2]

   L is not a valid type.