Linear Systems

Let \(f_1,\dots,f_r\) be homogeneous polynomials of some common degree \(d\) on some projective space \({\bf P}\) defined over a field. The set of hypersurfaces

\[a_1f_1 + \dots + a_rf_r = 0\]

where the \(a_i\)s are elements of the base field of \({\bf P}\) is an example of a linear system. This can be thought of as being the vector space of elements \((a_1,\dots,a_r)\) or even the projectivisation of that space (since multiplying the equation above by a constant does not change the hypersurface it defines and the equation \(0=0\) does not define a hypersurface at all). The same is true if \(f_1,\dots,f_r\) are a finite collection of polynomials defined on some affine space.

All linear systems in Magma arise in a similar way to the above example. It does not matter whether the linear system is considered to be the collection of hypersurfaces or the collection of homogeneous polynomials or the vector space of coefficients; Magma allows each of these interpretations and the distinction is blurred in the text below. One should note that linear systems in Magma are being used in a very elementary way: compare with the discussion on plane conics and cubics in the first two chapters of Reid’s Student Text [Reid, 1988].

Immediate applications of linear systems arise because of their close relationship to maps (consider the map to an \(r-1\)-dimensional projective space defined by the polynomials \(f_1,\dots,f_r\)) and their application to the extrapolation a scheme of some particular degree from a set of points lying on it or some subscheme of it.

More ambitious interpretations, as the zero-th coherent cohomology group of an invertible sheaf for instance, cannot be realised explicitly in Magma except inasmuch as the user can understand input and output easily in these terms. There is no analysis of linear systems on general schemes and so, in particular, no analysis of exact sequences of cohomology groups.

We give a brief description of the way in which linear systems work in Magma, an approach which echoes the more general definition. The complete linear system on \({\bf P}\) of degree \(d\) is the collection of all homogeneous polynomials of degree \(d\) on \({\bf P}\), or equivalently, the degree \(d\) hypersurfaces they define. Magma does not consider this to be a unique object: each time such a system is created, a completely new object will be created distinct from any previous creation. Its major attributes include a particular basis of degree \(d\) polynomials, which is always the standard monomial basis, and a vector space whose vectors correspond to the coefficients of a polynomial with respect to this basis. The vector space is called the coefficient space of the linear system. There are comparison maps: one to produce the vector of coefficients of polynomials with respect to the given basis and one to create a polynomial from a vector of coefficients. Most questions involving the analysis of linear systems are translated into the linear algebra setting, solved there and then translated back.

A general linear system corresponds to some vector subspace of the coefficient space of a complete linear system. The correspondence between vectors of coefficients and polynomials are computed at the level of the complete systems so that any two subsystems interpret coefficient vectors with respect to the same basis of polynomials.

Creation of Linear Systems

In practice, linear systems are not often created explicitly by hand. Typically, the complete linear system of all hypersurfaces of a given degree is created and then restricted by the imposition of geometrical conditions. For example, such a condition could require that all hypersurfaces pass through a particular point.

The creation methods below are split into three classes: (i) explicit initial creation methods; (ii) methods of imposing geometrical conditions; and (iii) creation of subsystems by nominating specific technical data calculated in advance by the user.

Explicit Creation

Initially, we present three methods by which a linear system can be created. The complete linear system of degree \(d\) whose sections are all monomials of that degree has a special creation function. Alternatively, a sequence of monomials of some common degree can be specified to generate the sections of a linear system. The third constructor is useful for calculating the images of maps and has been seen before: given a scheme \(S\) and a map \(f\) it calculates the linear system of hypersurfaces which contain \(f(S)\).

LinearSystem(P, d): Sch, RngIntElt -> LinearSys

The complete linear system on the affine or projective space \(P\) of degree \(d\). In the projective case, this is the space of all homogeneous polynomials of degree \(d\) on \(P\), whereas in the affine case it includes all polynomials of degree no bigger than \(d\). The integer \(d\) must be strictly positive.

LinearSystem(P, d): Sch, [RngIntElt] -> LinearSys

The complete linear system on the affine or projective space \(P\) of multi-degree \(d\). The length of \(d\) must be the number of gradings of \(P\), i.e. one degree for each grading. In the projective case, this is the space of all homogeneous polynomials of degree \(d\) on \(P\), whereas in the affine case it includes all polynomials of degree no bigger than \(d\). The integers in \(d\) must be strictly positive.

LinearSystem(P, F): Sch, SeqEnum[RngMPolElt] -> LinearSys

If \(P\) is a projective space and \(F\) is a sequence of homogeneous polynomials all of the same degree defined on \(P\), or if \(P\) is an affine space and \(F\) is a sequence of polynomials defined on \(P\) this returns the linear system generated by these polynomials. If the polynomials in \(F\) are linearly independent they will be used as a basis of the sections of the resulting linear system, otherwise a new basis will be computed.

MonomialsOfWeightedDegree(X, D): Sch, [RngIntElt] -> SetIndx

Return the monomials in the coordinate ring of the ambient of \(X\) having degree \(D[i]\) with respect to the \(i\)th grading of the ambient of \(X\).

Example: Linsys Construction (ex-7aa596)

