theorem Monoid.Coprod.fst_prod_snd :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N],
      MonoidHom.prod Monoid.Coprod.fst Monoid.Coprod.snd = Monoid.Coprod.toProd :=
  by sorry

This theorem states that for any two types `M` and `N` that form monoids, the product of the natural projections `Monoid.Coprod.fst` and `Monoid.Coprod.snd`, which are homomorphisms from the coproduct monoid `M * N` to `M` and `N` respectively, is equal to the natural projection `Monoid.Coprod.toProd`, which is a homomorphism from the coproduct monoid `M * N` to the product `M × N`. In other words, applying `Monoid.Coprod.fst` and `Monoid.Coprod.snd` to an element of `M * N` and combining them into a pair is the same as directly applying `Monoid.Coprod.toProd` to that element.

The natural projections `Monoid.Coprod.fst` and `Monoid.Coprod.snd` of a monoidal coproduct are equal to the projection map `Monoid.Coprod.toProd`, i.e., `Monoid.Coprod.fst (x, y) = x`, `Monoid.Coprod.snd (x, y) = y`, and `Monoid.Coprod.toProd (x, y) = (x, y)` for all `x : M` and `y : N`, where `M` and `N` are monoids.


theorem disjoint_lift'_closure_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T25Space X] {x y : X},
      Disjoint (Filter.lift' (nhds x) closure) (Filter.lift' (nhds y) closure) ↔ x ≠ y :=
  by sorry

The theorem states that for any topological space `X` that is also a T2.5 space, and for any two elements `x` and `y` of `X`, the closure of the neighborhood filters at `x` and `y` are disjoint if and only if `x` and `y` are not equal. In other words, if we have two distinct points in a T2.5 space, then the smallest closed sets containing the open sets around these points do not overlap. In this context, 'disjoint' means that the infimum (greatest lower bound) of the two sets is the bottom element of the lattice of sets, which corresponds to the empty set in this case.

In a T2.5 topological space, the closure of the neighborhood filters at distinct points are disjoint.


IsNilpotent.map

theorem IsNilpotent.map :
    ∀ {R : Type u_1} {S : Type u_2} [inst : MonoidWithZero R] [inst_1 : MonoidWithZero S] {r : R} {F : Type u_3}
      [inst_2 : FunLike F R S] [inst_3 : MonoidWithZeroHomClass F R S], IsNilpotent r → ∀ (f : F), IsNilpotent (f r) :=
  by sorry

The theorem `IsNilpotent.map` states that given two types `R` and `S` that are both monoids with zero, an object `r` of type `R`, and a function-like object `f` of type `F` that maps from `R` to `S`, if `r` is a nilpotent element in `R` (i.e., there exists a natural number `n` such that `r` raised to the power `n` equals zero), then `f(r)` is also a nilpotent element in `S`. Essentially, the nilpotency property is preserved under the map `f`.

If `r` is a nilpotent element in the monoid `(R, ∘)` with zero, then `f(r)` is a nilpotent element in the monoid `(S, ∘)` with zero, where `f : R → S` is a function-like object.


theorem Polynomial.degree_smul_le :
    ∀ {R : Type u} [inst : Semiring R] (a : R) (p : Polynomial R), Polynomial.degree (a • p) ≤ Polynomial.degree p := by
  sorry

The theorem `Polynomial.degree_smul_le` states that for any semiring `R`, for any element `a` of `R`, and for any polynomial `p` over `R`, the degree of the polynomial resulting from the scalar multiplication of `p` by `a`, denoted as `a • p`, is less than or equal to the degree of the original polynomial `p`. In other words, scaling a polynomial by a scalar does not increase its degree.

For any semiring R, element a of R, and polynomial p over R, the degree of a • p is less than or equal to the degree of p.


theorem isPreconnected_iff_ordConnected :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {s : Set α}, IsPreconnected s ↔ Set.OrdConnected s :=
  by sorry

The theorem `isPreconnected_iff_ordConnected` states that for a set `s` of a type `α`, under the conditions that `α` is a conditionally complete linear order, it has a topological space structure, an order topology and it's densely ordered, then `s` is preconnected if and only if `s` is order connected. In other words, in this mathematical context, a set is preconnected (there is no non-trivial open partition of the set) if and only if it is order connected (for any two points in the set, all the points between them are also in the set).

In a densely ordered, conditionally complete linear order `α` with order topology, a set `s` is preconnected if and only if it is order connected.


theorem dist_mul_mul_le :
    ∀ {E : Type u_6} [inst : SeminormedCommGroup E] (a₁ a₂ b₁ b₂ : E),
      dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ :=
  by sorry

This theorem states that in the context of a seminormed commutative group `E`, for any four elements `a₁`, `a₂`, `b₁`, `b₂` of `E`, the distance between the product `a₁ * a₂` and the product `b₁ * b₂` is less than or equal to the sum of the distances between `a₁` and `b₁`, and `a₂` and `b₂`. This is a property akin to the triangle inequality in a metric space.

In a seminormed commutative group, the triangle inequality for the product holds: ||a₁ * a₂ - b₁ * b₂|| ≤ ||a₁ - b₁|| + ||a₂ - b₂||.


theorem Real.le_log_iff_exp_le : ∀ {x y : ℝ}, 0 < y → (x ≤ Real.log y ↔ Real.exp x ≤ y) := by sorry

This theorem states that for every pair of real numbers `x` and `y`, given `y` is greater than 0, `x` is less than or equal to the logarithm of `y` if and only if the exponential of `x` is less than or equal to `y`. In other words, it establishes a relationship between the exponential and logarithmic functions on the real numbers: if the exponential of a number is bounded by another positive number, then the original number is bounded by the logarithm of the second number, and vice versa.

For all real numbers x and y with y > 0, x <= log y if and only if exp x <= y.


theorem IntermediateField.map_le_iff_le_comap :
    ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
      [inst_3 : Algebra K L] [inst_4 : Algebra K L'] {f : L →ₐ[K] L'} {s : IntermediateField K L}
      {t : IntermediateField K L'}, IntermediateField.map f s ≤ t ↔ s ≤ IntermediateField.comap f t :=
  by sorry

The theorem `IntermediateField.map_le_iff_le_comap` states that for any fields `K`, `L` and `L'`, with `L` and `L'` being extensions of `K`, any `K`-algebra homomorphism `f` from `L` to `L'`, and any intermediate fields `s` in `L` and `t` in `L'`, the image of `s` under `f` is a subset of `t` if and only if `s` is a subset of the preimage of `t` under `f`. In other words, this theorem describes a relationship between intermediate fields under a homomorphism and its inverse operation.

For any fields K, L, L', homomorphism f from L to L', and intermediate fields s in L and t in L', the image of s under f is a subset of t if and only if s is a subset of the preimage of t under f.


/-- If a direct sum of submodules is internal then the submodules span the module.  -/
theorem DirectSum.IsInternal.submodule_iSup_eq_top :
    ∀ {R : Type u} [inst : Semiring R] {ι : Type v} [dec_ι : DecidableEq ι] {M : Type u_1} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {A : ι → Submodule R M}, DirectSum.IsInternal A → iSup A = ⊤ :=
  by sorry

This theorem states that if a direct sum of submodules is internal, then these submodules span the entire module.

More specifically, for any semiring `R`, and any type `ι` with decidable equality, given a module `M` over `R` that is an additive commutative monoid, and a family `A` of submodules of `M` indexed by `ι`, if the direct sum of the submodules in `A` is internal, then the supremum of the submodules in `A`, denoted as `iSup A`, equals the entire module `M`, denoted as `⊤`. This essentially means that the submodules in `A` cover the whole module `M`.

If `M` is a module over a semiring `R` with decidable equality, and `A` is a family of submodules of `M` whose internal direct sum equals `M`, then the supremum of `A` equals `M`.


theorem Composition.sum_blocksFun :
    ∀ {n : ℕ} (c : Composition n), (Finset.sum Finset.univ fun i => Composition.blocksFun c i) = n := by sorry

The theorem `Composition.sum_blocksFun` states that for any natural number `n` and any composition `c` of `n`, the sum of the values of the `blocksFun` function applied to each element in the universal finite set is equal to `n`. In other words, if you take a composition of a number, transform each block of the composition using the `blocksFun` function, and add up all the results, you'll get the original number back.

For any natural number `n` and composition `c` of `n`, the sum of applying the function `blocksFun` to each block in `c` equals `n`.


/-- **Fundamental theorem of arithmetic** -/
theorem Nat.factors_unique :
    ∀ {n : ℕ} {l : List ℕ}, List.prod l = n → (∀ p ∈ l, Nat.Prime p) → List.Perm l (Nat.factors n) := by sorry

The theorem `Nat.factors_unique` represents the Fundamental Theorem of Arithmetic. It states that for any natural number `n` and any list of natural numbers `l`, if the product of the elements in `l` equals `n` and each number `p` in `l` is prime, then `l` is a permutation of the prime factorization of `n`. In other words, every natural number has a unique prime factorization (up to the order of the factors).

Every natural number has a unique prime factorization.


/-- The map `(r ≃ s) → (r → s)` is injective.  -/
theorem Equiv.coe_fn_injective : ∀ {α : Sort u} {β : Sort v}, Function.Injective fun e => ⇑e := by sorry

The theorem `Equiv.coe_fn_injective` asserts that for any sorts `α` and `β`, the function that maps an equivalence `e : α ≃ β` to its corresponding function `⇑e : α → β` is injective. In other words, if two equivalences between `α` and `β` induce the same function from `α` to `β`, then the two equivalences were in fact the same.

If two functions `e1, e2 : α → β` are equal, then the corresponding equivalences `e1 : α ≃ β` and `e2 : α ≃ β` are equal.


theorem Seminorm.continuousAt_zero' :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ},
      Seminorm.closedBall p 0 r ∈ nhds 0 → ContinuousAt (⇑p) 0 :=
  by sorry

This theorem states that for a given nontrivial normed field `𝕜`, an additive commutative group `E` with a scalar multiplication operation by `𝕜` that forms a module, and a topological structure on `E` that allows for continuous scalar multiplication, if the closed ball of radius `r` at `0` with respect to a seminorm `p` is in the neighborhood of `0`, then the function given by the seminorm `p` is continuous at `0`. This essentially means that as we approach `0` from any direction within this closed ball, the value of the seminorm function approaches the value at `0` continuously, without any abrupt changes or discontinuity.

If a normed module `(𝕜, E, ∗)` over a nontrivial normed field `𝕜` with continuous scalar multiplication has a seminorm `p` such that the closed ball `B(0, r)` is in the neighborhood of `0`, then `p` is continuous at `0`.


theorem compl_eq_comm : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], xᶜ = y ↔ yᶜ = x := by sorry

This theorem states that for any type `α` equipped with a Boolean algebra structure, and any two elements `x` and `y` of this type, the complement of `x` equals `y` if and only if the complement of `y` equals `x`. In mathematical terms, if `x` and `y` are elements of a Boolean algebra, then the complement of `x` (`xᶜ`) is equal to `y` if and only if the complement of `y` (`yᶜ`) is equal to `x`.

For any Boolean algebra `α`, and elements `x, y` in `α`, `xᶜ = y` if and only if `yᶜ = x`.


