lean/OAI/Computability/Logspace/ProbabilityDecision.lean

import OAI.Computability.Logspace.ConfigurationGraph
import OAI.Computability.Logspace.HierarchicalEstimator

namespace OAI

/-!
Conditioning at the initial configuration and deterministic separation of acceptance probabilities.

From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*.
-/

set_option autoImplicit true

section

namespace ExactDerandomization.Stage
noncomputable section
open Hie Est At Analysis Buf Net Finset

/-- constants chosen once for the analytic part of the algorithm. -/
structure Wares where
    p : Const
    A0 : ℕ
    ell : ℕ

namespace Wares

def density (w:Wares) (B : ℕ) := (1+w.p.M)*B
def levels (w:Wares) (B:ℕ):=2^w.density B
def tolls (w:Wares) (B : ℕ):=4*B+w.A0*(1+coreR w.p B)
def top (w:Wares) (B : ℕ):=8*(w.tolls B+w.density B+2*B)
def ceiling (w:Wares) (B : ℕ):= w.top B+B + w.density B+1
structure Proof (w:Wares) where
   T : Tonic w.p
   v : Purse T
   credit : v.askFor w.A0
   wind : Wind 18 w.ell

lemma choose : ∃ w:Wares,Nonempty w.Proof := by
   obtain ⟨p⟩:= Hie.exists_const
   obtain ⟨t⟩:= tonic_up p
   obtain ⟨v⟩:= finance t
   obtain ⟨a,h⟩:= v.credit
   obtain ⟨l,hl⟩:= find_lam 18
   exact ⟨⟨p,a,l⟩,⟨⟨t,v,h,hl⟩⟩⟩

end Wares

namespace Raw
variable {q w h : ℕ} (P : Base.Source q w h) (x : Word) (u : Wares)
def H : Hie.Prize := ⟨⟨u.p,0,P.dom x,fun i j=>↑(P.S x i j)⟩,
                      fun i=>↑(P.reward x i),fun i=>↑(P.pr x i)⟩

lemma honestly : (H P x u).Correct := by
   let Q:=H P x u
   change Q.Correct; refine ⟨?_,fun i=>?_,fun i=>?_,?_⟩
   · constructor
     · intro i j; change 0≤(P.S x i j:ℝ); exact_mod_cast (P.S_nonneg x i j)
     · intro i j; change (P.S x i j:ℝ) ≤1*rate 0; rw [rate0,one_mul]; exact_mod_cast P.S_le x i j
     · intro i; change ∑ j∈P.dom x,(P.S x i j:ℝ)≤ 1
       exact_mod_cast P.S_sub x i
     intro i j hi
     change 0< (P.S x i j:ℝ) at hi
     have he:=(P.S_pos (x:=x) (n:=i) (j:=j)).1 (by exact_mod_cast hi)
     have ht b (e : P.next x i b=some j): i∈P.dom x ∧ j∈P.dom x∧i<j :=
       ⟨P.mem (P.steps_to e).1,P.mem (P.steps_to e).2.2.1,P.forward e⟩
     rcases he with h|h <;> exact ht _ h
   · change 0≤(P.reward x i:ℝ); unfold Base.Source.reward; split <;> norm_num
   · have hp:=P.bounded x (P.clock x) i
     change (0:ℝ)≤ (P.pr x i:ℝ) ∧ (P.pr x i:ℝ)≤1
     unfold Base.Source.pr; exact_mod_cast hp
   ext i
   have ht:=P.pr_eq x i
   rw [P.avg_S] at ht
   change (P.pr x i:ℝ)= (P.reward x i:ℝ)+∑ j∈P.dom x,(P.S x i j:ℝ)*(P.pr x j:ℝ)
   exact_mod_cast ht

lemma fits (e : P.Space) : P.first x∈ (H P x u).P.S := P.mem_first e x
lemma answer (e : P.Space) :
    (H P x u).v (P.first x) = (P.mach.acceptanceProbability x (P.clock x):ℝ) :=
    congrArg (fun t:ℚ=>(t:ℝ)) (P.fair e x)

