import Mathlib
import OAI.Combinatorics.IndependentSets.Geometry.PatternInvariant
import OAI.Combinatorics.IndependentSets.Reduction.Circle

namespace OAI

namespace LargeIndependentSets
open MeasureTheory Set ProductAveraging
open scoped BigOperators Classical NNReal

theorem arbitrary_real_junta (L : ℝ≥0) {u : ℝ} (hu : 0 < u) :
    ∃ J : ℕ, 1 ≤ J ∧ ∀ (ι : Type) [Fintype ι] [DecidableEq ι],
      ∀ f : (ι → ℝ) → ℝ, LipschitzWith L f → (∀ x, |f x| ≤ 1) →
      ∃ S : Finset ι, S.card ≤ J ∧
        (∫ x, (f x-average BooleanJunta.unitLaw S f x)^2
          ∂Measure.pi (fun _ : ι => BooleanJunta.unitLaw)) < u := by
  obtain ⟨J,hJ,H⟩ := BooleanJunta.real_cube_junta_uniform L hu
  refine ⟨J,hJ,?_⟩
  intro ι _ _ f hf hb
  let e : Fin (Fintype.card ι) ≃ ι := (Fintype.equivFin ι).symm
  let g := f ∘ reindex (α:=ℝ) e
  have hg : LipschitzWith L g := by simpa only [mul_one] using hf.comp (reindex_lipschitz e)
  obtain ⟨S,hS,hi,he⟩ := H _ g hg (fun x => hb _)
  refine ⟨S.image e,(Finset.card_image_le).trans hS,?_⟩
  have ham := average_measurable BooleanJunta.unitLaw (S.image e) hf.continuous.measurable
  have h := integral_preserving (reindex_preserving BooleanJunta.unitLaw e)
    ((hf.continuous.measurable.sub ham).pow_const 2).aestronglyMeasurable
  have hp (x : Fin (Fintype.card ι) → ℝ) :
      (f (reindex e x)-average BooleanJunta.unitLaw (S.image e) f (reindex e x))^2 =
      (g x-average BooleanJunta.unitLaw S g x)^2 := by
    rw [← average_reindex BooleanJunta.unitLaw e S hf.continuous.measurable]
    rfl
  change (∫ x, (f (reindex e x)-average BooleanJunta.unitLaw (S.image e) f (reindex e x))^2
    ∂Measure.pi (fun _ : Fin (Fintype.card ι) => BooleanJunta.unitLaw)) =
    (∫ x, (f x-average BooleanJunta.unitLaw (S.image e) f x)^2
      ∂Measure.pi (fun _ : ι => BooleanJunta.unitLaw)) at h
  simp only [hp] at h
  rw [← h]
  exact he
end LargeIndependentSets

namespace LargeIndependentSets.PhaseTest
open MeasureTheory Set
open scoped BigOperators Classical NNReal
abbrev Circle := AddCircle (1:ℝ)
instance circleProbability : IsProbabilityMeasure (volume : Measure Circle) where
  measure_univ := by simp [Circle]
noncomputable def rotationLaw : Measure ℝ := volume.restrict (Ico 0 1)
instance rotationProbability : IsProbabilityMeasure rotationLaw where
  measure_univ := by simp [rotationLaw]
noncomputable def representative (x : Circle) : ℝ := (AddCircle.equivIco (1:ℝ) 0 x).val
lemma representative_mem (x : Circle) : representative x ∈ Ico (0:ℝ) 1 := by
  simpa [representative] using (AddCircle.equivIco (1:ℝ) 0 x).property
lemma representative_measurable : Measurable representative :=
  measurable_subtype_coe.comp (AddCircle.measurableEquivIco (1:ℝ) 0).measurable
lemma representative_coe (x : Circle) : (representative x : Circle) = x := AddCircle.coe_equivIco
lemma representative_eq {x : ℝ} (hx : x ∈ Ico (0:ℝ) 1) : representative (x : Circle) = x := by
  have h := AddCircle.equivIco_coe_eq (p:=(1:ℝ)) (a:=0) (x:=x) (by simpa using hx)
  exact congrArg Subtype.val h
