5 Linear Homotopy. 5-1 Introduction

Transcription

1 Algebraic Geodesy and Geoinformatics PART I METHODS 5 Linear Homotopy 5-1 Introduction Most often, there exist a fundamental task of solving systems of equations in geodesy. In such cases, many geodetic problems are represented as systems of multivariate polynomials. Frequently the bottleneck in solving such systems is to find out proper initial starting values for iterative methods, which lead to convergence to solutions with physical meaning. Although symbolic methods such as Groebner basis or resultants have been shown to be very efficient, providing solutions for systems of only modest size. In addition, in some cases the nonlinear equations representing the geodetic problems are not polynomial ones. Therefore, in case of some real life problems one should employ global numerical methods to avoid initial value problem. Using numerical algorithms to solve polynomial systems with tools originating from algebraic geometry is the main activity in the so called Numerical Algebraic Geometry. This is a new developing field on the crossroads of algebraic geometry, numerical analysis, computer science and engineering. Homotopy continuation method is a global numerical method to solve not only polynomial systems, but also nonlinear system in general. 5-2 Definition and basic concepts The continuous deformation of an object to an other object is known as homotopy. Let us consider two univariate polynomials p1 and q1 of the same degree, p1 HxL = x2-3 q1 HxL = -x2 - x + 1 Define the linear convex function, H in variables x and Λ, called as homotopy function as, H Hx, ΛL = H1 - ΛL p1 HxL + Λ q1 HxL In geometric terms, the homotopy H provides us a continuous, smooth deformation from p1 -which is obtained for Λ = 0 by H(x, 0) - to q1 - which is obtained for Λ = 1 by H(x, 1). The homotopy function can be seen in the figure 5.1 for different Λ values, Λ = 0., 0.1,...,1. We call it linear homotopy because H is a linear function of the variable Λ. Let us define these functions,

2 2 Linear_Homotopy_05.nb Clear"Global " p 1 x_ : x 2 3 q 1 x_ : x 2 x 1 Hx_, Λ_ : 1 Λ p 1 x Λ q 1 x Now we can plot the homotopy function with different constant Λ values, illustrating the deformation of p 1 (x) into q 1 (x). Show PlotTableHx, Λ, Λ, 0, 1, 0.1, x, 2, 1.5, AxesLabel "x", ImageSize 300, GraphicsText"p 1 ", 0.5, 3., GraphicsText"q 1 ", 0.35, 0.8, GraphicsText"Hx,Λ", 0.3, q Fig. 5.1 Deformation of the function H from p 1 to q 1 as function of Λ Now let us consider two univariate polynomials p 2 and q 2 of the different degrees, Define the linear convex homotopy again with, Similarly, the functions are p 2 x_ : x 2 1 q 2 x_ : x x2 4 Hx_, Λ_ : 1 Λ p 2 x Λ q 2 x and

3 Linear_Homotopy_05.nb ShowPlotTableHx, Λ, Λ, 0, 1, 0.1, x, 2.5, 2.5, AxesLabel "x", GraphicsText"p 2 ", 1.5, 2., GraphicsText"q 2 ", 0.9, p q 2 Fig. 5.2 Deformation of the function H from p 2 to q 2 as function of Λ 5-3 Solving nonlinear equation via homotopy Homotopy continuation method deforms the known roots of the start system into the roots of the target system. Now, let us look at how homotopy can be used to solve a simple polynomial equation. Consider the polynomial equation of degree two, qx_ : x 2 8 x 9 By deleting the middle term, we can get a more simple equation, which can be solved easily by inspection, px_ : x 2 9 This equation also has two roots and will be considered as start system for the target system. The linear homotopy can be defined as it follows or Hx_, Λ_ : 1 Λ px Λ qx Hx, Λ Expand 9 x 2 8 x Λ Let us plot the homotopy H for the polynomials p(x) and q(x) ShowPlotTableHx, Λ, Λ, 0, 1, 0.1, x, 10, 10, AxesLabel "x", GraphicsText"px", 8, 35., GraphicsText"qx", 8, qx px

4 4 Linear_Homotopy_05.nb Fig. 5.3 Deformation of the function H from p x to q x as function of Λ Homotopy continuation method deforms p(x) = 0, the known roots of the start system, into q(x) = 0, the roots of the target system. Let us solve the equation H(x, Λ) = 0 for different values of Λ. Considering x 0 = 3 one of the solutions of p(x) = 0 as initial guess value, and solving H(x, Λ 1 ) = 0, where let Λ 1 = 0.2, employing Newton-Raphson method subsequently, we get x 0 3; Λ 1 0.2; x 1 x. FindRootHx, Λ 1 0, x, x Using the result as guess value for the next solution step Λ 2 0.4; x 2 x. FindRootHx, Λ 2 0, x, x and so on, Λ 3 0.6; x 3 x. FindRootHx, Λ 3 0, x, x Λ 4 0.8; x 4 x. FindRootHx, Λ 4 0, x, x Λ 5 1; x 5 x. FindRootHx, Λ 5 0, x, x 4 1. Let us display the transition of a root of the polynomial p(x) into a root of the polynomial q(x), ShowPlotTableHx, Λ, Λ, 0, 1, 0.2, x, 0, 5, AxesLabel "x", ListPlot3, 0, x 1, 0, x 2, 0, x 3, 0, x 4, 0, x 5, 0, PlotStyle PointSize0.016, RGBColor1, 0, 0, GraphicsText"px", 5, 10., GraphicsText"qx", 4, qx Fig. 5.4 The transition of the root from x = 3 to x = 1 during the deformation of the function H The homotopy path is the function x = x (Λ), where in every point H (x,λ) = 0. Fig. 5.5 shows the path of homotopy transition of the root of p(x) into the root of q(x). Λ 0 0.; ShowListPlotTableΛ i, x i, i, 0, 5, Joined True, AxesLabel "Λ", "xλ", ListPlotTableΛ i, x i, i, 0, 5, PlotStyle PointSize0.016, RGBColor1, 0, 0, GraphicsText"p3 0", 0.12, 2.95, Text"q1 0", 0.95, 1.25

