File size: 6,225 Bytes
9b6e014 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | import Mathlib
import OAI.Probability.BinarySweep.Trajectories.Trajectory
namespace OAI
noncomputable section
open scoped BigOperators Classical
namespace BinaryCoordinateSweeps
lemma weighted_entry_bound (n : ℕ) {p C a : ℝ} (hp : 0 ≤ p)
(hbound : 0 < p → p ≤ Real.exp (C + a)) :
p * Real.exp (-C / (n+1 : ℝ)) ≤
Real.exp (a / (n+1 : ℝ)) * p ^ ((n : ℝ) / (n+1 : ℝ)) := by
rcases hp.eq_or_lt with hp | hp
· subst p
simp only [zero_mul]
positivity
have hn : (0 : ℝ) < n+1 := by positivity
have hl : Real.log p ≤ C + a := (Real.log_le_iff_le_exp hp).mpr (hbound hp)
have he : Real.log p + -C / (n+1 : ℝ) ≤
a / (n+1 : ℝ) + Real.log p * ((n : ℝ) / (n+1 : ℝ)) := by
apply (mul_le_mul_iff_left₀ hn).mp
field_simp
nlinarith [hl]
calc
_ = Real.exp (Real.log p + -C / (n+1 : ℝ)) := by
rw [Real.exp_add, Real.exp_log hp]
_ ≤ Real.exp (a / (n+1 : ℝ) + Real.log p * ((n : ℝ) / (n+1 : ℝ))) :=
Real.exp_le_exp.mpr he
_ = _ := by rw [Real.exp_add, Real.rpow_def_of_pos hp]
theorem weighted_cycle_le_card {A : Type*} [Fintype A] (n : ℕ)
(p C : Fin (n+1) → A → A → ℝ) (a : ℝ)
(hp : ∀ i x y, 0 ≤ p i x y)
(hsum : ∀ i y, ∑ x, p i x y = 1)
(hbound : ∀ i x y, 0 < p i x y → p i x y ≤ Real.exp (C i x y + a)) :
(∑ x : Fin (n+1) → A,
∏ i, p i (x i) (x (finRotate (n+1) i)) *
Real.exp (-C i (x i) (x (finRotate (n+1) i)) / (n+1 : ℝ))) ≤
Real.exp a * (Fintype.card A : ℝ) := by
have hconstant : (∏ _i : Fin (n+1), Real.exp (a / (n+1 : ℝ))) = Real.exp a := by
rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin, ← Real.exp_nat_mul]
congr 1
push_cast
field_simp
calc
_ ≤ ∑ x : Fin (n+1) → A,
∏ i, Real.exp (a / (n+1 : ℝ)) *
(p i (x i) (x (finRotate (n+1) i))) ^ ((n : ℝ) / (n+1 : ℝ)) := by
apply Finset.sum_le_sum
intro x _
apply Finset.prod_le_prod₀
· intro i _; exact mul_nonneg (hp _ _ _) (Real.exp_pos _).le
· intro i _; exact weighted_entry_bound n (hp _ _ _) (hbound _ _ _)
_ = Real.exp a * (∑ x : Fin (n+1) → A,
∏ i, (p i (x i) (x (finRotate (n+1) i))) ^ ((n : ℝ) / (n+1 : ℝ))) := by
simp_rw [Finset.prod_mul_distrib, hconstant]
rw [Finset.mul_sum]
_ ≤ _ := mul_le_mul_of_nonneg_left (Cyclic.sum_cycle_rpow_le_card n p hp hsum)
(Real.exp_pos a).le
def placementEdgeCost {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
(z : ℝ) (reverse : Bool) {k : ℕ} (x y : Placement H k 0) : ℝ :=
if reverse then placementTransitionCost H z y (placementIdentification H k x)
else placementTransitionCost H z x (placementIdentification H k y)
lemma placementEdge_bound {b h r : ℕ} {bits : Fin b → ℕ}
(H : PathFamily bits h) (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
(hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
(reverse : Bool) {k : ℕ} (x y : Placement H k 0)
(hp : 0 < placementEdge H z reverse x y) :
placementEdge H z reverse x y ≤
Real.exp (placementEdgeCost H z reverse x y +
(-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)) := by
have hsingle (x y : Placement H k 0) (hp : 0 < placementKernel H z x y) :
placementKernel H z x y ≤ Real.exp (
placementTransitionCost H z x (placementIdentification H k y) +
(-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)) := by
have hc := placement_probability_cost_of_pos H hd hz hzr x
(placementIdentification H k y) hp
have hs : (0 : ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
rw [Real.rpow_def_of_pos hs, ← Real.exp_add] at hc
convert hc using 1 <;> congr 1
ring
cases reverse with
| false => exact hsingle x y hp
| true => exact hsingle y x hp
lemma linePerturbationRadius_lt_one (r : ℕ) : linePerturbationRadius r < 1 := by
have hf : (1 : ℝ) ≤ ((2 ^ (2 * r)).factorial : ℝ) := by
exact_mod_cast Nat.factorial_pos (2 ^ (2 * r))
unfold linePerturbationRadius
apply (div_lt_one (by positivity)).mpr
linarith
theorem placement_weighted_cycle_bound {b h r : ℕ} {bits : Fin b → ℕ}
(H : PathFamily bits h) (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
(hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
(k n : ℕ) (reverse : Fin (n+1) → Bool) :
(∑ x : Fin (n+1) → Placement H k 0,
∏ i, placementEdge H z (reverse i) (x i) (x (finRotate (n+1) i)) *
Real.exp (-placementEdgeCost H z (reverse i) (x i) (x (finRotate (n+1) i)) /
(n+1 : ℝ))) ≤ Real.exp (-pathCost H + Real.log 4 * k * b) := by
have hz1 := hzr.trans_lt (linePerturbationRadius_lt_one r)
have hc := weighted_cycle_le_card (A := Placement H k 0) n
(fun i => placementEdge H z (reverse i))
(fun i => placementEdgeCost H z (reverse i))
(-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)
(by
intro i x y
unfold placementEdge
split_ifs <;> exact placementKernel_nonneg H hz hz1 _ _)
(by
intro i y
unfold placementEdge
cases reverse i with
| false => exact placementKernel_colSum H hz hz1 y
| true => exact placementKernel_rowSum H hz hz1 y)
(by intro i x y hp; exact placementEdge_bound H hd hz hzr (reverse i) x y hp)
rw [card_placement] at hc
apply hc.trans
have hcard : ((gridSize bits - h).descFactorial k : ℝ) ≤ (gridSize bits : ℝ) ^ k := by
exact_mod_cast (Nat.descFactorial_le_pow (gridSize bits - h) k).trans
(Nat.pow_le_pow_left (Nat.sub_le (gridSize bits) h) k)
have hs : (0 : ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
calc
_ ≤ Real.exp (-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b) *
(gridSize bits : ℝ) ^ k :=
mul_le_mul_of_nonneg_left hcard (Real.exp_pos _).le
_ = _ := by
have he : (gridSize bits : ℝ) ^ k =
Real.exp ((k : ℝ) * Real.log (gridSize bits)) := by
rw [Real.exp_nat_mul, Real.exp_log hs]
rw [he, ← Real.exp_add]
congr 1
ring
end BinaryCoordinateSweeps
end
end OAI
|