# 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.

Fig. 7 Two red lines meet four blue lines in a point. Their intersection points are marked by red disks.

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 function `solve_general`.

    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 `solution_plane`.

    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[1]), int(name[2]))
            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

Then the `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 in `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 `input_generators`.

    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[0] for x in pone]
        atwo = [x/ptwo[0] 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 `output_generators` below 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 `examples` of the source code for phcpy.