lines meeting four given lines¶
Consider as given four lines, our problem is to compute all lines which meet the four given lines in a point. In Fig. 7, the four given lines are shown in blue while the lines that meet those four lines are drawn in red.
A line in projective 3-space is represented by two points, stored in the columns of a 4-by-2 matrix. So the space we work in is the complex 4-space. For this problem we have a formal root count, named after Pieri.
from phcpy.schubert import pieri_root_count rc = pieri_root_count(2, 2, 0, verbose=False)
In 4-space, the dimension of the input planes equals two
and also the dimension of the output planes is two.
The value returned in
rc is two for this problem.
a general configuration¶
In a general configuration, random number generators are applied
to determine the points which span the input lines.
The solving of a general configuration is encapsulated in the
def solve_general(mdim, pdim, qdeg): """ Solves a general instance of Pieri problem, computing the p-plane producing curves of degree qdeg which meet a number of general m-planes at general interpolation points, where p = pdim and m = mdim on input. For the problem of computing the two lines which meet four general lines, mdim = 2, pdim = 2, and qdeg = 0. Returns a tuple with four lists. The first two lists contain matrices with the input planes and the solution planes respectively. The third list is the list of polynomials solved and the last list is the solution list. """ from numpy import array from phcpy.schubert import random_complex_matrix from phcpy.schubert import run_pieri_homotopies dim = mdim*pdim + qdeg*(mdim+pdim) ranplanes = [random_complex_matrix(mdim+pdim, mdim) \ for _ in range(0, dim)] (pols, sols) = run_pieri_homotopies(mdim, pdim, qdeg, ranplanes, \ verbose=False) inplanes = [array(plane) for plane in ranplanes] outplanes = [solution_plane(mdim+pdim, pdim, sol) for sol in sols] return (inplanes, outplanes, pols, sols)
The solutions returned by
run_pieri_homotopies are converted into
numpy matrices, as defined by the function
def solution_plane(rows, cols, sol): """ Returns a sympy array with as many rows as the value of rows and with as many columns as the value of columns, using the string represention of a solution in sol. """ from numpy import zeros from phcpy.solutions import coordinates result = zeros((rows, cols), dtype=complex) for k in range(cols): result[k][k] = 1 (vars, vals) = coordinates(sol) for (name, value) in zip(vars, vals): i, j = (int(name), int(name)) result[i-1][j-1] = value return result
For the verification of the intersection conditions, the matrices of the input planes are concatenated to the solution planes and the determinant of the concatenated matrix is computed.
def verify_determinants(inps, sols, verbose=True): """ Verifies the intersection conditions with determinants, concatenating the planes in inps with those in the sols. Both inps and sols are lists of numpy arrays. Returns the sum of the absolute values of all determinants. If verbose, then for all solutions in sols, the computed determinants are printed to screen. """ from numpy import matrix from numpy.linalg import det checksum = 0 for sol in sols: if verbose: print('checking solution\n', sol) for plane in inps: cat = concatenate([plane, sol], axis=-1) mat = matrix(cat) dcm = det(mat) if verbose: print('the determinant :', dcm) checksum = checksum + abs(dcm) return checksum
main() function contains the following code.
(inp, otp, pols, sols) = solve_general(mdim, pdim, deg) print('The input planes :') for plane in inp: print(plane) print('The solution planes :') for plane in otp: print(plane) check = verify_determinants(inp, otp) print('Sum of absolute values of determinants :', check)
The polynomial system in
pols with corresponding solutions
sols can be used as start system to solve specific problems,
as will be done in the next section.
a real configuration¶
The solution of a real instance takes on input the system and corresponding solutions of a general instance.
def solve_real(mdim, pdim, start, sols): """ Solves a real instance of Pieri problem, for input planes of dimension mdim osculating a rational normal curve. On return are the planes of dimension pdim. """ from phcpy.schubert import real_osculating_planes from phcpy.schubert import make_pieri_system from phcpy.trackers import track oscplanes = real_osculating_planes(mdim, pdim, 0) target = make_pieri_system(mdim, pdim, 0, oscplanes, False) rtsols = track(target, start, sols) inplanes = [array(plane) for plane in oscplanes] outplanes = [solution_plane(mdim+pdim, pdim, sol) for sol in rtsols] return (inplanes, outplanes, target, rtsols)
The code for the
main() is similar as when calling
solve_general(), as shown above at the end of the previous section.
The points which span the planes are in projective 3-space,
represented by four coordinates.
In projective space, the coordinates belong to equivalence classes
and all nonzero multiples of the four coordinates represented the
same point. To map the points in affine space,
all coordinates are divided by the first coordinate.
After this division, the first coordinate equals one and is omitted.
This mapping is done by the function
def input_generators(plane): """ Given in plane is a numpy matrix, with in its columns the coordinates of the points which span a line, in 4-space. The first coordinate must not be zero. Returns the affine representation of the line, after dividing each generator by its first coordinate. """ pone = list(plane[:,0]) ptwo = list(plane[:,1]) aone = [x/pone for x in pone] atwo = [x/ptwo for x in ptwo] return (aone[1:], atwo[1:])
The solutions of the Pieri homotopies are represented in a so-called
localization pattern, where the second point has its first coordinate
equal to zero. To map to affine 3-space, the second point is the sum
of the two generators. The function
computes this mapping.
def output_generators(plane): """ Given in plane is a numpy matrix, with in its columns the coordinates of the points which span a line, in 4-space. The solution planes follow the localization pattern 1, *, *, 0 for the first point and 0, 1, *, * for the second point, which means that the second point in standard projective coordinates lies at infinity. For the second generator, the sum of the points is taken. The imaginary part of each coordinate is omitted. """ pone = list(plane[:,0]) ptwo = list(plane[:,1]) aone = [x.real for x in pone] atwo = [x.real + y.real for (x, y) in zip(pone, ptwo)] return (aone[1:], atwo[1:])
The complete script is available in the directory
of the source code for phcpy.