/- Released under Apache 2.0 license as described in the file LICENSE. -/ import FormalConflictRange.NegCrossTruncBottomGap import FormalConflictRange.NegCrossTruncClampLong import FormalConflictRange.NegCrossTruncNonclampNonpos import FormalConflictRange.NegCrossTruncAnchor /-! # The crossed negative-begin truncated nonpositive-end gap cell This module closes the last forward truncated residual cell: a crossed forward read with a negative begin offset, a nonpositive end offset, and reported keys strictly below both selectors. The cell splits on whether the gap above `begin.key` has enough capacity for the end overshoot, but the closed form is uniform in the two capacity regimes. Writing `U = max begin.key end_.key`, the minimal sound range is `[⊥, U)` when `clampNonposBottom` holds, and `[head, U)` otherwise (where `head` is the reported head). The soundness half is complete. * Soundness of `[⊥, U)` is `sound_bottomLong_of_nonpos`: agreement below `U` fixes both selector resolutions, and the complete window lies strictly below `end_.key ≤ U`. * In the non-bottom branch every compatible database resolves its begin selector onto the reported head. The gap count in `[head, begin.key)` is forced to `beginSlack + 1` by `gap_count_eq_beginSlack_of_resolve_head`, and `resolve_begin_eq_head_of_agree_gap` transports the resolution across agreement on that gap; this yields soundness of `[head, U)` (`sound_headLong_of_nonbottom`). The necessity half is proved in the companion modules `NegCrossTruncNonposGapA2a`, `NegCrossTruncNonposGapA2aBottom`, and `NegCrossTruncNonposGapCrossFree`. It splits into toggle witnesses for keys in `(last, end_.key)` (erase) and in `[end_.key, U)` (insert), with the filler budget determined by `clampNonposBottom`. The closed form `closedFormNegCrossTruncNonposGap` is defined here; the companion modules prove it minimal on the three subcells. -/ namespace FormalConflictRange /-- The crossed negative-begin truncated nonpositive-end gap cell. -/ def negCrossTruncNonposGap (r : RangeRead) (res : Result) : Prop := res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧ ((leastReported r res : Key) : WithTop Key) < r.begin.key ∧ r.end_.offset ≤ 0 ∧ reportedBelowBegin r res ≤ beginSlack r ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key ∧ r.end_.key < (⊤ : WithTop Key) ∧ (r.end_.key < r.begin.key ∨ intervalCard r.begin.key r.end_.key < (((clampNonposD r + 1 : ℕ)) : ℕ∞)) /-- The closed form of the crossed negative-begin truncated nonpositive-end gap cell. -/ noncomputable def closedFormNegCrossTruncNonposGap (r : RangeRead) (res : Result) : ConflictRange := by classical exact if clampNonposBottom r res then ⟨(([] : Key) : WithTop Key), max r.begin.key r.end_.key⟩ else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), max r.begin.key r.end_.key⟩ /-- **Soundness of `[⊥, max begin.key end.key)` at nonpositive selector offsets.** The complete window lies strictly below `end_.key`, so agreement on every key below the maximum fixes both selector resolutions and the whole window. -/ theorem sound_bottomLong_of_nonpos {r : RangeRead} {res : Result} (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) : Sound r res (⟨(([] : Key) : WithTop Key), max r.begin.key r.end_.key⟩ : ConflictRange) := by intro db₁ db₂ hagree set U : WithTop Key := max r.begin.key r.end_.key with hU have hf : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < U)) = db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < U)) := by have h := hagree rw [AgreeOn, keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h exact h have hB : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := U) (s := r.begin) hbegin (le_max_left _ _) hf have hE : resolve db₁ r.end_ = resolve db₂ r.end_ := resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := U) (s := r.end_) hend (le_max_right _ _) hf have hresEnd : resolve db₁ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend have hpred : ∀ db : DB, db.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_)) = (db.keys.filter (fun k : Key => decide ((k : WithTop Key) < U))).filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_)) := by intro db rw [List.filter_filter] apply List.filter_congr intro k _ by_cases hlt : (k : WithTop Key) < U · simp [hlt] · have hp : ¬ (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_) := by rintro ⟨-, hkk⟩ exact hlt (lt_of_lt_of_le hkk (le_trans hresEnd (le_max_right _ _))) simp [hlt, hp] have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by unfold RangeRead.completeKeys RangeRead.inRange rw [← hB, ← hE] rw [hpred db₁, hpred db₂, hf] unfold RangeRead.Compatible rw [hck] /-- When the begin selector resolves onto a stored key `head` at a negative begin offset, the gap count in `[head, begin.key)` is exactly `beginSlack + 1`. -/ theorem gap_count_eq_beginSlack_of_resolve_head {db : DB} {r : RangeRead} {head : Key} (hbegin : r.begin.offset < 0) (hcross : ((head : Key) : WithTop Key) < r.begin.key) (hanc : 0 ≤ r.begin.anchor db) (hres : resolve db r.begin = ((head : Key) : WithTop Key)) : db.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by classical have hne_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by rw [hres]; exact (WithTop.coe_lt_top head).ne have hltlen : (r.begin.anchor db).toNat < db.keys.length := by by_contra h rw [resolve_eq_top hanc (by omega)] at hne_top exact hne_top rfl have hget : db.keys[(r.begin.anchor db).toNat] = head := by rw [resolve_eq_getElem hanc hltlen] at hres exact WithTop.coe_inj.mp hres have hrank : db.keys.countP (fun k : Key => decide (k < head)) = (r.begin.anchor db).toNat := countP_lt_eq_of_getElem db.sorted hltlen hget have hanchor : r.begin.anchor db = (db.keys.countP (fun k : Key => decide (k < head)) : ℤ) := by have hconv : ((r.begin.anchor db).toNat : ℤ) = r.begin.anchor db := Int.toNat_of_nonneg hanc rw [← hrank] at hconv exact hconv.symm have hsplit := countP_lt_eq_add_filter_withTop db.keys db.nodup (a := head) (B := r.begin.key) (le_of_lt hcross) have hsplit' : db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = db.keys.countP (fun k : Key => decide (k < head)) + (db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key))).length := by rw [hsplit, ← List.countP_eq_length_filter] have hkey := anchor_eq_count_sub_slack db r (le_of_lt hbegin) rw [hanchor] at hkey have hcast : ((db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) = (db.keys.countP (fun k : Key => decide (k < head)) : ℤ) + ((db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key))).length : ℤ) := by rw [hsplit']; push_cast; ring have hG : (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 have h1 : ((db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) = (db.keys.countP (fun k : Key => decide (k < head)) : ℤ) + (beginSlack r : ℤ) + 1 := by linarith [hkey] have : ((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 linarith [hcast, h1] omega rw [List.countP_eq_length_filter] exact hG /-- Given agreement on the gap `[head, begin.key)` and a first database whose begin selector resolves onto the reported head, the second database (which stores the head) resolves onto the head too. The gap count is forced to `beginSlack + 1` by the anchor identity, so the anchor is always the rank of the head. -/ theorem resolve_begin_eq_head_of_agree_gap {db₁ db₂ : DB} {r : RangeRead} {res : Result} {head : Key} (_hrev : r.reverse = false) (_hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hcross : ((head : Key) : WithTop Key) < r.begin.key) (hanc₁ : 0 ≤ r.begin.anchor db₁) (hres₁ : resolve db₁ r.begin = ((head : Key) : WithTop Key)) (hagree : 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))) (hhead_mem₂ : head ∈ db₂.keys) : resolve db₂ r.begin = ((head : Key) : WithTop Key) := by classical have hsplit₁ := countP_lt_eq_add_filter_withTop db₁.keys db₁.nodup (a := head) (B := r.begin.key) (le_of_lt hcross) have hsplit₂ := countP_lt_eq_add_filter_withTop db₂.keys db₂.nodup (a := head) (B := r.begin.key) (le_of_lt hcross) have hsplit₁' : db₁.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = db₁.keys.countP (fun k : Key => decide (k < head)) + db₁.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) := by rw [hsplit₁, ← List.countP_eq_length_filter] have hsplit₂' : db₂.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = db₂.keys.countP (fun k : Key => decide (k < head)) + db₂.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) := by rw [hsplit₂, ← List.countP_eq_length_filter] have hgap₁ : db₁.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := gap_count_eq_beginSlack_of_resolve_head hbegin hcross hanc₁ hres₁ have hgap₂ : db₂.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by rw [List.countP_eq_length_filter, ← hagree, ← List.countP_eq_length_filter] exact hgap₁ have hanchor₂ : r.begin.anchor db₂ = (db₂.keys.countP (fun k : Key => decide (k < head)) : ℤ) := by rw [anchor_eq_count_sub_slack db₂ r (le_of_lt hbegin), hsplit₂', hgap₂] push_cast ring have hlt : db₂.keys.countP (fun k : Key => decide (k < head)) < db₂.keys.length := by obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_mem₂ rw [countP_lt_eq_of_getElem db₂.sorted hi hix] exact hi have hnat : (r.begin.anchor db₂).toNat = db₂.keys.countP (fun k : Key => decide (k < head)) := by rw [hanchor₂, Int.toNat_natCast] have h0 : 0 ≤ r.begin.anchor db₂ := by rw [hanchor₂]; exact Int.natCast_nonneg _ have hlt' : (r.begin.anchor db₂).toNat < db₂.keys.length := by rw [hnat]; exact hlt have hget : db₂.keys[(r.begin.anchor db₂).toNat] = head := by rw [getElem_congr_idx (h' := hnat)] exact getElem_countP_lt db₂.sorted hhead_mem₂ rw [resolve_eq_getElem h0 hlt'] exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hget /-- **Compatibility transfers across agreement on the crossed negative-begin truncated nonpositive-end gap range in the non-bottom branch.** Here the range is `[head, max begin.key end.key)`. -/ theorem compatible_of_agree_negCross_trunc_nonposGap_nonbottom {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hclamp : reportedBelowBegin r res ≤ beginSlack r) (hnbot : ¬ clampNonposBottom r res) (hend : r.end_.offset ≤ 0) {db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res) (hagree : AgreeOn (⟨((res.keys.head hne : Key) : WithTop Key), max r.begin.key r.end_.key⟩ : ConflictRange) db1 db2) : RangeRead.Compatible db2 r res := by set head : Key := res.keys.head hne with hhead set last : Key := res.keys.getLast hne with hlast have hlastD : res.keys.getLastD ([] : Key) = last := by rw [hlast, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by rw [hhead]; exact hcross -- The begin anchor is nonnegative, hence the begin selector resolves onto the head. have hanc1 : 0 ≤ r.begin.anchor db1 := by by_contra h exact hnbot (clampNonposBottom_of_anchor_neg_trunc hc1 hrev hmore hne hbegin hend hclamp (by omega)) have hpre := RangeRead.compatible_keys_prefix hc1 have hckne : RangeRead.completeKeys db1 r ≠ [] := hpre.ne_nil hne obtain ⟨a, _ha_mem, ha_res, ha_head⟩ := RangeRead.completeKeys_head_resolve hrev hckne hanc1 have hhead_eq_a : res.keys.head hne = a := by rw [← ha_head] exact hpre.head hne have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by rw [hhead, hhead_eq_a]; exact ha_res set upper : WithTop Key := max r.begin.key r.end_.key with hupper have hhead_upper : ((head : Key) : WithTop Key) < upper := by rw [hupper] exact lt_of_lt_of_le hcross' (le_max_left _ _) have hlast_mem_res : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r := hpre.subset hlast_mem_res have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ := (RangeRead.mem_completeKeys.mp hlast_ck1).2.2 have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt have hhead_le_last : head ≤ last := by simp only [hhead, hlast] exact hsort.rel_getLast (List.head_mem hne) have hlast_upper : ((last : Key) : WithTop Key) < upper := by have hle := resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend exact lt_of_lt_of_le (lt_of_lt_of_le hlt1 hle) (by rw [hupper]; exact le_max_right _ _) have hmem := (agreeOn_iff (⟨((head : Key) : WithTop Key), upper⟩ : ConflictRange) db1 db2).mp hagree have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) → (k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by intro k hk1 hk2 refine hmem k ?_ exact ⟨hk1, hk2⟩ have hhead_db1 : head ∈ db1.keys := RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne) have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1 have hB_upper : r.begin.key ≤ upper := by rw [hupper]; exact le_max_left _ _ have hgap : db1.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) = db2.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) := by apply eq_of_forall_mem_iff_of_pairwise · exact db1.sorted.pairwise.filter _ · exact db2.sorted.pairwise.filter _ · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨hk1, hge, hlt⟩ exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mp hk1, hge, hlt⟩ · rintro ⟨hk2, hge, hlt⟩ exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mpr hk2, hge, hlt⟩ have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) := resolve_begin_eq_head_of_agree_gap hrev hne hbegin hcross' hanc1 hres1 hgap hhead_db2 have hne_top : resolve db1 r.end_ ≠ (⊤ : WithTop Key) := resolve_ne_top_of_offset_nonpos hend obtain ⟨q, hq⟩ := WithTop.ne_top_iff_exists.mp hne_top have hlast_q : last < q := by have h := hlt1 rw [← hq] at h exact WithTop.coe_lt_coe.mp h have hqne : q ≠ ([] : Key) := by intro hnil have h : last < ([] : Key) := by rwa [hnil] at hlast_q exact absurd h (List.not_lt_nil last) have hq_le_E : ((q : Key) : WithTop Key) ≤ r.end_.key := by rw [hq] exact resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend have hhead_q : ((head : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) := WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hhead_le_last hlast_q)) have hEnd_upper : r.end_.key ≤ upper := by rw [hupper]; exact le_max_right _ _ have hagreeEnd : db1.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) = db2.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := by apply eq_of_forall_mem_iff_of_pairwise · exact db1.sorted.pairwise.filter _ · exact db2.sorted.pairwise.filter _ · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨hk1, hge, hlt⟩ exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mp hk1, hge, hlt⟩ · rintro ⟨hk2, hge, hlt⟩ exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mpr hk2, hge, hlt⟩ have hqget := resolve_filter_reverse_eq_some_of_ne_nil (db := db1) (s := r.end_) hend hqne hq.symm have hresEnd2 : resolve db2 r.end_ = ((q : Key) : WithTop Key) := resolve_eq_of_agree_between (db₁ := db1) (db₂ := db2) (s := r.end_) hend (E := r.end_.key) rfl (le_trans hhead_q hq_le_E) hagreeEnd hqget hhead_q have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by rw [hresEnd2] exact WithTop.coe_lt_coe.mpr hlast_q have hres1len : (RangeRead.completeKeys db1 r).filter (fun k : Key => decide (k ≤ last)) = res.keys := by have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2 rwa [← hlast] at h have hck1 : (RangeRead.completeKeys db1 r).filter (fun k : Key => decide (k ≤ last)) = db1.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1 have hck2 : (RangeRead.completeKeys db2 r).filter (fun k : Key => decide (k ≤ last)) = db2.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2 have heq : db1.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = db2.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by apply eq_of_forall_mem_iff_of_pairwise · exact db1.sorted.pairwise.filter _ · exact db2.sorted.pairwise.filter _ · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨hk1, hge, hle⟩ exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1, hge, hle⟩ · rintro ⟨hk2, hge, hle⟩ exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2, hge, hle⟩ have h2 : (RangeRead.completeKeys db2 r).filter (fun k : Key => decide (k ≤ last)) = res.keys := by rw [hck2, ← heq, ← hck1, hres1len] rw [compatible_iff_truncated_keys hrev hmore hne] exact ⟨by simpa using hc1.1, h2⟩ /-- **Soundness of `[head, max begin.key end.key)` in the non-bottom branch.** -/ theorem sound_headLong_of_nonbottom {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hclamp : reportedBelowBegin r res ≤ beginSlack r) (hnbot : ¬ clampNonposBottom r res) (hend : r.end_.offset ≤ 0) : Sound r res (⟨((res.keys.head hne : Key) : WithTop Key), max r.begin.key r.end_.key⟩ : ConflictRange) := by intro db1 db2 hagree constructor · intro hc1 exact compatible_of_agree_negCross_trunc_nonposGap_nonbottom hrev hmore hne hbegin hcross hclamp hnbot hend hc1 hagree · intro hc2 exact compatible_of_agree_negCross_trunc_nonposGap_nonbottom hrev hmore hne hbegin hcross hclamp hnbot hend hc2 (AgreeOn.symm hagree) end FormalConflictRange