This is NAGtypes.info, produced by Macaulay2, version 1.26.06

NAGtypes -- Common types used in Numerical Algebraic Geometry
*************************************************************

Description
===========

The package defines types used by the package NumericalAlgebraicGeometry,
as well as other numerical algebraic geometry
packages: e.g., interface packages PHCpack, and
Bertini::Bertini.

Datatypes:

  * Point -- a numerical approximation of a point in a
    complex space
  * PolySystem -- a polynomial system (usually with complex
    coefficients)
  * WitnessSet -- a witness set representing (possibly
    positive-dimensional) solution components
  * NumericalVariety -- a numerical description of a
    variety
  * PolySpace -- a polynomial vector subspace
  * DualSpace -- a dual functional vector subspace

See the corresponding documentation nodes for description of provided service
functions.

We display the objects of all new types showing only partial data. Moreover, if
an object is assigned to a global variable, only the name of the variable is
shown. Use peek (Macaulay2Doc), for more information.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal((x^2+y^2+2)*x,(x^2+y^2+2)*y);                                 |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : w1 = witnessSet(I , ideal(x-y), {point {{0.999999*ii,0.999999*ii}},     |
|                                                                             |
|o3 = w1                                                                      |
|                                                                             |
|o3 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|point {{-1.000001*ii,-1.000001*ii}}} )                                       |
+-----------------------------------------------------------------------------+
|i4 : O = point {{0.,0.}}                                                     |
|                                                                             |
|o4 = O                                                                       |
|                                                                             |
|o4 : Point                                                                   |
+-----------------------------------------------------------------------------+
|i5 : numericalVariety {witnessSet(I, ideal R, {O}),w1}                       |
|                                                                             |
|o5 = a "numerical variety" with components in                                |
|     dim 0:  [dim=0,deg=1]-*may be reducible*-                               |
|     dim 1:  w1                                                              |
|                                                                             |
|o5 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i6 : V = oo                                                                  |
|                                                                             |
|o6 = V                                                                       |
|                                                                             |
|o6 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i7 : peek V                                                                  |
|                                                                             |
|o7 = NumericalVariety{0 => {[dim=0,deg=1]-*may be reducible*-}}              |
|                      1 => {w1}                                              |
+-----------------------------------------------------------------------------+
|i8 : peek w1                                                                 |
|                                                                             |
|o8 = WitnessSet{cache => CacheTable{...1...}        }                        |
|                Equations => {-3} | x3+xy2+2x |                              |
|                             {-3} | x2y+y3+2y |                              |
|                Points => {{.999999*ii, .999999*ii}}                         |
|                          {{-ii, -ii}              }                         |
|                Slice => | 1 -1 0 |                                          |
+-----------------------------------------------------------------------------+
|i9 : peek O                                                                  |
|                                                                             |
|o9 = Point{cache => CacheTable{}}                                            |
|           Coordinates => {0, 0}                                             |
+-----------------------------------------------------------------------------+

Author
======

  * Anton Leykin <leykin@math.gatech.edu>

Version
=======

