import OAI.Computability.BinPacking.Computation.MachineRegularOwnerBodyBounds namespace OAI namespace BinPackingGames.Foundations.Complexity.MachineRegularTable open Turing MachineComposition open BinPackingGames.Foundations.PCP namespace Header inductive Extra | m | index | work | scratch | vertices | darts | emit | output deriving DecidableEq protected abbrev Extra.enumList : List Extra := [.m, .index, .work, .scratch, .vertices, .darts, .emit, .output] protected theorem Extra.enumList_getElem?_ctorIdx_eq (x : Extra) : Extra.enumList[x.ctorIdx]? = some x := by cases x <;> rfl protected theorem Extra.enumList_nodup : Extra.enumList.Nodup := by decide instance : Fintype Extra where elems := ⟨Extra.enumList, Extra.enumList_nodup⟩ complete x := by cases x <;> decide abbrev Tape := MachineCloudPrefix.Tape ⊕ Extra abbrev Alphabet (_ : Tape) := Bool abbrev State (σ : Type) := MachineCloudPrefix.State σ def tableTape : Tape := .inl (.inner .table) def nTape : Tape := .inl .bound def queryTape : Tape := .inl (.inner .query) def fuelTape : Tape := .inl .remaining def sumTape : Tape := .inl .total def mTape : Tape := .inr .m def indexTape : Tape := .inr .index def workTape : Tape := .inr .work def scratchTape : Tape := .inr .scratch def verticesTape : Tape := .inr .vertices def dartsTape : Tape := .inr .darts def emitTape : Tape := .inr .emit def outputTape : Tape := .inr .output def memory (inner : MachineCloudPrefix.Tape → List Bool) (m index work scratch vertices darts emit output : List Bool) : Tape → List Bool | .inl k => inner k | .inr .m => m | .inr .index => index | .inr .work => work | .inr .scratch => scratch | .inr .vertices => vertices | .inr .darts => darts | .inr .emit => emit | .inr .output => output def frame (t n v f s m i w a N R e o : List Bool) : Tape → List Bool := memory (MachineCloudPrefix.frame t v [] [] [] n f s) m i w a N R e o @[simp] theorem frame_table (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o tableTape = t := rfl @[simp] theorem frame_n (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o nTape = n := rfl @[simp] theorem frame_query (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o queryTape = v := rfl @[simp] theorem frame_fuel (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o fuelTape = f := rfl @[simp] theorem frame_sum (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o sumTape = s := rfl @[simp] theorem frame_m (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o mTape = m := rfl @[simp] theorem frame_index (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o indexTape = i := rfl @[simp] theorem frame_work (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o workTape = w := rfl @[simp] theorem frame_scratch (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o scratchTape = a := rfl @[simp] theorem frame_vertices (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o verticesTape = N := rfl @[simp] theorem frame_darts (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o dartsTape = R := rfl @[simp] theorem frame_emit (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o emitTape = e := rfl @[simp] theorem frame_output (t n v f s m i w a N R e o : List Bool) : frame t n v f s m i w a N R e o outputTape = o := rfl @[simp] theorem update_frame_table (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) tableTape x = frame x n v f s m i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_n (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) nTape x = frame t x v f s m i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_query (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) queryTape x = frame t n x f s m i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_fuel (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) fuelTape x = frame t n v x s m i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_sum (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) sumTape x = frame t n v f x m i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_m (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) mTape x = frame t n v f s x i w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_index (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) indexTape x = frame t n v f s m x w a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_work (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) workTape x = frame t n v f s m i x a N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_scratch (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) scratchTape x = frame t n v f s m i w x N R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_vertices (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) verticesTape x = frame t n v f s m i w a x R e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_darts (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) dartsTape x = frame t n v f s m i w a N x e o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_emit (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) emitTape x = frame t n v f s m i w a N R x o := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_output (t n v f s m i w a N R e o x : List Bool) : Function.update (frame t n v f s m i w a N R e o) outputTape x = frame t n v f s m i w a N R e x := by funext k cases k with | inl k => cases k with | inner j => cases j <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr j => cases j <;> rfl inductive Field | vertices | darts deriving DecidableEq protected abbrev Field.enumList : List Field := [.vertices, .darts] protected theorem Field.enumList_getElem?_ctorIdx_eq (x : Field) : Field.enumList[x.ctorIdx]? = some x := by cases x <;> rfl protected theorem Field.enumList_nodup : Field.enumList.Nodup := by decide instance : Fintype Field where elems := ⟨Field.enumList, Field.enumList_nodup⟩ complete x := by cases x <;> decide inductive CopyPhase | count | rEmit | nEmit deriving DecidableEq protected abbrev CopyPhase.enumList : List CopyPhase := [.count, .rEmit, .nEmit] protected theorem CopyPhase.enumList_getElem?_ctorIdx_eq (x : CopyPhase) : CopyPhase.enumList[x.ctorIdx]? = some x := by cases x <;> rfl protected theorem CopyPhase.enumList_nodup : CopyPhase.enumList.Nodup := by decide instance : Fintype CopyPhase where elems := ⟨CopyPhase.enumList, CopyPhase.enumList_nodup⟩ complete x := by cases x <;> decide inductive Label | init | seedM | clearIndex | lookup (field : Field) (label : MachinePreservingLookupClean.Label) | prefix (label : MachineCloudPrefix.Label) | copyFirst (phase : CopyPhase) | copySecond (phase : CopyPhase) | add | scaleSeed | scaleScan | scaleRestore | appendFirst | appendSecond | appendThird | cleanupZeros | clearQuery | done deriving DecidableEq, Fintype def fieldTape : Field → Tape | .vertices => nTape | .darts => mTape def fieldExit : Field → Label | .vertices => .seedM | .darts => .clearIndex def lookupSlots (field : Field) : Fin 5 → Tape := ![tableTape, indexTape, workTape, fieldTape field, scratchTape] theorem lookupSlots_injective (field : Field) : Function.Injective (lookupSlots field) := by intro i j h cases field <;> fin_cases i <;> fin_cases j <;> simp_all [lookupSlots, fieldTape, tableTape, indexTape, workTape, nTape, mTape, scratchTape] def copySource : CopyPhase → Tape | .count => mTape | .rEmit => dartsTape | .nEmit => verticesTape def copyDestination : CopyPhase → Tape | .count => verticesTape | .rEmit | .nEmit => emitTape def copyExit : CopyPhase → Label | .count => .add | .rEmit => .copyFirst .nEmit | .nEmit => .appendFirst def prefixView : Tape → Option MachineCloudPrefix.Tape | .inl k => some k | .inr _ => none theorem prefixView_left (k : MachineCloudPrefix.Tape) : prefixView (.inl k) = some k := rfl theorem prefixView_right (j : Tape) (k : MachineCloudPrefix.Tape) (h : prefixView j = some k) : Sum.inl k = j := by cases j <;> simp_all [prefixView] theorem prefixTapes (inner : MachineCloudPrefix.Tape → List Bool) (extra : Tape → List Bool) : MachineCloudPadding.Placement.tapes prefixView inner extra = memory inner (extra mTape) (extra indexTape) (extra workTape) (extra scratchTape) (extra verticesTape) (extra dartsTape) (extra emitTape) (extra outputTape) := by funext j cases j with | inl k => rfl | inr k => cases k <;> rfl variable {σ : Type} def program (q : Nat) : Label → TM2.Stmt Alphabet Label (State σ) | .init => .push indexTape (fun _ => false) (.goto fun _ => .lookup .vertices (.run .copyFirst)) | .seedM => .push indexTape (fun _ => true) (.goto fun _ => .lookup .darts (.run .copyFirst)) | .clearIndex => .pop indexTape (fun state _ => (state.1, none)) (.goto fun _ => .prefix .init) | .lookup field l => MachinePreservingLookupClean.statement (lookupSlots field) (Label.lookup field) (some (fieldExit field)) l | .prefix l => MachineCloudPadding.Placement.statement Sum.inl Label.prefix (some (.copyFirst .count)) (MachineCloudPrefix.program l) | .copyFirst phase => Reduction.MachineTransfer.loopAt (copySource phase) scratchTape id false (.copyFirst phase) (some (.copySecond phase)) | .copySecond phase => MachineCopy.forkLoop scratchTape (copySource phase) (copyDestination phase) false (.copySecond phase) (some (copyExit phase)) | .add => MachineUnaryAddAt.loop sumTape verticesTape .add (some .scaleSeed) | .scaleSeed => MachineUnaryAffineAt.seed dartsTape 0 .scaleScan | .scaleScan => MachineUnaryAffineAt.scan verticesTape scratchTape dartsTape (q + 1) .scaleScan .scaleRestore | .scaleRestore => Reduction.MachineTransfer.loopAt scratchTape verticesTape id false .scaleRestore (some (.copyFirst .rEmit)) | .appendFirst => Reduction.MachineTransfer.loopAt outputTape scratchTape id false .appendFirst (some .appendSecond) | .appendSecond => Reduction.MachineTransfer.loopAt emitTape scratchTape id false .appendSecond (some .appendThird) | .appendThird => Reduction.MachineTransfer.loopAt scratchTape outputTape id false .appendThird (some .cleanupZeros) | .cleanupZeros => .pop sumTape (fun state _ => (state.1, none)) (.pop fuelTape (fun state _ => (state.1, none)) (.goto fun _ => .clearQuery)) | .clearQuery => MachineLookup.discard queryTape .clearQuery .done | .done => .halt private theorem appendTrace {α : Type} (f : α → α) {a b : Nat} {x y z : α} (hs : f^[a] x = y) (ht : f^[b] y = z) : f^[a + b] x = z := by rw [Nat.add_comm a b, Function.iterate_add_apply, hs, ht] def paddingTotal (t : GraphTables.Table) : Nat := PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) t.vertices def vertexTotal (t : GraphTables.Table) : Nat := PreprocessingRegularTables.vertexCount t (PreprocessingRegularTables.padding t) def dartTotal (q : Nat) (t : GraphTables.Table) : Nat := vertexTotal t * (q + 1) theorem vertexTotal_eq (t : GraphTables.Table) : vertexTotal t = t.darts + paddingTotal t := by unfold vertexTotal PreprocessingRegularTables.vertexCount paddingTotal rw [PreprocessingPaddingOffsets.offset_all] theorem initStep (q : Nat) (table output : List Bool) (ambient : σ) (register : Option Bool) : TM2.step (program q) ⟨some .init, ((ambient, false), register), frame table [] [] [] [] [] [] [] [] [] [] [] output⟩ = some ⟨some (.lookup .vertices (.run .copyFirst)), ((ambient, false), register), frame table [] [] [] [] [] (encodeWord 0) [] [] [] [] [] output⟩ := by simp [TM2.step, program, TM2.stepAux, encodeWord] theorem seedMStep (q : Nat) (table n output : List Bool) (ambient : σ) (register : Option Bool) : TM2.step (program q) ⟨some .seedM, ((ambient, false), register), frame table n [] [] [] [] (encodeWord 0) [] [] [] [] [] output⟩ = some ⟨some (.lookup .darts (.run .copyFirst)), ((ambient, false), register), frame table n [] [] [] [] (encodeWord 1) [] [] [] [] [] output⟩ := by simp [TM2.step, program, TM2.stepAux, encodeWord] theorem clearIndexStep (q : Nat) (table n m output : List Bool) (ambient : σ) (register : Option Bool) : TM2.step (program q) ⟨some .clearIndex, ((ambient, false), register), frame table n [] [] [] m (encodeWord 0) [] [] [] [] [] output⟩ = some ⟨some (.prefix .init), ((ambient, false), none), frame table n [] [] [] m [] [] [] [] [] [] output⟩ := by simp [TM2.step, program, TM2.stepAux, encodeWord] def readTime (t : GraphTables.Table) : Nat := 1 + MachinePreservingLookupClean.steps (GraphTables.tableWords t) 0 + 1 + MachinePreservingLookupClean.steps (GraphTables.tableWords t) 1 + 1 theorem readTrace (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : (advance (TM2.step (program q)))^[readTime t] (some ⟨some .init, ((ambient, false), register), frame (GraphTables.tableBits t) [] [] [] [] [] [] [] [] [] [] [] output⟩) = some ⟨some (.prefix .init), ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] [] [] [] output⟩ := by have hi : (advance (TM2.step (program q)))^[1] (some ⟨some .init, ((ambient, false), register), frame (GraphTables.tableBits t) [] [] [] [] [] [] [] [] [] [] [] output⟩) = some ⟨some (.lookup .vertices (.run .copyFirst)), ((ambient, false), register), frame (GraphTables.tableBits t) [] [] [] [] [] (encodeWord 0) [] [] [] [] [] output⟩ := initStep q _ _ ambient register have hn := MachinePreservingLookupClean.traceAt_fromTapes (lookupSlots .vertices) (lookupSlots_injective .vertices) (Label.lookup .vertices) (some Label.seedM) (program q) (fun _ => rfl) (frame (GraphTables.tableBits t) [] [] [] [] [] (encodeWord 0) [] [] [] [] [] output) (GraphTables.tableWords t) rfl rfl 0 t.vertices (by simp [GraphTables.tableWords]) [] (by simp [lookupSlots]) (by simp [lookupSlots]) (ambient, false) register simp [MachinePreservingLookup.initialTapes, MachineLookup.tapes, lookupSlots, fieldTape] at hn have hs : (advance (TM2.step (program q)))^[1] (some ⟨some .seedM, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] [] (encodeWord 0) [] [] [] [] [] output⟩) = some ⟨some (.lookup .darts (.run .copyFirst)), ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] [] (encodeWord 1) [] [] [] [] [] output⟩ := seedMStep q _ _ _ ambient none have hm := MachinePreservingLookupClean.traceAt_fromTapes (lookupSlots .darts) (lookupSlots_injective .darts) (Label.lookup .darts) (some Label.clearIndex) (program q) (fun _ => rfl) (frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] [] (encodeWord 1) [] [] [] [] [] output) (GraphTables.tableWords t) rfl rfl 1 t.darts (by simp [GraphTables.tableWords]) [] (by simp [lookupSlots]) (by simp [lookupSlots]) (ambient, false) none simp [MachinePreservingLookup.initialTapes, MachineLookup.tapes, lookupSlots, fieldTape] at hm have hc : (advance (TM2.step (program q)))^[1] (some ⟨some .clearIndex, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) (encodeWord 0) [] [] [] [] [] output⟩) = some ⟨some (.prefix .init), ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] [] [] [] output⟩ := clearIndexStep q _ _ _ _ ambient none exact appendTrace _ (appendTrace _ (appendTrace _ (appendTrace _ hi hn) hs) hm) hc theorem prefixTrace (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : (advance (TM2.step (program q)))^[MachineCloudPrefix.totalTime t t.vertices []] (some ⟨some (.prefix .init), ((ambient, false), register), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] [] [] [] output⟩) = some ⟨some (.copyFirst .count), ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord (paddingTotal t)) (encodeWord t.darts) [] [] [] [] [] [] output⟩ := by have h := MachineCloudPadding.Placement.trace Sum.inl prefixView prefixView_left prefixView_right Label.prefix (some (Label.copyFirst .count)) (frame [] [] [] [] [] (encodeWord t.darts) [] [] [] [] [] [] output) (MachineCloudPrefix.program (σ := σ)) (program q) (fun _ => rfl) _ _ _ (MachineCloudPrefix.prefixTrace t t.vertices (Nat.le_refl _) [] ambient register) simpa only [MachineCloudPadding.Placement.configuration, MachineCloudPadding.Placement.label, prefixTapes, frame_m, frame_index, frame_work, frame_scratch, frame_vertices, frame_darts, frame_emit, frame_output, List.append_nil, paddingTotal, frame, memory, mTape, indexTape, workTape, scratchTape, verticesTape, dartsTape, emitTape, outputTape] using h def computeTime (t : GraphTables.Table) : Nat := (2 * (t.darts + 2) + (paddingTotal t + 1)) + (2 * (vertexTotal t + 1) + 1) theorem computeTrace (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : (advance (TM2.step (program q)))^[computeTime t] (some ⟨some (.copyFirst .count), ((ambient, false), register), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord (paddingTotal t)) (encodeWord t.darts) [] [] [] [] [] [] output⟩) = some ⟨some (.copyFirst .rEmit), ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] output⟩ := by have hc := MachineCopy.copyTrace mTape verticesTape scratchTape (by decide) (by decide) (by decide) false (Label.copyFirst .count) (Label.copySecond .count) (some Label.add) (program q) rfl rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord (paddingTotal t)) (encodeWord t.darts) [] [] [] [] [] [] output) rfl (ambient, false) register simp only [frame_m, frame_vertices, encodeWord_length, List.append_nil, update_frame_vertices] at hc have ha := MachineUnaryAddAt.addFromTapes sumTape verticesTape (by decide) Label.add (some Label.scaleSeed) (program q) rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord (paddingTotal t)) (encodeWord t.darts) [] [] [] (encodeWord t.darts) [] [] output) (paddingTotal t) t.darts [] [] (by simp) (by simp) (ambient, false) none simp only [MachineUnaryAddAt.unaryTapes, Reduction.MachineTransfer.tapesAt, List.append_nil, update_frame_sum, update_frame_vertices] at ha rw [show paddingTotal t + t.darts = vertexTotal t by rw [vertexTotal_eq]; omega] at ha have hm := MachineUnaryAffineAt.seededAffineTrace verticesTape scratchTape dartsTape (by decide) (by decide) (by decide) (q + 1) 0 Label.scaleSeed Label.scaleScan Label.scaleRestore (some (Label.copyFirst .rEmit)) (program q) rfl rfl rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) [] [] output) (vertexTotal t) [] (by simp) rfl (ambient, false) none simp only [frame_darts, List.append_nil, Nat.add_zero, update_frame_darts] at hm rw [show (q + 1) * vertexTotal t = dartTotal q t by unfold dartTotal; ac_rfl] at hm exact appendTrace _ (appendTrace _ hc ha) hm def headerBits (q : Nat) (t : GraphTables.Table) : List Bool := encodeWords [vertexTotal t, dartTotal q t] theorem headerBits_eq (q : Nat) (t : GraphTables.Table) : headerBits q t = encodeWord (vertexTotal t) ++ encodeWord (dartTotal q t) := by simp only [headerBits, encodeWords, List.append_nil] theorem headerBits_length (q : Nat) (t : GraphTables.Table) : (headerBits q t).length = vertexTotal t + dartTotal q t + 2 := by rw [headerBits_eq] simp only [List.length_append, encodeWord_length] omega theorem cleanupZerosStep (q : Nat) (table n m N R output : List Bool) (ambient : σ) (register : Option Bool) : TM2.step (program q) ⟨some .cleanupZeros, ((ambient, false), register), frame table n n (encodeWord 0) (encodeWord 0) m [] [] [] N R [] output⟩ = some ⟨some .clearQuery, ((ambient, false), none), frame table n n [] [] m [] [] [] N R [] output⟩ := by simp [TM2.step, program, TM2.stepAux, encodeWord] def emitTime (q : Nat) (t : GraphTables.Table) (output : List Bool) : Nat := (((2 * (dartTotal q t + 2) + 2 * (vertexTotal t + 2)) + (2 * ((headerBits q t).length + output.length) + 3)) + 1) + (t.vertices + 1) + 1 theorem emitTrace (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : (advance (TM2.step (program q)))^[emitTime q t output] (some ⟨some (.copyFirst .rEmit), ((ambient, false), register), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] output⟩) = some ⟨none, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩ := by have hr := MachineCopy.copyTrace dartsTape emitTape scratchTape (by decide) (by decide) (by decide) false (Label.copyFirst .rEmit) (Label.copySecond .rEmit) (some (Label.copyFirst .nEmit)) (program q) rfl rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] output) rfl (ambient, false) register simp only [frame_darts, frame_emit, encodeWord_length, List.append_nil, update_frame_emit] at hr have hn := MachineCopy.copyTrace verticesTape emitTape scratchTape (by decide) (by decide) (by decide) false (Label.copyFirst .nEmit) (Label.copySecond .nEmit) (some Label.appendFirst) (program q) rfl rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) (encodeWord (dartTotal q t)) output) rfl (ambient, false) none simp only [frame_vertices, frame_emit, encodeWord_length, update_frame_emit, ← headerBits_eq] at hn have ha := MachineAppendAt.appendTrace emitTape outputTape scratchTape (by decide) (by decide) (by decide) false Label.appendFirst Label.appendSecond Label.appendThird (some Label.cleanupZeros) (program q) rfl rfl rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) (headerBits q t) output) rfl (ambient, false) none simp only [frame_emit, frame_output, MachineAppendAt.appendTapes, Reduction.MachineTransfer.tapesAt, update_frame_emit, update_frame_output] at ha have hz : (advance (TM2.step (program q)))^[1] (some ⟨some .cleanupZeros, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) (encodeWord 0) (encodeWord 0) (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩) = some ⟨some .clearQuery, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩ := cleanupZerosStep q _ _ _ _ _ _ ambient none have hc := MachineLookup.discardTrace queryTape Label.clearQuery Label.done (program q) rfl (frame (GraphTables.tableBits t) (encodeWord t.vertices) (encodeWord t.vertices) [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)) t.vertices [] (by simp) (ambient, false) none simp only [update_frame_query] at hc have hd : (advance (TM2.step (program q)))^[1] (some ⟨some .done, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩) = some ⟨none, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩ := rfl exact appendTrace _ (appendTrace _ (appendTrace _ (appendTrace _ (appendTrace _ hr hn) ha) hz) hc) hd def totalTime (q : Nat) (t : GraphTables.Table) (output : List Bool) : Nat := ((readTime t + MachineCloudPrefix.totalTime t t.vertices []) + computeTime t) + emitTime q t output theorem trace (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : (advance (TM2.step (program q)))^[totalTime q t output] (some ⟨some .init, ((ambient, false), register), frame (GraphTables.tableBits t) [] [] [] [] [] [] [] [] [] [] [] output⟩) = some ⟨none, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩ := appendTrace _ (appendTrace _ (appendTrace _ (readTrace q t output ambient register) (prefixTrace q t output ambient none)) (computeTrace q t output ambient none)) (emitTrace q t output ambient none) noncomputable def arithmeticPolynomial (q : Nat) : Polynomial Nat := let X : Polynomial Nat := Polynomial.X let G : Polynomial Nat := Polynomial.C ExpanderFamily.growth * X let D : Polynomial Nat := Polynomial.C (ExpanderFamily.growth * (q + 1)) * X (12 * X + 11) + ((2 * (X + 2) + (G + 1)) + (2 * (G + 1) + 1)) + (((2 * (D + 2) + 2 * (G + 2)) + (2 * ((G + D + 2) + X) + 3)) + 1 + (X + 1) + 1) noncomputable def timePolynomial (q : Nat) : Polynomial Nat := MachineCloudPrefix.timePolynomial.comp (2 * Polynomial.X + 1) + arithmeticPolynomial q theorem totalTime_le (q : Nat) (t : GraphTables.Table) (output : List Bool) : totalTime q t output ≤ (timePolynomial q).eval ((GraphTables.tableBits t).length + output.length) := by let L := (GraphTables.tableBits t).length + output.length have hT : (GraphTables.tableBits t).length ≤ L := by unfold L; omega have hO : output.length ≤ L := by unfold L; omega have hn := (GraphTables.vertices_le_tableBits_length t).trans hT have hm := (GraphTables.darts_le_tableBits_length t).trans hT have hN : vertexTotal t ≤ ExpanderFamily.growth * L := (PreprocessingMachineBounds.regularVertices_le_input t).trans (Nat.mul_le_mul_left ExpanderFamily.growth hT) have hS : paddingTotal t ≤ ExpanderFamily.growth * L := (PreprocessingMachineBounds.prefix_le_input t t.vertices).trans (Nat.mul_le_mul_left ExpanderFamily.growth hT) have hR : dartTotal q t ≤ (ExpanderFamily.growth * (q + 1)) * L := by calc _ ≤ (ExpanderFamily.growth * L) * (q + 1) := Nat.mul_le_mul_right (q + 1) hN _ = _ := by ac_rfl have hr0 := MachinePreservingLookupClean.steps_le (GraphTables.tableWords t) 0 t.vertices (by simp [GraphTables.tableWords]) have hr1 := MachinePreservingLookupClean.steps_le (GraphTables.tableWords t) 1 t.darts (by simp [GraphTables.tableWords]) have hread : readTime t ≤ 12 * L + 11 := by change _ ≤ 6 * (GraphTables.tableBits t).length + 4 at hr0 hr1 unfold readTime omega have hprefixInput : MachineCloudPrefix.inputLength t t.vertices [] ≤ 2 * L + 1 := by simp only [MachineCloudPrefix.inputLength, List.append_nil, encodeWord_length] omega have hp := (MachineCloudPrefix.totalTime_le t t.vertices (Nat.le_refl _) []).trans (natPolynomial_eval_mono MachineCloudPrefix.timePolynomial hprefixInput) have harith : readTime t + computeTime t + emitTime q t output ≤ (arithmeticPolynomial q).eval L := by simp only [arithmeticPolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_X, Polynomial.eval_ofNat, Polynomial.eval_one] unfold computeTime emitTime rw [headerBits_length] omega have htotal := Nat.add_le_add hp harith simpa only [totalTime, timePolynomial, Polynomial.eval_add, Polynomial.eval_comp, Polynomial.eval_mul, Polynomial.eval_ofNat, Polynomial.eval_X, Polynomial.eval_one, L, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using htotal def inTime (q : Nat) (t : GraphTables.Table) (output : List Bool) (ambient : σ) (register : Option Bool) : StateTransition.EvalsToInTime (TM2.step (program q)) ⟨some .init, ((ambient, false), register), frame (GraphTables.tableBits t) [] [] [] [] [] [] [] [] [] [] [] output⟩ (some ⟨none, ((ambient, false), none), frame (GraphTables.tableBits t) (encodeWord t.vertices) [] [] [] (encodeWord t.darts) [] [] [] (encodeWord (vertexTotal t)) (encodeWord (dartTotal q t)) [] (output ++ headerBits q t)⟩) ((timePolynomial q).eval ((GraphTables.tableBits t).length + output.length)) where steps := totalTime q t output evals_in_steps := trace q t output ambient register steps_le_m := totalTime_le q t output end Header namespace Fuel variable {K Λ σ : Type} [DecidableEq K] def guard (fuel : K) (body : Λ) (exit : Option Λ) : TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool) := .pop fuel (fun s bit => (s.1, bit)) (.branch (fun s => s.2.getD false) (.load (fun s => (s.1, none)) (.goto fun _ => body)) (.load (fun s => (s.1, none)) (match exit with | some label => .goto fun _ => label | none => .halt))) theorem guard_succ (fuel : K) (body : Λ) (exit : Option Λ) (base : K → List Bool) (n : Nat) (ambient : σ) (register : Option Bool) : TM2.stepAux (guard fuel body exit) (ambient, register) (Function.update base fuel (encodeWord (n + 1))) = ⟨some body, (ambient, none), Function.update base fuel (encodeWord n)⟩ := by simp [guard, TM2.stepAux, encodeWord, List.replicate_succ] theorem guard_zero (fuel : K) (body : Λ) (exit : Option Λ) (base : K → List Bool) (ambient : σ) (register : Option Bool) : TM2.stepAux (guard fuel body exit) (ambient, register) (Function.update base fuel (encodeWord 0)) = ⟨exit, (ambient, none), Function.update base fuel []⟩ := by cases exit <;> simp [guard, TM2.stepAux, encodeWord] def increment (counter : K) (next : Λ) : TM2.Stmt (fun _ : K => Bool) Λ σ := .push counter (fun _ => true) (.goto fun _ => next) theorem increment_step (counter : K) (next : Λ) (base : K → List Bool) (n : Nat) (state : σ) : TM2.stepAux (increment counter next) state (Function.update base counter (encodeWord n)) = ⟨some next, state, Function.update base counter (encodeWord (n + 1))⟩ := by simp [increment, TM2.stepAux, encodeWord, List.replicate_succ] end Fuel namespace Top abbrev Body := MachineRegularOriginalBody.Tape abbrev Tape := Body ⊕ (Header.Tape ⊕ Fin 4) abbrev Alphabet (_ : Tape) := Bool abbrev State := MachineRegularOriginalBody.State × Option Bool abbrev Data := MachineRegularMetadata.Data abbrev BaseTable := PreprocessingRegularTables.BaseTable private def sumDecidableEq {A B : Type} (left : DecidableEq A) (right : DecidableEq B) : DecidableEq (A ⊕ B) | .inl a, .inl b => match left a b with | .isTrue h => .isTrue (congrArg (Sum.inl : A → A ⊕ B) h) | .isFalse h => .isFalse (fun e => h (Sum.inl.inj e)) | .inr a, .inr b => match right a b with | .isTrue h => .isTrue (congrArg (Sum.inr : B → A ⊕ B) h) | .isFalse h => .isFalse (fun e => h (Sum.inr.inj e)) | .inl _, .inr _ => .isFalse (by intro h; cases h) | .inr _, .inl _ => .isFalse (by intro h; cases h) instance tapeDecidableEq : DecidableEq Tape := sumDecidableEq (sumDecidableEq (inferInstanceAs (DecidableEq (Fin 27))) (sumDecidableEq (inferInstanceAs (DecidableEq MachineRegularMetadata.Extra)) (sumDecidableEq (sumDecidableEq (sumDecidableEq (inferInstanceAs (DecidableEq MachineExpanderRow.Tape)) (inferInstanceAs (DecidableEq MachineExpanderTable.ExtraTape))) (inferInstanceAs (DecidableEq MachineExpanderFamily.ExtraTape))) (inferInstanceAs (DecidableEq MachineCeilingPower.Tape))))) (sumDecidableEq (sumDecidableEq (inferInstanceAs (DecidableEq MachineCloudPrefix.Tape)) (inferInstanceAs (DecidableEq Header.Extra))) (inferInstanceAs (DecidableEq (Fin 4)))) instance tapeBEq : BEq Tape where beq a b := decide (a = b) instance tapeLawfulBEq : LawfulBEq Tape where eq_of_beq := of_decide_eq_true rfl := of_decide_eq_self_eq_true _ instance tapeFintype : Fintype Tape := by change Fintype ((Fin 27 ⊕ (MachineRegularMetadata.Extra ⊕ (((MachineExpanderRow.Tape ⊕ MachineExpanderTable.ExtraTape) ⊕ MachineExpanderFamily.ExtraTape) ⊕ MachineCeilingPower.Tape))) ⊕ ((MachineCloudPrefix.Tape ⊕ Header.Extra) ⊕ Fin 4)) infer_instance def coreTape (i : Fin 27) : Tape := .inl (.inl i) def oldFuel : Tape := .inr (.inr 0) def ownerFuel : Tape := .inr (.inr 1) def dummyFuel : Tape := .inr (.inr 2) def scratch : Tape := .inr (.inr 3) def headerTape (k : Header.Tape) : Tape := if k = Header.tableTape then coreTape 0 else if k = Header.mTape then coreTape 6 else if k = Header.outputTape then coreTape 8 else .inr (.inl k) def headerView : Tape → Option Header.Tape | .inl (.inl i) => match i.val with | 0 => some Header.tableTape | 6 => some Header.mTape | 8 => some Header.outputTape | _ => none | .inl (.inr _) => none | .inr (.inl k) => if k = Header.tableTape ∨ k = Header.mTape ∨ k = Header.outputTape then none else some k | .inr (.inr _) => none theorem headerView_left (k : Header.Tape) : headerView (headerTape k) = some k := by by_cases ht : k = Header.tableTape · subst k; rfl by_cases hm : k = Header.mTape · subst k; rfl by_cases ho : k = Header.outputTape · subst k; rfl simp [headerTape, headerView, ht, hm, ho] theorem headerView_right (j : Tape) (k : Header.Tape) (h : headerView j = some k) : headerTape k = j := by cases j with | inl j => cases j with | inl i => fin_cases i <;> simp_all [headerView] <;> subst k <;> rfl | inr e => cases h | inr j => cases j with | inl i => by_cases hi : i = Header.tableTape ∨ i = Header.mTape ∨ i = Header.outputTape · simp [headerView, hi] at h · have hik : i = k := by simpa [headerView, hi] using h subst k simp only [not_or] at hi simp [headerTape, hi.1, hi.2.1, hi.2.2] | inr i => cases h def bodyView : Tape → Option Body | .inl k => some k | .inr _ => none theorem bodyView_left (k : Body) : bodyView (.inl k) = some k := rfl theorem bodyView_right (j : Tape) (k : Body) (h : bodyView j = some k) : Sum.inl k = j := by cases j with | inl j => cases h; rfl | inr j => cases h def ownerTape : MachineRegularOwnerBody.Tape → Tape | .inl k => .inl k | .inr i => if i.val = 0 then dummyFuel else scratch def ownerView : Tape → Option MachineRegularOwnerBody.Tape | .inl k => some (.inl k) | .inr (.inl _) => none | .inr (.inr i) => match i.val with | 2 => some (.inr 0) | 3 => some (.inr 1) | _ => none theorem ownerView_left (k : MachineRegularOwnerBody.Tape) : ownerView (ownerTape k) = some k := by cases k with | inl k => rfl | inr i => fin_cases i <;> rfl theorem ownerView_right (j : Tape) (k : MachineRegularOwnerBody.Tape) (h : ownerView j = some k) : ownerTape k = j := by cases j with | inl j => cases h; rfl | inr j => cases j with | inl j => cases h | inr i => fin_cases i <;> simp_all [ownerView] <;> subst k <;> rfl def headerStates : (Header.State Unit × (MachineRegularOriginalBody.CoreState × (MachineRegularOriginalBody.FamilyState × Option Bool))) ≃ State where toFun p := (((p.2.1, p.1), p.2.2.1), p.2.2.2) invFun p := (p.1.1.2, (p.1.1.1, (p.1.2, p.2))) left_inv _ := rfl right_inv _ := rfl def readyState (H : BaseTable) : State := (MachineRegularOriginalBody.readyState H, none) inductive CopyPhase | old | owner deriving DecidableEq protected abbrev CopyPhase.enumList : List CopyPhase := [.old, .owner] protected theorem CopyPhase.enumList_getElem?_ctorIdx_eq (x : CopyPhase) : CopyPhase.enumList[x.ctorIdx]? = some x := by cases x <;> rfl protected theorem CopyPhase.enumList_nodup : CopyPhase.enumList.Nodup := by decide instance : Fintype CopyPhase where elems := ⟨CopyPhase.enumList, CopyPhase.enumList_nodup⟩ complete x := by cases x <;> decide def copySource : CopyPhase → Tape | .old => coreTape 6 | .owner => headerTape Header.nTape def copyTarget : CopyPhase → Tape | .old => oldFuel | .owner => ownerFuel inductive Label | header (l : Header.Label) | oldSeed | copyFirst (phase : CopyPhase) | copySecond (phase : CopyPhase) | oldGuard | oldBody (l : MachineRegularOriginalBody.Label) | oldIncrement | ownerSeed | ownerGuard | ownerBody (l : MachineRegularOwnerBody.Label) | ownerIncrement | clear (i : Fin 7) deriving DecidableEq, Fintype def copyExit : CopyPhase → Label | .old => .oldGuard | .owner => .ownerGuard def clearTape : Fin 7 → Tape := ![coreTape 1, coreTape 2, coreTape 5, coreTape 6, headerTape Header.nTape, headerTape Header.verticesTape, headerTape Header.dartsTape] def clearEntry (k : Nat) : Option Label := if h : k < 7 then some (.clear ⟨k, h⟩) else none def program (H : BaseTable) : Label → TM2.Stmt Alphabet Label State | .header l => Lift.statement headerTape Label.header (some .oldSeed) headerStates (Header.program PreprocessingRegularTables.internalDegree l) | .oldSeed => .push (coreTape 1) (fun _ => false) (.goto fun _ => Label.copyFirst CopyPhase.old) | .copyFirst phase => Reduction.MachineTransfer.loopAt (copySource phase) scratch id false (.copyFirst phase) (some (.copySecond phase)) | .copySecond phase => MachineCopy.forkLoop scratch (copySource phase) (copyTarget phase) false (.copySecond phase) (some (copyExit phase)) | .oldGuard => Fuel.guard oldFuel (Label.oldBody MachineRegularOriginalBody.entry) (some Label.ownerSeed) | .oldBody l => Lift.statement Sum.inl Label.oldBody (some .oldIncrement) (Equiv.refl _) (MachineRegularOriginalBody.program H l) | .oldIncrement => Fuel.increment (coreTape 1) Label.oldGuard | .ownerSeed => .push (coreTape 2) (fun _ => false) (.push (coreTape 5) (fun _ => false) (.goto fun _ => Label.copyFirst CopyPhase.owner)) | .ownerGuard => Fuel.guard ownerFuel (.ownerBody MachineRegularOwnerBody.entry) (clearEntry 0) | .ownerBody l => MachineCloudPadding.Placement.statement ownerTape Label.ownerBody (some .ownerIncrement) (MachineRegularOwnerBody.program H l) | .ownerIncrement => Fuel.increment (coreTape 2) Label.ownerGuard | .clear i => MachineDrain.drain (clearTape i) (.clear i) (clearEntry (i.val + 1)) def machine (H : BaseTable) : FinTM2 where K := Tape k₀ := coreTape 0 k₁ := coreTape 8 Γ _ := Bool Λ := Label main := .header .init σ := State initialState := readyState H m := program H def frame (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : Tape → List Bool | .inl k => MachineRegularOriginalBody.frame data k | .inr (.inl k) => header k | .inr (.inr i) => counters i def cfg (H : BaseTable) (label : Option Label) (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : TM2.Cfg Alphabet Label State := ⟨label, readyState H, frame data header counters⟩ @[simp] theorem frame_core (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) (i : Fin 27) : frame data header counters (coreTape i) = MachineRegularMetadata.frame data (.inl i) := rfl theorem bodyPlacement (data extra : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : MachineCloudPadding.Placement.tapes bodyView (MachineRegularOriginalBody.frame data) (frame extra header counters) = frame data header counters := by funext j cases j with | inl j => rfl | inr j => cases j <;> rfl def headerAux (n N R : List Bool) : Header.Tape → List Bool := fun k => if k = Header.nTape then n else if k = Header.verticesTape then N else if k = Header.dartsTape then R else [] @[simp] theorem headerAux_empty : headerAux [] [] [] = (fun _ => []) := by funext k simp [headerAux] theorem headerPlacement (data : Data) (t n m N R output : List Bool) (counters : Fin 4 → List Bool) : MachineCloudPadding.Placement.tapes headerView (Header.frame t n [] [] [] m [] [] [] N R [] output) (frame data (fun _ => []) counters) = frame { data with table := t, darts := m, output := output } (headerAux n N R) counters := by funext j cases j with | inl j => cases j with | inl i => fin_cases i <;> rfl | inr e => cases e with | inl e => cases e <;> rfl | inr e => rfl | inr j => cases j with | inl k => cases k with | inl k => cases k with | inner k => cases k <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr k => cases k <;> rfl | inr i => rfl def inputData (t : GraphTables.Table) (output : List Bool) : Data where table := GraphTables.tableBits t globalIndex := [] owner := [] localRank := [] count := [] offset := [] darts := [] rotor := [] output := output padding := [] level := [] def headerData (t : GraphTables.Table) (output : List Bool) : Data := { inputData t output with darts := encodeWord t.darts } def headerStacks (t : GraphTables.Table) : Header.Tape → List Bool := headerAux (encodeWord t.vertices) (encodeWord (Header.vertexTotal t)) (encodeWord (Header.dartTotal PreprocessingRegularTables.internalDegree t)) theorem headerTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[Header.totalTime PreprocessingRegularTables.internalDegree t output] (some (cfg H (some (.header .init)) (inputData t output) (fun _ => []) counters)) = some (cfg H (some .oldSeed) (headerData t (output ++ Header.headerBits PreprocessingRegularTables.internalDegree t)) (headerStacks t) counters) := by have raw := Header.trace PreprocessingRegularTables.internalDegree t output () none have placed := Lift.trace headerTape headerView headerView_left headerView_right Label.header (some .oldSeed) headerStates (MachineRegularInternalRow.coreInitialState PreprocessingRegularTables.internalDegree MachineRegularOriginalBody.degree_positive (), (MachineRegularFamily.readyState H, none)) (frame (inputData t output) (fun _ => []) counters) (Header.program PreprocessingRegularTables.internalDegree) (program H) (fun _ => rfl) _ _ _ raw simpa only [Lift.configuration, MachineCloudPadding.Placement.label, headerPlacement, headerAux_empty, cfg, readyState, MachineRegularOriginalBody.readyState, headerStates, Equiv.coe_fn_mk, headerData, inputData, headerStacks] using placed def oldData (t : GraphTables.Table) (index : Nat) (output : List Bool) : Data := { headerData t output with globalIndex := encodeWord index } theorem originalData_eq (t : GraphTables.Table) (e : Fin t.darts) (output : List Bool) : MachineRegularOriginalBody.initialData t e output = oldData t e.val output := rfl theorem oldBodyTrace (H : BaseTable) (t : GraphTables.Table) (e : Fin t.darts) (output : List Bool) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[MachineRegularOriginalBody.totalSteps H t e output] (some (cfg H (some (Label.oldBody MachineRegularOriginalBody.entry)) (oldData t e.val output) header counters)) = some (cfg H (some .oldIncrement) (oldData t e.val (output ++ MachineRegularOriginalBody.emittedBits H t e)) header counters) := by have raw := MachineRegularOriginalBody.originalTrace H t e output have placed := Lift.trace Sum.inl bodyView bodyView_left bodyView_right Label.oldBody (some .oldIncrement) (Equiv.refl _) none (frame (oldData t e.val output) header counters) (MachineRegularOriginalBody.program H) (program H) (fun _ => rfl) _ _ _ raw simpa only [Lift.configuration, MachineCloudPadding.Placement.label, bodyPlacement, MachineRegularOriginalBody.cfg, originalData_eq, cfg, readyState, Equiv.refl_apply] using placed def counterStacks (old owners dummy work : List Bool) : Fin 4 → List Bool := ![old, owners, dummy, work] @[simp] theorem frame_oldFuel (data : Data) (header : Header.Tape → List Bool) (old owners dummy work : List Bool) : frame data header (counterStacks old owners dummy work) oldFuel = old := rfl @[simp] theorem frame_ownerFuel (data : Data) (header : Header.Tape → List Bool) (old owners dummy work : List Bool) : frame data header (counterStacks old owners dummy work) ownerFuel = owners := rfl @[simp] theorem update_frame_oldFuel (data : Data) (header : Header.Tape → List Bool) (old owners dummy work replacement : List Bool) : Function.update (frame data header (counterStacks old owners dummy work)) oldFuel replacement = frame data header (counterStacks replacement owners dummy work) := by funext j cases j with | inl j => rfl | inr j => cases j with | inl j => rfl | inr i => fin_cases i <;> rfl @[simp] theorem update_frame_ownerFuel (data : Data) (header : Header.Tape → List Bool) (old owners dummy work replacement : List Bool) : Function.update (frame data header (counterStacks old owners dummy work)) ownerFuel replacement = frame data header (counterStacks old replacement dummy work) := by funext j cases j with | inl j => rfl | inr j => cases j with | inl j => rfl | inr i => fin_cases i <;> rfl @[simp] theorem update_frame_global (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) (replacement : List Bool) : Function.update (frame data header counters) (coreTape 1) replacement = frame { data with globalIndex := replacement } header counters := by funext j cases j with | inl j => cases j with | inl i => fin_cases i <;> rfl | inr e => cases e with | inl e => cases e <;> rfl | inr e => rfl | inr j => cases j <;> rfl @[simp] theorem update_frame_owner (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) (replacement : List Bool) : Function.update (frame data header counters) (coreTape 2) replacement = frame { data with owner := replacement } header counters := by funext j cases j with | inl j => cases j with | inl i => fin_cases i <;> rfl | inr e => cases e with | inl e => cases e <;> rfl | inr e => rfl | inr j => cases j <;> rfl theorem oldGuardStep (H : BaseTable) (data : Data) (header : Header.Tape → List Bool) (remaining : Nat) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .oldGuard) data header (counterStacks (encodeWord (remaining + 1)) [] [] []))) = some (cfg H (some (Label.oldBody MachineRegularOriginalBody.entry)) data header (counterStacks (encodeWord remaining) [] [] [])) := by change some (TM2.stepAux (Fuel.guard oldFuel (Label.oldBody MachineRegularOriginalBody.entry) (some Label.ownerSeed)) (readyState H) _) = _ simp only [Fuel.guard, TM2.stepAux, frame_oldFuel, encodeWord, List.replicate_succ, List.cons_append, List.head?_cons, List.tail_cons, Option.getD_some, Bool.cond_true, update_frame_oldFuel] rfl theorem oldGuardExit (H : BaseTable) (data : Data) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .oldGuard) data header (counterStacks (encodeWord 0) [] [] []))) = some (cfg H (some Label.ownerSeed) data header (counterStacks [] [] [] [])) := by change some (TM2.stepAux (Fuel.guard oldFuel (Label.oldBody MachineRegularOriginalBody.entry) (some Label.ownerSeed)) (readyState H) _) = _ simp only [Fuel.guard, TM2.stepAux, frame_oldFuel, encodeWord, List.replicate_zero, List.nil_append, List.head?_cons, List.tail_cons, Option.getD_some, Bool.cond_false, update_frame_oldFuel] rfl theorem oldIncrementStep (H : BaseTable) (t : GraphTables.Table) (index : Nat) (output : List Bool) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .oldIncrement) (oldData t index output) header counters)) = some (cfg H (some .oldGuard) (oldData t (index + 1) output) header counters) := by change some (TM2.stepAux (Fuel.increment (coreTape 1) Label.oldGuard) (readyState H) (frame (oldData t index output) header counters)) = _ simp only [Fuel.increment, TM2.stepAux, frame_core] change some (⟨some Label.oldGuard, readyState H, Function.update (frame (oldData t index output) header counters) (coreTape 1) (true :: encodeWord index)⟩ : TM2.Cfg (fun _ : Tape => Bool) Label State) = _ rw [update_frame_global] simp only [cfg, oldData, encodeWord, List.replicate_succ, List.cons_append] def oldPrefix (H : BaseTable) (t : GraphTables.Table) (k : Nat) : List Bool := PreprocessingRegularLoopWords.blocksPrefix (MachineRegularOriginalBody.emittedBits H t) k noncomputable def oldElapsed (H : BaseTable) (t : GraphTables.Table) (output : List Bool) : Nat → Nat | 0 => 0 | k + 1 => oldElapsed H t output k + if h : k < t.darts then 1 + MachineRegularOriginalBody.totalSteps H t ⟨k,h⟩ (output ++ oldPrefix H t k) + 1 else 0 private theorem joinTrace {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] theorem oldPrefixTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) (k : Nat) : k ≤ t.darts → (advance (TM2.step (program H)))^[oldElapsed H t output k] (some (cfg H (some .oldGuard) (oldData t 0 output) header (counterStacks (encodeWord t.darts) [] [] []))) = some (cfg H (some .oldGuard) (oldData t k (output ++ oldPrefix H t k)) header (counterStacks (encodeWord (t.darts-k)) [] [] [])) := by induction k with | zero => intro _ simp [oldElapsed, oldPrefix] | succ k ih => intro hk have hlt : k < t.darts := by omega have hremaining : t.darts-k = (t.darts-(k+1))+1 := by omega have previous := ih (by omega) have guard := oldGuardStep H (oldData t k (output ++ oldPrefix H t k)) header (t.darts-(k+1)) rw [← hremaining] at guard have body := oldBodyTrace H t ⟨k,hlt⟩ (output ++ oldPrefix H t k) header (counterStacks (encodeWord (t.darts-(k+1))) [] [] []) have increment := oldIncrementStep H t k ((output ++ oldPrefix H t k) ++ MachineRegularOriginalBody.emittedBits H t ⟨k,hlt⟩) header (counterStacks (encodeWord (t.darts-(k+1))) [] [] []) have combined := joinTrace (joinTrace (joinTrace previous guard) body) increment have bits := PreprocessingRegularLoopWords.blocksPrefix_succ (MachineRegularOriginalBody.emittedBits H t) k hlt change oldPrefix H t (k+1) = oldPrefix H t k ++ MachineRegularOriginalBody.emittedBits H t ⟨k,hlt⟩ at bits simpa only [oldElapsed, dite_eq_left hlt, bits, List.append_assoc, Nat.add_assoc] using combined theorem oldLoopTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[oldElapsed H t output t.darts + 1] (some (cfg H (some .oldGuard) (oldData t 0 output) header (counterStacks (encodeWord t.darts) [] [] []))) = some (cfg H (some Label.ownerSeed) (oldData t t.darts (output ++ oldPrefix H t t.darts)) header (counterStacks [] [] [] [])) := by have prefixRun := oldPrefixTrace H t output header t.darts (Nat.le_refl _) simp only [Nat.sub_self] at prefixRun exact joinTrace prefixRun (oldGuardExit H _ header) @[simp] theorem frame_scratch (data : Data) (header : Header.Tape → List Bool) (old owners dummy work : List Bool) : frame data header (counterStacks old owners dummy work) scratch = work := rfl @[simp] theorem frame_darts (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : frame data header counters (coreTape 6) = data.darts := rfl @[simp] theorem frame_header_n (data : Data) (n N R : List Bool) (counters : Fin 4 → List Bool) : frame data (headerAux n N R) counters (headerTape Header.nTape) = n := rfl theorem oldSeedStep (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .oldSeed) (headerData t output) header counters)) = some (cfg H (some (.copyFirst .old)) (oldData t 0 output) header counters) := by change some (TM2.stepAux (.push (coreTape 1) (fun _ => false) (.goto fun _ => Label.copyFirst CopyPhase.old)) (readyState H) (frame (headerData t output) header counters)) = _ change some (⟨some (Label.copyFirst CopyPhase.old), readyState H, Function.update (frame (headerData t output) header counters) (coreTape 1) [false]⟩ : TM2.Cfg (fun _ : Tape => Bool) Label State) = _ rw [update_frame_global] rfl theorem copyOldTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[2*(t.darts+2)] (some (cfg H (some (.copyFirst .old)) (oldData t 0 output) header (counterStacks [] [] [] []))) = some (cfg H (some .oldGuard) (oldData t 0 output) header (counterStacks (encodeWord t.darts) [] [] [])) := by have h := MachineCopy.copyTrace (coreTape 6) oldFuel scratch (by decide) (by decide) (by decide) false (.copyFirst .old) (.copySecond .old) (some .oldGuard) (program H) rfl rfl (frame (oldData t 0 output) header (counterStacks [] [] [] [])) rfl (MachineRegularOriginalBody.readyState H) none simpa only [frame_darts, oldData, headerData, inputData, encodeWord_length, frame_oldFuel, List.append_nil, update_frame_oldFuel, cfg, readyState, Nat.add_assoc] using h theorem oldStageTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[1+2*(t.darts+2)+(oldElapsed H t output t.darts+1)] (some (cfg H (some .oldSeed) (headerData t output) header (counterStacks [] [] [] []))) = some (cfg H (some Label.ownerSeed) (oldData t t.darts (output ++ oldPrefix H t t.darts)) header (counterStacks [] [] [] [])) := joinTrace (joinTrace (oldSeedStep H t output header _) (copyOldTrace H t output header)) (oldLoopTrace H t output header) @[simp] theorem update_frame_offset (data : Data) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) (replacement : List Bool) : Function.update (frame data header counters) (coreTape 5) replacement = frame { data with offset := replacement } header counters := by funext j cases j with | inl j => cases j with | inl i => fin_cases i <;> rfl | inr e => cases e with | inl e => cases e <;> rfl | inr e => rfl | inr j => cases j <;> rfl def ownerData (t : GraphTables.Table) (index : Nat) (output : List Bool) : Data := { headerData t output with globalIndex := encodeWord (t.darts + PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) index) owner := encodeWord index offset := encodeWord (PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) index) } theorem ownerSeedStep (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some Label.ownerSeed) (oldData t t.darts output) header counters)) = some (cfg H (some (.copyFirst .owner)) (ownerData t 0 output) header counters) := by change some (TM2.stepAux (.push (coreTape 2) (fun _ => false) (.push (coreTape 5) (fun _ => false) (.goto fun _ => Label.copyFirst CopyPhase.owner))) (readyState H) (frame (oldData t t.darts output) header counters)) = _ simp only [TM2.stepAux, frame_core] change some (⟨some (Label.copyFirst CopyPhase.owner), readyState H, Function.update (Function.update (frame (oldData t t.darts output) header counters) (coreTape 2) [false]) (coreTape 5) [false]⟩ : TM2.Cfg (fun _ : Tape => Bool) Label State) = _ rw [update_frame_owner, update_frame_offset] simp only [cfg, ownerData, oldData, PreprocessingPaddingOffsets.offset_zero, Nat.add_zero, encodeWord, List.replicate_zero, List.nil_append] theorem copyOwnerTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) : (advance (TM2.step (program H)))^[2*(t.vertices+2)] (some (cfg H (some (.copyFirst .owner)) (ownerData t 0 output) (headerStacks t) (counterStacks [] [] [] []))) = some (cfg H (some .ownerGuard) (ownerData t 0 output) (headerStacks t) (counterStacks [] (encodeWord t.vertices) [] [])) := by have h := MachineCopy.copyTrace (headerTape Header.nTape) ownerFuel scratch (by decide) (by decide) (by decide) false (.copyFirst .owner) (.copySecond .owner) (some .ownerGuard) (program H) rfl rfl (frame (ownerData t 0 output) (headerStacks t) (counterStacks [] [] [] [])) rfl (MachineRegularOriginalBody.readyState H) none simpa only [headerStacks, frame_header_n, encodeWord_length, frame_ownerFuel, List.append_nil, update_frame_ownerFuel, cfg, readyState, Nat.add_assoc] using h theorem ownerPlacement (data extra : Data) (header : Header.Tape → List Bool) (old owners : List Bool) : MachineCloudPadding.Placement.tapes ownerView (MachineRegularOwnerBody.frame data) (frame extra header (counterStacks old owners [] [])) = frame data header (counterStacks old owners [] []) := by funext j cases j with | inl j => rfl | inr j => cases j with | inl j => rfl | inr i => fin_cases i <;> rfl theorem ownerInitialData_eq (t : GraphTables.Table) (v : Fin t.vertices) (output : List Bool) : MachineRegularOwnerBody.initialData t v output = ownerData t v.val output := rfl theorem ownerBodyTrace (H : BaseTable) (t : GraphTables.Table) (v : Fin t.vertices) (output : List Bool) (header : Header.Tape → List Bool) (owners : List Bool) : (advance (TM2.step (program H)))^[MachineRegularOwnerBody.totalSteps H t v output] (some (cfg H (some (.ownerBody MachineRegularOwnerBody.entry)) (ownerData t v.val output) header (counterStacks [] owners [] []))) = some (cfg H (some .ownerIncrement) (MachineRegularOwnerBody.finalData H t v output) header (counterStacks [] owners [] [])) := by have raw := MachineRegularOwnerBody.ownerTrace H t v output have placed := MachineCloudPadding.Placement.trace ownerTape ownerView ownerView_left ownerView_right Label.ownerBody (some .ownerIncrement) (frame (ownerData t v.val output) header (counterStacks [] owners [] [])) (MachineRegularOwnerBody.program H) (program H) (fun _ => rfl) _ _ _ raw simpa only [MachineCloudPadding.Placement.configuration, MachineCloudPadding.Placement.label, ownerPlacement, MachineRegularOwnerBody.cfg, MachineRegularOwnerBody.readyState, ownerInitialData_eq, cfg, readyState] using placed theorem ownerGuardStep (H : BaseTable) (data : Data) (header : Header.Tape → List Bool) (remaining : Nat) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .ownerGuard) data header (counterStacks [] (encodeWord (remaining+1)) [] []))) = some (cfg H (some (.ownerBody MachineRegularOwnerBody.entry)) data header (counterStacks [] (encodeWord remaining) [] [])) := by change some (TM2.stepAux (Fuel.guard ownerFuel (.ownerBody MachineRegularOwnerBody.entry) (clearEntry 0)) (readyState H) _) = _ simp only [Fuel.guard, TM2.stepAux, frame_ownerFuel, encodeWord, List.replicate_succ, List.cons_append, List.head?_cons, List.tail_cons, Option.getD_some, Bool.cond_true, update_frame_ownerFuel] rfl theorem ownerGuardExit (H : BaseTable) (data : Data) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .ownerGuard) data header (counterStacks [] (encodeWord 0) [] []))) = some (cfg H (clearEntry 0) data header (counterStacks [] [] [] [])) := by change some (TM2.stepAux (Fuel.guard ownerFuel (.ownerBody MachineRegularOwnerBody.entry) (clearEntry 0)) (readyState H) _) = _ simp only [Fuel.guard, TM2.stepAux, frame_ownerFuel, encodeWord, List.replicate_zero, List.nil_append, List.head?_cons, List.tail_cons, Option.getD_some, Bool.cond_false, update_frame_ownerFuel] rfl theorem ownerIncrementStep (H : BaseTable) (t : GraphTables.Table) (v : Fin t.vertices) (output : List Bool) (header : Header.Tape → List Bool) (counters : Fin 4 → List Bool) : (advance (TM2.step (program H)))^[1] (some (cfg H (some .ownerIncrement) (MachineRegularOwnerBody.finalData H t v output) header counters)) = some (cfg H (some .ownerGuard) (ownerData t (v.val+1) (output ++ MachineRegularOwnerBody.ownerBits H t v)) header counters) := by change some (TM2.stepAux (Fuel.increment (coreTape 2) Label.ownerGuard) (readyState H) (frame (MachineRegularOwnerBody.finalData H t v output) header counters)) = _ simp only [Fuel.increment, TM2.stepAux, frame_core] change some (⟨some Label.ownerGuard, readyState H, Function.update (frame (MachineRegularOwnerBody.finalData H t v output) header counters) (coreTape 2) (true :: encodeWord v.val)⟩ : TM2.Cfg (fun _ : Tape => Bool) Label State) = _ rw [update_frame_owner] have offset := PreprocessingRegularBounds.offset_succ (PreprocessingRegularTables.padding t) v.val v.isLt simp only [cfg, ownerData, headerData, inputData, MachineRegularOwnerBody.finalData, MachineRegularOwnerBody.initialData, offset, encodeWord, List.replicate_succ, List.cons_append, Nat.add_assoc] def ownerPrefix (H : BaseTable) (t : GraphTables.Table) (k : Nat) : List Bool := PreprocessingRegularLoopWords.blocksPrefix (MachineRegularOwnerBody.ownerBits H t) k noncomputable def ownerElapsed (H : BaseTable) (t : GraphTables.Table) (output : List Bool) : Nat → Nat | 0 => 0 | k+1 => ownerElapsed H t output k + if h : k < t.vertices then 1 + MachineRegularOwnerBody.totalSteps H t ⟨k,h⟩ (output ++ ownerPrefix H t k) + 1 else 0 theorem ownerPrefixTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) (k : Nat) : k ≤ t.vertices → (advance (TM2.step (program H)))^[ownerElapsed H t output k] (some (cfg H (some .ownerGuard) (ownerData t 0 output) header (counterStacks [] (encodeWord t.vertices) [] []))) = some (cfg H (some .ownerGuard) (ownerData t k (output ++ ownerPrefix H t k)) header (counterStacks [] (encodeWord (t.vertices-k)) [] [])) := by induction k with | zero => intro _ simp [ownerElapsed, ownerPrefix] | succ k ih => intro hk have hlt : k < t.vertices := by omega have hremaining : t.vertices-k = (t.vertices-(k+1))+1 := by omega have previous := ih (by omega) have guard := ownerGuardStep H (ownerData t k (output ++ ownerPrefix H t k)) header (t.vertices-(k+1)) rw [← hremaining] at guard have body := ownerBodyTrace H t ⟨k,hlt⟩ (output ++ ownerPrefix H t k) header (encodeWord (t.vertices-(k+1))) have increment := ownerIncrementStep H t ⟨k,hlt⟩ (output ++ ownerPrefix H t k) header (counterStacks [] (encodeWord (t.vertices-(k+1))) [] []) have combined := joinTrace (joinTrace (joinTrace previous guard) body) increment have bits := PreprocessingRegularLoopWords.blocksPrefix_succ (MachineRegularOwnerBody.ownerBits H t) k hlt change ownerPrefix H t (k+1) = ownerPrefix H t k ++ MachineRegularOwnerBody.ownerBits H t ⟨k,hlt⟩ at bits simpa only [ownerElapsed, dite_eq_left hlt, bits, List.append_assoc, Nat.add_assoc] using combined theorem ownerLoopTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) (header : Header.Tape → List Bool) : (advance (TM2.step (program H)))^[ownerElapsed H t output t.vertices+1] (some (cfg H (some .ownerGuard) (ownerData t 0 output) header (counterStacks [] (encodeWord t.vertices) [] []))) = some (cfg H (clearEntry 0) (ownerData t t.vertices (output ++ ownerPrefix H t t.vertices)) header (counterStacks [] [] [] [])) := by have prefixRun := ownerPrefixTrace H t output header t.vertices (Nat.le_refl _) simp only [Nat.sub_self] at prefixRun exact joinTrace prefixRun (ownerGuardExit H _ header) theorem ownerStageTrace (H : BaseTable) (t : GraphTables.Table) (output : List Bool) : (advance (TM2.step (program H)))^[1+2*(t.vertices+2)+(ownerElapsed H t output t.vertices+1)] (some (cfg H (some Label.ownerSeed) (oldData t t.darts output) (headerStacks t) (counterStacks [] [] [] []))) = some (cfg H (clearEntry 0) (ownerData t t.vertices (output ++ ownerPrefix H t t.vertices)) (headerStacks t) (counterStacks [] [] [] [])) := joinTrace (joinTrace (ownerSeedStep H t output (headerStacks t) _) (copyOwnerTrace H t output)) (ownerLoopTrace H t output (headerStacks t)) theorem owner_output_eq_ownerPrefix (H : BaseTable) (t : GraphTables.Table) (k : Nat) : (Header.headerBits PreprocessingRegularTables.internalDegree t ++ oldPrefix H t t.darts) ++ ownerPrefix H t k = PreprocessingRegularBounds.ownerPrefix t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) k := by have oldBits : MachineRegularOriginalBody.emittedBits H t = PreprocessingRegularWords.originalVertexBits t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) := rfl have ownerBits : MachineRegularOwnerBody.ownerBits H t = PreprocessingRegularBounds.ownerBits t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) := rfl simp only [Header.headerBits, Header.vertexTotal, Header.dartTotal, oldPrefix, ownerPrefix, PreprocessingRegularLoopWords.blocksPrefix_all, PreprocessingRegularBounds.ownerPrefix, PreprocessingRegularBounds.header] rw [oldBits, ownerBits] def cleaned (base : Tape → List Bool) : Nat → Tape → List Bool | 0 => base | k+1 => if h : k < 7 then Function.update (cleaned base k) (clearTape ⟨k,h⟩) [] else cleaned base k def cleanupTime (base : Tape → List Bool) : Nat → Nat | 0 => 0 | k+1 => cleanupTime base k + if h : k < 7 then ((cleaned base k) (clearTape ⟨k,h⟩)).length+1 else 0 theorem drainTrace (H : BaseTable) (i : Fin 7) (base : Tape → List Bool) : (advance (TM2.step (program H)))^[(base (clearTape i)).length+1] (some ⟨some (.clear i), readyState H, base⟩) = some ⟨clearEntry (i.val+1), readyState H, Function.update base (clearTape i) []⟩ := by have h := MachineDrain.drainTrace (clearTape i) (.clear i) (clearEntry (i.val+1)) (program H) rfl base (base (clearTape i)) (MachineRegularOriginalBody.readyState H) none simpa only [Function.update_eq_self, readyState] using h theorem cleanupPrefixTrace (H : BaseTable) (base : Tape → List Bool) (k : Nat) (hk : k ≤ 7) : (advance (TM2.step (program H)))^[cleanupTime base k] (some ⟨clearEntry 0, readyState H, base⟩) = some ⟨clearEntry k, readyState H, cleaned base k⟩ := by induction k with | zero => rfl | succ k ih => have h : k < 7 := by omega have first := ih (by omega) have second := drainTrace H ⟨k,h⟩ (cleaned base k) have atEntry : clearEntry k = some (.clear ⟨k,h⟩) := by simp only [clearEntry, dite_eq_left h] rw [atEntry] at first simpa only [cleanupTime, cleaned, dite_eq_left h] using joinTrace first second theorem cleanupTrace (H : BaseTable) (base : Tape → List Bool) : (advance (TM2.step (program H)))^[cleanupTime base 7] (some ⟨clearEntry 0, readyState H, base⟩) = some ⟨none, readyState H, cleaned base 7⟩ := by simpa only [clearEntry, lt_self_iff_false, dite_false] using cleanupPrefixTrace H base 7 le_rfl def finalStacks (t : GraphTables.Table) (output : List Bool) : Tape → List Bool := frame (ownerData t t.vertices output) (headerStacks t) (counterStacks [] [] [] []) theorem cleaned_finalStacks (t : GraphTables.Table) (output : List Bool) : cleaned (finalStacks t output) 7 = frame (inputData t output) (fun _ => []) (counterStacks [] [] [] []) := by funext j cases j with | inl j => cases j with | inl i => fin_cases i <;> rfl | inr e => cases e with | inl e => cases e <;> rfl | inr e => rfl | inr j => cases j with | inl k => cases k with | inl k => cases k with | inner k => cases k <;> rfl | bound => rfl | remaining => rfl | total => rfl | inr k => cases k <;> rfl | inr i => fin_cases i <;> rfl theorem cleaned_length_le (base : Tape → List Bool) (k : Nat) : ∀ j, (cleaned base k j).length ≤ (base j).length := by induction k with | zero => intro j; exact Nat.le_refl _ | succ k ih => intro j simp only [cleaned] split · rename_i hk by_cases hj : j = clearTape ⟨k,hk⟩ · simp [hj] · simpa only [Function.update_of_ne hj] using ih j · exact ih j theorem cleanupTime_le (base : Tape → List Bool) (cap : Nat) (bounded : ∀ i : Fin 7, (base (clearTape i)).length ≤ cap) (k : Nat) : cleanupTime base k ≤ k*(cap+1) := by induction k with | zero => simp [cleanupTime] | succ k ih => simp only [cleanupTime] split · rename_i hk have hword := (cleaned_length_le base k (clearTape ⟨k,hk⟩)).trans (bounded ⟨k,hk⟩) calc cleanupTime base k + ((cleaned base k (clearTape ⟨k,hk⟩)).length+1) ≤ k*(cap+1)+(cap+1) := by omega _ = (k+1)*(cap+1) := by simp only [Nat.add_mul, one_mul] · exact ih.trans (Nat.mul_le_mul_right _ (by omega)) theorem cleanupTime_final_le (t : GraphTables.Table) (output : List Bool) : cleanupTime (finalStacks t output) 7 ≤ (7*(ExpanderFamily.growth*(PreprocessingRegularTables.internalDegree+4)+4)) * (PreprocessingMachineBounds.inputLength t+1) := by let L := PreprocessingMachineBounds.inputLength t let g := ExpanderFamily.growth let q := PreprocessingRegularTables.internalDegree let C := g*(q+4)+4 have hm : t.darts ≤ L := GraphTables.darts_le_tableBits_length t have hn : t.vertices ≤ L := GraphTables.vertices_le_tableBits_length t have hs : PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) t.vertices ≤ g*L := PreprocessingMachineBounds.prefix_le_input t t.vertices have hN : Header.vertexTotal t ≤ g*L := PreprocessingMachineBounds.regularVertices_le_input t have hone : 1 ≤ C := by dsimp [C]; omega have hg : g ≤ C := by have h := Nat.mul_le_mul_left g (show 1 ≤ q+4 by omega) dsimp [C] omega have hgp : g+1 ≤ C := by have h := Nat.mul_le_mul_left g (show 1 ≤ q+4 by omega) dsimp [C] omega have hgq : g*(q+1) ≤ C := by have h := Nat.mul_le_mul_left g (show q+1 ≤ q+4 by omega) dsimp [C] omega have hmC : t.darts ≤ C*L := hm.trans (by simpa using Nat.mul_le_mul_right L hone) have hnC : t.vertices ≤ C*L := hn.trans (by simpa using Nat.mul_le_mul_right L hone) have hsC : PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) t.vertices ≤ C*L := hs.trans (Nat.mul_le_mul_right L hg) have hNC : Header.vertexTotal t ≤ C*L := hN.trans (Nat.mul_le_mul_right L hg) have hxC : t.darts + PreprocessingPaddingOffsets.offset (PreprocessingRegularTables.padding t) t.vertices ≤ C*L := by calc _ ≤ L+g*L := Nat.add_le_add hm hs _ = (g+1)*L := by simp only [Nat.add_mul, one_mul, Nat.add_comm] _ ≤ C*L := Nat.mul_le_mul_right L hgp have hRC : Header.dartTotal q t ≤ C*L := by calc _ ≤ (g*L)*(q+1) := Nat.mul_le_mul_right _ hN _ = (g*(q+1))*L := by ac_rfl _ ≤ C*L := Nat.mul_le_mul_right L hgq have bounds : ∀ i : Fin 7, (finalStacks t output (clearTape i)).length ≤ C*L+1 := by intro i fin_cases i · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hxC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hnC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hsC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hmC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hnC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hNC 1 · change (encodeWord _).length ≤ _ simpa only [encodeWord_length] using Nat.add_le_add_right hRC 1 have actual := cleanupTime_le (finalStacks t output) (C*L+1) bounds 7 have hC : 2 ≤ C := by dsimp [C]; omega change cleanupTime (finalStacks t output) 7 ≤ (7*C)*(L+1) nlinarith def headerOutput (t : GraphTables.Table) : List Bool := Header.headerBits PreprocessingRegularTables.internalDegree t def oldOutput (H : BaseTable) (t : GraphTables.Table) : List Bool := headerOutput t ++ oldPrefix H t t.darts def finalOutput (H : BaseTable) (t : GraphTables.Table) : List Bool := oldOutput H t ++ ownerPrefix H t t.vertices noncomputable def totalTime (H : BaseTable) (t : GraphTables.Table) : Nat := Header.totalTime PreprocessingRegularTables.internalDegree t [] + (1+2*(t.darts+2)+(oldElapsed H t (headerOutput t) t.darts+1)) + (1+2*(t.vertices+2)+(ownerElapsed H t (oldOutput H t) t.vertices+1)) + cleanupTime (finalStacks t (finalOutput H t)) 7 theorem old_output_eq_originalPrefix (H : BaseTable) (t : GraphTables.Table) (k : Nat) : Header.headerBits PreprocessingRegularTables.internalDegree t ++ oldPrefix H t k = PreprocessingRegularBounds.originalPrefix t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) k := rfl theorem finalOutput_eq (H : BaseTable) (t : GraphTables.Table) : finalOutput H t = PortTables.tableBits (PreprocessingRegularTables.regularize H t) := by change finalOutput H t = PortTables.tableBits (PreprocessingRegularTables.ofCloudTables t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t)) rw [PreprocessingRegularWords.tableBits_ofCloudTables] have oldBits : MachineRegularOriginalBody.emittedBits H t = PreprocessingRegularWords.originalVertexBits t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) := rfl have ownerBits : MachineRegularOwnerBody.ownerBits H t = (fun v => (List.ofFn (PreprocessingRegularWords.dummyVertexBits t (PreprocessingRegularTables.padding t) (PreprocessingRegularTables.familyCloudTable H t) v)).flatten) := rfl simp only [finalOutput, oldOutput, headerOutput, Header.headerBits, Header.vertexTotal, Header.dartTotal, oldPrefix, ownerPrefix, PreprocessingRegularLoopWords.blocksPrefix_all, List.append_assoc] rw [oldBits, ownerBits] end Top end BinPackingGames.Foundations.Complexity.MachineRegularTable end OAI