\(\ZZ\)-filtered vector spaces¶
This module implements filtered vector spaces, that is, a descending sequence of vector spaces
with degrees \(d\in \ZZ\). It is not required that \(F_d\) is the entire
ambient space for \(d\ll 0\) (see
is_exhaustive()) nor that \(F_d=0\) for
\(d\gg 0\) (see is_separating()). To
construct a filtered vector space, use the FilteredVectorSpace()
command. It supports easy creation of simple filtrations, for example
the trivial one:
sage: FilteredVectorSpace(2, base_ring=RDF)
RDF^2
>>> from sage.all import *
>>> FilteredVectorSpace(Integer(2), base_ring=RDF)
RDF^2
The next-simplest filtration has a single non-trivial inclusion between \(V_d\) and \(V_{d+1}\):
sage: d = 1
sage: V = FilteredVectorSpace(2, d);  V
QQ^2 >= 0
sage: [V.get_degree(i).dimension() for i in range(0,4)]
[2, 2, 0, 0]
>>> from sage.all import *
>>> d = Integer(1)
>>> V = FilteredVectorSpace(Integer(2), d);  V
QQ^2 >= 0
>>> [V.get_degree(i).dimension() for i in range(Integer(0),Integer(4))]
[2, 2, 0, 0]
To construct general filtrations, you need to tell Sage about generating vectors for the nested subspaces. For example, a dictionary whose keys are the degrees and values are a list of generators:
sage: r1 = (1, 0, 5)
sage: r2 = (0, 1, 2)
sage: r3 = (1, 2, 1)
sage: V = FilteredVectorSpace({0:[r1, r2, r3], 1:[r1, r2], 3:[r1]});  V
QQ^3 >= QQ^2 >= QQ^1 >= QQ^1 >= 0
>>> from sage.all import *
>>> r1 = (Integer(1), Integer(0), Integer(5))
>>> r2 = (Integer(0), Integer(1), Integer(2))
>>> r3 = (Integer(1), Integer(2), Integer(1))
>>> V = FilteredVectorSpace({Integer(0):[r1, r2, r3], Integer(1):[r1, r2], Integer(3):[r1]});  V
QQ^3 >= QQ^2 >= QQ^1 >= QQ^1 >= 0
For degrees \(d\) that are not specified, the associated vector subspace is the same as the next-lower degree, that is, \(V_d \simeq V_{d-1}\). In the above example, this means that
- \(V_d \simeq \QQ^3\) for \(d<0\) 
- \(V_0 = \mathop{span}(r_1, r_2) \simeq \QQ^2\) 
- \(V_1 = V_2 = \mathop{span}(r_3) \simeq \QQ\) 
- \(V_d = 0\) for \(d \geq 3\) 
That is:
sage: V.get_degree(0) == V
True
sage: V.get_degree(1) == V.span([r1, r2])
True
sage: V.get_degree(2) == V.get_degree(3) == V.span([r1])
True
sage: V.get_degree(4) == V.get_degree(5) == V.span([])
True
>>> from sage.all import *
>>> V.get_degree(Integer(0)) == V
True
>>> V.get_degree(Integer(1)) == V.span([r1, r2])
True
>>> V.get_degree(Integer(2)) == V.get_degree(Integer(3)) == V.span([r1])
True
>>> V.get_degree(Integer(4)) == V.get_degree(Integer(5)) == V.span([])
True
If you have many generators you can just pass the generators once and then refer to them by index:
sage: FilteredVectorSpace([r1, r2, r3], {0:[0,1,2], 1:[1,2], 3:[1]})
QQ^3 >= QQ^2 >= QQ^1 >= QQ^1 >= 0
>>> from sage.all import *
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0),Integer(1),Integer(2)], Integer(1):[Integer(1),Integer(2)], Integer(3):[Integer(1)]})
QQ^3 >= QQ^2 >= QQ^1 >= QQ^1 >= 0
Note that generators for the degree-\(d\) subspace of the filtration are automatically generators for all lower degrees. For example, here we do not have to specify the ray \(r_2\) separately in degree 1:
sage: FilteredVectorSpace([r1, r2, r3], {0:[0   ], 1:[1]})
QQ^2 >= QQ^1 >= 0 in QQ^3
sage: FilteredVectorSpace([r1, r2, r3], {0:[0, 1], 1:[1]})
QQ^2 >= QQ^1 >= 0 in QQ^3
>>> from sage.all import *
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0)   ], Integer(1):[Integer(1)]})
QQ^2 >= QQ^1 >= 0 in QQ^3
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0), Integer(1)], Integer(1):[Integer(1)]})
QQ^2 >= QQ^1 >= 0 in QQ^3
The degree can be infinite (plus infinity), this allows construction of filtered vector spaces that are not eventually zero in high degree:
sage: FilteredVectorSpace([r1, r2, r3], {0:[0,1], oo:[1]})
QQ^2 >= QQ^1 in QQ^3
>>> from sage.all import *
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0),Integer(1)], oo:[Integer(1)]})
QQ^2 >= QQ^1 in QQ^3
Any field can be used as the vector space base. For example a finite field:
sage: F.<a> = GF(5^3)                                                               # needs sage.rings.finite_rings
sage: r1 = (a, 0, F(5));  r1                                                        # needs sage.rings.finite_rings
(a, 0, 0)
sage: FilteredVectorSpace([r1, r2, r3], {0:[0,1], oo:[1]}, base_ring=F)             # needs sage.rings.finite_rings
GF(125)^2 >= GF(125)^1 in GF(125)^3
>>> from sage.all import *
>>> F = GF(Integer(5)**Integer(3), names=('a',)); (a,) = F._first_ngens(1)# needs sage.rings.finite_rings
>>> r1 = (a, Integer(0), F(Integer(5)));  r1                                                        # needs sage.rings.finite_rings
(a, 0, 0)
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0),Integer(1)], oo:[Integer(1)]}, base_ring=F)             # needs sage.rings.finite_rings
GF(125)^2 >= GF(125)^1 in GF(125)^3
Or the algebraic field:
sage: r1 = (1, 0, 1+QQbar(I));  r1                                                  # needs sage.rings.number_field
(1, 0, I + 1)
sage: FilteredVectorSpace([r1, r2, r3], {0:[0,1], oo:[1]}, base_ring=QQbar)         # needs sage.rings.number_field
Vector space of dimension 2 over Algebraic Field
>= Vector space of dimension 1 over Algebraic Field
in Vector space of dimension 3 over Algebraic Field
>>> from sage.all import *
>>> r1 = (Integer(1), Integer(0), Integer(1)+QQbar(I));  r1                                                  # needs sage.rings.number_field
(1, 0, I + 1)
>>> FilteredVectorSpace([r1, r2, r3], {Integer(0):[Integer(0),Integer(1)], oo:[Integer(1)]}, base_ring=QQbar)         # needs sage.rings.number_field
Vector space of dimension 2 over Algebraic Field
>= Vector space of dimension 1 over Algebraic Field
in Vector space of dimension 3 over Algebraic Field
- sage.modules.filtered_vector_space.FilteredVectorSpace(arg1, arg2=None, base_ring=Rational Field, check=True)[source]¶
- Construct a filtered vector space. - INPUT: - This function accepts various input that determines the vector space and filtration. - Just the dimensionFilteredVectorSpace(dimension): Return the trivial filtration (where all vector spaces are isomorphic). 
- Dimension and maximal degree, see - constructor_from_dim_degree()for arguments. Construct a filtration with only one non-trivial step \(V\supset 0\) at the given cutoff degree.
- A dictionary containing the degrees as keys and a list of vector space generators as values, see - FilteredVectorSpace_from_generators()
- Generators and a dictionary containing the degrees as keys and the indices of vector space generators as values, see - FilteredVectorSpace_from_generators_indices()
 - In addition, the following keyword arguments are supported: - base_ring– a field (default: \(\QQ\)). The base field of the vector space. Must be a field.
 - EXAMPLES: - Just the dimension for the trivial filtration: - sage: FilteredVectorSpace(2) QQ^2 - >>> from sage.all import * >>> FilteredVectorSpace(Integer(2)) QQ^2 - Dimension and degree: - sage: FilteredVectorSpace(2, 1) QQ^2 >= 0 - >>> from sage.all import * >>> FilteredVectorSpace(Integer(2), Integer(1)) QQ^2 >= 0 - Dictionary of generators: - sage: FilteredVectorSpace({1:[(1,0), (0,1)], 3:[(1,0)]}) QQ^2 >= QQ^1 >= QQ^1 >= 0 - >>> from sage.all import * >>> FilteredVectorSpace({Integer(1):[(Integer(1),Integer(0)), (Integer(0),Integer(1))], Integer(3):[(Integer(1),Integer(0))]}) QQ^2 >= QQ^1 >= QQ^1 >= 0 - Generators and a dictionary referring to them by index: - sage: FilteredVectorSpace([(1,0), (0,1)], {1:[0,1], 3:[0]}) QQ^2 >= QQ^1 >= QQ^1 >= 0 - >>> from sage.all import * >>> FilteredVectorSpace([(Integer(1),Integer(0)), (Integer(0),Integer(1))], {Integer(1):[Integer(0),Integer(1)], Integer(3):[Integer(0)]}) QQ^2 >= QQ^1 >= QQ^1 >= 0 
