Axiom Pauli Matrix Implementation

The PauliMatrix is a square matrix which can be represented by a linear combination of basis matrices.

I'm not sure if this is the best name as I think this is a bit more general than the matrices that arise in Pauli's treatment of spin in quantum mechanics?

One application of this is to find matrix representation isomorphic to a given Clifford Algebra.

There are two reasons that make this useful:


(1) -> P := PauliMatrix(Integer,2,2)

   (1)  PauliMatrix(Integer,2,2)
                                                             Type: Type
(2) -> a := matrix([[1,2],[3,4]])$P

        +1  2+
   (2)  |    |
        +3  4+
                                         Type: PauliMatrix(Integer,2,2)
(3) -> a*a

        +7   10+
   (3)  |      |
        +15  22+
                                         Type: PauliMatrix(Integer,2,2)
(4) ->

Rafal Ablamowicz method: (Also see Pertti Lounesto 2nd ed P225) A matrix will itself satisfy the characteristic polynomial equation obeyed by its own eigenvalues and that therefore the equivalent Clifford number will also obey the same characteristic equation

det(A - λ I) = 0

where

Example 1 - Two Dimensional Case

The bilinear form is:

a11 a12
a21 a22

m1*m2 = m1 /\ m2 + bilinear(m1,m2)

m1*m1 = m1 /\ m1 + bilinear(m1,m1) = bilinear(m1,m1)

(1) -> )library CLIF
   CliffordAlgebra is now explicitly exposed in frame frame1
   CliffordAlgebra will be automatically loaded when needed from
      /home/martin/CLIF.NRLIB/CLIF
(1)->B:=CliffordAlgebra(2,Expression(Fraction(Integer)),[[a1,a2],[a3,a4]])

   (1)  CliffordAlgebra(2,Expression(Fraction(Integer)),[[a1,a2],[a3,a4]])
                                                               Type: Type
(2) -> C:B := multivector[c1,c2,c3,c4]

   (2)  c1 + c2 e  + c3 e  + c4 e e
                 1       2       1 2
  Type: CliffordAlgebra(2,Expression(Fraction(Integer)),[[a1,a2],[a3,a4]])
(3) -> C*C

   (3)
                        2        2                         2     2
     (- a1 a4 + a2 a3)c4  + a4 c3  + (a3 + a2)c2 c3 + a1 c2  + c1
   +
     ((a3 - a2)c2 c4 + 2c1 c2)e  + ((a3 - a2)c3 c4 + 2c1 c3)e
                               1                             2
   +
                 2
     ((a3 - a2)c4  + 2c1 c4)e e
                             1 2
  Type: CliffordAlgebra(2,Expression(Fraction(Integer)),[[a1,a2],[a3,a4]])
(4) ->

:

a11 = 1 a12 = 0
a21 = 0 a22 = 1

 

(1) -> )library CLIF
   CliffordAlgebra is now explicitly exposed in frame frame1
   CliffordAlgebra will be automatically loaded when needed from
      /home/martin/CLIF.NRLIB/CLIF
(1) -> B := CliffordAlgebra(2,Expression(Fraction(Integer)),[[1,0],[0,1]])

   (1)  CliffordAlgebra(2,Expression(Fraction(Integer)),[[1,0],[0,1]])
                                                               Type: Type
(2) -> C:B := multivector[c1,c2,c3,c4]

   (2)  c1 + c2 e  + c3 e  + c4 e e
                 1       2       1 2
     Type: CliffordAlgebra(2,Expression(Fraction(Integer)),[[1,0],[0,1]])
(3) -> C*C

            2     2     2     2
   (3)  - c4  + c3  + c2  + c1  + 2c1 c2 e  + 2c1 c3 e  + 2c1 c4 e e
                                          1           2           1 2
     Type: CliffordAlgebra(2,Expression(Fraction(Integer)),[[1,0],[0,1]])
(4) ->

c1 = - c4² + c3² + c2² + c1²

c2 = 2c1 c2

c3 = 2c1 c3

c4 = 2c1 c4

so:

c1 = 1/2

1/4 = - c4² + c3² + c2²

We need to find primitive idempotent (it squares to itself). So an idempotent is:

ƒ=½(1+e1)

because:

ƒ=ƒ²

since:

ƒ²= ¼(1+e1)(1+e1) = ¼(1 + 2e1+ e1²) = ¼(2e1+ 2e1) =½(1+e1) = ƒ

so if we take ƒ as the first base, to get the other bases we take all combinations:

ƒ1 =ƒ=½(1+e1)

