From 64a06cae592dafa4ad007110d5d7ea9ae62dcee5 Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Mon, 14 Oct 2019 09:43:38 -0400 Subject: [PATCH] eja: add the unique spectral_decomposition() for elements. --- mjo/eja/eja_element.py | 63 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py index ee33e4b..a4af4ea 100644 --- a/mjo/eja/eja_element.py +++ b/mjo/eja/eja_element.py @@ -1040,6 +1040,69 @@ class FiniteDimensionalEuclideanJordanAlgebraElement(IndexedFreeModuleElement): + def spectral_decomposition(self): + """ + Return the unique spectral decomposition of this element. + + ALGORITHM: + + Following Faraut and Korányi's Theorem III.1.1, we restrict this + element's left-multiplication-by operator to the subalgebra it + generates. We then compute the spectral decomposition of that + operator, and the spectral projectors we get back must be the + left-multiplication-by operators for the idempotents we + seek. Thus applying them to the identity element gives us those + idempotents. + + Since the eigenvalues are required to be distinct, we take + the spectral decomposition of the zero element to be zero + times the identity element of the algebra (which is idempotent, + obviously). + + SETUP:: + + sage: from mjo.eja.eja_algebra import RealSymmetricEJA + + EXAMPLES: + + The spectral decomposition of the identity is ``1`` times itself, + and the spectral decomposition of zero is ``0`` times the identity:: + + sage: J = RealSymmetricEJA(3,AA) + sage: J.one() + e0 + e2 + e5 + sage: J.one().spectral_decomposition() + [(1, e0 + e2 + e5)] + sage: J.zero().spectral_decomposition() + [(0, e0 + e2 + e5)] + + TESTS:: + + sage: J = RealSymmetricEJA(4,AA) + sage: x = sum(J.gens()) + sage: sd = x.spectral_decomposition() + sage: l0 = sd[0][0] + sage: l1 = sd[1][0] + sage: c0 = sd[0][1] + sage: c1 = sd[1][1] + sage: c0.inner_product(c1) == 0 + True + sage: c0.is_idempotent() + True + sage: c1.is_idempotent() + True + sage: c0 + c1 == J.one() + True + sage: l0*c0 + l1*c1 == x + True + + """ + P = self.parent() + A = self.subalgebra_generated_by(orthonormalize_basis=True) + result = [] + for (evalue, proj) in A(self).operator().spectral_decomposition(): + result.append( (evalue, proj(A.one()).superalgebra_element()) ) + return result def subalgebra_generated_by(self, orthonormalize_basis=False): """ -- 2.43.2