This documentation describes version 1.21 of NAGtypes, released Nov 2022.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{NAGtypesSource,                                                        |
|  title = {{NAGtypes: types used in Numerical Algebraic Geometry.            |
|  author = {Anton Leykin},                                                   |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    "http://people.math.gatech.edu/~aleykin3/NAG4M2"}                        |
|}                                                                            |
|-----------------------------------------------------------------------------|
|Version~1.21}},                                                              |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * AbstractPoint -- a type used to store a point in
        complex space
      * "Point" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * DualSpace -- a dual functional vector subspace
      * NumericalVariety -- a numerical variety
      * PolySpace -- a polynomial vector subspace
      * PolySystem -- a polynomial system
      * ProjectiveWitnessSet -- a projective
        witness set
      * System -- a system of functions
      * WitnessSet -- a witness set
      * "Ambient" -- see WSet, -- (under construction!) new types
        and methods needed to generalize WitnessSet
      * "SlicingVariety" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * WSet -- (under construction!) new types and methods needed
        to generalize WitnessSet
  * Functions and commands
      * "coordinates" -- see AbstractPoint, -- a type used
        to store a point in complex space
      * addition -- Union of polynomial spaces
      * areEqual -- determine if solutions are equal
      * declareIrreducible -- declares a component
        represented by the witness set irreducible
      * dualSpace -- construct a DualSpace
      * evaluate -- evaluate a polynomial system or matrix at
        a point
      * generalEquations -- random linear combinations
        of equations/generators
      * isContained -- Is one space contained in the other
      * isGEQ -- compare two points
      * isRealPoint -- determine whether a point is real
      * numericalAffineSpace -- affine space as a
        numerical variety
      * "numericalVariety" -- see numericalVariety(List),
        -- construct a numerical variety
      * "projectiveNumericalVariety" -- see numericalVariety(List),
        -- construct a numerical variety
      * point -- construct a Point
      * polySpace -- construct a PolySpace
      * "parameters" -- see PolySystem, -- a polynomial
        system
      * polySystem -- construct a polynomial system
      * "project" -- see project(AbstractPoint,ZZ),
        -- project a point
      * projectiveWitnessSet -- construct a
        ProjectiveWitnessSet
      * realPoints -- select real points
      * reduceSpace -- reduce the generators of a space
      * residual -- residual of a polynomial function at a
        point
      * "projectiveSliceEquations" -- see sliceEquations(Matrix,Ring),
        -- slicing linear functions
      * "sliceEquations" -- see sliceEquations(Matrix,Ring),
        -- slicing linear functions
      * solutionsWithMultiplicity -- replaces
        clusters of approximately equal points by single points with
        multiplicity
      * "sortSolutions" -- see sortSolutions(List),
        -- sort the list of solutions
      * "evaluateJacobian" -- see System, -- a system of
        functions
      * "numFunctions" -- see System, -- a system of functions
      * "numParameters" -- see System, -- a system of functions
      * "numVariables" -- see System, -- a system of functions
      * "toAffineChart" -- see toAffineChart(ZZ,List),
        -- coordinates of a point in the
        projective space in an affine chart
      * "equations" -- see WitnessSet, -- a witness set
      * "points" -- see WitnessSet, -- a witness set
      * "slice" -- see WitnessSet, -- a witness set
      * witnessSet -- construct a WitnessSet
  * Methods
      * "coordinates(AbstractPoint)" -- see AbstractPoint,
        -- a type used to store a point in complex space
      * "coordinates(Point)" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "matrix(AbstractPoint)" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "net(AbstractPoint)" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "status(AbstractPoint)" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "addition(PolySpace,PolySpace)" -- see addition, --
        Union of polynomial spaces
      * "AbstractPoint == AbstractPoint" -- see areEqual, --
        determine if solutions are equal
      * "areEqual(AbstractPoint,AbstractPoint)" -- see areEqual,
        -- determine if solutions are equal
      * "areEqual(BasicList,BasicList)" -- see areEqual, --
        determine if solutions are equal
      * "areEqual(CC,CC)" -- see areEqual, -- determine if
        solutions are equal
      * "areEqual(List,List)" -- see areEqual, -- determine if
        solutions are equal
      * "areEqual(Matrix,Matrix)" -- see areEqual, -- determine
        if solutions are equal
      * "areEqual(MutableMatrix,MutableMatrix)" -- see areEqual,
        -- determine if solutions are equal
      * "areEqual(Number,Number)" -- see areEqual, -- determine
        if solutions are equal
      * areEqual(DualSpace,DualSpace)
        -- approximate equality of dual
        spaces
      * areEqual(PolySpace,PolySpace)
        -- approximate equality of
        subspaces spanned by polynomials
      * check(WitnessSet) (missing documentation)
      * components(NumericalVariety),
        -- list components of a numerical variety
      * "components(NumericalVariety,ZZ)" -- see
        components(NumericalVariety), -- list
        components of a numerical variety
      * "components(NumericalVariety,ZZ,InfiniteNumber)" -- see
        components(NumericalVariety), -- list
        components of a numerical variety
      * "components(NumericalVariety,ZZ,ZZ)" -- see
        components(NumericalVariety), -- list
        components of a numerical variety
      * "declareIrreducible(WitnessSet)" -- see declareIrreducible,
        -- declares a component represented by the witness
        set irreducible
      * decompose(WitnessSet) (missing documentation)
      * "dim(DualSpace)" -- see DualSpace, -- a dual
        functional vector subspace
      * "generators(DualSpace)" -- see DualSpace, -- a dual
        functional vector subspace
      * "net(DualSpace)" -- see DualSpace, -- a dual
        functional vector subspace
      * "point(DualSpace)" -- see DualSpace, -- a dual
        functional vector subspace
      * "ring(DualSpace)" -- see DualSpace, -- a dual
        functional vector subspace
      * "dualSpace(DualSpace)" -- see dualSpace, -- construct
        a DualSpace
      * "dualSpace(Matrix,AbstractPoint)" -- see dualSpace, --
        construct a DualSpace
      * "dualSpace(PolySpace,AbstractPoint)" -- see dualSpace,
        -- construct a DualSpace
      * "evaluate(Matrix,AbstractPoint)" -- see evaluate, --
        evaluate a polynomial system or matrix at a point
      * "evaluate(Matrix,Matrix)" -- see evaluate, -- evaluate
        a polynomial system or matrix at a point
      * "evaluate(PolySystem,Matrix)" -- see evaluate, --
        evaluate a polynomial system or matrix at a point
      * "evaluateJacobian(PolySystem,AbstractPoint)" -- see evaluate,
        -- evaluate a polynomial system or matrix at a point
      * "generalEquations(WitnessSet)" -- see generalEquations,
        -- random linear combinations of equations/generators
      * "generalEquations(ZZ,Ideal)" -- see generalEquations,
        -- random linear combinations of equations/generators
      * "generalEquations(ZZ,List)" -- see generalEquations,
        -- random linear combinations of equations/generators
      * homogenize(PolySystem,Ring,RingElement)
        -- homogenize a
        polynomial system
      * intersect(PolySpace,PolySpace)
        -- Intersection of polynomial
        spaces
      * "isContained(DualSpace,DualSpace)" -- see isContained,
        -- Is one space contained in the other
      * "isContained(PolySpace,PolySpace)" -- see isContained,
        -- Is one space contained in the other
      * "isGEQ(AbstractPoint,AbstractPoint)" -- see isGEQ, --
        compare two points
      * "isGEQ(List,List)" -- see isGEQ, -- compare two points
      * "isRealPoint(AbstractPoint)" -- see isRealPoint, --
        determine whether a point is real
      * isSubset(NumericalVariety,NumericalVariety) (missing documentation)
      * isSubset(WitnessSet,NumericalVariety) (missing documentation)
      * isSubset(WitnessSet,WitnessSet) (missing documentation)
      * net(Point) (missing documentation)
      * norm(Thing,AbstractPoint), --
        p-norm of the point
      * "numericalAffineSpace(PolynomialRing)" -- see
        numericalAffineSpace, -- affine space as a
        numerical variety
      * "check(NumericalVariety)" -- see NumericalVariety,
        -- a numerical variety
      * "degree(NumericalVariety)" -- see NumericalVariety,
        -- a numerical variety
      * "dim(NumericalVariety)" -- see NumericalVariety,
        -- a numerical variety
      * "net(NumericalVariety)" -- see NumericalVariety,
        -- a numerical variety
      * NumericalVariety == NumericalVariety (missing documentation)
      * NumericalVariety | NumericalVariety (missing documentation)
      * numericalVariety(List) -- construct
        a numerical variety
      * "projectiveNumericalVariety(List)" -- see numericalVariety(List),
        -- construct a numerical variety
      * "point(AbstractPoint)" -- see point, -- construct a Point
      * "point(List)" -- see point, -- construct a Point
      * "point(List,CacheTable)" -- see point, -- construct a
        Point
      * "point(Matrix)" -- see point, -- construct a Point
      * "dim(PolySpace)" -- see PolySpace, -- a polynomial
        vector subspace
      * "generators(PolySpace)" -- see PolySpace, -- a
        polynomial vector subspace
      * "net(PolySpace)" -- see PolySpace, -- a polynomial
        vector subspace
      * "ring(PolySpace)" -- see PolySpace, -- a polynomial
        vector subspace
      * "polySpace(Matrix)" -- see polySpace, -- construct a
        PolySpace
      * "polySpace(PolySpace)" -- see polySpace, -- construct
        a PolySpace
      * "equations(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "ideal(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "isHomogeneous(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "jacobian(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "net(PolySystem)" -- see PolySystem, -- a polynomial
        system
      * "numFunctions(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "numParameters(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "numVariables(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "parameters(PolySystem)" -- see PolySystem, -- a
        polynomial system
      * "ring(PolySystem)" -- see PolySystem, -- a polynomial
        system
      * "polySystem(Ideal)" -- see polySystem, -- construct a
        polynomial system
      * "polySystem(List)" -- see polySystem, -- construct a
        polynomial system
      * "polySystem(Matrix)" -- see polySystem, -- construct
        a polynomial system
      * "polySystem(PolySystem)" -- see polySystem, --
        construct a polynomial system
      * polySystem(WitnessSet) (missing documentation)
      * project(AbstractPoint,ZZ), --
        project a point
      * "project(Point,ZZ)" -- see project(AbstractPoint,ZZ),
        -- project a point
      * "projectiveWitnessSet(Ideal,Matrix,Matrix,List)" -- see
        projectiveWitnessSet, -- construct a
        ProjectiveWitnessSet
      * "random(DualSpace)" -- see random(PolySpace),
        -- random element of a subspace
      * random(PolySpace) -- random element of a
        subspace
      * "random(ZZ,DualSpace)" -- see random(PolySpace),
        -- random element of a subspace
      * "random(ZZ,PolySpace)" -- see random(PolySpace),
        -- random element of a subspace
      * random(WitnessSet) (missing documentation)
      * "realPoints(List)" -- see realPoints, -- select real
        points
      * "reduceSpace(DualSpace)" -- see reduceSpace, --
        reduce the generators of a space
      * "reduceSpace(PolySpace)" -- see reduceSpace, --
        reduce the generators of a space
      * "residual(List,Point)" -- see residual, -- residual of
        a polynomial function at a point
      * "residual(Matrix,Matrix)" -- see residual, -- residual
        of a polynomial function at a point
      * "residual(System,AbstractPoint)" -- see residual, --
        residual of a polynomial function at a point
      * "residual(System,Point)" -- see residual, -- residual
        of a polynomial function at a point
      * "projectiveSliceEquations(Matrix,Ring)" -- see
        sliceEquations(Matrix,Ring), --
        slicing linear functions
      * sliceEquations(Matrix,Ring),
        -- slicing linear functions
      * "solutionsWithMultiplicity(List)" -- see
        solutionsWithMultiplicity, -- replaces
        clusters of approximately equal points by single points with
        multiplicity
      * sortSolutions(List) -- sort the list of
        solutions
      * status(Point) (missing documentation)
      * substitute(PolySystem,Ring),
        -- substitute a ring in a polynomial system
      * "evaluate(System,AbstractPoint)" -- see System, -- a
        system of functions
      * "evaluate(System,AbstractPoint,AbstractPoint)" -- see System,
        -- a system of functions
      * "evaluate(System,Matrix)" -- see System, -- a system of
        functions
      * "evaluate(System,Matrix,Matrix)" -- see System, -- a
        system of functions
      * "evaluateJacobian(System,AbstractPoint)" -- see System,
        -- a system of functions
      * "evaluateJacobian(System,AbstractPoint,AbstractPoint)" -- see
        System, -- a system of functions
      * "evaluateJacobian(System,Matrix)" -- see System, -- a
        system of functions
      * "evaluateJacobian(System,Matrix,Matrix)" -- see System,
        -- a system of functions
      * "numFunctions(System)" -- see System, -- a system of
        functions
      * "numParameters(System)" -- see System, -- a system of
        functions
      * "numVariables(System)" -- see System, -- a system of
        functions
      * toAffineChart(ZZ,List), --
        coordinates of a point in the projective space in an affine chart
      * union(NumericalVariety,NumericalVariety) (missing documentation)
      * "codim(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "degree(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "dim(WitnessSet)" -- see WitnessSet, -- a witness set
      * "equations(WitnessSet)" -- see WitnessSet, -- a
        witness set
      * "ideal(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "net(WitnessSet)" -- see WitnessSet, -- a witness set
      * "points(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "ring(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "slice(WitnessSet)" -- see WitnessSet, -- a witness
        set
      * "witnessSet(Ideal,Ideal,List)" -- see witnessSet, --
        construct a WitnessSet
      * "witnessSet(Ideal,Matrix,List)" -- see witnessSet, --
        construct a WitnessSet
      * "witnessSet(PolySystem,Matrix,List)" -- see witnessSet,
        -- construct a WitnessSet
      * "witnessSet(PolySystem,PolySystem,List)" -- see witnessSet,
        -- construct a WitnessSet
      * WitnessSet - WitnessSet (missing documentation)
      * WitnessSet == WitnessSet (missing documentation)
      * witnessSet(Ideal,ZZ) (missing documentation)
      * "ambient(SlicingVariety)" -- see WSet, -- (under
        construction!) new types and methods needed to generalize WitnessSet
      * "ambient(WSet)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * "codim(SlicingVariety)" -- see WSet, -- (under
        construction!) new types and methods needed to generalize WitnessSet
      * "codim(WSet)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * "degree(WSet)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * "dim(Ambient)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * "dim(SlicingVariety)" -- see WSet, -- (under construction!)
        new types and methods needed to generalize WitnessSet
      * "dim(WSet)" -- see WSet, -- (under construction!) new types
        and methods needed to generalize WitnessSet
      * "map(SlicingVariety)" -- see WSet, -- (under construction!)
        new types and methods needed to generalize WitnessSet
      * "net(Ambient)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
      * "net(SlicingVariety)" -- see WSet, -- (under construction!)
        new types and methods needed to generalize WitnessSet
      * "net(WSet)" -- see WSet, -- (under construction!) new types
        and methods needed to generalize WitnessSet
      * "points(WSet)" -- see WSet, -- (under construction!) new
        types and methods needed to generalize WitnessSet
  * Symbols
      * "ConditionNumber" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "Coordinates" -- see AbstractPoint, -- a type used
        to store a point in complex space
      * "DecreasePrecision" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "DeflationNumber" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "ErrorBoundEstimate" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "IncreasePrecision" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "Infinity" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * "LastT" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * "MaxPrecision" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "MinStepFailure" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "Multiplicity" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "NumberOfSteps" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "NumericalRankFailure" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "Origin" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * "RefinementFailure" -- see AbstractPoint, -- a
        type used to store a point in complex space
      * "Regular" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * "Singular" -- see AbstractPoint, -- a type used to
        store a point in complex space
      * "SolutionStatus" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * "WindingNumber" -- see AbstractPoint, -- a type
        used to store a point in complex space
      * Norm -- p in the p-norm
      * "Reduced" -- see polySpace, -- construct a PolySpace
      * "ContinuationParameter" -- see PolySystem, -- a
        polynomial system
      * "NumberOfPolys" -- see PolySystem, -- a polynomial
        system
      * "NumberOfVariables" -- see PolySystem, -- a
        polynomial system
      * "PolyMap" -- see PolySystem, -- a polynomial system
      * "SpecializationRing" -- see PolySystem, -- a
        polynomial system
      * ProjectiveNumericalVariety -- a
        projective numerical variety
      * "AffineChart" -- see ProjectiveWitnessSet,
        -- a projective witness set
      * "Equations" -- see WitnessSet, -- a witness set
      * "IsIrreducible" -- see WitnessSet, -- a witness set
      * "Points" -- see WitnessSet, -- a witness set
      * "ProjectionDimension" -- see WitnessSet, -- a witness
        set
      * "Slice" -- see WitnessSet, -- a witness set

For the programmer
==================

The object NAGtypes, is a package (Macaulay2Doc),
defined in NAGtypes.m2, with auxiliary files in NAGtypes/.

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:36:0.

AbstractPoint -- a type used to store a point in complex space
**************************************************************

Description
===========

The type Point inherited from AbstractPoint is used to store a solution to a
polynomial system obtained by such functions as solveSystem (NumericalAlgebraicGeometry),
see track (NumericalAlgebraicGeometry).
The following
methods can be used to access a AbstractPoint,:
  * coordinates -- get the coordinates (returns a list)
  * matrix -- get the coordinates (returns a matrix)
  * status -- get the type of solution (e.g., Regular)
Possible return values of status (Macaulay2Doc), reflect the
status with respect to a homotopy continuation procedure that obtained this
point:
  * Regular -- the jacobian of the polynomial system is regular at the point
  * Singular -- the jacobian of the polynomial system is (near)singular at the
    point
  * Infinity -- the solution path is deemed divergent
  * MinStepFailure -- the tracker failed to stay above the minimal step
    increment threshold
  * NumericalRankFailure -- it is likely that in a sequence of deflations
    numerical rank did not give the correct rank
  * RefinementFailure -- a solution refinement function failed
  * Origin -- the solution path approaches the origin (impossible to give a
    relative error estimate)
  * IncreasePrecision -- the current precision is deemed inadequate for robust
    computation
  * DecreasePrecision -- the current precision is deemed excessive (more than
    the double of sufficient precision)
  * null -- the point has not been classified
Only coordinates are displayed (by net (Macaulay2Doc)); other
attributes of a Point, p are stored in p.cache.  Different
algorithms attach different information describing the point. For example,
see solveSystem (NumericalAlgebraicGeometry), produces
the following.

+-----------------------------------------------------------------------------+
|i1 : loadPackage "NumericalAlgebraicGeometry";                               |
+-----------------------------------------------------------------------------+
|i2 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i3 : sols = solveSystem{x^2+y^2-3, x^3-y^3-7}                                |
|                                                                             |
|o3 = {{-.101284+.779159*ii, -1.89699-.041601*ii}, {1.89699+.041601*ii,       |
|     ------------------------------------------------------------------------|
|     .101284-.779159*ii}, {-1.7957-1.31322*ii, 1.7957-1.31322*ii},           |
|     ------------------------------------------------------------------------|
|     {1.89699-.041601*ii, .101284+.779159*ii}, {-1.7957+1.31322*ii,          |
|     ------------------------------------------------------------------------|
|     1.7957+1.31322*ii}, {-.101284-.779159*ii, -1.89699+.041601*ii}}         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : pt = first sols                                                         |
|                                                                             |
|o4 = pt                                                                      |
|                                                                             |
|o4 : Point                                                                   |
+-----------------------------------------------------------------------------+
|i5 : peek pt                                                                 |
|                                                                             |
|o5 = Point{cache => CacheTable{...5...}                             }        |
|           Coordinates => {-.101284+.779159*ii, -1.89699-.041601*ii}         |
+-----------------------------------------------------------------------------+
|i6 : coordinates pt                                                          |
|                                                                             |
|o6 = {-.101284+.779159*ii, -1.89699-.041601*ii}                              |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : status pt                                                               |
|                                                                             |
|o7 = Regular                                                                 |
|                                                                             |
|o7 : Symbol                                                                  |
+-----------------------------------------------------------------------------+

The other keys that may be attached include

  * NumberOfSteps -- the number of steps in made by the
    continuation procedure
  * LastT -- the last value of the continuation parameter
    produced during tracking (equals 1 for a regular solution)
  * ErrorBoundEstimate -- an estimate of the distance
    from the approximation to the actual solution
  * MaxPrecision -- max precision used during the
    homotopy tracking
  * Multiplicity -- the multiplicity of an isolated
    solution
  * WindingNumber -- the winding number of a singular
    solution determined in the end-games
  * DeflationNumber -- number of first-order deflations
    in the regularization of a singular solution
  * Tracker -- reserved for developers

Basic service functions:

  * areEqual -- determine if solutions are equal
  * sortSolutions -- sort the list of solutions
  * isRealPoint -- determine whether a point is real
  * realPoints -- select real points
  * solutionsWithMultiplicity -- replaces
    clusters of approximately equal points by single points with multiplicity
  * norm(Thing,AbstractPoint) -- p-norm
    of the point
  * toAffineChart -- coordinates of a
    point in the projective space in an affine chart

Types of point:
===============

  * "Point"

Methods that use a point:
=========================

  * "coordinates(AbstractPoint)"
  * "matrix(AbstractPoint)"
  * "net(AbstractPoint)"
  * "status(AbstractPoint)"
  * "AbstractPoint == AbstractPoint" -- see areEqual, --
    determine if solutions are equal
  * "areEqual(AbstractPoint,AbstractPoint)" -- see areEqual, --
    determine if solutions are equal
  * "dualSpace(Matrix,AbstractPoint)" -- see dualSpace, --
    construct a DualSpace
  * "dualSpace(PolySpace,AbstractPoint)" -- see dualSpace, --
    construct a DualSpace
  * "evaluate(Matrix,AbstractPoint)" -- see evaluate, --
    evaluate a polynomial system or matrix at a point
  * "evaluateJacobian(PolySystem,AbstractPoint)" -- see evaluate,
    -- evaluate a polynomial system or matrix at a point
  * "isGEQ(AbstractPoint,AbstractPoint)" -- see isGEQ, -- compare
    two points
  * "isRealPoint(AbstractPoint)" -- see isRealPoint, --
    determine whether a point is real
  * norm(Thing,AbstractPoint) -- p-norm
    of the point
  * "point(AbstractPoint)" -- see point, -- construct a Point
  * project(AbstractPoint,ZZ), --
    project a point
  * "residual(System,AbstractPoint)" -- see residual, --
    residual of a polynomial function at a point
  * "evaluate(System,AbstractPoint)" -- see System, -- a system
    of functions
  * "evaluate(System,AbstractPoint,AbstractPoint)" -- see System,
    -- a system of functions
  * "evaluateJacobian(System,AbstractPoint)" -- see System, -- a
    system of functions
  * "evaluateJacobian(System,AbstractPoint,AbstractPoint)" -- see System,
    -- a system of functions

For the programmer
==================

The object AbstractPoint, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:103:0.

addition -- Union of polynomial spaces
**************************************

  * Usage:
        S = addition(T, U)
  * Inputs:
      * T, an instance of the type PolySpace,
      * U, an instance of the type PolySpace,
  * Optional inputs (Macaulay2Doc),:
      * Tolerance => ..., default value .000001
  * Outputs:
      * S, an instance of the type PolySpace,

Description
===========

Finds the union of two polynomial spaces.

Ways to use addition:
=====================

  * "addition(PolySpace,PolySpace)"

For the programmer
==================

The object addition, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1035:0.

areEqual -- determine if solutions are equal
********************************************

  * Usage:
        b = areEqual(x,y)
  * Inputs:
      * x, a solution or a list of solutions
      * y, a solution or a list of solutions
  * Optional inputs (Macaulay2Doc),:
      * Projective => ..., default value false, if true (Macaulay2Doc),
        then solutions are considered as representatives of
        points in the projective space
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * b, tells if x and y are approximately equal

Description
===========

The inputs can be complex numbers, see points,  or lists of
points (presented as points, or lists of coordinates). The
function returns false if the distance between x and y exceeds Tolerance (NumericalLinearAlgebra),
and true, otherwise.

If Projective=>true then 1-\cos\alpha is compared with the Tolerance (NumericalLinearAlgebra),
where \alpha is the angle between x and y.

+--------------------------------------------------------------------+
|i1 : areEqual({{-1,1e-7},{1e-7*ii,-1}}, {{-1, 0}, {0, -1}})         |
|                                                                    |
|o1 = true                                                           |
+--------------------------------------------------------------------+
|i2 : areEqual({3*ii,2*ii,1+ii}, {-6,-4,-2+2*ii}, Projective=>true)  |
|                                                                    |
|o2 = false                                                          |
+--------------------------------------------------------------------+

For two points, A and Bcalling A == Bis equivalent to
areEqual(A,B), however, there is no way to specify the optional parameter.

+----------------------------------------+
|i3 : A = point {{-1,1e-7}, {1e-7*ii,-1}}|
|                                        |
|o3 = A                                  |
|                                        |
|o3 : Point                              |
+----------------------------------------+
|i4 : B = point {{-1,0}, {0, -1}}        |
|                                        |
|o4 = B                                  |
|                                        |
|o4 : Point                              |
+----------------------------------------+
|i5 : A == B                             |
|                                        |
|o5 = true                               |
+----------------------------------------+

See also
========

  * solveSystem (NumericalAlgebraicGeometry), --
    solve a system of polynomial equations
  * track (NumericalAlgebraicGeometry), --
    track a linear segment homotopy given start and target system
  * sortSolutions -- sort the list of solutions

Ways to use areEqual:
=====================

  * "areEqual(AbstractPoint,AbstractPoint)"
  * "areEqual(BasicList,BasicList)"
  * "areEqual(CC,CC)"
  * "areEqual(List,List)"
  * "areEqual(Matrix,Matrix)"
  * "areEqual(MutableMatrix,MutableMatrix)"
  * "areEqual(Number,Number)"
  * areEqual(DualSpace,DualSpace),
    -- approximate equality of dual spaces
  * areEqual(PolySpace,PolySpace),
    -- approximate equality of subspaces spanned by polynomials

For the programmer
==================

The object areEqual, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:227:0.

areEqual(DualSpace,DualSpace) -- approximate equality of dual spaces
********************************************************************

  * Function: areEqual,
  * Usage:
        b = areEqual(A,B)
  * Inputs:
      * A, an instance of the type DualSpace,
      * B, an instance of the type DualSpace,
  * Optional inputs (Macaulay2Doc),:
      * Projective, => ..., default value false, determine if
        solutions are equal
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

Description
===========

Two dual spaces are approximately equal if the have (approximately) the same
base point(DualSpace), and the linear spaces spanned by the
differential operators are equal approximately.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : A = dualSpace(matrix{{y^2,x^2+x*y}},point{{1,1}})                       |
|                                                                             |
|o2 = | y2 x2+xy |                                                            |
|                                                                             |
|o2 : DualSpace                                                               |
+-----------------------------------------------------------------------------+
|i3 : B = dualSpace(matrix{{x^2+x*y+y^2,y^2+0.00000001}},point{{1,1+0.00000001|
|                                                                             |
|o3 = | x2+xy+y2 y2+1e-8 |                                                    |
|                                                                             |
|o3 : DualSpace                                                               |
|-----------------------------------------------------------------------------|
|}})                                                                          |
+-----------------------------------------------------------------------------+
|i4 : b = areEqual(A,B)                                                       |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * areEqual(DualSpace,DualSpace),
    -- approximate equality of dual spaces
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:984:0.

areEqual(PolySpace,PolySpace) -- approximate equality of subspaces spanned by polynomials
*****************************************************************************************

  * Function: areEqual,
  * Usage:
        b = areEqual(A,B)
  * Inputs:
      * A, an instance of the type PolySpace,
      * B, an instance of the type PolySpace,
  * Optional inputs (Macaulay2Doc),:
      * Projective, => ..., default value false, determine if
        solutions are equal
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

Description
===========

Two spaces are approximately equal if the numericalImage (NumericalLinearAlgebra),
of their union of their generators has
the same dimension as both of them.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : b = areEqual(polySpace matrix{{y^2,x^2+x*y}}, polySpace                 |
|                                                                             |
|o2 = true                                                                    |
|-----------------------------------------------------------------------------|
|matrix{{x^2+x*y+y^2,y^2+0.00000001}})                                        |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * areEqual(PolySpace,PolySpace),
    -- approximate equality of subspaces spanned by polynomials
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:960:0.

components(NumericalVariety) -- list components of a numerical variety
**********************************************************************

  * Function: components (Macaulay2Doc),
  * Usage:
        components(V)
        components(V,a)
        components(V,a,b)
  * Inputs:
      * V, a numerical variety,
  * Outputs:
      * a list (Macaulay2Doc), of witness sets,

Description
===========

Returns a list of components of a numerical variety. If a (an integer (Macaulay2Doc))
and/or b (an integer (Macaulay2Doc), or
infinity (Macaulay2Doc)) are specified, then components of dimension
a (respectively, components of dimension at least a and at most b) are
returned.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]; I = ideal((x^2+y^2+2)*x,(x^2+y^2+2)*y);                    |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : w1 := witnessSet(I , ideal(x-y), {point {{0.999999*ii,0.999999*ii}},    |
|                                                                             |
|o3 = [dim=1,deg=2]-*may be reducible*-                                       |
|                                                                             |
|o3 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|point {{-1.000001*ii,-1.000001*ii}}} )                                       |
+-----------------------------------------------------------------------------+
|i4 : w0 := witnessSet(I, ideal R, {point {{0.,0.}}})                         |
|                                                                             |
|o4 = [dim=0,deg=1]-*may be reducible*-                                       |
|                                                                             |
|o4 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i5 : V := numericalVariety {w0,w1}                                           |
|                                                                             |
|o5 = a "numerical variety" with components in                                |
|     dim 0:  [dim=0,deg=1]-*may be reducible*-                               |
|     dim 1:  [dim=1,deg=2]-*may be reducible*-                               |
|                                                                             |
|o5 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i6 : components V                                                            |
|                                                                             |
|o6 = {[dim=0,deg=1]-*may be reducible*-, [dim=1,deg=2]-*may be reducible*-}  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * NumericalVariety -- a numerical variety

Ways to use this method:
========================

  * components(NumericalVariety), --
    list components of a numerical variety
  * "components(NumericalVariety,ZZ)"
  * "components(NumericalVariety,ZZ,InfiniteNumber)"
  * "components(NumericalVariety,ZZ,ZZ)"
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:769:0.

declareIrreducible -- declares a component represented by the witness set irreducible
*************************************************************************************

Description
===========

This is a service method that for a witness set W sets the flag
W.cache.IsIrreducible to true.

Ways to use declareIrreducible:
===============================

  * "declareIrreducible(WitnessSet)"

For the programmer
==================

The object declareIrreducible, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:666:0.

DualSpace -- a dual functional vector subspace
**********************************************

Description
===========

This type stores a finite dimensional subspace of the local dual of a
polynomial ring at a point. In practice, the subspace is stored as a
PolySpace, with functionals represented by the corresponding
polynomial, along with a AbstractPoint. The following
methods can be used to access a DualSpace:

  * gens -- a one-row matrix of the generators
  * dim -- the number of generators
  * ring -- the ring of the generators
  * point -- the base point of the dual space

See also
========

  * dualSpace -- construct a DualSpace
  * PolySpace -- a polynomial vector subspace

Methods that use an object of class DualSpace:
==============================================

  * areEqual(DualSpace,DualSpace),
    -- approximate equality of dual spaces
  * "dim(DualSpace)"
  * "generators(DualSpace)"
  * "net(DualSpace)"
  * "point(DualSpace)"
  * "ring(DualSpace)"
  * "dualSpace(DualSpace)" -- see dualSpace, -- construct a
    DualSpace
  * "isContained(DualSpace,DualSpace)" -- see isContained,
    -- Is one space contained in the other
  * "random(DualSpace)" -- see random(PolySpace),
    -- random element of a subspace
  * "random(ZZ,DualSpace)" -- see random(PolySpace),
    -- random element of a subspace
  * "reduceSpace(DualSpace)" -- see reduceSpace, -- reduce
    the generators of a space

For the programmer
==================

The object DualSpace, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:910:0.

dualSpace -- construct a DualSpace
**********************************

  * Usage:
        D = dualSpace(M,p)
        D = dualSpace(S,p)
  * Inputs:
      * M, a matrix (Macaulay2Doc), with one row of generators
      * S, an instance of the type PolySpace,
      * p, a point,
  * Outputs:
      * D, an instance of the type DualSpace,

Description
===========

Used to construct a finite dimensional subspace of the local dual space of
polynomial ring at a point.

+-----------------------------+
|i1 : R = CC[x,y];            |
+-----------------------------+
|i2 : M = matrix{{1,x,x^2-y}} |
|                             |
|o2 = | 1 x x2-y |            |
|                             |
|             1      3        |
|o2 : Matrix R  <-- R         |
+-----------------------------+
|i3 : p = point matrix{{1,0}};|
+-----------------------------+
|i4 : D = dualSpace(M,p)      |
|                             |
|o4 = | 1 x x2-y |            |
|                             |
|o4 : DualSpace               |
+-----------------------------+

Ways to use dualSpace:
======================

  * "dualSpace(DualSpace)"
  * "dualSpace(Matrix,AbstractPoint)"
  * "dualSpace(PolySpace,AbstractPoint)"

For the programmer
==================

The object dualSpace, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:938:0.

evaluate -- evaluate a polynomial system or matrix at a point
*************************************************************

  * Usage:
        y = evaluate(f,x)
  * Inputs:
      * f, a polynomial system, or a matrix (Macaulay2Doc),
      * x, a point, or a matrix (Macaulay2Doc),
  * Outputs:
      * y, the value f(x)

Description
===========

Evaluates a PolySystem, or a matrix with polynomial entries
at a point.

+------------------------------------------------------+
|i1 : R = CC[x,y]; S = polySystem {x^2+y^2-6, 2*x^2-y};|
+------------------------------------------------------+
|i3 : p = point {{1.0+3*ii,2.3+ii}};                   |
+------------------------------------------------------+
|i4 : evaluate(S,p)                                    |
|                                                      |
|o4 = | -9.71+10.6ii |                                 |
|     | -18.3+11ii   |                                 |
|                                                      |
|                2         1                           |
|o4 : Matrix CC    <-- CC                              |
|              53        53                            |
+------------------------------------------------------+
|i5 : evaluate(jacobian S, p)                          |
|                                                      |
|o5 = | 2+6ii  4.6+2ii |                               |
|     | 4+12ii -1      |                               |
|                                                      |
|                2         2                           |
|o5 : Matrix CC    <-- CC                              |
|              53        53                            |
+------------------------------------------------------+

See also
========

  * PolySystem -- a polynomial system

Ways to use evaluate:
=====================

  * "evaluate(Matrix,AbstractPoint)"
  * "evaluate(Matrix,Matrix)"
  * "evaluate(PolySystem,Matrix)"
  * "evaluate(System,AbstractPoint)" -- see System, -- a system
    of functions
  * "evaluate(System,AbstractPoint,AbstractPoint)" -- see System,
    -- a system of functions
  * "evaluate(System,Matrix)" -- see System, -- a system of
    functions
  * "evaluate(System,Matrix,Matrix)" -- see System, -- a system
    of functions

For the programmer
==================

The object evaluate, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:415:0.

generalEquations -- random linear combinations of equations/generators
**********************************************************************

  * Usage:
        L = generalEquations(k,F)
        L = generalEquations(k,I)
  * Inputs:
      * k, an integer (Macaulay2Doc),
      * F, a list (Macaulay2Doc), a list of polynomials
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), k linear combinations of
        polynomials in F (of generators of I)

Description
===========

A variety V (that is not necessarily a complete intersection) of codimension k
is a component of a complete intersection of codimension k defined by k general
linear combinations of any generating set of the defining ideal of V.

This function automates the above construction.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y,z];                                                          |
+-----------------------------------------------------------------------------+
|i2 : F = {x*y, x^2 - y, x*z};                                                |
+-----------------------------------------------------------------------------+
|i3 : L = generalEquations(2,F)                                               |
|                                                                             |
|                            2                                                |
|o3 = {(.29398 + .632944*ii)x  + (.892712 + .673395*ii)x*y + (.0258884 +      |
|     ------------------------------------------------------------------------|
|                                                                       2     |
|     .714827*ii)x*z + (- .29398 - .632944*ii)y, (.461944 + .775187*ii)x  +   |
|     ------------------------------------------------------------------------|
|     (.89189 + .231053*ii)x*y + (.909047 + .314897*ii)x*z + (- .461944 -     |
|     ------------------------------------------------------------------------|
|     .775187*ii)y}                                                           |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use generalEquations:
=============================

  * "generalEquations(WitnessSet)"
  * "generalEquations(ZZ,Ideal)"
  * "generalEquations(ZZ,List)"

For the programmer
==================

The object generalEquations, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:830:0.

homogenize(PolySystem,Ring,RingElement) -- homogenize a polynomial system
*************************************************************************

  * Function: homogenize (Macaulay2Doc),
  * Usage:
        G = sub(F,R,t)
  * Inputs:
      * F, a polynomial system,
      * R, a ring (Macaulay2Doc),
      * t, a ring element (Macaulay2Doc), a ring element (Macaulay2Doc),
        a variable in R
  * Outputs:
      * G, a polynomial system,

Description
===========

Constructs a polynomial system, that is a homogenization of
the given system.

+------------------------------------------------------+
|i1 : R = CC[x,y]; S := polySystem {x^2+y^2-6, 2*x^4-y}|
|                                                      |
|o2 = {-2} | x2+y2-6 |                                 |
|     {-4} | 2x4-y   |                                 |
|                                                      |
|o2 : PolySystem                                       |
+------------------------------------------------------+
|i3 : T := homogenize(S,CC[x,y,t],t)                   |
|                                                      |
|o3 = {-2} | x2+y2-6t2 |                               |
|     {-4} | 2x4-yt3   |                               |
|                                                      |
|o3 : PolySystem                                       |
+------------------------------------------------------+
|i4 : ring T                                           |
|                                                      |
|o4 = CC  [x..y, t]                                    |
|       53                                             |
|                                                      |
|o4 : PolynomialRing                                   |
+------------------------------------------------------+

See also
========

  * homogenize (Macaulay2Doc) -- homogenize with respect to a
    variable
  * PolySystem -- a polynomial system

Ways to use this method:
========================

  * homogenize(PolySystem,Ring,RingElement)
    -- homogenize a polynomial
    system
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:503:0.

intersect(PolySpace,PolySpace) -- Intersection of polynomial spaces
*******************************************************************

  * Function: intersect (Macaulay2Doc),
  * Usage:
        S = intersection(T, U)
  * Inputs:
      * T, an instance of the type PolySpace,
      * U, an instance of the type PolySpace,
  * Optional inputs (Macaulay2Doc),:
      * Tolerance => ..., default value .000001
  * Outputs:
      * S, an instance of the type PolySpace,

Description
===========

Finds the intersection of two polynomial spaces.

Ways to use this method:
========================

  * intersect(PolySpace,PolySpace),
    -- Intersection of polynomial spaces
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1053:0.

isContained -- Is one space contained in the other
**************************************************

  * Usage:
        b = isContained(S, T)
        b = isContained(D, E)
  * Inputs:
      * S, an instance of the type PolySpace,
      * T, an instance of the type PolySpace,
      * D, an instance of the type DualSpace,
      * E, an instance of the type DualSpace,
  * Optional inputs (Macaulay2Doc),:
      * Tolerance => ..., default value .000001
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether S is
        contained in T (or D in E).

Description
===========

Determines numerically whether the first polynomial space is contained in the
second.

Ways to use isContained:
========================

  * "isContained(DualSpace,DualSpace)"
  * "isContained(PolySpace,PolySpace)"

For the programmer
==================

The object isContained, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1105:0.

isGEQ -- compare two points
***************************

  * Usage:
        b = isGEQ(x,y)
  * Inputs:
      * x, a point,or a list of complex (floating point)
        numbers
      * y, a point,or a list of complex (floating point)
        numbers
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * b, tells if x is (approximately) greater or equal than y

Description
===========

The inputs are lists of complex numbers, the order is (approximately)
lexicographic: regard each complex n-vector as real 2n-vector, for the
corresponding coordinates a and b (of two real 2n-vectors) a < b if b-a is
larger than Tolerance (NumericalLinearAlgebra).

+---------------------------+
|i1 : isGEQ({1,1,1},{1,0,2})|
|                           |
|o1 = true                  |
+---------------------------+
|i2 : isGEQ({1,1e-7},{1, 0})|
|                           |
|o2 = true                  |
+---------------------------+

See also
========

  * areEqual -- determine if solutions are equal

Ways to use isGEQ:
==================

  * "isGEQ(AbstractPoint,AbstractPoint)"
  * "isGEQ(List,List)"

For the programmer
==================

The object isGEQ, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:184:0.

isRealPoint -- determine whether a point is real
************************************************

  * Usage:
        b = isRealPoint p
  * Inputs:
      * p
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * b, tells if p is within Tolerance (NumericalLinearAlgebra),
        to a real point

Description
===========

+-------------------------------------------------+
|i1 : needsPackage "NumericalAlgebraicGeometry"   |
|                                                 |
|o1 = NumericalAlgebraicGeometry                  |
|                                                 |
|o1 : Package                                     |
+-------------------------------------------------+
|i2 : R = CC[x,y];                                |
+-------------------------------------------------+
|i3 : sols = solveSystem{x^3-y^2, x-y-2}          |
|                                                 |
|o3 = {{1, -1}, {-2*ii, -2-2*ii}, {2*ii, -2+2*ii}}|
|                                                 |
|o3 : List                                        |
+-------------------------------------------------+
|i4 : sols / isRealPoint                          |
|                                                 |
|o4 = {true, false, false}                        |
|                                                 |
|o4 : List                                        |
+-------------------------------------------------+

Ways to use isRealPoint:
========================

  * "isRealPoint(AbstractPoint)"

For the programmer
==================

The object isRealPoint, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:245:0.

Norm -- p in the p-norm
***********************

Description
===========

Specifies p-norm, where p is either an integer (Macaulay2Doc), or
infinity (Macaulay2Doc),

Functions with optional argument named Norm:
============================================

  * "residual(...,Norm=>...)"

For the programmer
==================

The object Norm, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:166:0.

norm(Thing,AbstractPoint) -- p-norm of the point
************************************************

  * Function: norm (Macaulay2Doc),
  * Usage:
        a = norm(p,pt)
  * Inputs:
      * p, a thing (Macaulay2Doc), a positive real number or
        infinity (Macaulay2Doc),
      * pt, a point,
  * Outputs:
      * a, the p-norm of the point pt

Description
===========

+-----------------------------------------------------------------------------+
|i1 : needsPackage "NumericalAlgebraicGeometry"                               |
|                                                                             |
|o1 = NumericalAlgebraicGeometry                                              |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i3 : sols = solveSystem{x^2+y^2-3, x^3-y^3-7}                                |
|                                                                             |
|o3 = {{-.101284+.779159*ii, -1.89699-.041601*ii}, {1.89699+.041601*ii,       |
|     ------------------------------------------------------------------------|
|     .101284-.779159*ii}, {-1.7957-1.31322*ii, 1.7957-1.31322*ii},           |
|     ------------------------------------------------------------------------|
|     {1.89699-.041601*ii, .101284+.779159*ii}, {-1.7957+1.31322*ii,          |
|     ------------------------------------------------------------------------|
|     1.7957+1.31322*ii}, {-.101284-.779159*ii, -1.89699+.041601*ii}}         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : norm(infinity, first sols)                                              |
|                                                                             |
|o4 = 1.897443252529452                                                       |
|                                                                             |
|o4 : RR (of precision 53)                                                    |
+-----------------------------------------------------------------------------+
|i5 : norm(2.5, last sols)                                                    |
|                                                                             |
|o5 = 1.978570110375526                                                       |
|                                                                             |
|o5 : RR (of precision 53)                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * norm(Thing,AbstractPoint) -- p-norm
    of the point
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:280:0.

numericalAffineSpace -- affine space as a numerical variety
***********************************************************

  * Usage:
        numericalAffineSpace R
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * a numerical variety,

Description
===========

Constructs a numerical variety representing the complex affine space
corresponding to the given coordinate ring.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : V := numericalAffineSpace R                                             |
|                                                                             |
|o2 = a "numerical variety" with components in                                |
|     dim 2:  (dim=2,deg=1)                                                   |
|                                                                             |
|o2 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i3 : C := first components V                                                 |
|                                                                             |
|o3 = (dim=2,deg=1)                                                           |
|                                                                             |
|o3 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i4 : equations C                                                             |
|                                                                             |
|o4 = {}                                                                      |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : slice C                                                                 |
|                                                                             |
|o5 = {(.892712 + .673395*ii)x + (.0258884 + .714827*ii)y - .461944 -         |
|     ------------------------------------------------------------------------|
|     .775187*ii, (.29398 + .632944*ii)x + (.89189 + .231053*ii)y - .909047 - |
|     ------------------------------------------------------------------------|
|     .314897*ii}                                                             |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : points C                                                                |
|                                                                             |
|o6 = {{.364967-.0660072*ii, .826623-.098325*ii}}                             |
|                                                                             |
|o6 : VerticalList                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * NumericalVariety -- a numerical variety

Ways to use numericalAffineSpace:
=================================

  * "numericalAffineSpace(PolynomialRing)"

For the programmer
==================

The object numericalAffineSpace, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:789:0.

NumericalVariety -- a numerical variety
***************************************

Description
===========

This type stores a collection of witness sets representing a complex affine
variety.

Note that
  * The ambient space is expected to be the same, i.e., see dimension,
    (or ProjectionDimension) of witness sets,
    should be the same.
  * The constructor numericalVariety(List),
    does not check the sensibility of the input; run
    check(NumericalVariety), to verify the validity of a
    numerical variety.
Basic service routines:
  * dim -- the dimension
  * codim -- the codimension
  * deg -- the degree
  * components(NumericalVariety)
+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]; I = ideal((x^2+y^2+2)*x,(x^2+y^2+2)*y*(y-1));              |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : w1 := witnessSet(I , ideal(x-y), {point {{0.999*ii,0.999*ii}}, point    |
|                                                                             |
|o3 = [dim=1,deg=2]-*may be reducible*-                                       |
|                                                                             |
|o3 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|{{-1.001*ii,-1.001*ii}}} )                                                   |
+-----------------------------------------------------------------------------+
|i4 : w0 := witnessSet(I, ideal R, {point {{0.,0.}}})                         |
|                                                                             |
|o4 = [dim=0,deg=1]-*may be reducible*-                                       |
|                                                                             |
|o4 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i5 : w0' := witnessSet(I, ideal R, {point {{0.,1.}}})                        |
|                                                                             |
|o5 = [dim=0,deg=1]-*may be reducible*-                                       |
|                                                                             |
|o5 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i6 : V := numericalVariety {w0,w1,w0'}                                       |
|                                                                             |
|o6 = a "numerical variety" with components in                                |
|     dim 0:  [dim=0,deg=1]-*may be reducible*- [dim=0,deg=1]-*may be         |
|     dim 1:  [dim=1,deg=2]-*may be reducible*-                               |
|                                                                             |
|o6 : NumericalVariety                                                        |
|-----------------------------------------------------------------------------|
|reducible*-                                                                  |
+-----------------------------------------------------------------------------+
|i7 : dim V                                                                   |
|                                                                             |
|o7 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i8 : degree V                                                                |
|                                                                             |
|o8 = 2                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * WitnessSet -- a witness set

Functions and methods returning a numerical variety:
====================================================

  * NumericalVariety | NumericalVariety (missing documentation)
  * "numericalVariety" -- see numericalVariety(List),
    -- construct a numerical variety
  * union(NumericalVariety,NumericalVariety) (missing documentation)

Methods that use a numerical variety:
=====================================

  * components(NumericalVariety), --
    list components of a numerical variety
  * "components(NumericalVariety,ZZ)" -- see
    components(NumericalVariety), -- list
    components of a numerical variety
  * "components(NumericalVariety,ZZ,InfiniteNumber)" -- see
    components(NumericalVariety), -- list
    components of a numerical variety
  * "components(NumericalVariety,ZZ,ZZ)" -- see
    components(NumericalVariety), -- list
    components of a numerical variety
  * isSubset(NumericalVariety,NumericalVariety) (missing documentation)
  * isSubset(WitnessSet,NumericalVariety) (missing documentation)
  * "check(NumericalVariety)"
  * "degree(NumericalVariety)"
  * "dim(NumericalVariety)"
  * "net(NumericalVariety)"
  * NumericalVariety == NumericalVariety (missing documentation)

For the programmer
==================

The object NumericalVariety, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:720:0.

numericalVariety(List) -- construct a numerical variety
*******************************************************

  * Function: numericalVariety,
  * Usage:
        V = numericalVariety Ws; V = projectiveNumericalVariety Ws;
  * Inputs:
      * Ws, a list (Macaulay2Doc), contains (projective) witness
        sets representing components of a variety
  * Outputs:
      * V, a numerical variety,

Description
===========

Constructs a numerical (affine or projective) variety. It is NOT expected that
every witness set W in the list Ws has the same W.Equations.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]; I = ideal((x^2+y^2+2)*x,(x^2+y^2+2)*y);                    |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : w1 = witnessSet(I , ideal(x-y), {point {{0.999999*ii,0.999999*ii}},     |
|                                                                             |
|o3 = w1                                                                      |
|                                                                             |
|o3 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|point {{-1.000001*ii,-1.000001*ii}}} )                                       |
+-----------------------------------------------------------------------------+
|i4 : w0 = witnessSet(I, ideal R, {point {{0.,0.}}})                          |
|                                                                             |
|o4 = w0                                                                      |
|                                                                             |
|o4 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i5 : V = numericalVariety {w0,w1}                                            |
|                                                                             |
|o5 = V                                                                       |
|                                                                             |
|o5 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * WitnessSet -- a witness set
  * ProjectiveWitnessSet -- a projective witness
    set
  * numericalAffineSpace -- affine space as a
    numerical variety

