ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgebraicGeometry.pullbackSpecIso_inv_snd
@[reassoc (attr := simp)]
lemma pullbackSpecIso_inv_snd :
    (pullbackSpecIso R S T).inv ≫ pullback.snd _ _ = Spec.map (ofHom (toRingHom includeRight)) 
Arguments: (R S T : Type u) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T]
Goal: (AlgebraicGeometry.pullbackSpecIso R S T).inv ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
      (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T))) =
  AlgebraicGeometry.Spec.map (CommRingCat.ofHom ↑Algebra.TensorProduct.includeRight)
-- AlgebraicGeometry.pullbackSpecIso_hom_fst
@[reassoc (attr := simp)]
lemma pullbackSpecIso_hom_fst :
    (pullbackSpecIso R S T).hom ≫ Spec.map (ofHom includeLeftRingHom) = pullback.fst _ _ 
Arguments: (R S T : Type u) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T]
Goal: (AlgebraicGeometry.pullbackSpecIso R S T).hom ≫
    AlgebraicGeometry.Spec.map (CommRingCat.ofHom Algebra.TensorProduct.includeLeftRingHom) =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
    (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T)))
-- AlgebraicGeometry.pullbackSpecIso_hom_snd
@[reassoc (attr := simp)]
lemma pullbackSpecIso_hom_snd :
    (pullbackSpecIso R S T).hom ≫ Spec.map (ofHom (toRingHom includeRight)) = pullback.snd _ _ 
Arguments: (R S T : Type u) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T]
Goal: (AlgebraicGeometry.pullbackSpecIso R S T).hom ≫
    AlgebraicGeometry.Spec.map (CommRingCat.ofHom ↑Algebra.TensorProduct.includeRight) =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
    (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T)))
