File size: 4,769 Bytes
2f887db | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | 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
|