ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.mem_ndinsert_of_mem
theorem mem_ndinsert_of_mem {a b : α} {s : Multiset α} (h : a ∈ s) : a ∈ ndinsert b s 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} {s : Multiset α} (h : a ∈ s)
Goal: a ∈ Multiset.ndinsert b s
-- Multiset.length_ndinsert_of_mem
@[simp]
theorem length_ndinsert_of_mem {a : α} {s : Multiset α} (h : a ∈ s) :
    card (ndinsert a s) = card s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (h : a ∈ s)
Goal: Multiset.card (Multiset.ndinsert a s) = Multiset.card s
-- Multiset.length_ndinsert_of_not_mem
@[simp]
theorem length_ndinsert_of_not_mem {a : α} {s : Multiset α} (h : a ∉ s) :
    card (ndinsert a s) = card s + 1 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (h : a ∉ s)
Goal: Multiset.card (Multiset.ndinsert a s) = Multiset.card s + 1
-- Multiset.dedup_cons
theorem dedup_cons {a : α} {s : Multiset α} : dedup (a ::ₘ s) = ndinsert a (dedup s) 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: (a ::ₘ s).dedup = Multiset.ndinsert a s.dedup
-- Multiset.Nodup.ndinsert
theorem Nodup.ndinsert (a : α) : Nodup s → Nodup (ndinsert a s) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (a : α)
Goal: s.Nodup → (Multiset.ndinsert a s).Nodup
-- Multiset.ndinsert_le
theorem ndinsert_le {a : α} {s t : Multiset α} : ndinsert a s ≤ t ↔ s ≤ t ∧ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s t : Multiset α}
Goal: Multiset.ndinsert a s ≤ t ↔ s ≤ t ∧ a ∈ t
-- Multiset.attach_ndinsert
theorem attach_ndinsert (a : α) (s : Multiset α) :
    (s.ndinsert a).attach =
      ndinsert ⟨a, mem_ndinsert_self a s⟩ (s.attach.map fun p => ⟨p.1, mem_ndinsert_of_mem p.2⟩) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Multiset α)
Goal: (Multiset.ndinsert a s).attach = Multiset.ndinsert ⟨a, ⋯⟩ (Multiset.map (fun p => ⟨↑p, ⋯⟩) s.attach)
-- Multiset.disjoint_ndinsert_left
@[simp]
theorem disjoint_ndinsert_left {a : α} {s t : Multiset α} :
    Disjoint (ndinsert a s) t ↔ a ∉ t ∧ Disjoint s t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s t : Multiset α}
Goal: (Multiset.ndinsert a s).Disjoint t ↔ a ∉ t ∧ s.Disjoint t
-- Multiset.disjoint_ndinsert_right
@[simp]
theorem disjoint_ndinsert_right {a : α} {s t : Multiset α} :
    Disjoint s (ndinsert a t) ↔ a ∉ s ∧ Disjoint s t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s t : Multiset α}
