ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- WeierstrassCurve.Affine.Point.map_some
lemma map_some {x y : F} (h : (W.baseChange F).toAffine.Nonsingular x y) :
    map W f (some h) = some ((W.baseChange_nonsingular f.injective ..).mpr h) 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [CommRing S] [Algebra R S] {F : Type u} [Field F] [Algebra R F] [Algebra S F] [IsScalarTower R S F] {K : Type v} [Field K] [Algebra R K] [Algebra S K] [IsScalarTower R S K] (f : F →ₐ[S] K) {x y : F} (h : (WeierstrassCurve.baseChange W F).toAffine.Nonsingular x y)
Goal: (WeierstrassCurve.Affine.Point.map W f) (WeierstrassCurve.Affine.Point.some h) = WeierstrassCurve.Affine.Point.some ⋯
-- WeierstrassCurve.Affine.Point.map_id
lemma map_id (P : W⟮F⟯) : map W (Algebra.ofId F F) P = P 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve.Affine R) {F : Type u} [Field F] [Algebra R F] (P : WeierstrassCurve.Affine.Point (WeierstrassCurve.baseChange W F))
Goal: (WeierstrassCurve.Affine.Point.map W (Algebra.ofId F F)) P = P
-- WeierstrassCurve.Affine.Point.map_map
lemma map_map (P : W⟮F⟯) : map W g (map W f P) = map W (g.comp f) P 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [CommRing S] [Algebra R S] {F : Type u} [Field F] [Algebra R F] [Algebra S F] [IsScalarTower R S F] {K : Type v} [Field K] [Algebra R K] [Algebra S K] [IsScalarTower R S K] (f : F →ₐ[S] K) {L : Type w} [Field L] [Algebra R L] [Algebra S L] [IsScalarTower R S L] (g : K →ₐ[S] L) (P : WeierstrassCurve.Affine.Point (WeierstrassCurve.baseChange W F))
Goal: (WeierstrassCurve.Affine.Point.map W g) ((WeierstrassCurve.Affine.Point.map W f) P) =
  (WeierstrassCurve.Affine.Point.map W (g.comp f)) P
-- WeierstrassCurve.Affine.Point.map_injective
lemma map_injective : Function.Injective <| map W f 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [CommRing S] [Algebra R S] {F : Type u} [Field F] [Algebra R F] [Algebra S F] [IsScalarTower R S F] {K : Type v} [Field K] [Algebra R K] [Algebra S K] [IsScalarTower R S K] (f : F →ₐ[S] K)
Goal: Function.Injective ⇑(WeierstrassCurve.Affine.Point.map W f)
-- WeierstrassCurve.Affine.Point.map_baseChange
lemma map_baseChange [Algebra F K] [IsScalarTower R F K] [Algebra F L] [IsScalarTower R F L]
    (f : K →ₐ[F] L) (P : W⟮F⟯) : map W f (baseChange W F K P) = baseChange W F L P 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve.Affine R) {F : Type u} [Field F] [Algebra R F] {K : Type v} [Field K] [Algebra R K] {L : Type w} [Field L] [Algebra R L] [Algebra F K] [IsScalarTower R F K] [Algebra F L] [IsScalarTower R F L] (f : K →ₐ[F] L) (P : WeierstrassCurve.Affine.Point (WeierstrassCurve.baseChange W F))
Goal: (WeierstrassCurve.Affine.Point.map W f) ((WeierstrassCurve.Affine.Point.baseChange W F K) P) =
  (WeierstrassCurve.Affine.Point.baseChange W F L) P
-- EllipticCurve.Affine.nonsingular
lemma nonsingular [Nontrivial R] {x y : R} (h : E.toAffine.Equation x y) :
    E.toAffine.Nonsingular x y 
