theorem MeasureTheory.snorm_const_smul_le :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] {𝕜 : Type u_5} [inst_1 : NormedRing 𝕜] [inst_2 : MulActionWithZero 𝕜 F]
      [inst_3 : BoundedSMul 𝕜 F] (c : 𝕜) (f : α → F),
      MeasureTheory.snorm (c • f) p μ ≤ ‖c‖₊ • MeasureTheory.snorm f p μ :=
  by sorry

This theorem asserts that for any measurable space `α`, any normed additive commutative group `F`, any extended non-negative real number `p`, any measure `μ` on `α`, any normed ring `𝕜`, and any scalar multiplication of `𝕜` on `F`, if `f` is a function from `α` to `F` and `c` is an element of `𝕜`, then the `ℒp` seminorm (as defined by `MeasureTheory.snorm`) of the scalar multiple `c • f` is less than or equal to the product of the non-negative norm of `c` and the `ℒp` seminorm of `f`. This formalizes a type of inequality for the `ℒp` seminorm under scalar multiplication.

For any measurable space `α`, normed additive commutative group `F`, extended non-negative real number `p`, measure `μ` on `α`, normed ring `𝕜`, and scalar multiplication of `𝕜` on `F`, if `f : α → F` is measurable and `c ∈ 𝕜`, then `||c • f||ₗₙ ≤ ||c|| • ||f||ₗₙ`, where `||.||` denotes the `ℒp` seminorm.


theorem AddUnits.add_left_inj :
    ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) {b c : α}, b + ↑a = c + ↑a ↔ b = c := by sorry

This theorem, `AddUnits.add_left_inj`, in Lean 4 is stating that for any type `α` that forms an additive monoid, for any unit `a` of addition, the equality `b + ↑a = c + ↑a` is equivalent to `b = c`. In other words, if adding the same unit to two elements `b` and `c` in the monoid results in the same result, then `b` and `c` must have been the same to begin with. This theorem embodies the concept of left-cancellation in the setting of an additive monoid.

For any additive monoid type `α` and unit `a` of addition, `b = c` if and only if `b + a = c + a`.


theorem isSquare_op_iff : ∀ {α : Type u_2} [inst : Mul α] {a : α}, IsSquare (MulOpposite.op a) ↔ IsSquare a := by sorry

This theorem states that for any type `α` that has a multiplication operation, and for any element `a` of that type, `a` is a square in the multiplicative sense (i.e., there exists an `r` in `α` such that `a = r * r`) if and only if the multiplicative opposite of `a` is also a square. In other words, an element and its multiplicative opposite share the property of being a square.

For any type `α` with multiplication and any `a` in `α`, `a` and its multiplicative opposite are both squares if and only if they have a common square root in `α`.


theorem Set.pairwise_disjoint_Ioc_add_zsmul :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α),
      Pairwise (Disjoint on fun n => Set.Ioc (a + n • b) (a + (n + 1) • b)) :=
  by sorry

The theorem `Set.pairwise_disjoint_Ioc_add_zsmul` states that for any type `α` which is an ordered additive commutative group, and for any two elements `a` and `b` of this type, we have that the left-open right-closed intervals `(a + n • b, a + (n + 1) • b]` are pairwise disjoint. In other words, for any two different integers `n` and `m`, there is no `x` which belongs to both intervals `(a + n • b, a + (n + 1) • b]` and `(a + m • b, a + (m + 1) • b]`. Here, `•` represents the scalar multiplication operation in the group, and `Disjoint` means that the infimum (greatest lower bound) of the two sets is the bottom element of the lattice of subsets.

For any ordered additive commutative group type `α` and elements `a, b` in `α`, the left-open right-closed intervals `(a + n • b, a + (n + 1) • b]` are pairwise disjoint for distinct integers `n`.


/-- Every ideal of the product ring is of the form `I × J`, where `I` and `J` can be explicitly
given as the image under the projection maps.  -/
theorem Ideal.ideal_prod_eq :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (I : Ideal (R × S)),
      I = Ideal.prod (Ideal.map (RingHom.fst R S) I) (Ideal.map (RingHom.snd R S) I) :=
  by sorry

The theorem `Ideal.ideal_prod_eq` in Lean 4 states that every ideal of the product semiring is of a particular form. Specifically, given any semirings `R` and `S`, and any ideal `I` of the product semiring `R × S`, the ideal `I` is equal to the product of two ideals. These two ideals are the images of `I` under the natural projection maps from `R × S` to `R` and `S` respectively. In other words, any ideal of the product semiring can be decomposed into a pair of ideals, one in each of the constituent semirings, by using the natural projection maps.

Given any ideal `I` of the product semiring `R × S`, there exist ideals `J` in `R` and `K` in `S` such that `I = J × K`, where `×` denotes the product semiring.


theorem MeasureTheory.Measure.eq_rnDeriv₀ :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite ν]
      {s : MeasureTheory.Measure α} {f : α → ENNReal},
      AEMeasurable f ν →
        MeasureTheory.Measure.MutuallySingular s ν →
          μ = s + ν.withDensity f → f =ᶠ[MeasureTheory.Measure.ae ν] μ.rnDeriv ν :=
  by sorry

This theorem states that, for any measurable space `α`, measures `μ`, `ν` and `s` on `α`, and a function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), under the conditions that `ν` is sigma finite, `f` is almost everywhere measurable with respect to `ν`, and `s` and `ν` are mutually singular (i.e., `s` and `ν` are measures such that there exists a measurable set on which one measure is zero while the other one is zero on the set's complement), then if `μ` equals the sum of `s` and the measure derived from `ν` with density `f`, it must be the case that `f` is almost everywhere equal to the Radon-Nikodym derivative of `μ` with respect to `ν`. In other words, `f` can be thought of as the derivation of `μ` from `ν` when taking into account the mutually singular part `s`.

If `μ` is the sum of a sigma-finite measure `ν`, a mutually singular measure `s`, and the product of `ν` and the almost everywhere defined, measurable function `f`, then `f` is the Radon-Nikodym derivative of `μ` with respect to `ν`.


/-- For filtrations indexed by a discrete order, `Adapted` and `ProgMeasurable` are equivalent.
This lemma provides `Adapted f u → ProgMeasurable f u`.
See `ProgMeasurable.adapted` for the reverse direction, which is true more generally.  -/
theorem MeasureTheory.Adapted.progMeasurable_of_discrete :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : TopologicalSpace β]
      [inst_1 : Preorder ι] {u : ι → Ω → β} {f : MeasureTheory.Filtration ι m} [inst_2 : TopologicalSpace ι]
      [inst_3 : DiscreteTopology ι] [inst_4 : SecondCountableTopology ι] [inst_5 : MeasurableSpace ι]
      [inst_6 : OpensMeasurableSpace ι] [inst_7 : TopologicalSpace.PseudoMetrizableSpace β],
      MeasureTheory.Adapted f u → MeasureTheory.ProgMeasurable f u :=
  by sorry

This theorem states that for filtrations indexed by a discrete order, the properties of being `Adapted` and `ProgMeasurable` are equivalent, in the direction that if a sequence of functions `u` is `Adapted` to a filtration `f`, then it is `ProgMeasurable` with respect to `f`. Here, a sequence of functions `u` is said to be `Adapted` to a filtration `f` if for all `i`, `u i` is `f i`-measurable. The term `ProgMeasurable` refers to a stronger property than `Adapted`. The reverse direction, that `ProgMeasurable` implies `Adapted`, is true more generally and is provided by the lemma `ProgMeasurable.adapted`. This theorem requires a number of conditions on the types, including that the index set has a topology that is both discrete and second countable, and the target space of the functions is a pseudo-metrizable topological space.

For filtrations indexed by a discrete and second countable index set, a sequence of functions is Adapted if and only if it is Progressively Measurable.


theorem CauchyFilter.uniformEmbedding_pureCauchy :
    ∀ {α : Type u} [inst : UniformSpace α], UniformEmbedding CauchyFilter.pureCauchy := by sorry

The theorem `CauchyFilter.uniformEmbedding_pureCauchy` states that for every type `α` equipped with a uniform space structure, the function `pureCauchy` which embeds `α` into its completion `CauchyFilter α` is a uniform embedding. A uniform embedding is a function between two uniform spaces that preserves the uniformity structure, meaning that it is injective and the topology induced by the uniform structure on the domain is the same as the subspace topology from the codomain.

The `pureCauchy` function, which embeds a uniform space `α` into its completion `CauchyFilter α`, is a uniform embedding.


theorem Ring.closure_subset : ∀ {R : Type u} [inst : Ring R] {s t : Set R}, IsSubring t → s ⊆ t → Ring.closure s ⊆ t :=
  by sorry

This theorem states that for any type `R` that forms a ring, given two sets `s` and `t` of elements from `R`, if `t` forms a subring and all elements of `s` are also elements of `t`, then all elements of the smallest subring (as defined by `Ring.closure`) containing `s` are also elements of `t`. In other words, the closure of `s` under the ring operations is a subset of `t`.

In mathematical terms, if `t` is a subring of a ring `R` and `s` is a subset of `t`, then the closure of `s` (i.e., the smallest subring containing `s`) is also a subset of `t`.

If `t` is a subring of a ring `R` and `s` is a subset of `t`, then the closure of `s` in `R` is contained in `t`.


theorem Complex.restrictScalars_one_smulRight' :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (x : E),
      ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 x) =
        ContinuousLinearMap.smulRight Complex.reCLM x + Complex.I • ContinuousLinearMap.smulRight Complex.imCLM x :=
  by sorry

This theorem states that for any element `x` of a certain type `E` (where `E` is a seminormed additive commutative group and a complex normed space), the restriction of scalars from the complex numbers to the real numbers on the continuous linear map defined by right-multiplication by `x` is equal to the sum of two terms: the continuous linear map defined by right-multiplication by the real part of `x`, and the imaginary unit times the continuous linear map defined by right-multiplication by the imaginary part of `x`. In other words, this theorem encapsulates how a complex linear transformation relates to its real and imaginary parts when viewed as real linear transformations.

For any complex number `x` and seminormed additive commutative group `E` being a complex normed space, the restriction of scalars from complex numbers to real numbers on the right-multiplication-by-`x` linear map equals the sum of right-multiplication-by-the-real-part-of-`x` and the imaginary unit times right-multiplication-by-the-imaginary-part-of-`x` linear maps.


theorem integrable_inv_one_add_sq : MeasureTheory.Integrable (fun x => (1 + x ^ 2)⁻¹) MeasureTheory.volume := by sorry

The theorem `integrable_inv_one_add_sq` states that the real-valued function `(1 + x^2)⁻¹` is integrable with respect to the Lebesgue measure. In this context, a function is considered integrable if it is both measurable and its integral over the entire domain is finite. Specifically, the function in question is the multiplicative inverse of `(1 + x^2)`, implying that we are looking at the area under the curve of this function over the entire real line. This theorem assures us that this area is indeed finite.

The theorem `integrable_inv_one_add_sq` asserts that the function `(1 + x^2)⁻¹` is Lebesgue integrable over the real line.


SupClosed.preimage

