import Mathlib
import OAI.Probability.LogConcave.LowerBounds.RevealRotation
import OAI.Probability.LogConcave.Sampling.NormalizedDirection

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

namespace LogConcaveSampling.LowerBound
open ProbabilityTheory

theorem complementary_gaussian_direction_law {d : ℕ} (E : Submodule ℝ (Point d))
    {w : Eᗮ} (hw : ‖w‖ = 1) :
    (stdGaussian Eᗮ).map (normalizedDirection w) =
      (subspaceHaar E).map (fun O => complementIsometry E O w) := by
  have hn := ae_stdGaussian_ne_zero_of_unit hw
  have hp : ∀ᵐ p ∂(subspaceHaar E).prod (stdGaussian Eᗮ), p.2 ≠ 0 :=
    Measure.quasiMeasurePreserving_snd.ae hn
  calc
    _ = (((subspaceHaar E).prod (stdGaussian Eᗮ)).map
        (fun p => ‖p.2‖ • complementIsometry E p.1 w)).map (normalizedDirection w) := by
      rw [complementary_gaussian_radius_haar_direction E hw]
    _ = ((subspaceHaar E).prod (stdGaussian Eᗮ)).map
        (fun p => complementIsometry E p.1 w) := by
      rw [Measure.map_map (measurable_normalizedDirection w) (by fun_prop)]
      apply Measure.map_congr
      filter_upwards [hp] with p hp
      exact normalizedDirection_scale (by simpa using hw) (norm_pos_iff.mpr hp)
    _ = _ := by
      change Measure.map ((fun O => complementIsometry E O w) ∘ Prod.fst) _ = _
      rw [← Measure.map_map (f := Prod.fst) (g := fun O => complementIsometry E O w)
        (by fun_prop) measurable_fst]
      simp

theorem projected_gaussian_direction_law {d : ℕ} (E : Submodule ℝ (Point d))
    {w : Eᗮ} (hw : ‖w‖ = 1) :
    (stdGaussian (Point d)).map
      (fun g => normalizedDirection w (Eᗮ.orthogonalProjectionOnto g)) =
      (subspaceHaar E).map (fun O => complementIsometry E O w) := by
  change Measure.map (normalizedDirection w ∘ Eᗮ.orthogonalProjectionOnto) _ = _
  rw [← Measure.map_map (f := Eᗮ.orthogonalProjectionOnto)
    (g := normalizedDirection w) (measurable_normalizedDirection w) (by fun_prop),
    stdGaussian_orthogonalProjection, complementary_gaussian_direction_law E hw]

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling
namespace LowerBound

def prefixSpace (d k : ℕ) : Submodule ℝ (Point d) where
  carrier := {x | ∀ i : Fin d, k ≤ i.val → x i = 0}
  zero_mem' := by intro i _; rfl
  add_mem' := by intro x y hx hy i hi; simp [hx i hi, hy i hi]
  smul_mem' := by intro c x hx i hi; simp [hx i hi]

@[simp] theorem mem_prefixSpace {d k : ℕ} (x : Point d) :
    x ∈ prefixSpace d k ↔ ∀ i : Fin d, k ≤ i.val → x i = 0 := Iff.rfl

def coordinateVector {d : ℕ} (i : Fin d) : Point d := EuclideanSpace.single i 1

@[simp] theorem coordinateVector_apply {d : ℕ} (i j : Fin d) :
    coordinateVector i j = if j = i then 1 else 0 := by
  simp [coordinateVector, eq_comm]

@[simp] theorem coordinateVector_norm {d : ℕ} (i : Fin d) : ‖coordinateVector i‖ = 1 := by
  simp [coordinateVector]

@[simp] theorem inner_coordinateVector {d : ℕ} (i : Fin d) (x : Point d) :
    inner ℝ (coordinateVector i) x = x i := by
  simp [coordinateVector, EuclideanSpace.inner_single_left]

@[simp] theorem prefixSpace_zero (d : ℕ) : prefixSpace d 0 = ⊥ := by
  ext x
  simp only [mem_prefixSpace, zero_le, forall_true_left, Submodule.mem_bot]
  exact ⟨fun h => by ext i; exact h i, fun h i => by simp [h]⟩

lemma prefixSpace_mono (d : ℕ) {k l : ℕ} (hkl : k ≤ l) :
    prefixSpace d k ≤ prefixSpace d l := by
  intro x hx i hi
  exact hx i (hkl.trans hi)