Arguments: {R : Type u} [CommRing R] (E : EllipticCurve R) [Nontrivial R] {x y : R} (h : E.toAffine.Equation x y)
Goal: E.toAffine.Nonsingular x y
-- Set.Subsingleton.anti
theorem Subsingleton.anti (ht : t.Subsingleton) (hst : s ⊆ t) : s.Subsingleton 
Arguments: {α : Type u} {s t : Set α} (ht : t.Subsingleton) (hst : s ⊆ t)
Goal: s.Subsingleton
-- Set.Subsingleton.eq_singleton_of_mem
theorem Subsingleton.eq_singleton_of_mem (hs : s.Subsingleton) {x : α} (hx : x ∈ s) : s = {x} 
Arguments: {α : Type u} {s : Set α} (hs : s.Subsingleton) {x : α} (hx : x ∈ s)
Goal: s = {x}
-- Set.subsingleton_empty
@[simp]
theorem subsingleton_empty : (∅ : Set α).Subsingleton 
Arguments: {α : Type u}
Goal: ∅.Subsingleton
-- Set.subsingleton_singleton
@[simp]
theorem subsingleton_singleton {a} : ({a} : Set α).Subsingleton 
Arguments: {α : Type u} {a : α}
Goal: {a}.Subsingleton
-- Set.subsingleton_of_subset_singleton
theorem subsingleton_of_subset_singleton (h : s ⊆ {a}) : s.Subsingleton 
Arguments: {α : Type u} {a : α} {s : Set α} (h : s ⊆ {a})
Goal: s.Subsingleton
-- Set.subsingleton_of_forall_eq
theorem subsingleton_of_forall_eq (a : α) (h : ∀ b ∈ s, b = a) : s.Subsingleton 
Arguments: {α : Type u} {s : Set α} (a : α) (h : ∀ b ∈ s, b = a)
Goal: s.Subsingleton
-- Set.subsingleton_iff_singleton
theorem subsingleton_iff_singleton {x} (hx : x ∈ s) : s.Subsingleton ↔ s = {x} 
Arguments: {α : Type u} {s : Set α} {x : α} (hx : x ∈ s)
Goal: s.Subsingleton ↔ s = {x}
-- Set.Subsingleton.eq_empty_or_singleton
theorem Subsingleton.eq_empty_or_singleton (hs : s.Subsingleton) : s = ∅ ∨ ∃ x, s = {x} 
Arguments: {α : Type u} {s : Set α} (hs : s.Subsingleton)
Goal: s = ∅ ∨ ∃ x, s = {x}
-- Set.Subsingleton.induction_on
theorem Subsingleton.induction_on {p : Set α → Prop} (hs : s.Subsingleton) (he : p ∅)
    (h₁ : ∀ x, p {x}) : p s 
Arguments: {α : Type u} {s : Set α} {p : Set α → Prop} (hs : s.Subsingleton) (he : p ∅) (h₁ : ∀ (x : α), p {x})
Goal: p s
-- Set.subsingleton_univ
theorem subsingleton_univ [Subsingleton α] : (univ : Set α).Subsingleton 
Arguments: {α : Type u} [Subsingleton α]
Goal: Set.univ.Subsingleton
-- Set.subsingleton_of_univ_subsingleton
theorem subsingleton_of_univ_subsingleton (h : (univ : Set α).Subsingleton) : Subsingleton α 
Arguments: {α : Type u} (h : Set.univ.Subsingleton)
Goal: Subsingleton α
-- Set.subsingleton_univ_iff
@[simp]
theorem subsingleton_univ_iff : (univ : Set α).Subsingleton ↔ Subsingleton α 
Arguments: {α : Type u}
Goal: Set.univ.Subsingleton ↔ Subsingleton α
-- Set.Subsingleton.inter_singleton
lemma Subsingleton.inter_singleton : (s ∩ {a}).Subsingleton 
Arguments: {α : Type u} {a : α} {s : Set α}
Goal: (s ∩ {a}).Subsingleton
-- Set.Subsingleton.singleton_inter
lemma Subsingleton.singleton_inter : ({a} ∩ s).Subsingleton 
Arguments: {α : Type u} {a : α} {s : Set α}
Goal: ({a} ∩ s).Subsingleton
-- Set.subsingleton_of_subsingleton
theorem subsingleton_of_subsingleton [Subsingleton α] {s : Set α} : Set.Subsingleton s 
Arguments: {α : Type u} [Subsingleton α] {s : Set α}
Goal: s.Subsingleton
-- Set.subsingleton_isTop
theorem subsingleton_isTop (α : Type*) [PartialOrder α] : Set.Subsingleton { x : α | IsTop x } 
Arguments: (α : Type u_1) [PartialOrder α]
Goal: {x | IsTop x}.Subsingleton
-- Set.subsingleton_isBot
theorem subsingleton_isBot (α : Type*) [PartialOrder α] : Set.Subsingleton { x : α | IsBot x } 
Arguments: (α : Type u_1) [PartialOrder α]
Goal: {x | IsBot x}.Subsingleton
-- Set.exists_eq_singleton_iff_nonempty_subsingleton
theorem exists_eq_singleton_iff_nonempty_subsingleton :
    (∃ a : α, s = {a}) ↔ s.Nonempty ∧ s.Subsingleton 
