lean/OAI/Geometry/IntegralFillings/Currents/CountableTests.lean

import Mathlib
import OAI.Geometry.IntegralFillings.Currents.WeakCompactness

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 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 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 Foundations
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] [CompactSpace X]
lemma exists_normal_weak_subsequence_of_integral_mass_bound
    {k : ℕ} {Ts : ℕ → Functional X (k+1+1)}
    (hTs : ∀ j, IsIntegral (k+1+1) (Ts j))
    (M N : ℝ≥0) (hM : ∀ j, mass (Ts j) ≤ M)
    (hN : ∀ j, mass (boundarySucc (Ts j)) ≤ N) :
    ∃ (ψ : ℕ → ℕ), StrictMono ψ ∧
      ∃ T : Functional X (k+1+1), IsMetricCurrent T ∧
        IsMetricCurrent (boundarySucc T) ∧ mass T ≤ M ∧
        mass (boundarySucc T) ≤ N ∧
        ∀ b π, Tendsto (fun j => Ts (ψ j) b π) atTop (𝓝 (T b π)) := by
  obtain ⟨l, hl, hle, T, hT, hbd, hTM, hTN, hlim⟩ :=
    exists_normal_weak_cluster_of_integral_mass_bound (l := atTop) hTs M N hM hN
  let := hl
  have hsep (K : ℕ) : ∃ D : ℕ → TestClass (X := X) (k+1+1) K, DenseRange D :=
    TopologicalSpace.exists_dense_seq _
  choose D hD using hsep
  let evaluations (U : Functional X (k+1+1)) : (ℕ × ℕ) → ℝ :=
    fun ij => TestClass.eval U (D ij.1 ij.2)
  have heval : Tendsto (fun j => evaluations (Ts j)) l (𝓝 (evaluations T)) :=
    tendsto_pi_nhds.mpr fun ij => hlim _ _
  obtain ⟨ψ, hψ, hψlim⟩ := (heval.mapClusterPt.mono hle).tendsto_subseq
  refine ⟨ψ, hψ, T, hT, hbd, hTM, hTN, ?_⟩
  have hall (K : ℕ) (p : TestClass (X := X) (k+1+1) K) :
      Tendsto (fun j => TestClass.eval (Ts (ψ j)) p) atTop (𝓝 (TestClass.eval T p)) := by
    let C : ℝ≥0 := (K : ℝ≥0) ^ (k+1+1) * M +
      (k+1+1) * ((K : ℝ≥0) + K) ^ (k+1) * (K * N + K * M)
    have hL (j : ℕ) : LipschitzWith C (TestClass.eval (K := K) (Ts j)) := by
      simpa [C, Nat.cast_add, Nat.cast_one] using IntegerRectifiable.testClass_lipschitz (hTs j).2.1 (hTs j).1 (hTs j).2.2.1 M N
        (hM j) (hN j) K
    have hLlim : LipschitzWith C (TestClass.eval (K := K) T) :=
      lipschitz_of_pointwise_limit (l := l) hL (fun q => hlim q.val.1 (fun i => q.val.2 i))
    apply tendsto_of_lipschitz_dense (fun j => hL (ψ j)) hLlim (hD K) _ p
    intro i
    exact tendsto_pi_nhds.mp hψlim (K, i)
  intro b π
  by_cases hadm : Admissible b π
  · obtain ⟨K, p, hp₁, hp₂⟩ := admissible_mem_testClass hadm
    simpa only [TestClass.eval, hp₁, hp₂] using hall K p
  · have heq : (fun j => Ts (ψ j) b π) = fun _ => 0 :=
      funext fun j => (hTs (ψ j)).1.offDomain b π hadm
    rw [heq, hT.offDomain b π hadm]
    exact tendsto_const_nhds

end Foundations
end SharpIntegralFillings

namespace SharpIntegralFillings.Foundations
open MeasureTheory Set Filter
open scoped Topology NNReal

variable {X : Type*} [MetricSpace X] [CompactSpace X]
  [MeasurableSpace X] [BorelSpace X]

