| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
| open scoped BigOperators Classical |
| open scoped BigOperators Classical |
| open scoped ENNReal NNReal |
| namespace HardSphere.Lattice |
|
|
| def binaryValue : (n : ℕ) → (Fin n → Bool) → ℕ |
| | 0, _ => 0 |
| | n + 1, b => (b 0).toNat + 2 * binaryValue n (fun i ↦ b i.succ) |
|
|
| lemma binaryValue_injective (n : ℕ) : Function.Injective (binaryValue n) := by |
| induction n with |
| | zero => intro b c _; exact Subsingleton.elim _ _ |
| | succ n ih => |
| intro b c h |
| have h0 : b 0 = c 0 := by |
| unfold binaryValue at h |
| cases hb : b 0 <;> cases hc : c 0 <;> simp_all <;> omega |
| have ht : (fun i : Fin n ↦ b i.succ) = (fun i : Fin n ↦ c i.succ) := by |
| apply ih |
| simp only [binaryValue, h0] at h |
| omega |
| funext i |
| refine Fin.cases h0 (fun j ↦ congrFun ht j) i |
|
|
| def signedValue (n : ℕ) (b : Fin n → Bool) : ℤ := |
| 2 * (binaryValue n b : ℤ) - ((2 : ℤ) ^ n - 1) |
|
|
| lemma signedValue_injective (n : ℕ) : Function.Injective (signedValue n) := by |
| intro b c h |
| apply binaryValue_injective n |
| have h' : (binaryValue n b : ℤ) = (binaryValue n c : ℤ) := by |
| unfold signedValue at h |
| omega |
| exact_mod_cast h' |
|
|
| lemma pmf_map_injective_atom_le {A B : Type*} (p : PMF A) (f : A → B) |
| (hf : Function.Injective f) (b : B) (a : ℝ≥0∞) (ha : ∀ x, p x ≤ a) : |
| p.map f b ≤ a := by |
| classical |
| rw [PMF.map_apply] |
| by_cases hb : ∃ x, b = f x |
| · obtain ⟨x, hx⟩ := hb |
| rw [tsum_eq_single x] |
| · simpa [hx] using ha x |
| · intro y hy |
| have hby : b ≠ f y := fun h ↦ hy (hf (hx.symm.trans h)).symm |
| simp [hby] |
| · have hz : ∀ x, b ≠ f x := by simpa using hb |
| simp only [ite_eq_right (hz _), tsum_zero] |
| exact zero_le |
|
|
| theorem signed_uniform_atom (n : ℕ) (z : ℤ) : |
| (PMF.uniformOfFintype (Fin n → Bool)).map (signedValue n) z ≤ |
| ((2 : ℝ≥0∞) ^ n)⁻¹ := by |
| apply pmf_map_injective_atom_le _ _ (signedValue_injective n) |
| intro b |
| simp [PMF.uniformOfFintype_apply] |
|
|
| lemma pmf_independent_shift_atom_le {A : Type*} (q : PMF A) (p : PMF ℤ) |
| (f : A → ℤ) (a : ℝ≥0∞) (ha : ∀ z, p z ≤ a) (z : ℤ) : |
| (q.bind fun x ↦ p.map (fun y ↦ y + f x)) z ≤ a := by |
| rw [PMF.bind_apply] |
| calc |
| (∑' x, q x * (p.map (fun y ↦ y + f x)) z) ≤ ∑' x, q x * a := by |
| apply ENNReal.tsum_le_tsum |
| intro x |
| exact mul_le_mul_right |
| (pmf_map_injective_atom_le p _ (fun _ _ h ↦ add_right_cancel h) z a ha) _ |
| _ = a := by rw [ENNReal.tsum_mul_right, q.tsum_coe, one_mul] |
|
|
| def spin (b : Bool) : ℤ := 2 * (b.toNat : ℤ) - 1 |
|
|
| @[simp] lemma abs_spin (b : Bool) : |spin b| = 1 := by cases b <;> norm_num [spin] |
|
|
| lemma binaryValue_snoc (n : ℕ) (b : Fin n → Bool) (c : Bool) : |
| binaryValue (n+1) (Fin.snoc b c) = binaryValue n b + 2^n * c.toNat := by |
| induction n with |
| | zero => |
| change (Fin.snoc (α := fun _ ↦ Bool) b c (Fin.last 0)).toNat + 2*0 = 0 + 1*c.toNat |
| rw [Fin.snoc_last] |
| omega |
| | succ n ih => |
| have ht : (fun i : Fin (n+1) ↦ Fin.snoc (α := fun _ ↦ Bool) b c i.succ) = |
| Fin.snoc (α := fun _ ↦ Bool) (fun i : Fin n ↦ b i.succ) c := by |
| funext i |
| refine Fin.lastCases ?_ (fun i ↦ ?_) i |
| · simp |
| · rw [Fin.snoc_castSucc] |
| exact Fin.snoc_castSucc (α := fun _ ↦ Bool) c b i.succ |
| change (Fin.snoc (α := fun _ ↦ Bool) b c 0).toNat + |
| 2 * binaryValue (n+1) (fun i ↦ Fin.snoc (α := fun _ ↦ Bool) b c i.succ) = |
| (b 0).toNat + 2 * binaryValue n (fun i ↦ b i.succ) + 2^(n+1)*c.toNat |
| rw [ht, ih, Fin.snoc_apply_zero, pow_succ] |
| ring |
|
|
| lemma signedValue_snoc (n : ℕ) (b : Fin n → Bool) (c : Bool) : |
| signedValue (n+1) (Fin.snoc b c) = signedValue n b + (2 : ℤ)^n * spin c := by |
| rw [signedValue, binaryValue_snoc] |
| simp only [Nat.cast_add, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, pow_succ] |
| unfold signedValue spin |
| ring |
|
|
| def OffSpine : ℕ → Type |
| | 0 => Unit |
| | n+1 => OffSpine n × (((Fin n → Bool) × OffSpine n) × ((Fin n → Bool) × OffSpine n)) |
|
|
| instance offSpineFintype : ∀ n, Fintype (OffSpine n) |
| | 0 => inferInstanceAs (Fintype Unit) |
| | n+1 => by |
| let : Fintype (OffSpine n) := offSpineFintype n |
| exact inferInstanceAs (Fintype (OffSpine n × |
| (((Fin n → Bool) × OffSpine n) × ((Fin n → Bool) × OffSpine n)))) |
|
|
| instance offSpineNonempty : ∀ n, Nonempty (OffSpine n) |
| | 0 => ⟨()⟩ |
| | n+1 => by |
| let : Nonempty (OffSpine n) := offSpineNonempty n |
| exact inferInstanceAs (Nonempty (OffSpine n × |
| (((Fin n → Bool) × OffSpine n) × ((Fin n → Bool) × OffSpine n)))) |
|
|
| abbrev TreeNoise (n : ℕ) := (Fin n → Bool) × OffSpine n |
|
|
| def leaves : (n : ℕ) → ℤ → TreeNoise n → List ℤ |
| | 0, s, _ => [s] |
| | n+1, s, w => |
| leaves n s (Fin.init w.1, w.2.1) ++ leaves n s w.2.2.1 ++ |
| leaves n (spin (w.1 (Fin.last n))) w.2.2.2 |
|
|
| @[simp] lemma length_leaves (n : ℕ) (s : ℤ) (w : TreeNoise n) : |
| (leaves n s w).length = 3^n := by |
| induction n generalizing s with |
| | zero => rfl |
| | succ n ih => simp only [leaves, List.length_append, ih, pow_succ]; omega |
|
|
| lemma abs_of_mem_leaves {n : ℕ} {s : ℤ} (hs : |s| = 1) (w : TreeNoise n) |
| {x : ℤ} (hx : x ∈ leaves n s w) : |x| = 1 := by |
| induction n generalizing s with |
| | zero => |
| simp only [leaves, List.mem_singleton] at hx |
| exact hx ▸ hs |
| | succ n ih => |
| simp only [leaves, List.mem_append] at hx |
| rcases hx with (hx | hx) | hx |
| · exact ih hs _ hx |
| · exact ih hs _ hx |
| · exact ih (abs_spin _) _ hx |
|
|
| def offSum : (n : ℕ) → OffSpine n → ℤ |
| | 0, _ => 0 |
| | n+1, w => offSum n w.1 + |
| (signedValue n w.2.1.1 + offSum n w.2.1.2) + |
| (signedValue n w.2.2.1 + offSum n w.2.2.2) |
|
|
| lemma sum_leaves (n : ℕ) (s : ℤ) (w : TreeNoise n) : |
| (leaves n s w).sum = (2 : ℤ)^n * s + signedValue n w.1 + offSum n w.2 := by |
| induction n generalizing s with |
| | zero => simp [leaves, signedValue, binaryValue, offSum] |
| | succ n ih => |
| simp only [leaves, List.sum_append, ih, offSum] |
| have hsnoc : Fin.snoc (Fin.init w.1) (w.1 (Fin.last n)) = w.1 := Fin.snoc_init_self _ |
| have hsv := signedValue_snoc n (Fin.init w.1) (w.1 (Fin.last n)) |
| rw [hsnoc] at hsv |
| rw [hsv, pow_succ] |
| ring |
|
|
| lemma uniform_product {A B : Type*} [Fintype A] [Fintype B] [Nonempty A] [Nonempty B] : |
| PMF.uniformOfFintype (A × B) = |
| (PMF.uniformOfFintype B).bind (fun b ↦ |
| (PMF.uniformOfFintype A).map (fun a ↦ (a,b))) := by |
| classical |
| ext ⟨a,b⟩ |
| simp [PMF.bind_apply, PMF.map_apply, PMF.uniformOfFintype_apply, |
| Fintype.card_prod, ENNReal.mul_inv, Prod.mk.injEq, ite_and, mul_comm] |
|
|
| theorem leaf_sum_atom (n : ℕ) (s x : ℤ) : |
| ((PMF.uniformOfFintype (TreeNoise n)).map (fun w ↦ (leaves n s w).sum)) x ≤ |
| ((2 : ℝ≥0∞)^n)⁻¹ := by |
| rw [uniform_product, PMF.map_bind] |
| simp_rw [PMF.map_comp, Function.comp_def, sum_leaves] |
| have h : (fun w : OffSpine n ↦ |
| (PMF.uniformOfFintype (Fin n → Bool)).map |
| (fun b ↦ (2:ℤ)^n * s + signedValue n b + offSum n w)) = |
| (fun w : OffSpine n ↦ |
| ((PMF.uniformOfFintype (Fin n → Bool)).map (signedValue n)).map |
| (fun y ↦ y + ((2:ℤ)^n * s + offSum n w))) := by |
| funext w |
| rw [PMF.map_comp] |
| congr 1 |
| funext b |
| dsimp |
| ring |
| rw [h] |
| exact pmf_independent_shift_atom_le _ _ _ _ (signed_uniform_atom n) x |
|
|
| def branchEquiv (n : ℕ) : TreeNoise (n+1) ≃ |
| Bool × (TreeNoise n × (TreeNoise n × TreeNoise n)) where |
| toFun w := (w.1 (Fin.last n), ((Fin.init w.1, w.2.1), w.2.2)) |
| invFun w := (Fin.snoc w.2.1.1 w.1, (w.2.1.2, w.2.2)) |
| left_inv w := by rcases w with ⟨b, c, d⟩; simp |
| right_inv w := by simp |
|
|
| abbrev BranchContext (n : ℕ) := Bool × (TreeNoise n × TreeNoise n) |
|
|
| def branchAt (n : ℕ) (d : Fin 3) : TreeNoise (n+1) ≃ TreeNoise n × BranchContext n := |
| (branchEquiv n).trans (match d with |
| | ⟨0, _⟩ => |
| { toFun := fun w ↦ (w.2.1, (w.1, w.2.2)) |
| invFun := fun w ↦ (w.2.1, (w.1, w.2.2)) |
| left_inv := fun _ ↦ rfl |
| right_inv := fun _ ↦ rfl } |
| | ⟨1, _⟩ => |
| { toFun := fun w ↦ (w.2.2.1, (w.1, (w.2.1, w.2.2.2))) |
| invFun := fun w ↦ (w.2.1, (w.2.2.1, (w.1, w.2.2.2))) |
| left_inv := fun _ ↦ rfl |
| right_inv := fun _ ↦ rfl } |
| | ⟨2, _⟩ => |
| { toFun := fun w ↦ (w.2.2.2, (w.1, (w.2.1, w.2.2.1))) |
| invFun := fun w ↦ (w.2.1, (w.2.2.1, (w.2.2.2, w.1))) |
| left_inv := fun _ ↦ rfl |
| right_inv := fun _ ↦ rfl }) |
|
|
| def branchRoot (d : Fin 3) (s : ℤ) (b : Bool) : ℤ := |
| if d = 2 then spin b else s |
|
|
| def branchBefore (n : ℕ) (d : Fin 3) (s : ℤ) (c : BranchContext n) : List ℤ := |
| match d with |
| | ⟨0, _⟩ => [] |
| | ⟨1, _⟩ => leaves n s c.2.1 |
| | ⟨2, _⟩ => leaves n s c.2.1 ++ leaves n s c.2.2 |
|
|
| def branchAfter (n : ℕ) (d : Fin 3) (s : ℤ) (c : BranchContext n) : List ℤ := |
| match d with |
| | ⟨0, _⟩ => leaves n s c.2.1 ++ leaves n (spin c.1) c.2.2 |
| | ⟨1, _⟩ => leaves n (spin c.1) c.2.2 |
| | ⟨2, _⟩ => [] |
|
|
| lemma leaves_branchAt (n : ℕ) (d : Fin 3) (s : ℤ) (w : TreeNoise n) |
| (c : BranchContext n) : |
| leaves (n+1) s ((branchAt n d).symm (w,c)) = |
| branchBefore n d s c ++ leaves n (branchRoot d s c.1) w ++ branchAfter n d s c := by |
| fin_cases d <;> simp [branchAt, branchEquiv, branchRoot, branchBefore, branchAfter, |
| leaves, List.append_assoc] |
|
|
| lemma length_branchBefore (n : ℕ) (d : Fin 3) (s : ℤ) (c : BranchContext n) : |
| (branchBefore n d s c).length = d.val * 3^n := by |
| fin_cases d <;> simp [branchBefore, two_mul] |
|
|
| def BlockContext (q : ℕ) : ℕ → Type |
| | 0 => Unit |
| | h+1 => BranchContext (q+h) × BlockContext q h |
|
|
| instance blockContextFintype (q : ℕ) : ∀ h, Fintype (BlockContext q h) |
| | 0 => inferInstanceAs (Fintype Unit) |
| | h+1 => by |
| let : Fintype (BlockContext q h) := blockContextFintype q h |
| exact inferInstanceAs (Fintype (BranchContext (q+h) × BlockContext q h)) |
|
|
| instance blockContextNonempty (q : ℕ) : ∀ h, Nonempty (BlockContext q h) |
| | 0 => ⟨()⟩ |
| | h+1 => by |
| let : Nonempty (BlockContext q h) := blockContextNonempty q h |
| exact inferInstanceAs (Nonempty (BranchContext (q+h) × BlockContext q h)) |
|
|
| private def rotateProd (A B C : Type*) : (A × B) × C ≃ A × (C × B) where |
| toFun w := (w.1.1, (w.2, w.1.2)) |
| invFun w := ((w.1,w.2.2),w.2.1) |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| def extractNoise (q : ℕ) : (h : ℕ) → (Fin h → Fin 3) → |
| TreeNoise (q+h) ≃ TreeNoise q × BlockContext q h |
| | 0, _ => |
| { toFun := fun w ↦ (w, ()) |
| invFun := Prod.fst |
| left_inv := fun _ ↦ rfl |
| right_inv := fun w ↦ by rcases w with ⟨w,⟨⟩⟩; rfl } |
| | h+1, a => (branchAt (q+h) (a 0)).trans |
| ((Equiv.prodCongr (extractNoise q h (fun i ↦ a i.succ)) (Equiv.refl _)).trans |
| (rotateProd _ _ _)) |
|
|
| def blockRoot (q : ℕ) : (h : ℕ) → (Fin h → Fin 3) → ℤ → BlockContext q h → ℤ |
| | 0, _, s, _ => s |
| | h+1, a, s, c => blockRoot q h (fun i ↦ a i.succ) (branchRoot (a 0) s c.1.1) c.2 |
|
|
| def blockBefore (q : ℕ) : (h : ℕ) → (Fin h → Fin 3) → ℤ → BlockContext q h → List ℤ |
| | 0, _, _, _ => [] |
| | h+1, a, s, c => branchBefore (q+h) (a 0) s c.1 ++ |
| blockBefore q h (fun i ↦ a i.succ) (branchRoot (a 0) s c.1.1) c.2 |
|
|
| def blockAfter (q : ℕ) : (h : ℕ) → (Fin h → Fin 3) → ℤ → BlockContext q h → List ℤ |
| | 0, _, _, _ => [] |
| | h+1, a, s, c => blockAfter q h (fun i ↦ a i.succ) (branchRoot (a 0) s c.1.1) c.2 ++ |
| branchAfter (q+h) (a 0) s c.1 |
|
|
| lemma leaves_extractNoise (q h : ℕ) (a : Fin h → Fin 3) (s : ℤ) (w : TreeNoise q) |
| (c : BlockContext q h) : |
| leaves (q+h) s ((extractNoise q h a).symm (w,c)) = |
| blockBefore q h a s c ++ leaves q (blockRoot q h a s c) w ++ blockAfter q h a s c := by |
| induction h generalizing s with |
| | zero => simp [extractNoise, blockBefore, blockRoot, blockAfter] |
| | succ h ih => |
| change leaves (q+h+1) s ((branchAt (q+h) (a 0)).symm |
| ((extractNoise q h (fun i ↦ a i.succ)).symm (w,c.2), c.1)) = _ |
| rw [leaves_branchAt, ih] |
| simp only [blockBefore, blockRoot, blockAfter, List.append_assoc] |
|
|
| def addressIndex : (h : ℕ) → (Fin h → Fin 3) → ℕ |
| | 0, _ => 0 |
| | h+1, a => (a 0).val * 3^h + addressIndex h (fun i ↦ a i.succ) |
|
|
| lemma length_blockBefore (q h : ℕ) (a : Fin h → Fin 3) (s : ℤ) (c : BlockContext q h) : |
| (blockBefore q h a s c).length = addressIndex h a * 3^q := by |
| induction h generalizing s with |
| | zero => simp [blockBefore, addressIndex] |
| | succ h ih => |
| simp only [blockBefore, List.length_append, length_branchBefore, ih, addressIndex, pow_add] |
| ring |
|
|
| lemma uniform_equiv {A B : Type*} [Fintype A] [Fintype B] [Nonempty A] [Nonempty B] |
| (e : A ≃ B) : PMF.uniformOfFintype A = (PMF.uniformOfFintype B).map e.symm := by |
| classical |
| ext a |
| rw [PMF.map_apply, tsum_eq_single (e a)] |
| · simp [PMF.uniformOfFintype_apply, Fintype.card_congr e] |
| · intro b hb |
| have h : a ≠ e.symm b := fun h ↦ hb ((congrArg e h).trans (e.apply_symm_apply b)).symm |
| simp [h] |
|
|
| lemma pair_map_apply {A B C : Type*} [DecidableEq B] (p : PMF A) (b : B) (f : A → C) (y : B) (z : C) : |
| (p.map (fun x ↦ (b, f x))) (y,z) = if y = b then (p.map f) z else 0 := by |
| classical |
| by_cases h : y = b |
| · simp [PMF.map_apply, Prod.mk.injEq, h] |
| · simp [PMF.map_apply, Prod.mk.injEq, h] |
|
|
| lemma conditional_atom {A B C : Type*} (p : PMF A) (q : B → PMF C) |
| (c : A → B) (f : A → C → ℤ) (a : ℝ≥0∞) |
| (ha : ∀ w z, ((q (c w)).map (f w)) z ≤ a) (H : B) (z : ℤ) : |
| (p.bind (fun w ↦ (q (c w)).map (fun x ↦ (c w, f w x)))) (H,z) ≤ |
| a * (p.map c) H := by |
| classical |
| rw [PMF.bind_apply, PMF.map_apply, ← ENNReal.tsum_mul_left] |
| apply ENNReal.tsum_le_tsum |
| intro w |
| rw [pair_map_apply] |
| split_ifs with h |
| · simpa [mul_comm] using mul_le_mul_right (ha w z) (p w) |
| · simp |
|
|
| lemma addressIndex_lt (h : ℕ) (a : Fin h → Fin 3) : addressIndex h a < 3^h := by |
| induction h with |
| | zero => simp [addressIndex] |
| | succ h ih => |
| have hd := (a 0).isLt |
| rw [addressIndex, pow_succ] |
| have := ih (fun i ↦ a i.succ) |
| nlinarith |
|
|
| lemma addressIndex_surjective (h : ℕ) (b : ℕ) (hb : b < 3^h) : |
| ∃ a : Fin h → Fin 3, addressIndex h a = b := by |
| induction h generalizing b with |
| | zero => |
| have : b = 0 := by simpa using hb |
| exact ⟨Fin.elim0, this.symm⟩ |
| | succ h ih => |
| have hp : 0 < 3^h := pow_pos (by omega) _ |
| have hd : b / 3^h < 3 := (Nat.div_lt_iff_lt_mul hp).mpr (by simpa [pow_succ, mul_comm] using hb) |
| obtain ⟨a, ha⟩ := ih (b % 3^h) (Nat.mod_lt _ hp) |
| refine ⟨Fin.cons ⟨b / 3^h, hd⟩ a, ?_⟩ |
| simp only [addressIndex, Fin.cons_zero, Fin.cons_succ, ha] |
| simpa [mul_comm] using Nat.div_add_mod b (3^h) |
|
|
| lemma take_sum_block (l b r : List ℤ) (v : ℕ) (hv : l.length + b.length ≤ v) : |
| ((l ++ b ++ r).take v).sum = b.sum + |
| (l.sum + (r.take (v - (l.length + b.length))).sum) := by |
| rw [List.take_append, List.take_of_length_le (by simpa using hv), List.sum_append, |
| List.sum_append, List.length_append] |
| ring |
|
|
| def walk (m : ℕ) (w : TreeNoise m) (j : ℕ) : ℤ := (leaves m 1 w |>.take j).sum |
|
|
| def incrementHistory (m u : ℕ) (w : TreeNoise m) : List ℤ := (leaves m 1 w).take u |
|
|
| theorem aligned_prediction (q h : ℕ) (b u v : ℕ) (hb : b < 3^h) |
| (hu : u ≤ b * 3^q) (hv : (b+1) * 3^q ≤ v) (H : List ℤ) (x : ℤ) : |
| ((PMF.uniformOfFintype (TreeNoise (q+h))).map |
| (fun w ↦ (incrementHistory (q+h) u w, walk (q+h) w v))) (H,x) ≤ |
| ((2 : ℝ≥0∞)^q)⁻¹ * |
| ((PMF.uniformOfFintype (TreeNoise (q+h))).map (incrementHistory (q+h) u)) H := by |
| classical |
| obtain ⟨a, ha⟩ := addressIndex_surjective h b hb |
| let pre (c : BlockContext q h) := blockBefore q h a 1 c |
| let post (c : BlockContext q h) := blockAfter q h a 1 c |
| let root (c : BlockContext q h) := blockRoot q h a 1 c |
| let hist (c : BlockContext q h) := (pre c).take u |
| let shift (c : BlockContext q h) := (pre c).sum + (post c |>.take (v - (b+1)*3^q)).sum |
| have hp (c : BlockContext q h) : (pre c).length = b * 3^q := by |
| simp [pre, length_blockBefore, ha] |
| have hhist (w : TreeNoise q) (c : BlockContext q h) : |
| incrementHistory (q+h) u ((extractNoise q h a).symm (w,c)) = hist c := by |
| simp only [incrementHistory, leaves_extractNoise, List.append_assoc] |
| exact List.take_append_of_le_length (by change u ≤ (pre c).length; rw [hp]; exact hu) |
| have hwalk (w : TreeNoise q) (c : BlockContext q h) : |
| walk (q+h) ((extractNoise q h a).symm (w,c)) v = (leaves q (root c) w).sum + shift c := by |
| rw [walk, leaves_extractNoise, take_sum_block] |
| · simp only [root, shift, pre, post, length_blockBefore, ha, length_leaves, add_mul, one_mul] |
| · change (pre c).length + (leaves q (root c) w).length ≤ v |
| rw [hp, length_leaves] |
| simpa [add_mul] using hv |
| rw [uniform_equiv (extractNoise q h a)] |
| simp only [PMF.map_comp] |
| rw [uniform_product] |
| simp only [PMF.map_bind, PMF.map_comp, Function.comp_def, hhist, hwalk] |
| have hr : (PMF.uniformOfFintype (BlockContext q h)).bind |
| (fun c ↦ (PMF.uniformOfFintype (TreeNoise q)).map (fun _ ↦ hist c)) = |
| (PMF.uniformOfFintype (BlockContext q h)).map hist := by |
| change (PMF.uniformOfFintype (BlockContext q h)).bind |
| (fun c ↦ (PMF.uniformOfFintype (TreeNoise q)).map (Function.const _ (hist c))) = _ |
| simp only [PMF.map_const] |
| rfl |
| rw [hr] |
|
|
| rw [PMF.bind_apply, PMF.map_apply, ← ENNReal.tsum_mul_left] |
| apply ENNReal.tsum_le_tsum |
| intro c |
| rw [pair_map_apply] |
| split_ifs with hc |
| · have hh : ((PMF.uniformOfFintype (TreeNoise q)).map |
| (fun w ↦ (leaves q (root c) w).sum + shift c)) x ≤ ((2:ℝ≥0∞)^q)⁻¹ := by |
| change ((PMF.uniformOfFintype (TreeNoise q)).map |
| ((fun y ↦ y + shift c) ∘ (fun w ↦ (leaves q (root c) w).sum))) x ≤ _ |
| rw [← PMF.map_comp] |
| exact pmf_map_injective_atom_le _ _ (fun _ _ e ↦ add_right_cancel e) _ _ |
| (leaf_sum_atom q (root c)) |
| simpa [mul_comm] using mul_le_mul_right hh ((PMF.uniformOfFintype (BlockContext q h)) c) |
| · simp |
|
|
| end HardSphere.Lattice |
| end |
|
|
| end OAI |
|
|
