import OAI.Computability.Logspace.AffineSampling
import OAI.Computability.Logspace.ConfigurationGraph
import OAI.Computability.Logspace.DyadicArithmetic
import OAI.Computability.Logspace.ProbabilityDecision
import OAI.Computability.Logspace.RecursivePrograms
import Mathlib.NumberTheory.Bertrand

namespace OAI

/-!
Uniform prime-field enumeration and finite arithmetic for deterministic probability decisions.

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

set_option autoImplicit true

section

namespace ExactDerandomization.Grain
open Relay Counter Finset
namespace Prime

def tube {α} (f:PT (α×ℕ) Bool) (x:Word)(a:α)(n:ℕ):ℕ :=
    forNat (fun j v=>if f x (a,j) then j+1 else v) 0 n
lemma tube_hi {α}(f:PT (α×ℕ) Bool) (x a n):tube f x a n≤n:=by
   induction n <;> simp only [tube,forNat] at *
   · exact le_rfl
   split <;> omega

lemma unique_small {α} {f:PT (α×ℕ) Bool} {x a n} :
    tube f x a n=0 ↔ ∀ j < n, f x (a,j)=false :=by
   induction n with
   | zero=> simp [tube,forNat]
   | succ n ih=>
     have he : (∀ j<n+1,f x (a,j)=false) ↔ f x (a,n)=false ∧ (∀ j<n,f x (a,j)=false) :=by
        constructor
        · exact fun h=>⟨h n (by omega),fun i he=> h i (by omega)⟩
        intro h i hi
        rcases Nat.eq_or_lt_of_le (Nat.le_of_lt_succ hi) with he|he
        · simpa [he] using h.1
        · exact h.2 i he
     rw [he]; change (if f x (a,n) then n+1 else _)=0 ↔ _
     cases h:f x (a,n) <;> simp [← ih,tube]
lemma uniquely {α} {f:PT (α×ℕ) Bool} {x a n i}
    (h:tube f x a n=i+1) : i < n ∧ f x (a,i)=true:=by
   induction n with
   | zero=> simp [tube,forNat] at h
   | succ n ih=>
     change (if f x (a,n) then n+1 else tube f x a n)=i+1 at h
     split at h
     · have he:i=n:=by omega
       subst i; exact ⟨by omega,by assumption⟩
     obtain ⟨ht,hh⟩:=ih h; exact ⟨by omega,hh⟩

lemma tubeK {α} [Wire α] {f:PT (α×ℕ) Bool}{n:PT α ℕ}(h:Kn f)(he:Kn n):
     Kn (fun x a=>tube f x a (n x a)):=
   Kn.stroll (fun x (b:α×ℕ×ℕ)=>if f x (b.1,b.2.1) then b.2.1+1 else b.2.2)
       n (fun _ _=>0) n ((h.comp (Kn.first.tuple Kn.next.left)).cond Kn.next.left.succ Kn.next.right)
         he (Kn.fix 0) he (fun _ _ _ hv=> le_trans (tube_hi ..) hv)

def test (_:Word)(a:ℕ×ℕ):Bool :=
    if a.2 < 2 then false else decide (a.1%a.2=0)

def primex (x:Word)(k:ℕ):Bool :=
    if k<2 then false else decide (tube test x k k=0)

lemma divK : Kn test:= Kn.next.cond_lt (Kn.fix _) (Kn.fix _) ((Kn.first.mod Kn.next).eq (Kn.fix _))
lemma pxK : Kn primex:= Kn.identity.cond_lt (Kn.fix _) (Kn.fix _)
            ((tubeK divK Kn.identity).eq (Kn.fix _))

lemma px_eq (x n): primex x n=true↔n.Prime:=by
   unfold primex
   by_cases ht:n<2
   · simp only [ht,ite_true,Bool.false_eq_true,false_iff]
     intro h; have he:=h.two_le; omega
   rw [ite_eq_right ht,decide_eq_true_eq,unique_small]
   constructor
   · intro h
     rw [Nat.prime_def_lt]
     refine ⟨by omega,?_⟩
     intro m hm he
     have hs:= h _ hm
     have h0 : m≠0:= by rintro rfl; simp at he; omega
     by_cases hb:m<2
     · omega
     simp [test,hb,Nat.mod_eq_zero_of_dvd he] at hs
   intro h m hm
   unfold test; split
   · rfl
   next hh=>
      by_contra! hv
      have hz:m∣n:= Nat.dvd_of_mod_eq_zero (by simpa using hv)
      have he:= (Nat.dvd_prime h).1 hz; omega

def atp (x:Word) (a:ℕ×ℕ):Bool :=
    if a.1 < a.2 then primex x a.2 else false
def last (x:Word) (n:ℕ) := tube atp x n (2*n+1)-1
lemma last_prime (x n)(h:0<n) : (last x n).Prime ∧ n < last x n ∧ last x n≤ 2*n:= by
    obtain ⟨p,hp,ht,hk⟩:= Nat.bertrand n (by omega)
    have hl: atp x (n,p)=true:=by rw [atp]; simp [ht,(px_eq ..).2 hp]
    unfold last
    cases hh:tube atp x n (2*n+1) with
    | zero=> have he:=unique_small.1 hh p (by omega); simp_all
    | succ i=>
      have he:=uniquely hh
      simp only [Nat.add_sub_cancel]
      unfold atp at *; split at he
      · exact ⟨(px_eq ..).1 he.2,by assumption,by omega⟩
      · grind

lemma lastK : Kn last:=(tubeK (Kn.first.cond_lt Kn.next (pxK.comp Kn.next) (Kn.fix _))
                     (((Kn.fix 2).times Kn.identity).succ)).pred
end Prime
end ExactDerandomization.Grain

end

section

namespace ExactDerandomization.Grain
open Relay Counter Stage Hie
variable {q w h:ℕ}
structure Rock (q w h:ℕ) where
   P:Base.Source q w h
   w:Wares
   pad:ℕ

namespace Rock
variable (p:Rock q w h)
def B (x:Word):ℕ:= p.pad+lb (p.P.size x)+ lb (x.length+2)
def lamp (x:Word):ℕ:=2^(p.w.ceiling (p.B x))+p.w.p.M
def n (x:Word):ℕ:=Prime.last x (p.lamp x)
instance primed (x:Word) : Fact (p.n x).Prime:=⟨(Prime.last_prime x (p.lamp x)
        (by unfold lamp; positivity)).1⟩
lemma nf (x:Word): p.w.p.M<p.n x ∧ 2^(p.w.ceiling (p.B x))≤ p.n x:=by
    have he:p.lamp x < p.n x:=(Prime.last_prime x (p.lamp x) (by unfold lamp; positivity)).2.1
    unfold lamp at he; constructor <;> first|exact le_trans (Nat.le_add_left _ _) he|exact (Nat.le_add_right _ _).trans he.le
noncomputable def matter0 (x:Word):Matter q w h (p.n x):=⟨p.P,p.w,x,p.B x⟩
lemma prompts (e:p.w.Proof) (h:6≤p.pad) (ht:e.T.bank ≤ Est.box p.pad) (x:Word) :
      (p.matter0 x).ready e := by
    have hp:p.pad≤p.B x:=by unfold B; omega
    exact ⟨h.trans hp, (below (p.P.size x)).le.trans (Nat.pow_le_pow_right Nat.zero_lt_two (by change lb (p.P.size x) ≤ p.B x; unfold B; omega)),
           ht.trans (Est.box_mono hp), (p.nf x).1,(p.nf x).2⟩

lemma sizeE :E (fun x _=>p.B x):= ((E.const p.pad).add (lbE p.P.eSize)).add
                  (lbE (E.length.add (E.const 2)))
