| import OAI.Computability.WeisfeilerLeman.BoundedRun |
|
|
| namespace OAI |
|
|
| namespace WLTime.Diagonal |
| @[simp] theorem unary_length (n : ℕ) : (unary n).length=n+1 := by simp [unary] |
| @[simp] theorem entryBits_length (e : Entry) : (entryBits e).length=e.1+e.2.1+e.2.2+3 := by |
| simp [entryBits]; omega |
| theorem tableBits_length_upper (es : List Entry) (q g : ℕ) |
| (he : ∀ e∈es,e.1<q ∧ e.2.1<g ∧ e.2.2<3) : |
| (tableBits es).length ≤ (q+g+3)*es.length := by |
| induction es with |
| | nil => simp [tableBits] |
| | cons e es ih => |
| have h := he e (by simp) |
| have hs := ih (fun x hx => he x (by simp [hx])) |
| change (entryBits e++tableBits es).length ≤ _ |
| rw [List.length_append,entryBits_length,List.length_cons] |
| nlinarith |
| theorem tableBits_length_lower (es : List Entry) : es.length ≤ (tableBits es).length := by |
| induction es with |
| | nil => simp [tableBits] |
| | cons e es ih => |
| change (e::es).length ≤ (entryBits e++tableBits es).length |
| rw [List.length_cons,List.length_append,entryBits_length] |
| omega |
| theorem designation_length (M : OneTape) : |
| (designation M).length=2*(M.states+M.symbols+2+(tableBits (raw M).table).length)+1 := by |
| simp only [designation,List.length_append,unary_length,description,Raw.bits,raw] |
| ring |
| theorem designation_bounds (M : OneTape) {m : ℕ} (hm : (designation M).length ≤ m) : |
| M.states ≤ m ∧ M.symbols ≤ m ∧ M.states*M.symbols ≤ m ∧ |
| (tableBits (raw M).table).length ≤ m := by |
| rw [designation_length] at hm |
| have h := tableBits_length_lower (raw M).table |
| rw [(raw_valid M).2.2.1] at h |
| change M.states*M.symbols ≤ (tableBits (raw M).table).length at h |
| omega |
| theorem designation_upper (M : OneTape) (B : ℕ) (hq : M.states ≤ B) (hg : M.symbols ≤ B) |
| (hB : 3 ≤ B) : (designation M).length ≤ 13*B^3 := by |
| have he := tableBits_length_upper (raw M).table M.states M.symbols (raw_valid M).2.2.2 |
| rw [(raw_valid M).2.2.1] at he |
| have ht : (tableBits (raw M).table).length ≤ 3*B^3 := by |
| calc |
| _ ≤ (M.states+M.symbols+3)*(M.states*M.symbols) := he |
| _ ≤ (3*B)*(B*B) := Nat.mul_le_mul (by omega) (Nat.mul_le_mul hq hg) |
| _ = 3*B^3 := by ring |
| have hp : B ≤ B^3 := Nat.le_self_pow (by decide) B |
| rw [designation_length] |
| omega |
| end WLTime.Diagonal |
| namespace WLTime.Universal |
| theorem stepBound_small (M : OneTape) {m : ℕ} (hfit : (Diagonal.designation M).length ≤ m) |
| (hm : 1 ≤ m) : stepBound M ≤ 1000*m^2 := by |
| obtain ⟨hq,hg,hqg,hbits⟩ := Diagonal.designation_bounds M hfit |
| unfold stepBound |
| calc |
| _ ≤ (m+1)*(30*m+60*m+60*m+100)+50*m+100*m+100 := by gcongr |
| _ ≤ 1000*m^2 := by nlinarith |
| theorem timeBound_small (s : ℕ) (M : OneTape) {m : ℕ} |
| (hfit : (Diagonal.designation M).length ≤ m) (hm : 2 ≤ m) |
| (hs : 1 ≤ s) (hsm : 18*s ≤ m) |
| (hfactor : 8*((boundedProgram s).scratch+Fintype.card Reg+1)*1200^2 ≤ m) : |
| timeBound s M m ≤ m^(2*s+5) := by |
| obtain ⟨hq,hg,_,_⟩ := Diagonal.designation_bounds M hfit |
| have hstep := stepBound_small M hfit (by omega) |
| have hpow : m ≤ m^s := Nat.le_self_pow (by omega) m |
| have h1 : 65*m+3*M.states+5*M.symbols+21+(stepBound M+18*s)*m^s ≤ 1200*m^(s+2) := by |
| rw [pow_add,pow_two] |
| have hm2 : m ≤ m*m := by nlinarith |
| have hpos : 1 ≤ m^s := one_le_pow₀ (by omega) |
| nlinarith |
| unfold timeBound |
| calc |
| _ ≤ 8*((boundedProgram s).scratch+Fintype.card Reg+1)*(1200*m^(s+2))^2 := by gcongr |
| _ = (8*((boundedProgram s).scratch+Fintype.card Reg+1)*1200^2)*m^(2*s+4) := by ring |
| _ ≤ m*m^(2*s+4) := Nat.mul_le_mul_right _ hfactor |
| _ = m^(2*s+5) := by |
| simpa only [show 2*s+5=(2*s+4)+1 by omega] using (pow_succ' m (2*s+4)).symm |
| end WLTime.Universal |
|
|
| namespace WLTime.Diagonal |
|
|
| theorem pointwise_contradiction (D : OneTape) (w : List Bool) (T : ℕ) |
| (ht : D.toTM.halts w) (hb : D.toTM.time w ≤ T) |
| (hc : D.toTM.accepts w ↔ ¬∃ t ≤ T,(D.toTM.run w t).state.val=1) : False := by |
| rw [bounded_accepts_iff D w T ht hb] at hc |
| exact not_iff_self hc.symm |
|
|
| theorem padded_designation (D : OneTape) (data : List Bool) (m : ℕ) |
| (hm : (designation D).length+data.length ≤ m) : |
| let w := designation D++data++List.replicate (m-((designation D).length+data.length)) false |
| w.length=m ∧ designated w=some D := by |
| dsimp |
| constructor |
| · simp only [List.length_append,List.length_replicate] |
| omega |
| · rw [List.append_assoc] |
| exact designated_prefix D _ |
|
|
| end WLTime.Diagonal |
|
|
| namespace WLTime.Numeric |
| open Filter |
| open scoped Topology |
| theorem polylog_sublinear (K r : ℕ) : |
| ∃ m₀ : ℕ, ∀ m ≥ m₀, K*((Nat.digits 2 m).length+1)^r ≤ m := by |
| have h : (fun x : ℝ => ((K : ℝ)*3^r)*(Real.logb 2 x)^r) =o[atTop] id := |
| Real.isLittleO_pow_logb_id_atTop.const_mul_left _ |
| have hb := tendsto_natCast_atTop_atTop.eventually (h.bound (by norm_num : (0 : ℝ)<1)) |
| have hall : ∀ᶠ m : ℕ in atTop, K*((Nat.digits 2 m).length+1)^r ≤ m := by |
| filter_upwards [hb,eventually_ge_atTop 2] with m hm h2 |
| have hm0 : m ≠ 0 := by omega |
| have hm2R : (2 : ℝ) ≤ m := by exact_mod_cast h2 |
| have hmposR : (0 : ℝ) < m := by linarith |
| have hlog : 1 ≤ Real.logb 2 (m : ℝ) := by |
| rw [Real.le_logb_iff_rpow_le (by norm_num) hmposR] |
| simpa using hm2R |
| have hd : (((Nat.digits 2 m).length+1 : ℕ) : ℝ) ≤ 3*Real.logb 2 m := by |
| rw [Nat.length_digits 2 m (by omega) hm0] |
| push_cast |
| have ht := Real.natLog_le_logb m 2 |
| norm_num at ht |
| linarith |
| have hl0 : 0 ≤ Real.logb 2 (m : ℝ) := by linarith |
| simp only [Real.norm_eq_abs,Function.id_def] at hm |
| rw [abs_of_nonneg (by positivity),abs_of_nonneg (Nat.cast_nonneg m),one_mul] at hm |
| have hp := pow_le_pow_left₀ (by positivity : (0 : ℝ) ≤ ((Nat.digits 2 m).length+1 : ℕ)) hd r |
| have hp' := mul_le_mul_of_nonneg_left hp (Nat.cast_nonneg K) |
| rw [mul_pow] at hp' |
| have hh : (K : ℝ)*(((Nat.digits 2 m).length+1 : ℕ) : ℝ)^r ≤ (m : ℝ) := by nlinarith |
| exact_mod_cast hh |
| exact eventually_atTop.mp hall |
| end WLTime.Numeric |
|
|
| namespace WLTime.Numeric |
| noncomputable def base (C m : ℕ) := 1+C*m^2*((C*m^2+1)^2+1) |
| theorem base_lower (C m : ℕ) (hC : 1≤C) : m ≤ base C m := by |
| have hm : m≤ m^2 := Nat.le_self_pow (by decide) m |
| have hp : 1≤(C*m^2+1)^2+1 := by omega |
| have hc : m^2≤C*m^2 := Nat.le_mul_of_pos_left _ (by omega) |
| have ht := Nat.le_mul_of_pos_right (C*m^2) (by omega : 0<(C*m^2+1)^2+1) |
| dsimp [base]; omega |
| theorem base_upper (C m : ℕ) (hC : 1≤C) (hm : 1≤ m) : base C m ≤ 6*C^3*m^6 := by |
| have hCm : 1≤C*m^2 := by |
| have : 0<C*m^2 := by positivity |
| omega |
| have h1 : (C*m^2+1)^2+1≤5*(C*m^2)^2 := by nlinarith |
| have h2 := Nat.mul_le_mul_left (C*m^2) h1 |
| have h3 : 1≤C^3*m^6 := by |
| have : 0<C^3*m^6 := by positivity |
| omega |
| dsimp [base] |
| nlinarith [show C*m^2*(5*(C*m^2)^2)=5*C^3*m^6 by ring] |
| noncomputable def chooseOrder (C n : ℕ) := Nat.findGreatest (fun m => base C m≤n) n |
| theorem chooseOrder_bounds (C n m₀ : ℕ) (hC : 1≤C) (hn : base C m₀≤n) : |
| m₀≤chooseOrder C n ∧ base C (chooseOrder C n)≤n ∧ n<base C (chooseOrder C n+1) := by |
| have hb : m₀≤n := (base_lower C m₀ hC).trans hn |
| have h1 := Nat.le_findGreatest (P:=fun x => base C x≤n) hb hn |
| have h2 := Nat.findGreatest_spec (P:=fun x => base C x≤n) hb hn |
| refine ⟨h1,h2,?_⟩ |
| by_cases hlt : chooseOrder C n<n |
| · exact lt_of_not_ge ((Nat.findGreatest_eq_iff.mp (rfl : chooseOrder C n=chooseOrder C n)).2.2 |
| (by omega) (by omega)) |
| · have hle : chooseOrder C n≤n := Nat.findGreatest_le n |
| have h := base_lower C (chooseOrder C n+1) hC |
| omega |
| theorem order_polynomial (C n m : ℕ) (hC : 1≤C) (hm : 384*C^3≤ m) |
| (hn : n<base C (m+1)) : n≤ m^8 := by |
| have hc : 1≤C^3 := one_le_pow₀ hC |
| have hm1 : 1≤ m := by nlinarith |
| have hu := base_upper C (m+1) hC (by omega) |
| have hp : (m+1)^6≤64*m^6 := by |
| calc |
| _≤(2*m)^6 := Nat.pow_le_pow_left (by omega) 6 |
| _=64*m^6 := by ring |
| have hx : n≤384*C^3*m^6 := by nlinarith |
| calc |
| n≤384*C^3*m^6 := hx |
| _≤ m*m^6 := Nat.mul_le_mul_right _ hm |
| _=m^7 := by ring |
| _≤ m^8 := Nat.pow_le_pow_right (by omega) (by decide) |
| end WLTime.Numeric |
| namespace WLTime.Numeric |
| theorem pow_mono (m i j : ℕ) (hm : 0 < m) (h : i ≤ j) : m^i ≤ m^j := Nat.pow_le_pow_right hm h |
| theorem grow_one (m X : ℕ) (hm : 2≤ m) (hX : 1≤X) : X+1≤X*m := by nlinarith |
| theorem space_arith (m X : ℕ) (hm : m≤X) (hX : 0<X) : 2*(X-1)+m+2<4*X := by omega |
| theorem digits_le (n : ℕ) : (Nat.digits 2 n).length≤ n+1 := by |
| apply (Nat.digits_length_le_iff (by decide) n).mpr |
| exact (Nat.lt_two_pow_self (n:=n)).trans_le (Nat.pow_le_pow_right (by decide) (by omega)) |
| theorem digits_polynomial (n m e : ℕ) (he : 0< e) (hn : n≤ m^e) : |
| (Nat.digits 2 n).length+1≤(e+1)*((Nat.digits 2 m).length+1) := by |
| have hm := Nat.lt_base_pow_length_digits (m:=m) (by decide : 1< 2) |
| have hp := Nat.pow_lt_pow_left hm (by omega : e≠0) |
| have hn' : n< 2^((Nat.digits 2 m).length*e) := by |
| rw [pow_mul] ; exact hn.trans_lt hp |
| have hl := (Nat.digits_length_le_iff (by decide : 1< 2) n).mpr hn' |
| nlinarith |
| theorem sum_le_pow {m a b e : ℕ} (hm : 2≤ m) (ha : a≤ m^e) (hb : b≤ m^e) : |
| a+b≤ m^(e+1) := by |
| rw [pow_succ] |
| nlinarith |
| theorem input_small (n m : ℕ) (hm : 8≤ m) (hn : n≤ m^8) : |
| 2*(Nat.digits 2 n).length+1+2*n^2≤ m^20 := by |
| have hd := digits_le n |
| have hp : 1≤ m^8 := one_le_pow₀ (by omega) |
| have hq : m^8≤ m^16 := Nat.pow_le_pow_right (by omega) (by decide) |
| have hn2 : n^2≤ m^16 := by simpa only [←pow_mul] using Nat.pow_le_pow_left hn 2 |
| have hr : 8≤ m^4 := (show 8≤ m by omega).trans (Nat.le_self_pow (by decide) m) |
| rw [show 20=16+4 by decide,pow_add] |
| nlinarith |
| theorem scale6 (m X x : ℕ) (hm : 7≤ m) (hx : x≤X) (hX : 1≤X) : 6*x+1≤X*m := by |
| nlinarith only [hm,hx,hX] |
| theorem consumer_inside (m B Y W X : ℕ) (hm : 16≤ m) (hmX : m≤X) (hB : B≤X) (hY : Y≤X) (hW : W≤X) : |
| m+B+5*Y+W+3≤X*m := by nlinarith only [hm,hmX,hB,hY,hW] |
| theorem writer_small (C charge n m : ℕ) (hm : 128≤ m) (hC : C≤ m) |
| (hf : charge≤ m) (hn : n≤ m^8) : |
| 17*m+3+24*((Nat.digits 2 n).length+1)*(n+1)+(2*(2*(Nat.digits 2 n).length+1)+1)+ |
| charge*(6*(C+n+m+2)^27+1)^8 ≤ m^2400 := by |
| have hm0 : 0< m := by omega |
| have hm1 : 1≤ m := by omega |
| have hm2 : 2≤ m := by omega |
| have hm7 : 7≤ m := by omega |
| have hp (e : ℕ) (he : e≠0) : m≤ m^e := Nat.le_self_pow he m |
| have hd := digits_le n |
| have hQ : C+n+m+2≤ m^11 := by |
| have h8 := hp 8 (by decide) |
| have h3 : 4≤ m^3 := (show 4≤ m by omega).trans (hp 3 (by decide)) |
| rw [show 11=8+3 by decide,pow_add] |
| nlinarith only [hC,hn,h8,h3,hm2] |
| have hQp : (C+n+m+2)^27≤ m^(11*27) := by |
| exact (Nat.pow_le_pow_left hQ 27).trans_eq (pow_mul m 11 27).symm |
| have h297 : 1≤ m^(11*27) := one_le_pow₀ hm1 |
| have hbody : 6*(C+n+m+2)^27+1≤ m^(11*27+1) := by |
| rw [pow_succ m (11*27)] |
| exact scale6 m (m^(11*27)) ((C+n+m+2)^27) hm7 hQp h297 |
| have hbp : (6*(C+n+m+2)^27+1)^8≤ m^((11*27+1)*8) := by |
| exact (Nat.pow_le_pow_left hbody 8).trans_eq (pow_mul m (11*27+1) 8).symm |
| have hc : charge*(6*(C+n+m+2)^27+1)^8≤ m^((11*27+1)*8+1) := by |
| calc |
| _≤ m*m^((11*27+1)*8) := Nat.mul_le_mul hf hbp |
| _=m^((11*27+1)*8+1) := (pow_succ' m ((11*27+1)*8)).symm |
| have h8 := hp 8 (by decide) |
| have h16 : (m^8)^2=m^16 := by ring |
| have hn2 : (n+1)^2≤ 4*m^16 := by nlinarith only [hn,h8,hm,h16] |
| have hsmall : 17*m+3+24*((Nat.digits 2 n).length+1)*(n+1)+(2*(2*(Nat.digits 2 n).length+1)+1)≤ m^20 := by |
| have h4 : 256≤ m^4 := (show 256≤128^4 by decide).trans (Nat.pow_le_pow_left hm 4) |
| have hn16 : n≤ m^16 := hn.trans (Nat.pow_le_pow_right hm0 (by decide)) |
| have hm16 := hp 16 (by decide) |
| rw [show 20=16+4 by decide,pow_add] |
| have hplus : (Nat.digits 2 n).length+1≤2*(n+1) := by omega |
| have hprod := Nat.mul_le_mul_right (n+1) hplus |
| nlinarith only [hprod,hn2,h4,hn16,hm16,hm,hd] |
| have h20 : m^20≤ m^((11*27+1)*8+1) := pow_mono m 20 ((11*27+1)*8+1) hm0 (by decide) |
| exact (sum_le_pow hm2 (hsmall.trans h20) hc).trans |
| (pow_mono m _ _ hm0 (by decide)) |
| theorem consumer_small (m a B Y v factor overhead : ℕ) (hm : 16≤ m) |
| (hB : B≤ m^2400) (hY : Y≤ m^20) (hv : v≤ m^(8*a)) |
| (hf : factor≤ m) (ho : overhead≤ m) : |
| factor*(m+B+5*Y+overhead*v+3)^2≤ m^(2*(max 2400 (8*a+1))+3) := by |
| have hm0 : 0< m := lt_of_lt_of_le (by decide : 0<16) hm |
| let r := max 2400 (8*a+1) |
| have hr : 1≤ r := (by decide : 1≤ 2400).trans (le_max_left _ _) |
| have h2400 : m^2400≤ m^r := pow_mono m 2400 r hm0 (le_max_left _ _) |
| have h20 : m^20≤ m^r := Nat.pow_le_pow_right hm0 ((by decide : 20≤ 2400).trans (le_max_left _ _)) |
| have h8 : overhead*v≤ m^r := by |
| calc |
| _≤ m*m^(8*a) := Nat.mul_le_mul ho hv |
| _=m^(8*a+1) := by ring |
| _≤ m^r := Nat.pow_le_pow_right hm0 (le_max_right _ _) |
| have hmr : m≤ m^r := Nat.le_self_pow (Nat.ne_of_gt hr) m |
| have hB' := hB.trans h2400 |
| have hY' := hY.trans h20 |
| have hinside : m+B+5*Y+overhead*v+3≤ m^(r+1) := by |
| rw [pow_succ] |
| exact consumer_inside _ _ _ _ _ hm hmr hB' hY' h8 |
| calc |
| _≤ m*(m^(r+1))^2 := Nat.mul_le_mul hf (Nat.pow_le_pow_left hinside 2) |
| _=m^(2*r+3) := by ring |
| end WLTime.Numeric |
|
|
| namespace WLTime.OneTape.Symbolic |
| open scoped Classical |
| theorem coefficient_pos (U : OneTape) (d q : ℕ) : 0< coefficient U d q (d+q+2) := by |
| unfold coefficient Compression.ConsistencyData.rectCoefficient |
| apply Nat.mul_pos |
| · apply Fintype.card_pos_iff.mpr |
| exact ⟨(⟨0,by omega⟩,Sum.inl (.inl .dummy))⟩ |
| · exact Compression.ConsistencyData.tagValues_card_pos _ _ |
| end WLTime.OneTape.Symbolic |
| namespace WLTime |
| open OneTape.Symbolic OneTape.Symbolic.FullWriter |
| open scoped Classical |
| theorem worstTime_ge (A : Model) (p : InputClass) {n : ℕ} (G H : Graph n) (hp : p.contains G H) : |
| A.time n (encodePair G H)≤ worstTime A p n := by |
| unfold worstTime |
| exact (show A.time n (encodePair G H)≤ if p.contains G H then A.time n (encodePair G H) else 0 by simp [hp]).trans |
| (Finset.le_sup (f:=fun pair : Graph n × Graph n => if p.contains pair.1 pair.2 then A.time n (encodePair pair.1 pair.2) else 0) |
| (Finset.mem_univ (G,H))) |
| theorem promised_pair (U : OneTape) (d q : ℕ) (hr : 2≤ d+q) (w : List Bool) (pad : ℕ) (p : InputClass) : |
| p.contains (pairGraph U d q hr w pad 0) (pairGraph U d q hr w pad 1) := by |
| cases p with |
| | unrestricted => trivial |
| | diameterTwo => exact ⟨pairGraph_diameter U d q hr w pad 0,pairGraph_diameter U d q hr w pad 1⟩ |
|
|
| theorem designation_small (U : OneTape) (d q : ℕ) (A : TM) : |
| ∃m₀,∀m≥ m₀,∀n≤ m^8,(Diagonal.designation (consumer U d q A n)).length≤ m := by |
| let K := statesBound U d q A+alphabetBound U d q A+3 |
| obtain ⟨m₀,hm₀⟩ := Numeric.polylog_sublinear (13*(K*9)^3) 3 |
| refine ⟨m₀,?_⟩ |
| intro m hm n hn |
| have hd := Numeric.digits_polynomial n m 8 (by decide) hn |
| let B := K*((Nat.digits 2 n).length+1) |
| have hq : (consumer U d q A n).states≤ B := by |
| exact (consumer_states U d q A n).trans (Nat.mul_le_mul_right _ (by dsimp [K]; omega)) |
| have hg : (consumer U d q A n).symbols≤ B := by |
| have h := consumer_alphabet U d q A n |
| dsimp [B,K]; nlinarith |
| have hB : 3≤ B := by dsimp [B,K]; nlinarith |
| calc |
| _≤ 13*B^3 := Diagonal.designation_upper _ B hq hg hB |
| _≤ 13*(K*9*((Nat.digits 2 m).length+1))^3 := by |
| apply Nat.mul_le_mul_left |
| apply Nat.pow_le_pow_left |
| dsimp [B] |
| nlinarith |
| _=(13*(K*9)^3)*((Nat.digits 2 m).length+1)^3 := by ring |
| _≤ m := hm₀ m hm |
|
|
| theorem time_window (m s : ℕ) (hm : 2≤ m) (hs : 1≤ s) : m^(2*s+5)≤ m^(3*s+6)-1 := by |
| have he : 2*s+5+1≤ 3*s+6 := by omega |
| have hp := Nat.pow_le_pow_right (by omega : 0< m) he |
| have hpos : 1≤ m^(2*s+5) := one_le_pow₀ (by omega) |
| rw [pow_succ] at hp |
| have hh : m^(2*s+5)+1≤ m^(2*s+5)*m := by |
| exact Numeric.grow_one _ _ hm hpos |
| exact Nat.le_sub_one_of_lt (lt_of_lt_of_le (Nat.lt_add_one _) (hh.trans hp)) |
|
|
| theorem space_window (m d q : ℕ) (hm : 2≤ m) (hd : 1≤ d) (hq : d+3≤ q) : |
| 2*(m^d-1)+m+2< m^(q+1) := by |
| have hp := Nat.pow_le_pow_right (by omega : 0< m) (show d+2≤ q+1 by omega) |
| have hmd := Nat.le_self_pow (by omega : d≠0) m |
| rw [pow_add,pow_two] at hp |
| have hm2 : 4≤ m*m := by nlinarith only [hm] |
| have hx : m^d*4≤ m^(q+1) := (Nat.mul_le_mul_left (m^d) hm2).trans hp |
| have ht : 0< m^d := pow_pos (by omega) _ |
| have hl := Numeric.space_arith m (m^d) hmd ht |
| exact hl.trans_le (by simpa only [Nat.mul_comm] using hx) |
| end WLTime |
| namespace WLTime |
| open OneTape.Symbolic OneTape.Symbolic.FullWriter |
| open scoped Classical |
| def conventionShift : Convention → ℕ | .joint => 1 | .separate => 2 |
| theorem pair_correct_convention (U : OneTape) (d q : ℕ) (hr : 2≤ d+q) (w : List Bool) |
| (hm : 2≤ w.length) (pad : ℕ) (hL : 2*(w.length^d-1)+w.length+2< w.length^(q+1)) |
| (c : Convention) (k : ℕ) (hk : k=d+q+conventionShift c) : |
| Equivalent c k (pairGraph U d q hr w pad 0) (pairGraph U d q hr w pad 1) ↔ |
| ¬∃t≤ w.length^d-1,(U.toTM.run w t).state.val=1 := by |
| subst k |
| cases c with |
| | joint => exact (pairGraph_correct U d q hr w hm pad hL).1 |
| | separate => exact (pairGraph_correct U d q hr w hm pad hL).2 |
|
|
| theorem tm_pointwise (s d q k a n m : ℕ) (c : Convention) (p : InputClass) (A : TM) |
| (hA : Decides (.turing A) c k p) (hk : k=d+q+conventionShift c) |
| (hm : 128≤ m) (hs : 1≤ s) (hd : d=3*s+6) (hq : d+3≤ q) |
| (ha : 2*max 2400 (8*a+1)+3≤ s) |
| (hbase : baseOrder (Universal.machine s) d q m≤ n) (hn : n≤ m^8) |
| (hfit : (Diagonal.designation (consumer (Universal.machine s) d q A n)).length≤ m) |
| (hC : coefficient (Universal.machine s) d q (d+q+2)≤ m) |
| (hcharge : (body (Universal.machine s) d q).charge≤ m) |
| (hfactor : consumerFactor (Universal.machine s) d q A≤ m) |
| (hAfac : 8*A.tapes+2≤ m) |
| (hUfac : 8*((Universal.boundedProgram s).scratch+Fintype.card Universal.Reg+1)*1200^2≤ m) |
| (hsm : 18*s≤ m) : |
| ¬worstTime (.turing A) p n≤ n^a := by |
| intro hfast |
| let U := Universal.machine s |
| let D := consumer U d q A n |
| let z := List.replicate (m-(Diagonal.designation D).length) false |
| let w := Diagonal.designation D++z |
| have hlen : w.length=m := by |
| dsimp [w,z] |
| rw [List.length_append,List.length_replicate,Nat.add_sub_of_le hfit] |
| have hr : 2≤ d+q := by omega |
| let G := pairGraph U d q hr w (n-baseOrder U d q w.length) 0 |
| let H := pairGraph U d q hr w (n-baseOrder U d q w.length) 1 |
| let ys := encodePair G H |
| have hgn : (listing U d q (d+q+2) w (n-baseOrder U d q w.length)).items.length=n := by |
| rw [listing_length,hlen,Nat.add_sub_of_le hbase] |
| have hprom : p.contains G H := promised_pair U d q hr w _ p |
| have hdec := hA _ G H hprom |
| change A.halts ys ∧ (A.accepts ys ↔ Equivalent c k G H) at hdec |
| have htime : A.time ys≤ n^a := by |
| have ht := worstTime_ge (.turing A) p G H hprom |
| change A.time ys≤ worstTime (.turing A) p _ at ht |
| rw [hgn] at ht |
| exact ht.trans hfast |
| have hprod := consumer_correct U d q A n w (by rw [hlen]; omega) hr |
| (by simpa only [hlen] using hbase) ys rfl (A.time ys) (A.time_halted ys hdec.1) |
| have hy : ys.length≤ m^20 := by |
| have hy := input_length U d q n w hr (by simpa only [hlen] using hbase) |
| exact hy.le.trans (Numeric.input_small n m (by omega) hn) |
| have hb : budget U d q n w.length≤ m^2400 := by |
| rw [hlen] |
| simpa only [budget,encodeNat_length] using |
| Numeric.writer_small (coefficient U d q (d+q+2)) (body U d q).charge n m hm hC hcharge hn |
| have hv : A.time ys≤ m^(8*a) := by |
| calc |
| _≤ n^a := htime |
| _≤(m^8)^a := Nat.pow_le_pow_left hn a |
| _=m^(8*a) := (pow_mul m 8 a).symm |
| have hDtime : D.toTM.time w≤ m^s := by |
| have hbnd := Numeric.consumer_small m a (budget U d q n w.length) ys.length (A.time ys) |
| (consumerFactor U d q A) (8*A.tapes+2) (by omega) hb hy hv hfactor hAfac |
| have ht := hprod.2.1 |
| rw [hlen] at ht hbnd |
| exact ht.trans (hbnd.trans (Nat.pow_le_pow_right (by omega) ha)) |
| have hU := Universal.machine_correct s D z (by change 0< w.length; rw [hlen]; omega) |
| change U.toTM.halts w ∧ U.toTM.time w≤ Universal.timeBound s D w.length ∧ |
| (U.toTM.accepts w ↔ ¬∃t≤ w.length^s,(D.toTM.run w t).state.val=1) at hU |
| have hUt : U.toTM.time w≤ w.length^d-1 := by |
| apply hU.2.1.trans |
| rw [hlen] |
| apply (Universal.timeBound_small s D hfit (by omega) hs hsm hUfac).trans |
| simpa only [hd] using time_window m s (by omega) hs |
| have hwin : 2*(w.length^d-1)+w.length+2< w.length^(q+1) := by |
| rw [hlen]; exact space_window m d q (by omega) (by omega) hq |
| have hpair := pair_correct_convention U d q hr w (by rw [hlen]; omega) (n-baseOrder U d q w.length) hwin c k hk |
| have hUb := Diagonal.bounded_accepts_iff U w (w.length^d-1) hU.1 hUt |
| have hEq : Equivalent c k G H ↔ ¬U.toTM.accepts w := hpair.trans (not_congr hUb) |
| have hc : D.toTM.accepts w ↔ ¬∃t≤ m^s,(D.toTM.run w t).state.val=1 := by |
| have hh := hprod.2.2.trans (not_congr (hdec.2.trans hEq)) |
| rw [not_not] at hh |
| exact hh.trans (by simpa only [hlen] using hU.2.2) |
| exact Diagonal.pointwise_contradiction D w (m^s) hprod.1 hDtime hc |
| end WLTime |
|
|
| end OAI |
|
|