theorem SupClosed.preimage :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {s : Set α}
      [inst_2 : FunLike F β α] [inst_3 : SupHomClass F β α], SupClosed s → ∀ (f : F), SupClosed (⇑f ⁻¹' s) :=
  by sorry

The theorem `SupClosed.preimage` states that for any types `F`, `α`, `β`, where `α` and `β` are semilattice sup types, a set `s` of type `α`, a function-like object `f` of type `F` from `β` to `α`, and a sup-homomorphism class instance for `F`, `β`, and `α`, if the set `s` is sup-closed (i.e., for all elements `a` and `b` in `s`, their least upper bound `a ⊔ b` is also in `s`), then the preimage of `s` under the function `f` (denoted by `⇑f ⁻¹' s`) is also sup-closed.

If `s` is a sup-closed set in a semilattice `α` and `f` is a sup-homomorphism from a semilattice `β` to `α`, then the preimage `f⁻¹(s)` is a sup-closed set in `β`.


theorem finprod_eq_mulIndicator_apply :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (s : Set α) (f : α → M) (a : α),
      (finprod fun x => f a) = Set.mulIndicator s f a :=
  by sorry

The theorem `finprod_eq_mulIndicator_apply` states that for any given set `s` of type `α`, any function `f` from `α` to a commutative monoid `M`, and any element `a` of type `α`, the product of `f a` over all elements of the multiplicative support of `f` (`finprod fun x => f a`) is equal to `f a` if `a` belongs to the set `s`, and `1` otherwise. This latter operation is defined by `Set.mulIndicator s f a`. In other words, this theorem connects the concepts of finitary product and set-valued multiplication indicator function in the context of a commutative monoid.

For any set `s`, function `f` from a commutative monoid to itself, and element `a` of the set, `finprod fun x => f x = f a` if `a` is in `s`, and `finprod fun x => f x = 1` otherwise, equivalent to `Set.mulIndicator s f a`.


theorem Mathlib.Algebra.Homology.ShortComplex.Homology._auxLemma.2 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
      (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁) (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂)
      (h₃ : CategoryTheory.ShortComplex.LeftHomologyData S₃),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.leftHomologyMap' φ₂ h₂ h₃) =
        CategoryTheory.ShortComplex.leftHomologyMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ :=
  by sorry

This theorem states that for any category `C` equipped with zero morphisms, and given any three `ShortComplex` objects `S₁`, `S₂`, `S₃` in that category, along with morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, and left homology data `h₁`, `h₂`, `h₃` corresponding to these objects, the composition of the left homology maps corresponding to the morphisms `φ₁` and `φ₂` is equal to the left homology map corresponding to the composition of the morphisms `φ₁` and `φ₂`. In mathematical terms, we have `(φ₁ * φ₂) * h = φ₁ * (φ₂ * h)` where `*` denotes the composition of morphisms, showing that the operation of taking left homology maps is compatible with the composition of morphisms.

Given any three objects `S₁`, `S₂`, `S₃` in a category with zero morphisms, and morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, the left homology maps satisfy `(φ₁ * φ₂) * h = φ₁ * (φ₂ * h)`, where `*` denotes composition of morphisms.


theorem Polynomial.opRingEquiv_op_monomial :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (r : R),
      (Polynomial.opRingEquiv R) (MulOpposite.op ((Polynomial.monomial n) r)) =
        (Polynomial.monomial n) (MulOpposite.op r) :=
  by sorry

The theorem `Polynomial.opRingEquiv_op_monomial` states for any semiring `R`, natural number `n` and element `r` of `R`, applying the ring isomorphism `Polynomial.opRingEquiv R` to the element obtained by applying the `MulOpposite.op` operation to the monomial `a * X^n` where `a` is `r`, is the same as applying the `MulOpposite.op` operation to `r` and then creating the corresponding monomial. In simpler terms, it says that changing the order of operations — creating a monomial first then taking the opposite, or taking the opposite first then creating a monomial — doesn't change the final result.

For any semiring `R`, applying the ring isomorphism `Polynomial.opRingEquiv R` to the monomial obtained by applying `MulOpposite.op` to `r * X^n` is equivalent to applying `MulOpposite.op` to `r` and then creating the monomial `X^n`.


theorem ProbabilityTheory.kernel.map_apply' :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
      {mγ : MeasurableSpace γ} {f : β → γ} (κ : ↥(ProbabilityTheory.kernel α β)) (hf : Measurable f) (a : α)
      {s : Set γ}, MeasurableSet s → ↑↑((ProbabilityTheory.kernel.map κ f hf) a) s = ↑↑(κ a) (f ⁻¹' s) :=
  by sorry

This theorem, named `ProbabilityTheory.kernel.map_apply'`, states that for any types `α`, `β` and `γ` with their respective measurable spaces `mα`, `mβ` and `mγ`, and any function `f` that maps `β` to `γ` and is measurable (the preimage of every measurable set is measurable), along with any element `a` of type `α` and any measurable set `s` of type `γ`, the application of the kernel map of `κ` (which is a measurable kernel from `α` to `β`) and `f` to `a` and `s` is equal to the application of `κ` to `a` and the preimage of `s` under `f`.

In simpler terms, this theorem relates the measure of the set obtained by mapping a measurable kernel through a measurable function to the measure of the preimage of that set under the original function.

For any measurable kernels κ from type α to β and measurable functions f from β to γ, and for any a in α and measurable set s in γ, the application of κ to a and the preimage of s under f is equal to the application of κ to a and f to the measure of s.


theorem hasSum_subtype_iff_of_support_subset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α}
      {s : Set β}, Function.support f ⊆ s → (HasSum (f ∘ Subtype.val) a ↔ HasSum f a) :=
  by sorry

This theorem states that for any types `α` and `β`, given an addition-commutative monoid structure on `α` and a topological space structure on `α`, for any function `f` from `β` to `α` and any element `a` of `α`, and for a set `s` of `β`, if the support of function `f` (i.e., the set of points `x` such that `f(x) ≠ 0`) is a subset of set `s`, then the proposition "the sum of the function `f` composed with the projection function `Subtype.val` has a limit of `a`" is logically equivalent to the proposition "the sum of the function `f` also has a limit of `a`". Here, the sum is over the elements in the subtype defined by the predicate corresponding to set `s`.

For any addition-commutative monoid `α` with a topology, function `f` from type `β` to `α`, and subsets `s` of `β`, if `f`'s support is contained in `s` and the sum of `f` has a limit as the elements in the subtype of `β` defined by `s` approach, then the sum of `f` composed with the projection function from the subtype to `α` also has a limit equal to the limit of `a` in `α`.


theorem FirstOrder.Language.Substructure.closure_union :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] (s t : Set M),
      (FirstOrder.Language.Substructure.closure L).toFun (s ∪ t) =
        (FirstOrder.Language.Substructure.closure L).toFun s ⊔ (FirstOrder.Language.Substructure.closure L).toFun t :=
  by sorry

The theorem `FirstOrder.Language.Substructure.closure_union` states that for any first-order language `L` and any type `M` with a `FirstOrder.Language.Structure` instance, and any two sets `s` and `t` of type `M`, the closure of the union of `s` and `t` in the language `L` is equivalent to the supremum (join operation in the lattice theory) of the closures of `s` and `t` separately in the language `L`. This theorem is essentially expressing that the closure operation respects set unions in the context of first order languages.

For any first-order language L and type M with a FirstOrder.Language.Structure instance, the closure of the union of two sets s and t in language L is equal to the join (supremum) of the closures of s and t.


/-- In a preadditive category, when `p : X ⟶ X` is idempotent,
then `𝟙 X - p` is also idempotent.  -/
theorem CategoryTheory.Idempotents.idem_of_id_sub_idem :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
      (p : X ⟶ X),
      CategoryTheory.CategoryStruct.comp p p = p →
        CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X - p)
            (CategoryTheory.CategoryStruct.id X - p) =
          CategoryTheory.CategoryStruct.id X - p :=
  by sorry

This theorem states that in a preadditive category, if a morphism `p : X → X` is idempotent (meaning that composing `p` with itself results in `p`), then the morphism `𝟙 X - p` (where `𝟙 X` is the identity morphism on `X`) is also idempotent. That is, composing `𝟙 X - p` with itself results in `𝟙 X - p`. The category is defined by the type `C`, `X` is an object of this category, and `p` is a morphism from `X` to `X`.

In a preadditive category, an idempotent morphism's identity morphism subtraction is also idempotent. (Or, the identity morphism minus an idempotent morphism is idempotent in a preadditive category.)


/-- A set is contained in its own (open) thickening.  -/
theorem Metric.self_subset_thickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ}, 0 < δ → ∀ (E : Set α), E ⊆ Metric.thickening δ E := by sorry

The theorem states that for any set in a pseudo metric space, the set is contained within its own δ-thickening, given that δ is greater than 0. In other words, every point in the set is within a δ distance from some point in the set. Here, the δ-thickening of a set consists of all points in the space that are less than δ distance away from some point in the set.

In a pseudo metric space, every set is contained in its own δ-thickening for any δ > 0. (Every point in the set is within δ distance of some point in the set.)


theorem Finsupp.update_idem :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (f : α →₀ M) (a : α) (b c : M),
      Finsupp.update (Finsupp.update f a b) a c = Finsupp.update f a c :=
  by sorry

The theorem `Finsupp.update_idem` states that for any elements `a` of type `α` and `b`, `c` of type `M` (where `M` has a zero element), and any function `f` mapping elements of type `α` to elements of `M` (with finite support), updating the value of `f` at `a` to `b` and then updating it again at `a` to `c` is the same as just updating the value of `f` at `a` to `c` in the first place. In other words, consecutive updates at the same location in a finitely-supported function are idempotent; the second update erases the effect of the first.

For any function `f` with finite support from type `α` to type `M` with zero element, the updates `f := (f.map (λ x => if x = a then b else f x))` and `f := (f.map (λ x => if x = a then c else f x))` are equal, where `a` is an element of type `α` and `b` and `c` are elements of type `M`.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.45 :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) := by sorry

This theorem states that, for any type `α` which has a structure of a semilattice with respect to an infimum operation and also has a least or "bottom" element, and for any two elements `a` and `b` of this type, `a` and `b` are disjoint if and only if the infimum of `a` and `b` is the bottom element. In mathematical terms, it says that $a$ and $b$ are disjoint (which is defined as that for any $x$ that is less than or equal to both $a$ and $b$, $x$ must also be less than or equal to the bottom element) if and only if $a \wedge b = \bot$, where $\wedge$ denotes the infimum operation and $\bot$ represents the bottom element.

For any semilattice with a least element, elements $a$ and $b$ are disjoint if and only if their infimum is the least element.


theorem LinearMap.bijective_of_ne_zero :
    ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_5}
      [inst_3 : AddCommGroup N] [inst_4 : Module R N] [inst_5 : IsSimpleModule R M] [inst_6 : IsSimpleModule R N]
      {f : M →ₗ[R] N}, f ≠ 0 → Function.Bijective ⇑f :=
  by sorry

The theorem `LinearMap.bijective_of_ne_zero` states that for any ring `R`, and any two simple `R`-modules `M` and `N`, any non-zero linear map `f : M →ₗ[R] N` is bijective. Here, a simple `R`-module is a module that only has two submodules: the zero submodule and the module itself. A bijective function is one that is both injective (no two different inputs map to the same output) and surjective (every possible output is mapped by some input).

