ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Turing.Tape.write_mk'
@[simp]
theorem Tape.write_mk' {Γ} [Inhabited Γ] (a b : Γ) (L R : ListBlank Γ) :
    (Tape.mk' L (R.cons a)).write b = Tape.mk' L (R.cons b) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (a b : Γ) (L R : Turing.ListBlank Γ)
Goal: Turing.Tape.write b (Turing.Tape.mk' L (Turing.ListBlank.cons a R)) = Turing.Tape.mk' L (Turing.ListBlank.cons b R)
-- Turing.Tape.map_fst
@[simp]
theorem Tape.map_fst {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') :
    ∀ T : Tape Γ, (T.map f).1 = f T.1 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (T : Turing.Tape Γ)
Goal: (Turing.Tape.map f T).head = f.f T.head
-- Turing.Tape.map_write
@[simp]
theorem Tape.map_write {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (b : Γ) :
    ∀ T : Tape Γ, (T.write b).map f = (T.map f).write (f b) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (b : Γ) (T : Turing.Tape Γ)
Goal: Turing.Tape.map f (Turing.Tape.write b T) = Turing.Tape.write (f.f b) (Turing.Tape.map f T)
-- Turing.Tape.write_move_right_n
@[simp, nolint simpNF]
theorem Tape.write_move_right_n {Γ} [Inhabited Γ] (f : Γ → Γ) (L R : ListBlank Γ) (n : ℕ) :
    ((Tape.move Dir.right)^[n] (Tape.mk' L R)).write (f (R.nth n)) =
      (Tape.move Dir.right)^[n] (Tape.mk' L (R.modifyNth f n)) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (f : Γ → Γ) (L R : Turing.ListBlank Γ) (n : ℕ)
Goal: Turing.Tape.write (f (R.nth n)) ((Turing.Tape.move Turing.Dir.right)^[n] (Turing.Tape.mk' L R)) =
  (Turing.Tape.move Turing.Dir.right)^[n] (Turing.Tape.mk' L (Turing.ListBlank.modifyNth f n R))
-- Turing.Tape.map_move
theorem Tape.map_move {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (T : Tape Γ) (d) :
    (T.move d).map f = (T.map f).move d 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (T : Turing.Tape Γ) (d : Turing.Dir)
Goal: Turing.Tape.map f (Turing.Tape.move d T) = Turing.Tape.move d (Turing.Tape.map f T)
-- Turing.Tape.map_mk'
theorem Tape.map_mk' {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (L R : ListBlank Γ) :
    (Tape.mk' L R).map f = Tape.mk' (L.map f) (R.map f) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (L R : Turing.ListBlank Γ)
Goal: Turing.Tape.map f (Turing.Tape.mk' L R) = Turing.Tape.mk' (Turing.ListBlank.map f L) (Turing.ListBlank.map f R)
-- Turing.Tape.map_mk₂
theorem Tape.map_mk₂ {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (L R : List Γ) :
    (Tape.mk₂ L R).map f = Tape.mk₂ (L.map f) (R.map f) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (L R : List Γ)
Goal: Turing.Tape.map f (Turing.Tape.mk₂ L R) = Turing.Tape.mk₂ (List.map f.f L) (List.map f.f R)
-- Turing.Tape.map_mk₁
theorem Tape.map_mk₁ {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (l : List Γ) :
    (Tape.mk₁ l).map f = Tape.mk₁ (l.map f) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : List Γ)
Goal: Turing.Tape.map f (Turing.Tape.mk₁ l) = Turing.Tape.mk₁ (List.map f.f l)
-- Turing.reaches₁_eq
theorem reaches₁_eq {σ} {f : σ → Option σ} {a b c} (h : f a = f b) :
    Reaches₁ f a c ↔ Reaches₁ f b c 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h : f a = f b)
Goal: Turing.Reaches₁ f a c ↔ Turing.Reaches₁ f b c
-- Turing.reaches_total
theorem reaches_total {σ} {f : σ → Option σ} {a b c} (hab : Reaches f a b) (hac : Reaches f a c) :
    Reaches f b c ∨ Reaches f c b 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (hab : Turing.Reaches f a b) (hac : Turing.Reaches f a c)
Goal: Turing.Reaches f b c ∨ Turing.Reaches f c b
-- Turing.reaches₁_fwd
theorem reaches₁_fwd {σ} {f : σ → Option σ} {a b c} (h₁ : Reaches₁ f a c) (h₂ : b ∈ f a) :
    Reaches f b c 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h₁ : Turing.Reaches₁ f a c) (h₂ : b ∈ f a)
Goal: Turing.Reaches f b c
-- Turing.Reaches₀.trans
theorem Reaches₀.trans {σ} {f : σ → Option σ} {a b c : σ} (h₁ : Reaches₀ f a b)
    (h₂ : Reaches₀ f b c) : Reaches₀ f a c
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h₁ : Turing.Reaches₀ f a b) (h₂ : Turing.Reaches₀ f b c)
Goal: Turing.Reaches₀ f a c
-- Turing.Reaches₀.refl
@[refl]
theorem Reaches₀.refl {σ} {f : σ → Option σ} (a : σ) : Reaches₀ f a a
  
Arguments: {σ : Type u_1} {f : σ → Option σ} (a : σ)
Goal: Turing.Reaches₀ f a a
-- Turing.Reaches₀.single
theorem Reaches₀.single {σ} {f : σ → Option σ} {a b : σ} (h : b ∈ f a) : Reaches₀ f a b
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (h : b ∈ f a)
Goal: Turing.Reaches₀ f a b
-- Turing.Reaches₀.head
theorem Reaches₀.head {σ} {f : σ → Option σ} {a b c : σ} (h : b ∈ f a) (h₂ : Reaches₀ f b c) :
    Reaches₀ f a c 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h : b ∈ f a) (h₂ : Turing.Reaches₀ f b c)
Goal: Turing.Reaches₀ f a c
-- Turing.Reaches₀.tail
theorem Reaches₀.tail {σ} {f : σ → Option σ} {a b c : σ} (h₁ : Reaches₀ f a b) (h : c ∈ f b) :
    Reaches₀ f a c 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h₁ : Turing.Reaches₀ f a b) (h : c ∈ f b)
Goal: Turing.Reaches₀ f a c
-- Turing.reaches₀_eq
theorem reaches₀_eq {σ} {f : σ → Option σ} {a b} (e : f a = f b) : Reaches₀ f a b
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (e : f a = f b)
Goal: Turing.Reaches₀ f a b
-- Turing.Reaches₁.to₀
theorem Reaches₁.to₀ {σ} {f : σ → Option σ} {a b : σ} (h : Reaches₁ f a b) : Reaches₀ f a b
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (h : Turing.Reaches₁ f a b)
Goal: Turing.Reaches₀ f a b
-- Turing.Reaches.to₀
theorem Reaches.to₀ {σ} {f : σ → Option σ} {a b : σ} (h : Reaches f a b) : Reaches₀ f a b
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (h : Turing.Reaches f a b)
Goal: Turing.Reaches₀ f a b
-- Turing.Reaches₀.tail'
theorem Reaches₀.tail' {σ} {f : σ → Option σ} {a b c : σ} (h : Reaches₀ f a b) (h₂ : c ∈ f b) :
    Reaches₁ f a c 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b c : σ} (h : Turing.Reaches₀ f a b) (h₂ : c ∈ f b)
Goal: Turing.Reaches₁ f a c
-- Turing.mem_eval
theorem mem_eval {σ} {f : σ → Option σ} {a b} : b ∈ eval f a ↔ Reaches f a b ∧ f b = none 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ}
Goal: b ∈ Turing.eval f a ↔ Turing.Reaches f a b ∧ f b = none
-- Turing.eval_maximal₁
theorem eval_maximal₁ {σ} {f : σ → Option σ} {a b} (h : b ∈ eval f a) (c) : ¬Reaches₁ f b c
  
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (h : b ∈ Turing.eval f a) (c : σ)
Goal: ¬Turing.Reaches₁ f b c
-- Turing.eval_maximal
theorem eval_maximal {σ} {f : σ → Option σ} {a b} (h : b ∈ eval f a) {c} : Reaches f b c ↔ c = b 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (h : b ∈ Turing.eval f a) {c : σ}
Goal: Turing.Reaches f b c ↔ c = b
-- Turing.reaches_eval
theorem reaches_eval {σ} {f : σ → Option σ} {a b} (ab : Reaches f a b) : eval f a = eval f b 
Arguments: {σ : Type u_1} {f : σ → Option σ} {a b : σ} (ab : Turing.Reaches f a b)
Goal: Turing.eval f a = Turing.eval f b
-- Turing.tr_reaches₁
theorem tr_reaches₁ {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) {b₁} (ab : Reaches₁ f₁ a₁ b₁) : ∃ b₂, tr b₁ b₂ ∧ Reaches₁ f₂ a₂ b₂ 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ : σ₁} {a₂ : σ₂} (aa : tr a₁ a₂) {b₁ : σ₁} (ab : Turing.Reaches₁ f₁ a₁ b₁)
Goal: ∃ b₂, tr b₁ b₂ ∧ Turing.Reaches₁ f₂ a₂ b₂
-- Turing.tr_reaches
theorem tr_reaches {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) {b₁} (ab : Reaches f₁ a₁ b₁) : ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂ 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ : σ₁} {a₂ : σ₂} (aa : tr a₁ a₂) {b₁ : σ₁} (ab : Turing.Reaches f₁ a₁ b₁)
Goal: ∃ b₂, tr b₁ b₂ ∧ Turing.Reaches f₂ a₂ b₂
-- Turing.tr_reaches_rev
theorem tr_reaches_rev {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) {b₂} (ab : Reaches f₂ a₂ b₂) :
    ∃ c₁ c₂, Reaches f₂ b₂ c₂ ∧ tr c₁ c₂ ∧ Reaches f₁ a₁ c₁ 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ : σ₁} {a₂ : σ₂} (aa : tr a₁ a₂) {b₂ : σ₂} (ab : Turing.Reaches f₂ a₂ b₂)
Goal: ∃ c₁ c₂, Turing.Reaches f₂ b₂ c₂ ∧ tr c₁ c₂ ∧ Turing.Reaches f₁ a₁ c₁
-- Turing.tr_eval
theorem tr_eval {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ b₁ a₂}
    (aa : tr a₁ a₂) (ab : b₁ ∈ eval f₁ a₁) : ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂ 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ b₁ : σ₁} {a₂ : σ₂} (aa : tr a₁ a₂) (ab : b₁ ∈ Turing.eval f₁ a₁)
Goal: ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ Turing.eval f₂ a₂
-- Turing.tr_eval_rev
theorem tr_eval_rev {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ b₂ a₂}
    (aa : tr a₁ a₂) (ab : b₂ ∈ eval f₂ a₂) : ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ eval f₁ a₁ 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ : σ₁} {b₂ a₂ : σ₂} (aa : tr a₁ a₂) (ab : b₂ ∈ Turing.eval f₂ a₂)
Goal: ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ Turing.eval f₁ a₁
-- Turing.tr_eval_dom
theorem tr_eval_dom {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) : (eval f₂ a₂).Dom ↔ (eval f₁ a₁).Dom 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop} (H : Turing.Respects f₁ f₂ tr) {a₁ : σ₁} {a₂ : σ₂} (aa : tr a₁ a₂)
Goal: (Turing.eval f₂ a₂).Dom ↔ (Turing.eval f₁ a₁).Dom
-- Turing.frespects_eq
theorem frespects_eq {σ₁ σ₂} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂} {a₂ b₂} (h : f₂ a₂ = f₂ b₂) :
    ∀ {b₁}, FRespects f₂ tr a₂ b₁ ↔ FRespects f₂ tr b₂ b₁
  
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂} {a₂ b₂ : σ₂} (h : f₂ a₂ = f₂ b₂) {b₁ : Option σ₁}
Goal: Turing.FRespects f₂ tr a₂ b₁ ↔ Turing.FRespects f₂ tr b₂ b₁
-- Turing.fun_respects
theorem fun_respects {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂} :
    (Respects f₁ f₂ fun a b ↦ tr a = b) ↔ ∀ ⦃a₁⦄, FRespects f₂ tr (tr a₁) (f₁ a₁) 