theorem CategoryTheory.unit_transferNatTransSelf :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D}
      {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (f : L₂ ⟶ L₁) (X : C),
      CategoryTheory.CategoryStruct.comp (adj₁.unit.app X)
          (((CategoryTheory.transferNatTransSelf adj₁ adj₂) f).app (L₁.obj X)) =
        CategoryTheory.CategoryStruct.comp (adj₂.unit.app X) (R₂.map (f.app X)) :=
  by sorry

The theorem `CategoryTheory.unit_transferNatTransSelf` states that for any two categories `C` and `D`, with `C` of type `u₁` and `D` of type `u₂`, and with category structures given by `inst` and `inst_1` respectively, for any two functors `L₁`, `L₂` from `C` to `D` and any two functors `R₁`, `R₂` from `D` to `C`, and for any natural transformations `f : L₂ ⟶ L₁`, if `L₁` is left adjoint to `R₁` (denoted `L₁ ⊣ R₁`) and `L₂` is left adjoint to `R₂` (denoted `L₂ ⊣ R₂`), then for any object `X` of `C`, the composition of the unit of the adjunction `adj₁` at `X` with the application of the natural transformation resulting from transferring `adj₁` to `adj₂` via `f` to `L₁.obj X` is equal to the composition of the unit of the adjunction `adj₂` at `X` with the mapping of the functor `R₂` applied to `f.app X`.

For categories C and D, functors L₁, L₂, R₁, R₂ between them, and given left adjoints L₁ ⊣ R₁ and L₂ ⊣ R₂, the unit of the adjunction at an object X in C, applied to L₁.obj X and transferred via f, equals the unit of the adjunction at X in D, composed with R₂.app f.app X.


theorem AlgebraicGeometry.PresheafedSpace.Hom.ext :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
      (α β : AlgebraicGeometry.PresheafedSpace.Hom X Y) (w : α.base = β.base),
      CategoryTheory.CategoryStruct.comp α.c (CategoryTheory.whiskerRight (CategoryTheory.eqToHom ⋯) X.presheaf) = β.c →
        α = β :=
  by sorry

This theorem states that for any category `C`, and any two objects `X` and `Y` in the category of algebraic geometry presheafed spaces over `C`, if we have two morphisms `α` and `β` from `X` to `Y`, and if the base maps of `α` and `β` are equal, then if the composition of `α.c` and the whisker right of the equality morphism (derived from the equality of base maps) with `X.presheaf` is equal to `β.c`, then `α` and `β` are equal.

In simple terms, this theorem is about the equality of two morphisms in the category of algebraic geometry presheafed spaces. It states that if these two morphisms have the same base map, and if a certain composite morphism involving one of the morphisms and the identity morphism (that comes from the equality of the base maps) is equal to the other morphism, then the two original morphisms are indeed the same.

If two morphisms in the category of algebraic geometry presheafed spaces over a category `C` have equal base maps and their compositions with the identity morphism from the equality of base maps yield equal morphisms when precomposed with the presheaf of one object, then the two morphisms are equal.


theorem AddSubmonoid.LocalizationMap.lift_comp :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P}
      (hg : ∀ (y : ↥S), IsAddUnit (g ↑y)),
      AddMonoidHom.comp (AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.toMap f) = g :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.lift_comp` states that for any additive commutative monoid `M`, an additive submonoid `S` of `M`, additive commutative monoids `N` and `P`, a localization map `f` from `S` to `N`, and an additive monoid homomorphism `g` from `M` to `P` such that every element `y` in `S` is an add-unit under `g`, the composition of the lift of `f` with respect to `g` and the map from `M` to `N` induced by `f` is equal to `g`. In other words, it expresses the unique property of the lifting operation in the context of localization of additive monoids.

For any additive commutative monoids $M$, $N$, $P$, an additive submonoid $S$ of $M$, an additive commutative monoid homomorphism $g : M \to P$ such that every element in $S$ is an add-unit under $g$, and a localization map $f : S \to N$, the composition of the lift of $f$ with respect to $g$ and the map induced by $f$ is equal to $g$.


/-- In a second-countable space, an open set, given as a union of open sets,
is equal to the union of countably many of those sets.
In particular, any open covering of `α` has a countable subcover: α is a Lindelöf space.  -/
theorem TopologicalSpace.isOpen_iUnion_countable :
    ∀ {α : Type u} [t : TopologicalSpace α] [inst : SecondCountableTopology α] {ι : Type u_1} (s : ι → Set α),
      (∀ (i : ι), IsOpen (s i)) → ∃ T, Set.Countable T ∧ ⋃ i ∈ T, s i = ⋃ i, s i :=
  by sorry

The theorem `TopologicalSpace.isOpen_iUnion_countable` states that for any type `α` that has a topology and a second-countable topology, given a set of open sets indexed by `ι`, if every one of these sets is open, there exists a countable subset `T` of `ι` such that the union of all the sets in `T` is equal to the union of all sets in `ι`. In other words, in a second-countable space, an open set that can be expressed as a union of open sets can also be represented as a union of countably many open sets. This implies that any open cover of `α` has a countable subcover, which characterizes `α` as a Lindelöf space (a topological space in which every open cover has a countable subcover).

In a second-countable topological space, every open cover has a countable subcover.


theorem MvPowerSeries.invOfUnit_eq :
    ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] (φ : MvPowerSeries σ k)
      (h : (MvPowerSeries.constantCoeff σ k) φ ≠ 0),
      MvPowerSeries.invOfUnit φ (Units.mk0 ((MvPowerSeries.constantCoeff σ k) φ) h) = φ⁻¹ :=
  by sorry

The theorem `MvPowerSeries.invOfUnit_eq` states that for any type `σ`, any field `k`, and any multivariate formal power series `φ` over `σ` and `k`, if the constant coefficient of `φ` is non-zero, then `invOfUnit φ` applied to the unit group element created from the constant coefficient of `φ` (using `Units.mk0`) is equal to the multiplicative inverse of `φ` (denoted by `φ⁻¹`). In less technical terms, this theorem is expressing how to calculate the multiplicative inverse of a power series when the constant term is not zero, using the invertibility of the constant term.

If `φ` is a multivariate formal power series over a field `k` and `σ` with non-zero constant coefficient, then `Units.mk0 (const coeff φ) ^-1 = φ⁻¹`.


theorem Mathlib.Data.Real.NNReal._auxLemma.29 : ∀ {q : NNReal}, (0 ≤ ↑q) = True := by sorry

This theorem states that for every nonnegative real number `q`, the assertion that `q` is greater than or equal to zero is always true. In other words, it's a formal statement about a property of nonnegative real numbers: they are always, by definition, greater than or equal to zero.

For every non-negative real number `q`, we have `q ≥ 0`.


theorem Mathlib.Algebra.Order.Floor._auxLemma.10 :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      0 ≤ a → (n ≤ ⌊a⌋₊) = (↑n ≤ a) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Floor._auxLemma.10`, from the Mathlib library in Lean 4, states that for any type `α` that is a `LinearOrderedSemiring` and `FloorSemiring`, and for any `a` in `α` and `n` in `ℕ` (the set of natural numbers), provided `a` is non-negative (0 ≤ a), then `n` is less than or equal to the floor of `a` (n ≤ ⌊a⌋₊) if and only if the natural number `n` as a member of `α` (↑n) is less than or equal to `a`. This theorem bridges the relationship between the floor function and basic inequalities in a given ordered semiring.

For any `LinearOrderedSemiring` and `FloorSemiring` type `α`, and for all `a : α` non-negative and `n : ℕ`, `n ≤ ⌊a⌋₊ if and only if ↑n ≤ a`.


theorem Mathlib.Algebra.Order.Floor._auxLemma.37 :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, (⌈a⌉ ≤ z) = (a ≤ ↑z) := by
  sorry

This theorem, from the Mathlib library in Lean 4, states that for any type `α` that is a linear ordered ring and a floor ring, and for any integer `z` and any value `a` of type `α`, the statement that the ceiling of `a` is less than or equal to `z` is equivalent to the statement that `a` is less than or equal to the real number equivalent of `z`. In other words, it shows that, in the context of certain mathematical structures, comparing a number to the ceiling of another number is the same as comparing it to the other number itself.

For any linear ordered ring and floor ring type `α`, and integers `z` and `a` of type `α`, `a <= toReal z` if and only if `ceiling a <= z`.


theorem Mathlib.Algebra.Order.Floor._auxLemma.38 :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, (z ≤ ⌊a⌋) = (↑z ≤ a) := by
  sorry

This theorem, from the `Mathlib.Algebra.Order.Floor` library, is known as `_auxLemma.38`. It asserts that for any integer `z` and any element `a` of a type `α`, where `α` is a linearly ordered ring with a floor function, `z` is less than or equal to the floor of `a` if and only if the real number equivalent of `z` is less than or equal to `a`. In other words, the comparison of an integer `z` with the floor of a number `a` in this ordered ring structure is equivalent to the comparison of the real number variant of `z` with `a`. This theorem provides a useful equivalence relation that bridges the gap between integers and reals in the context of linearly ordered rings with a floor function.

For any integer `z` and element `a` in a linearly ordered ring with a floor function, `z ≤ floor a` if and only if `reál z ≤ a`.


/-- If `K` admits an orthogonal projection, `K` and `Kᗮ` are complements of each other.  -/
theorem Submodule.isCompl_orthogonal_of_completeSpace :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {K : Submodule 𝕜 E} [inst_3 : HasOrthogonalProjection K], IsCompl K Kᗮ :=
  by sorry

This theorem states that for any field `𝕜` and any normed add-commutative group `E` that forms an inner product space over `𝕜`, if a submodule `K` of `E` admits an orthogonal projection, then `K` and the orthogonal complement of `K` (denoted `Kᗮ`) are complements of each other. In the context of vector spaces, two subspaces being complements means that every vector in the space can be uniquely written as the sum of a vector in one subspace and a vector in the other subspace.

If a submodule `K` of a normed add-commutative group `E` over a field `𝕜`, which forms an inner product space, has an orthogonal projection, then `K` and its orthogonal complement `Kᗮ` are complementary subspaces.


theorem Mathlib.Algebra.Order.Floor._auxLemma.35 :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, (⌊a⌋ < z) = (a < ↑z) := by
  sorry

This theorem, `Mathlib.Algebra.Order.Floor._auxLemma.35`, states that for any type `α` that is a linearly ordered ring and has a floor function, and for any integer `z` and any element `a` of `α`, the inequality `⌊a⌋ < z` (the floor of `a` is less than `z`) is equivalent to the inequality `a < ↑z` ( `a` is less than the integer `z` coverted to `α`).

For any linearly ordered ring `α` with a floor function, the inequality `⌊a⌋ < z` is equivalent to `a < ↑z`.


theorem Mathlib.Algebra.Order.Floor._auxLemma.36 :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, (z < ⌈a⌉) = (↑z < a) := by
  sorry

This theorem, under the Mathlib algebra order floor module, states that for any type `α` that forms a linearly ordered ring and a floor ring, and for any integer `z` and element `a` of type `α`, `z` is less than the ceiling of `a` if and only if the real number equivalent of `z` is less than `a`. In essence, it establishes a relationship between the inequality of an integer and a real number with the inequality of that integer and the ceiling of the real number.

For any linearly ordered ring and floor ring type `α`, and for any integer `z` and element `a` of `α`, `z < ceiling a` if and only if `toReal z < a`.


theorem Mathlib.Data.Real.NNReal._auxLemma.19 : ∀ {r₁ r₂ : NNReal}, (↑r₁ < ↑r₂) = (r₁ < r₂) := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any two nonnegative real numbers `r₁` and `r₂`, the condition "the value of `r₁` is less than the value of `r₂`" is equivalent to "the real number represented by `r₁` is less than the real number represented by `r₂`". Here, `NNReal` refers to the type of nonnegative real numbers, and `↑r₁` and `↑r₂` denote the real numbers corresponding to `r₁` and `r₂`, respectively.

For any `r₁, r₂ : NNReal`, `r₁ < r₂` if and only if `↑r₁ < ↑r₂`.


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

