login  home  contents  what's new  discussion  bug reports help  links  subscribe  changes  refresh  edit

fricas
)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 now explicitly exposed in frame initial
Monoidal will be automatically loaded when needed from
/var/aw/var/LatexWiki/MONAL.NRLIB/MONAL
Prop is now 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
T ==> CartesianTensor(1,dim,K)
Exports ==> Join(Ring, VectorSpace K, Monoidal NNI, RetractableTo K) with
arity: % -> Prop %
basisOut: () -> List %
basisIn: () -> List %
tensor: % -> T
I : () -> %
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
import List NNI
import NAT
L ==> Record(domain:NNI, codomain:NNI, data:T)
-- FreeMonoid provides unevaluated products
Rep ==> FreeMonoid L
RR ==> Record(gen:L,exp:NNI)
rep(x:%):Rep == x pretend Rep
per(x:Rep):% == x pretend %
dim:NNI := size()$gener 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(%)
--  dx:= basisIn()
--  reduce(_+,[ (dx.i)^n * (dx.i)^n for i in 1..dim])
co(n:NAT):% == reduce(_+,[ Dx^n * Dx^n for Dx in basisOut()])$List(%) -- Dx:= basisOut() -- reduce(_+,[ (Dx.i)^n * (Dx.i)^n for i in 1..dim]) -- 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] tensor(x:%):T == dat(x).data -- 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 -- factor parallel identites nl := leadI hclf(rep f,rep g) nI := rep(I)^nl f := per overlap(nI,rep f).rm g := per overlap(nI,rep g).rm ln := trailI hcrf(rep f,rep g) In := rep(I)^ln f := per overlap(rep f,In).lm g := per overlap(rep g,In).lm -- 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 -- Factoring out parallel identities guarantees that: if nf>0 and ng>0 then error "either nf or ng or both must be 0" if fn>0 and gn>0 then error "either fn or gn or both must be 0" -- 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 nI * per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * per In
if f2=1 then error "g2 should be 1"
if g2=1 then error "f2 should be 1"
return per nI * per coerce [nf+dom(f)+fn,ng+cod(g)+gn,r] * per In * (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
using old system compiler.
LOP abbreviates domain LinearOperator
------------------------------------------------------------------------
initializing NRLIB LOP for LinearOperator
compiling into NRLIB LOP
importing List NonNegativeInteger
importing PositiveInteger
processing macro definition L ==> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
processing macro definition Rep ==> FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
processing macro definition RR ==> Record(gen: Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),exp: NonNegativeInteger)
compiling local rep : $-> FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) LOP;rep is replaced by x Time: 0.03 SEC. compiling local per : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) ->$
LOP;per is replaced by x
Time: 0 SEC.
compiling exported dimension : () -> CardinalNumber
Time: 0 SEC.
compiling exported dom : $-> NonNegativeInteger Time: 0 SEC. compiling exported cod :$ -> NonNegativeInteger
Time: 0 SEC.
compiling local prod : (Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))) -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
Time: 0.02 SEC.
compiling local dats : List Record(gen: Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)),exp: NonNegativeInteger) -> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K))
Time: 0 SEC.
compiling local dat : $-> Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) Time: 0 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.01 SEC. compiling exported basisOut : () -> List$
Time: 0.01 SEC.
compiling exported basisIn : () -> List $Time: 0.01 SEC. compiling exported ev : PositiveInteger ->$
Time: 0.02 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 tensor : $-> CartesianTensor(One,dim,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 SEC.
compiling exported zero? : $-> Boolean Time: 0.02 SEC. compiling exported One : () ->$
Time: 0 SEC.
compiling exported one? : $-> Boolean Time: 0 SEC. compiling exported I : () ->$
Time: 0.01 SEC.
compiling exported = : ($,$) -> Boolean
Time: 0 SEC.
compiling exported coerce : List PositiveInteger -> $Time: 0.02 SEC. compiling exported coerce : List None ->$
Time: 0 SEC.
compiling exported coerce : K -> $Time: 0.01 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 Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger
Time: 0.01 SEC.
compiling local trailI : FreeMonoid Record(domain: NonNegativeInteger,codomain: NonNegativeInteger,data: CartesianTensor(One,dim,K)) -> NonNegativeInteger
Time: 0.01 SEC.
compiling exported / : ($,$) -> $Time: 0.33 SEC. compiling exported / : (Tuple$,$) ->$
Time: 0.01 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.04 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.01 SEC.
Warnings:
[1] dom:  domain has no value
[2] cod:  codomain has no value
[3] /:  i has no value
[4] /:  j has no value
Cumulative Statistics for Constructor LinearOperator
Time: 0.65 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((tensor ((CartesianTensor (One) dim K) %))): Not documented!!!!
--->-->LinearOperator((I (%))): 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 26 JUL 2013 06:02:52 PM):
; /var/aw/var/LatexWiki/LOP.NRLIB/LOP.fasl written
; compilation finished in 0:00:00.444
------------------------------------------------------------------------
LinearOperator is now explicitly exposed in frame initial
LinearOperator will be automatically loaded when needed from
/var/aw/var/LatexWiki/LOP.NRLIB/LOP

