login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit
The Algebra of Complex Numbers Is Frobenius In Many Ways
  ↑  

CaleyDickson
  
last edited 1 year ago by Bill Page

Edit detail for CaleyDickson revision 2 of 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Editor: Bill Page
Time: 2011/04/16 11:06:09 GMT-7
Note: better 
changed:
-CaleyDickson(R:CommutativeRing,C:ComplexCategory(R)):Exports == Implementation where
CaleyDickson(R:CommutativeRing,C:CommutativeRing,gamma:C):Exports == Implementation where

removed:
-
-    0:% == per pair(0,0)
-    zero?(x):Boolean == rep(x)=0
-    1:% == per pair(1,0)
-    imaginary():% == per pair(0,1)
-    basis():Vector % == vector [1,imaginary()]

changed:
-    (x:% = y:%):Boolean == rep x = rep y
-    (x:% * y:%):% == per pair(real x * real y - conjugate imag y * imag x, imag y * real x + imag x * conjugate real y)
-    (x:% + y:%):% == per(rep x + rep y)
-    (x:% - y:%):% == per(rep x - rep y)
-    conjugate(x:%):% == per pair(conjugate(real x), -imag x)
    0:% == complex(0,0)
    zero?(x:%):Boolean == zero? rep(x)
    1:% == per pair(1,0)
    one?(x:%):Boolean  == one? real x and zero? imag x

    if C has ComplexCategory(R) then
      -- In general we need conjugate
      (x:% * y:%):% == complex(real x * real y - gamma*conjugate imag y * imag x,
                               imag y * real x + imag x * conjugate real y)
      conjugate(x:%):% == complex(conjugate(real x), -imag x)
    else
      -- If not complex then conjugate is identity
      (x:% * y:%):% == complex(real x * real y - gamma*imag y * imag x,
                               imag y * real x + imag x * real y)
      conjugate(x:%):% == per pair(real x, -imag x)


removed:
-    retract(x:%):C ==
-       imag x ~=0 => error "not retractable"
-       real x

changed:
-    coerce(x:Integer):% == per pair(x::R::C,0)
-    coerce(x:%):OutputForm == real(x)::OutputForm + message("%I")*imag(x)::OutputForm
    --
    -- The following and many other funtctions are inherited from ComplexCategory
    --
    -- To Do:
    -- 1) Check which other functions are still correct for higher-order algebras!
    --
    --basis():Vector % == vector [1,imaginary()]
    --(x:% - y:%):% == per(rep x - rep y)
    --imaginary():% == complex(0,1)
    --retract(x:%):C ==
    --   imag x ~=0 => error "not retractable"
    --   real x
    --coerce(x:Integer):% == per pair(x::R::C,0)
    coerce(x:%):OutputForm ==
      --imag x = 0 => real(x)::OutputForm
      --imag x = 1 => real(x)::OutputForm + message("%i")
      real(x)::OutputForm + message("%i")*paren(imag(x)::OutputForm)

    -- re-defined these just to save function calls
    (x:% + y:%):% == per(rep x + rep y)
    (x:% = y:%):Boolean == rep x = rep y

added:
Test


changed:
-Q:=CaleyDickson(FRAC INT,Complex FRAC INT)
-q:Q:=complex(complex(1,1),complex(1,1))
)set output tex off
)set output algebra on

added:

