Namespaces
namespace	aho_corasick
	Namespace for AhoCorasick helper functions.

namespace	bipartition
	Namespace for Bipartition helper functions.

namespace	blocks
	Namespace for Blocks helper functions.

namespace	bmat8
	Namespace for BMat8 helper functions.

namespace	congruence

namespace	forest
	Helper functions for the Forest class.

namespace	froidure_pin
	This namespace contains helper functions for the FroidurePin class template.

namespace	kambites

namespace	knuth_bendix

namespace	konieczny
	This namespace contains helper functions for the Konieczny class template.

namespace	literals
	Namespace containing some custom literals for creating words.

namespace	matrix
	Namespace for helper functions for matrices.

namespace	paths
	Namespace containing helper functions for the Paths class.

namespace	pbr
	Namespace for PBR helper functions.

namespace	presentation
	Namespace for Presentation helper functions.

namespace	schreier_sims
	Namespace for SchreierSims helper functions.

namespace	sims
	Helper functions for low-index congruences.

namespace	stephen
	Helper functions for the Stephen class.

namespace	todd_coxeter

namespace	ukkonen
	Namespace for Ukkonen helper functions.

namespace	word_graph
	Namespace containing helper functions for the WordGraph class.

namespace	words
	Namespace containing some operators for creating words.

Classes
class	Action
	Class for generating the action of a semigroup. More...

struct	ActionTraits

class	AhoCorasick
	For an implementation of the Aho-Corasick algorithm. More...

class	Bipartition
	Class for representing bipartitions. More...

class	Blocks
	A Blocks object represents a signed partition of the set \(\{0, \ldots, n - 1\}\). More...

class	BMat8
	Fast boolean matrices of dimension up to 8 x 8. More...

struct	BooleanOne
	Function object for returning the multiplicative identity. More...

struct	BooleanPlus
	Function object for addition in the boolean semiring. More...

struct	BooleanProd
	Function object for multiplication in the boolean semiring. More...

struct	BooleanZero
	Function object for returning the additive identity. More...

struct	Complexity
	Adapter for the complexity of multiplication. More...

struct	Complexity< Bipartition >

struct	Complexity< BMat8 >
	Specialization of the adapter Complexity for instances of BMat8. More...

struct	Complexity< HPCombi::BMat8 >
	Specialization of the Complexity adapter for `HPCombi::BMat8`. More...

struct	Complexity< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of Complexity for IsMatrix. More...

struct	Complexity< PBR >
	Specialization of the adapter Complexity for instances of PBR. More...

struct	Complexity< TPTransf16Subclass, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, TPTransf16Subclass > > >
	Specialisation of the Complexity adapter for subclasses of `HPCombi::PTransf16`. More...

struct	Degree
	Adapter for the degree of an element. More...

struct	Degree< BMat8 >
	Specialization of the adapter Degree for instances of BMat8. More...

struct	Degree< HPCombi::BMat8 >
	Specialization of the Degree adapter for `HPCombi::BMat8`. More...

struct	Degree< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of Degree for IsMatrix. More...

struct	Degree< PBR >
	Specialization of the adapter Degree for instances of PBR. More...

struct	Degree< TPTransf16Subclass, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, TPTransf16Subclass > > >
	Specialization of the Degree adapter for `HPCombi::PTransf16`. More...

class	Dot
	A representation of a graph in the DOT language of Graphviz. More...

class	DynamicMatrix< PlusOp, ProdOp, ZeroOp, OneOp, Scalar >
	Class for matrices with compile time arithmetic and run-time dimensions. More...

class	DynamicMatrix< Semiring, Scalar >
	Class for matrices with run-time arithmetic and dimensions. More...

class	DynamicPTransf
	Partial transformations with dynamic degree. More...

class	DynamicRowView< PlusOp, ProdOp, ZeroOp, OneOp, Scalar >
	Row view class for DynamicMatrix (compile-time arithmetic). More...

class	DynamicRowView< Semiring, Scalar >
	Row view class for DynamicMatrix (run-time arithmetic). More...

struct	EqualTo
	Adapter for testing equality. More...

class	Forest
	Class representing a collection of spanning trees of a word graph. More...

class	FroidurePin
	Class implementing the Froidure-Pin algorithm. More...

class	FroidurePinBase
	Base class for FroidurePin containing non-element specific data and member functions. More...

struct	FroidurePinTraits
	Traits class for FroidurePin. More...

class	Gabow
	Class implementing Gabow's algorithm for computing strongly connected components of a WordGraph. More...

struct	Hash
	Adapter for hashing. More...

struct	Hash< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of Hash for IsMatrix. More...

struct	Hash< PBR >
	Specialization of the adapter Hash for instances of PBR. More...

struct	Hash< std::array< T, N > >
	Specialised adapter for hashing arrays. More...

struct	Hash< std::pair< S, T > >
	Specialised adapter for hashing pairs. More...

struct	Hash< std::vector< T > >
	Specialised adapter for hashing vectors. More...

struct	Hash< std::vector< T >, Hasher >
	Specialised adapter for hashing vectors with non-standard hasher. More...

struct	ImageLeftAction
	Adapter for the value of a left action. More...

struct	ImageLeftAction< BMat8, BMat8 >
	Specialization of the adapter ImageLeftAction for instances of BMat8. More...

struct	ImageLeftAction< HPCombi::BMat8, HPCombi::BMat8 >
	Specialization of the ImageLeftAction adapter for `HPCombi::BMat8`. More...

struct	ImageLeftAction< HPCombi::PPerm16, HPCombi::PPerm16 >
	Specialization of the ImageLeftAction adapter for `HPCombi::PTransf16`. More...

struct	ImageLeftAction< HPCombi::Transf16, HPCombi::Vect16 >
	Specialization of the ImageLeftAction adapter for `HPCombi::Transf16`. More...

struct	ImageLeftAction< Mat, Container >
	Specialisation of the ImageLeftAction adapter for BMat. More...

struct	ImageLeftAction< PPerm< N, Scalar >, PPerm< N, Scalar > >

struct	ImageLeftAction< PPerm< N, Scalar >, T >

struct	ImageLeftAction< Transf< N, Scalar >, T >

struct	ImageRightAction
	Adapter for the value of a right action. More...

struct	ImageRightAction< BMat8, BMat8 >
	Specialization of the adapter ImageRightAction for instances of BMat8. More...

struct	ImageRightAction< HPCombi::BMat8, HPCombi::BMat8 >
	Specialization of the ImageRightAction adapter for `HPCombi::BMat8`. More...

struct	ImageRightAction< HPCombi::Perm16, TIntType, std::enable_if_t< std::is_integral_v< TIntType > > >
	Specialization of the ImageRightAction adapter for `HPCombi::PTransf16`. More...

struct	ImageRightAction< HPCombi::PPerm16, HPCombi::PPerm16 >
	Specialization of the ImageRightAction adapter for `HPCombi::PTransf16`. More...

struct	ImageRightAction< HPCombi::Transf16, HPCombi::PTransf16 >
	Specialization of the ImageRightAction adapter for `HPCombi::Transf16`. More...

struct	ImageRightAction< Mat, BitSet< N > >
	Specialisation of the ImageRightAction adapter for BMat and `BitSet`. More...

struct	ImageRightAction< Mat, Container >
	Specialisation of the ImageRightAction adapter for BMat and containers of `BitSet`. More...

struct	ImageRightAction< Perm< N, Scalar >, T, std::enable_if_t< std::is_integral_v< T > > >

struct	ImageRightAction< PPerm< N, Scalar >, BitSet< M > >

struct	ImageRightAction< PPerm< N, Scalar >, PPerm< N, Scalar > >

struct	ImageRightAction< PPerm< N, Scalar >, T >

struct	ImageRightAction< Transf< N, Scalar >, BitSet< M > >

struct	ImageRightAction< Transf< N, Scalar >, T >

struct	IncreaseDegree
	Adapter for increasing the degree of an element. More...

struct	IncreaseDegree< BMat8 >
	Specialization of the adapter IncreaseDegree for instances of BMat8. More...

struct	IncreaseDegree< HPCombi::BMat8 >
	Specialization of the IncreaseDegree adapter for `HPCombi::BMat8`. More...

struct	IncreaseDegree< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of IncreaseDegree for IsMatrix. More...

struct	IncreaseDegree< PBR >
	Specialization of the adapter IncreaseDegree for instances of PBR. More...

struct	IncreaseDegree< T, std::enable_if_t< IsDerivedFromPTransf< T > > >

struct	IntegerOne
	Function object for returning the multiplicative identity. More...

struct	IntegerPlus
	Function object for addition in the ring of integers. More...

struct	IntegerProd
	Function object for multiplication in the ring of integers. More...

struct	IntegerZero
	Function object for returning the additive identity. More...

struct	Inverse
	Adapter for the inverse of an element. More...

struct	Inverse< BMat8 >
	Specialization of the adapter Inverse for instances of BMat8. More...

struct	Inverse< HPCombi::BMat8 >
	Specialization of the Inverse adapter for `HPCombi::BMat8`. More...

struct	Inverse< HPCombi::Perm16 >
	Specialization of the Inverse adapter for `HPCombi::PTransf16`. More...