-- Levenshtein.defaultCost_substitute
@[simps]
def defaultCost [DecidableEq α] : Cost α α ℕ 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α)
Goal: Levenshtein.defaultCost.substitute a b = if a = b then 0 else 1
-- Levenshtein.defaultCost_delete
@[simps]
def defaultCost [DecidableEq α] : Cost α α ℕ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: ∀ (x : α), Levenshtein.defaultCost.delete x = 1
-- Levenshtein.defaultCost_insert
@[simps]
def defaultCost [DecidableEq α] : Cost α α ℕ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: ∀ (x : α), Levenshtein.defaultCost.insert x = 1
-- Levenshtein.weightCost_delete
@[simps]
def weightCost (f : α → ℕ) : Cost α α ℕ 
Arguments: {α : Type u_1} (f : α → ℕ) (a : α)
Goal: (Levenshtein.weightCost f).delete a = f a
-- Levenshtein.weightCost_substitute
@[simps]
def weightCost (f : α → ℕ) : Cost α α ℕ 
Arguments: {α : Type u_1} (f : α → ℕ) (a b : α)
Goal: (Levenshtein.weightCost f).substitute a b = max (f a) (f b)
-- Levenshtein.weightCost_insert
@[simps]
def weightCost (f : α → ℕ) : Cost α α ℕ 
Arguments: {α : Type u_1} (f : α → ℕ) (b : α)
Goal: (Levenshtein.weightCost f).insert b = f b
-- Levenshtein.stringLengthCost_insert
@[simps!]
def stringLengthCost : Cost String String ℕ 
Arguments: (b : String)
Goal: Levenshtein.stringLengthCost.insert b = b.length
-- Levenshtein.stringLengthCost_delete
@[simps!]
def stringLengthCost : Cost String String ℕ 
Arguments: (a : String)
Goal: Levenshtein.stringLengthCost.delete a = a.length
-- Levenshtein.stringLengthCost_substitute
@[simps!]
def stringLengthCost : Cost String String ℕ 
Arguments: (a b : String)
Goal: Levenshtein.stringLengthCost.substitute a b = max a.length b.length
-- Levenshtein.stringLogLengthCost_insert
@[simps!]
def stringLogLengthCost : Cost String String ℕ 
Arguments: (b : String)
Goal: Levenshtein.stringLogLengthCost.insert b = (b.length + 1).log2
-- Levenshtein.stringLogLengthCost_substitute
@[simps!]
def stringLogLengthCost : Cost String String ℕ 
Arguments: (a b : String)
Goal: Levenshtein.stringLogLengthCost.substitute a b = max (a.length + 1).log2 (b.length + 1).log2
-- Levenshtein.stringLogLengthCost_delete
@[simps!]
def stringLogLengthCost : Cost String String ℕ 
Arguments: (a : String)
Goal: Levenshtein.stringLogLengthCost.delete a = (a.length + 1).log2
-- Levenshtein.impl_cons
theorem impl_cons (w' : 0 < List.length ds) :
    impl C (x :: xs) y ⟨d :: ds, w⟩ =
      let ⟨r, w⟩ := impl C xs y ⟨ds, w'⟩
      ⟨min (C.delete x + r[0]) (min (C.insert y + d) (C.substitute x y + ds[0])) :: r, by simp⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (y : β) (d : δ) (ds : List δ) (w : 0 < (d :: ds).length) (w' : 0 < ds.length)
Goal: Levenshtein.impl C (x :: xs) y ⟨d :: ds, w⟩ =
  match Levenshtein.impl C xs y ⟨ds, w'⟩ with
  | ⟨r, w⟩ => ⟨min (C.delete x + r[0]) (min (C.insert y + d) (C.substitute x y + ds[0])) :: r, ⋯⟩
-- Levenshtein.impl_cons_fst_zero
theorem impl_cons_fst_zero (h : 0 < (impl C (x :: xs) y ⟨d :: ds, w⟩).val.length)
    (w' : 0 < List.length ds) : (impl C (x :: xs) y ⟨d :: ds, w⟩).1[0] =
      let ⟨r, w⟩ := impl C xs y ⟨ds, w'⟩
      min (C.delete x + r[0]) (min (C.insert y + d) (C.substitute x y + ds[0])) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (y : β) (d : δ) (ds : List δ) (w : 0 < (d :: ds).length) (h : 0 < (Levenshtein.impl C (x :: xs) y ⟨d :: ds, w⟩).val.length) (w' : 0 < ds.length)
Goal: (Levenshtein.impl C (x :: xs) y ⟨d :: ds, w⟩).val[0] =
  match Levenshtein.impl C xs y ⟨ds, w'⟩ with
  | ⟨r, w⟩ => min (C.delete x + r[0]) (min (C.insert y + d) (C.substitute x y + ds[0]))
-- Levenshtein.impl_length
theorem impl_length (d : {r : List δ // 0 < r.length}) (w : d.1.length = xs.length + 1) :
    (impl C xs y d).1.length = xs.length + 1 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (xs : List α) (y : β) (d : { r // 0 < r.length }) (w : d.val.length = xs.length + 1)
Goal: (Levenshtein.impl C xs y d).val.length = xs.length + 1
-- suffixLevenshtein_length
theorem suffixLevenshtein_length (xs : List α) (ys : List β) :
    (suffixLevenshtein C xs ys).1.length = xs.length + 1 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (xs : List α) (ys : List β)
Goal: (suffixLevenshtein C xs ys).val.length = xs.length + 1
-- suffixLevenshtein_eq
theorem suffixLevenshtein_eq (xs : List α) (y ys) :
    impl C xs y (suffixLevenshtein C xs ys) = suffixLevenshtein C xs (y :: ys) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (xs : List α) (y : β) (ys : List β)
Goal: Levenshtein.impl C xs y (suffixLevenshtein C xs ys) = suffixLevenshtein C xs (y :: ys)
-- suffixLevenshtein_nil_nil
theorem suffixLevenshtein_nil_nil : (suffixLevenshtein C [] []).1 = [0] 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ}
Goal: (suffixLevenshtein C [] []).val = [0]
-- List.eq_of_length_one
theorem List.eq_of_length_one (x : List α) (w : x.length = 1) :
    have : 0 < x.length := lt_of_lt_of_eq Nat.zero_lt_one w.symm
    x = [x[0]] 
Arguments: {α : Type u_1} (x : List α) (w : x.length = 1)
Goal: let_fun this := ⋯;
x = [x[0]]
-- suffixLevenshtein_nil'
theorem suffixLevenshtein_nil' (ys : List β) :
    (suffixLevenshtein C [] ys).1 = [levenshtein C [] ys] 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (ys : List β)
Goal: (suffixLevenshtein C [] ys).val = [levenshtein C [] ys]
-- suffixLevenshtein_cons₂
theorem suffixLevenshtein_cons₂ (xs : List α) (y ys) :
    suffixLevenshtein C xs (y :: ys) = (impl C xs) y (suffixLevenshtein C xs ys) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (xs : List α) (y : β) (ys : List β)
Goal: suffixLevenshtein C xs (y :: ys) = Levenshtein.impl C xs y (suffixLevenshtein C xs ys)
-- suffixLevenshtein_cons₁_aux
theorem suffixLevenshtein_cons₁_aux {x y : {r : List δ // 0 < r.length}}
    (w₀ : x.1[0]'x.2 = y.1[0]'y.2) (w : x.1.tail = y.1.tail) : x = y 
Arguments: {δ : Type u_3} {x y : { r // 0 < r.length }} (w₀ : x.val[0] = y.val[0]) (w : x.val.tail = y.val.tail)
Goal: x = y
-- suffixLevenshtein_cons₁
theorem suffixLevenshtein_cons₁
    (x : α) (xs ys) :
    suffixLevenshtein C (x :: xs) ys =
      ⟨levenshtein C (x :: xs) ys ::
        (suffixLevenshtein C xs ys).1, by simp⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (ys : List β)
Goal: suffixLevenshtein C (x :: xs) ys = ⟨levenshtein C (x :: xs) ys :: (suffixLevenshtein C xs ys).val, ⋯⟩
-- suffixLevenshtein_cons₁_fst
theorem suffixLevenshtein_cons₁_fst (x : α) (xs ys) :
    (suffixLevenshtein C (x :: xs) ys).1 =
      levenshtein C (x :: xs) ys ::
        (suffixLevenshtein C xs ys).1 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (ys : List β)
Goal: (suffixLevenshtein C (x :: xs) ys).val = levenshtein C (x :: xs) ys :: (suffixLevenshtein C xs ys).val
-- suffixLevenshtein_cons_cons_fst_get_zero
theorem suffixLevenshtein_cons_cons_fst_get_zero
    (x : α) (xs y ys) (w : 0 < (suffixLevenshtein C (x :: xs) (y :: ys)).val.length) :
    (suffixLevenshtein C (x :: xs) (y :: ys)).1[0]'w =
      let ⟨dx, _⟩ := suffixLevenshtein C xs (y :: ys)
      let ⟨dy, _⟩ := suffixLevenshtein C (x :: xs) ys
      let ⟨dxy, _⟩ := suffixLevenshtein C xs ys
      min
        (C.delete x + dx[0])
        (min
          (C.insert y + dy[0])
          (C.substitute x y + dxy[0])) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (y : β) (ys : List β) (w : 0 < (suffixLevenshtein C (x :: xs) (y :: ys)).val.length)
Goal: (suffixLevenshtein C (x :: xs) (y :: ys)).val[0] =
  match suffixLevenshtein C xs (y :: ys) with
  | ⟨dx, property⟩ =>
    match suffixLevenshtein C (x :: xs) ys with
    | ⟨dy, property_1⟩ =>
      match suffixLevenshtein C xs ys with
      | ⟨dxy, property_2⟩ => min (C.delete x + dx[0]) (min (C.insert y + dy[0]) (C.substitute x y + dxy[0]))
-- suffixLevenshtein_eq_tails_map
theorem suffixLevenshtein_eq_tails_map (xs ys) :
    (suffixLevenshtein C xs ys).1 = xs.tails.map fun xs' => levenshtein C xs' ys 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (xs : List α) (ys : List β)
Goal: (suffixLevenshtein C xs ys).val = List.map (fun xs' => levenshtein C xs' ys) xs.tails
-- levenshtein_nil_nil
@[simp]
theorem levenshtein_nil_nil : levenshtein C [] [] = 0 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ}
Goal: levenshtein C [] [] = 0
-- levenshtein_nil_cons
@[simp]
theorem levenshtein_nil_cons (y) (ys) :
    levenshtein C [] (y :: ys) = C.insert y + levenshtein C [] ys 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (y : β) (ys : List β)
Goal: levenshtein C [] (y :: ys) = C.insert y + levenshtein C [] ys
-- levenshtein_cons_nil
@[simp]
theorem levenshtein_cons_nil (x : α) (xs : List α) :
    levenshtein C (x :: xs) [] = C.delete x + levenshtein C xs [] 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α)
Goal: levenshtein C (x :: xs) [] = C.delete x + levenshtein C xs []
-- levenshtein_cons_cons
@[simp]
theorem levenshtein_cons_cons
    (x : α) (xs : List α) (y : β) (ys : List β) :
    levenshtein C (x :: xs) (y :: ys) =
      min (C.delete x + levenshtein C xs (y :: ys))
        (min (C.insert y + levenshtein C (x :: xs) ys)
          (C.substitute x y + levenshtein C xs ys)) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} [AddZeroClass δ] [Min δ] {C : Levenshtein.Cost α β δ} (x : α) (xs : List α) (y : β) (ys : List β)
Goal: levenshtein C (x :: xs) (y :: ys) =
  min (C.delete x + levenshtein C xs (y :: ys))
    (min (C.insert y + levenshtein C (x :: xs) ys) (C.substitute x y + levenshtein C xs ys))
-- suffixLevenshtein_minimum_le_levenshtein_cons
theorem suffixLevenshtein_minimum_le_levenshtein_cons (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ levenshtein C xs (y :: ys) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (y : β) (ys : List β)
Goal: (↑(suffixLevenshtein C xs ys)).minimum ≤ ↑(levenshtein C xs (y :: ys))
-- le_suffixLevenshtein_cons_minimum
theorem le_suffixLevenshtein_cons_minimum (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ (suffixLevenshtein C xs (y :: ys)).1.minimum 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (y : β) (ys : List β)
Goal: (↑(suffixLevenshtein C xs ys)).minimum ≤ (↑(suffixLevenshtein C xs (y :: ys))).minimum
-- le_suffixLevenshtein_append_minimum
theorem le_suffixLevenshtein_append_minimum (xs : List α) (ys₁ ys₂) :
    (suffixLevenshtein C xs ys₂).1.minimum ≤ (suffixLevenshtein C xs (ys₁ ++ ys₂)).1.minimum 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (ys₁ ys₂ : List β)
Goal: (↑(suffixLevenshtein C xs ys₂)).minimum ≤ (↑(suffixLevenshtein C xs (ys₁ ++ ys₂))).minimum
-- suffixLevenshtein_minimum_le_levenshtein_append
theorem suffixLevenshtein_minimum_le_levenshtein_append (xs ys₁ ys₂) :
    (suffixLevenshtein C xs ys₂).1.minimum ≤ levenshtein C xs (ys₁ ++ ys₂) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (ys₁ ys₂ : List β)
Goal: (↑(suffixLevenshtein C xs ys₂)).minimum ≤ ↑(levenshtein C xs (ys₁ ++ ys₂))
-- le_levenshtein_cons
theorem le_levenshtein_cons (xs : List α) (y ys) :
    ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (y : β) (ys : List β)
Goal: ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys)
-- le_levenshtein_append
theorem le_levenshtein_append (xs : List α) (ys₁ ys₂) :
    ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys₂ ≤ levenshtein C xs (ys₁ ++ ys₂) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} {C : Levenshtein.Cost α β δ} [CanonicallyLinearOrderedAddCommMonoid δ] (xs : List α) (ys₁ ys₂ : List β)
Goal: ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys₂ ≤ levenshtein C xs (ys₁ ++ ys₂)
-- List.foldl_argAux_eq_none
@[simp]
theorem foldl_argAux_eq_none : l.foldl (argAux r) o = none ↔ l = [] ∧ o = none 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] {l : List α} {o : Option α}
Goal: List.foldl (List.argAux r) o l = none ↔ l = [] ∧ o = none
-- _private.Mathlib.Data.List.MinMax.0.List.foldl_argAux_mem
private theorem foldl_argAux_mem (l) : ∀ a m : α, m ∈ foldl (argAux r) (some a) l → m ∈ a :: l 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] (l : List α) (a m : α)
Goal: m ∈ List.foldl (List.argAux r) (some a) l → m ∈ a :: l
-- List.argAux_self
@[simp]
theorem argAux_self (hr₀ : Irreflexive r) (a : α) : argAux r (some a) a = a 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] (hr₀ : Irreflexive r) (a : α)
Goal: List.argAux r (some a) a = some a
-- List.not_of_mem_foldl_argAux
theorem not_of_mem_foldl_argAux (hr₀ : Irreflexive r) (hr₁ : Transitive r) :
    ∀ {a m : α} {o : Option α}, a ∈ l → m ∈ foldl (argAux r) o l → ¬r a m 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] {l : List α} (hr₀ : Irreflexive r) (hr₁ : Transitive r) {a m : α} {o : Option α}
Goal: a ∈ l → m ∈ List.foldl (List.argAux r) o l → ¬r a m
-- List.argmax_nil
@[simp]
theorem argmax_nil (f : α → β) : argmax f [] = none 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] (f : α → β)
Goal: List.argmax f [] = none
-- List.argmin_nil
@[simp]
theorem argmin_nil (f : α → β) : argmin f [] = none 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] (f : α → β)
Goal: List.argmin f [] = none
-- List.argmax_singleton
@[simp]
theorem argmax_singleton {f : α → β} {a : α} : argmax f [a] = a 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {a : α}
Goal: List.argmax f [a] = some a
-- List.argmin_singleton
@[simp]
theorem argmin_singleton {f : α → β} {a : α} : argmin f [a] = a 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {a : α}
Goal: List.argmin f [a] = some a
-- List.not_lt_of_mem_argmax
theorem not_lt_of_mem_argmax : a ∈ l → m ∈ argmax f l → ¬f m < f a 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α} {a m : α}
Goal: a ∈ l → m ∈ List.argmax f l → ¬f m < f a
-- List.not_lt_of_mem_argmin
theorem not_lt_of_mem_argmin : a ∈ l → m ∈ argmin f l → ¬f a < f m 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α} {a m : α}
Goal: a ∈ l → m ∈ List.argmin f l → ¬f a < f m
-- List.argmax_concat
theorem argmax_concat (f : α → β) (a : α) (l : List α) :
    argmax f (l ++ [a]) =
      Option.casesOn (argmax f l) (some a) fun c => if f c < f a then some a else some c 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] (f : α → β) (a : α) (l : List α)
