| import Mathlib |
| import OAI.Computability.MaxCut.PCP.EquationEmit |
| import OAI.Computability.MaxCut.Machines.MachineFiniteTable |
|
|
| namespace OAI |
|
|
| namespace MaxCutGames.Foundations.Hastad.SourceDescriptorEmission |
|
|
| open Turing |
| open Target SourceContexts SourceOccurrences SourceLocalSignature SourceLocalEquation |
| open MaxCutGames.Reduction.CloneGap |
| open MaxCutGames.Foundations.Complexity |
|
|
| def codedEquation (u D : ℕ) (state : LocalInput u D) : |
| Equation (Fin (localKeyEncoding u).size) := |
| mapEquation (localKeyEncoding u).code (SourceLocalEquation.emit u D state) |
|
|
| def descriptorWords (u D : ℕ) (state : LocalInput u D) : List ℕ := |
| MaxCutGames.Reduction.SourceEncoding.equationWords (codedEquation u D state) |
|
|
| def descriptorBits (u D : ℕ) (state : LocalInput u D) : List Bool := |
| encodeWords (descriptorWords u D state) |
|
|
| @[simp] theorem descriptorWords_length (u D : ℕ) (state : LocalInput u D) : |
| (descriptorWords u D state).length = 4 := |
| MaxCutGames.Reduction.SourceEncoding.equationWords_length _ |
|
|
| theorem descriptorBits_length_le (u D : ℕ) (state : LocalInput u D) : |
| (descriptorBits u D state).length ≤ 3 * (localKeyEncoding u).size + 2 := |
| MaxCutGames.Reduction.SourceEncoding.equationBits_length_le _ |
|
|
| @[simp] theorem decode_descriptorBits (u D : ℕ) (state : LocalInput u D) : |
| decodeWords (descriptorBits u D state) = some (descriptorWords u D state) := |
| decodeWords_encodeWords _ |
|
|
| @[simp] theorem parse_descriptorWords (u D : ℕ) (state : LocalInput u D) : |
| MaxCutGames.Reduction.SourceEncoding.parseEquation (localKeyEncoding u).size |
| (descriptorWords u D state) = some (codedEquation u D state, []) := by |
| simpa only [List.append_nil, descriptorWords] using |
| MaxCutGames.Reduction.SourceEncoding.parseEquation_encoded (codedEquation u D state) [] |
|
|
| /-- Decoding the finite address suffixes recovers the exact local equation, |
| including all repeated occurrences and the Boolean correction. -/ |
| theorem decode_codedEquation (u D : ℕ) (state : LocalInput u D) : |
| mapEquation (localKeyEncoding u).code.symm (codedEquation u D state) = |
| SourceLocalEquation.emit u D state := by |
| unfold codedEquation |
| rw [SourceLocalEquation.mapEquation_comp] |
| have h : (localKeyEncoding u).code.symm ∘ (localKeyEncoding u).code = id := by |
| funext key |
| exact (localKeyEncoding u).code.symm_apply_apply key |
| rw [h] |
| rfl |
|
|
| theorem codedEquation_global (F : Formula) (u D : ℕ) (p : SourceIndex F u D) : |
| mapEquation |
| (addressMap F u p.1.1 (sampledVariables F p.1.1 p.1.2) ∘ |
| (localKeyEncoding u).code.symm) |
| (codedEquation u D (ofContext F p.1.1 p.1.2, p.2)) = |
| sourceEquation F u D p := by |
| rw [← SourceLocalEquation.mapEquation_comp, decode_codedEquation] |
| exact (sourceEquation_eq_map_emit F u D p).symm |
|
|
| def descriptorPushBound (u D : ℕ) : ℕ := |
| ((localInputs u D).map (fun state => (descriptorBits u D state).length)).sum |
|
|
| theorem descriptorPushBound_le (u D : ℕ) : |
| descriptorPushBound u D ≤ |
| (localInputs u D).length * (3 * (localKeyEncoding u).size + 2) := by |
| have hlist (states : List (LocalInput u D)) : |
| (states.map (fun state => (descriptorBits u D state).length)).sum ≤ |
| states.length * (3 * (localKeyEncoding u).size + 2) := by |
| induction states with |
| | nil => simp |
| | cons state states ih => |
| simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.add_mul, Nat.one_mul] |
| have hstate := descriptorBits_length_le u D state |
| omega |
| exact hlist (localInputs u D) |
|
|
| variable {K Λ : Type} [DecidableEq K] |
|
|
| /-- Executable state equality is obtained from the explicit radix code. -/ |
| instance localInputDecidableEq (u D : ℕ) : DecidableEq (LocalInput u D) := |
| fun x y => |
| if h : (localInputEncoding u D).code x = (localInputEncoding u D).code y then |
| isTrue ((localInputEncoding u D).code.injective h) |
| else isFalse (fun hxy => h (congrArg (localInputEncoding u D).code hxy)) |
|
|
| /-- Concrete finite-table statement. Its state is the finite signature/tape |
| pair; every branch leaf contains a fixed finite push chain. -/ |
| def emitDescriptor (u D : ℕ) (dst : K) |
| (next : TM2.Stmt (fun _ : K => Bool) Λ (LocalInput u D)) : |
| TM2.Stmt (fun _ : K => Bool) Λ (LocalInput u D) := |
| MachineFiniteTable.emit (Γ := fun _ : K => Bool) dst |
| (descriptorBits u D) (localInputs u D) next |
|
|
| theorem stepAux_emitDescriptor (u D : ℕ) (dst : K) |
| (next : TM2.Stmt (fun _ : K => Bool) Λ (LocalInput u D)) |
| (state : LocalInput u D) (tapes : K → List Bool) : |
| TM2.stepAux (emitDescriptor u D dst next) state tapes = |
| TM2.stepAux next state |
| (Function.update tapes dst (descriptorBits u D state ++ tapes dst)) := |
| MachineFiniteTable.stepAux_emit (Γ := fun _ : K => Bool) dst |
| (descriptorBits u D) (localInputs u D) |
| (mem_localInputs u D) next state tapes |
|
|
| omit [DecidableEq K] in |
| theorem emitDescriptor_push_bound (u D : ℕ) (dst : K) |
| (next : TM2.Stmt (fun _ : K => Bool) Λ (LocalInput u D)) : |
| Runtime.statementPushBound (emitDescriptor u D dst next) ≤ |
| descriptorPushBound u D + Runtime.statementPushBound next := |
| MachineFiniteTable.emit_push_bound (Γ := fun _ : K => Bool) dst |
| (descriptorBits u D) (localInputs u D) next |
|
|
| /-- One actual TM2 transition emits the descriptor and enters the chosen |
| continuation label. Only a program-definition equation is required. -/ |
| def emitDescriptorInTime (u D : ℕ) (dst : K) |
| (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (LocalInput u D)) |
| (label exitLabel : Λ) |
| (atLabel : program label = emitDescriptor u D dst (.goto (fun _ => exitLabel))) |
| (state : LocalInput u D) (tapes : K → List Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some label, state, tapes⟩ |
| (some ⟨some exitLabel, state, |
| Function.update tapes dst (descriptorBits u D state ++ tapes dst)⟩) 1 := |
| MachineFiniteTable.emitInTime (Γ := fun _ : K => Bool) dst |
| (descriptorBits u D) (localInputs u D) |
| (mem_localInputs u D) program label exitLabel atLabel state tapes |
|
|
| theorem descriptor_output_frame (u D : ℕ) (dst : K) |
| (state : LocalInput u D) (tapes : K → List Bool) (k : K) (h : k ≠ dst) : |
| (Function.update tapes dst (descriptorBits u D state ++ tapes dst)) k = tapes k := |
| MachineFiniteTable.output_frame (Γ := fun _ : K => Bool) dst |
| (descriptorBits u D) state tapes k h |
|
|
| end MaxCutGames.Foundations.Hastad.SourceDescriptorEmission |
|
|
| namespace MaxCutGames.Foundations.Hastad.SourceTestEmit |
|
|
| open Turing |
| open Target SourceContexts SourceOccurrences SourceLocalSignature SourceLocalEquation |
| open SourceAddressDescriptors SourceEquationEmit |
| open MaxCutGames.Reduction.CloneGap |
| open Complexity |
|
|
| abbrev Label (u D : ℕ) := Unit ⊕ (LocalInput u D × SourceEquationEmit.Label) |
| abbrev State (u D : ℕ) := LocalInput u D × Option Bool |
|
|
| def localEquation (u D : ℕ) (state : LocalInput u D) : Equation Descriptor := |
| mapEquation (descriptor u) (SourceLocalEquation.emit u D state) |
|
|
| def bodyLabel (u D : ℕ) (state : LocalInput u D) (label : SourceEquationEmit.Label) : |
| Label u D := .inr (state, label) |
|
|
| variable {K : Type} [DecidableEq K] |
|
|
| def program (u D : ℕ) (sources : Fin 3 → K) (destination scratch : K) |
| (exit : Option (Label u D)) : |
| Label u D → TM2.Stmt (fun _ : K => Bool) (Label u D) (State u D) |
| | .inl _ => .goto (fun state => bodyLabel u D state.1 .seed) |
| | .inr (state, label) => |
| SourceEquationEmit.statement sources destination scratch (localEquation u D state) |
| (bodyLabel u D state) exit label |
|
|
| /-- The table selector is one real transition; every subsequent copy/push |
| transition belongs to the same fixed program. -/ |
| theorem testTrace (u D : ℕ) (sources : Fin 3 → K) (destination scratch : K) |
| (sourceDestination : ∀ side, sources side ≠ destination) |
| (sourceScratch : ∀ side, sources side ≠ scratch) |
| (destinationScratch : destination ≠ scratch) (exit : Option (Label u D)) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → ℕ) |
| (sourceWords : ∀ side, base (sources side) = encodeWord (values side)) |
| (scratchEmpty : base scratch = []) (register : Option Bool) : |
| (MachineComposition.advance (TM2.step (program u D sources destination scratch exit)))^[ |
| SourceEquationEmit.steps values (localEquation u D state) + 1] |
| (some ⟨some (.inl ()), (state, register), base⟩) = |
| some ⟨exit, (state, none), |
| prefixTapes destination base (words values (localEquation u D state))⟩ := by |
| rw [Function.iterate_succ_apply] |
| change (MachineComposition.advance (TM2.step (program u D sources destination scratch exit)))^[ |
| SourceEquationEmit.steps values (localEquation u D state)] |
| (some ⟨some (bodyLabel u D state .seed), (state, register), base⟩) = _ |
| exact SourceEquationEmit.equationTrace sources destination scratch sourceDestination |
| sourceScratch destinationScratch (localEquation u D state) (bodyLabel u D state) exit |
| (program u D sources destination scratch exit) (fun _ => rfl) |
| base values sourceWords scratchEmpty state register |
|
|
| def testInTime (u D : ℕ) (sources : Fin 3 → K) (destination scratch : K) |
| (sourceDestination : ∀ side, sources side ≠ destination) |
| (sourceScratch : ∀ side, sources side ≠ scratch) |
| (destinationScratch : destination ≠ scratch) (exit : Option (Label u D)) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → ℕ) |
| (sourceWords : ∀ side, base (sources side) = encodeWord (values side)) |
| (scratchEmpty : base scratch = []) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step (program u D sources destination scratch exit)) |
| ⟨some (.inl ()), (state, register), base⟩ |
| (some ⟨exit, (state, none), |
| prefixTapes destination base (words values (localEquation u D state))⟩) |
| (SourceEquationEmit.steps values (localEquation u D state) + 1) where |
| steps := SourceEquationEmit.steps values (localEquation u D state) + 1 |
| evals_in_steps := testTrace u D sources destination scratch sourceDestination sourceScratch |
| destinationScratch exit state base values sourceWords scratchEmpty register |
| steps_le_m := Nat.le_refl _ |
|
|
| def sourceTestInTime (F : Formula) (u D : ℕ) (p : SourceIndex F u D) |
| (sources : Fin 3 → K) (destination scratch : K) |
| (sourceDestination : ∀ side, sources side ≠ destination) |
| (sourceScratch : ∀ side, sources side ≠ scratch) |
| (destinationScratch : destination ≠ scratch) (exit : Option (Label u D)) |
| (base : K → List Bool) |
| (sourceWords : ∀ side, base (sources side) = encodeWord |
| (baseValue F u p.1.1 (sampledVariables F p.1.1 p.1.2) side)) |
| (scratchEmpty : base scratch = []) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step (program u D sources destination scratch exit)) |
| ⟨some (.inl ()), ((ofContext F p.1.1 p.1.2, p.2), register), base⟩ |
| (some ⟨exit, ((ofContext F p.1.1 p.1.2, p.2), none), |
| prefixTapes destination base |
| (MaxCutGames.Reduction.SourceEncoding.equationWords (sourceEquation F u D p))⟩) |
| (6 * nBits F u + 17) where |
| steps := SourceEquationEmit.steps |
| (baseValue F u p.1.1 (sampledVariables F p.1.1 p.1.2)) |
| (localEquation u D (ofContext F p.1.1 p.1.2, p.2)) + 1 |
| evals_in_steps := by |
| rw [sourceEquation_words] |
| exact testTrace u D sources destination scratch sourceDestination sourceScratch |
| destinationScratch exit (ofContext F p.1.1 p.1.2, p.2) base |
| (baseValue F u p.1.1 (sampledVariables F p.1.1 p.1.2)) sourceWords scratchEmpty register |
| steps_le_m := by |
| have h := equation_emit_steps_le F u p.1.1 (sampledVariables F p.1.1 p.1.2) |
| (localEquation u D (ofContext F p.1.1 p.1.2, p.2)) |
| change _ + 1 ≤ _ |
| unfold SourceEquationEmit.steps |
| omega |
|
|
| end MaxCutGames.Foundations.Hastad.SourceTestEmit |
|
|
| namespace MaxCutGames.Foundations.Hastad.SourceTestAppend |
|
|
| open Turing Complexity |
| open Target SourceContexts SourceOccurrences SourceLocalSignature SourceLocalEquation |
| open SourceAddressDescriptors SourceEquationEmit SourceTestEmit |
|
|
| inductive Label (u D : Nat) |
| | test (label : SourceTestEmit.Label u D) |
| | append |
| deriving DecidableEq, Fintype |
|
|
| abbrev State (u D : Nat) := SourceTestEmit.State u D |
|
|
| structure Layout (K : Type) where |
| sources : Fin 3 → K |
| temporary : K |
| scratch : K |
| accumulator : K |
| sourceTemporary : ∀ side, sources side ≠ temporary |
| sourceScratch : ∀ side, sources side ≠ scratch |
| sourceAccumulator : ∀ side, sources side ≠ accumulator |
| temporaryScratch : temporary ≠ scratch |
| temporaryAccumulator : temporary ≠ accumulator |
| scratchAccumulator : scratch ≠ accumulator |
|
|
| def equationBits (u D : Nat) (values : Fin 3 → Nat) (state : LocalInput u D) : List Bool := |
| encodeWords (words values (localEquation u D state)) |
|
|
| def steps (u D : Nat) (values : Fin 3 → Nat) (state : LocalInput u D) : Nat := |
| SourceEquationEmit.steps values (localEquation u D state) + 1 + |
| (equationBits u D values state).length + 1 |
|
|
| variable {K Λ : Type} [DecidableEq K] |
|
|
| def bodyLabel (u D : Nat) (labels : Label u D → Λ) (state : LocalInput u D) |
| (label : SourceEquationEmit.Label) : Λ := |
| labels (.test (SourceTestEmit.bodyLabel u D state label)) |
|
|
| def statement (u D : Nat) (layout : Layout K) (labels : Label u D → Λ) (exit : Option Λ) : |
| Label u D → TM2.Stmt (fun _ : K => Bool) Λ (State u D) |
| | .test (.inl _) => .goto (fun state => bodyLabel u D labels state.1 .seed) |
| | .test (.inr (state, label)) => |
| SourceEquationEmit.statement layout.sources layout.temporary layout.scratch |
| (localEquation u D state) (bodyLabel u D labels state) (some (labels .append)) label |
| | .append => Reduction.MachineTransfer.loopAt layout.temporary layout.accumulator id false |
| (labels .append) exit |
|
|
| def program (u D : Nat) (layout : Layout K) (exit : Option (Label u D)) : |
| Label u D → TM2.Stmt (fun _ : K => Bool) (Label u D) (State u D) := |
| statement u D layout id exit |
|
|
| def resultTapes (layout : Layout K) (base : K → List Bool) (bits : List Bool) : K → List Bool := |
| Function.update base layout.accumulator (bits.reverse ++ base layout.accumulator) |
|
|
| theorem resultTapes_other (layout : Layout K) (base : K → List Bool) (bits : List Bool) |
| (k : K) (hk : k ≠ layout.accumulator) : resultTapes layout base bits k = base k := by |
| simp [resultTapes, hk] |
|
|
| theorem resultTapes_source (layout : Layout K) (base : K → List Bool) (bits : List Bool) |
| (side : Fin 3) : resultTapes layout base bits (layout.sources side) = base (layout.sources side) := |
| resultTapes_other layout base bits _ (layout.sourceAccumulator side) |
|
|
| theorem resultTapes_temporary (layout : Layout K) (base : K → List Bool) (bits : List Bool) : |
| resultTapes layout base bits layout.temporary = base layout.temporary := |
| resultTapes_other layout base bits _ layout.temporaryAccumulator |
|
|
| theorem resultTapes_scratch (layout : Layout K) (base : K → List Bool) (bits : List Bool) : |
| resultTapes layout base bits layout.scratch = base layout.scratch := |
| resultTapes_other layout base bits _ layout.scratchAccumulator |
|
|
| /-- Placement-aware finite selection plus actual equation emission. -/ |
| theorem emitTrace (u D : Nat) (layout : Layout K) (labels : Label u D → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ label, p (labels label) = statement u D layout labels exit label) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (register : Option Bool) : |
| (MachineComposition.advance (TM2.step p))^[ |
| SourceEquationEmit.steps values (localEquation u D state) + 1] |
| (some ⟨some (labels (.test (.inl ()))), (state, register), base⟩) = |
| some ⟨some (labels .append), (state, none), |
| prefixTapes layout.temporary base (words values (localEquation u D state))⟩ := by |
| have select : TM2.step p |
| ⟨some (labels (.test (.inl ()))), (state, register), base⟩ = |
| some ⟨some (bodyLabel u D labels state .seed), (state, register), base⟩ := by |
| change some (TM2.stepAux (p (labels (.test (.inl ())))) (state, register) base) = _ |
| rw [atLabels] |
| rfl |
| rw [Function.iterate_succ_apply] |
| change (MachineComposition.advance (TM2.step p))^[ |
| SourceEquationEmit.steps values (localEquation u D state)] |
| (TM2.step p ⟨some (labels (.test (.inl ()))), (state, register), base⟩) = _ |
| rw [select] |
| exact SourceEquationEmit.equationTrace layout.sources layout.temporary layout.scratch |
| layout.sourceTemporary layout.sourceScratch layout.temporaryScratch (localEquation u D state) |
| (bodyLabel u D labels state) (some (labels .append)) p |
| (fun label => atLabels (.test (SourceTestEmit.bodyLabel u D state label))) |
| base values sourceWords scratchEmpty state register |
|
|
| /-- Exact one-record append trace in an arbitrary caller program. -/ |
| theorem appendTrace (u D : Nat) (layout : Layout K) (labels : Label u D → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ label, p (labels label) = statement u D layout labels exit label) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (register : Option Bool) : |
| (MachineComposition.advance (TM2.step p))^[steps u D values state] |
| (some ⟨some (labels (.test (.inl ()))), (state, register), base⟩) = |
| some ⟨exit, (state, none), resultTapes layout base (equationBits u D values state)⟩ := by |
| let emitted := prefixTapes layout.temporary base (words values (localEquation u D state)) |
| have hemit := emitTrace u D layout labels exit p atLabels state base values sourceWords |
| scratchEmpty register |
| have htemp : emitted layout.temporary = equationBits u D values state := by |
| simp [emitted, prefixTapes, equationBits, temporaryEmpty] |
| have hacc : emitted layout.accumulator = base layout.accumulator := |
| prefixTapes_other _ _ _ _ (Ne.symm layout.temporaryAccumulator) |
| have hfinal : Reduction.MachineTransfer.tapesAt layout.temporary layout.accumulator emitted [] |
| ((equationBits u D values state).reverse ++ base layout.accumulator) = |
| resultTapes layout base (equationBits u D values state) := by |
| funext k |
| by_cases hka : k = layout.accumulator |
| · subst k |
| simp [Reduction.MachineTransfer.tapesAt, resultTapes] |
| · by_cases hkt : k = layout.temporary |
| · subst k |
| simp [Reduction.MachineTransfer.tapesAt, resultTapes, layout.temporaryAccumulator, |
| temporaryEmpty] |
| · simp [Reduction.MachineTransfer.tapesAt, resultTapes, emitted, prefixTapes, hka, hkt] |
| have transferred := Reduction.MachineTransfer.transferAt_fromTapes |
| (Γ := fun _ : K => Bool) (σ := LocalInput u D) |
| layout.temporary layout.accumulator layout.temporaryAccumulator id false (labels .append) |
| exit p (by simpa only [statement] using atLabels .append) emitted state none |
| change (MachineComposition.advance (TM2.step p))^[(emitted layout.temporary).length + 1] |
| (some ⟨some (labels .append), (state, none), emitted⟩) = _ at transferred |
| rw [htemp, hacc] at transferred |
| simp only [List.map_id] at transferred |
| rw [hfinal] at transferred |
| rw [show steps u D values state = ((equationBits u D values state).length + 1) + |
| (SourceEquationEmit.steps values (localEquation u D state) + 1) by unfold steps; omega, |
| Function.iterate_add_apply, hemit] |
| exact transferred |
|
|
| def appendInTime (u D : Nat) (layout : Layout K) (labels : Label u D → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ label, p (labels label) = statement u D layout labels exit label) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (.test (.inl ()))), (state, register), base⟩ |
| (some ⟨exit, (state, none), resultTapes layout base (equationBits u D values state)⟩) |
| (steps u D values state) where |
| steps := steps u D values state |
| evals_in_steps := appendTrace u D layout labels exit p atLabels state base values |
| sourceWords scratchEmpty temporaryEmpty register |
| steps_le_m := Nat.le_refl _ |
|
|
| def programInTime (u D : Nat) (layout : Layout K) (exit : Option (Label u D)) |
| (state : LocalInput u D) (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step (program u D layout exit)) |
| ⟨some (.test (.inl ())), (state, register), base⟩ |
| (some ⟨exit, (state, none), resultTapes layout base (equationBits u D values state)⟩) |
| (steps u D values state) := |
| appendInTime u D layout id exit (program u D layout exit) (fun _ => rfl) state base values |
| sourceWords scratchEmpty temporaryEmpty register |
|
|
| def sourceAppendInTime (F : Formula) (u D : Nat) (occurrence : SourceIndex F u D) |
| (layout : Layout K) (labels : Label u D → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ label, p (labels label) = statement u D layout labels exit label) |
| (base : K → List Bool) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord |
| (baseValue F u occurrence.1.1 (sampledVariables F occurrence.1.1 occurrence.1.2) side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (.test (.inl ()))), |
| ((ofContext F occurrence.1.1 occurrence.1.2, occurrence.2), register), base⟩ |
| (some ⟨exit, ((ofContext F occurrence.1.1 occurrence.1.2, occurrence.2), none), |
| resultTapes layout base (encodeWords |
| (MaxCutGames.Reduction.SourceEncoding.equationWords (sourceEquation F u D occurrence)))⟩) |
| (9 * nBits F u + 20) where |
| steps := steps u D |
| (baseValue F u occurrence.1.1 (sampledVariables F occurrence.1.1 occurrence.1.2)) |
| (ofContext F occurrence.1.1 occurrence.1.2, occurrence.2) |
| evals_in_steps := by |
| rw [sourceEquation_words] |
| exact appendTrace u D layout labels exit p atLabels |
| (ofContext F occurrence.1.1 occurrence.1.2, occurrence.2) base |
| (baseValue F u occurrence.1.1 (sampledVariables F occurrence.1.1 occurrence.1.2)) |
| sourceWords scratchEmpty temporaryEmpty register |
| steps_le_m := by |
| have he := equation_emit_steps_le F u occurrence.1.1 |
| (sampledVariables F occurrence.1.1 occurrence.1.2) |
| (localEquation u D (ofContext F occurrence.1.1 occurrence.1.2, occurrence.2)) |
| have hl := MaxCutGames.Reduction.SourceEncoding.equationBits_length_le |
| (sourceEquation F u D occurrence) |
| rw [sourceEquation_words] at hl |
| unfold steps SourceEquationEmit.steps equationBits |
| dsimp only [localEquation] at he hl ⊢ |
| omega |
|
|
| abbrev Tape := Fin 3 ⊕ Fin 3 |
|
|
| def standardLayout : Layout Tape where |
| sources := Sum.inl |
| temporary := .inr 0 |
| scratch := .inr 1 |
| accumulator := .inr 2 |
| sourceTemporary _ := Sum.inl_ne_inr |
| sourceScratch _ := Sum.inl_ne_inr |
| sourceAccumulator _ := Sum.inl_ne_inr |
| temporaryScratch := by decide |
| temporaryAccumulator := by decide |
| scratchAccumulator := by decide |
|
|
| def machine (u D : Nat) (initial : LocalInput u D) : FinTM2 where |
| K := Tape |
| k₀ := .inl 0 |
| k₁ := .inr 2 |
| Γ _ := Bool |
| Λ := Label u D |
| main := .test (.inl ()) |
| σ := State u D |
| initialState := (initial, none) |
| m := program u D standardLayout none |
|
|
| def machineInTime (u D : Nat) (initial state : LocalInput u D) |
| (base : Tape → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (.inl side) = encodeWord (values side)) |
| (scratchEmpty : base (.inr 1) = []) (temporaryEmpty : base (.inr 0) = []) |
| (register : Option Bool) : |
| StateTransition.EvalsToInTime (machine u D initial).step |
| ⟨some (Label.test (.inl ())), (state, register), base⟩ |
| (some ⟨none, (state, none), resultTapes standardLayout base (equationBits u D values state)⟩) |
| (steps u D values state) := |
| programInTime u D standardLayout none state base values sourceWords scratchEmpty temporaryEmpty register |
|
|
| end MaxCutGames.Foundations.Hastad.SourceTestAppend |
|
|
| /-! An actual fixed finite traversal of all query/noise tapes. The finite |
| control contains one branch for each prescribed tape. The input-dependent |
| signature and the three address bases remain in registers throughout. -/ |
|
|
| namespace MaxCutGames.Foundations.Hastad.SourceQueryLoop |
|
|
| open Turing Complexity Target SourceContexts SourceOccurrences |
| open SourceLocalSignature SourceLocalEquation |
|
|
| abbrev Query (u D : Nat) := SourceTape.TestTape (I u) (J u) D |
| abbrev State (u D : Nat) := SourceTestAppend.State u D |
|
|
| inductive Label (u D n : Nat) |
| | load (index : Fin (n + 1)) |
| | emit (index : Fin n) (label : SourceTestAppend.Label u D) |
| deriving DecidableEq, Fintype |
|
|
| variable {K Λ : Type} [DecidableEq K] |
|
|
| def finish (u D : Nat) (exit : Option Λ) : |
| TM2.Stmt (fun _ : K => Bool) Λ (State u D) := |
| match exit with |
| | none => .halt |
| | some label => .goto fun _ => label |
|
|
| def statement (u D n : Nat) (queries : Nat → Query u D) |
| (layout : SourceTestAppend.Layout K) (labels : Label u D n → Λ) (exit : Option Λ) : |
| Label u D n → TM2.Stmt (fun _ : K => Bool) Λ (State u D) |
| | .load index => |
| if h : index.val < n then |
| .load (fun state => ((state.1.1, queries index.val), none)) |
| (.goto fun _ => labels (.emit ⟨index.val, h⟩ (.test (.inl ())))) |
| else finish u D exit |
| | .emit index label => |
| SourceTestAppend.statement u D layout (fun l => labels (.emit index l)) |
| (some (labels (.load ⟨index.val + 1, by omega⟩))) label |
|
|
| def prefixBits (u D : Nat) (queries : Nat → Query u D) |
| (values : Fin 3 → Nat) (signature : Signature u) : Nat → List Bool |
| | 0 => [] |
| | n + 1 => prefixBits u D queries values signature n ++ |
| SourceTestAppend.equationBits u D values (signature, queries n) |
|
|
| def prefixSteps (u D : Nat) (queries : Nat → Query u D) |
| (values : Fin 3 → Nat) (signature : Signature u) : Nat → Nat |
| | 0 => 0 |
| | n + 1 => prefixSteps u D queries values signature n + |
| (SourceTestAppend.steps u D values (signature, queries n) + 1) |
|
|
| theorem resultTapes_append (layout : SourceTestAppend.Layout K) (base : K → List Bool) |
| (first second : List Bool) : |
| SourceTestAppend.resultTapes layout |
| (SourceTestAppend.resultTapes layout base first) second = |
| SourceTestAppend.resultTapes layout base (first ++ second) := by |
| funext k |
| by_cases hk : k = layout.accumulator |
| · subst k |
| simp [SourceTestAppend.resultTapes, List.reverse_append, List.append_assoc] |
| · simp [SourceTestAppend.resultTapes, hk] |
|
|
| theorem prefixTrace (u D n : Nat) (queries : Nat → Query u D) |
| (layout : SourceTestAppend.Layout K) (labels : Label u D n → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ l, p (labels l) = statement u D n queries layout labels exit l) |
| (signature : Signature u) (initialQuery : Query u D) |
| (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (r : Nat) (hr : r ≤ n) : |
| ∃ lastQuery : Query u D, |
| (MachineComposition.advance (TM2.step p))^[prefixSteps u D queries values signature r] |
| (some ⟨some (labels (.load ⟨0, by omega⟩)), ((signature, initialQuery), none), base⟩) = |
| some ⟨some (labels (.load ⟨r, by omega⟩)), ((signature, lastQuery), none), |
| SourceTestAppend.resultTapes layout base (prefixBits u D queries values signature r)⟩ := by |
| induction r with |
| | zero => |
| refine ⟨initialQuery, ?_⟩ |
| simp [prefixSteps, prefixBits, SourceTestAppend.resultTapes] |
| | succ r ih => |
| obtain ⟨lastQuery, hprevious⟩ := ih (by omega) |
| have hlt : r < n := by omega |
| let current := SourceTestAppend.resultTapes layout base |
| (prefixBits u D queries values signature r) |
| have hselect : TM2.step p |
| ⟨some (labels (.load ⟨r, by omega⟩)), ((signature, lastQuery), none), current⟩ = |
| some ⟨some (labels (.emit ⟨r, hlt⟩ (.test (.inl ())))), |
| ((signature, queries r), none), current⟩ := by |
| change some (TM2.stepAux (p (labels (.load ⟨r, by omega⟩))) _ _) = _ |
| rw [atLabels] |
| simp only [statement, hlt, ↓reduceDIte, TM2.stepAux] |
| have hbody := SourceTestAppend.appendTrace u D layout |
| (fun l => labels (.emit ⟨r, hlt⟩ l)) |
| (some (labels (.load ⟨r + 1, by omega⟩))) p |
| (fun l => atLabels (.emit ⟨r, hlt⟩ l)) (signature, queries r) current values |
| (fun side => (SourceTestAppend.resultTapes_source layout base _ side).trans |
| (sourceWords side)) |
| ((SourceTestAppend.resultTapes_scratch layout base _).trans scratchEmpty) |
| ((SourceTestAppend.resultTapes_temporary layout base _).trans temporaryEmpty) none |
| refine ⟨queries r, ?_⟩ |
| rw [show prefixSteps u D queries values signature (r + 1) = |
| (SourceTestAppend.steps u D values (signature, queries r) + 1) + |
| prefixSteps u D queries values signature r by rw [prefixSteps]; omega, |
| Function.iterate_add_apply, hprevious, Function.iterate_succ_apply] |
| change (MachineComposition.advance (TM2.step p))^[ |
| SourceTestAppend.steps u D values (signature, queries r)] |
| (TM2.step p ⟨some (labels (.load ⟨r, by omega⟩)), |
| ((signature, lastQuery), none), current⟩) = _ |
| rw [hselect, hbody] |
| rw [show current = SourceTestAppend.resultTapes layout base |
| (prefixBits u D queries values signature r) from rfl, resultTapes_append] |
| rfl |
|
|
| theorem prefixSteps_le (u D n B : Nat) (queries : Nat → Query u D) |
| (values : Fin 3 → Nat) (signature : Signature u) |
| (hbound : ∀ i, i < n → SourceTestAppend.steps u D values (signature, queries i) ≤ B) : |
| prefixSteps u D queries values signature n ≤ n * (B + 1) := by |
| induction n with |
| | zero => simp [prefixSteps] |
| | succ n ih => |
| have hp := ih (fun i hi => hbound i (by omega)) |
| have hb := hbound n (by omega) |
| rw [prefixSteps, Nat.succ_mul] |
| omega |
|
|
| /-- The complete finite traversal, including its final exit transition. -/ |
| theorem loopInTime (u D n B : Nat) (queries : Nat → Query u D) |
| (layout : SourceTestAppend.Layout K) (labels : Label u D n → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State u D)) |
| (atLabels : ∀ l, p (labels l) = statement u D n queries layout labels exit l) |
| (signature : Signature u) (initialQuery : Query u D) |
| (base : K → List Bool) (values : Fin 3 → Nat) |
| (sourceWords : ∀ side, base (layout.sources side) = encodeWord (values side)) |
| (scratchEmpty : base layout.scratch = []) (temporaryEmpty : base layout.temporary = []) |
| (hbound : ∀ i, i < n → SourceTestAppend.steps u D values (signature, queries i) ≤ B) : |
| ∃ lastQuery : Query u D, |
| Nonempty (StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (.load ⟨0, by omega⟩)), ((signature, initialQuery), none), base⟩ |
| (some ⟨exit, ((signature, lastQuery), none), |
| SourceTestAppend.resultTapes layout base (prefixBits u D queries values signature n)⟩) |
| (n * (B + 1) + 1)) := by |
| obtain ⟨lastQuery, hprefix⟩ := prefixTrace u D n queries layout labels exit p atLabels |
| signature initialQuery base values sourceWords scratchEmpty temporaryEmpty n (Nat.le_refl n) |
| refine ⟨lastQuery, ⟨{ |
| steps := prefixSteps u D queries values signature n + 1 |
| evals_in_steps := ?_ |
| steps_le_m := ?_ }⟩⟩ |
| · change (MachineComposition.advance (TM2.step p))^[ |
| prefixSteps u D queries values signature n + 1] _ = _ |
| rw [Function.iterate_succ_apply', hprefix] |
| rw [MachineComposition.advance_some] |
| change some (TM2.stepAux (p (labels (.load ⟨n, by omega⟩))) _ _) = _ |
| rw [atLabels] |
| simp only [statement, Nat.lt_irrefl, ↓reduceDIte] |
| cases exit <;> rfl |
| · exact Nat.add_le_add_right (prefixSteps_le u D n B queries values signature hbound) 1 |
|
|
| end MaxCutGames.Foundations.Hastad.SourceQueryLoop |
|
|
| end OAI |
|
|
