Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
r""" Jordan Algebras
AUTHORS:
- Travis Scrimshaw (2014-04-02): initial version """
#***************************************************************************** # Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu> # # Distributed under the terms of the GNU General Public License (GPL) # http://www.gnu.org/licenses/ #*****************************************************************************
#from sage.misc.lazy_attribute import lazy_attribute
r""" 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
.. MATH::
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
.. MATH::
(\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:
- :wikipedia:`Jordan_algebra`
- [Ja1971]_
- [Ch2012]_
- [McC1978]_
- [Al1947]_ """ """ Choose the correct parent based upon input.
TESTS:
We check arguments with passing in an associative algebra::
sage: cat = Algebras(QQ).WithBasis().FiniteDimensional() sage: C = CombinatorialFreeModule(QQ, ['x','y','z'], category=cat) sage: J1 = JordanAlgebra(C, names=['a','b','c']) sage: J2.<a,b,c> = JordanAlgebra(C) sage: J1 is J2 True
We check with passing in a symmetric bilinear form::
sage: m = matrix([[0,1],[1,1]]) sage: J1 = JordanAlgebra(m) sage: J2 = JordanAlgebra(QQ, m) sage: J3 = JordanAlgebra(m, QQ) sage: J1 is J2 False sage: J2 is J3 True sage: J4 = JordanAlgebra(ZZ, m) sage: J1 is J4 True sage: m = matrix(QQ, [[0,1],[1,1]]) sage: J1 = JordanAlgebra(m) sage: J1 is J2 True """ names = names.split(',')
raise ValueError("the base ring cannot have characteristic 2")
# arg0 is the base ring and arg1 is a matrix raise ValueError("the bilinear form is not symmetric")
r""" A (special) Jordan algebra `A^+` from an associative algebra `A`. """ """ Initialize ``self``.
TESTS::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: TestSuite(J).run() sage: J.category() Category of commutative unital algebras with basis over Rational Field """ raise ValueError("A is not an associative algebra")
# Remove the preceding line once trac #16492 is fixed # Removing this line will also break some of the input formats, # see trac #16054
""" Return a string representation of ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: JordanAlgebra(F) Jordan algebra of Free Algebra on 3 generators (x, y, z) over Rational Field """
""" Construct an element of ``self`` from ``x``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: J(5) 5 sage: elt = J(x + 2*x*y); elt x + 2*x*y sage: elt.parent() is J True """
""" Return an element of ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: J.an_element() 2 + 2*x + 3*y """
def basis(self): """ 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)} """
# TODO: Keep this until we can better handle R.<...> shorthand """ 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 """
def zero(self): """ Return the element `0`.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: J.zero() 0 """
def one(self): """ Return the element `1` if it exists.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: J.one() 1 """
""" An element of a special Jordan algebra. """ """ Initialize ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: TestSuite(a + 2*b - c).run() """
""" Return a string representation of ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: a + 2*b - c x + 2*y - z """
""" Return a latex representation of ``self``.
EXAMPLES::
sage: F.<x0,x1,x2> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: latex(a + 2*b - c) x_{0} + 2x_{1} - x_{2} """
""" Return if ``self`` is non-zero.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: bool(a + 2*b - c) True """
""" Check equality.
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 == elt True sage: elt == x False sage: elt == 2*b False """ return False
""" Check inequality.
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 != elt False sage: elt != x True sage: elt != 2*b True """
""" Add ``self`` and ``other``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: a + 2*b x + 2*y """
""" Negate ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: -(a + 2*b) -x - 2*y """
""" Subtract ``other`` from ``self``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: a - 2*b x - 2*y """
""" Multiply ``self`` and ``other``.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: (a + 2*b) * (c - b) -1/2*x*y + 1/2*x*z - 1/2*y*x - 2*y^2 + y*z + 1/2*z*x + z*y
sage: F.<x,y,z> = FreeAlgebra(GF(3)) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: (a + 2*b) * (c - b) x*y + 2*x*z + y*x + y^2 + y*z + 2*z*x + z*y """ # This is safer than dividing by 2
""" Multiply ``self`` by the scalar ``other`` on the left.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: (a + b) * 2 2*x + 2*y """
""" Multiply ``self`` and the scalar ``other`` by the right action.
EXAMPLES::
sage: F.<x,y,z> = FreeAlgebra(QQ) sage: J = JordanAlgebra(F) sage: a,b,c = map(J, F.gens()) sage: 2 * (a + b) 2*x + 2*y """
""" 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} """
r""" A Jordan algebra given by a symmetric bilinear form `m`. """ """ Initialize ``self``.
TESTS::
sage: m = matrix([[-2,3],[3,4]]) sage: J = JordanAlgebra(m) sage: TestSuite(J).run() """
""" Return a string representation of ``self``.
EXAMPLES::
sage: m = matrix([[-2,3],[3,4]]) sage: JordanAlgebra(m) Jordan algebra over Integer Ring given by the symmetric bilinear form: [-2 3] [ 3 4] """ " form:\n{}".format(self.base_ring(), self._form)
""" Construct an element of ``self`` from ``s``.
Here ``s`` can be a pair of an element of `R` and an element of `M`, or an element of `R`, or an element of `M`, or an element of a(nother) Jordan algebra given by a symmetric bilinear form.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J = JordanAlgebra(m) sage: J(2) 2 + (0, 0) sage: J((-4, (2, 5))) -4 + (2, 5) sage: J((-4, (ZZ^2)((2, 5)))) -4 + (2, 5) sage: J(2, (-2, 3)) 2 + (-2, 3) sage: J(2, (ZZ^2)((-2, 3))) 2 + (-2, 3) sage: J(-1, 1, 0) -1 + (1, 0) sage: J((ZZ^2)((1, 3))) 0 + (1, 3)
sage: m = matrix([[2]]) sage: J = JordanAlgebra(m) sage: J(2) 2 + (0) sage: J((-4, (2,))) -4 + (2) sage: J(2, (-2,)) 2 + (-2) sage: J(-1, 1) -1 + (1) sage: J((ZZ^1)((3,))) 0 + (3)
sage: m = Matrix(QQ, []) sage: J = JordanAlgebra(m) sage: J(2) 2 + () sage: J((-4, ())) -4 + () sage: J(2, ()) 2 + () sage: J(-1) -1 + () sage: J((ZZ^0)(())) 0 + () """
if s.parent() is self: return s return self.element_class(self, R(s._s), self._M(s._v))
raise ValueError("must be length 2")
raise ValueError("unable to construct an element from the given data")
def basis(self): """ 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)) """ for x in self._M.basis())
""" 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)) """
def zero(self): """ Return the element 0.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J = JordanAlgebra(m) sage: J.zero() 0 + (0, 0) """
def one(self): """ 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) """
""" An element of a Jordan algebra defined by a symmetric bilinear form. """ """ Initialize ``self``.
TESTS::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: TestSuite(a + 2*b - c).run() """
""" Return a string representation of ``self``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: a + 2*b - c 1 + (2, -1) """
r""" Return a latex representation of ``self``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: latex(a + 2*b - c) 1 + \left(2,\,-1\right) """
""" Return if ``self`` is non-zero.
TESTS::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: bool(1) True sage: bool(b) True sage: bool(a + 2*b - c) True """
""" Check equality.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: x = 4*a - b + 3*c sage: x == J((4, (-1, 3))) True sage: a == x False
sage: m = matrix([[-2,3],[3,4]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: 4*a - b + 3*c == x False """
""" Check inequality.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: x = 4*a - b + 3*c sage: x != J((4, (-1, 3))) False sage: a != x True
sage: m = matrix([[-2,3],[3,4]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: 4*a - b + 3*c != x True """
""" Add ``self`` and ``other``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: a + b 1 + (1, 0) sage: b + c 0 + (1, 1) """
""" Negate ``self``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: -(a + b - 2*c) -1 + (-1, 2) """
""" Subtract ``other`` from ``self``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: a - b 1 + (-1, 0) sage: b - c 0 + (1, -1) """
""" Multiply ``self`` and ``other``.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: (4*a - b + 3*c)*(2*a + 2*b - c) 12 + (6, 2)
sage: m = matrix([[-2,3],[3,4]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: (4*a - b + 3*c)*(2*a + 2*b - c) 21 + (6, 2) """ self._s * other._s + (self._v * P._form * other._v.column())[0], other._s * self._v + self._s * other._v)
""" Multiply ``self`` by the scalar ``other`` on the left.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: (a + b - c) * 2 2 + (2, -2) """
""" Multiply ``self`` with the scalar ``other`` by the right action.
EXAMPLES::
sage: m = matrix([[0,1],[1,1]]) sage: J.<a,b,c> = JordanAlgebra(m) sage: 2 * (a + b - c) 2 + (2, -2) """
""" 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} """
r""" 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 """
r""" 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 """ * self._v.column())[0]
r""" 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 """
|