Edit detail for LinearOperator revision 51 of 63

Introduction

Bi-graded linear operators (transformations) over n-dimensional vector spaces on a commutative ring . Members of this domain are morphisms . 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

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)

)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

   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 

;;;     ***       |Monoidal| REDEFINED
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 03 APR 2013 11:52:56 PM):

; /var/aw/var/LatexWiki/MONAL.NRLIB/MONAL.fasl written
; compilation finished in 0:00:00.006
------------------------------------------------------------------------
   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.

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

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/3186492205692341477-25px002.spad
      using old system compiler.
   PROP abbreviates domain Prop 
------------------------------------------------------------------------
   initializing NRLIB PROP for Prop 
   compiling into NRLIB PROP 
   processing macro definition Rep ==> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger) 
   compiling local rep : $ -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger)
      PROP;rep is replaced by x 
Time: 0.01 SEC.

   compiling local per : Record(domain: NonNegativeInteger,codomain: NonNegativeInteger) -> $
      PROP;per is replaced by x 
Time: 0 SEC.

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

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

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

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

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

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

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

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

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

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

(time taken in buildFunctor:  0)

;;;     ***       |Prop| REDEFINED

;;;     ***       |Prop| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor Prop
      Time: 0.02 seconds

   finalizing NRLIB PROP 
   Processing Prop for Browser database:
--->-->Prop(constructor): Not documented!!!!
--->-->Prop((coerce (% L))): Not documented!!!!
--->-->Prop(): Missing Description
; compiling file "/var/aw/var/LatexWiki/PROP.NRLIB/PROP.lsp" (written 03 APR 2013 11:52:56 PM):

; /var/aw/var/LatexWiki/PROP.NRLIB/PROP.fasl written
; compilation finished in 0:00:00.031
------------------------------------------------------------------------
   Prop is now explicitly exposed in frame initial 
   Prop will be automatically loaded when needed from 
      /var/aw/var/LatexWiki/PROP.NRLIB/PROP

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

)lib CARTEN MONAL PROP

   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 already explicitly exposed in frame initial 
   Monoidal will be automatically loaded when needed from 
      /var/aw/var/LatexWiki/MONAL.NRLIB/MONAL
   Prop is already explicitly exposed in frame initial 
   Prop will be automatically loaded when needed from 
      /var/aw/var/LatexWiki/PROP.NRLIB/PROP

)abbrev domain LOP LinearOperator
LinearOperator(gener:OrderedFinite,K:Field): Exports == Implementation where
  NNI ==> NonNegativeInteger
  NAT ==> PositiveInteger

  Exports ==> Join(Ring, VectorSpace K, Monoidal NNI, RetractableTo K) with
    arity: % -> Prop %
    basisOut: () -> List %
    basisIn: () -> List %
    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

    dim:NNI := size()$gener
    T := CartesianTensor(1,dim,K)
    L := Record(domain:NNI, codomain:NNI, data:T)
    RR := Record(gen:L,exp:NNI)
    -- FreeMonoid provides unevaluated products
    Rep ==> FreeMonoid L
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    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(%)
    co(n:NAT):% == reduce(_+,[ Dx^n * Dx^n for Dx in basisOut()])$List(%)

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

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

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

      -- parallel factors guarantees that these are just identities
      if nf>0 and ng>0 then
        return I*(f2/g2)
      if fn>0 and gn>0 then
        output("Should not happen: trailing [fn,gn] = ",[fn,gn]::OutputForm)$OutputPackage
        return (f/g)*I

      -- 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 coerce [nf+dom(f)+fn,ng+cod(g)+gn,r]
      return per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * (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

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/905110569189869980-25px004.spad
      using old system compiler.
   LOP abbreviates domain LinearOperator 
------------------------------------------------------------------------
   initializing NRLIB LOP for LinearOperator 
   compiling into NRLIB LOP 
   importing List NonNegativeInteger
   processing macro definition Rep ==> FreeMonoid L 
   compiling local rep : $ -> FreeMonoid L
      LOP;rep is replaced by x 
Time: 0.02 SEC.

   compiling local per : FreeMonoid L -> $
      LOP;per is replaced by x 
Time: 0 SEC.

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

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

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

   compiling local prod : (L,L) -> L
Time: 0.01 SEC.

   compiling local dats : List RR -> L
Time: 0 SEC.

   compiling local dat : $ -> L
Time: 0.01 SEC.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   compiling exported coerce : List None -> $
Time: 0.01 SEC.

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

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

   compiling exported elt : ($,PositiveInteger) -> $
Time: 0 SEC.

   compiling exported elt : ($,PositiveInteger,PositiveInteger) -> $
Time: 0 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 L -> NonNegativeInteger
Time: 0.02 SEC.

   compiling local trailI : FreeMonoid L -> NonNegativeInteger
Time: 0.01 SEC.

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

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

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

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

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

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

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

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

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

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

;;;     ***       |LinearOperator| REDEFINED

;;;     ***       |LinearOperator| REDEFINED
Time: 0 SEC.

   Warnings: 
      [1] /:  i has no value
      [2] /:  j has no value

   Cumulative Statistics for Constructor LinearOperator
      Time: 4.12 seconds

   finalizing NRLIB LOP 
   Processing LinearOperator for Browser database:
--->-->LinearOperator(constructor): Not documented!!!!
--->-->LinearOperator((arity ((Prop %) %))): Not documented!!!!
--->-->LinearOperator((basisOut ((List %)))): Not documented!!!!
--->-->LinearOperator((basisIn ((List %)))): 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 (PositiveInteger))))---------
--->-->LinearOperator((coerce (% (List (PositiveInteger))))): 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 (% % (PositiveInteger)))): Not documented!!!!
--->-->LinearOperator((elt (% % (PositiveInteger) (PositiveInteger)))): Not documented!!!!
--->-->LinearOperator((elt (% % (PositiveInteger) (PositiveInteger) (PositiveInteger)))): 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 (% (PositiveInteger)))---------
--->-->LinearOperator((ev (% (PositiveInteger)))): Improper first word in comments: 
"(2,{}0)-tensor for evaluation"
--------(co (% (PositiveInteger)))---------
--->-->LinearOperator((co (% (PositiveInteger)))): Improper first word in comments: 
"(0,{}2)-tensor for co-evaluation"
--->-->LinearOperator(): Missing Description
; compiling file "/var/aw/var/LatexWiki/LOP.NRLIB/LOP.lsp" (written 03 APR 2013 11:53:00 PM):

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

