theorem Mathlib.Combinatorics.SetFamily.Shadow._auxLemma.3 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α},
      (t ∈ Finset.shadow 𝒜) = ∃ s ∈ 𝒜, ∃ a ∈ s, Finset.erase s a = t :=
  by sorry

This theorem states that for any type `α` with decidable equality, any family of finite sets `𝒜`, and any set `t` of type `α`, `t` is in the shadow of `𝒜` if and only if there exists a set `s` in `𝒜` and an element `a` in `s` such that `t` is the set `s` with the element `a` removed. In other words, the shadow of a set family `𝒜` can be characterized as all sets that can be obtained by removing one element from a set in `𝒜`.

For any decidably equal type `α` and family `𝒜` of finite sets, a set `t` is in the shadow of `𝒜` if and only if there exists `s ∈ 𝒜` and `a ∈ s` such that `t = s \ {a}`.


theorem SpectrumRestricts.algebraMap_image :
    ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Ring A]
      [inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {a : A}
      {f : S → R}, SpectrumRestricts a f → ⇑(algebraMap R S) '' spectrum R a = spectrum S a :=
  by sorry

The theorem `SpectrumRestricts.algebraMap_image` asserts that for any commutative semirings `R` and `S`, a ring `A`, algebra structures from `R` to `S`, `R` to `A`, and `S` to `A`, a scalar tower structure for `R`, `S`, and `A`, a given element `a` of `A`, and a function from `S` to `R` that restricts the spectrum of `a`, the image of the spectrum of `a` (from the algebra of `R` to `A`) under the algebra mapping from `R` to `S` is equal to the spectrum of `a` in the algebra of `S` to `A`. In mathematical terms, if `f` restricts the spectrum of `a`, then the image of the spectrum of `a` under the algebra map `R → S` is exactly the spectrum of `a` with respect to `S`.

For any commutative semirings R, S, a ring A, algebra structures and scalar towers, if an element a of A has spectrum s in the algebra of R to A, and the function restricting the spectrum of a to S is f, then the image of s under the algebra map R → S equals the spectrum of a in the algebra of S to A.


theorem CategoryTheory.Limits.kernelComparison_comp_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D]
      [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (G : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms G] [inst_5 : CategoryTheory.Limits.HasKernel f]
      [inst_6 : CategoryTheory.Limits.HasKernel (G.map f)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelComparison f G)
          (CategoryTheory.Limits.kernel.ι (G.map f)) =
        G.map (CategoryTheory.Limits.kernel.ι f) :=
  by sorry

The theorem `CategoryTheory.Limits.kernelComparison_comp_ι` states that for any categories `C` and `D` with zero morphisms, a morphism `f : X ⟶ Y` in `C`, and a functor `G : C → D` that preserves zero morphisms, if `f` and `G.map f` both have kernels, then the composition of the kernel comparison of `f` under `G` with the kernel injection of `G.map f` is equal to the image under `G` of the kernel injection of `f`. In simpler terms, this theorem describes a certain commutativity condition involving kernels and a functor between categories.

For functors preserving zero morphisms between categories with zero morphisms, if a morphism in the source category has a kernel and its image under the functor also has a kernel, then the comparison morphism between their kernel injections is equal to the image under the functor of the kernel injection of the original morphism.


theorem FractionalIdeal.coeIdeal_le_one :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {I : Ideal R}, ↑I ≤ 1 :=
  by sorry

This theorem states that for any commutative ring `R`, any submonoid `S` of `R`, any commutative ring `P`, any algebra `R P`, and any ideal `I` of `R`, the fractional ideal generated by `I` in the ring of fractions `P` is less than or equal to one. This essentially means that any element of `I` when seen as a fraction in `P` always has a value that's less than or equal to one.

For any commutative ring `R`, submonoid `S` of `R`, commutative ring `P`, algebra `RP`, and ideal `I` of `R`, the fractional ideal of `I` in `RP` is contained in the multiplicative monoid of `RP` consisting of elements less than or equal to one.


theorem Inducing.map_nhds_eq :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Inducing f → ∀ (x : X), Filter.map f (nhds x) = nhdsWithin (f x) (Set.range f) :=
  by sorry

The theorem `Inducing.map_nhds_eq` states that for any types `X` and `Y`, a function `f: X → Y`, and any point `x` in `X`, under the conditions that `f` induces the topological structure on `Y` from `X`, the forward map of the neighborhood filter at `x` under `f` is equal to the neighborhood within filter at `f(x)` in the range of `f`. Essentially, it confirms that the induced topology correctly transforms local properties of `X` under `f` to `Y`.

For any functions `f: X -> Y` inducing the topology on `Y` from `X`, the neighborhood filter at `x` in `X` is equal to the neighborhood filter at `f(x)` in `Y`.


theorem IsAddUnit.add_right_inj :
    ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit a → (a + b = a + c ↔ b = c) := by sorry

The theorem `IsAddUnit.add_right_inj` states that for any type `M` that is an additive monoid (`AddMonoid M`), and for any elements `a`, `b`, and `c` in `M`, if `a` is an additive unit (i.e., it has a two-sided additive inverse), then the equality of `a + b` and `a + c` implies the equality of `b` and `c`. In essence, this theorem guarantees the cancelability of the additive unit from the left side of an equation in an additive monoid.

If `a` is an additive unit in an additive monoid `M`, then `a + b = a + c` implies `b = c`.


theorem Real.sin_sq : ∀ (x : ℝ), Real.sin x ^ 2 = 1 - Real.cos x ^ 2 := by sorry

This theorem states that for all real numbers `x`, the square of the sine of `x` is equal to 1 subtracted by the square of the cosine of `x`. In mathematical terms, it's expressing the well-known trigonometric identity $\sin^2(x) = 1 - \cos^2(x)$ for all real `x`. This identity is a consequence of the Pythagorean identity in trigonometry.

For all real numbers x, the square of sine(x) equals one minus the square of cosine(x). In mathematical notation: ∀x:ℝ, sin²(x) = 1 - cos²(x).


theorem Nat.Primrec'.to_prim : ∀ {n : ℕ} {f : Vector ℕ n → ℕ}, Nat.Primrec' f → Primrec f := by sorry

This theorem is stating that for all natural numbers `n` and for all functions `f` from `Vector ℕ n` to `ℕ` (i.e., functions taking a vector of `n` natural numbers and returning a natural number), if `f` is primitive recursive according to `Nat.Primrec'` definition, then `f` is also primitive recursive according to the `Primrec` definition. In other words, it is saying that the `Nat.Primrec'` primitive recursion concept implies the `Primrec` concept for functions from vectors of natural numbers to natural numbers.

If `f` is a primitive recursive function from `Vector ℕ n` to `ℕ` according to the `Nat.Primrec'` definition, then `f` is also primitive recursive according to the `Primrec` definition.


theorem Quiver.Path.comp_assoc :
    ∀ {V : Type u} [inst : Quiver V] {a b c d : V} (p : Quiver.Path a b) (q : Quiver.Path b c) (r : Quiver.Path c d),
      Quiver.Path.comp (Quiver.Path.comp p q) r = Quiver.Path.comp p (Quiver.Path.comp q r) :=
  by sorry

This theorem asserts the associativity of path composition in a quiver. Specifically, for any quiver labeled by a type `V`, and any vertices `a`, `b`, `c`, and `d` in this quiver, if there are paths `p` from `a` to `b`, `q` from `b` to `c`, and `r` from `c` to `d`, then composing `p` and `q` and then `r` is the same as composing `p` with the composition of `q` and `r`. In other words, `(p∘q)∘r = p∘(q∘r)`, where `∘` denotes the path composition operation.

For any quiver with vertex labels, and paths `p` from `a` to `b`, `q` from `b` to `c`, and `r` from `c` to `d`, the composition of `p` and `q` followed by `r` equals the composition of `p` with the composition of `q` and `r`. In other words, `(p∘q)∘r = p∘(q∘r)`.


theorem Multiset.normalize_gcd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (s : Multiset α),
      normalize (Multiset.gcd s) = Multiset.gcd s :=
  by sorry

This theorem states that for any type `α` that forms a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, and for any multiset `s` of this type, the normalization of the greatest common divisor (GCD) of the multiset is equal to the GCD of the multiset itself. In other words, if we take a multiset, compute its GCD, and then normalize this number, we obtain the same result as if we just computed the GCD. This is essentially saying that the GCD of a multiset is already in a normalized form.

For any multiset of types `α` that form a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, the normalization of the greatest common divisor of the multiset equals the greatest common divisor itself.


theorem bddAbove_range_prod :
    ∀ {ι : Sort x} {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {F : ι → α × β},
      BddAbove (Set.range F) ↔ BddAbove (Set.range (Prod.fst ∘ F)) ∧ BddAbove (Set.range (Prod.snd ∘ F)) :=
  by sorry

This theorem states that for any function `F` from a type `ι` to a product of types `α` and `β` (where `α` and `β` have pre-order relations), the range of `F` is bounded above if and only if both the range of the first projection of `F` and the range of the second projection of `F` are bounded above. In other words, a set of ordered pairs is bounded above if and only if the set of all first components of the pairs and the set of all second components of the pairs are both bounded above.

The range of a function from a type to a product of types, each with a preorder relation, is bounded above if and only if the ranges of both projections are bounded above.


theorem CategoryTheory.effectiveEpiFamilyStructCompIso_aux :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {B B' : C} {α : Type u_2} (X : α → C)
      (π : (a : α) → X a ⟶ B) (i : B ⟶ B') {W : C} (e : (a : α) → X a ⟶ W),
      (∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
          CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (π a₁) i) =
              CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.CategoryStruct.comp (π a₂) i) →
            CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) →
        ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
          CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
            CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂) :=
  by sorry

This theorem, `CategoryTheory.effectiveEpiFamilyStructCompIso_aux`, is a statement about morphism composition in a category theory context. Specifically, it states that for any category `C` with objects `B`, `B'`, `W`, and `X(a)` (for any `a` in type `α`), given morphisms `π(a): X(a) ⟶ B`, `i: B ⟶ B'`, and `e(a): X(a) ⟶ W`, if for all other objects `Z` and any two elements `a₁`, `a₂` in type `α` and morphisms `g₁: Z ⟶ X(a₁)`, `g₂: Z ⟶ X(a₂)`, the composition `g₁ ≫ (π(a₁) ≫ i)` is equal to the composition `g₂ ≫ (π(a₂) ≫ i)` implies that the composition `g₁ ≫ e(a₁)` is equal to the composition `g₂ ≫ e(a₂)`, then it follows that if `g₁ ≫ π(a₁)` is equal to `g₂ ≫ π(a₂)`, then `g₁ ≫ e(a₁)` is also equal to `g₂ ≫ e(a₂)`. In short, it's a statement about the preservation of equality between certain compositions of morphisms.

If for all objects `Z` and morphisms `g₁, g₂: Z ⟶ X(a)` in a category `C` with objects `B`, `B'`, `W`, and `X(a)`, the equalities `g₁ ≫ π(a₁) = g₂ ≫ π(a₂)` and `g₁ ≫ (π(a₁) ≫ i) = g₂ ≫ (π(a₂) ≫ i)` imply `g₁ ≫ e(a₁) = g₂ ≫ e(a₂)`, then `π` preserves equalities between morphisms `e(a)`.


theorem Subgroup.map_id : ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G), Subgroup.map (MonoidHom.id G) K = K := by
  sorry

The theorem `Subgroup.map_id` states that for any given group `G` and any subgroup `K` of `G`, if we apply the identity map of the monoid `G` to `K` using the function `Subgroup.map`, the result is `K` itself. In simple terms, the image of a subgroup under the identity map is the subgroup itself.

