import Mathlib

namespace OAI

noncomputable section

open MeasureTheory Filter
open scoped ENNReal NNReal

open scoped RealInnerProductSpace BoundedContinuousFunction
namespace EuclideanFiveColor.Amenable
variable (G : Type*) [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G]

def shift {E : Type*} [PseudoMetricSpace E] (g : G) (f : G →ᵇ E) : G →ᵇ E :=
  f.compContinuous ⟨fun x => x + g, continuous_of_discreteTopology⟩

@[simp] lemma shift_apply {E : Type*} [PseudoMetricSpace E] (g x : G) (f : G →ᵇ E) :
    shift G g f x = f (x+g) := rfl

/-- A normalized positive translation-invariant real functional. -/
structure Mean where
  map : (G →ᵇ ℝ) →L[ℝ] ℝ
  map_const : ∀ c, map (BoundedContinuousFunction.const G c) = c
  positive : ∀ f, (∀ x, 0 ≤ f x) → 0 ≤ map f
  invariant : ∀ g f, map (shift G g f) = map f

variable {G}
namespace Mean
variable (M : Mean G)
lemma mono (f h : G →ᵇ ℝ) (hf : ∀ x, f x ≤ h x) : M.map f ≤ M.map h := by
  have hm := M.positive (h-f) (fun x => sub_nonneg.mpr (hf x))
  simpa only [map_sub, sub_nonneg] using hm

lemma abs_le (f h : G →ᵇ ℝ) (hf : ∀ x, |f x| ≤ h x) : |M.map f| ≤ M.map h := by
  rw [_root_.abs_le]
  constructor
  · have := M.mono (-h) f (fun x => (_root_.abs_le.mp (hf x)).1)
    simpa only [map_neg] using this
  · exact M.mono f h fun x => (_root_.abs_le.mp (hf x)).2

lemma exists_lt {f : G →ᵇ ℝ} {ε : ℝ} (h : M.map f < ε) : ∃ g, f g < ε := by
  by_contra hn
  push Not at hn
  have := M.mono (BoundedContinuousFunction.const G ε) f hn
  rw [M.map_const] at this
  exact (not_lt_of_ge this) h

variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]

def normFn (V : G →ᵇ H) : G →ᵇ ℝ :=
  BoundedContinuousFunction.ofNormedAddCommGroup (fun x => ‖V x‖)
    (continuous_norm.comp V.continuous) ‖V‖ (fun x => by simpa using V.norm_coe_le_norm x)
omit [AddCommGroup G] [DiscreteTopology G] [InnerProductSpace ℝ H] [CompleteSpace H] in
@[simp] lemma normFn_apply (V : G →ᵇ H) (x : G) : normFn V x = ‖V x‖ := rfl

def pairing (V : G →ᵇ H) (v : H) : G →ᵇ ℝ :=
  BoundedContinuousFunction.ofNormedAddCommGroup (fun x => inner ℝ (V x) v)
    (V.continuous.inner continuous_const) (‖V‖ * ‖v‖)
    (fun x => (norm_inner_le_norm _ _).trans (mul_le_mul_of_nonneg_right (V.norm_coe_le_norm x) (norm_nonneg v)))
omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in
@[simp] lemma pairing_apply (V : G →ᵇ H) (v : H) (x : G) : pairing V v x = inner ℝ (V x) v := rfl

omit [CompleteSpace H] in
lemma pairing_bound (V : G →ᵇ H) (v : H) :
    |M.map (pairing V v)| ≤ M.map (normFn V) * ‖v‖ := by
  have he : M.map (‖v‖ • normFn V) = M.map (normFn V) * ‖v‖ := by
    rw [map_smul]; simp [mul_comm]
  rw [← he]
  apply M.abs_le
  intro x
  simpa [mul_comm] using (norm_inner_le_norm (𝕜 := ℝ) (V x) v)

