theorem Mathlib.LinearAlgebra.Basic._auxLemma.1 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] {f : F} {x : M₂}, (x ∈ LinearMap.range f) = ∃ y, f y = x :=
  by sorry

The theorem `Mathlib.LinearAlgebra.Basic._auxLemma.1` states that for all types `R`, `R₂`, `M`, and `M₂` such that `R` and `R₂` are semirings, `M` and `M₂` are additively commutative monoids, and `M` and `M₂` are modules over `R` and `R₂` respectively; for any type `F` which has a function-like relationship between `M` and `M₂`, and any semilinear map from `R` to `R₂` denoted by `τ₁₂` that has a surjective ring homomorphism, and any function `f` of type `F` and any `x` from `M₂`, the theorem asserts that `x` is in the range of the linear map `f` if and only if there exists a `y` such that `f(y) = x`.

Given semirings R and R₂, additively commutative monoids and R-modules M and M₂, a semilinear map τ₁₂ from R to R₂ that is a surjective ring homomorphism, and a function F from M₂ to M with the property that for all x in M₂, there exists y such that f(y) = x if and only if x is in the image of f under τ₁₂, then for all x in M₂, x is in the range of f if and only if there exists a y in M such that f(y) = x.


/-- `R` is integrally closed iff all integral elements of its fraction field `K`
are also elements of `R`.  -/
theorem isIntegrallyClosed_iff :
    ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : CommRing K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K], IsIntegrallyClosed R ↔ ∀ {x : K}, IsIntegral R x → ∃ y, (algebraMap R K) y = x :=
  by sorry

The theorem states that an integral domain `R` is integrally closed if and only if every integral element of the fraction field `K` of `R` is also an element of `R`. In other words, for every `x` in `K` that is integral over `R`, there exists a `y` in `R` such that the image of `y` under the algebraic embedding from `R` to `K` is `x`. Here, being "integral" means that the element is a root of some monic polynomial with coefficients in `R`, and being "integrally closed" means that every element of `K` that is integral over `R` actually lies in `R`.

An integral domain is integrally closed if and only if every element in its fraction field that is integral over it lies in the domain itself.


theorem isGreatest_singleton : ∀ {α : Type u} [inst : Preorder α] {a : α}, IsGreatest {a} a := by sorry

This theorem states that for any preorder set `α` and any element `a` from that set, `a` is the greatest element of the singleton set `{a}`. In other words, in the context of a partial order, `a` is the unique greatest element of its own singleton set. This makes sense because a singleton set contains only one element, so that element is trivially the greatest (and least) element within that set.

For any preorder set `α` and its element `a`, `a` is the greatest element of the singleton set `{a}`. In a partial order context, `a` is the unique greatest element of its own singleton set.


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

This theorem states that for all integers `a` and `b`, the product of the negations of `a` and `b` (i.e., `-a * -b`) is equal to the product of `a` and `b` (i.e., `a * b`). This is a formal expression of the mathematical rule that the product of two negative numbers is a positive number.

For all integers a and b, the product of the negations of a and b equals the product of a and b. That is, -a * -b = a * b.


theorem Multiset.prod_hom :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] (s : Multiset α) {F : Type u_5}
      [inst_2 : FunLike F α β] [inst_3 : MonoidHomClass F α β] (f : F),
      Multiset.prod (Multiset.map (⇑f) s) = f (Multiset.prod s) :=
  by sorry

This theorem, `Multiset.prod_hom`, states that for any types `α` and `β` with commutative monoid structures, a multiset `s` of type `α`, a function type `F` such that it behaves like a function from `α` to `β` (indicated by `FunLike F α β`), and a function `f` of type `F` which is also a monoid homomorphism (indicated by `MonoidHomClass F α β`), the product of the multiset obtained by mapping `f` over `s` is equal to the result of applying `f` to the product of `s`. In other words, the function `f` preserves the product operation while being applied to each element of the multiset or to the entire product of the multiset, demonstrating its homomorphic property.

For any commutative monoids `α` and `β`, given a multiset `s` of type `α`, a function `F` that behaves like a function from `α` to `β` and is a monoid homomorphism `F: MonoidHomClass α β`, the product of `s` mapped under `F` equals the product of `F` applied to the product of `s`.


theorem dimH_mono : ∀ {X : Type u_2} [inst : EMetricSpace X] {s t : Set X}, s ⊆ t → dimH s ≤ dimH t := by sorry

The theorem `dimH_mono` states that for any type `X` that has an `EMetricSpace` instance, for any two sets `s` and `t` of type `X`, if `s` is a subset of `t` then the Hausdorff dimension of `s` is less than or equal to the Hausdorff dimension of `t`. In mathematical terms, if $s \subseteq t$, then $\text{dimH}(s) \leq \text{dimH}(t)$. This theorem is a statement about the monotonicity of the Hausdorff dimension in an extended metric space.

For any extended metric space (X), if s is a subset of t, then the Hausdorff dimension of s is less than or equal to the Hausdorff dimension of t. (i.e., dimH(s) ≤ dimH(t)).


theorem Matrix.charpoly_natDegree_eq_dim :
    ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
      [inst_3 : Nontrivial R] (M : Matrix n n R), Polynomial.natDegree (Matrix.charpoly M) = Fintype.card n :=
  by sorry

The theorem `Matrix.charpoly_natDegree_eq_dim` states that for any commutative ring `R` and any finite type `n` that has decidable equality, given a nontrivial matrix `M` with entries in `R` and both its rows and columns indexed by `n`, the natural degree of the characteristic polynomial of `M` is equal to the number of elements in `n`. This can be understood as the degree of the characteristic polynomial of a matrix being equal to the dimension of the matrix in the field of the matrix entries.

For any commutative ring with decidable equality `R` and a finite type `n`, the natural degree of the characteristic polynomial of a nontrivial `n x n` matrix over `R` equals the number of elements in `n`.


theorem Decidable.lt_or_eq_of_le :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : DecidableRel fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b → a < b ∨ a = b :=
  by sorry

This theorem, "Decidable.lt_or_eq_of_le", states that for any type `α` that has a partial order and a decidable relation on the less than or equal to (`≤`) operation, given two elements `a` and `b` from `α`, if `a` is less than or equal to `b`, then `a` is either strictly less than `b` or `a` is equal to `b`. Thus, it provides a mechanism to decide between the two possible outcomes of the less than or equal to (`≤`) comparison.

For any type `α` with a decidable partial order `≤`, if `a ≤ b` then `a = b` or `a < b`.


theorem Mathlib.SetTheory.Cardinal.Basic._auxLemma.78 :
    ∀ {α : Type u}, (Cardinal.aleph0 ≤ Cardinal.mk α) = Infinite α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is greater than or equal to `ℵ₀` (the smallest infinite cardinal, which is the cardinality of the set of natural numbers) if and only if `α` is an infinite set. In other words, if a set has cardinality at least as large as the set of natural numbers, then it is an infinite set.

A set `α` has cardinality greater than or equal to that of the natural numbers if and only if `α` is infinite.


theorem MeasureTheory.lintegral_add_left' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      AEMeasurable f μ → ∀ (g : α → ENNReal), ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_add_left'` states that for any measure space `α` with a measure `μ` and two functions `f` and `g` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` is almost everywhere measurable with respect to `μ`, then the integral of the function `(a : α), f a + g a` with respect to `μ` is equal to the sum of the integrals of the functions `(a : α), f a` and `(a : α), g a` with respect to `μ`. In other words, we can split the integral of a sum of two functions into the sum of their separate integrals, when one of the functions is almost everywhere measurable.

If `μ` is a measure on `α` and `f, g : α → ENNReal` are almost everywhere equal almost everywhere measurable functions, then `∫(a : α, f a + g a) dμ = ∫(a : α, f a) dμ + ∫(a : α, g a) dμ`.


theorem ContinuousLinearMap.integral_comp_comm :
    ∀ {X : Type u_1} {E : Type u_3} {F : Type u_4} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X}
      {𝕜 : Type u_5} [inst_1 : RCLike 𝕜] [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E]
      [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F] [inst_6 : NormedSpace ℝ F] [inst_7 : CompleteSpace F]
      [inst_8 : NormedSpace ℝ E] [inst_9 : CompleteSpace E] (L : E →L[𝕜] F) {φ : X → E},
      MeasureTheory.Integrable φ μ → ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ) :=
  by sorry

The theorem `ContinuousLinearMap.integral_comp_comm` states that for any measurable space `X`, normed addcomm groups `E` and `F`, a measure `μ` on `X`, a RCLike `𝕜`, normed spaces over `𝕜` for `E` and `F`, normed spaces over ℝ for `E` and `F` (which are complete spaces), and a continuous linear map `L` from `E` to `F`, if a function `φ` from `X` to `E` is integrable with respect to `μ`, then the integral over `X` of the function obtained by applying `L` to `φ(x)` is equal to the result of applying `L` to the integral over `X` of `φ(x)`.

In mathematical notation, this theorem states that if `φ : X → E` is integrable, then `∫ (L ∘ φ) dμ = L (∫ φ dμ)`.

The theorem asserts that for a measurable space `(X, μ)`, normed addcomm groups `E` and `F` over a RCLike `𝕜`, a continuous linear map `L : E → F`, and an integrable function `φ : X → E`, the integral of their composition `(L ∘ φ)` equals `L` applied to the integral of `φ`, i.e., `∫ (L ∘ φ) dμ = L (∫ φ dμ)`.


theorem TensorAlgebra.lift_ι_apply :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {A : Type u_3} [inst_3 : Semiring A] [inst_4 : Algebra R A] (f : M →ₗ[R] A) (x : M),
      ((TensorAlgebra.lift R) f) ((TensorAlgebra.ι R) x) = f x :=
  by sorry

The theorem `TensorAlgebra.lift_ι_apply` states that for any commutative semiring `R`, additive commutative monoid `M`, and `M` is a module over `R`, and for any semiring `A` with `A` being an algebra over `R`, and a linear map `f` from `M` to `A`, the composition of the lift of `f` to the tensor algebra of `M` over `R` and the canonical linear map from `M` to that tensor algebra, when applied to any element `x` of `M`, is equal to the application of `f` to `x`. In simpler terms, this theorem confirms that the lifting operation on the tensor algebra correctly interprets the linear map when it is applied to elements of the module `M`.

For any commutative semiring `R`, additive commutative monoid `M` being an `R`-module, semiring `A` an `R`-algebra, and linear map `f` from `M` to `A`, the composition of `f`'s lift to the tensor algebra of `M` over `R` and the canonical map from `M` to the tensor algebra equals `f` itself when applied to any `x` in `M`.


theorem Multiset.rel_flip :
    ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset β} {t : Multiset α},
      Multiset.Rel (flip r) s t ↔ Multiset.Rel r t s :=
  by sorry

This theorem is about the relation between multisets and a flipped relation. For any types `α` and `β` and any relation `r` from `α` to `β`, and any multiset `s` of type `β` and `t` of type `α`, the multiset relation of the flipped relation `r` and the multisets `s` and `t` is equivalent to the multiset relation of `r` and the multisets `t` and `s`. In other words, flipping the inputs of the relation `r` does not change the way it relates the multisets `s` and `t` in the context of `Multiset.Rel`.

