| import Mathlib |
| import OAI.Computability.MaxCut.Machines.MachineExpanderFamilyAffine |
|
|
| namespace OAI |
|
|
| /-! |
| |
|
|
| Only the five actual row inputs are stored. Every address, table return and |
| finite control value below is computed from those inputs. The thirteen tape |
| frames use the existing phase-output functions. These are data identities and |
| size bounds, not assumed machine executions. |
| -/ |
|
|
| namespace MaxCutGames.Foundations.Complexity.MachineExpanderRow |
|
|
| open PCP.ExpanderTables PCP.ExpanderRowControl PCP.ExpanderTableWords |
|
|
| structure RowData (v d : Nat) where |
| oldTable : Table v (degree d) |
| smallTable : Table (cloudSize d) d |
| inputVertex : Fin v |
| inputCloud : Fin (cloudSize d) |
| inputPort : Fin (degree d) |
|
|
| def rowData {v d : Nat} (G : Table v (degree d)) (H : Table (cloudSize d) d) |
| (vertex : Fin v) (cloud : Fin (cloudSize d)) (port : Fin (degree d)) : RowData v d := |
| ⟨G, H, vertex, cloud, port⟩ |
|
|
| namespace RowData |
|
|
| variable {v d : Nat} (r : RowData v d) |
|
|
| def control0 : Control d := start r.smallTable r.inputCloud r.inputPort |
| def firstRow : Fin (v * degree d) := rowIndex v (degree d) (r.inputVertex, firstOffset r.control0) |
| def firstValue : Nat := (reverseIndex r.oldTable r.firstRow).val |
| def firstPair : Fin v × Fin (degree d) := lookup r.oldTable (r.inputVertex, firstOffset r.control0) |
| def firstVertex : Fin v := r.firstPair.1 |
| def firstReturn : Fin (degree d) := r.firstPair.2 |
| def control1 : Control d := receiveFirst r.control0 r.firstReturn |
| def secondRow : Fin (v * degree d) := rowIndex v (degree d) (r.firstVertex, secondOffset r.control1) |
| def secondValue : Nat := (reverseIndex r.oldTable r.secondRow).val |
| def secondPair : Fin v × Fin (degree d) := lookup r.oldTable (r.firstVertex, secondOffset r.control1) |
| def secondVertex : Fin v := r.secondPair.1 |
| def secondReturn : Fin (degree d) := r.secondPair.2 |
| def control2 : Control d := receiveSecond r.smallTable r.control1 r.secondReturn |
| def query1 : Nat := firstAddress r.inputVertex.val r.control0 |
| def query2 : Nat := secondAddress r.firstVertex.val r.control1 |
| def finalValue : Nat := outputAddress r.secondVertex.val r.control2 |
| def tableLength : Nat := (encodeWords (rotationWords r.oldTable)).length |
|
|
| theorem query1_eq_firstRow : r.query1 = r.firstRow.val := |
| firstAddress_eq_rowIndex r.inputVertex r.control0 |
|
|
| theorem query2_eq_secondRow : r.query2 = r.secondRow.val := |
| secondAddress_eq_rowIndex r.firstVertex r.control1 |
|
|
| @[simp] theorem firstValue_div_degree : r.firstValue / degree d = r.firstVertex.val := rfl |
| @[simp] theorem firstValue_mod_degree : r.firstValue % degree d = r.firstReturn.val := rfl |
| @[simp] theorem secondValue_div_degree : r.secondValue / degree d = r.secondVertex.val := rfl |
| @[simp] theorem secondValue_mod_degree : r.secondValue % degree d = r.secondReturn.val := rfl |
|
|
| theorem firstReturn_eq_residue (positive : 0 < d) : |
| r.firstReturn = MachineFixedDivMod.residue (degree d) (Nat.mul_pos positive positive) |
| r.firstValue := Fin.ext rfl |
|
|
| theorem secondReturn_eq_residue (positive : 0 < d) : |
| r.secondReturn = MachineFixedDivMod.residue (degree d) (Nat.mul_pos positive positive) |
| r.secondValue := Fin.ext rfl |
|
|
| theorem receiveFirst_residue_eq_control1 (positive : 0 < d) : |
| receiveFirst r.control0 (MachineFixedDivMod.residue (degree d) |
| (Nat.mul_pos positive positive) r.firstValue) = r.control1 := by |
| rw [← r.firstReturn_eq_residue positive] |
| rfl |
|
|
| theorem receiveSecond_residue_eq_control2 (positive : 0 < d) : |
| receiveSecond r.smallTable r.control1 (MachineFixedDivMod.residue (degree d) |
| (Nat.mul_pos positive positive) r.secondValue) = r.control2 := by |
| rw [← r.secondReturn_eq_residue positive] |
| rfl |
|
|
| theorem firstSelected : (rotationWords r.oldTable)[r.query1]? = some r.firstValue := by |
| rw [query1_eq_firstRow] |
| exact rotationWords_getElem? r.oldTable r.firstRow |
|
|
| theorem secondSelected : (rotationWords r.oldTable)[r.query2]? = some r.secondValue := by |
| rw [query2_eq_secondRow] |
| exact rotationWords_getElem? r.oldTable r.secondRow |
|
|
| theorem evaluateRow_eq : evaluateRow r.oldTable r.smallTable r.inputVertex r.inputCloud r.inputPort = |
| (r.secondVertex, r.control2) := rfl |
|
|
| theorem finalValue_eq_step_reverseIndex : |
| r.finalValue = (reverseIndex (step r.oldTable r.smallTable) |
| (rowIndex (v * cloudSize d) (degree d) |
| (rowIndex v (cloudSize d) (r.inputVertex, r.inputCloud), r.inputPort))).val := by |
| simpa only [evaluateRow_eq, finalValue] using outputAddress_eq_step_reverseIndex |
| r.oldTable r.smallTable r.inputVertex r.inputCloud r.inputPort |
|
|
| theorem rows_le_tableLength : v * degree d ≤ r.tableLength := by |
| simp only [tableLength, encodeWords_length, rotationWords_length] |
| omega |
|
|
| theorem query1_le_tableLength : r.query1 ≤ r.tableLength := by |
| rw [query1_eq_firstRow] |
| exact r.firstRow.isLt.le.trans r.rows_le_tableLength |
|
|
| theorem query2_le_tableLength : r.query2 ≤ r.tableLength := by |
| rw [query2_eq_secondRow] |
| exact r.secondRow.isLt.le.trans r.rows_le_tableLength |
|
|
| theorem firstValue_le_tableLength : r.firstValue ≤ r.tableLength := |
| (reverseIndex r.oldTable r.firstRow).isLt.le.trans r.rows_le_tableLength |
|
|
| theorem secondValue_le_tableLength : r.secondValue ≤ r.tableLength := |
| (reverseIndex r.oldTable r.secondRow).isLt.le.trans r.rows_le_tableLength |
|
|
| theorem inputVertex_le_tableLength : r.inputVertex.val ≤ r.tableLength := by |
| have hq : 1 ≤ degree d := Nat.zero_lt_of_lt r.inputPort.isLt |
| have hv : v ≤ v * degree d := by simpa using Nat.mul_le_mul_left v hq |
| exact r.inputVertex.isLt.le.trans (hv.trans r.rows_le_tableLength) |
|
|
| theorem firstVertex_le_tableLength : r.firstVertex.val ≤ r.tableLength := by |
| rw [← firstValue_div_degree] |
| exact (Nat.div_le_self r.firstValue (degree d)).trans r.firstValue_le_tableLength |
|
|
| theorem secondVertex_le_tableLength : r.secondVertex.val ≤ r.tableLength := by |
| rw [← secondValue_div_degree] |
| exact (Nat.div_le_self r.secondValue (degree d)).trans r.secondValue_le_tableLength |
|
|
| theorem firstReturn_le_tableLength : r.firstReturn.val ≤ r.tableLength := by |
| rw [← firstValue_mod_degree] |
| exact (Nat.mod_le r.firstValue (degree d)).trans r.firstValue_le_tableLength |
|
|
| theorem secondReturn_le_tableLength : r.secondReturn.val ≤ r.tableLength := by |
| rw [← secondValue_mod_degree] |
| exact (Nat.mod_le r.secondValue (degree d)).trans r.secondValue_le_tableLength |
|
|
| end RowData |
|
|
| variable {v d : Nat} |
|
|
| /-- Complete explicit tape contents; all three scratch roles omitted here are empty. -/ |
| def frameContents (r : RowData v d) (output : List Bool) |
| (qr qi lo q1 q2 r1 r2 : List Bool) : Tape → List Bool |
| | .inputVertex => encodeWord r.inputVertex.val |
| | .table => encodeWords (rotationWords r.oldTable) |
| | .output => output |
| | .queryReverse => qr |
| | .queryIndex => qi |
| | .lookupOutput => lo |
| | .quotientFirst => q1 |
| | .quotientSecond => q2 |
| | .remainderFirst => r1 |
| | .remainderSecond => r2 |
| | _ => [] |
|
|
| def frame0 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| frameContents r output [] [] [] [] [] [] [] |
| def frame1 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| initializedTapes id (frame0 r output) |
| def frame2 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| emittedWord .queryReverse (frame1 r output) r.query1 |
| def frame3 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| Reduction.MachineTransfer.tapesAt .queryReverse .queryIndex (frame2 r output) [] |
| (encodeWord r.query1) |
| def frame4 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| lookupResultTapes id (frame3 r output) r.firstValue [] |
| def frame5 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| divisionOutput d id .quotientFirst .remainderFirst (frame4 r output) r.firstValue [] [] [] |
| def frame6 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| clearedQueryTapes id (frame5 r output) |
| def frame7 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| emittedWord .queryReverse (frame6 r output) r.query2 |
| def frame8 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| Reduction.MachineTransfer.tapesAt .queryReverse .queryIndex (frame7 r output) [] |
| (encodeWord r.query2) |
| def frame9 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| lookupResultTapes id (frame8 r output) r.secondValue [] |
| def frame10 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| divisionOutput d id .quotientSecond .remainderSecond (frame9 r output) r.secondValue [] [] [] |
| def frame11 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| emittedWord .output (frame10 r output) r.finalValue |
| def frame12 (r : RowData v d) (output : List Bool) : Tape → List Bool := |
| cleanupTapes id (frame11 r output) |
|
|
| private theorem lookupResultTapes_id_eq_inline_MachineExpanderRowFrames (base : Tape → List Bool) |
| (value : Nat) (suffix : List Bool) : |
| lookupResultTapes id base value suffix = |
| Function.update |
| (Function.update (Function.update base .queryIndex (encodeWord 0 ++ suffix)) |
| .lookupWork []) |
| .lookupOutput (encodeWord value ++ base .lookupOutput) := rfl |
|
|
| @[simp] theorem frame1_eq (r : RowData v d) (output : List Bool) : |
| frame1 r output = frameContents r output [] [] [] |
| (encodeWord 0) (encodeWord 0) (encodeWord 0) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame1, frame0, frameContents, initializedTapes, encodeWord] |
| |
| @[simp] theorem frame2_eq (r : RowData v d) (output : List Bool) : |
| frame2 r output = frameContents r output (encodeWord r.query1).reverse [] [] |
| (encodeWord 0) (encodeWord 0) (encodeWord 0) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame2, frameContents, emittedWord] |
| |
| @[simp] theorem frame3_eq (r : RowData v d) (output : List Bool) : |
| frame3 r output = frameContents r output [] (encodeWord r.query1) [] |
| (encodeWord 0) (encodeWord 0) (encodeWord 0) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame3, frameContents, Reduction.MachineTransfer.tapesAt] |
| |
| @[simp] theorem frame4_eq (r : RowData v d) (output : List Bool) : |
| frame4 r output = frameContents r output [] (encodeWord 0) (encodeWord r.firstValue) |
| (encodeWord 0) (encodeWord 0) (encodeWord 0) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame4, lookupResultTapes_id_eq_inline_MachineExpanderRowFrames, frameContents] |
| |
| @[simp] theorem frame5_eq (r : RowData v d) (output : List Bool) : |
| frame5 r output = frameContents r output [] (encodeWord 0) (encodeWord 0) |
| (encodeWord r.firstVertex.val) (encodeWord 0) |
| (encodeWord r.firstReturn.val) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame5, divisionOutput, MachineFixedDivMod.unaryTapes, |
| MachineFixedDivMod.tapes, MachineCopy.forkTapes, frameContents] |
| |
| @[simp] theorem frame6_eq (r : RowData v d) (output : List Bool) : |
| frame6 r output = frameContents r output [] [] [] (encodeWord r.firstVertex.val) |
| (encodeWord 0) (encodeWord r.firstReturn.val) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame6, clearedQueryTapes, frameContents, encodeWord] |
| |
| @[simp] theorem frame7_eq (r : RowData v d) (output : List Bool) : |
| frame7 r output = frameContents r output (encodeWord r.query2).reverse [] [] |
| (encodeWord r.firstVertex.val) (encodeWord 0) |
| (encodeWord r.firstReturn.val) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame7, emittedWord, frameContents] |
| |
| @[simp] theorem frame8_eq (r : RowData v d) (output : List Bool) : |
| frame8 r output = frameContents r output [] (encodeWord r.query2) [] |
| (encodeWord r.firstVertex.val) (encodeWord 0) |
| (encodeWord r.firstReturn.val) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame8, Reduction.MachineTransfer.tapesAt, frameContents] |
| |
| @[simp] theorem frame9_eq (r : RowData v d) (output : List Bool) : |
| frame9 r output = frameContents r output [] (encodeWord 0) (encodeWord r.secondValue) |
| (encodeWord r.firstVertex.val) (encodeWord 0) |
| (encodeWord r.firstReturn.val) (encodeWord 0) := by |
| funext tape |
| cases tape <;> simp [frame9, lookupResultTapes_id_eq_inline_MachineExpanderRowFrames, frameContents] |
| |
| @[simp] theorem frame10_eq (r : RowData v d) (output : List Bool) : |
| frame10 r output = frameContents r output [] (encodeWord 0) (encodeWord 0) |
| (encodeWord r.firstVertex.val) (encodeWord r.secondVertex.val) |
| (encodeWord r.firstReturn.val) (encodeWord r.secondReturn.val) := by |
| funext tape |
| cases tape <;> simp [frame10, divisionOutput, MachineFixedDivMod.unaryTapes, |
| MachineFixedDivMod.tapes, MachineCopy.forkTapes, frameContents] |
| |
| @[simp] theorem frame11_eq (r : RowData v d) (output : List Bool) : |
| frame11 r output = frameContents r ((encodeWord r.finalValue).reverse ++ output) |
| [] (encodeWord 0) (encodeWord 0) |
| (encodeWord r.firstVertex.val) (encodeWord r.secondVertex.val) |
| (encodeWord r.firstReturn.val) (encodeWord r.secondReturn.val) := by |
| funext tape |
| cases tape <;> simp [frame11, emittedWord, frameContents] |
| |
| @[simp] theorem frame12_eq (r : RowData v d) (output : List Bool) : |
| frame12 r output = frameContents r ((encodeWord r.finalValue).reverse ++ output) |
| [] [] [] [] [] [] [] := by |
| funext tape |
| cases tape <;> simp [frame12, cleanupTapes, frameContents] |
| |
| theorem final_frame_eq (r : RowData v d) (output : List Bool) : |
| frame12 r output = emittedWord .output (frame0 r output) r.finalValue := by |
| funext tape |
| cases tape <;> simp [frame0, emittedWord, frameContents] |
| |
| /-! Direct input facts for the individual checked phase traces. -/ |
| |
| @[simp] theorem frame0_inputVertex (r : RowData v d) (output : List Bool) : |
| frame0 r output .inputVertex = encodeWord r.inputVertex.val := rfl |
|
|
| @[simp] theorem frame0_table (r : RowData v d) (output : List Bool) : |
| frame0 r output .table = encodeWords (rotationWords r.oldTable) := rfl |
|
|
| @[simp] theorem frame0_output (r : RowData v d) (output : List Bool) : |
| frame0 r output .output = output := rfl |
|
|
| @[simp] theorem frame1_inputVertex (r : RowData v d) (output : List Bool) : |
| frame1 r output .inputVertex = encodeWord r.inputVertex.val := by simp [frameContents] |
|
|
| @[simp] theorem frame1_emitScratch (r : RowData v d) (output : List Bool) : |
| frame1 r output .emitScratch = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame2_queryReverse (r : RowData v d) (output : List Bool) : |
| frame2 r output .queryReverse = (encodeWord r.query1).reverse := by simp [frameContents] |
|
|
| @[simp] theorem frame2_queryIndex (r : RowData v d) (output : List Bool) : |
| frame2 r output .queryIndex = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame3_table (r : RowData v d) (output : List Bool) : |
| frame3 r output .table = encodeWords (rotationWords r.oldTable) := by simp [frameContents] |
|
|
| @[simp] theorem frame3_lookupRestore (r : RowData v d) (output : List Bool) : |
| frame3 r output .lookupRestore = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame3_lookupWork (r : RowData v d) (output : List Bool) : |
| frame3 r output .lookupWork = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame3_lookupOutput (r : RowData v d) (output : List Bool) : |
| frame3 r output .lookupOutput = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame3_queryIndex (r : RowData v d) (output : List Bool) : |
| frame3 r output .queryIndex = encodeWord r.query1 := by simp [frameContents] |
|
|
| @[simp] theorem frame4_lookupOutput (r : RowData v d) (output : List Bool) : |
| frame4 r output .lookupOutput = encodeWord r.firstValue := by simp [frameContents] |
|
|
| @[simp] theorem frame4_quotientFirst (r : RowData v d) (output : List Bool) : |
| frame4 r output .quotientFirst = encodeWord 0 := by simp [frameContents] |
|
|
| @[simp] theorem frame4_remainderFirst (r : RowData v d) (output : List Bool) : |
| frame4 r output .remainderFirst = encodeWord 0 := by simp [frameContents] |
|
|
| @[simp] theorem frame6_quotientFirst (r : RowData v d) (output : List Bool) : |
| frame6 r output .quotientFirst = encodeWord r.firstVertex.val := by simp [frameContents] |
|
|
| @[simp] theorem frame6_emitScratch (r : RowData v d) (output : List Bool) : |
| frame6 r output .emitScratch = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame7_queryReverse (r : RowData v d) (output : List Bool) : |
| frame7 r output .queryReverse = (encodeWord r.query2).reverse := by simp [frameContents] |
|
|
| @[simp] theorem frame7_queryIndex (r : RowData v d) (output : List Bool) : |
| frame7 r output .queryIndex = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame8_table (r : RowData v d) (output : List Bool) : |
| frame8 r output .table = encodeWords (rotationWords r.oldTable) := by simp [frameContents] |
|
|
| @[simp] theorem frame8_lookupRestore (r : RowData v d) (output : List Bool) : |
| frame8 r output .lookupRestore = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame8_lookupWork (r : RowData v d) (output : List Bool) : |
| frame8 r output .lookupWork = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame8_lookupOutput (r : RowData v d) (output : List Bool) : |
| frame8 r output .lookupOutput = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame8_queryIndex (r : RowData v d) (output : List Bool) : |
| frame8 r output .queryIndex = encodeWord r.query2 := by simp [frameContents] |
|
|
| @[simp] theorem frame9_lookupOutput (r : RowData v d) (output : List Bool) : |
| frame9 r output .lookupOutput = encodeWord r.secondValue := by simp [frameContents] |
|
|
| @[simp] theorem frame9_quotientSecond (r : RowData v d) (output : List Bool) : |
| frame9 r output .quotientSecond = encodeWord 0 := by simp [frameContents] |
|
|
| @[simp] theorem frame9_remainderSecond (r : RowData v d) (output : List Bool) : |
| frame9 r output .remainderSecond = encodeWord 0 := by simp [frameContents] |
|
|
| @[simp] theorem frame10_quotientSecond (r : RowData v d) (output : List Bool) : |
| frame10 r output .quotientSecond = encodeWord r.secondVertex.val := by simp [frameContents] |
|
|
| @[simp] theorem frame10_emitScratch (r : RowData v d) (output : List Bool) : |
| frame10 r output .emitScratch = [] := by simp [frameContents] |
|
|
| @[simp] theorem frame10_output (r : RowData v d) (output : List Bool) : |
| frame10 r output .output = output := by simp [frameContents] |
|
|
| theorem final_dirty_word_length_le (r : RowData v d) (output : List Bool) (i : Fin 6) : |
| ((frame11 r output) (dirtyTape i)).length ≤ r.tableLength + 1 := by |
| have h1 := r.firstVertex_le_tableLength |
| have h2 := r.secondVertex_le_tableLength |
| have h3 := r.firstReturn_le_tableLength |
| have h4 := r.secondReturn_le_tableLength |
| fin_cases i <;> simp only [frame11_eq, dirtyTape, frameContents, encodeWord_length] <;> omega |
| |
| theorem cleanupSteps_le_tableLength (r : RowData v d) (output : List Bool) : |
| cleanupSteps id (frame11 r output) ≤ 6 * (r.tableLength + 1) + 6 := by |
| have h1 := r.firstVertex_le_tableLength |
| have h2 := r.secondVertex_le_tableLength |
| have h3 := r.firstReturn_le_tableLength |
| have h4 := r.secondReturn_le_tableLength |
| simp only [cleanupSteps, frame11_eq, id_eq, frameContents, encodeWord_length] |
| omega |
|
|
| end MaxCutGames.Foundations.Complexity.MachineExpanderRow |
|
|
| /-! |
| # Complete execution of one expander-table row |
|
|
| The actual finite program performs both stored-table lookups, splits their |
| results by its fixed degree, emits the resulting square/zigzag reverse index, |
| and clears its work tapes. Its transition bound is linear in the unary input |
| table length. The output accumulator and finite caller state are arbitrary. |
| -/ |
|
|
| namespace MaxCutGames.Foundations.Complexity.MachineExpanderRow |
|
|
| open Turing MachineComposition |
| open PCP.ExpanderTables PCP.ExpanderRowControl PCP.ExpanderTableWords PCP.AlphabetTable |
|
|
| private theorem concatenate_inline_MachineExpanderRow {A : Type*} {f : A → A} {m n : Nat} {a b c : A} |
| (first : f^[m] a = b) (second : f^[n] b = c) : f^[m + n] a = c := by |
| rw [Nat.add_comm m n, Function.iterate_add_apply, first, second] |
|
|
| /-- The actual number of transitions, retaining both concrete lookup costs. -/ |
| def rowSteps {v d : Nat} (r : RowData v d) (output : List Bool) : Nat := |
| 1 + emitSteps r.inputVertex.val + (r.query1 + 2) + |
| MachinePreservingLookupClean.steps (rotationWords r.oldTable) r.firstRow.val + |
| (r.firstValue + 2) + 1 + emitSteps r.firstVertex.val + (r.query2 + 2) + |
| MachinePreservingLookupClean.steps (rotationWords r.oldTable) r.secondRow.val + |
| (r.secondValue + 2) + emitSteps r.secondVertex.val + |
| (cleanupSteps id (frame11 r output) + 1) |
|
|
| section Execution |
|
|
| variable {v d : Nat} {ρ Λ : Type} [Fintype ρ] |
| (positive : 0 < d) (r : RowData v d) (output : List Bool) (ambient : ρ) |
| (labels : Label d → Λ) (exit : Option Λ) |
| (target : Λ → TM2.Stmt (fun _ : Tape => Bool) Λ (State ρ d)) |
| (code : ∀ l, target (labels l) = statement positive r.smallTable id labels exit l) |
|
|
| include code |
|
|
| /-- The complete execution follows the concrete program. The only code premise |
| places its instructions in a caller; every lookup is derived from `oldTable`. -/ |
| theorem rowTraceAt : |
| (advance (TM2.step target))^[rowSteps r output] |
| (some ⟨some (labels .initialize), divisionState positive ambient r.control0 none, |
| frame0 r output⟩) = |
| some ⟨exit, divisionState positive ambient r.control2 none, |
| emittedWord .output (frame0 r output) r.finalValue⟩ := by |
| let zero := MachineFixedDivMod.residue (degree d) (Nat.mul_pos positive positive) 0 |
| have h0 : (advance (TM2.step target))^[1] |
| (some ⟨some (labels .initialize), divisionState positive ambient r.control0 none, |
| frame0 r output⟩) = |
| some ⟨some (labels (.firstEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control0 none, frame1 r output⟩ := by |
| simpa only [Function.iterate_one, advance_some, divisionState, frame1] using |
| initializeStepAt positive r.smallTable id Function.injective_id labels exit target code |
| (frame0 r output) (divisionState positive ambient r.control0 none) |
| have h1 := firstEmitTraceAt positive r.smallTable id Function.injective_id |
| labels exit target code r.inputVertex.val (frame1 r output) |
| (by simp) (by simp) ((ambient,r.control0),zero) |
| change (advance (TM2.step target))^[emitSteps r.inputVertex.val] |
| (some ⟨some (labels (.firstEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control0 none, frame1 r output⟩) = |
| some ⟨some (labels .firstReverse), divisionState positive ambient r.control0 none, |
| frame2 r output⟩ at h1 |
| have h2 := reversePhaseTrace_unary false positive r.smallTable id Function.injective_id |
| labels exit target code (frame2 r output) (((ambient,r.control0),zero),()) none |
| r.query1 [] (by simp) (by simp) |
| simp only [List.append_nil] at h2 |
| change (advance (TM2.step target))^[r.query1 + 2] |
| (some ⟨some (labels .firstReverse), divisionState positive ambient r.control0 none, |
| frame2 r output⟩) = |
| some ⟨some (labels (.firstLookup (.run .copyFirst))), |
| divisionState positive ambient r.control0 none, frame3 r output⟩ at h2 |
| have h3 := lookupPhaseTrace false positive r.smallTable id Function.injective_id |
| labels exit target code (frame3 r output) r.oldTable |
| (by simp) (by simp) |
| (r.inputVertex, firstOffset r.control0) [] |
| (by simpa [frameContents, RowData.firstRow] using |
| congrArg encodeWord r.query1_eq_firstRow) |
| (by simp) (((ambient,r.control0),zero),()) none |
| change (advance (TM2.step target))^[MachinePreservingLookupClean.steps |
| (rotationWords r.oldTable) r.firstRow.val] |
| (some ⟨some (labels (.firstLookup (.run .copyFirst))), |
| divisionState positive ambient r.control0 none, frame3 r output⟩) = |
| some ⟨some (labels .firstScan), divisionState positive ambient r.control0 none, |
| frame4 r output⟩ at h3 |
| have h4 := firstDivisionTrace positive r.smallTable id Function.injective_id labels exit |
| target code (frame4 r output) r.firstValue [] [] [] |
| (by simp) (by simp) (by simp) |
| ambient r.control0 none |
| rw [← r.firstReturn_eq_residue positive] at h4 |
| change (advance (TM2.step target))^[r.firstValue + 2] |
| (some ⟨some (labels .firstScan), divisionState positive ambient r.control0 none, |
| frame4 r output⟩) = |
| some ⟨some (labels .clearQuery), divisionState positive ambient r.control1 none, |
| frame5 r output⟩ at h4 |
| have h5 : (advance (TM2.step target))^[1] |
| (some ⟨some (labels .clearQuery), divisionState positive ambient r.control1 none, |
| frame5 r output⟩) = |
| some ⟨some (labels (.secondEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control1 none, frame6 r output⟩ := by |
| simpa only [Function.iterate_one, advance_some, frame6] using |
| clearQueryStepAt positive r.smallTable id Function.injective_id labels exit target code |
| (frame5 r output) (divisionState positive ambient r.control1 none) |
| have h6 := secondEmitTraceAt positive r.smallTable id Function.injective_id |
| labels exit target code r.firstVertex.val (frame6 r output) |
| (by simp) (by simp) ((ambient,r.control1),zero) |
| change (advance (TM2.step target))^[emitSteps r.firstVertex.val] |
| (some ⟨some (labels (.secondEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control1 none, frame6 r output⟩) = |
| some ⟨some (labels .secondReverse), divisionState positive ambient r.control1 none, |
| frame7 r output⟩ at h6 |
| have h7 := reversePhaseTrace_unary true positive r.smallTable id Function.injective_id |
| labels exit target code (frame7 r output) (((ambient,r.control1),zero),()) none |
| r.query2 [] (by simp) (by simp) |
| simp only [List.append_nil] at h7 |
| change (advance (TM2.step target))^[r.query2 + 2] |
| (some ⟨some (labels .secondReverse), divisionState positive ambient r.control1 none, |
| frame7 r output⟩) = |
| some ⟨some (labels (.secondLookup (.run .copyFirst))), |
| divisionState positive ambient r.control1 none, frame8 r output⟩ at h7 |
| have h8 := lookupPhaseTrace true positive r.smallTable id Function.injective_id |
| labels exit target code (frame8 r output) r.oldTable |
| (by simp) (by simp) |
| (r.firstVertex, secondOffset r.control1) [] |
| (by simpa [frameContents, RowData.secondRow] using |
| congrArg encodeWord r.query2_eq_secondRow) |
| (by simp) (((ambient,r.control1),zero),()) none |
| change (advance (TM2.step target))^[MachinePreservingLookupClean.steps |
| (rotationWords r.oldTable) r.secondRow.val] |
| (some ⟨some (labels (.secondLookup (.run .copyFirst))), |
| divisionState positive ambient r.control1 none, frame8 r output⟩) = |
| some ⟨some (labels .secondScan), divisionState positive ambient r.control1 none, |
| frame9 r output⟩ at h8 |
| have h9 := secondDivisionTrace positive r.smallTable id Function.injective_id labels exit |
| target code (frame9 r output) r.secondValue [] [] [] |
| (by simp) (by simp) (by simp) |
| ambient r.control1 none |
| rw [← r.secondReturn_eq_residue positive] at h9 |
| change (advance (TM2.step target))^[r.secondValue + 2] |
| (some ⟨some (labels .secondScan), divisionState positive ambient r.control1 none, |
| frame9 r output⟩) = |
| some ⟨some (labels (.outputEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control2 none, frame10 r output⟩ at h9 |
| have h10 := outputEmitTraceAt positive r.smallTable id Function.injective_id |
| labels exit target code r.secondVertex.val (frame10 r output) |
| (by simp) (by simp) ((ambient,r.control2),zero) |
| change (advance (TM2.step target))^[emitSteps r.secondVertex.val] |
| (some ⟨some (labels (.outputEmit (Emitter.labelAt 3 _ 0 .entry))), |
| divisionState positive ambient r.control2 none, frame10 r output⟩) = |
| some ⟨some (labels (.cleanup 0)), divisionState positive ambient r.control2 none, |
| frame11 r output⟩ at h10 |
| have h11 := cleanupExitTraceAt positive r.smallTable id Function.injective_id |
| labels exit target code (frame11 r output) (divisionState positive ambient r.control2 none) |
| change (advance (TM2.step target))^[cleanupSteps id (frame11 r output) + 1] |
| (some ⟨some (labels (.cleanup 0)), divisionState positive ambient r.control2 none, |
| frame11 r output⟩) = |
| some ⟨exit, divisionState positive ambient r.control2 none, frame12 r output⟩ at h11 |
| rw [final_frame_eq] at h11 |
| exact concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow |
| (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow (concatenate_inline_MachineExpanderRow |
| (concatenate_inline_MachineExpanderRow h0 h1) h2) h3) h4) h5) h6) h7) h8) h9) h10) h11 |
|
|
| end Execution |
|
|
| theorem rowSteps_le {v d : Nat} (r : RowData v d) (output : List Bool) : |
| rowSteps r output ≤ 80 * (r.tableLength + 1) := by |
| have lookup1 := MachinePreservingLookupClean.steps_le (rotationWords r.oldTable) |
| r.firstRow.val r.firstValue (rotationWords_getElem? r.oldTable r.firstRow) |
| have lookup2 := MachinePreservingLookupClean.steps_le (rotationWords r.oldTable) |
| r.secondRow.val r.secondValue (rotationWords_getElem? r.oldTable r.secondRow) |
| have h0 := r.inputVertex_le_tableLength |
| have h1 := r.query1_le_tableLength |
| have h2 := r.firstValue_le_tableLength |
| have h3 := r.firstVertex_le_tableLength |
| have h4 := r.query2_le_tableLength |
| have h5 := r.secondValue_le_tableLength |
| have h6 := r.secondVertex_le_tableLength |
| have clean := cleanupSteps_le_tableLength r output |
| change _ ≤ 6 * r.tableLength + 4 at lookup1 lookup2 |
| simp only [rowSteps, emitSteps] |
| omega |
|
|
| /-- The actual row program has a linear transition bound, with all temporary |
| tapes empty at return. The bound holds for every valid finite input table. -/ |
| def rowInTimeAt {v d : Nat} {ρ Λ : Type} [Fintype ρ] |
| (positive : 0 < d) (r : RowData v d) (output : List Bool) (ambient : ρ) |
| (labels : Label d → Λ) (exit : Option Λ) |
| (target : Λ → TM2.Stmt (fun _ : Tape => Bool) Λ (State ρ d)) |
| (code : ∀ l, target (labels l) = statement positive r.smallTable id labels exit l) : |
| StateTransition.EvalsToInTime (TM2.step target) |
| ⟨some (labels .initialize), divisionState positive ambient r.control0 none, |
| frame0 r output⟩ |
| (some ⟨exit, divisionState positive ambient r.control2 none, |
| emittedWord .output (frame0 r output) r.finalValue⟩) |
| (80 * (r.tableLength + 1)) where |
| steps := rowSteps r output |
| evals_in_steps := rowTraceAt positive r output ambient labels exit target code |
| steps_le_m := rowSteps_le r output |
|
|
| /-- Specialization to the standalone finite row program. -/ |
| def rowInTime {v d : Nat} {ρ : Type} [Fintype ρ] |
| (positive : 0 < d) (r : RowData v d) (output : List Bool) (ambient : ρ) : |
| StateTransition.EvalsToInTime (TM2.step (program positive r.smallTable)) |
| ⟨some .initialize, divisionState positive ambient r.control0 none, frame0 r output⟩ |
| (some ⟨none, divisionState positive ambient r.control2 none, |
| emittedWord .output (frame0 r output) r.finalValue⟩) |
| (80 * (r.tableLength + 1)) := |
| rowInTimeAt positive r output ambient id none (program positive r.smallTable) (fun _ => rfl) |
|
|
| end MaxCutGames.Foundations.Complexity.MachineExpanderRow |
|
|
| /-! |
| # Concrete boundary steps of the expander-table machine |
|
|
| Every execution theorem below reduces the actual common program statement. |
| States and dependent tape frames are arbitrary; only the relevant unary word |
| or finite-position branch is specified. No phase execution is a premise. |
| -/ |
| |
| namespace MaxCutGames.Foundations.Complexity.MachineExpanderTable |
| |
| open Turing |
| open PCP.ExpanderTables PCP.ExpanderRowControl |
| |
| variable {ρ : Type} {d : Nat} |
|
|
| @[simp] theorem caller_boundaryState (positive : 0 < d) (H : Table (cloudSize d) d) |
| (ambient : ρ) (position : Position d) : |
| caller (boundaryState positive H ambient position) = ambient := rfl |
|
|
| @[simp] theorem prepareState_boundaryState (positive : 0 < d) (H : Table (cloudSize d) d) |
| (ambient : ρ) (position : Position d) : |
| prepareState positive H (boundaryState positive H ambient position) = |
| boundaryState positive H ambient position := rfl |
|
|
| @[simp] theorem clearRegister_boundaryState (positive : 0 < d) (H : Table (cloudSize d) d) |
| (ambient : ρ) (position : Position d) : |
| clearRegister (boundaryState positive H ambient position) = |
| boundaryState positive H ambient position := rfl |
|
|
| @[simp] theorem caller_prepareState (positive : 0 < d) (H : Table (cloudSize d) d) |
| (state : State ρ d) : caller (prepareState positive H state) = caller state := rfl |
|
|
| @[simp] theorem caller_resetState (positive : 0 < d) (H : Table (cloudSize d) d) |
| (state : State ρ d) : caller (resetState positive H state) = caller state := rfl |
|
|
| @[simp] theorem caller_clearRegister (state : State ρ d) : |
| caller (clearRegister state) = caller state := rfl |
|
|
| @[simp] theorem caller_advancePositionState (positive : 0 < d) (state : State ρ d) : |
| caller (advancePositionState positive state) = caller state := rfl |
|
|
| @[simp] theorem caller_resetPositionState (positive : 0 < d) (state : State ρ d) : |
| caller (resetPositionState positive state) = caller state := rfl |
|
|
| theorem nextPosition_val_of_lt (positive : 0 < d) (position : Position d) |
| (more : position.val + 1 < rowFactor d) : |
| (nextPosition positive position).val = position.val + 1 := Nat.mod_eq_of_lt more |
|
|
| /-- Replacing the count word leaves the entire row frame and result unchanged. -/ |
| theorem boundaryTapes_update_count (vertex remaining next : Nat) |
| (oldTable output countSuffix result : List Bool) : |
| Function.update (boundaryTapes vertex remaining oldTable output countSuffix result) |
| (.inr .vertexCount) (encodeWord next ++ countSuffix) = |
| boundaryTapes vertex next oldTable output countSuffix result := by |
| funext tape |
| rcases tape with row | extra |
| · cases row <;> simp [boundaryTapes, rowTapes, MachineEmbedding.tapes, Function.update] |
| · cases extra <;> simp [boundaryTapes, extraTapes, MachineEmbedding.tapes, Function.update] |
| |
| /-- The last row's one actual push increments the unary vertex word. -/ |
| theorem boundaryTapes_increment_vertex (vertex remaining : Nat) |
| (oldTable output countSuffix result : List Bool) : |
| Function.update (boundaryTapes vertex remaining oldTable output countSuffix result) |
| (.inl .inputVertex) (true :: encodeWord vertex) = |
| boundaryTapes (vertex + 1) remaining oldTable output countSuffix result := by |
| funext tape |
| rcases tape with row | extra |
| · cases row <;> |
| simp [boundaryTapes, rowTapes, MachineEmbedding.tapes, Function.update, |
| encodeWord, List.replicate_succ] |
| · cases extra <;> |
| simp [boundaryTapes, extraTapes, MachineEmbedding.tapes, Function.update] |
| |
| theorem initialTapes_initialize (vertices : Nat) (oldTable countSuffix : List Bool) : |
| Function.update (initialTapes vertices oldTable countSuffix) (.inl .inputVertex) [false] = |
| boundaryTapes 0 vertices oldTable [] countSuffix [] := by |
| funext tape |
| rcases tape with row | extra |
| · cases row <;> |
| simp [initialTapes, boundaryTapes, rowTapes, MachineEmbedding.tapes, |
| Function.update, encodeWord] |
| · cases extra <;> |
| simp [initialTapes, boundaryTapes, extraTapes, MachineEmbedding.tapes, |
| Function.update] |
| |
| variable [Fintype ρ] |
| |
| theorem initializeStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) : |
| TM2.step (program positive H) ⟨some (.inr .initialize), state, base⟩ = |
| some ⟨some (.inr .vertexGuard), resetState positive H state, |
| Function.update base (.inl .inputVertex) (false :: base (.inl .inputVertex))⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .initialize)) state base) = _ |
| rw [program_outer] |
| rfl |
|
|
| theorem initialize_boundaryStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (vertices : Nat) (oldTable countSuffix : List Bool) (state : State ρ d) : |
| TM2.step (program positive H) |
| ⟨some (.inr .initialize), state, initialTapes vertices oldTable countSuffix⟩ = |
| some ⟨some (.inr .vertexGuard), initialState positive H (caller state), |
| boundaryTapes 0 vertices oldTable [] countSuffix []⟩ := by |
| have h := initializeStep positive H (initialTapes vertices oldTable countSuffix) state |
| have input : initialTapes vertices oldTable countSuffix (.inl .inputVertex) = [] := rfl |
| simp only [input, resetState] at h |
| exact h.trans (congrArg |
| (fun tapes : ∀ tape, List (Alphabet tape) => |
| (some ⟨some (.inr .vertexGuard), initialState positive H (caller state), tapes⟩ : |
| Option (TM2.Cfg Alphabet (Label d) (State ρ d)))) |
| (initialTapes_initialize vertices oldTable countSuffix)) |
|
|
| /-- A positive vertex counter is physically decremented; its suffix remains. -/ |
| theorem vertexGuard_succStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (remaining : Nat) (suffix : List Bool) |
| (counter : base (.inr .vertexCount) = encodeWord (remaining + 1) ++ suffix) : |
| TM2.step (program positive H) ⟨some (.inr .vertexGuard), state, base⟩ = |
| some ⟨some (.inr .prepareRow), clearRegister state, |
| Function.update base (.inr .vertexCount) (encodeWord remaining ++ suffix)⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .vertexGuard)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, MachineControl.statement, vertexGuardCore, TM2.stepAux, |
| guardStates, clearRegister, counter, encodeWord, List.replicate_succ] |
|
|
| /-- The zero delimiter is retained when the loop enters output reversal. -/ |
| theorem vertexGuard_zeroStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (suffix : List Bool) |
| (counter : base (.inr .vertexCount) = encodeWord 0 ++ suffix) : |
| TM2.step (program positive H) ⟨some (.inr .vertexGuard), state, base⟩ = |
| some ⟨some (.inr .reverseOutput), clearRegister state, base⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .vertexGuard)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, MachineControl.statement, vertexGuardCore, TM2.stepAux, |
| guardStates, clearRegister, counter, encodeWord] |
|
|
| theorem vertexGuard_boundary_succStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (vertex remaining : Nat) (oldTable output countSuffix result : List Bool) |
| (state : State ρ d) : |
| TM2.step (program positive H) |
| ⟨some (.inr .vertexGuard), state, |
| boundaryTapes vertex (remaining + 1) oldTable output countSuffix result⟩ = |
| some ⟨some (.inr .prepareRow), clearRegister state, |
| boundaryTapes vertex remaining oldTable output countSuffix result⟩ := by |
| simpa only [boundaryTapes_update_count] using |
| vertexGuard_succStep positive H |
| (boundaryTapes vertex (remaining + 1) oldTable output countSuffix result) |
| state remaining countSuffix rfl |
|
|
| theorem vertexGuard_boundary_zeroStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (vertex : Nat) (oldTable output countSuffix result : List Bool) (state : State ρ d) : |
| TM2.step (program positive H) |
| ⟨some (.inr .vertexGuard), state, |
| boundaryTapes vertex 0 oldTable output countSuffix result⟩ = |
| some ⟨some (.inr .reverseOutput), clearRegister state, |
| boundaryTapes vertex 0 oldTable output countSuffix result⟩ := |
| vertexGuard_zeroStep positive H |
| (boundaryTapes vertex 0 oldTable output countSuffix result) state countSuffix rfl |
|
|
| /-- Preparing a row modifies finite control only, preserving every tape. -/ |
| theorem prepareRowStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) : |
| TM2.step (program positive H) ⟨some (.inr .prepareRow), state, base⟩ = |
| some ⟨some (.inl .initialize), prepareState positive H state, base⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .prepareRow)) state base) = _ |
| rw [program_outer] |
| rfl |
|
|
| /-- A nonfinal row advances the finite position without changing tapes. -/ |
| theorem afterRow_moreStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (more : state.2.val + 1 < rowFactor d) : |
| TM2.step (program positive H) ⟨some (.inr .afterRow), state, base⟩ = |
| some ⟨some (.inr .prepareRow), advancePositionState positive state, base⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .afterRow)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, TM2.stepAux, more] |
|
|
| /-- The final row increments the tape vertex and resets the finite position. -/ |
| theorem afterRow_lastStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (last : ¬ state.2.val + 1 < rowFactor d) : |
| TM2.step (program positive H) ⟨some (.inr .afterRow), state, base⟩ = |
| some ⟨some (.inr .vertexGuard), resetPositionState positive state, |
| Function.update base (.inl .inputVertex) (true :: base (.inl .inputVertex))⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .afterRow)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, TM2.stepAux, last] |
|
|
| theorem afterRow_last_boundaryStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (vertex remaining : Nat) (oldTable output countSuffix result : List Bool) |
| (state : State ρ d) (last : ¬ state.2.val + 1 < rowFactor d) : |
| TM2.step (program positive H) |
| ⟨some (.inr .afterRow), state, |
| boundaryTapes vertex remaining oldTable output countSuffix result⟩ = |
| some ⟨some (.inr .vertexGuard), resetPositionState positive state, |
| boundaryTapes (vertex + 1) remaining oldTable output countSuffix result⟩ := by |
| have input : boundaryTapes vertex remaining oldTable output countSuffix result |
| (.inl .inputVertex) = encodeWord vertex := rfl |
| have h := afterRow_lastStep positive H |
| (boundaryTapes vertex remaining oldTable output countSuffix result) state last |
| simp only [input] at h |
| exact h.trans (congrArg |
| (fun tapes : ∀ tape, List (Alphabet tape) => |
| (some ⟨some (.inr .vertexGuard), resetPositionState positive state, tapes⟩ : |
| Option (TM2.Cfg Alphabet (Label d) (State ρ d)))) |
| (boundaryTapes_increment_vertex vertex remaining oldTable output countSuffix result)) |
|
|
| /-- One reversal step moves an actual symbol and preserves the finite position. -/ |
| theorem reverseOutput_consStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (symbol : Bool) (word : List Bool) (source : base (.inl .output) = symbol :: word) : |
| TM2.step (program positive H) ⟨some (.inr .reverseOutput), state, base⟩ = |
| some ⟨some (.inr .reverseOutput), ((state.1.1, some symbol), state.2), |
| Function.update (Function.update base (.inl .output) word) |
| (.inr .result) (symbol :: base (.inr .result))⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .reverseOutput)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, MachineControl.statement, Reduction.MachineTransfer.loopAt, |
| Reduction.MachineTransfer.exitAt, TM2.stepAux, guardStates, source] |
|
|
| theorem reverseOutput_nilStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) |
| (source : base (.inl .output) = []) : |
| TM2.step (program positive H) ⟨some (.inr .reverseOutput), state, base⟩ = |
| some ⟨some (.inr .done), clearRegister state, base⟩ := by |
| have same : Function.update base (.inl .output) [] = base := by |
| simpa only [source] using Function.update_eq_self (.inl .output) base |
| change some (TM2.stepAux (program positive H (.inr .reverseOutput)) state base) = _ |
| rw [program_outer] |
| simp [outerStatement, MachineControl.statement, Reduction.MachineTransfer.loopAt, |
| Reduction.MachineTransfer.exitAt, TM2.stepAux, guardStates, clearRegister, source, same] |
|
|
| theorem doneStep (positive : 0 < d) (H : Table (cloudSize d) d) |
| (base : ∀ tape, List (Alphabet tape)) (state : State ρ d) : |
| TM2.step (program positive H) ⟨some (.inr .done), state, base⟩ = |
| some ⟨none, state, base⟩ := by |
| change some (TM2.stepAux (program positive H (.inr .done)) state base) = _ |
| rw [program_outer] |
| rfl |
|
|
| end MaxCutGames.Foundations.Complexity.MachineExpanderTable |
|
|
| end OAI |
|
|
