| import Mathlib |
| import OAI.Computability.MaxCut.Machines.MachineCopy |
| import OAI.Computability.MaxCut.Machines.MachineBinaryFormula |
|
|
| namespace OAI |
|
|
| /-! |
| Preserved comparisons of actual field stacks and their finite equality profile. |
| All whole-word equalities below are specifications of finite-head comparison. |
| -/ |
|
|
| namespace MaxCutGames.Foundations.Complexity.MachineFieldProfile |
|
|
| open Turing |
|
|
| abbrev Profile (q : Nat) := Fin q → Fin q → Bool |
|
|
| def equalityProfile {q : Nat} (words : Fin q → List Bool) : Profile q := |
| fun i j => decide (words i = words j) |
|
|
| theorem equalityProfile_encodeWord {q : Nat} (names : Fin q → Nat) (i j : Fin q) : |
| equalityProfile (fun k => encodeWord (names k)) i j = decide (names i = names j) := by |
| have h : encodeWord (names i) = encodeWord (names j) ↔ names i = names j := by |
| constructor |
| · intro heq |
| have hh := congrArg List.length heq |
| simpa only [encodeWord_length, Nat.add_right_cancel_iff] using hh |
| · rintro heq |
| rw [heq] |
| simp only [equalityProfile, h] |
|
|
| section Transport |
| variable {K Λ σ τ : Type} [DecidableEq K] |
|
|
| omit [DecidableEq K] in |
| theorem statement_roundtrip (e : σ ≃ τ) |
| (q : TM2.Stmt (fun _ : K => Bool) Λ τ) : |
| MachineControl.statement id e (MachineControl.statement id e.symm q) = q := by |
| induction q <;> simp_all [MachineControl.statement] |
|
|
| def copyStateEquiv (σ : Type) : |
| ((σ × Bool × Option Bool) × Option Bool) ≃ MachineCompare.State σ where |
| toFun s := (s.1.1, s.1.2.1, s.1.2.2, s.2) |
| invFun s := ((s.1, s.2.1, s.2.2.1), s.2.2.2) |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| def normalState (ambient : σ) : MachineCompare.State σ := (ambient, false, none, none) |
|
|
| def copyStatement (q : TM2.Stmt (fun _ : K => Bool) Λ |
| ((σ × Bool × Option Bool) × Option Bool)) : |
| TM2.Stmt (fun _ : K => Bool) Λ (MachineCompare.State σ) := |
| MachineControl.statement id (copyStateEquiv σ) q |
|
|
| def copyInCompareState (source destination scratch : K) |
| (hSD : source ≠ destination) (hST : source ≠ scratch) (hDT : destination ≠ scratch) |
| (firstLabel secondLabel : Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (MachineCompare.State σ)) |
| (atFirst : program firstLabel = copyStatement |
| (Reduction.MachineTransfer.loopAt source scratch id false firstLabel (some secondLabel))) |
| (atSecond : program secondLabel = copyStatement |
| (MachineCopy.forkLoop scratch source destination false secondLabel exit)) |
| (base : K → List Bool) (hScratch : base scratch = []) (ambient : σ) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some firstLabel, normalState ambient, base⟩ |
| (some ⟨exit, normalState ambient, |
| Function.update base destination (base source ++ base destination)⟩) |
| (2 * ((base source).length + 1)) := by |
| let e := copyStateEquiv σ |
| let view := MachineControl.program (Equiv.refl Λ) e.symm program |
| have hfirst : view firstLabel = |
| Reduction.MachineTransfer.loopAt source scratch id false firstLabel (some secondLabel) := by |
| dsimp [view, MachineControl.program] |
| rw [atFirst] |
| exact statement_roundtrip e.symm _ |
| have hsecond : view secondLabel = |
| MachineCopy.forkLoop scratch source destination false secondLabel exit := by |
| dsimp [view, MachineControl.program] |
| rw [atSecond] |
| exact statement_roundtrip e.symm _ |
| let run := MachineCopy.copyInTime source destination scratch hSD hST hDT false |
| firstLabel secondLabel exit view hfirst hsecond base hScratch (ambient, false, none) none |
| have hprogram : MachineControl.program (Equiv.refl Λ) e view = program := by |
| funext label |
| exact statement_roundtrip e (program label) |
| have hsim (a b : TM2.Cfg (fun _ : K => Bool) Λ ((σ × Bool × Option Bool) × Option Bool)) |
| (hab : TM2.step view a = some b) : |
| TM2.step program (MachineControl.configuration id e a) = |
| some (MachineControl.configuration id e b) := by |
| have hh := MachineControl.step_simulation (Equiv.refl Λ) e view a |
| rw [hprogram, hab] at hh |
| exact hh |
| have lifted := MachineComposition.liftExecutionInTime (TM2.step view) (TM2.step program) |
| (MachineControl.configuration id e) hsim run |
| simpa [MachineControl.configuration, copyStateEquiv, normalState, e] using lifted |
|
|
| end Transport |
|
|
| section PreservedComparison |
| variable {K Λ σ : Type} [DecidableEq K] |
|
|
| def nonDestructiveCompareInTime (left right workLeft workRight scratch : K) |
| (hleft : left ≠ workLeft ∧ left ≠ workRight ∧ left ≠ scratch) |
| (hright : right ≠ workLeft ∧ right ≠ workRight ∧ right ≠ scratch) |
| (hwork : workLeft ≠ workRight ∧ workLeft ≠ scratch ∧ workRight ≠ scratch) |
| (leftFirst leftSecond rightFirst rightSecond compareLabel : Λ) |
| (equalExit differentExit : Option Λ) |
| (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (MachineCompare.State σ)) |
| (atLeftFirst : program leftFirst = copyStatement |
| (Reduction.MachineTransfer.loopAt left scratch id false leftFirst (some leftSecond))) |
| (atLeftSecond : program leftSecond = copyStatement |
| (MachineCopy.forkLoop scratch left workLeft false leftSecond (some rightFirst))) |
| (atRightFirst : program rightFirst = copyStatement |
| (Reduction.MachineTransfer.loopAt right scratch id false rightFirst (some rightSecond))) |
| (atRightSecond : program rightSecond = copyStatement |
| (MachineCopy.forkLoop scratch right workRight false rightSecond (some compareLabel))) |
| (atCompare : program compareLabel = |
| MachineCompare.loop workLeft workRight compareLabel equalExit differentExit) |
| (base : K → List Bool) (hWL : base workLeft = []) (hWR : base workRight = []) |
| (hScratch : base scratch = []) (ambient : σ) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some leftFirst, normalState ambient, base⟩ |
| (some ⟨if base left = base right then equalExit else differentExit, |
| normalState ambient, base⟩) |
| (2 * ((base left).length + 1) + 2 * ((base right).length + 1) + |
| max (base left).length (base right).length + 1) := by |
| let t₁ := Function.update base workLeft (base left) |
| let t₂ := Function.update t₁ workRight (base right) |
| have h₁ := copyInCompareState left workLeft scratch hleft.1 hleft.2.2 hwork.2.1 |
| leftFirst leftSecond (some rightFirst) program atLeftFirst atLeftSecond base hScratch ambient |
| simp only [hWL, List.append_nil] at h₁ |
| have hSR : t₁ right = base right := by simp [t₁, hright.1] |
| have hDR : t₁ workRight = [] := by simp [t₁, Ne.symm hwork.1, hWR] |
| have hTR : t₁ scratch = [] := by simp [t₁, Ne.symm hwork.2.1, hScratch] |
| have h₂ := copyInCompareState right workRight scratch hright.2.1 hright.2.2 hwork.2.2 |
| rightFirst rightSecond (some compareLabel) program atRightFirst atRightSecond t₁ hTR ambient |
| rw [hSR, hDR] at h₂ |
| simp only [List.append_nil] at h₂ |
| have hL : t₂ workLeft = base left := by simp [t₂, t₁, hwork.1] |
| have hR : t₂ workRight = base right := by simp [t₂] |
| have hrestore : Reduction.MachineTransfer.tapesAt workLeft workRight t₂ [] [] = base := by |
| funext p |
| by_cases hl : p = workLeft |
| · subst p |
| simp [Reduction.MachineTransfer.tapesAt, hwork.1, hWL] |
| · by_cases hr : p = workRight |
| · subst p |
| simp [Reduction.MachineTransfer.tapesAt, hWR] |
| · simp [Reduction.MachineTransfer.tapesAt, t₂, t₁, hl, hr] |
| have h₃ := MachineCompare.compareInTime workLeft workRight hwork.1 compareLabel |
| equalExit differentExit program atCompare t₂ ambient none none |
| rw [hL, hR, hrestore] at h₃ |
| let h₁₂ := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ h₁ h₂ |
| let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ h₁₂ h₃ |
| exact { toEvalsTo := run.toEvalsTo, steps_le_m := by have h := run.steps_le_m; omega } |
|
|
| end PreservedComparison |
|
|
| def setEntry {q : Nat} (profile : Profile q) (pair : Fin q × Fin q) (bit : Bool) : Profile q := |
| Function.update profile pair.1 (Function.update (profile pair.1) pair.2 bit) |
|
|
| theorem setEntry_apply {q : Nat} (profile : Profile q) (pair : Fin q × Fin q) |
| (bit : Bool) (i j : Fin q) : |
| setEntry profile pair bit i j = if (i, j) = pair then bit else profile i j := by |
| rcases pair with ⟨a, b⟩ |
| by_cases hi : i = a <;> by_cases hj : j = b <;> simp [setEntry, hi, hj] |
|
|
| def setExpected {q : Nat} (words : Fin q → List Bool) (profile : Profile q) |
| (pair : Fin q × Fin q) : Profile q := |
| setEntry profile pair (equalityProfile words pair.1 pair.2) |
|
|
| def foldProfile {q : Nat} (words : Fin q → List Bool) (initial : Profile q) |
| (cells : List (Fin q × Fin q)) : Profile q := cells.foldl (setExpected words) initial |
|
|
| theorem foldProfile_apply {q : Nat} (words : Fin q → List Bool) (initial : Profile q) |
| (cells : List (Fin q × Fin q)) (i j : Fin q) : |
| foldProfile words initial cells i j = |
| if (i, j) ∈ cells then equalityProfile words i j else initial i j := by |
| induction cells generalizing initial with |
| | nil => rfl |
| | cons pair rest ih => |
| change foldProfile words (setExpected words initial pair) rest i j = _ |
| rw [ih] |
| by_cases hrest : (i, j) ∈ rest |
| · simp [hrest] |
| · by_cases hpair : (i, j) = pair |
| · subst pair |
| simp [hrest, setExpected, setEntry_apply] |
| · simp [hrest, hpair, setExpected, setEntry_apply] |
|
|
| abbrev Tape (q : Nat) := Fin q ⊕ Fin 3 |
| abbrev Label {q : Nat} (cells : List (Fin q × Fin q)) := Fin (cells.length + 1) × Fin 7 |
|
|
| def labelAt {q : Nat} (cells : List (Fin q × Fin q)) (r : Nat) (phase : Fin 7) : Label cells := |
| (⟨min r cells.length, by omega⟩, phase) |
|
|
| def storePair {q : Nat} (pair : Fin q × Fin q) (bit : Bool) |
| {Λ : Type} (nextLabel : Λ) : |
| TM2.Stmt (fun _ : Tape q => Bool) Λ (MachineCompare.State (Profile q)) := |
| .load (fun state => normalState (setEntry state.1 pair bit)) (.goto fun _ => nextLabel) |
|
|
| /-- The fixed list of pairs determines all control labels and original fields. |
| The program compares only copied work-stack heads, then stores one finite bit. -/ |
| def profileProgram {q : Nat} (cells : List (Fin q × Fin q)) (label : Label cells) : |
| TM2.Stmt (fun _ : Tape q => Bool) (Label cells) (MachineCompare.State (Profile q)) := |
| if h : label.1.val < cells.length then |
| let pair := cells[label.1.val] |
| let r := label.1.val |
| match label.2.val with |
| | 0 => copyStatement (Reduction.MachineTransfer.loopAt (.inl pair.1) (.inr 2) id false |
| (labelAt cells r 0) (some (labelAt cells r 1))) |
| | 1 => copyStatement (MachineCopy.forkLoop (.inr 2) (.inl pair.1) (.inr 0) false |
| (labelAt cells r 1) (some (labelAt cells r 2))) |
| | 2 => copyStatement (Reduction.MachineTransfer.loopAt (.inl pair.2) (.inr 2) id false |
| (labelAt cells r 2) (some (labelAt cells r 3))) |
| | 3 => copyStatement (MachineCopy.forkLoop (.inr 2) (.inl pair.2) (.inr 1) false |
| (labelAt cells r 3) (some (labelAt cells r 4))) |
| | 4 => MachineCompare.loop (.inr 0) (.inr 1) (labelAt cells r 4) |
| (some (labelAt cells r 5)) (some (labelAt cells r 6)) |
| | 5 => storePair pair true (labelAt cells (r + 1) 0) |
| | _ => storePair pair false (labelAt cells (r + 1) 0) |
| else .halt |
|
|
| def pairTime {q : Nat} (words : Fin q → List Bool) (pair : Fin q × Fin q) : Nat := |
| 2 * ((words pair.1).length + 1) + 2 * ((words pair.2).length + 1) + |
| max (words pair.1).length (words pair.2).length + 2 |
|
|
| def prefixProfile {q : Nat} (words : Fin q → List Bool) (initial : Profile q) |
| (cells : List (Fin q × Fin q)) (r : Nat) : Profile q := |
| foldProfile words initial (cells.take r) |
|
|
| def prefixTime {q : Nat} (words : Fin q → List Bool) |
| (cells : List (Fin q × Fin q)) (r : Nat) : Nat := |
| ((cells.take r).map (pairTime words)).sum |
|
|
| theorem prefixProfile_succ {q : Nat} (words : Fin q → List Bool) (initial : Profile q) |
| (cells : List (Fin q × Fin q)) (r : Nat) (hr : r < cells.length) : |
| prefixProfile words initial cells (r + 1) = |
| setExpected words (prefixProfile words initial cells r) cells[r] := by |
| unfold prefixProfile foldProfile |
| rw [List.take_succ_eq_append_getElem hr, List.foldl_append] |
| rfl |
|
|
| theorem prefixTime_succ {q : Nat} (words : Fin q → List Bool) |
| (cells : List (Fin q × Fin q)) (r : Nat) (hr : r < cells.length) : |
| prefixTime words cells (r + 1) = prefixTime words cells r + pairTime words cells[r] := by |
| unfold prefixTime |
| rw [List.take_succ_eq_append_getElem hr, List.map_append, List.sum_append] |
| rfl |
|
|
| /-- One fully constructed copy/copy/compare/store stage, restoring every stack. -/ |
| def stageInTime {q : Nat} (cells : List (Fin q × Fin q)) (r : Nat) (hr : r < cells.length) |
| (base : Tape q → List Bool) (hwork : ∀ w : Fin 3, base (.inr w) = []) (profile : Profile q) : |
| StateTransition.EvalsToInTime (TM2.step (profileProgram cells)) |
| ⟨some (labelAt cells r 0), normalState profile, base⟩ |
| (some ⟨some (labelAt cells (r + 1) 0), |
| normalState (setExpected (fun i => base (.inl i)) profile cells[r]), base⟩) |
| (pairTime (fun i => base (.inl i)) cells[r]) := by |
| let pair := cells[r] |
| have copied := nonDestructiveCompareInTime (.inl pair.1) (.inl pair.2) |
| (.inr 0 : Tape q) (.inr 1) (.inr 2) (by simp) (by simp) (by simp) |
| (labelAt cells r 0) (labelAt cells r 1) (labelAt cells r 2) (labelAt cells r 3) |
| (labelAt cells r 4) (some (labelAt cells r 5)) (some (labelAt cells r 6)) |
| (profileProgram cells) |
| (by simp [profileProgram, labelAt, Nat.min_eq_left hr.le, hr, pair]) |
| (by simp [profileProgram, labelAt, Nat.min_eq_left hr.le, hr, pair]) |
| (by simp [profileProgram, labelAt, Nat.min_eq_left hr.le, hr, pair]) |
| (by simp [profileProgram, labelAt, Nat.min_eq_left hr.le, hr, pair]) |
| (by simp [profileProgram, labelAt, Nat.min_eq_left hr.le, hr]) |
| base (hwork 0) (hwork 1) (hwork 2) profile |
| have stored : StateTransition.EvalsToInTime (TM2.step (profileProgram cells)) |
| ⟨if base (.inl pair.1) = base (.inl pair.2) then some (labelAt cells r 5) |
| else some (labelAt cells r 6), normalState profile, base⟩ |
| (some ⟨some (labelAt cells (r + 1) 0), |
| normalState (setExpected (fun i => base (.inl i)) profile pair), base⟩) 1 := { |
| steps := 1 |
| evals_in_steps := by |
| change TM2.step (profileProgram cells) |
| ⟨if base (.inl pair.1) = base (.inl pair.2) then some (labelAt cells r 5) |
| else some (labelAt cells r 6), normalState profile, base⟩ = _ |
| by_cases heq : base (.inl pair.1) = base (.inl pair.2) |
| · simp [heq, TM2.step, profileProgram, labelAt, |
| Nat.min_eq_left hr.le, hr, storePair, TM2.stepAux, normalState, |
| setExpected, equalityProfile, pair] |
| · simp [heq, TM2.step, profileProgram, labelAt, |
| Nat.min_eq_left hr.le, hr, storePair, TM2.stepAux, normalState, |
| setExpected, equalityProfile, pair] |
| steps_le_m := Nat.le_refl _ |
| } |
| let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ copied stored |
| refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ } |
| have h := run.steps_le_m |
| dsimp only [pair] at h |
| dsimp only [pairTime] |
| omega |
|
|
| /-- Compose the actual stages up to any fixed position in the pair list. -/ |
| def prefixInTime {q : Nat} (cells : List (Fin q × Fin q)) |
| (base : Tape q → List Bool) (hwork : ∀ w : Fin 3, base (.inr w) = []) (initial : Profile q) |
| (r : Nat) (hr : r ≤ cells.length) : |
| StateTransition.EvalsToInTime (TM2.step (profileProgram cells)) |
| ⟨some (labelAt cells 0 0), normalState initial, base⟩ |
| (some ⟨some (labelAt cells r 0), |
| normalState (prefixProfile (fun i => base (.inl i)) initial cells r), base⟩) |
| (prefixTime (fun i => base (.inl i)) cells r) := by |
| induction r with |
| | zero => |
| exact { steps := 0, evals_in_steps := rfl, steps_le_m := Nat.le_refl _ } |
| | succ r ih => |
| have hrl : r < cells.length := by omega |
| let first := ih (by omega) |
| let second := stageInTime cells r hrl base hwork |
| (prefixProfile (fun i => base (.inl i)) initial cells r) |
| let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ first second |
| rw [prefixProfile_succ _ _ _ _ hrl, prefixTime_succ _ _ _ hrl] |
| exact { toEvalsTo := run.toEvalsTo, steps_le_m := by have h := run.steps_le_m; omega } |
|
|
| def allPairs (q : Nat) : List (Fin q × Fin q) := |
| (List.finRange q).flatMap fun i => (List.finRange q).map fun j => (i, j) |
|
|
| theorem mem_allPairs {q : Nat} (i j : Fin q) : (i, j) ∈ allPairs q := by |
| simp [allPairs] |
|
|
| theorem length_allPairs (q : Nat) : (allPairs q).length = q * q := by |
| simp [allPairs, List.length_flatMap] |
|
|
| theorem foldProfile_allPairs {q : Nat} (words : Fin q → List Bool) (initial : Profile q) : |
| foldProfile words initial (allPairs q) = equalityProfile words := by |
| funext i j |
| simp [foldProfile_apply, mem_allPairs] |
|
|
| /-- A concrete finite machine for the full field equality matrix. -/ |
| def profileMachine (q : Nat) : FinTM2 where |
| K := Tape q |
| k₀ := .inr 0 |
| k₁ := .inr 0 |
| Γ _ := Bool |
| Λ := Label (allPairs q) |
| main := labelAt (allPairs q) 0 0 |
| σ := MachineCompare.State (Profile q) |
| initialState := normalState (fun _ _ => false) |
| m := profileProgram (allPairs q) |
|
|
| /-- Compute every matrix entry while preserving all original field stacks. -/ |
| def profileInTime (q : Nat) (base : Tape q → List Bool) |
| (hwork : ∀ w : Fin 3, base (.inr w) = []) (initial : Profile q) : |
| StateTransition.EvalsToInTime (profileMachine q).step |
| ⟨some (labelAt (allPairs q) 0 0), normalState initial, base⟩ |
| (some ⟨none, normalState (equalityProfile (fun i => base (.inl i))), base⟩) |
| (((allPairs q).map (pairTime (fun i => base (.inl i)))).sum + 1) := by |
| let cells := allPairs q |
| have first := prefixInTime cells base hwork initial cells.length (Nat.le_refl _) |
| have last : StateTransition.EvalsToInTime (TM2.step (profileProgram cells)) |
| ⟨some (labelAt cells cells.length 0), |
| normalState (prefixProfile (fun i => base (.inl i)) initial cells cells.length), base⟩ |
| (some ⟨none, normalState (equalityProfile (fun i => base (.inl i))), base⟩) 1 := { |
| steps := 1 |
| evals_in_steps := by |
| change TM2.step (profileProgram cells) |
| ⟨some (labelAt cells cells.length 0), |
| normalState (prefixProfile (fun i => base (.inl i)) initial cells cells.length), base⟩ = _ |
| simp [TM2.step, profileProgram, labelAt, TM2.stepAux, |
| prefixProfile, cells, foldProfile_allPairs] |
| steps_le_m := Nat.le_refl _ |
| } |
| let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ first last |
| refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ } |
| have h := run.steps_le_m |
| simpa [prefixTime, cells, Nat.add_comm] using h |
|
|
| theorem pairTime_le {q : Nat} (words : Fin q → List Bool) (L : Nat) |
| (hL : ∀ i, (words i).length ≤ L) (pair : Fin q × Fin q) : |
| pairTime words pair ≤ 5 * L + 6 := by |
| have hi := hL pair.1 |
| have hj := hL pair.2 |
| have hm := max_le hi hj |
| dsimp only [pairTime] |
| omega |
|
|
| theorem totalTime_le {q : Nat} (words : Fin q → List Bool) (L : Nat) |
| (hL : ∀ i, (words i).length ≤ L) (cells : List (Fin q × Fin q)) : |
| (cells.map (pairTime words)).sum ≤ cells.length * (5 * L + 6) := by |
| induction cells with |
| | nil => simp |
| | cons pair rest ih => |
| have hp := pairTime_le words L hL pair |
| simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.add_mul, Nat.one_mul] |
| omega |
|
|
| /-- A linear bound in the maximum original field length, for fixed `q`. |
| The actual machine and execution witness are retained. -/ |
| def profileInTime_bounded (q : Nat) (base : Tape q → List Bool) |
| (hwork : ∀ w : Fin 3, base (.inr w) = []) (initial : Profile q) |
| (L : Nat) (hL : ∀ i, (base (.inl i)).length ≤ L) : |
| StateTransition.EvalsToInTime (profileMachine q).step |
| ⟨some (labelAt (allPairs q) 0 0), normalState initial, base⟩ |
| (some ⟨none, normalState (equalityProfile (fun i => base (.inl i))), base⟩) |
| (q * q * (5 * L + 6) + 1) := by |
| let run := profileInTime q base hwork initial |
| refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ } |
| apply run.steps_le_m.trans |
| apply Nat.add_le_add_right |
| simpa only [length_allPairs] using totalTime_le (fun i => base (.inl i)) L hL (allPairs q) |
|
|
| end MaxCutGames.Foundations.Complexity.MachineFieldProfile |
|
|
| end OAI |
|
|
