import Mathlib
import OAI.GroupTheory.SimpleAmenable.RandomFields.SignalRemainder
import OAI.GroupTheory.SimpleAmenable.RandomFields.FieldSignalData
import OAI.GroupTheory.SimpleAmenable.Simplicial.BitReindex

namespace OAI

section
section
open scoped symmDiff
namespace SimpleAmenable
open scoped commutatorElement
open scoped commutatorElement
section SourceTransportEstimate
open Classical Matrix MeasureTheory
attribute [local irreducible] sourceCommonSites flagBoxFinset

theorem smoothNoiseTransportError_le_decidable {ι : Type*} [Fintype ι] [H : DecidableEq ι]
    (B C : Matrix ι ι ℝ) (h : ι → ℝ) :
    smoothNoiseTransportError B C h ≤ smoothNoiseTransportConstant*
      (matrixHSNorm (C-B)+(1+matrixHSNorm (C-B))*finiteL2Norm ((1+B)⁻¹*ᵥh)) := by
  have he : H=Classical.decEq ι := Subsingleton.elim _ _
  cases he
  exact smoothNoiseTransportError_le B C h

theorem smoothNoiseTransportError_of_bounds {ι : Type*} [Fintype ι] [DecidableEq ι]
    (B C : Matrix ι ι ℝ) (h : ι → ℝ) {d b : ℝ} (hd : 0≤d)
    (hh : matrixHSNorm (C-B)≤d) (hi : finiteL2Norm ((1+B)⁻¹*ᵥh)≤b) :
    smoothNoiseTransportError B C h≤ smoothNoiseTransportConstant*(d+(1+d)*b) := by
  apply (smoothNoiseTransportError_le_decidable B C h).trans
  apply mul_le_mul_of_nonneg_left _ smoothNoiseTransportConstant_pos.le
  exact add_le_add hh (mul_le_mul (add_le_add le_rfl hh) hi (finiteL2Norm_nonneg _)
    (add_nonneg zero_le_one hd))

theorem sourceSmoothFieldLaw_transportEstimate {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D)
    (g : polygonFullGroup a m) (θ χ : (ℝ×ℝ) → ℝ) {L ρ η κ : ℝ} (hL : 0<L)
    (hχc : ∀x,L≤‖x‖ → χ x=0) (q : ℝ) (hθc : ∀x,L≤‖x‖ → θ x=q)
    (hρ : 0<ρ) (hκ : 0<κ) (n : ℕ) (d b : ℝ) (hd : 0≤d) :
    let T := sourceCommonSites (v:=v) hD g hL n
    let B : Matrix T T ℝ := Matrix.of (fun z w => sourceFlagMatrix χ ρ η κ n z.val w.val)
    let C : Matrix T T ℝ := Matrix.of (fun z w => sourceFlagMatrix χ ρ η κ n
      (flagSiteAction hD g⁻¹ z.val) (flagSiteAction hD g⁻¹ w.val))
    let h : T → ℝ := fun z => flagSignalDifference hD g θ (sourceDyadicN n) z.val
    matrixHSNorm (C-B) ≤ d → finiteL2Norm ((1+B)⁻¹*ᵥh) ≤ b →
    ObservableClose (sourceSmoothFieldLaw (v:=v) hD θ χ hL ρ η κ n)
      ((sourceSmoothFieldLaw (v:=v) hD θ χ hL ρ η κ n).map
        (fieldReindex (flagSitePermutation hD g)))
      (smoothNoiseTransportConstant*(d+(1+d)*b)) := by
  intro T B C h hh hi
  have hc := sourceSmoothFieldLaw_close (v:=v) (η:=η) hD g θ χ hL hχc q hθc hρ hκ n
  exact hc.mono (smoothNoiseTransportError_of_bounds B C h hd hh hi)

end SourceTransportEstimate

section SourceTransportConstants
open Classical Matrix MeasureTheory Filter
open scoped Topology