Arguments: {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂}
Goal: (Turing.Respects f₁ f₂ fun a b => tr a = b) ↔ ∀ ⦃a₁ : σ₁⦄, Turing.FRespects f₂ tr (tr a₁) (f₁ a₁)
-- Turing.tr_eval'
theorem tr_eval' {σ₁ σ₂} (f₁ : σ₁ → Option σ₁) (f₂ : σ₂ → Option σ₂) (tr : σ₁ → σ₂)
    (H : Respects f₁ f₂ fun a b ↦ tr a = b) (a₁) : eval f₂ (tr a₁) = tr <$> eval f₁ a₁ 
Arguments: {σ₁ σ₂ : Type u_1} (f₁ : σ₁ → Option σ₁) (f₂ : σ₂ → Option σ₂) (tr : σ₁ → σ₂) (H : Turing.Respects f₁ f₂ fun a b => tr a = b) (a₁ : σ₁)
Goal: Turing.eval f₂ (tr a₁) = tr <$> Turing.eval f₁ a₁
-- Turing.TM0.step_supports
theorem step_supports (M : Machine₀) {S : Set Λ} (ss : Supports M S) :
    ∀ {c c' : Cfg₀}, c' ∈ step M c → c.q ∈ S → c'.q ∈ S 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} [Inhabited Λ] (M : Turing.TM0.Machine Γ Λ) {S : Set Λ} (ss : Turing.TM0.Supports M S) {c c' : Turing.TM0.Cfg Γ Λ}
