Fold the clamped branch into the positive rule

On a clamped nonpositive begin the reference clamped rule `compactClamped` and
the positive rule `compactPositive` coincide: the begin offset is nonpositive,
so `residualB = 0`, and the reversed-truncated rule collapses to its no-skip
case.

So `closedForm` now dispatches on `1 ≤ r.begin.offset ∨ clampedNonpos r res`
and drops `closedFormClamped`, `closedFormNonposRevTrunc` and
`nonposRevReduced`, together with their bridges.  `closedForm_eq` splits
explicitly on the positive and clamped regions, using the new reference lemmas
`ref_closedFormNonposRevTrunc_eq` and `ref_compactClamped_eq_compactPositive`.

The headlines, their statements and the comparator inputs are unchanged.
This commit is contained in:
andrew committed 2026-11-17 14:39:41 -05:00
1 parent efd1b323e7
commit 6cfdb13da1
3 files changed
+66 -99

No files matched your search

+50 -2
View File
@@ -101,14 +101,62 @@ theorem minimal_iff (r : RangeRead) (res : Result) (cr : ConflictRange) :
/-! ## The closed form -/
/-- At a nonpositive begin offset the reversed-truncated rule with no begin skip
agrees with the clamped reference rule: both reduce to `compactReverseTruncatedZero`. -/
theorem ref_closedFormNonposRevTrunc_eq (r : FormalConflictRange.RangeRead)
(res : FormalConflictRange.Result) (h : r.begin.offset ≤ 0)
(hm : res.more = true) (hr : r.reverse = true) :
FormalConflictRange.closedFormNonposRevTrunc r res =
FormalConflictRange.compactReverseTruncated r res := by
have hB : FormalConflictRange.residualB r = 0 := by
unfold FormalConflictRange.residualB
rw [Int.toNat_eq_zero]
omega
simp only [FormalConflictRange.closedFormNonposRevTrunc,
FormalConflictRange.compactReverseTruncated, hB, ite_true,
FormalConflictRange.closedFormOffsetOneTotal,
FormalConflictRange.nonposRevReduced,
FormalConflictRange.closedFormOffsetOneUniversal, hm, hr]
split <;> rfl
/-- On a clamped nonpositive read the reference positive and clamped rules are the
same function: `compactClamped` differs from `compactPositive` only in the
reversed-truncated branch, where the begin offset is nonpositive and the clamp
makes the two rules coincide. -/
theorem ref_compactClamped_eq_compactPositive (r : FormalConflictRange.RangeRead)
(res : FormalConflictRange.Result) (h : FormalConflictRange.clampedNonpos r res) :
FormalConflictRange.compactClamped r res =
FormalConflictRange.compactPositive r res := by
obtain ⟨hne, hbegin, _hlo⟩ := h
unfold FormalConflictRange.compactClamped FormalConflictRange.compactPositive
FormalConflictRange.compactSplit
by_cases hm : res.more = false
· simp [hm, hne]
· have hm' : res.more = true := by cases h : res.more <;> simp_all
simp only [hm]
by_cases hr : r.reverse = false
· simp [hr, hne]
· have hr' : r.reverse = true := by cases h : r.reverse <;> simp_all
simp [hr, hne, ref_closedFormNonposRevTrunc_eq r res hbegin hm' hr']
theorem closedForm_eq (r : RangeRead) (res : Result) :
FormalConflictRange.conflictRangeClosedFormClosed (toRefRead r) (toRefRes res) =
toRefCR (closedForm r res) := by
by_cases hne : res.keys = []
· unfold FormalConflictRange.conflictRangeClosedFormClosed closedForm
simp [hne]
· unfold FormalConflictRange.conflictRangeClosedFormClosed closedForm
simp [hne]
· by_cases hpos : 1 ≤ r.begin.offset
· unfold FormalConflictRange.conflictRangeClosedFormClosed closedForm
simp [hne, hpos]
· by_cases hclamp : clampedNonpos r res
· have hclampRef : FormalConflictRange.clampedNonpos (toRefRead r) (toRefRes res) := by
obtain ⟨hb, hk⟩ := hclamp
exact ⟨hne, hb, hk⟩
unfold FormalConflictRange.conflictRangeClosedFormClosed closedForm
rw [ref_compactClamped_eq_compactPositive _ _ hclampRef]
simp [hne, hpos, hclamp, FormalConflictRange.clampedNonpos, Statement.clampedNonpos]
· unfold FormalConflictRange.conflictRangeClosedFormClosed closedForm
simp [hne, hpos, hclamp]
/-! ## The headlines -/