IsMaxFilter.isExtr

theorem IsMaxFilter.isExtr :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α},
      IsMaxFilter f l a → IsExtrFilter f l a :=
  by sorry

The theorem `IsMaxFilter.isExtr` states that for all types `α` and `β`, where `β` has a preorder structure, and for all functions `f` from `α` to `β`, filters `l` on `α`, and elements `a` of `α`, if `a` is a maximum point for `f` within some neighborhood determined by `l` (i.e., `f(x) ≤ f(a)` for all `x` in this neighborhood), then `a` is an extremal point for `f` with respect to this filter `l`. In other words, if `a` is a local maximum for `f`, it is also a local extremum (either a local maximum or minimum).

For any type `α` with preorder `β`, given a function `f` from `α` to `β`, an element `a` in `α`, and a filter `l` on `α`, if `a` is a maximum point of `f` within `l`'s neighborhood, then `a` is an extremal point for `f` with respect to `l`.


theorem Set.Icc_subset_Ici_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b ⊆ Set.Ici a := by sorry

The theorem `Set.Icc_subset_Ici_self` states that for any type `α` with a preorder structure, any left-closed right-closed interval `[a, b]` (that is, the set of all `x` such that `a ≤ x` and `x ≤ b`) is a subset of the left-closed right-infinite interval starting at `a` (that is, the set of all `x` such that `a ≤ x`). This is intuitively true since any element in the interval `[a, b]` will certainly be greater than or equal to `a`.

For any preordered type `α` and elements `a ≤ b` in `α`, the interval `[a, b]` is a subset of the interval `{x : α | a ≤ x}`.


theorem CategoryTheory.Limits.coprod.desc_inl_inr :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y],
      CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr =
        CategoryTheory.CategoryStruct.id (X ⨿ Y) :=
  by sorry

This theorem, `CategoryTheory.Limits.coprod.desc_inl_inr`, states that in any category `C` with a binary coproduct of two objects `X` and `Y`, the morphism described by the coproduct of the inclusion maps from `X` and `Y` is equal to the identity morphism on the coproduct `X ⨿ Y`. In other words, it formalizes the universal property of the coproduct in category theory: for every pair of morphisms from `X` and `Y` to the coproduct `X ⨿ Y` (given by `CategoryTheory.Limits.coprod.inl` and `CategoryTheory.Limits.coprod.inr`), there exists a unique morphism from the coproduct to itself (given by `CategoryTheory.Limits.coprod.desc`) which makes the corresponding diagram commute, and this morphism is the identity on `X ⨿ Y`.

In any category with binary coproducts, the coproduct inclusions are equal to the coproduct description morphisms, which are the identity morphisms on the coproduct.


theorem List.chain_cons :
    ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α}, List.Chain R a (b :: l) ↔ R a b ∧ List.Chain R b l := by
  sorry

This theorem states that for any type `α`, any relation `R` of type `α → α → Prop`, any elements `a` and `b` of type `α`, and any list `l` of type `List α`, the property of `List.Chain R a (b :: l)` (which means that the relation `R` forms a chain from `a` through the list starting with `b` followed by `l`) is equivalent to the conjunction of two conditions: `R a b` (the relation `R` holds between `a` and `b`) and `List.Chain R b l` (the relation `R` forms a chain from `b` through the list `l`).

For any type `α`, relation `R` on `α`, and elements `a`, `b` in `α` and list `l` of `α`, `List.Chain R a (b :: l)` if and only if `R a b` and `List.Chain R b l`.


theorem Even.neg_one_pow :
    ∀ {α : Type u_2} [inst : Monoid α] {n : ℕ} [inst_1 : HasDistribNeg α], Even n → (-1) ^ n = 1 := by sorry

The theorem `Even.neg_one_pow` states that for any natural number `n` in a monoidal type `α` that also has a notion of negation, if `n` is even (i.e., there exists an `r` in `α` such that `n = r + r`), then the power of `-1` raised to `n` is `1`. In mathematical terms, this can be written as if $n$ is even, then $(-1)^n = 1$.

For any even natural number `n` in a monoidal type `α` with negation, (-1)^n = 1.


theorem sup_eq_bot_iff :
    ∀ {α : Type u} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {a b : α}, a ⊔ b = ⊥ ↔ a = ⊥ ∧ b = ⊥ := by sorry

This theorem states that for any type `α` that is a semilattice with a supremum operation and has a bottom element, the supremum (`⊔`) of any two elements `a` and `b` of this type is equal to the bottom element if and only if both `a` and `b` are the bottom element.

For any semilattice `α` with a bottom element, `⊔(a, b) = bottom` if and only if `a = bottom` and `b = bottom`.


theorem Nat.min_le_right : ∀ (a b : ℕ), min a b ≤ b := by sorry

This theorem states that for any two natural numbers `a` and `b`, the minimum of `a` and `b` is always less than or equal to `b`. In other words, no matter what two natural numbers you choose, the smaller one (or either one if they are equal) will never be greater than `b`.

For all natural numbers `a` and `b`, `a ≤ b`.


SemilinearIsometryClass.isometry

theorem SemilinearIsometryClass.isometry :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} {𝓕 : Type u_10} [inst : Semiring R]
      [inst_1 : Semiring R₂] {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂]
      [inst_4 : Module R E] [inst_5 : Module R₂ E₂] [inst_6 : FunLike 𝓕 E E₂]
      [inst : SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕), Isometry ⇑f :=
  by sorry

The theorem `SemilinearIsometryClass.isometry` states that, for any semiring `R`, a second semiring `R₂`, types `E` and `E₂`, and a type `𝓕`, given instances of `E` and `E₂` as seminormed additive commutative groups, `R` and `R₂` as modules over `E` and `E₂` respectively, `𝓕` as a function-like from `E` to `E₂`, and a semilinear isometry class on `𝓕`, `σ₁₂`, `E`, and `E₂`, any function `f` of type `𝓕` is an isometry. In other words, it preserves the edistance (extended distance) between the points in the pseudometric spaces `E` and `E₂`, i.e., the distance between the images of any two points under `f` is the same as the distance between the points themselves.

Given seminormed additive commutative groups `E` and `E₂`, semirings `R` and `R₂`, a semilinear isometry class `σ₁₂` on a function-like map `𝓕` from `E` to `E₂`, if `𝓕` is a semilinear isometry between `E` and `𝓕(E)` with respect to `σ₁₂`, then for any `f` in the isometry class of `𝓕`, the extended distance `d₂(f(x), f(y)) = d₁(x, y)` holds for all `x, y` in `E`.


theorem imp_not_comm : ∀ {a b : Prop}, a → ¬b ↔ b → ¬a := by sorry

This theorem states that for any two propositions `a` and `b`, the implication of `a` leading to the negation of `b` is logically equivalent to `b` leading to the negation of `a`. In other words, if assuming `a` to be true implies that `b` must be false, then it is also true that if `b` is assumed true, `a` must be false, and vice versa. This captures a fundamental symmetry in logical reasoning.

The logical implication `a → ⊥ → b` is equivalent to `b → ⊥ → a`, where `⊥` represents the logical false.


theorem Commute.pow_pow :
    ∀ {M : Type u_2} [inst : Monoid M] {a b : M}, Commute a b → ∀ (m n : ℕ), Commute (a ^ m) (b ^ n) := by sorry

The theorem `Commute.pow_pow` states that for any type `M` that forms a monoid, and for any elements `a` and `b` of type `M` that commute, meaning `a * b = b * a`, then for any non-negative integers `m` and `n`, the `m`-th power of `a` and the `n`-th power of `b` also commute. In other words, if `a` and `b` commute, then `(a ^ m) * (b ^ n) = (b ^ n) * (a ^ m)` for all non-negative integers `m` and `n`.

For any monoid `M` and commuting elements `a, b` in `M`, the powers `a^m` and `b^n` commute for all non-negative integers `m` and `n`, that is, `a^m * b^n = b^n * a^m`.


/-- The submonoid generated by a set is contained in any submonoid that contains the set.  -/
theorem Monoid.closure_subset :
    ∀ {M : Type u_1} [inst : Monoid M] {s t : Set M}, IsSubmonoid t → s ⊆ t → Monoid.Closure s ⊆ t := by sorry

This theorem states that for any type `M` that forms a Monoid, given two sets of elements `s` and `t` from `M`, if `t` is a submonoid and the set `s` is contained within `t`, then the submonoid generated by `s` (as defined by `Monoid.Closure`) is also contained within `t`. Essentially, this theorem shows that a submonoid generated by a subset of a larger submonoid remains within the bounds of the larger submonoid.

If `s` is a subset of the submonoid `t` of a monoid `M`, then the submonoid generated by `s` (Monoid.Closure `s`) is contained within `t`.


theorem minpoly.algEquiv_eq :
    ∀ {A : Type u_1} {B : Type u_2} {B' : Type u_3} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Ring B']
      [inst_3 : Algebra A B] [inst_4 : Algebra A B'] (f : B ≃ₐ[A] B') (x : B), minpoly A (f x) = minpoly A x :=
  by sorry

This theorem states that for any types `A`, `B`, and `B'`, where `A` is a commutative ring and `B` and `B'` are rings, and we have algebra structures from `A` to `B` and `A` to `B'`, if `f` is an algebraic equivalence from `B` to `B'` and `x` is an element in `B`, then the minimal polynomial of `f(x)` over `A` is equal to the minimal polynomial of `x` over `A`. This means that the algebraic equivalence `f` preserves the minimal polynomial of any element.

For any commutative ring `A`, and rings `B`, `B'` with `A`-algebra structures, if `f: B -> B'` is an algebraic equivalence and `x` is an element in `B`, then the minimal polynomial of `f(x)` over `A` equals the minimal polynomial of `x` over `A`.


theorem Mathlib.Data.Set.Basic._auxLemma.14 : ∀ {α : Type u}, (Set.univ = ∅) = IsEmpty α := by sorry

This theorem states that for any type `α`, the universal set of `α` is equal to the empty set if and only if `α` is an empty type. In other words, it establishes a correspondence between the condition of the universal set on `α` being empty and the type `α` having no instances. This is a foundation concept in type theory and set theory, connecting the properties of a type with the properties of the set of its instances.

The universal set of a type `α` is empty if and only if `α` is an empty type.


theorem Set.insert_subset : ∀ {α : Type u} {a : α} {s t : Set α}, a ∈ t → s ⊆ t → insert a s ⊆ t := by sorry

The theorem `Set.insert_subset` states that for any type `α`, any element `a` of type `α`, and any sets `s` and `t` of type `α`, if `a` belongs to set `t` and set `s` is a subset of `t`, then the set resulting from inserting `a` into `s` is also a subset of `t`. In other words, it ensures that adding an element to a subset, where the element is already part of the superset, will result in another subset of that superset.

If `a` is an element of set `t` and `s` is a subset of `t`, then `a :: s` (the set obtained by inserting `a` into `s`) is a subset of `t`.


theorem Fintype.one_lt_card_iff_nontrivial : ∀ {α : Type u_1} [inst : Fintype α], 1 < Fintype.card α ↔ Nontrivial α :=
  by sorry

The theorem `Fintype.one_lt_card_iff_nontrivial` states that for any given finite type `α`, the number of elements (`Fintype.card α`) in `α` is greater than one if and only if `α` is nontrivial. In this context, a nontrivial type is one that has at least two distinct elements. Thus, this theorem is essentially relating the size of a finite type with its nontriviality.

A finite type `α` has more than one element if and only if `Fintype.card α` is greater than one.


theorem MeasureTheory.measure_diff_null :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      ↑↑μ s₂ = 0 → ↑↑μ (s₁ \ s₂) = ↑↑μ s₁ :=
  by sorry