def pairingMap (V : G →ᵇ H) : H →L[ℝ] ℝ :=
  LinearMap.mkContinuous
    { toFun := fun v => M.map (pairing V v)
      map_add' := by
        intro v w
        have he : pairing V (v+w) = pairing V v + pairing V w := by ext; simp [inner_add_right]
        rw [he, map_add]
      map_smul' := by
        intro c v
        have he : pairing V (c • v) = c • pairing V v := by ext; simp [inner_smul_right]
        rw [he, map_smul]; rfl }
    (M.map (normFn V)) (fun v => M.pairing_bound V v)

def vector (V : G →ᵇ H) : H := (InnerProductSpace.toDual ℝ H).symm (M.pairingMap V)

lemma vector_pair (V : G →ᵇ H) (v : H) :
    inner ℝ (M.vector V) v = M.map (pairing V v) := InnerProductSpace.toDual_symm_apply

lemma vector_norm_le (V : G →ᵇ H) : ‖M.vector V‖ ≤ M.map (normFn V) := by
  rw [vector, LinearIsometryEquiv.norm_map]
  apply (M.pairingMap V).opNorm_le_bound (M.positive _ (fun x => by simp))
  exact M.pairing_bound V

lemma vector_add (V W : G →ᵇ H) : M.vector (V+W) = M.vector V + M.vector W := by
  apply ext_inner_right ℝ; intro v
  rw [inner_add_left, M.vector_pair, M.vector_pair, M.vector_pair]
  have he : pairing (V+W) v = pairing V v + pairing W v := by ext; simp [inner_add_left]
  rw [he, map_add]

lemma vector_smul (c : ℝ) (V : G →ᵇ H) : M.vector (c • V) = c • M.vector V := by
  apply ext_inner_right ℝ; intro v
  rw [real_inner_smul_left, M.vector_pair, M.vector_pair]
  have he : pairing (c • V) v = c • pairing V v := by ext; simp [real_inner_smul_left]
  rw [he, map_smul]; rfl

lemma vector_shift (V : G →ᵇ H) (g : G) : M.vector (shift G g V) = M.vector V := by
  apply ext_inner_right ℝ; intro v
  rw [M.vector_pair, M.vector_pair]
  exact M.invariant g (pairing V v)

lemma vector_map {J : Type*} [NormedAddCommGroup J] [InnerProductSpace ℝ J] [CompleteSpace J]
    (L : H →L[ℝ] J) (V : G →ᵇ H) :
    M.vector (L.compLeftContinuousBounded G V) = L (M.vector V) := by
  apply ext_inner_right ℝ; intro v
  rw [M.vector_pair, ← L.adjoint_inner_right, M.vector_pair]
  congr 1; ext x
  exact (L.adjoint_inner_right (V x) v).symm

def squareNorm (V : G →ᵇ H) : G →ᵇ ℝ := normFn V * normFn V
omit [AddCommGroup G] [DiscreteTopology G] [InnerProductSpace ℝ H] [CompleteSpace H] in
@[simp] lemma squareNorm_apply (V : G →ᵇ H) (x : G) : squareNorm V x = ‖V x‖^2 := by
  simp [squareNorm, pow_two]

lemma jensen (V : G →ᵇ H) : ‖M.vector V‖^2 ≤ M.map (squareNorm V) := by
  let c := M.vector V
  have he : squareNorm (V - BoundedContinuousFunction.const G c) =
      squareNorm V - (2 : ℝ) • pairing V c + BoundedContinuousFunction.const G (‖c‖^2) := by
    ext x
    simp only [squareNorm_apply, BoundedContinuousFunction.sub_apply, BoundedContinuousFunction.const_apply,
      BoundedContinuousFunction.add_apply, BoundedContinuousFunction.smul_apply, pairing_apply, smul_eq_mul]
    rw [norm_sub_sq_real]
  have hp := M.positive (squareNorm (V - BoundedContinuousFunction.const G c)) (fun x => by
    rw [squareNorm_apply]; positivity)
  rw [he, map_add, map_sub, map_smul, M.map_const, ← M.vector_pair] at hp
  change 0 ≤ M.map (squareNorm V) - 2 * inner ℝ c c + ‖c‖^2 at hp
  rw [real_inner_self_eq_norm_sq] at hp
  dsimp [c] at hp
  linarith