For any group (G, *) and subgroup K of G, Subgroup.map G id K = K.


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

This theorem states that for any semilattice of infimum type `α` and for any two elements `a` and `b` of this type, the infimum of `a` and the infimum of `a` and `b` is equal to the infimum of `a` and `b`. In other words, it shows the idempotency of the infimum operation in the context of a semilattice, where infimum of `a` with itself and another element `b` doesn't change the result as compared to the infimum of `a` and `b`.

In a semilattice, the infimum of an element with itself is equal to the infimum of that element with any other element.


theorem Multiset.cons_zero : ∀ {α : Type u_1} (a : α), a ::ₘ 0 = {a} := by sorry

This theorem states that for any type `α` and an instance `a` of that type, when `a` is prepended to an empty multiset (`0`), the resulting multiset is a singleton multiset containing only `a`. In other words, `a ::ₘ 0` is equivalent to `{a}`. Here, `::ₘ` represents the operation of adding an element to a multiset in the Lean 4 theorem prover.

For any type `α` and element `a` of type `α`, appending `a` to the empty multiset is equivalent to creating a singleton multiset containing `a`. In Lean 4 notation, `a ::ₘ 0` is equivalent to `{a}`.


Set.MapsTo.iterate

theorem Set.MapsTo.iterate :
    ∀ {α : Type u_1} {f : α → α} {s : Set α}, Set.MapsTo f s s → ∀ (n : ℕ), Set.MapsTo f^[n] s s := by sorry

The theorem `Set.MapsTo.iterate` states that for any type `α`, a function `f` from `α` to `α`, and a set `s` of type `α`, if `f` maps `s` to itself (`Set.MapsTo f s s`), then for any natural number `n`, the `n`-times iterated function `f^[n]` also maps `s` to itself. In other words, applying `f` repeatedly `n` times to any element in `s` will result in an element that also belongs to `s`.

If a function maps a set to itself, then the `n`-th power of the function also maps the set to itself for any natural number `n`.


/-- The `p`-adic norm of an integer `m` is one iff `p` doesn't divide `m`.  -/
theorem padicNorm.int_eq_one_iff : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (m : ℤ), padicNorm p ↑m = 1 ↔ ¬↑p ∣ m := by sorry

The theorem `padicNorm.int_eq_one_iff` states that for every prime number `p` and every integer `m`, the `p`-adic norm of `m` is equal to one if and only if `p` does not divide `m`. In other words, when we convert the integer `m` into a rational number and compute its `p`-adic norm, we get one if and only if the prime number `p` is not a divisor of `m`.

For every prime number p and integer m, the p-adic norm of m equals 1 if and only if p does not divide m.


theorem Set.SurjOn.rightInvOn_invFunOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} [inst : Nonempty α],
      Set.SurjOn f s t → Set.RightInvOn (Function.invFunOn f s) f t :=
  by sorry

The theorem `Set.SurjOn.rightInvOn_invFunOn` asserts that for any sets `s` of type `α` and `t` of type `β`, and any function `f` from `α` to `β`, if `α` is nonempty and `f` is surjective from `s` to `t` (that is, `t` is contained within the image of `s` under `f`), then the function `Function.invFunOn f s`, which constructs the inverse for `f` on the domain `s`, is a right inverse to `f` on `t` (meaning that `f (Function.invFunOn f s x) = x` for all `x` in `t`). In other words, this theorem is a formalization of the mathematical concept that a surjective function has a right inverse.

If `f` is a surjective function from a nonempty set `s` to `t`, then there exists a function `g` such that `f(g(x)) = x` for all `x` in `t`.


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

This theorem, `Mathlib.Order.WithBot._auxLemma.24`, states that for any type `α` and any two elements `a` and `b` of that type, the equality of the 'lifted' versions of `a` and `b` (denoted as `↑a` and `↑b`) is equivalent to the equality of `a` and `b` themselves. In the context of order theory, 'lifting' often means embedding a set into a larger set where the original set elements maintain their order relation. Here, it implies that the equality of elements holds true even after they have been 'lifted' (or embedded) into some larger structure, such as a set with added bottom element (which is what `WithBot` refers to).

For any type `α` and its elements `a` and `b`, `↑a = ↑b` if and only if `a = b`.


theorem Mathlib.Order.WithBot._auxLemma.33 : ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑a ≤ ↑b) = (a ≤ b) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of this type, provided that `α` has a less-than-or-equal-to (`≤`) operation, the statement that `a` is less than or equal to `b` when both are lifted to the type WithBot α (represented as `↑a ≤ ↑b`), is equivalent to the statement that `a` is less than or equal to `b` in the original type `α`. In other words, the less-than-or-equal-to relation is preserved when elements are lifted to the WithBot type.

For any type `α` equipped with a `≤` relation and any `a, b ∈ α`, `a ≤ b` is equivalent to `↑a ≤ ↑b` in the type `WithBot α`, where `↑` denotes the lifting function.


theorem PartialHomeomorph.map_extend_nhdsWithin_eq_image :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H) {s : Set M} {y : M},
      y ∈ f.source →
        Filter.map (↑(PartialHomeomorph.extend f I)) (nhdsWithin y s) =
          nhdsWithin (↑(PartialHomeomorph.extend f I) y)
            (↑(PartialHomeomorph.extend f I) '' ((PartialHomeomorph.extend f I).source ∩ s)) :=
  by sorry

The theorem `PartialHomeomorph.map_extend_nhdsWithin_eq_image` states that for any non-trivially normed field `𝕜`, a normed add commutative group `E`, a normed space `𝕜 E`, and topological spaces `M` and `H`, given a partial homeomorphism `f` from `M` to `H`, a Model with Corners `I` from `𝕜` to `E` and `H`, a set `s` of `M`, and an element `y` of `M` that belongs to the source of `f`, the forward map of the "neighborhood within" filter of `y` and `s` using the extension of the partial homeomorphism equals the "neighborhood within" filter of the image of `y` under the extension of the partial homeomorphism, and the image of the intersection of the source of the extension of the partial homeomorphism and `s`.

For a non-trivially normed field `𝕜`, a normed add commutative group `E`, a normed space `𝕜 E`, topological spaces `M` and `H`, a partial homeomorphism `f` from `M` to `H`, a Model with Corners `I` from `𝕜` to `E` and `H`, and a set `s` of `M` and an element `y` of `M` in the domain of `f`, the neighborhood filters of `y` and the image of `y` under the extension of `f`, with respect to the neighborhood within relation, are equal.


theorem Mathlib.Order.WithBot._auxLemma.46 : ∀ {α : Type u_1} [inst : LT α] {a b : α}, (↑a < ↑b) = (a < b) := by sorry

This theorem states that for any type `α` with a less than (`<`) operation, and any two elements `a` and `b` of this type, the inequality `↑a < ↑b` is equivalent to `a < b`. Here, `↑a` and `↑b` denote the lift of `a` and `b` to an extended type that includes a "bottom" element (represented as `WithBot α`). Essentially, this theorem ensures that the inequality relationship between `a` and `b` is preserved when they are lifted to the `WithBot α` type.

For any type `α` with a total order and any elements `a` and `b` of `α`, `a < b` is equivalent to `↑a < ↑b` in the type `WithBot α`, where `↑` denotes lifting to `WithBot α`.


theorem Mathlib.Order.WithBot._auxLemma.47 : ∀ {α : Type u_1} [inst : LT α] {a b : α}, (some a < some b) = (a < b) := by
  sorry

This theorem states that for any type `α` with a less-than `<` relation, and for any two elements `a` and `b` of type `α`, the inequality `some a < some b` is equivalent to `a < b`. Here, `some` denotes the 'option' type constructor, i.e., `some a` is the option type that contains the value `a`. Essentially, this theorem confirms that option types preserve the order of the underlying type.

For any type `α` with a total order `<`, and for all `a` and `b` in `α`, `some a < some b` if and only if `a < b`.


theorem Mathlib.Order.WithBot._auxLemma.48 : ∀ {α : Type u_1} [inst : LT α] (a : α), (↑a < ⊤) = True := by sorry

This theorem states that for any type `α` that has a less-than (`<`) relation, and for any element `a` of this type `α`, the statement that `a` is less than infinity (`⊤`) is always true. Put simply, for any given type with an order, every element of that type is less than infinity.

For any type `α` with a total order and any `a` in `α`, `a` < ⊤ (where ⊤ is the greatest element in `α` representing infinity).


theorem Polynomial.coeff_X_add_one_pow :
    ∀ (R : Type u_1) [inst : Semiring R] (n k : ℕ), Polynomial.coeff ((Polynomial.X + 1) ^ n) k = ↑(Nat.choose n k) :=
  by sorry

The theorem `Polynomial.coeff_X_add_one_pow` states that for any semiring `R` and for any natural numbers `n` and `k`, the coefficient of the `k`th term in the polynomial `(X + 1)^n` is equal to the binomial coefficient "n choose k". In other words, when you expand a binomial expression `(X + 1)^n`, the coefficient of the term `X^k` is the number of ways to choose `k` items from `n` items.

For any semiring R and natural numbers n and k, the coefficient of X^k in (X + 1)^n is equal to the binomial coefficient n choose k.


theorem Fintype.card_unit : Fintype.card Unit = 1 := by sorry

The theorem `Fintype.card_unit` states that the cardinality (or the number of elements) of the `Unit` type is 1. Here, `Fintype.card Unit` refers to the size of the `Unit` type, which is a finite type (`Fintype`). The `Unit` type is a type with exactly one value in Lean 4, similar to the `void` type in some other programming languages. Therefore, this theorem is essentially saying that there is exactly one value in the `Unit` type.

The theorem `Fintype.card_unit` asserts that the cardinality of the Unit type in Lean 4 is equal to 1.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.3 :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : α}, (1 ≤ a⁻¹) = (a ≤ 1) :=
  by sorry

This theorem states that for any type `α` that is a group and has an order defined on it, and that this order is covariant with the group operation, for any element `a` of this type, the condition that `1` is less than or equal to the inverse of `a` holds if and only if `a` is less than or equal to `1`. In this context, 'covariant' means that if `x ≤ y` then `z * x ≤ z * y` for all `z`.

For any group `α` with a covariant order `≤` on it, an element `a` has `1 ≤ a⁻¹` if and only if `a ≤ 1`.


/-- This property is sometimes referred to as `α` being upper continuous.  -/
theorem DirectedOn.inf_sSup_eq :
    ∀ {α : Type u_2} [inst : CompleteLattice α] [inst_1 : IsCompactlyGenerated α] {a : α} {s : Set α},
      DirectedOn (fun x x_1 => x ≤ x_1) s → a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b :=
  by sorry

This theorem, referred to as `α` being upper continuous, states that for any type `α` that forms a Complete Lattice and is Compactly Generated, and for any element `a` of `α` and set `s` of `α`, if the set `s` is directed in the sense that for every pair of elements from `s`, there exists another element in `s` that is greater than or equal to both, then the infimum (greatest lower bound) of `a` and the supremum (least upper bound) of `s` is equal to the supremum of the set of all infimums of `a` and each element `b` in `s`. In LaTeX terms, if `s` is directed with respect to `≤`, then `a ∧ sup s = sup {a ∧ b | b ∈ s}`.

For any complete lattice `α` that is compactly generated, if `s` is a directed set in `α` with respect to `≤`, then the infimum of any element `a` in `α` and the supremum of `s` are equal to the supremum of the set of all infimums of `a` and each element in `s`.


/-- Any element semiconjugates `0` to `0`. -/
theorem AddSemiconjBy.zero_right : ∀ {M : Type u_2} [inst : AddZeroClass M] (a : M), AddSemiconjBy a 0 0 := by sorry