This theorem, `MeasureTheory.measure_diff_null`, states that for any types `α`, any measurable space `m` on `α`, any measure `μ` in this measurable space, and any two sets `s₁` and `s₂` of type `α`, if the measure `μ` of set `s₂` is zero, then the measure of the difference `s₁ \ s₂` is equal to the measure of `s₁`. In simpler terms, if we subtract a set `s₂` with measure zero from another set `s₁`, the measure of the resulting set is the same as the original measure of `s₁`.

If `μ(s₂) = 0`, then `μ(s₁ \ s₂) = μ(s₁)`.


theorem ENNReal.div_top : ∀ {a : ENNReal}, a / ⊤ = 0 := by sorry

The theorem `ENNReal.div_top` states that for any extended nonnegative real number `a`, the division of `a` by positive infinity (`⊤`) is equal to zero. This aligns with the mathematical concept that any real number divided by infinity approaches zero.

For any extended nonnegative real number `a`, `a / ⊤ = 0`.


List.Nodup.map

theorem List.Nodup.map :
    ∀ {α : Type u} {β : Type v} {l : List α} {f : α → β},
      Function.Injective f → List.Nodup l → List.Nodup (List.map f l) :=
  by sorry

This theorem states that for any given type `α` and `β`, a list `l` of type `α`, and a function `f` from `α` to `β`, if the function `f` is injective (meaning that identical outputs imply identical inputs) and the list `l` has no duplicate elements (each element appears at most once in the list), then the list resulting from mapping the function `f` over `l` (applying `f` to each element of `l`) will also have no duplicate elements.

If `f` is an injective function from type `α` to type `β` and list `l` of type `α` has no duplicates, then the list obtained by applying `f` to each element in `l` also has no duplicates.


theorem Mathlib.Order.Filter.Cofinite._auxLemma.1 :
    ∀ {α : Type u_2} {s : Set α}, (s ∈ Filter.cofinite) = Set.Finite sᶜ := by sorry

This theorem from the Mathlib library in Lean states that for any type `α` and any set `s` of this type, `s` belongs to the cofinite filter if and only if the complement of `s` is a finite set. Here, the cofinite filter is defined as the collection of subsets whose complements are finite. Thus, it establishes a direct connection between the concept of cofinite filters and finite sets, specifically through the complement of a set.

A set `s` of type `α` belongs to the cofinite filter if and only if the complement of `s` is finite.


theorem Complex.ofReal_cpow : ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), ↑(x ^ y) = ↑x ^ ↑y := by sorry

This theorem states that for any real number `x` that is greater than or equal to zero, and for any real number `y`, the complex representation of `x` raised to the power of `y` is equal to the complex representation of `x` raised to the power of the complex representation of `y`. In other words, if `x` is a non-negative real number and `y` is any real number, then `(x ^ y)` converted to a complex number is the same as `x` converted to a complex number and then raised to the power of `y` converted to a complex number. In mathematical notation, this could be expressed as ∀ x, y ∈ ℝ, x ≥ 0 ⇒ (x ^ y) ∈ ℂ = (x ∈ ℂ) ^ (y ∈ ℂ).

For any non-negative real number `x` and complex number `y`, `x^y` equals the complex number `x` raised to the power of `y`.


theorem Nat.finite_of_card_ne_zero : ∀ {α : Type u_1}, Nat.card α ≠ 0 → Finite α := by sorry

The theorem `Nat.finite_of_card_ne_zero` states that for any type `α`, if the cardinality of `α` as a natural number (i.e., `Nat.card α`) is not equal to zero, then `α` is a finite set. In other words, if a set has a non-zero cardinality when represented as a natural number, it must be finite. This follows the definition of `Nat.card`, where an infinite set has a cardinality of zero when represented as a natural number.

If the natural number representation of the cardinality of a type `α` is non-zero, then `α` is a finite set.


theorem Nat.dvd_div_iff : ∀ {a b c : ℕ}, c ∣ b → (a ∣ b / c ↔ c * a ∣ b) := by sorry

This theorem states that for all natural numbers `a`, `b`, and `c`, if `c` is a divisor of `b`, then `a` divides `b / c` if and only if `c * a` divides `b`. In other words, it establishes a connection between the divisibility of `b` by `a` and `c * a` under the assumption that `c` is a divisor of `b`.

For all natural numbers `a`, `b`, and `c`, if `c` divides `b`, then `a` divides `b / c` if and only if `c * a` divides `b`.


ContDiff.prod

/-- The cartesian product of `C^n` functions is `C^n`. -/
theorem ContDiff.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {f : E → F} {g : E → G},
      ContDiff 𝕜 n f → ContDiff 𝕜 n g → ContDiff 𝕜 n fun x => (f x, g x) :=
  by sorry

The theorem `ContDiff.prod` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, and `G` that are also normed spaces over `𝕜`, and for any functions `f : E → F` and `g : E → G` that are n-times continuously differentiable, the cartesian product function `(f, g) : E → F × G` is also n-times continuously differentiable. The cartesian product function is defined by `(f, g)(x) = (f(x), g(x))` for every `x` in `E`.

For any non-trivially normed fields `𝕜` and normed additive commutative groups/normed spaces `E`, `F`, and `G` over `𝕜`, if `f : E → F` and `g : E → G` are n-times continuously differentiable functions, then the cartesian product function `(f, g) : E → F × G` is also n-times continuously differentiable.


theorem Mathlib.Order.WithBot._auxLemma.1 : ∀ {α : Type u_1} {a b : α}, (↑a = ↑b) = (a = b) := by sorry

This theorem, named `_auxLemma.1` from the `Mathlib.Order.WithBot` namespace in Lean, states that for any type `α` and any two elements `a` and `b` of type `α`, the statement that the type-coerced `a` is equal to the type-coerced `b` is equivalent to the statement that `a` is equal to `b`. In other words, coercion does not change the equality relation between `a` and `b`.

For any type `α` and elements `a`, `b` of type `α` in Lean, the coerced elements `α to α a` and `α to α b` are equal if and only if `a` and `b` are equal.


theorem CategoryTheory.Arrow.cechNerve.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
      [inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
      (n : SimplexCategoryᵒᵖ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom :=
  by sorry

The theorem `CategoryTheory.Arrow.cechNerve.proof_1` states that for any category `C`, any arrow `f` in this category, and any natural number `n`, if `f` has a wide pullback in `C` for all `n`, then the wide pullback of `f` exists in the opposite simplex category. Here, an arrow is a morphism in `C`, a wide pullback is a limit of a wide cospan, and the simplex category consists of natural numbers as objects and monotone functions as morphisms.

If for every arrow `f` in a category `C` and natural number `n`, `f` has a wide pullback in `C`, then `f` has a wide pullback in the opposite simplex category.


theorem MeasureTheory.snorm_one_eq_lintegral_nnnorm :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
      {f : α → F}, MeasureTheory.snorm f 1 μ = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ :=
  by sorry

This theorem states that for any measured space 'α', any normed added commutative group 'F', any measurable function 'f' from 'α' to 'F', and any measure 'μ' on 'α', the ℒ¹ seminorm of 'f' (with respect to 'μ') is equal to the Lebesgue integral over 'α' of the nonnegative part of the norm of 'f'. In mathematical language, this is saying that `MeasureTheory.snorm f 1 μ` is equal to `∫⁻ (x : α), ↑‖f x‖₊ ∂μ`, where `‖f x‖₊` denotes the nonnegative part of the norm of 'f' at 'x'.

The ℒ¹ norm of a measurable function from a measured space to a normed additive commutative group, with respect to a given measure, equals the Lebesgue integral of the nonnegative part of its norm over the measured space.


theorem CategoryTheory.Iso.to_eq : ∀ {X : Type u} [inst : PartialOrder X] {x y : X}, (x ≅ y) → x = y := by sorry

This theorem states that for any type `X` in a partial order, if two elements `x` and `y` of `X` are isomorphic (denoted as `x ≅ y`), then `x` is equal to `y`. In other words, in the context of a partial order, isomorphic elements are necessarily equal.

In a partial order, isomorphic elements are equal.


theorem Nat.le_sqrt : ∀ {m n : ℕ}, m ≤ Nat.sqrt n ↔ m * m ≤ n := by sorry

This theorem, `Nat.le_sqrt`, in Lean 4 states a property about the square root of natural numbers. For any two natural numbers `m` and `n`, `m` is less than or equal to the square root of `n` if and only if the square of `m` is less than or equal to `n`. This theorem provides a connection between the integer square root function and the standard inequality of natural numbers.

For all natural numbers m and n, m ≤ √n if and only if m² ≤ n.


theorem SetTheory.PGame.turnBound_of_left :
    ∀ {S : Type u} [inst : SetTheory.PGame.State S] {s t : S},
      t ∈ SetTheory.PGame.State.l s →
        ∀ (n : ℕ), SetTheory.PGame.State.turnBound s ≤ n + 1 → SetTheory.PGame.State.turnBound t ≤ n :=
  by sorry

This theorem is about states in a positional game theory. It states that for any type `S` which is a state in a positional game, for any two states `s` and `t` of `S`, if state `t` is in the set of left moves from `s` (denoted by `SetTheory.PGame.State.l s`), then for any natural number `n`, if the turn bound of `s` (denoted by `SetTheory.PGame.State.turnBound s`) is less than or equal to `n + 1`, then the turn bound of `t` is less than or equal to `n`. In simple terms, it means if you can reach the state `t` by making a move from state `s`, then the turn bound of `t` is always less than or equal to the turn bound of `s` minus 1.

For any positional game state `S`, if `t` is in the set of left moves from state `s` in `S` and the turn bound of `s` is less than or equal to `n + 1`, then the turn bound of `t` is less than or equal to `n`.


/-- A specific witness of `I.directed` when `P` has joins.  -/
theorem Order.Ideal.sup_mem :
    ∀ {P : Type u_1} [inst : SemilatticeSup P] {x y : P} {s : Order.Ideal P}, x ∈ s → y ∈ s → x ⊔ y ∈ s := by sorry

This theorem states that, given a type `P` which is a semilattice with a supremum (or join), for any two elements `x` and `y` of `P` and an order ideal `s` of `P`, if `x` and `y` both belong to `s`, then the supremum of `x` and `y` (`x ⊔ y`) also belongs to `s`. This provides a specific case of `I.directed` when `P` has joins. In other words, in this type of order ideal, the sup (join) of any two members is still a member of the order ideal.

Given a semilattice `P` with supremum and an order ideal `s`, if `x` and `y` in `s` then `x ⊔ y` is in `s`.


theorem Fin.sum_univ_two :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] (f : Fin 2 → β), (Finset.sum Finset.univ fun i => f i) = f 0 + f 1 := by
  sorry

The theorem `Fin.sum_univ_two` states that for any function `f` from a two-element finite type (`Fin 2`) to a type `β` that forms an additive commutative monoid, computing the sum of `f` over all elements of the universal set (`Finset.univ`) results in the sum of `f` evaluated at `0` and `f` evaluated at `1`. In other words, if we apply `f` to each element of a two-element set and sum the results, we get `f(0) + f(1)`.

For any additive commutative monoid β and function f from a two-element finite set to β, the sum of f over the universal set is equal to f(0) + f(1).


theorem Polynomial.derivative_one : ∀ {R : Type u} [inst : Semiring R], Polynomial.derivative 1 = 0 := by sorry

The theorem `Polynomial.derivative_one` states that for any semiring `R`, the derivative of a constant polynomial, specifically the polynomial `1`, is `0`. That is, when we take the derivative of the constant polynomial `1` (considered as a polynomial over any semiring `R`), the result is the zero polynomial.

The derivative of the constant polynomial 1 over any semiring is the zero polynomial.


Filter.Eventually.curry

theorem Filter.Eventually.curry :
    ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {p : α × β → Prop},
      (∀ᶠ (x : α × β) in la ×ˢ lb, p x) → ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y) :=
  by sorry