Goal: s.Disjoint (Multiset.ndinsert a t) ↔ a ∉ s ∧ s.Disjoint t
-- Multiset.coe_ndunion
@[simp]
theorem coe_ndunion (l₁ l₂ : List α) : @ndunion α _ l₁ l₂ = (l₁ ∪ l₂ : List α) 
Arguments: {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α)
Goal: (↑l₁).ndunion ↑l₂ = ↑(l₁ ∪ l₂)
-- Multiset.zero_ndunion
theorem zero_ndunion (s : Multiset α) : ndunion 0 s = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: Multiset.ndunion 0 s = s
-- Multiset.cons_ndunion
@[simp]
theorem cons_ndunion (s t : Multiset α) (a : α) : ndunion (a ::ₘ s) t = ndinsert a (ndunion s t) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α) (a : α)
Goal: (a ::ₘ s).ndunion t = Multiset.ndinsert a (s.ndunion t)
-- Multiset.mem_ndunion
@[simp]
theorem mem_ndunion {s t : Multiset α} {a : α} : a ∈ ndunion s t ↔ a ∈ s ∨ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} {a : α}
Goal: a ∈ s.ndunion t ↔ a ∈ s ∨ a ∈ t
-- Multiset.le_ndunion_right
theorem le_ndunion_right (s t : Multiset α) : t ≤ ndunion s t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: t ≤ s.ndunion t
-- Multiset.subset_ndunion_right
theorem subset_ndunion_right (s t : Multiset α) : t ⊆ ndunion s t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: t ⊆ s.ndunion t
-- Multiset.ndunion_le_add
theorem ndunion_le_add (s t : Multiset α) : ndunion s t ≤ s + t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s.ndunion t ≤ s + t
-- Multiset.ndunion_le
theorem ndunion_le {s t u : Multiset α} : ndunion s t ≤ u ↔ s ⊆ u ∧ t ≤ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s.ndunion t ≤ u ↔ s ⊆ u ∧ t ≤ u
-- Multiset.subset_ndunion_left
theorem subset_ndunion_left (s t : Multiset α) : s ⊆ ndunion s t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ⊆ s.ndunion t
-- Multiset.le_ndunion_left
theorem le_ndunion_left {s} (t : Multiset α) (d : Nodup s) : s ≤ ndunion s t 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (t : Multiset α) (d : s.Nodup)
Goal: s ≤ s.ndunion t
-- Multiset.ndunion_le_union
theorem ndunion_le_union (s t : Multiset α) : ndunion s t ≤ s ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s.ndunion t ≤ s ∪ t
-- Multiset.Nodup.ndunion
theorem Nodup.ndunion (s : Multiset α) {t : Multiset α} : Nodup t → Nodup (ndunion s t) 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) {t : Multiset α}
Goal: t.Nodup → (s.ndunion t).Nodup
-- Multiset.ndunion_eq_union
@[simp]
theorem ndunion_eq_union {s t : Multiset α} (d : Nodup s) : ndunion s t = s ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (d : s.Nodup)
Goal: s.ndunion t = s ∪ t
-- Multiset.dedup_add
theorem dedup_add (s t : Multiset α) : dedup (s + t) = ndunion s (dedup t) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: (s + t).dedup = s.ndunion t.dedup
-- Multiset.Disjoint.ndunion_eq
theorem Disjoint.ndunion_eq {s t : Multiset α} (h : Disjoint s t) :
    s.ndunion t = s.dedup + t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s.Disjoint t)
Goal: s.ndunion t = s.dedup + t
-- Multiset.Subset.ndunion_eq_right
theorem Subset.ndunion_eq_right {s t : Multiset α} (h : s ⊆ t) : s.ndunion t = t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ⊆ t)
Goal: s.ndunion t = t
-- Multiset.coe_ndinter
@[simp]
theorem coe_ndinter (l₁ l₂ : List α) : @ndinter α _ l₁ l₂ = (l₁ ∩ l₂ : List α) 
Arguments: {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α)
Goal: (↑l₁).ndinter ↑l₂ = ↑(l₁ ∩ l₂)
-- Multiset.zero_ndinter
@[simp]
theorem zero_ndinter (s : Multiset α) : ndinter 0 s = 0 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: Multiset.ndinter 0 s = 0
-- Multiset.cons_ndinter_of_mem
@[simp]
theorem cons_ndinter_of_mem {a : α} (s : Multiset α) {t : Multiset α} (h : a ∈ t) :
    ndinter (a ::ₘ s) t = a ::ₘ ndinter s t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α} (h : a ∈ t)
Goal: (a ::ₘ s).ndinter t = a ::ₘ s.ndinter t
-- Multiset.ndinter_cons_of_not_mem
@[simp]
theorem ndinter_cons_of_not_mem {a : α} (s : Multiset α) {t : Multiset α} (h : a ∉ t) :
    ndinter (a ::ₘ s) t = ndinter s t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α} (h : a ∉ t)
