import Mathlib
import OAI.Probability.LogConcave.OraclePrograms.MeanCorrect
import OAI.Probability.LogConcave.OraclePrograms.CalibratedMeanCircuit
import OAI.Probability.LogConcave.OraclePrograms.PairDistBounds
import OAI.Probability.LogConcave.OraclePrograms.ShiftInvariant
import OAI.Probability.LogConcave.Sampling.PrependTape
import OAI.Probability.LogConcave.Dynamics.ProbabilityFlowGrowth

namespace OAI

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

variable {d : ℕ}

def fullTape (k : ℕ) (z : (Fin k → Point d) × Point d) : Fin (k+1) → Point d :=
  Fin.append z.1 (fun _ => z.2)

lemma fullTape_preserving (k : ℕ) :
    MeasurePreserving (fullTape (d:=d) k) ((gaussianTape d k).prod (stdGaussian (Point d)))
      (gaussianTape d (k+1)) := by
  exact (MeanTree.appendSlots_preserving (stdGaussian (Point d)) k 1).comp
    ((MeasurePreserving.id _).prod (oneSlot_preserving (stdGaussian (Point d))))

lemma full_fixedSeed {V : Point d → ℝ} (S : ReservedProgram d) {K : ℝ}
    (h : ∀x y g,‖S.pre.run V (x,g)-S.pre.run V (y,g)‖≤K*‖x-y‖) :
    ∀x y g,‖S.full.program.run V (x,g)-S.full.program.run V (y,g)‖≤K*‖x-y‖ := by
  intro x y g
  have hx := full_run S V x g
  have hy := full_run S V y g
  rw [hx,hy,add_sub_add_right_eq_sub]
  exact h x y _

lemma anchor_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    (x : Point d) (S : ReservedProgram d) {r T η B : ℝ}
    (hr : 0≤r) (hl : (lam:ℝ)*r^2<1) (hT : 0≤T)
    (hη : T*η=Real.sqrt (1-T^2)) (hreserve : S.reserve=η/2)
    (hpre : SquaredAt (gaussianTape d S.slots)
      ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d)))
      (fun g => S.pre.run F (x,g)) (fun z => z.1+(Real.sqrt 3*η/2) • z.2) B) :
    SquaredAt (gaussianTape d S.full.slots) (interpolationLaw F x r T)
      (fun g => T • S.full.program.run F (x,g)) id (T^2*B) := by
  let := probability_gibbs_of_partition
    (partition_pos_of_continuous (hF.continuous_potential x r)).ne'
    (partition_ne_top_of_integrable (hF.integrable_exp_neg_potential x hr hl))
  have hV : Measurable (fun z => (F z,gradient F z)) :=
    hF.smooth.continuous.measurable.prodMk hF.gradient_lipschitz.continuous.measurable
  have hf : Measurable (fun g => S.pre.run F (x,g)) :=
    (S.pre.measurable_run F hV).comp (by fun_prop)
  have hfull : Measurable (fun g => T • S.full.program.run F (x,g)) := by
    have hh := (S.full.program.measurable_run F hV).comp (show Measurable (fun z : Fin S.full.slots → Point d => (x,z)) by fun_prop)
    fun_prop
  let H : Point d → Point d → Point d := fun a g => T • (a+S.reserve • g)
  have hh := hpre.shared_lipschitz (stdGaussian (Point d)) hf (by fun_prop) hT H (by fun_prop)
    (fun a b g => by simp only [H,←smul_sub,add_sub_add_right_eq_sub,norm_smul,Real.norm_eq_abs,abs_of_nonneg hT]; exact le_rfl)
  have hnoise := smoothing_add_gaussian
    ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))) (gibbs (primitivePotential F x r))
    (fun z => z.1+(Real.sqrt 3*η/2) • z.2) id (by fun_prop) measurable_id
    (Real.sqrt 3*η/2) (η/2) η (by
      rw [div_pow,mul_pow,Real.sq_sqrt (by norm_num : (0:ℝ)≤3),div_pow]; ring) rfl
  have hnoise' := congrArg (Measure.map (fun z : Point d => T • z)) hnoise
  rw [Measure.map_map (by fun_prop) (by fun_prop),Measure.map_map (by fun_prop) (by fun_prop)] at hnoise'
  have hlaw : (((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))).prod (stdGaussian (Point d))).map
      (fun z => H (z.1.1+(Real.sqrt 3*η/2) • z.1.2) z.2)=interpolationLaw F x r T := by
    convert hnoise' using 1
    · simp only [H,hreserve,comp_def]
    · simp only [comp_def,smul_add,smul_smul,hη,interpolationLaw,id_eq]
  have hp := hh.reindex (fullTape S.slots)
    (fun z => H (z.1.1+(Real.sqrt 3*η/2) • z.1.2) z.2)
    (fullTape_preserving S.slots).measurable (by fun_prop)
    (fun g : Fin (S.slots+1) → Point d => T • S.full.program.run F (x,g)) id hfull measurable_id
    (fun z => by rw [full_run]; simp only [fullTape,Fin.append_left,Fin.append_right,H])
    (fun _ => rfl)
  rw [(fullTape_preserving S.slots).map_eq,hlaw] at hp
  exact hp
end LogConcaveSampling.OracleCompiler.ReservedProgram

end

end

section

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

variable (C : CircuitParameters) {d : ℕ}