This theorem states that for any given types `α` and `β`, and any given filters `la` on type `α` and `lb` on type `β`, if a certain property `p` holds eventually (i.e., outside a finite set) for pairs `(x, y)` drawn from `α` and `β` under the Cartesian product of `la` and `lb`, then it also holds that eventually, for any `x` drawn from `α` under `la`, the property `p` holds eventually for all `y` drawn from `β` under `lb`. In other words, if a property holds eventually for all pairs from two filters' Cartesian product, then the property also holds when we separate the components and consider them under their original filters.

If a property holds eventually for all pairs in the product of two filters, then the property holds eventually for each filter's elements when considering their respective projections.


theorem AddSubgroup.mem_zmultiples : ∀ {G : Type u_1} [inst : AddGroup G] (g : G), g ∈ AddSubgroup.zmultiples g := by
  sorry

This theorem states that for any given additive group `G` and an element `g` in `G`, `g` is an element of the subgroup generated by `g` itself. In other words, every element in an additive group is in the additive subgroup generated by itself. This is a fundamental property of groups in mathematics: any element of a group forms a cyclic subgroup with itself.

Every element in an additive group is in the subgroup generated by that element itself.


ringChar.spec

theorem ringChar.spec : ∀ (R : Type u_1) [inst : NonAssocSemiring R] (x : ℕ), ↑x = 0 ↔ ringChar R ∣ x := by sorry

The theorem `ringChar.spec` states that for any type `R` which is a non-associative semiring (denoted by `[inst : NonAssocSemiring R]`) and any natural number `x`, `x` (when promoted to the type `R`) is equal to zero if and only if `x` is divisible by the unique characteristic (`ringChar R`) of the semiring `R`.

For any non-associative semiring R and natural number x, x = 0 in R if and only if x is congruent to 0 modulo the unique characteristic of R.


theorem CategoryTheory.eqToHom_op :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : X = Y),
      (CategoryTheory.eqToHom h).op = CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.eqToHom_op` states that for any category 'C' and any two objects 'X' and 'Y' in 'C' such that 'X' equals 'Y' (denoted by 'h : X = Y'), the opposite morphism of the morphism from 'X' to 'Y' obtained through the function `CategoryTheory.eqToHom` using the equality 'h', is equal to the morphism obtained by applying `CategoryTheory.eqToHom` to some equality (suppressed for brevity). This means that the operation of taking the opposite does not change the morphism given by the equality between objects in the category.

For any category 'C' and objects 'X' and 'Y' with 'X = Y', the opposite morphisms of `CategoryTheory.eqToHom X Y` are equal.


/-- Deprecated, use `_root_.map_list_sum` instead. -/
theorem AddMonoidHom.map_list_sum :
    ∀ {M : Type u_5} {N : Type u_6} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N) (l : List M),
      f (List.sum l) = List.sum (List.map (⇑f) l) :=
  by sorry

The theorem `AddMonoidHom.map_list_sum` states that for any list `l` of elements of type `M` in an additive monoid, and any additive monoid homomorphism `f` from `M` to another additive monoid `N`, the result of applying `f` to the sum of the list `l` is equivalent to the sum of the list obtained by mapping `f` over `l`. In mathematical terms, this corresponds to the property ∑ (f(a_i)) = f(∑ a_i) where the sums range over all elements a_i of the list. This theorem is deprecated and `_root_.map_list_sum` should be used instead.

For any additive monoid `M`, list `l` of elements from `M`, and additive monoid homomorphism `f` from `M` to another additive monoid `N`, the sum of `f` applied to the elements of `l` equals `f` applied to the sum of `l`. That is, ∑(`f(l)`) = `f`(∑(`l`)).


theorem Fin.val_zero : ∀ (n : ℕ), ↑0 = 0 := by sorry

This theorem, named `Fin.val_zero`, states that for any natural number `n`, the value of the zero element in the finite set of size `n` is equal to zero. In other words, when you coerce zero from the finite set to the natural numbers, you get zero.

For any natural number `n`, the zero element of the finite set of size `n` equals the natural number zero.


theorem eq_div_iff : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, b ≠ 0 → (c = a / b ↔ c * b = a) := by
  sorry

This theorem, `eq_div_iff`, states that for any type `G₀` that is a GroupWithZero (i.e., a mathematical structure with operations of addition and multiplication, a zero element, and an inverse operation for all non-zero elements), given any three elements `a`, `b`, and `c` from `G₀` such that `b` is not zero, `c` is equal to the division of `a` by `b` if and only if the product of `c` and `b` is equal to `a`. This is a generalization of the standard mathematical property $c = \frac{a}{b} \Leftrightarrow cb = a$ for non-zero $b$.

For any group with zero `G₀` and non-zero `b` in `G₀`, `c` is the quotient of `a` by `b` if and only if `c` multiplied by `b` equals `a`.


theorem Cardinal.sum_const :
    ∀ (ι : Type u) (a : Cardinal.{v}),
      (Cardinal.sum fun x => a) = Cardinal.lift.{v, u} (Cardinal.mk ι) * Cardinal.lift.{u, v} a :=
  by sorry

The theorem `Cardinal.sum_const` states that for any type `ι` and any cardinal number `a`, the sum of constant `a` across all elements of type `ι` is equal to the product of the cardinality of type `ι` and `a` after both have been lifted to the correct universe. This corresponds to the mathematical notion that the cardinality of a product set is the product of the cardinalities of the individual sets.

For any cardinal number `a` and type `ι`, the sum of `a` in `ι` is equal to the product of the cardinality of `ι` and `a`.


theorem Computation.destruct_eq_think :
    ∀ {α : Type u} {s s' : Computation α}, Computation.destruct s = Sum.inr s' → s = Computation.think s' := by sorry

The theorem `Computation.destruct_eq_think` states that for any type `α` and any two computations `s` and `s'` of type `α`, if the destructor of `s` yields `s'` encapsulated in the right component of the sum type (`Sum.inr s'`), then `s` must be a computation that delays for one "tick" and then performs the computation `s'` (i.e., `s = Computation.think s'`). In other words, if the destruction of a computation gives another computation, then the original computation is actually a delayed version of the resulting computation.

If `s` and `s'` are computations of type `α` such that `s` destructs to `Sum.inr s'`, then `s` is equal to the delayed computation `Computation.think s'`.


theorem CategoryTheory.ShortComplex.p_descOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) {A : C} (k : S.X₂ ⟶ A) (hk : CategoryTheory.CategoryStruct.comp S.f k = 0)
      [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.pOpcycles S)
          (CategoryTheory.ShortComplex.descOpcycles S k hk) =
        k :=
  by sorry

The theorem `CategoryTheory.ShortComplex.p_descOpcycles` states that for any category having zero morphisms, given a short complex `S` in the category, and a morphism `k` from `S.X₂` to a category object `A` such that the composition of `S.f` and `k` is the zero morphism, if `S` has right homology then the composition of `CategoryTheory.ShortComplex.pOpcycles S` and `CategoryTheory.ShortComplex.descOpcycles S k hk` equals `k`.

In more detail, this theorem is about the interaction of certain morphisms in a short complex, a structure in category theory. If `S` is a short complex in a category `C`, `k` is a morphism from the second object of the complex `S.X₂` to an object `A` in `C`, and the composition of `S.f` and `k` is the zero morphism (represented in Lean as `CategoryTheory.CategoryStruct.comp S.f k = 0`), then when `S` has a property called right homology, the composition of the morphism from `S.X₂` to the 'opposite cycles' of `S` (`CategoryTheory.ShortComplex.pOpcycles S`) and the morphism from the 'opposite cycles' of `S` to `A` that is characterized by `k` (`CategoryTheory.ShortComplex.descOpcycles S k hk`) is `k` itself. The theorem thus describes a 'reversibility' property for this particular sequence of morphisms and operations in a short complex with right homology.

Given a short complex in a category with zero morphisms and right homology, if a morphism from the second object to an object in the category making the composition with the complex's forward morphism zero is equal to the descent morphism of cycles through that morphism, then the morphisms are equal.


theorem Set.infinite_image_iff :
    ∀ {α : Type u} {β : Type v} {s : Set α} {f : α → β}, Set.InjOn f s → (Set.Infinite (f '' s) ↔ Set.Infinite s) := by
  sorry

This theorem states that for any types `α` and `β`, a set `s` of type `α`, and a function `f` that maps from `α` to `β`, if `f` is injective on the set `s`, then the image of the set `s` under `f` is infinite if and only if the set `s` itself is infinite. In other words, an injective function preserves the infiniteness of a set.

For any injective function `f` between sets `α` and `β`, if `α` is infinite, then so is the image `f(α)`.


HasDerivAt.hasFDerivAt

/-- **Alias** of the forward direction of `hasDerivAt_iff_hasFDerivAt`.

---

Expressing `HasDerivAt f f' x` in terms of `HasFDerivAt`  -/
theorem HasDerivAt.hasFDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {f' : F},
      HasDerivAt f f' x → HasFDerivAt f (ContinuousLinearMap.smulRight 1 f') x :=
  by sorry

The theorem `HasDerivAt.hasFDerivAt` states that, given a nontrivially normed field `𝕜`, a normed additive commutative group `F`, and a normed space `𝕜 F`, for any function `f : 𝕜 → F`, point `x` in `𝕜`, and derivative `f'` in `F`, if `f` has the derivative `f'` at the point `x` (expressed as `HasDerivAt f f' x`), then `f` also has the continuous linear map `f'` as a derivative at `x` (expressed as `HasFDerivAt f (ContinuousLinearMap.smulRight 1 f') x`). The continuous linear map in this case is represented by the scalar multiplication of `f'` by `1`.

Given a nontrivially normed field 𝕜, a normed additive commutative group F, and a normed space 𝕜⊗F over 𝕜, if a function f : 𝕜 → F has the derivative f' at x in 𝕜 and f' is continuous, then f has the continuous linear derivative f' at x.


