theorem Set.indicator_of_mem :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {a : α},
      a ∈ s → ∀ (f : α → M), Set.indicator s f a = f a :=
  by sorry

The theorem `Set.indicator_of_mem` asserts that for any type `α`, type `M` equipped with a zero element, a set `s` of elements of type `α`, and an element `a` of type `α`, if `a` is an element of the set `s`, then the indicator function of the set `s` applied to the function `f` and the element `a` equals the function `f` applied to the element `a`. In other words, if `a` belongs to `s`, the set indicator will simply return the value of function `f` at `a`. This theorem essentially defines the behavior of the set indicator function when the element is within the set.

For any set `s` of type `α` and function `f` from `α` to a type `B`, if `a` is an element of `s`, then `indicator_s a = f a`.


theorem iInf_le : ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] (f : ι → α) (i : ι), iInf f ≤ f i := by
  sorry

This theorem, `iInf_le`, asserts that for any type `α` which forms a complete lattice, and any function `f` from an arbitrary type `ι` to `α`, the infimum of the range of `f` (denoted by `iInf f`) is less than or equal to the function value `f i` at any point `i` in the domain `ι`. In simpler terms, the least value in the entire range of the function `f` does not exceed the value of `f` at any specific point.

For any complete lattice `α` and function `f` from a type `ι` to `α`, the infimum of `f`'s range is less than or equal to `f(i)` for all `i` in `ι`.


theorem Nat.lt_succ_iff : ∀ {m n : ℕ}, m < Nat.succ n ↔ m ≤ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, `m` is less than the successor of `n` if and only if `m` is less than or equal to `n`. In other words, the theorem establishes a connection between the "less than" and "less than or equal to" relations for natural numbers when considering the successor of a number.

For all natural numbers m and n, m < (S n) if and only if m <= n, where S denotes the successor function.


Filter.HasBasis.comap

theorem Filter.HasBasis.comap :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (f : β → α),
      Filter.HasBasis l p s → Filter.HasBasis (Filter.comap f l) p fun i => f ⁻¹' s i :=
  by sorry

The theorem `Filter.HasBasis.comap` states that for every pair of types `α` and `β`, a sort `ι`, a filter `l` on `α`, a function `p` from `ι` to `Prop`, and a function `s` from `ι` to a set of `α`, along with a function `f` from `β` to `α`, if we have a basis for the filter `l` defined by the predicates `p` and the sets `s`, then we also have a basis for the filter obtained by the function `f` composed with `l`, where the basis is defined by the predicates `p` and the preimage of the sets `s` under the function `f`.

If `l` is a filter on `α` with basis `{p : ι → Prop, s : ι → set α | ∀ i, ∃ x : α, p i ∧ l x = s i}`, then `f '' l` has basis `{p, ∥f∥ '' s}`, where `∥f∥` is the function mapping a set to its image under `f`.


theorem Set.mem_preimage : ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, a ∈ f ⁻¹' s ↔ f a ∈ s := by
  sorry

The theorem `Set.mem_preimage` states that for any types `α` and `β`, any function `f` from `α` to `β`, any set `s` of elements of type `β`, and any element `a` of type `α`, `a` is an element of the preimage of `s` under `f` if and only if `f(a)` is an element of `s`. In other words, it says that an element belongs to the preimage of a set under a function exactly when its image under the function belongs to the original set. This theorem formalizes one of the fundamental properties of the preimage of a set under a function in set theory.

For any function between sets, an element is in the preimage if and only if its image is in the given set.


theorem MeasureTheory.measure_ne_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.IsFiniteMeasure μ]
      (s : Set α), ↑↑μ s ≠ ⊤ :=
  by sorry

This theorem states that for any given type `α`, any measurable space `m0` of type `α`, any measure `μ` of the measurable space `α`, and any set `s` of type `α`, the double coercion (or measure) of `μ s` is not equal to positive infinity. In other words, if `μ` is a finite measure, then the measure of any set `s` under this measure `μ` is also finite.

For any finite measure μ on measurable space α, the measure μ(s) of any set s in α is finite.


theorem smul_neg :
    ∀ {M : Type u_1} {A : Type u_4} [inst : Monoid M] [inst_1 : AddGroup A] [inst_2 : DistribMulAction M A] (r : M)
      (x : A), r • -x = -(r • x) :=
  by sorry

This theorem, `smul_neg`, states that for any types `M` and `A`, where `M` is a monoid, `A` is an additive group, and `A` is also a distributive `M`-action, the scalar multiplication of a monoid element `r` and the additive inverse of an element `x` from `A` is equal to the additive inverse of the scalar multiplication of `r` and `x`. In terms of mathematical notation, this corresponds to the property `r * -x = -(r * x)`, where `*` denotes the action of `M` on `A`.

For any monoid `M`, additive group `A`, and distributive `M`-action on `A`, the scalar multiplication of an element `r` in `M` and the additive inverse `-x` of an element `x` in `A` equals the additive inverse of the scalar multiplication of `r` and `x`, i.e., `r * -x = -(r * x)`.


IsOpen.inter

theorem IsOpen.inter : ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsOpen s → IsOpen t → IsOpen (s ∩ t) :=
  by sorry

This theorem specifies that for any type `X` equipped with a topological space structure, if `s` and `t` are sets of elements of type `X` and both `s` and `t` are open in this topological space, then the intersection of `s` and `t` is also open in the topological space. In the language of topology, this theorem states that the intersection of any two open sets is also open, a fundamental property of topological spaces.

In any topological space, the intersection of two open sets is open.


Exists.elim

theorem Exists.elim : ∀ {α : Sort u} {p : α → Prop} {b : Prop}, (∃ x, p x) → (∀ (a : α), p a → b) → b := by sorry

This theorem, `Exists.elim`, states that for any sort `α`, any predicate `p` on `α`, and any proposition `b`, if there exists an element in `α` that satisfies `p`, and assuming that for any element in `α`, if it satisfies `p` then `b` is true, then `b` must be true. It essentially says that if `b` follows from a property that is satisfied by at least one element, then `b` is true. This is a form of existential elimination in logical reasoning.

If there exists an `α` such that `p(α)` holds and for all `x`, if `p(x)` then `b`, then `b` holds.


theorem Int.cast_add : ∀ {R : Type u} [inst : AddGroupWithOne R] (m n : ℤ), ↑(m + n) = ↑m + ↑n := by sorry

This theorem, `Int.cast_add`, states that for any type `R` that forms an additive group with an identity element, the cast of the sum of two integers `m` and `n` into `R` is equal to the sum of the individual casts of `m` and `n` into `R`. In other words, the operation of casting an integer into another type commutes with the addition operation on integers. This is a fundamental property of addition that allows for more flexible and powerful mathematical manipulations.

For any additive group `R` with identity element, the cast of `m + n` into `R` is equal to the cast of `m` into `R` plus the cast of `n` into `R`. (In Lean notation: `to_add R m n = to_add R m (to_add R n)`)


Function.Injective.ne

theorem Function.Injective.ne :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Injective f → ∀ {a₁ a₂ : α}, a₁ ≠ a₂ → f a₁ ≠ f a₂ := by sorry

This theorem states that for any types `α` and `β` and any function `f : α → β`, if the function `f` is injective (which means that for any two elements `a₁` and `a₂` in `α`, `f a₁ = f a₂` only if `a₁ = a₂`), then for any two different elements `a₁` and `a₂` in `α` (`a₁ ≠ a₂`), their images under `f` are also different (`f a₁ ≠ f a₂`). In other words, an injective function preserves distinctness.

If `f : α → β` is an injective function, then for all `a₁, a₂ ∈ α` with `a₁ ≠ a₂`, it follows that `f a₁ ≠ f a₂`.


/-- **Alias** of `Left.add_nonneg`. -/
theorem add_nonneg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, 0 ≤ a → 0 ≤ b → 0 ≤ a + b :=
  by sorry

The theorem `add_nonneg` states that for any type `α` that has an addition operation and a zero element (`AddZeroClass`), a preorder relation (`Preorder`), and is covariant in that adding an element to another increases its preorder value (`CovariantClass`), if `a` and `b` are elements of `α` and both are greater than or equal to zero, then their sum `a + b` is also greater than or equal to zero. This theorem is essentially an alias or a different name for the theorem `Left.add_nonneg`.

For any type with an additive structure and a preorder relation that is covariant with respect to addition, if both operands are non-negative, then their sum is also non-negative.


theorem and_iff_right : ∀ {a b : Prop}, a → (a ∧ b ↔ b) := by sorry

This theorem, `and_iff_right`, states that for any two propositions `a` and `b`, if `a` is true, then the statement "`a` and `b` is true if and only if `b` is true". In other words, if we already know `a` is true, then the truth of `a ∧ b` (the conjunction of `a` and `b`) is entirely determined by the truth of `b`.

If `a` holds, then `a` and `b` are equal in truth value to `b`.


theorem Nat.Prime.one_lt : ∀ {p : ℕ}, Nat.Prime p → 1 < p := by sorry

The theorem `Nat.Prime.one_lt` states that for all natural numbers `p`, if `p` is a prime number, then `p` is greater than 1. In other words, if a natural number is prime, it must be strictly larger than 1.

If a natural number `p` is prime, then `p` is a positive integer greater than 1.


theorem Set.ext_iff : ∀ {α : Type u} {s t : Set α}, s = t ↔ ∀ (x : α), x ∈ s ↔ x ∈ t := by sorry

The theorem `Set.ext_iff` states that for any type `α`, and for any two sets `s` and `t` of type `α`, the sets `s` and `t` are equal if and only if for every element `x` of type `α`, `x` is a member of `s` if and only if `x` is a member of `t`. In other words, two sets are considered equal in Lean 4 if they have exactly the same elements.

Two sets of type `α` are equal if and only if they contain the same elements.


theorem zero_ne_one : ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], 0 ≠ 1 := by sorry

This theorem, named `zero_ne_one`, is a statement about any type `α` that has a zero (`Zero α`), a one (`One α`), and the property that one is not zero (`NeZero 1`). It asserts that zero is not equal to one in the given type. This is a fundamental property in mathematics and is usually employed in fields where the concept of zero and one are defined such as in the case of numbers.

For any type `α` with `Zero α`, `One α`, and `NeZero 1`, `Zero α` is not equal to `One α`.


Primrec.comp

theorem Primrec.comp :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : β → σ} {g : α → β}, Primrec f → Primrec g → Primrec fun a => f (g a) :=
  by sorry

The theorem `Primrec.comp` states that if `f` is a primitive recursive function from type `β` to type `σ`, and `g` is a primitive recursive function from type `α` to type `β`, then the composition of `f` and `g` (given by `fun a => f (g a)`) is also a primitive recursive function. Here, the types `α, β, σ` are assumed to be primcodable, meaning that they can be encoded and decoded as natural numbers.

If `f` is a primitive recursive function from type `β` to type `σ` and `g` is a primitive recursive function from type `α` to type `β`, then the composition `f ∘ g` defined as `x ↦ f (g x)` is a primitive recursive function.


Homeomorph.continuous

theorem Homeomorph.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      Continuous ⇑h :=
  by sorry

