The first run
Below we show how BertiniLab can be used to set up and solve a simple example, the system of equations


The solution set consists of the four points:

Contents
Defining the problem
The main input for Bertini is the input file. A simple example of such an input file is shown below:
variable_group x,y; function f,g;
f = x^2 - 1; g = y^2 - 4; END;
Bertini is then run with the command
bertini input
A BertiniLab equivalent to the input file is shown below:
polysyms x y f = x^2 - 1; g = y^2 - 4; poly_system = BertiniLab('variable_group',[x; y],'function_def',[f; g]);
The object poly_system looks like this:
disp(poly_system)
BertiniLab with properties:
config: [1x1 struct]
function_def: [2x1 polysym]
variable: []
variable_group: [2x1 polysym]
hom_variable_group: []
pathvariable: []
random: []
random_real: []
definedSubfunction: []
parameter: [0x2 polysym]
constant: [0x2 polysym]
subfunction: [0x2 polysym]
starting_points: []
final_parameters: []
member_points: []
interactive_choices: {}
Bertini_io_folder: ''
view_progress: 0
components: [0x0 struct]
solve_summary: ''
function_name: [2x1 polysym]
order_of_variables: [2x1 polysym]
There are many different ways of setting up BertiniLab for the same problem. In this example, the variables and equations are input as cell arrays of strings:
poly_system = BertiniLab('variable_group',{'x';'y'},'function_def',{'x^2-1'; 'y^2-1'});
In this example, a MATLAB function is used:
polysyms x y polyFun = @(a,b) [a^2-1; b^2-1]; poly_system = BertiniLab('variable_group',[x; y],'function_def',polyFun(x,y));
In this example, the variables and declarations are assigned separately:
poly_system = BertiniLab;
poly_system.variable_group = {'x';'y'};
poly_system.function_def = {'x^2-1'; 'y^2-1'};
Running Bertini
Once the problem is defined, it is solved using the method solve. This creates the file input and runs Bertini.
poly_system = poly_system.solve;
Note that poly_system should be the output of the command (the LHS of the above equation) so it can store some information from the run. The resulting object poly_system is shown below:
disp(poly_system)
BertiniLab with properties:
config: [1x1 struct]
function_def: [2x1 polysym]
variable: []
variable_group: [2x1 polysym]
hom_variable_group: []
pathvariable: []
random: []
random_real: []
definedSubfunction: []
parameter: [0x2 polysym]
constant: [0x2 polysym]
subfunction: [0x2 polysym]
starting_points: []
final_parameters: []
member_points: []
interactive_choices: {}
Bertini_io_folder: ''
view_progress: 0
components: [0x0 struct]
solve_summary: '
Bertini(TM) v1.4
(October 23, 2013)
D....'
function_name: [2x1 polysym]
order_of_variables: [2x1 polysym]
A lot of the properties are empty, but function_def and variable_group are assigned; and after solve was called, values are assigned to order_of_variables, solve_summary and output_file_names.
order_of_variables stores the order in which the variables were declared in the Bertini input file:
disp(poly_system.order_of_variables)
x y
output_file_names retrieves the names of the files that were created by Bertini during its run:
disp(poly_system.output_file_names(:))
'main_data'
'raw_solutions'
'raw_data'
'real_finite_solutions'
'finite_solutions'
'nonsingular_solutions'
'singular_solutions'
Finally, solve_summary contains the summary of the run that would go to the screen if Bertini were called in a command window:
disp(poly_system.solve_summary)
Bertini(TM) v1.4
(October 23, 2013)
D.J. Bates, J.D. Hauenstein,
A.J. Sommese, C.W. Wampler
(using GMP v5.1.3, MPFR v3.1.2)
NOTE: You have requested to use adaptive path tracking. Please make sure that you have
setup the following tolerances appropriately:
CoeffBound: 2.105837000000e+00, DegreeBound: 2.000000000000e+00
AMPSafetyDigits1: 1, AMPSafetyDigits2: 1, AMPMaxPrec: 1024
Tracking path 0 of 4
Finite Solution Summary
NOTE: nonsingular vs singular is based on condition number and identical endpoints
| Number of real solns | Number of non-real solns | Total
------------------------------------------------------------------------------------------
Non-singular | 4 | 0 | 4
Singular | 0 | 0 | 0
------------------------------------------------------------------------------------------
Total | 4 | 0 | 4
Finite Multiplicity Summary
Multiplicity | Number of real solns | Number of non-real solns
------------------------------------------------------------------------------------------
1 | 4 | 0
------------------------------------------------------------------------------------------
The following files may be of interest to you:
main_data: A human-readable version of the solutions - main output file.
raw_solutions: A list of the solutions with the corresponding path numbers.
raw_data: Similar to the previous, but with the points in Bertini's homogeneous
coordinates along with more information about the solutions.
real_finite_solutions: A list of all real finite solutions.
finite_solutions: A list of all finite solutions.
nonsingular_solutions: A list of all nonsingular solutions.
singular_solutions: A list of all singular solutions.
------------------------------------------------------------------------------------------
Paths Tracked: 4
Retrieving the solutions
The output summary explains the outputs of Bertini. If the users wishes to simply retrieve the solution points, all of them are contained in raw_solutions. Since the solutions are real, nonsingular and finite, they should all be in finite_solutions, real_finite_solutions and nonsingular_solutions. The method match_solutions retrieves the data and assigns it to the correct variables:
sols = poly_system.match_solutions('real_finite_solutions');
disp(sols)
x: [1x4 polysym]
y: [1x4 polysym]
The solutions are:
disp([sols.x sols.y])
1.000000000000000e+00+(0.000000000000000e+00)*I 1.000000000000000e+00+(-2.775557561562891e-17)*I -1.000000000000000e+00+(0.000000000000000e+00)*I -9.999999999999999e-01+(5.551115123125783e-17)*I 1.000000000000000e+00+(0.000000000000000e+00)*I -1.000000000000000e+00+(2.775557561562891e-17)*I 1.000000000000000e+00+(0.000000000000000e+00)*I -9.999999999999999e-01+(5.551115123125783e-17)*I
That's a bit messy. Since the solutions are classified as real, the imaginary part can be ignored. The class polysym has the method real_imag to do this, and we can add the variable names as titles by putting the polysym variables in the top row:
[x_re,~] = sols.x.real_imag; [y_re,~] = sols.y.real_imag; disp([x x_re; y y_re].')
x y
1.000000000000000e+00 1.000000000000000e+00
1.000000000000000e+00 -1.000000000000000e+00
-1.000000000000000e+00 1.000000000000000e+00
-9.999999999999999e-01 -9.999999999999999e-01
The solutions can also be converted to other classes such as double precision:
disp(double([x_re y_re]))
Columns 1 through 7
1.0000 1.0000 -1.0000 -1.0000 1.0000 -1.0000 1.0000
Column 8
-1.0000