import Mathlib
import OAI.Geometry.SmoothYau.NodalMeasure.ExtrusionEquiv
import OAI.Geometry.SmoothYau.Spectrum.StdGaussianMapInnerUnit
import OAI.Geometry.SmoothYau.SphereMetric.UnitCorrelation

namespace OAI

noncomputable section
namespace YauCounterexamples
section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set MeasureTheory ProbabilityTheory
open scoped ENNReal

lemma complex_stdGaussian_eq_map :
    stdGaussian ℂ = (Measure.pi (fun _ : Fin 2 => gaussianReal 0 1)).map
      (fun x => (x 0 : ℂ)+(x 1 : ℂ)*Complex.I) := by
  simpa [Complex.coe_orthonormalBasisOneI,Fin.sum_univ_two,Algebra.smul_def]
    using stdGaussian_eq_map_pi_orthonormalBasis Complex.orthonormalBasisOneI

lemma complex_gaussian_pair :
    MeasurePreserving (fun x : ℝ × ℝ => (x.1 : ℂ)+(x.2 : ℂ)*Complex.I)
      ((gaussianReal 0 1).prod (gaussianReal 0 1)) (stdGaussian ℂ) := by
  have hp := (measurePreserving_piFinTwo (fun _ : Fin 2 => gaussianReal 0 1)).symm
  have hm : MeasurePreserving (fun x : Fin 2 → ℝ => (x 0 : ℂ)+(x 1 : ℂ)*Complex.I)
      (Measure.pi (fun _ : Fin 2 => gaussianReal 0 1)) (stdGaussian ℂ) :=
    ⟨by fun_prop,complex_stdGaussian_eq_map.symm⟩
  exact hm.comp hp

lemma gaussian_complex_rotation (e : Circle) :
    MeasurePreserving (fun z : ℂ => (e : ℂ)*z) (stdGaussian ℂ) (stdGaussian ℂ) :=
  ⟨(rotation e).continuous.measurable,stdGaussian_map (rotation e)⟩

lemma gaussian_complex_conj :
    MeasurePreserving (starRingEnd ℂ) (stdGaussian ℂ) (stdGaussian ℂ) :=
  ⟨Complex.continuous_conj.measurable,stdGaussian_map Complex.conjLIE⟩

lemma gaussian_complex_pi_rotation {ι : Type*} [Fintype ι] (e : ι → Circle) :
    MeasurePreserving (fun z : ι → ℂ => fun i => (e i : ℂ)*z i)
      (Measure.pi (fun _ : ι => stdGaussian ℂ)) (Measure.pi (fun _ : ι => stdGaussian ℂ)) :=
  measurePreserving_pi _ _ (fun i => gaussian_complex_rotation (e i))

lemma gaussian_complex_from_real_parts {ι : Type*} [Fintype ι] :
    MeasurePreserving (fun x : (ι ⊕ ι) → ℝ =>
      fun i => (x (.inl i) : ℂ)-(x (.inr i) : ℂ)*Complex.I)
      (Measure.pi (fun _ : ι ⊕ ι => gaussianReal 0 1))
      (Measure.pi (fun _ : ι => stdGaussian ℂ)) := by
  have hsplit := measurePreserving_sumPiEquivProdPi (fun _ : ι ⊕ ι => gaussianReal 0 1)
  have hpair := (measurePreserving_arrowProdEquivProdArrow ℝ ℝ ι
    (fun _ => gaussianReal 0 1) (fun _ => gaussianReal 0 1)).symm
  have hc := gaussian_complex_conj.comp complex_gaussian_pair
  have hpi := measurePreserving_pi (fun _ : ι => (gaussianReal 0 1).prod (gaussianReal 0 1))
    (fun _ : ι => stdGaussian ℂ) (fun _ => hc)
  convert hpi.comp (hpair.comp hsplit) using 1
  ext x i
  simp [Function.comp_def,MeasurableEquiv.sumPiEquivProdPi,
    MeasurableEquiv.arrowProdEquivProdArrow, Complex.conj_ofReal,sub_eq_add_neg]