This theorem states that for any two types `X` and `Y`, given that both `X` and `Y` are topological spaces, if there is a homeomorphism between `X` and `Y`, then the application of this homeomorphism is a continuous function. In other words, it preserves the topological structures of `X` and `Y`, demonstrating one of the key properties of homeomorphisms in topology.

Given topological spaces X and Y and a homeomorphism f : X ↔ Y, the function f is continuous.


theorem MeasureTheory.Measure.map_apply :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β},
      Measurable f → ∀ {s : Set β}, MeasurableSet s → ↑↑(MeasureTheory.Measure.map f μ) s = ↑↑μ (f ⁻¹' s) :=
  by sorry

This theorem, `MeasureTheory.Measure.map_apply`, states that for any two types `α` and `β`, if `f` is a function from `α` to `β` that is measurable and `s` is a measurable set in the `β` space, then the measure of `s` under the pushforward measure created by `f` is equal to the measure of the preimage of `s` under `f` in the `α` space. In other words, it is a property about the pushforward of measures: if you pushforward a measure using a measurable function, then measuring a set under this new measure is the same as measuring the preimage of the set under the original measure.

For measurable functions between measurable spaces, the pushforward measure of a set is equal to the measure of its preimage.


theorem le_abs_self : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), a ≤ |a| := by sorry

This theorem states that for any type `α` which forms a lattice and is also an additive group, any element `a` of `α` is less than or equal to the absolute value of `a`. Here `|a|` denotes the absolute value of `a`.

For any lattice and additive group type `α`, every element `a` in `α` satisfies `|a| ≥ a`.


theorem Real.pi_pos : 0 < Real.pi := by sorry

This theorem states that the real number π (pi), which is defined as twice a zero of the cosine function in the interval [1,2], is greater than zero. In other words, the value of π is positive.

The theorem asserts that 0 < π, where π is defined as the positive root of the polynomial x => x^2 + x - 1 in the interval (1, 2).


theorem Set.Finite.coe_toFinset : ∀ {α : Type u} {s : Set α} (hs : Set.Finite s), ↑(Set.Finite.toFinset hs) = s := by
  sorry

This theorem states that for any type `α` and any set `s` of elements of type `α`, if `s` is a finite set, then the conversion of the `Finset` representing `s` back into a set is equal to `s` itself. Here, `Finset` is a type of finite sets in Lean 4. The `Set.Finite.toFinset` function is used to get the `Finset` that represents the finite set `s`, while `↑` is used to convert this `Finset` back into a set. The theorem ensures the consistency of conversion between sets and `Finset`s for finite sets.

For any finite set `s` of type `α`, the conversion of `s` to a `Finset` and back to a set is equal to the original set `s`.


theorem Quotient.inductionOn₂ :
    ∀ {α : Sort uA} {β : Sort uB} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop}
      (q₁ : Quotient s₁) (q₂ : Quotient s₂), (∀ (a : α) (b : β), motive ⟦a⟧ ⟦b⟧) → motive q₁ q₂ :=
  by sorry

The theorem `Quotient.inductionOn₂` states that for any given sorts `α` and `β`, and for any given setoids `s₁` and `s₂` on these sorts, if we have a property `motive` that relates an element of the quotient set of `s₁` to an element of the quotient set of `s₂`, then if this property holds for all pairs of equivalence classes of `s₁` and `s₂`, it will also hold for any two given equivalence classes `q₁` and `q₂` of `s₁` and `s₂` respectively. In other words, the theorem allows us to perform an induction on pairs of elements from two quotient sets, under the assumption that our inductive property is preserved by the equivalence relations defining the quotient sets.

If `motive` is a relation between equivalence classes of two setoids `s₁` and `s₂`, and `motive` holds for all pairs of equivalence classes if and only if it holds for `q₁` and `q₂`, then `motive` holds for the equivalence classes `q₁` and `q₂` of `s₁` and `s₂` respectively.


theorem Continuous.subtype_mk :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X → Prop} {f : Y → X},
      Continuous f → ∀ (hp : ∀ (x : Y), p (f x)), Continuous fun x => { val := f x, property := ⋯ } :=
  by sorry

This theorem states that for any two types `X` and `Y` with given topological space structures and a predicate `p` on `X`, if a function `f` from `Y` to `X` is continuous and for every element in `Y` the predicate `p` holds true for the image of that element under `f`, then the function that takes an element of `Y` and returns a subtype of `X` with the value being the image of the element under `f` and the property being the satisfaction of the predicate `p` is also continuous.

If `f: Y → X` is a continuous function between topological spaces `X` and `Y` such that `p(x)` holds for all `x ∈ Y` implies `p(f(x))` holds for `p` a predicate on `X`, then the function `g : Y → Subtype X` defined by `g(y) = {x | p(x) and x = f(y)}` is continuous.


theorem map_prod :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommMonoid β] [inst_1 : CommMonoid γ] {G : Type u_6}
      [inst_2 : FunLike G β γ] [inst_3 : MonoidHomClass G β γ] (g : G) (f : α → β) (s : Finset α),
      g (Finset.prod s fun x => f x) = Finset.prod s fun x => g (f x) :=
  by sorry

This theorem, named `map_prod`, states that for any types `α`, `β`, `γ`, and `G`, given that `β` and `γ` are commutative monoids, `G` is a function-like structure from `β` to `γ`, and `G` also forms a monoid homomorphism from `β` to `γ`. If we have a function `g : G`, a function `f : α → β`, and a finite set `s : Finset α`, then applying `g` to the product of the elements in `s` mapped by `f` is the same as the product of the elements in `s` mapped by `g` composed with `f`. In mathematical terms, it states that $g(\prod_{x \in s} f(x)) = \prod_{x \in s} g(f(x))$. This is essentially a property of homomorphisms in the context of commutative monoids.

Given commutative monoids `β` and `γ`, a monoid homomorphism `G : β → γ`, and `f : α → β` and `g : G`, `g(∏ₓ x ∈ s. f x) = ∏ₓ x ∈ s. g(f x)`, where `s : Finset α`.


theorem and_iff_left : ∀ {b a : Prop}, b → (a ∧ b ↔ a) := by sorry

This theorem is stating that for all propositions `a` and `b`, if `b` is true, then `a` and `b` are equivalent to `a`. In other words, when `b` is given to be true, `a ∧ b` (the conjunction of `a` and `b`) and `a` itself express the same truth value. If `a` is true, then `a ∧ b` is also true, and vice versa.

For all propositions `a` and `b`, if `b` is true then `a ∧ b` and `a` are equivalent.


theorem Algebra.algebraMap_eq_smul_one :
    ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
      (algebraMap R A) r = r • 1 :=
  by sorry

This theorem states that for any types `R` and `A`, where `R` is a commutative semiring and `A` is a semiring with an algebra structure over `R`, and for any element `r` in `R`, the algebra map (which is the embedding of `R` into `A` defined by the algebra structure) of `r` is equal to `r` times the multiplicative identity element in `A`. In mathematical terms, this means that for any `r` in `R`, we have that `algebraMap R A r = r * 1_A`, where `1_A` denotes the multiplicative identity in `A`.

For any commutative semiring `R` and semiring `A` with an algebra structure over `R`, the algebra map embeds each element `r` in `R` as `r * 1_A` in `A`.


IsCompact.image

theorem IsCompact.image :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      IsCompact s → Continuous f → IsCompact (f '' s) :=
  by sorry

The theorem `IsCompact.image` states that for any two topological spaces `X` and `Y`, a set `s` from `X`, and a function `f` from `X` to `Y`, if the set `s` is compact and the function `f` is continuous, then the image of the set `s` under the function `f` is also compact. In mathematical terms, if \(s\) is a compact set in a topological space \(X\) and \(f: X \to Y\) is a continuous function, then \(f(s)\) is a compact set in the topological space \(Y\).

If a compact set in a topological space is mapped by a continuous function to another topological space, the image is also a compact set.


theorem Measurable.prod_mk :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {β : Type u_6} {γ : Type u_7} {x : MeasurableSpace β}
      {x_1 : MeasurableSpace γ} {f : α → β} {g : α → γ}, Measurable f → Measurable g → Measurable fun a => (f a, g a) :=
  by sorry

The `Measurable.prod_mk` theorem states that for any two measurable functions, `f` mapping from type `α` to `β` and `g` mapping from `α` to `γ`, if both `f` and `g` are measurable functions, then a function that takes an element of type `α` and returns a pair consisting of the images of this element under `f` and `g` is also a measurable function. Here, measurability of a function is defined in the sense that the preimage of any measurable set under the function is also a measurable set.

If `f : α → β` and `g : α → γ` are measurable functions, then the function `x ↦ (f x, g x)` from `α` to `β × γ` is measurable.


theorem inv_mul_cancel_right : ∀ {G : Type u_1} [inst : Group G] (a b : G), a * b⁻¹ * b = a := by sorry

This theorem states that for any group `G` and any elements `a` and `b` of that group, if you multiply `a` by the inverse of `b` and then by `b` itself, you get back `a`. This is a property of group theory where the multiplication of an element and its inverse gives the identity element, so multiplying by the inverse and the element itself is effectively doing nothing. In mathematical terms, this theorem establishes that `a * b⁻¹ * b = a` for all `a` and `b` in any group `G`.

For all groups G, elements a and b in G, a * b⁻¹ * b = a.


theorem Set.image_comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β → γ) (g : α → β) (a : Set α), f ∘ g '' a = f '' (g '' a) := by
  sorry

The theorem `Set.image_comp` states that for all types `α`, `β`, and `γ`, and for all functions `f : β → γ` and `g : α → β`, and a set `a` of type `α`, the image of the composition of `f` and `g` on the set `a` is equal to the image of `f` on the image of `g` on the set `a`. In mathematical terms, this theorem is about the associativity of function composition and image generation: $(f \circ g)(A) = f(g(A))$ where $f : \beta \rightarrow \gamma$, $g : \alpha \rightarrow \beta$, and $A$ is a set of type $\alpha$.

For all sets `α`, `β`, `γ`, functions `f : β → γ` and `g : α → β`, and sets `a : α`, the image of `f` composed with `g` on the set `a` equals the image of `f` applied to the image of `g` on `a`. In mathematical notation: `(∘)<^> image g a = image (f ∘ g) a`.


theorem List.mem_cons_self : ∀ {α : Type u_1} (a : α) (l : List α), a ∈ a :: l := by sorry

This theorem, `List.mem_cons_self`, states that for any type of data `α` and for any element `a` of this type and any list `l` of elements of this type, `a` is an element of the list that results from prepending `a` to `l`. In other words, an element is always a member of the list obtained by adding it to the front of any other list.

For any type `α` and any `α` element `a` and list `l` of length `n+1` elements of type `α`, `a` is in the list `[a] :: l` if and only if `a` is in `l`.


theorem Finset.mem_insert_self : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), a ∈ insert a s := by
  sorry

The theorem `Finset.mem_insert_self` states that for any type `α` with decidable equality (represented by `[inst : DecidableEq α]`), for any element `a` of type `α`, and for any finite set `s` of elements of the same type `α` (represented by `s : Finset α`), `a` is a member of the set obtained by inserting `a` into `s`. In other words, if you insert an element into a finite set, the resulting set definitely contains that element.

For any type `α` with decidable equality and any finite set `s` of elements from `α`, the inserted element `a` is an element of the set `Finset.insert a s`.


