ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.exists_fin_zero_pi
@[simp]
theorem exists_fin_zero_pi {α : Fin 0 → Sort*} {P : (∀ i, α i) → Prop} :
    (∃ x, P x) ↔ P finZeroElim 
Arguments: {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}
Goal: (∃ x, P x) ↔ P finZeroElim
-- Fin.forall_fin_succ_pi
theorem forall_fin_succ_pi {P : (∀ i, α i) → Prop} : (∀ x, P x) ↔ ∀ a v, P (Fin.cons a v) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {P : ((i : Fin (n + 1)) → α i) → Prop}
Goal: (∀ (x : (i : Fin (n + 1)) → α i), P x) ↔ ∀ (a : α 0) (v : (i : Fin n) → α i.succ), P (Fin.cons a v)
-- Fin.exists_fin_succ_pi
theorem exists_fin_succ_pi {P : (∀ i, α i) → Prop} : (∃ x, P x) ↔ ∃ a v, P (Fin.cons a v) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {P : ((i : Fin (n + 1)) → α i) → Prop}
Goal: (∃ x, P x) ↔ ∃ a v, P (Fin.cons a v)
-- Fin.tail_update_zero
@[simp]
theorem tail_update_zero : tail (update q 0 z) = tail q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i) (z : α 0)
Goal: Fin.tail (Function.update q 0 z) = Fin.tail q
-- Fin.tail_update_succ
@[simp]
theorem tail_update_succ : tail (update q i.succ y) = update (tail q) i y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i) (i : Fin n) (y : α i.succ)
Goal: Fin.tail (Function.update q i.succ y) = Function.update (Fin.tail q) i y
-- Fin.comp_cons
theorem comp_cons {α : Type*} {β : Type*} (g : α → β) (y : α) (q : Fin n → α) :
    g ∘ cons y q = cons (g y) (g ∘ q) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (g : α → β) (y : α) (q : Fin n → α)
Goal: g ∘ Fin.cons y q = Fin.cons (g y) (g ∘ q)
-- Fin.comp_tail
theorem comp_tail {α : Type*} {β : Type*} (g : α → β) (q : Fin n.succ → α) :
    g ∘ tail q = tail (g ∘ q) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (g : α → β) (q : Fin n.succ → α)
Goal: g ∘ Fin.tail q = Fin.tail (g ∘ q)
-- Fin.le_cons
theorem le_cons [∀ i, Preorder (α i)] {x : α 0} {q : ∀ i, α i} {p : ∀ i : Fin n, α i.succ} :
    q ≤ cons x p ↔ q 0 ≤ x ∧ tail q ≤ p 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} [(i : Fin (n + 1)) → Preorder (α i)] {x : α 0} {q : (i : Fin (n + 1)) → α i} {p : (i : Fin n) → α i.succ}
Goal: q ≤ Fin.cons x p ↔ q 0 ≤ x ∧ Fin.tail q ≤ p
-- Fin.cons_le
theorem cons_le [∀ i, Preorder (α i)] {x : α 0} {q : ∀ i, α i} {p : ∀ i : Fin n, α i.succ} :
    cons x p ≤ q ↔ x ≤ q 0 ∧ p ≤ tail q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} [(i : Fin (n + 1)) → Preorder (α i)] {x : α 0} {q : (i : Fin (n + 1)) → α i} {p : (i : Fin n) → α i.succ}
Goal: Fin.cons x p ≤ q ↔ x ≤ q 0 ∧ p ≤ Fin.tail q
-- Fin.cons_le_cons
theorem cons_le_cons [∀ i, Preorder (α i)] {x₀ y₀ : α 0} {x y : ∀ i : Fin n, α i.succ} :
    cons x₀ x ≤ cons y₀ y ↔ x₀ ≤ y₀ ∧ x ≤ y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} [(i : Fin (n + 1)) → Preorder (α i)] {x₀ y₀ : α 0} {x y : (i : Fin n) → α i.succ}
Goal: Fin.cons x₀ x ≤ Fin.cons y₀ y ↔ x₀ ≤ y₀ ∧ x ≤ y
-- Fin.range_fin_succ
theorem range_fin_succ {α} (f : Fin (n + 1) → α) :
    Set.range f = insert (f 0) (Set.range (Fin.tail f)) 