For any relations $r$ from type $\alpha$ to type $\beta$, multisets $s$ of type $\beta$, and $t$ of type $\alpha$, the multiset relations $s \multimap r \multimap t$ and $t \multimap r \multimap s$ are equal in the context of multisets.


theorem Mathlib.CategoryTheory.Equivalence._auxLemma.1 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f]
      {g h : Z ⟶ X}, (CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) :=
  by sorry

This theorem states that in any category `C`, for any objects `X`, `Y`, `Z` of `C` and any morphism `f` from `X` to `Y` that is a monomorphism, if we have two morphisms `g` and `h` from `Z` to `X`, then the composition of `g` with `f` is equal to the composition of `h` with `f` if and only if `g` is equal to `h`. In other words, monomorphisms in a category are left-cancellative with respect to composition.

In any category, if `f` is a monomorphism from object `X` to object `Y`, and `g` and `h` are morphisms from object `Z` to `X`, then `g ∘ f = h ∘ f` implies `g = h`.


BotHom.ext

theorem BotHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Bot α] [inst_1 : Bot β] {f g : BotHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two types, `α` and `β`, both equipped with a bottom element (`Bot`), if two morphisms `f` and `g` from `α` to `β` (i.e., two `BotHom` from `α` to `β`) map every element of `α` to the same element in `β`, then `f` and `g` are essentially the same morphism. In other words, two `BotHom` are equal if they are point-wise equal.

Given types `α` and `β` with bottom elements `Botα` and `Botβ`, respectively, and morphisms `f : α → β` and `g : α → β` such that `f (Botα) = g (Botα)`, then `f = g`.


/-- The second projection at a point in a product is `C^∞`.  -/
theorem contDiffAt_snd :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {p : E × F}, ContDiffAt 𝕜 n Prod.snd p :=
  by sorry

This theorem states that for any point `p` in the Cartesian product of two normed vector spaces `E` and `F` over a nontrivially normed field `𝕜`, the function that projects onto the second component (from the pair `p` to the second element of the pair) is `C^∞`, or infinitely continuously differentiable. In other words, the second projection function is smooth at any point in the Cartesian product of these two spaces.

The second projection function on the Cartesian product of two normed vector spaces over a nontrivially normed field is infinitely differentiable.


theorem CategoryTheory.ShortComplex.RightHomologyMapData.quasiIso_iff :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂] {φ : S₁ ⟶ S₂}
      {h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁} {h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.QuasiIso φ ↔ CategoryTheory.IsIso γ.φH :=
  by sorry

This theorem states that for any two short complexes `S₁` and `S₂` in a category `C`, which has zero morphisms, and given certain homological data `h₁` and `h₂` for these complexes, a specific morphism `φ` from `S₁` to `S₂` is a quasi-isomorphism if and only if a certain morphism `γ.φH` associated with the mapping data `γ` (which is based on `φ`, `h₁`, and `h₂`) is an isomorphism. This theorem thus establishes a connection between the concepts of quasi-isomorphisms of short complexes and isomorphisms of their associated homological mapping data.

A morphism between two short complexes in a zero-morphism category is a quasi-isomorphism if and only if the associated homological morphism induced by mapping data is an isomorphism.


ProbabilityTheory.kernel.IndepFun.symm

theorem ProbabilityTheory.kernel.IndepFun.symm :
    ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
      {x : MeasurableSpace β} {x_1 : MeasurableSpace β'},
      ProbabilityTheory.kernel.IndepFun f g κ μ → ProbabilityTheory.kernel.IndepFun g f κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepFun.symm` states that for any given types `α`, `Ω`, `β`, and `β'`, measurable spaces over `α` and `Ω`, a probability kernel `κ` from `α` to `Ω`, a measure `μ` over `α`, and functions `f` and `g` from `Ω` to `β` and `β'` respectively, if the functions `f` and `g` are independent with respect to `κ` and `μ`, then `g` and `f` are also independent with respect to `κ` and `μ`. This means the property of being independent functions under a probability kernel and a measure is symmetric.

If functions `f` and `g` are independent with respect to measure `μ` and probability kernel `κ` from type `α` to `Ω`, then `g` and `f` are also independent with respect to `μ` and `κ`.


theorem SetLike.coe_mem : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} (x : ↥p), ↑x ∈ p := by sorry

This theorem states that for any types `A` and `B`, and a set-like structure `i` on `A` and `B`, given a set `p` of type `A` and an element `x` of type `↥p` (which means `x` is an element of `p`), the coercion of `x` back into type `B` (denoted by `↑x`) is an element of `p`. Essentially, it says that if `x` is an element of `p`, then `x` remains an element of `p` even after it is converted to `B`.

For any set-like structures `i` on types `A` and `B`, and a set `p` of type `A`, the coercion of an element `x` of type `A` belonging to `p` back into type `B` (denoted by `↑x`) also belongs to `p`.


theorem infClosed_infClosure : ∀ {α : Type u_2} [inst : SemilatticeInf α] {s : Set α}, InfClosed (infClosure s) := by
  sorry

The theorem `infClosed_infClosure` states that for any type `α` that forms a semilattice with respect to an "infimum" operation (denoted as `⊓`), and for any set `s` of elements of type `α`, the closure of `s` under the infimum operation is an inf-closed set. Here, a set is said to be inf-closed if for every pair of elements in the set, their infimum is also in the set. Furthermore, the "infimum closure" of a set `s` is the set of all elements that can be expressed as the infimum of some non-empty subset of `s`.

For any semilattice type `α` with infimum operation `⊓` and any inf-closed set `s` of elements in `α`, the infimum closure of `s` is equal to the set of all elements that are the infimum of some non-empty subset of `s`.


theorem NonUnitalSubsemiring.gc_map_comap :
    ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
      {F : Type u_1} [inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] (f : F),
      GaloisConnection (NonUnitalSubsemiring.map f) (NonUnitalSubsemiring.comap f) :=
  by sorry

This theorem, `NonUnitalSubsemiring.gc_map_comap`, states that for any non-unital non-associative semirings `R` and `S`, and for any function `f` of type `F` that is a non-unital ring homomorphism from `R` to `S` and also satisfies the `FunLike` property (meaning it can be injectively coerced to a function from `R` to `S`), there exists a Galois connection between the function `NonUnitalSubsemiring.map f` and the function `NonUnitalSubsemiring.comap f`. In other words, for any elements `a` from the codomain and `b` from the domain, `NonUnitalSubsemiring.map f a ≤ b` if and only if `a ≤ NonUnitalSubsemiring.comap f b`. Here, `NonUnitalSubsemiring.map f` is a function that applies `f` to each element of a subsemiring of `R` and `NonUnitalSubsemiring.comap f` is a function that returns the preimage of a subsemiring of `S` under `f`.

For any non-unital non-associative semirings R and S, and for any non-unital ring homomorphism f from R to S satisfying the FunLike property, there exists a Galois connection between the maps sending a subsemiring of R to its image under f and a subsemiring of S to its preimage under f.


theorem Fintype.card_of_subtype :
    ∀ {α : Type u_1} {p : α → Prop} (s : Finset α),
      (∀ (x : α), x ∈ s ↔ p x) → ∀ [inst : Fintype { x // p x }], Fintype.card { x // p x } = s.card :=
  by sorry

The theorem `Fintype.card_of_subtype` states that for any type `α` and any property `p` of `α`, given a finite set `s` of elements of `α`, if for every element `x` of `α`, `x` is in `s` if and only if `x` satisfies `p`, then, provided `{ x // p x }` is a finite type, the cardinality of `{ x // p x }` (i.e. the number of elements that satisfy `p`) is equal to the cardinality of the set `s`. In other words, this theorem relates the size of a subset defined by a property to the size of a finite set satisfying the same property.

If `s` is a finite set of elements in type `α` such that `x ∈ s` if and only if `p(x)` holds, then the number of elements in `{x : α | p(x)}` equals the cardinality of `s`.


theorem ENNReal.toReal_eq_zero_iff : ∀ (x : ENNReal), x.toReal = 0 ↔ x = 0 ∨ x = ⊤ := by sorry

This theorem states that for any extended nonnegative real number `x`, the real number equivalent of `x` is zero if and only if `x` itself is zero or `x` is infinity. In other words, it says that an extended nonnegative real number is mapped to zero in the real number system if and only if it is either zero or infinity in the extended nonnegative real number system.

An extended nonnegative real number maps to zero in the real number system if and only if it is zero or infinity in the extended nonnegative real number system.


theorem IsMinFilter.filter_mono :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α},
      IsMinFilter f l a → l' ≤ l → IsMinFilter f l' a :=
  by sorry

The theorem `IsMinFilter.filter_mono` states that for any types `α` and `β` with a pre-order relation on `β`, a function `f` from `α` to `β`, filters `l` and `l'` on `α`, and an element `a` of type `α`, if `a` is a minimum of the function `f` over the set defined by the filter `l` (that is, for every element `x` in some neighborhood of `a` defined by `l`, the value of `f` at `a` is less than or equal to the value of `f` at `x`), and if the filter `l'` is a subset of `l`, then `a` is also a minimum of the function `f` over the set defined by the filter `l'`.

If `a` is a minimum of a function `f` over the filter `l` and `l'` is a subset of `l`, then `a` is also a minimum of `f` over the filter `l'`.


/-- $\lim_{x\to+\infty}|x|=+\infty$  -/
theorem Filter.tendsto_abs_atTop_atTop :
    ∀ {α : Type u_3} [inst : LinearOrderedAddCommGroup α], Filter.Tendsto abs Filter.atTop Filter.atTop := by sorry

The theorem `Filter.tendsto_abs_atTop_atTop` states that for any type `α` which is a linearly ordered additive commutative group, the absolute value function `abs` has a limit of positive infinity as its argument approaches positive infinity. In other words, as we take larger and larger values of `x` (approaching positive infinity), the absolute value of `x` (denoted as `|x|`) also approaches positive infinity. Using the $\lim_{x\to+\infty}$ notation, this can be written as $\lim_{x\to+\infty}|x|=+\infty$.

For any linearly ordered additive commutative group type `α`, the absolute value function `abs` on `α` is unbounded above and approaches positive infinity as the argument approaches positive infinity.


/-- If `f : X → Y` is an `Embedding`, the image `f '' s` of a set `s` is compact
if and only if `s` is compact.  -/
theorem Embedding.isCompact_iff :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      Embedding f → (IsCompact s ↔ IsCompact (f '' s)) :=
  by sorry

The theorem `Embedding.isCompact_iff` states that for any two types `X` and `Y` with respective topological space instances, a set `s` of type `X`, and a function `f` from `X` to `Y`, if `f` is an embedding then the image of the set `s` under the function `f`, denoted `f '' s`, is compact if and only if `s` itself is compact. In other words, an embedding preserves the compactness of sets.

An embedding of a compact topological space preserves the compactness of sets: if a function between two topological spaces is an embedding and its domain is a compact set, then the image of that set under the function is also compact.


theorem QuotientGroup.out_eq' :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} (a : α ⧸ s), ↑(Quotient.out' a) = a := by sorry

The theorem `QuotientGroup.out_eq'` states that for any type `α` with a group structure (indicated by `inst : Group α`), and any subgroup `s` of `α`, and any element `a` of the quotient group `α ⧸ s`, applying the function `Quotient.out'` to `a` and then applying the embedding of `α` into the quotient group `α ⧸ s` (indicated by `↑`) gives back the original element `a`. In other words, the `Quotient.out'` function is a right inverse to the quotient map for quotient groups.

For any group `α` and subgroup `s`, the `Quotient.out'` function on the quotient group `α ⧸ s` is a right inverse to the quotient map, i.e., `Quotient.out' (↑a) = a` for all `a` in `α ⧸ s`.


theorem Polynomial.degree_X_sub_C :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] (a : R),
      Polynomial.degree (Polynomial.X - Polynomial.C a) = 1 :=
  by sorry

