ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Order/IsWellOrderLimitElement.lean

full_name: wellOrderSucc
code: /-- Given an element `a : α` in a well ordered set, this is the successor of `a`,
i.e. the smallest element stricly greater than `a` if it exists (or `a` itself otherwise). -/
noncomputable def wellOrderSucc (a : α) : α 
goal: α

full_name: self_le_wellOrderSucc
code: lemma self_le_wellOrderSucc (a : α) : a ≤ wellOrderSucc a 
goal: a ≤ wellOrderSucc a

full_name: wellOrderSucc_le
code: lemma wellOrderSucc_le {a b : α} (ha : a < b) : wellOrderSucc a ≤ b 
goal: wellOrderSucc a ≤ b

full_name: self_lt_wellOrderSucc
code: lemma self_lt_wellOrderSucc {a b : α} (h : a < b) : a < wellOrderSucc a 
goal: a < wellOrderSucc a

full_name: le_of_lt_wellOrderSucc
code: lemma le_of_lt_wellOrderSucc {a b : α} (h : a < wellOrderSucc b) : a ≤ b 
goal: a ≤ b

full_name: IsWellOrderLimitElement.not_succ
code: /-- This property of an element `a : α` in a well-ordered type holds iff `a` is a
limit element, i.e. it is not a successor and it is not the smallest element of `α`. -/
class IsWellOrderLimitElement (a : α) : Prop where
  not_bot : ∃ (b : α), b < a
  not_succ (b : α) (hb : b < a) : ∃ (c : α), b < c ∧ c < a
goal: ∃ c, b < c ∧ c < a

full_name: IsWellOrderLimitElement.not_bot
code: /-- This property of an element `a : α` in a well-ordered type holds iff `a` is a
limit element, i.e. it is not a successor and it is not the smallest element of `α`. -/
class IsWellOrderLimitElement (a : α) : Prop where
  not_bot : ∃ (b : α), b < a
  not_succ (b : α) (hb : b < a) : ∃ (c : α), b < c ∧ c < a
goal: ∃ b, b < a

full_name: IsWellOrderLimitElement
code: /-- This property of an element `a : α` in a well-ordered type holds iff `a` is a
limit element, i.e. it is not a successor and it is not the smallest element of `α`. -/
class IsWellOrderLimitElement (a : α) : Prop where
  not_bot : ∃ (b : α), b < a
  not_succ (b : α) (hb : b < a) : ∃ (c : α), b < c ∧ c < a
goal: Prop

full_name: IsWellOrderLimitElement.neq_bot
code: lemma IsWellOrderLimitElement.neq_bot [OrderBot α] : a ≠ ⊥ 
goal: a ≠ ⊥

full_name: IsWellOrderLimitElement.bot_lt
code: lemma IsWellOrderLimitElement.bot_lt [OrderBot α] : ⊥ < a 
goal: ⊥ < a

full_name: IsWellOrderLimitElement.wellOrderSucc_lt
code: lemma IsWellOrderLimitElement.wellOrderSucc_lt {b : α} (hb : b < a) :
    wellOrderSucc b < a 
goal: wellOrderSucc b < a

full_name: eq_bot_or_eq_succ_or_isWellOrderLimitElement
code: lemma eq_bot_or_eq_succ_or_isWellOrderLimitElement [OrderBot α] (a : α) :
    a = ⊥ ∨ (∃ b, a = wellOrderSucc b ∧ b < a) ∨ IsWellOrderLimitElement a 
goal: a = ⊥ ∨ (∃ b, a = wellOrderSucc b ∧ b < a) ∨ IsWellOrderLimitElement a

full_name: IsWellOrderLimitElement.neq_succ
code: lemma IsWellOrderLimitElement.neq_succ (a : α) (ha : a < wellOrderSucc a)
    [IsWellOrderLimitElement (wellOrderSucc a)] : False 
goal: False