Arguments: {n : ℕ} {α : Type u_1} (f : Fin (n + 1) → α)
Goal: Set.range f = insert (f 0) (Set.range (Fin.tail f))
-- Fin.range_cons
@[simp]
theorem range_cons {α : Type*} {n : ℕ} (x : α) (b : Fin n → α) :
    Set.range (Fin.cons x b : Fin n.succ → α) = insert x (Set.range b) 
Arguments: {α : Type u_1} {n : ℕ} (x : α) (b : Fin n → α)
Goal: Set.range (Fin.cons x b) = insert x (Set.range b)
-- Fin.append_left
@[simp]
theorem append_left {α : Type*} (u : Fin m → α) (v : Fin n → α) (i : Fin m) :
    append u v (Fin.castAdd n i) = u i 
Arguments: {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (i : Fin m)
Goal: Fin.append u v (Fin.castAdd n i) = u i
-- Fin.append_right
@[simp]
theorem append_right {α : Type*} (u : Fin m → α) (v : Fin n → α) (i : Fin n) :
    append u v (natAdd m i) = v i 
Arguments: {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (i : Fin n)
Goal: Fin.append u v (Fin.natAdd m i) = v i
-- Fin.append_right_nil
theorem append_right_nil {α : Type*} (u : Fin m → α) (v : Fin n → α) (hv : n = 0) :
    append u v = u ∘ Fin.cast (by rw [hv, Nat.add_zero]) 
Arguments: {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (hv : n = 0)
Goal: Fin.append u v = u ∘ Fin.cast ⋯
-- Fin.append_elim0
@[simp]
theorem append_elim0 {α : Type*} (u : Fin m → α) :
    append u Fin.elim0 = u ∘ Fin.cast (Nat.add_zero _) 
Arguments: {m : ℕ} {α : Type u_1} (u : Fin m → α)
Goal: Fin.append u Fin.elim0 = u ∘ Fin.cast ⋯
-- Fin.append_left_nil
theorem append_left_nil {α : Type*} (u : Fin m → α) (v : Fin n → α) (hu : m = 0) :
    append u v = v ∘ Fin.cast (by rw [hu, Nat.zero_add]) 
Arguments: {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (hu : m = 0)
Goal: Fin.append u v = v ∘ Fin.cast ⋯
-- Fin.elim0_append
@[simp]
theorem elim0_append {α : Type*} (v : Fin n → α) :
    append Fin.elim0 v = v ∘ Fin.cast (Nat.zero_add _) 
Arguments: {n : ℕ} {α : Type u_1} (v : Fin n → α)
Goal: Fin.append Fin.elim0 v = v ∘ Fin.cast ⋯
-- Fin.append_assoc
theorem append_assoc {p : ℕ} {α : Type*} (a : Fin m → α) (b : Fin n → α) (c : Fin p → α) :
    append (append a b) c = append a (append b c) ∘ Fin.cast (Nat.add_assoc ..) 
Arguments: {m n p : ℕ} {α : Type u_1} (a : Fin m → α) (b : Fin n → α) (c : Fin p → α)
Goal: Fin.append (Fin.append a b) c = Fin.append a (Fin.append b c) ∘ Fin.cast ⋯
-- Fin.append_left_eq_cons
theorem append_left_eq_cons {α : Type*} {n : ℕ} (x₀ : Fin 1 → α) (x : Fin n → α) :
    Fin.append x₀ x = Fin.cons (x₀ 0) x ∘ Fin.cast (Nat.add_comm ..) 
Arguments: {α : Type u_1} {n : ℕ} (x₀ : Fin 1 → α) (x : Fin n → α)
Goal: Fin.append x₀ x = Fin.cons (x₀ 0) x ∘ Fin.cast ⋯
-- Fin.cons_eq_append
theorem cons_eq_append {α : Type*} (x : α) (xs : Fin n → α) :
    cons x xs = append (cons x Fin.elim0) xs ∘ Fin.cast (Nat.add_comm ..) 
Arguments: {n : ℕ} {α : Type u_1} (x : α) (xs : Fin n → α)
Goal: Fin.cons x xs = Fin.append (Fin.cons x Fin.elim0) xs ∘ Fin.cast ⋯
-- Fin.append_cast_left
@[simp] lemma append_cast_left {n m} {α : Type*} (xs : Fin n → α) (ys : Fin m → α) (n' : ℕ)
    (h : n' = n) :
    Fin.append (xs ∘ Fin.cast h) ys = Fin.append xs ys ∘ (Fin.cast <| by rw [h]) 
Arguments: {n m : ℕ} {α : Type u_1} (xs : Fin n → α) (ys : Fin m → α) (n' : ℕ) (h : n' = n)
Goal: Fin.append (xs ∘ Fin.cast h) ys = Fin.append xs ys ∘ Fin.cast ⋯
-- Fin.append_cast_right
@[simp] lemma append_cast_right {n m} {α : Type*} (xs : Fin n → α) (ys : Fin m → α) (m' : ℕ)
    (h : m' = m) :
    Fin.append xs (ys ∘ Fin.cast h) = Fin.append xs ys ∘ (Fin.cast <| by rw [h]) 
Arguments: {n m : ℕ} {α : Type u_1} (xs : Fin n → α) (ys : Fin m → α) (m' : ℕ) (h : m' = m)
Goal: Fin.append xs (ys ∘ Fin.cast h) = Fin.append xs ys ∘ Fin.cast ⋯
-- Fin.append_rev
lemma append_rev {m n} {α : Type*} (xs : Fin m → α) (ys : Fin n → α) (i : Fin (m + n)) :
    append xs ys (rev i) = append (ys ∘ rev) (xs ∘ rev) (cast (Nat.add_comm ..) i) 
Arguments: {m n : ℕ} {α : Type u_1} (xs : Fin m → α) (ys : Fin n → α) (i : Fin (m + n))
Goal: Fin.append xs ys i.rev = Fin.append (ys ∘ Fin.rev) (xs ∘ Fin.rev) (Fin.cast ⋯ i)
-- Fin.append_comp_rev
lemma append_comp_rev {m n} {α : Type*} (xs : Fin m → α) (ys : Fin n → α) :
    append xs ys ∘ rev = append (ys ∘ rev) (xs ∘ rev) ∘ cast (Nat.add_comm ..) 
Arguments: {m n : ℕ} {α : Type u_1} (xs : Fin m → α) (ys : Fin n → α)
Goal: Fin.append xs ys ∘ Fin.rev = Fin.append (ys ∘ Fin.rev) (xs ∘ Fin.rev) ∘ Fin.cast ⋯
-- Fin.repeat_apply
@[simp]
theorem repeat_apply {α : Type*} (a : Fin n → α) (i : Fin (m * n)) :
    Fin.repeat m a i = a i.modNat 
Arguments: {m n : ℕ} {α : Type u_1} (a : Fin n → α) (i : Fin (m * n))
Goal: Fin.repeat m a i = a i.modNat
-- Fin.repeat_zero
@[simp]
theorem repeat_zero {α : Type*} (a : Fin n → α) :
    Fin.repeat 0 a = Fin.elim0 ∘ cast (Nat.zero_mul _) 
Arguments: {n : ℕ} {α : Type u_1} (a : Fin n → α)
Goal: Fin.repeat 0 a = Fin.elim0 ∘ Fin.cast ⋯
-- Fin.repeat_one
@[simp]
theorem repeat_one {α : Type*} (a : Fin n → α) : Fin.repeat 1 a = a ∘ cast (Nat.one_mul _) 
Arguments: {n : ℕ} {α : Type u_1} (a : Fin n → α)
Goal: Fin.repeat 1 a = a ∘ Fin.cast ⋯
-- Fin.repeat_succ
theorem repeat_succ {α : Type*} (a : Fin n → α) (m : ℕ) :
    Fin.repeat m.succ a =
      append a (Fin.repeat m a) ∘ cast ((Nat.succ_mul _ _).trans (Nat.add_comm ..)) 
Arguments: {n : ℕ} {α : Type u_1} (a : Fin n → α) (m : ℕ)
Goal: Fin.repeat m.succ a = Fin.append a (Fin.repeat m a) ∘ Fin.cast ⋯
-- Fin.repeat_add
@[simp]
theorem repeat_add {α : Type*} (a : Fin n → α) (m₁ m₂ : ℕ) : Fin.repeat (m₁ + m₂) a =
    append (Fin.repeat m₁ a) (Fin.repeat m₂ a) ∘ cast (Nat.add_mul ..) 
Arguments: {n : ℕ} {α : Type u_1} (a : Fin n → α) (m₁ m₂ : ℕ)
Goal: Fin.repeat (m₁ + m₂) a = Fin.append (Fin.repeat m₁ a) (Fin.repeat m₂ a) ∘ Fin.cast ⋯
-- Fin.repeat_rev
theorem repeat_rev {α : Type*} (a : Fin n → α) (k : Fin (m * n)) :
    Fin.repeat m a k.rev = Fin.repeat m (a ∘ Fin.rev) k 
Arguments: {m n : ℕ} {α : Type u_1} (a : Fin n → α) (k : Fin (m * n))
Goal: Fin.repeat m a k.rev = Fin.repeat m (a ∘ Fin.rev) k
-- Fin.repeat_comp_rev
theorem repeat_comp_rev {α} (a : Fin n → α) :
    Fin.repeat m a ∘ Fin.rev = Fin.repeat m (a ∘ Fin.rev) 
Arguments: {m n : ℕ} {α : Type u_1} (a : Fin n → α)
Goal: Fin.repeat m a ∘ Fin.rev = Fin.repeat m (a ∘ Fin.rev)
-- Fin.init_def
theorem init_def {n : ℕ} {α : Fin (n + 1) → Type*} {q : ∀ i, α i} :
    (init fun k : Fin (n + 1) ↦ q k) = fun k : Fin n ↦ q (castSucc k) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {q : (i : Fin (n + 1)) → α i}
Goal: (Fin.init fun k => q k) = fun k => q k.castSucc
-- Fin.init_snoc
@[simp]
theorem init_snoc : init (snoc p x) = p 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α i.castSucc)
Goal: Fin.init (Fin.snoc p x) = p
-- Fin.snoc_castSucc
@[simp]
theorem snoc_castSucc : snoc p x (castSucc i) = p i 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α i.castSucc) (i : Fin n)
Goal: Fin.snoc p x i.castSucc = p i
-- Fin.snoc_comp_castSucc
@[simp]
theorem snoc_comp_castSucc {n : ℕ} {α : Sort _} {a : α} {f : Fin n → α} :
    (snoc f a : Fin (n + 1) → α) ∘ castSucc = f 
Arguments: {n : ℕ} {α : Type u_1} {a : α} {f : Fin n → α}
Goal: Fin.snoc f a ∘ Fin.castSucc = f
-- Fin.snoc_last
@[simp]
theorem snoc_last : snoc p x (last n) = x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α i.castSucc)
Goal: Fin.snoc p x (Fin.last n) = x
-- Fin.snoc_zero
lemma snoc_zero {α : Type*} (p : Fin 0 → α) (x : α) :
    Fin.snoc p x = fun _ ↦ x 
Arguments: {α : Type u_1} (p : Fin 0 → α) (x : α)
Goal: Fin.snoc p x = fun x_1 => x
-- Fin.snoc_comp_nat_add
@[simp]
theorem snoc_comp_nat_add {n m : ℕ} {α : Sort _} (f : Fin (m + n) → α) (a : α) :
    (snoc f a : Fin _ → α) ∘ (natAdd m : Fin (n + 1) → Fin (m + n + 1)) =
      snoc (f ∘ natAdd m) a 
Arguments: {n m : ℕ} {α : Type u_1} (f : Fin (m + n) → α) (a : α)
Goal: Fin.snoc f a ∘ Fin.natAdd m = Fin.snoc (f ∘ Fin.natAdd m) a
-- Fin.snoc_cast_add
@[simp]
theorem snoc_cast_add {α : Fin (n + m + 1) → Type*} (f : ∀ i : Fin (n + m), α (castSucc i))
    (a : α (last (n + m))) (i : Fin n) : (snoc f a) (castAdd (m + 1) i) = f (castAdd m i) 
Arguments: {m n : ℕ} {α : Fin (n + m + 1) → Type u_1} (f : (i : Fin (n + m)) → α i.castSucc) (a : α (Fin.last (n + m))) (i : Fin n)
Goal: Fin.snoc f a (Fin.castAdd (m + 1) i) = f (Fin.castAdd m i)
-- Fin.snoc_comp_cast_add
@[simp]
theorem snoc_comp_cast_add {n m : ℕ} {α : Sort _} (f : Fin (n + m) → α) (a : α) :
    (snoc f a : Fin _ → α) ∘ castAdd (m + 1) = f ∘ castAdd m 
Arguments: {n m : ℕ} {α : Type u_1} (f : Fin (n + m) → α) (a : α)
Goal: Fin.snoc f a ∘ Fin.castAdd (m + 1) = f ∘ Fin.castAdd m
-- Fin.snoc_update
@[simp]
theorem snoc_update : snoc (update p i y) x = update (snoc p x) (castSucc i) y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α i.castSucc) (i : Fin n) (y : α i.castSucc)
Goal: Fin.snoc (Function.update p i y) x = Function.update (Fin.snoc p x) i.castSucc y
-- Fin.update_snoc_last
theorem update_snoc_last : update (snoc p x) (last n) z = snoc p z 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α i.castSucc) (z : α (Fin.last n))
Goal: Function.update (Fin.snoc p x) (Fin.last n) z = Fin.snoc p z
-- Fin.snoc_init_self
@[simp]
theorem snoc_init_self : snoc (init q) (q (last n)) = q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i)
Goal: Fin.snoc (Fin.init q) (q (Fin.last n)) = q
-- Fin.init_update_last
@[simp]
theorem init_update_last : init (update q (last n) z) = init q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i) (z : α (Fin.last n))
Goal: Fin.init (Function.update q (Fin.last n) z) = Fin.init q
-- Fin.init_update_castSucc
@[simp]
theorem init_update_castSucc : init (update q (castSucc i) y) = update (init q) i y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i) (i : Fin n) (y : α i.castSucc)
Goal: Fin.init (Function.update q i.castSucc y) = Function.update (Fin.init q) i y
-- Fin.tail_init_eq_init_tail
theorem tail_init_eq_init_tail {β : Type*} (q : Fin (n + 2) → β) :
    tail (init q) = init (tail q) 