The theorem `Polynomial.degree_X_sub_C` states that for any ring `R` that is nontrivial, and for any element `a` in `R`, the degree of the polynomial `(Polynomial.X - Polynomial.C a)` is 1. Here, `Polynomial.X` represents the polynomial variable and `Polynomial.C a` is the constant polynomial `a`. This means that the highest power of the polynomial variable that appears in the polynomial resulting from subtracting the constant polynomial `a` from the polynomial variable is 1.

For any nontrivial ring R and element a in R, the degree of the polynomial (X - C a) is 1.


theorem Nat.mod_modEq : ∀ (a n : ℕ), a % n ≡ a [MOD n] := by sorry

This theorem, named `Nat.mod_modEq`, states that for any two natural numbers `a` and `n`, the remainder of `a` divided by `n` (denoted as `a % n`) is congruent to `a` modulo `n` (denoted as `a [MOD n]`). In other words, when `a` is divided by `n`, the remainder is the same whether we consider it in terms of computer science '%' operator or in terms of mathematical modulo operation.

For all natural numbers `a` and `n`, `a % n` equals `a mod n`.


theorem normalize_apply :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (x : α),
      normalize x = x * ↑(normUnit x) :=
  by sorry

This theorem states that for any type 'α' which has the properties of a 'CancelCommMonoidWithZero' and a 'NormalizationMonoid', the operation of 'normalize' applied to an element 'x' of type 'α' is equivalent to multiplying 'x' by the unit norm of 'x'. Here, 'normalize' is a function that chooses an element of each associate class in 'α' by multiplying by the 'normUnit'. The 'normUnit' is the unit element associated with 'x' in the normalization monoid.

For any cancel commutative monoid with additive identity 'α' having a normalization monoid structure, normalizing an element 'x' equals multiplying 'x' by its norm unit.


/-- In an ordered additive commutative monoid, if each summand `f i` of one finite sum is less than
or equal to the corresponding summand `g i` of another finite sum, then `s.sum f ≤ s.sum g`.

This is a variant (beta-reduced) version of the standard lemma `Finset.sum_le_sum`, convenient
for the `gcongr` tactic.  -/
theorem GCongr.sum_le_sum :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f g : ι → N} {s : Finset ι},
      (∀ i ∈ s, f i ≤ g i) → Finset.sum s f ≤ Finset.sum s g :=
  by sorry

This theorem states that, within an ordered additive commutative monoid (a structure with addition as a commutative operation and an order relation compatible with the addition), if for each element `i` in a finite set `s`, the value of function `f` at `i` is less than or equal to the value of function `g` at `i`, then the sum of values of `f` over `s` is less than or equal to the sum of values of `g` over `s`. In other words, if each term of one sum is not greater than the corresponding term of another sum, then the total of the first sum is not greater than the total of the second sum. This is a useful theorem when working with inequalities involving sums in an ordered additively commutative structure.

If `f` and `g` are functions on a finite set `s` in an ordered additive commutative monoid such that `f i ≤ gi` for all `i ∈ s`, then `∑ i in s f i ≤ ∑ i in s gi`.


theorem List.foldr_append :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β → β) (b : β) (l l' : List α),
      List.foldr f b (l ++ l') = List.foldr f (List.foldr f b l') l :=
  by sorry

The theorem `List.foldr_append` states that for any types `α` and `β`, any function `f` of type `α → β → β`, any value `b` of type `β`, and any two lists `l` and `l'` of type `List α`, the result of applying `List.foldr` with function `f` and initial value `b` to the append of `l` and `l'` (`l ++ l'`) is equal to the result of applying `List.foldr` with function `f` to list `l` with the initial value being the result of applying `List.foldr` with function `f` and initial value `b` to list `l'`. In other words, it is expressing the property of distributivity of the `foldr` function over list concatenation.

For any types `α` and `β`, functions `f : α → β → β`, initial value `b : β`, and lists `l, l' : List α`, `List.foldr (λ x xs => f x xs) b (l ++ l')` is equal to `List.foldr (λ x xs => f x (List.foldr (λ y ys => f y ys) b xs)) b l`.


theorem Nat.range_cast_int : Set.range Nat.cast = Set.Ici 0 := by sorry

This theorem states that the range of the natural number casting function to integers is equivalent to the set of all integers that are greater than or equal to 0. In other words, when every natural number is cast to an integer, the resulting set of integers is the same as the set of all integers greater than or equal to 0. This is symbolically represented as: $range(Nat.cast) = [0, \infty)$.

The range of the natural number to integer casting function equals the set of integers greater than or equal to zero.


theorem Convex.is_linear_preimage :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] {s : Set F},
      Convex 𝕜 s → ∀ {f : E → F}, IsLinearMap 𝕜 f → Convex 𝕜 (f ⁻¹' s) :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any two types `E` and `F` that are additive commutative monoids and also `𝕜`-modules, if a set `s` of type `F` is convex, then the preimage of `s` under any linear map `f` from `E` to `F` is also convex.

Given an ordered semiring `𝕜`, if `E` and `F` are additive commutative `𝕜`-modules and `s ⊆ F` is a convex set, then the preimage `f⁻¹(s) ⊆ E` under any linear map `f : E → F` is also convex.


theorem LipschitzWith.of_edist_le :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      (∀ (x y : α), edist (f x) (f y) ≤ edist x y) → LipschitzWith 1 f :=
  by sorry

The theorem `LipschitzWith.of_edist_le` states that for any two types `α` and `β`, where both `α` and `β` are pseudo emetric spaces, and for any function `f` from `α` to `β`, if for all `x` and `y` in `α` the extended distance (`edist`) between `f(x)` and `f(y)` is less than or equal to the extended distance between `x` and `y`, then the function `f` is Lipschitz continuous with a Lipschitz constant of `1`. That is, the theorem states that if `edist (f x) (f y) ≤ edist x y` for all `x` and `y` in `α`, then the distance between any two images under `f` is at most the distance between their pre-images.

If `f: α → β` is a function between pseudo metric spaces `α` and `β` such that `edist (f x) (f y) ≤ edist x y` for all `x, y ∈ α`, then `f` is Lipschitz continuous with Lipschitz constant 1.


theorem Inducing.tendsto_nhds_iff :
    ∀ {Y : Type u_2} {Z : Type u_3} {ι : Type u_4} {g : Y → Z} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z]
      {f : ι → Y} {l : Filter ι} {y : Y},
      Inducing g → (Filter.Tendsto f l (nhds y) ↔ Filter.Tendsto (g ∘ f) l (nhds (g y))) :=
  by sorry

The theorem `Inducing.tendsto_nhds_iff` states that for any types `Y`, `Z`, `ι`, a function `g` from `Y` to `Z`, a topological space over `Y` and `Z`, a function `f` from `ι` to `Y`, a filter `l` over `ι`, and an element `y` of `Y`, if `g` is an inducing function (i.e., the topology on `Y` is the initial topology with respect to `g`), then the function `f` tends to the neighborhood filter of `y` (in the sense of the Filter.Tendsto predicate) if and only if the composition of `g` and `f` tends to the neighborhood filter of `g(y)`. In simpler terms, the function `f` approaches `y` as its inputs approach the elements of the filter `l` if and only if `g(f)` approaches `g(y)` in the same manner.

For a function `g` inducing the topology on `Y` from `Z`, `f` tends to the neighborhood filter of `y` in `Y` if and only if `g ∘ f` tends to the neighborhood filter of `g(y)` in `Z`.


theorem Mathlib.Data.Int.Parity._auxLemma.19 : Even 1 = False := by sorry

This theorem, `Mathlib.Data.Int.Parity._auxLemma.19`, states that the integer 1 is not even. In the context of this theorem, a number is defined as even if it can be expressed as the sum of two identical numbers. However, there is no integer that, when doubled, equals 1, hence 1 is not considered even under this definition.

The theorem `Mathlib.Data.Int.Parity._auxLemma.19` in Lean 4 asserts that the integer 1 is odd, since it cannot be expressed as the sum of two identical integers.


theorem eq_bot_of_singletons_open : ∀ {α : Type u_1} {t : TopologicalSpace α}, (∀ (x : α), IsOpen {x}) → t = ⊥ := by
  sorry

This theorem, "eq_bot_of_singletons_open", states that for any type `α` and for any topological space `t` defined on `α`, if every singleton set `{x}` where `x` is an element of `α`, is an open set in the topological space, then the topology `t` is equivalent to the trivial (or indiscrete) topology, denoted by `⊥`. The trivial topology is one where the only open sets are the empty set and the whole set. Hence, this result says that if singletons are open, the topology is as coarse as possible.

If every singleton set is open in a topology, then the topology is equal to the trivial topology.


theorem Cardinal.aleph0_pos : 0 < Cardinal.aleph0 := by sorry

This theorem states that Aleph-zero (ℵ₀), which is known as the smallest infinite cardinal number or the cardinality of the set of natural numbers, is greater than zero. In the context of set theory, it establishes that the size of the set of natural numbers is not empty, but rather infinitely countable, and hence larger than zero.

The theorem asserts that ℵ₀, the cardinality of the set of natural numbers, is strictly greater than 0.


theorem Nat.coprime_zero_left : ∀ (n : ℕ), Nat.Coprime 0 n ↔ n = 1 := by sorry

This theorem states that for any natural number `n`, `n` is coprime to 0 if and only if `n` is equal to 1. In other words, a natural number `n` and 0 are said to be relatively prime (i.e., their greatest common divisor (gcd) is 1) if `n` itself is equal to 1.

A natural number `n` is coprime to 0 if and only if `n` equals 1.


theorem EMetric.mem_closedBall :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, y ∈ EMetric.closedBall x ε ↔ edist y x ≤ ε :=
  by sorry

This theorem states that for any type `α` equipped with a pseudo extended metric space structure, and for any elements `x`, `y` of type `α` and `ε` of type `ENNReal` (the extended nonnegative real numbers), `y` belongs to the closed ball centered at `x` with radius `ε` (as defined in pseudo extended metric space) if and only if the extended distance from `y` to `x` is less than or equal to `ε`. This essentially defines the property of the closed ball in the pseudo extended metric space context.

For any pseudo extended metric space `(α, d)`, and for all `x : α`, `y : α`, and `ε : ENNReal`, `y` is in the closed ball `{z : α | d(x, z) ≤ ε}` if and only if `d(x, y) ≤ ε`.


FirstOrder.Language.Substructure.ext

