Homotopies and Systems

straight_line_homotopy(F, G, x_vars; CCRing=AcbField(256), projective=false, gamma=nothing)
straight_line_homotopy(F, G, t; gamma=nothing)

Construct the straight-line homotopy

\[H(x,t) = (1 - t) \gamma G(x) + t F(x).\]

It accepts vectors of symbolic expressions F and G and the variable vector x_vars. It compiles the homotopy and returns an SpecializedHomotopy for track_path.

Options

• CCRing=AcbField(256): complex ball field used for parameter values and tracking.
• projective=false: homogenize and compile chart-based projective tracking.
• gamma=nothing: gamma-trick scalar. If omitted, a random complex scalar is used.

Example

@variables x y;
CC = AcbField(256);
F = [x^2 + 3y - 4, y^2 + 3];
G = [x^2 - 1, y^2 - 1];

H = straight_line_homotopy(F, G, [x, y]; CCRing=CC, gamma=CC(0.5, 0.5));
res = track_path(H, [CC(1), CC(-1)]);
solution(res)

compile_homotopy(H_eqs, x_vars, t_var; projective=false) -> CompiledHomotopy

Compile an explicitly given symbolic homotopy H_eqs(x, t).

Use this when you have already written the homotopy equations yourself. The returned CompiledHomotopy can be passed directly to track_path or certify_posteriori. The tracking precision is inferred from the ACB field of the starting point.

Complex numeric coefficients in H_eqs are internally parameterized and stored as fixed constants, so expressions such as (1 + im) * (x^3 - 1) work.

Options

• projective=false: homogenize in x_vars and compile coordinate-chart evaluators for projective tracking.

Example

@variables x y t;
gamma = 1 + im;
compiled = compile_homotopy([(1 - t) * gamma * (x^3 - 1) + t * (x^3 + 2y - 2),
                             (1 - t) * gamma * (y^2 - 1) + t * (y^2 + x - 2)],
                            [x, y], t);
CC = AcbField(256);
res = track_path(compiled, [CC(1), CC(1)])
success(res)
solution(res)

compile_system(F_eqs, x_vars; projective=false, const_vars=Num[]) -> CompiledHomotopy

Compile a static symbolic polynomial system F_eqs(x).

The result is used by variety_system and can also be evaluated through a SpecializedHomotopy with t = 0.

Options

• projective=false: homogenize in x_vars and compile projective chart evaluators.
• const_vars=Num[]: symbolic constants that should be supplied as fixed ACB values when constructing the SpecializedHomotopy.

Example

@variables x y;
CC = AcbField(128);
compiled = compile_system([x^2 + y^2 - 1], [x, y]);
sys = SpecializedHomotopy(compiled, CC);
evaluate_H(sys, [CC(1), CC(0)], CC(0))

compile_edge_homotopy(F_eqs, x_vars, p_vars; projective=false, const_vars=Num[]) -> CompiledHomotopy

Compile a parameter homotopy for a system F_eqs(x, p).

The compiled homotopy represents the linear parameter path from p_start to p_end. Specialize it with make_edge_system, or pass it directly to solve_monodromy.

Complex numeric coefficients in F_eqs are internally parameterized and stored as fixed constants, so expressions such as (1 + 2im) * x^2 work.

Options

• projective=false: homogenize in x_vars and use projective coordinate charts.
• const_vars=Num[]: symbolic constants that are not part of the moving parameter vector p_vars.

Example

@variables x y p q;
CC = AcbField(256);
F = [p*x^2 + 3y - 4, y^2 + q];
compiled = compile_edge_homotopy(F, [x, y], [p, q]);

p0 = [CC(1), CC(-1)];
p1 = [CC(cis(0.3)), CC(cis(0.7))];
sys = make_edge_system(compiled, p0, p1);
res = track_path(sys, [CC(1), CC(1)])
success(res)

make_edge_system(compiled, p_start, p_end, p_const=AcbFieldElem[]) -> SpecializedHomotopy

Specialize a CompiledHomotopy, usually from compile_edge_homotopy, to the linear parameter path from p_start to p_end.

p_const supplies fixed constants declared through const_vars or introduced internally for complex numeric coefficients.

Example

@variables x y p q;
CC = AcbField(256);
F = [p*x^2 + 3y - 4, y^2 + q];
compiled = compile_edge_homotopy(F, [x, y], [p, q]);
sys = make_edge_system(compiled, [CC(1), CC(-1)], [CC(cis(0.3)), CC(cis(0.7))]);
res = track_path(sys, [CC(1), CC(1)])
success(res)

SpecializedHomotopy

Tracking-ready homotopy used by track_path.

A SpecializedHomotopy combines a CompiledHomotopy, concrete start and target parameter values, fixed constants, an Arb/ACB precision, and projective chart state. It represents a homotopy ready for numerical evaluation.

Constructors:

SpecializedHomotopy(compiled, p_start, p_end, p_const=AcbFieldElem[]; source=compiled.source)
SpecializedHomotopy(compiled, CC::AcbField; source=compiled.source)

Prefer higher-level constructors when possible:

• straight_line_homotopy for direct start-target homotopies.
• track_path(compiled, x_start) for direct homotopies from compile_homotopy.
• make_edge_system for parameter homotopies from p_start to p_end.

CompiledHomotopy

Compiled evaluators for a homotopy or polynomial system.

Users usually obtain this from compile_homotopy, compile_system, or compile_edge_homotopy. Direct homotopies can be passed to track_path; parameter homotopies are specialized with make_edge_system before tracking.

Important fields:

• func_H, func_Jx, func_dt: compiled evaluators for H, dH/dx, and dH/dt.
• projective_coordinates: whether homogeneous coordinates are used.
• projective_patch: whether chart evaluators are available.
• n_vars: number of compiled variables, including the homogenizing coordinate for projective systems.
• source: optional HomotopySourceData for a posteriori certification.

HomotopySourceData

Metadata describing the symbolic source used to build a compiled homotopy.

This is stored in CompiledHomotopy and SpecializedHomotopy so that a posteriori certification can reconstruct a HomotopyContinuation.jl system. Most users do not construct this type directly.

Fields:

• kind: :direct, :edge, or :system.
• equations: symbolic equations after internal coefficient parameterization.
• variables: unknown variables.
• parameters: homotopy or system parameters.
• t_var: homotopy parameter for direct homotopies, or nothing.
• const_vars: symbolic constants treated as fixed parameters.
• projective: whether the source was compiled projectively.

evaluate_H(sys::SpecializedHomotopy, x, t)

Evaluate the specialized homotopy equations at point x and parameter t.

For projective systems compiled with coordinate charts, x may be either chart coordinates or full projective coordinates.

evaluate_Jac(sys::SpecializedHomotopy, x, t)

Evaluate the Jacobian of the specialized homotopy with respect to the unknowns.

evaluate_dt(sys::SpecializedHomotopy, x, t)

Evaluate the derivative of the specialized homotopy with respect to the homotopy parameter t.

system_with_precision(sys::SpecializedHomotopy, precision_bits::Integer)

Return an SpecializedHomotopy with the same compiled data and parameters as sys, but with all stored ACB values converted to AcbField(precision_bits).

This is used internally by adaptive-precision track_path, and can also be useful when manually retrying a difficult path.