If `R` is a ring and `M` and `N` are simple `R`-modules, then any non-zero linear map from `M` to `N` is a bijection.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.43 :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] {a : α} {f : ι → UpperSet α}, (a ∈ ⨆ i, f i) = ∀ (i : ι), a ∈ f i :=
  by sorry

This theorem states that for any type `α`, any type `ι`, any element `a` of type `α`, and any function `f` from `ι` to the upper sets of `α`, the condition of `a` being in the superset (denoted by `⨆`) of all `f i` is equivalent to `a` being in `f i` for every `i` in `ι`. In more human-friendly terms, an element is in the superset of all values of a function if and only if it is in the value of the function for every possible input.

For any type `α`, any type `ι`, any element `a` of type `α`, and any function `f` from `ι` to the upper sets of `α`, `a` belongs to the supremum of `{f i | i ∈ ι}` if and only if `a` belongs to `f i` for all `i` in `ι`.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.41 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) := by sorry

This theorem states that for any types `A` and `B`, given a SetLike instance `i` from `A` to `B`, and for any `p` of type `A` and `x` of type `B`, belonging of `x` to the coercion of `p` to a set is equivalent to belonging of `x` to `p` itself. In other words, `x` is in `p` if and only if `x` is in the set obtained by coercing `p` to a set.

For any SetLike instance from type `A` to type `B`, and for any `p` of type `A` and `x` of type `B`, `x` belongs to `p` if and only if `x` belongs to the coercion of `p` to a set.


theorem PrimeMultiset.prod_dvd_iff : ∀ {u v : PrimeMultiset}, PrimeMultiset.prod u ∣ PrimeMultiset.prod v ↔ u ≤ v := by
  sorry

The theorem `PrimeMultiset.prod_dvd_iff` states that for any two multisets of prime numbers `u` and `v`, the product of the elements of `u` divides the product of the elements of `v` if and only if `u` is a sub-multiset of `v`. In other words, every prime number in `u` also appears in `v`, possibly with fewer occurrences.

For multisets of prime numbers `u` and `v`, `prod u ∣ prod v` if and only if `u` is a sub-multiset of `v`.


/-- In a metrizable space (or even a pseudo metrizable space), an open set can be approximated from
inside by closed sets.  -/
theorem MeasureTheory.Measure.InnerRegularWRT.of_pseudoMetrizableSpace :
    ∀ {X : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace.PseudoMetrizableSpace X]
      [inst_2 : MeasurableSpace X] (μ : MeasureTheory.Measure X),
      MeasureTheory.Measure.InnerRegularWRT μ IsClosed IsOpen :=
  by sorry

This theorem states that in a pseudo-metrizable space, which is a mild generalization of a metrizable space, any open set can be approximated from the inside by closed sets. Specifically, given a measure `μ` on the space, the measure is inner regular with respect to the properties of being closed and open. This means that for every open set `U` and any real number `r` less than the measure of `U`, there exists a closed subset `K` of `U` such that the measure of `K` is greater than `r`. This theorem allows us to approximate the measure of an open set by the measures of its closed subsets.

In a pseudo-metrizable space equipped with a measure, every open set can be approximated from the inside by closed sets with respect to measure.


theorem DFinsupp.instAddDFinsuppToZero.proof_1 :
    ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → AddZeroClass (β i)] (x : ι), 0 + 0 = 0 := by sorry

This theorem states that for any type `ι` and a function `β` from `ι` to another type, given an instance of `AddZeroClass` for each `β i`, the addition of two zero elements results in zero. This essentially generalizes the property of additive identities in the context of Direct Sum of finitely supported functions (`DFinsupp`).

For any type `ι` and function `β : ι →Type_, if each `β i` has an additive zero, then the sum of any two additive zero elements of `β` is an additive zero.


/-- A `Finset` of a subsingleton type has cardinality at most one.  -/
theorem Finset.card_le_one_of_subsingleton : ∀ {α : Type u_1} [inst : Subsingleton α] (s : Finset α), s.card ≤ 1 := by
  sorry

This theorem states that for any given type `α` which is a subsingleton (i.e., it has at most one distinct element), any finite set (`Finset`) of this type `α` can have a cardinality (size) of at most one. Basically, this theorem ensures that if we have a set of a type where all elements are identical, then the size of the set can only be zero or one.

For any subsingleton type `α`, the cardinality of any finite set of `α` is at most 1.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.85 :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ LowerSet.Iic a) = (b ≤ a) := by sorry

The theorem `Mathlib.Order.UpperLower.Basic._auxLemma.85` states that for any type `α` equipped with a preorder and for any elements `a` and `b` of type `α`, `b` is a member of the principal lower set of `a` (`LowerSet.Iic a`) if and only if `b` is less than or equal to `a`. In other words, the membership of `b` in the principal lower set of `a` is equivalent to the inequality `b ≤ a`.

For any preordered type `α` and elements `a` and `b` of `α`, `b` belongs to the principal lower set of `a` if and only if `b` is less than or equal to `a`.


theorem subset_mul_closure_one :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] (s : Set G), s ⊆ s * closure {1} := by sorry

The theorem `subset_mul_closure_one` states that for any set `s` of a topological group `G`, the set `s` is a subset of the multiplication of `s` and the closure of the set containing only the group's unit element `1`. In other words, every element of `s` can be expressed as the product of an element in `s` and an element in the closure of the set `{1}`. The closure of a set is the smallest closed set containing the set, implying it includes all limit points of the set.

For any topological group G and set s of G, every element of s lies in the closure of {1} \* s.


theorem FiniteDimensional.finrank_linearMap_self :
    ∀ (R : Type u) (S : Type u') (M : Type v) [inst : Ring R] [inst_1 : Ring S] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : Module.Free R M] [inst_5 : Module.Finite R M] [inst_6 : StrongRankCondition R]
      [inst_7 : StrongRankCondition S] [inst_8 : Module R S] [inst_9 : SMulCommClass R S S],
      FiniteDimensional.finrank S (M →ₗ[R] S) = FiniteDimensional.finrank R M :=
  by sorry

This theorem states that for any types `R`, `S`, and `M`, where `R` and `S` are rings, `M` is an additively commutative group, `M` is a module over `R`, `M` is a free module over `R`, `M` is a finite module over `R`, `R` satisfies the strong rank condition, `S` satisfies the strong rank condition, `S` is a module over `R`, and the scalar multiplication on `S` commutes with `R`, the rank of the space of linear maps from `M` to `S` over the field `S` is equal to the rank of `M` over the field `R`. In other words, the dimension of the vector space of linear transformations from `M` to `S` (considered over the field `S`) is the same as the dimension of the vector space `M` (considered over the field `R`).

Given rings `R` and `S`, a finite, free, additively commutative `R`-module `M`, and a commutative `S`-module `S` such that both `R` and `S` satisfy the strong rank condition, the dimension of the space of `S`-linear maps from `M` to `S` equals the dimension of `M` over `R`.


theorem disjoint_right_comm :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α},
      Disjoint (a ⊓ b) c ↔ Disjoint (a ⊓ c) b :=
  by sorry

This theorem states that for any semilattice (a partially ordered set in which any two elements have a greatest lower bound) of type `α` with a minimum element (`OrderBot α`), and any three elements `a`, `b`, and `c` of `α`, the property of being disjoint is right commutative with respect to the infimum operation (`⊓`). In other words, `a` and `b` are disjoint with respect to `c` if and only if `a` and `c` are disjoint with respect to `b`. Here, two elements are said to be disjoint if their greatest lower bound (infimum) is the minimum element of the set.

For any semilattice with a minimum element, elements `a`, `b`, and `c` are disjoint with respect to each other if and only if `a ⊓ b = OrderBot` if and only if `a ⊓ c = OrderBot`.


Homeomorph.quotientMap

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

This theorem states that for any two types `X` and `Y`, each equipped with a topological space structure, if there exists a homeomorphism `h` from `X` to `Y`, then the function defined by the homeomorphism `h` is a quotient map. A quotient map is a function that is surjective and for any set `s` in `Y`, `s` is open if and only if its preimage under the function is an open set in `X`.

If `h` is a homeomorphism between topological spaces `(X, txX)` and `(Y, tyY)`, then `h` is a quotient map, i.e., for any open set `s` in `Y`, `h⁻¹(s)` is an open set in `X`.


theorem Set.mul_mem_center :
    ∀ {M : Type u_1} [inst : Mul M] {z₁ z₂ : M}, z₁ ∈ Set.center M → z₂ ∈ Set.center M → z₁ * z₂ ∈ Set.center M := by
  sorry

The theorem `Set.mul_mem_center` states that for any type `M` equipped with a multiplication operation (`Mul M`), if two elements `z₁` and `z₂` belong to the center of the magma `M` (i.e., they commute with every other element in `M`), then their product `z₁ * z₂` also belongs to the center of `M`. In other words, the center of a magma is closed under the magma's multiplication operation.

The center of a magma is a submonoid that is closed under multiplication.


theorem intervalIntegrable_const :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] {c : E}, IntervalIntegrable (fun x => c) μ a b :=
  by sorry

The theorem `intervalIntegrable_const` states that for any real numbers `a` and `b`, any measure `μ` on the real numbers that is locally finite, and any element `c` of a given normed additive commutative group `E`, the constant function `fun x => c` is interval integrable with respect to `μ` on the interval from `a` to `b`. This means that the constant function is integrable on both of the intervals `(a, b]` and `(b, a]`, which is equivalent to being integrable on the interval `(min(a, b), max(a, b)]`.

For any locally finite measure μ on the real numbers and any constant function f(x) = c, the function is integrable with respect to μ on any interval [a, b].


theorem Polynomial.taylor_zero' : ∀ {R : Type u_1} [inst : Semiring R], Polynomial.taylor 0 = LinearMap.id := by sorry

The theorem `Polynomial.taylor_zero'` states that for any type `R` equipped with a structure of semiring, the Taylor expansion of a polynomial at 0 is equivalent to the identity linear map. In other words, if you evaluate the Taylor series of any polynomial at the point zero, it acts as the identity on the polynomial.

For any semiring `R`, the Taylor expansion of a polynomial `f` over `R` at `0` equals the identity polynomial.


theorem Part.some_get : ∀ {α : Type u_1} {a : Part α} (ha : a.Dom), Part.some (a.get ha) = a := by sorry

The theorem `Part.some_get` states that for any type `α`, and any partial function `a` of type `Part α` with a domain (denoted by `a.Dom`), applying the function `Part.some` to the result of calling `a.get` with the domain `ha` returns the original partial function `a`. This means that wrapping a function's result with `Part.some` and then retrieving it gives back the original function. Essentially, it's saying that `Part.some` and `a.get` are inverses of each other for this particular setup.

For any partial function `a` of type `Part α` with domain `ha`, `Part.some (a.get ha) = a`.


theorem Nat.one_mod : ∀ (n : ℕ), 1 % (n + 2) = 1 := by sorry

This theorem declares that for all natural numbers `n`, the remainder of 1 divided by `n + 2` is always 1. In other words, when 1 is divided by any natural number greater than or equal to 2 (which is `n+2`), the remainder is invariably 1.

For all natural numbers n, 1 has a remainder of 1 when divided by n + 2.


theorem codisjoint_left_comm :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b c : α},
      Codisjoint a (b ⊔ c) ↔ Codisjoint b (a ⊔ c) :=
  by sorry