theorem Asymptotics.isLittleO_zero :
    ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} [inst : SeminormedAddCommGroup E']
      [inst_1 : SeminormedAddCommGroup F'] (g' : α → F') (l : Filter α), (fun _x => 0) =o[l] g' :=
  by sorry

This theorem states that for any types `α`, `E'`, and `F'`, where `E'` and `F'` are seminormed additive commutative groups, and any function `g'` from `α` to `F'`, and any filter `l` on `α`, the function that is constantly zero is little-o of `g'` at `l`. In simpler terms, as we get closer to the limit `l`, the values of the function `g'` grow much faster than the constant function that always equals zero. This is a fundamental concept in asymptotic analysis.

For any seminormed additive commutative groups `E'` and `F'`, function `g': α → F'`, and filter `l` on `α`, if for all `ε > 0`, there exists a `δ > 0` such that `∀x, y ∈ α`, `x ∈ l`, `d(x, y) < δ` implies `∥g'(x) - g'(y)∥ < ε`, then `0` is little-o of `g'` at `l`.


theorem MeasureTheory.integral_smul :
    ∀ {α : Type u_1} {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {G : Type u_5} [inst_1 : NormedAddCommGroup G]
      [inst_2 : NormedSpace ℝ G] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst_3 : NormedSpace 𝕜 G]
      [inst_4 : SMulCommClass ℝ 𝕜 G] (c : 𝕜) (f : α → G), ∫ (a : α), c • f a ∂μ = c • ∫ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_smul`, states that for any type `α`, a type `𝕜` which is a non-trivially normed field, a type `G` which is a normed commutative add group, and where `G` is a normed space over both `ℝ` (the real numbers) and `𝕜`, given a measurable space `m`, a measure `μ` on that space, and given that `G` is a scalar multiplication commutative class under `ℝ` and `𝕜`, then for any scalar constant `c` from `𝕜` and any function `f` from `α` to `G`, the integral of the scaled function `c • f`  with respect to measure `μ` is equal to `c` scaled by the integral of function `f` with respect to measure `μ`. In mathematical notation, ∫ c • f dμ = c • ∫ f dμ.

For any normed field `𝕜`, normed commutative add group `G` over `𝕜` and `ℝ`, measurable space `(m, μ)`, and scalar multiplication commutative class `G` under `𝕜` and `ℝ`, the integral of `c • f` with respect to `μ` equals `c` times the integral of `f` with respect to `μ` for any scalar `c` in `𝕜` and measurable function `f` from a type `α` to `G`.


theorem CategoryTheory.Localization.Construction.fac :
    ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} {D : Type uD}
      [inst_1 : CategoryTheory.Category.{uD', uD} D] (G : CategoryTheory.Functor C D)
      (hG : CategoryTheory.MorphismProperty.IsInvertedBy W G),
      CategoryTheory.Functor.comp (CategoryTheory.MorphismProperty.Q W)
          (CategoryTheory.Localization.Construction.lift G hG) =
        G :=
  by sorry

This theorem states that, given a category `C` with a morphism property `W` and another category `D`, if we have a functor `G` from `C` to `D` that inverts all morphisms in `W` (i.e., maps them to isomorphisms in `D`), then composing the functor `Q` associated with `W` with the localization lift of `G` (given by `CategoryTheory.Localization.Construction.lift G hG`) yields the original functor `G`. This localization construction is a key concept in category theory and this theorem formalizes one of its fundamental properties.

Given a category `C` with a morphism property `W`, a functor `G: C -> D`, and a localization of `C` at `W`, the functor `Q` associated with `W` and the lift `lift G hG` commute, i.e., `Q ∘ lift G hG = G`.


Set.PairwiseDisjoint.subset

theorem Set.PairwiseDisjoint.subset :
    ∀ {α : Type u_1} {ι : Type u_4} [inst : PartialOrder α] [inst_1 : OrderBot α] {s t : Set ι} {f : ι → α},
      Set.PairwiseDisjoint t f → s ⊆ t → Set.PairwiseDisjoint s f :=
  by sorry

The theorem `Set.PairwiseDisjoint.subset` states that for any types `α` and `ι`, with `α` being a partially ordered set that also has a least element, if a set `t` of elements of type `ι` is pairwise disjoint under a function `f` from `ι` to `α`, then any subset `s` of `t` is also pairwise disjoint under the same function `f`. In other words, if the images of any two different elements of `t` under `f` do not overlap, this will also hold for any subset `s` of `t`.

If `α` is a partially ordered set with a least element and `f : ι → α` is a function such that the images of distinct elements in any pairwise disjoint set `t` of `ι` under `f` are disjoint, then any subset `s` of `t` is also pairwise disjoint under `f`.


theorem Mathlib.Algebra.Module.Submodule.Map._auxLemma.1 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} [inst_6 : RingHomSurjective σ₁₂] {F : Type u_9} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F σ₁₂ M M₂] {f : F} {p : Submodule R M} {x : M₂},
      (x ∈ Submodule.map f p) = ∃ y ∈ p, f y = x :=
  by sorry

This theorem states that for all types `R`, `R₂`, `M`, `M₂`, and `F`, given the instances of `R` and `R₂` as semirings, `M` and `M₂` as additive commutative monoids, `M` as a module over `R`, `M₂` as a module over `R₂`, a ring homomorphism `σ₁₂` from `R` to `R₂` which is surjective, `F` as a type that behaves like a function from `M` to `M₂`, and `F` as a semilinear map class with respect to `σ₁₂`, `M`, and `M₂`, and given an element `f` of type `F`, a submodule `p` of `M`, and an element `x` of `M₂`, then `x` is in the image of the submodule `p` under the function `f` if and only if there exists an element `y` in `p` such that `f(y) = x`.

In other words, it is characterizing the elements of the image of a submodule under a (semi)linear map in terms of elements of the submodule itself.

For a surjective ring homomorphism σ₁₂ between semirings R and R₂, a semilinear map F from an additive commutative monoid M (a module over R) to another additive commutative monoid M₂, and any submodule p of M, an element x in M₂ is in the image of p under F if and only if there exists y in p such that F(y) = x.


theorem Mathlib.Order.Disjoint._auxLemma.4 :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a a = (a = ⊥) := by sorry

The theorem, `Mathlib.Order.Disjoint._auxLemma.4`, states that for any type `α` that has a partial order and a least element (denoted by `⊥`), an element `a` of `α` is said to be disjoint with itself if and only if `a` is the bottom element `⊥`. This is a property of lattice theory, where the term "disjoint" is generalized to mean that the infimum (greatest lower bound) of two elements is the bottom element. In this case, the theorem deals with the special scenario where the two elements are identical.

For any type `α` with a partial order and a least element `⊥`, an element `a` is disjoint with itself if and only if `a = ⊥`.


/-- Product of elements of a submonoid of a `CommMonoid` indexed by a `Finset` is in the
submonoid.  -/
theorem prod_mem :
    ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
      {ι : Type u_5} {t : Finset ι} {f : ι → M}, (∀ c ∈ t, f c ∈ S) → (Finset.prod t fun c => f c) ∈ S :=
  by sorry

The theorem `prod_mem` states that for any type `B`, element `S` of `B`, commutative monoid `M`, and any indexing type `ι`, if you have a finite set `t` (of type `Finset ι`) and a function `f` that maps elements of `ι` to `M`, then the product of the function `f` applied to the elements of the finite set `t` (denoted by `Finset.prod t fun c => f c`) is an element of `S`. This holds if and only if for each element `c` in the finite set `t`, `f c` is an element of `S`. This theorem basically says that the product of elements of a submonoid of a commutative monoid, indexed by a finite set, remains in the submonoid.

If `t` is a finite set, `B` a type, `S` an element of `B`, `M` a commutative monoid, and `f : ι → M` a function, then `Finset.prod t fun c => f c ∈ S` if and only if `∀c ∈ t, f c ∈ S`.


Filter.Tendsto.div

theorem Filter.Tendsto.div :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀]
      [inst_2 : HasContinuousInv₀ G₀] [inst_3 : ContinuousMul G₀] {f g : α → G₀} {l : Filter α} {a b : G₀},
      Filter.Tendsto f l (nhds a) → Filter.Tendsto g l (nhds b) → b ≠ 0 → Filter.Tendsto (f / g) l (nhds (a / b)) :=
  by sorry

The theorem `Filter.Tendsto.div` asserts that for any types `α` and `G₀`, given `G₀` is a group with zero, has a topological space structure, possesses a continuous inverse, and admits continuous multiplication, if `f` and `g` are functions from `α` to `G₀`, `l` is a filter on `α`, and `a` and `b` are elements of `G₀` such that `b` is not zero, then if `f` tends to `a` and `g` tends to `b` along `l` (as defined by the `Filter.Tendsto` function), then `f / g` (the pointwise division of `f` and `g`) tends to `a / b` along `l`. In other words, the limit of the quotient of two functions is the quotient of their limits, provided the limit of the denominator function is not zero.

If `f` and `g` are functions from a filtered space `(α, l)` to a group `G₀` with a topology, having continuous inverses and multiplication, and if `f` tends to `a` and `g` tends to `b` (not zero) along `l`, then `f / g` tends to `a / b` along `l`.


theorem dvd_normalize_iff :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {a b : α},
      a ∣ normalize b ↔ a ∣ b :=
  by sorry

The theorem `dvd_normalize_iff` states that for any type `α` that forms a `CancelCommMonoidWithZero` and a `NormalizationMonoid`, and any elements `a` and `b` of this type, `a` divides the normalized form of `b` if and only if `a` divides `b`. Here, "normalizing" an element is achieved by multiplying it with the norm unit of that element, as defined in the `normalize` function.

For any type `α` that forms a CancelCommMonoidWithZero and a NormalizationMonoid, `a` divides the normalization of `b` in `α` if and only if `a` divides `b`.


theorem max_def : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), max a b = if a ≤ b then b else a := by sorry

This theorem, `max_def`, states that for all types `α` (assuming `α` has an instance of `LinearOrder`, which provides an ordering for elements of `α`), the maximum of any two elements `a` and `b` of type `α` is determined as follows: If `a` is less than or equal to `b`, then the maximum is `b`; otherwise, the maximum is `a`.

For any type `α` with a LinearOrder instance, the maximum of `a` and `b` in `α` is `a` if `a` is greater than `b`, and is `b` otherwise.


theorem LinearEquiv.symm_symm :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
      LinearEquiv.symm (LinearEquiv.symm e) = e :=
  by sorry

This theorem states that for any two types `M` and `M₂` with associated semirings `R` and `S`, if they are equipped with addition-commutative monoid structures and module structures, and `σ` and `σ'` form a pair of inverse ring homomorphisms between `R` and `S`, then for any linear equivalence `e` between `M` and `M₂` under the ring homomorphism `σ`, the double application of the symmetry operation on `e` (i.e., applying symmetry twice in succession) will yield the original equivalence `e`. This means that the symmetry operation is its own inverse.

Given types `M` and `M₂` with semirings `R` and `S`, equipped with addition-commutative monoid and module structures, and having ring homomorphisms `σ: R → S` and `σ': S → R` that form an inverse pair, any linear equivalence `e: M ≃ₐσ M₂` satisfies `e ∘ symmetry(e) = id`.


theorem tendsto_order :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {f : β → α}
      {a : α} {x : Filter β},
      Filter.Tendsto f x (nhds a) ↔ (∀ a' < a, ∀ᶠ (b : β) in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ (b : β) in x, f b < a' :=
  by sorry

This theorem, `tendsto_order`, establishes a characterization of the limit of a function in terms of order theory. Given a function `f` from type `β` to `α` where `α` has a topology and a preorder structure and the topology is compatible with this preorder, then we say that the function `f` tends towards `a` as per the filter `x` if and only if for all values `a'` less than `a`, eventually (as dictated by the filter `x`), the function `f` mapped to `b` is greater than `a'`, and similarly for all `a'` greater than `a`, eventually, the function `f` mapped to `b` is less than `a'`. Here, "eventually" refers to the filter on `β` which can be thought of as a generalized notion of sequence or condition that becomes true "in the limit".

Given a compatible preorder and topology on `α`, a function `f : β → α` tends towards `a` as per filter `x` if and only if for all `a' < a`, eventually `f(b) > a'` for some `b ∈ x`, and for all `a' > a`, eventually `f(b) < a'` for some `b ∈ x`.


theorem Int.cast_inj : ∀ {α : Type u_1} [inst : AddGroupWithOne α] [inst_1 : CharZero α] {m n : ℤ}, ↑m = ↑n ↔ m = n :=
  by sorry

This theorem, `Int.cast_inj`, states that for any type `α` that has an `AddGroupWithOne` and `CharZero` structure, the equality of the casted integers `m` and `n` to type `α` implies and is implied by the equality of `m` and `n` themselves. In simpler terms, casting does not change the equality relationship between two integers, `m` and `n`, in the context of an additive group with one and a characteristic zero type.

For any type `α` with an AddGroupWithOne and CharZero structure, the casted integers `m` and `n` are equal if and only if `m` and `n` are equal as integers.


theorem Rat.divInt_zero : ∀ (n : ℤ), Rat.divInt n 0 = 0 := by sorry

The theorem `Rat.divInt_zero` states that for any integer `n`, the function `Rat.divInt` returns zero when the second argument is zero. In other words, when dividing any integer by zero, the result is always zero. This is mathematically represented as ∀ n ∈ ℤ, n / 0 = 0.

For all integers n, the quotient of n and 0 is equal to zero.


theorem AlgebraicGeometry.LocallyRingedSpace.Hom.ext :
    ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (x y : AlgebraicGeometry.LocallyRingedSpace.Hom X Y),
      x.val = y.val → x = y :=
  by sorry

This theorem states that for any two locally ringed spaces `X` and `Y`, and any two homomorphisms `x` and `y` from `X` to `Y`, if the underlying topological space element of `x` is equal to that of `y`, then `x` and `y` are equal. In other words, the equality of locally ringed space homomorphisms is determined by the equality of their underlying topological space elements.

If two homomorphisms between locally ringed spaces have equal underlying topological spaces, then they are equal.


theorem associated_zero_iff_eq_zero : ∀ {α : Type u_1} [inst : MonoidWithZero α] (a : α), Associated a 0 ↔ a = 0 := by
  sorry

The theorem `associated_zero_iff_eq_zero` states that for any type `α` that has the structure of a `MonoidWithZero`, an element `a` of type `α` is "associated" with zero if and only if `a` is zero itself. In the context of monoids, two elements are typically "associated" if one can be obtained from the other by multiplication with a unit. However, in a `MonoidWithZero`, the only way for an element to be associated with zero is if the element is zero itself, since multiplying any non-zero element by a unit cannot yield zero.

In a MonoidWithZero type, an element is associated with zero if and only if it is equal to zero.


theorem AddCommGroup.modEq_comm :
    ∀ {α : Type u_1} [inst : AddCommGroup α] {p a b : α}, a ≡ b [PMOD p] ↔ b ≡ a [PMOD p] := by sorry

This theorem states that for any type `α` that is an instance of an additive commutative group, and for any elements `p`, `a`, and `b` in this group, the congruence `a` is congruent to `b` modulo `p` is equivalent to `b` being congruent to `a` modulo `p`. In simpler terms, the order of `a` and `b` does not matter when we are checking for their congruence modulo `p` in an additive commutative group.

In an additive commutative group, the congruences of two elements are equal modulo a third element if and only if the elements are congruent to each other modulo that element.


theorem MeasureTheory.integrable_condexp :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → F'},
      MeasureTheory.Integrable (MeasureTheory.condexp m μ f) μ :=
  by sorry

The theorem `MeasureTheory.integrable_condexp` states that for any type `α` and any type `F'` that forms a normed additive commutative group and a normed space over the reals with complete space, for any measurable spaces `m` and `m0` over α, for any measure `μ` on `α`, and for any function `f` from `α` to `F'`, the conditional expectation of `f` (denoted as `MeasureTheory.condexp m μ f`) is integrable with respect to the measure `μ`. In other words, the conditional expectation of `f` is both measurable and has a finite integral.

For any measurable space `(α, m)`, measure `μ`, normed additive commutative group and normed space `(F', ||·||)` over the reals with complete space, and measurable function `f: α → F'`, the conditional expectation `MeasureTheory.condexp m μ f` is an integrable function with respect to `μ`.


theorem ContinuousLinearMap.ext_ring :
    ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_4} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
      [inst_3 : Module R₁ M₁] [inst_4 : TopologicalSpace R₁] {f g : R₁ →L[R₁] M₁}, f 1 = g 1 → f = g :=
  by sorry

This theorem asserts that for any two continuous linear maps `f` and `g` from a semiring `R₁` to a topological module `M₁` over `R₁`, if `f` and `g` map the multiplicative identity (1) of `R₁` to the same value in `M₁`, then `f` and `g` are equal. This means that for these structures, a continuous linear map is uniquely determined by its value at 1.

Given two continuous linear maps `f` and `g` from a semiring `R₁` to a topological module `M₁` over `R₁`, if `f` and `g` map the multiplicative identity `1` of `R₁` to the same element in `M₁`, then `f` equals `g`.


theorem map_mem_closure₂ :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y → Z} {x : X} {y : Y} {s : Set X} {t : Set Y} {u : Set Z},
      Continuous (Function.uncurry f) →
        x ∈ closure s → y ∈ closure t → (∀ a ∈ s, ∀ b ∈ t, f a b ∈ u) → f x y ∈ closure u :=
  by sorry

The theorem `map_mem_closure₂` states that for any three topological spaces `X`, `Y`, and `Z`, and for any function `f` from `X` to `Y` to `Z`, if the function `f` is continuous when uncurried, then for any points `x` in the closure of set `s` and `y` in the closure of set `t`, and for all elements `a` in set `s` and `b` in set `t` such that `f a b` belongs to set `u`, it follows that the function `f` applied to `x` and `y` belongs to the closure of set `u`.

In other words, this theorem is a result about continuous functions and closures in topological spaces. It specifically deals with the case where the function is uncurried - i.e., it takes a pair of inputs instead of a single one. It asserts that the image under such a function of a point from the closure of a product of two sets is contained in the closure of the image of that product set under the function.

If functions `f : X × X → Z` are uncurried continuous, then for any sets `s ⊆ X` and `t ⊆ Y` such that `f(s × t) ⊆ u`, and for all `a ∈ s`, `b ∈ t`, and `f(a, b) ∈ u`, it follows that `f(cl(a), cl(b)) ∈ cl(u)`, where `cl` denotes the closure operator.


theorem MeasureTheory.hasFiniteIntegral_def :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : α → β)
      (μ : MeasureTheory.Measure α), MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤ :=
  by sorry