end Raw

variable {q w h n : ℕ} [Fact n.Prime]
structure Matter (q w h n :ℕ) [Fact n.Prime] where
    P : Base.Source q w h
    w0 : Wares
    x : Word
    B : ℕ

namespace Matter
variable (m : Matter q w h n)
def s : Scene n :=
   ⟨Raw.H m.P m.x m.w0,m.w0.levels m.B, m.B,m.w0.ceiling m.B, m.w0.A0,m.w0.ell⟩
def x0 := m.P.first m.x
def i := m.s.H.child m.x0 m.B
def view := prizep m.B m.B
def top := m.w0.top m.B
def d := m.view.plan m.s

def ready (e:m.w0.Proof) :=
   6 ≤ m.B ∧ m.P.size m.x≤ 2^m.B∧ e.T.bank ≤ Est.box m.B ∧
               m.w0.p.M<n ∧ 2^m.s.roof≤n
lemma cseq {p:m.w0.Proof} (he:m.ready p) {k : ℕ} (h:k≤ m.B) :
      (m.s.stage k).S ⊆ range (m.w0.levels m.B) := by
   have hk (j : ℕ) : (m.s.stage j).S ⊆ range (2^m.B*m.w0.p.M^j) := by
      induction j with
      | zero=>
        change range (m.P.size m.x) ⊆ range _
        simpa using range_mono he.2.1
      | succ j ih=>
        intro x hx
        rw [m.s.mature,Stg.next] at hx
        obtain ⟨y,hv,i,hu,rfl⟩:=repr_copy hx
        have hl:=mem_range.1 (ih hv)
        let M:=m.w0.p.M
        have hM:(m.s.stage j).p.M=M:=by rw [m.s.aligned]; rfl
        apply mem_range.2
        rw [hM]; rw [hM] at hu
        unfold radix; rw [pow_succ]
        change i+M*y<2^m.B*(M^j*M)
        nlinarith
   apply (hk k).trans (range_mono ?_)
   let M:=m.w0.p.M
   have he:M≤2^M:= le_trans (by omega) (exp_big M)
   change 2^m.B*M^k ≤ 2^((1+M)*m.B)
   rw [add_mul,pow_add,pow_mul,pow_mul]
   gcongr <;> first | omega | positivity | exact Nat.one_le_pow M 2 (by omega)
lemma lineup {p:m.w0.Proof} (he:m.ready p) : m.s.SetUp := by
   refine ⟨Raw.honestly ..,rfl,he.2.2.2.1,he.2.2.2.2,
        fun i hi=> le_trans (card_le_card (m.cseq he hi)) (by simp [s]),fun i hi=>?_,p.wind⟩
   apply (m.cseq he hi).trans (range_mono ?_)
   apply le_trans _ he.2.2.2.2
   change 2^m.w0.density m.B ≤ 2^(m.w0.top m.B+m.B+m.w0.density m.B+1)
   exact Nat.pow_le_pow_right (by omega) (by omega)