Goal: (a ::ₘ s).ndinter t = s.ndinter t
-- Multiset.mem_ndinter
@[simp]
theorem mem_ndinter {s t : Multiset α} {a : α} : a ∈ ndinter s t ↔ a ∈ s ∧ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} {a : α}
Goal: a ∈ s.ndinter t ↔ a ∈ s ∧ a ∈ t
-- Multiset.Nodup.ndinter
@[simp]
theorem Nodup.ndinter {s : Multiset α} (t : Multiset α) : Nodup s → Nodup (ndinter s t) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (t : Multiset α)
Goal: s.Nodup → (s.ndinter t).Nodup
-- Multiset.le_ndinter
theorem le_ndinter {s t u : Multiset α} : s ≤ ndinter t u ↔ s ≤ t ∧ s ⊆ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s ≤ t.ndinter u ↔ s ≤ t ∧ s ⊆ u
-- Multiset.ndinter_le_left
theorem ndinter_le_left (s t : Multiset α) : ndinter s t ≤ s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s.ndinter t ≤ s
-- Multiset.ndinter_subset_left
theorem ndinter_subset_left (s t : Multiset α) : ndinter s t ⊆ s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s.ndinter t ⊆ s
-- Multiset.ndinter_subset_right
theorem ndinter_subset_right (s t : Multiset α) : ndinter s t ⊆ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s.ndinter t ⊆ t
-- Multiset.ndinter_le_right
theorem ndinter_le_right {s} (t : Multiset α) (d : Nodup s) : ndinter s t ≤ t 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (t : Multiset α) (d : s.Nodup)
Goal: s.ndinter t ≤ t
-- Multiset.inter_le_ndinter
theorem inter_le_ndinter (s t : Multiset α) : s ∩ t ≤ ndinter s t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∩ t ≤ s.ndinter t
-- Multiset.ndinter_eq_inter
@[simp]
theorem ndinter_eq_inter {s t : Multiset α} (d : Nodup s) : ndinter s t = s ∩ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (d : s.Nodup)
Goal: s.ndinter t = s ∩ t
-- Multiset.ndinter_eq_zero_iff_disjoint
theorem ndinter_eq_zero_iff_disjoint {s t : Multiset α} : ndinter s t = 0 ↔ Disjoint s t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s.ndinter t = 0 ↔ s.Disjoint t
-- Multiset.Subset.ndinter_eq_left
theorem Subset.ndinter_eq_left {s t : Multiset α} (h : s ⊆ t) : s.ndinter t = s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ⊆ t)
Goal: s.ndinter t = s
-- Mathlib.Vector.toList_injective
theorem toList_injective : Function.Injective (@toList α n) 
Arguments: {n : ℕ} {α : Type u_1}
Goal: Function.Injective Mathlib.Vector.toList
-- Mathlib.Vector.ext
@[ext]
theorem ext : ∀ {v w : Vector α n} (_ : ∀ m : Fin n, Vector.get v m = Vector.get w m), v = w
  
Arguments: {n : ℕ} {α : Type u_1} {v w : Mathlib.Vector α n}
Goal: (∀ (m : Fin n), v.get m = w.get m) → v = w
-- Mathlib.Vector.cons_val
@[simp]
theorem cons_val (a : α) : ∀ v : Vector α n, (a ::ᵥ v).val = a :: v.val
  