Ways to use this method:
========================

  * numericalVariety(List) -- construct a
    numerical variety
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:738:0.

point -- construct a Point
**************************

  * Usage:
        p = point c
  * Inputs:
      * c, a list (Macaulay2Doc),containing  elements in the form
        {{list of complex coordinates}, other data} or a matrix (Macaulay2Doc),
        (only coordinates) or a point,
        or a cache table (Macaulay2Doc),
  * Outputs:
      * p, an instance of the type Point,

Description
===========

+-----------------------------------------------------------------------------+
|i1 : p := point {{1+0.2*ii, 0.5}, SolutionStatus=>Regular, LastT=>1.,        |
|                                                                             |
|o1 = {1+.2*ii, .5}                                                           |
|                                                                             |
|o1 : Point                                                                   |
|-----------------------------------------------------------------------------|
|NumberOfSteps=>10, ConditionNumber=>2.3}                                     |
+-----------------------------------------------------------------------------+
|i2 : peek p.cache                                                            |
|                                                                             |
|o2 = CacheTable{ConditionNumber => 2.3   }                                   |
|                LastT => 1                                                   |
|                NumberOfSteps => 10                                          |
|                SolutionStatus => Regular                                    |
+-----------------------------------------------------------------------------+
|i3 : q := point p                                                            |
|                                                                             |
|o3 = {1+.2*ii, .5}                                                           |
|                                                                             |
|o3 : Point                                                                   |
+-----------------------------------------------------------------------------+