class	InversePresentation
	For an implementation of inverse presentations for semigroups or monoids. More...

struct	is_specialization_of
	Struct for checking if a template parameter is a specialization of another. More...

struct	is_specialization_of< Primary< Args... >, Primary >
	Struct for checking if a template parameter is a specialization of another. More...

class	IsObviouslyInfinite
	Class for checking if a finitely presented semigroup or monoid is obviously infinite. More...

class	Joiner
	Class for taking joins of word graphs. More...

class	Konieczny
	Class implementing Konieczny's algorithm. More...

struct	KoniecznyTraits
	This is a traits class for use with Konieczny. More...

struct	Lambda
	Adapter for the action on LambdaValue's. More...

struct	Lambda< BMat8, BMat8 >
	Specialization of the adapter Lambda for instances of BMat8. More...

struct	Lambda< HPCombi::BMat8, HPCombi::BMat8 >
	Specialization of the Lambda adapter for `HPCombi::BMat8`. More...

struct	Lambda< HPCombi::PPerm16, HPCombi::PPerm16 >
	Specialization of the Lambda adapter for `HPCombi::PPerm16`. More...

struct	Lambda< HPCombi::Transf16, HPCombi::PTransf16 >
	Specialization of the Lambda adapter for `HPCombi::Transf16`. More...

struct	Lambda< Mat, Container >
	Specialization of the Lambda adapter for BMat. More...

struct	Lambda< PPerm< N, Scalar >, BitSet< M > >

struct	Lambda< Transf< N, Scalar >, BitSet< M > >

struct	Lambda< Transf< N, Scalar >, T >

struct	LambdaValue
	Adapter for lambda functions. More...

struct	LambdaValue< BMat8 >
	Specialization of the adapter LambdaValue for instances of BMat8. More...

struct	LambdaValue< HPCombi::BMat8 >
	Specialization of the LambdaValue adapter for `HPCombi::BMat8`. More...

struct	LambdaValue< HPCombi::PPerm16 >
	Specialization of the LambdaValue adapter for `HPCombi::PPerm16`. More...

struct	LambdaValue< HPCombi::Transf16 >
	Specialization of the LambdaValue adapter for `HPCombi::Transf16`. More...

struct	LambdaValue< Mat >
	Specialisation of the LambdaValue adapter for BMat. More...

struct	LambdaValue< PPerm< N, Scalar > >

struct	LambdaValue< Transf< N, Scalar > >

struct	Less
	Adapter for comparisons. More...

struct	LexicographicalCompare
	A stateless struct with binary call operator using std::lexicographical_compare. More...

struct	LibsemigroupsException
	Exception class deriving from std::runtime_error. More...

struct	MaxPlusPlus
	Function object for addition in the max-plus semiring. More...

struct	MaxPlusProd
	Function object for multiplication in the max-plus semiring. More...

struct	MaxPlusTruncProd
	Function object for multiplication in truncated max-plus semirings. More...

class	MaxPlusTruncSemiring
	Class representing a truncated max-plus semiring. More...

struct	MaxPlusZero
	Function object for returning the additive identity of the max-plus semiring. More...

class	Meeter
	Class for taking meets of word graphs. More...

class	MinimalRepOrc
	For computing the minimal degree of a transformation representation arising from a right congruences of a finite semigroup or monoid. More...

struct	MinPlusPlus
	Function object for addition in the min-plus semiring. More...

struct	MinPlusProd
	Function object for multiplication in the min-plus semiring. More...

struct	MinPlusTruncProd
	Function object for multiplication in min-plus truncated semirings. More...

class	MinPlusTruncSemiring
	Class representing a truncated min-plus semiring. More...

struct	MinPlusZero
	Function object for returning the additive identity of the min-plus semiring. More...

struct	NTPPlus
	Function object for addition in ntp semirings. More...

struct	NTPProd
	Function object for multiplication in an ntp semirings. More...

class	NTPSemiring
	Class representing an ntp semiring. More...

struct	One
	Adapter for the identity element of the given type. More...

struct	One< BMat8 >
	Specialization of the adapter One for instances of BMat8. More...

struct	One< HPCombi::BMat8 >
	Specialization of the One adapter for `HPCombi::BMat8`. More...

struct	One< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of One for IsMatrix. More...

struct	One< PBR >
	Specialization of the adapter One for instances of PBR. More...

struct	One< TPTransf16Subclass, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, TPTransf16Subclass > > >
	Specialisation of the One adapter for `HPCombi::PTransf16`. More...

struct	OnSets
	Adapter for calculating right actions of each element in a container. More...

struct	OnTuples
	Adapter for calculating right actions of each element in a container. More...

class	Paths
	Range for iterating through paths in a WordGraph. More...

class	PBR
	Class for representing PBRs. More...

class	Perm
	Permutations with static or dynamic degree. More...

class	PPerm
	Partial permutations with static or dynamic degree. More...

class	Presentation
	For an implementation of presentations for semigroups or monoids. More...

struct	PresentationBase
	Empty base for presentation-like classes. More...

struct	Product
	Adapter for the product of two elements. More...

struct	Product< BMat8 >
	Specialization of the adapter Product for instances of BMat8. More...

struct	Product< HPCombi::BMat8 >
	Specialization of the Product adapter for `HPCombi::BMat8`. More...

struct	Product< Mat, std::enable_if_t< IsMatrix< Mat > > >
	Specialization of Product for IsMatrix. More...

struct	Product< PBR >
	Specialization of the adapter Product for instances of PBR. More...

struct	Product< TPTransf16Subclass, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, TPTransf16Subclass > > >
	Specialisation of the Product adapter for `HPCombi::PTransf16`. More...

class	PTransfBase
	Base class for partial transformations. More...

struct	Random
	Aggregator for choosing a single random item in a range. More...

struct	Rank
	Adapter for calculating ranks. More...

struct	Rank< BMat8 >
	Specialization of the adapter Rank for instances of BMat8. More...

struct	Rank< HPCombi::BMat8 >
	Specialization of the Rank adapter for `HPCombi::BMat8`. More...

struct	Rank< Mat, RankState< Mat > >
	Specialization of the Rank adapter for BMat. More...

struct	Rank< PPerm< N, Scalar > >

struct	Rank< T, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, T >, RankState< T > > >
	Specialization of the Rank adapter for `HPCombi` types. More...

struct	Rank< Transf< N, Scalar > >

class	RankState
	Base class for states for ranks. More...

class	RankState< Mat >
	Specialisation of the RankState adapter for BMat. More...

struct	RecursivePathCompare
	A stateless struct with binary call operator using recursive_path_compare. More...

class	RepOrc
	For computing small degree transformation representations of a finite semigroup or monoid. More...

class	Reporter
	Collection of values related to reporting. More...

struct	ReportGuard
	Struct for specifying whether or not to report about an algorithm's performance. More...

struct	Rho
	Adapter for the action on RhoValue's. More...

struct	Rho< BMat8, BMat8 >
	Specialization of the adapter Rho for instances of BMat8. More...

struct	Rho< HPCombi::BMat8, HPCombi::BMat8 >
	Specialization of the Rho adapter for `HPCombi::BMat8`. More...

struct	Rho< HPCombi::PPerm16, HPCombi::PPerm16 >
	Specialization of the Rho adapter for `HPCombi::PPerm16`. More...

struct	Rho< HPCombi::Transf16, HPCombi::Vect16 >
	Specialization of the Rho adapter for `HPCombi::Transf16`. More...

struct	Rho< Mat, Container >
	Specialization of the Rho adapter for Transf, `std::vector<BitSet<N>>` and `StaticVector1<BitSet<N>>`. More...

struct	Rho< PPerm< N, Scalar >, BitSet< M > >

struct	Rho< Transf< N, Scalar >, T >

struct	RhoValue
	Adapter for rho functions. More...

struct	RhoValue< BMat8 >
	Specialization of the adapter RhoValue for instances of BMat8. More...

struct	RhoValue< HPCombi::BMat8 >
	Specialization of the RhoValue adapter for `HPCombi::BMat8`. More...

struct	RhoValue< HPCombi::PPerm16 >
	Specialization of the RhoValue adapter for `HPCombi::PPerm16`. More...

struct	RhoValue< HPCombi::Transf16 >
	Specialization of the RhoValue adapter for `HPCombi::Transf16`. More...

struct	RhoValue< Mat >
	Specialization of the RhoValue adapter for BMat. More...

struct	RhoValue< PPerm< N, Scalar > >

struct	RhoValue< Transf< N, Scalar > >

class	Runner
	Abstract class for derived classes that run an algorithm. More...

class	SchreierSims
	A deterministic version of the Schreier-Sims algorithm acting on a small number of points. More...

struct	SchreierSimsTraits
	Traits class for use with the class template SchreierSims. More...

struct	ShortLexCompare
	A stateless struct with binary call operator using shortlex_compare. More...

class	Sims1
	For computing finite index right congruences of a finitely presented semigroup or monoid. More...

class	Sims2
	For computing finite index two-sided congruences of a finitely presented semigroup or monoid. More...