end Mean
end EuclideanFiveColor.Amenable

namespace EuclideanFiveColor.Amenable.Mean

section
open scoped BoundedContinuousFunction
variable {G : Type*} [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G]
variable (M : Mean G)
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]

def cross (V W : G →ᵇ H) : G →ᵇ ℝ :=
  BoundedContinuousFunction.ofNormedAddCommGroup (fun x => inner ℝ (V x) (W x))
    (V.continuous.inner W.continuous) (‖V‖ * ‖W‖) (fun x => by
      exact (norm_inner_le_norm (𝕜 := ℝ) _ _).trans
        (mul_le_mul (V.norm_coe_le_norm x) (W.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _)))

omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in
@[simp] lemma cross_apply (V W : G →ᵇ H) (x : G) : cross V W x = inner ℝ (V x) (W x) := rfl

omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in
lemma cross_comm (V W : G →ᵇ H) : cross V W = cross W V := by
  ext x; exact real_inner_comm _ _

omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in
lemma squareNorm_add (V W : G →ᵇ H) :
    squareNorm (V+W) = squareNorm V + squareNorm W + (2 : ℝ) • cross V W := by
  ext x
  simp only [squareNorm_apply, BoundedContinuousFunction.add_apply,
    BoundedContinuousFunction.smul_apply, cross_apply, smul_eq_mul]
  rw [norm_add_sq_real]; ring

omit [InnerProductSpace ℝ H] [CompleteSpace H] in
lemma squareNorm_shift (V : G →ᵇ H) (g : G) :
    M.map (squareNorm (shift G g V)) = M.map (squareNorm V) :=
  M.invariant g (squareNorm V)

def correlation (V W : G →ᵇ H) : G →ᵇ ℝ :=
  BoundedContinuousFunction.ofNormedAddCommGroup
    (fun g => M.map (cross (shift G g V) W)) continuous_of_discreteTopology
    (‖V‖ * ‖W‖) (fun g => by
      rw [Real.norm_eq_abs, ← M.map_const (‖V‖ * ‖W‖)]
      apply M.abs_le
      intro x
      exact (norm_inner_le_norm (𝕜 := ℝ) _ _).trans
        (mul_le_mul (V.norm_coe_le_norm (x+g)) (W.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _)))

omit [CompleteSpace H] in
@[simp] lemma correlation_apply (V W : G →ᵇ H) (g : G) :
    M.correlation V W g = M.map (cross (shift G g V) W) := rfl

omit [CompleteSpace H] in
lemma correlation_add (V W Z : G →ᵇ H) :
    M.correlation V (W+Z) = M.correlation V W + M.correlation V Z := by
  ext g
  simp only [correlation_apply, BoundedContinuousFunction.add_apply]
  rw [← map_add]
  congr 1; ext x
  simp only [cross_apply, BoundedContinuousFunction.add_apply, inner_add_right]

omit [CompleteSpace H] in
lemma correlation_zero (V : G →ᵇ H) : M.correlation V 0 = 0 := by
  ext g
  change M.map (cross (shift G g V) (0 : G →ᵇ H)) = 0
  have he : cross (shift G g V) (0 : G →ᵇ H) = 0 := by ext; simp
  rw [he, map_zero]

omit [CompleteSpace H] in
lemma correlation_shift (V W : G →ᵇ H) (g : G) :
    M.correlation V (shift G g W) = shift G (-g) (M.correlation V W) := by
  ext h
  change M.map (cross (shift G h V) (shift G g W)) =
    M.map (cross (shift G (h+-g) V) W)
  rw [← M.invariant (-g) (cross (shift G h V) (shift G g W))]
  congr 1; ext x
  simp only [shift_apply, cross_apply]
  congr 2 <;> abel

