X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=a7e56187550111a928823d536dc3ff88347b7424;hb=0848d2345f4813e9f176efef6864d65b1915c495;hp=47d247be636c01d59a06a4f48da4d56b63b0f508;hpb=801e9686b8eff405e50d9fb5cbf6f3b5a7c61117;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 47d247b..a7e5618 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -15,9 +15,10 @@ from sage.misc.prandom import choice 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, QuadraticField from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing from sage.rings.rational_field import QQ +from sage.rings.real_lazy import CLF, RLF from sage.structure.element import is_Matrix from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement @@ -502,8 +503,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): 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] ) :: @@ -678,7 +679,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): 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() @@ -801,7 +802,7 @@ def random_eja(): -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. @@ -813,7 +814,7 @@ def _real_symmetric_basis(n, field): 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 @@ -827,16 +828,23 @@ def _real_symmetric_basis(n, field): if i == j: Sij = Eij else: - # Beware, orthogonal but not normalized! Sij = Eij + Eij.transpose() + 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 @@ -845,12 +853,15 @@ def _complex_hermitian_basis(n, field): 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 """ - 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: @@ -861,7 +872,7 @@ def _complex_hermitian_basis(n, field): 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) @@ -872,13 +883,27 @@ def _complex_hermitian_basis(n, field): 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 @@ -887,7 +912,7 @@ def _quaternion_hermitian_basis(n, field): 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 @@ -964,7 +989,7 @@ def _embed_complex_matrix(M): EXAMPLES:: - sage: F = QuadraticField(-1,'i') + sage: F = QuadraticField(-1, 'i') sage: x1 = F(4 - 2*i) sage: x2 = F(1 + 2*i) sage: x3 = F(-i) @@ -998,8 +1023,8 @@ def _embed_complex_matrix(M): 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. @@ -1042,7 +1067,10 @@ def _unembed_complex_matrix(M): if not n.mod(2).is_zero(): raise ValueError("the matrix 'M' must be a complex embedding") - F = QuadraticField(-1, 'i') + 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()) i = F.gen() # Go top-left to bottom-right (reading order), converting every @@ -1190,6 +1218,15 @@ def _matrix_ip(X,Y): Y_mat = Y.natural_representation() return (X_mat*Y_mat).trace() +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): """ @@ -1208,7 +1245,7 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: e0*e0 e0 sage: e1*e1 - e0 + e2 + 1/2*e0 + 1/2*e2 sage: e2*e2 e2 @@ -1254,9 +1291,36 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): 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): - S = _real_symmetric_basis(n, field) + def __init__(self, n, field=QQ, normalize_basis=True, **kwargs): + if n > 1 and normalize_basis: + # 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 = _real_symmetric_basis(n, field, normalize_basis) Qs = _multiplication_table_from_matrix_basis(S) fdeja = super(RealSymmetricEJA, self) @@ -1267,7 +1331,9 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): **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): @@ -1323,9 +1389,36 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): 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 and normalize_basis: + # 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) @@ -1337,14 +1430,9 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): 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): @@ -1401,8 +1489,8 @@ 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)