Files
conflict-range/FormalConflictRange/NegCrossLongNonpos.lean
T

387 lines
21 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.NegCrossResidual
/-!
# The crossed negative-begin complete long cell at a nonpositive end offset
A forward complete result with a negative begin offset, `end.offset ≤ 0`, the end key
*below* the begin key (`end_.key < begin_.key`), reported keys below the begin key, and no
feasible clamping database. Every compatible database is nonclamping and resolves the
begin selector onto the reported head; the end selector stays at or below `end_.key`, so
agreement on `[head, begin_.key)` fixes the whole complete window. Every key from the head
up to `begin_.key` is necessary: the reported keys by convexity, keys below `end_.key` by
`necessary_last_to_end_key`, and keys in `[end_.key, begin_.key)` because inserting one
lifts the begin resolution above the reported head.
The minimal conflict range is therefore `[head, begin_.key)`.
-/
namespace FormalConflictRange
/-- **The capacity bound from a negative begin anchor, in the long cell.** In the crossed
complete cell with `end_.key < begin_.key` and `end.offset ≤ 0`, a clamping compatible
database forces `clampNonposBottom`. The interval `[begin.key, end.key)` contributes
nothing, so the stored keys split into the reported keys below `resolve end` and the
`d + 1` pad keys in `[resolve end, end.key)`, all below `begin.key`. -/
theorem clampNonposBottom_of_anchor_neg_long {r : RangeRead} {res : Result} {db : DB}
(hcomp : RangeRead.Compatible db r res)
(hrev : r.reverse = false) (hmore : res.more = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : r.end_.offset ≤ 0)
(hlong : r.end_.key < r.begin.key)
(hanchor : r.begin.anchor db < 0) :
clampNonposBottom r res := by
have hL : resolve db r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hanchor
have hres : res.keys =
db.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < resolve db r.end_)) := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· rw [heq, RangeRead.completeKeys, ite_eq_right (by simp [hrev])]
unfold RangeRead.inRange
rw [hL]
apply List.filter_congr
intro k _
rw [decide_eq_decide]
constructor
· intro h; exact h.2
· intro h; exact ⟨coe_nil_le_key_withTop _, h⟩
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
apply hne
rw [hres, hR]
rw [List.filter_eq_nil_iff]
intro k _
simp only [decide_eq_true_eq]
exact not_lt.mpr (coe_nil_le_key_withTop _)
have hRE : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hlen : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 :=
between_resolve_end_length hend hRne
have htR : res.keys.length = cnt db (resolve db r.end_) := by
rw [hres, cnt, List.countP_eq_length_filter]
have hrep : reportedBelowBegin r res = res.keys.length := by
unfold reportedBelowBegin
rw [List.countP_eq_length]
intro k hk
rw [decide_eq_true_eq]
rw [hres] at hk
have hk' : ((k : Key) : WithTop Key) < resolve db r.end_ :=
of_decide_eq_true (List.mem_filter.mp hk).2
exact lt_trans hk' (lt_of_le_of_lt hRE hlong)
have hcB : cnt db r.begin.key ≤ beginSlack r := by
have h := hanchor
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin)] at h
unfold cnt
omega
have hRB : resolve db r.end_ ≤ r.begin.key := le_trans hRE (le_of_lt hlong)
have hEB : r.end_.key ≤ r.begin.key := le_of_lt hlong
have h1 : cnt db r.end_.key =
cnt db (resolve db r.end_) + (between db (resolve db r.end_) r.end_.key).length :=
cnt_eq_add_between db hRE
have h2 : cnt db r.begin.key =
cnt db r.end_.key + (between db r.end_.key r.begin.key).length :=
cnt_eq_add_between db hEB
have hbd : (clampNonposD r + 1 : ℕ) ≤ beginSlack r - reportedBelowBegin r res := by
rw [hrep]
have h3 : res.keys.length + (clampNonposD r + 1) ≤ cnt db r.begin.key := by
rw [← htR, hlen] at h1
omega
omega
have hcap0 : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_lt hlong)
unfold clampNonposBottom
rw [hrep, hcap0]
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
have := hbd
omega
have hcast : ((res.keys.length + (clampNonposD r + 1) : ℕ) : ℕ∞) ≤ (beginSlack r : ℕ∞) :=
Nat.cast_le.mpr hnat
simpa [ENat.natCast_add, add_comm, add_left_comm, add_assoc] using hcast
/-- The nonclamping crossed negative-begin complete long cell at a nonpositive end
offset: `end_.key < begin.key`. -/
abbrev negCrossNonclampLongNonpos (r : RangeRead) (res : Result) : Prop :=
r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
r.end_.offset ≤ 0 ∧
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res ≤ beginSlack r ∧ ¬ clampNonposBottom r res ∧
r.end_.key < r.begin.key
/-- The closed form for the nonclamping crossed negative-begin complete long cell at a
nonpositive end offset: `[head, begin.key)`. -/
noncomputable def closedFormNegCrossNonclampLongNonpos (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩
/-- **The nonclamping crossed negative-begin complete long cell at a nonpositive end
offset is minimal.** Failure of the capacity bound makes every compatible database
nonclamping. The complete window is `[head, resolve end)`, so agreement on
`[head, begin.key)` fixes it. Every key from the head up to `begin.key` is necessary:
reported keys by convexity, keys below `end_.key` by `necessary_last_to_end_key`, and keys
in `[end_.key, begin.key)` because the capacity failure leaves `[end_.key, begin.key)`
empty in any compatible database, while inserting one lifts the begin resolution above
the reported head. -/
theorem minimal_closedForm_of_negCross_nonclamp_long_nonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossNonclampLongNonpos r res) :
Minimal r res (closedFormNegCrossNonclampLongNonpos r res) := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hnotbottom, hlong⟩ := hcell
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
rw [← hheadD]; exact hcrossD
obtain ⟨db₀, hcomp₀⟩ := hread
set head : Key := res.keys.head hne with hhead
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hheadD' : res.keys.headD ([] : Key) = head := hheadD.trans hhead
rw [show closedFormNegCrossNonclampLongNonpos r res =
⟨((head : Key) : WithTop Key), r.begin.key⟩ by
unfold closedFormNegCrossNonclampLongNonpos; rw [hheadD']]
have hnonclamp : ∀ db, RangeRead.Compatible db r res → 0 ≤ r.begin.anchor db := by
intro db hcomp
by_contra hneg
push Not at hneg
exact hnotbottom
(clampNonposBottom_of_anchor_neg_long hcomp hrev hmore hne hbegin hend hlong hneg)
have hread₀ : Readable r res := ⟨db₀, hcomp₀⟩
have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_stored₀ : head ∈ db₀.keys :=
RangeRead.compatible_keys_subset hcomp₀ (by rw [hhead]; exact List.head_mem hne)
have hhead_lt_res₀ : ((head : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp (by rw [← hres_eq₀]; exact hhead_mem)).2.2
have hhead_le_res₀ : ((head : Key) : WithTop Key) ≤ resolve db₀ r.end_ := le_of_lt hhead_lt_res₀
have hres_le₀ : resolve db₀ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hhead_lt_E₀ : ((head : Key) : WithTop Key) < r.end_.key :=
lt_of_lt_of_le hhead_lt_res₀ hres_le₀
have hRne₀ : resolve db₀ r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
rw [hR] at hhead_lt_res₀
exact absurd hhead_lt_res₀ (not_lt.mpr (coe_nil_le_key_withTop (head : Key)))
have hL₀ : resolve db₀ r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_anchor_nonneg hcomp₀ hrev hmore hne (hnonclamp db₀ hcomp₀)
have hres_filters : res.keys = between db₀ (head : WithTop Key) (resolve db₀ r.end_) := by
rw [hres_eq₀]
unfold RangeRead.completeKeys RangeRead.inRange between
rw [ite_eq_right (by simp [hrev]), hL₀]
have hlen_end : (between db₀ (head : WithTop Key) r.end_.key).length =
res.keys.length + (clampNonposD r + 1) := by
have hL1 := cnt_eq_add_between db₀ (w₁ := (head : WithTop Key)) (w₂ := r.end_.key)
(le_of_lt hhead_lt_E₀)
have hL2 := cnt_eq_add_between db₀ (w₁ := (head : WithTop Key))
(w₂ := resolve db₀ r.end_) hhead_le_res₀
have hL3 := cnt_eq_add_between db₀ (w₁ := resolve db₀ r.end_) (w₂ := r.end_.key) hres_le₀
have hL4 : (between db₀ (head : WithTop Key) (resolve db₀ r.end_)).length =
res.keys.length := by rw [← hres_filters]
have hp : (between db₀ (resolve db₀ r.end_) r.end_.key).length = clampNonposD r + 1 :=
between_resolve_end_length hend hRne₀
omega
have hlen_begin : (between db₀ (head : WithTop Key) r.begin.key).length = beginSlack r + 1 :=
filter_begin_length_of_anchor_nonneg hcomp₀ hrev hmore hne hbegin hcross
(hnonclamp db₀ hcomp₀)
have hall_reported_lt_E : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
intro k hk
have hklt := (RangeRead.mem_completeKeys.mp (by rw [← hres_eq₀]; exact hk)).2.2
exact lt_of_lt_of_le hklt hres_le₀
have hreported_eq : reportedBelowBegin r res = res.keys.length := by
unfold reportedBelowBegin
rw [List.countP_eq_length]
intro k hk
rw [decide_eq_true_eq]
exact lt_trans (hall_reported_lt_E k hk) hlong
have hnat : beginSlack r < res.keys.length + (clampNonposD r + 1) := by
have hcap0 : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_lt hlong)
have hnotle : ¬ ((reportedBelowBegin r res : ℕ∞) +
(((clampNonposD r + 1 : ℕ)) : ℕ∞) ≤ (beginSlack r : ℕ∞)) := by
intro hle
apply hnotbottom
unfold clampNonposBottom
rw [hcap0, tsub_zero]
exact hle
have hltE : (beginSlack r : ℕ∞) < (reportedBelowBegin r res : ℕ∞) +
(((clampNonposD r + 1 : ℕ)) : ℕ∞) := not_le.mp hnotle
rw [hreported_eq, ← ENat.natCast_add] at hltE
exact ENat.natCast_lt_natCast.mp hltE
have hP0 : (between db₀ r.end_.key r.begin.key).length = 0 := by
have hb := cnt_eq_add_between db₀ (w₁ := (head : WithTop Key)) (w₂ := r.begin.key)
(le_trans (le_of_lt hhead_lt_E₀) (le_of_lt hlong))
have he := cnt_eq_add_between db₀ (w₁ := (head : WithTop Key)) (w₂ := r.end_.key)
(le_of_lt hhead_lt_E₀)
have hbe := cnt_eq_add_between db₀ (w₁ := r.end_.key) (w₂ := r.begin.key) (le_of_lt hlong)
rw [hlen_begin] at hb
rw [hlen_end] at he
omega
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· have step : ∀ db₁ db₂, AgreeOn ⟨((head : Key) : WithTop Key), r.begin.key⟩ db₁ db₂ →
RangeRead.Compatible db₁ r res → RangeRead.Compatible db₂ r res := by
intro db₁ db₂ hagree hcomp₁
have hlim : RangeRead.withinLimit r res.keys := hcomp₁.1
have hres_eq : res.keys = RangeRead.completeKeys db₁ r := by
rcases hcomp₁.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_stored : head ∈ db₁.keys :=
RangeRead.compatible_keys_subset hcomp₁ (by rw [hhead]; exact List.head_mem hne)
have hL₁ : resolve db₁ r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_anchor_nonneg hcomp₁ hrev hmore hne (hnonclamp db₁ hcomp₁)
have hfilt : db₁.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) =
db₂.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) := by
simpa [AgreeOn, ConflictRange.keys] using hagree
have hfiltE := filter_between_eq_of_filter_end_eq (db₁ := db₁) (db₂ := db₂)
(a := head) (B := r.end_.key) (E := r.begin.key) (le_of_lt hlong) hfilt
have hlen₁ : (db₁.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key))).length =
beginSlack r + 1 :=
filter_begin_length_of_anchor_nonneg hcomp₁ hrev hmore hne hbegin hcross
(hnonclamp db₁ hcomp₁)
have hhead_in₁ : head ∈ db₁.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) :=
List.mem_filter.mpr ⟨hhead_stored, by rw [decide_eq_true_eq]; exact ⟨le_refl _, hcross⟩⟩
have hhead_stored₂ : head ∈ db₂.keys :=
List.mem_of_mem_filter (by rw [← hfilt]; exact hhead_in₁)
have hlen₂ : (db₂.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key))).length =
beginSlack r + 1 := by rw [← hfilt]; exact hlen₁
have hL₂ : resolve db₂ r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_filter_len hbegin hhead_stored₂ hcross hlen₂
have hhead_lt_res : ((head : Key) : WithTop Key) < resolve db₁ r.end_ :=
(RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem)).2.2
have hres_le : resolve db₁ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hhead_lt_E : ((head : Key) : WithTop Key) < r.end_.key :=
lt_of_lt_of_le hhead_lt_res hres_le
have hR : resolve db₂ r.end_ = resolve db₁ r.end_ := by
rcases resolve_eq_nil_or_eq_top_or_mem (db := db₁) (s := r.end_) with hn | ht | ⟨q, _, hqeq⟩
· rw [hn] at hhead_lt_res
exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le_key_withTop _))
· exact absurd ht (resolve_ne_top_of_offset_nonpos hend)
· have hqne : q ≠ [] := by
intro hqnil
rw [hqnil] at hqeq
rw [hqeq] at hhead_lt_res
exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le_key_withTop _))
have hqspec : (db₁.keys.filter (fun k : Key =>
decide (((k : Key) : WithTop Key) < r.end_.key))).reverse[
(-r.end_.offset).toNat]? = some q :=
resolve_filter_reverse_eq_some_of_ne_nil hend hqne hqeq
have hqa : ((head : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) := by
rw [← hqeq]; exact le_of_lt hhead_lt_res
have hR' : resolve db₂ r.end_ = ((q : Key) : WithTop Key) :=
resolve_eq_of_agree_between (db₁ := db₁) (db₂ := db₂) (s := r.end_) hend rfl
(le_of_lt hhead_lt_E) hfiltE hqspec hqa
rw [hR', hqeq]
have hP : db₁.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db₁ r.end_)) =
db₂.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db₁ r.end_)) :=
filter_between_eq_of_filter_end_eq (db₁ := db₁) (db₂ := db₂)
(a := head) (B := resolve db₁ r.end_) (E := r.end_.key) hres_le hfiltE
have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), ite_eq_right (by simp [hrev]), hL₁, hL₂, hR]
exact hP
exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
· intro k hlo hhi
have hk_head : head ≤ k := WithTop.coe_le_coe.mp hlo
have hk_lt_B : ((k : Key) : WithTop Key) < r.begin.key := hhi
by_cases hklast : k ≤ res.keys.getLast hne
· exact necessary_of_between_result hread₀ hhead_mem (List.getLast_mem hne) hk_head hklast
· have hk_gt_last : res.keys.getLast hne < k := lt_of_not_ge hklast
have hhead_le_last : head ≤ res.keys.getLast hne := by
have hsrt : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
rw [hhead, List.head_eq_getElem hne, List.getLast_eq_getElem hne]
exact hsrt.getElem_le_getElem_iff.mpr (by
have := List.length_pos_of_ne_nil hne
omega)
have hk_gt_head : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
by_cases hkE : ((k : Key) : WithTop Key) < r.end_.key
· exact fun cr hs => necessary_last_to_end_key hread₀ hrev hmore hne (by omega)
cr hs (le_of_lt hk_gt_last) hkE
· have hkE_le : r.end_.key ≤ ((k : Key) : WithTop Key) := le_of_not_gt hkE
intro cr hs
by_contra hkcr
have hknot : k ∉ db₀.keys := by
intro hkdb
have hkmem : k ∈ between db₀ r.end_.key r.begin.key := by
unfold between
exact List.mem_filter.mpr ⟨hkdb, by rw [decide_eq_true_eq]; exact ⟨hkE_le, hk_lt_B⟩⟩
have hpos : 0 < (between db₀ r.end_.key r.begin.key).length :=
List.length_pos_of_mem hkmem
omega
have hgt : ((head : Key) : WithTop Key) < resolve (db₀.insert k hknot) r.begin :=
resolve_begin_insert_gt hbegin hhead_stored₀ hcross hknot hk_gt_head hk_lt_B hlen_begin
have hhead_notin : head ∉ RangeRead.completeKeys (db₀.insert k hknot) r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev])]
intro hmem
simp only [List.mem_filter, decide_eq_true_eq] at hmem
exact absurd hmem.2.1 (not_le.mpr hgt)
have hcomp₁ : RangeRead.Compatible (db₀.insert k hknot) r res :=
(hs db₀ _ (ConflictRange.keys_insert_of_not_mem cr db₀ hknot hkcr).symm).mp hcomp₀
have hres_eq₁ : res.keys = RangeRead.completeKeys (db₀.insert k hknot) r := by
rcases hcomp₁.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
exact hhead_notin (by rw [← hres_eq₁]; exact hhead_mem)
/-- The reversed nonclamping crossed negative-begin complete long cell at a nonpositive
end offset. -/
abbrev negCrossNonclampLongNonposRev (r : RangeRead) (res : Result) : Prop :=
r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
r.end_.offset ≤ 0 ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res ≤ beginSlack r ∧ ¬ clampNonposBottom r res ∧
r.end_.key < r.begin.key
/-- The reversed closed form for the nonclamping crossed negative-begin complete long
cell at a nonpositive end offset: `[last reported, begin.key)`. -/
noncomputable def closedFormNegCrossNonclampLongNonposRev (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.getLastD ([] : Key) : Key) : WithTop Key), r.begin.key⟩
/-- **The reversed nonclamping crossed negative-begin complete long cell at a nonpositive
end offset is minimal**, by flipping the traversal. -/
theorem minimal_closedForm_of_negCross_nonclamp_long_nonpos_rev {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossNonclampLongNonposRev r res) :
Minimal r res (closedFormNegCrossNonclampLongNonposRev r res) := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hnotbottom, hlong⟩ := hcell
have hne' : res.keys.reverse ≠ [] := by simpa using hne
have hheadD : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by
rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse]
have hcount : reportedBelowBegin { r with reverse := false }
{ keys := res.keys.reverse, more := false } = reportedBelowBegin r res := by
unfold reportedBelowBegin
exact List.Perm.countP_eq _ (List.reverse_perm res.keys)
have hbottom' : clampNonposBottom { r with reverse := false }
{ keys := res.keys.reverse, more := false } ↔ clampNonposBottom r res := by
unfold clampNonposBottom
rw [hcount]
rfl
have hcell' : negCrossNonclampLongNonpos { r with reverse := false }
{ keys := res.keys.reverse, more := false } := by
refine ⟨rfl, hbegin, rfl, hne', hend, ?_, ?_, ?_, hlong⟩
· rw [hheadD]; exact hcrossD
· rw [hcount]; exact hmq
· intro h
exact hnotbottom (hbottom'.mp h)
have hread' : Readable { r with reverse := false }
{ keys := res.keys.reverse, more := false } := by
obtain ⟨db, hcomp⟩ := hread
exact ⟨db, (compatible_flip (db := db) (b := true) hrev hmore).mpr hcomp⟩
have hmin := minimal_closedForm_of_negCross_nonclamp_long_nonpos hread' hcell'
have hcr : closedFormNegCrossNonclampLongNonpos { r with reverse := false }
{ keys := res.keys.reverse, more := false } =
closedFormNegCrossNonclampLongNonposRev r res := by
unfold closedFormNegCrossNonclampLongNonpos closedFormNegCrossNonclampLongNonposRev
rw [hheadD]
rw [hcr] at hmin
exact (minimal_flip (b := true) hrev hmore).mp hmin
end FormalConflictRange