Linear transformations (operators) over n-dimensional cartesian vector spaces over a commutative ring . Members of this domain are morphisms . 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.
We try to start the right way by defining the concept of a monoidal category.
spad
)abbrev category MONAL Monoidal
)abbrev category MONAL Monoidal
Monoidal(R:AbelianSemiGroup):Category == Monoid with
dom: % -> R
++ domain
cod: % -> R
++ co-domain
_/: (%,%) -> %
++ vertical composition f/g = g*f
apply:(%,%) -> %
++ horizontal composition
coerce:(x:List None) -> %
++ identity for composition
add
(f:% / g:%):% == apply(g,f)
spad
Compiling FriCAS source code from file
/var/zope2/var/LatexWiki/6761162726479353213-25px001.spad using
old system compiler.
MONAL abbreviates category Monoidal
MONAL abbreviates category Monoidal
------------------------------------------------------------------------
initializing NRLIB MONAL for Monoidal
compiling into NRLIB MONAL
;;; *** |Monoidal| REDEFINED
Time: 0.06 SEC.
MONAL- abbreviates domain Monoidal&
------------------------------------------------------------------------
initializing NRLIB MONAL- for Monoidal&
compiling into NRLIB MONAL-
compiling exported / : (S,S) -> S
Time: 0.47 SEC.
(time taken in buildFunctor: 10)
;;; *** |Monoidal&| REDEFINED
Time: 0.01 SEC.
Cumulative Statistics for Constructor Monoidal&
Time: 0.48 seconds
finalizing NRLIB MONAL-
Processing Monoidal& for Browser database:
--------(dom (R %))---------
--------(cod (R %))---------
--------(/ (% % %))---------
--->-->Monoidal&((/ (% % %))): Improper first word in comments: vertical
"vertical composition \\spad{f/g} = \\spad{g*f}"
--------(apply (% % %))---------
--------(coerce (% (List (None))))---------
--->-->Monoidal&((coerce (% (List (None))))): Improper first word in comments: identity
"identity for composition"
--->-->Monoidal&(constructor): Not documented!!!!
--->-->Monoidal&(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/MONAL-.NRLIB/MONAL-.lsp" (written 09 APR 2011 10:33:35 PM):
; /var/zope2/var/LatexWiki/MONAL-.NRLIB/MONAL-.fasl written
; compilation finished in 0:00:00.091
------------------------------------------------------------------------
Monoidal& is now explicitly exposed in frame initial
Monoidal& will be automatically loaded when needed from
/var/zope2/var/LatexWiki/MONAL-.NRLIB/MONAL-
finalizing NRLIB MONAL
Processing Monoidal for Browser database:
--------(dom (R %))---------
--------(cod (R %))---------
--------(/ (% % %))---------
--->-->Monoidal((/ (% % %))): Improper first word in comments: vertical
"vertical composition \\spad{f/g} = \\spad{g*f}"
--------(apply (% % %))---------
--------(coerce (% (List (None))))---------
--->-->Monoidal((coerce (% (List (None))))): Improper first word in comments: identity
"identity for composition"
--->-->Monoidal(constructor): Not documented!!!!
--->-->Monoidal(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/MONAL.NRLIB/MONAL.lsp" (written 09 APR 2011 10:33:35 PM):
; /var/zope2/var/LatexWiki/MONAL.NRLIB/MONAL.fasl written
; compilation finished in 0:00:00.028
------------------------------------------------------------------------
Monoidal is now explicitly exposed in frame initial
Monoidal will be automatically loaded when needed from
/var/zope2/var/LatexWiki/MONAL.NRLIB/MONAL
>> System error:
The bounding indices 163 and 162 are bad for a sequence of length 162.
See also:
The ANSI Standard, Glossary entry for "bounding index designator"
The ANSI Standard, writeup for Issue SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR
The initial object in this category is the domain Prop (Products and Permutations).
spad
)abbrev domain PROP Prop
Prop(R:Ring): Join(Monoidal R, CoercibleTo OutputForm) with
_/:(R,R) -> %
== add
Rep == Record(domain:R,codomain:R)
rep(x:%):Rep == x pretend Rep
per(x:Rep):% == x pretend %
dom(f:%):R == rep(f).domain
cod(f:%):R == rep(f).codomain
coerce(f:%):OutputForm == dom(f)::OutputForm / cod(f)::OutputForm
(f:R / g:R):% == per [f,g]
apply(g:%, f:%):% ==
cod(f) ~= dom(g) => error "arity"
per [dom f,cod g]
coerce(x:List None):% == per [1,1]
(f:% * g:%):% == per [dom(f)+dom(g),cod(f)+cod(g)]
-- preserves arity
(f:% + g:%):% ==
dom(f)~=dom(g) or cod(g) ~= cod(g) => error "arity"
f
spad
Compiling FriCAS source code from file
/var/zope2/var/LatexWiki/2209711262636362952-25px002.spad using
old system compiler.
PROP abbreviates domain Prop
------------------------------------------------------------------------
initializing NRLIB PROP for Prop
compiling into NRLIB PROP
compiling local rep : $ -> Record(domain: R,codomain: R)
PROP;rep is replaced by x
Time: 0.06 SEC.
compiling local per : Record(domain: R,codomain: R) -> $
PROP;per is replaced by x
Time: 0.01 SEC.
compiling exported dom : $ -> R
Time: 0 SEC.
compiling exported cod : $ -> R
Time: 0 SEC.
compiling exported coerce : $ -> OutputForm
Time: 0.01 SEC.
compiling exported / : (R,R) -> $
Time: 0 SEC.
compiling exported apply : ($,$) -> $
Time: 0.01 SEC.
compiling exported coerce : List None -> $
Time: 0.01 SEC.
compiling exported * : ($,$) -> $
Time: 0 SEC.
compiling local + : ($,$) -> $
Time: 0 SEC.
(time taken in buildFunctor: 10)
;;; *** |Prop| REDEFINED
;;; *** |Prop| REDEFINED
Time: 0.01 SEC.
Cumulative Statistics for Constructor Prop
Time: 0.11 seconds
finalizing NRLIB PROP
Processing Prop for Browser database:
--->-->Prop((/ (% R R))): Not documented!!!!
--->-->Prop(constructor): Not documented!!!!
--->-->Prop(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/PROP.NRLIB/PROP.lsp" (written 09 APR 2011 10:33:36 PM):
; /var/zope2/var/LatexWiki/PROP.NRLIB/PROP.fasl written
; compilation finished in 0:00:00.329
------------------------------------------------------------------------
Prop is now explicitly exposed in frame initial
Prop will be automatically loaded when needed from
/var/zope2/var/LatexWiki/PROP.NRLIB/PROP
>> System error:
The bounding indices 163 and 162 are bad for a sequence of length 162.
See also:
The ANSI Standard, Glossary entry for "bounding index designator"
The ANSI Standard, writeup for Issue SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR
The LinearOperator? domain is Moniodal over NonNegativeInteger?
spad
)abbrev domain LIN LinearOperator
LinearOperator(dim:NonNegativeInteger,K:CommutativeRing): Exports == Implementation where
NNI ==> NonNegativeInteger
Exports ==> Join(Ring, BiModule(K,K), Monoidal NNI, CoercibleTo Prop NNI) with
inp: List K -> %
++ incoming vector
inp: List % -> %
out: List K -> %
++ output vector
out: List % -> %
coerce: K -> %
coerce: SquareMatrix(dim,K) -> %
_*: (%,NonNegativeInteger) -> %
arity: % -> Prop(NNI)
apply: (%,%) -> %
Implementation ==> add
import List NNI
T ==> CartesianTensor(1,dim,K)
Rep == Record(domain:NNI, codomain:NNI, data:T)
rep(x:%):Rep == x pretend Rep
per(x:Rep):% == x pretend %
dom(f:%):NNI == rep(f).domain
cod(f:%):NNI == rep(f).codomain
dat(f:%):T == rep(f).data
arity(f:%):Prop NNI == dom(f)/cod(f)
coerce(f:%):Prop NNI == arity f
0 == per [0,0,0]
--
-- f+g : A^{n+m} -> A^p = f:A^n -> A^p + g:A^m -> A^p
--
(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:%):% ==
dom(f) ~= dom(f) or cod(g) ~= cod(g) => error "arity"
per [dom(f),cod(f),dat(f)-dat(g)]
--
-- f/g : A^n -> A^p = f:A^n -> A^m / g:A^m -> A^p
-- g f : A^n -> A^p = g:A^m -> A^p * f:A^n -> A^m
--
apply(g:%,f:%):% ==
dom(g) ~= cod(f) => error "arity"
r:T := product(dat(f), dat(g))
n:Integer:=dom(f)+1
m:Integer:=dom(f)+cod(f)+1
for i in 0..cod(f)-1 repeat
r := contract(r,n,m-i)
--(m1:=subtractIfCan(m,1)) case NNI =>m:=m1
per [dom f,cod g,r]
coerce(x:List None):% == per [1,1,kroneckerDelta()$T]
1:% == per [0,0,1]
coerce(x:K):% == 1*x
-- repeated composition
(f:% ^ p:NNI):% ==
cod(f) ~= dom(f) => error "arity"
q:=subtractIfCan(p,1)
q case NNI => f^q * f
1
-- repeated sum
(f:% * p:NNI):% ==
print(p::OutputForm)
q:=subtractIfCan(p,1)
q case NNI => f*q + f
0
(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)]
(x:% = y:%):Boolean ==
dom(x) ~= dom(y) or cod(x) ~= cod(y) => error "arity"
dat(x) = dat(y)
(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)]
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
coerce(x:%):OutputForm == (dat(x))::OutputForm
spad
Compiling FriCAS source code from file
/var/zope2/var/LatexWiki/2457767226733576822-25px003.spad using
old system compiler.
LIN abbreviates domain LinearOperator
------------------------------------------------------------------------
initializing NRLIB LIN for LinearOperator
compiling into NRLIB LIN
importing List NonNegativeInteger
processing macro definition T$ ==> CartesianTensor(One,dim,K)
compiling local rep : $ -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
LIN;rep is replaced by x
Time: 0.06 SEC.
compiling local per : Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> $
LIN;per is replaced by x
Time: 0.01 SEC.
compiling exported dom : $ -> NonNegativeInteger
Time: 0 SEC.
compiling exported cod : $ -> NonNegativeInteger
Time: 0 SEC.
compiling local dat : $ -> CartesianTensor(One,dim,K)
Time: 0.01 SEC.
compiling exported arity : $ -> Prop NonNegativeInteger
Time: 0 SEC.
compiling exported coerce : $ -> Prop NonNegativeInteger
Time: 0 SEC.
compiling exported Zero : () -> $
Time: 0.01 SEC.
compiling exported + : ($,$) -> $
Time: 0.02 SEC.
compiling exported - : ($,$) -> $
Time: 0.01 SEC.
compiling exported apply : ($,$) -> $
Time: 0.02 SEC.
compiling exported coerce : List None -> $
Time: 0 SEC.
compiling exported One : () -> $
Time: 0 SEC.
compiling exported coerce : K -> $
Time: 0 SEC.
compiling exported ^ : ($,NonNegativeInteger) -> $
Time: 0.01 SEC.
compiling exported * : ($,NonNegativeInteger) -> $
Time: 0.01 SEC.
compiling exported * : ($,$) -> $
Time: 0.05 SEC.
compiling exported = : ($,$) -> Boolean
Time: 0.02 SEC.
compiling exported * : (K,$) -> $
Time: 0 SEC.
compiling exported * : ($,K) -> $
Time: 0 SEC.
compiling exported * : (Integer,$) -> $
Time: 0.01 SEC.
compiling exported inp : List K -> $
Time: 0.06 SEC.
compiling exported inp : List $ -> $
Time: 0.27 SEC.
compiling exported out : List K -> $
Time: 0.01 SEC.
compiling exported out : List $ -> $
Time: 0.04 SEC.
compiling exported coerce : $ -> OutputForm
Time: 0 SEC.
(time taken in buildFunctor: 10)
;;; *** |LinearOperator| REDEFINED
;;; *** |LinearOperator| REDEFINED
Time: 0.02 SEC.
Warnings:
[1] not known that (Ring) is of mode (CATEGORY domain (SIGNATURE quo ($ $ $)) (SIGNATURE rem ($ $ $)) (SIGNATURE gcd ($ $ $)) (SIGNATURE divide ((Record (: quotient $) (: remainder $)) $ $)) (SIGNATURE exquo ((Union $ failed) $ $)) (SIGNATURE shift ($ $ (Integer))) (SIGNATURE random ($ $)))
[2] arity: not known that (Ring) is of mode (CATEGORY domain (SIGNATURE quo ($ $ $)) (SIGNATURE rem ($ $ $)) (SIGNATURE gcd ($ $ $)) (SIGNATURE divide ((Record (: quotient $) (: remainder $)) $ $)) (SIGNATURE exquo ((Union $ failed) $ $)) (SIGNATURE shift ($ $ (Integer))) (SIGNATURE random ($ $)))
Cumulative Statistics for Constructor LinearOperator
Time: 0.64 seconds
finalizing NRLIB LIN
Processing LinearOperator for Browser database:
--------(inp (% (List K)))---------
--->-->LinearOperator((inp (% (List %)))): Not documented!!!!
--------(out (% (List K)))---------
--->-->LinearOperator((out (% (List %)))): Not documented!!!!
--->-->LinearOperator((coerce (% K))): Not documented!!!!
--->-->LinearOperator((coerce (% (SquareMatrix dim K)))): Not documented!!!!
--->-->LinearOperator((* (% % (NonNegativeInteger)))): Not documented!!!!
--->-->LinearOperator((arity ((Prop NNI) %))): Not documented!!!!
--->-->LinearOperator((apply (% % %))): Not documented!!!!
--->-->LinearOperator(constructor): Not documented!!!!
--->-->LinearOperator(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/LIN.NRLIB/LIN.lsp" (written 09 APR 2011 10:33:37 PM):
; /var/zope2/var/LatexWiki/LIN.NRLIB/LIN.fasl written
; compilation finished in 0:00:00.605
------------------------------------------------------------------------
LinearOperator is now explicitly exposed in frame initial
LinearOperator will be automatically loaded when needed from
/var/zope2/var/LatexWiki/LIN.NRLIB/LIN
>> System error:
The bounding indices 163 and 162 are bad for a sequence of length 162.
See also:
The ANSI Standard, Glossary entry for "bounding index designator"
The ANSI Standard, writeup for Issue SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR
Construction operators: input and output
axiom
L:=LIN(2,FRAC POLY INT)
Type: Type
axiom
A1:L:=inp[script(a,[[1,i]]) for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity A1
Type: Prop(NonNegativeInteger
?)
axiom
A2:L:=inp[script(a,[[2,i]]) for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
A:L:=inp[A1,A2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity A
Type: Prop(NonNegativeInteger
?)
axiom
B1:L:=out[script(b,[[],[1,i]]) for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity B1
Type: Prop(NonNegativeInteger
?)
axiom
B2:L:=out[script(b,[[],[2,i]]) for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
B:L:=out[B1,B2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity B
Type: Prop(NonNegativeInteger
?)
Composition
axiom
AB2 := A2 / B2; AB2::OutputForm = A2::OutputForm / B2::OutputForm
Type: Equation(OutputForm
?)
axiom
arity(AB2)::OutputForm = arity(A2)::OutputForm / arity(B2)::OutputForm
Type: Equation(OutputForm
?)
axiom
BA1 := B1 / A1; BA1::OutputForm = B1::OutputForm / A1::OutputForm
Type: Equation(OutputForm
?)
axiom
arity(BA1)::OutputForm = arity(B1)::OutputForm / arity(A1)::OutputForm
Type: Equation(OutputForm
?)
axiom
AB1 := A1 / B1; AB1::OutputForm = A1::OutputForm / B1::OutputForm
Type: Equation(OutputForm
?)
axiom
arity(AB1)::OutputForm = arity(A1)::OutputForm / arity(B1)::OutputForm
Type: Equation(OutputForm
?)
Powers
axiom
AB3:=(AB1*AB1)*AB1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(AB3)
Type: Prop(NonNegativeInteger
?)
axiom
test(AB3=AB1*(AB1*AB1))
Type: Boolean
axiom
test(AB3=AB1^3)
Type: Boolean
Sums
axiom
A12s := A1 + A2; A12s::OutputForm = A1::OutputForm + A2::OutputForm
Type: Equation(OutputForm
?)
axiom
arity(A12s)::OutputForm = arity(A1)::OutputForm + arity(A2)::OutputForm
Type: Equation(OutputForm
?)
axiom
B12s := B1 + B2; B12s::OutputForm = B1::OutputForm + B2::OutputForm
Type: Equation(OutputForm
?)
axiom
arity(B12s)::OutputForm = arity(B1)::OutputForm + arity(B2)::OutputForm
Type: Equation(OutputForm
?)
Multiplication
axiom
A3s:=(A1+A1)+A1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(A3s)
Type: Prop(NonNegativeInteger
?)
axiom
test(A3s=A1+(A1+A1))
Type: Boolean
axiom
test(A3s=A1*3)
3
2
1
0
Type: Boolean
axiom
B3s:=(B1+B1)+B1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(B3s)
Type: Prop(NonNegativeInteger
?)
axiom
test(B3s=B1+(B1+B1))
Type: Boolean
axiom
test(B3s=B1*3)
3
2
1
0
Type: Boolean
Expected error
axiom
B1A1:=B1*A1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(B1A1)
Type: Prop(NonNegativeInteger
?)
Product
axiom
AB11:=A1*B1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(AB11)
Type: Prop(NonNegativeInteger
?)
axiom
BA11:= B1*A1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(BA11)
Type: Prop(NonNegativeInteger
?)
axiom
AB := A*B
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(AB)
Type: Prop(NonNegativeInteger
?)
axiom
BA := B*A
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(BA)
Type: Prop(NonNegativeInteger
?)
axiom
X2:L:=inp[inp([script(x,[[i,j]]) for j in 1..2])$L for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
XB21:=X2*B1
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(XB21)
Type: Prop(NonNegativeInteger
?)
axiom
Y2:L:=out[out([script(y,[[],[i,j]]) for j in 1..2])$L for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
XY22:=X2*Y2
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(XY22)
Type: Prop(NonNegativeInteger
?)
axiom
YX22:=Y2*X2
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(XY22)
Type: Prop(NonNegativeInteger
?)
axiom
test((A*A)*A=A*(A*A))
Type: Boolean
axiom
test((B*B)*B=B*(B*B))
Type: Boolean
axiom
test((A*B)*A=A*(B*A))
Type: Boolean
Multiple inputs and outputs
axiom
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]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
WB1:=W B1
>> Error detected within library code:
arity
Another kind of diagram:
___ _ _
___ _) = _\_ _
_/ ___ _)
axiom
Y:=out[inp[inp([script(y,[[i],[j,k]]) for k in 1..2])$L for j in 1..2] for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(Y)
Type: Prop(NonNegativeInteger
?)
axiom
U:=inp[inp([script(u,[[],[i,j]]) for j in 1..2])$L for i in 1..2]
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(U)
Type: Prop(NonNegativeInteger
?)
axiom
YU:=(Y*[])/U
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(YU)
Type: Prop(NonNegativeInteger
?)
axiom
UY:=([]*Y)/U
Type: LinearOperator
?(2,
Fraction(Polynomial(Integer)))
axiom
arity(UY)
Type: Prop(NonNegativeInteger
?)
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.
axiom
DirectProduct(2,FRAC INT) has VectorSpace(FRAC INT)
Type: Boolean
Unfortunately:
axiom
DirectProduct(2,DirectProduct(2,FRAC INT)) has VectorSpace(FRAC INT)
Type: Boolean
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.
A [FreeModule]
? over a [Field]
? is a VectorSpace
? unfortunately this is not currently understood by Axiom:
axiom
FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
Type: Boolean