lemma coordinateVector_orthogonal_prefix {d k : ℕ} (hk : k < d) :
    coordinateVector ⟨k,hk⟩ ∈ (prefixSpace d k)ᗮ := by
  rw [Submodule.mem_orthogonal']
  intro y hy
  rw [inner_coordinateVector]
  exact hy ⟨k,hk⟩ le_rfl

lemma prefixSpace_succ {d k : ℕ} (hk : k < d) :
    prefixSpace d (k+1) = prefixSpace d k ⊔ ℝ ∙ coordinateVector ⟨k,hk⟩ := by
  apply le_antisymm
  · intro x hx
    have ht : x - (x ⟨k,hk⟩) • coordinateVector ⟨k,hk⟩ ∈ prefixSpace d k := by
      intro i hi
      by_cases hik : i.val = k
      · have he : i = ⟨k,hk⟩ := Fin.ext hik
        simp [he]
      · have hki : k+1 ≤ i.val := by omega
        have hine : i ≠ ⟨k,hk⟩ := by intro h; apply hik; exact congrArg Fin.val h
        simp [hx i hki, coordinateVector_apply, hine]
    have hs : x ⟨k,hk⟩ • coordinateVector ⟨k,hk⟩ ∈ ℝ ∙ coordinateVector ⟨k,hk⟩ :=
      Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)
    convert (prefixSpace d k ⊔ ℝ ∙ coordinateVector ⟨k,hk⟩).add_mem
      ((le_sup_left : prefixSpace d k ≤ _ ) ht) ((le_sup_right : ℝ ∙ coordinateVector ⟨k,hk⟩ ≤ _) hs)
      using 1
    module
  · apply sup_le
    · exact prefixSpace_mono d (Nat.le_succ k)
    · apply Submodule.span_le.mpr
      intro x hx
      rcases Set.mem_singleton_iff.mp hx with rfl
      intro i hi
      have hine : i ≠ ⟨k,hk⟩ := by intro h; have := congrArg Fin.val h; dsimp at this; omega
      simp [coordinateVector_apply, hine]

def prefixProject {d : ℕ} (k : ℕ) (x : Point d) : Point d :=
  toLp 2 (fun i => if i.val < k then x i else 0)

@[simp] theorem prefixProject_apply {d : ℕ} (k : ℕ) (x : Point d) (i : Fin d) :
    prefixProject k x i = if i.val < k then x i else 0 := rfl

@[fun_prop] theorem continuous_prefixProject {d : ℕ} (k : ℕ) :
    Continuous (prefixProject (d := d) k) := by
  unfold prefixProject
  apply (PiLp.continuous_toLp 2 _).comp
  apply continuous_pi
  intro i
  split_ifs <;> fun_prop

lemma prefixProject_mem {d : ℕ} (k : ℕ) (x : Point d) :
    prefixProject k x ∈ prefixSpace d k := by
  intro i hi
  simp [prefixProject_apply, not_lt_of_ge hi]

lemma sub_prefixProject_mem_orthogonal {d : ℕ} (k : ℕ) (x : Point d) :
    x - prefixProject k x ∈ (prefixSpace d k)ᗮ := by
  rw [Submodule.mem_orthogonal]
  intro y hy
  rw [EuclideanSpace.inner_eq_star_dotProduct]
  apply Finset.sum_eq_zero
  intro i _
  by_cases hi : i.val < k
  · simp [prefixProject_apply, hi]
  · simp [prefixProject_apply, hi, hy i (Nat.le_of_not_gt hi)]

lemma prefixProject_eq_projection {d : ℕ} (k : ℕ) (x : Point d) :
    prefixProject k x = (prefixSpace d k).starProjection x := by
  symm
  apply (Submodule.eq_starProjection_of_mem_of_inner_eq_zero
    (prefixProject_mem k x))
  intro y hy
  exact (prefixSpace d k).inner_left_of_mem_orthogonal hy
    (sub_prefixProject_mem_orthogonal k x)

end LowerBound
end LogConcaveSampling

namespace LogConcaveSampling.LowerBound
open ProbabilityTheory

instance subspaceHaar_invInvariant {d : ℕ} (E : Submodule ℝ (Point d)) :
    (subspaceHaar E).IsInvInvariant := by
  constructor
  have : IsProbabilityMeasure (subspaceHaar E).inv := by
    unfold Measure.inv
    infer_instance
  have h := Measure.isMulInvariant_eq_smul_of_compactSpace
    (subspaceHaar E).inv (subspaceHaar E)
  have hm := congrArg (fun μ : Measure (subspaceStabilizer E) => μ Set.univ) h
  simp only [measure_univ, Measure.smul_apply, ENNReal.smul_def, smul_eq_mul, mul_one] at hm
  have hc : (subspaceHaar E).inv.haarScalarFactor (subspaceHaar E) = 1 :=
    ENNReal.coe_injective hm.symm
  rw [hc, one_smul] at h
  exact h

def gaussianSection {d : ℕ} (E : Submodule ℝ (Point d)) (e : Eᗮ)
    (g : Point d) : subspaceStabilizer E :=
  complementSection E e (normalizedDirection e (Eᗮ.orthogonalProjectionOnto g))

@[fun_prop] theorem measurable_gaussianSection {d : ℕ}
    (E : Submodule ℝ (Point d)) (e : Eᗮ) : Measurable (gaussianSection E e) := by
  exact (measurable_complementSection_left E e).comp
    ((measurable_normalizedDirection e).comp (by fun_prop))

