Repository navigation
Speculative 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.
Treat the 71 as three jobs, not one.
- 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.
-
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. -
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.
-
A catalogued collection is a record with
grades.collect-catalog-records.tsturns every such record into aCOLLECTIONSrow of the catalog registry (packages/reference/scripts/collect-catalog-records.ts:43).packages/entry/src/types.ts:415-425says "presence is the kind":gradesa collection,catalogCarriera bare carrier,statOn/mapOna statistic or map. 289 records havegrades. -
stubmarks a record nobody wrote up. The schema allowsengineandcarrier(packages/entry/src/schema.ts:343,types.ts:437-442).ReferencePage.vue:381-382renders acarrierstub 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 underpackages/, 218 arestub: carrier(98 withgrades, 81 withcatalogCarrier, 39 neither) and 162 arestub: engine. -
"Declared" is not a field. The manifest takes a head as declared by a signature row carrying
libraryandtype(packages/manifest/src/assemble.ts:184). Families areEpsilFamilyentries declared byhead:; carriers areCarrierrecords with aplural; 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
pluralgets it declared as aset<type>symbol, andElement(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;ContinuedFractionandQuadraticIntegerdo not. No count, rank or enumeration comes with it. -
Three mechanisms give a collection a kernel. (1) An
EpsilFamilywithFamilyKernel/NumberKernel:count,unrank,rank,valid, positions in bigint (collections/src/families/types.ts:110-130). (2) For "the integers satisfying a predicate", thescanhelper: 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 lazyFilter, withRESTRICTIONSa 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).declareRestrictionsdeclares 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.
Primesis a declared constant; membership, no position (packages/reference/entries/Primes/index.md:3-9).IntegersandNonNegativeIntegersare bare engine symbols (packages/boxes/src/make.ts:86,packages/cli/tests/table.test.ts:24). -
@notatio/polytopedeclares no CE heads (packages/symbols/combinatorics/polytope/README.md:6);Permutahedron(4)and the others exist as frontend display symbols over a TypeScriptPolytope(packages/frontend/src/symbols.ts:928). -
No frontier list covers collections.
packages/census/src/wolfram-frontier-data.tsranks Wolfram call forms we cannot answer;packages/reference/src/backlog.jsonis empty ({}); the*-frontier.tsfiles in combinatorics are statistics and map gaps. The committed data that does list them is the explorer golden (§1).
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.
-
AmicableNumbers(a, loosely).AliquotSumis declared (number-theory/reference/AliquotSum), so membership isAliquotSum(AliquotSum(n)) = nandAliquotSum(n) != n: noIshead, but a predicate in declared heads. Count is an open problem and unrank has no proven bound, which is exactly the casescan-definitions.ts:1-8excludes. So: membership only;CountisNaNif 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 itPrimeNumberswith 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. -
CubeFreeNumbersisKFreeIntegers(3)(numeric-divisor.ts:290,:417, also inscan-definitions.ts);NaturalNumbersandIntegerNumbersare compute-engine'sNonNegativeIntegersandIntegers. All three are bucket f.
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 atlattice-paths/src/families/core.tsis the template) andFareySequences(increasing value) belong here. -
Order is open.
SignedSubsetsandCrossPolytope's faces: the polytope code walks signs in the order0, 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),IntegerFactorizationsandFactoradicNumeralsare 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.
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.
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.
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,StandardTableauxand 20 more (printed byno_kernel.py). Their records still carry the generated "not yet written up" summary. -
Singular or misfiled stubs:
FubiniNumberandLittleSchroderNumber(singular twins of declaredFubiniNumbers,LittleSchroderNumbers),Compositions(the type space ofIntegerComposition; the collection isIntegerCompositions),FareySequence(a Wolfram head, undeclared, next to the collection stubFareySequences), andMultisetAdd,MultisetCard,MultisetLe,MultisetMem(mathlib4 functions, not collections). -
PowerSetis a compute-engine head whose record says "alias of Subsets".
| 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.
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'sAtorder is first-class, and changing it later is a break; - declare
NaturalNumbersorIntegerNumbersbeside compute-engine's own sets; - name the five restrictions or add a
RESTRICTIONSentry with a second parameter before the table's signature(integer) -> collectionis extended on purpose; - declare
AmicableNumbersas 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.
- 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.
-
The five polytope rows. Recommend retire them as collections. Keep the polytope as a value in
@notatio/polytope; if the owner wantsPermutahedron(n)as an evaluable head, give it a value-constructor record and its own declare layer, separate from this list. -
The four vocabulary rows. Recommend retire; they duplicate the registry and the manifest, and
Glyphsduplicates theGlyphKindstype space. -
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. -
NaturalNumbersandIntegerNumbers. Recommend retire in favour of compute-engine'sNonNegativeIntegersandIntegers(the ruling). Keep the mathlib4 and OEIS rows (A000027,A001477) on a record for the engine's name. -
Named parameterized restrictions. Recommend not extending
RESTRICTIONSyet; 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. -
Membership on the type spaces for plain values (
Element(3, GaussianIntegers)is unevaluated today, assumed fromcarriers.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, soGaussianIntegers,GaussianRationals,FractionalNumbers. -
Page rule for stubs.
Statistics-and-Maps.md:7proposes 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. -
Cardinals and ordinals. Recommend leave catalog-only; revisit only if a Lean-style
Ordinalis wanted for its own sake.
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.
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 |