Arguments: {n : ℕ} {β : Type u_1} (q : Fin (n + 2) → β)
Goal: Fin.tail (Fin.init q) = Fin.init (Fin.tail q)
-- Fin.cons_snoc_eq_snoc_cons
theorem cons_snoc_eq_snoc_cons {β : Type*} (a : β) (q : Fin n → β) (b : β) :
    @cons n.succ (fun _ ↦ β) a (snoc q b) = snoc (cons a q) b 
Arguments: {n : ℕ} {β : Type u_1} (a : β) (q : Fin n → β) (b : β)
Goal: Fin.cons a (Fin.snoc q b) = Fin.snoc (Fin.cons a q) b
-- Fin.comp_snoc
theorem comp_snoc {α : Type*} {β : Type*} (g : α → β) (q : Fin n → α) (y : α) :
    g ∘ snoc q y = snoc (g ∘ q) (g y) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (g : α → β) (q : Fin n → α) (y : α)
Goal: g ∘ Fin.snoc q y = Fin.snoc (g ∘ q) (g y)
-- Fin.append_right_eq_snoc
theorem append_right_eq_snoc {α : Type*} {n : ℕ} (x : Fin n → α) (x₀ : Fin 1 → α) :
    Fin.append x x₀ = Fin.snoc x (x₀ 0) 