In this example we construct two linear systems on a projective plane. Although they are created in slightly different ways, Magma recognises that they are the same. It does the computation as a subspace equality test in the corresponding ‘coefficient spaces’.

> P<x,y,z> := ProjectiveSpace(Rationals(),2);
> L := LinearSystem(P,1);
> K := LinearSystem(P,[x+y,x-y,z+2*z+3*y]);
> L eq K;
true

Run in calculatorCopy input

ImageSystem(f, S, d): MapSch, Sch, RngIntElt -> LinearSys

The linear system on the codomain of the map of schemes \(f\) consisting of degree \(d\) hypersurfaces which contain \(f(S)\). An error is reported if the scheme \(S\) does not lie in the domain of \(f\).

Example: Image Finder (ex-2e0ca6)

This example demonstrates how one can use an intrinsic based on linear systems, ImageSystem, to find the equations of images of maps. The point is that sometimes the usual Gröbner basis can be very difficult, so if one is interested in the equations of low degree then the linear algebra computation might be more convenient.

The curve \(C\) has one singularity analytically equivalent to the cusp \(u^2 = v^5\) so is well-known to have genus \(4\).

> Q := RationalField();
> P<x,y,z> := ProjectiveSpace(Q,2);
> C := Curve(P,x^5 + y^4*z + y^2*z^3);

Run in calculatorCopy input

The canonical embedding of \(C\) is therefore given by four conics having a common tangent with the curve at its singularity.

> P3<a,b,c,d> := ProjectiveSpace(Q,3);
> phi := map< P -> P3 | [x^2,x*y,y^2,y*z] >;

Run in calculatorCopy input

Unless \(C\) is hyperelliptic, its canonical image will be the complete intersection of a conic and a cubic in \({\bf P}^3\).

> IC2 := Image(phi,C,2);
> IC3 := Image(phi,C,3);
> X := Intersection(IC2,IC3);
> Dimension(X);
1
> IsNonsingular(X);
true
> MinimalBasis(X);
[ a*c - b^2, a^2*b + c^2*d + d^3 ]

Run in calculatorCopy input

In this case the Gröbner basis of \(X\) has six elements so it is not so helpful for human comprehension. (Compare this with [Hartshorne, IV, Example 5.2.2].)

Geometric Restrictions: Points

Consider the following example. Suppose that \(L\) is a linear system on the projective plane whose sections are generated by the monomials \(x^2\), \(xy\), \(yz\) and let \(p=(1:0:0)\). The phrase ‘one imposes the condition on sections of \(L\) that they pass through the point \(p\)’ refers to the construction of the subsystem of \(L\), all of whose hypersurfaces pass through \(p\). Explicitly, this involves solving the linear equation in \(a\),\(b\),\(c\) obtained by evaluating the equation

\[ax^2 + bxy + cyz = 0\]

at the point \(p\). In this example, the equation is \(a=0\) and the required subsystem is the one whose sections are generated by \(xy\) and \(yz\).

The functions described in this section determine a linear subsystem of a given linear system by imposing conditions on the sections of that system.

LinearSystem(L, p): LinearSys, Point -> LinearSys

Given a point \(p\), construct the subsystem of the linear system \(L\) comprising of those hypersurfaces of \(L\) which include the point \(p\).

LinearSystem(L, P): LinearSys, SeqEnum[Point) -> LinearSys

Given a sequence \(P\) of points, create the subsystem of the linear system \(L\) comprising of those hypersurfaces of \(L\) which include the points \(q\) of \(P\).

Example: subsystems (ex-934794)

In this example we make some subsystems of linear systems by imposing conditions at points. In the first example, we construct the family of all curves having singularities with prescribed multiplicities at prescribed points. See Chapter Algebraic Curves for functions which apply to curves.

> P<x,y,z> := ProjectiveSpace(Rationals(),2);
> L := LinearSystem(P,6);
> p1 := P ! [1,0,0];
> p2 := P ! [0,1,0];
> p3 := P ! [0,0,1];
> p4 := P ! [1,1,1];
> L1 := LinearSystem(L,p1,3);
> L2 := LinearSystem(L1,p2,3);
> L3 := LinearSystem(L2,p3,3);
> L4 := LinearSystem(L3,p4,2);
> #Sections(L4);
7
> C := Curve(P,&+[ Random([1,2,3])*s : s in Sections(L4) ]);
> IsIrreducible(C);
true
> Genus(C);
0

Run in calculatorCopy input

In other words, \(L4\) parametrises a six-dimensional family of rational plane curves. (At least, the general element of \(L4\) is the equation of a rational plane curve — there are certainly degenerate sections which factorise so do not define an irreducible curve at all.) It would be nice to be able to parametrise one of these curves. The problem is that we need to choose a general one in order that it be irreducible, but on the other hand we have very little chance of finding a rational point of a general curve. However, since this family is nice and big, we can simply impose another point condition on it yielding a rational point on each of the restricted elements.

> p5 := P ! [2,1,1];
> L5 := LinearSystem(L4,P![2,1,1]);
> C := Curve(P,&+[ Random([1,2,3])*s : s in Sections(L5) ]);
> IsIrreducible(C);
true
> Genus(C);
0
> L<u,v> := ProjectiveSpace(Rationals(),1);
> phi := Parametrization(C, Place(C!p5), Curve(L));
> Ideal(Image(phi)) eq Ideal(C);
true