Arguments: {α : Type u} {s : Set α}
Goal: (∃ a, s = {a}) ↔ s.Nonempty ∧ s.Subsingleton
-- Set.subsingleton_coe
@[simp, norm_cast]
theorem subsingleton_coe (s : Set α) : Subsingleton s ↔ s.Subsingleton 
Arguments: {α : Type u} (s : Set α)
Goal: Subsingleton ↑s ↔ s.Subsingleton
-- Set.Subsingleton.coe_sort
theorem Subsingleton.coe_sort {s : Set α} : s.Subsingleton → Subsingleton s 
Arguments: {α : Type u} {s : Set α}
Goal: s.Subsingleton → Subsingleton ↑s
-- Set.nontrivial_of_mem_mem_ne
theorem nontrivial_of_mem_mem_ne {x y} (hx : x ∈ s) (hy : y ∈ s) (hxy : x ≠ y) : s.Nontrivial 
Arguments: {α : Type u} {s : Set α} {x y : α} (hx : x ∈ s) (hy : y ∈ s) (hxy : x ≠ y)
Goal: s.Nontrivial
-- Set.Nontrivial.choose_fst_mem
protected theorem Nontrivial.choose_fst_mem (hs : s.Nontrivial) : hs.choose.fst ∈ s 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: hs.choose.1 ∈ s
-- Set.Nontrivial.choose_snd_mem
protected theorem Nontrivial.choose_snd_mem (hs : s.Nontrivial) : hs.choose.snd ∈ s 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: hs.choose.2 ∈ s
-- Set.Nontrivial.choose_fst_ne_choose_snd
protected theorem Nontrivial.choose_fst_ne_choose_snd (hs : s.Nontrivial) :
    hs.choose.fst ≠ hs.choose.snd 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: hs.choose.1 ≠ hs.choose.2
-- Set.Nontrivial.mono
theorem Nontrivial.mono (hs : s.Nontrivial) (hst : s ⊆ t) : t.Nontrivial 
Arguments: {α : Type u} {s t : Set α} (hs : s.Nontrivial) (hst : s ⊆ t)
Goal: t.Nontrivial
-- Set.nontrivial_pair
theorem nontrivial_pair {x y} (hxy : x ≠ y) : ({x, y} : Set α).Nontrivial 
Arguments: {α : Type u} {x y : α} (hxy : x ≠ y)
Goal: {x, y}.Nontrivial
-- Set.nontrivial_of_pair_subset
theorem nontrivial_of_pair_subset {x y} (hxy : x ≠ y) (h : {x, y} ⊆ s) : s.Nontrivial 
Arguments: {α : Type u} {s : Set α} {x y : α} (hxy : x ≠ y) (h : {x, y} ⊆ s)
Goal: s.Nontrivial
-- Set.Nontrivial.pair_subset
theorem Nontrivial.pair_subset (hs : s.Nontrivial) : ∃ x y, x ≠ y ∧ {x, y} ⊆ s 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: ∃ x y, x ≠ y ∧ {x, y} ⊆ s
-- Set.nontrivial_iff_pair_subset
theorem nontrivial_iff_pair_subset : s.Nontrivial ↔ ∃ x y, x ≠ y ∧ {x, y} ⊆ s 
Arguments: {α : Type u} {s : Set α}
Goal: s.Nontrivial ↔ ∃ x y, x ≠ y ∧ {x, y} ⊆ s
-- Set.nontrivial_of_exists_ne
theorem nontrivial_of_exists_ne {x} (hx : x ∈ s) (h : ∃ y ∈ s, y ≠ x) : s.Nontrivial 
Arguments: {α : Type u} {s : Set α} {x : α} (hx : x ∈ s) (h : ∃ y ∈ s, y ≠ x)
Goal: s.Nontrivial
-- Set.Nontrivial.exists_ne
theorem Nontrivial.exists_ne (hs : s.Nontrivial) (z) : ∃ x ∈ s, x ≠ z 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial) (z : α)
Goal: ∃ x ∈ s, x ≠ z
-- Set.nontrivial_iff_exists_ne
theorem nontrivial_iff_exists_ne {x} (hx : x ∈ s) : s.Nontrivial ↔ ∃ y ∈ s, y ≠ x 
Arguments: {α : Type u} {s : Set α} {x : α} (hx : x ∈ s)
Goal: s.Nontrivial ↔ ∃ y ∈ s, y ≠ x
-- Set.nontrivial_of_lt
theorem nontrivial_of_lt [Preorder α] {x y} (hx : x ∈ s) (hy : y ∈ s) (hxy : x < y) :
    s.Nontrivial 