/-- Invariant-mean van der Corput: positivity and finite translates suffice.
There is no exchange of iterated means. -/
theorem vector_eq_zero_of_correlation_nonpos (V : G →ᵇ H)
    (hc : M.map (M.correlation V V) ≤ 0) : M.vector V = 0 := by
  classical
  let C : ℝ := M.map (squareNorm V) + 2
  have hC : 0 < C := by
    have := M.positive (squareNorm V) (fun x => by rw [squareNorm_apply]; positivity)
    dsimp [C]; linarith
  have hW (n : ℕ) : ∃ W : G →ᵇ H, M.vector W = (n : ℝ) • M.vector V ∧
      M.map (M.correlation V W) ≤ 0 ∧ M.map (squareNorm W) ≤ (n : ℝ)*C := by
    induction n with
    | zero =>
      refine ⟨0, ?_, ?_, ?_⟩
      · have he : M.vector (0 : G →ᵇ H) = 0 := by
          apply ext_inner_right ℝ; intro v
          rw [M.vector_pair, inner_zero_left]
          have he : pairing (0 : G →ᵇ H) v = 0 := by ext; simp
          rw [he, map_zero]
        simpa using he
      · simp [M.correlation_zero]
      · have he : squareNorm (0 : G →ᵇ H) = 0 := by ext; simp
        simp [he]
    | succ n ih =>
      obtain ⟨W, hv, hwc, hwe⟩ := ih
      obtain ⟨g, hg⟩ := M.exists_lt (lt_of_le_of_lt hwc zero_lt_one)
      refine ⟨W+shift G g V, ?_, ?_, ?_⟩
      · rw [M.vector_add, M.vector_shift, hv]
        simp [Nat.cast_add, add_smul]
      · rw [M.correlation_add, map_add, M.correlation_shift, M.invariant]
        linarith
      · rw [squareNorm_add, map_add, map_add, map_smul, M.squareNorm_shift,
          cross_comm W _, ← M.correlation_apply V W g]
        have hn : ((n+1 : ℕ) : ℝ) = (n : ℝ)+1 := by simp
        rw [hn]
        dsimp [C] at *
        change M.map (squareNorm W) + M.map (squareNorm V) + 2 * M.correlation V W g ≤
          ((n : ℝ)+1) * (M.map (squareNorm V) + 2)
        change M.correlation V W g < 1 at hg
        nlinarith
  have hn (n : ℕ) (hp : 0 < n) : (n : ℝ) * ‖M.vector V‖^2 ≤ C := by
    obtain ⟨W, hw, _, he⟩ := hW n
    have hj := (M.jensen W).trans he
    rw [hw, norm_smul, Real.norm_natCast] at hj
    have hnr : 0 < (n : ℝ) := by exact_mod_cast hp
    apply (mul_le_mul_iff_right₀ hnr).mp
    nlinarith
  by_contra hv
  have hnorm : 0 < ‖M.vector V‖^2 := sq_pos_of_pos (norm_pos_iff.mpr hv)
  obtain ⟨n, hn'⟩ := exists_nat_gt (max 0 (C / ‖M.vector V‖^2))
  have hn0 : 0 < n := by exact_mod_cast (lt_of_le_of_lt (le_max_left _ _) hn')
  have hratio := lt_of_le_of_lt (le_max_right _ _) hn'
  have hbad := (div_lt_iff₀ hnorm).mp hratio
  have hgood := hn n hn0
  linarith

end

open scoped BoundedContinuousFunction
variable {G : Type*} [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G]
variable (M : Mean G)
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]

def orbit (U : G → H ≃ₗᵢ[ℝ] H) (v : H) : G →ᵇ H :=
  BoundedContinuousFunction.ofNormedAddCommGroup (fun g => U g v)
    continuous_of_discreteTopology ‖v‖ (fun g => le_of_eq ((U g).norm_map v))