/-- Two substructures are equal if they have the same elements.  -/
theorem FirstOrder.Language.Substructure.ext :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      {S T : FirstOrder.Language.Substructure L M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any given first-order language `L` and any type `M` that is a structure for `L`, two substructures `S` and `T` of `L` over `M` are equal if they contain the same elements. In other words, if every element `x` of type `M` is in `S` if and only if it is in `T`, then `S` and `T` are the same substructure.

If two substructures of a first-order structure over a base type have the same elements, then they are equal.


theorem ContinuousLinearMap.map_smul :
    ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_4} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
      {M₂ : Type u_6} [inst_3 : TopologicalSpace M₂] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₁ M₁]
      [inst_6 : Module R₁ M₂] (f : M₁ →L[R₁] M₂) (c : R₁) (x : M₁), f (c • x) = c • f x :=
  by sorry

This theorem states that for any continuous linear map `f` from a module `M₁` to another module `M₂` over the same semiring `R₁`, and for any element `c` from `R₁` and `x` from `M₁`, the map of the scaled element `c • x` under `f` is equal to the scaled map of `x` under `f`, i.e., `f (c • x) = c • f x`. This is essentially an expression of the homogeneity property of linear maps in the context of topological vector spaces.

For any continuous linear map $f$ between modules $M\_1$ and $M\_2$ over the same semiring $R$, and for all $c \in R$ and $x \in M\_1$, we have $f(c \cdot x) = c \cdot f(x)$.


UniformSpace.Completion.ext'

theorem UniformSpace.Completion.ext' :
    ∀ {α : Type u_1} [inst : UniformSpace α] {Y : Type u_4} [inst_1 : TopologicalSpace Y] [inst_2 : T2Space Y]
      {f g : UniformSpace.Completion α → Y},
      Continuous f → Continuous g → (∀ (a : α), f (↑α a) = g (↑α a)) → ∀ (a : UniformSpace.Completion α), f a = g a :=
  by sorry

This theorem states that for any type `α` that is a uniform space and any type `Y` that is a topological space and a T2 space, if `f` and `g` are two functions from the Hausdorff (T2) completion of `α` to `Y` and both are continuous, then if `f` and `g` agree on the elements of `α` (i.e. `f` applied to any element of `α` is the same as `g` applied to the same element), they agree on all elements of the Hausdorff completion of `α`. That is, for any element `a` of the Hausdorff completion of `α`, the value of `f` at `a` is equal to the value of `g` at `a`. This is a universal property of the completion of a uniform space.

Given a uniform space `α`, a T2 topological space `Y`, and continuous functions `f` and `g` from the Hausdorff completion of `α` to `Y` that agree on `α`, they agree on all elements of the Hausdorff completion of `α`.


HasDerivWithinAt.hasFDerivWithinAt

theorem HasDerivWithinAt.hasFDerivWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} {f' : F},
      HasDerivWithinAt f f' s x → HasFDerivWithinAt f (ContinuousLinearMap.smulRight 1 f') s x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, and any normed additive commutative group `F` over `𝕜`, if a function `f` from `𝕜` to `F` has a derivative `f'` at a point `x` within a subset `s` of `𝕜`, then `f` has a Fréchet derivative at `x` within `s` which is represented by the continuous linear map obtained by right multiplication of `f'` by `1`. In mathematical terms, this means that if `f` satisfies the property `f(x') = f(x) + (x' - x) • f' + o(x' - x)`, as `x'` converges to `x` inside `s`, then it possesses a Fréchet derivative at `x` within `s`.

If a function `f` from a non-trivially normed field `𝕜` to a normed additive commutative group `F` over `𝕜` has a derivative `f'` at a point `x` within a subset `s` of `𝕜`, then `f` has a Fréchet derivative at `x` within `s` equal to the continuous linear map obtained by right multiplication of `f'` by `1`.


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

The theorem `Multiset.le_union_left` states that for any type `α` which has a decidable equality relation, and for any two multisets `s` and `t` of type `α`, the multiset `s` is a sub-multiset of the union of `s` and `t`. This means that all elements in `s` are also found in the union of `s` and `t`. This is a fundamental property of union operations in the context of multisets (or sets, generally).

For any decidably equal type `α` and multisets `s` and `t` of type `α`, `s` is a sub-multiset of the union `s ∪ t`.


theorem IsPreconnected.subset_connectedComponent :
    ∀ {α : Type u} [inst : TopologicalSpace α] {x : α} {s : Set α},
      IsPreconnected s → x ∈ s → s ⊆ connectedComponent x :=
  by sorry

This theorem states that for any topological space `α` and for any point `x` and set `s` within `α`, if `s` is preconnected and `x` belongs to `s`, then `s` is a subset of the connected component of `x`. Here, a set is preconnected if there is no non-trivial open partition of it, and the connected component of a point is the largest preconnected set that contains the point.

If a set `s` in a topological space `α` is preconnected and contains a point `x`, then `s` is a subset of the connected component of `x`.


theorem LieIdeal.map_le_iff_le_comap :
    ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L} {J : LieIdeal R L'},
      LieIdeal.map f I ≤ J ↔ I ≤ LieIdeal.comap f J :=
  by sorry

The theorem `LieIdeal.map_le_iff_le_comap` establishes a correspondence between the mapping and comapping of Lie ideals in a Lie algebra. Specifically, for all types `R`, `L`, and `L'`; given a commutative ring `R`, Lie rings `L` and `L'`, and Lie algebras `L` and `L'` over `R`, a linear map `f : L →ₗ⁅R⁆ L'`, and Lie ideals `I` of `L` and `J` of `L'`; the image of the ideal `I` under the map `f` is a subset of the ideal `J` if and only if the ideal `I` is a subset of the preimage of `J` under `f`. This theorem is essentially a version of the fundamental theorem of Galois theory for Lie algebras.

For a commutative ring R, Lie rings L and L', Lie algebras L and L' over R, a linear map f : L →ₗ⁅R⁆ L', and Lie ideals I of L and J of L': I ↴ f(I) ⊆ J if and only if I ⊆ f⁻¹(J).


theorem MeasureTheory.Lp.norm_toLp :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : α → E) (hf : MeasureTheory.Memℒp f p μ),
      ‖MeasureTheory.Memℒp.toLp f hf‖ = (MeasureTheory.snorm f p μ).toReal :=
  by sorry

This theorem states that for any type `α`, type `E` forming a normed additive commutative group, a measurable space `m0` on `α`, an extended nonnegative real `p`, a measure `μ` on `α`, and a function `f` from `α` to `E` that satisfies the `Memℒp` property, the norm of the element in Lp space corresponding to `f`, obtained via `Memℒp.toLp`, is equal to the real part of the `ℒp` seminorm of `f` with respect to measure `μ` and `p`.

In other words, for a function `f` that is almost everywhere strongly measurable and whose `ℒp` seminorm is finite, when this function is mapped to an Lp space, the norm of the resulting element is the same as the `ℒp` seminorm of the original function. The `ℒp` seminorm, denoted `MeasureTheory.snorm`, is defined as `0` for `p=0`, as the essential supremum of `‖f a‖` with respect to measure `μ` for `p = ∞`, and as `∫ ‖f a‖^p ∂μ` to the power of `1/p` for `0 < p < ∞`.

For any measurable space `(α, μ)`, type `E` forming a normed additive commutative group, and a measurable function `f: α → E` satisfying the `Memℒp` property with finite `ℒp` seminorm, the Lp norm of `Memℒp.toLp f` equals the `ℒp` seminorm of `f` with respect to `μ` and `p`.


theorem Ideal.span_mono : ∀ {α : Type u} [inst : Semiring α] {s t : Set α}, s ⊆ t → Ideal.span s ≤ Ideal.span t := by
  sorry

This theorem, `Ideal.span_mono`, is about ideals in a semiring. It states that for any type `α` with a semiring structure and for any two sets `s` and `t` of elements of type `α`, if `s` is a subset of `t` then the ideal generated by `s` is a subideal of the ideal generated by `t`. In other words, increasing the set of generators of an ideal can only increase the ideal itself.

If `s` is a subset of `t` in a semiring `α`, then the ideal generated by `s` is contained in the ideal generated by `t`.


theorem CategoryTheory.Sieve.pullback_id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X},
      CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.id X) S = S :=
  by sorry

The theorem `CategoryTheory.Sieve.pullback_id` states that for any category `C` and any object `X` in `C`, if we have a sieve `S` on `X`, then pulling back `S` via the identity morphism on `X` results in the original sieve `S`. This is essentially saying that the pullback operation preserves the identity, which is a common property in category theory.

For any category $C$ and object $X$ in $C$, and any sieve $S$ on $X$, the pullback of $S$ along the identity morphism on $X$ equals $S$.


theorem CategoryTheory.ShortComplex.LeftHomologyData.homologyIso_leftHomologyData :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.ShortComplex.LeftHomologyData.homologyIso (CategoryTheory.ShortComplex.leftHomologyData S) =
        (CategoryTheory.ShortComplex.leftHomologyIso S).symm :=
  by sorry

This theorem states that for any category `C` with zero morphisms, and any short complex `S` within that category that possesses a homology, the isomorphism generated by the left homology data of `S` is the inverse of the isomorphism generated by the left homology of `S`. In other words, it affirms the compatibility of the homology data with the actual left homology in a short complex in a mathematical category, providing a symmetry between these two constructions.

In a category with zero morphisms, the left homology isomorphisms of any short complex with homology coincide.


theorem Set.iInter_univ : ∀ {α : Type u_1} {ι : Sort u_4}, ⋂ x, Set.univ = Set.univ := by sorry

The theorem `Set.iInter_univ` states that for any type `α` and for any index set `ι`, the intersection of the universal set over all elements of the index set is still the universal set. In other words, if we take the intersection of the universal set across any collection of indices, we will always end up with the universal set, i.e., the set containing all elements of the type `α`. In formal mathematics notation, this can be written as: ∀α, ι, ⋂ₓ (Set.univ) = Set.univ.

The theorem asserts that the intersection of the universe over all indices in any index set is equal to the universe itself for any type `α`.


theorem hasDerivWithinAt_diff_singleton :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x :=
  by sorry

The theorem `hasDerivWithinAt_diff_singleton` states that for any nontrivially normed field `𝕜`, any normed additive commutative group `F`, any normed space over `𝕜` and `F`, any function `f` from `𝕜` to `F`, any value `f'` in `F`, any point `x` in `𝕜`, and any set `s` in `𝕜`, the derivative of `f` at `x` within the set `s` excluding `x` is the same as the derivative of `f` at `x` within the set `s`. In mathematical terms, it says that $f'(x)$ exists within $s \setminus \{x\}$ if and only if $f'(x)$ exists within $s$.

The derivative of a function from a nontrivially normed field to a normed space exists at a point in a set if and only if it exists in the set excluding that point.


theorem HomogeneousIdeal.toIdeal_injective :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A]
      [inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι]
      [inst_5 : GradedRing 𝒜], Function.Injective HomogeneousIdeal.toIdeal :=
  by sorry

The theorem `HomogeneousIdeal.toIdeal_injective` asserts that for any types `ι`, `σ`, and `A`, given that `A` forms a semiring, `σ` is a set-like of `A`, `σ` also forms an additive submonoid of `A`, `𝒜` is a function from `ι` to `σ`, the equality of `ι` is decidable, `ι` forms an additive monoid, and `𝒜` forms a graded ring, the function `HomogeneousIdeal.toIdeal` that converts a homogeneous ideal to an ideal is injective. In other words, if two homogeneous ideals are mapped to the same ideal by the function `HomogeneousIdeal.toIdeal`, then those two homogeneous ideals are the same. This injectivity holds universally across all such `ι`, `σ`, and `A`.