Arguments: {n : ℕ} {α : Type u_1} (a : α) (v : Mathlib.Vector α n)
Goal: ↑(a ::ᵥ v) = a :: ↑v
-- Mathlib.Vector.eq_cons_iff
theorem eq_cons_iff (a : α) (v : Vector α n.succ) (v' : Vector α n) :
    v = a ::ᵥ v' ↔ v.head = a ∧ v.tail = v' 
Arguments: {n : ℕ} {α : Type u_1} (a : α) (v : Mathlib.Vector α n.succ) (v' : Mathlib.Vector α n)
Goal: v = a ::ᵥ v' ↔ v.head = a ∧ v.tail = v'
-- Mathlib.Vector.ne_cons_iff
theorem ne_cons_iff (a : α) (v : Vector α n.succ) (v' : Vector α n) :
    v ≠ a ::ᵥ v' ↔ v.head ≠ a ∨ v.tail ≠ v' 
Arguments: {n : ℕ} {α : Type u_1} (a : α) (v : Mathlib.Vector α n.succ) (v' : Mathlib.Vector α n)
Goal: v ≠ a ::ᵥ v' ↔ v.head ≠ a ∨ v.tail ≠ v'
-- Mathlib.Vector.exists_eq_cons
theorem exists_eq_cons (v : Vector α n.succ) : ∃ (a : α) (as : Vector α n), v = a ::ᵥ as 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n.succ)
Goal: ∃ a as, v = a ::ᵥ as
-- Mathlib.Vector.toList_ofFn
@[simp]
theorem toList_ofFn : ∀ {n} (f : Fin n → α), toList (ofFn f) = List.ofFn f
  
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n → α)
Goal: (Mathlib.Vector.ofFn f).toList = List.ofFn f
-- Mathlib.Vector.mk_toList
@[simp]
theorem mk_toList : ∀ (v : Vector α n) (h), (⟨toList v, h⟩ : Vector α n) = v
  
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n) (h : v.toList.length = n)
Goal: ⟨v.toList, h⟩ = v
-- Mathlib.Vector.length_val
@[simp] theorem length_val (v : Vector α n) : v.val.length = n 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n)
Goal: (↑v).length = n
-- Mathlib.Vector.toList_map
@[simp]
theorem toList_map {β : Type*} (v : Vector α n) (f : α → β) :
    (v.map f).toList = v.toList.map f 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (v : Mathlib.Vector α n) (f : α → β)
Goal: (Mathlib.Vector.map f v).toList = List.map f v.toList
-- Mathlib.Vector.head_map
@[simp]
theorem head_map {β : Type*} (v : Vector α (n + 1)) (f : α → β) : (v.map f).head = f v.head 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (v : Mathlib.Vector α (n + 1)) (f : α → β)
Goal: (Mathlib.Vector.map f v).head = f v.head
-- Mathlib.Vector.tail_map
@[simp]
theorem tail_map {β : Type*} (v : Vector α (n + 1)) (f : α → β) :
    (v.map f).tail = v.tail.map f 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (v : Mathlib.Vector α (n + 1)) (f : α → β)
Goal: (Mathlib.Vector.map f v).tail = Mathlib.Vector.map f v.tail
-- Mathlib.Vector.get_eq_get
theorem get_eq_get (v : Vector α n) (i : Fin n) :
    v.get i = v.toList.get (Fin.cast v.toList_length.symm i) 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n) (i : Fin n)
Goal: v.get i = v.toList.get (Fin.cast ⋯ i)
-- Mathlib.Vector.get_replicate
@[simp]
theorem get_replicate (a : α) (i : Fin n) : (Vector.replicate n a).get i = a 
Arguments: {n : ℕ} {α : Type u_1} (a : α) (i : Fin n)
Goal: (Mathlib.Vector.replicate n a).get i = a
-- Mathlib.Vector.get_map
@[simp]
theorem get_map {β : Type*} (v : Vector α n) (f : α → β) (i : Fin n) :
    (v.map f).get i = f (v.get i) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (v : Mathlib.Vector α n) (f : α → β) (i : Fin n)
Goal: (Mathlib.Vector.map f v).get i = f (v.get i)
-- Mathlib.Vector.map₂_nil
@[simp]
theorem map₂_nil (f : α → β → γ) : Vector.map₂ f nil nil = nil 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ)
Goal: Mathlib.Vector.map₂ f Mathlib.Vector.nil Mathlib.Vector.nil = Mathlib.Vector.nil
-- Mathlib.Vector.map₂_cons
@[simp]
theorem map₂_cons (hd₁ : α) (tl₁ : Vector α n) (hd₂ : β) (tl₂ : Vector β n) (f : α → β → γ) :
    Vector.map₂ f (hd₁ ::ᵥ tl₁) (hd₂ ::ᵥ tl₂) = f hd₁ hd₂ ::ᵥ (Vector.map₂ f tl₁ tl₂) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} {γ : Type u_3} (hd₁ : α) (tl₁ : Mathlib.Vector α n) (hd₂ : β) (tl₂ : Mathlib.Vector β n) (f : α → β → γ)