Goal: c' ∈ Turing.TM0.step M c → c.q ∈ S → c'.q ∈ S
-- Turing.TM0.univ_supports
theorem univ_supports (M : Machine₀) : Supports M Set.univ 
Arguments: {Γ : Type u_1} {Λ : Type u_2} [Inhabited Λ] (M : Turing.TM0.Machine Γ Λ)
Goal: Turing.TM0.Supports M Set.univ
-- Turing.TM0.Machine.map_step
theorem Machine.map_step {S : Set Λ} (f₂₁ : Function.RightInverse f₁ f₂)
    (g₂₁ : ∀ q ∈ S, g₂ (g₁ q) = q) :
    ∀ c : Cfg Γ Λ,
      c.q ∈ S → (step M c).map (Cfg.map f₁ g₁) = step (M.map f₁ f₂ g₁ g₂) (Cfg.map f₁ g₁ c)
  
Arguments: {Γ : Type u_1} [Inhabited Γ] {Γ' : Type u_2} [Inhabited Γ'] {Λ : Type u_3} [Inhabited Λ] {Λ' : Type u_4} [Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ') (f₂ : Turing.PointedMap Γ' Γ) (g₁ : Λ → Λ') (g₂ : Λ' → Λ) {S : Set Λ} (f₂₁ : Function.RightInverse f₁.f f₂.f) (g₂₁ : ∀ q ∈ S, g₂ (g₁ q) = q) (c : Turing.TM0.Cfg Γ Λ)
Goal: c.q ∈ S →
  Option.map (Turing.TM0.Cfg.map f₁ g₁) (Turing.TM0.step M c) =
    Turing.TM0.step (M.map f₁ f₂ g₁ g₂) (Turing.TM0.Cfg.map f₁ g₁ c)
-- Turing.TM0.map_init
theorem map_init (g₁ : PointedMap Λ Λ') (l : List Γ) : (init l).map f₁ g₁ = init (l.map f₁) 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Γ' : Type u_2} [Inhabited Γ'] {Λ : Type u_3} [Inhabited Λ] {Λ' : Type u_4} [Inhabited Λ'] (f₁ : Turing.PointedMap Γ Γ') (g₁ : Turing.PointedMap Λ Λ') (l : List Γ)
Goal: Turing.TM0.Cfg.map f₁ g₁.f (Turing.TM0.init l) = Turing.TM0.init (List.map f₁.f l)
-- Turing.TM0.Machine.map_respects
theorem Machine.map_respects (g₁ : PointedMap Λ Λ') (g₂ : Λ' → Λ) {S} (ss : Supports M S)
    (f₂₁ : Function.RightInverse f₁ f₂) (g₂₁ : ∀ q ∈ S, g₂ (g₁ q) = q) :
    Respects (step M) (step (M.map f₁ f₂ g₁ g₂)) fun a b ↦ a.q ∈ S ∧ Cfg.map f₁ g₁ a = b 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Γ' : Type u_2} [Inhabited Γ'] {Λ : Type u_3} [Inhabited Λ] {Λ' : Type u_4} [Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ') (f₂ : Turing.PointedMap Γ' Γ) (g₁ : Turing.PointedMap Λ Λ') (g₂ : Λ' → Λ) {S : Set Λ} (ss : Turing.TM0.Supports M S) (f₂₁ : Function.RightInverse f₁.f f₂.f) (g₂₁ : ∀ q ∈ S, g₂ (g₁.f q) = q)
Goal: Turing.Respects (Turing.TM0.step M) (Turing.TM0.step (M.map f₁ f₂ g₁.f g₂)) fun a b =>
  a.q ∈ S ∧ Turing.TM0.Cfg.map f₁ g₁.f a = b
-- Turing.TM1.stmts₁_self
theorem stmts₁_self {q : Stmt₁} : q ∈ stmts₁ q 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {q : Turing.TM1.Stmt Γ Λ σ}
Goal: q ∈ Turing.TM1.stmts₁ q
-- Turing.TM1.stmts₁_trans
theorem stmts₁_trans {q₁ q₂ : Stmt₁} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂ 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {q₁ q₂ : Turing.TM1.Stmt Γ Λ σ}
Goal: q₁ ∈ Turing.TM1.stmts₁ q₂ → Turing.TM1.stmts₁ q₁ ⊆ Turing.TM1.stmts₁ q₂
-- Turing.TM1.stmts₁_supportsStmt_mono
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {S : Finset Λ} {q₁ q₂ : Turing.TM1.Stmt Γ Λ σ} (h : q₁ ∈ Turing.TM1.stmts₁ q₂) (hs : Turing.TM1.SupportsStmt S q₂)
Goal: Turing.TM1.SupportsStmt S q₁
-- Turing.TM1.stmts_trans
theorem stmts_trans {M : Λ → Stmt₁} {S : Finset Λ} {q₁ q₂ : Stmt₁} (h₁ : q₁ ∈ stmts₁ q₂) :
    some q₂ ∈ stmts M S → some q₁ ∈ stmts M S 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {M : Λ → Turing.TM1.Stmt Γ Λ σ} {S : Finset Λ} {q₁ q₂ : Turing.TM1.Stmt Γ Λ σ} (h₁ : q₁ ∈ Turing.TM1.stmts₁ q₂)
Goal: some q₂ ∈ Turing.TM1.stmts M S → some q₁ ∈ Turing.TM1.stmts M S
-- Turing.TM1.stmts_supportsStmt
theorem stmts_supportsStmt {M : Λ → Stmt₁} {S : Finset Λ} {q : Stmt₁} (ss : Supports M S) :
    some q ∈ stmts M S → SupportsStmt S q 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} [Inhabited Λ] {M : Λ → Turing.TM1.Stmt Γ Λ σ} {S : Finset Λ} {q : Turing.TM1.Stmt Γ Λ σ} (ss : Turing.TM1.Supports M S)
Goal: some q ∈ Turing.TM1.stmts M S → Turing.TM1.SupportsStmt S q
-- Turing.TM1.step_supports
theorem step_supports (M : Λ → Stmt₁) {S : Finset Λ} (ss : Supports M S) :
    ∀ {c c' : Cfg₁}, c' ∈ step M c → c.l ∈ Finset.insertNone S → c'.l ∈ Finset.insertNone S
  
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} {σ : Type u_3} [Inhabited Λ] (M : Λ → Turing.TM1.Stmt Γ Λ σ) {S : Finset Λ} (ss : Turing.TM1.Supports M S) {c c' : Turing.TM1.Cfg Γ Λ σ}
Goal: c' ∈ Turing.TM1.step M c → c.l ∈ Finset.insertNone S → c'.l ∈ Finset.insertNone S
-- Turing.TM1to0.tr_respects
theorem tr_respects :
    Respects (TM1.step M) (TM0.step (tr M)) fun (c₁ : Cfg₁) (c₂ : Cfg₁₀) ↦ trCfg M c₁ = c₂ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} [Inhabited Λ] {σ : Type u_3} [Inhabited σ] (M : Λ → Turing.TM1.Stmt Γ Λ σ)
Goal: Turing.Respects (Turing.TM1.step M) (Turing.TM0.step (Turing.TM1to0.tr M)) fun c₁ c₂ => Turing.TM1to0.trCfg M c₁ = c₂
-- Turing.TM1to0.tr_eval
theorem tr_eval (l : List Γ) : TM0.eval (tr M) l = TM1.eval M l 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} [Inhabited Λ] {σ : Type u_3} [Inhabited σ] (M : Λ → Turing.TM1.Stmt Γ Λ σ) (l : List Γ)
Goal: Turing.TM0.eval (Turing.TM1to0.tr M) l = Turing.TM1.eval M l
-- Turing.TM1to0.tr_supports
theorem tr_supports {S : Finset Λ} (ss : TM1.Supports M S) :
    TM0.Supports (tr M) ↑(trStmts M S) 
