| import Mathlib |
| import OAI.Computability.MaxCut.Machines.MachineTupleOdometer |
| import OAI.Computability.MaxCut.Games.AddressGame |
|
|
| namespace OAI |
|
|
| namespace MaxCutGames.Reduction.AddressMachineProgram |
|
|
| open Turing Foundations.Complexity Foundations.Hastad Integration |
| open MachineComposition |
|
|
| noncomputable section |
|
|
| abbrev Tape (k : Nat) {s d : Nat} (T : NoiseTables.Table s d) := |
| AddressMachineSpace.Tape k s d T.vectors.length |
| abbrev State (k : Nat) := AddressMachineSpace.State k |
|
|
| variable (k : Nat) {s d : Nat} (T : NoiseTables.Table s d) |
|
|
| def accumulator : Tape k T := AddressMachineSpace.headerTape k s d T.vectors.length .reversed |
| def output : Tape k T := AddressMachineSpace.finalOutput k s d T.vectors.length |
|
|
| theorem accumulator_ne_output : accumulator k T ≠ output k T := |
| AddressMachineSpace.headerTape_ne_finalOutput k s d T.vectors.length .reversed |
|
|
| /-- The finalizer visits every other tape in a fixed finite order. -/ |
| def clearKeys : List (Tape k T) := by |
| classical |
| exact ((Finset.univ : Finset (Tape k T)).filter |
| (fun tape : Tape k T => tape ≠ accumulator k T ∧ tape ≠ output k T)).toList |
|
|
| @[simp] theorem mem_clearKeys (tape : Tape k T) : |
| tape ∈ clearKeys k T ↔ tape ≠ accumulator k T ∧ tape ≠ output k T := by |
| classical |
| simp [clearKeys] |
|
|
| @[simp] theorem accumulator_not_mem_clearKeys : accumulator k T ∉ clearKeys k T := by simp |
| @[simp] theorem output_not_mem_clearKeys : output k T ∉ clearKeys k T := by simp |
|
|
| theorem clearKeys_covers (tape : Tape k T) (ha : tape ≠ accumulator k T) |
| (ho : tape ≠ output k T) : tape ∈ clearKeys k T := (mem_clearKeys k T tape).2 ⟨ha,ho⟩ |
|
|
| theorem clearKeys_nodup : (clearKeys k T).Nodup := by |
| unfold clearKeys |
| exact Finset.nodup_toList _ |
|
|
| abbrev HeaderLabel := MachineAddressHeaders.Label k s d T.vectors.length |
| abbrev BodyLabel := Integration.AddressTupleBody.Label k s d T.vectors.length |
| (AddressOutcomeSpecs.rows k T) |
| abbrev FinishLabel := SourceRuntimeFinish.Label (clearKeys k T) |
|
|
| inductive Label (k : Nat) {s d : Nat} (T : NoiseTables.Table s d) |
| | header (localLabel : HeaderLabel k T) |
| | initialize (localLabel : MachineOdometerInit.Label k) |
| | body (localLabel : BodyLabel k T) |
| | check (digit : Fin k) |
| | reset (digit : Fin k) |
| | finishStart |
| | finish (localLabel : FinishLabel k T) |
| deriving DecidableEq, Fintype |
|
|
| def headerLabels : HeaderLabel k T → Label k T := Label.header |
| def initializeLabels : MachineOdometerInit.Label k → Label k T := Label.initialize |
| def bodyLabels : BodyLabel k T → Label k T := Label.body |
| def finishLabels : FinishLabel k T → Label k T := Label.finish |
|
|
| def start : Label k T := .header (.inl .copyOut) |
| def initializeStart : Label k T := MachineOdometerInit.labelAt (initializeLabels k T) 0 |
| def bodyStart : Label k T := .body (Integration.AddressTupleBody.main (AddressOutcomeSpecs.rows k T)) |
| def checkLabel (j : Fin k) : Label k T := .check j |
| def resetLabel (j : Fin k) : Label k T := .reset j |
| def finishStart : Label k T := .finishStart |
|
|
| def next (r : Nat) : Label k T := |
| if h : r < k then checkLabel k T ⟨r,h⟩ else finishStart k T |
|
|
| def resetAt (r : Nat) : Label k T := |
| if h : r < k then resetLabel k T ⟨r,h⟩ else finishStart k T |
|
|
| @[simp] theorem next_lt (r : Nat) (h : r < k) : |
| next k T r = checkLabel k T ⟨r,h⟩ := by simp [next,h] |
| @[simp] theorem next_ge (r : Nat) (h : k ≤ r) : next k T r = finishStart k T := by |
| simp [next, Nat.not_lt.mpr h] |
| @[simp] theorem resetAt_lt (r : Nat) (h : r < k) : |
| resetAt k T r = resetLabel k T ⟨r,h⟩ := by simp [resetAt,h] |
|
|
| /-- Header, digit initialization, physical tuple body, carry loops, and complete |
| finalization are placed in a single actual finite transition program. -/ |
| def program : Label k T → TM2.Stmt (fun _ : Tape k T => Bool) (Label k T) (State k) |
| | .header l => MachineAddressHeaders.statement |
| (AddressMachineSpace.fullHeaderSlots k s d T.vectors.length) |
| (headerLabels k T) (some (initializeStart k T)) l |
| | .initialize l => MachineOdometerInit.statement |
| (AddressMachineSpace.odometerSlots k s d T.vectors.length) |
| (initializeLabels k T) (some (bodyStart k T)) l |
| | .body l => Integration.AddressTupleBody.instruction (AddressOutcomeSpecs.rows k T) |
| (bodyLabels k T) (some (next k T 0)) l |
| | .check j => MachineTupleOdometer.increment |
| (AddressMachineSpace.current k s d T.vectors.length j) |
| (AddressMachineSpace.remaining k s d T.vectors.length j) |
| (bodyStart k T) (resetLabel k T j) |
| | .reset j => MachineTupleOdometer.reset |
| (AddressMachineSpace.current k s d T.vectors.length j) |
| (AddressMachineSpace.remaining k s d T.vectors.length j) |
| (resetLabel k T j) (next k T (j.val+1)) |
| | .finishStart => MachineFieldTemplate.jump |
| (SourceRuntimeFinish.entry (clearKeys k T) (finishLabels k T)) |
| | .finish l => SourceRuntimeFinish.statement (clearKeys k T) (accumulator k T) (output k T) |
| (AddressMachineSpace.initialState k).1 (finishLabels k T) none l |
|
|
| @[simp] theorem atHeader (l : HeaderLabel k T) : program k T (headerLabels k T l) = |
| MachineAddressHeaders.statement (AddressMachineSpace.fullHeaderSlots k s d T.vectors.length) |
| (headerLabels k T) (some (initializeStart k T)) l := rfl |
|
|
| @[simp] theorem atInitialize (l : MachineOdometerInit.Label k) : |
| program k T (initializeLabels k T l) = |
| MachineOdometerInit.statement (AddressMachineSpace.odometerSlots k s d T.vectors.length) |
| (initializeLabels k T) (some (bodyStart k T)) l := rfl |
|
|
| @[simp] theorem atBody (l : BodyLabel k T) : program k T (bodyLabels k T l) = |
| Integration.AddressTupleBody.instruction (AddressOutcomeSpecs.rows k T) |
| (bodyLabels k T) (some (next k T 0)) l := rfl |
|
|
| @[simp] theorem atCheck (j : Fin k) : program k T (checkLabel k T j) = |
| MachineTupleOdometer.increment (AddressMachineSpace.current k s d T.vectors.length j) |
| (AddressMachineSpace.remaining k s d T.vectors.length j) |
| (bodyStart k T) (resetLabel k T j) := rfl |
|
|
| @[simp] theorem atReset (j : Fin k) : program k T (resetLabel k T j) = |
| MachineTupleOdometer.reset (AddressMachineSpace.current k s d T.vectors.length j) |
| (AddressMachineSpace.remaining k s d T.vectors.length j) |
| (resetLabel k T j) (next k T (j.val+1)) := rfl |
|
|
| @[simp] theorem atFinish (l : FinishLabel k T) : program k T (finishLabels k T l) = |
| SourceRuntimeFinish.statement (clearKeys k T) (accumulator k T) (output k T) |
| (AddressMachineSpace.initialState k).1 (finishLabels k T) none l := rfl |
|
|
| /-- This bridge has no data-dependent action and costs exactly one transition. -/ |
| theorem finishStartStep (state : State k) (base : Tape k T → List Bool) : |
| TM2.step (program k T) ⟨some (finishStart k T),state,base⟩ = |
| some ⟨SourceRuntimeFinish.entry (clearKeys k T) (finishLabels k T),state,base⟩ := by |
| change some (TM2.stepAux (MachineFieldTemplate.jump |
| (SourceRuntimeFinish.entry (clearKeys k T) (finishLabels k T))) state base) = _ |
| cases SourceRuntimeFinish.entry (clearKeys k T) (finishLabels k T) <;> rfl |
| |
| def finishStartInTime (state : State k) (base : Tape k T → List Bool) : |
| StateTransition.EvalsToInTime (TM2.step (program k T)) |
| ⟨some (finishStart k T),state,base⟩ |
| (some ⟨SourceRuntimeFinish.entry (clearKeys k T) (finishLabels k T),state,base⟩) 1 where |
| steps := 1 |
| evals_in_steps := finishStartStep k T state base |
| steps_le_m := Nat.le_refl _ |
|
|
| /-- All alphabets and registers are finite. Counts live solely on Bool stacks. -/ |
| def machine : FinTM2 where |
| K := Tape k T |
| k₀ := .source |
| k₁ := output k T |
| Γ := fun _ => Bool |
| Λ := Label k T |
| main := start k T |
| σ := State k |
| initialState := AddressMachineSpace.initialState k |
| m := program k T |
|
|
| @[simp] theorem machine_main : (machine k T).main = start k T := rfl |
| @[simp] theorem machine_program : (machine k T).m = program k T := rfl |
| @[simp] theorem machine_initialState : (machine k T).initialState = AddressMachineSpace.initialState k := rfl |
| @[simp] theorem machine_input : (machine k T).k₀ = (MachineSourceTuple.Tape.source : Tape k T) := rfl |
| @[simp] theorem machine_output : (machine k T).k₁ = output k T := rfl |
|
|
| /-- Identity alphabet encodings at both ends of the concrete machine. -/ |
| def inputAlphabet : (machine k T).Γ (machine k T).k₀ ≃ Bool := Equiv.refl Bool |
| def outputAlphabet : (machine k T).Γ (machine k T).k₁ ≃ Bool := Equiv.refl Bool |
|
|
| def inputTapes (bits : List Bool) : Tape k T → List Bool := |
| Function.update (fun _ => []) .source bits |
|
|
| def outputTapes (bits : List Bool) : Tape k T → List Bool := |
| SourceRuntimeFinish.canonicalTapes (output k T) bits |
|
|
| @[simp] theorem inputTapes_source (bits : List Bool) : inputTapes k T bits .source = bits := by |
| simp [inputTapes] |
|
|
| @[simp] theorem inputTapes_other (bits : List Bool) (tape : Tape k T) (h : tape ≠ .source) : |
| inputTapes k T bits tape = [] := by simp [inputTapes,h] |
|
|
| @[simp] theorem outputTapes_output (bits : List Bool) : outputTapes k T bits (output k T) = bits := by |
| simp [outputTapes, SourceRuntimeFinish.canonicalTapes] |
|
|
| @[simp] theorem outputTapes_other (bits : List Bool) (tape : Tape k T) (h : tape ≠ output k T) : |
| outputTapes k T bits tape = [] := by simp [outputTapes,SourceRuntimeFinish.canonicalTapes,h] |
|
|
| theorem initList_eq (bits : List Bool) : initList (machine k T) bits = |
| ⟨some (start k T),AddressMachineSpace.initialState k,inputTapes k T bits⟩ := by |
| change (⟨some (start k T),AddressMachineSpace.initialState k, |
| (initList (machine k T) bits).stk⟩ : (machine k T).Cfg) = _ |
| apply congrArg (fun tapes => |
| (⟨some (start k T),AddressMachineSpace.initialState k,tapes⟩ : (machine k T).Cfg)) |
| funext tape |
| by_cases h : tape = .source |
| · subst tape; simp [initList,machine,inputTapes]; rfl |
| · simp [initList,machine,inputTapes] |
| erw [dite_eq_right h, Function.update_of_ne h] |
| |
| theorem haltList_eq (bits : List Bool) : haltList (machine k T) bits = |
| ⟨none,AddressMachineSpace.initialState k,outputTapes k T bits⟩ := by |
| change (⟨none,AddressMachineSpace.initialState k, |
| (haltList (machine k T) bits).stk⟩ : (machine k T).Cfg) = _ |
| apply congrArg (fun tapes => |
| (⟨none,AddressMachineSpace.initialState k,tapes⟩ : (machine k T).Cfg)) |
| funext tape |
| by_cases h : tape = output k T |
| · subst tape; simp [haltList,machine,outputTapes,SourceRuntimeFinish.canonicalTapes]; rfl |
| · simp [haltList,machine,outputTapes,SourceRuntimeFinish.canonicalTapes] |
| erw [dite_eq_right h, Function.update_of_ne h] |
| |
| end |
| end MaxCutGames.Reduction.AddressMachineProgram |
| |
| end OAI |
| |
