ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Affine.Triangle.eq_orthocenter_of_forall_mem_altitude
theorem eq_orthocenter_of_forall_mem_altitude {t : Triangle ℝ P} {i₁ i₂ : Fin 3} {p : P}
    (h₁₂ : i₁ ≠ i₂) (h₁ : p ∈ t.altitude i₁) (h₂ : p ∈ t.altitude i₂) : p = t.orthocenter 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {t : Affine.Triangle ℝ P} {i₁ i₂ : Fin 3} {p : P} (h₁₂ : i₁ ≠ i₂) (h₁ : p ∈ Affine.Simplex.altitude t i₁) (h₂ : p ∈ Affine.Simplex.altitude t i₂)
Goal: p = t.orthocenter
-- Affine.Triangle.dist_orthocenter_reflection_circumcenter
theorem dist_orthocenter_reflection_circumcenter (t : Triangle ℝ P) {i₁ i₂ : Fin 3} (h : i₁ ≠ i₂) :
    dist t.orthocenter (reflection (affineSpan ℝ (t.points '' {i₁, i₂})) t.circumcenter) =
      t.circumradius 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ : Fin 3} (h : i₁ ≠ i₂)
Goal: dist t.orthocenter
    ((EuclideanGeometry.reflection (affineSpan ℝ (t.points '' {i₁, i₂}))) (Affine.Simplex.circumcenter t)) =
  Affine.Simplex.circumradius t
-- Affine.Triangle.dist_orthocenter_reflection_circumcenter_finset
theorem dist_orthocenter_reflection_circumcenter_finset (t : Triangle ℝ P) {i₁ i₂ : Fin 3}
    (h : i₁ ≠ i₂) :
    dist t.orthocenter
        (reflection (affineSpan ℝ (t.points '' ↑({i₁, i₂} : Finset (Fin 3)))) t.circumcenter) =
      t.circumradius 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ : Fin 3} (h : i₁ ≠ i₂)
Goal: dist t.orthocenter
    ((EuclideanGeometry.reflection (affineSpan ℝ (t.points '' ↑{i₁, i₂}))) (Affine.Simplex.circumcenter t)) =
  Affine.Simplex.circumradius t
-- Affine.Triangle.affineSpan_orthocenter_point_le_altitude
theorem affineSpan_orthocenter_point_le_altitude (t : Triangle ℝ P) (i : Fin 3) :
    line[ℝ, t.orthocenter, t.points i] ≤ t.altitude i 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (t : Affine.Triangle ℝ P) (i : Fin 3)
Goal: affineSpan ℝ {t.orthocenter, t.points i} ≤ Affine.Simplex.altitude t i
-- Affine.Triangle.altitude_replace_orthocenter_eq_affineSpan
theorem altitude_replace_orthocenter_eq_affineSpan {t₁ t₂ : Triangle ℝ P}
    {i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3} (hi₁₂ : i₁ ≠ i₂) (hi₁₃ : i₁ ≠ i₃) (hi₂₃ : i₂ ≠ i₃) (hj₁₂ : j₁ ≠ j₂)
    (hj₁₃ : j₁ ≠ j₃) (hj₂₃ : j₂ ≠ j₃) (h₁ : t₂.points j₁ = t₁.orthocenter)
    (h₂ : t₂.points j₂ = t₁.points i₂) (h₃ : t₂.points j₃ = t₁.points i₃) :
    t₂.altitude j₂ = line[ℝ, t₁.points i₁, t₁.points i₂] 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {t₁ t₂ : Affine.Triangle ℝ P} {i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3} (hi₁₂ : i₁ ≠ i₂) (hi₁₃ : i₁ ≠ i₃) (hi₂₃ : i₂ ≠ i₃) (hj₁₂ : j₁ ≠ j₂) (hj₁₃ : j₁ ≠ j₃) (hj₂₃ : j₂ ≠ j₃) (h₁ : t₂.points j₁ = t₁.orthocenter) (h₂ : t₂.points j₂ = t₁.points i₂) (h₃ : t₂.points j₃ = t₁.points i₃)