The theorem 'codisjoint_left_comm' states that for any type 'α', which is an instance of a semilattice with supremum and has a top order, and any elements 'a', 'b', and 'c' of 'α', the condition of 'a' and the supremum of 'b' and 'c' being codisjoint is equivalent to 'b' and the supremum of 'a' and 'c' being codisjoint. In other words, the property of being codisjoint is left commutative with respect to the supremum operation in this ordered semilattice.

In an ordered semilattice with top element where supremums exist, the codisjointness of elements a and the supremum of b and c is equivalent to the codisjointness of b and the supremum of a and c.


theorem Complex.tan_eq_sin_div_cos : ∀ (x : ℂ), Complex.tan x = Complex.sin x / Complex.cos x := by sorry

This theorem states that for every complex number `x`, the complex tangent of `x`, denoted by `Complex.tan x`, is equal to the quotient of the complex sine of `x` and the complex cosine of `x`. Here, `Complex.sin x` and `Complex.cos x` are defined in terms of the complex exponential function. The complex sine of a number `z` is defined as `(Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)) * Complex.I / 2` and the complex cosine of a number `z` is defined as `(Complex.exp (z * Complex.I) + Complex.exp (-z * Complex.I)) / 2`.

The complex tangent of a complex number `x` is equal to the quotient of its complex sine and complex cosine, where complex sine is defined as the imaginary part of the exponential function `Complex.exp (x * Complex.I) - Complex.exp (-x * Complex.I)` divided by 2, and complex cosine is defined as the real part of the exponential function `Complex.exp (x * Complex.I) + Complex.exp (-x * Complex.I)` divided by 2.


theorem Mathlib.CategoryTheory.Groupoid.Subgroupoid._auxLemma.16 :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (D : Set C) {c d : C} {f : c ⟶ d},
      (f ∈ (CategoryTheory.Subgroupoid.full D).arrows c d) = (c ∈ D ∧ d ∈ D) :=
  by sorry

This theorem states that for any type `C` that forms a groupoid, given a set `D` of `C`, and any morphism `f` from an object `c` to an object `d` in `C`, the morphism `f` is an arrow in the subgroupoid fully generated by `D` if and only if both `c` and `d` belong to `D`. In other words, the morphism `f` is part of the subgroupoid induced by `D` exactly when the objects `c` and `d` are elements of `D`.

For any groupoid `C` and subset `D` of `C`, a morphism `f` from an object `c` to an object `d` in `C` belongs to the subgroupoid fully generated by `D` if and only if both `c` and `d` are elements of `D`.


theorem MeasureTheory.Measure.coe_add :
    ∀ {α : Type u_1} {_m : MeasurableSpace α} (μ₁ μ₂ : MeasureTheory.Measure α), ↑↑(μ₁ + μ₂) = ↑↑μ₁ + ↑↑μ₂ := by sorry

The theorem `MeasureTheory.Measure.coe_add` states that for any given measurable space `α`, and for any two measures `μ₁` and `μ₂` in that space, the measure (or the size) of the union of `μ₁` and `μ₂` is equal to the sum of the measures of `μ₁` and `μ₂`. This is essentially an application of the addition operation on measures in the context of Measure Theory.

For any measurable spaces `(α, Σ)` and measurable sets `A ∈ Σ` and `B ∈ Σ`, the measure of their union `A ∪ B` is equal to the sum of their individual measures, i.e., `μ(A ∪ B) = μ(A) + μ(B)`.


theorem Finset.mem_zero : ∀ {α : Type u_2} [inst : Zero α] {a : α}, a ∈ 0 ↔ a = 0 := by sorry

This theorem states that for any type `α` that has a zero element (indicated by `[inst : Zero α]`), an element `a` of type `α` is a member of the zero set if and only if `a` is equal to zero. In mathematical terms, for any type `α` with a zero, `a ∈ 0` is equivalent to `a = 0`.

For any type `α` with a zero element, `a` is an element of the zero set if and only if `a` equals the zero element itself.


MeasureTheory.Memℒp.norm

theorem MeasureTheory.Memℒp.norm :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α → E}, MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp (fun x => ‖f x‖) p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.norm` states that given a measurable space `α`, a normed add commutative group `E`, a measure `μ` on `α`, a function `f` mapping from `α` to `E`, and a nonnegative extended real number `p`, if `f` satisfies the property of being almost everywhere strongly measurable and having its `p`th power integral norm finite (if `p` is less than infinity) or its essential supremum finite (if `p` is equal to infinity), denoted by `MeasureTheory.Memℒp f p μ`, then the norm of `f`, represented by the function `(fun x => ‖f x‖)`, also satisfies this property, i.e., `MeasureTheory.Memℒp (fun x => ‖f x‖) p μ`.

If a measurable function `f` from a measurable space `α` to a normed add commutative group `E` is almost everywhere strongly measurable and has finite `p`-th power integral norm or essential supremum (if `p` is finite or infinite, respectively), then the norm function `x ↦ ||f x||` is also measurable.


theorem ENNReal.ofReal_le_of_le_toReal : ∀ {a : ℝ} {b : ENNReal}, a ≤ b.toReal → ENNReal.ofReal a ≤ b := by sorry

The theorem `ENNReal.ofReal_le_of_le_toReal` states that for any real number `a` and any extended nonnegative real number `b`, if `a` is less than or equal to the real number representation of `b` (indicated by `b.toReal`), then the extended nonnegative real number representation of `a` (given by `ENNReal.ofReal a`) is less than or equal to `b`. In other words, this theorem preserves the order relation "less than or equal to" under the map from real numbers to extended nonnegative real numbers.

For all real numbers `a` and extended nonnegative real numbers `b`, `a ≤ b.toReal` implies `ENNReal.ofReal a ≤ b`.


theorem TwoUniqueProds.of_injective_mulHom :
    ∀ {G : Type u} {H : Type v} [inst : Mul G] [inst_1 : Mul H] (f : H →ₙ* G),
      Function.Injective ⇑f → TwoUniqueProds G → TwoUniqueProds H :=
  by sorry

The theorem `TwoUniqueProds.of_injective_mulHom` states that for any types `G` and `H` equipped with multiplication (`Mul G` and `Mul H`), given an injective group homomorphism `f` (a function preserving multiplication) from `H` to `G`, if `G` satisfies the `TwoUniqueProds` property, then `H` also satisfies the `TwoUniqueProds` property. Here, the `TwoUniqueProds` property is a condition (not given in the provided code) typically related to the uniqueness of solutions to certain equations in the context of structures with a multiplication operation.

If `f` is an injective group homomorphism from `H` to the group `G` with the `TwoUniqueProds` property, then `H` also has the `TwoUniqueProds` property.


theorem Basis.equivFun_ofEquivFun :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Finite ι] (e : M ≃ₗ[R] ι → R), Basis.equivFun (Basis.ofEquivFun e) = e :=
  by sorry

This theorem, `Basis.equivFun_ofEquivFun`, states that for any semiring `R`, additive commutative monoid `M`, module structure on `M` over `R`, and finite type `ι`, given a linear equivalence `e` between `M` and the function type `ι → R`, the function `Basis.equivFun` applied to the basis of `M` over `R` as defined by the `Basis.ofEquivFun` function with `e` as its argument will equal to `e`. In simpler terms, it implies for a given linear equivalence between a module and a finite set of functions, the function to map a basis to this equivalence will recover the original equivalence.

For any semiring `R`, additive commutative monoid `M` with an `R`-module structure, finite type `ι`, and a linear equivalence `e` between `M` and `ι → R`, the basis transformation `Basis.equivFun (Basis.ofEquivFun e)` equals `e`.


theorem SetTheory.PGame.moveRight_nim' :
    ∀ {o : Ordinal.{u_1}} (i : SetTheory.PGame.RightMoves (SetTheory.PGame.nim o)),
      SetTheory.PGame.moveRight (SetTheory.PGame.nim o) i =
        SetTheory.PGame.nim ↑(SetTheory.PGame.toRightMovesNim.symm i) :=
  by sorry

This theorem states that for any ordinal 'o' and any right move 'i' in the game of Nim on 'o', when the right player makes a move 'i' in this game, the resulting game position is the Nim game on the ordinal that corresponds to the inverse of 'i' under the mapping from initial ordinals less than 'o' to the set of right moves in the game of Nim on 'o'. In simple terms, this theorem is describing the dynamics of the game of Nim: when the right player makes a move, the game transitions to a state that corresponds to a smaller ordinal number.

For any ordinal 'o' and right move 'i' in the game of Nim, the resulting game position is the Nim game on the ordinal 'o' corresponding to the inverse of 'i' under the mapping from initial ordinals to right moves.


theorem sdiff_sup_self : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), b \ a ⊔ a = b ⊔ a := by
  sorry

This theorem states that for any type `α` that forms a Generalized Coheyting Algebra, and any two elements `a` and `b` of that type, the supremum (join operation, denoted by `⊔`) of `b` subtracted by `a` (`b \ a`) and `a` itself is equal to the supremum of `b` and `a`. In other words, removing `a` from `b` and then taking the supremum with `a` just brings us back to the supremum of `b` and `a`. This is a property specific to the structures in logic and mathematics known as Generalized Coheyting Algebras.

For any type `α` forming a Generalized Cohesion Algebra and any `a, b` in `α`, `(b \ a) ⊔ a = b ⊔ a`.


theorem AkraBazziRecurrence.deriv_smoothingFn :
    ∀ {x : ℝ}, 1 < x → deriv AkraBazziRecurrence.smoothingFn x = -x⁻¹ / Real.log x ^ 2 := by sorry

The theorem `AkraBazziRecurrence.deriv_smoothingFn` states that for any real number `x` such that `x` is greater than 1, the derivative of the Akra-Bazzi recurrence's smoothing function, which is defined as `1 / log(n)`, at `x` is equal to `-1 / (x * log(x)^2)`. This theorem communicates the rate of change of the smoothing function at any point `x` greater than 1 in the context of the Akra-Bazzi recurrence.

For `x` greater than 1, the derivative of the Akra-Bazzi recurrence's smoothing function `1 / log(n)` is equal to `-1 / (x * log(x)^2)`.


theorem Set.mul_mem_centralizer :
    ∀ {M : Type u_1} {S : Set M} {a b : M} [inst : Semigroup M],
      a ∈ Set.centralizer S → b ∈ Set.centralizer S → a * b ∈ Set.centralizer S :=
  by sorry

This theorem states that for any type `M` that is a semigroup, if `a` and `b` are both elements of the centralizer of a set `S` of `M`, then the product of `a` and `b` is also an element of the centralizer of `S`. In other words, the centralizer of a set in a semigroup is closed under multiplication. This means that for all elements `m` in `S`, the equations `m * (a * b) = (a * b) * m` hold true, since `a * b` commutes with every element in `S`.

In a semigroup, the centralizer of a set is closed under multiplication, i.e., if `a` and `b` are in the centralizer of a set `S`, then `a * b` is also in the centralizer of `S`.


theorem mem_upperBounds_image2_of_mem_lowerBounds :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Antitone (Function.swap f b)) →
        (∀ (a : α), Antitone (f a)) → a ∈ lowerBounds s → b ∈ lowerBounds t → f a b ∈ upperBounds (Set.image2 f s t) :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, where `α`, `β`, `γ` each have a preorder, given a function `f` from `α` and `β` to `γ`, sets `s` and `t` of `α` and `β` respectively, and elements `a` in `α` and `b` in `β`, if for all `b` in `β`, the function obtained by fixing `b` and varying the other argument of `f` is antitone (i.e., it reverses the order), and similarly, for all `a` in `α`, the function obtained by fixing `a` and varying the other argument of `f` is antitone, and if `a` is a lower bound of `s` and `b` is a lower bound of `t`, then the value `f(a, b)` is an upper bound of the image of the set `s × t` under `f`.

If functions `f` from a preordered type `α` to a preordered type `γ` with antitone components for every element, and `a` is a lower bound of a set `s` in `α` and `b` is a lower bound of set `t` in `β`, then `f(a, b)` is an upper bound of the image of `s × t` under `f`.


HasDerivWithinAt.smul

theorem HasDerivWithinAt.smul :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜} {𝕜' : Type u_1}
      [inst_3 : NontriviallyNormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜'] [inst_5 : NormedSpace 𝕜' F]
      [inst_6 : IsScalarTower 𝕜 𝕜' F] {c : 𝕜 → 𝕜'} {c' : 𝕜'},
      HasDerivWithinAt c c' s x →
        HasDerivWithinAt f f' s x → HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) s x :=
  by sorry

This theorem states that the derivative of a function, that is the product of two functions, within a given subset can be calculated if the derivatives of the individual functions within the same subset are known. More specifically, if `c` is a function from `𝕜` to `𝕜'` with derivative `c'` at a point `x` within a set `s`, and `f` is a function from `𝕜` to `F` with derivative `f'` at the same point `x` within the same set `s`, then the derivative of the function `(c y) * (f y)` at the point `x` within the set `s` is `(c x) * f' + c' * (f x)`. Here, `𝕜`, `𝕜'` and `F` are types over which certain algebraic structures like normed fields, normed add comm groups and normed spaces are defined, and `IsScalarTower 𝕜 𝕜' F` means that the scalar multiplication operations in these structures are compatible with each other.