lemma codeE : E (fun x _=>2^p.B x):= by
    have hh:= ((E.const (2^p.pad)).mul (digitsE p.P.eSize)).mul
                       (digitsE (E.length.add (E.const 2)))
    simpa only [B,pow_add] using hh

section
variable {α} [Wire α]
lemma BKn:Kn (fun x (_:α)=>p.B x):=Kn.word _ p.sizeE
lemma codeKn:Kn (fun x (_:α)=> (2:ℕ)^p.B x):=Kn.word _ p.codeE

abbrev linE (a b:ℕ) (x:Word) := a + b*p.B x
lemma exprKn (i j):Kn (fun x (_:α)=>(2:ℕ)^p.linE i j x):=by
    simpa only [linE, mul_comm j, pow_add,pow_mul] using
                  (Kn.fix (α:=α) (2^i)).times (Kn.power j p.codeKn)
lemma affine :∃ a b,∀ x,p.w.ceiling (p.B x)=p.linE a b x:=by
   let m:=p.w.p.M
   let g:=p.w.A0
   use 8*g+1,8*(4+g*(Net.lag p.w.p)+(1+m)+2)+1+(1+m)
   intro x; unfold Wares.ceiling Wares.top Wares.tolls Wares.density linE Net.coreR m g; ring
lemma lampK:Kn (fun x (_:α)=>p.lamp x):=by
   obtain ⟨a,b,h⟩:=p.affine
   unfold lamp; simp only [h]
   exact (p.exprKn a b).add (Kn.fix _)
lemma nKn :Kn (fun x (_:α)=> p.n x):= Prime.lastK.comp p.lampK

end
end Rock
end ExactDerandomization.Grain

end

section

namespace ExactDerandomization.Grain
open Relay Counter Rill Analysis Square Affine Env Wrap Finset

abbrev Page := Four ℕ
abbrev Stamp:= Page×Page
abbrev Issue:=Stamp×Stamp×Stamp
variable {n:ℕ} [Fact n.Prime]

namespace Print
set_option synthInstance.maxSize 4096
noncomputable section

def ncard (x:V n):Page := vmap (fun i=> i.val) x
def den (n:ℕ)(x:Page) : V n := vmap (fun (i:ℕ)=> (i: ZMod n)) x
def badge (s:Channel n):Stamp :=(ncard s.1.val,ncard s.2)
def issued (s:Env n 0):Issue:=(badge s.1,badge s.2.1,badge s.2.2.1)
lemma nr (x:V n):den n (ncard x)=x:= by simp [den,ncard,vmap]
lemma xi : Function.Injective (@badge n) := by
   intro a b h
   have he1 : a.1.val=b.1.val:=by rw [← nr a.1.val,← nr b.1.val, show ncard a.1.val=ncard b.1.val from
                                                           congrArg Prod.fst h]
   exact Prod.ext (Subtype.ext he1) (by rw [← nr a.2,← nr b.2,show ncard a.2=ncard b.2 from congrArg Prod.snd h])
instance : Subsingleton (Salt 0):=inferInstanceAs (Subsingleton (V 1))
lemma xu : Function.Injective (@issued n) := by
   rintro ⟨v,w,t,r⟩ ⟨v',w',t',r'⟩ h
   unfold issued at h; simp only [Prod.mk.injEq] at h ⊢
   exact ⟨xi h.1,xi h.2.1,xi h.2.2,Subsingleton.elim ..⟩

def barr (a ℓ:ℕ×ℕ):Prop:=a.1<ℓ.1∧a.2<ℓ.2
def brief (a:Page)(n:ℕ):Prop:=barr a.1 (n,n) ∧ barr a.2 (n,n)
def on (a:Stamp)(n:ℕ):Prop:= brief a.1 n ∧ a.1≠0 ∧ brief a.2 n
def revealed (a:Issue)(n:ℕ):Prop:=on a.1 n ∧ on a.2.1 n ∧ on a.2.2 n
instance (a:Page)(n):Decidable (brief a n):=by unfold brief barr;infer_instance
instance (a:Stamp)(n):Decidable (on a n):=by unfold on;infer_instance
instance (a:Issue)(n):Decidable (revealed a n):=by unfold revealed;infer_instance
lemma nsmall (x:V n): brief (ncard x) n := by simp [ncard,vmap,brief,barr,ZMod.val_lt]
omit [Fact (Nat.Prime n)] in
lemma rn (x:Page)(h:brief x n): ncard (den n x)=x:= by
   obtain ⟨⟨ht,hf⟩,hq,hz⟩:=h
   simp [ncard,den,vmap,ZMod.val_natCast,Nat.mod_eq_of_lt,ht,hf,hq,hz]
lemma valid (s:Channel n):on (badge s) n:= by
   refine ⟨nsmall _,?_,nsmall _⟩
   change ncard s.1.val≠_
   intro he
   apply s.1.prop
   rw [← nr s.1.val,he]; simp [den,vmap,Prod.ext_iff]
lemma built (x:Stamp)(h:on x n):∃ s:Channel n,badge s=x:=by
   obtain ⟨ha,hb,hk⟩:=h
   have hp : den n x.1 ≠0:= by
      intro he; apply hb; rw [← rn x.1 ha,he]; simp [ncard,vmap,Prod.ext_iff]
   exact ⟨(⟨den n x.1,hp⟩,den n x.2),by simp [badge,rn x.1 ha,rn x.2 hk]⟩
lemma constit (s:Env n 0):revealed (issued s) n :=⟨valid _,valid _,valid _⟩
lemma fill (x:Issue)(h:revealed x n): ∃ s:Env n 0,issued s=x:=by
   rcases x with ⟨a,b,c⟩
   obtain ⟨u,rfl⟩:= built a h.1
   obtain ⟨v,rfl⟩:= built b h.2.1
   obtain ⟨w,rfl⟩:= built c h.2.2
   exact ⟨(u,v,w,(0:Salt 0)),rfl⟩

def wallP (n:ℕ):Page:=((n,n),(n,n))
def ink (n:ℕ):Stamp:=(wallP n,wallP n)
def pages (n:ℕ):ℕ:=enc ((ink n,ink n,ink n):Issue)+1
lemma boxbound (s:Env n 0):enc (issued s)< pages n:=by
   have he(q:V n):enc (ncard q)≤enc (wallP n):= by
      obtain ⟨⟨ha,hb⟩,hc,hd⟩:=nsmall q
      exact bead_mono (pair_mono ha.le hb.le) (pair_mono hc.le hd.le)
   have hp(x:Channel n): enc (badge x) ≤ enc (ink n):= bead_mono (he _) (he _)
   exact Nat.lt_succ_of_le (bead_mono (hp _) (bead_mono (hp _) (hp _)))

def publish (n v:ℕ) : Bool:= decide (revealed (dec v:Issue) n ∧ enc (dec v:Issue)=v)
def spine (n:ℕ) : Finset ℕ:= (range (pages n)).filter (fun i=> publish n i)
lemma entry (s:Env n 0) : enc (issued s)∈spine n:= by
    rw [spine,mem_filter]; exact ⟨mem_range.2 (boxbound _),
                                   by simp [publish,constit]⟩
lemma owner {x}(h:x∈spine n): ∃ s:Env n 0, enc (issued s)=x:=by
   obtain ⟨ht,he⟩:=mem_filter.1 h
   obtain ⟨hi,hf⟩:= of_decide_eq_true he
   obtain ⟨s,h⟩:= fill (dec x) hi
   exact ⟨s,by rw [h,hf]⟩
lemma columns {n:ℕ} [Fact n.Prime] (f:ℕ→ℝ):
   ∑ i∈spine n,f i=∑ s:Env n 0, f (enc (issued s)):=by
   classical
   symm
   refine sum_nbij (fun s:Env n 0=>enc (issued s)) (fun x _=>entry x) (fun s _ t _ h=>?_)
               (fun x hx=>by obtain ⟨s,h⟩:=owner hx; exact ⟨s,mem_univ _,h⟩) fun _ _=>rfl
   exact xu (by simpa using congrArg (fun a=> (dec a:Issue)) h)