- class sage.modules.filtered_vector_space.FilteredVectorSpace_class(base_ring, dim, generators, filtration, check=True)[source]¶
- Bases: - FreeModule_ambient_field- A descending filtration of a vector space. - INPUT: - base_ring– a field; the base field of the ambient vector space
- dim– integer; the dimension of the ambient vector space
- generators– tuple of generators for the ambient vector space. These will be used to span the subspaces of the filtration.
- filtration– dictionary of filtration steps in ray index notation. See- construct_from_generators_indices()for details.
- check– boolean (default:- True); whether to perform consistency checks
 - ambient_vector_space()[source]¶
- Return the ambient (unfiltered) vector space. - OUTPUT: a vector space - EXAMPLES: - sage: V = FilteredVectorSpace(1, 0) sage: V.ambient_vector_space() Vector space of dimension 1 over Rational Field - >>> from sage.all import * >>> V = FilteredVectorSpace(Integer(1), Integer(0)) >>> V.ambient_vector_space() Vector space of dimension 1 over Rational Field 
 - change_ring(base_ring)[source]¶
- Return the same filtration over a different base ring. - INPUT: - base_ring– the new base ring
 - OUTPUT: - This method returns a new filtered vector space whose subspaces are defined by the same generators but over a different base ring. - EXAMPLES: - sage: V = FilteredVectorSpace(1, 0); V QQ^1 >= 0 sage: V.change_ring(RDF) RDF^1 >= 0 - >>> from sage.all import * >>> V = FilteredVectorSpace(Integer(1), Integer(0)); V QQ^1 >= 0 >>> V.change_ring(RDF) RDF^1 >= 0 
 - direct_sum(other)[source]¶