lemma identity {p:m.w0.Proof} (he:m.ready p) :
    |m.s.H.v m.x0-m.view.pursue m.s m.i| ≤ 1/32 := by
   let C:=m.s.H
   let c:=m.B
   have hh : C.P.i=0:= rfl
   have hs := m.lineup he
   have hk:C.Correct:=hs.correct
   have hp : 2^(C.P.i+c) ≤ n := by
       rw [hh,zero_add]
       apply m.s.fits hs
       change c≤ m.w0.ceiling m.B; unfold c Wares.ceiling; omega
   have hx:= C.finish n hk c hp m.x0
   change |C.v _-(C.iterate n c).W (C.child m.x0 c)| ≤ _
   rw [abs_of_nonneg hx.1]; apply hx.2.trans; rw [hh,zero_add]
   have hZ : C.P.S.card ≤ 2^m.B := by
       change (range _).card≤_
       rw [card_range]; exact he.2.1
   apply le_trans (b:=(Est.box c)^2*rate c)
   · apply mul_le_mul_of_nonneg_right _ (rate_pos _).le
     push_cast
     have hR : (C.P.S.card:ℝ)≤2^c:=by exact_mod_cast hZ
     unfold Est.box
     nlinarith [show 0≤(2:ℝ)^c by positivity]
   rw [rr,show (Est.box c)^2*dry c^4=dry c^2 from ?_]
   · have he1 : 0≤dry c:= (dry0 _).le
     have ht:= dry_mono (show 6≤c from he.1)
     norm_num [dry,Est.box] at ht
     unfold dry Est.box at *
     nlinarith
   have he:= unify c
   linear_combination (norm := ring_nf) ((Est.box c*dry c)+1) * dry c^2 * he

lemma rank_allow :
    allowance m.s.gap m.top (m.view.key m.s) =
       dry (m.w0.density m.B) * dry m.B ^2 := by
   let w:=m.w0; let B:=m.B
   change dry (8*(w.tolls B+w.density B+2*B)/8) *
           Est.box (2*B+2*B+w.A0*(1+coreR w.p B+ 0))= _
   have ht : 2*B+2*B+w.A0*(1+coreR w.p B+0)=w.tolls B:=by unfold Wares.tolls; ring
   rw [ht,Nat.mul_div_cancel_left _ (by omega),dryP,dryP,Nat.mul_comm 2,dryM]
   change (dry (w.tolls B)*_ * _)*Est.box (w.tolls B)=dry _*_
   rw [show ∀ x y z v:ℝ,(x*y*z)*v=x*v*y*z by intros; ring,reunite,one_mul]

end Matter
end
end ExactDerandomization.Stage

end

section

set_option synthInstance.maxSize 4096
namespace ExactDerandomization.Stage
noncomputable section
open Hie Est At Analysis Buf Net Finset

variable {q w h n : ℕ} [Fact n.Prime]
namespace Matter
variable (m : Matter q w h n) {p : m.w0.Proof}
abbrev oracleV : Paint n :=
   (Net.forecast m.s m.top).outV m.view
abbrev polls (u : Pool n) := hit m.B (↑m.i:ZMod n) u.1

lemma reachesB : m.view.ready m.s m.top := by
   unfold view Peek.ready prizep
   refine ⟨le_rfl, le_rfl, ?_, trivial⟩
   unfold s Wares.ceiling top
   dsimp only
   omega

lemma origin (h:m.P.Space) : m.i∈m.d.S :=
   Prize.reach n m.s.H m.B (m.P.mem_first h m.x)