This theorem states that for any short complex `S` in a category `C` that has zero morphisms, if the second object `X₂` of the short complex is a zero object, then the short complex `S` is exact. In the language of category theory, a short complex is a sequence of morphisms and objects that mimics the structure of a chain complex with only three nonzero terms. An exact short complex is one where the image of the morphism from the first object to the second object is equal to the kernel of the morphism from the second object to the third object. The condition that `X₂` is a zero object means that every morphism to `X₂` is a zero morphism and every morphism from `X₂` is a zero morphism.

A short complex `S` in category `C` with zero morphisms is exact if its middle object `X₂` is a zero object.


SetTheory.PGame.Subsequent.moveRight

theorem SetTheory.PGame.Subsequent.moveRight :
    ∀ {x : SetTheory.PGame} (j : SetTheory.PGame.RightMoves x),
      SetTheory.PGame.Subsequent (SetTheory.PGame.moveRight x j) x :=
  by sorry

This theorem in set theory states that for any game `x` and any legal move `j` for the player Right, the game that results after Right makes the move `j` is a subsequent of the game `x`. In other words, the game that you get after Right's move can be reached from `x` by playing some nonempty sequence of moves.

For any game `x` and legal move `j` for player Right, there exists a nonempty sequence of moves leading from `x` to the game resulting from Right making move `j`.


/-- Dropping the elements up to `n` in `l₁ ++ l₂` is the same as dropping the elements up to `n`
in `l₁`, dropping the elements up to `n - l₁.length` in `l₂`, and appending them.  -/
theorem List.drop_append_eq_append_drop :
    ∀ {α : Type u_1} {l₁ l₂ : List α} {n : ℕ},
      List.drop n (l₁ ++ l₂) = List.drop n l₁ ++ List.drop (n - List.length l₁) l₂ :=
  by sorry

This theorem states that for any list `l1` and `l2` of elements of any type `α`, and for any natural number `n`, the operation of dropping the first `n` elements from the combined list `l1 ++ l2` is equivalent to first dropping the first `n` elements from `l1` and `l2` separately, where from `l2`, we drop `n - length of l1` elements, and then appending the two resultant lists. This means that the `drop` operation is distributive over the list concatenation operation.

For any lists `l1` and `l2` of length `m` and `n` respectively, and natural number `k` such that `m + n - k ≥ 0`, the lists `drop k (l1 ++ l2)` and `drop k l1 ++ drop (k - m) l2` are equal.


theorem Subgroup.map_eq_bot_iff :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (H : Subgroup G) {f : G →* N},
      Subgroup.map f H = ⊥ ↔ H ≤ MonoidHom.ker f :=
  by sorry

This theorem states that for any group `G`, any group `N`, a subgroup `H` of `G`, and a monoid homomorphism `f` from `G` to `N`, the image of the subgroup `H` under the homomorphism `f` is the trivial subgroup (denoted by `⊥`) if and only if `H` is a subset of the kernel of the homomorphism `f`. Here, the kernel of a homomorphism `f` is defined as the subgroup of elements `x` in `G` such that `f(x)` equals the identity element in `N`.

A subgroup H of a group G is mapped to the trivial subgroup under a group homomorphism f to N if and only if H is contained in the kernel of f.


theorem Fin.cast.proof_1 : ∀ {n m : ℕ}, n = m → ∀ (i : Fin n), ↑i < m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` equals `m`, then for any `i` in the finite set of `n`, the value of `i` is less than `m`. In other words, every element of a finite set of size `n` is less than `n` itself.

For any finite set of natural numbers of size `n`, every element `i` in the set satisfies `i < n`.


theorem PrimeSpectrum.zeroLocus_radical :
    ∀ {R : Type u} [inst : CommSemiring R] (I : Ideal R),
      PrimeSpectrum.zeroLocus ↑(Ideal.radical I) = PrimeSpectrum.zeroLocus ↑I :=
  by sorry

This theorem states that for any ideal `I` in a commutative semiring `R`, the set of points in the prime spectrum where the radical of `I` vanishes (denoted by `PrimeSpectrum.zeroLocus ↑(Ideal.radical I)`) is equal to the set of points in the prime spectrum where `I` itself vanishes (denoted by `PrimeSpectrum.zeroLocus ↑I`). In other words, the zero locus of the radical of an ideal is the same as the zero locus of the ideal itself.

The zero locus of an ideal and its radical in the prime spectrum of a commutative semiring are equal.


theorem Mathlib.GroupTheory.Perm.Support._auxLemma.16 :
    ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ := by sorry

This theorem, from the Group Theory and Permutation sections in the Mathlib library, states that for any type `α` and any two finite sets `s₁` and `s₂` of this type, `s₁` is equal to `s₂` if and only if for any element `a` of type `α`, `a` is in `s₁` if and only if `a` is in `s₂`. In other words, two finite sets are equal if they contain exactly the same elements.

Two finite sets `s₁` and `s₂` of type `α` are equal if and only if they have the same elements.


ContDiffAt.div

theorem ContDiffAt.div :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} [inst_3 : CompleteSpace 𝕜] {f g : E → 𝕜} {n : ℕ∞},
      ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n g x → g x ≠ 0 → ContDiffAt 𝕜 n (fun x => f x / g x) x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and normed add commutative group `E` that is a normed space over `𝕜`, and for any point `x` in `E` and two functions `f` and `g` from `E` to `𝕜`, if `f` and `g` are continuously differentiable at `x` of any order `n` (can be a natural number or infinity), and if `g(x)` is not zero, then the function defined by the quotient of `f(x)` by `g(x)` is also continuously differentiable at `x` of the same order `n`.

If `f` and `g` are continuously differentiable functions of order `n` from a normed space `E` over a nontrivially normed field `𝕜` to `𝕜`, with `g(x) ≠ 0`, then the quotient function `f / g` is also continuously differentiable of order `n` at `x`.


theorem IsAdjoinRoot.liftHom_map :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      {T : Type u_1} [inst_3 : CommRing T] {x : T} [inst_4 : Algebra R T] (hx' : (Polynomial.aeval x) f = 0)
      (h : IsAdjoinRoot S f) (z : Polynomial R), (IsAdjoinRoot.liftHom x hx' h) (h.map z) = (Polynomial.aeval x) z :=
  by sorry

This theorem states that for any commutative ring `R`, ring `S`, commutative ring `T`, polynomial `f` over `R`, an algebra `S` over `R`, an algebra `T` over `R`, and an element `x` of `T`, if `x` is a root of the polynomial `f` (that is, `(Polynomial.aeval x) f = 0`) and `S` is generated by the roots of `f` (that is, `h : IsAdjoinRoot S f`), then for any polynomial `z` over `R`, the mapping of `z` under the homomorphism `IsAdjoinRoot.liftHom x hx' h` is equal to the result of evaluating `z` at `x` (that is, `(IsAdjoinRoot.liftHom x hx' h) (h.map z) = (Polynomial.aeval x) z`). Essentially, this theorem ensures the consistency between the root adjoined homomorphism and polynomial evaluation at a root.

For any commutative rings `R`, `S`, `T`, polynomial `f` over `R`, algebra `S` over `R` generated by the roots of `f`, and element `x` of `T` being a root of `f`, the root adjoined homomorphism `IsAdjoinRoot.liftHom x h x' h` maps `z` over `R` to the value of `z` evaluated at `x`.


theorem Finset.coe_infs :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeInf α] (s t : Finset α), ↑(s ⊼ t) = ↑s ⊼ ↑t := by sorry

The theorem `Finset.coe_infs` states that for any given types `α`, which has a decidable equality and is a semilattice under the operation of infimum, and any two finsets `s` and `t` of type `α`, the infimum of the union of `s` and `t` is the same as the union of the infimums of `s` and `t`. Essentially, this theorem asserts that the operation of finding the infimum commutes with the operation of taking the union in the context of finsets.

For any semilattic type `α` with decidable equality, the infimum of the union of two finsets `s` and `t` over `α` equals the union of the infima of `s` and `t`.


theorem Finset.prod_disj_sum :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommMonoid β] (s : Finset α) (t : Finset γ) (f : α ⊕ γ → β),
      (Finset.prod (Finset.disjSum s t) fun x => f x) =
        (Finset.prod s fun x => f (Sum.inl x)) * Finset.prod t fun x => f (Sum.inr x) :=
  by sorry

The `Finset.prod_disj_sum` theorem states that for any two finite sets `s` and `t`, and any function `f` from the disjoint union of `s` and `t` to a commutative monoid, the product of `f` over the disjoint union of `s` and `t` equals the product of the restrictions of `f` to `s` and `t`, separately. Here, the restriction of `f` to `s` or `t` is calculated by applying `f` to an element from `s` or `t`, respectively, and then taking the sum of the left or right, respectively. This theorem articulates a form of distributivity for the product operation over finite sets.

For any commutative monoid M and finite sets s and t, the function product of a function from the disjoint union of s and t to M equals the function product of the restrictions of the function to s and t.


theorem CategoryTheory.Preadditive.mono_of_isZero_kernel' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
      {f : X ⟶ Y} (c : CategoryTheory.Limits.KernelFork f),
      CategoryTheory.Limits.IsLimit c → CategoryTheory.Limits.IsZero c.pt → CategoryTheory.Mono f :=
  by sorry

The theorem `CategoryTheory.Preadditive.mono_of_isZero_kernel'` states that for any category `C` that is preadditive (which means it's a category equipped with a bifunctorial binary operation "+"), if we have morphism `f` from object `X` to object `Y` such that there exists a kernel fork `c` of `f` which is a limit (meaning it represents the "best" or "universal" solution to a particular diagram in the category) and the source `pt` of `c` is a zero object (which means it's both a terminal and initial object in the category), then the morphism `f` is a monomorphism. In a nutshell, a monomorphism in a preadditive category is determined by its kernel being a zero object.

If in a preadditive category, a morphism has a kernel that is a limit with a zero object as source, then the morphism is a monomorphism.


theorem Set.sUnion_diff_singleton_empty : ∀ {α : Type u_1} (s : Set (Set α)), ⋃₀ (s \ {∅}) = ⋃₀ s := by sorry

This theorem, `Set.sUnion_diff_singleton_empty`, states that for any type `α` and for any collection `s` of sets of type `α`, the union over the collection obtained by removing the empty set from `s` is equal to the union over the original collection `s`. In other words, excluding the empty set from a collection of sets does not change the union of the collection. This theorem can be seen as a property regarding the interaction between set union and set difference operations.

For any type `α` and collection `s` of sets of type `α`, the set difference of `s` with the empty set is equal to `s` itself when considering set unions. That is, `⋃(s \ {}) = ⋃s`.


theorem Cardinal.ord_injective : Function.Injective Cardinal.ord := by sorry

The theorem `Cardinal.ord_injective` is stating that the function `Cardinal.ord` is injective. In the context of mathematics, this means that for any two cardinals `c1` and `c2`, if `Cardinal.ord c1` is equal to `Cardinal.ord c2`, then `c1` must be equal to `c2`. In other words, no two different cardinals can have the same ordinal under the `Cardinal.ord` function. The function `Cardinal.ord` assigns to each cardinal number the least ordinal number whose cardinal is that cardinal number, so this theorem is ensuring the uniqueness of this assignment.

The `Cardinal.ord` function maps distinct cardinal numbers to distinct ordinal numbers.


theorem descPochhammer_map :
    ∀ {R : Type u} [inst : Ring R] {T : Type v} [inst_1 : Ring T] (f : R →+* T) (n : ℕ),
      Polynomial.map f (descPochhammer R n) = descPochhammer T n :=
  by sorry

The theorem `descPochhammer_map` states that for every ring homomorphism `f` from a ring `R` to another ring `T` and for every natural number `n`, if you construct a `descPochhammer` polynomial with coefficients in `R` and then map it across the ring homomorphism `f` to `T` (using the `Polynomial.map` function), the result is the same as if you'd constructed the `descPochhammer` polynomial directly in `T`. In other words, the process of creating a `descPochhammer` polynomial commutes with the action of a ring homomorphism.