Goal: List.argmax f (l ++ [a]) = Option.casesOn (List.argmax f l) (some a) fun c => if f c < f a then some a else some c
-- List.argmin_concat
theorem argmin_concat (f : α → β) (a : α) (l : List α) :
    argmin f (l ++ [a]) =
      Option.casesOn (argmin f l) (some a) fun c => if f a < f c then some a else some c 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] (f : α → β) (a : α) (l : List α)
Goal: List.argmin f (l ++ [a]) = Option.casesOn (List.argmin f l) (some a) fun c => if f a < f c then some a else some c
-- List.argmax_mem
theorem argmax_mem : ∀ {l : List α} {m : α}, m ∈ argmax f l → m ∈ l
  
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α} {m : α}
Goal: m ∈ List.argmax f l → m ∈ l
-- List.argmin_mem
theorem argmin_mem : ∀ {l : List α} {m : α}, m ∈ argmin f l → m ∈ l 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α} {m : α}
Goal: m ∈ List.argmin f l → m ∈ l
-- List.argmax_eq_none
@[simp]
theorem argmax_eq_none : l.argmax f = none ↔ l = [] 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α}
Goal: List.argmax f l = none ↔ l = []
-- List.argmin_eq_none
@[simp]
theorem argmin_eq_none : l.argmin f = none ↔ l = [] 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [DecidableRel fun x x_1 => x < x_1] {f : α → β} {l : List α}
Goal: List.argmin f l = none ↔ l = []
-- List.le_of_mem_argmax
theorem le_of_mem_argmax : a ∈ l → m ∈ argmax f l → f a ≤ f m 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {a m : α}
Goal: a ∈ l → m ∈ List.argmax f l → f a ≤ f m
-- List.le_of_mem_argmin
theorem le_of_mem_argmin : a ∈ l → m ∈ argmin f l → f m ≤ f a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {a m : α}
Goal: a ∈ l → m ∈ List.argmin f l → f m ≤ f a
-- List.argmax_cons
theorem argmax_cons (f : α → β) (a : α) (l : List α) :
    argmax f (a :: l) =
      Option.casesOn (argmax f l) (some a) fun c => if f a < f c then some c else some a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] (f : α → β) (a : α) (l : List α)