def selectedCoefficientOrder : (Fin 3 ⊕ Fin 3) ≃ (Fin 2 ⊕ (Fin 1 ⊕ Fin 3)) where
  toFun := Sum.elim
    (fun i => ![Sum.inr (Sum.inl 0),Sum.inl 0,Sum.inr (Sum.inr 0)] i)
    (fun i => ![Sum.inr (Sum.inr 1),Sum.inr (Sum.inr 2),Sum.inl 1] i)
  invFun := Sum.elim
    (fun i => ![Sum.inl 1,Sum.inr 2] i)
    (Sum.elim (fun _ => Sum.inl 0) (fun i => ![Sum.inl 2,Sum.inr 0,Sum.inr 1] i))
  left_inv := by intro i; rcases i with i|i <;> fin_cases i <;> rfl
  right_inv := by
    intro i; rcases i with i|i
    · fin_cases i <;> rfl
    · rcases i with i|i <;> fin_cases i <;> rfl

def selectedComplexCoefficients (v : (Fin 2 → ℝ) × ((Fin 1 ⊕ Fin 3) → ℝ)) : Fin 3 → ℂ :=
  ![(v.2 (.inl 0) : ℂ)-(v.2 (.inr 1) : ℂ)*Complex.I,
    (v.1 0 : ℂ)-(v.2 (.inr 2) : ℂ)*Complex.I,
    (v.2 (.inr 0) : ℂ)-(v.1 1 : ℂ)*Complex.I]

lemma selectedComplexCoefficients_law :
    MeasurePreserving selectedComplexCoefficients
      ((Measure.pi (fun _ : Fin 2 => gaussianReal 0 1)).prod
        (Measure.pi (fun _ : Fin 1 ⊕ Fin 3 => gaussianReal 0 1)))
      (Measure.pi (fun _ : Fin 3 => stdGaussian ℂ)) := by
  have hsplit := measurePreserving_sumPiEquivProdPi_symm
    (fun _ : Fin 2 ⊕ (Fin 1 ⊕ Fin 3) => gaussianReal 0 1)
  have hreorder := measurePreserving_piCongrLeft
    (fun _ : Fin 3 ⊕ Fin 3 => gaussianReal 0 1) selectedCoefficientOrder.symm
  have h := gaussian_complex_from_real_parts.comp (hreorder.comp hsplit)
  convert h using 1
  ext v i
  fin_cases i <;> rfl


end

section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology ENNReal
open MeasureTheory ProbabilityTheory
open scoped RealInnerProductSpace
open scoped RealInnerProductSpace
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

theorem stdGaussian_opposite_eq (a b : E) (ha : ‖a‖ = 1) (hb : ‖b‖ = 1)
    (hρ : |⟪a, b⟫| < 1) (m₁ m₂ : ℝ) :
    (stdGaussian E) {x | (m₁ + ⟪a, x⟫) * (m₂ + ⟪b, x⟫) < 0} =
      gaussianPairOppositeProbability (⟪a, b⟫, m₁, m₂) := by
  let ρ := ⟪a, b⟫
  let s := Real.sqrt (1 - ρ ^ 2)
  let c := s⁻¹ • (b - ρ • a)
  obtain ⟨hc, hac, hbc⟩ := correlated_pair_orthogonal a b ha hb hρ
  change ‖c‖ = 1 at hc
  change ⟪a, c⟫ = 0 at hac
  change b = ρ • a + s • c at hbc
  let S : Set (ℝ × ℝ) := {z | (m₁ + z.1) * (m₂ + ρ * z.1 + s * z.2) < 0}
  have hS : MeasurableSet S :=
    measurableSet_lt (by fun_prop) measurable_const
  let F : E → ℝ × ℝ := fun x => (⟪a, x⟫, ⟪c, x⟫)
  have hF : Measurable F := by dsimp only [F]; fun_prop
  have hset : {x | (m₁ + ⟪a, x⟫) * (m₂ + ⟪b, x⟫) < 0} = F ⁻¹' S := by
    ext x
    simp only [Set.mem_ofPred_eq, Set.mem_preimage, F, S]
    rw [hbc]
    simp only [inner_add_left, real_inner_smul_left, add_assoc]
  rw [hset, ← Measure.map_apply hF hS]
  change ((stdGaussian E).map (fun x => (⟪a, x⟫, ⟪c, x⟫))) S = _
  rw [stdGaussian_map_orthonormal_pair a c ha hc hac,
    ← (measurePreserving_piFinTwo (fun _ : Fin 2 => gaussianReal 0 1)).map_eq,
    Measure.map_apply (MeasurableEquiv.piFinTwo (fun _ : Fin 2 => ℝ)).measurable hS]
  rfl