5 Linear_Homotopy_05.nb p3 0 q1 0 Fig. 5.5 The homotopy path is the function x = x (Λ), where in every point H = Tracing homotopy path as initial value problem Comparing homotopy solution with the traditional Newton-Raphson solution, it is clear that if Λ is small enough, the convergence may be ensured in every step. However, one can consider this root tracing procedure as an initial value problem of an ordinary differential equation. Since H (x, Λ) = 0 for every Λ [0, 1], therefore Then the initial value problem is with Here H x is the Jacobian of H with respect to x i, i = 1,..., n, in case of n nonlinear equations with n variables. In our single variable case, the two partial derivates of the homotopy function are dhdλ DHx, Λ, Λ 8 x dhdx DHx, Λ, x 2 x 1 Λ 8 2 x Λ Then the right hand side of the differential equation to be solved is deqrhs dhdλ. x xλ dhdx 8 xλ 2 1 Λ xλ Λ 8 2 xλ The differential equation,

6 6 Linear_Homotopy_05.nb deq DxΛ, Λ deqrhs 8 xλ x Λ 2 1 Λ xλ Λ 8 2 xλ The initial value is x0 x 0 3 The numerical solution sol NDSolvedeq, x0 x0, xλ, Λ, 0, 1 xλ InterpolatingFunction 0., 1., Λ The trajectory is the homotopy path, PlotxΛ. sol, Λ, 0, 1, AxesLabel "Λ", "xλ", Epilog PointSize0.016, Blue, Point0, x0, PointSize0.016, Red, Point1, FirstxΛ. sol. Λ 1 Fig. 5.6 The trajectory of the solution as the homotopy path The value of the corresponding root of q(x) is x(λ) at Λ =1, FirstxΛ. sol. Λ Types of linear homotopy General linear homotopy As we have seen, the start system can be constructed intuitively, reducing the original system (target system) to a more simple system (start system), which roots can be easily computed. In order to get all of the roots of the target system, the start system should have so many roots as many the target system has. The start system can be constructed in different ways, however there are two typical techniques for generating the start sytems, which are usually employed.

7 Linear_Homotopy_05.nb Fixed-point homotopy The start system can be considered as where x 0 is a guess value for the root of the target system q x 0. In that case the homotopy function is Newton homotopy An other construction for the start system, when we consider p(x) as in that case the homotopy function is or There are other methods to construct start system for linear homotopy. In a section, following later, we shall see how one can define start system for polynomial systems automatically. It is known that local methods, like Newton-Raphson method, require initial guess of a root, which is close to the intended root for the particular application. Global methods, like homotopy continuation method can find solution from a start guess, which is far from the solution. Now, we shall illustrate some situations when Newton-Raphson method fails, but homotopy method can be successful. We shall consider two usual problems with the Newton-Raphson method, namely when the Jacobi matrix is singular or when the convergency is too slow. 5-6 Newton-Raphson vs. homotopy method Singular Jacobi matrix Let us consider the following univariate polynomial of degree three, This polynomial has one real and two conjugate complex roots. qx_ : 27 x x x 40 Plotqx, x, 3, 1, AxesLabel "x", "qx", ImageSize 350

8 8 Linear_Homotopy_05.nb Fig. 5.7 The real root of the polynomial Let us try to find the real root using Newton- Raphson method, with an initial guess value x 0-2, FindRootqx, x, 2 FindRoot::jsing: Encountered a singular Jacobian at the point x 2.. Try perturbing the initial points. x 2. This method also fails when x FindRootqx, x, 1.5 FindRoot::lstol: The line search decreased the step size to within tolerance specified by AccuracyGoal and PrecisionGoal but was unable to find a sufficient decrease in the merit function. You may need more than MachinePrecision digits of working precision to meet these tolerances. x Now we use homotopy method. Let us employ fixed- point homotopy with x 0-2, Fig. 5.8 shows the plot of fixed point homotopy curves for target system q x in case of x 0 2, x0 2; Hx_, Λ_ : 1 Λ x x0 Λ qx ShowPlotTableHx, Λ, Λ, 0, 1, 0.1, x, 3, 2, AxesLabel "x", "px,qx", PlotRange 10, 40, ImageSize 350, GraphicsText"px x x 0 ", 2.15, 1.5, Text"qx", 2.45, 31

9 Linear_Homotopy_05.nb qx px x x Fig. 5.8 The homotopy function of the problem with parameter Λ Let us generate the fixed pont homotopy path for q x 0 in case of x 0 2, DHx, Λ, Λ rhs. x xλ; 0 DHx, Λ, x sol NDSolveDxΛ, Λ rhs, x0 x0, xλ, Λ, 0, 1; PlotxΛ. sol, Λ, 0, 1, PlotRange 1.9, 2.9, AxesLabel "Λ", "xλ", Epilog PointSize0.016, Blue, Point0, x0, PointSize0.016, Red, Point1, FirstxΛ. sol. Λ 1, ImageSize Fig. 5.9 The homotopy path of the problem A value of the real root is FirstxΛ. sol. Λ This fixed-point homotopy also works with x 0 = Slow convergency Let us consider now a two- dimensional problem. The target sytem is