For every ring homomorphism $f$ from a ring $R$ to another ring $T$ and every natural number $n$, the map $f$ applied to the descendant Pochhammer polynomial $P_{n}(X;a)$ in $R$ is equal to the descendant Pochhammer polynomial $P_{n}(X;a)$ constructed in $T$. In other words, $f(P_{n}(X;a)_{R}) = P_{n}(X;a)_{T}$.


/-- **AM-GM inequality**: The geometric mean is less than or equal to the arithmetic mean, weighted
version for `NNReal`-valued functions.  -/
theorem NNReal.geom_mean_le_arith_mean_weighted :
    ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
      (Finset.sum s fun i => w i) = 1 → (Finset.prod s fun i => z i ^ ↑(w i)) ≤ Finset.sum s fun i => w i * z i :=
  by sorry

The theorem `NNReal.geom_mean_le_arith_mean_weighted` is a statement of the AM-GM inequality (Arithmetic Mean-Geometric Mean Inequality), specifically for the weighted version of the inequality with nonnegative real valued functions. It states that for any type `ι` and any finite set of elements of this type (`s : Finset ι`), given two functions `w` and `z` that map each element of the finite set to a nonnegative real number, if the sum of the `w(i)` values for all `i` in the finite set equals 1, then the product over all `i` in the set of `z(i)` raised to the power of `w(i)` is less than or equal to the sum over all `i` in the set of `w(i)` multiplied by `z(i)`. This is essentially saying that the geometric mean of the set is less than or equal to the weighted arithmetic mean.

For any finite set and functions mapping elements to nonnegative real numbers with sum of weights equal to 1, the geometric mean of these functions is less than or equal to the weighted arithmetic mean.


theorem Cardinal.lift_lt_aleph0 :
    ∀ {c : Cardinal.{u}}, Cardinal.lift.{v, u} c < Cardinal.aleph0 ↔ c < Cardinal.aleph0 := by sorry

The theorem `Cardinal.lift_lt_aleph0` states that for all cardinals `c` in universe `u`, the lift operation on `c` to universe `v` (`Cardinal.lift.{v, u} c`) is less than the smallest infinite cardinal (`Cardinal.aleph0`) if and only if `c` itself is less than `Cardinal.aleph0`. This means that the relationship of being less than `ℵ₀` is preserved under the universe lift operation on cardinals.

For all cardinals `c` in universe `u`, `Cardinal.lift.{v, u} c < Cardinal.aleph0` if and only if `c < Cardinal.aleph0`.


/-- Every coequalizer of `(f, g)`, where `f = g`, is an isomorphism.  -/
theorem CategoryTheory.Limits.isIso_colimit_cocone_parallelPair_of_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y},
      f = g →
        ∀ {c : CategoryTheory.Limits.Cofork f g},
          CategoryTheory.Limits.IsColimit c → CategoryTheory.IsIso (CategoryTheory.Limits.Cofork.π c) :=
  by sorry

This theorem states that in any category `C`, for any two morphisms `f` and `g` from `X` to `Y`, if `f` and `g` are the same, then for any cofork `c` of `f` and `g`, if `c` is a colimit, then the arrow (`π`) from the apex of the cofork to `Y` is an isomorphism. In simpler terms, it says that every coequalizer of a pair of identical morphisms in a category is an isomorphism.

In any category, if two morphisms have the same source and target and are equal, then their coequalizer is an isomorphism.


theorem Polynomial.cyclotomic.proof_1 :
    ∀ (n : ℕ),
      ¬n = 0 →
        ∃ P,
          Polynomial.map (Int.castRingHom ℂ) P = Polynomial.cyclotomic' n ℂ ∧
            Polynomial.degree P = Polynomial.degree (Polynomial.cyclotomic' n ℂ) ∧ Polynomial.Monic P :=
  by sorry

This theorem states that for any non-zero natural number `n`, there exists a polynomial `P` such that when `P` is mapped across the ring homomorphism from integers to complex numbers, it equals the `n`-th cyclotomic polynomial (in the complex number field), and the degree of `P` equals the degree of the `n`-th cyclotomic polynomial. Additionally, the polynomial `P` is monic, which means its leading coefficient is 1. In other words, there is a monic polynomial with integer coefficients that, upon casting to the complex numbers and measuring degree, behaves like the `n`-th cyclotomic polynomial over the complex numbers.

For any natural number `n`, there exists a monic polynomial `P` with integer coefficients of degree `n` that maps to the `n`-th cyclotomic polynomial in the complex numbers under the ring homomorphism from integers to complex numbers.


theorem Mathlib.Data.Part._auxLemma.4 : ∀ {α : Type u_1} (a : α), (a ∈ Part.none) = False := by sorry

This theorem states that for any type `α` and any element `a` of that type, `a` is not an element of `Part.none`. In other words, `Part.none`, which is a `Part` with a `False` domain and an empty function, contains no elements irrespective of the type `α`.

For all types `α` and elements `a` of type `α`, `a` is not an element of the empty `Part` `Part.none` with domain `False`.


theorem Mathlib.Data.Part._auxLemma.5 : ∀ {α : Type u_1} (a : α), (Part.some a).1 = True := by sorry

This theorem states that for any type `α` and an element `a` of type `α`, the domain of the `Part.some a` function is `True`. In other words, the defined part function `Part.some a` has a domain that is always `True` for any `a` of any type `α`.

For any type `α` and element `a` of type `α`, the domain of the function `Part.some a` is unconditionally `True`.


theorem Nat.zero_lt_two : 0 < 2 := by sorry

This theorem states that zero is less than two in the domain of natural numbers. In other words, it confirms the mathematical fact that the natural number 0 is indeed smaller than the natural number 2.

The theorem asserts that 0 < 2 in the natural numbers.


theorem CategoryTheory.ShortComplex.leftHomologyMap'_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.ShortComplex.leftHomologyMap' (CategoryTheory.CategoryStruct.id S) h h =
        CategoryTheory.CategoryStruct.id h.H :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftHomologyMap'_id` states that for any category `C` of a certain type, with `C` having zero morphisms, and for any short complex `S` of `C`, the left homology map applied to the identity morphism of `S` is equivalent to the identity morphism on the left homology data `h` of `S`. This is essentially stating that the left homology map respects the identity morphism in the categorical sense.

For any short complex S in a zero-morphism category C, the left homology map applied to the identity morphism of S equals the identity on the left homology data of S.


theorem HahnSeries.ofPowerSeries_X :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : StrictOrderedSemiring Γ],
      (HahnSeries.ofPowerSeries Γ R) PowerSeries.X = (HahnSeries.single 1) 1 :=
  by sorry

The theorem `HahnSeries.ofPowerSeries_X` states that for any types Γ and R, where Γ is a strict ordered semiring and R is a semiring, the application of the function `HahnSeries.ofPowerSeries` onto the power series variable `PowerSeries.X` is equal to the Hahn series which has coefficient 1 at 1 and zero elsewhere, represented as `HahnSeries.single 1 1`. In other words, the power series variable, when casted as a Hahn series with coefficients from a strict ordered semiring, is equivalent to a Hahn series with a single nonzero coefficient 1 at 1.

For any strict ordered semiring Γ and semiring R, the Hahn series obtained from casting the power series variable `PowerSeries.X` as a Hahn series with coefficients from Γ is equal to the Hahn series with a single nonzero coefficient 1 at 1.


theorem ArithmeticFunction.IsMultiplicative.map_mul_of_coprime :
    ∀ {R : Type u_1} [inst : MonoidWithZero R] {f : ArithmeticFunction R},
      ArithmeticFunction.IsMultiplicative f → ∀ {m n : ℕ}, Nat.Coprime m n → f (m * n) = f m * f n :=
  by sorry

The theorem `ArithmeticFunction.IsMultiplicative.map_mul_of_coprime` states that for any type `R` equipped with the structure of a `MonoidWithZero` and an arithmetic function `f` on `R` which is multiplicative, if `m` and `n` are two natural numbers that are coprime (i.e., their greatest common divisor is 1), then the value of the function at the product `m * n` equals the product of the function's values at `m` and `n`. This theorem is an important property for multiplicative arithmetic functions in number theory.

For any coprime natural numbers m and n and multiplicative arithmetic function f on a MonoidWithZero R, f (m * n) = f(m) * f(n).


theorem List.not_mem_keys_of_nodupKeys_cons :
    ∀ {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)}, List.NodupKeys (s :: l) → s.fst ∉ List.keys l :=
  by sorry

This theorem states that for any type `α`, any type `β` which depends on `α`, any `s` of type `Sigma β`, and any list `l` of type `Sigma β`, if the list created by prepending `s` to `l` does not contain duplicate keys (`List.NodupKeys (s :: l)`), then the first element of `s` (i.e., `s.fst`) is not in the list of keys of `l` (`s.fst ∉ List.keys l`). Essentially, if a list of key-value pairs has no duplicate keys, the key of the first pair is not a key in the rest of the list.

If `s :: l` is a list of key-value pairs such that `List.NodupKeys (s :: l)`, then `s.fst` is not a key in `l`.


theorem Complex.tan_zero : Complex.tan 0 = 0 := by sorry

This theorem states that the value of the complex tangent function at zero is zero. In other words, when you take the tangent of zero in the complex number system (which is defined as the complex sine of the number divided by the complex cosine of the number), the result is zero.

The complex tangent function evaluates to zero at zero. (tan(z) = z /  komplex_abs z where z is a complex number and komplex_abs is the absolute value function in Lean 4 complex arithmetic.)


theorem IsBezout.gcd_dvd_left :
    ∀ {R : Type u} [inst : CommRing R] (x y : R) [inst_1 : Submodule.IsPrincipal (Ideal.span {x, y})],
      IsBezout.gcd x y ∣ x :=
  by sorry

The theorem `IsBezout.gcd_dvd_left` states that for any commutative ring `R` and any two elements `x` and `y` of `R`, if the ideal generated by `x` and `y` is principal (i.e., it can be generated by a single element), then the greatest common divisor (`gcd`) of `x` and `y` (as defined in a Bézout domain) divides `x`. In other words, `x` is a multiple of the `gcd` of `x` and `y`.

In a commutative ring, if the ideal generated by two elements is principal, then the greatest common divisor of those elements divides one of them.


/-- This can be used to prove
```lean
example (a b c d : α) [Mul α] [AddCommMonoid α] :
  dot_product ![a, b] ![c, d] = a * c + b * d :=
(dot_productᵣ_eq _ _).symm
```
 -/
theorem Matrix.dotProductᵣ_eq :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : AddCommMonoid α] {m : ℕ} (a b : Fin m → α),
      Matrix.dotProductᵣ a b = Matrix.dotProduct a b :=
  by sorry

The theorem `Matrix.dotProductᵣ_eq` states that for any type `α` that has multiplication and addition, any natural number `m`, and any two functions `a` and `b` from `Fin m` to `α`, the alternative version of matrix dot product (`Matrix.dotProductᵣ`) produces the same result as the standard matrix dot product (`Matrix.dotProduct`). In other words, for the given vectors `a` and `b`, the sum of the entrywise products using `Matrix.dotProductᵣ` and `Matrix.dotProduct` are equal. This theorem would be used, for instance, to prove that the dot product of two 2-dimensional vectors `[a, b]` and `[c, d]` is `a * c + b * d`.

For any type `α` with multiplication and addition, and for any functions `a : Fin m → α` and `b : Fin n → α`, the entrywise matrix dot product `Matrix.dotProductᵣ a b` equals the standard matrix dot product `Matrix.dotProduct a.toMatrix b.toMatrix`.