class	SimsRefinerFaithful
	For pruning the search tree when looking for congruences arising from right or two-sided congruences representing faithful actions. More...

class	SimsRefinerIdeals
	For pruning the search tree when looking for congruences arising from right or two-sided ideals. More...

class	SimsSettings
	For setting the presentation and various runtime parameters of the Sims low index algorithm. More...

class	SimsStats
	For keeping track of various statistics arising during the runtime of the low index algorithm. More...

struct	SmallestInteger
	Type giving the smallest unsigned integer type that can represent a template. More...

class	StaticMatrix
	Static matrix class. More...

class	StaticPTransf
	Partial transformations with static degree. More...

class	StaticRowView
	Class for views into a row of a matrix over a semiring. More...

class	Stephen
	For constructing the word graph of left factors of a word in an f.p. semigroup. More...

class	StringRange
	Class for generating strings in a given range and in a particular order. More...

struct	Swap
	Adapter for swapping. More...

struct	Swap< TPTransf16Subclass, std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, TPTransf16Subclass > > >
	Specialization of the Swap adapter for `HPCombi::PTransf16`. More...

class	ToString
	Class for converting word_type into std::string with specified alphabet. More...

class	ToWord
	Class for converting strings to word_type with specified alphabet. More...

class	Transf
	Transformations with static or dynamic degree. More...

class	Ukkonen
	For an implementation of Ukkonen's algorithm. More...

class	WordGraph
	Class for representing word graphs. More...

class	WordRange
	Class for generating words in a given range and in a particular order. More...

Typedefs
template<size_t R = 0, size_t C = R>
using	BMat = std::conditional_t<R == 0 \|\| C == 0, DynamicBMat, StaticBMat<R, C>>
	Alias template for boolean matrices.

template<size_t N>
using	BMatFastest = typename detail::BMatFastestHelper<N>::type
	Type of the fastest type of boolean matrix of given dimension.

using	DynamicBMat = DynamicMatrix<BooleanPlus, BooleanProd, BooleanZero, BooleanOne, int>
	Alias for dynamic boolean matrices.

template<typename Scalar>
using	DynamicIntMat
	Alias for dynamic integer matrices.

template<typename Scalar>
using	DynamicMaxPlusMat
	Alias for dynamic max-plus matrices.

template<size_t T, typename Scalar>
using	DynamicMaxPlusTruncMat
	Alias for dynamic truncated max-plus matrices.

template<typename Scalar>
using	DynamicMinPlusMat
	Alias for dynamic min-plus matrices.

template<size_t T, typename Scalar>
using	DynamicMinPlusTruncMat
	Alias for dynamic truncated min-plus matrices.

template<size_t T, size_t P, typename Scalar>
using	DynamicNTPMatWithoutSemiring
	Alias for ntp matrices with static threshold and period.

template<typename Scalar>
using	DynamicNTPMatWithSemiring = DynamicMatrix<NTPSemiring<Scalar>, Scalar>
	Alias for ntp matrices with dynamic threshold and period.

template<typename Scalar>
using	DynamicProjMaxPlusMat = detail::ProjMaxPlusMat<DynamicMaxPlusMat<Scalar>>
	Alias for dynamic projective max-plus matrices with run-time dimensions.

template<typename Given, typename Expected>
using	enable_if_is_same = std::enable_if_t<std::is_same_v<Given, Expected>, Expected>
	Alias equal to the second template parameter if both template parameters are equal.

template<size_t R = 0, size_t C = R, typename Scalar = int>
using	IntMat
	Alias template for integer matrices.

template<size_t N>
using	LeastPerm = typename detail::LeastPermHelper<N>::type
	Type of perms using the least memory for a given degree.

template<size_t N>
using	LeastPPerm = typename detail::LeastPPermHelper<N>::type
	Type of partial perms using the least memory for a given degree.

template<size_t N>
using	LeastTransf = typename detail::LeastTransfHelper<N>::type
	Type of transformations using the least memory for a given degree.

template<typename Element, typename Point, typename Func = ImageLeftAction<Element, Point>, typename Traits = ActionTraits<Element, Point>>
using	LeftAction = Action<Element, Point, Func, Traits, side::left>

using	letter_type = size_t
	Type for the index of a generator of a semigroup.

using	LimitMax = detail::Constant<-2, detail::Max>
	Type for the maximum value of something.

template<size_t R = 0, size_t C = R, typename Scalar = int>
using	MaxPlusMat
	Alias template for max-plus matrices.

template<size_t T = 0, size_t R = 0, size_t C = R, typename Scalar = int>
using	MaxPlusTruncMat
	Alias template for truncated max-plus matrices.

template<size_t R = 0, size_t C = R, typename Scalar = int>
using	MinPlusMat
	Alias template for min-plus matrices.

template<size_t T = 0, size_t R = 0, size_t C = R, typename Scalar = int>
using	MinPlusTruncMat
	Alias template for truncated min-plus matrices.

using	NegativeInfinity = detail::Constant<0, detail::Min>
	Type for negative infinity.

template<size_t T = 0, size_t P = 0, size_t R = 0, size_t C = R, typename Scalar = size_t>
using	NTPMat
	Alias template for ntp matrices.

using	PositiveInfinity = detail::Constant<-1, detail::Max>
	Type for positive infinity.

template<size_t R = 0, size_t C = R, typename Scalar = int>
using	ProjMaxPlusMat
	Alias template for projective max-plus matrices.

template<size_t N = 0, typename Scalar = std::conditional_t<N == 0, uint32_t, typename SmallestInteger<N>::type>>
using	PTransf
	Partial transformations with static or dynamic degree.

using	relation_type = std::pair<word_type, word_type>
	Type for a pair of word_type (a relation) of a semigroup.

template<typename Element, typename Point, typename Func = ImageRightAction<Element, Point>, typename Traits = ActionTraits<Element, Point>>
using	RightAction = Action<Element, Point, Func, Traits, side::right>

template<size_t R, size_t C>
using	StaticBMat
	Alias for static boolean matrices.

template<size_t R, size_t C, typename Scalar>
using	StaticIntMat
	Alias for static integer matrices.

template<size_t R, size_t C, typename Scalar>
using	StaticMaxPlusMat
	Alias for static max-plus matrices.

template<size_t T, size_t R, size_t C, typename Scalar>
using	StaticMaxPlusTruncMat
	Alias for static truncated max-plus matrices.

template<size_t R, size_t C, typename Scalar>
using	StaticMinPlusMat
	Alias for static min-plus matrices.

template<size_t T, size_t R, size_t C, typename Scalar>
using	StaticMinPlusTruncMat
	Alias for static truncated min-plus matrices.

template<size_t T, size_t P, size_t R, size_t C, typename Scalar>
using	StaticNTPMat
	Alias for ntp matrices with static threshold and period, and dimensions.

template<size_t R, size_t C, typename Scalar>
using	StaticProjMaxPlusMat = detail::ProjMaxPlusMat<StaticMaxPlusMat<R, C, Scalar>>
	Alias for static projective max-plus matrices with compile-time arithmetic and dimensions.

using	Undefined = detail::Constant<0, detail::Max>
	Type for undefined values.

using	word_type = std::vector<letter_type>
	Type for a word over the generators of a semigroup.

Enumerations
enum class	congruence_kind { onesided = 1 , twosided = 2 }
	Enum to indicate the sided-ness of a congruence. More...

enum class	Order : uint8_t { none = 0 , shortlex , lex , recursive }
	The possible orderings of words and strings. More...

enum class	side { left , right }
	Enum class indicating the handedness or side of an action. More...

enum class	tril { FALSE = 0 , TRUE = 1 , unknown = 2 }
	Enum to indicate true, false or not currently knowable. More...

Functions
template<typename Iterator1, typename Iterator2>
	FroidurePin (Iterator1, Iterator2) -> FroidurePin< std::decay_t< decltype(*std::declval< Iterator1 >())> >

template<typename Node>
	Gabow (WordGraph< Node > const &) -> Gabow< Node >
	Deduction guide for Gabow objects.

template<typename Node>
	Paths (WordGraph< Node > &&) -> Paths< Node >

template<typename Node>
	Paths (WordGraph< Node > const &) -> Paths< Node >

template<typename Node1, typename Node2>
auto	cbegin_pilo (WordGraph< Node1 > const &wg, Node2 source, size_t min=0, size_t max=POSITIVE_INFINITY)
	Returns an iterator for pilo (Path And Node In Lex Order).

template<typename Node1, typename Node2>
auto	cbegin_pislo (WordGraph< Node1 > const &wg, Node2 source, size_t min=0, size_t max=POSITIVE_INFINITY)

template<typename Node1, typename Node2>
auto	cbegin_pstilo (WordGraph< Node1 > const &wg, Node2 source, Node2 target, size_t min=0, size_t max=POSITIVE_INFINITY)

template<typename Node1, typename Node2>
auto	cbegin_pstislo (WordGraph< Node1 > const &wg, Node2 source, Node2 target, size_t min=0, size_t max=POSITIVE_INFINITY)

detail::const_wilo_iterator	cbegin_wilo (size_t n, size_t upper_bound, word_type &&first, word_type &&last)
	Returns a forward iterator pointing to the 3rd parameter `first`.

