| import Mathlib |
| import OAI.Probability.Contingency.DenseWeightBounds |
|
|
| namespace OAI |
|
|
| /-! Stack Compiler. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators |
| namespace Contingency.BitModel.StackCode |
|
|
| inductive Op (labels work : ℕ) where |
| | push (i : Fin work) (b : Bool) (next : Fin labels) |
| | pop (i : Fin work) (empty zero one : Fin labels) |
| | read (empty zero one : Fin labels) |
| | coin (zero one : Fin labels) |
| | emit (b : Bool) (next : Fin labels) |
| | jump (next : Fin labels) |
| | halt |
|
|
| structure Program where |
| labels : ℕ |
| work : ℕ |
| start : Fin labels |
| code : Fin labels → Op labels work |
|
|
| |
|
|
| structure Memory (work : ℕ) where |
| input : List Bool |
| consumed : ℕ |
| stack : Fin work → List Bool |
| blanks : Fin work → ℕ |
| outputRev : List Bool |
|
|
| structure Config (P : Program) where |
| state : Option (Fin P.labels) |
| memory : Memory P.work |
|
|
| def branch {n : ℕ} (empty zero one : Fin n) : Option Bool → Fin n |
| | none => empty |
| | some false => zero |
| | some true => one |
|
|
| def stackTape (xs : List Bool) (r : ℕ) : Tape := |
| ⟨xs.map some,none,List.replicate r none⟩ |
|
|
| def inputTape : List Bool → ℕ → Tape |
| | [],p => ⟨List.replicate p none,none,[]⟩ |
| | b::xs,p => ⟨List.replicate p none,some b,xs.map some⟩ |
|
|
| @[simp] theorem tape_keep (t : Tape) : t.move .stay t.head=t := by cases t; rfl |
|
|
| theorem stack_push (xs : List Bool) (r : ℕ) (b : Bool) : |
| (stackTape xs r).move .right (some b)=stackTape (b::xs) (r-1) := by |
| cases r <;> simp [stackTape,Tape.move,List.replicate_succ] |
|
|
| theorem stack_pop_empty (r : ℕ) : |
| ((stackTape [] r).move .left none).move .stay none=stackTape [] (r+1) := by |
| simp [stackTape,Tape.move,List.replicate_succ] |
|
|
| theorem stack_pop_cons (b : Bool) (xs : List Bool) (r : ℕ) : |
| ((stackTape (b::xs) r).move .left none).move .stay none=stackTape xs (r+1) := by |
| simp [stackTape,Tape.move,List.replicate_succ] |
|
|
| theorem stack_pop_head (xs : List Bool) (r : ℕ) : |
| ((stackTape xs r).move .left none).head=xs.head? := by cases xs <;> rfl |
|
|
| theorem input_read (xs : List Bool) (p : ℕ) : |
| (inputTape xs p).move .right none=inputTape xs.tail (p+1) := by |
| cases xs with |
| | nil => simp [inputTape,Tape.move,List.replicate_succ] |
| | cons b xs => cases xs <;> simp [inputTape,Tape.move,List.replicate_succ] |
|
|
| @[simp] theorem inputTape_head (xs : List Bool) (p : ℕ) : |
| (inputTape xs p).head=xs.head? := by cases xs <;> rfl |
|
|
| def Memory.tapes {w : ℕ} (m : Memory w) : Fin (w+1) → Tape := |
| Fin.lastCases (inputTape m.input m.consumed) (fun i => stackTape (m.stack i) (m.blanks i)) |
|
|
| @[simp] theorem tapes_work {w : ℕ} (m : Memory w) (i : Fin w) : |
| m.tapes i.castSucc=stackTape (m.stack i) (m.blanks i) := by simp [Memory.tapes] |
|
|
| @[simp] theorem tapes_input {w : ℕ} (m : Memory w) : |
| m.tapes (Fin.last w)=inputTape m.input m.consumed := by simp [Memory.tapes] |
|
|
| def Memory.push {w : ℕ} (m : Memory w) (i : Fin w) (b : Bool) : Memory w := |
| {m with stack := Function.update m.stack i (b::m.stack i) |
| blanks := Function.update m.blanks i (m.blanks i-1)} |
|
|
| def Memory.pop {w : ℕ} (m : Memory w) (i : Fin w) : Memory w := |
| {m with stack := Function.update m.stack i (m.stack i).tail |
| blanks := Function.update m.blanks i (m.blanks i+1)} |
|
|
| def Memory.read {w : ℕ} (m : Memory w) : Memory w := |
| {m with input := m.input.tail,consumed := m.consumed+1} |
|
|
| def effect {l w : ℕ} (op : Op l w) (coin : Bool) (m : Memory w) : Option (Fin l) × Memory w := |
| match op with |
| | .push i b next => (some next,m.push i b) |
| | .pop i e z o => (some (branch e z o (m.stack i).head?),m.pop i) |
| | .read e z o => (some (branch e z o m.input.head?),m.read) |
| | .coin z o => (some (if coin then o else z),m) |
| | .emit b next => (some next,{m with outputRev := b::m.outputRev}) |
| | .jump next => (some next,m) |
| | .halt => (none,m) |
|
|
| def step (P : Program) (coin : Bool) (c : Config P) : Config P := |
| match c.state with |
| | none => c |
| | some pc => let e := effect (P.code pc) coin c.memory; ⟨e.1,e.2⟩ |
|
|
| def first {l : ℕ} (pc : Fin l) : Fin (l*2) := finProdFinEquiv (pc,0) |
| def second {l : ℕ} (pc : Fin l) : Fin (l*2) := finProdFinEquiv (pc,1) |
|
|
| def preserved {l t : ℕ} (next : Option (Fin l)) (heads : Fin t → Option Bool) |
| (emit : Option Bool := none) : Instruction l t := |
| ⟨next,heads,fun _ => .stay,emit⟩ |
|
|
| def active {l t : ℕ} (next : Option (Fin l)) (heads : Fin t → Option Bool) |
| (i : Fin t) (write : Option Bool) (move : Move) : Instruction l t := |
| ⟨next,Function.update heads i write,Function.update (fun _ => .stay) i move,none⟩ |
|
|
| def prepare (P : Program) (pc : Fin P.labels) (heads : Fin (P.work+1) → Option Bool) : |
| Instruction (P.labels*2) (P.work+1) := |
| match P.code pc with |
| | .pop i _ _ _ => active (some (second pc)) heads i.castSucc (heads i.castSucc) .left |
| | _ => preserved (some (second pc)) heads |
|
|
| def execute (P : Program) (pc : Fin P.labels) (coin : Bool) |
| (heads : Fin (P.work+1) → Option Bool) : Instruction (P.labels*2) (P.work+1) := |
| match P.code pc with |
| | .push i b next => active (some (first next)) heads i.castSucc (some b) .right |
| | .pop i e z o => active (some (first (branch e z o (heads i.castSucc)))) heads i.castSucc none .stay |
| | .read e z o => active (some (first (branch e z o (heads (Fin.last P.work))))) heads (Fin.last P.work) none .right |
| | .coin z o => preserved (some (first (if coin then o else z))) heads |
| | .emit b next => preserved (some (first next)) heads (some b) |
| | .jump next => preserved (some (first next)) heads |
| | .halt => preserved none heads |
|
|
| |
|
|
| def compile (P : Program) : Machine where |
| states := P.labels*2 |
| tapes := P.work+1 |
| start := first P.start |
| inputTape := Fin.last P.work |
| transition s coin heads := |
| let cp := finProdFinEquiv.symm s |
| if cp.2=0 then prepare P cp.1 heads else execute P cp.1 coin heads |
|
|
| def encode (P : Program) (c : Config P) : BitModel.Config (compile P) := |
| ⟨c.state.map first,c.memory.tapes,c.memory.outputRev⟩ |
|
|
| @[simp] theorem compile_first (P : Program) (pc : Fin P.labels) (coin : Bool) (heads) : |
| (compile P).transition (first pc) coin heads=prepare P pc heads := by |
| simp [compile,first] |
|
|
| @[simp] theorem compile_second (P : Program) (pc : Fin P.labels) (coin : Bool) (heads) : |
| (compile P).transition (second pc) coin heads=execute P pc coin heads := by |
| simp [compile,second] |
|
|
| theorem move_preserved {t : ℕ} (ts : Fin t → Tape) : |
| (fun i => (ts i).move .stay (ts i).head)=ts := by funext i; exact tape_keep _ |
|
|
| theorem move_active {t : ℕ} (ts : Fin t → Tape) (i : Fin t) (a : Option Bool) (d : Move) : |
| (fun j => (ts j).move (Function.update (fun _ => Move.stay) i d j) |
| (Function.update (fun k => (ts k).head) i a j)) = |
| Function.update ts i ((ts i).move d a) := by |
| funext j |
| by_cases h : j=i <;> simp [h] |
|
|
| theorem tapes_push {w : ℕ} (m : Memory w) (i : Fin w) (b : Bool) : |
| (m.push i b).tapes=Function.update m.tapes i.castSucc |
| ((m.tapes i.castSucc).move .right (some b)) := by |
| funext j |
| refine Fin.lastCases ?_ (fun k => ?_) j |
| · simp [Memory.tapes,Memory.push,Function.update_apply, ne_of_gt (Fin.castSucc_lt_last i)] |
| · by_cases h : k=i |
| · subst k; simp [Memory.push,stack_push] |
| · simp [Memory.push,h] |
|
|
| theorem tapes_pop {w : ℕ} (m : Memory w) (i : Fin w) : |
| (m.pop i).tapes=Function.update m.tapes i.castSucc |
| (((m.tapes i.castSucc).move .left none).move .stay none) := by |
| funext j |
| refine Fin.lastCases ?_ (fun k => ?_) j |
| · simp [Memory.tapes,Memory.pop,Function.update_apply, ne_of_gt (Fin.castSucc_lt_last i)] |
| · by_cases h : k=i |
| · subst k |
| simp only [tapes_work,Memory.pop,Function.update_self] |
| cases m.stack i <;> simp [stack_pop_empty,stack_pop_cons] |
| · simp [Memory.pop,h] |
|
|
| theorem tapes_read {w : ℕ} (m : Memory w) : |
| m.read.tapes=Function.update m.tapes (Fin.last w) |
| ((m.tapes (Fin.last w)).move .right none) := by |
| funext j |
| refine Fin.lastCases ?_ (fun k => ?_) j |
| · simp [Memory.read,input_read] |
| · simp [Memory.read] |
|
|
| |
| theorem two_steps (P : Program) (noise coin : Bool) (c : Config P) : |
| (compile P).step coin ((compile P).step noise (encode P c)) = |
| encode P (step P coin c) := by |
| rcases c with ⟨state,m⟩ |
| cases state with |
| | none => rfl |
| | some pc => |
| change (compile P).step coin ((compile P).step noise |
| ⟨some (first pc),m.tapes,m.outputRev⟩) = |
| encode P ⟨(effect (P.code pc) coin m).1,(effect (P.code pc) coin m).2⟩ |
| cases h : P.code pc <;> |
| simp [Machine.step,compile_first,prepare,h,active,preserved, |
| compile_second,execute,encode,effect,Option.map] <;> try rfl |
| case push i b next => |
| congr 1 |
| exact (move_active m.tapes i.castSucc (some b) .right).trans (tapes_push m i b).symm |
| case read e z o => |
| congr 1 |
| exact (move_active m.tapes (Fin.last P.work) none .right).trans (tapes_read m).symm |
| case pop i e z o => |
| congr 1 |
| · dsimp only [compile] at * |
| simp only [Function.update_self] |
| change some (first (branch e z o ((stackTape (m.stack i) (m.blanks i)).move .left none).head))=_ |
| rw [stack_pop_head] |
| · dsimp only [compile] at * |
| funext j |
| refine Fin.lastCases ?_ (fun k => ?_) j |
| · have hi : Fin.last P.work ≠ i.castSucc := ne_of_gt (Fin.castSucc_lt_last i) |
| simp [Function.update_apply,hi,Memory.pop] |
| simpa using tape_keep (inputTape m.input m.consumed) |
| · by_cases hk : k=i |
| · subst k |
| simp only [Function.update_self,tapes_work,Memory.pop] |
| change ((stackTape (m.stack i) (m.blanks i)).move .left none).move .stay none=_ |
| cases hxs : m.stack i <;> |
| simp [stack_pop_empty,stack_pop_cons] |
| · simp [Function.update_apply,hk,Memory.pop] |
|
|
| end Contingency.BitModel.StackCode |
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.BitModel.StackCode |
|
|
| def initial (P : Program) (xs : List Bool) : Config P := |
| ⟨some P.start,⟨xs,0,fun _ => [],fun _ => 0,[]⟩⟩ |
|
|
| def run (P : Program) (xs : List Bool) {t : ℕ} (coins : Fin t → Bool) : Config P := |
| (List.ofFn coins).foldl (fun c b => step P b c) (initial P xs) |
|
|
| theorem initial_eq (P : Program) (xs : List Bool) : |
| encode P (initial P xs)=(compile P).initial xs := by |
| unfold encode initial Machine.initial compile |
| congr 1 |
| funext j |
| refine Fin.lastCases ?_ (fun i => ?_) j |
| · simp only [tapes_input,ite_true] |
| cases xs <;> rfl |
| · simp only [tapes_work,Fin.castSucc_ne_last,ite_false] |
| rfl |
|
|
| theorem fold_pairs (P : Program) (ps : List (Bool×Bool)) (c : Config P) : |
| (ps.flatMap fun p => [p.1,p.2]).foldl (fun c b => (compile P).step b c) (encode P c) = |
| encode P (ps.foldl (fun c p => step P p.2 c) c) := by |
| induction ps generalizing c with |
| | nil => rfl |
| | cons p ps ih => |
| simp only [List.flatMap_cons,List.foldl_append,List.foldl_cons,List.foldl_nil] |
| rw [two_steps,ih] |
|
|
| theorem coins_as_pairs {t : ℕ} (coins : Fin (t*2) → Bool) : |
| List.ofFn coins=(List.ofFn fun i : Fin t => (coins (first i),coins (second i))).flatMap |
| (fun p => [p.1,p.2]) := by |
| rw [List.ofFn_mul,List.flatMap_def,List.map_ofFn] |
| congr 1 |
| apply congrArg List.ofFn |
| funext i |
| simp [List.ofFn_succ,first,second,finProdFinEquiv,Nat.mul_comm,Nat.add_comm] |
|
|
| |
| theorem run_eq (P : Program) (xs : List Bool) {t : ℕ} (coins : Fin (t*2) → Bool) : |
| (compile P).run xs coins=encode P (run P xs (fun i => coins (second i))) := by |
| unfold Machine.run |
| rw [← initial_eq,coins_as_pairs,fold_pairs] |
| unfold run |
| congr 1 |
| have hh := List.foldl_map (f:=Prod.snd) (g:=fun c b => step P b c) |
| (l:=List.ofFn fun i : Fin t => (coins (first i),coins (second i))) (init:=initial P xs) |
| simpa only [List.map_ofFn,Function.comp_def] using hh.symm |
|
|
| def coinPairs (t : ℕ) : (Fin (t*2) → Bool) ≃ (Fin t → Bool)×(Fin t → Bool) where |
| toFun f := (fun i => f (first i),fun i => f (second i)) |
| invFun p j := let q := finProdFinEquiv.symm j |
| if q.2=0 then p.1 q.1 else p.2 q.1 |
| left_inv f := by |
| funext j |
| obtain ⟨⟨i,k⟩,rfl⟩ := finProdFinEquiv.surjective j |
| fin_cases k <;> simp [first,second] |
| right_inv p := by |
| rcases p with ⟨a,b⟩ |
| apply Prod.ext <;> funext i <;> simp [first,second] |
|
|
| |
| theorem count_second (t : ℕ) (p : (Fin t → Bool) → Prop) [DecidablePred p] : |
| (Finset.univ.filter fun c : Fin (t*2) → Bool => p (fun i => c (second i))).card = |
| 2^t*(Finset.univ.filter p).card := by |
| classical |
| simp only [Finset.card_filter] |
| change (∑ c,if p ((coinPairs t c).2) then 1 else 0)=_ |
| rw [(coinPairs t).sum_comp (fun ab => if p ab.2 then (1:ℕ) else 0),Fintype.sum_prod_type] |
| simp |
|
|
| noncomputable def mass (P : Program) (xs out : List Bool) (t : ℕ) : ℝ := |
| ((Finset.univ.filter fun coins : Fin t → Bool => (run P xs coins).state=none ∧ |
| (run P xs coins).memory.outputRev.reverse=out).card:ℝ)/2^t |
|
|
| noncomputable def tail (P : Program) (xs : List Bool) (t : ℕ) : ℝ := |
| ((Finset.univ.filter fun coins : Fin t → Bool => (run P xs coins).state≠none).card:ℝ)/2^t |
|
|
| @[simp] theorem encode_halt (P : Program) (c : Config P) : |
| (encode P c).state=none ↔ c.state=none := by cases h : c.state <;> simp [encode,h,Option.map] |
|
|
| @[simp] theorem encode_output (P : Program) (c : Config P) : |
| (encode P c).outputRev=c.memory.outputRev := rfl |
|
|
| theorem mass_compile (P : Program) (xs out : List Bool) (t : ℕ) : |
| (compile P).mass xs out (t*2)=mass P xs out t := by |
| classical |
| unfold Machine.mass |
| simp only [run_eq,encode_halt,encode_output] |
| rw [count_second t (fun c => (run P xs c).state=none ∧ |
| (run P xs c).memory.outputRev.reverse=out)] |
| unfold mass |
| push_cast |
| rw [pow_mul,pow_two] |
| field_simp |
|
|
| theorem tail_compile (P : Program) (xs : List Bool) (t : ℕ) : |
| (compile P).tail xs (t*2)=tail P xs t := by |
| classical |
| unfold Machine.tail |
| simp only [run_eq,ne_eq,encode_halt] |
| rw [count_second t (fun c => (run P xs c).state≠none)] |
| unfold tail |
| push_cast |
| rw [pow_mul,pow_two] |
| field_simp |
|
|
| end Contingency.BitModel.StackCode |
|
|
| |
|
|
| |
|
|
| |
|
|
| namespace Contingency.BitModel.StackCode.BinaryTrial |
| noncomputable section |
|
|
| inductive Cmp | lt | eq | gt |
| deriving DecidableEq |
|
|
| instance : Fintype Cmp where |
| elems := {.lt,.eq,.gt} |
| complete := by intro s; cases s <;> simp |
|
|
| def advance (s : Cmp) (bound coin : Bool) : Cmp := |
| match s with |
| | .lt => .lt |
| | .gt => .gt |
| | .eq => if coin=bound then .eq else if coin then .gt else .lt |
|
|
| def accept : Cmp → Bool |
| | .lt | .eq => true |
| | .gt => false |
|
|
| inductive Q |
| | start (s : Cmp) |
| | save (s : Cmp) (bound : Bool) |
| | choose (s : Cmp) (bound : Bool) |
| | place (s : Cmp) (bound coin : Bool) |
| | finish (s : Cmp) |
| | halt |
| deriving DecidableEq, Fintype |
|
|
| def label (q : Q) : Fin (Fintype.card Q) := Fintype.equivFin Q q |
|
|
| def code : Q → Op (Fintype.card Q) 4 |
| | .start s => .pop 0 (label (.finish s)) (label (.save s false)) (label (.save s true)) |
| | .save s v => .push 2 v (label (.choose s v)) |
| | .choose s v => .coin (label (.place s v false)) (label (.place s v true)) |
| | .place s v b => .push 1 b (label (.start (advance s v b))) |
| | .finish s => .push 3 (accept s) (label .halt) |
| | .halt => .halt |
|
|
| def program : Program := |
| ⟨Fintype.card Q,4,label (.start .eq),fun pc => code ((Fintype.equivFin Q).symm pc)⟩ |
|
|
| def config (q : Q) (m : Memory 4) : Config program := ⟨some (label q),m⟩ |
|
|
| @[simp] theorem program_code (q : Q) : program.code (label q)=code q := by |
| simp [program,label] |
|
|
| |
| theorem one_step (q : Q) (m : Memory 4) (coin : Bool) : |
| step program coin (config q m)= |
| ⟨(effect (code q) coin m).1,(effect (code q) coin m).2⟩ := by |
| simp [step,config,program,label] |
|
|
| def digitMemory (m : Memory 4) (v b : Bool) : Memory 4 := ((m.pop 0).push 2 v).push 1 b |
|
|
| @[simp] theorem digit_stack0 (m : Memory 4) (v b : Bool) : |
| (digitMemory m v b).stack 0=(m.stack 0).tail := by simp [digitMemory,Memory.pop,Memory.push] |
| @[simp] theorem digit_stack1 (m : Memory 4) (v b : Bool) : |
| (digitMemory m v b).stack 1=b::m.stack 1 := by simp [digitMemory,Memory.pop,Memory.push] |
| @[simp] theorem digit_stack2 (m : Memory 4) (v b : Bool) : |
| (digitMemory m v b).stack 2=v::m.stack 2 := by simp [digitMemory,Memory.pop,Memory.push] |
| @[simp] theorem digit_stack3 (m : Memory 4) (v b : Bool) : |
| (digitMemory m v b).stack 3=m.stack 3 := by simp [digitMemory,Memory.pop,Memory.push] |
|
|
| theorem four_steps (s : Cmp) (m : Memory 4) (v b n₀ n₁ n₃ : Bool) (rest : List Bool) |
| (hm : m.stack 0=v::rest) : |
| [n₀,n₁,b,n₃].foldl (fun c z => step program z c) (config (.start s) m)= |
| config (.start (advance s v b)) (digitMemory m v b) := by |
| cases v <;> cases b <;> |
| simp [List.foldl_cons,List.foldl_nil,code,effect,branch,hm,config,digitMemory, |
| step,program,label] |
|
|
| structure Digit where |
| bound : Bool |
| coin : Bool |
| noise₀ : Bool |
| noise₁ : Bool |
| noise₃ : Bool |
|
|
| def bits (d : Digit) : List Bool := [d.noise₀,d.noise₁,d.coin,d.noise₃] |
|
|
| def wordMemory (ds : List Digit) (m : Memory 4) : Memory 4 := |
| ds.foldl (fun m d => digitMemory m d.bound d.coin) m |
|
|
| def wordCmp (ds : List Digit) (s : Cmp) : Cmp := |
| ds.foldl (fun s d => advance s d.bound d.coin) s |
|
|
| theorem pass (ds : List Digit) (s : Cmp) (m : Memory 4) |
| (hm : m.stack 0=ds.map Digit.bound) : |
| (ds.flatMap bits).foldl (fun c b => step program b c) (config (.start s) m)= |
| config (.start (wordCmp ds s)) (wordMemory ds m) := by |
| induction ds generalizing s m with |
| | nil => rfl |
| | cons d ds ih => |
| simp only [List.flatMap_cons,List.foldl_append] |
| rw [show bits d=[d.noise₀,d.noise₁,d.coin,d.noise₃] from rfl] |
| rw [four_steps s m d.bound d.coin d.noise₀ d.noise₁ d.noise₃ _ hm] |
| rw [ih] |
| · rfl |
| · simp [hm] |
|
|
| theorem pass_stacks (ds : List Digit) (m : Memory 4) (hm : m.stack 0=ds.map Digit.bound) : |
| (wordMemory ds m).stack 0=[] ∧ |
| (wordMemory ds m).stack 1=(ds.map Digit.coin).reverse++m.stack 1 ∧ |
| (wordMemory ds m).stack 2=(ds.map Digit.bound).reverse++m.stack 2 ∧ |
| (wordMemory ds m).stack 3=m.stack 3 := by |
| induction ds generalizing m with |
| | nil => simp_all [wordMemory] |
| | cons d ds ih => |
| have htail : (digitMemory m d.bound d.coin).stack 0=ds.map Digit.bound := by simp [hm] |
| have hh := ih (digitMemory m d.bound d.coin) htail |
| simpa [wordMemory,List.reverse_cons,List.append_assoc] using hh |
|
|
| |
| theorem pass_length (ds : List Digit) : (ds.flatMap bits).length=4*ds.length := by |
| induction ds with |
| | nil => rfl |
| | cons d ds ih => simp [bits,ih]; omega |
|
|
| theorem finish (s : Cmp) (m : Memory 4) (hn : m.stack 0=[]) (b₀ b₁ b₂ : Bool) : |
| [b₀,b₁,b₂].foldl (fun c b => step program b c) (config (.start s) m)= |
| ⟨none,(m.pop 0).push 3 (accept s)⟩ := by |
| simp [List.foldl_cons,List.foldl_nil,step,program,label,config,code,effect,branch,hn] |
|
|
| end |
| end Contingency.BitModel.StackCode.BinaryTrial |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.BitModel.StackCode.BinaryTrial |
|
|
| def cmpNat (x y : ℕ) : Cmp := if x<y then .lt else if x=y then .eq else .gt |
|
|
| def beValue (xs : List Bool) : ℕ := xs.foldl (fun a b => 2*a+b.toNat) 0 |
|
|
| theorem advance_cmpNat (x y : ℕ) (v b : Bool) : |
| advance (cmpNat x y) v b=cmpNat (2*x+b.toNat) (2*y+v.toNat) := by |
| cases v <;> cases b <;> |
| unfold cmpNat <;> split_ifs <;> simp_all [advance] <;> omega |
|
|
| theorem cmp_fold (ds : List Digit) (x y : ℕ) : |
| wordCmp ds (cmpNat x y)= |
| cmpNat ((ds.map Digit.coin).foldl (fun n b => 2*n+b.toNat) x) |
| ((ds.map Digit.bound).foldl (fun n b => 2*n+b.toNat) y) := by |
| induction ds generalizing x y with |
| | nil => rfl |
| | cons d ds ih => |
| change wordCmp ds (advance (cmpNat x y) d.bound d.coin)=_ |
| rw [advance_cmpNat,ih] |
| rfl |
|
|
| theorem comparison_correct (ds : List Digit) : |
| accept (wordCmp ds .eq)=decide (beValue (ds.map Digit.coin)≤beValue (ds.map Digit.bound)) := by |
| have hh : wordCmp ds .eq=cmpNat (beValue (ds.map Digit.coin)) |
| (beValue (ds.map Digit.bound)) := cmp_fold ds 0 0 |
| rw [hh] |
| unfold cmpNat |
| split_ifs <;> simp_all [accept] <;> omega |
|
|
| def wordValue {n : ℕ} (bs : Fin n → Bool) : ℕ := beValue (List.ofFn bs) |
|
|
| theorem wordValue_succ {n : ℕ} (bs : Fin (n+1) → Bool) : |
| wordValue bs=2*wordValue (fun i : Fin n => bs i.castSucc)+(bs (Fin.last n)).toNat := by |
| unfold wordValue beValue |
| rw [List.ofFn_succ',List.concat_eq_append,List.foldl_append] |
| rfl |
| |
| theorem wordValue_lt {n : ℕ} (bs : Fin n → Bool) : wordValue bs<2^n := by |
| induction n with |
| | zero => simp [wordValue,beValue] |
| | succ n ih => |
| have hh := ih (fun i => bs i.castSucc) |
| rw [wordValue_succ,pow_succ] |
| cases hb : bs (Fin.last n) <;> simp only [Bool.toNat_false,Bool.toNat_true] <;> omega |
| |
| theorem wordValue_injective (n : ℕ) : Function.Injective (@wordValue n) := by |
| induction n with |
| | zero => intro f g _; funext i; exact Fin.elim0 i |
| | succ n ih => |
| intro f g h |
| rw [wordValue_succ,wordValue_succ] at h |
| have hb : f (Fin.last n)=g (Fin.last n) := by |
| cases hf : f (Fin.last n) <;> cases hg : g (Fin.last n) <;> try rfl |
| all_goals simp only [hf,hg,Bool.toNat_true,Bool.toNat_false] at h; omega |
| have hp : wordValue (fun i : Fin n => f i.castSucc)=wordValue (fun i : Fin n => g i.castSucc) := by |
| rw [hb] at h; omega |
| have hh := ih hp |
| funext i |
| exact Fin.lastCases hb (fun i => congrFun hh i) i |
| |
| def wordFin {n : ℕ} (bs : Fin n → Bool) : Fin (2^n) := ⟨wordValue bs,wordValue_lt bs⟩ |
| |
| theorem wordFin_bijective (n : ℕ) : Function.Bijective (@wordFin n) := by |
| apply (Fintype.bijective_iff_injective_and_card _).mpr |
| constructor |
| · intro f g h |
| exact wordValue_injective n (congrArg Fin.val h) |
| · simp |
| |
| noncomputable def wordEquiv (n : ℕ) : (Fin n → Bool) ≃ Fin (2^n) := |
| Equiv.ofBijective wordFin (wordFin_bijective n) |
| |
| |
| |
| theorem word_count (n : ℕ) (u : Fin (2^n)) : |
| (Finset.univ.filter fun bs : Fin n → Bool => wordFin bs=u).card=1 := by |
| classical |
| change (Finset.univ.filter fun bs => wordEquiv n bs=u).card=1 |
| have hh (bs) : wordEquiv n bs=u ↔ bs=(wordEquiv n).symm u := by |
| exact (Equiv.eq_symm_apply _).symm |
| have he : Finset.univ.filter (fun bs => wordEquiv n bs=u) = {(wordEquiv n).symm u} := by |
| ext bs |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_singleton,hh] |
| rw [he,Finset.card_singleton] |
| |
| end Contingency.BitModel.StackCode.BinaryTrial |
| |
| end |
| |
| end OAI |
| |