theorem sdiff_sdiff_right' :
    ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x \ (y \ z) = x \ y ⊔ x ⊓ z := by sorry

This theorem, `sdiff_sdiff_right'`, states that for any type `α` which forms a GeneralizedBooleanAlgebra and for any elements `x`, `y`, and `z` of that type, the set difference of `x` and the set difference of `y` and `z` is equal to the join of the set difference of `x` and `y` with the meet of `x` and `z`. In mathematical notation, this is written as $x \setminus (y \setminus z) = (x \setminus y) \sqcup (x \cap z)$. The theorem is universally quantified over `x`, `y`, and `z`, meaning it holds for all possible values of these variables.

For any type `α` forming a GeneralizedBooleanAlgebra and any elements `x`, `y`, and `z` of that type, $x \setminus (y \setminus z) = (x \setminus y) \sqcup (x \cap z)$.


theorem dvd_dvd_iff_associated :
    ∀ {α : Type u_1} [inst : CancelMonoidWithZero α] {a b : α}, a ∣ b ∧ b ∣ a ↔ Associated a b := by sorry

The theorem `dvd_dvd_iff_associated` states that for any type `α` that is a `CancelMonoidWithZero`, and any two elements `a` and `b` of that type, `a` divides `b` and `b` divides `a` if and only if `a` and `b` are associated. Here, two elements are called associated if one of them is equal to the other multiplied by a unit on the right, where a unit is an element that has a multiplicative inverse.

For any type `α` that is a `CancelMonoidWithZero` and any elements `a` and `b` of `α`, `a` divides `b` and `b` divides `a` if and only if `a` and `b` are right associate with some unit in `α`.


theorem wcovBy_eq_reflGen_covBy :
    ∀ {α : Type u_1} [inst : PartialOrder α], (fun x x_1 => x ⩿ x_1) = Relation.ReflGen fun x x_1 => x ⋖ x_1 := by sorry

This theorem states that, for any given type 'α' which has a partial order defined on it, the relation 'weakly covers', denoted as '⩿', is equivalent to the reflexive transitive closure of the 'covers' relation, denoted by '⋖'. In other words, an element weakly covers another if and only if it covers that element in a non-strict partial order, or it is equal to that element.

For any type 'α' with a partial order, the relation 'weakly covers' ('⩿') is equal to the reflexive transitive closure of the 'covers' ('⋖') relation.


HasDerivAt.log

theorem HasDerivAt.log :
    ∀ {f : ℝ → ℝ} {x f' : ℝ}, HasDerivAt f f' x → f x ≠ 0 → HasDerivAt (fun y => Real.log (f y)) (f' / f x) x := by
  sorry

The theorem `HasDerivAt.log` states that for any real-valued function `f` from the real numbers, and for any real numbers `x` and `f'`, if the function `f` has the derivative `f'` at the point `x` and `f(x)` is nonzero, then the derivative at `x` of the function which maps `y` to the logarithm (in the extended sense defined by `Real.log`) of `f(y)` is `f' / f(x)`. This theorem provides a rule for differentiating the composition of the logarithm function with any differentiable function that does not vanish at the point of differentiation.

If real-valued function `f` has nonzero derivative `f'` at `x`, then the logarithm function of `f(x)` has derivative `f' / f(x)` at `x`.


theorem Set.monotone_accumulate :
    ∀ {α : Type u_1} {β : Type u_2} {s : α → Set β} [inst : Preorder α], Monotone (Set.Accumulate s) := by sorry

The theorem `Set.monotone_accumulate` states that for any type `α` with a preorder structure and any function `s` from `α` to sets of type `β`, the operation `Set.Accumulate s` is monotone. In other words, if `x ≤ y` for two elements `x`, `y` of type `α`, then `Set.Accumulate s x` is a subset of `Set.Accumulate s y`. Here, `Set.Accumulate s x` is defined to be the union of `s z` for all `z` in `α` such that `z ≤ x`.

For any preorder (α, ≤) and function s : α → Sets (β), the operation Set.Accumulate s is monotone, that is, Set.Accumulate s x ⊆ Set.Accumulate s y for all x ≤ y in α.


theorem div_mul_cancel_of_invertible :
    ∀ {α : Type u} [inst : GroupWithZero α] (a b : α) [inst_1 : Invertible b], a / b * b = a := by sorry

This theorem states that for any type `α` that is a group with zero, given two elements `a` and `b` of this type, if `b` is invertible (meaning there exists a multiplicative inverse for `b`), then the result of dividing `a` by `b` and then multiplying by `b` is equal to `a`. In mathematical terms, this is equivalent to saying that for any group with zero and any elements `a` and `b` in that group, if `b` has a multiplicative inverse, then `(a / b) * b = a`.

If `α` is a group with zero, `a` and `b` are elements of `α` with `b` invertible, then `(a / b) * b = a`.


theorem AEMeasurable.map_map_of_aemeasurable :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {g : β → γ} {f : α → β},
      AEMeasurable g (MeasureTheory.Measure.map f μ) →
        AEMeasurable f μ →
          MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) = MeasureTheory.Measure.map (g ∘ f) μ :=
  by sorry

This theorem, `AEMeasurable.map_map_of_aemeasurable`, states that for all types `α`, `β`, and `γ`, with `α`, `β`, and `γ` representing sets, and given measurable spaces on these sets (`m0` on `α`, `inst` on `β`, and `inst_1` on `γ`), a measure `μ` on `α`, and functions `g : β → γ` and `f : α → β`, if `g` is almost everywhere measurable with respect to the measure obtained by mapping `f` to the measure `μ`, and `f` is almost everywhere measurable with respect to the measure `μ`, then the measure obtained by first mapping `f` to the measure `μ` and then mapping `g` to the result, is equal to the measure obtained by mapping the composition of `g` and `f` to the measure `μ`. In other words, it asserts that for almost everywhere measurable functions, the operation of measure pushforward commutes with function composition.

Given measurable spaces `(α, m0)`, `(β, inst)`, `(γ, inst_1)` and measures `μ` on `α`, if `f : α → β` and `g : β → γ` are almost everywhere measurable with respect to `μ` and the measures induced by `f` and `g`, then `(μ ∘ f) ∘ g = μ ∘ (g ∘ f)` almost everywhere.


theorem Complex.abs_mul_cos_arg : ∀ (x : ℂ), Complex.abs x * Real.cos (Complex.arg x) = x.re := by sorry

The theorem `Complex.abs_mul_cos_arg` states that for any complex number `x`, the product of the absolute value of `x` and the cosine of the argument of `x` is equal to the real part of `x`. In mathematical terms, this means that for any complex number `x`, we have |x| * cos(arg(x)) = Re(x), where |x| denotes the absolute value of `x`, arg(x) refers to its argument, and Re(x) is its real part. This relationship is a key part of the polar representation of complex numbers.

For any complex number x, |x| * cos(arg x) = Re(x).


theorem Finset.image_one :
    ∀ {α : Type u_2} {β : Type u_3} [inst : One α] [inst_1 : DecidableEq β] {f : α → β}, Finset.image f 1 = {f 1} := by
  sorry

This theorem, named 'Finset.image_one', states that for any types `α` and `β`, given that `α` has a defined "one" element (denoted by the typeclass `One α`) and `β` has decidable equality (indicated by `DecidableEq β`), for any function `f` from `α` to `β`, the image of the singleton finset containing only the "one" element of `α` under `f` is the singleton finset containing `f` applied to the "one" element of `α`. In other words, if we apply `f` to each element in the singleton set containing only the "one" element in `α`, we get a new set containing only the result `f 1`.

For functions between types with defined "one" elements and decidable equality, the image of the singleton set containing the "one" element under the function is the singleton set containing the image of the "one" element.


theorem comap_norm_atTop :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E], Filter.comap norm Filter.atTop = Bornology.cobounded E := by sorry

The theorem `comap_norm_atTop` states that for any type `E` which forms a seminormed add group, the filter of the preimage of the filter at infinity (`Filter.atTop`) under the norm function is equal to the filter of cobounded sets in the bornology of `E`. In other words, the norm function maps cobounded sets in `E` to sets that are unbounded above. This reveals a relationship between the norm of a seminormed group and its associated bornology.

For any seminormed add group `E`, the preimage of the filter at infinity under the norm function equals the filter of cobounded sets in `E`'s bornology.


theorem Int.units_sq : ∀ (u : ℤˣ), u ^ 2 = 1 := by sorry

This theorem states that for any unit `u` of integers (`ℤˣ`), the square of `u` is equal to `1`. In the language of mathematics, this can be expressed as: for all `u` in the unit group of integers, `u^2 = 1`.

For all units `u` in the integers, `u^2 = 1`.


theorem ENNReal.add_div : ∀ {a b c : ENNReal}, (a + b) / c = a / c + b / c := by sorry

This theorem states that for any three extended nonnegative real numbers `a`, `b`, and `c`, the division of the sum of `a` and `b` by `c` is equal to the sum of the division of `a` by `c` and the division of `b` by `c`. In mathematical terms, this theorem is expressing the property $(a + b) / c = a / c + b / c$ for extended nonnegative real numbers, which is a common property in the field of real numbers.

For extended nonnegative real numbers `a`, `b`, and `c`, the quotient of their sum by `c` equals the sum of their individual quotients by `c`. That is, $(a + b) / c = a / c + b / c$.


/-- A monotone function is continuous to the left at a point if and only if its left limit
coincides with the value of the function.  -/
theorem Monotone.continuousWithinAt_Iio_iff_leftLim_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f →
        ∀ {x : α} [inst_4 : TopologicalSpace α] [inst_5 : OrderTopology α],
          ContinuousWithinAt f (Set.Iio x) x ↔ Function.leftLim f x = f x :=
  by sorry

This theorem states that for a monotone function `f` mapping from a linearly ordered type `α` to a conditionally complete linearly ordered topological space `β`, the function `f` is continuous to the left at a point `x` (meaning within the left-infinite right-open interval ending at `x`) if and only if the left limit of the function at `x` equals the value of the function at `x`. Here, the left limit of a function at a point is the value that the function approaches as it gets arbitrarily close to that point from the left.

A monotone function from a linearly ordered type to a conditionally complete linearly ordered topological space is left-continuous at a point if and only if its left limit at that point exists and equals the function value at that point.


theorem FirstOrder.Language.completeTheory.isMaximal :
    ∀ (L : FirstOrder.Language) (M : Type w) [inst : FirstOrder.Language.Structure L M] [inst_1 : Nonempty M],
      FirstOrder.Language.Theory.IsMaximal (FirstOrder.Language.completeTheory L M) :=
  by sorry

The theorem `FirstOrder.Language.completeTheory.isMaximal` states that for any first-order language `L` and any type `M` that has a `FirstOrder.Language.Structure` instance, and assuming that `M` is not empty, the complete theory of `M` in `L` is a maximal theory. In other words, the complete theory of `M` in `L` is satisfiable and for every sentence `φ` in `L`, either `φ` or its negation is in the theory. This captures the notion that a complete theory includes every possible statement or its negation for a given language and structure.

Given a non-empty first-order structure `M` in a first-order language `L`, the complete theory of `M` in `L` is a maximal consistent theory.


theorem Set.rightInverse_rangeSplitting :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
      Function.Injective f → Function.RightInverse (Set.rangeFactorization f) (Set.rangeSplitting f) :=
  by sorry

The theorem `Set.rightInverse_rangeSplitting` states that for any types `α` and `β`, and any injective function `f` from `α` to `β`, the function `Set.rangeFactorization f` has a right inverse given by the function `Set.rangeSplitting f`. In other words, if you first apply `Set.rangeFactorization f` and then `Set.rangeSplitting f`, you get back the original element. This is equivalent to saying `Set.rangeSplitting f ∘ Set.rangeFactorization f = id`, where `id` is the identity function.