Goal: Affine.Simplex.altitude t₂ j₂ = affineSpan ℝ {t₁.points i₁, t₁.points i₂}
-- Affine.Triangle.orthocenter_replace_orthocenter_eq_point
theorem orthocenter_replace_orthocenter_eq_point {t₁ t₂ : Triangle ℝ P} {i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3}
    (hi₁₂ : i₁ ≠ i₂) (hi₁₃ : i₁ ≠ i₃) (hi₂₃ : i₂ ≠ i₃) (hj₁₂ : j₁ ≠ j₂) (hj₁₃ : j₁ ≠ j₃)
    (hj₂₃ : j₂ ≠ j₃) (h₁ : t₂.points j₁ = t₁.orthocenter) (h₂ : t₂.points j₂ = t₁.points i₂)
    (h₃ : t₂.points j₃ = t₁.points i₃) : t₂.orthocenter = t₁.points i₁ 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {t₁ t₂ : Affine.Triangle ℝ P} {i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3} (hi₁₂ : i₁ ≠ i₂) (hi₁₃ : i₁ ≠ i₃) (hi₂₃ : i₂ ≠ i₃) (hj₁₂ : j₁ ≠ j₂) (hj₁₃ : j₁ ≠ j₃) (hj₂₃ : j₂ ≠ j₃) (h₁ : t₂.points j₁ = t₁.orthocenter) (h₂ : t₂.points j₂ = t₁.points i₂) (h₃ : t₂.points j₃ = t₁.points i₃)
Goal: t₂.orthocenter = t₁.points i₁
-- EuclideanGeometry.exists_of_range_subset_orthocentricSystem
theorem exists_of_range_subset_orthocentricSystem {t : Triangle ℝ P}
    (ho : t.orthocenter ∉ Set.range t.points) {p : Fin 3 → P}
    (hps : Set.range p ⊆ insert t.orthocenter (Set.range t.points)) (hpi : Function.Injective p) :
    (∃ i₁ i₂ i₃ j₂ j₃ : Fin 3,
      i₁ ≠ i₂ ∧ i₁ ≠ i₃ ∧ i₂ ≠ i₃ ∧ (∀ i : Fin 3, i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
        p i₁ = t.orthocenter ∧ j₂ ≠ j₃ ∧ t.points j₂ = p i₂ ∧ t.points j₃ = p i₃) ∨
      Set.range p = Set.range t.points 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {t : Affine.Triangle ℝ P} (ho : t.orthocenter ∉ Set.range t.points) {p : Fin 3 → P} (hps : Set.range p ⊆ insert t.orthocenter (Set.range t.points)) (hpi : Function.Injective p)
Goal: (∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = t.orthocenter ∧ j₂ ≠ j₃ ∧ t.points j₂ = p i₂ ∧ t.points j₃ = p i₃) ∨
  Set.range p = Set.range t.points
-- EuclideanGeometry.exists_dist_eq_circumradius_of_subset_insert_orthocenter
theorem exists_dist_eq_circumradius_of_subset_insert_orthocenter {t : Triangle ℝ P}
    (ho : t.orthocenter ∉ Set.range t.points) {p : Fin 3 → P}
    (hps : Set.range p ⊆ insert t.orthocenter (Set.range t.points)) (hpi : Function.Injective p) :
    ∃ c ∈ affineSpan ℝ (Set.range t.points), ∀ p₁ ∈ Set.range p, dist p₁ c = t.circumradius 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {t : Affine.Triangle ℝ P} (ho : t.orthocenter ∉ Set.range t.points) {p : Fin 3 → P} (hps : Set.range p ⊆ insert t.orthocenter (Set.range t.points)) (hpi : Function.Injective p)
Goal: ∃ c ∈ affineSpan ℝ (Set.range t.points), ∀ p₁ ∈ Set.range p, dist p₁ c = Affine.Simplex.circumradius t
-- EuclideanGeometry.OrthocentricSystem.affineIndependent
theorem OrthocentricSystem.affineIndependent {s : Set P} (ho : OrthocentricSystem s) {p : Fin 3 → P}
    (hps : Set.range p ⊆ s) (hpi : Function.Injective p) : AffineIndependent ℝ p 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {s : Set P} (ho : EuclideanGeometry.OrthocentricSystem s) {p : Fin 3 → P} (hps : Set.range p ⊆ s) (hpi : Function.Injective p)
Goal: AffineIndependent ℝ p
-- EuclideanGeometry.affineSpan_of_orthocentricSystem
theorem affineSpan_of_orthocentricSystem {s : Set P} (ho : OrthocentricSystem s) {p : Fin 3 → P}
    (hps : Set.range p ⊆ s) (hpi : Function.Injective p) :
    affineSpan ℝ (Set.range p) = affineSpan ℝ s 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {s : Set P} (ho : EuclideanGeometry.OrthocentricSystem s) {p : Fin 3 → P} (hps : Set.range p ⊆ s) (hpi : Function.Injective p)
Goal: affineSpan ℝ (Set.range p) = affineSpan ℝ s
-- EuclideanGeometry.OrthocentricSystem.exists_circumradius_eq
theorem OrthocentricSystem.exists_circumradius_eq {s : Set P} (ho : OrthocentricSystem s) :
    ∃ r : ℝ, ∀ t : Triangle ℝ P, Set.range t.points ⊆ s → t.circumradius = r 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {s : Set P} (ho : EuclideanGeometry.OrthocentricSystem s)
Goal: ∃ r, ∀ (t : Affine.Triangle ℝ P), Set.range t.points ⊆ s → Affine.Simplex.circumradius t = r
-- EuclideanGeometry.OrthocentricSystem.eq_insert_orthocenter
theorem OrthocentricSystem.eq_insert_orthocenter {s : Set P} (ho : OrthocentricSystem s)
    {t : Triangle ℝ P} (ht : Set.range t.points ⊆ s) :
    s = insert t.orthocenter (Set.range t.points) 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {s : Set P} (ho : EuclideanGeometry.OrthocentricSystem s) {t : Affine.Triangle ℝ P} (ht : Set.range t.points ⊆ s)
Goal: s = insert t.orthocenter (Set.range t.points)
-- Turing.BlankExtends.refl
@[refl]
theorem BlankExtends.refl {Γ} [Inhabited Γ] (l : List Γ) : BlankExtends l l 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : List Γ)
Goal: Turing.BlankExtends l l
-- Turing.BlankExtends.trans
@[trans]
theorem BlankExtends.trans {Γ} [Inhabited Γ] {l₁ l₂ l₃ : List Γ} :
    BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {l₁ l₂ l₃ : List Γ}