If `c` and `f` are functions with derivatives `c'` and `f'` in the set `s` of a normed field `𝕜`, `𝕜'`, and `F` with compatible scalars, then the derivative of the product `(c ∘ y) * (f ∘ y)` at `x` in `s` is `(c x) * f' + c' * (f x)`.


theorem Even.pow_nonneg : ∀ {R : Type u_4} [inst : LinearOrderedRing R] {n : ℕ}, Even n → ∀ (a : R), 0 ≤ a ^ n := by
  sorry

The theorem `Even.pow_nonneg` states that for any type `R`, which is a linear ordered ring, and for any natural number `n` which is even, the nth power of any element `a` from the type `R` is non-negative, i.e., greater than or equal to zero. In other words, if `n` is an even number, then the nth power of any element in a linear ordered ring is always non-negative.

For every linear ordered ring R and every even natural number n, the nth power of any element a in R is non-negative (i.e., ≥ 0).


theorem Filter.le_def : ∀ {α : Type u} {f g : Filter α}, f ≤ g ↔ ∀ x ∈ g, x ∈ f := by sorry

This theorem, `Filter.le_def`, is about filters in a certain type `α`. A filter `f` is less than or equal to a filter `g` if and only if for every set `x` that belongs to the filter `g`, `x` also belongs to the filter `f`. In other words, filter `f` is a subset of filter `g` when every set in `g` is also found in `f`.

A filter `f` is less than or equal to a filter `g` if and only if every element in `g` belongs to `f`.


theorem Real.coe_comp_expOrderIso : Subtype.val ∘ ⇑Real.expOrderIso = Real.exp := by sorry

The theorem `Real.coe_comp_expOrderIso` asserts that the function composition of `Subtype.val` (which extracts the underlying real number of a subtype) and `Real.expOrderIso` (which is an order isomorphism between real numbers, ℝ, and the open interval (0, +∞)) equals the real exponential function (`Real.exp`). In other words, applying the exponential function to a real number, and then taking its underlying value, is the same as directly applying the real exponential function.

The theorem `Real.coe_comp_expOrderIso` states that the function `Subtype.val ∘ Real.expOrderIso` equals `Real.exp`, where `Subtype.val` extracts the underlying real number from a subtype and `Real.expOrderIso` is an order isomorphism between `ℝ` and `(0, +∞)`. Thus, `Subtype.val (Real.expOrderIso x) = Real.exp x` for all real numbers `x`.


theorem coe_nndist : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), ↑(nndist x y) = dist x y := by sorry

This theorem states that for any pseudometric space `α`, the nonnegative real number distance (`nndist`) between any two points `x` and `y` in `α`, when coerced to a real number (`↑`), is equal to the regular distance (`dist`) between `x` and `y`. In other words, in any pseudometric space, the nonnegative distance and the conventional distance between any two points are essentially the same, the only difference being their respective types (nonnegative real numbers vs. real numbers).

For any pseudometric space, the coerced non-negative real distance between two points equals the regular distance between them. (i.e., ↑(nndist x y) = dist x y)


/-- The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel.  -/
theorem ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib' :
    ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω]
      [inst_1 : StandardBorelSpace Ω] [inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} [inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω}
      {mβ : MeasurableSpace β} {f : β × Ω → F} [inst_5 : NormedSpace ℝ F] [inst_6 : CompleteSpace F],
      Measurable X →
        AEMeasurable Y μ →
          MeasureTheory.Integrable f (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ) →
            (MeasureTheory.condexp (MeasurableSpace.comap X mβ) μ fun a => f (X a, Y a)) =ᶠ[MeasureTheory.Measure.ae μ]
              fun a => ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a) :=
  by sorry

The theorem `ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib'` states that, for a given function `f` of the product `(X, Y)`, the conditional expectation of `f` is almost everywhere equal to the integral of the function `y ↦ f(X, y)` with respect to the `condDistrib` kernel. This is under the conditions that `X` is measurable, `Y` is almost everywhere measurable with respect to measure `μ`, and `f` is integrable with respect to the pushforward measure of the function mapping `a` to `(X a, Y a)`. The "almost everywhere" equality is with respect to the measure space defined by `μ` and the condition is expressed in terms of the `condDistrib` of `Y` and `X` with respect to measure `μ`.

For measurable functions `X` and almost everywhere measurable `Y` with respect to measure `μ`, and integrable `f` with respect to the pushforward measure of the map `a mapsto (X a, Y a)`, the almost everywhere equality holds between the conditional expectation of `f` given `Y` and the integral of `f(_, y)` with respect to the `condDistrib` kernel of `Y` with respect to `μ`.


theorem AffineSubspace.nonempty_iff_ne_bot :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] (Q : AffineSubspace k P), Set.Nonempty ↑Q ↔ Q ≠ ⊥ :=
  by sorry

This theorem, titled `AffineSubspace.nonempty_iff_ne_bot`, states that for any field `k`, any additive commutative group `V`, any `P` which is a module over `k` with `V` as its corresponding vector space (`V` is an additive torsor for `P`), and any affine subspace `Q` of `P`, the set `Q` is nonempty (i.e., there exists an element in `Q`) if and only if `Q` is not the bottom element (`⊥`, which represents the empty set in this context).

An affine subspace of a module over a field is nonempty if and only if it is not the empty set.


theorem Mathlib.Data.Nat.PartENat._auxLemma.16 : ∀ (x : ℕ), (↑x = ⊤) = False := by sorry

This theorem states that for any natural number 'x', the expression '↑x = ⊤' is always false. Here, '↑x' denotes the lifting of the natural number 'x' to the extended natural numbers (including infinity, denoted by '⊤'). In other words, no natural number can be equal to infinity.

The theorem asserts that for all natural numbers x, the lifted natural number ↑x is not equal to the top element ⊤.


theorem Mathlib.Data.Nat.PartENat._auxLemma.24 : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by sorry

This theorem states that for any proposition `b` and any type `α` that is nonempty (i.e., has at least one value), the type of functions from `α` to `b` is equivalent to `b` itself. In other words, regardless of what `α` is, if there is at least one value of type `α`, then a function that takes an input of type `α` and outputs a proposition `b` is itself effectively a proposition `b`. This reflects the intuition that if there's only one possibility for an input, then a function depending on that input is essentially the same as its output.

For any nonempty type `α`, the type of functions from `α` to a proposition `b` is equivalent to `b`.


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

This theorem states that for any type `R` that is an additive monoid with an identity element (i.e., has operations for addition that follow the rules of an additive monoid and has a defined "one" element), the sum of the additive identities of two natural numbers `m` and `n` is equal to the additive identity of their sum. In other words, when `m` and `n` are interpreted (coerced) as elements of `R`, their sum in `R` is the same as if you first added them within the natural numbers and then interpreted the result as an element of `R`. This is written in LaTeX as: \( \forall R, m, n \in \mathbb{N}\), if `R` is an additive monoid with one, then \( m + n = m + n \) when both sides are considered as elements in `R`.

For any additive monoid `R` with identity, the sum of two natural numbers `m` and `n` in `R` is equal to their sum in the natural numbers when interpreted as elements of `R`.


/-- If `u` is a monotone function with linear ordered codomain and the range of `u` is not bounded
above, then `Tendsto u atTop atTop`.  -/
theorem Filter.tendsto_atTop_atTop_of_monotone' :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : Preorder ι] [inst_1 : LinearOrder α] {u : ι → α},
      Monotone u → ¬BddAbove (Set.range u) → Filter.Tendsto u Filter.atTop Filter.atTop :=
  by sorry

The theorem states that for any function `u` from a type `ι` with a preorder to a type `α` with a linear order, if `u` is monotone and its range is not bounded above, then the function `u` tends to infinity as its input tends to infinity. In other words, if `u` is a monotone function and there is no upper limit to the values it can take, then as we increase the inputs to `u` without bound, the output of `u` will also increase without bound.

If `u` is a monotone function from a preordered type `ι` to an ordered type `α` with no upper bound on its image, then for any `x in ι`, `u(x)` approaches infinity as `x` approaches the limit point of `ι`.


theorem TensorProduct.ext_threefold :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {P : Type u_6} {Q : Type u_7}
      [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
      [inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q]
      {g h : TensorProduct R (TensorProduct R M N) P →ₗ[R] Q},
      (∀ (x : M) (y : N) (z : P), g ((x ⊗ₜ[R] y) ⊗ₜ[R] z) = h ((x ⊗ₜ[R] y) ⊗ₜ[R] z)) → g = h :=
  by sorry

This theorem, `TensorProduct.ext_threefold`, states that for any commutative semiring `R` and any modules `M`, `N`, `P`, and `Q` over `R`, if we have two linear maps `g` and `h` from the tensor product of `M`, `N`, and `P` to `Q`, then if these two maps agree on all triples of elements `(x, y, z)` where `x` is from `M`, `y` is from `N`, and `z` is from `P`, i.e., `g ((x ⊗ₜ[R] y) ⊗ₜ[R] z) = h ((x ⊗ₜ[R] y) ⊗ₜ[R] z)` for all `x`, `y`, `z`, then `g` and `h` are the same map, i.e., `g = h`. This is an extension property of tensor products in the context of module theory, ensuring the uniqueness of maps out of the tensor product given their values on generators.

Given a commutative semiring R and modules M, N, P, and Q over R, if two linear maps g and h from M ⊗ N ⊗ P to Q agree on all triples of elements, then g = h.


theorem upperCentralSeries_eq_top_iff_nilpotencyClass_le :
    ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G] {n : ℕ},
      upperCentralSeries G n = ⊤ ↔ Group.nilpotencyClass G ≤ n :=
  by sorry

