A Design and an Implementation of an Inverse Kinematics Computation in Robotics Using Gröbner Bases

Abstract

The solution and a portable implementation of the inverse kinematics computation of a 3 degree-of-freedom (DOF) robot manipulator using Gröbner bases are presented. The main system was written Python with computer algebra system SymPy. Gröbner bases are computed with computer algebra system Risa/Asir, called from Python via OpenXM infrastructure for communicating mathematical software systems. For solving a system of algebraic equations, several solvers (both symbolic and numerical) are used from Python, and their performance has been compared. Experimental results with different solvers for solving a system of algebraic equations are shown.

Introduction

In robotics, inverse kinematics computation is one of the central topics in motion planning [17]. In the field of computer algebra, methods of the inverse kinematics computation using Gröbner bases have been proposed ([2, 7, 22, 23], and the references therein). After formulating the forward kinematics problem using the Denavit–Hartenberg convention, the inverse kinematics problem is derived as a system of algebraic equations by conversion of trigonometric expressions to polynomials. Then, the system is triangularized by computing the Gröbner basis with respect to the lexicographic ordering and solved by appropriate solvers.

Since methods using Gröbner bases solve the inverse kinematics problem directly, these methods have advantages that one can verify if the given inverse kinematics problem is solvable (with the certification of the solution if needed), and if it is solvable, one can obtain the configuration of parameters for the desired motion of the robot directly, before the actual motion. On the other hand, the computational cost of methods using Gröbner bases tends to be high compared to that of numerical methods, thus it is desired to decrease computational cost for effective computation of solving the inverse kinematics problem using Gröbner bases. Furthermore, for the use of these methods in robotics simulators such as the Robot Operating System (ROS) [9], an implementation that can easily be integrated with these simulators is needed.

In this paper, we present the solution and a portable implementation of the inverse kinematics computation of a 3 degree-of-freedom (DOF) robot manipulator using Gröbner bases. For portable implementation and rapid development, the main program is developed in Python with computer algebra system SymPy [12]. Gröbner bases are computed effectively using computer algebra system Risa/Asir [14], connected to Python with OpenXM infrastructure for communicating mathematical software systems [10]. Then, the system of algebraic equations is solved using an appropriate solver called within Python. As the main focus of our paper, several solvers for solving a system of algebraic equations have been compared: an exact solver included in SymPy, a multivariate numerical solver using the secant method, and a univariate numerical solver with successive substitutions.

The rest of the paper is organized as follows. In Sect. 2, the method of inverse kinematics computation of a 3 DOF manipulator using Gröbner bases is explained. In Sect. 3, the description of the proposed system for solving the inverse kinematics problem is presented. In Sect. 4, the result of experiments is presented.

Inverse Kinematics of a 3 Degree-of-Freedom (DOF) Robot Manipulator

In this paper, an example of 3 degree-of-freedom (DOF) manipulator has been built using LEGO^® MINDSTORMS^® EV3 Education1 (henceforth abbreviated to EV3) (Fig. 1). An EV3 set has a computer (which is called “EV3 Intelligent Brick”), servo motors and sensors (gyro, ultrasonic, color and touch sensors), along with bricks used for constructing building blocks of robots. While a GUI-based programming environment for controlling the robot is available, several programming languages such as Python, Ruby, C, and Java can also be used on the top of other programming environments.

Fig. 1.

A 3 DOF manipulator built with EV3.

We first solve the forward kinematics problem. Components of the manipulator are defined as shown in Fig. 2. Segments (links) are called Segment i () from the one fixed on the ground towards the end effector, and a joint connecting Segment i and is called Joint i. For Joint i, the coordinate system , with the , and axes and the origin at Joint i, is defined according to the Denavit–Hartenberg convention [18] (Fig. 2). Note that, since the present coordinate system is right-handed, the positive axis pointing upwards and downwards is denoted by “” and “”, respectively. Furthermore, let be the coordinate system satisfying that the origin is placed at the perpendicular foot from the origin of , and the direction of axes , and are the same as that of axes , and , respectively. Also, let Joint 5 be the end effector, and be the coordinate system with the origin placed at the position of Joint 5 and that the axes , and have the same direction as the axes , and , respectively.

Fig. 2.

Components and the coordinate systems of the manipulator.

Let be the distance between axes and , the angle between axes and with respect to axis, the distance between axes and , and be the angle between axes and with respect to axis. Then, the coordinate transformation matrix from the coordinate system to is expressed as

Since the joint parameters , , and for EV3 are given as shown in Table 1 (note that the unit of and is centimeters) and the transformation matrix T from the coordinate system to is calculated as , the position of the end effector with respect to the coordinate system is expressed as