10 10 Linear_Homotopy_05.nb Fig shows the contour plot of the system of equations in case of f 1 0 and f 2 0 f1x_, y_ : x ^ 2 x y 1 f2x_, y_ : Sqrtx 1 y ShowContourPlotf1x, y 0, f2x, y 0, x, 1.1, 2, y, 2, 1, FrameLabel "x", "y", ImageSize 350, GraphicsText"f 1 x, y 0", 1.43, 0, Text"f 2 x, y 0", 0.5, 1, Text"f 1 x, y 0", 0.45, f 1 x, y f 1 x, y f 2 x, y We try Newton-Raphson method with x 0 = and y 0 = 0.5, x0 0.1; y0 0.5; Fig The real roots of the nonlinear system FindRootf1x, y, f2x, y, x, x0, y, y0 FindRoot::cvmit: Failed to converge to the requested accuracy or precision within 100 iterations. x , y Now let us employ Newton homotopy, f1x0, y0 Hx_, y_, Λ_ : Flatten1 Λ f2x0, y0 Hx, y, Λ f1x, y f2x, y 1 x 2 x y Λ, 1 x y Λ Let us generate the contour plot of the start system in case of Newton homotopy with x and y 0 0.5,

11 Linear_Homotopy_05.nb ShowContourPlotHx, y, 01 0, x, 1, 2, y, 2, 1, FrameLabel "x", "y", ImageSize 350, GraphicsText"Hx,y,0 0", 0.75, 1, ContourPlotHx, y, 02 0, x, 1, 2, y, 2, 1, ImageSize y Hx,y, Fig The homotopy function contours at H = 0 Let us define a function for the Jacobi computation as it follows, JacobiF_, X_ : OuterD, F, X Then the total Jacobian, ( H x H H ) y Λ JxyΛ JacobiHx, y, Λ, x, y, Λ; MatrixFormJxyΛ 2 x y x x The Jacobian respecting to x and y Jxy TakeJxyΛ, 1, 2, 1, 2; MatrixFormJxy 2 x y x 1 2 1x 1 Now, in case of system of two variables, X ={x, y}, we should solve a linear system in order to get explicit form of the differential equation system, namely

12 12 Linear_Homotopy_05.nb The right hand side of the linear system b TakeJxyΛ, 1, 2, 2 1; MatrixFormb Solving the linear system, we get rhs LinearSolveJxy, b Simplify. Map Λ &, x, y Flatten 1. xλ xλ yλ xλ yλ, 2. xλ 1. yλ 0.5 xλ 2. xλ 1. xλ xλ yλ xλ 2. xλ xΛ 0.5 xλ 1.xΛ yλ 1. yλ Then the left hand side of the differential equation system is, lhs MapDΛ, Λ, 1 &, x, y x Λ, y Λ Therefore the differential equation system, deqs MapThread1 2 &, lhs, SetPrecisionrhs, 20 x Λ xλ xλ yλ xλ yλ xλ yλ xλ xλ xλ xλ yλ, y Λ xλ yλ xλ xλ xλ xλ yλ Here we used an extra precision because this system is stiff. The initial values are also given in rational form representing infinite precision. The numerical solution, sol NDSolveJoindeqs, x0 1 10, y0 1 2, xλ, yλ, Λ, 0, 1, WorkingPrecision 20 xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ The plot of the homotopy solution of the system in case of Newton homotopy with x and y 0 0.5,

13 Linear_Homotopy_05.nb ShowPlotxΛ, yλ. sol, Λ, 0, 1, FrameLabel "Λ", "xλ, yλ", Frame True, Epilog PointSize0.016, Blue, Point0, x0, 0, y0, PointSize0.016, Red, Point1, FirstxΛ. sol. Λ 1, 1, FirstyΛ. sol. Λ 1, GraphicsText"xΛ", 0.6, 0.6, GraphicsText"yΛ", 0.4, yλ xλ, yλ xλ Fig The homotopy paths of the solution The solution of the system, xs, ys FlattenxΛ, yλ. sol. Λ , We can round these values, xs, ys xs, ys Round 1, Regularization of the homotopy function Sometimes this form of homotopy methods may also fail, because of singularity resulting diverging path. Let us consider the following system, f1x_, y_ : x ^ 2 y 3 f2x_, y_ : x 1 8 y ^ 2 1

14 14 Linear_Homotopy_05.nb ShowContourPlotf1x, y 0, f2x, y 0, x, 10, 10, y, 10, 10, FrameLabel "x", "y", GraphicsText"f 1 x,y 0", 0, 9, Text"f 2 x,y 0", 8, y f 1 x,y Fig The real roots of the polynomial system First, let us try to solve the problem using Newton- Rapson method, starting with x 0 = - 1 and y 0 = -1, FindRootf1x, y, f2x, y, x, 1, y, 1 FindRoot::lstol: The line search decreased the step size to within tolerance specified by AccuracyGoal and PrecisionGoal but was unable to find a sufficient decrease in the merit function. You may need more than MachinePrecision digits of working precision to meet these tolerances. x , y This result is not correct, f1x, y, f2x, y , or with x 0 = 1 and y 0 = -1, FindRootf1x, y, f2x, y, x, 1, y, 1 FindRoot::lstol: The line search decreased the step size to within tolerance specified by AccuracyGoal and PrecisionGoal but was unable to find a sufficient decrease in the merit function. You may need more than MachinePrecision digits of working precision to meet these tolerances. x , y again, this is not a solution f1x, y, f2x, y , These mean that none of them is a correct solution, Newton - Raphson method fails.

