Multiple \(\ZZ\)-graded filtrations of a single vector space - Modules

Skip to content
Back to top
View this page
Edit this page

# Multiple \(\ZZ\)-graded filtrations of a single vector space

See `filtered_vector_space` for simply graded vector spaces. This module implements the analog but for a collection of filtrations of the same vector space.

The basic syntax to use it is a dictionary whose keys are some arbitrary indexing set and values are `FilteredVectorSpace()`

Sage

    sage: F1 = FilteredVectorSpace(2, 1)
    sage: F2 = FilteredVectorSpace({0:[(1,0)], 2:[(2,3)]})
    sage: V = MultiFilteredVectorSpace({'first':F1, 'second':F2})
    sage: V
    Filtrations
         first: QQ^2 >= QQ^2 >=  0   >= 0
        second: QQ^2 >= QQ^1 >= QQ^1 >= 0

    sage: V.index_set()   # random output
    {'second', 'first'}
    sage: sorted(V.index_set())
    ['first', 'second']

    sage: V.get_filtration('first')
    QQ^2 >=  0
    sage: V.get_degree('second', 1)
    Vector space of degree 2 and dimension 1 over Rational Field
    Basis matrix:
    [  1 3/2]

Python

    >>> from sage.all import *
    >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
    >>> F2 = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(0))], Integer(2):[(Integer(2),Integer(3))]})
    >>> V = MultiFilteredVectorSpace({'first':F1, 'second':F2})
    >>> V
    Filtrations
         first: QQ^2 >= QQ^2 >=  0   >= 0
        second: QQ^2 >= QQ^1 >= QQ^1 >= 0

    >>> V.index_set()   # random output
    {'second', 'first'}
    >>> sorted(V.index_set())
    ['first', 'second']

    >>> V.get_filtration('first')
    QQ^2 >=  0
    >>> V.get_degree('second', Integer(1))
    Vector space of degree 2 and dimension 1 over Rational Field
    Basis matrix:
    [  1 3/2]

sage.modules.multi_filtered_vector_space.MultiFilteredVectorSpace(arg, base_ring=None, check=True)

  Construct a multi-filtered vector space.

  INPUT:

  - `arg` – either a non-empty dictionary of filtrations or an integer. The latter is interpreted as the vector space dimension, and the indexing set of the filtrations is empty.

  - `base_ring` – a field (default: `'None'`). The base field of the vector space. Must be a field. If not specified, the base field is derived from the filtrations.

  - `check` – boolean (default: `True`); whether to perform consistency checks

  EXAMPLES:

  Sage

      sage: MultiFilteredVectorSpace(3, QQ)
      Unfiltered QQ^3

      sage: F1 = FilteredVectorSpace(2, 1)
      sage: F2 = FilteredVectorSpace(2, 3)
      sage: V = MultiFilteredVectorSpace({1:F1, 2:F2});  V
      Filtrations
          1: QQ^2 >=  0   >=  0   >= 0
          2: QQ^2 >= QQ^2 >= QQ^2 >= 0

  Python

      >>> from sage.all import *
      >>> MultiFilteredVectorSpace(Integer(3), QQ)
      Unfiltered QQ^3

      >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
      >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
      >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2});  V
      Filtrations
          1: QQ^2 >=  0   >=  0   >= 0
          2: QQ^2 >= QQ^2 >= QQ^2 >= 0