theorem Mathlib.Data.Finset.Basic._auxLemma.6 : ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) := by sorry

This theorem, from the `Mathlib.Data.Finset.Basic` library, states that for any type `α`, any element `a` of type `α`, and any finite set `s` of elements of type `α`, the condition "`a` belongs to the underlying set of `s`" is equivalent to the condition "`a` belongs to `s`". In mathematical terms, it says that an element being in a finite set is the same as it being in the set's underlying set. It means that the element's presence in the finset is not affected by its implementation details.

For any type `α`, any element `a` of type `α`, and any finite set `s` of elements of type `α`, `a` is in the underlying set of `s` if and only if `a` is in `s`.


theorem subset_refl : ∀ {α : Type u} [inst : HasSubset α] [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1] (a : α), a ⊆ a := by
  sorry

This theorem, named `subset_refl`, states that for any type `α` that has a subset operation and is reflexive with respect to subset operation, any element `a` of type `α` is a subset of itself. In mathematical terms, it expresses the reflexivity of set inclusion: for any set `a`, `a` is included in `a`.

For any type `α` with a reflexive subset relation, every element `a` in `α` is a subset of `{a}`.


theorem Mathlib.Init.Order.Defs._auxLemma.2 : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) := by
  sorry

This theorem, `Mathlib.Init.Order.Defs._auxLemma.2`, states that for every type `α` that has a linear order, for any two elements `a` and `b` of type `α`, the statement "it's not true that `a` is less than or equal to `b`" is equivalent to " `b` is strictly less than `a`". In other words, `a` not being less than or equal to `b` is the same as saying `b` is less than `a`. This theorem captures one of the fundamental properties of ordered sets.

For any type `α` with a linear order, `a` not less than or equal to `b` is equivalent to `b` being strictly less than `a`.


theorem Mathlib.Init.Order.Defs._auxLemma.1 : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) := by
  sorry

This theorem states that for any type `α` that has a linear order, and for any two elements `a` and `b` of this type, the statement "not `a` is less than `b`" is equivalent to the statement "`b` is less than or equal to `a`". In mathematical notation, this can be written as ¬(a < b) ↔ (b ≤ a). This is a fundamental property of linearly ordered sets.

The negation of the linear order relation between two elements is equivalent to the reverse order relation in a linearly ordered type. (or) In a linearly ordered type, `a` and `b` are not ordered `<` if and only if `b` is ordered `≤` or `a`.


theorem Filter.Tendsto.mono_left :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x y : Filter α} {z : Filter β},
      Filter.Tendsto f x z → y ≤ x → Filter.Tendsto f y z :=
  by sorry

The theorem `Filter.Tendsto.mono_left` states that for all types `α` and `β`, for all functions `f` mapping from `α` to `β`, and for all filters `x`, `y` on `α` and a filter `z` on `β`, if `f` tends to filter `z` via filter `x`, and filter `y` is less or equal to filter `x`, then `f` also tends to filter `z` via filter `y`. In other words, it states that if `f` is converging with respect to a larger filter, it also converges with respect to any of its smaller subfilters.

If `f` tends to filter `z` via filter `x`, and `x` is a subset of `y`, then `f` tends to filter `z` via filter `y`.


theorem dvd_mul_right : ∀ {α : Type u_1} [inst : Semigroup α] (a b : α), a ∣ a * b := by sorry

This theorem, named `dvd_mul_right`, asserts that for any type `α` that forms a semigroup, any element `a` of this type divides the product of `a` and any other element `b` of the same type. In other words, if we multiply `a` by any other element of the semigroup, that result is a multiple of `a` (or, `a` is a factor of `a*b`). This holds true for all elements `a` and `b` in the semigroup.

For any semigroup type `α` and elements `a, b` in `α`, `a` divides the product `a * b`.


ContinuousOn.mono

theorem ContinuousOn.mono :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s t : Set α},
      ContinuousOn f s → t ⊆ s → ContinuousOn f t :=
  by sorry

This theorem states that for any two types `α` and `β` with topological space structures, and a function `f` from `α` to `β`, if `f` is continuous on a set `s` of `α`, and `t` is a subset of `s`, then `f` is also continuous on `t`. In mathematical terms, this expresses the idea that the continuity of a function on a set implies its continuity on all subsets of that set.

If `f` is a continuous function from topological space `α` to topological space `β`, and `s` is a subset of `α`, then `f` restricted to `s` is continuous.


theorem Filter.basis_sets : ∀ {α : Type u_1} (l : Filter α), Filter.HasBasis l (fun s => s ∈ l) id := by sorry

This theorem states that for any filter `l` on a type `α`, the filter has a basis consisting of its own sets. In other words, each set `s` in the filter `l` can be considered a part of the basis for constructing that filter. Here, `Filter.HasBasis l (fun s => s ∈ l) id` means that the filter `l` has a basis where each set is an element of the filter, and the index set is just the identity function.

Every filter on a type has itself as its basis.


theorem LinearMap.map_zero :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      (f : M →ₛₗ[σ] M₃), f 0 = 0 :=
  by sorry

This theorem states that for all semirings R and S, with additive commutative monoids M and M₃, and modules M over R and M₃ over S, and for a ring homomorphism σ from R to S, a linear map f from M to M₃ (preserving the structure of the module under the ring homomorphism σ) sends the zero vector of M to the zero vector of M₃. In other words, every linear map maps the zero vector from its domain to the zero vector in its codomain.

For any semirings R and S, ring homomorphism σ from R to S, and linear maps f from an additive commutative M-module M to an S-module M₃, if f preserves the module structure under σ, then f maps the zero vector of M to the zero vector of M₃.


theorem mul_inv_cancel_left : ∀ {G : Type u_1} [inst : Group G] (a b : G), a * (a⁻¹ * b) = b := by sorry

This theorem states that for any given group `G`, and for any elements `a` and `b` from this group, the product of `a` and the result of the multiplication of the inverse of `a` (`a⁻¹`) with `b` is equal to `b`. In mathematical terms, we could express this as: for any `a`, `b` in a group `G`, `a * (a⁻¹ * b) = b`. This theorem is essentially about the 'cancellation' property in group theory, which allows one to simplify expressions by 'canceling out' terms.

In any group, for all elements `a` and `b`, `a * (a⁻¹ * b) = b`.


theorem Mathlib.Data.Finset.Image._auxLemma.25 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
      (b ∈ Finset.image f s) = ∃ a ∈ s, f a = b :=
  by sorry

This theorem, `Mathlib.Data.Finset.Image._auxLemma.25`, states that for any types `α` and `β`, where `β` has decidable equality, a function `f` from `α` to `β`, a finite set `s` of type `α`, and an element `b` of type `β`, `b` is in the image of `s` under `f` if and only if there exists an element `a` in `s` such that `f(a)` equals `b`. In other words, an element is in the image of a set under a function if and only if it is the output of the function applied to an element of the original set.

For any type `α`, `β` with decidable equality, and a function `f` from `α` to `β`, an element `b` is in the image of a finite set `s` of type `α` under `f` if and only if there exists an element `a` in `s` such that `f(a) = b`.


theorem Complex.ofReal_mul : ∀ (r s : ℝ), ↑(r * s) = ↑r * ↑s := by sorry

This theorem states that for any two real numbers `r` and `s`, the complex representation of their product is equal to the product of their complex representations. In other words, if you multiply two real numbers and then convert the result to a complex number, you'll get the same result as if you converted the two real numbers to complex numbers first and then multiplied them together. This is written in mathematical notation as: ∀ (r s : ℝ), ↑(r * s) = ↑r * ↑s.

For all real numbers r and s, the complex number representation of their product equals the product of their individual complex number representations. (i.e., ∀ (r s : ℝ), ↑(r * s) = ↑r * ↑s)


theorem add_neg_cancel_left : ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), a + (-a + b) = b := by sorry

This theorem states that for any type `G` that has the structure of an add group, for any elements `a` and `b` of `G`, adding `a` to the result of adding the negation of `a` to `b` will always equal `b`. In mathematical terms, it says that for any elements `a` and `b` in an additive group, the equation `a + (-a + b) = b` always holds, demonstrating the cancellation property of the negation in the group.

For any add group `G` and elements `a, b` in `G`, `a + (-a + b) = b`.


theorem inv_pos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 < a⁻¹ ↔ 0 < a := by sorry

This theorem states that for any type `α` that forms a `LinearOrderedSemifield`, the reciprocal of a given element `a` of `α` is greater than zero if and only if `a` is greater than zero. In mathematical terms, for any real number `a`, `0 < 1/a` is true if and only if `0 < a` is true.

For any type `α` that is a LinearOrderedSemifield, `0 < a` implies `0 < 1/a`.


theorem Multiset.map_cons :
    ∀ {α : Type u_1} {β : Type v} (f : α → β) (a : α) (s : Multiset α),
      Multiset.map f (a ::ₘ s) = f a ::ₘ Multiset.map f s :=
  by sorry

The theorem `Multiset.map_cons` states that for all types `α` and `β`, for any function `f` from `α` to `β`, for any element `a` of type `α`, and for any multiset `s` of type `α`, mapping function `f` over a multiset that has `a` consed to `s` (`a ::ₘ s`) is the same as consing the function `f` applied to `a` to the multiset obtained by mapping `f` over `s` (i.e., `f a ::ₘ Multiset.map f s`). In other words, it asserts that the `map` operation distributes over the `cons` operation for multisets. This is an analogue to the familiar property in list theory where mapping a function over a list that has an element consed to it is equivalent to consing the function applied to the element to the mapped list.

For all types `α` and `β`, and functions `f` from `α` to `β`, the operation of mapping `f` over a multiset `s` and consing `f(a)` to the result is equivalent to consing `a` to the multiset obtained by mapping `f` over `s`. In symbols, `(∀αβ (f : α → β) (a : α) (s : MultiSet α), f a ::ₘ (Multiset.map f s) ≡ a ::ₘ (Multiset.map f (s : MultiSet α)))`.


Filter.EventuallyEq.trans

theorem Filter.EventuallyEq.trans :
    ∀ {α : Type u} {β : Type v} {l : Filter α} {f g h : α → β}, f =ᶠ[l] g → g =ᶠ[l] h → f =ᶠ[l] h := by sorry

This theorem, `Filter.EventuallyEq.trans`, states that for any given types `α` and `β`, any filter `l` on type `α`, and any three functions `f`, `g`, and `h` from `α` to `β`, if `f` is eventually equal to `g` with respect to the filter `l`, and `g` is eventually equal to `h` with respect to the same filter `l`, then `f` is eventually equal to `h` with respect to filter `l`. This is a transitivity property of the "eventually equal" relation in the context of filters.

If filters `l` on types `α` make functions `f` and `g` from `α` to `β` eventually equal, then `f` and `h` are eventually equal with respect to filter `l` if `g` is eventually equal to `h` with respect to `l`.


theorem ite_self : ∀ {α : Sort u} {c : Prop} {d : Decidable c} (a : α), (if c then a else a) = a := by sorry

This theorem, denoted as `ite_self`, states that for any type `α`, any proposition `c`, any decidable condition `d` derived from `c`, and any element `a` of type `α`, the result of the 'if-then-else' operation (`if c then a else a`) is always equal to `a` itself, regardless of whether condition `c` is true or false. In simpler terms, if the two outcomes of an 'if-then-else' operation are the same, then the operation is equivalent to that outcome.