theorem gaussian_wave_opposite_uniform (α β M : ℝ) (hα : -1 < α) (hαβ : α ≤ β)
    (hβ : β < 1) (hM : 0 ≤ M) :
    ∃ q : ℝ, 0 < q ∧ ∀ (a b : E) (m₁ m₂ : ℝ),
      ‖a‖ = 1 → ‖b‖ = 1 → α ≤ ⟪a, b⟫ → ⟪a, b⟫ ≤ β →
      |m₁| ≤ M → |m₂| ≤ M →
      ENNReal.ofReal q ≤ (stdGaussian E)
        {x | (m₁ + ⟪a, x⟫) * (m₂ + ⟪b, x⟫) < 0} := by
  obtain ⟨q, hq, h⟩ := gaussian_opposite_uniform α β M hα hαβ hβ hM
  refine ⟨q, hq, ?_⟩
  intro a b m₁ m₂ ha hb hlo hhi hm₁ hm₂
  rw [stdGaussian_opposite_eq a b ha hb (abs_lt.mpr ⟨hα.trans_le hlo, hhi.trans_lt hβ⟩)]
  exact h (⟪a, b⟫, m₁, m₂) hlo hhi hm₁ hm₂


end


open Set MeasureTheory ProbabilityTheory
open scoped ENNReal RealInnerProductSpace
variable {I : Type*} [Fintype I]

def complexGaussianRealValue (z : I → ℂ) (γ : I → ℂ) : ℝ :=
  ∑ i, (γ i*z i).re

lemma complexGaussianRealValue_real_parts (z : I → ℂ) (x : (I ⊕ I) → ℝ) :
    complexGaussianRealValue z (fun i => (x (.inl i) : ℂ)-(x (.inr i) : ℂ)*Complex.I) =
      ⟪complexValueVector z,WithLp.toLp 2 x⟫ := by
  simp only [complexGaussianRealValue,PiLp.inner_apply,complexValueVector,
    Fintype.sum_sum_type, RCLike.inner_apply]
  simp only [Sum.elim_inl,Sum.elim_inr,starRingEnd_apply,star_trivial]
  simp only [Complex.mul_re,Complex.sub_re,Complex.ofReal_re,Complex.I_re,Complex.ofReal_im,
    Complex.I_im,mul_zero,sub_zero,Complex.sub_im,Complex.mul_im,mul_one,
    add_zero,zero_sub,neg_mul,sub_neg_eq_add, Finset.sum_add_distrib]