- Return the direct sum. - INPUT: - other– a filtered vector space
 - OUTPUT: the direct sum as a filtered vector space - EXAMPLES: - sage: V = FilteredVectorSpace(2, 0) sage: W = FilteredVectorSpace({0:[(1,-1),(2,1)], 1:[(1,1)]}) sage: V.direct_sum(W) QQ^4 >= QQ^1 >= 0 sage: V + W # syntactic sugar QQ^4 >= QQ^1 >= 0 sage: V + V == FilteredVectorSpace(4, 0) True sage: W = FilteredVectorSpace([(1,-1),(2,1)], {1:[0,1], 2:[1]}) sage: V + W QQ^4 >= QQ^2 >= QQ^1 >= 0 - >>> from sage.all import * >>> V = FilteredVectorSpace(Integer(2), Integer(0)) >>> W = FilteredVectorSpace({Integer(0):[(Integer(1),-Integer(1)),(Integer(2),Integer(1))], Integer(1):[(Integer(1),Integer(1))]}) >>> V.direct_sum(W) QQ^4 >= QQ^1 >= 0 >>> V + W # syntactic sugar QQ^4 >= QQ^1 >= 0 >>> V + V == FilteredVectorSpace(Integer(4), Integer(0)) True >>> W = FilteredVectorSpace([(Integer(1),-Integer(1)),(Integer(2),Integer(1))], {Integer(1):[Integer(0),Integer(1)], Integer(2):[Integer(1)]}) >>> V + W QQ^4 >= QQ^2 >= QQ^1 >= 0 - A suitable base ring is chosen if they do not match: - sage: v = [(1,0), (0,1)] sage: F1 = FilteredVectorSpace(v, {0:[0], 1:[1]}, base_ring=QQ) sage: F2 = FilteredVectorSpace(v, {0:[0], 1:[1]}, base_ring=RDF) sage: F1 + F2 # needs scipy RDF^4 >= RDF^2 >= 0 - >>> from sage.all import * >>> v = [(Integer(1),Integer(0)), (Integer(0),Integer(1))] >>> F1 = FilteredVectorSpace(v, {Integer(0):[Integer(0)], Integer(1):[Integer(1)]}, base_ring=QQ) >>> F2 = FilteredVectorSpace(v, {Integer(0):[Integer(0)], Integer(1):[Integer(1)]}, base_ring=RDF) >>> F1 + F2 # needs scipy RDF^4 >= RDF^2 >= 0 
 - dual()[source]¶