lemma IsMetricCurrent.testClass_continuous {d : ℕ} {T : Functional X d}
    (hT : IsMetricCurrent T) (K : ℕ) :
    Continuous (TestClass.eval (X := X) (d := d) (K := K) T) := by
  apply continuous_iff_seqContinuous.mpr
  intro ps p hp
  have hcoord : Tendsto (fun n => T p.val.1 (fun i => (ps n).val.2 i)) atTop
      (𝓝 (T p.val.1 (fun i => p.val.2 i))) := by
    apply hT.sequentialContinuity _ _ _ p.boundedLip
    · intro i
      exact ⟨K,fun n => (ps n).property.2.2 i⟩
    · intro i x
      have hc : Continuous (fun q : TestClass (X := X) d K => q.val.2 i x) := by fun_prop
      exact hc.continuousAt.tendsto.comp hp
  have hd : Tendsto (fun n => dist (ps n) p) atTop (𝓝 0) :=
    tendsto_iff_dist_tendsto_zero.mp hp
  have hbnd (n : ℕ) :
      dist (T p.val.1 (fun i => (ps n).val.2 i))
        (T (ps n).val.1 (fun i => (ps n).val.2 i)) ≤
      ((K:ℝ)^d * mass T) * dist (ps n) p := by
    have hh := IsMetricCurrent.first_difference_bound hT p.boundedLip (ps n).boundedLip
      (fun i => (ps n).val.2 i) K (ps n).property.2.2 (nndist (ps n) p) (fun x => ?_)
    · simpa only [Real.dist_eq,NNReal.coe_natCast,coe_nndist,mul_assoc,mul_comm,mul_left_comm]
        using hh
    · have h := (ContinuousMap.dist_apply_le_dist (f := (ps n).val.1) (g := p.val.1) x).trans
        (le_max_left (dist (ps n).val.1 p.val.1) (dist (ps n).val.2 p.val.2))
      change dist ((ps n).val.1 x) (p.val.1 x) ≤ dist (ps n) p at h
      simpa only [coe_nndist,Real.dist_eq,abs_sub_comm] using h
  apply tendsto_of_tendsto_of_dist hcoord
  exact squeeze_zero (fun n => dist_nonneg) hbnd (by simpa using hd.const_mul ((K:ℝ)^d * mass T))

theorem exists_countable_current_tests (d : ℕ) :
    ∃ (b : ℕ → ℕ → X → ℝ) (π : ℕ → ℕ → Fin d → X → ℝ),
      (∀ K j, Admissible (b K j) (π K j)) ∧
      ∀ S T : Functional X d, IsMetricCurrent S → IsMetricCurrent T →
        (∀ K j, S (b K j) (π K j) = T (b K j) (π K j)) → S = T := by
  choose p hp using fun K : ℕ => TopologicalSpace.exists_dense_seq (TestClass (X := X) d K)
  refine ⟨fun K j => (p K j).val.1,fun K j i => (p K j).val.2 i,?_,?_⟩
  · intro K j
    exact ⟨(p K j).boundedLip,fun i => ⟨K,(p K j).property.2.2 i⟩⟩
  · intro S T hS hT heq
    have he (K : ℕ) : TestClass.eval (K := K) S = TestClass.eval (K := K) T := by
      apply (hp K).equalizer (IsMetricCurrent.testClass_continuous hS K) (IsMetricCurrent.testClass_continuous hT K)
      funext j
      exact heq K j
    funext b π
    by_cases h : Admissible b π
    · obtain ⟨K,q,hb,hπ⟩ := admissible_mem_testClass h
      have hh := congrFun (he K) q
      simpa only [TestClass.eval,hb,hπ] using hh
    · rw [hS.offDomain b π h,hT.offDomain b π h]

theorem ae_eq_of_ae_test_eq {A : Type*} [MeasurableSpace A] (μ : Measure A)
    {d : ℕ} {S T : A → Functional X d}
    (hS : ∀ᵐ a ∂μ, IsMetricCurrent (S a)) (hT : ∀ᵐ a ∂μ, IsMetricCurrent (T a))
    (he : ∀ b π, Admissible b π → ∀ᵐ a ∂μ, S a b π = T a b π) :
    ∀ᵐ a ∂μ, S a = T a := by
  obtain ⟨b,π,ha,hex⟩ := exists_countable_current_tests (X := X) d
  have hc : ∀ᵐ a ∂μ, ∀ K j, S a (b K j) (π K j) = T a (b K j) (π K j) :=
    ae_all_iff.mpr fun K => ae_all_iff.mpr fun j => he _ _ (ha K j)
  filter_upwards [hS,hT,hc] with a hs ht h
  exact hex _ _ hs ht h

end SharpIntegralFillings.Foundations

end

end OAI