lemma complex_gaussian_standardized_sign_law (z w : I → ℂ)
    (hz : complexValueVector z ≠ 0) (hw : complexValueVector w ≠ 0)
    (m₁ m₂ : ℝ) (hρ : |unitCorrelation (complexValueVector z) (complexValueVector w)| < 1) :
    (Measure.pi (fun _ : I => stdGaussian ℂ))
      {γ | (m₁+complexGaussianRealValue z γ)*(m₂+complexGaussianRealValue w γ) < 0} =
      gaussianPairOppositeProbability (unitCorrelation (complexValueVector z) (complexValueVector w),
        m₁/‖complexValueVector z‖,m₂/‖complexValueVector w‖) := by
  let a := complexValueVector z
  let b := complexValueVector w
  have ha : 0 < ‖a‖ := norm_pos_iff.mpr hz
  have hb : 0 < ‖b‖ := norm_pos_iff.mpr hw
  let S : Set (I → ℂ) :=
    {γ | (m₁+complexGaussianRealValue z γ)*(m₂+complexGaussianRealValue w γ) < 0}
  have hS : MeasurableSet S := by
    apply measurableSet_lt _ measurable_const
    dsimp [complexGaussianRealValue]; fun_prop
  rw [←gaussian_complex_from_real_parts.map_eq,Measure.map_apply
    gaussian_complex_from_real_parts.measurable hS]
  let T : Set (EuclideanSpace ℝ (I ⊕ I)) :=
    {x | (m₁/‖a‖+⟪‖a‖⁻¹ • a,x⟫)*(m₂/‖b‖+⟪‖b‖⁻¹ • b,x⟫) < 0}
  have hset : (fun x : (I ⊕ I) → ℝ => fun i =>
      (x (.inl i) : ℂ)-(x (.inr i) : ℂ)*Complex.I) ⁻¹' S =
        (WithLp.toLp 2) ⁻¹' T := by
    ext x
    simp only [S,T,Set.mem_preimage,Set.mem_ofPred_eq,complexGaussianRealValue_real_parts,
      real_inner_smul_left]
    change (m₁+⟪a,WithLp.toLp 2 x⟫)*(m₂+⟪b,WithLp.toLp 2 x⟫) < 0 ↔ _
    rw [show m₁/‖a‖+‖a‖⁻¹*⟪a,WithLp.toLp 2 x⟫ =
      (m₁+⟪a,WithLp.toLp 2 x⟫)/‖a‖ by ring,
      show m₂/‖b‖+‖b‖⁻¹*⟪b,WithLp.toLp 2 x⟫ =
      (m₂+⟪b,WithLp.toLp 2 x⟫)/‖b‖ by ring,div_mul_div_comm]
    rw [div_lt_iff₀ (mul_pos ha hb),zero_mul]
  change (Measure.pi (fun _ : I ⊕ I => gaussianReal 0 1))
      ((fun x => fun i => (x (.inl i) : ℂ)-(x (.inr i) : ℂ)*Complex.I) ⁻¹' S) = _
  rw [hset,←Measure.map_apply (PiLp.continuous_toLp 2 _).measurable
    (show MeasurableSet T by
      apply measurableSet_lt _ measurable_const
      fun_prop),map_pi_eq_stdGaussian]
  exact stdGaussian_opposite_eq _ _ (norm_normalize_vector a hz) (norm_normalize_vector b hw) hρ (m₁/‖a‖) (m₂/‖b‖)

theorem complex_gaussian_sign_uniform (α β M : ℝ) (hα : -1 < α) (hαβ : α ≤ β)
    (hβ : β < 1) (hM : 0 ≤ M) :
    ∃ q > 0, ∀ (I : Type) [Fintype I] (z w : I → ℂ) (m₁ m₂ : ℝ),
      complexValueVector z ≠ 0 → complexValueVector w ≠ 0 →
      α ≤ unitCorrelation (complexValueVector z) (complexValueVector w) →
      unitCorrelation (complexValueVector z) (complexValueVector w) ≤ β →
      |m₁/‖complexValueVector z‖| ≤ M → |m₂/‖complexValueVector w‖| ≤ M →
      ENNReal.ofReal q ≤ (Measure.pi (fun _ : I => stdGaussian ℂ))
        {γ | (m₁+complexGaussianRealValue z γ)*(m₂+complexGaussianRealValue w γ) < 0} := by
  obtain ⟨q,hq,hprob⟩ := gaussian_opposite_uniform α β M hα hαβ hβ hM
  refine ⟨q,hq,?_⟩
  intro I _ z w m₁ m₂ hz hw hlo hhi hm₁ hm₂
  rw [complex_gaussian_standardized_sign_law z w hz hw m₁ m₂
    (abs_lt.mpr ⟨hα.trans_le hlo,hhi.trans_lt hβ⟩)]
  exact hprob _ hlo hhi hm₁ hm₂


end YauCounterexamples
end

end OAI