Skip to content

Speculative Collections Without Kernels

enumeratio edited this page Nov 15, 2026 · 1 revision

Collections without kernels

Speculative. A proposal, not adopted.

The Ideas page says many catalogued collections have a record and no declared head, and that a good share are numeric sets (Ideas.md:55). This page pins that down: which collections, what each would take to get a kernel (a count, an enumeration, or only membership), and in what order to do them. The answer differs from the idea's wording. The list is 71 long, only a handful are numeric sets, and about a third of the rows are not kernel work at all.

"Measured" means computed from the tree at origin/main, commit bfa63e225, on 2026-11-15, by a script kept with the design drafts (git-tracked files only; Python with PyYAML; nothing from the repository was built or run). "Assumed" means read from source or reasoned, not run. Nothing here was run through compute-engine; "declared" is a static scan plus one committed engine-derived golden (§1), and §Measured versus assumed says where the two could differ.

Recommendation

Treat the 71 as three jobs, not one.

  1. Clear what is not a kernel job (22 rows, plus 27 stale flags). Eleven rows duplicate a head that is already declared under another name or parameter; five are polytope values filed as collections; four are catalogue vocabulary; two are base sets compute-engine already declares. The 27 stale flags are declared heads whose record still says "no kernel". All of this is record editing, with a redirect for each retired page. It needs no engine change and shrinks the list to 49 before anyone writes a family.
  2. Do not declare the restrictions (5 rows); show them. Each is a declared collection filtered by a declared statistic. An anonymous Restricted(base, predicate) example on the base's page is a test and a doc, and the induced order is already the rule. Name one only when it earns it.
  3. Build families for the finite combinatorial rest (the 40 in bucket c) in order of how settled their order is. Start with the ones whose order is a value order or a plain lex on parts and whose count has an OEIS row: FareySequences, GoldbachPartitions, MultiplicativePartitions, OrderedFactorizations. Do not declare any whose order the carrier does not settle (SignedSubsets, Dissections; §Order of work).

The numeric sets are done for practical purposes: 85 of the 89 collections with the Numeric carrier are already declared.

What exists

  • A catalogued collection is a record with grades. collect-catalog-records.ts turns every such record into a COLLECTIONS row of the catalog registry (packages/reference/scripts/collect-catalog-records.ts:43). packages/entry/src/types.ts:415-425 says "presence is the kind": grades a collection, catalogCarrier a bare carrier, statOn/mapOn a statistic or map. 289 records have grades.
  • stub marks a record nobody wrote up. The schema allows engine and carrier (packages/entry/src/schema.ts:343, types.ts:437-442). ReferencePage.vue:381-382 renders a carrier stub outside the "Carrier domains" domain as "A name from the enumeratio catalogue with no kernel of its own yet; this page carries its crosswalk only." Of 3,096 records under packages/, 218 are stub: carrier (98 with grades, 81 with catalogCarrier, 39 neither) and 162 are stub: engine.
  • "Declared" is not a field. The manifest takes a head as declared by a signature row carrying library and type (packages/manifest/src/assemble.ts:184). Families are EpsilFamily entries declared by head:; carriers are Carrier records with a plural; compute-engine's own sets are bare engine symbols. The catalog registry asks the engine, never the data (packages/catalog/src/declare.ts:13-16).
  • A carrier's plural is already a membership-only collection. Every carrier with a plural gets it declared as a set<type> symbol, and Element(x, Plural) answers True for a value of that carrier, False for a value of another of ours, and nothing for anything else (packages/structures/src/carriers.ts:174-217). 92 of the 94 carriers have a plural; ContinuedFraction and QuadraticInteger do not. No count, rank or enumeration comes with it.
  • Three mechanisms give a collection a kernel. (1) An EpsilFamily with FamilyKernel/NumberKernel: count, unrank, rank, valid, positions in bigint (collections/src/families/types.ts:110-130). (2) For "the integers satisfying a predicate", the scan helper: a predicate plus a proven bound on the n-th member gives unrank, rank and membership; a set with no proven bound "has no definition here" (scan-definitions.ts:1-8, :60, :206). (3) A named restriction: Restricted(base, predicate) over a lazy Filter, with RESTRICTIONS a table of 19, 18 of which name a fast implementation (packages/structures/src/restriction.ts:43, :267-318; Restrictions §1: a restriction head means the induced order). declareRestrictions declares each as (integer) -> collection (restriction.ts:306), so a restriction with a second parameter does not fit the table.
  • Compute-engine's base sets are declared and are not ours. Primes is a declared constant; membership, no position (packages/reference/entries/Primes/index.md:3-9). Integers and NonNegativeIntegers are bare engine symbols (packages/boxes/src/make.ts:86, packages/cli/tests/table.test.ts:24).
  • @notatio/polytope declares no CE heads (packages/symbols/combinatorics/polytope/README.md:6); Permutahedron(4) and the others exist as frontend display symbols over a TypeScript Polytope (packages/frontend/src/symbols.ts:928).
  • No frontier list covers collections. packages/census/src/wolfram-frontier-data.ts ranks Wolfram call forms we cannot answer; packages/reference/src/backlog.json is empty ({}); the *-frontier.ts files in combinatorics are statistics and map gaps. The committed data that does list them is the explorer golden (§1).