Run in calculatorCopy input

To illustrate another feature of imposing point conditions on linear systems, we use a point that is not in the base field of the ambient space. Linear systems on an ambient spaces are defined over its base field, so nonrational points impose conditions as the union of their Galois conjugates.

> A<x,y> := AffineSpace(FiniteField(2), 2);
> L := LinearSystem(A, 2);
> L;
Linear system on Affine Space of dimension 2 Variables : x, y
with 6 sections: 1 x y x^2 x*y y^2
> k1<w> := ext< BaseRing(A) | 2> ;
> p := A(k1)![1,w];
> p;
(1, w)
> LinearSystem(L, p);
Linear system on Affine Space of dimension 2
Variables : x, y
with 4 sections:

x^2 + 1
x*y + y
x + 1
y^2 + y + 1

> k2<v> := ext< BaseRing(A) | 3> ;
> q := A(k2) ! [1,v];
> LinearSystem(L, q);
Linear system on Affine Space of dimension 2
Variables : x, y
with 3 sections:

x^2 + 1
x*y + y
x + 1

Run in calculatorCopy input

Note the minimal polynomial of the \(y\) coordinate of the point \((1,w)\) is of degree \(2\) so is visible in the restricted linear system. On the other hand, \(v\) is of order \(3\) so it imposes more conditions on the linear system.

LinearSystem(L, p, m): LinearSys, Point, RngIntElt -> LinearSys

LinearSystem(L, P, M): LinearSys, SeqEnum[Point), SeqEnum(RngIntElt) -> LinearSys

The arguments \(m\) and \(M\) give the multiplicities of the point \(p\) or the sequence of points \(P\), repectively. If there is a sequence of points \(P\) then the sequence \(M\) contains the multiplicities of the points \(P\) where the \(i\)-th element of \(M\) is the multiplicity of the \(i\)-th point in \(P\). The subsystem of \(L\) constructed in this case will consist of the hypersurfaces of \(L\) which pass through each point \(q\) of \(P\) with multiplicity at least \(n\) of \(M\), where \(n\) is the corresponding element of \(M\).

Example: Subsystems Mult (ex-9b3b7a)

In this example we construct a plane curve of degree \(20\) with \(18\) singular points having multiplicities \(2,2,2,2,2,2,3,3,3,3,3,5,5,5,7,7,8,9\).