Given a semiring `A`, a set-like `σ` that forms an additive submonoid and is graded over a decidably-equivalent additive monoid `ι`, the function `HomogeneousIdeal.toIdeal` mapping homogeneous ideals to ideals is injective.


theorem sSup_image' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : SupSet α] {s : Set β} {f : β → α}, sSup (f '' s) = ⨆ a, f ↑a := by sorry

This theorem states that for any two types `α` and `β`, given a supremum-structured set `α` and a function `f` from `β` to `α`, the supremum of the image of a set `s` under the function `f`, denoted by `sSup (f '' s)`, is equal to the supremum over all elements `a` in the original set `s` of `f(a)`, denoted by `⨆ a, f ↑a`. Essentially, it's saying that the supremum of the image of a set under a function is the same as the supremum of the function values at each point in the set. This theorem is related to the concept of supremum in order theory.

For any supremum-structured set `α`, function `f` from `β` to `α`, and set `s` in `β`, the image `sSup (f '' s)` is equal to the supremum `⨆ a ∈ s, f ↑a` of the function values on `s`.


Nat.succ.inj

theorem Nat.succ.inj : ∀ {n n_1 : ℕ}, Nat.succ n = Nat.succ n_1 → n = n_1 := by sorry

This theorem, `Nat.succ.inj`, states that for any two natural numbers `n` and `n_1`, if the successor (the next natural number) of `n` is equal to the successor of `n_1`, then `n` must be equal to `n_1`. In other words, if `n+1` equals `n_1+1`, then `n` equals `n_1`. This is an application of the principle of injectivity of the successor function in the natural numbers.

If for natural numbers `n` and `n_1`, `n+1 = n_1+1`, then `n = n_1`.


/-- In a Noetherian space, all sets are compact.  -/
theorem TopologicalSpace.NoetherianSpace.isCompact :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace.NoetherianSpace α] (s : Set α),
      IsCompact s :=
  by sorry

This theorem states that in a Noetherian topological space, all sets are compact. Formally, for any type `α` that has a topological space structure and is a Noetherian space, any set `s` of type `α` is compact. In other words, for any nontrivial filter `f` that contains `s`, there exists an element `x` in `s` such that every set of `f` intersects every neighborhood of `x`.

In a Noetherian topological space, every set is compact.


theorem Submodule.gc_map_comap :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂]
      [inst_8 : RingHomSurjective σ₁₂] (f : F), GaloisConnection (Submodule.map f) (Submodule.comap f) :=
  by sorry

The theorem `Submodule.gc_map_comap` establishes a Galois connection between the map and comap functions in the context of submodules of modules over semirings. Specifically, for any types `R`, `R₂`, `M`, `M₂`, and `F`, given semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, `R`-module structure on `M`, `R₂`-module structure on `M₂`, a semiring homomorphism `σ₁₂` from `R` to `R₂`, a function `f` of type `F` from `M` to `M₂` (with `F` being a type that has an injective coercion to functions from `M` to `M₂`), and when `σ₁₂` is surjective and `F` acts as a semilinear map with respect to `σ₁₂`, then the function `Submodule.map f` and `Submodule.comap f` form a Galois connection. In simpler terms, this means that for all submodules `a` and `b`, `Submodule.map f a` is a subset of `b` if and only if `a` is a subset of `Submodule.comap f b`.

Given semirings `R` and `R₂`, additive commutative monoids `M` and `M₂` with `R`-module structures, a semiring homomorphism `σ₁₂` from `R` to `R₂`, a function `f` from `M` to `M₂` acting as a semilinear map with respect to `σ₁₂`, and when `σ₁₂` is surjective, the map and comap functions of `f` on submodules of `M` form a Galois connection.


theorem Matrix.StdBasisMatrix.apply_of_ne :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type u_5} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Semiring α]
      (i : m) (j : n) (c : α) (i' : m) (j' : n), ¬(i = i' ∧ j = j') → Matrix.stdBasisMatrix i j c i' j' = 0 :=
  by sorry

The theorem `Matrix.StdBasisMatrix.apply_of_ne` states that for any types `m`, `n`, and `α` with decidable equality (`DecidableEq`) and a semiring structure on `α`, and for any elements `i, i'` of type `m`, `j, j'` of type `n`, and `c` of type `α`, if `(i, j)` is not equal to `(i', j')`, then the entry of the standard basis matrix `stdBasisMatrix` at the position `(i', j')`, created with `i, j, c` as parameters, is zero.

In other words, the standard basis matrix created with `i, j, c` has `c` at the `i-th` row and `j-th` column, and zeroes elsewhere. The theorem specifically asserts that if we're looking at a position `(i', j')` that is not the same as `(i, j)`, then the value at that position in the matrix will be zero.

For any types `m`, `n`, and `α` with decidable equality and a semiring structure, the standard basis matrix `stdBasisMatrix` has entry `0` at position `(i', j')` whenever `(i, j)` is not equal to `(i', j')`.


theorem eventually_eventually_nhds :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {p : X → Prop},
      (∀ᶠ (y : X) in nhds x, ∀ᶠ (x : X) in nhds y, p x) ↔ ∀ᶠ (x : X) in nhds x, p x :=
  by sorry

This theorem states that for any topological space `X` and any point `x` in `X`, a property `p` holds eventually for all points in a neighborhood of `x`, if and only if `p` holds eventually for all points in a neighborhood of every point in the neighborhood of `x`. Here, "eventually" refers to the mathematical concept implying that beyond a certain point in a sequence or function, all subsequent terms or values satisfy a given property. Also, "neighborhood" is used in the topological sense where it refers to a set that includes an open set containing the point.

For any topological space X and point x, a property p holds eventually for all points in a neighborhood of x if and only if it holds eventually for all points in the neighborhood of any point in that neighborhood.


theorem FirstOrder.Language.Substructure.fg_def :
    ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : FirstOrder.Language.Structure L M]
      {N : FirstOrder.Language.Substructure L M},
      FirstOrder.Language.Substructure.FG N ↔
        ∃ S, Set.Finite S ∧ (FirstOrder.Language.Substructure.closure L).toFun S = N :=
  by sorry

This theorem states that for any first-order language `L`, any type `M`, and any `N` which is a substructure of `L` over `M`, `N` is finitely generated if and only if there exists a set `S` which is finite and the substructure generated by `S` is equal to `N`. The substructure generated by `S` means the smallest substructure that contains `S`. This gives a precise mathematical condition for a substructure to be finitely generated in the context of first-order languages.

A substructure of a first-order language with respect to a type is finitely generated if and only if there exists a finite set generating it.


theorem sub_div' : ∀ {K : Type u_3} [inst : Field K] (a b c : K), c ≠ 0 → b - a / c = (b * c - a) / c := by sorry

This theorem states that for any type `K` which is a field, given any three elements `a`, `b`, and `c` of type `K`, where `c` is not equal to zero, the value of the expression `b - a / c` is equal to `(b * c - a) / c`. Essentially, this theorem rearranges a subtraction and division operation into a single division operation.

For any field `K` and elements `a`, `b`, and `c` in `K` with `c` non-zero, `b - a / c` equals `(b * c - a) / c`.


theorem CategoryTheory.ShortComplex.p_opcyclesMap :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasRightHomology S₂] (φ : S₁ ⟶ S₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.pOpcycles S₁)
          (CategoryTheory.ShortComplex.opcyclesMap φ) =
        CategoryTheory.CategoryStruct.comp φ.τ₂ (CategoryTheory.ShortComplex.pOpcycles S₂) :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.p_opcyclesMap`, states that for any category `C` with zero morphisms, and any two short complexes `S₁` and `S₂` in `C` that have right homology, given a morphism `φ` from `S₁` to `S₂`, the composition of the projection from `S₁` to its associated opcycles with the opcycles map of `φ` is equal to the composition of `φ`'s τ₂ component with the projection from `S₂` to its associated opcycles. In other words, this theorem articulates a specific commutative property of these operations in the context of Category Theory and the structure of short complexes.

 For any short complexes `S₁` and `S₂` in a category with zero morphisms and right homology, and a morphism `φ` between them, the diagram commutes:

```
 opcycles(S₁) ↓───────┐
                   | ⊣ p₂(S₁)          opcycles(S₂) ↓───────┐
                   |                                    |
                   | φ                                   |
                   |                                    |
                  ↓─────────────────────────────────────────↓
 H_(n+1)(S₁)   ──┐----┐ H_(n+1)(S₂)
               | P₂(S₁)|
               └─────┘
```

where `opcycles` is the opcycles map, `p₂` is the projection to the second component, and `H_n` represents the n-th homology.


theorem finprod_eq_prod_of_mulSupport_toFinset_subset :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) (hf : Set.Finite (Function.mulSupport f))
      {s : Finset α}, Set.Finite.toFinset hf ⊆ s → (finprod fun i => f i) = Finset.prod s fun i => f i :=
  by sorry

The theorem `finprod_eq_prod_of_mulSupport_toFinset_subset` states that for any type `α` and `M`, where `M` is a commutative monoid, given a function `f : α → M`, if the set of points `x` such that `f(x) ≠ 1` (also known as the multiplicative support of `f`) is finite, then for any finite set `s` of type `α`, if the finite set corresponding to the multiplicative support of `f` is a subset of `s`, then the product of `f(x)` as `x` ranges over all elements of type `α` (denoted as `finprod f`) is equal to the product of `f(x)` as `x` ranges over the elements of the finite set `s` (denoted as `Finset.prod s f`). In other words, it shows that the infinite product over all elements is the same as the finite product over a superset of the multiplicative support.

Given a commutative monoid `M` and a function `f : α → M` with finite multiplicative support, if the multiplicative support of `f` is a subset of a finite set `s`, then `finprod f = Finset.prod s f`.


theorem CategoryTheory.GrothendieckTopology.toPlus_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
      [inst_1 : CategoryTheory.Category.{max v u, w} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      {P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp η (CategoryTheory.GrothendieckTopology.toPlus J Q) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.toPlus J P)
          (CategoryTheory.GrothendieckTopology.plusMap J η) :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.toPlus_naturality` states that for a category `C` with a Grothendieck topology `J`, another category `D`, and two functors `P` and `Q` from the opposite of `C` to `D`, when we have certain structures in place (specifically, for any object `X` in `C` and any cover `S` of `X` in `J`, the multicospan associated with the index of the cover on `P` has a limit, and any object `X` in `C` has colimits of shape opposite to the poset of covers of `X` in `D`), then the composition of a morphism `η` from `P` to `Q` with the `toPlus` operation on `Q` (according to `J`) equals the composition of the `toPlus` operation on `P` (according to `J`) with the `plusMap` operation on `η` (according to `J`). In other words, this theorem shows the naturality of the `toPlus` operation in the context of the Grothendieck topology.

Given a category with a Grothendieck topology, for any two functors from the opposite category with the required structures, the `toPlus` operation on their composite is equal to the composition of the `toPlus` operations and the `plusMap` operation.


theorem inducing_id : ∀ {X : Type u_1} [inst : TopologicalSpace X], Inducing id := by sorry

