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

# Edit detail for SandBoxBiQuaternions revision 3 of 3

 1 2 3 Editor: test1 Time: 2022/06/10 15:22:50 GMT+0 Note:

changed:
-See OverloadProb for some interesting observations and problems that resulted from further
See OverloadProblems for some interesting observations and problems that resulted from further


The Biquaternion calculus support function collection

D. Cyganski - May-June 2007

## Hamiltonian Biquaternions

Define the type Q of Hamiltonian biquaternions (not to be confused with Clifford biquaternions which are an entirely different object)

fricas
C:=Complex Expression Integer
 (1)
Type: Type
fricas
Q:=Quaternion C
 (2)
Type: Type
fricas
q:Q:=quatern(q0,q1,q2,q3)
 (3)
Type: Quaternion(Complex(Expression(Integer)))

Define a function that takes a complex list (parameter l) into a quaternion

fricas
qlist(l:List C):Q==quatern(l.1,l.2,l.3,l.4)
Function declaration qlist : List(Complex(Expression(Integer))) ->
Quaternion(Complex(Expression(Integer))) has been added to
workspace.
Type: Void

Define a function that takes a quaternion into a list

fricas
listq(x:Q):List C == [real x, imagI x, imagJ x, imagK x]
Function declaration listq : Quaternion(Complex(Expression(Integer))
) -> List(Complex(Expression(Integer))) has been added to
workspace.
Type: Void

Define a function that takes a biquat into a matrix

fricas
matrixq(x:Q):Matrix C == matrix _
[[real x + %i*imagI(x), imagJ x + %i*imagK(x)], _
[-imagJ(x) + %i*imagK(x), real x - %i*imagI(x)]]
Function declaration matrixq : Quaternion(Complex(Expression(Integer
))) -> Matrix(Complex(Expression(Integer))) has been added to
workspace.
Type: Void

## The Pauli basis Biquaternions

The quaternion package in axiom is based upon the Hamiltonian basis, i,j,k, in constrast to the Pauli basis used in the Mogan papers which make certain operations correspond more closely (in the sense of visualization as ordering of components is more natural so that classical operations can be easily identified) to vector calculus functions and connect with more directly with various spinor QM formulations. To both follow these papers and obtain these visualization benefits, we will define and use the Pauli basis also.

The Pauli basis in terms of the Hamiltonian quaternion basis

fricas
sig0:=quatern(1,0,0,0)::Q
 (4)
Type: Quaternion(Complex(Expression(Integer)))
fricas
sig1:=%i*quatern(0,0,0,1)::Q
 (5)
Type: Quaternion(Complex(Expression(Integer)))
fricas
sig2:=%i*quatern(0,0,1,0)::Q
 (6)
Type: Quaternion(Complex(Expression(Integer)))
fricas
sig3:=-%i*quatern(0,1,0,0)::Q
 (7)
Type: Quaternion(Complex(Expression(Integer)))

For purposes of manipulation and display it would be best if we either:

1. Copy the quaternion source code and edit it to use sigma_i as symbols for the basis rather than i,j,k and change the definition of multiplication to correspond to this Pauli basis so that all current display and entry functions are flipped to the new basis
2. Use the sigma basis above with the existing package but define a new display function, say sigrep, that can show us the results in Pauli form at will, but otherwise show it in Hamiltonian basis

While 2. is not as natural and convenient, it is easier to code and would automatically provide a development that could be seen in the visually appealing Pauli form, or in the standard Hamiltonian form of biquaternions.

After a quick review and finding no fast path to 2. and not wishing to get into the mechanics of compiling an axiom package instead of working on the physics, I have taken the yet easier path and simply defined the simplest display function that gives me access to seeing Pauli basis results: a list of the the four Pauli basis coefficients.

Define a function that produces the Pauli basis representation of the biquaternion

fricas
siglist(x:Q):List C == _
[real x, -imagK(x)*%i,-imagJ(x)*%i,%i*imagI(x)]
Function declaration siglist : Quaternion(Complex(Expression(Integer
))) -> List(Complex(Expression(Integer))) has been added to
workspace.
Type: Void

## Biquaternion Calculus

Define the quaternion derivative (Morgan, 2001, Eq. 2)

fricas
D(q:Q,x:Symbol,y:Symbol,z:Symbol):Q == _
sig1*D(q,x) + sig2*D(q,y) + sig3*D(q,z)
Function declaration D : (Quaternion(Complex(Expression(Integer))),
Symbol, Symbol, Symbol) -> Quaternion(Complex(Expression(Integer)
)) has been added to workspace.
Type: Void