theorem sourceSmoothFieldLaw_transport_constants {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D)
    (g : polygonFullGroup a m) (ψ χ : (ℝ×ℝ) → ℝ)
    (hψ : ContDiff ℝ 2 ψ) (hsψ : HasCompactSupport ψ) (q K L Λ : ℝ)
    (hL : 0<L) (hKL : K+2 ≤ L)
    (hcompact : ∀x,K ≤ ‖x‖ → ψ x=0)
    (hχ : ∀x,χ x∈Set.Icc (0:ℝ) 1)
    (hχ₁ : ∀x,‖x‖ ≤ K+2 → χ x=1)
    (hχc : ∀x,L ≤ ‖x‖ → χ x=0)
    (hΛ : 0≤Λ) (hLip : ∀x y,|χ x-χ y| ≤ Λ*(|x.1-y.1|+|x.2-y.2|)) :
    ∃C₁ C₂ : ℝ,0≤C₁ ∧ 0≤C₂ ∧ ∀η : ℝ,0<η → η≤1 → ∀κ : ℝ,0<κ →
      ∀δ d : ℝ,0<δ → 0<d → ∀ᶠn : ℕ in atTop,
      ObservableClose (sourceSmoothFieldLaw (v:=v) hD (fun x => q+ψ x) χ hL ((D:ℝ)^4/5) η κ n)
        ((sourceSmoothFieldLaw (v:=v) hD (fun x => q+ψ x) χ hL ((D:ℝ)^4/5) η κ n).map
          (fieldReindex (flagSitePermutation hD g)))
        (smoothNoiseTransportConstant*(d+(1+d)*(C₁*η+C₂*Real.sqrt κ+δ))) := by
  obtain ⟨C₁,C₂,hC₁,hC₂,hinv⟩ := sourceFlagMatrix_inverse_signal (v:=v) hD g ψ χ hψ hsψ q K L hL hKL hcompact hχ hχ₁ hχc
  refine ⟨C₁,C₂,hC₁,hC₂,?_⟩
  intro η hη hη₁ κ hκ δ d hδ hd
  have hD' : (0:ℝ)<D := by exact_mod_cast hD
  have hρ : 0<(D:ℝ)^4/5 := by positivity
  let T := sourceCommonSites (v:=v) hD g hL
  let B (n : ℕ) : Matrix (T n) (T n) ℝ := Matrix.of (fun z w =>
    sourceFlagMatrix χ ((D:ℝ)^4/5) η κ n z.val w.val)
  let C (n : ℕ) : Matrix (T n) (T n) ℝ := Matrix.of (fun z w =>
    sourceFlagMatrix χ ((D:ℝ)^4/5) η κ n (flagSiteAction hD g⁻¹ z.val) (flagSiteAction hD g⁻¹ w.val))
  let h (n : ℕ) : T n → ℝ := fun z => flagSignalDifference hD g (fun x => q+ψ x) (sourceDyadicN n) z.val
  have hhs : Tendsto (fun n => matrixHSNorm (C n-B n)) atTop (nhds 0) := by
    convert! sourceFlagMatrix_HS_tendsto hD g χ hχ hL hχc hΛ hρ hη hκ hLip T using 1
  filter_upwards [hinv η hη hη₁ κ hκ δ hδ,hhs.eventually_lt_const hd] with n hn hdn
  have hi : finiteL2Norm ((1+B n)⁻¹*ᵥh n)≤C₁*η+C₂*Real.sqrt κ+δ := by
    exact hn (T n) Finset.subset_union_left
  have hθc : ∀x,L≤‖x‖ → q+ψ x=q := by
    intro x hx
    rw [hcompact x (by linarith only [hx,hKL]),add_zero]
  exact sourceSmoothFieldLaw_transportEstimate (v:=v) (η:=η) hD g (fun x => q+ψ x) χ
    hL hχc q hθc hρ hκ n d (C₁*η+C₂*Real.sqrt κ+δ) hd.le hdn.le hi

end SourceTransportConstants

section SignalTransport
open Classical MeasureTheory Filter
open scoped Topology
namespace FieldSignalData

