| import OAI.Computability.BinPacking.CookLevin.ConfigIndex |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.MachineCircuit |
|
|
| open Turing StatementCircuit BoundedExecution |
| open scoped BigOperators |
|
|
| variable {K : Type} {Γ : K → Type} {Λ σ : Type} |
| variable [DecidableEq K] [Fintype Λ] [DecidableEq Λ] |
| variable [Fintype σ] [DecidableEq σ] |
| variable [∀ k, Fintype (Γ k)] [∀ k, DecidableEq (Γ k)] |
|
|
| private theorem bool_ext {a b : Bool} (h : a = true ↔ b = true) : a = b := by |
| cases a <;> cases b <;> simp_all |
|
|
| def StepSafe (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) (cfg : TM2.Cfg Γ Λ σ) : Prop := |
| ∀ label, cfg.l = some label → StatementSafe S (program label) cfg.var cfg.stk |
|
|
| noncomputable def liveCase (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) |
| (bit : ConfigBit Γ Λ σ S) (label : Λ) : Expr (ConfigBit Γ Λ σ S) := |
| .and (.input (.inl (some label))) |
| ((transitionExpr S (program label) bit).rename Sum.inr) |
|
|
| noncomputable def stickyExpr (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) |
| (bit : ConfigBit Γ Λ σ S) : Expr (ConfigBit Γ Λ σ S) := |
| .or (.and (.input (.inl none)) (.input bit)) |
| (Expr.disjoin (Finset.univ.toList.map (liveCase S program bit))) |
|
|
| omit [Fintype Λ] [DecidableEq Λ] [Fintype σ] [DecidableEq σ] |
| [∀ stack, Fintype (Γ stack)] [∀ stack, DecidableEq (Γ stack)] in |
| theorem absorbing_live (program : Λ → TM2.Stmt Γ Λ σ) (cfg : TM2.Cfg Γ Λ σ) |
| (label : Λ) (live : cfg.l = some label) : |
| absorbingNext (TM2.step program) cfg = TM2.stepAux (program label) cfg.var cfg.stk := by |
| cases cfg with |
| | mk l v tapes => |
| change l = some label at live |
| subst l |
| rfl |
|
|
| omit [Fintype Λ] [DecidableEq Λ] [Fintype σ] [DecidableEq σ] |
| [∀ stack, Fintype (Γ stack)] [∀ stack, DecidableEq (Γ stack)] in |
| theorem absorbing_halted (program : Λ → TM2.Stmt Γ Λ σ) (cfg : TM2.Cfg Γ Λ σ) |
| (halted : cfg.l = none) : absorbingNext (TM2.step program) cfg = cfg := by |
| apply absorbingNext_of_none |
| cases cfg with |
| | mk l v tapes => |
| change l = none at halted |
| subst l |
| rfl |
|
|
| omit [Fintype Λ] in |
| theorem liveCase_eval (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) |
| (cfg : TM2.Cfg Γ Λ σ) (safe : StepSafe S program cfg) |
| (bit : ConfigBit Γ Λ σ S) (label : Λ) : |
| (liveCase S program bit label).eval (configEncoding S cfg) = |
| (decide (cfg.l = some label) && |
| configEncoding S (absorbingNext (TM2.step program) cfg) bit) := by |
| by_cases live : cfg.l = some label |
| · simp only [liveCase, Expr.eval, Expr.eval_rename, configEncoding, live, |
| decide_true, Bool.true_and] |
| rw [transitionExpr_eval S (program label) cfg.var cfg.stk (safe label live), |
| absorbing_live program cfg label live] |
| rfl |
| · simp [liveCase, Expr.eval, configEncoding, live] |
|
|
| theorem stickyExpr_eval (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) |
| (cfg : TM2.Cfg Γ Λ σ) (safe : StepSafe S program cfg) |
| (bit : ConfigBit Γ Λ σ S) : |
| (stickyExpr S program bit).eval (configEncoding S cfg) = |
| configEncoding S (absorbingNext (TM2.step program) cfg) bit := by |
| have hactive : |
| (Expr.disjoin (Finset.univ.toList.map (liveCase S program bit))).eval |
| (configEncoding S cfg) = true ↔ |
| ∃ label, cfg.l = some label ∧ |
| configEncoding S (absorbingNext (TM2.step program) cfg) bit = true := by |
| rw [Expr.eval_disjoin_true] |
| simp only [List.mem_map] |
| constructor |
| · rintro ⟨e, ⟨label, _, rfl⟩, he⟩ |
| rw [liveCase_eval S program cfg safe] at he |
| exact ⟨label, by simpa only [Bool.and_eq_true, decide_eq_true_eq] using he⟩ |
| · rintro ⟨label, hl, hb⟩ |
| refine ⟨liveCase S program bit label, ?_, ?_⟩ |
| · exact ⟨label, by simp, rfl⟩ |
| · rw [liveCase_eval S program cfg safe] |
| simp [hl, hb] |
| apply bool_ext |
| simp only [stickyExpr, Expr.eval, Bool.or_eq_true, Bool.and_eq_true, hactive] |
| cases hl : cfg.l with |
| | none => |
| rw [absorbing_halted program cfg hl] |
| simp [configEncoding, hl] |
| | some label => simp [configEncoding, hl] |
|
|
| omit [DecidableEq K] [Fintype Λ] [Fintype σ] [∀ stack, Fintype (Γ stack)] in |
| theorem configEncoding_injective (S : Nat) (first second : TM2.Cfg Γ Λ σ) |
| (hfirst : ∀ k, (first.stk k).length ≤ S) |
| (hsecond : ∀ k, (second.stk k).length ≤ S) |
| (same : configEncoding S first = configEncoding S second) : first = second := by |
| have hl : first.l = second.l := by |
| have h := congrFun same (.inl second.l) |
| simpa only [configEncoding, decide_true, decide_eq_true_eq] using h |
| have hv : first.var = second.var := by |
| have h := congrFun same (.inr (.inl second.var)) |
| simpa only [configEncoding, inputEncoding, decide_true, decide_eq_true_eq] using h |
| have ht : first.stk = second.stk := by |
| funext k |
| apply StackEncoding.encode_injective (hfirst k) (hsecond k) |
| funext i |
| have h := congrFun same (.inr (.inr ⟨k, i, StackEncoding.encode S (second.stk k) i⟩)) |
| simpa only [configEncoding, inputEncoding, decide_true, decide_eq_true_eq] using h |
| cases first |
| cases second |
| simp only at hl hv ht |
| cases hl |
| cases hv |
| cases ht |
| rfl |
|
|
| noncomputable def programCost (program : Λ → TM2.Stmt Γ Λ σ) : Nat := |
| ∑ label, statementCost (program label) 1 |
|
|
| omit [DecidableEq K] [DecidableEq Λ] [DecidableEq σ] |
| [∀ stack, DecidableEq (Γ stack)] in |
| theorem statementCost_le_programCost (program : Λ → TM2.Stmt Γ Λ σ) (label : Λ) : |
| statementCost (program label) 1 ≤ programCost program := by |
| unfold programCost |
| exact Finset.single_le_sum (f := fun i : Λ => statementCost (program i) 1) |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ label) |
|
|
| noncomputable def expressionCost (program : Λ → TM2.Stmt Γ Λ σ) : Nat := |
| 5 + Fintype.card Λ * (programCost program + 3) |
|
|
| omit [DecidableEq K] [DecidableEq Λ] [DecidableEq σ] |
| [∀ stack, DecidableEq (Γ stack)] in |
| theorem one_le_expressionCost (program : Λ → TM2.Stmt Γ Λ σ) : |
| 1 ≤ expressionCost program := by |
| unfold expressionCost |
| omega |
|
|
| theorem stickyExpr_size_le (S : Nat) (program : Λ → TM2.Stmt Γ Λ σ) |
| (bit : ConfigBit Γ Λ σ S) : |
| (stickyExpr S program bit).size ≤ expressionCost program := by |
| have hc : ∀ e ∈ Finset.univ.toList.map (liveCase S program bit), |
| e.size ≤ programCost program + 2 := by |
| intro e he |
| rcases List.mem_map.mp he with ⟨label, _, rfl⟩ |
| have h := (transitionExpr_size_le S (program label) bit).trans |
| (statementCost_le_programCost program label) |
| simp only [liveCase, Expr.size, Expr.size_rename] |
| omega |
| have hd := Expr.size_disjoin_le |
| (Finset.univ.toList.map (liveCase S program bit)) (programCost program + 2) hc |
| simp only [List.length_map, Finset.length_toList, Finset.card_univ] at hd |
| simp only [Nat.add_assoc] at hd |
| rw [show (2 : Nat) + 1 = 3 by decide] at hd |
| simp only [stickyExpr, Expr.size, expressionCost] |
| omega |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.MachineCircuit |
|
|
| end OAI |
|
|