Arguments: {α : Type u} {s : Set α} [Preorder α] {x y : α} (hx : x ∈ s) (hy : y ∈ s) (hxy : x < y)
Goal: s.Nontrivial
-- Set.nontrivial_of_exists_lt
theorem nontrivial_of_exists_lt [Preorder α]
    (H : ∃ᵉ (x ∈ s) (y ∈ s), x < y) : s.Nontrivial 
Arguments: {α : Type u} {s : Set α} [Preorder α] (H : ∃ x ∈ s, ∃ y ∈ s, x < y)
Goal: s.Nontrivial
-- Set.Nontrivial.exists_lt
theorem Nontrivial.exists_lt [LinearOrder α] (hs : s.Nontrivial) : ∃ᵉ (x ∈ s) (y ∈ s), x < y 
Arguments: {α : Type u} {s : Set α} [LinearOrder α] (hs : s.Nontrivial)
Goal: ∃ x ∈ s, ∃ y ∈ s, x < y
-- Set.nontrivial_iff_exists_lt
theorem nontrivial_iff_exists_lt [LinearOrder α] :
    s.Nontrivial ↔ ∃ᵉ (x ∈ s) (y ∈ s), x < y 
Arguments: {α : Type u} {s : Set α} [LinearOrder α]
Goal: s.Nontrivial ↔ ∃ x ∈ s, ∃ y ∈ s, x < y
-- Set.Nontrivial.nonempty
protected theorem Nontrivial.nonempty (hs : s.Nontrivial) : s.Nonempty 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: s.Nonempty
-- Set.Nontrivial.ne_empty
protected theorem Nontrivial.ne_empty (hs : s.Nontrivial) : s ≠ ∅ 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: s ≠ ∅
-- Set.Nontrivial.not_subset_empty
theorem Nontrivial.not_subset_empty (hs : s.Nontrivial) : ¬s ⊆ ∅ 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: ¬s ⊆ ∅
-- Set.not_nontrivial_empty
@[simp]
theorem not_nontrivial_empty : ¬(∅ : Set α).Nontrivial 
Arguments: {α : Type u}
Goal: ¬∅.Nontrivial
-- Set.not_nontrivial_singleton
@[simp]
theorem not_nontrivial_singleton {x} : ¬({x} : Set α).Nontrivial 
Arguments: {α : Type u} {x : α}
Goal: ¬{x}.Nontrivial
-- Set.Nontrivial.ne_singleton
theorem Nontrivial.ne_singleton {x} (hs : s.Nontrivial) : s ≠ {x} 
Arguments: {α : Type u} {s : Set α} {x : α} (hs : s.Nontrivial)
Goal: s ≠ {x}
-- Set.Nontrivial.not_subset_singleton
theorem Nontrivial.not_subset_singleton {x} (hs : s.Nontrivial) : ¬s ⊆ {x} 
Arguments: {α : Type u} {s : Set α} {x : α} (hs : s.Nontrivial)
Goal: ¬s ⊆ {x}
-- Set.nontrivial_univ
theorem nontrivial_univ [Nontrivial α] : (univ : Set α).Nontrivial 
Arguments: {α : Type u} [Nontrivial α]
Goal: Set.univ.Nontrivial
-- Set.nontrivial_of_univ_nontrivial
theorem nontrivial_of_univ_nontrivial (h : (univ : Set α).Nontrivial) : Nontrivial α 
Arguments: {α : Type u} (h : Set.univ.Nontrivial)
Goal: Nontrivial α
-- Set.nontrivial_univ_iff
@[simp]
theorem nontrivial_univ_iff : (univ : Set α).Nontrivial ↔ Nontrivial α 
Arguments: {α : Type u}
Goal: Set.univ.Nontrivial ↔ Nontrivial α
-- Set.nontrivial_of_nontrivial
theorem nontrivial_of_nontrivial (hs : s.Nontrivial) : Nontrivial α 
Arguments: {α : Type u} {s : Set α} (hs : s.Nontrivial)
Goal: Nontrivial α
-- Set.nontrivial_coe_sort
@[simp, norm_cast]
theorem nontrivial_coe_sort {s : Set α} : Nontrivial s ↔ s.Nontrivial 
Arguments: {α : Type u} {s : Set α}
Goal: Nontrivial ↑s ↔ s.Nontrivial
-- Set.nontrivial_of_nontrivial_coe
theorem nontrivial_of_nontrivial_coe (hs : Nontrivial s) : Nontrivial α 
Arguments: {α : Type u} {s : Set α} (hs : Nontrivial ↑s)
Goal: Nontrivial α
-- Set.nontrivial_mono
theorem nontrivial_mono {α : Type*} {s t : Set α} (hst : s ⊆ t) (hs : Nontrivial s) :
    Nontrivial t 