Goal: Turing.BlankExtends l₁ l₂ → Turing.BlankExtends l₂ l₃ → Turing.BlankExtends l₁ l₃
-- Turing.BlankExtends.below_of_le
theorem BlankExtends.below_of_le {Γ} [Inhabited Γ] {l l₁ l₂ : List Γ} :
    BlankExtends l l₁ → BlankExtends l l₂ → l₁.length ≤ l₂.length → BlankExtends l₁ l₂ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {l l₁ l₂ : List Γ}
Goal: Turing.BlankExtends l l₁ → Turing.BlankExtends l l₂ → l₁.length ≤ l₂.length → Turing.BlankExtends l₁ l₂
-- Turing.BlankExtends.above_of_le
theorem BlankExtends.above_of_le {Γ} [Inhabited Γ] {l l₁ l₂ : List Γ} :
    BlankExtends l₁ l → BlankExtends l₂ l → l₁.length ≤ l₂.length → BlankExtends l₁ l₂ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {l l₁ l₂ : List Γ}
Goal: Turing.BlankExtends l₁ l → Turing.BlankExtends l₂ l → l₁.length ≤ l₂.length → Turing.BlankExtends l₁ l₂
-- Turing.BlankRel.refl
@[refl]
theorem BlankRel.refl {Γ} [Inhabited Γ] (l : List Γ) : BlankRel l l 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : List Γ)
Goal: Turing.BlankRel l l
-- Turing.BlankRel.symm
@[symm]
theorem BlankRel.symm {Γ} [Inhabited Γ] {l₁ l₂ : List Γ} : BlankRel l₁ l₂ → BlankRel l₂ l₁ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {l₁ l₂ : List Γ}
Goal: Turing.BlankRel l₁ l₂ → Turing.BlankRel l₂ l₁
-- Turing.BlankRel.trans
@[trans]
theorem BlankRel.trans {Γ} [Inhabited Γ] {l₁ l₂ l₃ : List Γ} :
    BlankRel l₁ l₂ → BlankRel l₂ l₃ → BlankRel l₁ l₃ 