1

Table 1.

Joint parameters for EV3.

i	(cm)		(cm)
1	0	0	8
2	0		0
3	16	0	0
4	16	0	0
5	16	0	0	0

Next, for solving the inverse kinematics problem, we solve Eq. (1) with respect to , , . With the expansion of trigonometric functions using the trigonometric addition formulas and transformation of trigonometric functions defined as

subject to , Eq. (1) is transferred to a system of algebraic equations:

2

Then, by putting the coordinate into Eq. (2) and computing Gröbner basis of an ideal with respect to the lexicographic (lex) ordering, a “triangularized” system of equations is obtained. By solving the triangularized system of equations, configuration of the joint angles are obtained.

Remark 1

We see that the ideal is zero-dimensional for generic values of x, y, z, as follows. By computing the comprehensive Gröbner system [8] of with parameters x, y, z and variables in with respect to lex order with , we have as the Gröbner basis for the generic case2. In the generic case, we have , , , , , , where denotes the leading monomial of g. This shows that the ideal is zero-dimensional for the generic case [1].

Implementation

We have implemented a system for the inverse kinematics computation of the manipulator in SymPy [12] on the top of Python, connecting with the computer algebra system Risa/Asir [14] via OpenXM infrastructure for communicating mathematical software systems [10].

Python (and SymPy) has been chosen for rapid development including the use of the library for solving algebraic equations, and interoperability with the Robot Operating System (ROS) [9] for embedding our present implementation as a simulation environment or an inverse kinematics solver in the future.

OpenXM (which stands for “Open message eXchange protocol for Mathematics”) consists of definitions of protocols and data formats for communication and/or interchange of mathematical information among mathematical software systems. It also includes implementation of interface for various mathematical softwares including Risa/Asir, Kan/sm1 [20], Maple [11], Mathematica [26], MixedVol [3], NTL [16], PHC Pack [25] and TiGERS [4].

Risa/Asir is used for effective computation of Gröbner bases. After receiving input polynomials from Python/SymPy, it first computes the Gröbner basis with respect to the graded reverse lexicographic (grlex) ordering. Then, it converts the basis to the one with respect to lex ordering (with a modular FGLM algorithm [14]) before returning the final result to the host program. Risa/Asir can be called from Python easily using ctypes library [15] with the OpenXM interface library for Risa/Asir.

Experiments

We have tested our implementation for inverse kinematics computation for randomly given points within the feasible region.

For solving a system of algebraic equations, the following solvers have been used:

1. a built-in exact solver in SymPy (sympy.solvers.solvers.solve),

2. a numerical solver in Python’s npmath library [6] (mpmath.findroot) using multivariate secant method3 (called by sympy.solvers.solvers.nsolve function in SymPy package),

3. a numerical solver in Python’s NumPy package [24] (numpy.roots) solving univariate algebraic equations with successive substitutions.

For each solver, 10 sets of experiments were conducted with 100 random points given in each set of experiments (thus 1000 random points were given in total).

The computing environment is as follows.

• Host environment. Intel Core i5-7360U 2.3GHz, RAM 8GB, macOS 10.15.1, Parallels Desktop Lite 1.4.0.

• Guest environment. RAM 2GB, Linux 4.15.0, Python 2.7.12, SymPy 1.4, mpmath 1.1.0, numpy 1.11.0, OpenXM 1.3.3-1, Asir 20191101.

Remark 2

As shown in Remark 1, if the given point is within the feasible region, the system of algebraic equations has real solution(s) and can be solved rigorously, where is the Gröbner basis of the ideal with respect to lex order.

Remark 3

For the exact computation of Gröbner bases, the coordinates of the sample points are given as rational numbers with the magnitude of the denominator is less than 100.

The Result with an Exact Solver (solve)

Table 2 shows the result of experiments with the exact solver (sympy.solvers.solvers.solve) [19]. For a system of algebraic equations, the solver computes a Gröbner basis with lex order, solve univariate equations and substitute the roots in the other equations to obtain the other coordinate4.

Table 2.

A result of the inverse kinematics computation with the exact solver (nsolve).

Test	(s)	(s)	(s)	Error (cm)
1	0.511	37.410	58.771
2	0.244	38.268	60.528
3	0.378	37.890	59.970
4	0.311	38.123	57.955
5	0.234	38.615	61.405
6	0.471	37.599	59.809
7	0.292	37.839	59.784
8	0.166	22.145	36.476
9	0.254	21.568	35.650
10	0.267	21.501	34.217
Average	0.312	33.092	52.457