For any type `α`, proposition `c` over `α`, decidable `d` derived from `c`, and `a` : `α`, `if c then a else a` equals `a`.


theorem Finset.card_map : ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} (f : α ↪ β), (Finset.map f s).card = s.card :=
  by sorry

This theorem states that for any given types `α` and `β`, given a finset `s` of type `α` and an embedding function `f` from `α` to `β`, the cardinality (or the number of elements) in the finset obtained by mapping `s` through `f` is the same as the cardinality of `s` itself. This is because `f` is an embedding function, ensuring that there are no duplicates in the resultant finset, hence preserving the number of elements.

For any finset `s` of type `α` and embedding function `f` from `α` to `β`, the cardinality of `s` equals the cardinality of the image `f''(s)`.


theorem Mathlib.Data.Set.Defs._auxLemma.2 : ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any element `x` of type `α`, the statement "x is in the complement of set s" is equivalent to the statement "x is not in set s". Here, the complement of a set `s` (denoted as `sᶜ` in Lean 4) consists of all elements in the universal set (which includes all possible elements of type `α`) that are not in `s`. In mathematical notation, this can be expressed as `x ∈ sᶜ ⟺ x ∉ s`.

For any type `α` and set `s` of type `α`, the element `x` is in the complement of `s` if and only if `x` is not in `s`. In Lean 4 notation, `x ∈ sᶜ ↔ x ∉ s`.


/-- One of **de Morgan's laws**: the negation of a conjunction is logically equivalent to the
disjunction of the negations.  -/
theorem not_and_or : ∀ {a b : Prop}, ¬(a ∧ b) ↔ ¬a ∨ ¬b := by sorry

This theorem is one of De Morgan's laws, stating that the negation of a conjunction between two propositions is logically equivalent to the disjunction of the negations of those two propositions. In other words, for any two properties 'a' and 'b', the proposition "not (a and b)" is equivalent to the proposition "not a or not b".

The negation of the conjunction of propositions a and b is logically equivalent to the disjunction of their negations.


theorem List.reverse_cons : ∀ {α : Type u} (a : α) (as : List α), List.reverse (a :: as) = List.reverse as ++ [a] := by
  sorry

The theorem `List.reverse_cons` states that for any type `α` and any element `a` of type `α` and list `as` of type `List α`, the reverse of the list obtained by prepending `a` to `as` is equal to the concatenation of the reverse of `as` and the list containing `a` as its only element. In other words, reversing a list where an element is added at the beginning results in the reversed original list followed by the added element.

For any type `α` and any element `a` of type `α` and list `as` of type `List α`, `List.reverse (a :: as) = List.reverse as ++ [a]`.


theorem iff_true : ∀ (p : Prop), (p ↔ True) = p := by sorry

This theorem states that for any proposition `p`, the equivalence of `p` and `True` is the same as `p` itself. In other words, it asserts that if we have a logical equivalence (represented by the ↔ symbol) between any proposition and the truth value `True`, this is logically identical to the original proposition `p`. This is consistent with the intuitive understanding of truth in logic, since any statement that is equivalent to `True` must be true itself.

For any proposition `p` in Lean, `p ↔ True` is logically equivalent to `p`.


theorem Set.indicator_of_not_mem :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {a : α},
      a ∉ s → ∀ (f : α → M), Set.indicator s f a = 0 :=
  by sorry

The theorem `Set.indicator_of_not_mem` states that for any set `s` of elements of type `α`, any function `f` from `α` to `M` and any element `a` of type `α`, if `a` is not a member of `set s`, then the set indicator of `s`, `f`, and `a` equals `0`. Here, the set indicator of `s`, `f`, and `a` is defined as `f a` if `a` is in the set `s` and `0` otherwise. In other words, the theorem expresses that if an element does not belong to a specific set, the set indicator function for that element and set returns zero. This is a property of the set indicator function in the context of mathematical set theory.

For any set `s` of type `α`, any function `f : α → M`, and any `a : α`, if `a` is not in `s`, then `f a = 0`.


AlgHom.commutes

theorem AlgHom.commutes :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (r : R),
      φ ((algebraMap R A) r) = (algebraMap R B) r :=
  by sorry

The theorem `AlgHom.commutes` states that for all commutative semirings `R` and semirings `A` and `B`, equipped with an algebra structure over `R`, and for every algebra homomorphism `φ` from `A` to `B`, the application of `φ` after mapping an element `r` from `R` to `A` via the `algebraMap` is the same as directly mapping the element `r` to `B` via the `algebraMap`. In other words, given any element in the base ring, the algebra homomorphism from `A` to `B` commutes with the algebra maps from `R` to `A` and `R` to `B`. This can be written in mathematical notation as `φ(algebraMap(R,A)(r)) = algebraMap(R,B)(r)` for all `r` in `R`.

For every commutative semiring homomorphism φ between algebra structures over a commutative semiring R, and for all elements r in R, φ(α(r)) = α'(r), where α and α' denote the algebra maps from R to the respective algebra structures.


HasFDerivAt.differentiableAt

theorem HasFDerivAt.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E}, HasFDerivAt f f' x → DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `HasFDerivAt.differentiableAt` states that for any non-trivially normed field `𝕜`, if a function `f` from a normed additive commutative group `E` to another such group `F` (both of which are normed over `𝕜`) has a continuous linear map `f'` as its derivative at a point `x` in `E`, then the function `f` is differentiable at the point `x`. In other words, if `f` satisfies the condition `f x' = f x + f' (x' - x) + o (x' - x)` as `x'` tends to `x`, then `f` is differentiable at `x`.

If a function between two normed additive commutative groups over a non-trivially normed field has a continuous linear derivative at a point, then the function is differentiable at that point.


NeZero.ne

theorem NeZero.ne : ∀ {R : Type u_1} [inst : Zero R] (n : R) [h : NeZero n], n ≠ 0 := by sorry

This theorem, `NeZero.ne`, states that for any type `R` that has a zero element, any element `n` of `R` that is not zero, denoted by the property `NeZero n`, is not equal to zero. Here, `NeZero n` is a way of saying that `n` is non-zero, and `n ≠ 0` asserts that `n` is not equal to the zero element of `R`. In more traditional mathematical notation, this would read as "for all n in R, where R is any type with a zero, if n is not zero, then n is not equal to zero".

For any type `R` with a zero element, every non-zero element `n` in `R` is distinct from the zero element.


theorem nhds_prod_eq :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x : X} {y : Y},
      nhds (x, y) = nhds x ×ˢ nhds y :=
  by sorry

This theorem states that for any two types X and Y which both have a topological space structure, and for any elements x of X and y of Y, the neighborhood filter of the pair (x, y) in the product topology is equal to the product of the neighborhood filter of x and the neighborhood filter of y. This theorem is a fundamental property of product topologies in topology.

For any topological spaces X and Y, and any x in X and y in Y, the neighborhood filter of the pair (x, y) in the product topology is equal to the product of the neighborhood filters of x in X and y in Y.


theorem Set.image_preimage_eq_inter_range :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {t : Set β}, f '' (f ⁻¹' t) = t ∩ Set.range f := by sorry

This theorem asserts that for any types `α` and `β`, and any function `f` from `α` to `β`, and any set `t` of `β`, the image under `f` of the preimage of `t` under `f` equals the intersection of `t` and the range of `f`. In other words, the set of all images under `f` of elements that map to `t` when `f` is applied, coincides with the set of elements that are both in `t` and in the range of `f`.

For any function `f` from type `α` to type `β` and any subset `t` of `β`, the image of the inverse image of `t` under `f` equals the intersection of `t` and the range of `f`.


theorem Nat.le_of_lt_succ : ∀ {m n : ℕ}, m < Nat.succ n → m ≤ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` is less than the successor of `n` (in other words, `m` is less than `n+1`), then `m` is less than or equal to `n`. It essentially formalizes the intuitive fact that if a number is less than the next number after another, it must be less than or equal to that other number.

If `m` is less than `n+1`, then `m` is less than or equal to `n`.


/-- We make this the simp lemma instead of `range_coe`. The reason is that if we write
for `s : Set α` the function `(↑) : s → α`, then the inferred implicit arguments of `(↑)` are
`↑α (fun x ↦ x ∈ s)`.  -/
theorem Subtype.range_coe_subtype : ∀ {α : Type u_1} {p : α → Prop}, Set.range Subtype.val = {x | p x} := by sorry

This theorem, `Subtype.range_coe_subtype`, states that for any type `α` and any proposition `p` that is a property of elements of `α`, the range of the function `Subtype.val` (which maps each subtype of `α` satisfying the property `p` to `α`) is exactly the set of elements of `α` that satisfy the property `p`. In other words, by mapping through `Subtype.val`, we recover exactly the set of elements in `α` that satisfy the property `p`. This theorem is marked as a simplification lemma, meaning that Lean's simplifier will use it to automatically simplify expressions in proofs.

The `Subtype.range_coe_subtype` theorem in Lean asserts that the range of the function `Subtype.val` from subtypes of a type `α` satisfying a property `p` is equal to the set of elements in `α` that satisfy `p`.


theorem CategoryTheory.Functor.image_preimage :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [inst_2 : CategoryTheory.Full F]
      {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (F.preimage f) = f :=
  by sorry

This theorem states that for any two objects `X` and `Y` in a category `C`, and a functor `F` from `C` to another category `D`, if there exists a morphism `f` from `F.obj X` to `F.obj Y` in `D`, then the mapping of the preimage of `f` under `F` is equal to `f` itself. Here, `F` is a fully faithful functor, meaning it fully and faithfully preserves the morphisms of the category. The theorem verifies this property by showing the preservation of morphism `f` through its preimage and mapping.

For any fully faithful functor F from category C to D and any morphism f in D from F(X) to F(Y) in D, the preimage of f under F equals f itself.


theorem or_comm : ∀ {a b : Prop}, a ∨ b ↔ b ∨ a := by sorry

This theorem, `or_comm`, states that for all propositions `a` and `b`, the logical disjunction `a ∨ b` (read as "a or b") is logically equivalent to `b ∨ a` (read as "b or a"). In other words, the order of the propositions in a disjunction operation does not affect the truth value of the disjunction, making the operation commutative.

For all propositions `a` and `b`, the logical disjunction `a ∨ b` is equivalent to `b ∨ a`.


/-- Ring homomorphisms preserve addition.  -/
theorem RingHom.map_add :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β) (a b : α),
      f (a + b) = f a + f b :=
  by sorry

This theorem, named `RingHom.map_add`, states that for any two types `α` and `β` which are non-associative semirings, and for any ring homomorphism `f` from `α` to `β`, the homomorphism preserves the addition operation. More formally, for any two elements `a` and `b` of `α`, the image of their sum under `f` is equal to the sum of their individual images under `f`. In mathematical terms, for all `a, b` in `α`, `f(a + b) = f(a) + f(b)`. This property is one of the defining characteristics of a ring homomorphism.

Given any ring homomorphism `f` between non-associative semirings `α` and `β`, `f(a + b) = f(a) + f(b)` for all `a, b` in `α`.


theorem isOpen_univ : ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen Set.univ := by sorry

The theorem `isOpen_univ` states that for any type `X` that has a topological space structure, the universal set on `X` is open in the corresponding topological space. In other words, the set of all elements of `X` is an open set, as per the definition of openness in the given topological space on `X`. This is a universal property, valid for any topological space.

The universal set of any topological space is open in that space.


Disjoint.symm

theorem Disjoint.symm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] ⦃a b : α⦄, Disjoint a b → Disjoint b a := by sorry

This theorem states that the Disjoint property in a lattice is symmetric for any two elements. In other words, for any type `α` that has a partial order and a bottom element, if two elements `a` and `b` are Disjoint (i.e., their greatest lower bound is the bottom element), then `b` and `a` are also Disjoint.

For any lattice with bottom element, if elements `a` and `b` are Disjoint, then `b` and `a` are also Disjoint.


theorem sub_pos :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      0 < a - b ↔ b < a :=
  by sorry

This theorem, named `sub_pos`, states that, for any type `α` that has an addition operation (determined by `AddGroup α`), a less than relation (`LT α`), and the operation `+` and relation `<` are compatible with each other (ensured by `CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1`), the difference of two elements `a` and `b` (represented as `a - b`) is greater than zero if and only if `b` is less than `a`. This theorem is a formal statement of a common property of ordered groups.

For any additive group `α`, if `a` and `b` are its elements with `a > b`, then `a - b > 0`.


theorem Filter.map_map :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {m : α → β} {m' : β → γ},
      Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f :=
  by sorry

The theorem `Filter.map_map` states that for any types `α`, `β`, and `γ`, and for any filter `f` on `α` and any functions `m : α → β` and `m' : β → γ`, applying the function `m'` to the filter resulting from applying `m` to `f` is the same as applying the function `m' ∘ m` to the filter `f`. This is essentially a statement of function composition in the context of filter maps, and captures the intuition that the order of applying filter maps doesn't matter if we adjust the functions accordingly.

Given filters `f` on type `α`, functions `m : α → β` and `m' : β → γ`, the application of `m'` to the filter obtained by applying `m` to `f` is equivalent to the application of `m' ∘ m` to `f`.


theorem MeasureTheory.ae_of_all :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop} (μ : MeasureTheory.Measure α),
      (∀ (a : α), p a) → ∀ᵐ (a : α) ∂μ, p a :=
  by sorry

