From 88eb54dba783144477d35d2b246bff15df438c2e Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Mon, 22 Feb 2021 10:27:16 -0500 Subject: [PATCH] eja: replace monomial(i) with gens()[i] most places. The way cartesian products of combinatorial free modules are constructed, the monomials are identified by pairs of integers rather than single digits. This means when we're looping through monomial(i) for i=0,1,...,n in a CartesianProductEJA, that nothing is happening: monomial(i) is always zero. It wants e.g. monomial((i,j)) instead. So, switch all of those to gens()[i] which works everywhere. This fixes rank computations in cartesian product algebras. --- mjo/eja/eja_algebra.py | 44 +++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-) diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index ccc5006..3390df7 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -311,9 +311,9 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): return ``True``, unless this algebra was constructed with ``check_axioms=False`` and passed an invalid multiplication table. """ - return all( (self.monomial(i)**2)*(self.monomial(i)*self.monomial(j)) + return all( (self.gens()[i]**2)*(self.gens()[i]*self.gens()[j]) == - (self.monomial(i))*((self.monomial(i)**2)*self.monomial(j)) + (self.gens()[i])*((self.gens()[i]**2)*self.gens()[j]) for i in range(self.dimension()) for j in range(self.dimension()) ) @@ -335,9 +335,9 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): for i in range(self.dimension()): for j in range(self.dimension()): for k in range(self.dimension()): - x = self.monomial(i) - y = self.monomial(j) - z = self.monomial(k) + x = self.gens()[i] + y = self.gens()[j] + z = self.gens()[k] diff = (x*y).inner_product(z) - x.inner_product(y*z) if self.base_ring().is_exact(): @@ -660,8 +660,8 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # And to each subsequent row, prepend an entry that belongs to # the left-side "header column." - M += [ [self.monomial(i)] + [ self.product_on_basis(i,j) - for j in range(n) ] + M += [ [self.gens()[i]] + [ self.product_on_basis(i,j) + for j in range(n) ] for i in range(n) ] return table(M, header_row=True, header_column=True, frame=True) @@ -1129,7 +1129,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): def L_x_i_j(i,j): # From a result in my book, these are the entries of the # basis representation of L_x. - return sum( vars[k]*self.monomial(k).operator().matrix()[i,j] + return sum( vars[k]*self.gens()[k].operator().matrix()[i,j] for k in range(n) ) L_x = matrix(F, n, n, L_x_i_j) @@ -2730,6 +2730,33 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, Real Field (+) Euclidean Jordan algebra of dimension 6 over Algebraic Real Field + Rank is additive on a Cartesian product:: + + sage: J1 = HadamardEJA(1) + sage: J2 = RealSymmetricEJA(2) + sage: J = cartesian_product([J1,J2]) + sage: J1.rank.clear_cache() + sage: J2.rank.clear_cache() + sage: J.rank.clear_cache() + sage: J.rank() + 3 + sage: J.rank() == J1.rank() + J2.rank() + True + + The same rank computation works over the rationals, with whatever + basis you like:: + + sage: J1 = HadamardEJA(1, field=QQ, orthonormalize=False) + sage: J2 = RealSymmetricEJA(2, field=QQ, orthonormalize=False) + sage: J = cartesian_product([J1,J2]) + sage: J1.rank.clear_cache() + sage: J2.rank.clear_cache() + sage: J.rank.clear_cache() + sage: J.rank() + 3 + sage: J.rank() == J1.rank() + J2.rank() + True + TESTS: All factors must share the same base field:: @@ -2753,7 +2780,6 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, True sage: x.inner_product(y) == J.cartesian_inner_product(x,y) True - """ def __init__(self, modules, **kwargs): CombinatorialFreeModule_CartesianProduct.__init__(self, -- 2.43.2