theorem meanFrom_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    {q Kf Ki Ks ef ei es ηmin r σ en : ℝ} (hd : 1 ≤ d)
    (hs : MeanSize lam q r σ) (hl : q ≤ 1/4) (hL : (lam:ℝ)*r ≤ 1)
    (hD : 1 ≤ C.D) (hψ : 0 ≤ C.ψ) (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf)
    (hKf : 0 ≤ Kf) (hKi : 0 ≤ Ki) (hef : 0 < ef) (hei : 0 ≤ ei)
    (hsmall : (lam:ℝ)*C.meanCenterBudget r σ*(2*Real.pi+2) ≤ 1)
    (hcon : 4*(C.meanCenterBudget r σ)^2*((lam:ℝ)*Ki)^2 ≤ 1)
    (hRT : Real.sqrt (1-C.T^2) ≤ C.T) (hη : ηmin ≤ Real.sqrt (1-C.T^2)/C.T)
    (hm : C.m=C.n) (hnc : C.nc=C.n) (hNc : C.Nc=C.N)
    (Mf Mi : ℝ → ℝ → SeedProgram d) (S : ℝ → ℝ → ReservedProgram d)
    (B : ℕ) (hBD : (B:ℝ) ≤ C.D^2)
    (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ))
    (hf : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) Kf ef Mf)
    (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi)
    (hS : SampleCorrect F lam (q/Real.sqrt (1-C.T^2)) Ks es ηmin S)
    (hrsv : (S r (Real.sqrt (1-C.T^2)/C.T)).reserve=(Real.sqrt (1-C.T^2)/C.T)/2)
    (x : Point d)
    (hcert : CalibratedMeanCircuit (r:=r) (T:=C.T) (h:=C.h) (ψ:=C.ψ) (s:=σ/2)
      hF x hs.1 (by linarith [hs.2.2.2.1] : (lam:ℝ)*r^2 ≤ 1/2)
      (by linarith [C.T_lower]) C.T_upper C.h_pos C.n C.N (en^2)) :
    let dep := (depth (C.meanTree (d:=d) r σ):ℝ)
    let a := 2*(1+2*dep)*(C.Af*Kf*q*ei+ef)
    SquaredAt (gaussianTape d (C.meanFrom Mf Mi S r σ).slots) (stdGaussian (Point d))
      (fun g => (C.meanFrom Mf Mi S r σ).program.run F (x,g))
      (fun g => primitiveExpectedField F x r+σ • g)
      (2*(C.Af*((lam:ℝ)*Kf)*dep*r)^2*(C.T^2*(es^2*(circuitD F x)^2))+
        80*(σ*a)^2*((20+16*circuitGrowthConstant^2)*(circuitD F x)^2)+
        8*((σ/2)*circuitD F x)^2*en^2) := by
  let dep := (depth (C.meanTree (d:=d) r σ):ℝ)
  let a := 2*(1+2*dep)*(C.Af*Kf*q*ei+ef)
  let P : Bool → ℝ → ℝ → Prop := fun s => if s then
    MeanSize lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) else
    MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2)))
  let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi
  let E := compileDeclaredRoot C.D (C.meanCenterBudget r σ) C.Af Mf Mi
    (C.meanTree (d:=d) r σ) (Real.sqrt 3*σ/2)
  have hA0 : 0 < C.A := hA ▸ C.actualA_pos
  have hAf0 : 0 < C.Af := hAf ▸ C.actualAf_pos
  have hbud : 0 ≤ C.meanCenterBudget r σ := by unfold meanCenterBudget; positivity [hs.1,hs.2.2.1]
  have hLip : (lam:ℝ)*Ki*C.meanCenterBudget r σ ≤ 1 := by
    have hn : 0 ≤ (lam:ℝ)*Ki*C.meanCenterBudget r σ := by positivity
    nlinarith [sq_nonneg ((lam:ℝ)*Ki*C.meanCenterBudget r σ)]
  have hrad : (lam:ℝ)*r^2 ≤ 1/4 := hs.2.2.2.1.trans hl
  have hT : 0 ≤ C.T := by linarith [C.T_lower]
  have ha : 0 < a := by dsimp [a,dep]; positivity [hs.nonneg lam.coe_nonneg]
  have hv := C.meanTree_valid (d:=d) lam.coe_nonneg hs (by linarith) hψ hA hAf
  have hrdy := hv.shiftReady (P true) (P false) (fun _ _ h => h.1.ne')
    (fun _ _ h => h.1.ne') _ _
  have hpos := C.meanCompiled_variation hs.1 hs.2.2.1 hψ hA hAf
    (mul_nonneg lam.coe_nonneg hKf) (mul_nonneg lam.coe_nonneg hKi) hLip F P M hf.lip hi.lip
    (Real.sqrt 3*σ/2) hrdy
  obtain ⟨Lf,hLf,hfl⟩ := C.meanCompiled_anchor_lipschitz hs.1 hs.2.2.1 hψ hA hAf
    (mul_nonneg lam.coe_nonneg hKf) (mul_nonneg lam.coe_nonneg hKi) hLip F P M hf.lip hi.lip
    (Real.sqrt 3*σ/2) hrdy x
  obtain ⟨Lg,hgl⟩ := C.meanTree_anchor_lipschitz (σ:=σ) hF hs.1 hrad x
  have hc (z : Point d × Point d) := C.meanCompiled_scaled hF hs (by linarith) hL hD hψ hA hAf hKf hKi hef.le hei
    hsmall hcon Mf Mi B hBD hbudget hf hi x z.1 z.2
  have hanc := C.mean_anchor_size lam.coe_nonneg hs hRT
  have he := hS.error _ _ hanc hη x
  have hanc' := ReservedProgram.anchor_squared hF x _ hs.1.le (by linarith : (lam:ℝ)*r^2 < 1) hT
    (show C.T*(Real.sqrt (1-C.T^2)/C.T)=Real.sqrt (1-C.T^2) by field_simp [ne_of_gt (by linarith [C.T_lower] : 0<C.T)]) hrsv he
  let := interpolationLaw_probability hF x hs.1.le (by linarith : (lam:ℝ)*r^2 < 1) C.T
  obtain ⟨w,hw,hlaw,hwi,hnum⟩ := C.meanTree_numerical_noisy hF x hs.1 hrad hm hnc hNc hcert
  have hmoment := pairGauge_interpolation_moment hF x hs.1.le hs.2.1
    (by linarith : (lam:ℝ)*r^2 ≤ 1/2) hT C.T_upper hd
  let v := compileDeclaredRootShift C.D (C.meanCenterBudget r σ) C.Af Mf Mi
    (C.meanTree (d:=d) r σ) (Real.sqrt 3*σ/2) (C.meanDrift r σ hs.1)
  let anc := S r (Real.sqrt (1-C.T^2)/C.T)
  have hp := meanParent_squared hF x anc.full E (anc.extraShift (-2*Real.sqrt (1-C.T^2)/C.T)) v C.T
    (interpolationLaw F x r C.T) (fun z => (C.meanTree r σ).eval F (x,z)) w
    (primitiveExpectedField F x r) σ (Real.sqrt 3*σ/2) hgl.continuous.measurable hw
    (pairGauge (circuitD F x)) (one_le_pairGauge (circuitD_nonneg F x))
    (pairGauge_change _) hmoment.1
    (show 0 ≤ C.Af*((lam:ℝ)*Kf)*dep*r by positivity [hs.1]) hLf Lg.coe_nonneg
    (mul_pos hs.2.2.1 ha) hanc' (hpos.2 x) hfl
    (fun z z' => by simpa only [dist_eq_norm] using hgl.dist_le_mul z z')
    hc hwi hnum hlaw
  unfold meanFrom
  rw [dite_eq_left hs.1]
  apply hp.mono
  have hh := mul_le_mul_of_nonneg_left hmoment.2 (show 0 ≤ 80*(σ*a)^2 by positivity)
  calc
    _ ≤ 2*(C.Af*((lam:ℝ)*Kf)*dep*r)^2*(C.T^2*(es^2*(circuitD F x)^2))+
      80*(σ*a)^2*((20+16*circuitGrowthConstant^2)*(circuitD F x)^2)+
      8*((σ/2*circuitD F x)^2*en^2) := add_le_add (add_le_add le_rfl hh) le_rfl
    _ = _ := by ring
end LogConcaveSampling.OracleCompiler.CircuitParameters

end

end

section

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

variable (C : CircuitParameters) {d : ℕ}

theorem sampleFrom_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    {q Kf Ki ef ei r η en : ℝ} (hd : 1 ≤ d)
    (hs : SampleSize lam q r η) (hl : q ≤ 1/4) (hL : (lam:ℝ)*r ≤ 1)
    (hRη : Real.sqrt (1-C.T^2) ≤ η) (hD : 1 ≤ C.D)
    (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf)
    (hKf : 0 ≤ Kf) (hKi : 0 ≤ Ki) (hef : 0 < ef) (hei : 0 ≤ ei)
    (hsmall : (lam:ℝ)*C.sampleCenterBudget r*(2*Real.pi+2) ≤ 1)
    (hcon : 4*(C.sampleCenterBudget r)^2*((lam:ℝ)*Ki)^2 ≤ 1)
    (Mf Mi : ℝ → ℝ → SeedProgram d) (B : ℕ) (hBD : (B:ℝ) ≤ C.D^2)
    (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ))
    (hf : MeanCorrect F lam ((1+4*C.Af)*q) Kf ef Mf)
    (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi)
    (x : Point d)
    (hlr : (lam:ℝ)*r^2 ≤ 1/2)
    (hnumi : Integrable (fun Y => ‖sampleMeanCircuit F x r (sampleCorrelation η) C.h
      (C.n+1) C.N (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1) Y-
      (sampleCorrelation η)⁻¹ • fullProbabilityFlow hF x hs.1.le hlr (sampleCorrelation η) Y‖^2)
      (stdGaussian (Point d)))
    (hnum : (∫Y,‖sampleMeanCircuit F x r (sampleCorrelation η) C.h
      (C.n+1) C.N (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1) Y-
      (sampleCorrelation η)⁻¹ • fullProbabilityFlow hF x hs.1.le hlr (sampleCorrelation η) Y‖^2
      ∂stdGaussian (Point d)) ≤ (circuitD F x)^2*en^2) :
    let dep := (depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ)
    let a := 2*(1+dep)*(C.Af*Kf*q*ei+ef)
    SquaredAt (gaussianTape d (C.sampleFrom Mf Mi r η).slots)
      ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d)))
      (fun g => (C.sampleFrom Mf Mi r η).pre.run F (x,g))
      (fun z => z.1+(Real.sqrt 3*η/2) • z.2)
      ((400*(η*a)^2+4*en^2)*(circuitD F x)^2) := by
  let dep := (depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ)
  let a := 2*(1+dep)*(C.Af*Kf*q*ei+ef)
  let P : Bool → ℝ → ℝ → Prop := fun s => if s then
    MeanSize lam ((1+4*C.Af)*q) else MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2)))
  let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi
  let E := compileDeclaredRoot C.D (C.sampleCenterBudget r) (C.sampleFinalBudget r) Mf Mi
    (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) (η/Real.sqrt 2)
  have hA0 : 0 < C.A := hA ▸ C.actualA_pos
  have hAf0 : 0 < C.Af := hAf ▸ C.actualAf_pos
  have hbud : 0 ≤ C.sampleCenterBudget r := by unfold sampleCenterBudget; positivity
  have hLip : (lam:ℝ)*Ki*C.sampleCenterBudget r ≤ 1 := by
    have hn : 0 ≤ (lam:ℝ)*Ki*C.sampleCenterBudget r := by positivity
    nlinarith [sq_nonneg ((lam:ℝ)*Ki*C.sampleCenterBudget r)]
  have hrad : (lam:ℝ)*r^2 ≤ 1/4 := hs.2.2.2.2.trans
    ((mul_le_of_le_one_right (hs.nonneg lam.coe_nonneg) hs.2.2.2.1).trans hl)
  have ha : 0 < a := by dsimp [a,dep]; positivity [hs.nonneg lam.coe_nonneg]
  have hv := C.sampleTree_valid (d:=d) lam.coe_nonneg hs C.residual_pos hRη (by linarith) hA hAf
  have hrdy := hv.shiftReady (P true) (P false) (fun _ _ h => h.1.ne') (fun _ _ h => h.1.ne') _ _
  obtain ⟨Lf,hLf,hfl⟩ := C.sampleCompiled_anchor_lipschitz hs.1 hs.2.2.1 hs.2.2.2.1 hA hAf
    (mul_nonneg lam.coe_nonneg hKf) (mul_nonneg lam.coe_nonneg hKi) hLip F P M hf.lip hi.lip
    (η/Real.sqrt 2) hrdy x
  obtain ⟨Lg,hgl⟩ := C.sampleTree_anchor_lipschitz hF hs.1 hs.2.2.1 hs.2.2.2.1 hrad x
  have heval : (fun Y => (C.sampleTree r η hs.2.2.1 hs.2.2.2.1).eval F (x,Y))=
      sampleMeanCircuit F x r (sampleCorrelation η) C.h (C.n+1) C.N
        (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1) := by
    funext Y; exact C.sampleTree_eval hF r η hs.2.2.1 hs.2.2.2.1 x Y
  rw [heval] at hgl
  have hc Y := C.sampleCompiled_scaled hF hs (by linarith) hL hRη hD hA hAf hKf hKi hef.le hei
    hsmall hcon Mf Mi B hBD hbudget hf hi x Y
  simp only [C.sampleTree_eval hF] at hc
  let v := compileDeclaredRootShift C.D (C.sampleCenterBudget r) (C.sampleFinalBudget r) Mf Mi
    (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) (η/Real.sqrt 2)
    (C.sampleDrift r η hs.1 hs.2.2.1 hs.2.2.2.1)
  have hpr := sampleCorrelation_properties hs.2.2.1 hs.2.2.2.1
  have hp := sampleParent_squared hF x hs.1.le hlr (by linarith [hpr.1]) hpr.2.1 hpr.2.2
    (C.n+1) C.N (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1)
    (probabilityEndpoint_time _ _ C.h_pos _ (by omega)) E v hLf Lg.coe_nonneg (mul_pos hs.2.2.1 ha)
    hgl.continuous.measurable hfl
    (fun z z' => by simpa only [dist_eq_norm] using hgl.dist_le_mul z z') hc hnumi hnum
  unfold sampleFrom
  rw [dite_eq_left ⟨hs.1,hs.2.2.1,hs.2.2.2.1⟩]
  apply hp.mono
  have hh := mul_le_mul_of_nonneg_left (anchorGauge_circuitD_moment hd F x)
    (show 0 ≤ 40*(η*a)^2 by positivity)
  calc
    _ ≤ 40*(η*a)^2*(10*(circuitD F x)^2)+4*((circuitD F x)^2*en^2) := add_le_add hh le_rfl
    _ = _ := by ring
