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...
85 Codomain: Euclidean Jordan algebra of dimension 3 over...
87 If you try to add two identical vector space operators but on
88 different EJAs, that should blow up::
90 sage: J1 = RealSymmetricEJA(2)
91 sage: J2 = JordanSpinEJA(3)
92 sage: id = identity_matrix(QQ, 3)
93 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,J1,id)
94 sage: g = FiniteDimensionalEuclideanJordanAlgebraOperator(J2,J2,id)
96 Traceback (most recent call last):
98 TypeError: unsupported operand parent(s) for +: ...
101 return FiniteDimensionalEuclideanJordanAlgebraOperator(
104 self
.matrix() + other
.matrix())
107 def _composition_(self
, other
, homset
):
109 Compose two EJA operators to get another one (and NOT a formal
110 composite object) back.
114 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
115 sage: from mjo.eja.eja_algebra import (
117 ....: RealCartesianProductEJA,
118 ....: RealSymmetricEJA)
122 sage: J1 = JordanSpinEJA(3)
123 sage: J2 = RealCartesianProductEJA(2)
124 sage: J3 = RealSymmetricEJA(1)
125 sage: mat1 = matrix(QQ, [[1,2,3],
127 sage: mat2 = matrix(QQ, [[7,8]])
128 sage: g = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,
131 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J2,
135 Linear operator between finite-dimensional Euclidean Jordan
136 algebras represented by the matrix:
138 Domain: Euclidean Jordan algebra of dimension 3 over
140 Codomain: Euclidean Jordan algebra of dimension 1 over
144 return FiniteDimensionalEuclideanJordanAlgebraOperator(
147 self
.matrix()*other
.matrix())
150 def __eq__(self
, other
):
151 if self
.domain() != other
.domain():
153 if self
.codomain() != other
.codomain():
155 if self
.matrix() != other
.matrix():
160 def __invert__(self
):
162 Invert this EJA operator.
166 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
167 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
171 sage: J = RealSymmetricEJA(2)
172 sage: id = identity_matrix(J.base_ring(), J.dimension())
173 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
175 Linear operator between finite-dimensional Euclidean Jordan
176 algebras represented by the matrix:
180 Domain: Euclidean Jordan algebra of dimension 3 over...
181 Codomain: Euclidean Jordan algebra of dimension 3 over...
184 return FiniteDimensionalEuclideanJordanAlgebraOperator(
190 def __mul__(self
, other
):
192 Compose two EJA operators, or scale myself by an element of the
193 ambient vector space.
195 We need to override the real ``__mul__`` function to prevent the
196 coercion framework from throwing an error when it fails to convert
197 a base ring element into a morphism.
201 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
202 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
206 We can scale an operator on a rational algebra by a rational number::
208 sage: J = RealSymmetricEJA(2)
209 sage: e0,e1,e2 = J.gens()
210 sage: x = 2*e0 + 4*e1 + 16*e2
212 Linear operator between finite-dimensional Euclidean Jordan algebras
213 represented by the matrix:
217 Domain: Euclidean Jordan algebra of dimension 3 over...
218 Codomain: Euclidean Jordan algebra of dimension 3 over...
219 sage: x.operator()*(1/2)
220 Linear operator between finite-dimensional Euclidean Jordan algebras
221 represented by the matrix:
225 Domain: Euclidean Jordan algebra of dimension 3 over...
226 Codomain: Euclidean Jordan algebra of dimension 3 over...
230 if other
in self
.codomain().base_ring():
231 return FiniteDimensionalEuclideanJordanAlgebraOperator(
235 except NotImplementedError:
236 # This can happen with certain arguments if the base_ring()
237 # is weird and doesn't know how to test membership.
240 # This should eventually delegate to _composition_ after performing
241 # some sanity checks for us.
242 mor
= super(FiniteDimensionalEuclideanJordanAlgebraOperator
,self
)
243 return mor
.__mul
__(other
)
248 Negate this EJA operator.
252 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
253 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
257 sage: J = RealSymmetricEJA(2)
258 sage: id = identity_matrix(J.base_ring(), J.dimension())
259 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
261 Linear operator between finite-dimensional Euclidean Jordan
262 algebras represented by the matrix:
266 Domain: Euclidean Jordan algebra of dimension 3 over...
267 Codomain: Euclidean Jordan algebra of dimension 3 over...
270 return FiniteDimensionalEuclideanJordanAlgebraOperator(
276 def __pow__(self
, n
):
278 Raise this EJA operator to the power ``n``.
282 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
283 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
287 Ensure that we get back another EJA operator that can be added,
288 subtracted, et cetera::
290 sage: J = RealSymmetricEJA(2)
291 sage: id = identity_matrix(J.base_ring(), J.dimension())
292 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
293 sage: f^0 + f^1 + f^2
294 Linear operator between finite-dimensional Euclidean Jordan
295 algebras represented by the matrix:
299 Domain: Euclidean Jordan algebra of dimension 3 over...
300 Codomain: Euclidean Jordan algebra of dimension 3 over...
306 # Raising a vector space morphism to the zero power gives
307 # you back a special IdentityMorphism that is useless to us.
308 rows
= self
.codomain().dimension()
309 cols
= self
.domain().dimension()
310 mat
= matrix
.identity(self
.base_ring(), rows
, cols
)
312 mat
= self
.matrix()**n
314 return FiniteDimensionalEuclideanJordanAlgebraOperator(
323 A text representation of this linear operator on a Euclidean
328 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
329 sage: from mjo.eja.eja_algebra import JordanSpinEJA
333 sage: J = JordanSpinEJA(2)
334 sage: id = identity_matrix(J.base_ring(), J.dimension())
335 sage: FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
336 Linear operator between finite-dimensional Euclidean Jordan
337 algebras represented by the matrix:
340 Domain: Euclidean Jordan algebra of dimension 2 over
342 Codomain: Euclidean Jordan algebra of dimension 2 over
346 msg
= ("Linear operator between finite-dimensional Euclidean Jordan "
347 "algebras represented by the matrix:\n",
351 return ''.join(msg
).format(self
.matrix(),
356 def _sub_(self
, other
):
358 Subtract ``other`` from this EJA operator.
362 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
363 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
367 sage: J = RealSymmetricEJA(2)
368 sage: id = identity_matrix(J.base_ring(),J.dimension())
369 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,id)
371 Linear operator between finite-dimensional Euclidean Jordan
372 algebras represented by the matrix:
376 Domain: Euclidean Jordan algebra of dimension 3 over...
377 Codomain: Euclidean Jordan algebra of dimension 3 over...
380 return (self
+ (-other
))
385 Return the matrix representation of this operator with respect
386 to the default bases of its (co)domain.
390 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
391 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
395 sage: J = RealSymmetricEJA(2)
396 sage: mat = matrix(J.base_ring(), J.dimension(), range(9))
397 sage: f = FiniteDimensionalEuclideanJordanAlgebraOperator(J,J,mat)
407 def minimal_polynomial(self
):
409 Return the minimal polynomial of this linear operator,
410 in the variable ``t``.
414 sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
415 sage: from mjo.eja.eja_algebra import RealSymmetricEJA
419 sage: J = RealSymmetricEJA(3)
420 sage: J.one().operator().minimal_polynomial()
424 # The matrix method returns a polynomial in 'x' but want one in 't'.
425 return self
.matrix().minimal_polynomial().change_variable_name('t')