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 NumberField
+from sage.rings.number_field.number_field import NumberField, QuadraticField
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.rings.real_lazy import CLF, RLF
from sage.structure.element import is_Matrix
from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
-def _real_symmetric_basis(n, field):
+def _real_symmetric_basis(n, field, normalize):
"""
Return a basis for the space of real symmetric n-by-n matrices.
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: B = _real_symmetric_basis(n, QQbar)
+ sage: B = _real_symmetric_basis(n, QQbar, False)
sage: all( M.is_symmetric() for M in B)
True
Sij = Eij
else:
Sij = Eij + Eij.transpose()
- # Now normalize it.
- Sij = Sij / _real_symmetric_matrix_ip(Sij,Sij).sqrt()
+ if normalize:
+ Sij = Sij / _real_symmetric_matrix_ip(Sij,Sij).sqrt()
S.append(Sij)
return tuple(S)
-def _complex_hermitian_basis(n, field):
+def _complex_hermitian_basis(n, field, normalize):
"""
Returns a basis for the space of complex Hermitian n-by-n matrices.
+ Why do we embed these? Basically, because all of numerical linear
+ algebra assumes that you're working with vectors consisting of `n`
+ entries from a field and scalars from the same field. There's no way
+ to tell SageMath that (for example) the vectors contain complex
+ numbers, while the scalar field is real.
+
SETUP::
sage: from mjo.eja.eja_algebra import _complex_hermitian_basis
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: B = _complex_hermitian_basis(n, QQ)
+ sage: field = QuadraticField(2, 'sqrt2')
+ sage: B = _complex_hermitian_basis(n, field, False)
sage: all( M.is_symmetric() for M in B)
True
S = []
for i in xrange(n):
for j in xrange(i+1):
- Eij = matrix(field, n, lambda k,l: k==i and l==j)
+ Eij = matrix(F, n, lambda k,l: k==i and l==j)
if i == j:
Sij = _embed_complex_matrix(Eij)
S.append(Sij)
S.append(Sij_real)
Sij_imag = _embed_complex_matrix(I*Eij - I*Eij.transpose())
S.append(Sij_imag)
+
+ # Since we embedded these, we can drop back to the "field" that we
+ # started with instead of the complex extension "F".
+ S = [ s.change_ring(field) for s in S ]
+ if normalize:
+ S = [ s / _complex_hermitian_matrix_ip(s,s).sqrt() for s in S ]
+
return tuple(S)
-def _quaternion_hermitian_basis(n, field):
+
+def _quaternion_hermitian_basis(n, field, normalize):
"""
Returns a basis for the space of quaternion Hermitian n-by-n matrices.
+ Why do we embed these? Basically, because all of numerical linear
+ algebra assumes that you're working with vectors consisting of `n`
+ entries from a field and scalars from the same field. There's no way
+ to tell SageMath that (for example) the vectors contain complex
+ numbers, while the scalar field is real.
+
SETUP::
sage: from mjo.eja.eja_algebra import _quaternion_hermitian_basis
sage: set_random_seed()
sage: n = ZZ.random_element(1,5)
- sage: B = _quaternion_hermitian_basis(n, QQbar)
+ sage: B = _quaternion_hermitian_basis(n, QQ, False)
sage: all( M.is_symmetric() for M in B )
True
EXAMPLES::
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ sage: F = QuadraticField(-1, 'i')
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: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ sage: F = QuadraticField(-1, 'i')
sage: X = random_matrix(F, n)
sage: Y = random_matrix(F, n)
sage: actual = _embed_complex_matrix(X) * _embed_complex_matrix(Y)
field = M.base_ring()
blocks = []
for z in M.list():
- a = z.real()
- b = z.imag()
+ a = z.vector()[0] # real part, I guess
+ b = z.vector()[1] # imag part, I guess
blocks.append(matrix(field, 2, [[a,b],[-b,a]]))
# We can drop the imaginaries here.
Unembedding is the inverse of embedding::
sage: set_random_seed()
- sage: R = PolynomialRing(QQ, 'z')
- sage: z = R.gen()
- sage: F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ sage: F = QuadraticField(-1, 'i')
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")
- R = PolynomialRing(QQ, 'z')
+ field = M.base_ring() # This should already have sqrt2
+ R = PolynomialRing(field, 'z')
z = R.gen()
- F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ 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")
- R = PolynomialRing(QQ, 'z')
- z = R.gen()
- F = NumberField(z**2 + 1, 'i', embedding=CLF(-1).sqrt())
+ F = QuadraticField(-1, 'i')
i = F.gen()
blocks = []
def _real_symmetric_matrix_ip(X,Y):
return (X*Y).trace()
+def _complex_hermitian_matrix_ip(X,Y):
+ # This takes EMBEDDED matrices.
+ Xu = _unembed_complex_matrix(X)
+ Yu = _unembed_complex_matrix(Y)
+ # The trace need not be real; consider Xu = (i*I) and Yu = I.
+ return ((Xu*Yu).trace()).vector()[0] # real part, I guess
class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra):
"""
True
"""
- def __init__(self, n, field=QQ, **kwargs):
+ def __init__(self, n, field=QQ, normalize_basis=True, **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')
+ p = z**2 - 2
+ if p.is_irreducible():
+ field = NumberField(p, 'sqrt2', embedding=RLF(2).sqrt())
- S = _real_symmetric_basis(n, field)
+ S = _real_symmetric_basis(n, field, normalize_basis)
Qs = _multiplication_table_from_matrix_basis(S)
fdeja = super(RealSymmetricEJA, self)
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,4)
+ sage: J = ComplexHermitianEJA(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 = ComplexHermitianEJA(n).random_element()
+ sage: x.operator().matrix().is_symmetric()
+ True
+
"""
- def __init__(self, n, field=QQ, **kwargs):
- S = _complex_hermitian_basis(n, field)
+ def __init__(self, n, field=QQ, normalize_basis=True, **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()
+ p = z**2 - 2
+ if p.is_irreducible():
+ field = NumberField(p, 'sqrt2', embedding=RLF(2).sqrt())
+
+ S = _complex_hermitian_basis(n, field, normalize_basis)
Qs = _multiplication_table_from_matrix_basis(S)
fdeja = super(ComplexHermitianEJA, self)
def inner_product(self, x, y):
- # Since a+bi on the diagonal is represented as
- #
- # a + bi = [ a b ]
- # [ -b a ],
- #
- # we'll double-count the "a" entries if we take the trace of
- # the embedding.
- return _matrix_ip(x,y)/2
+ X = x.natural_representation()
+ Y = y.natural_representation()
+ return _complex_hermitian_matrix_ip(X,Y)
class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
True
"""
- def __init__(self, n, field=QQ, **kwargs):
- S = _quaternion_hermitian_basis(n, field)
+ def __init__(self, n, field=QQ, normalize_basis=True, **kwargs):
+ S = _quaternion_hermitian_basis(n, field, normalize_basis)
Qs = _multiplication_table_from_matrix_basis(S)
fdeja = super(QuaternionHermitianEJA, self)