Edit detail for SandBoxObserverAsIdempotent2 revision 14 of 18

Obs(2) is a 4 dimensional Frobenius Algebra

Generators of Obs(2)

)set output abbreviate on

V := OrderedVariableList [p,q]

(1)

M := FreeMonoid V

(2)

gens:List M := enumerate()$V

(3)

Representation

divisible := Record(lm: M,rm: M)

(4)

leftDiv(k:Union(divisible,"failed")):M == (k::divisible).lm

   Function declaration leftDiv : Union(Record(lm: FMONOID(OVAR([p,q]))
      ,rm: FMONOID(OVAR([p,q]))),"failed") -> FMONOID(OVAR([p,q])) has 
      been added to workspace.

rightDiv(k:Union(divisible,"failed")):M == (k::divisible).rm

   Function declaration rightDiv : Union(Record(lm: FMONOID(OVAR([p,q])
      ),rm: FMONOID(OVAR([p,q]))),"failed") -> FMONOID(OVAR([p,q])) has
      been added to workspace.

K := FRAC POLY INT

(5)

MK := FreeModule(K,M)

(6)

coeff(x:MK):K == leadingCoefficient(x)

   Function declaration coeff : FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))
      ) -> FRAC(POLY(INT)) has been added to workspace.

monomial(x:MK):M == leadingSupport(x)

   Function declaration monomial : FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q
      ]))) -> FMONOID(OVAR([p,q])) has been added to workspace.

m(x:M):Symbol == subscript('m,[retract(x)::Symbol])

   Function declaration m : FMONOID(OVAR([p,q])) -> SYMBOL has been 
      added to workspace.

γ(x:M,y:M):Symbol == subscript('γ,[concat(string retract x, string retract y)::Symbol])

   Function declaration γ : (FMONOID(OVAR([p,q])),FMONOID(OVAR([p,q])))
       -> SYMBOL has been added to workspace.

Basis

basis := concat(gens,concat [[i*j for j in gens | i~=j] for i in gens])

(7)

Idempotent

rule1(ij:MK):MK ==
  for k in gens repeat
    kk := divide(monomial(ij),k*k)
    if kk case divisible then
      ij:=(coeff(ij) * m(k)*γ(k,k)) * (leftDiv(kk) * k * rightDiv(kk))
  return(ij)

   Function declaration rule1 : FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))
      ) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))) has been added to 
      workspace.

Reduction

rule2(ij:MK):MK ==
  for i in gens repeat
    for j in gens | j ~= i repeat
      for k in gens | k ~= j repeat
        ijk:=divide(monomial(ij),i*j*k)
        if ijk case divisible then
          if i=k then
            ij := (coeff(ij)*m(i)*m(j)*γ(i,j)*γ(j,i) ) * _
                  (leftDiv(ijk)*i*rightDiv(ijk))
          else
            ij := (coeff(ij)*m(j)*γ(i,j)*γ(j,k) / γ(i,k) ) * _
                  (leftDiv(ijk)*i*k*rightDiv(ijk))
  return(ij)

   Function declaration rule2 : FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))
      ) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))) has been added to 
      workspace.

An endomorphism on the K-Module is defined by the fixed point of applied rules

mod(ij:MK):MK ==
  ijFix:MK := 1
  while ijFix~=ij repeat
    ijFix := ij
    ij := rule1(ij)
    ij := rule2(ij)
  return(ij)

   Function declaration mod : FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q])))
       -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q]))) has been added to 
      workspace.

Matrix

Algebra is the free algebra product modulo the fixed point

--MT := [[mod(i*j) for j in basis] for i in basis]
-- idempotent
MT := [[monomial(eval(coeff(mod(i*j)),[γ(gens(1),gens(1))=1, γ(gens(2), gens(2))=1, γ(gens(2), gens(1))=γ(gens(1), gens(2))]), monomial(mod(i*j)))$MK for j in basis] for i in basis]

Compiling function monomial with type FM(FRAC(POLY(INT)),FMONOID(
      OVAR([p,q]))) -> FMONOID(OVAR([p,q]))