detail::const_wilo_iterator	cbegin_wilo (size_t n, size_t upper_bound, word_type const &first, word_type const &last)
	Returns a forward iterator pointing to the 3rd parameter `first`.

detail::const_wislo_iterator	cbegin_wislo (size_t n, word_type &&first, word_type &&last)
	Returns a forward iterator pointing to the 2nd parameter `first`.

detail::const_wislo_iterator	cbegin_wislo (size_t n, word_type const &first, word_type const &last)
	Returns a forward iterator pointing to the 2nd parameter `first`.

template<typename Node>
auto	cend_pilo (WordGraph< Node > const &wg)

template<typename Node>
auto	cend_pislo (WordGraph< Node > const &wg)

template<typename Node>
auto	cend_pstilo (WordGraph< Node > const &wg)

template<typename Node>
auto	cend_pstislo (WordGraph< Node > const &wg)

detail::const_wilo_iterator	cend_wilo (size_t n, size_t upper_bound, word_type &&first, word_type &&last)
	Returns a forward iterator pointing to one after the end of the range from `first` to `last`.

detail::const_wilo_iterator	cend_wilo (size_t n, size_t upper_bound, word_type const &first, word_type const &last)
	Returns a forward iterator pointing to one after the end of the range from `first` to `last`.

detail::const_wislo_iterator	cend_wislo (size_t n, word_type &&first, word_type &&last)
	Returns a forward iterator pointing to one after the end of the range from `first` to `last`.

detail::const_wislo_iterator	cend_wislo (size_t n, word_type const &first, word_type const &last)
	Returns a forward iterator pointing to one after the end of the range from `first` to `last`.

template<typename S, typename T>
auto	chain (S const &x, T const &y)
	Chain objects (const references).

template<typename Word>
	Congruence (Congruence< Word > &&) -> Congruence< Word >
	Deduction guide.

template<typename Word>
	Congruence (Congruence< Word > const &) -> Congruence< Word >
	Deduction guide.

template<typename Word>
	Congruence (congruence_kind, Presentation< Word > &&) -> Congruence< Word >
	Deduction guide.

template<typename Word>
	Congruence (congruence_kind, Presentation< Word > const &) -> Congruence< Word >
	Deduction guide.

template<typename T>
static size_t	COUNT_TRUES_BLOCK (T block)

static std::chrono::nanoseconds	delta (std::chrono::high_resolution_clock::time_point const &t)
	The time between a given point and now.

template<typename T>
std::vector< typename T::point_type >	domain (T const &f)
	Returns the set of points where a partial transformation is defined.

template<typename T, typename Scalar>
void	domain (T const &f, std::vector< Scalar > &dom)
	Replace the contents of a vector by the set of points where a partial transformation is defined.

template<typename T>
auto	enumerate (T const &thing)
	Enumerate an object (by const reference).

template<typename Range1, typename Range2>
bool	equal (Range1 r1, Range2 r2)
	Check two ranges for equality.

template<typename PresentationType>
bool	equal_to_no_checks (Stephen< PresentationType > const &x, Stephen< PresentationType > const &y)
	Check equality of two Stephen instances (no checks).

template<typename... Args>
std::string	fmt_default (std::string_view sv, Args &&... args)
	No doc.

template<typename T>
bool	freeband_equal_to (T first1, T last1, T first2, T last2)
	Check if two words represent the same element of a free band (iterators).

template<typename T>
bool	freeband_equal_to (T x, T y)
	Check if two words represent the same element of a free band (non-`word_type`).

bool	freeband_equal_to (word_type const &x, word_type const &y)
	Check if two words represent the same element of a free band.

template<typename T>
std::vector< typename T::point_type >	image (T const &f)
	Returns the set of images of a partial transformation.

template<typename T, typename Scalar>
void	image (T const &f, std::vector< Scalar > &im)
	Replace the contents of a vector by the set of images of a partial transformation.

template<size_t N, typename Scalar>
Perm< N, Scalar >	inverse (Perm< N, Scalar > const &f)
	Returns the inverse of a permutation.

template<size_t N, typename Scalar>
void	inverse (Perm< N, Scalar > const &from, Perm< N, Scalar > &to)
	Returns the inverse of a permutation.

template<size_t N, typename Scalar>
PPerm< N, Scalar >	inverse (PPerm< N, Scalar > const &f)
	Returns the inverse of a partial perm.

template<size_t N, typename Scalar>
void	inverse (PPerm< N, Scalar > const &from, PPerm< N, Scalar > &to)
	Replace contents of a partial perm with the inverse of another.

template<typename Word>
bool	is_obviously_infinite (Congruence< Word > &c)
	Function for checking if a congruence obviously has infinite many classes.

template<typename Rewriter, typename ReductionOrder>
bool	is_obviously_infinite (detail::KnuthBendixImpl< Rewriter, ReductionOrder > &kb)
	Function for checking if the quotient of a finitely presented semigroup or monoid defined by a KnuthBendix object is obviously infinite or not.

bool	is_obviously_infinite (detail::ToddCoxeterImpl const &tc)
	Function for checking if the quotient of a finitely presented semigroup or monoid defined by a ToddCoxeterImpl object is obviously infinite or not.

template<typename Word>
bool	is_obviously_infinite (Kambites< Word > &k)
	Function for checking if the finitely presented semigroup or monoid defined by a Kambites object obviously has infinite many classes.

template<>
bool	is_obviously_infinite (Presentation< std::string > const &p)
	Function for checking if the finitely presented semigroup or monoid defined by a Presentation object is obviously infinite or not.

template<typename Word>
bool	is_obviously_infinite (Presentation< Word > const &p)
	Function for checking if the finitely presented semigroup or monoid defined by a Presentation object is obviously infinite or not.

template<typename Range>
bool	is_sorted (Range r)
	Check if a range is sorted according to std::less.

template<typename Range, typename Compare>
bool	is_sorted (Range r, Compare &&comp)
	Check if a range is sorted according to `comp`.

template<typename Word>
	Kambites (congruence_kind, Presentation< Word > &&) -> Kambites< Word >
	Deduction guide.

template<typename Word>
	Kambites (congruence_kind, Presentation< Word > const &) -> Kambites< Word >
	Deduction guide.

template<typename Word>
	Kambites (Kambites< Word > &&) -> Kambites< Word >
	Deduction guide.

template<typename Word>
	Kambites (Kambites< Word > const &) -> Kambites< Word >
	Deduction guide.

template<typename Word>
	KnuthBendix (congruence_kind, Presentation< Word > &&) -> KnuthBendix< Word >
	Deduction guide.

template<typename Word>
	KnuthBendix (congruence_kind, Presentation< Word > const &) -> KnuthBendix< Word >
	Deduction guide.

template<typename Word>
	KnuthBendix (KnuthBendix< Word > &&) -> KnuthBendix< Word >
	Deduction guide.

template<typename Word>
	KnuthBendix (KnuthBendix< Word > const &) -> KnuthBendix< Word >
	Deduction guide.

template<size_t N, typename Scalar>
PPerm< N, Scalar >	left_one (PPerm< N, Scalar > const &f)
	Returns the left one of a partial perm.

template<typename Range1, typename Range2>
bool	lexicographical_compare (Range1 r1, Range2 r2)
	Check if a range is lexicographically less than another.

template<typename T>
bool	lexicographical_compare (T const x, T const y)
	Compare two objects via their pointers using std::lexicographical_compare.

template<typename T, typename = std::enable_if_t<!rx::is_input_or_sink_v<T>>>
bool	lexicographical_compare (T const &x, T const &y)
	Compare two objects of the same type using std::lexicographical_compare.

template<typename Return, typename Container>
enable_if_is_same< Return, HPCombi::Transf16 >	make (Container &&cont)
	Construct a HPCombi::Transf16 from universal reference and check.

template<typename Return, typename Container>
enable_if_is_same< Return, HPCombi::Perm16 >	make (Container &&cont)
	Construct a HPCombi::Perm16 from universal reference and check.

template<typename Return, typename Container>
enable_if_is_same< Return, HPCombi::PPerm16 >	make (Container &&cont)
	Construct a HPCombi::PPerm16 from container and check.

template<typename Return, typename Container>
enable_if_is_same< Return, Blocks >	make (Container const &cont)
	Check the arguments, construct a Blocks object, and check it.

template<typename Return, typename Container>
enable_if_is_same< Return, Bipartition >	make (Container const &cont)
	Check the arguments, construct a bipartition, and check it.

template<template< typename... > typename Thing, typename Container, typename Traits = KoniecznyTraits<typename Container::value_type>>
std::enable_if_t< std::is_same_v< Konieczny< typename Container::value_type, Traits >, Thing< typename Container::value_type, Traits > >, Konieczny< typename Container::value_type, Traits > >	make (Container const &gens)
	Safely construct from generators.

template<template< typename... > typename Thing, typename Container, typename Element = typename Container::value_type>
auto	make (Container const &gens) -> std::enable_if_t< std::is_same_v< Thing< Element >, FroidurePin< Element > >, FroidurePin< Element > >
	Construct a FroidurePin iinstance from container of generators.