The theorem `AddSemiconjBy.zero_right` states that for any type `M` that has an addition operation and a zero element, any element `a` of type `M` semiconjugates `0` to `0`. In other words, for any element `a` in `M`, the equation `a + 0 = 0 + a` always holds true. This captures the property that adding zero to any element in an additive structure does not change its value.

For any additive type `M` and any element `a` in `M`, `a + 0 = 0 + a`.


/-- The **Heine–Borel theorem**: In a proper space, the closure of a bounded set is compact.  -/
theorem Bornology.IsBounded.isCompact_closure :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} [inst_1 : ProperSpace α],
      Bornology.IsBounded s → IsCompact (closure s) :=
  by sorry

The Heine-Borel theorem states that in a proper space (a space in which every bounded subset is totally bounded), the closure of a bounded set is compact. Here, a set is said to be bounded if it is bounded relative to the ambient bornology on the space, and a set is compact if for every nontrivial filter that contains the set, there exists an element in the set such that every set of the filter meets every neighborhood of this element. The closure of a set is defined as the smallest closed set containing the set. In other words, in a space where boundedness is equivalent to total boundedness, making a bounded set closed (by taking its closure) makes it compact.


theorem RatFunc.num_X : ∀ {K : Type u} [inst : Field K], RatFunc.num RatFunc.X = Polynomial.X := by sorry

This theorem states that for any type `K` that forms a field, the numerator of the rational function that corresponds to the polynomial variable (or indeterminate) in the rational functions over `K` is equal to the polynomial variable in the polynomials over `K`. In mathematical terms, if we consider `RatFunc.X` as a rational function which is simply the polynomial variable considered as a rational function, then its numerator, when the denominator is normalized to be monic, is just the polynomial variable itself.

For any field `K`, the numerator of the rational function `RatFunc.X` over `K` is equal to the polynomial variable `X` in the polynomials over `K`.


theorem Real.sin_arcsin' : ∀ {x : ℝ}, x ∈ Set.Icc (-1) 1 → Real.sin (Real.arcsin x) = x := by sorry

This theorem states that for all real numbers `x` within the interval from -1 to 1, inclusive, the sine of the arcsine of `x` equals `x`. In other words, when `x` is in the interval [-1, 1], the `sin` and `arcsin` functions are inverses of each other. This theorem is essentially capturing the mathematical concept that $sin(arcsin(x)) = x$ for $x$ in the range $[-1, 1]$.

For all real numbers `x` in the interval [-1, 1], sin(arcsin(x)) = x holds.


theorem RatFunc.num_C : ∀ {K : Type u} [inst : Field K] (c : K), RatFunc.num (RatFunc.C c) = Polynomial.C c := by sorry

The theorem `RatFunc.num_C` states that for any type `K` that forms a field, and for any element `c` of `K`, the numerator of the constant rational function `c` (denoted as `RatFunc.C c`) is equal to the constant polynomial `c` (denoted as `Polynomial.C c`). In other words, when we consider a constant as a rational function, its numerator is just the same constant considered as a polynomial.

For any field `K` and constant `c` in `K`, `RatFunc.C c` equals `Polynomial.C c`.


/-- If `n` is non-zero, converting the value of a `Fin n` to `Fin n` results
in the same value.   -/
theorem Fin.cast_val_eq_self : ∀ {n : ℕ} [inst : NeZero n] (a : Fin n), ↑↑a = a := by sorry

This theorem states that for any non-zero natural number `n`, if you have a value `a` that is of type `Fin n` (which represents a finite set of `n` distinct elements), then converting `a` twice into `Fin n` type will result in the original value `a`. Essentially, it asserts that double conversion of a `Fin n` value to `Fin n` doesn't change the value.

For any non-zero natural number `n` and any `a` of type `Fin n`, converting `a` to `Fin n` twice equals `a`. In Lean syntax, `(Fin.coe : Fin n → nat) (Fin.coe a) = a`.


theorem MeasureTheory.AEFinStronglyMeasurable.exists_set_sigmaFinite :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : Zero β] [inst_2 : T2Space β],
      MeasureTheory.AEFinStronglyMeasurable f μ →
        ∃ t,
          MeasurableSet t ∧
            f =ᶠ[MeasureTheory.Measure.ae (μ.restrict tᶜ)] 0 ∧ MeasureTheory.SigmaFinite (μ.restrict t) :=
  by sorry

The theorem `MeasureTheory.AEFinStronglyMeasurable.exists_set_sigmaFinite` states that for any measurable space `α`, measure `μ` on `α`, topological space `β`, and a function `f` from `α` to `β`, if `f` is almost everywhere finitely strongly measurable with respect to `μ`, then there exists a measurable set `t` such that `f` is almost everywhere equal to zero with respect to the measure restricted to the complement of `t` and the measure restricted to `t` is sigma-finite. Here, a function is said to be almost everywhere finitely strongly measurable if it is almost everywhere equal to the limit of a sequence of simple functions with support of finite measure. Sigma-finite means that the set can be partitioned into a countable collection of measurable sets with finite measure.

Given a measurable space `(α, Σ, μ)`, topological space `(β, τ)`, and a function `f : α → β` almost everywhere finitely strongly measurable with respect to `μ`, there exists a measurable set `t ∈ Σ` such that the restriction of `μ` to `t` is sigma-finite and `f` is almost everywhere equal to zero on the complement of `t`.


theorem CategoryTheory.Presieve.IsSheaf.isSheafFor :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (J : CategoryTheory.GrothendieckTopology C)
      {P : CategoryTheory.Functor Cᵒᵖ (Type w)},
      CategoryTheory.Presieve.IsSheaf J P →
        ∀ (R : CategoryTheory.Presieve X),
          CategoryTheory.Sieve.generate R ∈ J.sieves X → CategoryTheory.Presieve.IsSheafFor P R :=
  by sorry

This theorem asserts that for any category `C`, Grothendieck topology `J` on `C`, object `X` in `C`, and presheaf `P` (which is a functor from the opposite category of `C` to the category of types), if `P` is a sheaf for the topology `J`, then for any presieve `R` on `X`, if the sieve generated by `R` belongs to the sieves of `X` in `J`, then `P` is a sheaf for `R`.

In other words, if a presheaf satisfies the sheaf condition for every sieve in a topology, it will also satisfy the sheaf condition for any presieve that generates a sieve in that topology.

If a presheaf is a sheaf for a Grothendieck topology, then it is a sheaf for any presieve generating a sieve in that topology.


theorem Finset.sum_sigma' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {σ : α → Type u_6} (s : Finset α)
      (t : (a : α) → Finset (σ a)) (f : (a : α) → σ a → β),
      (Finset.sum s fun a => Finset.sum (t a) fun s => f a s) = Finset.sum (Finset.sigma s t) fun x => f x.fst x.snd :=
  by sorry

The theorem `Finset.sum_sigma'` states that for any types `α` and `β`, given an additive commutative monoid structure on `β`, a function `σ` from `α` to another type, a finite set `s` of elements of type `α`, a function `t` that assigns to each element of `α` a finite set of elements of type `σ a`, and a function `f` that takes an element of `α` and an element of `σ a` and returns an element of `β`, the sum over `s` of the sum over `t a` of `f(a, s)` is equal to the sum over the finite set of dependent pairs `(i, a)` such that `i` is in `s` and `a` is in `t i` of `f(i, a)`.
In other words, it proves that the sum of sums of a function over sets defined by a function over a set is equal to the sum of that function over the set of all pairs defined by the original set and function.

For any additive commutative monoid β, given a function σ : α → *, a finite set s ⊆ α, a function t : α → Finset β, and a function f : α × σ(α) → β, the sum ∑i ∈ s ∑j ∈ t(i) f(i, j) equals the sum ∑(i, j) ∈ Finset.product s (λi => t i) f.


theorem IsLocalization.ringEquivOfRingEquiv.proof_5 :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {P : Type u_2} [inst_1 : CommSemiring P]
      {T : Submonoid P} (h : R ≃+* P), Submonoid.map (RingEquiv.toMonoidHom h) M = T → M ≤ Submonoid.comap (↑h) T :=
  by sorry

This theorem states that for any commutative semirings `R` and `P` with submonoids `M` and `T` respectively, and a given ring equivalence `h` from `R` to `P`, if the image of submonoid `M` under the monoid homomorphism induced by `h` is equal to `T`, then `M` is a subset of the preimage of `T` under the inverse of the monoid homomorphism induced by `h`. This is essentially saying that the preimage of `T` contains `M` when `M` is mapped to `T` by the ring equivalence `h`.

If `h` is a ring equivalence from commutative semirings `R` to `P` with submonoids `M` in `R` and `T` in `P`, such that the image of `M` under the monoid homomorphism induced by `h` equals `T`, then `M` is a subset of the preimage of `T` under the inverse monoid homomorphism of `h`.