15 Linear_Homotopy_05.nb Let us try to solve the problem with homotopy method. We consider the following obvious functions as start system of { f 1, f 2 } by deleting the low order terms, g1x_, y_ : x ^ 2 1 g2x_, y_ : y ^ 2 1 Remark: The degree of the start and the target system should be the same. Solveg1x, y 0, g2x, y 0, x, y x 1, y 1, x 1, y 1, x 1, y 1, x 1, y 1 The zeros of this system are (1, 1), (-1, 1), (-1, -1) and (1, -1). Let us consider x0 1; y0 1; The homotopy function is g1x, y Hx_, y_, Λ_ : Flatten1 Λ g2x, y Hx, y, Λ Λ f1x, y f2x, y 1 x 2 1 Λ 3 x 2 y Λ, 1 y 2 1 Λ The total Jacobian, 1 x y2 8 Λ JxΛ JacobiHx, y, Λ, x, y, Λ; MatrixFormJxΛ 2 x 1 Λ 2 x Λ Λ 2 y The Jacobian respecting to x and y Λ 2 y 1 Λ y Λ 4 x 7 y2 8 Jx TakeJxΛ, 1, 2, 1, 2; MatrixFormJx 2 x 1 Λ 2 x Λ Λ Λ 2 y 1 Λ y Λ 4 Now, we set up the differential equation system for tracing homotopy paths. Explicit form of the differential equation system should be expressed. The right hand side of the linear system b TakeJxΛ, 1, 2, 2 1; MatrixFormb 2 y x 7 y2 8 Solving the linear system, we get the right hand side, rhs LinearSolveJx, b Simplify. Map Λ &, x, y Flatten 8 Λ xλ Λ yλ 16 7 Λ yλ2, 8 xλ2 4 Λ 2 yλ 7 xλ yλ Λ Λ xλ yλ 2 2 Λ Λ xλ yλ The left hand side is, lhs MapDΛ, Λ, 1 &, x, y x Λ, y Λ

16 16 Linear_Homotopy_05.nb Then the differential equation system can be written as, deqs MapThread1 2 &, lhs, rhs x Λ 8 Λ xλ Λ yλ 16 7 Λ yλ2, 4 2 Λ Λ xλ yλ y Λ 8 xλ2 4 Λ 2 yλ 7 xλ yλ Λ Λ xλ yλ The numerical solution of the system with the initial values {x0, y0}, or sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1, Method "ExplicitRungeKutta " NDSolve::ndstf : At Λ , system appears to be stiff. Methods Automatic, BDF or StiffnessSwitching may be more appropriate. xλ InterpolatingFunction 0., , Λ, yλ InterpolatingFunction 0., , Λ sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1, Method "StiffnessSwitching " NDSolve::ndsz: At Λ , step size is effectively zero; singularity or stiff system suspected. xλ InterpolatingFunction 0., , Λ, yλ InterpolatingFunction 0., , Λ The integration has failed because singularity of the Jacobi matrix of H(x, y, Λ) occured. In order to avoid singularity in real field, we consider a modified complex homotopy function, where Γ is a complex number. For almost all choices of a complex constant Γ, all solution paths defined by the homotopy above are regular, i.e.: for all Λ [0, 1], the Jacobian matrix of H (x, Λ) is regular and no path diverges. Let us now consider, Γ 1 ; Then the homotopy function, g1x, y Hx_, y_, Λ_ : FlattenΓ 1 Λ g2x, y Hx, y, Λ Λ f1x, y f2x, y 1 1 x 2 1 Λ 3 x 2 y Λ, 1 1 y 2 1 Λ The total Jacobian, JxΛ JacobiHx, y, Λ, x, y, Λ; MatrixFormJxΛ 1 x y2 8 Λ 2 2 x 1 Λ 2 x Λ Λ 3 x x 2 y Λ 2 2 y 1 Λ y Λ 1 x y y2 The Jacobian respecting to x and y

17 Linear_Homotopy_05.nb Jx TakeJxΛ, 1, 2, 1, 2; MatrixFormJx 2 2 x 1 Λ 2 x Λ Λ Λ 2 2 y 1 Λ y Λ 4 The right hand side of the linear system b TakeJxΛ, 1, 2, 2 1; MatrixFormb 3 x x 2 y 1 x y y2 Solving the linear system, rhs LinearSolveJx, b Simplify. Map Λ &, x, y Flatten 8 Λ 1 xλ Λ 1 2 xλ 2 yλ Λ yλ Λ Λ 7 8 Λ 2 xλ yλ, Λ xλ 2 4 Λ 1 2 yλ 1 Λ xλ yλ Λ Λ 7 8 Λ 2 xλ yλ Then the differential equation system is, lhs MapDΛ, Λ, 1 &, x, y x Λ, y Λ deqs MapThread1 2 &, lhs, rhs x Λ 8 Λ 1 xλ Λ 1 2 xλ 2 yλ Λ yλ Λ Λ 7 8 Λ 2 xλ yλ, y Λ Λ xλ 2 4 Λ 1 2 yλ 1 Λ xλ yλ Λ Λ 7 8 Λ 2 xλ yλ The numerical solution sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1 xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ The solution of the polynomial system, xλ, yλ. sol. Λ , Now we have got a complex root,

18 18 Linear_Homotopy_05.nb ShowParametricPlotReyΛ, ImyΛ. sol, Λ, 0, 1, PlotRange All, FrameLabel "Re", "Im", Frame True, Epilog PointSize0.02, Blue, PointRey0, Imy0, PointSize0.02, Red, PointFirstReyΛ. sol. Λ 1, FirstImyΛ. sol. Λ 1, PointSize0.02, Blue, PointRex0, Imx0, PointSize0.02, Red, PointFirstRexΛ. sol. Λ 1, FirstImxΛ. sol. Λ 1, ParametricPlotRexΛ, ImxΛ. sol, Λ, 0, 1, PlotRange All, GraphicsText"xΛ", 1.5, 0.5, GraphicsText"yΛ", 0.5, xλ Im yλ Fig The homotopy paths on complex plain Basically, our original system, the target system has four solutions, NSolvef1x, y 0, f2x, y 0, x, y x , y , x , y , x , y , x , y The other roots can be also computed using different start values, namely x0 1; y0 1; sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1; xλ, yλ. sol. Λ , and the real roots x0 1; y0 1; sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1; xλ, yλ. sol. Λ ,