full_name: Nat.wellOrderSucc_eq
code: @[simp]
lemma Nat.wellOrderSucc_eq (a : ℕ) : wellOrderSucc a = succ a 
goal: wellOrderSucc a = a.succ

full_name: Nat.not_isWellOrderLimitElement
code: lemma Nat.not_isWellOrderLimitElement (a : ℕ) [IsWellOrderLimitElement a] : False 
goal: False
File: Mathlib/Order/CompletePartialOrder.lean

full_name: CompletePartialOrder
code: /--
Complete partial orders are partial orders where every directed set has a least upper bound.
-/
class CompletePartialOrder (α : Type*) extends PartialOrder α, SupSet α where
  /-- For each directed set `d`, `sSup d` is the least upper bound of `d`. -/
  lubOfDirected : ∀ d, DirectedOn (· ≤ ·) d → IsLUB d (sSup d)
goal: Type u_4

full_name: CompletePartialOrder.lubOfDirected
code: /--
Complete partial orders are partial orders where every directed set has a least upper bound.
-/
class CompletePartialOrder (α : Type*) extends PartialOrder α, SupSet α where
  /-- For each directed set `d`, `sSup d` is the least upper bound of `d`. -/
  lubOfDirected : ∀ d, DirectedOn (· ≤ ·) d → IsLUB d (sSup d)
goal: DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB d (sSup d)

full_name: DirectedOn.isLUB_sSup
code: protected lemma DirectedOn.isLUB_sSup : DirectedOn (· ≤ ·) d → IsLUB d (sSup d) 
goal: DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB d (sSup d)

full_name: DirectedOn.le_sSup
code: protected lemma DirectedOn.le_sSup (hd : DirectedOn (· ≤ ·) d) (ha : a ∈ d) : a ≤ sSup d 
goal: a ≤ sSup d

full_name: DirectedOn.sSup_le
code: protected lemma DirectedOn.sSup_le (hd : DirectedOn (· ≤ ·) d) (ha : ∀ b ∈ d, b ≤ a) : sSup d ≤ a 
goal: sSup d ≤ a

full_name: Directed.le_iSup
code: protected lemma Directed.le_iSup (hf : Directed (· ≤ ·) f) (i : ι) : f i ≤ ⨆ j, f j 
goal: f i ≤ ⨆ j, f j

full_name: Directed.iSup_le
code: protected lemma Directed.iSup_le (hf : Directed (· ≤ ·) f) (ha : ∀ i, f i ≤ a) :  ⨆ i, f i ≤ a 
goal: ⨆ i, f i ≤ a

full_name: CompletePartialOrder.scottContinuous
code: /-- Scott-continuity takes on a simpler form in complete partial orders. -/
lemma CompletePartialOrder.scottContinuous {f : α → β} :
    ScottContinuous f ↔
    ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → IsLUB (f '' d) (f (sSup d)) 
goal: ScottContinuous f ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))

full_name: CompletePartialOrder.toOmegaCompletePartialOrder
code: /-- A complete partial order is an ω-complete partial order. -/
instance CompletePartialOrder.toOmegaCompletePartialOrder : OmegaCompletePartialOrder α 
goal: OmegaCompletePartialOrder α

full_name: CompleteLattice.toCompletePartialOrder
code: /-- A complete lattice is a complete partial order. -/
instance CompleteLattice.toCompletePartialOrder [CompleteLattice α] : CompletePartialOrder α 
goal: CompletePartialOrder α
File: Mathlib/Order/Filter/Germ/OrderedMonoid.lean

full_name: Filter.Germ.instOrderedAddCommMonoid
code: @[to_additive]
instance instOrderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β) 
goal: OrderedAddCommMonoid (l.Germ β)

full_name: Filter.Germ.instOrderedCommMonoid
code: @[to_additive]
instance instOrderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β) 
goal: OrderedCommMonoid (l.Germ β)

full_name: Filter.Germ.instOrderedCancelCommMonoid
code: @[to_additive]
instance instOrderedCancelCommMonoid [OrderedCancelCommMonoid β] :
    OrderedCancelCommMonoid (Germ l β) 