Arguments: {α : Type u_1} {n : ℕ} (x : Fin n → α) (x₀ : Fin 1 → α)
Goal: Fin.append x x₀ = Fin.snoc x (x₀ 0)
-- Fin.snoc_eq_append
theorem snoc_eq_append {α : Type*} (xs : Fin n → α) (x : α) :
    snoc xs x = append xs (cons x Fin.elim0) 
Arguments: {n : ℕ} {α : Type u_1} (xs : Fin n → α) (x : α)
Goal: Fin.snoc xs x = Fin.append xs (Fin.cons x Fin.elim0)
-- Fin.append_left_snoc
theorem append_left_snoc {n m} {α : Type*} (xs : Fin n → α) (x : α) (ys : Fin m → α) :
    Fin.append (Fin.snoc xs x) ys =
      Fin.append xs (Fin.cons x ys) ∘ Fin.cast (Nat.succ_add_eq_add_succ ..) 
Arguments: {n m : ℕ} {α : Type u_1} (xs : Fin n → α) (x : α) (ys : Fin m → α)
Goal: Fin.append (Fin.snoc xs x) ys = Fin.append xs (Fin.cons x ys) ∘ Fin.cast ⋯
-- Fin.append_right_cons
theorem append_right_cons {n m} {α : Type*} (xs : Fin n → α) (y : α) (ys : Fin m → α) :
    Fin.append xs (Fin.cons y ys) =
      Fin.append (Fin.snoc xs y) ys ∘ Fin.cast (Nat.succ_add_eq_add_succ ..).symm 