Arguments: {α : Type u_1} {s t : Set α} (hst : s ⊆ t) (hs : Nontrivial ↑s)
Goal: Nontrivial ↑t
-- Set.not_subsingleton_iff
@[simp]
theorem not_subsingleton_iff : ¬s.Subsingleton ↔ s.Nontrivial 
Arguments: {α : Type u} {s : Set α}
Goal: ¬s.Subsingleton ↔ s.Nontrivial
-- Set.not_nontrivial_iff
@[simp]
theorem not_nontrivial_iff : ¬s.Nontrivial ↔ s.Subsingleton 
Arguments: {α : Type u} {s : Set α}
Goal: ¬s.Nontrivial ↔ s.Subsingleton
-- Set.subsingleton_or_nontrivial
protected lemma subsingleton_or_nontrivial (s : Set α) : s.Subsingleton ∨ s.Nontrivial 
Arguments: {α : Type u} (s : Set α)
Goal: s.Subsingleton ∨ s.Nontrivial
-- Set.eq_singleton_or_nontrivial
lemma eq_singleton_or_nontrivial (ha : a ∈ s) : s = {a} ∨ s.Nontrivial 
Arguments: {α : Type u} {a : α} {s : Set α} (ha : a ∈ s)
Goal: s = {a} ∨ s.Nontrivial
-- Set.nontrivial_iff_ne_singleton
lemma nontrivial_iff_ne_singleton (ha : a ∈ s) : s.Nontrivial ↔ s ≠ {a} 
Arguments: {α : Type u} {a : α} {s : Set α} (ha : a ∈ s)
Goal: s.Nontrivial ↔ s ≠ {a}
-- Set.Nonempty.exists_eq_singleton_or_nontrivial
lemma Nonempty.exists_eq_singleton_or_nontrivial : s.Nonempty → (∃ a, s = {a}) ∨ s.Nontrivial 
Arguments: {α : Type u} {s : Set α}
Goal: s.Nonempty → (∃ a, s = {a}) ∨ s.Nontrivial
-- Set.univ_eq_true_false
theorem univ_eq_true_false : univ = ({True, False} : Set Prop) 
Goal: Set.univ = {True, False}
-- Set.Subsingleton.monotoneOn
protected theorem Subsingleton.monotoneOn (h : s.Subsingleton) : MonotoneOn f s 
Arguments: {α : Type u} {β : Type v} {s : Set α} [Preorder α] [Preorder β] (f : α → β) (h : s.Subsingleton)
Goal: MonotoneOn f s
-- Set.Subsingleton.antitoneOn
protected theorem Subsingleton.antitoneOn (h : s.Subsingleton) : AntitoneOn f s 
Arguments: {α : Type u} {β : Type v} {s : Set α} [Preorder α] [Preorder β] (f : α → β) (h : s.Subsingleton)
Goal: AntitoneOn f s
-- Set.Subsingleton.strictMonoOn
protected theorem Subsingleton.strictMonoOn (h : s.Subsingleton) : StrictMonoOn f s 
Arguments: {α : Type u} {β : Type v} {s : Set α} [Preorder α] [Preorder β] (f : α → β) (h : s.Subsingleton)
Goal: StrictMonoOn f s
-- Set.Subsingleton.strictAntiOn
protected theorem Subsingleton.strictAntiOn (h : s.Subsingleton) : StrictAntiOn f s 
Arguments: {α : Type u} {β : Type v} {s : Set α} [Preorder α] [Preorder β] (f : α → β) (h : s.Subsingleton)
Goal: StrictAntiOn f s
-- Set.monotoneOn_singleton
@[simp]
theorem monotoneOn_singleton : MonotoneOn f {a} 
Arguments: {α : Type u} {β : Type v} {a : α} [Preorder α] [Preorder β] (f : α → β)
Goal: MonotoneOn f {a}
-- Set.antitoneOn_singleton
@[simp]
theorem antitoneOn_singleton : AntitoneOn f {a} 
Arguments: {α : Type u} {β : Type v} {a : α} [Preorder α] [Preorder β] (f : α → β)
Goal: AntitoneOn f {a}
-- Set.strictMonoOn_singleton
@[simp]
theorem strictMonoOn_singleton : StrictMonoOn f {a} 
Arguments: {α : Type u} {β : Type v} {a : α} [Preorder α] [Preorder β] (f : α → β)
Goal: StrictMonoOn f {a}
-- Set.strictAntiOn_singleton
@[simp]
theorem strictAntiOn_singleton : StrictAntiOn f {a} 
Arguments: {α : Type u} {β : Type v} {a : α} [Preorder α] [Preorder β] (f : α → β)
Goal: StrictAntiOn f {a}
-- FiniteInter.univ_mem
structure FiniteInter : Prop where
    univ_mem : Set.univ ∈ S
    inter_mem : ∀ ⦃s⦄, s ∈ S → ∀ ⦃t⦄, t ∈ S → s ∩ t ∈ S