For testing the derivative we define this set of operators

fricas
Ft:=operator 'Ft; Fx:=operator 'Fx; Fy:=operator 'Fy; Fz:=operator 'Fz;
Type: BasicOperator?

Now form a general quaternion which is a function of x,y,z

fricas
F:Q:=Ft(x,y,z)*sig0+Fx(x,y,z)*sig1+Fy(x,y,z)*sig2+Fz(x,y,z)*sig3
 (8)
Type: Quaternion(Complex(Expression(Integer)))

In the Pauli basis the derivative of this biquat should produce (Morgan 2001, eq 1):

  D(Ft+F.sigma)=div(F)+(grad(Ft)+%i*curl(F)).sigma


which it does

fricas
siglist(D(F,x,y,z))
fricas
Compiling function D with type (Quaternion(Complex(Expression(
Integer))), Symbol, Symbol, Symbol) -> Quaternion(Complex(
Expression(Integer)))
fricas
Compiling function siglist with type Quaternion(Complex(Expression(
Integer))) -> List(Complex(Expression(Integer)))
 (9)
Type: List(Complex(Expression(Integer)))

## Biquaternion Exponential

Define a function that evaluates the Biquat exponential by beginning with the biquat rotation

First let's introduce some refinement to the language we will use. In many texts and papers, the i,j,k or sigma1, sigma2, sigma3 components of the biquaternion are called the imaginary components while the scalar or sigma0 component are called real. This introduces vast confusion when dealing with biquaternions in which there is a "true" imaginary unit, %i being used. We will adopt a variation on the language used by Gsponer and others. A biquat has scalar component a which may have itself an imaginary component. The component is its vector component which again may be complex:

  [0,b,c,d]=[0,Re(b),Re(c),Re(d)]+[0,Im(b),Im(c),Im(d)]=Re(Vec(q))+Im(Vec(q))


Thus, for us, a "real quaternion" has real scalar and vector components and does not refer to a quaternion with only a scalar component as it would in the language adopted by the quatern package in axiom.

The rotation is a function of real number, theta and a unit norm, real vector quaternion. It's form is that of a simple complex quaternion exponential, R(theta,q) = exp(a) where a is an Imaginary Vector quaternion. The result is Unit Norm, Vector quaternion. That is, exponentials of pure imaginary, pure vector quaternions are like exponentials of pure imaginary numbers, resulting in each case in a unit norm object of the same type. For many of our purposes in the representation of relativistic and quantum mechanics it is the only type of quaternion for which we will have to evaluate the exponential.

Define a biquaternion rotation operator that takes a biquat through a rotation of theta radians about the axis defined by the unit q biquat (Morgan 2001, Eq 3).

fricas
rot(theta:Expression Integer,q:Q):Q==cos(theta/2)-%i::Q*q*sin(theta/2)
Function declaration rot : (Expression(Integer), Quaternion(Complex(
Expression(Integer)))) -> Quaternion(Complex(Expression(Integer))
) has been added to workspace.
Type: Void