This theorem states that for any type `X` with a given topology (represented by `TopologicalSpace X`), the identity mapping (represented by `id`) is an inducing map. In terms of mathematics, it is saying that the identity function is always a topological embedding, thus it induces the same topology on the underlying set `X`.

The identity function is a topological embedding for any topological space `X`.


theorem Mathlib.Data.Multiset.Nodup._auxLemma.1 : ∀ {α : Type u_1} {l : List α}, Multiset.Nodup ↑l = List.Nodup l := by
  sorry

The theorem `Mathlib.Data.Multiset.Nodup._auxLemma.1` states that for all types `α` and for any list `l` of that type, the property of the multiset associated to `l` having no duplicates (i.e., `Multiset.Nodup ↑l`) is equivalent to the property of the list `l` having no duplicates (i.e., `List.Nodup l`). In other words, a list and its corresponding multiset share the same "no duplicates" property.

The theorem asserts that for any type `α` and list `l` of length `n` over `α`, `Multiset.Nodup (List.map fromList (List.take n (List.repeat x (nat.succ (n - 1)))）) ≡ List.nodup l`, where `x` is any element of type `α` and `fromList` is the function mapping a multiset to its underlying list.


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

This theorem, `OreLocalization.zero_def`, states that for every type `R` that is a semiring and for every submonoid `S` of `R` that is an Ore set, the value of zero in the Ore localization is equal to the fraction `0 /ₒ 1`. In other words, in the context of Ore localization, zero can be expressed as the ratio of zero to one.

In an Ore localization of a semiring R with respect to an Ore set S, the element representing zero is equal to the fraction 0 /ₒ 1.


theorem AlgebraicGeometry.Scheme.Pullback.v.proof_1 :
    ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst : ∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.map i) f) g]
      (i j : 𝒰.J),
      CategoryTheory.Limits.HasPullback
        (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst (𝒰.map i)) (𝒰.map j) :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.Pullback.v.proof_1` states that, given schemes `X`, `Y`, `Z`, an open cover `𝒰` of `X`, morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, and for all `i` in `𝒰.J` if the pullback of the composition of `𝒰.map i` and `f` with `g` exists, then for any `i, j` in `𝒰.J`, the pullback of the composition of the first projection of the pullback of `f` and `g` and `𝒰.map i` with `𝒰.map j` also exists. Essentially, this theorem relates the pullback of certain morphisms with the pullbacks of related compositions and is a part of the algebraic geometry theory in the context of scheme theory.

Given schemes X, Y, Z, an open cover 𝒰 of X, morphisms f : X ⟶ Z and g : Y ⟶ Z, if for all i in 𝒰.J, the pullback of the composition of 𝒰.map i ∘ f and g exists, then the pullback of the composition of the first projection of the pullback of f and g with 𝒰.map i and 𝒰.map j exists for all i, j in 𝒰.J.


theorem LieSubmodule.mono_lie_right :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N N' : LieSubmodule R L M)
      (I : LieIdeal R L), N ≤ N' → ⁅I, N⁆ ≤ ⁅I, N'⁆ :=
  by sorry

The theorem `LieSubmodule.mono_lie_right` states that for any commutative ring `R`, any Lie ring `L`, any Additive commutative group `M`, where `L` is a Lie algebra over `R` and `M` is a `L`-module, if `N` and `N'` are two Lie submodules of `M` and `I` is a Lie ideal of `L`, then if `N` is a subset of `N'`, the Lie bracket of `I` and `N` is also a subset of the Lie bracket of `I` and `N'`. This theorem demonstrates a kind of "monotonicity" property of the Lie bracket operation with respect to the inclusion of Lie submodules.

If `I` is a Lie ideal of a commutative ring `R` over a Lie algebra `L`, and `N` is a subset of `N'`, both being Lie submodules of an `L`-module `M`, then the Lie bracket of `I` with `N` is contained in the Lie bracket of `I` with `N'`.


theorem Matrix.dotProduct_zero :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (v : m → α),
      Matrix.dotProduct v 0 = 0 :=
  by sorry

The theorem `Matrix.dotProduct_zero` states that for any set `m` and any type `α` that forms a non-unital, non-associative semiring, the dot product of any vector `v` (represented as a function from `m` to `α`) with the zero vector (represented as the function constantly returning zero) is always the zero element of `α`. This mirrors the property in vector algebra that the dot product of any vector with the zero vector is zero.

For any non-unital, non-associative semiring `α` and vector `v` as a function from a set `m` to `α`, `∀ i, v i • 0 = 0`.


theorem CategoryTheory.FreeBicategory.preinclusion_map₂ :
    ∀ {B : Type u} [inst : Quiver B] {a b : B} (f g : CategoryTheory.Discrete (Quiver.Path a b)) (η : f ⟶ g),
      (CategoryTheory.FreeBicategory.preinclusion B).map₂ η = CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.FreeBicategory.preinclusion_map₂` states that for any type `B` equipped with a `Quiver` structure, and for any two objects `a` and `b` in `B`, given two discrete paths `f` and `g` from `a` to `b` in the discrete quiver and a morphism `η` from `f` to `g`, applying the `map₂` function of the `preinclusion` of the free bicategory of `B` to `η` will yield the same result as applying the `eqToHom` function to a certain equality. The `eqToHom` function is used to turn an equality into a morphism in a category, avoiding potential complications from dependent type theory.

For any type `B` with a `Quiver` structure, given two objects `a` and `b`, discrete paths `f` and `g` from `a` to `b`, and a morphism `η` from `f` to `g`, `preinclusion_map₂ η = eqToHom (ap _ _ η)` in the free bicategory of `B`.


theorem Filter.lift_le :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} {h : Filter β} {s : Set α},
      s ∈ f → g s ≤ h → Filter.lift f g ≤ h :=
  by sorry

This theorem is about filters and sets in Lean 4. Specifically, it states that for any types 'α' and 'β', any filter 'f' of type 'α', any function 'g' that maps a set 'α' to a filter 'β', any filter 'h' of type 'β', and any set 's' of type 'α', if 's' is in the filter 'f' and the filter 'g(s)' is less than or equal to the filter 'h', then the lift of filter 'f' along the function 'g' is also less than or equal to the filter 'h'. In other words, the theorem guarantees a certain order-preserving property of the 'lift' operation on filters.

For any filters $f:\alpha \to Prop$, $g:\alpha \to \beta \to Prop$, and $h:\beta \to Prop$, if $s:\alpha$, $f(s)$, and $g(s,\_) \leq h$ hold, then $lift(f,g) \leq h$, where $lift(f,g) : \beta \to Prop$ is the lift of filter $f$ along function $g$.


theorem Bool.or_eq_true : ∀ (a b : Bool), ((a || b) = true) = (a = true ∨ b = true) := by sorry

This theorem, `Bool.or_eq_true`, states that for all Boolean values `a` and `b`, the condition where the logical OR of `a` and `b` equals `true` is equivalent to the condition where either `a` is `true` or `b` is `true`. In other words, `a OR b` being `true` is the same as either `a` being `true` or `b` being `true` in Boolean logic.

For all Boolean values `a` and `b`, `a ∨ b` is equivalent to `a = true ∨ b = true`.


theorem principal_le_nhdsSet :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, Filter.principal s ≤ nhdsSet s := by sorry

The theorem `principal_le_nhdsSet` states that for any given set `s` in a topological space `X`, the principal filter of `s` is less than or equal to the filter of neighborhoods of `s`. In other words, the collection of all supersets of `s` (defined as the principal filter) is a subset of the collection of all neighborhoods of `s` in the topological space `X`. This means every superset of `s` is a neighborhood of `s` in the space `X`.

For any set $s$ in a topological space $X$, the principal filter of $s$ is contained in the filter of neighborhoods of $s$.


/-- An antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsSup` to the `Filter.liminf` of the image if the function is continuous at the `limsSup`
(and the filter is bounded from above and below).  -/
theorem Antitone.map_limsSup_of_continuousAt :
    ∀ {R : Type u_4} {S : Type u_5} [inst : ConditionallyCompleteLinearOrder R] [inst_1 : TopologicalSpace R]
      [inst_2 : OrderTopology R] [inst_3 : ConditionallyCompleteLinearOrder S] [inst_4 : TopologicalSpace S]
      [inst_5 : OrderTopology S] {F : Filter R} [inst_6 : Filter.NeBot F] {f : R → S},
      Antitone f →
        ContinuousAt f (Filter.limsSup F) →
          autoParam (Filter.IsBounded (fun x x_1 => x ≤ x_1) F) _auto✝ →
            autoParam (Filter.IsBounded (fun x x_1 => x ≥ x_1) F) _auto✝¹ → f (Filter.limsSup F) = Filter.liminf f F :=
  by sorry

The theorem `Antitone.map_limsSup_of_continuousAt` states that for any antitone function `f` mapping from a conditionally complete linear ordered space `R` to another such space `S`, if `f` is continuous at the supremum limit (`limsSup`) of a given filter `F` in `R` (which is also bounded from above and below), then the value of `f` at the `limsSup` of `F` is equal to the infimum limit (`liminf`) of the image of `F` under `f`. In other words, `f` maps the `limsSup` of `F` to the `liminf` of the image of `F` under `f`.

For an antitone function `f` between conditionally complete linear ordered spaces `R` and `S`, if `f` is continuous at the supremum `x` of a filter `F` in `R` (bounded above and below), then `f(x) = inf { f(y) | y ∈ F }`.


/-- The second projection in a product is `C^∞`.  -/
theorem contDiff_snd :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞},
      ContDiff 𝕜 n Prod.snd :=
  by sorry

The theorem `contDiff_snd` states that for any number type `𝕜` that has a normed field structure, any types `E` and `F` that have normed additive commutative group structures and are normed spaces over `𝕜`, and any natural number or infinity `n`, the second projection function `Prod.snd` on the product of `E` and `F` is continuously differentiable `n` times. In other words, the second component of a pair (tuple) is a function that is `C^∞` or infinitely differentiable.

For any normed field `𝕜`, and normed additive commutative groups `E` and `F` as normed spaces over `𝕜`, the second projection function `Prod.snd` on the product of `E` and `F` is infinitely differentiable.


theorem Set.iUnion_iUnion_eq_or_left :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {p : β → Prop} {s : (x : β) → x = b ∨ p x → Set α},
      ⋃ x, ⋃ (h : x = b ∨ p x), s x h = s b ⋯ ∪ ⋃ x, ⋃ (h : p x), s x ⋯ :=
  by sorry

This theorem states that for any types `α` and `β`, any element `b` of type `β`, any predicate `p` on `β`, and any family of sets `s` indexed by elements of `β` that satisfy either being equal to `b` or satisfying the predicate `p`, the union over all `x` of `β` of the unions over all proofs `h` that `x` equals `b` or `p` holds for `x` of the sets `s x h`, is equal to the union of the set `s b` with the union over all `x` of `β` of the unions over all proofs `h` that `p` holds for `x` of the sets `s x h`. In other words, the union over all elements and all qualifying predicates is the same as the union of the set for a particular element and all qualifying predicates.

For any types `α`, any predicate `p` on `β`, and any family `s` indexed by `β` such that for each `x` in `β` the set `s x` is either equal to `{b}` when `x = b` or a subset of `s b` when `p(x)` holds, the union of `s x h` over all `x` in `β` and all proofs `h` that `x = b` or `p(x)` holds is equal to `s b ∪ ⋃(s x h)` over all `x` in `β` and all proofs `h` that `p(x)` holds.