Goal: List.argmax f (a :: l) = Option.casesOn (List.argmax f l) (some a) fun c => if f a < f c then some c else some a
-- List.argmin_cons
theorem argmin_cons (f : α → β) (a : α) (l : List α) :
    argmin f (a :: l) =
      Option.casesOn (argmin f l) (some a) fun c => if f c < f a then some c else some a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] (f : α → β) (a : α) (l : List α)
Goal: List.argmin f (a :: l) = Option.casesOn (List.argmin f l) (some a) fun c => if f c < f a then some c else some a
-- List.index_of_argmax
theorem index_of_argmax :
    ∀ {l : List α} {m : α}, m ∈ argmax f l → ∀ {a}, a ∈ l → f m ≤ f a → l.indexOf m ≤ l.indexOf a
  
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} [DecidableEq α] {l : List α} {m : α}
Goal: m ∈ List.argmax f l → ∀ {a : α}, a ∈ l → f m ≤ f a → List.indexOf m l ≤ List.indexOf a l
-- List.index_of_argmin
theorem index_of_argmin :
    ∀ {l : List α} {m : α}, m ∈ argmin f l → ∀ {a}, a ∈ l → f a ≤ f m → l.indexOf m ≤ l.indexOf a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} [DecidableEq α] {l : List α} {m : α}
