from sage.misc.table import table
from sage.modules.free_module import FreeModule, VectorSpace
from sage.rings.integer_ring import ZZ
-from sage.rings.number_field.number_field import QuadraticField
+from sage.rings.number_field.number_field import NumberField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.rational_field import QQ
+from sage.rings.real_lazy import CLF
from sage.structure.element import is_Matrix
from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
return self.zero()
natural_basis = self.natural_basis()
- if elt not in natural_basis[0].matrix_space():
+ basis_space = natural_basis[0].matrix_space()
+ if elt not in basis_space:
raise ValueError("not a naturally-represented algebra element")
- # Thanks for nothing! Matrix spaces aren't vector
- # spaces in Sage, so we have to figure out its
- # natural-basis coordinates ourselves.
- V = VectorSpace(elt.base_ring(), elt.nrows()*elt.ncols())
+ # Thanks for nothing! Matrix spaces aren't vector spaces in
+ # Sage, so we have to figure out its natural-basis coordinates
+ # ourselves. We use the basis space's ring instead of the
+ # element's ring because the basis space might be an algebraic
+ # closure whereas the base ring of the 3-by-3 identity matrix
+ # could be QQ instead of QQbar.
+ V = VectorSpace(basis_space.base_ring(), elt.nrows()*elt.ncols())
W = V.span_of_basis( _mat2vec(s) for s in natural_basis )
coords = W.coordinate_vector(_mat2vec(elt))
return self.from_vector(coords)
Finite family {0: e0, 1: e1, 2: e2}
sage: J.natural_basis()
(
- [1 0] [0 1] [0 0]
- [0 0], [1 0], [0 1]
+ [1 0] [ 0 1/2*sqrt2] [0 0]
+ [0 0], [1/2*sqrt2 0], [0 1]
)
::
sage: J = RealSymmetricEJA(2)
sage: J.vector_space()
- Vector space of dimension 3 over Rational Field
+ Vector space of dimension 3 over...
"""
return self.zero().to_vector().parent().ambient_vector_space()
def _real_symmetric_basis(n, field):
"""
Return a basis for the space of real symmetric n-by-n matrices.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import _real_symmetric_basis
+
+ TESTS::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: B = _real_symmetric_basis(n, QQbar)
+ sage: all( M.is_symmetric() for M in B)
+ True
+
"""
# The basis of symmetric matrices, as matrices, in their R^(n-by-n)
# coordinates.
if i == j:
Sij = Eij
else:
- # Beware, orthogonal but not normalized!
Sij = Eij + Eij.transpose()
+ # Now normalize it.
+ Sij = Sij / _real_symmetric_matrix_ip(Sij,Sij).sqrt()
S.append(Sij)
return tuple(S)
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) )
+ sage: B = _complex_hermitian_basis(n, QQ)
+ sage: all( M.is_symmetric() for M in B)
True
"""
- F = QuadraticField(-1, 'I')
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ F = NumberField(z**2 + 1, 'I', embedding=CLF(-1).sqrt())
I = F.gen()
# This is like the symmetric case, but we need to be careful:
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: all( M.is_symmetric() for M in _quaternion_hermitian_basis(n) )
+ sage: B = _quaternion_hermitian_basis(n, QQbar)
+ sage: all( M.is_symmetric() for M in B )
True
"""
EXAMPLES::
- sage: F = QuadraticField(-1,'i')
+ sage: R = PolynomialRing(QQ, 'z')
+ sage: z = R.gen()
+ sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
sage: x1 = F(4 - 2*i)
sage: x2 = F(1 + 2*i)
sage: x3 = F(-i)
sage: set_random_seed()
sage: n = ZZ.random_element(5)
- sage: F = QuadraticField(-1, 'i')
+ sage: R = PolynomialRing(QQ, 'z')
+ sage: z = R.gen()
+ sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
sage: X = random_matrix(F, n)
sage: Y = random_matrix(F, n)
sage: actual = _embed_complex_matrix(X) * _embed_complex_matrix(Y)
Unembedding is the inverse of embedding::
sage: set_random_seed()
- sage: F = QuadraticField(-1, 'i')
+ sage: R = PolynomialRing(QQ, 'z')
+ sage: z = R.gen()
+ sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
sage: M = random_matrix(F, 3)
sage: _unembed_complex_matrix(_embed_complex_matrix(M)) == M
True
if not n.mod(2).is_zero():
raise ValueError("the matrix 'M' must be a complex embedding")
- F = QuadraticField(-1, 'i')
+ R = PolynomialRing(QQ, 'z')
+ z = R.gen()
+ F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
i = F.gen()
# Go top-left to bottom-right (reading order), converting every
if M.ncols() != n:
raise ValueError("the matrix 'M' must be square")
- F = QuadraticField(-1, 'i')
+ R = PolynomialRing(QQ, 'z')
+ z = R.gen()
+ F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
i = F.gen()
blocks = []
Y_mat = Y.natural_representation()
return (X_mat*Y_mat).trace()
+def _real_symmetric_matrix_ip(X,Y):
+ return (X*Y).trace()
+
class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra):
"""
sage: e0*e0
e0
sage: e1*e1
- e0 + e2
+ 1/2*e0 + 1/2*e2
sage: e2*e2
e2
sage: (x*y).inner_product(z) == y.inner_product(x*z)
True
+ Our basis is normalized with respect to the natural inner product::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: J = RealSymmetricEJA(n)
+ sage: all( b.norm() == 1 for b in J.gens() )
+ True
+
+ Left-multiplication operators are symmetric because they satisfy
+ the Jordan axiom::
+
+ sage: set_random_seed()
+ sage: n = ZZ.random_element(1,5)
+ sage: x = RealSymmetricEJA(n).random_element()
+ sage: x.operator().matrix().is_symmetric()
+ True
+
"""
def __init__(self, n, field=QQ, **kwargs):
+ if n > 1:
+ # We'll need sqrt(2) to normalize the basis, and this
+ # winds up in the multiplication table, so the whole
+ # algebra needs to be over the field extension.
+ R = PolynomialRing(field, 'z')
+ z = R.gen()
+ field = NumberField(z**2 - 2, 'sqrt2')
+
S = _real_symmetric_basis(n, field)
Qs = _multiplication_table_from_matrix_basis(S)
**kwargs)
def inner_product(self, x, y):
- return _matrix_ip(x,y)
+ X = x.natural_representation()
+ Y = y.natural_representation()
+ return _real_symmetric_matrix_ip(X,Y)
class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
projects / sage.d.git / blobdiff