theorem realLaw_transport_constants (S : FieldSignalData)
    {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) (g : polygonFullGroup a m) :
    ∃C₁ C₂ : ℝ,0≤C₁ ∧ 0≤C₂ ∧ ∀η : ℝ,0<η → η≤1 → ∀κ : ℝ,0<κ →
      ∀δ d : ℝ,0<δ → 0<d → ∀ᶠn : ℕ in atTop,
      ObservableClose (S.realLaw (v:=v) hD η κ n)
        ((S.realLaw (v:=v) hD η κ n).map (fieldReindex (flagSitePermutation hD g)))
        (smoothNoiseTransportConstant*(d+(1+d)*(C₁*η+C₂*Real.sqrt κ+δ))) :=
  sourceSmoothFieldLaw_transport_constants hD g S.ψ S.χ S.smooth S.compact S.q S.K S.L S.Λ
    S.L_pos S.gap S.ψ_zero S.χ_range S.χ_one S.χ_zero S.Λ_nonneg S.χ_lipschitz

theorem bitLaw_transport_constants (S : FieldSignalData)
    {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) (g : polygonFullGroup a m) :
    ∃C₁ C₂ : ℝ,0≤C₁ ∧ 0≤C₂ ∧ ∀η : ℝ,0<η → η≤1 → ∀κ : ℝ,0<κ →
      ∀δ d : ℝ,0<δ → 0<d → ∀ᶠn : ℕ in atTop,
      ObservableClose (S.bitLaw (v:=v) hD η κ n)
        ((S.bitLaw (v:=v) hD η κ n).map (bitReindex (flagSitePermutation hD g)))
        (smoothNoiseTransportConstant*(d+(1+d)*(C₁*η+C₂*Real.sqrt κ+δ))) := by
  obtain ⟨C₁,C₂,hC₁,hC₂,h⟩ := S.realLaw_transport_constants (v:=v) hD g
  refine ⟨C₁,C₂,hC₁,hC₂,fun η hη hη₁ κ hκ δ d hδ hd => ?_⟩
  filter_upwards [h η hη hη₁ κ hκ δ d hδ hd] with n hn
  exact hn.threshold_transport _ _

end FieldSignalData
end SignalTransport

section SourceFieldTransport
open Classical Matrix MeasureTheory Filter
open scoped Topology

theorem sourceSmoothFieldLaw_transport {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D)
    (g : polygonFullGroup a m) (ψ χ : (ℝ×ℝ) → ℝ)
    (hψ : ContDiff ℝ 2 ψ) (hsψ : HasCompactSupport ψ) (q K L Λ : ℝ)
    (hL : 0<L) (hKL : K+2 ≤ L)
    (hcompact : ∀x,K ≤ ‖x‖ → ψ x=0)
    (hχ : ∀x,χ x∈Set.Icc (0:ℝ) 1)
    (hχ₁ : ∀x,‖x‖ ≤ K+2 → χ x=1)
    (hχc : ∀x,L ≤ ‖x‖ → χ x=0)
    (hΛ : 0≤Λ) (hLip : ∀x y,|χ x-χ y| ≤ Λ*(|x.1-y.1|+|x.2-y.2|))
    (ε : ℝ) (hε : 0<ε) :
    ∃η κ : ℝ,0<η ∧ η≤1 ∧ 0<κ ∧ ∀ᶠn : ℕ in atTop,
      ObservableClose (sourceSmoothFieldLaw (v:=v) hD (fun x => q+ψ x) χ hL ((D:ℝ)^4/5) η κ n)
        ((sourceSmoothFieldLaw (v:=v) hD (fun x => q+ψ x) χ hL ((D:ℝ)^4/5) η κ n).map
          (fieldReindex (flagSitePermutation hD g))) ε := by
  obtain ⟨C₁,C₂,hC₁,hC₂,ht⟩ := sourceSmoothFieldLaw_transport_constants (v:=v) hD g ψ χ
    hψ hsψ q K L Λ hL hKL hcompact hχ hχ₁ hχc hΛ hLip
  obtain ⟨η,κ,δ,d,hη,hη₁,hκ,hδ,hd,hparameters⟩ :=
    smallTransportParameters smoothNoiseTransportConstant_pos hC₁ hC₂ hε
  refine ⟨η,κ,hη,hη₁,hκ,?_⟩
  filter_upwards [ht η hη hη₁ κ hκ δ d hδ hd] with n hn
  exact hn.mono (hparameters d (C₁*η+C₂*Real.sqrt κ+δ) hd.le le_rfl (by positivity) le_rfl).le

end SourceFieldTransport

end SimpleAmenable
end
end

end OAI