Arguments: {α : Type u_1} {S : Set (Set α)} (self : FiniteInter S)
Goal: Set.univ ∈ S
-- FiniteInter.inter_mem
structure FiniteInter : Prop where
    univ_mem : Set.univ ∈ S
    inter_mem : ∀ ⦃s⦄, s ∈ S → ∀ ⦃t⦄, t ∈ S → s ∩ t ∈ S
Arguments: {α : Type u_1} {S : Set (Set α)} (self : FiniteInter S) ⦃s : Set α⦄
Goal: s ∈ S → ∀ ⦃t : Set α⦄, t ∈ S → s ∩ t ∈ S
-- FiniteInter.finiteInterClosure_finiteInter
theorem finiteInterClosure_finiteInter : FiniteInter (finiteInterClosure S) 
Arguments: {α : Type u_1} (S : Set (Set α))
Goal: FiniteInter (FiniteInter.finiteInterClosure S)
-- FiniteInter.finiteInter_mem
theorem finiteInter_mem (cond : FiniteInter S) (F : Finset (Set α)) :
    ↑F ⊆ S → ⋂₀ (↑F : Set (Set α)) ∈ S 
Arguments: {α : Type u_1} {S : Set (Set α)} (cond : FiniteInter S) (F : Finset (Set α))
Goal: ↑F ⊆ S → ⋂₀ ↑F ∈ S
-- FiniteInter.finiteInterClosure_insert
theorem finiteInterClosure_insert {A : Set α} (cond : FiniteInter S) (P)
    (H : P ∈ finiteInterClosure (insert A S)) : P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q 
Arguments: {α : Type u_1} {S : Set (Set α)} {A : Set α} (cond : FiniteInter S) (P : Set α) (H : P ∈ FiniteInter.finiteInterClosure (insert A S))
Goal: P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q
-- FiniteInter.mk₂
theorem mk₂ (h: ∀ ⦃s⦄, s ∈ S → ∀ ⦃t⦄, t ∈ S → s ∩ t ∈ S) :
    FiniteInter (insert (univ : Set α) S) 
Arguments: {α : Type u_1} {S : Set (Set α)} (h : ∀ ⦃s : Set α⦄, s ∈ S → ∀ ⦃t : Set α⦄, t ∈ S → s ∩ t ∈ S)
Goal: FiniteInter (insert Set.univ S)
-- List.cons_injective
@[simp] theorem cons_injective {a : α} : Injective (cons a) 
Arguments: {α : Type u} {a : α}
Goal: Function.Injective (List.cons a)
-- List.singleton_injective
theorem singleton_injective : Injective fun a : α => [a] 
Arguments: {α : Type u}
Goal: Function.Injective fun a => [a]
-- List.singleton_inj
theorem singleton_inj {a b : α} : [a] = [b] ↔ a = b 
Arguments: {α : Type u} {a b : α}
Goal: [a] = [b] ↔ a = b
-- List.set_of_mem_cons
theorem set_of_mem_cons (l : List α) (a : α) : { x | x ∈ a :: l } = insert a { x | x ∈ l } 
Arguments: {α : Type u} (l : List α) (a : α)
Goal: {x | x ∈ a :: l} = insert a {x | x ∈ l}
-- Decidable.List.eq_or_ne_mem_of_mem
theorem _root_.Decidable.List.eq_or_ne_mem_of_mem [DecidableEq α]
    {a b : α} {l : List α} (h : a ∈ b :: l) : a = b ∨ a ≠ b ∧ a ∈ l 