This theorem, `MeasureTheory.ae_of_all`, states that for any measurable space `α` and any property `p` on `α`, if every element in `α` satisfies the property `p`, then `p` holds almost everywhere with respect to the measure `μ`. In other words, any property that is true for every point in a given measurable space is also true almost everywhere under any measure applied to that space. "Almost everywhere" means that the set of points where the property is not true is of measure zero.

If every point in a measurable space carries a measurable property and the set of points where the property doesn't hold has measure zero, then the property holds almost everywhere.


theorem not_or : ∀ {p q : Prop}, ¬(p ∨ q) ↔ ¬p ∧ ¬q := by sorry

This theorem, `not_or`, states that for all propositions `p` and `q`, the negation of the disjunction `p ∨ q` is equivalent to the conjunction of the negations `¬p ∧ ¬q`. In simpler terms, it means that "not (p or q)" is the same as "not p and not q". This is a fundamental principle in classical logic known as De Morgan's laws.

The negation of the disjunction of propositions `p` and `q` is equivalent to the conjunction of their negations, i.e., `¬(p ∨ q) ≡ ¬p ∧ ¬q`.


theorem lt_add_one :
    ∀ {α : Type u_1} [inst : One α] [inst_1 : AddZeroClass α] [inst_2 : PartialOrder α] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1] [inst_5 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α),
      a < a + 1 :=
  by sorry

This theorem, `lt_add_one`, states that for any element `a` of a certain type `α`, `a` is less than `a` plus one. The type `α` has certain properties enforced by the provided typeclasses: it has an element considered as "one" (`One α`), it supports addition with zero (`AddZeroClass α`), it has a partial order defined (`PartialOrder α`), zero is less than or equal to one (`ZeroLEOneClass α`), one is not zero (`NeZero 1`), and the addition operation is covariant, meaning that if `x < y` then `x + z < y + z` for any `z` (`CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1`).

For any element `a` of type `α` with properties `One α`, `AddZeroClass α`, `PartialOrder α`, `ZeroLEOneClass α`, and `NeZero 1`, and covariant addition, we have `a < a + One α`.


theorem heq_of_eq : ∀ {α : Sort u} {a a' : α}, a = a' → HEq a a' := by sorry

This theorem, `heq_of_eq`, states that for any given type `α` and any two elements `a` and `a'` of that type, if `a` is equal to `a'` (denoted as `a = a'`), then `a` and `a'` are heterogeneously equal (denoted as `HEq a a'`). Here, "heterogeneously equal" means that the elements are equal, even if they may have different types, which in this specific theorem, they do not since they are both of the same type `α`. This theorem therefore establishes a direct connection between the normal equality and heterogeneous equality in Lean.

For all types `α` and elements `a` and `a'` of type `α`, if `a` equals `a'` (`a = a'`), then `a` is heterogeneously equal to `a'` (`HEq a a'`).


theorem pow_ne_zero :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} [inst_1 : NoZeroDivisors M₀] (n : ℕ), a ≠ 0 → a ^ n ≠ 0 := by
  sorry

This theorem states that for any non-zero element `a` of a given type `M₀` (which forms a Monoid with zero and has no zero divisors), the power of `a` raised to any natural number `n` is not equal to zero. This means, in such a structure, a non-zero element raised to any power never results in zero.

For any non-zero element `a` in a Monoid `M₀` without zero divisors, `a^n ≠ 0` for all natural numbers `n`.


theorem closure_minimal :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], s ⊆ t → IsClosed t → closure s ⊆ t := by sorry

The theorem `closure_minimal` states that for any type `X` with a topology (denoted by `inst : TopologicalSpace X`), and any two sets `s` and `t` of type `X`, if `s` is a subset of `t` and `t` is a closed set, then the closure of set `s` is also a subset of `t`. In other words, in a topological space, the closure of a set is always contained within any closed set that contains the original set.

If `s` is a subset of a closed set `t` in a topological space `X`, then the closure of `s` is contained in `t`.


ContinuousLinearMap.ext

theorem ContinuousLinearMap.ext :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
      [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
      [inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {f g : M₁ →SL[σ₁₂] M₂},
      (∀ (x : M₁), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous linear maps `f` and `g` from a module `M₁` over a semiring `R₁` to a module `M₂` over a semiring `R₂`, under a specific ring homomorphism `σ₁₂` from `R₁` to `R₂`, if `f` and `g` are equal at all points `x` in `M₁`, then `f` and `g` themselves are equal. This theorem basically guarantees the extensionality of continuous linear maps, meaning that two continuous linear maps are equal if they are equal on every element of their domain.

Given continuous linear maps `f` and `g` from module `M₁` over semiring `R₁` to module `M₂` over semiring `R₂`, and a ring homomorphism `σ₁₂` from `R₁` to `R₂`, if `f(x) = g(x)` for all `x` in `M₁`, then `f = g`.


theorem neg_add_cancel_left : ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), -a + (a + b) = b := by sorry

This theorem, `neg_add_cancel_left`, states that for any type `G` that is an additive group, and for any two elements `a` and `b` of this type `G`, the result of adding the additive inverse of `a` to the sum of `a` and `b` is always equal to `b`. In mathematical terms, it states that for all `a` and `b` in an additive group, `-a + (a + b) = b`. This is essentially an application of the additive inverse property in group theory.

For all additive groups `G`, and elements `a` and `b` in `G`, the additive inverse of `a` combined with `a` and `b` equals `b`, i.e., `-a + (a + b) = b`.


theorem Set.mem_setOf_eq : ∀ {α : Type u} {x : α} {p : α → Prop}, (x ∈ {y | p y}) = p x := by sorry

This theorem states that for any type `α`, any element `x` of type `α`, and any predicate `p` over `α`, the statement "`x` belongs to the set of all elements `y` of type `α` for which the predicate `p` holds" is logically equivalent to the statement "the predicate `p` holds for `x`". In other words, the element `x` is in the set defined by the condition `p` if and only if `x` itself satisfies the condition `p`.

For any type `α`, element `x` of type `α`, and predicate `p` over `α`, `x` belongs to the set of elements satisfying `p` if and only if `p` holds for `x`.


theorem Mathlib.Data.Set.Defs._auxLemma.9 :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) := by sorry

This theorem states that for any sets `s` of type `α` and `t` of type `β`, and any ordered pair `p` of type `α × β`, the pair `p` is in the Cartesian product of the sets `s` and `t` (denoted as `s ×ˢ t`) if and only if the first element of the pair `p` is in the set `s` and the second element of `p` is in the set `t`.

For any sets `α`, `β`, `s` of type `α`, and `t` of type `β`, the ordered pair `p` belongs to the Cartesian product `s × βt` if and only if its first component `p.1` belongs to `s` and its second component `p.2` belongs to `t`.


theorem Int.mul_comm : ∀ (a b : ℤ), a * b = b * a := by sorry

This theorem, `Int.mul_comm`, states that for all integers `a` and `b`, the multiplication of `a` and `b` is commutative. In other words, multiplying `a` by `b` is the same as multiplying `b` by `a`.

For all integers `a` and `b`, `a * b` equals `b * a`.


theorem StrictMono.le_iff_le :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono f → ∀ {a b : α}, f a ≤ f b ↔ a ≤ b :=
  by sorry

This theorem states that for all types `α` and `β`, if `α` is a linearly ordered type and `β` is a preordered type, and if we have a function `f` from `α` to `β` that is strictly monotone, then for all elements `a` and `b` of `α`, the function `f` applied to `a` is less than or equal to `f` applied to `b` if and only if `a` is less than or equal to `b`. In other words, a strictly monotone function preserves the order relation from its domain to its codomain.

A strictly monotone function from a linearly ordered type to a preordered type preserves the order relation.


Or.symm

theorem Or.symm : ∀ {a b : Prop}, a ∨ b → b ∨ a := by sorry

This theorem, `Or.symm`, states that for all propositions `a` and `b`, if `a` or `b` is true then `b` or `a` is also true. In other words, the disjunction (logical "or") operation is symmetric, meaning that the order of the propositions doesn't affect the truth value of the disjunction.

For all propositions `a` and `b`, `a ∨ b` is equivalent to `b ∨ a`.


UniformContinuous.comp

theorem UniformContinuous.comp :
    ∀ {α : Type ua} {β : Type ub} {γ : Type uc} [inst : UniformSpace α] [inst_1 : UniformSpace β]
      [inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
      UniformContinuous g → UniformContinuous f → UniformContinuous (g ∘ f) :=
  by sorry

The theorem `UniformContinuous.comp` states that for any three types `α`, `β`, and `γ`, each equipped with a uniform space structure (`UniformSpace α`, `UniformSpace β`, `UniformSpace γ` respectively), if a function `g` from `β` to `γ` is uniformly continuous, and a function `f` from `α` to `β` is uniformly continuous, then the composition of `g` and `f` (denoted by `g ∘ f`) is also uniformly continuous. In other words, the property of uniform continuity is preserved under function composition.

If functions `f : α → β` and `g : β → γ` are uniformly continuous, then their composition `g ∘ f : α → γ` is also uniformly continuous.


theorem Tactic.Elementwise.hom_elementwise :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.ConcreteCategory C]
      {X Y : C} {f g : X ⟶ Y}, f = g → ∀ (x : (CategoryTheory.forget C).obj X), f x = g x :=
  by sorry

This theorem, `Tactic.Elementwise.hom_elementwise`, states that for any concrete category `C`, given two morphisms `f` and `g` from object `X` to object `Y` in `C`, if `f` and `g` are equal, then the action of `f` and `g` on any element `x` of the type associated to `X` by the forgetful functor from `C` to `Type` are also equal. In simpler terms, if two morphisms are equal, then their action on any element of the object they originate from is also equal.

If morphisms `f` and `g` in category `C` from object `X` to object `Y` are equal, then for all `x : X`, `f x = g x`.


theorem Finset.mem_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
      b ∈ Finset.image f s ↔ ∃ a ∈ s, f a = b :=
  by sorry

The theorem `Finset.mem_image` states that for any types `α` and `β`, given a decidable equality on `β`, a function `f` from `α` to `β`, a finite set `s` of type `α`, and an element `b` of type `β`, `b` is in the image of `s` under `f` if and only if there exists an element `a` in `s` such that `f(a) = b`. In other words, an element `b` is in the image of `s` under `f` exactly when `b` is the image of some element in `s` under the function `f`.

For any decidable equality on type `β` and a function `f` from type `α` to `β`, an element `b` is in the image of a finite set `s` of type `α` under `f` if and only if there exists an element `a` in `s` such that `f(a) = b`.


AlgEquiv.ext

theorem AlgEquiv.ext :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {f g : A₁ ≃ₐ[R] A₂},
      (∀ (a : A₁), f a = g a) → f = g :=
  by sorry

This theorem, `AlgEquiv.ext`, states that for any commutative semiring `R` and any two semirings `A₁` and `A₂`, along with the algebra structure over them, if two algebraic equivalences `f` and `g` from `A₁` to `A₂` over `R` are such that their effects on any element `a` from `A₁` are identical (i.e., `f a = g a` for all `a` in `A₁`), then `f` and `g` are the same algebraic equivalence. This theorem is a declaration of the extensionality principle for algebraic equivalences.

If two algebraic equivalences over a commutative semiring from one semiring to another have identical effects on all elements, they are equal.


theorem Nat.cast_ne_zero : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] {n : ℕ}, ↑n ≠ 0 ↔ n ≠ 0 :=
  by sorry

