File size: 4,653 Bytes
695bd70 | 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 | import OAI.Geometry.RuledCovering.OuterApproximation
import OAI.Geometry.RuledCovering.Lattice
namespace OAI
noncomputable section
open Set MeasureTheory Filter Metric
open scoped Topology ContDiff Pointwise
namespace RuledApproximation
/-- A quantitative derivative remainder in convex local coordinates. -/
theorem c1_local_remainder {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F]
{v : E → F} {U : Set E} (hU : IsOpen U) (hv : ContDiffOn ℝ 1 v U)
{p : E} (hp : p ∈ U) {delta : ℝ} (hd : 0 < delta) :
∃ r : ℝ, 0 < r ∧ ball p r ⊆ U ∧ ∀ x ∈ ball p r, ∀ y ∈ ball p r,
‖v x - v y - fderiv ℝ v p (x - y)‖ ≤ delta * ‖x - y‖ := by
have hdc : ContinuousAt (fderiv ℝ v) p :=
(hv.contDiffAt (hU.mem_nhds hp)).continuousAt_fderiv (by norm_num)
have hevent : ∀ᶠ x in 𝓝 p, ‖fderiv ℝ v x - fderiv ℝ v p‖ < delta := by
simpa only [dist_eq_norm] using hdc.eventually (ball_mem_nhds _ hd)
obtain ⟨r, hr, hrsub⟩ := Metric.mem_nhds_iff.mp (Filter.inter_mem hevent (hU.mem_nhds hp))
have hsub : ball p r ⊆ U := fun x hx => (hrsub hx).2
refine ⟨r, hr, hsub, ?_⟩
intro x hx y hy
apply (convex_ball p r).norm_image_sub_le_of_norm_hasFDerivWithin_le' (φ := fderiv ℝ v p)
(fun z hz => ((hv.contDiffAt (hU.mem_nhds (hsub hz))).differentiableAt
(by norm_num)).hasFDerivAt.hasFDerivWithinAt)
(fun z hz => (hrsub hz).1.le) hy hx
/-- Extending a nonnegative continuous weight from a compact patch does not alter it there. -/
theorem continuous_nonneg_extension {E : Type*} [TopologicalSpace E] [NormalSpace E]
{K : Set E} (hK : IsClosed K) {f : E → ℝ} (hf : ContinuousOn f K)
(hn : ∀ x ∈ K, 0 ≤ f x) :
∃ F : E → ℝ, Continuous F ∧ (∀ x, 0 ≤ F x) ∧ Set.EqOn F f K := by
let fc : C(K, ℝ) := ⟨_, continuousOn_iff_continuous_domRestrict.mp hf⟩
obtain ⟨g, hg⟩ := ContinuousMap.exists_restrict_eq hK fc
refine ⟨fun x => max (g x) 0, g.continuous.max continuous_const, fun x => le_max_right _ _, ?_⟩
intro x hx
have hgx : g x = f x := congrArg (fun q : C(K, ℝ) => q ⟨x, hx⟩) hg
dsimp only
rw [hgx, max_eq_left (hn x hx)]
abbrev Parameter := Fin 2 → ℝ
/-- Exact affine lattice template. The uniform bound retains finitely many centers. -/
def LatticeModel (A : Parameter →L[ℝ] Parameter) (L R : ℝ) : Prop :=
∀ n : ℕ, 0 < n → ∀ p : Parameter, ∀ r : ℝ, |r| ≤ L →
∃ b ∈ coordinateGrid n, dist b p ≤ R / n ∧
‖p - b + r • A (p - b)‖ ≤ 1 / (2 * n)
/-- The nonlinear local producer. Unlike tilting a continuum of lines, it produces a
finite set of intercept centers covering every label and every time simultaneously. -/
theorem local_finite_certificate {K U : Set Parameter} (hK : IsCompact K)
(hU : IsOpen U) (hKU : K ⊆ U) (v : Parameter → Parameter)
(A : Parameter →L[ℝ] Parameter) {L R delta : ℝ}
(hL : 0 ≤ L) (hdelta : 0 ≤ delta) (hmodel : LatticeModel A L R)
(hrem : ∀ p ∈ U, ∀ b ∈ U,
‖v p - v b - A (p - b)‖ ≤ delta * ‖p - b‖)
{F : Parameter → ℝ} (hF : Continuous F) (hFpos : ∀ p, 0 ≤ F p)
{eps : ℝ} (heps : 0 < eps) :
∃ n : ℕ, 0 < n ∧ ∃ S : Set Parameter, S.Finite ∧ S ⊆ U ∧
(∀ p ∈ K, ∀ r : ℝ, |r| ≤ L → ∃ b ∈ S,
‖p + r • v p - (b + r • v b)‖ ≤ (1 / 2 + L * delta * R) / n) ∧
(∑' b : S, F b) / (n : ℝ) ^ 2 < (∫ p in K, F p) + eps := by
obtain ⟨n, hn, S, hSfinite, hSU, hretain, hcost⟩ :=
(finite_weighted_grid_outer hK hU hKU hF hFpos R heps).exists
refine ⟨n, hn, S, hSfinite, fun b hb => (hSU hb).1, ?_, hcost⟩
intro p hp r hr
obtain ⟨b, hbgrid, hbp, hlin⟩ := hmodel n hn p r hr
have hbS := hretain b hbgrid ⟨p, hp, hbp⟩
have hbp' : ‖p - b‖ ≤ R / n := by simpa [dist_eq_norm, norm_sub_rev] using hbp
have herr := hrem p (hKU hp) b (hSU hbS).1
refine ⟨b, hbS, ?_⟩
calc
‖p + r • v p - (b + r • v b)‖ =
‖(p - b + r • A (p - b)) + r • (v p - v b - A (p - b))‖ := by
congr 1
module
_ ≤ ‖p - b + r • A (p - b)‖ + ‖r • (v p - v b - A (p - b))‖ := norm_add_le _ _
_ ≤ 1 / (2 * n) + L * (delta * (R / n)) := by
apply add_le_add hlin
rw [norm_smul, Real.norm_eq_abs]
exact (mul_le_mul_of_nonneg_right hr (norm_nonneg _)).trans
(mul_le_mul_of_nonneg_left (herr.trans (mul_le_mul_of_nonneg_left hbp' hdelta)) hL)
_ = (1 / 2 + L * delta * R) / n := by ring
end RuledApproximation
end
end OAI
|