File size: 19,208 Bytes
e63eb7f | 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 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 | import OAI.Combinatorics.EditApproximation.Geometry.BandRounding
import OAI.Combinatorics.EditApproximation.Definitions
namespace OAI
/-!
# Actual rounded band actions pass the finite guards
Each child uses its own envelope-derived integer spacing. The action is
rounded with literal integer division; wide-grid, radius and imbalance
claims are proved for these returned states.
-/
namespace EditApproximation
open Finset
theorem bandChildEnvelope_pos {ny M : ℕ} (b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (i : Fin M) :
0 < bandChildEnvelope b band initial i := by
unfold bandChildEnvelope rationalDyadicCeiling
positivity
theorem roundedBandAction_endpoint_error {ny M : ℕ} (thetaExponent b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (action : Fin M → TargetInterval ny) (i : Fin M) :
(Nat.dist (action i).lo (roundedBandAction thetaExponent b band initial action i).lo : ℚ) ≤
(2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i ∧
(Nat.dist (action i).hi (roundedBandAction thetaExponent b band initial action i).hi : ℚ) ≤
(2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i := by
have hscaled : 0 ≤ (2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i :=
mul_nonneg (zpow_pos (by norm_num : (0 : ℚ) < 2) _).le (bandChildEnvelope_pos b band initial i).le
exact ⟨gridRound_scaled_error _ _ _ (bandRoundSpacing_exact thetaExponent b band initial i) hscaled,
gridRound_scaled_error _ _ _ (bandRoundSpacing_exact thetaExponent b band initial i) hscaled⟩
theorem roundedBandAction_distance {ny M : ℕ} (thetaExponent b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (action : Fin M → TargetInterval ny) (i : Fin M) :
(targetEndpointDistance (action i) (roundedBandAction thetaExponent b band initial action i) : ℚ) ≤
2 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i := by
have h := roundedBandAction_endpoint_error thetaExponent b band initial action i
unfold targetEndpointDistance
push_cast
convert add_le_add h.1 h.2 using 1
ring
/-- Actual rounded wide membership and imbalance guard. The sum premise
is supplied by bandChildEnvelope_sum_guard, and the remaining premises
are explicit computed-parameter inequalities. -/
theorem roundedBandAction_guards {α : Type*} (source target : List α)
{M b P : ℕ} (parent : TargetInterval source.length) (r : TargetInterval target.length)
(thetaExponent : ℕ) (tau velocity : ℚ)
(child initial : Fin M → TargetInterval target.length → ℚ)
(action : Fin M → TargetInterval target.length)
(haction : action ∈ computedBandActions parent r b P tau ((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child)
(hM : 0 < M) (hPpos : 0 < P)
(hbPower : ∃ e : ℕ, b = 2 ^ e) (hPPower : ∃ e : ℕ, P = 2 ^ e)
(hscale : (M : ℚ) ≤ (2 : ℚ) ^ (-(thetaExponent : ℤ)) * P)
(F : ℚ)
(hsmall : 64 * F * (2 : ℚ) ^ (-(thetaExponent : ℤ)) ≤ 4)
(htheta : (2 : ℚ) ^ (-(thetaExponent : ℤ)) ≤ 1 / 2)
(hinitialGap : ∀ i s, |rationalStateGap
(substring source (sourceChild parent i).lo (sourceChild parent i).hi) target s| ≤ initial i s)
(hsum : (∑ i : Fin M, bandChildEnvelope b
(computedBandActions parent r b P tau ((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child) initial i) ≤ 64 * F * b) :
let band := computedBandActions parent r b P tau ((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child
roundedBandAction thetaExponent b band initial action ∈ wideActionList M parent r b P ∧
∀ i, |rationalStateGap
(substring source (sourceChild parent i).lo (sourceChild parent i).hi) target
(roundedBandAction thetaExponent b band initial action i)| ≤ 2 * bandChildEnvelope b band initial i := by
let theta : ℚ := 2 ^ (-(thetaExponent : ℤ))
let band := computedBandActions parent r b P tau theta velocity child
let envelope := fun i : Fin M => bandChildEnvelope b band initial i
let rounded := roundedBandAction thetaExponent b band initial action
have htheta0 : 0 ≤ theta := (zpow_pos (by norm_num : (0 : ℚ) < 2) _).le
have henv (i : Fin M) : 0 ≤ envelope i := (bandChildEnvelope_pos b band initial i).le
have hsingle (i : Fin M) : envelope i ≤ ∑ j, envelope j :=
single_le_sum (fun j _ => henv j) (mem_univ i)
have hbudget (i : Fin M) : theta * envelope i ≤ 4 * b := by
have h := (mul_le_mul_of_nonneg_left (hsingle i) htheta0).trans
(mul_le_mul_of_nonneg_left hsum htheta0)
have hb := mul_le_mul_of_nonneg_right hsmall (show (0 : ℚ) ≤ b by positivity)
nlinarith only [h, hb]
obtain ⟨hnonempty, hwide, hv, hpredicate⟩ :=
computedBandActions_mem parent r b P tau theta velocity child action haction
have herr := roundedBandAction_endpoint_error thetaExponent b band initial action
have hanchor (anchor before after : ℕ) (i : Fin M)
(hbefore : Nat.dist anchor before ≤ 6 * b)
(herror : (Nat.dist before after : ℚ) ≤ theta * envelope i) :
Nat.dist anchor after ≤ 10 * b := by
have htriangle : (Nat.dist anchor after : ℚ) ≤ (Nat.dist anchor before : ℚ) + Nat.dist before after := by
exact_mod_cast Nat.dist.triangle_inequality anchor before after
have hbeforeQ : (Nat.dist anchor before : ℚ) ≤ 6 * b := by exact_mod_cast hbefore
have hafter : (Nat.dist anchor after : ℚ) ≤ 10 * b := by
linarith only [htriangle, hbeforeQ, herror, hbudget i]
exact_mod_cast hafter
constructor
· apply wideActionList_complete
· intro i
have hgrid := bandRoundSpacing_wide_grid thetaExponent band initial i hM hPpos hbPower hPPower hscale
exact ⟨hgrid.trans (dvd_mul_right _ _), hgrid.trans (dvd_mul_right _ _)⟩
· intro i
exact hanchor _ _ _ i (hpredicate.2.1 i).1 (herr i).1
· intro i
exact hanchor _ _ _ i (hpredicate.2.1 i).2 (herr i).2
· intro i
have hbefore := (hinitialGap i (action i)).trans
((bandChildEnvelope_lower b band initial i).2 action haction)
have hspatial := stateLengthGap_spatial
(substring source (sourceChild parent i).lo (sourceChild parent i).hi) target (rounded i) (action i)
rw [← rationalStateGap_cast, ← rationalStateGap_cast] at hspatial
have hspatialQ : |rationalStateGap
(substring source (sourceChild parent i).lo (sourceChild parent i).hi) target (rounded i)| ≤
|rationalStateGap (substring source (sourceChild parent i).lo (sourceChild parent i).hi) target (action i)| +
(targetEndpointDistance (rounded i) (action i) : ℚ) := by exact_mod_cast hspatial
have hdistance := roundedBandAction_distance thetaExponent b band initial action i
have hsym : targetEndpointDistance (rounded i) (action i) = targetEndpointDistance (action i) (rounded i) := by
unfold targetEndpointDistance
rw [Nat.dist_comm (rounded i).lo, Nat.dist_comm (rounded i).hi]
rw [hsym] at hspatialQ
have hscaled := mul_le_mul_of_nonneg_right htheta (henv i)
nlinarith only [hbefore, hspatialQ, hdistance, hscaled]
/-- Moving the two endpoints of each interval charges at most their total
movement, including the outside connections. -/
theorem connectionBudget_pair_perturbation {n : ℕ}
(pairs : List (TargetInterval n × TargetInterval n)) (beforeStart afterStart finish : ℕ) :
connectionBudget afterStart (pairs.map Prod.snd) finish ≤
connectionBudget beforeStart (pairs.map Prod.fst) finish + Nat.dist afterStart beforeStart +
(pairs.map fun pair => targetEndpointDistance pair.1 pair.2).sum := by
induction pairs generalizing beforeStart afterStart with
| nil =>
simp only [List.map_nil, List.sum_nil, connectionBudget, Nat.add_zero]
have h := Nat.dist.triangle_inequality afterStart beforeStart finish
omega
| cons pair rest ih =>
rcases pair with ⟨before, after⟩
have htail := ih before.hi after.hi
have hfirst := Nat.dist.triangle_inequality afterStart beforeStart before.lo
have hsecond := Nat.dist.triangle_inequality afterStart before.lo after.lo
rw [Nat.dist_comm after.hi before.hi] at htail
simp only [List.map_cons, List.sum_cons, connectionBudget, targetEndpointDistance] at htail ⊢
omega
theorem endpointActionConnection_perturbation {n M : ℕ} (r : TargetInterval n)
(before after : Fin M → TargetInterval n) :
endpointActionConnection r after ≤ endpointActionConnection r before +
∑ i, targetEndpointDistance (before i) (after i) := by
have h := connectionBudget_pair_perturbation
(List.ofFn fun i : Fin M => (before i, after i)) r.lo r.lo r.hi
simpa only [List.map_ofFn, List.sum_ofFn, Function.comp_def, Nat.dist_self, Nat.add_zero,
endpointActionConnection] using h
/-- The returned rounded action pays at most `2 θ ∑ hᵢ` in actual
connection cost when its unrounded band action has zero connection. -/
theorem roundedBandAction_connection {n M : ℕ} (r : TargetInterval n)
(thetaExponent b : ℕ) (band : List (Fin M → TargetInterval n))
(initial : Fin M → TargetInterval n → ℚ) (action : Fin M → TargetInterval n)
(hzero : endpointActionConnection r action = 0) :
(endpointActionConnection r (roundedBandAction thetaExponent b band initial action) : ℚ) ≤
2 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * ∑ i, bandChildEnvelope b band initial i := by
have hnatural := endpointActionConnection_perturbation r action
(roundedBandAction thetaExponent b band initial action)
rw [hzero, Nat.zero_add] at hnatural
have hcast : (endpointActionConnection r
(roundedBandAction thetaExponent b band initial action) : ℚ) ≤
∑ i, (targetEndpointDistance (action i)
(roundedBandAction thetaExponent b band initial action i) : ℚ) := by
exact_mod_cast hnatural
calc
_ ≤ ∑ i, (targetEndpointDistance (action i)
(roundedBandAction thetaExponent b band initial action i) : ℚ) := hcast
_ ≤ ∑ i, 2 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i :=
sum_le_sum fun i _ => roundedBandAction_distance thetaExponent b band initial action i
_ = _ := by rw [mul_sum]
theorem canonicalRoundedBandAction_connection {nx ny M : ℕ} (parent : TargetInterval nx)
(r : TargetInterval ny) (thetaExponent b P : ℕ) (tau velocity : ℚ)
(child initial : Fin M → TargetInterval ny → ℚ)
(hnonempty : computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child ≠ []) :
let band := computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child
(endpointActionConnection r
(canonicalRoundedBandAction thetaExponent b band hnonempty initial) : ℚ) ≤
2 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * ∑ i, bandChildEnvelope b band initial i := by
have hmem := List.head_mem hnonempty
obtain ⟨_, _, _, hpredicate⟩ := computedBandActions_mem parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child _ hmem
exact roundedBandAction_connection r thetaExponent b _ initial _ hpredicate.1
/-- The initial table's literal spatial bound controls the value of every
returned rounded state. -/
theorem roundedBandAction_initialValue {ny M : ℕ} (thetaExponent b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (action : Fin M → TargetInterval ny)
(L0 : ℚ) (hL0 : 0 ≤ L0)
(hspatial : ∀ i s t, initial i s ≤ initial i t + L0 * targetEndpointDistance s t)
(i : Fin M) :
initial i (roundedBandAction thetaExponent b band initial action i) ≤ initial i (action i) +
2 * L0 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i := by
have h := hspatial i (roundedBandAction thetaExponent b band initial action i) (action i)
have hsym : targetEndpointDistance (roundedBandAction thetaExponent b band initial action i) (action i) =
targetEndpointDistance (action i) (roundedBandAction thetaExponent b band initial action i) := by
unfold targetEndpointDistance
rw [Nat.dist_comm (roundedBandAction thetaExponent b band initial action i).lo,
Nat.dist_comm (roundedBandAction thetaExponent b band initial action i).hi]
rw [hsym] at h
have hmove := mul_le_mul_of_nonneg_left
(roundedBandAction_distance thetaExponent b band initial action i) hL0
nlinarith only [h, hmove]
theorem roundedBandAction_initialValue_le_twice {ny M : ℕ} (thetaExponent b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (action : Fin M → TargetInterval ny)
(haction : action ∈ band) (L0 : ℚ) (hL0 : 0 ≤ L0)
(hsmall : 2 * L0 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) ≤ 1)
(hspatial : ∀ i s t, initial i s ≤ initial i t + L0 * targetEndpointDistance s t)
(i : Fin M) :
initial i (roundedBandAction thetaExponent b band initial action i) ≤
2 * bandChildEnvelope b band initial i := by
have hbefore := (bandChildEnvelope_lower b band initial i).2 action haction
have hafter := roundedBandAction_initialValue thetaExponent b band initial action L0 hL0 hspatial i
have hmove := mul_le_mul_of_nonneg_right hsmall (bandChildEnvelope_pos b band initial i).le
nlinarith only [hbefore, hafter, hmove]
/-- The canonical rounded action is close to every member of its actual
computed band, with distance measured at both child endpoints. -/
theorem canonicalRoundedBandAction_distance {nx ny M : ℕ} (parent : TargetInterval nx)
(r : TargetInterval ny) (thetaExponent b P : ℕ) (tau velocity : ℚ) (htau : 0 < tau)
(child initial : Fin M → TargetInterval ny → ℚ)
(hnonempty : computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child ≠ [])
(action : Fin M → TargetInterval ny)
(haction : action ∈ computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child) (i : Fin M) :
let band := computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child
(targetEndpointDistance (action i)
(canonicalRoundedBandAction thetaExponent b band hnonempty initial i) : ℚ) ≤
6 * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * bandChildEnvelope b band initial i := by
let theta : ℚ := (2 : ℚ) ^ (-(thetaExponent : ℤ))
let band := computedBandActions parent r b P tau theta velocity child
let canonical := band.head hnonempty
let rounded := canonicalRoundedBandAction thetaExponent b band hnonempty initial
have htheta : 0 ≤ theta := (zpow_pos (by norm_num : (0 : ℚ) < 2) _).le
have hcanonical : canonical ∈ band := List.head_mem hnonempty
have hdiameter := computedBand_child_endpoint_diameter parent r b P tau theta velocity
htau htheta child action canonical haction hcanonical i
have hdiameterQ : (targetEndpointDistance (action i) (canonical i) : ℚ) ≤ 4 * theta * b / M := by
exact_mod_cast hdiameter
have hfloor := (bandChildEnvelope_lower b band initial i).1
have hscaled := mul_le_mul_of_nonneg_left hfloor (mul_nonneg (by norm_num : (0 : ℚ) ≤ 4) htheta)
have hdiameterEnvelope : (targetEndpointDistance (action i) (canonical i) : ℚ) ≤
4 * theta * bandChildEnvelope b band initial i := by
calc
_ ≤ 4 * theta * ((b : ℚ) / M) := by convert hdiameterQ using 1; ring
_ ≤ _ := hscaled
have hround := roundedBandAction_distance thetaExponent b band initial canonical i
change (targetEndpointDistance (canonical i) (rounded i) : ℚ) ≤
2 * theta * bandChildEnvelope b band initial i at hround
have htriangle : (targetEndpointDistance (action i) (rounded i) : ℚ) ≤
targetEndpointDistance (action i) (canonical i) + targetEndpointDistance (canonical i) (rounded i) := by
have hnatural : targetEndpointDistance (action i) (rounded i) ≤
targetEndpointDistance (action i) (canonical i) + targetEndpointDistance (canonical i) (rounded i) := by
unfold targetEndpointDistance
have hlo := Nat.dist.triangle_inequality (action i).lo (canonical i).lo (rounded i).lo
have hhi := Nat.dist.triangle_inequality (action i).hi (canonical i).hi (rounded i).hi
omega
exact_mod_cast hnatural
change (targetEndpointDistance (action i) (rounded i) : ℚ) ≤
6 * theta * bandChildEnvelope b band initial i
linarith only [htriangle, hdiameterEnvelope, hround]
/-- The actual canonical rounded action satisfies the rounded-action
cost inequality uniformly for every actual band member. -/
theorem canonicalRoundedBandAction_cost {nx ny M : ℕ} (parent : TargetInterval nx)
(r : TargetInterval ny) (thetaExponent b P : ℕ) (tau velocity : ℚ) (htau : 0 < tau)
(child initial value : Fin M → TargetInterval ny → ℚ)
(hnonempty : computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child ≠ [])
(action : Fin M → TargetInterval ny)
(haction : action ∈ computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child)
(delta L : ℚ) (hL : 0 ≤ L)
(hspatial : ∀ i s t, value i s ≤ (1 + delta) * value i t + L * targetEndpointDistance s t) :
let band := computedBandActions parent r b P tau
((2 : ℚ) ^ (-(thetaExponent : ℤ))) velocity child
rationalEndpointActionValue r (canonicalRoundedBandAction thetaExponent b band hnonempty initial) value ≤
(1 + delta) * (∑ i, value i (action i)) +
(6 * L + 2) * (2 : ℚ) ^ (-(thetaExponent : ℤ)) * ∑ i, bandChildEnvelope b band initial i := by
let theta : ℚ := (2 : ℚ) ^ (-(thetaExponent : ℤ))
let band := computedBandActions parent r b P tau theta velocity child
let rounded := canonicalRoundedBandAction thetaExponent b band hnonempty initial
have hchild (i : Fin M) : value i (rounded i) ≤ (1 + delta) * value i (action i) +
6 * L * theta * bandChildEnvelope b band initial i := by
have h := hspatial i (rounded i) (action i)
have hsym : targetEndpointDistance (rounded i) (action i) = targetEndpointDistance (action i) (rounded i) := by
unfold targetEndpointDistance
rw [Nat.dist_comm (rounded i).lo, Nat.dist_comm (rounded i).hi]
rw [hsym] at h
have hmove := mul_le_mul_of_nonneg_left
(canonicalRoundedBandAction_distance parent r thetaExponent b P tau velocity htau child initial
hnonempty action haction i) hL
nlinarith only [h, hmove]
have hsum := sum_le_sum fun i (_ : i ∈ (univ : Finset (Fin M))) => hchild i
rw [sum_add_distrib, ← mul_sum, ← mul_sum] at hsum
have hconnection := canonicalRoundedBandAction_connection parent r thetaExponent b P tau velocity child initial hnonempty
change (endpointActionConnection r rounded : ℚ) + ∑ i, value i (rounded i) ≤ _
nlinarith only [hsum, hconnection]
end EditApproximation
end OAI
|