| import Mathlib |
| import OAI.Geometry.CAT0Fillings.Currents.FiniteAtoms |
|
|
| namespace OAI |
|
|
| section |
|
|
| open Set Filter MeasureTheory Metric |
| open scoped Topology NNReal |
|
|
| namespace CAT0Fillings.SliceReconstruction |
| attribute [local instance] Classical.propDecidable |
| variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma zeroChart_exists_supported_atom [Nonempty X] (C : IntegerChart X 0) : |
| ∃ a : ℤ, ∃ x : X, (a ≠ 0 → x ∈ C.image) ∧ C.action = atomCurrent a x := by |
| by_cases h : (0 : Euc 0) ∈ C.domain |
| · exact ⟨C.multiplicity 0, C.param ⟨0, h⟩, |
| fun _ => ⟨⟨0, h⟩, rfl⟩, C.zero_action h⟩ |
| · refine ⟨0, Classical.arbitrary X, fun ha => (ha rfl).elim, ?_⟩ |
| rw [C.zero_action_eq_zero h] |
| funext b π |
| simp only [atomCurrent, Int.cast_zero, zero_mul, ite_self, Pi.zero_apply] |
|
|
| theorem integerRectifiable_zero_distinct_representation [CompactSpace X] [Nonempty X] |
| {T : Functional X 0} (hT : IsMetricCurrent T) (hI : IntegerRectifiable T) : |
| ∃ (m : ℕ) (a : Fin m → ℤ) (x : Fin m → X), |
| (∀ i, a i ≠ 0) ∧ Function.Injective x ∧ |
| ∀ b π, T b π = ∑ i, atomCurrent (a i) (x i) b π := by |
| classical |
| obtain ⟨C, hd, hC, hCS, heq⟩ := hI |
| choose a x hsupp hact using fun i => zeroChart_exists_supported_atom (C i) |
| have hmass i : mass (C i).action = |(a i : ℝ)| := by |
| rw [hact i, mass_atomCurrent] |
| have haS : Summable (fun i => |(a i : ℝ)|) := by simpa only [hmass] using hCS |
| have hfinite := finite_support_int_of_summable_abs a haS |
| let s := hfinite.toFinset |
| have hs : ∀ i, i ∈ s ↔ a i ≠ 0 := fun i => hfinite.mem_toFinset |
| let e := s.equivFin.symm |
| have hezero : ∀ i, a (e i) ≠ 0 := fun i => (hs _).mp (e i).property |
| refine ⟨s.card, fun i => a (e i), fun i => x (e i), hezero, ?_, ?_⟩ |
| · intro i j hij |
| apply e.injective |
| apply Subtype.ext |
| by_contra hne |
| have hi : x (e i) ∈ (C (e i)).image := hsupp _ (hezero i) |
| have hj : x (e i) ∈ (C (e j)).image := by |
| simpa only [hij] using hsupp _ (hezero j) |
| exact Set.disjoint_left.mp (hd hne) hi hj |
| · intro b π |
| by_cases hadm : Admissible b π |
| · rw [heq] |
| simp_rw [hact] |
| rw [tsum_eq_sum (s := s) (fun i hi => by |
| have hai : a i = 0 := not_not.mp (fun hn => hi ((hs i).mpr hn)) |
| simp only [atomCurrent, hai, Int.cast_zero, zero_mul, ite_self])] |
| rw [← Finset.sum_attach] |
| exact (e.sum_comp (fun i : s => atomCurrent (a i) (x i) b π)).symm |
| · simp only [hT.offDomain b π hadm, atomCurrent, ite_eq_right hadm, Finset.sum_const_zero] |
|
|
| def atomicTent (p : X) (r : ℝ) (z : X) : ℝ := |
| min (dist z p) (max 0 (r - dist z p)) |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma atomicTent_lipschitz (p : X) (r : ℝ) : LipschitzWith 1 (atomicTent p r) := by |
| have hdist : LipschitzWith 1 (fun z : X => dist z p) := LipschitzWith.dist_left p |
| have hsub : LipschitzWith 1 (fun z : X => r - dist z p) := by |
| simpa using (LipschitzWith.const r).sub hdist |
| have hother : LipschitzWith 1 (fun z : X => max 0 (r - dist z p)) := |
| hsub.const_max 0 |
| change LipschitzWith 1 (fun z : X => min (dist z p) (max 0 (r - dist z p))) |
| simpa only [max_self] using hdist.min hother |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma atomicTent_unit_bound (p : X) {r : ℝ} (hr : r ≤ 1) (z : X) : |
| |atomicTent p r z| ≤ 1 := by |
| have h0 : 0 ≤ atomicTent p r z := le_min dist_nonneg (le_max_left _ _) |
| rw [abs_of_nonneg h0] |
| exact (min_le_right _ _).trans (max_le (by norm_num) |
| ((sub_le_self _ dist_nonneg).trans hr)) |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| @[simp] lemma atomicTent_center (p : X) (r : ℝ) : atomicTent p r p = 0 := by |
| simp [atomicTent] |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma atomicTent_near {p z : X} {r : ℝ} (h : 2 * dist z p ≤ r) : |
| atomicTent p r z = dist z p := by |
| exact min_eq_left ((by linarith : dist z p ≤ r - dist z p).trans (le_max_right _ _)) |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma atomicTent_far {p z : X} {r : ℝ} (h : r ≤ dist z p) : |
| atomicTent p r z = 0 := by |
| simp only [atomicTent, max_eq_left (sub_nonpos.mpr h), min_eq_right dist_nonneg] |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma matched_atom_distance_le {m : ℕ} {S U : Functional X 0} |
| (a a' : Fin m → ℤ) (x y : Fin m → X) |
| (hS : ∀ b π, S b π = ∑ j, atomCurrent (a j) (x j) b π) |
| (hU : ∀ b π, U b π = ∑ j, atomCurrent (a' j) (y j) b π) |
| (i : Fin m) (hai : a' i ≠ 0) {r D : ℝ} (hr : r ≤ 1) |
| (hnear : 2 * dist (y i) (x i) ≤ r) |
| (hx : ∀ j, j ≠ i → r ≤ dist (x j) (x i)) |
| (hy : ∀ j, j ≠ i → r ≤ dist (y j) (x i)) |
| (hD : ∀ b : X → ℝ, LipschitzWith 1 b → (∀ z, |b z| ≤ 1) → |
| |S b (fun j => Fin.elim0 j) - U b (fun j => Fin.elim0 j)| ≤ D) : |
| dist (x i) (y i) ≤ D := by |
| classical |
| let b := atomicTent (x i) r |
| have hbl : BoundedLip b := |
| ⟨⟨1, atomicTent_lipschitz _ _⟩, 1, atomicTent_unit_bound _ hr⟩ |
| have hbx j : b (x j) = 0 := by |
| by_cases hji : j = i |
| · subst j; exact atomicTent_center _ _ |
| · exact atomicTent_far (hx j hji) |
| have hby (j : Fin m) (hji : j ≠ i) : b (y j) = 0 := atomicTent_far (hy j hji) |
| have hsi : S b (fun j => Fin.elim0 j) = 0 := by |
| rw [hS] |
| apply Finset.sum_eq_zero |
| intro j _ |
| rw [atomCurrent_apply _ _ hbl, hbx, mul_zero] |
| have hui : U b (fun j => Fin.elim0 j) = (a' i : ℝ) * dist (y i) (x i) := by |
| rw [hU, Finset.sum_eq_single i] |
| · rw [atomCurrent_apply _ _ hbl] |
| change _ * atomicTent (x i) r (y i) = _ |
| rw [atomicTent_near hnear] |
| · intro j _ hji |
| rw [atomCurrent_apply _ _ hbl, hby j hji, mul_zero] |
| · simp |
| have hbound := hD b (atomicTent_lipschitz _ _) (atomicTent_unit_bound _ hr) |
| rw [hsi, hui, zero_sub, abs_neg, abs_mul, abs_of_nonneg dist_nonneg] at hbound |
| have ha1 : (1 : ℝ) ≤ |(a' i : ℝ)| := by exact_mod_cast Int.one_le_abs hai |
| calc |
| dist (x i) (y i) = 1 * dist (y i) (x i) := by simp [dist_comm] |
| _ ≤ |(a' i : ℝ)| * dist (y i) (x i) := mul_le_mul_of_nonneg_right ha1 dist_nonneg |
| _ ≤ D := hbound |
|
|
| end CAT0Fillings.SliceReconstruction |
| end |
|
|
| section |
|
|
| open Set Filter MeasureTheory Metric TopologicalSpace |
| open scoped Topology NNReal |
|
|
| namespace CAT0Fillings.SliceReconstruction |
| attribute [local instance] Classical.propDecidable |
| variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] |
|
|
| def UnitRepresentation {m : ℕ} (S : Functional X 0) (a : Fin m → ℤ) (x : Fin m → X) : Prop := |
| ∀ b : X → ℝ, LipschitzWith 1 b → (∀ z, |b z| ≤ 1) → |
| S b (fun j => Fin.elim0 j) = ∑ j, (a j : ℝ) * b (x j) |
|
|
| abbrev AtomCode := Σ m : ℕ, (Fin m → ℤ) × (Fin m → ℕ) × ℚ |
| namespace AtomCode |
| abbrev size (c : AtomCode) := c.1 |
| abbrev weights (c : AtomCode) : Fin c.size → ℤ := c.2.1 |
| abbrev centers (c : AtomCode) : Fin c.size → ℕ := c.2.2.1 |
| abbrev radius (c : AtomCode) : ℝ := (c.2.2.2 : ℝ) |
|
|
| def Valid [SeparableSpace X] [Nonempty X] (c : AtomCode) : Prop := |
| 0 < c.radius ∧ 4 * c.radius ≤ 1 ∧ (∀ i, c.weights i ≠ 0) ∧ |
| ∀ i j, i ≠ j → 8 * c.radius ≤ |
| dist (TopologicalSpace.denseSeq X (c.centers i)) (TopologicalSpace.denseSeq X (c.centers j)) |
| end AtomCode |
|
|
| lemma atomCode_countable : Countable AtomCode := inferInstance |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma exists_separated_center_code [SeparableSpace X] [Nonempty X] |
| {m : ℕ} (x : Fin m → X) (hx : Function.Injective x) : |
| ∃ (r : ℚ) (c : Fin m → ℕ), 0 < (r : ℝ) ∧ 4 * (r : ℝ) ≤ 1 ∧ |
| (∀ i, dist (x i) (TopologicalSpace.denseSeq X (c i)) ≤ (r : ℝ)) ∧ |
| ∀ i j, i ≠ j → 8 * (r : ℝ) ≤ |
| dist (TopologicalSpace.denseSeq X (c i)) (TopologicalSpace.denseSeq X (c j)) := by |
| have he : ∀ᶠ r : ℝ in 𝓝 0, r < 1 / 4 ∧ |
| ∀ i j : Fin m, i ≠ j → 10 * r < dist (x i) (x j) := by |
| refine (eventually_lt_nhds (by norm_num : (0 : ℝ) < 1 / 4)).and ?_ |
| simp only [Filter.eventually_all] |
| intro i j hij |
| have hd : 0 < dist (x i) (x j) := dist_pos.mpr (fun h => hij (hx h)) |
| filter_upwards [eventually_lt_nhds (by positivity : (0 : ℝ) < dist (x i) (x j) / 10)] with r hr |
| linarith |
| obtain ⟨δ, hδ, hball⟩ := Metric.mem_nhds_iff.mp he |
| obtain ⟨r, hr0, hrδ⟩ := exists_pos_rat_lt hδ |
| have hr0' : (0 : ℝ) < r := by exact_mod_cast hr0 |
| have hr := hball (show (r : ℝ) ∈ ball (0 : ℝ) δ by |
| simpa only [mem_ball, Real.dist_eq, sub_zero, abs_of_pos hr0'] using hrδ) |
| choose c hc using fun i : Fin m => |
| (TopologicalSpace.denseRange_denseSeq X).exists_dist_lt (x i) hr0' |
| refine ⟨r, c, hr0', by linarith [hr.1], fun i => (hc i).le, ?_⟩ |
| intro i j hij |
| have hd := hr.2 i j hij |
| have htri : dist (x i) (x j) ≤ |
| dist (x i) (TopologicalSpace.denseSeq X (c i)) + |
| dist (TopologicalSpace.denseSeq X (c i)) (TopologicalSpace.denseSeq X (c j)) + |
| dist (x j) (TopologicalSpace.denseSeq X (c j)) := by |
| calc |
| _ ≤ dist (x i) (TopologicalSpace.denseSeq X (c i)) + |
| dist (TopologicalSpace.denseSeq X (c i)) (x j) := dist_triangle _ _ _ |
| _ ≤ _ := by |
| have := dist_triangle (TopologicalSpace.denseSeq X (c i)) |
| (TopologicalSpace.denseSeq X (c j)) (x j) |
| rw [dist_comm (TopologicalSpace.denseSeq X (c j)) (x j)] at this |
| linarith |
| linarith [hc i, hc j] |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma unitRepresentation_matched_distance [SeparableSpace X] [Nonempty X] |
| {S U : Functional X 0} (c : AtomCode) (hc : c.Valid (X := X)) |
| (x y : Fin c.size → X) |
| (hx : ∀ i, dist (x i) (TopologicalSpace.denseSeq X (c.centers i)) ≤ c.radius) |
| (hy : ∀ i, dist (y i) (TopologicalSpace.denseSeq X (c.centers i)) ≤ c.radius) |
| (hS : UnitRepresentation S c.weights x) (hU : UnitRepresentation U c.weights y) |
| {D : ℝ} |
| (hD : ∀ b : X → ℝ, LipschitzWith 1 b → (∀ z, |b z| ≤ 1) → |
| |S b (fun j => Fin.elim0 j) - U b (fun j => Fin.elim0 j)| ≤ D) |
| (i : Fin c.size) : dist (x i) (y i) ≤ D := by |
| classical |
| let p j := TopologicalSpace.denseSeq X (c.centers j) |
| have hnear : 2 * dist (y i) (x i) ≤ 4 * c.radius := by |
| have ht := dist_triangle_right (y i) (x i) (p i) |
| linarith [hx i, hy i] |
| have hfar (z : Fin c.size → X) (hz : ∀ j, dist (z j) (p j) ≤ c.radius) |
| (j : Fin c.size) (hji : j ≠ i) : 4 * c.radius ≤ dist (z j) (x i) := by |
| have ht : dist (p j) (p i) ≤ dist (z j) (p j) + dist (z j) (x i) + dist (x i) (p i) := by |
| calc |
| _ ≤ dist (p j) (z j) + dist (z j) (p i) := dist_triangle _ _ _ |
| _ ≤ _ := by |
| have := dist_triangle (z j) (x i) (p i) |
| rw [dist_comm (p j) (z j)] |
| linarith |
| linarith [hc.2.2.2 j i hji, hz j, hx i, hc.1] |
| let b := atomicTent (x i) (4 * c.radius) |
| have hbx j : b (x j) = 0 := by |
| by_cases hji : j = i |
| · subst j; exact atomicTent_center _ _ |
| · exact atomicTent_far (hfar x hx j hji) |
| have hsi : S b (fun j => Fin.elim0 j) = 0 := by |
| rw [hS b (atomicTent_lipschitz _ _) (atomicTent_unit_bound _ hc.2.1)] |
| apply Finset.sum_eq_zero |
| intro j _ |
| rw [hbx, mul_zero] |
| have hui : U b (fun j => Fin.elim0 j) = (c.weights i : ℝ) * dist (y i) (x i) := by |
| rw [hU b (atomicTent_lipschitz _ _) (atomicTent_unit_bound _ hc.2.1), Finset.sum_eq_single i] |
| · change _ * atomicTent _ _ _ = _ |
| rw [atomicTent_near hnear] |
| · intro j _ hji |
| change _ * atomicTent _ _ _ = _ |
| rw [atomicTent_far (hfar y hy j hji), mul_zero] |
| · simp |
| have hbound := hD b (atomicTent_lipschitz _ _) (atomicTent_unit_bound _ hc.2.1) |
| rw [hsi, hui, zero_sub, abs_neg, abs_mul, abs_of_nonneg dist_nonneg] at hbound |
| have ha1 : (1 : ℝ) ≤ |(c.weights i : ℝ)| := by exact_mod_cast Int.one_le_abs (hc.2.2.1 i) |
| calc |
| dist (x i) (y i) = 1 * dist (y i) (x i) := by simp [dist_comm] |
| _ ≤ |(c.weights i : ℝ)| * dist (y i) (x i) := mul_le_mul_of_nonneg_right ha1 dist_nonneg |
| _ ≤ D := hbound |
|
|
| variable {P : Type*} [MetricSpace P] |
|
|
| def atomDomain [SeparableSpace X] [Nonempty X] |
| (S : P → Functional X 0) (E : Set P) (c : AtomCode) : Set P := |
| {t | t ∈ E ∧ c.Valid (X := X) ∧ ∃ x : Fin c.size → X, |
| (∀ i, dist (x i) (TopologicalSpace.denseSeq X (c.centers i)) ≤ c.radius) ∧ |
| UnitRepresentation (S t) c.weights x} |
|
|
| omit [MeasurableSpace X] [BorelSpace X] [MetricSpace P] in |
| lemma atomDomain_subset [SeparableSpace X] [Nonempty X] |
| (S : P → Functional X 0) (E : Set P) (c : AtomCode) : atomDomain S E c ⊆ E := |
| fun _ h => h.1 |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma isCompact_atomDomain [CompactSpace X] [Nonempty X] |
| (S : P → Functional X 0) {E : Set P} (hE : IsCompact E) (c : AtomCode) |
| (hS : ∀ b : X → ℝ, LipschitzWith 1 b → (∀ z, |b z| ≤ 1) → |
| ContinuousOn (fun t => S t b (fun j => Fin.elim0 j)) E) : |
| IsCompact (atomDomain S E c) := by |
| apply hE.of_isClosed_subset _ (atomDomain_subset S E c) |
| apply IsSeqClosed.isClosed |
| intro z t hz hzt |
| have htE : t ∈ E := hE.isClosed.mem_of_tendsto hzt (Eventually.of_forall fun j => (hz j).1) |
| choose x hx hrepr using fun j => (hz j).2.2 |
| obtain ⟨y, φ, hφ, hy⟩ := CompactSpace.tendsto_subseq x |
| have hyi i : Tendsto (fun j => x (φ j) i) atTop (𝓝 (y i)) := |
| (continuous_apply i).tendsto _ |>.comp hy |
| refine ⟨htE, (hz 0).2.1, y, ?_, ?_⟩ |
| · intro i |
| exact le_of_tendsto ((hyi i).dist tendsto_const_nhds) |
| (Eventually.of_forall fun j => hx (φ j) i) |
| · intro b hb hb1 |
| have hztE : Tendsto z atTop (𝓝[E] t) := tendsto_nhdsWithin_iff.mpr |
| ⟨hzt, Eventually.of_forall fun j => (hz j).1⟩ |
| have hL := ((hS b hb hb1 t htE).tendsto.comp hztE).comp hφ.tendsto_atTop |
| have hR : Tendsto (fun j => ∑ i, (c.weights i : ℝ) * b (x (φ j) i)) atTop |
| (𝓝 (∑ i, (c.weights i : ℝ) * b (y i))) := by |
| apply tendsto_finsetSum |
| intro i _ |
| exact tendsto_const_nhds.mul ((hb.continuous.tendsto _).comp (hyi i)) |
| have hL' : Tendsto (fun j => ∑ i, (c.weights i : ℝ) * b (x (φ j) i)) atTop |
| (𝓝 (S t b (fun j => Fin.elim0 j))) := by |
| convert hL using 1 |
| funext j |
| exact (hrepr (φ j) b hb hb1).symm |
| exact tendsto_nhds_unique hL' hR |
|
|
| omit [MetricSpace P] in |
| lemma integral_mem_atomDomain [CompactSpace X] [Nonempty X] |
| (S : P → Functional X 0) {E : Set P} {t : P} (ht : t ∈ E) |
| (hI : IsIntegral 0 (S t)) : ∃ c : AtomCode, t ∈ atomDomain S E c := by |
| classical |
| obtain ⟨m, a, x, ha, hinj, hrepr⟩ := integerRectifiable_zero_distinct_representation hI.1 hI.2 |
| obtain ⟨r, centers, hr0, hr1, hx, hsep⟩ := exists_separated_center_code x hinj |
| let c : AtomCode := ⟨m, a, centers, r⟩ |
| refine ⟨c, ht, ⟨hr0, hr1, ha, hsep⟩, x, hx, ?_⟩ |
| intro b hb hb1 |
| rw [hrepr] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact atomCurrent_apply _ _ ⟨⟨1, hb⟩, 1, hb1⟩ |
|
|
| noncomputable def selectedAtom [SeparableSpace X] [Nonempty X] |
| (S : P → Functional X 0) (E : Set P) (c : AtomCode) |
| (t : atomDomain S E c) : Fin c.size → X := Classical.choose t.property.2.2 |
|
|
| omit [MeasurableSpace X] [BorelSpace X] [MetricSpace P] in |
| lemma selectedAtom_spec [SeparableSpace X] [Nonempty X] |
| (S : P → Functional X 0) (E : Set P) (c : AtomCode) (t : atomDomain S E c) : |
| (∀ i, dist (selectedAtom S E c t i) (TopologicalSpace.denseSeq X (c.centers i)) ≤ c.radius) ∧ |
| UnitRepresentation (S t) c.weights (selectedAtom S E c t) := Classical.choose_spec t.property.2.2 |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma selectedAtom_lipschitz [SeparableSpace X] [Nonempty X] |
| (S : P → Functional X 0) (E : Set P) (c : AtomCode) {K : ℝ≥0} |
| (hS : ∀ b : X → ℝ, LipschitzWith 1 b → (∀ z, |b z| ≤ 1) → |
| LipschitzOnWith K (fun t => S t b (fun j => Fin.elim0 j)) E) |
| (i : Fin c.size) : LipschitzWith K (fun t : atomDomain S E c => selectedAtom S E c t i) := by |
| rw [lipschitzWith_iff_dist_le_mul] |
| intro s t |
| apply unitRepresentation_matched_distance c s.property.2.1 |
| (selectedAtom S E c s) (selectedAtom S E c t) |
| (selectedAtom_spec S E c s).1 (selectedAtom_spec S E c t).1 |
| (selectedAtom_spec S E c s).2 (selectedAtom_spec S E c t).2 |
| intro b hb hb1 |
| simpa only [Real.dist_eq, Subtype.dist_eq] using (hS b hb hb1).dist_le_mul s s.property.1 t t.property.1 |
|
|
| end CAT0Fillings.SliceReconstruction |
| end |
|
|
| end OAI |
|
|
