help links subscribe changes refresh edit

	FriCAS Algebra
FreeModule ←	↑	→ QuadraticForm

LinearOperator

last edited 4 years ago by Bill Page

Edit detail for LinearOperator revision 44 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/04/26 22:25:36 GMT-7
Note: faster composition

changed:
-    -- evaluation:
    -- composition:

changed:
-      r:T := product(dat f, dat g)
-      g1:Integer:=dom(f)+1
-      f1:Integer:=dom(f)+cod(f)+1
-      for i in 0..cod(f)-1 repeat
-        r := contract(r,g1,f1-i)
      f1:Integer:=dom(f)+1
      g1:Integer:=dom(f)+cod(f)+1
      if cod(f)=0 then
        r:T := product(dat f, dat g)
      else  -- product and first contraction
        r:T := contract(dat f,f1, dat g,1)
        -- more contractions
        for i in 1..cod(f)-1 repeat
          r := contract(r,f1,g1-i)

Introduction

Bi-graded linear operators (transformations) over n-dimensional vector spaces on a commutative ring . Members of this domain are morphisms $K^n \to K^m$ . Products, permutations and composition (grafting) of morphisms are 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 = 0     outputs

$\scalebox{1} % Change this value to rescale the drawing. { \begin{pspicture}(0,-0.92)(4.82,0.92) \psbezier[linewidth=0.04](2.2,0.9)(2.2,0.1)(2.6,0.1)(2.6,0.9) \psline[linewidth=0.04cm](2.4,0.3)(2.4,-0.1) \psbezier[linewidth=0.04](2.4,-0.1)(2.4,-0.9)(3.0,-0.9)(3.0,-0.1) \psline[linewidth=0.04cm](3.0,-0.1)(3.0,0.9) \psbezier[linewidth=0.04](4.8,0.9)(4.8,0.1)(4.4,0.1)(4.4,0.9) \psline[linewidth=0.04cm](4.6,0.3)(4.6,-0.1) \psbezier[linewidth=0.04](4.6,-0.1)(4.6,-0.9)(4.0,-0.9)(4.0,-0.1) \psline[linewidth=0.04cm](4.0,-0.1)(4.0,0.9) \usefont{T1}{ptm}{m}{n} \rput(3.4948437,0.205){=} \psline[linewidth=0.04cm](0.6,-0.7)(0.6,0.9) \psbezier[linewidth=0.04](0.0,-0.1)(0.0,-0.9)(1.2,-0.9)(1.2,-0.1) \psline[linewidth=0.04cm](0.0,-0.1)(0.0,0.9) \psline[linewidth=0.04cm](1.2,-0.1)(1.2,0.9) \usefont{T1}{ptm}{m}{n} \rput(1.6948438,0.205){=} \end{pspicture} }$

External vertices in this graph represent vectors, and tensors. Internal nodes and arcs (edges) represent linear operators. Horizontal juxtaposition (i.e. a horizontal cross-section) represents tensor product. Vertical juxtaposition represents operator composition.

See examples and documentation below

I would like you to make brief comments in the form at the bottom of this web page. For more detailed but related comments click discussion on the top menu.

Regards, Bill Page.

Source Code

We try to start the right way by defining the concept of a monoidal category.

Ref: http://en.wikipedia.org/wiki/PROP_(category_theory)

fricas

(1) -> <spad>

fricas

)abbrev category MONAL Monoidal
Monoidal(R:AbelianSemiGroup):Category == Ring with
    dom: % -> R
      ++ domain
    cod: % -> R
      ++ co-domain
    _/: (%,%) -> %
      ++ vertical composition f/g
    apply:(%,%) -> %
      ++ horizontal product f g = f*g</spad>

fricas

Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/2074022068168685528-25px001.spad
      using old system compiler.
   MONAL abbreviates category Monoidal 
------------------------------------------------------------------------
   initializing NRLIB MONAL for Monoidal 
   compiling into NRLIB MONAL 
Time: 0 SEC.

   finalizing NRLIB MONAL 
   Processing Monoidal for Browser database:
--->-->Monoidal(constructor): Not documented!!!!
--------(dom (R %))---------
--------(cod (R %))---------
--------(/ (% % %))---------
--->-->Monoidal((/ (% % %))): Improper first word in comments: vertical
"vertical composition \\spad{f/g}"
--------(apply (% % %))---------
--->-->Monoidal((apply (% % %))): Improper first word in comments: horizontal
"horizontal product \\spad{f} \\spad{g} = \\spad{f*g}"
--->-->Monoidal(): Missing Description
; compiling file "/var/aw/var/LatexWiki/MONAL.NRLIB/MONAL.lsp" (written 14 SEP 2026 12:12:39 PM):

; wrote /var/aw/var/LatexWiki/MONAL.NRLIB/MONAL.fasl
; compilation finished in 0:00:00.000
------------------------------------------------------------------------
   Monoidal is now explicitly exposed in frame initial 
   Monoidal will be automatically loaded when needed from 
      /var/aw/var/LatexWiki/MONAL.NRLIB/MONAL

The initial object in this category is the domain Prop (Products and Permutations). The Prop domain represents everything that is "constant" about all the domains in this category. It can be defined as an endo-functor with only the information available about the category itself.

spad

)abbrev domain PROP Prop
Prop(L:Monoidal NNI): Exports == Implementation where
  NNI ==> NonNegativeInteger

  Exports ==> Monoidal NNI with
    coerce: L -> %

  Implementation ==> add
    Rep == Record(domain:NNI, codomain:NNI)                -- Rep == L
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    coerce(f:%):OutputForm == dom(f)::OutputForm / cod(f)::OutputForm

    coerce(f:L):% == per [dom f, cod f]                    -- coerce(f:L):% == per f

    dom(x:%):NNI == rep(x).domain                          -- dom(x:%):NNI == dom rep x
    cod(x:%):NNI == rep(x).codomain                        -- cod(x:%):NNI == cod rep x
    0:% == per [0,0]                                       -- 0:% == per 0
    1:% == per [0,0]                                       -- 1:% == per 1
    -- evaluation
    (f:% / g:%):% == per [dom f, cod g]                    -- (f:% / g:%):% == per (rep f / rep g)
    -- product
    apply(f:%,g:%):% == per [dom f + dom g, cod f + cod g] -- apply(f:%,g:%):% == per apply(rep f,rep g)
    (f:% * g:%):% == per [dom f + dom g, cod f + cod g]    --(f:% * g:%):% == per (rep f * rep g)
    -- sum
    (f:% + g:%):% == per [dom f, cod f]                    --(f:% + g:%):% == per (rep f + rep g)

spad

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/3714416860228184972-25px002.spad
      using old system compiler.
   PROP abbreviates domain Prop 
------------------------------------------------------------------------
   initializing NRLIB PROP for Prop 
   compiling into NRLIB PROP 
************* USER ERROR **********
available signatures for Rep: 
    NONE
NEED Rep: () -> ?
****** comp fails at level 1 with expression: ******
((DEF (|Rep|) (NIL)
  (|Record| (|:| |domain| (|NonNegativeInteger|))
            (|:| |codomain| (|NonNegativeInteger|)))))
