Download data/lean/OAI/Combinatorics/EditDistance/RecursiveWords.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/EditDistance/RecursiveWords.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/EditDistance/RecursiveWords.lean
-
curl -L -o RecursiveWords.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/EditDistance/RecursiveWords.lean
18.6 kB
| import OAI.Combinatorics.EditDistance.RecursiveControl | |
| import OAI.Combinatorics.EditDistance.RowConstruction | |
| import OAI.Combinatorics.EditDistance.PrimePeriods | |
| namespace OAI | |
| /-! | |
| # Recursive payloads, markers, symbol codes, and word separation | |
| -/ | |
| namespace EditFamily | |
| open scoped BigOperators | |
| open EditDistortion EditAverage EditFourier EditSlots | |
| lemma torsionHom_intCast {G : Type*} [AddCommGroup G] (p : β) (v : G) (hv : p β’ v = 0) | |
| (a : β€) : torsionHom p v hv (a : ZMod p) = a β’ v := by | |
| simp [torsionHom] | |
| lemma Family.far_int {p m A : β} {Ξ± Q : β} (F : Family p m A Ξ± Q) | |
| (hp : 0 < p) (z : F.State) (a : β€) (ha : Β¬ (p : β€) β£ a) : | |
| (m : β) * Ξ± β€ (indel (List.ofFn (F.word z)) (List.ofFn (F.word (z + a β’ F.v))) : β) := by | |
| let : NeZero p := β¨Nat.ne_of_gt hpβ© | |
| let x : ZMod p := a | |
| have hx : x β 0 := fun h => ha ((ZMod.intCast_zmod_eq_zero_iff_dvd a p).mp h) | |
| have hv : x.val β’ F.v = a β’ F.v := by | |
| rw [β torsionHom_apply p F.v F.annihilate x] | |
| exact torsionHom_intCast p F.v F.annihilate a | |
| rw [β hv] | |
| exact F.far z x.val (Nat.pos_of_ne_zero (fun h => hx ((ZMod.val_eq_zero x).mp h))) (ZMod.val_lt x) | |
| section Words | |
| variable {J : Type} [Fintype J] [DecidableEq J] (i : J) | |
| variable {p : J β β} {m A : β} {Ξ± Q : β} | |
| variable (F : β j, Family (p j) m A Ξ± Q) | |
| noncomputable def payloadList (z : ProductState F) (row : β) : List (Slots i Γ Fin A) := | |
| tagged (enumeration i) (fun r => List.ofFn ((F (component i r)).word | |
| (z (component i r) + row β’ (F (component i r)).v))) | |
| lemma payload_length (z : ProductState F) (row : β) : | |
| (payloadList i F z row).length = (2 * Fintype.card J - 1) * m := by | |
| rw [payloadList, tagged_length, enumeration, List.map_ofFn, List.sum_ofFn] | |
| simp only [Function.comp_apply, List.length_ofFn, Finset.sum_const, Finset.card_univ, | |
| Fintype.card_fin, nsmul_eq_mul, slots_card, Nat.cast_id] | |
| noncomputable def payloadFn (z : ProductState F) (row : β) : | |
| Fin ((2 * Fintype.card J - 1) * m) β (Slots i Γ Fin A) := | |
| fixedFn (payloadList i F z row) (payload_length i F z row) | |
| @[simp] lemma ofFn_payloadFn (z : ProductState F) (row : β) : | |
| List.ofFn (payloadFn i F z row) = payloadList i F z row := ofFn_fixedFn _ _ | |
| noncomputable def rawWord (L : β) (z : ProductState F) : List (Option (Slots i Γ Fin A)) := | |
| EditRows.rowWord (fun row : Fin L => payloadFn i F z row.val) | |
| @[simp] lemma rawWord_length (L : β) (z : ProductState F) : | |
| (rawWord i F L z).length = 2 * ((2 * Fintype.card J - 1) * m) * L := | |
| EditRows.rowWord_length _ | |
| omit [Fintype J] in | |
| lemma shift_state (z : ProductState F) (u row row' : β) (j : J) : | |
| (z + u β’ lift F i (F i).v) j + row' β’ (F j).v = | |
| (z j + row β’ (F j).v) + | |
| ((row' : β€) - (row : β€) + if j = i then (u : β€) else 0) β’ (F j).v := by | |
| by_cases hj : j = i | |
| Β· subst j | |
| simp only [Pi.add_apply, Pi.smul_apply, lift, Pi.single_eq_same] | |
| simp [add_zsmul, sub_zsmul] | |
| abel | |
| Β· simp only [Pi.add_apply, Pi.smul_apply, lift, Pi.single_eq_of_ne hj, smul_zero, | |
| ite_eq_right hj, add_zero, sub_zsmul, natCast_zsmul] | |
| abel | |
| noncomputable def componentDistance (z z' : ProductState F) (row row' : β) (j : J) : β := | |
| indel (List.ofFn ((F j).word (z j + row β’ (F j).v))) | |
| (List.ofFn ((F j).word (z' j + row' β’ (F j).v))) | |
| omit [Fintype J] [DecidableEq J] in | |
| lemma componentDistance_nonneg (z z' : ProductState F) (row row' : β) (j : J) : | |
| 0 β€ componentDistance F z z' row row' j := Nat.cast_nonneg _ | |
| lemma payload_distance_ge_sum (z z' : ProductState F) (row row' : β) : | |
| (β r : Slots i, componentDistance F z z' row row' (component i r)) β€ | |
| (indel (payloadList i F z row) (payloadList i F z' row') : β) := by | |
| exact sum_indel_le_tagged (enumeration i) (enumeration_nodup i) (enumeration_full i) _ _ | |
| omit [Fintype J] in | |
| lemma componentDistance_far (hp : β j, (p j).Prime) | |
| (z : ProductState F) (u row row' : β) (j : J) | |
| (ha : Β¬ (p j : β€) β£ ((row' : β€) - (row : β€) + if j = i then (u : β€) else 0)) : | |
| (m : β) * Ξ± β€ componentDistance F z (z + u β’ lift F i (F i).v) row row' j := by | |
| unfold componentDistance | |
| rw [shift_state] | |
| exact (F j).far_int (hp j).pos _ _ ha | |
| lemma payload_separation | |
| (hp : β j, (p j).Prime) (hinj : Function.Injective p) | |
| (P : β) (hP : 1 β€ P) (hpP : β j, P β€ p j) (hΞ± : 0 β€ Ξ±) | |
| (z : ProductState F) (u : β) (hu0 : 0 < u) (hu : u < p i) | |
| (row row' : β) (hr : row < P ^ (Fintype.card J / 2)) | |
| (hr' : row' < P ^ (Fintype.card J / 2)) : | |
| Ξ± * Fintype.card J * m / 3 β€ | |
| (indel (payloadList i F z row) | |
| (payloadList i F (z + u β’ lift F i (F i).v) row') : β) := by | |
| let D := componentDistance F z (z + u β’ lift F i (F i).v) row row' | |
| have hDn (j : J) : 0 β€ D j := componentDistance_nonneg F _ _ _ _ j | |
| have hsum := payload_distance_ge_sum i F z (z + u β’ lift F i (F i).v) row row' | |
| rw [sum_slots] at hsum | |
| change (Fintype.card J : β) * D i + β j : {j : J // j β i}, D j β€ _ at hsum | |
| have hma : 0 β€ (m : β) * Ξ± := mul_nonneg (Nat.cast_nonneg _) hΞ± | |
| have hrest : 0 β€ β j : {j : J // j β i}, D j := Finset.sum_nonneg (fun j _ => hDn j) | |
| by_cases hphase : Β¬(p i : β€) β£ ((row' : β€) - row + u) | |
| Β· have hf : (m : β) * Ξ± β€ D i := by | |
| exact componentDistance_far i F hp z u row row' i (by simpa using hphase) | |
| have hmul := mul_le_mul_of_nonneg_left hf (Nat.cast_nonneg (Fintype.card J) : (0 : β) β€ _) | |
| have hbma : 0 β€ (Fintype.card J : β) * ((m : β) * Ξ±) := mul_nonneg (Nat.cast_nonneg _) hma | |
| nlinarith | |
| Β· push Not at hphase | |
| let q : β€ := (row' : β€) - row | |
| have hq : q β 0 := by | |
| intro hq | |
| have hd : (p i : β€) β£ (u : β€) := by simpa [q, hq] using hphase | |
| have hd' : p i β£ u := by exact_mod_cast hd | |
| exact Nat.not_dvd_of_pos_of_lt hu0 hu hd' | |
| have hqr : q.natAbs < P ^ (Fintype.card J / 2) := by | |
| apply Int.ofNat_lt.mp | |
| rw [Int.natCast_natAbs] | |
| apply abs_lt.mpr | |
| dsimp [q] | |
| have hrZ : (row : β€) < (P : β€) ^ (Fintype.card J / 2) := by exact_mod_cast hr | |
| have hrZ' : (row' : β€) < (P : β€) ^ (Fintype.card J / 2) := by exact_mod_cast hr' | |
| constructor <;> omega | |
| let S := Finset.univ.filter (fun j => j β i β§ Β¬(p j : β€) β£ q) | |
| have hc : Fintype.card J - Fintype.card J / 2 β€ S.card := | |
| EditPhase.many_nonzero_phases p hp hinj hP hpP hq hqr i | |
| have hbc : (Fintype.card J : β) / 3 β€ (S.card : β) := by | |
| have hn : Fintype.card J β€ 3 * (Fintype.card J - Fintype.card J / 2) := by omega | |
| have hn' : (Fintype.card J : β) β€ 3 * ((Fintype.card J - Fintype.card J / 2 : β) : β) := by | |
| exact_mod_cast hn | |
| have hc' : ((Fintype.card J - Fintype.card J / 2 : β) : β) β€ (S.card : β) := by | |
| exact_mod_cast hc | |
| linarith | |
| have hS : (S.card : β) * ((m : β) * Ξ±) β€ β j β S, D j := by | |
| calc | |
| _ = β _j β S, (m : β) * Ξ± := by simp | |
| _ β€ _ := by | |
| apply Finset.sum_le_sum | |
| intro j hj | |
| obtain β¨hji, hdivβ© := (Finset.mem_filter.mp hj).2 | |
| exact componentDistance_far i F hp z u row row' j (by simpa [hji, q] using hdiv) | |
| have hsub : S β Finset.univ.erase i := by | |
| intro j hj | |
| simp only [Finset.mem_erase, Finset.mem_univ, and_true] | |
| exact (Finset.mem_filter.mp hj).2.1 | |
| have hSrest : β j β S, D j β€ β j : {j : J // j β i}, D j := by | |
| rw [β Finset.sum_subtype (Finset.univ.erase i) (by simp) D] | |
| exact Finset.sum_le_sum_of_subset_of_nonneg hsub (fun j _ _ => hDn j) | |
| have hbound := mul_le_mul_of_nonneg_right hbc hma | |
| have hdi : 0 β€ (Fintype.card J : β) * D i := mul_nonneg (Nat.cast_nonneg _) (hDn i) | |
| nlinarith | |
| theorem rawWord_far | |
| (hp : β j, (p j).Prime) (hinj : Function.Injective p) | |
| (P : β) (hP : 1 β€ P) (hpP : β j, P β€ p j) (hm : 0 < m) | |
| (hΞ±0 : 0 β€ Ξ±) (hΞ±1 : Ξ± β€ 1) | |
| (z : ProductState F) (u : β) (hu0 : 0 < u) (hu : u < p i) : | |
| (2 * ((2 * Fintype.card J - 1) * m) * P ^ (Fintype.card J / 2) : β) * (Ξ± / 24) β€ | |
| (indel (rawWord i F (P ^ (Fintype.card J / 2)) z) | |
| (rawWord i F (P ^ (Fintype.card J / 2)) (z + u β’ lift F i (F i).v)) : β) := by | |
| have hb : 1 β€ Fintype.card J := Fintype.card_pos_iff.mpr β¨iβ© | |
| have hB : 0 < (2 * Fintype.card J - 1) * m := Nat.mul_pos (by omega) hm | |
| have hbR : (1 : β) β€ Fintype.card J := by exact_mod_cast hb | |
| have hcast : ((2 * Fintype.card J - 1 : β) : β) = 2 * (Fintype.card J : β) - 1 := by | |
| rw [Nat.cast_sub (by omega), Nat.cast_mul, Nat.cast_ofNat, Nat.cast_one] | |
| have htB : Ξ± * Fintype.card J * m / 6 β€ (((2 * Fintype.card J - 1) * m : β) : β) := by | |
| rw [Nat.cast_mul, hcast] | |
| have ha := mul_le_mul_of_nonneg_right hΞ±1 (Nat.cast_nonneg (Fintype.card J) : (0 : β) β€ _) | |
| have ha' := mul_le_mul_of_nonneg_right ha (Nat.cast_nonneg m : (0 : β) β€ _) | |
| nlinarith [Nat.cast_nonneg m (Ξ± := β)] | |
| have h := EditRows.indel_row_separation | |
| (fun r : Fin (P ^ (Fintype.card J / 2)) => payloadFn i F z r.val) | |
| (fun r : Fin (P ^ (Fintype.card J / 2)) => payloadFn i F (z + u β’ lift F i (F i).v) r.val) | |
| hB htB (by | |
| intro r r' | |
| rw [ofFn_payloadFn, ofFn_payloadFn] | |
| convert payload_separation i F hp hinj P hP hpP hΞ±0 z u hu0 hu r r' r.isLt r'.isLt using 1 | |
| ring) | |
| change (P ^ (Fintype.card J / 2) : β) * (Ξ± * Fintype.card J * m / 6) β€ _ at h | |
| apply le_trans _ h | |
| simp only [Nat.cast_mul, Nat.cast_ofNat, hcast] | |
| have ha : 0 β€ Ξ± * m * (P ^ (Fintype.card J / 2) : β) := by positivity | |
| nlinarith | |
| lemma payload_distance_le_sum (z z' : ProductState F) (row : β) : | |
| (indel (payloadList i F z row) (payloadList i F z' row) : β) β€ | |
| β r : Slots i, componentDistance F z z' row row (component i r) := by | |
| have h := cost_tagged_le (enumeration i) | |
| (fun r => List.ofFn ((F (component i r)).word (z (component i r) + row β’ (F (component i r)).v))) | |
| (fun r => List.ofFn ((F (component i r)).word (z' (component i r) + row β’ (F (component i r)).v))) false | |
| change indel (payloadList i F z row) (payloadList i F z' row) β€ _ at h | |
| rw [enumeration, List.map_ofFn, List.sum_ofFn] at h | |
| have h' := Nat.cast_le (Ξ± := β).mpr h | |
| rw [Nat.cast_sum] at h' | |
| change (indel (payloadList i F z row) (payloadList i F z' row) : β) β€ | |
| β x : Fin (Fintype.card (Slots i)), componentDistance F z z' row row | |
| (component i ((Fintype.equivFin (Slots i)).symm x)) at h' | |
| rw [(Fintype.equivFin (Slots i)).symm.sum_comp | |
| (fun r => componentDistance F z z' row row (component i r))] at h' | |
| exact h' | |
| omit [Fintype J] in | |
| lemma componentDistance_lift (j : J) (e : (F j).State) (r : β) | |
| (her : (e,r) β (F j).steps) (z : ProductState F) (row : β) (k : J) : | |
| componentDistance F z (z + lift F j e) row row k β€ if k = j then m * r else 0 := by | |
| by_cases hk : k = j | |
| Β· subst k | |
| have he : (z + lift F j e) j + row β’ (F j).v = (z j + row β’ (F j).v) + e := by | |
| simp [lift, add_right_comm] | |
| unfold componentDistance | |
| rw [he, ite_eq_left rfl] | |
| exact (F j).cheap e r her (z j + row β’ (F j).v) | |
| Β· have he : (z + lift F j e) k + row β’ (F k).v = z k + row β’ (F k).v := by | |
| simp [lift, hk] | |
| simp only [componentDistance, he, ite_eq_right hk] | |
| change (cost false _ _ : β) β€ 0 | |
| simp only [cost_refl, Nat.cast_zero, le_refl] | |
| lemma payload_cheap_lift (j : J) (e : (F j).State) (r : β) | |
| (her : (e,r) β (F j).steps) (z : ProductState F) (row : β) : | |
| (indel (payloadList i F z row) (payloadList i F (z + lift F j e) row) : β) β€ | |
| multiplicity i j * m * r := by | |
| calc | |
| _ β€ β s : Slots i, componentDistance F z (z + lift F j e) row row (component i s) := | |
| payload_distance_le_sum i F z (z + lift F j e) row | |
| _ β€ β s : Slots i, if component i s = j then (m : β) * r else 0 := by | |
| apply Finset.sum_le_sum | |
| intro s _ | |
| exact componentDistance_lift F j e r her z row (component i s) | |
| _ = _ := by rw [sum_slots_delta]; ring | |
| lemma rawWord_cheap_lift (hm : 0 < m) (L : β) | |
| (j : J) (e : (F j).State) (r : β) (her : (e,r) β (F j).steps) (z : ProductState F) : | |
| (indel (rawWord i F L z) (rawWord i F L (z + lift F j e)) : β) β€ | |
| (2 * ((2 * Fintype.card J - 1) * m) * L : β) * (weight i j * r) := by | |
| have hb : 1 β€ Fintype.card J := Fintype.card_pos_iff.mpr β¨iβ© | |
| have hB : 0 < (2 * Fintype.card J - 1) * m := Nat.mul_pos (by omega) hm | |
| have hbR : (1 : β) β€ Fintype.card J := by exact_mod_cast hb | |
| have hcast : ((2 * Fintype.card J - 1 : β) : β) = 2 * (Fintype.card J : β) - 1 := by | |
| rw [Nat.cast_sub (by omega), Nat.cast_mul, Nat.cast_ofNat, Nat.cast_one] | |
| have h := EditRows.indel_rowWord_le hB | |
| (fun row : Fin L => payloadFn i F z row.val) | |
| (fun row : Fin L => payloadFn i F (z + lift F j e) row.val) | |
| have h' := Nat.cast_le (Ξ± := β).mpr h | |
| change (indel (rawWord i F L z) (rawWord i F L (z + lift F j e)) : β) β€ _ at h' | |
| rw [Nat.cast_sum] at h' | |
| simp only [ofFn_payloadFn] at h' | |
| calc | |
| _ β€ β row : Fin L, (indel (payloadList i F z row.val) | |
| (payloadList i F (z + lift F j e) row.val) : β) := h' | |
| _ β€ β _row : Fin L, (multiplicity i j : β) * m * r := | |
| Finset.sum_le_sum (fun row _ => payload_cheap_lift i F j e r her z row.val) | |
| _ = _ := by | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, | |
| weight, Nat.cast_mul, Nat.cast_ofNat, hcast] | |
| field_simp [show (2 * (Fintype.card J : β) - 1) β 0 by linarith] | |
| lemma payload_allPhase (z : ProductState F) (row : β) : | |
| payloadList i F (z + allPhase F) row = payloadList i F z (row+1) := by | |
| unfold payloadList | |
| congr 1 | |
| funext s | |
| congr 2 | |
| simp only [Pi.add_apply, allPhase, add_nsmul, one_nsmul] | |
| abel | |
| lemma rawWord_cheap_phase (hm : 0 < m) (L : β) (hL : 0 < L) (z : ProductState F) : | |
| (indel (rawWord i F L z) (rawWord i F L (z + allPhase F)) : β) β€ | |
| (2 * ((2 * Fintype.card J - 1) * m) * L : β) * (2 / (L : β)) := by | |
| have hb : 1 β€ Fintype.card J := Fintype.card_pos_iff.mpr β¨iβ© | |
| have hB : 0 < (2 * Fintype.card J - 1) * m := Nat.mul_pos (by omega) hm | |
| have h := EditRows.indel_row_shift hL hB | |
| (fun row : Fin L => payloadFn i F z row.val) | |
| (fun row : Fin L => payloadFn i F (z + allPhase F) row.val) (by | |
| intro a b hab | |
| apply List.ofFn_injective | |
| rw [ofFn_payloadFn, ofFn_payloadFn, payload_allPhase, hab]) | |
| have h' := Nat.cast_le (Ξ± := β).mpr h | |
| change (indel (rawWord i F L z) (rawWord i F L (z + allPhase F)) : β) β€ _ at h' | |
| convert h' using 1 | |
| push_cast | |
| field_simp | |
| ring | |
| noncomputable def symbolCode : Option (Slots i Γ Fin A) β | |
| Fin (1 + (2 * Fintype.card J - 1) * A) := | |
| (Fintype.equivFin _).trans (finCongr (by | |
| rw [Fintype.card_option, Fintype.card_prod, slots_card, Fintype.card_fin] | |
| omega)) | |
| noncomputable def nextWord (L : β) (z : ProductState F) : | |
| Fin (2 * ((2 * Fintype.card J - 1) * m) * L) β | |
| Fin (1 + (2 * Fintype.card J - 1) * A) := | |
| fixedFn ((rawWord i F L z).map (symbolCode (A := A) i)) (by simp) | |
| @[simp] lemma ofFn_nextWord (L : β) (z : ProductState F) : | |
| List.ofFn (nextWord i F L z) = (rawWord i F L z).map (symbolCode (A := A) i) := | |
| ofFn_fixedFn _ _ | |
| lemma nextWord_distance (L : β) (z z' : ProductState F) : | |
| indel (List.ofFn (nextWord i F L z)) (List.ofFn (nextWord i F L z')) = | |
| indel (rawWord i F L z) (rawWord i F L z') := by | |
| rw [ofFn_nextWord, ofFn_nextWord] | |
| exact cost_map_eq_of_leftInverse (s := false) (symbolCode (A := A) i) | |
| (symbolCode (A := A) i).symm (symbolCode (A := A) i).left_inv _ _ | |
| noncomputable def nextSteps (L : β) : List (ProductState F Γ β) := | |
| (allPhase F, 2 / (L : β)) :: (Finset.univ.toList.flatMap (fun j => | |
| (F j).steps.map (fun er => (lift F j er.1, weight i j * er.2)))) | |
| lemma mem_nextSteps (L : β) (e : ProductState F) (r : β) : | |
| (e,r) β nextSteps i F L β | |
| (e = allPhase F β§ r = 2 / (L : β)) β¨ | |
| β (j : J) (e' : (F j).State) (r' : β), (e',r') β (F j).steps β§ | |
| e = lift F j e' β§ r = weight i j * r' := by | |
| simp only [nextSteps, List.mem_cons, Prod.mk.injEq, List.mem_flatMap, | |
| Finset.mem_toList, Finset.mem_univ, true_and, List.mem_map] | |
| constructor | |
| Β· rintro (h | β¨j, β¨e',r'β©, hmem, hβ©) | |
| Β· exact Or.inl h | |
| Β· exact Or.inr β¨j,e',r',hmem,h.1.symm,h.2.symmβ© | |
| Β· rintro (h | β¨j,e',r',hmem,he,hrβ©) | |
| Β· exact Or.inl h | |
| Β· exact Or.inr β¨j,(e',r'),hmem,he.symm,hr.symmβ© | |
| noncomputable def successor | |
| (hp : β j, (p j).Prime) (hinj : Function.Injective p) | |
| (P : β) (hP : 1 β€ P) (hpLow : β j, P β€ p j) (hpHigh : β j, p j β€ 2 * P) | |
| (hm : 0 < m) (hΞ±0 : 0 β€ Ξ±) (hΞ±1 : Ξ± β€ 1) (hQ : 0 β€ Q) | |
| (h : β) (hh : 0 < h) : | |
| Family (p i) (2 * ((2 * Fintype.card J - 1) * m) * P ^ (Fintype.card J / 2)) | |
| (1 + (2 * Fintype.card J - 1) * A) (Ξ± / 24) | |
| (2 * (2 * (P : β)) ^ (2 * h) / (P ^ (Fintype.card J / 2) : β) + Q / h) := by | |
| classical | |
| let L := P ^ (Fintype.card J / 2) | |
| have hL : 0 < L := pow_pos (by omega) _ | |
| refine { State := ProductState F | |
| group := inferInstance | |
| finite := inferInstance | |
| v := lift F i (F i).v | |
| annihilate := ?_ | |
| word := nextWord i F L | |
| steps := nextSteps i F L | |
| positive := ?_ | |
| cheap := ?_ | |
| far := ?_ | |
| control := ?_ } | |
| Β· rw [β lift_nsmul, (F i).annihilate] | |
| simp [lift] | |
| Β· intro e r her | |
| rcases (mem_nextSteps i F L e r).mp her with β¨rfl,rflβ© | β¨j,e',r',hmem,rfl,rflβ© | |
| Β· exact div_pos (by norm_num) (by exact_mod_cast hL) | |
| Β· exact mul_pos (weight_pos i j) ((F j).positive e' r' hmem) | |
| Β· intro e r her z | |
| rw [nextWord_distance] | |
| rcases (mem_nextSteps i F L e r).mp her with β¨rfl,rflβ© | β¨j,e',r',hmem,rfl,rflβ© | |
| Β· exact rawWord_cheap_phase i F hm L hL z | |
| Β· exact rawWord_cheap_lift i F hm L j e' r' hmem z | |
| Β· intro z u hu0 hu | |
| rw [nextWord_distance] | |
| exact rawWord_far i F hp hinj P hP hpLow hm hΞ±0 hΞ±1 z u hu0 hu | |
| Β· intro H hb u _hu0 hu | |
| apply successor_control i F hp hinj P (by exact_mod_cast (show 1 β€ 2 * P by omega)) | |
| (fun j => by exact_mod_cast hpHigh j) h hh L hQ H | |
| Β· exact hb _ _ ((mem_nextSteps i F L _ _).mpr (Or.inl β¨rfl,rflβ©)) | |
| Β· intro j e r hmem | |
| exact hb _ _ ((mem_nextSteps i F L _ _).mpr (Or.inr β¨j,e,r,hmem,rfl,rflβ©)) | |
| Β· exact hu | |
| end Words | |
| end EditFamily | |
| end OAI | |