Ways to use point:
==================

  * "point(DualSpace)" -- see DualSpace, -- a dual functional
    vector subspace
  * "point(AbstractPoint)"
  * "point(List)"
  * "point(List,CacheTable)"
  * "point(Matrix)"

For the programmer
==================

The object point, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:120:0.

PolySpace -- a polynomial vector subspace
*****************************************

Description
===========

This type stores a finite dimensional vector subspace of a polynomial ring,
given by a spanning set. The spanning set is generally assumed to be a basis
although this is not enforced. The following methods can be used to access a
PolySpace:

  * gens -- a one-row matrix of the generators
  * dim -- the number of generators
  * ring -- the ring of the generators

See also
========

  * polySpace -- construct a PolySpace
  * DualSpace -- a dual functional vector subspace

Functions and methods returning an object of class PolySpace:
=============================================================

  * addition -- Union of polynomial spaces
  * intersect(PolySpace,PolySpace),
    -- Intersection of polynomial spaces

Methods that use an object of class PolySpace:
==============================================

  * "addition(PolySpace,PolySpace)" -- see addition, -- Union
    of polynomial spaces
  * areEqual(PolySpace,PolySpace),
    -- approximate equality of subspaces spanned by polynomials
  * "dualSpace(PolySpace,AbstractPoint)" -- see dualSpace, --
    construct a DualSpace
  * "isContained(PolySpace,PolySpace)" -- see isContained,
    -- Is one space contained in the other
  * "dim(PolySpace)"
  * "generators(PolySpace)"
  * "net(PolySpace)"
  * "ring(PolySpace)"
  * "polySpace(PolySpace)" -- see polySpace, -- construct a
    PolySpace
  * random(PolySpace) -- random element of a
    subspace
  * "random(ZZ,PolySpace)" -- see random(PolySpace),
    -- random element of a subspace
  * "reduceSpace(PolySpace)" -- see reduceSpace, -- reduce
    the generators of a space

