assume_associative=False,
category=None,
rank=None):
+ """
+ EXAMPLES:
+
+ By definition, Jordan multiplication commutes::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: x*y == y*x
+ True
+
+ """
self._rank = rank
fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
fda.__init__(field,
instead of column vectors! We, on the other hand, assume column
vectors everywhere.
- EXAMPLES:
+ EXAMPLES::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: x.operator_matrix()*x.vector() == (x^2).vector()
+ True
+
+ A few examples of power-associativity::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: x*(x*x)*(x*x) == x^5
+ True
+ sage: (x*x)*(x*x*x) == x^5
+ True
+
+ We also know that powers operator-commute (Koecher, Chapter
+ III, Corollary 1)::
sage: set_random_seed()
sage: x = random_eja().random_element()
- sage: x.matrix()*x.vector() == (x**2).vector()
+ sage: m = ZZ.random_element(0,10)
+ sage: n = ZZ.random_element(0,10)
+ sage: Lxm = (x^m).operator_matrix()
+ sage: Lxn = (x^n).operator_matrix()
+ sage: Lxm*Lxn == Lxn*Lxm
True
"""
elif n == 1:
return self
else:
- return A.element_class(A, (self.matrix()**(n-1))*self.vector())
+ return A( (self.operator_matrix()**(n-1))*self.vector() )
def characteristic_polynomial(self):
raise NotImplementedError('irregular element')
+ def operator_commutes_with(self, other):
+ """
+ Return whether or not this element operator-commutes
+ with ``other``.
+
+ EXAMPLES:
+
+ The definition of a Jordan algebra says that any element
+ operator-commutes with its square::
+
+ sage: set_random_seed()
+ sage: x = random_eja().random_element()
+ sage: x.operator_commutes_with(x^2)
+ True
+
+ TESTS:
+
+ Test Lemma 1 from Chapter III of Koecher::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: u = J.random_element()
+ sage: v = J.random_element()
+ sage: lhs = u.operator_commutes_with(u*v)
+ sage: rhs = v.operator_commutes_with(u^2)
+ sage: lhs == rhs
+ True
+
+ """
+ if not other in self.parent():
+ raise ArgumentError("'other' must live in the same algebra")
+
+ A = self.operator_matrix()
+ B = other.operator_matrix()
+ return (A*B == B*A)
+
+
def det(self):
"""
Return my determinant, the product of my eigenvalues.
Example 11.11::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
+ sage: n = ZZ.random_element(1,10)
sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: while x.is_zero():
aren't multiples of the identity are regular::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
+ sage: n = ZZ.random_element(1,10)
sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x == x.coefficient(0)*J.one() or x.degree() == 2
return self.span_of_powers().dimension()
- def matrix(self):
+ def operator_matrix(self):
"""
Return the matrix that represents left- (or right-)
multiplication by this element in the parent algebra.
We have to override this because the superclass method
returns a matrix that acts on row vectors (that is, on
the right).
+
+ EXAMPLES:
+
+ Test the first polarization identity from my notes, Koecher Chapter
+ III, or from Baes (2.3)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: Lx = x.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lxx = (x*x).operator_matrix()
+ sage: Lxy = (x*y).operator_matrix()
+ sage: bool(2*Lx*Lxy + Ly*Lxx == 2*Lxy*Lx + Lxx*Ly)
+ True
+
+ Test the second polarization identity from my notes or from
+ Baes (2.4)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: x = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: Lx = x.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lz = z.operator_matrix()
+ sage: Lzy = (z*y).operator_matrix()
+ sage: Lxy = (x*y).operator_matrix()
+ sage: Lxz = (x*z).operator_matrix()
+ sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly)
+ True
+
+ Test the third polarization identity from my notes or from
+ Baes (2.5)::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: u = J.random_element()
+ sage: y = J.random_element()
+ sage: z = J.random_element()
+ sage: Lu = u.operator_matrix()
+ sage: Ly = y.operator_matrix()
+ sage: Lz = z.operator_matrix()
+ sage: Lzy = (z*y).operator_matrix()
+ sage: Luy = (u*y).operator_matrix()
+ sage: Luz = (u*z).operator_matrix()
+ sage: Luyz = (u*(y*z)).operator_matrix()
+ sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz
+ sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly
+ sage: bool(lhs == rhs)
+ True
+
"""
fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self)
return fda_elt.matrix().transpose()
+
def minimal_polynomial(self):
"""
EXAMPLES::
identity::
sage: set_random_seed()
- sage: n = ZZ.random_element(2,10).abs()
+ sage: n = ZZ.random_element(2,10)
sage: J = JordanSpinSimpleEJA(n)
sage: y = J.random_element()
sage: while y == y.coefficient(0)*J.one():
Alizadeh's Example 11.12::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,10).abs()
+ sage: n = ZZ.random_element(1,10)
sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x_vec = x.vector()
Property 6:
- sage: k = ZZ.random_element(1,10).abs()
+ sage: k = ZZ.random_element(1,10)
sage: actual = (x^k).quadratic_representation()
sage: expected = (x.quadratic_representation())^k
sage: actual == expected
elif not other in self.parent():
raise ArgumentError("'other' must live in the same algebra")
- return ( self.matrix()*other.matrix()
- + other.matrix()*self.matrix()
- - (self*other).matrix() )
+ L = self.operator_matrix()
+ M = other.operator_matrix()
+ return ( L*M + M*L - (self*other).operator_matrix() )
def span_of_powers(self):
sage: set_random_seed()
sage: x = random_eja().random_element()
sage: u = x.subalgebra_generated_by().random_element()
- sage: u.matrix()*u.vector() == (u**2).vector()
+ sage: u.operator_matrix()*u.vector() == (u**2).vector()
True
"""
s = 0
minimal_dim = V.dimension()
for i in xrange(1, V.dimension()):
- this_dim = (u**i).matrix().image().dimension()
+ this_dim = (u**i).operator_matrix().image().dimension()
if this_dim < minimal_dim:
minimal_dim = this_dim
s = i
# Beware, solve_right() means that we're using COLUMN vectors.
# Our FiniteDimensionalAlgebraElement superclass uses rows.
u_next = u**(s+1)
- A = u_next.matrix()
+ A = u_next.operator_matrix()
c_coordinates = A.solve_right(u_next.vector())
# Now c_coordinates is the idempotent we want, but it's in
Euclidean Jordan algebra of degree...
"""
- n = ZZ.random_element(1,5).abs()
+ n = ZZ.random_element(1,5)
constructor = choice([eja_rn,
JordanSpinSimpleEJA,
RealSymmetricSimpleEJA,
TESTS::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5).abs()
+ sage: n = ZZ.random_element(1,5)
sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) )
True
The degree of this algebra is `(n^2 + n) / 2`::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5).abs()
+ sage: n = ZZ.random_element(1,5)
sage: J = RealSymmetricSimpleEJA(n)
sage: J.degree() == (n^2 + n)/2
True
The degree of this algebra is `n^2`::
sage: set_random_seed()
- sage: n = ZZ.random_element(1,5).abs()
+ sage: n = ZZ.random_element(1,5)
sage: J = ComplexHermitianSimpleEJA(n)
sage: J.degree() == n^2
True
projects / sage.d.git / blobdiff