2 Euclidean Jordan Algebras. These are formally-real Jordan Algebras;
3 specifically those where u^2 + v^2 = 0 implies that u = v = 0. They
4 are used in optimization, and have some additional nice methods beyond
5 what can be supported in a general Jordan Algebra.
8 from sage
.categories
.magmatic_algebras
import MagmaticAlgebras
9 from sage
.structure
.element
import is_Matrix
10 from sage
.structure
.category_object
import normalize_names
12 from sage
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra
import FiniteDimensionalAlgebra
13 from sage
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra_element
import FiniteDimensionalAlgebraElement
15 class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra
):
17 def __classcall_private__(cls
,
21 assume_associative
=False,
25 mult_table
= [b
.base_extend(field
) for b
in mult_table
]
28 if not (is_Matrix(b
) and b
.dimensions() == (n
, n
)):
29 raise ValueError("input is not a multiplication table")
30 mult_table
= tuple(mult_table
)
32 cat
= MagmaticAlgebras(field
).FiniteDimensional().WithBasis()
33 cat
.or_subcategory(category
)
34 if assume_associative
:
35 cat
= cat
.Associative()
37 names
= normalize_names(n
, names
)
39 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, cls
)
40 return fda
.__classcall
__(cls
,
43 assume_associative
=assume_associative
,
49 def __init__(self
, field
,
52 assume_associative
=False,
56 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, self
)
65 Return a string representation of ``self``.
67 fmt
= "Euclidean Jordan algebra of degree {} over {}"
68 return fmt
.format(self
.degree(), self
.base_ring())
72 Return the rank of this EJA.
74 if self
._rank
is None:
75 raise ValueError("no rank specified at genesis")
80 class Element(FiniteDimensionalAlgebraElement
):
82 An element of a Euclidean Jordan algebra.
84 Since EJAs are commutative, the "right multiplication" matrix is
85 also the left multiplication matrix and must be symmetric::
87 sage: set_random_seed()
88 sage: n = ZZ.random_element(1,10).abs()
90 sage: J.random_element().matrix().is_symmetric()
93 sage: J.random_element().matrix().is_symmetric()
100 Return ``self`` raised to the power ``n``.
102 Jordan algebras are always power-associative; see for
103 example Faraut and Koranyi, Proposition II.1.2 (ii).
107 We have to override this because our superclass uses row vectors
108 instead of column vectors! We, on the other hand, assume column
113 sage: set_random_seed()
115 sage: x = J.random_element()
116 sage: x.matrix()*x.vector() == (x**2).vector()
126 return A
.element_class(A
, (self
.matrix()**(n
-1))*self
.vector())
129 def is_regular(self
):
131 Return whether or not this is a regular element.
135 The identity element always has degree one, but any element
136 linearly-independent from it is regular::
139 sage: J.one().is_regular()
141 sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity
142 sage: for x in J.gens():
143 ....: (J.one() + x).is_regular()
151 return self
.degree() == self
.parent().rank()
153 def span_of_powers(self
):
155 Return the vector space spanned by successive powers of
158 # The dimension of the subalgebra can't be greater than
159 # the big algebra, so just put everything into a list
160 # and let span() get rid of the excess.
161 V
= self
.vector().parent()
162 return V
.span( (self
**d
).vector() for d
in xrange(V
.dimension()) )
167 Compute the degree of this element the straightforward way
168 according to the definition; by appending powers to a list
169 and figuring out its dimension (that is, whether or not
170 they're linearly dependent).
175 sage: J.one().degree()
177 sage: e0,e1,e2,e3 = J.gens()
178 sage: (e0 - e1).degree()
181 In the spin factor algebra (of rank two), all elements that
182 aren't multiples of the identity are regular::
184 sage: set_random_seed()
185 sage: n = ZZ.random_element(1,10).abs()
187 sage: x = J.random_element()
188 sage: x == x.coefficient(0)*J.one() or x.degree() == 2
192 return self
.span_of_powers().dimension()
197 Return the matrix that represents left- (or right-)
198 multiplication by this element in the parent algebra.
200 We have to override this because the superclass method
201 returns a matrix that acts on row vectors (that is, on
204 fda_elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
205 return fda_elt
.matrix().transpose()
208 def subalgebra_generated_by(self
):
210 Return the associative subalgebra of the parent EJA generated
215 sage: set_random_seed()
216 sage: n = ZZ.random_element(1,10).abs()
218 sage: x = J.random_element()
219 sage: x.subalgebra_generated_by().is_associative()
222 sage: x = J.random_element()
223 sage: x.subalgebra_generated_by().is_associative()
226 Squaring in the subalgebra should be the same thing as
227 squaring in the superalgebra::
230 sage: x = J.random_element()
231 sage: u = x.subalgebra_generated_by().random_element()
232 sage: u.matrix()*u.vector() == (u**2).vector()
236 # First get the subspace spanned by the powers of myself...
237 V
= self
.span_of_powers()
240 # Now figure out the entries of the right-multiplication
241 # matrix for the successive basis elements b0, b1,... of
244 for b_right
in V
.basis():
245 eja_b_right
= self
.parent()(b_right
)
247 # The first row of the right-multiplication matrix by
248 # b1 is what we get if we apply that matrix to b1. The
249 # second row of the right multiplication matrix by b1
250 # is what we get when we apply that matrix to b2...
252 # IMPORTANT: this assumes that all vectors are COLUMN
253 # vectors, unlike our superclass (which uses row vectors).
254 for b_left
in V
.basis():
255 eja_b_left
= self
.parent()(b_left
)
256 # Multiply in the original EJA, but then get the
257 # coordinates from the subalgebra in terms of its
259 this_row
= V
.coordinates((eja_b_left
*eja_b_right
).vector())
260 b_right_rows
.append(this_row
)
261 b_right_matrix
= matrix(F
, b_right_rows
)
262 mats
.append(b_right_matrix
)
264 # It's an algebra of polynomials in one element, and EJAs
265 # are power-associative.
267 # TODO: choose generator names intelligently.
268 return FiniteDimensionalEuclideanJordanAlgebra(F
, mats
, assume_associative
=True, names
='f')
271 def minimal_polynomial(self
):
275 sage: set_random_seed()
276 sage: n = ZZ.random_element(1,10).abs()
278 sage: x = J.random_element()
279 sage: x.degree() == x.minimal_polynomial().degree()
284 sage: set_random_seed()
285 sage: n = ZZ.random_element(1,10).abs()
287 sage: x = J.random_element()
288 sage: x.degree() == x.minimal_polynomial().degree()
291 The minimal polynomial and the characteristic polynomial coincide
292 and are known (see Alizadeh, Example 11.11) for all elements of
293 the spin factor algebra that aren't scalar multiples of the
296 sage: set_random_seed()
297 sage: n = ZZ.random_element(2,10).abs()
299 sage: y = J.random_element()
300 sage: while y == y.coefficient(0)*J.one():
301 ....: y = J.random_element()
302 sage: y0 = y.vector()[0]
303 sage: y_bar = y.vector()[1:]
304 sage: actual = y.minimal_polynomial()
305 sage: x = SR.symbol('x', domain='real')
306 sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2)
307 sage: bool(actual == expected)
311 # The element we're going to call "minimal_polynomial()" on.
312 # Either myself, interpreted as an element of a finite-
313 # dimensional algebra, or an element of an associative
317 if self
.parent().is_associative():
318 elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
320 V
= self
.span_of_powers()
321 assoc_subalg
= self
.subalgebra_generated_by()
322 # Mis-design warning: the basis used for span_of_powers()
323 # and subalgebra_generated_by() must be the same, and in
325 elt
= assoc_subalg(V
.coordinates(self
.vector()))
327 # Recursive call, but should work since elt lives in an
328 # associative algebra.
329 return elt
.minimal_polynomial()
332 def is_nilpotent(self
):
334 Return whether or not some power of this element is zero.
336 The superclass method won't work unless we're in an
337 associative algebra, and we aren't. However, we generate
338 an assocoative subalgebra and we're nilpotent there if and
339 only if we're nilpotent here (probably).
343 The identity element is never nilpotent::
345 sage: set_random_seed()
346 sage: n = ZZ.random_element(2,10).abs()
348 sage: J.one().is_nilpotent()
351 sage: J.one().is_nilpotent()
354 The additive identity is always nilpotent::
356 sage: set_random_seed()
357 sage: n = ZZ.random_element(2,10).abs()
359 sage: J.zero().is_nilpotent()
362 sage: J.zero().is_nilpotent()
366 # The element we're going to call "is_nilpotent()" on.
367 # Either myself, interpreted as an element of a finite-
368 # dimensional algebra, or an element of an associative
372 if self
.parent().is_associative():
373 elt
= FiniteDimensionalAlgebraElement(self
.parent(), self
)
375 V
= self
.span_of_powers()
376 assoc_subalg
= self
.subalgebra_generated_by()
377 # Mis-design warning: the basis used for span_of_powers()
378 # and subalgebra_generated_by() must be the same, and in
380 elt
= assoc_subalg(V
.coordinates(self
.vector()))
382 # Recursive call, but should work since elt lives in an
383 # associative algebra.
384 return elt
.is_nilpotent()
387 def subalgebra_idempotent(self
):
389 Find an idempotent in the associative subalgebra I generate
390 using Proposition 2.3.5 in Baes.
394 sage: set_random_seed()
396 sage: c = J.random_element().subalgebra_idempotent()
400 sage: c = J.random_element().subalgebra_idempotent()
405 if self
.is_nilpotent():
406 raise ValueError("this only works with non-nilpotent elements!")
408 V
= self
.span_of_powers()
409 J
= self
.subalgebra_generated_by()
410 # Mis-design warning: the basis used for span_of_powers()
411 # and subalgebra_generated_by() must be the same, and in
413 u
= J(V
.coordinates(self
.vector()))
415 # The image of the matrix of left-u^m-multiplication
416 # will be minimal for some natural number s...
418 minimal_dim
= V
.dimension()
419 for i
in xrange(1, V
.dimension()):
420 this_dim
= (u
**i
).matrix().image().dimension()
421 if this_dim
< minimal_dim
:
422 minimal_dim
= this_dim
425 # Now minimal_matrix should correspond to the smallest
426 # non-zero subspace in Baes's (or really, Koecher's)
429 # However, we need to restrict the matrix to work on the
430 # subspace... or do we? Can't we just solve, knowing that
431 # A(c) = u^(s+1) should have a solution in the big space,
434 # Beware, solve_right() means that we're using COLUMN vectors.
435 # Our FiniteDimensionalAlgebraElement superclass uses rows.
438 c_coordinates
= A
.solve_right(u_next
.vector())
440 # Now c_coordinates is the idempotent we want, but it's in
441 # the coordinate system of the subalgebra.
443 # We need the basis for J, but as elements of the parent algebra.
445 basis
= [self
.parent(v
) for v
in V
.basis()]
446 return self
.parent().linear_combination(zip(c_coordinates
, basis
))
450 def characteristic_polynomial(self
):
451 return self
.matrix().characteristic_polynomial()
454 def eja_rn(dimension
, field
=QQ
):
456 Return the Euclidean Jordan Algebra corresponding to the set
457 `R^n` under the Hadamard product.
461 This multiplication table can be verified by hand::
464 sage: e0,e1,e2 = J.gens()
479 # The FiniteDimensionalAlgebra constructor takes a list of
480 # matrices, the ith representing right multiplication by the ith
481 # basis element in the vector space. So if e_1 = (1,0,0), then
482 # right (Hadamard) multiplication of x by e_1 picks out the first
483 # component of x; and likewise for the ith basis element e_i.
484 Qs
= [ matrix(field
, dimension
, dimension
, lambda k
,j
: 1*(k
== j
== i
))
485 for i
in xrange(dimension
) ]
487 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
,rank
=dimension
)
490 def eja_ln(dimension
, field
=QQ
):
492 Return the Jordan algebra corresponding to the Lorentz "ice cream"
493 cone of the given ``dimension``.
497 This multiplication table can be verified by hand::
500 sage: e0,e1,e2,e3 = J.gens()
516 In one dimension, this is the reals under multiplication::
525 id_matrix
= identity_matrix(field
,dimension
)
526 for i
in xrange(dimension
):
527 ei
= id_matrix
.column(i
)
528 Qi
= zero_matrix(field
,dimension
)
531 Qi
+= diagonal_matrix(dimension
, [ei
[0]]*dimension
)
532 # The addition of the diagonal matrix adds an extra ei[0] in the
533 # upper-left corner of the matrix.
534 Qi
[0,0] = Qi
[0,0] * ~
field(2)
537 # The rank of the spin factor algebra is two, UNLESS we're in a
538 # one-dimensional ambient space (the rank is bounded by the
539 # ambient dimension).
540 rank
= min(dimension
,2)
541 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
,rank
=rank
)