|
Dedekind 0.0.0
A structuralist C++23 Module Library
|
| Ndedekind | |
| Nalgebra | |
| Ndetail_polynomial | |
| CByMonomial | The support's order: by monomial |
| Ndetail_canonical | |
| CAtomAt | The dispatch of an atom's normal form to its sort: a comparison of two constants decided in it, any other atom in the polynomials over a carrier of the points where + and · are total on it, and on a carrier without them (𝔹, K₃) kept as written: equal forms still cut out equal sets, and different ones decide nothing |
| N_has_carrier_witness | |
| Calgebra_view | Thin algebra-view wrapper used as the pilot for the HasCarrier concept (#573) on a primitive carrier |
| Ndetail_universal | |
| Chomomorphism_of | Arrow is an arrow between two algebras, IsAlgebra of S on its domain and of T on its codomain, that carries each operation of S to the one in the same place of T, a monoid homomorphism for each: false unless both are signatures of one nonzero length. A struct, so its partial specialisation fires across module boundaries |
| Cpreserves | Arrow carries Op to Op2, of any arity, by the declared certificate, and the unit to the unit where Op has one, computed: a unary or non-unital operation asks the law alone |
| Chomomorphism_of< Arrow, Signature< Ss... >, Signature< Ts... > > | |
| Cdefault_signatures | The signatures a homomorphism defaults to: the semiring each end of an arrow registers, and the empty signature, which claims nothing, for a type that is no arrow |
| Cdefault_signatures< Arrow > | |
| Cis_galois_field | Opt-in trait: is this carrier (under the given operator witnesses) a Galois field, i.e. a field of finite cardinality? |
| Cis_galois_field< T, Add, Mult > | |
| Cgalois_order | The order \(q\) of a Galois field: the cardinality \(|T|\) (always a prime power \(p^n\)). Zero signals "not a Galois field" (the default). Struct-backed for the same reason as is_galois_field above |
| Cgalois_order< T, Add, Mult > | |
| C𝔽64 | The Galois field of order 64, \(\mathrm{GF}(2^6) = \mathbb{F}_2[x] / (x^6 + x + 1)\) |
| Cis_galois_field< bool, std::bit_xor< bool >, std::bit_and< bool > > | |
| Cgalois_order< bool, std::bit_xor< bool >, std::bit_and< bool > > | |
| CInverse | The group inverse under Op, reified as an arrow (an endomorphism G → G) |
| COneDimensionalVector | Reified carrier for a 1D module/vector-space coordinate |
| CBoolLineJoin | Additive join on 1D Boolean vectors (OR) |
| CBoolLineMeetAction | Scalar action on 1D Boolean vectors via meet (AND) |
| Cis_translation_invariant_ordered | Marker trait: T is a non-cyclic ordered additive group whose order is translation-invariant, with the saturating escape contract for values that would exceed representable capacity |
| Cis_translation_invariant_ordered< dedekind::sets::SignedCardinality > | sets::SignedCardinality is the project's bona-fide saturating proxy for \(\mathbb{Z}\): arithmetic escalates to \(\pm \aleph_0\) on overflow and propagates NaZ on indeterminate forms, rather than wrapping modulo capacity (cf. cardinality.cppm:923-967). This is the structural guarantee the marker certifies: translation preserves the partial order \(\le\) on the finite fragment; saturation collapses ordering past the boundary into the \(\pm \aleph_0\) sentinel (the meet still holds: both sides land at the same sentinel). The finite-fragment carrier SignedExtensionalCardinal is intentionally not opted in: it is cyclic (mod \(2^w\)), so its addition would reverse the order at the wrap boundary. The variant SignedCardinality is what callers should use whenever they want translation-invariance at the type level (i.e. the halfspace pipe) |
| Cis_scaling_invariant_ordered | The MULTIPLICATIVE order-compatibility axiom marker (O2): the positive cone is closed under *, i.e. 0≤a ∧ 0≤b ⟹ 0≤a·b — equivalently, scaling by a positive preserves the order. The multiplicative sibling of is_translation_invariant_ordered (O1, scaling ↔ translation) |
| CMonomial | A monomial in N variables: its exponents, one per slot (π is the slot 0; π_1, π_2, π_3 the slots 1, 2, 3). The free commutative monoid on N generators, written multiplicatively (the exponents add, as natural numbers: leaving the word raises), and a chain under the graded lexicographic order: by total degree, then by exponents |
| CPolynomial | The monoid algebra R[M]: a finitely supported function from the monomials to the coefficients, stored as its support sorted along the monomials' chain, no coefficient zero. A net (Domain the monomials, Codomain the coefficients, p(m) the coefficient of m), a commutative rig over a commutative rig, a ring over a ring (- where R has additive inverses) |
| CPoly | The polynomial reading of a term on the carrier C, an algebra for cata: a projection is its variable, a constant a coefficient, + - * the polynomial's where the carrier admits them, a division by a nonzero constant on a field the multiplication by its inverse. Any other node (//, %, a division by a term, an applied arrow, a conditional) has no free algebra catalogued here and is refused. Expanding into polynomials uses commutativity of * and its distributivity over +, so the carrier must be a certified commutative rig |
| CTropical | Tropical carrier T ∪ {∞}. finite==false is the ⊕-identity sentinel (−∞ for Max, +∞ for Min), absorbing under ⊗. operator+ is ⊗ (honest addition); ⊕ is TropicalPlus |
| CTropicalPlus | ⊕: the tropical addition, the order-extremum (a semilattice join for Max, meet for Min). Named, not an operator, so a+b never silently means max |
| Csemiring_ops< Tropical< T, M > > | The tropical semiring's operations, (⊕ = TropicalPlus, ⊗ = +): its own, not the ring's, registered on :universal's semiring_ops |
| Csemiring_ops | Canonical semiring operations of a carrier, so combinators can default their Add / Mult without a call site spelling them. The default (this primary) is the ordinary ring (+, ×), which is correct for any carrier whose native operators are its semiring ops; carriers whose ops differ specialize (the burden of proof sits at the implementation site): Tropical → (⊕ = TropicalPlus, ⊗ = +), bool → (∨, ∧) — bool must NOT take the default (bool
|
| Csemiring_ops< bool > | The Boolean semiring's operations, (∨, ∧) |
| CSignature | A signature, the \(F\) of an \((A, F)\) algebra named as one type: the Ops... of IsAlgebra, IsAlgebraOnSet and HasCarrier, which a concept can then take as a parameter and default |
| CBit2U64Action | Scalar action \(\mathbb{F}_2 \times \mathbb{F}_2^{64} \to
\mathbb{F}_2^{64}\) on (bool, uint64_t) |
| Csemiring_ops< dedekind::linear_algebra::MatNxNV< S, N > > | Mat(S) is a semiring: register its ⊕ / ⊗ so downstream (e.g. :transfer's star = the *-closure) reads them generically off semiring_ops, exactly as for the base S |
| Cis_translation_invariant_ordered< dedekind::numbers::QuadraticReal< D, Q > > | Carrier-promise: QuadraticReal<D,Q> is an ORDERED FIELD. The template gate (D>1) ∧ IsRational<Q> makes this unconditional — every instantiation is a REAL quadratic field ℚ(√D) with D>1 (no imaginary ℚ(√−n) case exists), hence formally real (−1 not a sum of squares), with a genuine total order (strong_ordering <=>, by comparing squares). So both order-compatibility axiom markers hold: O1 (translation) and O2 (scaling), closing IsOrderedMultiplicativeGroup<QuadraticReal<D,Q>> — which in turn certifies Complex<QuadraticReal<D,Q>> as a field (#818) |
| Cis_scaling_invariant_ordered< dedekind::numbers::QuadraticReal< D, Q > > | |
| Cis_translation_invariant_ordered< dedekind::numbers::Rational< I > > | |
| Cis_scaling_invariant_ordered< dedekind::numbers::Rational< I > > | |
| Ncategory | |
| Ndetail_quotient | |
| CIntByEquality | |
| Ndetail_automaton | |
| CColumnAt | One byte's entry: its rank plus one, or zero |
| CResidual | A state: whether a word of the set has just been read, and the pending words by length, pending[k - 1] those of length k |
| CDeriveSites | The set's own derivatives, one per letter: the same for every state, so computed once, before the walk |
| CAdvance | One pending length of a state's derivative by a letter: the pending words one longer, derived, and the set's own derivative where they are its length, joined; a word of length zero is a match |
| CBuild | The construction so far: the states found, in the order found, and the plan's rows for those already walked |
| CLetter | One letter out of the state being walked: its derivative's number, a new state numbered next where it is new |
| CWalk | One state walked, in the order found: its row of transitions, and whether it accepts. Past the states found, nothing to walk |
| CDecode | A code read back as its word: the digits in base Sigma, the first letter the most significant, each the letter of that rank |
| CDigits | |
| CDigit | |
| CReadBack | A code tested by a section: read back as its word, then the section's own membership |
| CMirrorDigit | One more digit of a half-site read backwards, reflected: the next letter of the other half, \(\sigma - 1 - d\) on the ranks |
| CAddPalindrome | One more half-site, its word's code a run of one where it lies in the codes kept. Halves ascending give codes ascending, the half being the word's most significant digits |
| CWithLetters | A plan with the columns of its alphabet's bytes |
| CSetLetter | One more letter of a power, into the set of them |
| CAddByte | One more letter of a prefix |
| CNextByte | One more byte of a word: its rank, the next digit |
| CCursor | Where a run of the matcher is: its state and the next position |
| CMatchStep | One position of the run: the state after its letter, and the position itself where that state accepts. O(1) state, the text read where it is |
| CEndsInSite | The kernel the table factors: whether a prefix ends in a word of the set, reading its last six letters and nothing kept |
| CAgreesOnPrefix | Whether the table and the windows agree on one more prefix |
| CEndsInSubset | The kernel the random words' table factors |
| CRandomLaws | What the seeds say: whether the laws hold on their words, and how many sites of the subset those held, so a vacuous run can be refused |
| CLawsOnSeed | |
| Ndetail_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) |
| CAt | The visitor that applies the active arrow to x |
| Ndetail_arrows_witness | |
| CInc | |
| Ndetail_chain_arrows | |
| CIsZero | |
| Ndetail_chain | |
| CSliceStep | The step of a chain restricted by value to [lo, hi): f of the element and its cover, while the element is below hi |
| Ndetail_comprehension | |
| CStepFrom | A fold step with its accumulator bound, \(a \mapsto \mathit{op}(\mathit{acc}, a)\): the present case of the eliminator |
| CTally | One more element into a count |
| CExtended | A Kleisli arrow into Maybe extended to the elements of a query, \(\kappa(-, f) : \mathit{Maybe}\,A \to \mathit{Maybe}\,B\) |
| CSubrangeAt | |
| CKernelAt | The kernel at one more prefix |
| CLengthOf | A kernel for the laws: a prefix's length |
| CKeepsWhatItClassifies | |
| CJoinWithStage | |
| CCountingStage | |
| CCounted | The count of a query, as Maybe's action: a query that may not be, counted where it is |
| Cascends_by_position | The trait behind AscendsByPosition: an arrow over the positions whose present elements rise with the position, so that a query read through it is sorted by construction. A struct, so that a family registers by one partial specialisation |
| Cascends_by_position< Where< P > > | where keeps the positions it keeps: a filtered chain is a chain in the same order |
| COne | An element's share of a take: one if present, none for a hole, read through Maybe's eliminator |
| CTaken | The coalgebra of take<K>: the walk, until K elements are present. One more state, the count so far; O(1), no storage |
| Celement_of | The value a query's element carries: the Maybe's, or the element itself in a plain sequence |
| Celement_of< Maybe< T > > | |
| CRead | The coalgebra reading a bounded list position by position, each element present: a value on the stack walked as any query, so every stage composes after it |
| CPending | order_by without a law to read, pending its take: it needs the whole query, so only the fused order_by >> take<K> is offered, never the sort alone (it would need the caller's buffer) |
| CBefore | Whether a ranks before b |
| CKeepBest | One more element into the best K so far, sorted by the rank: inserted after those it does not rank before, so ties keep the walk's order, and the last cut where the list overflows. O(K) on the stack |
| CProgression | The progression \(j \mapsto m j + r\), a residue class's members in order: a congruence filter on a chain read as a chain of its own |
| Cbound_of | The most elements a walk presents: a take's K, or a bounded list's, kept by each SELECT and WHERE after it (a map presents no more than it reads). No member where nothing bounds the walk |
| Cbound_of< Taken< S, Coalg, K > > | |
| Cbound_of< Read< T, K > > | |
| Cbound_of< Mapped< S, Coalg, F > > | |
| Ndetail_equality | |
| CSameInt | A carrier's own equality, certified once: the laws follow |
| Ndetail_etcs_total_witness | |
| CNonRegular | |
| CSetOverNonRegular | |
| CMember | |
| Ndetail_f_algebra | |
| Ccomponent_orders | The component orders of a product order, where Op is one |
| Ccomponent_orders< ProductLeq< LA, LB > > | |
| N_factorisation_upgrade_witnesses | |
| Cexact_category_witness | Category-shape-tagged toy carrier for upgrade-chain witnesses |
| Nimage_decidability_witness | |
| CToyRetract | |
| CToyEmbed | |
| CToyGeneral | |
| Ndetail_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 |
| CReversed | Op with its arguments exchanged, \(a \cdot^{op} b = b \cdot
a\) |
| Copposite | |
| Copposite< Reversed< Op > > | |
| Ndetail_kleisli | |
| CStepAt | The step at one element, a Kleisli arrow \(A \to T(A)\) |
| CExtending | A fold step on \(T(A)\): the step at the element, by κ |
| CHalved | A witness's step that may fail: half of an even count |
| N_kleisli_arrow_witness_380 | |
| Ctoy_partial_realize | |
| Ndetail_lattice_nodes | |
| Cdomain_of | The domain of a term, read off its first leaf |
| Cdomain_of< Meet< A, B > > | |
| Cdomain_of< Join< A, B > > | |
| Cdomain_of< Not< A > > | |
| Csame_domain | Two operands on one domain: a lazy trait, read only once both operands qualify, so an operand with no domain is never asked for one |
| CBuildsNodes | The opt-in as a leaf property, for over_nodes |
| Ndetail_limit | |
| CProjectionAt | |
| Cprojection_arrow | |
| Cprojection_arrow< 0, P > | |
| Ndetail | |
| CTerminalEnvelope | |
| CInitialEnvelope | |
| CDrillDown | The opt-in operator-> drill-down policy: the projector the projected-object concepts take, by name rather than as a lambda |
| Cmerc_filtered | |
| Cmerc_shell | |
| Ctopo_demo_arrow | |
| Ctopo_demo_bool_arrow | |
| Ctopo_demo_sieve | |
| Ctopo_bad_sieve_codomain_mismatch | |
| Ctopo_demo_topology | |
| Ctopo_projection_arrow | |
| Ctopo_bundle_witness | |
| Ndetail_mereology | |
| CDial | A discrete bounded chain of N values that is no enum: a class with a cover step and two bounds, nothing registered about its relations |
| Noperations | 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 |
| Ccompose | |
| Ndetail_morphism | |
| Cimage_of | The carrier a map on T lands in: an arrow's declared codomain, a bare callable's result |
| Cimage_of< F, T > | |
| Ndetail_periodic | |
| CDouble | One step of fast doubling, \((F(j), F(j+1))\) modulo m to \((F(2j), F(2j+1))\) or \((F(2j+1), F(2j+2))\) by bit i of k: \(F(2j) = F(j)(2F(j+1) - F(j))\), \(F(2j+1) = F(j)^2 + F(j+1)^2\) |
| CPisano | One step of the search for the Pisano period: the pair \((F(j), F(j+1))\) modulo m, and the least j at which it is \((0, 1)\) again, once found |
| CIverson | The Iverson bracket, bool to the counts, a semiring map |
| CCheckedPlus | The checked sum of two exact counts: none if either is none or their sum leaves the word |
| CCountStep | The window's step: how many are true |
| CAnyStep | The window's step: whether any is true |
| CWindowStep | One step of a window at k: the step applied to f(k + j) |
| Cbox_node | An entry of an outer product: the legs' predicates in parallel, then their meet, Tensor followed by Merge |
| Cbox_node< Compose< Tensor< A, B >, Both > > | |
| Cbox_legs | How many legs an entry has |
| Cbox_legs< Compose< Tensor< A, B >, Both > > | |
| CResidue | One residue's count on a leg, appended to its histogram |
| CCyclicTerm | One term of a cyclic convolution: the residues i and j of two histograms add to their sum modulo m |
| CCyclicRow | One row of a cyclic convolution: residue i of the first histogram against every residue of the second |
| CConvolve | The cyclic convolution of the histogram so far with one more leg's, in the counts' semiring, the ring of polynomials modulo \(x^m - 1\) |
| Cfactor_word | The count word of a factor |
| Cfactor_word< Factor< N > > | |
| CWith | One more value into a bounded list, as a fold's step |
| CSetByte | One letter into a packed set of bytes |
| CByteOf | A letter as the byte it is: ordered as bytes, not as char, which may be signed. (#1141) |
| CMapByte | One letter and its image into a table on the bytes |
| CToByte | A character as a byte |
| CKeepInSlice | One more byte, kept where the slice and the predicate both do |
| CFixByte | One byte into the identity table |
| CReflectedAt | One byte's image under the reflection: the letter at the reflected rank, the byte itself off the alphabet. (#1141: the chain's enumeration, once alphabets range over other carriers.) |
| CIsLetterAt | Whether a position of the bytes is a letter |
| CByteAt | A position of the bytes as its byte |
| CReversalAgrees | The reversal on indices agrees with position at i |
| CAgreesWithReverse | |
| CReturnsTwice | Whether an arrow on the bytes, taken twice, returns one more byte |
| CFallsAlong | One more letter of the alphabet against the one before it: the map's images must not rise along the chain of the letters |
| CDualIsTheMask | |
| CRotateByLetter | A family of rotations that depends on the letter: each component commutes with every map on the letters, yet a map that changes the letter meets different rotations at the two ends of the square, so it is no natural transformation, and is refused |
| CFixedByStage | fixed_by(g) before it meets the powers it applies to |
| CFixedByReflectedReverse | fixed_by(~rev) before it meets the powers it applies to |
| CCheckedFactor | One factor into the product, checked |
| CIsEmptyFactor | Whether a factor is empty, \(0^e\) with \(e > 0\) |
| CCheckedLength | One length's count into the sum, checked |
| CTimesPower | One factor into the product: \(b^e\) is e copies of b under *, which concat on copies computes by squaring, Listing 4's overload at the monoid \((\mathbb{N}/2^w, \times)\); the factors are then the plain fold, one multiplication each |
| CPlusLogPower | One factor into the width: its power's image under CeilLog2, \(e \lceil \log_2 b \rceil\), added saturating, the \((\mathbb{N}, +)\) side of TimesPower's fold |
| Cbit_word | The bit word of width W: a machine word where one has the width, std::bitset otherwise |
| Cbit_word< 8 > | |
| Cbit_word< 16 > | |
| Cbit_word< 32 > | |
| Cbit_word< 64 > | |
| CIterate | A letter after tau taken steps times |
| CKeptAfter | Whether the letter tau takes steps times to is kept |
| CReturnsAfter | Whether tau taken steps times returns the letter |
| CSetBit | One letter's bit into the packed characteristic function |
| CCycleCount | The letters that fill a merged cycle of length legs through tau, counted in the bit word of width W: the spider's merge on the truth values is \(\wedge\), so packed it is &, one mask per step around the cycle and one for the letters tau returns, and one popcount |
| CAndStep | One more step's mask into the meet |
| CCycleFactor | One merged leg's factor: the letters that fill a cycle, by popcount in the narrowest word that holds the alphabet, raised to the number of such cycles |
| CCylinderFactorsAt | The sequence of a cylinder's factors along the offsets of its window. A power is the same at every position, so every window that fits has the same factors (R2: the offset drops out): period 1, on the offsets where the window fits. The summands of occurrences are this sequence read by CountOf or ExactCountOf |
| CCountOf | A reading of a factored count, modulo the word: an arrow from the factor lists, with no period of its own; after a periodic sequence, the composite is periodic (period of a Compose) |
| CExactCountOf | A reading of a factored count, exactly: as CountOf |
| Ndetail_ordinal_sum | |
| CUnordered | |
| Ndetail_runs | |
| CSweep | One position of a sweep: the operation's value there, kept as a step where it differs from the value before |
| CState | |
| CTranslated | One step of a preimage along a translation: a step past it moves down by it; one at or before it is absorbed into the value at 0 |
| CAlong | One count of a sweep along a predicate: a step where its value changes, nothing where the steps outgrow their bound |
| CState | |
| CCommutes | The pullback square at one count: the apex holds it exactly where both operands do, and its legs land on the count itself |
| CPullsBack | The pullback's law at one count: the closed form reads what the composite P∘f reads, preimage(f, P)(x) = P(f(x)) |
| Cfree_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) |
| Cconstruction_base< F > | |
| CSpeciesTraits< dedekind::algebra::𝔽64 > | |
| Cis_cyclic_group< bool, std::bit_xor< bool > > | |
| Ccyclic_order< bool, std::bit_xor< bool > > | |
| Cis_cyclic_group< dedekind::algebra::𝔽64, std::multiplies< dedekind::algebra::𝔽64 > > | |
| Ccyclic_order< dedekind::algebra::𝔽64, std::multiplies< dedekind::algebra::𝔽64 > > | |
| CSpeciesTraits< dedekind::algebra::OneDimensionalVector< S, Tag > > | |
| CSpeciesTraits< dedekind::algebra::Monomial< N > > | |
| Cunit_trait< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > > | |
| Cis_exact_total< dedekind::algebra::Monomial< N >, std::multiplies< dedekind::algebra::Monomial< N > > > | |
| Cfree_algebra_base< dedekind::algebra::Polynomial< R, M > > | |
| Cunit_trait< dedekind::algebra::Polynomial< R, M >, std::plus< dedekind::algebra::Polynomial< R, M > > > | |
| Cunit_trait< dedekind::algebra::Polynomial< R, M >, std::multiplies< dedekind::algebra::Polynomial< R, M > > > | |
| Cis_periodic< dedekind::algebra::Polynomial< R, M >, std::plus< dedekind::algebra::Polynomial< R, M > > > | |
| Cis_periodic< dedekind::algebra::Polynomial< R, M >, std::multiplies< dedekind::algebra::Polynomial< R, M > > > | |
| Cquotient_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) |
| Cconstruction_base< Q > | |
| Cquotient_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 |
| Cquotient_congruence< detail_quotient::IntByEquality > | |
| Cproduct_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) |
| Cis_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<> > | |
| Csubalgebra_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 |
| Cconstruction_base< S > | |
| Cis_associative< T, Op > | |
| Cis_commutative< T, Op > | |
| Cis_periodic< T, Op > | |
| Cinverse_trait< T, Op > | |
| Cunit_trait< T, Op, void > | |
| Cunit_trait< dedekind::algebra::Tropical< T, M >, dedekind::algebra::TropicalPlus, void > | ⊕-identity is the ∞ sentinel |
| Cunit_trait< dedekind::algebra::Tropical< T, M >, std::plus< dedekind::algebra::Tropical< T, M > >, void > | ⊗-identity is 0 |
| Cis_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) |
| Cis_linear_action< dedekind::algebra::𝔽64, bool, std::plus< dedekind::algebra::𝔽64 >, std::bit_xor< bool >, std::bit_and< bool >, std::multiplies<> > | |
| Cis_linear_action< std::uint64_t, bool, std::bit_xor< std::uint64_t >, std::bit_xor< bool >, std::bit_and< bool >, dedekind::algebra::Bit2U64Action > | |
| Cquotient_algebra_base< dedekind::analysis::Dual< F > > | |
| Cis_linear_action< dedekind::analysis::Dual< F >, F, std::plus< dedekind::analysis::Dual< F > >, std::plus< F >, std::multiplies< F >, std::multiplies<> > | |
| Cis_exact_total< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > > | |
| Cis_exact_total< dedekind::analysis::Dual< F >, std::multiplies< dedekind::analysis::Dual< F > > > | |
| Cunit_trait< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > > | |
| Cunit_trait< dedekind::analysis::Dual< F >, std::multiplies< dedekind::analysis::Dual< F > > > | |
| Cinverse_trait< dedekind::analysis::Dual< F >, std::plus< dedekind::analysis::Dual< F > > > | |
| Cis_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 > > > > | |
| Cis_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 > > > > | |
| Cis_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 |
| Cis_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 |
| Cis_linear_action< S, S, Add, Add, std::multiplies< S >, std::multiplies<> > | The same, acted on by the transparent std::multiplies<> |
| Ccounting_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 |
| Ccounting_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 |
| CZeroAction | The 'Absorption' logic |
| Cacting_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 |
| Cacting_monoid< std::plus< std::size_t > > | A monoid acts on itself: (std::size_t, +) by + |
| Cadjunction_witness | Typed unit/counit data for an adjunction witness |
| Cis_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) |
| CColumns | 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 |
| CAutomaton | A matcher's plan: the transitions on each letter, and the states where a word of the set has just been read |
| CPrefix | 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 |
| CPrefixed | 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 |
| CMatches | 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 |
| CSection | 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 |
| CCurried | \(T \to T^T\): the operation, one argument at a time |
| CUncurried | \(T \times T \to U\): the curried operation, taken back |
| CInjections | 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) |
| CInjection | 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) |
| CSections | |
| Cis_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 |
| Cis_periodic< Sections< T, Op >, compose > | |
| Cis_total_by_construction< Sections< T, Op >, compose > | |
| Cunit_trait< Sections< T, Op >, compose > | |
| CMorphisms | |
| CArrows | |
| CSetId | The Identity morphism for the category Set |
| CSet | The Category of C++ Types (Set). Formally reified as a Cartesian Closed Category |
| Carrow_as_relation | Adapter: realise an IsArrow F : A → B as a binary relation (a, b) ↦ f(a) == b |
| CPairing | ⟨f, g⟩ : A → B × C, one argument into a product |
| CCopairing | [f, g] : A + B → C, case analysis out of a sum |
| Cis_involutive< Flip< A, A >, std::pair< A, A > > | |
| CCopy | Copy (comonoid comultiplication) Δ:A→A×A, a↦(a,a). The left adjoint of the meet; the fan-out of a cartesian bicategory |
| CDelete | Delete (counit) ε:A→1. Completes the commutative comonoid |
| CMerge | 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 |
| CTensor | 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 |
| CMergeBadOp | |
| Cis_integer_chain | Whether a carrier is an integer chain: the integral types, and the carriers that register themselves (sets' cardinals, a bignum) |
| Cunfold_view | |
| Citerator | A position of the walk: the element, the next state, live |
| CStepCoalgebra | 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 |
| CUntil | 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 |
| CUnfold | The anamorphism of a coalgebra as an arrow from the seeds: x >> unfold<S>(c) is unfold(x, c) |
| CMapped | The functor's action on a coalgebra: f on the emitted leg |
| CBelow | 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 |
| Cchain_view | |
| CSlice | 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 |
| CLifted | 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 |
| CWhere | 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 |
| CWindows | 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 |
| CLastOf | The history comonad's counit: a prefix's last letter |
| CWindowJoin | 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 |
| COffsets | 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 |
| CJoinWith | 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) |
| CCounting | 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) |
| Cantitone_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) |
| Cantitone_on_even_lengths< Compose< Compose< Fam, JoinWith< P, S > >, Counting< J > > > | |
| COrderBy | 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 |
| CTake | take<K>(), SQL's LIMIT: the first K present elements |
| CConstantMorphism | The Constant Morphism f: A -> B |
| CEquals | 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)) |
| CDiscreteCategory | DiscreteCategory realization using the Identity Morphism. Lifts a species T into a category where every arrow is the Identity<T> |
| Cis_symmetric | Engineer-supplied trait: relation Rel on T is symmetric (∀x, y: Rel(x, y) ⇔ Rel(y, x)) |
| Cis_symmetric< T, Rel > | |
| Cis_equality | Trait: Rel on T is equality, the diagonal Δ: Rel(a, b) holds iff a and b are the same value |
| Cis_equality< T, Rel > | |
| Cis_equality< T, std::equal_to< T > > | |
| Cis_equality< T, std::equal_to<> > | |
| Cis_equality< std::pair< A, B >, std::equal_to< std::pair< A, B > > > | |
| Cis_equality< std::pair< A, B >, std::equal_to<> > | |
| Cis_reflexive< T, Rel > | |
| Cis_transitive< T, Rel > | |
| Cis_antisymmetric< T, Rel > | |
| Cis_equality< int, detail_equality::SameInt > | |
| Cis_equality< detail_mereology::Dial< 3 >, std::equal_to< detail_mereology::Dial< 3 > > > | |
| CBetaReduction | 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 |
| CLawAlgebra | 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) |
| Cis_directed | Trait to mark a relation as directed: every pair of elements has an upper bound |
| Cis_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 |
| Cis_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) |
| Cis_codirected | Trait to mark a relation as codirected: every pair of elements has a lower bound |
| Cis_codirected< T, Rel > | Discovery: types may opt in via a nested is_codirected_v template member, mirroring the sibling trait patterns |
| Cis_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) |
| Cis_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 |
| CMaybeMap | 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 |
| CTupleMap | f on the one element of a one-tuple: the one-tuple functor's action on an arrow |
| Cmaybe_functor | The Intensional Functor for Optional (Maybe) values |
| Ctuple_functor | The Intensional Functor for 1-tuple values |
| Cis_functorial< maybe_functor< T > > | The container functors map their one slot or none elementwise: the functor laws hold by construction |
| Cis_functorial< tuple_functor< T > > | |
| Ccomposite_functor | Composite Functor G . F (Maps CatS -> CatT -> CatU) |
| Cis_functorial< composite_functor< F, G > > | A composite of functors is a functor: its laws derived from its legs' |
| Chas_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 |
| Cf_algebra | A concrete witness for an F-algebra |
| Cf_coalgebra | A concrete witness for an F-coalgebra |
| Cidentity_functor | |
| Cis_functorial< identity_functor< Cat > > | The identity functor returns each arrow itself: the functor laws hold by construction |
| CElement | 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 |
| CDelooping | 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 |
| CActing | An element acting: the arrow \(v \mapsto h(v, s)\) on the set the monoid acts on |
| CActingOn | The arrows by which a monoid acts on V, as a category: the image of the delooping under the action |
| CActionFunctor | 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 |
| Cis_functorial< ActionFunctor< H, V, S > > | An action's functor laws come with the action: derived from acting_monoid, which IsRightAction reads |
| CLeftActing | A scalar acting on the left: the arrow \(m \mapsto s \cdot m\) of a semimodule |
| CLeftActingOn | 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 |
| CLeftActionFunctor | 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 |
| Cis_functorial< LeftActionFunctor< M, S, AddM, AddS, MultS, Act > > | A semimodule's functor laws come with it: derived from IsSemimodule |
| CDaggerFunctor | 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 |
| Cis_functorial< DaggerFunctor< Dagger, T, Op > > | A dagger's functor laws come with the dagger: derived from IsDagger, its involution and its reversal of products |
| CImageChi | The characteristic predicate of image_of(F) — recognises y as "in the image of @c F" |
| CImageChi< F > | Image classifier for a retractable arrow: y is in the image iff the retract fires at y |
| Ckernel_quotient | Opt-in trait: textbook claim "for this @c F, @c A/ker(F) is the carrier @c ::Class" |
| Cimage_carrier | Opt-in trait: textbook claim "for this @c F, @c im(F) is the carrier @c ::type" |
| Cis_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 |
| Cis_involutive< F, T > | Discovery: a type may opt in via a nested is_involutive_v template member |
| Cis_involutive< std::logical_not< bool >, bool > | Canonical: std::logical_not<bool> is the involution on bool |
| Cis_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 |
| Cis_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.) |
| CReverse | 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 |
| Cis_involutive< Reverse, W > | |
| Cis_involutive< Reverse, std::strong_ordering > | |
| Cis_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 |
| Cis_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 |
| Cis_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 |
| Cis_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 |
| Cis_associative< T, detail_involution::Reversed< Op > > | |
| Cis_commutative< T, detail_involution::Reversed< Op > > | |
| Cis_idempotent< T, detail_involution::Reversed< Op > > | |
| Cunit_trait< T, detail_involution::Reversed< Op > > | |
| Cis_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 |
| Cis_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 |
| CIsoRetract | The retract of an IsIsomorphism: its total inverse arrow wrapped in an always-engaged std::optional |
| Cunit_witness | Unit_witness<Functor, T>: Generic Kleisli unit witness. Lifts a value into the Kleisli extension named by Functor::template Shape<T> |
| Cunit_witness< maybe_functor< T >, T > | |
| Ccounit_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) |
| Cunit_witness< tuple_functor< T >, T > | |
| Ccounit_witness< tuple_functor< T >, T > | |
| Cis_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 |
| Cis_cokleisli_triple | Trait: the co-Kleisli-triple laws, the duals, for Functor's counit and extend |
| Cis_kleisli_triple< maybe_functor< T > > | |
| Cis_kleisli_triple< tuple_functor< T > > | |
| Cis_cokleisli_triple< tuple_functor< T > > | |
| Cis_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)\) |
| Cis_frobenius_monad< tuple_functor< T > > | |
| Ckleisli_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 |
| Cfunctor_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)\) |
| Cfunctor_of< Maybe< A > > | |
| Cfunctor_of< std::tuple< A > > | |
| CLatticeBottom | 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 |
| CLatticeTop | The abstract top of the lattice over (T, Rel), dually |
| CLatticeBottom< T, std::less_equal< T > > | Canonical specialisation: integral carriers under std::less_equal have bottom = numeric_limits<T>::min() |
| CLatticeTop< T, std::less_equal< T > > | Canonical specialisation: integral carriers under std::less_equal have top = numeric_limits<T>::max() |
| CMeet | |
| CJoin | |
| Cpredicate_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 |
| Cpredicate_logic< P > | |
| Cpredicate_logic< Compose< F, G > > | |
| CMeet< A, B > | |
| CJoin< A, B > | |
| CNot | |
| CNot< 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 |
| Cover_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) |
| Cover_nodes< Leaf, Meet< A, B > > | |
| Cover_nodes< Leaf, Join< A, B > > | |
| Cover_nodes< Leaf, Not< A > > | |
| Cbuilds_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) |
| Cbuilds_lattice_nodes< Meet< A, B > > | |
| Cbuilds_lattice_nodes< Join< A, B > > | |
| Cbuilds_lattice_nodes< Not< A > > | |
| CMakeMeet | The pairing factory for the meet (∧, pullback): ⟨-,-⟩ : A×B→Meet |
| CMakeJoin | The pairing factory for the join (∨, pushout): ⟨-,-⟩ : A×B→Join |
| Claw_inactive | Sentinel: a law that does not fire on the given node |
| Ccanonical_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 |
| Cis_lattice_bottom_for | Is X the registered bottom of the lattice whose order is Ord? |
| Cis_lattice_bottom_for< LatticeBottom< T, Rel >, Ord > | |
| Cis_lattice_top_for | Is X the registered top of the lattice whose order is Ord? |
| Cis_lattice_top_for< LatticeTop< T, Rel >, Ord > | |
| Ccarrier_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) |
| Ccarrier_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 |
| Ccarrier_of< Meet< A, B > > | |
| Ccarrier_of< Join< A, B > > | |
| Ccarrier_of< Not< A > > | |
| Ccodomain_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) |
| Ccodomain_of< X > | |
| Ccodomain_of< Meet< A, B > > | |
| Ccodomain_of< Join< A, B > > | |
| Ccodomain_of< Not< A > > | |
| CHeytingExponential | 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 |
| CHeytingExponential< 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 |
| Cis_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 |
| Cis_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 = ⊤ |
| Clattice_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) |
| Clattice_less_logic< Less > | |
| Cno_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 ∧/∨ |
| Cno_canonical_order | No order for the reducer to canonicalise by: a carrier without one keeps the residue in its authored order, then combines it |
| CReduce | |
| CProjection | The projection π_k: the k-th component of a product |
| CProjection< 0 > | The projection out of the one-fold product A¹ ≅ A: the identity arrow (Identity), read at the point's own type |
| CAnyOperation | Base-case sentinel for the operation parameter of IsProduct / IsCoproduct |
| CSpeciesTraits< std::pair< A, B > > | |
| CSpeciesTraits< std::tuple< Ts... > > | |
| Clogic_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 |
| CBoole | The internal logic of the Classical Topos ({True, False}) |
| CKleene | The internal logic of the Kleene Topos |
| CChain | 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 |
| CPercentage | Percentage: a range-enforcing [0,100] carrier ("50:50") |
| CPercent | The bounded confidence chain: a 101-grade De Morgan (Kleene) chain, self-dual about 50 |
| CGetLogic | 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 |
| CGetLogic< Ternary > | |
| CGetLogic< T > | |
| CClassifierLogic | The logic species a classifier answer type belongs to |
| CClassifierLogic< bool > | |
| CClassifierLogic< Ternary > | |
| CClassifierLogic< T > | |
| Cunit_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 |
| Cunit_trait< C, Inf > | |
| Cspecies_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 |
| Cspecies_embed< L, L > | |
| Cspecies_embed< Boole, To > | |
| Cspecies_embed< Kleene, Percent > | |
| Cjoin_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 |
| Cjoin_logic< L1, L2 > | |
| Cmeet_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 |
| Cmeet_logic< L1, L2 > | |
| CSemidecided | 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 |
| CTruth | The Monic Wrapper for a Logical Species (Ω) |
| CSpeciesTraits< Truth< L > > | Bridge the Monic Wrapper to the Logic Species Registry |
| CLogicTraits | Primary Template: Default to Classical (Boolean) Logic |
| CLogicTraits< T > | Specialization for Floating-Point Species (IEEE 754 NaN handling) |
| CSubobjectClassifier | |
| CNegationArrow | The arrow reading of logic negation ¬ = L::RFL on the truth object Ω — the canonical order-reversing arrow |
| CLiftLogic | 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) |
| Cis_involutive< logic_complement< Boole >, bool > | Witness: Boolean negation is an involution. Boole's RFL is std::logical_not on bool (!!b = b) |
| Cis_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) |
| Cis_involutive< logic_complement< Chain< T > >, T > | Witness: the Chain<T> reflection ~a is an involution (~~x = x) for every integral carrier |
| Cis_involutive< logic_complement< Percent >, Percentage > | Witness: the Percent reflection 100-p is an involution |
| Cis_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 |
| Cis_reflexive | Trait to mark a relation as reflexive: a ~ a = True |
| Cis_reflexive< T, std::less_equal< T > > | |
| Cis_transitive | |
| Cis_transitive< T, std::less_equal< T > > | |
| Cis_antisymmetric | |
| Cis_antisymmetric< T, std::less_equal< T > > | |
| Cis_connex | |
| Cis_connex< T, Rel > | |
| Cis_connex< T, std::less_equal< T > > | |
| CChainWalk | 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) |
| CChainStep | 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 |
| CSup | Value-returning chain lattice ops — the honest T × T → T meet / join |
| CInf | Meet ∧: the greatest lower bound on a chain (min), returned by value. Value-returning sibling of Sup |
| Cunit_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 |
| Cunit_trait< bool, Inf > | |
| Cunit_trait< detail_mereology::Dial< N >, Sup > | |
| Cunit_trait< detail_mereology::Dial< N >, Inf > | |
| Cis_monadic | T : C -> C with η : Id ⟹ T and μ : T² ⟹ T |
| Cis_comonadic | Trait: the comonad laws for ε and δ on W, the duals |
| Carchetype | The representative presentation of an object: itself for a value type; the one it names (C::archetype) otherwise |
| Carchetype< C > | |
| CMorphism | The formal structure of an Arrow f: A -> B |
| Cinfer_morphism | Universal inference for any Morphism signature f: Args... -> Codomain |
| CSpeciesTraits< F, A > | |
| CSpeciesTraits< std::logical_and< bool > > | |
| CSpeciesTraits< std::logical_or< bool > > | |
| CSpeciesTraits< std::equal_to< bool > > | |
| CSpeciesTraits< std::plus< T > > | |
| CSpeciesTraits< std::minus< T > > | |
| CSpeciesTraits< std::multiplies< T > > | |
| CSpeciesTraits< std::divides< T > > | |
| CSpeciesTraits< std::bit_and< T > > | |
| CSpeciesTraits< std::bit_or< T > > | |
| CSpeciesTraits< std::less_equal< T > > | |
| CSpeciesTraits< std::less< T > > | |
| CMorphicBridge | |
| CMorphicBridge< T > | |
| CMorphicBridge< R(C::*)(A) const > | |
| CMorphicBridge< R(C::*)(A)> | |
| CMorphicBridge< std::function< R(A)> > | |
| Csignature_extractor | |
| CRule | A type-erased Morphism A -> B between Species |
| CIdentity | The Identity Morphism and Functorial Witness |
| CCompose | The reified composition arrow g∘f: "apply @c F, then @c G" (diagrammatic f≫g order), the arrow-algebra companion to Identity |
| Chas_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) |
| Chas_one_value< Compose< F, G > > | |
| Ccommutes | 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) |
| Cunit_trait< Identity< T >, Op > | |
| CIdentityIn | 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 |
| Cis_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 |
| Cis_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 |
| Cis_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 |
| Cmaybe_monad_tag | |
| Cidentity_monad_tag | |
| Ctuple_monad_tag | |
| Cidentity_transformation | The Identity Natural Transformation for Functor F |
| Cvertical_composition | Vertical composition of two 2-morphisms (β . α) |
| Chorizontal_composition | Horizontal composition (Godement product) |
| CSuccessor | 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 |
| CZeroElement | 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 |
| CPredecessor | The predecessor \(P : N \to N\) as an arrow, in the carrier's own posture at ⊥: the monus on ℕ (0 a fixpoint), −1 on ℤ |
| CIn | 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\) |
| CPrior | The destructor \(\langle \text{is}\;Z?,\, P\rangle : N \to 1 + N\): nothing at zero, else the predecessor |
| CNumericWitness | A typed witness of numeric classification in Ω_K3 |
| CIntervalBoundaryPolicy | Closed interval policy [lower, upper] for integral species |
| CFullMachineBoundaryPolicy | Full-machine boundary policy (no clipping) |
| CNaNHolePolicy | IEEE-754 NaN-hole classifier policy for floating species |
| CGetLogic< std::optional< T > > | |
| CPartial | The Kleisli Context for "Consistently Broken" Species |
| CTernaryResult | A Logic-Aware Result container for Ternary outcomes |
| CSafeAddTransform | Addition with overflow check (Classical Logic) |
| CBoundedAddTransform | Addition that consults a user-supplied numeric boundary policy |
| CBoundedMulTransform | Multiplication with user-supplied numeric boundary policy |
| CBoundedDivTransform | Division with user-supplied numeric boundary policy |
| CHonestDivTransform | Division with truncation-awareness (Ternary Logic) |
| Cunit_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 |
| Cunit_period< ConstantMorphism< N, B > > | |
| Cunit_period< Compose< F, G > > | |
| CCongruent | 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 |
| CFibonacciMod | 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 |
| COpaque | 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 |
| CShift | A translation of the counts, \(k \mapsto k + j\): after it, a periodic arrow keeps its period, on an extent narrowed by j |
| Cbuilds_lattice_nodes< P > | Periodic predicates opt in: their | and & are the lattice's nodes (:lattice), periodic with the least common multiple of their periods |
| CRolling | 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 |
| CBox | 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 |
| CAtMost | 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 |
| CFactor | A factor of a count, \(b^e\): a base raised to an exponent |
| CCycles | The cycles of a permutation of positions of one length, and how many there are: one term of its cycle type |
| CLetters | 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") |
| CBytes | 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 |
| CRanked | 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 |
| CReflection | |
| Cis_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 |
| CSplitMix | 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 |
| CRandomLetter | A random letter by position: the hash, read as a rank in an alphabet |
| CLetterMap | 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 |
| CPower | 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 |
| CPowerMap | 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 |
| CRotation | 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 |
| Cis_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) |
| Ccommutes< 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) |
| Ccommutes< PowerMap< T >, Morphism< W, W, Rotation< N > > > | |
| Cis_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 |
| CLetterMaps | The letter maps on the bytes as a category: one arrow type, LetterMap, the identity its identity table |
| CLetterMapsOnWords | The letter maps on every letter of a word as a category: the image of LetterMaps under the list functor |
| CPowerFunctor | 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 |
| Cis_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 |
| COnWords | A transformation of the power functor with one component, a map on the words, the same at every letter |
| CSymmetric | 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 |
| CHolds | One position of a word against the condition: the letter at i is the power's, and its image under tau is at sigma(i) |
| CPowers | 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) |
| CFixedBy | 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 |
| CLength | 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 |
| CReflectedReverse | ~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.) |
| Clength_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 |
| Clength_coherent< Reverse > | |
| Cdensity_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) |
| Cdensity_falls_on_even_lengths< Compose< Powers< C, F, N >, FixedBy< Power< C, F, N >, S, T > > > | |
| COuter | An outer product of two counted tensors, its count the product of theirs |
| CFreeMonoid | 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 |
| CCeilLog2 | \(\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 |
| CPow2 | \(k \mapsto 2^k\) on the counts, refused past the word: the window of the bit words |
| CPack | 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\) |
| CUnpack | 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 |
| CIsSquare | 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}\) |
| CWindow | 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 |
| CCylinder | 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 |
| Cunit_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 |
| Cmonotone_trait | User-declared monotonicity witness for an arrow type F with respect to the ambient order relation Op |
| Cantimonotone_trait | User-declared anti-monotonicity witness for an arrow type F with respect to the ambient order relation Op |
| CProfile | 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) |
| CArrowNodeAt | The engine at one former and one law, as a function of the law |
| CProductLeq | 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 |
| CSubobjectInclusion | 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 |
| CPullbackApex | 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) |
| CMember | A member of the apex: one value, read in each operand. Its components are the legs, Π<1, Member> and Π<2, Member> as arrows (:limit's projections), the co-restrictions A ∧ B ↪ A and A ∧ B ↪ B: inclusions, so monic, not epic |
| CPushoutApex | 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 |
| CMember | |
| CClassifierApex | 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 |
| CRunList | 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 |
| CMember | The subobject surface: a member is a count the run list holds, and its inclusion into the counts is the count itself |
| CRunCombine | 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 |
| CStringArrow | An arrow that is just a label |
| CStringCategory | The Category of Labels |
| CSpeciesTraits | |
| CSpeciesTraits< T > | |
| Cis_associative | Trait to mark an operation as associative: (a ∘ b) ∘ c = a ∘ (b ∘ c) |
| Cis_commutative | Trait to mark an operation as commutative: a ∘ b = b ∘ a |
| Cis_commutative< T, std::bit_or< T > > | |
| Cis_commutative< T, std::bit_and< T > > | |
| Cis_idempotent | Trait to mark an operation as idempotent: a ∘ a = a |
| Cis_idempotent< T, Op > | |
| Cunit_registry | |
| Cunit_registry< T, Op > | |
| Cunit_registry< T, std::plus< T > > | |
| Cunit_registry< T, std::multiplies< T > > | |
| Cunit_registry< bool, Op > | |
| Cunit_trait | |
| Cunit_trait< T, Op, std::void_t< decltype(T::template unit_v< Op >)> > | |
| Cinverse_trait | The Formal Trait: Hooks the bridge into the Concept system |
| Cunit_trait< bool, std::bit_xor< bool > > | |
| Cunit_trait< T, std::plus<> > | |
| Cunit_trait< T, std::plus< T > > | |
| Cunit_trait< T, std::multiplies<> > | |
| Cunit_trait< T, std::multiplies< T > > | |
| Cunit_trait< T, std::bit_xor< T > > | |
| Cunit_trait< bool, std::bit_and< bool > > | |
| Cunit_trait< T, std::bit_or<> > | |
| Cunit_trait< T, std::bit_and<> > | The top of the bit lattice: every bit set, ~T{} (an unsigned word's & identity; true on bool) |
| Cis_idempotent< bool, std::logical_and< bool > > | |
| Cis_idempotent< bool, std::logical_or< bool > > | |
| Cis_idempotent< T, std::bit_and< T > > | |
| Cis_idempotent< T, std::bit_or< T > > | |
| Cis_associative< T, std::bit_or< T > > | |
| Cis_transfinite | Primary trait for Transfiniteness |
| Corigin_trait | Primary trait: The distinguished 'Point' of a species |
| Corigin_trait< T > | Atomic Proof: Integrals are pointed at 0 |
| CSubobject | The Subobject Species S ↣ A |
| CMember | The Internal Member of the Subobject. Wraps a value from the ambient space that satisfies the classifier |
| Cbuilds_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) |
| Cis_periodic | |
| Cis_saturating | |
| Cis_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 |
| Cis_periodic< T, std::plus< T > > | |
| Cis_periodic< T, std::minus< T > > | |
| Cis_periodic< T, std::multiplies< T > > | |
| Cis_periodic< T, std::bit_xor< T > > | |
| Cconstruction_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 |
| Cis_total_by_construction | Path E to totality: by construction. Defined below is_total, which it recurses into on the base |
| Cis_total | The certificate. Op is taken up to cv/ref (a const Inf keys the same registration as Inf) |
| Cis_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 |
| Cis_total< T, Op > | A qualified operation is total where the operation is: the paths read the unqualified operation, and so does every specialisation |
| Cis_total_by_construction< D, std::plus< D > > | |
| Cis_total_by_construction< D, std::multiplies< D > > | |
| Cunit_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 |
| Cis_cyclic_group | Opt-in trait: is (T, Op) a \emph{cyclic} abelian group? |
| Ccyclic_order | The order \(n\) of a cyclic group (its cardinality) |
| Cis_cyclic_group< T, std::plus< T > > | |
| Ccyclic_order< T, std::plus< T > > | |
| CSpeciesTraits< dedekind::ieee::IEEE< F > > | |
| Cis_associative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > > | |
| Cis_commutative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEAdd< F > > | |
| Cis_associative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > > | |
| Cis_commutative< dedekind::ieee::IEEE< F >, dedekind::ieee::IEEEMul< F > > | |
| Cis_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 > > > | |
| Cis_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 > > > | |
| Cis_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 > > > | |
| Cis_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 > > > | |
| Cis_functorial< dedekind::linear_algebra::matrix2x2_functor< T > > | Elementwise lifts: the functor laws hold by construction |
| Cunit_witness< dedekind::linear_algebra::matrix2x2_functor< T >, T > | |
| Ccounit_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 |
| Cunit_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 |
| Cunit_trait< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cis_associative< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cis_associative< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cis_commutative< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cis_total_by_construction< dedekind::linear_algebra::Matrix2x2V< T >, std::plus< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cis_total_by_construction< dedekind::linear_algebra::Matrix2x2V< T >, std::multiplies< dedekind::linear_algebra::Matrix2x2V< T > > > | |
| Cunit_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 |
| Cunit_trait< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N > > | ⊗-identity of Mat(S) is the identity matrix |
| Cis_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) |
| Cis_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 |
| Cis_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 |
| Cunit_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 |
| Cis_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 +) |
| Cis_saturating< dedekind::linear_algebra::MatNxNV< S, N >, dedekind::linear_algebra::MatTimes< S, N > > | |
| Cis_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 |
| Cis_functorial< dedekind::linear_algebra::vec2_functor< T > > | Elementwise lifts: the functor laws hold by construction |
| Cis_functorial< dedekind::linear_algebra::covec2_functor< T > > | |
| Cunit_witness< dedekind::linear_algebra::vec2_functor< T >, T > | |
| Cunit_witness< dedekind::linear_algebra::covec2_functor< T >, T > | |
| Ccounit_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 |
| Cproduct_algebra_base< dedekind::linear_algebra::Vec2V< T > > | |
| Cproduct_algebra_base< dedekind::linear_algebra::Covec2V< T > > | |
| Cunit_trait< dedekind::linear_algebra::Vec2V< T >, std::plus< dedekind::linear_algebra::Vec2V< T > > > | |
| Cunit_trait< dedekind::linear_algebra::Covec2V< T >, std::plus< dedekind::linear_algebra::Covec2V< T > > > | |
| Cinverse_trait< dedekind::linear_algebra::Vec2V< T >, std::plus< dedekind::linear_algebra::Vec2V< T > > > | |
| Cinverse_trait< dedekind::linear_algebra::Covec2V< T >, std::plus< dedekind::linear_algebra::Covec2V< T > > > | |
| Cis_associative< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Cis_commutative< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Cis_associative< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > > | |
| Cis_commutative< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > > | |
| Cis_periodic< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Cis_periodic< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > > | |
| Cis_periodic< dedekind::morphologies::Modular< N >, std::minus< dedekind::morphologies::Modular< N > > > | |
| Cunit_trait< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Cunit_trait< dedekind::morphologies::Modular< N >, std::multiplies< dedekind::morphologies::Modular< N > > > | |
| CSpeciesTraits< dedekind::morphologies::Modular< N > > | |
| Cis_cyclic_group< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Ccyclic_order< dedekind::morphologies::Modular< N >, std::plus< dedekind::morphologies::Modular< N > > > | |
| Cquotient_congruence< dedekind::morphologies::Modular< N > > | |
| Ckernel_quotient< dedekind::morphologies::first_iso_mod_2::mod_2_arrow > | |
| Cimage_carrier< dedekind::morphologies::first_iso_mod_2::mod_2_arrow > | |
| Cis_exact_total< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > > | |
| Cis_exact_total< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > > | |
| Cis_associative< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > > | |
| Cis_commutative< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > > | |
| Cinverse_trait< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > > | |
| Cis_exact_total< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Cis_associative< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Cis_commutative< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Cunit_trait< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Cinverse_trait< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Cis_cyclic_group< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| Ccyclic_order< dedekind::numbers::UnitRoot< N >, std::multiplies< dedekind::numbers::UnitRoot< N > > > | |
| CSpeciesTraits< dedekind::numbers::Complex< R > > | |
| Cis_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 > > > > | |
| Cis_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 > > > > | |
| Cquotient_algebra_base< dedekind::numbers::Complex< R > > | |
| Cis_linear_action< dedekind::numbers::Complex< R >, R, std::plus< dedekind::numbers::Complex< R > >, std::plus< R >, std::multiplies< R >, std::multiplies<> > | |
| Cunit_trait< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > > | |
| Cunit_trait< dedekind::numbers::Complex< R >, std::multiplies< dedekind::numbers::Complex< R > > > | |
| Cinverse_trait< dedekind::numbers::Complex< R >, std::plus< dedekind::numbers::Complex< R > > > | |
| CSpeciesTraits< dedekind::numbers::Cut< Q > > | Atlas registration: Cut<Q> is a first-class species |
| CSpeciesTraits< dedekind::numbers::QuadraticReal< D, Q > > | Atlas registration: QuadraticReal<D,Q> is a first-class species |
| Cis_exact_total< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_exact_total< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_associative< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_associative< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_commutative< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_commutative< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cunit_trait< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cunit_trait< dedekind::numbers::QuadraticReal< D, Q >, std::multiplies< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cinverse_trait< dedekind::numbers::QuadraticReal< D, Q >, std::plus< dedekind::numbers::QuadraticReal< D, Q > > > | |
| Cis_exact_total< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > > | |
| Cis_exact_total< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > > | |
| Cunit_trait< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > > | |
| Cunit_trait< dedekind::numbers::Rational< I >, std::multiplies< dedekind::numbers::Rational< I > > > | |
| Cis_linear_action< dedekind::numbers::Rational< I >, I, std::plus< dedekind::numbers::Rational< I > >, std::plus< I >, std::multiplies< I >, std::multiplies<> > | |
| Cinverse_trait< dedekind::numbers::Rational< I >, std::plus< dedekind::numbers::Rational< I > > > | |
| Cis_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 |
| Cis_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 > > > | |
| CSpeciesTraits< dedekind::numbers::Rational< Z > > | |
| Cis_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) |
| Cis_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 > > > > | |
| Cis_reflexive< T, dedekind::order::bit_subset_eq< T > > | |
| Cis_transitive< T, dedekind::order::bit_subset_eq< T > > | |
| Cis_antisymmetric< T, dedekind::order::bit_subset_eq< T > > | |
| Cis_directed< T, dedekind::order::bit_subset_eq< T > > | |
| Cis_codirected< T, dedekind::order::bit_subset_eq< T > > | |
| CHeytingExponential< 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 |
| CLatticeBottom< T, dedekind::order::bit_subset_eq< T > > | Bitwise-lattice bottom: the all-zeros bitmask |
| CLatticeTop< T, dedekind::order::bit_subset_eq< T > > | Bitwise-lattice top: the all-ones bitmask |
| Cis_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) |
| Cis_equality< A, Endo< A, L, C, DiagPred< A > > > | |
| Cis_equality< A, Endo< A, L, C, PairwisePred< Op > > > | |
| Cmonotone_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\)) |
| Cmonotone_trait< dedekind::relational::Preimage< F, L >, std::less_equal<> > | |
| Cmonotone_trait< dedekind::relational::Dual< F, L >, std::less_equal<> > | |
| Cis_adjoint< dedekind::relational::Image< F, L >, dedekind::relational::Preimage< F, L >, std::less_equal<> > | |
| Cis_adjoint< dedekind::relational::Preimage< F, L >, dedekind::relational::Dual< F, L >, std::less_equal<> > | |
| Cpath_functor | The path functor for the Path <·> shape (#508 / PR #521 review) |
| Cunit_witness< path_functor< T >, T > | |
| Ccounit_witness< path_functor< T >, T > | |
| Cis_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 |
| Cis_cokleisli_triple< dedekind::sequences::path_functor< T > > | |
| Cis_transfinite< dedekind::sets::𝔸< T, L, C > > | |
| Cis_lattice_bottom_for< dedekind::sets::Ø< T, L >, dedekind::sets::subobject_order< L > > | |
| Cis_lattice_top_for< dedekind::sets::𝔸< T, L, C >, dedekind::sets::subobject_order< L > > | |
| Cis_integer_chain< dedekind::sets::Cardinality > | |
| Cis_integer_chain< dedekind::sets::SignedCardinality > | |
| Cis_integer_chain< dedekind::sets::ExtensionalCardinal< W > > | |
| Cis_integer_chain< dedekind::sets::SignedExtensionalCardinal< S > > | |
| Cunit_trait< C1, std::plus< C1 > > | |
| Cunit_trait< C1, std::multiplies< C1 > > | |
| Cis_periodic< C1, std::plus< C1 > > | |
| Cis_periodic< C1, std::multiplies< C1 > > | |
| Cunit_trait< Z1, std::plus< Z1 > > | |
| Cunit_trait< Z1, std::multiplies< Z1 > > | |
| Cis_periodic< Z1, std::plus< Z1 > > | |
| Cis_periodic< Z1, std::multiplies< Z1 > > | |
| Cinverse_trait< Z1, std::plus< Z1 > > | |
| Cis_cyclic_group< dedekind::sets::ExtensionalCardinal< W >, std::plus< dedekind::sets::ExtensionalCardinal< W > > > | |
| Cis_cyclic_group< dedekind::sets::SignedExtensionalCardinal< S >, std::plus< dedekind::sets::SignedExtensionalCardinal< S > > > | |
| Cunit_trait< SC, std::plus< SC > > | |
| Cunit_trait< SC, std::multiplies< SC > > | |
| Cis_saturating< SC, std::plus< SC > > | |
| Cis_saturating< SC, std::multiplies< SC > > | |
| Cis_saturating< SC, std::minus< SC > > | |
| Cinverse_trait< SC, std::plus< SC > > | |
| Cunit_trait< Card, std::plus< Card > > | |
| Cunit_trait< Card, std::multiplies< Card > > | |
| Cis_saturating< Card, std::plus< Card > > | |
| Cis_saturating< Card, std::multiplies< Card > > | |
| CSpeciesTraits< dedekind::sets::Cardinality > | |
| CSpeciesTraits< dedekind::sets::SignedCardinality > | |
| CSpeciesTraits< dedekind::sets::SignedExtensionalCardinal< S > > | |
| Cantimonotone_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 |
| Cis_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 |
| Cmonotone_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 |
| Cmonotone_trait< dedekind::sets::Restrict< K, UA, UB >, std::less_equal<> > | |
| Cis_adjoint< dedekind::sets::Inject< K, UA, UB >, dedekind::sets::Restrict< K, UA, UB >, std::less_equal<> > | |
| Ccompose | |
| CComposePred | The composed predicate for the relative product \(R;S\) over a Boolean intermediate, the ∃-over-the-middle enumerated on {false, true} |
| CDiagPred | 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 |
| CPairwisePred | 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) |
| CSwapPred | The swapped predicate for converse: \(R^\smile(b,a) = R(a,b)\) |
| CRelAnd | Meet (conjunction) of two relational predicates, the result of && on them |
| CRelOr | Join (disjunction) of two relational predicates, the result of || on them, dual to RelAnd |
| Nsets | |
| Ndetail | |
| Cinsert_into | The step of the folds below: insert one element into the container accumulated so far, and hand it on (Rule 3: a fold, not a loop). The element is taken by value and moved in, so a transformed result is moved, not copied (a move-only one included) |
| Cdecided | A classifier read as a decided truth value: its answer converted to bool as if would convert it, so a classifier valued in an explicit truth type (Truth<Boole>) is admitted. Applied as a const value |
| Ndetail_setexpr_witness | |
| Call_in | |
| Ndetail_sum_witness | |
| CInjections | 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) |
| Ndetail_terms_witness | |
| CForeign | |
| CResidueClass | The class \(\{x \in \mathbb{N} \mid x \equiv r \pmod n\}\), read analytically: the materialisation of ℕ | (π % n == r) |
| CØ | ∅: The Initial Object. Extensional (Size 0) |
| CMember | Member-shape mirror of Subobject's. Vacuously inhabited (Ø has no members) — but the wrapper type is still required so the IsSubobject contract has a Member-to-T projection to read through ι |
| Cdefault_cardinality | Trait behind default_cardinality_t: ℵ_0 for every carrier (the countable fiction of #680) .. |
| Cdefault_cardinality< bool > | ... except bool, which is Finite by its representation |
| C𝔸 | The universal set over the carrier T: the terminal object ⊤ of Sub(T), the reified type constraint |
| CMember | Member-shape mirror of Subobject's: every element of T is a member of U via the always-True classifier; the wrapper carries the T-value the IsSubobject contract reads back through ι |
| CSetObjectLeaf | A leaf that is a set object, the property over_nodes lifts |
| Cis_set_object | A set object: a leaf, or a node over set objects on one domain, by category's over_nodes, the rule its opt-in | and & follow too |
| CSubobjects | The subobjects of a carrier in a logic, \(\mathrm{Sub}(T, L)\) ( \(\mathrm{Sub}(\mathbb{A}_T)\), \(\chi\) valued in L), as an object: the domain or codomain of an arrow on sets — the complement, the pushforward along an injection. No one type is this object: every set object over the carrier in that logic presents it (the expression grammar is a type-indexed family: 𝔸, a comprehension, a Meet / Join / Not node), and the universe, its top, is the representative, so category::IsArrow checks an arrow on sets at the universe and asks the result to be a set object over it (morphism__Objects_And_Their_Presentations). A universe's cardinality class is a bound, not part of the object |
| Csubobject_order | The subset (⊆) order on the subobject lattice Sub(T), keyed by the logic species L. This is the injected order (Ord) under which the generic lattice-law term reducer (category:lattice_term, #865/#890) normalises set expressions: Ø is its bottom (⊥, initial), 𝔸 its top (⊤, terminal). Keying by L lets the algebra markers distinguish Boole (a Boolean subobject lattice, every law) from Kleene (Heyting / De Morgan, no complement collapse) |
| Ccodomain_reduce | The codomain leg of the two-axis reduce (#894) |
| Ccodomain_reduce< Ø< T, L > > | |
| Ccodomain_reduce< 𝔸< T, L, C > > | |
| Cis_extensional< 𝔸< T, L, C > > | |
| CFinite | |
| Cis_extensional | Primary trait: Is a species defined by its members? |
| Cis_extensional< T > | |
| Cℵ | |
| CExtensionalCardinal | Finite extensional cardinal: one machine word W |
| CCheckedResult | A wrapped result and whether the exact result overflowed W |
| CCardinalityEffect | Draft writer-like cardinality effect carrier |
| CSignedExtensionalCardinal | Signed one-word integer: two's complement in the signed word S |
| CCheckedResult | A wrapped result and whether the exact result overflowed |
| CPositiveInfinity | |
| CNegativeInfinity | |
| CNaZ | |
| CSetExpr | Opt-in CRTP base that supplies the ETCS set surface to a specialized set expression. It provides Member, ι (the subobject inclusion), Codomain, logic_species, and the set-lattice trait members. It keys the classifier χ off the Derived's own operator() |
| CMember | A member is a carrier value; ι projects it back into the ambient (the subobject inclusion the ETCS axioms read) |
| Canswer_logic | The species of a predicate's answer, relative to the base's species L: an answer already in L::Ω is in L (so a Chain<int> universe accepts an int-valued predicate), otherwise the answer type names its species (classifier_logic_t; no default) |
| Canswer_logic< L, Answer > | |
| Cdatum_cardinality | |
| Cdatum_cardinality< Predicate, Base > | |
| CComprehension | |
| CUniversalPredicate | The universal predicate: accepts every element of T |
| CEmptyPredicate | The empty predicate: rejects every element of T |
| CUnknownPredicate | The archetypal undecidable predicate: answers Unknown everywhere |
| CSetCombine | The injected leaf-combiner (the reducer's Combine policy) for the subobject lattice: at an order-incomparable residual, hand the two set leaves to the carrier's domain ∧ / ∨ on their runtime data and let the reducer fold the result again. Two plain sets over one universe combine through their predicates (structured_and / structured_or via ADL, elevated back to a set); a value leaf (an Interval) combines directly. Each leg is present only where the carrier actually combines the pair, so elsewhere the residual stays a Meet / Join node |
| Cset_predicate | The predicate of a PLAIN set, a Comprehension over the universe 𝔸<T,L> (::type absent otherwise); PlainSet gates the plain-set-only branches (complement pair, predicate negation) so a compound node (Meet / Join) takes the node path |
| Cset_predicate< Comprehension< 𝔸< T, L, C >, P > > | |
| CComplement | The complement as an arrow on the object \(\mathrm{Sub}(T, L)\) (Subobjects, :boundaries), \(S \mapsto \neg S\): an endomorphism, its domain and codomain the one object, presented by every set object over T in L. It is an involution by the reducer's own law \(\neg\neg A \to A\): operator~ peels the node, so ~~s is s, by type, for every presentation s; the certificate reads that law at the representative. The first arrow on sets category::IsInvolution admits: the concept quantifies over the object, not over one value type (morphism__Objects_And_Their_Presentations) |
| CInitialObjectArrow | InitialObjectArrow<Init, Target> — the unique arrow from the initial object into any subobject (Init → Target), i.e. the empty function / the ⊥-of-Sub(U) leg. Dual to inclusion_arrow: where that reifies an inclusion into the ambient, this reifies the initiality mediator out of Ø. Gated on category::IsInitialObject<Init> so only a genuine initial object (Ø, tagged) can be the source; the body forwards the (vacuous) Member value and is unreachable in practice (Ø has no members). Canonical span leg for a pushout A ← Ø → B, replacing hand-rolled per-instance span structs. #881 |
| CSymbolicImagePredicate | Symbolic image-of-intensional-Set predicate (#602 layer 1) |
| CComposedIsoImagePredicate | Composed predicate for the iso-decidable image(f, Set) specialisation below: y ↦ S(f^{-1}(y)) where S is the source set's characteristic and f^{-1} is the iso's inverse |
| CComposedRetractImagePredicate | Composed predicate for the retract-decidable image(f, Set) specialisation: y ↦ let mx = retract(f)(y); mx.has_value() ? S(mx.value()) : L::False |
| CExtensionalSet | |
| Cuniverse_cardinality | The cardinality class of a set object's universe |
| Cuniverse_cardinality< 𝔸< T, L, C > > | |
| Cproduct_cardinality | |
| Cproduct_cardinality< Finite, Finite > | |
| Cproduct_cardinality< Finite, ℵ< N > > | |
| Cproduct_cardinality< ℵ< N >, Finite > | |
| Cproduct_cardinality< ℵ< M >, ℵ< N > > | |
| CSumMembership | Membership of a sum: the copairing \([\chi_a, \chi_b]\), each answer lifted into the join of the summands' species. A named functor (the product's dual is the meet of its cylinders, ProductMembership) |
| Csum_universe | The sum of two set objects: the subobject (a, b) of the coproduct of their carriers, \(|a + b| = |a| + |b|\) (the join on the cardinal lattice, as for the product). Reduced where the types decide it: |
| Csum_universe< 𝔸< X, LA, CA >, 𝔸< Y, LB, CB > > | |
| CRestrict | \(\iota_K^{-1}\) as an arrow: the restriction, lifted into the sum's logic (a summand given in a smaller logic sits in the sum's by \(\Sigma \hookrightarrow \Omega\)). The right adjoint of Inject. Defined on every presentation restriction reaches: the sums, their lattice nodes, the boundaries |
| CInject | \(\exists_{\iota_K}\): a set of the summand as the set of the sum that is it on its summand and empty on the other, kept as a sum (the strength reduction a | Ø → a is the inverse direction). The left adjoint of Restrict |
| Cdescent | A descent: \(\pi_i - c\), a slot stepped down by a constant, and the slot it steps on. c > 0 is checked when the χ node is built. That the descent ends is Archimedes' axiom, that enough steps of c exceed any magnitude [1] |
| Cdescent< BinOp< std::minus<>, Projection< I >, Const< K > > > | |
| CEnv | The point and the set under definition, threaded through a body: the term nodes read it as the point (conversion, and term_value below), Self reads it as the set |
| CSelf | The set under definition pulled back along the terms: χ(t₁, …) is \(x \mapsto \chi(t_1(x), \ldots)\) with \(\chi\) the comprehension's own classifier, unknown until the former closes it. A relational predicate (an operand of && / ||), evaluable only through an Env |
| CChiTag | The classifier under definition: χ(terms…) in a former's body is the set being formed, applied to the terms |
| CDescendsAt | The measure algebra at the points X for position J: a χ node passes when its argument in position J descends on the coordinate J stands for; every node when all its legs pass; any other leaf vacuously |
| CBindArgs | The binding of the arguments of every χ in a body at the points X: each a term bound there, a constant cast into its coordinate's carrier. The body's own binding treats a χ as a leaf, so its arguments are bound here |
| CRec | The recursion, closed: the base's membership, then the body evaluated with this very predicate in scope for its Self nodes |
| CPoint | |
| CRelAnd | Meet (conjunction) of two relational predicates, the result of && on them |
| CRelOr | Join (disjunction) of two relational predicates, the result of || on them, dual to RelAnd |
| CConst | A constant, carried as a value |
| CBinOp | a op b, the operator a standard functor (std::plus<>, minus, multiplies, divides, modulus) applied in one carrier |
| CAp | An arrow applied to a term, f(a) |
| CCondT | McCarthy's conditional on terms: a where p holds, else b |
| CCmp | The atom a R b over two terms, a relational predicate |
| CTerm | A term built at run time, the grammar with its shape a value; defined after the binding below |
| CSubstOne | The one-slot substitution as a slot map |
| CPred | A relational predicate built at run time: comparisons of terms and their connectives; defined after the binding below |
| CSlots | The slot algebra: the slots a term or a relational predicate mentions, as a bit mask (bit i for π_i, bit 0 for the unary π). A node mentions the union of its legs' slots; a predicate the grammar does not know mentions every slot, so no certificate reads more into it than it says |
| COn | The carrier a rule is stated for, as a tag. A rule admits(On<C>, key, divisor_is_constant) says that the operator key is in the signature of C: a symbol one of the carrier's certified varieties has. It is declared in this namespace beside the certificate and found by ADL, so it is in force where that module is imported: the comparisons beside the partial orders (order:poset), // and % beside IsDividableChain (order:completeness), a field's / beside IsField (algebra:field); + - * and == != here, whose certificates are category's. Without a rule an operator is not in the signature |
| CFieldDivision | The two divisions Python tells apart, as keys: a field's, and the Euclidean one of an ordered carrier with remainder. The typed grammar's std::divides<> is the carrier's own, admitted where either is |
| CEuclideanDivision | |
| Crel_key | A comparison's key: the standard functor it is |
| Crel_key< Rel::Lt > | |
| Crel_key< Rel::Le > | |
| Crel_key< Rel::Gt > | |
| Crel_key< Rel::Ge > | |
| Crel_key< Rel::Eq > | |
| Crel_key< Rel::Ne > | |
| Cnot_admitted | Refused at the carrier: an operator not total there, a division by a term, an order comparison on an unordered carrier, a slot the points have not. Raised when a term built at run time is bound |
| Cpoint_sorts | The sorts of a point type: the carriers of its coordinates, each once. A carrier value has one sort; a pair of two carriers two (one where they agree). A term built at run time names no carrier until it is bound, and every node then has a sort: a projection its slot's, a constant its context's, an operator its operands' common one, a comparison 𝔹 |
| Cpoint_sorts< std::pair< A, B > > | |
| CRow | A row: a point of an n-ary product whose arity and columns' sorts are data. Each cell is a value of one of the carriers Cs, and the cell's alternative is its column's sort, so a row is its own schema. Slots are π_1 … π_n |
| Cpoint_sorts< Row< Cs... > > | |
| Cwith_carrier | The tuple S with C appended, unless C is in it already |
| Cwith_carrier< std::tuple< Cs... >, C > | |
| Cvalue_sum | The value of a term built at run time at a point: the one sort's carrier, or the sum of the sorts where there are more |
| Cvalue_sum< std::tuple< A > > | |
| Cvalue_sum< std::tuple< A, B, Cs... > > | |
| CReadAs | The coordinate slot of the point p, read in the sort C the dispatch chose; the point itself for the unary π |
| CEmbedsAt | Whether the sort b embeds into the sort a, at points of P |
| CFrom | |
| CConstantAs | A constant read in the sort C: a numeral cast into it, a constant of a sort (a bool, a Ternary) read in its own and embedded |
| CValue | The value algebra: a term or a predicate folded at the point p. A projection reads its coordinate, a constant is its value, a predicate the grammar does not know is evaluated as itself; an operator or a comparison combines its operands in the carrier of the non-constant one; an applied arrow converts its argument into its domain |
| CVerdict | |
| CFiniteSort | Whether a sort is a finite chain, enumerated exactly |
| CSearch | |
| CBound | The result of a binding: nothing but the checks that ran |
| CBind | The binding algebra at the points X: a constant beside a term (a, b of an operator, a comparison or a conditional) meets the term's carrier now; a constant under an arrow meets the arrow's domain. A leaf binds trivially |
| CPinConstant | A numeral read in the sort C and written back as a constant of that sort, through lift; a carrier lift has no constant for keeps the numeral |
| CDefinition | A slot's definition: the term t of a conjunct π_slot == t (or t == π_slot) with t free of the slot, and the conjunction without it. ∃π_slot. P is then the rest with t for π_slot: the existential is eliminated by substitution. Dually, under ∀ a disjunct π_slot != t defines it: ∀g. (g ≠ t ∨ Q) ≡ Q[t/g] |
| CNoConstants | No carrier value as a constant: the lift that names nothing, so eliminate_quantifiers eliminates by definition alone and leaves every quantifier over a chain to the search |
| CChainValues | The values of a finite chain as constants, through lift: the cases of Shannon's expansion; none for any other carrier |
| CShiftDown | The slots above an eliminated bound slot, moved down by one |
| CCondSplit | A term with its first conditional taken out: the condition, and the term with the conditional replaced by each branch |
| CTotal | The totality algebra at the points X: a node is total when its legs are, and an operator when it is admitted on its carrier (admits, the gate the value algebra enforces: total there, or dividing by a nonzero constant), an applied arrow when the arrow is total and its argument already has the arrow's domain (a conversion may fail). A predicate the grammar does not know is not certified |
| Cgraph_atom | π_2 == t, or t == π_2, with t mentioning only the first slot: the graph of the function x ↦ t(x). term is t |
| Cgraph_atom< Cmp< Rel::Eq, T, Projection< 2 > > > | |
| Cgraph_atom< Cmp< Rel::Eq, Projection< 2 >, T > > | |
| CMentionsSelf | The self algebra: a term or predicate mentions the set under definition when one of its leaves is a χ node; every node passes it up |
| CProjection | The projection π_k: the k-th component of a product |
| Norder | |
| Ndetail_interval | |
| CAsInterval | A piece as the interval it is |
| Ndetail_steps | |
| COpaque | Not a step source: a leaf the run lists do not read (an opaque predicate), or a node over one |
| CSteps | The normal form of a set term as the algebra of cata: an interval's sides, a stored run list read in place, the boundaries as constants; a meet or join the merge of its legs' steps under ∧ or ∨, a complement their relabelling by ¬. Lazy: nothing is stored, the steps are pulled by the query that reads them |
| Ndetail_cover_witness | |
| CWalk | A walk along the cover: where it is, and whether it met b |
| CStepToward | One successor step of a walk that looks for b |
| CAgreesFrom | For a fixed a, every b agrees: a < b iff reached |
| CAgreesOn | Every a in the window agrees with every b |
| Ndetail_halfspace_witness | |
| CUnrelatedCardinalityAlias | |
| Ndetail_runs | χ(x): the value of the last step at or before x |
| CAnd | The species' operations as named functions on L::Ω |
| COr | |
| CRfl | |
| CIff | a ⇔ b in the species: both, or neither |
| CLiftInto | A value lifted along the dominance into the species J |
| CAtLeast | Whether a value reaches a level, and whether it is the level: the α-cut and the fibre, pointwise |
| CEqualTo | |
| CMapValue | A step with its value mapped into the species L2 |
| CSameValue | Two steps with one value; the first step of a chunk; a step at a given value: the parts of dropping repeats |
| CFront | |
| CValueIs | |
| CToItself | An element as the step to its own value: χ = id |
| CNotPast | A step at or before x: its position is not past x |
| CLastValue | The value of the later step: a fold that keeps the last one |
| CFoldPieces | The species' fold of the values over the carrier's own pieces: a step before every element sets the first value, one after every element ends the fold |
| CState | The value of the piece being read, and the fold of the pieces before it, none before the first piece inside the carrier |
| CNotAfterAll | A step inside or below the carrier: the fold ends at the first one above every element |
| CClosed | A piece of a discrete chain with ends, read closed: a canonical start is just below its first element, an end just below the element after its last; an absent side at the carrier's end |
| CToStep | A breakpoint of a map as a step |
| CMapSteps | A sorted map of breakpoints as a source |
| Ndetail_connective | |
| COfKind | Whether a predicate is of the kind k (a bound to fold) |
| CStructurallyBefore | a before b in the structural order |
| CStructurallySame | a and b the same tree (equivalent in the structural order) |
| CInterval | A convex subset of a chain as a VALUE — an interval: each side an optional Bound, with a runtime-evaluable membership χ. Closed under ∩; a union or a complement leaves it unless one operand covers the other. No side is the universe; both sides closed at one value is a point; no Span at all is the one empty set, to which crossing bounds normalise. The bounds ride as values, never as NTTPs. Consume it through &, |, ==, <=, membership and the half / point / empty / universe / bounded factories |
| CProductRestrict | The product's own membership conjoined with a relational restriction, so a bind over a restricted product keeps that membership and cannot admit pairs outside it (a full product contributes a trivially-true product) |
| CInSlot | \(\pi_I^{-1}(S)\): the cylinder of a set S on axis I of a pair, a relational predicate |
| Cbit_subset_eq | Integral carriers under the bitwise Boolean algebra (#710) |
| CSub | Sub(C) for an ordered carrier: a subobject reified as a runtime interval value. Bounds are C values with ±∞ (unbounded) flags and an empty flag; the convex families coerce in via the converting constructors below (which also are the 𝔓 gate — no constructor ⇒ no Sub(C)). Folds onto SetExpr (so it is itself a first-class IsSubobject / IsSet) and is std::regular, so Set<Sub,…> is an IsSet and Sub values are usable in generic set APIs |
| CSubsetOf | The membership predicate of 𝔓(S): \(X \mapsto X \subseteq S\), with S coerced to Sub(C). A named functor (no lambda) |
| Ccarrier_cardinality | Cardinality class of a halfspace's carrier T (#848/#927) |
| Ccarrier_cardinality< T > | |
| CBound | One side of an interval as a value: the bound and whether it is attained (non-strict) or not (strict) |
| CSpan | The sides of an inhabited convex set; an absent side is unbounded |
| CPosition | A position on the chain: just below at, or just above it |
| CStep | Where the value changes, and to what. A source holds its steps by value (an interval's two sides, an iterator's current step), so the carrier and the truth values are default-initialisable |
| CSpanSteps | An interval's sides as a source, valued value on it and ⊥ elsewhere: at most two steps. No sides is the whole carrier, no span the empty set, so the constants are spans too |
| CRunListSteps | Pst's run list (category:runs) as a step source: each of its steps the position just below it, the value from there on alternating from outside. Where both apply, on a finite chain with Boolean values, the order's run lists read it as any source, so ext, the merges and the cuts take it; the vocabulary they share is to move into category (#1138) |
| CAsStep | The i-th step as the order's: below its position, in where i is even |
| CSourceRef | A source read through a reference: a stored run list inside a term is traversed where it is, not copied |
| CRelabelSteps | A source with every value relabelled into the species L2: a complement, a lift into a wider species, an α-cut |
| CMergeView | The steps of two ranges merged along the chain, each read as f of the two values there: the one lazy merge C++23 does not ship. A forward view; repeats are dropped by the caller |
| Citerator | |
| CMergeSteps | Two sources merged along the chain under a pointwise operation: the steps of both, each read as f of the two values there |
| CIdentitySteps | χ(x) = x on a finite chain, valued in the chain's own species: a step at every element above the least (none on a one-element chain) |
| CPiece | A piece on which a two-valued source holds: a start (nullopt below every element) and an end (nullopt above) |
| CPiecesView | The pieces of a two-valued source over the carrier, in order: its steps read in enter / leave pairs, a step outside the carrier read as the carrier's end. A forward view |
| Citerator | |
| CRun | A maximal run of membership as its closed ends, [lo, hi] |
| CRuns | A set of the chain V valued in L, materialised: its breakpoints, each the value from that position on, and the value before them. The one stored form, for a value that must outlive the term it was read from (a Python handle); a source like any other, its steps a view of the map |
| Cchain_view | |
| Nanalysis | |
| CDual | Represents f(x) + f'(x)ε |
| CTwoForm | An antisymmetric bilinear form ω(u, v) = -ω(v, u) |
| COneForm | The cotangent vector (The 'Gradient' components) |
| CHarmonicOscillator | Concrete Hamiltonian carrier for the 1-D harmonic oscillator |
| CGaussianKernel | Gaussian radial basis function (RBF) kernel |
| CReproducingKernel | |
| Ngeometry | |
| CFiniteDim | |
| CCountablyInfiniteDim | |
| CVector | An element of a Coordinate Space over a Field F |
| CFunctionalVector | A vector-like object defined by coordinate evaluation x[i] |
| CLatticeFactory | Factory for unbounded lattice discretizations by set species |
| CLatticeFactory< NaturalLatticeSet > | |
| CLatticeFactory< 𝔸< I > > | |
| CLinearMap | A dense compile-time-sized linear map F^Cols -> F^Rows |
| CDifferentiableMap | A finite-dimensional map paired with a user-supplied Jacobian witness |
| CTangentBundlePoint | A point in the tangent bundle T(F^N) = F^N × F^N |
| CCotangentBundlePoint | A point in the cotangent bundle T*(F^N) = F^N × (F^N)* |
| Nieee | |
| CApprox | Approximation envelope for an IEEE value |
| CReportErrorPolicy | Report policy: keep value and attach an error envelope |
| CIgnoreErrorPolicy | Ignore policy: run fast lane and drop all diagnostics |
| CAdaptiveErrorPolicy | Adaptive policy: respond to risky regions via ternary status |
| CIEEE | IEEE effect wrapper: values interpreted under machine IEEE semantics |
| CIEEEAdd | Certified operation token for addition under IEEE-by-fiat semantics |
| CIEEEMul | Certified operation token for multiplication under IEEE-by-fiat semantics |
| Nlinear_algebra | |
| Ndetail_diag | |
| Clinear_rule_int | |
| Cconst_rule_three | |
| Cconst_rule_six | |
| Crule_one_two | |
| Ndetail | |
| CComplexToMatrix2x2Hom | |
| CDualToMatrix2x2Hom | |
| Ndetail_transfer | |
| CQuadDiagRule | |
| CEdgeSucc | The path DAG's edge relation i → i+1, a NAMED predicate carrier (un-lambda'd, so it is a typed relation the DSL converse and relation traits attach to) |
| CWeightedUnitPath | |
| CCyclicShift | |
| CStaticRankNullity | Convenience compile-time carrier for finite-dimensional witnesses |
| CColumnOrientation | Tag for column-oriented 1-tensors (vectors in the usual sense) |
| CRowOrientation | Tag for row-oriented 1-tensors (covectors, linear functionals) |
| Cdual_orientation | The dual (opposite) orientation — the type-level column↔row flip the transpose / dagger of a 1-tensor performs (a Ket becomes a Bra and vice versa) |
| Cdual_orientation< ColumnOrientation > | |
| Cdual_orientation< RowOrientation > | |
| Cdim_finite | Type-level witness for a finite dimension N. Sibling of dedekind::sets::ℵ<N> on the infinite side; together they cover the dimension axis used by Diagonal / OuterProduct without forcing the std::variant<> Cardinality value to appear as an NTTP |
| CDiagonal | Diagonal matrix carrier M: D dimension D and diagonal rule F |
| Cidentity_rule | Identity rule: i ↦ T{1}. IsArrow witness for the constant unit |
| Czero_rule | Zero rule: i ↦ T{0} |
| Cone_hot | The one-hot / basis vector e_k : j ↦ δ(j,k) = [j=k] (T{1} on its own index k, T{0} elsewhere) — a 1-arg IsArrow, the k-th COLUMN of the identity Identity (the Kronecker δ with one leg fixed; Diagonal 's entry is δ_ij·F) |
| Cdiagonal_product_rule | The componentwise rule (F·(i) = F(i) · G(i) |
| COuterProduct | Rank-1 matrix M = u][j] = u(i) product taken in a semiring |
| CInvertible2x2 | Full-rank 2×2 matrix with entries as non-type template parameters |
| CMatrix2x2 | General (possibly-singular) 2×2 matrix with NTTP entries |
| CDirectSum | Direct sum of two invertibles — the trivial compositional preserver |
| CBlockUpperTriangular | Block-upper-triangular matrix — Tier 2 of #366, the degenerate-Schur case where the lower-left block is zero |
| CMatrix2x2V | Value-level 2×2 matrix — the runtime companion to NTTP Matrix2x2 |
| CMatrix2x2Map | f on every entry: the matrix2x2_functor's action on an arrow, an endomap of the entries applied entrywise |
| Cmatrix2x2_functor | |
| CMatPlus | Mat(S)'s additive monoid ⊕: elementwise base-⊕ |
| CMatTimes | Mat(S)'s multiplicative monoid ⊗: the ⊕- c_{ij} = ⊕_k a_{ik} ⊗ b_{kj} (matrix multiply) |
| CSemimoduleVec | An N-entry semimodule vector over the semiring S, read as an index→scalar arrow. IsColumnVector / IsCovector by the default (semimodule) contract: ⊕ and the two-sided scalar ⊗ action, but no negation (a dioid has none). Ket (ColumnOrientation, |v⟩) and Bra (RowOrientation, ⟨w|) are its two orientations — the bra·ket language of :transfer made first-class carriers, the "matrix column/row @b is a vector" slogan for a semiring. One carrier, orientation as a template parameter (the tag is the only difference between a column and a row) |
| CMatNxNV | Mat(S): the N×N matrix over a semiring S. Entries are stored row-major; ⊕ / ⊗ are S's semiring operations, read off dedekind::algebra::semiring_ops (never native operator+/ which the tropical carriers skew) |
| CTransposeF | The transpose reified as a dagger functor: TransposeF{}(A) = Aᵀ. A value/type (not a free call), so the point-free dedekind::category dagger predicates and concepts (is_unitary, IsDagger, IsUnitary) can take it as their Dagger argument. On Mat(S) the dagger is the transpose; on Rel it is converse; on a Hilbert space the adjoint — :involution unifies the three |
| CScaled | The scalar ⊗-action on an arrow f : D → S: \((c \odot f)(x) = c \otimes f(x)\). An IsArrow (the scaled vector), carrying the scalar c and the arrow f |
| CPointwiseSum | The pointwise ⊕ of two arrows over a shared domain: \((f \boxplus g)(x) = f(x) \oplus g(x)\). An IsArrow (the sum vector) |
| CReflected | Reflect an arrow through the origin of its domain: \((U f)(x) =
f(-x)\) — the parity operator U precomposed onto f. The third intensional combinator (beside Scaled / PointwiseSum) that completes the surface: with them it ASSEMBLES the even projector \(P = \tfrac12(I+U)\) as scaled(½, pointwise_sum(f, reflected(f))), rather than hand-rolling pointwise + and scalar ·. Requires the domain to carry unary negation (found by ADL on the domain type) |
| CVec2 | Structural 2-tuple with coordinates at the type level |
| CCovec2V | Value-level row vector (covector) of length 2, viewed as a 1×2 matrix |
| CVec2V | Value-level column vector of length 2, viewed as a 2×1 matrix |
| CArrowView | Named-pair view via operator-> |
| CVec2Map | f on every entry: the vec2_functor's action on an arrow, an endomap of the entries applied entrywise |
| Cvec2_functor | |
| CCovec2Map | f on every entry: the covec2_functor's action on an arrow, an endomap of the entries applied entrywise |
| Ccovec2_functor | |
| CDual | Represents f(x) + f'(x)ε |
| CComplex | |
| Nmorphologies | |
| Nsingleton_image_breadcrumb | |
| CSuccessor | 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 |
| Nfirst_iso_mod_2 | |
| Cmod_2_arrow | The parity homomorphism mod_2: int → bool |
| Cconnector | Hand-rolled iso connector Modular<2> → bool |
| Cconnector_inv | Inverse direction: bool → Modular<2> |
| CCauchyPath | |
| CCyclicRing | Minimal int-backed \(\mathbb{Z}/N\mathbb{Z}\) carrier from the experimental reintegration phase. Retained for parity with the existing test; Modular<N> below is the broader (auto-typed N) replacement |
| CModular | \(\mathbb{Z}/N\mathbb{Z}\) as a total finite cyclic ring |
| CCongruence | The residue-class predicate \(x \equiv R \pmod N\): the characteristic map of the fiber of the reduction \(\mathbb{Z} \twoheadrightarrow \mathbb{Z}/N\mathbb{Z} =\) Modular<N> over the residue R |
| CModularCongruence | The binary congruence relation \(x \equiv y \pmod N\) on the integer carrier: the kernel of the reduction \(\mathbb{Z} \twoheadrightarrow \mathbb{Z}/N\mathbb{Z} =\) Modular<N> |
| Csafe_float | Finite IEEE-754 subset: the finiteness invariant makes the order total, so (unlike raw F) this carrier reflexively compares |
| Nnumbers | |
| Ndetail_rational | |
| Cis_rational | |
| Cis_rational< Rational< Z > > | |
| CReachPath | The reach indicator's type: a Path<Ternary> monotone in {Unknown, True} (True absorbs), constructible only through collatz_reach_path, which guarantees that shape; registered absorptive in sequences below, as :mandelbrot's DivergencePath is |
| CComplex | |
| CPartialAddComplex | Partial addition transform for Complex<R> |
| CPartialMulComplex | Partial multiplication transform for Complex<R> |
| CUnitRoot | A SYMBOLIC N-th root of unity \(\zeta_N^{\,p}\), carried by its exponent p ∈ ℤ/N (Modular<N>). The unit harmonics \(\mu_N=\{z:z^N=1\}\): the torsion subgroup of the unit circle U(1), cut out of ℂ, cyclic of order N and \(\cong\mathbb{Z}/N\) via de Moivre |
| CCharacter | The de Moivre CHARACTER \(\chi_m : \mathbb{Z}/N \to \mu_N\), \(k \mapsto \zeta_N^{\,mk}\) — the plane wave "as such", carried SYMBOLICALLY in UnitRoot<N> (consumes the μ_N layer; resolve() collapses to exact ℂ at N=8) |
| CDiscreteCos | The exact discrete COSINE \(\cos_N(k) = \cos(2\pi k/N) =
\Re\,\zeta_N^k\) over the Modular<N> angle — the EVEN part of the de Moivre character (= the \(\tfrac12(I+U)\) projection's real value) |
| CDiscreteSin | The exact discrete SINE \(\sin_N(k) = \sin(2\pi k/N) =
\Im\,\zeta_N^k\) — the ODD part of the character (Im of character<N>(1) resolved). An IsArrow Modular<N> → ℝ, exact at N=8 |
| CCut | A decidable Dedekind real: a principal rational cut or a rational radical \(\pm\sqrt{c}\) |
| CLowerCut | The datum of a real's lower set: the real itself, χ(q) = real.contains(q) |
| CLatticeFactory | Primary template for lattice factory values |
| CLatticeFactory< ℝ_d, 1 > | Lattice factory specialization for ℝ |
| CLatticeFactory< ℝ_d, N > | Lattice factory specialization for ℝ^N, N > 1 |
| CDivergencePath | The escape signal of a Mandelbrot orbit, tagged as a sequence-shape witness: a monotone {Unknown,True}-valued Path<Ternary> that is structurally absorptive for every parameter c |
| CQuadraticReal | A real of \(\mathbb{Q}(\sqrt D)\): \(a+b\sqrt D\) |
| CQuaternion | Hamilton's hypercomplex numbers q = a + bi + cj + dk |
| CRational | The Field of Fractions over an Integral Domain Z |
| CPartialAddRational | Partial addition transform for Rational |
| CPartialMulRational | Partial multiplication transform for Rational |
| CHonestDivRational | Division transform for Rational |
| CPartialEmbedIntegerToRational | Identity and Associativity traits for Rational arithmetic |
| CEmbedRationalToReal | The field embedding \(\mathbb{Q}\hookrightarrow\mathbb{R} =\mathbb{Q}(\sqrt2)\), \(q\mapsto q+0\sqrt2\) |
| CInterval | A convex subset of a chain as a VALUE — an interval: each side an optional Bound, with a runtime-evaluable membership χ. Closed under ∩; a union or a complement leaves it unless one operand covers the other. No side is the universe; both sides closed at one value is a point; no Span at all is the one empty set, to which crossing bounds normalise. The bounds ride as values, never as NTTPs. Consume it through &, |, ==, <=, membership and the half / point / empty / universe / bounded factories |
| CComprehension | |
| C𝔸 | The universal set over the carrier T: the terminal object ⊤ of Sub(T), the reified type constraint |
| CMember | Member-shape mirror of Subobject's: every element of T is a member of U via the always-True classifier; the wrapper carries the T-value the IsSubobject contract reads back through ι |
| Nsequences | |
| Ndetail | The interval ↔ iota_view bridge: order's Interval<T,L>, a value, read as the half-open std::ranges::iota_view [start, bound), and back, as a total inverse |
| Ctoy_countable_family | |
| CIotaBounds | The [start, bound) iota_view bounds a finite value set normalises to (shared between to_iota_view and from_iota_view): the Interval / Singleton / Empty kinds of a Interval, read off its value endpoints. An unbounded kind (Halfspace / Universe) has no finite range and yields the empty bounds; a per-arm overload will refuse it once the set is a coproduct (#970) |
| Ndetail_pst | |
| CToMembership | An element of the walk as the step to its membership, ⊥ past the window's top |
| Ndetail_pst_witness | |
| CRun | A maximal run of membership as its closed ends, [lo, hi] |
| Ndetail_relprod | The composed predicate for \(R;S\) over the finite ℕ-prefix \([0,M)\) middle. Carries M (so the bound survives repeated squaring) and the two operand IsRelPredicate operands. The \(\exists\)-over-the-middle is the short-circuiting std::ranges::any_of over a lazy iota generator: it advances only to the first witness \(b\), so a hit returns immediately ( \(\top \vee
x =
\top\)) — O(1) memory (no bool accumulator threaded), O(M) steps worst-case, no array |
| CIsMiddle | Whether b is a middle for \((a, c)\): \(R(a,b) \wedge
S(b,c)\), with b the i-th element of ℕ |
| Ccarrier_regime | The regime of a carrier for the limit-collapse: Boole when the carrier declares a countable cardinality_type (ℵ_0 / Finite), Kleene when it is uncountable or declares none (the continuum, or a non-cardinality'd primitive such as double). This is a cardinality question (Specker's theorem is about enumerability), not a species one |
| Ccarrier_regime< C, std::void_t< typename C::cardinality_type > > | |
| COrbitSequence | The orbit sequence n ↦ Opⁿ(generator) of a carrier (T, Op), reified as a distinct IsSequence type |
| CSuccessorOrbit | The orbit of a seed under the NNO step, \(n \mapsto S^{n}(a)\): the unique morphism the universal property gives from ℕ into the carrier ( \(f(0) = a,\; f(n+1) = S(f(n))\)), as a sequence — the unfold iterate(a, Successor<N>{}) named, so the sequence-shape traits can attach to it. Its shape classifies the carrier's posture at the bound: an injective infinite stream on an unbounded chain (the NNO proper), monotone and bounded on a saturating one — eventually constant at ⊤ when the chain is finite (K₃, IsAbsorptiveSequence), converging to ℵ₀ without reaching it on ℕ's proxy — periodic on a wrapping one |
| CCurve | A continuum-indexed family γ: I -> T |
| CFiniteNet | A finite net: a tabulated morphism size_t → X (an IsNet, since std::size_t is a directed set). Read as a function d(v); the std::array tabulation is private business, not the interface |
| CFiniteSeq | A finite sequence: an array-backed range of length n ≤ Cap — the compile-time extensional realization of a sequence |
| CPath | A sequence F: ℕ → T |
| Cconst_iterator | |
| CSequenceGraph | as_relation(path) — adapt a Path<T> into its graph relation, a Set of (index, value) pairs |
| CScanSteps | The normal form of s on the window [lo, hi], by exhaustion: a step source that walks the window (and the element after it) along chain_view and steps where χ changes, ⊥ outside the window. Lazy: one walk per traversal, nothing stored |
| CBoundedSet | The value-semantic comprehension \(\{x \in \mathrm{dom} \mid
P(x)\}\) over a finite domain: an argmax result (or any refinement of a bounded interval), carrying both the interval (the finite range ext scans via to_iota_view) and the refinement predicate P |
| CDominanceRefinement | The dominance-refinement predicate of an argmax: x is optimal iff no member x' of the (finite) domain beats it under order∘cost, i.e. \(\forall x' \in \mathrm{dom}.\ \mathrm{order}(\mathrm{cost}(x'),
\mathrm{cost}(x))\). A named functor rather than a capturing lambda, so the refinement is an inspectable type carried in the BoundedSet signature argmax returns — the ∀-filter made visible at compile time |
| CIotaIntersection | std::ranges::iota_view as a Form-chain object: an order::IsOrderMeetSemilattice under subset-inclusion, with intersection as the meet |
| CComposePrefixPred | |
| CTailEquivalent | The tail-equivalence relation on Path<T>: agreement on a sampled tail window [start, start+span) |
| Classo_presentation | Opt-in finite-state ("lasso") presentation of an eventually-periodic sequence: a prefix of length pre_period followed by a cycle of length period (s(n) = s(n+period) for all n ≥ pre_period). The primary carries no presentation; a witness specialises it with the finite (pre_period, period) data — the engineer's honesty obligation (the presentation cannot be computed in general). Absorptive ⇒ period = 1; periodic ⇒ pre_period = 0 |
| CØ | ∅: The Initial Object. Extensional (Size 0) |
| CMember | Member-shape mirror of Subobject's. Vacuously inhabited (Ø has no members) — but the wrapper type is still required so the IsSubobject contract has a Member-to-T projection to read through ι |
| C𝔸 | The universal set over the carrier T: the terminal object ⊤ of Sub(T), the reified type constraint |
| CMember | Member-shape mirror of Subobject's: every element of T is a member of U via the always-True classifier; the wrapper carries the T-value the IsSubobject contract reads back through ι |
| Cchain_view | |
| CComprehension | |
| Noptimization | |
| CEdge | A directed edge of the graph: tail → head (node indices) |
| CRelax | Fold step of the single-source semiring closure: relax the potential at e.head through the edge e, d(v) ← d(v) ⊕ d(u) ⊗ c(u,v) |
| CCriticalPathState | Fold accumulator of annotate: the transient potential net paired with the critical-path predecessor map it induces |
| CCriticalPathStep | Fold step of annotate: relax through e and, when the candidate wins the (selective) join, record e.tail as e.head's predecessor |
| CHalfspace2D | 2D halfspace a·x + b·y ≤ c, entries as NTTPs |
| CHalfspaceTriple | Value-level halfspace carrier (a, b, c) for the bridge kernel. Paired with the NTTP carrier Halfspace2D: an instance of Halfspace2D<T, a, b, c> destructures into a HalfspaceTriple <T>{a, b, c} for the uniform value-vector the kernel consumes. The two structures share one role — the halfspace — split across the type/value boundary the bridge straddles |
| CVertexCandidate | Reduction output: optimum coordinates with a feasibility flag |
| CLPSolutionPredicate | :expressions predicate carrying the LP's runtime optimal locus as (point, feasible) value-level state |
| CSingleton2DPredicate | :expressions predicate for the LP's unique optimal vertex at NTTP coordinates |
| CPolytope2D | Polytope context: the (cx, cy, Hs...) pack reified as a type |
| CHalfspace2DPredicate | :expressions predicate for one 2D halfspace a·x + b·y ≤ c |
| CPolytope2DPredicate | :expressions predicate for the meet of N 2D halfspaces: a polytope as a single conjunctive predicate, with the halfspace pack carried at the type level so downstream combinators (argmax , and anything else dispatching on the polytope's structure) can extract it |
| CLinearFunctional | Linear functional U : F → T with NTTP-typed coefficients. Carries the objective as type parameters so argmax can call the NTTP-driven implementation detail::maximize_set directly without smuggling the values through function parameters |
| CFiniteNet | A finite net: a tabulated morphism size_t → X (an IsNet, since std::size_t is a directed set). Read as a function d(v); the std::array tabulation is private business, not the interface |
| CFiniteSeq | A finite sequence: an array-backed range of length n ≤ Cap — the compile-time extensional realization of a sequence |
| CVec2 | Structural 2-tuple with coordinates at the type level |
| Nrelational | |
| Ndetail_hyperdoctrine_witness | |
| CCode | |
| CSeven | |
| CCopy | Copy (comonoid comultiplication) Δ:A→A×A, a↦(a,a). The left adjoint of the meet; the fan-out of a cartesian bicategory |
| CInjection | 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) |
| CInject | \(\exists_{\iota_K}\): a set of the summand as the set of the sum that is it on its summand and empty on the other, kept as a sum (the strength reduction a | Ø → a is the inverse direction). The left adjoint of Restrict |
| CRestrict | \(\iota_K^{-1}\) as an arrow: the restriction, lifted into the sum's logic (a summand given in a smaller logic sits in the sum's by \(\Sigma \hookrightarrow \Omega\)). The right adjoint of Inject. Defined on every presentation restriction reaches: the sums, their lattice nodes, the boundaries |
| Ndetail_graph | |
| CAgreesAt | Whether r and the graph g agree on the pair (a, b) |
| CAgreesOnRow | Whether r and the graph g agree on every pair of the row a: ∀ b ∈ cod |
| Ndetail_rows | |
| CSortsSoFar | The step of a ∧ over a row's cells: the next cell has the next column's sort. The fold's state is the verdict so far and the column reached |
| CCellOfSort | |
| CAppendLeaf | The step of a fold building the factors of a product of carriers: one leaf more |
| CAppendColumns | The step of the fold reading an object's columns off its factors: a leaf's sort; a sum's tag, then its summands' columns |
| CAsConstant | as_constant as a visitor over a row's cells |
| CFirstSet | The step of a fold for the first index whose flag is set: the answer so far, or N while there is none |
| CIdentify | The step of the fold for identified: one equation more |
| CKept | The step of the fold checking a projection's columns: each in 1 … n and none twice. seen has n + 1 slots |
| CKeep | |
| CProjected | The step of the fold building a projection: the next kept column's sort, and its equation π_{n + j} == π_c |
| CProject | |
| CRanges | A slot map by three ranges: the domain's columns, the codomain's, and the slots past the arity (a factor's own bound slots) |
| CAtDefault | The step of the fold for at_defaults: the column i at its sort's default |
| CEncoded | The step of the fold for encodes: the predicate so far and the slot reached; a leaf moves one slot on, a sum asks that its tag pick a side and moves past its columns |
| CEncodeFactor | |
| CBindMiddle | The step of the fold binding a composite's middle: the i-th from the innermost, ∃π_{n + j} over the middle column j = m − i, so the outermost binds the first |
| CWithSlot | The step of the fold for column_mask: one slot's bit more |
| CDefined | The columns [lo, hi) as defined by p: per column the term of a conjunct defining it over the columns of others alone, landing in the column's sort (a K₃ term defines no 𝔹 column), and whether nothing else is asked (the residual ⊤). Nothing where a column is not so defined |
| CDefining | The step of the fold for defined_columns: the terms so far, the predicate left, and whether every column so far was defined |
| CDefineColumn | |
| CFibrePredicate | The reified fibre of a relation R at a point x: the predicate \(b \mapsto (x,b)\in R\). Named (the sibling of GraphPredicate / PreimagePredicate) so the fibre is stable and inspectable rather than a lambda blackbox (#840) |
| CSwapPred | The swapped predicate for converse: \(R^\smile(b,a) = R(a,b)\) |
| CComposePred | The composed predicate for the relative product \(R;S\) over a Boolean intermediate, the ∃-over-the-middle enumerated on {false, true} |
| CIntersect | The point-free composite meet R∩S = Δ† ∘ (R⊗S) ∘ Δ: copy the shared domain, run both legs in parallel, merge their codomain outputs where they agree. The arrow-level (spider) realisation of the relational intersection, whose (Copy,Merge) legs are certified by IsMeetAsRightAdjoint — the same R∩S the extensional operator& above computes over Set<pair>, spelled point-free |
| CDiagPred | 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 |
| CPairwisePred | 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) |
| CCoreflexivePred | The coreflexive predicate for \(\Delta_S = \{(x,x) \mid x \in S\}\) — the diagonal restricted to a unary set S (a partial identity): on the diagonal and in S. Carries S by value so it stays inspectable (no lambda) |
| CNodeAt | The engine at one node and one law, as a function of the law; the converse reads its operand at the dagger law |
| CGraphPredicate | The membership predicate of a functional graph \(\Gamma_f\): \((a,b)\mapsto b = f(a)\) |
| CGraphArrow | The arrow a function's graph atom names, the converse of graph: a relation A×B | (π_2 == t) certified a function is the arrow a ↦ t(a), t read at a pair whose first coordinate is a |
| CPreimagePredicate | The preimage predicate \(a \mapsto f(a)\in S\): the subobject S pulled back along the functional arrow f ( \(\chi_S\circ f\)) |
| CFixed | The arrow that fixes one factor of a pair: \(x \mapsto (c, x)\) (K = 1) or \(x \mapsto (x, c)\) (K = 2). Substitution along it is one case of Shannon's expansion |
| CPreimage | \(f^{-1} : \mathrm{Sub}(B, L) \to \mathrm{Sub}(A, L)\), substitution along \(f\): \(b \mapsto \{x \mid f(x) \in b\}\) (preimage, \(\chi_b \circ f\)). Total, a lattice homomorphism, monotone; the right adjoint of Image and the left adjoint of Dual |
| CDual | \(\forall_f : \mathrm{Sub}(A, L) \to \mathrm{Sub}(B, L)\), the dual image: \(a \mapsto \{y \mid \forall x.\ f(x) = y \Rightarrow x \in
a\}\), which is \(\neg\,\exists_f\,\neg\) (De Morgan: the logic is an Ockham algebra), a composite of three arrows on presented objects. The right adjoint of Preimage; monotone, as anti∘co∘anti |
| CImage | \(\exists_f : \mathrm{Sub}(A, L) \to \mathrm{Sub}(B, L)\), the image along \(f : A \to B\): \(a \mapsto f[a] = \{f(x) \mid x \in a\}\). Partial: defined where image_along eliminates the \(\exists\). Monotone; the left adjoint of Preimage |
| CFactor | A factor of an object: a carrier (a leaf, its sort the column's), or the sum \(X + Y\) of two objects (#1039). A sum lays out a tag column (𝔹: which summand), then the left summand's columns, then the right's; a row reads only the active side, so every column keeps one carrier |
| CObject | An object: a product of factors in normal form, a list. The product is associative with unit 1 (the empty list), so \((A \times B) \times C\) and \(A \times (B \times C)\) are the same object by construction, and >> composes regardless of grouping. Read as a binary tree, (first, rest), where a tree is asked for (kind / operands in Python). The columns are its factors' |
| CRelExpr | A relation \(A \rightsquigarrow B\) built at run time: a term over relations, its objects dom and cod data, its classifier a reading |
| CMember | |
| CLawSet | The relations certified the law W: a datum on the universe of relations, so 𝔸<Re>{} & Total<Re>{} is the set of total relations, membership its χ in K₃ (inferred, or not), and a map or an isomorphism a meet of such sets, nothing stored. Its χ obeys the facts the set is declared: closed under >>, so S(f) ∧ S(g) ≤ S(f >> g); a down-set or an up-set in ⊆; carried by ° to its dagger law. Its complement is never inhabited by inference (¬True, else Unknown): Σ, not Π |
| CCanonicalPairPredicate | |
| CComprehension | |
| C𝔸 | The universal set over the carrier T: the terminal object ⊤ of Sub(T), the reified type constraint |
| CMember | Member-shape mirror of Subobject's: every element of T is a member of U via the always-True classifier; the wrapper carries the T-value the IsSubobject contract reads back through ι |
| CRelAnd | Meet (conjunction) of two relational predicates, the result of && on them |
| CRelOr | Join (disjunction) of two relational predicates, the result of || on them, dual to RelAnd |
| Njlt | |
| CFactor | A factor of a count, \(b^e\): a base raised to an exponent |
| CFreeMonoid | 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 |
| CLetterMap | 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 |
| CLetters | 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") |
| CPower | 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 |
| CPowerMap | 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 |
| CReflectedReverse | ~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.) |
| CReflection | |
| CReverse | 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 |
| CRotation | 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 |
| CAutomaton | A matcher's plan: the transitions on each letter, and the states where a word of the set has just been read |
| CCommutativeRingRegistration | A ring whose multiplication is also commutative |
| CFieldRegistration | A commutative ring in which every non-zero multiplicative element is also invertible |
| CGaloisFieldRegistration | Extends FieldRegistration with the Galois-specific opt-ins: the carrier is declared a finite field of a given order |
| CRigRegistration | Base class for SpeciesTraits<T> of carriers forming a \emph{rig} (semiring) under (Add, Mult) with identities Zero (additive) and One (multiplicative) |
| CRingRegistration | A rig whose additive monoid is an abelian group (i.e. has additive inverses). Mult is not required to commute here; see CommutativeRingRegistration for that |