Arguments: {n m : ℕ} {α : Type u_1} (xs : Fin n → α) (y : α) (ys : Fin m → α)
Goal: Fin.append xs (Fin.cons y ys) = Fin.append (Fin.snoc xs y) ys ∘ Fin.cast ⋯
-- Fin.append_cons
theorem append_cons {α} (a : α) (as : Fin n → α) (bs : Fin m → α) :
    Fin.append (cons a as) bs
    = cons a (Fin.append as bs) ∘ (Fin.cast <| Nat.add_right_comm n 1 m) 
Arguments: {m n : ℕ} {α : Type u_1} (a : α) (as : Fin n → α) (bs : Fin m → α)
Goal: Fin.append (Fin.cons a as) bs = Fin.cons a (Fin.append as bs) ∘ Fin.cast ⋯
-- Fin.append_snoc
theorem append_snoc {α} (as : Fin n → α) (bs : Fin m → α) (b : α) :
    Fin.append as (snoc bs b) = snoc (Fin.append as bs) b 
Arguments: {m n : ℕ} {α : Type u_1} (as : Fin n → α) (bs : Fin m → α) (b : α)
Goal: Fin.append as (Fin.snoc bs b) = Fin.snoc (Fin.append as bs) b
-- Fin.comp_init
theorem comp_init {α : Type*} {β : Type*} (g : α → β) (q : Fin n.succ → α) :
    g ∘ init q = init (g ∘ q) 