theorem Profinite.NobelingProof.continuous_projRestricts :
    ∀ {I : Type u} (C : Set (I → Bool)) {J K : I → Prop} [inst : (i : I) → Decidable (J i)]
      [inst_1 : (i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i),
      Continuous (Profinite.NobelingProof.ProjRestricts C h) :=
  by sorry

This theorem is a part of the Profinite space proof in Nobeling's theorem. It states that for any type `I`, any set `C` of boolean valued functions on `I`, and any two properties `J` and `K` of elements of `I` (where for each `i` in `I`, it is decidable whether `J i` and `K i` hold), if every `i` such that `J i` holds also satisfies `K i`, then the function `Profinite.NobelingProof.ProjRestricts C h`, which restricts a projection based on the set `C` and properties `J` and `K`, is continuous. Here, the function `h` ensures the inclusion of the domain where `J` holds into the domain where `K` holds.

If a set `C` of boolean functions on a type `I` satisfies `J i ⟹ K i` for all `i` in `I` where `J i` and `K i` are decidable, then the function restricting a projection based on `C`, `J`, and `K` is continuous.


theorem AddCommGroupCat.mono_iff_injective :
    ∀ {A B : AddCommGroupCat} (f : A ⟶ B), CategoryTheory.Mono f ↔ Function.Injective ⇑f := by sorry

This theorem states that for any two objects `A` and `B` in the category of additive commutative groups (denoted `AddCommGroupCat`), a morphism `f` from `A` to `B` is a monomorphism (in categorical sense, meaning roughly that it "preserves distinctness") if and only if the function represented by `f` is injective (in the set-theoretic sense, meaning that distinct inputs lead to distinct outputs). In other words, in the category of additive commutative groups, the categorical notion of a monomorphism aligns with the set-theoretic notion of an injective function.

In the category of additive commutative groups, a morphism is a monomorphism if and only if the represented function is injective.


theorem SimpleGraph.Subgraph.le_induce_union :
    ∀ {V : Type u} {G : SimpleGraph V} {G' : SimpleGraph.Subgraph G} {s s' : Set V},
      SimpleGraph.Subgraph.induce G' s ⊔ SimpleGraph.Subgraph.induce G' s' ≤ SimpleGraph.Subgraph.induce G' (s ∪ s') :=
  by sorry

This theorem states that for any type `V`, any `SimpleGraph` `G` of `V`, any subgraph `G'` of `G`, and any two sets `s` and `s'` of `V`, the union of the induced subgraphs of `G'` with respect to `s` and `s'` is contained within (or equal to) the induced subgraph of `G'` with respect to the union of `s` and `s'`. In other words, if we induce a subgraph from `s` and another from `s'`, then their union is a subgraph of the induced subgraph from `s ∪ s'`.

For any simple graph `G` on type `V`, any subgraph `G'` of `G`, and any sets `s` and `s'` of `V`, the induced subgraph of `G'` on `s ∪ s'` is contained in the union of the induced subgraphs of `G'` on `s` and `s'`.


SimpleGraph.Coloring.valid

theorem SimpleGraph.Coloring.valid :
    ∀ {V : Type u} {G : SimpleGraph V} {α : Type u_1} (C : SimpleGraph.Coloring G α) {v w : V}, G.Adj v w → C v ≠ C w :=
  by sorry

The theorem `SimpleGraph.Coloring.valid` states that for any type `V`, any simple graph `G` of type `V`, any type `α`, and any `α`-coloring `C` of the graph `G`, if `v` and `w` are vertices in `G` such that `v` is adjacent to `w` (expressed as `G.Adj v w`), then the colors of `v` and `w` under the coloring `C` are different. This theorem captures a key property of graph coloring: no two adjacent vertices share the same color.

In any simple graph and any valid coloring, adjacent vertices have distinct colors.


theorem IsLUB.exists_between :
    ∀ {α : Type u} [inst : LinearOrder α] {s : Set α} {a b : α}, IsLUB s a → b < a → ∃ c ∈ s, b < c ∧ c ≤ a := by sorry

The theorem `IsLUB.exists_between` states that for any type `α` under a linear order, given a set `s` of type `α` and two elements `a` and `b` of type `α`, if `a` is a least upper bound of the set `s` and `b` is strictly less than `a`, then there exists an element `c` in the set `s` such that `b` is strictly less than `c` and `c` is less than or equal to `a`. In other words, when `a` is the least upper bound of `s` and `b` is less than `a`, there is always an element `c` from `s` that lies between `b` and `a`.

If `a` is the least upper bound of a set `s` in a linear order and `b` is strictly less than `a`, then there exists an element `c` in `s` with `b` strictly less than `c` and `c` less than or equal to `a`.


theorem MeasureTheory.stoppedValue_eq_of_mem_finset :
    ∀ {Ω : Type u_1} {ι : Type u_3} {τ : Ω → ι} {E : Type u_4} {u : ι → Ω → E} [inst : AddCommMonoid E] {s : Finset ι},
      (∀ (ω : Ω), τ ω ∈ s) → MeasureTheory.stoppedValue u τ = Finset.sum s fun i => Set.indicator {ω | τ ω = i} (u i) :=
  by sorry

This theorem states that for all types `Ω`, `ι`, and `E`, a function `τ` from `Ω` to `ι`, and a map `u` from `ι` and `Ω` to `E`, given an additive commutative monoid structure on `E`, and a finite set `s` of `ι`, if for every element `ω` in `Ω`, `τ ω` is in `s`, then the stopped value of the map `u` with respect to the stopping time `τ` is equal to the sum over `s` of the set indicator function applied to the set of elements `ω` for which `τ ω` equals `i`, and the function `u i`. In mathematical terms, $\text{stoppedValue}\ u\ \tau = \sum_{i \in s} \text{Set.indicator}\ \{w | \tau w = i\}\ (u\ i)$.

For a commutative additive monoid `E`, given a function `τ:` `Ω` → `ι`, a map `u:` `ι` × `Ω` → `E`, and a finite set `s` ⊆ `ι`, if `τω` ∈ `s` for all `ω` ∈ `Ω`, then `stoppedValue` `u` `τ` = ∑(``i`:` `s`) Set.indicator {`ω` | `τ`(`ω`) = `i`} `u` `i`.


IsMaxFilter.sup

theorem IsMaxFilter.sup :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMaxFilter g l a → IsMaxFilter (fun x => f x ⊔ g x) l a :=
  by sorry

The theorem `IsMaxFilter.sup` states that for any types `α` and `β` where `β` is a semilattice, given two functions `f` and `g` from `α` to `β`, an element `a` of type `α`, and a filter `l` on `α`, if `f` and `g` are both maximized at `a` relative to `l`, then the function whose value at any point is the supremum of `f` and `g` at that point is also maximized at `a` relative to `l`. In other words, if `f(x) ≤ f(a)` and `g(x) ≤ g(a)` for all `x` in some `l`-neighborhood of `a`, then `(f(x) ⊔ g(x)) ≤ (f(a) ⊔ g(a))` for all such `x`.

If functions `f` and `g` from type `α` to semilattice `β` are maximized at `a` in filter `l` on `α`, then their pointwise supremum is also maximized at `a` in `l`.


theorem ProbabilityTheory.condexpKernel_apply_eq_condDistrib :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
      [inst_1 : Nonempty Ω] {μ : MeasureTheory.Measure Ω} [inst_2 : MeasureTheory.IsFiniteMeasure μ] {ω : Ω},
      (ProbabilityTheory.condexpKernel μ m) ω = (ProbabilityTheory.condDistrib id id μ) (id ω) :=
  by sorry

This theorem states that for any type `Ω` that is both a measurable and standard Borel space, and given a finite measure `μ` on this space, the conditional expectation kernel at any point `ω` in `Ω` is equal to the conditional distribution at that same point `ω`. The identity function is used as the measurable functions for both the kernel and distribution.

For any measurable and standard Borel space `(Ω, Σ, μ)`, the conditional expectation kernel and conditional distribution coincide, both using the identity function as measurable maps: `E[f|Σ] = D(f|Σ)` for all `f: Ω → ℝ`.


theorem mul_lt_of_lt_one_right :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α]
      [inst_3 : PosMulStrictMono α], 0 < a → b < 1 → a * b < a :=
  by sorry

This theorem states that for any given type `α` which has multiplication, an identity element for multiplication, zero, and a preorder (a reflexive and transitive relation), and satisfies the property of strict monotonicity of multiplication by positive elements (defined by `PosMulStrictMono α`), if `a` is a positive element and `b` is less than one, then the product of `a` and `b` is less than `a`. In mathematical terms, this can be stated as: if 0 < a and b < 1, then a * b < a.

For any type `α` with multiplication, an identity element, zero, a preorder, and strict monotonicity of multiplication by positive elements, if `a` is positive and `b` is less than one, then `a * b` is less than `a`.


theorem Polynomial.ofFinsupp_add :
    ∀ {R : Type u} [inst : Semiring R] {a b : AddMonoidAlgebra R ℕ},
      { toFinsupp := a + b } = { toFinsupp := a } + { toFinsupp := b } :=
  by sorry

This theorem states that for any semiring `R` and any two elements `a` and `b` of the monoid algebra over `R` generated by the additive monoid of natural numbers (`AddMonoidAlgebra R ℕ`), the sum of the mappings `toFinsupp` from `a` and `b` into `R` is the same as the mapping `toFinsupp` from the sum of `a` and `b` into `R`. In other words, it expresses that the `toFinsupp` function, which maps from the monoid algebra to `R`, preserves the addition operation.

For any semiring `R`, the `toFinsupp` function maps the sum of elements in the monoid algebra `AddMonoidAlgebra R ℕ` to the sum of their individual `toFinsupp` images in `R`.


theorem isGreatest_univ : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α], IsGreatest Set.univ ⊤ := by sorry

This theorem, `isGreatest_univ`, states that for any type `α` that has a preorder and is also an ordered set with a maximum element (denoted as `⊤`), the maximum element is the greatest element of the universal set (i.e., the set that contains all elements of `α`). In other words, no element in the universal set of `α` is greater than the maximum element `⊤`.

For any type `α` with a preorder and a maximum element `⊤`, the maximum element is the greatest element in the universal set of `α`. (i.e., for all `x ∈ α`, `x ≤ ⊤`).


theorem Finset.le_max_of_eq :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α} {a b : α}, a ∈ s → Finset.max s = ↑b → a ≤ b := by sorry

The theorem `Finset.le_max_of_eq` states that for any given type `α` that has a linear order, and for any finite set `s` of elements of this type, if an element `a` belongs to `s` and the maximum value of `s` is `b`, then `a` is less than or equal to `b`. This ensures that any element of a finite set is always less than or equal to the maximum of that set.

For any type `α` with a linear order and any finite set `s` of elements from `α`, if `a` is an element of `s` and `b` is the maximum element of `s`, then `a ≤ b`.


theorem Mathlib.Order.Filter.Bases._auxLemma.4 : ∀ {α : Type u} {s t : Set α}, (s ∈ Filter.principal t) = (t ⊆ s) := by
  sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, `s` is in the principal filter of `t` if and only if `t` is a subset of `s`. In other words, a set `s` is a part of the collection of all supersets of another set `t` (the principal filter of `t`) precisely when every element of `t` is also an element of `s`.

For any type `α` and sets `s` and `t` of type `α`, `s` is the principal filter of `t` if and only if `t` is a subset of `s`.


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

The theorem `Odd.neg_one_pow` states that for any natural number `n` in a monoid structure `α` (which is also endowed with an operation `HasDistribNeg`), if `n` is an odd number (meaning there exists an integer `k` such that `n` is equal to `2k + 1`), then the expression `(-1) ^ n` is equal to `-1`. In other words, raising `-1` to the power of any odd natural number results in `-1`.

For any monoid `α` with `HasDistribNeg`, if `n` is an odd natural number, then `(-1) ^ n = -1`.


/-- Extensionality lemma for algebra maps out of `A'[X]` over a smaller base ring than `A'`
 -/
theorem Polynomial.algHom_ext' :
    ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] {f g : Polynomial A →ₐ[R] B},
      AlgHom.comp f Polynomial.CAlgHom = AlgHom.comp g Polynomial.CAlgHom → f Polynomial.X = g Polynomial.X → f = g :=
  by sorry

This theorem, `Polynomial.algHom_ext'`, is an extensionality lemma for algebra maps out of `A'[X]` over a smaller base ring than `A'`. In more detail, it states that for any types `R`, `A`, and `B` with `R` a commutative semiring, `A` a semiring, and `B` a semiring, and `A` and `B` being algebras over `R`, if we have two algebra homomorphisms `f` and `g` from the polynomial ring in `A` to `B`, then if the composition of `f` and `Polynomial.CAlgHom` (which maps a scalar to a constant polynomial) equals the composition of `g` and `Polynomial.CAlgHom`, and `f` applied to the polynomial variable `X` equals `g` applied to `X`, then `f` and `g` are equal.

If `R` is a commutative semiring, `A` and `B` are semirings and algebras over `R`, and `f` and `g` are algebra homomorphisms from the polynomial ring in `A` to `B` such that `Polynomial.CAlgHom ∘ f = Polynomial.CAlgHom ∘ g` and `f X = g X`, then `f = g`.


theorem Ordinal.bsup_eq_sup' :
    ∀ {ι : Type u} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (f : ι → Ordinal.{max u v}),
      Ordinal.bsup (Ordinal.type r) (Ordinal.bfamilyOfFamily' r f) = Ordinal.sup f :=
  by sorry

The theorem `Ordinal.bsup_eq_sup'` states that for every type `ι`, every relation `r` on `ι` constituting a well-order, and every function `f` from `ι` to the type of ordinals, the supremum of the family of ordinals indexed by the set of ordinals less than the ordinal type of `r` (computed using `Ordinal.bsup` and `Ordinal.bfamilyOfFamily' r f`) is equal to the supremum of the family of ordinals produced by `f` (computed using `Ordinal.sup f`). In simpler terms, it says that the supremum of a family of ordinals doesn't change when we change the indexing set from a given type to the ordinals less than the ordinal type of a well-ordering on that type.

For every well-ordered type `ι`, every relation `r` on `ι`, and every monotonic function `f` from `ι` to the ordinals, the supremum of `Ordinal.bsup (Ordinal.bfamilyOfFamily' r f)` equals `Ordinal.sup f`.


theorem Mathlib.Data.List.Nodup._auxLemma.5 : ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) := by sorry

