Skip to content

Speculative Modular Names

enumeratio edited this page Nov 16, 2026 · 1 revision

Names in the modular package

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.

Recommendation

  1. Drop the group prefix from the Modular… heads, keep it on ModularMatrix. The prefix names the group, the argument type already says so, and Modular already means two other things in the catalogue (modulo, and a function of τ). ModularMatrix is the carrier and the one name where the bare word is too general.
  2. Widen compute-engine's Trace and Discriminant rather than declare ModularTrace and FormDiscriminant. This is what the package already does for Dot, MatrixPower and Inverse (src/declare.ts:154-193), and what combinatorics already does for Trace on tableaux (packages/reference/entries/Trace/index.md).
  3. Fold WordSymbol and LinkingWithTrefoil into RademacherSymbol. 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.
  4. Rename FareyNeighbours to IsFareyNeighbor. It is a predicate and spelled British; the catalogue says Neighbors.
  5. ModularClasses(n, primitive?) becomes HyperbolicClasses(n, Primitive -> True). A positional boolean is an option, and the heads count hyperbolic classes only.
  6. 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 in web/.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.

What exists

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.

1. Diagnosis

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 (Wolfram system-names.ts:4623), ModularResidue, ModularResidues, ModularMajorIndex. Two are functions of τ: ModularJ and ModularLambda (system-names.ts:4624). Dropping the prefix from the group heads removes the ambiguity.
  • Implementation-named heads: two, not several. Only WordSymbol and LinkingWithTrefoil are named for how or why the number is computed, and both are duplicates. ModularSTWord is 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) and KroneckerSymbol (3959) are Wolfram's heads, QuadraticIrrationalQ (5673) is the predicate we call IsQuadraticIrrational, and matrix trace is Tr (7134) while Trace (7135) is Wolfram's evaluation trace. Absent from Wolfram: ModularForm, CongruenceSubgroup, EisensteinE, ClassNumber (only NumberFieldClassNumber, :5015), DedekindSum, RademacherSymbol, QuadraticForm, PellSolution. Wolfram does hold the modular-function names: DedekindEta (1891), ModularLambda, KleinInvariantJ (3949), EllipticTheta (2337).

2. The rename table

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 predicates IsElliptic, IsParabolic, IsHyperbolic. One head keeps the identity case and the single trace comparison.
  • ModularWord (4): LRWord says the alphabet, PositiveWord says the property. LRWord pairs with STWord; the two heads differ only by generators.
  • ModularClass and ModularClasses (7, 8): ConjugacyClass for 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 as Hyperbolic….
  • FormRho (23): the queue's FormCycleStep keeps a Form prefix the rule drops; ReductionStep and ReductionCycle form a pair. If the owner keeps the queued name, FormCycle stays 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

3. What the names force

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.

4. Cost

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 the NOVEL list, which pins "novel" heads by name in both directions. Trace and Discriminant move into the OVERRIDDEN list (: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, since packages/census/tests/rename-queue.test.ts fails a row whose to is declared.
  • packages/frontend/tests/function-view.golden.json:1618 and function-view.test.ts:52: the type text expression<QuadraticForm>.
  • packages/wolfram/tests/from-wolfram.test.ts:118,190 and to-wolfram.test.ts:31: ModularTrace["LRLR"] used as a sample of an unmapped head. After the rename Trace maps to Tr, so the sample changes.
  • packages/symbols/groups/braid/docs/lorenz.md:96 (ModularFromSTWord) and braid/reference/LorenzBraid/index.md:20 (ModularClasses in seeAlso).
  • packages/oracle/src/reserved-names-data.ts:305: Sage's own QuadraticForm in 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.

Open questions, with recommended answers

  1. Widen Trace and Discriminant, or declare package heads? Widen. The package does it for three heads and combinatorics for Trace. Cost: two new OVERRIDDEN names and an untested widening of a lazy head (Discriminant); nothing was probed, so a builder probes that first. If it fails, fall back to QuadraticFormDiscriminant.
  2. QuadraticForm to BinaryQuadraticForm? Yes, though the rule's wording (a prefix only when the bare name is taken in the catalogue) says no. A three-argument QuadraticForm(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.
  3. 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 for FormAction.
  4. FormClassNumber or FormClassCount? Keep FormClassNumber. Every neighbour calls it the class number; the …Count ruling was against NumberOf….
  5. Are the generator letters in STWord and LRWord abbreviations? No: S, T, L, R are the generators' own names. Keep.
  6. One head or three predicates for the element kind? One head, ElementKind.
  7. Supersede the three queued rows? Yes. Drop the rows for WordSymbol and LinkingWithTrefoil (merged) and for FormRho (renamed in the same pass, name per question 8).
  8. ReductionStep or the queued FormCycleStep? ReductionStep, with ReductionCycle. It follows the rule against repeating the carrier; if the owner would keep the queue's agreed name, keep FormCycle with it.
  9. Move KroneckerSymbol to number-theory? Yes, in its own change. It is a placement fix, not a rename, and Compute-Engine-Overrides already notes number-theory names it while modular declares it.
  10. Should FormClassNumber count primitive forms only? Probably, but that is a value change; check it against qfbclassno or Sage before renaming anything, since a rename that keeps the wrong number keeps the wrong address stable.
  11. British spelling in prose. Nine files outside the head names use stabiliser, factorisation, recognise and the like (eight records, one guide). Fix in the codemod's PR, by hand.

Measured versus assumed

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).

Home

Project

Working

Design: every design page, by subject

Clone this wiki locally