File size: 4,655 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
import OAI.Combinatorics.EditDistance.Families
import OAI.Combinatorics.EditDistance.DirectSums
import OAI.Combinatorics.EditDistance.Slots

namespace OAI

/-!
# Averaged displacement control for recursive word families
-/

namespace EditFamily
open scoped BigOperators
open EditDistortion EditAverage EditFourier EditSlots

section InductiveControl
variable {J : Type} [Fintype J] [DecidableEq J] (i : J)

noncomputable def weight (j : J) : ℝ := (EditSlots.multiplicity i j : ℝ) / (2 * (2 * Fintype.card J - 1))

lemma weight_pos (j : J) : 0 < weight i j := by
  have hb : 0 < (Fintype.card J : ℝ) := by
    exact_mod_cast Fintype.card_pos_iff.mpr ⟨i⟩
  have hb' : (1 : ℝ) ≀ Fintype.card J := by
    exact_mod_cast (show 1 ≀ Fintype.card J by exact Fintype.card_pos_iff.mpr ⟨i⟩)
  have hc : 0 < (EditSlots.multiplicity i j : ℝ) := by
    by_cases hj : j = i <;> simp [EditSlots.multiplicity, hj, hb]
  exact div_pos hc (by linarith)

lemma sum_weight : (βˆ‘ j : J, weight i j) = 1 / 2 := by
  have hb : (1 : ℝ) ≀ Fintype.card J := by
    exact_mod_cast (show 1 ≀ Fintype.card J by exact Fintype.card_pos_iff.mpr ⟨i⟩)
  simp only [weight, ← Finset.sum_div, sum_multiplicity]
  field_simp [show (2 * (Fintype.card J : ℝ) - 1) β‰  0 by linarith]

variable {p : J β†’ β„•} {m A : β„•} {Ξ± Q : ℝ}
variable (F : βˆ€ j, Family (p j) m A Ξ± Q)

abbrev ProductState := βˆ€ j, (F j).State

def lift (j : J) (e : (F j).State) : ProductState F := Pi.single j e

def allPhase : ProductState F := fun j => (F j).v

lemma sum_lift_vectors : (βˆ‘ j, lift F j (F j).v) = allPhase F := by
  ext j
  simp [lift, allPhase]

omit [Fintype J] in
lemma lift_nsmul (j : J) (u : β„•) (e : (F j).State) :
    lift F j (u β€’ e) = u β€’ lift F j e := by
  ext k
  by_cases hk : k = j
  Β· subst k; simp [lift]
  Β· simp [lift, hk]

lemma variation_zero (H : ProductState F β†’ L1) : variation H 0 = 0 := by
  simp [variation, avg]

lemma component_control (hQ : 0 ≀ Q) (H : ProductState F β†’ L1)
    (hh : βˆ€ j e r, (e,r) ∈ (F j).steps β†’
      variation H (lift F j e) ≀ weight i j * r)
    (j : J) (a : β„•) (ha : a < p j) :
    variation H (a β€’ lift F j (F j).v) ≀ weight i j * Q := by
  by_cases ha0 : a = 0
  Β· simp only [ha0, zero_nsmul, variation_zero]
    exact mul_nonneg (weight_pos i j).le hQ
  let T := EditSlices.slice (fun j => (F j).State) H j (weight i j)
  have hT : βˆ€ e r, (e,r) ∈ (F j).steps β†’ variation T e ≀ r := by
    intro e r her
    rw [EditSlices.variation_slice _ H j _ (weight_pos i j)]
    apply (div_le_iffβ‚€ (weight_pos i j)).mpr
    simpa only [lift, mul_comm] using hh j e r her
  have hC := (F j).control T hT a (Nat.pos_of_ne_zero ha0) ha
  rw [EditSlices.variation_slice _ H j _ (weight_pos i j)] at hC
  have hC' := (div_le_iffβ‚€ (weight_pos i j)).mp hC
  change variation H (lift F j (a β€’ (F j).v)) ≀ Q * weight i j at hC'
  rw [lift_nsmul] at hC'
  simpa only [mul_comm] using hC'

theorem successor_control
    (hp : βˆ€ j, (p j).Prime) (hinj : Function.Injective p)
    (P : ℝ) (hP : 1 ≀ 2 * P) (hpP : βˆ€ j, (p j : ℝ) ≀ 2 * P)
    (h : β„•) (hh : 0 < h) (L : β„•) (hQ : 0 ≀ Q)
    (H : ProductState F β†’ L1) (hΟ„ : variation H (allPhase F) ≀ 2 / L)
    (hlift : βˆ€ j e r, (e,r) ∈ (F j).steps β†’
      variation H (lift F j e) ≀ weight i j * r)
    (u : β„•) (hu : u < p i) :
    variation H (u β€’ lift F i (F i).v) ≀
      2 * (2 * P) ^ (2 * h) / L + Q / h := by
  let (j : J) : NeZero (p j) := ⟨(hp j).ne_zero⟩
  have hv (j : J) : p j β€’ lift F j (F j).v = 0 := by
    rw [← lift_nsmul, (F j).annihilate]
    simp [lift]
  have hc := prime_vector_displacement p (fun j => lift F j (F j).v) hv hp hinj
    P hP hpP h hh H i (u : ZMod (p i))
  rw [ZMod.val_natCast_of_lt hu, sum_lift_vectors] at hc
  have hb (j : J) : avg (fun a : ZMod (p j) => variation H (a.val β€’ lift F j (F j).v)) ≀
      weight i j * Q := by
    rw [← avg_const (X := ZMod (p j)) (weight i j * Q)]
    exact avg_mono (fun a => component_control i F hQ H hlift j a.val (ZMod.val_lt a))
  calc
    _ ≀ (2 * P) ^ (2 * h) * variation H (allPhase F) +
        (2 / (h : ℝ)) * βˆ‘ j, avg (fun a : ZMod (p j) =>
          variation H (a.val β€’ lift F j (F j).v)) := hc
    _ ≀ (2 * P) ^ (2 * h) * (2 / (L : ℝ)) +
        (2 / (h : ℝ)) * βˆ‘ j, weight i j * Q := by
      apply add_le_add
      Β· exact mul_le_mul_of_nonneg_left hΟ„ (pow_nonneg (by linarith) _)
      Β· exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun j _ => hb j)) (by positivity)
    _ = _ := by rw [← Finset.sum_mul, sum_weight]; ring

end InductiveControl
end EditFamily

end OAI