The theorem `upperCentralSeries_eq_top_iff_nilpotencyClass_le` states that for any nilpotent group `G` and natural number `n`, the `n`th term of the upper central series of `G` being the whole group `G` is equivalent to the nilpotency class of `G` being less than or equal to `n`. Here, the upper central series of a group is a sequence of subgroups, and the nilpotency class of a group is the smallest `n` such that the `n`th term of the upper central series is `G`.

For any nilpotent group G and natural number n, the upper central series of G reaches G if and only if the nilpotency class of G is less than or equal to n.


padicValRat.inv

/-- A rewrite lemma for `padicValRat p (q⁻¹)` with condition `q ≠ 0`.  -/
theorem padicValRat.inv : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ), padicValRat p q⁻¹ = -padicValRat p q := by sorry

This is a theorem about the p-adic valuation of the reciprocal of a rational number. Specifically, for any prime number `p` and any non-zero rational number `q`, the p-adic valuation of `q`'s reciprocal (`q⁻¹`) is the negation of the p-adic valuation of `q` itself. The p-adic valuation is a measure of how divisible a number is by a given prime, and this theorem shows that inverting a rational number inverts its p-adic valuation.

For any prime number `p` and non-zero rational number `q`, the p-adic valuation of `q`'s reciprocal is the negation of the p-adic valuation of `q`.


theorem ContDiffBump.one_of_mem_closedBall :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E] {c : E}
      (f : ContDiffBump c) {x : E}, x ∈ Metric.closedBall c f.rIn → ↑f x = 1 :=
  by sorry

The theorem `ContDiffBump.one_of_mem_closedBall` states that for any type `E` that is a normed additive commutative group and a real normed space, and also has a smoothly varying ("C^∞-") bump function (`HasContDiffBump`), and for any center point `c` and bump function `f` over `c`, if a point `x` lies within the closed ball of radius `f.rIn` centered at `c` (meaning the distance from `x` to `c` is less than or equal to `f.rIn`), then the value of the bump function `f` at the point `x` is equal to 1. This implies that the bump function `f` equals 1 at all points within the given closed ball.

For any normed additive commutative group `E` with a smoothly varying bump function `f` over a center point `c`, if `x` is in the closed ball of radius `f.rIn` centered at `c`, then `f(x) = 1`.


theorem Option.pbind.proof_1 : ∀ {α : Type u_1} (a : α), some a = some a := by sorry

This theorem, `Option.pbind.proof_1`, asserts that for all types `α` and any element `a` of type `α`, an option containing `a` is equal to itself. In other words, any `some a` is equal to `some a`. This statement is essentially a formulation of the reflexivity property of equality in the context of option types in Lean 4.

For all types `α` and elements `a` of type `α`, the option `some a` is equal to `some a`. In Lean 4 syntax: `(Option.pbind _ (some a) (some a)).get = a`.


theorem UniformSpace.Completion.comap_coe_eq_uniformity :
    ∀ (α : Type u_1) [inst : UniformSpace α],
      Filter.comap (fun p => (↑α p.1, ↑α p.2)) (uniformity (UniformSpace.Completion α)) = uniformity α :=
  by sorry

This theorem states that for any type `α` equipped with a uniform space structure, the filter obtained by taking the preimage (comap) through the function that maps each pair of elements in `α` to a pair in the completion of `α` (using the canonical embedding `↑α`) applied to the uniformity of the completion of `α`, is equal to the original uniformity of `α`. In other words, the uniformity filter on the completion of `α` under this mapping corresponds exactly to the original uniformity filter of `α`. This theorem is essential in the analysis of uniform spaces and their completions, and provides a link between the original space and its completion.

For any uniform space `(α, Δ)`, the filter on `α × α` obtained by composing the diagonal map with the canonical embedding of `α` into its completion, is equal to the original uniformity filter `Δ`.


theorem smul_ball :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {c : 𝕜},
      c ≠ 0 → ∀ (x : E) (r : ℝ), c • Metric.ball x r = Metric.ball (c • x) (‖c‖ * r) :=
  by sorry

The theorem `smul_ball` states that for any non-zero scalar `c`, any point `x`, and any real number `r`, the scaled version of a metric ball centered at `x` with radius `r` is equal to the metric ball centered at the scaled point `c • x` with radius `‖c‖ * r`. Here `𝕜` represents the normed field, `E` represents the semi-normed additive commutative group, and `Metric.ball x r` denotes the set of all points `y` such that the distance between `y` and `x` is less than `r`. This theorem is a property in the context of normed spaces.

For any non-zero scalar `c` in a normed field `𝕜`, any point `x` in a semi-normed additive commutative group `E`, and any real number `r`, the metric ball `Metric.ball x r` is equal to `Metric.ball (c • x) (‖c��|| * r)`.


theorem TensorProduct.lid_tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
      (r : R), (TensorProduct.lid R M) (r ⊗ₜ[R] m) = r • m :=
  by sorry

The theorem `TensorProduct.lid_tmul` states that for any commutative semiring `R`, any module `M` over `R`, and any elements `m` in `M` and `r` in `R`, applying the left identity operation of the tensor product (`TensorProduct.lid R M`) to the tensor product of `r` and `m` (`r ⊗ₜ[R] m`) is equivalent to scalar multiplication of `m` by `r` (`r • m`). This essentially says that the scalar can be "pulled out" of the tensor product, reinforcing the idea that the base ring behaves like a left identity for the tensor product of modules, up to a linear equivalence.

For any commutative semiring `R`, module `M` over `R`, and elements `m in M` and `r in R`, `r ⊗ₜ[R] m = TensorProduct.lid R M r ⊗ₜ[R] m` is equivalent to `r • m`.


theorem Set.Icc.coe_zero : ∀ {α : Type u_1} [inst : OrderedSemiring α], ↑0 = 0 := by sorry

This theorem states that for any type `α` which is an ordered semiring, the coercion of the integer zero to this type equals the zero element of the semiring. In other words, when you take the integer zero and convert it into any instance of an ordered semiring (`α`), it remains the zero element in that semiring.

For any ordered semiring `α`, the coerced integer zero is equal to the semiring's additive identity.


theorem List.append_cancel_right_eq : ∀ {α : Type u_1} (as bs cs : List α), (as ++ bs = cs ++ bs) = (as = cs) := by
  sorry

This theorem states that for any type `α` and any three lists `as`, `bs`, and `cs` of type `α`, the equivalence of the concatenation of `as` and `bs` with the concatenation of `cs` and `bs` implies that `as` and `cs` are equal. In other words, if appending the same list `bs` to two other lists `as` and `cs` results in the same list, then `as` and `cs` must be the same.

If for any lists `as`, `bs`, and `cs` of type `α`, `as ++ bs = cs ++ bs` implies `as = cs`, then the theorem states that list concatenation is commutative and associative up to equality.


theorem totallyBounded_iff_subset :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {s : Set α},
      TotallyBounded s ↔ ∀ d ∈ uniformity α, ∃ t ⊆ s, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ d} :=
  by sorry

This theorem states that for any set `s` of a certain type `α`, where `α` is equipped with a uniform space structure, the set `s` is totally bounded if and only if for every entourage `d` in the uniformity of `α`, there exists a finite subset `t` of `s` such that every element of `s` is `d`-near to some element of `t`. More explicitly, for each `d` in the uniformity of `α`, there exists a finite set `t` such that `t` is a subset of `s`, and for every element in `s`, there exists an element in `t` such that the pair of this element and the element in `t` belongs to `d`.

A uniform space `(α, δ)` is totally bounded if and only if for every entourage `d` in `δ`, there exists a finite subset `t` of `α` such that every element in `α` is `d`-near to some element in `t`.


theorem MeasureTheory.FiniteMeasure.zero_testAgainstNN_apply :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] (f : BoundedContinuousFunction Ω NNReal),
      MeasureTheory.FiniteMeasure.testAgainstNN 0 f = 0 :=
  by sorry

The theorem `MeasureTheory.FiniteMeasure.zero_testAgainstNN_apply` states that for any measurable space `Ω` that also has a topological structure and any bounded continuous function `f` from `Ω` to nonnegative real numbers, if we pair the zero measure (a finite measure) with the function `f`, the result will always be zero. This is equivalent to saying that the Lebesgue integral of the function `f` with respect to the zero measure is zero.

For any measurable space with a topology and a bounded continuous function, the Lebesgue integral of the function with respect to the zero measure is zero.


theorem subset_sInf_of_within :
    ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s] {t : Set ↑s},
      Set.Nonempty t → BddBelow t → sInf (Subtype.val '' t) ∈ s → sInf (Subtype.val '' t) = ↑(sInf t) :=
  by sorry

This theorem, `subset_sInf_of_within`, states that for any type `α`, given a set `s` of this type with a preorder and an inhabited subtype, and another set `t` which is a subset of the subtype of `s`, if `t` is nonempty and bounded below, and if the greatest lower bound (infimum or `sInf`) of the image of `t` under the `Subtype.val` function is an element of `s`, then this greatest lower bound is equal to the infimum of `t` coerced into the base type. In other words, the theorem asserts that within a certain subset of a type, if conditions of non-emptiness, lower bound, and inhabitation are met, infimums in the subset and the larger set coincide.

If `s` is a non-empty subset of a type `α` with a preorder and an inhabited subtype, and `t` is a bounded below subset of `s`, such that the infimum of `t` in the subtype exists and is an element of `s`, then the infimum of `t` in the subtype equals the infimum of `t` coerced into the base type.


Hyperreal.IsSt.add

theorem Hyperreal.IsSt.add :
    ∀ {x y : ℝ*} {r s : ℝ}, Hyperreal.IsSt x r → Hyperreal.IsSt y s → Hyperreal.IsSt (x + y) (r + s) := by sorry

The theorem `Hyperreal.IsSt.add` states that for any hyperreal numbers `x` and `y`, and any real numbers `r` and `s`, if `x` is infinitesimally close to `r` and `y` is infinitesimally close to `s` (as defined by the `Hyperreal.IsSt` predicate), then the sum of `x` and `y` is infinitesimally close to the sum of `r` and `s`. This theorem essentially asserts the preservation of the "closeness" relation under addition in the hyperreal number system.

For any hyperreal numbers `x` and `y` infinitesimally close to real numbers `r` and `s` respectively, `x + y` is infinitesimally close to `r + s`.


/-- **Alias** of the reverse direction of `strictMono_toDual_comp_iff`. -/
theorem StrictAnti.dual_right :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictAnti f → StrictMono (⇑OrderDual.toDual ∘ f) :=
  by sorry

This theorem, "`StrictAnti.dual_right`", asserts that for any types `α` and `β` with preorders, and any function `f` from `α` to `β` that is strictly anti-monotone (meaning that if `a < b` then `f(b) < f(a)`), the composition of `f` with the identity function `OrderDual.toDual` (which is basically giving us the reverse order) yields a strictly monotone function. In other words, it says that reversing the order of the inputs to a strictly anti-monotone function gives a strictly monotone function.

