openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Reduction /NormalizedTargetInitialization.lean
| import OAI.Computability.PerfectCompleteness.Machines.ExactTargetOdometer | |
| import OAI.Computability.PerfectCompleteness.Machines.SourceClauseCountMachine | |
| import OAI.Computability.PerfectCompleteness.Machines.TupleInitializationMachine | |
| namespace OAI | |
| namespace PerfectCompleteness.NormalizedTargetInitialization | |
| open Turing UniqueGamesTheorem.Foundations.Complexity | |
| open MachineComposition | |
| open scoped Classical | |
| noncomputable section | |
| abbrev Tape (width : Nat) := SignedTupleLayout.Tape width (Fin 4) | |
| abbrev Alphabet {width : Nat} (_ : Tape width) := Bool | |
| abbrev State (A : Type) := A × Option Bool | |
| def clean {A : Type} (ambient : A) : State A := (ambient, none) | |
| variable {width : Nat} | |
| def countTape : Fin 4 → Tape width | |
| | 0 => .source .table | |
| | 1 => .extra 1 | |
| | 2 => .extra 2 | |
| | 3 => .extra 0 | |
| theorem countTape_injective : Function.Injective (countTape (width := width)) := by | |
| intro i j same | |
| fin_cases i <;> fin_cases j <;> simp [countTape] at same ⊢ | |
| def currents (width : Nat) : List (Tape width) := List.ofFn SignedTupleLayout.Tape.current | |
| def remaining (width : Nat) : List (Tape width) := List.ofFn SignedTupleLayout.Tape.remaining | |
| theorem destinations_nodup (width : Nat) : (currents width ++ remaining width).Nodup := by | |
| unfold currents remaining | |
| apply List.nodup_append.mpr | |
| refine ⟨?_, ?_, ?_⟩ | |
| · apply List.nodup_ofFn.mpr | |
| intro i j same | |
| simpa using same | |
| · apply List.nodup_ofFn.mpr | |
| intro i j same | |
| simpa using same | |
| · intro a ha b hb | |
| obtain ⟨i, rfl⟩ := List.mem_ofFn.mp ha | |
| obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hb | |
| intro same | |
| cases same | |
| theorem count_not_destination : | |
| (SignedTupleLayout.Tape.extra 0 : Tape width) ∉ currents width ++ remaining width := by | |
| simp [currents, remaining, List.mem_ofFn] | |
| inductive Label | |
| | seed | |
| | count (label : SourceClauseCountMachine.Label) | |
| | tuple (label : TupleInitializationMachine.Label) | |
| deriving DecidableEq, Fintype | |
| variable {Λ A : Type} | |
| def instruction (labels : Label → Λ) (done rejected : Option Λ) : | |
| Label → TM2.Stmt (Alphabet (width := width)) Λ (State A) | |
| | .seed => .push (.extra 0) (fun _ => false) | |
| (.push .edgeCount (fun _ => false) | |
| (.load (fun state => clean state.1) | |
| (.goto (fun _ => labels (.count SourceClauseCountMachine.main))))) | |
| | .count label => SourceClauseCountMachine.instruction countTape | |
| (fun l => labels (.count l)) (some (labels (.tuple .seed))) rejected label | |
| | .tuple label => TupleInitializationMachine.instruction (.extra 0) | |
| (currents width) (remaining width) (fun l => labels (.tuple l)) done label | |
| theorem instruction_pushBound (labels : Label → Λ) (done rejected : Option Λ) (label : Label) : | |
| Runtime.statementPushBound (instruction (width := width) (A := A) labels done rejected label) ≤ | |
| 2 * width + 2 := by | |
| have exitBound (destination : Tape width) (exit : Option Λ) : | |
| Runtime.statementPushBound | |
| (UniqueGamesTheorem.Reduction.MachineTransfer.exitAt | |
| (Γ := Alphabet (width := width)) (σ := A) destination exit) = 0 := by | |
| cases exit <;> rfl | |
| cases label with | |
| | seed => simp [instruction, Runtime.statementPushBound] | |
| | count label => | |
| cases label <;> | |
| simp [instruction, SourceClauseCountMachine.instruction, | |
| UniqueGamesTheorem.Reduction.MachineTransfer.loopAt, MachineCopy.forkLoop, | |
| UnaryBlockSkipMachine.instruction, UnaryBlockSkipMachine.finish, | |
| UniqueGamesTheorem.Foundations.Hastad.SourceMachine.fieldLoop, | |
| MachineDrain.drain, Runtime.statementPushBound, exitBound] | |
| | tuple label => | |
| have bound := TupleInitializationMachine.instruction_pushBound | |
| (σ := A) (SignedTupleLayout.Tape.extra 0 : Tape width) | |
| (currents width) (remaining width) (fun l => labels (.tuple l)) done label | |
| change Runtime.statementPushBound | |
| (TupleInitializationMachine.instruction (.extra 0) | |
| (currents width) (remaining width) (fun l => labels (.tuple l)) done label) ≤ _ | |
| refine bound.trans ?_ | |
| simp only [currents, remaining, List.length_ofFn] | |
| omega | |
| def inputTapes (input : NormalizedSourceInput.Input) : Tape width → List Bool | |
| | .source .table => NormalizedSourceInput.bits input | |
| | _ => [] | |
| def seededTapes (input : NormalizedSourceInput.Input) : Tape width → List Bool := | |
| Function.update (Function.update (inputTapes input) (.extra 0) [false]) .edgeCount [false] | |
| def countedTapes (input : NormalizedSourceInput.Input) : Tape width → List Bool := | |
| Function.update (seededTapes input) (.extra 0) | |
| (encodeWord (NormalizedSourceInput.clauseCount input)) | |
| def zeroDigits (input : NormalizedSourceInput.Input) : | |
| Fin width → Fin (NormalizedSourceInput.clauseCount input) := | |
| fun _ => ⟨0, NormalizedSourceInput.clauseCount_positive input⟩ | |
| def readyTapes (input : NormalizedSourceInput.Input) : Tape width → List Bool := | |
| Function.update (ExactTargetOdometer.baseTapes input (zeroDigits input) (fun _ => [])) | |
| .edgeCount (encodeWord 0) | |
| @[simp] theorem seeded_count (input : NormalizedSourceInput.Input) : | |
| seededTapes (width := width) input (.extra 0) = [false] := by | |
| simp [seededTapes] | |
| @[simp] theorem counted_count (input : NormalizedSourceInput.Input) : | |
| countedTapes (width := width) input (.extra 0) = | |
| encodeWord (NormalizedSourceInput.clauseCount input) := by | |
| simp [countedTapes] | |
| theorem initializedTapes_eq_ready (input : NormalizedSourceInput.Input) : | |
| TupleInitializationMachine.initializedTapes (.extra 0) (currents width) (remaining width) | |
| (countedTapes input) (NormalizedSourceInput.clauseCount input - 1) [] = | |
| readyTapes input := by | |
| funext key | |
| cases key with | |
| | source source => | |
| cases source <;> | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes] | |
| | current position => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes, zeroDigits, encodeWord] | |
| | remaining position => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes, zeroDigits, encodeWord] | |
| | encodedVariable position slot => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes] | |
| | adapterScratch => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes] | |
| | edgeWork slot => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes] | |
| | edgeCount => | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, | |
| readyTapes, encodeWord] | |
| | extra slot => | |
| fin_cases slot <;> | |
| simp [TupleInitializationMachine.initializedTapes, TupleInitializationMachine.prefixOn, | |
| currents, remaining, List.mem_ofFn, countedTapes, seededTapes, inputTapes, | |
| readyTapes, ExactTargetOdometer.baseTapes] | |
| @[simp] theorem ready_table (input : NormalizedSourceInput.Input) : | |
| readyTapes (width := width) input (.source .table) = NormalizedSourceInput.bits input := by | |
| simp [readyTapes, ExactTargetOdometer.baseTapes] | |
| @[simp] theorem ready_current (input : NormalizedSourceInput.Input) (position : Fin width) : | |
| readyTapes input (.current position) = encodeWord 0 := by | |
| simp [readyTapes, ExactTargetOdometer.baseTapes, zeroDigits] | |
| @[simp] theorem ready_remaining (input : NormalizedSourceInput.Input) (position : Fin width) : | |
| readyTapes input (.remaining position) = | |
| encodeWord (NormalizedSourceInput.clauseCount input - 1) := by | |
| simp [readyTapes, ExactTargetOdometer.baseTapes, zeroDigits] | |
| @[simp] theorem ready_extra (input : NormalizedSourceInput.Input) (slot : Fin 4) : | |
| readyTapes (width := width) input (.extra slot) = [] := by | |
| simp [readyTapes, ExactTargetOdometer.baseTapes] | |
| theorem ready_eq_native {branch : Nat → Nat} {n t : Nat} | |
| (input : NormalizedSourceInput.Input) : | |
| readyTapes (width := TreeCanonical.locationCount branch n t) input = | |
| ExactTargetOdometer.nativeTapes (branch := branch) (n := n) (t := t) | |
| input (zeroDigits input) ⟨[], [], [], 0⟩ (fun _ : Fin 4 => []) := by | |
| funext key | |
| cases key with | |
| | source source => | |
| cases source <;> | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes, | |
| ExactTargetOdometer.baseTapes] | |
| | current position => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| | remaining position => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| | encodedVariable position slot => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| | adapterScratch => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| | edgeWork slot => | |
| fin_cases slot <;> | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes, | |
| ExactTargetOdometer.baseTapes, CanonicalVertexNames.tokens] | |
| | edgeCount => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| | extra slot => | |
| simp [readyTapes, ExactTargetOdometer.nativeTapes, SignedTupleBodyMachine.tapes] | |
| variable (labels : Label → Λ) (done rejected : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (width := width)) Λ (State A)) | |
| (atLabels : ∀ label, program (labels label) = instruction labels done rejected label) | |
| include atLabels in | |
| theorem seedStep (input : NormalizedSourceInput.Input) (ambient : A) (register : Option Bool) : | |
| TM2.step program ⟨some (labels .seed), (ambient, register), inputTapes input⟩ = | |
| some ⟨some (labels (.count SourceClauseCountMachine.main)), clean ambient, seededTapes input⟩ := by | |
| change some (TM2.stepAux (program (labels .seed)) _ _) = _ | |
| rw [atLabels .seed] | |
| simp [instruction, TM2.stepAux, seededTapes, inputTapes, clean] | |
| def initializeExactInTime (input : NormalizedSourceInput.Input) | |
| (ambient : A) (register : Option Bool) : | |
| StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels .seed), (ambient, register), inputTapes input⟩ | |
| (some ⟨done, clean ambient, readyTapes input⟩) | |
| (1 + 3 * ((NormalizedSourceInput.bits input).length + 1) + | |
| (NormalizedSourceInput.clauseCount input + 1)) := by | |
| have seeded : StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels .seed), (ambient, register), inputTapes input⟩ | |
| (some ⟨some (labels (.count SourceClauseCountMachine.main)), | |
| clean ambient, seededTapes input⟩) 1 := by | |
| refine { steps := 1, evals_in_steps := ?_, steps_le_m := Nat.le_refl 1 } | |
| exact seedStep labels done rejected program atLabels input ambient register | |
| have counted : StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels (.count SourceClauseCountMachine.main)), clean ambient, seededTapes input⟩ | |
| (some ⟨some (labels (.tuple .seed)), clean ambient, countedTapes input⟩) | |
| (3 * ((NormalizedSourceInput.bits input).length + 1)) := by | |
| have run := SourceClauseCountMachine.countInTime countTape countTape_injective | |
| (fun label => labels (.count label)) (some (labels (.tuple .seed))) rejected | |
| program (fun label => atLabels (.count label)) (seededTapes input) ambient input.formula | |
| (by simp [countTape, seededTapes, inputTapes, NormalizedSourceInput.bits]) | |
| (by simp [countTape, seededTapes, inputTapes]) | |
| (by simp [countTape, seededTapes, inputTapes]) | |
| simpa only [SourceClauseCountMachine.clean, clean, countTape, countedTapes, seeded_count, | |
| NormalizedSourceInput.bits, NormalizedSourceInput.clauseCount, encodeWord] using run | |
| have initialized : StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels (.tuple .seed)), clean ambient, countedTapes input⟩ | |
| (some ⟨done, clean ambient, readyTapes input⟩) | |
| (NormalizedSourceInput.clauseCount input + 1) := by | |
| have run := TupleInitializationMachine.initializeInTime (σ := A) | |
| (SignedTupleLayout.Tape.extra 0 : Tape width) | |
| (currents width) (remaining width) (destinations_nodup width) count_not_destination | |
| (fun label => labels (.tuple label)) done program | |
| (fun label => by simpa only [instruction] using atLabels (.tuple label)) | |
| (countedTapes input) ambient (NormalizedSourceInput.clauseCount input) | |
| (NormalizedSourceInput.clauseCount_positive input) [] | |
| (by simp only [counted_count, List.append_nil]) | |
| simpa only [TupleInitializationMachine.clean, clean, initializedTapes_eq_ready] using run | |
| have first := StateTransition.EvalsToInTime.trans (TM2.step program) _ _ _ _ _ seeded counted | |
| have full := StateTransition.EvalsToInTime.trans (TM2.step program) _ _ _ _ _ first initialized | |
| simpa only [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using full | |
| theorem count_length_le (input : NormalizedSourceInput.Input) : | |
| NormalizedSourceInput.clauseCount input + 1 ≤ (NormalizedSourceInput.bits input).length := by | |
| rw [NormalizedSourceInput.bits_eq] | |
| simp only [List.length_append, encodeWord_length] | |
| omega | |
| def initializeInTime (input : NormalizedSourceInput.Input) (ambient : A) (register : Option Bool) : | |
| StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels .seed), (ambient, register), inputTapes input⟩ | |
| (some ⟨done, clean ambient, readyTapes input⟩) | |
| (4 * ((NormalizedSourceInput.bits input).length + 1)) := by | |
| let run := initializeExactInTime labels done rejected program atLabels input ambient register | |
| refine | |
| { steps := run.steps | |
| evals_in_steps := run.evals_in_steps | |
| steps_le_m := run.steps_le_m.trans ?_ } | |
| have bounded := count_length_le input | |
| omega | |
| theorem finite_tapes : Finite (Tape width) := inferInstance | |
| theorem finite_state [Finite A] : Finite (State A) := inferInstance | |
| theorem finite_alphabet (key : Tape width) : Finite (Alphabet key) := inferInstance | |
| end | |
| end PerfectCompleteness.NormalizedTargetInitialization | |
| end OAI | |