lemma designate {f:Paint n} (h:m.P.Space) (hr:m.ready p) :
    |m.d.vm f m.i| ≤ (m.s.N:ℝ)*m.d.von f := by
   let d:=m.d
   let P:=pct n d.u
   let a : ℝ:=d.N
   let x:=m.i
   let k:= d.vm f x
   have hu : d.u=m.B :=rfl
   have heB : 2^d.u≤n:= by
       rw [hu]
       have he:= m.lineup hr
       apply m.s.fits he

       change m.B ≤ m.w0.ceiling _; unfold Wares.ceiling; omega
   have hx := m.origin h
   have hF: k^4 ≤ d.vm (fun s i=> f s i^4) x := by apply av_four_le
   have hA:a≥1:=by
       change (1:ℝ) ≤ (2^(m.w0.density m.B):ℕ)
       exact_mod_cast (show 0< (2^(m.w0.density m.B):ℕ) by positivity)
   have ht i : 0≤ d.vm (fun s i=>f s i^4) i := av_nonneg _ (by intros; positivity)
   have hR : 0< rate d.u:=rate_pos _
   have hp : rate d.u ≤ P:=(pct_bounds heB).1
   let u:=scaleM d.N d.u
   have hs :
      u*P*k^4 ≤d.von f^4 := calc
      _ ≤ u*(P*(d.vm (fun s i=>f s i^4) x)):=by
            have hv := mul_le_mul_of_nonneg_left hF
               (mul_nonneg (scaleM_nn d.N d.u) (hR.le.trans hp))
            dsimp only [u]; linarith
      _ ≤ _:= by
         rw [d.von_four,d.vpivot]
         apply mul_le_mul_of_nonneg_left _ (scaleM_nn ..)
         exact single_le_sum (f:=fun i=>P*(d.vm (fun s i=>f s i^4) i))
                    (fun i _=>mul_nonneg (hR.le.trans hp) (ht i)) hx
   have ha : 0<a*rate d.u:=mul_pos (by linarith) hR
   have he : a*(u*P*k^4) ≥ k^4 := by
      have hN:0<(d.N:ℝ) := by change 0<a; linarith
      unfold u scaleM a
      field_simp
      nlinarith [mul_le_mul_of_nonneg_right hp (show 0≤k^4 by positivity)]
   change |k| ≤ a*d.von f
   have hu0 :=d.vn0 f
   conv_lhs=>rw [← four_fourth (abs_nonneg _)]
   conv_rhs=> rw [← four_fourth (show 0≤a*d.von f by positivity)]
   rw [Meter.abs4,mul_pow]
   apply fourth_mono
   have he0:a≤a^4:=by simpa using pow_le_pow_right₀ hA (show 1≤(4:ℕ) by omega)
   exact le_trans he ((mul_le_mul_of_nonneg_left hs (by linarith :0≤a)).trans
         (mul_le_mul_of_nonneg_right he0 (by positivity)))

set_option maxHeartbeats 500000 in
lemma designate_est (h:m.P.Space) (hr:m.ready p) :
    |m.view.pursue m.s m.i-m.d.vm m.oracleV m.i| ≤ 1/32 := by
   have he:=m.lineup hr
   have hs : Trust (s:=m.s) p.T m.top (Net.forecast m.s m.top) := error_estimate (s:=m.s) p.v he p.credit _
   have hv := hs.v m.reachesB
   let u:=m.view.wear m.s
   let F:= fun (s:Pool n) (i:ℕ)=> u s i-m.oracleV s i
   have hx := m.designate (f:=F) h hr
   unfold F at hx; rw [Axis.vmean_sub] at hx
   have hh:m.d.vm u=m.view.pursue m.s:=Axis.vdet ..
   rw [hh] at hx
   apply hx.trans
   have hT :=mul_le_mul_of_nonneg_left hv.2 (show (0:ℝ)≤ m.s.N by positivity)
   apply hT.trans
   rw [m.rank_allow]
   let d:=m.w0.density m.B
   have hd : (m.s.N:ℝ)=Est.box d := by change ((2^d:ℕ):ℝ)=_; simp [Est.box]
   rw [hd]
   have hu : Est.box d * (p.T.bank * (dry d * dry m.B^2))=p.T.bank*dry m.B^2 := by
      have hh:= unify d
      linear_combination (norm := ring_nf) p.T.bank*dry m.B^2*hh
   change Est.box d * (p.T.bank*(dry d*dry m.B^2)) ≤ _
   rw [hu]
   calc p.T.bank * dry m.B^2 ≤ Est.box m.B*dry m.B^2 := by gcongr; exact hr.2.2.1
        _ = dry m.B := by rw [pow_two,← mul_assoc,unify,one_mul]
        _ ≤ _:= (dry_mono hr.1).trans (by norm_num [dry,Est.box])