ƒ2 =e2ƒ = ½e2(1+e1) = ½(1- e1)e2

ƒ3 =ƒe2 = ½(1+e1) e2

ƒ4 =e2ƒe2 = ½ e2(1+e1) e2 = ½ (1-e1)

 

A ƒ =
a11ƒ a12ƒ
a21ƒ a22ƒ
=
a0 + a1 a2 + a3
a2 - a3 a0 - a1
ƒ

Converting Instances

a11 a12
a21 a22
= m1
b11 b12
b21 b22
+ m2
c11 c12
c21 c22
+ m3
d11 d12
d21 d22
+ m4
e11 e12
e21 e22

 

a11 a12
a21 a22
=
m1 b11 + m2 c11 + m3 d11 + m4 e11 m1 b12 + m2 c12 + m3 d12 + m4 e12
m1 b21 + m2 c21 + m3 d21 + m4 e21 m1 b22 + m2 c22 + m3 d22 + m4 e22

a11
a12
a21
a22
=
m1 b11 + m2 c11 + m3 d11 + m4 e11
m1 b12 + m2 c12 + m3 d12 + m4 e12
m1 b21 + m2 c21 + m3 d21 + m4 e21
m1 b22 + m2 c22 + m3 d22 + m4 e22

a11
a12
a21
a22
=
b11 c11 d11 e11
b21 c21 d21 e21
b12 c12 d12 e12
b22 c22 d22 e22
m1
m2
m3
m4

 

 

Compute the inverse using the coefficients from the polynomial.

 

Pauli Matrix

For two dimensions the Pauli matricies would be:

b1 := matrix[[1,0],[0,-1]]
b2 := matrix[[0,1],[1,0]]

These square to 1:

(3) -> b1*b1

        +1  0+
   (3)  |    |
        +0  1+
                                                    Type: Matrix(Integer)
(4) -> b2*b2

        +1  0+
   (4)  |    |
        +0  1+
                                                    Type: Matrix(Integer) 

For three dimensions the Pauli matricies would be:

b1 := matrix[[1,0],[0,1]]                                             
b2 := matrix[[1,0],[0,-1]]                                            
b3 := matrix[[0,1],[1,0]]                                             
b4 := matrix[[0,%i],[-%i,0]]

Which square to one:

(5) -> b1*b1

        +1  0+
   (5)  |    |
        +0  1+
                                                    Type: Matrix(Integer)
(6) -> b2*b2

        +1  0+
   (6)  |    |
        +0  1+
                                                    Type: Matrix(Integer)
(7) -> b3*b3

        +1  0+
   (7)  |    |
        +0  1+
                                                    Type: Matrix(Integer)

(13) -> b4*b4

         +1  0+
   (13)  |    |
         +0  1+
                                            Type: Matrix(Complex(Integer))

Power Sets

A set S, the power set (or powerset) of S, written P(S) or 2S, is the set of all subsets of S, including the empty set and S itself.

(1) -> P :=PauliMatrix(2,Float,[matrix[[1,0],[0,-1]],matrix[[0,1],[1,0]]])

   (1)  PauliMatrix(2,Float,[MATRIX,MATRIX])
                                                               Type: Type
(2) -> localPowerSets(1)$P

   (2)  [[1],[]]
                                         Type: List(List(PositiveInteger))
(3) -> localPowerSets(2)$P

   (3)  [[2],[2,1],[1],[]]
                                         Type: List(List(PositiveInteger))
(4) -> localPowerSets(3)$P

   (4)  [[3],[3,1],[3,2,1],[3,2],[2],[2,1],[1],[]]
                                         Type: List(List(PositiveInteger))
(5) -> localPowerSets(4)$P

   (5)
   [[4], [4,1], [4,2,1], [4,2], [4,3,2], [4,3,2,1], [4,3,1], [4,3], [3],
    [3,1],[3,2,1], [3,2], [2], [2,1], [1], []]
                                         Type: List(List(PositiveInteger))
(6) ->

Discussion

See this thread on FriCAS forum.


metadata block
see also:
Correspondence about this page

Book Shop - Further reading.

Where I can, I have put links to Amazon for books that are relevant to the subject, click on the appropriate country flag to get more details of the book or to buy it from them.

flag flag flag flag flag flag Axiom Volume 1: Tutorial. Documentation is freely availible from: http://www.axiom-developer.org/axiom-website/documentation.html

 

This site may have errors. Don't use for critical systems.

Copyright (c) 1998-2017 Martin John Baker - All rights reserved - privacy policy.