| import Mathlib |
| import OAI.Computability.MinUncut.Encoding.PortTableEncoding |
| import OAI.Computability.MinUncut.Search.UniformRational |
| import OAI.Computability.MinUncut.Machines.GraphCoreMachine |
| import OAI.Computability.MinUncut.Encoding.BitOutputBound |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace MinUncut.Uniform |
| open MinUncut.Costed MinUncut.Costed.Arena |
| open _root_.Turing _root_.OAI.Turing Turing.ToPartrec _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Polynomial |
| open MinUncutGames MinUncutGames.Foundations.Complexity |
| open MinUncutGames.BinaryEncoding |
| attribute [local irreducible] MinUncut.Preprocess.selectedInner MinUncut.Preprocess.selectedOuter |
| attribute [local irreducible] frontend frontendMachine program output initializerCode |
|
|
| def framedFrontend : FinTM2 := |
| Framed.machine frontendMachine.tm frontendMachine.inputAlphabet frontendMachine.outputAlphabet |
|
|
| def fullMachine : FinTM2 := |
| MachineSequential.machine framedFrontend coreMachine frontendMachine.outputAlphabet false |
| lemma full_finite (k : fullMachine.K) : Finite (fullMachine.Γ k) := |
| sequential_finiteAlphabet _ _ _ _ |
| (Framed.finiteAlphabet _ _ _ frontend_finite) core_finite k |
|
|
| def frontSize : Polynomial ℕ := |
| X+C (Runtime.programPushBound frontendMachine.tm)*frontendMachine.time |
| lemma frontSize_bound (F : BinaryFormula.Formula) : |
| (MinUncutGames.Foundations.Complexity.formulaBits (frontend F).val).length≤ |
| frontSize.eval (formulaBits F).length := |
| Runtime.encodedOutputLength frontendMachine F |
|
|
| def fullTime (K : ℕ) : Polynomial ℕ := |
| frontendMachine.time+C (4*(nameBits K).length+3)+C 2*frontSize+(coreTime K).comp frontSize |
|
|
| def full_outputs (K : ℕ) (F : BinaryFormula.Formula) : |
| TM2OutputsInTime fullMachine |
| ((inputBits (K,F)).map frontendMachine.inputAlphabet.symm) |
| (some (output K F).bits) ((fullTime K).eval (formulaBits F).length) := by |
| let v:=formulaBits F |
| let w:=MinUncutGames.Foundations.Complexity.formulaBits (frontend F).val |
| let mid:=(nameBits K++w).map frontendMachine.outputAlphabet.symm |
| let h1:=Framed.execute frontendMachine.tm frontendMachine.inputAlphabet frontendMachine.outputAlphabet |
| K v w _ (frontendMachine.outputsFun F) |
| have handoff:mid.map frontendMachine.outputAlphabet=nameBits K++w:=by |
| simp only [mid,List.map_map,Function.comp_def,Equiv.apply_symm_apply] |
| exact List.map_id _ |
| let h2: TM2OutputsInTime coreMachine (mid.map frontendMachine.outputAlphabet) |
| (some (output K F).bits) ((coreTime K).eval w.length):=by |
| erw [handoff] |
| exact core_outputs K F |
| let hh:=MachineSequential.execute framedFrontend coreMachine frontendMachine.outputAlphabet false |
| _ _ _ _ _ h1 h2 |
| have hs:=frontSize_bound F |
| have hc:=evalNat_mono (coreTime K) hs |
| refine ⟨hh.toEvalsTo,hh.steps_le_m.trans ?_⟩ |
| change frontendMachine.time.eval v.length+2*(nameBits K).length+1+ |
| 2*(mid.length+1)+(coreTime K).eval w.length≤(fullTime K).eval v.length |
| simp only [mid,List.length_map,List.length_append,fullTime,eval_add,eval_C,eval_mul,eval_comp] |
| dsimp only [v,w] at * |
| omega |
|
|
| def computation : TM2Computable inputBits Output.bits (fun p=>output p.1 p.2) where |
| tm := fullMachine |
| inputAlphabet := frontendMachine.inputAlphabet |
| outputAlphabet := Equiv.refl Bool |
| outputsFun p := by |
| change TM2Outputs fullMachine |
| ((inputBits (p.1,p.2)).map frontendMachine.inputAlphabet.symm) |
| (some ((output p.1 p.2).bits.map id)) |
| erw [List.map_id] |
| exact (full_outputs p.1 p.2).toEvalsTo |
|
|
| def outputSize (K : ℕ) : Polynomial ℕ := |
| C 2*(C (nameBits K).length+X+fullTime K*C (Runtime.programPushBound fullMachine)) |
| lemma outputSize_bound (K : ℕ) (F : BinaryFormula.Formula) : |
| (output K F).vertices+(output K F).bits.length≤ |
| (outputSize K).eval (formulaBits F).length := by |
| have h:=graph_size_of_runtime fullMachine (output K F) |
| ((inputBits (K,F)).map frontendMachine.inputAlphabet.symm) |
| (output K F).bits ((fullTime K).eval (formulaBits F).length) rfl (full_outputs K F) |
| erw [List.length_map] at h |
| simpa only [inputBits,List.length_append,outputSize, |
| eval_mul,eval_add,eval_C,eval_X] using h |
|
|
| def reduction : Reduction where |
| reduce := output |
| machine := computation |
| finiteAlphabet := full_finite |
| time := fullTime |
| runtime K F := by |
| change TM2OutputsInTime fullMachine |
| ((inputBits (K,F)).map frontendMachine.inputAlphabet.symm) |
| (some ((output K F).bits.map id)) ((fullTime K).eval (formulaBits F).length) |
| erw [List.map_id] |
| exact full_outputs K F |
| size := outputSize |
| output_size := outputSize_bound |
| yes K _ F hf := output_yes K F hf |
| no := output_no |
| end MinUncut.Uniform |
| namespace MinUncut |
|
|
| theorem main : Nonempty Reduction := ⟨Uniform.reduction⟩ |
| end MinUncut |
|
|
| end |
| end |
|
|
| end OAI |
|
|