def gaussianForward {d : ℕ} (E : Submodule ℝ (Point d)) (e : Eᗮ)
    (p : Point d × subspaceStabilizer (E ⊔ ℝ ∙ (e : Point d))) : subspaceStabilizer E :=
  gaussianSection E e p.1 * residualInclusion E e p.2

@[fun_prop] theorem measurable_gaussianForward {d : ℕ}
    (E : Submodule ℝ (Point d)) (e : Eᗮ) : Measurable (gaussianForward E e) := by
  unfold gaussianForward
  exact ((measurable_gaussianSection E e).comp measurable_fst).mul
    ((continuous_residualInclusion E e).measurable.comp measurable_snd)

theorem gaussianForward_law {d : ℕ} (E : Submodule ℝ (Point d))
    {e : Eᗮ} (he : ‖e‖ = 1) :
    ((stdGaussian (Point d)).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
      (gaussianForward E e) = subspaceHaar E := by
  calc
    _ = ((subspaceHaar E).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
        (revealComplement E e) := by
      ext s hs
      rw [Measure.map_apply (measurable_gaussianForward E e) hs,
        Measure.map_apply (measurable_revealComplement E e) hs,
        Measure.prod_apply_symm (hs.preimage (measurable_gaussianForward E e)),
        Measure.prod_apply_symm (hs.preimage (measurable_revealComplement E e))]
      apply lintegral_congr
      intro h
      have hM : (stdGaussian (Point d)).map (fun g => gaussianForward E e (g,h)) =
          (subspaceHaar E).map (fun O => revealComplement E e (O,h)) := by
        have hm : Measurable (fun v : Eᗮ => complementSection E e v * residualInclusion E e h) :=
          (measurable_complementSection_left E e).mul_const _
        have hl := congrArg (fun μ : Measure Eᗮ => μ.map
          (fun v => complementSection E e v * residualInclusion E e h))
          (projected_gaussian_direction_law E he)
        rw [Measure.map_map hm (by fun_prop), Measure.map_map hm (by fun_prop)] at hl
        exact hl
      have ha := congrArg (fun μ : Measure (subspaceStabilizer E) => μ s) hM
      rw [Measure.map_apply (f := fun g => gaussianForward E e (g,h)) (by fun_prop) hs,
        Measure.map_apply (f := fun O => revealComplement E e (O,h)) (by fun_prop) hs] at ha
      exact ha
    _ = _ := revealComplement_law E e

def gaussianBackward {d : ℕ} (E : Submodule ℝ (Point d)) (e w : Eᗮ)
    (p : Point d × subspaceStabilizer (E ⊔ ℝ ∙ (e : Point d))) : subspaceStabilizer E :=
  complementSection E e w * residualInclusion E e p.2 * (gaussianSection E e p.1)⁻¹

@[fun_prop] theorem measurable_gaussianBackward {d : ℕ}
    (E : Submodule ℝ (Point d)) (e w : Eᗮ) : Measurable (gaussianBackward E e w) := by
  unfold gaussianBackward
  fun_prop

theorem gaussianBackward_law {d : ℕ} (E : Submodule ℝ (Point d))
    {e : Eᗮ} (he : ‖e‖ = 1) (w : Eᗮ) :
    ((stdGaussian (Point d)).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
      (gaussianBackward E e w) = subspaceHaar E := by
  calc
    _ = ((stdGaussian (Point d)).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
        (fun p => complementSection E e w * (gaussianForward E e p)⁻¹) := by
      apply map_prod_eq_of_second_fiber_law (measurable_gaussianBackward E e w) (by fun_prop)
      intro g
      calc
        _ = ((subspaceHaar (E ⊔ ℝ ∙ (e : Point d))).map Inv.inv).map
            (fun h => complementSection E e w * (gaussianForward E e (g,h))⁻¹) := by
          rw [Measure.map_map (by fun_prop) (by fun_prop)]
          congr 1
          funext h
          apply Subtype.ext
          simp only [Function.comp_apply, gaussianForward, gaussianBackward,
            residualInclusion, Subgroup.coe_mul, Subgroup.coe_inv]
          group
        _ = _ := by rw [Measure.map_inv_eq_self]
    _ = (((stdGaussian (Point d)).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
        (gaussianForward E e)).map (fun O => complementSection E e w * O⁻¹) := by
      rw [Measure.map_map (by fun_prop) (measurable_gaussianForward E e)]
      rfl
    _ = _ := by
      rw [gaussianForward_law E he]
      simpa only [div_eq_mul_inv] using
        (Measure.map_div_left_eq_self (subspaceHaar E) (complementSection E e w))

lemma gaussianBackward_sends {d : ℕ} (E : Submodule ℝ (Point d))
    {e w : Eᗮ} (he : ‖e‖ = 1) (hw : ‖w‖ = 1)
    (p : Point d × subspaceStabilizer (E ⊔ ℝ ∙ (e : Point d))) :
    complementIsometry E (gaussianBackward E e w p)
      (normalizedDirection e (Eᗮ.orthogonalProjectionOnto p.1)) = w := by
  have hs := complementSection_sends E
    (show ‖e‖ = ‖normalizedDirection e (Eᗮ.orthogonalProjectionOnto p.1)‖ by simp [he])
  rw [gaussianBackward, complementIsometry_mul, complementIsometry_mul,
    complementIsometry_inv]
  have hi : (complementIsometry E (gaussianSection E e p.1)).symm
      (normalizedDirection e (Eᗮ.orthogonalProjectionOnto p.1)) = e :=
    (complementIsometry E (gaussianSection E e p.1)).symm_apply_eq.mpr hs.symm
  rw [hi, residualInclusion_fixes]
  exact complementSection_sends E (he.trans hw.symm)

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

def remainingHaar {d : ℕ} (E : Submodule ℝ (Point d)) : Measure (Rotations d) :=
  (subspaceHaar E).map Subtype.val

instance remainingHaar_probability {d : ℕ} (E : Submodule ℝ (Point d)) :
    IsProbabilityMeasure (remainingHaar E) := by
  unfold remainingHaar
  infer_instance

lemma remainingHaar_fixes {d : ℕ} (E : Submodule ℝ (Point d)) :
    ∀ᵐ H ∂remainingHaar E, H ∈ subspaceStabilizer E := by
  apply (ae_map_iff measurable_subtype_coe.aemeasurable
    (subspaceStabilizer_isClosed E).measurableSet).mpr
  exact Filter.Eventually.of_forall Subtype.property

def ambientBackward {d : ℕ} (E : Submodule ℝ (Point d)) (e w : Eᗮ)
    (p : Point d × Rotations d) : Rotations d :=
  (complementSection E e w).1 * p.2 * (gaussianSection E e p.1).1⁻¹

@[fun_prop] lemma measurable_ambientBackward {d : ℕ}
    (E : Submodule ℝ (Point d)) (e w : Eᗮ) : Measurable (ambientBackward E e w) := by
  unfold ambientBackward
  fun_prop

lemma ambientBackward_law {d : ℕ} (E : Submodule ℝ (Point d))
    {e : Eᗮ} (he : ‖e‖ = 1) (w : Eᗮ) :
    ((stdGaussian (Point d)).prod (remainingHaar (E ⊔ ℝ ∙ (e : Point d)))).map
      (ambientBackward E e w) = remainingHaar E := by
  have hp := Measure.map_prod_map (stdGaussian (Point d))
    (subspaceHaar (E ⊔ ℝ ∙ (e : Point d))) measurable_id measurable_subtype_coe
  rw [Measure.map_id] at hp
  unfold remainingHaar
  rw [hp, Measure.map_map (measurable_ambientBackward E e w) (by fun_prop)]
  calc
    _ = (((stdGaussian (Point d)).prod (subspaceHaar (E ⊔ ℝ ∙ (e : Point d)))).map
        (gaussianBackward E e w)).map Subtype.val := by
      rw [Measure.map_map measurable_subtype_coe (measurable_gaussianBackward E e w)]
      rfl
    _ = _ := by rw [gaussianBackward_law E he]

lemma ambientBackward_mem {d : ℕ} (E : Submodule ℝ (Point d)) (e w : Eᗮ)
    (g : Point d) {H : Rotations d} (hH : H ∈ subspaceStabilizer (E ⊔ ℝ ∙ (e : Point d))) :
    ambientBackward E e w (g,H) ∈ subspaceStabilizer E :=
  (gaussianBackward E e w (g,⟨H,hH⟩)).property

lemma ambientBackward_sends {d : ℕ} (E : Submodule ℝ (Point d))
    {e w : Eᗮ} (he : ‖e‖ = 1) (hw : ‖w‖ = 1) (g : Point d)
    {H : Rotations d} (hH : H ∈ subspaceStabilizer (E ⊔ ℝ ∙ (e : Point d))) :
    rotationIsometry (ambientBackward E e w (g,H))
      ((normalizedDirection e (Eᗮ.orthogonalProjectionOnto g) : Eᗮ) : Point d) = (w : Point d) :=
  congrArg Subtype.val (gaussianBackward_sends E he hw (g,⟨H,hH⟩))

def prefixUnit {d k : ℕ} (hk : k < d) : (prefixSpace d k)ᗮ :=
  ⟨coordinateVector ⟨k,hk⟩, coordinateVector_orthogonal_prefix hk⟩

@[simp] lemma norm_prefixUnit {d k : ℕ} (hk : k < d) : ‖prefixUnit hk‖ = 1 := by
  exact coordinateVector_norm _

abbrev Frames (d : ℕ) := Rotations d × Rotations d

def frameCompletion {d : ℕ} (F : Frames d) (H : Rotations d) : Rotations d :=
  F.1 * H * F.2⁻¹

@[fun_prop] lemma measurable_frameCompletion {d : ℕ} :
    Measurable (fun p : Frames d × Rotations d => frameCompletion p.1 p.2) := by
  unfold frameCompletion
  fun_prop

def flagDirection {d k : ℕ} (hk : k < d) (x : Point d) : (prefixSpace d k)ᗮ :=
  normalizedDirection (prefixUnit hk) ((prefixSpace d k)ᗮ.orthogonalProjectionOnto x)

@[fun_prop] lemma measurable_flagDirection {d k : ℕ} (hk : k < d) :
    Measurable (flagDirection hk) := by
  exact (measurable_normalizedDirection _).comp (by fun_prop)

@[simp] lemma norm_flagDirection {d k : ℕ} (hk : k < d) (x : Point d) :
    ‖flagDirection hk x‖ = 1 := norm_normalizedDirection (norm_prefixUnit hk) _

def inverseFrameUpdate {d k : ℕ} (hk : k < d) (F : Frames d) (x g : Point d) : Frames d :=
  (F.1 * (complementSection (prefixSpace d k) (prefixUnit hk)
      (flagDirection hk (rotationIsometry F.1⁻¹ x))).1,
   F.2 * (gaussianSection (prefixSpace d k) (prefixUnit hk) (rotationIsometry F.2⁻¹ g)).1)

@[fun_prop] lemma measurable_inverseFrameUpdate {d k : ℕ} (hk : k < d) :
    Measurable (fun p : Frames d × Point d × Point d => inverseFrameUpdate hk p.1 p.2.1 p.2.2) := by
  unfold inverseFrameUpdate
  apply Measurable.prodMk
  · apply Measurable.mul (by fun_prop)
    apply measurable_subtype_coe.comp
    exact (measurable_complementSection_left _ _).comp (by fun_prop)
  · fun_prop

theorem inverseFrameUpdate_law {d k : ℕ} (hk : k < d) (F : Frames d) (x : Point d) :
    ((stdGaussian (Point d)).prod (remainingHaar (prefixSpace d (k+1)))).map
      (fun p => frameCompletion (inverseFrameUpdate hk F x p.1) p.2) =
    (remainingHaar (prefixSpace d k)).map (frameCompletion F) := by
  let E := prefixSpace d k
  let e := prefixUnit hk
  let w := flagDirection hk (rotationIsometry F.1⁻¹ x)
  have hg : (stdGaussian (Point d)).map (rotationIsometry F.2⁻¹) = stdGaussian (Point d) :=
    stdGaussian_map (rotationIsometry F.2⁻¹)
  have hP := Measure.map_prod_map (stdGaussian (Point d))
    (remainingHaar (prefixSpace d (k+1))) (by fun_prop : Measurable (rotationIsometry F.2⁻¹))
      measurable_id
  rw [hg, Measure.map_id] at hP
  have hl := congrArg (fun μ : Measure (Rotations d) => μ.map (frameCompletion F))
    (ambientBackward_law E (norm_prefixUnit hk) w)
  have hEq : E ⊔ ℝ ∙ (e : Point d) = prefixSpace d (k+1) := (prefixSpace_succ hk).symm
  rw [hEq, Measure.map_map (by fun_prop) (measurable_ambientBackward E e w)] at hl
  rw [hP, Measure.map_map (by fun_prop) (by fun_prop)] at hl
  convert hl using 1
  congr 1
  funext p
  simp only [Function.comp_apply, frameCompletion,
    inverseFrameUpdate, ambientBackward, E, e, w]
  group; rfl

lemma remainingHaar_map_inv {d : ℕ} (E : Submodule ℝ (Point d)) :
    (remainingHaar E).map Inv.inv = remainingHaar E := by
  unfold remainingHaar
  rw [Measure.map_map (by fun_prop) measurable_subtype_coe]
  calc
    _ = ((subspaceHaar E).map Inv.inv).map Subtype.val := by
      rw [Measure.map_map measurable_subtype_coe (by fun_prop)]
      rfl
    _ = _ := by rw [Measure.map_inv_eq_self]

@[simp] lemma frameCompletion_swap {d : ℕ} (F : Frames d) (H : Rotations d) :
    frameCompletion F.swap H⁻¹ = (frameCompletion F H)⁻¹ := by
  simp [frameCompletion]; group

def forwardFrameUpdate {d k : ℕ} (hk : k < d) (F : Frames d) (y g : Point d) : Frames d :=
  (inverseFrameUpdate hk F.swap y g).swap

@[fun_prop] lemma measurable_forwardFrameUpdate {d k : ℕ} (hk : k < d) :
    Measurable (fun p : Frames d × Point d × Point d => forwardFrameUpdate hk p.1 p.2.1 p.2.2) := by
  unfold forwardFrameUpdate
  have h := (measurable_inverseFrameUpdate hk).comp
    (show Measurable (fun p : Frames d × Point d × Point d => (p.1.swap,p.2)) by fun_prop)
  exact h.snd.prodMk h.fst

theorem forwardFrameUpdate_law {d k : ℕ} (hk : k < d) (F : Frames d) (y : Point d) :
    ((stdGaussian (Point d)).prod (remainingHaar (prefixSpace d (k+1)))).map
      (fun p => frameCompletion (forwardFrameUpdate hk F y p.1) p.2) =
    (remainingHaar (prefixSpace d k)).map (frameCompletion F) := by
  have hl := congrArg (fun μ : Measure (Rotations d) => μ.map Inv.inv)
    (inverseFrameUpdate_law hk F.swap y)
  rw [Measure.map_map (by fun_prop) (by fun_prop),
    Measure.map_map (by fun_prop) (by fun_prop)] at hl
  have hP := Measure.map_prod_map (stdGaussian (Point d))
    (remainingHaar (prefixSpace d (k+1))) measurable_id (by fun_prop : Measurable (Inv.inv : Rotations d → _))
  rw [Measure.map_id, remainingHaar_map_inv] at hP
  rw [hP, Measure.map_map (by fun_prop) (by fun_prop)]
  change ((stdGaussian (Point d)).prod (remainingHaar (prefixSpace d (k+1)))).map
    (fun p => frameCompletion (forwardFrameUpdate hk F y p.1) p.2⁻¹) = _
  simp only [forwardFrameUpdate, frameCompletion_swap]
  simp only [Function.comp_def] at hl
  rw [hl]
  calc
    _ = ((remainingHaar (prefixSpace d k)).map Inv.inv).map (frameCompletion F) := by
      rw [Measure.map_map (by fun_prop) (by fun_prop)]
      congr 1; funext H
      simp [frameCompletion, mul_assoc]
    _ = _ := by rw [remainingHaar_map_inv]

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound
open scoped RealInnerProductSpace

def frameSpace {d : ℕ} (O : Rotations d) (E : Submodule ℝ (Point d)) : Submodule ℝ (Point d) :=
  E.map (rotationIsometry O).toLinearEquiv.toLinearMap

lemma mem_frameSpace {d : ℕ} (O : Rotations d) (E : Submodule ℝ (Point d)) (x : Point d) :
    x ∈ frameSpace O E ↔ rotationIsometry O⁻¹ x ∈ E := by
  constructor
  · rintro ⟨y,hy,rfl⟩
    rw [rotationIsometry_inv_apply]
    change (rotationIsometry O).symm (rotationIsometry O y) ∈ E
    rw [LinearIsometryEquiv.symm_apply_apply]
    exact hy
  · intro hx
    refine ⟨rotationIsometry O⁻¹ x,hx,?_⟩
    simp only [LinearEquiv.coe_toLinearMap, LinearIsometryEquiv.coe_toLinearEquiv,
      rotationIsometry_inv_apply, LinearIsometryEquiv.apply_symm_apply]

lemma frameSpace_mul {d : ℕ} (O P : Rotations d) (E : Submodule ℝ (Point d)) :
    frameSpace (O*P) E = frameSpace O (frameSpace P E) := by
  ext x
  simp only [mem_frameSpace, _root_.mul_inv_rev, rotationIsometry_mul]

lemma frameSpace_sup {d : ℕ} (O : Rotations d) (E F : Submodule ℝ (Point d)) :
    frameSpace O (E ⊔ F) = frameSpace O E ⊔ frameSpace O F := Submodule.map_sup _ _ _

lemma frameSpace_line {d : ℕ} (O : Rotations d) (x : Point d) :
    frameSpace O (ℝ ∙ x) = ℝ ∙ rotationIsometry O x := by
  simp only [frameSpace, Submodule.map_span, Set.image_singleton,
    LinearEquiv.coe_toLinearMap, LinearIsometryEquiv.coe_toLinearEquiv]

lemma frameSpace_fixed {d : ℕ} (E : Submodule ℝ (Point d))
    {O : Rotations d} (hO : O ∈ subspaceStabilizer E) : frameSpace O E = E := by
  apply le_antisymm
  · rintro x ⟨y,hy,rfl⟩
    change rotationIsometry O y ∈ E
    rw [hO y hy]
    exact hy
  · intro x hx
    exact ⟨x,hx,hO x hx⟩

lemma frameSpace_mono {d : ℕ} (O : Rotations d) {E F : Submodule ℝ (Point d)}
    (h : E ≤ F) : frameSpace O E ≤ frameSpace O F := Submodule.map_mono h

lemma complementSection_frameSpace {d : ℕ} (E : Submodule ℝ (Point d))
    {e w : Eᗮ} (h : ‖e‖ = ‖w‖) :
    frameSpace (complementSection E e w).1 (E ⊔ ℝ ∙ (e : Point d)) =
      E ⊔ ℝ ∙ (w : Point d) := by
  rw [frameSpace_sup, frameSpace_fixed E (complementSection E e w).property, frameSpace_line]
  have hs := congrArg Subtype.val (complementSection_sends E h)
  change rotationIsometry (complementSection E e w).1 e = w at hs
  rw [hs]

lemma flagSection_frameSpace {d k : ℕ} (hk : k < d) (x : Point d) :
    frameSpace (complementSection (prefixSpace d k) (prefixUnit hk) (flagDirection hk x)).1
      (prefixSpace d (k+1)) = prefixSpace d k ⊔ ℝ ∙ (flagDirection hk x : Point d) := by
  rw [prefixSpace_succ hk]
  exact complementSection_frameSpace (prefixSpace d k)
    (e := prefixUnit hk) (w := flagDirection hk x) (by rw [norm_prefixUnit, norm_flagDirection])

lemma vector_mem_flagDirection {d k : ℕ} (hk : k < d) (x : Point d) :
    x ∈ prefixSpace d k ⊔ ℝ ∙ (flagDirection hk x : Point d) := by
  let E := prefixSpace d k
  have ht : ((Eᗮ.orthogonalProjectionOnto x : Eᗮ) : Point d) ∈
      ℝ ∙ (flagDirection hk x : Point d) := by
    change _ ∈ ℝ ∙ ((normalizedDirection (prefixUnit hk) (Eᗮ.orthogonalProjectionOnto x) : Eᗮ) : Point d)
    by_cases hn : Eᗮ.orthogonalProjectionOnto x = 0
    · simp [hn]
    · have hs := (ℝ ∙ ((normalizedDirection (prefixUnit hk) (Eᗮ.orthogonalProjectionOnto x) : Eᗮ) : Point d)).smul_mem
        ‖Eᗮ.orthogonalProjectionOnto x‖ (Submodule.mem_span_singleton_self _)
      simpa only [normalizedDirection, ite_eq_right hn, Submodule.coe_smul_of_tower, smul_smul,
        mul_inv_cancel₀ (norm_ne_zero_iff.mpr hn), one_smul] using hs
  have hp : E.starProjection x ∈ E := E.starProjection_apply_mem x
  have hs := (E ⊔ ℝ ∙ (flagDirection hk x : Point d)).add_mem
    ((le_sup_left : E ≤ _) hp) ((le_sup_right : ℝ ∙ _ ≤ _) ht)
  convert hs using 1
  exact (E.starProjection_add_starProjection_orthogonal x).symm

lemma flagDirection_mem_span {d k : ℕ} (hk : k < d) (x : Point d)
    (hn : (prefixSpace d k)ᗮ.orthogonalProjectionOnto x ≠ 0) :
    (flagDirection hk x : Point d) ∈ prefixSpace d k ⊔ ℝ ∙ x := by
  let E := prefixSpace d k
  have hx : x ∈ E ⊔ ℝ ∙ x := (le_sup_right : ℝ ∙ x ≤ _) (Submodule.mem_span_singleton_self x)
  have hp : E.starProjection x ∈ E ⊔ ℝ ∙ x :=
    (le_sup_left : E ≤ _) (E.starProjection_apply_mem x)
  have ht := (E ⊔ ℝ ∙ x).sub_mem hx hp
  rw [← Submodule.starProjection_orthogonal_val] at ht
  have hs := (E ⊔ ℝ ∙ x).smul_mem ‖Eᗮ.orthogonalProjectionOnto x‖⁻¹ ht
  simp only [flagDirection, normalizedDirection, ite_eq_right hn]
  exact hs

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

def extendFrame {d k : ℕ} (hk : k < d) (O : Rotations d) (x : Point d) : Rotations d :=
  O * (complementSection (prefixSpace d k) (prefixUnit hk)
    (flagDirection hk (rotationIsometry O⁻¹ x))).1

@[fun_prop] lemma measurable_extendFrame {d k : ℕ} (hk : k < d) :
    Measurable (fun p : Rotations d × Point d => extendFrame hk p.1 p.2) := by
  unfold extendFrame
  apply Measurable.mul measurable_fst
  apply measurable_subtype_coe.comp
  exact (measurable_complementSection_left _ _).comp (by fun_prop)

lemma inverseFrameUpdate_eq {d k : ℕ} (hk : k < d) (F : Frames d) (x g : Point d) :
    inverseFrameUpdate hk F x g = (extendFrame hk F.1 x, extendFrame hk F.2 g) := rfl

lemma forwardFrameUpdate_eq {d k : ℕ} (hk : k < d) (F : Frames d) (y g : Point d) :
    forwardFrameUpdate hk F y g = (extendFrame hk F.1 g, extendFrame hk F.2 y) := rfl

lemma frameSpace_extendFrame {d k : ℕ} (hk : k < d) (O : Rotations d) (x : Point d) :
    frameSpace (extendFrame hk O x) (prefixSpace d (k+1)) =
      frameSpace O (prefixSpace d k) ⊔
        ℝ ∙ rotationIsometry O (flagDirection hk (rotationIsometry O⁻¹ x) : Point d) := by
  rw [extendFrame, frameSpace_mul, flagSection_frameSpace, frameSpace_sup, frameSpace_line]

lemma frameSpace_le_extendFrame {d k : ℕ} (hk : k < d) (O : Rotations d) (x : Point d) :
    frameSpace O (prefixSpace d k) ≤ frameSpace (extendFrame hk O x) (prefixSpace d (k+1)) := by
  rw [frameSpace_extendFrame]
  exact le_sup_left

lemma mem_frameSpace_extendFrame {d k : ℕ} (hk : k < d) (O : Rotations d) (x : Point d) :
    x ∈ frameSpace (extendFrame hk O x) (prefixSpace d (k+1)) := by
  rw [extendFrame, frameSpace_mul, flagSection_frameSpace, mem_frameSpace]
  exact vector_mem_flagDirection hk _

lemma frameSpace_extendFrame_le {d k : ℕ} (hk : k < d) (O : Rotations d) (x : Point d)
    (hn : (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry O⁻¹ x) ≠ 0) :
    frameSpace (extendFrame hk O x) (prefixSpace d (k+1)) ≤
      frameSpace O (prefixSpace d k) ⊔ ℝ ∙ x := by
  rw [extendFrame, frameSpace_mul, flagSection_frameSpace]
  have hs : prefixSpace d k ⊔ ℝ ∙ (flagDirection hk (rotationIsometry O⁻¹ x) : Point d) ≤
      prefixSpace d k ⊔ ℝ ∙ rotationIsometry O⁻¹ x := by
    apply sup_le le_sup_left
    exact Submodule.span_le.mpr (by
      intro v hv
      rcases Set.mem_singleton_iff.mp hv with rfl
      exact flagDirection_mem_span hk _ hn)
  have h := frameSpace_mono O hs
  simp only [frameSpace_sup, frameSpace_line, rotationIsometry_inv_apply,
    LinearIsometryEquiv.apply_symm_apply] at h
  rw [frameSpace_sup, frameSpace_line]
  simpa only [rotationIsometry_inv_apply] using h

lemma ae_frameGaussian_nonzero {d k : ℕ} (hk : k < d) (O : Rotations d) :
    ∀ᵐ g ∂stdGaussian (Point d),
      (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry O⁻¹ g) ≠ 0 := by
  have h := ae_stdGaussian_ne_zero_of_unit (norm_prefixUnit hk)
  rw [← stdGaussian_orthogonalProjection (prefixSpace d k)ᗮ] at h
  have hp : ∀ᵐ x ∂stdGaussian (Point d), (prefixSpace d k)ᗮ.orthogonalProjectionOnto x ≠ 0 :=
    (ae_map_iff (by fun_prop) (measurableSet_singleton 0).compl).mp h
  rw [← stdGaussian_map (rotationIsometry O⁻¹)] at hp
  exact (ae_map_iff (by fun_prop) ((measurableSet_singleton 0).compl.preimage (by fun_prop))).mp hp

def filledObservation {d k : ℕ} (O : Rotations d) (x g : Point d) : Point d :=
  if (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry O⁻¹ x) = 0 then g else x

@[fun_prop] lemma measurable_filledObservation {d k : ℕ} :
    Measurable (fun p : Rotations d × Point d × Point d => filledObservation (k := k) p.1 p.2.1 p.2.2) := by
  unfold filledObservation
  exact Measurable.ite (measurableSet_eq_fun (by fun_prop) measurable_const) (by fun_prop) (by fun_prop)

lemma mem_frameSpace_of_projection_zero {d k : ℕ} (O : Rotations d) (x : Point d)
    (hz : (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry O⁻¹ x) = 0) :
    x ∈ frameSpace O (prefixSpace d k) := by
  rw [mem_frameSpace]
  have hz' := congrArg Subtype.val hz
  change (prefixSpace d k)ᗮ.starProjection (rotationIsometry O⁻¹ x) = 0 at hz'
  rw [Submodule.starProjection_orthogonal_val, sub_eq_zero] at hz'
  rw [hz']
  exact Submodule.starProjection_apply_mem _ _

lemma mem_frameSpace_filledExtend {d k : ℕ} (hk : k < d) (O : Rotations d) (x g : Point d) :
    x ∈ frameSpace (extendFrame hk O (filledObservation (k := k) O x g)) (prefixSpace d (k+1)) := by
  unfold filledObservation
  split_ifs with hz
  · exact frameSpace_le_extendFrame hk O g (mem_frameSpace_of_projection_zero O x hz)
  · exact mem_frameSpace_extendFrame hk O x

lemma frameSpace_filledExtend_le {d k : ℕ} (hk : k < d) (O : Rotations d) (x g : Point d)
    (hg : (prefixSpace d k)ᗮ.orthogonalProjectionOnto (rotationIsometry O⁻¹ g) ≠ 0) :
    frameSpace (extendFrame hk O (filledObservation (k := k) O x g)) (prefixSpace d (k+1)) ≤
      (frameSpace O (prefixSpace d k) ⊔ ℝ ∙ x) ⊔ ℝ ∙ g := by
  unfold filledObservation
  split_ifs with hx
  · exact (frameSpace_extendFrame_le hk O g hg).trans (sup_le_sup le_sup_left le_rfl)
  · exact (frameSpace_extendFrame_le hk O x hx).trans le_sup_left

end LogConcaveSampling.LowerBound

end LowerProof
end
end
end

end OAI