from sage.categories.all import FreeModules
from sage.categories.map import Map
-class FiniteDimensionalEJAOperator(Map):
+class EJAOperator(Map):
r"""
An operator between two finite-dimensional Euclidean Jordan algebras.
SETUP::
sage: from mjo.eja.eja_algebra import HadamardEJA
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
EXAMPLES:
sage: J = HadamardEJA(3)
sage: V = VectorSpace(J.base_ring(), 3)
sage: M = matrix.identity(J.base_ring(), 3)
- sage: FiniteDimensionalEJAOperator(V,J,M)
+ sage: EJAOperator(V,J,M)
Traceback (most recent call last):
...
TypeError: domain must be a finite-dimensional Euclidean
Jordan algebra
- sage: FiniteDimensionalEJAOperator(J,V,M)
+ sage: EJAOperator(J,V,M)
Traceback (most recent call last):
...
TypeError: codomain must be a finite-dimensional Euclidean
"""
def __init__(self, domain_eja, codomain_eja, mat):
- from mjo.eja.eja_algebra import FiniteDimensionalEJA
+ from mjo.eja.eja_algebra import EJA
# I guess we should check this, because otherwise you could
# pass in pretty much anything algebraish.
- if not isinstance(domain_eja, FiniteDimensionalEJA):
+ if not isinstance(domain_eja, EJA):
raise TypeError('domain must be a finite-dimensional '
'Euclidean Jordan algebra')
- if not isinstance(codomain_eja, FiniteDimensionalEJA):
+ if not isinstance(codomain_eja, EJA):
raise TypeError('codomain must be a finite-dimensional '
'Euclidean Jordan algebra')
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import JordanSpinEJA
EXAMPLES::
sage: J = JordanSpinEJA(3)
sage: x = J.linear_combination(zip(J.gens(),range(len(J.gens()))))
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
sage: f(x) == x
True
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import (
....: JordanSpinEJA,
....: RealSymmetricEJA )
sage: J = RealSymmetricEJA(2)
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
- sage: g = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
+ sage: g = EJAOperator(J,J,id)
sage: f + g
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
sage: id1 = identity_matrix(J1.base_ring(), 3)
sage: J2 = JordanSpinEJA(3)
sage: id2 = identity_matrix(J2.base_ring(), 3)
- sage: f = FiniteDimensionalEJAOperator(J1,J1,id1)
- sage: g = FiniteDimensionalEJAOperator(J2,J2,id2)
+ sage: f = EJAOperator(J1,J1,id1)
+ sage: g = EJAOperator(J2,J2,id2)
sage: f + g
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for +: ...
"""
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
self.domain(),
self.codomain(),
self.matrix() + other.matrix())
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import (
....: JordanSpinEJA,
....: HadamardEJA,
sage: mat1 = matrix(AA, [[1,2,3],
....: [4,5,6]])
sage: mat2 = matrix(AA, [[7,8]])
- sage: g = FiniteDimensionalEJAOperator(J1, J2, mat1)
- sage: f = FiniteDimensionalEJAOperator(J2, J3, mat2)
+ sage: g = EJAOperator(J1, J2, mat1)
+ sage: f = EJAOperator(J2, J3, mat2)
sage: f*g
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
Algebraic Real Field
"""
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
other.domain(),
self.codomain(),
self.matrix()*other.matrix())
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES::
sage: J = RealSymmetricEJA(2)
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
sage: ~f
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
Codomain: Euclidean Jordan algebra of dimension 3 over...
"""
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
self.codomain(),
self.domain(),
~self.matrix())
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES:
"""
try:
if other in self.codomain().base_ring():
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
self.domain(),
self.codomain(),
self.matrix()*other)
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES::
sage: J = RealSymmetricEJA(2)
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
sage: -f
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
Codomain: Euclidean Jordan algebra of dimension 3 over...
"""
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
self.domain(),
self.codomain(),
-self.matrix())
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
TESTS:
sage: J = RealSymmetricEJA(2)
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
sage: f^0 + f^1 + f^2
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
else:
mat = self.matrix()**n
- return FiniteDimensionalEJAOperator(
+ return EJAOperator(
self.domain(),
self.codomain(),
mat)
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import JordanSpinEJA
EXAMPLES::
sage: J = JordanSpinEJA(2)
sage: id = identity_matrix(J.base_ring(), J.dimension())
- sage: FiniteDimensionalEJAOperator(J,J,id)
+ sage: EJAOperator(J,J,id)
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
[1 0]
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES::
sage: J = RealSymmetricEJA(2)
sage: id = identity_matrix(J.base_ring(),J.dimension())
- sage: f = FiniteDimensionalEJAOperator(J,J,id)
+ sage: f = EJAOperator(J,J,id)
sage: f - (f*2)
Linear operator between finite-dimensional Euclidean Jordan
algebras represented by the matrix:
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import (random_eja,
....: JordanSpinEJA,
....: RealSymmetricEJA)
sage: M = matrix(R, [ [0, 0],
....: [0, 0],
....: [0, 0] ])
- sage: L = FiniteDimensionalEJAOperator(J1,J2,M)
+ sage: L = EJAOperator(J1,J2,M)
sage: L.is_zero()
True
sage: M = matrix(R, [ [0, 0],
....: [0, 1],
....: [0, 0] ])
- sage: L = FiniteDimensionalEJAOperator(J1,J2,M)
+ sage: L = EJAOperator(J1,J2,M)
sage: L.is_zero()
False
The left-multiplication-by-zero operation on a given algebra
is its zero map::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.zero().operator().is_zero()
True
The identity operator is its own inverse::
- sage: set_random_seed()
sage: J = random_eja()
sage: idJ = J.one().operator()
sage: idJ.inverse() == idJ
The inverse of the inverse is the operator we started with::
- sage: set_random_seed()
sage: x = random_eja().random_element()
sage: L = x.operator()
sage: not L.is_invertible() or (L.inverse().inverse() == L)
The identity operator is always invertible::
- sage: set_random_seed()
sage: J = random_eja()
sage: J.one().operator().is_invertible()
True
The zero operator is never invertible in a nontrivial algebra::
- sage: set_random_seed()
sage: J = random_eja()
sage: not J.is_trivial() and J.zero().operator().is_invertible()
False
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES::
sage: J = RealSymmetricEJA(2)
sage: mat = matrix(J.base_ring(), J.dimension(), range(9))
- sage: f = FiniteDimensionalEJAOperator(J,J,mat)
+ sage: f = EJAOperator(J,J,mat)
sage: f.matrix()
[0 1 2]
[3 4 5]
SETUP::
- sage: from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+ sage: from mjo.eja.eja_operator import EJAOperator
sage: from mjo.eja.eja_algebra import RealSymmetricEJA
EXAMPLES::
# for the spectral theorem to work.
us[i] = us[i]/us[i].norm()
mat = us[i].column()*us[i].row()
- Pi = FiniteDimensionalEJAOperator(
+ Pi = EJAOperator(
self.domain(),
self.codomain(),
mat)