template<template< typename... > typename Thing, typename Iterator1, typename Iterator2, typename Element = std::decay_t<decltype(*std::declval<Iterator1>())>>
auto	make (Iterator1 first, Iterator2 last) -> std::enable_if_t< std::is_same_v< Thing< Element >, FroidurePin< Element > >, FroidurePin< Element > >
	Construct a FroidurePin instance from range of elements given by iterators.

template<typename Return, typename OtherContainer>
std::enable_if_t< IsTransf< Return >, Return >	make (OtherContainer &&cont)
	Construct a Transf from universal reference container and check.

template<typename Return, typename OtherContainer>
std::enable_if_t< IsPPerm< Return >, Return >	make (OtherContainer &&cont)
	Construct a PPerm from universal reference container and check.

template<typename Return, typename OtherContainer>
std::enable_if_t< IsPerm< Return >, Return >	make (OtherContainer &&cont)
	Construct from universal reference container and check.

template<typename Return>
enable_if_is_same< Return, PBR >	make (PBR::initializer_list_type< int32_t > left, PBR::initializer_list_type< int32_t > right)
	Construct and check a PBR.

template<typename Return>
enable_if_is_same< Return, PBR >	make (PBR::initializer_list_type< uint32_t > args)
	Construct and check a PBR.

template<typename Return>
enable_if_is_same< Return, PBR >	make (PBR::vector_type< int32_t > left, PBR::vector_type< int32_t > right)
	Construct and check a PBR.

template<typename Mat, typename Semiring, typename = std::enable_if_t<IsMatrix<Mat>>>
Mat	make (Semiring const *semiring, std::initializer_list< std::initializer_list< typename Mat::scalar_type > > const &rows)
	Constructs a matrix (from std::initializer_list) and checks it.

template<typename Mat, typename Semiring, typename = std::enable_if_t<IsMatrix<Mat>>>
Mat	make (Semiring const *semiring, std::initializer_list< typename Mat::scalar_type > const &row)
	Constructs a row and checks it.

template<typename Mat, typename Semiring, typename = std::enable_if_t<IsMatrix<Mat>>>
Mat	make (Semiring const *semiring, std::vector< std::vector< typename Mat::scalar_type > > const &rows)
	Constructs a matrix (from std::vector of std::vector) and checks it.

template<typename Return>
std::enable_if_t< is_specialization_of_v< Return, WordGraph >, Return >	make (size_t num_nodes, std::initializer_list< std::vector< typename Return::node_type > > targets)
	Constructs a word graph from a number of nodes and targets.

template<typename Return>
std::enable_if_t< is_specialization_of_v< Return, WordGraph >, Return >	make (size_t num_nodes, std::vector< std::vector< typename Return::node_type > > const &targets)
	Constructs a word graph from a number of nodes and targets.

template<template< typename... > typename Thing, typename Element, typename Traits = KoniecznyTraits<Element>>
std::enable_if_t< std::is_same_v< Konieczny< Element, Traits >, Thing< Element, Traits > >, Konieczny< Element, Traits > >	make (std::initializer_list< Element > const &gens)
	Safely construct from generators.

template<template< typename... > typename Thing, typename Element>
auto	make (std::initializer_list< Element > gens) -> std::enable_if_t< std::is_same_v< Thing< Element >, FroidurePin< Element > >, FroidurePin< Element > >
	Construct a FroidurePin instance from std::initializer_list of generators.

template<typename Return, typename Int>
enable_if_is_same< Return, HPCombi::PPerm16 >	make (std::initializer_list< Int > dom, std::initializer_list< Int > ran, size_t M)
	Construct a HPCombi::PPerm16 from domain, range, and degree, and check.

template<typename Return, typename OtherScalar>
std::enable_if_t< IsTransf< Return >, Return >	make (std::initializer_list< OtherScalar > cont)
	Construct a Transf from initializer list and check.

template<size_t R, size_t C, typename Scalar>
ProjMaxPlusMat< R, C, Scalar >	make (std::initializer_list< std::initializer_list< Scalar > > const &rows)
	Constructs a projective max-plus matrix (from std::initializer_list) and checks it.

template<typename Return>
enable_if_is_same< Return, Blocks >	make (std::initializer_list< std::vector< int32_t > > const &cont)
	Check the arguments, construct a Blocks object, and check it.

template<typename Return>
enable_if_is_same< Return, Bipartition >	make (std::initializer_list< std::vector< int32_t > > const &cont)
	Check the arguments, construct a Blocks object, and check it.

template<typename Mat, typename = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
Mat	make (std::initializer_list< std::vector< typename Mat::scalar_type > > const &rows)
	Checks the arguments, constructs a matrix, and checks it.

template<typename Mat, typename = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
Mat	make (std::initializer_list< typename Mat::scalar_type > const &row)
	Constructs a row and checks it.

template<typename Return>
std::enable_if_t< IsPPerm< Return >, Return >	make (std::initializer_list< typename Return::point_type > cont)
	Construct a PPerm from initializer list and check.

template<typename Return>
std::enable_if_t< IsPerm< Return >, Return >	make (std::initializer_list< typename Return::point_type > cont)
	Construct from universal reference container and check.

template<typename Return>
std::enable_if_t< IsPPerm< Return >, Return >	make (std::initializer_list< typename Return::point_type > dom, std::initializer_list< typename Return::point_type > ran, size_t M)
	Construct a PPerm from domain, range, and degree, and check.

template<typename Return>
enable_if_is_same< Return, Bipartition >	make (std::initializer_list< uint32_t > const &cont)
	Check the arguments, construct a bipartition, and check it.

template<typename Return>
enable_if_is_same< Return, Forest >	make (std::initializer_list< uint32_t > parent, std::initializer_list< uint32_t > edge_labels)
	Construct a Forest from parents and labels.

template<typename Return>
std::enable_if_t< std::is_base_of_v< HPCombi::PTransf16, Return >, Return >	make (std::initializer_list< uint8_t > &&cont)
	Construct a HPCombi::Transf16 from universal reference and check.

template<typename Mat, typename = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
Mat	make (std::vector< std::vector< typename Mat::scalar_type > > const &rows)
	Checks the arguments, constructs a matrix, and checks it.

template<typename Return>
std::enable_if_t< IsPPerm< Return >, Return >	make (std::vector< typename Return::point_type > const &dom, std::vector< typename Return::point_type > const &ran, size_t M)
	Construct a PPerm from domain, range, and degree, and check.

template<typename Return>
enable_if_is_same< Return, Forest >	make (std::vector< uint32_t > const &parent, std::vector< uint32_t > const &edge_labels)
	Construct a Forest from parents and labels.

template<typename Return>
enable_if_is_same< Return, HPCombi::PPerm16 >	make (std::vector< uint8_t > const &dom, std::vector< uint8_t > const &ran, size_t deg=16)
	Construct a HPCombi::PPerm16 from domain, range, and degree, and check.

template<typename Return, typename... T>
enable_if_is_same< Return, PBR >	make (T... args)
	Construct and check a PBR.

template<typename Node1, typename Node2>
uint64_t	number_of_paths (WordGraph< Node1 > const &wg, Node2 source)

template<typename Node1, typename Node2>
uint64_t	number_of_paths (WordGraph< Node1 > const &wg, Node2 source, Node2 target, size_t min, size_t max, paths::algorithm lgrthm=paths::algorithm::automatic)

template<typename Node1, typename Node2>
uint64_t	number_of_paths (WordGraph< Node1 > const &wg, Node2 source, size_t min, size_t max, paths::algorithm lgrthm=paths::algorithm::automatic)

template<typename Node1, typename Node2>
paths::algorithm	number_of_paths_algorithm (WordGraph< Node1 > const &wg, Node2 source) noexcept

template<typename Node1, typename Node2>
paths::algorithm	number_of_paths_algorithm (WordGraph< Node1 > const &wg, Node2 source, Node2 target, size_t min, size_t max)

template<typename Node1, typename Node2>
paths::algorithm	number_of_paths_algorithm (WordGraph< Node1 > const &wg, Node2 source, size_t min, size_t max)

uint64_t	number_of_words (size_t n, size_t min, size_t max)
	Returns the number of words over an alphabet with a given number of letters with length in a specified range.

template<typename T>
auto	one (T const &f) -> std::enable_if_t< IsDerivedFromPTransf< T >, T >
	Returns the identity transformation of same degree as a sample.

bool	operator!= (Bipartition const &x, Bipartition const &y)
	Check bipartitions for inequality.

template<typename Word>
bool	operator!= (InversePresentation< Word > const &lhop, InversePresentation< Word > const &rhop)
	Compare for inequality.

template<typename Word>
bool	operator!= (Presentation< Word > const &lhop, Presentation< Word > const &rhop)
	Compare for inequality.

bool	operator!= (PBR const &x, PBR const &y)
	Compare two PBRs for inequality.

Bipartition	operator* (Bipartition const &x, Bipartition const &y)
	Multiply two bipartitions.

constexpr BMat8	operator* (bool scalar, BMat8 const &x) noexcept
	Multiplication operator.

template<typename Mat>
auto	operator* (typename Mat::scalar_type a, Mat const &x) -> std::enable_if_t< IsMatrix< Mat >, Mat >
	Multiply a matrix by a scalar.