end
variable {α} [Wire α]
open Kn
lemma both {f g:PT α Bool}(h:Kn f)(k:Kn g):Kn (fun x a=> f x a&&g x a):=by
   convert h.cond k (Kn.fix false) using 1
   ext x a; cases hx:f x a <;> simp []
lemma bytesK {f:PT α Page}{g:PT α ℕ}(h:Kn f)(k:Kn g):
    Kn (fun x a=> decide (brief (f x a) (g x a))):=by
   convert both (both (h.left.left.lt k) (h.left.right.lt k)) (both (h.right.left.lt k) (h.right.right.lt k))
       using 1
   ext x a
   rw [Bool.eq_iff_iff]
   simp only [decide_eq_true_eq, Bool.and_eq_true]
   rfl
lemma onK {f:PT α Stamp}{g:PT α ℕ}(h:Kn f)(k:Kn g):
    Kn (fun x a=>decide (on (f x a) (g x a))):=by
   let t:=h.left
   have he:Kn (fun x a=> decide ((f x a).1≠0)):=by
      convert bneg _ ((Kn.wash.comp h.left).eq (Kn.fix (enc (0:Page)))) using 1
      ext x a; rw [Bool.eq_iff_iff]; simp; exact ⟨fun e h=>e (by
                              simpa using congrArg (fun n=>(dec n:Page)) h), fun e h=>e (by rw [h])⟩
   convert both (bytesK h.left k) (both he (bytesK h.right k)) using 1
   ext x a
   rw [Bool.eq_iff_iff]
   simp only [decide_eq_true_eq, Bool.and_eq_true]
   rfl
lemma pagesK {f:PT α ℕ}(h:Kn f):
    Kn (fun x a=>pages (f x a)):= by
   have ha:=h.tuple h; have hb:=ha.tuple ha; have ht:=hb.tuple hb
   exact (Kn.wash.comp (ht.tuple (ht.tuple ht))).succ
lemma pubK {f g:PT α ℕ}(h:Kn f)(k:Kn g):
    Kn (fun x a=>publish (f x a) (g x a)):=by
   have he:=(Kn.unpack (α:=Issue)).comp k
   have hz:=both (onK he.left h) (both (onK he.right.left h) (onK he.right.right h))
   convert both hz ((Kn.wash.comp he).eq k) using 1
   ext x a
   rw [Bool.eq_iff_iff]
   simp only [publish, decide_eq_true_eq, Bool.and_eq_true]
   rfl

end Print
end ExactDerandomization.Grain

end

section

namespace ExactDerandomization.Grain
open Relay Counter Rill Analysis Square Affine Env Wrap Finset
namespace Print
noncomputable section

def ms (n i x y:ℕ) := (x+i*y)%n
def zi (n i:ℕ ) (x y:ℕ×ℕ) := (ms n i x.1 y.1,ms n i x.2 y.2)
def mix (n i:ℕ ) (a b:Page):Page:=(zi n i a.1 b.1,zi n i a.2 b.2)

variable {n:ℕ} [Fact n.Prime]
lemma valms (i:ℕ ) (x y:ZMod n): (x+(i:ZMod n)*y).val=ms n i x.val y.val:=by
    have he:(x+(i:ZMod n)*y)= ↑(x.val+i*y.val):=by simp
    rw [he,ZMod.val_natCast]; rfl
lemma nadd (i:ℕ ) (x y:V n): ncard (x+(i:ZMod n)•y)=mix n i (ncard x) (ncard y) :=
    Prod.ext (Prod.ext (valms ..) (valms ..)) (Prod.ext (valms ..) (valms ..))

def shoot (n k x:ℕ ) (p:Stamp):Bool:=decide (brief (mix n x p.2 p.1 ) (side n k))
lemma shoots (a:Channel n) (k i):
    shoot n k i (badge a)=true ↔ hit k (i:ZMod n) a := by
   unfold shoot badge hit vEval; dsimp only; rw [← nadd,decide_eq_true_eq]; simp [ncard,brief,barr,vmap,restr,each,and_assoc]

def stretch (n s t:ℕ) (p:Stamp):Stamp:=(mix n s 0 p.1,mix n t p.2 p.1)
lemma stretchy (a:Channel n ) (s t:ℕ) (h:(s:ZMod n)≠0) :
   stretch n s t (badge a)=badge (affineChannel (↑s:ZMod n) ↑t h a) := by
   let w:= a.1.val
   unfold stretch badge
   change (_,_)= (ncard ((s:ZMod n)•w), ncard (a.2+(t:ZMod n)•w))
   have he: ncard (0:V n)=0:=by simp [ncard,vmap,Prod.ext_iff]
   apply Prod.ext _ (nadd t a.2 w).symm
   rw [← zero_add ((s:ZMod n) • w)]
   rw [nadd,he]

end
variable {α} [Wire α]
variable {x y k p:PT α ℕ}
lemma asideK (h:Kn x ) (e:Kn k):Kn (fun w a=>side (x w a ) (k w a)):= by
    convert (((h.pred.div (Kn.cap h.succ (Kn.fix 2) e)).succ)) using 1
    ext w a; unfold side
    by_cases he :2^(k w a) ≤ x w a+1
    · rw [min_eq_right he]
    rw [min_eq_left (by omega),Nat.div_eq_of_lt (by omega),Nat.div_eq_of_lt (by omega)]

lemma msK (hr:Kn p) (ht:Kn k ) (h:Kn x ) (e:Kn y):Kn (fun w a=>ms (p w a) (k w a) (x w a) (y w a)):=
    (h.add (ht.times e)).mod hr
lemma ziK (hr:Kn p ) (ht:Kn k){u v:PT α (ℕ×ℕ)}(h:Kn u ) (e:Kn v):
    Kn (fun w a=>zi (p w a ) (k w a ) (u w a ) (v w a)):=
    (msK hr ht h.left e.left).tuple (msK hr ht h.right e.right)
lemma mixK (hr:Kn p ) (ht:Kn k){u v:PT α Page}(h:Kn u ) (e:Kn v):
    Kn (fun w a=>mix (p w a ) (k w a ) (u w a ) (v w a)):=
       (ziK hr ht h.left e.left).tuple (ziK hr ht h.right e.right)
lemma shootK(hr:Kn p ) (ht:Kn k ) (h:Kn x){f:PT α Stamp}(e:Kn f):
    Kn (fun w a=>shoot (p w a ) (k w a ) (x w a ) (f w a)):=bytesK (mixK hr h e.right e.left) (asideK hr ht)
lemma stretchK (hr:Kn p ) (ht:Kn k ) (h:Kn x){f:PT α Stamp}(e:Kn f):
    Kn (fun w a=> stretch (p w a ) (k w a ) (x w a ) (f w a)) :=
       (mixK hr ht (Kn.fix _) e.left).tuple (mixK hr h e.right e.left)
end Print
end ExactDerandomization.Grain

end

section

set_option synthInstance.maxSize 4096

namespace ExactDerandomization.Grain
open Relay Counter Stage Est Analysis Hie Finset
namespace Rock
variable {q w h:ℕ}(p:Rock q w h)
noncomputable section

def camp (x:Word):ℕ:= p.w.p.M^p.B x*p.P.first x
lemma camps (x) : p.camp x=(p.matter0 x).i:=by
   let z:=p.matter0 x
   have he (n): z.s.H.child z.x0 n=p.w.p.M^n*p.P.first x:=by
       induction n with
       | zero=> change p.P.first x=_; simp
       | succ n ih=> rw [Prize.child,ih]
                     unfold radix; change _+p.w.p.M*_=_
                     ring
   exact (he _).symm
