# -*- coding: utf-8 -*-
-from itertools import izip
-
from sage.matrix.constructor import matrix
from sage.modules.free_module import VectorSpace
from sage.modules.with_basis.indexed_element import IndexedFreeModuleElement
return not (p(zero) == zero)
- def is_minimal_idempotent(self):
+ def is_primitive_idempotent(self):
"""
- Return whether or not this element is a minimal idempotent.
+ Return whether or not this element is a primitive (or minimal)
+ idempotent.
+ A primitive idempotent is a non-zero idempotent that is not
+ the sum of two other non-zero idempotents. Remark 2.7.15 in
+ Baes shows that this is what he refers to as a "minimal
+ idempotent."
An element of a Euclidean Jordan algebra is a minimal idempotent
if it :meth:`is_idempotent` and if its Peirce subalgebra
sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
....: RealSymmetricEJA,
+ ....: TrivialEJA,
....: random_eja)
WARNING::
sage: x = sum(J.gens())
sage: x.is_regular()
False
- sage: [ c.is_minimal_idempotent()
+ sage: [ c.is_primitive_idempotent()
....: for (l,c) in x.spectral_decomposition() ]
[False, True]
sage: x = sum( i*J.gens()[i] for i in range(len(J.gens())) )
sage: x.is_regular()
True
- sage: [ c.is_minimal_idempotent()
+ sage: [ c.is_primitive_idempotent()
....: for (l,c) in x.spectral_decomposition() ]
[True, True]
sage: set_random_seed()
sage: J = random_eja()
- sage: J.rank() == 1 or not J.one().is_minimal_idempotent()
+ 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_minimal_idempotent()
+ sage: (not x.is_idempotent()) and x.is_primitive_idempotent()
False
Proposition 2.7.19 in Baes says that an element is a minimal
sage: J = JordanSpinEJA(4)
sage: x = J.random_element()
sage: expected = (x.is_idempotent() and x.trace() == 1)
- sage: actual = x.is_minimal_idempotent()
+ sage: actual = x.is_primitive_idempotent()
sage: actual == expected
True
+ Primitive idempotents must be non-zero::
+
+ sage: set_random_seed()
+ sage: J = random_eja()
+ sage: J.zero().is_idempotent()
+ True
+ sage: J.zero().is_primitive_idempotent()
+ False
+
+ As a consequence of the fact that primitive idempotents must
+ be non-zero, there are no primitive idempotents in a trivial
+ Euclidean Jordan algebra::
+
+ sage: J = TrivialEJA()
+ sage: J.one().is_idempotent()
+ True
+ sage: J.one().is_primitive_idempotent()
+ False
+
"""
- # TODO: when the Peirce decomposition is implemented for real,
- # we can use that instead of finding this eigenspace manually.
- #
- # Trivial eigenspaces don't appear in the list, so we default to the
- # trivial one and override it if there's a nontrivial space in the
- # list.
if not self.is_idempotent():
return False
- J1 = VectorSpace(self.parent().base_ring(), 0)
- for (eigval, eigspace) in self.operator().matrix().left_eigenspaces():
- if eigval == 1:
- J1 = eigspace
+ if self.is_zero():
+ return False
+
+ (_,_,J1) = self.parent().peirce_decomposition(self)
return (J1.dimension() == 1)
"""
B = self.parent().natural_basis()
W = self.parent().natural_basis_space()
- return W.linear_combination(izip(B,self.to_vector()))
+ return W.linear_combination(zip(B,self.to_vector()))
def norm(self):
True
"""
+ if self.parent().is_trivial():
+ return self
+
if self.is_nilpotent():
raise ValueError("this only works with non-nilpotent elements!")