Jordan Algebras

AUTHORS:

  • Travis Scrimshaw (2014-04-02): initial version
class sage.algebras.jordan_algebra.JordanAlgebra

Bases: sage.structure.parent.Parent, sage.structure.unique_representation.UniqueRepresentation

A Jordan algebra.

A Jordan algebra is a magmatic algebra (over a commutative ring \(R\)) whose multiplication satisfies the following axioms:

  • \(xy = yx\), and
  • \((xy)(xx) = x(y(xx))\) (the Jordan identity).

See [Ja1971], [Ch2012], and [McC1978], for example.

These axioms imply that a Jordan algebra is power-associative and the following generalization of Jordan’s identity holds [Al1947]: \((x^m y) x^n = x^m (y x^n)\) for all \(m, n \in \ZZ_{>0}\).

Let \(A\) be an associative algebra over a ring \(R\) in which \(2\) is invertible. We construct a Jordan algebra \(A^+\) with ground set \(A\) by defining the multiplication as

\[x \circ y = \frac{xy + yx}{2}.\]

Often the multiplication is written as \(x \circ y\) to avoid confusion with the product in the associative algebra \(A\). We note that if \(A\) is commutative then this reduces to the usual multiplication in \(A\).

Jordan algebras constructed in this fashion, or their subalgebras, are called special. All other Jordan algebras are called exceptional.

Jordan algebras can also be constructed from a module \(M\) over \(R\) with a symmetric bilinear form \((\cdot, \cdot) : M \times M \to R\). We begin with the module \(M^* = R \oplus M\) and define multiplication in \(M^*\) by

\[(\alpha + x) \circ (\beta + y) = \underbrace{\alpha \beta + (x,y)}_{\in R} + \underbrace{\beta x + \alpha y}_{\in M}\]

where \(\alpha, \beta \in R\) and \(x,y \in M\).

INPUT:

Can be either an associative algebra \(A\) or a symmetric bilinear form given as a matrix (possibly followed by, or preceded by, a base ring argument)

EXAMPLES:

We let the base algebra \(A\) be the free algebra on 3 generators:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F); J
Jordan algebra of Free Algebra on 3 generators (x, y, z) over Rational Field
sage: a,b,c = map(J, F.gens())
sage: a*b
1/2*x*y + 1/2*y*x
sage: b*a
1/2*x*y + 1/2*y*x

Jordan algebras are typically non-associative:

sage: (a*b)*c
1/4*x*y*z + 1/4*y*x*z + 1/4*z*x*y + 1/4*z*y*x
sage: a*(b*c)
1/4*x*y*z + 1/4*x*z*y + 1/4*y*z*x + 1/4*z*y*x

We check the Jordan identity:

sage: (a*b)*(a*a) == a*(b*(a*a))
True
sage: x = a + c
sage: y = b - 2*a
sage: (x*y)*(x*x) == x*(y*(x*x))
True

Next we construct a Jordan algebra from a symmetric bilinear form:

sage: m = matrix([[-2,3],[3,4]])
sage: J.<a,b,c> = JordanAlgebra(m); J
Jordan algebra over Integer Ring given by the symmetric bilinear form:
[-2  3]
[ 3  4]
sage: a
1 + (0, 0)
sage: b
0 + (1, 0)
sage: x = 3*a - 2*b + c; x
3 + (-2, 1)

We again show that Jordan algebras are usually non-associative:

sage: (x*b)*b
-6 + (7, 0)
sage: x*(b*b)
-6 + (4, -2)

We verify the Jordan identity:

sage: y = -a + 4*b - c
sage: (x*y)*(x*x) == x*(y*(x*x))
True

The base ring, while normally inferred from the matrix, can also be explicitly specified:

sage: J.<a,b,c> = JordanAlgebra(m, QQ); J
Jordan algebra over Rational Field given by the symmetric bilinear form:
[-2  3]
[ 3  4]
sage: J.<a,b,c> = JordanAlgebra(QQ, m); J # either order work
Jordan algebra over Rational Field given by the symmetric bilinear form:
[-2  3]
[ 3  4]

REFERENCES:

class sage.algebras.jordan_algebra.JordanAlgebraSymmetricBilinear(R, form, names=None)

Bases: sage.algebras.jordan_algebra.JordanAlgebra

A Jordan algebra given by a symmetric bilinear form \(m\).