Arguments: {α : Type u} [DecidableEq α] {a b : α} {l : List α} (h : a ∈ b :: l)
Goal: a = b ∨ a ≠ b ∧ a ∈ l
-- List.mem_pair
lemma mem_pair {a b c : α} : a ∈ [b, c] ↔ a = b ∨ a = c 
Arguments: {α : Type u} {a b c : α}
Goal: a ∈ [b, c] ↔ a = b ∨ a = c
-- List.mem_map_of_injective
@[simp 1100, nolint simpNF]
theorem mem_map_of_injective {f : α → β} (H : Injective f) {a : α} {l : List α} :
    f a ∈ map f l ↔ a ∈ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} (H : Function.Injective f) {a : α} {l : List α}
Goal: f a ∈ List.map f l ↔ a ∈ l
-- Function.Involutive.exists_mem_and_apply_eq_iff
@[simp]
theorem _root_.Function.Involutive.exists_mem_and_apply_eq_iff {f : α → α}
    (hf : Function.Involutive f) (x : α) (l : List α) : (∃ y : α, y ∈ l ∧ f y = x) ↔ f x ∈ l 
Arguments: {α : Type u} {f : α → α} (hf : Function.Involutive f) (x : α) (l : List α)
Goal: (∃ y, y ∈ l ∧ f y = x) ↔ f x ∈ l
-- List.mem_map_of_involutive
theorem mem_map_of_involutive {f : α → α} (hf : Involutive f) {a : α} {l : List α} :
    a ∈ map f l ↔ f a ∈ l 
Arguments: {α : Type u} {f : α → α} (hf : Function.Involutive f) {a : α} {l : List α}
Goal: a ∈ List.map f l ↔ f a ∈ l
-- List.length_pos_iff_ne_nil
theorem length_pos_iff_ne_nil {l : List α} : 0 < length l ↔ l ≠ [] 
Arguments: {α : Type u} {l : List α}
Goal: 0 < l.length ↔ l ≠ []
-- List.exists_of_length_succ
theorem exists_of_length_succ {n} : ∀ l : List α, l.length = n + 1 → ∃ h t, l = h :: t
  
Arguments: {α : Type u} {n : ℕ} (l : List α)
Goal: l.length = n + 1 → ∃ h t, l = h :: t
-- List.length_injective_iff
@[simp] lemma length_injective_iff : Injective (List.length : List α → ℕ) ↔ Subsingleton α 
Arguments: {α : Type u}
Goal: Function.Injective List.length ↔ Subsingleton α
-- List.length_injective
@[simp default+1] -- Porting note: this used to be just @[simp]
lemma length_injective [Subsingleton α] : Injective (length : List α → ℕ) 
Arguments: {α : Type u} [Subsingleton α]
Goal: Function.Injective List.length
-- List.length_eq_two
theorem length_eq_two {l : List α} : l.length = 2 ↔ ∃ a b, l = [a, b] 
Arguments: {α : Type u} {l : List α}
Goal: l.length = 2 ↔ ∃ a b, l = [a, b]
-- List.length_eq_three
theorem length_eq_three {l : List α} : l.length = 3 ↔ ∃ a b c, l = [a, b, c] 
Arguments: {α : Type u} {l : List α}
Goal: l.length = 3 ↔ ∃ a b c, l = [a, b, c]
-- List.singleton_eq
theorem singleton_eq (x : α) : ({x} : List α) = [x] 
Arguments: {α : Type u} (x : α)
Goal: {x} = [x]
-- List.insert_neg
theorem insert_neg [DecidableEq α] {x : α} {l : List α} (h : x ∉ l) :
    Insert.insert x l = x :: l 
Arguments: {α : Type u} [DecidableEq α] {x : α} {l : List α} (h : ¬x ∈ l)
Goal: insert x l = x :: l
-- List.insert_pos
theorem insert_pos [DecidableEq α] {x : α} {l : List α} (h : x ∈ l) : Insert.insert x l = l 
Arguments: {α : Type u} [DecidableEq α] {x : α} {l : List α} (h : x ∈ l)
Goal: insert x l = l
-- List.doubleton_eq
theorem doubleton_eq [DecidableEq α] {x y : α} (h : x ≠ y) : ({x, y} : List α) = [x, y] 
Arguments: {α : Type u} [DecidableEq α] {x y : α} (h : x ≠ y)
Goal: {x, y} = [x, y]
-- List.forall_mem_of_forall_mem_cons
theorem forall_mem_of_forall_mem_cons {p : α → Prop} {a : α} {l : List α} (h : ∀ x ∈ a :: l, p x) :
    ∀ x ∈ l, p x 
