Repository navigation
Speculative Modular Names
Speculative. A proposal, not adopted.
@notatio/modular (packages/symbols/groups/modular/) declares 37 heads. The Ideas page says they are heavily prefixed, several are named for their implementation, and Wolfram gives no names to align against. The count bears out the prefix claim and part of the implementation claim, and the Wolfram claim is wrong for five heads. The package is also not about congruence subgroups, cusps or modular forms: it is the full group PSL(2,ℤ), continued fractions, indefinite binary quadratic forms and the Rademacher symbol. This page lists every head, says what each is, finds what the neighbouring systems call it, and proposes a name for each as a row the owner can accept or amend.
"Measured" means read or counted from the tree at origin/main, commit bfa63e225, with a file and line. "From memory" means a fact about Sage, PARI, Mathlib, LMFDB or the literature that I did not check; there is no network and no node_modules here, so nothing was run. Counts are over git ls-files with word-boundary matching.
-
Drop the group prefix from the
Modular…heads, keep it onModularMatrix. The prefix names the group, the argument type already says so, andModularalready means two other things in the catalogue (modulo, and a function of τ).ModularMatrixis the carrier and the one name where the bare word is too general. -
Widen compute-engine's
TraceandDiscriminantrather than declareModularTraceandFormDiscriminant. This is what the package already does forDot,MatrixPowerandInverse(src/declare.ts:154-193), and what combinatorics already does forTraceon tableaux (packages/reference/entries/Trace/index.md). -
Fold
WordSymbolandLinkingWithTrefoilintoRademacherSymbol. All three return one number (src/rademacher.ts:88-108). That is the two heads the census rename queue already holds for this package (packages/census/src/rename-queue.ts:29-47), with its own note that an overload may beat a second head. -
Rename
FareyNeighbourstoIsFareyNeighbor. It is a predicate and spelled British; the catalogue saysNeighbors. -
ModularClasses(n, primitive?)becomesHyperbolicClasses(n, Primitive -> True). A positional boolean is an option, and the heads count hyperbolic classes only. -
Do it as one codemod and one PR, with a redirect per renamed head. The permalink ledger is append-only (
web/ledger.tsv:1-3), so 17 old/reference/symbol/…addresses need rules inweb/.vitepress/redirects.ts. The three heads in the census queue are drained in the same change.
Of the 37 heads: 17 change (13 mechanical renames, 2 widenings of compute-engine heads, 2 removals by merging), 20 stay.
The package extends structures and residues (package.json:52-58, layer extension). Every head has one record in reference/<Head>/ (37 folders). Of the 37, 36 are declared with ce.declare or the aboutMatrix/aboutWord/aboutForm/aboutDiscriminant helpers in src/declare.ts; ContinuedFraction is compute-engine's own head, wrapped in place (src/declare.ts:602-632), as is FromContinuedFraction (:634), which has no record here. Dot, MatrixPower and Inverse are widened, not declared (:154-193).
The crosswalk fields on these records are thin. Measured over the 37 records: names: on 6 (five wolframIdentity: true, one wolfram: QuadraticIrrationalQ), references: on 5 (Wikipedia, MathWorld, Rosetta Code only), bindings: on 3, catalog: on none, and no sage, mathlib, oeis or lmfdb field anywhere. So the neighbouring names below come from the oracle and Wolfram name lists in the tree, or from memory.
Signatures are from the records. M is expression<ModularMatrix> | list | string (a matrix, a nested list or an LR word; src/declare.ts:190).
The group and its elements (6)
| Head | Signature | Meaning |
|---|---|---|
ModularMatrix |
(a,b,c,d) or (word)
|
element of PSL(2,ℤ), as four integers or an LR word |
ModularTrace |
(M) -> integer |
trace of the element |
ModularKind |
(M) -> string |
Identity, Elliptic, Parabolic or Hyperbolic, by |trace| against 2 (src/psl2z.ts:80-90) |
ModularWord |
(M) -> string |
the positive word in L, R of a matrix with non-negative entries |
ModularSTWord |
(M) -> list<integer> |
exponents of the alternating S/T factorisation |
ModularFromSTWord |
(list<integer>) -> ModularMatrix |
inverse of ModularSTWord
|
Conjugacy classes and the Rademacher symbol (8)
| Head | Signature | Meaning |
|---|---|---|
ModularClass |
(word) -> string |
least rotation of an LR word, the name of its conjugacy class (src/psl2z.ts:300) |
ModularClasses |
(n, primitive?) -> list |
hyperbolic classes of word length n, as necklaces (:308-319) |
IsPrimitiveClass |
(word) -> boolean |
word is not a proper power |
RademacherSymbol |
(M) -> integer |
Ψ, defined for hyperbolic M (src/rademacher.ts:88) |
WordSymbol |
(word) -> integer |
R count minus L count of a word (:97) |
LinkingWithTrefoil |
(M) -> integer |
alias of RademacherSymbol (:108) |
RademacherPhi |
(M) -> integer |
Φ, not a class function |
DedekindSum |
(h,k) -> number |
s(h,k), exact |
Continued fractions, Stern–Brocot, Farey (7)
| Head | Signature | Meaning |
|---|---|---|
ContinuedFraction |
(x, n?) |
compute-engine's, widened to quadratic irrationals |
ContinuedFractionK |
(f, g, (i, imin, imax)) |
generalised continued fraction |
Convergents |
(list) or (x, n?)
|
convergents p_k/q_k |
SternBrocotPath |
(p, q) -> string |
L/R path of p/q |
FromSternBrocotPath |
(string) -> number |
inverse |
FareySequence |
(n) -> list |
Farey sequence of order n; record is a Wolfram stub |
FareyNeighbours |
(p,q,r,s) -> boolean |
|ps − qr| = 1 |
Binary quadratic forms (15)
| Head | Signature | Meaning |
|---|---|---|
QuadraticForm |
(a,b,c) |
integral binary form ax² + bxy + cy², a value |
FormDiscriminant |
(form) -> integer |
b² − 4ac |
IsIndefinite |
(form) -> boolean |
D > 0 and not a square (src/forms.ts:55) |
IsReducedForm |
(form) -> boolean |
Gauss's reduction condition |
ReduceForm |
(form) -> form |
walk ρ until reduced |
FormRho |
(form) -> form |
Gauss's ρ, one step round the cycle |
FormCycle |
(form) -> list<form> |
the cycle of reduced forms, i.e. the class |
FormAutomorph |
(form) -> ModularMatrix |
generator of the stabiliser, from the Pell solution |
FormAction |
(form, M) -> form |
substitution (x,y) ↦ (px+qy, rx+sy) |
EvaluateForm |
(form, x, y) -> integer |
value at a point |
ReducedForms |
(D) -> list |
every reduced form of discriminant D |
FormClasses |
(D) -> list |
classes of discriminant D, each a ρ-cycle |
FormClassNumber |
(D) -> integer |
how many classes (src/forms.ts:182) |
PellSolution |
(D) -> list |
fundamental (t,u) of t² − Du² = 4 |
IsQuadraticIrrational |
(x) -> boolean |
eventually periodic continued fraction; Wolfram's QuadraticIrrationalQ
|
Number theory (1): KroneckerSymbol(a, n), the Kronecker symbol. It is declared here (src/declare.ts:858) but belongs with JacobiSymbol and LegendreSymbol in number-theory.
Not here: congruence subgroups, cusps, fundamental domains, Hecke operators, modular forms and spaces of them. The modular-function heads are elsewhere: ModularJ, ModularLambda (a Wolfram stub), KleinInvariantJ, EisensteinG in analytic (packages/symbols/analysis/analytic/src/modular.ts:202) and DedekindEta, EisensteinE in compute-engine (packages/reference/entries/DedekindEta, EisensteinE). packages/engine/src/modular.ts is unrelated: it makes Mod(f(args), m) lazy (:1-10). HeckeT is the Iwahori–Hecke basis element (packages/symbols/algebras/hecke/reference/HeckeT/index.md), not a Hecke operator.
Counts are of the 37 heads; a head can be in several rows.
| Finding | Count | Heads |
|---|---|---|
| Redundant prefix or affix: the argument type already says the carrier | 15 |
ModularTrace, ModularKind, ModularWord, ModularSTWord, ModularFromSTWord, ModularClass, ModularClasses; FormDiscriminant, FormAction, FormCycle, FormAutomorph, FormRho; IsReducedForm, ReduceForm, EvaluateForm
|
| of which kept anyway, because the bare name is taken or empty | 3 |
FormAction (bare Action says nothing), ReduceForm (Wolfram's Reduce, system-names.ts:5835), EvaluateForm (Evaluate, :2438) |
| Duplicate of another head, named for a route or a reading | 2 |
WordSymbol (counts letters), LinkingWithTrefoil (Ghys's theorem); both equal RademacherSymbol on hyperbolic input |
| Named by Gauss's symbol, not by what it does | 1 |
FormRho (the census queue already says so) |
| Name misdescribes the argument | 1 |
IsPrimitiveClass tests a word, not a class |
| Name too general for the carrier | 1 |
QuadraticForm, which takes three coefficients (binary only) |
| Spelling or predicate form | 1 |
FareyNeighbours: British, and a boolean not named Is…
|
| Positional boolean where an option belongs | 1 | ModularClasses(n, primitive?) |
| Abbreviation in the strict sense | 0 |
STWord carries the generator letters S and T, ContinuedFractionK is Wolfram's own |
| Would collide with a head elsewhere if the prefix were dropped | 5 |
Trace (compute-engine), Discriminant (compute-engine, Wolfram), Reduce (Wolfram), Evaluate (compute-engine, Wolfram), Word (a stub record in combinatorics, and Wolfram system-names.ts:7704) |
| Near collision today | 4 |
QuadraticForm (Sage and Mathlib name the general form the same, from memory for Mathlib), ModularClass and ModularClasses (beside ConjugacyClasses for finite groups and ConjugacyClassRepresentative for permutations), FormCycle (beside Wolfram's Cycles, system-names.ts:1776) |
| Fine as they are | 17 | see the table |
Three notes on the numbers.
-
"Modular" already means three things. There are 14
Modular…heads in the catalogue. Eight are this package's (the group). Four mean modulo:ModularInverse(Wolframsystem-names.ts:4623),ModularResidue,ModularResidues,ModularMajorIndex. Two are functions of τ:ModularJandModularLambda(system-names.ts:4624). Dropping the prefix from the group heads removes the ambiguity. -
Implementation-named heads: two, not several. Only
WordSymbolandLinkingWithTrefoilare named for how or why the number is computed, and both are duplicates.ModularSTWordis named for its layout in the sense that it returns the exponent list, not a word; it is the mathematical name, so I count it as fine. -
The Wolfram claim. The Ideas page says there is no counterpart. Measured in
packages/wolfram/src/system-names.ts(7,736 names):ContinuedFraction(1583),ContinuedFractionK(1584),Convergents(1624),FareySequence(2588) andKroneckerSymbol(3959) are Wolfram's heads,QuadraticIrrationalQ(5673) is the predicate we callIsQuadraticIrrational, and matrix trace isTr(7134) whileTrace(7135) is Wolfram's evaluation trace. Absent from Wolfram:ModularForm,CongruenceSubgroup,EisensteinE,ClassNumber(onlyNumberFieldClassNumber,:5015),DedekindSum,RademacherSymbol,QuadraticForm,PellSolution. Wolfram does hold the modular-function names:DedekindEta(1891),ModularLambda,KleinInvariantJ(3949),EllipticTheta(2337).
Columns: current, proposed, rule applied, source of the name, collision check (git ls-files | grep '/reference/<Name>/index.md' over the tree, plus the Wolfram and compute-engine lists), and my confidence. in-pkg and out are file counts naming the old head, inside the package outside its own record folder, and outside the package (§4). Sources: W Wolfram name list (measured), CE packages/reference/entries (measured), Sage the Sage 10.9 global-name list in packages/oracle/src/reserved-names-data.ts:187-423 (measured for global names; method names from memory), Fungrim packages/reference/src/fungrim-symbols-data.ts (measured), and PARI, Mathlib, literature (from memory, not checked).
| # | Current | Proposed | Rule | Source | Collision | in-pkg / out | Conf. |
|---|---|---|---|---|---|---|---|
| 1 | ModularMatrix |
keep | carrier; bare name too general | Sage SL2Z, Fungrim PSL2Z name the group, not an element |
none | — | high |
| 2 | ModularTrace |
Trace (widen CE) |
follow compute-engine | CE Trace; W Tr
|
CE Trace has a record; combinatorics already overloads it |
8 / 4 | high |
| 3 | ModularKind |
ElementKind; alt Kind
|
drop group prefix | literature: "elliptic, parabolic, hyperbolic element"; Sage uses is_elliptic-style predicates (from memory) |
none in tree or W | 7 / 2 | low |
| 4 | ModularWord |
LRWord; alt PositiveWord
|
drop prefix; bare Word taken |
literature: L, R letters; code calls it positiveWord
|
Word is a stub record and W |
15 / 2 | medium |
| 5 | ModularSTWord |
STWord |
drop prefix | literature: S, T generators | none | 9 / 2 | medium |
| 6 | ModularFromSTWord |
FromSTWord |
drop prefix; From… is CE's inverse form |
CE FromContinuedFraction
|
none | 5 / 3 | medium |
| 7 | ModularClass |
HyperbolicClass |
drop prefix; singular of the collection | literature: hyperbolic conjugacy class | none; near ConjugacyClasses, ConjugacyClassRepresentative
|
5 / 2 | medium |
| 8 | ModularClasses |
HyperbolicClasses(n, Primitive -> True) |
plural collection; option not positional boolean; booleans default False | same | none | 9 / 3 | medium |
| 9 | IsPrimitiveClass |
IsPrimitiveWord |
argument is a word | literature: primitive word (Lyndon) | none | 4 / 2 | high |
| 10 | ContinuedFraction |
keep | CE and W | CE, W :1583
|
ContinuedFractions is a catalogue collection, a correct plural |
— | high |
| 11 | ContinuedFractionK |
keep | W fixes the short name | W :1584
|
none | — | high |
| 12 | Convergents |
keep | W | W :1624
|
none | — | high |
| 13 | SternBrocotPath |
keep | literature | Stern–Brocot tree | none | — | high |
| 14 | FromSternBrocotPath |
keep | inverse form as CE's | CE FromContinuedFraction
|
none | — | high |
| 15 | FareySequence |
keep | W | W :2588
|
none (record is a stub to write up) | — | high |
| 16 | FareyNeighbours |
IsFareyNeighbor |
predicate Is…; American spelling |
IsCoprime is the binary-predicate precedent; catalogue spells Neighbors
|
none | 4 / 2 | high |
| 17 | PellSolution |
keep; alt FundamentalPellSolution
|
mathematics' name | Mathlib Pell namespace (from memory) |
none in W | — | medium |
| 18 | QuadraticForm |
BinaryQuadraticForm |
name matches the carrier; keep QuadraticForm free for the general form |
Sage BinaryQF (reserved-names-data.ts:199) and QuadraticForm (:305); PARI Qfb (from memory) |
none today; Sage and Mathlib use the bare name for the n-ary form | 25 / 5 | low |
| 19 | FormDiscriminant |
Discriminant (widen CE) |
follow compute-engine | CE Discriminant, W :2132; Sage BinaryQF.discriminant (from memory) |
CE head is lazy, polynomial signature (value, symbol?)
|
5 / 2 | medium |
| 20 | IsIndefinite |
keep | fine; narrower than some texts (§3) | Cohen, Buell treat non-square D > 0 as indefinite (from memory) | none | — | medium |
| 21 | IsReducedForm |
IsReduced |
drop the carrier word | Sage is_reduced (from memory) |
none; Reduce is W's, IsReduced is not |
5 / 2 | low |
| 22 | ReduceForm |
keep | bare Reduce is Wolfram's |
Sage reduced_form, PARI qfbred (from memory) |
Reduce W :5835
|
— | medium |
| 23 | FormRho |
ReductionStep; queued: FormCycleStep
|
name what it does | Gauss's ρ, "reduction operator" (from memory) | none | 6 / 3 | medium |
| 24 | FormCycle |
ReductionCycle |
drop the carrier word; bare Cycle sits beside Cycles
|
Sage BinaryQF.cycle (from memory) |
none | 6 / 2 | medium |
| 25 | FormAutomorph |
Automorph; alt FundamentalAutomorph
|
drop the carrier word | Gauss's "automorph" | none; near AutomorphismGroupSize
|
6 / 2 | low |
| 26 | FormAction |
keep | bare Action is empty |
none | none | — | low |
| 27 | EvaluateForm |
keep | bare Evaluate is CE's and W's |
none |
Evaluate CE and W :2438
|
— | medium |
| 28 | ReducedForms |
keep | plural collection of reduced forms | Fungrim has the spelled-out PrimitiveReducedPositiveIntegralBinaryQuadraticForms
|
none | — | high |
| 29 | FormClasses |
keep | the argument is an integer, so the subject stays | PARI qfbclassno (from memory) |
none | — | medium |
| 30 | FormClassNumber |
keep; alt FormClassCount
|
mathematics' name over the …Count rule |
Sage class_number, PARI qfbclassno (from memory); W has only NumberFieldClassNumber
|
none | — | medium |
| 31 | RademacherSymbol |
keep, absorbs 32 and 33 | literature: Rademacher symbol Ψ (Barge–Ghys; from memory) | none in W, Fungrim | none | — | high |
| 32 | WordSymbol |
removed; RademacherSymbol(word)
|
duplicate; named for the route | queued as RademacherSymbolOfWord
|
none | 4 / 3 | high |
| 33 | LinkingWithTrefoil |
removed; RademacherSymbol(M)
|
duplicate; named for a theorem | queued as TrefoilLinkingNumber
|
none | 5 / 3 | high |
| 34 | RademacherPhi |
keep | spelled-out Greek letter, as W's EulerPhi, LerchPhi
|
literature: Rademacher function Φ | none | — | high |
| 35 | DedekindSum |
keep | mathematics' name | Fungrim DedekindSum (fungrim-symbols-data.ts:100); Sage dedekind_sum (reserved-names-data.ts:373) |
none in W | — | high |
| 36 | KroneckerSymbol |
keep; move to number-theory
|
W | W :3959; Fungrim :215
|
none | — | high |
| 37 | IsQuadraticIrrational |
keep |
Is… over W's …Q
|
W QuadraticIrrationalQ :5673, mapped in the record |
none | — | high |
Alternatives where two names are reasonable:
-
ModularKind(3): one head returning a string (recommended, as now), or three predicatesIsElliptic,IsParabolic,IsHyperbolic. One head keeps the identity case and the single trace comparison. -
ModularWord(4):LRWordsays the alphabet,PositiveWordsays the property.LRWordpairs withSTWord; the two heads differ only by generators. -
ModularClassandModularClasses(7, 8):ConjugacyClassfor the singular is also right and is free in the catalogue, but the plural is not the conjugacy classes of a group, it is the hyperbolic ones of one word length, so the pair reads better asHyperbolic…. -
FormRho(23): the queue'sFormCycleStepkeeps aFormprefix the rule drops;ReductionStepandReductionCycleform a pair. If the owner keeps the queued name,FormCyclestays too and rows 23 and 24 change together.
Calls after the change:
Trace(ModularMatrix(1, 1, 1, 2)) // 3
LRWord(ModularMatrix(1, 1, 1, 2)) // "LR"
HyperbolicClasses(4, Primitive -> True)
RademacherSymbol("LRRRR") // 3, was WordSymbol
Discriminant(BinaryQuadraticForm(1, 2, -1)) // 8
A congruence subgroup is a value, and nothing here names one. Sage's constructors are Gamma0(N), Gamma1(N), GammaH and the class CongruenceSubgroup (all in the Sage global list, reserved-names-data.ts:214,246); Mathlib has CongruenceSubgroup.Gamma0 (from memory); Wolfram and Fungrim have none. Under the no-abbreviation rule the spelled-out name is CongruenceSubgroup. The three families would be one head taking the level and a rule, CongruenceSubgroup(N, Type -> …)-style, not three heads. That is a design for the package that adds them. The decision made now is narrower: LRWord, STWord, HyperbolicClass and the rest are specific to the full group, because L and R generate its positive monoid and the cycle structure is the full group's. Dropping Modular from them is safe while the package holds one group. When a second group arrives, the full-group heads either take it as an argument or keep a name that says so. I recommend keeping the full-group names as they are and passing the group as an argument only on the new heads.
The modular group as a head. Neighbouring group heads are singular values: CyclicGroup(n), DihedralGroup(n), SymmetricGroup(n) with GroupElements, GroupOrder over them (packages/symbols/algebras/groupalgebra/reference/). A ModularGroup() head would follow them, and Mathlib calls the group ModularGroup (from memory). It is not a plural domain, since it is one group and not a collection of anything. No head here needs it today, so I do not propose adding it. ModularMatrix is then the constructor of one member, and a plural ModularMatrices would be an infinite unordered collection with no use.
How elements are written. Three spellings of one element, accepted everywhere by the union M: four integers (a matrix, up to sign), an LR word (a string, positive elements only), and S/T exponents (a list). LRWord returns a string and STWord returns a list of exponents, so "word" means two layouts. The name STWord is the mathematical one, and I keep it; the alternative STExponents and FromSTExponents say what comes back. If the owner wants one rule, "a word is a string over its letters" gives the second. The head ModularMatrix accepts a word, which is why Dot, Inverse and MatrixPower are widened in place (src/declare.ts:154-193); no naming decision changes that.
Classes and counts. FormClassNumber and FormClasses(D) count all classes of forms of discriminant D, not only primitive forms: reducedForms has no content filter (src/forms.ts:147-162). The classical class number counts primitive forms. That is a value question, not a name question, and it is not computed here: I could not run anything. The name FormClassNumber promises the classical number. It is also a property of the order of discriminant D (QuadraticOrder(D), packages/symbols/arithmetic/number-theory/reference/QuadraticOrder/index.md), which a later ClassNumber(order) head would take; the names here do not block that.
IsIndefinite. It is true for D > 0 and non-square only (src/forms.ts:50-58), and false for x² − y². Some texts use the word that way (from memory), some take all D > 0. I keep the name and suggest the record states the convention.
Measured with word-boundary matching over git ls-files. "Old heads" are the 17 that change: the 15 renamed (rows 2-9, 16, 18, 19, 21, 23-25) and the 2 removed (32, 33).
| Where | Files | Occurrences |
|---|---|---|
Own record folders (reference/<Old>/, index.md and examples.tsv) |
34 | 140 |
Elsewhere in the package: 21 other records, README.md, docs/modular-group.md, src/declare.ts, one test |
25 | 171 |
| Outside the package | 10 | 47 |
Dropping QuadraticForm from the set takes the in-package count to 19 files and 118 occurrences, and the outside count to 7 and 42 (QuadraticForm alone is 25 files and 79 occurrences in the package). It is the largest single row, which is why its confidence is low.
Outside the package, by file:
-
web/ledger.tsv: the 17 old addresses, one line each (web/ledger.tsv:2863-5387). Append-only; not to be rewritten. -
packages/reference/tests/provenance.test.ts:591-939: the old names in theNOVELlist, which pins "novel" heads by name in both directions.TraceandDiscriminantmove into theOVERRIDDENlist (:185), where a new name is by its own comment "an override nobody decided on", so each needs the owner's decision. -
packages/census/src/rename-queue.ts:29-47: three rows to delete, sincepackages/census/tests/rename-queue.test.tsfails a row whosetois declared. -
packages/frontend/tests/function-view.golden.json:1618andfunction-view.test.ts:52: the type textexpression<QuadraticForm>. -
packages/wolfram/tests/from-wolfram.test.ts:118,190andto-wolfram.test.ts:31:ModularTrace["LRLR"]used as a sample of an unmapped head. After the renameTracemaps toTr, so the sample changes. -
packages/symbols/groups/braid/docs/lorenz.md:96(ModularFromSTWord) andbraid/reference/LorenzBraid/index.md:20(ModularClassesinseeAlso). -
packages/oracle/src/reserved-names-data.ts:305: Sage's ownQuadraticFormin a generated list. A false positive; the codemod must skip it.
No package imports a head by name. The six dependents of @notatio/modular (census, cli, oracle, reference, braid, web; package.json of each) use declareModular, notation and declares.json only (packages/cli/src/notation.ts:15, web/.vitepress/theme/worker-catalogue.ts:29,139). The package's notation table keys ModularMatrix, DedekindSum, FormClassNumber, RademacherPhi and RademacherSymbol (src/notation.ts:9-28), none renamed.
One codemod covers the 13 mechanical renames (rows 3-9, 16, 18, 21, 23-25): a word-boundary rewrite in tracked text, plus git mv of 13 record folders (26 files). It must skip web/ledger.tsv, packages/oracle/src/reserved-names-data.ts and rename-queue.ts, and re-sort the NOVEL list. The hand-written part, to be named in the PR as Contributing asks: the two widenings (Trace, Discriminant) with their OVERRIDDEN and Compute-Engine-Overrides entries; the merge of WordSymbol and LinkingWithTrefoil into RademacherSymbol (two records and the guide's trefoil section deleted or rewritten, the domain difference below); the Primitive -> True option; 17 renamedSymbols rules in web/.vitepress/redirects.ts:58 and 17 appended ledger lines; the Sites and Compute-Engine-Overrides wiki pages. The static redirect budget is 2,000 (web/.vitepress/redirects.ts:15); I did not count the rules in use.
Domain difference in the merge: WordSymbol("R") is 1 for any positive word, RademacherSymbol is undefined unless the trace exceeds 2 (src/rademacher.ts:88-98). After the merge a parabolic word declines.
-
Widen
TraceandDiscriminant, or declare package heads? Widen. The package does it for three heads and combinatorics forTrace. Cost: two newOVERRIDDENnames and an untested widening of alazyhead (Discriminant); nothing was probed, so a builder probes that first. If it fails, fall back toQuadraticFormDiscriminant. -
QuadraticFormtoBinaryQuadraticForm? Yes, though the rule's wording (a prefix only when the bare name is taken in the catalogue) says no. A three-argumentQuadraticForm(a, b, c)also reads as a diagonal ternary form, and Sage and Mathlib use the bare name for the general one. Cheaper now than after more heads depend on it. Low confidence. -
Keep three
Form…names kept by exception (FormAction,ReduceForm,EvaluateForm)? Keep. Each bare name is empty or taken. The owner may prefer a different verb forFormAction. -
FormClassNumberorFormClassCount? KeepFormClassNumber. Every neighbour calls it the class number; the…Countruling was againstNumberOf…. -
Are the generator letters in
STWordandLRWordabbreviations? No: S, T, L, R are the generators' own names. Keep. -
One head or three predicates for the element kind? One head,
ElementKind. -
Supersede the three queued rows? Yes. Drop the rows for
WordSymbolandLinkingWithTrefoil(merged) and forFormRho(renamed in the same pass, name per question 8). -
ReductionStepor the queuedFormCycleStep?ReductionStep, withReductionCycle. It follows the rule against repeating the carrier; if the owner would keep the queue's agreed name, keepFormCyclewith it. -
Move
KroneckerSymboltonumber-theory? Yes, in its own change. It is a placement fix, not a rename, andCompute-Engine-Overridesalready notesnumber-theorynames it whilemodulardeclares it. -
Should
FormClassNumbercount primitive forms only? Probably, but that is a value change; check it againstqfbclassnoor Sage before renaming anything, since a rename that keeps the wrong number keeps the wrong address stable. -
British spelling in prose. Nine files outside the head names use
stabiliser,factorisation,recogniseand the like (eight records, one guide). Fix in the codemod's PR, by hand.
Measured, from the tree at bfa63e225: the 37 heads and their records, signatures and declarations; the crosswalk fields on the records; every file and occurrence count in §4; the Wolfram name list (7,736 names) and the line of each name cited; the compute-engine records in packages/reference/entries; the Sage 10.9 global-name list and the Fungrim symbol list; the redirect and ledger mechanisms; the census rename queue; the NOVEL and OVERRIDDEN lists.
From memory, not checked: everything about PARI, Mathlib, LMFDB and the literature, including Sage method names (discriminant, reduced_form, is_reduced, cycle, class_number), Mathlib's ModularGroup, CongruenceSubgroup.Gamma0 and Pell, the "Rademacher symbol" attribution, and how Cohen and Buell define "indefinite". LMFDB was not consulted for any row.
Not run, because nothing may be: any evaluation. The class-number count including imprimitive forms is read from reducedForms, not computed. That widening Discriminant works on a lazy compute-engine head is assumed. I used the sibling compute-engine checkout only to see that Trace and Discriminant exist there; it is version 0.148.0 against the 0.187 pin, so I relied on the entries in this repo instead. How many redirect rules are already in use is not counted. Whether Wolfram's evaluation-trace Trace makes the transpiler mapping Trace to Tr fragile is not checked; the census queue's rule is that a Wolfram collision is not a reason to rename (rename-queue.ts:11-12).