The definition of `x^2` is the unambiguous `x*x`::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: x*x == (x^2)
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
We also know that powers operator-commute (Koecher, Chapter
III, Corollary 1)::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: m = ZZ.random_element(0,10)
sage: n = ZZ.random_element(0,10)
We should always get back an element of the algebra::
- sage: set_random_seed()
sage: p = PolynomialRing(AA, 't').random_element()
sage: J = random_eja()
sage: x = J.random_element()
The characteristic polynomial of an element should evaluate
to zero on that element::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: p = x.characteristic_polynomial()
sage: x.apply_univariate_polynomial(p).is_zero()
Ensure that we can always compute an inner product, and that
it gives us back a real number::
- sage: set_random_seed()
sage: J = random_eja()
sage: x,y = J.random_elements(2)
sage: x.inner_product(y) in RLF
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
Test Lemma 1 from Chapter III of Koecher::
- sage: set_random_seed()
sage: u,v = random_eja().random_elements(2)
sage: lhs = u.operator_commutes_with(u*v)
sage: rhs = v.operator_commutes_with(u^2)
Test the first polarization identity from my notes, Koecher
Chapter III, or from Baes (2.3)::
- sage: set_random_seed()
sage: x,y = random_eja().random_elements(2)
sage: Lx = x.operator()
sage: Ly = y.operator()
Test the second polarization identity from my notes or from
Baes (2.4)::
- sage: set_random_seed()
- sage: x,y,z = random_eja().random_elements(3)
- sage: Lx = x.operator()
- sage: Ly = y.operator()
- sage: Lz = z.operator()
- sage: Lzy = (z*y).operator()
- sage: Lxy = (x*y).operator()
- sage: Lxz = (x*z).operator()
- sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly)
+ sage: x,y,z = random_eja().random_elements(3) # long time
+ sage: Lx = x.operator() # long time
+ sage: Ly = y.operator() # long time
+ sage: Lz = z.operator() # long time
+ sage: Lzy = (z*y).operator() # long time
+ sage: Lxy = (x*y).operator() # long time
+ sage: Lxz = (x*z).operator() # long time
+ sage: lhs = Lx*Lzy + Lz*Lxy + Ly*Lxz # long time
+ sage: rhs = Lzy*Lx + Lxy*Lz + Lxz*Ly # long time
+ sage: bool(lhs == rhs) # long time
True
Test the third polarization identity from my notes or from
Baes (2.5)::
- sage: set_random_seed()
- sage: u,y,z = random_eja().random_elements(3)
- sage: Lu = u.operator()
- sage: Ly = y.operator()
- sage: Lz = z.operator()
- sage: Lzy = (z*y).operator()
- sage: Luy = (u*y).operator()
- sage: Luz = (u*z).operator()
- sage: Luyz = (u*(y*z)).operator()
- sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz
- sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly
- sage: bool(lhs == rhs)
+ sage: u,y,z = random_eja().random_elements(3) # long time
+ sage: Lu = u.operator() # long time
+ sage: Ly = y.operator() # long time
+ sage: Lz = z.operator() # long time
+ sage: Lzy = (z*y).operator() # long time
+ sage: Luy = (u*y).operator() # long time
+ sage: Luz = (u*z).operator() # long time
+ sage: Luyz = (u*(y*z)).operator() # long time
+ sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz # long time
+ sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly # long time
+ sage: bool(lhs == rhs) # long time
True
"""
An element is invertible if and only if its determinant is
non-zero::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: x.is_invertible() == (x.det() != 0)
True
Ensure that the determinant is multiplicative on an associative
subalgebra as in Faraut and Korányi's Proposition II.2.2::
- sage: set_random_seed()
- sage: J = random_eja().random_element().subalgebra_generated_by()
+ sage: x0 = random_eja().random_element()
+ sage: J = x0.subalgebra_generated_by(orthonormalize=False)
sage: x,y = J.random_elements(2)
sage: (x*y).det() == x.det()*y.det()
True
The determinant in real matrix algebras is the usual determinant::
- sage: set_random_seed()
sage: X = matrix.random(QQ,3)
sage: X = X + X.T
sage: J1 = RealSymmetricEJA(3)
The inverse in the spin factor algebra is given in Alizadeh's
Example 11.11::
- sage: set_random_seed()
sage: J = JordanSpinEJA.random_instance()
sage: x = J.random_element()
sage: while not x.is_invertible():
The identity element is its own inverse::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.one().inverse() == J.one()
True
If an element has an inverse, it acts like one::
- sage: set_random_seed()
sage: J = random_eja()
sage: x = J.random_element()
sage: (not x.is_invertible()) or (x.inverse()*x == J.one())
The inverse of the inverse is what we started with::
- sage: set_random_seed()
sage: J = random_eja()
sage: x = J.random_element()
sage: (not x.is_invertible()) or (x.inverse().inverse() == x)
of an element is the inverse of its left-multiplication operator
applied to the algebra's identity, when that inverse exists::
- sage: set_random_seed()
- sage: J = random_eja()
- sage: x = J.random_element()
- sage: (not x.operator().is_invertible()) or (
- ....: x.operator().inverse()(J.one()) == x.inverse() )
+ sage: J = random_eja() # long time
+ sage: x = J.random_element() # long time
+ sage: (not x.operator().is_invertible()) or ( # long time
+ ....: x.operator().inverse()(J.one()) # long time
+ ....: == # long time
+ ....: x.inverse() ) # long time
True
Check that the fast (cached) and slow algorithms give the same
answer::
- sage: set_random_seed() # long time
sage: J = random_eja(field=QQ, orthonormalize=False) # long time
sage: x = J.random_element() # long time
sage: while not x.is_invertible(): # long time
True
"""
not_invertible_msg = "element is not invertible"
- if self.parent()._charpoly_coefficients.is_in_cache():
+
+ algebra = self.parent()
+ if algebra._charpoly_coefficients.is_in_cache():
# We can invert using our charpoly if it will be fast to
# compute. If the coefficients are cached, our rank had
# better be too!
if self.det().is_zero():
raise ZeroDivisionError(not_invertible_msg)
- r = self.parent().rank()
+ r = algebra.rank()
a = self.characteristic_polynomial().coefficients(sparse=False)
- return (-1)**(r+1)*sum(a[i+1]*self**i for i in range(r))/self.det()
+ return (-1)**(r+1)*algebra.sum(a[i+1]*self**i
+ for i in range(r))/self.det()
try:
inv = (~self.quadratic_representation())(self)
The identity element is always invertible::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.one().is_invertible()
True
The zero element is never invertible in a non-trivial algebra::
- sage: set_random_seed()
sage: J = random_eja()
sage: (not J.is_trivial()) and J.zero().is_invertible()
False
Test that the fast (cached) and slow algorithms give the same
answer::
- sage: set_random_seed() # long time
sage: J = random_eja(field=QQ, orthonormalize=False) # long time
sage: x = J.random_element() # long time
sage: slow = x.is_invertible() # long time
The identity element is minimal only in an EJA of rank one::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.rank() == 1 or not J.one().is_primitive_idempotent()
True
A non-idempotent cannot be a minimal idempotent::
- sage: set_random_seed()
sage: J = JordanSpinEJA(4)
sage: x = J.random_element()
sage: (not x.is_idempotent()) and x.is_primitive_idempotent()
idempotent if and only if it's idempotent with trace equal to
unity::
- sage: set_random_seed()
sage: J = JordanSpinEJA(4)
sage: x = J.random_element()
sage: expected = (x.is_idempotent() and x.trace() == 1)
Primitive idempotents must be non-zero::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.zero().is_idempotent()
True
The identity element is never nilpotent, except in a trivial EJA::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.one().is_nilpotent() and not J.is_trivial()
False
The additive identity is always nilpotent::
- sage: set_random_seed()
sage: random_eja().zero().is_nilpotent()
True
The zero element should never be regular, unless the parent
algebra has dimension less than or equal to one::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.dimension() <= 1 or not J.zero().is_regular()
True
The unit element isn't regular unless the algebra happens to
consist of only its scalar multiples::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.dimension() <= 1 or not J.one().is_regular()
True
In the spin factor algebra (of rank two), all elements that
aren't multiples of the identity are regular::
- sage: set_random_seed()
sage: J = JordanSpinEJA.random_instance()
sage: n = J.dimension()
sage: x = J.random_element()
The zero and unit elements are both of degree one in nontrivial
algebras::
- sage: set_random_seed()
sage: J = random_eja()
sage: d = J.zero().degree()
sage: (J.is_trivial() and d == 0) or d == 1
Our implementation agrees with the definition::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
always the same, except in trivial algebras where the minimal
polynomial of the unit/zero element is ``1``::
- sage: set_random_seed()
sage: J = random_eja()
sage: mu = J.one().minimal_polynomial()
sage: t = mu.parent().gen()
The degree of an element is (by one definition) the degree
of its minimal polynomial::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: x.degree() == x.minimal_polynomial().degree()
True
identity. We require the dimension of the algebra to be at least
two here so that said elements actually exist::
- sage: set_random_seed()
sage: d_max = JordanSpinEJA._max_random_instance_dimension()
sage: n = ZZ.random_element(2, max(2,d_max))
sage: J = JordanSpinEJA(n)
The minimal polynomial should always kill its element::
- sage: set_random_seed()
- sage: x = random_eja().random_element()
- sage: p = x.minimal_polynomial()
- sage: x.apply_univariate_polynomial(p)
+ sage: x = random_eja().random_element() # long time
+ sage: p = x.minimal_polynomial() # long time
+ sage: x.apply_univariate_polynomial(p) # long time
0
The minimal polynomial is invariant under a change of basis,
and in particular, a re-scaling of the basis::
- sage: set_random_seed()
sage: d_max = RealSymmetricEJA._max_random_instance_dimension()
sage: d = ZZ.random_element(1, d_max)
sage: n = RealSymmetricEJA._max_random_instance_size(d)
TESTS::
- sage: set_random_seed()
sage: J = random_eja()
sage: x,y = J.random_elements(2)
sage: x.operator()(y) == x*y
The explicit form in the spin factor algebra is given by
Alizadeh's Example 11.12::
- sage: set_random_seed()
sage: x = JordanSpinEJA.random_instance().random_element()
sage: x_vec = x.to_vector()
sage: Q = matrix.identity(x.base_ring(), 0)
Test all of the properties from Theorem 11.2 in Alizadeh::
- sage: set_random_seed()
sage: J = random_eja()
sage: x,y = J.random_elements(2)
sage: Lx = x.operator()
This subalgebra, being composed of only powers, is associative::
- sage: set_random_seed()
sage: x0 = random_eja().random_element()
- sage: A = x0.subalgebra_generated_by()
+ sage: A = x0.subalgebra_generated_by(orthonormalize=False)
sage: x,y,z = A.random_elements(3)
sage: (x*y)*z == x*(y*z)
True
Squaring in the subalgebra should work the same as in
the superalgebra::
- sage: set_random_seed()
sage: x = random_eja().random_element()
- sage: A = x.subalgebra_generated_by()
+ sage: A = x.subalgebra_generated_by(orthonormalize=False)
sage: A(x^2) == A(x)*A(x)
True
element... unless the original algebra was trivial, in which
case the subalgebra is trivial too::
- sage: set_random_seed()
sage: A = random_eja().zero().subalgebra_generated_by()
sage: (A.is_trivial() and A.dimension() == 0) or A.dimension() == 1
True
where there are non-nilpotent elements, or that we get the dumb
solution in the trivial algebra::
- sage: set_random_seed()
sage: J = random_eja()
sage: x = J.random_element()
sage: while x.is_nilpotent() and not J.is_trivial():
The trace of an element is a real number::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.random_element().trace() in RLF
True
The trace is linear::
- sage: set_random_seed()
sage: J = random_eja()
sage: x,y = J.random_elements(2)
sage: alpha = J.base_ring().random_element()
sage: (alpha*x + y).trace() == alpha*x.trace() + y.trace()
True
+ The trace of a square is nonnegative::
+
+ sage: x = random_eja().random_element()
+ sage: (x*x).trace() >= 0
+ True
+
"""
P = self.parent()
r = P.rank()
The trace inner product is commutative, bilinear, and associative::
- sage: set_random_seed()
sage: J = random_eja()
sage: x,y,z = J.random_elements(3)
sage: # commutative
projects / sage.d.git / blobdiff