Regina Calculation Engine
Classes | Public Types | Static Public Member Functions | List of all members
regina::LPConstraintEuler Class Reference


A class that constraints the tableaux of normal surface matching equations to ensure that Euler characteristic is strictly positive. More...

#include <enumerate/treeconstraint.h>

Inheritance diagram for regina::LPConstraintEuler:
regina::LPConstraintBase

Classes

struct  Coefficients
 Stores the extra coefficients in the tableaux associated with this constraint class (in this case, one extra integer per column). More...
 

Public Types

enum  { nConstraints = 1 }
 
enum  { nConstraints }
 

Static Public Member Functions

static bool addRows (LPCol< regina::LPConstraintEuler > *col, const int *columnPerm, const Triangulation< 3 > *tri)
 
template<typename IntType >
static void constrain (LPData< regina::LPConstraintEuler, IntType > &lp, unsigned numCols)
 
static bool verify (const NormalSurface *s)
 
static bool verify (const AngleStructure *)
 
static bool supported (NormalCoords coords)
 
static bool addRows (LPCol< LPConstraintBase > *col, const int *columnPerm, const Triangulation< 3 > *tri)
 Explicitly constructs equations for the linear function(s) constrained by this class. More...
 
template<typename IntType >
static void constrain (LPData< LPConstraintNone, IntType > &lp, unsigned numCols)
 Explicitly constraints each of these linear functions to an equality or inequality in the underlying tableaux. More...
 

Detailed Description


A class that constraints the tableaux of normal surface matching equations to ensure that Euler characteristic is strictly positive.

There are many ways of writing Euler characteritic as a linear function. The function constructed here has integer coefficients, but otherwise has no special properties of note.

This constraint can work with either normal or almost normal coordinates. In the case of almost normal coordinates, the function is modified to measure Euler characteristic minus the number of octagons (a technique of Casson, also employed by Jaco and Rubinstein, that is used to ensure we do not have more than two octagons when searching for a normal or almost normal sphere in the 3-sphere recognition algorithm).

See the LPConstraintBase class notes for details on all member functions and structs.

Precondition
We are working in standard normal or almost normal coordinates (not quadrilateral or quadrilateral-octagon coordinates). In particular, the coordinate system passed to the corresponding LPInitialTableaux class constructor must be NS_STANDARD.
Warning
The API for this class has not yet been finalised. This means that the class interface may change in new versions of Regina, without maintaining backward compatibility. If you use this class directly in your own code, please watch the detailed changelogs upon new releases to see if you need to make changes to your code.
Python
Not present.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
inherited
Enumerator
nConstraints 

The number of additional linear constraints that we impose.

Each constraint will generate one new variable (column) and one new equation (row) in the tableaux.

Member Function Documentation

◆ addRows()

static bool regina::LPConstraintBase::addRows ( LPCol< LPConstraintBase > *  col,
const int *  columnPerm,
const Triangulation< 3 > *  tri 
)
staticinherited

Explicitly constructs equations for the linear function(s) constrained by this class.

Specifically, this routine takes an array of Coefficients objects (one for each column of the initial tableaux) and fills in the necessary coefficient data.

The precise form of the linear function(s) will typically depend upon the underlying triangulation. For this reason, the triangulation is explicitly passed, along with the permutation that indicates which columns of the initial tableaux correspond to which normal or angle structure coordinates.

More precisely: recall that, for each linear function, the initial tableaux acquires one new variable x_i that evaluates this linear function f(x). This routine must create the corresponding row that sets f(x) - x_i = 0. Thus it must construct the coefficients of f(x) in the columns corresponding to normal coordinates, and it must also set a coefficient of -1 in the column for the corresponding new variable.

For each subclass S of LPConstraintBase, the array col must be an array of objects of type LPCol<S>. The class LPCol<S> is itself a larger subclass of the Coefficients class. This exact type must be used because the compiler must know how large each column object is in order to correct access each element of the given array.

As described in the LPInitialTableaux class notes, it might not be possible to construct the linear functions (since the triangulation might not satisfy the necessary requirements). In this case, this routine should ensure that the linear functions are in fact the zero functions, and should return false (but it must still set -1 coefficients for the new variables as described above). Otherwise (if the linear function were successfully constructed) this routine should return true.

If you are implementing this routine in a subclass that works with angle structure coordinates, remember that your linear constraints must not interact with the scaling coordinate (the final angle structure coordinate that is used to projectivise the angle structure polytope into a polyhedral cone). Your implementation of this routine must ensure that your linear constraints all have coefficient zero in this column.

Precondition
For all coefficients in the array col, the Coefficients substructures have all been initialised with the default constructor and not modified since.
Parameters
colthe array of columns as stored in the initial tableaux (i.e., the data member LPInitialTableaux::col_).
columnPermthe corresponding permutation of columns that describes how columns of the tableaux correspond to normal or angle structure coordinates in the underlying triangulation (i.e., the data member LPInitialTableaux::columnPerm_).
trithe underlying triangulation.
Returns
true if the linear functions were successfully constructed, or false if not (in which case they will be replaced with the zero functions instead).

◆ constrain()

template<typename IntType >
static void regina::LPConstraintBase::constrain ( LPData< LPConstraintNone, IntType > &  lp,
unsigned  numCols 
)
staticinherited

Explicitly constraints each of these linear functions to an equality or inequality in the underlying tableaux.

This will typically consist of a series of calls to LPData::constrainZero() and/or LPData::constrainPositive().

The variables for these extra linear functions are stored in columns numCols - nConstraints, ..., numCols - 1 of the given tableaux, and so your calls to LPData::constrainZero() and/or LPData::constrainPositive() should operate on these (and only these) columns.

Precondition
These column coefficients belong to the initial starting tableaux (LPInitialTableaux) from which the given tableaux is derived.
Parameters
lpthe tableaux in which to constrain these linear functions.
numColsthe number of columns in the given tableaux.

The documentation for this class was generated from the following file:

Copyright © 1999-2021, The Regina development team
This software is released under the GNU General Public License, with some additional permissions; see the source code for details.
For further information, or to submit a bug or other problem, please contact Ben Burton (bab@maths.uq.edu.au).