goal: OrderedCancelCommMonoid (l.Germ β)

full_name: Filter.Germ.instOrderedAddCancelCommMonoid
code: @[to_additive]
instance instOrderedCancelCommMonoid [OrderedCancelCommMonoid β] :
    OrderedCancelCommMonoid (Germ l β) 
goal: OrderedCancelAddCommMonoid (l.Germ β)

full_name: Filter.Germ.instCanonicallyOrderedCommMonoid
code: @[to_additive]
instance instCanonicallyOrderedCommMonoid [CanonicallyOrderedCommMonoid β] :
    CanonicallyOrderedCommMonoid (Germ l β) 
goal: CanonicallyOrderedCommMonoid (l.Germ β)

full_name: Filter.Germ.instCanonicallyOrderedAddCommMonoid
code: @[to_additive]
instance instCanonicallyOrderedCommMonoid [CanonicallyOrderedCommMonoid β] :
    CanonicallyOrderedCommMonoid (Germ l β) 
goal: CanonicallyOrderedAddCommMonoid (l.Germ β)
File: Mathlib/Order/Filter/ListTraverse.lean

full_name: Filter.sequence_mono
code: theorem sequence_mono : ∀ as bs : List (Filter α), Forall₂ (· ≤ ·) as bs → sequence as ≤ sequence bs
  
goal: List.Forall₂ (fun x x_1 => x ≤ x_1) as bs → sequence as ≤ sequence bs

full_name: Filter.mem_traverse
code: theorem mem_traverse :
    ∀ (fs : List β) (us : List γ),
      Forall₂ (fun b c => s c ∈ f b) fs us → traverse s us ∈ traverse f fs
  
goal: List.Forall₂ (fun b c => s c ∈ f b) fs us → traverse s us ∈ traverse f fs

full_name: Filter.mem_traverse_iff
code: theorem mem_traverse_iff (fs : List β) (t : Set (List α)) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α), Forall₂ (fun b (s : Set α) => s ∈ f b) fs us ∧ sequence us ⊆ t 
goal: t ∈ traverse f fs ↔ ∃ us, List.Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
File: Mathlib/Order/Filter/Ker.lean

full_name: Filter.ker
code: /-- The *kernel* of a filter is the intersection of all its sets. -/
def ker (f : Filter α) : Set α 
goal: Set α

full_name: Filter.ker_def
code: lemma ker_def (f : Filter α) : f.ker = ⋂ s ∈ f, s 
goal: f.ker = ⋂ s ∈ f, s

full_name: Filter.mem_ker
code: @[simp] lemma mem_ker : a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s 
goal: a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s

full_name: Filter.subset_ker
code: @[simp] lemma subset_ker : s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t 
goal: s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t

full_name: Filter.gi_principal_ker
code: /-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker 
goal: GaloisCoinsertion Filter.principal Filter.ker

full_name: Filter.ker_mono
code: lemma ker_mono : Monotone (ker : Filter α → Set α) 
goal: Monotone Filter.ker

full_name: Filter.ker_surjective
code: lemma ker_surjective : Surjective (ker : Filter α → Set α) 
goal: Function.Surjective Filter.ker

