Download data/lean/OAI/Geometry/IntegralFillings/Currents/ProductRule.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.01 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IntegralFillings/Currents/ProductRule.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/IntegralFillings/Currents/ProductRule.lean
-
curl -L -o ProductRule.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IntegralFillings/Currents/ProductRule.lean
7.01 kB
| 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 | |