from sage.matrix.constructor import matrix

from mjo.eja.eja_algebra import FiniteDimensionalEuclideanJordanAlgebra
from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement


class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensionalEuclideanJordanAlgebraElement):
    """
    SETUP::

        sage: from mjo.eja.eja_algebra import random_eja

    TESTS::

    The natural representation of an element in the subalgebra is
    the same as its natural representation in the superalgebra::

        sage: set_random_seed()
        sage: A = random_eja().random_element().subalgebra_generated_by()
        sage: y = A.random_element()
        sage: actual = y.natural_representation()
        sage: expected = y.superalgebra_element().natural_representation()
        sage: actual == expected
        True

    """

    def superalgebra_element(self):
        """
        Return the object in our algebra's superalgebra that corresponds
        to myself.

        SETUP::

            sage: from mjo.eja.eja_algebra import (RealSymmetricEJA,
            ....:                                  random_eja)

        EXAMPLES::

            sage: J = RealSymmetricEJA(3)
            sage: x = sum(J.gens())
            sage: x
            e0 + e1 + e2 + e3 + e4 + e5
            sage: A = x.subalgebra_generated_by()
            sage: A(x)
            f1
            sage: A(x).superalgebra_element()
            e0 + e1 + e2 + e3 + e4 + e5

        TESTS:

        We can convert back and forth faithfully::

            sage: set_random_seed()
            sage: J = random_eja()
            sage: x = J.random_element()
            sage: A = x.subalgebra_generated_by()
            sage: A(x).superalgebra_element() == x
            True
            sage: y = A.random_element()
            sage: A(y.superalgebra_element()) == y
            True

        """
        return self.parent().superalgebra().linear_combination(
          zip(self.parent()._superalgebra_basis, self.to_vector()) )




class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclideanJordanAlgebra):
    """
    The subalgebra of an EJA generated by a single element.
    """
    def __init__(self, elt):
        superalgebra = elt.parent()

        # First compute the vector subspace spanned by the powers of
        # the given element.
        V = superalgebra.vector_space()
        superalgebra_basis = [superalgebra.one()]
        basis_vectors = [superalgebra.one().to_vector()]
        W = V.span_of_basis(basis_vectors)
        for exponent in range(1, V.dimension()):
            new_power = elt**exponent
            basis_vectors.append( new_power.to_vector() )
            try:
                W = V.span_of_basis(basis_vectors)
                superalgebra_basis.append( new_power )
            except ValueError:
                # Vectors weren't independent; bail and keep the
                # last subspace that worked.
                break

        # Make the basis hashable for UniqueRepresentation.
        superalgebra_basis = tuple(superalgebra_basis)

        # Now figure out the entries of the right-multiplication
        # matrix for the successive basis elements b0, b1,... of
        # that subspace.
        field = superalgebra.base_ring()
        n = len(superalgebra_basis)
        mult_table = [[W.zero() for i in range(n)] for j in range(n)]
        for i in range(n):
            for j in range(n):
                product = superalgebra_basis[i]*superalgebra_basis[j]
                mult_table[i][j] = W.coordinate_vector(product.to_vector())

        # TODO: We'll have to redo this and make it unique again...
        prefix = 'f'

        # The rank is the highest possible degree of a minimal
        # polynomial, and is bounded above by the dimension. We know
        # in this case that there's an element whose minimal
        # polynomial has the same degree as the space's dimension
        # (remember how we constructed the space?), so that must be
        # its rank too.
        rank = W.dimension()

        category = superalgebra.category().Associative()
        natural_basis = tuple( b.natural_representation()
                               for b in superalgebra_basis )

        self._superalgebra = superalgebra
        self._vector_space = W
        self._superalgebra_basis = superalgebra_basis


        fdeja = super(FiniteDimensionalEuclideanJordanElementSubalgebra, self)
        return fdeja.__init__(field,
                              mult_table,
                              rank,
                              prefix=prefix,
                              category=category,
                              natural_basis=natural_basis)


    def _element_constructor_(self, elt):
        """
        Construct an element of this subalgebra from the given one.
        The only valid arguments are elements of the parent algebra
        that happen to live in this subalgebra.

        SETUP::

            sage: from mjo.eja.eja_algebra import RealSymmetricEJA
            sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra

        EXAMPLES::

            sage: J = RealSymmetricEJA(3)
            sage: x = sum( i*J.gens()[i] for i in range(6) )
            sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x)
            sage: [ K(x^k) for k in range(J.rank()) ]
            [f0, f1, f2]

        ::

        """
        if elt in self.superalgebra():
            coords = self.vector_space().coordinate_vector(elt.to_vector())
            return self.from_vector(coords)


    def superalgebra(self):
        """
        Return the superalgebra that this algebra was generated from.
        """
        return self._superalgebra


    def vector_space(self):
        """
        SETUP::

            sage: from mjo.eja.eja_algebra import RealSymmetricEJA
            sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra

        EXAMPLES::

            sage: J = RealSymmetricEJA(3)
            sage: x = sum( i*J.gens()[i] for i in range(6) )
            sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x)
            sage: K.vector_space()
            Vector space of degree 6 and dimension 3 over Rational Field
            User basis matrix:
            [ 1  0  1  0  0  1]
            [ 0  1  2  3  4  5]
            [10 14 21 19 31 50]
            sage: (x^0).to_vector()
            (1, 0, 1, 0, 0, 1)
            sage: (x^1).to_vector()
            (0, 1, 2, 3, 4, 5)
            sage: (x^2).to_vector()
            (10, 14, 21, 19, 31, 50)

        """
        return self._vector_space


    Element = FiniteDimensionalEuclideanJordanElementSubalgebraElement