full_name: Filter.ker_bot
code: @[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ 
goal: ⊥.ker = ∅

full_name: Filter.ker_top
code: @[simp] lemma ker_top : ker (⊤ : Filter α) = univ 
goal: ⊤.ker = Set.univ

full_name: Filter.ker_eq_univ
code: @[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ 
goal: f.ker = Set.univ ↔ f = ⊤

full_name: Filter.ker_inf
code: @[simp] lemma ker_inf (f g : Filter α) : ker (f ⊓ g) = ker f ∩ ker g 
goal: (f ⊓ g).ker = f.ker ∩ g.ker

full_name: Filter.ker_iInf
code: @[simp] lemma ker_iInf (f : ι → Filter α) : ker (⨅ i, f i) = ⨅ i, ker (f i) 
goal: (⨅ i, f i).ker = ⨅ i, (f i).ker

full_name: Filter.ker_sInf
code: @[simp] lemma ker_sInf (S : Set (Filter α)) : ker (sInf S) = ⨅ f ∈ S, ker f 
goal: (sInf S).ker = ⨅ f ∈ S, f.ker

full_name: Filter.ker_principal
code: @[simp] lemma ker_principal (s : Set α) : ker (𝓟 s) = s 
goal: (Filter.principal s).ker = s

full_name: Filter.ker_pure
code: @[simp] lemma ker_pure (a : α) : ker (pure a) = {a} 
goal: (pure a).ker = {a}

full_name: Filter.ker_comap
code: @[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f 
goal: (Filter.comap m f).ker = m ⁻¹' f.ker
File: Mathlib/Order/Filter/ModEq.lean

full_name: Nat.frequently_modEq
code: /-- Infinitely many natural numbers are equal to `d` mod `n`. -/
theorem frequently_modEq {n : ℕ} (h : n ≠ 0) (d : ℕ) : ∃ᶠ m in atTop, m ≡ d [MOD n] 
goal: ∃ᶠ (m : ℕ) in Filter.atTop, m ≡ d [MOD n]

full_name: Nat.frequently_mod_eq
code: theorem frequently_mod_eq {d n : ℕ} (h : d < n) : ∃ᶠ m in atTop, m % n = d 
goal: ∃ᶠ (m : ℕ) in Filter.atTop, m % n = d

full_name: Nat.frequently_even
code: theorem frequently_even : ∃ᶠ m : ℕ in atTop, Even m 
goal: ∃ᶠ (m : ℕ) in Filter.atTop, Even m

full_name: Nat.frequently_odd
code: theorem frequently_odd : ∃ᶠ m : ℕ in atTop, Odd m 
goal: ∃ᶠ (m : ℕ) in Filter.atTop, Odd m

full_name: Filter.nonneg_of_eventually_pow_nonneg
code: theorem Filter.nonneg_of_eventually_pow_nonneg {α : Type*} [LinearOrderedRing α] {a : α}
    (h : ∀ᶠ n in atTop, 0 ≤ a ^ (n : ℕ)) : 0 ≤ a 
goal: 0 ≤ a
File: Mathlib/Order/Filter/Ring.lean

full_name: Filter.EventuallyLE.mul_le_mul
code: theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
    {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
    (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
goal: f₁ * g₁ ≤ᶠ[l] f₂ * g₂

full_name: Filter.EventuallyLE.mul_le_mul'
code: @[to_additive EventuallyLE.add_le_add]
theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
    [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
    (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
goal: f₁ * g₁ ≤ᶠ[l] f₂ * g₂

full_name: Filter.EventuallyLE.add_le_add
code: @[to_additive EventuallyLE.add_le_add]
theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
    [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
    (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
goal: f₁ + g₁ ≤ᶠ[l] f₂ + g₂

full_name: Filter.EventuallyLE.mul_nonneg
code: theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
    (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g 
goal: 0 ≤ᶠ[l] f * g

full_name: Filter.eventually_sub_nonneg
code: theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
    0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g 
goal: 0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g

full_name: Filter.Germ.instOrderedAddCommGroup
code: @[to_additive]
instance instOrderedCommGroup [OrderedCommGroup β] : OrderedCommGroup (Germ l β) 
goal: OrderedAddCommGroup (l.Germ β)

full_name: Filter.Germ.instOrderedCommGroup
code: @[to_additive]
instance instOrderedCommGroup [OrderedCommGroup β] : OrderedCommGroup (Germ l β) 
goal: OrderedCommGroup (l.Germ β)

full_name: Filter.Germ.instOrderedSemiring
code: instance instOrderedSemiring [OrderedSemiring β] : OrderedSemiring (Germ l β) 
goal: OrderedSemiring (l.Germ β)

full_name: Filter.Germ.instOrderedCommSemiring
code: instance instOrderedCommSemiring [OrderedCommSemiring β] : OrderedCommSemiring (Germ l β) 
goal: OrderedCommSemiring (l.Germ β)

full_name: Filter.Germ.instOrderedRing
code: instance instOrderedRing [OrderedRing β] : OrderedRing (Germ l β) 
goal: OrderedRing (l.Germ β)

full_name: Filter.Germ.instOrderedCommRing
code: instance instOrderedCommRing [OrderedCommRing β] : OrderedCommRing (Germ l β) 
goal: OrderedCommRing (l.Germ β)
File: Mathlib/Order/Filter/Subsingleton.lean

full_name: Filter.Subsingleton
code: /-- We say that a filter is a *subsingleton* if there exists a subsingleton set
that belongs to the filter. -/
protected def Subsingleton (l : Filter α) : Prop 
goal: Prop

full_name: Filter.HasBasis.subsingleton_iff
code: theorem HasBasis.subsingleton_iff {ι : Sort*} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s) :
    l.Subsingleton ↔ ∃ i, p i ∧ (s i).Subsingleton 
goal: l.Subsingleton ↔ ∃ i, p i ∧ (s i).Subsingleton

full_name: Filter.Subsingleton.anti
code: theorem Subsingleton.anti {l'} (hl : l.Subsingleton) (hl' : l' ≤ l) : l'.Subsingleton 
goal: l'.Subsingleton

full_name: Filter.Subsingleton.of_subsingleton
code: @[nontriviality]
theorem Subsingleton.of_subsingleton [Subsingleton α] : l.Subsingleton 
goal: l.Subsingleton

full_name: Filter.Subsingleton.map
code: theorem Subsingleton.map (hl : l.Subsingleton) (f : α → β) : (map f l).Subsingleton 
goal: (Filter.map f l).Subsingleton

full_name: Filter.Subsingleton.prod
code: theorem Subsingleton.prod (hl : l.Subsingleton) {l' : Filter β} (hl' : l'.Subsingleton) :
    (l ×ˢ l').Subsingleton 
goal: (l ×ˢ l').Subsingleton

full_name: Filter.subsingleton_pure
code: @[simp]
theorem subsingleton_pure {a : α} : Filter.Subsingleton (pure a) 
goal: (pure a).Subsingleton

full_name: Filter.subsingleton_bot
code: @[simp]
theorem subsingleton_bot : Filter.Subsingleton (⊥ : Filter α) 
goal: ⊥.Subsingleton

full_name: Filter.Subsingleton.exists_eq_pure
code: /-- A nontrivial subsingleton filter is equal to `pure a` for some `a`. -/
theorem Subsingleton.exists_eq_pure [l.NeBot] (hl : l.Subsingleton) : ∃ a, l = pure a 
goal: ∃ a, l = pure a

full_name: Filter.subsingleton_iff_bot_or_pure
code: /-- A filter is a subsingleton iff it is equal to `⊥` or to `pure a` for some `a`. -/
theorem subsingleton_iff_bot_or_pure : l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a 
goal: l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a

full_name: Filter.subsingleton_iff_exists_le_pure
code: /-- In a nonempty type, a filter is a subsingleton iff
it is less than or equal to a pure filter. -/
theorem subsingleton_iff_exists_le_pure [Nonempty α] : l.Subsingleton ↔ ∃ a, l ≤ pure a 
goal: l.Subsingleton ↔ ∃ a, l ≤ pure a

full_name: Filter.subsingleton_iff_exists_singleton_mem
code: theorem subsingleton_iff_exists_singleton_mem [Nonempty α] : l.Subsingleton ↔ ∃ a, {a} ∈ l 
goal: l.Subsingleton ↔ ∃ a, {a} ∈ l

full_name: Filter.Subsingleton.isCountablyGenerated
code: lemma Subsingleton.isCountablyGenerated (hl : l.Subsingleton) : IsCountablyGenerated l 
goal: l.IsCountablyGenerated
File: Mathlib/Order/Filter/Curry.lean

full_name: Filter.curry
code: /-- This filter is characterized by `Filter.eventually_curry_iff`:
`(∀ᶠ (x : α × β) in f.curry g, p x) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in g, p (x, y)`. Useful
in adding quantifiers to the middle of `Tendsto`s. See
`hasFDerivAt_of_tendstoUniformlyOnFilter`. -/
def curry (f : Filter α) (g : Filter β) : Filter (α × β) 
goal: Filter (α × β)

full_name: Filter.eventually_curry_iff
code: theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → Prop} :
    (∀ᶠ x : α × β in f.curry g, p x) ↔ ∀ᶠ x : α in f, ∀ᶠ y : β in g, p (x, y) 
goal: (∀ᶠ (x : α × β) in f.curry g, p x) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in g, p (x, y)

full_name: Filter.frequently_curry_iff
code: theorem frequently_curry_iff {α β : Type*} {l : Filter α} {m : Filter β}
    (p : (α × β) → Prop) : (∃ᶠ x in l.curry m, p x) ↔ ∃ᶠ x in l, ∃ᶠ y in m, p (x, y) 
goal: (∃ᶠ (x : α × β) in l.curry m, p x) ↔ ∃ᶠ (x : α) in l, ∃ᶠ (y : β) in m, p (x, y)

full_name: Filter.mem_curry_iff
code: theorem mem_curry_iff {f : Filter α} {g : Filter β} {s : Set (α × β)} :
    s ∈ f.curry g ↔ ∀ᶠ x : α in f, ∀ᶠ y : β in g, (x, y) ∈ s 
goal: s ∈ f.curry g ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in g, (x, y) ∈ s

full_name: Filter.curry_le_prod
code: theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.prod g 
goal: f.curry g ≤ f.prod g

full_name: Filter.Tendsto.curry
code: theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {lc : Filter γ}
    (h : ∀ᶠ a in la, Tendsto (fun b : β => f a b) lb lc) : Tendsto (↿f) (la.curry lb) lc 
goal: Filter.Tendsto (↿f) (la.curry lb) lc

full_name: Filter.frequently_curry_prod_iff
code: theorem frequently_curry_prod_iff {α β : Type*} {l : Filter α} {m : Filter β}
    (s : Set α) (t : Set β) : (∃ᶠ x in l.curry m, x ∈ s ×ˢ t) ↔ sᶜ ∉ l ∧ tᶜ ∉ m 
goal: (∃ᶠ (x : α × β) in l.curry m, x ∈ s ×ˢ t) ↔ sᶜ ∉ l ∧ tᶜ ∉ m

full_name: Filter.prod_mem_curry
code: theorem prod_mem_curry {α β : Type*} {l : Filter α} {m : Filter β} {s : Set α} {t : Set β}
    (hs : s ∈ l) (ht : t ∈ m) : s ×ˢ t ∈ l.curry m 
goal: s ×ˢ t ∈ l.curry m

full_name: Filter.eventually_curry_prod_iff
code: theorem eventually_curry_prod_iff {α β : Type*} {l : Filter α} {m : Filter β}
    [NeBot l] [NeBot m] (s : Set α) (t : Set β) :
    (∀ᶠ x in l.curry m, x ∈ s ×ˢ t) ↔ s ∈ l ∧ t ∈ m 
goal: (∀ᶠ (x : α × β) in l.curry m, x ∈ s ×ˢ t) ↔ s ∈ l ∧ t ∈ m
File: Mathlib/Order/Filter/ENNReal.lean

full_name: ENNReal.eventually_le_limsup
code: theorem eventually_le_limsup [CountableInterFilter f] (u : α → ℝ≥0∞) :
    ∀ᶠ y in f, u y ≤ f.limsup u 
goal: ∀ᶠ (y : α) in f, u y ≤ Filter.limsup u f

full_name: ENNReal.limsup_eq_zero_iff
code: theorem limsup_eq_zero_iff [CountableInterFilter f] {u : α → ℝ≥0∞} :
    f.limsup u = 0 ↔ u =ᶠ[f] 0 
goal: Filter.limsup u f = 0 ↔ u =ᶠ[f] 0

full_name: ENNReal.limsup_const_mul_of_ne_top
code: theorem limsup_const_mul_of_ne_top {u : α → ℝ≥0∞} {a : ℝ≥0∞} (ha_top : a ≠ ⊤) :
    (f.limsup fun x : α => a * u x) = a * f.limsup u 
goal: Filter.limsup (fun x => a * u x) f = a * Filter.limsup u f

full_name: ENNReal.limsup_const_mul
code: theorem limsup_const_mul [CountableInterFilter f] {u : α → ℝ≥0∞} {a : ℝ≥0∞} :
    f.limsup (a * u ·) = a * f.limsup u 
goal: Filter.limsup (fun x => a * u x) f = a * Filter.limsup u f

full_name: ENNReal.limsup_mul_le
code: theorem limsup_mul_le [CountableInterFilter f] (u v : α → ℝ≥0∞) :
    f.limsup (u * v) ≤ f.limsup u * f.limsup v 
goal: Filter.limsup (u * v) f ≤ Filter.limsup u f * Filter.limsup v f

full_name: ENNReal.limsup_add_le
code: theorem limsup_add_le [CountableInterFilter f] (u v : α → ℝ≥0∞) :
    f.limsup (u + v) ≤ f.limsup u + f.limsup v 
goal: Filter.limsup (u + v) f ≤ Filter.limsup u f + Filter.limsup v f

full_name: ENNReal.limsup_liminf_le_liminf_limsup
code: theorem limsup_liminf_le_liminf_limsup {β} [Countable β] {f : Filter α} [CountableInterFilter f]
    {g : Filter β} (u : α → β → ℝ≥0∞) :
    (f.limsup fun a : α => g.liminf fun b : β => u a b) ≤
      g.liminf fun b => f.limsup fun a => u a b 
goal: Filter.limsup (fun a => Filter.liminf (fun b => u a b) g) f ≤
  Filter.liminf (fun b => Filter.limsup (fun a => u a b) f) g
File: Mathlib/Order/Part.lean

full_name: Monotone.partBind
code: lemma Monotone.partBind (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x ↦ (f x).bind (g x) 
goal: Monotone fun x => (f x).bind (g x)

full_name: Antitone.partBind
code: lemma Antitone.partBind (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x ↦ (f x).bind (g x) 
goal: Antitone fun x => (f x).bind (g x)

full_name: Monotone.partMap
code: lemma Monotone.partMap (hg : Monotone g) : Monotone fun x ↦ (g x).map f 
goal: Monotone fun x => Part.map f (g x)

full_name: Antitone.partMap
code: lemma Antitone.partMap (hg : Antitone g) : Antitone fun x ↦ (g x).map f 
goal: Antitone fun x => Part.map f (g x)

full_name: Monotone.partSeq
code: lemma Monotone.partSeq (hf : Monotone f) (hg : Monotone g) : Monotone fun x ↦ f x <*> g x 
goal: Monotone fun x => Seq.seq (f x) fun x_1 => g x

full_name: Antitone.partSeq
code: lemma Antitone.partSeq (hf : Antitone f) (hg : Antitone g) : Antitone fun x ↦ f x <*> g x 
goal: Antitone fun x => Seq.seq (f x) fun x_1 => g x

full_name: OrderHom.partBind
code: /-- `Part.bind` as a monotone function -/
@[simps]
def partBind (f : α →o Part β) (g : α →o β → Part γ) : α →o Part γ 
goal: α →o Part γ

full_name: OrderHom.partBind_coe
code: /-- `Part.bind` as a monotone function -/
@[simps]
def partBind (f : α →o Part β) (g : α →o β → Part γ) : α →o Part γ 
goal: (f.partBind g) x = (f x).bind (g x)
File: Mathlib/Order/PropInstances.lean

full_name: Prop.instDistribLattice
code: /-- Propositions form a distributive lattice. -/
instance Prop.instDistribLattice : DistribLattice Prop 
goal: DistribLattice Prop

full_name: Prop.instBoundedOrder
code: /-- Propositions form a bounded order. -/
instance Prop.instBoundedOrder : BoundedOrder Prop 
goal: BoundedOrder Prop

full_name: Prop.bot_eq_false
code: @[simp]
theorem Prop.bot_eq_false : (⊥ : Prop) = False 
goal: ⊥ = False

full_name: Prop.top_eq_true
code: @[simp]
theorem Prop.top_eq_true : (⊤ : Prop) = True 
goal: ⊤ = True

full_name: Prop.le_isTotal
code: instance Prop.le_isTotal : IsTotal Prop (· ≤ ·) 
goal: IsTotal Prop fun x x_1 => x ≤ x_1

full_name: Prop.linearOrder
code: noncomputable instance Prop.linearOrder : LinearOrder Prop 
goal: LinearOrder Prop

full_name: sup_Prop_eq
code: @[simp]
theorem sup_Prop_eq : (· ⊔ ·) = (· ∨ ·) 
goal: (fun x x_1 => x ⊔ x_1) = fun x x_1 => x ∨ x_1

full_name: inf_Prop_eq
code: @[simp]
theorem inf_Prop_eq : (· ⊓ ·) = (· ∧ ·) 
goal: (fun x x_1 => x ⊓ x_1) = fun x x_1 => x ∧ x_1

full_name: Pi.disjoint_iff
code: theorem disjoint_iff [∀ i, OrderBot (α' i)] {f g : ∀ i, α' i} :
    Disjoint f g ↔ ∀ i, Disjoint (f i) (g i) 
goal: Disjoint f g ↔ ∀ (i : ι), Disjoint (f i) (g i)

full_name: Pi.codisjoint_iff
code: theorem codisjoint_iff [∀ i, OrderTop (α' i)] {f g : ∀ i, α' i} :
    Codisjoint f g ↔ ∀ i, Codisjoint (f i) (g i) 
goal: Codisjoint f g ↔ ∀ (i : ι), Codisjoint (f i) (g i)

full_name: Pi.isCompl_iff
code: theorem isCompl_iff [∀ i, BoundedOrder (α' i)] {f g : ∀ i, α' i} :
    IsCompl f g ↔ ∀ i, IsCompl (f i) (g i) 
goal: IsCompl f g ↔ ∀ (i : ι), IsCompl (f i) (g i)

full_name: Prop.disjoint_iff
code: @[simp]
theorem Prop.disjoint_iff {P Q : Prop} : Disjoint P Q ↔ ¬(P ∧ Q) 
goal: Disjoint P Q ↔ ¬(P ∧ Q)

full_name: Prop.codisjoint_iff
code: @[simp]
theorem Prop.codisjoint_iff {P Q : Prop} : Codisjoint P Q ↔ P ∨ Q 
goal: Codisjoint P Q ↔ P ∨ Q

full_name: Prop.isCompl_iff
code: @[simp]
theorem Prop.isCompl_iff {P Q : Prop} : IsCompl P Q ↔ ¬(P ↔ Q) 
goal: IsCompl P Q ↔ ¬(P ↔ Q)

full_name: Prop.decidablePredBot
code: instance Prop.decidablePredBot : DecidablePred (⊥ : α → Prop) 
goal: DecidablePred ⊥

full_name: Prop.decidablePredTop
code: instance Prop.decidablePredTop : DecidablePred (⊤ : α → Prop) 
goal: DecidablePred ⊤

full_name: Prop.decidableRelBot
code: instance Prop.decidableRelBot : DecidableRel (⊥ : α → α → Prop) 
goal: DecidableRel ⊥

full_name: Prop.decidableRelTop
code: instance Prop.decidableRelTop : DecidableRel (⊤ : α → α → Prop) 
goal: DecidableRel ⊤