In each test, is the average of computing time of Gröbner basis, is the average of computing time for solving the system of algebraic equations, is the average of total computing time for inverse kinematics computation, and ‘Error’ is the average of absolute error of the position of the end effector with the configuration of joint angles , computed by solving the inverse kinematics problem, from the randomly given position. Note that includes the time for synchronizing received data of Gröbner basis from Risa/Asir ( 1.5 s) and the time for evaluation of Error. The bottom row ‘Average’ shows the average of the values in each column of the 10 test sets.

In all the test cases, the system of algebraic equations has been rigorously solved with finding appropriate real roots, although it took much time for finding the roots. For finding joint angles , the solutions have been approximated by double precision floating-point numbers for efficient use of function. We see that, though the approximation of the solution, the position of the end effector has been computed with high precision, compared to the length of the segments (Table 1).

The Result with the Multivariate Numerical Solver (nsolve)

Table 3 shows the result of experiments with the multivariate numerical solver (mpmath.findroot) [5]. The columns ‘Test’, , , , ‘Error’, and the bottom row ‘Average’ are the same as those in Table 2. In these sets of experiments, we have observed that the method did not converge in many cases, so the column ‘#Fail’ shows the number of tests in which the method did not converge in each test set. Note that the data in , , , ‘Error’ and ‘Average’ have been taken for the tests in which the method has successfully converged. The number ‘(564)’ in the ‘Average’ row and the ‘#Fail’ column shows the total number of tests in which the method did not converge5.

Table 3.

A result of the inverse kinematics computation with the multivariate numerical solver (nsolve).

Test	(s)	(s)	(s)	Error (cm)	#Fail
1	0.249	0.261	4.096		54
2	0.248	0.256	4.086		49
3	0.274	0.275	4.140		55
4	0.264	0.268	4.112		60
5	0.264	0.271	4.121		62
6	0.264	0.269	4.119		68
7	0.268	0.276	4.126		52
8	0.272	0.274	4.133		50
9	0.270	0.265	4.119		50
10	0.290	0.254	4.118		64
Average	0.266	0.267	4.117		(564)

The result shows that the method did not converge in approximately half of the test cases, while, in the cases that the method converged, the method is more efficient than the exact root-finding method. It also shows that, in the cases that the method converged, the magnitude of the absolute error of the solution is approximately 10 times larger than those in the case of the exact method, which is sufficiently small for practical use6.

The Result with the Univariate Numerical Solver (roots) with successive substitutions

Table 4 shows the result of experiments with the univariate numerical solver (numpy.roots) [21]. The columns ‘Test’, , , , ‘Error’, and the bottom row ‘Average’ are the same as those in Tables 2 and 3. The result shows that the method successfully converged and found appropriate solutions with sufficiently small errors in all the tests.

Table 4.

The result of the inverse kinematics computation with the univariate numerical solver (roots) with successive substitutions.

Test	(s)	(s)	(s)	Error (cm)
1	0.245	0.309	4.181
2	0.246	0.306	4.179
3	0.246	0.306	4.179
4	0.247	0.307	4.181
5	0.251	0.313	4.187
6	0.250	0.316	4.197
7	0.254	0.314	4.198
8	0.252	0.307	4.183
9	0.254	0.309	4.186
10	0.253	0.307	4.181
Average	0.250	0.309	4.185

Concluding Remarks

In this paper, we have presented a portable implementation of the inverse kinematics computation of a 3 DOF robot manipulator using Gröbner bases. The implementation is made on the top of Python and SymPy with using Risa/Asir for efficient computation of Gröbner bases and symbolic and/or numerical solvers called within Python for solving a system of algebraic equations. Risa/Asir can easily be called from Python via OpenXM infrastructure.

The experiments have shown the following features of solvers used in solving the system of algebraic equations used in the present computation:

1. Symbolic solver can be used for inverse kinematics computation with high accuracy with the certification of real roots, although the computing time increases.

2. Multivariate numerical solver is often unstable, although it can be used to solve the inverse kinematics problem with high efficiency and accuracy in stable cases.

3. Univariate numerical solver with successive substitutions is stable with high efficiency and accuracy for all the tests in the present paper.

Thus, we see that univariate numerical solver with successive substitutions is effective for solving the inverse kinematics problem in the present case, although certification of real roots may be needed.

For future research, we need to improve implementation for calling Risa/Asir from Python via OpenXM in a more sophisticated way for more efficient computation.7 Furthermore, we intend to extend our implementation for embedding our solver in robotics simulators such as ROS and/or controlling the actual EV3 manipulators including the one we have built in the present paper.