lemma quotient_preserving : MeasurePreserving (fun x : ℝ => (x : Circle)) rotationLaw volume := by
  have h := AddCircle.measurePreserving_mk (1:ℝ) 0
  simpa only [zero_add, restrict_Ioc_eq_restrict_Icc, rotationLaw,
    restrict_Ico_eq_restrict_Icc] using h
lemma representative_preserving : MeasurePreserving representative volume rotationLaw := by
  refine ⟨representative_measurable,?_⟩
  rw [← quotient_preserving.map_eq, Measure.map_map representative_measurable quotient_preserving.measurable]
  have he : (fun x : ℝ => representative (x : Circle)) =ᵐ[rotationLaw] id := by
    filter_upwards [ae_restrict_mem measurableSet_Ico] with x hx
    exact representative_eq hx
  change Measure.map (fun x : ℝ => representative (x : Circle)) rotationLaw = rotationLaw
  rw [Measure.map_congr he, Measure.map_id]
noncomputable def rotate (z : Circle) (x : ℝ) : ℝ := representative ((x : Circle)+z)
lemma rotate_preserving (z : Circle) : MeasurePreserving (rotate z) rotationLaw rotationLaw :=
  representative_preserving.comp ((measurePreserving_add_right volume z).comp quotient_preserving)
lemma rotate_coe (z : Circle) (x : ℝ) : ((rotate z x : ℝ) : Circle) = (x : Circle)+z := representative_coe _

variable {ι : Type*} [Fintype ι] [DecidableEq ι]
variable {M : ι → Type*} [∀ i, Fintype (M i)]
variable {κ τ : Type*}

noncomputable def phase (p : ∀ j, κ → M j) (t : ι → ℝ) (θ : (Sigma M) → ℝ) : κ → Circle :=
  fun k => ∑ j, ((t j * θ ⟨j,p j k⟩ : ℝ) : Circle)
noncomputable def auxiliary (p : ∀ j, κ → M j) (r : κ → τ) (a : τ → ι)
    (t : ι → ℝ) (θ : Sigma M → ℝ) (z : ι → Circle) : κ → Circle :=
  fun k => z (a (r k)) + phase p t θ k
noncomputable def blockShift (q : ∀ j, M j → τ) (a : τ → ι) (j : ι)
    (z : ι → Circle) (θ : Sigma M → ℝ) : Sigma M → ℝ :=
  fun c => if c.1 = j then rotate (z (a (q c.1 c.2))) (θ c) else θ c

lemma blockShift_preserving (q : ∀ j, M j → τ) (a : τ → ι) (j : ι) (z : ι → Circle) :
    MeasurePreserving (blockShift q a j z)
      (Measure.pi (fun _ : Sigma M => rotationLaw)) (Measure.pi (fun _ : Sigma M => rotationLaw)) := by
  apply measurePreserving_pi (fun _ : Sigma M => rotationLaw) (fun _ : Sigma M => rotationLaw)
    (f:=fun c x => if c.1 = j then rotate (z (a (q c.1 c.2))) x else x)
  intro c
  by_cases hc : c.1 = j
  · simpa only [blockShift, hc, ↓reduceIte] using rotate_preserving (z (a (q c.1 c.2)))
  · simp only [hc, ↓reduceIte]
    exact ⟨measurable_id, Measure.map_id⟩