Arguments: {n : ℕ} {α : Type u_1} {β : Type u_2} (g : α → β) (q : Fin n.succ → α)
Goal: g ∘ Fin.init q = Fin.init (g ∘ q)
-- Fin.snocCases_snoc
@[simp] lemma snocCases_snoc
    {P : (∀ i : Fin (n+1), α i) → Sort*} (h : ∀ x x₀, P (Fin.snoc x x₀))
    (x : ∀ i : Fin n, (Fin.init α) i) (x₀ : α (Fin.last _)) :
    snocCases h (Fin.snoc x x₀) = h x x₀ 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {P : ((i : Fin (n + 1)) → α i) → Sort u_1} (h : (x : (i : Fin n) → α i.castSucc) → (x₀ : α (Fin.last n)) → P (Fin.snoc x x₀)) (x : (i : Fin n) → Fin.init α i) (x₀ : α (Fin.last n))
Goal: Fin.snocCases h (Fin.snoc x x₀) = h x x₀
-- Fin.forall_iff_succAbove
theorem forall_iff_succAbove {p : Fin (n + 1) → Prop} (i : Fin (n + 1)) :
    (∀ j, p j) ↔ p i ∧ ∀ j, p (i.succAbove j) 
Arguments: {n : ℕ} {p : Fin (n + 1) → Prop} (i : Fin (n + 1))
Goal: (∀ (j : Fin (n + 1)), p j) ↔ p i ∧ ∀ (j : Fin n), p (i.succAbove j)
-- Fin.insertNth_apply_same
@[simp]
theorem insertNth_apply_same (i : Fin (n + 1)) (x : α i) (p : ∀ j, α (i.succAbove j)) :
    insertNth i x p i = x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (i : Fin (n + 1)) (x : α i) (p : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth x p i = x
-- Fin.insertNth_apply_succAbove
@[simp]
theorem insertNth_apply_succAbove (i : Fin (n + 1)) (x : α i) (p : ∀ j, α (i.succAbove j))
    (j : Fin n) : insertNth i x p (i.succAbove j) = p j 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (i : Fin (n + 1)) (x : α i) (p : (j : Fin n) → α (i.succAbove j)) (j : Fin n)
Goal: i.insertNth x p (i.succAbove j) = p j
-- Fin.succAbove_cases_eq_insertNth
@[simp]
theorem succAbove_cases_eq_insertNth : @succAboveCases.{u + 1} = @insertNth.{u} 
Goal: @Fin.succAboveCases = @Fin.insertNth
-- Fin.removeNth_insertNth
@[simp] lemma removeNth_insertNth (p : Fin (n + 1)) (a : α p) (f : ∀ i, α (succAbove p i)) :
    removeNth p (insertNth p a f) = f 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (p : Fin (n + 1)) (a : α p) (f : (i : Fin n) → α (p.succAbove i))
Goal: p.removeNth (p.insertNth a f) = f
-- Fin.removeNth_zero
@[simp] lemma removeNth_zero (f : ∀ i, α i) : removeNth 0 f = tail f 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (f : (i : Fin (n + 1)) → α i)
Goal: Fin.removeNth 0 f = Fin.tail f
-- Fin.removeNth_last
@[simp] lemma removeNth_last {α : Type*} (f : Fin (n + 1) → α) : removeNth (last n) f = init f 
Arguments: {n : ℕ} {α : Type u_1} (f : Fin (n + 1) → α)
Goal: (Fin.last n).removeNth f = Fin.init f
-- Fin.insertNth_comp_succAbove
@[simp]
theorem insertNth_comp_succAbove (i : Fin (n + 1)) (x : β) (p : Fin n → β) :
    insertNth i x p ∘ i.succAbove = p 
Arguments: {n : ℕ} {β : Type v} (i : Fin (n + 1)) (x : β) (p : Fin n → β)
Goal: i.insertNth x p ∘ i.succAbove = p
-- Fin.insertNth_eq_iff
theorem insertNth_eq_iff {p : Fin (n + 1)} {a : α p} {f : ∀ i, α (p.succAbove i)} {g : ∀ j, α j} :
    insertNth p a f = g ↔ a = g p ∧ f = removeNth p g 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {p : Fin (n + 1)} {a : α p} {f : (i : Fin n) → α (p.succAbove i)} {g : (j : Fin (n + 1)) → α j}
Goal: p.insertNth a f = g ↔ a = g p ∧ f = p.removeNth g
-- Fin.eq_insertNth_iff
theorem eq_insertNth_iff {p : Fin (n + 1)} {a : α p} {f : ∀ i, α (p.succAbove i)} {g : ∀ j, α j} :
    g = insertNth p a f ↔ g p = a ∧ removeNth p g = f 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {p : Fin (n + 1)} {a : α p} {f : (i : Fin n) → α (p.succAbove i)} {g : (j : Fin (n + 1)) → α j}
Goal: g = p.insertNth a f ↔ g p = a ∧ p.removeNth g = f
-- Fin.insertNth_apply_below
theorem insertNth_apply_below {i j : Fin (n + 1)} (h : j < i) (x : α i)
    (p : ∀ k, α (i.succAbove k)) :
    i.insertNth x p j = @Eq.recOn _ _ (fun x _ ↦ α x) _
    (succAbove_castPred_of_lt _ _ h) (p <| j.castPred _) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {i j : Fin (n + 1)} (h : j < i) (x : α i) (p : (k : Fin n) → α (i.succAbove k))
Goal: i.insertNth x p j = Eq.recOn ⋯ (p (j.castPred ⋯))
-- Fin.insertNth_apply_above
theorem insertNth_apply_above {i j : Fin (n + 1)} (h : i < j) (x : α i)
    (p : ∀ k, α (i.succAbove k)) :
    i.insertNth x p j = @Eq.recOn _ _ (fun x _ ↦ α x) _
    (succAbove_pred_of_lt _ _ h) (p <| j.pred _) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {i j : Fin (n + 1)} (h : i < j) (x : α i) (p : (k : Fin n) → α (i.succAbove k))
Goal: i.insertNth x p j = Eq.recOn ⋯ (p (j.pred ⋯))
-- Fin.insertNth_zero
theorem insertNth_zero (x : α 0) (p : ∀ j : Fin n, α (succAbove 0 j)) :
    insertNth 0 x p =
      cons x fun j ↦ _root_.cast (congr_arg α (congr_fun succAbove_zero j)) (p j) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (j : Fin n) → α (Fin.succAbove 0 j))
