| import Mathlib | |
| import OAI.Geometry.IntegralFillings.Charts.Jacobian | |
| namespace OAI | |
| section | |
| open Set Filter MeasureTheory | |
| open scoped Topology ENNReal NNReal | |
| open MeasureTheory Filter Set Metric | |
| open scoped Topology Pointwise NNReal | |
| namespace SharpIntegralFillings | |
| open MeasureTheory Set Filter | |
| open scoped Topology NNReal | |
| namespace IntegerChart | |
| variable {X : Type*} [MetricSpace X] | |
| variable {k : ℕ} (C : IntegerChart X k) | |
| lemma jacobian_permute (π : Fin k → X → ℝ) (σ : Equiv.Perm (Fin k)) (z : Euc k) : | |
| C.jacobian (π ∘ σ) z = (Equiv.Perm.sign σ : ℤ) * C.jacobian π z := by | |
| let M : Matrix (Fin k) (Fin k) ℝ := Matrix.of fun i j => | |
| fderivWithin ℝ (C.scalar (π i)) C.domain z (EuclideanSpace.single j 1) | |
| change (M.submatrix σ id).det = (Equiv.Perm.sign σ : ℤ) * M.det | |
| exact Matrix.det_permute σ M | |
| lemma action_permute {b : X → ℝ} {π : Fin k → X → ℝ} | |
| (h : Admissible b π) (σ : Equiv.Perm (Fin k)) : | |
| C.action b (π ∘ σ) = (Equiv.Perm.sign σ : ℤ) * C.action b π := by | |
| have hσ : Admissible b (π ∘ σ) := ⟨h.1, fun i => h.2 (σ i)⟩ | |
| simp only [action, ite_eq_left h, ite_eq_left hσ, C.jacobian_permute] | |
| rw [← integral_const_mul] | |
| apply integral_congr_ae | |
| filter_upwards [] with z | |
| ring | |
| end IntegerChart | |
| namespace Foundations | |
| variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] [CompactSpace X] | |
| lemma IntegerRectifiable.apply_update_mul {k : ℕ} {T : Functional X k} | |
| (hT : IntegerRectifiable T) {b f g : X → ℝ} (hb : BoundedLip b) | |
| (hf : BoundedLip f) (hg : BoundedLip g) (π : Fin k → X → ℝ) | |
| (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) (i : Fin k) : | |
| T b (Function.update π i (fun x => f x * g x)) = | |
| T (fun x => b x * f x) (Function.update π i g) + | |
| T (fun x => b x * g x) (Function.update π i f) := by | |
| obtain ⟨C, _, hC, hsum, hrepr⟩ := hT | |
| have hup {a : X → ℝ} (ha : BoundedLip a) : | |
| ∀ j, ∃ K : ℝ≥0, LipschitzWith K ((Function.update π i a) j) := by | |
| intro j | |
| by_cases hji : j = i | |
| · simpa [hji] using ha.1 | |
| · simpa [hji] using hπ j | |
| rw [hrepr, hrepr, hrepr, ← Summable.tsum_add | |
| (summable_actions_of_summable_masses hC hsum ⟨BoundedLip.mul hb hf, hup hg⟩) | |
| (summable_actions_of_summable_masses hC hsum ⟨BoundedLip.mul hb hg, hup hf⟩)] | |
| apply tsum_congr | |
| intro j | |
| exact (C j).action_update_mul hb hf hg π hπ i | |
| omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in | |
| lemma admissible_vecCons {k : ℕ} {b f : X → ℝ} {π : Fin k → X → ℝ} | |
| (hb : BoundedLip b) (hf : ∃ K : ℝ≥0, LipschitzWith K f) | |
| (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) : | |
| Admissible b (Matrix.vecCons f π) := by | |
| refine ⟨hb, ?_⟩ | |
| intro i | |
| refine Fin.cases ?_ (fun j => ?_) i | |
| · exact hf | |
| · exact hπ j | |
| lemma update_vecCons_zero {α : Type*} {k : ℕ} (f g : α) (π : Fin k → α) : | |
| Function.update (Matrix.vecCons f π) 0 g = Matrix.vecCons g π := by | |
| funext i | |
| refine Fin.cases ?_ (fun j => ?_) i | |
| · simp | |
| · simp | |
| lemma IntegerRectifiable.product_rule {k : ℕ} {T : Functional X (k + 1)} | |
| (hT : IntegerRectifiable T) {b f : X → ℝ} (hb : BoundedLip b) | |
| (hf : BoundedLip f) (π : Fin k → X → ℝ) | |
| (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) : | |
| T b (Matrix.vecCons f π) + T f (Matrix.vecCons b π) = | |
| boundarySucc T (fun x => b x * f x) π := by | |
| have h := IntegerRectifiable.apply_update_mul hT (BoundedLip.const 1) hb hf (Matrix.vecCons b π) | |
| (admissible_vecCons (BoundedLip.const 1) hb.1 hπ).2 0 | |
| simp only [update_vecCons_zero, one_mul] at h | |
| have hadm : Admissible (fun x => b x * f x) π := ⟨BoundedLip.mul hb hf, hπ⟩ | |
| exact h.symm.trans (by rw [boundarySucc, ite_eq_left hadm]) | |
| lemma IntegerRectifiable.cycle_product_rule {k : ℕ} {T : Functional X (k + 1)} | |
| (hT : IntegerRectifiable T) (hz : IsCycle T) {b f : X → ℝ} (hb : BoundedLip b) | |
| (hf : BoundedLip f) (π : Fin k → X → ℝ) | |
| (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) : | |
| T b (Matrix.vecCons f π) = -T f (Matrix.vecCons b π) := by | |
| have h := IntegerRectifiable.product_rule hT hb hf π hπ | |
| have hz' : boundarySucc T = fun _ _ => 0 := hz | |
| rw [hz'] at h | |
| exact eq_neg_of_add_eq_zero_left h | |
| omit [BorelSpace X] [CompactSpace X] in | |
| lemma IntegerRectifiable.apply_permute {k : ℕ} {T : Functional X k} | |
| (hT : IntegerRectifiable T) {b : X → ℝ} {π : Fin k → X → ℝ} | |
| (h : Admissible b π) (σ : Equiv.Perm (Fin k)) : | |
| T b (π ∘ σ) = (Equiv.Perm.sign σ : ℤ) * T b π := by | |
| obtain ⟨C, _, _, _, hrepr⟩ := hT | |
| rw [hrepr, hrepr, ← tsum_mul_left] | |
| exact tsum_congr fun j => (C j).action_permute h σ | |
| omit [BorelSpace X] [CompactSpace X] in | |
| lemma IntegerRectifiable.abs_apply_permute {k : ℕ} {T : Functional X k} | |
| (hT : IntegerRectifiable T) {b : X → ℝ} {π : Fin k → X → ℝ} | |
| (h : Admissible b π) (σ : Equiv.Perm (Fin k)) : | |
| |T b (π ∘ σ)| = |T b π| := by | |
| rw [IntegerRectifiable.apply_permute hT h σ, abs_mul, abs_unit_intCast, one_mul] | |
| lemma IntegerRectifiable.head_bound {k : ℕ} {T : Functional X (k + 1)} | |
| (hT : IntegerRectifiable T) (hcur : IsMetricCurrent T) | |
| (hbd : IsMetricCurrent (boundarySucc T)) | |
| {b f : X → ℝ} {Kb : ℝ≥0} (hb : LipschitzWith Kb b) (hf : BoundedLip f) | |
| (π : Fin k → X → ℝ) (K : Fin k → ℝ≥0) | |
| (hπ : ∀ i, LipschitzWith (K i) (π i)) | |
| (B F : ℝ≥0) (hB : ∀ x, |b x| ≤ B) (hF : ∀ x, |f x| ≤ F) : | |
| |T b (Matrix.vecCons f π)| ≤ | |
| (∏ i, (K i : ℝ)) * ((B : ℝ) * mass (boundarySucc T) + (Kb : ℝ) * mass T) * F := by | |
| have hb' : BoundedLip b := ⟨⟨Kb, hb⟩, B, hB⟩ | |
| have hπ' : ∀ i, ∃ L : ℝ≥0, LipschitzWith L (π i) := fun i => ⟨K i, hπ i⟩ | |
| have hprod := IntegerRectifiable.product_rule hT hb' hf π hπ' | |
| have heq : T b (Matrix.vecCons f π) = | |
| boundarySucc T (fun x => b x * f x) π - T f (Matrix.vecCons b π) := by | |
| linarith | |
| have hbf (x : X) : |b x * f x| ≤ (B : ℝ) * F := by | |
| rw [abs_mul] | |
| exact mul_le_mul (hB x) (hF x) (abs_nonneg _) B.coe_nonneg | |
| have h1 := hbd.mass_bound_uniform (BoundedLip.mul hb' hf) K hπ hbf | |
| have hK : ∀ i, LipschitzWith (Matrix.vecCons Kb K i) (Matrix.vecCons b π i) := by | |
| intro i | |
| exact Fin.cases hb (fun j => hπ j) i | |
| have h2 := hcur.mass_bound_uniform hf (Matrix.vecCons Kb K) hK hF | |
| have hmult : (∏ i, ((Matrix.vecCons Kb K i : ℝ≥0) : ℝ)) = | |
| (Kb : ℝ) * ∏ i, (K i : ℝ) := by rw [Fin.prod_univ_succ]; rfl | |
| rw [hmult] at h2 | |
| rw [heq] | |
| calc |boundarySucc T (fun x => b x * f x) π - T f (Matrix.vecCons b π)| ≤ | |
| |boundarySucc T (fun x => b x * f x) π| + |T f (Matrix.vecCons b π)| := abs_sub _ _ | |
| _ ≤ ((∏ i, (K i : ℝ)) * ((B : ℝ) * F)) * mass (boundarySucc T) + | |
| (((Kb : ℝ) * ∏ i, (K i : ℝ)) * F) * mass T := add_le_add h1 h2 | |
| _ = _ := by ring | |
| end Foundations | |
| end SharpIntegralFillings | |
| end | |
| end OAI | |