This theorem states that for all propositions 'a' and 'b', the conjunction 'a AND b' is equivalent to 'b AND a'. This is basically asserting the commutativity property of logical conjunction in propositional logic. In mathematical terms, if you have two conditions or properties 'a' and 'b', the statement " 'a' and 'b' are true" is the same as the statement " 'b' and 'a' are true".

For all propositions a and b, the conjunction a AND b is equivalent to the conjunction b AND a.


theorem Filter.EventuallyEq.const_smul :
    ∀ {α : Type u} {β : Type v} {γ : Type u_2} [inst : SMul γ β] {f g : α → β} {l : Filter α},
      f =ᶠ[l] g → ∀ (c : γ), (fun x => c • f x) =ᶠ[l] fun x => c • g x :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and given that `β` is a scalar multiple of `γ`, if two functions `f` and `g` from `α` to `β` are eventually equal at a filter `l`, then the function that multiplies `f` by any scalar `c` from `γ` will be eventually equal at the same filter `l` to the function that multiplies `g` by the same scalar `c`. In mathematical terms, if $f(x) = g(x)$ eventually at some filter $l$, then for any scalar $c$, $c \cdot f(x) = c \cdot g(x)$ eventually at the same filter $l$.

For any types `α`, `β` being scalar types with `β = c * γ` for some scalar `c`, if functions `f` and `g` from `α` to `β` are eventually equal at filter `l`, then `c * f(x)` is eventually equal to `c * g(x)` at the same filter `l`.


/-- The restriction of the pushforward measure is the pushforward of the restriction. For a version
assuming only `AEMeasurable`, see `restrict_map_of_aemeasurable`.  -/
theorem MeasureTheory.Measure.restrict_map :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β},
      Measurable f →
        ∀ {s : Set β},
          MeasurableSet s →
            (MeasureTheory.Measure.map f μ).restrict s = MeasureTheory.Measure.map f (μ.restrict (f ⁻¹' s)) :=
  by sorry

The theorem `MeasureTheory.Measure.restrict_map` states that for any two types `α` and `β` with their respective measurable spaces `m0` and `inst`, along with a measure `μ` on `α` and a measurable function `f` from `α` to `β`, the restriction of the pushforward measure of `μ` under `f` to a measurable set `s` in `β` is the same as the pushforward of the restriction of `μ` to the preimage of `s` under `f`. In other words, it characterizes the interaction between the operations of measure pushforward and restriction in terms of set functions and their preimages. This theorem requires the function `f` to be measurable, and it is stated for all measurable sets `s`.

Given measurable spaces `(α, m0)` and `(β, inst)`, a measure `μ` on `α`, a measurable function `f : α -> β`, and a measurable set `s` in `β`, the pushforward measure of the restriction of `μ` to `f⁁⁻¹(s)` is equal to the restriction of the pushforward measure of `μ` under `f` to `s`.


theorem edist_mul_left :
    ∀ {M : Type u} [inst : Mul M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricSMul M M] (a b c : M),
      edist (a * b) (a * c) = edist b c :=
  by sorry

This theorem states that for any type `M` that is equipped with a multiplication operation, a pseudo emetric space structure, and an isometric scalar multiplication structure, the edistance (extended distance) between the product of `a` and `b` and the product of `a` and `c` is equal to the edistance between `b` and `c`. This essentially means the multiplication by `a` preserves the edistance between `b` and `c`. This is applicable for any elements `a`, `b` and `c` in `M`.

For any type `M` with multiplication, a pseudo-metric, and isometric scalar multiplication, the extended distance between `a` \* `b` and `a` \* `c` equals the extended distance between `b` and `c`, for all `a, b, c` in `M`.


theorem nhds_nhdsAdjoint_of_ne : ∀ {α : Type u} {a b : α} (f : Filter α), b ≠ a → nhds b = pure b := by sorry

This theorem states that for any type `α`, and any two elements `a` and `b` of `α` that are not equal, along with a filter `f` on `α`, the neighborhood filter of `b` is equal to the pure filter of `b`. In other words, the set of all neighborhoods of `b` (each of which is a set that contains an open set around `b`) is equal to the set that contains `b` and nothing else if `b` is not equal to `a`.

For any type `α`, filter `f` on `α`, and distinct elements `a` and `b` of `α`, the neighborhood filter of `b` equals the pure point filter of `b` in `f`.


theorem List.sum_le_sum :
    ∀ {ι : Type u_1} {M : Type u_5} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} {f g : ι → M},
      (∀ i ∈ l, f i ≤ g i) → List.sum (List.map f l) ≤ List.sum (List.map g l) :=
  by sorry

This theorem, `List.sum_le_sum`, states that given any types `ι` and `M`, where `M` is a monoid under addition and is also a preorder, and also satisfies covariant classes with respect to addition operation and less than or equal to relation, for any list `l` of elements of type `ι` and any two functions `f` and `g` from `ι` to `M`, if each element of the list `l` when mapped through function `f` is less than or equal to the same element when mapped through function `g`, then the sum of all the elements of list `l` when mapped through function `f` is less than or equal to the sum of all the elements when mapped through function `g`. In other words, if `f(i) ≤ g(i)` for all `i` in list `l`, then the sum of `f(i)` for all `i` in `l` is less than or equal to the sum of `g(i)` for all `i` in `l`.

Given a list `l` of elements from a preorder `(ι, ≤)` with monoid structure `M` under addition, if `f(i) ≤ g(i)` for all `i` in `l`, then `Σ(i in l) f i ≤ Σ(i in l) g i`.


theorem ultrafilterBasis_is_basis : ∀ {α : Type u}, TopologicalSpace.IsTopologicalBasis (ultrafilterBasis α) := by sorry

The theorem `ultrafilterBasis_is_basis` states that for any type `α`, the `ultrafilterBasis` defined for `α` is a topological basis. In terms of topology, a topological basis is a subset of the power set of a topological space that can be used to generate the topology of that space. In this context, the sets of ultrafilters over the elements of `α` that contain a particular subset of `α` form a topological basis, meaning that every open set in the topology can be written as a union of these sets.

The set of ultrafilters over a type `α` forms a topological basis for the Scott topology on `α`.


theorem OreLocalization.one_def :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S], 1 = 1 /ₒ 1 := by sorry

This theorem states that in the context of Ore localization, given any type `R` which forms a monoid and a submonoid `S` of `R` that is an Ore set, the identity element '1' of the Ore localization is equal to the fraction '1 over 1' in the Ore localization. The Ore localization is a method of generalizing the construction of the quotient field of an integral domain to more general rings.

In the context of Ore localization, the identity element is equal to '1/1' in the Ore localization of a monoid `R` with an Ore submonoid `S`.


theorem Set.image_add_const_Icc :
    ∀ {M : Type u_1} [inst : OrderedCancelAddCommMonoid M] [inst_1 : ExistsAddOfLE M] (a b c : M),
      (fun x => x + a) '' Set.Icc b c = Set.Icc (b + a) (c + a) :=
  by sorry

This theorem states that for any ordered cancelable commutative monoid `M` where addition exists for less than or equal elements, and given any elements `a`, `b`, and `c` of type `M`, the image of the interval from `b` to `c` (inclusive at both ends, denoted as `Set.Icc b c`) under the function `x ⟼ x + a` is exactly the interval from `b + a` to `c + a` (again inclusive at both ends). This is essentially a translation of the interval `[b, c]` by `a` along the real line.

For any ordered cancelable commutative monoid `M` with addition, and elements `a`, `b`, and `c` of `M`, the image of the interval `Set.Icc b c` under the function `x ⟼ x + a` equals `Set.Icc (b + a) (c + a)`.


theorem Ideal.submodule_span_eq : ∀ {α : Type u} [inst : Semiring α] {s : Set α}, Submodule.span α s = Ideal.span s :=
  by sorry

This theorem states that for any semiring `α` and a set `s` of elements from `α`, the span of `s` as a submodule of `α` is equal to the ideal generated by `s`. In other words, the smallest submodule of `α` that contains `s` is the same as the ideal of `α` that is generated by `s`. The `Submodule.span α s` and `Ideal.span s` are two different ways of defining a similar concept in the context of ring theory and module theory respectively, and this theorem asserts their equivalence.

For any semiring `α` and set `s` of its elements, the submodule generated by `s` in `α` equals the ideal generated by `s`.


theorem AddMonoidHom.map_finsum_plift :
    ∀ {M : Type u_2} {N : Type u_3} {α : Sort u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (f : M →+ N)
      (g : α → M), Set.Finite (Function.support (g ∘ PLift.down)) → f (finsum fun x => g x) = finsum fun x => f (g x) :=
  by sorry

This theorem states that for any two types `M` and `N` that form additive commutative monoids, and any type `α`, given an additive monoid homomorphism `f` from `M` to `N` and a function `g` from `α` to `M`, if the support of the composition `g ∘ PLift.down` is finite (i.e., there are only finitely many elements `x` in `α` such that `(g ∘ PLift.down)(x) ≠ 0`), then the value of `f` applied to the finite sum of `g(x)` over all `x` in `α` is equal to the finite sum of `f(g(x))` over all `x` in `α`.

This means that we can interchange the order of the sum and the application of the homomorphism `f` when summing over the elements of the support of `g ∘ PLift.down`.

Given additive commutative monoids M and N, an additive monoid homomorphism f from M to N, and a function g from a set α to M with finite support, the sum of f(g(x)) over x in α equals the application of f to the sum of g(x) over x in α.


theorem Turing.ListBlank.nth_map :
    ∀ {Γ : Type u_1} {Γ' : Type u_2} [inst : Inhabited Γ] [inst_1 : Inhabited Γ'] (f : Turing.PointedMap Γ Γ')
      (l : Turing.ListBlank Γ) (n : ℕ),
      Turing.ListBlank.nth (Turing.ListBlank.map f l) n = f.f (Turing.ListBlank.nth l n) :=
  by sorry

The theorem `Turing.ListBlank.nth_map` states that for any types `Γ` and `Γ'` (assumed to be inhabited), a pointed map `f` from `Γ` to `Γ'`, a `ListBlank` `l` of type `Γ`, and a natural number `n`, the `n`-th element of the `ListBlank` obtained by mapping `f` over `l` is the same as the result of applying `f` to the `n`-th element of `l`. In other words, it establishes the property that the `map` and `nth` operations on `ListBlank`s commute with each other under the application of a pointed map.

For any pointed map `f` and `ListBlank` `l`, the `n`-th element of the list obtained by mapping `f` over `l` is equal to applying `f` to the `n`-th element of `l`.


theorem CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C) {Z : C} (h : S.L₂.X₂ ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.φ₁ S)
          (CategoryTheory.CategoryStruct.comp S.L₂.f h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.φ₂ S) h :=
  by sorry

The theorem `CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f_assoc` states that for any category `C`, which is also an Abelian category, and given `S`, an object of type `CategoryTheory.ShortComplex.SnakeInput C`, and an arbitrary morphism `h` from `S.L₂.X₂` to `Z`, the composition of the canonical map `φ₁` with the composition of `S.L₂.f` and `h` is the same as the composition of the canonical map `φ₂` with `h`. In mathematical notation, this is saying that `(φ₁ ∘ (S.L₂.f ∘ h)) = (φ₂ ∘ h)`.

For any Abelian category `C`, given an object `S` in `CategoryTheory.ShortComplex.SnakeInput C`, and a morphism `h` from `S.L₂.X₂` to `Z`, the composition of `φ₁` with `h` and `S.L₂.f` is equal to the composition of `φ₂` with `h`. That is, `(φ₁ ∘ h ∘ S.L₂.f) = (φ₂ ∘ h)`.


theorem PadicInt.zmod_cast_comp_toZModPow :
    ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] (m n : ℕ) (h : m ≤ n),
      RingHom.comp (ZMod.castHom ⋯ (ZMod (p ^ m))) (PadicInt.toZModPow n) = PadicInt.toZModPow m :=
  by sorry