For the programmer
==================

The object PolySpace, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:857:0.

polySpace -- construct a PolySpace
**********************************

  * Usage:
        S = polySpace M
  * Inputs:
      * M, a matrix (Macaulay2Doc), with one row of generators
  * Optional inputs (Macaulay2Doc),:
      * Reduced => ..., default value false
  * Outputs:
      * S, an instance of the type PolySpace,

Description
===========

Used to construct a finite dimensional vector subspace of a polynomial ring.

+-------------------------------+
|i1 : R = CC[x,y];              |
+-------------------------------+
|i2 : M = matrix{{y^2,x^2+x*y}};|
|                               |
|             1      2          |
|o2 : Matrix R  <-- R           |
+-------------------------------+
|i3 : S = polySpace M           |
|                               |
|o3 = | y2 x2+xy |              |
|                               |
|o3 : PolySpace                 |
+-------------------------------+

Ways to use polySpace:
======================

  * "polySpace(Matrix)"
  * "polySpace(PolySpace)"

For the programmer
==================

The object polySpace, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:882:0.

PolySystem -- a polynomial system
*********************************

Description
===========

This type stores a polynomial system, the following methods can be used to
access a PolySystem:
  * ideal -- the ideal generated by the system
  * equations -- the list of polynomials in the system
  * ring -- the ring containing the polynomials
  * jacobian -- the jacobian of the polynomial map
  * parameters -- the list of parameter variables (if any)