omit [AddCommGroup G] [CompleteSpace H] in
@[simp] lemma orbit_apply (U : G → H ≃ₗᵢ[ℝ] H) (v : H) (g : G) : orbit U v g = U g v := rfl

lemma vector_orbit_invariant (U : G → H ≃ₗᵢ[ℝ] H)
    (hU : ∀ g h v, U (g+h) v = U g (U h v)) (v : H) (g : G) :
    U g (M.vector (orbit U v)) = M.vector (orbit U v) := by
  change (U g).toLinearIsometry.toContinuousLinearMap (M.vector (orbit U v)) = _
  rw [← M.vector_map (U g).toLinearIsometry.toContinuousLinearMap]
  have he : (U g).toLinearIsometry.toContinuousLinearMap.compLeftContinuousBounded G (orbit U v) =
      shift G g (orbit U v) := by
    ext h
    change U g (U h v) = U (h+g) v
    rw [add_comm h g, hU]
  rw [he, M.vector_shift]

lemma vector_orbit_pair_fixed (U : G → H ≃ₗᵢ[ℝ] H) (v w : H)
    (hw : ∀ g, U g w = w) : inner ℝ (M.vector (orbit U v)) w = inner ℝ v w := by
  rw [M.vector_pair]
  have he : pairing (orbit U v) w = BoundedContinuousFunction.const G (inner ℝ v w) := by
    ext g
    change inner ℝ (U g v) w = inner ℝ v w
    calc
      inner ℝ (U g v) w = inner ℝ (U g v) (U g w) := by rw [hw g]
      _ = inner ℝ v w := (U g).inner_map_map v w
  rw [he, M.map_const]

/-- The mean ergodic projection criterion, valid for every positive invariant
mean and without an assumption that the group has a distinguished generator. -/
theorem vector_orbit_eq_zero (U : G → H ≃ₗᵢ[ℝ] H)
    (hU : ∀ g h v, U (g+h) v = U g (U h v)) (v : H)
    (hv : ∀ w, (∀ g, U g w = w) → inner ℝ v w = 0) :
    M.vector (orbit U v) = 0 := by
  have hf := M.vector_orbit_invariant U hU v
  have hi := M.vector_orbit_pair_fixed U v (M.vector (orbit U v)) hf
  rw [hv _ hf] at hi
  exact inner_self_eq_zero.mp hi

end EuclideanFiveColor.Amenable.Mean

namespace EuclideanFiveColor.Amenable.Koopman
open MeasureTheory Filter
section Action
variable {G X E : Type*} [AddCommGroup G] [MeasurableSpace X]
  [AddAction G X] [MeasurableConstVAdd G X] (μ : Measure X)
  [VAddInvariantMeasure G X μ]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E]

def linear (g : G) : Lp E 2 μ →ₗᵢ[ℝ] Lp E 2 μ :=
  Lp.compMeasurePreservingₗᵢ ℝ (fun x => g +ᵥ x) (measurePreserving_vadd g μ)

lemma linear_add (g h : G) (f : Lp E 2 μ) :
    linear μ (g+h) f = linear μ g (linear μ h f) := by
  change Lp.compMeasurePreserving (fun x => (g+h) +ᵥ x) _ f =
    Lp.compMeasurePreserving (fun x => g +ᵥ x) _
      (Lp.compMeasurePreserving (fun x => h +ᵥ x) _ f)
  have he : (fun x : X => (g+h) +ᵥ x) =
      (fun x => h +ᵥ x) ∘ (fun x => g +ᵥ x) := by
    funext x
    simp only [Function.comp_apply, ← add_vadd, add_comm]
  simpa only [he] using Lp.compMeasurePreserving_comp_apply f
    (measurePreserving_vadd h μ) (measurePreserving_vadd g μ)