Tests

fricas
L := LOP(OVAR ['1,'2],EXPR INT)
 (1)
Type: Type
fricas
dimension()$L  (2) Type: CardinalNumber? fricas macro Σ(f,i,b) == reduce(+,[f*b.i for i in 1..#b]) Type: Void fricas A:L := Σ( Σ( script(a,[[j],[i]]), i,basisIn()$L), j,basisOut()\$L)
 (3)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
3*A
 (4)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
A/3
 (5)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
I:L := [1]
 (6)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
test( I*I = [1,2] )
 (7)
Type: Boolean
fricas
X:L := [2,1]
 (8)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- printing
I*X*X*I
 (9)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- braid
B3:=(I*X)/(X*I)
 (10)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
test(B3/B3/B3 = I*I*I)
 (11)
Type: Boolean
fricas
-- parallel
(X*X)/(X*X)
 (12)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
-- trace
U:L:=ev(1)
 (13)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
Ω:L:=co(1)
 (14)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))
fricas
Ω/U
 (15)
Type: LinearOperator(OrderedVariableList([1,2]),Expression(Integer))

Various special cases of composition

fricas
-- case 1
test( X/X = [1,2] )
 (16)
Type: Boolean
fricas
test( (I*X)/(I*X) = [1,2,3] )
 (17)
Type: Boolean
fricas
test( (I*X*I)/(I*X*I) = [1,2,3,4] )
 (18)
Type: Boolean
fricas
-- case 2
test( (X*I*I)/(X*X) = [1,2,4,3] )
 (19)
Type: Boolean
fricas
-- case 3
test( (X*X)/(X*I*I) = [1,2,4,3] )
 (20)
Type: Boolean
fricas
-- case 4
test ( (I*I*X)/(X*X) = [2,1,3,4] )
 (21)
Type: Boolean
fricas
-- case 5
test( (I*X*I)/(X*X) = [3,1,4,2] )
 (22)
Type: Boolean
fricas
-- case 6
test( (I*I*X)/(X*I*I)=[2,1,4,3] )
 (23)
Type: Boolean
fricas
test( (I*X)/(X*I) = [3,1,2] )
 (24)
Type: Boolean
fricas
test( (I*X*I)/(X*I*I)=[3,1,2,4] )
 (25)
Type: Boolean
fricas
-- case 7
test( (X*X)/(I*I*X) = [2,1,3,4] )
 (26)
Type: Boolean
fricas
-- case 8
test( (X*I)/(I*X) = [2,3,1] )
 (27)
Type: Boolean
fricas
-- case 9
test( (X*X)/(I*X*I) = [2,4,1,3] )
 (28)
Type: Boolean

 Subject:   Be Bold !! ( 15 subscribers )