- Return the dual filtered vector space. - OUTPUT: - The graded dual, that is, the dual of a degree-\(d\) subspace is a set of linear constraints in degree \(-d+1\). That is, the dual generators live in degree \(-d\). - EXAMPLES: - sage: gens = identity_matrix(3).rows() sage: F = FilteredVectorSpace(gens, {0:[0,1,2], 2:[0]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 sage: F.support() (0, 2) sage: F.dual() QQ^3 >= QQ^2 >= QQ^2 >= 0 sage: F.dual().support() (-2, 0) - >>> from sage.all import * >>> gens = identity_matrix(Integer(3)).rows() >>> F = FilteredVectorSpace(gens, {Integer(0):[Integer(0),Integer(1),Integer(2)], Integer(2):[Integer(0)]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 >>> F.support() (0, 2) >>> F.dual() QQ^3 >= QQ^2 >= QQ^2 >= 0 >>> F.dual().support() (-2, 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 graded exterior product, that is, the wedge product of a generator of degree \(d_1\) with a generator in degree \(d_2\) has degree \(d_1 + d_2\). - EXAMPLES: - sage: # needs sage.groups sage: F = FilteredVectorSpace(1, 1) + FilteredVectorSpace(1, 2); F QQ^2 >= QQ^1 >= 0 sage: F.exterior_power(1) QQ^2 >= QQ^1 >= 0 sage: F.exterior_power(2) QQ^1 >= 0 sage: F.exterior_power(3) 0 sage: F.wedge(2) QQ^1 >= 0 - >>> from sage.all import * >>> # needs sage.groups >>> F = FilteredVectorSpace(Integer(1), Integer(1)) + FilteredVectorSpace(Integer(1), Integer(2)); F QQ^2 >= QQ^1 >= 0 >>> F.exterior_power(Integer(1)) QQ^2 >= QQ^1 >= 0 >>> F.exterior_power(Integer(2)) QQ^1 >= 0 >>> F.exterior_power(Integer(3)) 0 >>> F.wedge(Integer(2)) QQ^1 >= 0 
 - get_degree(d)[source]¶
- Return the degree- - dentry of the filtration.- INPUT: - d– integer; the desired degree of the filtration
 - OUTPUT: - The degree- - dvector space in the filtration as subspace of the ambient space.- EXAMPLES: - sage: rays = [(1,0), (1,1), (1,2), (-1,-1)] sage: F = FilteredVectorSpace(rays, {3:[1], 1:[1,2]}) sage: F.get_degree(2) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 1] sage: F.get_degree(oo) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] sage: F.get_degree(-oo) Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] - >>> from sage.all import * >>> rays = [(Integer(1),Integer(0)), (Integer(1),Integer(1)), (Integer(1),Integer(2)), (-Integer(1),-Integer(1))] >>> F = FilteredVectorSpace(rays, {Integer(3):[Integer(1)], Integer(1):[Integer(1),Integer(2)]}) >>> F.get_degree(Integer(2)) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 1] >>> F.get_degree(oo) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] >>> F.get_degree(-oo) Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] 
 - graded(d)[source]¶
- Return the associated graded vectorspace. - INPUT: - d– integer; the degree
 - OUTPUT: the quotient \(G_d = F_d / F_{d+1}\) - EXAMPLES: - sage: rays = [(1,0), (1,1), (1,2)] sage: F = FilteredVectorSpace(rays, {3:[1], 1:[1,2]}) sage: F.graded(1) Vector space quotient V/W of dimension 1 over Rational Field where V: Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] W: Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 1] - >>> from sage.all import * >>> rays = [(Integer(1),Integer(0)), (Integer(1),Integer(1)), (Integer(1),Integer(2))] >>> F = FilteredVectorSpace(rays, {Integer(3):[Integer(1)], Integer(1):[Integer(1),Integer(2)]}) >>> F.graded(Integer(1)) Vector space quotient V/W of dimension 1 over Rational Field where V: Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] W: Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 1] 
 - is_constant()[source]¶