lemma campK {α} [Wire α]:Kn (fun x (_:α)=>p.camp x):=by
   let k:=p.w.p.M
   have hf:Kn (fun x (_:α)=>(k)^p.B x):=by
      convert (Kn.cap (p.exprKn 0 k) (Kn.fix k) p.BKn) using 1
      ext x a; symm; apply min_eq_right
      rw [linE,Nat.zero_add,pow_mul]
      have hh:= growing k
      gcongr; omega
   exact hf.times (Kn.word _ p.P.eFirst)

def qualify (x:Word) (a:ℕ) : Bool :=
     Print.publish (p.n x) a && Print.shoot (p.n x) (p.B x) (p.camp x) (dec a:Issue).1

abbrev printid (x:Word)(s:Pool (p.n x)) := enc (Print.issued s)
lemma verified (x:Word) (s:Pool (p.n x)):
    p.qualify x (p.printid x s)= true ↔ (p.matter0 x).polls s:=by
    have he:= (Print.entry s)
    have hk:= (mem_filter.1 he).2
    change Print.publish (p.n x) (p.printid x s)=true at hk
    rw [qualify, Bool.and_eq_true,hk]
    simp only [true_and]
    unfold printid; rw [Wire.eq]
    change _=true ↔ hit (p.B x) (↑(p.matter0 x).i:ZMod (p.n x)) s.1
    rw [← camps]
    exact Print.shoots ..
lemma qualifyK:Kn p.qualify:=
    Print.both (Print.pubK p.nKn Kn.identity) (Print.shootK p.nKn p.BKn p.campK (Kn.unpack (α:=Issue)).left)

lemma numbers (x) (f:ℕ→ℕ):
   (↑(∑ i∈range (Print.pages (p.n x)),if p.qualify x i then f i else 0):ℝ)=
        ∑ s∈ univ.filter (fun s:Pool (p.n x)=> (p.matter0 x).polls s),(f (p.printid x s):ℝ) := by
   classical
   let n:=p.n x
   let : Fact n.Prime:=p.primed x
   let F i:= (↑(if p.qualify x i then f i else 0):ℝ)
   push_cast
   calc
      _ = ∑ i∈Print.spine n,F i := by
             rw [Print.spine,sum_filter]
             refine sum_congr rfl fun i _=> ?_
             unfold F qualify
             by_cases h: Print.publish (p.n x) i=true
             · simp [h,n]
             simp [h,n]
      _ = _:=by
          rw [Print.columns (n:=n),sum_filter]
          refine sum_congr rfl fun i hi=>?_
          unfold F
          change (↑(if p.qualify x (p.printid x i) then f (p.printid x i) else 0):ℝ)=_
          split <;> have ht:= p.verified x i <;> grind

def sumtop (x:Word)(f:ℕ→ℕ) :ℕ:=
       ∑ i∈range (Print.pages (p.n x)), if p.qualify x i then min 64 (f i) else 0
lemma totalK (f:PT ℕ ℕ)(h:Kn f){α}[Wire α]: Kn (fun x (_:α)=> p.sumtop x (f x)):=by
   let g:PT (α × ℕ × ℕ) ℕ:= fun x a=> a.2.2+
                            (if p.qualify x a.2.1 then min 64 (f x a.2.1) else 0)
   have hg:Kn g:= Kn.next.right.add ((p.qualifyK.comp Kn.next.left).cond
                                        ((Kn.fix _).small (h.comp Kn.next.left)) (Kn.fix _))
   have hp (x a j):forNat (fun k v=>g x (a,k,v)) 0 j=
                   ∑ i∈range j, (if p.qualify x i then min 64 (f x i) else 0):=by
       induction j with
       | zero=> simp [forNat]
       | succ i ih=> rw [sum_range_succ,← ih]; rfl
   have ht:Kn (fun x (_:α)=> Print.pages (p.n x)):=Print.pagesK p.nKn
   simpa only [hp,sumtop] using Kn.stroll g _ (fun _ _=>0) _ hg ht (Kn.fix 0) (ht.times (Kn.fix 64)) (by
      intro x a B he
      rw [hp]
      apply le_trans (b:=∑ i∈range B,(64:ℕ))
      · exact sum_le_sum (fun i hi=>by split <;> omega)
      · simpa using Nat.mul_le_mul_right 64 he)

def census (x:Word):ℕ:=p.sumtop x (fun _=>1)
lemma witness0 (x): (p.census x:ℝ) = (univ.filter (fun s:Pool (p.n x)=> (p.matter0 x).polls s)).card:= by
   simpa only [census,sumtop,min_eq_right (show 1≤(64:ℕ) by omega),sum_const,nsmul_eq_mul,Nat.cast_one,mul_one] using p.numbers x (fun _=>1)
lemma positive0 (x):0 < p.census x:=by
   have h0:= (p.matter0 x).quorum
   have hz:= p.witness0 x
   have ht:p.census x=(univ.filter (fun s:Pool (p.n x)=>(p.matter0 x).polls s)).card:=by
        exact_mod_cast hz
   rwa [ht]

def survey (f:PT ℕ ℕ)(x)(s:Pool (p.n x)):ℝ:= (↑(min 64 (f x (p.printid x s))):ℝ) /64
lemma countok (f:PT ℕ ℕ)(x) :
    p.sumtop x (f x)=p.sumtop x (f x) ∧
       ((p.sumtop x (f x):ℝ)/64) = (p.census x:ℝ)*(p.matter0 x).evidence (p.survey f x):=by
   refine ⟨rfl,?_⟩
   rw [p.witness0,← Matter.tally_eq]
   unfold survey
   rw [← sum_div]
   congr 1
   exact p.numbers x (fun v=> min 64 (f x v))

def answer (f:PT ℕ ℕ) (x:Word) :ℕ :=
   if p.census x*32 < p.sumtop x (f x) then 1 else 0
lemma zenK {n:PT ℕ ℕ} (h:Kn n) (x : Word → ℕ) (ht : n=fun w _=>x w):
   E (fun y _=> x y):= by
   rw [ht] at h
   exact h (E.const 0)
lemma censusK : E (fun x _=> p.census x):=
   zenK (p.totalK (α:=ℕ) _ (Kn.fix 1)) _ (by rfl)
lemma tallyK (f:PT ℕ ℕ)(h:Kn f) : E (fun x _=> p.sumtop x (f x)) :=
   zenK (p.totalK (α:=ℕ) _ h) _ rfl
lemma annK (f:PT ℕ ℕ)(h: Kn f): E (fun x _=> p.answer f x):=
        (p.censusK.mul (E.const 32)).ite_lt (p.tallyK f h) (E.const 1) (E.const 0)

lemma scale_cnv {t:ℚ}: (t ≤ (1:ℚ)/3 → (t:ℝ) ≤1/3) ∧ ((2:ℚ)/3≤ t → (2:ℝ)/3≤ t):= by
    constructor <;> intro h
    · have hp:(↑t:ℝ)≤ ↑((1:ℚ)/3):= Rat.cast_le.mpr h
      push_cast at hp; exact hp
    have hp:(↑((2:ℚ)/3):ℝ) ≤ (t:ℝ):= Rat.cast_le.mpr h
    push_cast at hp; exact hp
lemma certificate {t v:ℝ}{a b:ℕ} {h:Prop} (hp: -(1/8:ℝ)< t-v ∧ t-v<1/8)
    (h0:0<(a:ℝ)) (hx:(b:ℝ)/64=a*v) (ht:¬h→ t≤ 1/3) (hu:h → 2/3≤ t):
     a*32 < b ↔ h:=by
       constructor
       · intro hs
         by_contra hv
         have hr:=ht hv
         have he:(a:ℝ)*32 < b:=by exact_mod_cast hs
         nlinarith [hp.1,hp.2]
       intro hs
       have hz:=hu hs
       have hc:(a:ℝ)*32 < b:=by nlinarith [hp.1,hp.2]
       exact_mod_cast hc