theorem AddOpposite.continuous_op : ∀ {M : Type u_1} [inst : TopologicalSpace M], Continuous AddOpposite.op := by sorry

The theorem `AddOpposite.continuous_op` states that for any type `M` equipped with a topological space structure, the operation `AddOpposite.op` is continuous. In other words, if we consider `M` as a topological space, then the function that takes an element `x` of `M` and produces the additive opposite `AddOpposite.op x` is a continuous function.

The additive opposition operation is a continuous function on any topological space.


theorem Primrec.list_cons : ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.cons := by sorry

The theorem `Primrec.list_cons` states that for any type `α` which is primcodable (denoted by `[inst : Primcodable α]`), the function `List.cons` is a binary primitive recursive function. `List.cons` is a function that takes two arguments: an element of type `α` and a list of elements of type `α`, and returns a new list formed by adding the given element to the head of the given list. The theorem asserts that this operation is primitive recursive, which means it can be computed using a limited set of basic operations and recursion.

For any type `α` that is primcodable, the function `List.cons : α → List α → List α` is a primitive recursive function.


theorem CategoryTheory.Sieve.pullback_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ Y}
      (S : CategoryTheory.Sieve X),
      CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.comp g f) S =
        CategoryTheory.Sieve.pullback g (CategoryTheory.Sieve.pullback f S) :=
  by sorry

The theorem `CategoryTheory.Sieve.pullback_comp` states that for any category `C` with objects `X`, `Y`, and `Z`, and morphisms `f` from `Y` to `X` and `g` from `Z` to `Y`, for any Sieve `S` on `X`, pulling back the Sieve `S` along the composite morphism `g ≫ f` (i.e., `g` followed by `f`) is equivalent to first pulling back `S` along `f` and then pulling back the result along `g`. This theorem captures the intuitive idea that the order of pulling back sieves along a composition of morphisms doesn't matter.

For any category C, morphisms f from Y to X and g from Z to Y, and sieve S on X, the pullback of S along the composite morphism g ≫ f is equal to the pullback of the pullback of S along f along g.


theorem List.rotate_cons_succ :
    ∀ {α : Type u} (l : List α) (a : α) (n : ℕ), List.rotate (a :: l) (Nat.succ n) = List.rotate (l ++ [a]) n := by
  sorry

This theorem states that for any list `l` of elements of type `α`, any element `a` of the same type, and any natural number `n`, rotating the list that results from prepending `a` to `l` by `n+1` is the same as rotating the list that results from appending `a` to `l` by `n`. In other words, the operation of rotating a list to the left by `n+1` positions after adding an element at the beginning is the same as rotating the extended list to the left by `n` positions after adding the same element at the end.

For any list `l` of length `n` and any element `a` and natural number `n`, prepending `a` to `l` and rotating left by `n+1` is equivalent to appending `a` to `l` and rotating left by `n`.


theorem BoxIntegral.Box.coe_inf : ∀ {ι : Type u_1} (I J : WithBot (BoxIntegral.Box ι)), ↑(I ⊓ J) = ↑I ∩ ↑J := by sorry

This theorem is about the intersection of two possibly bounded boxes in an arbitrary dimension. More specifically, for any type `ι` and any two possibly bounded boxes `I` and `J` (where a possibly bounded box is represented by the `WithBot` type constructor applied to `BoxIntegral.Box ι`), the box resulting from the infimum (greatest lower bound) of `I` and `J` is equivalent to the intersection of the boxes `I` and `J`. Here, the `coe` function is used to remove the `WithBot` wrapping, and `⊓` denotes the infimum operation.

For any type `ι` and boxes `I` and `J` of type `WithBot (Box ι)`, the infimum `I ⊓ J` is equivalent to the intersection of `I` and `J`, i.e., `{x : ι | x ∈ I ∧ x ∈ J}`.


theorem Int.mul_le_mul_of_nonneg_right : ∀ {a b c : ℤ}, a ≤ b → 0 ≤ c → a * c ≤ b * c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than or equal to `b` and `c` is non-negative (greater than or equal to zero), then the product of `a` and `c` is less than or equal to the product of `b` and `c`. Essentially, this theorem is capturing the idea that multiplication by a non-negative integer preserves the order of other integers.

For integers `a` ≤ `b` and non-negative integer `c`, `a` * `c` ≤ `b` * `c`.


theorem groupCohomology.mem_twoCocycles_iff :
    ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep k G} (f : G × G → CoeSort.coe A),
      f ∈ groupCohomology.twoCocycles A ↔
        ∀ (g h j : G), f (g * h, j) + f (g, h) = ((Rep.ρ A) g) (f (h, j)) + f (g, h * j) :=
  by sorry

The theorem `groupCohomology.mem_twoCocycles_iff` gives a condition for a function `f` to be in the 2-cocycles `Z²(G, A)` of a representation `A` of a monoid `G` over a commutative ring `k`. Specifically, `f` is a 2-cocycle if and only if for all elements `g`, `h`, `j` of the group `G`, the equation `f (g * h, j) + f (g, h) = ((Rep.ρ A) g) (f (h, j)) + f (g, h * j)` holds. The left-hand side of this equation is the sum of the values of `f` at `(g * h, j)` and `(g, h)`, and the right-hand side is the result of applying the `g`-th action of the representation `A` on the result of `f (h, j)` and adding the value of `f` at `(g, h * j)`. This theorem is central to the study of group cohomology.

A function `f` is a 2-cocycle in the group cohomology of a monoid `G` over a commutative ring `k` with respect to a representation `A` if and only if for all `g, h, j` in `G`, `f (g * h, j) + f (g, h) = (Rep.ρ A g) (f (h, j)) + f (g, h * j)`.


theorem Ideal.prime_of_isPrime :
    ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] {P : Ideal A},
      P ≠ ⊥ → Ideal.IsPrime P → Prime P :=
  by sorry

This theorem states that for any commutative ring 'A' which is also a Dedekind domain, if 'P' is a non-trivial left ideal (not the zero ideal) in 'A' and 'P' is a prime ideal, then 'P' is a prime element of 'A'. Here, a prime ideal is an ideal that if an element times another falls into this ideal, then at least one of the elements must belong to the ideal. A prime element is one which is not zero, not a unit, and if it divides a product of two elements, it must divide at least one of those elements.

A non-zero, non-unit element 'p' in a commutative Dedekind domain 'A' is a prime element if and only if the ideal generated by 'p' is a prime ideal.


theorem Path.extend_extends :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {a b : X} (γ : Path a b) {t : ℝ} (ht : t ∈ Set.Icc 0 1),
      Path.extend γ t = γ { val := t, property := ht } :=
  by sorry

This theorem states that for all types `X`, assuming that `X` has a topology, and for any two points `a` and `b` in `X` with a path `γ` connecting them, if a real number `t` is in the closed interval [0, 1], then extending the path `γ` at `t` is equivalent to the path `γ` at `t`. In simpler terms, it states that the "extended" path at a point in the unit interval is the same as the original path at that point.

For any connected topological space $(X, \tau)$, points $a, b \in X$ with a path $\gamma$ connecting them, and real number $t \in [0, 1]$, the extended path $\gamma \ast [t]$ is equal to $\gamma$ at point $t$, i.e., $\gamma \ast [t] = \gamma$.


theorem MeasureTheory.FinStronglyMeasurable.fin_support_approx :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → β} [inst : Zero β]
      [inst_1 : TopologicalSpace β] (hf : MeasureTheory.FinStronglyMeasurable f μ) (n : ℕ),
      ↑↑μ (Function.support ↑(MeasureTheory.FinStronglyMeasurable.approx hf n)) < ⊤ :=
  by sorry

The theorem `MeasureTheory.FinStronglyMeasurable.fin_support_approx` states that for any given function `f` from `α` to `β`, if `f` is FinStronglyMeasurable with respect to a measure `μ`, then for any natural number `n`, the measure of the support (i.e., the set of points `x` such that `f(x) ≠ 0`) of the `n`-th approximating simple function in the sequence guaranteed by `f`'s FinStronglyMeasurability is finite (i.e., less than infinity). Here, the approximating sequence of simple functions is produced by the existence property in the definition of FinStronglyMeasurable functions. In other words, every function in the approximating sequence for `f` has finite measure support.

For any FinStronglyMeasurable function `f` from a measurable space `(α, Σ)` to another measurable space `(β, Τ)` and any natural number `n`, the support of the `n`-th approximating simple function in the sequence guaranteed by `f`'s FinStronglyMeasurability has finite measure.


theorem Set.isCompl_range_inl_range_inr :
    ∀ {α : Type u_1} {β : Type u_2}, IsCompl (Set.range Sum.inl) (Set.range Sum.inr) := by sorry

The theorem `Set.isCompl_range_inl_range_inr` states that for all types `α` and `β`, the range of the function `Sum.inl` (which sends an element from type `α` to the corresponding element in the sum type `α + β`) and the range of the function `Sum.inr` (which sends an element from type `β` to the corresponding element in the sum type `α + β`) are complements of each other in the set of all possible values of the sum type `α + β`. In other words, every element in `α + β` can be uniquely identified as coming from `α` via `Sum.inl` or from `β` via `Sum.inr`, but not both.

For all types `α` and `β`, the ranges of `Sum.inl` and `Sum.inr` over `α + β` form a pair of complementary subsets, i.e., for all `x : α + β`, `Sum.inl x ∈ Set.range (Sum.inl : α → α + β)` if and only if `Sum.inr x ∉ Set.range (Sum.inr : β → α + β)`.


theorem WithTop.coe_ne_top : ∀ {α : Type u_1} {a : α}, ↑a ≠ ⊤ := by sorry

This theorem states that for any type `α` and any element `a` of that type, the embedding of `a` into the `WithTop α` type is not equal to `⊤` (`top`). In other words, no regular element from the original type `α` can be represented as the special `top` element in the `WithTop α` type after it's embedded. This is in the context of the `WithTop` type constructor, which adds a top element to any given type.

For any type `α` and element `a` of `α`, the embedding of `a` into `WithTop α` is not equal to the top element `⊤` in `WithTop α`.


theorem Real.Angle.pi_ne_zero : ↑Real.pi ≠ 0 := by sorry

This theorem states that the real number representation of the mathematical constant pi (π), as defined in Lean 4, is not equal to zero. In other words, it guarantees that the value of pi, approximately equal to 3.14159265, cannot be zero, consistent with its mathematical definition.

The theorem asserts that the value of Pi in Lean 4 is not equal to zero.


theorem Iff.to_eq : ∀ {a b : Prop}, (a ↔ b) → a = b := by sorry

This theorem, named `Iff.to_eq`, states that for any two propositions `a` and `b`, if `a` is logically equivalent to `b` (denoted by `a ↔ b`), then `a` is equal to `b`. In other words, if two propositions are mutually implied (each one can be deduced from the other), they can be considered identical.

If two propositions `a` and `b` are logically equivalent, then `a = b`.


theorem subset_mulTSupport :
    ∀ {X : Type u_1} {α : Type u_2} [inst : One α] [inst_1 : TopologicalSpace X] (f : X → α),
      Function.mulSupport f ⊆ mulTSupport f :=
  by sorry