@[simp] lemma linear_zero (f : Lp E 2 μ) : linear μ (0 : G) f = f := by
  change Lp.compMeasurePreserving (fun x => (0 : G) +ᵥ x) _ f = f
  have he : (fun x : X => (0 : G) +ᵥ x) = id := funext (fun x => zero_vadd G x)
  simpa only [he] using Lp.compMeasurePreserving_id_apply f

def action (g : G) : Lp E 2 μ ≃ₗᵢ[ℝ] Lp E 2 μ :=
  LinearIsometryEquiv.ofSurjective (linear μ g) (fun f =>
    ⟨linear μ (-g) f, by rw [← linear_add, add_neg_cancel, linear_zero]⟩)

@[simp] lemma action_apply (g : G) (f : Lp E 2 μ) : action μ g f = linear μ g f := rfl

lemma action_add (g h : G) (f : Lp E 2 μ) :
    action μ (g+h) f = action μ g (action μ h f) := linear_add μ g h f

lemma coe_action (g : G) (f : Lp E 2 μ) :
    action μ g f =ᵐ[μ] (fun x => f (g +ᵥ x)) :=
  Lp.coeFn_compMeasurePreserving f (measurePreserving_vadd g μ)

end Action

variable {G X E : Type*} [AddCommGroup G] [MeasurableSpace X]
  [AddAction G X] [MeasurableConstVAdd G X] (μ : Measure X)
  [IsProbabilityMeasure μ] [ErgodicVAdd G X μ]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
  [MeasurableSpace E] [BorelSpace E] [MeasurableSpace.CountablySeparated E]

omit [IsProbabilityMeasure μ] [CompleteSpace E] in
lemma ae_eq_const_of_fixed (f : Lp E 2 μ)
    (hf : ∀ g : G, action μ g f = f) : ∃ c : E, f =ᵐ[μ] fun _ => c := by
  apply exists_eventuallyEq_const_of_forall_separating MeasurableSet
  intro A hA
  have := ErgodicVAdd.aeconst_of_forall_preimage_vadd_ae_eq (G := G)
    ((Lp.stronglyMeasurable f).measurable hA) (fun g => by
      have ha := coe_action μ g f
      rw [hf g] at ha
      exact ha.symm.mono (fun x hx =>
        propext (show f (g +ᵥ x) ∈ A ↔ f x ∈ A by change f (g +ᵥ x) = f x at hx; rw [hx])))
  exact eventuallyEmptyOrUniv_iff.mp this

lemma inner_fixed_zero (v : Lp E 2 μ)
    (hv : ∫ x, v x ∂μ = 0) (w : Lp E 2 μ) (hw : ∀ g : G, action μ g w = w) :
    inner ℝ v w = 0 := by
  obtain ⟨c, hc⟩ := ae_eq_const_of_fixed (G := G) μ w hw
  rw [L2.inner_def]
  calc
    (∫ x, inner ℝ (v x) (w x) ∂μ) = ∫ x, inner ℝ c (v x) ∂μ :=
      integral_congr_ae (hc.mono (fun x hx => by dsimp only at hx ⊢; rw [hx, real_inner_comm]))
    _ = inner ℝ c (∫ x, v x ∂μ) := integral_inner ((Lp.memLp v).integrable (by norm_num)) c
    _ = 0 := by rw [hv, inner_zero_right]

variable [TopologicalSpace G] [DiscreteTopology G]

theorem vector_orbit_zero (M : Mean G) (v : Lp E 2 μ)
    (hv : ∫ x, v x ∂μ = 0) : M.vector (H := Lp E 2 μ) (Mean.orbit (action (G := G) (E := E) μ) v) = 0 :=
by
  apply M.vector_orbit_eq_zero (H := Lp E 2 μ) (action (G := G) (E := E) μ)
    (action_add (G := G) (E := E) μ) v
  exact inner_fixed_zero (G := G) (E := E) μ v hv

end EuclideanFiveColor.Amenable.Koopman

end

end OAI