class Element(parent, s, v)

Bases: sage.structure.element.AlgebraElement

An element of a Jordan algebra defined by a symmetric bilinear form.

bar()

Return the result of the bar involution of self.

The bar involution \(\bar{\cdot}\) is the \(R\)-linear endomorphism of \(M^*\) defined by \(\bar{1} = 1\) and \(\bar{x} = -x\) for \(x \in M\).

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J.<a,b,c> = JordanAlgebra(m)
sage: x = 4*a - b + 3*c
sage: x.bar()
4 + (1, -3)

We check that it is an algebra morphism:

sage: y = 2*a + 2*b - c
sage: x.bar() * y.bar() == (x*y).bar()
True
monomial_coefficients(copy=True)

Return a dictionary whose keys are indices of basis elements in the support of self and whose values are the corresponding coefficients.

INPUT:

  • copy – ignored

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J.<a,b,c> = JordanAlgebra(m)
sage: elt = a + 2*b - c
sage: elt.monomial_coefficients()
{0: 1, 1: 2, 2: -1}
norm()

Return the norm of self.

The norm of an element \(\alpha + x \in M^*\) is given by \(n(\alpha + x) = \alpha^2 - (x, x)\).

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J.<a,b,c> = JordanAlgebra(m)
sage: x = 4*a - b + 3*c; x
4 + (-1, 3)
sage: x.norm()
13
trace()

Return the trace of self.

The trace of an element \(\alpha + x \in M^*\) is given by \(t(\alpha + x) = 2 \alpha\).

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J.<a,b,c> = JordanAlgebra(m)
sage: x = 4*a - b + 3*c
sage: x.trace()
8
algebra_generators()

Return a basis of self.

The basis returned begins with the unity of \(R\) and continues with the standard basis of \(M\).

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J = JordanAlgebra(m)
sage: J.basis()
Family (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
basis()

Return a basis of self.

The basis returned begins with the unity of \(R\) and continues with the standard basis of \(M\).

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J = JordanAlgebra(m)
sage: J.basis()
Family (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
gens()

Return the generators of self.

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J = JordanAlgebra(m)
sage: J.basis()
Family (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
one()

Return the element 1 if it exists.

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J = JordanAlgebra(m)
sage: J.one()
1 + (0, 0)
zero()

Return the element 0.

EXAMPLES:

sage: m = matrix([[0,1],[1,1]])
sage: J = JordanAlgebra(m)
sage: J.zero()
0 + (0, 0)
class sage.algebras.jordan_algebra.SpecialJordanAlgebra(A, names=None)

Bases: sage.algebras.jordan_algebra.JordanAlgebra

A (special) Jordan algebra \(A^+\) from an associative algebra \(A\).

class Element(parent, x)

Bases: sage.structure.element.AlgebraElement

An element of a special Jordan algebra.

monomial_coefficients(copy=True)

Return a dictionary whose keys are indices of basis elements in the support of self and whose values are the corresponding coefficients.

INPUT:

  • copy – (default: True) if self is internally represented by a dictionary d, then make a copy of d; if False, then this can cause undesired behavior by mutating d

EXAMPLES:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: a,b,c = map(J, F.gens())
sage: elt = a + 2*b - c
sage: elt.monomial_coefficients()
{x: 1, y: 2, z: -1}
algebra_generators()

Return the basis of self.

EXAMPLES:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: J.basis()
Lazy family (Term map(i))_{i in Free monoid on 3 generators (x, y, z)}
basis()

Return the basis of self.

EXAMPLES:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: J.basis()
Lazy family (Term map(i))_{i in Free monoid on 3 generators (x, y, z)}
gens()

Return the generators of self.

EXAMPLES:

sage: cat = Algebras(QQ).WithBasis().FiniteDimensional()
sage: C = CombinatorialFreeModule(QQ, ['x','y','z'], category=cat)
sage: J = JordanAlgebra(C)
sage: J.gens()
(B['x'], B['y'], B['z'])

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: J.gens()
Traceback (most recent call last):
...
NotImplementedError: infinite set
one()

Return the element \(1\) if it exists.

EXAMPLES:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: J.one()
1
zero()

Return the element \(0\).

EXAMPLES:

sage: F.<x,y,z> = FreeAlgebra(QQ)
sage: J = JordanAlgebra(F)
sage: J.zero()
0