Complex Numbers
\begin{axiom}
C:=CaleyDickson(FRAC INT, FRAC INT,1)
gens1:List C:=[complex(1,0),complex(0,1)]
matrix [[gens1.i * gens1.j for j in 1..#gens1] for i in 1..#gens1]
--
-- compare
--
gens2:List Complex(FRAC INT):=[1,imaginary()]
matrix [[gens2.i * gens2.j for j in 1..#gens2] for i in 1..#gens2]
\end{axiom}

Quaternions
\begin{axiom}
Q:=CaleyDickson(FRAC INT,C,1)
gens3:List Q:=[ _
  complex(complex(1,0)$C,complex(0,0)$C), _
  complex(complex(0,1)$C,complex(0,0)$C), _
  complex(complex(0,0)$C,complex(1,0)$C), _
  complex(complex(0,0)$C,complex(0,1)$C)]
matrix [[gens3.i * gens3.j for j in 1..#gens3] for i in 1..#gens3]
--
-- compare
--
gens4:List Quaternion(FRAC INT):=[ _
  quatern(1,0,0,0), _
  quatern(0,1,0,0), _
  quatern(0,0,1,0), _
  quatern(0,0,0,1)]
matrix [[gens4.i * gens4.j for j in 1..#gens4] for i in 1..#gens4]
\end{axiom}

Ref:

http://en.wikipedia.org/wiki/Cayley%E2%80%93Dickson_construction

"The Cayley–Dickson construction, named after Arthur Cayley and Leonard Eugene Dickson, produces a sequence of algebras over the field of real numbers, each with twice the dimension of the previous one. The algebras produced by this process are known as Cayley–Dickson algebras; since they extend the complex numbers, ... "

complex numbers, quaternions, octonions, sedenions, ...

spad
)abbrev domain CALEY CaleyDickson
CaleyDickson(R:CommutativeRing,C:CommutativeRing,gamma:C):Exports == Implementation where
  Exports ==> ComplexCategory(C) with
    if C has Field then Field
  Implementation ==> add
    Rep == DirectProduct(2,C)
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    pair(x:C,y:C):Rep == directProduct vector [x,y]
    complex(x:C,y:C):% == per pair(x,y)
    real(x:%):C == rep(x).1
    imag(x:%):C == rep(x).2

    0:% == complex(0,0)
    zero?(x:%):Boolean == zero? rep(x)
    1:% == per pair(1,0)
    one?(x:%):Boolean  == one? real x and zero? imag x

    if C has ComplexCategory(R) then
      -- In general we need conjugate
      (x:% * y:%):% == complex(real x * real y - gamma*conjugate imag y * imag x,
                               imag y * real x + imag x * conjugate real y)
      conjugate(x:%):% == complex(conjugate(real x), -imag x)
    else
      -- If not complex then conjugate is identity
      (x:% * y:%):% == complex(real x * real y - gamma*imag y * imag x,
                               imag y * real x + imag x * real y)
      conjugate(x:%):% == per pair(real x, -imag x)

    if C has Field then
      inv(x:%):% == per(inv(real(conjugate x * x))$C * rep conjugate x)
      (x:% / y:%):% == x * inv(y)
    coerce(x:C):% == per pair(x,0)
    --
    -- The following and many other funtctions are inherited from ComplexCategory
    --
    -- To Do:
    -- 1) Check which other functions are still correct for higher-order algebras!
    --
    --basis():Vector % == vector [1,imaginary()]
    --(x:% - y:%):% == per(rep x - rep y)
    --imaginary():% == complex(0,1)
    --retract(x:%):C ==
    --   imag x ~=0 => error "not retractable"
    --   real x
    --coerce(x:Integer):% == per pair(x::R::C,0)
    coerce(x:%):OutputForm ==
      --imag x = 0 => real(x)::OutputForm
      --imag x = 1 => real(x)::OutputForm + message("%i")
      real(x)::OutputForm + message("%i")*paren(imag(x)::OutputForm)

    -- re-defined these just to save function calls
    (x:% + y:%):% == per(rep x + rep y)
    (x:% = y:%):Boolean == rep x = rep y
spad
   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/4173995386861702799-25px001.spad using 
      old system compiler.
   CALEY abbreviates domain CaleyDickson 
------------------------------------------------------------------------
   initializing NRLIB CALEY for CaleyDickson 
   compiling into NRLIB CALEY 
****** Domain: C already in scope
   compiling local rep : $ -> DirectProduct(2,C)
      CALEY;rep is replaced by x 
Time: 0.54 SEC.

   compiling local per : DirectProduct(2,C) -> $
      CALEY;per is replaced by x 
Time: 0.01 SEC.

   compiling local pair : (C,C) -> DirectProduct(2,C)
Time: 0.02 SEC.

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

   compiling exported real : $ -> C
Time: 0.01 SEC.

   compiling exported imag : $ -> C
Time: 0.01 SEC.

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

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

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

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

****** Domain: C already in scope
augmenting C: (ComplexCategory R)
   compiling exported * : ($,$) -> $
Time: 0.09 SEC.

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

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

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

****** Domain: C already in scope
augmenting C: (Field)
   compiling exported inv : $ -> $
Time: 0.05 SEC.

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

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

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

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

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

****** Domain: C already in scope
augmenting C: (EuclideanDomain)
****** Domain: C already in scope
augmenting C: (PolynomialFactorizationExplicit)
****** Domain: C already in scope
augmenting C: (RadicalCategory)
****** Domain: C already in scope
augmenting C: (TranscendentalFunctionCategory)
****** Domain: C already in scope
augmenting C: (RealNumberSystem)
****** Domain: C already in scope
augmenting C: (TranscendentalFunctionCategory)
****** Domain: C already in scope
augmenting C: (Comparable)
****** Domain: C already in scope
augmenting C: (ConvertibleTo (InputForm))
****** Domain: C already in scope
augmenting C: (ConvertibleTo (Pattern (Float)))
****** Domain: C already in scope
augmenting C: (ConvertibleTo (Pattern (Integer)))
****** Domain: C already in scope
augmenting C: (DifferentialRing)
****** Domain: C already in scope
augmenting C: (Eltable C C)
****** Domain: C already in scope
augmenting C: (EuclideanDomain)
****** Domain: C already in scope
augmenting C: (Evalable C)
****** Domain: C already in scope
augmenting C: (Field)
****** Domain: C already in scope
augmenting C: (Finite)
****** Domain: C already in scope
augmenting C: (FiniteFieldCategory)
****** Domain: C already in scope
augmenting C: (InnerEvalable (Symbol) C)
****** Domain: C already in scope
augmenting C: (IntegerNumberSystem)
****** Domain: C already in scope
augmenting C: (IntegralDomain)
****** Domain: C already in scope
augmenting C: (LinearlyExplicitRingOver (Integer))
****** Domain: C already in scope
augmenting C: (PartialDifferentialRing (Symbol))
****** Domain: C already in scope
augmenting C: (PatternMatchable (Float))
****** Domain: C already in scope
augmenting C: (PatternMatchable (Integer))
****** Domain: C already in scope
augmenting C: (RealConstant)
****** Domain: C already in scope
augmenting C: (RealNumberSystem)
****** Domain: C already in scope
augmenting C: (RetractableTo (Fraction (Integer)))
****** Domain: C already in scope
augmenting C: (RetractableTo (Integer))
****** Domain: C already in scope
augmenting C: (TranscendentalFunctionCategory)
(time taken in buildFunctor:  3140)

;;;     ***       |CaleyDickson| REDEFINED

;;;     ***       |CaleyDickson| REDEFINED
Time: 3.50 SEC.

   Cumulative Statistics for Constructor CaleyDickson
      Time: 4.28 seconds

   finalizing NRLIB CALEY 
   Processing CaleyDickson for Browser database:
--->-->CaleyDickson(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/CALEY.NRLIB/CALEY.lsp" (written 16 APR 2011 11:06:06 AM):

; /var/zope2/var/LatexWiki/CALEY.NRLIB/CALEY.fasl written
; compilation finished in 0:00:00.685
------------------------------------------------------------------------
   CaleyDickson is now explicitly exposed in frame initial 
   CaleyDickson will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/CALEY.NRLIB/CALEY

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

Test

axiom
)set output tex off
axiom
)set output algebra on

Complex Numbers

axiom
C:=CaleyDickson(FRAC INT, FRAC INT,1)

   (1)  CaleyDickson(Fraction(Integer),Fraction(Integer),1)
Type: Type
axiom
gens1:List C:=[complex(1,0),complex(0,1)]

   (2)  [1 + %i(0),0 + %i(1)]
Type: List(CaleyDickson?(Fraction(Integer),Fraction(Integer),1))
axiom
matrix [[gens1.i * gens1.j for j in 1..#gens1] for i in 1..#gens1]

        +1 + %i(0)   0 + %i(1) +
   (3)  |                      |
        +0 + %i(1)  - 1 + %i(0)+
Type: Matrix(CaleyDickson?(Fraction(Integer),Fraction(Integer),1))
axiom
--
-- compare
--
gens2:List Complex(FRAC INT):=[1,imaginary()]

   (4)  [1,%i]
Type: List(Complex(Fraction(Integer)))
axiom
matrix [[gens2.i * gens2.j for j in 1..#gens2] for i in 1..#gens2]

        +1   %i +
   (5)  |       |
        +%i  - 1+
Type: Matrix(Complex(Fraction(Integer)))

Quaternions

axiom
Q:=CaleyDickson(FRAC INT,C,1)

   (6)
  CaleyDickson(Fraction(Integer),CaleyDickson(Fraction(Integer),Fraction(Intege
  r),1),1+(%i)*PAREN(0))
Type: Type
axiom
gens3:List Q:=[ _
  complex(complex(1,0)$C,complex(0,0)$C), _
  complex(complex(0,1)$C,complex(0,0)$C), _
  complex(complex(0,0)$C,complex(1,0)$C), _
  complex(complex(0,0)$C,complex(0,1)$C)]

   (7)
   [1 + %i(0) + %i(0 + %i(0)), 0 + %i(1) + %i(0 + %i(0)),
    0 + %i(0) + %i(1 + %i(0)), 0 + %i(0) + %i(0 + %i(1))]
Type: List(CaleyDickson?(Fraction(Integer),CaleyDickson?(Fraction(Integer),Fraction(Integer),1),1+()*PAREN(0)))
axiom
matrix [[gens3.i * gens3.j for j in 1..#gens3] for i in 1..#gens3]

   (8)
   [
     [1 + %i(0) + %i(0 + %i(0)), 0 + %i(1) + %i(0 + %i(0)),
      0 + %i(0) + %i(1 + %i(0)), 0 + %i(0) + %i(0 + %i(1))]
     ,

     [0 + %i(1) + %i(0 + %i(0)), - 1 + %i(0) + %i(0 + %i(0)),
      0 + %i(0) + %i(0 + %i(1)), 0 + %i(0) + %i(- 1 + %i(0))]
     ,

     [0 + %i(0) + %i(1 + %i(0)), 0 + %i(0) + %i(0 + %i(- 1)),
      - 1 + %i(0) + %i(0 + %i(0)), 0 + %i(1) + %i(0 + %i(0))]
     ,

     [0 + %i(0) + %i(0 + %i(1)), 0 + %i(0) + %i(1 + %i(0)),
      0 + %i(- 1) + %i(0 + %i(0)), - 1 + %i(0) + %i(0 + %i(0))]
     ]
Type: Matrix(CaleyDickson?(Fraction(Integer),CaleyDickson?(Fraction(Integer),Fraction(Integer),1),1+()*PAREN(0)))
axiom
--
-- compare
--
gens4:List Quaternion(FRAC INT):=[ _
  quatern(1,0,0,0), _
  quatern(0,1,0,0), _
  quatern(0,0,1,0), _
  quatern(0,0,0,1)]

   (9)  [1,i,j,k]
Type: List(Quaternion(Fraction(Integer)))
axiom
matrix [[gens4.i * gens4.j for j in 1..#gens4] for i in 1..#gens4]

         +1   i    j    k +
         |                |
         |i  - 1   k   - j|
   (10)  |                |
         |j  - k  - 1   i |
         |                |
         +k   j   - i  - 1+
Type: Matrix(Quaternion(Fraction(Integer)))