lean/OAI/Probability/LogConcave/OraclePrograms/MeanCorrect.lean

import Mathlib
import OAI.Probability.LogConcave.OraclePrograms.MeanSize
import OAI.Probability.LogConcave.Sampling.LogMeshCountRate

namespace OAI

section
noncomputable section
namespace LogConcaveSampling.OracleCompiler
open MeanTree MeasureTheory Quadrature
open scoped Classical NNReal

variable {d : ℕ}

lemma MeanSize.mono {lam q q' r σ : ℝ} (h : MeanSize lam q r σ) (hq : q≤q') :
    MeanSize lam q' r σ :=
  ⟨h.1,h.2.1,h.2.2.1,h.2.2.2.1.trans hq,
    h.2.2.2.2.trans (mul_le_mul_of_nonneg_right hq h.2.2.1.le)⟩

lemma SampleSize.mono {lam q q' r η : ℝ} (h : SampleSize lam q r η) (hq : q≤q') :
    SampleSize lam q' r η :=
  ⟨h.1,h.2.1,h.2.2.1,h.2.2.2.1,
    h.2.2.2.2.trans (mul_le_mul_of_nonneg_right hq h.2.2.1.le)⟩

lemma final_mean_size {lam q r σ R Af : ℝ} (hlam : 0≤lam)
    (h : MeanSize lam q r σ) (hR : 0<R) (hR1 : R≤1) (hAf : 0<Af) :
    MeanSize lam ((1+4*Af)*R*q) (r*R) (declaredNoise (Real.sqrt 3*σ/2) Af) := by
  have hr := h.1
  have hσ := h.2.2.1
  have hq := h.nonneg hlam
  have hroot : 1≤Real.sqrt 3 := by norm_num
  have hn : 0<declaredNoise (Real.sqrt 3*σ/2) Af := by unfold declaredNoise; positivity
  have hrR : r*R≤r := mul_le_of_le_one_right h.1.le hR1
  have hR2 : R^2≤R := by nlinarith
  have hsq := mul_le_mul_of_nonneg_right h.2.2.2.1 (sq_nonneg R)
  have hqR := mul_le_mul_of_nonneg_left hR2 hq
  have hAfR : R*q≤(1+4*Af)*R*q := by nlinarith [mul_nonneg hR.le hq]
  refine ⟨mul_pos h.1 hR,hrR.trans h.2.1,hn,?_,?_⟩
  · nlinarith [hsq]
  · have hσ : σ/(4*Af)≤declaredNoise (Real.sqrt 3*σ/2) Af := by
      unfold declaredNoise
      have hh := mul_le_mul_of_nonneg_right hroot h.2.2.1.le
      apply (le_div_iff₀ (by positivity : 0<2*Af)).2
      calc
        σ/(4*Af)*(2*Af)=σ/2 := by field_simp; ring
        _≤Real.sqrt 3*σ/2 := by linarith
    have hs := mul_le_mul_of_nonneg_right h.2.2.2.2 hR.le
    have ht := mul_le_mul_of_nonneg_left hσ (show 0≤4*Af*R*q by positivity)
    have hid : (4*Af*R*q)*(σ/(4*Af))=q*σ*R := by field_simp
    rw [hid] at ht
    have he : 4*Af*R*q≤(1+4*Af)*R*q := by nlinarith [mul_nonneg hR.le hq]
    have hh := mul_le_mul_of_nonneg_right he hn.le
    nlinarith