theorem convince {A:Language}(hS:p.P.Space)(p1: p.w.Proof)(hv:6≤p.pad)
    (hm:p1.T.bank≤Est.box p.pad)
    (fo:PT ℕ ℕ)(he:Kn fo)
    (ha:∀ x (s:Pool (p.n x)),
       let m:= p.matter0 x
       m.polls s → |p.survey fo x s-m.oracleV s m.i|≤ 1/32)
    (hs:∀ x∈A, (2/3:ℚ) ≤ p.P.mach.acceptanceProbability x (p.P.clock x))
    (ht:∀ x, x∉A → p.P.mach.acceptanceProbability x (p.P.clock x) ≤ (1/3:ℚ)):
    A∈ L :=by
    apply (p.annK fo he).gives_L _
    intro x
    have hx:=(p.countok fo x).2
    have hp :=Matter.probes (p:=p1) (p.matter0 x) hS (p.prompts p1 hv hm x) (p.survey fo x) (ha x)
    let t:ℝ:=p.P.mach.acceptanceProbability x (p.P.clock x)
    let v:ℝ:=(p.matter0 x).evidence (p.survey fo x)
    change |t-v|<_ at hp
    rw [abs_lt] at hp
    let a:=p.census x
    let b:=p.sumtop x (fo x)
    have h1 :0<(a:ℝ):=by exact_mod_cast p.positive0 x
    change (b:ℝ)/_=↑a*v at hx
    change p.answer fo x≠0↔ _
    unfold answer; change (if a*32<b then _ else _)≠_ ↔ _
    suffices hh:a*32 < b ↔x ∈ A by simpa using hh
    apply certificate hp h1 hx ?_ ?_
    · intro hy; exact scale_cnv.1 (ht x hy)
    intro hy; exact scale_cnv.2 (hs x hy)

end
end Rock
end ExactDerandomization.Grain

end

section

namespace ExactDerandomization.Grain
open Relay Counter Rill Analysis Square Affine Env Wrap Finset
namespace Print
noncomputable section
abbrev Z4:=Four ℤ

def zd (a:Page):Z4:=vmap (fun i:ℕ=>(i:ℤ)) a
def red (n:ℕ ) (a:Z4) :Page:=vmap (fun i:ℤ=>(i%(n:ℤ)).toNat) a

def change0 (n:ℕ ) (g:Gen ) (v:Page):Page:=red n (pol false g (zd v))
def change1 (n:ℕ ) (g:Gen ) (v:Page ) (k:ℕ ) (w:W):Page:=
    red n (pol true g (zd v)+addin (side n k) w)
def bare (n:ℕ ) (g:Gen ) (s:Stamp):Stamp:=(change0 n g s.1,red n (pol true g (zd s.2)))
def walkstep (n:ℕ ) (g:Gen ) (k:ℕ ) (w:W ) (s:Stamp):Stamp:=
         (change0 n g s.1,change1 n g s.2 k w)

def reducep (a:Page ) (m:ℕ):Page:= vmap (· % m) a
def fetch (n k i:ℕ ) (g:Gen ) (s:Stamp):W:=
    guess (side n k) (pol true g (zd (reducep (mix n i s.2 s.1) (side n k))))

variable {n m:ℕ} [Fact n.Prime] [NeZero m]
omit [NeZero m] in
lemma readout (v:V m) : zd (ncard v)=raiseV v:= rfl
lemma redCast (v:Z4):red m v=ncard (reduceV m v):=by
    have h(i:ℤ):(i%(m:ℤ)).toNat=(i:ZMod m).val:=by
       rw [← ZMod.val_intCast]; omega
    simp only [red,ncard,vmap,reduceV,h]
omit [NeZero m] in
lemma reducePol_any (b g) (t: Z4) : reduceV m (pol b g t)=pol b g (reduceV m t) := by
   cases b
   · unfold pol; split
     all_goals
       unfold reduceV lower vmap
       cases he:g.2 with
       | inl u=>
          cases u with
          | inl b=> rcases b with ⟨a,b⟩; cases a <;> simp
          | inr b=>cases b <;> simp
       | inr u=> rcases u with ⟨a,b⟩; cases a <;> cases b <;> simp
   · exact reducePol g t

lemma prints_any (v:V m ) (b g):red m (pol b g (zd (ncard v)))=ncard (act b g v):=by
    rw [readout,redCast,reducePol_any,reraise,act_formula]
lemma recast (g ) (s:Channel n):
    bare n g (badge s)=badge (gens n g s):=by
   let a:=s.1.val; let b:=s.2
   exact Prod.ext (prints_any a false g) (prints_any b true g)
lemma zoom (g k w ) (s:Channel n):
    walkstep n g k w (badge s)=badge (Variant k g w s):=by
    let a:=s.1.val; let b:=s.2
    have he:change1 n g (ncard b) k w=ncard (act true g b+reduceV n (addin (side n k) w)):=by
        rw [change1,redCast,reduce_add,readout,reducePol,reraise,act_formula]
    exact Prod.ext (prints_any a false g) he

lemma fetching (k i:ℕ ) (g ) (s:Channel n):
    fetch n k i g (badge s)=guessP k g (closeP k (↑i:ZMod n) s):= by
     let v:=vEval s (↑i:ZMod n)
     have he:mix n i (badge s).2 (badge s).1=ncard v:=(nadd ..).symm
     rw [fetch,he]
     have ht: reducep (ncard v) (side n k)=ncard (vshort k v):= by
        simp only [reducep,ncard,vshort,vmap,ZMod.val_natCast]
     rw [ht,readout]; rfl

variable {α β γ:Type}[Wire α][Wire β][Wire γ]
lemma quads {s:PT α (Four β)} (h:Kn s ) (f:PT (α×β) γ ) (e:Kn f):
    Kn (fun x a=>vmap (fun i=>f x (a,i)) (s x a)):=by
    exact ((e.comp (Kn.identity.tuple h.left.left)).tuple
                (e.comp (Kn.identity.tuple h.left.right))).tuple
             ((e.comp (Kn.identity.tuple h.right.left)).tuple
                (e.comp (Kn.identity.tuple h.right.right)))
lemma zdK {s:PT α Page}(h:Kn s):Kn (fun x a=>zd (s x a)):=quads h (fun _ (a:α×ℕ)=>(a.2:ℤ)) Kn.next.ZofN

lemma holeK {x:PT α ℤ} {m:PT α ℕ} (h:Kn x ) (e:Kn m) :
    Kn (fun w a=> x w a%((m w a:ℕ):ℤ)):= by
    convert e.cond_eq (Kn.fix 0) h (h.modulus e.pred) using 1
    ext w a; split
    · simp_all
    · next hz=> simp [Nat.sub_add_cancel (show 1 ≤ m w a by omega)]

lemma redK {f:PT α Z4} {m:PT α ℕ}(h:Kn f ) (e:Kn m):
    Kn (fun w a=> red (m w a ) (f w a)) :=
       quads h (fun w (a:α×ℤ)=>(a.2%(m w a.1)).toNat) ((holeK Kn.next (e.comp Kn.first)).topNat)