PBR	operator* (PBR const &x, PBR const &y)
	Multiply two PBRs.

template<typename Mat>
auto	operator+ (typename Mat::scalar_type a, Mat const &x) -> std::enable_if_t< IsMatrix< Mat >, Mat >
	Add a scalar to a matrix.

std::ostream &	operator<< (std::ostream &os, BMat8 const &x)
	Insertion operator.

std::ostream &	operator<< (std::ostream &os, detail::TCE const &x)
	No doc.

template<typename Word, typename Rewriter, typename ReductionOrder>
std::ostream &	operator<< (std::ostream &os, KnuthBendix< Word, Rewriter, ReductionOrder > const &kb)
	Insert into std::ostream.

template<typename Range, typename = std::enable_if_t<rx::is_input_or_sink_v<Range>>>
std::ostream &	operator<< (std::ostream &os, Range r)
	Insert a range into an output stream.

template<typename Node>
std::ostream &	operator<< (std::ostream &os, WordGraph< Node > const &wg)

std::ostringstream &	operator<< (std::ostringstream &os, BMat8 const &x)
	Insertion operator.

template<typename S, typename T>
std::ostringstream &	operator<< (std::ostringstream &os, detail::RowViewCommon< S, T > const &x)
	Insertion operator for row views.

std::ostringstream &	operator<< (std::ostringstream &os, detail::TCE const &x)
	No doc.

template<typename Mat>
auto	operator<< (std::ostringstream &os, Mat const &x) -> std::enable_if_t< IsMatrix< Mat >, std::ostringstream & >
	Insertion operator for matrices.

bool	operator<= (Bipartition const &x, Bipartition const &y)
	Compare bipartitions.

bool	operator<= (PBR const &x, PBR const &y)
	Convenience function that just calls operator< and operator==.

template<typename Word>
bool	operator== (InversePresentation< Word > const &lhop, InversePresentation< Word > const &rhop)
	Compare for equality.

template<typename Word>
bool	operator== (Presentation< Word > const &lhop, Presentation< Word > const &rhop)
	Compare for equality.

template<typename PresentationType>
bool	operator== (Stephen< PresentationType > const &x, Stephen< PresentationType > const &y)
	Check equality of two Stephen instances.

bool	operator> (Bipartition const &x, Bipartition const &y)
	Compare bipartitions.

bool	operator> (PBR const &x, PBR const &y)
	Convenience function that just calls operator<.

bool	operator>= (Bipartition const &x, Bipartition const &y)
	Compare bipartitions.

bool	operator>= (PBR const &x, PBR const &y)
	Convenience function that just calls operator<=.

template<typename Word>
	Presentation (Presentation< Word > &&) -> Presentation< Word >
	Deduction guide.

template<typename Word>
	Presentation (Presentation< Word > const &) -> Presentation< Word >
	Deduction guide.

std::string	random_string (std::string const &alphabet, size_t length)
	Returns a random string.

std::string	random_string (std::string const &alphabet, size_t min, size_t max)
	Returns a random string.

auto	random_strings (std::string const &alphabet, size_t number, size_t min, size_t max)
	Returns a range object of random strings.

word_type	random_word (size_t length, size_t nr_letters)
	Returns a random word.

template<typename T>
bool	recursive_path_compare (T const x, T const y) noexcept
	Compare two objects via their pointers using recursive_path_compare.

template<typename T, typename = std::enable_if_t<!rx::is_input_or_sink_v<T>>>
bool	recursive_path_compare (T const &first1, T last1, T const &first2, T last2) noexcept
	Compare two objects of the same type using the recursive path comparison.

template<typename T, typename = std::enable_if_t<!rx::is_input_or_sink_v<T>>>
bool	recursive_path_compare (T const &x, T const &y) noexcept
	Compare two objects of the same type using recursive_path_compare.

template<typename... Args>
void	report_default (std::string_view sv, Args &&... args)
	No doc.

std::mutex &	report_mutex ()
	No doc.

template<typename... Args>
void	report_no_lock_no_prefix (std::string_view sv, Args &&... args)
	No doc.

template<typename... Args>
void	report_no_prefix (std::string_view sv, Args &&... args)
	No doc.

bool	reporting_enabled () noexcept
	No doc.

template<typename Word>
Word &	reverse (Word &&w)
	Reverse an object.

template<size_t N, typename Scalar>
PPerm< N, Scalar >	right_one (PPerm< N, Scalar > const &f)
	Returns the right one of a partial perm.

template<typename Range1, typename Range2>
bool	shortlex_compare (Range1 r1, Range2 r2)
	Check if a range is shortlex less than another.

template<typename T>
bool	shortlex_compare (T const x, T const y)
	Compare two objects via their pointers using shortlex_compare.

template<typename T, typename = std::enable_if_t<!rx::is_input_or_sink_v<T>>>
bool	shortlex_compare (T const &first1, T const &last1, T const &first2, T const &last2)
	Compare two objects of the same type using the short-lex reduction ordering.

template<typename T, typename = std::enable_if_t<!rx::is_input_or_sink_v<T>>>
bool	shortlex_compare (T const &x, T const &y)
	Compare two objects of the same type using shortlex_compare.

	Stephen (InversePresentation< word_type > &&) -> Stephen< InversePresentation< word_type > >
	Deduction guide.

	Stephen (InversePresentation< word_type > &) -> Stephen< InversePresentation< word_type > >
	Deduction guide.

	Stephen (InversePresentation< word_type > const &) -> Stephen< InversePresentation< word_type > >
	Deduction guide.

	Stephen (Presentation< word_type > &&) -> Stephen< Presentation< word_type > >
	Deduction guide.

	Stephen (Presentation< word_type > &) -> Stephen< Presentation< word_type > >
	Deduction guide.

	Stephen (Presentation< word_type > const &) -> Stephen< Presentation< word_type > >
	Deduction guide.

	Stephen (std::shared_ptr< InversePresentation< word_type > > &&) -> Stephen< InversePresentation< word_type > >
	Deduction guide.

	Stephen (std::shared_ptr< Presentation< word_type > > &&) -> Stephen< Presentation< word_type > >
	Deduction guide.

template<typename Scalar, typename Container>
void	throw_if_image_value_out_of_range (PTransfBase< Scalar, Container > const &f)
	Check a partial transformation.

template<size_t N, typename Scalar>
void	throw_if_image_value_out_of_range (Transf< N, Scalar > const &f)
	Check a transformation.

template<size_t N, typename Scalar>
auto	throw_if_not_perm (Perm< N, Scalar > const &f)
	Check a permutation.

template<size_t N, typename Scalar>
void	throw_if_not_pperm (PPerm< N, Scalar > const &f)
	Check a partial perm.

template<template< typename... > typename Thing, typename Word>
auto	to (Congruence< Word > &cong) -> std::enable_if_t< std::is_same_v< Thing< int >, FroidurePin< int > >, std::unique_ptr< FroidurePinBase > >
	Convert a Congruence object to a FroidurePin object.

template<typename Result>
auto	to (congruence_kind knd, FroidurePinBase &fpb) -> std::enable_if_t< std::is_same_v< KnuthBendix< typename Result::native_word_type, typename Result::rewriter_type >, Result >, Result >
	Convert a FroidurePin object to a KnuthBendix object.

template<typename Result, typename Node>
auto	to (congruence_kind knd, FroidurePinBase &fpb, WordGraph< Node > const &wg) -> std::enable_if_t< std::is_same_v< Congruence< typename Result::native_word_type >, Result >, Result >
	Convert a FroidurePin object to a Congruence object.

template<template< typename... > typename Thing, typename Word, typename Rewriter, typename ReductionOrder>
auto	to (congruence_kind knd, KnuthBendix< Word, Rewriter, ReductionOrder > &kb) -> std::enable_if_t< std::is_same_v< ToddCoxeter< Word >, Thing< Word > >, ToddCoxeter< Word > >
	Convert a KnuthBendix object to a ToddCoxeter object.

template<typename Result>
auto	to (congruence_kind knd, ToddCoxeter< typename Result::native_word_type > &tc) -> std::enable_if_t< std::is_same_v< KnuthBendix< typename Result::native_word_type, typename Result::rewriter_type >, Result >, Result >
	Convert a ToddCoxeter object to a KnuthBendix object.

template<template< typename... > typename Thing, typename Word>
auto	to (congruence_kind knd, ToddCoxeter< Word > &tc) -> std::enable_if_t< std::is_same_v< Thing< Word >, KnuthBendix< Word > >, KnuthBendix< Word > >
	Convert a ToddCoxeter object to a KnuthBendix object.

template<typename Result, typename Node>
auto	to (congruence_knd knd, FroidurePinBase &fpb, WordGraph< Node > const &wg) -> std::enable_if_t< std::is_same_v< ToddCoxeter< typename Result::native_word_type >, Result >, Result >
	Convert a FroidurePin object to a ToddCoxeter object.

template<typename Result, typename Rewriter, typename ReductionOrder>
auto	to (detail::KnuthBendixImpl< Rewriter, ReductionOrder > &kb) -> std::enable_if_t< std::is_same_v< Presentation< typename Result::word_type >, Result >, Result >
	No doc.