The rotation is a basis for defining the general exponential, since we can always extract the unit vector corresponding to a given biquaternion, all we need is the biquaternion abs operation, not provided by axiom (note, many texts and papers label the abs which is a complex valued norm^2 by the name "norm" - very bad form -- I've adopted abs as the name to avoid this confusion.

fricas
((x:Q)/(y:Q)):Q == x*inv(y)
Function declaration ?/? : (Quaternion(Complex(Expression(Integer)))
, Quaternion(Complex(Expression(Integer)))) -> Quaternion(Complex
(Expression(Integer))) has been added to workspace.
Type: Void
fricas
abs(q:Q):C == sqrt((q*conjugate(q))::C)
Function declaration abs : Quaternion(Complex(Expression(Integer)))
-> Complex(Expression(Integer)) has been added to workspace.
Type: Void
fricas
exp(q:Q):Q == ( _
q-conjugate(q)=0 => exp( (q+conjugate(q))::C/2)$C * sig0; _ exp( (q+conjugate(q))::C/2)$C * (sig0*cos(abs(q)) + (q-conjugate(q))/abs(q-conjugate(q))*sin(abs(q))) )
Function declaration exp : Quaternion(Complex(Expression(Integer)))
-> Quaternion(Complex(Expression(Integer))) has been added to
workspace.
Type: Void

Test (comment out this test later)

If I've defined these correctly, then the rotation about the x axis defined by qx below by 2 radians should give the same answer as exponentiation to -%i*qx (not a very complete test)

fricas
qx:=sig1
 (10)
Type: Quaternion(Complex(Expression(Integer)))
fricas
siglist(rot(2,qx))
fricas
Compiling function / with type (Quaternion(Complex(Expression(
Integer))), Quaternion(Complex(Expression(Integer)))) ->
Quaternion(Complex(Expression(Integer)))
There are 1 exposed and 7 unexposed library operations named cos
having 1 argument(s) but none was determined to be applicable.
Use HyperDoc Browse, or issue
)display op cos
package-calling the operation or using coercions on the arguments
will allow you to apply the operation.
Cannot find a definition or applicable library operation named cos
with argument type(s)
Quaternion(Complex(Expression(Integer)))
Perhaps you should use "@" to indicate the required return type,
or "$" to specify which version of the function you need. FriCAS will attempt to step through and interpret the code. fricas Compiling function rot with type (Expression(Integer), Quaternion( Complex(Expression(Integer)))) -> Quaternion(Complex(Expression( Integer)))  (11) Type: List(Complex(Expression(Integer))) fricas siglist(exp(-%i::Q*qx)) There are 1 exposed and 9 unexposed library operations named exp having 1 argument(s) but none was determined to be applicable. Use HyperDoc Browse, or issue )display op exp to learn more about the available operations. Perhaps package-calling the operation or using coercions on the arguments will allow you to apply the operation. Cannot find a definition or applicable library operation named exp with argument type(s) Quaternion(Complex(Expression(Integer))) Perhaps you should use "@" to indicate the required return type, or "$" to specify which version of the function you need.
FriCAS will attempt to step through and interpret the code.
fricas
Compiling function exp with type Quaternion(Complex(Expression(
Integer))) -> Quaternion(Complex(Expression(Integer)))
fricas
Compiling function abs with type Quaternion(Complex(Expression(
Integer))) -> Complex(Expression(Integer))
 (12)
Type: List(Complex(Expression(Integer)))

which it does

fricas
(%%(-1)=%%(-2))@Boolean
 (13)
Type: Boolean

To express a proof of equality such as:

   rot(theta,q) = exp((-theta/2)*%i*q)


for arbitrary real and biquaternion real unit vector q as one would in Maple, we need to express the fact that q is a vector quantity with real coefficients in the Pauli basis representing a unit magnitude vector. One way to represent this is to create a quaternion called qnv, representing a general normalized (unit length) vector part only biquat with two independent variables q1 and q2 representing its only degrees of freedom

fricas
qnv:=q1*sig1+q2*sig2+sqrt(1-q1^2-q2^2)*sig3
 (14)
Type: Quaternion(Complex(Expression(Integer)))

## Assumptions about Variables

Now, in the equations that will result, we will obtain subexpressions of the form . The positive root will always be appropriate in this formula and one way to get it (in other computer algebra systems) would be to restrict theta to positive values so as to avoid branches of that would otherwise have to be properly selected to get an equality. Thus, one means to get the desired simplification is to perform the restriction of theta to positive values. My current understanding is: Axiom does not support variables with properties in the sense that Maple does (the "assume" facility).

## Problems

Returning to the case at hand, let's expand a test of equality of the four biquat components and seek a way to prove that each component is zero.

fricas
theta := _\theta
 (15)
Type: Variable(\theta)
fricas
testqeq:=map(simplify, siglist( rot(theta,qnv) - exp((-theta/2)*%i*qnv)))_
::List Expression Complex Integer
 (16)
Type: List(Expression(Complex(Integer)))

As is quite obvious from this result, the two equations would have been shown to be equal if positivity of the theta variable was enforced. This raises two questions: (1) How would one perform a proof such as the above within the allowed operations of Axiom? (2) How can Axiom be called an symbolic algebra system if basic notions of algebraic proof such as restrictions of a variable to the semiring of non-negative integers is disallowed? How are symbolic manipulations, proofs and solutions to be carried out without this basic notion? I am led to think that axiom can only be considered a semi-numerical software system.

## Rules and Pattern Matching

Let's try another way to answer question 1 by using symbolic pattern matching "rules". Define a rule that recognizes the specific case of the variable theta appearing in a construct that should be simplified given its positivity

fricas
posthetaRule:=rule sqrt(theta^2)==theta
 (17)
Type: RewriteRule?(Integer,Integer,Expression(Integer))