end LogConcaveSampling.OracleCompiler.CircuitParameters

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler.CircuitParameters
open MeanTree

variable (C : CircuitParameters) {d : ℕ}

def depthBound : ℕ := 4*(C.N+1)^2

lemma meanTree_depth (hN : C.Nc≤C.N) (r σ : ℝ) :
    depth (C.meanTree (d:=d) r σ)≤C.depthBound := by
  exact meanCircuit_fixed_depth r C.T C.h C.ψ (σ/2) C.n C.m C.N C.nc C.Nc hN C.meanEndpoint _ _ _ _ _ _

lemma sampleTree_depth (r η : ℝ) (hη : 0<η) (hη1 : η≤1) :
    depth (C.sampleTree (d:=d) r η hη hη1)≤C.depthBound := by
  have hh := depth_forward r (sampleCorrelation η) C.h (C.n+1) C.N
    (anchor (Prod.fst : SampleInput d → Point d) (by fun_prop))
    (anchor Prod.snd (by fun_prop)) (C.sampleEndpoint η hη hη1) (b:=0) (by simp) (by simp)
  dsimp only [sampleTree,literalSample] at ⊢
  rw [depth_scale]
  unfold depthBound
  nlinarith

lemma depthBound_pos : 0<C.depthBound := by unfold depthBound; positivity
end LogConcaveSampling.OracleCompiler.CircuitParameters

