From 38eba543f6b4f24b0c255c2f4b5d6ae39319e198 Mon Sep 17 00:00:00 2001 From: iris-ai <4+iris-ai@noreply.localhost> Date: Wed, 16 Sep 2026 18:15:44 -0400 Subject: [PATCH] Tighten a validity range to what the arithmetic needs `Holds::through`'s allowance for the two routes to a length was four half steps either side, from a derivation that said each rounding now drops a whole step where it used to drop half of one. That overshot: three is the floor, two fires the `Holds` assertion in `draw_at` on eleven generated cases, and four was never measured as necessary. Tightening both ends did not move one of the rig's twenty-five work counters, so the extra half step was not buying any reuse either. It cannot go to zero. The range has to contain the box a drawing was made in, which the assertion checks, and it must not contain a box the drawing does not hold for, which the warm-against-cold oracle checks -- and those two only coincide where a length reached two ways is the same number. It is not, yet; composing in `i64` and narrowing once is the queued change that would make it so, and shrinking this allowance is how to tell whether that worked. Checked: fmt, clippy, 81 suite tests, 17 core unit tests, the release oracle at 100 seeds and at 1000 seeds of depth 6, all fifteen shrinker cases at 400 seeds of depth 5, and `tabs`, `view`, `minimal`, `text`, `random` and the tab replay byte-identical at 1920x1200 against `2bc6bdf`. Co-Authored-By: Claude Opus 5 --- core/src/ui/holds.rs | 44 ++++++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/core/src/ui/holds.rs b/core/src/ui/holds.rs index 080352c..244aea9 100644 --- a/core/src/ui/holds.rs +++ b/core/src/ui/holds.rs @@ -55,23 +55,26 @@ impl Holds { if rel == 0 { return Self::ANY; } - // In half steps. The box a length was composed down the chain from - // and the box the same length is measured against the window in are - // two routes to one number, each rounding where the other does not, - // and each rounding drops a whole step since `Fixed::mul` truncates: - // two steps either side. The multiply on the way in drops a step of - // its own, and only downward, so it is one more step at the top and - // nothing at the bottom -- and the whole of a box has no multiply in - // it, however many pixels were added to it, since multiplying by one - // is exact and taking the pixels off again is too. Allowing for it - // there anyway compounded, a step a level down a chain of widgets - // each taking the whole of its parent, which is the unsound - // direction: a range wider than what a drawing holds for admits - // reusing it where it does not hold. + // In half steps, and no more than the arithmetic needs: too wide a + // range admits reusing a drawing where it does not hold, and too + // narrow a one leaves out the box a drawing was made in, which the + // `Holds` assertion in `draw_at` catches. `ROUTES` is at that floor + // -- two half steps fires it -- and tightening both ends moved not + // one of the rig's work counters, so the slack is not buying reuse. + // + // `ROUTES` covers a box composed down the chain against the same box + // measured against the window: two routes to one number, each + // rounding where the other does not. `way_in` covers the multiply + // this inverts, which drops a step and only ever downward, so it + // belongs at the top of the range alone -- and the whole of a box has + // no multiply in it, however many pixels were added to it, since + // multiplying by one is exact and taking the pixels off again is too. + // Allowing for it there anyway compounded, a step a level down a + // chain of widgets each taking the whole of its parent. // // Shifted by half of what a `Rel` counts in, to divide by the // fraction: exact until the division takes it back to the grid. - const ROUTES: i64 = 4; + const ROUTES: i64 = 3; let px = len.px.raw() as i64; let half_rel = REL_SHIFT - 1; let way_in = match rel == Rel::ONE.raw() as i64 { @@ -136,19 +139,20 @@ mod tests { /// taken off it, brings no multiply of its own: only the two routes to /// the same length are left to allow for, and not a rounding that did /// not happen. Widening for it as well grew the interval a level at a - /// time down a chain of them. + /// time down a chain of them. Three half steps come back as one whole + /// one, since dividing by a whole box is dividing by one. #[test] fn the_whole_of_a_box_widens_by_the_routes_alone() { let at = Px::from_int(956); - let two_steps = |len: Px| Holds { - lo: len - Px::from_raw(2), - hi: len + Px::from_raw(2), + let one_step = |len: Px| Holds { + lo: len - Px::STEP, + hi: len + Px::STEP, }; - assert_eq!(Holds::at(at).through(Len::FULL), two_steps(at)); + assert_eq!(Holds::at(at).through(Len::FULL), one_step(at)); let less_eight = Len::from_parts(Rel::ONE, Px::from_int(-8)); assert_eq!( Holds::at(at).through(less_eight), - two_steps(at + Px::from_int(8)) + one_step(at + Px::from_int(8)) ); }