Compiling function coeff with type FM(FRAC(POLY(INT)),FMONOID(OVAR([
      p,q]))) -> FRAC(POLY(INT))

Compiling function m with type FMONOID(OVAR([p,q])) -> SYMBOL

Compiling function γ with type (FMONOID(OVAR([p,q])),FMONOID(OVAR([p
      ,q]))) -> SYMBOL

Compiling function leftDiv with type Union(Record(lm: FMONOID(OVAR([
      p,q])),rm: FMONOID(OVAR([p,q]))),"failed") -> FMONOID(OVAR([p,q])
      )

Compiling function rightDiv with type Union(Record(lm: FMONOID(OVAR(
      [p,q])),rm: FMONOID(OVAR([p,q]))),"failed") -> FMONOID(OVAR([p,q]
      ))

Compiling function rule1 with type FM(FRAC(POLY(INT)),FMONOID(OVAR([
      p,q]))) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q])))

Compiling function rule2 with type FM(FRAC(POLY(INT)),FMONOID(OVAR([
      p,q]))) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q])))

Compiling function mod with type FM(FRAC(POLY(INT)),FMONOID(OVAR([p,
      q]))) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,q])))

(8)

Structure Constants

R:=FRAC DMP(concat [[m(i) for i in gens],concat [[γ(j,i) for i in gens] for j in gens]], INT)

(9)

mat3(y:M):List List R == map(z+->map(x+->coefficient(x,y)::FRAC POLY INT,z),MT)

   Function declaration mat3 : FMONOID(OVAR([p,q])) -> LIST(LIST(FRAC(
      DMP([m[p],m[q],γ[pp],γ[pq],γ[qp],γ[qq]],INT)))) has been added to
      workspace.

ss:=map(mat3, basis)

Compiling function mat3 with type FMONOID(OVAR([p,q])) -> LIST(LIST(
      FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[qp],γ[qq]],INT))))

(10)

Algebra

cats(m:M):Symbol==concat(map(x+->string(x.gen::Symbol),factors m))::Symbol

   Function declaration cats : FMONOID(OVAR([p,q])) -> SYMBOL has been 
      added to workspace.

A:=AlgebraGivenByStructuralConstants(R,#(basis)::PI,map(cats,basis),ss::Vector(Matrix R))

Compiling function cats with type FMONOID(OVAR([p,q])) -> SYMBOL

(11)

alternative?()$A

   algebra satisfies 2*associator(a,b,b) = 0 = 2*associator(a,a,b) = 0

(12)

antiAssociative?()$A

   algebra is not anti-associative

(13)

antiCommutative?()$A

   algebra is not anti-commutative

(14)

associative?()$A

   algebra is associative

(15)

commutative?()$A

   algebra is not commutative

(16)

flexible?()$A

   algebra is flexible

(17)

jacobiIdentity?()$A

   Jacobi identity does not hold

(18)

jordanAdmissible?()$A

   algebra is not Jordan admissible

(19)

jordanAlgebra?()$A

   algebra is not commutative
   this is not a Jordan algebra

(20)

leftAlternative?()$A

   algebra is left alternative

(21)

lieAdmissible?()$A

   algebra is Lie admissible

(22)

lieAlgebra?()$A

   algebra is not anti-commutative
   this is not a Lie algebra

(23)

--powerAssociative?()$A
rightAlternative?()$A

   algebra is right alternative

(24)

Check Multiplication

AB := entries basis()$A

(25)

A2MK(z:A):MK==reduce(+,map((x:R,y:M):MK+->(x::K)*y,coordinates(z),basis))

   Function declaration A2MK : ALGSC(FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[
      qp],γ[qq]],INT)),4,[p,q,pq,qp],[[[m[p],0,0,m[p]*m[q]*γ[pq]^2],[0,
      0,0,0],[m[p]*m[q]*γ[pq]^2,0,0,m[p]*m[q]^2*γ[pq]^2],[0,0,0,0]],[[0
      ,0,0,0],[0,m[q],m[p]*m[q]*γ[pq]^2,0],[0,0,0,0],[0,m[p]*m[q]*γ[pq]
      ^2,m[p]^2*m[q]*γ[pq]^2,0]],[[0,1,m[p],0],[0,0,0,0],[0,m[q],m[p]*m
      [q]*γ[pq]^2,0],[0,0,0,0]],[[0,0,0,0],[1,0,0,m[q]],[0,0,0,0],[m[p]
      ,0,0,m[p]*m[q]*γ[pq]^2]]]) -> FM(FRAC(POLY(INT)),FMONOID(OVAR([p,
      q]))) has been added to workspace.