19 Linear_Homotopy_05.nb These complex "tails" can be eliminated by using computation with high precision, sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1, AccuracyGoal 20, PrecisionGoal 20, WorkingPrecision 30; xλ, yλ. sol. Λ , Chop N , The other real root can be computed similarly, x0 1; y0 1; sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1; xλ, yλ. sol. Λ , Now, again complex "tails" can be eliminated, sol NDSolveJoindeqs, x0 x0, y0 y0, xλ, yλ, Λ, 0, 1, AccuracyGoal 20, PrecisionGoal 20, WorkingPrecision 30; xλ, yλ. sol. Λ , Chop N , Start system for polynomial systems How we can find the proper start system, which will provide all of the solutions of the target system automatically? This problem can be solved if the nonlinear system is specially a system of polynomial equations. Let us consider the case when we are looking for the homotopy solution of f(x) = 0, where f(x) is a polynomial system, f(x): n n. To get all of the solutions, one should find out a proper polynomial system, as start system, g(x) = 0, where g(x): n n with known or easily computable solutions. An appropriate start system can be generated in the following way, Let f i x 1,..., x n, i 1,..., n be a system of n polynomials. We are interested of the common zeros of the system, namely f f 1 x,..., f n x 0. Let d j denote the degree of the j th polynomial that is the degree of the highest order monomial in the equation. Then such a starting system is, where Φ j and Θ j are random real numbers in the interval [0, 2 Π]. The equation above has the obvious particular solution x j = i Θ j and the complete set of the starting solutions for j = 1,..., n is given by

20 20 Linear_Homotopy_05.nb Bezout s theorem states that the number of isolated roots of such a system is bounded by the total degree of the system, n i 1 d i = d 1 d 2...d n. Let us consider the following system f1x_, y_ : x ^ 2 y ^ 2 1 f2x_, y_ : x ^ 3 y ^ 3 1 The degrees of the polynomials are d1 2; d2 3; Indeed, this system has the following six roots (d 1 d 2 = 2 * 3 = 6), as it is expected. Indeed using built-in Global Numerical Solver, NSolvef1x, y 0, f2x, y 0, x, y x , y , x , y , x 1., y 0., x 1., y 0., x 0., y 1., x 0., y 1. Length 6 Now, we compute the start system. We generate random real numbers in the interval [0, 2Π] as it follows Φ1 RandomReal, 0, 2 Π Φ2 RandomReal, 0, 2 Π Θ1 RandomReal, 0, 2 Π Θ2 RandomReal, 0, 2 Π The start system is, g1x_, y_ : Φ1 x d1 Θ1 d1 g2x_, y_ : Φ2 y d2 Θ2 d2 g1x, y x 2 g2x, y y 3 Then the complete set of the starting solutions, Xi TableExp Θ1 2 Π k d1, k, 0, d ,

