ToddCoxeter< Word >::options

template<typename Word>
struct libsemigroups::ToddCoxeter< Word >::options

This struct containing various options that can be used to control the behaviour of Todd-Coxeter.

Public Types
enum class	def_policy : uint8_t {   no_stack_if_no_space , purge_from_top , purge_all , discard_all_if_no_space ,   unlimited }
	Enum class containing values for specifying how to handle edge definitions. More...
enum class	def_version : uint8_t { one , two }
	Values for specifying how to handle edge definitions. More...
enum class	lookahead_extent { full , partial }
	Enum class for specifying the extent of any lookahead performed. More...
enum class	lookahead_style { hlt , felsch }
	Enum class for specifying the style of any lookahead performed. More...
enum class	strategy {   hlt , felsch , CR , R_over_C ,   Cr , Rc }
	Enum class containing various strategies. More...

Member Enumeration Documentation

def_policy

template<typename Word>

enum class def_policy : uint8_t

strong

The values in this enum can be used as the argument for def_policy.

For our purposes, a definition is a recently defined edge in the word graph that we are attempting to construct in an instance of ToddCoxeter. The values in this enum influence how these definitions are stored and processed.

For every definition held in the definition stack, a depth first search through the Felsch tree of the generating pairs is performed. The aim is to only follow paths from nodes in the word graph labelled by generating pairs that actually pass through the edge described by a definition.

The values in this enum represent what to do if the number of definitions in the stack exceeds the value def_max.

Enumerator
no_stack_if_no_space	Do not put newly generated definitions in the stack if the stack already has size def_max.
purge_from_top	If the definition stack has size def_max and a new definition is generated, then definitions with dead source node are are popped from the top of the stack (if any).
purge_all	If the definition stack has size def_max and a new definition is generated, then definitions with dead source node are are popped from the entire of the stack (if any).
discard_all_if_no_space	If the definition stack has size def_max and a new definition is generated, then all definitions in the stack are discarded.
unlimited	There is no limit to the number of definitions that can be put in the stack.

def_version

template<typename Word>

enum class def_version : uint8_t

strong

The values in this enum can be used as the argument for def_version.

For our purposes, a definition is a recently defined edge in the word graph that we are attempting to construct in an instance of ToddCoxeter. The values in this enum influence how these definitions are stored and processed.

For every definition held in the definition stack, a depth first search through the Felsch tree of the generating pairs is performed. The aim is to only follow paths from nodes in the word graph labelled by generating pairs that actually pass through the edge described by a definition. There are two versions of this represented by the values def_version::one and def_version::two. The first version is simpler, but may involve following the same path that leads nowhere multiple times. The second version is more complex, and attempts to avoid following the same path multiple times if it is found to lead nowhere once.

Enumerator
one	Version 1 definition processing.
two	Version 2 definition processing.

lookahead_extent

template<typename Word>

enum class lookahead_extent

strong

The values in this enum can be used as the argument for lookahead_extent to specify the extent of any lookahead that should be performed.

Enumerator
full	Perform a full lookahead from every node in the word graph. Full lookaheads are therefore sometimes slower but may detect more coincidences than a partial lookahead.
partial	Perform a partial lookahead starting from the current node in the word graph. Partial lookaheads are sometimes faster but may not detect as many coincidences as a full lookahead.

lookahead_style

template<typename Word>

enum class lookahead_style

strong

The values in this enum can be used as the argument for lookahead_style to specify the style of any lookahead that should be performed.

Enumerator
hlt	The lookahead will be done in HLT style by following the paths labelled by every relation from every node in the range specified by lookahead_extent::full or lookahead_extent::partial.
felsch	The lookahead will be done in Felsch style where every edge is considered in every path labelled by a relation in which it occurs.

strategy

template<typename Word>

enum class strategy

strong

The values in this enum can be passed to the member function strategy to define the strategy to be used when performing a congruence enumeration.

Several of the strategies mimic ACE strategies of the same name. The ACE strategy "R*" is equivalent to strategy(options::strategy::hlt).save(true).

Enumerator
hlt	This value indicates that the HLT (Hazelgrove-Leech-Trotter) strategy should be used. This is analogous to ACE's R-style.
felsch	This value indicates that the Felsch strategy should be used. This is analogous to ACE's C-style.
CR	This strategy is meant to mimic the ACE strategy of the same name. The Felsch is run until at least f_defs() nodes are defined, then the HLT strategy is run until at least hlt_defs() divided by \(N\) nodes have been defined, where \(N\) is the sum of the lengths of the words in the presentation and generating pairs. These steps are repeated until the enumeration terminates.
R_over_C	This strategy is meant to mimic the ACE strategy R/C. The HLT strategy is run until the first lookahead is triggered (when the number of active nodes in current_word_graph is at least lookahead_next). A full lookahead is then performed, and then the CR strategy is used.
Cr	This strategy is meant to mimic the ACE strategy Cr. The Felsch strategy is run until at least f_defs() new nodes have been defined, then the HLT strategy is run until at least hlt_defs() divided by \(N\) nodes have been defined, where \(N\) is the sum of the lengths of the words in the presentation and generating pairs. Then the Felsch strategy is run.
Rc	This strategy is meant to mimic the ACE strategy Rc. The HLT strategy is run until at least hlt_defs() divided by \(N\) new nodes have been defined (where \(N\) is the sum of the lengths of the words in the presentation and generating pairs) the Felsch strategy is then run until at least f_defs() new nodes are defined, and then the HLT strategy is run.

---

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

• /Users/jdm/libsemigroups/include/libsemigroups/todd-coxeter-class.hpp