test(MT=map(x+->map(A2MK,x),[[i*j for j in AB] for i in AB]))

Compiling function A2MK with type ALGSC(FRAC(DMP([m[p],m[q],γ[pp],γ[
      pq],γ[qp],γ[qq]],INT)),4,[p,q,pq,qp],[[[m[p],0,0,m[p]*m[q]*γ[pq]^
      2],[0,0,0,0],[m[p]*m[q]*γ[pq]^2,0,0,m[p]*m[q]^2*γ[pq]^2],[0,0,0,0
      ]],[[0,0,0,0],[0,m[q],m[p]*m[q]*γ[pq]^2,0],[0,0,0,0],[0,m[p]*m[q]
      *γ[pq]^2,m[p]^2*m[q]*γ[pq]^2,0]],[[0,1,m[p],0],[0,0,0,0],[0,m[q],
      m[p]*m[q]*γ[pq]^2,0],[0,0,0,0]],[[0,0,0,0],[1,0,0,m[q]],[0,0,0,0]
      ,[m[p],0,0,m[p]*m[q]*γ[pq]^2]]]) -> FM(FRAC(POLY(INT)),FMONOID(
      OVAR([p,q])))

(26)

Trace

[rightTrace(i)$A for i in AB]

(27)

[leftTrace(i)$A for i in AB]

(28)

trace(i)==rightTrace(i) / #gens

[trace(i) for i in AB]

Compiling function trace with type ALGSC(FRAC(DMP([m[p],m[q],γ[pp],γ
      [pq],γ[qp],γ[qq]],INT)),4,[p,q,pq,qp],[[[m[p],0,0,m[p]*m[q]*γ[pq]
      ^2],[0,0,0,0],[m[p]*m[q]*γ[pq]^2,0,0,m[p]*m[q]^2*γ[pq]^2],[0,0,0,
      0]],[[0,0,0,0],[0,m[q],m[p]*m[q]*γ[pq]^2,0],[0,0,0,0],[0,m[p]*m[q
      ]*γ[pq]^2,m[p]^2*m[q]*γ[pq]^2,0]],[[0,1,m[p],0],[0,0,0,0],[0,m[q]
      ,m[p]*m[q]*γ[pq]^2,0],[0,0,0,0]],[[0,0,0,0],[1,0,0,m[q]],[0,0,0,0
      ],[m[p],0,0,m[p]*m[q]*γ[pq]^2]]]) -> FRAC(DMP([m[p],m[q],γ[pp],γ[
      pq],γ[qp],γ[qq]],INT))

(29)

Center

C:=basisOfCenter()$AlgebraPackage(R,A); # C

(30)

c:=C(1)

(31)

[c*i-i*c for i in AB]

(32)

test(c*c=c)

(33)

Unit

rightTrace(c)

(34)

n := #basis / rightTrace(c) * c

(35)

trace(n)

(36)

test(n*n=n)

(37)

test(n=unit()$A)

(38)

f:=gcd map(x+->denom x,coordinates(n))

(39)

--ff:= matrix [[γ(i,j)::R for j in gens] for i in gens]
ff:= matrix [[eval(γ(i,j)::R,[γ(gens(1),gens(1))=1,γ(gens(2),gens(2))=1,γ(gens(2),gens(1))=γ(gens(1),gens(2))]) for j in gens] for i in gens]

(40)