For any injective function `f` from type `α` to type `β`, `Set.rangeSplitting f ∘ Set.rangeFactorization f = id`.


theorem Basis.repr_total :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M) (v : ι →₀ R), b.repr ((Finsupp.total ι M R ⇑b) v) = v :=
  by sorry

The theorem `Basis.repr_total` states that for any semiring `R`, additive commutative monoid `M`, and a basis `b` of module `M` over `R`, and any function `v` mapping from a type `ι` to `R`, the representation of the linear combination of the basis elements (i.e., `b.repr`) evaluated at the total function (i.e., `(Finsupp.total ι M R ⇑b) v`) is equal to the function `v` itself. In other words, this theorem relates the representation of a vector in terms of the basis to the function describing the coefficients of the linear combination in that basis. This can be interpreted as the property that the coefficients you get when representing a vector in terms of a basis are exactly the ones you used to construct the vector as a linear combination of the basis elements.

For any semiring `R`, additive commutative monoid `M`, basis `b` of `M` over `R`, and function `v : ι -> R`, we have `b.repr (Finsupp.total ι M R v) = v`.


IsMinFilter.inf

theorem IsMinFilter.inf :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeInf β] {f g : α → β} {a : α} {l : Filter α},
      IsMinFilter f l a → IsMinFilter g l a → IsMinFilter (fun x => f x ⊓ g x) l a :=
  by sorry

The theorem `IsMinFilter.inf` states that for any two functions `f` and `g` from a type `α` to a type `β`, and for a specific value `a` of type `α` and a filter `l` on `α`, if `a` is a minimum point for both `f` and `g` with respect to the filter `l` (in other words, if for all `x` in some `l`-neighborhood of `a`, the value of `f` and `g` at `a` is less than or equal to the value of `f` and `g` at `x`), then `a` is also a minimum point for the function that takes `x` to the infimum of `f(x)` and `g(x)` with respect to the same filter `l`. The type `β` is assumed to be a semilattice with respect to the infimum operation.

If `a` is a minimum point for both `f` and `g` with respect to filter `l` on type `α`, then `a` is also a minimum point for the function `x => inf (f x) (g x)` with respect to the same filter `l`, where `inf` denotes the infimum operation in semilattice `β`.


theorem LieHom.map_zero :
    ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
      [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂), f 0 = 0 :=
  by sorry

The theorem `LieHom.map_zero` states that for any given Lie algebra homomorphism `f` from `L₁` to `L₂` over a commutative ring `R`, the image of the zero element of `L₁` under `f` is the zero element of `L₂`. In other words, `f` preserves the zero element when mapping from one Lie algebra to another. This theorem is valid for any types `R`, `L₁`, and `L₂` where `R` is a commutative ring and `L₁` and `L₂` are Lie algebras over `R`.

For any Lie algebra homomorphism f from Lie algebra L₁ to Lie algebra L₂ over commutative ring R, f(0) = 0, where 0 denotes the zero element in L₁ and L₂.


theorem Cardinal.mul_le_max_of_aleph0_le_left : ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → a * b ≤ max a b := by
  sorry

The theorem `Cardinal.mul_le_max_of_aleph0_le_left` states that for any two cardinal numbers `a` and `b`, if the cardinality of `a` is greater than or equal to `ℵ₀` (the smallest infinite cardinal, corresponding to the cardinality of the set of natural numbers), then the product of the cardinalities `a` and `b` is less than or equal to the maximum of `a` and `b`. In simpler terms, this theorem says that if a set has at least as many elements as the set of natural numbers, then for any other set, the size of their Cartesian product will be at most the size of the larger of the two sets.

For any cardinal numbers `a` and `b` with `a ≥ ℵ₀`, the product `a * b` is bounded above by `max(a, b)`.


theorem Set.sep_eq_self_iff_mem_true :
    ∀ {α : Type u} {s : Set α} {p : α → Prop}, {x | x ∈ s ∧ p x} = s ↔ ∀ x ∈ s, p x := by sorry

This theorem states that for any type `α`, a set `s` of `α`, and a property `p` that each element of `α` may or may not satisfy, the set of elements `x` such that `x` is in `s` and `x` satisfies `p` is equal to `s` if and only if every element in `s` satisfies `p`. In mathematical terms, it claims that ${x | x \in s \land p(x)} = s$ if and only if for all $x \in s$, $p(x)$ is true.

For any set `s` of type `α` and property `p` on `α`, `{x | x ∈ s ∧ p(x)} = s` if and only if for all `x ∈ s`, `p(x)` holds.


theorem Monotone.map_inf :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : SemilatticeInf β] {f : α → β},
      Monotone f → ∀ (x y : α), f (x ⊓ y) = f x ⊓ f y :=
  by sorry

The theorem `Monotone.map_inf` asserts that for any types `α` and `β` equipped with a linear order and a semilattice structure respectively, and any function `f` from `α` to `β`, if `f` is monotone, then for any elements `x` and `y` in `α`, the infimum (or greatest lower bound) of `f(x)` and `f(y)` in `β` is equal to `f` of the infimum of `x` and `y` in `α`. In other words, a monotone function preserves the operation of taking infimums.

For any monotone function between linearly ordered semilattices, the image of the infimum of two elements is equal to the infimum of their images.


theorem AddMonoid.lcm_addOrderOf_eq_exponent :
    ∀ {G : Type u} [inst : AddMonoid G] [inst_1 : Fintype G],
      Finset.lcm Finset.univ addOrderOf = AddMonoid.exponent G :=
  by sorry

This theorem states that for any type `G` that is an instance of an `AddMonoid` and `Fintype`, the least common multiple (lcm) of the orders of all elements in the universal finite set (`Finset.univ`) equals to the exponent of the additive monoid. In other words, the least common multiple of the numbers obtained by applying the function `addOrderOf` to each element of the universal finite set is equal to the exponent of the additive monoid `G`. The `addOrderOf` function represents the order of an element in the group, while the `exponent` of an additive group is defined as the smallest positive integer `n` such that `n • g = 0` for all `g ∈ G`, if it exists.

For any additive monoid and finite type `G` in Lean 4, the least common multiple of the orders of all elements in `Finset.univ` equals the exponent of the additive monoid `G`.


theorem ContinuousMap.idealOfSet_ofIdeal_eq_closure :
    ∀ {X : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : TopologicalSpace X] [inst_2 : CompactSpace X]
      (I : Ideal C(X, 𝕜)), ContinuousMap.idealOfSet 𝕜 (ContinuousMap.setOfIdeal I) = Ideal.closure I :=
  by sorry

This theorem states that for any compact topological space `X` and any ring `𝕜` that behaves like real or complex numbers (captured by `RCLike 𝕜`), given an ideal `I` in the ring of continuous functions from `X` to `𝕜`, the ideal constructed from the set of points where each function in the ideal vanishes (using `ContinuousMap.setOfIdeal`) and then taking the ideal of functions vanishing outside this set (using `ContinuousMap.idealOfSet`) is equal to the closure of the original ideal `I` in the topological space of the ring (using `Ideal.closure`). This essentially implies a type of continuity or closeness between the original ideal and the ideal constructed from the set of vanishing points.

For any compact topological space X and RCLike ring 𝕜, the closure of an ideal I in the ring of continuous functions from X to 𝕜 is equal to the ideal generated by the functions in I that vanish on the set of points where all functions in I equal 0.


/-- The `k`th coefficient of `Polynomial.taylor r f` is `(Polynomial.hasseDeriv k f).eval r`.  -/
theorem Polynomial.taylor_coeff :
    ∀ {R : Type u_1} [inst : Semiring R] (r : R) (f : Polynomial R) (n : ℕ),
      Polynomial.coeff ((Polynomial.taylor r) f) n = Polynomial.eval r ((Polynomial.hasseDeriv n) f) :=
  by sorry

The theorem `Polynomial.taylor_coeff` asserts that for any semiring `R`, any element `r` of `R`, any polynomial `f` over `R`, and any natural number `n`, the `n`th coefficient of the Taylor expansion of `f` at `r` is equal to the evaluation at `r` of the `n`th Hasse derivative of `f`. In mathematical notation, this is saying that if `f` is a polynomial and `r` is a point, then the `n`th coefficient of the Taylor series of `f` around `r` is equal to the value at `r` of the `n`th Hasse derivative of `f`. The Hasse derivative is a variant of the derivative that incorporates binomial coefficients.

For any semiring `R`, polynomial `f` over `R`, element `r` in `R`, and natural number `n`, the `n`th coefficient of the Taylor expansion of `f` at `r` equals the `n`th Hasse derivative of `f` evaluated at `r`.


/-- **Alias** of `List.append_of_mem`. -/
theorem List.mem_split : ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → ∃ s t, l = s ++ a :: t := by sorry

This theorem, `List.mem_split`, states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, if `a` is an element of `l`, then there exist two lists `s` and `t` such that `l` can be expressed as the concatenation of `s`, the singleton list containing `a`, and `t`. In other words, if an element is in a list, then the list can be split into two parts: one part before the occurrence of the element and one part after.

If `α` is a type, `a` is an element of list `l` of type `α`, then `l` can be expressed as `s :: [a] :: t` for some lists `s` and `t`.


theorem Finset.box_succ_eq_sdiff :
    ∀ {α : Type u_1} [inst : OrderedRing α] [inst_1 : LocallyFiniteOrder α] [inst_2 : DecidableEq α] (n : ℕ),
      Finset.box (n + 1) = Finset.Icc (-↑(Nat.succ n)) ↑(Nat.succ n) \ Finset.Icc (-↑n) ↑n :=
  by sorry

The theorem `Finset.box_succ_eq_sdiff` states that for any given natural number `n` and any type `α` that is an ordered ring with a locally finite order and decidable equality, the hollow box centered at `0` going from `-n-1` to `n+1` (represented by `Finset.box (n + 1)`) is equivalent to the set difference of the interval from `-n-1` to `n+1` and the interval from `-n` to `n` (represented by `Finset.Icc (-↑(Nat.succ n)) ↑(Nat.succ n) \ Finset.Icc (-↑n) ↑n`). In other words, the hollow box at the `n+1` level is formed by removing the box at the `n` level from the solid box at the `n+1` level.

For any ordered ring type `α` with locally finite order and decidable equality, the hollow box `Finset.box (Nat.succ n)` centered at `0` in `Finset (α)` is equal to the set difference of the interval `Finset.Icc (-↑(Nat.succ n)) ↑(Nat.succ n)` and the interval `Finset.Icc (-↑n) ↑n` in `Finset (α)`.


theorem Subgroup.eq_top_of_card_eq :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : Fintype ↥H] [inst_2 : Fintype G],
      Fintype.card ↥H = Fintype.card G → H = ⊤ :=
  by sorry

This theorem states that for any group `G` and any subgroup `H` of `G`, if the number of elements in `H` (denoted as `Fintype.card ↥H`) is equal to the number of elements in `G` (denoted as `Fintype.card G`), then the subgroup `H` must be equal to the entire group `G`. In other words, if a subgroup and the group have the same cardinality, the subgroup is the whole group.

If a subgroup of a group has the same number of elements as the group, then the subgroup is equal to the group.


HasDerivAt.mul

theorem HasDerivAt.mul :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_2} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸] {c d : 𝕜 → 𝔸} {c' d' : 𝔸},
      HasDerivAt c c' x → HasDerivAt d d' x → HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x :=
  by sorry

This theorem, `HasDerivAt.mul`, states that for any type `𝕜` which is a non-trivially normed field and any type `𝔸` which is a normed ring and also a normed algebra over `𝕜`, given two functions `c, d` from `𝕜` to `𝔸` and their respective derivatives `c'` and `d'` at a point `x` in `𝕜`, if `c` has derivative `c'` at `x` and `d` has derivative `d'` at `x`, then the derivative at `x` of the function that maps `y` to the product of `c y` and `d y`, is `(c' * d x) + (c x * d')`.

