import Mathlib namespace OAI /-! Finite averages, affine spectral gaps, and fourth-moment sampling estimates. From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. -/ set_option autoImplicit true section /-! Scalar cutoffs. Piecewise using only arithmetic and min/max. We use fourth moments (instead of eighth), hence fourth-root flatness. -/ namespace ExactDerandomization.Analysis noncomputable section def fourth (x : ℝ) := Real.sqrt (Real.sqrt x) def Ic (c : ℝ) (f : ℝ→ℝ) := ∀ x y : ℝ, x ≤ y → f x≤f y ∧ f y - f x≤c*(y-x) def Lip (c : ℝ) (f : ℝ→ℝ) := ∀ x y, |f y-f x|≤c*|y-x| def smooth (x : ℝ) := min 1 (max 0 x) def in01 (x : ℝ) := 0≤x ∧ x≤1 lemma fourth_nn (x) : 0≤ fourth x := Real.sqrt_nonneg _ lemma fourth_four {x : ℝ} (h : 0≤x) : fourth x^4=x := by rw [fourth,show 4=2*2 from rfl,pow_mul,Real.sq_sqrt (Real.sqrt_nonneg _),Real.sq_sqrt h] lemma four_fourth {x : ℝ} (h : 0≤x) : fourth (x^4)=x := by unfold fourth; rw [show 4=2*2 from rfl,pow_mul,Real.sqrt_sq (sq_nonneg _),Real.sqrt_sq h] lemma Ic.lip {c f} (h : Ic c f) : Lip c f := by intro x y; rcases le_total x y with h1|h1 · obtain ⟨e,g⟩ := h x y h1 rwa [abs_of_nonneg (sub_nonneg.mpr e),abs_of_nonneg (sub_nonneg.mpr h1)] obtain ⟨e,g⟩ := h y x h1 rw [abs_of_nonpos (sub_nonpos.mpr e),abs_of_nonpos (sub_nonpos.mpr h1)] linarith lemma unit_mem (x) : in01 (smooth x) := by unfold in01 smooth; grind lemma unit_ic : Ic 1 smooth := by intro x y h; unfold smooth; grind lemma exp4inc {x y : ℝ} (hx : in01 x) (hy : in01 y) (h : x≤y) : x^4 ≤ y^4 ∧ y^4-x^4≤4*(y-x) := by have hv : y-x≥0 := by linarith refine ⟨pow_le_pow_left₀ hx.1 h _,?_⟩ have H : y^3+y^2*x+y*x^2+x^3≤4 := calc _ ≤ (1:ℝ)^3+1^2*1+1*1^2+1^3 := by obtain ⟨_,_⟩:=hx; obtain ⟨_,_⟩:=hy; gcongr _ = _ := by norm_num nlinarith [mul_le_mul_of_nonneg_right H hv] lemma icUnitFour : Ic 4 (fun x=>smooth x^4) := by intro x y h obtain ⟨e,t⟩ := unit_ic x y h obtain ⟨s,r⟩ := exp4inc (unit_mem x) (unit_mem y) e exact ⟨s,by dsimp; linarith⟩ def fade (x : ℝ) := (smooth (2*x)^4 + (1-smooth (2*(1-x))^4))/2 lemma fade_low {x : ℝ} (h : x≤1/2) : fade x=(smooth (2*x)^4)/2 := by have hg : 1≤2*(1-x) := by linarith have ht : smooth (2*(1-x))=1 := by unfold smooth; grind unfold fade; rw [ht]; ring lemma fade_symm (x : ℝ) : fade (1-x) = 1-fade x := by simp only [fade,sub_sub_cancel] ring lemma fade_ic : Ic 8 fade := by intro x y e obtain ⟨h1,h2⟩ := icUnitFour (2*x) (2*y) (by linarith) obtain ⟨h3,h4⟩ := icUnitFour (2*(1-y)) (2*(1-x)) (by linarith) dsimp at *; unfold fade; constructor <;> linarith lemma fade_bot {x : ℝ} (h : x≤0) : fade x=0 := by rw [fade_low (by linarith)] have e : 2*x≤0 := by linarith simp [smooth,e] lemma fade_top {x : ℝ} (h : 1≤x) : fade x=1 := by have := fade_symm x rw [fade_bot (by linarith)] at this; linarith lemma fade_mem (x) : in01 (fade x) := by rcases le_total x 0 with h|h · simp [fade_bot h,in01] rcases le_total 1 x with e|e · simp [fade_top e,in01] constructor · simpa only [fade_bot (le_refl _)] using (fade_ic 0 x h).1 · simpa only [fade_top (le_refl _)] using (fade_ic x 1 e).1 def rising (a b x : ℝ) := fade ((x-a)/(b-a)) lemma rising_ic {a b : ℝ} (h:a rcases le_total 0 (y-A-W) with hs|hs <;> simp [hg,hs] <;> linarith lemma shoulder_bot {A W x} (h:0 linarith, by rw [div_le_iff₀ h]; linarith⟩ rw [smooth,max_eq_right hs.1,min_eq_right hs.2,max_eq_left (show x-A-W≤0 from by linarith),add_zero] have H := pow_le_pow_of_le_one hs.1 hs.2 (show 1≤ (4:ℕ) by omega) calc _ ≤ W*((x-A)/W)^1 := mul_le_mul_of_nonneg_left H (le_of_lt h) _ = _ := by field_simp lemma fourth_mono : Monotone fourth := fun _ _ h=>Real.sqrt_le_sqrt (Real.sqrt_le_sqrt h) lemma fourth_pos {x : ℝ} (h : 0fourth (f x)) := by let v:=fourth (f t) have hv : 0?_)⟩ obtain ⟨h1,h2⟩ := h x y he have hx: f t≤f x := (h t x hg).1 let u:= fourth (f x) let z:= fourth (f y) have hu : v ≤ u := fourth_mono hx have hz : u ≤ z := fourth_mono h1 have hs : v^3 ≤ z^3+z^2*u+z*u^2+u^3 := by have e := pow_le_pow_left₀ (le_of_lt hv) hu 3 have hh : 0fourth (fade x)) := by let u := fourth (1/2) have hu : 0 nlinarith lemma rising_root {a b : ℝ} (h : afourth (rising a b x)) ∧ Lip c (fun x=>fourth (1-rising a b x)) := by obtain ⟨c,hc,e⟩ := fade_root have ek := e.lip let u (x : ℝ) := (x-a)/(b-a) have he (x y) : c*|u y-u x|=c/(b-a)*|y-x| := by rw [show u y-u x=(y-x)/(b-a) by unfold u; ring, abs_div, abs_of_pos (sub_pos.2 h)] ring refine ⟨c/(b-a),div_pos hc (sub_pos.2 h),fun x y=>?_,fun x y=>?_⟩ · rw [← he]; exact ek (u x) (u y) · change |fourth (1-fade (u y))-fourth (1-fade (u x))|≤_ rw [← fade_symm,←fade_symm,← he] have ht := ek (1-u x) (1-u y) rwa [show 1-u y-(1-u x)=-(u y-u x) by ring,abs_neg] at ht lemma shoulder_root (A W) (e : 0fourth (shoulder A W x)) := by have H : 0< shoulder A W (A+W) := by have he : A+W-A=W := by ring unfold shoulder smooth; rw [he,div_self (ne_of_gt e)] simpa using e have hp := fourth_pos e refine rise_root (shoulder_ic A W e) H (a:=fourth W/W) (by positivity) (by norm_num) ?_ intro x y hx hy have hl (x) (h : x≤A+W) : fourth (shoulder A W x)=fourth W*smooth ((x-A)/W) := by unfold shoulder rw [max_eq_left (show x-A-W≤0 by linarith),add_zero, fourth_mul (le_of_lt e),four_fourth (unit_mem _).1] rw [hl x (le_trans hx hy),hl y hy] obtain ⟨h1,h2⟩ := unit_ic ((x-A)/W) ((y-A)/W) (by gcongr) refine ⟨by nlinarith,?_⟩ have ht := mul_le_mul_of_nonneg_left h2 (le_of_lt hp) calc _ ≤ _ := show fourth W*smooth ((y-A)/W)-fourth W*smooth ((x-A)/W) ≤ fourth W*(1*((y-A)/W-(x-A)/W)) by rw [← mul_sub]; exact ht _ = _ := by ring end end ExactDerandomization.Analysis end section /-! Basic finite averages in the statistical analysis. -/ namespace ExactDerandomization namespace Analysis noncomputable section open Finset variable {α β : Type} def avs (s : Finset α) (f : α → ℝ) : ℝ := (∑ i ∈ s, f i) / s.card def av [Fintype α] (f : α → ℝ) : ℝ := avs univ f variable [Fintype α] [Fintype β] lemma av_cmul (x : ℝ) (f : α → ℝ) : av (fun i=> x*f i) = x*av f := by rw [av,av,avs,avs,← mul_sum]; ring lemma av_mulc (x : ℝ) (f : α → ℝ) : av (fun i=> f i*x) = av f *x := by simpa only [mul_comm x] using av_cmul x f lemma av_add (f g : α → ℝ) : av (fun i=>f i+g i)=av f+av g := by simp only [av,avs,sum_add_distrib,add_div] lemma av_sub (f g : α → ℝ) : av (fun i=>f i-g i)=av f-av g := by simp only [av,avs,sum_sub_distrib,sub_div] lemma av_div (f : α → ℝ) (x : ℝ) : av (fun i=> f i/x) = av f/x := by simp only [div_eq_mul_inv,av_mulc] lemma av_mono {f g : α → ℝ} (h : f ≤ g) : av f ≤ av g := div_le_div_of_nonneg_right (sum_le_sum fun i _=>h i) (Nat.cast_nonneg _) lemma av_nonneg (f : α → ℝ) (h : ∀ i, 0≤f i) : 0 ≤ av f := div_nonneg (sum_nonneg fun i _=>h i) (Nat.cast_nonneg _) lemma av_swap (f : α → β → ℝ) : av (fun i=> av (f i))=av (fun j=> av (fun i=> f i j)) := by simp only [av,avs,← sum_div] rw [sum_comm] ring lemma av_sum {γ : Type} (s : Finset γ) (f : γ → α → ℝ) : av (fun i=>∑ j∈s, f j i) = ∑ j∈s,av (f j) := by simp only [av,avs,← sum_div] rw [sum_comm] lemma av_equiv (e : α ≃ β) (f : β → ℝ) : av (fun i=> f (e i)) = av f := by simp only [av,avs,card_univ,Fintype.card_congr e] rw [Fintype.sum_equiv e _ f fun i=>rfl] lemma av_perm (e : Equiv.Perm α) (f : α → ℝ) : av (fun i=> f (e i))=av f := av_equiv e f lemma av_prod (f : α × β → ℝ) : av f = av (fun a=> av (fun b=> f (a,b))) := by simp only [av,avs,card_univ,Fintype.card_prod,Nat.cast_mul,← sum_div] rw [Fintype.sum_prod_type] simp only [div_eq_mul_inv,mul_inv_rev] ring lemma av_const [Nonempty α] (c : ℝ) : av (fun _ : α=> c) = c := by simp [av,avs,Fintype.card_pos.ne'] lemma av_zero : av (fun _ : α=> (0:ℝ)) = 0 := by simp [av,avs] lemma av_card [Nonempty α] (f : α → ℝ) : (Fintype.card α : ℝ)*av f = ∑ i,f i := by rw [mul_comm]; simp [av,avs,Fintype.card_pos.ne'] variable [Nonempty α] lemma av_sq_le (f : α → ℝ) : av f ^2 ≤ av (fun i=>f i^2) := by let c := av f have h := av_nonneg (fun i=> f i^2 - (2*c*f i)+c^2) (fun i=>by nlinarith [sq_nonneg (f i-c)]) rw [av_add, av_sub, av_const,av_cmul] at h dsimp [c] at h; nlinarith lemma av_four_le (f : α → ℝ) : av f ^4 ≤ av (fun i=>f i^4) := by calc av f ^4 = (av f^2)^2 := by ring _ ≤ (av (fun i=>f i^2))^2 := pow_le_pow_left₀ (sq_nonneg _) (av_sq_le f) _ _ ≤ av (fun i=>(f i^2)^2) := av_sq_le _ _ = _ := by simp only [pow_succ, pow_zero]; ring_nf /-- Variance around the finite average. -/ def var2 (f : α → ℝ) := av (fun i=>(f i-av f)^2) lemma var2_sum (f : α → ℝ) : var2 f = av (fun i=> f i^2) - av f^2 := by unfold var2 have he (i : α) : (f i-av f)^2=f i^2-(2*av f)*f i+(av f)^2 := by ring simp only [he,av_add,av_sub,av_const,av_cmul] ring lemma var2_best (f : α → ℝ) (z : ℝ) : var2 f ≤ av (fun i=>(f i-z)^2) := by rw [var2_sum] have he (i : α) : (f i-z)^2=f i^2-2*z*f i+z^2 := by ring simp only [he,av_add,av_sub,av_cmul,av_const] nlinarith [sq_nonneg (av f-z)] lemma var2_pair (f : α → ℝ) : av (fun i=> av (fun j=> (f i-f j)^2)) = 2*var2 f := by have h (i j : α) : (f i-f j)^2=f i^2-(2*f i)*f j+f j^2 := by ring simp only [h,av_add,av_sub,av_cmul,av_const,av_mulc,var2_sum] ring lemma pair_four (f : α → ℝ) (h : av f=0) : av (fun i=> f i^4) ≤ av (fun i=> av (fun j=> (f i-f j)^4)) := by apply av_mono; intro i have he := av_four_le (fun j=>f i-f j) simpa only [av_sub,av_const,h,sub_zero] using he end end Analysis end ExactDerandomization end section namespace ExactDerandomization.Analysis noncomputable section open Finset Complex open scoped ComplexConjugate namespace Square abbrev T (n : ℕ) := ZMod n × ZMod n abbrev order (n : ℕ) [NeZero n] := Fintype.card (T n) variable {n : ℕ} [NeZero n] abbrev c (x : ZMod n) := ZMod.stdAddChar x lemma cab (i : ZMod n) : ‖c i‖ = 1 := Circle.norm_coe _ lemma csq (i : ZMod n) : normSq (c i)=1 := by rw [← Complex.sq_norm,cab]; norm_num lemma cconj (i : ZMod n) : conj (c i)=c (-i) := by have hi : c i * c (-i) = 1 := by rw [c,c,← AddChar.map_add_eq_mul]; simp have ht := mul_conj (c i) rw [csq, Complex.ofReal_one] at ht exact mul_left_cancel₀ (by intro h; simp [h] at hi) (ht.trans hi.symm) def dot (x y : T n) : ZMod n := x.1*y.1+x.2*y.2 abbrev e (x y : T n) := c (dot x y) lemma ortho (x : T n) : ∑ k : T n, e k x = if x=0 then (order n:ℂ) else 0 := by have h (a : ZMod n) : ∑ k, c (k*a) = if a=0 then (n:ℂ) else 0 := by simp only [c,AddChar.sum_mulShift a (ZMod.isPrimitive_stdAddChar _)] split <;> simp_all have hi (a b : ZMod n) : e (a,b) x=c (a*x.1)*c (b*x.2) := AddChar.map_add_eq_mul _ _ _ rw [Fintype.sum_prod_type] simp only [hi,← mul_sum,← sum_mul,h] rcases x with ⟨a,b⟩ by_cases ha : a=0 <;> by_cases hb : b=0 <;> simp [ha,hb,T,order,Prod.ext_iff] lemma cross (x y : T n) : ∑ k : T n, e k x * conj (e k y) = if x=y then (order n:ℂ) else 0 := by have hi (k : T n) : e k x * conj (e k y) = e k (x-y) := by simp only [e,cconj,c,← AddChar.map_add_eq_mul] congr 1 unfold dot; simp only [Prod.fst_sub, Prod.snd_sub]; ring simp only [hi,ortho,sub_eq_zero] def hat (f : T n → ℂ) (k : T n) := ∑ x, e k x*f x lemma parse (f : T n → ℂ) : ∑ k, normSq (hat f k) = order n * ∑ x, normSq (f x) := by apply Complex.ofReal_injective simp only [ofReal_sum,ofReal_mul,ofReal_natCast,← mul_conj] have he (k) : hat f k*conj (hat f k) = ∑ x, ∑ y, (e k x * conj (e k y)) * (f x*conj (f y)) := by simp only [hat, map_sum,map_mul]; rw [sum_mul]; simp only [mul_sum]; congr! 2; ring simp only [he] rw [sum_comm] rw [mul_sum] apply sum_congr rfl; intro i _ rw [sum_comm]; simp_rw [← sum_mul,cross]; simp lemma hat_sub (f g : T n → ℂ) (k) : hat (fun i=> f i-g i) k = hat f k-hat g k := by simp [hat,mul_sub,sum_sub_distrib] lemma hat_shift (f : T n → ℂ) (y k : T n) : hat (fun x=> f (x+y)) k = e k (-y) * hat f k := by have he (x : T n) : e k x = e k (-y)*e k (x+y) := by simp only [e,c,← AddChar.map_add_eq_mul] congr 1 simp only [dot,Prod.fst_neg,Prod.snd_neg,Prod.fst_add,Prod.snd_add]; ring calc hat (fun x=> f (x+y)) k = ∑ x, e k (-y)*(e k (x+y)*f (x+y)) := by unfold hat; apply sum_congr rfl; intro x _ rw [← mul_assoc,← he] _ = _ := by rw [← mul_sum] congr 1 exact Fintype.sum_equiv (Equiv.addRight y) _ _ fun i=> rfl def shear (b : Bool) (d : ZMod n) : T n → T n := match b with | true => fun x => (x.1+d*x.2, x.2) | false => fun x=> (x.1,x.2+d*x.1) omit [NeZero n] in lemma shear_shear (b) (d : ZMod n) (x : T n) : shear b (-d) (shear b d x)=x := by cases b <;> simp [shear] def shPerm (b : Bool) (d : ZMod n) : Equiv.Perm (T n) := ⟨shear b d,shear b (-d),shear_shear b d, fun x=>by simpa using shear_shear b (-d) x⟩ lemma e_shear (b) (d : ZMod n) (x y : T n) : e (shear (!b) (-d) x) (shear b d y)=e x y := by unfold e; congr 1; cases b <;> simp [dot,shear] <;> ring lemma hat_sh (f : T n → ℂ) (b : Bool) (d : ZMod n) (k) : hat (fun i=> f (shear b d i)) k = hat f (shear (!b) (-d) k) := by exact Fintype.sum_equiv (shPerm b d) _ _ fun x => by simp only [shPerm,Equiv.coe_fn_mk,e_shear] def mass (f : T n → ℝ) (k : T n) := normSq (hat (fun i=> (f i:ℂ)) k) lemma allmass (f : T n→ℝ) : ∑ k, mass f k = (order n:ℝ)^2*av (fun i=> (f i)^2) := by unfold mass rw [parse,pow_two,mul_assoc,av_card] simp [sq] lemma at0 (f : T n→ℝ) : mass f 0 = (order n:ℝ)^2*(av f)^2 := by unfold mass have he : hat (fun i=> (f i:ℂ)) 0 = ↑(∑ i, f i) := by simp [hat,e,c,dot] rw [he, ← av_card] simp [sq] lemma vnonzero (f : T n→ℝ) : ∑ k, (if k=0 then 0 else mass f k) = (order n:ℝ)^2*var2 f := by have he (k) : (if k=0 then 0 else mass f k) = mass f k-(if k=0 then mass f k else 0) := by split <;> simp_all simp only [he,sum_sub_distrib,allmass,var2_sum] simp [at0]; ring /-- Character displacement away from low frequencies. -/ abbrev lift (i : ZMod n) := i.valMinAbs def near (i : ZMod n) : Prop := 16*|lift i|<(n:ℤ) instance (i : ZMod n) : Decidable (near i) := by unfold near; infer_instance def threshold : ℝ := 2*(1-Real.cos (Real.pi/8)) lemma pos_threshold : 0 linarith) (show Real.pi/8∈ Set.Icc 0 Real.pi by constructor <;> linarith) (show 0rw [abs_of_nonneg w]; nlinarith | inr w=>rw [abs_of_nonpos w]; nlinarith have hl : Real.pi/8≤|t| := by rw [hh,le_div_iff₀ hn]; nlinarith have hz := Real.cos_le_cos_of_nonneg_of_le_pi (show 0≤Real.pi/8 by linarith) hu hl have hnz : Real.cos |t| = Real.cos t := by rcases le_total 0 t with h|h · rw [abs_of_nonneg h] · rw [abs_of_nonpos h, Real.cos_neg] rw [hnz] at hz rw [he,hr] unfold threshold; linarith end Square end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section open Finset variable {α β γ : Type} def energy [Fintype α] (k : ℕ) (f : α → ℝ) (p : α → α) := av fun i=> (f (p i)-f i)^k def mass4 [Fintype α] (f : α → ℝ) := av fun i=> f i^4 abbrev Family (γ α : Type) := γ → Equiv.Perm α def energies [Fintype α] [Fintype γ] (G : Family γ α) (f : α → ℝ) := ∑ j : γ, energy 2 f (G j) def expands [Fintype α] [Fintype γ] (G : Family γ α) (C : ℝ) := ∀ f : α → ℝ, var2 f ≤ C * energies G f lemma samesq (a b : ℝ) (h : 0≤a*b) : (a-b)^4 ≤ 4*(a^2-b^2)^2 ∧ (a^2-b^2)^2 ≤ 2*(a-b)^2*(a^2+b^2) := by have : 0 ≤ (a-b)^2*(a*b) := by positivity constructor <;> nlinarith [(show 0≤ (a-b)^4 by positivity)] lemma oppsq (a b : ℝ) (h : a*b≤0) : (a-b)^4 ≤ 4*(a^2+b^2)^2 ∧ (a^2+b^2)^2 ≤ 2*(a-b)^2*(a^2+b^2) := by have : (a-b)^2 ≤ 2*(a^2+b^2) := by nlinarith [sq_nonneg (a+b)] have hc : a*b*(a^2+b^2)≤0 := mul_nonpos_of_nonpos_of_nonneg h (by positivity) constructor <;> nlinarith [sq_nonneg (a^2+b^2),sq_nonneg (a-b)] lemma signedsq (a b : ℝ) : (a-b)^4 ≤ 4*(a*|a|-b*|b|)^2 ∧ (a*|a|-b*|b|)^2 ≤ 2*(a-b)^2*(a^2+b^2) := by rcases le_total 0 a with ha|ha <;> rcases le_total 0 b with hb|hb · rw [abs_of_nonneg ha,abs_of_nonneg hb] simpa only [sq] using samesq a b (mul_nonneg ha hb) · rw [abs_of_nonneg ha,abs_of_nonpos hb] simpa [sq] using oppsq a b (mul_nonpos_of_nonneg_of_nonpos ha hb) · rw [abs_of_nonpos ha,abs_of_nonneg hb] have e := oppsq a b (mul_nonpos_of_nonpos_of_nonneg ha hb) constructor <;> linarith [e.1,e.2] · rw [abs_of_nonpos ha,abs_of_nonpos hb] have e := samesq a b (mul_nonneg_of_nonpos_of_nonpos ha hb) constructor <;> linarith [e.1,e.2] lemma signedsq_eps (A a b : ℝ) (h : 0≤A) : 32*A*(a*|a|-b*|b|)^2 ≤ a^4+b^4+2048*A^2*(a-b)^4 := by have he := mul_le_mul_of_nonneg_left (signedsq a b).2 (show 0≤32*A by positivity) nlinarith [sq_nonneg (a^2-32*A*(a-b)^2),sq_nonneg (b^2-32*A*(a-b)^2)] lemma even4 (a b : ℝ) : ((a+b)/2)^4 + (a-b)^4/16 ≤ (a^4+b^4)/2 := by nlinarith [sq_nonneg (a^2-b^2)] variable [Fintype α] [Nonempty α] [Fintype γ] [Nonempty γ] /-- L4 Poincare via L2 on signed-squares. -/ lemma e4 {G : Family γ α} {C : ℝ} (hC : 1≤C) (h : expands G C) (f : α → ℝ) (ef : av f=0) : let A := C*Fintype.card γ mass4 f ≤ 1024*A^2 * av (fun j : γ=>energy 4 f (G j)) := by let A := C*(Fintype.card γ) have hA : 0 ≤ A := mul_nonneg (by linarith) (Nat.cast_nonneg _) let g i := f i*|f i| have h1 : mass4 f ≤ 8*var2 g := by have he (i j : α) : (f i-f j)^4 ≤ 4*(g i-g j)^2 := (signedsq (f i) (f j)).1 have hu : av (fun i=> av (fun j=> (f i-f j)^4)) ≤ av (fun i=> av (fun j=>4*(g i-g j)^2)) := av_mono (fun i=> av_mono (he i)) simp only [av_cmul,var2_pair] at hu have hh := pair_four f ef unfold mass4; linarith have h2 : mass4 f ≤ 8*A*av (fun j=>energy 2 g (G j)) := by have H := h g unfold energies at H rw [← av_card] at H dsimp only [A]; linarith have h3 (j : γ) : 32*A* energy 2 g (G j) ≤ mass4 f+mass4 f+2048*A^2*energy 4 f (G j) := by have he : av (fun i=>32*A*(g (G j i)-g i)^2) ≤ av (fun i=> f (G j i)^4 + f i^4 +2048*A^2*(f (G j i)-f i)^4) := av_mono fun i=> signedsq_eps A _ _ hA rw [av_cmul,av_add,av_add,av_cmul, show av (fun i=>f (G j i)^4) = _ from av_perm (G j) (fun i=>f i^4)] at he exact he have hu := av_mono (f:=fun j=>32*A* energy 2 g (G j)) (g:=fun j => mass4 f+mass4 f+2048*A^2*energy 4 f (G j)) h3 simp only [av_add, av_cmul, av_const] at hu dsimp; dsimp only [A] at h2 hu linarith def lazyK (G : Family γ α) (f : α → ℝ) : α → ℝ := fun i => av fun j=> (f (G j i)+f i)/2 omit [Nonempty α] in lemma K_av (G : Family γ α) (f : α → ℝ) : av (lazyK G f)=av f := by unfold lazyK rw [av_swap] simp only [av_div,av_add] have e (j : γ) := av_perm (G j) f simp only [e,av_const] ring omit [Nonempty α] in lemma K_dec (G : Family γ α) (f : α → ℝ) : mass4 (lazyK G f) + (av fun j=>energy 4 f (G j))/16 ≤ mass4 f := by have H : av (fun i=> (lazyK G f i)^4) ≤ av (fun i=> av (fun j=> ((f (G j i)+f i)/2)^4)) := av_mono fun i=> av_four_le (fun j=> (f (G j i)+f i)/2) have e (j : γ) : av (fun i=>((f (G j i)+f i)/2)^4) + energy 4 f (G j)/16 ≤ mass4 f := by have hi := av_mono (f:=fun i=> ((f (G j i)+f i)/2)^4 + (f (G j i)-f i)^4 /16) (g:=fun i=> (f (G j i)^4+f i^4)/2) (fun i=> even4 _ _) rw [av_add,av_div,av_div,av_add,show av (fun i=>f (G j i)^4) = _ from av_perm (G j) (fun i=>f i^4)] at hi unfold energy mass4 linarith unfold mass4 rw [av_swap (fun i j=> ((f (G j i)+f i)/2)^4)] at H have he := av_mono (f:=fun j : γ=> av (fun i=>((f (G j i)+f i)/2)^4) + energy 4 f (G j)/16) (g:=fun _=> mass4 f) e rw [av_add,av_div,av_const] at he dsimp only [mass4] at * linarith def loss (γ : Type) [Fintype γ] (C : ℝ) := (16384*(C*Fintype.card γ)^2)⁻¹ lemma loss_bounds (hC : 1≤ C) : 0 < loss γ C ∧ loss γ C < 1 := by have h : (1:ℝ) ≤ Fintype.card γ := by exact_mod_cast Fintype.card_pos have h' : 1 ≤ C * Fintype.card γ := by nlinarith unfold loss have h0 : 1 < 16384 * (C * ↑(Fintype.card γ)) ^ 2 := by nlinarith constructor · exact inv_pos.mpr (by linarith) · exact inv_lt_one_of_one_lt₀ h0 lemma K_shrink {G : Family γ α} (hC : 1≤ C) (h : expands G C) (f : α → ℝ) (ef : av f=0) : mass4 (lazyK G f) ≤ (1-loss γ C)*mass4 f := by have h1 := K_dec G f have h2 := e4 hC h f ef set V := av (fun j : γ=>energy 4 f (G j)) set A := C*↑(Fintype.card γ) change mass4 f ≤ 1024*A^2*V at h2 change _ ≤ (1-(16384*A^2)⁻¹) * mass4 f have hA : 0 < A := mul_pos (by linarith) (Nat.cast_pos.mpr Fintype.card_pos) have he : (16384*A^2)⁻¹ * mass4 f ≤ V/16 := by field_simp linarith linarith def walk (G : Family γ α) (f : α → ℝ) : ℕ → α → ℝ | 0 => f | d+1 => lazyK G (walk G f d) lemma walk_mix {G : Family γ α} (hC : 1 ≤ C) (h : expands G C) (f : α → ℝ) (d : ℕ) : mass4 (fun i=> walk G f d i-av f) ≤ (1-loss γ C)^d * (16*mass4 f) := by let g := fun i=> f i-av f have eg : av g=0 := by simp [g,av_sub,av_const] have eg1 : mass4 g ≤16*mass4 f := by have hz (i : α) : (f i-av f)^4 ≤ 8*(f i^4 + av f^4) := by have hs := even4 (f i) (av f) linarith [(show 0≤ ((f i+av f)/2)^4 by positivity)] have H := @av_mono α _ _ _ (show (fun i=>(f i-av f)^4) ≤ (fun i=>8*(f i^4+av f^4)) from hz) simp only [av_cmul,av_add,av_const] at H dsimp only [g,mass4] linarith [av_four_le f] have he (d : ℕ) : mass4 (walk G g d) ≤ (1-loss γ C)^d * (16*mass4 f) ∧ av (walk G g d)=0 ∧ walk G g d = fun i=>walk G f d i-av f := by induction d with | zero => simpa only [pow_zero,one_mul,walk] using And.intro eg1 ⟨eg,rfl⟩ | succ d ih => obtain ⟨e1,e2,e3⟩ := ih refine ⟨?_,?_,?_⟩ · rw [walk,pow_succ'] exact le_trans (K_shrink hC h _ e2) (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_left e1 (show 0 ≤ 1-loss γ C from sub_nonneg.2 (le_of_lt (loss_bounds hC).2))) · rw [walk,K_av,e2] · funext i simp only [walk,lazyK,e3,av_div,av_add,av_sub,av_const] ring obtain ⟨h1,h2,h3⟩ := he d rwa [← h3] end end ExactDerandomization.Analysis end section /-! Uniform affine mixing input for the paper, part 1: an elementary Fourier proof of a square torus gap. Additional permutations of an external coordinate are permitted during shear moves. This provides the needed finite statement without assuming a property-(T) result. -/ namespace ExactDerandomization.Analysis.Square noncomputable section open Finset Complex variable {n : ℕ} [NeZero n] def core (k : T n) := k≠0 ∧ near k.1 ∧ near k.2 instance (k : T n) : Decidable (core k) := by unfold core; infer_instance def sector (k : T n) : Bool := decide (|lift k.2| ≤ |lift k.1|) def signcode (k : T n) : Bool := decide ((lift k.2 > 0) = (lift k.1 > 0)) omit [NeZero n] in lemma lift_zero (a : ZMod n) : lift a=0 ↔ a=0 := ZMod.valMinAbs_eq_zero _ abbrev Shears := Bool × Bool def amount (b : Bool) : ℤ := if b then 3 else -3 /-- Frequency moves -/ def move (b : Shears) : Equiv.Perm (T n) := shPerm (!b.1) (amount b.2 : ZMod n) lemma swing_near (x y : ZMod n) (a : Bool) (h : near x) (e : near y) : lift (x + (amount a:ZMod n) * y) = lift x + amount a * lift y := by rw [lift, ZMod.valMinAbs_spec] constructor · simp [lift] · simp only [Set.mem_Ioc] unfold near at h e have h1:= le_abs_self (lift x); have h2:= neg_le_abs (lift x) have h3:= le_abs_self (lift y); have h4:= neg_le_abs (lift y) cases a <;> dsimp [amount] <;> omega lemma squash (x y : ℤ) (a : Bool) (h : |y| ≤ |x|) (e : x ≠ 0) : |x| < |y+amount a*x| ∧ decide ((y+amount a*x > 0)=(x>0))=a := by obtain ⟨h0,h1⟩ := abs_le.1 h rcases e.lt_or_gt with w|w · rw [abs_of_neg w] at * cases a <;> simp [amount,lt_abs] <;> omega · rw [abs_of_pos w] at * cases a <;> simp [amount,lt_abs] <;> omega lemma ping {k : T n} {b : Shears} (h : core k) (hb : sector k=b.1) : let v := move b k v≠0 ∧ (!sector v)=b.1 ∧ signcode v=b.2 := by rcases k with ⟨x,y⟩; obtain ⟨hk,hx,hy⟩ := h have he : ¬(lift x=0 ∧ lift y=0) := by intro h; apply hk; simp [lift_zero x |>.1 h.1,lift_zero y |>.1 h.2] rcases b with ⟨b,s⟩ cases b · simp only [sector, decide_eq_false_iff_not] at hb have hv : lift y ≠ 0 := by intro hy; simp [hy] at hb have hg := squash (lift y) (lift x) s (by omega) hv change (x+_,y)≠0 ∧ _ refine ⟨fun h=>hv ((lift_zero y).2 (congrArg Prod.snd h)),?_⟩ simp only [move,shPerm,shear,sector,Equiv.coe_fn_mk,signcode,Bool.not_false, swing_near x y s hx hy] constructor · simp [le_of_lt hg.1] · simpa only [eq_comm (a:=(lift y > 0))] using hg.2 · simp only [sector, decide_eq_true_eq] at hb have hv : lift x ≠ 0 := by intro h simp [h] at hb apply he ⟨h,(lift_zero y).mpr ?_⟩ simpa only [lift_zero] using hb have hg := squash (lift x) (lift y) s hb hv change (x,y+_)≠0 ∧ _ refine ⟨fun h=>hv ((lift_zero x).2 (congrArg Prod.fst h)),?_⟩ simp only [move,shPerm,shear,sector,Equiv.coe_fn_mk,signcode,Bool.not_true, swing_near y x s hy hx] exact ⟨by simp [not_le.2 hg.1],hg.2⟩ lemma sqcompare (x y : ℂ) : 2*normSq x ≤ 3*normSq y +6*normSq (y-x) := by simp only [normSq_apply, sub_re, sub_im] nlinarith [sq_nonneg (2*x.re-3*y.re), sq_nonneg (2*x.im-3*y.im)] variable {α : Type} [Fintype α] [Nonempty α] variable (F : α → T n → ℝ) def atoms (k : T n) := av (fun i => mass (F i) k) omit [Nonempty α] in lemma ann (k) : 0 ≤ atoms F k := av_nonneg _ (fun _=> normSq_nonneg _) def changeF (b : Shears) (u : Equiv.Perm α) (i : α) (x : T n) : ℝ := F (u i) (shear b.1 (-(amount b.2 : ZMod n)) x) - F i x def changed (b : Shears) (u : Equiv.Perm α) := atoms (changeF F b u) omit [Nonempty α] in lemma trial (k : T n) (b : Shears) (u : Equiv.Perm α) : 2 * atoms F k ≤ 3 * atoms F (move b k) + 6*changed F b u k := by have he (i) : 2 * mass (F i) k ≤ 3 * mass (F (u i)) (move b k) +6*mass (changeF F b u i) k := by unfold changeF mass simp_rw [ofReal_sub] rw [hat_sub,hat_sh (fun j=>(F (u i) j:ℂ)) b.1 (-(amount b.2:ZMod n)) k,neg_neg] exact sqcompare _ _ unfold changed atoms rw [← av_perm u (fun i=> mass (F i) (move b k))] rw [← av_cmul,← av_cmul,← av_cmul,← av_add] exact av_mono he omit [Nonempty α] in lemma deflect (u : Shears → Equiv.Perm α) : 4 * ∑ k, (if core k then atoms F k else 0) ≤ 3 * ∑ k, (if k=0 then 0 else atoms F k) + 6 * ∑ b, ∑ k, changed F b (u b) k := by let ok (k : T n) b := core k ∧ sector k=b classical let dirsum k b := if ok k b then atoms F k else 0 let back k b s := if (!sector k)=b ∧ signcode k=s ∧ k≠0 then atoms F k else 0 have ev (b s : Bool) : 2 * ∑ k, dirsum k b ≤ 3 * ∑ k, back k b s + 6*∑ k, changed F (b,s) (u (b,s)) k := by let m : Equiv.Perm (T n) := move (b,s) rw [← Fintype.sum_equiv m (fun k=>back (m k) b s) (fun k=>back k b s) (fun _=>rfl), mul_sum,mul_sum,mul_sum,← sum_add_distrib] apply sum_le_sum intro k hk by_cases h : ok k b · have hg := ping (b:=(b,s)) h.1 h.2 have hp : (!sector (m k))=b ∧ signcode (m k)=s ∧ m k≠0 := ⟨hg.2.1,hg.2.2,hg.1⟩ unfold dirsum back; rw [ite_eq_left h,ite_eq_left hp]; exact trial F k _ _ · simp only [dirsum,h,ite_false,mul_zero] have ht : 0≤back (m k) b s := by unfold back; split; apply ann; rfl have hx : 0≤changed F (b,s) (u (b,s)) k := ann _ _ linarith have ea : (∑ b : Shears, 2 * ∑ k, dirsum k b.1) ≤ ∑ b : Shears, (3 * ∑ k, back k b.1 b.2 + 6*∑ k, changed F b (u b) k) := sum_le_sum fun b _ => ev b.1 b.2 rw [sum_add_distrib,← mul_sum,← mul_sum,← mul_sum,sum_comm, sum_comm (f:=fun (b : Shears) k=>back k b.1 b.2)] at ea have hd (k : T n) : ∑ b : Shears, dirsum k b.1 = 2*(if core k then atoms F k else 0) := by rw [Fintype.sum_prod_type] cases hb : sector k <;> by_cases e : core k <;> simp [dirsum, ok, hb,e] have he (k : T n) : ∑ b : Shears, back k b.1 b.2 = if k=0 then 0 else atoms F k := by rw [Fintype.sum_prod_type] cases hb : sector k <;> cases hs : signcode k <;> by_cases h : k=0 <;> simp [back,hb,hs,h] simp only [hd, he,← mul_sum] at ea linarith def axial (b : Bool) : T n := if b then (1,0) else (0,1) def shifted (b : Bool) (i : α) (x : T n) := F i (x+axial b)-F i x private def evalC (b : Bool) (k : T n) := c (-(if b then k.1 else k.2)) omit [Nonempty α] in lemma disp_shift (b : Bool) (k : T n) : atoms (shifted F b) k = normSq (evalC b k-1)*atoms F k := by have he (i : α) : mass (shifted F b i) k = normSq (evalC b k-1)*mass (F i) k := by unfold shifted mass simp_rw [ofReal_sub] rw [hat_sub,hat_shift (fun j=>(F i j:ℂ)) (axial b) k] have ht : e k (-axial b)=evalC b k := by cases b <;> simp [evalC,e,dot,axial] simp only [ht] rw [← sub_one_mul]; exact map_mul _ _ _ simp only [atoms, he,av_cmul] omit [Nonempty α] in lemma wings (k : T n) : threshold*((if k=0 then 0 else atoms F k)-(if core k then atoms F k else 0)) ≤ ∑ b : Bool, atoms (shifted F b) k := by rw [Fintype.sum_bool] have h0 (b) := ann (shifted F b) k by_cases he : k=0 · rw [ite_eq_left he] rw [ite_eq_right (show ¬core k from fun h=> h.1 he)] linarith [h0 true,h0 false] rw [ite_eq_right he]; split · linarith [h0 true,h0 false] · rename_i hv have hh : ¬ near k.1 ∨ ¬ near k.2 := by unfold core at hv; tauto have hz := ann F k simp only [sub_zero] rcases hh with hl|hr · have hw : threshold ≤ normSq (evalC true k - 1) := far_threshold _ hl linarith [mul_le_mul_of_nonneg_right hw hz, disp_shift F true k, h0 false] · have hw : threshold ≤ normSq (evalC false k - 1) := far_threshold _ hr linarith [mul_le_mul_of_nonneg_right hw hz, disp_shift F false k,h0 true] lemma gapFuel_pos : 1< 6+4/threshold := by linarith [div_pos (show 0<(4:ℝ) by norm_num) pos_threshold] def meanSq := av fun i=> av (fun x=> F i x ^2) omit [Nonempty α] in lemma meanSqNN : 0 ≤ meanSq F := av_nonneg _ (fun _=> av_nonneg _ (fun _=>sq_nonneg _)) omit [Nonempty α] in lemma packA : ∑ k, atoms F k = (order n:ℝ)^2 * meanSq F := by unfold atoms meanSq rw [← av_sum Finset.univ (fun k i=>mass (F i) k)] simp only [allmass,av_cmul] omit [Nonempty α] in /-- shear on chart large-first operates on first physical coordinate; left action is simultaneous on any allowed external index. -/ lemma square_gap (u : Shears → Equiv.Perm α) : av (fun i=>var2 (F i)) ≤ (6+4/threshold) * ((∑ b : Shears, meanSq (changeF F b (u b))) + ∑ b : Bool, meanSq (shifted F b)) := by have he : ∀ k:T n, (if k=0 then 0 else atoms F k) = av fun i=>if k=0 then 0 else mass (F i) k := by intro k; split · next h=> simp only [av_zero] · rfl have hmain : ∑ k:T n, (if k=0 then 0 else atoms F k) = (order n:ℝ)^2*av (fun i=>var2 (F i)) := by simp only [he] rw [← av_sum Finset.univ (fun k i=>if k=0 then 0 else mass (F i) k)] simp only [vnonzero,av_cmul] have H:=deflect F u simp only [changed,hmain,packA,← mul_sum] at H have J := Finset.sum_le_sum (s:=(Finset.univ : Finset (T n))) fun k _ => wings F k rw [sum_comm (f:=fun (k:T n) b=> atoms (shifted F b) k),← mul_sum,sum_sub_distrib,hmain] at J simp only [packA,← mul_sum] at J set Tt := ∑ b:Bool, meanSq (shifted F b) set Ts := ∑ b:Shears, meanSq (changeF F b (u b)) set Tl := ∑ k:T n, if core k then atoms F k else 0 set L := av (fun i=>var2 (F i)) let A := (order n:ℝ)^2 have hA : 0 < A := pow_pos (Nat.cast_pos.mpr Fintype.card_pos) _ have hp := pos_threshold have e1 : 4*Tl≤3*(A*L)+6*(A*Ts) := H have e2 : A*L - Tl ≤ A*Tt /threshold := (le_div_iff₀ hp).2 (by rw [mul_comm]; exact J) have e3 : L ≤6*Ts+4/threshold*Tt := by apply le_of_mul_le_mul_left _ hA simp only [div_eq_mul_inv] at e2 ⊢; linarith have et : 0 ≤ Tt := Finset.sum_nonneg fun b _=> meanSqNN _ have es : 0 ≤ Ts := Finset.sum_nonneg fun b _=> meanSqNN _ have er : 0 ≤4/threshold := by positivity nlinarith end end ExactDerandomization.Analysis.Square end section namespace ExactDerandomization.Analysis noncomputable section open Finset variable {α β γ : Type} variable [Fintype α] [Nonempty α] [Fintype β] [Nonempty β] lemma var2_decomp (f : α → ℝ) (z : ℝ) : av (fun i=> (f i-z)^2) = var2 f+(av f-z)^2 := by rw [var2_sum] simp only [sub_sq,av_add,av_sub,av_mulc,av_const,av_cmul] ring lemma var2_prod (f : α × β → ℝ) : var2 f= av (fun i=>var2 (fun j=> f (i,j))) + var2 (fun i=> av (fun j=>f (i,j))) := by simp only [var2_sum,av_prod,av_sub] ring omit [Nonempty α] in lemma var2_project (f : α → β → ℝ) : var2 (fun i=> av (f i)) ≤ av (fun j=>var2 (fun i=>f i j)) := by let z j:= av (fun i=>f i j) have h (i : α) : (av (f i)-av z)^2≤ av (fun j=> (f i j-z j)^2) := by rw [← av_sub]; exact av_sq_le _ have hz : av z = av (fun i=> av (f i)) := by dsimp only [z]; rw [← av_swap f] have he := av_mono (f:=fun i=> (av (f i)-av z)^2) (g:=fun i=> av (fun j=> (f i j-z j)^2)) h rw [hz,av_swap (fun i j=>(f i j-z j)^2)] at he exact he omit [Nonempty α] in /-- Product permutations and projection onto first factor. -/ lemma energy_project (f : α × β → ℝ) (p : Equiv.Perm α) (q : Equiv.Perm β) : energy 2 (fun i=> av (fun j=> f (i,j))) p ≤ energy 2 f (p.prodCongr q) := by unfold energy rw [av_prod] apply av_mono intro i change (av _-av _)^2 ≤ av (fun j : β=> (f (p i,q j)-f (i,j))^2) rw [← av_perm q (fun j=> f (p i,j)),← av_sub] exact av_sq_le _ abbrev Punc (α : Type) [Zero α] := {a : α // a≠0} variable [Zero α] [DecidableEq α] variable [hp : Nonempty (Punc α)] omit [Nonempty α] hp in lemma punc_sum (f : α → ℝ) : ∑ i:Punc α, f i.val = ∑ a:α, if a=0 then 0 else f a := by simp_rw [show ∀ a, (if a=0 then 0 else f a) = if a≠0 then f a else 0 by intro a; grind] rw [← Finset.sum_filter, Finset.sum_subtype _ (p:=fun a : α=>a≠0) (by simp) f] omit hp in lemma card_punc : Fintype.card (Punc α)+1 = Fintype.card α := by have ht := Fintype.card_pos (α:=α) simp [Punc]; omega lemma av_insert (f : α → ℝ) (h : ∀ i, 0≤f i) : av (fun i:Punc α=> f i.val) ≤ 2*av f := by set N := (Fintype.card α:ℝ) set M := (Fintype.card (Punc α):ℝ) have hM : 1≤ M := by dsimp only [M]; exact_mod_cast (show 1 ≤ Fintype.card (Punc α) from Fintype.card_pos) have h1 : N=M+1 := by dsimp only [N,M]; exact_mod_cast (card_punc (α:=α)).symm have e : M*av (fun i:Punc α=> f i.val) ≤ N*av f := by dsimp only [N,M]; rw [av_card,av_card,punc_sum] apply sum_le_sum; intro i _ split; apply h; exact le_rfl have he := av_nonneg f h nlinarith lemma var_insert (f : α → ℝ) : var2 (fun i:Punc α=> f i.val) ≤2*var2 f := le_trans (var2_best _ (av f)) (av_insert (fun i=>(f i-av f)^2) (fun _=>sq_nonneg _)) def rows (f : α → α → ℝ) : ℝ := av (fun i:Punc α=>var2 (f i.val)) def ctr (f : α → α → ℝ) : ℝ := av fun i:Punc α=>av fun j:Punc α=> f i.val j.val abbrev switch (f : α → α → ℝ) : α → α → ℝ := fun i j=>f j i lemma rows_ctrl (f : α → α → ℝ) : av (fun i:Punc α=>av fun j=> (f i j-ctr f)^2) ≤ 5*rows f+4*rows (switch f) := by let g (i:Punc α) := av fun j:Punc α=> f i j have hv : ctr f=av g := rfl have hi (i:Punc α) : av (fun j=> (f i j-ctr f)^2) ≤ 5*var2 (f i) + 2*(g i-ctr f)^2 := by rw [var2_decomp] let u : Punc α → ℝ := fun j=> av (f i)-f i j have hs := av_sq_le u have he : av (fun j:Punc α => u j^2) ≤ 2*var2 (f i) := by convert av_insert (fun j=> (f i j-av (f i))^2) (fun _=>sq_nonneg _) using 1 congr 1 ext j; dsimp [u]; ring rfl have hu : av u=av (f i)-g i := by simp [u,g,av_sub,av_const] rw [hu] at hs nlinarith [sq_nonneg (av (f i)+ctr f-2*g i)] have he := av_mono (f:=fun i:Punc α=>av fun j=> (f i j-ctr f)^2) (g:=fun i:Punc α=> 5*var2 (f i) + 2*(g i-ctr f)^2) hi rw [av_add,av_cmul,av_cmul,hv] at he have hs : var2 g ≤ 2*rows (switch f) := by refine le_trans (var2_project (fun (i : Punc α) (j:Punc α)=> f i j)) ?_ unfold rows; rw [← av_cmul] exact av_mono fun j=>var_insert (switch f j.val) rw [hv] change _ ≤ 5 * rows f + 2 * var2 g at he linarith omit [Fintype α] [Nonempty α] [DecidableEq α] in lemma nonempty_punc : Nonempty (Punc (α×α)) := by obtain ⟨i,hi⟩ := hp exact ⟨⟨(i,i),by intro h; exact hi (congrArg Prod.fst h)⟩⟩ /-- Return normalization factors explicitly. -/ lemma punctured [Nonempty (Punc (α×α))] (f : α → α → ℝ) : (Fintype.card (Punc (α×α)):ℝ)*var2 (fun i : Punc (α×α)=> f i.val.1 i.val.2) ≤ (Fintype.card (Punc α):ℝ)*Fintype.card α*(9 * (rows f + rows (switch f))) := by set M := (Fintype.card (Punc α):ℝ) set N := (Fintype.card α:ℝ) let z := ctr f have hz : ctr (switch f) = z := av_swap _ let u x y := (f x y-z)^2 let L := ∑ i : Punc α, ∑ j:α, u i.val j let R := ∑ j : Punc α, ∑ i:α, u i j.val have he : (Fintype.card (Punc (α×α)):ℝ)*var2 (fun i : Punc (α×α)=> f i.val.1 i.val.2) ≤ L+R := by refine le_trans (mul_le_mul_of_nonneg_left (var2_best _ z) (Nat.cast_nonneg _)) ?_ rw [av_card]; dsimp only [L,R] change ∑ i : Punc (α × α), (fun j:α × α=>u j.1 j.2) i.val ≤ _ rw [punc_sum (fun j : α×α=>u j.1 j.2),Fintype.sum_prod_type, punc_sum (fun i : α=>∑ j:α,u i j), punc_sum (fun j:α=>∑ i:α,u i j)] have eu (v:α → ℝ) (i : α) : (if i=0 then 0 else ∑ j,v j) = ∑ j, if i=0 then 0 else v j := by split <;> simp_all simp_rw [eu] nth_rw 3 [sum_comm] rw [←sum_add_distrib] apply sum_le_sum; intro i _ rw [← sum_add_distrib] apply sum_le_sum; intro j _ by_cases a:i=0 <;> by_cases b:j=0 <;> simp [a,b,u] positivity have et (p : α→α→ℝ) : ∑ i:Punc α,∑ j:α,(p i.val j-ctr p)^2 = M*N*av (fun i:Punc α=>av fun j:α=> (p i.val j-ctr p)^2) := by have hv (q : Punc α → α → ℝ) : ∑ i,∑ j,q i j=M*N*av (fun i=>av (q i)) := by simp_rw [← av_card, av_cmul] dsimp only [M,N]; ring exact hv _ have hu : L ≤ M*N*(5*rows f+4*rows (switch f)) := by dsimp only [L,u,z] rw [et]; exact mul_le_mul_of_nonneg_left (rows_ctrl f) (by dsimp only [M,N]; positivity) have hv : R ≤ M*N*(5*rows (switch f)+4*rows f) := by dsimp only [R,u]; rw [← hz] change ∑ i:Punc α,∑ j:α, (switch f i.val j-ctr (switch f))^2 ≤ _ rw [et] exact mul_le_mul_of_nonneg_left (rows_ctrl (switch f)) (by dsimp only [M,N]; positivity) linarith end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section open Finset open Square namespace Affine abbrev V (n : ℕ) := T n × T n abbrev Cmd := (Shears ⊕ Bool) ⊕ (Bool × Bool) abbrev Gen := Bool × Cmd abbrev sh (b : Shears) : Cmd := Sum.inl (Sum.inl b) abbrev tran (b : Bool) : Cmd := Sum.inl (Sum.inr b) abbrev ov (i j : Bool) : Cmd := Sum.inr (i,j) variable {n : ℕ} [NeZero n] def crossTerm (y : T n) (i j : Bool) : T n := let t := if j then y.1 else y.2 if i then (t,0) else (0,t) /-- act on lead coordinates with parameter other pair fixed. aff=true includes translations -/ def lead (k : Cmd) (aff : Bool) (d : T n) : Equiv.Perm (T n) := match k with | Sum.inl (Sum.inl b) => shPerm b.1 (-(amount b.2 : ZMod n)) | Sum.inl (Sum.inr b) => if aff then Equiv.addRight (axial b) else Equiv.refl _ | Sum.inr (i,j) => Equiv.addRight (crossTerm d i j) def face (b : Bool) : Equiv.Perm (V n) := if b then Equiv.prodComm _ _ else Equiv.refl _ omit [NeZero n] in lemma face_face (b) (x : V n) : face b (face b x)=x := by cases b <;> simp [face] def leadPerm (aff : Bool) (k : Cmd) : Equiv.Perm (V n) := ⟨fun x=> (lead k aff x.2 x.1,x.2), fun y=> ((lead k aff y.2).symm y.1,y.2), fun i=>by simp,fun i=>by simp⟩ def act (aff : Bool) (g : Gen) : Equiv.Perm (V n) := ((face g.1).trans (leadPerm aff g.2)).trans (face g.1) omit [NeZero n] in lemma orient (aff b c) (x : T n) (y) : act aff (b,c) (face b (x,y))=face b (lead c aff y x,y) := by simp only [act,Equiv.trans_apply,face_face]; rfl omit [NeZero n] in lemma nodrift (g : Gen) : act false g (0:V n)=0 := by have he (b) : face b (0:V n)=0 := by cases b <;> rfl simp only [act,Equiv.trans_apply,he]; rw [show leadPerm false g.2 (0:V n)=0 from ?_,he] cases g.2 with | inl a => cases a with | inl b => rcases b with ⟨a,b⟩; cases a <;> simp [leadPerm,lead,shPerm,shear,Prod.ext_iff] | inr b => simp [leadPerm,lead] | inr a => rcases a with ⟨i,j⟩; cases i <;> cases j <;> simp [leadPerm,lead,crossTerm,Prod.ext_iff] def Fperm (g : Gen) : Equiv.Perm (Punc (V n)) := Equiv.subtypeEquiv (act false g) (by intro x; constructor · exact fun h he=>h ((act false g).injective (he.trans (nodrift _).symm)) · intro h e; subst x; exact h (nodrift g)) omit [NeZero n] in lemma locked (b i) : Fperm (n:=n) (b,tran i) = Equiv.refl _ := by apply Equiv.ext; intro ⟨⟨j,k⟩,hx⟩; apply Subtype.ext cases b <;> simp [Fperm,act,face,leadPerm,lead] abbrev gap0 := 6+4/threshold section Torus variable {α : Type} [Fintype α] [Nonempty α] (f : α × V n → ℝ) (p : Family Gen α) def stepE (j : Gen) := energy 2 f ((p j).prodCongr (act true j)) def chart (b : Bool) := av (fun i:α=> av fun y:T n=>var2 (fun x=> f (i,face b (x,y)))) omit [Nonempty α] in lemma chart_cost (b : Bool) (hn : ∀ i : Bool,p (b,tran i)=Equiv.refl _) : chart f b ≤ gap0 * ∑ c:Cmd, stepE f p (b,c) := by let F y i x := f (i,face b (x,y)) let H (c:Cmd) (y x : T n) (i:α) := (F y (p (b,c) i) (lead c true y x)-F y i x)^2 let Z c (y : T n) := av fun i:α=> av fun x:T n=> H c y x i have he (y : T n) : av (fun i=>var2 (F y i)) ≤ gap0*∑ c:Cmd,Z c y := by rw [Fintype.sum_sum_type,Fintype.sum_sum_type] have ho := square_gap (F y) (fun s=> p (b,sh s)) have hj : (∑ s:Shears, meanSq (changeF (F y) s (p (b, sh s)))) = ∑ s:Shears,Z (sh s) y := rfl have hk : (∑ s:Bool, meanSq (shifted (F y) s))=∑ s:Bool,Z (tran s) y := by apply sum_congr rfl; intro i _ simp only [Z,H,hn,tran,lead,ite_true] rfl rw [hj,hk] at ho refine ho.trans (mul_le_mul_of_nonneg_left ?_ (by linarith [gapFuel_pos])) refine le_add_of_nonneg_right (sum_nonneg ?_) intro i _ exact av_nonneg _ fun i=> av_nonneg _ (fun _=> sq_nonneg _) have ht (c:Cmd) : stepE f p (b,c) = av (Z c) := by unfold stepE energy; rw [av_prod] unfold Z rw [av_swap (f:=fun y i=>av fun x=>H c y x i)] congr 1 funext i let L (r : V n) := (f (((p (b,c)).prodCongr (act true (b,c))) (i,r)) - f (i,r))^2 change av L= _ rw [← av_perm (face b) L,av_prod,av_swap (fun (x y:T n)=>L (face b (x,y)))] congr 1 funext y congr 1 funext x unfold L; simp only [Equiv.prodCongr_apply,Prod.map_apply,orient]; rfl unfold chart rw [av_swap (fun i (y:T n) =>var2 (F y i))] simp_rw [ht,← av_sum] rw [← av_cmul] exact av_mono he omit [Nonempty α] in lemma torus (hp : ∀ b i : Bool,p (b,tran i)=Equiv.refl _) : av (fun i : α=>var2 (fun j:V n=>f (i,j))) ≤ gap0* ∑ j:Gen, stepE f p j := by have hk (i:α) : var2 (fun j:V n=>f (i,j)) ≤ av (fun y:T n=>var2 (fun x=> f (i,face true (x,y)))) + av (fun y:T n=>var2 (fun x=> f (i,face false (x,y)))) := by rw [var2_prod] apply add_le_add · simp only [face,ite_true,Equiv.prodComm_apply]; exact le_rfl · simpa only [face,Bool.false_eq_true,ite_false,Equiv.refl_apply] using var2_project (fun (x y:T n)=>f (i,(x,y))) have he := av_mono (g:=fun i=> av (fun y:T n=>var2 (fun x=> f (i,face true (x,y)))) + av (fun y:T n=>var2 (fun x=> f (i,face false (x,y))))) (f:=fun i:α=>var2 (fun j:V n=>f (i,j))) hk rw [av_add] at he rw [Fintype.sum_prod_type,Fintype.sum_bool,mul_add] refine le_trans he (add_le_add ?_ ?_) · exact chart_cost f p _ (hp true) · exact chart_cost f p _ (hp false) end Torus end Affine end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis.Affine noncomputable section open Square Finset abbrev Frame (n : ℕ) := Punc (V n) variable {n : ℕ} [Fact n.Prime] instance square_punc : Nonempty (Punc (T n)) := ⟨⟨(1,0),by simp [Prod.ext_iff]⟩⟩ instance frame_NE : Nonempty (Frame n) := nonempty_punc def zoom (d : ZMod n) (e : d ≠ 0) : Equiv.Perm (T n) := ⟨fun x=>(d*x.1,d*x.2),fun x=>(d⁻¹*x.1,d⁻¹*x.2),by intro x; simp [e], by intro x; simp [e]⟩ lemma slice_frame {y : T n} (hy : y≠0) (f : T n → ℝ) : var2 f ≤ gap0*∑ c : Cmd, energy 2 f (lead c false y) := by let j : Bool := decide (y.1≠0) let v := if j then y.1 else y.2 have hv : v≠0 := by simp only [v]; split · next h=> simpa only [j,decide_eq_true_eq] using h · next h=> have eh : y.1=0 := by simpa [j] using h exact fun e=>hy (Prod.ext eh e) let p := zoom v hv have he (c:Shears) (x : T n) : p (shear c.1 (-(amount c.2:ZMod n)) x) = lead (sh c) false y (p x) := by rcases c with ⟨a,b⟩; cases a <;> simp [p,zoom,shear,lead,shPerm] <;> ring have ht (i) (x : T n) : p (x+axial i) = lead (ov i j) false y (p x) := by cases i <;> simp [p,zoom,lead,crossTerm,axial,v,mul_add] <;> split <;> simp_all let F := fun (_ : Unit) x=> f (p x) let u := fun (_ : Shears) => Equiv.refl Unit have H := square_gap F u have hz : av (fun i=>var2 (F i))=var2 f := by simp only [F,av_const,var2_sum,av_perm p f, av_perm p (fun i=> f i^2)] have ek (c) : meanSq (changeF F c (u c))=energy 2 f (lead (sh c) false y) := by simp only [meanSq,changeF,F,av_const,he] exact av_perm p (fun x=> (f (lead (sh c) false y x)-f x)^2) have ej (i) : meanSq (shifted F i)=energy 2 f (lead (ov i j) false y) := by simp only [meanSq, shifted,F,av_const,ht] exact av_perm p (fun x=> (f (lead (ov i j) false y x)-f x)^2) rw [Fintype.sum_sum_type,Fintype.sum_sum_type] simp only [hz,ek,ej] at H have hh (c : Cmd) : 0 ≤ energy 2 f (lead c false y) := av_nonneg _ (fun _=>sq_nonneg _) refine H.trans (mul_le_mul_of_nonneg_left ?_ (show 0≤gap0 by linarith [gapFuel_pos])) have hd : ∑ i : Bool, energy 2 f (lead (ov i j) false y) ≤ ∑ i : Bool × Bool, energy 2 f (lead (Sum.inr i) false y) := by rw [Fintype.sum_prod_type] apply sum_le_sum; intro i _ apply single_le_sum (fun j _=>hh (ov i j)) (mem_univ j) exact add_le_add (le_add_of_nonneg_right (sum_nonneg fun i _=> hh (tran i))) hd variable (F : Frame n → ℝ) (f : V n → ℝ) abbrev nf := (Fintype.card (Frame n):ℝ) abbrev nu := (Fintype.card (Punc (T n)):ℝ) def weighingF (n : ℕ) [Fact n.Prime] : ℝ := Fintype.card (Frame n) def weighingU (n : ℕ) [Fact n.Prime] : ℝ := (Fintype.card (Punc (T n)):ℝ)* order n def fSlice (b : Bool) (y x : T n) := f (face b (x,y)) def fSliceE (b : Bool) (c : Cmd) (y : T n) := energy 2 (fSlice f b y) (lead c false y) lemma fE_le (hf : ∀ i : Frame n,f i.val=F i) (b : Bool) (c) : weighingU n * av (fun i : Punc (T n)=> fSliceE f b c i.val) ≤ weighingF n*energy 2 F (Fperm (b,c)) := by let g := fun i:V n => (f (act false (b,c) i)-f i)^2 have he (i : Frame n) : (F (Fperm (b,c) i)-F i)^2 = g i.val := by rw [← hf,← hf]; rfl have hs (x : V n) : (∑ i:Frame n,g i.val)=∑ i:V n,g i := by rw [punc_sum] apply sum_congr rfl; intro i _; split · next h=> subst i; simp [g,nodrift] · rfl unfold energy weighingF rw [av_card] simp only [he] rw [hs 0,← Fintype.sum_equiv (face b) (fun i=>g (face b i)) g (fun _=>rfl), Fintype.sum_prod_type, sum_comm] have hc (y : T n) : (order n:ℝ)* fSliceE f b c y = ∑ x:T n,g (face b (x,y)) := by unfold fSliceE energy fSlice rw [av_card]; simp only [g,orient] unfold weighingU rw [mul_assoc,← av_cmul,av_card] simp only [hc] rw [punc_sum (fun y : T n=> ∑ x:T n,g (face b (x,y)))] exact sum_le_sum fun i _=> by split; apply sum_nonneg fun _ _=>sq_nonneg _; exact le_rfl lemma slice_E (b : Bool) (hf : ∀ i : Frame n,f i.val=F i) : weighingU n * rows (fSlice f b) ≤ gap0 * weighingF n * ∑ c:Cmd, energy 2 F (Fperm (b,c)) := by have he : rows (fSlice f b) ≤ gap0 * ∑ c:Cmd,av (fun i : Punc (T n)=> fSliceE f b c i.val) := by rw [← av_sum,← av_cmul] exact av_mono fun i=> slice_frame i.prop (fSlice f b i.val) have hs := sum_le_sum (s:=(univ : Finset Cmd)) fun c _ => fE_le F f hf b c rw [← mul_sum,← mul_sum] at hs have ht := mul_le_mul_of_nonneg_left he (show 0 ≤ weighingU n by unfold weighingU; positivity) have hu := mul_le_mul_of_nonneg_left hs (show 0≤gap0 by linarith [gapFuel_pos]) linarith lemma frame_gap : var2 F ≤ (9*gap0)*energies Fperm F := by let f (i : V n) := if h : i≠0 then F ⟨i,h⟩ else 0 have hf (i : Frame n) : f i.val=F i := by simp [f,i.prop] have ek := punctured (fun (i j : T n)=>f (i,j)) have he := slice_E F f true hf have hg := slice_E F f false hf change weighingF n * var2 (fun i : Frame n=> f (i.val.1,i.val.2)) ≤ weighingU n * (9*(rows _+rows _)) at ek have h0 : (fun i : Frame n=> f (i.val.1,i.val.2))=F := funext hf have h1 : fSlice f true = fun i j=> f (i,j) := by ext; rfl have h2 : fSlice f false = fun i j=> f (j,i) := by ext; rfl rw [h0] at ek change weighingF n*var2 F≤ weighingU n * (9*(rows (fun i j=>f (i,j)) +rows (fun i j=>f (j,i)))) at ek rw [← h1,← h2] at ek unfold energies rw [Fintype.sum_prod_type,Fintype.sum_bool] apply le_of_mul_le_mul_left (a:=weighingF n) · linarith · exact Nat.cast_pos.mpr Fintype.card_pos lemma expands_frame : expands (α:=Frame n) Fperm (9*gap0) := fun F=>frame_gap F variable (l : ℕ) [NeZero l] def gens (k : Gen) : Equiv.Perm (Frame n × V l) := Equiv.prodCongr (Fperm k) (act true k) /-- Uniform spectral input needed by the conditional averaging. -/ theorem slice_gap : expands (gens (n:=n) l) (10*gap0) := by intro f rw [var2_prod] have h1 := torus f Fperm locked have hx : gap0 * ∑ j:Gen,stepE f Fperm j=gap0*energies (gens l) f := rfl rw [hx] at h1 let g i := av fun j=> f (i,j) have h2:=frame_gap g have hu : energies Fperm g ≤ energies (gens l) f := sum_le_sum fun j _ => energy_project f _ _ have he := mul_le_mul_of_nonneg_left hu (show 0≤9*gap0 by linarith [gapFuel_pos]) change _ + var2 g ≤ _ linarith theorem bits_gap : expands (α:=V l) (act true) gap0 := by intro f have h := torus (fun x : Unit × V l=> f x.2) (fun _=>Equiv.refl Unit) (fun _ _=>rfl) simp only [av_const] at h unfold stepE energy at h unfold energies energy simp only [Equiv.prodCongr_apply,Prod.map_snd,av_prod,av_const] at h ⊢ exact h end end ExactDerandomization.Analysis.Affine end section namespace ExactDerandomization.Analysis noncomputable section open Square _root_.OAI.ExactDerandomization.Analysis.Affine Finset def side (n k : ℕ) := (n-1)/ (2^k)+1 instance (n k : ℕ) : NeZero (side n k) := ⟨Nat.succ_ne_zero _⟩ def rate (k : ℕ) : ℝ := (2^k)⁻¹ ^ (4:ℕ) def pct (n k : ℕ) := ((side n k : ℝ)/n)^ (4:ℕ) lemma rate_pos (k) : 0 i.val < side n k) v def vwide (k) (v : V (side n k)) : V n := vmap (fun i=> (i.val:ZMod n)) v def vshort (k) (v : V n) : V (side n k) := vmap (fun i=> (i.val:ZMod (side n k))) v instance (v : V n) (k) : Decidable (restr k v) := by unfold restr each; infer_instance lemma wrest (k) (v : V (side n k)) : restr k (vwide k v : V n) ∧ vshort k (vwide k v : V n) = v := by have h (i : ZMod (side n k)) : (↑i.val:ZMod n).val=i.val := by rw [ZMod.val_natCast,Nat.mod_eq_of_lt (lt_of_lt_of_le (ZMod.val_lt i) (side_le (NeZero.pos n) k))] simp only [restr, each,vwide,vshort,vmap,h,ZMod.val_lt,ZMod.natCast_zmod_val]; simp lemma restw (k) (v : V n) (h : restr k v) : vwide k (vshort k v)=v := by unfold restr each at h obtain ⟨h1,h2,h3,h4⟩ := h simp only [vwide,vshort,vmap,ZMod.val_natCast,Nat.mod_eq_of_lt,h1,h2,h3,h4,ZMod.natCast_zmod_val] def vEval (s : Channel n) (y : ZMod n) : V n := s.2+y • s.1.val def hit (k) (y : ZMod n) (s : Channel n) := restr k (vEval s y) instance (k) (y : ZMod n) (s) : Decidable (hit k y s) := by unfold hit; infer_instance abbrev pc (n k : ℕ) := Frame n × V (side n k) def openP (k) (y : ZMod n) (s : pc n k) : Channel n := (s.1,vwide k s.2-y • s.1.val) def closeP (k) (y : ZMod n) (s : Channel n) : pc n k := (s.1,vshort k (vEval s y)) lemma hit_open (k) (y : ZMod n) (s : pc n k) : hit k y (openP k y s) := by simp only [openP,hit,vEval,sub_add_cancel] exact (wrest k s.2).1 lemma close_open (k) (y : ZMod n) (s : pc n k) : closeP k y (openP k y s)=s := by simp only [openP,closeP,vEval,sub_add_cancel,(wrest k s.2).2] lemma open_close (k) (y : ZMod n) (s : Channel n) (h : hit k y s) : openP k y (closeP k y s)=s := by simp only [openP,closeP,restw k _ h]; simp only [vEval,add_sub_cancel_right] def atP (k : ℕ) (y : ZMod n) (f : Channel n → ℝ) : ℝ := av (fun s=> f (openP k y s)) lemma cardinalV (n : ℕ) [NeZero n] : Fintype.card (V n)=n^4 := by simp [V,T]; ring lemma ratioP (n : ℕ) [Fact n.Prime] (k) : (Fintype.card (pc n k):ℝ)=(Fintype.card (Channel n):ℝ)*pct n k := by simp only [Channel,pc,pct,Fintype.card_prod,ZMod.card,Nat.cast_mul] field_simp rw [mul_div_cancel_right₀ _ (Nat.cast_ne_zero.mpr (NeZero.ne n))] lemma conditionP (k) (y : ZMod n) (f : Channel n → ℝ) : av (fun s=>if hit k y s then f s else 0) = pct n k * atP k y f := by classical have he : ∑ s : Channel n, (if hit k y s then f s else 0)=∑ s,f (openP k y s) := by rw [← sum_filter] symm let e : pc n k ≃ {s:Channel n//hit k y s} := ⟨fun s=>⟨openP k y s,hit_open k y s⟩,fun s=>closeP k y s, close_open k y,fun s=>Subtype.ext (open_close k y _ s.prop)⟩ rw [sum_subtype _ (p:=hit k y) (by simp) f] exact Fintype.sum_equiv e _ (fun s=> f s.val) (fun _=>rfl) rw [← av_card,← av_card] at he rw [ratioP] at he unfold atP apply mul_left_cancel₀ (show (Fintype.card (Channel n):ℝ)≠0 by positivity) rw [he,mul_assoc] lemma contained (k j : ℕ) (e : j≤k) {y : ZMod n} {s} (h : hit k y s) : hit j y s := by have := side_antitone n e simp only [hit, restr, each] at *; omega lemma allhit (y : ZMod n) (s) : hit 0 y s := by simp only [hit,restr,each,side_zero (NeZero.pos n),ZMod.val_lt]; tauto def ind (k : ℕ) (y : ZMod n) (s : Channel n) : ℝ := if hit k y s then 1 else 0 lemma marginal (k) (y : ZMod n) : av (ind k y)=pct n k := by unfold ind simpa only [ind,atP,av_const,mul_one] using conditionP k y (fun _=>1) lemma pct_le (n : ℕ) [Fact n.Prime] (k) : pct n k ≤ 1 := by rw [← marginal k (0:ZMod n),← av_const (α:=Channel n) 1] apply av_mono; intro i; dsimp [ind]; split <;> norm_num def ri (n : ℕ) [Fact n.Prime] (k : ℕ) (w : V n) : ℝ := if restr k w then 1 else 0 lemma marginal_box (k) : av (ri n k)=pct n k := by have h := marginal k (0:ZMod n) rw [av_prod] at h unfold ri simpa only [ri,ind,hit,vEval,zero_smul, add_zero,av_const] using h def scale (z : ZMod n) (h : z≠0) : Equiv.Perm (Frame n) := let m (z:ZMod n) (e:z≠0) (x : Frame n) : Frame n := ⟨z • x.val,smul_ne_zero e x.prop⟩ ⟨m z h,m z⁻¹ (inv_ne_zero h), fun _=>Subtype.ext (inv_smul_smul₀ h _),fun _=>Subtype.ext (smul_inv_smul₀ h _)⟩ /-- padding by a fixed suffix leaves joint law unchanged -/ def affineChannel (u t : ZMod n) (h : u≠0) : Equiv.Perm (Channel n) := let m := scale u h ⟨fun s=>(m s.1,s.2+t • s.1.val),fun s=>(m.symm s.1,s.2-t • (m.symm s.1).val), fun x=> by simp,fun x=>by simp⟩ lemma affine_eval (u t : ZMod n) (h) (s : Channel n) (y : ZMod n) : vEval (affineChannel u t h s) y=vEval s (t+y*u) := by simp [vEval,affineChannel,scale,add_smul,mul_smul,add_assoc] lemma average_excl (f : V n→ℝ) (w : V n) (z : ZMod n) (e:z≠0) : (Fintype.card (Frame n):ℝ)*av (fun t:Frame n=> f (w+z • t.val)) + f w = (Fintype.card (V n):ℝ)*av f := by have hu := av_perm (scale z e) (fun t=> f (w+t.val)) change av (fun t : Frame n=> f (w+z • t.val))=_ at hu rw [hu,av_card,av_card,punc_sum (fun t:V n=>f (w+t)),← Fintype.sum_equiv (Equiv.addLeft w) _ f (fun i=>rfl)] have he (i:V n) : (if i=0 then 0 else f (w+i))= f (w+i)-(if i=0 then f w else 0) := by split <;> simp_all simp [he,sum_sub_distrib] lemma pairMean {k j} {x y : ZMod n} (he : y≠x) : atP k x (ind j y) ≤ 2*pct n j ∧ (k=j → atP k x (ind j y) ≤ pct n j) := by let f (v : V (side n k)) (s : Frame n) := ind j y (openP k x (s,v)) let value v := av (f v) have hk : atP k x (ind j y)=av value := by rw [atP,av_prod,av_swap] let M : ℝ := Fintype.card (Frame n) let N : ℝ := Fintype.card (V n) have h0 : 1 ≤ M := by dsimp only [M]; exact_mod_cast (show 1≤ Fintype.card (Frame n) from Fintype.card_pos) have hmm : M+1=N := by dsimp only [M,N]; exact_mod_cast card_punc (α:=V n) have hv (v : V (side n k)) : M*value v + ri n j (vwide k v)=N*pct n j := by have e := average_excl (ri n j) (vwide k v) (y-x) (sub_ne_zero.2 he) rw [marginal_box] at e have eq : f v= _ := show f v = fun s:Frame n=>ri n j (vwide k v+(y-x) • s.val) by ext s have hl : vEval (openP k x (s,v)) y=vwide k v+(y-x) • s.val := by simp only [vEval,openP,sub_smul]; abel simp only [f,ind,hit,ri,hl] dsimp only [value]; rw [eq]; exact e constructor · rw [hk] refine le_trans (av_mono (f:=value) (g:=fun _ => 2*pct n j) (fun i=>?_)) (le_of_eq (av_const _)) have e := hv i have hq := pct_pos (NeZero.pos n) j have hr : 0 ≤ ri n j (vwide k i) := by unfold ri; split <;> norm_num nlinarith intro e; subst k rw [hk] refine le_trans (av_mono (f:=value) (g:=fun _ => pct n j) (fun i=>?_)) (le_of_eq (av_const _)) have he := hv i rw [ri,ite_eq_left (wrest j i).1] at he have ht := pct_le n j nlinarith lemma pair_avg (k j) (x y : ZMod n) : av (fun i=> ind k x i * ind j y i) = pct n k * atP k x (ind j y) := by rw [← conditionP] apply congrArg av funext i unfold ind; split <;> simp_all lemma ind_nonneg (k) (x : ZMod n) (i) : 0 ≤ ind k x i := by unfold ind; split <;> norm_num lemma ind_mul (k) (x : ZMod n) (i) : ind k x i*ind k x i=ind k x i := by unfold ind; split <;> norm_num /-- Variance estimate for deterministic test set. -/ lemma count_var {α : Type} (s : Finset α) (g : α → ZMod n) (h : Set.InjOn g s) (k : ℕ) : let f i := ∑ j ∈ s, ind k (g j) i av f = s.card*pct n k ∧ var2 f ≤ s.card*pct n k := by let p:=pct n k let f (i) := ∑ j∈s, ind k (g j) i have he : av f=s.card*p := by simp only [f,av_sum,marginal,sum_const,nsmul_eq_mul,p] refine ⟨he,?_⟩ rw [var2_sum] change av (fun i=> (f i)^2)-_≤_ classical have hi (a) (ha : a∈s) (b) (hb : b∈s) : av (fun i=>ind k (g a) i*ind k (g b) i) ≤ p*p+(if a=b then p else 0) := by by_cases hx:a=b · subst a; rw [ite_eq_left rfl]; simp only [ind_mul,marginal]; dsimp [p]; nlinarith · rw [ite_eq_right hx,add_zero,pair_avg] have eq := pairMean (k:=k) (j:=k) (x:=g a) (y:=g b) (fun w=>hx (h ha hb w.symm)) exact mul_le_mul_of_nonneg_left (eq.2 rfl) (le_of_lt (pct_pos (NeZero.pos n) k)) have hj : av (fun i=>(f i)^2) = ∑ a∈s,∑ b∈s, av (fun i=>ind k (g a) i*ind k (g b) i) := by have h (i) : f i^2 = ∑ a∈s,∑ b∈s,ind k (g a) i*ind k (g b) i := by simp_rw [←mul_sum,←sum_mul]; rw [sq] simp only [h,av_sum] have hu := sum_le_sum (s:=s) fun a ha => sum_le_sum (s:=s) (fun b hb=> hi a ha b hb) have hr (a) (ha : a∈s) : ∑ b∈s,(p*p+(if a=b then p else 0)) = s.card*(p*p)+p := by simp [sum_add_distrib,ha] rw [hj] rw [sum_congr rfl hr, sum_const,nsmul_eq_mul] at hu change _-(av f)^2 ≤ (s.card:ℝ)*p rw [he]; linarith end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section open Finset variable {α : Type} abbrev Vals (α : Type) := α → ℝ def rkSet (s : Finset α) (f : Vals α) (K : ℕ) := insert 0 ((s.image f).filter (fun v=> K < (s.filter (fun i=> v ≤ f i)).card)) lemma rkSet_zero (s : Finset α) (f : Vals α) (K) : 0 ∈ rkSet s f K := by simp [rkSet] /-- zero-based descending rank, padded by zeros -/ def rank (s : Finset α) (f : Vals α) (K : ℕ) := (rkSet s f K).max' ⟨0,rkSet_zero s f K⟩ lemma rank_nn (s : Finset α) (f : Vals α) (K) : 0≤ rank s f K := Finset.le_max' _ _ (rkSet_zero s f K) lemma rank_member (s : Finset α) (f : Vals α) (K) : rank s f K ∈ rkSet s f K := Finset.max'_mem _ _ lemma rank_gt {s : Finset α} {f : Vals α} {K v} (h : 0≤v) : v v v v≤f i)).card := by classical constructor · intro e have he := rank_member s f K rw [rkSet,mem_insert] at he rcases he with he|he · linarith apply lt_of_lt_of_le (mem_filter.1 he).2 (card_le_card ?_) intro i hi obtain ⟨hi,hk⟩ := mem_filter.mp hi exact mem_filter.2 ⟨hi,e.trans hk⟩ · intro he let u:=s.filter (fun i=>v≤f i) have e : u.Nonempty := card_pos.mp (lt_of_le_of_lt K.zero_le he) let m:=(u.image f).min' (e.image _) obtain ⟨i,hi,rfl'⟩ : ∃ i∈u, f i=m := mem_image.mp (min'_mem _ _) have hm (i) (h : i∈u) : m ≤ f i := min'_le _ _ (mem_image_of_mem _ h) obtain ⟨hi,hg⟩ := mem_filter.mp hi rw [rfl'] at hg refine hg.trans (le_max' _ _ (mem_insert_of_mem (mem_filter.mpr ?_))) refine ⟨mem_image.2 ⟨i,hi,rfl'⟩, lt_of_lt_of_le he (card_le_card ?_)⟩ intro j hj; exact mem_filter.2 ⟨(mem_filter.1 hj).1,hm j hj⟩ lemma rank_le {s : Finset α} {f : Vals α} {K v} (h : 0≤v) (e : ∀ i∈s, f i≤v) : rank s f K ≤ v := by classical by_contra! H have hk := (rank_gt h).1 H have he : (s.filter fun i=>v (abs_le'.mp (e i hi)).1) · rw [neg_sub]; exact rank_compare h fun i hi=> by have := (abs_le'.mp (e i hi)).2; linarith end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section open Finset /-- A convenience for the different integrated-error sums. -/ structure Meter (α : Type) where I : (α → ℝ) → ℝ mono {f g : α → ℝ} : f≤g → I f≤I g add (f g) : I (fun i=> f i + g i) = I f+I g scl (c : ℝ) (f) : I (fun i=>c*f i)=c*I f namespace Meter variable {α β : Type} def Avg [Fintype α] : Meter α := ⟨av,av_mono,av_add,av_cmul⟩ def Sum (S : Finset α) : Meter α := ⟨fun f=>∑ i∈S,f i,fun h=>sum_le_sum fun i _=>h i,fun _ _=>sum_add_distrib, fun _ _=>(mul_sum ..).symm⟩ def Scale (u : Meter α) (c : ℝ) (h:0≤c) : Meter α := ⟨fun f=>c*u.I f,fun e=>mul_le_mul_of_nonneg_left (u.mono e) h, fun f g=>by rw [u.add,mul_add],fun a f=>by rw [u.scl]; ring⟩ def Along (u : Meter α) (v : α → Meter β) : Meter (α × β) := ⟨fun f=> u.I (fun a=> (v a).I fun b=>f (a,b)), fun h=>u.mono fun a=>(v a).mono fun b=>h (a,b), fun f g=> by simp only [Meter.add],fun c f=>by simp only [Meter.scl]⟩ variable (u : Meter α) lemma I0 : u.I (fun _=>0)=0 := by simpa using u.scl 0 (fun _=>0) lemma positive {f} (h : ∀ i,0≤f i) : 0≤u.I f := le_trans (le_of_eq u.I0.symm) (u.mono h) lemma Ineg (f) : u.I (fun i=> -f i) = -u.I f := by simpa using u.scl (-1) f lemma Isub (f g): u.I (fun i=>f i-g i)=u.I f-u.I g := by simp only [sub_eq_add_neg,u.add,u.Ineg] lemma Isum {γ : Type} (s : Finset γ) (f : γ → α → ℝ) : u.I (fun i=>∑ j∈s,f j i)=∑ j∈s,u.I (f j) := by classical induction s using Finset.induction_on <;> simp_all [u.I0, Meter.add] def m2 (f : α → ℝ) := u.I fun i=>f i^2 def m4 (f : α → ℝ) := u.I fun i=>f i^4 def L (f) := fourth (u.m4 f) lemma m2nn (f) : 0≤ u.m2 f := u.positive fun _=>sq_nonneg _ lemma m4nn (f) : 0≤ u.m4 f := u.positive fun _=> by positivity lemma Lnn (f) : 0≤u.L f := fourth_nn _ lemma L4 (f) : u.L f^4=u.m4 f := fourth_four (u.m4nn _) lemma LP {f : α → ℝ} {c : ℝ} (hc : 0≤ c) : u.L f ≤ c ↔ u.m4 f ≤ c^4 := by constructor · intro h; rw [← L4]; exact pow_le_pow_left₀ (u.Lnn _) h _ · intro h exact (fourth_mono h).trans_eq (four_fourth hc) lemma abs4 (z : ℝ) : |z|^4=z^4 := by rcases le_total 0 z with h|h; rw [abs_of_nonneg h]; rw [abs_of_nonpos h]; ring lemma neg4 (z : ℝ) : (-z)^4=z^4 := by ring lemma m4mono {f g} (h : ∀ i,|f i|≤|g i|) : u.m4 f≤u.m4 g := u.mono fun i=>by simpa only [abs4] using pow_le_pow_left₀ (abs_nonneg _) (h i) 4 lemma Lmono {f g} (h : ∀ i, |f i|≤|g i|) : u.L f ≤ u.L g := fourth_mono (u.m4mono h) lemma Labs (f) : u.L (fun i=>|f i|) = u.L f := by simp [L,m4,abs4] lemma Lzero : u.L (fun _=>0)=0 := by simp [L,m4,u.I0,fourth] lemma Lneg (f) : u.L (fun i=> -f i)=u.L f := by simp [L,m4,neg4] lemma Lmul (f) (c : ℝ) : u.L (fun i=>c*f i)=|c| * u.L f := by unfold L m4 simp only [mul_pow,u.scl,fourth_mul (show 0≤c^4 by positivity)] have he := four_fourth (x:=|c|) (abs_nonneg _) rw [abs4] at he rw [he] lemma cs (f g : α → ℝ) : (u.I fun i=> f i*g i)^2 ≤ u.m2 f*u.m2 g := by let x:=u.I fun i=> f i*g i have ht (p q:ℝ) : 0 ≤ p^2*u.m2 f-2*p*q*x+q^2*u.m2 g := by let F i:=p*f i-q*g i have he (i) : (F i)^2=p^2*f i^2-2*p*q*(f i*g i)+q^2*g i^2 := by unfold F; ring have hq:= u.m2nn F rw [m2] at hq simp only [he,u.add,u.Isub,u.scl] at hq exact hq have hh:=u.m2nn g rcases hh.eq_or_lt with hh|hh · by_contra h have he:x≠0:=by intro e; apply h; change x^2≤_;rw [e,← hh]; norm_num have hu:=ht 1 ((u.m2 f +1)/x) rw [←hh] at hu have hl : (u.m2 f+1)/x*x=u.m2 f+1:= by field_simp nlinarith [u.m2nn f] · have hu:= ht (u.m2 g) x change x^2≤_ by_contra! hs nlinarith [mul_lt_mul_of_pos_right hs hh] lemma m2m4 (f) : u.m2 (fun i=>f i^2)=u.m4 f := by unfold m2 m4 simp only [← pow_mul] lemma Holder2 (f g : α → ℝ) : u.I (fun i=> f i^2*g i^2) ≤ u.L f^2*u.L g^2 := by have he := u.cs (fun i=>f i^2) (fun i=>g i^2) rw [m2m4,m2m4,←L4,← L4] at he set x := u.I _ have hd : 0≤ u.L f^2*u.L g^2 := by positivity nlinarith lemma Holder3 (f g : α → ℝ) : u.I (fun i=> f i*g i^3) ≤ u.L f * u.L g^3 := by have he := u.cs (fun i=>f i*g i) (fun i=>g i^2) have hs := u.Holder2 f g rw [m2m4,←L4,m2] at he simp only [mul_pow] at he have hk (i : α) : f i*g i*g i^2=f i*g i^3 := by ring simp_rw [hk] at he have hz : 0≤u.L f *u.L g^3 := by have := u.Lnn f; have := u.Lnn g; positivity nlinarith [mul_le_mul_of_nonneg_right hs (show 0≤ u.L g^4 by positivity)] lemma mink (f g : α → ℝ) : u.L (fun i=> f i+g i)≤ u.L f+u.L g := by let z:=fun i=> f i+g i have he:u.L z ^4=u.I (fun i=> f i*z i^3)+u.I (fun i=>g i*z i^3) := by rw [← Meter.add,u.L4]; unfold m4 congr 1; ext i; unfold z; ring have hu:=u.Lnn z change u.L z≤_ by_contra! hv have hh : 0< u.L z := by linarith [u.Lnn f,u.Lnn g] have hx := u.Holder3 f z; have hy := u.Holder3 g z nlinarith [mul_lt_mul_of_pos_right hv (pow_pos hh 3)] lemma many {γ : Type} (S : Finset γ) (f : γ → α → ℝ) : u.L (fun i=>∑ j∈S,f j i) ≤ ∑ j∈S, u.L (f j) := by classical induction S using Finset.induction_on with | empty=>simp [Lzero] | @insert a S ha h=> simp only [sum_insert ha] exact le_trans (u.mink _ _) (add_le_add_right h _) end Meter end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section open Square _root_.OAI.ExactDerandomization.Analysis.Affine /- formula over any ring -/ namespace Wrap abbrev Four (α : Type) := (α × α) × (α × α) variable {R : Type} [CommRing R] def lower (aff : Bool) (k : Cmd) (x y : R × R) : R × R := match k with | Sum.inl (Sum.inl k)=> let t : R := -(amount k.2:R) if k.1 then (x.1+t*x.2,x.2) else (x.1,x.2+t*x.1) | Sum.inl (Sum.inr b)=> if aff then if b then (x.1+1,x.2) else (x.1,x.2+1) else x | Sum.inr (i,j) => let t := if j then y.1 else y.2 if i then (x.1+t,x.2) else (x.1,x.2+t) def pol (aff : Bool) (g : Gen) (x : Four R) : Four R := if g.1 then (x.1,lower aff g.2 x.2 x.1) else (lower aff g.2 x.1 x.2,x.2) variable {m : ℕ} [NeZero m] omit [NeZero m] in lemma act_formula (aff : Bool) (g : Gen) (x : V m) : act aff g x=pol aff g x := by have hl (x y : T m) (c) : lead c aff y x=lower aff c x y := by cases c with | inl b => cases b with | inl b => rcases b with ⟨c,d⟩; cases c <;> rfl | inr b => cases aff <;> cases b <;> simp [lead,lower,axial,Prod.ext_iff] | inr b => rcases b with ⟨c,d⟩; cases c <;> cases d <;> simp [lead,lower,crossTerm,Prod.ext_iff] cases g with | mk b c=> cases b <;> simp [face,act,pol,leadPerm,hl] def reduceV (m : ℕ) (z : Four ℤ) : V m := vmap (fun i : ℤ=> (i:ZMod m)) z def raiseV (z : V m) : Four ℤ := vmap (fun i=> (i.val:ℤ)) z omit [NeZero m] in lemma reduce_add (x y) : reduceV m (x+y)=reduceV m x+reduceV m y := by simp [reduceV,vmap] omit [NeZero m] in lemma reducePol (g) (x) : reduceV m (pol true g x)=pol true g (reduceV m x) := by let p (v : ℤ × ℤ) := ((v.1: ZMod m),(v.2:ZMod m)) have he (c) (x y : ℤ × ℤ) : p (lower true c x y) = lower true c (p x) (p y) := by cases c with | inl b => cases b with | inl b=> rcases b with ⟨i,j⟩; cases i <;> simp [lower,p] | inr b=> cases b <;> simp [lower,p] | inr b=> rcases b with ⟨i,j⟩; cases i <;> cases j <;> simp [lower,p] change (p _, p _) = pol true _ (p _,p _) cases g with | mk b c=> cases b <;> simp [pol,he] lemma reraise (x : V m) : reduceV m (raiseV x)=x := by simp [reduceV,vmap,raiseV] lemma modulo (z : Four ℤ) : raiseV (reduceV m z)=vmap (fun i=>i%(m:ℤ)) z := by simp only [reduceV,raiseV,vmap,ZMod.val_intCast] omit [NeZero m] in lemma affine_apply (g) (x y : V m) (b : ZMod m) : act true g (x-b • y)=act true g x-b • act false g y := by simp only [act_formula] have he c (x y z v : T m) : lower true c (x-b • z) (y-b • v) = lower true c x y - b • lower false c z v := by cases c with | inl a => cases a with | inl a=> rcases a with ⟨i,j⟩; cases i <;> ext <;> simp [lower] <;> ring | inr a=> cases a <;> ext <;> simp [lower] <;> ring | inr a=> rcases a with ⟨i,j⟩; cases i <;> cases j <;> ext <;> simp [lower] <;> ring cases g with | mk b c=> cases b <;> simp [pol,he] abbrev W := Four (Fin 11) def addin (m : ℕ) (w : W) : Four ℤ := vmap (fun i=> (m:ℤ)*((i.val:ℤ)-5)) w def chooseOne (m : ℕ) (i : ℤ) : Fin 11 := ⟨min 10 (5-i/(m:ℤ)).toNat,by omega⟩ def guess (m : ℕ) (x : Four ℤ) : W := vmap (chooseOne m) x lemma rem_one (x : ℤ) (h : -(4*(m:ℤ)) ≤ x ∧ x < 4*(m:ℤ)) : x+(m:ℤ)*((↑(chooseOne m x).val:ℤ)-5)=x%(m:ℤ) := by have hm : 0<(m:ℤ) := by exact_mod_cast NeZero.pos m have h1 : -4 ≤ x/(m:ℤ) := (Int.le_ediv_iff_mul_le hm).2 (by linarith [h.1]) have h2 := Int.ediv_lt_of_lt_mul hm h.2 have he : (↑(chooseOne m x).val : ℤ)-5=-(x/(m:ℤ)) := by dsimp [chooseOne]; omega rw [he] have h := Int.emod_add_mul_ediv x (m:ℤ) linarith lemma pol_bounded (x : V m) (g) : each (fun i : ℤ=> -(4*(m:ℤ)) ≤ i ∧ i < 4*(m:ℤ)) (pol true g (raiseV x)) := by let ith (p : T m) := ((p.1.val:ℤ),(p.2.val:ℤ)) let f i := -(4*(m:ℤ)) ≤ i ∧ i < 4*(m:ℤ) have h1 (p : ZMod m) : 0 ≤ (p.val:ℤ) ∧ (p.val:ℤ) < m := by constructor; positivity; exact_mod_cast ZMod.val_lt p have hp (p : ZMod m) : f p.val := by have h:=h1 p; dsimp [f]; omega have he (c) (p q : T m) : f (lower true c (ith p) (ith q)).1 ∧ f (lower true c (ith p) (ith q)).2 := by have h := h1 p.1; have h' := h1 p.2; have e:=h1 q.1; have e' := h1 q.2 cases c with | inl b => cases b with | inl b=> rcases b with ⟨i,j⟩; cases i <;> cases j <;> dsimp [ith,f,lower,amount] <;> omega | inr b=> cases b <;> dsimp [ith,f,lower] <;> omega | inr b=> rcases b with ⟨i,j⟩; cases i <;> cases j <;> dsimp [ith,f,lower] <;> omega cases g with | mk b c => cases b · exact ⟨(he c x.1 x.2).1,(he c x.1 x.2).2,hp _,hp _⟩ · exact ⟨hp _,hp _,he c x.2 x.1⟩ variable {n : ℕ} [Fact n.Prime] def guessP (k : ℕ) (g : Gen) (s : pc n k) : W := guess (side n k) (pol true g (raiseV s.2)) lemma affine_box (k : ℕ) (g) (s : pc n k) : act true g (vwide k s.2:V n)+reduceV n (addin (side n k) (guessP k g s)) = vwide k (act true g s.2) := by let z := pol true g (raiseV s.2) let l := side n k have hv (x:V l) : vwide k x=reduceV n (raiseV x) := by simp only [reduceV,vwide,raiseV,vmap,Int.cast_natCast] have he : act true g s.2=reduceV l z := by rw [act_formula]; dsimp [z,l]; rw [reducePol,reraise] rw [hv,hv,act_formula,← reducePol, ← reduce_add,he, modulo] apply congrArg (reduceV n) obtain ⟨e,h,i,t⟩ := pol_bounded s.2 g exact Prod.ext (Prod.ext (rem_one _ e) (rem_one _ h)) (Prod.ext (rem_one _ i) (rem_one _ t)) /-- each fixed guessed variant permutes the *full* environment and does not involve its not-yet-known retained point y. -/ def Variant (k : ℕ) (g : Gen) (w : W) : Equiv.Perm (Channel n) := Equiv.prodCongr (Fperm g) ((act true g).trans (Equiv.addRight (reduceV n (addin (side n k) w)))) lemma variant_pin (k) (g) (y : ZMod n) (s : pc n k) : Variant k g (guessP k g s) (openP k y s)=openP k y (gens (side n k) g s) := by refine Prod.ext ?_ ?_ · rfl · change act true g (vwide k s.2-y • s.1.val) + _ = vwide k _ - y • act false g s.1.val rw [affine_apply] change _ = vwide k (act true g s.2)-_ rw [← affine_box k g s]; abel end Wrap end end ExactDerandomization.Analysis end section set_option synthInstance.maxSize 1024 namespace ExactDerandomization.Analysis noncomputable section open Finset Square _root_.OAI.ExactDerandomization.Analysis.Affine abbrev Salt (d : ℕ) := V (2^d) namespace Salt variable {b d : ℕ} abbrev Reg (d : ℕ) := ZMod (2^d) def lo (d : ℕ) (s : Reg b) : Reg d := (s.val:Reg d) def hi (d : ℕ) (s : Reg b) : Reg (b-d) := ↑(s.val/2^d) def join (s : Reg d × Reg (b-d)) : Reg b := ↑(s.1.val+2^d*s.2.val) def strip (e : d≤b) : Reg b ≃ Reg d × Reg (b-d) := have hp : (2:ℕ)^b=2^(b-d)*2^d := by rw [← pow_add,Nat.sub_add_cancel e] { toFun := fun v=>(lo d v, hi d v) invFun := join left_inv := by intro v dsimp only [lo,hi,join] have hg : v.val/2^d < 2^(b-d) := (Nat.div_lt_iff_lt_mul (by positivity)).mpr (by rw [← hp]; exact v.val_lt) simp only [ZMod.val_natCast,Nat.mod_eq_of_lt hg, Nat.mod_add_div,ZMod.natCast_zmod_val] right_inv := by intro v have hv : v.1.val < 2^d := v.1.val_lt have he : v.2.val<2^(b-d) := v.2.val_lt have hg : v.1.val+2^d*v.2.val<2^b := by rw [hp]; nlinarith dsimp only [lo,hi,join] simp only [ZMod.val_natCast,Nat.mod_eq_of_lt hg] rw [Nat.add_mul_div_left _ _ (pow_pos (by omega) _),Nat.div_eq_of_lt hv,Nat.zero_add, ZMod.natCast_zmod_val,Nat.cast_add,Nat.cast_mul, show ((↑(2^d:ℕ) : Reg d))=0 from ZMod.natCast_self _,zero_mul,add_zero, ZMod.natCast_zmod_val] } private def par {α β γ : Type} (e : α ≃ β × γ) : (α × α) ≃ (β × β) × (γ × γ) := (Equiv.prodCongr e e).trans (Equiv.prodProdProdComm _ _ _ _) def splitBits (e : d≤b) : Salt b ≃ Salt d × Salt (b-d) := par (par (strip e)) set_option synthInstance.maxSize 1024 theorem fst_split (e:d≤b) (v : Salt b) : (splitBits e v).1=vmap (lo d) v := rfl theorem snd_split (e:d≤b) (v : Salt b) : (splitBits e v).2=vmap (hi d) v := rfl end Salt /-- Canonical roles: X,Y,Z, then raw (unreduced) salt bits. -/ abbrev Env (n w : ℕ) := Channel n × Channel n × Channel n × Salt w namespace Env variable {n w d : ℕ} [Fact n.Prime] abbrev Slice (n k j d : ℕ) := pc n k × pc n j × Channel n × Salt d def inward (k j : ℕ) (x y : ZMod n) (s : Env n w) : Slice n k j w := (closeP k x s.1, closeP j y s.2.1,s.2.2) def outward (k j : ℕ) (x y : ZMod n) (s : Slice n k j w) : Env n w := (openP k x s.1,openP j y s.2.1,s.2.2) abbrev mask (k j : ℕ) (x y : ZMod n) (s : Env n w) := hit k x s.1 ∧ hit j y s.2.1 theorem inverse1 (k j) (x y : ZMod n) (s : Env n w) (h : mask k j x y s) : outward k j x y (inward k j x y s)=s := by simp [outward,inward,open_close _ _ _ h.1,open_close _ _ _ h.2] theorem inverse2 (k j) (x y : ZMod n) (s : Slice n k j w) : inward k j x y (outward k j x y s)=s := by simp [outward,inward,close_open] theorem hits (k j) (x y : ZMod n) (s : Slice n k j w) : mask k j x y (outward k j x y s) := ⟨hit_open ..,hit_open ..⟩ def cond (k j : ℕ) (x y : ZMod n) (f : Env n w → ℝ) := av (fun s=> f (outward k j x y s)) theorem two_cond (k j : ℕ) (x y : ZMod n) (f : Env n w → ℝ) : av (fun s=> if mask k j x y s then f s else 0) = pct n k * pct n j * cond k j x y f := by let h (v w : Channel n) := av fun t : Channel n × Salt _ => f (v,w,t) have he (v : Channel n) : av (fun a : Channel n × Channel n × Salt w => if mask k j x y (v,a) then f (v,a) else 0) = if hit k x v then pct n j*atP j y (h v) else 0 := by cases em : decide (hit k x v) · have h : ¬hit k x v := decide_eq_false_iff_not.mp em simp [mask,h,av_zero] have hx : hit k x v := of_decide_eq_true em simp only [mask, hx,true_and,ite_true] rw [av_prod,← conditionP j y (h v)] congr 1 ext i by_cases e : hit j y i · simp [e,h] · simp [e,av_zero] rw [av_prod] change av (fun a=> av (fun b=> if mask k j x y (a,b) then f (a,b) else 0)) = _ simp_rw [he] rw [conditionP] unfold atP cond rw [av_cmul, mul_assoc,av_prod] unfold outward h simp only [av_prod] def subSalt {k j : ℕ} (e : d≤w) : Slice n k j w ≃ Slice n k j d × Salt (w-d) := let t := Salt.splitBits e { toFun := fun ⟨a,b,c,v⟩=> ((a,b,c,(t v).1),(t v).2) invFun := fun ⟨⟨a,b,c,v⟩,u⟩=> (a,b,c,t.symm (v,u)) left_inv := by rintro ⟨a,b,c,v⟩; simp right_inv := by rintro ⟨⟨a,b,c,v⟩,u⟩; simp } def panel (k j : ℕ) (x y : ZMod n) (e : d≤w) (z : Salt (w-d)) (f : Env n w → ℝ) : Slice n k j d → ℝ := fun s=>f (outward k j x y ((subSalt e).symm (s,z))) lemma mean_panel (k j) (x y : ZMod n) (e : d≤w) (f : Env n w → ℝ) : av (fun z=> av (panel k j x y e z f))=cond k j x y f := by unfold panel rw [av_swap,← av_prod (fun p=>f (outward k j x y ((subSalt e).symm p)))] exact av_equiv (subSalt e).symm (fun s=>f (outward k j x y s)) end Env end end ExactDerandomization.Analysis end section set_option synthInstance.maxSize 2048 namespace ExactDerandomization.Analysis noncomputable section open Square _root_.OAI.ExactDerandomization.Analysis.Affine Finset def unionG {α β γ δ : Type} (f : Family γ α) (g : Family δ β) : Family (γ⊕δ) (α × β) := Sum.elim (fun i=> Equiv.prodCongr (f i) (Equiv.refl β)) (fun i=> Equiv.prodCongr (Equiv.refl α) (g i)) lemma expands_product {α β γ δ : Type} [Fintype α] [Nonempty α] [Fintype β] [Nonempty β] [Fintype γ] [Fintype δ] {f : Family γ α} {g : Family δ β} {C : ℝ} (hf : expands f C) (hg : expands g C) (hC : 0≤C) : expands (unionG f g) C := by intro w rw [var2_prod,energies,Fintype.sum_sum_type,mul_add,add_comm] apply add_le_add · refine le_trans (hf _) (mul_le_mul_of_nonneg_left ?_ hC) unfold energies exact sum_le_sum fun i _=> energy_project w (f i) (Equiv.refl β) · let v (i : α) (j) := w (i,j) have he := av_mono (f:=fun i=>var2 (v i)) (g:=fun i=>C*energies g (v i)) (fun i=>hg _) simp only [energies,av_cmul,av_sum] at he refine he.trans (le_of_eq ?_) congr 1 apply sum_congr rfl intro i _ unfold energy rw [av_prod] rfl lemma nonneg_en {α γ : Type} [Fintype α] [Fintype γ] (g : Family γ α) (f) : 0 ≤ energies g f := sum_nonneg fun _ _=>av_nonneg _ fun _=>sq_nonneg _ namespace Env variable {n w d : ℕ} [Fact n.Prime] abbrev Choice := Gen ⊕ Gen ⊕ Gen ⊕ Gen abbrev Atom := Bool × Choice abbrev Roller := Wrap.W def mixP (k j : ℕ) : Family Choice (Slice n k j d) := unionG (gens (side n k)) (unionG (gens (side n j)) (unionG (gens n) (act true))) lemma full_gap (k j : ℕ) : expands (mixP k j : Family Choice (Slice n k j d)) (10*gap0) := by have hh : 0≤gap0 := by linarith [gapFuel_pos] refine expands_product (slice_gap _) (expands_product (slice_gap _) (expands_product (slice_gap _) ?_ (by positivity)) (by positivity)) (by positivity) intro f have H := bits_gap (2^d) f have hg : 0≤energies (act true) f := nonneg_en _ _ exact le_trans H (mul_le_mul_of_nonneg_right (by linarith) hg) def rolling (e : d≤w) (i : Gen) : Equiv.Perm (Salt w) := let eq := Salt.splitBits e (eq.trans (Equiv.prodCongr (act true i) (Equiv.refl _))).trans eq.symm def rollG (k j : ℕ) (e : d≤w) (v : Roller) : Family Choice (Env n w) := unionG (fun i=> Wrap.Variant k i v) (unionG (fun i=> Wrap.Variant j i v) (unionG (gens n) (rolling e))) def rol (k j : ℕ) (e : d≤w) (a : Atom) (v : Roller) : Equiv.Perm (Env n w) := if a.1 then rollG k j e v a.2 else Equiv.refl _ def winner (k j : ℕ) (x y : ZMod n) (a : Atom) (s : Env n w) : Roller := if a.1 then match a.2 with | Sum.inl i => Wrap.guessP k i (closeP k x s.1) | Sum.inr (Sum.inl i) => Wrap.guessP j i (closeP j y s.2.1) | _ => 0 else 0 def fullact (k j : ℕ) (a : Atom) : Equiv.Perm (Slice n k j d) := if a.1 then mixP k j a.2 else Equiv.refl _ def exportP (k j : ℕ) (x y : ZMod n) (e : d≤w) (z : Salt (w-d)) (s : Slice n k j d) := outward k j x y ((subSalt e).symm (s,z)) theorem winner_roll (k j : ℕ) (x y : ZMod n) (e : d≤w) (z : Salt (w-d)) (s : Slice n k j d) (a : Atom) : let o := exportP k j x y e z rol k j e a (winner k j x y a (o s)) (o s) = o (fullact k j a s) := by rcases a with ⟨b, i|i|i|i⟩ <;> cases b <;> rcases s with ⟨s1,s2,s3,s4⟩ <;> simp [rol,rollG,winner,exportP,outward,unionG,subSalt,mixP,fullact, Wrap.variant_pin,close_open,rolling] def weight := (↑(Fintype.card Atom) : ℝ)⁻¹ omit [Fact (Nat.Prime n)] in lemma atom_mix (k j : ℕ) (f : Slice n k j d → ℝ) (s) : lazyK (mixP k j) f s= weight*∑ a:Atom,f (fullact k j a s) := by have he (f:Atom→ℝ) : weight*∑ a,f a=av f := by unfold weight av avs; simp [div_eq_mul_inv]; ring rw [he,av_prod,av_swap] unfold lazyK fullact congr 1 funext i simp [av,avs] abbrev Paths (α : Type) : ℕ → Type | 0 => Unit | d+1 => α × Paths α d instance pathFin (α) [Fintype α] (d) : Fintype (Paths α d) := match d with | 0 => inferInstanceAs (Fintype Unit) | k+1 => letI : Fintype (Paths α k) := pathFin α k; inferInstanceAs (Fintype (α × Paths α k)) def go (k j : ℕ) (e : d≤w) : {l : ℕ}→Paths Atom l → Paths Roller l → Equiv.Perm (Env n w) | 0,_,_=> Equiv.refl _ | _+1,(a,s),(v,t)=> (rol k j e a v).trans (go k j e s t) def live (k j : ℕ) (x y : ZMod n) (e : d≤w) : {l : ℕ}→ Paths Atom l → Paths Roller l → Env n w → Bool | 0,_,_,_=>true | _+1,(a,s),(v,t),u=> if v=winner k j x y a u then live k j x y e s t (rol k j e a v u) else false theorem ok_dest (k j : ℕ) (x y : ZMod n) (e : d≤w) {l:ℕ} (p : Paths Atom l) (r : Paths Roller l) {s : Env n w} (h : mask k j x y s) (hl : live k j x y e p r s=true) : mask k j x y (go k j e p r s) := by induction l generalizing s with | zero=> exact h | succ l ih=> rcases p with ⟨a,p⟩; rcases r with ⟨v,r⟩ rw [live] at hl; split at hl · next he=> apply ih p r _ hl let o := subSalt (n:=n) (k:=k) (j:=j) e let v' := inward k j x y s have hh : exportP k j x y e (o v').2 (o v').1=s := by simp [o,exportP,v',inverse1 _ _ _ _ s h] change mask _ _ _ _ (rol k j _ a v s) rw [he,← hh,winner_roll] exact hits _ _ _ _ _ · simp at hl def sampling (k j : ℕ) (x y : ZMod n) (e : d ≤ w) (l : ℕ) (f : Env n w → ℝ) (s : Env n w) : ℝ := ∑ p : Paths Atom l, ∑ r : Paths Roller l, if live k j x y e p r s then weight^l * f (go k j e p r s) else 0 lemma pathZero (α : Type) [Fintype α] (f : Paths α 0→ℝ) : ∑ a,f a = f () := by change ∑ a:Unit,f a= _; simp lemma pathFold (α : Type) [Fintype α] (l) (f : Paths α (l+1)→ℝ) : ∑ a,f a = ∑ a:α,∑ b:Paths α l,f (a,b) := Fintype.sum_prod_type _ lemma sampler_identity (k j : ℕ) (x y : ZMod n) (e : d ≤ w) (z : Salt (w-d)) (l : ℕ) (f : Env n w → ℝ) (s : Slice n k j d) : sampling k j x y e l f (exportP k j x y e z s) = walk (mixP k j) (panel k j x y e z f) l s := by induction l generalizing s with | zero => simp [sampling,walk,go,live,exportP,panel] | succ l ih => let o := exportP k j x y e z unfold sampling rw [walk,atom_mix,mul_sum,pathFold] apply sum_congr rfl; intro a _ simp_rw [pathFold Roller] rw [sum_comm] let b := winner k j x y a (o s) have he (p : Paths Atom l) (v : Paths Roller l) : (if live k j x y e (l:=l+1) (a,p) (b,v) (o s) then weight^(l+1) * f (go k j e (l:=l+1) (a,p) (b,v) (o s)) else 0) = weight * (if live k j x y e p v (o (fullact k j a s)) then weight^l*f (go k j e p v (o (fullact k j a s))) else 0) := by have hg : rol k j e a b (o s)=o (fullact k j a s) := winner_roll .. rw [live,ite_eq_left rfl,go,Equiv.trans_apply,hg] split; rw [pow_succ',mul_assoc]; rw [mul_zero] rw [Finset.sum_eq_single b] · rw [← ih] simp only [sampling, mul_sum] exact sum_congr rfl (fun p _ => sum_congr rfl (fun v _=> he p v)) · intro v _ h have hv : v ≠ winner k j x y a (exportP k j x y e z s) := h simp [live,hv] · simp /-- Kernel contraction for this sampling definition. Handles high salt bits z held fixed; target here is the mean in that panel. -/ lemma sampler_est (k j : ℕ) (x y : ZMod n) (e : d≤w) (z : Salt (w-d)) (l : ℕ) (f : Env n w → ℝ) : let o := exportP k j x y e z let g := panel k j x y e z f mass4 (fun s=>sampling k j x y e l f (o s) - av g) ≤ (1-loss Choice (10*gap0))^l * (16*mass4 g) := by simp only [sampler_identity] exact walk_mix (by linarith [gapFuel_pos]) (full_gap k j) _ _ end Env end end ExactDerandomization.Analysis end section namespace ExactDerandomization.Analysis noncomputable section variable {α : Type} lemma difference_L (u : Meter α) (f g : α → ℝ) : |u.L f-u.L g| ≤ u.L (fun i=>f i-g i) := by have H (f g : α→ℝ) : u.L f≤u.L g + u.L (fun i=>f i-g i) := by have ht:=u.mink g (fun i=>f i-g i) simp_all have ht:u.L (fun i=>g i-f i)=u.L (fun i=>f i-g i) := by convert u.Lneg (fun i=>f i-g i) using 2; ext i; simp obtain h:= H f g obtain h':=H g f rw [abs_le] constructor <;> linarith lemma integralRoot (u : Meter α) (f : α → ℝ) (h : ∀ i,0≤f i) : fourth (u.I f)=u.L (fun i=>fourth (f i)) := by simp [Meter.L,Meter.m4,fourth_four (h _)] lemma mixtures (u : Meter α) (f g : α→ℝ) (h:∀ i,0≤f i) (e:∀ i,0≤g i) : (fourth (u.I f)-fourth (u.I g))^4 ≤ u.I (fun i=>(fourth (f i)-fourth (g i))^4) := by rw [integralRoot u f h,integralRoot u g e] let f' := fun i=>fourth (f i) let g' := fun i=>fourth (g i) have he := difference_L u f' g' have ht := pow_le_pow_left₀ (abs_nonneg _) he 4 rw [Meter.abs4,u.L4] at ht exact ht abbrev rel (x d : ℝ) := min 1 (|x| / (1+d)) lemma four_distance {x y C : ℝ} (h:0≤x) (e:0≤y) (hx:x≤C) (hy:y≤C) : |x^4-y^4|≤4*C^3* |x-y| := by rw [show x^4-y^4=(x-y)*(x^3+x^2*y+x*y^2+y^3) by ring,abs_mul, abs_of_nonneg (show 0≤x^3+x^2*y+x*y^2+y^3 by positivity)] have hh : x^3+x^2*y+x*y^2+y^3≤4*C^3 := by calc _ ≤ C^3+C^2*C+C*C^2+C^3 := by gcongr; linarith _ = _ := by ring nlinarith [mul_le_mul_of_nonneg_left hh (abs_nonneg (x-y))] lemma ordinary {s t u : ℝ} (h : 0 ≤ s) (e : 0≤t) (hs:fourth s ≤ u) (ht:fourth t ≤ u) : |s-t| ≤ 4*u^3 * |fourth s-fourth t| := by convert four_distance (fourth_nn s) (fourth_nn t) hs ht using 2; rw [fourth_four h,fourth_four e] lemma fidelity {s t u C : ℝ} (h : 0 ≤ s) (e : 0≤t) (g:0≤u) (he:s≤C*u) (hc:1≤C) : rel (s-t) u ≤32*C * |fourth s-fourth t| := by let v:=fourth s let w:=fourth t let x:=max 1 v have hx: 1≤x:=le_max_left .. have hv:=fourth_nn s; change 0≤v at hv have hw: v≤x:=le_max_right .. rcases le_total 1 |v-w| with h1|h1 · exact le_trans (min_le_left ..) (show 1≤32*C * |v-w| by nlinarith) · have hj : w ≤ 2*x:= by rw [abs_le] at h1; linarith [h1.1] have hl : x^3≤C*(1+u) := by rcases le_total v 1 with h2|h2 · rw [show x=1 from max_eq_left h2] nlinarith · rw [show x=v from max_eq_right h2] have ht : v^3 ≤ v^4:= by exact pow_le_pow_right₀ h2 (by omega) have hk:v^4=s:=fourth_four h nlinarith have hp : 0<1+u:=by linarith have he := ordinary h e (show v≤2*x by linarith) hj refine le_trans (min_le_right ..) ((div_le_iff₀ hp).mpr ?_) change |s - t|≤32*C * |v-w| * (1+u) nlinarith [mul_le_mul_of_nonneg_right hl (abs_nonneg (v-w))] end end ExactDerandomization.Analysis end end OAI