- Return whether the filtration is constant. - OUTPUT: boolean; whether the filtered vector spaces are identical in all degrees - EXAMPLES: - sage: V = FilteredVectorSpace(2); V QQ^2 sage: V.is_constant() True sage: V = FilteredVectorSpace(1, 0); V QQ^1 >= 0 sage: V.is_constant() False sage: V = FilteredVectorSpace({0:[(1,)]}); V QQ^1 >= 0 sage: V.is_constant() False - >>> from sage.all import * >>> V = FilteredVectorSpace(Integer(2)); V QQ^2 >>> V.is_constant() True >>> V = FilteredVectorSpace(Integer(1), Integer(0)); V QQ^1 >= 0 >>> V.is_constant() False >>> V = FilteredVectorSpace({Integer(0):[(Integer(1),)]}); V QQ^1 >= 0 >>> V.is_constant() False 
 - is_exhaustive()[source]¶
- Return whether the 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 - EXAMPLES: - sage: F = FilteredVectorSpace({0:[(1,1)]}); F QQ^1 >= 0 in QQ^2 sage: F.is_exhaustive() False sage: G = FilteredVectorSpace(2, 0); G QQ^2 >= 0 sage: G.is_exhaustive() True - >>> from sage.all import * >>> F = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(1))]}); F QQ^1 >= 0 in QQ^2 >>> F.is_exhaustive() False >>> G = FilteredVectorSpace(Integer(2), Integer(0)); G QQ^2 >= 0 >>> G.is_exhaustive() True 
 - is_separating()[source]¶
- Return whether the 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 - EXAMPLES: - sage: F = FilteredVectorSpace({0:[(1,1)]}); F QQ^1 >= 0 in QQ^2 sage: F.is_separating() True sage: G = FilteredVectorSpace({0:[(1,1,0)], oo:[(0,0,1)]}); G QQ^2 >= QQ^1 in QQ^3 sage: G.is_separating() False - >>> from sage.all import * >>> F = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(1))]}); F QQ^1 >= 0 in QQ^2 >>> F.is_separating() True >>> G = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(1),Integer(0))], oo:[(Integer(0),Integer(0),Integer(1))]}); G QQ^2 >= QQ^1 in QQ^3 >>> G.is_separating() False 
 - max_degree()[source]¶
- Return the highest degree of the filtration. - OUTPUT: - Integer or minus infinity. The smallest degree of the filtration such that the filtration is constant to the right. - EXAMPLES: - sage: FilteredVectorSpace(1, 3).max_degree() 4 sage: FilteredVectorSpace({0:[[1]]}).max_degree() 1 sage: FilteredVectorSpace(3).max_degree() -Infinity - >>> from sage.all import * >>> FilteredVectorSpace(Integer(1), Integer(3)).max_degree() 4 >>> FilteredVectorSpace({Integer(0):[[Integer(1)]]}).max_degree() 1 >>> FilteredVectorSpace(Integer(3)).max_degree() -Infinity 
 - min_degree()[source]¶
- Return the lowest degree of the filtration. - OUTPUT: - Integer or plus infinity. The largest degree \(d\) of the (descending) filtration such that the filtered vector space \(F_d\) is still equal to \(F_{-\infty}\). - EXAMPLES: - sage: FilteredVectorSpace(1, 3).min_degree() 3 sage: FilteredVectorSpace(2).min_degree() +Infinity - >>> from sage.all import * >>> FilteredVectorSpace(Integer(1), Integer(3)).min_degree() 3 >>> FilteredVectorSpace(Integer(2)).min_degree() +Infinity 
 - presentation()[source]¶
- Return a presentation in term of generators of various degrees. - OUTPUT: - A pair consisting of generators and a filtration suitable as input to - construct_from_generators_indices().- EXAMPLES: - sage: rays = [(1,0), (1,1), (1,2), (-1,-1)] sage: F = FilteredVectorSpace(rays, {0:[1, 2], 2:[3]}); F QQ^2 >= QQ^1 >= QQ^1 >= 0 sage: F.presentation() (((0, 1), (1, 0), (1, 1)), {0: (1, 0), 2: (2,), +Infinity: ()}) - >>> from sage.all import * >>> rays = [(Integer(1),Integer(0)), (Integer(1),Integer(1)), (Integer(1),Integer(2)), (-Integer(1),-Integer(1))] >>> F = FilteredVectorSpace(rays, {Integer(0):[Integer(1), Integer(2)], Integer(2):[Integer(3)]}); F QQ^2 >= QQ^1 >= QQ^1 >= 0 >>> F.presentation() (((0, 1), (1, 0), (1, 1)), {0: (1, 0), 2: (2,), +Infinity: ()}) 
 - random_deformation(epsilon=None)[source]¶