In mathematical terms, if we have two functions `c` and `d` differentiable at point `x`, then the derivative of the function `f(y) = c(y) * d(y)` at point `x` is given by the Leibniz product rule: `f'(x) = c'(x) * d(x) + c(x) * d'(x)`.

Given two differentiable functions $c$ and $d$ from a normed field $ℝ$ to a normed ring and algebra $𝔸$ over $ℝ$, the derivative of their product function $f(y) = c(y) \cdot d(y)$ at a point $x$ is given by the Leibniz product rule: $f'(x) = c'(x) \cdot d(x) + c(x) \cdot d'(x)$.


theorem Matroid.Basis.mem_of_insert_indep :
    ∀ {α : Type u_1} {M : Matroid α} {I X : Set α} {e : α}, M.Basis I X → e ∈ X → M.Indep (insert e I) → e ∈ I := by
  sorry

The theorem `Matroid.Basis.mem_of_insert_indep` states that for any type `α`, any matroid `M` over `α`, any two sets `I` and `X` of `α`, and any element `e` of type `α`, if `I` is a basis of `X` in `M`, `e` is an element of `X`, and the set obtained by inserting `e` into `I` is independent in `M`, then `e` is an element of `I`. In other words, in a matroid, if we have an independent set that is also a basis for another set, and an element from that other set can be added without destroying independence, then that element was already in the original basis.

If `I` is a basis of a matroid `M` over `α`, `e` is an element of `X` in `M` with `I ∣ X` independent, then `e` is an element of `I`.


Memℓp.neg

theorem Memℓp.neg :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      Memℓp f p → Memℓp (-f) p :=
  by sorry

The theorem `Memℓp.neg` states that for any type `α`, any function `E : α → Type` that maps `α` to a Normed Additive Commutative Group, any extended nonnegative real number `p`, and any function `f : (i : α) → E i`, if `f` belongs to `ℓp` (denoted as `Memℓp f p`), then the negation of `f` (denoted as `-f`) also belongs to `ℓp`. This means the property defined by `Memℓp` is preserved under negation of the function. This property is important in the context of sequences or series in functional analysis and measure theory, where `ℓp` spaces play a significant role.

If `f : α → E α` belongs to the `ℓp` space with respect to aNormed Additive Commutative Group `E : α → Type`, then the negation of `f` also belongs to the `ℓp` space with respect to `E`.


theorem Stream'.WSeq.flatten_think :
    ∀ {α : Type u} (c : Computation (Stream'.WSeq α)),
      Stream'.WSeq.flatten (Computation.think c) = Stream'.WSeq.think (Stream'.WSeq.flatten c) :=
  by sorry

The theorem `Stream'.WSeq.flatten_think` states that for any computation `c` of a weak sequence (a sequence of optional values) of any type `α`, running the computation `c` for one "tick" and then flattening the result is the same as first flattening the computation `c` and then running the result for one "tick". In other words, the order of flattening (converting a computation yielding a weak sequence into a weak sequence) and "thinking" (running a computation for one tick) doesn't change the final outcome of the computation. This theorem is essentially about the commutativity of these two operations.

For any weak sequence computation `c` of type `α`, the result of thinking `c` and then flattening is equal to flattening `c` and then thinking the resulting weak sequence.


theorem Finset.truncatedInf_of_mem :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : BoundedOrder α] [inst_2 : DecidableRel fun x x_1 => x ≤ x_1]
      {s : Finset α} {a : α} (h : a ∈ upperClosure ↑s),
      Finset.truncatedInf s a = Finset.inf' (Finset.filter (fun x => x ≤ a) s) ⋯ id :=
  by sorry

The theorem `Finset.truncatedInf_of_mem` states that for any type `α` that is a semilattice with respect to the operation "infimum", has a bounded order, and has a decidable relation for less than or equal to operation, if a given element `a` of type `α` is in the upper closure of a finite set `s` (i.e., `a` is an upper bound of some element of `s`), then the truncated infimum of `s` and `a` is equivalent to the infimum of the set obtained by filtering `s` to include only those elements less than or equal to `a`.
This essentially means that the lower bound of the elements of `s` that are less than or equal to `a` (or the least element if it exists) is the same whether we consider it within the entire set `s` or within the subset of `s` that is less than or equal to `a`.

If `α` is a semilattice with decidable order relation and bounded order, and `a` is an upper bound of some element in the finite set `s` of `α`, then the truncated infimum of `s` and `a` equals the infimum of `s` restricted to elements less than or equal to `a`.


theorem min_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 : α),
      min (a + c) (b + c) = min a b + c :=
  by sorry

The theorem `min_add_add_right` states that for all types `α` which have a linear order and an addition operation (the operation must be covariant, i.e., if `x ≤ y` then `x + z ≤ y + z` for all `z`), the minimum of `a + c` and `b + c` is equal to the minimum of `a` and `b` added to `c`. In mathematical terms, this can be written as: ∀ a, b, c ∈ α, min(a + c, b + c) = min(a, b) + c. It essentially describes a property of the addition operation in a ordered additive structure in the presence of a minimum operation.

For all types `α` with a covariant addition and a minimum operation, the minimum of `a + c` and `b + c` equals `min(a, b) + c`.


/-- A monotone map has a limit to the left of any point `x`, equal to `sSup (f '' (Iio x))`.  -/
theorem Monotone.tendsto_nhdsWithin_Iio :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : ConditionallyCompleteLinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderTopology β]
      {f : α → β}, Monotone f → ∀ (x : α), Filter.Tendsto f (nhdsWithin x (Set.Iio x)) (nhds (sSup (f '' Set.Iio x))) :=
  by sorry

This theorem asserts that for any given point `x` and a function `f` that is monotone (meaning if `a ≤ b` then `f(a) ≤ f(b)`), the function `f` has a limit to the left of `x`, which is equal to the supremum (`sSup`) of the image of the function `f` over the left-open interval up to `x` (`Iio x`). Here, `Filter.Tendsto` describes the limit of the function, `nhdsWithin` describes the neighborhood within a set, and `nhds` indicates the neighborhood filter around a given point. The set `Iio x` represents all elements less than `x`. So, in simpler terms, the theorem says that for a function that is increasing, the limit of the function as it approaches any point from the left (or lower values) is the greatest value that the function takes on for inputs less than that point.

For a monotone function `f`, the left limit of `f` at a point `x` equals the supremum of `f` over the left-open interval around `x`.


/-- If two functions are equal in a neighbourhood of `x`, then for `y` sufficiently close
to `x` these functions are equal in a neighbourhood of `y`.  -/
theorem Filter.EventuallyEq.eventuallyEq_nhds :
    ∀ {X : Type u} {α : Type u_1} {x : X} [inst : TopologicalSpace X] {f g : X → α},
      f =ᶠ[nhds x] g → ∀ᶠ (y : X) in nhds x, f =ᶠ[nhds y] g :=
  by sorry

This theorem states that if two functions are equal in a neighborhood of a point `x` (in a topological space `X`), then for each point `y` in a neighborhood around `x`, the two functions are also equal in a neighborhood around `y`. In mathematical terms, it means that if `f` and `g` are two functions from `X` to any type `α` such that `f` and `g` are equal at a vicinity of a point `x` (expressed as `f =ᶠ[nhds x] g`), then for almost every point `y` in the vicinity of `x` (expressed as `∀ᶠ (y : X) in nhds x`), `f` and `g` are also equal in the vicinity of `y` (expressed as `f =ᶠ[nhds y] g`).

If functions $f$ and $g$ are equal in a neighborhood of a point $x$ in a topological space, then they are equal in the neighborhoods of almost all points $y$ around $x$.


theorem Ordinal.derivFamily_fp :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {i : ι},
      Ordinal.IsNormal (f i) → ∀ (o : Ordinal.{max u v}), f i (Ordinal.derivFamily f o) = Ordinal.derivFamily f o :=
  by sorry

This theorem states that for any type `ι`, any function `f` from `ι` and an ordinal to an ordinal, and any element `i` of type `ι`, if `f i` is a normal ordinal function, then for any ordinal `o`, applying `f i` to the derivative of the family `f` at `o` results in the derivative of the family `f` at `o` itself. In other words, the derivative of the family `f` at `o` is a fixed point of the function `f i` when `f i` is a normal ordinal function.

For any function `f` from a type `ι` to ordinal numbers, and any `i` in `ι` such that `f i` is a normal ordinal function, the derivative of `f` at an ordinal `o` is equal to `f i` applied to the derivative of `f` at `o`.


IsMaxFilter.congr

theorem IsMaxFilter.congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → f =ᶠ[l] g → f a = g a → IsMaxFilter g l a :=
  by sorry

The theorem `IsMaxFilter.congr` states that for any two functions `f` and `g` from a type `α` to an ordered type `β`, if `f` has a property that it reaches its maximum (`IsMaxFilter`) at a point `a` according to some `l`-neighborhood, and `f` equals `g` almost everywhere in this `l`-neighborhood, and moreover `f(a) = g(a)`, then `g` also has the `IsMaxFilter` property at `a` with respect to the same `l`-neighborhood. In other words, if `f` and `g` are essentially the same in the `l`-neighborhood of `a` and `f` attains its maximum at `a`, then `g` also attains its maximum at `a`.

If functions `f` and `g` from type `α` to an ordered type `β` agree and have maximum value at point `a` within an `l`-neighborhood, then `g` also has maximum value at `a` within that same `l`-neighborhood.


ContMDiffMap.ext