lemma place (f:Pool n→ℝ) :
    av (fun s:Pool n=> if m.polls s then f s else 0)=
        pct n m.B *m.d.vm (fun s _=>f s) m.i := by
   let P (u : Pool n) := hit m.B (↑m.i:ZMod n) u.1
   have ht:= @Env.two_cond n 0 _ m.B 0 (m.i:ZMod n) 0 f
   simp only [Env.mask,allhit,and_true,pct_c0,mul_one] at ht
   exact ht

def jury (f:Pool n→ℝ) := m.d.vm (fun s _=>f s) m.i
lemma yard (f:Pool n→ℝ)
    (h : ∀ s,m.polls s → |f s-m.oracleV s m.i| ≤ 1/32) :
    |m.jury f-m.d.vm m.oracleV m.i| ≤ 1/32 := by
   unfold jury Axis.vm Env.cond
   let o:Env.Slice n m.B 0 0→Pool n :=
                  Env.outward m.B 0 (m.i:ZMod n) 0
   have hh (u : Env.Slice n m.B 0 0) := h (o u) (Env.hits ..).1
   let v u:=f (o u)-m.oracleV (o u) m.i
   have he : -(1/32:ℝ) ≤ av v ∧ av v≤1/32 := by
      refine ⟨?_,?_⟩
      · refine le_trans ?_ (av_mono (g:=v) (f:=fun _=> -(1/32:ℝ)) (fun i=>(abs_le.1 (hh i)).1))
        rw [av_const]
      refine le_trans (av_mono (f:=v) (g:=fun _=> (1/32:ℝ)) (fun i=>(abs_le.1 (hh i)).2)) ?_
      rw [av_const]
   unfold v at he; rw [av_sub] at he; rw [abs_le]; exact he

def evidence (f: Pool n → ℝ) := m.jury f
lemma probes (h:m.P.Space) (hr:m.ready p) (f:Pool n→ℝ)
    (he: ∀ s,m.polls s → |f s - m.oracleV s m.i|≤1/32) :
    |(m.P.mach.acceptanceProbability m.x (m.P.clock m.x):ℝ)-m.evidence f| < 1/8 := by
   rw [← Raw.answer _ _ m.w0 h]
   have h1:= m.identity hr; have h2:= m.designate_est h hr
   have h3 := m.yard f he
   change |m.s.H.v m.x0-m.jury f| < 1/8
   rw [abs_le] at *; rw [abs_lt]
   constructor <;> linarith [h3.1,h3.2,h1.1,h1.2,h2.1,h2.2]

/-- Compare arithmetic rather than doing probability tests. -/
lemma tally_eq (f:Pool n→ℝ) :
    (∑ s∈ univ.filter (fun s:Pool n=>m.polls s),f s) =
        ((univ.filter (fun s:Pool n=>m.polls s)).card:ℝ) * m.evidence f := by
   let S:=univ.filter fun s:Pool n=>m.polls s
   have he (f: Pool n→ ℝ) : ∑ s∈S,f s=
          (Fintype.card (Pool n):ℝ)*(pct n m.B * m.jury f) := by
      rw [show m.jury f=m.d.vm (fun s _ => f s) _ from rfl,← m.place f,av_card]; exact sum_filter ..
   have hi := he (fun _=>1)
   simp only [sum_const,nsmul_eq_mul,mul_one] at hi
   have hx : m.jury (fun _=>1)=1:= congrFun (m.d.vdet (n:=n) (fun _=>1)) m.i
   rw [hx,mul_one] at hi
   change _=(S.card:ℝ)*_
   rw [he,hi,mul_assoc]; rfl
lemma quorum :
    0<(univ.filter fun s:Pool n=>m.polls s).card := by
   apply card_pos.mpr
   let P:=Env.Slice n m.B 0 0
   have hp:Nonempty P:=by unfold P; infer_instance
   obtain ⟨x⟩:=hp
   exact ⟨Env.outward _ _ (↑m.i:ZMod n) 0 x,mem_filter.mpr ⟨mem_univ _,
                          (Env.hits ..).1⟩⟩
end Matter

end
end ExactDerandomization.Stage

end

end OAI