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: 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]

>>> 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)[source]#

Contstruct 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 (optional; default: True). Whether to perform consistency checks.

EXAMPLES:

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

>>> 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)[source]#

Bases: FreeModule_ambient_field

Python constructor.

Warning

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

INPUT:

  • base_ring – a ring. the base ring.

  • dim – integer. The dimension of the ambient vector space.

  • filtrations – a dictionary whose values are filtrations.

  • check – boolean (optional). Whether to perform additional consistency checks.

EXAMPLES:

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

>>> 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()[source]#

Return the ambient (unfiltered) vector space.

OUTPUT:

A vector space.

EXAMPLES:

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

>>> 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)[source]#

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

INPUT:

  • base_ring – a 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: 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

>>> 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)[source]#

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: 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

>>> 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()[source]#

Return the dual.

OUTPUT:

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

EXAMPLES:

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

>>> 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)[source]#

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: 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

>>> 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)[source]#

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: 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]

>>> 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)[source]#

Return the filtration indexed by key.

OUTPUT:

A filtered vector space.

EXAMPLES:

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

>>> 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)[source]#

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: 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:
[]

>>> 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()[source]#

Return the allowed indices for the different filtrations.

OUTPUT:

Set.

EXAMPLES:

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

>>> 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()[source]#

Return whether the multi-filtration is constant.

OUTPUT:

Boolean. Whether the each filtration is constant, see is_constant().

EXAMPLES:

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

>>> 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()[source]#

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: F1 = FilteredVectorSpace(2, 1)
sage: F2 = FilteredVectorSpace(2, 3)
sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
sage: V.is_exhaustive()
True

>>> 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()[source]#

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: F1 = FilteredVectorSpace(2, 1)
sage: F2 = FilteredVectorSpace(2, 3)
sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
sage: V.is_separating()
True

>>> 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()[source]#

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: F1 = FilteredVectorSpace(2, 1)
sage: F2 = FilteredVectorSpace(2, 3)
sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
sage: V.max_degree()
4

>>> 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()[source]#

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: F1 = FilteredVectorSpace(2, 1)
sage: F2 = FilteredVectorSpace(2, 3)
sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
sage: V.min_degree()
1

>>> 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)[source]#

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: 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

>>> 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)[source]#

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

OUTPUT:

The shift of self. See shift().

EXAMPLES:

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)

>>> 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()[source]#

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: F1 = FilteredVectorSpace(2, 1)
sage: F2 = FilteredVectorSpace(2, 3)
sage: V = MultiFilteredVectorSpace({1:F1, 2:F2})
sage: V.support()
(1, 3)

>>> 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)[source]#

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: 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

>>> 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)[source]#

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: 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

>>> 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)[source]#

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: 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

>>> 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