ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Linear.0.Nat.Linear.eq_of_not_blt_eq_true
private theorem eq_of_not_blt_eq_true (h₁ : ¬ (Nat.blt x y = true)) (h₂ : ¬ (Nat.blt y x = true)) : x = y 
Arguments: {x y : Nat} (h₁ : ¬x.blt y = true) (h₂ : ¬y.blt x = true)
Goal: x = y
-- Nat.Linear.Poly.denote_eq_cancelAux
theorem Poly.denote_eq_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_eq ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_eq ctx (cancelAux fuel m₁ m₂ r₁ r₂) 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly) (h : Nat.Linear.Poly.denote_eq ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂))
Goal: Nat.Linear.Poly.denote_eq ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂)
-- Nat.Linear.Poly.of_denote_eq_cancelAux
theorem Poly.of_denote_eq_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_eq ctx (cancelAux fuel m₁ m₂ r₁ r₂)) : denote_eq ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂) 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly) (h : Nat.Linear.Poly.denote_eq ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂))
Goal: Nat.Linear.Poly.denote_eq ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
-- Nat.Linear.Poly.denote_eq_cancel
theorem Poly.denote_eq_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_eq ctx (m₁, m₂)) : denote_eq ctx (cancel m₁ m₂) 
Arguments: {ctx : Nat.Linear.Context} {m₁ m₂ : Nat.Linear.Poly} (h : Nat.Linear.Poly.denote_eq ctx (m₁, m₂))
Goal: Nat.Linear.Poly.denote_eq ctx (m₁.cancel m₂)
-- Nat.Linear.Poly.of_denote_eq_cancel
theorem Poly.of_denote_eq_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_eq ctx (cancel m₁ m₂)) : denote_eq ctx (m₁, m₂) 
Arguments: {ctx : Nat.Linear.Context} {m₁ m₂ : Nat.Linear.Poly} (h : Nat.Linear.Poly.denote_eq ctx (m₁.cancel m₂))
Goal: Nat.Linear.Poly.denote_eq ctx (m₁, m₂)
-- Nat.Linear.Poly.denote_eq_cancel_eq
theorem Poly.denote_eq_cancel_eq (ctx : Context) (m₁ m₂ : Poly) : denote_eq ctx (cancel m₁ m₂) = denote_eq ctx (m₁, m₂) 
Arguments: (ctx : Nat.Linear.Context) (m₁ m₂ : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote_eq ctx (m₁.cancel m₂) = Nat.Linear.Poly.denote_eq ctx (m₁, m₂)
-- Nat.Linear.Poly.denote_le_cancelAux
theorem Poly.denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂) 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly) (h : Nat.Linear.Poly.denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂))
Goal: Nat.Linear.Poly.denote_le ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂)
-- Nat.Linear.Poly.of_denote_le_cancelAux
theorem Poly.of_denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)) : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂) 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly) (h : Nat.Linear.Poly.denote_le ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂))
Goal: Nat.Linear.Poly.denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
-- Nat.Linear.Poly.denote_le_cancel
theorem Poly.denote_le_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_le ctx (m₁, m₂)) : denote_le ctx (cancel m₁ m₂) 
Arguments: {ctx : Nat.Linear.Context} {m₁ m₂ : Nat.Linear.Poly} (h : Nat.Linear.Poly.denote_le ctx (m₁, m₂))
Goal: Nat.Linear.Poly.denote_le ctx (m₁.cancel m₂)
-- Nat.Linear.Poly.of_denote_le_cancel
theorem Poly.of_denote_le_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_le ctx (cancel m₁ m₂)) : denote_le ctx (m₁, m₂) 
Arguments: {ctx : Nat.Linear.Context} {m₁ m₂ : Nat.Linear.Poly} (h : Nat.Linear.Poly.denote_le ctx (m₁.cancel m₂))
Goal: Nat.Linear.Poly.denote_le ctx (m₁, m₂)
-- Nat.Linear.Poly.denote_le_cancel_eq
theorem Poly.denote_le_cancel_eq (ctx : Context) (m₁ m₂ : Poly) : denote_le ctx (cancel m₁ m₂) = denote_le ctx (m₁, m₂) 
Arguments: (ctx : Nat.Linear.Context) (m₁ m₂ : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote_le ctx (m₁.cancel m₂) = Nat.Linear.Poly.denote_le ctx (m₁, m₂)
-- Nat.Linear.Poly.denote_combineAux
theorem Poly.denote_combineAux (ctx : Context) (fuel : Nat) (p₁ p₂ : Poly) : (p₁.combineAux fuel p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (p₁ p₂ : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.combineAux fuel p₁ p₂) =
  Nat.Linear.Poly.denote ctx p₁ + Nat.Linear.Poly.denote ctx p₂
-- Nat.Linear.Poly.denote_combine
theorem Poly.denote_combine (ctx : Context) (p₁ p₂ : Poly) : (p₁.combine p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (p₁.combine p₂) = Nat.Linear.Poly.denote ctx p₁ + Nat.Linear.Poly.denote ctx p₂
-- Nat.Linear.Expr.denote_toPoly
theorem Expr.denote_toPoly (ctx : Context) (e : Expr) : e.toPoly.denote ctx = e.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (e : Nat.Linear.Expr)
Goal: Nat.Linear.Poly.denote ctx e.toPoly = Nat.Linear.Expr.denote ctx e
-- Nat.Linear.Expr.eq_of_toNormPoly
theorem Expr.eq_of_toNormPoly (ctx : Context) (a b : Expr) (h : a.toNormPoly = b.toNormPoly) : a.denote ctx = b.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (a b : Nat.Linear.Expr) (h : a.toNormPoly = b.toNormPoly)
Goal: Nat.Linear.Expr.denote ctx a = Nat.Linear.Expr.denote ctx b
-- Nat.Linear.Expr.of_cancel_eq
theorem Expr.of_cancel_eq (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.toNormPoly b.toNormPoly = (c.toPoly, d.toPoly)) : (a.denote ctx = b.denote ctx) = (c.denote ctx = d.denote ctx) 
Arguments: (ctx : Nat.Linear.Context) (a b c d : Nat.Linear.Expr) (h : a.toNormPoly.cancel b.toNormPoly = (c.toPoly, d.toPoly))
Goal: (Nat.Linear.Expr.denote ctx a = Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c = Nat.Linear.Expr.denote ctx d)
-- Nat.Linear.Expr.of_cancel_le
theorem Expr.of_cancel_le (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.toNormPoly b.toNormPoly = (c.toPoly, d.toPoly)) : (a.denote ctx ≤ b.denote ctx) = (c.denote ctx ≤ d.denote ctx) 
Arguments: (ctx : Nat.Linear.Context) (a b c d : Nat.Linear.Expr) (h : a.toNormPoly.cancel b.toNormPoly = (c.toPoly, d.toPoly))
Goal: (Nat.Linear.Expr.denote ctx a ≤ Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c ≤ Nat.Linear.Expr.denote ctx d)
-- Nat.Linear.Expr.of_cancel_lt
theorem Expr.of_cancel_lt (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.inc.toNormPoly b.toNormPoly = (c.inc.toPoly, d.toPoly)) : (a.denote ctx < b.denote ctx) = (c.denote ctx < d.denote ctx) 
Arguments: (ctx : Nat.Linear.Context) (a b c d : Nat.Linear.Expr) (h : a.inc.toNormPoly.cancel b.toNormPoly = (c.inc.toPoly, d.toPoly))
Goal: (Nat.Linear.Expr.denote ctx a < Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c < Nat.Linear.Expr.denote ctx d)
-- Nat.Linear.ExprCnstr.toPoly_norm_eq
theorem ExprCnstr.toPoly_norm_eq (c : ExprCnstr) : c.toPoly.norm = c.toNormPoly 
Arguments: (c : Nat.Linear.ExprCnstr)
Goal: c.toPoly.norm = c.toNormPoly
-- Nat.Linear.ExprCnstr.denote_toPoly
theorem ExprCnstr.denote_toPoly (ctx : Context) (c : ExprCnstr) : c.toPoly.denote ctx = c.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr)
Goal: Nat.Linear.PolyCnstr.denote ctx c.toPoly = Nat.Linear.ExprCnstr.denote ctx c
-- Nat.Linear.ExprCnstr.denote_toNormPoly
theorem ExprCnstr.denote_toNormPoly (ctx : Context) (c : ExprCnstr) : c.toNormPoly.denote ctx = c.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr)
Goal: Nat.Linear.PolyCnstr.denote ctx c.toNormPoly = Nat.Linear.ExprCnstr.denote ctx c
-- Nat.Linear.Poly.mul.go_denote
theorem Poly.mul.go_denote (ctx : Context) (k : Nat) (p : Poly) : (Poly.mul.go k p).denote ctx = k * p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.mul.go k p) = k * Nat.Linear.Poly.denote ctx p
-- Nat.Linear.PolyCnstr.denote_mul
theorem PolyCnstr.denote_mul (ctx : Context) (k : Nat) (c : PolyCnstr) : (c.mul (k+1)).denote ctx = c.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (c : Nat.Linear.PolyCnstr)
Goal: Nat.Linear.PolyCnstr.denote ctx (Nat.Linear.PolyCnstr.mul (k + 1) c) = Nat.Linear.PolyCnstr.denote ctx c
-- Nat.Linear.PolyCnstr.denote_combine
theorem PolyCnstr.denote_combine {ctx : Context} {c₁ c₂ : PolyCnstr} (h₁ : c₁.denote ctx) (h₂ : c₂.denote ctx) : (c₁.combine c₂).denote ctx 
Arguments: {ctx : Nat.Linear.Context} {c₁ c₂ : Nat.Linear.PolyCnstr} (h₁ : Nat.Linear.PolyCnstr.denote ctx c₁) (h₂ : Nat.Linear.PolyCnstr.denote ctx c₂)
Goal: Nat.Linear.PolyCnstr.denote ctx (c₁.combine c₂)
-- Nat.Linear.Poly.isNum?_eq_some
theorem Poly.isNum?_eq_some (ctx : Context) {p : Poly} {k : Nat} : p.isNum? = some k → p.denote ctx = k 
Arguments: (ctx : Nat.Linear.Context) {p : Nat.Linear.Poly} {k : Nat}
Goal: p.isNum? = some k → Nat.Linear.Poly.denote ctx p = k
-- Nat.Linear.Poly.of_isZero
theorem Poly.of_isZero (ctx : Context) {p : Poly} (h : isZero p = true) : p.denote ctx = 0 
Arguments: (ctx : Nat.Linear.Context) {p : Nat.Linear.Poly} (h : p.isZero = true)
Goal: Nat.Linear.Poly.denote ctx p = 0
-- Nat.Linear.Poly.of_isNonZero
theorem Poly.of_isNonZero (ctx : Context) {p : Poly} (h : isNonZero p = true) : p.denote ctx > 0 
Arguments: (ctx : Nat.Linear.Context) {p : Nat.Linear.Poly} (h : p.isNonZero = true)
Goal: Nat.Linear.Poly.denote ctx p > 0
-- Nat.Linear.PolyCnstr.eq_false_of_isUnsat
theorem PolyCnstr.eq_false_of_isUnsat (ctx : Context) {c : PolyCnstr} : c.isUnsat → c.denote ctx = False 
Arguments: (ctx : Nat.Linear.Context) {c : Nat.Linear.PolyCnstr}
Goal: c.isUnsat = true → Nat.Linear.PolyCnstr.denote ctx c = False
-- Nat.Linear.PolyCnstr.eq_true_of_isValid
theorem PolyCnstr.eq_true_of_isValid (ctx : Context) {c : PolyCnstr} : c.isValid → c.denote ctx = True 
Arguments: (ctx : Nat.Linear.Context) {c : Nat.Linear.PolyCnstr}
Goal: c.isValid = true → Nat.Linear.PolyCnstr.denote ctx c = True
-- Nat.Linear.ExprCnstr.eq_false_of_isUnsat
theorem ExprCnstr.eq_false_of_isUnsat (ctx : Context) (c : ExprCnstr) (h : c.toNormPoly.isUnsat) : c.denote ctx = False 
Arguments: (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr) (h : c.toNormPoly.isUnsat = true)
Goal: Nat.Linear.ExprCnstr.denote ctx c = False
-- Nat.Linear.ExprCnstr.eq_true_of_isValid
theorem ExprCnstr.eq_true_of_isValid (ctx : Context) (c : ExprCnstr) (h : c.toNormPoly.isValid) : c.denote ctx = True 
Arguments: (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr) (h : c.toNormPoly.isValid = true)
Goal: Nat.Linear.ExprCnstr.denote ctx c = True
-- Nat.Linear.Certificate.of_combineHyps
theorem Certificate.of_combineHyps (ctx : Context) (c : PolyCnstr) (cs : Certificate) (h : (combineHyps c cs).denote ctx → False) : c.denote ctx → cs.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (c : Nat.Linear.PolyCnstr) (cs : Nat.Linear.Certificate) (h : Nat.Linear.PolyCnstr.denote ctx (Nat.Linear.Certificate.combineHyps c cs) → False)
Goal: Nat.Linear.PolyCnstr.denote ctx c → Nat.Linear.Certificate.denote ctx cs
-- Nat.Linear.Certificate.of_combine
theorem Certificate.of_combine (ctx : Context) (cs : Certificate) (h : cs.combine.denote ctx → False) : cs.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (cs : Nat.Linear.Certificate) (h : Nat.Linear.PolyCnstr.denote ctx cs.combine → False)
Goal: Nat.Linear.Certificate.denote ctx cs
-- Nat.Linear.Certificate.of_combine_isUnsat
theorem Certificate.of_combine_isUnsat (ctx : Context) (cs : Certificate) (h : cs.combine.isUnsat) : cs.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (cs : Nat.Linear.Certificate) (h : cs.combine.isUnsat = true)
Goal: Nat.Linear.Certificate.denote ctx cs
-- Nat.Linear.denote_monomialToExpr
theorem denote_monomialToExpr (ctx : Context) (k : Nat) (v : Var) : (monomialToExpr k v).denote ctx = k * v.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (v : Nat.Linear.Var)
Goal: Nat.Linear.Expr.denote ctx (Nat.Linear.monomialToExpr k v) = k * Nat.Linear.Var.denote ctx v
-- Nat.Linear.Poly.denote_toExpr_go
theorem Poly.denote_toExpr_go (ctx : Context) (e : Expr) (p : Poly) : (toExpr.go e p).denote ctx = e.denote ctx + p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (e : Nat.Linear.Expr) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Expr.denote ctx (Nat.Linear.Poly.toExpr.go e p) = Nat.Linear.Expr.denote ctx e + Nat.Linear.Poly.denote ctx p
-- Nat.Linear.Poly.denote_toExpr
theorem Poly.denote_toExpr (ctx : Context) (p : Poly) : p.toExpr.denote ctx = p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Expr.denote ctx p.toExpr = Nat.Linear.Poly.denote ctx p
-- Nat.Linear.ExprCnstr.eq_of_toNormPoly_eq
theorem ExprCnstr.eq_of_toNormPoly_eq (ctx : Context) (c d : ExprCnstr) (h : c.toNormPoly == d.toPoly) : c.denote ctx = d.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (c d : Nat.Linear.ExprCnstr) (h : (c.toNormPoly == d.toPoly) = true)
Goal: Nat.Linear.ExprCnstr.denote ctx c = Nat.Linear.ExprCnstr.denote ctx d
-- Nat.Linear.Expr.eq_of_toNormPoly_eq
theorem Expr.eq_of_toNormPoly_eq (ctx : Context) (e e' : Expr) (h : e.toNormPoly == e'.toPoly) : e.denote ctx = e'.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (e e' : Nat.Linear.Expr) (h : (e.toNormPoly == e'.toPoly) = true)
Goal: Nat.Linear.Expr.denote ctx e = Nat.Linear.Expr.denote ctx e'
-- List.cons_ne_nil
theorem cons_ne_nil (a : α) (l : List α) : a :: l ≠ [] 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: a :: l ≠ []
-- List.cons_ne_self
@[simp]
theorem cons_ne_self (a : α) (l : List α) : a :: l ≠ l 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: a :: l ≠ l
-- List.head_eq_of_cons_eq
theorem head_eq_of_cons_eq (H : h₁ :: t₁ = h₂ :: t₂) : h₁ = h₂ 
Goal: ∀ {α : Type u_1} {h₁ : α} {t₁ : List α} {h₂ : α} {t₂ : List α}, h₁ :: t₁ = h₂ :: t₂ → h₁ = h₂
-- List.tail_eq_of_cons_eq
theorem tail_eq_of_cons_eq (H : h₁ :: t₁ = h₂ :: t₂) : t₁ = t₂ 
Goal: ∀ {α : Type u_1} {h₁ : α} {t₁ : List α} {h₂ : α} {t₂ : List α}, h₁ :: t₁ = h₂ :: t₂ → t₁ = t₂
-- List.cons_inj_right
theorem cons_inj_right (a : α) {l l' : List α} : a :: l = a :: l' ↔ l = l' 
Arguments: {α : Type u_1} (a : α) {l l' : List α}
Goal: a :: l = a :: l' ↔ l = l'
-- List.cons_eq_cons
theorem cons_eq_cons {a b : α} {l l' : List α} : a :: l = b :: l' ↔ a = b ∧ l = l' 
Arguments: {α : Type u_1} {a b : α} {l l' : List α}
Goal: a :: l = b :: l' ↔ a = b ∧ l = l'
-- List.exists_cons_of_ne_nil
theorem exists_cons_of_ne_nil : ∀ {l : List α}, l ≠ [] → ∃ b L, l = b :: L
  
Arguments: {α : Type u_1} {l : List α}
Goal: l ≠ [] → ∃ b L, l = b :: L
-- List.eq_nil_of_length_eq_zero
theorem eq_nil_of_length_eq_zero (_ : length l = 0) : l = [] 
Goal: ∀ {α : Type u_1} {l : List α}, l.length = 0 → l = []
-- List.ne_nil_of_length_eq_add_one
theorem ne_nil_of_length_eq_add_one (_ : length l = n + 1) : l ≠ [] 
Goal: ∀ {α : Type u_1} {l : List α} {n : Nat}, l.length = n + 1 → l ≠ []
-- List.length_eq_zero
@[simp] theorem length_eq_zero : length l = 0 ↔ l = [] 
Goal: ∀ {α : Type u_1} {l : List α}, l.length = 0 ↔ l = []
-- List.length_pos_of_mem
theorem length_pos_of_mem {a : α} : ∀ {l : List α}, a ∈ l → 0 < length l
  
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: a ∈ l → 0 < l.length
-- List.exists_mem_of_length_pos
theorem exists_mem_of_length_pos : ∀ {l : List α}, 0 < length l → ∃ a, a ∈ l
  
Arguments: {α : Type u_1} {l : List α}
Goal: 0 < l.length → ∃ a, a ∈ l
-- List.length_pos_iff_exists_mem
theorem length_pos_iff_exists_mem {l : List α} : 0 < length l ↔ ∃ a, a ∈ l 
Arguments: {α : Type u_1} {l : List α}
Goal: 0 < l.length ↔ ∃ a, a ∈ l
-- List.exists_cons_of_length_pos
theorem exists_cons_of_length_pos : ∀ {l : List α}, 0 < l.length → ∃ h t, l = h :: t
  
Arguments: {α : Type u_1} {l : List α}
Goal: 0 < l.length → ∃ h t, l = h :: t
-- List.length_pos_iff_exists_cons
theorem length_pos_iff_exists_cons :
    ∀ {l : List α}, 0 < l.length ↔ ∃ h t, l = h :: t 
Arguments: {α : Type u_1} {l : List α}
Goal: 0 < l.length ↔ ∃ h t, l = h :: t
-- List.exists_cons_of_length_eq_add_one
theorem exists_cons_of_length_eq_add_one :
    ∀ {l : List α}, l.length = n + 1 → ∃ h t, l = h :: t
  
Arguments: {α : Type u_1} {n : Nat} {l : List α}
Goal: l.length = n + 1 → ∃ h t, l = h :: t
-- List.length_pos
theorem length_pos {l : List α} : 0 < length l ↔ l ≠ [] 
Arguments: {α : Type u_1} {l : List α}
Goal: 0 < l.length ↔ l ≠ []
-- List.length_eq_one
theorem length_eq_one {l : List α} : length l = 1 ↔ ∃ a, l = [a] 
Arguments: {α : Type u_1} {l : List α}
Goal: l.length = 1 ↔ ∃ a, l = [a]
-- List.get_cons_zero
@[simp] theorem get_cons_zero : get (a::l) (0 : Fin (l.length + 1)) = a 
Goal: ∀ {α : Type u_1} {a : α} {l : List α}, (a :: l).get 0 = a
-- List.get_cons_succ
@[simp] theorem get_cons_succ {as : List α} {h : i + 1 < (a :: as).length} :
  (a :: as).get ⟨i+1, h⟩ = as.get ⟨i, Nat.lt_of_succ_lt_succ h⟩ 
Arguments: {α : Type u_1} {i : Nat} {a : α} {as : List α} {h : i + 1 < (a :: as).length}
Goal: (a :: as).get ⟨i + 1, h⟩ = as.get ⟨i, ⋯⟩
-- List.get_cons_succ'
@[simp] theorem get_cons_succ' {as : List α} {i : Fin as.length} :
  (a :: as).get i.succ = as.get i 
Arguments: {α : Type u_1} {a : α} {as : List α} {i : Fin as.length}
Goal: (a :: as).get i.succ = as.get i
-- List.get?_len_le
theorem get?_len_le : ∀ {l : List α} {n}, length l ≤ n → l.get? n = none
  
Arguments: {α : Type u_1} {l : List α} {n : Nat}
Goal: l.length ≤ n → l.get? n = none
-- List.get?_eq_get
theorem get?_eq_get : ∀ {l : List α} {n} (h : n < l.length), l.get? n = some (get l ⟨n, h⟩)
  
Arguments: {α : Type u_1} {l : List α} {n : Nat} (h : n < l.length)
Goal: l.get? n = some (l.get ⟨n, h⟩)
-- List.get?_eq_some
theorem get?_eq_some : l.get? n = some a ↔ ∃ h, get l ⟨n, h⟩ = a 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {n : Nat}, l.get? n = some a ↔ ∃ h, l.get ⟨n, h⟩ = a
-- List.get?_eq_none
theorem get?_eq_none : l.get? n = none ↔ length l ≤ n 
Goal: ∀ {α : Type u_1} {l : List α} {n : Nat}, l.get? n = none ↔ l.length ≤ n
-- List.get?_eq_getElem?
@[simp] theorem get?_eq_getElem? (l : List α) (i : Nat) : l.get? i = l[i]? 
Arguments: {α : Type u_1} (l : List α) (i : Nat)
Goal: l.get? i = l[i]?
-- List.get_eq_getElem
@[simp] theorem get_eq_getElem (l : List α) (i : Fin l.length) : l.get i = l[i.1]'i.2 
Arguments: {α : Type u_1} (l : List α) (i : Fin l.length)
Goal: l.get i = l[↑i]
-- List.getElem?_nil
@[simp] theorem getElem?_nil {n : Nat} : ([] : List α)[n]? = none 
Arguments: {α : Type u_1} {n : Nat}
Goal: [][n]? = none
-- List.getElem?_cons_zero
@[simp] theorem getElem?_cons_zero {l : List α} : (a::l)[0]? = some a 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: (a :: l)[0]? = some a
-- List.getElem?_cons_succ
@[simp] theorem getElem?_cons_succ {l : List α} : (a::l)[n+1]? = l[n]? 
Arguments: {α : Type u_1} {a : α} {n : Nat} {l : List α}
Goal: (a :: l)[n + 1]? = l[n]?
-- List.getElem?_len_le
theorem getElem?_len_le : ∀ {l : List α} {n}, length l ≤ n → l[n]? = none
  
Arguments: {α : Type u_1} {l : List α} {n : Nat}
Goal: l.length ≤ n → l[n]? = none
-- List.getElem?_eq_getElem
@[simp] theorem getElem?_eq_getElem {l : List α} {n} (h : n < l.length) : l[n]? = some l[n] 
Arguments: {α : Type u_1} {l : List α} {n : Nat} (h : n < l.length)
Goal: l[n]? = some l[n]
-- List.getElem?_eq_some
theorem getElem?_eq_some {l : List α} : l[n]? = some a ↔ ∃ h : n < l.length, l[n] = a 
Arguments: {α : Type u_1} {n : Nat} {a : α} {l : List α}
Goal: l[n]? = some a ↔ ∃ h, l[n] = a
-- List.getElem?_eq_none_iff
@[simp] theorem getElem?_eq_none_iff : l[n]? = none ↔ length l ≤ n 
Goal: ∀ {α : Type u_1} {l : List α} {n : Nat}, l[n]? = none ↔ l.length ≤ n
-- List.getElem?_eq_none
theorem getElem?_eq_none (h : length l ≤ n) : l[n]? = none 
Goal: ∀ {α : Type u_1} {l : List α} {n : Nat}, l.length ≤ n → l[n]? = none
-- List.getElem!_nil
@[simp] theorem getElem!_nil [Inhabited α] {n : Nat} : ([] : List α)[n]! = default 
Arguments: {α : Type u_1} [Inhabited α] {n : Nat}
Goal: [][n]! = default
-- List.getElem!_cons_zero
@[simp] theorem getElem!_cons_zero [Inhabited α] {l : List α} : (a::l)[0]! = a 
Arguments: {α : Type u_1} {a : α} [Inhabited α] {l : List α}
Goal: (a :: l)[0]! = a
-- List.getElem!_cons_succ
@[simp] theorem getElem!_cons_succ [Inhabited α] {l : List α} : (a::l)[n+1]! = l[n]! 
Arguments: {α : Type u_1} {a : α} {n : Nat} [Inhabited α] {l : List α}
Goal: (a :: l)[n + 1]! = l[n]!
-- List.get_cons_cons_one
@[simp] theorem get_cons_cons_one : (a₁ :: a₂ :: as).get (1 : Fin (as.length + 2)) = a₂ 
Goal: ∀ {α : Type u_1} {a₁ a₂ : α} {as : List α}, (a₁ :: a₂ :: as).get 1 = a₂
-- List.get!_len_le
theorem get!_len_le [Inhabited α] : ∀ {l : List α} {n}, length l ≤ n → l.get! n = (default : α)
  
Arguments: {α : Type u_1} [Inhabited α] {l : List α} {n : Nat}
Goal: l.length ≤ n → l.get! n = default
-- List.get?_zero
theorem get?_zero (l : List α) : l.get? 0 = l.head? 
Arguments: {α : Type u_1} (l : List α)
Goal: l.get? 0 = l.head?
-- List.getElem_of_eq
theorem getElem_of_eq {l l' : List α} (h : l = l') {i : Nat} (w : i < l.length) :
    l[i] = l'[i]'(h ▸ w) 
Arguments: {α : Type u_1} {l l' : List α} (h : l = l') {i : Nat} (w : i < l.length)
Goal: l[i] = l'[i]
-- List.get_of_eq
theorem get_of_eq {l l' : List α} (h : l = l') (i : Fin l.length) :
    get l i = get l' ⟨i, h ▸ i.2⟩ 
Arguments: {α : Type u_1} {l l' : List α} (h : l = l') (i : Fin l.length)
Goal: l.get i = l'.get ⟨↑i, ⋯⟩
-- List.getElem_singleton
@[simp] theorem getElem_singleton (a : α) (h : i < 1) : [a][i] = a 
Arguments: {α : Type u_1} {i : Nat} (a : α) (h : i < 1)
Goal: [a][i] = a
-- List.get_singleton
@[deprecated getElem_singleton (since := "2024-06-12")]
theorem get_singleton (a : α) (n : Fin 1) : get [a] n = a 
Arguments: {α : Type u_1} (a : α) (n : Fin 1)
Goal: [a].get n = a
-- List.getElem_zero
theorem getElem_zero {l : List α} (h : 0 < l.length) : l[0] = l.head (length_pos.mp h) 
Arguments: {α : Type u_1} {l : List α} (h : 0 < l.length)
Goal: l[0] = l.head ⋯
-- List.get_mk_zero
theorem get_mk_zero : ∀ {l : List α} (h : 0 < l.length), l.get ⟨0, h⟩ = l.head (length_pos.mp h)
  
Arguments: {α : Type u_1} {l : List α} (h : 0 < l.length)
Goal: l.get ⟨0, h⟩ = l.head ⋯
-- List.getElem!_of_getElem?
theorem getElem!_of_getElem? [Inhabited α] : ∀ {l : List α} {n : Nat}, l[n]? = some a → l[n]! = a
  
Arguments: {α : Type u_1} {a : α} [Inhabited α] {l : List α} {n : Nat}
Goal: l[n]? = some a → l[n]! = a
-- List.get!_of_get?
theorem get!_of_get? [Inhabited α] : ∀ {l : List α} {n}, get? l n = some a → get! l n = a
  
Arguments: {α : Type u_1} {a : α} [Inhabited α] {l : List α} {n : Nat}
Goal: l.get? n = some a → l.get! n = a
-- List.get!_eq_getD
@[simp] theorem get!_eq_getD [Inhabited α] : ∀ (l : List α) n, l.get! n = l.getD n default
  
Arguments: {α : Type u_1} [Inhabited α] (l : List α) (n : Nat)
Goal: l.get! n = l.getD n default
-- List.ext_getElem?
@[ext] theorem ext_getElem? {l₁ l₂ : List α} (h : ∀ n : Nat, l₁[n]? = l₂[n]?) : l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h : ∀ (n : Nat), l₁[n]? = l₂[n]?)
Goal: l₁ = l₂
-- List.ext_getElem
theorem ext_getElem {l₁ l₂ : List α} (hl : length l₁ = length l₂)
    (h : ∀ (n : Nat) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁[n]'h₁ = l₂[n]'h₂) : l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (hl : l₁.length = l₂.length) (h : ∀ (n : Nat) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁[n] = l₂[n])
Goal: l₁ = l₂
-- List.ext_get
theorem ext_get {l₁ l₂ : List α} (hl : length l₁ = length l₂)
    (h : ∀ n h₁ h₂, get l₁ ⟨n, h₁⟩ = get l₂ ⟨n, h₂⟩) : l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (hl : l₁.length = l₂.length) (h : ∀ (n : Nat) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁.get ⟨n, h₁⟩ = l₂.get ⟨n, h₂⟩)
Goal: l₁ = l₂
-- List.getElem_concat_length
@[simp] theorem getElem_concat_length : ∀ (l : List α) (a : α) (i) (_ : i = l.length) (w), (l ++ [a])[i]'w = a
  
Arguments: {α : Type u_1} (l : List α) (a : α) (i : Nat)
Goal: i = l.length → ∀ (w : i < (l ++ [a]).length), (l ++ [a])[i] = a
-- List.getElem?_concat_length
theorem getElem?_concat_length (l : List α) (a : α) : (l ++ [a])[l.length]? = some a 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: (l ++ [a])[l.length]? = some a
-- List.get?_concat_length
@[deprecated getElem?_concat_length (since := "2024-06-12")]
theorem get?_concat_length (l : List α) (a : α) : (l ++ [a]).get? l.length = some a 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: (l ++ [a]).get? l.length = some a