From 7cc14790f039294802ed304105db1ee643e6d8dd Mon Sep 17 00:00:00 2001 From: Rafael Vuijk Date: Mon, 16 Nov 2026 00:43:13 +0000 Subject: [PATCH] A set Settings.Budget caps lids and arguments, and replaces allowances MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Each BudgetLedger.For call site now declares a BudgetRole, and a set MathS.Settings.Budget does to it what that role calls for: - Allowance (SolveSystem's 10,000 steps / 60 s, Gröbner's 5 s): replaced, as before, so "raise MathS.Settings.Budget to allow more" stays true. - Lid (the perfect-square proof's 2,000 steps / 50 ms): the smaller limit on each axis, so a set budget, Unlimited included, never lifts it. - Argument (EqualitySaturation, CanonicalizationOverGraph, AreEqual): the argument is the allowance and the set budget caps it, so an explicit budget inside an Unlimited scope is spent as passed. The lid is tightened on both axes rather than the clock alone: a lid is never raised, so the incomparability of steps between algorithms does not bite, and a caller who set steps is not ignored. The proof completes in 15 to 1,203 steps over the unit suite (median 212) and a stopped proof falls back to the symbolic test; Factorize and Simplify answers were measured unchanged under unset, Unlimited, {Steps = 1} and {Steps = 1_000_000}. What moves: EqualitySaturation and CanonicalizationOverGraph with an explicit budget inside a scope set to Unlimited, measured against the 2.7.0 package; BREAKING-CHANGES.md has the rows. The four test-only ledgers pass their own budget, so they are Argument. Part of #2454 Co-Authored-By: Claude Opus 5.5 --- BREAKING-CHANGES.md | 26 ++++ .../AngouriMath/Convenience/MathS.Equality.cs | 3 +- Sources/AngouriMath/Convenience/MathS.cs | 52 +++++-- .../AngouriMath/Core/Budgets/BudgetLedger.cs | 45 +++++- .../AngouriMath/Core/Budgets/BudgetRole.cs | 39 +++++ .../AngouriMath/Core/Budgets/WorkBudget.cs | 4 +- .../Core/Transformations/EqualityOracle.cs | 3 +- .../Core/Transformations/Saturation.cs | 4 +- .../Transformation.Catalogue.cs | 13 +- .../Functions/Algebra/Groebner/Buchberger.cs | 3 +- .../Continuous/Solvers/EquationSolver.cs | 4 +- .../Patterns/Patterns.ExpandFactorize.cs | 4 +- .../UnitTests/Core/Budgets/BudgetRoleTest.cs | 146 ++++++++++++++++++ .../Core/Transformations/ConstantFoldTest.cs | 2 +- .../Transformations/ProvidedInAnEClassTest.cs | 2 +- .../Transformations/RunawayBreadthTest.cs | 2 +- .../Transformations/SaturationAblationTest.cs | 2 +- 17 files changed, 318 insertions(+), 36 deletions(-) create mode 100644 Sources/AngouriMath/Core/Budgets/BudgetRole.cs create mode 100644 Sources/Tests/UnitTests/Core/Budgets/BudgetRoleTest.cs diff --git a/BREAKING-CHANGES.md b/BREAKING-CHANGES.md index 2db9400c6..1fa147e33 100644 --- a/BREAKING-CHANGES.md +++ b/BREAKING-CHANGES.md @@ -233,6 +233,32 @@ returned as all of them. `MathS.Equations("y^2 - 2", "x^2 + (P - Q y) * x - 3"). --- +### A set `MathS.Settings.Budget` caps a budget passed as an argument instead of replacing it + +**Silent: the same call stops sooner.** A set `MathS.Settings.Budget` replaced every budget in the library, including one +a caller passed by hand, so `EqualitySaturation(budget, ...)` and `CanonicalizationOverGraph(budget)` inside a scope set +to `WorkBudget.Unlimited` ran unlimited. Now what a set budget does depends on what the budget it meets is for +([#2454](https://github.com/asc-community/AngouriMath/issues/2454)): a budget passed as an argument runs under the smaller +limit on each axis of it and the setting, so `Unlimited` leaves it as passed; the perfect-square proof that `Factorize` +runs and `Simplify` offers keeps its own lid of 2,000 steps and 50 ms under the same rule, so a set budget only tightens +it; and the system solver and its Gröbner path are replaced by the setting as before, so raising it still allows more. +With `budget = new WorkBudget { Steps = 5, Time = TimeSpan.FromSeconds(30) }`, inside +`MathS.Settings.Budget.Set(WorkBudget.Unlimited)`: + +| Input | Was (2.7.0) | Now | +|---|---|---| +| `Transformation.EqualitySaturation(budget, CostModel.Default).ApplyOrKeep("x * 2 * 3 + x")` | `x * 7` | `x * 2 * 3 + x` | +| `Transformation.EqualitySaturation(budget, CostModel.Default).ApplyOrKeep("2 * sqrt(2) * sqrt(3)")` | `2 * sqrt(6)` | `2 * sqrt(2) * sqrt(3)` | +| `Transformation.CanonicalizationOverGraph(budget).ApplyOrKeep("a * b + b * a")` | `2 * a * b` | `a * b + a * b` | +| `Transformation.CanonicalizationOverGraph(budget).ApplyOrKeep("x + 0 + 2 * x")` | `3 * x` | `2 * x + x` | + +Unset, nothing moves. `Factorize` and `Simplify` give the same answers on 2.7.0 and now under an unset, +an `Unlimited`, a `{ Steps = 1 }` and a `{ Steps = 1_000_000 }` budget, measured on `2 + 2 * sqrt(2) * sqrt(3) + 3`, +`a + 2 * sqrt(a) * sqrt(b) + b` and `2 + 2 * sqrt(6) + 3`: a proof the lid stops is "not proved", and the symbolic test +behind it still answers. + +--- + ### An indexed union or intersection binds its index **Silent: a bound name is no longer reported free.** `FreeVariables` of `union(A_k, k in I)` and `intersection(A_k, k in I)` diff --git a/Sources/AngouriMath/Convenience/MathS.Equality.cs b/Sources/AngouriMath/Convenience/MathS.Equality.cs index 0d3ad6880..261f16b1b 100644 --- a/Sources/AngouriMath/Convenience/MathS.Equality.cs +++ b/Sources/AngouriMath/Convenience/MathS.Equality.cs @@ -25,7 +25,8 @@ partial class MathS /// tried, a rule's match attempt, a node the graph grows by -- so the same question under /// the same steps gets the same answer on any machine; a /// makes it depend on the machine, and says when it - /// did. , where set, overrides this. + /// did. , where set, caps this: the smaller limit on each axis + /// applies, so an ambient leaves it as passed. /// /// /// The weakest soundness a proof may rest on. , the default, diff --git a/Sources/AngouriMath/Convenience/MathS.cs b/Sources/AngouriMath/Convenience/MathS.cs index 142a9d47a..a2cde479c 100644 --- a/Sources/AngouriMath/Convenience/MathS.cs +++ b/Sources/AngouriMath/Convenience/MathS.cs @@ -6694,11 +6694,40 @@ internal static EDecimal DowncastingTolerance /// /// Leaving this alone is not the same as setting it to /// . Unset, each algorithm keeps the budget - /// it chose for itself -- the Gröbner path bounds itself by five seconds and - /// by five structural ceilings, and did so before this setting existed. Set, this - /// replaces those defaults wherever a budget is honoured, so + /// it chose for itself. Set, what it does depends on what that budget is for + /// (#2454): + /// + /// + /// A working allowance is replaced. The system solver + /// (: 10,000 steps and 60 seconds + /// over the whole call) and its Gröbner path (5 seconds) run under this budget + /// instead of their own, so this is how a caller raises them -- and /// here means "do not stop", which for a - /// doubly-exponential algorithm means what it says. + /// doubly-exponential algorithm means what it says. + /// A lid can only be tightened. The proof that a written-out perfect + /// square is one, which runs and + /// offers as a candidate, bounds itself by 2,000 + /// steps and 50 milliseconds against a stall. It runs under the smaller limit on + /// each axis of that and this, so setting this never makes Simplify or + /// Factorize run longer. A proof stopped early is "not proved" and falls back + /// to the symbolic test, so tightening it costs time, not answers. + /// A budget passed as an argument is capped. + /// , + /// and + /// + /// spend the budget they were given, under the smaller limit on each axis of it and + /// this: the outer scope bounds the inner one, and + /// here leaves the argument as passed. + /// + /// + /// A budget names both axes. cannot say "no opinion" + /// about one of them, so a left + /// is "no clock": new WorkBudget { Steps = 1_000_000 } raises the solver's + /// steps and also removes its 60 seconds. Against a lid or an argument the missing + /// clock is simply the looser limit, and theirs applies -- the lid's 50 milliseconds + /// included, which decide how soon the proof gives up and not the answer. Saying + /// "no opinion" per axis is a change to itself, left to v3 + /// (#746). /// /// /// A budget in is reproducible and one in @@ -6709,17 +6738,10 @@ internal static EDecimal DowncastingTolerance /// (#373) /// /// - /// It is honoured only where an algorithm asks. Today that is the system solver -- - /// its Gröbner path, and the ledger - /// keeps over the whole call --, the rewrite graph wherever it runs: - /// , - /// and - /// , and the proof that a written-out perfect - /// square is one, which runs and - /// offers as a candidate. Simplify itself - /// is not bounded by it, and nor is anything else in the library, each of which - /// bounds itself by ceilings of its own that this does not reach; so setting it does - /// not make an arbitrary call bounded. + /// It is honoured only at the sites listed above. Simplify itself is not + /// bounded by it, and nor is anything else in the library, each of which bounds + /// itself by ceilings of its own that this does not reach; so setting it does not + /// make an arbitrary call bounded. /// /// /// diff --git a/Sources/AngouriMath/Core/Budgets/BudgetLedger.cs b/Sources/AngouriMath/Core/Budgets/BudgetLedger.cs index 07bac7201..209fdf105 100644 --- a/Sources/AngouriMath/Core/Budgets/BudgetLedger.cs +++ b/Sources/AngouriMath/Core/Budgets/BudgetLedger.cs @@ -69,11 +69,48 @@ private BudgetLedger(string where, WorkBudget limits) /// /// A ledger for one computation. is what the algorithm - /// bounds itself by when nobody has said otherwise; a caller who sets - /// replaces it. + /// bounds itself by when nobody has set ; + /// says what a set one does to it. + /// https://github.com/asc-community/AngouriMath/issues/2454 /// - internal static BudgetLedger For(string where, WorkBudget ownDefault) - => new(where, MathS.Settings.Budget.IsOverriden ? MathS.Settings.Budget.Value : ownDefault); + internal static BudgetLedger For(string where, WorkBudget ownDefault, BudgetRole role) + => new(where, Limits(ownDefault, role)); + + /// The limits a computation of runs under. + internal static WorkBudget Limits(WorkBudget ownDefault, BudgetRole role) + { + var setting = MathS.Settings.Budget; + if (!setting.IsOverriden) + return ownDefault; + var set = setting.Value; + // A lid is tightened on both axes, not on the clock alone, although a step means + // something different to each algorithm. The incomparability is a reason not to + // *raise* one algorithm's ceiling by a number chosen for another, and a lid is never + // raised. Taking only the clock would ignore a caller who set steps -- the + // reproducible axis -- at exactly the sites where they asked for less. And it is + // cheap: the one lid, the perfect-square proof, completes in 15 to 1,203 steps over + // the unit suite (median 212), and a proof stopped short is "not proved", which falls + // back to the symbolic test -- so a budget below that costs time, and no answer of + // Factorize or Simplify was measured to move under one. + return role switch + { + BudgetRole.Allowance => set, + BudgetRole.Lid or BudgetRole.Argument => Tighter(ownDefault, set), + _ => throw new ArgumentOutOfRangeException(nameof(role), role, null), + }; + } + + /// + /// The smaller limit on each axis: what both and + /// allow. A missing is no ceiling, + /// so it yields to any clock. + /// + private static WorkBudget Tighter(WorkBudget a, WorkBudget b) + => new() + { + Steps = Math.Min(a.Steps, b.Steps), + Time = a.Time is { } x && b.Time is { } y ? (x < y ? x : y) : a.Time ?? b.Time, + }; /// /// Charges of work and answers whether the computation may diff --git a/Sources/AngouriMath/Core/Budgets/BudgetRole.cs b/Sources/AngouriMath/Core/Budgets/BudgetRole.cs new file mode 100644 index 000000000..8ced7a44b --- /dev/null +++ b/Sources/AngouriMath/Core/Budgets/BudgetRole.cs @@ -0,0 +1,39 @@ +// +// Copyright (c) 2019-2026 Angouri. +// AngouriMath is licensed under MIT. +// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md. +// Website: https://am.angouri.org. +// + +namespace AngouriMath.Core.Budgets +{ + /// + /// What a computation's own budget is for, which decides what a set + /// does to it. Declared where the ledger is made, + /// , so that each site says which it is. + /// https://github.com/asc-community/AngouriMath/issues/2454 + /// + internal enum BudgetRole + { + /// + /// A guard against a stall inside an operation that is not about this computation + /// at all -- the perfect-square proof Factorize runs. A set budget can only + /// tighten it, so setting one never makes Simplify or Factorize run + /// longer than they would unset. + /// + Lid, + + /// + /// The working allowance of an algorithm a caller asks for by name -- the system + /// solver, the Gröbner path. A set budget replaces it, which is what lets a caller + /// raise it; capping it instead would make raising it do nothing. + /// + Allowance, + + /// + /// A budget the caller passed as an argument. It is the allowance, and a set budget, + /// being the outer scope, caps it: the smaller limit on each axis. + /// + Argument, + } +} diff --git a/Sources/AngouriMath/Core/Budgets/WorkBudget.cs b/Sources/AngouriMath/Core/Budgets/WorkBudget.cs index 271962f67..b3450a3c7 100644 --- a/Sources/AngouriMath/Core/Budgets/WorkBudget.cs +++ b/Sources/AngouriMath/Core/Budgets/WorkBudget.cs @@ -62,8 +62,8 @@ public sealed record WorkBudget /// /// No ceiling on either axis. This is what /// reads as its default — but see that property: leaving it alone means each - /// algorithm keeps its own default, and it is only a caller who sets it who gets - /// this. + /// algorithm keeps its own default, and setting it to this lifts only the working + /// allowances, never a lid. /// public static WorkBudget Unlimited { get; } = new(); } diff --git a/Sources/AngouriMath/Core/Transformations/EqualityOracle.cs b/Sources/AngouriMath/Core/Transformations/EqualityOracle.cs index 656cf9a83..4bd9636e9 100644 --- a/Sources/AngouriMath/Core/Transformations/EqualityOracle.cs +++ b/Sources/AngouriMath/Core/Transformations/EqualityOracle.cs @@ -203,7 +203,8 @@ internal static EqualityAnswer Ask(Entity left, Entity right, WorkBudget budget, throw new ArgumentOutOfRangeException(nameof(domain), domain, "Equality is asked over the complex or the real numbers."); - var ledger = BudgetLedger.For(Where, budget); + // The caller's argument, capped by a set MathS.Settings.Budget. + var ledger = BudgetLedger.For(Where, budget, BudgetRole.Argument); try { if (left.Equals(right)) diff --git a/Sources/AngouriMath/Core/Transformations/Saturation.cs b/Sources/AngouriMath/Core/Transformations/Saturation.cs index 71c36041b..9c6bcc4ef 100644 --- a/Sources/AngouriMath/Core/Transformations/Saturation.cs +++ b/Sources/AngouriMath/Core/Transformations/Saturation.cs @@ -270,7 +270,9 @@ internal static bool ProvesEqual(Entity left, Entity right, var b = graph.AddEntity(right); graph.Rebuild(); - var ledger = BudgetLedger.For(nameof(ProvesEqual), budget); + // A lid: the one caller passes a guard against stalls, not an allowance a user + // chose, so a set MathS.Settings.Budget can only tighten it. + var ledger = BudgetLedger.For(nameof(ProvesEqual), budget, BudgetRole.Lid); Run(graph, rules, ledger, CostModel.Default.Cost); ledger.Report(); return graph.Find(a) == graph.Find(b); diff --git a/Sources/AngouriMath/Core/Transformations/Transformation.Catalogue.cs b/Sources/AngouriMath/Core/Transformations/Transformation.Catalogue.cs index 4d6395984..3232384d6 100644 --- a/Sources/AngouriMath/Core/Transformations/Transformation.Catalogue.cs +++ b/Sources/AngouriMath/Core/Transformations/Transformation.Catalogue.cs @@ -441,9 +441,9 @@ private static class PolynomialFactorizationHolder /// /// What this call may spend before it settles for the best it has found so far. /// is charged once per e-node the graph actually creates; - /// is the wall-clock backstop. A caller who sets - /// overrides this, the same as every other bounded - /// computation in the library. + /// is the wall-clock backstop. A set + /// caps this, the smaller limit on each axis + /// applying, and does not replace it. /// /// Which candidate counts as cheapest once exploration stops. /// @@ -770,7 +770,9 @@ internal EqualitySaturationTransformation(WorkBudget budget, CostModel costModel var root = graph.AddEntity(input); graph.Rebuild(); - var ledger = BudgetLedger.For(Name, budget); + // The caller passed this budget, so it is theirs to spend and a set + // MathS.Settings.Budget, the outer scope, caps it. + var ledger = BudgetLedger.For(Name, budget, BudgetRole.Argument); // Stop once the answer has: after two passes in which the cheapest member of the // root's class did not change, further merging can only add members this // extraction would not choose. That is the fixed point a caller who extracts @@ -829,7 +831,8 @@ internal GraphCanonicalizationTransformation(WorkBudget budget, RewriteRuleGrowt var root = graph.AddEntity(input); graph.Rebuild(); - var ledger = BudgetLedger.For(Name, budget); + // An argument, as in EqualitySaturationTransformation. + var ledger = BudgetLedger.For(Name, budget, BudgetRole.Argument); // The same stop as EqualitySaturationTransformation's, on the least member // rather than the cheapest, since that is what this extracts. Entity? last = null; diff --git a/Sources/AngouriMath/Functions/Algebra/Groebner/Buchberger.cs b/Sources/AngouriMath/Functions/Algebra/Groebner/Buchberger.cs index 6ed042a09..6956f5304 100644 --- a/Sources/AngouriMath/Functions/Algebra/Groebner/Buchberger.cs +++ b/Sources/AngouriMath/Functions/Algebra/Groebner/Buchberger.cs @@ -51,7 +51,8 @@ internal sealed class GroebnerBudget [ConstantField] internal static readonly WorkBudget Default = new() { Time = TimeSpan.FromSeconds(5) }; - private readonly BudgetLedger ledger = BudgetLedger.For("Gröbner", Default); + // An allowance: a set MathS.Settings.Budget replaces Default, so a caller can raise it. + private readonly BudgetLedger ledger = BudgetLedger.For("Gröbner", Default, BudgetRole.Allowance); /// /// Charges one unit of work and answers whether to carry on. Called where the diff --git a/Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver.cs b/Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver.cs index e0b1bb205..6dc06fce4 100644 --- a/Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver.cs +++ b/Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver.cs @@ -120,7 +120,9 @@ internal static Set Solve(Entity equation, Variable x) // budget of its own is what bounded the fast path and left the fall-through // unbounded, so the same `Solve` finished or did not depending on which internal // path accepted it. https://github.com/asc-community/AngouriMath/issues/896 - var ledger = BudgetLedger.For("SolveSystem", SystemSolveBudget); + // An allowance: a set MathS.Settings.Budget replaces SystemSolveBudget, which is + // what the exceptions below mean by "raise MathS.Settings.Budget to allow more". + var ledger = BudgetLedger.For("SolveSystem", SystemSolveBudget, BudgetRole.Allowance); try { var variables = new Variable[vars.Length]; diff --git a/Sources/AngouriMath/Functions/Simplification/Patterns/Patterns.ExpandFactorize.cs b/Sources/AngouriMath/Functions/Simplification/Patterns/Patterns.ExpandFactorize.cs index 0659be336..746763348 100644 --- a/Sources/AngouriMath/Functions/Simplification/Patterns/Patterns.ExpandFactorize.cs +++ b/Sources/AngouriMath/Functions/Simplification/Patterns/Patterns.ExpandFactorize.cs @@ -201,8 +201,10 @@ internal static Entity PerfectSquareRules(Entity x) /// What the rewrite graph may spend proving a cross term equal to its candidate: two /// thousand steps and fifty milliseconds. On the corpus the safe ceiling saturates a /// term of this size in under a millisecond and a few dozen e-nodes, so this is a lid - /// against the stall family rather than a working allowance. + /// against the stall family rather than a working allowance, and is declared as one: a set + /// can only tighten it. /// https://github.com/asc-community/AngouriMath/issues/1200 + /// https://github.com/asc-community/AngouriMath/issues/2454 /// [ConstantField] private static readonly WorkBudget PerfectSquareProofBudget = new() { Steps = 2_000, Time = TimeSpan.FromMilliseconds(50) }; diff --git a/Sources/Tests/UnitTests/Core/Budgets/BudgetRoleTest.cs b/Sources/Tests/UnitTests/Core/Budgets/BudgetRoleTest.cs new file mode 100644 index 000000000..6f8fb8c7a --- /dev/null +++ b/Sources/Tests/UnitTests/Core/Budgets/BudgetRoleTest.cs @@ -0,0 +1,146 @@ +// +// Copyright (c) 2019-2026 Angouri. +// AngouriMath is licensed under MIT. +// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md. +// Website: https://am.angouri.org. +// + +using System; +using System.Linq; +using AngouriMath.Core.Budgets; +using AngouriMath.Core.Transformations; +using AngouriMath.Extensions; +using AngouriMath.Functions; +using AngouriMath.Functions.Algebra; +using Xunit; + +namespace AngouriMath.Tests.Core.Budgets +{ + /// + /// What a set does to each kind of budget: it replaces + /// an allowance, and it can only tighten a lid or a budget passed as an argument. + /// https://github.com/asc-community/AngouriMath/issues/2454 + /// + [Trait("Area", "Core")] + public sealed class BudgetRoleTest + { + private static readonly WorkBudget Lid + = new() { Steps = 2_000, Time = TimeSpan.FromMilliseconds(50) }; + + [Fact] + public void UnsetLeavesEveryRoleOnItsOwn() + { + Assert.False(MathS.Settings.Budget.IsOverriden); + foreach (var role in new[] { BudgetRole.Lid, BudgetRole.Allowance, BudgetRole.Argument }) + Assert.Equal(Lid, BudgetLedger.Limits(Lid, role)); + } + + [Fact] + public void UnlimitedDoesNotLiftALid() + { + using var _ = MathS.Settings.Budget.Set(WorkBudget.Unlimited); + Assert.Equal(Lid, BudgetLedger.Limits(Lid, BudgetRole.Lid)); + } + + [Fact] + public void ALidTakesTheSmallerLimitOnEachAxis() + { + using (MathS.Settings.Budget.Set(new WorkBudget { Steps = 1 })) + Assert.Equal(Lid with { Steps = 1 }, BudgetLedger.Limits(Lid, BudgetRole.Lid)); + using (MathS.Settings.Budget.Set(new WorkBudget { Steps = 1_000_000 })) + Assert.Equal(Lid, BudgetLedger.Limits(Lid, BudgetRole.Lid)); + using (MathS.Settings.Budget.Set(new WorkBudget { Time = TimeSpan.FromMilliseconds(1) })) + Assert.Equal(Lid with { Time = TimeSpan.FromMilliseconds(1) }, BudgetLedger.Limits(Lid, BudgetRole.Lid)); + } + + /// + /// What the solver's refusal tells a caller to do -- "raise MathS.Settings.Budget to allow + /// more" -- has to work, so an allowance is replaced, not capped. + /// + [Fact] + public void ARaisedBudgetRaisesAnAllowance() + { + var raised = new WorkBudget { Steps = 100_000 }; + using var _ = MathS.Settings.Budget.Set(raised); + Assert.Equal(raised, BudgetLedger.Limits(EquationSolver.SystemSolveBudget, BudgetRole.Allowance)); + } + + [Fact] + public void AnArgumentIsCappedByTheSetBudget() + { + var argument = new WorkBudget { Steps = 1_000, Time = TimeSpan.FromSeconds(1) }; + using (MathS.Settings.Budget.Set(WorkBudget.Unlimited)) + Assert.Equal(argument, BudgetLedger.Limits(argument, BudgetRole.Argument)); + using (MathS.Settings.Budget.Set(new WorkBudget { Steps = 5 })) + Assert.Equal(argument with { Steps = 5 }, BudgetLedger.Limits(argument, BudgetRole.Argument)); + } + + /// + /// The perfect-square proof under an unlimited setting keeps the lid its caller gave it. + /// It used to run to saturation; ten steps do not reach the proof it would find. + /// + [Fact] + public void TheProofKeepsItsLidUnderUnlimited() + { + using var _ = MathS.Settings.Budget.Set(WorkBudget.Unlimited); + using var recording = BudgetRecording.Start(); + var proved = Saturation.ProvesEqual("2 * sqrt(2) * sqrt(3)".ToEntity(), "2 * sqrt(6)".ToEntity(), + Saturation.SafeRules, new WorkBudget { Steps = 10, Time = TimeSpan.FromSeconds(30) }); + Assert.False(proved); + Assert.Equal("steps", Assert.Single(recording.Outcomes).Reason); + } + + /// + /// A tight setting tightens the proof, and the collapse still answers: an unproved cross + /// term falls back to the symbolic test, so the proof stopping early costs time, not the + /// answer. + /// + [Fact] + public void ATightSettingTightensTheProofAndTheCollapseStillAnswers() + { + using var _ = MathS.Settings.Budget.Set(new WorkBudget { Steps = 1 }); + using var recording = BudgetRecording.Start(); + Assert.Equal("(sqrt(3) + sqrt(2)) ^ 2".ToEntity(), + Patterns.CollapseToPerfectSquare("2 + 2 * sqrt(2) * sqrt(3) + 3".ToEntity())); + var proofs = recording.Outcomes.Where(outcome => outcome.Where == nameof(Saturation.ProvesEqual)).ToList(); + Assert.NotEmpty(proofs); + Assert.All(proofs, proof => Assert.True(proof.Steps <= 2)); + } + + /// + /// AreEqual with a budget of its own inside an unlimited scope spends that budget. + /// It used to run unlimited and prove the equality. + /// + [Fact] + public void AnExplicitBudgetHoldsInsideAnUnlimitedScope() + { + using var _ = MathS.Settings.Budget.Set(WorkBudget.Unlimited); + var answer = MathS.AreEqual("2 * sqrt(2) * sqrt(3)", "2 * sqrt(6)", new WorkBudget { Steps = 1 }); + Assert.Equal(EqualityVerdict.Unknown, answer.Verdict); + Assert.Equal("steps", answer.Budget.Reason); + } + + /// The rows of BREAKING-CHANGES.md, which were run unlimited on 2.7.0. + [Theory] + [InlineData("x * 2 * 3 + x", "x * 2 * 3 + x", "6 * x + x")] + [InlineData("a * b + b * a", "a * b + b * a", "a * b + a * b")] + public void TheGraphSpendsItsArgumentInsideAnUnlimitedScope(string input, string saturated, string canonical) + { + var budget = new WorkBudget { Steps = 5, Time = TimeSpan.FromSeconds(30) }; + using var _ = MathS.Settings.Budget.Set(WorkBudget.Unlimited); + Assert.Equal(saturated.ToEntity(), + Transformation.EqualitySaturation(budget, AngouriMath.Core.CostModel.Default).ApplyOrKeep(input.ToEntity())); + Assert.Equal(canonical.ToEntity(), + Transformation.CanonicalizationOverGraph(budget).ApplyOrKeep(input.ToEntity())); + } + + [Fact] + public void ATighterScopeCapsAnExplicitBudget() + { + using var _ = MathS.Settings.Budget.Set(new WorkBudget { Steps = 1 }); + var answer = MathS.AreEqual("2 * sqrt(2) * sqrt(3)", "2 * sqrt(6)", new WorkBudget { Steps = 1_000_000 }); + Assert.Equal(EqualityVerdict.Unknown, answer.Verdict); + Assert.Equal("steps", answer.Budget.Reason); + } + } +} diff --git a/Sources/Tests/UnitTests/Core/Transformations/ConstantFoldTest.cs b/Sources/Tests/UnitTests/Core/Transformations/ConstantFoldTest.cs index 1cd4fa83d..b9a0dc797 100644 --- a/Sources/Tests/UnitTests/Core/Transformations/ConstantFoldTest.cs +++ b/Sources/Tests/UnitTests/Core/Transformations/ConstantFoldTest.cs @@ -68,7 +68,7 @@ private static (bool Saturated, int Nodes, Entity? Extracted) Saturate(string so { var graph = new EGraph(); var root = graph.AddEntity(source.ToEntity()); - var ledger = BudgetLedger.For(nameof(ConstantFoldTest), budget); + var ledger = BudgetLedger.For(nameof(ConstantFoldTest), budget, BudgetRole.Argument); var saturated = Saturation.Run(graph, Saturation.RulesUpTo(RewriteRuleGrowth.Rearranges), ledger, n => n.Complexity); return (saturated, graph.NodeCount, graph.Extract(root, n => n.Complexity)); } diff --git a/Sources/Tests/UnitTests/Core/Transformations/ProvidedInAnEClassTest.cs b/Sources/Tests/UnitTests/Core/Transformations/ProvidedInAnEClassTest.cs index 4b35f391e..6f9db6f3b 100644 --- a/Sources/Tests/UnitTests/Core/Transformations/ProvidedInAnEClassTest.cs +++ b/Sources/Tests/UnitTests/Core/Transformations/ProvidedInAnEClassTest.cs @@ -30,7 +30,7 @@ public sealed class ProvidedInAnEClassTest var graph = new EGraph(); var root = graph.AddEntity(source.ToEntity()); var ledger = BudgetLedger.For(nameof(ProvidedInAnEClassTest), - new WorkBudget { Steps = 200_000, Time = TimeSpan.FromSeconds(20) }); + new WorkBudget { Steps = 200_000, Time = TimeSpan.FromSeconds(20) }, BudgetRole.Argument); Saturation.Run(graph, Saturation.RulesUpTo(ceiling), ledger, node => node.Complexity); return graph.Extract(root, node => node.Complexity); diff --git a/Sources/Tests/UnitTests/Core/Transformations/RunawayBreadthTest.cs b/Sources/Tests/UnitTests/Core/Transformations/RunawayBreadthTest.cs index 51ea0512f..bb9080431 100644 --- a/Sources/Tests/UnitTests/Core/Transformations/RunawayBreadthTest.cs +++ b/Sources/Tests/UnitTests/Core/Transformations/RunawayBreadthTest.cs @@ -77,7 +77,7 @@ private static (bool Saturated, int Nodes, string Extracted) Saturate(string sou { var graph = new EGraph(); var root = graph.AddEntity(source.ToEntity()); - var ledger = BudgetLedger.For(nameof(RunawayBreadthTest), Quick); + var ledger = BudgetLedger.For(nameof(RunawayBreadthTest), Quick, BudgetRole.Argument); var saturated = Saturation.Run(graph, rules, ledger, node => node.Complexity); return (saturated, graph.NodeCount, graph.Extract(root, node => node.Complexity)?.Stringize() ?? "(nothing)"); } diff --git a/Sources/Tests/UnitTests/Core/Transformations/SaturationAblationTest.cs b/Sources/Tests/UnitTests/Core/Transformations/SaturationAblationTest.cs index 118088bc7..10d7017e7 100644 --- a/Sources/Tests/UnitTests/Core/Transformations/SaturationAblationTest.cs +++ b/Sources/Tests/UnitTests/Core/Transformations/SaturationAblationTest.cs @@ -91,7 +91,7 @@ private static (bool Saturated, int Nodes) Saturate(string source, IReadOnlyList { var graph = new EGraph(); graph.AddEntity(source.ToEntity()); - var ledger = BudgetLedger.For(nameof(SaturationAblationTest), Quick); + var ledger = BudgetLedger.For(nameof(SaturationAblationTest), Quick, BudgetRole.Argument); var saturated = Saturation.Run(graph, rules, ledger, node => node.Complexity); return (saturated, graph.NodeCount); }