omit [∀ index, Fintype (M index)] in
lemma full_block_absorption (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
    (hc : ∀ j k, q j (p j k) = r k) (a : τ → ι) (j : ι)
    (t : ι → ℝ) (ht : t j = 1) (θ : Sigma M → ℝ) (z : ι → Circle) :
    phase p t (blockShift q a j z θ) = auxiliary p r a t θ z := by
  funext k
  unfold phase auxiliary
  change (∑ l, ((t l * blockShift q a j z θ ⟨l,p l k⟩ : ℝ) : Circle)) =
    z (a (r k)) + ∑ l, ((t l * θ ⟨l,p l k⟩ : ℝ) : Circle)
  calc
    _ = ∑ l, (((t l * θ ⟨l,p l k⟩ : ℝ) : Circle) + if l=j then z (a (r k)) else 0) := by
      apply Finset.sum_congr rfl
      intro l _
      by_cases hl : l = j
      · subst l
        simp only [blockShift, ↓reduceIte, ht, one_mul, rotate_coe, hc]
      · simp only [blockShift, hl, ↓reduceIte, add_zero]
    _ = _ := by rw [Finset.sum_add_distrib]; simp [add_comm]

lemma absorption_integral [Fintype κ] (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
    (hc : ∀ j k, q j (p j k) = r k) (a : τ → ι) (j : ι)
    (t : ι → ℝ) (ht : t j = 1) (z : ι → Circle)
    (F : (κ → Circle) → ℝ) (hF : Measurable F) :
    (∫ θ, F (auxiliary p r a t θ z) ∂Measure.pi (fun _ : Sigma M => rotationLaw)) =
      ∫ θ, F (phase p t θ) ∂Measure.pi (fun _ : Sigma M => rotationLaw) := by
  have hp : Measurable (phase p t) := by
    apply Measurable.of_eval
    intro k
    exact Finset.measurable_sum _ (fun l _ => quotient_preserving.measurable.comp
      (measurable_const.mul (measurable_pi_apply (⟨l,p l k⟩ : Sigma M))))
  have he (θ : Sigma M → ℝ) : F (auxiliary p r a t θ z) = F (phase p t (blockShift q a j z θ)) := by
    rw [full_block_absorption p q r hc a j t ht]
  simp_rw [he]
  exact ProductAveraging.integral_preserving (blockShift_preserving q a j z) (hF.comp hp).aestronglyMeasurable

omit [DecidableEq ι] [∀ index, Fintype (M index)] in
lemma auxiliary_lipschitz [Fintype κ] (p : ∀ j, κ → M j) (r : κ → τ) (a : τ → ι)
    (t : ι → ℝ) (θ : Sigma M → ℝ) : LipschitzWith 1 (auxiliary p r a t θ) := by
  apply LipschitzWith.of_dist_le_mul
  intro z w
  simp only [NNReal.coe_one, one_mul]
  apply (dist_pi_le_iff dist_nonneg).mpr
  intro k
  simpa only [auxiliary, dist_add_right] using dist_le_pi_dist z w (a (r k))

omit [DecidableEq ι] [∀ index, Fintype (M index)] in
lemma auxiliary_mean_zero [Fintype κ] (p : ∀ j, κ → M j) (r : κ → τ) (a : τ → ι)
    (t : ι → ℝ) (θ : Sigma M → ℝ) (F : (κ → Circle) → ℝ)
    (hF : Measurable F) (hodd : ∀ x, F (fun k => x k + ((1/2:ℝ):Circle)) = -F x) :
    (∫ z, F (auxiliary p r a t θ z)) = 0 := by
  let v : ι → Circle := fun _ => ((1/2:ℝ):Circle)
  have hm := hF.comp (auxiliary_lipschitz p r a t θ).continuous.measurable
  have he (z : ι → Circle) : F (auxiliary p r a t θ (z+v)) = -F (auxiliary p r a t θ z) := by
    convert hodd (auxiliary p r a t θ z) using 1
    congr 1
    funext k
    simp [auxiliary, v, add_assoc, add_comm, add_left_comm]
  have hp := ProductAveraging.integral_preserving (measurePreserving_add_right (volume : Measure (ι→Circle)) v)
    hm.aestronglyMeasurable
  change (∫ z, F (auxiliary p r a t θ (z+v))) = (∫ z, F (auxiliary p r a t θ z)) at hp
  simp only [he, integral_neg] at hp
  linarith
end LargeIndependentSets.PhaseTest

end OAI