This theorem states that for any natural number 'n' and any type 'R' that is an additive monoid with identity element and has the property of being characteristic zero, the casted value of 'n' to 'R' is not equal to zero if and only if 'n' is not equal to zero. In other words, the natural number 'n' is non-zero if and only if its casted value in the additive monoid 'R' is also non-zero. The characteristic zero property ensures that the additive identity (zero) and multiplicative identity (one) in 'R' correspond with the numbers 0 and 1 in the natural numbers.

For any additive monoid with identity element and characteristic zero 'R' and natural number 'n', the cast of 'n' to 'R' is non-zero if and only if 'n' is non-zero.


theorem iff_false : ∀ (p : Prop), (p ↔ False) = ¬p := by sorry

This theorem states that for any proposition `p`, the bi-conditional `p ↔ False` is equivalent to the negation of `p`, denoted as `¬p`. In other words, saying that `p` is logically equivalent to `False` is the same as saying `p` is not true.

The theorem asserts that for any proposition `p`, the bi-conditional `p ↔ False` is equivalent to the negation `¬p` in Lean logic.


HomologicalComplex.Hom.comm

theorem HomologicalComplex.Hom.comm :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {A B : HomologicalComplex V c}
      (f : HomologicalComplex.Hom A B) (i j : ι),
      CategoryTheory.CategoryStruct.comp (f.f i) (B.d i j) = CategoryTheory.CategoryStruct.comp (A.d i j) (f.f j) :=
  by sorry

The theorem `HomologicalComplex.Hom.comm` states that for any category `V` with zero morphisms, any complex shape `c`, any two homological complexes `A` and `B` over `V` with shape `c`, and a morphism `f` from `A` to `B`, for all indices `i` and `j`, the composition of the morphism `f.f i` and the differential `B.d i j` is equal to the composition of the differential `A.d i j` and the morphism `f.f j`. This theorem expresses a fundamental commutativity property in the theory of homological complexes in the category theory context.

For any homological complexes A and B over a category with zero morphisms and any morphism f between them, the order of composing their differentials and the morphism f is commutative for all indices, i.e., f.fi * B.dij = A.dij * f.fj.


theorem Int.cast_neg : ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℤ), ↑(-n) = -↑n := by sorry

This theorem, `Int.cast_neg`, states that for every integer `n`, the negation of `n` cast into an arbitrary type `R` (that is, `-n` as an element of `R`), is equal to the negation of `n` as an element of `R`. Here, the type `R` is assumed to be an addable group with a unity (which typically means there's a zero, a negative operation, an addition operation, and a "one" element defined in a compatible way on `R`). In mathematical notation, this could be expressed as ∀n ∈ ℤ, ∀R ∈ AddGroupWithOne, cast(-n) = -cast(n).

For every integer `n` and additive group with unity `R`, the negation of the integer `n` cast to `R` equals the negation of `n` as an element of `R`. In mathematical notation: ∀n ∈ ℤ, ∀R ∈ AddGroupWithOne, -cast(n) = cast(-n).


Complex.ext

theorem Complex.ext : ∀ {z w : ℂ}, z.re = w.re → z.im = w.im → z = w := by sorry

This theorem states that for any two complex numbers `z` and `w`, if their real parts (`z.re` and `w.re`) are equal and their imaginary parts (`z.im` and `w.im`) are also equal, then `z` and `w` must be the same complex number. Essentially, it confirms the intuition that two complex numbers are identical if and only if both their real and imaginary components are identical.

If two complex numbers `z` and `w` have equal real and imaginary parts, i.e., `z.re = w.re` and `z.im = w.im`, then `z = w`.


theorem GaloisConnection.l_bot :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot β]
      [inst_3 : OrderBot α] {l : α → β} {u : β → α}, GaloisConnection l u → l ⊥ = ⊥ :=
  by sorry

This theorem states that for any two ordered types `α` and `β`, both with a bottom element (`OrderBot α` and `OrderBot β` respectively), if there is a Galois connection between `α` and `β` given by functions `l` and `u`, then the minimum (bottom) element of `α` mapped by the function `l` is the minimum (bottom) element of `β`. In other words, the bottom element of `α` when transformed by `l`, stays the bottom element in the `β` space, respecting the Galois connection between the two spaces.

For any Galois connection between ordered types `α` and `β` with bottom elements, the image of the bottom element of `α` under the left adjoint function `l` is the bottom element of `β`.


SetLike.ext'

theorem SetLike.ext' : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, ↑p = ↑q → p = q := by sorry

This theorem states that for any two types `A` and `B`, given that `A` is a "set-like" type of `B`, if two elements `p` and `q` of type `A` have the same interpretations as elements of type `B` (i.e., `↑p = ↑q`), then `p` and `q` must be the same elements of type `A` (i.e., `p = q`). In other words, this theorem asserts that the interpretation function in the `SetLike` typeclass is injective (or one-to-one).

Given two set-like types `A` and `B` with `A` being set-like over `B`, if for all `p, q ∈ A`, `↑p = ↑q` implies `p = q`, then the interpretation function `↑ : A → B` is injective.


StrictMono.monotone

theorem StrictMono.monotone :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β}, StrictMono f → Monotone f :=
  by sorry

The theorem `StrictMono.monotone` states that for any types `α` and `β`, which have a partial order and preorder respectively, and any function `f` from `α` to `β`, if `f` is strictly monotone, then `f` is also monotone. In other words, if for all `a` and `b` in `α` such that `a < b` it holds that `f(a) < f(b)`, then it must also be the case that for all `a` and `b` in `α` such that `a ≤ b`, we have `f(a) ≤ f(b)`.

If `f` is a strictly monotonic function from a partially ordered type `α` to a preordered type `β`, then `f` is monotonic.


theorem closure_mono : ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], s ⊆ t → closure s ⊆ closure t := by
  sorry

The theorem `closure_mono` states that for any type `X` with a topological space structure and any two subsets `s` and `t` of `X`, if `s` is a subset of `t`, then the closure of `s` is a subset of the closure of `t`. In other words, the operation of taking closures in a topological space is "monotone": increasing the original set results in an increase of its closure.

For any topological space (X, τ), and subsets s, t of X with s ⊆ t, the closure of s is contained in the closure of t, denoted ∫s⊆∫t.


theorem Submodule.smul_mem :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M) {x : M} (r : R), x ∈ p → r • x ∈ p :=
  by sorry

This theorem, `Submodule.smul_mem`, states that for any semiring `R`, additively commutative monoid `M`, and `Module R M` as well as any element `x` of `M` and scalar `r` from `R`, if `x` is an element of a submodule `p` of `M`, then the scalar multiple `r • x` is also an element of the submodule `p`. In other words, the submodule `p` is closed under scalar multiplication from `R`.

If `p` is a submodule of an additively commutative monoid `M` over a semiring `R`, then for all `x in p` and `r in R`, `r • x` is also in `p`.


theorem Finset.sum_const_zero :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} [inst : AddCommMonoid β], (Finset.sum s fun _x => 0) = 0 := by sorry

The theorem `Finset.sum_const_zero` states that for any finite set `s` of any type `α` and for any type `β` that forms an additive commutative monoid, the sum of the constant function that always returns zero over all elements in `s` is zero. In other words, if you sum up zero for each element in a finite set, the total sum will be zero.

For any finite set `s` and any additive commutative monoid `β`, the sum of the constant function mapping every element of `s` to the additive identity of `β` is the additive identity of `β`.


theorem GaloisConnection.monotone_l :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → Monotone l :=
  by sorry