This theorem states that for any natural number `p` that is prime and any two natural numbers `m` and `n` such that `m` is less than or equal to `n`, the composition of the ring homomorphism from `ZMod n` to `ZMod (p ^ m)` with the ring homomorphism from `ℤ_[p]` to `ZMod (p^n)` is equal to the ring homomorphism from `ℤ_[p]` to `ZMod (p^m)`. In other words, it ensures the compatibility of reducing a p-adic integer modulo `p^n` before or after reducing modulo `p^m` for `m ≤ n`.

For any prime number p and natural numbers m and n with m <= n, the ring homomorphism from Z_[p] to ZMod (p^m) commutes with the ring homomorphism from ZMod n to ZMod (p^m).


theorem Mathlib.Algebra.Order.Ring.Lemmas._auxLemma.5 :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulStrictMono α]
      [inst_3 : PosMulReflectLT α], 0 < a → (0 < a * b) = (0 < b) :=
  by sorry

The theorem `Mathlib.Algebra.Order.Ring.Lemmas._auxLemma.5` in Lean 4 states that for any type `α` equipped with a multiplication operation, a zero element, and a preorder relation, and if this type `α` satisfies two properties: strict monotonicity of multiplication by positive elements on the left (`PosMulStrictMono α`) and strict reverse monotonicity of multiplication by nonnegative elements on the left (`PosMulReflectLT α`), then for any two elements `a` and `b` from `α`, if `a` is positive (i.e., `0 < a`), then `a` times `b` is positive if and only if `b` is positive. In other words, it states that if `0 < a`, then `0 < a * b` is equivalent to `0 < b`.

If `α` is a type with multiplication, zero, and preorder such that multiplication by positive elements is strictly monotonic and multiplication by nonnegative elements is strictly reverse monotonic, then for all `a, b ∈ α` with `0 < a`, we have `0 < a * b` if and only if `0 < b`.


theorem LinearMap.stdBasis_same :
    ∀ (R : Type u_1) {ι : Type u_2} [inst : Semiring R] (φ : ι → Type u_3) [inst_1 : (i : ι) → AddCommMonoid (φ i)]
      [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : DecidableEq ι] (i : ι) (b : φ i),
      (LinearMap.stdBasis R φ i) b i = b :=
  by sorry

The theorem "LinearMap.stdBasis_same" states that for any semi-ring `R`, index type `ι`, a family of types `φ : ι → Type`, where each `φ i` is an additively commutative monoid and a module over `R`, and a decidable equality on `ι`, given an index `i` of type `ι` and an element `b` of `φ i`, applying the standard basis linear map on `b` and then evaluating it at `i` will yield `b` itself. Essentially, it asserts that the standard basis linear map behaves as expected when applied to its corresponding index in the basis.

For any semi-ring `R`, index type `ι`, a family of additively commutative monoids and `R`-modules `φ : ι → Type`, and a decidable equality on `ι`, the standard basis linear map on an element `b` of `φ i` evaluated at `i` equals `b` itself.


theorem CategoryTheory.ShortComplex.exact_of_iso :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C},
      (S₁ ≅ S₂) → CategoryTheory.ShortComplex.Exact S₁ → CategoryTheory.ShortComplex.Exact S₂ :=
  by sorry

This theorem states that in any category `C` (with zero morphisms), if there is an isomorphism between two short complexes `S₁` and `S₂`, then `S₂` is exact whenever `S₁` is exact. In other words, exactness is preserved under isomorphism in the context of short complexes in a category. Here, a short complex is a specific type of diagram in category theory, and a complex is said to be exact if it satisfies certain conditions related to the objects and morphisms in the diagram.

In any category with zero morphisms, the exactness of a short complex is preserved under isomorphism.


theorem Mathlib.Data.Fintype.Card._auxLemma.7 : ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True :=
  by sorry

This theorem states that for any type `α` which is a finite type (denoted as `Fintype α`), any element `x` of type `α` is always contained in the universal finite set of type `α` (`Finset.univ`). In other words, for a given finite type, every element of that type is included in the universal set of that type.

For any finite type `α`, every element of `α` belongs to the universal finite set `Finset.univ` of type `Finset α`.


theorem Mathlib.Data.Fintype.Card._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α], (Fintype.card α = 0) = False := by sorry

This theorem states that for any type `α` which is a finite type (denoted by `Fintype α`) and non-empty (denoted by `Nonempty α`), the cardinality of `α` (the number of elements in `α`) cannot be zero. In other words, it's impossible for a non-empty finite type to have zero elements.

A non-empty finite type has a positive number of elements.


theorem Set.finite_of_encard_le_coe : ∀ {α : Type u_1} {s : Set α} {k : ℕ}, Set.encard s ≤ ↑k → Set.Finite s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any natural number `k`, if the cardinality of set `s` is less than or equal to `k`, then the set `s` is finite. Here, the cardinality of a set is defined as a term in `ℕ∞` (the set of natural numbers including infinity), and a set is considered finite if there exists a natural number `n` such that there is an equivalence between the set and the finite set `Fin n`.

For any type `α` and set `s` of type `α`, if the cardinality of `s` is less than or equal to some natural number `k`, then `s` is a finite set.


theorem LieAlgebra.isSemisimple_iff_no_abelian_ideals :
    ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
      LieAlgebra.IsSemisimple R L ↔ ∀ (I : LieIdeal R L), IsLieAbelian ↥↑I → I = ⊥ :=
  by sorry

The theorem states that for any commutative ring `R` and any Lie ring `L` that is also a Lie algebra over `R`, the Lie algebra is semisimple if and only if for every Lie ideal `I` of this algebra, if `I` is Abelian (i.e., it is trivial as a Lie module over itself), then `I` must be the zero ideal. In other words, a Lie algebra is semisimple if it does not have any non-zero Abelian ideals.

A Lie algebra over a commutative ring is semisimple if and only if it has no non-zero Abelian Lie ideals.


theorem Function.injective_iff_hasLeftInverse :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Nonempty α] {f : α → β}, Function.Injective f ↔ Function.HasLeftInverse f :=
  by sorry

This theorem states that for any types `α` and `β` with `α` being nonempty, and any function `f` from `α` to `β`, the function `f` is injective if and only if `f` has a left inverse. In mathematical terms, a function `f: α → β` is injective if each element in `β` is mapped to by at most one element in `α`, and `f` has a left inverse if there exists another function that when composed with `f` from the left, results in the identity function on `α`. The theorem establishes a correspondence between these two properties of a function.

A function `f: α → β` with nonempty `α` is injective if and only if there exists a function `g: β → α` such that `f ∘ g = idα`.


/-- A measure on a countable type is a sum of Dirac measures.  -/
theorem MeasureTheory.Measure.sum_smul_dirac :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : Countable α] [inst_2 : MeasurableSingletonClass α]
      (μ : MeasureTheory.Measure α), (MeasureTheory.Measure.sum fun a => ↑↑μ {a} • MeasureTheory.Measure.dirac a) = μ :=
  by sorry

The theorem `MeasureTheory.Measure.sum_smul_dirac` states that for any measure `μ` on a countable and measurable singleton type `α`, it can be represented as a sum of Dirac measures, each scaled by the measure of the corresponding singleton set. In other words, any measure in such a set-up can be broken down into a series of "point masses" (Dirac measures), each located at a unique point in the space and weighed by the measure of that point. This is an important theorem in measure theory because it demonstrates that the concept of a measure can be generalized from simple summation of values at points (as in Dirac measures) to more complex structures that account for densities and distributions.

For any countable and measurable singleton type in a measure space, the measure can be represented as a sum of Dirac measures, each scaled by the measure of the corresponding singleton set.


theorem List.attach.proof_1 : ∀ {α : Type u_1} (l : List α), ∀ x ∈ l, x ∈ l := by sorry

This theorem states that for any given type `α` and a list `l` of type `α`, any element `x` that is in the list `l` is indeed in the list `l`. This is essentially a tautology or a self-evident truth, which asserts that any member of a list is a member of that list. In mathematical notation, this would be expressed as "For all `x`, if `x` belongs to `l`, then `x` belongs to `l`".

For any list `l` and any element `x` in type `α`, if `x ∈ l`, then `x ∈ l`.


theorem Hyperreal.infiniteNeg_iff_infinitesimal_inv_neg :
    ∀ {x : ℝ*}, Hyperreal.InfiniteNeg x ↔ Hyperreal.Infinitesimal x⁻¹ ∧ x⁻¹ < 0 := by sorry

The theorem `Hyperreal.infiniteNeg_iff_infinitesimal_inv_neg` establishes an equivalence between two properties of hyperreal numbers. Specifically, it states that for any hyperreal number `x`, `x` is negatively infinite if and only if the inverse of `x` is infinitesimal and negative. In other words, a hyperreal number `x` is smaller than all real numbers if and only if the reciprocal of `x` is infinitesimally close to zero and is negative.

A hyperreal number `x` is negatively infinite if and only if its multiplicative inverse is an infinitesimal negative.


theorem MvPolynomial.totalDegree_C :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (a : R), MvPolynomial.totalDegree (MvPolynomial.C a) = 0 := by
  sorry

This theorem states that for any type `R` and `σ`, with `R` being a commutative semiring, the total degree of a constant multivariate polynomial is zero. In more detail, given any element `a` from `R`, when we construct a constant polynomial with value `a` using `MvPolynomial.C`, the maximum absolute degree of its monomials, as calculated by `MvPolynomial.totalDegree`, is always zero.

For any commutative semiring `R` and constant polynomial `p` of type `MvPolynomial R` with `p = MvPolynomial.C a` for some `a : R`, the total degree of `p` is zero.


theorem Real.toNNReal_le_toNNReal : ∀ {r p : ℝ}, r ≤ p → Real.toNNReal r ≤ Real.toNNReal p := by sorry

This theorem states that for all real numbers `r` and `p`, if `r` is less than or equal to `p`, then the non-negative real number equivalent of `r` (which is `0` if `r` is less than `0`) is less than or equal to the non-negative real number equivalent of `p`. In mathematical terms, for any $r, p \in \mathbb{R}$, if $r \leq p$ then $\text{toNNReal}(r) \leq \text{toNNReal}(p)$, where $\text{toNNReal}$ is a function that converts a real number to a non-negative real number by taking the maximum of the number and zero.

For all real numbers $r$ and $p$, if $r \leq p$, then $0 \lor r \leq 0 \lor p \implies \text{toNNReal}(r) \leq \text{toNNReal}(p)$, where $\text{toNNReal}$ is the function mapping $r$ to $0$ if $r < 0$ and to $r$ otherwise.


theorem Nat.factors_eq : ∀ {n : ℕ}, UniqueFactorizationMonoid.normalizedFactors n = ↑(Nat.factors n) := by sorry

The theorem `Nat.factors_eq` states that for every natural number 'n', the multiset of prime factors determined noncomputably (via the `UniqueFactorizationMonoid.normalizedFactors` function) is equal to the coercion of the list of prime factors of 'n' (obtained by the `Nat.factors` function). In other words, both methods for obtaining the prime factorization of a natural number 'n' yield the same result, despite one being a multiset and the other being a list.

For every natural number n, the multiset of prime factors obtained noncomputably is equal to the coercion of the list of prime factors of n.


