| import OAI.Combinatorics.EditDistance.RecursiveWords |
|
|
| namespace OAI |
|
|
| /-! |
| # Length, alphabet, and distortion recurrences for word families |
| -/ |
|
|
| namespace EditFamily |
| open scoped BigOperators |
|
|
| def familyLength (b P s : ℕ) : ℕ := (2 * (2 * b - 1) * P ^ (b / 2)) ^ s |
|
|
| def familyAlphabet (b P : ℕ) : ℕ → ℕ |
| | 0 => 2 * P |
| | s+1 => 1 + (2 * b - 1) * familyAlphabet b P s |
|
|
| noncomputable def familyAlpha (s : ℕ) : ℝ := (24 : ℝ)⁻¹ ^ s |
|
|
| noncomputable def familyBudget (b P h : ℕ) : ℕ → ℝ |
| | 0 => 2 |
| | s+1 => 2 * (2 * (P : ℝ)) ^ (2 * h) / (P ^ (b / 2) : ℕ) + familyBudget b P h s / h |
|
|
| lemma familyLength_pos {b P : ℕ} (hb : 0 < b) (hP : 0 < P) (s : ℕ) : |
| 0 < familyLength b P s := by |
| unfold familyLength |
| exact pow_pos (Nat.mul_pos (Nat.mul_pos (by omega) (by omega)) (pow_pos hP _)) _ |
|
|
| lemma familyAlpha_pos (s : ℕ) : 0 < familyAlpha s := by |
| unfold familyAlpha |
| positivity |
|
|
| lemma familyAlpha_le_one (s : ℕ) : familyAlpha s ≤ 1 := by |
| unfold familyAlpha |
| exact pow_le_one₀ (by norm_num) (by norm_num) |
|
|
| lemma familyBudget_nonneg (b P h s : ℕ) : 0 ≤ familyBudget b P h s := by |
| induction s with |
| | zero => norm_num [familyBudget] |
| | succ s ih => |
| exact add_nonneg (by positivity) (div_nonneg ih (Nat.cast_nonneg _)) |
|
|
| noncomputable def recursive {J : Type} [Fintype J] [DecidableEq J] |
| (p : J → ℕ) (hp : ∀ j, (p j).Prime) (hinj : Function.Injective p) |
| (P : ℕ) (hP : 1 ≤ P) (hpLow : ∀ j, P ≤ p j) (hpHigh : ∀ j, p j ≤ 2 * P) |
| (h : ℕ) (hh : 0 < h) : (s : ℕ) → (j : J) → |
| Family (p j) (familyLength (Fintype.card J) P s) (familyAlphabet (Fintype.card J) P s) |
| (familyAlpha s) (familyBudget (Fintype.card J) P h s) |
| | 0, j => base (hp j) (hpHigh j) |
| | s+1, j => by |
| let F := recursive p hp hinj P hP hpLow hpHigh h hh s |
| have hn : familyLength (Fintype.card J) P (s+1) = |
| 2 * ((2 * Fintype.card J - 1) * familyLength (Fintype.card J) P s) * |
| P ^ (Fintype.card J / 2) := by |
| simp only [familyLength, pow_succ] |
| ring |
| have ha : familyAlpha (s+1) = familyAlpha s / 24 := by |
| simp only [familyAlpha, pow_succ, div_eq_mul_inv] |
| rw [hn, familyAlphabet, ha, familyBudget] |
| exact successor j F hp hinj P hP hpLow hpHigh |
| (familyLength_pos (Fintype.card_pos_iff.mpr ⟨j⟩) (by omega) s) |
| (familyAlpha_pos s).le (familyAlpha_le_one s) |
| (familyBudget_nonneg _ _ _ _) h hh |
|
|
| lemma familyAlphabet_pos {b P : ℕ} (hP : 0 < P) (s : ℕ) : 0 < familyAlphabet b P s := by |
| cases s <;> simp only [familyAlphabet] <;> omega |
|
|
| lemma familyAlphabet_le {b P : ℕ} (hb : 0 < b) (hP : 0 < P) (s : ℕ) : |
| familyAlphabet b P s ≤ (2 * P + 1) * (2 * b) ^ s := by |
| induction s with |
| | zero => simp [familyAlphabet] |
| | succ s ih => |
| have hap := familyAlphabet_pos (b := b) hP s |
| have hb' : 2 * b - 1 + 1 = 2 * b := by omega |
| calc |
| familyAlphabet b P (s+1) = 1 + (2 * b - 1) * familyAlphabet b P s := rfl |
| _ ≤ 2 * b * familyAlphabet b P s := by |
| nlinarith [Nat.mul_add (2 * b - 1) 1 (familyAlphabet b P s)] |
| _ ≤ 2 * b * ((2 * P + 1) * (2 * b) ^ s) := Nat.mul_le_mul_left _ ih |
| _ = (2 * P + 1) * (2 * b) ^ (s+1) := by rw [pow_succ]; ring |
|
|
| end EditFamily |
|
|
| end OAI |
|
|