The theorem `MeasureTheory.hasFiniteIntegral_def` states that for any types `α` and `β`, where `β` is a normed add commutative group, any measurable space `α`, any function `f` from `α` to `β`, and any measure `μ` on `α`, the function `f` has a finite integral with respect to measure `μ` if and only if the Lebesgue integral over `α` of the nonnegative extended real norm of `f` with respect to measure `μ` is less than infinity. This theorem provides a precise mathematical definition of what it means for a function to have a finite integral in measure theory.

A measurable function from a measurable space to a normed add commutative group has a finite integral with respect to a measure if and only if the Lebesgue integral of the function's nonnegative extended real norm is finite.


theorem Pretrivialization.mem_target :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} (e : Pretrivialization F proj) {x : B × F}, x ∈ e.target ↔ x.1 ∈ e.baseSet :=
  by sorry

This theorem, "Pretrivialization.mem_target", states that for all types `B`, `F`, and `Z` where `B` and `F` are topological spaces and `proj` is a function from `Z` to `B`, and given a pretrivialization `e` of `F` with respect to `proj` and a pair `x` of `B` and `F`, then `x` is in the target of `e` if and only if the first element of `x` is in the base set of `e`.

For any topological spaces B, F, and Z, and a pretrivialization e of F over B with respect to a map proj : Z -> B, the pair (x.1, x) is in the target of e if and only if x.1 is in the base set of e.


theorem Finsupp.total_apply :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {v : α → M} (l : α →₀ R), (Finsupp.total α M R v) l = Finsupp.sum l fun i a => a • v i :=
  by sorry

The theorem `Finsupp.total_apply` states that for any types `α`, `M`, and `R`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is a module over `R`, and for any function `v : α → M` and `l : α →₀ R`, applying the total function `Finsupp.total α M R v` to `l` is equivalent to computing the sum over `l` where each term in the sum is a scalar multiple of `v i`, where the scalar is `a` and the multiplication is given by the module structure. In simpler terms, this theorem equates the total of a linear combination to the sum of the scaled vectors in the combination.

For any semiring `R`, additive commutative monoid `M` that is an `R`-module, function `v : α → M`, and `α`-indexed family `l : α →₀ R`, the sum of scaled vectors `∑ i in α, l i ⊤ v i` equals the application of the total function `Finsupp.total α M R v` to `l`.


theorem Finset.card_le_card_of_inj_on :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (f : α → β),
      (∀ a ∈ s, f a ∈ t) → (∀ a₁ ∈ s, ∀ a₂ ∈ s, f a₁ = f a₂ → a₁ = a₂) → s.card ≤ t.card :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of arbitrary types `α` and `β`, respectively, if a function `f` maps each element of `s` to an element of `t` and `f` is injective (meaning that different elements in `s` map to different elements in `t`), then the cardinality (or size) of `s` is less than or equal to the cardinality of `t`. In other words, an injective function from `s` to `t` cannot increase the size of the set.

If `f` is an injective function from finite sets `s` and `t` with types `α` and `β` respectively, then the cardinality of `s` is less than or equal to the cardinality of `t`.


theorem Set.mem_empty_iff_false : ∀ {α : Type u} (x : α), x ∈ ∅ ↔ False := by sorry

This theorem states that for any type `α` and any element `x` of this type, the proposition "element `x` belongs to the empty set" is logically equivalent to `False`. In other words, no element can belong to the empty set in the universe of set theory.

For any type `α` and any of its elements `x`, `x ∈ ∅` is logically equivalent to `False`. (In the context of Lean or set theory, `∅` represents the empty set.)


theorem Rat.zero_divInt : ∀ (n : ℤ), Rat.divInt 0 n = 0 := by sorry

The theorem `Rat.zero_divInt` states that for any integer `n`, the result of the function `Rat.divInt` with the first argument as 0 and the second argument as `n` is always 0. In mathematical terms, it is equivalent to saying that $\frac{0}{n} = 0$ for any integer `n`.

The theorem asserts that for all integers `n`, the quotient of 0 by `n` is equal to 0 in the `Rat` type of Lean. In mathematical notation, $\text{Rat}(0/n) = 0$.


theorem Real.isBounded_iff_bddBelow_bddAbove : ∀ {s : Set ℝ}, Bornology.IsBounded s ↔ BddBelow s ∧ BddAbove s := by
  sorry

The theorem `Real.isBounded_iff_bddBelow_bddAbove` states that for any set `s` of real numbers, the set is bounded with respect to the ambient bornology (a structure that specifies which sets are "bounded") if and only if the set is bounded both below and above. In other words, a set of real numbers is considered bounded in this context if there exists both a lower bound and an upper bound for the set.

A set of real numbers is bounded with respect to the ambient bornology if and only if it has both a lower bound and an upper bound.


theorem Subalgebra.smul_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A) {x : A}, x ∈ S → ∀ (r : R), r • x ∈ S :=
  by sorry

This theorem, `Subalgebra.smul_mem`, states that for any given types R and A, where R is a commutative semiring and A is a semiring with an algebra structure over R, and for any subalgebra S of A, if an element x belongs to S, then the scaling of x by any scalar r from R also belongs to S. In other words, the scalar multiplication of any element in the subalgebra by any scalar in R remains within the subalgebra.

For any commutative semiring R, semiring A with an algebra structure over R, and subalgebra S of A, if x is in S and r is in R, then r \* x is in S. (Here, \* denotes scalar multiplication.)


theorem Matrix.isUnit_det_of_invertible :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
      [inst_3 : Invertible A], IsUnit (Matrix.det A) :=
  by sorry

This theorem states that for any square matrix `A` with indices of type `n` and elements of type `α`, where `α` is a type over a commutative ring, and `n` is a finite type with decidable equality, if `A` is invertible, then the determinant of `A` is a unit in the commutative ring `α`. In terms of linear algebra, this essentially means that the determinant of any invertible square matrix is a non-zero element in the underlying field or ring, thus having a multiplicative inverse.

