import Mathlib
import OAI.Probability.LogConcave.LowerBounds.RoundFrames
import OAI.Probability.LogConcave.Sampling.TapeSnocEquiv

namespace OAI

section
section
noncomputable section
open MeasureTheory Filter
open scoped ENNReal NNReal Topology

section LowerProof
open Matrix Topology TopologicalSpace ProbabilityTheory Classical WithLp
open scoped Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory

namespace LogConcaveSampling.LowerBound
open MeasureTheory ProbabilityTheory
open scoped RealInnerProductSpace

lemma remainingHaar_bot (d : ℕ) : remainingHaar (⊥ : Submodule ℝ (Point d)) = rotationHaar d := by
  have hmem (P : Rotations d) : P ∈ subspaceStabilizer (⊥ : Submodule ℝ (Point d)) := by
    intro x hx
    have hx' : x = 0 := hx
    simp [hx']
  have hi : (remainingHaar (⊥ : Submodule ℝ (Point d))).IsMulLeftInvariant := by
    constructor
    intro P
    change ((subspaceHaar (⊥ : Submodule ℝ (Point d))).map Subtype.val).map (P * ·) = _
    let P' : subspaceStabilizer (⊥ : Submodule ℝ (Point d)) := ⟨P,hmem P⟩
    rw [Measure.map_map (by fun_prop) measurable_subtype_coe]
    calc
      _ = ((subspaceHaar (⊥ : Submodule ℝ (Point d))).map (P' * ·)).map Subtype.val := by
        rw [Measure.map_map measurable_subtype_coe (by fun_prop)]
        rfl
      _ = _ := by rw [map_mul_left_eq_self]; rfl
  have h := Measure.isMulInvariant_eq_smul_of_compactSpace
    (remainingHaar (⊥ : Submodule ℝ (Point d))) (rotationHaar d)
  have hmass := congrArg (fun μ : Measure (Rotations d) => μ Set.univ) h
  simp only [measure_univ, Measure.smul_apply, ENNReal.smul_def, smul_eq_mul, mul_one] at hmass
  have hc : (remainingHaar (⊥ : Submodule ℝ (Point d))).haarScalarFactor (rotationHaar d) = 1 :=
    ENNReal.coe_injective hmass.symm
  rwa [hc, one_smul] at h

def linearHistory {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ} (A : OracleAlgorithm Ω d q)
    (Λ : Point d →L[ℝ] Point d) (O : Rotations d) (ω : Ω) : ℕ → Transcript d q
  | 0 => 0
  | n+1 =>
    let h := linearHistory A Λ O ω n
    if hn : n < q then Function.update h ⟨n,hn⟩ (linearReply Λ O (A.query ⟨n,hn⟩ (ω,h))) else h

lemma measurable_linearHistory {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (n : ℕ) :
    Measurable (fun p : Ω × Rotations d => linearHistory A Λ p.2 p.1 n) := by
  induction n with
  | zero => exact measurable_const
  | succ n ih =>
    simp only [linearHistory]
    split_ifs with hn
    · have hq := (A.query_measurable ⟨n,hn⟩).comp (measurable_fst.prodMk ih)
      have hr := (measurable_linearReply Λ).comp (measurable_snd.prodMk hq)
      apply Measurable.of_eval
      intro j
      by_cases hj : j = ⟨n,hn⟩
      · subst j
        simpa only [Function.update_self, Function.comp_def] using hr
      · simpa only [Function.update_of_ne hj, Function.comp_def] using (measurable_pi_apply j).comp ih
    · exact ih

abbrev RevealState (Ω : Type*) (d q n : ℕ) :=
  Ω × Frames d × Transcript d q × (Fin n → Point d × Point d)

abbrev RoundRandom (d : ℕ) := Point d × Point d × Point d

def roundRandomLaw (d : ℕ) : Measure (RoundRandom d) :=
  (stdGaussian (Point d)).prod ((stdGaussian (Point d)).prod (stdGaussian (Point d)))

instance roundRandomLaw_probability (d : ℕ) : IsProbabilityMeasure (roundRandomLaw d) := by
  unfold roundRandomLaw
  infer_instance

def initialRevealState {Ω : Type*} {d q : ℕ} (ω : Ω) : RevealState Ω d q 0 :=
  (ω,(1,1),0,Fin.elim0)

lemma measurable_initialRevealState {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ} :
    Measurable (initialRevealState (Ω := Ω) (d := d) (q := q)) := by
  unfold initialRevealState
  fun_prop

def revealStep {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d)
    (n : ℕ) (p : RevealState Ω d q n × RoundRandom d) : RevealState Ω d q (n+1) :=
  let s := p.1
  let r := p.2
  let t := Fin.snoc (α := fun _ : Fin (n+1) => Point d × Point d) s.2.2.2 (r.1,r.2.1)
  if hn : n < q then
    let hk : 2*n+1 < d := by omega
    let x := A.query ⟨n,hn⟩ (s.1,s.2.2.1)
    let F := roundFrames hk Λ s.2.1 x r
    let u := roundCoordinate hk s.2.1 x r.1
    let reply := (⟪u,Λ u⟫ / 2,frameTransport F (Λ u))
    (s.1,F,Function.update s.2.2.1 ⟨n,hn⟩ reply,t)
  else (s.1,s.2.1,s.2.2.1,t)

lemma measurable_revealStep {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d) (n : ℕ) :
    Measurable (revealStep A Λ hd n) := by
  let Z := RevealState Ω d q n × RoundRandom d
  have hseed : Measurable (fun p : Z => p.1.1) := measurable_fst.fst
  have hframe : Measurable (fun p : Z => p.1.2.1) := measurable_fst.snd.fst
  have hhist : Measurable (fun p : Z => p.1.2.2.1) := measurable_fst.snd.snd.fst
  have htape : Measurable (fun p : Z => Fin.snoc (α := fun _ : Fin (n+1) => Point d × Point d)
      p.1.2.2.2 (p.2.1,p.2.2.1)) := measurable_fin_snoc n |>.comp
    (measurable_fst.snd.snd.snd.prodMk (measurable_snd.fst.prodMk measurable_snd.snd.fst))
  unfold revealStep
  split_ifs with hn
  · have hk : 2*n+1 < d := by omega
    let x : Z → Point d := fun p => A.query ⟨n,hn⟩ (p.1.1,p.1.2.2.1)
    have hx : Measurable x := (A.query_measurable _).comp (hseed.prodMk hhist)
    let F : Z → Frames d := fun p => roundFrames hk Λ p.1.2.1 (x p) p.2
    have hF : Measurable F := (measurable_roundFrames hk Λ).comp
      (f := fun p : Z => ((p.1.2.1,x p),p.2)) ((hframe.prodMk hx).prodMk measurable_snd)
    let u : Z → Point d := fun p => roundCoordinate hk p.1.2.1 (x p) p.2.1
    have hu : Measurable u := (measurable_roundCoordinate hk).comp
      (f := fun p : Z => ((p.1.2.1,x p),p.2.1)) ((hframe.prodMk hx).prodMk measurable_snd.fst)
    have hΛu : Measurable (fun p : Z => Λ (u p)) := Λ.continuous.measurable.comp hu
    have hreply : Measurable (fun p : Z => (⟪u p,Λ (u p)⟫ / 2,frameTransport (F p) (Λ (u p)))) :=
      ((hu.inner hΛu).div_const 2).prodMk ((measurable_frameTransport (d := d)).comp
        (f := fun p : Z => (F p,Λ (u p))) (hF.prodMk hΛu))
    have hupdate : Measurable (fun p : Z => Function.update p.1.2.2.1 ⟨n,hn⟩
        (⟪u p,Λ (u p)⟫ / 2,frameTransport (F p) (Λ (u p)))) := by
      apply Measurable.of_eval
      intro j
      by_cases hj : j = ⟨n,hn⟩
      · subst j; simpa only [Function.update_self, Function.comp_def] using hreply
      · simpa only [Function.update_of_ne hj, Function.comp_def] using (measurable_pi_apply j).comp hhist
    exact hseed.prodMk (hF.prodMk (hupdate.prodMk htape))
  · exact hseed.prodMk (hframe.prodMk (hhist.prodMk htape))

def HistoryConsistent {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (n : ℕ)
    (s : RevealState Ω d q n) : Prop :=
  ∀ H ∈ subspaceStabilizer (prefixSpace d (2*n)),
    s.2.2.1 = linearHistory A Λ (frameCompletion s.2.1 H) s.1 n

lemma initial_historyConsistent {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (ω : Ω) :
    HistoryConsistent A Λ 0 (initialRevealState ω) := by
  intro H hH
  rfl

lemma revealStep_historyConsistent {Ω : Type*} [MeasurableSpace Ω] {d q n : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d) (hn : n < q)
    (s : RevealState Ω d q n) (r : RoundRandom d) (hs : HistoryConsistent A Λ n s) :
    HistoryConsistent A Λ (n+1) (revealStep A Λ hd n (s,r)) := by
  have hk : 2*n+1 < d := by omega
  let x := A.query ⟨n,hn⟩ (s.1,s.2.2.1)
  let F := roundFrames hk Λ s.2.1 x r
  intro H hH
  have hH₂ : H ∈ subspaceStabilizer (prefixSpace d (2*n+2)) := by
    simpa only [Nat.mul_add, Nat.mul_one] using hH
  have hH₀ : H ∈ subspaceStabilizer (prefixSpace d (2*n)) :=
    subspaceStabilizer_anti (prefixSpace_mono d (by omega)) hH₂
  obtain ⟨H',hH',he⟩ := compatibleFrames_reconstruct _ (roundFrames_compatible hk Λ s.2.1 x r) hH₀
  have hh : s.2.2.1 = linearHistory A Λ (frameCompletion F H) s.1 n := by
    rw [he]
    exact hs H' hH'
  change (revealStep A Λ hd n (s,r)).2.2.1 =
    linearHistory A Λ (frameCompletion (revealStep A Λ hd n (s,r)).2.1 H)
      (revealStep A Λ hd n (s,r)).1 (n+1)
  simp only [revealStep, dite_eq_left hn, linearHistory]
  rw [← hh]
  congr 1
  exact (roundReply_correct hk Λ s.2.1 x r hH₂).symm

def completeRevealState {Ω : Type*} {d q : ℕ} (n : ℕ)
    (p : RevealState Ω d q n × Rotations d) : Ω × Rotations d :=
  (p.1.1,frameCompletion p.1.2.1 p.2)

lemma measurable_completeRevealState {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ} (n : ℕ) :
    Measurable (completeRevealState (Ω := Ω) (d := d) (q := q) n) :=
  measurable_fst.fst.prodMk ((measurable_frameCompletion (d := d)).comp
    (f := fun p : RevealState Ω d q n × Rotations d => (p.1.2.1,p.2))
    (measurable_fst.snd.fst.prodMk measurable_snd))

lemma revealStep_completion_law {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d)
    (n : ℕ) (hn : n < q) (s : RevealState Ω d q n) :
    ((roundRandomLaw d).prod (remainingHaar (prefixSpace d (2*(n+1))))).map
      (fun p => completeRevealState (n+1) (revealStep A Λ hd n (s,p.1),p.2)) =
      (remainingHaar (prefixSpace d (2*n))).map (fun h => completeRevealState n (s,h)) := by
  have hk : 2*n+1 < d := by omega
  have he := congrArg (fun ν : Measure (Rotations d) => ν.map (fun O => (s.1,O)))
    (roundFrames_law hk Λ s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)))
  have hf : Measurable (fun p : RoundRandom d × Rotations d =>
      frameCompletion (roundFrames hk Λ s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)) p.1) p.2) :=
    (measurable_frameCompletion (d := d)).comp
      (f := fun p : RoundRandom d × Rotations d =>
        (roundFrames hk Λ s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)) p.1,p.2))
      (((measurable_roundFrames hk Λ).comp
        (f := fun p : RoundRandom d × Rotations d =>
          ((s.2.1,A.query ⟨n,hn⟩ (s.1,s.2.2.1)),p.1))
        (measurable_const.prodMk measurable_fst)).prodMk measurable_snd)
  rw [Measure.map_map (by fun_prop) hf, Measure.map_map (by fun_prop) (by fun_prop)] at he
  simpa only [completeRevealState,revealStep,dite_eq_left hn,roundRandomLaw,
    Nat.mul_add,Nat.mul_one,Function.comp_def] using he