Goal: m ∈ List.argmin f l → ∀ {a : α}, a ∈ l → f a ≤ f m → List.indexOf m l ≤ List.indexOf a l
-- List.mem_argmax_iff
theorem mem_argmax_iff :
    m ∈ argmax f l ↔
      m ∈ l ∧ (∀ a ∈ l, f a ≤ f m) ∧ ∀ a ∈ l, f m ≤ f a → l.indexOf m ≤ l.indexOf a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {m : α} [DecidableEq α]
Goal: m ∈ List.argmax f l ↔
  m ∈ l ∧ (∀ (a : α), a ∈ l → f a ≤ f m) ∧ ∀ (a : α), a ∈ l → f m ≤ f a → List.indexOf m l ≤ List.indexOf a l
-- List.argmax_eq_some_iff
theorem argmax_eq_some_iff :
    argmax f l = some m ↔
      m ∈ l ∧ (∀ a ∈ l, f a ≤ f m) ∧ ∀ a ∈ l, f m ≤ f a → l.indexOf m ≤ l.indexOf a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {m : α} [DecidableEq α]
Goal: List.argmax f l = some m ↔
  m ∈ l ∧ (∀ (a : α), a ∈ l → f a ≤ f m) ∧ ∀ (a : α), a ∈ l → f m ≤ f a → List.indexOf m l ≤ List.indexOf a l