- Return a random deformation. - INPUT: - epsilon– a number in the base ring
 - OUTPUT: - A new filtered vector space where the generators of the subspaces are moved by - epsilontimes a random vector.- EXAMPLES: - sage: gens = identity_matrix(3).rows() sage: F = FilteredVectorSpace(gens, {0:[0,1,2], 2:[0]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 sage: F.get_degree(2) Vector space of degree 3 and dimension 1 over Rational Field Basis matrix: [1 0 0] sage: G = F.random_deformation(1/50); G QQ^3 >= QQ^1 >= QQ^1 >= 0 sage: D = G.get_degree(2) sage: D.degree() 3 sage: v = D.basis_matrix()[0] sage: v[0] 1 sage: while F.random_deformation(1/50).get_degree(2).matrix() == matrix([1, 0, 0]): ....: pass - >>> from sage.all import * >>> gens = identity_matrix(Integer(3)).rows() >>> F = FilteredVectorSpace(gens, {Integer(0):[Integer(0),Integer(1),Integer(2)], Integer(2):[Integer(0)]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 >>> F.get_degree(Integer(2)) Vector space of degree 3 and dimension 1 over Rational Field Basis matrix: [1 0 0] >>> G = F.random_deformation(Integer(1)/Integer(50)); G QQ^3 >= QQ^1 >= QQ^1 >= 0 >>> D = G.get_degree(Integer(2)) >>> D.degree() 3 >>> v = D.basis_matrix()[Integer(0)] >>> v[Integer(0)] 1 >>> while F.random_deformation(Integer(1)/Integer(50)).get_degree(Integer(2)).matrix() == matrix([Integer(1), Integer(0), Integer(0)]): ... pass 
 - shift(deg)[source]¶
- Return a filtered vector space with degrees shifted by a constant. - EXAMPLES: - sage: gens = identity_matrix(3).rows() sage: F = FilteredVectorSpace(gens, {0:[0,1,2], 2:[0]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 sage: F.support() (0, 2) sage: F.shift(-5).support() (-5, -3) - >>> from sage.all import * >>> gens = identity_matrix(Integer(3)).rows() >>> F = FilteredVectorSpace(gens, {Integer(0):[Integer(0),Integer(1),Integer(2)], Integer(2):[Integer(0)]}); F QQ^3 >= QQ^1 >= QQ^1 >= 0 >>> F.support() (0, 2) >>> F.shift(-Integer(5)).support() (-5, -3) 
 - 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: G = FilteredVectorSpace({0:[(1,1,0)], 3:[(0,1,0)]}); G QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0 in QQ^3 sage: G.support() (0, 3) sage: G = FilteredVectorSpace({0:[(1,1,0)], 3:[(0,1,0)], oo:[(0,0,1)]}); G QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= QQ^1 sage: G.support() (0, 3, +Infinity) - >>> from sage.all import * >>> G = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(1),Integer(0))], Integer(3):[(Integer(0),Integer(1),Integer(0))]}); G QQ^2 >= QQ^1 >= QQ^1 >= QQ^1 >= 0 in QQ^3 >>> G.support() (0, 3) >>> G = FilteredVectorSpace({Integer(0):[(Integer(1),Integer(1),Integer(0))], Integer(3):[(Integer(0),Integer(1),Integer(0))], oo:[(Integer(0),Integer(0),Integer(1))]}); G QQ^3 >= QQ^2 >= QQ^2 >= QQ^2 >= QQ^1 >>> G.support() (0, 3, +Infinity) 
 - symmetric_power(n)[source]¶
- Return the \(n\)-th graded symmetric power. - INPUT: - n– integer; symmetric product of how many copies of- self
 - OUTPUT: - The graded symmetric product, that is, the symmetrization of a generator of degree \(d_1\) with a generator in degree \(d_2\) has degree \(d_1 + d_2\). - EXAMPLES: - sage: F = FilteredVectorSpace(1, 1) + FilteredVectorSpace(1, 2); F QQ^2 >= QQ^1 >= 0 sage: F.symmetric_power(2) QQ^3 >= QQ^2 >= QQ^1 >= 0 - >>> from sage.all import * >>> F = FilteredVectorSpace(Integer(1), Integer(1)) + FilteredVectorSpace(Integer(1), Integer(2)); F QQ^2 >= QQ^1 >= 0 >>> F.symmetric_power(Integer(2)) QQ^3 >= QQ^2 >= QQ^1 >= 0 
 - tensor_product(other)[source]¶
- Return the graded tensor product. - INPUT: - other– a filtered vector space
 - OUTPUT: - The graded tensor product, that is, the tensor product of a generator of degree \(d_1\) with a generator in degree \(d_2\) has degree \(d_1 + d_2\). - EXAMPLES: - sage: F1 = FilteredVectorSpace(1, 1) sage: F2 = FilteredVectorSpace(1, 2) sage: F1.tensor_product(F2) QQ^1 >= 0 sage: F1 * F2 QQ^1 >= 0 sage: F1.min_degree() 1 sage: F2.min_degree() 2 sage: (F1*F2).min_degree() 3 - >>> from sage.all import * >>> F1 = FilteredVectorSpace(Integer(1), Integer(1)) >>> F2 = FilteredVectorSpace(Integer(1), Integer(2)) >>> F1.tensor_product(F2) QQ^1 >= 0 >>> F1 * F2 QQ^1 >= 0 >>> F1.min_degree() 1 >>> F2.min_degree() 2 >>> (F1*F2).min_degree() 3 - A suitable base ring is chosen if they do not match: - sage: v = [(1,0), (0,1)] sage: F1 = FilteredVectorSpace(v, {0:[0], 1:[1]}, base_ring=QQ) sage: F2 = FilteredVectorSpace(v, {0:[0], 1:[1]}, base_ring=RDF) sage: F1 * F2 # needs scipy RDF^4 >= RDF^3 >= RDF^1 >= 0 - >>> from sage.all import * >>> v = [(Integer(1),Integer(0)), (Integer(0),Integer(1))] >>> F1 = FilteredVectorSpace(v, {Integer(0):[Integer(0)], Integer(1):[Integer(1)]}, base_ring=QQ) >>> F2 = FilteredVectorSpace(v, {Integer(0):[Integer(0)], Integer(1):[Integer(1)]}, base_ring=RDF) >>> F1 * F2 # needs scipy RDF^4 >= RDF^3 >= RDF^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 graded exterior product, that is, the wedge product of a generator of degree \(d_1\) with a generator in degree \(d_2\) has degree \(d_1 + d_2\). - EXAMPLES: - sage: # needs sage.groups sage: F = FilteredVectorSpace(1, 1) + FilteredVectorSpace(1, 2); F QQ^2 >= QQ^1 >= 0 sage: F.exterior_power(1) QQ^2 >= QQ^1 >= 0 sage: F.exterior_power(2) QQ^1 >= 0 sage: F.exterior_power(3) 0 sage: F.wedge(2) QQ^1 >= 0 - >>> from sage.all import * >>> # needs sage.groups >>> F = FilteredVectorSpace(Integer(1), Integer(1)) + FilteredVectorSpace(Integer(1), Integer(2)); F QQ^2 >= QQ^1 >= 0 >>> F.exterior_power(Integer(1)) QQ^2 >= QQ^1 >= 0 >>> F.exterior_power(Integer(2)) QQ^1 >= 0 >>> F.exterior_power(Integer(3)) 0 >>> F.wedge(Integer(2)) QQ^1 >= 0 
 
- sage.modules.filtered_vector_space.construct_from_dim_degree(dim, max_degree, base_ring, check)[source]¶
- Construct a filtered vector space. - INPUT: - dim– integer; the dimension
- max_degree– integer or infinity; the maximal degree where the vector subspace of the filtration is still the entire space
 - EXAMPLES: - sage: V = FilteredVectorSpace(2, 5); V QQ^2 >= 0 sage: V.get_degree(5) Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] sage: V.get_degree(6) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] sage: FilteredVectorSpace(2, oo) QQ^2 sage: FilteredVectorSpace(2, -oo) 0 in QQ^2 - >>> from sage.all import * >>> V = FilteredVectorSpace(Integer(2), Integer(5)); V QQ^2 >= 0 >>> V.get_degree(Integer(5)) Vector space of degree 2 and dimension 2 over Rational Field Basis matrix: [1 0] [0 1] >>> V.get_degree(Integer(6)) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] >>> FilteredVectorSpace(Integer(2), oo) QQ^2 >>> FilteredVectorSpace(Integer(2), -oo) 0 in QQ^2 