Arguments: {α : Type u} {p : α → Prop} {a : α} {l : List α} (h : ∀ (x : α), x ∈ a :: l → p x) (x : α)
Goal: x ∈ l → p x
-- List.exists_mem_cons_of
theorem exists_mem_cons_of {p : α → Prop} {a : α} (l : List α) (h : p a) : ∃ x ∈ a :: l, p x 
Arguments: {α : Type u} {p : α → Prop} {a : α} (l : List α) (h : p a)
Goal: ∃ x, x ∈ a :: l ∧ p x
-- List.exists_mem_cons_of_exists
theorem exists_mem_cons_of_exists {p : α → Prop} {a : α} {l : List α} : (∃ x ∈ l, p x) →
    ∃ x ∈ a :: l, p x 
Arguments: {α : Type u} {p : α → Prop} {a : α} {l : List α}
Goal: (∃ x, x ∈ l ∧ p x) → ∃ x, x ∈ a :: l ∧ p x
-- List.or_exists_of_exists_mem_cons
theorem or_exists_of_exists_mem_cons {p : α → Prop} {a : α} {l : List α} : (∃ x ∈ a :: l, p x) →
    p a ∨ ∃ x ∈ l, p x 
Arguments: {α : Type u} {p : α → Prop} {a : α} {l : List α}
Goal: (∃ x, x ∈ a :: l ∧ p x) → p a ∨ ∃ x, x ∈ l ∧ p x
-- List.exists_mem_cons_iff
theorem exists_mem_cons_iff (p : α → Prop) (a : α) (l : List α) :
    (∃ x ∈ a :: l, p x) ↔ p a ∨ ∃ x ∈ l, p x 
Arguments: {α : Type u} (p : α → Prop) (a : α) (l : List α)
Goal: (∃ x, x ∈ a :: l ∧ p x) ↔ p a ∨ ∃ x, x ∈ l ∧ p x
-- List.cons_subset_of_subset_of_mem
theorem cons_subset_of_subset_of_mem {a : α} {l m : List α}
    (ainm : a ∈ m) (lsubm : l ⊆ m) : a::l ⊆ m 
Arguments: {α : Type u} {a : α} {l m : List α} (ainm : a ∈ m) (lsubm : l ⊆ m)
Goal: a :: l ⊆ m
-- List.append_subset_of_subset_of_subset
theorem append_subset_of_subset_of_subset {l₁ l₂ l : List α} (l₁subl : l₁ ⊆ l) (l₂subl : l₂ ⊆ l) :
    l₁ ++ l₂ ⊆ l 
Arguments: {α : Type u} {l₁ l₂ l : List α} (l₁subl : l₁ ⊆ l) (l₂subl : l₂ ⊆ l)
Goal: l₁ ++ l₂ ⊆ l
-- List.map_subset_iff
theorem map_subset_iff {l₁ l₂ : List α} (f : α → β) (h : Injective f) :
    map f l₁ ⊆ map f l₂ ↔ l₁ ⊆ l₂ 
Arguments: {α : Type u} {β : Type v} {l₁ l₂ : List α} (f : α → β) (h : Function.Injective f)
Goal: List.map f l₁ ⊆ List.map f l₂ ↔ l₁ ⊆ l₂
-- List.append_eq_has_append
theorem append_eq_has_append {L₁ L₂ : List α} : List.append L₁ L₂ = L₁ ++ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List α}
Goal: L₁.append L₂ = L₁ ++ L₂
-- List.append_left_eq_self
@[simp] theorem append_left_eq_self {x y : List α} : x ++ y = y ↔ x = [] 
Arguments: {α : Type u} {x y : List α}
Goal: x ++ y = y ↔ x = []
-- List.self_eq_append_left
@[simp] theorem self_eq_append_left {x y : List α} : y = x ++ y ↔ x = [] 
Arguments: {α : Type u} {x y : List α}
Goal: y = x ++ y ↔ x = []
-- List.append_right_eq_self
@[simp] theorem append_right_eq_self {x y : List α} : x ++ y = x ↔ y = [] 
Arguments: {α : Type u} {x y : List α}
Goal: x ++ y = x ↔ y = []
-- List.self_eq_append_right
@[simp] theorem self_eq_append_right {x y : List α} : x = x ++ y ↔ y = [] 
Arguments: {α : Type u} {x y : List α}
Goal: x = x ++ y ↔ y = []