passagemath-modules 10.6.31__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra_ideal.py

@@ -0,0 +1,196 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.rings.finite_rings (because all doctests use GF)
+"""
+Ideals of Finite Dimensional Algebras
+
+It is necessary to use algebras in the category of associative algebras.
+"""
+
+# ****************************************************************************
+#  Copyright (C) 2011 Johan Bosman <johan.g.bosman@gmail.com>
+#  Copyright (C) 2011, 2013 Peter Bruin <peter.bruin@math.uzh.ch>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement
+
+from sage.matrix.constructor import matrix
+from sage.rings.ideal import Ideal_generic
+from sage.structure.element import Matrix, parent
+
+from sage.misc.cachefunc import cached_method
+from functools import reduce
+
+from sage.structure.richcmp import (op_LT, op_LE, op_EQ, op_NE,
+                                    op_GT, op_GE)
+
+
+class FiniteDimensionalAlgebraIdeal(Ideal_generic):
+    """
+    An ideal of a :class:`FiniteDimensionalAlgebra`.
+
+    INPUT:
+
+    - ``A`` -- a finite-dimensional algebra
+    - ``gens`` -- the generators of this ideal
+    - ``given_by_matrix`` -- boolean (default: ``False``); whether the basis
+      matrix is given by ``gens``
+
+    EXAMPLES::
+
+        sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+        sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+        ....:                                      Matrix([[0, 1], [0, 0]])],
+        ....:                              category=cat)
+        sage: A.ideal(A([0,1]))
+        Ideal (e1) of Finite-dimensional algebra of degree 2 over Finite Field of size 3
+    """
+    def __init__(self, A, gens=None, given_by_matrix=False):
+        """
+        EXAMPLES::
+
+            sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                      Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.ideal(A([0,1]))
+            sage: TestSuite(I).run(skip='_test_category')  # Currently ideals are not using the category framework
+        """
+        k = A.base_ring()
+        n = A.degree()
+        if given_by_matrix:
+            self._basis_matrix = gens
+            gens = gens.rows()
+        elif gens is None:
+            self._basis_matrix = matrix(k, 0, n)
+        elif isinstance(gens, (list, tuple)):
+            B = [FiniteDimensionalAlgebraIdeal(A, x).basis_matrix() for x in gens]
+            B = reduce(lambda x, y: x.stack(y), B, matrix(k, 0, n))
+            self._basis_matrix = B.echelon_form().image().basis_matrix()
+        elif isinstance(gens, Matrix):
+            gens = FiniteDimensionalAlgebraElement(A, gens)
+        elif isinstance(gens, FiniteDimensionalAlgebraElement):
+            gens = gens.vector()
+            B = matrix([(gens * b).list() for b in A.table()])
+            self._basis_matrix = B.echelon_form().image().basis_matrix()
+        Ideal_generic.__init__(self, A, gens)
+
+    def _richcmp_(self, other, op):
+        r"""
+        Comparisons.
+
+        TESTS::
+
+            sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                      Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.ideal(A([1,1]))
+            sage: J = A.ideal(A([0,1]))
+            sage: I == J
+            False
+            sage: I == I
+            True
+            sage: I == I + J
+            True
+
+            sage: A2 = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                       Matrix([[0, 1], [0, 0]])],
+            ....:     category=cat)
+            sage: A is A2
+            True
+            sage: A == A2
+            True
+            sage: I2 = A.ideal(A([1,1]))
+            sage: I == I2
+            True
+
+            sage: I != J, I != I, I != I+J
+            (True, False, False)
+            sage: I <= J, I <= I, I <= I+J
+            (False, True, True)
+            sage: I < J, I < I, I < I+J
+            (False, False, False)
+            sage: I >= J, I >= I, I >= I+J
+            (True, True, True)
+            sage: I > J, I > I, I > I+J
+            (True, False, False)
+
+            sage: I = A.ideal(A([1,1]))
+            sage: J = A.ideal(A([0,1]))
+            sage: I != J
+            True
+            sage: I != I
+            False
+            sage: I != I + J
+            False
+        """
+        if self.basis_matrix() == other.basis_matrix():
+            return op == op_EQ or op == op_LE or op == op_GE
+        elif op == op_EQ:
+            return False
+        elif op == op_NE:
+            return True
+        if op == op_LE or op == op_LT:
+            return self.vector_space().is_subspace(other.vector_space())
+        elif op == op_GE or op == op_GT:
+            return other.vector_space().is_subspace(self.vector_space())
+
+    def __contains__(self, elt):
+        """
+        EXAMPLES::
+
+            sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                      Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: J = A.ideal(A([0,1]))
+            sage: A([0,1]) in J
+            True
+            sage: A([1,0]) in J
+            False
+        """
+        if self.ring() is not parent(elt):
+            return False
+        return elt.vector() in self.vector_space()
+
+    def basis_matrix(self):
+        """
+        Return the echelonized matrix whose rows form a basis of ``self``.
+
+        EXAMPLES::
+
+            sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                      Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.ideal(A([1,1]))
+            sage: I.basis_matrix()
+            [1 0]
+            [0 1]
+        """
+        return self._basis_matrix
+
+    @cached_method
+    def vector_space(self):
+        """
+        Return ``self`` as a vector space.
+
+        EXAMPLES::
+
+            sage: cat = CommutativeAlgebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]]),
+            ....:                                      Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.ideal(A([1,1]))
+            sage: I.vector_space()
+            Vector space of degree 2 and dimension 2 over Finite Field of size 3
+            Basis matrix:
+            [1 0]
+            [0 1]
+        """
+        return self.basis_matrix().image()

sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra_morphism.py

@@ -0,0 +1,255 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Morphisms Between Finite Algebras
+"""
+
+# ****************************************************************************
+#  Copyright (C) 2011 Johan Bosman <johan.g.bosman@gmail.com>
+#  Copyright (C) 2011, 2013 Peter Bruin <peter.bruin@math.uzh.ch>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from sage.rings.morphism import RingHomomorphism_im_gens
+from sage.rings.homset import RingHomset_generic
+from sage.structure.element import Matrix
+
+
+class FiniteDimensionalAlgebraMorphism(RingHomomorphism_im_gens):
+    """
+    Create a morphism between two :class:`finite-dimensional algebras <FiniteDimensionalAlgebra>`.
+
+    INPUT:
+
+    - ``parent`` -- the parent homset
+
+    - ``f`` -- matrix of the underlying `k`-linear map
+
+    - ``unitary`` -- boolean (default: ``True``); if ``True`` and ``check``
+      is also ``True``, raise a :exc:`ValueError` unless ``A`` and ``B`` are
+      unitary and ``f`` respects unit elements
+
+    - ``check`` -- boolean (default: ``True``); check whether the given
+      `k`-linear map really defines a (not necessarily unitary)
+      `k`-algebra homomorphism
+
+    The algebras ``A`` and ``B`` must be defined over the same base field.
+
+    EXAMPLES::
+
+        sage: from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_morphism import FiniteDimensionalAlgebraMorphism
+        sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+        ....:                                   Matrix([[0, 1], [0, 0]])])
+        sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+        sage: H = Hom(A, B)
+        sage: f = H(Matrix([[1], [0]]))
+        sage: f.domain() is A
+        True
+        sage: f.codomain() is B
+        True
+        sage: f(A.basis()[0])
+        e
+        sage: f(A.basis()[1])
+        0
+
+    .. TODO:: An example illustrating unitary flag.
+    """
+    def __init__(self, parent, f, check=True, unitary=True):
+        """
+        TESTS::
+
+            sage: from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_morphism import FiniteDimensionalAlgebraMorphism
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: H = Hom(A, B)
+            sage: phi = FiniteDimensionalAlgebraMorphism(H, Matrix([[1, 0]]))
+            sage: TestSuite(phi).run(skip='_test_category')
+        """
+        A = parent.domain()
+        B = parent.codomain()
+
+        RingHomomorphism_im_gens.__init__(self, parent=parent, im_gens=f.rows(), check=check)
+        self._matrix = f
+
+        if unitary and check and (not A.is_unitary()
+                                  or not B.is_unitary()
+                                  or self(A.one()) != B.one()):
+            raise ValueError("homomorphism does not respect unit elements")
+
+    def _repr_(self):
+        r"""
+        TESTS::
+
+            sage: cat = CommutativeAlgebras(QQ).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.maximal_ideal()                                                 # needs sage.libs.pari
+            sage: q = A.quotient_map(I)                                                 # needs sage.libs.pari
+            sage: q._repr_()                                                            # needs sage.libs.pari
+            'Morphism from Finite-dimensional algebra of degree 2 over Rational Field to Finite-dimensional algebra of degree 1 over Rational Field given by matrix\n[1]\n[0]'
+        """
+        return "Morphism from {} to {} given by matrix\n{}".format(
+            self.domain(), self.codomain(), self._matrix)
+
+    def __call__(self, x):
+        """
+        TESTS::
+
+            sage: cat = CommutativeAlgebras(QQ).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.maximal_ideal()                                                 # needs sage.libs.pari
+            sage: q = A.quotient_map(I)                                                 # needs sage.libs.pari
+            sage: q(0) == 0 and q(1) == 1                                               # needs sage.libs.pari
+            True
+        """
+        x = self.domain()(x)
+        B = self.codomain()
+        return B.element_class(B, x.vector() * self._matrix)
+
+    def __eq__(self, other):
+        """
+        Check equality.
+
+        TESTS::
+
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: H = Hom(A, B)
+            sage: phi = H(Matrix([[1, 0]]))
+            sage: psi = H(Matrix([[1, 0]]))
+            sage: phi == psi
+            True
+            sage: phi == H.zero()
+            False
+        """
+        return (isinstance(other, FiniteDimensionalAlgebraMorphism)
+                and self.parent() == other.parent()
+                and self._matrix == other._matrix)
+
+    def __ne__(self, other):
+        """
+        Check not equals.
+
+        TESTS::
+
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: H = Hom(A, B)
+            sage: phi = H(Matrix([[1, 0]]))
+            sage: psi = H(Matrix([[1, 0]]))
+            sage: phi != psi
+            False
+            sage: phi != H.zero()
+            True
+        """
+        return not self == other
+
+    def matrix(self):
+        """
+        Return the matrix of ``self``.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: M = Matrix([[1], [0]])
+            sage: H = Hom(A, B)
+            sage: f = H(M)
+            sage: f.matrix() == M
+            True
+        """
+        return self._matrix
+
+    def inverse_image(self, I):
+        """
+        Return the inverse image of ``I`` under ``self``.
+
+        INPUT:
+
+        - ``I`` -- ``FiniteDimensionalAlgebraIdeal``, an ideal of ``self.codomain()``
+
+        OUTPUT: :class:`FiniteDimensionalAlgebraIdeal`, the inverse image of `I` under ``self``
+
+        EXAMPLES::
+
+            sage: cat = CommutativeAlgebras(QQ).FiniteDimensional().WithBasis()
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])],
+            ....:                              category=cat)
+            sage: I = A.maximal_ideal()                                                 # needs sage.libs.pari
+            sage: q = A.quotient_map(I)                                                 # needs sage.libs.pari
+            sage: B = q.codomain()                                                      # needs sage.libs.pari
+            sage: q.inverse_image(B.zero_ideal()) == I                                  # needs sage.libs.pari
+            True
+        """
+        coker_I = I.basis_matrix().transpose().kernel().basis_matrix().transpose()
+        return self.domain().ideal((self._matrix * coker_I).kernel().basis_matrix(), given_by_matrix=True)
+
+
+class FiniteDimensionalAlgebraHomset(RingHomset_generic):
+    """
+    Set of morphisms between two finite-dimensional algebras.
+    """
+    @cached_method
+    def zero(self):
+        """
+        Construct the zero morphism of ``self``.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: H = Hom(A, B)
+            sage: H.zero()
+            Morphism from Finite-dimensional algebra of degree 1 over Rational Field to
+             Finite-dimensional algebra of degree 2 over Rational Field given by matrix
+            [0 0]
+        """
+        from sage.matrix.constructor import matrix
+        return FiniteDimensionalAlgebraMorphism(self, matrix.zero(self.domain().ngens(),
+                                                       self.codomain().ngens()),
+                                     False, False)
+
+    def __call__(self, f, check=True, unitary=True):
+        """
+        Construct a homomorphism.
+
+        .. TODO::
+
+            Implement taking generator images and converting them to a matrix.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([1])])
+            sage: B = FiniteDimensionalAlgebra(QQ, [Matrix([[1, 0], [0, 1]]),
+            ....:                                   Matrix([[0, 1], [0, 0]])])
+            sage: H = Hom(A, B)
+            sage: H(Matrix([[1, 0]]))
+            Morphism from Finite-dimensional algebra of degree 1 over Rational Field to
+             Finite-dimensional algebra of degree 2 over Rational Field given by matrix
+            [1 0]
+        """
+        if isinstance(f, FiniteDimensionalAlgebraMorphism):
+            if f.parent() is self:
+                return f
+            if f.parent() == self:
+                return FiniteDimensionalAlgebraMorphism(self, f._matrix, check, unitary)
+        elif isinstance(f, Matrix):
+            return FiniteDimensionalAlgebraMorphism(self, f, check, unitary)
+        try:
+            from sage.matrix.constructor import matrix
+            return FiniteDimensionalAlgebraMorphism(self, matrix(f), check, unitary)
+        except Exception:
+            return RingHomset_generic.__call__(self, f, check)