Goal: Fin.insertNth 0 x p = Fin.cons x fun j => cast ⋯ (p j)
-- Fin.insertNth_zero'
@[simp]
theorem insertNth_zero' (x : β) (p : Fin n → β) : @insertNth _ (fun _ ↦ β) 0 x p = cons x p 
Arguments: {n : ℕ} {β : Type v} (x : β) (p : Fin n → β)
Goal: Fin.insertNth 0 x p = Fin.cons x p
-- Fin.insertNth_last
theorem insertNth_last (x : α (last n)) (p : ∀ j : Fin n, α ((last n).succAbove j)) :
    insertNth (last n) x p =
      snoc (fun j ↦ _root_.cast (congr_arg α (succAbove_last_apply j)) (p j)) x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (j : Fin n) → α ((Fin.last n).succAbove j))
Goal: (Fin.last n).insertNth x p = Fin.snoc (fun j => cast ⋯ (p j)) x
-- Fin.insertNth_last'
@[simp]
theorem insertNth_last' (x : β) (p : Fin n → β) :
    @insertNth _ (fun _ ↦ β) (last n) x p = snoc p x 
Arguments: {n : ℕ} {β : Type v} (x : β) (p : Fin n → β)
Goal: (Fin.last n).insertNth x p = Fin.snoc p x
-- Fin.insertNth_rev
lemma insertNth_rev {α : Type*} (i : Fin (n + 1)) (a : α) (f : Fin n → α) (j : Fin (n + 1)) :
    insertNth (α := fun _ ↦ α) i a f (rev j) = insertNth (α := fun _ ↦ α) i.rev a (f ∘ rev) j 