The theorem `GaloisConnection.monotone_l` states that for any types `α` and `β` equipped with preorder structures, if a pair of functions `l : α → β` and `u : β → α` form a Galois connection, then the function `l` is monotone. In other words, if for all `a` in `α` and `b` in `β`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`, then for all `a, b` in `α`, if `a` is less than or equal to `b`, then `l a` is less than or equal to `l b`.

If `l` and `u` form a Galois connection between preordered types `α` and `β`, then `l` is a monotone function from `α` to `β`.


theorem CharP.cast_eq_zero : ∀ (R : Type u_1) [inst : AddMonoidWithOne R] (p : ℕ) [inst_1 : CharP R p], ↑p = 0 := by
  sorry

This theorem states that for any type `R` that has an instance of `AddMonoidWithOne` (meaning it is a mathematical object with an operation similar to addition and a "one" element), and a natural number `p` that has a characteristic `CharP` associated with `R`, the cast of `p` to `R` equals zero. In mathematical terms, this theorem states that in a ring `R` of characteristic `p`, the element `p` of the ring is the additive identity, i.e., it behaves like the number zero.

In a ring of characteristic `p`, the element `p` behaves as the additive identity.


theorem Finset.coe_image₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] (f : α → β → γ) (s : Finset α) (t : Finset β),
      ↑(Finset.image₂ f s t) = Set.image2 f ↑s ↑t :=
  by sorry

This theorem states that for any types `α`, `β`, `γ` and a binary function `f` from `α` and `β` to `γ`, for any finite sets `s` of type `α` and `t` of type `β`, the image of `f` over the cartesian product of `s` and `t` (obtained using `Finset.image₂` and then coerced to a set) is equal to the image of `f` over the cartesian product of `s` and `t` considered as sets (obtained using `Set.image2`). This equality holds when we have a decidable equality on `γ`. In other words, the theorem reveals the consistency between the `image₂` operations on finite sets and on general sets when we view finite sets as particular sets.

For any types `α`, `β`, `γ` and a decidably equated binary function `f` from `α × β` to `γ`, the sets `Finset.image₂ f (Finset.univ s) (Finset.univ t)` and `Set.image2 f (s × t)` are equal, where `s` is a finite set of type `α` and `t` is a finite set of type `β`.


theorem Finset.mem_range : ∀ {n m : ℕ}, m ∈ Finset.range n ↔ m < n := by sorry

This theorem states that for any two natural numbers 'n' and 'm', 'm' is a member of the set 'Finset.range n' if and only if 'm' is less than 'n'. In other words, a natural number 'm' belongs to the set of natural numbers less than 'n' exactly when 'm' is less than 'n'.

For any natural numbers n and m, m is an element of Finset.range n if and only if m < n.


theorem lt_top_iff_ne_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, a < ⊤ ↔ a ≠ ⊤ := by
  sorry

This theorem states that for any type `α`, given a partial order and an order top on `α`, and for any element `a` of type `α`, `a` is less than the top element if and only if `a` is not equal to the top element. In other words, an element in such a partially ordered set is less than the maximum (top) element if and only if it is not that maximum element itself.

In a partially ordered set, an element is strictly less than the top element if and only if it is not the top element itself.


theorem Polynomial.eval_X : ∀ {R : Type u} [inst : Semiring R] {x : R}, Polynomial.eval x Polynomial.X = x := by sorry

The theorem `Polynomial.eval_X` states that for any type `R` which forms a semiring (a mathematical structure which includes operations like addition and multiplication), for any element `x` from the semiring `R`, when you evaluate the polynomial 'X' (which is a monomial of degree 1, essentially making it the variable or indeterminate in the polynomial context) at the point `x`, you simply get `x` back. This reflects the basic algebraic principle that substituting a variable with a specific value in a polynomial gives you a new expression where all occurrences of the variable are replaced with that specific value.

For any semiring `R` and element `x` in `R`, `Polynomial.eval_X x = x`.


theorem Nat.succ_le_succ : ∀ {n m : ℕ}, n ≤ m → Nat.succ n ≤ Nat.succ m := by sorry

This theorem, `Nat.succ_le_succ`, states that for all natural numbers `n` and `m`, if `n` is less than or equal to `m`, then the successor of `n` (i.e. `n + 1` in mathematics, represented as `Nat.succ n` in Lean 4) is less than or equal to the successor of `m` (i.e. `m + 1` in mathematics, represented as `Nat.succ m` in Lean 4). This theorem essentially captures the intuitive notion that increasing both sides of an inequality by the same amount preserves the inequality.

For all natural numbers `n` and `m`, if `n ≤ m` then `Nat.succ n ≤ Nat.succ m`.


theorem Mathlib.Data.Set.Defs._auxLemma.3 : ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) := by
  sorry

This theorem, named `Mathlib.Data.Set.Defs._auxLemma.3`, states that for all types `α`, and for all sets `s` and `t` of type `α`, for any element `x` of type `α`, the statement "x is in the difference of sets s and t" is equivalent to the statement "x is in set s and x is not in set t". In mathematical notation, this is saying that $x \in (s \setminus t)$ if and only if $x \in s$ and $x \notin t$. The difference of two sets (also called the set-theoretic difference or relative complement) is the set of all elements that are in the first set but not in the second set.

For all types `α`, sets `s` and `t` of type `α`, and element `x` of type `α`, $x \in (s \setminus t) \Leftrightarrow x \in s \land x \notin t$.


theorem Finset.prod_insert :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {a : α} {f : α → β} [inst : CommMonoid β] [inst_1 : DecidableEq α],
      a ∉ s → (Finset.prod (insert a s) fun x => f x) = f a * Finset.prod s fun x => f x :=
  by sorry

The theorem `Finset.prod_insert` states that for any types `α` and `β`, a finite set `s` of type `α`, an element `a` of type `α`, and a function `f` from `α` to `β`, given that `β` forms a commutative monoid and `α` has decidable equality, if `a` is not an element of `s`, then the product of the function `f` evaluated over the set resulting from the insertion of `a` into `s` is equal to the product of `f` evaluated at `a` and the product of `f` evaluated over `s`. In mathematical terms, if $a \notin s$, then $\prod_{x \in s \cup \{a\}} f(x) = f(a) \cdot \prod_{x \in s} f(x)$.

For any commutative monoid β and type α with decidable equality, if a is not an element of finite set s and f is a function from α to β, then f(a) * ∏x∈s f(x) = ∏x∈s∪{a} f(x).


theorem Nat.succ_le_iff : ∀ {m n : ℕ}, Nat.succ m ≤ n ↔ m < n := by sorry

This theorem states a relationship between two natural number operations in mathematics. Specifically, for any two natural numbers `m` and `n`, the successor of `m` (which is `m` + 1) is less than or equal to `n` if and only if `m` is less than `n`.

For all natural numbers m and n, m < n if and only if m + 1 <= n.


theorem isCompact_univ : ∀ {X : Type u} [inst : TopologicalSpace X] [h : CompactSpace X], IsCompact Set.univ := by sorry

This theorem states that for any type `X` equipped with a topology (denoted by `TopologicalSpace X`) and with the property that it is a compact space (`CompactSpace X`), the universal set of `X` (i.e., the set containing all elements of `X`, denoted by `Set.univ`) is compact. Here, a set is compact if for every nontrivial filter `f` that contains the set, there exists an element `a` in the set such that every set of `f` meets every neighborhood of `a`.

In Lean 4, if `X` is a compact topological space, then the universal set of `X` is compact. Equivalently, every cover of `Set.univ` by open sets in `X` has a finite subcover.


theorem mul_le_mul_right' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α]
      [i : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {b c : α},
      b ≤ c → ∀ (a : α), b * a ≤ c * a :=
  by sorry

The theorem `mul_le_mul_right'` states that for any type `α` that supports multiplication and a "less than or equal to" comparison, and that maintains a certain covariant class property, if `b` and `c` are elements of `α` such that `b` is less than or equal to `c`, then for any other element `a` of `α`, the result of multiplying `b` by `a` is less than or equal to the result of multiplying `c` by `a`. In short, it proves the property of preserving the order under multiplication on the right in such a structure.

For all types `α` with covariant multiplication and a total order, and for all `a`, `b`, and `c` in `α` with `b ≤ c`, we have `b * a ≤ c * a`.


theorem Finset.card_range : ∀ (n : ℕ), (Finset.range n).card = n := by sorry

This theorem states that for any natural number `n`, the cardinality of the set `Finset.range n` (which is the set of natural numbers less than `n`) is equal to `n` itself. In other words, the number of natural numbers less than any given natural number `n` is exactly `n`.

The cardinality of `Finset.range n` equals `n`.


theorem Mathlib.Data.Nat.Cast.Defs._auxLemma.3 :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (m n : ℕ), ↑m + ↑n = ↑(m + n) := by sorry

This theorem, titled `Mathlib.Data.Nat.Cast.Defs._auxLemma.3`, states that for any type `R` that has an `AddMonoidWithOne` structure, and for any natural numbers `m` and `n`, the sum of the casts of `m` and `n` to type `R` is equal to the cast of the sum of `m` and `n` to type `R`. In mathematical terms, it asserts that `↑m + ↑n` equals `↑(m + n)`, where `↑` denotes the cast to type `R`. This essentially allows us to treat the casting function as a homomorphism when it comes to addition.

For any type `R` with an `AddMonoidWithOne` structure and natural numbers `m` and `n`, the cast of `m + n` to type `R` is equal to the sum of the casts of `m` and `n` to type `R`. In Lean, this is expressed by `Mathlib.Data.Nat.Cast.Defs._auxLemma.3`.


theorem Set.mem_iInter₂ :
    ∀ {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} {x : γ} {s : (i : ι) → κ i → Set γ},
      x ∈ ⋂ i, ⋂ j, s i j ↔ ∀ (i : ι) (j : κ i), x ∈ s i j :=
  by sorry

This theorem states that for any type `γ`, any sort `ι`, any sort-dependent family `κ` indexed by `ι`, any element `x` of type `γ`, and any double-indexed family `s` of sets of elements of type `γ`, the element `x` is in the intersection over all `i` and `j` of the sets `s i j` if and only if, for every `i` of type `ι` and every `j` of type `κ i`, `x` is in `s i j`. In terms of set theory, this means that an element belongs to the intersection of a collection of sets if and only if it belongs to each set in the collection.

For any type `γ`, sort `ι`, sort-dependent family `κ`, element `x` of type `γ`, and sets `s i j` indexed by `ι` and `κ i`, `x` is in the intersections of all `s i j` if and only if it is in each `s i j`.


/-- **Alias** of the reverse direction of `Set.range_iff_surjective`. -/
theorem Function.Surjective.range_eq :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Function.Surjective f → Set.range f = Set.univ := by sorry

The theorem `Function.Surjective.range_eq` states that for any function `f` from a type `ι` to another type `α`, if the function `f` is surjective (meaning that for every element `b` in `α`, there is some element `a` in `ι` such that `f(a) = b`), then the range of `f` (i.e., the set of all values that `f` can produce) is equal to the universal set `Set.univ` of `α`, which contains all elements of `α`. In other words, a surjective function's output includes every possible element of the codomain.

If `f` is a surjective function from type `ι` to type `α`, then the range of `f` equals the universe `Set.univ` of `α`.


theorem Filter.le_principal_iff : ∀ {α : Type u} {s : Set α} {f : Filter α}, f ≤ Filter.principal s ↔ s ∈ f := by sorry

The theorem `Filter.le_principal_iff` establishes a relationship between filters and sets in a certain type `α`. For any type `α`, any set `s` of type `α`, and any filter `f` on `α`, the theorem states that the filter `f` is less than or equal to the principal filter of `s` if and only if `s` is an element of the filter `f`. In other words, it provides a condition on the relationship between a filter and a set such that the filter being a subset of all supersets of a given set is equivalent to the set being in the filter.

A filter `f` on a type `α` is equal to the principal filter of a set `s` if and only if `s` is an element of `f`.


theorem ne_of_mem_of_not_mem :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Membership α β] {s : β} {a b : α}, a ∈ s → b ∉ s → a ≠ b := by sorry

This theorem states that for any types `α` and `β` where `α` has a membership relation with `β`, given an instance `s` of `β` and two instances `a` and `b` of `α`, if `a` is a member of `s` and `b` is not a member of `s`, then `a` is not equal to `b`. In mathematical terms, if $a$ belongs to a set $s$ and $b$ does not belong to the same set, then $a$ is not equal to $b$.

If $a$ is an element of set $s$ and $b$ is not an element of $s$, then $a$ is not equal to $b$.


