X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=1e5ada2188c3b6b3834165f221ab20b56d5c1f98;hb=f2564c0412a2498ff32245a848ba61746124eaf8;hp=a73cfaf689c7206f7644e10021006e4bcf6f08f7;hpb=d284bd1283830bfa1417b30c592b529a1cd1f47b;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index a73cfaf..1e5ada2 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -94,6 +94,20 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): The inner product associated with this Euclidean Jordan algebra. Will default to the trace inner product if nothing else. + + EXAMPLES: + + The inner product must satisfy its axiom for this algebra to truly + be a Euclidean Jordan Algebra:: + + sage: set_random_seed() + sage: J = random_eja() + sage: x = J.random_element() + sage: y = J.random_element() + sage: z = J.random_element() + sage: (x*y).inner_product(z) == y.inner_product(x*z) + True + """ if (not x in self) or (not y in self): raise TypeError("arguments must live in this algebra") @@ -160,6 +174,51 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): An element of a Euclidean Jordan algebra. """ + def __init__(self, A, elt=None): + """ + EXAMPLES: + + The identity in `S^n` is converted to the identity in the EJA:: + + sage: J = RealSymmetricSimpleEJA(3) + sage: I = identity_matrix(QQ,3) + sage: J(I) == J.one() + True + + This skew-symmetric matrix can't be represented in the EJA:: + + sage: J = RealSymmetricSimpleEJA(3) + sage: A = matrix(QQ,3, lambda i,j: i-j) + sage: J(A) + Traceback (most recent call last): + ... + ArithmeticError: vector is not in free module + + """ + # Goal: if we're given a matrix, and if it lives in our + # parent algebra's "natural ambient space," convert it + # into an algebra element. + # + # The catch is, we make a recursive call after converting + # the given matrix into a vector that lives in the algebra. + # This we need to try the parent class initializer first, + # to avoid recursing forever if we're given something that + # already fits into the algebra, but also happens to live + # in the parent's "natural ambient space" (this happens with + # vectors in R^n). + try: + FiniteDimensionalAlgebraElement.__init__(self, A, elt) + except ValueError: + natural_basis = A.natural_basis() + if elt in natural_basis[0].matrix_space(): + # 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()**2) + W = V.span( _mat2vec(s) for s in natural_basis ) + coords = W.coordinates(_mat2vec(elt)) + FiniteDimensionalAlgebraElement.__init__(self, A, coords) + def __pow__(self, n): """ Return ``self`` raised to the power ``n``. @@ -1057,6 +1116,12 @@ def _complex_hermitian_basis(n, field=QQ): return tuple(S) +def _mat2vec(m): + return vector(m.base_ring(), m.list()) + +def _vec2mat(v): + return matrix(v.base_ring(), sqrt(v.degree()), v.list()) + def _multiplication_table_from_matrix_basis(basis): """ At least three of the five simple Euclidean Jordan algebras have the @@ -1077,19 +1142,13 @@ def _multiplication_table_from_matrix_basis(basis): field = basis[0].base_ring() dimension = basis[0].nrows() - def mat2vec(m): - return vector(field, m.list()) - - def vec2mat(v): - return matrix(field, dimension, v.list()) - V = VectorSpace(field, dimension**2) - W = V.span( mat2vec(s) for s in basis ) + W = V.span( _mat2vec(s) for s in basis ) # Taking the span above reorders our basis (thanks, jerk!) so we # need to put our "matrix basis" in the same order as the # (reordered) vector basis. - S = tuple( vec2mat(b) for b in W.basis() ) + S = tuple( _vec2mat(b) for b in W.basis() ) Qs = [] for s in S: @@ -1102,7 +1161,7 @@ def _multiplication_table_from_matrix_basis(basis): # why we're computing rows here and not columns. Q_rows = [] for t in S: - this_row = mat2vec((s*t + t*s)/2) + this_row = _mat2vec((s*t + t*s)/2) Q_rows.append(W.coordinates(this_row)) Q = matrix(field, W.dimension(), Q_rows) Qs.append(Q) @@ -1123,13 +1182,13 @@ def _embed_complex_matrix(M): sage: x2 = F(1 + 2*i) sage: x3 = F(-i) sage: x4 = F(6) - sage: M = matrix(F,2,[x1,x2,x3,x4]) + sage: M = matrix(F,2,[[x1,x2],[x3,x4]]) sage: _embed_complex_matrix(M) - [ 4 2| 1 -2] - [-2 4| 2 1] + [ 4 -2| 1 2] + [ 2 4|-2 1] [-----+-----] - [ 0 1| 6 0] - [-1 0| 0 6] + [ 0 -1| 6 0] + [ 1 0| 0 6] """ n = M.nrows() @@ -1140,7 +1199,7 @@ def _embed_complex_matrix(M): for z in M.list(): a = z.real() b = z.imag() - blocks.append(matrix(field, 2, [[a,-b],[b,a]])) + blocks.append(matrix(field, 2, [[a,b],[-b,a]])) # We can drop the imaginaries here. return block_matrix(field.base_ring(), n, blocks) @@ -1157,8 +1216,17 @@ def _unembed_complex_matrix(M): ....: [ 9, 10, 11, 12], ....: [-10, 9, -12, 11] ]) sage: _unembed_complex_matrix(A) - [ -2*i + 1 -4*i + 3] - [ -10*i + 9 -12*i + 11] + [ 2*i + 1 4*i + 3] + [ 10*i + 9 12*i + 11] + + TESTS:: + + sage: set_random_seed() + sage: F = QuadraticField(-1, 'i') + sage: M = random_matrix(F, 3) + sage: _unembed_complex_matrix(_embed_complex_matrix(M)) == M + True + """ n = ZZ(M.nrows()) if M.ncols() != n: @@ -1179,7 +1247,7 @@ def _unembed_complex_matrix(M): raise ValueError('bad real submatrix') if submat[0,1] != -submat[1,0]: raise ValueError('bad imag submatrix') - z = submat[0,0] + submat[1,0]*i + z = submat[0,0] + submat[0,1]*i elements.append(z) return matrix(F, n/2, elements)