class sage.modules.multi_filtered_vector_space.MultiFilteredVectorSpace_class(base_ring, dim, filtrations, check=True)

  Bases: `FreeModule_ambient_field`

  Python constructor.

  Warning

  Use `MultiFilteredVectorSpace()` to construct multi-filtered vector spaces.

  INPUT:

  - `base_ring` – the base ring

  - `dim` – integer; the dimension of the ambient vector space

  - `filtrations` – dictionary whose values are filtrations

  - `check` – boolean (default: `True`); whether to perform additional consistency checks

  EXAMPLES:

  Sage

      sage: F1 = FilteredVectorSpace(2, 1)
      sage: F2 = FilteredVectorSpace(2, 3)
      sage: V = MultiFilteredVectorSpace({1:F1, 2:F2});  V
      Filtrations
          1: QQ^2 >=  0   >=  0   >= 0
          2: QQ^2 >= QQ^2 >= QQ^2 >= 0

  Python

      >>> from sage.all import *
      >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
      >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
      >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2});  V
      Filtrations
          1: QQ^2 >=  0   >=  0   >= 0
          2: QQ^2 >= QQ^2 >= QQ^2 >= 0

  ambient_vector_space()

    Return the ambient (unfiltered) vector space.

    OUTPUT: a vector space

    EXAMPLES:

    Sage

        sage: V = FilteredVectorSpace(2, 0)
        sage: W = FilteredVectorSpace(2, 2)
        sage: F = MultiFilteredVectorSpace({'a':V, 'b':W})
        sage: F.ambient_vector_space()
        Vector space of dimension 2 over Rational Field

    Python

        >>> from sage.all import *
        >>> V = FilteredVectorSpace(Integer(2), Integer(0))
        >>> W = FilteredVectorSpace(Integer(2), Integer(2))
        >>> F = MultiFilteredVectorSpace({'a':V, 'b':W})
        >>> F.ambient_vector_space()
        Vector space of dimension 2 over Rational Field

  change_ring(base_ring)

    Return the same multi-filtration over a different base ring.

    INPUT:

    - `base_ring` – the new base ring

    OUTPUT:

    This method returns a new multi-filtered vector space whose subspaces are defined by the same generators but over a different base ring.

    EXAMPLES:

    Sage

        sage: V = FilteredVectorSpace(2, 0)
        sage: W = FilteredVectorSpace(2, 2)
        sage: F = MultiFilteredVectorSpace({'a':V, 'b':W});  F
        Filtrations
            a: QQ^2 >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^2 >= 0
        sage: F.change_ring(RDF)
        Filtrations
            a: RDF^2 >=   0   >=   0   >= 0
            b: RDF^2 >= RDF^2 >= RDF^2 >= 0

        sage: MultiFilteredVectorSpace(3, base_ring=QQ).change_ring(RR)
        Unfiltered RR^3

    Python

        >>> from sage.all import *
        >>> V = FilteredVectorSpace(Integer(2), Integer(0))
        >>> W = FilteredVectorSpace(Integer(2), Integer(2))
        >>> F = MultiFilteredVectorSpace({'a':V, 'b':W});  F
        Filtrations
            a: QQ^2 >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^2 >= 0
        >>> F.change_ring(RDF)
        Filtrations
            a: RDF^2 >=   0   >=   0   >= 0
            b: RDF^2 >= RDF^2 >= RDF^2 >= 0

        >>> MultiFilteredVectorSpace(Integer(3), base_ring=QQ).change_ring(RR)
        Unfiltered RR^3

  direct_sum(other)

    Return the direct sum.

    INPUT:

    - `other` – a multi-filtered vector space with the same `index_set()`

    OUTPUT:

    The direct sum as a multi-filtered vector space. See `direct_sum()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: G1 = FilteredVectorSpace(1, 1)
        sage: G2 = FilteredVectorSpace(1, 3)
        sage: W = MultiFilteredVectorSpace({'a':G1, 'b':G2})
        sage: V.direct_sum(W)
        Filtrations
            a: QQ^3 >= QQ^3 >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= 0
        sage: V + W   # syntactic sugar
        Filtrations
            a: QQ^3 >= QQ^3 >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> G1 = FilteredVectorSpace(Integer(1), Integer(1))
        >>> G2 = FilteredVectorSpace(Integer(1), Integer(3))
        >>> W = MultiFilteredVectorSpace({'a':G1, 'b':G2})
        >>> V.direct_sum(W)
        Filtrations
            a: QQ^3 >= QQ^3 >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= 0
        >>> V + W   # syntactic sugar
        Filtrations
            a: QQ^3 >= QQ^3 >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= 0

  dual()

    Return the dual.

    OUTPUT:

    The dual as a multi-filtered vector space. See `dual()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: V.dual()
        Filtrations
            a: QQ^2 >= QQ^2 >= QQ^2 >=  0   >= 0
            b: QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> V.dual()
        Filtrations
            a: QQ^2 >= QQ^2 >= QQ^2 >=  0   >= 0
            b: QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

  exterior_power(n)

    Return the \(n\)-th graded exterior power.

    INPUT:

    - `n` – integer; exterior product of how many copies of `self`

    OUTPUT:

    The exterior power as a multi-filtered vector space. See `exterior_power()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: V.exterior_power(2)  # long time
        Filtrations
            a: QQ^1 >=  0   >= 0
            b: QQ^1 >= QQ^1 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> V.exterior_power(Integer(2))  # long time
        Filtrations
            a: QQ^1 >=  0   >= 0
            b: QQ^1 >= QQ^1 >= 0

  get_degree(key, deg)

    Return one filtered vector space.

    INPUT:

    - `key` – an element of the `index_set()`; specifies which filtration

    - `d` – integer; the desired degree of the filtration

    OUTPUT:

    The vector space of degree `deg` in the filtration indexed by `key` as subspace of the ambient space.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.get_degree(2, 0)
        Vector space of degree 2 and dimension 2 over Rational Field
        Basis matrix:
        [1 0]
        [0 1]

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.get_degree(Integer(2), Integer(0))
        Vector space of degree 2 and dimension 2 over Rational Field
        Basis matrix:
        [1 0]
        [0 1]

  get_filtration(key)

    Return the filtration indexed by `key`.

    OUTPUT: a filtered vector space

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.get_filtration(2)
        QQ^2 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.get_filtration(Integer(2))
        QQ^2 >= 0

  graded(key, deg)

    Return the associated graded vector space.

    INPUT:

    - `key` – an element of the `index_set()`; specifies which filtration

    - `d` – integer; the desired degree of the filtration

    OUTPUT:

    The quotient \(G_d = F_d / F_{d+1}\) of the filtration \(F\) corresponding to `key`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.graded(2, 3)
        Vector space quotient V/W of dimension 1 over Rational Field where
        V: Vector space of degree 2 and dimension 1 over Rational Field
        Basis matrix:
        [1 0]
        W: Vector space of degree 2 and dimension 0 over Rational Field
        Basis matrix:
        []

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.graded(Integer(2), Integer(3))
        Vector space quotient V/W of dimension 1 over Rational Field where
        V: Vector space of degree 2 and dimension 1 over Rational Field
        Basis matrix:
        [1 0]
        W: Vector space of degree 2 and dimension 0 over Rational Field
        Basis matrix:
        []

  index_set()

    Return the allowed indices for the different filtrations.

    OUTPUT: set

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.index_set()
        {1, 2}

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.index_set()
        {1, 2}

  is_constant()

    Return whether the multi-filtration is constant.

    OUTPUT: boolean; whether the each filtration is constant, see `is_constant()`

    EXAMPLES:

    Sage

        sage: V = FilteredVectorSpace(2, 0)
        sage: W = FilteredVectorSpace(2, 2)
        sage: F = MultiFilteredVectorSpace({'a':V, 'b':W});  F
        Filtrations
            a: QQ^2 >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^2 >= 0
        sage: F.is_constant()
        False

    Python

        >>> from sage.all import *
        >>> V = FilteredVectorSpace(Integer(2), Integer(0))
        >>> W = FilteredVectorSpace(Integer(2), Integer(2))
        >>> F = MultiFilteredVectorSpace({'a':V, 'b':W});  F
        Filtrations
            a: QQ^2 >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^2 >= 0
        >>> F.is_constant()
        False

  is_exhaustive()

    Return whether the multi-filtration is exhaustive.

    A filtration \(\{F_d\}\) in an ambient vector space \(V\) is exhaustive if \(\cup F_d = V\). See also `is_separating()`.

    OUTPUT: boolean; whether each filtration is constant, see `is_exhaustive()`

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.is_exhaustive()
        True

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.is_exhaustive()
        True

  is_separating()

    Return whether the multi-filtration is separating.

    A filtration \(\{F_d\}\) in an ambient vector space \(V\) is exhaustive if \(\cap F_d = 0\). See also `is_exhaustive()`.

    OUTPUT: boolean; whether each filtration is separating, see `is_separating()`

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.is_separating()
        True

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.is_separating()
        True

  max_degree()

    Return the highest degree of the filtration.

    OUTPUT:

    Integer or minus infinity. The smallest degree of the filtrations such that the filtrations are constant to the right.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.max_degree()
        4

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.max_degree()
        4

  min_degree()

    Return the lowest degree of the filtration.

    OUTPUT:

    Integer or plus infinity. The largest degree \(d\) of the (descending) filtrations such that, for each individual filtration, the filtered vector space \(F_d\) still equal to \(F_{-\infty}\).

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.min_degree()
        1

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.min_degree()
        1

  random_deformation(epsilon=None)

    Return a random deformation.

    INPUT:

    - `epsilon` – a number in the base ring

    OUTPUT:

    A new multi-filtered vector space where the generating vectors of subspaces are moved by `epsilon` times a random vector.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: V.get_degree('b',1)
        Vector space of degree 2 and dimension 1 over Rational Field
        Basis matrix:
        [1 0]
        sage: D = V.random_deformation(1/100).get_degree('b',1)
        sage: D.degree()
        2
        sage: D.dimension()
        1
        sage: D.matrix()[0, 0]
        1

        sage: while V.random_deformation(1/100).get_degree('b',1).matrix() == matrix([1, 0]):
        ....:     pass

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> V.get_degree('b',Integer(1))
        Vector space of degree 2 and dimension 1 over Rational Field
        Basis matrix:
        [1 0]
        >>> D = V.random_deformation(Integer(1)/Integer(100)).get_degree('b',Integer(1))
        >>> D.degree()
        2
        >>> D.dimension()
        1
        >>> D.matrix()[Integer(0), Integer(0)]
        1

        >>> while V.random_deformation(Integer(1)/Integer(100)).get_degree('b',Integer(1)).matrix() == matrix([Integer(1), Integer(0)]):
        ...     pass

  shift(deg)

    Return a filtered vector space with degrees shifted by a constant.

    OUTPUT:

    The shift of `self`. See `shift()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: V.support()
        (0, 1, 3)
        sage: V.shift(-5).support()
        (-5, -4, -2)

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> V.support()
        (0, 1, 3)
        >>> V.shift(-Integer(5)).support()
        (-5, -4, -2)

  support()

    Return the degrees in which there are non-trivial generators.

    OUTPUT:

    A tuple of integers (and plus infinity) in ascending order. The last entry is plus infinity if and only if the filtration is not separating (see `is_separating()`).

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(2, 3)
        sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
        sage: V.support()
        (1, 3)

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(2), Integer(3))
        >>> V = MultiFilteredVectorSpace({Integer(1):F1, Integer(2):F2})
        >>> V.support()
        (1, 3)

  symmetric_power(n)

    Return the \(n\)-th graded symmetric power.

    INPUT:

    - `n` – integer; symmetric product of how many copies of `self`

    OUTPUT:

    The symmetric power as a multi-filtered vector space. See `symmetric_power()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: V.symmetric_power(2)
        Filtrations
            a: QQ^3 >= QQ^3 >= QQ^3 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> V.symmetric_power(Integer(2))
        Filtrations
            a: QQ^3 >= QQ^3 >= QQ^3 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

  tensor_product(other)

    Return the graded tensor product.

    INPUT:

    - `other` – a multi-filtered vector space with the same `index_set()`

    OUTPUT:

    The tensor product of `self` and `other` as a multi-filtered vector space. See `tensor_product()`.

    EXAMPLES:

    Sage

        sage: F1 = FilteredVectorSpace(2, 1)
        sage: F2 = FilteredVectorSpace(1, 3) + FilteredVectorSpace(1,0)
        sage: V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        sage: G1 = FilteredVectorSpace(1, 1)
        sage: G2 = FilteredVectorSpace(1, 3)
        sage: W = MultiFilteredVectorSpace({'a':G1, 'b':G2})
        sage: V.tensor_product(W)
        Filtrations
            a: QQ^2 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0
        sage: V * W   # syntactic sugar
        Filtrations
            a: QQ^2 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

    Python

        >>> from sage.all import *
        >>> F1 = FilteredVectorSpace(Integer(2), Integer(1))
        >>> F2 = FilteredVectorSpace(Integer(1), Integer(3)) + FilteredVectorSpace(Integer(1),Integer(0))
        >>> V = MultiFilteredVectorSpace({'a':F1, 'b':F2})
        >>> G1 = FilteredVectorSpace(Integer(1), Integer(1))
        >>> G2 = FilteredVectorSpace(Integer(1), Integer(3))
        >>> W = MultiFilteredVectorSpace({'a':G1, 'b':G2})
        >>> V.tensor_product(W)
        Filtrations
            a: QQ^2 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0
        >>> V * W   # syntactic sugar
        Filtrations
            a: QQ^2 >=  0   >=  0   >=  0   >=  0   >= 0
            b: QQ^2 >= QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0

  wedge(n)

    alias of `exterior_power()`.