| import Mathlib | |
| import OAI.Geometry.IntegralFillings.Charts.Differentiability | |
| import OAI.Geometry.IntegralFillings.Charts.Jacobian | |
| import OAI.Geometry.IntegralFillings.Slicing.CoordinateChart | |
| import OAI.Geometry.IntegralFillings.Slicing.CoordinateDerivative | |
| namespace OAI | |
| section | |
| open Filter Set | |
| open Set Filter MeasureTheory TopologicalSpace | |
| open scoped Topology ENNReal | |
| open Set MeasureTheory | |
| open scoped RealInnerProductSpace | |
| open Matrix | |
| open scoped RealInnerProductSpace MatrixOrder | |
| open Set Filter MeasureTheory | |
| open MeasureTheory Filter Set Metric | |
| open scoped Topology Pointwise NNReal | |
| open Set MeasureTheory Measure Filter Module | |
| open Set Filter MeasureTheory Measure ContinuousLinearMap | |
| open scoped Topology Convolution NNReal | |
| open Set Filter MeasureTheory Measure Metric | |
| open scoped Topology ContDiff | |
| open Set Filter Metric | |
| open scoped Topology NNReal | |
| open Set MeasureTheory Filter | |
| open scoped Topology ENNReal NNReal | |
| namespace SharpIntegralFillings.IntegerChart | |
| open Set MeasureTheory Filter | |
| open scoped Topology | |
| variable {X : Type*} [MetricSpace X] {k : ℕ} (C : IntegerChart X (k+1)) | |
| noncomputable def coordinateMinor (π : Fin k → X → ℝ) (w : Euc (k+1)) : ℝ := | |
| (Matrix.of fun i j : Fin k => | |
| (fderivWithin ℝ (C.scalar (π i)) C.domain w) (EuclideanSpace.single j.succ 1)).det | |
| lemma ae_coordinateSlice_jacobian (π : Fin k → X → ℝ) | |
| (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) : | |
| ∀ᵐ t : ℝ, ∀ (ht : Integrable (fun z => (C.multiplicity (coordinateLayer k t z):ℝ)) | |
| (volume.restrict (C.coordinateDomain t))), | |
| ∀ᵐ z ∂volume.restrict (C.coordinateDomain t), | |
| (C.coordinateSlice t ht).jacobian π z = C.coordinateMinor π (coordinateLayer k t z) := by | |
| have hall : ∀ i, ∀ᵐ t : ℝ, ∀ ht, ∀ᵐ z ∂volume.restrict (C.coordinateDomain t), ∀ j : Fin k, | |
| (fderivWithin ℝ ((C.coordinateSlice t ht).scalar (π i)) (C.coordinateDomain t) z) | |
| (EuclideanSpace.single j 1) = | |
| (fderivWithin ℝ (C.scalar (π i)) C.domain (coordinateLayer k t z)) | |
| (EuclideanSpace.single j.succ 1) := by | |
| intro i | |
| obtain ⟨K,hK⟩ := hπ i | |
| exact C.ae_coordinateSlice_fderiv hK | |
| filter_upwards [ae_all_iff.mpr hall] with t ht | |
| intro hi | |
| filter_upwards [ae_all_iff.mpr (fun i => ht i hi)] with z hz | |
| apply congrArg Matrix.det | |
| ext i j | |
| exact hz i j | |
| lemma ae_coordinate_minor_eq {u : X → ℝ} | |
| (hu : ∀ z (hz : z ∈ C.domain), u (C.param ⟨z,hz⟩) = (Prism.split k z).1) | |
| (π : Fin k → X → ℝ) : | |
| ∀ᵐ z ∂volume.restrict C.domain, | |
| C.jacobian (Matrix.vecCons u π) z = C.coordinateMinor π z := by | |
| filter_upwards [ae_uniqueDiffWithinAt volume C.domain,ae_restrict_mem C.borel] with z hz hm | |
| have hd : fderivWithin ℝ (C.scalar u) C.domain z = | |
| (ContinuousLinearMap.fst ℝ ℝ (Euc k)).comp (Prism.split k).toContinuousLinearMap := by | |
| apply HasFDerivWithinAt.fderivWithin _ hz | |
| apply (((ContinuousLinearMap.fst ℝ ℝ (Euc k)).hasFDerivAt).comp z | |
| (Prism.split k).hasFDerivAt).hasFDerivWithinAt.congr | |
| · intro w hw | |
| rw [C.scalar_eq hw,hu w hw] | |
| rfl | |
| · rw [C.scalar_eq hm,hu z hm] | |
| rfl | |
| let A : Matrix (Fin (k+1)) (Fin (k+1)) ℝ := Matrix.of fun i j => | |
| (fderivWithin ℝ (C.scalar (Matrix.vecCons u π i)) C.domain z) (EuclideanSpace.single j 1) | |
| have ha0 : ∀ j, A 0 j = if j=0 then 1 else 0 := by | |
| intro j | |
| dsimp only [A,Matrix.of_apply,Matrix.cons_val_zero] | |
| rw [hd] | |
| cases j using Fin.cases with | |
| | zero => simp [ContinuousLinearMap.comp_apply] | |
| | succ j => simp [ContinuousLinearMap.comp_apply] | |
| change A.det = _ | |
| rw [Matrix.det_succ_row_zero] | |
| simp only [ha0,mul_ite,mul_zero,ite_mul,zero_mul,Finset.sum_ite_eq',Finset.mem_univ,ite_true, | |
| Fin.val_zero,pow_zero,one_mul] | |
| apply congrArg Matrix.det | |
| ext i j | |
| simp only [Matrix.submatrix_apply,Fin.succAbove_zero,A,Matrix.of_apply,Matrix.cons_val_succ] | |
| end SharpIntegralFillings.IntegerChart | |
| namespace SharpIntegralFillings.IntegerChart | |
| open Set MeasureTheory Filter | |
| open scoped Topology | |
| variable {X : Type*} [MetricSpace X] {k : ℕ} (C : IntegerChart X (k+1)) | |
| lemma coordinate_indicator (g : Euc (k+1) → ℝ) (t : ℝ) : | |
| (fun z => C.domain.indicator g ((Prism.split k).symm (t,z))) = | |
| (C.coordinateDomain t).indicator (fun z => g (coordinateLayer k t z)) := by | |
| funext z | |
| change C.domain.indicator g (coordinateLayer k t z) = _ | |
| by_cases hz : coordinateLayer k t z ∈ C.domain | |
| · rw [indicator_of_mem hz,indicator_of_mem (show z ∈ C.coordinateDomain t from hz)] | |
| · rw [indicator_of_notMem hz,indicator_of_notMem (show z ∉ C.coordinateDomain t from hz)] | |
| lemma coordinate_setIntegral {g : Euc (k+1) → ℝ} | |
| (hg : Integrable g (volume.restrict C.domain)) : | |
| ∫ w in C.domain, g w = ∫ t : ℝ, ∫ z in C.coordinateDomain t, | |
| g (coordinateLayer k t z) := by | |
| rw [←integral_indicator C.borel,Prism.integral_split] | |
| have hi : Integrable (C.domain.indicator g) := (integrable_indicator_iff C.borel).mpr hg | |
| have hip : Integrable (fun p : ℝ × Euc k => C.domain.indicator g ((Prism.split k).symm p)) := | |
| ((Prism.split_symm_measurePreserving k).integrable_comp_emb | |
| (Prism.split k).symm.toHomeomorph.measurableEmbedding).mpr hi | |
| change (∫ p : ℝ × Euc k, C.domain.indicator g ((Prism.split k).symm p) ∂volume.prod volume) = _ | |
| rw [integral_prod _ hip] | |
| apply integral_congr_ae | |
| exact Eventually.of_forall fun t => by | |
| dsimp only | |
| rw [C.coordinate_indicator g t,integral_indicator (C.measurableSet_coordinateDomain t)] | |
| lemma integrable_coordinate_setIntegral {g : Euc (k+1) → ℝ} | |
| (hg : Integrable g (volume.restrict C.domain)) : | |
| Integrable (fun t : ℝ => ∫ z in C.coordinateDomain t, g (coordinateLayer k t z)) := by | |
| have hi : Integrable (C.domain.indicator g) := (integrable_indicator_iff C.borel).mpr hg | |
| have hip : Integrable (fun p : ℝ × Euc k => C.domain.indicator g ((Prism.split k).symm p)) := | |
| ((Prism.split_symm_measurePreserving k).integrable_comp_emb | |
| (Prism.split k).symm.toHomeomorph.measurableEmbedding).mpr hi | |
| convert hip.integral_prod_left using 1 | |
| funext t | |
| rw [C.coordinate_indicator g t,integral_indicator (C.measurableSet_coordinateDomain t)] | |
| lemma integrable_coordinateMinor {u : X → ℝ} {K : ℝ≥0} (hL : LipschitzWith K u) | |
| (hu : ∀ z (hz : z ∈ C.domain), u (C.param ⟨z,hz⟩) = (Prism.split k z).1) | |
| {b : X → ℝ} {π : Fin k → X → ℝ} (h : Admissible b π) : | |
| Integrable (fun w => (C.multiplicity w:ℝ)*C.scalar b w*C.coordinateMinor π w) | |
| (volume.restrict C.domain) := by | |
| have ha : ∀ i, ∃ L : ℝ≥0, LipschitzWith L (Matrix.vecCons u π i) := by | |
| intro i | |
| cases i using Fin.cases with | |
| | zero => exact ⟨_,hL⟩ | |
| | succ i => exact h.2 i | |
| apply (C.integrable_action_integrand h.1 ha).congr | |
| filter_upwards [C.ae_coordinate_minor_eq hu π] with z hz | |
| rw [hz] | |
| lemma ae_coordinateSliceTotal_action {b : X → ℝ} {π : Fin k → X → ℝ} | |
| (h : Admissible b π) : | |
| ∀ᵐ t : ℝ, (C.coordinateSliceTotal t).action b π = | |
| ∫ z in C.coordinateDomain t, (C.multiplicity (coordinateLayer k t z):ℝ)* | |
| C.scalar b (coordinateLayer k t z)*C.coordinateMinor π (coordinateLayer k t z) := by | |
| filter_upwards [C.ae_coordinateSliceTotal_eq,C.ae_coordinateSlice_jacobian π h.2] with t ht hj | |
| obtain ⟨hi,heq⟩ := ht | |
| rw [heq,action,ite_eq_left h] | |
| apply integral_congr_ae | |
| filter_upwards [hj hi,ae_restrict_mem (C.measurableSet_coordinateDomain t)] with z hz hm | |
| change (C.multiplicity (coordinateLayer k t z):ℝ)* | |
| (C.coordinateSlice t hi).scalar b z*(C.coordinateSlice t hi).jacobian π z = _ | |
| rw [C.coordinateSlice_scalar_eq t hi b hm,hz] | |
| theorem coordinateSlice_action_integral {u : X → ℝ} {K : ℝ≥0} (hL : LipschitzWith K u) | |
| (hu : ∀ z (hz : z ∈ C.domain), u (C.param ⟨z,hz⟩) = (Prism.split k z).1) | |
| {b : X → ℝ} {π : Fin k → X → ℝ} (h : Admissible b π) : | |
| C.action b (Matrix.vecCons u π) = ∫ t : ℝ, (C.coordinateSliceTotal t).action b π := by | |
| have ha : Admissible b (Matrix.vecCons u π) := ⟨h.1,fun i => by | |
| cases i using Fin.cases with | |
| | zero => exact ⟨_,hL⟩ | |
| | succ i => exact h.2 i⟩ | |
| rw [action,ite_eq_left ha] | |
| calc | |
| _ = ∫ w in C.domain, (C.multiplicity w:ℝ)*C.scalar b w*C.coordinateMinor π w := by | |
| apply integral_congr_ae | |
| filter_upwards [C.ae_coordinate_minor_eq hu π] with z hz | |
| rw [hz] | |
| _ = ∫ t : ℝ, ∫ z in C.coordinateDomain t, (C.multiplicity (coordinateLayer k t z):ℝ)* | |
| C.scalar b (coordinateLayer k t z)*C.coordinateMinor π (coordinateLayer k t z) := | |
| C.coordinate_setIntegral (C.integrable_coordinateMinor hL hu h) | |
| _ = _ := integral_congr_ae (Filter.EventuallyEq.symm (C.ae_coordinateSliceTotal_action h)) | |
| lemma coordinateSlice_action_integrable {u : X → ℝ} {K : ℝ≥0} (hL : LipschitzWith K u) | |
| (hu : ∀ z (hz : z ∈ C.domain), u (C.param ⟨z,hz⟩) = (Prism.split k z).1) | |
| {b : X → ℝ} {π : Fin k → X → ℝ} (h : Admissible b π) : | |
| Integrable (fun t : ℝ => (C.coordinateSliceTotal t).action b π) := | |
| (C.integrable_coordinate_setIntegral (C.integrable_coordinateMinor hL hu h)).congr | |
| (Filter.EventuallyEq.symm (C.ae_coordinateSliceTotal_action h)) | |
| end SharpIntegralFillings.IntegerChart | |
| open Set Filter MeasureTheory | |
| open scoped Topology ENNReal NNReal | |
| namespace SharpIntegralFillings | |
| attribute [local instance] Classical.propDecidable | |
| universe u | |
| end SharpIntegralFillings | |
| open MeasureTheory Filter Set Metric | |
| open scoped Topology Pointwise NNReal | |
| end | |
| end OAI | |