\(\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_fieldA descending filtration of a vector space.
INPUT:
base_ring– a field; the base field of the ambient vector spacedim– integer; the dimension of the ambient vector spacegenerators– 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. Seeconstruct_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 ofself
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 ofself
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 ofself
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 dimensionmax_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 integerdegreestipulates that all filtration steps of degree higher or equal thandegree(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). Theray_indicesare a list or iterable of ray indices, which span a subspace of the vector space. The integerdegreestipulates that all filtration steps of degree higher or equal thandegree(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