****** level 1  ******
x:= (DEF (Rep) (NIL) (Record (: domain (NonNegativeInteger)) (: codomain (NonNegativeInteger))))
m:= $EmptyMode
f:=
((((~= #) (= #) (|coerce| #) (|latex| #) ...)))

   >> Apparent user error:
   unspecified error

The LinearOperator? domain is Moniodal over NonNegativeInteger?. The objects of this domain are all tensor powers of a vector space of fixed dimension. The arrows are linear operators that map from one object (tensor power) to another.

Ref: http://en.wikipedia.org/wiki/Category_of_vector_spaces

all members of this domain have the same dimension
it might be useful (but much more complicated) to allow source and target dimensions to be different

spad

)abbrev domain LIN LinearOperator
LinearOperator(dim:NNI,gen: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)
    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) -> %
    ev: NAT -> %
      ++ (2,0)-tensor for evaluation
    co: NAT -> %
      ++ (0,2)-tensor for co-evaluation

  Implementation ==> add
    import List NNI
    import NAT
    Rep == Record(domain:NNI, codomain:NNI, data:T)
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    -- Prop (arity)
    dom(f:%):NNI == rep(f).domain
    cod(f:%):NNI == rep(f).codomain
    dat(f:%):T == rep(f).data
    arity(f:%):Prop % == f::Prop %

    retractIfCan(f:%):Union(K,"failed") ==
      dom(f)=0 and cod(f)=0 => retract(dat f)$T
      return "failed"
    retract(f:%):K ==
      dom(f)=0 and cod(f)=0 => retract(dat f)$T
      error "failed"

    -- basis
    basisVectors():List % == [per [0,1,entries(row(1,i)$SquareMatrix(dim,K))::T] for i in 1..dim]
    basisForms():List % == [per [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 [dom g,cod g,unravel(map(f,ravel dat g))$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
    unravel(p:Prop %,r:List K):% ==
      dim^(dom(p)+cod(p)) ~= #r => error "failed"
      per [dom(p),cod(p),unravel(r)$T]
    tensor(x:%):T == dat(x)

    -- sum
    (f:% + g:%):% ==
      dat(f)=0 => g
      dat(g)=0 => f
      dom(f) ~= dom(g) or cod(f) ~= cod(g) => error "arity"
      per [dom f,cod f,dat(f)+dat(g)]

    (f:% - g:%):% ==
      dat(f)=0 => g
      dat(g)=0 => f
      dom(f) ~= dom(f) or cod(g) ~= cod(g) => error "arity"
      per [dom f, cod f,dat(f)-dat(g)]

    _-(f:%):% == per [dom f, cod f,-dat(f)]

    -- repeated sum
    (p:NNI * f:%):% ==
      p=1 => f
      q:=subtractIfCan(p,1)
      q case NNI => q*f + f
      -- zero map (non-trivial)
      per [dom f,cod f,0*dat(f)]

    -- identity for sum (trivial zero map)
    0 == per [0,0,0]
    zero?(f:%):Boolean == dat f = 0 * dat f
    -- identity for product
    1:% == per [0,0,1]
    one?(f:%):Boolean == dat f = 1$T
    -- identity for composition
    I == per([1,1,kroneckerDelta()$T])
    -- inherited from Ring
    --(x:% = y:%):Boolean ==
    --  dom(x) ~= dom(y) or cod(x) ~= cod(y) => error "arity"
    --  dat(x) = dat(y)
    (x:% = y:%):Boolean == zero? (x - 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 [#p,#p,reindex(dat r,p3)]
    coerce(p:List None):% == per [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:%):% ==
      r:T := product(dat f,dat g)
      -- dom(f) + cod(f) + dom(g) + cod(g)
      p:List Integer := concat                _
        [[i for i in 1..dom(f)],              _
        [dom(f)+cod(f)+i for i in 1..dom(g)], _
        [dom(f)+i for i in 1..cod(f)],        _
        [dom(f)+dom(g)+cod(f)+i for i in 1..cod(g)]]
        -- dom(f) + dom(g) + cod(f) + cod(g)
      per [dom(f)+dom(g),cod(f)+cod(g),reindex(r,p)]

    -- repeated product
    (f:% ^ p:NNI):% ==
      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
      -- dom(g) ~= cod(f) => error "arity"
      f1:Integer:=dom(f)+1
      g1:Integer:=dom(f)+cod(f)+1
      if cod(f)=0 then
        r:T := product(dat f, dat g)
      else  -- product and first contraction
        r:T := contract(dat f,f1, dat g,1)
        -- more contractions
        for i in 1..cod(f)-1 repeat
          r := contract(r,f1,g1-i)
      per [dom(f),cod(g),r]

    (x:K * y:%):% == per [dom y, cod y,x*dat(y)]
    (x:% * y:K):% == per [dom x,cod x,dat(x)*y]
    (x:Integer * y:%):% == per [dom y,cod y,x*dat(y)]

    -- constructors
    inp(x:List K):% == per [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 [(dom(first x)+1),cod(first x),[dat(y) for y in x]::T]$Rep
    out(x:List K):% == per [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 [dom(first x),(cod(first x)+1),[dat(y) for y in x]::T]$Rep

    -- display operators using basis
    coerce(x:%):OutputForm ==
      dom(x)=0 and cod(x)=0 => return dat(x)::OutputForm
      if size()$gen > 0 then
        gens:List OutputForm:=[index(i::PositiveInteger)$gen::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:= []
      -- 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) | k~=0]
      empty? terms => return 0::OutputForm
      -- combine the terms
      return reduce(_+,terms)

spad

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

   >> Apparent user error:
   unspecified error

Getting Started

Consult the source code above for more details.

Conveniences

fricas

-- summation
macro Σ(x,i)==reduce(+,[x for i in 1..dim])

Type: Void

fricas

-- list comprehension
macro Ξ(f,i)==[f for i in 1..dim]

Type: Void

Basis

fricas

dim:=2

$\label{eq1}2$

(1)

Type: PositiveInteger?

fricas

Q:=EXPR INT

$\label{eq2}\hbox{\axiomType{Expression}\ } \left({\hbox{\axiomType{Integer}\ }}\right)$

(2)

Type: Type

fricas

L:=LinearOperator(dim,OVAR [x,y],Q)

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

Construction

fricas

A1:L := Σ(superscript(a1,[i])*dx.i,i)

   L is not a valid type.

Composition (evaluation)

$g/f : A^n \to A^{m+p} = f:A^n \to A^m <em> g:A^n \to A^p$

fricas

AB2 := A2 / B2; AB2::OutputForm = A2::OutputForm / B2::OutputForm

$\label{eq3}{\frac{A 2}{B 2}}={\frac{A 2}{B 2}}$

(3)

Type: Equation(OutputForm?)

fricas

arity(AB2)::OutputForm = arity(A2)::OutputForm / arity(B2)::OutputForm

   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) 
                        Fraction(Polynomial(Integer))

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

Partial Evaluation

fricas

BBA1 := B/A1

$\label{eq4}\frac{B}{A 1}$

(4)

Type: Fraction(Polynomial(Integer))

fricas

BBA2 := B/B1

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

(5)

Type: Fraction(Polynomial(Integer))

fricas

BBA3 := A1/A

$\label{eq6}\frac{A 1}{A}$

(6)

Type: Fraction(Polynomial(Integer))

fricas

BBA4 := B1/A

$\label{eq7}\frac{B 1}{A}$

(7)

Type: Fraction(Polynomial(Integer))

Powers

fricas

AB3:=(AB1*AB1)*AB1;

Type: Polynomial(Integer)

fricas

arity(AB3)

   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

$f+g : A^n \to A^m = f:A^n \to A^m + g:A^n \to A^m$

fricas

A12s := A1 + A2; A12s::OutputForm = A1::OutputForm + A2::OutputForm

$\label{eq8}{A 2 + A 1}={A 1 + A 2}$

(8)

Type: Equation(OutputForm?)

fricas

arity(A12s)::OutputForm = arity(A1)::OutputForm + arity(A2)::OutputForm

   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.

Multiplication

fricas

A3s:=(A1+A1)+A1

$\label{eq9}3 \ A 1$

(9)

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{eq10}3 \ B 1$

(10)

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.

Product

fricas

AB11:=A1*B1

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

(11)

Type: Polynomial(Integer)

fricas

arity(AB11)

   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.

Permutations and Identities

fricas

H:L:=[1,2]

   L is not a valid type.

Manipulations

fricas

tensor AB

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

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

Examples

Another kind of diagram:


     Y  =  Y 
    U       U

Algebra

fricas

Y:=Σ(Σ(Σ(script(y,[[k],[i,j]])*Dx.k*dx.i*dx.j,j),i),k)

   There are no library operations named Dx 
      Use HyperDoc Browse or issue
                                 )what op Dx
      to learn if there is any operation containing " Dx " in its name.
   Cannot find a definition or applicable library operation named Dx 
      with argument type(s) 
                               PositiveInteger

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.
   FriCAS will attempt to step through and interpret the code.
   There are no library operations named Dx 
      Use HyperDoc Browse or issue
                                 )what op Dx
      to learn if there is any operation containing " Dx " in its name.

   Cannot find a definition or applicable library operation named Dx 
      with argument type(s) 
                               PositiveInteger

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

Commutator Algebra

fricas

Y - [2,1]
  /   Y

   There are 12 exposed and 15 unexposed library operations named / 
      having 2 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                                )display op /
      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 / 
      with argument type(s) 
                            List(PositiveInteger)
                                 Variable(Y)

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

Pairing

fricas

U:=inp[inp([script(u,[[],[i,j]]) for j in 1..2])$L for i in 1..2]

   L is not a valid type.

3-point function

fricas

YU := Y I
  /    U

   There are no exposed library operations named Y but there are 2 
      unexposed operations with that name. Use HyperDoc Browse or issue
                                )display op Y
      to learn more about the available operations.

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

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

Oddities (should work on the right)

fricas

YU := Y [1]
  /    U

$\label{eq12}\frac{Y_{1}}{U}$

(12)

Type: Fraction(Polynomial(Integer))

fricas

YU := Y.[1]
  /    U

$\label{eq13}\frac{Y_{1}}{U}$

(13)

Type: Fraction(Polynomial(Integer))

Ok on the left

fricas

UY := [1].Y
  /      U

   There are 1 exposed and 1 unexposed library operations named elt 
      having 1 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                               )display op elt
      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 application of object of type List(NonNegativeInteger) 
      to argument(s) of type(s) 
                                 Variable(Y)

Co-algebra

fricas

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

   L is not a valid type.

Handle

λ
Y

fricas

Φ := λ
  /  Y

$\label{eq14}\frac{��}{Y}$

(14)

Type: Fraction(Polynomial(Integer))

fricas

arity Φ

   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) 
                        Fraction(Polynomial(Integer))

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

Back to the top.

Comments

Please leave comments and suggestions.

Thanks

Bill Page

Linear operators as morphisms --Bill Page, Thu, 10 Mar 2011 09:42:33 -0800 reply

If linear operators really are to be morphisms (in the sense of category theory) then they must have a domain and a co-domain that are vector spaces, not just an in-degree and out-degree. E.g.:

  Rep == Record(Dom:VectorSpace, Cod:VectorSpace, t:T)

But VectorSpace? is a category which would make Dom and Cod domains. The domains that currently satisfy VectorSpace? in Axiom are rather limited and seem oddly focused on number theory (finite fields). It is a good thing however that DirectProduct? is a conditional member of this cateogry.

fricas

DirectProduct(2,FRAC INT) has VectorSpace(FRAC INT)

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

   Cannot find a definition or applicable library operation named 
      VectorSpace with argument type(s) 
                                    Type

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

Unfortunately:

fricas

DirectProduct(2,DirectProduct(2,FRAC INT)) has VectorSpace(FRAC INT)

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

   Cannot find a definition or applicable library operation named 
      VectorSpace with argument type(s) 
                                    Type

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

The problem with VectorSpace? is that the domain [Vector]? is not a member of this category instead it satisfies VectoryCategory?.

Is it possible to treat tensors from CartesianTensor? as maps from VectorSpace? to VectorSpace?? We would like for example:

  T:DirectProduct(dim,DirectProduct(dim,FRAC INT)) -> DirectProduct(dim,FRAC INT))

To be a linear operator with two inputs and one output.

Modules --Bill Page, Thu, 10 Mar 2011 16:03:13 -0800 reply

A [FreeModule]? over a [Field]? is a VectorSpace? unfortunately this is not currently understood by Axiom:

fricas

FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)

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

   Cannot find a definition or applicable library operation named 
      VectorSpace with argument type(s) 
                                    Type

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