| import Mathlib |
| import OAI.Computability.MinUncut.Graphs.DemandOrder |
| import OAI.Computability.MinUncut.Machines.ArenaMachineProgram |
| import OAI.Computability.MinUncut.Machines.CodeFiniteMachine |
| import OAI.Computability.MinUncut.Graphs.GraphWordCodec |
|
|
| namespace OAI |
|
|
| namespace MinUncut.Costed.GraphRegisters |
| open _root_.Turing _root_.OAI.Turing _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Polynomial MinUncutGames.Foundations.Complexity |
| open MinUncut.PathRealization |
| noncomputable section |
|
|
| def fullGraphMachine : FinTM2 := |
| MachineSequential.machine (codeMachine rawRenderer.code) GraphCodec.machine id .cons |
|
|
| lemma fullGraphMachine_finiteAlphabet (k : fullGraphMachine.K) : |
| Finite (fullGraphMachine.Γ k) := |
| sequential_finiteAlphabet _ _ _ _ (codeMachine_finiteAlphabet _) GraphCodec.finiteAlphabet k |
|
|
| def renderTime : Polynomial ℕ := C 10*rawRenderer.bound+10 |
|
|
| def packedInput {N : ℕ} (ds : List (Demand (Fin N))) (k : ℕ) : List ℕ := |
| N::ds.length::k::packDemands ds |
|
|
| lemma rawRenderer_output {N : ℕ} (ds : List (Demand (Fin N))) (k : ℕ) : |
| renderRaw (packedInput ds k)= |
| (N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds) := by |
| rw [packedInput,renderRaw_encode,rawGraphWords,rawTable_pack] |
|
|
| lemma codec_length_le (n k : ℕ) (v : List Bool) (rest : List ℕ) : |
| (MinUncutGames.BinaryEncoding.nameBits n++v++MinUncutGames.BinaryEncoding.nameBits k).length≤ |
| 2*magnitude (n::(v.map Bool.toNat++2::k::rest)) := by |
| have hf (a : ℕ) : (MinUncutGames.BinaryEncoding.nameBits a).length≤2*a+1 := by |
| have h := trNat_length_le a |
| rw [GraphCodec.trNat_bits,List.length_map] at h |
| have hg (w : List Bool) : (MinUncutGames.BinaryEncoding.frame w).length=2*w.length+1 := by |
| induction w with |
| | nil => rfl |
| | cons b w ih => simp only [MinUncutGames.BinaryEncoding.frame,List.length_cons,ih]; omega |
| rw [MinUncutGames.BinaryEncoding.nameBits,hg] |
| omega |
| have hm (w : List Bool) : w.length+k+3≤ magnitude (w.map Bool.toNat++2::k::rest) := by |
| induction w with |
| | nil => simp only [List.map_nil,List.nil_append,magnitude_cons,List.length_nil]; omega |
| | cons b w ih => |
| simp only [List.map_cons,List.cons_append,magnitude_cons,List.length_cons] |
| omega |
| have hn := hf n; have hk := hf k; have h := hm v |
| simp only [List.length_append,magnitude_cons] |
| omega |
|
|
| def fullGraphMachine_outputs {N : ℕ} (ds : List (Demand (Fin N))) (k : ℕ) (hk : 1≤k) : |
| TM2OutputsInTime fullGraphMachine (trList (packedInput ds k)) |
| (some (listOutput ds k hk).bits) (renderTime.eval (magnitude (packedInput ds k))) := by |
| apply Classical.choice |
| obtain ⟨t,ht,hc⟩ := rawRenderer.run (packedInput ds k) |
| rw [rawRenderer_output] at hc |
| have h1 := hc.finiteMachine |
| have h2 := GraphCodec.outputsInTime (N+ds.length*3) k (canonicalTable ds) (packDemands ds) |
| have h2' : TM2OutputsInTime GraphCodec.machine |
| ((trList ((N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds))).map id) |
| (some (MinUncutGames.BinaryEncoding.nameBits (N+ds.length*3)++canonicalTable ds++MinUncutGames.BinaryEncoding.nameBits k)) |
| (2*bitsize ((N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds))+ |
| (MinUncutGames.BinaryEncoding.nameBits (N+ds.length*3)++canonicalTable ds++MinUncutGames.BinaryEncoding.nameBits k).length+2) := by |
| erw [List.map_id] |
| exact h2 |
| have h := MachineSequential.execute (codeMachine rawRenderer.code) GraphCodec.machine id Γ'.cons |
| _ _ _ _ _ h1 h2' |
| have hm := rawRenderer.size (packedInput ds k) |
| rw [rawRenderer_output] at hm |
| have hb := (bitsize_le_magnitude _).trans hm |
| have hl := codec_length_le (N+ds.length*3) k (canonicalTable ds) (packDemands ds) |
| rw [←listOutput_bits ds k hk] at h |
| refine ⟨⟨h.toEvalsTo,le_trans h.steps_le_m ?_⟩⟩ |
| simp only [renderTime,eval_add,eval_mul,eval_C,eval_ofNat] |
| have hb2 := bitsize_le_magnitude ((N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds)) |
| have hl2 := hl |
| rw [←listOutput_bits ds k hk] at hl2 |
| change t + 1 + 2 * ((trList ((N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds))).length + 1) + |
| (2*bitsize ((N+ds.length*3)::((canonicalTable ds).map Bool.toNat++2::k::packDemands ds))+(listOutput ds k hk).bits.length+2) ≤ _ |
| simp only [bitsize] at hb hb2 ⊢ |
| omega |
|
|
| end |
| end MinUncut.Costed.GraphRegisters |
|
|
| namespace MinUncut.Costed.Arena |
| open _root_.Turing _root_.OAI.Turing _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Turing.ToPartrec Polynomial |
| open MinUncutGames.Foundations.Complexity |
| noncomputable section |
|
|
| def universalWords (v : List ℕ) : List ℕ := |
| let z := prepareOutput (control v) |
| let r := (outputStep^[z.headI] z.tail).drop 2 |
| (prefixStep^[r.headI] (0::r.tail)).tail |
|
|
| def universalWordsProgram : PolyProgram universalWords := |
| reversePrefixProgram.comp ((PolyProgram.drop 2).comp |
| (outputLoopProgram.comp (prepareOutputProgram.comp controlProgram))) |
|
|
| lemma universalWords_spec {c v w B} (hr : Runs c v w B) (hl : w.length≤B) (base : Heap) : |
| ∃h,universalWords (B::(initialState c v base).encode)=w++w.reverse++2::words h := by |
| obtain ⟨t,ht,hc⟩ := hr |
| obtain ⟨h,out,ho,he⟩ := CodeRun.interpreted hc base ht |
| refine ⟨h,?_⟩ |
| have hh : control (B::(initialState c v base).encode)=B::(State.mk 2 0 out 0 h).encode := by |
| simpa only [control,List.headI_cons,keepTick_iter] using congrArg (List.cons B) he |
| simp only [universalWords,hh] |
| have hp : prepareOutput (B::(State.mk 2 0 out 0 h).encode)=B::(OutputState.mk out h []).encode := rfl |
| rw [hp] |
| simp only [List.headI_cons,List.tail_cons] |
| rw [ho.output_padded [] hl] |
| simp only [List.append_nil,OutputState.encode,List.cons_append,List.nil_append, |
| List.drop_succ_cons,List.drop_zero,List.headI_cons,List.tail_cons] |
| rw [reversePrefix_spec,List.reverse_reverse,List.append_assoc] |
|
|
| def universalGraphMachine : FinTM2 := |
| MachineSequential.machine (codeMachine universalWordsProgram.code) GraphCodec.machine id .cons |
|
|
| lemma universalGraphMachine_finiteAlphabet (k : universalGraphMachine.K) : |
| Finite (universalGraphMachine.Γ k) := |
| sequential_finiteAlphabet _ _ _ _ (codeMachine_finiteAlphabet _) GraphCodec.finiteAlphabet k |
|
|
| def universalGraphTime : Polynomial ℕ := C 10*universalWordsProgram.bound+10 |
|
|
| def graphPacked (c : Code) (v : List ℕ) (B : ℕ) : List ℕ := B::(initialState c v []).encode |
|
|
| def universalGraphMachine_outputs {c : Code} {v : List ℕ} {B n k : ℕ} |
| {table : List Bool} {rest : List ℕ} |
| (hc : Runs c v (n::(table.map Bool.toNat++2::k::rest)) B) |
| (hl : (n::(table.map Bool.toNat++2::k::rest)).length≤B) : |
| TM2OutputsInTime universalGraphMachine (trList (graphPacked c v B)) |
| (some (MinUncutGames.BinaryEncoding.nameBits n++table++MinUncutGames.BinaryEncoding.nameBits k)) |
| (universalGraphTime.eval (magnitude (graphPacked c v B))) := by |
| apply Classical.choice |
| obtain ⟨h,he⟩ := universalWords_spec hc hl [] |
| let junk := rest++(n::(table.map Bool.toNat++2::k::rest)).reverse++2::words h |
| have he' : universalWords (graphPacked c v B)=n::(table.map Bool.toNat++2::k::junk) := by |
| simpa only [graphPacked,List.cons_append,List.append_assoc,junk] using he |
| obtain ⟨t,ht,hr⟩ := universalWordsProgram.run (graphPacked c v B) |
| rw [he'] at hr |
| have h1 := hr.finiteMachine |
| have h2 := GraphCodec.outputsInTime n k table junk |
| have h2' : TM2OutputsInTime GraphCodec.machine |
| ((trList (n::(table.map Bool.toNat++2::k::junk))).map id) |
| (some (MinUncutGames.BinaryEncoding.nameBits n++table++MinUncutGames.BinaryEncoding.nameBits k)) |
| (2*bitsize (n::(table.map Bool.toNat++2::k::junk))+ |
| (MinUncutGames.BinaryEncoding.nameBits n++table++MinUncutGames.BinaryEncoding.nameBits k).length+2) := by |
| have input_eq : @List.map (GraphCodec.machine.Γ GraphCodec.machine.k₀) |
| (GraphCodec.machine.Γ GraphCodec.machine.k₀) id |
| (trList (n::(table.map Bool.toNat++2::k::junk))) = |
| trList (n::(table.map Bool.toNat++2::k::junk)) := List.map_id _ |
| simpa only [input_eq] using h2 |
| have hh := MachineSequential.execute (codeMachine universalWordsProgram.code) GraphCodec.machine id Γ'.cons |
| _ _ _ _ _ h1 h2' |
| have hm := universalWordsProgram.size (graphPacked c v B) |
| rw [he'] at hm |
| have hb := bitsize_le_magnitude (n::(table.map Bool.toNat++2::k::junk)) |
| have ho := GraphRegisters.codec_length_le n k table junk |
| refine ⟨⟨hh.toEvalsTo,hh.steps_le_m.trans ?_⟩⟩ |
| change t+1+2*((trList (n::(table.map Bool.toNat++2::k::junk))).length+1)+ |
| (2*bitsize (n::(table.map Bool.toNat++2::k::junk))+ |
| (MinUncutGames.BinaryEncoding.nameBits n++table++MinUncutGames.BinaryEncoding.nameBits k).length+2)≤_ |
| simp only [universalGraphTime,eval_add,eval_mul,eval_C,eval_ofNat] |
| simp only [bitsize] at hb ⊢ |
| omega |
| end |
| end MinUncut.Costed.Arena |
|
|
| end OAI |
|
|