lemma plow (b:Bool ) (g:Affine.Cmd) {s t:PT α (ℤ×ℤ)} (h:Kn s ) (e:Kn t):
    Kn (fun x a => lower b g (s x a) (t x a)):= by
    cases g with
    | inl c=>
      cases c with
      | inl c=>
        rcases c with ⟨w,z⟩; cases w
        · exact h.left.tuple (h.right.plusZ ((Kn.fix (-(amount z:ℤ))).prodZ h.left))
        exact (h.left.plusZ ((Kn.fix (-(amount z:ℤ))).prodZ h.right)).tuple h.right
      | inr c=>
        cases b
        · exact h
        cases c
        · exact h.left.tuple (h.right.plusZ (Kn.fix _))
        exact (h.left.plusZ (Kn.fix _)).tuple h.right
    | inr c=>
      rcases c with ⟨i,j⟩; cases i <;> cases j
      · exact h.left.tuple (h.right.plusZ e.right)
      · exact h.left.tuple (h.right.plusZ e.left)
      · exact (h.left.plusZ e.right).tuple h.right
      exact (h.left.plusZ e.left).tuple h.right

lemma polK {f:PT α Z4}(h:Kn f ) (b:Bool ) (g:Gen):Kn (fun w a=> pol b g (f w a)):= by
   rcases g with ⟨i,j⟩; cases i
   · exact (plow b j h.left h.right).tuple h.right
   exact h.left.tuple (plow b j h.right h.left)

lemma plusK {f g:PT α Z4}(h:Kn f ) (e:Kn g): Kn (fun w a=> f w a+g w a):=
    ((h.left.left.plusZ e.left.left).tuple (h.left.right.plusZ e.left.right)).tuple
               ((h.right.left.plusZ e.right.left).tuple (h.right.right.plusZ e.right.right))

lemma addK {f:PT α ℕ}(h:Kn f ) (v:W):Kn (fun w a=> addin (f w a) v):=by
    have he(i:Fin 11):Kn (fun w a=> (f w a:ℤ)*((i.val:ℤ)-5)) := h.ZofN.prodZ (Kn.fix _)
    exact ((he _).tuple (he _)).tuple ((he _).tuple (he _))

lemma bareK {f:PT α Stamp}(h:Kn f ) (g:Gen){p:PT α ℕ}(he:Kn p):
    Kn (fun x a=> bare (p x a) g (f x a)) :=
    (redK (polK (zdK h.left) false g) he).tuple (redK (polK (zdK h.right) true g) he)
lemma zoomK {f:PT α Stamp}(h:Kn f ) (g:Gen){p k:PT α ℕ}(hp:Kn p ) (hk:Kn k ) (v:W):
    Kn (fun x a=>walkstep (p x a) g (k x a) v (f x a)) :=
   (redK (polK (zdK h.left) false g) hp).tuple
     (redK (plusK (polK (zdK h.right) true g) (addK (asideK hp hk) v)) hp)

lemma downK {x m:PT α ℕ}(h:Kn x ) (e:Kn m): Kn (fun w a=> x w a/m w a):= h.div e
lemma dropK {x:PT α ℤ} {m:PT α ℕ}(h:Kn x ) (e:Kn m):Kn (fun w a=> x w a/(m w a:ℕ)):=by
   convert e.cond_eq (Kn.fix 0) (Kn.fix 0) (h.chop e.pred) using 1
   ext w a; split
   · next hz=> simp [show m w a=0 from hz]
   next hz=> simp [Nat.sub_add_cancel (show 1 ≤ m w a by omega)]
lemma pickK {f:PT α Z4}(h:Kn f) {m:PT α ℕ}(e:Kn m):
    Kn (fun w a=> vmap (fun i:Fin 11=>i.val) (guess (m w a ) (f w a))):=by
    have hp {s:PT α ℤ}(hs: Kn s):Kn (fun w a=>(chooseOne (m w a) (s w a)).val) :=
        (Kn.fix 10).small (((Kn.fix 5).plusZ ((dropK hs e).negZ)).topNat)
    exact ((hp h.left.left).tuple (hp h.left.right)).tuple
          ((hp h.right.left).tuple (hp h.right.right))
lemma fetchK0 {p k z:PT α ℕ}{f:PT α Stamp}(h:Kn f ) (g:Gen ) (hp:Kn p ) (hk:Kn k ) (hz:Kn z):
    Kn (fun x a=>vmap (fun i:Fin 11=>i.val)
                       (fetch (p x a ) (k x a) (z x a) g (f x a))):=by
   have he:= asideK hp hk
   let u (x a):=mix (p x a ) (z x a) ((f x a).2) ((f x a).1)
   have ht:Kn u:= mixK hp hz h.right h.left
   have hv := quads ht _ (Kn.next.mod (he.comp Kn.first))
   exact pickK (polK (zdK hv) true g) he
lemma fetchK {p k z:PT α ℕ}{f:PT α Stamp}(h:Kn f ) (g:Gen ) (hp:Kn p ) (hk:Kn k ) (hz:Kn z ) (v):
    Kn (fun x a=>decide (fetch (p x a ) (k x a ) (z x a) g (f x a)=v)):=by
   let glyph (v:W):=enc (vmap (fun i:Fin 11=>i.val) v)
   have he : Function.Injective glyph:=by
     intro a b hx
     have hp:=congrArg (fun n=>(dec n:Page)) hx; unfold glyph at hp
     simp [vmap,Prod.ext_iff] at *
     exact ⟨⟨Fin.ext hp.1.1,Fin.ext hp.1.2⟩,Fin.ext hp.2.1,Fin.ext hp.2.2⟩
   let s x a:=fetch (p x a ) (k x a ) (z x a) g (f x a)
   convert (Kn.wash.comp (fetchK0 h g hp hk hz)).eq (Kn.fix (glyph v)) using 1
   ext x a
   change decide (s x a=v)=decide (glyph (s x a)=glyph v)
   simp [he.eq_iff]

end
end Print
end ExactDerandomization.Grain

end

section

set_option synthInstance.maxSize 4096
namespace ExactDerandomization.Grain
open Relay Counter Rill Analysis Square Affine Env Wrap Finset
namespace Print
noncomputable section
abbrev Token:= Atom×Roller

def checkS (v:Token)(n k _ x:ℕ)(s:Issue):Bool :=
   if v.1.1 then match v.1.2 with
     | .inl i=> decide (fetch n k x i s.1=v.2)
     | .inr (.inl _)=>true
     | _=> decide (v.2=0)
   else decide (v.2=0)
def checkD (v:Token)(n _ j x:ℕ)(s:Issue):Bool :=
   if v.1.1 then match v.1.2 with
     | .inr (.inl i)=> decide (fetch n j x i s.2.1=v.2)
     | _=>true
   else true
def arch (v:Token)(n k j:ℕ)(s:Issue):Issue:=
   if v.1.1 then match v.1.2 with
     | .inl i=> (walkstep n i k v.2 s.1,s.2)
     | .inr (.inl i)=> (s.1,walkstep n i j v.2 s.2.1,s.2.2)
     | .inr (.inr (.inl i))=> (s.1,s.2.1,bare n i s.2.2)
     | _=>s
   else s
abbrev Bundle:=(ℕ×ℕ×ℕ)×ℕ×Issue
def tossR (b:Bool)(v:Token)(_ :Word)(a:Bundle):Bool×Issue:=
    let (n,k,j):=a.1
    let (x,s):=a.2
    (if b then checkS v n k j x s else checkD v n k j x s, arch v n k j s)

variable {n:ℕ} [Fact n.Prime]
lemma rose (v:Token)(k j)(s:Env n 0):arch v n k j (issued s)=
                   issued (rol k j (d:=0) (w:=0) le_rfl v.1 v.2 s):=by
    rcases v with ⟨⟨b,i|i|i|i⟩,v⟩ <;> cases b <;>
     rcases s with ⟨s,t,u,w⟩ <;> simp [issued,arch,rol,rollG,unionG,zoom,recast]