Only polynomials are displayed (by net (Macaulay2Doc)); to see the
data stored in a witness set use peek (Macaulay2Doc).

For developers:
===============

Required entries in a PolySystem, are
  * NumberOfVariables of type ZZ (Macaulay2Doc),
  * NumberOfPolys of type ZZ (Macaulay2Doc),
  * PolyMap of type Matrix (Macaulay2Doc), a column matrix over a
    polynomial ring
  * Jacobian of type Matrix (Macaulay2Doc), the jacobian of
    PolyMap
+----------------------------------------+
|i1 : CC[x,y]                            |
|                                        |
|o1 = CC  [x..y]                         |
|       53                               |
|                                        |
|o1 : PolynomialRing                     |
+----------------------------------------+
|i2 : S = polySystem {x^2+y^2-6, 2*x^2-y}|
|                                        |
|o2 = S                                  |
|                                        |
|o2 : PolySystem                         |
+----------------------------------------+
|i3 : p = point {{1.0+3*ii,2.3+ii}};     |
+----------------------------------------+
|i4 : evaluate(S,p)                      |
|                                        |
|o4 = | -9.71+10.6ii |                   |
|     | -18.3+11ii   |                   |
|                                        |
|                2         1             |
|o4 : Matrix CC    <-- CC                |
|              53        53              |
+----------------------------------------+
|i5 : evaluate(jacobian S, p)            |
|                                        |
|o5 = | 2+6ii  4.6+2ii |                 |
|     | 4+12ii -1      |                 |
|                                        |
|                2         2             |
|o5 : Matrix CC    <-- CC                |
|              53        53              |
+----------------------------------------+

Basic service functions:

  * polySystem -- construct a polynomial system
  * evaluate -- evaluate a polynomial system or matrix at a
    point

See also
========

  * WitnessSet -- a witness set

Methods that use a polynomial system:
=====================================

  * "evaluate(PolySystem,Matrix)" -- see evaluate, -- evaluate
    a polynomial system or matrix at a point
  * "evaluateJacobian(PolySystem,AbstractPoint)" -- see evaluate,
    -- evaluate a polynomial system or matrix at a point
  * homogenize(PolySystem,Ring,RingElement)
    -- homogenize a polynomial
    system
  * "equations(PolySystem)"
  * "ideal(PolySystem)"
  * "isHomogeneous(PolySystem)"
  * "jacobian(PolySystem)"
  * "net(PolySystem)"
  * "numFunctions(PolySystem)"
  * "numParameters(PolySystem)"
  * "numVariables(PolySystem)"
  * "parameters(PolySystem)"
  * "ring(PolySystem)"
  * "polySystem(PolySystem)" -- see polySystem, -- construct
    a polynomial system
  * substitute(PolySystem,Ring), --
    substitute a ring in a polynomial system
  * "witnessSet(PolySystem,Matrix,List)" -- see witnessSet,
    -- construct a WitnessSet
  * "witnessSet(PolySystem,PolySystem,List)" -- see witnessSet,
    -- construct a WitnessSet

For the programmer
==================

The object PolySystem, is a type (Macaulay2Doc),
with ancestor classes System, < MutableHashTable (Macaulay2Doc)
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:396:0.

polySystem -- construct a polynomial system
*******************************************

  * Usage:
        P = polysystem F
  * Inputs:
      * F, a list (Macaulay2Doc), or an ideal (Macaulay2Doc),
        or a matrix (Macaulay2Doc), (column
        matrix) with polynomial entries or a polynomial system,
  * Outputs:
      * P, a polynomial system,

Description
===========

Constructs a PolySystem, from the given polynomials.

+-----------------------------------------------------------+
|i1 : R = CC[x,y]; S := polySystem {x^2+y^2-6, 2*x^2-y}     |
|                                                           |
|o2 = {-2} | x2+y2-6 |                                      |
|     {-2} | 2x2-y   |                                      |
|                                                           |
|o2 : PolySystem                                            |
+-----------------------------------------------------------+
|i3 : S = polySystem transpose matrix {{x^2+y^2-6, 2*x^2-y}}|
|                                                           |
|o3 = {-2} | x2+y2-6 |                                      |
|     {-2} | 2x2-y   |                                      |
|                                                           |
|o3 : PolySystem                                            |
+-----------------------------------------------------------+
|i4 : T = polySystem S                                      |
|                                                           |
|o4 = T                                                     |
|                                                           |
|o4 : PolySystem                                            |
+-----------------------------------------------------------+

See also
========

  * PolySystem -- a polynomial system

Ways to use polySystem:
=======================

  * "polySystem(Ideal)"
  * "polySystem(List)"
  * "polySystem(Matrix)"
  * "polySystem(PolySystem)"
  * polySystem(WitnessSet) (missing documentation)

For the programmer
==================

The object polySystem, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:462:0.

project(AbstractPoint,ZZ) -- project a point
********************************************

  * Function: project,
  * Usage:
        q = project(p,n)
  * Inputs:
      * p, a point,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * q, projection of p to the first n coordinates

Description
===========

Projects a point to the subspace corresponding to the first n coordinates.

+-----------------------------------------------------------------------------+
|i1 : p = point({{1+ii,2.3,2*ii}, ConditionNumber=>1000, ErrorBoundEstimate   |
|-----------------------------------------------------------------------------|
|=>0.01});                                                                    |
+-----------------------------------------------------------------------------+
|i2 : project(p,2)                                                            |
|                                                                             |
|o2 = {1+ii, 2.3}                                                             |
|                                                                             |
|o2 : Point                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * WitnessSet -- a witness set
  * ProjectionDimension -- a witness set

Ways to use this method:
========================

  * project(AbstractPoint,ZZ), --
    project a point
  * "project(Point,ZZ)"
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:324:0.

ProjectiveNumericalVariety -- a projective numerical variety
************************************************************

Description
===========

An object of this type stores a collection of projective witness sets,

See also
========

  * projectiveWitnessSet -- construct a
    ProjectiveWitnessSet

For the programmer
==================

The object ProjectiveNumericalVariety, is a
symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:796:0.

ProjectiveWitnessSet -- a projective witness set
************************************************

Description
===========

This type stores a witness set of an equidimensional projective solution
component.

See also
========

  * WitnessSet -- a witness set
  * projectiveWitnessSet -- construct a
    ProjectiveWitnessSet

Functions and methods returning an object of class ProjectiveWitnessSet:
========================================================================

  * projectiveWitnessSet -- construct a
    ProjectiveWitnessSet

For the programmer
==================

The object ProjectiveWitnessSet, is a type (Macaulay2Doc),
with ancestor classes WitnessSet, <
WSet < HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:621:0.

projectiveWitnessSet -- construct a ProjectiveWitnessSet
********************************************************

  * Usage:
        w = projectiveWitnessSet(E,C,S,P)
  * Inputs:
      * E, an ideal (Macaulay2Doc), in a polynomial ring over
        CC (Macaulay2Doc),
      * C, a matrix (Macaulay2Doc), in a polynomial ring over
        CC (Macaulay2Doc),
      * S, a matrix (Macaulay2Doc),  complex coefficients of a
        linear system
      * P, a list (Macaulay2Doc), contains witness points (of type
        AbstractPoint)
  * Outputs:
      * w, an instance of the type ProjectiveWitnessSet,

Description
===========

Used to construct a witness set for a component of the variety V(E).  An affine
chart is specified by the matrix of the coefficients of the (normalized) linear
equation defining the chart: e.g., ax+by+cz=1 is encoded as [a,b,c].

It is expected that the, V(E) and the plane V(S) defined by S are of
complementary dimensions and that P is contained in the intersection of V(E+C)
and V(S).

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : w = projectiveWitnessSet( ideal(x^2+y^2+2*z^2), matrix{{0,0,1}},        |
|                                                                             |
|o2 = w                                                                       |
|                                                                             |
|o2 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|matrix{{1,-1,0}}, {point {{0.999999*ii,0.999999*ii,1.}}, point {{            |
|-----------------------------------------------------------------------------|
|-1.000001*ii,-1.000001*ii,1.}}} )                                            |
+-----------------------------------------------------------------------------+
|i3 : peek w                                                                  |
|                                                                             |
|o3 = WitnessSet{AffineChart => | 0 0 1 |               }                     |
|                cache => CacheTable{...1...}                                 |
|                Points => {{.999999*ii, .999999*ii, 1}}                      |
|                          {{-ii, -ii, 1}              }                      |
|                Slice => | 1 -1 0 |                                          |
|                                    2    2     2                             |
|                Equations => ideal(x  + y  + 2z )                            |
+-----------------------------------------------------------------------------+

Ways to use projectiveWitnessSet:
=================================

  * "projectiveWitnessSet(Ideal,Matrix,Matrix,List)"

For the programmer
==================

The object projectiveWitnessSet, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:655:0.