- sage.modules.filtered_vector_space.construct_from_generators(filtration, base_ring, check)[source]¶
- Construct a filtered vector space. - INPUT: - filtration– dictionary of filtration steps. Each filtration step is a pair consisting of an integer degree and a list/tuple/iterable of vector space generators. The integer- degreestipulates that all filtration steps of degree higher or equal than- degree(up to the next filtration step) are said subspace.
 - EXAMPLES: - sage: from sage.modules.filtered_vector_space import construct_from_generators sage: r = [1, 2] sage: construct_from_generators({1:[r]}, QQ, True) QQ^1 >= 0 in QQ^2 - >>> from sage.all import * >>> from sage.modules.filtered_vector_space import construct_from_generators >>> r = [Integer(1), Integer(2)] >>> construct_from_generators({Integer(1):[r]}, QQ, True) QQ^1 >= 0 in QQ^2 
- sage.modules.filtered_vector_space.construct_from_generators_indices(generators, filtration, base_ring, check)[source]¶
- Construct a filtered vector space. - INPUT: - generators– list/tuple/iterable of vectors, or something convertible to them. The generators spanning various subspaces.
- filtration– list or iterable of filtration steps. Each filtration step is a pair- (degree, ray_indices). The- ray_indicesare a list or iterable of ray indices, which span a subspace of the vector space. The integer- degreestipulates that all filtration steps of degree higher or equal than- degree(up to the next filtration step) are said subspace.
 - EXAMPLES: - sage: from sage.modules.filtered_vector_space import construct_from_generators_indices sage: gens = [(1,0), (0,1), (-1,-1)] sage: V = construct_from_generators_indices(gens, {1:[0,1], 3:[1]}, QQ, True); V QQ^2 >= QQ^1 >= QQ^1 >= 0 - >>> from sage.all import * >>> from sage.modules.filtered_vector_space import construct_from_generators_indices >>> gens = [(Integer(1),Integer(0)), (Integer(0),Integer(1)), (-Integer(1),-Integer(1))] >>> V = construct_from_generators_indices(gens, {Integer(1):[Integer(0),Integer(1)], Integer(3):[Integer(1)]}, QQ, True); V QQ^2 >= QQ^1 >= QQ^1 >= 0 