theorem ContMDiffMap.ext :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {H : Type u_4} [inst_5 : TopologicalSpace H] {H' : Type u_5} [inst_6 : TopologicalSpace H']
      {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'} {M : Type u_6} [inst_7 : TopologicalSpace M]
      [inst_8 : ChartedSpace H M] {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {n : ℕ∞}
      {f g : ContMDiffMap I I' M M' n}, (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, any normed additive commutative groups `E` and `E'`, any topological spaces `H`, `H'`, `M` and `M'`, any model with corners `I` and `I'` over `𝕜`, and any continuously differentiable map `f` and `g` between `M` and `M'` of class `n`, if `f` and `g` are equal at every point in `M`, then `f` and `g` are indeed the same map. In other words, two continuously differentiable maps are equal if they are equal at every point in their domain.

For any nontrivially normed field `𝕜`, if two continuously differentiable maps between Banach spaces over `𝕜` are equal at every point, then they are equal.


theorem DomMulAct.stabilizerEquiv_invFun_eq :
    ∀ {α : Type u_1} {ι : Type u_2} {f : α → ι} (g : (i : ι) → Equiv.Perm { a // f a = i }) {a : α} {i : ι}
      (h : f a = i), DomMulAct.stabilizerEquiv_invFun g a = ↑((g i) { val := a, property := h }) :=
  by sorry

The theorem `DomMulAct.stabilizerEquiv_invFun_eq` states that for any types `α` and `ι`, and any function `f` from `α` to `ι`, along with a function `g` which associates each element of `ι` to a permutation of the subset of `α` where `f` equals that element, for any given elements `a` in `α` and `i` in `ι` such that `f(a)` equals `i`, the `invFun` of the `stabilizerEquiv` applied to `g` and `a` is equal to the application of the permutation `g(i)` to the element `a` with the proof that `f(a)` equals `i`.

For any function `f: α → ι` and permutation function `g: ι → permission (α × α)`, if `a ∈ α` and `i ∈ ι` satisfy `f(a) = i`, then `(stabilizerEquiv g a).invFun a = g(i)(a)`.


theorem MeasureTheory.Measure.ae_le_iff_absolutelyContinuous :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      MeasureTheory.Measure.ae μ ≤ MeasureTheory.Measure.ae ν ↔ MeasureTheory.Measure.AbsolutelyContinuous μ ν :=
  by sorry

The theorem `MeasureTheory.Measure.ae_le_iff_absolutelyContinuous` states that for any given type `α`, measurable space `m0`, and measures `μ` and `ν` on `α`, the measure `μ` is almost everywhere less than or equal to the measure `ν` if and only if `μ` is absolutely continuous with respect to `ν`. In other words, `μ` is dominated by `ν` (meaning if `ν(A) = 0` then `μ(A) = 0`) if and only if for almost every element under `μ`, it is also in `ν`.

A measurable set function $\mu$ is almost everywhere less than or equal to another measurable set function $\nu$ on the same measurable space if and only if $\mu$ is absolutely continuous with respect to $\nu$.


theorem Nat.sum_divisorsAntidiagonal :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ},
      (Finset.sum (Nat.divisorsAntidiagonal n) fun i => f i.1 i.2) = Finset.sum (Nat.divisors n) fun i => f i (n / i) :=
  by sorry

The theorem `Nat.sum_divisorsAntidiagonal` states that for any natural number `n` and any function `f` from pairs of natural numbers to a type `M` that has an addition operation, the sum of `f` applied to each pair in the divisor antidiagonal of `n` is equal to the sum of `f` applied to each divisor of `n` and `n` divided by that divisor. In other words, it expresses a relationship between the sum over the divisors of a number and the sum over its divisor pairs, under a given function `f`.

For any natural number `n` and function `f` from pairs of natural numbers to a type with addition, the sum of `f` applied to each divisor pair in the antidiagonal of `n` equals the sum of `f` applied to each divisor of `n` and the quotient of `n` by that divisor.


/-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same `Field.finSepDegree`
over `F`.  -/
theorem Field.finSepDegree_eq_of_equiv :
    ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w)
      [inst_3 : Field K] [inst_4 : Algebra F K], (E ≃ₐ[F] K) → Field.finSepDegree F E = Field.finSepDegree F K :=
  by sorry

The theorem `Field.finSepDegree_eq_of_equiv` states that for any fields `F`, `E`, and `K` such that `F` is an algebra over `E` and `K`, if `E` and `K` are isomorphic as `F`-algebras, then they have the same finite separable degree over `F`. The finite separable degree of a field extension `E / F` is defined as the number of `F`-algebra homomorphisms from `E` to its algebraic closure, represented as a natural number, except when there are infinitely many of such homomorphisms, in which case it is defined to be zero.

If fields `F`, `E`, and `K` are such that `F` is an algebra over `E` and `K`, and `E` and `K` are isomorphic as `F`-algebras, then they have the same finite separable degree over `F`.


theorem real_inner_self_eq_norm_sq :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x : F), ⟪x, x⟫_ℝ = ‖x‖ ^ 2 := by
  sorry

This theorem states that for every element `x` in an inner product space `F` over the real numbers, the inner product of `x` with itself (`⟪x, x⟫_ℝ`) is equal to the square of the norm of `x` (`‖x‖ ^ 2`). In other words, it represents the Pythagorean theorem in the context of real inner product spaces: the square of the length of a vector is equal to the square of its components summed together.

For every element `x` in a real inner product space, the inner product of `x` with itself equals the square of its norm: `⟪x, x⟫_ℝ = ‖x‖ ^ 2`.


theorem Set.smul_set_iUnion :
    ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} [inst : SMul α β] (a : α) (s : ι → Set β),
      a • ⋃ i, s i = ⋃ i, a • s i :=
  by sorry

The theorem `Set.smul_set_iUnion` states that for all types α and β, for all sort ι, given an instance of scalar multiplication (`SMul`) on α and β, a scalar `a` of type α and a function `s` from ι to a set of β, the scalar multiplication of `a` with the union (over some index set ι) of the sets `s i` is equal to the union of the scalar multiplication of `a` with each individual set `s i`. In mathematical terms, this can be written as \(a \cdot \bigcup_{i} s_i = \bigcup_{i} a \cdot s_i\).

For any types α and β with scalar multiplication, and for any function from an index set to sets of β, the scalar multiplication of an element by the union of the sets is equal to the union of the scalar multiplications of that element by each set. In other words, \(a \cdot \bigcup\_{i} s\_i = \bigcup\_{i} a \cdot s\_i\).


theorem Asymptotics.isBigO_of_le :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      (l : Filter α), (∀ (x : α), ‖f x‖ ≤ ‖g x‖) → f =O[l] g :=
  by sorry

This theorem, `Asymptotics.isBigO_of_le`, states that for all types `α`, `E`, and `F`, where `E` and `F` are types with a norm (a function that assigns a strictly positive length or size to each vector in a vector space), and given any function `f` from `α` to `E`, and `g` from `α` to `F`, along with a filter `l` on `α`, if the norm of `f(x)` is always less than or equal to the norm of `g(x)` for every `x` in `α`, then `f` is Big O of `g` at the filter `l`. In Big O notation, this is saying that `f` grows no faster than `g`, considering the limits as `x` approaches the elements determined by the filter `l`.

Given types `α`, `E` with a norm, functions `f: α → E` and `g: α → F` from `α` to normed types `E` and `F`, and a filter `l` on `α`, if `||f(x)|| ≤ ||g(x)||` for all `x` in `α`, then `f` is Big O of `g` at filter `l`.


theorem biInf_inf :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α} {a : α},
      (∃ i, p i) → (⨅ i, ⨅ (h : p i), f i h) ⊓ a = ⨅ i, ⨅ (h : p i), f i h ⊓ a :=
  by sorry

This theorem states that for any type `α` which forms a complete lattice, any indexed set of elements of `α` (via some function `f` from indices `i` of type `ι` satisfying a certain property `p` to `α`), and any element `a` of `α`, if there exists at least one index satisfying the property `p`, then the infimum over all `f i` (for `i` satisfying `p`) intersected with `a` is equal to the infimum over all `(f i) ⊓ a` (for `i` satisfying `p`).

In other words, the infimum of the intersection is the same as the intersection of the infimums, provided there's some valid index.

For any complete lattice `α`, if `f : ι → α` is a function such that for some property `p` on indices `i` of type `ι`, the infimum of `{f i | i : ι, p i}` intersect `a` equals the infimum of `{f i ⊓ a | i : ι, p i}` when there exists an `i` satisfying `p`.


/-- Existence of a conditional kernel. Use the definition `condKernel` to get that kernel.  -/
theorem ProbabilityTheory.exists_cond_kernel :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} {Ω : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
      [inst_2 : Nonempty Ω] (ρ : MeasureTheory.Measure (α × Ω)) [inst_3 : MeasureTheory.IsFiniteMeasure ρ]
      (γ : Type u_3) [inst_4 : MeasurableSpace γ],
      ∃ η,
        ∃ (_ : ProbabilityTheory.IsMarkovKernel η),
          ProbabilityTheory.kernel.const γ ρ =
            ProbabilityTheory.kernel.compProd (ProbabilityTheory.kernel.const γ (MeasureTheory.Measure.fst ρ))
              (ProbabilityTheory.kernel.prodMkLeft γ η) :=
  by sorry

This theorem, named `ProbabilityTheory.exists_cond_kernel` is about the existence of a conditional kernel in the context of probability theory.

It states that for any measurable spaces `α` and `Ω` with `Ω` being a standard Borel space and non-empty, and for any finite measure `ρ` on the product space `α × Ω`, and for any measurable space `γ`, there exists a kernel `η` such that `η` is a Markov kernel, and the constant kernel with measure `ρ` is equal to the composition of the constant kernel with the marginal measure of `ρ` and the kernel obtained by taking the comap of the projection from `η`.

In simpler terms, this theorem guarantees that, under certain conditions, we can find a transition kernel that represents the conditional probability distribution of some random variable given its past history, effectively forming a Markov chain.

Given any finite measure on a product space of two measurable spaces with the second space being standard Borel and non-empty, there exists a Markov kernel whose constant kernel equals the composition of the marginal measure and the conditional kernel obtained by projecting onto the second space.


theorem AddSubgroup.isComplement_univ_singleton :
    ∀ {G : Type u_1} [inst : AddGroup G] {g : G}, AddSubgroup.IsComplement Set.univ {g} := by sorry

This theorem states that for any given type `G` that has an additive group structure, and any element `g` of `G`, the set of all elements of `G` (denoted by `Set.univ`) and the singleton set containing just the element `g` are complements. Here, two sets `S` and `T` being complements (in the context of additive groups) means that the function that adds an element of `S` to an element of `T` is a bijection, i.e., every element of the group `G` can be written uniquely as the sum of an element from `S` and an element from `T`. So, every element of the group `G` can be uniquely expressed as the sum of some other element of `G` and the specific element `g`.

For any additive group `G` and element `g` in `G`, the sets `Set.univ` and the singleton set `{g}` are complementary in the sense that their elements can be paired to form every element in `G` in a unique way.


theorem Nat.dvd_add_iff_left : ∀ {k m n : ℕ}, k ∣ n → (k ∣ m ↔ k ∣ m + n) := by sorry

This theorem states that for all natural numbers `k`, `m`, and `n`, if `k` divides `n`, then `k` divides `m` if and only if `k` divides `m + n`. In mathematical notation, this can be written as: ∀ k, m, n ∈ ℕ, if k | n, then k | m ⇔ k | (m + n).

For all natural numbers `k`, `m`, and `n`, `k` divides `m` if and only if `k` divides `m + n`. (Or, equivalently, `k` | `m` ⇔ `k` | `(m + n)`.)


theorem FirstOrder.Language.model_nonemptyTheory_iff :
    ∀ (L : FirstOrder.Language) {M : Type w} [inst : FirstOrder.Language.Structure L M],
      M ⊨ FirstOrder.Language.nonemptyTheory L ↔ Nonempty M :=
  by sorry

This theorem connects the concepts of a structure and nonemptiness in a first-order language. Specifically, for a given first-order language 'L' and a type 'M' that has a structure in 'L', the theorem states that 'M' is a model of the nonempty theory of 'L' if and only if 'M' is nonempty. In other words, a type 'M' satisfies all sentences in the nonempty theory of 'L' (i.e., there is at least one element in 'M') if and only if there exists at least one element in 'M'.

For a first-order language L and a nonempty type M in it, M is a model of L's nonempty theory if and only if M is nonempty.


/-- A set is a neighborhood of `a` within `(-∞, a)` if and only if it contains an interval `(l, a)`
with `l < a`, provided `a` is not a bottom element.  -/
theorem mem_nhdsWithin_Iio_iff_exists_Ioo_subset' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a l' : α}
      {s : Set α}, l' < a → (s ∈ nhdsWithin a (Set.Iio a) ↔ ∃ l ∈ Set.Iio a, Set.Ioo l a ⊆ s) :=
  by sorry

The theorem `mem_nhdsWithin_Iio_iff_exists_Ioo_subset'` asserts that for any type `α` that has a topological space structure, a linear order, and an order topology, and for any elements `a` and `l'` of type `α` and a set `s` of type `α`, if `l'` is less than `a`, then `s` is a neighborhood of `a` within the set of elements less than `a` (`(-∞, a)`) if and only if there exists an element `l` less than `a` such that the open interval from `l` to `a` (`(l, a)`) is a subset of `s`. Here, a "neighborhood of `a` within `(-∞, a)`" is a set that contains the intersection of `(-∞, a)` and a neighborhood of `a`, and an "open interval from `l` to `a`" is the set of elements that are greater than `l` and less than `a`.

For any topological space with a linear order and order topology, an element `a` has a neighborhood `s` within the set of elements less than `a` if and only if there exists an element `l` less than `a` such that the open interval `(l, a)` is a subset of `s`.