template<template< typename... > typename Thing>
auto	to (detail::ToddCoxeterImpl &tc) -> std::enable_if_t< std::is_same_v< Thing< detail::TCE >, FroidurePin< detail::TCE > >, FroidurePin< detail::TCE > >
	Convert a ToddCoxeter object to a FroidurePin object.

template<typename Result>
auto	to (FroidurePinBase &fp) -> std::enable_if_t< std::is_same_v< Presentation< typename Result::word_type >, Result >, Result >
	Make a presentation from a FroidurePin object.

template<typename Result, typename Word>
auto	to (InversePresentation< Word > const &ip) noexcept -> std::enable_if_t< std::is_same_v< InversePresentation< typename Result::word_type >, Result > &&!std::is_same_v< Word, typename Result::word_type >, Result >
	Make an inverse presentation from a different type of inverse presentation.

template<typename Result, typename Word, typename Func>
auto	to (InversePresentation< Word > const &ip, Func &&f) -> std::enable_if_t< std::is_same_v< InversePresentation< typename Result::word_type >, Result >, Result >
	Make an inverse presentation from a different type of inverse presentation.

template<template< typename... > typename Thing, typename Word>
auto	to (Kambites< Word > &k) -> std::enable_if_t< std::is_same_v< Thing< detail::KE< Word > >, FroidurePin< detail::KE< Word > > >, FroidurePin< detail::KE< Word > > >
	Convert a Kambites object to a FroidurePin object.

template<template< typename... > typename Thing, typename Word, typename Rewriter typename ReductionOrder>
auto	to (KnutBendix< Word, Rewriter, ReductionOrder > &kb) -> std::enable_if_t< std::is_same_v< Thing< Word >, Presentation< Word > >, Presentation< Word > >
	Make a presentation from a KnuthBendix object.

template<template< typename... > typename Thing, typename Word, typename Rewriter, typename ReductionOrder>
auto	to (KnuthBendix< Word, Rewriter, ReductionOrder > &kb) -> std::enable_if_t< std::is_same_v< Thing< int >, FroidurePin< int > >, FroidurePin< detail::KBE< KnuthBendix< Word, Rewriter, ReductionOrder > > > >
	Convert a KnuthBendix object to a FroidurePin object.

template<typename Result, typename WordIn, typename Rewriter, typename ReductionOrder>
auto	to (KnuthBendix< WordIn, Rewriter, ReductionOrder > &kb) -> std::enable_if_t< std::is_same_v< Presentation< typename Result::word_type >, Result >, Result >
	Make a presentation from a KnuthBendix object.

template<template< typename... > typename Thing, typename Element, typename Traits>
auto	to (Konieczny< Element, Traits > const &k) -> std::enable_if_t< std::is_same_v< Thing< int >, FroidurePin< int > >, FroidurePin< Element > >
	Convert a Konieczny object to a FroidurePin object.

template<typename Result, typename Word>
auto	to (Presentation< Word > const &p) -> std::enable_if_t< std::is_same_v< Presentation< typename Result::word_type >, Result > &&!std::is_same_v< typename Result::word_type, Word >, Result >
	Make a presentation from a different type of presentation.

template<typename Result, typename Word, typename Func>
auto	to (Presentation< Word > const &p, Func &&f) -> std::enable_if_t< std::is_same_v< Presentation< typename Result::word_type >, Result >, Result >
	Make a presentation from a different type of presentation.

template<typename Result, typename Node>
auto	to (WordGraph< Node > const &wg) -> std::enable_if_t< std::is_same_v< FroidurePin< typename Result::element_type >, Result >, Result >
	Convert a WordGraph object to a FroidurePin object.

template<typename Result, typename Node>
auto	to (WordGraph< Node > const &wg, size_t first, size_t last) -> std::enable_if_t< std::is_same_v< FroidurePin< typename Result::element_type >, Result >, Result >
	Convert a WordGraph object to a FroidurePin object.

std::string	to_human_readable_repr (Dot const &d)
	Return a human readable representation of a Dot object.

std::string	to_human_readable_repr (Dot::Kind const &k, std::string const &sep="::")
	Return a human readable representation of a Dot::Kind object.

std::string	to_human_readable_repr (Forest const &f)
	Return a human readable representation of a Forest object.

template<typename Element, typename Traits>
std::string	to_human_readable_repr (FroidurePin< Element, Traits > const &fp)
	Return a human readable representation of a FroidurePin object.

template<typename Node>
std::string	to_human_readable_repr (Gabow< Node > const &g)
	Return a human readable representation of a Gabow object.

template<typename Node>
std::string	to_human_readable_repr (Paths< Node > const &p)
	Return a human readable representation of a Paths object.

std::string	to_human_readable_repr (PBR const &x)
	Return a human readable representation of a PBR.

template<typename Element, typename Point, typename Func, typename Traits, side LeftOrRight>
std::string	to_human_readable_repr (Action< Element, Point, Func, Traits, LeftOrRight > const &action)
	Return a human readable representation of an Action object.

std::string	to_human_readable_repr (AhoCorasick const &ac)
	Return a string representation.

std::string	to_human_readable_repr (Bipartition const &x, std::string_view braces="{}", size_t max_width=72)
	Return a human readable representation of a bipartition.

std::string	to_human_readable_repr (Blocks const &x, std::string_view braces="{}", size_t max_width=72)
	Return a human readable representation of a blocks object.

std::string	to_human_readable_repr (BMat8 const &x, std::string const &braces="{}")
	Returns a string representation.

template<typename Word>
std::string	to_human_readable_repr (Congruence< Word > const &c)
	Return a human readable representation of a Congruence object.

template<typename Word>
std::string	to_human_readable_repr (InversePresentation< Word > const &p)
	Return a human readable representation of an InversePresentation.

static std::string	to_human_readable_repr (Joiner const &join)
	Return a human readable representation of a Joiner object.

template<typename Word>
std::string	to_human_readable_repr (Kambites< Word > const &k)
	Return a human readable representation of a Kambites object.

template<typename Word, typename Rewriter, typename ReductionOrder>
std::string	to_human_readable_repr (KnuthBendix< Word, Rewriter, ReductionOrder > &kb)
	Return a string representation of a KnuthBendix instance.

template<typename Element, typename Traits>
std::string	to_human_readable_repr (Konieczny< Element, Traits > const &x)
	Return a human readable representation of a Konieczny object.

template<typename Mat>
auto	to_human_readable_repr (Mat const &x, std::string const &prefix, std::string const &short_name="", std::string const &braces="{}", size_t max_width=72) -> std::enable_if_t< IsMatrix< Mat >, std::string >
	Returns a human readable representation of a matrix.

static std::string	to_human_readable_repr (Meeter const &meet)
	Return a human readable representation of a Meeter object.

std::string	to_human_readable_repr (MinimalRepOrc const &x)
	Return a human readable representation of a MinimalRepOrc object.

template<size_t N, typename Scalar>
std::string	to_human_readable_repr (Perm< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}", size_t max_width=72)
	Return a human readable representation of a Perm object.

template<size_t N, typename Scalar>
std::string	to_human_readable_repr (PPerm< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}", size_t max_width=72)
	Return a human readable representation of a PPerm object.

template<typename Word>
std::string	to_human_readable_repr (Presentation< Word > const &p)
	Return a human readable representation of a presentation.

std::string	to_human_readable_repr (RepOrc const &x)
	Return a human readable representation of a RepOrc object.

template<size_t N, typename Point, typename Element, typename Traits>
std::string	to_human_readable_repr (SchreierSims< N, Point, Element, Traits > const &S, size_t max_width=72)
	Returns a human readable representation of a SchreierSims object.

std::string	to_human_readable_repr (Sims1 const &x)
	Return a human readable representation of a Sims1 object.

std::string	to_human_readable_repr (Sims2 const &x)
	Return a human readable representation of a Sims2 object.

std::string	to_human_readable_repr (SimsRefinerFaithful const &x)
	Return a human readable representation of a SimsRefinerFaithful object.

std::string	to_human_readable_repr (SimsRefinerIdeals const &x)
	Return a human readable representation of a SimsRefinerIdeals object.

std::string	to_human_readable_repr (SimsStats const &x)
	Return a human readable representation of a SimsStats object.

template<typename PresentationType>
std::string	to_human_readable_repr (Stephen< PresentationType > const &x)
	Return a human readable representation of a Stephen instance.

std::string	to_human_readable_repr (StringRange const &sr, size_t max_width=72)
	Return a human readable representation of a StringRange object.

template<typename Word>
std::string	to_human_readable_repr (ToddCoxeter< Word > const &tc)
	Return a human readable representation of a ToddCoxeter object.

std::string	to_human_readable_repr (ToString const &tstr)
	Return a human readable representation of a ToString object.

template<size_t N, typename Scalar>
std::string	to_human_readable_repr (Transf< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}", size_t max_width=72)
	Return a human readable representation of a Transf object.

template<typename Element, typename Traits>
std::string	to_human_readable_repr (typename Konieczny< Element, Traits >::DClass const &x)
	Return a human readable representation of a Konieczny::DClass object.