1. The list

Rule. A collection has no kernel when its record has grades and stub: carrier, no signature row with library, and its name is not a head: or declare( literal in any non-test source file under packages/. Measured: 289 catalogued collections, 98 of them stub: carrier, 27 of those declared though flagged, 71 with no kernel.

Cross-check. packages/frontend/tests/explorer.test.ts builds an engine with combinatorics and structures declared, tries to open each of the 289 records as a table, and pins the result in packages/frontend/tests/explorer.golden.json (null for no table; components/docs/collection-explorer.md:21: "catalog-only, untyped, or not opening as a collection"). Measured on the committed golden: 212 open, 77 do not. All 71 are among the 77, and nothing the scan calls kernel-less opens a table. The other six nulls are declared heads that open no table in that engine: Permutations, PowerSet, RationalNumbers (compute-engine's own), PartitionAlgebra (a package that engine does not declare), and SelfConjugatePartitions and Surjections (declared, undocumented; why they open nothing is not determined).

What the 71 look like. None has a body or an examples.tsv. 49 carry the generated summary "Catalogued in the enumeratio database…" and 22 a hand-written one; 49 have crosswalk rows and 22 have none. 36 have an OEIS row. 30 are the plural of a carrier, so Element answers for them today and nothing else does. 15 are unbounded. All 71 have a published page (web/ledger.tsv, symbol rows such as line 2504, /reference/symbol/CubeFreeNumbers), so retiring one needs a redirect rule (Sites §3, web/.vitepress/redirects.ts).

Bucket n What the row is Examples
a 1 numeric set, membership predicate exists AmicableNumbers
b 1 image of a declared sequence PrimeGaps
c 40 carrier exists, no family FareySequences, Dissections, GaussianIntegers
d 2 no carrier CardinalNumbers, OmegaOrdinals
e 5 restriction of a declared collection by a declared statistic NarayanaNumbers, ConnectedLabeledGraphs
f1 11 duplicate of a declared head CubeFreeNumbers, StepCompositions
f2 5 polytope value filed as a collection Permutahedron, Cyclohedron
f3 4 catalogue vocabulary Collections, Traits
f4 2 compute-engine's own base set NaturalNumbers, IntegerNumbers

Bucket (a) in the strict sense, where an Is… head already exists for the set, is empty: the declared predicates IsPrime, IsPerfect, IsSquareFree all correspond to sets that are already declared (PrimeNumbers, PerfectNumbers, SquareFreeNumbers). Numeric sets by the carrier rule in the script (a number-valued carrier) are 14 of 71: one in a, one in b, seven in c, two in d, three in f. The 89 collections with carrier Numeric are 85 declared and 4 not (AmicableNumbers, CubeFreeNumbers, NaturalNumbers, PrimeGaps), so the Ideas page's "a good share" was true of an earlier tree and is not true of this one.

2. Bucket a and b: the numeric sets that are left

  • AmicableNumbers (a, loosely). AliquotSum is declared (number-theory/reference/AliquotSum), so membership is AliquotSum(AliquotSum(n)) = n and AliquotSum(n) != n: no Is head, but a predicate in declared heads. Count is an open problem and unrank has no proven bound, which is exactly the case scan-definitions.ts:1-8 excludes. So: membership only; Count is NaN if the owner keeps "declared open problem" for it.
  • PrimeGaps (b). The record says its elements are the primes, each addressed by the smaller prime of its pair, with the gap carried on each element (reference/entries/PrimeGaps/index.md, OEIS A000040 and A001223 notes). That makes it PrimeNumbers with a reading, not a new set; the gap sequence repeats values, so as a collection of gaps it breaks "a collection is a carrier plus one total order" over distinct elements. See open question 4.
  • CubeFreeNumbers is KFreeIntegers(3) (numeric-divisor.ts:290, :417, also in scan-definitions.ts); NaturalNumbers and IntegerNumbers are compute-engine's NonNegativeIntegers and Integers. All three are bucket f.

3. Bucket c: carrier exists, no family

40 rows; every carrier is a Carrier record (Numeric is compute-engine's own type). 30 are a carrier's plural, so the type space is declared and the missing piece is a count and an order. 10 are not (BoxConfinedPartitions, CalkinWilfPaths, ContinuedFractions, FareySequences, HyperbinaryRepresentations, Hypernumerary, LabeledForests, MulticomplexNumbers, SingletonSpecies, SumsOfTwoSquares): they are a grading or a parameter of a carrier whose plural is taken. Measured: 33 are finite graded fibres, 7 are number-valued (FractionalNumbers, GaussianFractionals, GaussianIntegers, GaussianRationals, ModularResidues, MulticomplexNumbers, SumsOfTwoSquares). 16 carry an OEIS row to check a count against; 14 have no external row at all, so the reference examples would be their only proof (PythagoreanTriples, EgyptianFractions, KDyckPaths, RationalDyckPaths, SquareDecompositions, …).

Two sub-groups matter for sequencing.

  • Order is settled by the carrier's shape or by value. A list of parts is lex (Restrictions §4). MultiplicativePartitions, OrderedFactorizations, KDyckPaths, KMotzkinPaths, RationalDyckPaths (the lattice-path family at lattice-paths/src/families/core.ts is the template) and FareySequences (increasing value) belong here.
  • Order is open. SignedSubsets and CrossPolytope's faces: the polytope code walks signs in the order 0, 1, -1 (packages/symbols/combinatorics/polytope/src/hypercube.ts, signedSubsets), which is not stated as a ruling. Dissections (a 0/1 word over diagonals), GaussianIntegers (a spiral is one total order of order type ω, row-by-row is not), IntegerFactorizations and FactoradicNumerals are the same kind of question.

SumsOfTwoSquares probably belongs in f1: PowersRepresentations(n, k, p) is declared (number-theory/reference/PowersRepresentations). Not checked against its examples.

4. Bucket d: no carrier

CardinalNumbers and OmegaOrdinals have only a catalogCarrier stub for Cardinal and OmegaOrdinal, no Carrier record, and compute-engine has no cardinal or ordinal type (assumed; I did not probe it). Both cite only mathlib4. A kernel here means first deciding to model transfinite numbers at all. A cardinal count is not an integer; OmegaOrdinals would be ω-ordered, which is where "an unbounded collection is an enumeration of order type ω" would hold by construction, but there is no carrier to enumerate. Recommendation: leave catalog-only.

5. Bucket e: restrictions

Each rests on a declared collection and a declared statistic (measured: the statistic's statOn lists the carrier).

Row Base Predicate Count check
NarayanaNumbers DyckPaths(n) Peaks(_x) = k (Peaks has DyckPath in statOn) OEIS A001263
LittleSchroderTriangle, SchroederTriangle SchroederPaths(n) Peaks(_x) = k, but what k grades is not checked A-numbers in the records
ConnectedLabeledGraphs LabeledGraphs(n) GraphComponentCount(_x) = 1 A001187 (in the record)
BoundedPartPartitions IntegerPartitions(n) LargestPart(_x) <= k, or IntegerPartitions(n, All, parts) with parts the first k integers A026820

The mechanism exists (Restricted, §What exists) and keeps the carrier, so every statistic already applies. The order is the base's induced order, which the wiki already rules. What does not exist is a named, parameterized restriction: RESTRICTIONS heads take one integer (restriction.ts:306). The cost of these five is therefore an example row each, not a kernel. A fast kernel (completion counts, Restrictions §2) is a later optimisation and needs the base's order to admit one.

6. Bucket f: findings

Each is a record to edit, with a redirect where a page goes.

f1, duplicates of a declared head (11).

Row Is
CubeFreeNumbers KFreeIntegers(3) (numeric-divisor.ts:417)
KPartPartitions IntegerPartitions(n, {k}) (record signature)
Weak3Compositions, WeakCompositionsIntoKParts WeakCompositions(n, 3), WeakCompositions(n, k) (compositions/src/families/core.ts:146)
SurjectionsOntoK Surjections(n, k), typed with two integers
StepCompositions FibonacciCompositions(n) (parts 1 and 2)
SparseSubsets FibStrings(n) (no two adjacent ones)
IndependentSetsCycle LucasStrings(n) (its own record note says "matching LucasStrings")
SternBrocotPaths BinaryWords(n) (record: "cardinality only; borrows binary_words")
KColoredPermutations ColoredPermutations(n, k) (record notes the swapped argument order)
BooleanAlgebra BooleanLattice(n) in incidence; an order structure, not a collection

f2, polytope values filed as collections (5): Associahedron, CrossPolytope, Permutahedron, Simplex, Cyclohedron. By the plural/singular ruling these are values; their face collections are SetCompositions(n) (declared), Subsets (declared), SignedSubsets (bucket c) and Dissections (bucket c). Cyclohedron has no object in @notatio/polytope at all.

f3, catalogue vocabulary (4): Carriers, Collections, Traits (carrier Text, no carrier record) and Glyphs, which is the type space of GlyphKind (packages/frontend/src/carrier-data.ts, plural GlyphKinds). The catalog registry and manifest already are these collections.

f4, base sets under a catalogue name (2): NaturalNumbers, IntegerNumbers.

Outside the 71, also in the data:

  • 27 declared heads still flagged stub: carrier, so their page says "no kernel of its own yet": ParkingFunctions, LabeledGraphs, Tournaments, SchroederPaths, SelfConjugatePartitions, Surjections, StandardTableaux and 20 more (printed by no_kernel.py). Their records still carry the generated "not yet written up" summary.
  • Singular or misfiled stubs: FubiniNumber and LittleSchroderNumber (singular twins of declared FubiniNumbers, LittleSchroderNumbers), Compositions (the type space of IntegerComposition; the collection is IntegerCompositions), FareySequence (a Wolfram head, undeclared, next to the collection stub FareySequences), and MultisetAdd, MultisetCard, MultisetLe, MultisetMem (mathlib4 functions, not collections).
  • PowerSet is a compute-engine head whose record says "alias of Subsets".

What a kernel means, per bucket

Bucket count unrank / rank membership Through
a, AmicableNumbers NaN at most none: no proven bound yes, from AliquotSum Element with a predicate; not a scan
b, PrimeGaps infinite from NthPrime if elements are positions needs an element decision a sequence head, not a collection (Q4)
c, order settled from the OEIS row or a table lex/value order, Epsil definition, fast kernel optional valid EpsilFamily (§What exists, 1)
c, order open do not declare do not declare Element on the type space (30 of the 40 already) nothing yet
d none none none no carrier; leave
e the base's count under the filter the base's induced order, by filtering Element of the filter Restricted (2), then a completion count if wanted
f n/a n/a n/a record edit

Each mechanism above is read from source; none of these specific kernels was written or run.

Order of work

Cheapest and largest by work saved: f (22 rows plus 27 flags, no code). Largest by remaining work: c (40).

Batch 1, one pull request, data only. Move the crosswalk rows of the 11 f1 duplicates and the singular twins onto the declared record, retire the stubs with a redirect each, remove the 27 stale stub: carrier lines, and regenerate packages/frontend/tests/explorer.golden.json (UPDATE_EXPLORER=1), whose keys for the retired names disappear. Proof: the golden diff is exactly the retired names; packages/reference/tests/catalog-records-migration.test.ts passes on the regenerated catalog data; web/ledger.tsv is append-only, so each retired page needs its redirect rule first (web/ledger.tsv:1-2). The f2, f3 and f4 rows wait for questions 2 to 4.

Batch 2, one pull request, restrictions as examples. For each of the five e rows, a Restricted(base, predicate) example on the base's record with expected pinned to the OEIS count at small n and known/source where the record has one (A001263, A001187, A026820). Proof: known.test.ts holds the example; no head is declared.

Batch 3, one pull request, four families: FareySequences(n) (count 1 + Σ φ(k), A005728, from the declared Totient; order is value order), GoldbachPartitions(n) (A045917; the singular GoldbachPartition is declared), MultiplicativePartitions(n) (A001055), OrderedFactorizations(n) (A074206). Each is a finite one-parameter fibre whose carrier and type space exist, with an OEIS row in its record. What proves them: the reference examples as snapshots, counts to the OEIS terms in the record, rank(unrank(r)) = r and the Epsil-versus-fast-kernel agreement test (tests/fast-kernels.test.ts, AGENTS.md). Cheapness here is assumed; I did not read the carrier or the sibling kernels for these four beyond their shapes.

Do not:

  • declare a head whose order the carrier does not settle: SignedSubsets, Dissections, GaussianIntegers, IntegerFactorizations, FactoradicNumerals. Every collection's At order is first-class, and changing it later is a break;
  • declare NaturalNumbers or IntegerNumbers beside compute-engine's own sets;
  • name the five restrictions or add a RESTRICTIONS entry with a second parameter before the table's signature (integer) -> collection is extended on purpose;
  • declare AmicableNumbers as a collection with a count: the count is an open problem.

Later: the remaining c rows by order status, then the number-valued sets (membership first), then the polytopes if the owner wants a value layer.

Open questions, with recommended answers

  1. Retire the f1 duplicates by deletion plus redirect, or keep them as aliases? Recommend delete and redirect, crosswalk rows moved to the target. The ruling forbids a singular or second name for a collection, and a second record is a second page that says "no kernel" about a head that has one.
  2. The five polytope rows. Recommend retire them as collections. Keep the polytope as a value in @notatio/polytope; if the owner wants Permutahedron(n) as an evaluable head, give it a value-constructor record and its own declare layer, separate from this list.
  3. The four vocabulary rows. Recommend retire; they duplicate the registry and the manifest, and Glyphs duplicates the GlyphKinds type space.
  4. PrimeGaps. Recommend retire the collection row and, if wanted, add a sequence head for the gaps: its elements repeat, which a collection of distinct elements does not allow, and the record already says the elements are the primes.
  5. NaturalNumbers and IntegerNumbers. Recommend retire in favour of compute-engine's NonNegativeIntegers and Integers (the ruling). Keep the mathlib4 and OEIS rows (A000027, A001477) on a record for the engine's name.
  6. Named parameterized restrictions. Recommend not extending RESTRICTIONS yet; use anonymous examples (batch 2) and extend the table when a second restriction needs the parameter. Reason: the table is the specification a fast kernel is tested against, and nothing here has a kernel to test.
  7. Membership on the type spaces for plain values (Element(3, GaussianIntegers) is unevaluated today, assumed from carriers.ts:204-211). Recommend yes for the number-valued carriers, as membership only. Reason: it is the ruling's floor and costs one predicate each, but only where the carrier is a number, so GaussianIntegers, GaussianRationals, FractionalNumbers.
  8. Page rule for stubs. Statistics-and-Maps.md:7 proposes stub pages go away for statistics and maps, and the working rule is a symbol page only for a declared head. All 71 collection stubs still have a published page. Recommend keep the pages until f is cleared, fix the banner for the 27, then apply the rule to what is left.
  9. Cardinals and ordinals. Recommend leave catalog-only; revisit only if a Lean-style Ordinal is wanted for its own sake.

Measured versus assumed

Measured (script, commit bfa63e225). 3,096 records read under packages/; 289 with grades; 98 of them stub: carrier; 27 of those declared; 71 not; the golden's 212 and 77, with the two sets related as stated; bucket sizes; carrier existence and plural for each row; 85 of 89 Numeric collections declared; counts of summaries, crosswalk rows, OEIS rows, ledger pages.

Assumed. Declared status for the scan is a literal match in source, so a head declared through a name built at run time (the PermutationsAvoiding… family is) would be missed; the golden agrees with the scan on all 71, which bounds that risk but was not rerun. The bucket assignments for a, b, d, e and f are my reading of each record and of the declared heads named; they are judgments, not computed. That Peaks, GraphComponentCount and LargestPart have the right meaning for the e rows is not checked beyond statOn. That the four batch-3 families are cheap is not checked. That compute-engine has no ordinal or cardinal type, and that Count of a carrier-plural symbol is unevaluated, are not probed.

The 71, in full

Columns: bucket; carrier; whether the name is a carrier's plural ("type space": Element answers on constructed values); u for unbounded; OEIS row; package; what the row rests on, for buckets other than c.

Name b Carrier Type space u OEIS Package Rests on
AmicableNumbers a Numeric u A063990 reference/entries AliquotSum is declared; amicable = AliquotSum(AliquotSum(n)) = n and AliquotSum(n) != n; no Is head, no proven bound for unrank
PrimeGaps b Numeric u A000040, A001223 reference/entries gaps of PrimeNumbers: NthPrime(k+1) - NthPrime(k); element identity open (a gap repeats)
AffinePermutations c AffinePermutation yes combinatorics
AscentSequences c AscentSequence yes A022493 combinatorics
BoxConfinedPartitions c IntegerPartition reference/entries
CalkinWilfPaths c BinaryWord A002487 reference/entries
CollatzTrajectories c CollatzTrajectory yes arithmetic/number-theory
ColoredMotzkinPaths c ColoredMotzkinPath yes A000108 combinatorics
ContinuedFractions c ContinuedFraction reference/entries
CorePartitions c CorePartition yes combinatorics
DecoratedPermutations c DecoratedPermutation yes A000522 combinatorics
Dissections c Dissection yes A001003 combinatorics
EgyptianFractions c EgyptianFraction yes arithmetic/number-theory
FactoradicNumerals c FactoradicNumeral yes u combinatorics
FareySequences c RationalNumber A005728 reference/entries
FiniteSetElements c FiniteSetElement yes combinatorics
Finsets c Finset yes u combinatorics
FractionalNumbers c FractionalNumber yes u arithmetic/numerals
GaussianFractionals c GaussianFractional yes u arithmetic/number-theory
GaussianIntegers c GaussianInteger yes u arithmetic/number-theory
GaussianRationals c GaussianRational yes u arithmetic/number-theory
GoldbachPartitions c GoldbachPartition yes A045917 arithmetic/number-theory
HyperbinaryRepresentations c HyperbinaryWord A002487 reference/entries
Hypernumerary c HypernumeraryWord reference/entries
IntegerFactorizations c IntegerFactorization yes u arithmetic/number-theory
KDyckPaths c KDyckPath yes combinatorics
KMotzkinPaths c KMotzkinPath yes A055151 combinatorics
LabeledForests c LabeledTree A000272 reference/entries
ModularResidues c ModularResidue yes arithmetic/residues
MulticomplexNumbers c Multicomplex reference/entries
MultiplicativePartitions c MultiplicativePartition yes A001055 combinatorics
OrderedFactorizations c OrderedFactorization yes A074206 combinatorics
PlaneTrees c PlaneTree yes A000108 combinatorics
PythagoreanTriples c PythagoreanTriple yes arithmetic/number-theory
RationalDyckPaths c RationalDyckPath yes combinatorics
RookPlacements c RookPlacement yes A002720 combinatorics
SignedSetCompositions c SignedSetComposition yes combinatorics
SignedSubsets c SignedSubset yes A000244 combinatorics
SingletonSpecies c Singleton reference/entries
SquareDecompositions c SquareDecomposition yes u arithmetic/number-theory
SumsOfTwoSquares c GaussianInteger reference/entries
TotalPartitions c TotalPartition yes A001003 combinatorics
CardinalNumbers d Cardinal (none) u A001477 reference/entries no Carrier record (stub catalogCarrier only); CE has no cardinal or ordinal type
OmegaOrdinals d OmegaOrdinal (none) u reference/entries no Carrier record (stub catalogCarrier only); CE has no cardinal or ordinal type
BoundedPartPartitions e IntegerPartition A026820 reference/entries IntegerPartitions(n) restricted by LargestPart <= k, or IntegerPartitions(n, All, Range(k))
ConnectedLabeledGraphs e LabeledGraph reference/entries LabeledGraphs(n) restricted by GraphComponentCount = 1
LittleSchroderTriangle e SchroederPath A114709 reference/entries SchroederPaths(n) restricted by Peaks = k (Peaks is declared on SchroederPath); what k grades is unchecked
NarayanaNumbers e DyckPath A001263 reference/entries DyckPaths(n) restricted by Peaks = k (Peaks is declared on DyckPath)
SchroederTriangle e SchroederPath A060693 reference/entries SchroederPaths(n) restricted by Peaks = k (Peaks is declared on SchroederPath); what k grades is unchecked
BooleanAlgebra f1 Finset A000079 reference/entries duplicate of BooleanLattice(n) (incidence), an order structure not a collection
CubeFreeNumbers f1 Numeric u reference/entries duplicate of KFreeIntegers(3) (numeric-divisor.ts:417)
IndependentSetsCycle f1 BinaryWord A000204 reference/entries duplicate of LucasStrings(n)
KColoredPermutations f1 ColoredPermutation A319027 reference/entries duplicate of ColoredPermutations(n, k)
KPartPartitions f1 IntegerPartition A008284 reference/entries duplicate of IntegerPartitions(n, {k})
SparseSubsets f1 BinaryWord A000045 reference/entries duplicate of FibStrings(n)
StepCompositions f1 IntegerComposition A000045 reference/entries duplicate of FibonacciCompositions(n)
SternBrocotPaths f1 BinaryWord A000079 reference/entries duplicate of BinaryWords(n) (record: cardinality only, borrows binary_words)
SurjectionsOntoK f1 Surjection A019538 reference/entries duplicate of Surjections(n, k) (typed, two integers)
Weak3Compositions f1 WeakComposition A000217 reference/entries duplicate of WeakCompositions(n, 3)
WeakCompositionsIntoKParts f1 WeakComposition reference/entries duplicate of WeakCompositions(n, k)
Associahedron f2 Dissection A001003 reference/entries a polytope is a value (the face collection is the carrier plural: SetCompositions, Subsets, SignedSubsets, Dissections); @notatio/polytope declares no CE heads
CrossPolytope f2 SignedSubset A000244 reference/entries a polytope is a value (the face collection is the carrier plural: SetCompositions, Subsets, SignedSubsets, Dissections); @notatio/polytope declares no CE heads
Cyclohedron f2 Dissection reference/entries a polytope is a value (the face collection is the carrier plural: SetCompositions, Subsets, SignedSubsets, Dissections); @notatio/polytope declares no CE heads
Permutahedron f2 SetComposition A000670 reference/entries a polytope is a value (the face collection is the carrier plural: SetCompositions, Subsets, SignedSubsets, Dissections); @notatio/polytope declares no CE heads
Simplex f2 Finset reference/entries a polytope is a value (the face collection is the carrier plural: SetCompositions, Subsets, SignedSubsets, Dissections); @notatio/polytope declares no CE heads
Carriers f3 Text (none) reference/entries catalogue vocabulary, not mathematics (Text carrier, or GlyphKinds which is the GlyphKind type space)
Collections f3 Text (none) reference/entries catalogue vocabulary, not mathematics (Text carrier, or GlyphKinds which is the GlyphKind type space)
Glyphs f3 GlyphKind reference/entries catalogue vocabulary, not mathematics (Text carrier, or GlyphKinds which is the GlyphKind type space)
Traits f3 Text (none) reference/entries catalogue vocabulary, not mathematics (Text carrier, or GlyphKinds which is the GlyphKind type space)
IntegerNumbers f4 IntegerNumber (none) u reference/entries CE declares the base set (NonNegativeIntegers, Integers); catalogue name to be retired
NaturalNumbers f4 Numeric u A000027, A001477 reference/entries CE declares the base set (NonNegativeIntegers, Integers); catalogue name to be retired

Home

Project

Working

Design: every design page, by subject

Clone this wiki locally