lemma final_sample_size {lam q r η r' Af : ℝ} (hlam : 0≤lam)
    (h : SampleSize lam q r η) (hr' : 0<r') (hhi : r'≤r) (hAf : 0<Af) :
    MeanSize lam ((1+4*Af)*q) r' (declaredNoise (η/Real.sqrt 2) (Af*r)) := by
  have hr := h.1
  have hη0 := h.2.2.1
  have hq := h.nonneg hlam
  have hs2 : 0<Real.sqrt 2 := by positivity
  have hs21 : Real.sqrt 2≤2 := by norm_num
  have hn : 0<declaredNoise (η/Real.sqrt 2) (Af*r) := by unfold declaredNoise; positivity
  have hl : lam*r^2≤q := h.2.2.2.2.trans (mul_le_of_le_one_right hq h.2.2.2.1)
  have hqf : q≤(1+4*Af)*q := by nlinarith
  refine ⟨hr',hhi.trans h.2.1,hn,?_,?_⟩
  · exact (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ hr'.le hhi 2) hlam).trans (hl.trans hqf)
  · have hη : η/(4*Af*r)≤declaredNoise (η/Real.sqrt 2) (Af*r) := by
      unfold declaredNoise
      apply (le_div_iff₀ (by positivity : 0<2*(Af*r))).2
      calc
        η/(4*Af*r)*(2*(Af*r))=η/2 := by field_simp [hr.ne']; ring
        _≤η/Real.sqrt 2 := div_le_div_of_nonneg_left h.2.2.1.le hs2 hs21
    have hh := mul_le_mul_of_nonneg_right hη (show 0≤4*Af*q by positivity)
    have hid : (η/(4*Af*r))*(4*Af*q)=q*η/r := by field_simp
    rw [hid] at hh
    have hs : lam*r≤q*η/r := (le_div_iff₀ h.1).2 (by nlinarith [h.2.2.2.2])
    have hm := mul_le_mul_of_nonneg_left hhi hlam
    have he := mul_le_mul_of_nonneg_right (show 4*Af*q≤(1+4*Af)*q by nlinarith) hn.le
    nlinarith

namespace CircuitParameters
variable (C : CircuitParameters)

lemma residual_pos : 0<Real.sqrt (1-C.T^2) := by
  apply Real.sqrt_pos.mpr
  nlinarith [C.T_lower,C.T_upper]
lemma residual_le_one : Real.sqrt (1-C.T^2)≤1 := by
  apply (Real.sqrt_le_iff).mpr
  exact ⟨by norm_num,by nlinarith [sq_nonneg C.T]⟩

theorem meanTree_valid {lam q r σ : ℝ} (hlam : 0≤lam) (hs : MeanSize lam q r σ)
    (hD : 0<C.D) (hψ : 0≤C.ψ) (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) :
    DeclaredRootValid C.D (C.meanCenterBudget r σ) C.Af
      (MeanSize lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q))
      (MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))))
      (C.meanTree (d:=d) r σ) (Real.sqrt 3*σ/2) := by
  have hA0 : 0<C.A := hA ▸ C.actualA_pos
  have hAf0 : 0<C.Af := hAf ▸ C.actualAf_pos
  have hr := hs.1
  have hσ := hs.2.2.1
  have hb : 0<C.meanCenterBudget r σ := by unfold meanCenterBudget; positivity
  have hR := C.residual_pos
  have hq := hs.nonneg hlam
  have hw := C.meanTree_actual_weights (d:=d) hs.1 hs.2.2.1 hψ
  rw [←hA,←hAf] at hw
  have hg := (literalMean_geometry (d:=d) (r:=r) (σ:=σ) (N:=C.N) (nc:=C.nc) (Nc:=C.Nc)
    (by linarith [C.T_lower]) C.T_upper C.h_pos C.v_nonneg C.angle_bound C.meanEndpoint).2
  apply declaredRootValid_of_radius_bounds hD (mul_pos hs.1 hR) _ _ _ (by positivity) hw.1 hw.2
  · exact centers_mono _ (fun r' b h => h.radius hs.1.le (by linarith [C.T_lower]) C.T_upper) hg
  · have hf := meanCircuit_final_radius (d:=d) r C.T C.h C.ψ (σ/2) C.n C.m C.N C.nc C.Nc C.meanEndpoint
      (anchor Prod.fst (by fun_prop)) (anchor (fun z : MeanInput d => z.2.1) (by fun_prop))
      (fun z : MeanInput d => z.2.2) (by fun_prop)
    cases he : C.meanTree (d:=d) r σ with | node k b hb a rr cc =>
      change ∀i, MeanSize _ _ (rr i) _
      have hf' : ∀i,rr i=r*Real.sqrt (1-C.T^2) := by
        change rootScales (fun r' => r'=r*Real.sqrt (1-C.T^2)) (C.meanTree r σ) at hf
        rw [he] at hf
        exact hf
      intro i
      rw [hf' i]
      exact final_mean_size hlam hs hR C.residual_le_one hAf0
  · intro r' n hlo hhi hn _
    apply (internal_meanSize hlam hq hs.1 hs.2.1 hR hD hb hs.2.2.2.1 hlo hhi hn).mono
    have hsmall := C.meanCenterBudget_small hs hA0.le
    have hh := mul_le_mul_of_nonneg_left hsmall (show 0≤4*C.D/Real.sqrt (1-C.T^2) by positivity)
    have hx : 0≤C.D*C.A*q/Real.sqrt (1-C.T^2) := by positivity
    nlinarith [show (4*C.D/Real.sqrt (1-C.T^2))*(lam*C.meanCenterBudget r σ)=
      4*C.D*lam*C.meanCenterBudget r σ/Real.sqrt (1-C.T^2) by ring,
      show (4*C.D/Real.sqrt (1-C.T^2))*(2*C.A*q)=8*(C.D*C.A*q/Real.sqrt (1-C.T^2)) by ring,
      show q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))=q+16*(C.D*C.A*q/Real.sqrt (1-C.T^2)) by ring]