lemma landlord (v:Token)(k j x y:ℕ)(s:Env n 0):
    v.2=winner k j (↑x:ZMod n) (↑y:ZMod n) v.1 s ↔
          checkS v n k j x (issued s)=true ∧ checkD v n k j y (issued s)=true :=by
   rcases s with ⟨s,t,u,w⟩; rcases v with ⟨⟨b,i|i|i|i⟩,v⟩ <;>
     cases b <;> simp [issued,winner,checkS,checkD,fetching,eq_comm]

lemma S_K(v:Token):
   Kn (fun (_:Word)(a:Bundle)=>checkS v a.1.1 a.1.2.1 a.1.2.2 a.2.1 a.2.2):=by
    rcases v with ⟨⟨b,i|i|i|i⟩,v⟩ <;> cases b
    all_goals first| exact Kn.fix _ |
        exact fetchK Kn.next.right.left i Kn.first.left Kn.first.right.left Kn.next.left v
lemma D_K(v:Token):
   Kn (fun (_:Word)(a:Bundle)=>checkD v a.1.1 a.1.2.1 a.1.2.2 a.2.1 a.2.2):=by
    rcases v with ⟨⟨b,i|i|i|i⟩,v⟩ <;> cases b <;> first| exact Kn.fix _ |
       exact fetchK Kn.next.right.right.left i Kn.first.left Kn.first.right.right Kn.next.left v

lemma A_K(v:Token):
   Kn (fun (_:Word)(a:Bundle)=> arch v a.1.1 a.1.2.1 a.1.2.2 a.2.2):=by
   have hz:Kn (fun (_:Word)(a:Bundle)=>a.2.2):=Kn.next.right
   rcases v with ⟨⟨b,i|i|i|i⟩,v⟩ <;> cases b
   · exact hz
   · exact (zoomK hz.left i Kn.first.left Kn.first.right.left v).tuple hz.right
   · exact hz
   · exact hz.left.tuple
                     ((zoomK hz.right.left i Kn.first.left Kn.first.right.right v).tuple hz.right.right)
   · exact hz
   · exact hz.left.tuple (hz.right.left.tuple (bareK hz.right.right i Kn.first.left))
   · exact hz
   · exact hz
lemma tossed(b:Bool)(v) : Kn (tossR b v):= by
   cases b
   · exact Kn.tuple (D_K v) (A_K v)
   · exact Kn.tuple (S_K v) (A_K v)

abbrev rad:=Fintype.card Token
lemma rad_pos:0<rad:= Fintype.card_pos
def number : Fin rad≃Token := (Fintype.equivFin Token).symm
def mark (i:ℕ):Token:=number ⟨i%rad,Nat.mod_lt _ rad_pos⟩

lemma mintK {α β} [Wire α][Wire β](f:Token→ PT α β) (h:∀ v,Kn (f v))
   (k:PT α ℕ)(hp:Kn k):Kn (fun x a=> f (mark (k x a)) x a):= by
  let u(v:Fin rad):= v.val
  let m:Fin rad := ⟨0,rad_pos⟩
  classical
  have he (s: ℕ):
    Kn (fun x a=> let n:= (k x a)%rad
                  if n < s then f (mark n) x a else f (mark 0) x a):=by
     induction s with
     | zero=> simpa using h (mark 0)
     | succ s ih =>
       convert ((hp.mod (Kn.fix rad)).cond_eq (Kn.fix s) (h (mark s)) ih) using 1
       ext x a
       dsimp only
       generalize k x a % rad=n
       by_cases he:n=s
       · subst s
         rw [ite_eq_left (by omega),ite_eq_left rfl]
       rw [ite_eq_right he]
       by_cases ht:n<s
       · rw [ite_eq_left (by omega),ite_eq_left ht]
       rw [ite_eq_right (by omega),ite_eq_right ht]
  have ht (v):v%rad<rad:=Nat.mod_lt v rad_pos
  convert he rad using 1
  ext x a
  dsimp only
  rw [ite_eq_left (ht _)]
  simp only [mark,Nat.mod_mod]

def queue : (l c:ℕ) → Paths Atom l×Paths Roller l
   | 0,_=>((),())
   | l+1,c=>
     let u:=mark c
     let v:=queue l (c/rad)
     ((u.1,v.1),(u.2,v.2))

lemma width (r:ℕ)(_:0< r)(n:ℕ)(f:ℕ→ℝ):
   ∑ i∈range (r*n),f i = ∑ i∈range r, ∑ j∈range n,f (i+j*r):=by
   induction n with
   | zero=> simp
   | succ n ih=>
     conv_rhs => arg 2; ext; rw [sum_range_succ]
     rw [mul_add,mul_one, sum_add_distrib,← ih]
     have ht := sum_range_add f (r*n) r
     rw [ht]; simp [Nat.add_comm,mul_comm]

lemma emblem (v:Token→ℝ):
    ∑ i ∈ range rad, v (mark i)= ∑ i:Token,v i:=by
   rw [← Fin.sum_univ_eq_sum_range (fun i => v (mark i))]
   exact Fintype.sum_equiv number _ _ (fun i=>by
       have hp: mark (i:Fin rad).val=number i := congrArg number (Fin.ext (Nat.mod_eq_of_lt i.isLt))
       simp only [hp])

