1 from sage
.matrix
.constructor
import matrix
3 from mjo
.eja
.eja_algebra
import FiniteDimensionalEJA
4 from mjo
.eja
.eja_element
import FiniteDimensionalEJAElement
6 class FiniteDimensionalEJASubalgebraElement(FiniteDimensionalEJAElement
):
10 sage: from mjo.eja.eja_algebra import random_eja
14 The matrix representation of an element in the subalgebra is
15 the same as its matrix representation in the superalgebra::
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.to_matrix()
21 sage: expected = y.superalgebra_element().to_matrix()
22 sage: actual == expected
25 The left-multiplication-by operator for elements in the subalgebra
26 works like it does in the superalgebra, even if we orthonormalize
29 sage: set_random_seed()
30 sage: x = random_eja(field=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
38 def superalgebra_element(self
):
40 Return the object in our algebra's superalgebra that corresponds
45 sage: from mjo.eja.eja_algebra import (RealSymmetricEJA,
50 sage: J = RealSymmetricEJA(3)
51 sage: x = sum(J.gens())
53 e0 + e1 + e2 + e3 + e4 + e5
54 sage: A = x.subalgebra_generated_by()
57 sage: A(x).superalgebra_element()
58 e0 + e1 + e2 + e3 + e4 + e5
59 sage: y = sum(A.gens())
62 sage: B = y.subalgebra_generated_by()
65 sage: B(y).superalgebra_element()
70 We can convert back and forth faithfully::
72 sage: set_random_seed()
73 sage: J = random_eja()
74 sage: x = J.random_element()
75 sage: A = x.subalgebra_generated_by()
76 sage: A(x).superalgebra_element() == x
78 sage: y = A.random_element()
79 sage: A(y.superalgebra_element()) == y
81 sage: B = y.subalgebra_generated_by()
82 sage: B(y).superalgebra_element() == y
86 return self
.parent().superalgebra()(self
.to_matrix())
91 class FiniteDimensionalEJASubalgebra(FiniteDimensionalEJA
):
93 A subalgebra of an EJA with a given basis.
97 sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
99 ....: RealSymmetricEJA)
100 sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra
104 The following Peirce subalgebras of the 2-by-2 real symmetric
105 matrices do not contain the superalgebra's identity element::
107 sage: J = RealSymmetricEJA(2)
108 sage: E11 = matrix(AA, [ [1,0],
110 sage: E22 = matrix(AA, [ [0,0],
112 sage: K1 = FiniteDimensionalEJASubalgebra(J, (J(E11),))
113 sage: K1.one().to_matrix()
116 sage: K2 = FiniteDimensionalEJASubalgebra(J, (J(E22),))
117 sage: K2.one().to_matrix()
123 Ensure that our generator names don't conflict with the superalgebra::
125 sage: J = JordanSpinEJA(3)
126 sage: J.one().subalgebra_generated_by().gens()
128 sage: J = JordanSpinEJA(3, prefix='f')
129 sage: J.one().subalgebra_generated_by().gens()
131 sage: J = JordanSpinEJA(3, prefix='b')
132 sage: J.one().subalgebra_generated_by().gens()
135 Ensure that we can find subalgebras of subalgebras::
137 sage: A = ComplexHermitianEJA(3).one().subalgebra_generated_by()
138 sage: B = A.one().subalgebra_generated_by()
143 def __init__(self
, superalgebra
, basis
, **kwargs
):
144 self
._superalgebra
= superalgebra
145 V
= self
._superalgebra
.vector_space()
146 field
= self
._superalgebra
.base_ring()
148 # A half-assed attempt to ensure that we don't collide with
149 # the superalgebra's prefix (ignoring the fact that there
150 # could be super-superelgrbas in scope). If possible, we
151 # try to "increment" the parent algebra's prefix, although
152 # this idea goes out the window fast because some prefixen
154 prefixen
= [ 'f', 'g', 'h', 'a', 'b', 'c', 'd' ]
156 prefix
= prefixen
[prefixen
.index(self
._superalgebra
.prefix()) + 1]
160 # The superalgebra constructor expects these to be in original matrix
161 # form, not algebra-element form.
162 matrix_basis
= tuple( b
.to_matrix() for b
in basis
)
163 def jordan_product(x
,y
):
164 return (self
._superalgebra
(x
)*self
._superalgebra
(y
)).to_matrix()
166 def inner_product(x
,y
):
167 return self
._superalgebra
(x
).inner_product(self
._superalgebra
(y
))
169 super().__init
__(matrix_basis
,
177 def _element_constructor_(self
, elt
):
179 Construct an element of this subalgebra from the given one.
180 The only valid arguments are elements of the parent algebra
181 that happen to live in this subalgebra.
185 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
186 sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra
190 sage: J = RealSymmetricEJA(3)
191 sage: X = matrix(AA, [ [0,0,1],
195 sage: basis = ( x, x^2 ) # x^2 is the identity matrix
196 sage: K = FiniteDimensionalEJASubalgebra(J, basis, orthonormalize=False)
205 if elt
in self
.superalgebra():
206 return super()._element
_constructor
_(elt
.to_matrix())
208 return super()._element
_constructor
_(elt
)
212 def matrix_space(self
):
214 Return the matrix space of this algebra, which is identical to
215 that of its superalgebra.
217 This is correct "by definition," and avoids a mismatch when
218 the subalgebra is trivial (with no matrix basis elements to
219 infer anything from) and the parent is not.
221 return self
.superalgebra().matrix_space()
224 def superalgebra(self
):
226 Return the superalgebra that this algebra was generated from.
228 return self
._superalgebra
231 Element
= FiniteDimensionalEJASubalgebraElement