-- List.mem_argmin_iff
theorem mem_argmin_iff :
    m ∈ argmin f l ↔
      m ∈ l ∧ (∀ a ∈ l, f m ≤ f a) ∧ ∀ a ∈ l, f a ≤ f m → l.indexOf m ≤ l.indexOf a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {m : α} [DecidableEq α]
Goal: m ∈ List.argmin f l ↔
  m ∈ l ∧ (∀ (a : α), a ∈ l → f m ≤ f a) ∧ ∀ (a : α), a ∈ l → f a ≤ f m → List.indexOf m l ≤ List.indexOf a l
-- List.argmin_eq_some_iff
theorem argmin_eq_some_iff :
    argmin f l = some m ↔
      m ∈ l ∧ (∀ a ∈ l, f m ≤ f a) ∧ ∀ a ∈ l, f a ≤ f m → l.indexOf m ≤ l.indexOf a 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : α → β} {l : List α} {m : α} [DecidableEq α]
Goal: List.argmin f l = some m ↔
  m ∈ l ∧ (∀ (a : α), a ∈ l → f m ≤ f a) ∧ ∀ (a : α), a ∈ l → f a ≤ f m → List.indexOf m l ≤ List.indexOf a l
-- List.maximum_nil
@[simp]
theorem maximum_nil : maximum ([] : List α) = ⊥ 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1]
Goal: [].maximum = ⊥
-- List.minimum_nil
@[simp]
theorem minimum_nil : minimum ([] : List α) = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1]
Goal: [].minimum = ⊤
-- List.maximum_singleton
@[simp]
theorem maximum_singleton (a : α) : maximum [a] = a 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] (a : α)
Goal: [a].maximum = ↑a
-- List.minimum_singleton
@[simp]
theorem minimum_singleton (a : α) : minimum [a] = a 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] (a : α)
Goal: [a].minimum = ↑a
-- List.maximum_mem
theorem maximum_mem {l : List α} {m : α} : (maximum l : WithTop α) = m → m ∈ l 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {m : α}
Goal: l.maximum = ↑m → m ∈ l
-- List.minimum_mem
theorem minimum_mem {l : List α} {m : α} : (minimum l : WithBot α) = m → m ∈ l 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {m : α}
Goal: l.minimum = ↑m → m ∈ l
-- List.maximum_eq_bot
@[simp]
theorem maximum_eq_bot {l : List α} : l.maximum = ⊥ ↔ l = [] 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α}
Goal: l.maximum = ⊥ ↔ l = []