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 (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– 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: 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– 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 - degin the filtration indexed by- keyas 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 - epsilontimes 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 - selfand- otheras 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