theorem sampleTree_valid {lam q r η R : ℝ} (hlam : 0≤lam) (hs : SampleSize lam q r η)
    (hR : 0<R) (hRη : R≤η) (hD : 0<C.D)
    (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) :
    DeclaredRootValid C.D (C.sampleCenterBudget r) (C.sampleFinalBudget r)
      (MeanSize lam ((1+4*C.Af)*q))
      (MeanSize lam (q*(1+16*C.D*C.A/R)))
      (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) (η/Real.sqrt 2) := by
  have hA0 : 0<C.A := hA ▸ C.actualA_pos
  have hAf0 : 0<C.Af := hAf ▸ C.actualAf_pos
  have hr := hs.1
  have hη := hs.2.2.1
  have hq := hs.nonneg hlam
  have hb : 0<C.sampleCenterBudget r := by unfold sampleCenterBudget; positivity
  have hw := C.sampleTree_actual_weights (d:=d) hr hη hs.2.2.2.1
  rw [←hA,←hAf] at hw
  have hp := sampleCorrelation_properties hη hs.2.2.2.1
  have hg := (literalSample_geometry (d:=d) (r:=r) (N:=C.N) (Nat.succ_pos C.n)
    (by linarith [hp.1]) hp.2.1 C.h_pos (C.sampleEndpoint η hη hs.2.2.2.1)).2
  have hrad : centers (fun r' (_ : SampleInput d → Point d) => r*(R/4)≤r' ∧ r'≤r)
      (C.sampleTree r η hη hs.2.2.2.1) := by
    apply centers_mono _ (fun r' b h => ?_) hg
    have hh := h.radius hr.le (by linarith [hp.1]) hp.2.1
    have hlow := sampleCorrelation_radius_lower hη hs.2.2.2.1
    exact ⟨(mul_le_mul_of_nonneg_left (by linarith : R/4≤Real.sqrt (1-(sampleCorrelation η)^2)) hr.le).trans hh.1,hh.2⟩
  have hfinal : rootScales (fun r' => MeanSize lam ((1+4*C.Af)*q) r'
      (declaredNoise (η/Real.sqrt 2) (C.sampleFinalBudget r)))
      (C.sampleTree (d:=d) r η hη hs.2.2.2.1) := by
    cases he : C.sampleTree (d:=d) r η hη hs.2.2.2.1 with | node k b hb a rr cc =>
      rw [he] at hrad
      intro i
      exact final_sample_size hlam hs ((by positivity : 0<r*(R/4)).trans_le (hrad i).1.1)
        (hrad i).1.2 hAf0
  apply declaredRootValid_of_radius_bounds hD (by positivity : 0<r*(R/4)) _ _ _
    (by positivity) hw.1 hw.2 hrad hfinal
  intro r' n hlo hhi hn _
  have hl : lam*r^2≤q := hs.2.2.2.2.trans (mul_le_of_le_one_right hq hs.2.2.2.1)
  apply (internal_meanSize hlam hq hr hs.2.1 (by positivity : 0<R/4) hD hb hl hlo hhi hn).mono
  have hsml := C.sampleCenterBudget_small hlam hs hA0.le
  have hh := mul_le_mul_of_nonneg_left hsml (show 0≤16*C.D/R by positivity)
  calc
    q+4*C.D*lam*C.sampleCenterBudget r/(R/4)
        = q+(16*C.D/R)*(lam*C.sampleCenterBudget r) := by ring
    _≤q+(16*C.D/R)*(C.A*q) := add_le_add le_rfl hh
    _=q*(1+16*C.D*C.A/R) := by ring

lemma mean_anchor_size {lam q r σ : ℝ} (hlam : 0≤lam) (hs : MeanSize lam q r σ)
    (hRT : Real.sqrt (1-C.T^2)≤C.T) :
    SampleSize lam (q/Real.sqrt (1-C.T^2)) r (Real.sqrt (1-C.T^2)/C.T) := by
  have hT : 0<C.T := by linarith [C.T_lower]
  have hR := C.residual_pos
  have hq := hs.nonneg hlam
  refine ⟨hs.1,hs.2.1,div_pos hR hT,(div_le_one hT).2 hRT,?_⟩
  calc
    lam*r^2≤q := hs.2.2.2.1
    _≤q/C.T := (le_div_iff₀ hT).2 (mul_le_of_le_one_right hq C.T_upper.le)
    _=(q/Real.sqrt (1-C.T^2))*(Real.sqrt (1-C.T^2)/C.T) := by field_simp

end CircuitParameters
end LogConcaveSampling.OracleCompiler

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler
open MeasureTheory ProbabilityTheory Coupling
open scoped Classical NNReal

variable {d : ℕ}

structure MeanCorrect (F : Point d → ℝ) (lam q K e : ℝ)
    (M : ℝ → ℝ → SeedProgram d) : Prop where
  lip : ∀r σ,MeanSize lam q r σ → ∀x y g,
    ‖(M r σ).program.run F (x,g)-(M r σ).program.run F (y,g)‖≤lam*K*‖x-y‖
  error : ∀r σ,MeanSize lam q r σ → ∀x,
    SquaredAt (gaussianTape d (M r σ).slots) (stdGaussian (Point d))
      (fun g => (M r σ).program.run F (x,g))
      (fun g => primitiveExpectedField F x r+σ • g) (σ^2*e^2*(circuitD F x)^2)

structure SampleCorrect (F : Point d → ℝ) (lam q K e : ℝ) (ηmin : ℝ)
    (S : ℝ → ℝ → ReservedProgram d) : Prop where
  lip : ∀r η,SampleSize lam q r η → ηmin≤η → ∀x y g,
    ‖(S r η).pre.run F (x,g)-(S r η).pre.run F (y,g)‖≤lam*r*K*‖x-y‖
  error : ∀r η,SampleSize lam q r η → ηmin≤η → ∀x,
    SquaredAt (gaussianTape d (S r η).slots)
      ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d)))
      (fun g => (S r η).pre.run F (x,g))
      (fun z => z.1+(Real.sqrt 3*η/2) • z.2) (e^2*(circuitD F x)^2)