Arguments: {Γ : Type u_1} {Λ : Type u_2} [Inhabited Λ] {σ : Type u_3} [Inhabited σ] (M : Λ → Turing.TM1.Stmt Γ Λ σ) [Fintype σ] {S : Finset Λ} (ss : Turing.TM1.Supports M S)
Goal: Turing.TM0.Supports (Turing.TM1to0.tr M) ↑(Turing.TM1to0.trStmts M S)
-- Turing.TM1to1.exists_enc_dec
theorem exists_enc_dec [Finite Γ] : ∃ (n : ℕ) (enc : Γ → Vector Bool n) (dec : Vector Bool n → Γ),
    enc default = Vector.replicate n false ∧ ∀ a, dec (enc a) = a 
Arguments: {Γ : Type u_1} [Inhabited Γ] [Finite Γ]
Goal: ∃ n enc dec, enc default = Mathlib.Vector.replicate n false ∧ ∀ (a : Γ), dec (enc a) = a
-- Turing.TM1to1.stepAux_move
theorem stepAux_move (d : Dir) (q : Stmt'₁) (v : σ) (T : Tape Bool) :
    stepAux (moveₙ d q) v T = stepAux q v ((Tape.move d)^[n] T) 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (d : Turing.Dir) (q : Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ) (v : σ) (T : Turing.Tape Bool)
Goal: Turing.TM1.stepAux (Turing.TM1to1.move d q) v T = Turing.TM1.stepAux q v ((Turing.Tape.move d)^[n] T)
-- Turing.TM1to1.supportsStmt_move
theorem supportsStmt_move {S : Finset Λ'₁} {d : Dir} {q : Stmt'₁} :
    SupportsStmt S (moveₙ d q) = SupportsStmt S q 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} {S : Finset Turing.TM1to1.Λ'} {d : Turing.Dir} {q : Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ}
Goal: Turing.TM1.SupportsStmt S (Turing.TM1to1.move d q) = Turing.TM1.SupportsStmt S q
-- Turing.TM1to1.supportsStmt_write
theorem supportsStmt_write {S : Finset Λ'₁} {l : List Bool} {q : Stmt'₁} :
    SupportsStmt S (write l q) = SupportsStmt S q 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {S : Finset Turing.TM1to1.Λ'} {l : List Bool} {q : Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ}
Goal: Turing.TM1.SupportsStmt S (Turing.TM1to1.write l q) = Turing.TM1.SupportsStmt S q
-- Turing.TM1to1.supportsStmt_read
theorem supportsStmt_read {S : Finset Λ'₁} :
    ∀ {f : Γ → Stmt'₁}, (∀ a, SupportsStmt S (f a)) → SupportsStmt S (read dec f) 
Arguments: {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (dec : Mathlib.Vector Bool n → Γ) {S : Finset Turing.TM1to1.Λ'} {f : Γ → Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ}
Goal: (∀ (a : Γ), Turing.TM1.SupportsStmt S (f a)) → Turing.TM1.SupportsStmt S (Turing.TM1to1.read dec f)
-- Turing.TM1to1.trTape_mk'
theorem trTape_mk' (L R : ListBlank Γ) : trTape enc0 (Tape.mk' L R) = trTape' enc0 L R 
Arguments: {Γ : Type u_1} [Inhabited Γ] {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (enc0 : enc default = Mathlib.Vector.replicate n false) (L R : Turing.ListBlank Γ)
Goal: Turing.TM1to1.trTape enc0 (Turing.Tape.mk' L R) = Turing.TM1to1.trTape' enc0 L R
-- Turing.TM1to1.trTape'_move_left
theorem trTape'_move_left (L R : ListBlank Γ) :
    (Tape.move Dir.left)^[n] (trTape' enc0 L R) = trTape' enc0 L.tail (R.cons L.head) 
Arguments: {Γ : Type u_1} [Inhabited Γ] {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (enc0 : enc default = Mathlib.Vector.replicate n false) (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.move Turing.Dir.left)^[n] (Turing.TM1to1.trTape' enc0 L R) =
  Turing.TM1to1.trTape' enc0 L.tail (Turing.ListBlank.cons L.head R)
-- Turing.TM1to1.trTape'_move_right
theorem trTape'_move_right (L R : ListBlank Γ) :
    (Tape.move Dir.right)^[n] (trTape' enc0 L R) = trTape' enc0 (L.cons R.head) R.tail 
Arguments: {Γ : Type u_1} [Inhabited Γ] {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (enc0 : enc default = Mathlib.Vector.replicate n false) (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.move Turing.Dir.right)^[n] (Turing.TM1to1.trTape' enc0 L R) =
  Turing.TM1to1.trTape' enc0 (Turing.ListBlank.cons R.head L) R.tail
-- Turing.TM1to1.stepAux_write
theorem stepAux_write (q : Stmt'₁) (v : σ) (a b : Γ) (L R : ListBlank Γ) :
    stepAux (write (enc a).toList q) v (trTape' enc0 L (ListBlank.cons b R)) =
      stepAux q v (trTape' enc0 (ListBlank.cons a L) R) 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} {σ : Type u_3} {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (enc0 : enc default = Mathlib.Vector.replicate n false) (q : Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ) (v : σ) (a b : Γ) (L R : Turing.ListBlank Γ)
Goal: Turing.TM1.stepAux (Turing.TM1to1.write (enc a).toList q) v (Turing.TM1to1.trTape' enc0 L (Turing.ListBlank.cons b R)) =
  Turing.TM1.stepAux q v (Turing.TM1to1.trTape' enc0 (Turing.ListBlank.cons a L) R)
-- Turing.TM1to1.stepAux_read
theorem stepAux_read (f : Γ → Stmt'₁) (v : σ) (L R : ListBlank Γ) :
    stepAux (read dec f) v (trTape' enc0 L R) = stepAux (f R.head) v (trTape' enc0 L R) 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} {σ : Type u_3} {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (dec : Mathlib.Vector Bool n → Γ) (enc0 : enc default = Mathlib.Vector.replicate n false) (encdec : ∀ (a : Γ), dec (enc a) = a) (f : Γ → Turing.TM1.Stmt Bool Turing.TM1to1.Λ' σ) (v : σ) (L R : Turing.ListBlank Γ)
Goal: Turing.TM1.stepAux (Turing.TM1to1.read dec f) v (Turing.TM1to1.trTape' enc0 L R) =
  Turing.TM1.stepAux (f R.head) v (Turing.TM1to1.trTape' enc0 L R)
-- Turing.TM1to1.tr_respects
theorem tr_respects {enc₀} :
    Respects (step M) (step (tr enc dec M)) fun c₁ c₂ ↦ trCfg enc enc₀ c₁ = c₂ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} {σ : Type u_3} {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (dec : Mathlib.Vector Bool n → Γ) (enc0 : enc default = Mathlib.Vector.replicate n false) (M : Λ → Turing.TM1.Stmt Γ Λ σ) (encdec : ∀ (a : Γ), dec (enc a) = a) {enc₀ : enc default = Mathlib.Vector.replicate n false}
Goal: Turing.Respects (Turing.TM1.step M) (Turing.TM1.step (Turing.TM1to1.tr enc dec M)) fun c₁ c₂ =>
  Turing.TM1to1.trCfg enc enc₀ c₁ = c₂
-- Turing.TM1to1.tr_supports
theorem tr_supports {S : Finset Λ} (ss : Supports M S) : Supports (tr enc dec M) (trSupp M S) 
Arguments: {Γ : Type u_1} {Λ : Type u_2} [Inhabited Λ] {σ : Type u_3} {n : ℕ} {enc : Γ → Mathlib.Vector Bool n} (dec : Mathlib.Vector Bool n → Γ) (M : Λ → Turing.TM1.Stmt Γ Λ σ) [Fintype Γ] {S : Finset Λ} (ss : Turing.TM1.Supports M S)
Goal: Turing.TM1.Supports (Turing.TM1to1.tr enc dec M) (Turing.TM1to1.trSupp M S)
-- Turing.TM0to1.tr_respects
theorem tr_respects : Respects (TM0.step M) (TM1.step (tr M)) fun a b ↦ trCfg M a = b 
Arguments: {Γ : Type u_1} [Inhabited Γ] {Λ : Type u_2} [Inhabited Λ] (M : Turing.TM0.Machine Γ Λ)
Goal: Turing.Respects (Turing.TM0.step M) (Turing.TM1.step (Turing.TM0to1.tr M)) fun a b => Turing.TM0to1.trCfg M a = b
-- Turing.TM2.stmts₁_self
theorem stmts₁_self {q : Stmt₂} : q ∈ stmts₁ q 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {q : Turing.TM2.Stmt Γ Λ σ}
Goal: q ∈ Turing.TM2.stmts₁ q
-- Turing.TM2.stmts₁_trans
theorem stmts₁_trans {q₁ q₂ : Stmt₂} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂ 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {q₁ q₂ : Turing.TM2.Stmt Γ Λ σ}
Goal: q₁ ∈ Turing.TM2.stmts₁ q₂ → Turing.TM2.stmts₁ q₁ ⊆ Turing.TM2.stmts₁ q₂
-- Turing.TM2.stmts₁_supportsStmt_mono
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₂} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {S : Finset Λ} {q₁ q₂ : Turing.TM2.Stmt Γ Λ σ} (h : q₁ ∈ Turing.TM2.stmts₁ q₂) (hs : Turing.TM2.SupportsStmt S q₂)
Goal: Turing.TM2.SupportsStmt S q₁
-- Turing.TM2.stmts_trans
theorem stmts_trans {M : Λ → Stmt₂} {S : Finset Λ} {q₁ q₂ : Stmt₂} (h₁ : q₁ ∈ stmts₁ q₂) :
    some q₂ ∈ stmts M S → some q₁ ∈ stmts M S 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {M : Λ → Turing.TM2.Stmt Γ Λ σ} {S : Finset Λ} {q₁ q₂ : Turing.TM2.Stmt Γ Λ σ} (h₁ : q₁ ∈ Turing.TM2.stmts₁ q₂)
Goal: some q₂ ∈ Turing.TM2.stmts M S → some q₁ ∈ Turing.TM2.stmts M S