Getting Started

Consult the source code above for more details.

Convenient Notation

-- summation
macro Σ(f,i,b) == reduce(+,[f*b.i for i in 1..#b])

-- list comprehension
macro Ξ(f,i)==[f for i in 1..retract(dimension()$L)]

Basis

Q := EXPR INT

(1)

L := LOP(OVAR ['x,'y],Q)

(2)

dim:Integer:=retract dimension()$L

(3)

Dx:=basisOut()$L

(4)

dx:=basisIn()$L

(5)

matrix Ξ(Ξ( eval(dx.i * Dx.j), i),j)

(6)

matrix Ξ(Ξ( Dx.i / dx.j, i),j)

(7)

Tests

A:L := Σ( Σ( script(a,[[j],[i]]), i,Dx), j,dx)

(8)

-- scalar
3*A

(9)

A/3

(10)

-- identity
I:L := [1]

(11)

H:L:=[1,2]

(12)

test( I*I = H )

(13)

-- twist
X:L := [2,1]

(14)

test(X/X=H)

(15)

-- printing
I*X*X*I

(16)

-- trace
U:L:=ev(1)

(17)

Ω:L:=co(1)

(18)

Ω/U

(19)

test
  ( I Ω  ) /
  (  U I ) = I

(20)

test
  (  Ω I ) /
  ( I U  ) = I

(21)

Various special cases of composition

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

(22)

test( (I*X)/(I*X) = [1,2,3] )

(23)

test( (I*X*I)/(I*X*I) = [1,2,3,4] )

(24)

-- case 2
test( (X*I*I)/(X*X) = [1,2,4,3] )

(25)

-- case 3
test( (X*X)/(X*I*I) = [1,2,4,3] )

(26)

-- case 4
test ( (I*I*X)/(X*X) = [2,1,3,4] )

(27)

-- case 5
test( (I*X*I)/(X*X) = [3,1,4,2] )

(28)

-- case 6
test( (I*I*X)/(X*I*I)=[2,1,4,3] )

(29)

test( (I*X)/(X*I) = [3,1,2] )

(30)

test( (I*X*I)/(X*I*I)=[3,1,2,4] )

(31)

-- case 7
test( (X*X)/(I*I*X) = [2,1,3,4] )

(32)

-- case 8
test( (X*I)/(I*X) = [2,3,1] )

(33)

-- case 9
test( (X*X)/(I*X*I) = [2,4,1,3] )

(34)

Construction

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

(35)

arity A1

(36)

A2:L := Σ(superscript(a2,[i]),i,dx)

(37)

A:L := A1*I+I*A2

(38)

arity A

(39)

B1:L := Σ(subscript(b1,[i]),i,Dx)

(40)

arity B1

(41)

B2:L := Σ(subscript(b2,[i]),i,Dx)

(42)

B:L := B1*I+I*B2

(43)

arity B

(44)

BB:L := Σ(Σ(subscript(b,[i,j]),i,Dx),j,Dx)

(45)

W:L := Σ(Σ(Σ(script(w,[[k],[i,j]]),k,Dx),i,dx),j,dx)

(46)

Composition (evaluation)

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

(47)

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

(48)

BA1 := B1 / A1; BA1::OutputForm = B1::OutputForm / A1::OutputForm

(49)

arity(BA1)::OutputForm = arity(B1)::OutputForm / arity(A1)::OutputForm

(50)

AB1 := A1 / B1; AB1::OutputForm = A1::OutputForm / B1::OutputForm

(51)

arity(AB1)::OutputForm = arity(A1)::OutputForm / arity(B1)::OutputForm

(52)

Partial Evaluation

BBA1 := B/A1

                     1
                     -
                     2
   arity warning: ------
                  1  1 1
                  - (-)
                  0  1

(53)

BBA2 := B/B1

                     1
                     -
                     2
   arity warning: ------
                  0  1 2
                  - (-)
                  1  1

(54)

BBA3 := A1/A

                   1 2 1
                  (-)  -
                   1   0
   arity warning: ------
                     2
                     -
                     1

(55)

BBA4 := B1/A

                   1 1 0
                  (-)  -
                   1   1
   arity warning: ------
                     2
                     -
                     1

(56)

Powers

AB3:=(AB1*AB1)*AB1;

arity(AB3)

(57)

test(AB3=AB1*(AB1*AB1))

(58)

test(AB3=AB1^3)

(59)

one? (AB3^0)

(60)

Sums

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

(61)

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

(62)

B12s := B1 + B2; B12s::OutputForm = B1::OutputForm + B2::OutputForm

(63)

arity(B12s)::OutputForm = arity(B1)::OutputForm + arity(B2)::OutputForm

(64)

-B12s

(65)

zero? (A12s - A12s)

(66)

Multiplication

A3s:=(A1+A1)+A1

(67)

arity(A3s)

(68)

test(A3s=A1+(A1+A1))

(69)

test(A3s=A1*3)

(70)

zero? (0*A3s)

(71)

B3s:=(B1+B1)+B1

(72)

arity(B3s)

(73)

test(B3s=B1+(B1+B1))

(74)

test(B3s=B1*3)

(75)

Product

AB11:=A1*B1

(76)

arity(AB11)

(77)

BA11:= B1*A1

(78)

arity(BA11)

(79)

AB := A*B

(80)

arity(AB)

(81)

BA := B*A

(82)

arity(BA)

(83)

WB1:=W*B1

(84)

arity(WB1)

(85)

test((A*A)*A=A*(A*A))

(86)

test((B*B)*B=B*(B*B))

(87)

test((A*B)*A=A*(B*A))

(88)

Permutations

-- braid
B3:=(I*X)/(X*I)

(89)

test(B3/B3/B3 = I*I*I)

(90)

-- parallel
test((X*X)/(X*X)=H*H)

(91)

Manipulations

ravel AB

(92)

test(unravel(arity AB,ravel AB)$L=AB)

(93)

map(x+->x+1,AB)$L

(94)

[superscript(a1,[i])=i for i in 1..dim]::List EQ Q

(95)

eval(A,[superscript(a1,[i])=i for i in 1..dim]::List EQ Q)

(96)

Examples

Another kind of diagram:

     Y  =  Y 
    U       U

Algebra

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

(97)

arity Y

(98)

Commutator

Y -   X /
      Y

(99)

Pairing

U:=Σ(Σ(script(u,[[],[i,j]]),j,dx),i,dx)

(100)

arity U

(101)

3-point function

YU := Y I
  /    U

(102)

YU := Y.I
  /    U

(103)

arity YU

(104)

YU:L := (Y,I) / U

(105)

UY:L := (I,Y) / U

(106)

Oddities (should work on the right)

YU := Y [1]
  /    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) 
                            List(PositiveInteger)

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.
YU := Y.[1]
  /    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) 
                            List(PositiveInteger)

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

Ok on the left

UY := [1].Y
  /      U

(107)

UY := [1] Y
  /      U

(108)

arity UY

(109)

Co-algebra

λ:=Σ(Σ(Σ(script(y,[[i],[j,k]]),i,dx),j,Dx),k,Dx)

(110)

arity λ

(111)

Handle

λ
Y

Φ := λ
  /  Y

(112)

arity Φ

(113)

Back to the top.

Comments

Please leave comments and suggestions.

Thanks

Bill Page