import Mathlib
import OAI.Probability.LogConcave.LowerBounds.DensityCoefficient
import OAI.Probability.LogConcave.Sampling.Map

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 WithLp
open MeasureTheory ProbabilityTheory
open scoped ENNReal NNReal
open Matrix
open Polynomial
open scoped BigOperators

namespace LogConcaveSampling.LowerBound
open WithLp
open scoped RealInnerProductSpace

lemma spectrum_iterate_apply {d : ℕ} (j : ℕ) (x : Point d) (k : Fin d) :
    ((spectrumOperator d).toLinearMap^[j]) x k = x k * eigenvalue d k ^ j := by
  induction j with
  | zero => simp
  | succ j ih =>
    rw [Function.iterate_succ_apply']
    change spectrumOperator d (((spectrumOperator d).toLinearMap^[j]) x) k = _
    rw [spectrumOperator_apply,ih,pow_succ]
    ring

lemma orbitHull_in_krylov {d r : ℕ} (a : Fin (r+1) → Point d) {u : Point d}
    (hu : u ∈ orbitHull (spectrumOperator d).toLinearMap r a) :
    ofLp u ∈ krylovSpace (fun k i => a i k) := by
  let coord : Point d →ₗ[ℝ] (Fin d → ℝ) :=
    {toFun := ofLp, map_add' := by intros; rfl, map_smul' := by intros; rfl}
  have h : orbitHull (spectrumOperator d).toLinearMap r a ≤
      (krylovSpace (fun k i => a i k)).comap coord := by
    apply Submodule.span_le.mpr
    rintro v ⟨i,j,hj,rfl⟩
    apply Submodule.subset_span
    refine ⟨i,j,hj,?_⟩
    funext k
    exact spectrum_iterate_apply j (a i) k
  exact h hu

lemma linearReply_eq_quadratic {d : ℕ} (O : Rotations d) (x : Point d) :
    linearReply (spectrumOperator d) O x = firstOrderReply (quadraticPotential O) x := by
  rw [quadratic_firstOrderReply]
  apply Prod.ext
  · change ⟪(rotationIsometry O).symm x, spectrumOperator d ((rotationIsometry O).symm x)⟫ / 2 = _
    have h := (rotationIsometry O).inner_map_map ((rotationIsometry O).symm x)
      (spectrumOperator d ((rotationIsometry O).symm x))
    simpa only [LinearIsometryEquiv.apply_symm_apply, quadraticOperator,
      ContinuousLinearMap.comp_apply, LinearIsometryEquiv.coe_toContinuousLinearEquiv,
      ContinuousLinearEquiv.coe_coe] using congrArg (fun z : ℝ => z/2) h.symm
  · rfl

lemma linearHistory_eq_quadratic {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (O : Rotations d) (ω : Ω) (n : ℕ) :
    linearHistory A (spectrumOperator d) O ω n = A.history (quadraticPotential O) ω n := by
  induction n with
  | zero => rfl
  | succ n ih => simp only [linearHistory,OracleAlgorithm.history,ih,linearReply_eq_quadratic]

def hardEigenOutput {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) (p : Ω × Rotations d) : Fin d → ℝ :=
  ofLp ((rotationIsometry p.2).symm (A.run (quadraticPotential p.2) p.1))

lemma measurable_hardEigenOutput {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (A : OracleAlgorithm Ω d q) : Measurable (hardEigenOutput A) := by
  have hr : Measurable (fun p : Ω × Rotations d => A.run (quadraticPotential p.2) p.1) := by
    simpa only [OracleAlgorithm.run,← linearHistory_eq_quadratic,Function.comp_def] using
      A.output_measurable.comp (measurable_fst.prodMk (measurable_linearHistory A (spectrumOperator d) q))
  have haction : Measurable (fun p : Rotations d × Point d => (rotationIsometry p.1).symm p.2) := by
    have hh := (continuous_rotation_apply (d := d)).measurable.comp
      (f := fun p : Rotations d × Point d => (p.1⁻¹,p.2))
      (measurable_fst.inv.prodMk measurable_snd)
    simpa only [Function.comp_def,rotationIsometry_inv_apply] using hh
  exact (measurable_ofLp 2 _).comp (f := fun p : Ω × Rotations d =>
    (rotationIsometry p.2).symm (A.run (quadraticPotential p.2) p.1))
    (haction.comp (f := fun p : Ω × Rotations d =>
      (p.2,A.run (quadraticPotential p.2) p.1)) (measurable_snd.prodMk hr))

theorem hard_algorithm_separation {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (μ : Measure Ω) [IsProbabilityMeasure μ] (A : OracleAlgorithm Ω d q)
    (hd : 2*q+1 ≤ d) (hqd : 4*(q+q)+1 < 2*d) (ht : blockTolerance d (q+q) ≤ 1/2) :
    (μ.prod (rotationHaar d)).real {p | hardEigenOutput A p ∈ separationEvent d (q+q)} ≤ 1/100 := by
  let P := couplingLaw μ d q
  let U : CouplingNoise Ω d q → Fin d → ℝ := fun p =>
    ofLp (finishCoordinate A (by omega) (couplingState A (spectrumOperator d) hd p).1)
  let rows : CouplingNoise Ω d q → Fin d → Fin (q+q+1) → ℝ := fun p k i => couplingColumns p i k
  have hrows : HasLaw rows (gaussianRows d (q+q+1)) P := by
    have he : MeasurePreserving (fun a : Fin (q+q+1) → Point d => fun k i => a i k)
        (Measure.pi (fun _ : Fin (q+q+1) => stdGaussian (Point d))) (gaussianRows d (q+q+1)) :=
      ⟨by fun_prop,gaussianColumns_rows_law d (q+q+1)⟩
    exact (he.comp (couplingColumns_law μ)).hasLaw
  have hU : ∀ᵐ p ∂P, U p ∈ krylovSpace (rows p) := by
    filter_upwards [coupling_output_span μ A (spectrumOperator d) hd] with p hp
    exact orbitHull_in_krylov (couplingColumns p) hp
  have hb := algorithm_span_separation_bound hqd ht hrows U hU
  have he : ∀ᵐ p ∂P, U p = hardEigenOutput A
      (finishComplete A (by omega) (couplingState A (spectrumOperator d) hd p)) := by
    filter_upwards [coupling_output_correct μ A (spectrumOperator d) hd] with p hp
    simpa only [hardEigenOutput,OracleAlgorithm.run,linearHistory_eq_quadratic] using congrArg ofLp hp
  have hmeas : MeasurableSet {p | hardEigenOutput A p ∈ separationEvent d (q+q)} :=
    (separationEvent_measurable d (q+q)).preimage (measurable_hardEigenOutput A)
  rw [← coupling_complete_law μ A (spectrumOperator d) hd,
    Measure.real,Measure.map_apply
      ((measurable_finishComplete A (by omega)).comp (measurable_couplingState A (spectrumOperator d) hd)) hmeas]
  change P.real {p | hardEigenOutput A (finishComplete A (by omega) (couplingState A (spectrumOperator d) hd p)) ∈ separationEvent d (q+q)} ≤ _
  have hs : {p | hardEigenOutput A (finishComplete A (by omega) (couplingState A (spectrumOperator d) hd p)) ∈ separationEvent d (q+q)}
      =ᵐ[P] {p | U p ∈ separationEvent d (q+q)} := by
    filter_upwards [he] with p hp
    exact congrArg (fun z : Fin d → ℝ => z ∈ separationEvent d (q+q)) hp.symm
  rwa [measureReal_congr hs]

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

lemma quadratic_gibbs_eigenframe {d : ℕ} (O : Rotations d) :
    (gibbs (quadraticPotential O)).map (fun x => ofLp ((rotationIsometry O).symm x)) =
      targetGaussian d := by
  rw [← quadratic_gibbs_eq_gaussian O,Measure.map_map (by fun_prop) (by fun_prop)]
  simp only [Function.comp_def,LinearIsometryEquiv.symm_apply_apply,WithLp.ofLp_toLp]
  exact Measure.map_id

lemma hardEigenOutput_tv {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}
    (μ : Measure Ω) [IsProbabilityMeasure μ] (A : OracleAlgorithm Ω d q)
    (h : ∀ O : Rotations d, TVAtMost (μ.map (A.run (quadraticPotential O)))
      (gibbs (quadraticPotential O)) (1/10)) (O : Rotations d) :
    TVAtMost (μ.map (fun ω => hardEigenOutput A (ω,O))) (targetGaussian d) (1/10) := by
  have hr : Measurable (A.run (quadraticPotential O)) := by
    change Measurable (fun ω : Ω => A.output (ω,A.history (quadraticPotential O) ω q))
    simp_rw [← linearHistory_eq_quadratic A O]
    exact A.output_measurable.comp (f := fun ω : Ω =>
      (ω,linearHistory A (spectrumOperator d) O ω q))
      (measurable_id.prodMk ((measurable_linearHistory A (spectrumOperator d) q).comp
        (f := fun ω : Ω => (ω,O)) (measurable_id.prodMk measurable_const)))
  have ht := (h O).map (f := fun x => ofLp ((rotationIsometry O).symm x)) (by fun_prop)
  rwa [quadratic_gibbs_eigenframe,Measure.map_map (by fun_prop) hr] at ht

theorem canSample_target_separation_bound {d q : ℕ}
    (hd : 2*q+1 ≤ d) (hqd : 4*(q+q)+1 < 2*d) (ht : blockTolerance d (q+q) ≤ 1/2)
    (h : CanSample d q) : (targetGaussian d).real (separationEvent d (q+q)) ≤ 11/100 := by
  obtain ⟨Ω,mΩ,μ,hμ,A,hA⟩ := h
  have hTV := hardEigenOutput_tv μ A (fun O => (hA _ (quadraticPotential_admissible O)).2)
  have hevent := hard_algorithm_separation μ A hd hqd ht
  have hm : MeasurableSet {p | hardEigenOutput A p ∈ separationEvent d (q+q)} :=
    (separationEvent_measurable d (q+q)).preimage (measurable_hardEigenOutput A)
  have hlower := prob_prod_event_lower μ (rotationHaar d) hm
    (a := (targetGaussian d).real (separationEvent d (q+q)) - 1/10) (fun O => by
      have hh := hTV O _ (separationEvent_measurable d (q+q))
      have hb : Measurable (fun ω : Ω => hardEigenOutput A (ω,O)) :=
        (measurable_hardEigenOutput A).comp (f := fun ω : Ω => (ω,O))
          (measurable_id.prodMk measurable_const)
      rw [Measure.real,Measure.map_apply hb (separationEvent_measurable d (q+q))] at hh
      have hh' := (abs_le.mp hh).1
      change -(1/10 : ℝ) ≤ μ.real {ω | hardEigenOutput A (ω,O) ∈ separationEvent d (q+q)} - _ at hh'
      change _ ≤ μ.real {ω | hardEigenOutput A (ω,O) ∈ separationEvent d (q+q)}
      linarith)
  linarith

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

lemma spectralDecay_bounds : (1/8 : ℝ) ≤ spectralDecay ∧ spectralDecay ≤ 1/4 := by
  have h := Real.sq_sqrt (show (0 : ℝ) ≤ 2 by norm_num)
  have h' := Real.sqrt_nonneg (2 : ℝ)
  dsimp [spectralDecay]
  constructor <;> nlinarith

theorem target_mean_lower {d r : ℕ} (hn : 2*r+1 < d) :
    (d : ℝ) / (4 * 8^(2*r+1)) ≤
      |∫ u, diagonalStatistic (fun k : Fin d => weight d (2*r+1) k) u ∂targetGaussian d| := by
  let n := 2*r+1
  let m := ∫ u, diagonalStatistic (fun k : Fin d => weight d (2*r+1) k) u ∂targetGaussian d
  have hr := (lower_target_statistic hn).1
  have hp : 0 < spectralDecay := spectralDecay_pos
  have hb := spectralDecay_bounds
  have hd : (0 : ℝ) ≤ d := Nat.cast_nonneg d
  have hs : 0 < Real.sqrt (2 : ℝ) := Real.sqrt_pos.mpr (by norm_num)
  have hs2 : Real.sqrt (2 : ℝ) ≤ 2 := by nlinarith [Real.sq_sqrt (show (0 : ℝ) ≤ 2 by norm_num)]
  have hp2 : spectralDecay^2 ≤ 1/16 := by nlinarith
  have hpow : spectralDecay^(2*d-n) ≤ spectralDecay^(n+2) :=
    pow_le_pow_of_le_one hp.le spectralDecay_lt_one.le (by dsimp [n]; omega)
  have hrem : Real.sqrt 2 * d * spectralDecay^(2*d-n) / (1-spectralDecay) ≤
      (d : ℝ) * spectralDecay^n / 4 := by
    calc
      _ ≤ 2 * d * spectralDecay^(n+2) / (1/2) := by
        apply div_le_div₀ (by positivity)
        · gcongr
        · norm_num
        · linarith
      _ = 4 * d * spectralDecay^n * spectralDecay^2 := by rw [pow_add]; ring
      _ ≤ (d : ℝ) * spectralDecay^n / 4 := by
        have hh := mul_le_mul_of_nonneg_left hp2 (mul_nonneg hd (pow_nonneg hp.le n))
        nlinarith
  have hlead : (d : ℝ) * spectralDecay^n / 2 ≤ |(d : ℝ) / Real.sqrt 2 * (-spectralDecay)^n| := by
    rw [abs_mul,abs_div,abs_pow,abs_neg,abs_of_nonneg hd,abs_of_pos hs,abs_of_pos hp]
    calc
      _ = ((d : ℝ)/2) * spectralDecay^n := by ring
      _ ≤ _ := by gcongr
  have htri := abs_sub_abs_le_abs_sub ((d : ℝ) / Real.sqrt 2 * (-spectralDecay)^n) m
  rw [abs_sub_comm] at htri
  have hmean : (d : ℝ) * spectralDecay^n / 4 ≤ |m| := by
    change |m - (d : ℝ) / Real.sqrt 2 * (-spectralDecay)^n| ≤ _ at hr
    linarith only [hr,hrem,hlead,htri]
  calc
    _ = (d : ℝ) * (1/8)^n / 4 := by rw [div_pow]; simp only [one_pow]; field_simp; rfl
    _ ≤ (d : ℝ) * spectralDecay^n / 4 := by gcongr; exact hb.1
    _ ≤ _ := hmean

lemma lower_denominator (q : ℕ) : (4 : ℝ) * 8^(2*(q+q)+1) = 2^(12*q+5) := by
  rw [show (4 : ℝ) = 2^2 by norm_num, show (8 : ℝ) = 2^3 by norm_num,
    ← pow_mul,← pow_add]
  congr 1
  omega

lemma polynomial_threshold_le_pow (q : ℕ) :
    160 * ((q+q : ℕ)+1 : ℝ)^2 + 20 ≤ (2 : ℝ)^(2*q+10) := by
  have hq : ((q+q : ℕ)+1 : ℝ) ≤ (2 : ℝ)^(q+1) := by
    have h := (Nat.lt_two_pow_self (n := q)).succ_le
    have hh : (q : ℝ)+1 ≤ (2 : ℝ)^q := by exact_mod_cast h
    push_cast
    rw [pow_succ]
    linarith
  have hp : (1 : ℝ) ≤ 2^(2*q+2) := one_le_pow₀ (by norm_num)
  have hsq : (((q+q : ℕ)+1 : ℝ)^2) ≤ (2 : ℝ)^(2*q+2) := by
    calc
      _ ≤ ((2 : ℝ)^(q+1))^2 := by gcongr
      _ = _ := by rw [← pow_mul]; congr 1; omega
  calc
    _ ≤ 180 * (2 : ℝ)^(2*q+2) := by nlinarith
    _ ≤ 256 * (2 : ℝ)^(2*q+2) := by gcongr; norm_num
    _ = _ := by rw [show 256 = (2:ℝ)^8 by norm_num,← pow_add]; congr 1; omega

lemma sqrt_exponential_lower {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) :
    (2 : ℝ)^(32*(q+1)) ≤ Real.sqrt d := by
  apply (Real.le_sqrt (by positivity) (by positivity)).mpr
  have hh : (2 : ℝ)^(64*(q+1)) ≤ d := by exact_mod_cast hd
  convert hh using 1
  rw [← pow_mul]
  congr 1
  omega

lemma target_large_mean {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) (hn : 2*(q+q)+1 < d) :
    separationThreshold d (q+q) + 20 * Real.sqrt d ≤
      |∫ u, diagonalStatistic (fun k : Fin d => weight d (2*(q+q)+1) k) u ∂targetGaussian d| := by
  have hm := target_mean_lower hn
  rw [lower_denominator] at hm
  have hs := sqrt_exponential_lower hd
  have hcoeff := polynomial_threshold_le_pow q
  have hp : (2 : ℝ)^(2*q+10) * 2^(12*q+5) ≤ Real.sqrt d := by
    calc
      _ = (2 : ℝ)^(14*q+15) := by rw [← pow_add]; congr 1; omega
      _ ≤ 2^(32*(q+1)) := by apply pow_le_pow_right₀ (by norm_num); omega
      _ ≤ _ := hs
  have hh : (160 * (((q+q : ℕ)+1 : ℝ))^2 + 20) * 2^(12*q+5) ≤ Real.sqrt d :=
    le_trans (mul_le_mul_of_nonneg_right hcoeff (by positivity)) hp
  have hh' := mul_le_mul_of_nonneg_right hh (Real.sqrt_nonneg (d : ℝ))
  rw [← sq,Real.sq_sqrt (Nat.cast_nonneg d)] at hh'
  calc
    _ = (160 * (((q+q : ℕ)+1 : ℝ))^2 + 20) * Real.sqrt d := by
      unfold separationThreshold
      push_cast
      ring
    _ ≤ (d : ℝ) / 2^(12*q+5) := by
      apply (le_div_iff₀ (by positivity)).mpr
      nlinarith only [hh']
    _ ≤ _ := hm

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

lemma exponential_dimension_bounds {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) :
    100 ≤ d ∧ 2*(q+q)+1 < d ∧ 2*q+1 ≤ d ∧ 4*(q+q)+1 < 2*d := by
  have hlin := (Nat.lt_two_pow_self (n := 64*(q+1))).trans_le hd
  have hexp : 2^64 ≤ 2^(64*(q+1)) := pow_le_pow_right₀ (by norm_num) (by omega)
  have h100 : 100 ≤ d := le_trans (by norm_num : 100 ≤ 2^64) (hexp.trans hd)
  omega

lemma exponential_tolerance {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) :
    blockTolerance d (q+q) ≤ 1/2 := by
  have hpos : 0 < d := by have := (exponential_dimension_bounds hd).1; omega
  have hs := sqrt_exponential_lower hd
  have hcoeff := polynomial_threshold_le_pow q
  have hp : (2 : ℝ)^(2*q+10) ≤ 2^(32*(q+1)) :=
    pow_le_pow_right₀ (by norm_num) (by omega)
  have hh : 80 * (((q+q : ℕ)+1 : ℝ))^2 ≤ Real.sqrt d := by
    have hsq := sq_nonneg (((q+q : ℕ)+1 : ℝ))
    linarith
  unfold blockTolerance
  apply (div_le_iff₀ (Real.sqrt_pos.mpr (by exact_mod_cast hpos))).mpr
  push_cast at hh ⊢
  linarith

theorem target_event_large {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) :
    9/10 ≤ (targetGaussian d).real (separationEvent d (q+q)) := by
  have hb := exponential_dimension_bounds hd
  have hpos : 0 < d := by omega
  have hdr : (0 : ℝ) < d := by exact_mod_cast hpos
  have hsqrt : 0 < Real.sqrt (d : ℝ) := Real.sqrt_pos.mpr hdr
  have hm := target_large_mean hd hb.2.1
  let m := |∫ u, diagonalStatistic (fun k : Fin d => weight d (2*(q+q)+1) k) u ∂targetGaussian d|
  have hmargin : 20 * Real.sqrt d ≤ m - separationThreshold d (q+q) := by
    dsimp [m]; linarith only [hm]
  have hsep : separationThreshold d (q+q) < m := by linarith
  have htail := target_separation_tail hpos hsep
  have hden : 400 * (d : ℝ) ≤ (m-separationThreshold d (q+q))^2 := by
    calc
      _ = (20 * Real.sqrt (d : ℝ))^2 := by rw [mul_pow,Real.sq_sqrt hdr.le]; ring
      _ ≤ _ := by gcongr
  have h₁ : 2/(d : ℝ) ≤ 1/50 := by
    apply (div_le_iff₀ hdr).mpr
    have hh : (100 : ℝ) ≤ d := by exact_mod_cast hb.1
    linarith
  have h₂ : 2*d/(m-separationThreshold d (q+q))^2 ≤ 1/200 := by
    apply (div_le_iff₀ (sq_pos_of_pos (sub_pos.mpr hsep))).mpr
    linarith
  rw [measureReal_compl (separationEvent_measurable d (q+q)),probReal_univ] at htail
  change 1 - (targetGaussian d).real (separationEvent d (q+q)) ≤ 2/(d : ℝ) +
    2*d/(m-separationThreshold d (q+q))^2 at htail
  linarith

end LogConcaveSampling.LowerBound

namespace LogConcaveSampling.LowerBound

theorem not_canSample_exponential {d q : ℕ} (hd : 2^(64*(q+1)) ≤ d) : ¬ CanSample d q := by
  intro h
  have hb := exponential_dimension_bounds hd
  have h₁ := canSample_target_separation_bound hb.2.2.1 hb.2.2.2 (exponential_tolerance hd) h
  have h₂ := target_event_large hd
  linarith

lemma exponential_of_small_log {d q : ℕ} (hd : 2^128 ≤ d)
    (hq : (q : ℝ) < (128 * Real.log 2)⁻¹ * Real.log d) : 2^(64*(q+1)) ≤ d := by
  have hl : 0 < Real.log (2 : ℝ) := Real.log_pos (by norm_num)
  have hdp : 0 < d := lt_of_lt_of_le (by positivity) hd
  have hdr : (0 : ℝ) < d := by exact_mod_cast hdp
  have hd' : (2 : ℝ)^128 ≤ d := by exact_mod_cast hd
  have hlog : 128 * Real.log (2 : ℝ) ≤ Real.log d := by
    have hh := Real.log_le_log (by positivity) hd'
    simpa only [Real.log_pow, Nat.cast_ofNat] using hh
  have hq' : 128 * Real.log (2 : ℝ) * q < Real.log d := by
    have hh := mul_lt_mul_of_pos_left hq (show 0 < 128 * Real.log (2 : ℝ) by positivity)
    rwa [← mul_assoc,mul_inv_cancel₀ (by positivity),one_mul] at hh
  have hx : Real.log ((2 : ℝ)^(64*(q+1))) ≤ Real.log d := by
    rw [Real.log_pow]
    push_cast
    nlinarith only [hlog,hq']
  have hexp := (Real.log_le_log_iff (by positivity) hdr).mp hx
  exact_mod_cast hexp

theorem source_logarithmic_lower :
    ∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, 2 ≤ d₀ ∧ ∀ d : ℕ, d₀ ≤ d →
      ENNReal.ofReal (c * Real.log (d : ℝ)) ≤ (queryComplexity d).toENNReal := by
  refine ⟨(128 * Real.log 2)⁻¹, by positivity, 2^128, by norm_num, ?_⟩
  intro d hd
  have hfeasible : ∀ q : ℕ, CanSample d q → (128 * Real.log 2)⁻¹ * Real.log d ≤ q := by
    intro q hq
    by_contra hh
    exact not_canSample_exponential (exponential_of_small_log hd (lt_of_not_ge hh)) hq
  unfold queryComplexity
  rw [sInf_image]
  simp only [ENat.toENNReal_iInf]
  apply le_iInf
  intro q
  apply le_iInf
  intro hq
  simpa only [ENat.toENNReal_coe,ENNReal.ofReal_natCast] using
    ENNReal.ofReal_le_ofReal (hfeasible q hq)

end LogConcaveSampling.LowerBound

end LowerProof

end

end

end

end OAI