21 Linear_Homotopy_05.nb and Yi TableExp Θ2 2 Π k d2, k, 0, d , , We need all of the combination of the initial values {X i, Y j, i = 1, 2, j = 1, 2 X0 TuplesXi, Yi , , , , , , , , , , , These values are satisfy the start system, Mapg11, 2 &, X , 0. 0., 0. 0., , , Chop 0, 0, 0, 0, 0, 0 Mapg21, 2 &, X , , , 0. 0., , Chop 0, 0, 0, 0, 0, 0 So we have six initial values for solving our homotopy equations. These initial values will provide the start point of the six homotopy paths. The end points of these paths are the six solutions of the target system. Before carring out the computation, it is high time to implement four Mathematica functions to carry out linear homotopy computations in Mathematica environment. 5-9 Implementation of homotopy methods in Mathematica Function for computing start system for polynomials This function will compute the start system as well as the initial values for the computation of the homotopy paths in case of polynomial system. Input variables F - list of functions of the polynomial system to be solved, F = { f 1 (x), f 2 (x),..., f n (x)} X - list of the independent variables, X = {x 1,x 2,...,x n } d - list of the degrees of the polynomials, d = {d 1,d 2,...,d n } Output variables

22 22 Linear_Homotopy_05.nb G - list of start system, G = {g 1 (x), g 2 (x),...,g n (x)} X0 - list of initial values, X0 = {{x0 1,x0 2,...,x0 n 1,{x0 1,x0 2,...,x0 n 2,...,{x0 1,x0 2,...,x0 n m } where m is the number of the roots of F StartingSystemF_, X_, d_ : Modulen, k, Φ, Θ, G, Xi, X0, n LengthX; Φ TableRandomReal, 0, 2 Π, n; Θ TableRandomReal, 0, 2 Π, n; G MapThread &, Φ, d, Θ, X; Xi MapThreadTableExp 1 2 Π k 2, k, 0, 2 1 &, Θ, d; X0 TuplesXi; G, X0 Now, let us create the start system with this function. The list of the functions of the system we considered above is, F f1x, y, f2x, y 1 x 2 y 2, 1 x 3 y 3 The list of variables X x, y x, y The list of the degrees of the polynomials, d d1, d2 2, 3 Now, employing our function sol StartingSystemF, X, d; The start system is G sol x 2, y 3 and the initial values are X0 sol , , , , , , , , , , , They are the solutions of the start system, MapG1. x 1, y 2 &, X0 Chop 0, 0, 0, 0, 0, 0

23 Linear_Homotopy_05.nb MapG2. x 1, y 2 &, X0 Chop 0, 0, 0, 0, 0, Function for direct path tracing This function will compute the homotopy paths using Newton-Raphson method successively. Input variables F - list of functions of the polynomial system to be solved, F = { f 1 (x), f 2 (x),..., f n (x)} G - list of the start system, G = g 1 x,g 2 (x),...,g n x}, X - list of the independent variables X = {x 1,x 2,...,x n } X0 - list of initial values, X0 = {{x0 1,x0 2,...,x0 n 1,{x0 1,x0 2,...,x0 n 2,...,{x0 1,x0 2,...,x0 n m } where m is the number of the roots of F Γ - list of complex numbers, {Γ 1, Γ 2,...,Γ n }, it means Γ i can be different for every g i (x), If the start system is generated for polynomials all Γ i = 1. n - number of the subintervalls in [0, 1]. Output variables sol[1] sol[2] - list of the i-th solutions correspondig to the i-th initial values, {x0 1,x0 2,...,x0 n i, i = 1...m - list of the path of i-th solutions in form of interpolating functions of the variables correspondig with the i-th initial values, {x0 1,x0 2,...,x0 n i, i = 1...m, {{φ 1, φ 2,..., φ n 1,{φ 1, φ 2,..., φ n 2,...,{φ 1, φ 2,..., φ n m }, φ i =φ i (Λ) LinearHomotopyFR F_, G_, X_, X0_, Γ_, n_ : ModuleH, X0L, Λ0, i, Β, m, R, RR, j, k, sol, OffFindRoot::"lstol"; Λ0 Tablei 1, i, 0, n; n H Flatten1 Β ThreadG Γ Β F; m LengthX; k LengthX0; RR ; Do X0L X0j; DoAppendToX0L, Map2 &, FindRootH. Β Λ0i 1, MapThread1, 2 &, X, X0Li, i, 1, n; R ; DoAppendToR, InterpolationMapThread1, 2i &, Λ0, X0L, i, 1, m; AppendToRR, MapChopN1 &, R, R, j, 1, k; sol TransposeRR; sol1, TableMapThread1Λ 2Λ &, X, sol2, i, i, 1, LengthX0 Remark: It is reasonable to carry out computation with n = 100, however sometimes one may need more subintervalls, but it also possible that less will enough to get satisfactory result. In case of polynomial system, when we generate a start system in complex domain, we do not need to use complex Γ, Γ 1, 1;

24 24 Linear_Homotopy_05.nb sol LinearHomotopyFR F, G, X, X0, Γ, 100; The first output gives the roots of the system, sol1fr Chopsol1, , 0, 0, 1., 1., 0, , , 0, 1., , The second output is the list of the interpolation functions of the paths, sol2fr sol2 xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ, xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ, xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ, xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ, xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ, xλ InterpolatingFunction 0., 1., Λ, yλ InterpolatingFunction 0., 1., Λ Function for path tracing with integration This function will compute the homotopy paths using numerical integration of the differencial equation system employing Runge-Kutta method. In this implementation we compute the inverse of the Jacobian, namely the initial value problem will be expressed as with Here H x 1 is the inverse of the Jacobian (H x ) with respect to x i, i = 1,..., n, in case of n nonlinear equations with n variables. The inverse will be computed in symbolic way therefore the number of equations may be limited by n = 6-8. Input variables F - list of functions of the polynomial system to be solved, F = { f 1 (x), f 2 (x),..., f n (x)} G - list of the start system, G = g 1 x,g 2 (x),...,g n x}, X - list of the independent variables X = {x 1,x 2,...,x n } X0 - list of initial values, X0 = {{x0 1,x0 2,...,x0 n 1,{x0 1,x0 2,...,x0 n 2,...,{x0 1,x0 2,...,x0 n m } where m is the number of the roots of F Γ - list of complex numbers, {Γ 1, Γ 2,...,Γ n }, it means Γ i can be different for every g i (x), If start system is generated for polynomials all Γ i = 1. p - indicating numerical precision of the computation., p = 0 standard precision, p =1 high precision Output variables

25 Linear_Homotopy_05.nb sol[1] sol[2] - list of the i-th solutions correspondig to the i-th initial values, {x0 1,x0 2,...,x0 n i, i = 1...m - list of the path of i-th solutions in form of interpolating functions of the variables correspondig with the i-th initial values, {x0 1,x0 2,...,x0 n i, i = 1...m, {{φ 1, φ 2,..., φ n 1,{φ 1, φ 2,..., φ n 2,...,{φ 1, φ 2,..., φ n m }, where φ i =φ i (Λ) LinearHomotopyNDS01 X_, F_, G_, X0_, Γ_, p_ : ModuleH, n, JΛ, J, u, i, j, b, A, a, B, rhs, lhs, deqs, sol, pa, pp, wp, OffNDSolve::"precw"; H Flatten1 Λ ThreadG Γ Λ F; n LengthX; JΛ OuterD, H, JoinX, Λ; J TakeJΛ, 1, n, 1, n; u TakeJΛ, 1, n, n 1; A Tablea i,j, i, 1, n, j, 1, n; B Tableb i, i, 1, n; rhs SimplifyLinearSolveA, B. JoinTableb i ui, i, 1, n, FlattenTable a i,j Ji, j, i, 1, n, j, 1, n. Map Λ &, X Flatten; lhs MapDΛ, Λ, 1 &, X; deqs MapThread1 2 &, lhs, rhs; pa, pp, wp Ifp 1, AccuracyGoal 20, PrecisionGoal 20, WorkingPrecision 30,,, ; sol MapFlattenNDSolveJoindeqs, MapThread10 2 &, X,, MapΛ &, X, Λ, 0, 1, pa, pp, wp &, X0; MapChopNMapΛ &, X.. Λ 1 &, sol, sol Now we solve the same problem. First, we use standard precision, sol LinearHomotopyNDS01 X, F, G, X0, Γ, 0; sol , , , , , , , , , , , Chopsol1, , 0, 0, 1., 1., 0, , , 0, 1., , Using higher precision, the computation takes a considerably longer time, sol LinearHomotopyNDS01 X, F, G, X0, Γ, 1; sol1nds sol1 1., , , 1., 1., , , , , 1., , but we have smaller values for the "tails",

26 26 Linear_Homotopy_05.nb Chopsol1NDS, , 0, 0, 1., 1., 0, , , 0, 1., , The interpolation functions for the paths sol2nds sol2 xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ, xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ, xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ, xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ, xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ, xλ InterpolatingFunction 0, , Λ, yλ InterpolatingFunction 0, , Λ Remarks : 1) To get explicit form for the differential equation system, the linear equation system is solved in symbolic way. Therefore, the maximum number of equation can be about n = 6-8, 2) High precision solution (p = 1) would take much longer time than standard precision does ( p = 0). In order to avoid to compute the inverse in this implementation, we consider a new parameter, t, namely this means with s(t) = {x (t), Λ(t)} we get where H s is the Jacobian of the homotopy function respect to vector s having n 1 dimensions. Then the i th derivate function can be expressed as where H i s is the i th column of the Jacobian matrix H s s t. However, in that case one need to check the upper bound of the integration parameter, while integration should be carried out up to t, where Λ t 0. Therefore it is reasonable to eliminate the last derivate of vector s, namely Considering that for i = 1, 2,..., n.

27 Linear_Homotopy_05.nb now the integration can be carried out with independent variable Λ on [0, 1]. The new implementation considering these changes is the following, LinearHomotopyNDS02 X_, F_, G_, X0_, Γ_, p_ : ModuleH, n, JΛ, rhs, rhs0, i, lhs, deqs, sol, pa, pp, wp, OffNDSolve::"precw"; H Flatten1 Λ ThreadG Γ Λ F; n LengthX; JΛ OuterD, H, JoinX, Λ; rhs0 Table1 i1 DetTransposeDropTransposeJΛ, i, i, i, 1, n 1; rhs DropMap Lastrhs0 &, rhs0, n 1, n 1. Map Λ &, X Flatten; lhs MapDΛ, Λ, 1 &, X; deqs MapThread1 2 &, lhs, rhs; pa, pp, wp Ifp 1, AccuracyGoal 20, PrecisionGoal 20, WorkingPrecision 30,,, ; sol MapFlattenNDSolveJoindeqs, MapThread10 2 &, X,, MapΛ &, X, Λ, 0, 1, pa, pp, wp &, X0; MapChopNMapΛ &, X.. Λ 1 &, sol, sol The input and output are the same as in case of the function LinearHomotopyNDS01. sol LinearHomotopyNDS02 X, F, G, X0, Γ, 1; sol1 1., , , 1., 1., , , , , 1., , Chopsol1, , 0, 0, 1., 1., 0, , , 0, 1., , Function for visualization of paths This function plots the homotopy paths computed by either direct method or by integration. Input variables X - the list of the independent variables X = {x 1, x 2,...,x n } sol - list of the interpolation functions of the variables {{φ 1, φ 2,..., φ n 1,{φ 1, φ 2,..., φ n 2,...,{φ 1, φ 2,..., φ n m } X0 - list of initial values, X0 = {{x0 1,x0 2,...,x0 n 1,{x0 1,x0 2,...,x0 n 2,...,{x0 1,x0 2,...,x0 n m } where m is the number of the roots of F, PathsX_, sol_, X0_ : GraphicsArrayTableParametricPlotReXiΛ, ImXiΛ. solj, Λ, 0, 1, PlotRange All, BaseStyle FontSize 10, FontFamily "Times", Axes None, FrameLabel "Re", "Im", Frame True, AspectRatio 0.6, PlotLabel StringJoinToStringXi, "Λ ", Epilog PointSize0.02, Blue, PointReX0j, i, ImX0j, i, PointSize0.02, Red, Point ReXiΛ. solj. Λ 1, ImXiΛ. solj. Λ 1, j, 1, LengthX0, i, 1, LengthX;

28 28 Linear_Homotopy_05.nb Let us plot the result of the solution of system above pnds PathsX, sol2, X0

29 Linear_Homotopy_05.nb 29 Im Im Im Im Im Im Im Im yλ Re Fig The homotopy paths Remark: These functions are implemented in the GeoAlgebra application package and you can use them, but in a slightly different way, see in Chapters of Part II.

30 30 Linear_Homotopy_05.nb Remark: These functions are implemented in the GeoAlgebra application package and you can use them, but in a slightly different way, see in Chapters of Part II Examples D Resection Problem The three-dimensional resection problem concerns itself with the determination of position and orientation of point P 0 connected by angular observations, φ i, j, i,,j = 1,2,3 to three known stations, P i, i = 1,2,3, see Fig It means, that the space angles, φ i, j as well as the distances S i, j, i,,j = 1, 2, 3 are known and the distances S i, i = 1, 2, 3 should be computed. Fig The geometrical interpretation of the 3D resection problem Grunert proposed the following distance equations, This is a system of polynomial equations for the variables S 1 S 2 and S 3 representing distances. Let us intruduce the folllowing variables then our system can be written in the following form, p1 x1 2 2 f12 x1 x2 x2 2 d12; p2 x2 2 2 f23 x2 x3 x3 2 d23; p3 x3 2 2 f31 x1 x3 x1 2 d31; Data are data SetPrecisiond , d , d , f12 Cos , f23 Cos , f31 Cos , 20; X x1, x2, x3;

31 Linear_Homotopy_05.nb F p1, p2, p3. data x x1 x2 x2 2, x x2 x3 x3 2, x x1 x3 x3 2 d 2, 2, 2; The start system ss StartingSystemF, X, d; G ss x1 2, x2 2, x3 2 The initial values X0 ss , , , , , , , , , , , , , , , , , , , , , , , The upper bound of the number of the estimated isolated roots LengthX0 8 Let Γ 1, 1, 1; Employing direct path tracing algorithm sol LinearHomotopyFR F, G, X, X0, Γ, 100; The solutions are sol , , , , , , , , , , , , , , , , , , , , , , , Selecting real, positive solution Selectsol1, Im Im Im & Flatten , ,

32 32 Linear_Homotopy_05.nb The position of the this solution p Positionsol1, Flatten First 4 Homotopy solution paths of the 3D resection problem, P PathsX, sol2, p, X0p Im Fig The real root of the polynomial

33 Linear_Homotopy_05.nb GPS Positioning 4-point Problem Throughout history, position determination has been one of the most important tasks of mountaineers, pilots, sailor, civil engineers etc. In modern times, Global Positioning System (GPS) employing Global Navigation Satellite Systems (GNSS) provide an ultimate method to accomplish this task. If one has a hand held GPS receiver, the receiver measures the travel time of the signal transmitted from the satellites. Then this distance can be computed by multiplying the measured time by the speed of light in vacuum. The distance of the receiver from the i-th satellite, d i is related to the unknown position of the receiver, {X,Y, Z} where a i, b i, c i, i are the coordinates of the i th satellite. The distance is influenced also by the satellite and receiver clock biases. The satellite clock biases can be modeled while the receiver clock biases have to be considered as an unknown variable, Ξ. This means, we have four unknowns, consequently we need four satellite signals as minimum observation. Let us employ x 1, x 2, x 3 and x 4 variables for the four unknowns, {X,Y, Z, Ξ,} then our equations are, e i = 0, i = 1...4, where Cleard, b or e1 x1 a 0 2 x2 b 0 2 x3 c 0 2 x4 d 0 2 ; e2 x1 a 1 2 x2 b 1 2 x3 c 1 2 x4 d 1 2 ; e3 x1 a 2 2 x2 b 2 2 x3 c 2 2 x4 d 2 2 ; e4 x1 a 3 2 x2 b 3 2 x3 c 3 2 x4 d 3 2 ; f1, f2, f3, f4 e1, e2, e3, e4 Expand x1 2 x2 2 x3 2 x4 2 2 x1 a 0 a x2 b 0 b x3 c 0 c x4 d 0 d 0 2, x1 2 x2 2 x3 2 x4 2 2 x1 a 1 a x2 b 1 b x3 c 1 c x4 d 1 d 1 2, x1 2 x2 2 x3 2 x4 2 2 x1 a 2 a x2 b 2 b x3 c 2 c x4 d 2 d 2 2, x1 2 x2 2 x3 2 x4 2 2 x1 a 3 a x2 b 3 b x3 c 3 c x4 d 3 d 3 2 Now let us create the start system in a different way. We consider the univariable parts of the equations as start system. Namely, g1 a 0 2 b 0 2 c 0 2 d 0 2 Coefficientf1, x1, 1 x1 Coefficientf1, x1, 2 x1 2 x1 2 2 x1 a 0 a 0 2 b 0 2 c 0 2 d 0 2 g2 a 1 2 b 1 2 c 1 2 d 1 2 Coefficientf2, x2, 1 x2 Coefficientf2, x2, 2 x2 2 x2 2 a x2 b 1 b 1 2 c 1 2 d 1 2 g3 a 2 2 b 2 2 c 2 2 d 2 2 Coefficientf3, x3, 1 x3 Coefficientf3, x3, 2 x3 2 x3 2 a 2 2 b x3 c 2 c 2 2 d 2 2 g4 a 3 2 b 3 2 c 3 2 d 3 2 Coefficientf4, x4, 1 x4 Coefficientf4, x4, 2 x4 2 x4 2 a 3 2 b 3 2 c x4 d 3 d 3 2 The observation data are,

34 34 Linear_Homotopy_05.nb data a , a , a , a , b , b , b , b , c , c , c , c , d , d , d , d ; The target system, F f1, f2, f3, f4. data x1 x x2 x x3 x x4 x4 2, x1 x x2 x x3 x x4 x4 2, x1 x x2 x x3 x x4 x4 2, x1 x x2 x x3 x x4 x4 2 The start system consisting of univariate polynomials, G g1, g2, g3, g4. data x1 x1 2, x2 x2 2, x3 x3 2, x4 x4 2 Let us compute the initial values as the solution of the start system, X x1, x2, x3, x4; X0 TransposePartitionMap2 &, FlattenMapThreadNSolve1 0, 2 &, G, X, , , , , , , , Employing the path tracing algorithm by integration, Γ 1, 1, 1, 1; OffNDSolve::"ndsz"; OffInterpolatingFunction ::"dmval"; OffNDSolve::"mxst"; sol LinearHomotopyNDS01 X, F, G, X0, Γ, 1; AbsoluteTiming , Null sol , , , , 0, 0, 0, 0 Eliminating imaginary tails Chop, , , , , 0, 0, 0, 0 The first (real) solution has physical meaning,

35 Linear_Homotopy_05.nb NumberForm1, , , , The direct path search is much faster, sol LinearHomotopyFR F, G, X, X0, Γ, 100; AbsoluteTiming , Null and gives practically one solution sol , , , , , , , or NumberForm1, , , , The built function NSolve employing numerical Groebner basis provides the same result, NSolveF, X x , x , x , x , x , x , x , x NumberForm, 16 & x , x , x , x Parallel Computing Having acces to more processors and/ or more cores, homotopy solution can be computed in parallel way, since every homotopy path belonging to different start values can be traced independently, simultaneously. Mathematica can utilize such hardware configuration. You need a very small modification in calling our function. Let us compute the GPS solution with single and with double core. The computation time can be reduced considerably, especially when the original running time is high. Here, in case of direct path tracing we used 1000 subintervall instead of 100 in order to stress the difference in the running time, between one and double core computations. AbsoluteTimingsol LinearHomotopyFR F, G, X, X0, Γ, 1000; , Null Now, we employ a pure function for the elements of the list of the initial values (start values), AbsoluteTimingsol ParallelTryLinearHomotopyFR F, G, X,, Γ, 1000 &, X0; , Null Now employing the path tracing algorithms by integration with high precision,

36 36 Linear_Homotopy_05.nb AbsoluteTimingsol LinearHomotopyNDS01 X, F, G, X0, Γ, 1; , Null AbsoluteTimingsol ParallelTryLinearHomotopyNDS01 X, F, G,, Γ, 1 &, X0; , Null and using numerical inverse, AbsoluteTimingsol LinearHomotopyNDS02 X, F, G, X0, Γ, 1; , Null AbsoluteTimingsol ParallelTryLinearHomotopyNDS02 X, F, G,, Γ, 1 &, X0; , Null If the computation time with one core is short then the improvement using two cores is small because of the communication time consumption between the cores. However in case of longer time, the improvement can be considerable.