1 from sage
.matrix
.constructor
import matrix
2 from sage
.categories
.all
import FreeModules
3 from sage
.categories
.map import Map
5 class FiniteDimensionalEuclideanJordanAlgebraOperator(Map
):
6 def __init__(self
, domain_eja
, codomain_eja
, mat
):
8 # isinstance(domain_eja, FiniteDimensionalEuclideanJordanAlgebra) and
9 # isinstance(codomain_eja, FiniteDimensionalEuclideanJordanAlgebra) ):
10 # raise ValueError('(co)domains must be finite-dimensional Euclidean '
13 F
= domain_eja
.base_ring()
14 if not (F
== codomain_eja
.base_ring()):
15 raise ValueError("domain and codomain must have the same base ring")
17 # We need to supply something here to avoid getting the
18 # default Homset of the parent FiniteDimensionalAlgebra class,
19 # which messes up e.g. equality testing. We use FreeModules(F)
20 # instead of VectorSpaces(F) because our characteristic polynomial
21 # algorithm will need to F to be a polynomial ring at some point.
22 # When F is a field, FreeModules(F) returns VectorSpaces(F) anyway.
23 parent
= domain_eja
.Hom(codomain_eja
, FreeModules(F
))
25 # The Map initializer will set our parent to a homset, which
26 # is explicitly NOT what we want, because these ain't algebra
28 super(FiniteDimensionalEuclideanJordanAlgebraOperator
,self
).__init
__(parent
)
30 # Keep a matrix around to do all of the real work. It would
31 # be nice if we could use a VectorSpaceMorphism instead, but
32 # those use row vectors that we don't want to accidentally
33 # expose to our users.
39 Allow this operator to be called only on elements of an EJA.
43 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
44 sage: from mjo.eja.eja_algebra import JordanSpinEJA
48 sage: J = JordanSpinEJA(3)
49 sage: x = J.linear_combination(zip(J.gens(),range(len(J.gens()))))
50 sage: id = identity_matrix(J.base_ring(), J.dimension())
51 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
56 return self
.codomain().from_vector(self
.matrix()*x
.to_vector())
59 def _add_(self
, other
):
61 Add the ``other`` EJA operator to this one.
65 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
66 sage: from mjo.eja.eja_algebra import (
68 ....: RealSymmetricEJA )
72 When we add two EJA operators, we get another one back::
74 sage: J = RealSymmetricEJA(2)
75 sage: id = identity_matrix(J.base_ring(), J.dimension())
76 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
77 sage: g = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
79 Linear operator between finite-dimensional Euclidean Jordan
80 algebras represented by the matrix:
84 Domain: Euclidean Jordan algebra of dimension 3 over
86 Codomain: Euclidean Jordan algebra of dimension 3 over
89 If you try to add two identical vector space operators but on
90 different EJAs, that should blow up::
92 sage: J1 = RealSymmetricEJA(2)
93 sage: J2 = JordanSpinEJA(3)
94 sage: id = identity_matrix(QQ, 3)
95 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,J1,id)
96 sage: g = FiniteDimensionalEuclideanJordanAlgebraOperator(J2,J2,id)
98 Traceback (most recent call last):
100 TypeError: unsupported operand parent(s) for +: ...
103 return FiniteDimensionalEuclideanJordanAlgebraOperator(
106 self
.matrix() + other
.matrix())
109 def _composition_(self
, other
, homset
):
111 Compose two EJA operators to get another one (and NOT a formal
112 composite object) back.
116 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
117 sage: from mjo.eja.eja_algebra import (
119 ....: RealCartesianProductEJA,
120 ....: RealSymmetricEJA)
124 sage: J1 = JordanSpinEJA(3)
125 sage: J2 = RealCartesianProductEJA(2)
126 sage: J3 = RealSymmetricEJA(1)
127 sage: mat1 = matrix(QQ, [[1,2,3],
129 sage: mat2 = matrix(QQ, [[7,8]])
130 sage: g = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,
133 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J2,
137 Linear operator between finite-dimensional Euclidean Jordan
138 algebras represented by the matrix:
140 Domain: Euclidean Jordan algebra of dimension 3 over
142 Codomain: Euclidean Jordan algebra of dimension 1 over
146 return FiniteDimensionalEuclideanJordanAlgebraOperator(
149 self
.matrix()*other
.matrix())
152 def __eq__(self
, other
):
153 if self
.domain() != other
.domain():
155 if self
.codomain() != other
.codomain():
157 if self
.matrix() != other
.matrix():
162 def __invert__(self
):
164 Invert this EJA operator.
168 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
169 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
173 sage: J = RealSymmetricEJA(2)
174 sage: id = identity_matrix(J.base_ring(), J.dimension())
175 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
177 Linear operator between finite-dimensional Euclidean Jordan
178 algebras represented by the matrix:
182 Domain: Euclidean Jordan algebra of dimension 3 over
184 Codomain: Euclidean Jordan algebra of dimension 3 over
188 return FiniteDimensionalEuclideanJordanAlgebraOperator(
194 def __mul__(self
, other
):
196 Compose two EJA operators, or scale myself by an element of the
197 ambient vector space.
199 We need to override the real ``__mul__`` function to prevent the
200 coercion framework from throwing an error when it fails to convert
201 a base ring element into a morphism.
205 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
206 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
210 We can scale an operator on a rational algebra by a rational number::
212 sage: J = RealSymmetricEJA(2)
213 sage: e0,e1,e2 = J.gens()
214 sage: x = 2*e0 + 4*e1 + 16*e2
216 Linear operator between finite-dimensional Euclidean Jordan algebras
217 represented by the matrix:
221 Domain: Euclidean Jordan algebra of dimension 3 over
223 Codomain: Euclidean Jordan algebra of dimension 3 over
225 sage: x.operator()*(1/2)
226 Linear operator between finite-dimensional Euclidean Jordan algebras
227 represented by the matrix:
231 Domain: Euclidean Jordan algebra of dimension 3 over
233 Codomain: Euclidean Jordan algebra of dimension 3 over
237 if other
in self
.codomain().base_ring():
238 return FiniteDimensionalEuclideanJordanAlgebraOperator(
243 # This should eventually delegate to _composition_ after performing
244 # some sanity checks for us.
245 mor
= super(FiniteDimensionalEuclideanJordanAlgebraOperator
,self
)
246 return mor
.__mul
__(other
)
251 Negate this EJA operator.
255 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
256 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
260 sage: J = RealSymmetricEJA(2)
261 sage: id = identity_matrix(J.base_ring(), J.dimension())
262 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
264 Linear operator between finite-dimensional Euclidean Jordan
265 algebras represented by the matrix:
269 Domain: Euclidean Jordan algebra of dimension 3 over
271 Codomain: Euclidean Jordan algebra of dimension 3 over
275 return FiniteDimensionalEuclideanJordanAlgebraOperator(
281 def __pow__(self
, n
):
283 Raise this EJA operator to the power ``n``.
287 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
288 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
292 Ensure that we get back another EJA operator that can be added,
293 subtracted, et cetera::
295 sage: J = RealSymmetricEJA(2)
296 sage: id = identity_matrix(J.base_ring(), J.dimension())
297 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
298 sage: f^0 + f^1 + f^2
299 Linear operator between finite-dimensional Euclidean Jordan
300 algebras represented by the matrix:
304 Domain: Euclidean Jordan algebra of dimension 3 over
306 Codomain: Euclidean Jordan algebra of dimension 3 over
313 # Raising a vector space morphism to the zero power gives
314 # you back a special IdentityMorphism that is useless to us.
315 rows
= self
.codomain().dimension()
316 cols
= self
.domain().dimension()
317 mat
= matrix
.identity(self
.base_ring(), rows
, cols
)
319 mat
= self
.matrix()**n
321 return FiniteDimensionalEuclideanJordanAlgebraOperator(
330 A text representation of this linear operator on a Euclidean
335 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
336 sage: from mjo.eja.eja_algebra import JordanSpinEJA
340 sage: J = JordanSpinEJA(2)
341 sage: id = identity_matrix(J.base_ring(), J.dimension())
342 sage: FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
343 Linear operator between finite-dimensional Euclidean Jordan
344 algebras represented by the matrix:
347 Domain: Euclidean Jordan algebra of dimension 2 over
349 Codomain: Euclidean Jordan algebra of dimension 2 over
353 msg
= ("Linear operator between finite-dimensional Euclidean Jordan "
354 "algebras represented by the matrix:\n",
358 return ''.join(msg
).format(self
.matrix(),
363 def _sub_(self
, other
):
365 Subtract ``other`` from this EJA operator.
369 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
370 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
374 sage: J = RealSymmetricEJA(2)
375 sage: id = identity_matrix(J.base_ring(),J.dimension())
376 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
378 Linear operator between finite-dimensional Euclidean Jordan
379 algebras represented by the matrix:
383 Domain: Euclidean Jordan algebra of dimension 3 over
385 Codomain: Euclidean Jordan algebra of dimension 3 over
389 return (self
+ (-other
))
394 Return the matrix representation of this operator with respect
395 to the default bases of its (co)domain.
399 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
400 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
404 sage: J = RealSymmetricEJA(2)
405 sage: mat = matrix(J.base_ring(), J.dimension(), range(9))
406 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,mat)
416 def minimal_polynomial(self
):
418 Return the minimal polynomial of this linear operator,
419 in the variable ``t``.
423 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
424 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
428 sage: J = RealSymmetricEJA(3)
429 sage: J.one().operator().minimal_polynomial()
433 # The matrix method returns a polynomial in 'x' but want one in 't'.
434 return self
.matrix().minimal_polynomial().change_variable_name('t')