random(PolySpace) -- random element of a subspace
*************************************************

  * Function: random (Macaulay2Doc),
  * Usage:
        f = random S
        f = random(d,S)
  * Inputs:
      * S, an instance of the type PolySpace, or an instance
        of the type DualSpace,
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (missing documentation) => ..., default value null,
      * Density (Macaulay2Doc), => ...,
        default value 1,
      * Height (Macaulay2Doc), => ..., default
        value 10,
      * MaximalRank (Macaulay2Doc), => ...,
        default value false,
      * UpperTriangular (Macaulay2Doc), =>
        ..., default value false,
  * Outputs:
      * f, a ring element (Macaulay2Doc),

Description
===========

Provides a random element of a (finite dimensional) PolySpace,
or DualSpace, (of the given degree/order d).

Ways to use this method:
========================

  * "random(DualSpace)"
  * random(PolySpace) -- random element of a
    subspace
  * "random(ZZ,DualSpace)"
  * "random(ZZ,PolySpace)"
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1126:0.

realPoints -- select real points
********************************

  * Usage:
        R = realPoints L
  * Inputs:
      * L, see points,
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * R, see points, that are real (up to Tolerance (NumericalLinearAlgebra))

Description
===========

Selects real points from a list of points using the function isRealPoint.

+-----------------------------------------------------------------------------+
|i1 : needsPackage "NumericalAlgebraicGeometry"                               |
|                                                                             |
|o1 = NumericalAlgebraicGeometry                                              |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i3 : sols = solveSystem{x^6-y^4, x-y-2}                                      |
|                                                                             |
|o3 = {{-2*ii, -2-2*ii}, {.937565-.715691*ii, -1.06244-.715691*ii},           |
|     ------------------------------------------------------------------------|
|     {.937565+.715691*ii, -1.06244+.715691*ii}, {-2.87513, -4.87513}, {1,    |
|     ------------------------------------------------------------------------|
|     -1}, {2*ii, -2+2*ii}}                                                   |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : realPoints sols                                                         |
|                                                                             |
|o4 = {{-2.87513, -4.87513}, {1, -1}}                                         |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * realPoints -- select real points

Ways to use realPoints:
=======================

  * "realPoints(List)"

For the programmer
==================

The object realPoints, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:262:0.

reduceSpace -- reduce the generators of a space
***********************************************

  * Usage:
        S = reduceSpace T
  * Inputs:
      * T, an instance of the type DualSpace, or an instance
        of the type PolySpace,
  * Optional inputs (Macaulay2Doc),:
      * Monomials => ..., default value null
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * S, an instance of the type DualSpace, or an instance
        of the type PolySpace,

Description
===========

Reduces the generators of a DualSpace or PolySpace so that the new generators
are linearly independent, and each has a distinct lead monomial.  This is
achieved by Gaussian reduction.

+------------------------------------------+
|i1 : R = CC[x,y];                         |
+------------------------------------------+
|i2 : T = polySpace matrix{{x,y,x-y+1e-10}}|
|                                          |
|o2 = | x y x-y+1e-10 |                    |
|                                          |
|o2 : PolySpace                            |
+------------------------------------------+
|i3 : S = reduceSpace T                    |
|                                          |
|o3 = | x y |                              |
|                                          |
|o3 : PolySpace                            |
+------------------------------------------+
|i4 : S = reduceSpace(T, Tolerance=>1e-12) |
|                                          |
|o4 = | x y 1 |                            |
|                                          |
|o4 : PolySpace                            |
+------------------------------------------+

Ways to use reduceSpace:
========================

  * "reduceSpace(DualSpace)"
  * "reduceSpace(PolySpace)"

For the programmer
==================

The object reduceSpace, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1081:0.

residual -- residual of a polynomial function at a point
********************************************************

  * Usage:
        y = residual(f,x)
  * Inputs:
      * f, a polynomial system, or a matrix (Macaulay2Doc),
      * x, a point, or a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Norm, => ..., default value 2, p in the p-norm
  * Outputs:
      * y, the norm of f(x)

Description
===========

Evaluates a PolySystem, or a matrix with polynomial entries
at a point and returns the norm of the result.

+------------------------------------------------------+
|i1 : R = CC[x,y]; S = polySystem {x^2+y^2-5, 2*x^2-y};|
+------------------------------------------------------+
|i3 : p = point {{1.001-0.0001*ii,2.+0.0001*ii}};      |
+------------------------------------------------------+
|i4 : evaluate(S,p)                                    |
|                                                      |
|o4 = | .00200098+.0001998ii |                         |
|     | .00400198-.0005004ii |                         |
|                                                      |
|                2         1                           |
|o4 : Matrix CC    <-- CC                              |
|              53        53                            |
+------------------------------------------------------+
|i5 : residual(S,p)                                    |
|                                                      |
|o5 = .0045066711751354                                |
|                                                      |
|o5 : RR (of precision 53)                             |
+------------------------------------------------------+
|i6 : residual(S,p,Norm=>3)                            |
|                                                      |
|o6 = .004193337404122793                              |
|                                                      |
|o6 : RR (of precision 53)                             |
+------------------------------------------------------+
|i7 : residual(S,p,Norm=>infinity)                     |
|                                                      |
|o7 = .00403314320107731                               |
|                                                      |
|o7 : RR (of precision 53)                             |
+------------------------------------------------------+

See also
========

  * PolySystem -- a polynomial system

Ways to use residual:
=====================

  * "residual(List,Point)"
  * "residual(Matrix,Matrix)"
  * "residual(System,AbstractPoint)"
  * "residual(System,Point)"

For the programmer
==================

The object residual, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:444:0.

sliceEquations(Matrix,Ring) -- slicing linear functions
*******************************************************

  * Function: sliceEquations,
  * Usage:
        S = sliceEquations(M,R)
        S = projectiveSliceEquations(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc),  contains the coefficients of
        the slicing linear polynomials
      * R, a ring (Macaulay2Doc),  where the output polynomials
        belong
  * Outputs:
      * S, a list (Macaulay2Doc), contains linear polynomials

Description
===========

A service function used  in NumericalAlgebraicGeometry.

+--------------------------------------------------------------------+
|i1 : R = CC[x,y]                                                    |
|                                                                    |
|o1 = R                                                              |
|                                                                    |
|o1 : PolynomialRing                                                 |
+--------------------------------------------------------------------+
|i2 : sliceEquations(matrix{{1,2,3},{4,5,6*ii}}, R)                  |
|                                                                    |
|o2 = {x + 2y + 3, 4x + 5y + 6*ii}                                   |
|                                                                    |
|o2 : List                                                           |
+--------------------------------------------------------------------+
|i3 : projectiveSliceEquations(matrix{{1,2,3},{4,5,6*ii}}, CC[x,y,z])|
|                                                                    |
|o3 = {x + 2y + 3z, 4x + 5y + 6*ii*z}                                |
|                                                                    |
|o3 : List                                                           |
+--------------------------------------------------------------------+

Ways to use this method:
========================

  * sliceEquations(Matrix,Ring), --
    slicing linear functions
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:684:0.

solutionsWithMultiplicity -- replaces clusters of approximately equal points by single points with multiplicity
***************************************************************************************************************

  * Usage:
        M = solutionsWithMultiplicity S
  * Inputs:
      * S, see points,
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
  * Outputs:
      * M, see points, with a multiplicity field

Description
===========

Clusters the points and outputs a list with one point p per cluster with
p.Multiplicity, equal to the size of the cluster. If the
multiplicity is not 1, then p.See SolutionStatus, is set to
Singular,; otherwise, it is inherited from one of the
points in the cluster.

Whether two points are approximately equal is decided by the function
areEqual, that depends on Tolerance (NumericalLinearAlgebra).

+-----------------------------------------------------------------------------+
|i1 : a = point {{0,1}}                                                       |
|                                                                             |
|o1 = a                                                                       |
|                                                                             |
|o1 : Point                                                                   |
+-----------------------------------------------------------------------------+
|i2 : b = point {{0.000000001,1+0.00000000001*ii}}                            |
|                                                                             |
|o2 = b                                                                       |
|                                                                             |
|o2 : Point                                                                   |
+-----------------------------------------------------------------------------+
|i3 : c = point {{0.001*ii,1}}                                                |
|                                                                             |
|o3 = c                                                                       |
|                                                                             |
|o3 : Point                                                                   |
+-----------------------------------------------------------------------------+
|i4 : M = solutionsWithMultiplicity {a,b,c}                                   |
|                                                                             |
|o4 = {a, c}                                                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : peek M                                                                  |
|                                                                             |
|o5 = {Point{cache => CacheTable{...1...}},                                   |
|            Coordinates => {0, 1}                                            |
|     ------------------------------------------------------------------------|
|     Point{cache => CacheTable{...1...}}}                                    |
|           Coordinates => {.001*ii, 1}                                       |
+-----------------------------------------------------------------------------+

Caveat
======

A point in a cluster may be farther than Tolerance (NumericalLinearAlgebra),
from another point in the cluster. (In that
case there has to be another point in the cluster that is within the
Tolerance (NumericalLinearAlgebra).)

Ways to use solutionsWithMultiplicity:
======================================

  * "solutionsWithMultiplicity(List)"

For the programmer
==================

The object solutionsWithMultiplicity, is a
method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:304:0.

sortSolutions(...,Tolerance=>...) -- the tolerance of a numerical computation
*****************************************************************************

Functions with optional argument named Tolerance:
=================================================

  * "addition(...,Tolerance=>...)" -- see addition, -- Union of
    polynomial spaces
  * "intersect(PolySpace,PolySpace,Tolerance=>...)" -- see
    intersect(PolySpace,PolySpace), --
    Intersection of polynomial spaces
  * "isContained(...,Tolerance=>...)" -- see isContained, --
    Is one space contained in the other
  * "areEqual(...,Tolerance=>...)"
  * "differencePointSet(...,Tolerance=>...)"
  * "isGEQ(...,Tolerance=>...)"
  * "isRealPoint(...,Tolerance=>...)"
  * "realPoints(...,Tolerance=>...)"
  * "reduceSpace(...,Tolerance=>...)"
  * "solutionsWithMultiplicity(...,Tolerance=>...)"
  * sortSolutions(...,Tolerance=>...)
    -- the tolerance of a
    numerical computation
  * "unionPointSet(...,Tolerance=>...)"
  * "colReduce(...,Tolerance=>...)" -- see
    Tolerance(NumericalLinearAlgebra) (NumericalLinearAlgebra),
    -- the
    tolerance of a numerical computation
  * "numericalImage(...,Tolerance=>...)" -- see
    Tolerance(NumericalLinearAlgebra) (NumericalLinearAlgebra),
    -- the
    tolerance of a numerical computation
  * "numericalKernel(...,Tolerance=>...)" -- see
    Tolerance(NumericalLinearAlgebra) (NumericalLinearAlgebra),
    -- the
    tolerance of a numerical computation

Further information
===================

  * Default value: .000001
  * Function: sortSolutions, -- sort the list of
    solutions
  * Option key: Tolerance (NumericalLinearAlgebra), -- the
    tolerance of a numerical computation
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:159:0.

sortSolutions(List) -- sort the list of solutions
*************************************************

  * Function: sortSolutions,
  * Usage:
        t = sortSolutions s
  * Inputs:
      * s, a list (Macaulay2Doc), contains solutions (represented
        either by lists of coordinates or points)
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value .000001, the tolerance of a numerical computation
      * Weights => ..., default value null
  * Outputs:
      * t, a list (Macaulay2Doc), contains solutions sorted as
        described below