Arguments: {Γ : Type u_1} [Inhabited Γ] {l₁ l₂ l₃ : List Γ}
Goal: Turing.BlankRel l₁ l₂ → Turing.BlankRel l₂ l₃ → Turing.BlankRel l₁ l₃
-- Turing.BlankRel.equivalence
theorem BlankRel.equivalence (Γ) [Inhabited Γ] : Equivalence (@BlankRel Γ _) 
Arguments: (Γ : Type u_1) [Inhabited Γ]
Goal: Equivalence Turing.BlankRel
-- Turing.ListBlank.induction_on
@[elab_as_elim]
protected theorem ListBlank.induction_on {Γ} [Inhabited Γ] {p : ListBlank Γ → Prop}
    (q : ListBlank Γ) (h : ∀ a, p (ListBlank.mk a)) : p q 
Arguments: {Γ : Type u_1} [Inhabited Γ] {p : Turing.ListBlank Γ → Prop} (q : Turing.ListBlank Γ) (h : ∀ (a : List Γ), p (Turing.ListBlank.mk a))
Goal: p q
-- Turing.ListBlank.head_mk
@[simp]
theorem ListBlank.head_mk {Γ} [Inhabited Γ] (l : List Γ) :
    ListBlank.head (ListBlank.mk l) = l.headI 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : List Γ)
Goal: (Turing.ListBlank.mk l).head = l.headI
-- Turing.ListBlank.tail_mk
@[simp]
theorem ListBlank.tail_mk {Γ} [Inhabited Γ] (l : List Γ) :
    ListBlank.tail (ListBlank.mk l) = ListBlank.mk l.tail 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : List Γ)
Goal: (Turing.ListBlank.mk l).tail = Turing.ListBlank.mk l.tail
-- Turing.ListBlank.cons_mk
@[simp]
theorem ListBlank.cons_mk {Γ} [Inhabited Γ] (a : Γ) (l : List Γ) :
    ListBlank.cons a (ListBlank.mk l) = ListBlank.mk (a :: l) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (a : Γ) (l : List Γ)
Goal: Turing.ListBlank.cons a (Turing.ListBlank.mk l) = Turing.ListBlank.mk (a :: l)
-- Turing.ListBlank.head_cons
@[simp]
theorem ListBlank.head_cons {Γ} [Inhabited Γ] (a : Γ) : ∀ l : ListBlank Γ, (l.cons a).head = a 
Arguments: {Γ : Type u_1} [Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ)
Goal: (Turing.ListBlank.cons a l).head = a
-- Turing.ListBlank.tail_cons
@[simp]
theorem ListBlank.tail_cons {Γ} [Inhabited Γ] (a : Γ) : ∀ l : ListBlank Γ, (l.cons a).tail = l 
Arguments: {Γ : Type u_1} [Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ)
Goal: (Turing.ListBlank.cons a l).tail = l
-- Turing.ListBlank.cons_head_tail
@[simp]
theorem ListBlank.cons_head_tail {Γ} [Inhabited Γ] : ∀ l : ListBlank Γ, l.tail.cons l.head = l 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : Turing.ListBlank Γ)
Goal: Turing.ListBlank.cons l.head l.tail = l
-- Turing.ListBlank.exists_cons
theorem ListBlank.exists_cons {Γ} [Inhabited Γ] (l : ListBlank Γ) :
    ∃ a l', l = ListBlank.cons a l' 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : Turing.ListBlank Γ)
Goal: ∃ a l', l = Turing.ListBlank.cons a l'
-- Turing.ListBlank.nth_mk
@[simp]
theorem ListBlank.nth_mk {Γ} [Inhabited Γ] (l : List Γ) (n : ℕ) :
    (ListBlank.mk l).nth n = l.getI n 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : List Γ) (n : ℕ)
Goal: (Turing.ListBlank.mk l).nth n = l.getI n
-- Turing.ListBlank.nth_zero
@[simp]
theorem ListBlank.nth_zero {Γ} [Inhabited Γ] (l : ListBlank Γ) : l.nth 0 = l.head 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : Turing.ListBlank Γ)
Goal: l.nth 0 = l.head
-- Turing.ListBlank.nth_succ
@[simp]
theorem ListBlank.nth_succ {Γ} [Inhabited Γ] (l : ListBlank Γ) (n : ℕ) :
    l.nth (n + 1) = l.tail.nth n 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l : Turing.ListBlank Γ) (n : ℕ)
Goal: l.nth (n + 1) = l.tail.nth n
-- Turing.ListBlank.ext
@[ext]
theorem ListBlank.ext {Γ} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} :
    (∀ i, L₁.nth i = L₂.nth i) → L₁ = L₂ 