Goal: Mathlib.Vector.map₂ f (hd₁ ::ᵥ tl₁) (hd₂ ::ᵥ tl₂) = f hd₁ hd₂ ::ᵥ Mathlib.Vector.map₂ f tl₁ tl₂
-- Mathlib.Vector.get_ofFn
@[simp]
theorem get_ofFn {n} (f : Fin n → α) (i) : get (ofFn f) i = f i 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n → α) (i : Fin n)
Goal: (Mathlib.Vector.ofFn f).get i = f i
-- Mathlib.Vector.ofFn_get
@[simp]
theorem ofFn_get (v : Vector α n) : ofFn (get v) = v 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n)
Goal: Mathlib.Vector.ofFn v.get = v
-- Mathlib.Vector.get_tail
theorem get_tail (x : Vector α n) (i) : x.tail.get i = x.get ⟨i.1 + 1, by omega⟩ 
Arguments: {n : ℕ} {α : Type u_1} (x : Mathlib.Vector α n) (i : Fin (n - 1))
Goal: x.tail.get i = x.get ⟨↑i + 1, ⋯⟩
-- Mathlib.Vector.get_tail_succ
@[simp]
theorem get_tail_succ : ∀ (v : Vector α n.succ) (i : Fin n), get (tail v) i = get v i.succ
  
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n.succ) (i : Fin n)
Goal: v.tail.get i = v.get i.succ
-- Mathlib.Vector.tail_val
@[simp]
theorem tail_val : ∀ v : Vector α n.succ, v.tail.val = v.val.tail
  
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n.succ)
Goal: ↑v.tail = (↑v).tail
-- Mathlib.Vector.tail_nil
@[simp]
theorem tail_nil : (@nil α).tail = nil 
Arguments: {α : Type u_1}
Goal: Mathlib.Vector.nil.tail = Mathlib.Vector.nil
-- Mathlib.Vector.singleton_tail
@[simp]
theorem singleton_tail : ∀ (v : Vector α 1), v.tail = Vector.nil
  