If `A` is a square matrix of type `n x n` over a commutative ring `α` with decidable equality and `n` finite, and `A` is invertible, then the determinant of `A` is a unit in `α`.


LipschitzWith.comp

/-- The composition of Lipschitz functions is Lipschitz.  -/
theorem LipschitzWith.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] {Kf Kg : NNReal} {f : β → γ} {g : α → β},
      LipschitzWith Kf f → LipschitzWith Kg g → LipschitzWith (Kf * Kg) (f ∘ g) :=
  by sorry

The theorem `LipschitzWith.comp` asserts that the composition of Lipschitz continuous functions is also Lipschitz continuous. More formally, given two functions `f` and `g` of types `β → γ` and `α → β` respectively, if `f` is Lipschitz continuous with a nonnegative real constant `Kf` and `g` is Lipschitz continuous with a nonnegative real constant `Kg`, then their composition `(f ∘ g)` is Lipschitz continuous with the constant being the product of `Kf` and `Kg`. Here, `α`, `β`, and `γ` are types equipped with a pseudo emetric space structure which allows us to measure distance between elements of these types.

If functions `f: β → γ` and `g: α → β` are Lipschitz continuous with constants `Kf` and `Kg` respectively, then their composition `f ∘ g: α → γ` is Lipschitz continuous with constant `Kf * Kg`.


theorem Real.tendsto_exp_atBot : Filter.Tendsto Real.exp Filter.atBot (nhds 0) := by sorry

This theorem states that the real exponential function (`Real.exp`) tends to 0 as its argument tends to negative infinity. In other words, as we take the limit of the function `Real.exp` as the input goes to negative infinity (`Filter.atBot`), the output approaches 0 (`nhds 0`). This is formalized in Lean using the `Filter.Tendsto` predicate, which serves as the generic predicate for expressing the limit of a function.

The real exponential function `Real.exp` approaches 0 as its argument approaches negative infinity.


theorem continuous_quot_mk : ∀ {X : Type u} [inst : TopologicalSpace X] {r : X → X → Prop}, Continuous (Quot.mk r) := by
  sorry

This theorem states that for any type `X` equipped with a topological space structure and for any equivalence relation `r` on `X`, the quotient map (`Quot.mk r`) that sends each element of `X` to its equivalence class in the quotient space `Quot r` is continuous. In other words, the preimage of any open set in the quotient space `Quot r` under this map is an open set in `X`. This is a fundamental property in topology, especially when dealing with the quotient spaces.

Given a topological space `(X, τ)` and an equivalence relation `r` on `X`, the quotient map `Quot.mk r : X → Quot r` is a continuous function.


theorem ENNReal.zero_rpow_of_neg : ∀ {y : ℝ}, y < 0 → 0 ^ y = ⊤ := by sorry

This theorem states that for any real number `y` that is less than zero, the expression `0 ^ y` will evaluate to positive infinity. In mathematical terms, if y ∈ ℝ and y < 0, then 0 to the power of y (0^y) is positive infinity.

For any real number `y` less than zero, `0^y` is positive infinity.


theorem Polynomial.coeff_one_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.coeff 1 0 = 1 := by sorry

The theorem `Polynomial.coeff_one_zero` states that for any semiring `R`, the coefficient of `X^0` in the polynomial `1` is `1`. In other words, when you look at the constant polynomial `1` and retrieve the coefficient of the term `X^0`, you will always get `1`.

For any semiring R, the constant polynomial 1 in R[X] has a coefficient of 1 for the term X^0.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.15 : (⊤ = 0) = False := by sorry

This theorem states that infinity, designated as "⊤" in the Lean 4 language, is not equal to zero. In other words, the proposition that infinity is equal to zero is false. This is aligned with established mathematical principles, where infinity represents an unbounded quantity that is greater than any finite number, and hence cannot be equal to zero.

In Lean 4, the proposition that infinity (⊤) equals zero is false.


theorem Embedding.continuous_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z], Embedding g → (Continuous f ↔ Continuous (g ∘ f)) :=
  by sorry

This theorem states that for any types `X`, `Y`, and `Z`, and any functions `f` from `X` to `Y` and `g` from `Y` to `Z`, assuming `X`, `Y`, `Z` are topological spaces, and `g` is an embedding, then `f` is continuous if and only if the composition of `g` and `f` (`g ∘ f`) is continuous. In mathematical terms, if `g` is an embedding from a topological space `Y` to `Z`, then a function `f` from `X` to `Y` is continuous if and only if the function obtained by composing `f` with `g` is continuous.

If `g` is a topological space embedding from `Y` to `Z`, then a function `f` from `X` to `Y` is continuous if and only if the composition `g ∘ f` is continuous.


theorem inf_right_comm : ∀ {α : Type u} [inst : SemilatticeInf α] (a b c : α), a ⊓ b ⊓ c = a ⊓ c ⊓ b := by sorry

This theorem states that for any type `α` that is a semilattice with respect to the infimum operation, the order of infimum operations is commutative on the right side. In other words, for all elements `a`, `b`, and `c` of this type, the infimum of `a`, `b`, and `c` remains the same whether we first take the infimum of `b` and `c` and then with `a`, or first take the infimum of `c` and `b` and then with `a`. In mathematical notation, it states that $a \wedge (b \wedge c) = a \wedge (c \wedge b)$.

For any semilattice `α` with respect to infimum, the associativity of infimum holds: `a ∧ (b ∧ c) = a ∧ (c ∧ b)`.


theorem Multiset.card_lt_card : ∀ {α : Type u_1} {s t : Multiset α}, s < t → Multiset.card s < Multiset.card t := by
  sorry

This theorem, `Multiset.card_lt_card`, states that for any type `α` and any two multisets `s` and `t` of that type, if `s` is less than `t` then the cardinality of `s` (i.e., the sum of the multiplicities of all its elements, which is effectively the length of the list representing `s`) is less than the cardinality of `t`. In other words, if one multiset is smaller than another, then the number of elements (counting repeats) in the first multiset is less than the number of elements in the second.

For any type α and multisets s and t of that type, if s < t then |s| < |t|, where |.| denotes the cardinality.


theorem Part.bind_none : ∀ {α : Type u_1} {β : Type u_2} (f : α → Part β), Part.bind Part.none f = Part.none := by sorry

The theorem `Part.bind_none` states that for any function `f` from a type `α` to a partial type `β`, binding `Part.none` (representing a "null" or "empty" partial value) with function `f` results in `Part.none`. This can be understood as saying that when we try to apply `f` to an undefined or non-existent value (represented by `Part.none`), the result is again undefined or non-existent. In mathematical terms, it asserts that partial function binding with an undefined value leads to an undefined result, irrespective of the function used in the binding process.

For any partial function `f` from type `α` to partial type `β`, `bind (Part.none) f = Part.none`.


theorem Real.log_abs : ∀ (x : ℝ), Real.log |x| = Real.log x := by sorry

This theorem states that for every real number `x`, the real logarithm of the absolute value of `x` is equal to the real logarithm of `x` itself. In mathematical notation, this would be expressed as ∀x ∈ ℝ, log(|x|) = log(x). The theorem is applicable under the unconventional extension of the logarithm function to `(-∞, 0]` in Lean, which allows the logarithm function to retain some important properties, such as `log(x * y) = log(x) + log(y)` for all nonzero `x` and `y`, and the derivative of `log` being `1/x` away from `0`.

The theorem asserts that for all real numbers x, the absolute value of x's logarithm is equal to x's logarithm: log(|x|) = log(x).


theorem Finset.card_Ico_eq_card_Icc_sub_one :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a b : α),
      (Finset.Ico a b).card = (Finset.Icc a b).card - 1 :=
  by sorry

This theorem states that for any given type `α` with a partial order and locally finite order, for any two elements `a` and `b` of that type, the cardinality (or size) of the finset of elements `x` such that `a ≤ x` and `x < b` (denoted as `Finset.Ico a b`) is equal to the cardinality of the finset of elements `x` such that `a ≤ x` and `x ≤ b` (denoted as `Finset.Icc a b`) minus one. Essentially, this theorem is saying that the size of the set of elements within the interval `[a, b)` is one less than the size of the set of elements within the interval `[a, b]`.

For any type `α` with a locally finite partial order, the cardinality of the interval `[a, b)` is one less than the cardinality of the interval `[a, b]`.


theorem MeasureTheory.Ioo_ae_eq_Ioc :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.NoAtoms μ]
      [inst : PartialOrder α] {a b : α}, Set.Ioo a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Ioc a b :=
  by sorry

This theorem states that for any type `α` equipped with a `MeasurableSpace` structure `m0` and a measure `μ` that has no atoms, and a `PartialOrder` structure, the set of all elements `x` between `a` and `b` (exclusive) is equal "almost everywhere" (according to the measure `μ`) to the set of all elements `x` between `a` and `b` where `x` can be equal to `b`. In mathematical terms, this means that the left-open right-open interval $(a, b)$ is almost everywhere equal to the left-open right-closed interval $(a, b]$ with respect to the measure `μ`.

For any measurable space `(α, m0)` with no atomic measure `μ`, the sets $(a, b) \neq (a, b]$ differ in measure `μ` by a set of measure 0.


theorem ProbabilityTheory.condexpKernel_def :
    ∀ {Ω : Type u_3} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω] [inst_1 : Nonempty Ω]
      (μ : MeasureTheory.Measure Ω) [inst_2 : MeasureTheory.IsFiniteMeasure μ] (m : MeasurableSpace Ω),
      ProbabilityTheory.condexpKernel μ m =
        ProbabilityTheory.kernel.comap (ProbabilityTheory.condDistrib id id μ) id ⋯ :=
  by sorry

This theorem defines the conditional expectation kernel in probability theory. For every type `Ω` with `MeasurableSpace` and `StandardBorelSpace`, given a measure `μ` on `Ω` which is a finite measure and a `MeasurableSpace m`, the conditional expectation kernel of `μ` and `m` is equal to the comap of the kernel of conditional distribution with identity function. The theorem is applicable under the assumption that the type `Ω` is nonempty.

For any nonempty `Ω` with `MeasurableSpace` and `StandardBorelSpace`, the conditional expectation kernel of a finite measure `μ` on `Ω` and a `MeasurableSpace` `m` is equal to the composition of the kernel of the conditional distribution of `μ` and the identity function.


theorem dist_smul_pair :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
      [inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : BoundedSMul α β] (x : α) (y₁ y₂ : β),
      dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
  by sorry

This theorem states that for any two values `y1` and `y2` of type `β`, and a value `x` of type `α`, in a context where `α` and `β` are pseudo-metric spaces with zero elements and a bounded scalar multiplication operation, the distance between `x` scaled by `y1` and `x` scaled by `y2` is less than or equal to the product of the distance from `x` to zero and the distance from `y1` to `y2`. In mathematical terms, this can be represented as `dist(x*y1, x*y2) ≤ dist(x, 0) * dist(y1, y2)`.

In a pseudo-metric space with zero elements and bounded scalar multiplication, the distance between `x` scaled by `y1` and `x` scaled by `y2` (for any `x` of type `α` and `y1`, `y2` of type `β`) is less than or equal to the product of the distance from `x` to zero and the distance from `y1` to `y2`. In symbols: `dist(x * y1, x * y2) ≤ dist(x, 0) * dist(y1, y2)`.


theorem Rat.den_pos : ∀ (self : ℚ), 0 < self.den := by sorry

This theorem, `Rat.den_pos`, states that for any rational number, its denominator is always greater than zero. In other words, no matter what rational number you have, its denominator will never be zero or negative.

The denominator of every rational number is positive.


