| import OAI.Analysis.DiamondDistortion.SignCube |
|
|
| namespace OAI |
|
|
| universe u v |
|
|
| noncomputable section |
| open scoped BigOperators Classical Topology |
| open Set |
|
|
| namespace DiamondDistortion |
|
|
| open scoped ENNReal |
|
|
| namespace DirectLayers |
|
|
| section |
| open SignCube Diamond |
| variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [Preorder I] |
| def signed (x y : X) (b : Bool) : X := if b then x-y else x+y |
| lemma signed_average (x y : X) : (1/2:ℝ) • (signed x y false+signed x y true)=x := by |
| simp only [signed,Bool.false_eq_true,ite_false,ite_true] |
| module |
| lemma signed_error {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] (x y x' y' : X) (b : Bool) : |
| ‖signed x y b-signed x' y' b‖ ≤ ‖x-x'‖+‖y-y'‖ := by |
| cases b |
| · change ‖x+y-(x'+y')‖ ≤ _ |
| rw [show x+y-(x'+y')=(x-x')+(y-y') by abel] |
| exact norm_add_le _ _ |
| · change ‖x-y-(x'-y')‖ ≤ _ |
| rw [show x-y-(x'-y')=(x-x')-(y-y') by abel] |
| exact norm_sub_le _ _ |
| lemma signed_slope {n : ℕ} (f : Vertex (n+1) → X) (e : Edge n) (j : ℕ) (b : Bool) : |
| signed (slope (fun u => f (.inl u)) e) (deviation f e j) b=slope f (e,j,b) := by |
| cases b |
| · exact slope_plus_deviation f e j |
| · exact slope_minus_deviation f e j |
| lemma deviation_bound {n : ℕ} (f : Vertex (n+1) → X) {L : ℝ} |
| (hu : ∀ u v,‖f u-f v‖ ≤ L*distance (n+1) u v) (e : Edge n) (j : ℕ) : |
| ‖deviation f e j‖ ≤ L := by |
| apply norm_deviation_le (x := slope (fun u => f (.inl u)) e) |
| · rw [slope_plus_deviation]; exact slope_upper f hu _ |
| · rw [slope_minus_deviation]; exact slope_upper f hu _ |
|
|
| namespace Regular |
| variable {A : Midpoint.Heads I X} (hA : Regular A) |
| include hA |
| lemma signed_supported (H B : I) (hHB : H ≤ B) (x y : X) (hx : A.projection H x=x) |
| (hy : A.projection B y=y) (b : Bool) : A.projection B (signed x y b)=signed x y b := by |
| have hBx : A.projection B x=x := by rw [← hx,hA.nested_right _ _ hHB] |
| cases b <;> simp [signed,map_add,map_sub,hBx,hy] |
| lemma signed_layer (H B : I) (hHB : H ≤ B) (x y : X) (hx : A.projection H x=x) |
| (hy : A.projection B y=y) (b : Bool) : |
| ‖A.projection B (signed x y b)-A.projection H (signed x y b)‖=‖y-A.projection H y‖ := by |
| rw [hA.signed_supported H B hHB x y hx hy b] |
| cases b |
| · change ‖x+y-A.projection H (x+y)‖=_ |
| rw [map_add,hx,show x+y-(x+A.projection H y)=y-A.projection H y by abel] |
| · change ‖x-y-A.projection H (x-y)‖=_ |
| rw [map_sub,hx,show x-y-(x-A.projection H y)=-(y-A.projection H y) by abel,norm_neg] |
| lemma projected_layer_lower (H B : I) (hHB : H ≤ B) (z : X) {r η : ℝ} |
| (hr : r < ‖z-A.projection H z‖) (he : ‖z-A.projection B z‖ < η) : |
| r-η < ‖A.projection B z-A.projection H (A.projection B z)‖ := by |
| rw [hA.nested_left _ _ hHB] |
| have hh := norm_sub_le (z-A.projection H z) (z-A.projection B z) |
| rw [show (z-A.projection H z)-(z-A.projection B z)=A.projection B z-A.projection H z by abel] at hh |
| have hh' := norm_sub_le (A.projection B z-A.projection H z) (A.projection B z-z) |
| rw [show (A.projection B z-A.projection H z)-(A.projection B z-z)=z-A.projection H z by abel, |
| norm_sub_rev (A.projection B z) z] at hh' |
| linarith |
|
|
| lemma supported_selection (k : ℕ) (f : Vertex k → X) {s L η r q : ℝ} |
| (hl : ∀ u v,s*distance k u v ≤ ‖f u-f v‖) |
| (hu : ∀ u v,‖f u-f v‖ ≤ L*distance k u v) |
| (hη : 0 < η) (hr : r < s) (hq : 0 ≤ q) (hqr : q ≤ r-η) : |
| ∃ (T : Protocol X I k) (e : History k → Edge k), |
| T.Martingale ∧ T.Nested ∧ T.Anchored ∧ T.CommonHeads ∧ T.Supported A.projection ∧ |
| (∀ u,‖T.last u-slope f (e u)‖ < ((k:ℝ)+1)*η) ∧ |
| (k:ℝ)*q^2 ≤ T.freshSum A.projection := by |
| induction k with |
| | zero => |
| obtain ⟨H⟩ := hA.nonempty |
| obtain ⟨B,_,hB⟩ := hA.capture_one H (slope f ()) hη |
| refine ⟨.initial (A.projection B (slope f ())) B,fun _ => (),trivial,trivial,trivial,trivial, |
| A.idempotent B _,?_,?_⟩ |
| · intro u |
| simpa only [Protocol.last,Nat.cast_zero,zero_add,one_mul,norm_sub_rev] using hB |
| · simp only [Nat.cast_zero,zero_mul,Protocol.freshSum,le_refl] |
| | succ n ih => |
| obtain ⟨T,e,hM,hN,hAn,hC,hS,hE,hF⟩ := ih (fun u => f (.inl u)) (old_lower f hl) (old_upper f hu) |
| obtain ⟨H,hH⟩ := T.common_last hC |
| have hsel (u : History n) : ∃ j,r < ‖deviation f (e u) j-A.projection H (deviation f (e u) j)‖ := |
| select_tail A H _ (deviation_bound f hu (e u)) |
| (fun i j hij => deviation_separated f hl (e u) hij) (by linarith) |
| choose j hj using hsel |
| let z : History n → X := fun u => deviation f (e u) (j u) |
| obtain ⟨B,hHB,hB⟩ := hA.capture H z hη |
| let v : History n → X := fun u => A.projection B (z u) |
| let W : History (n+1) → X := fun u => signed (T.last u.1) (v u.1) u.2 |
| let T' : Protocol X I (n+1) := .extend T (fun _ => H) (fun _ => B) W |
| have hHx (u : History n) : A.projection H (T.last u)=T.last u := by |
| rw [← hH u]; exact T.supported_last A.projection hS u |
| have hv (u : History n) : A.projection B (v u)=v u := A.idempotent B _ |
| refine ⟨T',fun u => (e u.1,j u.1,u.2),?_,?_,?_,?_,?_,?_,?_⟩ |
| · exact ⟨hM,fun u => (signed_average _ _).symm⟩ |
| · exact ⟨hN,fun u => ⟨(hH u).le,hHB⟩⟩ |
| · exact ⟨hAn,fun u => (hH u).symm⟩ |
| · exact ⟨hC,B,fun _ => rfl⟩ |
| · exact ⟨hS,fun u b => hA.signed_supported H B hHB _ _ (hHx u) (hv u) b⟩ |
| · intro u |
| change ‖signed (T.last u.1) (v u.1) u.2-slope f (e u.1,j u.1,u.2)‖ < _ |
| rw [← signed_slope] |
| have he := signed_error (T.last u.1) (v u.1) |
| (slope (fun w => f (.inl w)) (e u.1)) (z u.1) u.2 |
| have hvz : ‖v u.1-z u.1‖ < η := by simpa only [v,norm_sub_rev] using hB u.1 |
| have he' := he.trans_lt (add_lt_add (hE u.1) hvz) |
| exact he'.trans_eq (by push_cast; ring) |
| · have hW (u : History (n+1)) : q^2 ≤ ‖A.projection B (W u)-A.projection H (W u)‖^2 := by |
| rw [hA.signed_layer H B hHB _ _ (hHx u.1) (hv u.1) u.2] |
| apply (sq_le_sq₀ hq (norm_nonneg _)).mpr |
| exact hqr.trans (hA.projected_layer_lower H B hHB (z u.1) (hj u.1) (hB u.1)).le |
| have he := mean_lower (n+1) hW |
| change (n+1:ℕ)*q^2 ≤ T.freshSum A.projection+Protocol.childEnergy A.projection n (fun _ => H) (fun _ => B) W |
| change q^2 ≤ Protocol.childEnergy A.projection n (fun _ => H) (fun _ => B) W at he |
| push_cast |
| nlinarith only [hF,he] |
| end Regular |
| end |
| section |
| open SignCube Diamond |
| variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [Preorder I] |
| variable (A : Midpoint.Heads I X) (hA : Regular A) |
|
|
| lemma approximate_bound {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [Preorder I] {k : ℕ} (f : Vertex k → X) {L η C : ℝ} |
| (hu : ∀ u v,‖f u-f v‖ ≤ L*distance k u v) |
| (T : Protocol X I k) (e : History k → Edge k) |
| (he : ∀ u,‖T.last u-slope f (e u)‖ < ((k:ℝ)+1)*η) |
| (hC : L+((k:ℝ)+1)*η ≤ C) : ∀ u,‖T.last u‖ ≤ C := by |
| intro u |
| have hh := norm_sub_norm_le (T.last u) (slope f (e u)) |
| have hb := slope_upper f hu (e u) |
| linarith [he u] |
|
|
| include hA |
|
|
| theorem predictable_graph (hin : PredictableInput A.projection 495) {D t : ℝ} (k : ℕ) |
| (f : Vertex k → X) (hf : HasDistortion k f D t) : (k:ℝ)/4 ≤ 495*(D+1)^2 := by |
| have hn := (normalized_distortion f hf).2.2 |
| let g := fun v => t⁻¹ • f v |
| have hl : ∀ u v,(1:ℝ)*distance k u v ≤ ‖g u-g v‖ := fun u v => (hn u v).1 |
| have hu : ∀ u v,‖g u-g v‖ ≤ D*distance k u v := by simpa only [mul_one] using fun u v => (hn u v).2 |
| let η := 1/(8*((k:ℝ)+1)) |
| have hk : 0 < (k:ℝ)+1 := by positivity |
| have hη : 0 < η := by dsimp [η]; positivity |
| have heq : ((k:ℝ)+1)*η=1/8 := by dsimp [η]; field_simp |
| have hηb : η ≤ 1/8 := by |
| dsimp [η] |
| apply (div_le_iff₀ (by positivity)).mpr |
| nlinarith [Nat.cast_nonneg (α := ℝ) k] |
| obtain ⟨T,e,hM,hN,hAn,hC,hS,hE,hF⟩ := hA.supported_selection k g hl hu hη |
| (by norm_num : (3/4:ℝ)<1) (by norm_num : (0:ℝ)≤1/2) (by linarith : (1/2:ℝ)≤3/4-η) |
| have hb := approximate_bound g hu T e hE (C := D+1) (by rw [heq]; linarith) |
| have hi := hin k T hM hN hAn hS (D+1) hb |
| norm_num at hF |
| nlinarith only [hF,hi] |
|
|
| theorem variation_graph (hin : PredictableInput A.projection 252) {D t : ℝ} (k : ℕ) |
| (f : Vertex k → X) (hf : HasDistortion k f D t) : (k:ℝ)/(16*D^2) ≤ 1008 := by |
| have hD : 0 < D := by linarith [hf.1] |
| have hn := upper_one_normalization f hf |
| let g := fun v => (D*t)⁻¹ • f v |
| have hl : ∀ u v,D⁻¹*distance k u v ≤ ‖g u-g v‖ := fun u v => (hn u v).1 |
| have hu : ∀ u v,‖g u-g v‖ ≤ (1:ℝ)*distance k u v := by simpa only [one_mul] using fun u v => (hn u v).2 |
| let η := min (1/(4*D)) (1/((k:ℝ)+1))/2 |
| have hk : 0 < (k:ℝ)+1 := by positivity |
| have hη : 0 < η := by dsimp [η]; positivity |
| have hηD : η ≤ 1/(8*D) := by |
| have hh := div_le_div_of_nonneg_right (min_le_left (1/(4*D)) (1/((k:ℝ)+1))) (by norm_num : (0:ℝ)≤2) |
| exact hh.trans_eq (by field_simp; ring) |
| have hηk : ((k:ℝ)+1)*η ≤ 1/2 := by |
| have hh := mul_le_mul_of_nonneg_left (div_le_div_of_nonneg_right |
| (min_le_right (1/(4*D)) (1/((k:ℝ)+1))) (by norm_num : (0:ℝ)≤2)) hk.le |
| exact hh.trans_eq (by field_simp) |
| have hr : 3/(4*D) < D⁻¹ := by rw [inv_eq_one_div]; apply (div_lt_div_iff₀ (by positivity) hD).mpr; nlinarith |
| have hqr : 1/(4*D) ≤ 3/(4*D)-η := by |
| have he : 3/(4*D)-1/(4*D)=4*(1/(8*D)) := by field_simp; ring |
| have hp : 0 ≤ 1/(8*D) := by positivity |
| linarith |
| obtain ⟨T,e,hM,hN,hAn,hC,hS,hE,hF⟩ := hA.supported_selection k g hl hu hη hr |
| (by positivity : (0:ℝ)≤1/(4*D)) hqr |
| have hb := approximate_bound g hu T e hE (C := 2) (by linarith) |
| have hi := hin k T hM hN hAn hS 2 hb |
| have he : (k:ℝ)*(1/(4*D))^2=(k:ℝ)/(16*D^2) := by field_simp; ring |
| rw [he] at hF |
| norm_num at hi |
| exact hF.trans hi |
|
|
| /-- The fresh-gap inequality telescopes for every supported predictable dyadic |
| process, even when each increment contains a nonzero old-head part. -/ |
| lemma gap_telescope (hin : GapInput A.projection) {k : ℕ} (T : Protocol X I k) |
| (hM : T.Martingale) (hN : T.Nested) (hAn : T.Anchored) (hS : T.Supported A.projection) : |
| T.freshSum A.projection ≤ 400*(T.terminalEnergy-T.initialEnergy) := by |
| induction T with |
| | initial x H => simp [Protocol.freshSum,Protocol.terminalEnergy,Protocol.last,Protocol.initialEnergy,mean] |
| | @extend n T U B W ih => |
| have hprev := ih hM.1 hN.1 hAn.1 hS.1 |
| let y : History n → X := fun u => (1/2:ℝ) • (W (u,false)-W (u,true)) |
| have hx (u : History n) : A.projection (U u) (T.last u)=T.last u := by |
| rw [hAn.2 u]; exact T.supported_last _ hS.1 u |
| have hy (u : History n) : A.projection (B u) (y u)=y u := by |
| dsimp [y] |
| rw [map_smul,map_sub,hS.2 u false,hS.2 u true] |
| have hw (u : History n) (b : Bool) : signed (T.last u) (y u) b=W (u,b) := by |
| rw [hM.2 u] |
| cases b <;> dsimp [signed,y] <;> module |
| have hlayer (u : History n) (b : Bool) : |
| ‖A.projection (B u) (W (u,b))-A.projection (U u) (W (u,b))‖=‖y u-A.projection (U u) (y u)‖ := by |
| rw [← hw u b,hA.signed_layer _ _ (hN.2 u).2 _ _ (hx u) (hy u) b] |
| have hgap (u : History n) : ‖y u-A.projection (U u) (y u)‖^2 ≤ |
| 400*((‖W (u,false)‖^2+‖W (u,true)‖^2)/2-‖T.last u‖^2) := by |
| have hh := hin (U u) (B u) (hN.2 u).2 (T.last u) (y u) (hx u) (hy u) |
| rw [hy u] at hh |
| have h0 := hw u false |
| have h1 := hw u true |
| change T.last u+y u=W (u,false) at h0 |
| change T.last u-y u=W (u,true) at h1 |
| rwa [h0,h1] at hh |
| have heq : Protocol.childEnergy A.projection n U B W=mean n (fun u => ‖y u-A.projection (U u) (y u)‖^2) := by |
| change mean n (fun u => (‖A.projection (B u) (W (u,false))-A.projection (U u) (W (u,false))‖^2+ |
| ‖A.projection (B u) (W (u,true))-A.projection (U u) (W (u,true))‖^2)/2)=_ |
| simp_rw [hlayer] |
| congr 1 |
| funext u |
| ring |
| have hstep : Protocol.childEnergy A.projection n U B W ≤ |
| 400*((Protocol.extend T U B W).terminalEnergy-T.terminalEnergy) := by |
| rw [heq] |
| have hh := mean_mono n hgap |
| rw [mean_mul,mean_sub] at hh |
| exact hh |
| change T.freshSum A.projection+Protocol.childEnergy A.projection n U B W ≤ |
| 400*((Protocol.extend T U B W).terminalEnergy-T.initialEnergy) |
| linarith |
|
|
| theorem gap_graph (hin : GapInput A.projection) {D t γ : ℝ} (k : ℕ) |
| (f : Vertex k → X) (hf : HasDistortion k f D t) (hγ : 0 < γ) |
| (hγa : γ < (2/D)/8) (hγk : γ < 1/((k:ℝ)+1)) : |
| ∃ T : Protocol X I k,T.Martingale ∧ T.Nested ∧ T.Anchored ∧ T.CommonHeads ∧ T.Supported A.projection ∧ |
| T.terminalEnergy ≤ 4 ∧ T.initialEnergy+(k:ℝ)*((2/D)/8)^2/400 ≤ T.terminalEnergy ∧ |
| (k:ℝ)*((2/D)/8)^2/400 ≤ T.initialEnergy+(k:ℝ)*((2/D)/8)^2/400 := by |
| have hD : 0 < D := by linarith [hf.1] |
| have hn := upper_one_normalization f hf |
| let g := fun v => (D*t)⁻¹ • f v |
| have hl : ∀ u v,D⁻¹*distance k u v ≤ ‖g u-g v‖ := fun u v => (hn u v).1 |
| have hu : ∀ u v,‖g u-g v‖ ≤ (1:ℝ)*distance k u v := by simpa only [one_mul] using fun u v => (hn u v).2 |
| have hr : (2/D)/4 < D⁻¹ := by rw [inv_eq_one_div]; field_simp; nlinarith |
| have hqr : (2/D)/8 ≤ (2/D)/4-γ := by linarith |
| obtain ⟨T,e,hM,hN,hAn,hC,hS,hE,hF⟩ := hA.supported_selection k g hl hu hγ hr |
| (by positivity : (0:ℝ)≤(2/D)/8) hqr |
| have hk : 0 < (k:ℝ)+1 := by positivity |
| have hγk' : ((k:ℝ)+1)*γ ≤ 1 := by |
| have hh := (lt_div_iff₀ hk).mp hγk |
| nlinarith |
| have hb := approximate_bound g hu T e hE (C := 2) (by linarith) |
| have htel := gap_telescope A hA hin T hM hN hAn hS |
| refine ⟨T,hM,hN,hAn,hC,hS,?_,?_,?_⟩ |
| · simpa only [show (2:ℝ)^2=4 by norm_num] using T.terminalEnergy_bound (by norm_num) hb |
| · linarith |
| · linarith [T.initialEnergy_nonneg] |
| end |
| |
| section |
| open SignCube Diamond |
| variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [Preorder I] |
| lemma norm_right_signed {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] (x y : X) (b : Bool) : ‖y‖ ≤ ‖x‖+‖signed x y b‖ := by |
| cases b |
| · have hh := norm_sub_le (x+y) x |
| rw [show x+y-x=y by abel] at hh |
| change ‖y‖ ≤ ‖x‖+‖x+y‖ |
| linarith |
| · have hh := norm_sub_le x (x-y) |
| rw [show x-(x-y)=y by abel] at hh |
| exact hh |
| lemma signed_tail (P : X →L[ℝ] X) (x y : X) (b : Bool) : |
| signed x y b-P (signed x y b)=signed (x-P x) (y-P y) b := by |
| cases b |
| · dsimp [signed]; rw [map_add]; abel |
| · dsimp [signed]; rw [map_sub]; abel |
| |
| namespace Regular |
| variable {A : Midpoint.Heads I X} (hA : Regular A) |
| include hA |
| /-- Exact slopes, with a single common finite ancestral head on each level. |
| Choosing the parent head slightly finer also ensures both child outcomes |
| carry a fresh layer; this is valid for both adaptive and leakage inputs. -/ |
| lemma true_selection (k : ℕ) (f : Vertex k → X) {s L η r q : ℝ} |
| (hl : ∀ u v,s*distance k u v ≤ ‖f u-f v‖) |
| (hu : ∀ u v,‖f u-f v‖ ≤ L*distance k u v) |
| (hη : 0 < η) (hr : r < s) (hq : 0 ≤ q) (hqr : q ≤ r-2*η) : |
| ∃ (T : Protocol X I k) (e : History k → Edge k), |
| T.Martingale ∧ T.Nested ∧ T.Anchored ∧ T.CommonHeads ∧ |
| (∀ u,T.last u=slope f (e u)) ∧ |
| (∀ u,‖T.last u-A.projection (T.lastHead u) (T.last u)‖ < η) ∧ |
| (k:ℝ)*q^2 ≤ T.freshSum A.projection ∧ T.leakageSum A.projection ≤ (k:ℝ)*η^2 := by |
| induction k with |
| | zero => |
| obtain ⟨H⟩ := hA.nonempty |
| obtain ⟨B,_,hB⟩ := hA.capture_one H (slope f ()) hη |
| refine ⟨.initial (slope f ()) B,fun _ => (),trivial,trivial,trivial,trivial, |
| fun _ => rfl,fun _ => hB,?_,?_⟩ <;> |
| simp only [Nat.cast_zero,zero_mul,Protocol.freshSum,Protocol.leakageSum,le_refl] |
| | succ n ih => |
| obtain ⟨T,e,hM,hN,hAn,hC,hE,hTail,hF,hLeak⟩ := ih (fun u => f (.inl u)) (old_lower f hl) (old_upper f hu) |
| obtain ⟨H,hH⟩ := T.common_last hC |
| have hsel (u : History n) : ∃ j,r < ‖deviation f (e u) j-A.projection H (deviation f (e u) j)‖ := |
| select_tail A H _ (deviation_bound f hu (e u)) |
| (fun i j hij => deviation_separated f hl (e u) hij) (by linarith) |
| choose j hj using hsel |
| let z : History n → X := fun u => deviation f (e u) (j u) |
| let W : History (n+1) → X := fun u => signed (T.last u.1) (z u.1) u.2 |
| obtain ⟨B,hHB,hB⟩ := hA.capture H W hη |
| let T' : Protocol X I (n+1) := .extend T (fun _ => H) (fun _ => B) W |
| have hparent (u : History n) : ‖T.last u-A.projection H (T.last u)‖ < η := by |
| rw [← hH u]; exact hTail u |
| have hWtail (u : History (n+1)) : r-η < ‖W u-A.projection H (W u)‖ := by |
| rw [signed_tail] |
| have hh := norm_right_signed (T.last u.1-A.projection H (T.last u.1)) |
| (z u.1-A.projection H (z u.1)) u.2 |
| have hz := hj u.1 |
| change r < ‖z u.1-A.projection H (z u.1)‖ at hz |
| linarith [hparent u.1] |
| refine ⟨T',fun u => (e u.1,j u.1,u.2),?_,?_,?_,?_,?_,?_,?_,?_⟩ |
| · exact ⟨hM,fun u => (signed_average _ _).symm⟩ |
| · exact ⟨hN,fun u => ⟨(hH u).le,hHB⟩⟩ |
| · exact ⟨hAn,fun u => (hH u).symm⟩ |
| · exact ⟨hC,B,fun _ => rfl⟩ |
| · intro u |
| change signed (T.last u.1) (z u.1) u.2=_ |
| rw [hE] |
| exact signed_slope f (e u.1) (j u.1) u.2 |
| · exact hB |
| · have hW (u : History (n+1)) : q^2 ≤ ‖A.projection B (W u)-A.projection H (W u)‖^2 := by |
| have hh := hA.projected_layer_lower H B hHB (W u) (hWtail u) (hB u) |
| rw [hA.nested_left H B hHB] at hh |
| apply (sq_le_sq₀ hq (norm_nonneg _)).mpr |
| linarith |
| have he := mean_lower (n+1) hW |
| change q^2 ≤ Protocol.childEnergy A.projection n (fun _ => H) (fun _ => B) W at he |
| change (n+1:ℕ)*q^2 ≤ T.freshSum A.projection+Protocol.childEnergy A.projection n (fun _ => H) (fun _ => B) W |
| push_cast |
| nlinarith only [hF,he] |
| · have hp (u : History n) : ‖A.projection B (T.last u)-A.projection H (T.last u)‖^2 ≤ η^2 := by |
| exact (sq_le_sq₀ (norm_nonneg _) hη.le).mpr ((hA.layer_parent H B hHB _).trans (hparent u).le) |
| have he := mean_upper n hp |
| change Protocol.parentEnergy A.projection n (fun _ => H) (fun _ => B) T.last ≤ η^2 at he |
| change T.leakageSum A.projection+Protocol.parentEnergy A.projection n (fun _ => H) (fun _ => B) T.last ≤ (n+1:ℕ)*η^2 |
| push_cast |
| nlinarith only [hLeak,he] |
| end Regular |
| end |
| |
| open SignCube Diamond |
| variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [Preorder I] |
| variable (A : Midpoint.Heads I X) (hA : Regular A) |
| include hA |
| lemma sign_constant_nonneg {C : ℝ} (hin : SignInput A.projection C) (x : X) (hx : 0 < ‖x‖) : 0 ≤ C := by |
| obtain ⟨H⟩ := hA.nonempty |
| have hh := hin 0 (.initial x H) trivial trivial |
| simp only [Protocol.freshSum,Protocol.leakageSum,Protocol.terminalEnergy,mean,Protocol.last,add_zero] at hh |
| have hp := sq_pos_of_pos hx |
| by_contra! hn |
| exact (mul_neg_of_neg_of_pos hn hp).not_ge hh |
| |
| omit hA in |
| lemma dyadic_budget (k : ℕ) : (k:ℝ)*((2:ℝ)^k)⁻¹^2 ≤ 1 := by |
| have hp : (k:ℝ)+1 ≤ (4:ℝ)^k := by |
| induction k with |
| | zero => norm_num |
| | succ n ih => |
| rw [pow_succ] |
| push_cast |
| have hn := Nat.cast_nonneg (α := ℝ) n |
| nlinarith |
| have he : ((2:ℝ)^k)^2=(4:ℝ)^k := by |
| rw [← pow_mul,mul_comm k 2,pow_mul] |
| norm_num |
| have hh : (k:ℝ) ≤ ((2:ℝ)^k)^2 := by rw [he]; linarith |
| have hd : 0 < ((2:ℝ)^k)^2 := by positivity |
| have hb := mul_le_mul_of_nonneg_right hh (inv_nonneg.mpr hd.le) |
| rw [mul_inv_cancel₀ hd.ne'] at hb |
| simpa only [inv_pow] using hb |
|
|
| theorem adaptive_graph {C : ℝ} (hin : SignInput A.projection C) {D t : ℝ} (k : ℕ) |
| (f : Vertex k → X) (hf : HasDistortion k f D t) : |
| (k:ℝ)/16 ≤ C*(D^2+(k:ℝ)*((2:ℝ)^k)⁻¹^2) ∧ |
| C*(D^2+(k:ℝ)*((2:ℝ)^k)⁻¹^2) ≤ C*(D^2+1) := by |
| have hn := (normalized_distortion f hf).2.2 |
| let g := fun v => t⁻¹ • f v |
| have hl : ∀ u v,(1:ℝ)*distance k u v ≤ ‖g u-g v‖ := fun u v => (hn u v).1 |
| have hu : ∀ u v,‖g u-g v‖ ≤ D*distance k u v := by simpa only [mul_one] using fun u v => (hn u v).2 |
| have hC : 0 ≤ C := sign_constant_nonneg A hA hin (slope g (baseEdge k)) |
| (lt_of_lt_of_le (by norm_num) (slope_lower g hl _)) |
| let η := min (((2:ℝ)^k)⁻¹) (1/8) |
| have hη : 0 < η := by dsimp [η]; positivity |
| have hη1 : η ≤ 1/8 := min_le_right _ _ |
| have hη2 : η ≤ ((2:ℝ)^k)⁻¹ := min_le_left _ _ |
| obtain ⟨T,e,hM,hN,hAn,hCommon,hE,hTail,hF,hLeak⟩ := hA.true_selection k g hl hu hη |
| (by norm_num : (3/4:ℝ)<1) (by norm_num : (0:ℝ)≤1/4) (by linarith : (1/4:ℝ)≤3/4-2*η) |
| have ht : T.terminalEnergy ≤ D^2 := T.terminalEnergy_bound (by linarith [hf.1]) |
| (fun u => by rw [hE]; exact slope_upper g hu _) |
| have hηsq : η^2 ≤ (((2:ℝ)^k)⁻¹)^2 := (sq_le_sq₀ hη.le (by positivity)).mpr hη2 |
| have hlk := hLeak.trans (mul_le_mul_of_nonneg_left hηsq (Nat.cast_nonneg k)) |
| have hi := (hin k T hM hN).trans (mul_le_mul_of_nonneg_left (add_le_add ht hlk) hC) |
| constructor |
| · norm_num at hF |
| nlinarith only [hF,hi] |
| · exact mul_le_mul_of_nonneg_left (add_le_add (le_refl (D^2)) (dyadic_budget k)) hC |
|
|
| def leakageTolerance (k : ℕ) : ℝ := min (1/8) (1/Real.sqrt (k:ℝ)) |
| omit hA in |
| lemma leakage_tolerance_properties {k : ℕ} (hk : 1 ≤ k) : |
| 0 < leakageTolerance k ∧ leakageTolerance k ≤ 1/8 ∧ (k:ℝ)*(leakageTolerance k)^2 ≤ 1 := by |
| have hk0 : 0 < (k:ℝ) := by exact_mod_cast (show 0 < k by omega) |
| have hs : 0 < Real.sqrt (k:ℝ) := Real.sqrt_pos.mpr hk0 |
| have hε : 0 < leakageTolerance k := by unfold leakageTolerance; positivity |
| refine ⟨hε,min_le_left _ _,?_⟩ |
| have hh : (leakageTolerance k)^2 ≤ (1/Real.sqrt (k:ℝ))^2 := |
| (sq_le_sq₀ hε.le (by positivity)).mpr (min_le_right _ _) |
| calc |
| _ ≤ (k:ℝ)*(1/Real.sqrt (k:ℝ))^2 := mul_le_mul_of_nonneg_left hh hk0.le |
| _ = 1 := by rw [div_pow,one_pow,Real.sq_sqrt hk0.le]; field_simp |
|
|
| theorem leakage_graph (hin : LeakageInput A.projection) {D t : ℝ} (k : ℕ) (hk : 1 ≤ k) |
| (f : Vertex k → X) (hf : HasDistortion k f D t) : |
| (k:ℝ)/8 ≤ 1024*(D^2+(k:ℝ)*(leakageTolerance k)^2) ∧ |
| 1024*(D^2+(k:ℝ)*(leakageTolerance k)^2) ≤ 1024*(D^2+1) := by |
| have hn := (normalized_distortion f hf).2.2 |
| let g := fun v => t⁻¹ • f v |
| have hl : ∀ u v,(1:ℝ)*distance k u v ≤ ‖g u-g v‖ := fun u v => (hn u v).1 |
| have hu : ∀ u v,‖g u-g v‖ ≤ D*distance k u v := by simpa only [mul_one] using fun u v => (hn u v).2 |
| obtain ⟨hη,hηb,hbudget⟩ := leakage_tolerance_properties hk |
| obtain ⟨T,e,hM,hN,hAn,hCommon,hE,hTail,hF,hLeak⟩ := hA.true_selection k g hl hu hη |
| (by norm_num : (3/4:ℝ)<1) (by norm_num : (0:ℝ)≤1/2) (by linarith : (1/2:ℝ)≤3/4-2*leakageTolerance k) |
| have ht : T.terminalEnergy ≤ D^2 := T.terminalEnergy_bound (by linarith [hf.1]) |
| (fun u => by rw [hE]; exact slope_upper g hu _) |
| have hi := hin k T hM hN hAn hCommon |
| constructor |
| · norm_num at hF |
| nlinarith [Nat.cast_nonneg (α := ℝ) k] |
| · linarith |
| end DirectLayers |
|
|
| end DiamondDistortion |
|
|
| end |
|
|
| end OAI |
|
|
