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
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra
import FiniteDimensionalAlgebra
9 from sage
.algebras
.finite_dimensional_algebras
.finite_dimensional_algebra_element
import FiniteDimensionalAlgebraElement
11 class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra
):
13 def __classcall__(cls
, field
, mult_table
, names
='e', category
=None):
14 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, cls
)
15 return fda
.__classcall
_private
__(cls
,
21 def __init__(self
, field
, mult_table
, names
='e', category
=None):
22 fda
= super(FiniteDimensionalEuclideanJordanAlgebra
, self
)
23 fda
.__init
__(field
, mult_table
, names
, category
)
28 Return a string representation of ``self``.
30 return "Euclidean Jordan algebra of degree {} over {}".format(self
.degree(), self
.base_ring())
34 Return the rank of this EJA.
36 raise NotImplementedError
39 class Element(FiniteDimensionalAlgebraElement
):
41 An element of a Euclidean Jordan algebra.
43 Since EJAs are commutative, the "right multiplication" matrix is
44 also the left multiplication matrix and must be symmetric::
46 sage: set_random_seed()
48 sage: J.random_element().matrix().is_symmetric()
55 Return ``self`` raised to the power ``n``.
57 Jordan algebras are always power-associative; see for
58 example Faraut and Koranyi, Proposition II.1.2 (ii).
66 return A
.element_class(A
, self
.vector()*(self
.matrix()**(n
-1)))
69 def span_of_powers(self
):
71 Return the vector space spanned by successive powers of
74 # The dimension of the subalgebra can't be greater than
75 # the big algebra, so just put everything into a list
76 # and let span() get rid of the excess.
77 V
= self
.vector().parent()
78 return V
.span( (self
**d
).vector() for d
in xrange(V
.dimension()) )
83 Compute the degree of this element the straightforward way
84 according to the definition; by appending powers to a list
85 and figuring out its dimension (that is, whether or not
86 they're linearly dependent).
91 sage: J.one().degree()
93 sage: e0,e1,e2,e3 = J.gens()
94 sage: (e0 - e1).degree()
97 In the spin factor algebra (of rank two), all elements that
98 aren't multiples of the identity are regular::
100 sage: set_random_seed()
101 sage: n = ZZ.random_element(1,10).abs()
103 sage: x = J.random_element()
104 sage: x == x.coefficient(0)*J.one() or x.degree() == 2
108 return self
.span_of_powers().dimension()
111 def subalgebra_generated_by(self
):
113 Return the subalgebra of the parent EJA generated by this element.
115 # First get the subspace spanned by the powers of myself...
116 V
= self
.span_of_powers()
119 # Now figure out the entries of the right-multiplication
120 # matrix for the successive basis elements b0, b1,... of
123 for b_right
in V
.basis():
124 eja_b_right
= self
.parent()(b_right
)
126 # The first row of the right-multiplication matrix by
127 # b1 is what we get if we apply that matrix to b1. The
128 # second row of the right multiplication matrix by b1
129 # is what we get when we apply that matrix to b2...
130 for b_left
in V
.basis():
131 eja_b_left
= self
.parent()(b_left
)
132 # Multiply in the original EJA, but then get the
133 # coordinates from the subalgebra in terms of its
135 this_row
= V
.coordinates((eja_b_left
*eja_b_right
).vector())
136 b_right_rows
.append(this_row
)
137 b_right_matrix
= matrix(F
, b_right_rows
)
138 mats
.append(b_right_matrix
)
140 return FiniteDimensionalEuclideanJordanAlgebra(F
, mats
)
143 def minimal_polynomial(self
):
147 sage: set_random_seed()
148 sage: n = ZZ.random_element(1,10).abs()
150 sage: x = J.random_element()
151 sage: x.degree() == x.minimal_polynomial().degree()
156 sage: set_random_seed()
157 sage: n = ZZ.random_element(1,10).abs()
159 sage: x = J.random_element()
160 sage: x.degree() == x.minimal_polynomial().degree()
163 The minimal polynomial and the characteristic polynomial coincide
164 and are known (see Alizadeh, Example 11.11) for all elements of
165 the spin factor algebra that aren't scalar multiples of the
168 sage: set_random_seed()
169 sage: n = ZZ.random_element(2,10).abs()
171 sage: y = J.random_element()
172 sage: while y == y.coefficient(0)*J.one():
173 ....: y = J.random_element()
174 sage: y0 = y.vector()[0]
175 sage: y_bar = y.vector()[1:]
176 sage: actual = y.minimal_polynomial()
177 sage: x = SR.symbol('x', domain='real')
178 sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2)
179 sage: bool(actual == expected)
183 V
= self
.span_of_powers()
184 assoc_subalg
= self
.subalgebra_generated_by()
185 # Mis-design warning: the basis used for span_of_powers()
186 # and subalgebra_generated_by() must be the same, and in
188 subalg_self
= assoc_subalg(V
.coordinates(self
.vector()))
189 return subalg_self
.matrix().minimal_polynomial()
192 def characteristic_polynomial(self
):
193 return self
.matrix().characteristic_polynomial()
196 def eja_rn(dimension
, field
=QQ
):
198 Return the Euclidean Jordan Algebra corresponding to the set
199 `R^n` under the Hadamard product.
203 This multiplication table can be verified by hand::
206 sage: e0,e1,e2 = J.gens()
221 # The FiniteDimensionalAlgebra constructor takes a list of
222 # matrices, the ith representing right multiplication by the ith
223 # basis element in the vector space. So if e_1 = (1,0,0), then
224 # right (Hadamard) multiplication of x by e_1 picks out the first
225 # component of x; and likewise for the ith basis element e_i.
226 Qs
= [ matrix(field
, dimension
, dimension
, lambda k
,j
: 1*(k
== j
== i
))
227 for i
in xrange(dimension
) ]
229 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
)
232 def eja_ln(dimension
, field
=QQ
):
234 Return the Jordan algebra corresponding to the Lorentz "ice cream"
235 cone of the given ``dimension``.
239 This multiplication table can be verified by hand::
242 sage: e0,e1,e2,e3 = J.gens()
258 In one dimension, this is the reals under multiplication::
267 id_matrix
= identity_matrix(field
,dimension
)
268 for i
in xrange(dimension
):
269 ei
= id_matrix
.column(i
)
270 Qi
= zero_matrix(field
,dimension
)
273 Qi
+= diagonal_matrix(dimension
, [ei
[0]]*dimension
)
274 # The addition of the diagonal matrix adds an extra ei[0] in the
275 # upper-left corner of the matrix.
276 Qi
[0,0] = Qi
[0,0] * ~
field(2)
279 return FiniteDimensionalEuclideanJordanAlgebra(field
,Qs
)