theorem AddSubgroup.map_mono :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {K K' : AddSubgroup G},
      K ≤ K' → AddSubgroup.map f K ≤ AddSubgroup.map f K' :=
  by sorry

The theorem `AddSubgroup.map_mono` states that for any two additive subgroups `K` and `K'` of an additive group `G` and a given additive monoid homomorphism `f` from `G` to another additive group `N`, if `K` is a subset of `K'` (denoted as `K ≤ K'`), then the image of `K` under `f` is a subset of the image of `K'` under `f`, i.e., `AddSubgroup.map f K ≤ AddSubgroup.map f K'`. This theorem is demonstrating the monotonicity of the map function on additive subgroups.

If `K ≤ K'` are additive subgroups of an additive group `G` and `f` is an additive monoid homomorphism from `G` to another additive group `N`, then `AddSubgroup.map f K ≤ AddSubgroup.map f K'`.


theorem ValuationSubring.coe_mem_principalUnitGroup_iff :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) {x : ↥(ValuationSubring.unitGroup A)},
      ↑x ∈ ValuationSubring.principalUnitGroup A ↔
        (ValuationSubring.unitGroupMulEquiv A) x ∈ MonoidHom.ker (Units.map ↑(LocalRing.residue ↥A)) :=
  by sorry

This theorem states that for any field `K` and a valuation subring `A` of `K`, a unit `x` from the unit group of `A` belongs to the principal unit group of `A` if and only if the equivalent element of `x` under the unit group multiplication equivalence relation of `A` belongs to the kernel of the monoid homomorphism induced by mapping units of the residue field of `A`. In simpler terms, it relates the elements of the principal unit group and the elements that become identity when mapped to the residue field of the valuation subring.

A unit in a valuation subring belongs to its principal unit group if and only if its class under the unit group equivalence relation maps to the identity element in the residue field under the homomorphism of unit groups.


theorem CategoryTheory.Functor.initial_of_final_op :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Functor.Final F.op], CategoryTheory.Functor.Initial F :=
  by sorry

This theorem states that, given any two categories `C` and `D`, and a functor `F` from `C` to `D`, if the opposite functor `F.op` is final, then the original functor `F` is initial. This is in the context of category theory, and the "opposite" functor reverses the direction of morphisms, while "final" and "initial" relate to certain properties of functors in terms of how they interact with limits and colimits.

If the opposite functor of `F` from category `C` to category `D` is final, then `F` is initial.


theorem BoundedContinuousFunction.dist_le_iff_of_nonempty :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      {f g : BoundedContinuousFunction α β} {C : ℝ} [inst_2 : Nonempty α],
      dist f g ≤ C ↔ ∀ (x : α), dist (f x) (g x) ≤ C :=
  by sorry

This theorem states that for any two bounded continuous functions `f` and `g` mapping from a topological space `α` to a pseudometric space `β`, and for any real number `C`, the distance between `f` and `g` is less than or equal to `C` if and only if the distance between `f(x)` and `g(x)` is less than or equal to `C` for all `x` in `α`. This holds true given that `α` is nonempty.

For any bounded continuous functions `f` and `g` from a nonempty topological space `α` to a pseudometric space `β`, the functions have distance at most `C` if and only if the images `f(x)` and `g(x)` of each point `x` in `α` have distance at most `C`.


theorem geom_sum_mul_neg :
    ∀ {α : Type u} [inst : Ring α] (x : α) (n : ℕ),
      (Finset.sum (Finset.range n) fun i => x ^ i) * (1 - x) = 1 - x ^ n :=
  by sorry

This theorem, `geom_sum_mul_neg`, states that for every type `α` that forms a ring and any element `x` of `α` and natural number `n`, the sum of the `i-th` powers of `x` for `i` in the range of natural numbers less than `n`, multiplied by `(1 - x)`, equals `1 - x^n`. In mathematical terms, it is expressing the formula for the sum of a geometric series: $\sum_{i=0}^{n-1} x^i * (1 - x) = 1 - x^n$. This is valid in any ring structure.

For any ring `α` and element `x` in `α`, the sum of the geometric series $\sum\_{i=0}^{n-1} x^i$ equals `1 - x^n`.


theorem AddUnits.neg_eq_of_add_eq_zero_right :
    ∀ {α : Type u} [inst : AddMonoid α] {u : AddUnits α} {a : α}, ↑u + a = 0 → ↑(-u) = a := by sorry

This theorem states that for any type `α` equipped with an additive monoid structure, given an additive unit `u` and an element `a` from `α`, if the sum of the coercions of `u` and `a` equals zero, then the coercion of the additive inverse of `u` is equal to `a`. In other words, in the context of an additive monoid, if adding a certain element to another results in zero, the second element is the additive inverse of the first.

For any additive monoid type `α` and its additive unit `u` with `u + a = 0` implying `a = -u`.


/-- When taking the supremum of `f : ι → α`, the elements of `ι` on which `f` gives `⊥` can be
dropped, without changing the result.  -/
theorem iSup_ne_bot_subtype :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] (f : ι → α), ⨆ i, f ↑i = ⨆ i, f i := by sorry

This theorem states that for any function `f` mapping from some type `ι` to a complete lattice `α`, the supremum (the least upper bound) of `f` over all `ι` doesn't change even if we drop the elements of `ι` for which `f` returns the bottom element (`⊥`). In this context, the bottom element is the smallest element of the lattice `α`.

Given a function `f` from type `ι` to a complete lattice `α` with bottom element `⊥`, the supremum of `f` over all `ι` is equal to the supremum of `f` over the elements of `ι` that map to an element above `⊥` in `α`.


theorem MeasurableEmbedding.comap_apply :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f →
        ∀ (μ : MeasureTheory.Measure β) (s : Set α), ↑↑(MeasureTheory.Measure.comap f μ) s = ↑↑μ (f '' s) :=
  by sorry

This theorem, `MeasurableEmbedding.comap_apply`, states that for any types `α` and `β`, any measurable spaces `m0` and `m1` over `α` and `β` respectively, and any function `f` from `α` to `β`, if `f` is a measurable embedding, then for any measure `μ` on `β` and any set `s` of `α`, the measure of `s` under the pushforward measure induced by `f` from `μ`, is equal to the measure of the image of `s` under `f` in the measure `μ`. In essence, it provides a relationship between measures on the original and image sets under a measurable embedding.

For any measurable spaces `m0` over `α`, `m1` over `β`, measurable embedding `f` from `α` to `β`, and measure `μ` on `β`, the pushforward measure of `μ` under `f` of a set `s` in `m0` equals the measure of the image of `s` under `f`.


theorem Real.tan_neg : ∀ (x : ℝ), Real.tan (-x) = -Real.tan x := by sorry

This theorem states that the real tangent function has odd symmetry. Specifically, for any real number `x`, the tangent of its negative, `tan(-x)`, is equal to the negative of the tangent of `x`, `-tan(x)`.

The real tangent function is an odd function, i.e., tan(-x) = -tan(x) for all real numbers x.


theorem AlgebraicTopology.DoldKan.Q_f_naturality :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (q n : ℕ)
      {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (f.app (Opposite.op (SimplexCategory.mk n)))
          ((AlgebraicTopology.DoldKan.Q q).f n) =
        CategoryTheory.CategoryStruct.comp ((AlgebraicTopology.DoldKan.Q q).f n)
          (f.app (Opposite.op (SimplexCategory.mk n))) :=
  by sorry

This theorem, `AlgebraicTopology.DoldKan.Q_f_naturality`, states that for any category `C` with preadditive structure, any simplicial objects `X` and `Y` in `C`, any natural number `q` and `n`, and any morphism `f` from `X` to `Y`, the composition of the morphism `f` applied to the opposite of the simplex category object created from `n`, with the `n`-th face map of the complement projection `Q` associated with `q`, is the same as the composition of the `n`-th face map of `Q` associated with `q`, with the morphism `f` applied to the opposite of the simplex category object created from `n`. This can be seen as a statement about the naturality of the complement projection `Q` in the category of simplicial objects.

For any preadditive category `C`, simplicial objects `X` and `Y`, natural number `q`, and morphism `f` in `C`, the diagram commuting between `f`, `Q_n` and `Q_n'` (where `Q` is the complement projection of `q`, `Q_n` is the `n`-th face map of `Q`, and `Q_n'` is the `n`-th face map of the morphism `f` applied to the opposite simplex category object) commutes.


theorem thickenedIndicatorAux_lt_top :
    ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {δ : ℝ} {E : Set α} {x : α}, thickenedIndicatorAux δ E x < ⊤ := by
  sorry

The theorem `thickenedIndicatorAux_lt_top` states that for any type `α` equipped with a pseudometric space structure, for any real number `δ`, any set `E` of type `α`, and any element `x` of type `α`, the value of the δ-thickened indicator function at `x` is always less than infinity. This essentially means that the δ-thickened indicator function always returns a finite value when given any element of the set.

For any pseudometric space `(α, d)`, real number `δ`, set `E ∈ α`, and `x ∈ α`, the value `thickenedIndicatorAux δ E x` is finite.


theorem induced_generateFrom_eq :
    ∀ {α : Type u_1} {β : Type u_2} {b : Set (Set β)} {f : α → β},
      TopologicalSpace.induced f (TopologicalSpace.generateFrom b) =
        TopologicalSpace.generateFrom (Set.preimage f '' b) :=
  by sorry

This theorem states that for any types `α` and `β`, a set `b` of sets of `β`, and a function `f` from `α` to `β`, the topology induced on `α` by the function `f` and the topology generated from `b` on `β` is equal to the topology on `α` generated by the preimage under `f` of each set in `b`. In simpler terms, we can generate a topology on `α` by taking the preimages of a collection of sets under a function, and this topology is the same as the one we would get by first generating a topology on `β` from the collection and then inducing a topology on `α` through the function.

The topology on a type `α` induced by a function `f` from `α` to `β` and a collection `b` of sets of `β`, is equal to the topology on `α` generated by the preimages under `f` of sets in `b`.


theorem Complex.sq_abs : ∀ (z : ℂ), Complex.abs z ^ 2 = Complex.normSq z := by sorry

The theorem `Complex.sq_abs` states that for any complex number `z`, the square of the absolute value of `z` is equal to the norm squared of `z`. In mathematical terms, if `z` is a complex number, then `|z|^2 = z.re^2 + z.im^2`, where `|z|` denotes the absolute value of `z`, `z.re` denotes the real part of `z`, and `z.im` denotes the imaginary part of `z`. The absolute value of a complex number is the square root of the norm squared, so squaring the absolute value gives us back the norm squared.

The square of the absolute value of a complex number equals the sum of the squares of its real and imaginary parts. (i.e. |z|^2 = z.re^2 + z.im^2)


theorem MeasureTheory.OuterMeasure.sUnion_null_iff :
    ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {S : Set (Set α)},
      Set.Countable S → (↑m (⋃₀ S) = 0 ↔ ∀ s ∈ S, ↑m s = 0) :=
  by sorry

This theorem is stating that for any type `α`, given an outer measure `m` on `α` and a countable collection of sets `S` of type `α`, the measure of the union of sets `S` is zero if and only if the measure of each set `s` in `S` is also zero. In mathematical terms, if `S` is a countable collection of subsets of a set `α` and `m` is an outer measure on `α`, then the total measure (according to `m`) of the union of all the sets in `S` is zero if and only if the measure of every set in `S` is zero.

For any outer measure `m` on a type `α` and countable collection `S` of subsets of `α`, the union of sets in `S` has measure zero if and only if every set in `S` has measure zero.


theorem MvPolynomial.vars_rename :
    ∀ {R : Type u} {σ : Type u_1} {τ : Type u_2} [inst : CommSemiring R] [inst_1 : DecidableEq τ] (f : σ → τ)
      (φ : MvPolynomial σ R), MvPolynomial.vars ((MvPolynomial.rename f) φ) ⊆ Finset.image f (MvPolynomial.vars φ) :=
  by sorry

This theorem `MvPolynomial.vars_rename` states that for any commutative semiring `R`, any types `σ` and `τ` where `τ` has decidable equality, and any function `f` from `σ` to `τ`, if `φ` is a multivariate polynomial over `σ` and `R`, then the set of variables appearing in the polynomial obtained by renaming the variables of `φ` using `f` is a subset of the image of the set of variables of `φ` under `f`. In other words, if we rename the variables in a polynomial, the new variables are exactly the images under `f` of the original variables.

For any commutative semiring R, type σ with decidable equality, function f from σ to type τ, and multivariate polynomial φ over σ and R, the variables in the polynomial obtained by renaming using f are a subset of the image of the polynomial's variables under f.


/-- The product of two elements of the additive closure of a submonoid `M` is an element of the
additive closure of `M`.  -/
theorem MulMemClass.mul_mem_add_closure :
    ∀ {M : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] [inst_1 : SetLike M R]
      [inst_2 : MulMemClass M R] {S : M} {a b : R},
      a ∈ AddSubmonoid.closure ↑S → b ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S :=
  by sorry

This theorem states that for any types `M` and `R`, where `M` is a set-like structure over `R` and `R` is a non-unital, non-associative semiring, if `S` is a structure of type `M` and `a` and `b` are elements of `R`, then the product of two elements that are within the additive closure of `S` (as defined by `AddSubmonoid.closure`) is also within the additive closure of `S`. In simpler terms, if you have a set `S` in a semiring `R` and you generate an additive submonoid `S'` by taking the closure of `S`, then the product of any two elements of `S'` will also be an element of `S'`. This follows from the closure properties of submonoids in ring theory.

Given a set-like structure `S` over a non-unital, non-associative semiring `R`, the additive closure of `S` is a submonoid of `R` and thus contains the product of any two of its elements.


theorem Nat.multichoose_zero_right : ∀ (n : ℕ), Nat.multichoose n 0 = 1 := by sorry

The theorem `Nat.multichoose_zero_right` states that for any natural number `n`, the multiset choosing function `Nat.multichoose` with `n` as the size of the type and `0` as the cardinality of the multiset always equals `1`. In mathematical terms, this theorem says that there is exactly one way to choose a multiset of size `0` from a set of size `n`, for any `n`, and that is the empty set.

For any natural number `n`, the multiset choosing function `Nat.multichoose` with `n` as the size and `0` as the cardinality equals 1, equivalent to there being only one multiset of size 0 from a set of size `n`, which is the empty multiset.


theorem Mathlib.Algebra.Pointwise.Stabilizer._auxAddLemma.9 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = ∀ (x : B), x ∈ p ↔ x ∈ q := by sorry

This theorem, named `Mathlib.Algebra.Pointwise.Stabilizer._auxAddLemma.9`, states that for any types `A` and `B`, with the condition that `A` is a subset-like structure of `B`, and for any elements `p` and `q` of type `A`, `p` is equal to `q` if and only if for all elements `x` of type `B`, `x` is in `p` exactly when `x` is in `q`. In other words, two elements of a subset-like structure are identical if they contain exactly the same elements.

For any subset-like structures `A` of type `B` and elements `p` and `q` of type `A`, `p` equals `q` if and only if they contain the same elements of `B`.


theorem Complex.abs_natCast : ∀ (n : ℕ), Complex.abs ↑n = ↑n := by sorry

This theorem states that for every natural number `n`, the absolute value of the complex number obtained by casting `n` to a complex number is equal to the real number obtained by casting `n` to a real number. In other words, for any natural number, its absolute value remains the same whether it's considered as a complex number or a real number.

For every natural number `n`, the absolute value of the complex number `fromNat n` is equal to the real number `fromNat n`.


theorem MonoidHom.cancel_right :
    ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : MulOneClass M] [inst_1 : MulOneClass N]
      [inst_2 : MulOneClass P] {g₁ g₂ : N →* P} {f : M →* N},
      Function.Surjective ⇑f → (MonoidHom.comp g₁ f = MonoidHom.comp g₂ f ↔ g₁ = g₂) :=
  by sorry

