eja: fix screwup introduced in 5d147bd962.

[sage.d.git] / mjo / eja / euclidean_jordan_algebra.py

diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py
index 8dedc4f68d319123948c36437b68abca2ddb1eef..d6b183f8fbfc75799ed63bc5e7ae21d2a85e8b6a 100644 (file)
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -709,7 +709,7 @@ def _multiplication_table_from_matrix_basis(basis):
     S = [ vec2mat(b) for b in W.basis() ]
 
     Qs = []
-    for s in basis:
+    for s in S:
         # Brute force the multiplication-by-s matrix by looping
         # through all elements of the basis and doing the computation
         # to find out what the corresponding row should be. BEWARE:
@@ -718,7 +718,7 @@ def _multiplication_table_from_matrix_basis(basis):
         # constructor uses ROW vectors and not COLUMN vectors. That's
         # why we're computing rows here and not columns.
         Q_rows = []
-        for t in basis:
+        for t in S:
             this_row = mat2vec((s*t + t*s)/2)
             Q_rows.append(W.coordinates(this_row))
         Q = matrix(field,Q_rows)
@@ -727,32 +727,78 @@ def _multiplication_table_from_matrix_basis(basis):
     return Qs
 
 
-def random_eja():
+def _embed_complex_matrix(M):
     """
-    Return a "random" finite-dimensional Euclidean Jordan Algebra.
-
-    ALGORITHM:
+    Embed the n-by-n complex matrix ``M`` into the space of real
+    matrices of size 2n-by-2n via the map the sends each entry `z = a +
+    bi` to the block matrix ``[[a,b],[-b,a]]``.
 
-    For now, we choose a random natural number ``n`` (greater than zero)
-    and then give you back one of the following:
-
-      * The cartesian product of the rational numbers ``n`` times; this is
-        ``QQ^n`` with the Hadamard product.
+    EXAMPLES::
 
-      * The Jordan spin algebra on ``QQ^n``.
+        sage: F = QuadraticField(-1,'i')
+        sage: x1 = F(4 - 2*i)
+        sage: x2 = F(1 + 2*i)
+        sage: x3 = F(-i)
+        sage: x4 = F(6)
+        sage: M = matrix(F,2,[x1,x2,x3,x4])
+        sage: _embed_complex_matrix(M)
+        [ 4  2| 1 -2]
+        [-2  4| 2  1]
+        [-----+-----]
+        [ 0  1| 6  0]
+        [-1  0| 0  6]
 
-      * The ``n``-by-``n`` rational symmetric matrices with the symmetric
-        product.
+    """
+    n = M.nrows()
+    if M.ncols() != n:
+        raise ArgumentError("the matrix 'M' must be square")
+    field = M.base_ring()
+    blocks = []
+    for z in M.list():
+        a = z.real()
+        b = z.imag()
+        blocks.append(matrix(field, 2, [[a,-b],[b,a]]))
+    return block_matrix(field, n, blocks)
+
+
+def RealSymmetricSimpleEJA(n):
+    """
+    The rank-n simple EJA consisting of real symmetric n-by-n
+    matrices, the usual symmetric Jordan product, and the trace inner
+    product. It has dimension `(n^2 + n)/2` over the reals.
+    """
+    pass
 
-    Later this might be extended to return Cartesian products of the
-    EJAs above.
+def ComplexHermitianSimpleEJA(n):
+    """
+    The rank-n simple EJA consisting of complex Hermitian n-by-n
+    matrices over the real numbers, the usual symmetric Jordan product,
+    and the real-part-of-trace inner product. It has dimension `n^2 over
+    the reals.
+    """
+    pass
 
-    TESTS::
+def QuaternionHermitianSimpleEJA(n):
+    """
+    The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
+    matrices, the usual symmetric Jordan product, and the
+    real-part-of-trace inner product. It has dimension `2n^2 - n` over
+    the reals.
+    """
+    pass
 
-        sage: random_eja()
-        Euclidean Jordan algebra of degree...
+def OctonionHermitianSimpleEJA(n):
+    """
+    This shit be crazy. It has dimension 27 over the reals.
+    """
+    n = 3
+    pass
 
+def JordanSpinSimpleEJA(n):
     """
-    n = ZZ.random_element(1,10).abs()
-    constructor = choice([eja_rn, eja_ln, eja_sn])
-    return constructor(dimension=n, field=QQ)
+    The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
+    with the usual inner product and jordan product ``x*y =
+    (<x_bar,y_bar>, x0*y_bar + y0*x_bar)``. It has dimension `n` over
+    the reals.
+    """
+    pass