The theorem `subset_mulTSupport` states that for any type `X` with a topology and any type `α` with a multiplicative identity (denoted `One α`), for any function `f` from `X` to `α`, the multiplicative support of `f` (i.e., the set of points `x` in `X` such that `f(x)` is not equal to the multiplicative identity of `α`) is a subset of the topological multiplicative support of `f` (i.e., the closure of the set of all points where the function is not equal to the multiplicative identity). In other words, every point where the function doesn't yield the multiplicative identity is contained in the set of limit points of the set where the function doesn't yield the multiplicative identity.

The multiplicative support of a function from a topological space to a type with a multiplicative identity is contained in the topological closure of its non-identity values.


theorem Nat.add_mod_mod : ∀ (m n k : ℕ), (m + n % k) % k = (m + n) % k := by sorry

This theorem states that for all natural numbers `m`, `n`, and `k`, the remainder of the sum of `m` and the remainder of `n` divided by `k`, all divided by `k`, is equal to the remainder when `m + n` is divided by `k`. In mathematical terms, it's expressing the property `(m + n mod k) mod k = (m + n) mod k`.

The theorem asserts that for all natural numbers `m`, `n`, and `k`, the remainder of `(m + n)` divided by `k` is equal to the remainder of `m` when divided by `k`, plus the remainder of `n` when divided by `k`. In Lean notation: `(m + n) mod k = (m mod k + n mod k) mod k`.


theorem CategoryTheory.CosimplicialObject.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.CosimplicialObject C} (f g : X ⟶ Y),
      (∀ (n : SimplexCategory), f.app n = g.app n) → f = g :=
  by sorry

This theorem states that, given any type `C` with a category structure, and any two cosimplicial objects `X` and `Y` in this category, if we have two morphisms `f` and `g` from `X` to `Y`, then `f` is equal to `g` if and only if their application to every object `n` in the simplex category produces the same results. In simpler terms, two morphisms between the same pair of cosimplicial objects are identical if they coincide on every natural number in the simplex category.

Given any category `C` with cosimplicial objects `X` and `Y`, and morphisms `f` and `g` from `X` to `Y`, they are equal if and only if for all `n`, `Fn = Gn` in `C(X(n), Y(n))`, where `Fn` and `Gn` are the application of `f` and `g` to the `n`-simplexes.


theorem Monoid.exponent_dvd :
    ∀ {G : Type u} [inst : Monoid G] {n : ℕ}, Monoid.exponent G ∣ n ↔ ∀ (g : G), orderOf g ∣ n := by sorry

This theorem states that for any group `G` and any natural number `n`, the exponent of the group `G` divides `n` if and only if the order of each element `g` in `G` divides `n`. Here, the exponent of a group is the smallest positive integer `n` such that raising any group element `g` to the power of `n` results in the identity element (`g ^ n = 1`), if such an integer exists, otherwise it's conventionally zero. Similarly, the order of a group element is the smallest positive integer `n` such that raising the given element to the power of `n` results in the identity element (`x ^ n = 1`), or zero if the element is of infinite order.

For any group `G` and natural number `n`, the group's exponent `n` equals the lcm (least common multiple) of the orders of all its elements.


theorem Ideal.pow_le_self : ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R} {n : ℕ}, n ≠ 0 → I ^ n ≤ I := by sorry

This theorem states that for any commutative semiring `R`, any ideal `I` of `R`, and any natural number `n` that is not zero, the `n`-th power of the ideal `I` (denoted as `I ^ n`) is a subset of or equal to `I`. In other words, raising an ideal to a power does not produce any new elements outside of the ideal, if the power is non-zero.

For any commutative semiring `R`, ideal `I`, and natural number `n` ≠ 0, `I ^ n` is contained in `I`.


theorem Polynomial.coe_normUnit :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizationMonoid R] {p : Polynomial R},
      ↑(normUnit p) = Polynomial.C ↑(normUnit (Polynomial.leadingCoeff p)) :=
  by sorry

This theorem states that for any commutative ring `R` that is also an integral domain and a normalization monoid, and for any polynomial `p` with coefficients in `R`, the unit normalization of `p` (denoted by `normUnit p`) is equal to the constant polynomial with the unit normalization of the leading coefficient of `p` as its constant term. In other words, the unit normalization of a polynomial equals a constant polynomial whose constant term is the unit normalization of the leading coefficient of the original polynomial.

For any commutative ring R that is an integral domain and a normalization monoid, the unit normalization of a polynomial p over R equals the constant polynomial with the unit normalization of p's leading coefficient as its constant term.


theorem List.forall_mem_nil : ∀ {α : Type u_1} (p : α → Prop), ∀ x ∈ [], p x := by sorry

This theorem states that for any property `p` that elements of some type `α` can have, any element `x` of type `α` that is in an empty list (denoted by `[]` in Lean) has the property `p`. Since there are no elements in an empty list, the statement is vacuously true for any `p` and `x`.

For any property `p`, any element `x` of type `α` in an empty list `[]` has property `p`. (Vacuously true)


theorem CategoryTheory.Limits.pullback.lift_fst_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
      (w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g) {Z_1 : C} (h_1 : X ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.lift h k w)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst h_1) =
        CategoryTheory.CategoryStruct.comp h h_1 :=
  by sorry

The theorem `CategoryTheory.Limits.pullback.lift_fst_assoc` states that for any category `C` with objects `W`, `X`, `Y`, `Z`, `Z_1`, morphisms `f: X ⟶ Z`, `g: Y ⟶ Z`, `h: W ⟶ X`, `k: W ⟶ Y`, and `h_1: X ⟶ Z_1`, given that a pullback exists for `f` and `g`, and `h` composed with `f` equals `k` composed with `g`, the composition of `pullback.lift h k w` with the composition of `pullback.fst` and `h_1` equals the composition of `h` and `h_1`. In other words, this theorem is about the associativity property of composition in the context of pullbacks in a category.

Given a pullback square in a category with morphisms `h`, `k`, `f`, `g`, and `h_1` such that `h` is in the pullback of `f` and `g`, `h_1 f = g k`, then `h_1 (pullback.lift h k w) = pullback.fst h (h_1 w)`.


theorem MeasureTheory.AEStronglyMeasurable'.stronglyMeasurable_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} (hfm : MeasureTheory.AEStronglyMeasurable' m f μ),
      MeasureTheory.StronglyMeasurable (MeasureTheory.AEStronglyMeasurable'.mk f hfm) :=
  by sorry

This theorem states that for any given topological space `β` and measurable spaces `m` and `m0` of type `α`, together with a measure `μ` on `α`, if a function `f` from `α` to `β` is almost everywhere (`μ`-a.e.) equal to an `m`-strongly measurable function (i.e., `f` satisfies `MeasureTheory.AEStronglyMeasurable' m f μ`), then the function almost everywhere equal to `f` that is `m`-strongly measurable (i.e., the function obtained by `MeasureTheory.AEStronglyMeasurable'.mk f hfm`) is strongly measurable (i.e., it is the limit point of a sequence of simple functions).

Given a topological space β, measurable spaces m and m0 of type α, and a measure μ on α, if a function f from α to β is almost everywhere equal to an m-strongly measurable function, then the almost everywhere equal, m-strongly measurable function is itself strongly measurable.


theorem Mathlib.Topology.Separation._auxLemma.3 : ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the logical conjunction of `a` and `b`, further conjoined with `c` (i.e., `(a ∧ b) ∧ c`), is logically equivalent to the conjunction of `a`, `b`, and `c` without any specific grouping (i.e., `a ∧ b ∧ c`). This essentially means that the association of conjunctions (and-operators) does not alter the truth value of the overall expression.

The theorem asserts that for all propositions `a`, `b`, and `c`, the logical expressions `(a ∧ b) ∧ c` and `a ∧ b ∧ c` are logically equivalent.


theorem Int.mul_emod_right : ∀ (a b : ℤ), a * b % a = 0 := by sorry

This theorem states that for all integer values `a` and `b`, the remainder of the product `a * b` divided by `a` is always 0. In other words, `a * b` is always a multiple of `a` for any pair of integers `a` and `b`. This is an application of the property of divisibility in integer multiplication.

For all integers `a` and `b`, `a * b` is a multiple of `a`.


theorem PowerSeries.constantCoeff_X :
    ∀ {R : Type u_1} [inst : Semiring R], (PowerSeries.constantCoeff R) PowerSeries.X = 0 := by sorry

The theorem `PowerSeries.constantCoeff_X` states that for any semiring `R`, the constant coefficient of the formal power series variable in `R` (often denoted as `X`) is zero. In other words, when we extract the constant coefficient (the zero-degree term) from the power series for the variable, we get zero, as there are no terms without the variable in the formal power series for `X`.

The constant coefficient of the formal power series variable is zero in any semiring.


theorem List.kerase_of_not_mem_keys :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {l : List (Sigma β)},
      a ∉ List.keys l → List.kerase a l = l :=
  by sorry

This theorem states that for any type `α`, a dependent type `β` that depends on `α`, and an instance of decidable equality on `α`, given a key `a` of type `α` and a list `l` of key-value pairs (sigmas), if the key `a` is not found in the list of keys derived from `l`, then the list obtained by removing the first occurrence of the key `a` from `l` (using the `List.kerase` function) is equal to the original list `l`. In other words, removing a key that is not present in the list of key-value pairs doesn't change the list.

For any type `α`, if `a` is not an element of the list `l` of key-value pairs `(α × β) list`, then `l` is equal to the list obtained by removing the first occurrence of the pair `(a, _)` from `l` using `List.kerase`.


theorem Set.projIcc.proof_1 :
    ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), a ≤ b → ∀ (x : α), a ≤ max a (min b x) ∧ max a (min b x) ≤ b :=
  by sorry

This theorem states that for any type `α` that has a linear order, given two elements `a` and `b` of that type such that `a` is less than or equal to `b`, then for any element `x` of the same type, the maximum of `a` and the minimum of `b` and `x` is both greater than or equal to `a` and less than or equal to `b`. Essentially, it is asserting that for any `x`, when it is constrained to be within the interval [a, b] via min and max operations, it indeed stays within that interval.

For any linear order type `α` and elements `a`, `b`, and `x` of type `α` with `a ≤ b`, the minimum of `b` and the maximum of `a` and `x` lies within the interval [`a`, `b`].


theorem MvPolynomial.X_pow_eq_monomial :
    ∀ {R : Type u} {σ : Type u_1} {e : ℕ} {n : σ} [inst : CommSemiring R],
      MvPolynomial.X n ^ e = (MvPolynomial.monomial fun₀ | n => e) 1 :=
  by sorry

This theorem states that for any commutative semiring `R`, any type `σ`, any natural number `e`, and any element `n` of type `σ`, the `e`th power of the `n`th degree 1 monomial is equal to the monomial with coefficient `1` and exponents given by the function that maps `n` to `e` and all other elements of `σ` to `0`. In other words, taking the `e`th power of the `n`th degree 1 monomial in a multivariable polynomial over a commutative semiring results in a monomial whose exponent for `n` is `e` and whose coefficient is `1`.

For any commutative semiring `R` and any `σ`, the `e`th power of the monomial `x^n` in `R[σ]` equals `x^(map n e)`, where `n : σ → ℕ`, `e : ℕ`, and `map` is function application.