But, now we encounter two new problems... a) Apparently "map" does not work with rules, so I can't apply this rule in a simple fashion to the entire List generated by our test case above for any x.

map only maps functions but we can easily turn a rule into an anonymous function:

fricas
map(x+->posthetaRule(x), [0,sqrt(theta^2),0,sqrt(theta^2)])
 (18)
Type: List(Expression(Integer))

b) But even if we were to split our list above, and try to apply this rule to a component, we get this disappointing result

fricas
posthetaRule testqeq.1
There are no library operations named posthetaRule
Use HyperDoc Browse or issue
)what op posthetaRule
to learn if there is any operation containing " posthetaRule " in
its name.
Cannot find a definition or applicable library operation named
posthetaRule with argument type(s)
Expression(Complex(Integer))
Perhaps you should use "@" to indicate the required return type,
or "$" to specify which version of the function you need. Apparently rules have built in assumption about the construction of the expression If I override this for a real element of the list we are testing I can successfully get one answer fricas [posthetaRule (testqeq.i::Expression Integer) for i in 1..1]  (19) Type: List(Expression(Integer)) But this doesn't extend to the remainder of the list fricas [posthetaRule (testqeq.i::Expression Integer) for i in 1..4] Cannot convert the value from type Expression(Complex(Integer)) to Expression(Integer) . because obviously we can't coerce an actually complex value into the Expression Integer type that the rule seems to want. Here is one way to create the necessary rule. Like everything else in Axiom rules are objects in some domain. We need to specify a domain for the rule that is compatible with the domain we wish to manipulate. So let's find out more about this domain: fricas )show RewriteRule RewriteRule(Base: SetCategory,R: Join(Ring,PatternMatchable(Base),Comparable,ConvertibleTo(Pattern(Base))),F: Join(FunctionSpace(R),PatternMatchable(Base),ConvertibleTo(Pattern(Base)))) is a domain constructor Abbreviation for RewriteRule is RULE This constructor is exposed in this frame. ------------------------------- Operations -------------------------------- ?=? : (%, %) -> Boolean coerce : Equation(F) -> % coerce : % -> OutputForm ?.? : (%, F) -> F hash : % -> SingleInteger latex : % -> String lhs : % -> F pattern : % -> Pattern(Base) retract : % -> Equation(F) rhs : % -> F rule : (F, F, List(Symbol)) -> % rule : (F, F) -> % ?~=? : (%, %) -> Boolean elt : (%, F, PositiveInteger) -> F hashUpdate! : (HashState, %) -> HashState quotedOperators : % -> List(Symbol) retractIfCan : % -> Union(Equation(F),"failed") suchThat : (%, List(Symbol), (List(F) -> Boolean)) -> % We can provide satisfactory parameters of this domain constructor as follows: fricas Complex Integer has PatternMatchable Integer  (20) Type: Boolean fricas Expression Complex Integer has FunctionSpace Complex Integer  (21) Type: Boolean fricas Expression Complex Integer has PatternMatchable Integer  (22) Type: Boolean So the following simplification works as hoped: fricas posxRule:=(rule sqrt('theta^2)==theta)$RewriteRule(Integer,Complex Integer,Expression Complex Integer)
 (23)
Type: RewriteRule?(Integer,Complex(Integer),Expression(Complex(Integer)))
fricas
map(x+->posxRule x, testqeq)
 (24)
Type: List(Expression(Complex(Integer)))

## Algebraic Domain of Computation

Recall that Axiom does things in an fundamentally algebraic rather than symbolic way. So although the pattern matching approach works, it goes somewhat against the overall philosophy of Axiom. It is possible to do almost anything by using rewrite rules including things that are mathematically incorrect. In this case the rule is simple and the results obvious but it more complicated situations this can be a problem.

Is there some "axiomatic", i.e. algebraic way to express the fact that is a positive real? Well, what we really need is that

be satisfied. Now consider that by definition of :

fricas
test (sqrt(x)^2=x)
 (25)
Type: Boolean

and so

fricas
test (sqrt(sqrt(x)^2)=sqrt(x))
 (26)
Type: Boolean

for any x. So the expression is one such thing that has the desired property in the Expression domain. With exactly the appropriate loss of generality, let us just suppose that is for some . Then if necessary we can also perform a change of variable back to

fricas
eval(eval(testqeq ,theta=sqrt(beta)),sqrt(beta)=theta)
 (27)
Type: List(Expression(Complex(Integer)))

See OverloadProblems for some interesting observations and problems that resulted from further development of this work with regard to type conversions and function overloading