theorem revealState_completion_law {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (μ : Measure Ω) [IsProbabilityMeasure μ] (A : OracleAlgorithm Ω d q)
    (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d) :
    ((stateLaw (μ.map (initialRevealState (d := d) (q := q))) (roundRandomLaw d)
        (revealStep A Λ hd) q).prod (remainingHaar (prefixSpace d (2*q)))).map
      (completeRevealState q) = μ.prod (rotationHaar d) := by
  have hi := measurable_initialRevealState (Ω := Ω) (d := d) (q := q)
  rw [stateLaw_completion _ _ _ (measurable_revealStep A Λ hd)
    (fun n => remainingHaar (prefixSpace d (2*n)))
    (fun n => completeRevealState (Ω := Ω) (d := d) (q := q) n)
    (fun n => measurable_completeRevealState n) q
    (fun n hn s => revealStep_completion_law A Λ hd n hn s)]
  simp only [Nat.mul_zero, prefixSpace_zero, remainingHaar_bot]
  have hp := Measure.map_prod_map μ (rotationHaar d) hi measurable_id
  rw [Measure.map_id] at hp
  rw [hp,Measure.map_map (measurable_completeRevealState 0) (hi.prodMap measurable_id)]
  convert (Measure.map_id (μ := μ.prod (rotationHaar d))) using 1
  congr 1
  funext p
  simp [completeRevealState,initialRevealState,frameCompletion]

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

def finishFrame {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d)
    (p : RevealState Ω d q q × Point d) : Frames d :=
  inverseFrameUpdate hd p.1.2.1 (A.output (p.1.1,p.1.2.2.1)) p.2

lemma measurable_finishFrame {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d) : Measurable (finishFrame A hd) := by
  apply (measurable_inverseFrameUpdate hd).comp
    (f := fun p : RevealState Ω d q q × Point d =>
      (p.1.2.1,A.output (p.1.1,p.1.2.2.1),p.2))
  exact measurable_fst.snd.fst.prodMk
    ((A.output_measurable.comp (measurable_fst.fst.prodMk measurable_fst.snd.snd.fst)).prodMk measurable_snd)

def finishComplete {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d)
    (p : (RevealState Ω d q q × Point d) × Rotations d) : Ω × Rotations d :=
  (p.1.1.1,frameCompletion (finishFrame A hd p.1) p.2)

lemma measurable_finishComplete {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d) : Measurable (finishComplete A hd) := by
  exact measurable_fst.fst.fst.prodMk ((measurable_frameCompletion (d := d)).comp
    (f := fun p : (RevealState Ω d q q × Point d) × Rotations d =>
      (finishFrame A hd p.1,p.2))
    (((measurable_finishFrame A hd).comp measurable_fst).prodMk measurable_snd))

lemma finishComplete_law {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d)
    (ν : Measure (RevealState Ω d q q)) [IsProbabilityMeasure ν] :
    ((ν.prod (stdGaussian (Point d))).prod
      (remainingHaar (prefixSpace d (2*q+1)))).map (finishComplete A hd) =
      (ν.prod (remainingHaar (prefixSpace d (2*q)))).map (completeRevealState q) := by
  have hlocal (s : RevealState Ω d q q) :
      ((stdGaussian (Point d)).prod (remainingHaar (prefixSpace d (2*q+1)))).map
          (fun p => finishComplete A hd ((s,p.1),p.2)) =
        (remainingHaar (prefixSpace d (2*q))).map
          (fun h => completeRevealState q (s,h)) := by
    have he := congrArg (fun η : Measure (Rotations d) => η.map (fun O => (s.1,O)))
      (inverseFrameUpdate_law hd s.2.1 (A.output (s.1,s.2.2.1)))
    rw [Measure.map_map (by fun_prop) (by fun_prop),
      Measure.map_map (by fun_prop) (by fun_prop)] at he
    exact he
  have he := eliminate_fresh_residual (μ := ν) (γ := stdGaussian (Point d))
    (η := remainingHaar (prefixSpace d (2*q)))
    (η' := remainingHaar (prefixSpace d (2*q+1)))
    (step := id) measurable_id (measurable_finishComplete A hd)
    (measurable_completeRevealState q) hlocal
  rwa [Measure.map_id] at he

def finishCoordinate {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d)
    (p : RevealState Ω d q q × Point d) : Point d :=
  (frameTransport (finishFrame A hd p)).symm (A.output (p.1.1,p.1.2.2.1))

lemma measurable_finishCoordinate {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d) : Measurable (finishCoordinate A hd) := by
  exact (measurable_inverse_frameTransport (d := d)).comp
    (f := fun p : RevealState Ω d q q × Point d =>
      (finishFrame A hd p,A.output (p.1.1,p.1.2.2.1)))
    ((measurable_finishFrame A hd).prodMk
      (A.output_measurable.comp (measurable_fst.fst.prodMk measurable_fst.snd.snd.fst)))

lemma finishCoordinate_mem {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q < d) (p : RevealState Ω d q q × Point d)
    (hg : (prefixSpace d (2*q))ᗮ.orthogonalProjectionOnto (rotationIsometry p.1.2.1.2⁻¹ p.2) ≠ 0) :
    finishCoordinate A hd p ∈ frameSpace p.1.2.1.2 (prefixSpace d (2*q)) ⊔ ℝ ∙ p.2 := by
  have hx : A.output (p.1.1,p.1.2.2.1) ∈ frameSpace (finishFrame A hd p).1
      (prefixSpace d (2*q+1)) := by
    simp only [finishFrame,inverseFrameUpdate_eq]
    exact mem_frameSpace_extendFrame hd _ _
  have hu := frameTransport_preimage_mem _ (finishFrame A hd p) hx
  have hb := frameSpace_extendFrame_le hd p.1.2.1.2 p.2 hg
  exact hb hu

lemma finishCoordinate_correct {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q < d)
    (s : RevealState Ω d q q) (g : Point d) (hs : HistoryConsistent A Λ q s)
    {H : Rotations d} (hH : H ∈ subspaceStabilizer (prefixSpace d (2*q+1))) :
    finishCoordinate A hd (s,g) =
      (rotationIsometry (finishComplete A hd ((s,g),H)).2).symm
        (A.output (s.1,linearHistory A Λ (finishComplete A hd ((s,g),H)).2 s.1 q)) := by
  have hH₀ : H ∈ subspaceStabilizer (prefixSpace d (2*q)) :=
    subspaceStabilizer_anti (prefixSpace_mono d (Nat.le_succ _)) hH
  obtain ⟨H',hH',he⟩ := compatibleFrames_reconstruct _
    (compatibleFrames_inverseUpdate hd s.2.1 (A.output (s.1,s.2.2.1)) g) hH₀
  have hh : s.2.2.1 = linearHistory A Λ (finishComplete A hd ((s,g),H)).2 s.1 q := by
    change s.2.2.1 = linearHistory A Λ (frameCompletion (finishFrame A hd (s,g)) H) s.1 q
    rw [finishFrame,he]
    exact hs H' hH'
  rw [← hh]
  symm
  apply frameCompletion_symm_eq_transport _ (finishFrame A hd (s,g)) hH
  simp only [finishFrame,inverseFrameUpdate_eq]
  exact mem_frameSpace_extendFrame hd _ _

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound
section
variable {E : Type*} [AddCommGroup E] [Module ℝ E]

def powerHull (L : E →ₗ[ℝ] E) : ℕ → Submodule ℝ E → Submodule ℝ E
  | 0, K => K
  | n+1, K => K ⊔ (powerHull L n K).map L

lemma powerHull_mono_base (L : E →ₗ[ℝ] E) (n : ℕ) {K K' : Submodule ℝ E} (h : K ≤ K') :
    powerHull L n K ≤ powerHull L n K' := by
  induction n with
  | zero => exact h
  | succ n ih => exact sup_le_sup h (Submodule.map_mono ih)

lemma le_powerHull (L : E →ₗ[ℝ] E) (n : ℕ) (K : Submodule ℝ E) : K ≤ powerHull L n K := by
  cases n with
  | zero => exact le_rfl
  | succ n => exact le_sup_left

lemma powerHull_le_succ (L : E →ₗ[ℝ] E) (n : ℕ) (K : Submodule ℝ E) :
    powerHull L n K ≤ powerHull L (n+1) K := by
  induction n with
  | zero => exact le_sup_left
  | succ n ih => exact sup_le_sup le_rfl (Submodule.map_mono ih)

lemma powerHull_mono_degree (L : E →ₗ[ℝ] E) {m n : ℕ} (h : m ≤ n) (K : Submodule ℝ E) :
    powerHull L m K ≤ powerHull L n K := by
  exact monotone_nat_of_le_succ (fun n => powerHull_le_succ L n K) h

def tapeHull {n : ℕ} (t : Fin n → E × E) : Submodule ℝ E :=
  Submodule.span ℝ (Set.range (fun i => (t i).1) ∪ Set.range (fun i => (t i).2))

lemma tapeHull_empty (t : Fin 0 → E × E) : tapeHull t = ⊥ := by
  simp [tapeHull]

lemma tapeHull_snoc {n : ℕ} (t : Fin n → E × E) (a b : E) :
    tapeHull (Fin.snoc (α := fun _ : Fin (n+1) => E × E) t (a,b)) =
      (tapeHull t ⊔ ℝ ∙ a) ⊔ ℝ ∙ b := by
  unfold tapeHull
  simp only [← Submodule.span_union]
  congr 1
  ext x
  simp only [Set.mem_union, Set.mem_range, Set.mem_singleton_iff]
  constructor
  · rintro (⟨i,hi⟩ | ⟨i,hi⟩)
    · refine Fin.lastCases ?_ (fun j => ?_) i hi
      · simp only [Fin.snoc_last]; intro h; exact Or.inl (Or.inr h.symm)
      · simp only [Fin.snoc_castSucc]; intro h; exact Or.inl (Or.inl (Or.inl ⟨j,h⟩))
    · refine Fin.lastCases ?_ (fun j => ?_) i hi
      · simp only [Fin.snoc_last]; intro h; exact Or.inr h.symm
      · simp only [Fin.snoc_castSucc]; intro h; exact Or.inl (Or.inl (Or.inr ⟨j,h⟩))
  · rintro (((⟨i,hi⟩ | ⟨i,hi⟩) | h) | h)
    · exact Or.inl ⟨i.castSucc, by simpa only [Fin.snoc_castSucc] using hi⟩
    · exact Or.inr ⟨i.castSucc, by simpa only [Fin.snoc_castSucc] using hi⟩
    · exact Or.inl ⟨Fin.last n, by simpa only [Fin.snoc_last] using h.symm⟩
    · exact Or.inr ⟨Fin.last n, by simpa only [Fin.snoc_last] using h.symm⟩

lemma powerHull_round_growth (L : E →ₗ[ℝ] E) {n : ℕ} {K : Submodule ℝ E}
    {t : Fin n → E × E} (hK : K ≤ powerHull L n (tapeHull t)) (a b : E) :
    ((K ⊔ ℝ ∙ a) ⊔ (K ⊔ ℝ ∙ a).map L) ⊔ ℝ ∙ b ≤
      powerHull L (n+1) (tapeHull (Fin.snoc (α := fun _ : Fin (n+1) => E × E) t (a,b))) := by
  rw [tapeHull_snoc]
  let K' := (tapeHull t ⊔ ℝ ∙ a) ⊔ ℝ ∙ b
  have hbase : tapeHull t ≤ K' := le_sup_left.trans le_sup_left
  have ha : ℝ ∙ a ≤ K' := le_sup_right.trans le_sup_left
  have hb : ℝ ∙ b ≤ K' := le_sup_right
  have hK' : K ⊔ ℝ ∙ a ≤ powerHull L n K' := sup_le
    (hK.trans (powerHull_mono_base L n hbase)) (ha.trans (le_powerHull L n K'))
  exact sup_le (sup_le (hK'.trans (powerHull_le_succ L n K'))
    ((Submodule.map_mono hK').trans le_sup_right)) (hb.trans (le_powerHull L (n+1) K'))

end
end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

lemma measurable_frameProjection (d k : ℕ) :
    Measurable (fun p : Rotations d × Point d =>
      (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry p.1⁻¹ p.2)) := by
  fun_prop

def roundGood {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q+1 ≤ d) (n : ℕ)
    (p : RevealState Ω d q n × RoundRandom d) : Prop :=
  if hn : n < q then
    let hk : 2*n < d := by omega
    (prefixSpace d (2*n))ᗮ.orthogonalProjectionOnto (rotationIsometry p.1.2.1.2⁻¹ p.2.1) ≠ 0 ∧
    (prefixSpace d (2*n+1))ᗮ.orthogonalProjectionOnto
      (rotationIsometry (inverseFrameUpdate hk p.1.2.1
        (A.query ⟨n,hn⟩ (p.1.1,p.1.2.2.1)) p.2.1).2⁻¹ p.2.2.1) ≠ 0
  else True

lemma measurableSet_roundGood {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q+1 ≤ d) (n : ℕ) :
    MeasurableSet {p | roundGood A hd n p} := by
  unfold roundGood
  split_ifs with hn
  · let Z := RevealState Ω d q n × RoundRandom d
    have hk : 2*n < d := by omega
    let x : Z → Point d := fun p => A.query ⟨n,hn⟩ (p.1.1,p.1.2.2.1)
    have hx : Measurable x := (A.query_measurable _).comp
      (measurable_fst.fst.prodMk measurable_fst.snd.snd.fst)
    let F : Z → Frames d := fun p => inverseFrameUpdate hk p.1.2.1 (x p) p.2.1
    have hF : Measurable F := (measurable_inverseFrameUpdate hk).comp
      (f := fun p : Z => (p.1.2.1,x p,p.2.1))
      (measurable_fst.snd.fst.prodMk (hx.prodMk measurable_snd.fst))
    have h₁ : Measurable (fun p : Z =>
        (prefixSpace d (2*n))ᗮ.orthogonalProjectionOnto (rotationIsometry p.1.2.1.2⁻¹ p.2.1)) :=
      (measurable_frameProjection d (2*n)).comp
      (f := fun p : Z => (p.1.2.1.2,p.2.1))
      (measurable_fst.snd.fst.snd.prodMk measurable_snd.fst)
    have h₂ : Measurable (fun p : Z =>
        (prefixSpace d (2*n+1))ᗮ.orthogonalProjectionOnto (rotationIsometry (F p).2⁻¹ p.2.2.1)) :=
      (measurable_frameProjection d (2*n+1)).comp
      (f := fun p : Z => ((F p).2,p.2.2.1)) (hF.snd.prodMk measurable_snd.snd.fst)
    exact ((measurableSet_singleton 0).compl.preimage h₁).inter
      ((measurableSet_singleton 0).compl.preimage h₂)
  · exact MeasurableSet.univ

lemma ae_roundGood {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (hd : 2*q+1 ≤ d) (n : ℕ) (hn : n < q)
    (s : RevealState Ω d q n) : ∀ᵐ r ∂roundRandomLaw d, roundGood A hd n (s,r) := by
  have hk : 2*n < d := by omega
  have hk' : 2*n+1 < d := by omega
  apply (Measure.ae_prod_iff_ae_ae
    ((measurableSet_roundGood A hd n).preimage (measurable_const.prodMk measurable_id))).mpr
  filter_upwards [ae_frameGaussian_nonzero hk s.2.1.2] with g hg
  have h := (Measure.quasiMeasurePreserving_fst
    (μ := stdGaussian (Point d)) (ν := stdGaussian (Point d))).ae
    (ae_frameGaussian_nonzero hk'
      (inverseFrameUpdate hk s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)) g).2)
  filter_upwards [h] with r hr
  simpa only [roundGood,dite_eq_left hn, id_eq] using And.intro hg hr

def SpanConsistent {Ω : Type*} {d q : ℕ} (Λ : Point d →L[ℝ] Point d) (n : ℕ)
    (s : RevealState Ω d q n) : Prop :=
  frameSpace s.2.1.2 (prefixSpace d (2*n)) ≤ powerHull Λ.toLinearMap n (tapeHull s.2.2.2)

lemma revealStep_spanConsistent {Ω : Type*} [MeasurableSpace Ω] {d q n : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d)
    (hn : n < q) (s : RevealState Ω d q n) (r : RoundRandom d)
    (hs : SpanConsistent Λ n s) (hg : roundGood A hd n (s,r)) :
    SpanConsistent Λ (n+1) (revealStep A Λ hd n (s,r)) := by
  have hk : 2*n+1 < d := by omega
  simp only [roundGood,dite_eq_left hn] at hg
  have h := (roundFrames_span_growth hk Λ s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)) r hg.1 hg.2).trans
    (powerHull_round_growth Λ.toLinearMap hs r.1 r.2.1)
  have hF : (revealStep A Λ hd n (s,r)).2.1 =
      roundFrames hk Λ s.2.1 (A.query ⟨n,hn⟩ (s.1,s.2.2.1)) r := by
    simp only [revealStep,dite_eq_left hn]
  have ht : (revealStep A Λ hd n (s,r)).2.2.2 =
      Fin.snoc (α := fun _ : Fin (n+1) => Point d × Point d) s.2.2.2 (r.1,r.2.1) := by
    simp only [revealStep,dite_eq_left hn]
  unfold SpanConsistent
  rw [hF,ht,show 2*(n+1) = 2*n+2 by omega]
  exact h

lemma revealRun_historyConsistent {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d)
    (n : ℕ) (hn : n ≤ q) (p : Ω × (Fin n → RoundRandom d)) :
    HistoryConsistent A Λ n (stateRun initialRevealState (revealStep A Λ hd) n p) := by
  induction n with
  | zero => exact initial_historyConsistent A Λ p.1
  | succ n ih =>
    exact revealStep_historyConsistent A Λ hd (by omega) _ _ (ih (by omega) _)

lemma revealRun_spanConsistent {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (μ : Measure Ω) [IsProbabilityMeasure μ] (A : OracleAlgorithm Ω d q)
    (Λ : Point d →L[ℝ] Point d) (hd : 2*q+1 ≤ d) :
    ∀ᵐ p ∂μ.prod (Measure.pi (fun _ : Fin q => roundRandomLaw d)),
      SpanConsistent Λ q (stateRun initialRevealState (revealStep A Λ hd) q p) := by
  apply stateRun_ae_invariant μ (roundRandomLaw d) initialRevealState
    measurable_initialRevealState (revealStep A Λ hd) (measurable_revealStep A Λ hd)
    (fun n => SpanConsistent Λ n) q (roundGood A hd) (measurableSet_roundGood A hd)
    (ae_roundGood A hd)
  · intro ω
    simp [SpanConsistent,initialRevealState,frameSpace,prefixSpace_zero,powerHull]
  · intro n hn s r hs hg
    exact revealStep_spanConsistent A Λ hd hn s r hs hg

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound
section
variable {E : Type*} [AddCommGroup E] [Module ℝ E]
def orbitHull {ι : Type*} (L : E →ₗ[ℝ] E) (n : ℕ) (t : ι → E) : Submodule ℝ E :=
  Submodule.span ℝ {v | ∃ i : ι, ∃ j : ℕ, j ≤ n ∧ v = (L^[j]) (t i)}

lemma orbitHull_mono {ι : Type*} (L : E →ₗ[ℝ] E) {m n : ℕ} (hmn : m ≤ n) (t : ι → E) :
    orbitHull L m t ≤ orbitHull L n t := by
  apply Submodule.span_mono
  rintro v ⟨i,j,hj,rfl⟩
  exact ⟨i,j,hj.trans hmn,rfl⟩

lemma map_orbitHull_le_succ {ι : Type*} (L : E →ₗ[ℝ] E) (n : ℕ) (t : ι → E) :
    (orbitHull L n t).map L ≤ orbitHull L (n+1) t := by
  rw [orbitHull,Submodule.map_span]
  apply Submodule.span_le.mpr
  rintro v ⟨u,⟨i,j,hj,rfl⟩,rfl⟩
  apply Submodule.subset_span
  refine ⟨i,j+1,Nat.succ_le_succ hj,?_⟩
  exact (Function.iterate_succ_apply' L j (t i)).symm

lemma span_range_le_orbitHull {ι : Type*} (L : E →ₗ[ℝ] E) (n : ℕ) (t : ι → E) :
    Submodule.span ℝ (Set.range t) ≤ orbitHull L n t := by
  apply Submodule.span_le.mpr
  rintro v ⟨i,rfl⟩
  exact Submodule.subset_span ⟨i,0,Nat.zero_le n,rfl⟩

lemma powerHull_le_orbitHull {ι : Type*} (L : E →ₗ[ℝ] E) (n : ℕ) (t : ι → E)
    {K : Submodule ℝ E} (hK : K ≤ Submodule.span ℝ (Set.range t)) :
    powerHull L n K ≤ orbitHull L n t := by
  induction n with
  | zero => exact hK.trans (span_range_le_orbitHull L 0 t)
  | succ n ih =>
    exact sup_le (hK.trans (span_range_le_orbitHull L (n+1) t))
      ((Submodule.map_mono ih).trans (map_orbitHull_le_succ L n t))

end
end LogConcaveSampling.LowerBound

end LowerProof
end
end
end

end OAI