| import OAI.Computability.BinPacking.PCP.NormalizationLoopMachine |
| import OAI.Computability.BinPacking.Reductions.BinaryHeaderMachine |
|
|
| namespace OAI |
|
|
| namespace BinPackingCompleteness.NormalizationMachine |
|
|
| open Turing BinPackingGames.Foundations Complexity |
| open MachineComposition BinPackingGames.Reduction.MachineTransfer |
|
|
| abbrev Tape := Fin 10 |
| abbrev Alphabet (_ : Tape) := Bool |
| abbrev State := NormalizationLoopMachine.State Unit |
|
|
| inductive Label |
| | readVariables | readCount |
| | loop (label : NormalizationLoopMachine.Label) |
| | restore | clauseStart | clauseLoop | variableStart | variableLoop | reject |
| deriving DecidableEq, Fintype |
|
|
| def loopTapes : Fin 9 → Tape := Fin.castSucc |
|
|
| theorem loopTapes_injective : Function.Injective loopTapes := by |
| intro i j h |
| apply Fin.ext |
| exact congrArg (fun k : Tape => k.val) h |
|
|
| def program : Label → TM2.Stmt Alphabet Label State |
| | .readVariables => Hastad.SourceMachine.fieldLoop 0 1 .readVariables (some .readCount) |
| | .readCount => Hastad.SourceMachine.fieldLoop 0 2 .readCount (some (.loop .guard)) |
| | .loop label => NormalizationLoopMachine.instruction loopTapes Label.loop |
| (some .restore) (some .reject) label |
| | .restore => loopAt 8 9 id false .restore (some .clauseStart) |
| | .clauseStart => BinaryHeaderMachine.delimiter 9 .clauseLoop |
| | .clauseLoop => loopAt 3 9 id false .clauseLoop (some .variableStart) |
| | .variableStart => BinaryHeaderMachine.delimiter 9 .variableLoop |
| | .variableLoop => loopAt 1 9 id false .variableLoop none |
| | .reject => .halt |
|
|
| abbrev machine : FinTM2 where |
| K := Tape |
| k₀ := 0 |
| k₁ := 9 |
| Γ := Alphabet |
| Λ := Label |
| main := .readVariables |
| σ := State |
| initialState := NormalizationLoopMachine.reset () |
| m := program |
|
|
| def tapes (input fresh remaining clauseCounter reversed output : List Bool) : Tape → List Bool := |
| fun k => if k = 0 then input else if k = 1 then fresh else if k = 2 then remaining |
| else if k = 3 then clauseCounter else if k = 8 then reversed else if k = 9 then output else [] |
|
|
| def cfg (label : Option Label) (input fresh remaining clauseCounter reversed output : List Bool) : |
| machine.Cfg := ⟨label, NormalizationLoopMachine.reset (), |
| tapes input fresh remaining clauseCounter reversed output⟩ |
|
|
| theorem initList_eq (input : List Bool) : |
| initList machine input = cfg (some .readVariables) input [] [] [] [] [] := by |
| unfold initList cfg |
| congr 1 |
| funext k |
| fin_cases k <;> simp [tapes, machine] |
|
|
| theorem haltList_eq (output : List Bool) : |
| haltList machine output = cfg none [] [] [] [] [] output := by |
| unfold haltList cfg |
| congr 1 |
| funext k |
| fin_cases k <;> simp [tapes, machine] |
|
|
| private theorem joinTrace {X : Type*} {f : X → X} {a b c : X} {n m : Nat} |
| (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] |
|
|
| theorem readVariablesTrace (n : Nat) (suffix : List Bool) : |
| (advance machine.step)^[n + 1] |
| (some (cfg (some .readVariables) (encodeWord n ++ suffix) [] [] [] [] [])) = |
| some (cfg (some .readCount) suffix (List.replicate n true) [] [] [] []) := by |
| have updated (input fresh : List Bool) : |
| Hastad.SourceMachine.fieldTapes (0 : Tape) 1 (tapes [] [] [] [] [] []) input fresh = |
| tapes input fresh [] [] [] [] := by |
| funext k |
| fin_cases k <;> simp [Hastad.SourceMachine.fieldTapes, tapes] |
| have run := Hastad.SourceMachine.fieldLoopTrace (0 : Tape) 1 (by decide) |
| .readVariables (some .readCount) program rfl (tapes [] [] [] [] [] []) n suffix [] |
| (NormalizationLoopMachine.reset ()).1 none |
| simp only [updated, List.append_nil] at run |
| exact run |
|
|
| theorem readCountTrace (n m : Nat) (suffix : List Bool) : |
| (advance machine.step)^[m + 1] |
| (some (cfg (some .readCount) (encodeWord m ++ suffix) (List.replicate n true) [] [] [] [])) = |
| some (cfg (some (.loop .guard)) suffix (List.replicate n true) (List.replicate m true) [] [] []) := by |
| have updated (input remaining : List Bool) : |
| Hastad.SourceMachine.fieldTapes (0 : Tape) 2 (tapes [] (List.replicate n true) [] [] [] []) |
| input remaining = tapes input (List.replicate n true) remaining [] [] [] := by |
| funext k |
| fin_cases k <;> simp [Hastad.SourceMachine.fieldTapes, tapes] |
| have run := Hastad.SourceMachine.fieldLoopTrace (0 : Tape) 2 (by decide) |
| .readCount (some (.loop .guard)) program rfl |
| (tapes [] (List.replicate n true) [] [] [] []) m suffix [] |
| (NormalizationLoopMachine.reset ()).1 none |
| simp only [updated, List.append_nil] at run |
| exact run |
|
|
| theorem headersTrace (n m : Nat) (suffix : List Bool) : |
| (advance machine.step)^[n + m + 2] |
| (some (cfg (some .readVariables) (encodeWord n ++ encodeWord m ++ suffix) [] [] [] [] [])) = |
| some (cfg (some (.loop .guard)) suffix (List.replicate n true) (List.replicate m true) [] [] []) := by |
| have first := readVariablesTrace n (encodeWord m ++ suffix) |
| have second := readCountTrace n m suffix |
| have full := joinTrace first second |
| have count : n + 1 + (m + 1) = n + m + 2 := by omega |
| simpa only [count, List.append_assoc] using full |
|
|
| theorem restoreTrace (fresh clauseCounter body : List Bool) : |
| (advance machine.step)^[body.length + 1] |
| (some (cfg (some .restore) [] fresh [] clauseCounter body.reverse [])) = |
| some (cfg (some .clauseStart) [] fresh [] clauseCounter [] body) := by |
| change (nextAt (9 : Tape) program)^[body.length + 1] |
| (some (cfg (some .restore) [] fresh [] clauseCounter body.reverse [])) = _ |
| have updated : tapesAt (8 : Tape) 9 (tapes [] fresh [] clauseCounter body.reverse []) [] body = |
| tapes [] fresh [] clauseCounter [] body := by |
| funext k |
| fin_cases k <;> simp [tapesAt, tapes] |
| have run := transferAt_fromTapes (Γ := Alphabet) (8 : Tape) 9 (by decide) id false |
| .restore (some .clauseStart) program rfl (tapes [] fresh [] clauseCounter body.reverse []) |
| (NormalizationLoopMachine.reset ()).1 none |
| have source : tapes [] fresh [] clauseCounter body.reverse [] 8 = body.reverse := rfl |
| have output : tapes [] fresh [] clauseCounter body.reverse [] 9 = [] := rfl |
| rw [source, output, List.length_reverse, List.reverse_reverse, List.map_id_fun, |
| List.append_nil, id_eq, updated] at run |
| exact run |
|
|
| theorem headerOutputTrace (n m : Nat) (body : List Bool) : |
| (advance machine.step)^[n + m + 4] |
| (some (cfg (some .clauseStart) [] (List.replicate n true) [] |
| (List.replicate m true) [] body)) = |
| some (cfg none [] [] [] [] [] (encodeWord n ++ encodeWord m ++ body)) := by |
| change (advance (TM2.step program))^[n + m + 4] |
| (some ⟨some .clauseStart, ((NormalizationLoopMachine.reset ()).1, none), |
| tapes [] (List.replicate n true) [] (List.replicate m true) [] body⟩) = |
| some ⟨none, ((NormalizationLoopMachine.reset ()).1, none), |
| tapes [] [] [] [] [] (encodeWord n ++ encodeWord m ++ body)⟩ |
| have updated (fresh clauses output : List Bool) : |
| BinaryHeaderMachine.tapes (1 : Tape) 3 9 (tapes [] [] [] [] [] []) fresh clauses output = |
| tapes [] fresh [] clauses [] output := by |
| funext k |
| fin_cases k <;> simp [BinaryHeaderMachine.tapes, tapes] |
| have run := BinaryHeaderMachine.headerTrace (1 : Tape) 3 9 (by decide) (by decide) (by decide) |
| .clauseStart .clauseLoop .variableStart .variableLoop none program rfl rfl rfl rfl |
| (tapes [] [] [] [] [] []) (NormalizationLoopMachine.reset ()).1 n m body none |
| simp only [updated] at run |
| exact run |
|
|
| theorem loopTrace (formula : Target.Formula) : |
| (advance machine.step)^[NormalizationLoopMachine.steps formula.variables formula.clauses] |
| (some (cfg (some (.loop .guard)) (encodeWords (formula.clauses.flatMap clauseWords)) |
| (List.replicate formula.variables true) (List.replicate formula.clauses.length true) |
| [] [] [])) = |
| some (cfg (some .restore) [] |
| (List.replicate (formula.variables + 4 * formula.clauses.length) true) [] |
| (List.replicate (13 * formula.clauses.length) true) |
| (NormalizationStream.blocks formula.variables formula.clauses).reverse []) := by |
| change (advance (TM2.step program))^[NormalizationLoopMachine.steps formula.variables formula.clauses] |
| (some ⟨some (.loop .guard), NormalizationLoopMachine.reset (), |
| tapes (encodeWords (formula.clauses.flatMap clauseWords)) |
| (List.replicate formula.variables true) (List.replicate formula.clauses.length true) |
| [] [] []⟩) = |
| some ⟨some .restore, NormalizationLoopMachine.reset (), |
| tapes [] (List.replicate (formula.variables + 4 * formula.clauses.length) true) [] |
| (List.replicate (13 * formula.clauses.length) true) |
| (NormalizationStream.blocks formula.variables formula.clauses).reverse []⟩ |
| have updated (input : List Bool) (fresh remaining : Nat) (counter output : List Bool) : |
| NormalizationLoopMachine.loopTapes loopTapes (tapes [] [] [] [] [] []) |
| input fresh remaining counter output = |
| tapes input (List.replicate fresh true) (List.replicate remaining true) counter output [] := by |
| funext k |
| fin_cases k <;> simp [NormalizationLoopMachine.loopTapes, loopTapes, tapes] |
| have run := NormalizationLoopMachine.loopTrace loopTapes loopTapes_injective Label.loop |
| (some .restore) (some .reject) program (fun _ => rfl) |
| (tapes [] [] [] [] [] []) () formula.clauses [] formula.variables [] [] |
| (by intros; simp [tapes]) |
| simp only [updated, List.append_nil, List.replicate_zero] at run |
| exact run |
|
|
| theorem formulaBits_eq (formula : Target.Formula) : |
| formulaBits formula = encodeWord formula.variables ++ encodeWord formula.clauses.length ++ |
| encodeWords (formula.clauses.flatMap clauseWords) := by |
| simp only [formulaBits, formulaWords, encodeWords_append, encodeWords, |
| List.append_nil, List.append_assoc] |
|
|
| def steps (formula : Target.Formula) : Nat := |
| (formula.variables + formula.clauses.length + 2) + |
| NormalizationLoopMachine.steps formula.variables formula.clauses + |
| ((NormalizationStream.blocks formula.variables formula.clauses).length + 1) + |
| ((formula.variables + 4 * formula.clauses.length) + 13 * formula.clauses.length + 4) |
|
|
| theorem normalizationTrace (formula : Target.Formula) : |
| (advance machine.step)^[steps formula] (some (initList machine (formulaBits formula))) = |
| some (haltList machine (formulaBits (Normalization.normalize formula))) := by |
| have first := headersTrace formula.variables formula.clauses.length |
| (encodeWords (formula.clauses.flatMap clauseWords)) |
| have second := loopTrace formula |
| have third := restoreTrace |
| (List.replicate (formula.variables + 4 * formula.clauses.length) true) |
| (List.replicate (13 * formula.clauses.length) true) |
| (NormalizationStream.blocks formula.variables formula.clauses) |
| have fourth := headerOutputTrace (formula.variables + 4 * formula.clauses.length) |
| (13 * formula.clauses.length) (NormalizationStream.blocks formula.variables formula.clauses) |
| have full := joinTrace (joinTrace (joinTrace first second) third) fourth |
| rw [initList_eq, haltList_eq, NormalizationStream.encoded_normalize, formulaBits_eq] |
| exact full |
|
|
| theorem header_counts_le (formula : Target.Formula) : |
| formula.variables ≤ (formulaBits formula).length ∧ |
| formula.clauses.length ≤ (formulaBits formula).length := by |
| rw [formulaBits_eq] |
| simp only [List.length_append, encodeWord_length] |
| omega |
|
|
| noncomputable def timePolynomial : Polynomial Nat := |
| Polynomial.C 1000 * (Polynomial.X + Polynomial.C 1) ^ 2 |
|
|
| theorem steps_le (formula : Target.Formula) : |
| steps formula ≤ timePolynomial.eval (formulaBits formula).length := by |
| let B := (formulaBits formula).length |
| let M := formula.variables + 4 * formula.clauses.length |
| have variablesBound : formula.variables ≤ B := (header_counts_le formula).1 |
| have clausesBound : formula.clauses.length ≤ B := (header_counts_le formula).2 |
| have addressBound : M ≤ 5 * B := by dsimp [M]; omega |
| have loopBound := NormalizationLoopMachine.steps_le formula.variables M formula.clauses |
| (by dsimp [M]; omega) (Nat.le_refl M) |
| have loopUniform : NormalizationLoopMachine.steps formula.variables formula.clauses ≤ |
| B * (420 * B + 128) + 1 := |
| loopBound.trans (Nat.add_le_add_right |
| (Nat.mul_le_mul clausesBound (by omega)) 1) |
| have bodyBound := NormalizationStream.blocks_length_le formula.clauses formula.variables M |
| (by dsimp [M]; omega) (Nat.le_refl M) |
| have bodyUniform : (NormalizationStream.blocks formula.variables formula.clauses).length ≤ |
| B * (39 * (5 * B + 3)) := |
| bodyBound.trans (Nat.mul_le_mul clausesBound (by omega)) |
| simp only [timePolynomial, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_add, |
| Polynomial.eval_C, Polynomial.eval_X] |
| change steps formula ≤ 1000 * (B + 1) ^ 2 |
| unfold steps |
| nlinarith |
|
|
| def outputsInTime (formula : Target.Formula) : |
| TM2OutputsInTime machine (formulaBits formula) |
| (some (formulaBits (Normalization.normalize formula))) |
| (timePolynomial.eval (formulaBits formula).length) where |
| steps := steps formula |
| evals_in_steps := normalizationTrace formula |
| steps_le_m := steps_le formula |
|
|
| noncomputable def computableInPolyTime : |
| TM2ComputableInPolyTime formulaBits formulaBits Normalization.normalize where |
| tm := machine |
| inputAlphabet := Equiv.refl Bool |
| outputAlphabet := Equiv.refl Bool |
| time := timePolynomial |
| outputsFun formula := by |
| change TM2OutputsInTime machine ((formulaBits formula).map id) |
| (some ((formulaBits (Normalization.normalize formula)).map id)) |
| (timePolynomial.eval (formulaBits formula).length) |
| simpa only [List.map_id_fun, id_eq] using outputsInTime formula |
|
|
| theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by |
| change Finite Bool |
| infer_instance |
|
|
| theorem computation_finiteAlphabet : MachineFiniteAlphabet.FiniteAlphabet computableInPolyTime.tm := |
| machine_finiteAlphabet |
|
|
| end BinPackingCompleteness.NormalizationMachine |
|
|
| end OAI |
|
|
