| import Mathlib |
| import OAI.Computability.MinUncut.PCP.TupleBound |
| import OAI.Computability.MinUncut.Machines.RuntimeSpace |
|
|
| namespace OAI |
|
|
| namespace MinUncutGames.Foundations.Hastad.SourceGenerator |
|
|
| open Turing Complexity Target |
| open SourceGeneratorModel SourceGeneratorProgram SourceGeneratorContract |
|
|
| noncomputable section |
|
|
| variable {u D : Nat} |
| local instance generatorExtraDecidableEq : DecidableEq (Extra u D) := Classical.decEq _ |
|
|
| def prefixPolynomial (u D : Nat) : Polynomial Nat := |
| SourceStartup.timePolynomial u D + SourceGeneratorTraversal.timePolynomial u D + 1 |
|
|
| def timePolynomial (u D : Nat) (hD : 0 < D) : Polynomial Nat := |
| SourceRuntimeSpace.completedTime (SourceGeneratorProgram.machine u D hD) |
| (clearKeys u D).length (prefixPolynomial u D) |
|
|
| def beforeFinish (F : Formula) (hD : 0 < D) : (SourceGeneratorProgram.machine u D hD).Cfg := |
| ⟨SourceRuntimeFinish.entry (clearKeys u D) SourceGeneratorProgram.Label.finish, |
| (initialAmbient u D hD, none), SourceGeneratorTraversal.traversalOutput F hD⟩ |
|
|
| def enterFinishInTime (F : Formula) (hD : 0 < D) : |
| StateTransition.EvalsToInTime (SourceGeneratorProgram.machine u D hD).step |
| ⟨some .finishEnter, (initialAmbient u D hD, none), |
| SourceGeneratorTraversal.traversalOutput F hD⟩ |
| (some (beforeFinish F hD)) 1 where |
| steps := 1 |
| evals_in_steps := by |
| change some (TM2.stepAux |
| (Reduction.MachineTransfer.exitAt (accumulatorTape u D) |
| (SourceRuntimeFinish.entry (clearKeys u D) SourceGeneratorProgram.Label.finish)) |
| _ _) = _ |
| cases h : SourceRuntimeFinish.entry (clearKeys u D) SourceGeneratorProgram.Label.finish <;> |
| simp only [Reduction.MachineTransfer.exitAt, beforeFinish, TM2.stepAux] <;> |
| erw [h] <;> rfl |
| steps_le_m := Nat.le_refl _ |
|
|
| def prefixInTime (F : Formula) (hm : 0 < F.clauses.length) (hD : 0 < D) : |
| StateTransition.EvalsToInTime (SourceGeneratorProgram.machine u D hD).step |
| (initList (SourceGeneratorProgram.machine u D hD) (formulaBits F)) |
| (some (beforeFinish F hD)) ((prefixPolynomial u D).eval (formulaBits F).length) := by |
| have start := startupInTime (u := u) F hm hD |
| let traversal := Classical.choice (SourceGeneratorTraversal.traversalInPolynomialTime |
| (u := u) F hm hD) |
| have first := StateTransition.EvalsToInTime.trans |
| (SourceGeneratorProgram.machine u D hD).step _ _ _ _ _ start traversal |
| have joined := StateTransition.EvalsToInTime.trans |
| (SourceGeneratorProgram.machine u D hD).step _ _ _ _ _ first (enterFinishInTime F hD) |
| refine { steps := joined.steps, evals_in_steps := joined.evals_in_steps, steps_le_m := ?_ } |
| apply joined.steps_le_m.trans |
| simp only [prefixPolynomial, Polynomial.eval_add, Polynomial.eval_one] |
| omega |
|
|
| theorem output_empty (F : Formula) (hD : 0 < D) : |
| SourceGeneratorTraversal.traversalOutput F hD (outputTape u D) = [] := by |
| rw [SourceGeneratorTraversal.traversalOutput_frame F hD _ |
| (Ne.symm (accumulator_ne_output u D))] |
| exact SourceStartup.ready_work_blank F (.extra (.inr ())) |
| (by simp) (by simp) (by simp) |
|
|
| theorem halted_configuration (F : Formula) (hD : 0 < D) : |
| (⟨none, (initialAmbient u D hD, none), |
| SourceRuntimeFinish.canonicalTapes (outputTape u D) |
| (SourceGeneratorTraversal.traversalOutput F hD (accumulatorTape u D)).reverse⟩ : |
| (SourceGeneratorProgram.machine u D hD).Cfg) = |
| haltList (SourceGeneratorProgram.machine u D hD) |
| (MinUncutGames.Reduction.SourceEncoding.inputBits (SourceOccurrences.sourceInput F u D hD)) := by |
| rw [SourceGeneratorTraversal.traversalOutput_accumulator, List.reverse_reverse] |
| simp only [haltList, SourceGeneratorProgram.machine] |
| congr 1 |
| funext k |
| by_cases hk : k = outputTape u D |
| · subst k |
| simp [SourceRuntimeFinish.canonicalTapes] |
| erw [Function.update_self] |
| rfl |
| · simp [SourceRuntimeFinish.canonicalTapes, hk] |
| erw [Function.update_of_ne hk] |
|
|
| def outputInTime (F : NonemptyFormula) (hD : 0 < D) : |
| TM2OutputsInTime (SourceGeneratorProgram.machine u D hD) (inputEncoding F) |
| (some (MinUncutGames.Reduction.SourceEncoding.inputBits (sourceMap u D hD F))) |
| ((timePolynomial u D hD).eval (inputEncoding F).length) := by |
| have hm : 0 < F.val.clauses.length := List.length_pos_iff.mpr F.property |
| have prefixRun := prefixInTime (u := u) F.val hm hD |
| have keepAcc : accumulatorTape u D ∉ clearKeys u D := by |
| simp [mem_clearKeys] |
| have keepOut : outputTape u D ∉ clearKeys u D := by |
| simp [mem_clearKeys] |
| have covers : ∀ k, k ≠ accumulatorTape u D → k ≠ outputTape u D → k ∈ clearKeys u D := |
| fun k ha ho => (mem_clearKeys u D k).mpr ⟨ha, ho⟩ |
| have finish := SourceRuntimeFinish.finishInTime (clearKeys u D) |
| (accumulatorTape u D) (outputTape u D) (accumulator_ne_output u D) |
| keepAcc keepOut covers (initialAmbient u D hD) SourceGeneratorProgram.Label.finish none |
| (SourceGeneratorProgram.program u D hD) (fun _ => rfl) |
| (SourceGeneratorTraversal.traversalOutput F.val hD) (output_empty F.val hD) |
| (initialAmbient u D hD) none |
| erw [halted_configuration F.val hD] at finish |
| have joined := SourceRuntimeSpace.prefixAndFinishInTime |
| (SourceGeneratorProgram.machine u D hD) (formulaBits F.val) (prefixPolynomial u D) |
| prefixRun (clearKeys u D) (accumulatorTape u D) (outputTape u D) |
| keepAcc keepOut covers (SourceGeneratorTraversal.traversalOutput F.val hD) |
| (output_empty F.val hD) (fun _ => rfl) finish |
| exact joined |
|
|
| def computableInPolyTime (u D : Nat) (hD : 0 < D) : |
| TM2ComputableInPolyTime inputEncoding MinUncutGames.Reduction.SourceEncoding.inputBits |
| (sourceMap u D hD) where |
| tm := SourceGeneratorProgram.machine u D hD |
| inputAlphabet := Equiv.refl Bool |
| outputAlphabet := Equiv.refl Bool |
| time := timePolynomial u D hD |
| outputsFun F := by |
| change TM2OutputsInTime (machine u D hD) ((inputEncoding F).map id) |
| (some ((MinUncutGames.Reduction.SourceEncoding.inputBits (sourceMap u D hD F)).map id)) _ |
| have input_eq : @List.map ((machine u D hD).Γ (machine u D hD).k₀) |
| ((machine u D hD).Γ (machine u D hD).k₀) id (inputEncoding F) = |
| inputEncoding F := List.map_id _ |
| have output_eq : @List.map ((machine u D hD).Γ (machine u D hD).k₁) |
| ((machine u D hD).Γ (machine u D hD).k₁) id |
| (MinUncutGames.Reduction.SourceEncoding.inputBits (sourceMap u D hD F)) = |
| MinUncutGames.Reduction.SourceEncoding.inputBits (sourceMap u D hD F) := List.map_id _ |
| simpa only [input_eq, output_eq] using outputInTime (u := u) F hD |
|
|
| theorem finite_work_alphabets (u D : Nat) (hD : 0 < D) |
| (k : (computableInPolyTime u D hD).tm.K) : |
| Finite ((computableInPolyTime u D hD).tm.Γ k) := by |
| change Finite Bool |
| infer_instance |
|
|
| def forErrorComputableInPolyTime (η ξ : ℚ) (hη : 0 < η) (hη1 : η ≤ 1) (hξ : 0 < ξ) : |
| TM2ComputableInPolyTime inputEncoding MinUncutGames.Reduction.SourceEncoding.inputBits |
| (errorMap η ξ hη hη1 hξ) := by |
| let D := SourceNoiseParameter.noiseDenominator ξ |
| let hD := SourceNoiseParameter.noiseDenominator_pos ξ |
| let u := SourceGap.repetitionCount η ξ hη hη1 hξ D hD |
| exact computableInPolyTime u D hD |
|
|
| theorem forError_finite_work_alphabets (η ξ : ℚ) (hη : 0 < η) (hη1 : η ≤ 1) (hξ : 0 < ξ) |
| (k : (forErrorComputableInPolyTime η ξ hη hη1 hξ).tm.K) : |
| Finite ((forErrorComputableInPolyTime η ξ hη hη1 hξ).tm.Γ k) := by |
| change Finite Bool |
| infer_instance |
|
|
| end |
|
|
| end MinUncutGames.Foundations.Hastad.SourceGenerator |
|
|
| namespace MinUncutGames.Foundations.PCP |
|
|
| structure ConstraintGraph (V E A : Type*) where |
| reverse : E ≃ E |
| reverse_involutive : Function.Involutive reverse |
| tail : E → V |
| accepts : E → A → A → Bool |
| reverse_accepts : ∀ e a b, accepts (reverse e) b a = accepts e a b |
|
|
| namespace ConstraintGraph |
|
|
| variable {V E A : Type*} |
|
|
| def head (G : ConstraintGraph V E A) (e : E) : V := G.tail (G.reverse e) |
|
|
| @[simp] theorem head_reverse (G : ConstraintGraph V E A) (e : E) : |
| G.head (G.reverse e) = G.tail e := by |
| simp only [head, G.reverse_involutive e] |
|
|
| def edgeSatisfied (G : ConstraintGraph V E A) (labeling : V → A) (e : E) : Bool := |
| G.accepts e (labeling (G.tail e)) (labeling (G.head e)) |
|
|
| @[simp] theorem edgeSatisfied_reverse (G : ConstraintGraph V E A) |
| (labeling : V → A) (e : E) : |
| G.edgeSatisfied labeling (G.reverse e) = G.edgeSatisfied labeling e := by |
| simpa only [edgeSatisfied, head, G.reverse_involutive e] using |
| G.reverse_accepts e (labeling (G.tail e)) (labeling (G.tail (G.reverse e))) |
|
|
| def Satisfiable (G : ConstraintGraph V E A) : Prop := |
| ∃ labeling : V → A, ∀ e, G.edgeSatisfied labeling e = true |
|
|
| def rejectedDarts [Fintype E] (G : ConstraintGraph V E A) (labeling : V → A) : |
| Finset E := Finset.univ.filter (fun e => G.edgeSatisfied labeling e = false) |
|
|
| def rejectionCount [Fintype E] (G : ConstraintGraph V E A) (labeling : V → A) : Nat := |
| (G.rejectedDarts labeling).card |
|
|
| theorem mem_rejectedDarts [Fintype E] (G : ConstraintGraph V E A) |
| (labeling : V → A) (e : E) : |
| e ∈ G.rejectedDarts labeling ↔ G.edgeSatisfied labeling e = false := by |
| simp [rejectedDarts] |
|
|
| theorem rejectionCount_le [Fintype E] (G : ConstraintGraph V E A) |
| (labeling : V → A) : G.rejectionCount labeling ≤ Fintype.card E := by |
| exact Finset.card_le_card (Finset.filter_subset _ _) |
|
|
| theorem rejected_exists_of_not_satisfiable (G : ConstraintGraph V E A) |
| (unsat : ¬ G.Satisfiable) (labeling : V → A) : |
| ∃ e, G.edgeSatisfied labeling e = false := by |
| classical |
| by_contra none |
| apply unsat |
| refine ⟨labeling, fun e => ?_⟩ |
| have notFalse : G.edgeSatisfied labeling e ≠ false := by |
| intro h |
| exact none ⟨e, h⟩ |
| cases h : G.edgeSatisfied labeling e <;> simp_all |
| |
| theorem rejectionCount_positive [Fintype E] (G : ConstraintGraph V E A) |
| (unsat : ¬ G.Satisfiable) (labeling : V → A) : |
| 1 ≤ G.rejectionCount labeling := by |
| obtain ⟨e, he⟩ := G.rejected_exists_of_not_satisfiable unsat labeling |
| exact Finset.one_le_card.mpr ⟨e, (G.mem_rejectedDarts labeling e).mpr he⟩ |
|
|
| end ConstraintGraph |
|
|
| end MinUncutGames.Foundations.PCP |
|
|
| end OAI |
|
|