> K := Rationals();
> A := AffineSpace(K, 2);
> M := [2,2,2,2,2,2,3,3,3,3,3,5,5,5,7,7,8,9];
> P := [A![Random(1,40), Random(1, 40)] : i in [1..#M]];
> time L := LinearSystem(LinearSystem(A, 20), P, M);
Time: 0.580
> #Sections(L);
1
> C := Curve(A, &+Sections(L));
> [Multiplicity(C, x): x in P];
[ 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 5, 5, 5, 7, 7, 8, 9 ]

Run in calculatorCopy input

Example: Subsystems Speed (ex-114b8f)

The construction of a subsystem defined by points is very fast. We illustrate this with an example where the subsystem contains thousands of specified points.

> K := FiniteField(397);
> P := ProjectiveSpace(K, 3);
> pts := [P!([Random(K) : i in [1..3]] cat [1]):j in [1..3275]];
> L := LinearSystem(P, 25);
> #Sections(L);
3276
> #pts;
3275
> time J := LinearSystem(L, pts);
Time: 11.430
> #Sections(J);
1

Run in calculatorCopy input

Geometric Restrictions: Schemes

This restriction constructs the subsystem of a linear system \(L\) which consists of the elements of \(L\) which contain the scheme \(X\).

LinearSystem(L, X : parameters): LinearSys, Sch -> LinearSys

The sections of this linear system are equal to the polynomials of the defining ideal of \(X\) whose homogeneous degree is the same as that of \(L\).

If \(X\) is an affine scheme, then a Groebner basis for the ideal of \(X\) must be computed. If the parameter Order is set to “order”, then the Groebner basis is computed using this order. The default is “grevlex”. If \(X\) is projective, then the ideal of \(X\) must be saturated first, which takes time. This saturation can be avoided by setting the parameter SaturateIdeal := false (but in this case the result may not be correct).

Example: Subsystems Scheme Quadric (ex-96c94f)

We define a curve in affine 3-space and show that there is exactly one quadric containing it.

> K := Rationals();
> A<x,y,z> := AffineSpace(K, 3);
> X := Curve(A, [x*y-y*z^2, x*y*z+y-1]);
> L := LinearSystem(A, 2);
> J := LinearSystem(L, X);
> J;

Linear system on Affine Space of dimension 3 over Rational Field
Variables: x, y, z
with 1 section:

x - z^2

Run in calculatorCopy input

Example: Subsystems Scheme Noncomplete (ex-aeb538)

In this example the scheme \(X\) is a curve in \(4\)-dimensional projective space and the initial linear system \(L\) is not complete.

> K := Rationals();
> R := PolynomialRing(K, 5, "grevlex");
> P := ProjectiveSpace(R);
> d := 5;
> s := [ &+[R.i^(d+j) : i in [1..5]]:j in [1..3] ];
> X := Scheme(P, s : Saturated := true);
> s := Sections(LinearSystem(P, d+4));
> s := [ &+[Random(1,10)*q : q in s] : i in [1 .. #s-30]];
> time L := LinearSystem(P, s);
> time J := LinearSystem(L, X);
Time: 4.220
> J;

Linear system with 25 sections

> // If L is complete, the computation is faster.

> L := LinearSystem(P, d+4);
> time J := LinearSystem(L,X);
Time: 0.000
> J;

Linear system with 55 sections

Run in calculatorCopy input

Example: Subsystems Scheme Variety (ex-4615cc)

In this example, the scheme \(X\) is a variety in a product of weighted projective spaces.

> K := FiniteField(103);
> P1 := ProjectiveSpace(K, [1, 2, 3, 5]);
> P2 := ProjectiveSpace(K, [2, 3, 5, 7]);
> P := DirectProduct(P1, P2);
> H := LinearSystem(P, [33, 35]);
> X := Scheme(P, [Random(H) : i in [1..3]] : Saturated:=true);
> L := LinearSystem(P, [35, 35]);
> time J := LinearSystem(L, X);
Time: 15.860
> #Sections(J);
6

Run in calculatorCopy input

Example: Subsystems Scheme Affvproj (ex-8af960)

In this example, the time taken by a computation in affine space is compared with the time taken in the projective space.

> K := Rationals();
> R<x,y,z,w,t> := PolynomialRing(K, 5, "grevlex");
> A := AffineSpace(R);
> d := 9;
> s := [&+[R.i^(d+j) : i in [1..5]]:j in [1..3]];
> X := Scheme(A,[s[1], s[2]]) join Scheme(A, [s[2], s[3]]);
> L := LinearSystem(A, d+2);
> time J := LinearSystem(L, X);
Time: 10.550
> #Sections(J);
1

Run in calculatorCopy input

We now take the projective closure of the schene \(X\) before computing the linear system.

> K := Rationals();
> R<x,y,z,w,t> := PolynomialRing(K, 5, "grevlex");
> A := AffineSpace(R);
> d := 9;
> s := [&+[R.i^(d+j) : i in [1..5]] : j in [1..3]];
> X := Scheme(A, [s[1], s[2]]) join Scheme(A, [s[2], s[3]]);
> X := ProjectiveClosure(X);
> A := Ambient(X);
> L := LinearSystem(A, d+2);
> time J := LinearSystem(L, X);
Time: 0.010
> #Sections(J);
1

Run in calculatorCopy input

The projective computation is much faster as no Groebner basis computation is needed.

Geometric Restrictions: Affine Plane Curves with Non-ordinary Singularities

Let \(S_1\rightarrow S_0\) be the blow-up of a surface \(S_0\) at a point \(p_0\). Then \(S_1\) contains an exceptional curve \(E_1\) (isomorphic to the projective line) that is contracted to \(p_0\). Let \(p_1\) be a point in \(E_1\). We can blow-up again at \(p_1\) and choose a point \(p_2\) in the new exceptional curve \(E_2\). Iterating this we get a sequence of infinitely near points \((p_0,\ldots,p_n)\).

Assuming that \(S_0\) is the affine plane, then \(p_0\) is defined by coordinates \([a_0,b_0]\) in the plane, and \(p_i\) is defined by coordinates \([a_i:b_i]\) in the projective line \(E_i\), for \(i>0\).

The coordinates \([a_i:b_i]\) have the geometric interpretation of tangent directions (direction of a line tangent to the branches of a curve singularity). After each blow-up, the new surface \(S_i\) is covered by affine plane patches, so we choose the one that contains the point \(p_i\). At each step we choose coordinates such that the new exceptional curve is always the line “\(y=0\)”. More precisely, the blow-up of a curve “\(F(x,y)=0\)” is given by taking \(F(x*y,y)=0\), except if the tangent direction of the singularity is \([1:0]\), in which case we take \(F(x,x*y)=0\) followed by \((x,y)\rightarrow (y,x)\).

LinearSystem(L, p, m, t): LinearSys, Point, SeqEnum, SeqEnum[SeqEnum]) -> LinearSys

Here \(L\) is a linear system of affine plane curves, \(p\) is a point in the plane, \(m=[m_0,\ldots,m_n]\) is a sequence of non-negative integers and \(t=[t_1,\ldots,t_n]\) is a sequence of vector coordinates (tangent directions). This function computes the subsystem of \(L\) containing the curves that have multiplicity \(m_0,\ldots,m_n\) at the infinitely near points given by \(p_0,t_1,\ldots,t_n\), respectively.

LinearSystem(L, P, M, T): LinearSys, Points, SeqEnum[SeqEnum], SeqEnum[SeqEnum[SeqEnum]]) -> LinearSys

Here \(L\) is a linear system of affine plane curves, \(P\) is a sequence of of points in the plane, \(M\) is a sequence of sequences of non-negative integers and \(T\) is a sequence of sequences of vector coordinates. The sequence \(M\) gives the multiplicities at the infinitely near points given by \(p,p-t_1,\ldots,p-t_n\), respectively where \(p\) runs though the points in \(P\). This function allows the computation of plane curves with singularities of any type.

Example: tacnode (ex-766e2f)

A tacnode is a double point with two branches sharing the same tangent direction. Thus it is a double point which resolves to a double point after one blow-up. We compute a quartic curve with one tacnode. Then we use ResolutionGraph to check the result.

> K := Rationals();
> A<x,y> := AffineSpace(K, 2);
> p := A![0,0];
> m := [2,2];
> t := [[1,1]];
> J := LinearSystem(A, 4);
> L := LinearSystem(J, p, m, t);
> L;
Linear system on Affine Space of dimension 2 over Rational Field
Variables: x, y
with 9 sections:
x^4
x^3*y
x^3 - y^3
x^2*y^2
x^2*y - y^3
x^2 - 2*x*y + y^2
x*y^3
x*y^2 - y^3
y^4

> C := Curve(A, &+Sections(L));
> C;
x^4 + x^3*y + x^3 + x^2*y^2 + x^2*y + x^2 + x*y^3 + x*y^2 - 2*x*y + y^4 - 3*y^3
    + y^2
> ResolutionGraph(C, A![0,0]);

The resolution graph on the Digraph
Vertex  Neighbours

1 ([ -2, 2, 1, 0 ])     2 ;
2 ([ -1, 4, 2, 2 ])     ;

Run in calculatorCopy input

Example: quadrifolium (ex-63a6fd)

Now let us compute the so-called quadrifolium: a curve of degree 6 with a quadruple point that resolves to two different double points after one blow-up. Thus it looks like the union of two tacnodes with different tangent directions. We consider this as two different singularities of type \([4,2]\) at the same point. In order to get a nicer picture, we consider curves symmetric with respect to the coordinate axes. We also ask that the curve contains, with multiplicity 1, three additional points, one of these with tangent directions \([[1,1]]\) (we are fixing the tangent line at the point). When we do not impose a tangent direction, the corresponding sequence of tangent directions is the empty one: \([]\).

> K := Rationals();
> A<x,y> := AffineSpace(K, 2);
> s6 := Sections(LinearSystem(A, 6));
> s := [q : q in s6 | q eq Evaluate(q, [-x,y]) and q eq Evaluate(q, [x,-y])];
> J := LinearSystem(A, s);
> p := [A![0,0], A![0,0], A![1,1], A![2/10,7/10], A![7/10,2/10]];
> m := [[4,2], [4,2], [1,1], [1], [1]];
> t := [[[1,0]], [[0,1]], [[1,-1]], [], []];
> L := LinearSystem(J, p, m, t);
> f := Sections(L)[1];
> C := Curve(A, f);
> ResolutionGraph(C, A![0,0]);

The resolution graph on the Digraph
Vertex  Neighbours

1 ([ -2, 2, 1, 0 ])     2 ;
2 ([ -1, 4, 2, 2 ])     ;

Run in calculatorCopy input

Example: Cusp Sing (ex-faf2b2)

A cusp singularity is a double point which resolves, after one blow-up, to a smooth curve tangent to the exceptional curve. So in order to get a cusp we need to have a double point and then, after one blow-up, ask for multiplicity \([1,1]\) with tangent direction \([1,0]\). The linear system of quintic curves is of dimension 20. A cusp singularity imposes five conditions, so if we ask for four cusps, we expect to find exactly one such curve:

> K := Rationals();
> A<x,y> := AffineSpace(K,2);
> J := LinearSystem(A,5);
> p := [A![1,1],A![-1,1],A![1,-1],A![-1,-1]];
> m := [[2,1,1],[2,1,1],[2,1,1],[2,1,1]];
> t := [[[1,2],[1,0]],[[1,3],[1,0]],[[1,4],[1,0]],[[1,5],[1,0]]];
> L := LinearSystem(J,p,m,t);
> f := Sections(L)[1];
> f;

x^5 - 368/195*x^4*y + 77/195*x^4 + 14/13*x^3*y^2 - 40/13*x^3 - 112/195*x^2*y^3 -
    2/195*x^2*y^2 + 848/195*x^2*y - 152/195*x^2 + 1/13*x*y^4 - 16/13*x*y^2 +
    28/13*x - 32/195*y^5 - 7/195*y^4 + 176/195*y^3 + 16/195*y^2 - 512/195*y +
    68/195

> C := Curve(A,f);
> {ResolutionGraph(C, q) : q in p};

    The resolution graph on the Digraph
    Vertex      Neighbours

    1 ([ -3, 2, 1, 0 ]) 2 ;
    2 ([ -1, 6, 4, 1 ]) 3 ;
    3 ([ -2, 3, 2, 0 ]) ;
}

Run in calculatorCopy input

Example: Two Cubics (ex-89e6c4)

We construct two cubics meeting at one point with multiplicty 8.

> K := Rationals();
> A<x,y> := AffineSpace(K, 2);
> J := LinearSystem(A, 3);
> p := A![0,0];
> m := [1,1,1,1,1,1,1,1];
> t := [[1,1], [1,2], [1,3], [1,4], [1,5], [1,6], [1,7]];
> L := LinearSystem(J, p, m, t);
> #Sections(L);
2
> C1 := Curve(A, Sections(L)[1]);
> C2 := Curve(A, Sections(L)[2]);
> Dimension(SingularSubscheme(C1));
-1
> Dimension(SingularSubscheme(C2));
-1
IntersectionNumber(C1, C2, p);
8

Run in calculatorCopy input

Example: Pencil Curves (ex-0bb25b)

Let \(C\) be a smooth plane conic not containing the origin \(p_0,\) and let \(p_1,\ldots,p_6\) be points in \(C\) such that the lines through \(p0,p1\) and \(p_0,p_2\) are tangent to \(C\). It can be shown the existence of a pencil \(L\) of curves of degree 8 with a quadruple point at \(p_0\) and tacnodes at \(p_i\) with branches tangent to the line through \(p_0,p_i\), for \(i=1,\ldots,6.\) Let \(f_1, f_2\) be the defining polynomials of two such curves. The smooth resolution of the surface with equation \(w^2=f_1f_2\) is a surface of general type with invariants \(p_g=q=1\) and \(K^2=8\). Here we compute the pencil \(L\).

> K := Rationals();
> A<x,y> := AffineSpace(K, 2);
> J := LinearSystem(A, 8);
> m := [[4], [2,2], [2,2], [2,2], [2,2], [2,2], [2,2]];
> p := [A![0,0], A![1,1], A![1,-1], A![5/2,2], A![5/2,-2], A![5,3], A![5,-3]];
> t := [   [],   [[1,1]], [[1,-1]], [[5/2,2]], [[5/2,-2]], [[5,3]], [[5,-3]]];
> L := LinearSystem(J, p, m, t);
> L;

Linear system on Affine Space of dimension 2 over Rational Field
Variables: x, y
with 2 sections:

x^8 - 2*x^7 - 17/2*x^6*y^2 + 18*x^5*y^2 + x^5 + 411/16*x^4*y^4 - 599/96*x^4*y^2 +
    1291/16*x^4 - 5245/96*x^3*y^4 - 15805/96*x^3*y^2 - 12275/384*x^2*y^6 +
    29075/192*x^2*y^4 - 36275/384*x^2*y^2 + 2125/96*x*y^6 + 14125/96*x*y^4 +
    6875/384*y^8 - 23125/192*y^6 + 6875/384*y^4
x^6 - x^5*y^2 - x^5 + 1/4*x^4*y^4 - 553/144*x^4*y^2 + 1/4*x^4 + 625/144*x^3*y^4 +
    625/144*x^3*y^2 - 625/576*x^2*y^6 + 625/288*x^2*y^4 - 625/576*x^2*y^2 -
    625/144*x*y^6 - 625/144*x*y^4 + 625/576*y^8 + 625/288*y^6 + 625/576*y^4

> C:=Curve(A, &+Sections(L));
> {ResolutionGraph(C, q) : q in p};
{
    The resolution graph on the Digraph
    Vertex      Neighbours

    1 ([ -1, 4, 1, 4 ]) ;

    ,
    The resolution graph on the Digraph
    Vertex      Neighbours

    1 ([ -2, 2, 1, 0 ]) 2 ;
    2 ([ -1, 4, 2, 2 ]) ;

}

Run in calculatorCopy input

Geometric Restrictions: Trace on a Scheme

LinearSystemTrace(L, X): LinearSys, Sch -> LinearSys

The trace of the linear system \(L\) on the scheme \(X\) which lies in the ambient space of \(L\). This merely simulates the restriction of the linear system \(L\) on \(X\) by taking the sections of \(L\) modulo the equations of \(X\). The result is still a linear system on the common ambient space.

Example: trace (ex-932066)

In this example, we restrict the linear system of cubics in space to a scheme, which is in fact a twisted cubic curve. (The intrinsic Sections is defined in Section Geometrical Properties.)

> P<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> L := LinearSystem(P,3);
> X := Scheme(P,[x*z-y^2,x*t-y*z,y*t-z^2]);
> #Sections(L);
20
> L1 := LinearSystemTrace(L,X);
> #Sections(L1);
10

Run in calculatorCopy input

Taking the sections of \(L\) modulo the equations of \(X\) reduces the dimension of the space of sections by \(10\). Of course, there is a choice being made about which particular trace sections to use — in the end, the computation is that of taking a complement in a vector space of some vector subspace.

Since we recognise this scheme \(X\) as the image of a projective line, we can confirm that the result is correct. We make a map from the projective line to the space \(P\) which has image \(X\). Then we check that the pullback \(L\) and \(L1\) are equal on the projective line. In fact, since the linear system embedding the line is the complete system of degree \(3\), and \(L\) comprises degree \(3\) hypersurfaces on \(P\), both pullbacks should give the complete linear system on the line of degree \(3\times 3=9\). (The intrinsic Pullback is defined in Section Linear Systems and Maps.)

> P1<u,v> := ProjectiveSpace(BaseRing(P),1);
> phi := map< P1 -> P | [u^3,u^2*v,u*v^2,v^3] >;
> Ideal(phi(P1)) eq Ideal(X);
true
> Pullback(phi,L) eq Pullback(phi,L1);
true
> Pullback(phi,L1);
Linear system on Projective Space of dimension 1
Variables : u, v
with 10 sections:
u^9 u^8*v u^7*v^2 u^6*v^3 u^5*v^4 u^4*v^5 u^3*v^6 u^2*v^7 u*v^8 v^9

Run in calculatorCopy input

Explicit Restrictions

LinearSystem(L, F): LinearSys, SeqEnum -> LinearSys

The subsystem of the linear system \(L\) generated by the polynomials in the sequence \(F\). An error results if the polynomials of \(F\) are not already sections of \(L\). As before, the polynomials in \(F\) are used as a basis of the sections of the resulting linear system provided they are linearly independent, otherwise a new basis is computed.

LinearSystem(L, V): LinearSys, ModTupFld -> LinearSys

The subsystem of the linear system \(L\) determined by the subspace \(V\) of the complete coefficient space of \(L\). It is an error to call this if \(V\) is not a subspace of the coefficient space of \(L\).

Basic Algebra of Linear Systems

This section presents functions for the following tasks: (i) assessing properties of the data type; (ii) geometrical properties of linear systems; (iii) linear algebra operations.

Tests for Linear Systems

Ambient(L): LinearSys -> Prj

AmbientSpace(L): LinearSys -> Prj

The projective space on which the linear system \(L\) is defined.

L eq K: LinearSys, LinearSys -> BoolElt

Returns true if and only if the linear systems \(L\) and \(K\) are equal if considered as linear subsystems of some complete linear system. An error results if \(L\) and \(K\) lie in different complete linear systems.

IsComplete(L): LinearSys -> BoolElt

Returns true if and only if the linear system \(L\) is the complete linear system of polynomials of some degree.

IsBasePointFree(L): LinearSys -> BoolElt

IsFree(L): LinearSys -> BoolElt

Returns true if and only if the linear system \(L\) has no base points.

Geometrical Properties

Sections(L): LinearSys -> SeqEnum

A sequence whose elements form basis of the sections of the linear system \(L\). By definition, this is a maximal set of linearly independent polynomials which are elements of \(L\).

Random(LS): LinearSys -> RngMPolElt

If the base field of \(LS\) admits random elements then this returns a random element of the space of sections in the linear system \(LS\). If the base field is the rational field, then a section having small random rational coefficients is defined. Otherwise, if there is no random element generator for the base field, the zero section is returned.

Degree(L): LinearSys -> RngIntElt

The degree of the sections of the linear system \(L\).

Dimension(L): LinearSys -> RngIntElt

The projective dimension of the linear system \(L\). This is the maximal number of linearly independent sections of \(L\) minus \(1\).

BaseScheme(L): LinearSys -> SchProj

The base scheme of the linear system \(L\). This is simply the scheme defined by the sections of \(L\). This function does not perform any tests on this scheme; it might be empty for example.

BaseComponent(L): LinearSys -> SchProj

The hypersurface common to all the elements of the linear system \(L\).

Reduction(L): LinearSys -> LinearSys

The linear system \(L\) with its codimension \(1\) base locus removed. In other words, the linear system defined by the sections of \(L\) after common factors are removed.

Example: Ls Reduction (ex-ad2e4b)

If one tries to impose too many point conditions on a linear system, the general elements will no longer be irreducible. From a quick genus calculation one might think that it was possible to impose singularities on multiplicities \(2\), \(3\), \(4\) on projective curves of degree \(6\) to reveal rational curves — indeed \(g=10-1-3-6=0\) if the resulting curves are irreducible.

> P<x,y,z> := ProjectiveSpace(Rationals(),2);
> L := LinearSystem(P,6);
> p1 := P ! [1,0,0];
> p2 := P ! [0,1,0];
> p3 := P ! [0,0,1];
> L1 := LinearSystem(L,p1,4);
> L2 := LinearSystem(L1,p2,3);
> L3 := LinearSystem(L2,p3,2);
> Sections(L3);
[ x^2*y^3*z, x^2*y^2*z^2, x^2*y*z^3, x^2*z^4, x*y^3*z^2,
    x*y^2*z^3, x*y*z^4, y^3*z^3, y^2*z^4 ]
> BaseComponent(L3);
Scheme over Rational Field defined by z

Run in calculatorCopy input

But notice that every section is divisible by \(z\). So the curve \(z=0\) is in the base locus of this linear system, that is, it is contained in every curve in the linear system \(L3\). The intrinsic BaseComponent identifies this component. The intrinsic Reduction creates a new linear system by removing this codimension \(1\) base locus, as is seen below. First, however, we look at the complete set of prime components of the base scheme and see that, while there is only one codimension \(1\) component which we already know, there is another component in higher codimension. When we reduce to remove the base component, this other piece of the base scheme remains, and other codimension \(2\) components also appear.

> MinimalPrimeComponents(BaseScheme(L3));
[
    Scheme over Rational Field defined by
    z,
    Scheme over Rational Field defined by
    x
    y
]
> L4 := Reduction(L3);
> Sections(L4);
[ x^2*y^3, x^2*y^2*z, x^2*y*z^2, x^2*z^3, x*y^3*z, x*y^2*z^2,
    x*y*z^3, y^3*z^2, y^2*z^3 ]
> MinimalPrimeComponents(BaseScheme(L4));
[
    Scheme over Rational Field defined by
    x
    y,
    Scheme over Rational Field defined by
    x
    z,
    Scheme over Rational Field defined by
    y
    z
]
> [ RationalPoints(Z) : Z in $1 ];
[
    {@ (0 : 0 : 1) @},
    {@ (0 : 1 : 0) @},
    {@ (1 : 0 : 0) @}
]

Run in calculatorCopy input

The linear system \(L4\) has sections which are visibly those of \(L3\) but with a single factor of \(z\) removed. It still has base locus but now that base locus comprises only points. Not surprisingly, it is exactly the three points which we imposed on curves in the first place.

BasePoints(L): LinearSys -> SeqEnum

A sequence containing the basepoints of the linear system \(L\) if the base locus of \(L\) is finite dimensional.

Multiplicity(L, p): LinearSys, Pt -> RngIntElt

The generic multiplicity of hypersurfaces of the linear system \(L\) at the point \(p\).

Linear Algebra

CoefficientSpace(L): LinearSys -> ModTupFld

The vector space corresponding to the linear system \(L\) whose vectors comprise the coefficients of the polynomial sections of \(L\).

CoefficientMap(L): LinearSys -> ModTupFldElt

The map from the polynomial ring that is the parent of the sections of the linear system \(L\) to the coefficient space of \(L\). When evaluated at a polynomial \(f\), this map will return vector of coefficients of \(f\) as a section of \(L\).

PolynomialMap(L): LinearSys -> RngMPolElt

The map from the coefficient space of the linear system \(L\) to the polynomial ring that is the parent of the sections of \(L\). When evaluated at a vector \(v\), this map will return the polynomial section of \(L\) whose coefficients with respect to the basis of \(L\) are \(v\).

Complement(L, K): LinearSys, LinearSys -> LinearSys

A maximal subsystem of the linear system \(L\) which does not contain any of the hypersurfaces of the linear system \(K\).

Complement(L, X): LinearSys, Sch -> LinearSys

A maximal subsystem of the linear system \(L\) comprising hypersurfaces not containing \(X\).

Example: Creation By Subspace (ex-0ff141)

In this example we show to define linear systems by referring to subspaces of a coefficient space. The explicit translation intrinsics between the linear algebra language and the linear system language let one ‘see’ what is happening in the background. We start by defining a linear system whose chosen sections are clearly not linearly independent.

> A<x,y> := AffineSpace(FiniteField(2),2);
> L := LinearSystem(A,[x^2-y^2,x^2,y^2]);
> VL := CoefficientSpace(L);
> VL;
KModule VL of dimension 2 over GF(2)
> W := sub< VL | VL.1 >;
> LinearSystem(L,W);
Linear system on Affine Space of dimension 2
Variables : x, y
with 1 section:
x^2
> phi := PolynomialMap(L);
> [ phi(v) : v in Basis(VL) ];
[
    x^2,
    y^2
]

Run in calculatorCopy input

Thus we see that Magma has chosen the obvious polynomial basis for the sections of \(L\) and disregarded the section \(x^2- y^2\).

L meet K: LinearSys, LinearSys -> LinearSys

Intersection(L, K): LinearSys, LinearSys -> LinearSys

The linear system whose coefficient space is the intersection of the coefficient spaces of the linear systems \(L\) and \(K\). An error is reported unless \(L\) and \(K\) lie in the same complete linear system.

X in L: Sch, LinearSys -> BoolElt

Returns true if and only if the scheme \(X\) occurs among the hypersurfaces comprising the linear system \(L\).

f in L: RngMPolElt, LinearSys -> BoolElt

Returns true if and only if the polynomial \(f\) is a section of the linear system \(L\). That is, true if and only if \(f\) is in the linear span of the basis of sections defining \(L\).

K subset L: LinearSys, LinearSys -> BoolElt

IsSubsystem(L, K): LinearSys, LinearSys -> BoolElt

Returns true if and only if the coefficient space of the linear system \(K\) is contained in that of the linear system \(L\). An error is reported if \(L\) and \(K\) do not lie in a common linear system.

Linear Systems and Maps

The sequence of sections of a linear system may be used to construct a map from the projective space on which the sections are defined to another having the appropriate dimension. This is done directly using the map constructor as in Section Maps between Schemes. For example, if \(L\) is a linear system on some projective space \(P\) then the corresponding map can be created as follows.

> map< P -> Q | S >
>              where Q is ProjectiveSpace(BaseRing(P),#S-1)
>              where S is Sections(L);

There is not a proper inverse to this operation: there is no reason why a map should be determined by linearly independent polynomials. However, the system determined by the polynomials defining a map is still important. It is sometimes called the homoloidal system of the map.

Pullback(f, L): MapSch, LinearSys -> LinearSys

The linear system \(f^*L\) on the domain of the map of schemes \(f\) where \(L\) is a linear system on the codomain of \(f\). This requires care when \(f\) is not a regular map: it really produces the system of homaloids, that is, the substitution of the map equations into the linear system’s sections.