mjo/eja/eja_subalgebra.py

   1 from sage.matrix.constructor import matrix
   2
   3 from mjo.eja.eja_algebra import FiniteDimensionalEuclideanJordanAlgebra
   4 from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
   5
   6 class FiniteDimensionalEuclideanJordanSubalgebraElement(FiniteDimensionalEuclideanJordanAlgebraElement):
   7     """
   8     SETUP::
   9
  10         sage: from mjo.eja.eja_algebra import random_eja
  11
  12     TESTS::
  13
  14     The natural representation of an element in the subalgebra is
  15     the same as its natural representation in the superalgebra::
  16
  17         sage: set_random_seed()
  18         sage: A = random_eja().random_element().subalgebra_generated_by()
  19         sage: y = A.random_element()
  20         sage: actual = y.natural_representation()
  21         sage: expected = y.superalgebra_element().natural_representation()
  22         sage: actual == expected
  23         True
  24
  25     The left-multiplication-by operator for elements in the subalgebra
  26     works like it does in the superalgebra, even if we orthonormalize
  27     our basis::
  28
  29         sage: set_random_seed()
  30         sage: x = random_eja(AA).random_element()
  31         sage: A = x.subalgebra_generated_by(orthonormalize_basis=True)
  32         sage: y = A.random_element()
  33         sage: y.operator()(A.one()) == y
  34         True
  35
  36     """
  37
  38     def superalgebra_element(self):
  39         """
  40         Return the object in our algebra's superalgebra that corresponds
  41         to myself.
  42
  43         SETUP::
  44
  45             sage: from mjo.eja.eja_algebra import (RealSymmetricEJA,
  46             ....:                                  random_eja)
  47
  48         EXAMPLES::
  49
  50             sage: J = RealSymmetricEJA(3)
  51             sage: x = sum(J.gens())
  52             sage: x
  53             e0 + e1 + e2 + e3 + e4 + e5
  54             sage: A = x.subalgebra_generated_by()
  55             sage: A(x)
  56             f1
  57             sage: A(x).superalgebra_element()
  58             e0 + e1 + e2 + e3 + e4 + e5
  59
  60         TESTS:
  61
  62         We can convert back and forth faithfully::
  63
  64             sage: set_random_seed()
  65             sage: J = random_eja()
  66             sage: x = J.random_element()
  67             sage: A = x.subalgebra_generated_by()
  68             sage: A(x).superalgebra_element() == x
  69             True
  70             sage: y = A.random_element()
  71             sage: A(y.superalgebra_element()) == y
  72             True
  73
  74         """
  75         return self.parent().superalgebra().linear_combination(
  76           zip(self.parent()._superalgebra_basis, self.to_vector()) )
  77
  78
  79
  80
  81 class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJordanAlgebra):
  82     """
  83     A subalgebra of an EJA with a given basis.
  84
  85     SETUP::
  86
  87         sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
  88         ....:                                  JordanSpinEJA)
  89
  90     TESTS:
  91
  92     Ensure that our generator names don't conflict with the superalgebra::
  93
  94         sage: J = JordanSpinEJA(3)
  95         sage: J.one().subalgebra_generated_by().gens()
  96         (f0,)
  97         sage: J = JordanSpinEJA(3, prefix='f')
  98         sage: J.one().subalgebra_generated_by().gens()
  99         (g0,)
 100         sage: J = JordanSpinEJA(3, prefix='b')
 101         sage: J.one().subalgebra_generated_by().gens()
 102         (c0,)
 103
 104     Ensure that we can find subalgebras of subalgebras::
 105
 106         sage: A = ComplexHermitianEJA(3).one().subalgebra_generated_by()
 107         sage: B = A.one().subalgebra_generated_by()
 108         sage: B.dimension()
 109         1
 110
 111     """
 112     def __init__(self, superalgebra, basis, rank=None, category=None):
 113         self._superalgebra = superalgebra
 114         V = self._superalgebra.vector_space()
 115         field = self._superalgebra.base_ring()
 116         if category is None:
 117             category = self._superalgebra.category()
 118
 119         # A half-assed attempt to ensure that we don't collide with
 120         # the superalgebra's prefix (ignoring the fact that there
 121         # could be super-superelgrbas in scope). If possible, we
 122         # try to "increment" the parent algebra's prefix, although
 123         # this idea goes out the window fast because some prefixen
 124         # are off-limits.
 125         prefixen = [ 'f', 'g', 'h', 'a', 'b', 'c', 'd' ]
 126         try:
 127             prefix = prefixen[prefixen.index(self._superalgebra.prefix()) + 1]
 128         except ValueError:
 129             prefix = prefixen[0]
 130
 131         basis_vectors = [ b.to_vector() for b in basis ]
 132         superalgebra_basis = [ self._superalgebra.from_vector(b)
 133                                for b in basis_vectors ]
 134
 135         W = V.span_of_basis( V.from_vector(v) for v in basis_vectors )
 136         n = len(superalgebra_basis)
 137         mult_table = [[W.zero() for i in range(n)] for j in range(n)]
 138         for i in range(n):
 139             for j in range(n):
 140                 product = superalgebra_basis[i]*superalgebra_basis[j]
 141                 # product.to_vector() might live in a vector subspace
 142                 # if our parent algebra is already a subalgebra. We
 143                 # use V.from_vector() to make it "the right size" in
 144                 # that case.
 145                 product_vector = V.from_vector(product.to_vector())
 146                 mult_table[i][j] = W.coordinate_vector(product_vector)
 147
 148         natural_basis = tuple( b.natural_representation()
 149                                for b in superalgebra_basis )
 150
 151
 152         self._vector_space = W
 153         self._superalgebra_basis = superalgebra_basis
 154
 155
 156         fdeja = super(FiniteDimensionalEuclideanJordanSubalgebra, self)
 157         return fdeja.__init__(field,
 158                               mult_table,
 159                               rank,
 160                               prefix=prefix,
 161                               category=category,
 162                               natural_basis=natural_basis)
 163
 164
 165
 166     def _element_constructor_(self, elt):
 167         """
 168         Construct an element of this subalgebra from the given one.
 169         The only valid arguments are elements of the parent algebra
 170         that happen to live in this subalgebra.
 171
 172         SETUP::
 173
 174             sage: from mjo.eja.eja_algebra import RealSymmetricEJA
 175             sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanSubalgebra
 176
 177         EXAMPLES::
 178
 179             sage: J = RealSymmetricEJA(3)
 180             sage: X = matrix(QQ, [ [0,0,1],
 181             ....:                  [0,1,0],
 182             ....:                  [1,0,0] ])
 183             sage: x = J(X)
 184             sage: basis = ( x, x^2 ) # x^2 is the identity matrix
 185             sage: K = FiniteDimensionalEuclideanJordanSubalgebra(J, basis)
 186             sage: K(J.one())
 187             f1
 188             sage: K(J.one() + x)
 189             f0 + f1
 190
 191         ::
 192
 193         """
 194         if elt not in self.superalgebra():
 195             raise ValueError("not an element of this subalgebra")
 196
 197         coords = self.vector_space().coordinate_vector(elt.to_vector())
 198         return self.from_vector(coords)
 199
 200
 201
 202     def natural_basis_space(self):
 203         """
 204         Return the natural basis space of this algebra, which is identical
 205         to that of its superalgebra.
 206
 207         This is correct "by definition," and avoids a mismatch when the
 208         subalgebra is trivial (with no natural basis to infer anything
 209         from) and the parent is not.
 210         """
 211         return self.superalgebra().natural_basis_space()
 212
 213
 214     def superalgebra(self):
 215         """
 216         Return the superalgebra that this algebra was generated from.
 217         """
 218         return self._superalgebra
 219
 220
 221     def vector_space(self):
 222         """
 223         SETUP::
 224
 225             sage: from mjo.eja.eja_algebra import RealSymmetricEJA
 226             sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanSubalgebra
 227
 228         EXAMPLES::
 229
 230             sage: J = RealSymmetricEJA(3)
 231             sage: E11 = matrix(QQ, [ [1,0,0],
 232             ....:                    [0,0,0],
 233             ....:                    [0,0,0] ])
 234             sage: E22 = matrix(QQ, [ [0,0,0],
 235             ....:                    [0,1,0],
 236             ....:                    [0,0,0] ])
 237             sage: b1 = J(E11)
 238             sage: b2 = J(E22)
 239             sage: basis = (b1, b2)
 240             sage: K = FiniteDimensionalEuclideanJordanSubalgebra(J,basis)
 241             sage: K.vector_space()
 242             Vector space of degree 6 and dimension 2 over...
 243             User basis matrix:
 244             [1 0 0 0 0 0]
 245             [0 0 1 0 0 0]
 246             sage: b1.to_vector()
 247             (1, 0, 0, 0, 0, 0)
 248             sage: b2.to_vector()
 249             (0, 0, 1, 0, 0, 0)
 250
 251         """
 252         return self._vector_space
 253
 254
 255     Element = FiniteDimensionalEuclideanJordanSubalgebraElement