The theorem `MonoidHom.cancel_right` states that for any three types `M`, `N`, and `P` that have the structure of a monoid (i.e., a set equipped with an associative binary operation and an identity element), given two monoid homomorphisms `g₁` and `g₂` from `N` to `P`, and another monoid homomorphism `f` from `M` to `N`, if `f` is surjective (i.e., for every element in `N`, there is an element in `M` such that applying `f` to this element gives the element in `N`), then the composition of `g₁` and `f` is equal to the composition of `g₂` and `f` if and only if `g₁` is equal to `g₂`. This theorem is a statement about the cancellation property of compositions of monoid homomorphisms when the second function is surjective.

Given monoid homomorphisms `f: M -> N`, `g₁, g₂: N -> P`, and `f` surjective, `g₁ ∘ f = g₂ ∘ f` if and only if `g₁ = g₂`.


theorem MeasureTheory.ae_eq_bot :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, MeasureTheory.Measure.ae μ = ⊥ ↔ μ = 0 :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` on `α`, and any measure `μ` on `α`, the "almost everywhere" filter of co-null sets of `μ` is equal to the bottom filter (denoted by `⊥`), if and only if the measure `μ` itself is zero. In other words, the measure `μ` is zero if and only if its "almost everywhere" filter, which consists of sets with complement of measure zero, is the trivial or bottom filter.

For any measure `μ` on a measurable space `(α, m0)`, the "almost everywhere" filter of co-null sets equals the bottom filter if and only if `μ` is the zero measure.


/-- **Tonelli's Theorem**: For `ℝ≥0∞`-valued almost everywhere measurable functions on `α × β`,
the integral of `f` is equal to the iterated integral.  -/
theorem MeasureTheory.lintegral_prod :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      (f : α × β → ENNReal),
      AEMeasurable f (MeasureTheory.Measure.prod μ ν) →
        ∫⁻ (z : α × β), f z ∂MeasureTheory.Measure.prod μ ν = ∫⁻ (x : α), ∫⁻ (y : β), f (x, y) ∂ν ∂μ :=
  by sorry

**Tonelli's Theorem**: For all non-negative extended real-valued functions `f` that are almost everywhere measurable on the product space `α × β`, the theorem asserts that the integral of `f` with respect to the product measure of measures `μ` and `ν` equals the iterated integral of `f` with respect to `ν` and `μ`. This holds under the assumption that the measure `ν` is sigma-finite. In other words, if `f` is an almost everywhere measurable function from `α × β` to non-negative extended reals (`[0, ∞]`), then the integral of `f` over the product space is equal to the iterated integral of `f` over the individual spaces.

For a non-negative, almost everywhere measurable function `f` on the product space `α × β` with sigma-finite measure `ν`, the integral of `f` with respect to the product measure of `μ` and `ν` equals the iterated integral with respect to `ν` and `μ`.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.7 :
    ∀ {A : Type u_4} {M₁ : Type u_5} [inst : SetLike A M₁] [inst_1 : One M₁] [hA : OneMemClass A M₁] {S' : A} {x : ↥S'},
      (↑x = 1) = (x = 1) :=
  by sorry

This theorem pertains to the field of Group Theory, specifically to submonoids. It states that for any type `A`, type `M₁`, where `A` acts like a set and `M₁` has a 'one' entity, and `A` is a class that contains the 'one' of `M₁`, if we have an element `x` of a subset `S'` of `A`, then the statement "the underlying element of `x` is equal to 'one'" is equivalent to the statement "`x` itself is equal to the 'one' of the subset `S'`". This theorem essentially says that the element `1` in the subset is the same as the element `1` in the original set when we consider the elements up to the subset structure.

For any set `A` with a 'one' element `1` and submonoid `M₁` containing `1`, the element `x` in `M₁` is equal to the 'one' of `M₁` if and only if the underlying element of `x` in `A` is equal to the 'one' of `A`.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.4 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid M} {y : N},
      (y ∈ AddSubmonoid.map f S) = ∃ x ∈ S, f x = y :=
  by sorry

This theorem states that for any types `M`, `N`, and `F`, where `M` and `N` are equipped with `AddZeroClass` structures (i.e., they are additive monoids with a zero element), `F` is a function type from `M` to `N` (`FunLike F M N`) and is also an additive monoid homomorphism (`AddMonoidHomClass F M N`), given any function `f` of type `F` and a submonoid `S` of `M`, and any element `y` of `N`, `y` is in the image of `S` under `f` (i.e., `y` is in `AddSubmonoid.map f S`) if and only if there exists an element `x` in `S` such that `f` applied to `x` equals `y` (written as `f x = y`). In mathematical terms, this theorem characterizes the image of an additive submonoid under an additive monoid homomorphism.

For any additive monoids M, N, and an additive monoid homomorphism F from M to N, an element y of N belongs to the image of an additive submonoid S of M under F if and only if there exists an element x in S such that F(x) = y.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.3 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N},
      (y ∈ Submonoid.map f S) = ∃ x ∈ S, f x = y :=
  by sorry

This theorem states that for any given types `M`, `N` and `F`, where `M` and `N` are equipped with the structure of `MulOneClass` (which essentially means they have multiplicative identities and multiplication operations), `F` is "function-like" from `M` to `N`, and `F` has the structure of a `MonoidHomClass` (which makes `F` a monoid homomorphism from `M` to `N`). Given a function `f` of type `F` and a submonoid `S` of `M`, for any element `y` of `N`, `y` is in the image of `S` under `f` if and only if there exists an element `x` in `S` such that `f(x)` equals `y`. In mathematical terms, it asserts that $y \in f(S)$ if and only if there exists $x \in S$ such that $f(x) = y$.

For any monoid homomorphism `F` from a multiplicative monoid `M` to a multiplicative monoid `N` and any submonoid `S` of `M`, the image of `S` under `F` equals the set of elements in `N` that have preimages in `S`.


theorem IsAdjoinRoot.map_X :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f), h.map Polynomial.X = IsAdjoinRoot.root h :=
  by sorry

The theorem `IsAdjoinRoot.map_X` states that for any commutative ring `R`, ring `S`, polynomial `f` of `R`, and algebra structure between `R` and `S`, if `h` is a proof that the root of `f` can be adjoined to generate `S`, then the result of mapping the indeterminate `X` from the polynomial via `h` is equal to the root of `f` that can be adjoined to generate `S`. In other words, this theorem asserts that the image of the polynomial indeterminate under the map `h` is indeed the root of the polynomial in the adjunctive structure.

Given a commutative ring R, ring S, polynomial f over R, and an algebra structure map h : R ℝ S such that the root of f can be adjoined to generate S, the image of the indeterminate X of f under h is equal to the root of f in the adjunctive structure.


theorem Filter.blimsup_and_le_inf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {p q : β → Prop} {u : β → α},
      (Filter.blimsup u f fun x => p x ∧ q x) ≤ Filter.blimsup u f p ⊓ Filter.blimsup u f q :=
  by sorry

The theorem `Filter.blimsup_and_le_inf` states that for any complete lattice `α`, filter `f` on type `β`, predicates `p` and `q` on `β`, and a function `u` mapping `β` to `α`, the bounded limit superior (blimsup) of `u` along `f`, bounded by the conjunction of predicates `p` and `q`, is less than or equal to the infimum of the blimsup of `u` along `f` bounded by `p` and the blimsup of `u` along `f` bounded by `q`. In other words, this theorem shows that the blimsup along a filter, when bounded by the conjunction of two predicates, is controlled by the individual blimsups for each of the predicates.

For any complete lattice `α`, filter `f` on type `β`, predicates `p` and `q` on `β`, and a function `u` mapping `β` to `α`, the blimsup of `u` along `f`, bounded by the conjunction of `p` and `q`, is less than or equal to the infimum of the blimsups of `u` along `f` bounded by `p` and the blimsup of `u` along `f` bounded by `q`.