dedekind::category Namespace Reference

Namespaces
namespace	detail_arrows
	The endomorphisms of T that have a storage class, as three coproducts, each an arrow by case analysis and a coproduct by construction (the Jlt paper, Listing 2).
namespace	detail_comprehension
namespace	detail_involution
	An involution is an endomorphism once read on its object: the implication holds of the lifted arrow, endo<T>(f), and not of a bare callable such as std::logical_not<bool>, which is a family of arrows, one per type, and no IsArrow until endo names its domain.
namespace	detail_kleisli
namespace	detail_lattice_nodes
namespace	operations
	Composition as an operation, the function object whose call is f >> g, so that a fold or a shape can take it as it takes std::plus; the operator stays what the partitions overload, and this only names it (the standard made the same move for + and never for >>). It lives in a namespace of its own, so that lookup by argument reaches no law function of the tree's (:species' associative) and a shape stating the laws of its own finds only those.

Classes
struct	free_algebra_base
	free_algebra_base<F>: carrier-side declaration that F is the free algebra over some base R (the textbook companion to HSP; cf. Burris–Sankappanavar §II.11). Specialise the ::type member at the carrier-defining partition (e.g. Polynomial<R, M> in algebra:polynomial records free_algebra_base<Polynomial<R, M>>::type = R). More...
struct	construction_base< F >
struct	SpeciesTraits< dedekind::algebra::𝔽64 >
struct	is_cyclic_group< bool, std::bit_xor< bool > >
struct	cyclic_order< bool, std::bit_xor< bool > >
struct	is_cyclic_group< dedekind::algebra::𝔽64, std::multiplies< dedekind::algebra::𝔽64 > >
struct	cyclic_order< dedekind::algebra::𝔽64, std::multiplies< dedekind::algebra::𝔽64 > >
struct	SpeciesTraits< dedekind::algebra::OneDimensionalVector< S, Tag > >
struct	SpeciesTraits< dedekind::algebra::Monomial< N > >
struct	unit_trait< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > >
struct	is_exact_total< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > >
struct	free_algebra_base< dedekind::algebra::Polynomial< R, M > >
struct	unit_trait< dedekind::algebra::Polynomial< R, M >, std::plus< dedekind::algebra::Polynomial< R, M > > >
struct	unit_trait< dedekind::algebra::Polynomial< R, M >, std::multiplies< dedekind::algebra::Polynomial< R, M > > >
struct	is_periodic< dedekind::algebra::Polynomial< R, M >, std::plus< dedekind::algebra::Polynomial< R, M > > >
struct	is_periodic< dedekind::algebra::Polynomial< R, M >, std::multiplies< dedekind::algebra::Polynomial< R, M > > >
struct	quotient_algebra_base
	quotient_algebra_base<Q>: carrier-side declaration that Q is a quotient of some base algebra. Specialise the ::type member at the carrier-defining partition (e.g.\ Complex<R> in numbers:complex records quotient_algebra_base<Complex<R>>::type = R). More...
struct	construction_base< Q >
struct	quotient_congruence
	quotient_congruence<Q>: carrier-side declaration of the congruence witnessing Q = V/R. ::type is the relation R, ::carrier is the carrier V that R lives on (R is a homogeneous relation on V). Mirrors the S-leg's subalgebra_base. More...
struct	quotient_congruence< detail_quotient::IntByEquality >
struct	product_algebra_base
	product_algebra_base<Q>: carrier-side declaration that Q is a finite direct product of some base algebra (the P operation in Birkhoff HSP). Specialise the ::type member at the carrier-defining partition (e.g.\ Vec2V<T> in linear_algebra:vec2 records product_algebra_base<Vec2V<T>>::type = T). More...
struct	is_linear_action< Q, product_algebra_base_t< Q >, std::plus< Q >, std::plus< product_algebra_base_t< Q > >, std::multiplies< product_algebra_base_t< Q > >, std::multiplies<> >
struct	subalgebra_base
	subalgebra_base: carrier-side declaration that S is a subalgebra of some base algebra (the S operation in Birkhoff HSP). Specialise the ::type member at the carrier-defining partition; the propagation specs below then lift the species-trait pins from base to S. More...
struct	construction_base< S >
struct	is_associative< T, Op >
struct	is_commutative< T, Op >
struct	is_periodic< T, Op >
struct	inverse_trait< T, Op >
struct	unit_trait< T, Op, void >
struct	unit_trait< dedekind::algebra::Tropical< T, M >, dedekind::algebra::TropicalPlus, void >
	⊕-identity is the ∞ sentinel. More...
struct	unit_trait< dedekind::algebra::Tropical< T, M >, std::plus< dedekind::algebra::Tropical< T, M > >, void >
	⊗-identity is 0. More...
struct	is_saturating< dedekind::algebra::Tropical< T, M >, std::plus< dedekind::algebra::Tropical< T, M > > >
	⊗ (= T's + with the ∞ sentinel absorbing) is total exactly when T's own + is total: the ∞ boundary saturates, and the finite part inherits T's totality. Gated on IsMagma<T> so the certificate is honest — true for a periodic carrier such as unsigned (defined wraparound, no UB), false for long long (signed overflow is not a magma; cf. the !IsMagma<int,+> rejection in category/total.cppm). More...
struct	is_linear_action< dedekind::algebra::𝔽64, bool, std::plus< dedekind::algebra::𝔽64 >, std::bit_xor< bool >, std::bit_and< bool >, std::multiplies<> >
struct	is_linear_action< std::uint64_t, bool, std::bit_xor< std::uint64_t >, std::bit_xor< bool >, std::bit_and< bool >, dedekind::algebra::Bit2U64Action >
struct	quotient_algebra_base< dedekind::analysis::Dual< F > >
struct	is_linear_action< dedekind::analysis::Dual< F >, F, std::plus< dedekind::analysis::Dual< F > >, std::plus< F >, std::multiplies< F >, std::multiplies<> >
struct	is_exact_total< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >
struct	is_exact_total< dedekind::analysis::Dual< F >, std::multiplies< dedekind::analysis::Dual< F > > >
struct	unit_trait< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >
struct	unit_trait< dedekind::analysis::Dual< F >, std::multiplies< dedekind::analysis::Dual< F > > >
struct	inverse_trait< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >
struct	is_homomorphism< std::decay_t< decltype(dedekind::analysis::embed_ℝ_𝔻)>, dedekind::numbers::QuadraticReal< 2 >, std::plus< dedekind::numbers::QuadraticReal< 2 > >, std::plus< dedekind::analysis::Dual< dedekind::numbers::QuadraticReal< 2 > > > >
struct	is_homomorphism< std::decay_t< decltype(dedekind::analysis::embed_ℝ_𝔻)>, dedekind::numbers::QuadraticReal< 2 >, std::multiplies< dedekind::numbers::QuadraticReal< 2 > >, std::multiplies< dedekind::analysis::Dual< dedekind::numbers::QuadraticReal< 2 > > > >
struct	is_linear_action
	The semimodule laws of an action Act : S x M -> M, declared: 1 m = m, 0 m = 0, (s + t) m = s m + t m, (s t) m = s (t m) and s (m + n) = s m + s n. A certificate, false where none is declared: a carrier with the right signatures is not thereby a semimodule. For scalars of type size_t, the integers modulo 2^64, the laws make n m the n-fold sum of m for every n. More...
struct	is_linear_action< S, S, Add, Add, Mult, Mult >
	A commutative semiring over itself, by its own multiplication: the semimodule laws are the semiring's (Golan, Semirings and their Applications, 1999, ch. 14), among them the unsigned integers, the ring of integers modulo a power of two. More...
struct	is_linear_action< S, S, Add, Add, std::multiplies< S >, std::multiplies<> >
	The same, acted on by the transparent std::multiplies<>. More...
struct	counting_action
	The counts' action on a monoid (T, Op), \((n, x) \mapsto x^n\), the n copies of x, where its laws give it in one step: derived, never declared, and absent where no law gives it, so that the binary method of :total squares instead. More...
struct	counting_action< T, Op >
	By the semimodule laws over the counts, \(1 \cdot x = x\) and \((s + t) \cdot x = s \cdot x + t \cdot x\), \(x^n\) is \(n \cdot x\), one action. More...
struct	ZeroAction
	The 'Absorption' logic. More...
struct	acting_monoid
	A fold along the walk, fold(r, v, h), and its specialisation by the action law (the Jlt paper's Listing 4). acting_monoid<H> names the monoid an action h acts by on the right, a declared certificate of \(h(h(v, a), b) = h(v, a \cdot b)\) and \(h(v, 1) = v\), the product in the walk's order; keyed by the action's type without cv-qualification, as a fold deduces it. A fold walks a right action; a left action, scalar first as IsLeftAction, is a right action of the opposite monoid and registers Opposite<Op> (:involution), the bridge between the two textbook conventions. On n copies of one value the fold is v acted on by their product, and concat computes the product in one step or by squaring: two declared laws, two overloads, composed by resolution. More...
struct	acting_monoid< std::plus< std::size_t > >
	A monoid acts on itself: (std::size_t, +) by +. More...
struct	adjunction_witness
	Typed unit/counit data for an adjunction witness. More...
struct	is_adjoint
	The adjunction law \(f(x) \le y \iff x \le g(y)\) as an opt-in leaf fact, with the one theorem derived here: a monotone isomorphism is adjoint to its inverse ( \(f(x) \le y \iff x \le f^{-1}(y)\), both legs monotone). Other adjunctions register their fact where their theorem is stated (Δ ⊣ ∧ per glb in :cartesian_bicategory, S ⊣ P on the saturating ℤ in numbers:integer, the antitone involution's self-adjunction in algebra:ordered_algebra). More...
struct	Columns
	The column of a byte in a plan: its rank in the alphabet, as a table of the 256 bytes the compiler computes once, so that a scan does one load per letter where Ranked would count the letters below it. An entry is the rank plus one, zero for a byte outside the alphabet. A Kleisli arrow into Maybe, as Ranked is, and the same arrow by value. More...
struct	Automaton
	A matcher's plan: the transitions on each letter, and the states where a word of the set has just been read. More...
struct	Prefix
	prefix("GA"): the words beginning with these letters, the predicate a section is met with. At most eight, the longest word a plan's menu holds. More...
struct	Prefixed
	A section met with a prefix. Its own type, so that only what knows the prefix reads it: count_factors reads cycle types alone, and would count the section as if no letter were fixed, so no count is offered until it has a law. More...
struct	Matches
	matches(plan), the stage that runs a matcher along a text: a query over the text's positions, present where a word of the plan's set ends. More...
struct	Section
	A binary operation curried, with named arrows throughout (the Jlt paper, Listing 3): curry<T>(op) is \(T \to T^T\), its value at a the operator section \(b \mapsto op(a, b)\), Haskell's (a +), and uncurry takes it back to \(T \times T \to U\). A chain's end and step are such sections: curry<N>(greater_equal<N>{})(unit) stops at the unit, curry<N>(plus<N>{})(1) is the successor. More...
struct	Curried
	\(T \to T^T\): the operation, one argument at a time. More...
struct	Uncurried
	\(T \times T \to U\): the curried operation, taken back. More...
struct	Injections
	The injections of the coproduct std::variant<A, B> as a named operation (IsCoproduct's Op, #881): inl / inr place a value by index, so equal summands stay apart (variant<int, int>). Static members, as the concept asks for Op::inl(a) / Op::inr(b). More...
struct	Injection
	The injection ι_K : A → A + B as an arrow: monic (it is injective, and its image is disjoint from the other summand's), the ground of a sum's strength reduction (a set inside one injection's image pulls back along it without loss). More...
struct	Sections
struct	is_associative< Sections< T, Op >, compose >
	Sections under composition are a monoid: composition is associative, total where the operation is, and the identity is its unit. More...
struct	is_periodic< Sections< T, Op >, compose >
struct	is_total_by_construction< Sections< T, Op >, compose >
struct	unit_trait< Sections< T, Op >, compose >
struct	Morphisms
struct	Arrows
struct	SetId
	The Identity morphism for the category Set. More...
struct	Set
	The Category of C++ Types (Set). Formally reified as a Cartesian Closed Category. More...
struct	arrow_as_relation
	Adapter: realise an IsArrow F : A → B as a binary relation (a, b) ↦ f(a) == b. More...
struct	Pairing
	⟨f, g⟩ : A → B × C, one argument into a product. More...
struct	Copairing
	[f, g] : A + B → C, case analysis out of a sum. More...
struct	is_involutive< Flip< A, A >, std::pair< A, A > >
struct	Copy
	Copy (comonoid comultiplication) Δ:A→A×A, a↦(a,a). The left adjoint of the meet; the fan-out of a cartesian bicategory. More...
struct	Delete
	Delete (counit) ε:A→1. Completes the commutative comonoid. More...
struct	Merge
	Merge (the dagger of copy) Δ†:A×A→A, (a,b)↦a⊓b. The right adjoint of the diagonal; the value that IsMeetAsRightAdjoint certifies as the glb. More...
struct	Tensor
	The parallel product ⊗ as the arrow-half of the product bifunctor: R⊗S : A×B→C×D is IsProduct acting on the morphism pair (R,S). The object-half is IsProduct itself (the carrier A×B is the product object); the arrow-half is this Tensor. The action is the mediating morphism ⟨R∘π₁, S∘π₂⟩ built from the product's own reified projections Π<1, P> / Π<2, P> (:limit) and its pairing (the std::pair mediator mediate_product wraps as an arrow); nothing here reimplements the universal property. More...
struct	MergeBadOp
struct	is_integer_chain
	Whether a carrier is an integer chain: the integral types, and the carriers that register themselves (sets' cardinals, a bignum). More...
class	unfold_view
struct	StepCoalgebra
	The coalgebra of a partial step \(X \to 1 + X\): the element, and the step as the next state, while the step has a value. Turns Prior, lower_cover or cover into a lens. More...
struct	Until
	The chain in arrows (the Jlt paper, Listing 3). Three arrows make it: an end, a predicate on the states; a step, an endo; a seed, a point. until(end, step) is the guard, after the Haskell Prelude's until, the partial step \(N \to 1 + N\) a cartesian category builds as \(\langle end, 1\rangle ; dist ; (! + step)\). chain(out) is the anamorphism as an arrow \(N \to N^*\), so a seed composed into it, x >> chain(out), is its chain. ns >> f is the functor's action, f mapped over the elements, the coalgebra's emitted leg post-composed, \((1 + f \times 1) \circ out\), and map id is the chain itself, decided at the type. A fold over the composite is a hylomorphism: nothing between the seed and the fold is built. More...
struct	Unfold
	The anamorphism of a coalgebra as an arrow from the seeds: x >> unfold<S>(c) is unfold(x, c). More...
struct	Mapped
	The functor's action on a coalgebra: f on the emitted leg. More...
struct	Below
	The coalgebra of the bounded chain [lo, hi]: over the state \(1 + C\), since past hi is no element, and the cover of a saturating top is nothing. More...
class	chain_view
struct	Slice
	The chain of C restricted by value to [lo, hi): the elements from lo up to hi, hi excluded, as pandas' .loc reads a slice. For any carrier with the covering step, std::byte among them. More...
struct	Lifted
	A fold step lifted through Maybe: Maybe's eliminator with the cases \([\mathit{acc}, \mathit{op}(\mathit{acc}, \cdot)]\), a hole leaving the accumulator as it is. Written once, so the folds that end a query take their plain steps and none cases on a hole. More...
struct	Where
	where(p), SQL's WHERE: the Kleisli arrow into Maybe that keeps an element where p holds, a hole where it does not. The walk keeps its length, so a filtered chain is a chain in the same order. More...
struct	Windows
	windows(n), the stage that reads each position's window of n elements, a position with its context, as a comonad's \(\delta\) would on an infinite stream; on a finite range the last n - 1 positions have no full window, so it is not a comonad here. It is std::views::slide(n), spelled as a stage. More...
struct	LastOf
	The history comonad's counit: a prefix's last letter. More...
struct	WindowJoin
	p >> s, SQL's JOIN on a window: the tensor of the windows of the words of p that land in s, at every offset where a window fits. A constructor, not a materialisation: the join is a tensor, counted, never enumerated, so it stays inside the counted world and never meets the bag a join yielding rows would need. More...
struct	Offsets
	The offsets a window takes, as a tensor: the chain of m, its count m, one factor \(m^1\). Its outer product with a tensor is the copower \(m \cdot X\), m copies, the action of \(\mathbb{N}\) on the counts (:action; Listing 4's concat on copies). Fubini's sum over the offsets, every summand the same (period 1, translation invariance), is this factor of the product. More...
struct	JoinWith
	join_with(p), a set of words to its join with p on the window: the join curried in the set, an arrow between tensors, its exponential transpose (curry, :cartesian); each join the pullback along the window (IsPullback, :pullback). More...
struct	Counting
	counting, a counted tensor to its count: the reading that ends a pipeline of arrows, as count ends a query. The cardinality, strong monoidal from \(\otimes\) to \(\times\) (the box law read on counts), modulo the word: a ranking by it is a ranking of the exact counts only while they fit, which the law's plan, evaluating no count, does not need and the fused pass does (#1134). More...
struct	antitone_on_even_lengths
	A rank whose values do not grow along the even lengths, so that ranking the even lengths descending reads them upwards. Derived, not registered per rank: a family's occurrences in the words of length N are \((N - n + 1)\) offsets times its density times \(|\Sigma|^N\), a product of non-negative sequences that do not grow, which does not grow either. The product law, stated here for the join's exact count; a general one belongs in :posetal, on an exact carrier or on an extent, since a word's × wraps and an antitone product past it is not antitone (#1134). More...
struct	antitone_on_even_lengths< Compose< Compose< Fam, JoinWith< P, S > >, Counting< J > > >
struct	OrderBy
	order_by(rank), SQL's ORDER BY: the stage that sorts a query by rank under Order, a strict weak order on the ranks. Ties are SQL's: which of the tied elements a take keeps, and in which order, is the plan's (a law's rewrite reads them in the walk's order or its reversal, the fused pass in the walk's); a rank without ties orders alike under every plan. More...
struct	Take
	take<K>(), SQL's LIMIT: the first K present elements. More...
struct	ConstantMorphism
	The Constant Morphism f: A -> B. More...
struct	Equals
	The equality test against one value as an arrow \(A \to 2\), the characteristic map of the point x: the condition a guard asks of a state (the Jlt paper's Listing 3, until(equals(1), step)). More...
struct	DiscreteCategory
	DiscreteCategory realization using the Identity Morphism. Lifts a species T into a category where every arrow is the Identity<T>. More...
struct	is_symmetric
	Engineer-supplied trait: relation Rel on T is symmetric (∀x, y: Rel(x, y) ⇔ Rel(y, x)). More...
struct	is_symmetric< T, Rel >
struct	is_equality
	Trait: Rel on T is equality, the diagonal Δ: Rel(a, b) holds iff a and b are the same value. More...
struct	is_equality< T, Rel >
struct	is_equality< T, std::equal_to< T > >
struct	is_equality< T, std::equal_to<> >
struct	is_equality< std::pair< A, B >, std::equal_to< std::pair< A, B > > >
struct	is_equality< std::pair< A, B >, std::equal_to<> >
struct	is_reflexive< T, Rel >
struct	is_transitive< T, Rel >
struct	is_antisymmetric< T, Rel >
struct	is_equality< int, detail_equality::SameInt >
struct	is_equality< detail_mereology::Dial< 3 >, std::equal_to< detail_mereology::Dial< 3 > > >
struct	BetaReduction
	The β-reduction algebra: a leaf is its own normal form; a node is reduce_β over its reduced legs. reduce_β is a dependent call resolved by ADL against the node type, so a law lives next to its node: the composition unit law above is the canonical exhibit, and further node laws add their own overloads beside their vocabulary. No node carries an is-this-kind tag; dispatch is on the node type. More...
struct	LawAlgebra
	The law algebra: a leaf is its declared profile, a node the law engine on its legs' profiles (:posetal, arrow_node); any other node certifies nothing (sound). The second algebra for the same cata: BetaReduction lands in a normal form (a free algebra, so it decides equality), LawAlgebra in a finite domain of profiles (an abstract interpretation, so it certifies, sound, not complete). More...
struct	is_directed
	Trait to mark a relation as directed: every pair of elements has an upper bound. More...
struct	is_directed< T, Rel >
	Discovery: types may opt in via a nested is_directed_v template member, mirroring the is_reflexive_v / is_transitive_v / is_antisymmetric_v discovery pattern. More...
struct	is_directed< T, std::less_equal< T > >
	A reflexive, connex <= is directed: of a and b one is above the other, and it bounds both (reflexivity bounds itself). Derived from the certificates (:mereology), not from the syntactic std::totally_ordered<T>, which double satisfies (#1043). More...
struct	is_codirected
	Trait to mark a relation as codirected: every pair of elements has a lower bound. More...
struct	is_codirected< T, Rel >
	Discovery: types may opt in via a nested is_codirected_v template member, mirroring the sibling trait patterns. More...
struct	is_codirected< T, std::less_equal< T > >
	A reflexive, connex <= is codirected: the lesser of a and b bounds both from below (#1043, as is_directed). More...
struct	is_functorial
	Trait: F preserves identities and composition, \(F(\mathrm{id}) = \mathrm{id}\) and \(F(f \gg g) = F(f) \gg F(g)\): the functor laws, a certificate as is_involutive and commutes are, primary std::false_type. A type cannot show them, since \(F(f \gg g)\) and \(F(f) \gg F(g)\) are different types that denote one arrow; a functor that lifts each arrow letterwise, elementwise or not at all declares it, and a composite of functors derives it. More...
struct	MaybeMap
	f on the value an optional holds, none where it holds none: the optional functor's action on an arrow. Its codomain is stated, so an arrow into optionals lifts to one into optionals of optionals, as a Kleisli extension needs, and is never collapsed by deduction. More...
struct	TupleMap
	f on the one element of a one-tuple: the one-tuple functor's action on an arrow. More...
struct	maybe_functor
	The Intensional Functor for Optional (Maybe) values. More...
struct	tuple_functor
	The Intensional Functor for 1-tuple values. More...
struct	is_functorial< maybe_functor< T > >
	The container functors map their one slot or none elementwise: the functor laws hold by construction. More...
struct	is_functorial< tuple_functor< T > >
struct	composite_functor
	Composite Functor G . F (Maps CatS -> CatT -> CatU). More...
struct	is_functorial< composite_functor< F, G > >
	A composite of functors is a functor: its laws derived from its legs'. More...
struct	has_one_value< composite_functor< F, G > >
	A composite of two functors with one value each has one value: its legs leave nothing to choose, although its two members keep it from being an empty type. More...
struct	f_algebra
	A concrete witness for an F-algebra. More...
struct	f_coalgebra
	A concrete witness for an F-coalgebra. More...
struct	identity_functor
struct	is_functorial< identity_functor< Cat > >
	The identity functor returns each arrow itself: the functor laws hold by construction. More...
struct	Element
	A monoid as a category with one object, its delooping, and an action of it as a functor out of that category (Mac Lane, CWM §I.2): the action's laws are the functor's. More...
struct	Delooping
	The delooping \(\mathbf{B}(T, \cdot)\): one object, an arrow per element, composition the operation, the identity its unit. Of the opposite operation, Opposite<Op>, it is the opposite category. More...
struct	Acting
	An element acting: the arrow \(v \mapsto h(v, s)\) on the set the monoid acts on. More...
struct	ActingOn
	The arrows by which a monoid acts on V, as a category: the image of the delooping under the action. More...
struct	ActionFunctor
	A right action as a functor out of the delooping of the monoid it acts by: the one object to V, an element s to \(v \mapsto h(v, s)\). Its functor laws are the action's, \(h(v, 1) = v\) and \(h(h(v, a), b) = h(v, a \cdot b)\), which acting_monoid declares, so they are derived and not declared again. A left action registers the opposite operation, so it is a functor out of the opposite category. More...
struct	is_functorial< ActionFunctor< H, V, S > >
	An action's functor laws come with the action: derived from acting_monoid, which IsRightAction reads. More...
struct	LeftActing
	A scalar acting on the left: the arrow \(m \mapsto s \cdot m\) of a semimodule. More...
struct	LeftActingOn
	The arrows by which the scalars act on a semimodule, as a category: certified by the semimodule's laws, so its identity is the scalars' unit. More...
struct	LeftActionFunctor
	A semimodule's left action as a functor out of the opposite of the delooping of its scalars' product: \((s t) m = s (t m)\), so s then t along the walk acts as \(t s\), the opposite product, and \(1 m = m\) keeps the identity. Those laws are the semimodule's, which is_linear_action declares, so the functor laws are derived. A left action of a monoid is a right action of its opposite: the right actions are ActionFunctor. More...
struct	is_functorial< LeftActionFunctor< M, S, AddM, AddS, MultS, Act > >
	A semimodule's functor laws come with it: derived from IsSemimodule. More...
struct	DaggerFunctor
	A dagger as a functor: from the delooping of (T, Op) to that of its opposite, each element to its dagger. The functor laws are the dagger's, \((a b)^\dagger = b^\dagger a^\dagger\), the composition law into the opposite category, and \(1^\dagger = 1\), which an involutive anti-homomorphism keeps; so they are derived from IsDagger and not declared again. Contravariant on the one object, and its own inverse. More...
struct	is_functorial< DaggerFunctor< Dagger, T, Op > >
	A dagger's functor laws come with the dagger: derived from IsDagger, its involution and its reversal of products. More...
struct	ImageChi
	The characteristic predicate of image_of(F) — recognises y as "in the image of @c F". More...
struct	ImageChi< F >
	Image classifier for a retractable arrow: y is in the image iff the retract fires at y. More...
struct	kernel_quotient
	Opt-in trait: textbook claim "for this @c F, @c A/ker(F) is the carrier @c ::Class". More...
struct	image_carrier
	Opt-in trait: textbook claim "for this @c F, @c im(F) is the carrier @c ::type". More...
struct	is_involutive
	Trait: a callable F is involutive on T iff F(F(x)) = x for all x ∈ T. Primary is std::false_type; opt-in via specialisation or member discovery (mirrors :species's is_reflexive / is_transitive export pattern). It is the CERTIFICATE the shape cannot supply: F² = Id is a claim about F, not a syntactic property of its call. More...
struct	is_involutive< F, T >
	Discovery: a type may opt in via a nested is_involutive_v template member. More...
struct	is_involutive< std::logical_not< bool >, bool >
	Canonical: std::logical_not<bool> is the involution on bool. More...
struct	is_involutive< std::bit_not< T >, T >
	Canonical: std::bit_not<T> is the involution on non-bool integral T (~~x = x). bool is EXCLUDED: ~x promotes to int (−1/−2) then converts back to true, so bit_not is not an involution on bool — its involution is std::logical_not. More...
struct	is_involutive< std::negate< T >, T >
	Canonical: unary minus is an involution on the unsigned integral carriers, where -x is 2^n - x and -(-x) = x for every x. The signed carriers are EXCLUDED: -INT_MIN is undefined behaviour, so std::negate<int> is an involution on all values but one, and that one makes it not a function. (The Jlt paper's Listing 1 states both.). More...
struct	Reverse
	An involution on a carrier that is not a number: reversing a word twice is the identity, on any word a value holds, a std::string or a std::vector of letters; not a view, whose copy would alias the caller's letters. A pure function object, value in and value out, so that it is an arrow in the sense of the Jlt paper's Rule 1, and a family of them, one per word type, as std::logical_not is one per truth type; endo<W>(rev) names the domain. More...
struct	is_involutive< Reverse, W >
struct	is_involutive< Reverse, std::strong_ordering >
struct	is_involutive< Identity< T >, T >
	The identity arrow is (trivially) an involution: id(id(x)) = x, so id⁻¹ = id. Identity is the degenerate case where idempotent (f²=f), involution (f²=id) and isomorphism coincide — the unique arrow with f²=f=id. Witnessed here so the compiler / cata can SEE it: the composition unit law (id∘f=f) subsumes it in practice, but a downstream inverse-cancellation rule (f∘f⁻¹→id, of which neg∘neg→id is the non-trivial case) needs id certified as the trivial member. More...
struct	is_involutive< Compose< F, G >, T >
	A composite of two commuting involutions is one, certified at the type where both legs are: \((g f)^2 = g g f f = \mathrm{id}\). The same law is_involution reads on a value (:posetal), where a leg's law may be decided on its value instead. More...
struct	is_involutive< Morphism< A, A, Impl >, A >
	The arrow wrapping a callable has the law iff the callable does: endo<A>(f) is an involution when f is. More...
struct	is_self_inverse< F >
	An involution is its own inverse: \(f \circ f = \mathrm{id}\) makes f an IsIsomorphism, through the :morphism hook (found by ordinary lookup, wherever f lives), with no inverse of its own. The hooks for a specific arrow (Identity, the negate Morphism) are more specialised and keep precedence. More...
struct	is_associative< T, detail_involution::Reversed< Op > >
struct	is_commutative< T, detail_involution::Reversed< Op > >
struct	is_idempotent< T, detail_involution::Reversed< Op > >
struct	unit_trait< T, detail_involution::Reversed< Op > >
struct	is_homomorphism< F, T, Op, detail_involution::Reversed< Op2 > >
	Over a commutative operation on the codomain, a homomorphism into it is one into its opposite: \(b \cdot a = a \cdot b\) there. More...
struct	is_homomorphism< Morphism< A, B, Impl >, A, Op, detail_involution::Reversed< Op2 > >
	The arrow wrapping a callable reverses an operation where the callable does, declared or derived: the meeting of the two rules above, more specialised than either, so that they never both apply. More...
struct	IsoRetract
	The retract of an IsIsomorphism: its total inverse arrow wrapped in an always-engaged std::optional. More...
struct	unit_witness
	unit_witness<Functor, T>: Generic Kleisli unit witness. Lifts a value into the Kleisli extension named by Functor::template Shape<T>. More...
struct	unit_witness< maybe_functor< T >, T >
struct	counit_witness
	counit_witness<Functor, T>: Generic Kleisli counit witness. Samples a value from the co-Kleisli extension named by Functor::template Shape<T>. Defined for genuine comonadic carriers only; maybe_functor is not specialised here because Maybe is a monad, not a comonad (counit on nullopt has no honest answer). More...
struct	unit_witness< tuple_functor< T >, T >
struct	counit_witness< tuple_functor< T >, T >
struct	is_kleisli_triple
	Trait: Functor's unit and bind satisfy the Kleisli-triple laws (Manes): \(\eta(x)^* f = f(x)\), \(m^* \eta = m\) and \((m^* f)^* g = m^* (x \mapsto f(x)^* g)\). A certificate, primary false, declared where a container's bind keeps them by construction. More...
struct	is_cokleisli_triple
	Trait: the co-Kleisli-triple laws, the duals, for Functor's counit and extend. More...
struct	is_kleisli_triple< maybe_functor< T > >
struct	is_kleisli_triple< tuple_functor< T > >
struct	is_cokleisli_triple< tuple_functor< T > >
struct	is_frobenius_monad
	Trait: Functor's multiplication and comultiplication satisfy the Frobenius law (Street, "Frobenius monads and pseudomonoids", 2004): \(T\mu \circ \delta T = \delta \circ \mu = \mu T \circ T\delta\). A certificate, primary false. Being a monad and a comonad is not enough: on streams (the diagonal monad, the suffix comonad) \(\delta \circ \mu\) reads \(s_{i+j}(i+j)\) where \(T\mu \circ \delta T\) reads \(s_{i+j}(j)\). More...
struct	is_frobenius_monad< tuple_functor< T > >
struct	kleisli_probe_arrow
	An arrow A → B the triple concepts probe bind and extend with: only its type is read, never its value. In this namespace, not a detail one, so argument-dependent lookup finds the >>= and <<= defined below. More...
struct	functor_of
	The functor whose values a container is: Maybe a value of maybe_functor , the one-tuple of tuple_functor . Kleisli extension reads its action on arrows, \(\mu \circ T(f)\). More...
struct	functor_of< Maybe< A > >
struct	functor_of< std::tuple< A > >
struct	LatticeBottom
	Structural witness types for the bottom (initial) and top (terminal) of the lattice over (T, Rel), playing the role of initial / terminal objects of the lattice viewed as a thin category. More...
struct	LatticeTop
	The abstract top of the lattice over (T, Rel), dually. More...
struct	LatticeBottom< T, std::less_equal< T > >
	Canonical specialisation: integral carriers under std::less_equal have bottom = numeric_limits<T>::min(). More...
struct	LatticeTop< T, std::less_equal< T > >
	Canonical specialisation: integral carriers under std::less_equal have top = numeric_limits<T>::max(). More...
struct	Meet
struct	Join
struct	predicate_logic
	The logic species a predicate answers in: its own, when it names one (IsSpeciesTaggedArrow), else the species of its answer type, and a composite the species of its last arrow. No type where none applies (a substitution failure, not an error). The lattice nodes over arrows and the combinators and Subobject (:topoi) read this, so a Chain<int> set (answer int, species Chain<int>) conjoins in Chain<int>, and a set pulled back along an arrow (a cylinder, χ ∘ π) answers in the set's species. More...
struct	predicate_logic< P >
struct	predicate_logic< Compose< F, G > >
struct	Meet< A, B >
struct	Join< A, B >
struct	Not
struct	Not< A >
	¬A over an arrow A → Ω is the arrow RFL ∘ A: the codomain's own reflection (generic over any bounded chain Ω: Boole !, Kleene ¬U=U, …). The node stays the literal Not , so is_not_node_v / de_morgan_of / is_complement_pair_v apply unchanged; its set-object reading is structural, downstream in sets. More...
struct	over_nodes
	A property of a term's leaves, lifted over the lattice's nodes: a Meet or Join has it where both operands do and share a domain, a Not where its operand does. One rule for every carrier that lifts a leaf property over the nodes: the opt-in to | and & below, and the set objects of sets (is_set_object). More...
struct	over_nodes< Leaf, Meet< A, B > >
struct	over_nodes< Leaf, Join< A, B > >
struct	over_nodes< Leaf, Not< A > >
struct	builds_lattice_nodes
	A carrier's opt-in: its predicates' | and & are the lattice's nodes. False by default; a node over two that build does, where they share a domain, by over_nodes, the rule sets' is_set_object follows too. A carrier that opts in keeps the lazy | and &; the set grammar of sets takes the rest, so a type that is both, a Subobject, is the lattice's. This is the lazy form: the node is the result, for intensional and symbolic predicates. A carrier with a normal form reduces at once instead (run lists in :runs, the set grammar in sets); where the lazy and the strict forms meet is not yet uniform (#1138). More...
struct	builds_lattice_nodes< Meet< A, B > >
struct	builds_lattice_nodes< Join< A, B > >
struct	builds_lattice_nodes< Not< A > >
struct	MakeMeet
	The pairing factory for the meet (∧, pullback): ⟨-,-⟩ : A×B→Meet. More...
struct	MakeJoin
	The pairing factory for the join (∨, pushout): ⟨-,-⟩ : A×B→Join. More...
struct	law_inactive
	Sentinel: a law that does not fire on the given node. More...
struct	canonical_order
	The default Ord: the carrier's own canonical std::less_equal order (the order bundled with its axioms). A caller whose ∧/∨ mean a different lattice on the same carrier injects that relation as Ord. More...
struct	is_lattice_bottom_for
	Is X the registered bottom of the lattice whose order is Ord? More...
struct	is_lattice_bottom_for< LatticeBottom< T, Rel >, Ord >
struct	is_lattice_top_for
	Is X the registered top of the lattice whose order is Ord? More...
struct	is_lattice_top_for< LatticeTop< T, Rel >, Ord >
struct	carrier_of
	The carrier type of a reduced term: a value-bearing leaf's ::value type, propagated through Meet / Join composites (a subterm that did not collapse, e.g. Join of two ≤-incomparable elements of a bit-subset lattice), or void when the carrier is unknown (an order-opaque leaf) or inhomogeneous. A composite propagates a carrier only when both children agree on a known one, so a nested mixed-carrier term (at any depth) is void and fails the SameCarrier guard below (fail-closed recursively). More...
struct	carrier_of< X >
	Carrier of a predicate / subobject leaf. Such a leaf is an arrow χ:Domain→Ω (IsArrow), not a wrapped value, so its carrier is the arrow's Domain. Reading it through IsArrow (the category arrow surface) rather than a bespoke typedef probe ties the reducer into category. The carrier-based gates (SameCarrier, distributivity, complement, De Morgan negation) then apply to set expressions too. An element leaf instead carries ::value, a point 1→T whose carrier is the value's type; the ::value specialisation above handles it. The two spellings extract the carrier from opposite ends of the arrow, so both coexist. More...
struct	carrier_of< Meet< A, B > >
struct	carrier_of< Join< A, B > >
struct	carrier_of< Not< A > >
struct	codomain_of
	The CODOMAIN Ω of a leaf / term, dual to carrier_of (the domain). A predicate / subobject leaf is an arrow χ:Domain→Ω, so its codomain is Ω (the subobject classifier), read via ::Codomain. A bare value leaf is a truth value, so its codomain is its own type (domain = codomain there, which is why the two-element bool lattice behaves identically under either accessor). Composites propagate the common Ω (fail-closed, exactly like carrier_of). More...
struct	codomain_of< X >
struct	codomain_of< Meet< A, B > >
struct	codomain_of< Join< A, B > >
struct	codomain_of< Not< A > >
struct	HeytingExponential
	Structural witness type for an exponential object in the lattice over (T, Rel) viewed as a thin cartesian closed category — the relative complement a → b held as a carrier value, exposed as a callable that computes the eval morphism eval(e, x) = e ∧ x. More...
struct	HeytingExponential< T, std::less_equal< T >, Inf >
	Canonical specialisation: integral carriers under std::less_equal with Inf as the meet. Holds an exponential value value ∈ T; operator()(x) returns Inf(value, x), the lattice meet, which is the eval morphism in a thin Heyting algebra. More...
struct	is_complement
	Opt-in trait: Not is the complement morphism for the Boolean lattice over (T, Rel, Join, Meet). The trait is the semantic gate for IsBooleanLatticeCategory — the structural side (Heyting + involutiveness of Not) is already enforced by the upstream concepts, but the complement laws. More...
struct	is_complement< std::logical_not< bool >, bool, std::less_equal< bool >, Sup, Inf >
	Canonical specialisation: std::logical_not<bool> is the complement for the 2-element Boolean lattice over (bool, std::less_equal<bool>, Sup, Inf). Value-level laws hold trivially: true ∧ !true = Inf(true, false) = false = ⊥, and true ∨ !true = Sup(true, false) = true = ⊤. More...
struct	lattice_less_logic
	The logic species a comparator reports in: Boole (a bool decision) unless the comparator names its own logic typedef (e.g. Kleene, so an undecidable comparison can be Unknown). More...
struct	lattice_less_logic< Less >
struct	no_leaf_combine
	The default leaf-combiner performs no domain combination. Two order-incomparable leaves stay a Meet / Join node. A downstream carrier (e.g. sets) injects a Combine that computes the actual domain meet / join of two compatible leaves. structured_and of two halfspaces yields an Interval, say. Combine returns law_inactive when no domain combination applies. This injected policy lets the reducer's incomparable-leaf residual fall through to the carrier's own ∧/∨. More...
struct	no_canonical_order
	No order for the reducer to canonicalise by: a carrier without one keeps the residue in its authored order, then combines it. More...
struct	Reduce
struct	Projection
	The projection π_k: the k-th component of a product. More...
struct	Projection< 0 >
	The projection out of the one-fold product A¹ ≅ A: the identity arrow (Identity), read at the point's own type. More...
struct	AnyOperation
	Base-case sentinel for the operation parameter of IsProduct / IsCoproduct. More...
struct	SpeciesTraits< std::pair< A, B > >
struct	SpeciesTraits< std::tuple< Ts... > >
struct	logic_complement
	Bridge the species' static-method ops (L::AND / L::OR / L::RFL) to the function-object types the :species / :total law registry is keyed on. More...
struct	Boole
	The internal logic of the Classical Topos ({True, False}). More...
struct	Kleene
	The internal logic of the Kleene Topos. More...
struct	Chain
	Chain<T>: the finite Kleene chain over an integral carrier T, the full-T-range many-valued logic. Boole (2 grades) and Kleene (3) are the small distinguished members; Chain<int> spans the implementation's full int range. More...
struct	Percentage
	Percentage: a range-enforcing [0,100] carrier ("50:50"). More...
struct	Percent
	The bounded confidence chain: a 101-grade De Morgan (Kleene) chain, self-dual about 50. More...
struct	GetLogic
	The logic a thing lives in, with Boole as the permissive default: a type that names no logic_species and is not a known answer type is read as classical. IsTotalArrow asks this of a plain carrier (an int domain is classical). Do not use it to read the species off a classifier answer: that is classifier_logic_t, which has no default and rejects an answer type that names no species. More...
struct	GetLogic< Ternary >
struct	GetLogic< T >
struct	ClassifierLogic
	The logic species a classifier answer type belongs to. More...
struct	ClassifierLogic< bool >
struct	ClassifierLogic< Ternary >
struct	ClassifierLogic< T >
struct	unit_trait< C, Sup >
	A classifier answer's ends are its species' ⊥ and ⊤: the identities of Sup (∨) and Inf (∧), derived once for every answer (𝔹, K₃, Percentage, …), the one spelling of a truth chain's bottom and top. More...
struct	unit_trait< C, Inf >
struct	species_embed
	The embedding From ↪ To of one species' answers into another's, preserving ⊥, ⊤, ∧, ∨ and ¬ (a De Morgan embedding), so that the set complement ~ commutes with every lift. More...
struct	species_embed< L, L >
struct	species_embed< Boole, To >
struct	species_embed< Kleene, Percent >
struct	join_logic
	The join of two species: the least shipped species both embed into. Partial: comparable species join to the larger one; an incomparable pair (K₃ / Chain<int>, across the parity gap) has no shipped upper bound and no type, so a cross-species combine of such sets is refused at compile time rather than mis-typed. HaveLogicJoin asks whether the join exists. More...
struct	join_logic< L1, L2 >
struct	meet_logic
	The meet of two species: the greatest species embedding into both. Total: 𝔹 (the dominance Σ) embeds into every species, so the order is a meet-semilattice with 𝔹 at the bottom. Comparable species meet at the smaller one; an incomparable shipped pair meets at 𝔹 (their only common lower bound). The meet is relative to the registered edges: two even chains (Chain<int>, Chain<long>) meet at 𝔹 here although an embedding between them exists mathematically; register the edge to refine it. A new species that shares a non-𝔹 lower bound with a species it does not compare to must specialise this. More...
struct	meet_logic< L1, L2 >
struct	Semidecided
	The verdict of a bounded search, read in K₃ along the dominance \(\Sigma \hookrightarrow \Omega\): a witness found is ⊤, none found so far is U, and nothing is ever ⊥, since the absence of a witness within a budget refutes nothing. The one arrow by which "undecided" enters a computation. More...
class	Truth
	The Monic Wrapper for a Logical Species (Ω). More...
struct	SpeciesTraits< Truth< L > >
	Bridge the Monic Wrapper to the Logic Species Registry. More...
struct	LogicTraits
	Primary Template: Default to Classical (Boolean) Logic. More...
struct	LogicTraits< T >
	Specialization for Floating-Point Species (IEEE 754 NaN handling). More...
struct	SubobjectClassifier
struct	NegationArrow
	The arrow reading of logic negation ¬ = L::RFL on the truth object Ω — the canonical order-reversing arrow. More...
struct	LiftLogic
	The arrow reading of the Rosolini dominance inclusion \(\iota:\mathbb{B}\hookrightarrow\Omega\) (lift_logic): a decided bool answer embeds as the target species' poles (⊥↦False, ⊤↦True). The canonical order-PRESERVING arrow, and the covariant codomain axis of a classifier \(\chi:A\to\Omega\) (#908). More...
struct	is_involutive< logic_complement< Boole >, bool >
	Witness: Boolean negation is an involution. Boole's RFL is std::logical_not on bool (!!b = b). More...
struct	is_involutive< logic_complement< Kleene >, Ternary >
	Witness: Kleene negation is an involution. Kleene's RFL reflects the K₃ chain about Unknown, so ¬¬a = a on all three values (the static_asserts above prove it). More...
struct	is_involutive< logic_complement< Chain< T > >, T >
	Witness: the Chain<T> reflection ~a is an involution (~~x = x) for every integral carrier. More...
struct	is_involutive< logic_complement< Percent >, Percentage >
	Witness: the Percent reflection 100-p is an involution. More...
struct	is_involutive< NegationArrow< L >, typename L::Ω >
	The arrow form of the reflection carries the same certificate: NegationArrow<L> is an involution on L::Ω exactly when the species' complement is, so the laws engine (:posetal) sees ¬ as its own inverse and, through saturation, as monic and epic. More...
struct	is_reflexive
	Trait to mark a relation as reflexive: a ~ a = True. More...
struct	is_reflexive< T, std::less_equal< T > >
struct	is_transitive
struct	is_transitive< T, std::less_equal< T > >
struct	is_antisymmetric
struct	is_antisymmetric< T, std::less_equal< T > >
struct	is_connex
struct	is_connex< T, Rel >
struct	is_connex< T, std::less_equal< T > >
struct	ChainWalk
	Where a walk from lo ends: the last value reached and how many values it took. reached_hi says whether it stopped at hi (rather than at a saturating top short of it, or at the end of the budget). More...
struct	ChainStep
	One step of the walk: the next value, or the walk itself once it has ended, which makes an ended walk the fixed point iterate stops at. More...
struct	Sup
	Value-returning chain lattice ops — the honest T × T → T meet / join. More...
struct	Inf
	Meet ∧: the greatest lower bound on a chain (min), returned by value. Value-returning sibling of Sup. More...
struct	unit_trait< bool, Sup >
	bool's ends, the identities of Sup and Inf, declared beside them: every partition that can ask (a chain walk on bool, as :equivalence does) then sees the one definition, before :logic's classifier-answer specialisation could give it a second. More...
struct	unit_trait< bool, Inf >
struct	unit_trait< detail_mereology::Dial< N >, Sup >
struct	unit_trait< detail_mereology::Dial< N >, Inf >
struct	is_monadic
	T : C -> C with η : Id ⟹ T and μ : T² ⟹ T. More...
struct	is_comonadic
	Trait: the comonad laws for ε and δ on W, the duals. More...
struct	archetype
	The representative presentation of an object: itself for a value type; the one it names (C::archetype) otherwise. More...
struct	archetype< C >
struct	Morphism
	The formal structure of an Arrow f: A -> B. More...
struct	infer_morphism
	Universal inference for any Morphism signature f: Args... -> Codomain. More...
struct	SpeciesTraits< F, A >
struct	SpeciesTraits< std::logical_and< bool > >
struct	SpeciesTraits< std::logical_or< bool > >
struct	SpeciesTraits< std::equal_to< bool > >
struct	SpeciesTraits< std::plus< T > >
struct	SpeciesTraits< std::minus< T > >
struct	SpeciesTraits< std::multiplies< T > >
struct	SpeciesTraits< std::divides< T > >
struct	SpeciesTraits< std::bit_and< T > >
struct	SpeciesTraits< std::bit_or< T > >
struct	SpeciesTraits< std::less_equal< T > >
struct	SpeciesTraits< std::less< T > >
struct	MorphicBridge
struct	MorphicBridge< T >
struct	MorphicBridge< R(C::*)(A) const >
struct	MorphicBridge< R(C::*)(A)>
struct	MorphicBridge< std::function< R(A)> >
struct	signature_extractor
struct	Rule
	A type-erased Morphism A -> B between Species. More...
struct	Identity
	The Identity Morphism and Functorial Witness. More...
struct	Compose
	The reified composition arrow g∘f: "apply @c F, then @c G" (diagrammatic f≫g order), the arrow-algebra companion to Identity. More...
struct	has_one_value
	Trait: the type T has exactly one value, so that two of its values are equal without comparing them: an empty type, or a composite of two such, whose legs leave nothing to choose. What lets a law read on a type speak of the one value it has (:natural). More...
struct	has_one_value< Compose< F, G > >
struct	commutes
	Trait: the arrows F and G commute, \(f \circ g = g \circ f\): a certificate, primary std::false_type, since that two particular maps commute is a claim about them, not a property of their calls, and composition commutes for no category in general. Read symmetrically by commutes_v. It is a naturality square with one functor (:natural), and what makes a composite of two involutions one (:involution, :posetal). More...
struct	unit_trait< Identity< T >, Op >
struct	IdentityIn
	The identity of a category whose arrows are one type, Cat::Arrow: an identity arrow on Cat::Species, so its law is read at the type, that converts to the category's arrow, Cat::unit_arrow(), where an arrow of that type is wanted. More...
struct	is_self_inverse
	Hook: an arrow that is its own inverse ( \(f \circ f = \mathrm{id}\)). Declared here, with the inverse it licenses, ahead of IsIsomorphism, so that concept finds the inverse by ordinary lookup for an arrow in any namespace, not only through argument-dependent lookup. :involution sets it for every certified involution. More...
struct	is_homomorphism
	The homomorphism law of a map F on the carrier T, declared: \(f(a \odot b) = f(a) \circledast f(b)\), Op on T and Op2 on the codomain, a homomorphism of magmas (Bourbaki, Algebra I, §I.1.1); for a unary operation, \(f(u(a)) = u'(f(a))\). A certificate, false where none is declared: the law is an equation on every pair, so it is declared and witnessed by computation at the declaration, as is_monic_arrow_v. A class template, so that a family of maps declares it once across modules; keyed like is_involutive<F, T>, a bare callable naming its carrier. More...
struct	is_homomorphism< Morphism< A, B, Impl >, A, Op, Op2 >
	The arrow wrapping a callable carries an operation where the callable does, when it keeps the callable's carrier: endo<A>(f) is a homomorphism when f is, with no second declaration. More...
struct	maybe_monad_tag
struct	identity_monad_tag
struct	tuple_monad_tag
struct	identity_transformation
	The Identity Natural Transformation for Functor F. More...
struct	vertical_composition
	Vertical composition of two 2-morphisms (β . α). More...
struct	horizontal_composition
	Horizontal composition (Godement product). More...
struct	Successor
	The successor \(S : N \to N\) as an arrow, over any carrier with the NNO step: the one spelling of the Peano successor where an IsArrow is needed (image, graph, the NNO witness), in place of a struct per site. More...
struct	ZeroElement
	The zero element \(Z : 1 \to N\), the nullary IsNNO witness: the carrier's default value, which is the NNO's zero for the integrals and for Cardinality. Nullary, so not an IsArrow (that concept asks for a Domain); a composable \(1 \to N\) arrow is not needed here. More...
struct	Predecessor
	The predecessor \(P : N \to N\) as an arrow, in the carrier's own posture at ⊥: the monus on ℕ (0 a fixpoint), −1 on ℤ. More...
struct	In
	The NNO's structure map \([Z, S] : 1 + N \to N\) as an arrow: zero, or the successor of the element given. std::optional<N> is \(1 + N\), the NNO's own functor \(F(X) = 1 + X\). More...
struct	Prior
	The destructor \(\langle \text{is}\;Z?,\, P\rangle : N \to 1 + N\): nothing at zero, else the predecessor. More...
struct	NumericWitness
	A typed witness of numeric classification in Ω_K3. More...
struct	IntervalBoundaryPolicy
	Closed interval policy [lower, upper] for integral species. More...
struct	FullMachineBoundaryPolicy
	Full-machine boundary policy (no clipping). More...
struct	NaNHolePolicy
	IEEE-754 NaN-hole classifier policy for floating species. More...
struct	GetLogic< std::optional< T > >
struct	Partial
	The Kleisli Context for "Consistently Broken" Species. More...
struct	TernaryResult
	A Logic-Aware Result container for Ternary outcomes. More...
struct	SafeAddTransform
	Addition with overflow check (Classical Logic). More...
struct	BoundedAddTransform
	Addition that consults a user-supplied numeric boundary policy. More...
struct	BoundedMulTransform
	Multiplication with user-supplied numeric boundary policy. More...
struct	BoundedDivTransform
	Division with user-supplied numeric boundary policy. More...
struct	HonestDivTransform
	Division with truncation-awareness (Ternary Logic). More...
struct	unit_period
	The trait behind HasUnitPeriod: a sequence whose period is 1 by its type, not only by its value, so that the sum along it needs no fold. A struct, as is_adjoint, so that a downstream partition registers a family by one partial specialisation. More...
struct	unit_period< ConstantMorphism< N, B > >
struct	unit_period< Compose< F, G > >
struct	Congruent
	The residue class \(\{k \mid k \equiv r \pmod m\}\) as a predicate on the counts, periodic with period m: the quotient onto Modular<m>'s carrier, then the test for r. More...
struct	FibonacciMod
	The Fibonacci numbers modulo m, \(k \mapsto F(k) \bmod m\), by fast doubling, \(\log k\) steps; the modulus is at most the square root of the word's order, so that the products stay in the word, and a wider one is refused where the arrow is read. More...
struct	Opaque
	An arrow with its laws hidden: called as f, with no period, so that a count along it is the plain fold. What a test runs beside the law to check it. More...
struct	Shift
	A translation of the counts, \(k \mapsto k + j\): after it, a periodic arrow keeps its period, on an extent narrowed by j. More...
struct	builds_lattice_nodes< P >
	Periodic predicates opt in: their | and & are the lattice's nodes (:lattice), periodic with the least common multiple of their periods. More...
struct	Rolling
	A window over a periodic predicate, SQL's window function over ROWS BETWEEN CURRENT ROW AND w - 1 FOLLOWING: \(k \mapsto\) the step folded over \(f(k), \ldots, f(k + w - 1)\). A finite combination of translations, so periodic with the same period. More...
struct	Box
	The outer product of predicates along chains, \(T(i_1, \ldots, i_K) = f_1(i_1) \wedge \cdots \wedge f_K(i_K)\) over the box of all indices, a rank-one tensor never built: its entry is the legs' Tensor followed by the merge, and the box's sides are the chains' lengths. In the pictures of tensor networks (Bridgeman and Chubb, "Hand-waving and Interpretive Dance: An Introductory Course on Tensor Networks", J. Phys. A 50, 2017), each count contracts a leg's index against a covector: all ones for the box, a residue class for a section. More...
struct	AtMost
	Words over an alphabet as a tensor, not as a sequence: the tensor power \(\Sigma^n\) of a filtered alphabet, its symmetric sections, and the free monoid on it truncated below a length, each counted as a product of factors that never overflow where the total does. Periodicity above is invariance under a translation of the counts; a symmetry here is invariance under a permutation of the positions of a word. More...
struct	Factor
	A factor of a count, \(b^e\): a base raised to an exponent. More...
struct	Cycles
	The cycles of a permutation of positions of one length, and how many there are: one term of its cycle type. More...
struct	Letters
	A subobject of the bytes given by its letters, \(\chi : \Sigma \to \Omega\) as a packed word of 256 bits: the predicate a filtered alphabet is built from, letters("ACGT"). More...
struct	Bytes
	A text written in the source: its bytes, held by value, and a view, so a query over it owns them and nothing dangles, a temporary's included. Its copy is constant-time in the sense a view asks, the length being in the type. More...
struct	Ranked
	A byte's rank in an alphabet: how many of its letters lie below it, the order isomorphism of the letters, in the bytes' order, onto \([0, |\Sigma|)\); a byte outside it is a hole. A Kleisli arrow into Maybe, as where is: a text of bytes read through it is the alphabet's letters, holes where it has none. More...
struct	Reflection
struct	is_involutive< Reflection, std::byte >
	The duality is an involution: \(({\sim} + n)\) is one on the ranks (is_involutive above), and a conjugate of an involution by a bijection is one. More...
struct	SplitMix
	A random number as an arrow out of the counts, a sequence on a chain: the hash of a position and a seed (SplitMix64, Steele, Lea and Flood 2014). constexpr, with no state: any position is at hand, a sequence of any length is never stored, and two seeds are two streams. So a law can be asked of random inputs in a static_assert, and a million events cost nothing to spin up. For exercising code: no cryptography, and no claim on sampling. More...
struct	RandomLetter
	A random letter by position: the hash, read as a rank in an alphabet. More...
struct	LetterMap
	An arrow on the bytes given by a table, each letter of from to the letter at the same place of to, every other byte fixed: letter_map("ACGT", "TGCA") is the complement of a base, an involution. More...
struct	Power
	The tensor power \(\Sigma^n\): the words of length n over the letters of a chain that a predicate keeps, a box of n legs, each the filtered alphabet, never built. More...
struct	PowerMap
	An arrow on the letters applied to every letter of a word, of any length: the list functor's action on arrows, \(\tau^{\times n}\) at each length \(n\) at once, beside power on the alphabet, Listing 4's power one level up. It commutes with every permutation of the positions, which is naturality read on words. More...
struct	Rotation
	The rotation of the positions of a word by shift, \(i \mapsto i + d \bmod n\), the symmetry of a power \(u^j\): on a word, the letter at i moves to i + d, as std::rotl moves a bit. A family of arrows, one per word type, as Reverse is. More...
struct	is_involutive< Compose< NegationArrow< Chain< N > >, Shift< N > >, N >
	The chain's reflection, then a translation, is a point reflection, \(x \mapsto c - x\), an involution for every c, the counts being unsigned: \(c - (c - x) \equiv x\) modulo the word. The reversal of n positions on indices is the one with \(c = n - 1\): \(n - 1 - i \equiv {\sim} i + n\), so ~Identity<N>{} >> shift(n). An involution, so an isomorphism, its own inverse (:involution). More...
struct	commutes< PowerMap< T >, Morphism< W, W, Reverse > >
	The naturality of the permutations of positions: rev and rotate(d) are natural transformations of the power functor \((-)^n\) to itself, so each square \(\sigma \circ \tau^{\times n} = \tau^{\times n} \circ \sigma\) commutes, for every tau at once. The certificate is declared here, once per permutation; :natural's IsNaturalTransformation checks its square only at the identities, by type, and does not yet read it. So the reverse complement is one map, written in either order, and an involution where tau is one (is_involution, :posetal). More...
struct	commutes< PowerMap< T >, Morphism< W, W, Rotation< N > > >
struct	is_involutive< PowerMap< T >, std::vector< C > >
	A map on every letter is an involution where the map on one is, certified at the type where tau's is; a LetterMap's law is of its table, so is_involution decides it on the value. More...
struct	LetterMaps
	The letter maps on the bytes as a category: one arrow type, LetterMap, the identity its identity table. More...
struct	LetterMapsOnWords
	The letter maps on every letter of a word as a category: the image of LetterMaps under the list functor. More...
struct	PowerFunctor
	The list functor on the letter maps, a word for a letter, of every length, and power(tau) for an arrow tau: the power functor \((-)^n\) at each length at once. It has no state, so it is one functor, and rev and rotate(d) are natural transformations of it to itself, by the certificates above. More...
struct	is_functorial< PowerFunctor >
	The power functor's laws: \(\mathrm{id}^{\times n} = \mathrm{id}\) and \((\sigma \gg \tau)^{\times n} = \sigma^{\times n} \gg \tau^{\times n}\), letterwise by construction, witnessed on a word. More...
struct	OnWords
	A transformation of the power functor with one component, a map on the words, the same at every letter. More...
struct	Symmetric
	The section of a tensor power fixed by a permutation sigma of the positions and an arrow tau on the letters, \(x_{\sigma(i)} = \tau(x_i)\): the legs merged along each cycle of sigma, the spider's Merge through tau, the words de Bruijn's power group element \((\sigma, \tau)\) fixes. More...
struct	Powers
	words(Σ), the tensor powers by length, \(n \mapsto \Sigma^n\): an arrow out of the counts into the tensors, the free monoid graded by length. Its density is 1 at every length. Each power is the exponential \(\Sigma^{[n]}\), the functions from the chain of n to the letters (IsExponential, :cartesian), and the family is a strong monoidal functor \((\mathbb{N}, +) \to (\text{tensors}, \otimes)\), \(\Sigma^{m+n} \cong \Sigma^m \otimes \Sigma^n\): the box law is its monoidality (no monoidal-functor concept states it yet, #1134). More...
struct	FixedBy
	fixed_by(g), a tensor power to its section fixed by g, a permutation of the positions after a letter map on every letter: an arrow between tensors. By Pólya each cycle of g fills with the letters it fixes, at most \(|\Sigma|^{\ell}\) for a cycle of length \(\ell\), so the section's density is at most 1. The section is the equalizer \(\mathrm{Eq}(\mathrm{id}, g)\) (IsEqualizer, :pullback), equally the limit of the action of \(\langle g \rangle\) on the power, a functor out of its delooping (ActionFunctor, Delooping, :functor): its invariants, Pólya their count. More...
struct	Length
	len(n): the fibre of the length over n, the predicate a graded family of words is met with. oligos & len(n) is the words of length n, \(\Sigma^n\) as the fibre of \(\Sigma^* \to \mathbb{N}\) over n, Trsk's filter on the graded set; it is the family applied at n, so the count law of the fibre is the power's, \(|\Sigma|^n\). The meets commute: oligos & len(n) & fixed_by(g) and oligos & fixed_by(g) & len(n) are one section. More...
struct	ReflectedReverse
	~rev: the reversal, then the reflection of the alphabet on every letter, the reverse complement. ~f is :posetal's: f then the reflection of its codomain's chain, which on the ranks of ACGT is \(x \mapsto 3 - x\), bitwise NOT on two bits. A word carries no alphabet, so ~rev is a family indexed by the alphabet, with a component at each, power(refl(Σ)) >> rev at Σ, taken where fixed_by(~rev) meets a power over Σ, as the exhibit's oligos & len(6) & fixed_by(~rev). Each component is an involution, two commuting involutions (commutes and is_involutive above). (#1141: an alphabet over another carrier has its component from its rank, as refl does.) More...
struct	length_coherent
	A permutation family coherent across lengths: from n to n + 2 its cycle type gains cycles and changes none. The reversal's is: the longer chain's antitone bijection restricted to the middle is the shorter's, with one more pair outside (antitone_cycle_type). A rotation's follows \(\gcd(n, d)\) and is not. Coherence is naturality: the family is a natural transformation of the powers over the chains and their middle inclusions \(n \hookrightarrow n + 2\) (IsNaturalTransformation, :natural), as it is natural over the letter maps already (power(τ) commutes with it). Sufficient, not necessary: rotate(1) is not coherent, yet its sections' density \(|\Sigma| / |\Sigma|^n\) falls. A struct trait, for a family to register by one specialisation. More...
struct	length_coherent< Reverse >
struct	density_falls_on_even_lengths
	A family of sets of words whose density does not grow along the even lengths. Derived, not registered per family: the powers have density 1; fixing a permutation keeps it at most 1, cycle by cycle; a length-coherent permutation adds cycles from n to n + 2, each at most 1, so the density along the even lengths does not grow (the restriction sites: \(k^j / |\Sigma|^{2j}\) of length \(2j\), k the letters \(\tau^2\) fixes). More...
struct	density_falls_on_even_lengths< Compose< Powers< C, F, N >, FixedBy< Power< C, F, N >, S, T > > >
struct	Outer
	An outer product of two counted tensors, its count the product of theirs. More...
struct	FreeMonoid
	The free monoid on a filtered alphabet, truncated below a length: \(\Sigma^{<L} = \coprod_{n < L} \Sigma^n\), the coproduct of the tensor powers, concatenation of words its operation. More...
struct	CeilLog2
	\(\lceil \log_2 \rceil\), the bits a positive count's predecessor occupies: a lax monoid homomorphism \((\mathbb{N}_{>0}, \times) \to (\mathbb{N}, +)\), \(\lceil \log_2 ab \rceil \le \lceil \log_2 a \rceil + \lceil \log_2 b \rceil\), carrying the power action, \(\lceil \log_2 b^e \rceil \le e \lceil \log_2 b \rceil\). The inequality is the soundness of reading a count's width off its factors. More...
struct	Pow2
	\(k \mapsto 2^k\) on the counts, refused past the word: the window of the bit words. More...
struct	Pack
	A pattern, given by its count, in the bit word of width W, the padding above it zero: the switch of representation, from the counts to the word whose API has the rotations and masks. A section of unpack on the counts below \(2^W\). More...
struct	Unpack
	A machine word read back as the count of its pattern: the retraction of pack, \(\mathit{unpack} \circ \mathit{pack} = \mathrm{id}\) on the counts below \(2^W\). Up to a machine word, since a count is one. More...
struct	IsSquare
	A pattern of even width length, packed into the bit word of width W, that is a square \(u u\): fixed by the rotation by half its width, within its width, the padding apart. For a width \(2^k\) these are exactly the proper powers, the patterns that are not primitive (Lothaire, Combinatorics on Words, §1.3): every proper divisor of \(2^k\) divides \(2^{k-1}\). More...
struct	Window
	The window of a word from position offset, length letters long: its projection onto those positions, \(\pi_I\) for \(I = \{\mathit{offset}, \ldots, \mathit{offset} + \mathit{length} - 1\}\), a factor of the word in the sense of combinatorics on words. Total: a window past the word's end is cut at it, so it is shorter. More...
struct	Cylinder
	The words of a tensor power whose window lies in a set of words: the cylinder set \(\pi_I^{-1}(S)\), the legs the window reads constrained by S and every other leg free. More...
struct	unit_period< detail_periodic::CylinderFactorsAt< P, S, N > >
	The cylinder's factors along the offsets are constant by their type, R2's translation invariance: the sum of their counts is one count times the offsets. More...
struct	monotone_trait
	User-declared monotonicity witness for an arrow type F with respect to the ambient order relation Op. More...
struct	antimonotone_trait
	User-declared anti-monotonicity witness for an arrow type F with respect to the ambient order relation Op. More...
struct	Profile
	The laws an arrow is known to have, one answer in K₃ per law: True where certified, Unknown where not, never False (a profile certifies, it does not refute). The pointwise lift Ω^E of the truth chain to the laws (lattice__Omega_First_Pointwise_Lift), restricted to its sub-chain Σ = {Unknown < True}: combined law by law with Inf / Sup. Read by the laws of functions below and by the laws of relations (relational:dyadic). More...
struct	ArrowNodeAt
	The engine at one former and one law, as a function of the law. More...
struct	ProductLeq
	Componentwise product order on std::pair ≤×: (a,c)≤(b,d) :⟺ a≤b ∧ c≤d. The order-theoretic product of two posets, not the lexicographic std::less_equal on the pair. More...
struct	SubobjectInclusion
	inclusion_arrow(S): the inclusion \(\iota_S : S \hookrightarrow \mathrm{Domain}(S)\) of a subobject as an arrow (Domain = S::Member, Codomain = S::Domain, through S's own ι), so it can be a leg of a cospan. A monomorphism by definition. More...
struct	PullbackApex
	The pullback apex of a meet of A and B: the apex itself, viewed with the subobject surface and the projection legs π_1 / π_2 (IsPullback). More...
struct	PushoutApex
	The pushout apex of a join of A and B: the apex viewed with the subobject surface and the coprojections ι1 / ι2 (IsPushout). Dual of PullbackApex. More...
struct	ClassifierApex
	The subobject a predicate classifies, as the pullback of the truth \(\top : 1 \to \Omega\) along the predicate \(p : X \to \Omega\) (the subobject classifier's square): its members, the leg into X their inclusion, the leg to 1 the unique one. A view over the subobject, owning nothing. More...
struct	RunList
	A subset of the counts held as its steps: the positions where membership flips, strictly increasing, from outside at 0. At most K steps, so at most K / 2 runs. More...
struct	RunCombine
	The run lists' domain meet and join, the reducer's leaf-combine: where two leaves are run lists on one chain, the sweep, its bound the sum of theirs. More...
struct	StringArrow
	An arrow that is just a label. More...
struct	StringCategory
	The Category of Labels. More...
struct	SpeciesTraits
struct	SpeciesTraits< T >
struct	is_associative
	Trait to mark an operation as associative: (a ∘ b) ∘ c = a ∘ (b ∘ c). More...
struct	is_commutative
	Trait to mark an operation as commutative: a ∘ b = b ∘ a. More...
struct	is_commutative< T, std::bit_or< T > >
struct	is_commutative< T, std::bit_and< T > >
struct	is_idempotent
	Trait to mark an operation as idempotent: a ∘ a = a. More...
struct	is_idempotent< T, Op >
struct	unit_registry
struct	unit_registry< T, Op >
struct	unit_registry< T, std::plus< T > >
struct	unit_registry< T, std::multiplies< T > >
struct	unit_registry< bool, Op >
struct	unit_trait
struct	unit_trait< T, Op, std::void_t< decltype(T::template unit_v< Op >)> >
struct	inverse_trait
	The Formal Trait: Hooks the bridge into the Concept system. More...
struct	unit_trait< bool, std::bit_xor< bool > >
struct	unit_trait< T, std::plus<> >
struct	unit_trait< T, std::plus< T > >
struct	unit_trait< T, std::multiplies<> >
struct	unit_trait< T, std::multiplies< T > >
struct	unit_trait< T, std::bit_xor< T > >
struct	unit_trait< bool, std::bit_and< bool > >
struct	unit_trait< T, std::bit_or<> >
struct	unit_trait< T, std::bit_and<> >
	The top of the bit lattice: every bit set, ~T{} (an unsigned word's & identity; true on bool). More...
struct	is_idempotent< bool, std::logical_and< bool > >
struct	is_idempotent< bool, std::logical_or< bool > >
struct	is_idempotent< T, std::bit_and< T > >
struct	is_idempotent< T, std::bit_or< T > >
struct	is_associative< T, std::bit_or< T > >
struct	is_transfinite
	Primary trait for Transfiniteness. More...
struct	origin_trait
	Primary trait: The distinguished 'Point' of a species. More...
struct	origin_trait< T >
	Atomic Proof: Integrals are pointed at 0. More...
struct	Subobject
	The Subobject Species S ↣ A. More...
struct	builds_lattice_nodes< Subobject< A, Chi > >
	Subobjects opt in to the lattice's | and & (:lattice): the meet and join of two subobjects of A are the pointwise meet and join of their characteristic arrows ( \(\mathrm{Sub}(A) \cong \mathrm{Hom}(A, \Omega)\)), the lattice's own nodes over them, nested terms included. A subobject is a set object too; opted in, it is the lattice's, not the set grammar's (builds_lattice_nodes). More...
struct	is_periodic
struct	is_saturating
struct	is_exact_total
	Path D to totality: the operation is total because the carrier is exact — arithmetic with no rounding, Op(a,b) defined and lossless up to the carrier's out-of-memory tripwire. The archetypes are the exact number fields (Rational = ℚ, QuadraticReal = ℚ(√D)) under + and *. Distinct from the three machine-finite paths, which are total by staying in a bounded range (wrap / stabilise / saturate); an exact carrier is total because its arithmetic is closed and exact. More...
struct	is_periodic< T, std::plus< T > >
struct	is_periodic< T, std::minus< T > >
struct	is_periodic< T, std::multiplies< T > >
struct	is_periodic< T, std::bit_xor< T > >
struct	construction_base
	A carrier's construction: D is built from a base algebra and computes with the base's operations. ::type is the base; ::times_mixes_plus says whether D's × multiplies out (a quotient of a polynomial ring, the Cauchy product: the base's × and +) or stays componentwise (a product, a subalgebra: the base's × alone). Declared once per construction leg in dedekind.algebra (H / P / S / F), never per carrier; a carrier declaring two legs is ambiguous here, honestly. More...
struct	is_total_by_construction
	Path E to totality: by construction. Defined below is_total, which it recurses into on the base. More...
struct	is_total
	The certificate. Op is taken up to cv/ref (a const Inf keys the same registration as Inf). More...
struct	is_total< T, detail_involution::Reversed< Op > >
	The opposite operation is total where the operation is, read off the value form, which sees registrations on the struct and on the value. More...
struct	is_total< T, Op >
	A qualified operation is total where the operation is: the paths read the unqualified operation, and so does every specialisation. More...
struct	is_total_by_construction< D, std::plus< D > >
struct	is_total_by_construction< D, std::multiplies< D > >
struct	unit_registry< ConstantMorphism< A, B >, Op >
	unit_registry specialisation for ConstantMorphism<A, B>. Registers the constant-at-identity-element-of-B as the identity element of ConstantMorphism<A, B> under operation Op. More...
struct	is_cyclic_group
	Opt-in trait: is (T, Op) a \emph{cyclic} abelian group? More...
struct	cyclic_order
	The order \(n\) of a cyclic group (its cardinality). More...
struct	is_cyclic_group< T, std::plus< T > >
struct	cyclic_order< T, std::plus< T > >
struct	SpeciesTraits< dedekind::ieee::IEEE< F > >
struct	is_associative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >
struct	is_commutative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >
struct	is_associative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >
struct	is_commutative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >
struct	is_homomorphism< dedekind::linear_algebra::detail::ComplexToMatrix2x2Hom, dedekind::numbers::Complex< dedekind::linear_algebra::detail::Rat >, std::plus< dedekind::numbers::Complex< dedekind::linear_algebra::detail::Rat > >, std::plus< dedekind::linear_algebra::Matrix2x2V< dedekind::linear_algebra::detail::Rat > > >
struct	is_homomorphism< dedekind::linear_algebra::detail::ComplexToMatrix2x2Hom, dedekind::numbers::Complex< dedekind::linear_algebra::detail::Rat >, std::multiplies< dedekind::numbers::Complex< dedekind::linear_algebra::detail::Rat > >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< dedekind::linear_algebra::detail::Rat > > >
struct	is_homomorphism< dedekind::linear_algebra::detail::DualToMatrix2x2Hom, dedekind::analysis::Dual< dedekind::linear_algebra::detail::Rat >, std::plus< dedekind::analysis::Dual< dedekind::linear_algebra::detail::Rat > >, std::plus< dedekind::linear_algebra::Matrix2x2V< dedekind::linear_algebra::detail::Rat > > >
struct	is_homomorphism< dedekind::linear_algebra::detail::DualToMatrix2x2Hom, dedekind::analysis::Dual< dedekind::linear_algebra::detail::Rat >, std::multiplies< dedekind::analysis::Dual< dedekind::linear_algebra::detail::Rat > >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< dedekind::linear_algebra::detail::Rat > > >
struct	is_functorial< dedekind::linear_algebra::matrix2x2_functor< T > >
	Elementwise lifts: the functor laws hold by construction. More...
struct	unit_witness< dedekind::linear_algebra::matrix2x2_functor< T >, T >
struct	counit_witness< dedekind::linear_algebra::matrix2x2_functor< T >, T >
	Counit / extract for Matrix2x2V<T>: top-left corner. Matches the m11 = (1, 1) entry — the canonical projection from the matrix algebra to the underlying scalar ring. More...
struct	unit_trait< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >
	The units of M₂(T), built from the scalars' own: the zero matrix for +, the identity for ×, what a ring homomorphism into it carries 0 and 1 to. More...
struct	unit_trait< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	is_associative< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	is_associative< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	is_commutative< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	is_total_by_construction< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	is_total_by_construction< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > >
struct	unit_trait< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatPlus< S, N > >
	⊕-identity of Mat(S) is the zero matrix. Registered on the exported unit_trait extension point (the internal unit_registry box is not reachable across modules), exactly as dedekind::algebra::Tropical registers its own ∞ / 0. More...
struct	unit_trait< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N > >
	⊗-identity of Mat(S) is the identity matrix. More...
struct	is_involutive< dedekind::linear_algebra::TransposeF< S, N >, dedekind::linear_algebra::MatNxNV< S, N > >
	The transpose is an involution (Aᵀᵀ = A) for any S, so TransposeF is a certified IsInvolution on Mat(S) — the involutive core of the dagger the predicates (is_unitary) read. A structural fact about the operation, not a per-arrow unitarity claim (unitarity is a value property; see :involution). More...
struct	is_homomorphism< dedekind::linear_algebra::TransposeF< S, N >, dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N >, Opposite< dedekind::linear_algebra::MatTimes< S, N > > >
	Over a commutative scalar ⊗ the transpose reverses matrix multiplication, \((A B)^{\top} = B^{\top} A^{\top}\): a homomorphism into the opposite product, so, with \(A^{\top\top} = A\), a dagger on Mat(S). Witnessed by contravariance_over_commutative_semiring below; over a noncommutative ⊗ the transpose stays an involution and is no dagger. More...
struct	is_linear_action< dedekind::linear_algebra::SemimoduleVec< S, N, O >, S, std::plus< dedekind::linear_algebra::SemimoduleVec< S, N, O > >, typename dedekind::algebra::semiring_ops< S >::add, typename dedekind::algebra::semiring_ops< S >::mult, std::multiplies<> >
	\(S^N\), entrywise, is a semimodule over any semiring S: the free semimodule of rank N, its laws the semiring's, entry by entry. One certificate for both orientations. More...
struct	unit_trait< dedekind::linear_algebra::SemimoduleVec< S, N, O >, std::plus< dedekind::linear_algebra::SemimoduleVec< S, N, O > > >
	The ⊕-identity of a dedekind::linear_algebra::SemimoduleVec (a Ket or Bra) is the zero vector (every entry the base ⊕-identity) — what makes it an IsCommutativeMonoid, hence an IsSemimodule, hence an IsColumnVector / IsCovector. One registration for both orientations. More...
struct	is_saturating< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatPlus< S, N > >
	Totality of Mat(S)'s monoids is inherited, honestly: matrix ⊕ is total exactly when the base ⊕ is a magma, and matrix ⊗ (built from both base ops) when both are. Same discipline as Tropical's ⊗ saturation — true for a periodic/saturating base such as the necklace's saturating-unsigned dioid, false where the base op is a hazard (e.g. signed +). More...
struct	is_saturating< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N > >
struct	is_saturating< dedekind::linear_algebra::SemimoduleVec< S, N, O >, std::plus< dedekind::linear_algebra::SemimoduleVec< S, N, O > > >
	Totality distributes over the vector construction (§4 property distribution): a dedekind::linear_algebra::Ket / dedekind::linear_algebra::Bra is a total magma under its elementwise ⊕ exactly when the scalar ⊕ is. Parametric on S — the decision is settled at the call site by which scalar the exhibit uses (a total field such as Rational<default_integer> or the max-plus dioid: yes; a signed long-backed Rational: no), never asserted near the carrier. More...
struct	is_functorial< dedekind::linear_algebra::vec2_functor< T > >
	Elementwise lifts: the functor laws hold by construction. More...
struct	is_functorial< dedekind::linear_algebra::covec2_functor< T > >
struct	unit_witness< dedekind::linear_algebra::vec2_functor< T >, T >
struct	unit_witness< dedekind::linear_algebra::covec2_functor< T >, T >
struct	counit_witness< dedekind::linear_algebra::vec2_functor< T >, T >
	Counit / extract witness for Vec2V<T>. Canonical projection to the first coordinate; mirrors the Reader-monad π_0 counit. More...
struct	product_algebra_base< dedekind::linear_algebra::Vec2V< T > >
struct	product_algebra_base< dedekind::linear_algebra::Covec2V< T > >
struct	unit_trait< dedekind::linear_algebra::Vec2V< T >, std::plus< dedekind::linear_algebra::Vec2V< T > > >
struct	unit_trait< dedekind::linear_algebra::Covec2V< T >, std::plus< dedekind::linear_algebra::Covec2V< T > > >
struct	inverse_trait< dedekind::linear_algebra::Vec2V< T >, std::plus< dedekind::linear_algebra::Vec2V< T > > >
struct	inverse_trait< dedekind::linear_algebra::Covec2V< T >, std::plus< dedekind::linear_algebra::Covec2V< T > > >
struct	is_associative< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	is_commutative< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	is_associative< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >
struct	is_commutative< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >
struct	is_periodic< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	is_periodic< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >
struct	is_periodic< dedekind::morphologies::Modular< N >, std::minus< dedekind::morphologies::Modular< N > > >
struct	unit_trait< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	unit_trait< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >
struct	SpeciesTraits< dedekind::morphologies::Modular< N > >
struct	is_cyclic_group< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	cyclic_order< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > >
struct	quotient_congruence< dedekind::morphologies::Modular< N > >
struct	kernel_quotient< dedekind::morphologies::first_iso_mod_2::mod_2_arrow >
struct	image_carrier< dedekind::morphologies::first_iso_mod_2::mod_2_arrow >
struct	is_exact_total< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
struct	is_exact_total< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >
struct	is_associative< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
struct	is_commutative< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
struct	inverse_trait< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >
struct	is_exact_total< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	is_associative< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	is_commutative< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	unit_trait< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	inverse_trait< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	is_cyclic_group< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	cyclic_order< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > >
struct	SpeciesTraits< dedekind::numbers::Complex< R > >
struct	is_homomorphism< std::decay_t< decltype(dedekind::numbers::embed_ℝ_ℂ)>, dedekind::numbers::QuadraticReal< 2 >, std::plus< dedekind::numbers::QuadraticReal< 2 > >, std::plus< dedekind::numbers::Complex< dedekind::numbers::QuadraticReal< 2 > > > >
struct	is_homomorphism< std::decay_t< decltype(dedekind::numbers::embed_ℝ_ℂ)>, dedekind::numbers::QuadraticReal< 2 >, std::multiplies< dedekind::numbers::QuadraticReal< 2 > >, std::multiplies< dedekind::numbers::Complex< dedekind::numbers::QuadraticReal< 2 > > > >
struct	quotient_algebra_base< dedekind::numbers::Complex< R > >
struct	is_linear_action< dedekind::numbers::Complex< R >, R, std::plus< dedekind::numbers::Complex< R > >, std::plus< R >, std::multiplies< R >, std::multiplies<> >
struct	unit_trait< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
struct	unit_trait< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >
struct	inverse_trait< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
struct	SpeciesTraits< dedekind::numbers::Cut< Q > >
	Atlas registration: Cut<Q> is a first-class species. More...
struct	SpeciesTraits< dedekind::numbers::QuadraticReal< D, Q > >
	Atlas registration: QuadraticReal<D,Q> is a first-class species. More...
struct	is_exact_total< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_exact_total< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_associative< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_associative< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_commutative< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_commutative< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >
struct	unit_trait< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > >
struct	unit_trait< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >
struct	inverse_trait< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > >
struct	is_exact_total< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
struct	is_exact_total< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > >
struct	unit_trait< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
struct	unit_trait< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > >
struct	is_linear_action< dedekind::numbers::Rational< I >, I, std::plus< dedekind::numbers::Rational< I > >, std::plus< I >, std::multiplies< I >, std::multiplies<> >
struct	inverse_trait< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
struct	is_homomorphism< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)>, dedekind::numbers::default_integer, std::plus< dedekind::numbers::default_integer >, std::plus< dedekind::numbers::Rational< dedekind::numbers::default_integer > > >
	ℤ ↪ ℚ preserves \(+,\times,0,1\) — the field-of-fractions ring embedding, between two strict-total algebras: ℤ is category::IsRing (saturating totality, :cardinality) and ℚ is category::IsField (exact totality, registered in this partition). So the declarations here make a fully-certified ring homomorphism, not merely an operational declaration. More...
struct	is_homomorphism< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)>, dedekind::numbers::default_integer, std::multiplies< dedekind::numbers::default_integer >, std::multiplies< dedekind::numbers::Rational< dedekind::numbers::default_integer > > >
struct	SpeciesTraits< dedekind::numbers::Rational< Z > >
struct	is_homomorphism< dedekind::numbers::EmbedRationalToReal< I >, dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > >, std::plus< dedekind::numbers::QuadraticReal< 2, dedekind::numbers::Rational< I > > > >
	S-leg is structure-preserving (witness: preserves + and ×; 0 and 1 are computed). More...
struct	is_homomorphism< dedekind::numbers::EmbedRationalToReal< I >, dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > >, std::multiplies< dedekind::numbers::QuadraticReal< 2, dedekind::numbers::Rational< I > > > >
struct	is_reflexive< T, dedekind::order::bit_subset_eq< T > >
struct	is_transitive< T, dedekind::order::bit_subset_eq< T > >
struct	is_antisymmetric< T, dedekind::order::bit_subset_eq< T > >
struct	is_directed< T, dedekind::order::bit_subset_eq< T > >
struct	is_codirected< T, dedekind::order::bit_subset_eq< T > >
struct	HeytingExponential< T, dedekind::order::bit_subset_eq< T >, std::bit_and< T > >
	HeytingExponential specialisation for the bitwise Boolean lattice (#710): on integral T (excluding bool — see caveat below) under bit_subset_eq with std::bit_and as meet, the relative complement a → b = ~a | b (Boolean Heyting), and the eval morphism e(x) = e & x (meet). Required so IsHeytingLatticeCategory fires at row 6 of the Form-chain for this Rel / Meet pairing. More...
struct	LatticeBottom< T, dedekind::order::bit_subset_eq< T > >
	Bitwise-lattice bottom: the all-zeros bitmask. More...
struct	LatticeTop< T, dedekind::order::bit_subset_eq< T > >
	Bitwise-lattice top: the all-ones bitmask. More...
struct	is_complement< std::bit_not< T >, T, dedekind::order::bit_subset_eq< T >, std::bit_or< T >, std::bit_and< T > >
	Canonical specialisation: std::bit_not<T> is the complement for the bitwise Boolean lattice on integral T (excluding bool — see caveat). Complement laws hold structurally: a & ~a = 0 (bottom) and a | ~a = ~T(0) (top). More...
struct	is_equality< A, Endo< A, L, C, DiagPred< A > > >
struct	is_equality< A, Endo< A, L, C, PairwisePred< Op > > >
struct	monotone_trait< dedekind::relational::Image< F, L >, std::less_equal<> >
	The hyperdoctrine, stated once for every arrow F: the three operations preserve inclusion, and \(\exists_f \dashv f^{-1} \dashv \forall_f\) — \(f[a] \subseteq b \iff a \subseteq f^{-1}(b)\) and \(f^{-1}(b) \subseteq a \iff b \subseteq \forall_f a\) (Lawvere; in Set, for every \(f\)). More...
struct	monotone_trait< dedekind::relational::Preimage< F, L >, std::less_equal<> >
struct	monotone_trait< dedekind::relational::Dual< F, L >, std::less_equal<> >
struct	is_adjoint< dedekind::relational::Image< F, L >, dedekind::relational::Preimage< F, L >, std::less_equal<> >
struct	is_adjoint< dedekind::relational::Preimage< F, L >, dedekind::relational::Dual< F, L >, std::less_equal<> >
struct	path_functor
	The path functor for the Path <·> shape (#508 / PR #521 review). More...
struct	unit_witness< path_functor< T >, T >
struct	counit_witness< path_functor< T >, T >
struct	is_kleisli_triple< dedekind::sequences::path_functor< T > >
	A path with the default (infinite) cardinality is a stream, whose bind is the diagonal and whose extend takes suffixes: the monad and the comonad on streams (Uustalu and Vene), their laws by construction. More...
struct	is_cokleisli_triple< dedekind::sequences::path_functor< T > >
struct	is_transfinite< dedekind::sets::𝔸< T, L, C > >
struct	is_lattice_bottom_for< dedekind::sets::Ø< T, L >, dedekind::sets::subobject_order< L > >
struct	is_lattice_top_for< dedekind::sets::𝔸< T, L, C >, dedekind::sets::subobject_order< L > >
struct	is_integer_chain< dedekind::sets::Cardinality >
struct	is_integer_chain< dedekind::sets::SignedCardinality >
struct	is_integer_chain< dedekind::sets::ExtensionalCardinal< W > >
struct	is_integer_chain< dedekind::sets::SignedExtensionalCardinal< S > >
struct	unit_trait< C1, std::plus< C1 > >
struct	unit_trait< C1, std::multiplies< C1 > >
struct	is_periodic< C1, std::plus< C1 > >
struct	is_periodic< C1, std::multiplies< C1 > >
struct	unit_trait< Z1, std::plus< Z1 > >
struct	unit_trait< Z1, std::multiplies< Z1 > >
struct	is_periodic< Z1, std::plus< Z1 > >
struct	is_periodic< Z1, std::multiplies< Z1 > >
struct	inverse_trait< Z1, std::plus< Z1 > >
struct	is_cyclic_group< dedekind::sets::ExtensionalCardinal< W >, std::plus< dedekind::sets::ExtensionalCardinal< W > > >
struct	is_cyclic_group< dedekind::sets::SignedExtensionalCardinal< S >, std::plus< dedekind::sets::SignedExtensionalCardinal< S > > >
struct	unit_trait< SC, std::plus< SC > >
struct	unit_trait< SC, std::multiplies< SC > >
struct	is_saturating< SC, std::plus< SC > >
struct	is_saturating< SC, std::multiplies< SC > >
struct	is_saturating< SC, std::minus< SC > >
struct	inverse_trait< SC, std::plus< SC > >
struct	unit_trait< Card, std::plus< Card > >
struct	unit_trait< Card, std::multiplies< Card > >
struct	is_saturating< Card, std::plus< Card > >
struct	is_saturating< Card, std::multiplies< Card > >
struct	SpeciesTraits< dedekind::sets::Cardinality >
struct	SpeciesTraits< dedekind::sets::SignedCardinality >
struct	SpeciesTraits< dedekind::sets::SignedExtensionalCardinal< S > >
struct	antimonotone_trait< dedekind::sets::Complement< T, L >, std::less_equal<> >
	The complement reverses inclusion: \(a \subseteq b \Rightarrow \neg b \subseteq \neg a\), for every carrier and logic. More...
struct	is_adjoint< dedekind::sets::Complement< T, L >, dedekind::sets::Complement< T, L >, std::less_equal<> >
	The complement is its own antitone adjoint, \(a \subseteq \neg b \iff b \subseteq \neg a\): the De Morgan algebra \(\mathrm{Sub}(T, L)\) as a Galois connection, for every carrier and logic. More...
struct	monotone_trait< dedekind::sets::Inject< K, UA, UB >, std::less_equal<> >
	The pushforward and the pullback along an injection preserve inclusion, and \(\exists_{\iota_K} \dashv \iota_K^{-1}\): \(\iota[a] \subseteq s \iff a \subseteq \iota^{-1}(s)\), the image–preimage adjunction, for every sum; \(\iota\) monic makes the unit the identity. More...
struct	monotone_trait< dedekind::sets::Restrict< K, UA, UB >, std::less_equal<> >
struct	is_adjoint< dedekind::sets::Inject< K, UA, UB >, dedekind::sets::Restrict< K, UA, UB >, std::less_equal<> >
struct	compose
struct	ComposePred
	The composed predicate for the relative product \(R;S\) over a Boolean intermediate, the ∃-over-the-middle enumerated on {false, true}. More...
struct	DiagPred
	The equality-of-coordinates predicate for the diagonal \(\Delta = \{(a,a)\}\). A plain std::equality_comparable check — the diagonal is pure equality, no ordering, so it lives here at the base. More...
struct	PairwisePred
	A binary predicate on A read at the pair ⟨a, b⟩: the other direction of the bridge a set over a product crosses (#1047), so std::less_equal<bool> is a set of pairs. Named, so it carries op and the set inherits every law op has on A (the rules below). More...
struct	SwapPred
	The swapped predicate for converse: \(R^\smile(b,a) = R(a,b)\). More...
struct	RelAnd
	Meet (conjunction) of two relational predicates, the result of && on them. More...
struct	RelOr
	Join (disjunction) of two relational predicates, the result of || on them, dual to RelAnd. More...

Concepts
concept	IsFreeAlgebra
	F is declared as the free algebra over some base R.
concept	IsQuotientAlgebra
	Q is declared as a quotient of some base algebra.
concept	IsCongruenceQuotient
	Q is a quotient of a carrier V by a declared congruence R for Op and reduces from V — the relational reading of the H leg.
concept	IsProductAlgebra
	Q is declared as a finite direct product of some base algebra.
concept	IsSubalgebra
	Subobject S of A is a subalgebra under operation Op when it is closed under Op.
concept	IsSubalgebraOf
	S is declared as a subalgebra of some base algebra.
concept	RegisteredViaHelper
concept	SpeciesTraitsHasIsAssociative
concept	SpeciesTraitsHasIsCommutative
concept	SpeciesTraitsHasIsPeriodic
concept	SpeciesTraitsHasIsInvertible
concept	SpeciesTraitsHasIsDistributive
concept	SpeciesTraitsHasIdentity
concept	IsLeftAction
	The shape of a left action (S ⟳ M), \(S \times M \to M\), scalar first, as a module's: its laws are the certificate a concept above it reads (is_linear_action for a semimodule). A left action of a monoid \(M\) is a right action (IsRightAction) of its opposite, Opposite<Op> (:involution), and over a commutative monoid the two coincide.
concept	IsSemimodule
	A commutative monoid M on which the semiring S acts linearly.
concept	HasCountingAction
	The counts act on (T, Op) in one step, by a law: the semimodule laws or idempotence.
concept	IsRightAction
	H is a right action \(M \times S \to M\) of the monoid (S, Op) that acting_monoid<H> names: M is a right S-set (Mac Lane and Moerdijk), an S-act (Kilp, Knauer and Mikhalev, Monoids, Acts and Categories). A left action is a right action of the opposite, Opposite<Op>.
concept	HasAdjunctionShape
	Structural shape: F and U have the categorical signature of an adjoint pair F ⊣ U — F : 𝒟 → 𝒞 (left, free) and U : 𝒞 → 𝒟 (right, forgetful).
concept	IsFreeFunctor
	Directional alias: F is the left adjoint of an adjunction F ⊣ U. Names the free direction — F sends an object d : 𝒟 to its free construction F(d) : 𝒞 (the universal recipient under U).
concept	IsForgetfulFunctor
	Directional alias: U is the right adjoint of an adjunction F ⊣ U. Names the forgetful direction — U drops the structure that distinguishes 𝒞 from 𝒟 (e.g., U_Ring→Rig forgets that you can do −).
concept	IsUnitOfAdjunction
	Structural shape: η is the unit of an adjunction F ⊣ U — a natural transformation id_𝒟 ⇒ U ∘ F.
concept	IsCounitOfAdjunction
	Structural shape: ε is the counit of an adjunction F ⊣ U — a natural transformation F ∘ U ⇒ id_𝒞. Dual of IsUnitOfAdjunction.
concept	IsAdjunction
	A typed unit/counit witness relating a left and right functor.
concept	IsCovariantFunctor
	A covariant functor between posetal categories: an order-PRESERVING arrow. This is IsMonotone read categorically (a monotone map is a functor of posets that preserves the direction of composition), the documented covariant pole of functor variance (#908).
concept	IsContravariantFunctor
	A contravariant functor between posetal categories: an order-REVERSING arrow (IsAntiMonotone read categorically). The contravariant pole; inhabited by the negation NegationArrow ¬ and any Compose that mixes one covariant with one contravariant leg.
concept	IsVariantFunctor
	A functor between posetal categories with a definite variance: covariant or contravariant. This is the "@c IsFunctor parametrized with @c IsVariant" umbrella whose poles are IsCovariantFunctor and IsContravariantFunctor, and exactly the leg-shape a Galois connection's adjoints must share (matched variance, below).
concept	IsOrderEmbedding
	An order-preserving embedding: a monic, order-preserving arrow of one ordered set into another. Such an embedding is a covariant functor between the two posetal categories, so IsCovariantFunctor is a conjunct — the classification is derived from the two legs (IsEmbeddingFunctor && IsMonotone), not re-declared per carrier (#908).
concept	IsGaloisConnection
	Structural shape: F and G form a Galois connection F ⊣ G in a posetal setting — the simplest adjunction. Both are monotone arrows; F : P → Q and G : Q → P with the source/target carriers crossed (so F's Codomain matches G's Domain and vice versa). The universal-property test, for monotone legs
concept	IsClosureOperator
	Structural shape: C is a closure operator on a poset P — an arrow C : P → P that is idempotent (C(C(x)) = C(x)), monotone (x ≤ y ⇒ C(x) ≤ C(y)), and extensive (x ≤ C(x)) for all x.
concept	IsExponential
	Categorical exponential object B^A — generalised structural recogniser of "eval morphism via call expression" (#698 Slice 6).
concept	IsArrowExponential
	An exponential E : A → B that also satisfies the project's morphism vocabulary (IsArrow with matching Domain / Codomain typedefs). #706.
concept	IsCoproduct
	Categorification of std::variant<A, B> as the categorical coproduct (A + B).
concept	IsCartesianClosed
	A Category equipped with Terminal Objects, Products, and Exponentials.
concept	IsProductCategory
	A category whose Species is a categorical product (std::pair).
concept	IsBinaryRelation
	A type R is a binary relation A × B → bool if it is callable on A and B and yields a boolean.
concept	IsBinaryFunction
	A binary relation R ⊆ A × B is a function when it is left-total AND right-unique.
concept	IsDirectedGraph
	A homogeneous binary relation R ⊆ V × V on a vertex set V is a directed graph: each ordered pair (u, v) with R(u, v) == true is an edge.
concept	IsUndirectedGraph
	A directed graph R is undirected when its relation is symmetric: R(u, v) iff R(v, u).
concept	IsCongruence
	A homogeneous binary relation R on a carrier V is a congruence w.r.t. operation Op when it is an equivalence relation and respects Op.
concept	HasSubscriptOperator
	Syntactic check: s[i] compiles for Seq, Idx.
concept	IsEvalArrow
	Seq exposes operator[Idx] and the carrier site has declared it as the CCC eval counit (Mac Lane CWM §IV.6).
concept	IsCopy
	: the DIAGONAL notion Δ:A→A×A --- an arrow whose Codomain is the square of its Domain (the comonoid comultiplication / fan-out). Copy is the canonical MODEL; this concept is the matchable "diagonal" handle. Purely structural: it names the crossed A→A×A signature, not that the map is a↦(a,a) (that is Copy's own obligation). Cartesian only: the non-cartesian ⊗ setting needs the carrier generalized past std::pair (#951); a type carrying more than one arrow reading needs the dom/cod contract (#952).
concept	IsMerge
	: the FOLD notion Δ†:A×A→A --- an arrow whose Domain is the square of its Codomain (the comonoid dagger / binary combiner). Merge<A,Meet> is the canonical MODEL; this concept is the matchable handle. Purely structural: it names the A×A→A signature, so a PROJECTION π:A×A→A also satisfies it (the shape cannot tell a fold from a projection, the same honesty gap as glb-vs-lub). Same seams as IsCopy: carrier past std::pair (#951); the multi-reading dom/cod contract (#952).
concept	IsMeetAsRightAdjoint
	The STRUCTURAL shape of "the meet @c ∧ is the right adjoint of the diagonal @c Δ" (Δ⊣∧): the reified theory this slice postulates as a type-check.
concept	IsTensor
	: the structural shape of the parallel product ⊗ --- an arrow whose Domain AND Codomain are product objects (the arrow-half of the product bifunctor). Tensor<R,S> is the canonical MODEL; this concept is the matchable handle. Cartesian only: the non-cartesian monoidal ⊗ (LA outer product) needs the carrier generalized past IsProduct (#951); a type with >1 arrow reading needs the dom/cod contract (#952).
concept	IsIntegerChain
	A chain with integer arithmetic: a discrete total order, locally finite (every bounded interval is finite), so a distributive lattice under min and max, with the NNO's step and the arithmetic operators as a shape. Finite on a machine word, unbounded for a bignum. Not a ring: int's overflow is undefined and a cardinal may saturate at \(\aleph_0\); the ring is IsRing's to claim.
concept	IsCountWord
	A word of the counts: an integer chain whose arithmetic wraps at its cyclic order, the unsigned integers but bool, and none narrower than int, whose products promote to a signed int that may overflow. std::size_t is the default throughout.
concept	IsFiniteChainSequence
	A sequence on finite chains: an arrow out of the counts, read along a chain of them (the Jlt paper's Figure 2, its vertical arrows). The chain is finite by its descent and ordered by its step, so the sequence needs no set concept; its laws, a period or an order kept or reversed, are laws of the composite chain >> f, and the folds read them (#1133).
concept	IsQuery
	A query: a range whose elements are Maybe, each present or a hole.
concept	IsPrefixKernel
	A kernel on the non-empty prefixes of a text: an arrow out of them, a coKleisli arrow of the history comonad, whose answer at a position may read all that came before it and nothing after.
concept	SetAsProduct
	Set := (Underlying, Classifier) read as a product, in the projection-access sense.
concept	IsConcrete
	A small category C is concrete when its objects are themselves sets — equivalently, when there is a faithful functor U : C → Set.
concept	HasTernarySupport
	True when a set object's classifier returns ternary truth values.
concept	IsCompatibleSetPair
	Two set objects over the same ambient species and same Ω codomain.
concept	IsDiscreteCategory
concept	IsSymmetric
	Formal verification: Rel(a, b) ⇔ Rel(b, a).
concept	IsEquality
	Rel on T is equality of values (the diagonal).
concept	IsChainDecidedSymmetric
	Symmetry, stated once for every relation on a walkable chain.
concept	IsEquivalence
	A binary relation on T that is reflexive, symmetric, and transitive — the textbook equivalence-relation axioms.
concept	IsHashFunction
	A callable h on T whose codomain is std::size_t — i.e. an arrow T → size_t.
concept	HasAxiom1Composition
	ETCS axiom 1 witness: composition is available for ambient arrows.
concept	HasAxiom2Identity
	ETCS axiom 2 witness: identity arrow acts neutrally on A.
concept	HasAxiom3TerminalObject
	ETCS axiom 3 witness: terminal object 1 is present.
concept	HasAxiom4WellPointedness
	ETCS axiom 4 witness: membership is evaluation through the carrier-as-characteristic-morphism. Post-#681 structural refactor: IsSubobject already requires the structural call shape { s(a) } -> IsΩ, so the membership-as-evaluation reading lands on the IsSubobject witness itself.
concept	HasAxiom5CartesianProduct
	ETCS axiom 5 witness: products exist for ambient species A.
concept	HasAxiom6Exponentiation
	ETCS axiom 6 witness: exponentials B^A exist (here A^A witness). Uses the named IsArrowExponential refinement (#706) rather than the ad hoc IsExponential && IsArrow combination that lived here previously.
concept	HasAxiom7SubobjectClassifier
	ETCS axiom 7 witness: every set is represented by a subobject.
concept	HasAxiom7ClassifierNaturalityWitness
	Optional naturality witness for Axiom 7 classifier behavior.
concept	HasAxiom8EmptySet
	ETCS axiom 8 witness: initial object 0 is present.
concept	HasAxiom9NNO
	ETCS axiom 9 witness: arithmetic species atlas exposes ℕ witness.
concept	IsSplitEpicPair
	Structural witness of a split epimorphism e with section s.
concept	HasAxiom10ChoiceSplitEpicWitness
	Axiom 10 (choice) support via an explicit split-epi witness shape.
concept	HasAxiom10ChoiceSplitEpicLawSurface
	Axiom 10 semantic-law surface (split-epi shape + equality codomain).
concept	HasAxiom7PullbackReindexingDefinitionalSurface
	Axiom 7 definitional reindexing witness surface.
concept	HasAxiom10PowerObjectLattice
	ETCS axiom 10 witness: power-object lattice completeness.
concept	HasETCSAxioms
	Diaconescu's classical direction (#698 Slice 9 review).
concept	IsSet
	ETCS set: a carrier satisfying the 10 ETCS axioms AND admitting the canonical Set-CCC witness over its ambient species.
concept	IsInitialFAlgebra
	Carrier A is the initial F-algebra for endofunctor F with structure map α.
concept	IsTerminalFCoalgebra
	Carrier A is the terminal F-coalgebra for endofunctor F with structure map α.
concept	IsTermNode
	A node of the term functor: a type that exposes its legs.
concept	Steers
	An algebra that steers the fold at T (Mendler style): it recurses into the legs it chooses by cata itself, instead of the strict fold.
concept	IsRegularEpi
	An arrow E is a regular epi when it is an epi and registered as the coequalizer of some parallel pair.
concept	IsRegularMono
	Dual of IsRegularEpi: an arrow M is a regular mono when it is a mono and the equalizer of some parallel pair.
concept	IsFactorisationSystem
	Category C admits the canonical (regular epi, mono) factorisation system. Form-chain row 6 (#718).
concept	IsRegularCategory
	Category C satisfies the regular-category axioms. Pinned for Set and (transitively) every topos.
concept	IsExactCategory
	Category C satisfies the exact-category axioms. Sollbruchstelle landing site.
concept	IsDirected
	Formal verification of the directedness axiom: ∀ a, b ∈ T. ∃ c ∈ T. Rel(a, c) ∧ Rel(b, c).
concept	IsCodirected
	Formal verification of the codirectedness axiom: ∀ a, b ∈ T. ∃ c ∈ T. Rel(c, a) ∧ Rel(c, b).
concept	IsFilteredCategory
	A thin category whose every finite subset of objects has an upper bound (directedness).
concept	IsFunctor
	The textbook functor (#633): an IsArrow whose Domain and Codomain are (small) categories — a 1-morphism in Cat, Mac Lane §I.3 — carrying a morphism map.
concept	IsShapedFunctor
	A 1-morphism mapping CatS -> CatT, refined with the container shape: an IsFunctor that additionally exposes a type-level object map Shape and the action on arrows, F(f).
concept	IsIdentityFunctor
concept	IsEndofunctor
	A structure-preserving mapping from a Category back to itself (F : 𝒞 → 𝒞).
concept	IsIterativeEndomorphism
	A stabilizing step function on a carrier species.
concept	IsFAlgebra
	A carrier A equipped with a structure map F<A> -> A.
concept	IsFCoalgebra
	A carrier A equipped with a structure map A -> F<A>.
concept	IsEmbeddingFunctor
	A functor that is fully faithful + injective on objects (Mac Lane CWM §IV.4 strong reading; the Yoneda-embedding flavour).
concept	IsQuotientFunctor
	A functor that is a regular epi / coequalizer presentation (Borceux Handbook §4.3).
concept	IsImageOf
	S realises the image of arrow F as a Subobject of Cod<F> — the mono side of the (regular epi, mono) factorisation system pinned in :factorisation.
concept	IsCoequalizer
	The categorical dual of IsEqualizer — a Quotient of Cod<F> equating two parallel arrows F, G.
concept	WitnessesFirstIso
	Connector witnesses the First Isomorphism Theorem at homomorphism F.
concept	IsInvolution
	Stated in arrow language: F is an endomorphism on the object T (IsEndomorphism, domain and codomain T — applying it twice returns to the domain) carrying the certificate \(f \circ f = \mathrm{id}_T\). T defaults to the arrow's domain; a bare callable names it. The object may be presented by many types (morphism__Objects_And_Their_Presentations), so the complement on \(\mathrm{Sub}(T)\) is an involution here, through this one concept.
concept	IsAntiHomomorphism
	A map on T that reverses Op, \(f(a \cdot b) = f(b) \cdot f(a)\): a homomorphism into the opposite, Opposite<Op>, read off the homomorphism certificate rather than declared apart.
concept	IsDagger
	The \(\dagger\)-category surface built on IsInvolution: IsDagger, the named intermediate IsIsometry, and IsUnitary — where "the converse is the inverse" (bijective relation) and "the transpose is the inverse" (orthogonal matrix) are one theorem.
concept	IsIsometry
	A singleton morphism-carrier F (its default value is the arrow) whose dagger is a left inverse: the named non-linear intermediate (Heunen & Vicary). For a value-level carrier, use the is_isometry predicate instead.
concept	IsUnitary
	A singleton morphism-carrier whose dagger is its inverse (isometry and coisometry) — a dagger-iso, \(f^\dagger = f^{-1}\). Hence an IsIsomorphism once lifted into the arrow surface (follow-up).
concept	IsRetractableArrow
	A monic arrow that ships with a structurally-known retract, a partial inverse retract(f) : Cod<F> → Maybe<Dom<F>>, discoverable via ADL on F.
concept	IsKleisliTriple
	A Kleisli triple ⟨T, η, (−)*⟩ (Manes), the monad in its extension form: the unit and bind, their laws certified by is_kleisli_triple.
concept	IsCoKleisliTriple
	A co-Kleisli triple ⟨W, ε, (−)†⟩, the comonad in its extension form: the counit and extend, their laws certified by is_cokleisli_triple.
concept	IsFrobenius
	A Frobenius monad (Street): a Kleisli and a co-Kleisli triple on one functor whose μ and δ satisfy the Frobenius law, certified by is_frobenius_monad.
concept	HasKleisliBindOperators
	A monadic carrier MA supports Kleisli bind, >>=, with a Kleisli arrow F; >> composes arrows and nothing else.
concept	HasComonadicExtendOperators
	A comonadic carrier WA supports comonadic extend, <<=, with a co-Kleisli arrow F.
concept	HasArrowDereferenceOperator
	Syntactic check: m.operator->() compiles for M.
concept	IsKleisliDeref
	M exposes operator-> and the carrier site has declared it as Kleisli dereference / comonadic extract (Mac Lane CWM §VI; Wadler 1992).
concept	IsKleisliArrow
	An arrow declared to live in the Kleisli category indexed by the monad tag M (constrained by IsDefaultMonadTag).
concept	IsLatticeCategory
	A posetal category that is both filtered and cofiltered, with joins and meets given by the algebraic lattice operations.
concept	IsBoundedLatticeCategory
	A lattice category that has a designated bottom (initial) and top (terminal) element — row 5 of the lattice Form-chain (#698 Slice 4).
concept	HasLogicSpecies
	The equational laws a lattice concept induces, as compile-time term-reduction rules over the term AST below. Each law is a decomposable, independently-testable part; the assembled reducer (:lattice_term) applies exactly the laws the supplied carrier proves. The richer the carrier's structure (a bounded chain is the sweet spot; bool the optimal witness), the more laws fire and the further a term collapses.
concept	IsSpeciesTaggedArrow
	An arrow that names its logic species and answers in it: Cod.
concept	SameCarrier
	Do both operands live in the same, known carrier? The boundary laws require this so a bound of one carrier (e.g. an int ⊤) is never applied as the unit / annihilator of a term whose other operand lives in a different carrier: a mixed-carrier term (⊤ᵢₙₜ ∧ bool-leaf) fails closed. Because the carrier is read via carrier_of, the laws still apply to an arbitrary same-carrier composite subterm (⊤∧X=X even when X is an un-collapsed Meet / Join), not only to leaves. (The glb/lub law forces a shared carrier through OrderComparable; this is its boundary-law counterpart.).
concept	IsIdempotentLeaf
	T's values are determined by its type, so a type-only lattice law (X∧X=X idempotence, a∧¬a=⊥ complement) collapses soundly on it: two same-type instances are necessarily the same value. A runtime-stateful leaf (say a Singleton holding a value, or a predicate with an expected field) is not idempotent, so those laws must not fire on it, else Meet{S{7},¬S{3}} would wrongly collapse to ⊥. This is the value-safety gate the type-level reducer shares with the value-first :lattice_term reducer (#922). Recursive over Meet / Join / Not through idempotent_leaf_v.
concept	OrderComparable
	Can A and B be compared in the injected order Ord, at compile time? Both must expose ::value of one carrier type T that is IsPosetal under Ord's resolved relation, and that relation must be default-constructible and constexpr-callable on those values. A registered-but-runtime-only or stateful order therefore fails this guard and the glb/lub collapse stays inactive (fail-closed) rather than hard-erroring.
concept	IsInvolutiveEndofunctor
	Involutive endofunctor concept — an endomap F : T → T with F² ≅ Id.
concept	IsHeytingLatticeCategory
	A bounded lattice category whose lattice exponentials are witnessed by :cartesian::IsExponential — row 6 of the lattice Form-chain (#698 Slice 6).
concept	IsBooleanLatticeCategory
	A Heyting lattice category whose complement is an involutive endofunctor satisfying the Boolean complement laws — row 7 of the lattice Form-chain (#698 Slice 7).
concept	IsSubobjectFamilyMember
	Compile-time meeting-point pins (#698 Slice 10) — three structurally distinct carriers at the same Form-chain rows.
concept	IsSubobjectLattice
	A type S is the carrier of a subobject lattice over S::Domain, with lattice structure induced pointwise from the classifier S::logic_species::Ω.
concept	IsBooleanSubobjectLattice
	The Form-chain ≤ relation on a subobject lattice is derivable from meet:
concept	IsLatticeLess
	The injected total order: a caller-supplied comparator with a static consteval less<X,Y>() returning a logic value in its lattice_less_logic (default Boole, i.e. bool). The reported logic must be a full IsOckhamAlgebra, so ::True (accessed by lattice_definitely_less) is guaranteed present. The reducer canonicalises only on a definitely-True result, so an Unknown (undecidable) comparison leaves the operands in authoring order. Total-ness is the caller's obligation (Jlt: asserted downstream), not checked here.
concept	Fires
	Whether a law fired: its result is not law_inactive.
concept	CombinesMeet
	The lattice-law reducer as the algebra of cata (:f_algebra, the one fold). A leaf reduces to itself. A Meet / Join assembles the induced laws over its two reduced operand values, most-collapsing first (bounded ▸ idempotent ▸ complement ▸ absorption ▸ distributivity ▸ glb/lub ▸ the injected leaf-combine), a law returning law_inactive ceding to the next; a rewrite (distributivity, the leaf-combine, De Morgan) is folded again. Less canonicalises the commutative residue. Every decision a law makes on the operand types is made inside decltype as well, so the normal form's type is reduce_t below and its value is this fold at run time: one law, two binding times.
concept	CombinesJoin
concept	IsMorphicTotal
	A Morphism whose Codomain is the Terminal Object (One).
concept	IsTerminalMorphism
	A morphism that maps into the Terminal Object (One).
concept	IsTerminalObject
	A type that plays the role of a terminal object — either the canonical global One (std::monostate, the unique terminal of the ambient category of sets) or an opt-in structural witness via the is_terminal_object_tag typedef.
concept	IsBoundaryProjection
	Projection witness from an owning/wrapper whole to a boundary object.
concept	IsProjectedTerminalObject
	Terminal-object witness through an optional projection policy.
concept	HasUniqueMorphismTo
	Asserts that there exists a unique morphism from T to U = One.
concept	HasUniqueMorphismFrom
	Asserts that there exists a unique (unreachable) morphism from Z = Zero to T.
concept	IsInitialObject
	A type that plays the role of an initial object — either the canonical global Zero (std::nullptr_t, the unique initial of the ambient category of sets) or an opt-in structural witness via the is_initial_object_tag typedef.
concept	IsBoundaryObject
	A type at a lattice / category bound: an initial object (⊥) or a terminal object (⊤).
concept	IsProjectedInitialObject
	Initial-object witness through an optional projection policy.
concept	TupleLike
concept	IsPairProjection
	Whether F is the projection \(\pi_K\) out of a pair: the recogniser the law readers (:cartesian, a product's defining form) and the hyperdoctrine (relational:graph) read. A genuine std::pair only: a pair-like carrier with more state is no product of its two members.
concept	IsProduct
	Categorification of std::pair<A, B> as the categorical product (A × B).
concept	IsArrowProduct
	An IsProduct whose projections are genuine MORPHISMS (arrows), not merely the structural callables IsProduct checks.
concept	IsProductProjection
	Functional-part projection witness from a product whole to one part.
concept	IsProjectedProduct
	Product witness through an optional whole-projection policy.
concept	IsArrowFromProduct
	Matches an Arrow whose Domain is a categorical Product (std::pair).
concept	IsProductParthood
	Bridge: a product P with parts A and B IS a mereological parthood in the projection-access reading.
concept	IsCartesian
	A small category equipped with a terminal object 1 and binary products × — a "cartesian category" in the textbook sense (Pierce, Basic Category Theory for Computer Scientists §1.4; Awodey).
concept	IsOckhamAlgebra
	The IsOckhamAlgebra Concept (The Algebraic Signature of Truth).
concept	HasLogicalOperators
	Pure syntactic shape: T supports the logical operators &&, ||, ! with closed results.
concept	IsΩ
	A truth-object: a type that can serve as the classifier Ω for a logical species.
concept	IsPst
	A truth-object that is a bounded chain: an IsΩ classifier whose values are totally ordered.
concept	LogicalMap
	A callable Pred that maps T -> Ω for some IsΩ Ω. Captures the notion of a predicate valued in an arbitrary logic species.
concept	IsClassifierAnswer
	T is a classifier answer: it names its species.
concept	LiftsTo
concept	HaveLogicJoin
concept	LiftableInto
	T can be lifted into To's answers: it already is one, or it is a classifier answer whose species' registered embedding into To accepts it and lands in To::Ω (a Truth<L> wrapper is not an L::Ω and is refused).
concept	IsDeMorganAlgebra
	The committed algebraic tower for the truth objects (#901).
concept	IsBoundedDeMorganChain
	A De Morgan algebra whose truth carrier Ω is totally ordered; by the chain-normality theorem this is automatically a Kleene lattice.
concept	IsBooleanLogic
	A bounded De Morgan chain whose reflection is a genuine complement (a∧¬a=⊥, a∨¬a=⊤); on a chain this forces the 2-element case 𝔹.
concept	IsTruthObject
	Ω may carry a relation's answer in the laws below: it has a top ⊤, the value a law asserts (reflexivity is rel(a, a) = ⊤). bool (top true) is the default; Ternary names its Ω::True, a value type with a species (Percentage, the bounded chains) finds it on the species. A statement of intent, not a certificate: the laws come before logic, so the truth objects are only certified downstream (:logic, IsΩ).
concept	IsReflexive
	Formal verification of the identity relation.
concept	IsTransitive
	Formal verification: (a ≤ b ∧ b ≤ c) ⇒ a ≤ c.
concept	IsAntisymmetric
	Formal verification: (a ≤ b ∧ b ≤ a) ⇒ a = b.
concept	IsConnex
	Formal verification: a ≤ b ∨ b ≤ a.
concept	SupInfOperand
	A carrier on which Sup / Inf (and max / min) are a genuine, usable value op: totally ordered (for <) and copy-constructible (the winner is returned by value). This is the CALL gate: Sup{}(1.0, 2.0) is a valid call that returns a value, so raw floats are not excluded here; only the lattice laws fail on them (see SupInfLattice).
concept	SupInfLattice
	A carrier on which max / min (and Sup / Inf) are honest lattice ops: usable (SupInfOperand) and carrying a certified order.
concept	IsWalkableChain
	Rel is a stateless relation on a discrete bounded chain T on which a law of Arity variables can be decided: a step (successor, by argument-dependent lookup, as for HasNNOStep), a least and a greatest value (the identities of Sup and Inf), the top reached from the bottom within chain_walk_budget, and nᴬʳⁱᵗʸ within law_evaluation_budget, all as constant expressions (what cannot be evaluated at compile time is simply not decided here, rather than an error).
concept	IsChainDecidedReflexive
	Each law, stated once for every relation on a walkable chain: the certificate the concept reads is the law over the whole chain, for ≤, ≥, ==, or any stateless relation, decided and never registered per operator. A carrier that answers through its own member keeps that answer; a law the compiler cannot evaluate is not decided here. Exported conditions, so a rule elsewhere can yield to these.
concept	IsChainDecidedAntisymmetric
concept	IsChainDecidedConnex
concept	IsChainDecidedTransitive
concept	IsPartRelation
	Verifies that a binary operator satisfies Leśniewski's mereological axioms.
concept	IsPartialOrder
	Named stage for the partial-order maturity level of parthood.
concept	IsTotalOrder
	Linear/total refinement of IsPartialOrder.
concept	IsPartOfRelation
	Minimal core part-whole relation yielding Omega.
concept	IsMereologicalJoinMagma
	Stage 0 for join-like algebra: closure only.
concept	IsMereologicalMeetMagma
	Stage 0 for meet-like algebra: closure only.
concept	IsMereologicalJoinSemigroup
	Stage 1 for join-like algebra: magma + associativity.
concept	IsMereologicalMeetSemigroup
	Stage 1 for meet-like algebra: magma + associativity.
concept	IsMereologicalMeetBand
	Non-commutative meet-like operation (associative + idempotent).
concept	IsMereologicalJoinBand
	Non-commutative join-like operation (associative + idempotent).
concept	IsAbsorptive
	Mutual absorption and internal idempotency for a pair of operations.
concept	IsMereologicalSkewLattice
	Non-commutative lattice-style operations (skew lattice fragment).
concept	IsMereologicalLatticeOperations
	Compatibility lattice alias over the skew core + absorption.
concept	IsMereologicalDistributiveLatticeOperations
	Mature distributive stage: lattice operations with mutual distribution.
concept	HasExtrema
	Structural requirement for Dedekind completeness witnesses.
concept	IsMereologicalCutCandidate
	Transitional bridge contract for the soft-to-hard structural cut.
concept	Parthood
	Skeletal part-whole contract at the concept level.
concept	IsMonad
concept	IsComonad
	The Unified Comonadic Proof: Co-Kleisli Action as Contextual Being.
concept	Presents
	S presents the object C: a value convertible to C (the default: the object is one value type), or a type the object names (C::presents).
concept	IsArrow
	A type that knows its own Domain (A) and Codomain (B), objects it maps between: called at the domain's representative, its result presents the codomain (morphism__Objects_And_Their_Presentations).
concept	IsSmallCategoryShape
	The structural prefix of IsSmallCategory (:small): a type naming an ::Arrow, a ::Species and an ::Id, the shape of a category, without its behavioural axioms (id_c, composition closure). IsSmallCategory itself cannot be named here, since :small imports :morphism. It tells a category apart from an object that merely exposes Domain / Codomain aliases: a Path<T>, a sequence \(\mathbb{N} \to T\), is an arrow and an object of Set, not a category (#525).
concept	IsEndomorphism
	Proposition: A Morphism where Domain ≡ Codomain (f: A -> A).
concept	IsIdentityArrow
concept	IsIsomorphism
	An Arrow f: A -> B with a guaranteed Inverse g: B -> A.
concept	IsConstantArrow
	An arrow known to be constant: every argument to one value.
concept	IsMonicArrow
	An arrow declared to be a monomorphism (ι: A ↣ B).
concept	IsEpicArrow
	An arrow declared to be an epimorphism (π: A ↠ B).
concept	IsMagmaHomomorphism
	A map on T declared to carry Op to Op2: \(f(a \odot b) = f(a) \circledast f(b)\).
concept	PreservesUnit
	A map on T carries the unit of Op to the unit of Op2, \(f(e) = e'\), computed at the one unit: the comparison is a template argument, so a map that is no constexpr function object is refused rather than an error. The unit half of a monoid homomorphism, and of a homomorphism of any signature whose operations have units.
concept	IsBijectiveArrow
	An arrow declared to be both a monomorphism (ι: A ↣ B) and an epimorphism (π: A ↠ B), i.e. an isomorphism of sets (A ≅ B).
concept	IsInjective
	Set-theoretic synonym for IsMonicArrow — an arrow is injective iff distinct inputs yield distinct outputs (f(x) == f(y) → x == y).
concept	IsSurjective
	Set-theoretic synonym for IsEpicArrow — an arrow is surjective iff every codomain element has a preimage (∀ b ∈ B ∃ a ∈ A. f(a) == b).
concept	IsBijective
	Set-theoretic synonym for IsBijectiveArrow — an arrow is bijective iff it is both injective and surjective, i.e. a set-theoretic isomorphism A ≅ B.
concept	HasArrowComposeOperators
	Two arrow types F, G compose via >> .
concept	IsDefaultMonadTag
concept	IsPreTransformation
	The raw family of components.
concept	IsTwoMorphism
	The bridge between two specific Functors.
concept	IsNaturalTransformation
	A family of components, one per object, whose square commutes at every arrow of the source: \(\alpha_Y \circ F(f) = G(f) \circ \alpha_X\) for each \(f : X \to Y\), read at an arbitrary arrow of the source category's one arrow type, not only at its identities, where every family passes.
concept	IsNNO
	Structural shape: (N, Z, S) is a Natural Numbers Object — Z is the zero element 1 → N, S is the successor map N → N.
concept	HasNNOStep
	A carrier with both NNO steps available: the shape a value-determined point collapse needs (succ(lo) == pred(hi)).
concept	IsNumericSpecies
concept	IsLipschitzBoundaryPolicy
	User-provided Lipschitz boundary policy over a numeric species.
concept	IsNumericHoleClassifier
	A characteristic morphism χ: T -> Ω_K3 for numeric support.
concept	IsPotential
	Structural isomorphism for "Maybe-like" species.
concept	IsPartialMagma
	A textbook-aligned partial binary algebra.
concept	IsPartialAssociative
	The Kleene Associativity Law.
concept	HasPartialIdentity
	Existence of a Neutral Element in a Partial Universe.
concept	IsPartialSupportClassifier
	Characteristic morphism χ: T -> Ω_K3 for partial support.
concept	IsPartialSemigroup
concept	IsPartialMonoid
concept	IsPartialLoop
	A Partial Monoid with local invertibility on support.
concept	IsPartialCommutativeSemigroup
concept	IsPartialGroup
concept	IsPartialAbelianGroup
concept	HasPeriod
	A sequence on finite chains with a declared period, read by period(f): \(f(k + p) = f(k)\) for every k. Periodicity is a sequence's, an arrow out of the counts, not an arrow's in general.
concept	HasUnitPeriod
	A sequence constant on its extent by its type: a constant arrow out of the counts, a sequence after one, and the cylinder's factors along the offsets (R2).
concept	HasCycleType
	A permutation of positions with a known cycle type.
concept	HasFactors
	A tensor whose count is a product of factors, as many as its type bounds: a shape, so an outer product of two is one too.
concept	IsPosetal
	A Category where morphisms are governed by a specific Logic Species (Ω).
concept	IsTotallyOrderedPosetal
	Posetal refinement where the underlying order is total/linear.
concept	IsOrderMeetSemilattice
	Order-theoretic meet-semilattice as a commutative refinement.
concept	IsCertifiedOrderMeetSemilattice
	Trait-certified meet-semilattice (associative + idempotent + commutative).
concept	IsOrderJoinSemilattice
	Order-theoretic join-semilattice as a commutative refinement.
concept	IsCertifiedOrderJoinSemilattice
	Trait-certified join-semilattice (associative + idempotent + commutative).
concept	IsOrderLatticeOperations
	Order-theoretic lattice operations as commutative + absorptive refinement over upstream mereological lattice operations.
concept	IsCertifiedOrderLatticeOperations
	Trait-certified lattice operations (commutative semilattices + absorption).
concept	IsOrderDistributiveLatticeOperations
	Distributive lattice refinement over IsOrderLatticeOperations.
concept	IsCertifiedOrderDistributiveLatticeOperations
	Trait-certified distributive lattice refinement.
concept	IsPathProjection
	Projection contract used by check_path to map objects into an orderable relation carrier.
concept	IsMonotone
	An arrow F declared to be order-preserving with respect to the ambient order relation Op.
concept	IsAntiMonotone
	An arrow F declared to be order-reversing with respect to the ambient order relation Op.
concept	IsVariant
	An arrow with a definite variance: order-preserving (IsMonotone) or order-reversing (IsAntiMonotone). The leg-shape of a Galois connection, whose adjoints are always one or the other. Mirrors :limit::IsBoundaryObject's "X @c || @c dual" disjunction shape.
concept	IsOrderIsomorphism
	An arrow that is both an order-preserving map and a bijection.
concept	IsOrderAntiIsomorphism
	An arrow that is both an order-reversing map and a bijection.
concept	HasDomain
	A type that names its domain: Dom<F> is formed. The guard under which IsInvolution<F> may be asked at all.
concept	IsPullback
	The apex of a pullback square over the cospan f: X ⟶ Z, g: Y ⟶ Z: a subobject carrying the two projection legs π₁ ⟶ X, π₂ ⟶ Y.
concept	IsEqualizer
	The kernel of a parallel pair (f, g: A ⟶ B).
concept	IsKernelPair
	The pullback of an arrow F against itself — the equivalence relation "have the same F-image" on Dom<F>.
concept	IsPushout
	The categorical dual of IsPullback: the apex of a pushout square over the span f: Z ⟶ X, g: Z ⟶ Y, carrying the two coprojection colegs ι1: X ⟶ P, ι2: Y ⟶ P.
concept	IsParallelPair
	F and G are a parallel pair of arrows — shared Dom and shared Cod.
concept	IsLocallySmallCategory
	Value-level locally-small witness: the Hom-collection of Cat is a set in the metatheory.
concept	IsSmallCategory
	A point-free, morphism-only reification of a Category.
concept	IsSpecies
	Formal verification that a type has been registered in the Atlas.
concept	HasTotalProduct
	Whether T's product is defined on all of T: a word narrower than int multiplies after promotion to int, and the largest product must fit it. unsigned char's does (255 · 255); unsigned short's does not (65535 · 65535 overflows int, undefined as -INT_MIN is), so it is refused as int is. Decided by the compiler: undefined behaviour is no constant expression. Unsigned words only: there the product grows with its factors, so the largest is the one that may overflow, and numeric_limits names it (a type without limits has max() == T{}, and the probe would check only 0 · 0).
concept	IsTransfinite
concept	IsFinite
concept	IsAssociative
concept	IsCommutative
concept	IsDistributive
	The "Glue" of the Ring: a * (b + c) = a*b + a*c.
concept	IsIdempotent
concept	IsThinCategory
	A category in which every hom-set has at most one morphism.
concept	IsClassifierConstant
concept	IsPredicate
	The Predicate Morphism: the DSL's membership test, i.e. the characteristic arrow \(\chi_A : A \to \Omega\).
concept	IsCharacteristic
	Categorical alias for a Predicate mapping to Ω: the characteristic arrow \(\chi_A : A \to \Omega\) that classifies a subobject (a set).
concept	IsDecidableCharacteristic
	The Boolean refinement of IsCharacteristic: a membership test valued in the dominance Σ, i.e. \(\chi_A : A \to \Sigma\) with \(\Sigma = \Omega\)-decided \(= @c bool\).
concept	IsDominanceInclusion
	The Rosolini inclusion arrow \(\iota : \Sigma \hookrightarrow \Omega\): a map between truth-objects out of the decided fragment.
concept	IsSieve
	Signature-level witness for a sieve of arrows into an object.
concept	IsGrothendieckTopology
	Signature-level witness for Grothendieck coverage rules over sieves.
concept	IsBundleProjection
	A projection morphism π : E -> B for a bundle candidate.
concept	IsFiberBundle
	Signature-level witness for a fiber bundle over a base species.
concept	IsSubobject
	The categorical witness of a monomorphism ι: S ↣ A — a characteristic morphism χ: A → Ω together with its inclusion.
concept	IsLSet
	An L-set: a subobject of a carrier with \(\chi : X \to L\) into a named bounded chain \(L\) (Codomain = L::Ω). The carrier is asked for copies (std::semiregular), not for a decidable ==: the equality of sets is the Rice cycle (#970), not a trait of the carrier, so the relations of a hom-set are a carrier too (𝔸<RelExpr>, #1045). An ETCS set asks decidable equality itself (IsSet, whose classifier construction needs it), as IsArrow asks an archetype of its domain rather than a value type (archetype_t). Pst is asked of the species (an Ockham algebra whose Ω is totally ordered), not of the bare Ω, so a Chain<int> set (Ω = int) qualifies while a bare int never does. The chain is the registered total order (IsTotalOrder: reflexive, transitive, antisymmetric, comparable), not the syntactic std::totally_ordered, so an Ω without certified order laws (a raw float, whose NaN breaks reflexivity) is refused honestly.
concept	IsFiniteChain
	A carrier that is a finite chain by its representation: totally ordered and either a machine integer or an enumeration (both finite by construction). bool, Ternary, int qualify; Cardinality and the dense carriers do not.
concept	IsFiniteLSet
	The Pst fragment: an L-set whose carrier is a finite chain (IsFiniteChain), so χ is a finite table and normalisation by evaluation is complete. Products of finite chains follow with IsProduct.
concept	IsQuotient
	The categorical witness of a regular epimorphism q: A ↠ Q — the dual of IsSubobject.
concept	IsPredicatePair
	Two predicates over one object, answering in one species: the operand sort of the predicate combinators below, which close on IsPredicate. Named so the set grammar's && / || (sets) can take exactly the other pairs of terms (relational fragments, mixed terms, the structured collapse) without overlapping these.
concept	IsPeriodic
	Taxonomic Decorator: Certifies that an operation is circular (wraps). This is the "Safety Certificate" for machine totality.
concept	IsSaturating
	Taxonomic Decorator: certifies that an operation reaches out-of-range values via a saturating escalation (e.g.\ \(\pm \aleph_0\)) rather than wrapping or being undefined.
concept	IsClosedUnder
	(S, Op) is closed under a binary operation: Op{}(s_1, s_2) returns a value of type S for any S-typed operands. The textbook closure axiom expressed structurally — no opt-in trait needed because closure is deducible from the operator's signature.
concept	IsClosedUnderUnary
	Unary closure variant: Op{}(s) returns S for any S-typed operand. Cardinality has no IsClosedUnderUnary for std::negate<> (negation of a positive natural would need to land outside ℕ); that's the structural witness that -Cardinality is closure-forcing rather than closed.
concept	IsClosedUnderEither
	(T, Op) is closed under Op, where Op may be either binary or unary. Distinct from IsClosedUnder (binary) so call sites that need a specific arity stay typo-proof.
concept	IsConstructed
	D declares a construction: a base and the shape of its ×.
concept	CommutativeRingLaws
	The base's laws that a multiplied-out × rests on.
concept	IsTotal
	The Master Safety Certificate for Level 0: is_total, as a concept.
concept	IsTotalArrow
	A Morphism whose domain species admits no undefined (hazard) values.
concept	IsPointed
	A type T has a chosen identity element under operation Op.
concept	IsMagma
	T × T → T (The Base Total Species).
concept	IsUnitalMagma
	A Magma with a global Identity (0 or 1).
concept	IsInvertible
	A pointed (T, Op) where every element has an Op-inverse.
concept	IsLoop
	A UnitalMagma with Inverses (-x).
concept	IsSemigroup
	An Associative Magma.
concept	IsCommutativeSemigroup
	An Associative Magma where the operation is also commutative.
concept	IsMonoid
	A Semigroup with a two-sided Identity element.
concept	IsMonoidHomomorphism
	A map between two monoids, (T, Op) and its image under Op2, that carries the operation, declared on every pair, and the unit to the unit, computed (:morphism's PreservesUnit).
concept	IsCommutativeMonoid
	A Monoid where the operation is commutative.
concept	IsGroup
	A Monoid with two-sided Inverses (The Perfect Symmetry).
concept	IsAbelianGroup
	A Commutative Group.
concept	IsCyclicGroup
	A cyclic abelian group: the honest concept name for \(\mathbb{Z}/n\mathbb{Z}\) carriers and their machine-backed cousins.
concept	IsRig
	A Semiring without Negatives (Addition is a Monoid).
concept	IsRng
	A Ring without Identity (Multiplication is a Semigroup).
concept	IsSemiring
	Alias for IsRig: a general multi-operation species.
concept	IsRing
	The Perfect Species (Rig ∩ Rng).
concept	IsCommutativeRing
	A Ring whose multiplication is commutative.
concept	IsField
	The axiomatic field witness — a commutative ring whose multiplicative structure is an abelian group (zero excluded, by convention on is_invertible_v).
concept	IsJoinSemilattice
	A Semilattice used as the "join" (least upper bound / ∨) half of a Lattice. In bool this is logical_or; in int it is max.
concept	IsMeetSemilattice
	A Semilattice used as the "meet" (greatest lower bound / ∧) half of a Lattice. In bool this is logical_and; in int it is min.
concept	IsLattice
	compatibility alias for order-lattice refinement.
concept	IsDistributiveLattice
	compatibility alias for distributive order lattices.
concept	IsBoundedLattice
	A IsLattice whose join and meet each carry an identity: the bottom \(\bot\) (unit<T>(Join{})) and top \(\top\) (unit<T>(Meet{})).
concept	IsBooleanAlgebra
	The top of the Boolean-algebra variety Alg(∨,∧,¬,⊥,⊤): a complemented distributive bounded lattice — the ∨/∧/¬ analogue of IsField topping the (signature-expanded) ring variety.
concept	HasClosureForcingShape
	Structural shape: Op{} sends (A, A) → B (binary) or A → B (unary) with A ≠ B. Pure deducible clause of IsClosureForcing. The universal-property side — that B is the smallest carrier closing Op over A — is carried by the is_closure_forcing_v opt-in trait below.
concept	IsClosureForcing
	Composite: structural shape + opt-in canonicality. The full witness that Op is the closure-forcing operator A → B (or A × A → B), with B the canonical recipient.
concept	IsCopies
	A range of n copies of one value, Bird's replicate n x, whose fold under a monoid is the power \(x^n\); n and the value known without walking it: copies_count(r) and copies_value(r), which each model supplies, declared above so that ordinary lookup finds them for models outside this namespace, the standard's among them.
concept	FractionBacking
	An integer backing over which fraction arithmetic obeys ℚ's laws under Op: it does not wrap, so a wrapped intermediate cross-product cannot silently break a law. Either it is exact, or it saturates and offers the is_finite hook (RejectsNonFinite) through which ℚ's tripwire rejects the saturated value instead of clamping.

Typedefs
template<typename F>
using	dedekind::category::free_algebra_base_t = typename free_algebra_base<F>::type
	Convenience alias for free_algebra_base<F>::type.
template<typename Q>
using	dedekind::category::quotient_algebra_base_t = typename quotient_algebra_base<Q>::type
	Convenience alias for quotient_algebra_base<Q>::type.
template<typename Q>
using	dedekind::category::quotient_congruence_t = typename quotient_congruence<Q>::type
	Convenience alias for quotient_congruence<Q>::type (the congruence relation R).
template<typename Q>
using	dedekind::category::quotient_congruence_carrier_t = typename quotient_congruence<Q>::carrier
	Convenience alias for quotient_congruence<Q>::carrier (the carrier V that the congruence lives on).
template<typename Q>
using	dedekind::category::product_algebra_base_t = typename product_algebra_base<Q>::type
	Convenience alias for product_algebra_base<Q>::type.
template<typename S>
using	dedekind::category::subalgebra_base_t = typename subalgebra_base<S>::type
	Convenience alias for subalgebra_base<S>::type.
using	ZeroZ = decltype(zero<int, int, std::plus<int>>())
template<typename A, typename B>
using	dedekind::category::Exponential
	The Exponential Object B^A (Type Alias).
template<std::size_t K, typename A, typename B>
using	dedekind::category::ι = Injection<K, A, B>
	The injection by its textbook name, \(\iota_K\) (Pierce), as the projection is Π.
template<typename A>
using	dedekind::category::CanonicalSetCCC = Set<A>
	Explicit alias for the canonical ETCS CCC witness over ambient A.
template<IsArrow F, IsArrow G>
using	dedekind::category::ProductArrow
	f × g = ⟨f ∘ π₁, g ∘ π₂⟩ : A × C → B × D.
template<typename A, typename B>
using	dedekind::category::Flip = Pairing<Π<2, std::pair<A, B>>, Π<1, std::pair<A, B>>>
	flip, the symmetry of the cartesian product, \(\sigma_{A,B} : A \times B \to B \times A\): the pairing of the projections the other way round, \(\langle \pi_2, \pi_1 \rangle\). On a square an involution, so an isomorphism, its own inverse; natural in both factors, \(\sigma \circ (f \times g) = (g \times f) \circ \sigma\), the braiding of the cartesian monoidal structure, symmetric. A word of two letters flipped is the word reversed.
template<IsArrow F, IsArrow G>
using	dedekind::category::SumArrow
	f + g = [ι₁ ∘ f, ι₂ ∘ g] : A + C → B + D.
template<std::regular X, std::semiregular Step>
using	dedekind::category::chain_t = unfold_view<X, StepCoalgebra<X, Step>>
	The chain of x under a partial step: what the step reaches from x, the step of it, then the step of that, until the step has nothing (Dedekind's chain of the step of x, [4]). With Prior it is \(n - 1, \ldots, 0\), the n elements below n, n itself excluded: the Jlt paper's Figure 2, after Lambek.
template<IsCountWord N, IsFiniteChainSequence F>
using	dedekind::category::FiniteChainSequence
	The finite sequence as a value, n >> chain<N>() >> f: the chain of n read by f, never built. A fold over it is the list as its fold, the Church encoding (#1133).
using	dedekind::category::ascending = std::less<>
	The orders a query is sorted by, the standard's comparisons named as SQL's ASC and DESC: the defaults of order_by's parameter, which takes any comparison with sufficient structure, a total preorder on the rank's values.
using	dedekind::category::descending = std::greater<>
template<typename X, typename Y = X>
using	dedekind::category::Constant = ConstantMorphism<X, Y>
	The constant arrow by its short name, the paper's spelling.
using	IntCat = DiscreteCategory<int>
template<typename S>
using	dedekind::category::discrete_lift_t = DiscreteCategory<S>
template<typename T>
using	dedekind::category::Maybe = std::optional<T>
	The Maybe endofunctor T, implemented via std::optional.
template<std::semiregular Op>
using	dedekind::category::Opposite = typename detail_involution::opposite<Op>::type
	The opposite operation, \(a \cdot^{op} b = b \cdot a\), the product of the opposite monoid \(M^{op}\) (Mac Lane, Categories for the Working Mathematician, II.2), an involution on operations: Opposite<Opposite<Op>> is Op, the same type. A left action of \(M\) is a right action of \(M^{op}\), so a left action folded along a walk acts by the product in \(M^{op}\). The laws read backwards are the laws: associativity, the unit, commutativity and idempotence carry over, declared once here, and totality in :total.
template<typename MA>
using	dedekind::category::functor_of_t = typename functor_of<std::remove_cvref_t<MA>>::type
template<typename P>
using	dedekind::category::predicate_logic_t = typename predicate_logic<P>::type
template<typename T, typename Ord>
using	dedekind::category::resolved_order_t
	The comparator Ord resolves to for a carrier T: std::less_equal<T> for canonical_order, otherwise Ord itself.
template<typename X>
using	dedekind::category::carrier_of_t = typename carrier_of<X>::type
template<typename X>
using	dedekind::category::codomain_of_t = typename codomain_of<X>::type
template<typename Less>
using	dedekind::category::lattice_less_logic_t = typename lattice_less_logic<Less>::type
template<typename Term, typename Less, typename Ord = canonical_order, typename Combine = no_leaf_combine>
using	dedekind::category::reduce_t
	The normal form of Term under Reduce<Less, Ord, Combine>: the type the fold produces, read without running it.
using	dedekind::category::One = std::monostate
	The Terminal Object (1): the unique sink of every morphism.
using	dedekind::category::Zero = std::nullptr_t
	The Initial Object (0): the unique source of every morphism.
template<std::size_t K>
using	dedekind::category::At = std::integral_constant<std::size_t, K>
	The projections π_k out of a product, one family: π_1, π_2 (Pierce, Basic Category Theory for Computer Scientists §1.4), π_3 and π_<k> for a flat n-ary product, and π for the one-fold product A¹ ≅ A, whose projection is the identity.
template<std::size_t K, typename P>
using	dedekind::category::Π = typename detail_limit::projection_arrow<K, P>::type
	π_k read at the product P, as a MORPHISM (Domain = P, Codomain the k-th part): the building block of IsArrowProduct. Π<0, P> is Identity
using	dedekind::category::TerminalCategory = DiscreteCategory<One>
using	dedekind::category::InitialCategory = DiscreteCategory<Zero>
template<typename Pred, typename T>
using	dedekind::category::OmegaOf
	Extract the Ω-type of a LogicalMap.
template<typename T>
using	dedekind::category::classifier_logic_t
template<typename L1, typename L2>
using	dedekind::category::join_logic_t = typename join_logic<L1, L2>::type
template<typename L1, typename L2>
using	dedekind::category::meet_logic_t = typename meet_logic<L1, L2>::type
template<typename T>
using	dedekind::category::LogicOf = typename LogicTraits<T>::type
	Shorthand for the Logic Species of a type.
template<typename T>
using	dedekind::category::Omega = typename LogicOf<T>::Ω
	Shorthand for the Subobject Classifier (Omega) of a species.
template<typename C>
using	dedekind::category::archetype_t = typename archetype<C>::type
template<IsArrow F>
using	dedekind::category::Dom = typename std::remove_cvref_t<F>::Domain
	Shorthand to look up the Domain of an Arrow type F.
template<IsArrow F>
using	dedekind::category::Cod = typename std::remove_cvref_t<F>::Codomain
	Shorthand to look up the Codomain of an Arrow type F.
template<typename F>
using	domain_t
template<typename F>
using	codomain_t
using	IntToBool = Morphism<int, bool, std::function<bool(int)>>
using	Negate = std::negate<int>
using	TaggedNegate = Morphism<int, int, Negate>
template<typename C>
using	dedekind::category::disc_self_endofunctor_t = identity_functor<C>
	Discrete-restriction representative of the textbook Disc / U functor: the identity endofunctor on a discrete category C.
template<typename C>
using	dedekind::category::disc_self_unit_t = identity_transformation<disc_self_endofunctor_t<C>>
	Discrete-restriction representative of the textbook unit η / counit ε of the Disc ⊣ U adjunction: the identity natural transformation on disc_self_endofunctor_t<C>.
using	dedekind::category::Alphabet
	The byte alphabet's type, as abc builds it: the letters under their predicate, a filtered chain of the bytes. Listing 5's Alphabet bases. (#1141: the first carrier of the alphabet concept.).
using	dedekind::category::Words = Powers<std::byte, Letters, std::size_t>
	The words over the byte alphabet, by length: words(Σ)'s type, Listing 5's Words oligos.
template<std::size_t Bits>
using	dedekind::category::narrowest_count_word
	The narrowest count word on the ladder holding Bits: the stage of the filtered colimit a count of that many bits factors through. The rungs are the words whose products stay in them (IsCountWord): 32 and 64 bits; past the top there is none, and the count stays in its factors, compared and multiplied exactly there.
template<std::size_t W>
using	dedekind::category::BitWord = typename detail_periodic::bit_word<W>::type
	The bit word of width W, chosen by the width: the machine word for 8, 16, 32 and 64 bits, std::bitset otherwise.
using	DefaultJoin = Sup
using	DefaultMeet = Inf
using	dedekind::category::ArrowLaws = Profile<ArrowLaw, every_arrow_law.size()>
	The profile of a function.
using	Runs4 = RunList<std::size_t, 4>
template<typename A, typename L = Boole>
using	dedekind::category::PowerObject = Exponential<A, typename L::Ω>
	Power Object Alias.
using	XOR = std::bit_xor<unsigned int>
using	AND = std::bit_and<unsigned int>
using	C1 = dedekind::sets::ExtensionalCardinal<>
using	Z1 = dedekind::sets::SignedExtensionalCardinal<>
using	SC = dedekind::sets::SignedCardinality
using	Card = dedekind::sets::Cardinality
using	SignedCardinality
	Signed counterpart of Cardinality with ±ℵ_0 escalation; the library's bona-fide proxy for \(\mathbb{Z}\) modulo physical limits.
template<typename A, typename L, typename C, typename P>
using	Endo

Enumerations
enum class	dedekind::category::Holes : bool { break_match , skip }
	What a byte outside the alphabet does to a match: break it, the matcher back at its start (no word of the set holds the byte), or be skipped, the matcher as it was. Never a match itself.
enum class	dedekind::category::Ternary : std::int8_t { False = -1 , Unknown = 0 , True = 1 }
	A three-valued propositional logic for handling partial information. More...
enum class	dedekind::category::CardinalityTag { Finite , Countable , Continuum }
enum class	dedekind::category::ArrowLaw : unsigned {   Injective , Surjective , Monotone , Antitone ,   Involutive , Constant }
enum class	dedekind::category::ArrowNode {   Compose , Product , Sum , Pairing ,   Copairing }
	The formers of arrows: g ∘ f, f × g, f + g, ⟨f, g⟩, [f, g].

Functions
template<typename S, typename Tag> requires requires(S s) { { -s } -> std::same_as<S>; }
constexpr dedekind::algebra::OneDimensionalVector< S, Tag >	inverse (dedekind::algebra::OneDimensionalVector< S, Tag > v, std::plus< dedekind::algebra::OneDimensionalVector< S, Tag > >)
template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>> requires IsMonoid<T, Op> && IsCopies<R> && HasCountingAction<T, Op>
constexpr T	dedekind::category::concat (R r, Op op={})
	concat on n copies of one value where the counts act in one step: \(x^n\) by the counting action, \(n \cdot x\) over a semimodule, x under an idempotent operation. The same signature as the binary method of :total and a stronger constraint, so resolution prefers it.
template<std::ranges::input_range R, std::semiregular M, typename H> requires std::invocable<const H&, M, std::ranges::range_value_t<R>>
constexpr M	dedekind::category::fold (R r, M v, H h)
	The fold along the walk: the standard's fold_left.
template<std::ranges::input_range R, std::semiregular M, typename H> requires IsCopies<R> && IsRightAction<H, M, std::ranges::range_value_t<R>>
constexpr M	dedekind::category::fold (R r, M v, H h)
	The fold under a monoid action of a sequence whose product has a fast form: v acted on once, by the product in the walk's order. The action law \(h(h(v, a), b) = h(v, a \cdot b)\) licenses this on any sequence, but it pays only where the product is cheaper than the actions one by one: elsewhere a product each costs more than an action each, a matrix by a matrix against a vector by a matrix. The fast form today is copies, whose product concat computes by squaring; periodic sequences are the natural next one. The same signature as the plain fold and a stronger constraint, so resolution prefers it.
template<typename Left, typename Right, typename Unit, typename Counit> requires IsAdjunction<std::remove_cvref_t<Left>, std::remove_cvref_t<Right>, std::remove_cvref_t<Unit>, std::remove_cvref_t<Counit>>
constexpr auto	dedekind::category::make_adjunction (Left left, Right right, Unit unit, Counit counit)
	Factory for adjunction witnesses.
constexpr Columns	dedekind::category::columns_of (const Letters &on)
template<std::size_t Sigma, std::size_t P, std::size_t K, std::size_t Q, IsCountWord N, std::size_t KL>
constexpr Maybe< Automaton< Sigma, Q > >	dedekind::category::automaton (const RunList< N, KL > &sites, std::type_identity_t< N > length)
	The matcher specialised to a set of words of one length: the minimal automaton of \(\Sigma^* L\), canonical.
template<std::size_t KL, std::size_t Sigma, std::size_t P, HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
constexpr Maybe< RunList< N, KL > >	dedekind::category::run_list (const Symmetric< Power< C, F, N >, S, T > &sites)
	A section's words as a run list over their codes: each word read as its letters' ranks in base \(\sigma\), the first the most significant, so the chain \([0, \sigma^n)\) in the dictionary order. Every code is read back as its word and tested by the section's own membership: \(\sigma^n\) tests, the set enumerated once.
template<std::size_t KL, std::size_t Sigma, std::size_t P, IsCountWord N> requires (Sigma >= 4 && Sigma % 2 == 0)
constexpr Maybe< RunList< N, KL > >	dedekind::category::run_list (const Symmetric< Power< std::byte, Letters, N >, Reverse, Reflection > &sites)
	The words a reflection then the reversal fixes, listed by the law: a word is fixed by its half-site, so the \(\sigma^{n/2}\) halves are visited in order and no word is tested, where the general overload tests all \(\sigma^n\). This is what lets a small panel's table be built at compile time. With an even alphabet the reflection fixes no letter, and from four letters no two codes are adjacent, so each is a run of its own. An odd length, or a reflection other than the alphabet's own, is left to the general overload.
template<std::size_t Sigma = 4, std::size_t P = 8, std::size_t K = 32, std::size_t Q = 320, std::size_t KL = 256, HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
constexpr Maybe< Automaton< Sigma, Q > >	dedekind::category::automaton (const Symmetric< Power< C, F, N >, S, T > &sites)
	The matcher specialised to a section: its words as a run list, then the plan. The capacities default to a menu's largest, four letters, words of length 8, pending sets of 32 steps and 320 states, the one pynzli offers too, so automaton(sites) reads alike in both languages; a tighter bound is named where the plan is a constant.
constexpr Prefix	dedekind::category::prefix (std::string_view word)
template<typename P, typename S, IsArrow T>
constexpr Prefixed< P, S, T >	dedekind::category::operator& (const Symmetric< P, S, T > &s, const Prefix &p)
template<std::size_t KL, std::size_t Sigma, std::size_t P, IsCountWord N> requires (Sigma >= 4 && Sigma % 2 == 0)
constexpr Maybe< RunList< N, KL > >	dedekind::category::run_list (const Prefixed< Power< std::byte, Letters, N >, Reverse, Reflection > &sites)
	The words of a section beginning with a prefix, by the law: no word tested, only the half-sites the prefix allows visited.
template<std::size_t Sigma = 4, std::size_t P = 8, std::size_t K = 32, std::size_t Q = 320, std::size_t KL = 256, IsCountWord N>
constexpr Maybe< Automaton< Sigma, Q > >	dedekind::category::automaton (const Prefixed< Power< std::byte, Letters, N >, Reverse, Reflection > &sites)
	The matcher of the words of a section beginning with a prefix. The same builder on a subset of the same words; capacities as for a section.
template<std::size_t Sigma, std::size_t Q>
constexpr std::size_t	dedekind::category::states (const Automaton< Sigma, Q > &plan)
template<std::size_t Sigma, std::size_t Q>
constexpr Matches< Sigma, Q >	dedekind::category::matches (const Automaton< Sigma, Q > &plan, Holes holes=Holes::break_match)
template<std::size_t Sigma, std::size_t Q>
constexpr Maybe< Matches< Sigma, Q > >	dedekind::category::matches (const Maybe< Automaton< Sigma, Q > > &plan, Holes holes=Holes::break_match)
	matches on a plan that may not be, automaton(section)'s Maybe: the stage, or nothing, by Maybe's action. The uncertainty of the capacity travels through the query to its count, so dna >> matches(automaton(s)) >> counting is a Maybe count with no case on it in between.
template<std::ranges::view V, std::size_t Sigma, std::size_t Q> requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>
constexpr auto	dedekind::category::operator>> (V letters, const Maybe< Matches< Sigma, Q > > &m)
template<std::ranges::view V, std::size_t Sigma, std::size_t Q> requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>
constexpr auto	dedekind::category::operator>> (V letters, const Matches< Sigma, Q > &m)
template<std::ranges::view V, std::size_t Sigma, std::size_t Q> requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>
constexpr auto	dedekind::category::scan (const Automaton< Sigma, Q > &plan, V letters)
	scan(plan, s): the history comonad's extension with its kernel factored through finitely many states, so that it keeps one state, not the history (Myhill and Nerode). It is matches(plan), its holes breaking a match.
template<std::ranges::view V, std::size_t Sigma, std::size_t Q> requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>
constexpr auto	dedekind::category::operator>> (V letters, const Automaton< Sigma, Q > &plan)
	s >> scanner: a plan read as the stage it is.
template<detail_comprehension::IsForeignView R, typename P, typename S, IsArrow T>
constexpr auto	dedekind::category::operator>> (R r, const Prefixed< P, S, T > &s)
	Where a prefixed section's words occur in a range of the caller's: the windows of its length it holds, as r >> s for a section.
template<typename F>
constexpr auto	dedekind::category::exponential (F f)
	Internal Hom Factory (Exponential).
template<typename A, typename F>
constexpr auto	dedekind::category::exponential (F f)
template<typename A, typename B, typename F>
constexpr auto	dedekind::category::exponential (F f)
template<IsArrowFromProduct F>
constexpr auto	dedekind::category::curry (F f)
	Currying: (X × A → B) ⟹ (X → B^A).
template<IsArrow F> requires IsArrow<Cod<F>>
constexpr auto	dedekind::category::uncurry (F f)
	Uncurrying: (X → B^A) ⟹ (X × A → B).
template<typename T, typename Op> requires (!IsArrow<Op>) && std::regular_invocable<const Op&, const T&, const T&>
constexpr Curried< T, Op >	dedekind::category::curry (Op op)
	The operation curried.
template<typename T, typename Op>
constexpr Uncurried< T, Op >	dedekind::category::uncurry (Curried< T, Op > c)
	The inverse of curry<T>.
template<typename A, typename B>
constexpr auto	dedekind::category::ι_1 (A value)
	Left injection ι₁: A → A + B.
template<typename A, typename B>
constexpr auto	dedekind::category::ι_2 (B value)
	Right injection ι₂: B → A + B.
template<typename T, typename Op>
constexpr Sections< T, Op >	dedekind::category::operator>> (const Sections< T, Op > &f, const Sections< T, Op > &g)
	f >> g on sections: the identity absorbed, two sections one, \((b \mapsto a \cdot b) ; (c \mapsto a' \cdot c) = (b \mapsto (a' \cdot a) \cdot b)\) by associativity, which Sections asks of the operation, with no state, so that both sections are of one operation.
template<typename T, typename Op>
constexpr Arrows< T, Op >	dedekind::category::operator>> (const Morphisms< T, Op > &f, const Morphisms< T, Op > &g)
	f >> g on morphisms, into Arrows: the identity absorbed, two sections one, two pointers a composite.
template<typename T, typename Op>
constexpr Arrows< T, Op >	dedekind::category::operator>> (const Arrows< T, Op > &f, const Arrows< T, Op > &g)
	f >> g on arrows, restricted to one level: two morphisms compose as above, the identity is absorbed, and a composite of composites is refused.
template<IsArrow F, IsArrow G> requires std::same_as<Cod<F>, Cod<G>>
constexpr auto	dedekind::category::mediate_coproduct (F f, G g)
	Mediating morphism for Coproducts: [f, g]: (A + B) -> X.
template<typename F, typename A> requires IsExponential<F, A, std::invoke_result_t<F, A>>
constexpr auto	dedekind::category::eval (F f, A a)
	The canonical evaluation morphism for the CCC: (B^A × A) → B.
template<typename From, typename To>
constexpr To	dedekind::category::lift (From const &)
	Canonical lift From → To across the carrier lattice — discoverability alias dispatching to the registered bespoke arrow for (From, To).
template<typename A, typename B = A>
constexpr Flip< A, B >	dedekind::category::flip ()
template<IsArrow F, IsArrow G>
constexpr ProductArrow< F, G >	dedekind::category::product_arrow (const F &f, const G &g)
	f × g, built.
template<IsArrow F, IsArrow G>
constexpr SumArrow< F, G >	dedekind::category::sum_arrow (const F &f, const G &g)
	f + g, built.
template<IsArrow F, IsArrow G>
constexpr ProductArrow< F, G >	dedekind::category::operator* (const F &f, const G &g)
	f * g = f × g and f + g = f + g on arrows: the product and coproduct functors' action on arrows, as category theory writes them (Mac Lane, Awodey). A more specific overload keeps its own meaning: a set's * (its cartesian product, the classifier read through ∧), an additive hom-set's + (geometry's function spaces: the sum of parallel arrows, as in an additive category); the term grammar's * + act on terms, which are not arrows.
template<IsArrow F, IsArrow G>
constexpr SumArrow< F, G >	dedekind::category::operator+ (const F &f, const G &g)
template<typename F, typename G>
constexpr auto	dedekind::category::legs (const Pairing< F, G > &a)
	The legs of a former, for cata.
template<typename F, typename G>
constexpr auto	dedekind::category::legs (const Copairing< F, G > &a)
template<std::regular S, std::semiregular Coalg>
constexpr unfold_view< S, Coalg >	dedekind::category::unfold (S seed, Coalg step)
	The unfold of seed by step.
template<std::regular X, std::semiregular Step>
constexpr chain_t< X, Step >	dedekind::category::chain (X x, Step step)
template<IsArrow End, IsArrow Step>
constexpr Until< End, Step >	dedekind::category::until (End end, Step step)
	The guard.
template<std::regular S, std::semiregular Coalg>
constexpr Unfold< S, Coalg >	dedekind::category::unfold (Coalg c)
	The anamorphism, as an arrow.
template<IsArrow Step> requires std::regular<Dom<Step>> && std::semiregular<Step>
constexpr Unfold< Dom< Step >, StepCoalgebra< Dom< Step >, Step > >	dedekind::category::chain (Step step)
	The chain of a partial step, as an arrow from the seeds: x >> chain(out) is chain(x, out).
template<std::regular S, std::semiregular Coalg, IsArrow F> requires std::same_as<Dom<F>, typename unfold_view<S, Coalg>::element_type>
constexpr unfold_view< S, Mapped< S, Coalg, F > >	dedekind::category::operator>> (const unfold_view< S, Coalg > &v, F f)
	ns >> f: f mapped over the walk, as a walk.
template<std::regular S, std::semiregular Coalg, IsArrow F> requires std::same_as<Dom<F>, typename unfold_view<S, Coalg>::element_type> && IsIdentityArrow<F>
constexpr unfold_view< S, Coalg >	dedekind::category::operator>> (const unfold_view< S, Coalg > &v, F)
	The functor's unit law, decided at the type: map id is the walk itself.
template<HasNNOStep C> requires std::totally_ordered<C>
constexpr Slice< C >	dedekind::category::slice (C lo, C hi)
template<HasNNOStep C, IsArrow F> requires std::totally_ordered<C> && std::same_as<Dom<F>, C>
constexpr unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > >	dedekind::category::operator>> (const Slice< C > &s, F f)
	An arrow along a restricted chain: f(lo), ..., f(hi - 1), a range never built.
template<HasNNOStep N> requires std::regular<N>
constexpr auto	dedekind::category::chain ()
	The default chain of a carrier with the NNO's step, the one its certificate supplies: n >> chain<N>() is what Prior<N> reaches from n, n - 1, ..., 0 (the Jlt paper's Listing 3).
template<std::semiregular Op>
constexpr Lifted< Op >	dedekind::category::lifted (Op op)
template<IsArrow P> requires std::same_as<Cod<P>, bool>
constexpr Where< P >	dedekind::category::where (P p)
template<detail_comprehension::IsForeignView R, IsArrow F> requires std::invocable<const F&, std::ranges::range_reference_t<R>>
constexpr auto	dedekind::category::operator>> (R r, F f)
	r >> f on a range of the caller's: f on each element, which is std::views::transform.
constexpr Windows	dedekind::category::windows (std::size_t n)
template<detail_comprehension::IsForeignView R> requires std::ranges::forward_range<R>
constexpr auto	dedekind::category::operator>> (R r, Windows w)
template<typename T, IsPrefixKernel< T > K>
constexpr auto	dedekind::category::scan (K k, std::span< const T > s)
	scan(k, s), the extension of the history comonad: a kernel asked at every non-empty prefix, SQL's window function over ROWS UNBOUNDED PRECEDING, as scan on a Path (:sequences). Every position has a prefix, so unlike a window of n this is a comonad on a finite range; each answer may read the whole prefix, so a kernel that factors through finitely many states has an overload of its own (:automaton).
template<typename P, typename S, IsArrow T>
constexpr auto	dedekind::category::where (const Symmetric< P, S, T > &s)
	where(section): the windows a section holds, its membership as the filter, where(sites). The section stays a tensor (its * is the outer product); only here is it read as a predicate, its characteristic map, an arrow from a window of its letters: a std::span, since an arrow has one domain and a text is contiguous (a genome's bytes, Listing 5's carrier). The membership itself reads any random-access range; a window of a non-contiguous container is tested by it directly, not through this stage.
template<detail_comprehension::IsForeignView R, typename P, typename S, IsArrow T> requires requires(R r, const Symmetric<P, S, T>& s) { std::move(r) >> windows(1uz) >> where(s); }
constexpr auto	dedekind::category::operator>> (R r, const Symmetric< P, S, T > &s)
	r >> s: where the words of a section occur in a range of the caller's: its windows of the section's length, each kept where the section holds it. The section knows its length, so no window of another arises. Listing 5's dna >> pali6, the same expression as the join below read at one sequence.
template<std::regular S, std::semiregular Coalg, IsArrow F> requires detail_comprehension::ReadsItsElements<unfold_view<S, Coalg>, F>
constexpr auto	dedekind::category::operator>> (const unfold_view< S, Coalg > &q, F f)
	>> f on a query, SQL's SELECT: f on the present elements, the holes passed through, Maybe's action on the arrow (maybe_functor).
template<std::regular S, std::semiregular Coalg, IsArrow F> requires detail_comprehension::ReadsItsElements<unfold_view<S, Coalg>, F> && detail_comprehension::IsMaybe<Cod<F>>
constexpr auto	dedekind::category::operator>> (const unfold_view< S, Coalg > &q, F f)
	>> f on a query with f a Kleisli arrow into Maybe, a second where among them: Kleisli composition, f extended by Maybe's κ (:kleisli), so the holes do not nest. Filter fusion, where(p) >> where(q) = where(p ∧ q), is then the monad's associativity, not a rewrite of this partition's.
template<IsCountWord N, typename P, typename Q> requires requires(const P& p, const Q& q) { { p & q } -> IsArrow; requires std::same_as<Cod<decltype(p& q)>, bool>; }
constexpr auto	dedekind::category::operator>> (const FiniteChainSequence< N, Where< P > > &q, const Where< Q > &w)
	where(p) >> where(q) on a chain, fused by type: one where whose predicate is the lattice term p & q, the meet in the Boolean algebra of the chain's subobjects (:lattice's Meet). The filter is then a term the lattice's laws and the periodic counts read, not two walks; where p & q is not formed, the Kleisli composite above takes the query.
template<IsCountWord N, HasPeriod P> requires std::same_as<Cod<P>, bool>
constexpr N	dedekind::category::count (const FiniteChainSequence< N, Where< P > > &q)
	The count of a chain under a periodic filter: the count of the filter's characteristic sequence, which :periodic takes period by period (the lcm for a meet), no walk of the query. The law count(where(p)) = count(χ_p), used as the rewrite.
template<IsCountWord N = std::size_t, IsQuery Q>
constexpr N	dedekind::category::count (Q q)
	The count of a query, SQL's COUNT: its present elements, the tally lifted through Maybe.
template<IsQuery Q, IsCountWord N = typename std::ranges::range_value_t< Q>::value_type>
constexpr N	dedekind::category::sum (Q q)
	The sum of a query of counts, SQL's SUM: + lifted through Maybe.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename P, typename S, IsArrow T> requires requires(const Power<C, F, N>& p, const Symmetric<P, S, T>& s) { occurrences(p, s); }
constexpr WindowJoin< Power< C, F, N >, Symmetric< P, S, T > >	dedekind::category::operator>> (const Power< C, F, N > &p, const Symmetric< P, S, T > &s)
template<IsCountWord N>
constexpr AtMost< Factor< N >, 1 >	dedekind::category::count_factors (const Offsets< N > &o)
template<typename P, typename S> requires requires(const P& p, const S& s) { occurrences(p, s); }
constexpr auto	dedekind::category::explain (const WindowJoin< P, S > &j)
	The plan of a join on the window, EXPLAIN: the offsets times the cylinder at the first, an outer product, the cylinder in turn its selection pushed down (pushed_down). Fubini, periodicity and the box law compose into it; none of the three is stated for joins. Its type is the plan, so a test asserts it. Defined where a window fits.
template<typename P, typename S> requires requires(const P& p, const S& s) { occurrences(p, s); }
constexpr auto	dedekind::category::count_factors (const WindowJoin< P, S > &j)
	The factors of a join's count: its plan's, the box law throughout, with no sum over the offsets left; none where no window fits.
template<typename P, typename S> requires requires(const P& p, const S& s) { occurrences(p, s); }
constexpr auto	dedekind::category::count (const WindowJoin< P, S > &j)
template<typename P, typename S> requires requires(const P& p, const S& s) { occurrences(p, s); }
constexpr auto	dedekind::category::exact_count (const WindowJoin< P, S > &j)
template<typename P>
constexpr detail_comprehension::JoinWithStage< P >	dedekind::category::join_with (P p)
template<IsArrow Fam, typename P> requires requires(const P& p, const Cod<Fam>& s) { occurrences(p, s); }
constexpr auto	dedekind::category::operator>> (const Fam &fam, const detail_comprehension::JoinWithStage< P > &st)
template<IsArrow F> requires requires(const Cod<F>& j) { count(j); }
constexpr auto	dedekind::category::operator>> (const F &f, detail_comprehension::CountingStage)
template<IsQuery Q>
constexpr std::size_t	dedekind::category::operator>> (Q q, detail_comprehension::CountingStage)
	q >> counting, the stage form of count(q): the fold that ends a query, in the query's own rhythm.
template<IsQuery Q>
constexpr Maybe< std::size_t >	dedekind::category::count (const Maybe< Q > &q)
	A query that may not be (a plan past its capacity), counted: the count lifted through Maybe, nothing where the query is nothing. The monad carries the uncertainty to the end, so no caller cases on it.
template<IsQuery Q>
constexpr Maybe< std::size_t >	dedekind::category::operator>> (const Maybe< Q > &q, detail_comprehension::CountingStage)
	The stage form of the same.
template<typename Order = ascending, IsArrow Rank> requires std::strict_weak_order<const Order&, Cod<Rank>, Cod<Rank>>
constexpr OrderBy< Rank, Order >	dedekind::category::order_by (Rank rank, Order order={})
template<std::size_t K>
constexpr Take< K >	dedekind::category::take ()
template<IsCountWord N, typename F, IsArrow Rank, typename Order> requires std::same_as<Dom<Rank>, N> && detail_comprehension::AscendsByPosition<F> && detail_comprehension::KeptByTheWalk<Rank, Order>
constexpr FiniteChainSequence< N, F >	dedekind::category::operator>> (const FiniteChainSequence< N, F > &q, const OrderBy< Rank, Order > &)
	order_by on a filtered chain whose rank keeps the walk's order: the identity, the query sorted by construction (rewrite 3).
template<IsCountWord N, typename F, IsArrow Rank, typename Order> requires std::same_as<Dom<Rank>, N> && detail_comprehension::AscendsByPosition<F> && detail_comprehension::ReversedByTheWalk<Rank, Order>
constexpr auto	dedekind::category::operator>> (const FiniteChainSequence< N, F > &q, const OrderBy< Rank, Order > &)
	order_by on a filtered chain whose rank reverses the walk's order: the query re-rooted on the ascending slice [0, n), read upwards, the positions where the walk read them downwards (rewrite 3).
template<std::ranges::input_range Q, IsArrow Rank, typename Order>
constexpr detail_comprehension::Pending< Q, Rank, Order >	dedekind::category::operator>> (Q q, OrderBy< Rank, Order > by)
	order_by with no law to read: pending its take.
template<std::regular S, std::semiregular Coalg, std::size_t K>
constexpr auto	dedekind::category::operator>> (const unfold_view< S, Coalg > &q, Take< K >)
	take<K> on a query or a sequence: the walk, until K elements are present, lazily (rewrite 1; on a sorted query, rewrite 3's first K).
template<typename Q, typename Rank, typename Order, std::size_t K>
constexpr auto	dedekind::category::operator>> (detail_comprehension::Pending< Q, Rank, Order > p, Take< K >)
	order_by >> take<K> with no law: fused, one pass keeping the best K in an AtMost, never sorting the whole (rewrite 2). A query still, each element present, so its count is its rows' and collect makes the plain list.
template<IsCountWord N, typename Rank, std::size_t K> requires std::same_as<Dom<Rank>, N> && antitone_on_even_lengths<Rank>::value
constexpr auto	dedekind::category::operator>> (const detail_comprehension::Pending< unfold_view< std::optional< N >, detail_chain::SliceStep< N, Where< Congruent< N > > > >, Rank, descending > &p, Take< K >)
	The lengths in a residue class, ranked by their occurrences, the first K: one plan compiled, the even case, and the run time only reindexing into it. A family whose density falls along the even lengths ranks them by construction, the shortest first (the walk read upwards, rewrite 3), so the first K need no rank evaluated at all. A residue class of even modulus holds lengths of one parity: even ones are the case; odd ones occur nowhere (the reversal pairs the letters, and no even alphabet fixes them all), all ranked alike. Either way the class's members in order are the plan, a progression: padded into the class by \(j \mapsto m j + r\), unpadded by reading the lengths back. An odd modulus mixes the parities and takes the fused pass.
template<std::regular S, std::semiregular Coalg> requires detail_comprehension::IsBounded<Coalg>
constexpr auto	dedekind::category::collect (const unfold_view< S, Coalg > &q)
	A query's present elements as a value, bounded by its take: the ext boundary, where a list is asked for (#1133). A plain sequence's elements as they are, a query's unwrapped.
template<typename S> requires IsSubobject<S, typename S::Domain>
constexpr auto	dedekind::category::in (const typename S::Domain &x, const S &s)
	Membership: x ∈ S evaluated via S's structural call (the carrier IS the characteristic morphism).
template<typename S, IsArrow E> requires IsSubobject<S, typename S::Domain> && std::same_as<Cod<E>, typename S::Domain>
constexpr auto	dedekind::category::in_via (const Dom< E > &x, E embedding, const S &s)
	Membership through an embedding arrow e:X→A, then the carrier-as-predicate: x ∈_e S = s(e(x)).
template<IsArrow F, IsArrow G> requires std::same_as<Cod<std::decay_t<F>>, Dom<std::decay_t<G>>>
constexpr auto	dedekind::category::compose_embedding (F f, G g)
	Compose two embedding arrows for pullback naturality path checks.
template<typename A, typename B>
constexpr auto	dedekind::category::constant (B y)
	The constant arrow's factory, beside id<A>() and endo<A>(f): the domain named, the codomain the value's.
template<std::equality_comparable A>
constexpr Equals< A >	dedekind::category::equals (A x)
	The equality test's factory.
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::symmetric_at (const Rel &rel, const T &a, const T &b)
	Symmetry at a point (mereology__The_Laws_At_A_Point).
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { successor(x) } -> std::convertible_to<T>; }
constexpr bool	dedekind::category::symmetric_on (const Rel &rel, const T &lo, const T &hi)
	Symmetry over a whole chain (mereology__The_Laws_On_A_Chain).
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { x == x } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::equality_at (const Rel &rel, const T &a, const T &b)
	Equality at a point: the relation answers as == does.
template<typename Epi, typename Section> requires IsSplitEpicPair<Epi, Section> && std::equality_comparable<Cod<Epi>>
constexpr bool	dedekind::category::split_epi_section_law_at (const Epi &epi, const Section &section, const Cod< Epi > &b)
	Law check for split epimorphisms at a concrete codomain element.
template<typename S, IsArrow E> requires IsSubobject<S, typename S::Domain> && std::same_as<Cod<E>, typename S::Domain> && std::equality_comparable< std::invoke_result_t<S const&, typename S::Domain const&>>
constexpr bool	dedekind::category::classifier_reindexing_definitional_witness_at (const S &s, const E &embedding, const Dom< E > &x)
	Definitional witness check for Axiom 7 reindexing through embedding.
template<typename A, typename Pred> requires IsSpecies<A> && std::invocable<std::decay_t<Pred>, const A&> && IsΩ<std::invoke_result_t<std::decay_t<Pred>, const A&>>
constexpr auto	dedekind::category::ambient_set (Pred predicate)
	Construct a set object over ambient species A from a characteristic predicate.
template<typename T, typename Hash, typename Equal, typename Alloc> requires IsSpecies<T>
constexpr auto	dedekind::category::ambient_set (std::unordered_set< T, Hash, Equal, Alloc > s)
	Lift std::unordered_set<T, ...> into an IsSet object, by value: the container is boxed, the lifted Subobject a value. (#607 slice 1, #1061).
template<typename T, typename Compare, typename Alloc> requires IsSpecies<T>
constexpr auto	dedekind::category::ambient_set (std::set< T, Compare, Alloc > s)
	Lift std::set<T, ...> into an IsSet object, by value: the container is boxed, the lifted Subobject a value. (#607 slice 1, #1061).
template<std::ranges::forward_range R> requires IsSpecies<std::ranges::range_value_t<R>> && (!requires(R& r, std::ranges::range_value_t<R> x) { r.contains(x); })
constexpr auto	dedekind::category::ambient_set (R r)
	Lift any std::ranges::input_range (a view, span, or container) into an IsSet object by wrapping std::ranges::find as the membership test. This is the Jlt-clean reading of a set — the set is its membership test — carried down to the std::ranges layer: a lazy view is a first-class IsSet, and it is constexpr where std::unordered_set (not constexpr-constructible with contents) is not. Excludes the keyed containers above by refusing a .contains() member, so those more specific overloads still win. The range is moved into the predicate (a view is cheap to own; the lifted Subobject carries its own copy). (#607 — the range slice of the wrapper-dissolution plan.).
template<IsArrow F, IsArrow G>
constexpr auto	dedekind::category::legs (const Compose< F, G > &c)
	The legs of a composite: the arrows it composes.
template<typename β, typename T> requires Steers<β, T> || IsTermNode<T> || std::invocable<const β&, const T&>
constexpr auto	dedekind::category::cata (const β &alg, const T &t)
	cata ⦇β⦈ — the catamorphism (fold): the unique F-algebra homomorphism from the initial algebra (the term itself, μF) into an algebra (B, β).
template<IsArrow T>
constexpr auto	dedekind::category::cata (const T &t)
	cata(t): the term rewritten to its normal form under the β-reduction algebra. simplify is cata. The IsArrow gate keeps a bare product out of the term universe.
template<typename 𝗙, typename 𝗚> requires IsArrow<std::decay_t<𝗙>> && IsArrow<std::decay_t<𝗚>> && std::same_as<typename std::decay_t<𝗙>::Codomain, typename std::decay_t<𝗚>::Domain> && IsShapedFunctor<𝗙> && IsShapedFunctor<𝗚> && std::same_as<typename std::remove_cvref_t<𝗙>::Τ_cat, typename std::remove_cvref_t<𝗚>::Σ_cat>
constexpr auto	dedekind::category::operator>> (𝗙 f, 𝗚 g)
template<typename 𝗙, typename 𝗚> requires IsArrow<std::decay_t<𝗙>> && IsArrow<std::decay_t<𝗚>> && std::same_as<typename std::decay_t<𝗙>::Codomain, typename std::decay_t<𝗚>::Domain> && IsShapedFunctor<𝗙> && IsShapedFunctor<𝗚> && std::same_as<typename std::remove_cvref_t<𝗙>::Τ_cat, typename std::remove_cvref_t<𝗚>::Σ_cat> && IsIdentityFunctor<𝗙>
constexpr auto	dedekind::category::operator>> (𝗙, 𝗚 g)
template<typename 𝗙, typename 𝗚> requires IsArrow<std::decay_t<𝗙>> && IsArrow<std::decay_t<𝗚>> && std::same_as<typename std::decay_t<𝗙>::Codomain, typename std::decay_t<𝗚>::Domain> && IsShapedFunctor<𝗙> && IsShapedFunctor<𝗚> && std::same_as<typename std::remove_cvref_t<𝗙>::Τ_cat, typename std::remove_cvref_t<𝗚>::Σ_cat> && IsIdentityFunctor<𝗚>
constexpr auto	dedekind::category::operator>> (𝗙 f, 𝗚)
template<typename 𝗙, typename 𝗚> requires IsArrow<std::decay_t<𝗙>> && IsArrow<std::decay_t<𝗚>> && std::same_as<typename std::decay_t<𝗙>::Codomain, typename std::decay_t<𝗚>::Domain> && IsShapedFunctor<𝗙> && IsShapedFunctor<𝗚> && std::same_as<typename std::remove_cvref_t<𝗙>::Τ_cat, typename std::remove_cvref_t<𝗚>::Σ_cat> && IsIdentityFunctor<𝗙> && IsIdentityFunctor<𝗚>
constexpr auto	dedekind::category::operator>> (𝗙 f, 𝗚)
template<typename 𝗙, typename 𝗚> requires IsShapedFunctor<𝗙> && IsShapedFunctor<𝗚> && std::same_as<typename std::remove_cvref_t<𝗚>::Τ_cat, typename std::remove_cvref_t<𝗙>::Σ_cat>
constexpr auto	dedekind::category::operator<< (𝗙 f, 𝗚 g)
	The "Upstream Fish" (Optional Composition Sugar) g << f => g ∘ f.
template<typename Functor, typename Structure> requires IsEndofunctor<std::remove_cvref_t<Functor>> && IsArrow<std::remove_cvref_t<Structure>>
constexpr auto	dedekind::category::make_f_algebra (Functor functor, Structure structure)
	Factory for F-algebra witnesses.
template<typename Functor, typename Structure> requires IsEndofunctor<std::remove_cvref_t<Functor>> && IsArrow<std::remove_cvref_t<Structure>>
constexpr auto	dedekind::category::make_f_coalgebra (Functor functor, Structure structure)
	Factory for F-coalgebra witnesses.
template<typename T, typename Step, typename Equal = std::equal_to<>> requires IsIterativeEndomorphism<T, Step> && std::predicate<const Equal&, const T&, const T&>
constexpr T	dedekind::category::fixed_point (T seed, Step step, Equal equal={}, std::size_t max_iterations=1024)
	Iteratively compute a fixed point of an endomorphism.
template<typename T, typename Step, typename Equal = std::equal_to<>> requires IsIterativeEndomorphism<T, Step> && std::predicate<const Equal&, const T&, const T&>
constexpr T	dedekind::category::least_fixpoint (T seed, Step step, Equal equal={}, std::size_t max_iterations=1024)
	Alias emphasizing order-theoretic reading of the fixed point.
template<typename T, typename Expand, typename Join, typename Equal = std::equal_to<>> requires std::predicate<const Equal&, const T&, const T&>
constexpr T	dedekind::category::closure (const T &x, Expand expand, Join join, Equal equal={}, std::size_t max_iterations=1024)
	The closure of x under expand: the textbook "closure of @c X under @c Y". It is the least fixpoint of S ↦ x ⊔ expand(S) — the smallest element ⊒ x closed under the one-step expansion expand — equivalently the Kleene join ⨆ₙ expandⁿ(x).
template<typename F> requires IsArrow<F> && std::constructible_from<std::remove_cvref_t<F>, F&&>
constexpr auto	dedekind::category::image_of (F f)
	Factory: image_of(f) constructs the image of f as a Subobject of Cod<F>.
template<typename Dagger, typename Op, typename T> requires std::equality_comparable<T> && requires(const T& g) { Op{}(Dagger{}(g), g); unit<T>(Op{}); }
constexpr bool	dedekind::category::is_isometry (const T &f)
	CRUCIAL (load-bearing across the library): "the converse @b is the inverse" — unitarity — is a property of an arrow (a value), not of a type. This is why the retired is_unitary certificate was wrong, and why the surface below is two coordinated forms of one computed law.
template<typename Dagger, typename Op, typename T> requires std::equality_comparable<T> && requires(const T& g) { Op{}(g, Dagger{}(g)); unit<T>(Op{}); }
constexpr bool	dedekind::category::is_coisometry (const T &f)
	The coisometry law: \(f \circ f^\dagger = \mathrm{id}\) — the dagger is a right inverse.
template<typename Dagger, typename Op, typename T>
constexpr bool	dedekind::category::is_unitary (const T &f)
	The unitary law: isometry and coisometry, hence \(f^\dagger = f^{-1}\) (a dagger-iso). Generalises the permutation's P° ; P = Δ check: the one predicate reads as "the converse is the inverse" (bijection, Mat(𝔹)), "the transpose is the inverse" (orthogonal, Mat(ℝ)) and "the adjoint is the inverse" (unitary, Mat(ℂ)) — the real / complex face of the same law.
template<typename F> requires IsIsomorphism<std::remove_cvref_t<F>> && requires(const std::remove_cvref_t<F>& cf, const Cod<F>& y) { inverse(cf)(y); }
constexpr auto	dedekind::category::retract (F f)
	Blanket retract for any IsIsomorphism: wraps inverse(f) in always-Some (see IsoRetract). This is what makes IsIsomorphism ⟹ IsRetractableArrow hold with no manual hook.
template<typename MA, typename F> requires requires(MA const& ma, F&& f) { μ(detail_kleisli::lifted(ma, std::forward<F>(f))); }
constexpr auto	dedekind::category::κ (MA const &ma, F f)
	κ (kappa): Kleisli bind (monadic extension).
template<typename WA, typename F> requires requires(WA const& wa, F&& f) { detail_kleisli::lifted(δ(wa), std::forward<F>(f)); }
constexpr auto	dedekind::category::σ (WA const &wa, F f)
	σ (sigma): Co-Kleisli extend (comonadic extension).
template<typename MonadTag, typename MA, typename F> requires IsDefaultMonadTag<MonadTag> && requires(MonadTag tag, MA const& ma, F&& f) { μ(tag, detail_kleisli::lifted(ma, std::forward<F>(f))); }
constexpr auto	dedekind::category::κ (MonadTag tag, MA const &ma, F f)
	κ with explicit monad-tag dispatch.
template<typename MonadTag, typename WA, typename F> requires IsDefaultMonadTag<MonadTag> && requires(MonadTag tag, WA const& wa, F&& f) { detail_kleisli::lifted(δ(tag, wa), std::forward<F>(f)); }
constexpr auto	dedekind::category::σ (MonadTag tag, WA const &wa, F f)
	σ with explicit monad-tag dispatch.
template<std::ranges::input_range R, typename TA, typename Step> requires detail_kleisli::IsKleisliStep<Step, TA, std::ranges::range_value_t<R>>
constexpr TA	dedekind::category::fold (R r, TA ta, Step step)
template<typename MA, typename F> requires requires(MA const& ma, F&& f) { { κ(ma, std::forward<F>(f)) }; }
constexpr auto	dedekind::category::operator>>= (MA const &ma, F f)
	operator>>= : Monadic bind (Kleisli arrow application).
template<typename WA, typename F> requires requires(WA const& wa, F&& f) { { σ(wa, std::forward<F>(f)) }; }
constexpr auto	dedekind::category::operator<<= (WA const &wa, F f)
	operator<<= : Comonadic extend (co-Kleisli arrow application).
template<typename A, typename B> requires detail_lattice_nodes::BuildNodes<A, B>
constexpr Join< A, B >	dedekind::category::operator| (A a, B b)
template<typename A, typename B> requires detail_lattice_nodes::BuildNodes<A, B>
constexpr Meet< A, B >	dedekind::category::operator& (A a, B b)
template<typename A, typename B>
constexpr A	dedekind::category::component (const Meet< A, B > &m, At< 1 >)
	π_1: the left-operand accessor of a binary node, returned by const-reference. The operand may itself be a whole set expression (a nested node), and π_1 / π_2 are pure projections. They must not copy the sub-structure. When the operand is a set, π_1(node) is then a bona fide reference to that IsSet (the downstream sets lift relies on this). Still ->convertible_to , so IsProduct is satisfied.
template<typename A, typename B>
constexpr B	dedekind::category::component (const Meet< A, B > &m, At< 2 >)
	π_2: the right-operand accessor of a meet, by const-reference (see π_1).
template<typename A, typename B>
constexpr A	dedekind::category::component (const Join< A, B > &j, At< 1 >)
	π_1: the left-operand accessor of a join, by const-reference (see the meet overload).
template<typename A, typename B>
constexpr B	dedekind::category::component (const Join< A, B > &j, At< 2 >)
	π_2: the right-operand accessor of a join, by const-reference.
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::meet_bounded_law (const RA &a, const RB &b)
	Law induced by a bounded lattice (IsBoundedLatticeCategory): the unit and annihilator. Meet: ⊥∧X=⊥ (annihilator), ⊤∧X=X (unit). Fires only when both operands share a carrier (mixed-carrier ⟹ inactive).
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::join_bounded_law (const RA &a, const RB &b)
	The join dual: ⊤∨X=⊤ (annihilator), ⊥∨X=X (unit). Likewise fires only when both operands share a carrier.
template<typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::idempotent_law (const RA &a, const RB &)
	Law induced by a (meet/join-)semilattice: idempotence X∧X=X / X∨X=X. Structural: it holds for the lattice operation itself, so it does not depend on the carrier's order. It fires even for order-incomparable opaque leaves. It is gated on idempotent_leaf_v, so a runtime-stateful leaf (two same-type-but-distinct instances) is not collapsed.
template<typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::meet_structural_absorption_law (const RA &a, const RB &b)
	Law induced by a lattice (IsLatticeCategory): structural absorption a∧(a∨b)=a. Structural like idempotence (a lattice axiom needing no order or carrier), so it fires even for order-incomparable opaque leaves; unlike the glb collapse (which needs comparable operands). One level only: nested / associatively-buried occurrences (a∧((a∨b)∨c)) await an associativity-flattening law (tracked on the reducer epic #890). Fails closed on a mixed-carrier term (has_mixed_carrier_v) so it upholds the same recursive fail-closed invariant as carrier_of / the boundary laws; the all-opaque (unknown-carrier) case still fires.
template<typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::join_structural_absorption_law (const RA &a, const RB &b)
	The join dual: a∨(a∧b)=a. Likewise fails closed on mixed carriers.
template<typename A, typename B, typename Ord>
consteval bool	dedekind::category::order_leq ()
	Is A ≤ B in the injected order Ord? (false when the pair is not compile-time comparable there — the glb/lub law then does not fire.).
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::meet_glb_law (const RA &a, const RB &b)
	Law induced by a lattice's order-meet consistency (RA≤RB ⟺ RA∧RB=RA): for ≤-comparable operands the meet is their glb (the smaller). Note this is not the structural absorption identity a∧(a∨b)=a (which needs no comparison); that is the separate meet_structural_absorption_law. Here only comparable operands collapse.
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::join_lub_law (const RA &a, const RB &b)
	The join dual: for comparable operands the join is their lub (the larger), RA≤RB ⟹ RA∨RB=RB. (Structural absorption a∨(a∧b)=a is the separate join_structural_absorption_law.).
template<typename X, typename P, typename Q> requires std::copy_constructible<X> && std::copy_constructible<P> && std::copy_constructible<Q>
constexpr auto	distribute_meet_over (const X &x, const Join< P, Q > &j)
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::meet_distributivity_law (const RA &a, const RB &b)
	Law induced by a distributive lattice: distribute meet over join, X∧(P∨Q) → (X∧P)∨(X∧Q), driving toward a join-of-meets (DNF). One direction only (meet over join, never join over meet), so re-reduction of the result — which the assembler performs — terminates. Gated on both operands sharing a carrier (SameCarrier) whose lattice is distributive under Ord; a chain is gated but pre-empted by the glb collapse, so this fires only on a genuine non-chain distributive lattice.
template<typename B> requires std::copy_constructible<B>
constexpr B	de_morgan_of (const Not< B > &n)
template<typename P, typename Q> requires std::copy_constructible<P> && std::copy_constructible<Q>
constexpr auto	de_morgan_of (const Meet< P, Q > &m)
template<typename P, typename Q> requires std::copy_constructible<P> && std::copy_constructible<Q>
constexpr auto	de_morgan_of (const Join< P, Q > &j)
template<typename Ord, typename RA> requires std::copy_constructible<RA>
constexpr auto	dedekind::category::de_morgan_law (const RA &a)
	Law induced by an involutive De Morgan negation: rewrite ¬(reduced) by involution (¬¬A→A) and De Morgan (¬(A∧B)→¬A∨¬B, ¬(A∨B)→¬A∧¬B), pushing the negation toward the leaves (negation-normal form). Gated on the carrier's lattice carrying such a negation under Ord; a bare ¬leaf is already normal and stays (law_inactive). The driver re-reduces the pushed-down result (termination: ¬ strictly descends).
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::meet_complement_law (const RA &, const RB &)
	Law induced by a complemented lattice: the complement collapse a∧¬a→⊥ (meet) / a∨¬a→⊤ (join). The bottom / top produced is the carrier's registered LatticeBottom / LatticeTop over its resolved order (for sets, that is Ø / 𝔸 once the sets layer registers them). Gated on the carrier being complemented under Ord; else inactive.
template<typename Ord, typename RA, typename RB> requires std::copy_constructible<RA> && std::copy_constructible<RB>
constexpr auto	dedekind::category::join_complement_law (const RA &, const RB &)
	The join dual: a∨¬a→⊤ (excluded middle).
template<typename Less, typename X, typename Y>
consteval bool	dedekind::category::lattice_definitely_less ()
	Did the comparator decide definitely True? (Unknown/False ⟹ don't reorder: keep authoring order.).
template<typename T>
constexpr auto	dedekind::category::bang ()
	The terminal map factory: produces the unique arrow !: T → One.
template<typename T>
constexpr auto	dedekind::category::zero ()
	The zero morphism factory: produces the unique (unreachable) arrow ?: Zero → T.
template<typename P, std::size_t K> requires TupleLike<P> && (K >= 1) && (K <= std::tuple_size_v<P>)
constexpr auto	dedekind::category::component (const P &p, At< K >)
	The k-th component of a tuple-like product, by reference: a projection reads its point without copying it (a string or vector carrier stays where it is). π_k returns a temporary's component by value.
template<typename P> requires (!TupleLike<P>) && requires(const P& p) { p.first; }
constexpr auto	dedekind::category::component (const P &p, At< 1 >)
	The components of a pair-like product that is not tuple-like.
template<typename P> requires (!TupleLike<P>) && requires(const P& p) { p.second; }
constexpr auto	dedekind::category::component (const P &p, At< 2 >)
template<IsArrow F, IsArrow G> requires std::same_as<Dom<F>, Dom<G>>
constexpr auto	dedekind::category::mediate_product (F f, G g)
	Mediating morphism for Products: ⟨f, g⟩: X -> (A × B).
template<std::same_as< Percentage > P>
constexpr P	dedekind::category::operator&& (P a, P b) noexcept
	The logical register on Percentage, as Ternary has below: && / || / ! are the species' AND / OR / RFL, so a Percentage answer conjoins as an answer (a product's membership a(x.first) && b(x.second) stays a Percentage) and HasLogicalOperators holds. Deduced on both operands, so no int → Percentage conversion sneaks a bare number into the register.
template<std::same_as< Percentage > P>
constexpr P	dedekind::category::operator|| (P a, P b) noexcept
template<std::same_as< Percentage > P>
constexpr P	dedekind::category::operator! (P a) noexcept
constexpr Ternary	dedekind::category::operator&& (Ternary a, Ternary b)
constexpr Ternary	dedekind::category::operator|| (Ternary a, Ternary b)
constexpr Ternary	dedekind::category::operator! (Ternary a)
constexpr Ternary	dedekind::category::successor (Ternary a) noexcept
	K₃'s step: the cover False → Unknown → True, saturating at the top (and its dual at the bottom), the NNO step of the chain (:nno).
constexpr Ternary	dedekind::category::predecessor (Ternary a) noexcept
constexpr std::strong_ordering	dedekind::category::operator<=> (Ternary a, Ternary b) noexcept
	Truth-order <=> on Ternary: the chain False (-1) < Unknown (0) < True (1).
template<typename TargetLogic, typename T> requires LiftableInto<T, TargetLogic>
constexpr auto	dedekind::category::lift_logic (T value)
	Lift an answer along the dominance into TargetLogic::Ω. A value already in TargetLogic::Ω passes through; otherwise its species is read off the answer type (classifier_logic_t) and the registered embedding applies. Constrained, so an unsupported lift is a substitution failure at the call site, not an error inside.
template<typename L>
constexpr bool	dedekind::category::holds (Truth< L > proposition) noexcept
	Semantic truth projection for assertion contexts.
template<typename L>
constexpr bool	dedekind::category::refutes (Truth< L > proposition) noexcept
	Semantic falsity projection for assertion contexts.
template<typename L> requires IsOckhamAlgebra<L> && logic_negation_is_involutive_v<L> && std::equality_comparable<typename L::Ω>
constexpr bool	dedekind::category::is_decided (typename L::Ω value)
	Membership in the decided core \(\{\top, \bot\}\) of an answer-lattice \(\Omega\) — the Rosolini dominance \(\Sigma\), which the paper and lift_logic define as exactly the decided subobject \(\{\top,\bot\} \hookrightarrow \Omega\).
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::reflexive_at (const Rel &rel, const T &a)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::transitive_at (const Rel &rel, const T &a, const T &b, const T &c)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { x == x } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::antisymmetric_at (const Rel &rel, const T &a, const T &b)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; }
constexpr bool	dedekind::category::connex_at (const Rel &rel, const T &a, const T &b)
template<typename T> requires requires(const T& t) { { successor(t) } -> std::convertible_to<T>; { t == t } -> std::convertible_to<bool>; }
constexpr ChainWalk< T >	walk_chain (const T &lo, const T &hi, std::size_t budget=chain_walk_budget)
	The walk from lo towards hi by the carrier's successor, within chain_walk_budget: the fixed point of one step, reached where the chain ends (at hi, or at a fixpoint of the step), so it stops there.
template<std::size_t Arity, typename Law, typename Rel, typename T, typename... Fixed> requires (sizeof...(Fixed) != Arity) || std::predicate<const Law&, const Rel&, const Fixed&...>
constexpr bool	holds_on_walk (Law law, const Rel &rel, const T &lo, std::size_t length, const Fixed &... fixed)
	A law of Arity points, at every tuple of points from lo to hi: the one walk every law below reads.
template<std::size_t Arity, typename Law, typename Rel, typename T>
constexpr bool	holds_on (Law law, const Rel &rel, const T &lo, const T &hi)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { successor(x) } -> std::convertible_to<T>; }
constexpr bool	dedekind::category::reflexive_on (const Rel &rel, const T &lo, const T &hi)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { successor(x) } -> std::convertible_to<T>; }
constexpr bool	dedekind::category::antisymmetric_on (const Rel &rel, const T &lo, const T &hi)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { successor(x) } -> std::convertible_to<T>; }
constexpr bool	dedekind::category::connex_on (const Rel &rel, const T &lo, const T &hi)
template<typename Rel, typename T> requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; { successor(x) } -> std::convertible_to<T>; }
constexpr bool	dedekind::category::transitive_on (const Rel &rel, const T &lo, const T &hi)
template<typename T>
constexpr std::size_t	chain_length (const T &lo, const T &hi)
	The number of values from lo to hi by the carrier's successor; 0 when hi is not reached within chain_walk_budget (the top, a fixpoint of the step, short of hi).
constexpr bool	fits_budget (std::size_t n, std::size_t arity)
	Whether a law of arity variables on a chain of n values fits law_evaluation_budget.
template<typename Whole> requires requires { whole.operator->(); }
constexpr auto	dedekind::category::arrow_drill_down (const Whole &whole)
	Generic opt-in drill-down projector for part-whole wrappers.
template<typename T>
constexpr T	dedekind::category::arrow_drill_down (const T *whole)
	Pointer overload for generic drill-down projection.
template<typename F>
	Morphism (F) -> Morphism< domain_t< F >, codomain_t< F >, F >
template<typename F> requires (!IsArrow<std::remove_cvref_t<F>>) && requires(F f) { typename signature_extractor<F>::type; }
constexpr auto	dedekind::category::arrow (F f)
template<typename A, typename B, typename F>
constexpr auto	dedekind::category::arrow (F f)
template<IsArrow F>
constexpr auto	arrow (F f)
template<typename A, typename F> requires (!IsArrow<F> && std::invocable<std::decay_t<F>, const A&>)
constexpr auto	dedekind::category::arrow (F f)
template<typename A, typename F>
constexpr auto	dedekind::category::endo (F f)
template<typename A, typename B>
constexpr auto	dedekind::category::operator&& (const Rule< A, B > &p1, const Rule< A, B > &p2)
template<typename A, typename B>
constexpr auto	dedekind::category::operator|| (const Rule< A, B > &p1, const Rule< A, B > &p2)
template<typename A>
constexpr auto	dedekind::category::id ()
	The Identity Factory: Returns the neutral arrow for Species A.
template<IsArrow F, IsArrow P> requires std::same_as<Cod<F>, Dom<P>>
constexpr auto	dedekind::category::preimage (const F &f, const P &p)
	The contravariant substitution / pullback f*: pull a codomain predicate (or arrow) P back along f, preimage(f,P) = P∘f = Compose<F,P>.
template<IsArrow F, IsArrow G>
constexpr F	dedekind::category::component (const Compose< F, G > &c, std::integral_constant< std::size_t, 1 >)
	Product projections for the reified composite Compose<F,G>: its two legs .f / .g are the product components, so Compose<F,G> is the categorical product of its operand arrows F, G in the arrow category — which is exactly why composition PRESERVES the leg types where the old type-erasing lambda hid them. These are custom-storage overloads of the projections' component hook (:limit; the slot is :limit's At<k>, spelled out here upstream of it): storage is named .f / .g rather than .first / .second, so per the Dual val/der precedent Compose supplies its own overloads in its home namespace, found by ADL. With them IsProduct<Compose<F,G>,F,G> holds (witnessed in :limit).
template<IsArrow F, IsArrow G>
constexpr G	dedekind::category::component (const Compose< F, G > &c, std::integral_constant< std::size_t, 2 >)
template<typename F, typename G> requires IsArrow<std::decay_t<F>> && IsArrow<std::decay_t<G>> && std::same_as<typename std::decay_t<F>::Codomain, typename std::decay_t<G>::Domain>
constexpr auto	dedekind::category::operator>> (F f, G g)
	Synthesizes an arrow A -> C from A -> B and B -> C.
template<typename F, typename G> requires IsArrow<std::decay_t<F>> && IsArrow<std::decay_t<G>> && std::same_as<typename std::decay_t<F>::Codomain, typename std::decay_t<G>::Domain> && IsIdentityArrow<F>
constexpr auto	dedekind::category::operator>> (F, G g)
template<typename F, typename G> requires IsArrow<std::decay_t<F>> && IsArrow<std::decay_t<G>> && std::same_as<typename std::decay_t<F>::Codomain, typename std::decay_t<G>::Domain> && IsIdentityArrow<G>
constexpr auto	dedekind::category::operator>> (F f, G)
template<typename F, typename G> requires IsArrow<std::decay_t<F>> && IsArrow<std::decay_t<G>> && std::same_as<typename std::decay_t<F>::Codomain, typename std::decay_t<G>::Domain> && IsIdentityArrow<F> && IsIdentityArrow<G>
constexpr auto	dedekind::category::operator>> (F f, G)
template<auto f, typename T> requires IsArrow<decltype(f)>
constexpr T	dedekind::category::call (T x)
	A stateless arrow as a function: &call<F{}, T> is a pointer through which F{} is called, so that an empty arrow has a representation with one storage class (:cartesian's Morphisms).
template<typename F, typename G> requires IsArrow<std::decay_t<F>> && (!IsArrow<std::decay_t<G>>) && std::invocable<std::decay_t<G>&, const typename std::decay_t<F>::Codomain&>
constexpr auto	dedekind::category::operator>> (F f, G g)
	operator>> with a callable on the RHS — auto-wraps the lambda as arrow<F::Codomain> .
template<typename F, typename G> requires (!IsArrow<std::decay_t<F>>) && IsArrow<std::decay_t<G>> && std::invocable<std::decay_t<F>&, const typename std::decay_t<G>::Domain&> && (!std::convertible_to<F, typename std::decay_t<G>::Domain>)
constexpr auto	dedekind::category::operator>> (F f, G g)
	The same with the callable on the LHS: rev >> power(τ) gives rev the arrow's domain, as power(τ) >> rev gives it the codomain. A value on the LHS is application (below); the two do not meet, since a value convertible to the domain is not a callable on it.
template<typename F> requires is_self_inverse_v<std::remove_cvref_t<F>>
constexpr std::remove_cvref_t< F >	dedekind::category::inverse (const F &f)
	A self-inverse arrow is its own inverse.
template<typename T>
constexpr auto	dedekind::category::inverse (Identity< T > id) noexcept
	The structural inverse of an Identity is itself.
template<typename A, typename B, typename Impl> requires std::same_as<Impl, std::negate<A>>
constexpr auto	dedekind::category::inverse (Morphism< A, B, Impl > f) noexcept
	The structural inverse of Negation is itself (Involutive).
template<IsArrow F, IsArrow G> requires (IsIsomorphism<F> && IsIsomorphism<G>)
constexpr auto	dedekind::category::inverse (const Compose< F, G > &c)
	A composite of isomorphisms is one: \((g \circ f)^{-1} = f^{-1} \circ g^{-1}\), the inverses run the other way round. The rule, not a declaration per composite; with the involution rule (:involution, an involution is its own inverse) the composite of two involutions is an isomorphism, though in general no involution.
template<typename T, typename Arrow> requires IsArrow<Arrow> && std::convertible_to<T, typename Arrow::Domain>
constexpr auto	dedekind::category::operator>> (T value, const Arrow &f) -> typename Arrow::Codomain
	Proposition: A Value x can be piped into a Morphism f: A -> B.
template<typename X, typename F, typename Equal = std::equal_to<>> requires std::copyable<X> && std::regular_invocable<const F&, const X&> && std::convertible_to<std::invoke_result_t<const F&, const X&>, X> && (std::predicate<const Equal&, const X&, const X&> || std::same_as<Equal, std::equal_to<>>)
constexpr X	dedekind::category::iterate (const F &f, const X &x0, std::size_t n, const Equal &equal={})
template<typename A>
constexpr Maybe< std::decay_t< A > >	η (A value)
	The Maybe endofunctor T, implemented via std::optional.
template<typename A> requires std::semiregular<std::decay_t<A>>
constexpr Maybe< std::decay_t< A > >	dedekind::category::η (maybe_monad_tag, A value)
template<typename A> requires std::semiregular<A>
constexpr Maybe< A >	μ (Maybe< Maybe< A > > const &mma)
	μ for Maybe: flattens nested optional context.
template<typename A> requires std::semiregular<A>
constexpr Maybe< A >	dedekind::category::μ (maybe_monad_tag, Maybe< Maybe< A > > const &mma)
template<typename A> requires IsSpecies<std::decay_t<A>>
constexpr std::tuple< std::decay_t< A > >	dedekind::category::η (tuple_monad_tag, A value)
	The std::tuple<T> Frobenius monad.
template<typename A> requires IsSpecies<A>
constexpr std::tuple< A >	μ (std::tuple< std::tuple< A > > const &tta)
template<typename A> requires IsSpecies<A>
constexpr std::tuple< A >	dedekind::category::μ (tuple_monad_tag, std::tuple< std::tuple< A > > const &tta)
template<typename A>
constexpr A	ε (std::tuple< A > const &ta)
template<typename A> requires IsSpecies<A>
constexpr A	dedekind::category::ε (tuple_monad_tag, std::tuple< A > const &ta)
template<typename A> requires IsSpecies<A>
constexpr std::tuple< std::tuple< A > >	δ (std::tuple< A > const &ta)
template<typename A> requires IsSpecies<A>
constexpr std::tuple< std::tuple< A > >	dedekind::category::δ (tuple_monad_tag, std::tuple< A > const &ta)
template<typename A>
constexpr Identity< std::decay_t< A > >	η (A value)
	The Identity Functor Id_C. Reified 1-morphism that preserves both objects and arrows exactly.
template<typename A> requires IsSpecies<std::decay_t<A>>
constexpr Identity< std::decay_t< A > >	dedekind::category::η (identity_monad_tag, A value)
template<typename A> requires IsSpecies<A>
constexpr Identity< A >	μ (Identity< Identity< A > > const &iia)
	Monadic join (μ): Identity<Identity<A>> → Identity. Unwraps a doubly wrapped identity arrow.
template<typename A> requires IsSpecies<A>
constexpr Identity< A >	dedekind::category::μ (identity_monad_tag, Identity< Identity< A > > const &iia)
template<typename A>
constexpr Identity< A >	ε (Identity< A > const &ia)
template<typename A> requires IsSpecies<A>
constexpr Identity< A >	dedekind::category::ε (identity_monad_tag, Identity< A > const &ia)
template<typename A>
constexpr Identity< Identity< A > >	δ (Identity< A > const &ia)
	Comonadic duplicate (δ): Identity → Identity<Identity<A>>. Wraps an identity arrow once more.
template<typename A> requires IsSpecies<A>
constexpr Identity< Identity< A > >	dedekind::category::δ (identity_monad_tag, Identity< A > const &ia)
template<std::integral T>
constexpr T	dedekind::category::successor (T n) noexcept
	The successor arrow as a free customization point: successor(n) for an NNO carrier, and its partial dual predecessor(n).
template<std::integral T>
constexpr T	dedekind::category::predecessor (T n) noexcept
template<typename T> requires requires(const T& n) { { T::successor(n) } -> std::convertible_to<T>; }
constexpr T	dedekind::category::successor (const T &n)
	Bridge to the :morphologies static-member convention.
constexpr bool	dedekind::category::predecessor (bool) noexcept
constexpr std::byte	dedekind::category::successor (std::byte b) noexcept
	The octets' covering step: std::byte's order read as a chain, the next byte, saturating at the top. No arithmetic, only the step, so a byte chain is a chain and no integer chain.
constexpr std::byte	dedekind::category::predecessor (std::byte b) noexcept
template<HasNNOStep N> requires std::equality_comparable<N>
constexpr std::optional< N >	dedekind::category::cover (const N &n)
	The cover \(S^{+} : N \to 1 + N\) (y covers x: x < y, nothing between, Davey and Priestley [3], ch. 1): the successor read partially, nullopt at a fixpoint of S, which on a saturating bounded chain is its top (ℵ₀ on Cardinality, True on K₃), and at a machine word's greatest value, where S has no value (signed) or wraps (unsigned: the ring ℤ/2^w under S, the chain 0 < 1 < … < 2^w − 1 under its cover); total on an unbounded chain. Whether the step itself is monotone is the arrow's fact (IsMonotone<Successor<N>>, registered in order:completeness from the carrier's periodicity), not the carrier's. std::optional<N> is \(1 + N\), the NNO's own functor \(F(X) = 1 + X\).
template<HasNNOStep N> requires std::equality_comparable<N>
constexpr std::optional< N >	dedekind::category::lower_cover (const N &n)
	The lower cover \(P^{+} : N \to 1 + N\), dual to cover: the predecessor read partially, nullopt at the least element (a fixpoint of P, or a machine word's least value). Not the destructor Prior, which is nothing at zero.
template<typename A, typename G> requires std::regular_invocable<const G&, const A&> && std::convertible_to<std::invoke_result_t<const G&, const A&>, A> && std::copyable<A>
constexpr A	dedekind::category::nno_iterate (A a0, G g, std::size_t n)
	Recursion-via-universal-property (operational discharge).
template<typename T, typename Policy> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr Ternary	dedekind::category::classify_numeric (T x, Policy policy)
	Classify a numeric value under a user policy.
template<std::integral T, typename Policy> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_add (T a, T b, Policy policy)
	Certified integer addition with an explicit support policy.
template<std::floating_point T, typename Policy = NaNHolePolicy<T>> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_add (T a, T b, Policy policy={})
	Certified floating addition with NaN-hole policy.
template<std::integral T, typename Policy> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_mul (T a, T b, Policy policy)
	Certified integer multiplication with an explicit support policy.
template<std::floating_point T, typename Policy = NaNHolePolicy<T>> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_mul (T a, T b, Policy policy={})
	Certified floating multiplication with NaN-hole policy.
template<std::integral T, typename Policy> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_div (T a, T b, Policy policy)
	Certified integer division with explicit policy.
template<std::floating_point T, typename Policy = NaNHolePolicy<T>> requires IsLipschitzBoundaryPolicy<Policy, T>
constexpr NumericWitness< T >	dedekind::category::certify_div (T a, T b, Policy policy={})
	Certified floating division with NaN-hole policy.
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< int >	dedekind::category::certify_add_int_interval (int a, int b, IntervalBoundaryPolicy< int > policy)
	Non-template bridge functions for profiler-friendly attribution.
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< unsigned int >	dedekind::category::certify_add_uint_full (unsigned int a, unsigned int b, FullMachineBoundaryPolicy< unsigned int > policy={})
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< int >	dedekind::category::certify_mul_int_interval (int a, int b, IntervalBoundaryPolicy< int > policy)
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< int >	dedekind::category::certify_div_int_full (int a, int b, FullMachineBoundaryPolicy< int > policy={})
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< double >	dedekind::category::certify_add_double_nan (double a, double b, NaNHolePolicy< double > policy={})
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< double >	dedekind::category::certify_mul_double_nan (double a, double b, NaNHolePolicy< double > policy={})
DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< double >	dedekind::category::certify_div_double_nan (double a, double b, NaNHolePolicy< double > policy={})
template<typename T>
constexpr bool	presence_of (const std::optional< T > &opt)
template<typename T>
constexpr Ternary	presence_of (const Partial< T > &p)
template<typename T>
constexpr Ternary	presence_of (const TernaryResult< T > &tr)
template<HasPeriod F, IsArrow G>
constexpr Dom< F >	dedekind::category::period (const Compose< F, G > &c)
	Inferred, not declared: an arrow after a periodic one is periodic with the same period, whatever the second arrow is.
template<HasPeriod F>
constexpr Dom< F >	dedekind::category::extent (const F &)
	Where a period's law holds: \(f(k + p) = f(k)\) for every k with k + p below the extent. A generator's law holds on the whole word; a shift narrows it, since the word does not wrap for the law.
template<HasPeriod F, IsArrow G>
constexpr Dom< F >	dedekind::category::extent (const Compose< F, G > &c)
template<IsCountWord N, typename B>
constexpr N	dedekind::category::period (const ConstantMorphism< N, B > &)
	A constant sequence, a constant arrow out of the counts: period 1, on the whole word. A constant arrow from anything else is no sequence and has no period.
template<IsCountWord N>
constexpr N	dedekind::category::period (const Congruent< N > &c)
template<IsCountWord N = std::size_t>
constexpr Congruent< N >	dedekind::category::congruent (std::type_identity_t< N > m, std::type_identity_t< N > r)
	The residue class of r modulo m.
template<IsCountWord N>
constexpr N	dedekind::category::period (const FibonacciMod< N > &f)
	The Pisano period \(\pi(m)\), the period of the Fibonacci numbers modulo m, a theorem: it exists and is at most \(6m\), so a search of that length finds it.
template<IsCountWord N = std::size_t>
constexpr FibonacciMod< N >	dedekind::category::fibonacci_mod (std::type_identity_t< N > m)
	The Fibonacci numbers modulo m.
template<IsArrow F>
constexpr Opaque< F >	dedekind::category::opaque (F f)
template<IsCountWord N = std::size_t, std::ranges::input_range R> requires std::convertible_to<std::ranges::range_value_t<R>, bool>
constexpr N	dedekind::category::count (R r)
	The count of a range of truth values: the plain fold.
template<IsCountWord N, HasPeriod F> requires std::same_as<Dom<F>, N> && std::convertible_to<Cod<F>, bool>
constexpr N	dedekind::category::count (const FiniteChainSequence< N, F > &v)
	The count along the chain of n under a periodic predicate: (n div p) periods and a remainder, by periodicity; the chain's order does not matter, since the counts commute. More specialised than the plain fold, so resolution prefers it.
template<IsCountWord N, HasPeriod F> requires std::same_as<Dom<F>, N> && std::convertible_to<Cod<F>, bool>
constexpr N	dedekind::category::count (const unfold_view< std::optional< N >, detail_chain::SliceStep< N, F > > &v)
	The count along a chain restricted by value to [lo, hi) under a periodic predicate: the law's count below hi less the law's count below lo, two calls whatever the bounds.
template<std::ranges::input_range R> requires IsCountWord<std::ranges::range_value_t<R>>
constexpr std::ranges::range_value_t< R >	dedekind::category::sum (R r)
	The sum of a range of counts: the plain fold.
template<IsCountWord N, HasPeriod F> requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, N>
constexpr N	dedekind::category::sum (const FiniteChainSequence< N, F > &v)
	The sum along the chain of n under a periodic arrow into the counts: (n div p) copies of one period's sum, one multiplication by the semimodule law, and a remainder.
template<IsCountWord N, HasUnitPeriod F> requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, N>
constexpr N	dedekind::category::sum (const FiniteChainSequence< N, F > &v)
	The sum along the chain of n under a sequence of period 1 by its type, a constant one on its extent: n copies of f(0), one multiplication by the semimodule law, and no fold at all, not even over a period of one or a remainder of none. The action of \(\mathbb{N}\) on the counts collapsing a constant, as Listing 4's concat on copies does. More specialised than the periodic sum, so resolution prefers it.
template<std::ranges::input_range R> requires detail_periodic::is_exact_count_v<std::ranges::range_value_t<R>>
constexpr std::ranges::range_value_t< R >	dedekind::category::exact_sum (R r)
	The exact sum of a range of exact counts: the plain fold, never wrapped, the discipline of exact_count.
template<IsCountWord N, HasPeriod F> requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, std::optional<N>>
constexpr std::optional< N >	dedekind::category::exact_sum (const FiniteChainSequence< N, F > &v)
	The exact sum along the chain of n under a periodic arrow into the exact counts: sum's law, checked.
template<IsCountWord N, HasUnitPeriod F> requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, std::optional<N>>
constexpr std::optional< N >	dedekind::category::exact_sum (const FiniteChainSequence< N, F > &v)
	The exact sum along a constant sequence: sum's collapse, checked.
template<IsCountWord N = std::size_t>
constexpr Shift< N >	dedekind::category::shift (std::type_identity_t< N > j)
template<IsCountWord N, HasPeriod G>
constexpr N	dedekind::category::period (const Compose< Shift< N >, G > &c)
template<IsCountWord N, HasPeriod G>
constexpr N	dedekind::category::extent (const Compose< Shift< N >, G > &c)
template<HasPeriod P, HasPeriod Q>
constexpr Dom< P >	dedekind::category::period (const Join< P, Q > &j)
template<HasPeriod P, HasPeriod Q>
constexpr Dom< P >	dedekind::category::period (const Meet< P, Q > &m)
template<HasPeriod P, HasPeriod Q>
constexpr Dom< P >	dedekind::category::extent (const Join< P, Q > &j)
template<HasPeriod P, HasPeriod Q>
constexpr Dom< P >	dedekind::category::extent (const Meet< P, Q > &m)
template<HasPeriod P>
constexpr Dom< P >	dedekind::category::period (const Not< P > &n)
template<HasPeriod P>
constexpr Dom< P >	dedekind::category::extent (const Not< P > &n)
template<detail_periodic::IsPeriodicPredicate F, std::semiregular Step, std::semiregular Acc>
constexpr Dom< F >	dedekind::category::period (const Rolling< F, Step, Acc > &r)
template<detail_periodic::IsPeriodicPredicate F, std::semiregular Step, std::semiregular Acc>
constexpr Dom< F >	dedekind::category::extent (const Rolling< F, Step, Acc > &r)
template<detail_periodic::IsPeriodicPredicate F>
constexpr Rolling< F, detail_periodic::CountStep< Dom< F > >, Dom< F > >	dedekind::category::rolling_count (F f, std::type_identity_t< Dom< F > > w)
	How many of w consecutive values are true, SQL's COUNT OVER a window.
template<detail_periodic::IsPeriodicPredicate F>
constexpr Rolling< F, detail_periodic::AnyStep, bool >	dedekind::category::rolling_any (F f, std::type_identity_t< Dom< F > > w)
	Whether any of w consecutive values is true.
template<IsCountWord N, IsArrow F, IsArrow G> requires std::same_as<Cod<F>, bool> && std::same_as<Cod<G>, bool>
constexpr auto	dedekind::category::operator* (const FiniteChainSequence< N, F > &a, const FiniteChainSequence< N, G > &b)
template<IsArrow T, std::size_t K, IsCountWord N, IsArrow G> requires std::same_as<Cod<G>, bool>
constexpr auto	dedekind::category::operator* (const Box< T, K, N > &x, const FiniteChainSequence< N, G > &b)
template<IsArrow T, std::size_t K, IsCountWord N>
constexpr std::array< N, K >	dedekind::category::count_factors (const Box< T, K, N > &b)
	Each leg's count over its chain, the factors of the box's count.
template<IsArrow T, std::size_t K, IsCountWord N>
constexpr N	dedekind::category::count (const Box< T, K, N > &b)
	The count over the box, SQL's COUNT(*) over a cross join: by distributivity the product of the legs' counts, contracting the rank-one tensor against the all-ones covector on each leg. Exact beyond the word only as its factors (count_factors); this is its residue.
template<IsArrow T, std::size_t K, IsCountWord N>
constexpr N	dedekind::category::count_section (const Box< T, K, N > &b, std::type_identity_t< N > m, std::type_identity_t< N > r)
	The count over the section \(i_1 + \cdots + i_K \equiv r \pmod m\) of the box, SQL's GROUP BY a computed key: the cyclic convolution of the legs' histograms over the residues, m numbers a leg, in the counts' semiring.
constexpr Letters	dedekind::category::letters (std::string_view alphabet)
constexpr auto	dedekind::category::abc (std::string_view a)
	The alphabet of its letters alone: the least slice of the bytes that holds them, under the predicate that keeps them, slice(lo, hi) >> letters(a) with lo the least letter and hi one past the greatest.
template<std::size_t M> requires (M >= 1)
constexpr Bytes< M - 1 >	dedekind::category::bytes (const char(&s)[M])
constexpr Ranked	dedekind::category::rank (const Letters &on)
constexpr Letters	dedekind::category::letters_of (const Alphabet &alphabet)
constexpr Ranked	dedekind::category::rank (const Alphabet &alphabet)
constexpr Reflection	dedekind::category::refl (const Letters &on)
constexpr Reflection	dedekind::category::refl (const Alphabet &alphabet)
constexpr RandomLetter	dedekind::category::random_letter (const Alphabet &alphabet, std::uint64_t seed=0)
constexpr auto	dedekind::category::random_text (const Alphabet &alphabet, std::size_t length, std::uint64_t seed=0)
template<std::size_t N>
constexpr std::array< std::byte, N >	dedekind::category::random_word (const Alphabet &alphabet, std::uint64_t seed=0)
	A random word held as a value, for a law's input where a stage wants contiguous letters.
constexpr LetterMap	dedekind::category::letter_map (std::string_view from, std::string_view to)
template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F> requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>
constexpr Power< C, F, N >	dedekind::category::power (const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > &leg, std::type_identity_t< N > n)
template<IsArrow T> requires std::same_as<Dom<T>, Cod<T>>
constexpr PowerMap< T >	dedekind::category::power (const T &tau)
template<IsCountWord N = std::size_t>
constexpr Rotation< N >	dedekind::category::rotate (std::type_identity_t< N > d)
template<IsCountWord N>
constexpr AtMost< Cycles< N >, 2 >	dedekind::category::antitone_cycle_type (N m)
	The cycle type of a finite chain's antitone bijection. A finite chain is rigid: its one antitone bijection is its reversal, the least element to the greatest and so inward, so \(\lfloor m/2 \rfloor\) pairs and, where m is odd, the middle fixed (#1133).
template<IsCountWord N>
constexpr AtMost< Cycles< N >, 2 >	dedekind::category::cycle_type (Reverse, N n)
	The cycle type of the reversal of n positions: the antitone bijection of their chain.
template<IsCountWord N>
constexpr AtMost< Cycles< N >, 1 >	dedekind::category::cycle_type (const Rotation< N > &r, N n)
	The cycle type of a rotation of n positions by d: \(g = \gcd(n, d)\) cycles of length \(n / g\), the identity where d is a multiple of n.
template<IsCountWord N>
constexpr N	dedekind::category::position (Reverse, N n, N i)
	A permutation of positions on indices: where it sends the position i of a word of length n, the reversal to \(n - 1 - i\).
template<IsCountWord N>
constexpr N	dedekind::category::position (const Rotation< N > &r, N n, N i)
template<IsArrow T> requires std::same_as<Dom<T>, std::byte> && std::same_as<Cod<T>, std::byte>
constexpr bool	dedekind::category::is_antitone (const T &t, const Letters &on)
	Whether a letter map reverses the order of an alphabet, decided on its table: the letters as bytes are a chain, and on a chain consecutive letters suffice. A law of the value, not of the type: the Watson–Crick pairing reverses A < C < G < T because of how the one-letter codes are chosen. Where it does and the map is a bijection, its cycle type is antitone_cycle_type's.
constexpr bool	dedekind::category::is_involution (const LetterMap &t)
	Whether a letter map is an involution, decided on its table: a law of the value, the 256 bytes taken twice, as a law of a finite structure is decided.
template<IsArrow T> requires std::same_as<Dom<T>, Cod<T>>
constexpr bool	dedekind::category::is_involution (const PowerMap< T > &p)
	A map on every letter is an involution where the map on one is.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires HasCycleType<S, N>
constexpr Symmetric< Power< C, F, N >, S, Identity< C > >	dedekind::category::symmetric (const Power< C, F, N > &p, S sigma)
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires HasCycleType<S, N>
constexpr Symmetric< Power< C, F, N >, S, Identity< C > >	dedekind::category::symmetric (const Power< C, F, N > &p, const Morphism< std::vector< C >, std::vector< C >, S > &sigma)
template<HasNNOStep C, IsArrow F, IsCountWord N, IsArrow T, typename S> requires std::same_as<Dom<T>, C> && HasCycleType<S, N>
constexpr Symmetric< Power< C, F, N >, S, T >	dedekind::category::symmetric (const Power< C, F, N > &p, const Compose< PowerMap< T >, Morphism< std::vector< C >, std::vector< C >, S > > &g)
template<HasNNOStep C, IsArrow F, IsCountWord N, IsArrow T, typename S> requires std::same_as<Dom<T>, C> && HasCycleType<S, N>
constexpr Symmetric< Power< C, F, N >, S, T >	dedekind::category::symmetric (const Power< C, F, N > &p, const Compose< Morphism< std::vector< C >, std::vector< C >, S >, PowerMap< T > > &g)
template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F> requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>
constexpr Powers< C, F, N >	dedekind::category::words (const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > &leg)
template<IsArrow T, typename C, typename S>
constexpr detail_periodic::FixedByStage< S, T >	dedekind::category::fixed_by (const Compose< PowerMap< T >, Morphism< std::vector< C >, std::vector< C >, S > > &g)
template<IsArrow T, typename C, typename S>
constexpr detail_periodic::FixedByStage< S, T >	dedekind::category::fixed_by (const Compose< Morphism< std::vector< C >, std::vector< C >, S >, PowerMap< T > > &g)
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T> requires std::same_as<Dom<T>, C> && HasCycleType<S, N>
constexpr auto	dedekind::category::operator>> (const Powers< C, F, N > &ps, const detail_periodic::FixedByStage< S, T > &st)
	The powers, then the sections each fixes: a family of sets of words by length, words(Σ) >> fixed_by(g).
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T> requires std::same_as<Dom<T>, C> && HasCycleType<S, N>
constexpr auto	dedekind::category::operator& (const Powers< C, F, N > &ps, const detail_periodic::FixedByStage< S, T > &st)
	words(Σ) & fixed_by(g): the words g fixes, by length, the same family spelled as Trsk spells a set under a predicate.
template<IsCountWord N = std::size_t>
constexpr Length< N >	dedekind::category::len (std::type_identity_t< N > n)
template<IsArrow Fam, IsCountWord N> requires is_graded_v<Fam> && std::same_as<Dom<Fam>, N>
constexpr Cod< Fam >	dedekind::category::operator& (const Fam &fam, Length< N > l)
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T> requires std::same_as<Dom<T>, C> && HasCycleType<S, N>
constexpr Symmetric< Power< C, F, N >, S, T >	dedekind::category::operator& (const Power< C, F, N > &p, const detail_periodic::FixedByStage< S, T > &st)
	power(Σ, n) & fixed_by(g): the power met with what g fixes, symmetric(power, g) spelled as Trsk spells a set under a predicate. The equalizer of g and the identity, a subobject of the power, and one the laws count: from g's cycle type, no word built.
constexpr ReflectedReverse	dedekind::category::operator~ (Reverse)
constexpr detail_periodic::FixedByReflectedReverse	dedekind::category::fixed_by (ReflectedReverse)
template<IsCountWord N>
constexpr Symmetric< Power< std::byte, Letters, N >, Reverse, Reflection >	dedekind::category::operator& (const Power< std::byte, Letters, N > &p, detail_periodic::FixedByReflectedReverse)
	power & fixed_by(~rev): the words the reverse complement fixes, the complement the power's own, refl of its letters.
template<IsCountWord N>
constexpr auto	dedekind::category::operator& (const Powers< std::byte, Letters, N > &ps, detail_periodic::FixedByReflectedReverse)
	words(Σ) & fixed_by(~rev): the same, by length.
template<HasFactors A, HasFactors B> requires std::same_as< detail_periodic::word_of_t<decltype(count_factors(std::declval<A>()))>, detail_periodic::word_of_t<decltype(count_factors(std::declval<B>()))>>
constexpr Outer< A, B >	dedekind::category::operator* (const A &a, const B &b)
template<HasFactors A, HasFactors B> requires std::same_as< detail_periodic::word_of_t<decltype(count_factors(std::declval<A>()))>, detail_periodic::word_of_t<decltype(count_factors(std::declval<B>()))>>
constexpr auto	dedekind::category::count_factors (const Outer< A, B > &o)
template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F> requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>
constexpr FreeMonoid< C, F, N >	dedekind::category::free_monoid (const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > &leg, std::type_identity_t< N > below)
template<typename L, IsCountWord N = detail_periodic::word_of_t<L>> requires detail_periodic::IsFactorsOf<L, N>
constexpr N	dedekind::category::count (const L &fs)
	The count of a factored tensor, modulo the word: a monoid concat under * over the factors, each a concat on copies of a popcount, by squaring. Agrees with exact_count wherever the word holds the count.
template<typename L, IsCountWord N = detail_periodic::word_of_t<L>> requires detail_periodic::IsFactorsOf<L, N>
constexpr std::optional< N >	dedekind::category::exact_count (const L &fs)
	The count of a factored tensor, exactly, or none where the word cannot hold it: never wrapped, the discipline of checked_lcm.
template<typename L, IsCountWord N = detail_periodic::word_of_t<L>> requires detail_periodic::IsFactorsOf<L, N>
constexpr std::size_t	dedekind::category::bits_needed (const L &fs)
	The bits a count needs at most, read off its factors without multiplying them: \(\prod b_i^{e_i} \le 2^S\) with \(S = \sum e_i \lceil \log_2 b_i \rceil\), so at most \(S + 1\) bits, S + 1 exactly where the product is \(2^S\); none for an empty factor; saturating. The same fold as count, in the other monoid: count folds \(b^e\) by \(\times\), this folds its image under CeilLog2 by \(+\), and the lax homomorphism between them is the bound. An abstract interpretation (Cousot and Cousot): the abstraction of a Galois connection between sets of values and their widths (IsGaloisConnection), sound by the adjunction. \(\mathbb{N}\) is the filtered colimit of the words \(\mathbb{N}_{<2^8} \hookrightarrow \mathbb{N}_{<2^{16}} \hookrightarrow \cdots\) (:filtered), and a finite count is compact, so it factors through a finite stage: this says which, before the count is computed (#1134).
template<HasNNOStep C, IsArrow F, IsCountWord N>
constexpr std::optional< N >	dedekind::category::exact_count (const FreeMonoid< C, F, N > &m)
constexpr auto	dedekind::category::bit_patterns (std::size_t n)
	The bit patterns of width n as a chain: the counts below \(2^n\), which binary numeration makes the words of \(\mathbb{B}^n\), bit i the letter at position i. No pattern is built: an arrow along the chain reads it. Refused past the word, where the patterns are no sequence a std::size_t can index. Counting by the laws never builds a pattern at any width; a pattern is packed only where an operation reads it, at any width known at compile time, and at run time up to max_packed_width (wider, in blocks, is #1109).
template<typename F> requires std::invocable<const F&, std::integral_constant<std::size_t, 8>>
constexpr auto	dedekind::category::with_width (std::size_t n, const F &f)
	A width known only at run time, dispatched to the narrowest precompiled bit word that holds it: 8, 16, 32 or 64 bits, a machine word, or 128, 256 or 512, a std::bitset. f is called with the width as a type, so it can name BitWord of it. Refused past max_packed_width.
template<std::unsigned_integral B> requires (!std::same_as<B, bool>)
constexpr std::size_t	dedekind::category::popcount (B x)
	The number of bits set in a machine word: the hardware's count, one instruction where the target has it.
template<std::size_t W>
constexpr std::size_t	dedekind::category::popcount (const std::bitset< W > &x)
	The number of bits set in a std::bitset.
template<HasNNOStep C, IsArrow F, IsCountWord N>
constexpr AtMost< Factor< N >, 1 >	dedekind::category::count_factors (const Power< C, F, N > &p)
	The factors of a tensor power's count: the filtered alphabet's count, its packed characteristic function's popcount, raised to the length, by the box law.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T> requires HasCycleType<S, N>
constexpr auto	dedekind::category::count_factors (const Symmetric< Power< C, F, N >, S, T > &s)
	The factors of a symmetric section's count: one merged leg per cycle of sigma, so the box law after the merges, the count Pólya's theorem gives for the words a permutation fixes.
template<IsCountWord N = std::size_t>
constexpr Window< N >	dedekind::category::window (std::type_identity_t< N > offset, std::type_identity_t< N > length)
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; } && std::equality_comparable<F>
constexpr Cylinder< Power< C, F, N >, S, N >	dedekind::category::cylinder (const Power< C, F, N > &p, Window< N > w, S s)
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires requires(const S& s) { requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; }
constexpr auto	dedekind::category::pushed_down (const Cylinder< Power< C, F, N >, S, N > &c)
	The plan of a cylinder, its selection pushed down. A cylinder in Tarski's sense, a predicate on a product in which only some legs constrain: the window's legs must lie in the set, the others are free. So the predicate moves onto the window's factor, \(\sigma_\varphi(W \times F) = \sigma_\varphi(W) \times F\), and the cylinder is the set times the power on the free legs, an outer product, whatever the window's offset. Defined where the window fits.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires requires(const S& s) { requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; }
constexpr auto	dedekind::category::count_factors (const Cylinder< Power< C, F, N >, S, N > &c)
	The factors of a cylinder's count, aggregate pushdown (eager aggregation: Yan and Larson, VLDB 1995), derived rather than stated: the selection pushed down (pushed_down), then the box law of the outer product, the set's count times \(|\Sigma|^{N - n}\) for the free legs. Empty where no word's window can lie in the set: a window past the end, or a set of words of another length.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; } && std::equality_comparable<F>
constexpr N	dedekind::category::occurrences (const Power< C, F, N > &p, const S &s)
	How often a set of words occurs in the words of a tensor power, counted with their positions: the pairs (word, offset) whose window lies in s, the sum over the offsets of the cylinders' counts, modulo the word. Each summand is pushed down (R2), so none depends on its offset: the summand has period 1, and the periodic sum takes one of them, times the number of offsets.
template<HasNNOStep C, IsArrow F, IsCountWord N, typename S> requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; } && std::equality_comparable<F>
constexpr std::optional< N >	dedekind::category::exact_occurrences (const Power< C, F, N > &p, const S &s)
	The occurrences exactly, or none where the word cannot hold them: never wrapped, the discipline of exact_count.
template<typename T, typename Rel = std::less_equal<T>, typename L = Boole, typename Project = std::identity> requires IsPathProjection<Project, T, Rel, typename L::Ω>
constexpr L::Ω	dedekind::category::check_path (T a, T b, T c, Project project={})
	Verify that a two-step path A→B→C exists in the posetal category.
template<typename Whole> requires requires { arrow_drill_down(whole).min; }
constexpr auto	dedekind::category::arrow_drill_down_min (const Whole &whole)
	Opt-in drill-down projector for min/max result carriers.
constexpr Ternary	dedekind::category::monotone (ArrowLaws p)
	What a profile says about monotonicity: the law read off the fold's result, in K₃ (True where certified, Unknown where not).
constexpr Ternary	dedekind::category::infer (ArrowLaw w, ArrowNode n, const ArrowLaws &a, const ArrowLaws &b)
	The engine at one law: a former's answer from its legs' profiles, their laws combined by the chain's own Inf (both legs) and Sup (either leg). The facts, each a theorem about functions:
constexpr ArrowLaws	dedekind::category::saturated (ArrowLaws p)
	Entailment, a closure operator on profiles: an involution is its own inverse, so a bijection. Nothing is entailed about a constant arrow's variance here: it is monotone and antitone under a reflexive order and neither under a strict one, and a profile is read under an arbitrary order; the typed reader has the fact where the order is in reach (:total). Nor the converse, monotone and antitone entailing constant, which holds on a connected domain only. The engine applies the entailment to values; a typed arrow already has it through the iso hook (:involution).
constexpr ArrowLaws	dedekind::category::without_variance (ArrowLaws p)
	The laws that do not depend on an order: a profile read under an order the former's variance facts are not about.
constexpr ArrowLaws	dedekind::category::arrow_node (ArrowNode n, const ArrowLaws &a, const ArrowLaws &b)
	The engine at a former, law by law, its legs and its answer saturated.
template<typename F, typename Op>
constexpr ArrowLaws	declared_arrow_laws ()
	The profile of a typed arrow, its variances under Op. Read off the concepts (an iso, hence an involution, is already monic and epic).
template<IsArrow F>
constexpr bool	dedekind::category::is_identity (const F &)
	The laws of an arrow asked on its value (the Jlt paper's Listing 1): each reads, at compile time, the registration its concept reads, so is_monic(f) is IsMonicArrow<F> at the value's type, and a composite's law comes through the readers above. A concept gates a template, a predicate states a fact; both read one registration.
template<IsArrow F>
constexpr bool	dedekind::category::is_constant (const F &)
template<IsArrow F>
constexpr bool	dedekind::category::is_monic (const F &)
template<IsArrow F>
constexpr bool	dedekind::category::is_epic (const F &)
template<IsArrow F>
constexpr bool	dedekind::category::is_iso (const F &)
template<IsArrow F>
constexpr bool	dedekind::category::is_involution (const F &)
template<IsArrow F, IsArrow G> requires commutes_v<F, G>
constexpr bool	dedekind::category::is_involution (const Compose< F, G > &c)
	A composite of two commuting involutions is one, \((g f)^2 = g g f f = \mathrm{id}\), its law derived from its legs' (commutes, :involution); where the legs do not commute, the reading above decides, and - after ~ is none.
template<IsArrow F, typename Op = std::less_equal<>>
constexpr bool	dedekind::category::is_monotone (const F &, Op={})
template<IsArrow F, typename Op = std::less_equal<>>
constexpr bool	dedekind::category::is_antitone (const F &, Op={})
template<IsArrow F> requires std::unsigned_integral<Cod<F>> && (!std::same_as<Cod<F>, bool>)
constexpr auto	dedekind::category::operator~ (const F &f)
	The involutions of a codomain, pointwise on the arrows into it: ~f and -f are f then the reflection of the chain, respectively unary minus, (-f)(x) = -f(x) as for functions in analysis; on an identity the composite is the involution itself (the unit law, :morphism). !f, for the arrows into a truth object, is in :topoi. Unsigned only: -INT_MIN is not a function on int (:involution); and not bool, which C++ counts as unsigned, so a set's characteristic arrow keeps the complement of :sets.
template<IsArrow F> requires std::unsigned_integral<Cod<F>> && (!std::same_as<Cod<F>, bool>)
constexpr auto	dedekind::category::operator- (const F &f)
template<typename L, typename Π, typename F, typename G> requires IsOckhamAlgebra<L> && IsArrow<F> && IsArrow<G> && IsProduct<Π, Dom<F>, Dom<G>> && std::same_as<Cod<F>, Cod<G>> && std::equality_comparable<Cod<F>>
constexpr auto	make_χ (F f, G g)
	The Characteristic Morphism χ: (X × Y) ⟶ Ω.
template<typename L = Boole, typename Π, typename F_Raw, typename G_Raw>
constexpr auto	dedekind::category::pullback (F_Raw f_raw, G_Raw g_raw)
	The Pullback Factory — constructs the Fiber Product X ×_Z Y.
template<typename S> requires IsSubobject<std::remove_cvref_t<S>, typename std::remove_cvref_t<S>::Domain>
constexpr SubobjectInclusion< std::remove_cvref_t< S > >	dedekind::category::inclusion_arrow (const S &s)
template<typename S> requires IsSubobject<S, typename S::Domain>
constexpr ClassifierApex< S >	dedekind::category::as_classified (const S &s)
template<std::size_t K, IsCountWord N> requires (K >= 2)
constexpr RunList< N, K >	dedekind::category::run (N lo, std::type_identity_t< N > hi)
template<typename T>
constexpr auto	dedekind::category::reduced (const T &t)
template<IsCountWord N, std::size_t J, std::size_t K>
constexpr RunList< N, J+K >	dedekind::category::operator| (const RunList< N, J > &a, const RunList< N, K > &b)
	The union of two run lists, at once: the lattice's Join node folded by the one reducer, the sweep its leaf-combine, as the set grammar's | folds through SetCombine (sets). Its bound is the sum of theirs. The strict form; the lazy one is the node itself, built and reduced later, as the predicates that opt in to :lattice's | keep it (#1138).
template<IsCountWord N, std::size_t J, std::size_t K>
constexpr RunList< N, J+K >	dedekind::category::operator& (const RunList< N, J > &a, const RunList< N, K > &b)
	The intersection, dual to the union; with a single run, by law a restriction.
template<std::size_t K, IsCountWord N, typename Pred> requires std::predicate<const Pred&, N>
constexpr Maybe< RunList< N, K > >	dedekind::category::run_list (N end, Pred holds)
	The run list of a predicate on \([0, \mathit{end})\): every count tested once, a step where the value changes.
template<IsCountWord N, std::size_t J, std::size_t K>
constexpr auto	dedekind::category::as_pullback (const RunList< N, J > &a, const RunList< N, K > &b)
	The intersection as the pullback of the two inclusions into the counts, category's apex view over it (IsPullback): in the thin category of run lists, the meet is the pullback.
template<IsCountWord N, std::size_t J, std::size_t K>
constexpr auto	dedekind::category::as_pushout (const RunList< N, J > &a, const RunList< N, K > &b)
	The union as the pushout, dual to as_pullback (IsPushout).
template<std::size_t K, IsCountWord N, std::size_t J>
constexpr Maybe< RunList< N, K > >	dedekind::category::narrowed (const RunList< N, J > &r)
	A run list under a bound claimed, not proved by the types: the same set where its steps fit, nothing where they do not.
template<IsCountWord N, std::size_t K>
constexpr RunList< N, K >	dedekind::category::preimage (const Shift< N > &t, const RunList< N, K > &s)
	preimage(shift(d), s): the pullback of s along the translation, \(x \mapsto s(x + d)\), in closed form, a run list again: the closed-form overload of :morphism's preimage(f, P), whose general form is the composite P∘f, as algebra's halfspace_transport gives one for an interval. The translation is read as a map of the chain, on its extent: the counts \(x\) with \(x + d\) below the word's top (extent in :periodic, where a shift's law holds), where the word does not wrap. halfspace_transport gates the same reading by the carrier's type (an ordered group, or ℕ, where \(x + k\) misses \(\{0, \ldots, k - 1\}\)); on the word, Pst's carrier, the extent is that gate, by value. The elements of s below d, whose preimages would wrap past the top, lie outside it and are not reported; the derivative (:automaton) meets its operand with the letter's interval first, so none exist there. The other reading, the word as the cyclic group \(\mathbb{Z}/2^w\) whose translation wraps, is order's translate (an image, a run through the end splitting in two) and morphologies' congruence preimage; it is a different arrow, and not this one (#1138).
template<IsCountWord N, std::size_t K>
constexpr RunList< N, K >	dedekind::category::operator>> (const Shift< N > &t, const RunList< N, K > &s)
	shift(d) >> s, the spelling of the preimage: precomposition with the translation.
template<typename T, IsArrow G> requires std::same_as<T, Dom<G>>
constexpr auto	dedekind::category::operator>> (Identity< T >, G g)
template<IsArrow F, typename T> requires std::same_as<Cod<F>, T>
constexpr auto	dedekind::category::operator>> (F f, Identity< T >)
template<typename T>
constexpr auto	dedekind::category::operator>> (Identity< T > i, Identity< T >)
template<typename T, typename Op> requires requires { unit_trait<T, Op>::value; }
constexpr T	dedekind::category::unit (Op)
	The unit of Op at the carrier T, read as unit<T>(Op{}).
template<std::integral 𝒯>
constexpr 𝒯	inverse (𝒯 a, std::bit_xor< 𝒯 >)
	In XOR, every element is its own inverse (Involutive).
template<std::integral 𝒯>
constexpr 𝒯	inverse (𝒯 a, std::plus< 𝒯 >)
	In Addition, negation is the inverse (Two's Complement wrapping).
template<typename T, typename Op> requires requires(T a) { { inverse(a, Op{}) } -> std::same_as<T>; }
constexpr T	dedekind::category::inverse_v (T a)
	The Master Bridge: Routes the request to specific implementations.
template<typename T, typename Op>
constexpr bool	dedekind::category::associative (Op)
	The laws as functions of the operation: associative<T>(Op{}), commutative<T>(Op{}), idempotent<T>(Op{}) and distributive<T>(Mul{}, Add{}).
template<typename T, typename Op>
constexpr bool	dedekind::category::commutative (Op)
template<typename T, typename Op>
constexpr bool	dedekind::category::idempotent (Op)
template<typename T, typename Mul, typename Add>
constexpr bool	dedekind::category::distributive (Mul, Add)
template<typename OmegaTarget, typename L, typename Constant> requires std::same_as<std::remove_cvref_t<Constant>, OmegaTarget> || requires(const std::remove_cvref_t<Constant>& c) { { lift_logic<L>(c) } -> std::same_as<OmegaTarget>; }
constexpr auto	lift_classifier_constant (Constant value)
	Lift a classifier constant into a predicate's Ω: the identity when it is already there, else the dominance lift lift_logic into the predicate's species L (true into Ternary, Ternary::Unknown into Percentage, true onto Chain<int>'s top, ...). The species is passed, not read off OmegaTarget, so a species-tagged predicate whose Ω is no truth object on its own (int) still lifts. Constrained, so a pair with no registered embedding fails the combinators' gate, not this body.
template<typename A, typename F> requires (!IsArrow<std::remove_cvref_t<F>>) && std::invocable<std::decay_t<F>, const A&> && IsΩ<std::invoke_result_t<std::decay_t<F>, const A&>>
constexpr auto	dedekind::category::classify (F f)
	Characteristic Morphism Factory (classify) Returns the Subobject Species (The Body) carrying the rule (The Arrow).
template<typename F> requires (!IsArrow<std::remove_cvref_t<F>>) && requires { typename signature_extractor<std::decay_t<F>>::type; } && IsΩ<codomain_t<std::decay_t<F>>>
constexpr auto	dedekind::category::classify (F f)
	Domain-inferring classify: deduces A from the callable's signature.
template<typename A, IsArrow F> requires IsPredicate<F> && std::same_as<Dom<F>, A>
constexpr auto	dedekind::category::classify (F f)
	Idempotent classify: Passthrough for existing Arrows.
template<typename P, typename Q> requires IsPredicatePair<P, Q>
constexpr auto	dedekind::category::operator&& (P p, Q q)
	Logical Conjunction (Intersection): Synthesizes a rule for A ∩ B.
template<IsClassifierConstant C, IsPredicate P> requires (!IsPredicate<std::remove_cvref_t<C>>) && requires(C c) { lift_classifier_constant<Cod<P>, predicate_logic_t<P>>(c); }
constexpr auto	dedekind::category::operator&& (C constant, P p)
	Conjunction of a constant logical value with a predicate.
template<IsPredicate P, IsClassifierConstant C> requires (!IsPredicate<std::remove_cvref_t<C>>) && requires(C c) { lift_classifier_constant<Cod<P>, predicate_logic_t<P>>(c); }
constexpr auto	dedekind::category::operator&& (P p, C constant)
	Conjunction of a predicate with a constant logical value.
template<typename P, typename Q> requires IsPredicatePair<P, Q>
constexpr auto	dedekind::category::operator|| (P p, Q q)
	Logical Disjunction (Union): Synthesizes a rule for A ∪ B.
template<IsClassifierConstant C, IsPredicate P> requires (!IsPredicate<std::remove_cvref_t<C>>) && requires(C c) { lift_classifier_constant<Cod<P>, predicate_logic_t<P>>(c); }
constexpr auto	dedekind::category::operator|| (C constant, P p)
	Disjunction of a constant logical value with a predicate.
template<IsPredicate P, IsClassifierConstant C> requires (!IsPredicate<std::remove_cvref_t<C>>) && requires(C c) { lift_classifier_constant<Cod<P>, predicate_logic_t<P>>(c); }
constexpr auto	dedekind::category::operator|| (P p, C constant)
	Disjunction of a predicate with a constant logical value.
template<IsPredicate P>
constexpr auto	dedekind::category::operator! (P p)
	Logical Negation (Complement): Synthesizes a rule for ¬A.
template<typename A, typename P, typename Q> requires std::invocable<const std::decay_t<P>&, const A&> && std::invocable<const std::decay_t<Q>&, const A&> && IsΩ<std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>> && std::same_as< std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>, std::remove_cvref_t< std::invoke_result_t<const std::decay_t<Q>&, const A&>>>
constexpr auto	dedekind::category::predicate_and (P p, Q q)
	Compose two plain callable predicates over a declared domain A.
template<typename A, typename P, typename Q> requires std::invocable<const std::decay_t<P>&, const A&> && std::invocable<const std::decay_t<Q>&, const A&> && IsΩ<std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>> && std::same_as< std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>, std::remove_cvref_t< std::invoke_result_t<const std::decay_t<Q>&, const A&>>>
constexpr auto	dedekind::category::predicate_or (P p, Q q)
	Disjunction bridge for plain callable predicates over domain A.
template<typename A, typename P> requires std::invocable<const std::decay_t<P>&, const A&> && IsΩ<std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>>
constexpr auto	dedekind::category::predicate_not (P p)
	Negation bridge for plain callable predicates over domain A.
template<typename A, typename L = Boole> requires IsOckhamAlgebra<L>
constexpr auto	dedekind::category::constant_classifier (typename L::Ω value)
	Constant classifier factory over domain A: A -> Ω.
template<typename A, typename L = Boole> requires IsOckhamAlgebra<L>
constexpr auto	dedekind::category::classifier_true ()
	The tautology / top predicate \(\top\) over domain A: the canonical always-true classifier A → Ω, constant at L::True. This is the topos truth arrow \(\top: 1 \to \Omega\) pulled back to a predicate on A (verum, "everything is a member"); use it wherever a whole-domain / unrestricted characteristic map is wanted rather than an ad-hoc [](const A&){ return true; } lambda.
template<typename A, typename L = Boole> requires IsOckhamAlgebra<L>
constexpr auto	dedekind::category::classifier_false ()
	The contradiction / bottom predicate \(\bot\) over domain A: the canonical always-false classifier A → Ω, constant at L::False (falsum, "nothing is a member"). Dual of classifier_true.
template<typename A, typename L = Kleene> requires IsOckhamAlgebra<L> && requires { L::Unknown; }
constexpr auto	dedekind::category::classifier_unknown ()
	Default unknown classifier over domain A (only for logics with Unknown).
template<typename L = Boole> requires IsOckhamAlgebra<L>
constexpr auto	dedekind::category::logical_true ()
	The 'true' morphism: 1 → Ω.
template<typename L = Boole> requires IsOckhamAlgebra<L>
constexpr auto	dedekind::category::logical_false ()
	The 'false' morphism: 1 → Ω.
template<typename A, typename B, typename Op = std::plus<B>> requires IsPointed<B, Op>
constexpr auto	dedekind::category::zero ()
	zero<A, B, Op>(): the constant morphism A → B that maps everything to the Op-identity element of B. Defaults to std::plus (additive identity, i.e. zero); with std::multiplies it is the constant at one.
template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>> requires IsMonoid<T, Op>
constexpr T	dedekind::category::concat (R r, Op op={})
	The free monoid's fold, concat, the canonical fold of a monoid: a range folded under the operation from its unit (the Jlt paper's Listings 2 to 4). Its specialisation, licensed by associativity, folds n copies of one value, any IsCopies range, by the binary method, one squaring per bit of n (Knuth, TAOCP 2 §4.6.3). Resolution picks it over the plain fold, its parameter being the more specific.
template<IsCountWord N, IsConstantArrow F>
constexpr N	dedekind::category::copies_count (const unfold_view< N, Mapped< N, StepCoalgebra< N, Prior< N > >, F > > &r)
	The counting chain of n under a constant arrow, n >> chain<N>() >> constant(x), is n copies of x, counted in the chain's own word.
template<IsCountWord N, IsConstantArrow F>
constexpr Cod< F >	dedekind::category::copies_value (const unfold_view< N, Mapped< N, StepCoalgebra< N, Prior< N > >, F > > &r)
template<std::copy_constructible T, std::integral B> requires (!std::same_as<B, bool>)
constexpr std::make_unsigned_t< B >	dedekind::category::copies_count (const std::ranges::repeat_view< T, B > &r)
	The standard's views::repeat(x, n) is n copies of x; its value is read only where n is not zero.
template<std::copy_constructible T, std::integral B> requires (!std::same_as<B, bool>)
constexpr T	dedekind::category::copies_value (const std::ranges::repeat_view< T, B > &r)
template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>> requires IsMonoid<T, Op> && IsCopies<R>
constexpr T	dedekind::category::concat (R r, Op op={})
	concat on n copies of one value: its n-th power, by squaring its first half, licensed by associativity. The same signature as the plain fold and a stronger constraint, so resolution prefers it wherever IsCopies holds. The value is read only where there is a copy, as a model promises it.
template<typename A, typename Chi>
constexpr auto	dedekind::category::universe (const Subobject< A, Chi > &)
template<typename A, typename Chi>
constexpr const Subobject< A, Chi > &	dedekind::category::classifier (const Subobject< A, Chi > &s)
template<typename A> requires requires(const A& a) { universe(a); }
constexpr auto	dedekind::category::universe (const Not< A > &n)
template<typename A>
constexpr const Not< A > &	dedekind::category::classifier (const Not< A > &n)
template<typename A, typename B> requires requires(const A& a) { universe(a); }
constexpr auto	dedekind::category::universe (const Meet< A, B > &m)
template<typename A, typename B>
constexpr const Meet< A, B > &	dedekind::category::classifier (const Meet< A, B > &m)
template<typename A, typename B> requires requires(const A& a) { universe(a); }
constexpr auto	dedekind::category::universe (const Join< A, B > &j)
template<typename A, typename B>
constexpr const Join< A, B > &	dedekind::category::classifier (const Join< A, B > &j)
template<>
constexpr SignedCardinality	lift< Cardinality, SignedCardinality > (Cardinality const &n)
template<IsArrow F, IsArrow G>
constexpr SumArrow< F, G >	operator+ (const F &f, const G &g)
template<IsArrow F> requires std::unsigned_integral<Cod<F>> && (!std::same_as<Cod<F>, bool>)
constexpr auto	operator- (const F &f)
constexpr 𝔽64	operator* (bool s, 𝔽64 v) noexcept
	Scalar action of \(\mathbb{F}_2\) (witnessed on bool) on 𝔽64, via the natural embedding \(\mathbb{F}_2 \hookrightarrow \mathbb{F}_{64}\) ( \(0 \mapsto 0\), \(1 \mapsto 1\)).
constexpr Cardinality	operator/ (const Cardinality &lhs, const Cardinality &rhs) noexcept
	Euclidean division on Cardinality. Convention follows the ExtensionalCardinal<> totalisation: division by zero yields zero; finite / ℵ_0 yields zero (the limit); ℵ_0 / finite-non-zero yields ℵ_0; ℵ_0 / ℵ_0 yields ℵ_0 (saturation rather than indeterminate — Cardinality has no NaZ-equivalent sentinel; the ℕ proxy keeps the policy total).
constexpr Cardinality	operator% (const Cardinality &lhs, const Cardinality &rhs) noexcept
	Euclidean remainder on Cardinality. Mirrors the operator/ convention: finite % finite delegates to the underlying ExtensionalCardinal<>'s %; finite % ℵ_0 returns the lhs (the limit-style "remainder is the original" reading); operations with ℵ_0 on the lhs saturate to ℵ_0.
template<typename A, typename B> requires requires { typename A::Domain; typename B::Domain; } && std::same_as<typename A::Domain, typename B::Domain> && (!IsBoundaryObject<A>) && (!IsBoundaryObject<B>) && IsStepTerm<A> && IsStepTerm<B> && std::same_as<typename A::logic_species, typename B::logic_species>
constexpr auto	operator== (const A &a, const B &b)
	Equality of two set terms of a chain as sets of the carrier, in the species: one traversal of their normal forms, so it is extensional ((0, 3) and [1, 3) are the same set of ℤ).
template<typename A, typename B> requires TermOperands<A, B>
constexpr auto	operator!= (A a, B b)
template<typename A, typename B> requires HasProperSubset<A, B>
constexpr A::logic_species::Ω	operator< (const A &a, const B &b)
template<typename A, typename B> requires DecidableMeetSubset<A, B>
constexpr A::logic_species::Ω	operator<= (const A &a, const B &b)
	\(A \subseteq B \iff A \cap B = A\) — the generic identity. More-specialized per-carrier <= (Set / Ø / 𝔸, the Singleton membership and Interval endpoints below) win by partial ordering; this fills the gaps (Halfspace ⊆ Halfspace).
template<typename A, typename B> requires HasProperSubset<B, A>
constexpr A::logic_species::Ω	operator> (const A &a, const B &b)
template<typename A, typename B> requires HasSubset<B, A>
constexpr A::logic_species::Ω	operator>= (const A &a, const B &b)
	Superset, proper subset, proper superset — each once from <= and ==, gated on HasSubset so they ride any decidable <= (generic or specialised). Together they supply HasPartialOrderOperators.
reduce_β for a Compose node — the canonical β exhibit
reduce_β is the β (F-algebra structure map, i.e. the one-step β-reduction) that cata applies after folding a node's legs. This overload set is the canonical exhibit: the reducer's first law, the monoid law of composition, co-located with the cata engine. The identity is the unit (id∘f = f = f∘id), so an Identity in a reduced leg is dropped. Dispatch is structural on Identity<T> in the reduced leg (no is-identity tag): the overloads pattern-match the leg types, and partial ordering picks the Identity ones over the generic IsArrow one. The first parameter is the Compose node as a type-tag for β dispatch (which constructor is this?); its own legs are unused — cata passes the already-reduced legs rf / rg, which is what β combines. Found by ADL, so a partition MAY instead scatter its node's reduce_β next to that node's vocabulary; the composition law lives here as the reference instance.
template<IsArrow F, IsArrow G, IsArrow RF, IsArrow RG>
constexpr auto	dedekind::category::reduce_β (const Compose< F, G > &, const RF &rf, const RG &rg)
template<IsArrow F, IsArrow G, typename T, IsArrow RG>
constexpr RG	dedekind::category::reduce_β (const Compose< F, G > &, const Identity< T > &, const RG &rg)
template<IsArrow F, IsArrow G, IsArrow RF, typename T>
constexpr RF	dedekind::category::reduce_β (const Compose< F, G > &, const RF &rf, const Identity< T > &)
template<IsArrow F, IsArrow G, typename T, typename U>
constexpr Identity< T >	dedekind::category::reduce_β (const Compose< F, G > &, const Identity< T > &i, const Identity< U > &)
template<typename F, typename G, typename RF, typename RG>
constexpr auto	dedekind::category::reduce_β (const Pairing< F, G > &, const RF &rf, const RG &rg)
	A pairing (copairing) rebuilt from its reduced legs: inert.
template<typename F, typename G, typename RF, typename RG>
constexpr auto	dedekind::category::reduce_β (const Copairing< F, G > &, const RF &rf, const RG &rg)
The legs of a node, for @c cata (@c :f_algebra)
The term functor stated once per node: the operands, by reference.
template<typename A, typename B>
constexpr auto	dedekind::category::legs (const Meet< A, B > &m)
template<typename A, typename B>
constexpr auto	dedekind::category::legs (const Join< A, B > &j)
template<typename A>
constexpr auto	dedekind::category::legs (const Not< A > &n)

Variables
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)> >
template<>
constexpr bool	is_embedding_functor_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)> > = true
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)>, std::less_equal<> >
template<typename G, typename Op>
constexpr bool	is_antimonotone_v< dedekind::algebra::Inverse< G, std::plus< G > >, Op > = true
	The additive group inverse Inverse<G, +> is antitone exactly on an ordered additive group (translation invariance is the hypothesis of the -b≤-a step), so the registration is gated on IsOrderedAdditiveGroup — the algebraic dog-food of the antitone reification (#959).
template<>
constexpr bool	is_adjoint_v< dedekind::algebra::AdditiveInverse< dedekind::sets::SignedCardinality >, dedekind::algebra::AdditiveInverse< dedekind::sets::SignedCardinality >, std::less_equal<> > = true
	The theorem: an antitone involution is self-adjoint, \(a \le -b \iff b \le -a\). The law leg of the witness below.
template<std::size_t N>
constexpr bool	is_reflexive_v< dedekind::algebra::Monomial< N >, std::less_equal<> > = true
template<std::size_t N>
constexpr bool	is_transitive_v< dedekind::algebra::Monomial< N >, std::less_equal<> > = true
template<std::size_t N>
constexpr bool	is_antisymmetric_v< dedekind::algebra::Monomial< N >, std::less_equal<> >
template<std::size_t N>
constexpr bool	is_connex_v< dedekind::algebra::Monomial< N >, std::less_equal<> > = true
template<std::size_t N>
constexpr bool	is_associative_v< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > > = true
template<std::size_t N>
constexpr bool	is_commutative_v< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > > = true
template<typename S, typename A, typename Op>
constexpr bool	dedekind::category::is_closed_under_v = false
	User-declared closure witness: subobject S of A is closed under operation Op.
template<typename T>
constexpr bool	is_distributive_v< T, std::multiplies< T >, std::plus< T > >
template<typename T, bool M>
constexpr bool	is_distributive_v< dedekind::algebra::Tropical< T, M >, std::plus< dedekind::algebra::Tropical< T, M > >, dedekind::algebra::TropicalPlus > = true
	⊗ distributes over ⊕.
template<typename F>
constexpr bool	is_invertible_v< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::analysis::embed_ℝ_𝔻)> >
template<typename M, typename S, typename AddM, typename AddS, typename MultS, typename Act>
constexpr bool	dedekind::category::is_linear_action_v
	Value form of is_linear_action.
template<typename F, typename G, typename Op = std::less_equal<>>
constexpr bool	dedekind::category::is_adjoint_v = is_adjoint<F, G, Op>::value
template<typename F, typename G, typename Op>
constexpr bool	is_adjoint_v< F, G, Op > = true
template<>
constexpr bool	is_kleisli_arrow_v< Ranked, maybe_monad_tag > = true
template<>
constexpr bool	is_kleisli_arrow_v< Columns, maybe_monad_tag > = true
constexpr Automaton< 4, 8 >	kmp_gaattc = detail_automaton::kmp_gaattc()
constexpr auto	bounded_pred = [limit = 42](int x) { return x < limit; }
template<typename R>
constexpr bool	dedekind::category::is_left_total_v = false
	User-declared left-totality witness for a binary relation.
template<typename R>
constexpr bool	dedekind::category::is_right_unique_v = false
	User-declared right-uniqueness witness for a binary relation.
template<typename R>
constexpr bool	dedekind::category::is_left_unique_v = false
	Left-uniqueness (injectivity of the relation): each b ∈ B is related to at most one a; R° right-unique. Same opt-in pattern; derived for the relational nodes by the rule table (relational:dyadic, Laws).
template<typename R>
constexpr bool	dedekind::category::is_right_total_v = false
	Right-totality (surjectivity of the relation): every b ∈ B is related to some a; R° left-total. Same opt-in pattern, derived likewise. With the other three: an isomorphism of Rel.
template<typename F>
constexpr bool	is_left_total_v< arrow_as_relation< F > > = true
template<typename F>
constexpr bool	is_right_unique_v< arrow_as_relation< F > > = true
template<typename F>
constexpr bool	is_left_unique_v< arrow_as_relation< F > > = true
template<typename F>
constexpr bool	is_right_total_v< arrow_as_relation< F > > = true
template<typename R, typename T, typename Op>
constexpr bool	dedekind::category::is_congruence_v = false
	User-declared congruence witness: R respects Op on T.
template<typename R, typename V, typename Op>
constexpr bool	is_congruence_v< R, V, Op > = true
template<typename Seq, typename Idx>
constexpr bool	dedekind::category::is_eval_arrow_v = false
	is_eval_arrow_v<Seq, Idx>: opt-in marker that the carrier's operator[] realises the CCC eval counit. Default false; specialise to true at the carrier site (FinitePath<T>, Vec2V<T>, …) when the subscript-as-eval reading holds.
template<typename F, typename G>
constexpr bool	is_monic_arrow_v< Pairing< F, G > >
template<typename A, typename F, typename B, typename G>
constexpr bool	is_monic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >
template<typename A, typename F, typename B, typename G>
constexpr bool	is_epic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >
template<typename A, typename F, typename B, typename G, typename LeqA, typename LeqB>
constexpr bool	is_monotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >
template<typename A, typename F, typename B, typename G, typename LeqA, typename LeqB>
constexpr bool	is_antimonotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >
template<typename F, typename G>
constexpr bool	is_epic_arrow_v< Copairing< F, G > >
template<typename F, typename G, typename X, typename Y>
constexpr bool	is_monic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >
template<typename F, typename G, typename X, typename Y>
constexpr bool	is_epic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >
template<typename A, typename LeqA>
constexpr bool	is_monotone_v< Copy< A >, ProductLeq< LeqA, LeqA > > = true
template<typename A, typename Meet>
constexpr bool	is_monotone_v< Merge< A, Meet >, ProductLeq< std::less_equal< A >, std::less_equal< A > > > = true
template<std::totally_ordered P>
constexpr bool	is_adjoint_v< Copy< P >, Merge< P, Inf >, ProductLeq< std::less_equal< P >, std::less_equal< P > > > = true
	The theorem Δ ⊣ ∧, \(\Delta(a) \le_\times (x, y) \iff a \le x \wedge y\), registered per glb: Inf (min) on a totally ordered carrier under its own ≤, and ∧ on bool. The shape IsMerge cannot tell the glb from the lub (Sup is a monotone fold of the same signature and is not the right adjoint of Δ), so the law leg is where that distinction lives; a merge with another injected op registers its own fact next to the proof that it is the glb.
template<>
constexpr bool	is_adjoint_v< Copy< bool >, Merge< bool, std::logical_and< bool > >, ProductLeq< std::less_equal< bool >, std::less_equal< bool > > >
template<typename R, typename S, typename LeqR, typename LeqS>
constexpr bool	is_monotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >
template<typename R, typename S, typename LeqR, typename LeqS>
constexpr bool	is_antimonotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >
constexpr detail_comprehension::CountingStage	dedekind::category::counting {}
	The stage counting what precedes it.
template<typename A, typename B, typename Op>
constexpr bool	is_associative_v< ConstantMorphism< A, B >, Op > = true
template<typename A, typename B>
constexpr bool	is_constant_arrow_v< ConstantMorphism< A, B > > = true
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_symmetric_v = is_symmetric<T, Rel>::value
	The "v" helper following the :species convention.
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_equality_v = is_equality<T, Rel>::value
template<typename F, typename A, typename α>
constexpr bool	dedekind::category::is_initial_f_algebra_v = false
	Opt-in trait: does carrier A witness the initial F-algebra universal property for endofunctor F with structure map α?
template<typename F, typename A, typename α>
constexpr bool	dedekind::category::is_terminal_f_coalgebra_v = false
	Opt-in trait: does carrier A witness the terminal F-coalgebra universal property for endofunctor F with structure map α?
template<typename E>
constexpr bool	dedekind::category::is_regular_epi_v = false
	User-declared witness: E is a regular epi (the coequalizer of some parallel pair).
template<typename M>
constexpr bool	dedekind::category::is_regular_mono_v = false
	User-declared witness: M is a regular mono (the equalizer of some parallel pair). Dual to is_regular_epi_v.
template<typename C>
constexpr bool	dedekind::category::is_factorisation_system_v = false
	User-declared witness: category C admits a (regular epi, mono) factorisation system — every arrow f of C factors as f = m ∘ e with e a regular epi and m a mono, uniquely up to iso.
template<typename C>
constexpr bool	dedekind::category::is_regular_category_v = false
	User-declared witness: C is a regular category — has finite limits, kernel pairs and coequalizers of kernel pairs, and regular epis are stable under pullback.
template<typename C>
constexpr bool	is_factorisation_system_v< C > = true
	Every regular category admits the (regular epi, mono) factorisation system (Wikipedia: regular category). The upgrade fires automatically; downstream callers need only register is_regular_category_v.
template<typename C>
constexpr bool	dedekind::category::is_exact_category_v = false
	User-declared witness: C is an exact category — a regular category in which every equivalence relation is the kernel pair of some arrow (every equivalence relation is effective).
template<typename C>
constexpr bool	is_regular_category_v< C > = true
	Every exact category is a regular category (Borceux vol 2 §2.6); the upgrade fires automatically.
template<typename T>
constexpr bool	is_regular_epi_v< Identity< T > > = true
template<typename T>
constexpr bool	is_regular_mono_v< Identity< T > > = true
template<typename E>
constexpr bool	is_epic_arrow_v< E > = true
template<typename M>
constexpr bool	is_monic_arrow_v< M > = true
template<>
constexpr bool	is_exact_category_v< _factorisation_upgrade_witnesses::exact_category_witness > = true
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_directed_v = is_directed<T, Rel>::value
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_codirected_v = is_codirected<T, Rel>::value
template<typename F>
constexpr bool	dedekind::category::is_functorial_v
template<typename F>
constexpr bool	is_identity_functor_v = false
	The unit laws of Cat, decided at the type: an identity functor composes to the other leg itself, \(\mathrm{id} \gg F = F = F \gg \mathrm{id}\), not to a composite around it, as an identity arrow does (:morphism). The overloads repeat the generic one's constraints and add one, so resolution orders them by subsumption (Jlt paper, Listing 1).
template<typename Cat>
constexpr bool	is_identity_functor_v< identity_functor< Cat > > = true
template<typename F>
constexpr bool	dedekind::category::is_embedding_functor_v = false
	Trait registry for the IsEmbeddingFunctor concept.
template<typename F>
constexpr bool	dedekind::category::is_quotient_functor_v = false
	Trait registry for the IsQuotientFunctor concept.
template<typename A>
constexpr bool	is_exact_category_v< CanonicalSetCCC< A > > = true
template<>
constexpr bool	is_monic_arrow_v< image_decidability_witness::ToyEmbed >
template<typename F, typename T>
constexpr bool	dedekind::category::is_involutive_v = is_involutive<F, T>::value
constexpr Reverse	dedekind::category::rev {}
	The reversal: of a word's positions, \(i \mapsto n - 1 - i\), the symmetry of a palindrome, and of a comparison.
template<typename M>
constexpr bool	dedekind::category::is_kleisli_deref_v = false
	is_kleisli_deref_v<M>: opt-in marker that the carrier's operator-> realises Kleisli dereference (for monadic carriers like Maybe<T>) or comonadic extract ε (for comonadic carriers like Identity<T>). Default false; specialise to true at the carrier site.
template<typename E, typename M>
constexpr bool	dedekind::category::is_kleisli_arrow_v = false
	User-declared "Kleisli arrow" witness (#380, step 1).
template<>
constexpr bool	is_kleisli_arrow_v< _kleisli_arrow_witness_380::toy_partial_realize, maybe_monad_tag > = true
template<typename X, typename Ord>
constexpr bool	dedekind::category::is_lattice_bottom_for_v
template<typename X, typename Ord>
constexpr bool	dedekind::category::is_lattice_top_for_v = is_lattice_top_for<X, Ord>::value
template<typename X>
constexpr bool	dedekind::category::has_mixed_carrier_v = false
	Does the term X mix carriers anywhere — either two different known carriers, or a known carrier with an opaque (unknown) one? Only a uniform term fails this: all leaves opaque (the all-unknown case), or all leaves the same known carrier. A known/opaque mix counts as mixed because an opaque leaf carries no evidence it belongs to the known carrier's lattice. The structural laws use this to fail closed on any mixed term while still firing on the all-opaque case. (carrier_of reports void for both all-opaque and mixed, so a per-node is_void mismatch is what distinguishes a known/opaque boundary here.).
template<typename A>
constexpr bool	dedekind::category::has_mixed_carrier_v< Not< A > > = has_mixed_carrier_v<A>
template<typename A, typename B>
constexpr bool	dedekind::category::has_mixed_carrier_v< Meet< A, B > >
template<typename A, typename B>
constexpr bool	dedekind::category::has_mixed_carrier_v< Join< A, B > >
template<typename X>
constexpr bool	dedekind::category::idempotent_leaf_v
	Is X a leaf whose VALUE is determined by its TYPE? Idempotence X∧X=X is sound only for such a leaf. Two same-type instances are then necessarily the same set, so collapsing them is correct. The default is std::is_empty_v<X>, true for a stateless tag or an NTTP-encoded carrier. A carrier with RUNTIME-STATEFUL leaves specialises this to false for them. sets does so for Set<T,L,P> whose predicate P carries a runtime field (e.g. a Point's pivot). The type-based idempotence then does not collapse two distinct-but-same-type values.
template<typename A, typename B>
constexpr bool	idempotent_leaf_v< Meet< A, B > >
	A compound node is value-determined iff its operands are. So a Meet / Join / Not of value-determined leaves stays collapsible, while one carrying a runtime-stateful leaf does not. This keeps the value-safety gate recursive rather than treating every operand-storing node as stateful (Meet / Join / Not now store their operands, so the bare std::is_empty_v default would report false for all of them).
template<typename A, typename B>
constexpr bool	idempotent_leaf_v< Join< A, B > >
template<typename A>
constexpr bool	idempotent_leaf_v< Not< A > > = idempotent_leaf_v<A>
template<typename Elem, typename Node>
constexpr bool	dedekind::category::is_join_containing_v = false
	Is Elem one of the operands of the Join node Node?
template<typename Elem, typename A, typename B>
constexpr bool	dedekind::category::is_join_containing_v< Elem, Join< A, B > >
template<typename Elem, typename Node>
constexpr bool	dedekind::category::is_meet_containing_v = false
	Is Elem one of the operands of the Meet node Node?
template<typename Elem, typename A, typename B>
constexpr bool	dedekind::category::is_meet_containing_v< Elem, Meet< A, B > >
template<typename X>
constexpr bool	dedekind::category::is_join_node_v = false
	Is X a Join node?
template<typename A, typename B>
constexpr bool	dedekind::category::is_join_node_v< Join< A, B > > = true
template<typename T, typename Ord>
constexpr bool	dedekind::category::is_distributive_lattice_for_v
	Is the lattice (carrier T, order Ord) distributive? Keyed to the order like the boundedness markers. The canonical (std::less_equal chain) case derives from the concept gates IsLatticeCategory<T> && IsOrderDistributiveLatticeOperations<T> — so a carrier that is not a lattice under std::less_equal is not licensed to distribute (NB the bare distributive<T>(max{}, min{}) trait is unconditionally true, which would license any carrier — hence the concept gate). A NON-chain distributive lattice (a custom Ord) opts in by specialising this to true (the Jlt assertion — the same posture as the injected total order). A canonical chain is gated distributive but never actually distributes: its joins glb/lub-collapse first.
template<typename X>
constexpr bool	dedekind::category::is_not_node_v = false
	Is X a Not node?
template<typename A>
constexpr bool	dedekind::category::is_not_node_v< Not< A > > = true
template<typename X>
constexpr bool	dedekind::category::is_meet_node_v = false
	Is X a Meet node?
template<typename A, typename B>
constexpr bool	dedekind::category::is_meet_node_v< Meet< A, B > > = true
template<typename T>
constexpr bool	dedekind::category::is_lattice_node_v
	Whether T is one of the nodes, Meet, Join or Not.
template<typename T, typename Ord>
constexpr bool	dedekind::category::is_de_morgan_negation_for_v = false
	Does the lattice (carrier T, order Ord) carry an involutive order-reversing negation (¬¬a=a and the De Morgan laws)? Keyed to the order and opt-in (default false — the Jlt assertion), the same posture as is_distributive_lattice_for_v.
template<>
constexpr bool	dedekind::category::is_de_morgan_negation_for_v< bool, canonical_order > = true
	Canonical bool is a De Morgan (indeed Boolean) algebra: ¬ is std::logical_not, involutive with the De Morgan laws — the production carrier that activates the negation laws (the all-laws-fire oracle).
template<typename T, typename Ord>
constexpr bool	dedekind::category::is_complemented_lattice_for_v = false
	Does the lattice (carrier T, order Ord) carry a genuine complement (a∧¬a=⊥, a∨¬a=⊤), not merely a De Morgan negation? Keyed to the order and opt-in (default false). A complemented lattice is also a De Morgan algebra, so a carrier asserting this should also assert is_de_morgan_negation_for_v.
template<>
constexpr bool	dedekind::category::is_complemented_lattice_for_v< bool, canonical_order >
	Canonical bool is a Boolean (hence complemented) lattice.
template<typename RA, typename RB>
constexpr bool	dedekind::category::is_complement_pair_v
	Are RA and RB a complement pair (RB=¬RA or RA=¬RB)?
template<typename Not, typename T, typename Rel, typename Join, typename Meet>
constexpr bool	dedekind::category::is_complement_v
constexpr Projection< 0 >	dedekind::category::π {}
	The unary projection, the identity: the variable of a comprehension over one carrier.
constexpr Projection< 1 >	dedekind::category::π_1 {}
	The projections of a pair (and the first three of a tuple).
constexpr Projection< 2 >	dedekind::category::π_2 {}
constexpr Projection< 3 >	dedekind::category::π_3 {}
template<std::size_t K>
constexpr Projection< K >	dedekind::category::π_ {}
	The family: π_<k> is the k-th projection of a flat product.
template<std::size_t K, typename P>
constexpr bool	is_epic_arrow_v< detail_limit::ProjectionAt< K, P > > = true
	A projection of a product is epic, inferred from the point's shape: with independent components, every value of the component is attained, the others being any value of their types, which are inhabited (semiregular). It is not monic, since it forgets the others; the Jlt paper's Listing 1 shows it beside its section.
template<std::size_t K, typename P>
constexpr bool	is_monic_arrow_v< detail_limit::ProjectionAt< K, P > > = true
	A projection whose components are inclusions is monic: the point is one value, each component that value seen in a part, as a pullback apex's legs are (:pullback). Inferred from the point's own declaration.
template<typename From, typename To>
constexpr bool	dedekind::category::lifts_to_v
	The dominance order: From ⊑ To iff the embedding species_embed<From, To> is registered. Reflexive and, over the shipped species, transitive (𝔹 ⊑ K₃ ⊑ Percent; 𝔹 ⊑ Chain<T>).
template<>
constexpr bool	is_reflexive_v< Percentage, std::less_equal<> > = true
	Register the Kleene carrier Ternary in the :total / :posetal machinery so the lattice-ladder and order concepts resolve on it, the same way bool and int are registered.
template<>
constexpr bool	is_transitive_v< Percentage, std::less_equal<> > = true
template<>
constexpr bool	is_antisymmetric_v< Percentage, std::less_equal<> > = true
template<>
constexpr bool	is_connex_v< Percentage, std::less_equal<> > = true
template<>
constexpr bool	is_reflexive_v< Percentage, std::less_equal< Percentage > >
template<>
constexpr bool	is_transitive_v< Percentage, std::less_equal< Percentage > >
template<>
constexpr bool	is_antisymmetric_v< Percentage, std::less_equal< Percentage > > = true
template<>
constexpr bool	is_connex_v< Percentage, std::less_equal< Percentage > >
template<typename L>
constexpr bool	dedekind::category::logic_negation_is_involutive_v
	true iff the logic negation ¬ = L::RFL is a certified involution. Both shipped De Morgan logics (𝔹, K₃) qualify; a future intuitionistic species whose ¬¬ is only a closure would not. Downstream double-negation elimination gates on this so it stays honest per logic.
template<typename L>
constexpr bool	dedekind::category::logic_is_complemented_v = false
	true iff the species' reflection is a genuine complement (a∧¬a=⊥ and a∨¬a=⊤ for all a), i.e. the chain is 2-element. Boole qualifies; Kleene and Chain<T> (|Ω|>2) do not: their interior values have no complement. This is the logic_species=Boole reading of decidability: the clopen core Σ = 𝔹 ↪ Ω.
template<>
constexpr bool	logic_is_complemented_v< Boole > = true
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_reflexive_v = is_reflexive<T, Rel>::value
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_transitive_v = is_transitive<T, Rel>::value
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_antisymmetric_v = is_antisymmetric<T, Rel>::value
template<typename T, typename Rel>
constexpr bool	dedekind::category::is_connex_v = is_connex<T, Rel>::value
constexpr std::size_t	chain_walk_budget = 1024
	The walk budget of a discrete bounded chain: a chain is decided only when its top is reached from its bottom within this many steps (a machine word is a discrete bounded chain too, but 2⁶⁴ steps is no compile-time decision).
template<std::integral T>
constexpr bool	is_reflexive_v< T, std::less_equal<> > = true
	Proof: <= on the integral types is a total order (reflexive, transitive, antisymmetric, connex), under the transparent spelling as under the typed one above.
template<std::integral T>
constexpr bool	is_transitive_v< T, std::less_equal<> > = true
template<std::integral T>
constexpr bool	is_antisymmetric_v< T, std::less_equal<> > = true
template<std::integral T>
constexpr bool	is_connex_v< T, std::less_equal<> > = true
constexpr std::size_t	law_evaluation_budget = std::size_t{1} << 16
	The evaluation budget of a law: a law of k variables on a chain of n values costs nᵏ evaluations, and is decided only within this (reflexivity on a long chain, transitivity only on a short one).
template<typename T>
constexpr bool	is_idempotent_v< T, Sup > = true
template<typename T>
constexpr bool	is_associative_v< T, Sup > = true
template<typename T>
constexpr bool	is_commutative_v< T, Sup > = true
template<typename T>
constexpr bool	is_idempotent_v< T, Inf > = true
template<typename T>
constexpr bool	is_associative_v< T, Inf > = true
template<typename T>
constexpr bool	is_commutative_v< T, Inf > = true
template<typename T>
constexpr bool	is_distributive_v< T, Sup, Inf > = true
template<typename T>
constexpr bool	is_distributive_v< T, Inf, Sup > = true
template<typename T>
constexpr bool	is_absorptive_v< T, Sup, Inf > = true
template<typename T>
constexpr bool	is_absorptive_v< T, Inf, Sup > = true
constexpr auto	logic_gate = arrow([](int x) -> bool { return x > 0; })
template<typename T>
constexpr bool	dedekind::category::has_one_value_v
template<typename F, typename G>
constexpr bool	dedekind::category::commutes_v
constexpr auto	f_neg = endo<int>(std::negate<int>{})
constexpr auto	identity_int = id<int>()
template<typename T, typename Op>
constexpr bool	is_associative_v< Identity< T >, Op >
template<typename T, typename Op>
constexpr bool	is_commutative_v< Identity< T >, Op >
template<typename T>
constexpr bool	is_identity_v = false
	The unit law, decided at the type: an identity on the matching object composes to the other leg itself, not to a Compose around it. The overloads repeat the generic one's constraints and add one, so resolution orders them by subsumption (Jlt paper, Listing 1).
template<typename A>
constexpr bool	is_identity_v< Identity< A > > = true
template<typename Cat>
constexpr bool	is_identity_v< IdentityIn< Cat > > = true
template<typename F>
constexpr bool	dedekind::category::is_self_inverse_v = is_self_inverse<F>::value
template<typename E>
constexpr bool	dedekind::category::is_monic_arrow_v = false
	User-declared monicity witness for an arrow type.
template<typename E>
constexpr bool	dedekind::category::is_constant_arrow_v = false
	The constancy of an arrow: declared for ConstantMorphism (:discrete), read off composition by the law engine (:posetal).
template<typename T>
constexpr bool	is_monic_arrow_v< Identity< T > > = true
template<typename E>
constexpr bool	dedekind::category::is_epic_arrow_v = false
	User-declared epicity witness for an arrow type.
template<typename T>
constexpr bool	is_epic_arrow_v< Identity< T > > = true
template<typename F, typename T, typename Op, typename Op2 = Op>
constexpr bool	dedekind::category::is_homomorphism_v = is_homomorphism<F, T, Op, Op2>::value
	Value form of is_homomorphism.
constexpr maybe_monad_tag	dedekind::category::maybe_monad {}
constexpr identity_monad_tag	dedekind::category::identity_monad {}
constexpr tuple_monad_tag	dedekind::category::tuple_monad {}
constexpr bool	dedekind::category::numeric_uses_builtin_overflow_checks = false
	Compile-time diagnostic: portable fallback overflow path enabled.
template<typename T, typename Op>
constexpr bool	dedekind::category::is_kleene_associative_v = false
template<typename T, typename Op>
constexpr bool	dedekind::category::is_kleene_commutative_v = false
template<typename T, typename Op>
constexpr bool	dedekind::category::is_kleene_invertible_v = false
template<typename T, typename Op>
constexpr T	dedekind::category::partial_unit_v = T{}
template<typename T>
constexpr bool	is_kleene_associative_v< T, SafeAddTransform< T > > = true
template<typename T>
constexpr T	partial_unit_v< T, SafeAddTransform< T > > = T(0)
template<std::unsigned_integral T>
constexpr bool	is_kleene_associative_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > > = true
template<std::unsigned_integral T>
constexpr bool	is_kleene_commutative_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > > = true
template<std::unsigned_integral T>
constexpr bool	is_kleene_invertible_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > > = true
template<std::unsigned_integral T>
constexpr T	partial_unit_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > >
template<std::unsigned_integral T>
constexpr bool	is_kleene_associative_v< T, BoundedMulTransform< T, FullMachineBoundaryPolicy< T > > > = true
template<std::unsigned_integral T>
constexpr bool	is_kleene_commutative_v< T, BoundedMulTransform< T, FullMachineBoundaryPolicy< T > > > = true
template<std::unsigned_integral T>
constexpr T	partial_unit_v< T, BoundedMulTransform< T, FullMachineBoundaryPolicy< T > > >
constexpr Congruent	dedekind::category::is_even {2, 0}
	The even counts, the residue class of 0 modulo 2. Its reading on ℕ as a sequence, a path into the truth values, is dedekind::sequences::is_even (sequences:samples).
template<typename Fam>
constexpr bool	is_graded_v = false
	A graded family of sets of words, indexed by the length: words(Σ), or it followed by stages.
template<HasNNOStep C, IsArrow F, IsCountWord N>
constexpr bool	is_graded_v< Powers< C, F, N > > = true
template<typename Fam, typename G>
constexpr bool	is_graded_v< Compose< Fam, G > > = is_graded_v<Fam>
constexpr Pow2	dedekind::category::pow2 {}
	\(k \mapsto 2^k\) on std::size_t.
template<std::size_t W>
constexpr Pack< W >	dedekind::category::pack {}
	A pattern packed into the bit word of width W.
template<std::size_t W>
constexpr Unpack< W >	dedekind::category::unpack {}
	A machine word read back as a count.
constexpr std::size_t	dedekind::category::max_packed_width = 512
	The widest bit word the library precompiles: 512 bits, the widest common vector register, a std::bitset at every width above 64.
constexpr std::ranges::min_max_result< int >	p1 {1, 0}
constexpr std::ranges::min_max_result< int >	p2 {2, 0}
constexpr std::ranges::min_max_result< int >	p3 {3, 0}
template<typename F, typename Op = std::less_equal<>>
constexpr bool	dedekind::category::is_monotone_v
template<typename F, typename Op = std::less_equal<>>
constexpr bool	dedekind::category::is_antimonotone_v
template<typename T, typename Op>
constexpr bool	is_monotone_v< Identity< T >, Op > = true
template<typename L, typename Op>
constexpr bool	is_antimonotone_v< NegationArrow< L >, Op > = true
template<typename L, typename Op>
constexpr bool	is_monotone_v< LiftLogic< L >, Op > = true
constexpr std::array< ArrowLaw, 6 >	dedekind::category::every_arrow_law
template<typename F, typename Op = std::less_equal<>>
constexpr ArrowLaws	dedekind::category::arrow_laws_v = declared_arrow_laws<F, Op>()
template<IsArrow F, IsArrow G>
constexpr bool	is_monic_arrow_v< Compose< F, G > >
template<IsArrow F, IsArrow G>
constexpr bool	is_epic_arrow_v< Compose< F, G > >
template<typename F, typename G, typename Op>
constexpr bool	is_monotone_v< Compose< F, G >, Op >
template<typename F, typename G, typename Op>
constexpr bool	is_antimonotone_v< Compose< F, G >, Op >
template<IsArrow F, IsArrow G>
constexpr bool	is_constant_arrow_v< Compose< F, G > >
template<typename A, typename B, typename LeqA, typename LeqB>
constexpr bool	is_reflexive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >
template<typename A, typename B, typename LeqA, typename LeqB>
constexpr bool	is_transitive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >
template<typename A, typename B, typename LeqA, typename LeqB>
constexpr bool	is_antisymmetric_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >
template<typename X, typename Y>
constexpr bool	is_reflexive_v< std::variant< X, Y >, std::less_equal<> >
template<typename X, typename Y>
constexpr bool	is_transitive_v< std::variant< X, Y >, std::less_equal<> >
template<typename X, typename Y>
constexpr bool	is_antisymmetric_v< std::variant< X, Y >, std::less_equal<> >
template<typename X, typename Y>
constexpr bool	is_reflexive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >
template<typename X, typename Y>
constexpr bool	is_transitive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >
template<typename X, typename Y>
constexpr bool	is_antisymmetric_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >
template<typename X, typename Y>
constexpr bool	is_connex_v< std::variant< X, Y >, std::less_equal<> >
template<typename X, typename Y>
constexpr bool	is_connex_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >
template<typename T, typename Op>
constexpr bool	is_associative_v< T, Op > = true
template<typename T, typename Op>
constexpr bool	dedekind::category::is_associative_v = is_associative<T, Op>::value
template<typename T, typename Op>
constexpr bool	dedekind::category::is_commutative_v = is_commutative<T, Op>::value
template<typename T, typename Op>
constexpr bool	dedekind::category::is_idempotent_v = is_idempotent<T, Op>::value
	Helper for shorthand access in concepts.
template<typename T>
constexpr size_t	dedekind::category::characteristic_v
	The Characteristic of the Species.
template<>
constexpr size_t	characteristic_v< unsigned char > = 256
template<typename Op> requires std::same_as<Op, std::logical_and<bool>> || std::same_as<Op, std::logical_and<void>>
constexpr bool	is_commutative_v< bool, Op > = true
template<typename Op> requires std::same_as<Op, std::logical_or<bool>> || std::same_as<Op, std::logical_or<void>>
constexpr bool	is_associative_v< bool, Op > = true
template<typename T, typename Mult, typename Add>
constexpr bool	dedekind::category::is_distributive_v = false
	Trait to mark the structural glue between two operators. axiom: a * (b + c) = (a * b) + (a * c).
template<typename T, typename Op>
constexpr bool	dedekind::category::is_invertible_v = inverse_trait<T, Op>::exists
	The Shorthand for the Registry.
template<>
constexpr bool	is_associative_v< bool, std::bit_xor< bool > > = true
	XOR on bool is the additive composition of the Boolean Ring. It is bit-perfect, associative, and total.
template<>
constexpr bool	is_invertible_v< bool, std::bit_xor< bool > > = true
	Every boolean is its own inverse (x ^ x = false). There is no Lipschitz boundary breach here.
template<std::unsigned_integral T>
constexpr bool	is_associative_v< T, std::plus<> > = true
	Associativity is only total for unsigned types (modular arithmetic). For signed types, it is REJECTED here due to the re-ordering hazard (UB).
template<std::unsigned_integral T>
constexpr bool	is_associative_v< T, std::plus< T > > = true
template<std::integral T>
constexpr bool	is_commutative_v< T, std::plus<> > = true
	Commutativity remains a total property (order-independence).
template<std::integral T>
constexpr bool	is_commutative_v< T, std::plus< T > > = true
template<std::unsigned_integral T>
constexpr bool	is_associative_v< T, std::multiplies< T > > = true
	Multiplication is ONLY associative for types with defined (modular) overflow. Signed integers fail this at Level 0 due to the UB hazard, and so does a word whose product overflows int after promotion (HasTotalProduct).
template<std::unsigned_integral T>
constexpr bool	is_commutative_v< T, std::multiplies< T > > = true
template<std::integral T>
constexpr bool	is_associative_v< T, std::modulus< T > > = false
	Modulus is NOT associative nor commutative, and has no identity.
template<std::integral T>
constexpr bool	is_commutative_v< T, std::modulus< T > > = false
template<std::integral T>
constexpr bool	is_associative_v< T, std::bit_xor< T > > = true
template<std::integral T>
constexpr bool	is_commutative_v< T, std::bit_xor< T > > = true
template<std::integral T>
constexpr bool	is_associative_v< T, std::bit_and< T > > = true
template<std::integral T>
constexpr bool	is_commutative_v< T, std::bit_and< T > > = true
template<>
constexpr bool	is_associative_v< bool, std::bit_and< bool > > = true
template<>
constexpr bool	is_commutative_v< bool, std::bit_and< bool > > = true
template<>
constexpr bool	is_invertible_v< bool, std::bit_and< bool > > = true
	On the multiplicative group \(\mathbb{F}_2^\times = \{\mathtt{true}\}\), the only non-zero element is self-inverse: true & true = true (the registered operator is std::bit_and<bool>, the bitwise AND). Zero (i.e. false) is excluded by convention on is_invertible_v, so the trait can be declared at the type level without quantifying over values. Together with the XOR additive group, this witnesses dedekind::category::IsField<bool, std::bit_xor<bool>, std::bit_and<bool>>: bool is the Galois field \(\mathbb{F}_2\) under its natural bitwise operators.
template<>
constexpr bool	is_distributive_v< bool, std::bit_and< bool >, std::bit_xor< bool > > = true
	AND distributes over XOR on bool: the field distributivity axiom.
template<std::integral T>
constexpr bool	is_idempotent_v< T, std::bit_or<> > = true
template<std::integral T>
constexpr bool	is_commutative_v< T, std::bit_or<> > = true
template<std::integral T>
constexpr bool	is_associative_v< T, std::bit_or<> > = true
template<std::integral T>
constexpr bool	is_idempotent_v< T, std::bit_and<> > = true
template<std::integral T>
constexpr bool	is_associative_v< T, std::bit_and<> > = true
template<std::integral T>
constexpr bool	is_commutative_v< T, std::bit_and<> > = true
template<std::unsigned_integral T>
constexpr bool	is_associative_v< T, std::multiplies<> > = true
template<typename T>
constexpr bool	is_distributive_v< T, std::bit_and<>, std::bit_or<> >
template<typename T>
constexpr bool	is_distributive_v< T, std::bit_or<>, std::bit_and<> >
template<typename T>
constexpr bool	is_distributive_v< T, std::bit_and< T >, std::bit_or< T > >
template<typename T>
constexpr bool	is_distributive_v< T, std::bit_or< T >, std::bit_and< T > >
template<typename T>
constexpr bool	is_distributive_v< T, std::multiplies<>, std::plus<> >
	Self-verifying the structural integrity of the reified species.
template<>
constexpr bool	is_distributive_v< bool, std::logical_or< bool >, std::logical_and< bool > >
template<>
constexpr bool	is_distributive_v< bool, std::logical_and< bool >, std::logical_or< bool > >
template<typename T>
constexpr bool	dedekind::category::is_transfinite_v = is_transfinite<T>::value
	Shorthand helper.
template<typename T, typename Op1, typename Op2>
constexpr bool	dedekind::category::is_absorptive_v = false
	The Absorber Trait (Axiom: a ∨ (a ∧ b) = a). Represents the structural tethering between two dual operations.
template<typename T>
constexpr bool	is_absorptive_v< T, std::logical_or< T >, std::logical_and< T > > = true
template<typename T>
constexpr bool	is_absorptive_v< T, std::logical_and< T >, std::logical_or< T > > = true
template<std::integral T>
constexpr bool	is_absorptive_v< T, std::bit_or<>, std::bit_and<> > = true
template<std::integral T>
constexpr bool	is_absorptive_v< T, std::bit_and<>, std::bit_or<> > = true
template<typename T>
constexpr bool	is_idempotent_v< T, std::bit_xor< T > > = false
template<typename T>
constexpr bool	is_idempotent_v< T, std::bit_and< T > > = true
template<typename T>
constexpr bool	is_absorptive_v< T, std::bit_xor< T >, std::bit_and< T > >
template<typename T>
constexpr bool	is_absorptive_v< T, std::bit_and< T >, std::bit_xor< T > >
template<typename T, typename Op>
constexpr bool	dedekind::category::is_periodic_v = is_periodic<T, Op>::value
template<typename T, typename Op>
constexpr bool	dedekind::category::is_saturating_v = is_saturating<T, Op>::value
template<typename T, typename Op>
constexpr bool	dedekind::category::is_exact_total_v = is_exact_total<T, Op>::value
template<typename T, typename Op>
constexpr bool	dedekind::category::is_total_by_construction_v
	Value form of is_total_by_construction.
template<typename T, typename Op>
constexpr bool	dedekind::category::is_total_v = is_total<T, Op>::value
	Value form of is_total.
template<IsConstructed D>
constexpr bool	is_associative_v< D, std::plus< D > >
template<IsConstructed D>
constexpr bool	is_commutative_v< D, std::plus< D > >
template<IsConstructed D>
constexpr bool	is_associative_v< D, std::multiplies< D > >
template<IsConstructed D>
constexpr bool	is_commutative_v< D, std::multiplies< D > >
template<IsConstructed D>
constexpr bool	is_distributive_v< D, std::multiplies< D >, std::plus< D > >
template<typename A, typename B, typename Op>
constexpr bool	is_monotone_v< ConstantMorphism< A, B >, Op > = true
template<typename A, typename B, typename Op>
constexpr bool	is_antimonotone_v< ConstantMorphism< A, B >, Op > = true
template<typename T, typename Op>
constexpr bool	dedekind::category::is_cyclic_group_v = is_cyclic_group<T, Op>::value
	Shorthand access to the is_cyclic_group trait.
template<typename T, typename Op>
constexpr std::size_t	dedekind::category::cyclic_order_v = cyclic_order<T, Op>::value
template<typename T, typename Join, typename Meet, typename Not>
constexpr bool	dedekind::category::is_complemented_v = false
	Opt-in complement law: T carries a complement Not w.r.t. the bounded lattice (Join, Meet), i.e. \(a \vee \neg a = \top\) and \(a \wedge \neg a = \bot\) for every a.
template<std::unsigned_integral T>
constexpr bool	is_complemented_v< T, std::bit_or<>, std::bit_and<>, std::bit_not<> > = true
	The bit lattice of an unsigned word is complemented by ~: a | ~a is every bit, a & ~a none. Not bool, whose ~ promotes (~true is -2) and is no involution (std::logical_not is bool's complement).
template<>
constexpr bool	is_complemented_v< bool, std::logical_or< bool >, std::logical_and< bool >, std::logical_not< bool > > = true
template<typename Op, typename A, typename B>
constexpr bool	dedekind::category::is_closure_forcing_v = false
	Opt-in trait carrying the universal-property clause of IsClosureForcing — the engineer's honesty obligation that B is the canonical (smallest) carrier closing Op over A inputs. C++ concepts cannot quantify universally, so this part of the witness is asserted, not deduced. Pattern mirrors is_associative_v / is_saturating.
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::geometry::embed_z2_r2)> >
template<std::floating_point F>
constexpr bool	is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >
template<std::floating_point F>
constexpr bool	is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >
template<std::floating_point F>
constexpr dedekind::ieee::IEEE< F >	partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >
template<std::floating_point F>
constexpr bool	is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >
template<std::floating_point F>
constexpr bool	is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >
template<std::floating_point F>
constexpr dedekind::ieee::IEEE< F >	partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >
template<detail_mat2x2::HasRingEntries T>
constexpr bool	is_distributive_v< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >
template<typename T, typename Idx>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Matrix2x2V< T >, Idx > = true
template<typename T, std::integral U, U I>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Matrix2x2V< T >, std::integral_constant< U, I > > = true
template<typename S, std::size_t N>
constexpr bool	is_distributive_v< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N >, dedekind::linear_algebra::MatPlus< S, N > >
	⊗ distributes over ⊕ in Mat(S) exactly when it does in S (§4 property distribution) — not unconditionally.
template<typename T>
constexpr bool	is_invertible_v< dedekind::linear_algebra::Vec2V< T >, std::plus< dedekind::linear_algebra::Vec2V< T > > > = true
template<typename T>
constexpr bool	is_invertible_v< dedekind::linear_algebra::Covec2V< T >, std::plus< dedekind::linear_algebra::Covec2V< T > > > = true
template<typename T, typename Idx>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Vec2V< T >, Idx >
template<typename T, typename Idx>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Covec2V< T >, Idx > = true
template<typename T, std::integral U, U I>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Vec2V< T >, std::integral_constant< U, I > > = true
template<typename T, std::integral U, U I>
constexpr bool	is_eval_arrow_v< dedekind::linear_algebra::Covec2V< T >, std::integral_constant< U, I > > = true
template<typename T>
constexpr bool	is_kleisli_deref_v< dedekind::linear_algebra::Vec2V< T > >
template<auto N>
constexpr bool	is_distributive_v< dedekind::morphologies::Modular< N >, std::multiplies<>, std::plus<> > = true
template<auto N>
constexpr bool	is_distributive_v< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > >, std::plus< dedekind::morphologies::Modular< N > > > = true
template<auto N>
constexpr bool	is_invertible_v< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > = true
template<auto N>
constexpr bool	is_invertible_v< dedekind::morphologies::Modular< N >, std::plus<> > = true
template<auto N>
constexpr bool	is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >
template<auto N>
constexpr bool	is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies<> >
template<auto N>
constexpr bool	is_reflexive_v< typename dedekind::morphologies::Modular< N >::machine_type, dedekind::morphologies::ModularCongruence< N > > = true
template<auto N>
constexpr bool	is_symmetric_v< typename dedekind::morphologies::Modular< N >::machine_type, dedekind::morphologies::ModularCongruence< N > > = true
template<auto N>
constexpr bool	is_transitive_v< typename dedekind::morphologies::Modular< N >::machine_type, dedekind::morphologies::ModularCongruence< N > > = true
template<auto N>
constexpr bool	is_congruence_v< dedekind::morphologies::ModularCongruence< N >, typename dedekind::morphologies::Modular< N >::machine_type, std::plus< typename dedekind::morphologies::Modular< N >::machine_type > >
template<auto N>
constexpr bool	is_congruence_v< dedekind::morphologies::ModularCongruence< N >, typename dedekind::morphologies::Modular< N >::machine_type, std::multiplies< typename dedekind::morphologies::Modular< N >::machine_type > > = true
template<std::floating_point F>
constexpr bool	is_reflexive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >
template<std::floating_point F>
constexpr bool	is_transitive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >
template<std::floating_point F>
constexpr bool	is_antisymmetric_v< dedekind::morphologies::safe_float< F >, std::less_equal<> > = true
template<std::floating_point F>
constexpr bool	is_connex_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(embed_sint_ℤ_)> >
template<>
constexpr bool	is_embedding_functor_v< std::decay_t< decltype(embed_sint_ℤ_)> > = true
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(embed_sint_ℤ_)>, std::less_equal<> >
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(embed_uint_ℕ_)> >
template<>
constexpr bool	is_embedding_functor_v< std::decay_t< decltype(embed_uint_ℕ_)> > = true
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(embed_uint_ℕ_)>, std::less_equal<> >
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(embed_𝔹_uint_)> >
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(embed_𝔹_uint_)>, std::less_equal<> >
template<typename R>
constexpr bool	is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >
	Kleene traits for complex arithmetic.
template<typename R>
constexpr dedekind::numbers::Complex< R >	partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >
template<typename R>
constexpr bool	is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >
template<typename R>
constexpr dedekind::numbers::Complex< R >	partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >
template<typename R>
constexpr bool	is_associative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >
template<typename R>
constexpr bool	is_commutative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >
template<typename R>
constexpr bool	is_distributive_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > >, std::plus< dedekind::numbers::Complex< R > > >
template<unsigned N>
constexpr bool	is_invertible_v< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > = true
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℝ_ℂ)> >
template<dedekind::numbers::IsComplexScalar R>
constexpr bool	is_invertible_v< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >
template<typename Q>
constexpr bool	is_reflexive_v< dedekind::numbers::Cut< Q >, std::less_equal<> > = true
template<typename Q>
constexpr bool	is_transitive_v< dedekind::numbers::Cut< Q >, std::less_equal<> > = true
template<typename Q>
constexpr bool	is_antisymmetric_v< dedekind::numbers::Cut< Q >, std::less_equal<> > = true
template<typename Q>
constexpr bool	is_connex_v< dedekind::numbers::Cut< Q >, std::less_equal<> > = true
template<>
constexpr bool	is_adjoint_v< Successor< SignedCardinality >, Predecessor< SignedCardinality >, std::less_equal<> > = true
	S ⊣ P on the saturating ℤ. Both legs are monotone (order:completeness); the unit \(x \le P(S(x))\) and the counit \(S(P(y)) \le y\) hold everywhere, at the ends by saturation ( \(P(S(\max)) = P(+\aleph_0) = +\aleph_0 \ge \max\)). The reverse P ⊣ S fails at the top, \(P(S(\max)) = +\aleph_0 > \max\), and S is no bijection, \(S(\max) = S(+\aleph_0)\): saturation keeps one of the two adjunctions ℤ proper has, and the witnesses in the numbers block say which.
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)> >
template<>
constexpr bool	is_embedding_functor_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)> > = true
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)>, std::less_equal<> >
template<long D, typename Q>
constexpr bool	is_reflexive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >
template<long D, typename Q>
constexpr bool	is_transitive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >
template<long D, typename Q>
constexpr bool	is_antisymmetric_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> > = true
template<long D, typename Q>
constexpr bool	is_connex_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >
template<long D, typename Q>
constexpr bool	is_distributive_v< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > = true
template<long D, typename Q>
constexpr bool	is_invertible_v< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > = true
template<long D, typename Q>
constexpr bool	is_invertible_v< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >
	Kleene traits for rational arithmetic.
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >
template<dedekind::morphologies::IsInteger I>
constexpr dedekind::numbers::Rational< I >	partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >
template<dedekind::morphologies::IsInteger I>
constexpr dedekind::numbers::Rational< I >	partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialEmbedIntegerToRational< I > > = true
	Kleene traits for integer→rational embedding (exact).
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_reflexive_v< dedekind::numbers::Rational< I >, std::less_equal<> > = true
	Ordering traits: Rational is a total order (ℚ ≤ is a chain).
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_transitive_v< dedekind::numbers::Rational< I >, std::less_equal<> > = true
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_antisymmetric_v< dedekind::numbers::Rational< I >, std::less_equal<> >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_connex_v< dedekind::numbers::Rational< I >, std::less_equal<> > = true
template<typename I>
constexpr bool	is_associative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
template<typename I>
constexpr bool	is_associative_v< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > > = true
template<typename I>
constexpr bool	is_commutative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
template<typename I>
constexpr bool	is_commutative_v< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > > = true
template<typename I>
constexpr bool	is_distributive_v< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > >, std::plus< dedekind::numbers::Rational< I > > > = true
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_invertible_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >
template<dedekind::morphologies::IsInteger I>
constexpr bool	is_invertible_v< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > > = true
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)> >
	ℤ ↪ ℚ is monic: \(n/1 = m/1 \iff n = m\).
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)>, std::less_equal<> >
	ℤ ↪ ℚ preserves order — the monotonicity the strength-reduction pullback rests on.
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝕃_ℚ<>)> >
	The finite doubles embed injectively into ℚ: distinct finite doubles have distinct dyadic values (-0.0 and +0.0 are one element of 𝕃).
template<typename I>
constexpr bool	is_monic_arrow_v< dedekind::numbers::EmbedRationalToReal< I > > = true
	S-leg is monic (witness: \(a\neq b\Rightarrow embed(a)\neq embed(b)\)).
template<HasNNOStep N>
constexpr bool	is_monotone_v< Successor< N >, std::less_equal<> > = true
	The step arrows preserve the order of a registered chain, \(x \le y \Rightarrow S(x) \le S(y)\) and likewise for P: the irreducible leaf facts the variance inference starts from. Saturation at a bound is monotone; wrapping is not, and wrapping is the carrier's registered periodicity (is_periodic_v of its +: the unsigned words, ℤ/N), so the fact is read off the algebra, not off the type's name; the chain gate supplies the order.
template<HasNNOStep N>
constexpr bool	is_monotone_v< Predecessor< N >, std::less_equal<> > = true
template<typename A, typename B, typename L, typename P, typename RP, typename C>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, dedekind::order::ProductRestrict< P, RP > > >
template<typename T>
constexpr bool	is_absorptive_v< T, std::bit_or< T >, std::bit_and< T > >
	Algebra-trait specialisations for std::bit_or<T> / std::bit_and<T> on specific integral T (#710).
template<typename T>
constexpr bool	is_absorptive_v< T, std::bit_and< T >, std::bit_or< T > >
template<typename A, typename L, typename C>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, A >, L, C >, dedekind::relational::DiagPred< A > > > = true
template<typename A, typename L, typename C>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, A >, L, C >, dedekind::relational::DiagPred< A > > > = true
template<typename A, typename L, typename C>
constexpr bool	is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, A >, L, C >, dedekind::relational::DiagPred< A > > > = true
template<typename A, typename L, typename C>
constexpr bool	is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, A >, L, C >, dedekind::relational::DiagPred< A > > > = true
template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >
template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >
template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>
constexpr bool	is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >
template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>
constexpr bool	is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >
template<typename B, typename A, typename L, typename Card, typename P>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >
template<typename B, typename A, typename L, typename Card, typename P>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >
template<typename B, typename A, typename L, typename Card, typename P>
constexpr bool	is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >
template<typename B, typename A, typename L, typename Card, typename P>
constexpr bool	is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >
template<typename A, typename B, typename L, typename Card, typename PR, typename PS>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >
template<typename A, typename B, typename L, typename Card, typename PR, typename PS>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >
template<typename A, typename B, typename L, typename Card, typename PR, typename PS>
constexpr bool	is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >
template<typename A, typename B, typename L, typename Card, typename PR, typename PS>
constexpr bool	is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >
template<typename A, typename L, typename C, typename Op>
constexpr bool	is_reflexive_v< A, Endo< A, L, C, PairwisePred< Op > > >
template<typename A, typename L, typename C, typename Op>
constexpr bool	is_symmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >
template<typename A, typename L, typename C, typename Op>
constexpr bool	is_transitive_v< A, Endo< A, L, C, PairwisePred< Op > > >
template<typename A, typename L, typename C, typename Op>
constexpr bool	is_antisymmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >
template<typename A, typename L, typename C, typename Op>
constexpr bool	is_connex_v< A, Endo< A, L, C, PairwisePred< Op > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_reflexive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_symmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_transitive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_antisymmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_reflexive_v< A, Endo< A, L, C, RelOr< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_symmetric_v< A, Endo< A, L, C, RelOr< PR, PS > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_connex_v< A, Endo< A, L, C, RelOr< PR, PS > > >
template<typename A, typename L, typename C, typename P>
constexpr bool	is_reflexive_v< A, Endo< A, L, C, SwapPred< P > > >
template<typename A, typename L, typename C, typename P>
constexpr bool	is_symmetric_v< A, Endo< A, L, C, SwapPred< P > > >
template<typename A, typename L, typename C, typename P>
constexpr bool	is_transitive_v< A, Endo< A, L, C, SwapPred< P > > >
template<typename A, typename L, typename C, typename P>
constexpr bool	is_antisymmetric_v< A, Endo< A, L, C, SwapPred< P > > >
template<typename A, typename L, typename C, typename P>
constexpr bool	is_connex_v< A, Endo< A, L, C, SwapPred< P > > >
template<typename A, typename L, typename C, typename PR, typename PS>
constexpr bool	is_reflexive_v< A, Endo< A, L, C, ComposePred< PR, PS, A > > >
template<typename F>
constexpr bool	is_left_total_v< dedekind::relational::Graph< F > > = true
template<typename F>
constexpr bool	is_right_unique_v< dedekind::relational::Graph< F > > = true
template<typename I, typename T, typename L, typename PathT, typename C>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >
template<typename I, typename T, typename L, typename PathT, typename C>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >
template<std::integral T>
constexpr bool	is_associative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >
template<std::integral T>
constexpr bool	is_commutative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >
template<std::integral T>
constexpr bool	is_idempotent_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >
template<typename T>
constexpr bool	is_reflexive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >
template<typename T>
constexpr bool	is_symmetric_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >
template<typename T>
constexpr bool	is_transitive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >
template<typename T>
constexpr bool	is_congruence_v< dedekind::sequences::TailEquivalent< T >, dedekind::sequences::Path< T >, std::plus< dedekind::sequences::Path< T > > >
template<typename T, typename L>
constexpr bool	is_distributive_lattice_for_v< T, dedekind::sets::subobject_order< L > > = true
	The subobject lattice Sub(T) is a distributive lattice under subobject_order<L>, for every carrier T and classifier L. In a topos Sub(T) is a Heyting algebra (meet distributes over join), and the classical (Boole) case is the Boolean specialisation of that. The DNF rewrite, however, acts on the pointwise L::AND / L::OR of the predicates, so its soundness needs those operations to distribute, which the IsOckhamAlgebra shape gate does not certify. So the marker is gated on a species-level distributivity certificate: IsBoundedDeMorganChain<L>. A bounded De Morgan chain is (by chain-normality) a distributive lattice, so its L::AND / L::OR distribute; every shipped species (Boole, Kleene, Chain<T>, Percent) satisfies it, while an unconstrained / non-distributive custom L is excluded (fail-closed). When gated, it licenses the reducer's meet_distributivity_law to rewrite a genuinely non-collapsing Sub(T) meet-over-join into disjunctive normal form (X∧(P∨Q)→(X∧P)∨(X∧Q)). FIXME(#907/#923): replace IsBoundedDeMorganChain with a dedicated species-level distributivity certificate (via the :species-trait bridge) so non-chain distributive logics can also opt in.
template<typename L>
constexpr bool	is_complemented_lattice_for_v< bool, dedekind::sets::subobject_order< L > >
template<>
constexpr bool	is_associative_v< C1, std::plus< C1 > > = true
template<>
constexpr bool	is_associative_v< C1, std::multiplies< C1 > > = true
template<>
constexpr bool	is_commutative_v< C1, std::plus< C1 > > = true
template<>
constexpr bool	is_commutative_v< C1, std::multiplies< C1 > > = true
template<>
constexpr bool	is_distributive_v< C1, std::multiplies< C1 >, std::plus< C1 > > = true
template<typename W>
constexpr bool	is_reflexive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >
template<typename W>
constexpr bool	is_transitive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >
template<typename W>
constexpr bool	is_antisymmetric_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> > = true
template<typename W>
constexpr bool	is_connex_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >
template<>
constexpr bool	is_associative_v< Z1, std::plus< Z1 > > = true
template<>
constexpr bool	is_associative_v< Z1, std::multiplies< Z1 > > = true
template<>
constexpr bool	is_commutative_v< Z1, std::plus< Z1 > > = true
template<>
constexpr bool	is_commutative_v< Z1, std::multiplies< Z1 > > = true
template<>
constexpr bool	is_distributive_v< Z1, std::multiplies< Z1 >, std::plus< Z1 > > = true
template<>
constexpr bool	is_invertible_v< Z1, std::plus< Z1 > > = true
template<typename S>
constexpr bool	is_reflexive_v< dedekind::sets::SignedExtensionalCardinal< S >, std::less_equal<> > = true
template<typename S>
constexpr bool	is_transitive_v< dedekind::sets::SignedExtensionalCardinal< S >, std::less_equal<> > = true
template<typename S>
constexpr bool	is_antisymmetric_v< dedekind::sets::SignedExtensionalCardinal< S >, std::less_equal<> > = true
template<typename S>
constexpr bool	is_connex_v< dedekind::sets::SignedExtensionalCardinal< S >, std::less_equal<> > = true
template<>
constexpr bool	is_associative_v< SC, std::plus< SC > > = true
template<>
constexpr bool	is_associative_v< SC, std::multiplies< SC > > = true
template<>
constexpr bool	is_commutative_v< SC, std::plus< SC > > = true
template<>
constexpr bool	is_commutative_v< SC, std::multiplies< SC > > = true
template<>
constexpr bool	is_distributive_v< SC, std::multiplies< SC >, std::plus< SC > > = true
template<>
constexpr bool	is_invertible_v< SC, std::plus< SC > > = true
template<>
constexpr bool	is_reflexive_v< SC, std::less_equal<> > = true
template<>
constexpr bool	is_transitive_v< SC, std::less_equal<> > = true
template<>
constexpr bool	is_antisymmetric_v< SC, std::less_equal<> > = true
template<>
constexpr bool	is_connex_v< SC, std::less_equal<> > = true
template<>
constexpr bool	is_associative_v< Card, std::plus< Card > > = true
template<>
constexpr bool	is_associative_v< Card, std::multiplies< Card > > = true
template<>
constexpr bool	is_commutative_v< Card, std::plus< Card > > = true
template<>
constexpr bool	is_commutative_v< Card, std::multiplies< Card > > = true
template<>
constexpr bool	is_distributive_v< Card, std::multiplies< Card >, std::plus< Card > > = true
template<>
constexpr bool	is_reflexive_v< Card, std::less_equal<> > = true
template<>
constexpr bool	is_transitive_v< Card, std::less_equal<> > = true
template<>
constexpr bool	is_antisymmetric_v< Card, std::less_equal<> > = true
template<>
constexpr bool	is_connex_v< Card, std::less_equal<> > = true
template<>
constexpr bool	is_closure_forcing_v< std::negate<>, dedekind::sets::Cardinality, dedekind::sets::SignedCardinality > = true
template<>
constexpr bool	is_closure_forcing_v< std::minus<>, dedekind::sets::Cardinality, dedekind::sets::SignedCardinality > = true
template<>
constexpr bool	is_epic_arrow_v< std::decay_t< decltype(dedekind::sets::abs_)> > = true
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(lift_ℕ_ℤ_)> >
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(lift_ℕ_ℤ_)>, std::less_equal<> > = true
template<>
constexpr bool	is_monic_arrow_v< std::decay_t< decltype(embed_𝕂3_ℤ_)> >
template<>
constexpr bool	is_monotone_v< std::decay_t< decltype(embed_𝕂3_ℤ_)>, std::less_equal<> >
template<typename T, IsOckhamAlgebra L, typename P, dedekind::sets::IsCardinality C>
constexpr bool	idempotent_leaf_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< T, L, C >, P > >
template<typename A, typename B, typename L, typename C, typename P>
constexpr bool	is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, P > > = true
template<typename A, typename B, typename L, typename C, typename P>
constexpr bool	is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, P > >

Detailed Description

matrix__Categorical_Anchor_For_Subscript

Pin the category:cartesian opt-in marker (#531) on Matrix2x2V<T>: the matrix subscript m[i] realises the CCC eval counit at the outer index, with the row's own operator[] closing m[i][j] over the inner index — together yielding the textbook entry m_{ij}.

tuple__Monadic_Unit_Witnesses

The functors above are the morphism-lifting half of a Kleisli triple; this section pins the η / unit half — the scalar → linear-map lift that the user expects to see at the linear-algebra layer. For Vec2V<T> and Covec2V<T> the canonical unit is the diagonal broadcast s ↦ {s, s}, which is the element of the kernel of the difference map {x, y} ↦ x − y. Together with the elementwise functorial lift in vec2_functor / covec2_functor, this gives a Reader-flavoured Kleisli triple ([2] → T with diagonal bind); the corresponding operator>>= is intentionally deferred to a follow-up since the project's Reader monad is not yet generalised beyond Path <·>.

vec2__Categorical_Anchors_For_Operators

Pin the category:cartesian / category:kleisli opt-in markers (#531) on the homogeneous-pair carriers: Vec2V<T> and Covec2V<T> realise the CCC eval counit through operator[]; Vec2V<T> also realises comonadic extract ε through operator-> via the ArrowView proxy (first / second projection of the pair).

rational__Kleene_Traits_in_Category_Namespace

Specializations of Kleene traits for Rational types. These must be in the dedekind::category namespace where the traits template variables are declared.

Typedef Documentation

Π

template<std::size_t K, typename P>

using dedekind::category::Π = typename detail_limit::projection_arrow<K, P>::type

export

π_k read at the product P, as a MORPHISM (Domain = P, Codomain the k-th part): the building block of IsArrowProduct. Π<0, P> is Identity

. It forwards to π_k, so it copies nothing where the component is a reference (a reducer node's operand).

Template Parameters

K	the slot.
P	the product.

ι

template<std::size_t K, typename A, typename B>

using dedekind::category::ι = Injection<K, A, B>

export

The injection by its textbook name, \(\iota_K\) (Pierce), as the projection is Π.

Template Parameters

K	the summand, 1 or 2.
A,B	the summands.

Alphabet

using dedekind::category::Alphabet

export

Initial value:

 
    unfold_view<std::optional<std::byte>,
                detail_chain::SliceStep<std::byte, Letters>>

The byte alphabet's type, as abc builds it: the letters under their predicate, a filtered chain of the bytes. Listing 5's Alphabet bases. (#1141: the first carrier of the alphabet concept.).

At

template<std::size_t K>

using dedekind::category::At = std::integral_constant<std::size_t, K>

export

The projections π_k out of a product, one family: π_1, π_2 (Pierce, Basic Category Theory for Computer Scientists §1.4), π_3 and π_<k> for a flat n-ary product, and π for the one-fold product A¹ ≅ A, whose projection is the identity.

limit__Products_and_Projections

Binary products are limits of the discrete two-object diagram {* → A, * → B}; their natural home is here in :limit alongside IsTerminalObject / IsInitialObject (themselves limits of the empty / opposite-empty diagrams). Re-homed from :cartesian under #637 — :cartesian retains the strictly CCC-completing pieces (exponentials, currying, IsCartesianClosed).

Projection<k> is the projection arrow: called on a point it returns the point's k-th component, and the term grammar (sets:terms) reads the same object as the variable of slot k. One entity, two uses, so the categorical projection and the relational variable cannot drift.

The component is the ADL hook component(p, At<k>{}). Its default reads a tuple-like product by std::get (std::pair, std::tuple) and a pair-like one by .first / .second (Complex, Rational, the boundary witnesses). A carrier whose storage is named differently (Dual's val / der, a reducer node's operands) states its own overload in its home namespace. Sister of the coproduct injections ι_1 / ι_2 in :cartesian.

The slot k of a projection, as a type: the k of π_k.

BitWord

template<std::size_t W>

using dedekind::category::BitWord = typename detail_periodic::bit_word<W>::type

export

The bit word of width W, chosen by the width: the machine word for 8, 16, 32 and 64 bits, std::bitset otherwise.

Template Parameters

W	the width.

CanonicalSetCCC

template<typename A>

using dedekind::category::CanonicalSetCCC = Set<A>

export

Explicit alias for the canonical ETCS CCC witness over ambient A.

This alias exists to reduce naming ambiguity with dedekind::sets::Set (the intensional set-builder DSL species).

chain_t

template<std::regular X, std::semiregular Step>

using dedekind::category::chain_t = unfold_view<X, StepCoalgebra<X, Step>>

export

The chain of x under a partial step: what the step reaches from x, the step of it, then the step of that, until the step has nothing (Dedekind's chain of the step of x, [4]). With Prior it is \(n - 1, \ldots, 0\), the n elements below n, n itself excluded: the Jlt paper's Figure 2, after Lambek.

Template Parameters

X	the carrier.
Step	the partial step.

Parameters

x	the first element.
step	the step.

Returns

the view.

The type of chain(x, step).

Template Parameters

X	the carrier.
Step	the partial step.

classifier_logic_t

template<typename T>

using dedekind::category::classifier_logic_t

export

Initial value:

 
    typename ClassifierLogic<std::remove_cvref_t<T>>::type

Cod

template<IsArrow F>

using dedekind::category::Cod = typename std::remove_cvref_t<F>::Codomain

export

Shorthand to look up the Codomain of an Arrow type F.

Codomain analogue of Dom; same picking-policy slot.

codomain_t

template<typename F>

using dedekind::category::codomain_t

Initial value:

 
    typename MorphicBridge<typename signature_extractor<F>::type>::Codomain

Constant

template<typename X, typename Y = X>

using dedekind::category::Constant = ConstantMorphism<X, Y>

export

The constant arrow by its short name, the paper's spelling.

Template Parameters

X	the domain.
Y	the codomain, by default the domain.

disc_self_endofunctor_t

template<typename C>

using dedekind::category::disc_self_endofunctor_t = identity_functor<C>

export

Discrete-restriction representative of the textbook Disc / U functor: the identity endofunctor on a discrete category C.

In the meta-categorical Disc ⊣ U adjunction, both Disc and U restrict to identity-on-objects-and-arrows when their source / target collapses to a single discrete category C. This alias pins the identity endofunctor under that textbook role name so the adjunction-machinery static_asserts can refer to it directly.

disc_self_unit_t

template<typename C>

using dedekind::category::disc_self_unit_t = identity_transformation<disc_self_endofunctor_t<C>>

export

Discrete-restriction representative of the textbook unit η / counit ε of the Disc ⊣ U adjunction: the identity natural transformation on disc_self_endofunctor_t<C>.

In the meta-categorical adjunction the unit η_S sends each element of S to its embedding in U(F(S)); under the discrete restriction F = U = Id and η = ε is the identity natural transformation on the identity endofunctor. Pinned under the textbook role name so the adjunction machinery sees a bona fide named type rather than documentary commentary.

discrete_lift_t

template<typename S>

using dedekind::category::discrete_lift_t = DiscreteCategory<S>

export

) and Disc(\mathbb{N}) are not the same category. The resulting type follows the IsDiscreteCategory concept definition by construction; the per-instance witnesses below pin it on the project's representative IsSet carrier.

Companion to:

• The Set_to_Cat_Embedding doc-section in :discrete.
• The IsSet aggregator above (the source side of the lift).
• HasAdjunctionShape / IsAdjunction in :adjunction (the bona fide adjunction machinery, instantiated for this lift below).
• disc_self_endofunctor_t / disc_self_unit_t in :natural (the named entities reifying the textbook Disc / U / η / ε under the discrete restriction; consumed by the static_asserts below).

etcs__Disc_dashv_U_adjunction

In the textbook Disc : Set → Cat is the left adjoint of the underlying-objects functor U : Cat → Set. The adjunction Disc ⊣ U lives between the meta-categories Set and Cat. This codebase encodes categories per-ambient (one Species per IsSmallCategory type), so the meta-categorical statement is one level above what the type system can express directly — there is no category_of_sets or category_of_categories type whose Species ranges over all sets or all categories. What is type-level expressible is the restriction of the adjunction to a single discrete carrier: on Disc(S) every functor that respects the discrete shape is the identity on objects and arrows, so Disc and U restricted to Disc(S) collapse to the trivial self-adjunction

Id_{Disc(S)} ⊣ Id_{Disc(S)}

with identity unit / counit naturals. The witnesses below mechanically exhibit this restriction using the bona fide HasAdjunctionShape / IsAdjunction concepts from :adjunction — the same surfaces that gate the trivial self-adjunction exhibit in functor_test.cpp:138. The full meta-categorical Disc ⊣ U is left as future work (it needs category_of_sets / category_of_categories types that the project does not yet model); tracked under #587.

Discrete-restriction lift filed and addressed under #572.

Dom

template<IsArrow F>

using dedekind::category::Dom = typename std::remove_cvref_t<F>::Domain

export

Shorthand to look up the Domain of an Arrow type F.

Picking-policy slot 1 of 3 — see the policy comment above. Use this in IsArrow-strict contexts; for primitive-aware generality use element_of_t from :sets:boundaries.

domain_t

template<typename F>

using dedekind::category::domain_t

Initial value:

 
    typename MorphicBridge<typename signature_extractor<F>::type>::Domain

Exponential

template<typename A, typename B>

using dedekind::category::Exponential

export

Initial value:

 
    decltype(exponential<A, B>(std::declval<std::function<B(A)>>()))

The Exponential Object B^A (Type Alias).

Now defined specifically as the result of the exponential factory.

FiniteChainSequence

template<IsCountWord N, IsFiniteChainSequence F>

using dedekind::category::FiniteChainSequence

export

Initial value:

 
    unfold_view<N, Mapped<N, StepCoalgebra<N, Prior<N>>, F>>

The finite sequence as a value, n >> chain<N>() >> f: the chain of n read by f, never built. A fold over it is the list as its fold, the Church encoding (#1133).

Template Parameters

N	the counts.
F	the arrow.

Flip

template<typename A, typename B>

using dedekind::category::Flip = Pairing<Π<2, std::pair<A, B>>, Π<1, std::pair<A, B>>>

export

flip, the symmetry of the cartesian product, \(\sigma_{A,B} : A \times B \to B \times A\): the pairing of the projections the other way round, \(\langle \pi_2, \pi_1 \rangle\). On a square an involution, so an isomorphism, its own inverse; natural in both factors, \(\sigma \circ (f \times g) = (g \times f) \circ \sigma\), the braiding of the cartesian monoidal structure, symmetric. A word of two letters flipped is the word reversed.

Template Parameters

A
B	the factors.

narrowest_count_word

template<std::size_t Bits>

using dedekind::category::narrowest_count_word

export

Initial value:

 
    std::conditional_t<(Bits <= 32), std::uint32_t, std::uint64_t>

The narrowest count word on the ladder holding Bits: the stage of the filtered colimit a count of that many bits factors through. The rungs are the words whose products stay in them (IsCountWord): 32 and 64 bits; past the top there is none, and the count stays in its factors, compared and multiplied exactly there.

Template Parameters

Bits

the bits.

Negate

using dedekind::category::Negate = std::negate<int>

morphism__Morphism_Lifting_Proof

OmegaOf

template<typename Pred, typename T>

using dedekind::category::OmegaOf

export

Initial value:

 std::remove_cvref_t<
    std::invoke_result_t<const std::decay_t<Pred>&, const T&>>

Extract the Ω-type of a LogicalMap.

One

using dedekind::category::One = std::monostate

export

The Terminal Object (1): the unique sink of every morphism.

Categorification of std::monostate as the Terminal Object. std::monostate is a unit type (exactly one value, {}), making it the canonical C++ representative of the categorical "1". Every species T admits exactly one morphism T → One (the constant function).

See also

IsTerminalObject, bang()

Opposite

template<std::semiregular Op>

using dedekind::category::Opposite = typename detail_involution::opposite<Op>::type

export

The opposite operation, \(a \cdot^{op} b = b \cdot a\), the product of the opposite monoid \(M^{op}\) (Mac Lane, Categories for the Working Mathematician, II.2), an involution on operations: Opposite<Opposite<Op>> is Op, the same type. A left action of \(M\) is a right action of \(M^{op}\), so a left action folded along a walk acts by the product in \(M^{op}\). The laws read backwards are the laws: associativity, the unit, commutativity and idempotence carry over, declared once here, and totality in :total.

Template Parameters

Op	the operation.

PowerObject

template<typename A, typename L = Boole>

using dedekind::category::PowerObject = Exponential<A, typename L::Ω>

export

Power Object Alias.

In a Topos, P(A) is the exponential object Ω^A.

ProductArrow

template<IsArrow F, IsArrow G>

using dedekind::category::ProductArrow

export

Initial value:

 Pairing<Compose<Π<1, std::pair<Dom<F>, Dom<G>>>, F>,
                             Compose<Π<2, std::pair<Dom<F>, Dom<G>>>, G>>

f × g = ⟨f ∘ π₁, g ∘ π₂⟩ : A × C → B × D.

reduce_t

template<typename Term, typename Less, typename Ord = canonical_order, typename Combine = no_leaf_combine>

using dedekind::category::reduce_t

export

Initial value:

 
    decltype(cata(std::declval<const Reduce<Less, Ord, Combine>&>(),
                  std::declval<const Term&>()))

The normal form of Term under Reduce<Less, Ord, Combine>: the type the fold produces, read without running it.

resolved_order_t

template<typename T, typename Ord>

using dedekind::category::resolved_order_t

export

Initial value:

 std::conditional_t<std::same_as<Ord, canonical_order>,
                                            std::less_equal<T>, Ord>

The comparator Ord resolves to for a carrier T: std::less_equal<T> for canonical_order, otherwise Ord itself.

SignedCardinality

using dedekind::sets::SignedCardinality

Signed counterpart of Cardinality with ±ℵ_0 escalation; the library's bona-fide proxy for \(\mathbb{Z}\) modulo physical limits.

Variant of (SignedExtensionalCardinal<>, +ℵ_0, −ℵ_0, NaZ). The finite alternative is the default-constructed first slot, so SignedCardinality{} is canonical zero.

Same picture as Cardinality (the ℕ proxy), with a sign added:

• Not cyclic — arithmetic does not wrap modulo capacity.
• On signed overflow, escalates (saturates) into ±ℵ_0 according to the sign of the operands.
• Indeterminate forms (+ℵ_0 + (−ℵ_0), 0 * ±ℵ_0, ±ℵ_0 / ±ℵ_0, x / 0) propagate the NaZ sentinel IEEE-NaN-style rather than throwing, keeping the carrier usable in constexpr / NTTP-shaped contexts that cannot observe exceptions.
• The finite fragment SignedExtensionalCardinal<> is one two's-complement word (so the variant is not a bignum). The explicit overflow story is escalation to \(\pm \aleph_0\), not bigint growth: signed-overflow UB and silent wrap are replaced by the saturation behaviour.

Strictly mathematically, \(\mathbb{Z} \cup \{\pm \aleph_0, \mathit{NaZ}\}\) is not a group in the textbook sense (+ℵ_0 + (−ℵ_0) = NaZ breaks the inverse law for the saturating elements). The library's pragmatic certificate accepts it as a proxy for \(\mathbb{Z}\) because the finite fragment is \(\mathbb{Z}\) exactly and the saturation / NaZ behaviour is the explicit overflow contract: "if you compute beyond memory limits, you saturate at @c ±ℵ_0; if you compute an indeterminate form, you get @c NaZ". Downstream code that requires strict-ℤ behaviour should test the finite-fragment alternative (std::holds_alternative<SignedExtensionalCardinal<>>).

Same shape as how unsigned int's IsRing claim is "modulo wrap" rather than literal \(\mathbb{Z}\) — the project's stance is that the truthful name for the carrier includes the overflow / saturation behaviour, and the trait registry pins what the carrier actually does at the limits.

SumArrow

template<IsArrow F, IsArrow G>

using dedekind::category::SumArrow

export

Initial value:

 Copairing<Compose<F, Injection<1, Cod<F>, Cod<G>>>,
                           Compose<G, Injection<2, Cod<F>, Cod<G>>>>

f + g = [ι₁ ∘ f, ι₂ ∘ g] : A + C → B + D.

TerminalCategory

using dedekind::category::TerminalCategory = DiscreteCategory<One>

export

limit__Realizations

XOR

using dedekind::category::XOR = std::bit_xor<unsigned int>

total__Boolean_Ring_Negative_Proof

Zero

using dedekind::category::Zero = std::nullptr_t

export

The Initial Object (0): the unique source of every morphism.

Categorification of std::nullptr_t as the Initial Object. std::nullptr_t has exactly one value (nullptr) that cannot be constructed from anything else, making it the canonical C++ representative of the categorical "0". From Zero, there exists exactly one (logically unreachable) morphism to every species T, the zero morphism.

See also

IsInitialObject, zero()

ZeroZ

using dedekind::category::ZeroZ = decltype(zero<int, int, std::plus<int>>())

action__Module_FreeModule_EndoRing_Trait_Registry

The NEW-A trait registry (#498/#499) was previously declared here as opt-in trait variables. It now lives where the underlying concepts live, in concept-based-default form so that every carrier that structurally satisfies the algebra automatically registers (no per-carrier opt-in required):

• is_module_v<M, R> — dedekind.algebra:modules (concept-default = IsModule<M, R>).
• is_vector_space_v<V, F> — dedekind.algebra:vectorspace (concept-default = IsVectorSpace<V, F>).
• is_free_module_v<M, R, N> — dedekind.linear_algebra:basis is_endomorphism_ring_v<A, V> (opt-in trait variables; carry structural metadata N or the A=End(V) identity that no concept derives from the operator surface alone).

Morphism Verification

Symmetry: Zero vs. Groupoid

Enumeration Type Documentation

ArrowLaw

enum class dedekind::category::ArrowLaw : unsigned

exportstrong

posetal__The_Laws_Of_A_Function

A law of a function (injective, surjective, monotone, antitone, involutive, constant) is a class of arrows; an arrow's profile (Profile, :logic) is the laws it is known to have. The profiles are a finite algebra over the formers of arrows (∘, ×, +, ⟨,⟩, [,]): per law a homomorphism into (Σ, ∧) where the law is closed under the former, the sign product where it is a variance (the group {+, −} of #908, with an absorbing "unknown"), and an entailment that saturates a profile (a closure operator). The profile of an arrow term is the unique homomorphism out of the term algebra (initial-algebra semantics: a fold, LawAlgebra for cata in :f_algebra), sound because each former's rule soundly abstracts the former (abstract interpretation: inferred ≤ true). Read twice: by the traits on Compose at compile time (below), by a fold over a term built at runtime. Monotone and antitone are read under an order Op; a former over a product reads each leg under its own order and combines the profiles here.

CardinalityTag

enum class dedekind::category::CardinalityTag

exportstrong

logic__Cardinality_Ontology_Tokens

Ternary

enum class dedekind::category::Ternary : std::int8_t

exportstrong

A three-valued propositional logic for handling partial information.

logic__Species_2

Indeterminacy)

Unlike Boole, Kleene's three-valued logic allows for an 'Unknown' state, modeling undecidability or missing knowledge within a predicate. This implementation follows Kleene's strong logic of indeterminacy (K3).

@values

• False (-1): The absolute negative.
• Unknown (0): The indeterminate or undecidable state.
• True (1): The absolute positive.

Function Documentation

η()

template<typename A>
requires IsSpecies<std::decay_t<A>>

std::tuple< std::decay_t< A > > dedekind::category::η ( tuple_monad_tag , A value )

constexprexport

The std::tuple<T> Frobenius monad.

std::tuple<T> is a 1-tuple — it always has a single element, so the comonadic counit std::get<0> is total (no Some-fragment caveat) and the duplicate wraps once more cleanly. Combined with the textbook monadic structure (η as std::make_tuple, μ via std::get<0> on the inner tuple), this makes std::tuple<T> the project's Frobenius monad — both Kleisli and co-Kleisli laws hold without concession, and the Frobenius law relating μ and δ (is_frobenius_monad, :kleisli).

Replaces the vestigial Box-as-trivially-comonadic carrier retired in #632.

ι_1()

template<typename A, typename B>

auto dedekind::category::ι_1 ( A value )

constexprexport

Left injection ι₁: A → A + B.

Wraps a value of type A into the coproduct std::variant<A, B>. When A and B are the same type, uses std::in_place_index<0> to unambiguously select the first alternative.

ι_2()

template<typename A, typename B>

auto dedekind::category::ι_2 ( B value )

constexprexport

Right injection ι₂: B → A + B.

Wraps a value of type B into the coproduct std::variant<A, B>. When A and B are the same type, uses std::in_place_index<1> to unambiguously select the second alternative.

κ() [1/2]

template<typename MA, typename F>
requires requires(MA const& ma, F&& f) { μ(detail_kleisli::lifted(ma, std::forward<F>(f))); }

auto dedekind::category::κ ( MA const & ma, F f )

constexprexport

κ (kappa): Kleisli bind (monadic extension).

Given a monadic value ma: T and a Kleisli arrow f: A → T, produces a value of type T by: κ(ma, f) = μ(T(f)(ma)) This is the textbook Kleisli extension operation.

Template Parameters

MA	The monadic type (e.g., Maybe<T>, Identity<T>)
F	The function type to apply (typically A → MA)

Parameters

ma	The monadic value to bind
f	The Kleisli arrow to extend

Returns

\(\mu(T(f)(ma))\)

κ() [2/2]

template<typename MonadTag, typename MA, typename F>
requires IsDefaultMonadTag<MonadTag> && requires(MonadTag tag, MA const& ma, F&& f) { μ(tag, detail_kleisli::lifted(ma, std::forward<F>(f))); }

auto dedekind::category::κ ( MonadTag tag, MA const & ma, F f )

constexprexport

κ with explicit monad-tag dispatch.

Default route: κ(tag, ma, f) = μ(tag, T(f)(ma)).

μ()

template<typename A>
requires std::semiregular<A>

Maybe< A > dedekind::category::μ ( Maybe< Maybe< A > > const & mma )

constexpr

μ for Maybe: flattens nested optional context.

Maybe<Maybe<A>> -> Maybe. On every value type, as its functor (maybe_functor) acts on every arrow: the Maybe monad on Set, not only on the registered species, so a Kleisli fold may carry any state.

σ() [1/2]

template<typename MonadTag, typename WA, typename F>
requires IsDefaultMonadTag<MonadTag> && requires(MonadTag tag, WA const& wa, F&& f) { detail_kleisli::lifted(δ(tag, wa), std::forward<F>(f)); }

auto dedekind::category::σ ( MonadTag tag, WA const & wa, F f )

constexprexport

σ with explicit monad-tag dispatch.

Default route: σ(tag, wa, f) = W(f)(δ(tag, wa)).

σ() [2/2]

template<typename WA, typename F>
requires requires(WA const& wa, F&& f) { detail_kleisli::lifted(δ(wa), std::forward<F>(f)); }

auto dedekind::category::σ ( WA const & wa, F f )

constexprexport

σ (sigma): Co-Kleisli extend (comonadic extension).

Given a comonadic value wa: W and a co-Kleisli arrow f: W → B, produces a value of type W by: σ(wa, f) = W(f)(δ(wa)) This is the textbook co-Kleisli extension operation (extend/cobind).

Template Parameters

WA	The comonadic type (e.g., std::tuple<T> as the Frobenius monad per kleisli__The_Tuple_Frobenius_Engine, or the identity- arrow Identity). Maybe is monad-only and intentionally not a comonadic carrier here (#632).
F	The function type to apply (typically W → B)

Parameters

wa	The comonadic value to extend
f	The co-Kleisli arrow to apply

Returns

\(W(f)(\delta(wa))\)

abc()

auto dedekind::category::abc ( std::string_view a )

constexprexport

The alphabet of its letters alone: the least slice of the bytes that holds them, under the predicate that keeps them, slice(lo, hi) >> letters(a) with lo the least letter and hi one past the greatest.

Parameters

a	the letters, as written: at least one, none the last byte.

Returns

the filtered byte chain, as bases is written. (#1141: one constructor of the alphabet concept, the filtered finite chain; the byte is its first carrier.)

antitone_cycle_type()

template<IsCountWord N>

AtMost< Cycles< N >, 2 > dedekind::category::antitone_cycle_type ( N m )

constexprexport

The cycle type of a finite chain's antitone bijection. A finite chain is rigid: its one antitone bijection is its reversal, the least element to the greatest and so inward, so \(\lfloor m/2 \rfloor\) pairs and, where m is odd, the middle fixed (#1133).

Parameters

m	the chain's length.

Returns

its cycles.

arrow()

template<typename F>
requires (!IsArrow<std::remove_cvref_t<F>>) && requires(F f) { typename signature_extractor<F>::type; }

auto dedekind::category::arrow ( F f )

constexprexport

morphism__Morphic_Factory

arrow_drill_down()

template<typename Whole>
requires requires { whole.operator->(); }

auto dedekind::category::arrow_drill_down ( const Whole & whole )

constexprexport

Generic opt-in drill-down projector for part-whole wrappers.

This is the upstream projector primitive used by downstream partitions (:posetal, :limit, and others) to express functional part access via operator-> while preserving explicit opt-in semantics.

Overloads support both wrapper types exposing a member operator-> and raw pointers.

arrow_drill_down_min()

template<typename Whole>
requires requires { arrow_drill_down(whole).min; }

auto dedekind::category::arrow_drill_down_min ( const Whole & whole )

constexprexport

Opt-in drill-down projector for min/max result carriers.

This helper specializes the upstream arrow_drill_down projector from :mereology to extract the min component used as an order witness.

Template Parameters

Whole

Carrier type accepted by arrow_drill_down(whole) where the projected object exposes a min field.

Parameters

whole

The projected carrier.

Returns

Reference to the min component used as the relation witness.

as_classified()

template<typename S>
requires IsSubobject<S, typename S::Domain>

ClassifierApex< S > dedekind::category::as_classified ( const S & s )

constexprexport

Parameters

s	a subobject.

Returns

it as the pullback of ⊤ along its characteristic map.

as_pullback()

template<IsCountWord N, std::size_t J, std::size_t K>

auto dedekind::category::as_pullback ( const RunList< N, J > & a, const RunList< N, K > & b )

constexprexport

The intersection as the pullback of the two inclusions into the counts, category's apex view over it (IsPullback): in the thin category of run lists, the meet is the pullback.

Parameters

a

param b two run lists on one chain.

Returns

the apex.

as_pushout()

template<IsCountWord N, std::size_t J, std::size_t K>

auto dedekind::category::as_pushout ( const RunList< N, J > & a, const RunList< N, K > & b )

constexprexport

The union as the pushout, dual to as_pullback (IsPushout).

Parameters

a

param b two run lists on one chain.

Returns

the apex.

associative()

template<typename T, typename Op>

bool dedekind::category::associative ( Op )

constexprexport

The laws as functions of the operation: associative<T>(Op{}), commutative<T>(Op{}), idempotent<T>(Op{}) and distributive<T>(Mul{}, Add{}).

Same split as unit: the is_*_v variable templates store the facts (partial specialisation, across modules), these functions read them, at compile time and at runtime alike.

Template Parameters

T	The carrier.

automaton() [1/3]

template<std::size_t Sigma = 4, std::size_t P = 8, std::size_t K = 32, std::size_t Q = 320, std::size_t KL = 256, IsCountWord N>

Maybe< Automaton< Sigma, Q > > dedekind::category::automaton ( const Prefixed< Power< std::byte, Letters, N >, Reverse, Reflection > & sites )

constexprexport

The matcher of the words of a section beginning with a prefix. The same builder on a subset of the same words; capacities as for a section.

Parameters

sites

the meet.

Returns

the plan, or nothing where a bound is too small.

automaton() [2/3]

template<std::size_t Sigma, std::size_t P, std::size_t K, std::size_t Q, IsCountWord N, std::size_t KL>

Maybe< Automaton< Sigma, Q > > dedekind::category::automaton ( const RunList< N, KL > & sites, std::type_identity_t< N > length )

constexprexport

The matcher specialised to a set of words of one length: the minimal automaton of \(\Sigma^* L\), canonical.

Template Parameters

Sigma	the letters.
P	the bound on the words' length.
K	the bound on the steps of a pending set.
Q	the bound on the states.

Parameters

sites	the words, as the indices of their letters in base Sigma, the first letter the most significant.
length	their length.

Returns

the plan, or nothing where a bound is too small.

automaton() [3/3]

template<std::size_t Sigma = 4, std::size_t P = 8, std::size_t K = 32, std::size_t Q = 320, std::size_t KL = 256, HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>

Maybe< Automaton< Sigma, Q > > dedekind::category::automaton ( const Symmetric< Power< C, F, N >, S, T > & sites )

constexprexport

The matcher specialised to a section: its words as a run list, then the plan. The capacities default to a menu's largest, four letters, words of length 8, pending sets of 32 steps and 320 states, the one pynzli offers too, so automaton(sites) reads alike in both languages; a tighter bound is named where the plan is a constant.

Template Parameters

KL	the bound claimed on the section's steps.

Parameters

sites

the section, Listing 5's sites.

Returns

the plan, or nothing where a bound is too small.

bang()

template<typename T>

auto dedekind::category::bang ( )

constexprexport

The terminal map factory: produces the unique arrow !: T → One.

For every species T there is exactly one morphism to the Terminal Object. This factory constructs it as a constant function that ignores its input and returns One{} (std::monostate{}).

Template Parameters

T	The domain species.

bit_patterns()

auto dedekind::category::bit_patterns ( std::size_t n )

constexprexport

The bit patterns of width n as a chain: the counts below \(2^n\), which binary numeration makes the words of \(\mathbb{B}^n\), bit i the letter at position i. No pattern is built: an arrow along the chain reads it. Refused past the word, where the patterns are no sequence a std::size_t can index. Counting by the laws never builds a pattern at any width; a pattern is packed only where an operation reads it, at any width known at compile time, and at run time up to max_packed_width (wider, in blocks, is #1109).

Parameters

n	the width.

Returns

the chain of patterns.

bits_needed()

template<typename L, IsCountWord N = detail_periodic::word_of_t<L>>
requires detail_periodic::IsFactorsOf<L, N>

std::size_t dedekind::category::bits_needed ( const L & fs )

constexprexport

The bits a count needs at most, read off its factors without multiplying them: \(\prod b_i^{e_i} \le 2^S\) with \(S = \sum e_i \lceil \log_2 b_i \rceil\), so at most \(S + 1\) bits, S + 1 exactly where the product is \(2^S\); none for an empty factor; saturating. The same fold as count, in the other monoid: count folds \(b^e\) by \(\times\), this folds its image under CeilLog2 by \(+\), and the lax homomorphism between them is the bound. An abstract interpretation (Cousot and Cousot): the abstraction of a Galois connection between sets of values and their widths (IsGaloisConnection), sound by the adjunction. \(\mathbb{N}\) is the filtered colimit of the words \(\mathbb{N}_{<2^8} \hookrightarrow \mathbb{N}_{<2^{16}} \hookrightarrow \cdots\) (:filtered), and a finite count is compact, so it factors through a finite stage: this says which, before the count is computed (#1134).

Parameters

fs	the factors.

Returns

the bits.

bytes()

template<std::size_t M>
requires (M >= 1)

Bytes< M - 1 > dedekind::category::bytes ( const char(&) s[M] )

constexprexport

Parameters

s

the text.

Returns

its bytes, without the terminator.

call()

template<auto f, typename T>
requires IsArrow<decltype(f)>

T dedekind::category::call ( T x )

constexprexport

A stateless arrow as a function: &call<F{}, T> is a pointer through which F{} is called, so that an empty arrow has a representation with one storage class (:cartesian's Morphisms).

Template Parameters

f	the arrow, a value determined by its type.
T	the object.

cata() [1/2]

template<typename β, typename T>
requires Steers<β, T> || IsTermNode<T> || std::invocable<const β&, const T&>

auto dedekind::category::cata ( const β & alg, const T & t )

constexprexport

cata ⦇β⦈ — the catamorphism (fold): the unique F-algebra homomorphism from the initial algebra (the term itself, μF) into an algebra (B, β).

Pierce (§2.2, and Meijer et al.'s "bananas"): for the term functor F, the term type is the initial algebra μF, with in : F(μF) → μF the constructor and, by Lambek, an iso, so μF ≅ F(μF). For any algebra (B, β) with β : F(B) → B there is a unique homomorphism cata(β) : μF → B satisfying cata(β) ∘ in = β ∘ F(cata(β)). Reading that fixpoint left to right is the implementation: legs exposes the sub-terms, F(cata) folds them (recurse), then β combines the results — a post-order fold applying β once per node.

The engine is law-free (a Scheme-apply-style dispatcher): it only knows to recurse and apply β. The algebra is a callable: β(leaf) on a leaf, β(node, folded_legs...) on a node, so an algebra states only the nodes it reads specially and one rule for the rest. An algebra whose results are std::integral_constant folds entirely inside decltype: a type-level reading (a certificate) and a value-level one (an evaluation) are the same fold.

Steering (Mendler style): a strict fold evaluates every leg. Where an algebra must not (McCarthy's conditional evaluates only the branch it selects), it defines β.steer(node) and recurses with cata(β, leg) into the legs it chooses. The engine tries steer first, then the strict fold, then the leaf.

Note

A grow-then-shrink β re-invokes cata on its result to reach a fixpoint; the laws here are shrink-only, so one pass suffices.

Template Parameters

β	the algebra.
T	the term.

Parameters

alg	the algebra.
t	the term.

Returns

the term's image under the algebra.

cata() [2/2]

template<IsArrow T>

auto dedekind::category::cata ( const T & t )

constexprexport

cata(t): the term rewritten to its normal form under the β-reduction algebra. simplify is cata. The IsArrow gate keeps a bare product out of the term universe.

Template Parameters

T	an arrow term.

Parameters

t

the term.

certify_add() [1/2]

template<std::integral T, typename Policy>
requires IsLipschitzBoundaryPolicy<Policy, T>

NumericWitness< T > dedekind::category::certify_add ( T a, T b, Policy policy )

constexprexport

Certified integer addition with an explicit support policy.

Arithmetic overflow is surfaced as Ω_K3::Unknown. Support-policy violations propagate the policy's ternary result, which may be Ω_K3::False or Ω_K3::Unknown depending on the boundary policy.

certify_add() [2/2]

template<std::floating_point T, typename Policy = NaNHolePolicy<T>>
requires IsLipschitzBoundaryPolicy<Policy, T>

NumericWitness< T > dedekind::category::certify_add ( T a, T b, Policy policy = {} )

constexprexport

Certified floating addition with NaN-hole policy.

The default policy maps NaN to Unknown.

certify_add_int_interval()

DEDEKIND_BRIDGE_NOINLINE DEDEKIND_BRIDGE_CONSTEXPR NumericWitness< int > dedekind::category::certify_add_int_interval ( int a, int b, IntervalBoundaryPolicy< int > policy )

export

Non-template bridge functions for profiler-friendly attribution.

numeric__Coverage_Bridge_API

These wrappers preserve the template-based public API while providing concrete entry points that coverage tools can attribute more consistently across module boundaries.

certify_div()

template<std::integral T, typename Policy>
requires IsLipschitzBoundaryPolicy<Policy, T>

NumericWitness< T > dedekind::category::certify_div ( T a, T b, Policy policy )

constexprexport

Certified integer division with explicit policy.

Division by zero and signed MIN / -1 overflow are surfaced as False/Unknown.

certify_mul()

template<std::integral T, typename Policy>
requires IsLipschitzBoundaryPolicy<Policy, T>

NumericWitness< T > dedekind::category::certify_mul ( T a, T b, Policy policy )

constexprexport

Certified integer multiplication with an explicit support policy.

Signed overflow is surfaced as Ω_K3::Unknown. Support-policy failures are propagated via the policy result for the inputs/result and therefore may surface as either Ω_K3::False or Ω_K3::Unknown.

chain() [1/2]

template<HasNNOStep N>
requires std::regular<N>

auto dedekind::category::chain ( )

constexprexport

The default chain of a carrier with the NNO's step, the one its certificate supplies: n >> chain<N>() is what Prior<N> reaches from n, n - 1, ..., 0 (the Jlt paper's Listing 3).

Template Parameters

N	the carrier.

chain() [2/2]

template<IsArrow Step>
requires std::regular<Dom<Step>> && std::semiregular<Step>

Unfold< Dom< Step >, StepCoalgebra< Dom< Step >, Step > > dedekind::category::chain ( Step step )

constexprexport

The chain of a partial step, as an arrow from the seeds: x >> chain(out) is chain(x, out).

Parameters

out	the partial step.

check_path()

template<typename T, typename Rel = std::less_equal<T>, typename L = Boole, typename Project = std::identity>
requires IsPathProjection<Project, T, Rel, typename L::Ω>

L::Ω dedekind::category::check_path ( T a, T b, T c, Project project = {} )

constexprexport

Verify that a two-step path A→B→C exists in the posetal category.

This helper checks a two-edge witness A→B and B→C using the supplied relation and projector. The result is expressed in the truth-value codomain Ω of the chosen Logic species L, so it works uniformly for Classical, Ternary, or any other pluggable logical universe — no bool hard-codes.

If Rel also models a posetal relation for the projected carrier, transitivity gives the direct edge A→C as a derived fact.

Template Parameters

T	Object type.
Rel	Relation type used to witness each edge.
L	Logic species providing AND and the Ω codomain.

classifier_reindexing_definitional_witness_at()

template<typename S, IsArrow E>
requires IsSubobject<S, typename S::Domain> && std::same_as<Cod<E>, typename S::Domain> && std::equality_comparable< std::invoke_result_t<S const&, typename S::Domain const&>>

bool dedekind::category::classifier_reindexing_definitional_witness_at ( const S & s, const E & embedding, const Dom< E > & x )

constexprexport

Definitional witness check for Axiom 7 reindexing through embedding.

Confirms that χ_S(e(x)) is evaluable at value x. The equality χ_S(e(x)) = in_via(x, e, S) holds by definition of in_via; this function evaluates the common expression once and checks reflexivity, serving as a concrete evaluability witness for HasAxiom7PullbackReindexingDefinitionalSurface. Assumes referential transparency of the embedding arrow.

classifier_true()

template<typename A, typename L = Boole>
requires IsOckhamAlgebra<L>

auto dedekind::category::classifier_true ( )

constexprexport

The tautology / top predicate \(\top\) over domain A: the canonical always-true classifier A → Ω, constant at L::True. This is the topos truth arrow \(\top: 1 \to \Omega\) pulled back to a predicate on A (verum, "everything is a member"); use it wherever a whole-domain / unrestricted characteristic map is wanted rather than an ad-hoc [](const A&){ return true; } lambda.

See also

classifier_false ( \(\bot\)), constant_classifier (arbitrary grade).

classify()

template<typename F>
requires (!IsArrow<std::remove_cvref_t<F>>) && requires { typename signature_extractor<std::decay_t<F>>::type; } && IsΩ<codomain_t<std::decay_t<F>>>

auto dedekind::category::classify ( F f )

constexprexport

Domain-inferring classify: deduces A from the callable's signature.

Allows classify(f) when f is a lambda with a strongly-typed operator(), e.g. [](const Complex<R>& x) -> bool { ... }. The domain A is extracted via arrow's signature_extractor, so no explicit template argument is needed.

closure()

template<typename T, typename Expand, typename Join, typename Equal = std::equal_to<>>
requires std::predicate<const Equal&, const T&, const T&>

T dedekind::category::closure ( const T & x, Expand expand, Join join, Equal equal = {}, std::size_t max_iterations = 1024 )

constexprexport

The closure of x under expand: the textbook "closure of @c X under @c Y". It is the least fixpoint of S ↦ x ⊔ expand(S) — the smallest element ⊒ x closed under the one-step expansion expand — equivalently the Kleene join ⨆ₙ expandⁿ(x).

One operator over many constructions (proof by implementation): reflexive-transitive closure R* = closure(Δ, λS.S;R); reachability = its Boolean instance; semiring / critical-path closure swaps the join; subgroup / span / convex-hull are closure(X, ·op·) — the universal-algebra "generated by". join is the ⊔ (union / the semilattice join); expand applies Y once.

Decidable exactly where the carrier stabilises (finite / IsExtensional, so equal detects the fixpoint) or under the max_iterations bound — the N-th Kleene approximant, i.e. the finite-subgraph selection a partial evaluation performs before an infinite structure's closure can be computed at all.

collect()

template<std::regular S, std::semiregular Coalg>
requires detail_comprehension::IsBounded<Coalg>

auto dedekind::category::collect ( const unfold_view< S, Coalg > & q )

constexprexport

A query's present elements as a value, bounded by its take: the ext boundary, where a list is asked for (#1133). A plain sequence's elements as they are, a query's unwrapped.

Parameters

q	a bounded query or sequence.

Returns

its elements, on the stack.

columns_of()

Columns dedekind::category::columns_of ( const Letters & on )

constexprexport

Parameters

on	the alphabet's letters, at most 255 of them, as abc holds.

Returns

the table of their columns.

component() [1/3]

template<typename A, typename B>

A dedekind::category::component ( const Meet< A, B > & m, At< 1 >  )

constexprexport

π_1: the left-operand accessor of a binary node, returned by const-reference. The operand may itself be a whole set expression (a nested node), and π_1 / π_2 are pure projections. They must not copy the sub-structure. When the operand is a set, π_1(node) is then a bona fide reference to that IsSet (the downstream sets lift relies on this). Still ->convertible_to , so IsProduct is satisfied.

lattice__AST_as_product

A binary node is the categorical product / coproduct of its operands, so it inhabits category::IsProduct (the role sets::AndPredicate / OrPredicate held before #892, now hoisted to where the AST lives). The operands are recovered by the free π_1 / π_2 accessors (found by ADL, overriding the default .first / .second projection), and MakeMeet / MakeJoin are the pairing FACTORIES \(\langle -,- \rangle: A \times B \to P\), the Op that IsProduct names, whose result type (Meet vs Join) discriminates the meet-pairing (pullback) from the join-pairing (pushout). The meet / join distinction is the reduction (∧ vs ∨), not the pairing; both nodes store and project both operands.

component() [2/3]

template<typename P>
requires (!TupleLike<P>) && requires(const P& p) { p.first; }

auto dedekind::category::component ( const P & p, At< 1 >  )

constexprexport

The components of a pair-like product that is not tuple-like.

Parameters

p	the point.

component() [3/3]

template<typename P, std::size_t K>
requires TupleLike<P> && (K >= 1) && (K <= std::tuple_size_v<P>)

auto dedekind::category::component ( const P & p, At< K >  )

constexprexport

The k-th component of a tuple-like product, by reference: a projection reads its point without copying it (a string or vector carrier stays where it is). π_k returns a temporary's component by value.

Parameters

p	the point.

compose_embedding()

template<IsArrow F, IsArrow G>
requires std::same_as<Cod<std::decay_t<F>>, Dom<std::decay_t<G>>>

auto dedekind::category::compose_embedding ( F f, G g )

constexprexport

Compose two embedding arrows for pullback naturality path checks.

Produces h = f >> g : A → C, preserving IsArrow compatibility. Use instead of an ad-hoc lambda when building composed-path witnesses for downstream axiom-7 reindexing surfaces in :etcs. Raw lambdas do not carry Domain / Codomain typedefs, so they fail the IsArrow concept; this wrapper delegates to operator>> which returns a properly typed Morphism.

concat() [1/3]

template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>>
requires IsMonoid<T, Op> && IsCopies<R> && HasCountingAction<T, Op>

T dedekind::category::concat ( R r, Op op = {} )

constexprexport

concat on n copies of one value where the counts act in one step: \(x^n\) by the counting action, \(n \cdot x\) over a semimodule, x under an idempotent operation. The same signature as the binary method of :total and a stronger constraint, so resolution prefers it.

Parameters

r	the copies.
op	the operation.

concat() [2/3]

template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>>
requires IsMonoid<T, Op> && IsCopies<R>

T dedekind::category::concat ( R r, Op op = {} )

constexprexport

concat on n copies of one value: its n-th power, by squaring its first half, licensed by associativity. The same signature as the plain fold and a stronger constraint, so resolution prefers it wherever IsCopies holds. The value is read only where there is a copy, as a model promises it.

Parameters

r	the copies.
op	the operation.

concat() [3/3]

template<std::ranges::input_range R, typename T = std::ranges::range_value_t<R>, typename Op = std::plus<T>>
requires IsMonoid<T, Op>

T dedekind::category::concat ( R r, Op op = {} )

constexprexport

The free monoid's fold, concat, the canonical fold of a monoid: a range folded under the operation from its unit (the Jlt paper's Listings 2 to 4). Its specialisation, licensed by associativity, folds n copies of one value, any IsCopies range, by the binary method, one squaring per bit of n (Knuth, TAOCP 2 §4.6.3). Resolution picks it over the plain fold, its parameter being the more specific.

total__Concat

Parameters

r	the range.
op	the operation.

congruent()

template<IsCountWord N = std::size_t>

Congruent< N > dedekind::category::congruent ( std::type_identity_t< N > m, std::type_identity_t< N > r )

constexprexport

The residue class of r modulo m.

Template Parameters

N	the counts.

Parameters

m	the modulus, positive.
r	the residue, taken modulo m.

copies_count() [1/2]

template<std::copy_constructible T, std::integral B>
requires (!std::same_as<B, bool>)

std::make_unsigned_t< B > dedekind::category::copies_count ( const std::ranges::repeat_view< T, B > & r )

constexprexport

The standard's views::repeat(x, n) is n copies of x; its value is read only where n is not zero.

Parameters

r

the view.

copies_count() [2/2]

template<IsCountWord N, IsConstantArrow F>

N dedekind::category::copies_count ( const unfold_view< N, Mapped< N, StepCoalgebra< N, Prior< N > >, F > > & r )

constexprexport

The counting chain of n under a constant arrow, n >> chain<N>() >> constant(x), is n copies of x, counted in the chain's own word.

Parameters

r	the chain.

count() [1/9]

template<IsArrow T, std::size_t K, IsCountWord N>

N dedekind::category::count ( const Box< T, K, N > & b )

constexprexport

The count over the box, SQL's COUNT(*) over a cross join: by distributivity the product of the legs' counts, contracting the rank-one tensor against the all-ones covector on each leg. Exact beyond the word only as its factors (count_factors); this is its residue.

Parameters

b	the outer product.

Returns

the count, modulo the word.

count() [2/9]

template<IsCountWord N, HasPeriod F>
requires std::same_as<Dom<F>, N> && std::convertible_to<Cod<F>, bool>

N dedekind::category::count ( const FiniteChainSequence< N, F > & v )

constexprexport

The count along the chain of n under a periodic predicate: (n div p) periods and a remainder, by periodicity; the chain's order does not matter, since the counts commute. More specialised than the plain fold, so resolution prefers it.

Parameters

v	the chain under the predicate.

Returns

how many of f(0), ..., f(n - 1) are true.

count() [3/9]

template<IsCountWord N, HasPeriod P>
requires std::same_as<Cod<P>, bool>

N dedekind::category::count ( const FiniteChainSequence< N, Where< P > > & q )

constexprexport

The count of a chain under a periodic filter: the count of the filter's characteristic sequence, which :periodic takes period by period (the lcm for a meet), no walk of the query. The law count(where(p)) = count(χ_p), used as the rewrite.

Parameters

q	the filtered chain.

Returns

how many elements it keeps.

count() [4/9]

template<typename L, IsCountWord N = detail_periodic::word_of_t<L>>
requires detail_periodic::IsFactorsOf<L, N>

N dedekind::category::count ( const L & fs )

constexprexport

The count of a factored tensor, modulo the word: a monoid concat under * over the factors, each a concat on copies of a popcount, by squaring. Agrees with exact_count wherever the word holds the count.

Parameters

fs	the factors.

Returns

the count, modulo the word.

count() [5/9]

template<IsQuery Q>

Maybe< std::size_t > dedekind::category::count ( const Maybe< Q > & q )

constexprexport

A query that may not be (a plan past its capacity), counted: the count lifted through Maybe, nothing where the query is nothing. The monad carries the uncertainty to the end, so no caller cases on it.

Parameters

q	the query, or nothing.

Returns

its count, or nothing.

count() [6/9]

template<IsCountWord N, HasPeriod F>
requires std::same_as<Dom<F>, N> && std::convertible_to<Cod<F>, bool>

N dedekind::category::count ( const unfold_view< std::optional< N >, detail_chain::SliceStep< N, F > > & v )

constexprexport

The count along a chain restricted by value to [lo, hi) under a periodic predicate: the law's count below hi less the law's count below lo, two calls whatever the bounds.

Parameters

v	the restricted chain under the predicate.

Returns

how many of f(lo), ..., f(hi - 1) are true.

count() [7/9]

template<typename P, typename S>
requires requires(const P& p, const S& s) { occurrences(p, s); }

auto dedekind::category::count ( const WindowJoin< P, S > & j )

constexprexport

Parameters

j	a join on the window.

Returns

its count, COUNT(*), modulo the word: occurrences.

count() [8/9]

template<IsCountWord N = std::size_t, IsQuery Q>

N dedekind::category::count ( Q q )

constexprexport

The count of a query, SQL's COUNT: its present elements, the tally lifted through Maybe.

Template Parameters

N	the counts.

Parameters

q	the query.

Returns

how many elements it holds.

count() [9/9]

template<IsCountWord N = std::size_t, std::ranges::input_range R>
requires std::convertible_to<std::ranges::range_value_t<R>, bool>

N dedekind::category::count ( R r )

constexprexport

The count of a range of truth values: the plain fold.

Template Parameters

N	the counts.

Parameters

r	the range.

Returns

how many are true.

count_factors() [1/7]

template<IsArrow T, std::size_t K, IsCountWord N>

std::array< N, K > dedekind::category::count_factors ( const Box< T, K, N > & b )

constexprexport

Each leg's count over its chain, the factors of the box's count.

Parameters

b	the outer product.

Returns

the counts, leg by leg.

count_factors() [2/7]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires requires(const S& s) { requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; }

auto dedekind::category::count_factors ( const Cylinder< Power< C, F, N >, S, N > & c )

constexprexport

The factors of a cylinder's count, aggregate pushdown (eager aggregation: Yan and Larson, VLDB 1995), derived rather than stated: the selection pushed down (pushed_down), then the box law of the outer product, the set's count times \(|\Sigma|^{N - n}\) for the free legs. Empty where no word's window can lie in the set: a window past the end, or a set of words of another length.

Parameters

c	the cylinder.

Returns

its count, factored.

count_factors() [3/7]

template<IsCountWord N>

AtMost< Factor< N >, 1 > dedekind::category::count_factors ( const Offsets< N > & o )

constexprexport

Parameters

o	the offsets.

Returns

their count, one factor.

count_factors() [4/7]

template<HasFactors A, HasFactors B>
requires std::same_as< detail_periodic::word_of_t<decltype(count_factors(std::declval<A>()))>, detail_periodic::word_of_t<decltype(count_factors(std::declval<B>()))>>

auto dedekind::category::count_factors ( const Outer< A, B > & o )

constexprexport

Parameters

o	an outer product.

Returns

its count, factored: both factors' factors, in their one word.

count_factors() [5/7]

template<HasNNOStep C, IsArrow F, IsCountWord N>

AtMost< Factor< N >, 1 > dedekind::category::count_factors ( const Power< C, F, N > & p )

constexprexport

The factors of a tensor power's count: the filtered alphabet's count, its packed characteristic function's popcount, raised to the length, by the box law.

Parameters

p	the power.

Returns

its count, factored.

count_factors() [6/7]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
requires HasCycleType<S, N>

auto dedekind::category::count_factors ( const Symmetric< Power< C, F, N >, S, T > & s )

constexprexport

The factors of a symmetric section's count: one merged leg per cycle of sigma, so the box law after the merges, the count Pólya's theorem gives for the words a permutation fixes.

Parameters

s	the section.

Returns

its count, factored.

count_factors() [7/7]

template<typename P, typename S>
requires requires(const P& p, const S& s) { occurrences(p, s); }

auto dedekind::category::count_factors ( const WindowJoin< P, S > & j )

constexprexport

The factors of a join's count: its plan's, the box law throughout, with no sum over the offsets left; none where no window fits.

Parameters

j

the join.

Returns

its count, factored.

count_section()

template<IsArrow T, std::size_t K, IsCountWord N>

N dedekind::category::count_section ( const Box< T, K, N > & b, std::type_identity_t< N > m, std::type_identity_t< N > r )

constexprexport

The count over the section \(i_1 + \cdots + i_K \equiv r \pmod m\) of the box, SQL's GROUP BY a computed key: the cyclic convolution of the legs' histograms over the residues, m numbers a leg, in the counts' semiring.

Parameters

b	the outer product.
m	the modulus, positive.
r	the residue.

Returns

the count, modulo the word.

cover()

template<HasNNOStep N>
requires std::equality_comparable<N>

std::optional< N > dedekind::category::cover ( const N & n )

constexprexport

The cover \(S^{+} : N \to 1 + N\) (y covers x: x < y, nothing between, Davey and Priestley [3], ch. 1): the successor read partially, nullopt at a fixpoint of S, which on a saturating bounded chain is its top (ℵ₀ on Cardinality, True on K₃), and at a machine word's greatest value, where S has no value (signed) or wraps (unsigned: the ring ℤ/2^w under S, the chain 0 < 1 < … < 2^w − 1 under its cover); total on an unbounded chain. Whether the step itself is monotone is the arrow's fact (IsMonotone<Successor<N>>, registered in order:completeness from the carrier's periodicity), not the carrier's. std::optional<N> is \(1 + N\), the NNO's own functor \(F(X) = 1 + X\).

Template Parameters

N	the carrier.

Parameters

n	an element.

Returns

the element covering n, if any.

curry()

template<typename T, typename Op>
requires (!IsArrow<Op>) && std::regular_invocable<const Op&, const T&, const T&>

Curried< T, Op > dedekind::category::curry ( Op op )

constexprexport

The operation curried.

Template Parameters

T	the carrier.

Parameters

op	the operation, a function object and no arrow (an arrow from a product has the overload above).

cycle_type() [1/2]

template<IsCountWord N>

AtMost< Cycles< N >, 1 > dedekind::category::cycle_type ( const Rotation< N > & r, N n )

constexprexport

The cycle type of a rotation of n positions by d: \(g = \gcd(n, d)\) cycles of length \(n / g\), the identity where d is a multiple of n.

Parameters

r	the rotation.
n	the length.

Returns

its cycles.

cycle_type() [2/2]

template<IsCountWord N>

AtMost< Cycles< N >, 2 > dedekind::category::cycle_type ( Reverse , N n )

constexprexport

The cycle type of the reversal of n positions: the antitone bijection of their chain.

Parameters

n	the length.

Returns

its cycles.

cylinder()

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; } && std::equality_comparable<F>

Cylinder< Power< C, F, N >, S, N > dedekind::category::cylinder ( const Power< C, F, N > & p, Window< N > w, S s )

constexprexport

Parameters

p	a tensor power.
w	a window on its words.
s	a set of words over the same legs: a power, or a symmetric section of one.

Returns

the words of p whose window lies in s.

declared_arrow_laws()

template<typename F, typename Op>

ArrowLaws dedekind::category::declared_arrow_laws ( )

constexpr

The profile of a typed arrow, its variances under Op. Read off the concepts (an iso, hence an involution, is already monic and epic).

Template Parameters

F	the arrow.
Op	the order.

equals()

template<std::equality_comparable A>

Equals< A > dedekind::category::equals ( A x )

constexprexport

The equality test's factory.

Parameters

x	the value.

eval()

template<typename F, typename A>
requires IsExponential<F, A, std::invoke_result_t<F, A>>

auto dedekind::category::eval ( F f, A a )

constexprexport

The canonical evaluation morphism for the CCC: (B^A × A) → B.

Applies a function (Exponential inhabitant) to its argument. This is the "eval" map that witnesses the adjunction between the product functor (– × A) and the exponential functor (–^A).

Template Parameters

F	A type satisfying IsExponential<F, A, B>.
A	The domain type.

exact_count() [1/3]

template<HasNNOStep C, IsArrow F, IsCountWord N>

std::optional< N > dedekind::category::exact_count ( const FreeMonoid< C, F, N > & m )

constexprexport

Parameters

m	the truncated free monoid.

Returns

how many words are shorter than its bound, exactly, or none where the word cannot hold it: then they are no sequence a word can index.

exact_count() [2/3]

template<typename L, IsCountWord N = detail_periodic::word_of_t<L>>
requires detail_periodic::IsFactorsOf<L, N>

std::optional< N > dedekind::category::exact_count ( const L & fs )

constexprexport

The count of a factored tensor, exactly, or none where the word cannot hold it: never wrapped, the discipline of checked_lcm.

Parameters

fs	the factors.

Returns

the count, or none.

exact_count() [3/3]

template<typename P, typename S>
requires requires(const P& p, const S& s) { occurrences(p, s); }

auto dedekind::category::exact_count ( const WindowJoin< P, S > & j )

constexprexport

Parameters

j	a join on the window.

Returns

its count exactly, or none where the word cannot hold it: exact_occurrences.

exact_occurrences()

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; } && std::equality_comparable<F>

std::optional< N > dedekind::category::exact_occurrences ( const Power< C, F, N > & p, const S & s )

constexprexport

The occurrences exactly, or none where the word cannot hold them: never wrapped, the discipline of exact_count.

Parameters

p	a tensor power.
s	a set of words over the same legs.

Returns

the occurrences, or none.

exact_sum() [1/3]

template<IsCountWord N, HasUnitPeriod F>
requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, std::optional<N>>

std::optional< N > dedekind::category::exact_sum ( const FiniteChainSequence< N, F > & v )

constexprexport

The exact sum along a constant sequence: sum's collapse, checked.

Parameters

v	the chain under the sequence.

Returns

n f(0), or none where it leaves the word.

exact_sum() [2/3]

template<IsCountWord N, HasPeriod F>
requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, std::optional<N>>

std::optional< N > dedekind::category::exact_sum ( const FiniteChainSequence< N, F > & v )

constexprexport

The exact sum along the chain of n under a periodic arrow into the exact counts: sum's law, checked.

Parameters

v	the chain under the arrow.

Returns

f(0) + ... + f(n - 1), or none where it leaves the word.

exact_sum() [3/3]

template<std::ranges::input_range R>
requires detail_periodic::is_exact_count_v<std::ranges::range_value_t<R>>

std::ranges::range_value_t< R > dedekind::category::exact_sum ( R r )

constexprexport

The exact sum of a range of exact counts: the plain fold, never wrapped, the discipline of exact_count.

Parameters

r	the range.

Returns

the sum, or none once a summand is none or the sum leaves the word.

explain()

template<typename P, typename S>
requires requires(const P& p, const S& s) { occurrences(p, s); }

auto dedekind::category::explain ( const WindowJoin< P, S > & j )

constexprexport

The plan of a join on the window, EXPLAIN: the offsets times the cylinder at the first, an outer product, the cylinder in turn its selection pushed down (pushed_down). Fubini, periodicity and the box law compose into it; none of the three is stated for joins. Its type is the plan, so a test asserts it. Defined where a window fits.

Parameters

j

the join.

Returns

its plan.

exponential() [1/3]

template<typename A, typename B, typename F>

auto dedekind::category::exponential ( F f )

constexprexport

1. Fully Explicit: Explicit A and B

exponential() [2/3]

template<typename A, typename F>

auto dedekind::category::exponential ( F f )

constexprexport

1. Semi-Automatic: Explicit Domain A, Inferred Codomain B

exponential() [3/3]

template<typename F>

auto dedekind::category::exponential ( F f )

constexprexport

Internal Hom Factory (Exponential).

1. Fully Automatic: Inferred from lambda signature

extent() [1/7]

template<HasPeriod F, IsArrow G>

Dom< F > dedekind::category::extent ( const Compose< F, G > & c )

constexprexport

Parameters

c	the composite.

Returns

the first leg's extent.

extent() [2/7]

template<IsCountWord N, HasPeriod G>

N dedekind::category::extent ( const Compose< Shift< N >, G > & c )

constexprexport

Parameters

c	a translation, then a periodic arrow.

Returns

the second leg's extent, less the translation.

extent() [3/7]

template<HasPeriod F>

Dom< F > dedekind::category::extent ( const F & )

constexprexport

Where a period's law holds: \(f(k + p) = f(k)\) for every k with k + p below the extent. A generator's law holds on the whole word; a shift narrows it, since the word does not wrap for the law.

Parameters

f	the arrow.

Returns

the extent.

extent() [4/7]

template<HasPeriod P, HasPeriod Q>

Dom< P > dedekind::category::extent ( const Join< P, Q > & j )

constexprexport

Parameters

j

the join.

Returns

the lesser of its legs' extents.

extent() [5/7]

template<HasPeriod P, HasPeriod Q>

Dom< P > dedekind::category::extent ( const Meet< P, Q > & m )

constexprexport

Parameters

m

the meet.

Returns

the lesser of its legs' extents.

extent() [6/7]

template<HasPeriod P>

Dom< P > dedekind::category::extent ( const Not< P > & n )

constexprexport

Parameters

n	the complement of a periodic predicate.

Returns

its extent.

extent() [7/7]

template<detail_periodic::IsPeriodicPredicate F, std::semiregular Step, std::semiregular Acc>

Dom< F > dedekind::category::extent ( const Rolling< F, Step, Acc > & r )

constexprexport

Parameters

r	the window.

Returns

the predicate's extent, less the window; an empty window reads nothing, so keeps the whole extent.

fibonacci_mod()

template<IsCountWord N = std::size_t>

FibonacciMod< N > dedekind::category::fibonacci_mod ( std::type_identity_t< N > m )

constexprexport

The Fibonacci numbers modulo m.

Template Parameters

N	the counts.

Parameters

m	the modulus, positive and at most \(2^{w/2}\) for a word of w bits.

fixed_by() [1/3]

template<IsArrow T, typename C, typename S>

detail_periodic::FixedByStage< S, T > dedekind::category::fixed_by ( const Compose< Morphism< std::vector< C >, std::vector< C >, S >, PowerMap< T > > & g )

constexprexport

Parameters

g	a permutation of the positions, then a letter map on every letter: the same section, the two commuting.

Returns

the stage.

fixed_by() [2/3]

template<IsArrow T, typename C, typename S>

detail_periodic::FixedByStage< S, T > dedekind::category::fixed_by ( const Compose< PowerMap< T >, Morphism< std::vector< C >, std::vector< C >, S > > & g )

constexprexport

Parameters

g	a letter map on every letter, then a permutation of the positions: power(complement) >> rev.

Returns

the stage that fixes it.

fixed_by() [3/3]

detail_periodic::FixedByReflectedReverse dedekind::category::fixed_by ( ReflectedReverse )

constexprexport

Parameters

g	the reverse complement, a family by alphabet.

Returns

the stage fixing it, its component taken at the power it meets.

fixed_point()

template<typename T, typename Step, typename Equal = std::equal_to<>>
requires IsIterativeEndomorphism<T, Step> && std::predicate<const Equal&, const T&, const T&>

T dedekind::category::fixed_point ( T seed, Step step, Equal equal = {}, std::size_t max_iterations = 1024 )

constexprexport

Iteratively compute a fixed point of an endomorphism.

The function stops when equal(next, current) holds or after the configured iteration budget. This gives the category layer a concrete, typed fixed-point operator without hard-coding any specific domain theory. A fixed point certifies itself: the result r is one exactly when equal(step(r), r), so a caller that needs to know whether the budget ran out checks that, in one step. * It is iterate (:morphism), the n-fold composite, which stops at the first fixed point it reaches.

flip()

template<typename A, typename B = A>

Flip< A, B > dedekind::category::flip ( )

constexprexport

Template Parameters

A
B	the factors.

Returns

the flip of \(A \times B\): a function, so it joins the overload set of any other flip.

fold() [1/3]

template<std::ranges::input_range R, std::semiregular M, typename H>
requires IsCopies<R> && IsRightAction<H, M, std::ranges::range_value_t<R>>

M dedekind::category::fold ( R r, M v, H h )

constexprexport

The fold under a monoid action of a sequence whose product has a fast form: v acted on once, by the product in the walk's order. The action law \(h(h(v, a), b) = h(v, a \cdot b)\) licenses this on any sequence, but it pays only where the product is cheaper than the actions one by one: elsewhere a product each costs more than an action each, a matrix by a matrix against a vector by a matrix. The fast form today is copies, whose product concat computes by squaring; periodic sequences are the natural next one. The same signature as the plain fold and a stronger constraint, so resolution prefers it.

Parameters

r	the copies.
v	the start.
h	the action.

fold() [2/3]

template<std::ranges::input_range R, std::semiregular M, typename H>
requires std::invocable<const H&, M, std::ranges::range_value_t<R>>

M dedekind::category::fold ( R r, M v, H h )

constexprexport

The fold along the walk: the standard's fold_left.

Parameters

r	the range.
v	the start.
h	the action.

fold() [3/3]

template<std::ranges::input_range R, typename TA, typename Step>
requires detail_kleisli::IsKleisliStep<Step, TA, std::ranges::range_value_t<R>>

TA dedekind::category::fold ( R r, TA ta, Step step )

constexprexport

Parameters

r	the range.
ta	the start, in the monad.
step	a step that may fail.

Returns

the fold in the Kleisli category.

free_monoid()

template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F>
requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>

FreeMonoid< C, F, N > dedekind::category::free_monoid ( const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > & leg, std::type_identity_t< N > below )

constexprexport

Parameters

leg	a chain of letters under a predicate.
below	the bound on the length, excluded.

Returns

the words shorter than it.

holds()

template<typename L>

bool dedekind::category::holds ( Truth< L > proposition )

constexprexportnoexcept

Semantic truth projection for assertion contexts.

Textbook alignment: in an internal logic, formulas denote Ω-values. holds projects that Ω-value to meta-level proof truth.

image_of()

template<typename F>
requires IsArrow<F> && std::constructible_from<std::remove_cvref_t<F>, F&&>

auto dedekind::category::image_of ( F f )

constexprexport

Factory: image_of(f) constructs the image of f as a Subobject of Cod<F>.

The returned Subobject's characteristic predicate (ImageChi above) recognises y as "@c y is in the image of @c f". Pairs with IsImageOf at the type level: the result satisfies IsImageOf<decltype(image_of(f)), F> for every IsArrow F. The Slice-2 realisation defers the existential resolution to Ternary::Unknown (Honest Rejection); concrete carrier-specific specialisations of ImageChi land in later slices (Slice 4's First-Iso-Theorem exhibit).

Template Parameters

F	The arrow whose image is being constructed.

inclusion_arrow()

template<typename S>
requires IsSubobject<std::remove_cvref_t<S>, typename std::remove_cvref_t<S>::Domain>

SubobjectInclusion< std::remove_cvref_t< S > > dedekind::category::inclusion_arrow ( const S & s )

constexprexport

Parameters

s	a subobject.

Returns

its inclusion, an arrow.

infer()

Ternary dedekind::category::infer ( ArrowLaw w, ArrowNode n, const ArrowLaws & a, const ArrowLaws & b )

constexprexport

The engine at one law: a former's answer from its legs' profiles, their laws combined by the chain's own Inf (both legs) and Sup (either leg). The facts, each a theorem about functions:

• closure: injective and surjective functions are closed under ∘, ×, +; involutive ones under × and +; constant ones under × and ⟨,⟩, and g ∘ f is constant as soon as either leg is, while f + g never is (it lands in two summands); monotone ones under × (the componentwise order) and + (std::variant's order, by summand first); antitone ones under × only (a sum's order keeps inl < inr, it does not reverse it);
• the sign table: variance multiplies along ∘ (monotone ∘ monotone and antitone ∘ antitone are monotone; mixed, antitone);
• duality: ⟨f, g⟩ is injective when either leg is, [f, g] surjective when either leg is; ⟨f, g⟩ keeps a variance both legs share, [f, g] none (it compares across summands, which neither leg governs). A variance is read under an order; these facts are about the former's own order (componentwise, by summand), and a fold under another order drops them (without_variance). The formers are in :cartesian: ⟨,⟩ and [,] as arrow types, × and + by their defining forms (f × g = ⟨f ∘ π₁, g ∘ π₂⟩, f + g = [ι₁ ∘ f, ι₂ ∘ g]), recognised by the readers so the facts on × and + keep their precision.

  Parameters

  w	the law.
  n	the former.
  a
  b	the legs' profiles (for ∘, a is the first arrow applied).

inverse()

template<std::integral 𝒯>

𝒯 dedekind::category::inverse ( 𝒯 a, std::bit_xor< 𝒯 >  )

inlineconstexpr

In XOR, every element is its own inverse (Involutive).

is_antitone()

template<IsArrow T>
requires std::same_as<Dom<T>, std::byte> && std::same_as<Cod<T>, std::byte>

bool dedekind::category::is_antitone ( const T & t, const Letters & on )

constexprexport

Whether a letter map reverses the order of an alphabet, decided on its table: the letters as bytes are a chain, and on a chain consecutive letters suffice. A law of the value, not of the type: the Watson–Crick pairing reverses A < C < G < T because of how the one-letter codes are chosen. Where it does and the map is a bijection, its cycle type is antitone_cycle_type's.

Template Parameters

T	an arrow on the bytes.

Parameters

t	the map.
on	the alphabet.

Returns

whether t is antitone on it.

is_decided()

template<typename L>
requires IsOckhamAlgebra<L> && logic_negation_is_involutive_v<L> && std::equality_comparable<typename L::Ω>

bool dedekind::category::is_decided ( typename L::Ω value )

constexprexport

Membership in the decided core \(\{\top, \bot\}\) of an answer-lattice \(\Omega\) — the Rosolini dominance \(\Sigma\), which the paper and lift_logic define as exactly the decided subobject \(\{\top,\bot\} \hookrightarrow \Omega\).

The \(\top\) endpoint is detected by value == L::True; the \(\bot\) endpoint by its Kleene reflection, L::RFL(value) == L::True (equivalently value == L::False). The reflection spelling is used on purpose: it is sound because RFL is an order-reversing involution (logic_negation_is_involutive_v, the :involution witness from the double-negation work), which the requires clause demands; a logic whose RFL were only a closure is excluded.

The answer is itself classical: a bound either is or is not reached, never Unknown. So is_decided co-restricts any \(\Omega\) to bool, the value-level observable behind HasDecidableMembership (the type-level, conservative certificate). On Boole ( \(\Sigma = \Omega\)) it is constantly true; on K₃ it is true off Unknown.

See also

Giuseppe Rosolini, Continuity and Effectiveness in Topoi (Oxford D.Phil., 1986); lift_logic (the inclusion \(\Sigma \hookrightarrow \Omega\)), #846 / #267, and the #847 recognised-vs-actual sub-quadrant this closes at the value level.

is_identity()

template<IsArrow F>

bool dedekind::category::is_identity ( const F & )

constexprexport

The laws of an arrow asked on its value (the Jlt paper's Listing 1): each reads, at compile time, the registration its concept reads, so is_monic(f) is IsMonicArrow<F> at the value's type, and a composite's law comes through the readers above. A concept gates a template, a predicate states a fact; both read one registration.

posetal__Laws_Asked_On_The_Value

Parameters

f	the arrow.
op	the order a variance is read under.

is_involution() [1/3]

template<IsArrow F, IsArrow G>
requires commutes_v<F, G>

bool dedekind::category::is_involution ( const Compose< F, G > & c )

constexprexport

A composite of two commuting involutions is one, \((g f)^2 = g g f f = \mathrm{id}\), its law derived from its legs' (commutes, :involution); where the legs do not commute, the reading above decides, and - after ~ is none.

Parameters

c	the composite.

is_involution() [2/3]

bool dedekind::category::is_involution ( const LetterMap & t )

constexprexport

Whether a letter map is an involution, decided on its table: a law of the value, the 256 bytes taken twice, as a law of a finite structure is decided.

Parameters

t

the map.

Returns

whether \(t \circ t = \mathrm{id}\).

is_involution() [3/3]

template<IsArrow T>
requires std::same_as<Dom<T>, Cod<T>>

bool dedekind::category::is_involution ( const PowerMap< T > & p )

constexprexport

A map on every letter is an involution where the map on one is.

Parameters

p	the power of the map.

Returns

whether it is one.

is_isometry()

template<typename Dagger, typename Op, typename T>
requires std::equality_comparable<T> && requires(const T& g) { Op{}(Dagger{}(g), g); unit<T>(Op{}); }

bool dedekind::category::is_isometry ( const T & f )

constexprexport

CRUCIAL (load-bearing across the library): "the converse @b is the inverse" — unitarity — is a property of an arrow (a value), not of a type. This is why the retired is_unitary certificate was wrong, and why the surface below is two coordinated forms of one computed law.

involution__Unitary_Is_A_Value_Property

A type-level is_involutive-style certificate would lie: a general matrix / relation carrier holds both unitary and non-unitary arrows, so no trait on the type can honestly claim "unitary". The honest thing is to compute \(f^\dagger \circ f = \mathrm{id}\) on the arrow.

• is_isometry / is_coisometry / is_unitary are predicates on the arrow value — always applicable (a matrix, a materialised relation);
• IsIsometry / IsUnitary are concepts that compute the same law on F{}, so they bite exactly on a singleton morphism-carrier (a type that is one arrow — the Trsk relation carriers). It is the same type-vs-value seam the library already lives on (IsSet is structural, a Singleton is a Subobject): unitarity sits on the value side, and a type-level trait pretending otherwise is precisely the bug.

involution__Dagger_Fixes_The_Witness

CRUCIAL: the dagger is the first bridge from this involution surface to the :morphism factorisation surface (mono / epi / iso). The arrow class fixes the inverse structure; the dagger fixes the witness (Heunen & Vicary, Categories for Quantum Theory, OUP 2019; Selinger, ENTCS 170, 2007; nLab, dagger category).

Layered on IsDagger, how far the dagger inverts an arrow is its factorisation class — and in each case the dagger hands over the witness a bare arrow would have to search for:

*   dagger law                arrow class      witness the dagger supplies
*   ---------------------------------------------------------------------------
*   f† ∘ f = id  (isometry)    split MONO       retraction  r = f†   (r∘f = id)
*   f ∘ f† = id  (coisometry)  split EPI        section     s = f†   (f∘s = id)
*   both         (unitary)     ISO              inverse     f⁻¹ = f†
*   f f† f = f   (partial iso) general m∘e      generalized inv. f†
* (Moore–Penrose)
* 

The fourth row completes the ladder: a general arrow f=m∘e (dagger-mono m ∘ dagger-epi e) is a partial isometry, its dagger the generalized (Moore–Penrose) inverse ( \(f f^\dagger f = f\), and \(f^\dagger f f^\dagger = f^\dagger\)) — a two-sided partial inverse, neither f†f nor ff† being id but each a projection. No concept yet (see the follow-up); paper Table tab:inverse-image-laws carries all four. IsIsometry is the named intermediate (Heunen & Vicary): no linearity — a split mono in a \(\dagger\)-monoid (the one-object case: f is an endo-arrow, Op its composition; a general \(f:A\to B\) needs the multi-object surface), so bijective relation, orthogonal matrix and unitary matrix are one theorem. The implication runs one way (a mono need not be an isometry). The real subsumption IsIsometry \(\Rightarrow\) split mono (and coisometry \(\Rightarrow\) split epi, unitary \(\Rightarrow\) IsIsomorphism, by registering inverse(f)=f†) needs the dagger carriers lifted into the :morphism arrow surface — a follow-up (tracking issue). Here the correspondence is stated and the law is witnessed; paper Table tab:inverse-image-laws carries the full picture.

The isometry law, computed on an arrow f: \(f^\dagger \circ f = \mathrm{id}\) — the dagger is a left inverse. General over the dagger Dagger and composition Op (id is the Op-identity unit_v); no linearity. f is an endo-arrow (Op a monoid on the single object T); a general \(f:A\to B\) isometry is the multi-object case, left to the arrow surface.

iterate()

template<typename X, typename F, typename Equal = std::equal_to<>>
requires std::copyable<X> && std::regular_invocable<const F&, const X&> && std::convertible_to<std::invoke_result_t<const F&, const X&>, X> && (std::predicate<const Equal&, const X&, const X&> || std::same_as<Equal, std::equal_to<>>)

X dedekind::category::iterate ( const F & f, const X & x0, std::size_t n, const Equal & equal = {} )

constexprexport

morphism__Iterate

The n-fold composite of an endomorphism, applied: \(f^n(x)\), the one bounded iteration of Jlt (Rule 3).

\[ \mathrm{iterate}(f, x, n) = \begin{cases} x & n = 0 \\ x_1 & x_1 = x \\ \mathrm{iterate}(f, x_1, n - 1) & \text{otherwise} \end{cases} \qquad x_1 = f(x) \]

Its readings: \(f^n\) is the power of f in the monoid of endomorphisms, on which \((\mathbb{N}, +)\) acts; \(n \mapsto f^n(x)\) is the arrow out of the natural numbers object that its universal property gives for x and f (nno_iterate in :nno is that face); and it is the catamorphism of the algebra \([x, f]\) of \(1 + X\) at n. Its intent is a fixed point: from \(x = \bot\) it is the n-th Kleene approximation of the least fixed point, PCF's fix with a budget (fix names the intent, iterate the computation); from another seed it finds a fixed point reachable from it, not necessarily the least. The early exit at a fixed point changes no value, since a fixed point absorbs ( \(f(y) = y\) gives \(f^m(y) = y\)): it is an operational shortcut, taken when equal applies to X, and a fixed point certifies itself. Implemented by eliminating the definition's one tail call, so it equals the recursion without tail-call optimisation, which the standard does not guarantee and constant evaluation does not perform: the loop's (x, k) are the arguments of the next call, each iteration one unfolding, and the mutation is local (Rule 1's footnote). The loop is the one Rule 3 exempts.

Template Parameters

X	the carrier.
F	the endomorphism.
Equal	the equality of the early exit.

Parameters

f	the endomorphism.
x0	the point.
n	the power.
equal	the equality.

join_with()

template<typename P>

detail_comprehension::JoinWithStage< P > dedekind::category::join_with ( P p )

constexprexport

Parameters

p	a tensor power.

Returns

the stage joining a set with it.

legs()

template<IsArrow F, IsArrow G>

auto dedekind::category::legs ( const Compose< F, G > & c )

constexprexport

The legs of a composite: the arrows it composes.

f_algebra__The_Term_Functor

legs is the term functor's out : μF → F(μF), stated once per node: the tuple of the sub-terms a node is built from, found by ADL beside the node's definition. A type without legs is a leaf. Compose is the first node, its legs the two arrows it composes (its product projections, #892); a bare product that is not an arrow is not a term and has no legs. Every reading of a term (a rewrite to normal form, a certificate, its value) is then an algebra over this one functor, and cata is the one engine that folds it.

Parameters

c

the node.

len()

template<IsCountWord N = std::size_t>

Length< N > dedekind::category::len ( std::type_identity_t< N > n )

constexprexport

Parameters

n	the length.

Returns

the fibre's predicate.

letter_map()

LetterMap dedekind::category::letter_map ( std::string_view from, std::string_view to )

constexprexport

Parameters

from	the letters moved.
to	their images, in the same order, as many.

Returns

the arrow.

letters()

Letters dedekind::category::letters ( std::string_view alphabet )

constexprexport

Parameters

alphabet

the letters, as written.

Returns

the predicate that keeps them.

letters_of()

Letters dedekind::category::letters_of ( const Alphabet & alphabet )

constexprexport

Parameters

alphabet

the filtered byte chain.

Returns

the letters it holds: its predicate's within its slice, which abc makes the same, and a chain sliced more narrowly does not.

lift()

template<typename From, typename To>

To dedekind::category::lift ( From const & )

constexprexport

Canonical lift From → To across the carrier lattice — discoverability alias dispatching to the registered bespoke arrow for (From, To).

Specialise this primary for each registered lattice pair. The primary fires a useful static_assert at instantiation if no specialisation exists, naming the design doc that lists the registered pairs. The body uses a dependent_false_v helper (avoids sizeof on From which would require completeness) and ends with std::unreachable() — itself [[noreturn]] — so the function does NOT need To to be default-constructible (no return To{} required). The function itself is NOT marked [[noreturn]] because that attribute would apply to specialisations too, and specialisations DO return their bespoke result. Full specialisations override the primary cleanly.

lifted()

template<std::semiregular Op>

Lifted< Op > dedekind::category::lifted ( Op op )

constexprexport

Parameters

op	a fold step.

Returns

op through Maybe.

lower_cover()

template<HasNNOStep N>
requires std::equality_comparable<N>

std::optional< N > dedekind::category::lower_cover ( const N & n )

constexprexport

The lower cover \(P^{+} : N \to 1 + N\), dual to cover: the predecessor read partially, nullopt at the least element (a fixpoint of P, or a machine word's least value). Not the destructor Prior, which is nothing at zero.

Template Parameters

N	the carrier.

Parameters

n	an element.

Returns

the element n covers, if any.

make_χ()

template<typename L, typename Π, typename F, typename G>
requires IsOckhamAlgebra<L> && IsArrow<F> && IsArrow<G> && IsProduct<Π, Dom<F>, Dom<G>> && std::same_as<Cod<F>, Cod<G>> && std::equality_comparable<Cod<F>>

auto dedekind::category::make_χ ( F f, G g )

constexpr

The Characteristic Morphism χ: (X × Y) ⟶ Ω.

In a Topos, every subobject is uniquely determined by a morphism into the subobject classifier Ω. For a pullback, χ identifies pairs (x, y) that map to the same image in the codomain Z.

Template Parameters

L	The Logic Species defining the Subobject Classifier Ω.
Π	The Product Species (e.g., std::pair<X, Y>).
F	Morphism type for f: X ⟶ Z (must share codomain with G).
G	Morphism type for g: Y ⟶ Z (must share codomain with F).

Parameters

f	The first morphism f: X ⟶ Z.
g	The second morphism g: Y ⟶ Z.

Returns

An arrow χ: Π ⟶ Ω that is L::True iff f(π₁(pair)) == g(π₂(pair)).

Note

Cod<F> and Cod<G> must be the same type and equality-comparable.

matches() [1/2]

template<std::size_t Sigma, std::size_t Q>

Matches< Sigma, Q > dedekind::category::matches ( const Automaton< Sigma, Q > & plan, Holes holes = Holes::break_match )

constexprexport

Parameters

plan	the matcher.
holes	what a hole does.

Returns

the stage.

matches() [2/2]

template<std::size_t Sigma, std::size_t Q>

Maybe< Matches< Sigma, Q > > dedekind::category::matches ( const Maybe< Automaton< Sigma, Q > > & plan, Holes holes = Holes::break_match )

constexprexport

matches on a plan that may not be, automaton(section)'s Maybe: the stage, or nothing, by Maybe's action. The uncertainty of the capacity travels through the query to its count, so dna >> matches(automaton(s)) >> counting is a Maybe count with no case on it in between.

Parameters

plan	the plan, or nothing.
holes	what a hole does.

Returns

the stage, or nothing.

mediate_coproduct()

template<IsArrow F, IsArrow G>
requires std::same_as<Cod<F>, Cod<G>>

auto dedekind::category::mediate_coproduct ( F f, G g )

constexprexport

Mediating morphism for Coproducts: [f, g]: (A + B) -> X.

Given f: A -> X and g: B -> X, constructs the unique morphism (the "case" analysis) that handles either alternative of a variant.

mediate_product()

template<IsArrow F, IsArrow G>
requires std::same_as<Dom<F>, Dom<G>>

auto dedekind::category::mediate_product ( F f, G g )

constexprexport

Mediating morphism for Products: ⟨f, g⟩: X -> (A × B).

Given f: X -> A and g: X -> B, constructs the unique morphism that pairs their results.

meet_bounded_law()

template<typename Ord, typename RA, typename RB>
requires std::copy_constructible<RA> && std::copy_constructible<RB>

auto dedekind::category::meet_bounded_law ( const RA & a, const RB & b )

constexprexport

Law induced by a bounded lattice (IsBoundedLatticeCategory): the unit and annihilator. Meet: ⊥∧X=⊥ (annihilator), ⊤∧X=X (unit). Fires only when both operands share a carrier (mixed-carrier ⟹ inactive).

lattice__Laws_As_Value_Functions

Each law is a constexpr function on the two reduced operand values, returning the reduced value or law_inactive. Where the operand types differ the decision is on the types (the result's type depends on it); where they coincide a law may decide on the values. The same function therefore runs at compile time (the normal form's type is its decltype) and at run time, on values built from Python: one law, two binding times.

Template Parameters

Ord	the lattice order.

Morphism()

template<typename F>

dedekind::category::Morphism

(

F

)

->Morphism< domain_t< F >, codomain_t< F >, F >

morphism__CTAD_Guide

narrowed()

template<std::size_t K, IsCountWord N, std::size_t J>

Maybe< RunList< N, K > > dedekind::category::narrowed ( const RunList< N, J > & r )

constexprexport

A run list under a bound claimed, not proved by the types: the same set where its steps fit, nothing where they do not.

Template Parameters

K	the claimed bound.

Parameters

r	the run list.

Returns

it, bounded by K.

nno_iterate()

template<typename A, typename G>
requires std::regular_invocable<const G&, const A&> && std::convertible_to<std::invoke_result_t<const G&, const A&>, A> && std::copyable<A>

A dedekind::category::nno_iterate ( A a0, G g, std::size_t n )

constexprexport

Recursion-via-universal-property (operational discharge).

Lambek's lemma as the honesty obligation

The structure map \([Z, S] : 1 + N \to N\) of the initial algebra is an isomorphism, with inverse \(\langle \text{is}\;Z?,\, P\rangle\). Here that reads IsIsomorphism<In<N>> (:morphism), which an inverse(In<N>) overload would declare. No shipped carrier declares one, each for its own reason, witnessed on values below and in numbers: ℤ (int, SignedCardinality) is a group, S(−1) = Z; the bounded chains (K₃, ℕ's proxy) saturate, so S is not injective at ⊤ (the largest finite cardinal and ℵ₀ both step to ℵ₀); and the signed machine integers have no value at S(max) at all, the same refusal as their ring claim (sets:cardinality). Likewise no step is declared a bijection: ℤ's proxy saturates, and S ⊣ P on it is registered as the adjunction it is (numbers:integer), not derived from an iso it is not.

Given an NNO witness (N, Z, S), an initial value a₀ of type A, and a step function g : A → A, materialises the unique morphism f : N → A in its iterated presentation:

f(0) = a₀ f(n+1) = g(f(n))

Operationally, this is bounded count-driven iteration: the caller supplies a count n (machine std::size_t) and gets back f(n) by composing g with itself n times starting from a₀. The count is the iteration driver — not the NNO element itself, since materialising a transfinite NNO element through machine-bounded iteration is structurally impossible. The universal-property claim that f exists and is unique remains the honesty obligation; what this combinator does is realise f at a finite index.

For NNO carriers like Cardinality that admit a transfinite ℵ_0 element, the recursion at the transfinite index is deliberately not provided by this combinator — callers needing that case state their own saturating semantics explicitly (a proof obligation discharge separate from the count-bounded recursion below).

Template Parameters

A	The recursion target type.
G	A unary callable G : A → A (the step function).

Parameters

a0	The initial value f(0).
g	The step function.
n	The count of iterations (the index into the NNO at which to evaluate f).

Returns

f(n) — the result of applying g to a₀ exactly n times.

occurrences()

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires requires(const S& s) { { detail_periodic::power_of(s) } -> std::same_as<Power<C, F, N>>; requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; } && std::equality_comparable<F>

N dedekind::category::occurrences ( const Power< C, F, N > & p, const S & s )

constexprexport

How often a set of words occurs in the words of a tensor power, counted with their positions: the pairs (word, offset) whose window lies in s, the sum over the offsets of the cylinders' counts, modulo the word. Each summand is pushed down (R2), so none depends on its offset: the summand has period 1, and the periodic sum takes one of them, times the number of offsets.

Parameters

p	a tensor power.
s	a set of words over the same legs.

Returns

the occurrences.

opaque()

template<IsArrow F>

Opaque< F > dedekind::category::opaque ( F f )

constexprexport

Parameters

f	the arrow.

Returns

f, its laws hidden.

operator!()

template<IsPredicate P>

auto dedekind::category::operator! ( P p )

constexprexport

Logical Negation (Complement): Synthesizes a rule for ¬A.

Note

Textbook term: pseudocomplement/complement depending on Ω.

operator&() [1/8]

template<typename A, typename B>
requires detail_lattice_nodes::BuildNodes<A, B>

Meet< A, B > dedekind::category::operator& ( A a, B b )

constexprexport

Parameters

a

param b two predicates that build nodes.

Returns

their meet, the node.

operator&() [2/8]

template<IsArrow Fam, IsCountWord N>
requires is_graded_v<Fam> && std::same_as<Dom<Fam>, N>

Cod< Fam > dedekind::category::operator& ( const Fam & fam, Length< N > l )

constexprexport

Parameters

fam	a graded family of sets of words.
l	the length.

Returns

the family's set at that length, the fibre.

operator&() [3/8]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
requires std::same_as<Dom<T>, C> && HasCycleType<S, N>

Symmetric< Power< C, F, N >, S, T > dedekind::category::operator& ( const Power< C, F, N > & p, const detail_periodic::FixedByStage< S, T > & st )

constexprexport

power(Σ, n) & fixed_by(g): the power met with what g fixes, symmetric(power, g) spelled as Trsk spells a set under a predicate. The equalizer of g and the identity, a subobject of the power, and one the laws count: from g's cycle type, no word built.

Parameters

p	the power.
st	the stage.

Returns

the section.

operator&() [4/8]

template<IsCountWord N>

Symmetric< Power< std::byte, Letters, N >, Reverse, Reflection > dedekind::category::operator& ( const Power< std::byte, Letters, N > & p, detail_periodic::FixedByReflectedReverse  )

constexprexport

power & fixed_by(~rev): the words the reverse complement fixes, the complement the power's own, refl of its letters.

Parameters

p	the power.

Returns

the section.

operator&() [5/8]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
requires std::same_as<Dom<T>, C> && HasCycleType<S, N>

auto dedekind::category::operator& ( const Powers< C, F, N > & ps, const detail_periodic::FixedByStage< S, T > & st )

constexprexport

words(Σ) & fixed_by(g): the words g fixes, by length, the same family spelled as Trsk spells a set under a predicate.

Parameters

ps	the words.
st	the stage.

Returns

the family.

operator&() [6/8]

template<IsCountWord N>

auto dedekind::category::operator& ( const Powers< std::byte, Letters, N > & ps, detail_periodic::FixedByReflectedReverse  )

constexprexport

words(Σ) & fixed_by(~rev): the same, by length.

Parameters

ps	the words.

Returns

the family.

operator&() [7/8]

template<IsCountWord N, std::size_t J, std::size_t K>

RunList< N, J+K > dedekind::category::operator& ( const RunList< N, J > & a, const RunList< N, K > & b )

constexprexport

The intersection, dual to the union; with a single run, by law a restriction.

Parameters

a

param b two run lists on one chain.

Returns

their intersection.

operator&() [8/8]

template<typename P, typename S, IsArrow T>

Prefixed< P, S, T > dedekind::category::operator& ( const Symmetric< P, S, T > & s, const Prefix & p )

constexprexport

Parameters

s	the section.
p	the prefix.

Returns

their meet.

operator&&() [1/2]

template<typename A, typename B>

auto dedekind::category::operator&& ( const Rule< A, B > & p1, const Rule< A, B > & p2 )

constexprexport

morphism__Rule_Overloads

operator&&() [2/2]

template<typename P, typename Q>
requires IsPredicatePair<P, Q>

auto dedekind::category::operator&& ( P p, Q q )

constexprexport

Logical Conjunction (Intersection): Synthesizes a rule for A ∩ B.

Note

Textbook term: meet (∧) in the internal Heyting/Boolean algebra of Ω.

Equal codomains no longer imply equal species (two tagged predicates can both answer int in different chains), so the species are required equal. For species-tagged operands the result is the lattice's own Meet node, which carries the species, so the combinators close on IsPredicate; plain Ω-valued arrows get a plain arrow as before.

operator*() [1/5]

𝔽64 dedekind::algebra::operator* ( bool s, 𝔽64 v )

constexprnoexcept

Scalar action of \(\mathbb{F}_2\) (witnessed on bool) on 𝔽64, via the natural embedding \(\mathbb{F}_2 \hookrightarrow \mathbb{F}_{64}\) ( \(0 \mapsto 0\), \(1 \mapsto 1\)).

Required by IsVectorSpace<𝔽64, bool> (witnessed in algebra:vectorspace): the scalar side is the prime subfield \(\mathbb{F}_2\); its action on the ambient field is "multiply every coordinate of @c v by the scalar bit", i.e.\ false·v = 0 and true·v = v. The one-operand std::multiplies functor dispatches here via ADL.

operator*() [2/5]

template<HasFactors A, HasFactors B>
requires std::same_as< detail_periodic::word_of_t<decltype(count_factors(std::declval<A>()))>, detail_periodic::word_of_t<decltype(count_factors(std::declval<B>()))>>

Outer< A, B > dedekind::category::operator* ( const A & a, const B & b )

constexprexport

Parameters

a

param b two counted tensors.

Returns

their outer product.

operator*() [3/5]

template<IsArrow T, std::size_t K, IsCountWord N, IsArrow G>
requires std::same_as<Cod<G>, bool>

auto dedekind::category::operator* ( const Box< T, K, N > & x, const FiniteChainSequence< N, G > & b )

constexprexport

Parameters

x	an outer product.
b	one more chain under a predicate.

Returns

their outer product.

operator*() [4/5]

template<IsArrow F, IsArrow G>

ProductArrow< F, G > dedekind::category::operator* ( const F & f, const G & g )

constexprexport

f * g = f × g and f + g = f + g on arrows: the product and coproduct functors' action on arrows, as category theory writes them (Mac Lane, Awodey). A more specific overload keeps its own meaning: a set's * (its cartesian product, the classifier read through ∧), an additive hom-set's + (geometry's function spaces: the sum of parallel arrows, as in an additive category); the term grammar's * + act on terms, which are not arrows.

Parameters

f

param g the arrows.

operator*() [5/5]

template<IsCountWord N, IsArrow F, IsArrow G>
requires std::same_as<Cod<F>, bool> && std::same_as<Cod<G>, bool>

auto dedekind::category::operator* ( const FiniteChainSequence< N, F > & a, const FiniteChainSequence< N, G > & b )

constexprexport

Parameters

a

param b two chains under predicates.

Returns

their outer product.

operator<<=()

template<typename WA, typename F>
requires requires(WA const& wa, F&& f) { { σ(wa, std::forward<F>(f)) }; }

auto dedekind::category::operator<<= ( WA const & wa, F f )

constexprexport

operator<<= : Comonadic extend (co-Kleisli arrow application).

Syntactic sugar for σ(wa, f). Given wa: W and f: W → B, produces W.

operator<=>()

std::strong_ordering dedekind::category::operator<=> ( Ternary a, Ternary b )

constexprexportnoexcept

Truth-order <=> on Ternary: the chain False (-1) < Unknown (0) < True (1).

Supplies the < the value-returning :mereology ops Inf / Sup need to compute the Kleene meet / join on Ternary directly, so the Form-chain Meet / Join slots reuse the generic lattice ops rather than carrying named Ternary-specific function-object struct types (#698 Slice 8 review). Inf on the chain is Kleene AND; Sup is Kleene OR, identical to Kleene::AND / OR (which are defined via Inf / Sup on the int8_t cast).

Note

Returns std::strong_ordering, not Ternary — comparison between two Ternary values is itself classically decided (the truth ordering is total). Unknown values in Ternary arise from undecidable predicates over an intensional ambient, not from comparing two Ternary values directly.

operator>>() [1/31]

template<typename T, typename Op>

Arrows< T, Op > dedekind::category::operator>> ( const Arrows< T, Op > & f, const Arrows< T, Op > & g )

constexprexport

f >> g on arrows, restricted to one level: two morphisms compose as above, the identity is absorbed, and a composite of composites is refused.

Parameters

f

param g the arrows.

operator>>() [2/31]

template<IsCountWord N, typename Rank, std::size_t K>
requires std::same_as<Dom<Rank>, N> && antitone_on_even_lengths<Rank>::value

auto dedekind::category::operator>> ( const detail_comprehension::Pending< unfold_view< std::optional< N >, detail_chain::SliceStep< N, Where< Congruent< N > > > >, Rank, descending > & p, Take< K >  )

constexprexport

The lengths in a residue class, ranked by their occurrences, the first K: one plan compiled, the even case, and the run time only reindexing into it. A family whose density falls along the even lengths ranks them by construction, the shortest first (the walk read upwards, rewrite 3), so the first K need no rank evaluated at all. A residue class of even modulus holds lengths of one parity: even ones are the case; odd ones occur nowhere (the reversal pairs the letters, and no even alphabet fixes them all), all ranked alike. Either way the class's members in order are the plan, a progression: padded into the class by \(j \mapsto m j + r\), unpadded by reading the lengths back. An odd modulus mixes the parities and takes the fused pass.

Parameters

p	the pending sort.

Returns

the first K lengths.

operator>>() [3/31]

template<IsArrow F>
requires requires(const Cod<F>& j) { count(j); }

auto dedekind::category::operator>> ( const F & f, detail_comprehension::CountingStage  )

constexprexport

Parameters

f	an arrow into counted tensors.

Returns

it, then the count.

operator>>() [4/31]

template<IsArrow Fam, typename P>
requires requires(const P& p, const Cod<Fam>& s) { occurrences(p, s); }

auto dedekind::category::operator>> ( const Fam & fam, const detail_comprehension::JoinWithStage< P > & st )

constexprexport

Parameters

fam	a family of sets of words.
st	the stage.

Returns

the family, each set joined with the power.

operator>>() [5/31]

template<IsCountWord N, typename F, IsArrow Rank, typename Order>
requires std::same_as<Dom<Rank>, N> && detail_comprehension::AscendsByPosition<F> && detail_comprehension::ReversedByTheWalk<Rank, Order>

auto dedekind::category::operator>> ( const FiniteChainSequence< N, F > & q, const OrderBy< Rank, Order > &  )

constexprexport

order_by on a filtered chain whose rank reverses the walk's order: the query re-rooted on the ascending slice [0, n), read upwards, the positions where the walk read them downwards (rewrite 3).

Parameters

q	the query.

Returns

it, ascending.

operator>>() [6/31]

template<IsCountWord N, typename F, IsArrow Rank, typename Order>
requires std::same_as<Dom<Rank>, N> && detail_comprehension::AscendsByPosition<F> && detail_comprehension::KeptByTheWalk<Rank, Order>

FiniteChainSequence< N, F > dedekind::category::operator>> ( const FiniteChainSequence< N, F > & q, const OrderBy< Rank, Order > &  )

constexprexport

order_by on a filtered chain whose rank keeps the walk's order: the identity, the query sorted by construction (rewrite 3).

Parameters

q	the query.

Returns

it.

operator>>() [7/31]

template<IsCountWord N, typename P, typename Q>
requires requires(const P& p, const Q& q) { { p & q } -> IsArrow; requires std::same_as<Cod<decltype(p& q)>, bool>; }

auto dedekind::category::operator>> ( const FiniteChainSequence< N, Where< P > > & q, const Where< Q > & w )

constexprexport

where(p) >> where(q) on a chain, fused by type: one where whose predicate is the lattice term p & q, the meet in the Boolean algebra of the chain's subobjects (:lattice's Meet). The filter is then a term the lattice's laws and the periodic counts read, not two walks; where p & q is not formed, the Kleisli composite above takes the query.

Parameters

q	the filtered chain.
w	the second filter.

Returns

the chain under one filter.

operator>>() [8/31]

template<typename T, typename Op>

Arrows< T, Op > dedekind::category::operator>> ( const Morphisms< T, Op > & f, const Morphisms< T, Op > & g )

constexprexport

f >> g on morphisms, into Arrows: the identity absorbed, two sections one, two pointers a composite.

Parameters

f

param g the morphisms.

operator>>() [9/31]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename P, typename S, IsArrow T>
requires requires(const Power<C, F, N>& p, const Symmetric<P, S, T>& s) { occurrences(p, s); }

WindowJoin< Power< C, F, N >, Symmetric< P, S, T > > dedekind::category::operator>> ( const Power< C, F, N > & p, const Symmetric< P, S, T > & s )

constexprexport

Parameters

p	a tensor power.
s	a section over the same legs.

Returns

the join of p and s on the window: s's words at every offset of every word of p, counted by its laws, never enumerated.

operator>>() [10/31]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>
requires std::same_as<Dom<T>, C> && HasCycleType<S, N>

auto dedekind::category::operator>> ( const Powers< C, F, N > & ps, const detail_periodic::FixedByStage< S, T > & st )

constexprexport

The powers, then the sections each fixes: a family of sets of words by length, words(Σ) >> fixed_by(g).

Parameters

ps	the powers.
st	the stage.

Returns

the family.

operator>>() [11/31]

template<typename T, typename Op>

Sections< T, Op > dedekind::category::operator>> ( const Sections< T, Op > & f, const Sections< T, Op > & g )

constexprexport

f >> g on sections: the identity absorbed, two sections one, \((b \mapsto a \cdot b) ; (c \mapsto a' \cdot c) = (b \mapsto (a' \cdot a) \cdot b)\) by associativity, which Sections asks of the operation, with no state, so that both sections are of one operation.

Parameters

f

param g the sections.

operator>>() [12/31]

template<IsCountWord N, std::size_t K>

RunList< N, K > dedekind::category::operator>> ( const Shift< N > & t, const RunList< N, K > & s )

constexprexport

shift(d) >> s, the spelling of the preimage: precomposition with the translation.

Parameters

t	the translation.
s	the run list.

Returns

preimage(t, s).

operator>>() [13/31]

template<HasNNOStep C, IsArrow F>
requires std::totally_ordered<C> && std::same_as<Dom<F>, C>

unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > dedekind::category::operator>> ( const Slice< C > & s, F f )

constexprexport

An arrow along a restricted chain: f(lo), ..., f(hi - 1), a range never built.

Parameters

s	the restricted chain.
f	the arrow.

Returns

the values along it.

operator>>() [14/31]

template<std::regular S, std::semiregular Coalg, IsArrow F>
requires detail_comprehension::ReadsItsElements<unfold_view<S, Coalg>, F> && detail_comprehension::IsMaybe<Cod<F>>

auto dedekind::category::operator>> ( const unfold_view< S, Coalg > & q, F f )

constexprexport

>> f on a query with f a Kleisli arrow into Maybe, a second where among them: Kleisli composition, f extended by Maybe's κ (:kleisli), so the holes do not nest. Filter fusion, where(p) >> where(q) = where(p ∧ q), is then the monad's associativity, not a rewrite of this partition's.

Parameters

q	the query.
f	the Kleisli arrow.

operator>>() [15/31]

template<std::regular S, std::semiregular Coalg, IsArrow F>
requires detail_comprehension::ReadsItsElements<unfold_view<S, Coalg>, F>

auto dedekind::category::operator>> ( const unfold_view< S, Coalg > & q, F f )

constexprexport

>> f on a query, SQL's SELECT: f on the present elements, the holes passed through, Maybe's action on the arrow (maybe_functor).

Parameters

q	the query.
f	the arrow.

operator>>() [16/31]

template<std::regular S, std::semiregular Coalg, std::size_t K>

auto dedekind::category::operator>> ( const unfold_view< S, Coalg > & q, Take< K >  )

constexprexport

take<K> on a query or a sequence: the walk, until K elements are present, lazily (rewrite 1; on a sorted query, rewrite 3's first K).

Parameters

q	the query.

Returns

its first K.

operator>>() [17/31]

template<std::regular S, std::semiregular Coalg, IsArrow F>
requires std::same_as<Dom<F>, typename unfold_view<S, Coalg>::element_type>

unfold_view< S, Mapped< S, Coalg, F > > dedekind::category::operator>> ( const unfold_view< S, Coalg > & v, F f )

constexprexport

ns >> f: f mapped over the walk, as a walk.

Parameters

v	the walk.
f	the arrow.

operator>>() [18/31]

template<typename Q, typename Rank, typename Order, std::size_t K>

auto dedekind::category::operator>> ( detail_comprehension::Pending< Q, Rank, Order > p, Take< K >  )

constexprexport

order_by >> take<K> with no law: fused, one pass keeping the best K in an AtMost, never sorting the whole (rewrite 2). A query still, each element present, so its count is its rows' and collect makes the plain list.

Parameters

p	the pending sort.

Returns

the best K, best first.

operator>>() [19/31]

template<typename F, typename G>
requires IsArrow<std::decay_t<F>> && (!IsArrow<std::decay_t<G>>) && std::invocable<std::decay_t<G>&, const typename std::decay_t<F>::Codomain&>

auto dedekind::category::operator>> ( F f, G g )

constexprexport

operator>> with a callable on the RHS — auto-wraps the lambda as arrow<F::Codomain> .

Convenience overload so call sites can chain a typed Arrow with an inline lambda without per-site arrow(λ) ceremony. The lambda's Domain is deduced from the LHS Arrow's Codomain; its Codomain is deduced from the lambda's invoke result. Equivalent to std::forward<F>(f) >> arrow<B>(std::forward<G>(g)) where B = F::Codomain — but spelled inline.

Note

Symmetric (lambda >> Arrow) adapter is intentionally NOT shipped: a bare lambda LHS has no fixed Domain, and inferring it from the RHS's Domain is fragile when the lambda is polymorphic. Wrap the lambda explicitly via arrow (λ) for that direction.

operator>>() [20/31]

template<typename F, typename G>
requires IsArrow<std::decay_t<F>> && IsArrow<std::decay_t<G>> && std::same_as<typename std::decay_t<F>::Codomain, typename std::decay_t<G>::Domain>

auto dedekind::category::operator>> ( F f, G g )

constexprexport

Synthesizes an arrow A -> C from A -> B and B -> C.

morphism__Categorical

By requiring A, B, and C as template parameters, we ensure the composition is a statically verified bridge. Functors are arrows too; their composition, which also composes their actions on arrows, is a more constrained overload in :functor, preferred by subsumption.

operator>>() [21/31]

template<typename T, IsArrow G>
requires std::same_as<T, Dom<G>>

auto dedekind::category::operator>> ( Identity< T > , G g )

constexprexport

small__Identity_Short_Circuits

operator>>() [22/31]

template<IsQuery Q>

std::size_t dedekind::category::operator>> ( Q q, detail_comprehension::CountingStage  )

constexprexport

q >> counting, the stage form of count(q): the fold that ends a query, in the query's own rhythm.

Parameters

q	the query.

Returns

its count.

operator>>() [23/31]

template<std::ranges::input_range Q, IsArrow Rank, typename Order>

detail_comprehension::Pending< Q, Rank, Order > dedekind::category::operator>> ( Q q, OrderBy< Rank, Order > by )

constexprexport

order_by with no law to read: pending its take.

Parameters

q	the query.
by	the stage.

Returns

the pending sort.

operator>>() [24/31]

template<detail_comprehension::IsForeignView R, typename P, typename S, IsArrow T>

auto dedekind::category::operator>> ( R r, const Prefixed< P, S, T > & s )

constexprexport

Where a prefixed section's words occur in a range of the caller's: the windows of its length it holds, as r >> s for a section.

Parameters

r	the view.
s	the meet.

Returns

the query.

operator>>() [25/31]

template<detail_comprehension::IsForeignView R, typename P, typename S, IsArrow T>
requires requires(R r, const Symmetric<P, S, T>& s) { std::move(r) >> windows(1uz) >> where(s); }

auto dedekind::category::operator>> ( R r, const Symmetric< P, S, T > & s )

constexprexport

r >> s: where the words of a section occur in a range of the caller's: its windows of the section's length, each kept where the section holds it. The section knows its length, so no window of another arises. Listing 5's dna >> pali6, the same expression as the join below read at one sequence.

Parameters

r	the view.
s	the section.

Returns

the query.

operator>>() [26/31]

template<detail_comprehension::IsForeignView R, IsArrow F>
requires std::invocable<const F&, std::ranges::range_reference_t<R>>

auto dedekind::category::operator>> ( R r, F f )

constexprexport

r >> f on a range of the caller's: f on each element, which is std::views::transform.

Parameters

r	the view.
f	the arrow.

Returns

the standard's transform view.

operator>>() [27/31]

template<detail_comprehension::IsForeignView R>
requires std::ranges::forward_range<R>

auto dedekind::category::operator>> ( R r, Windows w )

constexprexport

Parameters

r	a view of the caller's.
w	the stage.

Returns

the standard's slide view over it.

operator>>() [28/31]

template<typename T, typename Arrow>
requires IsArrow<Arrow> && std::convertible_to<T, typename Arrow::Domain>

auto dedekind::category::operator>> ( T value, const Arrow & f )->typenameArrow::Codomain

constexprexport

Proposition: A Value x can be piped into a Morphism f: A -> B.

morphism__Pipe_Operator

This is the terminal step of a Highway pipeline. It maps the Species-level data into the Codomain result.

Template Parameters

T	The Input Value type (The 'Car').
Arrow	The Morphism type (The 'Highway').

Note

Syntactic Sugar: x >> f ≡ f(x).

operator>>() [29/31]

template<std::ranges::view V, std::size_t Sigma, std::size_t Q>
requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>

auto dedekind::category::operator>> ( V letters, const Automaton< Sigma, Q > & plan )

constexprexport

s >> scanner: a plan read as the stage it is.

Parameters

letters	a text.
plan	the plan.

Returns

the query.

operator>>() [30/31]

template<std::ranges::view V, std::size_t Sigma, std::size_t Q>
requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>

auto dedekind::category::operator>> ( V letters, const Matches< Sigma, Q > & m )

constexprexport

Parameters

letters	a text of the caller's: bytes, read through the plan's own columns, so no text is read in another alphabet; or letters' ranks, also as rank(alphabet) reads them; a view, read where it is.
m	the stage.

Returns

the query of the positions where a word of the set ends: count it, take from it, collect it.

operator>>() [31/31]

template<std::ranges::view V, std::size_t Sigma, std::size_t Q>
requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>

auto dedekind::category::operator>> ( V letters, const Maybe< Matches< Sigma, Q > > & m )

constexprexport

Parameters

letters	a text read as letters.
m	the stage, or nothing.

Returns

the query, or nothing: Maybe's action on the stage.

operator>>=()

template<typename MA, typename F>
requires requires(MA const& ma, F&& f) { { κ(ma, std::forward<F>(f)) }; }

auto dedekind::category::operator>>= ( MA const & ma, F f )

constexprexport

operator>>= : Monadic bind (Kleisli arrow application).

kleisli__Kleisli_Bind_Operators

Syntactic sugar for κ(ma, f). Given ma: T and f: A → T, produces T.

operator|() [1/2]

template<typename A, typename B>
requires detail_lattice_nodes::BuildNodes<A, B>

Join< A, B > dedekind::category::operator| ( A a, B b )

constexprexport

Parameters

a

param b two predicates that build nodes.

Returns

their join, the node.

operator|() [2/2]

template<IsCountWord N, std::size_t J, std::size_t K>

RunList< N, J+K > dedekind::category::operator| ( const RunList< N, J > & a, const RunList< N, K > & b )

constexprexport

The union of two run lists, at once: the lattice's Join node folded by the one reducer, the sweep its leaf-combine, as the set grammar's | folds through SetCombine (sets). Its bound is the sum of theirs. The strict form; the lazy one is the node itself, built and reduced later, as the predicates that opt in to :lattice's | keep it (#1138).

Parameters

a

param b two run lists on one chain.

Returns

their union.

operator||()

template<typename P, typename Q>
requires IsPredicatePair<P, Q>

auto dedekind::category::operator|| ( P p, Q q )

constexprexport

Logical Disjunction (Union): Synthesizes a rule for A ∪ B.

Note

Textbook term: join (∨) in the internal Heyting/Boolean algebra of Ω.

operator~() [1/2]

template<IsArrow F>
requires std::unsigned_integral<Cod<F>> && (!std::same_as<Cod<F>, bool>)

auto dedekind::category::operator~ ( const F & f )

constexprexport

The involutions of a codomain, pointwise on the arrows into it: ~f and -f are f then the reflection of the chain, respectively unary minus, (-f)(x) = -f(x) as for functions in analysis; on an identity the composite is the involution itself (the unit law, :morphism). !f, for the arrows into a truth object, is in :topoi. Unsigned only: -INT_MIN is not a function on int (:involution); and not bool, which C++ counts as unsigned, so a set's characteristic arrow keeps the complement of :sets.

Parameters

f	the arrow.

operator~() [2/2]

ReflectedReverse dedekind::category::operator~ ( Reverse )

constexprexport

Returns

the reversal, then the reflection of the alphabet on every letter.

order_by()

template<typename Order = ascending, IsArrow Rank>
requires std::strict_weak_order<const Order&, Cod<Rank>, Cod<Rank>>

OrderBy< Rank, Order > dedekind::category::order_by ( Rank rank, Order order = {} )

constexprexport

Template Parameters

Order

the comparison, ascending by default.

Parameters

rank

the rank.

Returns

the stage.

period() [1/9]

template<HasPeriod F, IsArrow G>

Dom< F > dedekind::category::period ( const Compose< F, G > & c )

constexprexport

Inferred, not declared: an arrow after a periodic one is periodic with the same period, whatever the second arrow is.

Parameters

c	the composite.

Returns

the first leg's period.

period() [2/9]

template<IsCountWord N, HasPeriod G>

N dedekind::category::period ( const Compose< Shift< N >, G > & c )

constexprexport

Parameters

c	a translation, then a periodic arrow.

Returns

its period.

period() [3/9]

template<IsCountWord N>

N dedekind::category::period ( const Congruent< N > & c )

constexprexport

Parameters

c	the residue class.

Returns

its modulus.

period() [4/9]

template<IsCountWord N, typename B>

N dedekind::category::period ( const ConstantMorphism< N, B > & )

constexprexport

A constant sequence, a constant arrow out of the counts: period 1, on the whole word. A constant arrow from anything else is no sequence and has no period.

Returns

1.

period() [5/9]

template<IsCountWord N>

N dedekind::category::period ( const FibonacciMod< N > & f )

constexprexport

The Pisano period \(\pi(m)\), the period of the Fibonacci numbers modulo m, a theorem: it exists and is at most \(6m\), so a search of that length finds it.

Parameters

f	the arrow.

Returns

its period.

period() [6/9]

template<HasPeriod P, HasPeriod Q>

Dom< P > dedekind::category::period ( const Join< P, Q > & j )

constexprexport

Parameters

j

the join.

Returns

the lcm of its legs' periods.

period() [7/9]

template<HasPeriod P, HasPeriod Q>

Dom< P > dedekind::category::period ( const Meet< P, Q > & m )

constexprexport

Parameters

m

the meet.

Returns

the lcm of its legs' periods.

period() [8/9]

template<HasPeriod P>

Dom< P > dedekind::category::period ( const Not< P > & n )

constexprexport

Parameters

n	the complement of a periodic predicate.

Returns

its period: negation reads one value, so keeps the period.

period() [9/9]

template<detail_periodic::IsPeriodicPredicate F, std::semiregular Step, std::semiregular Acc>

Dom< F > dedekind::category::period ( const Rolling< F, Step, Acc > & r )

constexprexport

Parameters

r	the window.

Returns

the predicate's period.

popcount() [1/2]

template<std::unsigned_integral B>
requires (!std::same_as<B, bool>)

std::size_t dedekind::category::popcount ( B x )

constexprexport

The number of bits set in a machine word: the hardware's count, one instruction where the target has it.

Parameters

x

the word.

Returns

how many of its bits are set.

popcount() [2/2]

template<std::size_t W>

std::size_t dedekind::category::popcount ( const std::bitset< W > & x )

constexprexport

The number of bits set in a std::bitset.

Parameters

x

the word.

Returns

how many of its bits are set.

position() [1/2]

template<IsCountWord N>

N dedekind::category::position ( const Rotation< N > & r, N n, N i )

constexprexport

Parameters

r	the rotation by d.
n	the length.
i	a position below it.

Returns

\(i + d \bmod n\), where the letter at i moves.

position() [2/2]

template<IsCountWord N>

N dedekind::category::position ( Reverse , N n, N i )

constexprexport

A permutation of positions on indices: where it sends the position i of a word of length n, the reversal to \(n - 1 - i\).

Parameters

n	the length.
i	a position below it.

Returns

its image.

power() [1/2]

template<IsArrow T>
requires std::same_as<Dom<T>, Cod<T>>

PowerMap< T > dedekind::category::power ( const T & tau )

constexprexport

Parameters

tau	an arrow on the letters.

Returns

tau on every letter of a word.

power() [2/2]

template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F>
requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>

Power< C, F, N > dedekind::category::power ( const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > & leg, std::type_identity_t< N > n )

constexprexport

Parameters

leg	a chain of letters under a predicate, the filtered alphabet.
n	the length.

Returns

the words of length n over it.

predecessor() [1/2]

bool dedekind::category::predecessor ( bool )

constexprexportnoexcept

The step on the truth chains

\(\mathbf{Pst} = \mathbf{Jlt} \cap \mathbf{Chain}\): a bounded chain's cover saturates at ⊤ and its dual at ⊥, the posture Cardinality takes at ℵ₀. So the shipped truth chains 𝔹 and K₃ have the NNO step (a dense Pst carrier such as the unit interval has none: density is the absence of a cover), and the order layer's point collapse reads {x : ⊥ < x < ⊤} on K₃ as {Unknown}. bool is integral, so its successor already saturates (true + 1 narrows to true); its predecessor must not wrap.

predecessor() [2/2]

std::byte dedekind::category::predecessor ( std::byte b )

constexprexportnoexcept

Parameters

b

a byte.

Returns

the byte before it, saturating at the bottom.

predicate_and()

template<typename A, typename P, typename Q>
requires std::invocable<const std::decay_t<P>&, const A&> && std::invocable<const std::decay_t<Q>&, const A&> && IsΩ<std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>> && std::same_as< std::remove_cvref_t< std::invoke_result_t<const std::decay_t<P>&, const A&>>, std::remove_cvref_t< std::invoke_result_t<const std::decay_t<Q>&, const A&>>>

auto dedekind::category::predicate_and ( P p, Q q )

constexprexport

Compose two plain callable predicates over a declared domain A.

This is a practical bridge for std::predicate-style lambdas/functions that have not been lifted to Arrow/Predicate objects yet.

prefix()

Prefix dedekind::category::prefix ( std::string_view word )

constexprexport

Parameters

word	the letters, written out.

Returns

the predicate.

preimage() [1/2]

template<IsArrow F, IsArrow P>
requires std::same_as<Cod<F>, Dom<P>>

auto dedekind::category::preimage ( const F & f, const P & p )

constexprexport

The contravariant substitution / pullback f*: pull a codomain predicate (or arrow) P back along f, preimage(f,P) = P∘f = Compose<F,P>.

This is the general shape of the domain axis of a classifier \(\chi:A\to\Omega\) (#908): reindexing a predicate on the codomain to one on the domain. It is contravariant in f — preimage(f, preimage(g,P)) = preimage(g∘f, P), i.e. \((g\circ f)^* = f^*\circ g^*\) (by associativity of Compose) — so the arrow order reverses under pullback. Downstream partitions supply closed-form overloads that collapse P∘f symbolically rather than deferring it (e.g. :algebra's halfspace_transport pulls a Halfspace back through an affine graph to a new Halfspace; :relational, :complex likewise); those are the specialized fibres this general form is the default for.

Template Parameters

F	the map A→B to pull back along.
P	the codomain predicate/arrow B→Ω; Cod<F> must be Dom

.

Parameters

f	the map to substitute.
p	the codomain predicate to reindex.

Returns

the composite P∘f as a reified Compose<F,P> arrow A→Ω.

preimage() [2/2]

template<IsCountWord N, std::size_t K>

RunList< N, K > dedekind::category::preimage ( const Shift< N > & t, const RunList< N, K > & s )

constexprexport

preimage(shift(d), s): the pullback of s along the translation, \(x \mapsto s(x + d)\), in closed form, a run list again: the closed-form overload of :morphism's preimage(f, P), whose general form is the composite P∘f, as algebra's halfspace_transport gives one for an interval. The translation is read as a map of the chain, on its extent: the counts \(x\) with \(x + d\) below the word's top (extent in :periodic, where a shift's law holds), where the word does not wrap. halfspace_transport gates the same reading by the carrier's type (an ordered group, or ℕ, where \(x + k\) misses \(\{0, \ldots, k - 1\}\)); on the word, Pst's carrier, the extent is that gate, by value. The elements of s below d, whose preimages would wrap past the top, lie outside it and are not reported; the derivative (:automaton) meets its operand with the letter's interval first, so none exist there. The other reading, the word as the cyclic group \(\mathbb{Z}/2^w\) whose translation wraps, is order's translate (an image, a run through the end splitting in two) and morphologies' congruence preimage; it is a different arrow, and not this one (#1138).

Parameters

t	the translation.
s	the run list.

Returns

the preimage, on the extent.

product_arrow()

template<IsArrow F, IsArrow G>

ProductArrow< F, G > dedekind::category::product_arrow ( const F & f, const G & g )

constexprexport

f × g, built.

Parameters

f

param g the factors.

pullback()

template<typename L = Boole, typename Π, typename F_Raw, typename G_Raw>

auto dedekind::category::pullback ( F_Raw f_raw, G_Raw g_raw )

constexprexport

The Pullback Factory — constructs the Fiber Product X ×_Z Y.

Given two morphisms f: X ⟶ Z and g: Y ⟶ Z, constructs the Fiber Product P ≅ X ×_Z Y as the Subobject of Π = X × Y classified by the characteristic morphism χ(x, y) = (f(x) == g(y)).

Template Parameters

L	The Logic Species used for the Subobject Classifier Ω. Defaults to Boole (bool).
Π	The Product Species (must satisfy IsProduct<Π, Dom<F>, Dom<G>>). Typically std::pair<X, Y>.
F_Raw	The (possibly raw callable) type for the first morphism f: X ⟶ Z.
G_Raw	The (possibly raw callable) type for the second morphism g: Y ⟶ Z.

Parameters

f_raw	The first morphism (or raw callable) f: X ⟶ Z.
g_raw	The second morphism (or raw callable) g: Y ⟶ Z.

Returns

A Subobject<Π, χ> representing P = X ×_Z Y.

pushed_down()

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires requires(const S& s) { requires detail_periodic::IsBoundedFactorsOf<decltype(count_factors(s)), N>; }

auto dedekind::category::pushed_down ( const Cylinder< Power< C, F, N >, S, N > & c )

constexprexport

The plan of a cylinder, its selection pushed down. A cylinder in Tarski's sense, a predicate on a product in which only some legs constrain: the window's legs must lie in the set, the others are free. So the predicate moves onto the window's factor, \(\sigma_\varphi(W \times F) = \sigma_\varphi(W) \times F\), and the cylinder is the set times the power on the free legs, an outer product, whatever the window's offset. Defined where the window fits.

Parameters

c	the cylinder.

Returns

its plan, an outer product.

random_letter()

RandomLetter dedekind::category::random_letter ( const Alphabet & alphabet, std::uint64_t seed = 0 )

constexprexport

Parameters

alphabet	the letters.
seed	the seed.

Returns

its random letter by position.

random_text()

auto dedekind::category::random_text ( const Alphabet & alphabet, std::size_t length, std::uint64_t seed = 0 )

constexprexport

Parameters

alphabet	the letters.
length	how many positions.
seed	the seed.

Returns

the random text, a view, never stored.

random_word()

template<std::size_t N>

std::array< std::byte, N > dedekind::category::random_word ( const Alphabet & alphabet, std::uint64_t seed = 0 )

constexprexport

A random word held as a value, for a law's input where a stage wants contiguous letters.

Template Parameters

N	its length.

Parameters

alphabet	the letters.
seed	the seed.

Returns

the word.

rank() [1/2]

Ranked dedekind::category::rank ( const Alphabet & alphabet )

constexprexport

Parameters

alphabet

the filtered byte chain, as abc builds it.

Returns

the rank of a byte in its letters.

rank() [2/2]

Ranked dedekind::category::rank ( const Letters & on )

constexprexport

Parameters

on	the alphabet.

Returns

the rank of a byte in it.

reduced()

template<typename T>

auto dedekind::category::reduced ( const T & t )

constexprexport

Parameters

t	a lattice term over run lists.

Returns

its normal form: the reducer's laws, then the run lists' sweep on what remains.

refl() [1/2]

Reflection dedekind::category::refl ( const Alphabet & alphabet )

constexprexport

Parameters

alphabet

the filtered byte chain, as abc builds it.

Returns

the duality of its letters, the complement of ACGT. (#1141)

refl() [2/2]

Reflection dedekind::category::refl ( const Letters & on )

constexprexport

Parameters

on	the letters.

Returns

their duality. (#1141)

reflexive_at()

template<typename Rel, typename T>
requires requires(const Rel& r, const T& x) { { r(x, x) } -> std::convertible_to<bool>; }

bool dedekind::category::reflexive_at ( const Rel & rel, const T & a )

constexprexport

mereology__The_Laws_At_A_Point

Each law of a relation, read on a value at given points: the same statement the trait certifies for every point, decidable here for one. A relation over a finite carrier is checked exhaustively by these; a run-time relation (relational:rows) reads them as well (#1045: one definition per property, read on both sides). Ω = bool here; the many-valued reading is the run-time side's.

refutes()

template<typename L>

bool dedekind::category::refutes ( Truth< L > proposition )

constexprexportnoexcept

Semantic falsity projection for assertion contexts.

In non-classical logics (e.g., Kleene K3), refutes is distinct from !holds: Unknown is neither proven true nor proven false.

retract()

template<typename F>
requires IsIsomorphism<std::remove_cvref_t<F>> && requires(const std::remove_cvref_t<F>& cf, const Cod<F>& y) { inverse(cf)(y); }

auto dedekind::category::retract ( F f )

constexprexport

Blanket retract for any IsIsomorphism: wraps inverse(f) in always-Some (see IsoRetract). This is what makes IsIsomorphism ⟹ IsRetractableArrow hold with no manual hook.

Declared before IsRetractableArrow so the concept's dependent retract(f) lookup finds it by ordinary (non-ADL) lookup: an iso defined in a client namespace (whose associated namespaces do not include dedekind::category) is then still retractable, as the blanket implication advertises.

Gated on the inverse arrow being const-invocable: IsoRetract holds f as a const member and applies inverse(f) in a const operator(), so a mutable-inverse-only iso (one that satisfies IsIsomorphism but whose inverse arrow has a mutable-only operator()) must not be advertised as retractable: without this guard the concept's call-expression check passes (the body is not instantiated) yet the actual retract(f)(y) fails to compile. This mirrors the #823 const-invocability discipline the ImageChi retract seam also enforces.

rolling_any()

template<detail_periodic::IsPeriodicPredicate F>

Rolling< F, detail_periodic::AnyStep, bool > dedekind::category::rolling_any ( F f, std::type_identity_t< Dom< F > > w )

constexprexport

Whether any of w consecutive values is true.

Parameters

f	the predicate.
w	the width.

rolling_count()

template<detail_periodic::IsPeriodicPredicate F>

Rolling< F, detail_periodic::CountStep< Dom< F > >, Dom< F > > dedekind::category::rolling_count ( F f, std::type_identity_t< Dom< F > > w )

constexprexport

How many of w consecutive values are true, SQL's COUNT OVER a window.

Parameters

f	the predicate.
w	the width.

rotate()

template<IsCountWord N = std::size_t>

Rotation< N > dedekind::category::rotate ( std::type_identity_t< N > d )

constexprexport

Parameters

d	the shift.

Returns

the rotation of the positions by d.

run()

template<std::size_t K, IsCountWord N>
requires (K >= 2)

RunList< N, K > dedekind::category::run ( N lo, std::type_identity_t< N > hi )

constexprexport

Template Parameters

K	the bound on the steps.

Parameters

lo

param hi the ends.

Returns

the run \([lo, hi)\), empty where hi is not past lo.

run_list() [1/4]

template<std::size_t KL, std::size_t Sigma, std::size_t P, IsCountWord N>
requires (Sigma >= 4 && Sigma % 2 == 0)

Maybe< RunList< N, KL > > dedekind::category::run_list ( const Prefixed< Power< std::byte, Letters, N >, Reverse, Reflection > & sites )

constexprexport

The words of a section beginning with a prefix, by the law: no word tested, only the half-sites the prefix allows visited.

Parameters

sites

the meet.

Returns

its words, or nothing where a bound is too small.

run_list() [2/4]

template<std::size_t KL, std::size_t Sigma, std::size_t P, HasNNOStep C, IsArrow F, IsCountWord N, typename S, IsArrow T>

Maybe< RunList< N, KL > > dedekind::category::run_list ( const Symmetric< Power< C, F, N >, S, T > & sites )

constexprexport

A section's words as a run list over their codes: each word read as its letters' ranks in base \(\sigma\), the first the most significant, so the chain \([0, \sigma^n)\) in the dictionary order. Every code is read back as its word and tested by the section's own membership: \(\sigma^n\) tests, the set enumerated once.

Template Parameters

KL	the bound claimed on the steps.
Sigma	the letters.
P	the bound on the words' length.

Parameters

sites

the section.

Returns

its words, or nothing where a bound is too small.

run_list() [3/4]

template<std::size_t KL, std::size_t Sigma, std::size_t P, IsCountWord N>
requires (Sigma >= 4 && Sigma % 2 == 0)

Maybe< RunList< N, KL > > dedekind::category::run_list ( const Symmetric< Power< std::byte, Letters, N >, Reverse, Reflection > & sites )

constexprexport

The words a reflection then the reversal fixes, listed by the law: a word is fixed by its half-site, so the \(\sigma^{n/2}\) halves are visited in order and no word is tested, where the general overload tests all \(\sigma^n\). This is what lets a small panel's table be built at compile time. With an even alphabet the reflection fixes no letter, and from four letters no two codes are adjacent, so each is a run of its own. An odd length, or a reflection other than the alphabet's own, is left to the general overload.

Parameters

sites

the section.

Returns

its words, or nothing where a bound is too small.

run_list() [4/4]

template<std::size_t K, IsCountWord N, typename Pred>
requires std::predicate<const Pred&, N>

Maybe< RunList< N, K > > dedekind::category::run_list ( N end, Pred holds )

constexprexport

The run list of a predicate on \([0, \mathit{end})\): every count tested once, a step where the value changes.

Template Parameters

K	the bound claimed on the steps.

Parameters

end	the chain's end.
holds	the predicate.

Returns

its run list, or nothing where the bound is too small.

scan() [1/2]

template<std::ranges::view V, std::size_t Sigma, std::size_t Q>
requires std::ranges::random_access_range<V> && std::ranges::sized_range<V> && std::semiregular<V>

auto dedekind::category::scan ( const Automaton< Sigma, Q > & plan, V letters )

constexprexport

scan(plan, s): the history comonad's extension with its kernel factored through finitely many states, so that it keeps one state, not the history (Myhill and Nerode). It is matches(plan), its holes breaking a match.

Parameters

plan	the plan.
letters	a text.

Returns

the query.

scan() [2/2]

template<typename T, IsPrefixKernel< T > K>

auto dedekind::category::scan ( K k, std::span< const T > s )

constexprexport

scan(k, s), the extension of the history comonad: a kernel asked at every non-empty prefix, SQL's window function over ROWS UNBOUNDED PRECEDING, as scan on a Path (:sequences). Every position has a prefix, so unlike a window of n this is a comonad on a finite range; each answer may read the whole prefix, so a kernel that factors through finitely many states has an overload of its own (:automaton).

Parameters

k	the kernel.
s	the text.

Returns

the answers, lazily.

shift()

template<IsCountWord N = std::size_t>

Shift< N > dedekind::category::shift ( std::type_identity_t< N > j )

constexprexport

Template Parameters

N	the counts.

Parameters

j	the translation.

Returns

\(k \mapsto k + j\).

slice()

template<HasNNOStep C>
requires std::totally_ordered<C>

Slice< C > dedekind::category::slice ( C lo, C hi )

constexprexport

Parameters

lo	the bottom.
hi	the top, excluded.

Returns

the chain between them.

split_epi_section_law_at()

template<typename Epi, typename Section>
requires IsSplitEpicPair<Epi, Section> && std::equality_comparable<Cod<Epi>>

bool dedekind::category::split_epi_section_law_at ( const Epi & epi, const Section & section, const Cod< Epi > & b )

constexprexport

Law check for split epimorphisms at a concrete codomain element.

Encodes the semantic Axiom 10 equation e ∘ s = id at value b.

states()

template<std::size_t Sigma, std::size_t Q>

std::size_t dedekind::category::states ( const Automaton< Sigma, Q > & plan )

constexprexport

Parameters

plan

a plan.

Returns

how many states it has.

successor() [1/2]

std::byte dedekind::category::successor ( std::byte b )

constexprexportnoexcept

The octets' covering step: std::byte's order read as a chain, the next byte, saturating at the top. No arithmetic, only the step, so a byte chain is a chain and no integer chain.

Parameters

b

a byte.

Returns

the byte after it.

successor() [2/2]

template<std::integral T>

T dedekind::category::successor ( T n )

constexprexportnoexcept

The successor arrow as a free customization point: successor(n) for an NNO carrier, and its partial dual predecessor(n).

"Is there a next element" is the NNO's successor — an axiom of the category (it enters IsSet through HasETCSAxioms), not a per-carrier flag. So the order layer's value-determined point collapse of a bounded meet ({x : lo < x < hi} is the single point succ(lo) when succ(lo) == pred(hi)) gates on these, not on std::integral, which is a C++ accident that would exclude the ℕ proxy Cardinality — itself the canonical NNO witness.

Built-in integral carriers step by ±1. A carrier with the :morphologies static-member convention T::successor(n) is bridged. Any other carrier provides its own overloads in its namespace, found by ADL (the ℕ proxy does so in :sets:cardinality; its predecessor is the monus, 0 a fixpoint dual to ℵ_0 under successor). Callers spell the two-step (using dedekind::category::successor; then an unqualified call) so both the generic defaults and the ADL overloads compete.

sum() [1/4]

template<IsCountWord N, HasUnitPeriod F>
requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, N>

N dedekind::category::sum ( const FiniteChainSequence< N, F > & v )

constexprexport

The sum along the chain of n under a sequence of period 1 by its type, a constant one on its extent: n copies of f(0), one multiplication by the semimodule law, and no fold at all, not even over a period of one or a remainder of none. The action of \(\mathbb{N}\) on the counts collapsing a constant, as Listing 4's concat on copies does. More specialised than the periodic sum, so resolution prefers it.

Parameters

v	the chain under the sequence.

Returns

n f(0), modulo the word.

sum() [2/4]

template<IsCountWord N, HasPeriod F>
requires std::same_as<Dom<F>, N> && std::same_as<Cod<F>, N>

N dedekind::category::sum ( const FiniteChainSequence< N, F > & v )

constexprexport

The sum along the chain of n under a periodic arrow into the counts: (n div p) copies of one period's sum, one multiplication by the semimodule law, and a remainder.

Parameters

v	the chain under the arrow.

Returns

f(0) + ... + f(n - 1), modulo the word.

sum() [3/4]

template<IsQuery Q, IsCountWord N = typename std::ranges::range_value_t< Q>::value_type>

N dedekind::category::sum ( Q q )

constexprexport

The sum of a query of counts, SQL's SUM: + lifted through Maybe.

Parameters

q	the query.

Returns

the sum of its present elements, modulo the word.

sum() [4/4]

template<std::ranges::input_range R>
requires IsCountWord<std::ranges::range_value_t<R>>

std::ranges::range_value_t< R > dedekind::category::sum ( R r )

constexprexport

The sum of a range of counts: the plain fold.

Parameters

r	the range.

Returns

the sum, modulo the word.

sum_arrow()

template<IsArrow F, IsArrow G>

SumArrow< F, G > dedekind::category::sum_arrow ( const F & f, const G & g )

constexprexport

f + g, built.

Parameters

f

param g the summands.

symmetric() [1/4]

template<HasNNOStep C, IsArrow F, IsCountWord N, IsArrow T, typename S>
requires std::same_as<Dom<T>, C> && HasCycleType<S, N>

Symmetric< Power< C, F, N >, S, T > dedekind::category::symmetric ( const Power< C, F, N > & p, const Compose< Morphism< std::vector< C >, std::vector< C >, S >, PowerMap< T > > & g )

constexprexport

Parameters

p	a tensor power.
g	a permutation of the positions, then an arrow on every letter: the same section, the two commuting.

Returns

the words it fixes.

symmetric() [2/4]

template<HasNNOStep C, IsArrow F, IsCountWord N, IsArrow T, typename S>
requires std::same_as<Dom<T>, C> && HasCycleType<S, N>

Symmetric< Power< C, F, N >, S, T > dedekind::category::symmetric ( const Power< C, F, N > & p, const Compose< PowerMap< T >, Morphism< std::vector< C >, std::vector< C >, S > > & g )

constexprexport

Parameters

p	a tensor power.
g	an arrow on every letter, then a permutation of the positions: power(complement) >> rev.

Returns

the words it fixes.

symmetric() [3/4]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires HasCycleType<S, N>

Symmetric< Power< C, F, N >, S, Identity< C > > dedekind::category::symmetric ( const Power< C, F, N > & p, const Morphism< std::vector< C >, std::vector< C >, S > & sigma )

constexprexport

Parameters

p	a tensor power.
sigma	a permutation of its positions, named on its words.

Returns

the words it fixes.

symmetric() [4/4]

template<HasNNOStep C, IsArrow F, IsCountWord N, typename S>
requires HasCycleType<S, N>

Symmetric< Power< C, F, N >, S, Identity< C > > dedekind::category::symmetric ( const Power< C, F, N > & p, S sigma )

constexprexport

Parameters

p	a tensor power.
sigma	a permutation of its positions, rev or rotate(d).

Returns

the words it fixes.

take()

template<std::size_t K>

Take< K > dedekind::category::take ( )

constexprexport

Template Parameters

K	the bound.

Returns

the stage.

uncurry() [1/2]

template<typename T, typename Op>

Uncurried< T, Op > dedekind::category::uncurry ( Curried< T, Op > c )

constexprexport

The inverse of curry<T>.

Parameters

c	the curried operation.

uncurry() [2/2]

template<IsArrow F>
requires IsArrow<Cod<F>>

auto dedekind::category::uncurry ( F f )

constexprexport

Uncurrying: (X → B^A) ⟹ (X × A → B).

Transforms a function returning a function into a single function taking a categorical product (std::pair).

unfold() [1/2]

template<std::regular S, std::semiregular Coalg>

Unfold< S, Coalg > dedekind::category::unfold ( Coalg c )

constexprexport

The anamorphism, as an arrow.

Template Parameters

S	the state.

Parameters

c	the coalgebra.

unfold() [2/2]

template<std::regular S, std::semiregular Coalg>

unfold_view< S, Coalg > dedekind::category::unfold ( S seed, Coalg step )

constexprexport

The unfold of seed by step.

Template Parameters

S	the state.
Coalg	the coalgebra.

Parameters

seed	the first state.
step	the coalgebra.

Returns

the view.

unit()

template<typename T, typename Op>
requires requires { unit_trait<T, Op>::value; }

T dedekind::category::unit ( Op )

constexprexport

The unit of Op at the carrier T, read as unit<T>(Op{}).

A function of the operation's value: concepts read it at compile time, an ordinary call reads it at runtime. Registration stays with unit_trait / unit_registry, since a class template admits partial specialisation (whole families of carriers, across modules) and a function template does not.

Template Parameters

T	The carrier.
Op	The operation (deduced).

until()

template<IsArrow End, IsArrow Step>

Until< End, Step > dedekind::category::until ( End end, Step step )

constexprexport

The guard.

Parameters

end	where the chain stops.
step	the total step.

Returns

the partial step.

where() [1/2]

template<typename P, typename S, IsArrow T>

auto dedekind::category::where ( const Symmetric< P, S, T > & s )

constexprexport

where(section): the windows a section holds, its membership as the filter, where(sites). The section stays a tensor (its * is the outer product); only here is it read as a predicate, its characteristic map, an arrow from a window of its letters: a std::span, since an arrow has one domain and a text is contiguous (a genome's bytes, Listing 5's carrier). The membership itself reads any random-access range; a window of a non-contiguous container is tested by it directly, not through this stage.

Parameters

s	the section.

Returns

the stage.

where() [2/2]

template<IsArrow P>
requires std::same_as<Cod<P>, bool>

Where< P > dedekind::category::where ( P p )

constexprexport

Parameters

p	the predicate.

Returns

the elements where it holds.

window()

template<IsCountWord N = std::size_t>

Window< N > dedekind::category::window ( std::type_identity_t< N > offset, std::type_identity_t< N > length )

constexprexport

Parameters

offset	the first position.
length	how many.

Returns

the window of the words there.

windows()

Windows dedekind::category::windows ( std::size_t n )

constexprexport

Parameters

n	the window's length, at least one.

Returns

the stage.

with_width()

template<typename F>
requires std::invocable<const F&, std::integral_constant<std::size_t, 8>>

auto dedekind::category::with_width ( std::size_t n, const F & f )

constexprexport

A width known only at run time, dispatched to the narrowest precompiled bit word that holds it: 8, 16, 32 or 64 bits, a machine word, or 128, 256 or 512, a std::bitset. f is called with the width as a type, so it can name BitWord of it. Refused past max_packed_width.

Parameters

n	the width.
f	what to do in that word.

Returns

its result.

words()

template<IsCountWord N = std::size_t, HasNNOStep C, IsArrow F>
requires std::totally_ordered<C> && std::same_as<Dom<F>, C> && std::convertible_to<Cod<F>, bool>

Powers< C, F, N > dedekind::category::words ( const unfold_view< std::optional< C >, detail_chain::SliceStep< C, F > > & leg )

constexprexport

Template Parameters

N	the counts.

Parameters

leg	the filtered alphabet.

Returns

its powers, by length.

zero()

template<typename T>

auto dedekind::category::zero ( )

constexprexport

The zero morphism factory: produces the unique (unreachable) arrow ?: Zero → T.

From the Initial Object Zero (std::nullptr_t) there is exactly one morphism to any species T. Since nullptr can never actually appear as input in a well-formed program, this arrow's body is logically unreachable and terminates if ever called.

Template Parameters

T	The codomain species.

Variable Documentation

bounded_pred

auto dedekind::category::bounded_pred = [limit = 42](int x) { return x < limit; }

constexpr

cartesian__Structural_Exponential_Verification

chain_walk_budget

std::size_t dedekind::category::chain_walk_budget = 1024

inlineconstexpr

The walk budget of a discrete bounded chain: a chain is decided only when its top is reached from its bottom within this many steps (a machine word is a discrete bounded chain too, but 2⁶⁴ steps is no compile-time decision).

mereology__The_Laws_On_A_Chain

Each law over a whole discrete chain, decided: the law at a point, at every point (pair, triple) from lo to hi, the chain walked by the carrier's own successor (found by argument-dependent lookup). constexpr, so the compiler decides a certificate with them and the program a run-time relation with the same functions. Precondition: hi is reached from lo by the step (the rules below check it before calling).

characteristic_v

template<typename T>

size_t dedekind::category::characteristic_v

inlineconstexprexport

Initial value:

=
    0

The Characteristic of the Species.

For a finite ring (like char or int), this is the modulus n where n * 1 = 0. For infinite fields (Q, R), it is 0.

commutes_v

template<typename F, typename G>

bool dedekind::category::commutes_v

inlineconstexprexport

Initial value:

=
    commutes<std::remove_cvref_t<F>, std::remove_cvref_t<G>>::value ||
    commutes<std::remove_cvref_t<G>, std::remove_cvref_t<F>>::value

every_arrow_law

std::array<ArrowLaw, 6> dedekind::category::every_arrow_law

inlineconstexprexport

Initial value:

{
    ArrowLaw::Injective, ArrowLaw::Surjective, ArrowLaw::Monotone,
    ArrowLaw::Antitone,  ArrowLaw::Involutive, ArrowLaw::Constant}

has_mixed_carrier_v< Join< A, B > >

template<typename A, typename B>

bool dedekind::category::has_mixed_carrier_v< Join< A, B > >

inlineconstexprexport

Initial value:

=
    has_mixed_carrier_v<A> || has_mixed_carrier_v<B> ||
    (std::is_void_v<carrier_of_t<A>> != std::is_void_v<carrier_of_t<B>>) ||
    (!std::is_void_v<carrier_of_t<A>> && !std::is_void_v<carrier_of_t<B>> &&
     !std::is_same_v<carrier_of_t<A>, carrier_of_t<B>>)

has_mixed_carrier_v< Meet< A, B > >

template<typename A, typename B>

bool dedekind::category::has_mixed_carrier_v< Meet< A, B > >

inlineconstexprexport

Initial value:

=
    has_mixed_carrier_v<A> || has_mixed_carrier_v<B> ||
    (std::is_void_v<carrier_of_t<A>> != std::is_void_v<carrier_of_t<B>>) ||
    (!std::is_void_v<carrier_of_t<A>> && !std::is_void_v<carrier_of_t<B>> &&
     !std::is_same_v<carrier_of_t<A>, carrier_of_t<B>>)

has_one_value_v

template<typename T>

bool dedekind::category::has_one_value_v

inlineconstexprexport

Initial value:

=
    has_one_value<std::remove_cvref_t<T>>::value

idempotent_leaf_v

template<typename X>

bool dedekind::category::idempotent_leaf_v

inlineconstexprexport

Initial value:

=
    std::is_empty_v<std::remove_cvref_t<X>>

Is X a leaf whose VALUE is determined by its TYPE? Idempotence X∧X=X is sound only for such a leaf. Two same-type instances are then necessarily the same set, so collapsing them is correct. The default is std::is_empty_v<X>, true for a stateless tag or an NTTP-encoded carrier. A carrier with RUNTIME-STATEFUL leaves specialises this to false for them. sets does so for Set<T,L,P> whose predicate P carries a runtime field (e.g. a Point's pivot). The type-based idempotence then does not collapse two distinct-but-same-type values.

idempotent_leaf_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< T, L, C >, P > >

template<typename T, IsOckhamAlgebra L, typename P, dedekind::sets::IsCardinality C>

bool dedekind::category::idempotent_leaf_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< T, L, C >, P > >

inlineconstexpr

Initial value:

=
    std::is_empty_v<P>

idempotent_leaf_v< Join< A, B > >

template<typename A, typename B>

bool dedekind::category::idempotent_leaf_v< Join< A, B > >

inlineconstexpr

Initial value:

=
    idempotent_leaf_v<A> && idempotent_leaf_v<B>

idempotent_leaf_v< Meet< A, B > >

template<typename A, typename B>

bool dedekind::category::idempotent_leaf_v< Meet< A, B > >

inlineconstexpr

Initial value:

=
    idempotent_leaf_v<A> && idempotent_leaf_v<B>

A compound node is value-determined iff its operands are. So a Meet / Join / Not of value-determined leaves stays collapsible, while one carrying a runtime-stateful leaf does not. This keeps the value-safety gate recursive rather than treating every operand-storing node as stateful (Meet / Join / Not now store their operands, so the bare std::is_empty_v default would report false for all of them).

is_absorptive_v

template<typename T, typename Op1, typename Op2>

bool dedekind::category::is_absorptive_v = false

inlineconstexprexport

The Absorber Trait (Axiom: a ∨ (a ∧ b) = a). Represents the structural tethering between two dual operations.

Note

(#387 lift) The named concept IsAbsorptive that wraps this trait, plus the audit witnesses, live in dedekind.category:mereology (per #387's lift; the original draft considered a separate morphologies:absorption partition but settled on :mereology since the consumer concepts already live there). The opt-in specialisations for the canonical operator pairs ((logical_or, logical_and), the (bit_xor, bit_and) Boolean-ring non-witness) stay here, alongside the trait-variable template, so that other concepts in category (e.g. IsLattice in :total, IsMereologicalSkewLattice in :mereology, IsOrderLatticeOperations in :posetal) can reach them via the direct trait check without creating a circular dependency on :mereology.

is_absorptive_v< T, std::bit_and< T >, std::bit_or< T > >

template<typename T>

bool dedekind::category::is_absorptive_v< T, std::bit_and< T >, std::bit_or< T > >

inlineconstexpr

Initial value:

=
    std::is_integral_v<T>

is_absorptive_v< T, std::bit_and< T >, std::bit_xor< T > >

template<typename T>

bool dedekind::category::is_absorptive_v< T, std::bit_and< T >, std::bit_xor< T > >

inlineconstexpr

Initial value:

=
    false

is_absorptive_v< T, std::bit_or< T >, std::bit_and< T > >

template<typename T>

bool dedekind::category::is_absorptive_v< T, std::bit_or< T >, std::bit_and< T > >

inlineconstexpr

Initial value:

=
    std::is_integral_v<T>

Algebra-trait specialisations for std::bit_or<T> / std::bit_and<T> on specific integral T (#710).

order_lattice__Bitwise_Algebra_Trait_Registration

The project's existing specialisations cover bool + the transparent std::bit_or<> / std::bit_and<> forms, plus is_idempotent and is_associative for std::bit_or<T> on integral T at species.cppm:866-872. The pieces this slice still needs for the bitwise Boolean lattice's IsLatticeCategory chain to fire on generic integral T:

• is_absorptive_v<T, std::bit_or<T>, std::bit_and<T>> (variable spec)
• is_absorptive_v<T, std::bit_and<T>, std::bit_or<T>> (variable spec) (The typed distributivity pair lives in :species, beside the transparent one.)

Variable-template partial specs in this file embed the constraint in the value (cf. species.cppm:740 / :745 pattern with std::unsigned_integral / std::integral), not via a requires clause on the template — the requires-form yields "no variable template matches partial specialization" on libc++/clang.

is_absorptive_v< T, std::bit_xor< T >, std::bit_and< T > >

template<typename T>

bool dedekind::category::is_absorptive_v< T, std::bit_xor< T >, std::bit_and< T > >

inlineconstexpr

Initial value:

=
    false

is_absorptive_v< T, std::logical_or< T >, std::logical_and< T > >

template<typename T>

bool dedekind::category::is_absorptive_v< T, std::logical_or< T >, std::logical_and< T > > = true

inlineconstexpr

species__Lattice_Absorber_Registration

is_adjoint_v< Copy< bool >, Merge< bool, std::logical_and< bool > >, ProductLeq< std::less_equal< bool >, std::less_equal< bool > > >

template<>

bool dedekind::category::is_adjoint_v< Copy< bool >, Merge< bool, std::logical_and< bool > >, ProductLeq< std::less_equal< bool >, std::less_equal< bool > > >

inlineconstexpr

Initial value:

=
        true

is_adjoint_v< Copy< P >, Merge< P, Inf >, ProductLeq< std::less_equal< P >, std::less_equal< P > > >

template<std::totally_ordered P>

bool dedekind::category::is_adjoint_v< Copy< P >, Merge< P, Inf >, ProductLeq< std::less_equal< P >, std::less_equal< P > > > = true

inlineconstexpr

The theorem Δ ⊣ ∧, \(\Delta(a) \le_\times (x, y) \iff a \le x \wedge y\), registered per glb: Inf (min) on a totally ordered carrier under its own ≤, and ∧ on bool. The shape IsMerge cannot tell the glb from the lub (Sup is a monotone fold of the same signature and is not the right adjoint of Δ), so the law leg is where that distinction lives; a merge with another injected op registers its own fact next to the proof that it is the glb.

Template Parameters

P	the totally ordered carrier.

is_antimonotone_v

template<typename F, typename Op = std::less_equal<>>

bool dedekind::category::is_antimonotone_v

inlineconstexprexport

Initial value:

=
    antimonotone_trait<std::remove_cvref_t<F>, Op>::value

is_antimonotone_v< Compose< F, G >, Op >

template<typename F, typename G, typename Op>

bool dedekind::category::is_antimonotone_v< Compose< F, G >, Op >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Compose, arrow_laws_v<F, Op>,
               arrow_laws_v<G, Op>)[ArrowLaw::Antitone] == Ternary::True

is_antimonotone_v< dedekind::algebra::Inverse< G, std::plus< G > >, Op >

template<typename G, typename Op>

bool dedekind::category::is_antimonotone_v< dedekind::algebra::Inverse< G, std::plus< G > >, Op > = true

inlineconstexpr

The additive group inverse Inverse<G, +> is antitone exactly on an ordered additive group (translation invariance is the hypothesis of the -b≤-a step), so the registration is gated on IsOrderedAdditiveGroup — the algebraic dog-food of the antitone reification (#959).

Note

The multiplicative inverse Inverse<G, *> (x ↦ 1/x) is antitone only on the positive cone (0

is_antimonotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >

template<typename A, typename F, typename B, typename G, typename LeqA, typename LeqB>

bool dedekind::category::is_antimonotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Product, arrow_laws_v<F, LeqA>,
               arrow_laws_v<G, LeqB>)[ArrowLaw::Antitone] == Ternary::True

is_antimonotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >

template<typename R, typename S, typename LeqR, typename LeqS>

bool dedekind::category::is_antimonotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >

inlineconstexpr

Initial value:

=
    true

is_antisymmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >

template<typename A, typename L, typename C, typename Op>

bool dedekind::category::is_antisymmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >

inlineconstexpr

Initial value:

=
    is_antisymmetric_v<A, Op>

is_antisymmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_antisymmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_antisymmetric_v<A, Endo<A, L, C, PR>> ||
    is_antisymmetric_v<A, Endo<A, L, C, PS>>

is_antisymmetric_v< A, Endo< A, L, C, SwapPred< P > > >

template<typename A, typename L, typename C, typename P>

bool dedekind::category::is_antisymmetric_v< A, Endo< A, L, C, SwapPred< P > > >

inlineconstexpr

Initial value:

=
    is_antisymmetric_v<A, Endo<A, L, C, P>>

is_antisymmetric_v< dedekind::algebra::Monomial< N >, std::less_equal<> >

template<std::size_t N>

bool dedekind::category::is_antisymmetric_v< dedekind::algebra::Monomial< N >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_antisymmetric_v< dedekind::numbers::Rational< I >, std::less_equal<> >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_antisymmetric_v< dedekind::numbers::Rational< I >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_antisymmetric_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

template<typename A, typename B, typename LeqA, typename LeqB>

bool dedekind::category::is_antisymmetric_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

inlineconstexpr

Initial value:

=
        IsAntisymmetric<A, LeqA> && IsAntisymmetric<B, LeqB>

is_antisymmetric_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

template<typename X, typename Y>

bool dedekind::category::is_antisymmetric_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

inlineconstexpr

Initial value:

=
    IsAntisymmetric<X, std::less_equal<X>> &&
    IsAntisymmetric<Y, std::less_equal<Y>>

is_antisymmetric_v< std::variant< X, Y >, std::less_equal<> >

template<typename X, typename Y>

bool dedekind::category::is_antisymmetric_v< std::variant< X, Y >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        IsAntisymmetric<X, std::less_equal<>> &&
        IsAntisymmetric<Y, std::less_equal<>>

is_associative_v< ConstantMorphism< A, B >, Op >

template<typename A, typename B, typename Op>

bool dedekind::category::is_associative_v< ConstantMorphism< A, B >, Op > = true

inlineconstexpr

discrete__Constant_Morphism_Axioms

A Constant Mapping is inherently associative under any operation because it is a fixed sink: c ∘ (c ∘ c) = c.

is_associative_v< D, std::multiplies< D > >

template<IsConstructed D>

bool dedekind::category::is_associative_v< D, std::multiplies< D > >

inlineconstexpr

Initial value:

=
    associative<typename construction_base<D>::type>(
        std::multiplies<typename construction_base<D>::type>{}) &&
    (!construction_base<D>::times_mixes_plus ||
     CommutativeRingLaws<typename construction_base<D>::type>)

is_associative_v< D, std::plus< D > >

template<IsConstructed D>

bool dedekind::category::is_associative_v< D, std::plus< D > >

inlineconstexpr

Initial value:

=
    associative<typename construction_base<D>::type>(
        std::plus<typename construction_base<D>::type>{})

is_associative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >

template<typename R>

bool dedekind::category::is_associative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >

inlineconstexpr

Initial value:

=
        IsRng<R, std::plus<R>, std::multiplies<R>>

is_associative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

template<typename I>

bool dedekind::category::is_associative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

inlineconstexpr

Initial value:

=
    true

is_associative_v< Identity< T >, Op >

template<typename T, typename Op>

bool dedekind::category::is_associative_v< Identity< T >, Op >

inlineconstexpr

Initial value:

=
    is_associative_v<T, Op>

Verification

Traits to the Identity Functor

is_associative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

template<std::integral T>

bool dedekind::category::is_associative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

inlineconstexpr

Initial value:

=
    true

is_associative_v< T, Op >

template<typename T, typename Op>

bool dedekind::category::is_associative_v< T, Op > = true

inlineconstexpr

small__Grounding_Truths

is_associative_v< T, std::bit_xor< T > >

template<std::integral T>

bool dedekind::category::is_associative_v< T, std::bit_xor< T > > = true

inlineconstexpr

is_associative_v< T, std::modulus< T > >

template<std::integral T>

bool dedekind::category::is_associative_v< T, std::modulus< T > > = false

inlineconstexpr

Modulus is NOT associative nor commutative, and has no identity.

This is because (a mod n) mod n = a mod n, but (a mod n) mod m != a mod m in general. Also, a mod n != n mod a in general.

is_closed_under_v

template<typename S, typename A, typename Op>

bool dedekind::category::is_closed_under_v = false

inlineconstexprexport

User-declared closure witness: subobject S of A is closed under operation Op.

Closure: for all m1, m2 of S::Member, the value Op(ι(m1), ι(m2)) lies in the image of ι (i.e. is itself representable as a Member of S). Cannot be checked at compile time in general — opt-in.

Universal-algebra reference: Burris-Sankappanavar §II.5.

is_closure_forcing_v

template<typename Op, typename A, typename B>

bool dedekind::category::is_closure_forcing_v = false

inlineconstexprexport

Opt-in trait carrying the universal-property clause of IsClosureForcing — the engineer's honesty obligation that B is the canonical (smallest) carrier closing Op over A inputs. C++ concepts cannot quantify universally, so this part of the witness is asserted, not deduced. Pattern mirrors is_associative_v / is_saturating.

Specialise for each concrete (Op, A, B) triple where the universal-property holds — typically next to the carrier definitions, so the canonicality claim is visible alongside the carrier choice.

is_commutative_v< D, std::multiplies< D > >

template<IsConstructed D>

bool dedekind::category::is_commutative_v< D, std::multiplies< D > >

inlineconstexpr

Initial value:

=
    commutative<typename construction_base<D>::type>(
        std::multiplies<typename construction_base<D>::type>{}) &&
    (!construction_base<D>::times_mixes_plus ||
     CommutativeRingLaws<typename construction_base<D>::type>)

is_commutative_v< D, std::plus< D > >

template<IsConstructed D>

bool dedekind::category::is_commutative_v< D, std::plus< D > >

inlineconstexpr

Initial value:

=
    commutative<typename construction_base<D>::type>(
        std::plus<typename construction_base<D>::type>{})

is_commutative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >

template<typename R>

bool dedekind::category::is_commutative_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > >

inlineconstexpr

Initial value:

=
        IsRng<R, std::plus<R>, std::multiplies<R>> &&
        commutative<R>(std::multiplies<R>{})

is_commutative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

template<typename I>

bool dedekind::category::is_commutative_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

inlineconstexpr

Initial value:

=
    true

is_commutative_v< Identity< T >, Op >

template<typename T, typename Op>

bool dedekind::category::is_commutative_v< Identity< T >, Op >

inlineconstexpr

Initial value:

=
    is_commutative_v<T, Op>

is_commutative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

template<std::integral T>

bool dedekind::category::is_commutative_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

inlineconstexpr

Initial value:

=
    true

is_complement_pair_v

template<typename RA, typename RB>

bool dedekind::category::is_complement_pair_v

inlineconstexprexport

Initial value:

=
    std::same_as<RB, Not<RA>> || std::same_as<RA, Not<RB>>

Are RA and RB a complement pair (RB=¬RA or RA=¬RB)?

is_complement_v

template<typename Not, typename T, typename Rel, typename Join, typename Meet>

bool dedekind::category::is_complement_v

inlineconstexprexport

Initial value:

=
    is_complement<Not, T, Rel, Join, Meet>::value

is_complemented_lattice_for_v< bool, canonical_order >

template<>

bool dedekind::category::is_complemented_lattice_for_v< bool, canonical_order >

inlineconstexprexport

Initial value:

=
    true

Canonical bool is a Boolean (hence complemented) lattice.

is_complemented_lattice_for_v< bool, dedekind::sets::subobject_order< L > >

template<typename L>

bool dedekind::category::is_complemented_lattice_for_v< bool, dedekind::sets::subobject_order< L > >

inlineconstexpr

Initial value:

=
        true

is_complemented_v

template<typename T, typename Join, typename Meet, typename Not>

bool dedekind::category::is_complemented_v = false

inlineconstexprexport

Opt-in complement law: T carries a complement Not w.r.t. the bounded lattice (Join, Meet), i.e. \(a \vee \neg a = \top\) and \(a \wedge \neg a = \bot\) for every a.

Like the other algebraic laws (is_idempotent_v / is_absorptive_v) this is an opt-in trait defaulting to false; a carrier registers true and backs it with a computed witness at the registration site (the complement identity is a per-element fact the concept machinery cannot enumerate generically). Kept local to :total because IsBooleanAlgebra is its only consumer; promote to :species if reused.

is_complemented_v< bool, std::logical_or< bool >, std::logical_and< bool >, std::logical_not< bool > >

template<>

bool dedekind::category::is_complemented_v< bool, std::logical_or< bool >, std::logical_and< bool >, std::logical_not< bool > > = true

inlineconstexpr

(#809)

The lattice varieties, pinned on \(\mathbb{B}\) = bool under (logical_or, logical_and, logical_not) — the ∧/∨ mirror of the ring ladder (IsRng ... IsField) above. Two orthogonal directions climb here: equational refinement within the pure signature Alg(∧,∨) (Semilattice ⊂ Lattice ⊂ DistributiveLattice), and signature expansion (IsBoundedLattice adds the nullary bounds ⊥/⊤; IsBooleanAlgebra adds the unary complement ¬) — exactly as the ring ladder expands Alg(+,×) with 1 and inverses to reach IsField. The bounds on bool are \(\bot\) = false (join identity) and \(\top\) = true (meet identity).

is_congruence_v

template<typename R, typename T, typename Op>

bool dedekind::category::is_congruence_v = false

inlineconstexprexport

User-declared congruence witness: R respects Op on T.

A congruence is an equivalence relation preserved by Op: R(x, x') ∧ R(y, y') ⇒ R(Op(x, y), Op(x', y')). The full congruence definition is then IsEquivalence<T, R> ∧ is_congruence_v<R, T, Op>. Cannot be checked at compile time in general; opt-in.

Single-operation form. Multi-op congruences for ring-flavoured carriers (joint (+, ·) preservation) wait on a downstream witness; the variadic lift is the Sollbruchstelle here.

is_congruence_v< dedekind::morphologies::ModularCongruence< N >, typename dedekind::morphologies::Modular< N >::machine_type, std::plus< typename dedekind::morphologies::Modular< N >::machine_type > >

template<auto N>

bool dedekind::category::is_congruence_v< dedekind::morphologies::ModularCongruence< N >, typename dedekind::morphologies::Modular< N >::machine_type, std::plus< typename dedekind::morphologies::Modular< N >::machine_type > >

inlineconstexpr

Initial value:

=
    true

is_congruence_v< dedekind::sequences::TailEquivalent< T >, dedekind::sequences::Path< T >, std::plus< dedekind::sequences::Path< T > > >

template<typename T>

bool dedekind::category::is_congruence_v< dedekind::sequences::TailEquivalent< T >, dedekind::sequences::Path< T >, std::plus< dedekind::sequences::Path< T > > >

inlineconstexpr

Initial value:

=
    true

is_connex_v< A, Endo< A, L, C, PairwisePred< Op > > >

template<typename A, typename L, typename C, typename Op>

bool dedekind::category::is_connex_v< A, Endo< A, L, C, PairwisePred< Op > > >

inlineconstexpr

Initial value:

=
    is_connex_v<A, Op>

is_connex_v< A, Endo< A, L, C, RelOr< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_connex_v< A, Endo< A, L, C, RelOr< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_connex_v<A, Endo<A, L, C, PR>> || is_connex_v<A, Endo<A, L, C, PS>>

is_connex_v< A, Endo< A, L, C, SwapPred< P > > >

template<typename A, typename L, typename C, typename P>

bool dedekind::category::is_connex_v< A, Endo< A, L, C, SwapPred< P > > >

inlineconstexpr

Initial value:

=
    is_connex_v<A, Endo<A, L, C, P>>

is_connex_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

template<std::floating_point F>

bool dedekind::category::is_connex_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_connex_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

template<long D, typename Q>

bool dedekind::category::is_connex_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_connex_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

template<typename W>

bool dedekind::category::is_connex_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_connex_v< Percentage, std::less_equal< Percentage > >

template<>

bool dedekind::category::is_connex_v< Percentage, std::less_equal< Percentage > >

inlineconstexpr

Initial value:

=
    true

is_connex_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

template<typename X, typename Y>

bool dedekind::category::is_connex_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

inlineconstexpr

Initial value:

=
        IsConnex<X, std::less_equal<X>> && IsConnex<Y, std::less_equal<Y>>

is_connex_v< std::variant< X, Y >, std::less_equal<> >

template<typename X, typename Y>

bool dedekind::category::is_connex_v< std::variant< X, Y >, std::less_equal<> >

inlineconstexpr

Initial value:

=
    IsConnex<X, std::less_equal<>> && IsConnex<Y, std::less_equal<>>

is_constant_arrow_v

template<typename E>

bool dedekind::category::is_constant_arrow_v = false

inlineconstexprexport

The constancy of an arrow: declared for ConstantMorphism (:discrete), read off composition by the law engine (:posetal).

Template Parameters

E	the arrow.

is_constant_arrow_v< Compose< F, G > >

template<IsArrow F, IsArrow G>

bool dedekind::category::is_constant_arrow_v< Compose< F, G > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Compose, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Constant] == Ternary::True

is_constant_arrow_v< ConstantMorphism< A, B > >

template<typename A, typename B>

bool dedekind::category::is_constant_arrow_v< ConstantMorphism< A, B > > = true

inlineconstexpr

discrete__Constant_Is_Constant

Every argument to one value: the arrow factors through the terminal object, \(c \circ\, !\), so it is stated with no order on either side (Lawvere and Rosebrugh [6]). It is the vertical arrow of the Jlt paper's Figure 2 where the fold is n copies of one value (#981). Its variances, monotone and antitone under every reflexive order on the codomain, are registered in :total, where that order is in reach.

is_distributive_lattice_for_v

template<typename T, typename Ord>

bool dedekind::category::is_distributive_lattice_for_v

inlineconstexprexport

Initial value:

=
    std::same_as<resolved_order_t<T, Ord>, std::less_equal<T>> &&
    IsLatticeCategory<T> && IsOrderDistributiveLatticeOperations<T>

Is the lattice (carrier T, order Ord) distributive? Keyed to the order like the boundedness markers. The canonical (std::less_equal chain) case derives from the concept gates IsLatticeCategory<T> && IsOrderDistributiveLatticeOperations<T> — so a carrier that is not a lattice under std::less_equal is not licensed to distribute (NB the bare distributive<T>(max{}, min{}) trait is unconditionally true, which would license any carrier — hence the concept gate). A NON-chain distributive lattice (a custom Ord) opts in by specialising this to true (the Jlt assertion — the same posture as the injected total order). A canonical chain is gated distributive but never actually distributes: its joins glb/lub-collapse first.

is_distributive_lattice_for_v< T, dedekind::sets::subobject_order< L > >

template<typename T, typename L>

bool dedekind::category::is_distributive_lattice_for_v< T, dedekind::sets::subobject_order< L > > = true

inlineconstexpr

The subobject lattice Sub(T) is a distributive lattice under subobject_order<L>, for every carrier T and classifier L. In a topos Sub(T) is a Heyting algebra (meet distributes over join), and the classical (Boole) case is the Boolean specialisation of that. The DNF rewrite, however, acts on the pointwise L::AND / L::OR of the predicates, so its soundness needs those operations to distribute, which the IsOckhamAlgebra shape gate does not certify. So the marker is gated on a species-level distributivity certificate: IsBoundedDeMorganChain<L>. A bounded De Morgan chain is (by chain-normality) a distributive lattice, so its L::AND / L::OR distribute; every shipped species (Boole, Kleene, Chain<T>, Percent) satisfies it, while an unconstrained / non-distributive custom L is excluded (fail-closed). When gated, it licenses the reducer's meet_distributivity_law to rewrite a genuinely non-collapsing Sub(T) meet-over-join into disjunctive normal form (X∧(P∨Q)→(X∧P)∨(X∧Q)). FIXME(#907/#923): replace IsBoundedDeMorganChain with a dedicated species-level distributivity certificate (via the :species-trait bridge) so non-chain distributive logics can also opt in.

Note

This gate fires only for a bare category::Join reducer node; the value-level set operators materialise an irreducible union as a Join (a distinct type the reducer treats as an opaque leaf), so this marker does not change the value-level normal form (A∩(B∪C) still materialises as a Meet carrying its operands, per #892). Driving the DNF rewrite through the value path is a separate normal-form decision, deferred (#865).

is_distributive_v

template<typename T, typename Mult, typename Add>

bool dedekind::category::is_distributive_v = false

inlineconstexprexport

Trait to mark the structural glue between two operators. axiom: a * (b + c) = (a * b) + (a * c).

species__The_Distributive_Axiom

is_distributive_v< bool, std::logical_and< bool >, std::logical_or< bool > >

template<>

bool dedekind::category::is_distributive_v< bool, std::logical_and< bool >, std::logical_or< bool > >

inlineconstexpr

Initial value:

=
        true

is_distributive_v< bool, std::logical_or< bool >, std::logical_and< bool > >

template<>

bool dedekind::category::is_distributive_v< bool, std::logical_or< bool >, std::logical_and< bool > >

inlineconstexpr

Initial value:

=
        true

is_distributive_v< D, std::multiplies< D >, std::plus< D > >

template<IsConstructed D>

bool dedekind::category::is_distributive_v< D, std::multiplies< D >, std::plus< D > >

inlineconstexpr

Initial value:

=
    distributive<typename construction_base<D>::type>(
        std::multiplies<typename construction_base<D>::type>{},
        std::plus<typename construction_base<D>::type>{}) &&
    (!construction_base<D>::times_mixes_plus ||
     CommutativeRingLaws<typename construction_base<D>::type>)

is_distributive_v< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N >, dedekind::linear_algebra::MatPlus< S, N > >

template<typename S, std::size_t N>

bool dedekind::category::is_distributive_v< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N >, dedekind::linear_algebra::MatPlus< S, N > >

inlineconstexpr

Initial value:

=
        distributive<S>(typename dedekind::algebra::semiring_ops<S>::mult{},
                        typename dedekind::algebra::semiring_ops<S>::add{})

⊗ distributes over ⊕ in Mat(S) exactly when it does in S (§4 property distribution) — not unconditionally.

is_distributive_v< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >

template<detail_mat2x2::HasRingEntries T>

bool dedekind::category::is_distributive_v< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > >

inlineconstexpr

Initial value:

=
        true

is_distributive_v< dedekind::morphologies::Modular< N >, std::multiplies<>, std::plus<> >

template<auto N>

bool dedekind::category::is_distributive_v< dedekind::morphologies::Modular< N >, std::multiplies<>, std::plus<> > = true

inlineconstexpr

cyclic__Distributivity_and_Invertibility

is_distributive_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > >, std::plus< dedekind::numbers::Complex< R > > >

template<typename R>

bool dedekind::category::is_distributive_v< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > >, std::plus< dedekind::numbers::Complex< R > > >

inlineconstexpr

Initial value:

=
        IsRng<R, std::plus<R>, std::multiplies<R>>

is_distributive_v< T, std::bit_and< T >, std::bit_or< T > >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::bit_and< T >, std::bit_or< T > >

inlineconstexpr

Initial value:

=
    std::integral<T>

is_distributive_v< T, std::bit_and<>, std::bit_or<> >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::bit_and<>, std::bit_or<> >

inlineconstexpr

Initial value:

=
    std::integral<T>

is_distributive_v< T, std::bit_or< T >, std::bit_and< T > >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::bit_or< T >, std::bit_and< T > >

inlineconstexpr

Initial value:

=
    std::integral<T>

is_distributive_v< T, std::bit_or<>, std::bit_and<> >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::bit_or<>, std::bit_and<> >

inlineconstexpr

Initial value:

=
    std::integral<T>

is_distributive_v< T, std::multiplies< T >, std::plus< T > >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::multiplies< T >, std::plus< T > >

inlineconstexpr

Initial value:

=
    true

is_distributive_v< T, std::multiplies<>, std::plus<> >

template<typename T>

bool dedekind::category::is_distributive_v< T, std::multiplies<>, std::plus<> >

inlineconstexpr

Initial value:

=
    std::unsigned_integral<T> && HasTotalProduct<T>

Self-verifying the structural integrity of the reified species.

species__Taxonomic_Validation

species__Ring_like_distributivity_for_unsigned_integrals

The Modular<N> carrier and its trait specialisations moved to dedekind.morphologies:cyclic as part of #378; see that partition for the finite-cyclic-ring story. The generic distributivity claim for std::unsigned_integral carriers (which covers unsigned int / unsigned long / size_t) stays here.

is_embedding_functor_v

template<typename F>

bool dedekind::category::is_embedding_functor_v = false

inlineconstexprexport

Trait registry for the IsEmbeddingFunctor concept.

(#633)

Textbook CT (Mac Lane CWM; Borceux Handbook) names functors by their adjective modifiers, not by polymorphism / non-polymorphism umbrellas. The project already carries the textbook-canonical modifiers as separate concepts:

• IsEndofunctor (Mac Lane §I.3; F : 𝒞 → 𝒞) — defined above in this partition.
• IsFreeFunctor (Mac Lane §IV.3; left adjoint to forgetful) — defined in :adjunction.
• IsForgetfulFunctor (Mac Lane §IV; right adjoint to free) — defined in :adjunction.

The two modifiers below complete the monic / epi pair the carrier-lattice and (A, F) anchor work need:

• IsEmbeddingFunctor (Mac Lane CWM §IV.4; fully faithful + injective on objects — the Yoneda-embedding flavour). Concrete witnesses: the embed_*_*_ family.
• IsQuotientFunctor (Borceux Handbook §4.3; regular epi / coequalizer presentation). Slot reserved for the (A, F) anchor's Σ-algebras-as-functors T_Σ → Ddk (algebras arise as quotients of free algebras — Burris-Sankappanavar §II.10) and #602's carrier-lattice Frac / Cplx / Dual quotient half.

Both are engineer-asserted via trait registration — is_embedding_functor_v<F> / is_quotient_functor_v<F> — mirroring the is_monic_arrow_v / is_epic_arrow_v pattern in :morphism. The categorical content (fully faithful + injectivity on objects for embeddings; coequalizer of two parallel functors for quotients) is the engineer's claim, type-checked at the registration site.

Weaker reading variants (IsFaithfulFunctor on its own, IsFullFunctor on its own, IsEpiFunctor without the regular- epi strengthening, IsEssentiallySurjectiveFunctor, ...) land flat as separate concepts when a consumer earns them; there's no umbrella distinction in textbook CT.

functor__Two_Intuition_Pumps

Two reading registers live side-by-side in CT (cf. #633 body), but they are not separate type-system concepts:

• Container / Hask-endofunctor flavour: functor as polymorphic type-constructor. Examples in this partition: maybe_functor, tuple_functor, identity_functor. Type-system witness: these all satisfy IsShapedFunctor. At the textbook level they are endofunctors on Set; in this library's single-species encoding only identity_functor is literally Σ_cat = Τ_cat, while maybe_functor / tuple_functor present as Set<T> → Set<F<T>> (distinct single-species categories — so not a literal IsEndofunctor here; see the functor__IsFunctor_Models note).
• Algebraic-set / structural-CT flavour: functor as a structure-preserving map between two specific named categories, with further modifiers for monic / epi / faithful / full / etc. The carrier-lattice embeddings are IsEmbeddingFunctor witnesses; future quotient projections will be IsQuotientFunctor witnesses.

The two intuitions are unified at the IsFunctor level (Mac Lane §I.3): a functor is a structure-preserving map between two categories, full stop (IsShapedFunctor refines it with Shape). Polymorphic / non-polymorphic is a presentation choice for how F is given, not a structural CT property; textbook CT therefore does not name umbrella concepts "@c IsContainerFunctor" / "@c IsSpecificFunctor". This project follows the textbook reading: no umbrella concepts, only the textbook-canonical adjective modifiers.

Engineer-asserted opt-in: a functor is an embedding (fully faithful + injective on objects — Mac Lane CWM §IV.4, the Yoneda-embedding flavour) iff the engineer specialises this trait to true at the functor's declaration site. Mirrors is_monic_arrow_v in :morphism: the categorical claim is the engineer's, type-checked at the registration site.

Default false. Specialise at the carrier site (e.g. in :numbers:natural for embed_𝔹_ℕ_).

is_epic_arrow_v

template<typename E>

bool dedekind::category::is_epic_arrow_v = false

inlineconstexprexport

User-declared epicity witness for an arrow type.

Surjectivity cannot be verified at compile time in general. Users specialize this to true to declare that a given arrow is surjective (i.e., an epimorphism in the category of sets). The compiler trusts the declaration; no runtime proof is required.

This mirrors is_monic_arrow_v and follows the same opt-in declaration pattern.

is_epic_arrow_v< Compose< F, G > >

template<IsArrow F, IsArrow G>

bool dedekind::category::is_epic_arrow_v< Compose< F, G > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Compose, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Surjective] == Ternary::True

is_epic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >

template<typename F, typename G, typename X, typename Y>

bool dedekind::category::is_epic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Sum, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Surjective] == Ternary::True

is_epic_arrow_v< Copairing< F, G > >

template<typename F, typename G>

bool dedekind::category::is_epic_arrow_v< Copairing< F, G > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Copairing, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Surjective] == Ternary::True

is_epic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >

template<typename A, typename F, typename B, typename G>

bool dedekind::category::is_epic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Product, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Surjective] == Ternary::True

is_eval_arrow_v< dedekind::linear_algebra::Vec2V< T >, Idx >

template<typename T, typename Idx>

bool dedekind::category::is_eval_arrow_v< dedekind::linear_algebra::Vec2V< T >, Idx >

inlineconstexpr

Initial value:

=
    true

is_exact_category_v

template<typename C>

bool dedekind::category::is_exact_category_v = false

inlineconstexprexport

User-declared witness: C is an exact category — a regular category in which every equivalence relation is the kernel pair of some arrow (every equivalence relation is effective).

Set is exact, and every elementary topos is exact (Borceux vol 2 §2; "In Set and more generally any topos, every epimorphism is the coequalizer of its kernel pair"). Form-chain row 8 (#718).

is_exact_category_v< CanonicalSetCCC< A > >

template<typename A>

bool dedekind::category::is_exact_category_v< CanonicalSetCCC< A > > = true

inlineconstexpr

image__Factorisation_Cross_Reference

IsImageOf (mono leg) + IsCoequalizer (epi leg) jointly realise the (regular epi, mono) factorisation system named in :factorisation as IsFactorisationSystem<C>. The decomposition F = m ∘ e, with e the regular epi onto Im(F) and m the mono Im(F) ↪ Cod<F>, is what IsRegularCategory<C> witnesses universally; in Set / CanonicalSetCCC and every topos this factorisation is unique up to isomorphism. The witnesses below pin the canonical Set instances of the categorical chain.

is_factorisation_system_v

template<typename C>

bool dedekind::category::is_factorisation_system_v = false

inlineconstexprexport

User-declared witness: category C admits a (regular epi, mono) factorisation system — every arrow f of C factors as f = m ∘ e with e a regular epi and m a mono, uniquely up to iso.

The categorical anchor for the image-as-coequalizer reading (per :image's narration): the factorisation A → Im(F) → B is exactly the (regular epi, mono) factorisation of F.

is_functorial_v

template<typename F>

bool dedekind::category::is_functorial_v

inlineconstexprexport

Initial value:

=
    is_functorial<std::remove_cvref_t<F>>::value

is_idempotent_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

template<std::integral T>

bool dedekind::category::is_idempotent_v< std::ranges::iota_view< T, T >, dedekind::sequences::IotaIntersection >

inlineconstexpr

Initial value:

=
    true

is_idempotent_v< T, std::bit_or<> >

template<std::integral T>

bool dedekind::category::is_idempotent_v< T, std::bit_or<> > = true

inlineconstexpr

species__Transparent_Bridges

is_idempotent_v< T, std::bit_xor< T > >

template<typename T>

bool dedekind::category::is_idempotent_v< T, std::bit_xor< T > > = false

inlineconstexpr

(XOR, AND)

is_initial_f_algebra_v

template<typename F, typename A, typename α>

bool dedekind::category::is_initial_f_algebra_v = false

inlineconstexprexport

Opt-in trait: does carrier A witness the initial F-algebra universal property for endofunctor F with structure map α?

Defaults to false. Carriers register by partial- specialising this template to true at the point where they have the operational evidence (typically near the structural IsFAlgebra witness). The trait is the engineer's honesty obligation: declaring it asserts that the carrier truly satisfies the universal property's existence + uniqueness clause.

is_invertible_v< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >

template<typename F>

bool dedekind::category::is_invertible_v< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > >

inlineconstexpr

Initial value:

=
    true

is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >

template<auto N>

bool dedekind::category::is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > >

inlineconstexpr

Initial value:

=
        dedekind::morphologies::is_prime(static_cast<std::uint64_t>(N))

is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies<> >

template<auto N>

bool dedekind::category::is_invertible_v< dedekind::morphologies::Modular< N >, std::multiplies<> >

inlineconstexpr

Initial value:

=
        dedekind::morphologies::is_prime(static_cast<std::uint64_t>(N))

is_invertible_v< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >

template<dedekind::numbers::IsComplexScalar R>

bool dedekind::category::is_invertible_v< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > >

inlineconstexpr

Initial value:

=
    is_invertible_v<R, std::plus<R>>

is_invertible_v< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >

template<long D, typename Q>

bool dedekind::category::is_invertible_v< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > >

inlineconstexpr

Initial value:

=
        true

is_invertible_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_invertible_v< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > >

inlineconstexpr

Initial value:

=
    true

is_join_containing_v< Elem, Join< A, B > >

template<typename Elem, typename A, typename B>

bool dedekind::category::is_join_containing_v< Elem, Join< A, B > >

inlineconstexprexport

Initial value:

=
    std::same_as<Elem, A> || std::same_as<Elem, B>

is_kleene_associative_v

template<typename T, typename Op>

bool dedekind::category::is_kleene_associative_v = false

inlineconstexprexport

partial__Forward_Declarations_of_Traits

Kleene-style partial algebra traits. Specializations declare whether a binary operation on a type possesses associativity, commutativity, or invertibility under strong Kleene three-valued logic, where Unknown propagates unless dominated by False.

Strong Kleene logic is used (rather than weak Kleene / Priest logic) so that False \u2227 Unknown = False still holds – a defined-and-false input can short-circuit regardless of an undefined sibling.

Kleene, S.C. (1952). "Introduction to Metamathematics". Van Nostrand. \u00a764 (three-valued logic tables). Fitting, M. (1985). "A Kripke-Kleene Semantics for Logic Programs". J. Logic Programming 2(4):295\u2013312.

is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

template<std::floating_point F>

bool dedekind::category::is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

inlineconstexpr

Initial value:

=
    true

is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

template<std::floating_point F>

bool dedekind::category::is_kleene_associative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

inlineconstexpr

Initial value:

=
    true

is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

inlineconstexpr

Initial value:

=
    true

Kleene traits for rational arithmetic.

is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_kleene_associative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

inlineconstexpr

Initial value:

=
    true

is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

template<std::floating_point F>

bool dedekind::category::is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

inlineconstexpr

Initial value:

=
    true

is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

template<std::floating_point F>

bool dedekind::category::is_kleene_commutative_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

inlineconstexpr

Initial value:

=
    true

is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >

template<typename R>

bool dedekind::category::is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >

inlineconstexpr

Initial value:

=
    true

Kleene traits for complex arithmetic.

Commutativity holds for IEEE 754 component-wise operations. Associativity does NOT hold for floating-point carriers — that opt-in belongs exclusively to dedekind::ieee::IEEE<F>.

is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >

template<typename R>

bool dedekind::category::is_kleene_commutative_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >

inlineconstexpr

Initial value:

=
    true

is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

inlineconstexpr

Initial value:

=
    true

is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

template<dedekind::morphologies::IsInteger I>

bool dedekind::category::is_kleene_commutative_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

inlineconstexpr

Initial value:

=
    true

is_kleisli_arrow_v

template<typename E, typename M>

bool dedekind::category::is_kleisli_arrow_v = false

inlineconstexprexport

User-declared "Kleisli arrow" witness (#380, step 1).

A Kleisli arrow lives in the Kleisli category indexed by a monad tag M. Its underlying map has shape e: A → T, where T is the monadic carrier shape selected by the monad tag (Maybe for maybe_monad_tag, Identity for identity_monad_tag). The M slot is the monad tag itself — a tag type that names which Kleisli category the arrow inhabits — not the class template. Constrained by IsDefaultMonadTag to make the connection type-checked; downstream code can extend by adding new tags to the IsDefaultMonadTag disjunction in :natural. Default false; opt-in by specialising to true at the (E, M) pair. Pairs with the Kleisli extension above; this trait only declares membership in the Kleisli category, it does not implement composition.

is_kleisli_deref_v< dedekind::linear_algebra::Vec2V< T > >

template<typename T>

bool dedekind::category::is_kleisli_deref_v< dedekind::linear_algebra::Vec2V< T > >

inlineconstexpr

Initial value:

=
    true

is_lattice_bottom_for_v

template<typename X, typename Ord>

bool dedekind::category::is_lattice_bottom_for_v

inlineconstexprexport

Initial value:

=
    is_lattice_bottom_for<X, Ord>::value

is_lattice_node_v

template<typename T>

bool dedekind::category::is_lattice_node_v

inlineconstexprexport

Initial value:

=
    is_meet_node_v<T> || is_join_node_v<T> || is_not_node_v<T>

Whether T is one of the nodes, Meet, Join or Not.

is_left_total_v

template<typename R>

bool dedekind::category::is_left_total_v = false

inlineconstexprexport

User-declared left-totality witness for a binary relation.

Left-totality: every a ∈ A is related to at least one b ∈ B. Cannot be checked at compile time in general; opt-in via is_left_total_v<R> = true. Mirrors the is_monic_arrow_v / is_epic_arrow_v opt-in pattern in :morphism, and the is_reflexive_v / is_transitive_v / is_antisymmetric_v opt-in pattern in :mereology.

is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, P > >

template<typename A, typename B, typename L, typename C, typename P>

bool dedekind::category::is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, P > >

inlineconstexpr

Initial value:

=
    std::same_as<dedekind::sets::value_at_t<std::pair<A, B>,
                                            dedekind::sets::graph_term_t<P>>,
                 B> &&
    dedekind::sets::is_total_term_v<std::pair<A, B>,
                                    dedekind::sets::graph_term_t<P>>

is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

template<typename A, typename B, typename L, typename Card, typename PR, typename PS>

bool dedekind::category::is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Meet,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PS>>)
        [dedekind::relational::Law::Total] == Ternary::True

is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>

bool dedekind::category::is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Compose,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<B, C>, L, Card>, PS>>)
        [dedekind::relational::Law::Total] == Ternary::True

is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

template<typename B, typename A, typename L, typename Card, typename P>

bool dedekind::category::is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Converse,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, P>>)
        [dedekind::relational::Law::Total] == Ternary::True

is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >

template<typename I, typename T, typename L, typename PathT, typename C>

bool dedekind::category::is_left_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >

inlineconstexpr

Initial value:

=
    true

is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

template<typename A, typename B, typename L, typename Card, typename PR, typename PS>

bool dedekind::category::is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Meet,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PS>>)
        [dedekind::relational::Law::Injective] == Ternary::True

is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>

bool dedekind::category::is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Compose,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<B, C>, L, Card>, PS>>)
        [dedekind::relational::Law::Injective] == Ternary::True

is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

template<typename B, typename A, typename L, typename Card, typename P>

bool dedekind::category::is_left_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Converse,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, P>>)
        [dedekind::relational::Law::Injective] == Ternary::True

is_linear_action_v

template<typename M, typename S, typename AddM, typename AddS, typename MultS, typename Act>

bool dedekind::category::is_linear_action_v

inlineconstexprexport

Initial value:

=
    is_linear_action<M, S, AddM, AddS, MultS, Act>::value

Value form of is_linear_action.

is_meet_containing_v< Elem, Meet< A, B > >

template<typename Elem, typename A, typename B>

bool dedekind::category::is_meet_containing_v< Elem, Meet< A, B > >

inlineconstexprexport

Initial value:

=
    std::same_as<Elem, A> || std::same_as<Elem, B>

is_monic_arrow_v

template<typename E>

bool dedekind::category::is_monic_arrow_v = false

inlineconstexprexport

User-declared monicity witness for an arrow type.

Injectivity cannot be verified at compile time in general. Users specialize this to true to declare that a given arrow is injective (i.e., a monomorphism in the category of sets). The compiler trusts the declaration; no runtime proof is required.

This mirrors is_kleene_associative_v in the partial algebra layer.

is_monic_arrow_v< Compose< F, G > >

template<IsArrow F, IsArrow G>

bool dedekind::category::is_monic_arrow_v< Compose< F, G > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Compose, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Injective] == Ternary::True

is_monic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >

template<typename F, typename G, typename X, typename Y>

bool dedekind::category::is_monic_arrow_v< Copairing< Compose< F, Injection< 1, X, Y > >, Compose< G, Injection< 2, X, Y > > > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Sum, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Injective] == Ternary::True

is_monic_arrow_v< image_decidability_witness::ToyEmbed >

template<>

bool dedekind::category::is_monic_arrow_v< image_decidability_witness::ToyEmbed >

inlineconstexpr

Initial value:

=
    true

is_monic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >

template<typename A, typename F, typename B, typename G>

bool dedekind::category::is_monic_arrow_v< Pairing< Compose< A, F >, Compose< B, G > > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Product, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Injective] == Ternary::True

is_monic_arrow_v< Pairing< F, G > >

template<typename F, typename G>

bool dedekind::category::is_monic_arrow_v< Pairing< F, G > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Pairing, arrow_laws_v<F>,
               arrow_laws_v<G>)[ArrowLaw::Injective] == Ternary::True

is_monic_arrow_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)> >

inlineconstexpr

Initial value:

=
        true

is_monic_arrow_v< std::decay_t< decltype(dedekind::analysis::embed_ℝ_𝔻)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::analysis::embed_ℝ_𝔻)> >

inlineconstexpr

Initial value:

=
        true

is_monic_arrow_v< std::decay_t< decltype(dedekind::geometry::embed_z2_r2)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::geometry::embed_z2_r2)> >

inlineconstexpr

Initial value:

=
        true

is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℝ_ℂ)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℝ_ℂ)> >

inlineconstexpr

Initial value:

=
        true

is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)> >

inlineconstexpr

Initial value:

=
        true

ℤ ↪ ℚ is monic: \(n/1 = m/1 \iff n = m\).

is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)> >

inlineconstexpr

Initial value:

=
        true

is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝕃_ℚ<>)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(dedekind::numbers::embed_𝕃_ℚ<>)> >

inlineconstexpr

Initial value:

=
        true

The finite doubles embed injectively into ℚ: distinct finite doubles have distinct dyadic values (-0.0 and +0.0 are one element of 𝕃).

is_monic_arrow_v< std::decay_t< decltype(embed_𝔹_uint_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(embed_𝔹_uint_)> >

inlineconstexpr

Initial value:

=
    true

is_monic_arrow_v< std::decay_t< decltype(embed_𝕂3_ℤ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(embed_𝕂3_ℤ_)> >

inlineconstexpr

Initial value:

=
    true

is_monic_arrow_v< std::decay_t< decltype(embed_sint_ℤ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(embed_sint_ℤ_)> >

inlineconstexpr

Initial value:

=
    true

is_monic_arrow_v< std::decay_t< decltype(embed_uint_ℕ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(embed_uint_ℕ_)> >

inlineconstexpr

Initial value:

=
    true

is_monic_arrow_v< std::decay_t< decltype(lift_ℕ_ℤ_)> >

template<>

bool dedekind::category::is_monic_arrow_v< std::decay_t< decltype(lift_ℕ_ℤ_)> >

inlineconstexpr

Initial value:

=
    true

is_monotone_v

template<typename F, typename Op = std::less_equal<>>

bool dedekind::category::is_monotone_v

inlineconstexprexport

Initial value:

=
    monotone_trait<std::remove_cvref_t<F>, Op>::value

is_monotone_v< Compose< F, G >, Op >

template<typename F, typename G, typename Op>

bool dedekind::category::is_monotone_v< Compose< F, G >, Op >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Compose, arrow_laws_v<F, Op>,
               arrow_laws_v<G, Op>)[ArrowLaw::Monotone] == Ternary::True

is_monotone_v< ConstantMorphism< A, B >, Op >

template<typename A, typename B, typename Op>

bool dedekind::category::is_monotone_v< ConstantMorphism< A, B >, Op > = true

inlineconstexpr

total__Constant_Variance

A constant arrow is monotone and antitone under every reflexive order on its codomain, Op(x, y) giving Op(c, c), and neither under a strict one, c < c failing; so the registration asks the codomain's reflexivity (:mereology). The converse, that monotone and antitone make an arrow constant, holds on a connected domain, a chain, and is not applied (#981). zero() returns a constant arrow and has these facts with it.

is_monotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >

template<typename A, typename F, typename B, typename G, typename LeqA, typename LeqB>

bool dedekind::category::is_monotone_v< Pairing< Compose< A, F >, Compose< B, G > >, ProductLeq< LeqA, LeqB > >

inlineconstexpr

Initial value:

=
    arrow_node(ArrowNode::Product, arrow_laws_v<F, LeqA>,
               arrow_laws_v<G, LeqB>)[ArrowLaw::Monotone] == Ternary::True

is_monotone_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(dedekind::algebra::embed_𝔹_𝕂3_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
    true

is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_ℤ_ℚ_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
    true

ℤ ↪ ℚ preserves order — the monotonicity the strength-reduction pullback rests on.

is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(dedekind::numbers::embed_𝔹_ℕ_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
    true

is_monotone_v< std::decay_t< decltype(embed_𝔹_uint_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(embed_𝔹_uint_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_monotone_v< std::decay_t< decltype(embed_𝕂3_ℤ_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(embed_𝕂3_ℤ_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_monotone_v< std::decay_t< decltype(embed_sint_ℤ_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(embed_sint_ℤ_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_monotone_v< std::decay_t< decltype(embed_uint_ℕ_)>, std::less_equal<> >

template<>

bool dedekind::category::is_monotone_v< std::decay_t< decltype(embed_uint_ℕ_)>, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_monotone_v< Successor< N >, std::less_equal<> >

template<HasNNOStep N>

bool dedekind::category::is_monotone_v< Successor< N >, std::less_equal<> > = true

inlineconstexpr

The step arrows preserve the order of a registered chain, \(x \le y \Rightarrow S(x) \le S(y)\) and likewise for P: the irreducible leaf facts the variance inference starts from. Saturation at a bound is monotone; wrapping is not, and wrapping is the carrier's registered periodicity (is_periodic_v of its +: the unsigned words, ℤ/N), so the fact is read off the algebra, not off the type's name; the chain gate supplies the order.

Template Parameters

N	a chain with the NNO step whose + does not wrap.

is_monotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >

template<typename R, typename S, typename LeqR, typename LeqS>

bool dedekind::category::is_monotone_v< Tensor< R, S >, ProductLeq< LeqR, LeqS > >

inlineconstexpr

Initial value:

=
    true

is_quotient_functor_v

template<typename F>

bool dedekind::category::is_quotient_functor_v = false

inlineconstexprexport

Trait registry for the IsQuotientFunctor concept.

Engineer-asserted opt-in: a functor is a quotient (regular epi / coequalizer presentation — Borceux Handbook §4.3) iff the engineer specialises this trait to true at the functor's declaration site. Same shape as is_embedding_functor_v above.

Default false. Concrete witnesses populate when the (A, F) anchor work (#498) lands Σ-algebras as functors T_Σ → Ddk (algebras arise as quotients of free algebras — Burris-Sankappanavar §II.10) and when the carrier-lattice Frac / Cplx / Dual functors at the strict-quotient reading land (#602 layer-1.5+).

is_reflexive_v< A, Endo< A, L, C, ComposePred< PR, PS, A > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_reflexive_v< A, Endo< A, L, C, ComposePred< PR, PS, A > > >

inlineconstexpr

Initial value:

=
    is_reflexive_v<A, Endo<A, L, C, PR>> &&
    is_reflexive_v<A, Endo<A, L, C, PS>>

is_reflexive_v< A, Endo< A, L, C, PairwisePred< Op > > >

template<typename A, typename L, typename C, typename Op>

bool dedekind::category::is_reflexive_v< A, Endo< A, L, C, PairwisePred< Op > > >

inlineconstexpr

Initial value:

=
    is_reflexive_v<A, Op>

is_reflexive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_reflexive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_reflexive_v<A, Endo<A, L, C, PR>> &&
    is_reflexive_v<A, Endo<A, L, C, PS>>

is_reflexive_v< A, Endo< A, L, C, RelOr< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_reflexive_v< A, Endo< A, L, C, RelOr< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_reflexive_v<A, Endo<A, L, C, PR>> ||
    is_reflexive_v<A, Endo<A, L, C, PS>>

is_reflexive_v< A, Endo< A, L, C, SwapPred< P > > >

template<typename A, typename L, typename C, typename P>

bool dedekind::category::is_reflexive_v< A, Endo< A, L, C, SwapPred< P > > >

inlineconstexpr

Initial value:

=
    is_reflexive_v<A, Endo<A, L, C, P>>

is_reflexive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

template<std::floating_point F>

bool dedekind::category::is_reflexive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_reflexive_v< dedekind::numbers::Cut< Q >, std::less_equal<> >

template<typename Q>

bool dedekind::category::is_reflexive_v< dedekind::numbers::Cut< Q >, std::less_equal<> > = true

inlineconstexpr

cut__Order_Fabric

Cut<Q>'s <=> is a genuine total order (exact on the leaf shapes), so the poset traits are earned, not postulated. Registered parametrically over Q — the same shape Rational uses — so no witness is cloned per instantiation.

is_reflexive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

template<long D, typename Q>

bool dedekind::category::is_reflexive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

quadratic__Order_Fabric

The order is a genuine total order (decided by comparing squares), so the poset traits are earned; registered parametrically over (D,Q).

is_reflexive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

template<typename T>

bool dedekind::category::is_reflexive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

inlineconstexpr

Initial value:

=
    true

is_reflexive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

template<typename W>

bool dedekind::category::is_reflexive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_reflexive_v< Percentage, std::less_equal< Percentage > >

template<>

bool dedekind::category::is_reflexive_v< Percentage, std::less_equal< Percentage > >

inlineconstexpr

Initial value:

=
    true

is_reflexive_v< Percentage, std::less_equal<> >

template<>

bool dedekind::category::is_reflexive_v< Percentage, std::less_equal<> > = true

inlineconstexpr

Register the Kleene carrier Ternary in the :total / :posetal machinery so the lattice-ladder and order concepts resolve on it, the same way bool and int are registered.

FIXME: Extension Point for Option-Logic. In a future sprint (post-ETCS), consider specializing lift_logic for std::optional<bool>. This would bridge the C++ 'missing value' semantics with the Kleene 'Unknown' state, providing a functorial mapping from the Standard Library to the Ternary Topos.

logic__Formal_Verification

(#912)

Ternary is the finite 3-chain False < Unknown < True, with join ∨ = Sup and meet ∧ = Inf (the value-returning chain lattice ops from :species; not the std::ranges::max / min niebloids, which return const T& and so cannot satisfy IsClosedUnder's same_as<T> — see Sup / Inf and FIXME(#934)). Their lattice-law traits (is_idempotent_v / is_associative_v / is_commutative_v / is_distributive_v / is_absorptive_v) are registered generically over every carrier in :mereology (the Sup / Inf law blanket), so IsDistributiveLattice<Ternary, Sup, Inf> follows once the two pieces below are supplied:

1. the bounds (unit_v): ⊥ = False (∨-identity) and ⊤ = True (∧-identity), lifting the finite chain from IsDistributiveLattice up to IsBoundedLattice / IsPointed (Chain<int> cannot reach this rung: ℤ is unbounded);
2. the order traits (reflexive / transitive / antisymmetric under <=), which the :species blanket registers only for std::integral carriers — Ternary is a scoped enum, so it needs the explicit void-form std::less_equal<> registration mirrored here.

The carrier-level variety witnesses (IsDistributiveLattice / IsBoundedLattice) live in :total, which imports :logic transitively (via :posetal), so they cannot be asserted from this upstream partition; they are pinned in logic_lattice_structure_test.cpp and order_test.cpp alongside the Boole / Chain<int> siblings.

K₃'s total order under <=. Ternary is the 3-chain False < Unknown < True; a scoped enum, so no blanket over types covers it (an arbitrary enum's <=> may fail the laws; #946 review). Nothing registered here:

K₃'s total order under the typed relation std::less_equal<T>. The order:: concepts (IsPreOrdered / IsTotallyOrdered) query the transparent std::less_equal<> registered above, but the category:: order concepts (IsPartRelation / IsPosetal / IsTotalOrder / IsThinCategory) default Rel to the typed std::less_equal<Ternary> and query the traits for that exact type, so the transparent form does not reach them. Each law is decided by its law, for every relation on K₃ (:mereology), nothing registered for THIS carrier, and never by std::totally_ordered (#1043). It is also the order the :mereology SupInfLattice gate certifies against (a genuine total order cannot contain NaN).

Percentage's total order under <=: the 101-chain 0 < 1 < … < 100, with a defaulted <=> on one uint8_t, so the laws hold by construction. Registered in both the transparent and the typed spelling, as for Ternary, so Percent is a chain species for IsLSet and Percentage a posetal carrier.

is_reflexive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

template<typename A, typename B, typename LeqA, typename LeqB>

bool dedekind::category::is_reflexive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

inlineconstexpr

Initial value:

=
    IsReflexive<A, LeqA> && IsReflexive<B, LeqB>

is_reflexive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

template<typename X, typename Y>

bool dedekind::category::is_reflexive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

inlineconstexpr

Initial value:

=
        IsReflexive<X, std::less_equal<X>> &&
        IsReflexive<Y, std::less_equal<Y>>

is_reflexive_v< std::variant< X, Y >, std::less_equal<> >

template<typename X, typename Y>

bool dedekind::category::is_reflexive_v< std::variant< X, Y >, std::less_equal<> >

inlineconstexpr

Initial value:

=
    IsReflexive<X, std::less_equal<>> && IsReflexive<Y, std::less_equal<>>

is_reflexive_v< T, std::less_equal<> >

template<std::integral T>

bool dedekind::category::is_reflexive_v< T, std::less_equal<> > = true

inlineconstexpr

Proof: <= on the integral types is a total order (reflexive, transitive, antisymmetric, connex), under the transparent spelling as under the typed one above.

Note

Floating-point types are excluded: NaN breaks reflexivity and connexity. The NaN-free carrier is safe_float (:morphologies).

is_reflexive_v< typename dedekind::morphologies::Modular< N >::machine_type, dedekind::morphologies::ModularCongruence< N > >

template<auto N>

bool dedekind::category::is_reflexive_v< typename dedekind::morphologies::Modular< N >::machine_type, dedekind::morphologies::ModularCongruence< N > > = true

inlineconstexpr

cyclic__Modular_Is_A_Congruence_Quotient

Modular<N> = V/({\equiv}\bmod N) for N a power of two: on the machine carrier V = unsigned = ℤ/2^w, the mod-N relation ModularCongruence<N> is a genuine IsCongruence for the native + and × iff N | 2^w (Copilot #803). For such N the H-leg's relational reading fires (IsCongruenceQuotient, :algebra::quotient); for N ∤ 2^w it is honestly withheld — those moduli quotient abstract ℤ, not the machine carrier, and there is no total-ℤ machine carrier to host them (every one wraps or saturates). Modular<N> certifies its own (total, wraparound) species traits directly above — it does not propagate them from the non-total integer carrier V — so this is the congruence witness only, deliberately decoupled from quotient_algebra_base. The non-trivial companion to the int/(=) diagonal witness in :algebra::quotient.

is_regular_category_v

template<typename C>

bool dedekind::category::is_regular_category_v = false

inlineconstexprexport

User-declared witness: C is a regular category — has finite limits, kernel pairs and coequalizers of kernel pairs, and regular epis are stable under pullback.

In any regular category, the (regular epi, mono) pair is a factorisation system (Wikipedia, regular category). The full property's $\forall$-quantifiers are the engineer's honesty obligation; this trait is the opt-in witness. Form-chain row 7 (#718).

is_regular_epi_v

template<typename E>

bool dedekind::category::is_regular_epi_v = false

inlineconstexprexport

User-declared witness: E is a regular epi (the coequalizer of some parallel pair).

Cannot be checked at compile time in general — the existence of a parallel pair (f, g) such that E is coeq(f, g) is the engineer's honesty obligation, opted-in at the carrier registration site. In Sets and any topos, every epi is regular; in a general category, regular epis are a strict subclass of epis.

is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

template<typename A, typename B, typename L, typename Card, typename PR, typename PS>

bool dedekind::category::is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Meet,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PS>>)
        [dedekind::relational::Law::Surjective] == Ternary::True

is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>

bool dedekind::category::is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Compose,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<B, C>, L, Card>, PS>>)
        [dedekind::relational::Law::Surjective] == Ternary::True

is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

template<typename B, typename A, typename L, typename Card, typename P>

bool dedekind::category::is_right_total_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Converse,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, P>>)
        [dedekind::relational::Law::Surjective] == Ternary::True

is_right_unique_v

template<typename R>

bool dedekind::category::is_right_unique_v = false

inlineconstexprexport

User-declared right-uniqueness witness for a binary relation.

Right-uniqueness: each a ∈ A is related to at most one b ∈ B. Same opt-in pattern; combined with is_left_total_v<R>, this characterises a function as a special case of relation.

is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, dedekind::order::ProductRestrict< P, RP > > >

template<typename A, typename B, typename L, typename P, typename RP, typename C>

bool dedekind::category::is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, C >, dedekind::order::ProductRestrict< P, RP > > >

inlineconstexpr

Initial value:

=
    is_right_unique_v<dedekind::sets::Comprehension<
        dedekind::sets::𝔸<std::pair<A, B>, L, C>, P>>

is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

template<typename A, typename B, typename L, typename Card, typename PR, typename PS>

bool dedekind::category::is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, B >, L, Card >, dedekind::sets::RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Meet,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PS>>)
        [dedekind::relational::Law::Univalent] == Ternary::True

is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

template<typename A, typename C, typename L, typename PR, typename PS, typename B, typename Card>

bool dedekind::category::is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< A, C >, L, Card >, dedekind::relational::ComposePred< PR, PS, B > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Compose,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, PR>>,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<B, C>, L, Card>, PS>>)
        [dedekind::relational::Law::Univalent] == Ternary::True

is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

template<typename B, typename A, typename L, typename Card, typename P>

bool dedekind::category::is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< B, A >, L, Card >, dedekind::relational::SwapPred< P > > >

inlineconstexpr

Initial value:

=
    dedekind::relational::node_laws(
        dedekind::relational::Node::Converse,
        dedekind::relational::laws_of_v<dedekind::sets::Comprehension<
            dedekind::sets::𝔸<std::pair<A, B>, L, Card>, P>>)
        [dedekind::relational::Law::Univalent] == Ternary::True

is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >

template<typename I, typename T, typename L, typename PathT, typename C>

bool dedekind::category::is_right_unique_v< dedekind::sets::Comprehension< dedekind::sets::𝔸< std::pair< I, T >, L, C >, dedekind::sequences::SequenceGraph< PathT > > >

inlineconstexpr

Initial value:

=
    true

is_symmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >

template<typename A, typename L, typename C, typename Op>

bool dedekind::category::is_symmetric_v< A, Endo< A, L, C, PairwisePred< Op > > >

inlineconstexpr

Initial value:

=
    is_symmetric_v<A, Op>

is_symmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_symmetric_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_symmetric_v<A, Endo<A, L, C, PR>> &&
    is_symmetric_v<A, Endo<A, L, C, PS>>

is_symmetric_v< A, Endo< A, L, C, RelOr< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_symmetric_v< A, Endo< A, L, C, RelOr< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_symmetric_v<A, Endo<A, L, C, PR>> &&
    is_symmetric_v<A, Endo<A, L, C, PS>>

is_symmetric_v< A, Endo< A, L, C, SwapPred< P > > >

template<typename A, typename L, typename C, typename P>

bool dedekind::category::is_symmetric_v< A, Endo< A, L, C, SwapPred< P > > >

inlineconstexpr

Initial value:

=
    is_symmetric_v<A, Endo<A, L, C, P>>

is_symmetric_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

template<typename T>

bool dedekind::category::is_symmetric_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

inlineconstexpr

Initial value:

=
    true

is_total_by_construction_v

template<typename T, typename Op>

bool dedekind::category::is_total_by_construction_v

inlineconstexprexport

Initial value:

=
    is_total_by_construction<T, Op>::value

Value form of is_total_by_construction.

Template Parameters

T	the carrier.
Op	the operation on T.

is_total_v

template<typename T, typename Op>

bool dedekind::category::is_total_v = is_total<T, Op>::value

inlineconstexprexport

Value form of is_total.

Template Parameters

T	the carrier.
Op	the operation on T.

is_transitive_v< A, Endo< A, L, C, PairwisePred< Op > > >

template<typename A, typename L, typename C, typename Op>

bool dedekind::category::is_transitive_v< A, Endo< A, L, C, PairwisePred< Op > > >

inlineconstexpr

Initial value:

=
    is_transitive_v<A, Op>

is_transitive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

template<typename A, typename L, typename C, typename PR, typename PS>

bool dedekind::category::is_transitive_v< A, Endo< A, L, C, RelAnd< PR, PS > > >

inlineconstexpr

Initial value:

=
    is_transitive_v<A, Endo<A, L, C, PR>> &&
    is_transitive_v<A, Endo<A, L, C, PS>>

is_transitive_v< A, Endo< A, L, C, SwapPred< P > > >

template<typename A, typename L, typename C, typename P>

bool dedekind::category::is_transitive_v< A, Endo< A, L, C, SwapPred< P > > >

inlineconstexpr

Initial value:

=
    is_transitive_v<A, Endo<A, L, C, P>>

is_transitive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

template<std::floating_point F>

bool dedekind::category::is_transitive_v< dedekind::morphologies::safe_float< F >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_transitive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

template<long D, typename Q>

bool dedekind::category::is_transitive_v< dedekind::numbers::QuadraticReal< D, Q >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_transitive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

template<typename T>

bool dedekind::category::is_transitive_v< dedekind::sequences::Path< T >, dedekind::sequences::TailEquivalent< T > >

inlineconstexpr

Initial value:

=
    true

is_transitive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

template<typename W>

bool dedekind::category::is_transitive_v< dedekind::sets::ExtensionalCardinal< W >, std::less_equal<> >

inlineconstexpr

Initial value:

=
        true

is_transitive_v< Percentage, std::less_equal< Percentage > >

template<>

bool dedekind::category::is_transitive_v< Percentage, std::less_equal< Percentage > >

inlineconstexpr

Initial value:

=
    true

is_transitive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

template<typename A, typename B, typename LeqA, typename LeqB>

bool dedekind::category::is_transitive_v< std::pair< A, B >, ProductLeq< LeqA, LeqB > >

inlineconstexpr

Initial value:

=
    IsTransitive<A, LeqA> && IsTransitive<B, LeqB>

is_transitive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

template<typename X, typename Y>

bool dedekind::category::is_transitive_v< std::variant< X, Y >, std::less_equal< std::variant< X, Y > > >

inlineconstexpr

Initial value:

=
        IsTransitive<X, std::less_equal<X>> &&
        IsTransitive<Y, std::less_equal<Y>>

is_transitive_v< std::variant< X, Y >, std::less_equal<> >

template<typename X, typename Y>

bool dedekind::category::is_transitive_v< std::variant< X, Y >, std::less_equal<> >

inlineconstexpr

Initial value:

=
    IsTransitive<X, std::less_equal<>> && IsTransitive<Y, std::less_equal<>>

lifts_to_v

template<typename From, typename To>

bool dedekind::category::lifts_to_v

inlineconstexprexport

Initial value:

= requires {
  species_embed<From, To>::apply(std::declval<typename From::Ω>());
}

The dominance order: From ⊑ To iff the embedding species_embed<From, To> is registered. Reflexive and, over the shipped species, transitive (𝔹 ⊑ K₃ ⊑ Percent; 𝔹 ⊑ Chain<T>).

logic_negation_is_involutive_v

template<typename L>

bool dedekind::category::logic_negation_is_involutive_v

inlineconstexprexport

Initial value:

=
    IsInvolution<logic_complement<L>, typename L::Ω>

true iff the logic negation ¬ = L::RFL is a certified involution. Both shipped De Morgan logics (𝔹, K₃) qualify; a future intuitionistic species whose ¬¬ is only a closure would not. Downstream double-negation elimination gates on this so it stays honest per logic.

partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

template<std::floating_point F>

dedekind::ieee::IEEE<F> dedekind::category::partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > >

inlineconstexpr

Initial value:

=
        dedekind::ieee::IEEE<F>{F{0}}

partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

template<std::floating_point F>

dedekind::ieee::IEEE<F> dedekind::category::partial_unit_v< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > >

inlineconstexpr

Initial value:

=
        dedekind::ieee::IEEE<F>{F{1}}

partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >

template<typename R>

dedekind::numbers::Complex<R> dedekind::category::partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialAddComplex< R > >

inlineconstexpr

Initial value:

=
    dedekind::numbers::Complex<R>{R{}, R{}}

partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >

template<typename R>

dedekind::numbers::Complex<R> dedekind::category::partial_unit_v< dedekind::numbers::Complex< R >, dedekind::numbers::PartialMulComplex< R > >

inlineconstexpr

Initial value:

=
    dedekind::numbers::Complex<R>{R{1}, R{}}

partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

template<dedekind::morphologies::IsInteger I>

dedekind::numbers::Rational<I> dedekind::category::partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialAddRational< I > >

inlineconstexpr

Initial value:

=
    dedekind::numbers::Rational<I>(I{0}, I{1})

partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

template<dedekind::morphologies::IsInteger I>

dedekind::numbers::Rational<I> dedekind::category::partial_unit_v< dedekind::numbers::Rational< I >, dedekind::numbers::PartialMulRational< I > >

inlineconstexpr

Initial value:

=
    dedekind::numbers::Rational<I>(I{1}, I{1})

partial_unit_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > >

template<std::unsigned_integral T>

T dedekind::category::partial_unit_v< T, BoundedAddTransform< T, FullMachineBoundaryPolicy< T > > >

inlineconstexpr

Initial value:

=
        T(0)

partial_unit_v< T, BoundedMulTransform< T, FullMachineBoundaryPolicy< T > > >

template<std::unsigned_integral T>

T dedekind::category::partial_unit_v< T, BoundedMulTransform< T, FullMachineBoundaryPolicy< T > > >

inlineconstexpr

Initial value:

=
        T(1)