std::string	to_human_readable_repr (Ukkonen const &u)
	Return a human readable representation of an Ukkonen object.

std::string	to_human_readable_repr (Ukkonen::Node const &node, std::string const &sep="::")
	Return a human readable representation of an Ukkonen::Node object.

std::string	to_human_readable_repr (Ukkonen::State const &st, std::string const &sep="::")
	Return a human readable representation of an Ukkonen::State object.

template<typename Node>
std::string	to_human_readable_repr (WordGraph< Node > const &wg)
	Return a human readable representation of a WordGraph object.

std::string	to_human_readable_repr (WordRange const &wr, size_t max_width=72)
	Return a human readable representation of a WordRange object.

template<size_t N, typename Scalar>
std::string	to_input_string (Perm< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}")
	Return a string that can be used to recreate a permutation.

template<size_t N, typename Scalar>
std::string	to_input_string (PPerm< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}")
	Return a string that can be used to recreate a partial permutation.

template<size_t N, typename Scalar>
std::string	to_input_string (Transf< N, Scalar > const &x, std::string_view prefix="", std::string_view braces="{}")
	Return a string that can be used to recreate a transformation.

template<typename Node>
std::string	to_input_string (WordGraph< Node > const &wg, std::string const &prefix="", std::string const &braces="{}", std::string const &suffix="")
	Return a string that can be used to recreate a word graph.

template<typename Word>
	ToddCoxeter (congruence_kind, Presentation< Word > &&) -> ToddCoxeter< Word >
	Deduction guide.

template<typename Word>
	ToddCoxeter (congruence_kind, Presentation< Word > const &) -> ToddCoxeter< Word >
	Deduction guide.

template<typename Word>
	ToddCoxeter (congruence_kind, ToddCoxeter< Word > const &) -> ToddCoxeter< Word >
	Deduction guide.

template<typename Node>
	ToddCoxeter (congruence_kind, WordGraph< Node > &&) -> ToddCoxeter< word_type >
	Deduction guide.

template<typename Node>
	ToddCoxeter (congruence_kind, WordGraph< Node > const &) -> ToddCoxeter< word_type >
	Deduction guide.

template<typename Word>
	ToddCoxeter (ToddCoxeter< Word > &&) -> ToddCoxeter< Word >
	Deduction guide.

template<typename Word>
	ToddCoxeter (ToddCoxeter< Word > const &) -> ToddCoxeter< Word >
	Deduction guide.

Variables
template<size_t N>
constexpr uint64_t	BitSet< N >::MASK [64]

constexpr std::chrono::nanoseconds	FOREVER = std::chrono::nanoseconds::max()
	Value indicating forever (system dependent but possibly approx. 292 years).

template<typename Thing, template< typename... > typename Primary>
constexpr bool	is_specialization_of_v = is_specialization_of<Thing, Primary>::value
	Helper variable template for is_specialization_of.

template<typename Thing>
static constexpr bool	IsBipartition = std::is_same_v<std::decay_t<Thing>, Bipartition>
	Helper variable template.

template<typename T>
static constexpr bool	IsBitSet = detail::IsBitSetHelper<T>::value

template<typename T>
static constexpr bool	IsBMat = detail::IsBMatHelper<T>::value
	Helper to check if a type is BMat.

template<typename T>
static constexpr bool	IsDerivedFromPTransf = std::is_base_of_v<detail::PTransfPolymorphicBase, T>
	Helper variable template.

template<typename T>
static constexpr bool	IsDynamic = detail::IsDynamicHelper<T>::value
	Helper variable template.

template<typename T>
constexpr bool	IsDynamicMatrix = IsMatrix<T> && !IsStaticMatrix<T>
	Helper variable template.

template<typename T>
static constexpr bool	IsIntMat = detail::IsIntMatHelper<T>::value
	Helper variable template.

template<typename Thing>
static constexpr bool	IsInversePresentation = is_specialization_of_v<Thing, InversePresentation>
	Helper variable template.

template<typename T>
constexpr bool	IsMatrix = detail::IsMatrixHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsMatWithSemiring = detail::IsMatWithSemiringHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsMaxPlusMat = detail::IsMaxPlusMatHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsMaxPlusTruncMat = detail::IsMaxPlusTruncMatHelper<T>::value
	Helper to check if a type is MaxPlusTruncMat.

template<typename T>
static constexpr bool	IsMinPlusMat = detail::IsMinPlusMatHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsMinPlusTruncMat = detail::IsMinPlusTruncMatHelper<T>::value
	Helper to check if a type is MinPlusTruncMat.

template<typename U>
static constexpr bool	IsNTPMat = detail::IsNTPMatHelper<U>::value
	Helper to check if a type is NTPMat.

template<typename Thing>
static constexpr bool	IsPBR = std::is_same_v<Thing, PBR>
	Helper variable template.

template<typename T>
static constexpr bool	IsPerm = detail::IsPermHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsPPerm = detail::IsPPermHelper<T>::value
	Helper variable template.

template<typename Thing>
static constexpr bool	IsPresentation = is_specialization_of_v<Thing, Presentation>
	Helper variable template.

template<typename T>
static constexpr bool	IsProjMaxPlusMat = detail::IsProjMaxPlusMatHelper<T>::value
	Helper to check if a type is ProjMaxPlusMat.

template<typename T>
static constexpr bool	IsPTransf = detail::IsPTransfHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsStatic = detail::IsStaticHelper<T>::value
	Helper variable template.

template<typename T>
constexpr bool	IsStaticMatrix = detail::IsStaticMatrixHelper<T>::value
	Helper variable template.

template<typename T>
static constexpr bool	IsTransf = detail::IsTransfHelper<T>::value
	Helper variable template.

template<typename Thing>
static constexpr bool	IsWordGraph = is_specialization_of_v<Thing, WordGraph>
	Helper variable template.

LimitMax const	LIMIT_MAX
	Value for the maximum of something.

NegativeInfinity const	NEGATIVE_INFINITY
	Value for negative infinity.

PositiveInfinity const	POSITIVE_INFINITY
	Value for positive infinity.

Undefined const	UNDEFINED
	Value for something undefined.

Function Documentation

◆ equal_to_no_checks()

template<typename PresentationType>

bool equal_to_no_checks	(	Stephen< PresentationType > const &	x,
		Stephen< PresentationType > const &	y )

This function triggers a run of the Stephen algorithm of x and y, if it hasn't been run already, and then checks that x.word() equals y.word() in the underlying semigroup.

Parameters

x	a Stephen instance.
y	a Stephen instance.

Returns: A const_iterator_left_factors.

Exceptions

LibsemigroupsException if no presentation was set at the construction of s or with Stephen::init or if no word was set with Stephen::set_word .

Warning: Termination of the Stephen algorithm is undecidable in general, and this function may never terminate..; No checks are made on the validity of the parameters to this function. Bad things may happen if x and y have different underlying presentations.

◆ operator==()

template<typename PresentationType>

bool operator==	(	Stephen< PresentationType > const &	x,
		Stephen< PresentationType > const &	y )

This function triggers a run of the Stephen algorithm of x and y, if it hasn't been run already, and then checks that x.word() equals y.word() in the underlying semigroup.

Parameters

x	a Stephen instance.
y	a Stephen instance.

Returns: A const_iterator_left_factors.

Exceptions

LibsemigroupsException	if no presentation was set at the construction of `s` or with Stephen::init or if no word was set with Stephen::set_word .
LibsemigroupsException	if the presentations for `x` and `y` differ.

Warning: Termination of the Stephen algorithm is undecidable in general, and this function may never terminate..

◆ to_human_readable_repr() [1/9]

std::string to_human_readable_repr	(	Blocks const &	x,
		std::string_view	braces = "{}",
		size_t	max_width = 72 )

nodiscard

Return a human readable representation (std::string) of a Blocks object. The braces to be used in the returns string can be specified using the argument braces. By default the returned string can be used to reconstruct the bipartition x. If the width of this returned string would be greater than max_width, then an abbreviated string is returned instead.

Parameters

x	the Blocks object.
braces	the braces to use in the returned string (default: `"{}"`).
max_width	the maximum width of the returned string (default: `72`).

Returns: A std::string representation of x.

Exceptions

LibsemigroupsException if braces does not have length 2.

◆ to_human_readable_repr() [2/9]

template<typename PresentationType>

std::string to_human_readable_repr ( Stephen< PresentationType > const & x )

nodiscard

Return a human readable representation of a Stephen instance.

Parameters

x	the Stephen instance.

Exceptions: This function guarantees not to throw a LibsemigroupsException.

Variable Documentation

◆ IsPBR

template<typename Thing>

bool IsPBR = std::is_same_v<Thing, PBR>

staticconstexpr

The value of this variable is true if the template parameter Thing is PBR.

Template Parameters

Thing a type.

Warning: This alias is deprecated and will be removed from libsemigroups in v4, please use std::is_same_v<Thing, PBR> instead.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Function Documentation

◆ equal_to_no_checks()

◆ operator==()

◆ to_human_readable_repr() [1/9]

◆ to_human_readable_repr() [2/9]

Variable Documentation

◆ IsPBR