If `f` is a strictly anti-monotone function between preordered types `α` and `β`, then the composition `f ∘ OrderDual.toDual` is a strictly monotone function.


/-- A real function into a finite dimensional real vector space with bounded variation on a set
is differentiable almost everywhere in this set.  -/
theorem LocallyBoundedVariationOn.ae_differentiableWithinAt_of_mem :
    ∀ {V : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
      {f : ℝ → V} {s : Set ℝ}, LocallyBoundedVariationOn f s → ∀ᵐ (x : ℝ), x ∈ s → DifferentiableWithinAt ℝ f s x :=
  by sorry

This theorem states that for any real-valued function `f` mapping into a finite dimensional real vector space `V`, if `f` has locally bounded variation on a set `s`, then `f` is differentiable almost everywhere within the set `s`. In simpler terms, if a function's output varies in a bounded manner within certain local regions of its domain, then the function is most likely differentiable at almost all points within those regions. This is a fundamental result in real analysis and the theory of functions of a real variable.

If a real-valued function on a finite dimensional real vector space has locally bounded variation, then it is differentiable almost everywhere.


theorem FiniteField.odd_card_of_char_ne_two :
    ∀ {F : Type u_3} [inst : Field F] [inst_1 : Fintype F], ringChar F ≠ 2 → Fintype.card F % 2 = 1 := by sorry

This theorem states that for any finite field 'F', if the unique characteristic of the field (denoted by 'ringChar F') is not equal to 2, then the number of elements in the field (denoted by 'Fintype.card F') is odd. More formally, the cardinality of the field 'F' modulo 2 equals 1.

For any finite field 'F' with characteristic different from 2, the number of elements in 'F' is odd.


theorem Mathlib.Probability.Independence.Basic._auxLemma.1 :
    ∀ {α : Type u} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) = p a := by sorry

This theorem from the Mathlib.Probability.Independence.Basic library in Lean 4 states that for any type `α`, element `a` of that type, and property `p` that elements of type `α` might have, the property that all elements `x` of type `α` in the pure singleton set `{a}` satisfy `p` is equivalent to `a` itself satisfying `p`. Intuitively, this theorem expresses that if a property is true for all elements in a singleton set, it must be true for that single element. It appears to be a supporting lemma used in discussions of probability and independence.

For any type `α`, element `a` of `α`, and property `p`: the property `p` holds for all elements in the singleton set `{a}` if and only if `p` holds for `a`.


HasDerivWithinAt.div

theorem HasDerivWithinAt.div :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {𝕜' : Type u_1}
      [inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'},
      HasDerivWithinAt c c' s x →
        HasDerivWithinAt d d' s x →
          d x ≠ 0 → HasDerivWithinAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) s x :=
  by sorry

This theorem states that for any two functions `c` and `d` of some type `𝕜` to `𝕜'`, where `𝕜` and `𝕜'` are nontrivially normed fields, `c` and `d` both have derivatives `c'` and `d'` at a point `x` within a subset `s` of `𝕜`, and the value of `d` at `x` is not zero, then the quotient function `(c y) / (d y)` has a derivative at `x` within the subset `s`. The derivative of the quotient function at `x` is given by the quotient rule for derivatives, `(c' * d x - c x * d') / (d x) ^ 2`.

If `c` and `d` are differentiable functions from a nontrivially normed field `𝕜` to another such field `𝕜'`, `d(x) ≠ 0` for some `x` in a subset `s` of `𝕜`, then the quotient function `c / d` is differentiable at `x` in `s` and its derivative is `(c' * d x - c x * d') / (d x) ^ 2`.


theorem IsClosed.tendsto_coe_cofinite_of_discreteTopology :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
      IsClosed s → DiscreteTopology ↑s → Filter.Tendsto Subtype.val Filter.cofinite (Filter.cocompact X) :=
  by sorry

The theorem `IsClosed.tendsto_coe_cofinite_of_discreteTopology` states that for any type `X` equipped with a topological space structure, and any set `s` in `X`, if `s` is a closed set and the induced topology on `s` is discrete, then the natural function that sends an element of `s` to the same element in `X` (termed `Subtype.val`) is a function that tends to pull back complements of compact sets (termed `Filter.cocompact X`) to subsets whose complements are finite (termed `Filter.cofinite`). In other words, for every open set in `X` whose complement is compact, the preimage of that set under the function `Subtype.val` is an open set in `s` whose complement is finite. This is a generalization of the fact that in a discrete space, every set is open, and hence, closed, and in finite sets, every filter converges.

Given a topological space `(X : Type)` and a closed subset `s : X`, if the topology on `s` is discrete, then the inclusion map `s ↪ X` is continuous and sends compact sets to cofinite sets.


theorem max_add_add_right :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Add α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      max (a + c) (b + c) = max a b + c :=
  by sorry

The theorem `max_add_add_right` states that for any type `α` that has a linear order and an addition operation, and where the order respects the addition (that is, for any two elements `x` and `x_1` in `α`, if `x` is less than or equal to `x_1`, then `x + y` is less than or equal to `x_1 + y` for any `y` in `α`), then the maximum of `a + c` and `b + c` is equal to the maximum of `a` and `b` plus `c`, for any elements `a`, `b`, and `c` in `α`. In mathematical terms, this theorem is saying that $\max(a + c, b + c) = \max(a, b) + c$ for any numbers `a`, `b`, and `c`, given a numerical type `α` with the properties described.

For any type `α` with a linear order and addition operation where `x ≤ x_1` implies `x + y ≤ x_1 + y` for all `x`, `x_1`, and `y` in `α`, the maximum of `a + c` and `b + c` equals the maximum of `a` and `b` plus `c`, for any `a`, `b`, and `c` in `α`. (Or, mathematically: $\max(a + c, b + c) = \max(a, b) + c$ for all `a`, `b`, and `c` in `α`.)


theorem Ordinal.cof_lsub_le_lift :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u v}), Ordinal.cof (Ordinal.lsub f) ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) :=
  by sorry

The theorem `Ordinal.cof_lsub_le_lift` states that for any type `ι` and any function `f` from `ι` to the set of ordinals, the cofinality of the least strict upper bound of the image of `f` is less than or equal to the cardinality of `ι` lifted to the maximum of `v` and `u`. In simpler terms, it establishes a bound on the smallest size of an unbounded subset (cofinality) of the least upper bound of a set of ordinals, in terms of the size of the set from which the ordinals are drawn.

The cofinality of the least upper bound of a function from a type `ι` to ordinals is less than or equal to the cardinality of `ι` lifted to the maximum of the cofinalities of `v` and `u`.


theorem StarConvex.add_smul_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {x y : E}
      {s : Set E}, StarConvex 𝕜 x s → x + y ∈ s → ∀ {t : 𝕜}, 0 ≤ t → t ≤ 1 → x + t • y ∈ s :=
  by sorry

This theorem, `StarConvex.add_smul_mem`, states that given a star-convex set `s` in an ordered ring `𝕜` and a module `E` (a structure that behaves like a vector space), if a point `x` is in `s` and the set is star-convex at `x`, then for any point `y` in the same set and a non-negative scalar `t` less than or equal to `1`, the point obtained by adding `x` and the scalar multiple of `y` (`x + t • y`) is also in the set `s`. In other words, in a star-convex set, any point on the line segment between `x` and `y` (where `x` is a point in the set and `y` is any other point in the set) is also in the set.

Given a star-convex set `s` in an ordered ring `𝕜` and an module `E`, if `x` is in `s`, `x` is star-convex at `x`, and `y` is also in `s`, then `x + t • y` is in `s` for all `t ∈ 𝕜` with `0 ≤ t ≤ 1`.


theorem LinearMap.IsSymmetric.orthogonalFamily_eigenspaces' :
    ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {T : E →ₗ[𝕜] E},
      LinearMap.IsSymmetric T →
        OrthogonalFamily 𝕜 (fun μ => ↥(Module.End.eigenspace T (↑T μ))) fun μ =>
          Submodule.subtypeₗᵢ (Module.End.eigenspace T (↑T μ)) :=
  by sorry

This theorem states that for any type `𝕜` that behaves like a real or complex number (i.e., `𝕜` is `RCLike`), and any type `E` that forms a normed additive commutative group and an inner product space over `𝕜`, if we have a symmetric linear map `T` from `E` to `E` (i.e., `⟪T x, y⟫ = ⟪x, T y⟫` for all `x`, `y` in `E`), then the family of eigenspaces of `T` is orthogonal. Here, an eigenspace of `T` for a scalar `μ` consists of all vectors `x` such that `T x = μ • x`. In more detail, the theorem establishes that for each scalar `μ`, the elements of the eigenspace (which is a submodule of `E`) can be treated as a linearly independent set under the inner product (i.e., they form an orthogonal family), where the inner product on the eigenspace is induced by the natural embedding of the eigenspace into `E`.

For any `RCLike` type `𝕜`, normed additive commutative group and inner product space `E` over `𝕜`, and symmetric linear map `T` from `E` to `E`, the eigenspaces of `T` are orthogonal under the induced inner product.


theorem Real.abs_le_sqrt : ∀ {x y : ℝ}, x ^ 2 ≤ y → |x| ≤ Real.sqrt y := by sorry

The theorem `Real.abs_le_sqrt` states that for all real numbers `x` and `y`, if the square of `x` is less than or equal to `y`, then the absolute value of `x` is less than or equal to the square root of `y`. In other words, given any two real numbers, if the square of the first is no greater than the second, the magnitude of the first number will not exceed the square root of the second number.

For all real numbers x and y, if x^2 ≤ y then |x| ≤ √y.


theorem mul_inv_le_inv_mul_iff :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :=
  by sorry

The theorem `mul_inv_le_inv_mul_iff` states that for any type `α` that forms a group and has a less than or equal to relation (`LE`) defined on it, if it satisfies two specific covariance properties, then for any four elements `a`, `b`, `c` and `d` of this type, the inequality `a * inverse of b` is less than or equal to `inverse of d * c` if and only if `d * a` is less than or equal to `c * b`. Here, `inverse` refers to the inverse operation in the group. The covariance properties are related to the interaction of the multiplication operation and the less than or equal to relation in the group.

For all groups α with a defined LE relation, if multiplication is LE-covariant and inverse-preserving, then for all a, b, c, d ∈ α, a * b^-1 ≤ c * d^-1 if and only if d * a ≤ c * b.


theorem WithTop.sInf_empty : ∀ {α : Type u_5} [inst : InfSet α], sInf ∅ = ⊤ := by sorry

This theorem states that for any type `α` where an infimum (greatest lower bound) of a set can be defined, the infimum of an empty set is the greatest element in the partially ordered set of elements extended with a top element (`WithTop`). In other words, in the extended set `WithTop α`, the infimum of an empty set is always the top element (`⊤`). This aligns with the standard mathematical convention where the infimum of an empty set in a set extended with a top element is the top element itself.

In any partially ordered type `α` with a top element `⊤`, the infimum of an empty set equals `⊤`.


IsLowerSet.preimage