Arguments: {α : Type u_1} (v : Mathlib.Vector α 1)
Goal: v.tail = Mathlib.Vector.nil
-- Mathlib.Vector.tail_ofFn
@[simp]
theorem tail_ofFn {n : ℕ} (f : Fin n.succ → α) : tail (ofFn f) = ofFn fun i => f i.succ 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n.succ → α)
Goal: (Mathlib.Vector.ofFn f).tail = Mathlib.Vector.ofFn fun i => f i.succ
-- Mathlib.Vector.toList_empty
@[simp]
theorem toList_empty (v : Vector α 0) : v.toList = [] 
Arguments: {α : Type u_1} (v : Mathlib.Vector α 0)
Goal: v.toList = []
-- Mathlib.Vector.toList_singleton
@[simp]
theorem toList_singleton (v : Vector α 1) : v.toList = [v.head] 
Arguments: {α : Type u_1} (v : Mathlib.Vector α 1)
Goal: v.toList = [v.head]
-- Mathlib.Vector.empty_toList_eq_ff
@[simp]
theorem empty_toList_eq_ff (v : Vector α (n + 1)) : v.toList.isEmpty = false 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α (n + 1))
Goal: v.toList.isEmpty = false
-- Mathlib.Vector.not_empty_toList
theorem not_empty_toList (v : Vector α (n + 1)) : ¬v.toList.isEmpty 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α (n + 1))
Goal: ¬v.toList.isEmpty = true
-- Mathlib.Vector.map_id
@[simp]
theorem map_id {n : ℕ} (v : Vector α n) : Vector.map id v = v 
Arguments: {α : Type u_1} {n : ℕ} (v : Mathlib.Vector α n)
Goal: Mathlib.Vector.map id v = v
-- Mathlib.Vector.nodup_iff_injective_get
theorem nodup_iff_injective_get {v : Vector α n} : v.toList.Nodup ↔ Function.Injective v.get 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α n}
Goal: v.toList.Nodup ↔ Function.Injective v.get
-- Mathlib.Vector.head?_toList
theorem head?_toList : ∀ v : Vector α n.succ, (toList v).head? = some (head v)
  
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n.succ)
Goal: v.toList.head? = some v.head
-- Mathlib.Vector.toList_reverse
theorem toList_reverse {v : Vector α n} : v.reverse.toList = v.toList.reverse 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α n}
Goal: v.reverse.toList = v.toList.reverse
-- Mathlib.Vector.reverse_reverse
@[simp]
theorem reverse_reverse {v : Vector α n} : v.reverse.reverse = v 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α n}
Goal: v.reverse.reverse = v
-- Mathlib.Vector.get_zero
@[simp]
theorem get_zero : ∀ v : Vector α n.succ, get v 0 = head v
  
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n.succ)
Goal: v.get 0 = v.head
-- Mathlib.Vector.head_ofFn
@[simp]
theorem head_ofFn {n : ℕ} (f : Fin n.succ → α) : head (ofFn f) = f 0 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n.succ → α)
Goal: (Mathlib.Vector.ofFn f).head = f 0
-- Mathlib.Vector.get_cons_zero
theorem get_cons_zero (a : α) (v : Vector α n) : get (a ::ᵥ v) 0 = a 
Arguments: {n : ℕ} {α : Type u_1} (a : α) (v : Mathlib.Vector α n)
Goal: (a ::ᵥ v).get 0 = a
-- Mathlib.Vector.get_cons_nil
@[simp]
theorem get_cons_nil : ∀ {ix : Fin 1} (x : α), get (x ::ᵥ nil) ix = x
  