lemma primitive_terminal_envelope (F : Point d → ℝ) (x : Point d) {r c : ℝ}
    (hr : 0≤r) (hr1 : r≤1) (hc : 0≤c) :
    2*(Real.pi*Real.sqrt d+c*r*‖primitiveField F x r 0‖)^2+2*d≤
      (2*(Real.pi+c)^2+2)*(circuitD F x)^2 := by
  rw [field_zero_eq_gradient]
  have hs := sqrt_le_circuitD F x
  have hg : ‖gradient F x‖≤circuitD F x := le_add_of_nonneg_left (Real.sqrt_nonneg _)
  have hcr := mul_le_mul_of_nonneg_left hr1 hc
  have hcg := mul_le_mul_of_nonneg_left hg hc
  have hrG := mul_le_mul_of_nonneg_right hcr (norm_nonneg (gradient F x))
  have hp := mul_le_mul_of_nonneg_left hs Real.pi_pos.le
  have hu : Real.pi*Real.sqrt d+c*r*‖gradient F x‖≤(Real.pi+c)*circuitD F x := by nlinarith
  have hu2 := pow_le_pow_left₀ (show 0≤Real.pi*Real.sqrt d+c*r*‖gradient F x‖ by positivity) hu 2
  have hd2 := pow_le_pow_left₀ (Real.sqrt_nonneg (d:ℝ)) hs 2
  rw [Real.sq_sqrt (Nat.cast_nonneg d)] at hd2
  nlinarith

