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 = sum( i*J.gens()[i] for i in range(6) )
 181             sage: basis = tuple( x^k for k in range(J.rank()) )
 182             sage: K = FiniteDimensionalEuclideanJordanSubalgebra(J,basis)
 183             sage: [ K(x^k) for k in range(J.rank()) ]
 184             [f0, f1, f2]
 185
 186         ::
 187
 188         """
 189         if elt not in self.superalgebra():
 190             raise ValueError("not an element of this subalgebra")
 191
 192         coords = self.vector_space().coordinate_vector(elt.to_vector())
 193         return self.from_vector(coords)
 194
 195
 196
 197     def natural_basis_space(self):
 198         """
 199         Return the natural basis space of this algebra, which is identical
 200         to that of its superalgebra.
 201
 202         This is correct "by definition," and avoids a mismatch when the
 203         subalgebra is trivial (with no natural basis to infer anything
 204         from) and the parent is not.
 205         """
 206         return self.superalgebra().natural_basis_space()
 207
 208
 209     def superalgebra(self):
 210         """
 211         Return the superalgebra that this algebra was generated from.
 212         """
 213         return self._superalgebra
 214
 215
 216     def vector_space(self):
 217         """
 218         SETUP::
 219
 220             sage: from mjo.eja.eja_algebra import RealSymmetricEJA
 221             sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanSubalgebra
 222
 223         EXAMPLES::
 224
 225             sage: J = RealSymmetricEJA(3)
 226             sage: x = J.monomial(0) + 2*J.monomial(2) + 5*J.monomial(5)
 227             sage: basis = (x^0, x^1, x^2)
 228             sage: K = FiniteDimensionalEuclideanJordanSubalgebra(J,basis)
 229             sage: K.vector_space()
 230             Vector space of degree 6 and dimension 3 over...
 231             User basis matrix:
 232             [ 1  0  1  0  0  1]
 233             [ 1  0  2  0  0  5]
 234             [ 1  0  4  0  0 25]
 235             sage: (x^0).to_vector()
 236             (1, 0, 1, 0, 0, 1)
 237             sage: (x^1).to_vector()
 238             (1, 0, 2, 0, 0, 5)
 239             sage: (x^2).to_vector()
 240             (1, 0, 4, 0, 0, 25)
 241
 242         """
 243         return self._vector_space
 244
 245
 246     Element = FiniteDimensionalEuclideanJordanSubalgebraElement