From 3f99d243fb761f1e840c8560638b67a8dd3775c3 Mon Sep 17 00:00:00 2001 From: Rafael Vuijk Date: Sat, 5 Sep 2026 23:28:45 +0000 Subject: [PATCH] The growth census is held by a test, not quoted in a remark `Saturation.RulesUpTo` argues in prose from the split of rules across RewriteRuleGrowth, and the figures it quoted were stale by a factor of four: "26 collect, 17 rearrange, 9 expand and 270 are unjudged", and "84% of the library", all measured before the growth declarations went in. The unjudged count went 261 to 152 over that work; the true split is 97 / 45 / 30 / 152. The argument survives the correction -- a ceiling that refuses Unknown still refuses 47% of the rules, so the dial is still whether unjudged rules may fire at all. The arithmetic in it did not, which is the reason to hold a number somewhere that fails when it moves rather than to reason from it in a comment. RuleAuthoringGuideTest already pinned the 152. It pins all four now, so the next time they move this remark fails with them. Full suite 9564 passed, 0 failed. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_012sonx8iAspMiwRwokT1Ura --- .../Core/Transformations/Saturation.cs | 23 +++++++++++++------ .../Transformations/RuleAuthoringGuideTest.cs | 12 ++++++++++ 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/Sources/AngouriMath/Core/Transformations/Saturation.cs b/Sources/AngouriMath/Core/Transformations/Saturation.cs index a749af5fe..2d47d69bc 100644 --- a/Sources/AngouriMath/Core/Transformations/Saturation.cs +++ b/Sources/AngouriMath/Core/Transformations/Saturation.cs @@ -43,13 +43,22 @@ internal static class Saturation /// one, and that is a measurement rather than a preference. It reads like the value a /// ceiling should refuse — it means the rule's growth was not judged, because its /// replacement is code rather than a written pattern, so admitting it accepts a rewrite - /// nobody measured. But it is where the rules are: of the sound rules in - /// , 26 collect, 17 rearrange, 9 expand and 270 are - /// unjudged. A ceiling that refuses the fourth value refuses 84% of the library, and - /// what is left cannot do much — over six expression pairs equal only through a larger - /// intermediate form, the ceiling proved two, - /// and — all nine expanding rules added — proved - /// the same two. The third was proved only with the unjudged rules admitted. + /// nobody measured. But it is where the rules are: of the 324 rules in + /// , 97 collect, 45 rearrange, 30 expand and 152 are + /// unjudged. A ceiling that refuses the fourth value still refuses 47% of the library, + /// and what is left could not do much when this was written — over six expression pairs + /// equal only through a larger intermediate form, the + /// ceiling proved two, and + /// proved the same two. The third was proved + /// only with the unjudged rules admitted. + /// + /// + /// Those figures moved and this paragraph did not. It read "26 collect, 17 + /// rearrange, 9 expand and 270 are unjudged", and 84% — measured before the growth + /// declarations went in, which took the unjudged count from 261 to 152. The argument + /// survives the correction and the arithmetic in it did not, which is the reason to state + /// counts rather than a conclusion drawn from them. RuleAuthoringGuideTest holds all + /// four of these now, so the next time they move this remark fails with them. /// /// /// So the dial that matters is not how far a rule may enlarge; it is whether rules nobody diff --git a/Sources/Tests/UnitTests/Core/Transformations/RuleAuthoringGuideTest.cs b/Sources/Tests/UnitTests/Core/Transformations/RuleAuthoringGuideTest.cs index 4ee656e05..f8d34ea28 100644 --- a/Sources/Tests/UnitTests/Core/Transformations/RuleAuthoringGuideTest.cs +++ b/Sources/Tests/UnitTests/Core/Transformations/RuleAuthoringGuideTest.cs @@ -87,6 +87,18 @@ public void ReplacementAPatternOrCode() Stated(152, rules.Count(rule => rule.Growth is RewriteRuleGrowth.Unknown), "how many rules sit at Unknown growth"); + // The rest of the census, because `Saturation.RulesUpTo` argues from it in prose and + // the figures it quoted had gone stale by a factor of four -- "26 collect, 17 + // rearrange, 9 expand and 270 unjudged", measured before the growth declarations + // went in. The argument survived; the arithmetic did not. A number a remark reasons + // from belongs somewhere that fails when it moves. + Stated(97, rules.Count(rule => rule.Growth is RewriteRuleGrowth.Collects), + "how many rules are declared Collects"); + Stated(45, rules.Count(rule => rule.Growth is RewriteRuleGrowth.Rearranges), + "how many rules are declared Rearranges"); + Stated(30, rules.Count(rule => rule.Growth is RewriteRuleGrowth.Expands), + "how many rules are declared Expands"); + // And the two the document names. By their own names rather than by what the prose // calls them: the first is `squared-sine-and-cosine-of-one-argument-sum-to-one` and // the prose calls it the Pythagorean identity, which is right and is not what to