--ff:= matrix [[eval(γ(i,j)::R,[γ(gens(1),gens(1))=0,γ(gens(2),gens(2))=0,γ(gens(2),gens(1))=γ(gens(1),gens(2))]) for j in gens] for i in gens]
-determinant(ff)

(41)

test(f = %)

(42)

(f*n)::OutputForm / f::OutputForm

(43)

Lie bracket

p:=AB(1)

(44)

trace(p)

(45)

p*p-trace(p)*p

(46)

q:=AB(2)

(47)

trace(q)

(48)

q*q-trace(q)*q

(49)

p*q

(50)

pq:=p*q-q*p

(51)

trace(pq)

(52)

Orthogonal Observers

p' := trace(p)*n-p

(53)

trace(p')

(54)

p' * p' - trace(p')*p'

(55)

p * p'

(56)

p' * p

(57)

q' := trace(q)*n-q

(58)

trace(q')

(59)

q' * q' - trace(q')*q'

(60)

q * q'

(61)

q' * q

(62)

--
p' * q'

(63)

p * q'

(64)

p' * q

(65)

--
q' * p'

(66)

q * p'

(67)

q' * p

(68)

Orthogonal Observers are Derivations

p'*(p*q) = (p'*p)*q + p*(p'*q)

(69)

test %

(70)

q'*(p*q) = (q'*p)*q + p*(q'*q)

(71)

test %

(72)

Antisymmetric γ

eqAnti:List Equation EXPR INT := concat [[(i>j => γ(i,j)=γ(i,j);i=j =>γ(i,j)=0;γ(i,j)=-γ(j,i)) for j in gens] for i in gens]

(73)

anti(x:R):R == subst(x::EXPR INT, eqAnti)::FRAC POLY INT

   Function declaration anti : FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[qp],γ[
      qq]],INT)) -> FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[qp],γ[qq]],INT)) 
      has been added to workspace.

(anti(f)*map(anti ,coordinates(n))::A)::OutputForm / anti(f)::OutputForm

Compiling function anti with type FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[
      qp],γ[qq]],INT)) -> FRAC(DMP([m[p],m[q],γ[pp],γ[pq],γ[qp],γ[qq]],
      INT))

(74)

Momentum

P:=reduce(+,concat [[(1/γ(basis(i),basis(j)))::R*AB(i)*AB(j) for j in 1..size()$V] for i in 1..size()$V])

(75)

trace(P)

(76)

c:=1/trace(P)*P

(77)

c*c-c

(78)

trace(c)

(79)

Scalar Product

S := matrix [[trace(x*y) for y in AB] for x in AB]

(80)

)sh ALGSC

 ALGSC(R: FIELD,n: PI,ls: LIST(SYMBOL),gamma: VECTOR(MATRIX(R))) is a domain constructor
 Abbreviation for AlgebraGivenByStructuralConstants is ALGSC 
 This constructor is exposed in this frame.