Arguments: {α : Type u_1} {ix : Fin 1} (x : α)
Goal: (x ::ᵥ Mathlib.Vector.nil).get ix = x
-- Mathlib.Vector.get_cons_succ
@[simp]
theorem get_cons_succ (a : α) (v : Vector α n) (i : Fin n) : get (a ::ᵥ v) i.succ = get v i 
Arguments: {n : ℕ} {α : Type u_1} (a : α) (v : Mathlib.Vector α n) (i : Fin n)
Goal: (a ::ᵥ v).get i.succ = v.get i
-- Mathlib.Vector.last_def
theorem last_def {v : Vector α (n + 1)} : v.last = v.get (Fin.last n) 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α (n + 1)}
Goal: v.last = v.get (Fin.last n)
-- Mathlib.Vector.reverse_get_zero
theorem reverse_get_zero {v : Vector α (n + 1)} : v.reverse.head = v.last 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α (n + 1)}
Goal: v.reverse.head = v.last
-- Mathlib.Vector.scanl_nil
@[simp]
theorem scanl_nil : scanl f b nil = b ::ᵥ nil 
Arguments: {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β)
Goal: Mathlib.Vector.scanl f b Mathlib.Vector.nil = b ::ᵥ Mathlib.Vector.nil
-- Mathlib.Vector.scanl_cons
@[simp]
theorem scanl_cons (x : α) : scanl f b (x ::ᵥ v) = b ::ᵥ scanl f (f b x) v 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (v : Mathlib.Vector α n) (x : α)
Goal: Mathlib.Vector.scanl f b (x ::ᵥ v) = b ::ᵥ Mathlib.Vector.scanl f (f b x) v
-- Mathlib.Vector.scanl_val
@[simp]
theorem scanl_val : ∀ {v : Vector α n}, (scanl f b v).val = List.scanl f b v.val
  
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) {v : Mathlib.Vector α n}
Goal: ↑(Mathlib.Vector.scanl f b v) = List.scanl f b ↑v
-- Mathlib.Vector.toList_scanl
@[simp]
theorem toList_scanl : (scanl f b v).toList = List.scanl f b v.toList 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (v : Mathlib.Vector α n)
Goal: (Mathlib.Vector.scanl f b v).toList = List.scanl f b v.toList
-- Mathlib.Vector.scanl_singleton
@[simp]
theorem scanl_singleton (v : Vector α 1) : scanl f b v = b ::ᵥ f b v.head ::ᵥ nil 
Arguments: {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (v : Mathlib.Vector α 1)
Goal: Mathlib.Vector.scanl f b v = b ::ᵥ f b v.head ::ᵥ Mathlib.Vector.nil
-- Mathlib.Vector.scanl_head
@[simp]
theorem scanl_head : (scanl f b v).head = b 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (v : Mathlib.Vector α n)
Goal: (Mathlib.Vector.scanl f b v).head = b
-- Mathlib.Vector.scanl_get
@[simp]
theorem scanl_get (i : Fin n) :
    (scanl f b v).get i.succ = f ((scanl f b v).get (Fin.castSucc i)) (v.get i) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (v : Mathlib.Vector α n) (i : Fin n)
Goal: (Mathlib.Vector.scanl f b v).get i.succ = f ((Mathlib.Vector.scanl f b v).get i.castSucc) (v.get i)
-- Mathlib.Vector.mOfFn_pure
theorem mOfFn_pure {m} [Monad m] [LawfulMonad m] {α} :
    ∀ {n} (f : Fin n → α), (@mOfFn m _ _ _ fun i => pure (f i)) = pure (ofFn f)
  
Arguments: {m : Type u_2 → Type u_3} [Monad m] [LawfulMonad m] {α : Type u_2} {n : ℕ} (f : Fin n → α)
Goal: (Mathlib.Vector.mOfFn fun i => pure (f i)) = pure (Mathlib.Vector.ofFn f)
-- Mathlib.Vector.mmap_nil
@[simp]
theorem mmap_nil {m} [Monad m] {α β} (f : α → m β) : mmap f nil = pure nil 
Arguments: {m : Type u_2 → Type u_3} [Monad m] {α : Type u_4} {β : Type u_2} (f : α → m β)
Goal: Mathlib.Vector.mmap f Mathlib.Vector.nil = pure Mathlib.Vector.nil
-- Mathlib.Vector.mmap_cons
@[simp]
theorem mmap_cons {m} [Monad m] {α β} (f : α → m β) (a) :
    ∀ {n} (v : Vector α n),
      mmap f (a ::ᵥ v) = do
        let h' ← f a
        let t' ← mmap f v
        pure (h' ::ᵥ t')
  
Arguments: {m : Type u_2 → Type u_3} [Monad m] {α : Type u_4} {β : Type u_2} (f : α → m β) (a : α) {n : ℕ} (v : Mathlib.Vector α n)
Goal: Mathlib.Vector.mmap f (a ::ᵥ v) = do
  let h' ← f a
  let t' ← Mathlib.Vector.mmap f v
  pure (h' ::ᵥ t')
-- Mathlib.Vector.inductionOn_nil
@[simp]
theorem inductionOn_nil {C : ∀ {n : ℕ}, Vector α n → Sort*}
    (nil : C nil) (cons : ∀ {n : ℕ} {x : α} {w : Vector α n}, C w → C (x ::ᵥ w)) :
    Vector.nil.inductionOn nil cons = nil 
Arguments: {α : Type u_1} {C : {n : ℕ} → Mathlib.Vector α n → Sort u_2} (nil : C Mathlib.Vector.nil) (cons : {n : ℕ} → {x : α} → {w : Mathlib.Vector α n} → C w → C (x ::ᵥ w))
Goal: (Mathlib.Vector.nil.inductionOn nil fun {n} {x} {w} => cons) = nil
-- Mathlib.Vector.inductionOn_cons
@[simp]
theorem inductionOn_cons {C : ∀ {n : ℕ}, Vector α n → Sort*} {n : ℕ} (x : α) (v : Vector α n)
    (nil : C nil) (cons : ∀ {n : ℕ} {x : α} {w : Vector α n}, C w → C (x ::ᵥ w)) :
    (x ::ᵥ v).inductionOn nil cons = cons (v.inductionOn nil cons : C v) 
Arguments: {α : Type u_1} {C : {n : ℕ} → Mathlib.Vector α n → Sort u_2} {n : ℕ} (x : α) (v : Mathlib.Vector α n) (nil : C Mathlib.Vector.nil) (cons : {n : ℕ} → {x : α} → {w : Mathlib.Vector α n} → C w → C (x ::ᵥ w))
Goal: ((x ::ᵥ v).inductionOn nil fun {n} {x} {w} => cons) = cons (v.inductionOn nil fun {n} {x} {w} => cons)
-- Mathlib.Vector.insertNth_val
theorem insertNth_val {i : Fin (n + 1)} {v : Vector α n} :
    (v.insertNth a i).val = v.val.insertNth i.1 a 
Arguments: {n : ℕ} {α : Type u_1} {a : α} {i : Fin (n + 1)} {v : Mathlib.Vector α n}
Goal: ↑(Mathlib.Vector.insertNth a i v) = List.insertNth (↑i) a ↑v
-- Mathlib.Vector.eraseIdx_val
@[simp]
theorem eraseIdx_val {i : Fin n} : ∀ {v : Vector α n}, (eraseIdx i v).val = v.val.eraseIdx i
  
Arguments: {n : ℕ} {α : Type u_1} {i : Fin n} {v : Mathlib.Vector α n}
Goal: ↑(Mathlib.Vector.eraseIdx i v) = (↑v).eraseIdx ↑i
-- Mathlib.Vector.eraseIdx_insertNth
theorem eraseIdx_insertNth {v : Vector α n} {i : Fin (n + 1)} :
    eraseIdx i (insertNth a i v) = v 
Arguments: {n : ℕ} {α : Type u_1} {a : α} {v : Mathlib.Vector α n} {i : Fin (n + 1)}
Goal: Mathlib.Vector.eraseIdx i (Mathlib.Vector.insertNth a i v) = v
-- Mathlib.Vector.eraseIdx_insertNth'
theorem eraseIdx_insertNth' {v : Vector α (n + 1)} :
    ∀ {i : Fin (n + 1)} {j : Fin (n + 2)},
      eraseIdx (j.succAbove i) (insertNth a j v) = insertNth a (i.predAbove j) (eraseIdx i v)
  
Arguments: {n : ℕ} {α : Type u_1} {a : α} {v : Mathlib.Vector α (n + 1)} {i : Fin (n + 1)} {j : Fin (n + 2)}
Goal: Mathlib.Vector.eraseIdx (j.succAbove i) (Mathlib.Vector.insertNth a j v) =
  Mathlib.Vector.insertNth a (i.predAbove j) (Mathlib.Vector.eraseIdx i v)
-- Mathlib.Vector.insertNth_comm
theorem insertNth_comm (a b : α) (i j : Fin (n + 1)) (h : i ≤ j) :
    ∀ v : Vector α n,
      (v.insertNth a i).insertNth b j.succ = (v.insertNth b j).insertNth a (Fin.castSucc i)
  
Arguments: {n : ℕ} {α : Type u_1} (a b : α) (i j : Fin (n + 1)) (h : i ≤ j) (v : Mathlib.Vector α n)
Goal: Mathlib.Vector.insertNth b j.succ (Mathlib.Vector.insertNth a i v) =
  Mathlib.Vector.insertNth a i.castSucc (Mathlib.Vector.insertNth b j v)