theorem IsLowerSet.preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
      IsLowerSet s → ∀ {f : β → α}, Monotone f → IsLowerSet (f ⁻¹' s) :=
  by sorry

This theorem states that the preimage of a lower set under a monotone function is also a lower set. More specifically, given a set `s` of elements from a partially ordered type `α`, if `s` is a lower set, and we have a function `f` from a partially ordered type `β` to `α` that is monotone (meaning if `a ≤ b` then `f(a) ≤ f(b)`), then the preimage of `s` under `f` (which is the set of all elements from `β` that `f` maps into `s`) is also a lower set. In other words, if `b` is an element of this preimage and `a` is any element from `β` such that `a ≤ b`, then `a` is also in the preimage, thus making the preimage a lower set.

If `s` is a lower set in a partially ordered type `α` and `f` is a monotone function from a partially ordered type `β` to `α`, then the preimage of `s` under `f` is a lower set in `β`.


theorem AlgebraicGeometry.rangeIsAffineOpenOfOpenImmersion :
    ∀ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine X] (f : X ⟶ Y)
      [H : AlgebraicGeometry.IsOpenImmersion f],
      AlgebraicGeometry.IsAffineOpen (AlgebraicGeometry.Scheme.Hom.opensRange f) :=
  by sorry

The theorem `AlgebraicGeometry.rangeIsAffineOpenOfOpenImmersion` states that for any two algebraic schemes `X` and `Y`, where `X` is an affine scheme, and a morphism `f` from `X` to `Y` which is an open immersion, the image of the open immersion `f` as an open set in `Y` is an affine open subset. In simpler words, the theorem asserts that the range of an open immersion from an affine scheme is an affine open subset of the codomain scheme.

Given an affine scheme X and a morphism f from X to a scheme Y that is an open immersion, the image of f as an open subset in Y is an affine open subset.


Finset.Nonempty.bex

theorem Finset.Nonempty.bex : ∀ {α : Type u_1} {s : Finset α}, s.Nonempty → ∃ x, x ∈ s := by sorry

This theorem states that for any nonempty finite set `s` of an arbitrary type `α`, there exists an element `x` that belongs to `s`. In other words, if a finite set is not empty, we can always find at least one element in the set. This corresponds to the intuitive understanding of non-emptiness: a set is nonempty if and only if it contains at least one element.

For any finite non-empty set `s` in type `α`, there exists an element `x ∈ s`.


/-- This is Exercise 1.2.1 from [tao2010]. It allows you to express integration of a measurable
function with respect to `(μ.withDensity f)` as an integral with respect to `μ`, called the base
measure. `μ` is often the Lebesgue measure, and in this circumstance `f` is the probability density
function, and `(μ.withDensity f)` represents any continuous random variable as a
probability measure, such as the uniform distribution between 0 and 1, the Gaussian distribution,
the exponential distribution, the Beta distribution, or the Cauchy distribution (see Section 2.4
of [wasserman2004]). Thus, this method shows how to one can calculate expectations, variances,
and other moments as a function of the probability density function.
  -/
theorem MeasureTheory.lintegral_withDensity_eq_lintegral_mul :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) {f : α → ENNReal},
      Measurable f → ∀ {g : α → ENNReal}, Measurable g → ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ :=
  by sorry

This theorem, Exercise 1.2.1 from [tao2010], relates to the integration of a measurable function with respect to a measure, specifically the measure `(μ.withDensity f)`. It states that for any given measure `μ`, often the Lebesgue measure, and any given measurable functions `f` and `g`, the integral with respect to `(μ.withDensity f)` of `g` is equal to the integral with respect to `μ` of the product of `f` and `g`. This is particularly relevant when `f` represents a probability density function and `(μ.withDensity f)` represents a continuous random variable as a probability measure, such as various standard distributions (uniform, Gaussian, exponential, Beta, Cauchy). Hence, this theorem provides a method for calculating expectations, variances, and other statistical moments as a function of the probability density function.

For any measurable functions `f` and `g` and measure `μ`, the integral of `g` with respect to the measure `(μ.withDensity f)` equals the integral of the product of `f` and `g` with respect to `μ`.


theorem LiouvilleWith.sub_rat_iff : ∀ {p x : ℝ} {r : ℚ}, LiouvilleWith p (x - ↑r) ↔ LiouvilleWith p x := by sorry

This theorem states that for any real numbers `p` and `x`, and any rational number `r`, the number `x` is a Liouville number with exponent `p`, if and only if the number `x - r` is a Liouville number with the same exponent `p`. In other words, subtracting a rational number from a Liouville number results in another Liouville number with the same exponent.

If `x` is a Liouville number with exponent `p`, then so is `x - r` for any rational number `r` (i.e., Liouville numbers are closed under subtraction of rational numbers with the same exponent).


theorem HasStrictFDerivAt.approximates_deriv_on_open_nhds :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E ≃L[𝕜] F} {a : E},
      HasStrictFDerivAt f (↑f') a →
        ∃ s, a ∈ s ∧ IsOpen s ∧ ApproximatesLinearOn f (↑f') s (‖↑(ContinuousLinearEquiv.symm f')‖₊⁻¹ / 2) :=
  by sorry

This theorem states that for a function `f: E → F` having a strict Frechet derivative `f'` at a point `a` in a normed space over a nontrivially normed field, there exists a set `s` such that `a` is in `s`, `s` is open in the topological space, and `f` approximates linearly on `s` with error term bounded by half the inverse of the norm of the continuous linear inverse of `f'`. This essentially means that around every point where the function `f` has a derivative, we can find an open set where the function behaves nearly linearly, with a precise bound given on the error.

Given a function `f: E → F` with a strict Frechet derivative `f'` at a point `a` in a normed space over a nontrivially normed field, there exists an open set `s` containing `a` such that `f` approximates `f(x) ≈ f(a) + f'(a)(x - a)` for all `x ∈ s`, with an error bound `||(x - a) - f'(a)⁻¹(f(x) - f(a) - f'(a)(x - a))|| ≤ ||f'(a)⁻¹||/2`.


theorem Nat.factorial_mul_factorial_dvd_factorial :
    ∀ {n k : ℕ}, k ≤ n → Nat.factorial k * Nat.factorial (n - k) ∣ Nat.factorial n := by sorry

The theorem `Nat.factorial_mul_factorial_dvd_factorial` states that for any two natural numbers `n` and `k` where `k` is less than or equal to `n`, the product of the factorial of `k` and the factorial of the difference between `n` and `k`, divides the factorial of `n`. This can be written in mathematical notation as: if $0 \leq k \leq n$, then $k! \cdot (n - k)!$ divides $n!$.

For any natural numbers $n \geq k \geq 0$, $k! \cdot (n-k)!$ divides $n!$.


theorem toIcoMod_eq_iff :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) {a b c : α},
      toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p :=
  by sorry

This theorem states that for any type `α` which forms a linear ordered additive commutative group and is Archimedean, given a positive `p`, and any three elements `a`, `b`, `c` of type `α`, the function `toIcoMod` applied to `p`, `a` and `b` being equal to `c` is equivalent to `c` belonging to the left-closed right-open interval from `a` to `a + p` and there existing an element `z` such that `b = c + z • p`. In simpler terms, it says that a number `b` reduced to the interval `a` to `a + p` equals `c` if and only if `c` lies in the interval `a` to `a + p` and `b` can be expressed as `c` plus some multiple of `p`.

For any Archimedean, additively commutative and linearly ordered type `α` and positive element `p` in `α`, the element `c` belongs to the left-closed right-open interval `[a, a + p)` if and only if there exists an element `z` such that `b = c + z * p`.


theorem AbstractCompletion.continuous_map :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α) {β : Type u_2} [inst_1 : UniformSpace β]
      (pkg' : AbstractCompletion β) (f : α → β), Continuous (AbstractCompletion.map pkg pkg' f) :=
  by sorry

The theorem `AbstractCompletion.continuous_map` asserts that for any two types `α` and `β` equipped with Uniform Spaces, and their respective abstract completions `pkg` and `pkg'`, if there exists a function `f` from `α` to `β`, then the function obtained by mapping `f` to these completions, which is `AbstractCompletion.map pkg pkg' f`, is continuous. In other words, this theorem is about the continuity preservation property of the process of lifting maps to completions in the context of abstract completions and Uniform Spaces.

Given types `α` and `β` with Uniform Spaces structures, and functions `f: α → β`, the function `AbstractCompletion.map` preserves continuity: `AbstractCompletion.map ℵ ℵ' f` is continuous, where `ℵ` and `ℵ'` are the respective abstract completions.


theorem Multiset.antidiagonal_coe' :
    ∀ {α : Type u_1} (l : List α), Multiset.antidiagonal ↑l = ↑(List.revzip (Multiset.powersetAux' l)) := by sorry

The theorem `Multiset.antidiagonal_coe'` states that for any type `α` and any list `l` of type `α`, the antidiagonal of the multiset corresponding to `l` is equivalent to the list of reversed pairs of the powerset of `l`, where both are viewed as multisets. The antidiagonal of a multiset `s` includes all pairs `(t₁, t₂)` such that `t₁ + t₂ = s`, counted with multiplicities. This theorem links the antidiagonal of a multiset to operations on the list from which the multiset originated, specifically, generating the powerset and pairing each element with its corresponding element in the reverse list.

The antidiagonal of a multiset formed from a list is equal to the multiset of reversed element pairs from the list's powerset.


theorem PrincipalIdealRing.isMaximal_of_irreducible :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsPrincipalIdealRing R] {p : R},
      Irreducible p → Ideal.IsMaximal (Submodule.span R {p}) :=
  by sorry

This theorem states that in any Principal Ideal Ring `R`, which is a commutative ring where every ideal is principal, if `p` is an irreducible element of `R`, then the ideal generated by `p` (that is, the smallest submodule of `R` that contains `p`, denoted by `Submodule.span R {p}`) is a maximal ideal. An irreducible element is an element that cannot be expressed as the product of two other non-unit elements, and a maximal ideal is an ideal that is as large as possible without being equal to the whole ring.

In a commutative Principal Ideal Ring `R`, an irreducible element `p` generates a maximal ideal.


theorem CategoryTheory.Limits.WidePullback.lift_base :
    ∀ {J : Type w} {D : Type u_1} [inst : CategoryTheory.Category.{v₂, u_1} D] {B : D} {objs : J → D}
      (arrows : (j : J) → objs j ⟶ B) [inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows] {X : D} (f : X ⟶ B)
      (fs : (j : J) → X ⟶ objs j) (w : ∀ (j : J), CategoryTheory.CategoryStruct.comp (fs j) (arrows j) = f),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.lift f fs w)
          (CategoryTheory.Limits.WidePullback.base arrows) =
        f :=
  by sorry

This theorem, `CategoryTheory.Limits.WidePullback.lift_base`, states that in any category with a wide pullback along a collection of arrows from objects to a base object `B`, if we have an object `X` and morphisms from `X` to each object in the collection such that each composition of a morphism from `X` to an object in the collection and the arrow from that object to `B` is equal to a given morphism from `X` to `B`, then the composition of the lift (constructed from these morphisms from `X` and the equality conditions) and the base morphism of the wide pullback is equal to the given morphism from `X` to `B`. In simpler terms, it's saying that a certain diagram involving the wide pullback, the object `X` and the given morphisms commutes.

In a category with wide pullbacks, if for each object in a collection, there exists a morphism from an object X to it such that the composition of the morphism from X to the object and the arrow from that object to the base object is equal to a given morphism from X to the base object, then the lift constructed from these morphisms commutes with the base morphism of the wide pullback, resulting in the equality of the given morphism from X to the base object.