theorem Set.preimage_mono : ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s t : Set β}, s ⊆ t → f ⁻¹' s ⊆ f ⁻¹' t := by
  sorry

The theorem `Set.preimage_mono` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if a set `s` of type `β` is a subset of another set `t` of the same type, then the preimage of `s` under `f` is a subset of the preimage of `t` under `f`. Here, the preimage of a set under a function is the set of all elements in the domain that get mapped to the elements in the given set by the function.

If `s subseteq t` are subsets of type `β`, then `f⁁⁃1(s) subseteq f⁁⁃1(t)` for any function `f : α -> β` from type `α` to type `β`. (Here, `f⁁⁃1(X)` denotes the preimage of set `X` under function `f`.)


Filter.EventuallyEq.refl

theorem Filter.EventuallyEq.refl : ∀ {α : Type u} {β : Type v} (l : Filter α) (f : α → β), f =ᶠ[l] f := by sorry

This theorem states that, for any type `α` and `β`, and any filter `l` of type `α` and a function `f` from `α` to `β`, the function `f` is eventually equal to itself with respect to the filter `l`. "Eventually equal" is a concept in analysis meaning that the two functions are equal except possibly on a set of measure zero (or more generally, on a set that the filter does not "see").

For any type `α`, filter `l` on `α`, and function `f` from `α` to `β`, there exists a set in `l` on which `f` is equal to its restriction to that set.


theorem Set.diff_subset : ∀ {α : Type u} (s t : Set α), s \ t ⊆ s := by sorry

The theorem `Set.diff_subset` states that for any type `α`, and any two sets `s` and `t` of type `α`, the set difference of `s` and `t` (denoted as `s \ t`) is a subset of `s`. In mathematical terms, for all elements `x` of type `α`, if `x` is in the set difference `s \ t`, then `x` is also in `s`.

For any type `α` and sets `s` and `t` of type `α`, `s \ t` is a subset of `s`.


Units.isUnit

theorem Units.isUnit : ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ), IsUnit ↑u := by sorry

The theorem `Units.isUnit` states that for any type `M` that forms a Monoid, any element `u` of `Mˣ` (the set of units in the monoid `M`) is a unit. In other words, if `u` is an element of the set of units in the monoid `M`, then there exists another element in the monoid such that the product of `u` and this element is the monoid's identity.

For any monoid `M` and any of its unit element `u`, there exists an element `e` in `M` such that `u * e = e * u = 1_M`, where `1_M` is the identity element of `M`.


theorem List.map_append :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (l₁ l₂ : List α),
      List.map f (l₁ ++ l₂) = List.map f l₁ ++ List.map f l₂ :=
  by sorry

The theorem `List.map_append` states that for any two lists `l₁` and `l₂` of the same type `α`, and any function `f` from `α` to another type `β`, applying the `map` function with `f` to the append operation of `l₁` and `l₂` is the same as appending the results of applying `map` with `f` to `l₁` and `l₂` separately. That is, the mapping function distributes over the append operation for lists. In mathematical notation, this can be expressed as `map(f, l₁ ++ l₂) = map(f, l₁) ++ map(f, l₂)`.

For any lists `l₁`, `l₂` of type `α` and function `f` from `α` to `β`, `map(f, l₁ ++ l₂) = map(f, l₁) ++ map(f, l₂)`.


theorem dvd_zero : ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), a ∣ 0 := by sorry

This theorem states that any element `a` of a type `α` that forms a semigroup with zero divides zero. In mathematical terms, for any `a` in a semigroup-with-zero structure `α`, `a` divides `0`. This is a general property in number theory where any number is a divisor of zero.

In any semigroup with zero, every non-zero element is a divisor of zero.


theorem List.length_map :
    ∀ {α : Type u} {β : Type v} (as : List α) (f : α → β), List.length (List.map f as) = List.length as := by sorry

The theorem `List.length_map` states that for any list `as` of type `α` and any function `f` mapping from `α` to another type `β`, the length of the list obtained by applying `f` to each element of `as` (using the `List.map` function) is equal to the length of `as`. In other words, mapping a function over a list does not change its length. This is represented mathematically as: for all `as` in `List α` and all `f` in `α → β`, `List.length (List.map f as) = List.length as`.

For any list `as` of type `α` and function `f` from `α` to another type `β`, the length of the list obtained by applying `f` to each element of `as` using `List.map` is equal to the length of `as`. In mathematical notation, `List.length (List.map f as) = List.length as`.


theorem Finset.card_le_card : ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → s.card ≤ t.card := by sorry

This theorem states that for any two finite sets `s` and `t` of any type `α`, if set `s` is a subset of set `t`, then the cardinality (or the number of elements) of set `s` is less than or equal to the cardinality of set `t`. This is a fundamental property of finite sets in set theory.

For any finite sets `s` and `t` of type `α`, if `s` is a subset of `t`, then `#s ≤ #t`, where `#s` denotes the cardinality of `s`.


theorem SetLike.ext'_iff : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ↑p = ↑q := by sorry

This theorem, `SetLike.ext'_iff`, states that for any two types `A` and `B`, where `A` is set-like over `B`, and for any two elements `p` and `q` of type `A`, `p` is equal to `q` if and only if the set-like coercions of `p` and `q` to `B` are equal. In simpler terms, it means that if we have a type `A` that behaves like a set of elements of another type `B`, two instances of `A` are equal if their corresponding "sets" of `B` elements are equal.

For set-like types `A` over `B`, two elements `p` and `q` of `A` are equal if and only if their set-like coercions to `B` are equal.


theorem dist_self : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), dist x x = 0 := by sorry

This theorem states that for any type `α` that is a `PseudoMetricSpace`, the distance of any element `x` from itself is `0`. In mathematical terms, for a given element in a pseudo-metric space, the distance between the element and itself is always zero. This is consistent with the fundamental property of metric spaces where the distance from a point to itself is always zero.

For any pseudo-metric space `α`, the distance of any element `x` from itself is `0`. (or equivalently, `d x x = 0` where `d` is the distance function)


theorem continuous_pi :
    ∀ {X : Type u} {ι : Type u_5} {π : ι → Type u_6} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (π i)]
      {f : X → (i : ι) → π i}, (∀ (i : ι), Continuous fun a => f a i) → Continuous f :=
  by sorry

This theorem, `continuous_pi`, establishes that for any type `X` with a topological space structure, any indexing type `ι`, and any type `π` indexed by `ι` and equipped with a family of topological space structures, a function `f` from `X` to `π` is continuous if and only if for each index `i` in `ι`, the function obtained by applying `f` and then projecting onto the `i`th component, is continuous. In other words, a function into a product space is continuous if and only if each of its component functions is continuous.

A function from a topological space to a product of topological spaces is continuous if and only if each component function is continuous.


/-- **Alias** of the reverse direction of `inf_eq_left`. -/
theorem inf_of_le_left : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ≤ b → a ⊓ b = a := by sorry

This theorem, `inf_of_le_left`, is an alias of the reverse direction of the theorem `inf_eq_left`. The theorem states that for any type `α` that has an instance of the `SemilatticeInf` structure, given any two elements `a` and `b` of type `α`, if `a` is less than or equal to `b` then the infimum (i.e. greatest lower bound) of `a` and `b` is `a`.

For any semilattice `α` and elements `a, b ∈ α` with `a ≤ b`, the infimum of `a` and `b` is `a`.


theorem le_bot_iff : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, a ≤ ⊥ ↔ a = ⊥ := by sorry

This theorem, `le_bot_iff`, states that for any type `α` equipped with a partial order and a least element (denoted `⊥`), a given element `a` of type `α` is less than or equal to the least element if and only if `a` is in fact the least element itself. In other words, in such a system, the only element that is less than or equal to the least element is the least element itself.

For any type equipped with a partial order and a least element, an element is less than or equal to the least element if and only if they are equal.


theorem neg_inj : ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, -a = -b ↔ a = b := by sorry

This theorem, `neg_inj`, states that for any type `G` with an involutive negation operation, the negation of `a` is equal to the negation of `b` if and only if `a` is equal to `b`. In other words, negation is an injective (one-to-one) function in this context.

For any type `G` equipped with an involutive negation operation, negation is a function that maps distinct elements to distinct negated elements.


theorem Nat.sub_add_cancel : ∀ {n m : ℕ}, m ≤ n → n - m + m = n := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `m` is less than or equal to `n`, then subtracting `m` from `n` and then adding `m` back gives us `n`. This is a fundamental property of subtraction and addition in the natural numbers domain.

For all natural numbers `n` and `m`, `n = (n - m) + m`.


theorem Set.empty_subset : ∀ {α : Type u} (s : Set α), ∅ ⊆ s := by sorry

This theorem states that for any set `s` of a type `α`, the empty set is a subset of `s`. In mathematical terms, for every set `s` in the universe of discourse, it always holds that the empty set is a subset of `s`. This is a fundamental property of set theory, as the empty set contains no elements and therefore cannot contain any elements not in `s`.

For any set `s`, the empty set is a subset of `s`.


theorem Nat.succ_pred_eq_of_pos : ∀ {n : ℕ}, 0 < n → Nat.succ (Nat.pred n) = n := by sorry

This theorem, `Nat.succ_pred_eq_of_pos`, states that for all natural numbers `n`, if `n` is greater than `0`, then the successor of the predecessor of `n` is equal to `n` itself. In other words, if we have a positive natural number `n`, decrementing it by 1 (using `Nat.pred`) and then incrementing it by 1 (using `Nat.succ`) returns us back to the original number `n`.

For all natural numbers `n` greater than 0, `Nat.succ (Nat.pred n) = n`.


theorem Bool.of_not_eq_true : ∀ {b : Bool}, ¬b = true → b = false := by sorry

This theorem states that for any boolean value `b`, if `b` is not equal to `true`, then `b` must be equal to `false`. Remember that in the context of boolean logic, a variable can only have two possible values: `true` or `false`. Hence, if it's not `true`, it has to be `false`.

If a boolean value is not true, then it is false.


theorem nhdsWithin_le_nhds :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, nhdsWithin a s ≤ nhds a := by sorry

This theorem states that for any type `α` which has a topological space structure, for any element `a` of type `α`, and for any set `s` of elements of `α`, the neighborhood within `s` at `a`, denoted `nhdsWithin a s`, is contained within or equal to the neighborhood at `a`, denoted `nhds a`. In other words, all sets that contain the intersection of `s` and a neighborhood of `a` are also neighborhoods of `a`.

For any topological space `(α, τ)` and any `a ∈ α`, the neighborhood filter of `a`, `nhds a`, contains the neighborhood filter within `a` of any set `s ⊆ α`, `nhdsWithin a s`.


HasSum.summable

theorem HasSum.summable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α},
      HasSum f a → Summable f :=
  by sorry

The theorem `HasSum.summable` states that for any types `α` and `β`, given an additive commutative monoid structure on `α` and a topological space structure on `α`, if a function `f` from `β` to `α` has a sum `a` (denoted by `HasSum f a`), then `f` is summable (denoted by `Summable f`). In mathematical terms, if an infinite series associated with function `f` converges to a sum `a`, then the series is considered summable.

If `α` is an additive commutative monoid with a topology, and `f : β → α` has a sum `a`, then `f` is summable to `a`.