| import OAI.Computability.SpaceSimulation.OneTape.Wander |
|
|
| namespace OAI |
|
|
| namespace Fifths.Single |
| open Finset Square |
| variable {X : Type} (M : Single X) |
|
|
| def across (x : List X) (W : Site) (n : ℕ) := M.place x W n != M.place x W (n+1) |
| def crossings (x : List X) (W : Site) (n : ℕ) := |
| ∑ j ∈ Finset.range n, (M.across x W j).toNat |
| theorem crossings_mono (x : List X) (W : Site) : Monotone (M.crossings x W) := |
| monotone_nat_of_le_succ (fun t => by simp [crossings, sum_range_succ]) |
|
|
| section |
| variable (x : List X) (W : Site) |
|
|
| theorem tick_value {n : ℕ} (h : n ≤ W.T) : |
| (M.parseCtrl W.T (M.view x W n).ctrl).tick.val = n := by |
| simp only [view, M.roundtrip] |
| exact Square.cut_ok _ _ h |
| theorem waited (n i : ℕ) (l : n ≤ W.T) |
| (p : ¬(n<W.T ∧ M.place x W n = i)) : |
| M.localStep x W i ((M.view x W n).ctrl,(M.view x W n).cells i) = |
| ((M.view x W n).ctrl,(M.view x W n).cells i) := by |
| dsimp only [localStep] |
| rw [M.tick_value x W l] |
| have e := M.so_select x W n |
| unfold chooseBlock at e |
| rw [e,ite_eq_right p] |
|
|
| /-- Sweep from time t with the currently selected block. If neither |
| cap nor crossing reached, advanced just one tick per local iteration. |
| At a crossing bank its credit. Unselected buffers unchanged throughout. |
| -/ |
| theorem sweep_time (t : ℕ) (l : t ≤ W.T) (n : ℕ) : |
| let i := M.place x W t |
| ∃ j, t ≤ j ∧ j ≤ W.T ∧ |
| M.sweep x W (M.view x W t).ctrl ((M.view x W t).cells i) n = |
| ((M.view x W j).ctrl,(M.view x W j).cells i) ∧ |
| (∀ u, u ≠ i → (M.view x W t).cells u = (M.view x W j).cells u) ∧ |
| (j = W.T ∨ |
| M.place x W j = i ∧ j = t+n ∨ |
| M.place x W j ≠ i ∧ M.crossings x W t < M.crossings x W j) := by |
| induction n with |
| | zero => |
| exact ⟨t,le_rfl,l,rfl,fun _ _ => rfl,.inr (.inl ⟨rfl,rfl⟩)⟩ |
| | succ n ih => |
| dsimp only at ih ⊢ |
| obtain ⟨j,p,h,s,v,g⟩ := ih |
| rw [sweep,s,M.so_select] |
| rcases g with a|⟨a,b⟩|⟨a,b⟩ |
| · have d : ¬ (j<W.T ∧ M.place x W j = M.place x W t) := by omega |
| exact ⟨j,p,h,M.waited x W j _ h d,v,.inl a⟩ |
| · by_cases q : j = W.T |
| · exact ⟨j,p,h,M.waited x W j _ h (by omega),v,.inl q⟩ |
| have e : j < W.T := by omega |
| obtain ⟨w,y⟩ := M.realize x W j (M.place x W t) e a |
| refine ⟨j+1,by omega,e,w,fun u r => (v u r).trans (y u r),?_⟩ |
| by_cases z : M.place x W (j+1) = M.place x W t |
| · exact .inr (.inl ⟨z,by omega⟩) |
| · have r : M.crossings x W j < M.crossings x W (j+1) := by |
| have g : M.across x W j = true := by simp [across, a,Ne.symm z] |
| simp [crossings,sum_range_succ,g] |
| exact .inr (.inr ⟨z,lt_of_le_of_lt (M.crossings_mono x W p) r⟩) |
| · exact ⟨j,p,h,M.waited x W j _ h (fun h => a h.2),v,.inr (.inr ⟨a,b⟩)⟩ |
|
|
| theorem visited (t : ℕ) (l : t≤W.T) : |
| ∃ j, t ≤ j ∧ j ≤ W.T ∧ |
| (M.tour x W).step (M.view x W t) = M.view x W j ∧ |
| (j = W.T ∨ M.crossings x W t < M.crossings x W j) := by |
| obtain ⟨j,p,h,e,u,q⟩ := M.sweep_time x W t l W.T |
| refine ⟨j,p,h,?_,?_⟩ |
| · dsimp only [Tour.step,tour] |
| rw [M.so_select,e] |
| have a : Function.update (M.view x W t).cells (M.place x W t) ((M.view x W j).cells (M.place x W t)) = |
| (M.view x W j).cells := by |
| funext k |
| by_cases e : k=M.place x W t |
| · subst k; simp |
| · rw [Function.update_of_ne e]; exact u k e |
| dsimp only |
| rw [a] |
| · rcases q with q|⟨q,f⟩|⟨q,f⟩ |
| · exact .inl q |
| · left; omega |
| · exact .inr f |
| theorem story_ok (n : ℕ) : |
| ∃ t, t ≤ W.T ∧ (M.tour x W).story n = M.view x W t ∧ |
| (t = W.T ∨ n ≤ M.crossings x W t) := by |
| induction n with |
| | zero => exact ⟨0,Nat.zero_le _,rfl,.inr (Nat.zero_le _)⟩ |
| | succ n ih => |
| obtain ⟨t,h,p,g⟩ := ih |
| rw [Tour.story,p] |
| obtain ⟨j,v,l,e,k⟩ := M.visited x W t h |
| exact ⟨j,l,e, by omega⟩ |
|
|
| noncomputable def doneAt (z : ℕ) : Bool := |
| decide ((M.parseCtrl W.T z).tick.val = W.T) |
| noncomputable def predict (z : ℕ) : M.Outcome := |
| M.finish (M.parseCtrl W.T z).state |
|
|
| theorem reported {n} |
| (p : M.doneAt W ((M.tour x W).story n).ctrl = true) : |
| M.predict W ((M.tour x W).story n).ctrl = M.outcome x W.T := by |
| obtain ⟨j,l,e,q⟩ := M.story_ok x W n |
| unfold doneAt at p |
| rw [e, M.tick_value x W l] at p |
| rw [e, of_decide_eq_true p] |
| simp [predict,view,M.roundtrip,outcome,capture] |
| theorem closes {n} (l : M.crossings x W W.T < n) : |
| M.doneAt W ((M.tour x W).story n).ctrl = true := by |
| obtain ⟨j,h,e,k⟩ := M.story_ok x W n |
| have q := M.crossings_mono x W h |
| unfold doneAt; rw [e,M.tick_value x W h,decide_eq_true_eq] |
| omega |
| end |
| |
| -- At most one crossing per unit move when summing across offsets. |
| private theorem divides_shift {b u m : ℕ} |
| (h : (u+m)/b ≠ (u+(m+1))/b) : b ∣ u+m+1 := by |
| by_contra l |
| rw [← add_assoc,Nat.succ_div] at h |
| simp [l] at h |
| private theorem unique_cross {b u v m n : ℕ} (_p : 0 < b) (l : u<b) (h : v<b) |
| (x : m ≤ n+1) (y : n ≤ m+1) |
| (a : (u+m)/b ≠ (u+n)/b) (c : (v+m)/b ≠ (v+n)/b) : u=v := by |
| have f : ∀ u v s : ℕ, u < v → v < b → |
| ¬ (b ∣ u+s+1 ∧ b ∣ v+s+1) := by |
| rintro u v s q h ⟨a,c⟩ |
| have r : b ∣ v-u := by |
| rw [show v-u=(v+s+1)-(u+s+1) by omega] |
| exact Nat.dvd_sub c a |
| have := Nat.le_of_dvd (show 0<v-u by omega) r |
| omega |
| suffices g : ∃ s, b ∣ u+s+1 ∧ b ∣ v+s+1 by |
| obtain ⟨s,r,t⟩ := g |
| rcases lt_trichotomy u v with a|a|a |
| · exact (f u v s a h ⟨r,t⟩).elim |
| · exact a |
| · exact (f v u s a l ⟨t,r⟩).elim |
| rcases le_total m n with e|e |
| · have g : n=m+1 := by |
| by_contra h; have g : m=n := by omega |
| exact a (by rw [g]) |
| rw [g] at a c |
| exact ⟨m,divides_shift a,divides_shift c⟩ |
| · have g : m=n+1 := by |
| by_contra h; have g : m=n := by omega |
| exact a (by rw [g]) |
| rw [g] at a c |
| exact ⟨n,divides_shift a.symm,divides_shift c.symm⟩ |
|
|
| section |
| variable (x : List X) (T k : ℕ) (kp : 0<k) |
| private theorem atMostOne (j : ℕ) (e : j < T) : |
| (∑ a : Fin (k*k), (M.across x (Site.mk T k kp a) j).toNat) ≤ 1 := by |
| let u := M.seenPos x T j |
| let v := M.seenPos x T (j+1) |
| have y : disp u = (M.atTime x j).tape.pos := M.seenBack x e.le |
| have z : disp v = (M.atTime x (j+1)).tape.pos := M.seenBack x e |
| have g : ∃ d : Dir, disp v = disp u + d.delta := by |
| rw [y,z]; exact ⟨_,rfl⟩ |
| obtain ⟨d,p⟩ := g |
| have r := d.bounds |
| unfold disp at p |
| let f := fun a : Fin (k*k) => M.across x (Site.mk T k kp a) j |
| have m (a : Fin (k*k)) (e : f a = true) : |
| (a.val+u.val)/(k*k) ≠ (a.val+v.val)/(k*k) := by |
| simpa [f,across,place,Site.home,Site.b,u,v] using e |
| change (∑ a, (f a).toNat) ≤ 1 |
| by_cases l : ∃ a, f a = true |
| · obtain ⟨w,h⟩ := l |
| rw [sum_eq_single_of_mem w (mem_univ w)] |
| · simp [h] |
| · intro a _ b |
| cases e : f a |
| · rfl |
| exact (b (Fin.ext (unique_cross (Nat.mul_pos kp kp) a.isLt w.isLt |
| (by omega) (by omega) (m a e) (m w h)))).elim |
| · push Not at l |
| have h (a) := Bool.eq_false_iff.mpr (l a) |
| simp [h] |
|
|
| theorem offsets : |
| (∑ a : Fin (k*k), M.crossings x (Site.mk T k kp a) T) ≤ T := by |
| unfold crossings; rw [sum_comm] |
| calc |
| _ ≤ ∑ _ ∈ Finset.range T, 1 := sum_le_sum (fun i v => |
| M.atMostOne x T k kp i (mem_range.mp v)) |
| _ = T := by simp |
|
|
| theorem sufficient (h : T ≤ k^5) : |
| ∃ a : Fin (k*k), M.doneAt (Site.mk T k kp a) |
| (((M.tour x (Site.mk T k kp a)).story ((k+1)*(k*k))).ctrl) = true := by |
| suffices h : ∃ a : Fin (k*k), M.crossings x (Site.mk T k kp a) T < |
| (k+1)*(k*k) from |
| let ⟨a,q⟩ := h; ⟨a,M.closes x _ q⟩ |
| by_contra! b |
| have f : k*k*((k+1)*(k*k)) ≤ T := by |
| have p : (∑ _a : Fin (k*k), (k+1)*(k*k)) ≤ _ := |
| sum_le_sum (fun i _ => b i) |
| simpa using p.trans (M.offsets x T k kp) |
| have v : 0 < k^4 := pow_pos kp _ |
| rw [show k*k*((k+1)*(k*k)) = k^5 + k^4 by ring] at f |
| omega |
|
|
| end |
| end Fifths.Single |
|
|
| end OAI |
|
|