lemma touring (l:ℕ)(f:Paths Atom l → Paths Roller l → ℝ):
    ∑ i ∈ range (rad^l), f (queue l i).1 (queue l i).2 =∑ p,∑ g,f p g:=by
    induction l with
    | zero=> simp [queue]
    | succ l ih=>
      rw [pow_succ',width rad rad_pos]
      let v (s:Token):= ∑ a,∑ b, f (s.1,a) (s.2,b)
      have he (i) (hi:i<rad): ∑ j∈range (rad^l),f (queue _ (i+j*rad)).1 (queue _ (i+j*rad)).2=v (mark i):=by
          convert ih (fun a b=> f ((mark i).1,a) ((mark i).2,b)) using 1
          apply sum_congr rfl; intro j hj
          simp only [queue,Nat.add_mul_div_right _ _ rad_pos,Nat.div_eq_of_lt hi,zero_add,
                  mark,Nat.add_mul_mod_self_right]
      have hx:= sum_congr rfl (fun i (e:i∈range rad)=>he i (mem_range.1 e))
      rw [hx,emblem]
      rw [Fintype.sum_prod_type]; rw [pathFold Atom l]
      apply sum_congr rfl; intro a _
      simp_rw [pathFold Roller l]
      unfold v; rw [sum_comm]
end
end Print
end ExactDerandomization.Grain

end

section

set_option synthInstance.maxSize 4096
namespace ExactDerandomization.Grain
open Relay Counter Rill Analysis Square Affine Env Wrap Finset
namespace Print
noncomputable section

abbrev Guide:= (ℕ×ℕ×ℕ)×ℕ
abbrev MapState:=ℕ×Bool×Issue

def goon (b:Bool ) (x:Word ) (a:Guide × MapState):MapState :=
   let t:= tossR b (mark a.2.1) x (a.1.1,a.1.2,a.2.2.2)
   (a.2.1/rad, a.2.2.1 && t.1, t.2)

lemma goonK (b):Kn (goon b):=by
   let f (v:Token ) (x:Word ) (a:Guide×MapState):=
       tossR b v x (a.1.1,a.1.2,a.2.2.2)
   have hp(v):Kn (f v):= (tossed b v).comp (Kn.first.left.tuple
                                       (Kn.first.right.tuple Kn.next.right.right))
   have he:=mintK f hp _ Kn.next.left
   exact (Kn.next.left.div (Kn.fix rad)).tuple ((both Kn.next.right.left he.left).tuple he.right)

abbrev Lap:=Guide × MapState × ℕ
def capz (a:Lap) :ℕ:=
   bead a.2.1.1 (bead 1 (pages a.1.1.1))
lemma capzK:Kn (fun (_:Word ) (a:Lap)=>capz a):=by
   have h1:= (Kn.first (α:=Guide ) (β:=MapState×ℕ)).left.left
   have he:= pagesK h1
   have hz:= Kn.wash.comp ((Kn.fix (1:ℕ)).tuple he)
   exact Kn.wash.comp (Kn.next.left.left.tuple hz)
def spin (b:Bool ) (x:Word ) (a:Lap):MapState:=
   let L:=capz a
   dec (forNat (fun _ (v:ℕ)=> min L (enc (goon b x (a.1,dec v))))
        (min L (enc a.2.1)) a.2.2)

lemma spinK (b):Kn (spin b):=by
   let f:PT (Lap×ℕ×ℕ) ℕ:=fun x a=>min (capz a.1) (enc (goon b x (a.1.1,dec a.2.2)))
   have ht := Kn.stroll f _ _ _ ((capzK.comp Kn.first).small
       (Kn.wash.comp ((goonK b).comp (Kn.first.left.tuple (Kn.unpack.comp Kn.next.right)))))
          (Kn.next (α:=Guide ) (β:=MapState×ℕ)).right
          (capzK.small (Kn.wash.comp Kn.next.left)) capzK (by
             intro x a j _
             cases j <;> exact min_le_left _ _)
   exact Kn.unpack.comp ht

variable {n:ℕ}[Fact n.Prime]
lemma limits {v c k j x m H} (h:v≤c) (s:Env n 0 ) (b r:Bool) :
   enc ((v,b,issued s):MapState)≤ capz (((n,k,j),x),(c,r,m),H) :=
   bead_mono h (bead_mono (show enc b≤1 by cases b <;> decide) (boxbound s).le)

def scoreQ (b:Bool ) (k j x:ℕ) :
       {l:ℕ}→Paths Atom l → Paths Roller l→ Env n 0→ Bool
   | 0,_,_,_=>true
   | _+1,(t,a),(v,w),s=>
      (if b then checkS (t,v) n k j x (issued s) else checkD (t,v) n k j x (issued s)) &&
                   scoreQ b k j x a w (rol k j (d:=0 ) (w:=0) le_rfl t v s)

lemma wellQ (k j x y:ℕ){l:ℕ}(a:Paths Atom l ) (b:Paths Roller l ) (s:Env n 0):
   live k j (↑x:ZMod n) (↑y:ZMod n) (d:=0 ) (w:=0) le_rfl a b s=true ↔
       scoreQ true k j x a b s=true ∧ scoreQ false k j y a b s=true:=by
   induction l generalizing s with
   | zero=> simp [live,scoreQ]
   | succ l ih=>
     cases a with | mk t a=>
      cases b with | mk v b=>
       unfold live scoreQ
       let u:Token :=(t,v)
       have hx:= landlord u k j x y s
       dsimp only [u] at hx
       simp only [Bool.and_eq_true,ite_true,Bool.false_eq_true,ite_false]
       split
       · next hz=> have hp:=hx.1 hz; simp [hp,ih]
       next hz=> simp; grind

theorem flowed (b:Bool ) (k j i l c:ℕ ) (x:Word ) (s:Env n 0 ) (v:Bool) :
   spin b x (((n,k,j),i),(c,v,issued s),l) =
        let P:=queue l c
        (c/rad^l, v && scoreQ b k j i P.1 P.2 s,
                         issued (go k j (d:=0 ) (w:=0) le_rfl P.1 P.2 s)) :=by
    let q:Guide:=((n,k,j),i)
    let p:Lap:=(q,(c,v,issued s),l)
    let M:=capz p
    let f (z:ℕ):= min M (enc (goon b x (q,dec z)))
    have he(l':ℕ ) (c':ℕ ) (hv:c'≤c ) (v':Bool ) (s':Env n 0):
      forNat (fun _=> f) (enc ((c',v',issued s'):MapState)) l' =
        let P:=queue l' c'
        enc ((c'/rad^l',v'&&scoreQ b k j i P.1 P.2 s',
              issued (go k j (d:=0 ) (w:=0) le_rfl P.1 P.2 s')):MapState):=by
        induction l' generalizing c' v' s' with
        | zero=> simp [forNat,go,scoreQ]
        | succ l' ih=>
          let c0:=c'/rad
          have ht:c0≤c:=le_trans (Nat.div_le_self ..) hv
          let u:=mark c'
          let s0:=rol k j (d:=0 ) (w:=0) le_rfl u.1 u.2 s'
          let b0:=v' && (tossR b u x (q.1,q.2,issued s')).1
          have hh:f (enc ((c',v',issued s'):MapState))=enc ((c0,b0,issued s0):MapState):=by
               dsimp only [f]
               rw [dec_round]; unfold goon
               change min M (enc ((c0,b0,arch u n k j (issued s')):MapState))=_
               rw [rose]; exact min_eq_right (limits ht s0 b0 v)
          rw [forNat_cons,hh,ih c0 ht]
          simp only [c0,b0,q,s0,u, queue, tossR,scoreQ,go,Equiv.trans_apply,Nat.div_div_eq_div_mul,
                          pow_succ',Bool.and_assoc]
    unfold spin
    change dec (forNat _ (min M _) _)=_
    rw [min_eq_right (limits ..),he l c le_rfl]
    · dsimp only; simp only [Wire.eq]
    exact le_rfl

def stepout (n k j l a:ℕ ) (s:Issue):Issue:= (spin true [] (((n,k,j),0),(a,true,s),l)).2.2
def touched (b:Bool ) (n k j i l a:ℕ ) (s:Issue):Bool:=
                         (spin b [] (((n,k,j),i),(a,true,s),l)).2.1

lemma spin_null (b:Bool ) (x:Word ) (a:Lap):spin b x a=spin b [] a:=rfl

lemma stepK {α} [Wire α]{n k j l c :PT α ℕ}{s:PT α Issue}
   (hn:Kn n ) (hk:Kn k ) (hj:Kn j ) (hl:Kn l ) (hc:Kn c ) (hs:Kn s):
   Kn (fun x a=>stepout (n x a ) (k x a ) (j x a ) (l x a ) (c x a ) (s x a)) :=
   ((spinK true).comp (((hn.tuple (hk.tuple hj)).tuple (Kn.fix 0)).tuple
                                      ((hc.tuple ((Kn.fix _).tuple hs)).tuple hl))).right.right
lemma touchedK {α} [Wire α]{n k j i l c:PT α ℕ}{s:PT α Issue}
   (b ) (hn:Kn n ) (hk:Kn k ) (hj:Kn j ) (hi:Kn i ) (hl:Kn l ) (hc:Kn c ) (hs:Kn s):
   Kn (fun x a=> touched b (n x a ) (k x a ) (j x a ) (i x a ) (l x a ) (c x a ) (s x a)):=
   ((spinK b).comp (((hn.tuple (hk.tuple hj)).tuple hi).tuple
                                      ((hc.tuple ((Kn.fix _).tuple hs)).tuple hl))).right.left

lemma unpacked (k j l a ) (s:Env n 0):
   stepout n k j l a (issued s)=issued
                 (go k j (d:=0 ) (w:=0) le_rfl (queue l a).1 (queue l a).2 s):=by
   rw [stepout,flowed]
lemma exactHit (k j x y l a:ℕ ) (s:Env n 0):
   live k j (↑x:ZMod n) (↑y:ZMod n) (d:=0 ) (w:=0) le_rfl (queue l a).1 (queue l a).2 s=true ↔
     touched true n k j x l a (issued s)=true ∧ touched false n k j y l a (issued s)=true := by
   simp only [touched,flowed, Bool.true_and]; exact wellQ k j x y ..
end
end Print
end ExactDerandomization.Grain

end

end OAI