theorem Complex.ofReal_re : ∀ (r : ℝ), (↑r).re = r := by sorry

This theorem states that for any real number `r`, the real part of the complex number obtained by coercing `r` to a complex number is equal to `r` itself. In other words, the real component of a complex number created from a real number is just the original real number. The `.re` function in this context is used to extract the real part of a complex number.

For any real number `r`, the real part of the complex number obtained by coercing `r` is equal to `r` itself. (In Lean: `(real.coerce r).re = r`)


theorem Computation.eq_of_bisim :
    ∀ {α : Type u} (R : Computation α → Computation α → Prop),
      Computation.IsBisimulation R → ∀ {s₁ s₂ : Computation α}, R s₁ s₂ → s₁ = s₂ :=
  by sorry

The theorem `Computation.eq_of_bisim` states that for any type `α` and any relation `R` on computations of type `α`, if `R` is a bisimulation -- meaning it relates two computations if and only if their "next steps" (as given by the `Computation.destruct` function) are also related by `R` -- then any two computations related by `R` are in fact equal. In other words, if two computations behave the same way (as witnessed by the bisimulation `R`), then they are the same computation.

If `R` is a bisimulation relation on computations of type `α`, then for all `c₁` and `c₂` related by `R`, we have `c₁ = c₂`.


theorem Multiset.inter_le_left : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∩ t ≤ s := by sorry

This theorem states that for any type `α` with decidable equality (denoted as `DecidableEq α`), and for any two multisets, `s` and `t`, of this type `α`, the intersection of `s` and `t` (denoted as `s ∩ t`) is always a sub-multiset of `s` (denoted as `s ∩ t ≤ s`). Here, a multiset is a generalization of a set that allows multiple instances of the set's elements. The `≤` operator is used to denote the sub-multiset relation, meaning that all elements of `s ∩ t` are also elements of `s`, potentially with fewer repetitions.

For any type `α` with decidable equality and for any multisets `s` and `t` of type `α`, the intersection of `s` and `t` is a sub-multiset of `s`. (Or more mathematically, `s ∩ t ≤ s`.)


theorem Complex.sin_sq_add_cos_sq : ∀ (x : ℂ), Complex.sin x ^ 2 + Complex.cos x ^ 2 = 1 := by sorry

This theorem states that for any complex number `x`, the square of the complex sine of `x` plus the square of the complex cosine of `x` equals 1. This is a complex analog of the well-known trigonometric identity $\sin^2 \theta + \cos^2 \theta = 1$. Here, `Complex.sin x` and `Complex.cos x` represent the complex sine and complex cosine of `x`, respectively, both of which are defined in terms of the complex exponential function.

For any complex number x, the sum of the squares of its complex sine and complex cosine equals 1: |Complex.sin x|² + |Complex.cos x|² = 1.


theorem Mathlib.Data.Int.Cast.Basic._auxLemma.8 :
    ∀ {R : Type u} [inst : AddGroupWithOne R] (m n : ℤ), ↑m - ↑n = ↑(m - n) := by sorry

This theorem states that for any type `R` that has a structure of an additive group with a multiplicative identity (i.e., `AddGroupWithOne R`), and for any two integers `m` and `n`, the difference of the casted integers `m` and `n` in `R` is equal to the cast of the difference of the integers `m` and `n`. In mathematical terms, this can be represented as $(m - n) = [m] - [n]$, where $[m]$ and $[n]$ represent the casted integers.

For any additive group with a multiplicative identity `R` and integers `m` and `n`, the casted integers `[m]` and `[n]` differ by the group difference `m - n`.


theorem Set.mem_inter_iff : ∀ {α : Type u} (x : α) (a b : Set α), x ∈ a ∩ b ↔ x ∈ a ∧ x ∈ b := by sorry

This theorem, `Set.mem_inter_iff`, states for any type `α`, an element `x` of that type, and any two sets `a` and `b` of that type, `x` belongs to the intersection of sets `a` and `b` if and only if `x` belongs to `a` and `x` belongs to `b`. In other words, membership in the intersection of two sets is equivalent to membership in both of the sets.

For any type `α` and sets `a` and `b` of type `α`, `x ∈ a ∧ x ∈ b` if and only if `x ∈ a ∩ b`.


theorem MeasureTheory.SimpleFunc.coe_restrict :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Zero β] (f : MeasureTheory.SimpleFunc α β)
      {s : Set α}, MeasurableSet s → ↑(MeasureTheory.SimpleFunc.restrict f s) = Set.indicator s ↑f :=
  by sorry

This theorem states that for any measure space 'α' and any type 'β' with a zero element, given a measure theory simple function 'f' from 'α' to 'β' and a set 's' in 'α' that is measurable, the function obtained by restricting 'f' to 's' is identical to the indicator function of 's' applied to the original function 'f'. In other words, each value 'a' in the set 's' maps to 'f a' and values not in 's' map to zero.

For any measurable set $s$ in a measure space $\alpha$ and measurable simple function $f:\alpha\to\beta$ with zero element, the restricted function $f|_s = \chi_s\circ f$, where $\chi_s$ is the indicator function of $s$.


theorem Finset.Icc_self :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a : α), Finset.Icc a a = {a} := by sorry

This theorem states that for any type `α` that has a partial order and a locally finite order, the finite set of elements `x` such that `a ≤ x` and `x ≤ a` (represented by `Finset.Icc a a`) is equal to the set that contains only the element `a` (`{a}`). Essentially, when the lower and upper bounds are the same in an interval, the resulting set only contains that single element.

For any locally finite ordered type `α`, the interval `[a := a]` is a singleton set containing `a`.


/-- Subtracting the result of adding a group element produces the same result
as subtracting the points and subtracting that group element.  -/
theorem vsub_vadd_eq_vsub_sub :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ p₂ : P) (g : G),
      p₁ -ᵥ (g +ᵥ p₂) = p₁ -ᵥ p₂ - g :=
  by sorry

This theorem states that for any group `G` and any torsor `T` over that group, for any two points `p₁` and `p₂` in `T` and any element `g` in `G`, subtracting the result of adding `g` to `p₂` from `p₁` is the same as first subtracting `p₂` from `p₁` and then subtracting `g`. In mathematical terms, it's stating that \( p₁ - (g + p₂) = (p₁ - p₂) - g \) within the structure provided by the group and the torsor.

For any group `G` and torsor `T` over `G`, for all `p₁`, `p₂` in `T` and `g` in `G`, `p₁ - g - p₂ = p₁ - p₂ - g`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.mono :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      {μa μa' : MeasureTheory.Measure α} {μb μb' : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.Measure.AbsolutelyContinuous μa' μa →
        MeasureTheory.Measure.AbsolutelyContinuous μb μb' →
          MeasureTheory.Measure.QuasiMeasurePreserving f μa μb →
            MeasureTheory.Measure.QuasiMeasurePreserving f μa' μb' :=
  by sorry

The theorem states that, for any two types `α` and `β` with associated measurable spaces `m0` and `inst`, and for any two pairs of measures (`μa`, `μa'`) on `α` and (`μb`, `μb'`) on `β`, along with a function `f` from `α` to `β`, if `μa'` is absolutely continuous with respect to `μa` and `μb` is absolutely continuous with respect to `μb'`, and if `f` is a quasi measure preserving function from `μa` to `μb`, then `f` is also a quasi measure preserving function from `μa'` to `μb'`.

In other words, if a function preserves the measure from `μa` to `μb`, and if `μa'` and `μb` are dominated by `μa` and `μb'` respectively (meaning that any set with measure zero under `μa` or `μb` also has measure zero under `μa'` or `μb'`), then the function also preserves the measure from `μa'` to `μb'`.

If measures `μa'` and `μb'` are absolutely continuous with respect to `μa` and `μb` respectively, and `f` is a quasi measure preserving function from `(α, μa)` to `(β, μb)`, then `f` is also a quasi measure preserving function from `(α, μa')` to `(β, μb')`.


MeasureTheory.AEStronglyMeasurable.add

theorem MeasureTheory.AEStronglyMeasurable.add :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f g : α → β} [inst_1 : Add β] [inst_2 : ContinuousAdd β],
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (f + g) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.add` states that for any topological addable space `β`, given two functions `f` and `g` from a measurable space `α` to `β` that are almost everywhere strongly measurable with respect to a measure `μ`, the function obtained by pointwise addition of `f` and `g` is also almost everywhere strongly measurable with respect to the same measure `μ`. This holds provided that the addition operation on `β` is continuous. In other words, if `f` and `g` are almost everywhere equal to the limit of a sequence of simple functions, then so is `(f + g)`.

If `α` is a measurable space, `β` is a topological additive space with a continuous addition operation, and `f` and `g` are almost everywhere strongly measurable functions from `α` to `β`, then `f + g` is almost everywhere strongly measurable.


ManyOneReducible.trans

theorem ManyOneReducible.trans :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}, p ≤₀ q → q ≤₀ r → p ≤₀ r :=
  by sorry

This theorem, `ManyOneReducible.trans`, states that for any three types α, β, and γ, each of which has a `Primcodable` instance, and for any three propositions `p : α → Prop`, `q : β → Prop`, and `r : γ → Prop`, if `p` is many-one reducible to `q` (`p ≤₀ q`), and `q` is many-one reducible to `r` (`q ≤₀ r`), then `p` is many-one reducible to `r` (`p ≤₀ r`). This is the transitivity property for the many-one reducibility relation in the context of computability theory.

If `α`, `β`, and `γ` have `Primcodable` instances, and `p ≤₀ q` and `q ≤₀ r` are many-one reducibilities between propositions, then `p ≤₀ r`.


theorem himp_eq : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], x ⇨ y = y ⊔ xᶜ := by sorry

This theorem, `himp_eq`, states that for all types `α` (where `α` is an instance of a Boolean algebra), and for all elements `x` and `y` of type `α`, the operation of implication (denoted by `x ⇨ y`) is equal to the supremum (or join) of `y` and the complement of `x` (denoted by `xᶜ`). In mathematical terms, `x ⇒ y = y ∪ ¬x` for all elements `x` and `y` in any Boolean algebra.

In any Boolean algebra, the operation of implication (x ⇨ y) is equal to the supremum (y ∪ xᶜ) for all elements x and y.


theorem map_finsupp_sum :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} {P : Type u_11} [inst : Zero M] [inst_1 : AddCommMonoid N]
      [inst_2 : AddCommMonoid P] {H : Type u_16} [inst_3 : FunLike H N P] [inst_4 : AddMonoidHomClass H N P] (h : H)
      (f : α →₀ M) (g : α → M → N), h (Finsupp.sum f g) = Finsupp.sum f fun a b => h (g a b) :=
  by sorry

The theorem `map_finsupp_sum` states that for any types `α`, `M`, `N`, `P`, and `H`, given the conditions that `M` has a zero element, `N` and `P` have a commutative addition operation, `H` is a function-like object from `N` to `P`, and `H` is also a kind of additive monoid homomorphism between `N` and `P`, then for any `h` of type `H`, any function `f` from `α` to `M` with finite support, and any function `g` from `α` and `M` to `N`, applying `h` to the sum of `g a (f a)` over the support of `f` is equal to the sum of `h (g a b)` over the support of `f`. This is essentially a statement about being able to interchange the order of summation and the application of the function `h`.

For any commutative additive monoids (N, +) and (P, +), function-like object H from N to P that is an additive monoid homomorphism, and functions f from α to M with finite support and g from α and M to N, the following equality holds: h (∑i ∈ supp(f) g i (f i)) = ∑i ∈ supp(f) h (g i (f i)).


Localization.ind

theorem Localization.ind :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {p : Localization S → Prop},
      (∀ (y : M × ↥S), p (Localization.mk y.1 y.2)) → ∀ (x : Localization S), p x :=
  by sorry

The `Localization.ind` theorem states that for any commutative monoid `M` and any of its submonoids `S`, given a property `p` that applies to localized elements of `M`, if this property holds for every pair `(y.1, y.2)` where `y.1` is an element of the monoid `M` and `y.2` is an element of the submonoid `S` localized by `Localization.mk`, then this property `p` is valid for all elements `x` in the localization of `S`. In essence, this theorem allows for the induction over the elements of the localization of a commutive monoid at one of its submonoids.

If a property `p` holds for all pairs of elements `(y.1, y.2)` with `y.1` in a commutative monoid `M` and `y.2` in a submonoid `S`, then `p` holds for all elements in the localization of `S` in `M`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.2 : ∀ {a : ENNReal}, (0 ≤ a.toReal) = True := by sorry

This theorem states that for every extended nonnegative real number `a`, the property that `a` converted to a real number is greater than or equal to 0 is always true. In other words, the theorem asserts that any element of the extended nonnegative real numbers, when interpreted as a real number, is always nonnegative. The extended nonnegative real numbers are usually denoted as [0, ∞], and are relevant as the codomain of a measure.

For all extended nonnegative real numbers `a`, `a` as a real number is non-negative.


ENNReal.Tendsto.mul

theorem ENNReal.Tendsto.mul :
    ∀ {α : Type u_1} {f : Filter α} {ma mb : α → ENNReal} {a b : ENNReal},
      Filter.Tendsto ma f (nhds a) →
        a ≠ 0 ∨ b ≠ ⊤ →
          Filter.Tendsto mb f (nhds b) → b ≠ 0 ∨ a ≠ ⊤ → Filter.Tendsto (fun a => ma a * mb a) f (nhds (a * b)) :=
  by sorry

This theorem states that for a certain type `α`, a given filter `f` on `α`, two functions `ma` and `mb` from `α` to the extended nonnegative real numbers (`ENNReal`), and two extended nonnegative real numbers `a` and `b`, if `ma` tends towards `a` with respect to the filter `f` and either `a` is not zero or `b` is not infinity, and if `mb` tends towards `b` with respect to the filter `f` and either `b` is not zero or `a` is not infinity, then the function defined by the product of `ma` and `mb` also tends towards the product of `a` and `b` with respect to the filter `f`. This is a result about the limit behavior of a product of functions in the context of extended nonnegative real numbers and general topological spaces.

If functions `ma : α -> ENNReal` and `mb : α -> ENNReal` tend to `a, b ∈ ENNReal` (not zero if one is infinity) with respect to filter `f` on `α`, then their product `ma * mb` tends to `a * b` with respect to filter `f`.


theorem AddSubgroup.mem_bot : ∀ {G : Type u_1} [inst : AddGroup G] {x : G}, x ∈ ⊥ ↔ x = 0 := by sorry

This theorem states that for any type `G` which has the structure of an additive group, an element `x` of `G` belongs to the trivial subgroup (denoted by `⊥`) if and only if `x` is the zero element of the group. In other words, the trivial subgroup of an additive group consists only of the zero element.

The trivial subgroup of an additive group is equal to the set of its zero elements.


theorem mem_lowerBounds : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, a ∈ lowerBounds s ↔ ∀ x ∈ s, a ≤ x :=
  by sorry

The theorem `mem_lowerBounds` states that for any type `α` with a preorder (i.e., a relation satisfying reflexivity and transitivity) and for any set `s` of type `α` and element `a` of type `α`, `a` is in the lower bounds of `s` if and only if `a` is less than or equal to every element `x` in `s`. In other words, an element is considered a lower bound of a set in a preorder if it is less than or equal to every element of the set.

An element is a lower bound of a set in a preorder if and only if it is less than or equal to every element in the set.


theorem Set.Subsingleton.infsep_zero :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, Set.Subsingleton s → Set.infsep s = 0 := by sorry

This theorem states that for any set `s` of a certain type `α` that has an extended distance (edist) function defined, if `s` is a subsingleton set (meaning it contains at most one element), then the infimum separation of the set `s` is zero. The infimum separation of a set, as per the `Set.infsep` definition, is the real equivalent of the least separation between any two points in the set. Therefore, intuitively, if a set consists of at most one point, there are no two points to calculate the separation between, so the infimum separation is zero.

For any set `s` of type `α` with an extended distance function, if `s` is a subsingleton, then its infimum separation is 0.


em'

theorem em' : ∀ (p : Prop), ¬p ∨ p := by sorry

This theorem, `em'`, is a statement of the law of excluded middle in propositional logic. It asserts that for any proposition `p`, either `p` is true or `p` is not true, represented as `¬p ∨ p` in Lean 4. In other words, it affirms that every proposition is either true or false, with no third option available.