------------------------------- Operations --------------------------------
 ?*? : (SQMATRIX(n,R),%) -> %          ?*? : (R,%) -> %
 ?*? : (%,R) -> %                      ?*? : (NNI,%) -> %
 ?*? : (INT,%) -> %                    ?*? : (%,%) -> %
 ?*? : (PI,%) -> %                     ?+? : (%,%) -> %
 -? : % -> %                           ?-? : (%,%) -> %
 ?=? : (%,%) -> BOOLEAN                0 : () -> %
 ?^? : (%,PI) -> %                     alternative? : () -> BOOLEAN
 antiAssociative? : () -> BOOLEAN      antiCommutative? : () -> BOOLEAN
 antiCommutator : (%,%) -> %           apply : (MATRIX(R),%) -> %
 associative? : () -> BOOLEAN          associator : (%,%,%) -> %
 basis : () -> VECTOR(%)               coerce : VECTOR(R) -> %
 coerce : % -> OUTFORM                 commutative? : () -> BOOLEAN
 commutator : (%,%) -> %               convert : % -> VECTOR(R)
 convert : VECTOR(R) -> %              coordinates : % -> VECTOR(R)
 ?.? : (%,INT) -> R                    flexible? : () -> BOOLEAN
 hash : % -> SINT                      jacobiIdentity? : () -> BOOLEAN
 jordanAdmissible? : () -> BOOLEAN     jordanAlgebra? : () -> BOOLEAN
 latex : % -> STRING                   leftAlternative? : () -> BOOLEAN
 leftDiscriminant : () -> R            leftDiscriminant : VECTOR(%) -> R
 leftNorm : % -> R                     leftPower : (%,PI) -> %
 leftTrace : % -> R                    leftTraceMatrix : () -> MATRIX(R)
 lieAdmissible? : () -> BOOLEAN        lieAlgebra? : () -> BOOLEAN
 opposite? : (%,%) -> BOOLEAN          plenaryPower : (%,PI) -> %
 powerAssociative? : () -> BOOLEAN     rank : () -> PI
 represents : VECTOR(R) -> %           rightAlternative? : () -> BOOLEAN
 rightDiscriminant : () -> R           rightNorm : % -> R
 rightPower : (%,PI) -> %              rightTrace : % -> R
 rightTraceMatrix : () -> MATRIX(R)    sample : () -> %
 someBasis : () -> VECTOR(%)           zero? : % -> BOOLEAN
 ?~=? : (%,%) -> BOOLEAN              
 associatorDependence : () -> LIST(VECTOR(R)) if R has INTDOM
 conditionsForIdempotents : () -> LIST(POLY(R))
 conditionsForIdempotents : VECTOR(%) -> LIST(POLY(R))
 convert : % -> INFORM if R has FINITE
 coordinates : VECTOR(%) -> MATRIX(R)
 coordinates : (VECTOR(%),VECTOR(%)) -> MATRIX(R)
 coordinates : (%,VECTOR(%)) -> VECTOR(R)
 enumerate : () -> LIST(%) if R has FINITE
 hashUpdate! : (HASHSTAT,%) -> HASHSTAT
 index : PI -> % if R has FINITE
 leftCharacteristicPolynomial : % -> SUP(R)
 leftMinimalPolynomial : % -> SUP(R) if R has INTDOM
 leftRankPolynomial : () -> SUP(POLY(R)) if R has FIELD
 leftRecip : % -> Union(%,"failed") if R has INTDOM
 leftRegularRepresentation : % -> MATRIX(R)
 leftRegularRepresentation : (%,VECTOR(%)) -> MATRIX(R)
 leftTraceMatrix : VECTOR(%) -> MATRIX(R)
 leftUnit : () -> Union(%,"failed") if R has INTDOM
 leftUnits : () -> Union(Record(particular: %,basis: LIST(%)),"failed") if R has INTDOM
 lookup : % -> PI if R has FINITE
 noncommutativeJordanAlgebra? : () -> BOOLEAN
 random : () -> % if R has FINITE
 recip : % -> Union(%,"failed") if R has INTDOM
 represents : (VECTOR(R),VECTOR(%)) -> %
 rightCharacteristicPolynomial : % -> SUP(R)
 rightDiscriminant : VECTOR(%) -> R
 rightMinimalPolynomial : % -> SUP(R) if R has INTDOM
 rightRankPolynomial : () -> SUP(POLY(R)) if R has FIELD
 rightRecip : % -> Union(%,"failed") if R has INTDOM
 rightRegularRepresentation : % -> MATRIX(R)
 rightRegularRepresentation : (%,VECTOR(%)) -> MATRIX(R)
 rightTraceMatrix : VECTOR(%) -> MATRIX(R)
 rightUnit : () -> Union(%,"failed") if R has INTDOM
 rightUnits : () -> Union(Record(particular: %,basis: LIST(%)),"failed") if R has INTDOM
 size : () -> NNI if R has FINITE
 smaller? : (%,%) -> BOOLEAN if R has FINITE
 structuralConstants : () -> VECTOR(MATRIX(R))
 structuralConstants : VECTOR(%) -> VECTOR(MATRIX(R))
 subtractIfCan : (%,%) -> Union(%,"failed")
 unit : () -> Union(%,"failed") if R has INTDOM