File size: 6,000 Bytes
59d1c80 | 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 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | import Mathlib
import OAI.Geometry.IntegralFillings.Currents.WeightedAction
import OAI.Geometry.IntegralFillings.Currents.Contraction
namespace OAI
section
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 Set MeasureTheory Filter
open Filter Set
open scoped Topology NNReal
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 scoped Topology ENNReal NNReal
open MeasureTheory Filter Set Metric
open scoped Topology Pointwise NNReal
namespace SharpIntegralFillings
open Set MeasureTheory Filter BorelCoefficients
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
[CompactSpace X] {k : ℕ} {T : Functional X (k+1)}
lemma weightedCurrent_boundary_cycle (hT : IsMetricCurrent T) (hrect : IntegerRectifiable T)
(hz : IsCycle T) (μ : Measure X) [IsFiniteMeasure μ] (hμ : Controls T μ)
{u : X → ℝ} (hu : BoundedLip u) :
boundarySucc (weightedCurrent μ hT u) = - contractCurrent u T := by
classical
funext b π
by_cases hab : Admissible b π
· have hcons : Admissible (fun _ : X => (1:ℝ)) (Matrix.vecCons b π) :=
⟨BoundedLip.const 1,fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i⟩
simp only [boundarySucc,ite_eq_left hab,weightedCurrent,ite_eq_left hcons,mul_one,
Pi.neg_apply,contractCurrent_apply _ _ hab]
rw [borelAction_eq μ hT hμ ⟨hu,fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i⟩]
exact Foundations.IntegerRectifiable.cycle_product_rule hrect hz hu hab.1 π hab.2
· simp only [boundarySucc,ite_eq_right hab,Pi.neg_apply,contractCurrent,neg_zero]
lemma weightedCurrent_boundary_controls (hT : IsMetricCurrent T) (hrect : IntegerRectifiable T)
(hz : IsCycle T) (μ : Measure X) [IsFiniteMeasure μ] (hμ : Controls T μ)
{u : X → ℝ} (hu : BoundedLip u) {K : ℝ≥0} (hK : LipschitzWith K u) :
Controls (boundarySucc (weightedCurrent μ hT u)) (K • μ) := by
rw [weightedCurrent_boundary_cycle hT hrect hz μ hμ hu]
intro b π hb hπ
simpa only [Pi.neg_apply,abs_neg] using contractCurrent_controls hT hμ hK b π hb hπ
end SharpIntegralFillings
namespace SharpIntegralFillings.IntegerChart
open Set MeasureTheory Filter
variable {X : Type*} [MetricSpace X] {k : ℕ} (C : IntegerChart X k)
lemma ae_fderivWithin_scalar_comp {u : X → ℝ} {K : ℝ≥0} (hu : LipschitzWith K u)
{φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t) :
∀ᵐ z ∂volume.restrict C.domain,
fderivWithin ℝ (C.scalar (φ ∘ u)) C.domain z =
dφ (C.scalar u z) • fderivWithin ℝ (C.scalar u) C.domain z := by
filter_upwards [ae_uniqueDiffWithinAt volume C.domain,ae_restrict_mem C.borel,
C.ae_differentiableWithinAt_scalar hu] with z hz hzs hdu
have heq : EqOn (C.scalar (φ ∘ u)) (φ ∘ C.scalar u) C.domain := by
intro y hy
simp only [Function.comp_apply,C.scalar_eq hy]
have hh := (hφ (C.scalar u z)).comp_hasFDerivWithinAt z hdu.hasFDerivWithinAt
exact (hh.congr heq (heq hzs)).fderivWithin hz
lemma ae_jacobian_update_comp (π : Fin k → X → ℝ) (i : Fin k)
{u : X → ℝ} {K : ℝ≥0} (hu : LipschitzWith K u)
{φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t) :
∀ᵐ z ∂volume.restrict C.domain,
C.jacobian (Function.update π i (φ ∘ u)) z =
dφ (C.scalar u z) * C.jacobian (Function.update π i u) z := by
filter_upwards [C.ae_fderivWithin_scalar_comp hu hφ] with z hz
rw [C.jacobian_update,C.jacobian_update,hz]
simpa only [_root_.smul_apply,Pi.smul_def,smul_eq_mul] using Matrix.det_updateRow_smul
(Matrix.of fun a j => fderivWithin ℝ (C.scalar (π a)) C.domain z (EuclideanSpace.single j 1))
i (dφ (C.scalar u z))
(fun j => fderivWithin ℝ (C.scalar u) C.domain z (EuclideanSpace.single j 1))
lemma action_update_comp {b u : X → ℝ} (hb : BoundedLip b) (hu : BoundedLip u)
{φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t)
(hφu : BoundedLip (φ ∘ u)) (hdu : BoundedLip (dφ ∘ u))
(π : Fin k → X → ℝ) (hπ : ∀ j, ∃ K : ℝ≥0, LipschitzWith K (π j)) (i : Fin k) :
C.action b (Function.update π i (φ ∘ u)) =
C.action (fun x => b x * dφ (u x)) (Function.update π i u) := by
obtain ⟨K,hK⟩ := hu.1
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 [action,ite_eq_left ⟨hb,hup hφu⟩,action,ite_eq_left ⟨hb.mul hdu,hup hu⟩]
apply integral_congr_ae
filter_upwards [C.ae_jacobian_update_comp π i hK hφ,ae_restrict_mem C.borel] with z hz hzs
rw [hz,C.scalar_eq hzs,C.scalar_eq hzs,C.scalar_eq hzs]
ring
end SharpIntegralFillings.IntegerChart
namespace SharpIntegralFillings.Foundations
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] [CompactSpace X]
omit [BorelSpace X] [CompactSpace X] in
lemma IntegerRectifiable.apply_update_comp {k : ℕ} {T : Functional X k}
(hT : IntegerRectifiable T) {b u : X → ℝ} (hb : BoundedLip b) (hu : BoundedLip u)
{φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t)
(hφu : BoundedLip (φ ∘ u)) (hdu : BoundedLip (dφ ∘ u))
(π : Fin k → X → ℝ) (hπ : ∀ j, ∃ K : ℝ≥0, LipschitzWith K (π j)) (i : Fin k) :
T b (Function.update π i (φ ∘ u)) =
T (fun x => b x * dφ (u x)) (Function.update π i u) := by
obtain ⟨C,_,_,_,heq⟩ := hT
rw [heq,heq]
apply tsum_congr
intro j
exact (C j).action_update_comp hb hu hφ hφu hdu π hπ i
end SharpIntegralFillings.Foundations
end
end OAI
|