Arguments: {Γ : Type u_1} [i : Inhabited Γ] {L₁ L₂ : Turing.ListBlank Γ}
Goal: (∀ (i_1 : ℕ), L₁.nth i_1 = L₂.nth i_1) → L₁ = L₂
-- Turing.ListBlank.nth_modifyNth
theorem ListBlank.nth_modifyNth {Γ} [Inhabited Γ] (f : Γ → Γ) (n i) (L : ListBlank Γ) :
    (L.modifyNth f n).nth i = if i = n then f (L.nth i) else L.nth i 
Arguments: {Γ : Type u_1} [Inhabited Γ] (f : Γ → Γ) (n i : ℕ) (L : Turing.ListBlank Γ)
Goal: (Turing.ListBlank.modifyNth f n L).nth i = if i = n then f (L.nth i) else L.nth i
-- Turing.PointedMap.map_pt'
structure PointedMap.{u, v} (Γ : Type u) (Γ' : Type v) [Inhabited Γ] [Inhabited Γ'] :
    Type max u v where
    f : Γ → Γ'
  map_pt' : f default = default
Arguments: {Γ : Type u} {Γ' : Type v} [Inhabited Γ] [Inhabited Γ'] (self : Turing.PointedMap Γ Γ')
Goal: self.f default = default
-- Turing.PointedMap.mk_val
theorem PointedMap.mk_val {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : Γ → Γ') (pt) :
    (PointedMap.mk f pt : Γ → Γ') = f 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Γ → Γ') (pt : f default = default)
Goal: { f := f, map_pt' := pt }.f = f
-- Turing.PointedMap.map_pt
@[simp]
theorem PointedMap.map_pt {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') :
    f default = default 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ')
Goal: f.f default = default
-- Turing.PointedMap.headI_map
@[simp]
theorem PointedMap.headI_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : List Γ) : (l.map f).headI = f l.headI 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : List Γ)
Goal: (List.map f.f l).headI = f.f l.headI
-- Turing.ListBlank.map_mk
@[simp]
theorem ListBlank.map_mk {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (l : List Γ) :
    (ListBlank.mk l).map f = ListBlank.mk (l.map f) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : List Γ)
Goal: Turing.ListBlank.map f (Turing.ListBlank.mk l) = Turing.ListBlank.mk (List.map f.f l)
-- Turing.ListBlank.head_map
@[simp]
theorem ListBlank.head_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) : (l.map f).head = f l.head 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : Turing.ListBlank Γ)
Goal: (Turing.ListBlank.map f l).head = f.f l.head
-- Turing.ListBlank.tail_map
@[simp]
theorem ListBlank.tail_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) : (l.map f).tail = l.tail.map f 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : Turing.ListBlank Γ)
Goal: (Turing.ListBlank.map f l).tail = Turing.ListBlank.map f l.tail
-- Turing.ListBlank.map_cons
@[simp]
theorem ListBlank.map_cons {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) (a : Γ) : (l.cons a).map f = (l.map f).cons (f a) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : Turing.ListBlank Γ) (a : Γ)
Goal: Turing.ListBlank.map f (Turing.ListBlank.cons a l) = Turing.ListBlank.cons (f.f a) (Turing.ListBlank.map f l)
-- Turing.ListBlank.nth_map
@[simp]
theorem ListBlank.nth_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) (n : ℕ) : (l.map f).nth n = f (l.nth n) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (f : Turing.PointedMap Γ Γ') (l : Turing.ListBlank Γ) (n : ℕ)
Goal: (Turing.ListBlank.map f l).nth n = f.f (l.nth n)
-- Turing.proj_map_nth
theorem proj_map_nth {ι : Type*} {Γ : ι → Type*} [∀ i, Inhabited (Γ i)] (i : ι) (L n) :
    (ListBlank.map (@proj ι Γ _ i) L).nth n = L.nth n i 
Arguments: {ι : Type u_1} {Γ : ι → Type u_2} [(i : ι) → Inhabited (Γ i)] (i : ι) (L : Turing.ListBlank ((i : ι) → Γ i)) (n : ℕ)
Goal: (Turing.ListBlank.map (Turing.proj i) L).nth n = L.nth n i
-- Turing.ListBlank.map_modifyNth
theorem ListBlank.map_modifyNth {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (F : PointedMap Γ Γ')
    (f : Γ → Γ) (f' : Γ' → Γ') (H : ∀ x, F (f x) = f' (F x)) (n) (L : ListBlank Γ) :
    (L.modifyNth f n).map F = (L.map F).modifyNth f' n 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (F : Turing.PointedMap Γ Γ') (f : Γ → Γ) (f' : Γ' → Γ') (H : ∀ (x : Γ), F.f (f x) = f' (F.f x)) (n : ℕ) (L : Turing.ListBlank Γ)
Goal: Turing.ListBlank.map F (Turing.ListBlank.modifyNth f n L) = Turing.ListBlank.modifyNth f' n (Turing.ListBlank.map F L)
-- Turing.ListBlank.append_mk
@[simp]
theorem ListBlank.append_mk {Γ} [Inhabited Γ] (l₁ l₂ : List Γ) :
    ListBlank.append l₁ (ListBlank.mk l₂) = ListBlank.mk (l₁ ++ l₂) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l₁ l₂ : List Γ)
Goal: Turing.ListBlank.append l₁ (Turing.ListBlank.mk l₂) = Turing.ListBlank.mk (l₁ ++ l₂)
-- Turing.ListBlank.append_assoc
theorem ListBlank.append_assoc {Γ} [Inhabited Γ] (l₁ l₂ : List Γ) (l₃ : ListBlank Γ) :
    ListBlank.append (l₁ ++ l₂) l₃ = ListBlank.append l₁ (ListBlank.append l₂ l₃) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (l₁ l₂ : List Γ) (l₃ : Turing.ListBlank Γ)
Goal: Turing.ListBlank.append (l₁ ++ l₂) l₃ = Turing.ListBlank.append l₁ (Turing.ListBlank.append l₂ l₃)
-- Turing.ListBlank.bind_mk
@[simp]
theorem ListBlank.bind_mk {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (l : List Γ) (f : Γ → List Γ') (hf) :
    (ListBlank.mk l).bind f hf = ListBlank.mk (l.bind f) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (l : List Γ) (f : Γ → List Γ') (hf : ∃ n, f default = List.replicate n default)
Goal: (Turing.ListBlank.mk l).bind f hf = Turing.ListBlank.mk (l.bind f)
-- Turing.ListBlank.cons_bind
@[simp]
theorem ListBlank.cons_bind {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (a : Γ) (l : ListBlank Γ)
    (f : Γ → List Γ') (hf) : (l.cons a).bind f hf = (l.bind f hf).append (f a) 
Arguments: {Γ : Type u_1} {Γ' : Type u_2} [Inhabited Γ] [Inhabited Γ'] (a : Γ) (l : Turing.ListBlank Γ) (f : Γ → List Γ') (hf : ∃ n, f default = List.replicate n default)
Goal: (Turing.ListBlank.cons a l).bind f hf = Turing.ListBlank.append (f a) (l.bind f hf)
-- Turing.Tape.move_left_right
@[simp]
theorem Tape.move_left_right {Γ} [Inhabited Γ] (T : Tape Γ) :
    (T.move Dir.left).move Dir.right = T 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: Turing.Tape.move Turing.Dir.right (Turing.Tape.move Turing.Dir.left T) = T
-- Turing.Tape.move_right_left
@[simp]
theorem Tape.move_right_left {Γ} [Inhabited Γ] (T : Tape Γ) :
    (T.move Dir.right).move Dir.left = T 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: Turing.Tape.move Turing.Dir.left (Turing.Tape.move Turing.Dir.right T) = T
-- Turing.Tape.mk'_left
@[simp]
theorem Tape.mk'_left {Γ} [Inhabited Γ] (L R : ListBlank Γ) : (Tape.mk' L R).left = L 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.mk' L R).left = L
-- Turing.Tape.mk'_head
@[simp]
theorem Tape.mk'_head {Γ} [Inhabited Γ] (L R : ListBlank Γ) : (Tape.mk' L R).head = R.head 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.mk' L R).head = R.head
-- Turing.Tape.mk'_right
@[simp]
theorem Tape.mk'_right {Γ} [Inhabited Γ] (L R : ListBlank Γ) : (Tape.mk' L R).right = R.tail 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.mk' L R).right = R.tail
-- Turing.Tape.mk'_right₀
@[simp]
theorem Tape.mk'_right₀ {Γ} [Inhabited Γ] (L R : ListBlank Γ) : (Tape.mk' L R).right₀ = R 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: (Turing.Tape.mk' L R).right₀ = R
-- Turing.Tape.mk'_left_right₀
@[simp]
theorem Tape.mk'_left_right₀ {Γ} [Inhabited Γ] (T : Tape Γ) : Tape.mk' T.left T.right₀ = T 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: Turing.Tape.mk' T.left T.right₀ = T
-- Turing.Tape.exists_mk'
theorem Tape.exists_mk' {Γ} [Inhabited Γ] (T : Tape Γ) : ∃ L R, T = Tape.mk' L R 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: ∃ L R, T = Turing.Tape.mk' L R
-- Turing.Tape.move_left_mk'
@[simp]
theorem Tape.move_left_mk' {Γ} [Inhabited Γ] (L R : ListBlank Γ) :
    (Tape.mk' L R).move Dir.left = Tape.mk' L.tail (R.cons L.head) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: Turing.Tape.move Turing.Dir.left (Turing.Tape.mk' L R) = Turing.Tape.mk' L.tail (Turing.ListBlank.cons L.head R)
-- Turing.Tape.move_right_mk'
@[simp]
theorem Tape.move_right_mk' {Γ} [Inhabited Γ] (L R : ListBlank Γ) :
    (Tape.mk' L R).move Dir.right = Tape.mk' (L.cons R.head) R.tail 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ)
Goal: Turing.Tape.move Turing.Dir.right (Turing.Tape.mk' L R) = Turing.Tape.mk' (Turing.ListBlank.cons R.head L) R.tail
-- Turing.Tape.nth_zero
@[simp]
theorem Tape.nth_zero {Γ} [Inhabited Γ] (T : Tape Γ) : T.nth 0 = T.1 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: T.nth 0 = T.head
-- Turing.Tape.right₀_nth
theorem Tape.right₀_nth {Γ} [Inhabited Γ] (T : Tape Γ) (n : ℕ) : T.right₀.nth n = T.nth n 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ) (n : ℕ)
Goal: T.right₀.nth n = T.nth ↑n
-- Turing.Tape.mk'_nth_nat
@[simp]
theorem Tape.mk'_nth_nat {Γ} [Inhabited Γ] (L R : ListBlank Γ) (n : ℕ) :
    (Tape.mk' L R).nth n = R.nth n 
Arguments: {Γ : Type u_1} [Inhabited Γ] (L R : Turing.ListBlank Γ) (n : ℕ)
Goal: (Turing.Tape.mk' L R).nth ↑n = R.nth n
-- Turing.Tape.move_left_nth
@[simp]
theorem Tape.move_left_nth {Γ} [Inhabited Γ] :
    ∀ (T : Tape Γ) (i : ℤ), (T.move Dir.left).nth i = T.nth (i - 1)
  
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ) (i : ℤ)
Goal: (Turing.Tape.move Turing.Dir.left T).nth i = T.nth (i - 1)
-- Turing.Tape.move_right_nth
@[simp]
theorem Tape.move_right_nth {Γ} [Inhabited Γ] (T : Tape Γ) (i : ℤ) :
    (T.move Dir.right).nth i = T.nth (i + 1) 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ) (i : ℤ)
Goal: (Turing.Tape.move Turing.Dir.right T).nth i = T.nth (i + 1)
-- Turing.Tape.move_right_n_head
@[simp]
theorem Tape.move_right_n_head {Γ} [Inhabited Γ] (T : Tape Γ) (i : ℕ) :
    ((Tape.move Dir.right)^[i] T).head = T.nth i 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ) (i : ℕ)
Goal: ((Turing.Tape.move Turing.Dir.right)^[i] T).head = T.nth ↑i
-- Turing.Tape.write_self
@[simp]
theorem Tape.write_self {Γ} [Inhabited Γ] : ∀ T : Tape Γ, T.write T.1 = T 
Arguments: {Γ : Type u_1} [Inhabited Γ] (T : Turing.Tape Γ)
Goal: Turing.Tape.write T.head T = T
-- Turing.Tape.write_nth
@[simp]
theorem Tape.write_nth {Γ} [Inhabited Γ] (b : Γ) :
    ∀ (T : Tape Γ) {i : ℤ}, (T.write b).nth i = if i = 0 then b else T.nth i
  
Arguments: {Γ : Type u_1} [Inhabited Γ] (b : Γ) (T : Turing.Tape Γ) {i : ℤ}
Goal: (Turing.Tape.write b T).nth i = if i = 0 then b else T.nth i