For all propositions p in propositional logic, p or not p holds.


theorem Int.neg_le_neg : ∀ {a b : ℤ}, a ≤ b → -b ≤ -a := by sorry

This theorem states that for all integers `a` and `b`, if `a` is less than or equal to `b`, then `-b` is less than or equal to `-a`. In other words, the negation of a larger integer is less than or equal to the negation of a smaller integer.

For all integers `a` and `b`, if `a ≤ b`, then `-b ≤ -a`.


theorem Cardinal.nat_succ : ∀ (n : ℕ), ↑(Nat.succ n) = Order.succ ↑n := by sorry

The theorem `Cardinal.nat_succ` asserts that for every natural number 'n', the cardinality of the successor of 'n' is equal to the successor of the cardinality of 'n'. In other words, it states that the operation of finding the successor (the next number) in the natural numbers is compatible with the operation of finding the successor in the order structure.

For every natural number n, the cardinality of the set of natural numbers up to n's successor is the successor of the cardinality of the set of natural numbers up to n.


theorem Nat.bit_decomp : ∀ (n : ℕ), Nat.bit (Nat.bodd n) (Nat.div2 n) = n := by sorry

The theorem `Nat.bit_decomp` states that for any natural number `n`, if you take the binary representation of `n`, determine if it's odd or even using the `Nat.bodd` function to get the last digit, divide `n` by 2 using the `Nat.div2` function to get the remaining digits, and then concatenate the last digit and the remaining digits using the `Nat.bit` function, you will get back the original number `n`. In other words, it verifies the correctness of the decomposition of a natural number into its binary representation.

For any natural number `n`, the binary representation of `n` obtained by concatenating the last digit of its binary representation (determined by `Nat.bodd`) with the remaining digits (obtained by dividing `n` by 2 using `Nat.div2`) equals `n`.


theorem MeasureTheory.ae_restrict_eq :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → MeasureTheory.Measure.ae (μ.restrict s) = MeasureTheory.Measure.ae μ ⊓ Filter.principal s :=
  by sorry

The theorem `MeasureTheory.ae_restrict_eq` states that for any type `α`, any measurable space `m0` on `α`, any measure `μ` on `α`, and any set `s` of `α`, if `s` is a measurable set, then the "almost everywhere" filter of the measure restricted to `s` is equal to the intersection of the "almost everywhere" filter of the measure `μ` and the principal filter of `s`. In simpler terms, this theorem tells us about the relationship between the "almost everywhere" concept when applied to a measure restricted to a measurable subset and the original measure.

For any measurable space `(α, ℱ, μ)`, measurable set `s ∈ ℱ`, the almost everywhere filter of `μ` restricted to `s` equals the intersection of the almost everywhere filter of `μ` and the principal filter of `s`.


theorem PrimeSpectrum.basicOpen_eq_zeroLocus_compl :
    ∀ {R : Type u} [inst : CommSemiring R] (r : R), ↑(PrimeSpectrum.basicOpen r) = (PrimeSpectrum.zeroLocus {r})ᶜ := by
  sorry

This theorem states that for any commutative semiring `R` and any element `r` of `R`, the set of all prime ideals that do not contain `r` (denoted as `PrimeSpectrum.basicOpen r`) is equal to the complement of the set of all prime ideals that annihilate `r` (denoted as `PrimeSpectrum.zeroLocus {r}`). In mathematical terms, the open subset of the prime spectrum consisting of ideals excluding `r` is the same as the set of ideals that do not annihilate `r`.

The set of prime ideals not containing an element `r` in a commutative semiring `R` equals the complement of the set of prime ideals annihilating `r`.


theorem Int.log_of_right_le_one :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) {r : R},
      r ≤ 1 → Int.log b r = -↑(Nat.clog b ⌈r⁻¹⌉₊) :=
  by sorry

The theorem `Int.log_of_right_le_one` states that for any type `R` that is a linearly ordered semiring and a floor semiring, and for any natural number `b` and value `r` of type `R`, if `r` is less than or equal to `1`, then the integer logarithm of `r` with base `b` (i.e., the greatest power of `b` such that `b` to the power of this logarithm is less than or equal to `r`) is equal to the negative of the ceiling of the reciprocal of `r`, taken to the upper logarithm in base `b` (i.e., the smallest `k` such that `r` inverse is less than or equal to `b` to the power of `k`).

For any linearly ordered semiring and floor semiring type R, natural number b, and value r of type R, if 0 ≤ r in R, then log\_b (r) = -ceiling(1 / r)^(log\_b^(up) (1 / r)) where log\_b and ceiling are the integer logarithm and ceiling functions, respectively, with base b.


theorem Nat.dvd_of_mem_factors : ∀ {n p : ℕ}, p ∈ Nat.factors n → p ∣ n := by sorry

The theorem `Nat.dvd_of_mem_factors` states that for any two natural numbers `n` and `p`, if `p` is an element in the prime factorization of `n` (as defined by `Nat.factors n`), then `p` divides `n`. In more mathematical terms, if $p$ is a prime factor of $n$, then $n$ is divisible by $p$. This is a key property of prime factorization, asserting that all the factors listed indeed divide the original number.

If a prime number `p` is in the factorization of a natural number `n` (as defined by `Nat.factors n`), then `n` is divisible by `p`.


theorem Real.Angle.toReal_coe_eq_self_iff : ∀ {θ : ℝ}, Real.Angle.toReal ↑θ = θ ↔ -Real.pi < θ ∧ θ ≤ Real.pi := by sorry

This theorem states that for any real number `θ`, the function `Real.Angle.toReal` applied to the coersion of `θ` to a `Real.Angle` returns `θ` if and only if `θ` is strictly greater than negative pi (`-π`) and less than or equal to pi (`π`). In other words, converting a real number to a Real.Angle and then back to a real number yields the original number only if the original number lies within the interval `(-π, π]`.

The theorem asserts that for any real number `θ`, `Real.Angle.toReal (toReal θ) = θ` if and only if `θ` is in the interval `(-π, π]`.


theorem NNReal.zero_rpow : ∀ {x : ℝ}, x ≠ 0 → 0 ^ x = 0 := by sorry

This theorem states that for any real number `x` that is not equal to zero, raising zero to the power of `x` always gives zero. In mathematical terms, for all `x ∈ ℝ` where `x ≠ 0`, `0^x = 0`.

For all non-zero real numbers `x`, `0^x = 0`.


theorem OrderHom.lfp_le :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, f a ≤ a → OrderHom.lfp f ≤ a := by sorry

This theorem states that for any type `α` that forms a complete lattice, and for any order-preserving function `f` from `α` to `α`, if `f a` is less than or equal to `a` for some `a` in `α`, then the least fixed point of `f` is less than or equal to `a`. In other words, `a` is an upper bound of the least fixed point of the monotone function `f`.

If `f` is an order-preserving function on a complete lattice `α` with `a` in `α` such that `f(a) ≤ a`, then the least fixed point of `f` is less than or equal to `a`.