lemma terminalMean_correct {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    {q : ℝ} (hq : q≤1/2) :
    MeanCorrect F lam q 1 ((4*(Real.pi+2))*q) (terminalMeanProgram d) := by
  constructor
  · intro r σ hs x y g
    change ‖(SeedCompiler.terminalMean d r σ).run F (x,g)-
      (SeedCompiler.terminalMean d r σ).run F (y,g)‖≤(lam:ℝ)*1*‖x-y‖
    simp only [mul_one]
    exact (SeedCompiler.terminalMean_fixedSeed_lip hF.gradient_lipschitz r σ g).norm_sub_le x y
  · intro r σ hs x
    apply (terminalMeanProgram_squared hF x hs.1.le (hs.2.2.2.1.trans hq) σ).mono
    have hb := primitive_terminal_envelope F x hs.1.le hs.2.1 (c:=1) (by norm_num)
    simp only [one_mul] at hb
    have hq0 := hs.nonneg lam.coe_nonneg
    have hr := hs.1
    have hsq := pow_le_pow_left₀ (show 0≤(lam:ℝ)*r by positivity) hs.2.2.2.2 2
    have hm := mul_le_mul_of_nonneg_left hb (sq_nonneg (2*((lam:ℝ)*r)))
    have hc : 4*(2*(Real.pi+1)^2+2)≤(4*(Real.pi+2))^2 := by nlinarith [Real.pi_pos]
    have h₁ := mul_le_mul_of_nonneg_right hsq (show 0≤4*(2*(Real.pi+1)^2+2)*(circuitD F x)^2 by positivity)
    have h₂ := mul_le_mul_of_nonneg_right hc (show 0≤(q*σ)^2*(circuitD F x)^2 by positivity)
    nlinarith

lemma terminalSample_correct {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    {q : ℝ} (hq : q≤1/2) (ηmin : ℝ) :
    SampleCorrect F lam q 1 ((2*terminalTransportConstant*(Real.pi+3))*q) ηmin
      (terminalReservedProgram d) := by
  constructor
  · intro r η hs _ x y g
    have hh := terminalReservedProgram_lipschitz r η hF x y g
    rw [abs_of_pos hs.1] at hh
    simpa only [mul_one,mul_comm r (lam:ℝ)] using hh
  · intro r η hs _ x
    have hq0 := hs.nonneg lam.coe_nonneg
    have hl : (lam:ℝ)*r^2≤q := hs.2.2.2.2.trans
      (mul_le_of_le_one_right hq0 hs.2.2.2.1)
    apply (terminalReservedProgram_squared hF x hs.1.le (hl.trans hq) η).mono
    have hb := primitive_terminal_envelope F x hs.1.le hs.2.1 (c:=2) (by norm_num)
    have hsq := pow_le_pow_left₀ (show 0≤(lam:ℝ)*r^2 by positivity) hl 2
    have hm := mul_le_mul_of_nonneg_left hb (sq_nonneg (terminalTransportConstant*((lam:ℝ)*r^2)))
    have hc : 2*(Real.pi+2)^2+2≤(2*(Real.pi+3))^2 := by nlinarith [Real.pi_pos]
    have h₁ := mul_le_mul_of_nonneg_right hsq (show 0≤terminalTransportConstant^2*(2*(Real.pi+2)^2+2)*(circuitD F x)^2 by positivity)
    have h₂ := mul_le_mul_of_nonneg_right hc (show 0≤terminalTransportConstant^2*q^2*(circuitD F x)^2 by positivity)
    nlinarith
end LogConcaveSampling.OracleCompiler

end

end

end OAI