Description
===========

The sorting is done lexicographically regarding each complex n-vector as real
2n-vector. The output format of track (NumericalAlgebraicGeometry),
and
solveSystem (NumericalAlgebraicGeometry), is respected.
For the corresponding coordinates a and b (of two real 2n-vectors) a < b if b-a
is larger than Tolerance (NumericalLinearAlgebra).

+-----------------------------------------------------------------------------+
|i1 : needsPackage "NumericalAlgebraicGeometry"                               |
|                                                                             |
|o1 = NumericalAlgebraicGeometry                                              |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i3 : s = solveSystem {x^2+y^2-1, x*y}                                        |
|                                                                             |
|o3 = {{1, 8.30314e-21+4.44918e-20*ii}, {3.02251e-20+2.05294e-20*ii, -1},     |
|     ------------------------------------------------------------------------|
|     {-3.02251e-20-2.05294e-20*ii, 1}, {-1, -8.30314e-21-4.44918e-20*ii}}    |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : sortSolutions s                                                         |
|                                                                             |
|o4 = {{-1, -8.30314e-21-4.44918e-20*ii}, {3.02251e-20+2.05294e-20*ii, -1},   |
|     ------------------------------------------------------------------------|
|     {-3.02251e-20-2.05294e-20*ii, 1}, {1, 8.30314e-21+4.44918e-20*ii}}      |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The sorting described above does not possess good properties, since there may
be near ties in specific coordinate values between several points. A better way
is to specify a random weight (of length 2n where n=#points) as an optional
parameter sortSolutions(...,Weights=>...),
which provides a linear functional that evaluates to distinct (and
sufficiently) real numbers on the given points.

See also
========

  * solveSystem (NumericalAlgebraicGeometry), --
    solve a system of polynomial equations
  * track (NumericalAlgebraicGeometry), --
    track a linear segment homotopy given start and target system
  * areEqual -- determine if solutions are equal

Ways to use this method:
========================

  * sortSolutions(List) -- sort the list of
    solutions
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:145:0.

substitute(PolySystem,Ring) -- substitute a ring in a polynomial system
***********************************************************************

  * Function: substitute (Macaulay2Doc),
  * Usage:
        G = sub(F,R)
  * Inputs:
      * F, a polynomial system,
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * G, a polynomial system,

Description
===========

Constructs a polynomial system, by attempting to map
polynomials of a given system to a given ring.

+------------------------------------------------------+
|i1 : R = QQ[x,y]; S := polySystem {x^2+y^2-6, 2*x^2-y}|
|                                                      |
|o2 = {-2} | x2+y2-6 |                                 |
|     {-2} | 2x2-y   |                                 |
|                                                      |
|o2 : PolySystem                                       |
+------------------------------------------------------+
|i3 : T := sub(S,CC[x,y])                              |
|                                                      |
|o3 = {-2} | x2+y2-6 |                                 |
|     {-2} | 2x2-y   |                                 |
|                                                      |
|o3 : PolySystem                                       |
+------------------------------------------------------+
|i4 : ring T                                           |
|                                                      |
|o4 = CC  [x..y]                                       |
|       53                                             |
|                                                      |
|o4 : PolynomialRing                                   |
+------------------------------------------------------+

See also
========

  * polySystem -- construct a polynomial system
  * PolySystem -- a polynomial system

Ways to use this method:
========================

  * substitute(PolySystem,Ring), --
    substitute a ring in a polynomial system
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:482:0.

System -- a system of functions
*******************************

Description
===========

A type that inherits from this abstract type should supply methods for
evaluating a map that takes numVariables, (+ See numParameters,
if the system is parametric) inputs and produces numFunctions,
outputs and its jacobian.

Note for developers: it suffices to override the versions of evaluate,
and evaluateJacobian, that take (System,Matrix,Matrix)
as arguments.

See also
========

  * PolySystem -- a polynomial system

Types of System:
================

  * PolySystem -- a polynomial system

Methods that use an object of class System:
===========================================

  * "residual(System,AbstractPoint)" -- see residual, --
    residual of a polynomial function at a point
  * "residual(System,Point)" -- see residual, -- residual of a
    polynomial function at a point
  * "evaluate(System,AbstractPoint)"
  * "evaluate(System,AbstractPoint,AbstractPoint)"
  * "evaluate(System,Matrix)"
  * "evaluate(System,Matrix,Matrix)"
  * "evaluateJacobian(System,AbstractPoint)"
  * "evaluateJacobian(System,AbstractPoint,AbstractPoint)"
  * "evaluateJacobian(System,Matrix)"
  * "evaluateJacobian(System,Matrix,Matrix)"
  * "numFunctions(System)"
  * "numParameters(System)"
  * "numVariables(System)"

For the programmer
==================

The object System, is a type (Macaulay2Doc), with
ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1016:0.

toAffineChart(ZZ,List) -- coordinates of a point in the projective space in an affine chart
*******************************************************************************************

  * Function: toAffineChart,
  * Usage:
        y = toAffineChart(i,x)
  * Inputs:
      * i, an integer (Macaulay2Doc), the number of the standard
        chart
      * x, a list (Macaulay2Doc), projective coordinates of a point
  * Outputs:
      * y, a list (Macaulay2Doc), coordinates of x in the i-th
        affine chart

Description
===========

+------------------------------------+
|i1 : toAffineChart(2,{1,2,3,4,5,6}) |
|                                    |
|      1  2  4  5                    |
|o1 = {-, -, -, -, 2}                |
|      3  3  3  3                    |
|                                    |
|o1 : List                           |
+------------------------------------+
|i2 : toAffineChart(2,{1,2,0,4,5,6}) |
|                                    |
|o2 = infinity                       |
|                                    |
|o2 : InfiniteNumber                 |
+------------------------------------+

Caveat
======

Returns infinity if the i-th coordinate of x is zero.

See also
========

  * areEqual -- determine if solutions are equal

Ways to use this method:
========================

  * toAffineChart(ZZ,List) -- coordinates
    of a point in the projective space in an affine chart
-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:341:0.

WitnessSet -- a witness set
***************************

Description
===========

This type stores a witness set of an equidimensional solution component. The
following methods can be used to access a WitnessSet,:
  * ideal -- get the defining ideal of the algebraic superset
  * equations -- get the list of defining polynomials of the algebraic superset
  * slice -- get linear functions defining the slicing plane
  * points -- get the list of witness points (which are zeroes of all above)
Also one may determine
  * dim -- the dimension
  * codim -- the codimension
  * deg -- the degree (the number of witness points)
  * ring -- the ring of the defining polynomials
Only dimension and degree are displayed (by net (Macaulay2Doc)); to
see the data stored in a witness set use peek (Macaulay2Doc).

For developers:
===============

Required keys in a WitnessSet, are
  * Equations -- an ideal (Macaulay2Doc),
  * Slice -- a list (Macaulay2Doc), or a matrix (Macaulay2Doc),
  * Points--  a list of points,
  * cache.IsIrreducible -- takes values null (Macaulay2Doc),(not
    determined), see true (Macaulay2Doc), or false (Macaulay2Doc),
Optional keys:
  * ProjectionDimension -- an integer (Macaulay2Doc), the witness set
    describes a lifted variety (its projection on the first ProjectionDimension
    coordinates is the variety the witness set represents)

See also
========

  * witnessSet -- construct a WitnessSet
  * ProjectiveWitnessSet -- a projective witness
    set
  * NumericalVariety -- a numerical variety
  * declareIrreducible -- declares a component
    represented by the witness set irreducible

Types of witness set:
=====================

  * ProjectiveWitnessSet -- a projective witness
    set

Functions and methods returning a witness set:
==============================================

  * witnessSet -- construct a WitnessSet

Methods that use a witness set:
===============================

  * check(WitnessSet) (missing documentation)
  * "declareIrreducible(WitnessSet)" -- see declareIrreducible,
    -- declares a component represented by the witness set
    irreducible
  * decompose(WitnessSet) (missing documentation)
  * "generalEquations(WitnessSet)" -- see generalEquations,
    -- random linear combinations of equations/generators
  * isSubset(WitnessSet,NumericalVariety) (missing documentation)
  * isSubset(WitnessSet,WitnessSet) (missing documentation)
  * polySystem(WitnessSet) (missing documentation)
  * random(WitnessSet) (missing documentation)
  * "codim(WitnessSet)"
  * "degree(WitnessSet)"
  * "dim(WitnessSet)"
  * "equations(WitnessSet)"
  * "ideal(WitnessSet)"
  * "net(WitnessSet)"
  * "points(WitnessSet)"
  * "ring(WitnessSet)"
  * "slice(WitnessSet)"
  * WitnessSet - WitnessSet (missing documentation)
  * WitnessSet == WitnessSet (missing documentation)

For the programmer
==================

The object WitnessSet, is a type (Macaulay2Doc),
with ancestor classes WSet, < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:590:0.

witnessSet -- construct a WitnessSet
************************************

  * Usage:
        w = witnessSet(E,S,P)
  * Inputs:
      * E, an ideal (Macaulay2Doc), or a polynomial system,
      * S, an ideal (Macaulay2Doc), generated by linear polynomials
        (or a polynomial system, of the generators or a
        matrix (Macaulay2Doc), of their coefficients)
      * P, a list (Macaulay2Doc), contains witness points (of type
        AbstractPoint)
  * Outputs:
      * w, a witness set,

Description
===========

Used to construct a witness set of a component of the variety V(E). It is
expected that codim E == dim S and that P is a subset of the intersection of
V(E) and V(S).

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : w = witnessSet( ideal(x^2+y^2+2), ideal(x-y), {point                    |
|                                                                             |
|o2 = w                                                                       |
|                                                                             |
|o2 : WitnessSet                                                              |
|-----------------------------------------------------------------------------|
|{{0.999999*ii,0.999999*ii}}, point {{-1.000001*ii,-1.000001*ii}}} )          |
+-----------------------------------------------------------------------------+
|i3 : peek w                                                                  |
|                                                                             |
|o3 = WitnessSet{cache => CacheTable{...1...}        }                        |
|                Equations => {-2} | x2+y2+2 |                                |
|                Points => {{.999999*ii, .999999*ii}}                         |
|                          {{-ii, -ii}              }                         |
|                Slice => | 1 -1 0 |                                          |
+-----------------------------------------------------------------------------+

Ways to use witnessSet:
=======================

  * "witnessSet(Ideal,Ideal,List)"
  * "witnessSet(Ideal,Matrix,List)"
  * "witnessSet(PolySystem,Matrix,List)"
  * "witnessSet(PolySystem,PolySystem,List)"
  * witnessSet(Ideal,ZZ) (missing documentation)

For the programmer
==================

The object witnessSet, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:614:0.

WSet -- (under construction!) new types and methods needed to generalize WitnessSet
***********************************************************************************

Types of (abstract) witness set:
================================

  * WitnessSet -- a witness set

Methods that use a (abstract) witness set:
==========================================

  * "ambient(WSet)"
  * "codim(WSet)"
  * "degree(WSet)"
  * "dim(WSet)"
  * "net(WSet)"
  * "points(WSet)"

For the programmer
==================

The object WSet, is a type (Macaulay2Doc), with
ancestor classes HashTable (Macaulay2Doc), < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in NAGtypes/doc-NAGtypes.m2:1148:0.