| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.FiniteScan |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets.BinarySyntax |
|
|
| inductive Phase where |
| | headerMark | headerPayload |
| | widthStart | widthBit0 |
| | widthMark1 (b : Bool) | widthBit1 (b : Bool) |
| | widthMark2 (b c : Bool) |
| | sign (remaining : Fin 3) (first : Bool) |
| | mark (remaining : Fin 3) |
| | payload (remaining : Fin 3) |
| | bad |
| deriving DecidableEq, Fintype |
|
|
| def after (r : Fin 3) : Phase := |
| if h : r.val=0 then .widthStart else .sign ⟨r.val-1,by omega⟩ false |
|
|
| def width (n : Fin 4) : Phase := |
| if h : n.val=0 then .widthStart else .sign ⟨n.val-1,by omega⟩ true |
|
|
| def transition : Phase → Bool → Phase |
| | .headerMark, true => .headerPayload |
| | .headerMark, false => .widthStart |
| | .headerPayload, _ => .headerMark |
| | .widthStart, true => .widthBit0 |
| | .widthStart, false => .widthStart |
| | .widthBit0, b => .widthMark1 b |
| | .widthMark1 b, true => .widthBit1 b |
| | .widthMark1 b, false => if b then .sign 0 true else .widthStart |
| | .widthBit1 b, c => .widthMark2 b c |
| | .widthMark2 b c, false => if c then .sign (if b then 2 else 1) true |
| else if b then .sign 0 true else .widthStart |
| | .widthMark2 _ _, true => .bad |
| | .sign r _, _ => .mark r |
| | .mark r, true => .payload r |
| | .mark r, false => after r |
| | .payload r, _ => .mark r |
| | .bad, _ => .bad |
|
|
| def run (q : Phase) (s : List Bool) : Phase := s.foldl transition q |
|
|
| @[simp] lemma run_nil (q : Phase) : run q [] = q := rfl |
| @[simp] lemma run_cons (q : Phase) (b : Bool) (s : List Bool) : |
| run q (b::s) = run (transition q b) s := rfl |
| lemma run_append (q : Phase) (a b : List Bool) : run q (a++b) = run (run q a) b := |
| List.foldl_append |
|
|
| lemma run_header (s : List Bool) : run .headerMark (frame s) = .widthStart := by |
| induction s with |
| | nil => rfl |
| | cons b bs ih => simpa only [frame,run_cons,transition] using ih |
|
|
| lemma run_name (r : Fin 3) (s : List Bool) : run (.mark r) (frame s) = after r := by |
| induction s with |
| | nil => rfl |
| | cons b bs ih => simpa only [frame,run_cons,transition] using ih |
|
|
| lemma run_literal (r : Fin 3) (first : Bool) (l : Literal) : |
| run (.sign r first) (literalBits l) = after r := by |
| simpa only [literalBits,nameBits,run_cons,transition] using run_name r l.name.bits |
|
|
| lemma run_width (n : Fin 4) : run .widthStart (nameBits n.val) = width n := by |
| fin_cases n <;> rfl |
|
|
| lemma run_clause (C : List Literal) (hw : C.length ≤ 3) : |
| run .widthStart (clauseBits C) = .widthStart := by |
| unfold clauseBits |
| rw [run_append,run_width ⟨C.length,by omega⟩] |
| cases C with |
| | nil => rfl |
| | cons a C => |
| cases C with |
| | nil => |
| change run (.sign 0 true) (literalBits a ++ []) = .widthStart |
| simpa [after] using run_literal 0 true a |
| | cons b C => |
| cases C with |
| | nil => |
| simp only [List.length_cons,List.length_nil,List.flatMap_cons,List.flatMap_nil, |
| List.append_nil] |
| change run (.sign 1 true) (literalBits a ++ literalBits b) = _ |
| rw [run_append,run_literal] |
| exact run_literal 0 false b |
| | cons c C => |
| have hc : C=[] := by |
| apply List.length_eq_zero_iff.mp |
| simp only [List.length_cons] at hw |
| omega |
| subst C |
| simp only [List.length_cons,List.length_nil,List.flatMap_cons,List.flatMap_nil, |
| List.append_nil] |
| change run (.sign 2 true) (literalBits a ++ (literalBits b ++ literalBits c)) = _ |
| rw [run_append,run_literal] |
| change run (.sign 1 false) (literalBits b ++ literalBits c) = _ |
| rw [run_append,run_literal] |
| exact run_literal 0 false c |
|
|
| lemma run_clauses (Cs : List (List Literal)) (hw : ∀ C ∈ Cs, C.length ≤ 3) : |
| run .widthStart (Cs.flatMap clauseBits) = .widthStart := by |
| induction Cs with |
| | nil => rfl |
| | cons C Cs ih => |
| rw [List.flatMap_cons,run_append,run_clause C (hw C (by simp))] |
| exact ih (fun D hD => hw D (by simp [hD])) |
|
|
| lemma run_formula (F : Formula) : run .headerMark (formulaBits F) = .widthStart := by |
| rw [formulaBits,run_append] |
| simp only [nameBits,run_header] |
| exact run_clauses F.clauses F.width |
|
|
| noncomputable def phaseEquiv : Phase ≃ Fin (Fintype.card Phase) := Fintype.equivFin Phase |
| noncomputable def finiteTransition (q : Fin (Fintype.card Phase)) (b : Bool) := |
| phaseEquiv (transition (phaseEquiv.symm q) b) |
|
|
| lemma finite_run (q : Phase) (s : List Bool) : |
| s.foldl finiteTransition (phaseEquiv q) = phaseEquiv (run q s) := by |
| induction s generalizing q with |
| | nil => rfl |
| | cons b s ih => simpa [List.foldl_cons,finiteTransition,run,transition] using ih (transition q b) |
|
|
| noncomputable def annotated (s : List Bool) := |
| FiniteScan.output finiteTransition (phaseEquiv .headerMark) s |
|
|
| lemma annotated_history (s : List Bool) (j : ℕ) (hj : j ≤ s.length) : |
| (annotated s).history j = phaseEquiv (run .headerMark (s.take j)) := by |
| rw [annotated,FiniteScan.output_history _ _ _ j hj,finite_run] |
|
|
| noncomputable def certificate : Turing.TM2ComputableInPolyTime |
| (id : List Bool → List Bool) FiniteScan.State.bits annotated := |
| FiniteScan.certificate finiteTransition (phaseEquiv .headerMark) |
|
|
| lemma finiteAlphabet : IndependentSetsGames.Foundations.Complexity.MachineFiniteAlphabet.FiniteAlphabet |
| certificate.tm := FiniteScan.finiteAlphabet _ _ |
|
|
| end LargeIndependentSets.BinarySyntax |
|
|
| end OAI |
|
|