end

end

section

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

variable {d : ℕ}

lemma ReservedProgram.full_fixedSeed_lip (S : ReservedProgram d) (F : Point d → ℝ) (K : ℝ)
    (h : ∀x y g, ‖S.pre.run F (x,g)-S.pre.run F (y,g)‖≤K*‖x-y‖) :
    ∀x y g, ‖S.full.program.run F (x,g)-S.full.program.run F (y,g)‖≤K*‖x-y‖ := by
  intro x y g
  rw [full_run S F x g,full_run S F y g,add_sub_add_right_eq_sub]
  exact h x y _

namespace CircuitParameters
variable (C : CircuitParameters)

lemma sampleFrom_lipschitz {F : Point d → ℝ} {lam : ℝ≥0} {q Kf Ki ef ei r η : ℝ}
    (hs : SampleSize lam q r η) (hRη : Real.sqrt (1-C.T^2)≤η) (hD : 0<C.D)
    (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf)
    (hKf : 0≤Kf) (hKi : 0≤Ki)
    (hsmall : (lam:ℝ)*Ki*C.sampleCenterBudget r≤1)
    (Mf Mi : ℝ → ℝ → SeedProgram d)
    (hf : MeanCorrect F lam ((1+4*C.Af)*q) Kf ef Mf)
    (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi) :
    ∀x y g, ‖(C.sampleFrom Mf Mi r η).pre.run F (x,g)-
      (C.sampleFrom Mf Mi r η).pre.run F (y,g)‖≤
      (lam:ℝ)*r*(C.Af*(depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ)*Kf)*‖x-y‖ := by
  let P : Bool → ℝ → ℝ → Prop := fun s => if s then
    MeanSize lam ((1+4*C.Af)*q) else MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2)))
  let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi
  have hv := C.sampleTree_valid (d:=d) lam.coe_nonneg hs C.residual_pos hRη hD hA hAf
  have hrdy := hv.shiftReady (P true) (P false) (fun _ _ h => h.1.ne')
    (fun _ _ h => h.1.ne') _ _
  have hE := C.sampleCompiled_variation hs.1 hs.2.2.1 hs.2.2.2.1 hA hAf
    (mul_nonneg lam.coe_nonneg hKf) (mul_nonneg lam.coe_nonneg hKi) hsmall F P M hf.lip hi.lip
    (η/Real.sqrt 2) hrdy
  unfold sampleFrom
  rw [dite_eq_left ⟨hs.1,hs.2.2.1,hs.2.2.2.1⟩]
  dsimp only
  intro x y g
  have he := sampleParent_lipschitz F _ _ _ _ _ hE x y g
  convert! he using 1
  unfold sampleFinalBudget
  ring

lemma meanFrom_lipschitz {F : Point d → ℝ} {lam : ℝ≥0}
    {q Kf Ki Ks ef ei es ηmin r σ : ℝ}
    (hs : MeanSize lam q r σ) (hD : 0<C.D) (hψ : 0≤C.ψ)
    (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf)
    (hKf : 0≤Kf) (hKi : 0≤Ki) (hKs : 0≤Ks)
    (hsmall : (lam:ℝ)*Ki*C.meanCenterBudget r σ≤1)
    (hRT : Real.sqrt (1-C.T^2)≤C.T)
    (hη : ηmin≤Real.sqrt (1-C.T^2)/C.T)
    (Mf Mi : ℝ → ℝ → SeedProgram d) (S : ℝ → ℝ → ReservedProgram d)
    (hf : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) Kf ef Mf)
    (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi)
    (hS : SampleCorrect F lam (q/Real.sqrt (1-C.T^2)) Ks es ηmin S) :
    ∀x y g, ‖(C.meanFrom Mf Mi S r σ).program.run F (x,g)-
      (C.meanFrom Mf Mi S r σ).program.run F (y,g)‖≤
      (lam:ℝ)*(C.Af*(depth (C.meanTree (d:=d) r σ):ℝ)*Kf*(1+q*Ks))*‖x-y‖ := by
  let P : Bool → ℝ → ℝ → Prop := fun s => if s then
    MeanSize lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) else
    MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2)))
  let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi
  have hv := C.meanTree_valid (d:=d) lam.coe_nonneg hs hD hψ hA hAf
  have hrdy := hv.shiftReady (P true) (P false) (fun _ _ h => h.1.ne')
    (fun _ _ h => h.1.ne') _ _
  have hE := C.meanCompiled_variation hs.1 hs.2.2.1 hψ hA hAf
    (mul_nonneg lam.coe_nonneg hKf) (mul_nonneg lam.coe_nonneg hKi) hsmall F P M hf.lip hi.lip
    (Real.sqrt 3*σ/2) hrdy
  have ha := C.mean_anchor_size lam.coe_nonneg hs hRT
  have hSl := ReservedProgram.full_fixedSeed_lip _ F ((lam:ℝ)*r*Ks) (hS.lip _ _ ha hη)
  have hAf0 : 0<C.Af := hAf ▸ C.actualAf_pos
  have hT : 0≤C.T := by linarith [C.T_lower]
  have hK : 0≤C.Af*((lam:ℝ)*Kf)*(depth (C.meanTree (d:=d) r σ):ℝ) := by positivity
  unfold meanFrom
  rw [dite_eq_left hs.1]
  dsimp only
  intro x y g
  have he := meanParent_lipschitz F _ _ _ _ _ _ _ _ (mul_nonneg hK hs.1.le) hT hSl hE.1 hE.2 x y g
  apply he.trans
  have hq := mul_le_mul_of_nonneg_right hs.2.2.2.1 hKs
  have hTq : C.T*((lam:ℝ)*r^2*Ks)≤q*Ks :=
    (mul_le_of_le_one_left (show 0≤(lam:ℝ)*r^2*Ks by positivity) C.T_upper.le).trans hq
  have hh := mul_le_mul_of_nonneg_left hTq hK
  have heq : C.Af*((lam:ℝ)*Kf)*(depth (C.meanTree (d:=d) r σ):ℝ)+
      C.Af*((lam:ℝ)*Kf)*(depth (C.meanTree (d:=d) r σ):ℝ)*r*C.T*((lam:ℝ)*r*Ks)≤
      (lam:ℝ)*(C.Af*(depth (C.meanTree (d:=d) r σ):ℝ)*Kf*(1+q*Ks)) := by nlinarith
  exact mul_le_mul_of_nonneg_right heq (norm_nonneg _)

end CircuitParameters
end LogConcaveSampling.OracleCompiler

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler
open MeanTree Coupling
open scoped Classical NNReal

lemma mean_error_envelope {u k σ T es a en D M : ℝ}
    (hu : 0≤u) (hk : 0≤k) (_hσ : 0≤σ) (hT : 0≤T) (hT1 : T≤1)
    (hes : 0≤es) (ha : 0≤a) (hen : 0≤en) (hM : 1≤M) (hub : u≤σ*k) :
    2*u^2*(T^2*(es^2*D^2))+80*(σ*a)^2*(M*D^2)+8*(σ/2*D)^2*en^2≤
      σ^2*(2*k*es+10*M*a+2*en)^2*D^2 := by
  have hut : u*T≤σ*k := (mul_le_of_le_one_right hu hT1).trans hub
  have hv := pow_le_pow_left₀ (mul_nonneg hu hT) hut 2
  have hv' := mul_le_mul_of_nonneg_right hv (show 0≤2*es^2 by positivity)
  have hm : 80*M≤100*M^2 := by nlinarith
  have hm' := mul_le_mul_of_nonneg_right hm (sq_nonneg (σ*a))
  have h₁ : 0≤(2*k*es)*(10*M*a) := by positivity
  have h₂ : 0≤(2*k*es)*(2*en) := by positivity
  have h₃ : 0≤(10*M*a)*(2*en) := by positivity
  have hsum : 2*u^2*T^2*es^2+80*(σ*a)^2*M+2*σ^2*en^2≤
      σ^2*(2*k*es+10*M*a+2*en)^2 := by
    have hx := mul_nonneg (sq_nonneg σ) h₁
    have hy := mul_nonneg (sq_nonneg σ) h₂
    have hz := mul_nonneg (sq_nonneg σ) h₃
    nlinarith [sq_nonneg (σ*k*es),sq_nonneg (σ*en)]
  have hres := mul_le_mul_of_nonneg_right hsum (sq_nonneg D)
  nlinarith only [hres]

lemma sample_error_envelope {η a en D : ℝ} (hη : 0≤η) (hη1 : η≤1)
    (ha : 0≤a) (hen : 0≤en) :
    (400*(η*a)^2+4*en^2)*D^2≤(20*a+2*en)^2*D^2 := by
  have hη2 : η^2≤1 := by nlinarith
  have hh := mul_le_mul_of_nonneg_right hη2 (sq_nonneg a)
  apply mul_le_mul_of_nonneg_right _ (sq_nonneg D)
  nlinarith [mul_nonneg ha hen]

namespace CircuitParameters
variable (C : CircuitParameters) {d : ℕ}

def compilerError (H Kf q ei ef : ℝ) : ℝ :=
  2*(1+2*H)*(C.Af*Kf*q*ei+ef)

def meanError (H Kf q es ei ef en : ℝ) : ℝ :=
  2*(C.Af*Kf*H*q)*es+10*(20+16*circuitGrowthConstant^2)*C.compilerError H Kf q ei ef+2*en

def sampleError (H Kf q ei ef en : ℝ) : ℝ :=
  20*C.compilerError H Kf q ei ef+2*en

lemma physical_mean_factor {lam q Kf r σ H : ℝ}
    (hs : MeanSize lam q r σ) (hlam : 0≤lam) (hAf : 0≤C.Af) (hK : 0≤Kf)
    (hH : (depth (C.meanTree (d:=d) r σ):ℝ)≤H) :
    C.Af*(lam*Kf)*(depth (C.meanTree (d:=d) r σ):ℝ)*r≤σ*(C.Af*Kf*H*q) := by
  have hq := hs.nonneg hlam
  have h₁ := mul_le_mul_of_nonneg_left hs.2.2.2.2
    (show 0≤C.Af*Kf*(depth (C.meanTree (d:=d) r σ):ℝ) by positivity)
  have h₂ := mul_le_mul_of_nonneg_left hH (show 0≤σ*C.Af*Kf*q by positivity [hs.2.2.1])
  nlinarith

end CircuitParameters
end LogConcaveSampling.OracleCompiler

end

end

section

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

variable {d : ℕ}

namespace CircuitParameters
variable (C : CircuitParameters)

lemma meanCenter_scaled {lam q r σ : ℝ} (hs : MeanSize lam q r σ)
    (_hlam : 0≤lam) (hA : 0≤C.A) : lam*C.meanCenterBudget r σ≤2*C.A*q := by
  have hh : lam*r/σ≤q := (div_le_iff₀ hs.2.2.1).mpr hs.2.2.2.2
  have he : lam*(r/σ+r^2)≤2*q := by rw [mul_add,←mul_div_assoc]; linarith [hs.2.2.2.1]
  have hh := mul_le_mul_of_nonneg_left he hA
  unfold meanCenterBudget
  nlinarith only [hh]

lemma sampleCenter_scaled {lam q r η : ℝ} (hs : SampleSize lam q r η)
    (hlam : 0≤lam) (hA : 0≤C.A) : lam*C.sampleCenterBudget r≤2*C.A*q := by
  have hq := hs.nonneg hlam
  have he := hs.2.2.2.2.trans (mul_le_of_le_one_right hq hs.2.2.2.1)
  unfold sampleCenterBudget
  nlinarith [mul_le_mul_of_nonneg_left he hA,mul_nonneg hA hq]

lemma physical_small_of_scaled {lam B A q K : ℝ} (_hA : 0≤A) (_hq : 0≤q) (hK : 0≤K)
    (hB : 0≤lam*B) (hscale : lam*B≤2*A*q)
    (hp : 2*A*q*(2*Real.pi+2)≤1) (hcon : 4*A*q*K≤1) :
    lam*B*(2*Real.pi+2)≤1 ∧ 4*B^2*(lam*K)^2≤1 ∧ lam*K*B≤1 := by
  have hs := mul_le_mul_of_nonneg_right hscale (show 0≤2*Real.pi+2 by positivity [Real.pi_pos])
  have hk := mul_le_mul_of_nonneg_right hscale hK
  have hg : 0≤lam*B*K := mul_nonneg hB hK
  have hu : lam*B*K≤1/2 := by linarith
  refine ⟨hs.trans hp,?_,by nlinarith⟩
  have hh := pow_le_pow_left₀ hg hu 2
  nlinarith only [hh]

def MeanNumericalReady {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    (q en : ℝ) (hq : q≤1/4) : Prop :=
  ∀x r σ,∀hs : MeanSize lam q r σ,
    CalibratedMeanCircuit (r:=r) (T:=C.T) (h:=C.h) (ψ:=C.ψ) (s:=σ/2)
      hF x hs.1 (by linarith [hs.2.2.2.1] : (lam:ℝ)*r^2≤1/2)
      (by linarith [C.T_lower]) C.T_upper C.h_pos C.n C.N (en^2)

def SampleNumericalReady {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    (q en : ℝ) : Prop :=
  ∀x r η,∀hs : SampleSize lam q r η,∀hl : (lam:ℝ)*r^2≤1/2,
    Integrable (fun Y => ‖sampleMeanCircuit F x r (sampleCorrelation η) C.h
      (C.n+1) C.N (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1) Y-
      (sampleCorrelation η)⁻¹ • fullProbabilityFlow hF x hs.1.le hl (sampleCorrelation η) Y‖^2)
      (stdGaussian (Point d)) ∧
    (∫Y,‖sampleMeanCircuit F x r (sampleCorrelation η) C.h
      (C.n+1) C.N (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1) Y-
      (sampleCorrelation η)⁻¹ • fullProbabilityFlow hF x hs.1.le hl (sampleCorrelation η) Y‖^2
      ∂stdGaussian (Point d))≤(circuitD F x)^2*en^2

lemma compilerError_mono {H H' Kf q ei ef : ℝ} (hHH : H≤H')
    (hAf : 0≤C.Af) (hK : 0≤Kf) (hq : 0≤q) (hei : 0≤ei) (hef : 0≤ef) :
    C.compilerError H Kf q ei ef≤C.compilerError H' Kf q ei ef := by
  unfold compilerError
  nlinarith [mul_nonneg (sub_nonneg.mpr hHH) (show 0≤C.Af*Kf*q*ei+ef by positivity)]

end CircuitParameters
end LogConcaveSampling.OracleCompiler

end

end

section

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

variable (C : CircuitParameters) {d : ℕ}

theorem meanFrom_correct {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    {q Kf Ki Ks ef ei es en ηmin : ℝ} (hd : 1≤d) (hlam : (lam:ℝ)≤1)
    (hq : 0≤q) (hql : q≤1/4) (hRT : Real.sqrt (1-C.T^2)≤C.T)
    (hη : ηmin≤Real.sqrt (1-C.T^2)/C.T)
    (hD : 1≤C.D) (hψ : 0≤C.ψ) (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf)
    (hKf : 0≤Kf) (hKi : 0≤Ki) (hKs : 0≤Ks)
    (hef : 0<ef) (hei : 0≤ei) (hes : 0≤es) (hen : 0≤en)
    (hsmall : 2*C.A*q*(2*Real.pi+2)≤1) (hcon : 4*C.A*q*Ki≤1) (hqs : q*Ks≤1)
    (hm : C.m=C.n) (hnc : C.nc=C.n) (hNc : C.Nc=C.N)
    (Mf Mi : ℝ → ℝ → SeedProgram d) (S : ℝ → ℝ → ReservedProgram d)
    (B : ℕ) (hBD : (B:ℝ)≤C.D^2)
    (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ))
    (hf : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) Kf ef Mf)
    (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi)
    (hS : SampleCorrect F lam (q/Real.sqrt (1-C.T^2)) Ks es ηmin S)
    (hrsv : ∀r,(S r (Real.sqrt (1-C.T^2)/C.T)).reserve=(Real.sqrt (1-C.T^2)/C.T)/2)
    (hnum : C.MeanNumericalReady hF q en hql) :
    MeanCorrect F lam q (2*C.Af*C.depthBound*Kf)
      (C.meanError C.depthBound Kf q es ei ef en) (C.meanFrom Mf Mi S) := by
  have hA0 : 0<C.A := hA ▸ C.actualA_pos
  have hAf0 : 0<C.Af := hAf ▸ C.actualAf_pos
  have hH : 0≤(C.depthBound:ℝ) := Nat.cast_nonneg _
  have small {r σ : ℝ} (hs : MeanSize lam q r σ) :=
    physical_small_of_scaled hA0.le hq hKi
      (show 0≤(lam:ℝ)*C.meanCenterBudget r σ by unfold meanCenterBudget; positivity [hs.1,hs.2.2.1])
      (C.meanCenter_scaled hs lam.coe_nonneg hA0.le) hsmall hcon
  constructor
  · intro r σ hs x y g
    have he := C.meanFrom_lipschitz hs (by linarith) hψ hA hAf hKf hKi hKs
      (small hs).2.2 hRT hη Mf Mi S hf hi hS x y g
    have hdep : (depth (C.meanTree (d:=d) r σ):ℝ)≤C.depthBound :=
      by exact_mod_cast C.meanTree_depth (d:=d) hNc.le r σ
    have hdep0 : 0≤(depth (C.meanTree (d:=d) r σ):ℝ) := Nat.cast_nonneg _
    have hh : (depth (C.meanTree (d:=d) r σ):ℝ)*(1+q*Ks)≤2*C.depthBound := by
      have ht := mul_le_mul_of_nonneg_left hqs hdep0
      nlinarith
    have hk := mul_le_mul_of_nonneg_right hh
      (show 0≤(lam:ℝ)*C.Af*Kf*‖x-y‖ by positivity)
    apply he.trans
    nlinarith only [hk]
  · intro r σ hs x
    have hL : (lam:ℝ)*r≤1 := (mul_le_of_le_one_left hs.1.le hlam).trans hs.2.1
    have hp := C.meanFrom_squared hF hd hs hql hL hD hψ hA hAf hKf hKi hef hei
      (small hs).1 (small hs).2.1 hRT hη hm hnc hNc Mf Mi S B hBD hbudget hf hi hS
      (hrsv r) x (hnum x r σ hs)
    apply hp.mono
    let dep := (depth (C.meanTree (d:=d) r σ):ℝ)
    let a := C.compilerError dep Kf q ei ef
    let k := C.Af*Kf*C.depthBound*q
    have hdep : dep≤C.depthBound := by dsimp only [dep]; exact_mod_cast C.meanTree_depth (d:=d) hNc.le r σ
    have hdep0 : 0≤dep := by dsimp [dep]; positivity
    have ha : 0≤a := by dsimp [a,compilerError]; positivity
    have ha' : a≤C.compilerError C.depthBound Kf q ei ef := C.compilerError_mono hdep hAf0.le hKf hq hei hef.le
    have hu := C.physical_mean_factor hs lam.coe_nonneg hAf0.le hKf hdep
    have he := mean_error_envelope (D:=circuitD F x)
      (show 0≤C.Af*((lam:ℝ)*Kf)*dep*r by positivity [hs.1])
      (show 0≤k by dsimp [k]; positivity) hs.2.2.1.le
      (by linarith [C.T_lower] : 0≤C.T) C.T_upper.le hes ha hen
      (show 1≤20+16*circuitGrowthConstant^2 by nlinarith [sq_nonneg circuitGrowthConstant]) hu
    apply he.trans
    have hem : 2*k*es+10*(20+16*circuitGrowthConstant^2)*a+2*en≤
        C.meanError C.depthBound Kf q es ei ef en := by
      unfold meanError
      have hh := mul_le_mul_of_nonneg_left ha' (show 0≤10*(20+16*circuitGrowthConstant^2) by positivity)
      exact add_le_add (add_le_add le_rfl hh) le_rfl
    have he0 : 0≤2*k*es+10*(20+16*circuitGrowthConstant^2)*a+2*en := by dsimp [k]; positivity
    exact mul_le_mul_of_nonneg_right
      (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ he0 hem 2) (sq_nonneg σ)) (sq_nonneg _)
end LogConcaveSampling.OracleCompiler.CircuitParameters

end

end

end OAI