Arguments: {n : ℕ} {α : Type u_1} (i : Fin (n + 1)) (a : α) (f : Fin n → α) (j : Fin (n + 1))
Goal: i.insertNth a f j.rev = i.rev.insertNth a (f ∘ Fin.rev) j
-- Fin.insertNth_comp_rev
theorem insertNth_comp_rev {α} (i : Fin (n + 1)) (x : α) (p : Fin n → α) :
    (Fin.insertNth i x p) ∘ Fin.rev = Fin.insertNth (Fin.rev i) x (p ∘ Fin.rev) 
Arguments: {n : ℕ} {α : Type u_1} (i : Fin (n + 1)) (x : α) (p : Fin n → α)
Goal: i.insertNth x p ∘ Fin.rev = i.rev.insertNth x (p ∘ Fin.rev)
-- Fin.cons_rev
theorem cons_rev {α n} (a : α) (f : Fin n → α) (i : Fin <| n + 1) :
    cons (α := fun _ => α) a f i.rev = snoc (α := fun _ => α) (f ∘ Fin.rev : Fin _ → α) a i 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (f : Fin n → α) (i : Fin (n + 1))
Goal: Fin.cons a f i.rev = Fin.snoc (f ∘ Fin.rev) a i
-- Fin.cons_comp_rev
theorem cons_comp_rev {α n} (a : α) (f : Fin n → α) :
    Fin.cons a f ∘ Fin.rev = Fin.snoc (f ∘ Fin.rev) a 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (f : Fin n → α)
Goal: Fin.cons a f ∘ Fin.rev = Fin.snoc (f ∘ Fin.rev) a
-- Fin.snoc_rev
theorem snoc_rev {α n} (a : α) (f : Fin n → α) (i : Fin <| n + 1) :
    snoc (α := fun _ => α) f a i.rev = cons (α := fun _ => α) a (f ∘ Fin.rev : Fin _ → α) i 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (f : Fin n → α) (i : Fin (n + 1))
Goal: Fin.snoc f a i.rev = Fin.cons a (f ∘ Fin.rev) i
-- Fin.snoc_comp_rev
theorem snoc_comp_rev {α n} (a : α) (f : Fin n → α) :
    Fin.snoc f a ∘ Fin.rev = Fin.cons a (f ∘ Fin.rev) 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (f : Fin n → α)
Goal: Fin.snoc f a ∘ Fin.rev = Fin.cons a (f ∘ Fin.rev)
-- Fin.insertNth_binop
theorem insertNth_binop (op : ∀ j, α j → α j → α j) (i : Fin (n + 1)) (x y : α i)
    (p q : ∀ j, α (i.succAbove j)) :
    (i.insertNth (op i x y) fun j ↦ op _ (p j) (q j)) = fun j ↦
      op j (i.insertNth x p j) (i.insertNth y q j) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (op : (j : Fin (n + 1)) → α j → α j → α j) (i : Fin (n + 1)) (x y : α i) (p q : (j : Fin n) → α (i.succAbove j))
Goal: (i.insertNth (op i x y) fun j => op (i.succAbove j) (p j) (q j)) = fun j => op j (i.insertNth x p j) (i.insertNth y q j)
-- Fin.insertNth_le_iff
theorem insertNth_le_iff {i : Fin (n + 1)} {x : α i} {p : ∀ j, α (i.succAbove j)} {q : ∀ j, α j} :
    i.insertNth x p ≤ q ↔ x ≤ q i ∧ p ≤ fun j ↦ q (i.succAbove j) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} [(i : Fin (n + 1)) → Preorder (α i)] {i : Fin (n + 1)} {x : α i} {p : (j : Fin n) → α (i.succAbove j)} {q : (j : Fin (n + 1)) → α j}
Goal: i.insertNth x p ≤ q ↔ x ≤ q i ∧ p ≤ fun j => q (i.succAbove j)