- sage.modules.filtered_vector_space.is_FilteredVectorSpace(X)[source]¶
- Test whether - Xis a filtered vector space.- This function is for library use only. - INPUT: - X– anything
 - OUTPUT: boolean - EXAMPLES: - sage: from sage.modules.filtered_vector_space import is_FilteredVectorSpace sage: V = FilteredVectorSpace(2, 1) sage: is_FilteredVectorSpace(V) doctest:warning...: DeprecationWarning: the function is_FilteredVectorSpace is deprecated; use 'isinstance(..., FilteredVectorSpace_class)' instead See https://github.com/sagemath/sage/issues/37924 for details. True sage: is_FilteredVectorSpace('ceci n'est pas une pipe') False - >>> from sage.all import * >>> from sage.modules.filtered_vector_space import is_FilteredVectorSpace >>> V = FilteredVectorSpace(Integer(2), Integer(1)) >>> is_FilteredVectorSpace(V) doctest:warning...: DeprecationWarning: the function is_FilteredVectorSpace is deprecated; use 'isinstance(..., FilteredVectorSpace_class)' instead See https://github.com/sagemath/sage/issues/37924 for details. True >>> is_FilteredVectorSpace('ceci n'est pas une pipe') False 
- sage.modules.filtered_vector_space.normalize_degree(deg)[source]¶
- Normalize the degree. - deg– something that defines the degree (either integer or infinity)
 - OUTPUT: plus/minus infinity or a Sage integer - EXAMPLES: - sage: from sage.modules.filtered_vector_space import normalize_degree sage: type(normalize_degree(int(1))) <class 'sage.rings.integer.Integer'> sage: normalize_degree(oo) +Infinity - >>> from sage.all import * >>> from sage.modules.filtered_vector_space import normalize_degree >>> type(normalize_degree(int(Integer(1)))) <class 'sage.rings.integer.Integer'> >>> normalize_degree(oo) +Infinity