squareUp -- square up a polynomial system

Synopsis

• Usage:

  G = squareUp F

  G = squareUp(F,M)

  G = squareUp(F,n)

  G = squareUp(x0,F)

  G = squareUp(p0,x0,F)

• Inputs:
  • F, an instance of the type System
  • M, a matrix, used to square up the system (by default a random matrix is picked)
  • n, an integer, the number of polynomials to be formed (by default, this equals the number of variables)
  • x0, an instance of the type Point, used to compute the dimension of the tangent space (approximately)
  • p0, an instance of the type Point, parameters specialization (in case of a parametric system)
• Optional inputs:
  • block size
  • Field => ..., default value null
  • Strategy => ..., default value null
  • target rank
  • Verbose => ..., default value false
• Outputs:
  • G, a polynomial system

Description

There are two flavors of this method: both aimed at producing a regular sequence (either global or local).

The first squares up an overdetermined polynomial system (usually assuming that the user is interested in the isolated solutions; i.e., the components of dimension 0) and attaches keys SquareUpMatrix and SquaredUpSystem to F.

i1 : CC[X,Y]; F = polySystem {X^2+Y^2,X^3+Y^3,X^4+Y^4}

o2 = F

o2 : PolySystem

i3 : G := squareUp F

o3 = | (.296025-.479811ii)X4+(.296025-.479811ii)Y4+(-.605892-.324075ii)X3+(-.605892-.324075ii)Y3+(.448215+.0955171ii)X2+(.448215+.0955171ii)Y2 |
     | (-.085187-.0688326ii)X4+(-.085187-.0688326ii)Y4+(.54886+.147995ii)X3+(.54886+.147995ii)Y3+(.80766+.111983ii)X2+(.80766+.111983ii)Y2     |

o3 : PolySystem

i4 : peek F

o4 = PolySystem{NumberOfPolys => 3                                                                                                                                            }
                NumberOfVariables => 2
                PolyMap => {-2} | X2+Y2 |
                           {-3} | X3+Y3 |
                           {-4} | X4+Y4 |
                SquaredUpSystem => | (.296025-.479811ii)X4+(.296025-.479811ii)Y4+(-.605892-.324075ii)X3+(-.605892-.324075ii)Y3+(.448215+.0955171ii)X2+(.448215+.0955171ii)Y2 |
                                   | (-.085187-.0688326ii)X4+(-.085187-.0688326ii)Y4+(.54886+.147995ii)X3+(.54886+.147995ii)Y3+(.80766+.111983ii)X2+(.80766+.111983ii)Y2     |
                SquareUpMatrix => | .448215+.0955171ii -.605892-.324075ii .296025-.479811ii   |
                                  | .80766+.111983ii   .54886+.147995ii   -.085187-.0688326ii |

The other computes numericalRank r of the Jacobian of F and picks out the first r polynomials who give the same (approximate) rank at the specified point.

i5 : X = gateMatrix{toList vars(x,y,z)}

o5 = {{x, y, z}}

o5 : GateMatrix

i6 : P = gateMatrix{toList vars(a..d)}

o6 = {{a, b, c, d}}

o6 : GateMatrix

i7 : F = gateSystem(P,X,gateMatrix{{y^2-x*z},{x^2*y-z^2},{x^3-y*z},{a*x+b*y+c*z+d}})

o7 = gate system: 3 input(s) ---> 4 output(s) (with 4 parameters)

o7 : GateSystem

i8 : X0 = point{{1,1,1_CC}}

o8 = X0

o8 : Point

i9 : P0 = point{{1,1,1,-3_CC}}

o9 = P0

o9 : Point

i10 : norm evaluate(F, P0, X0) -- should be small

o10 = 0

o10 : RR (of precision 53)

i11 : numericalRank evaluateJacobian(F, P0, X0) -- should equal number of variables

o11 = 3

i12 : G = squareUp(P0, X0, F)

o12 = gate system: 3 input(s) ---> 3 output(s) (with 4 parameters)

o12 : GateSystem

i13 : netList entries gateMatrix G

      +-------------------------------------+
o13 = |((y * y) + (-1 * (x * z)))           |
      +-------------------------------------+
      |(((x * x) * y) + (-1 * (z * z)))     |
      +-------------------------------------+
      |((((a * x) + (b * y)) + (c * z)) + d)|
      +-------------------------------------+

Optional parameters are:

• ["block size"]: (default = 1) How many rows of Jacobian are evaluated at each step when squaring up a system at a specified Point.
• ["target rank"]: (default = full rank) The target rank of the subsystem.
• [Field]: (default = null). If null, then the coefficient ring is used for PolySystem and CC is used for GateSystem.
• [Strategy]: (default = "random matrix"). Given an overdetermined system, a random matrix is used to construct as many random linear combinations of the equations as there are variables. (Another option "slack variables" has not been implemented yet.)
• [Verbose]: (default = false).

See also

• PolySystem -- a polynomial system
• GateSystem -- a system of functions evaluated via a straightline program