math / data /lean /OAI /Combinatorics /EditDistance /RecursiveWords.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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