theorem Finset.erase_eq_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → Finset.erase s a = s := by sorry

The theorem `Finset.erase_eq_of_not_mem` states that for any type `α` that has decidable equality (meaning it's possible to determine if any two elements of the type are equal or not), if an element `a` of `α` is not in the finite set `s` (denoted by `a ∉ s`), then removing `a` from `s` (using the `Finset.erase` function) results in the same set `s`. In other words, erasing a non-member from a finite set leaves the set unchanged.

If `a` is not an element of the finite set `s`, then `Finset.erase a s = s`.


theorem Metric.mem_ball :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, y ∈ Metric.ball x ε ↔ dist y x < ε := by sorry

This theorem, named `Metric.mem_ball`, states that for any pseudometric space `α` and any elements `x` and `y` of `α`, along with a real number `ε`, the element `y` belongs to the ball of radius `ε` centered at `x` if and only if the distance from `y` to `x` is less than `ε`. In mathematical terms, this states that $y \in B(x, \epsilon)$ if and only if $d(y, x) < \epsilon$, where $B(x, \epsilon)$ represents the ball of radius $\epsilon$ centered at $x$ and $d(y, x)$ represents the distance from `y` to `x` in the pseudometric space.

For any pseudometric space and elements, an element belongs to the ball of radius ε centered at another element if and only if the distance between them is less than ε.


theorem MonoidHom.mem_ker :
    ∀ {G : Type u_1} [inst : Group G] {M : Type u_7} [inst_1 : MulOneClass M] (f : G →* M) {x : G},
      x ∈ MonoidHom.ker f ↔ f x = 1 :=
  by sorry

The theorem `MonoidHom.mem_ker` states that for any group `G`, any type `M` with a multiplication and a multiplicative identity, and any monoid homomorphism `f` from `G` to `M`, an element `x` of `G` belongs to the multiplicative kernel of `f` if and only if the evaluation of `f` at `x` equals the multiplicative identity of `M`. In mathematical terms, this is saying if `f : G → M` is a monoid homomorphism, then `x ∈ ker(f)` if and only if `f(x) = 1`, where `ker(f)` is the kernel of `f`, i.e., the set of elements in `G` that `f` maps to `1`.

For any monoid homomorphism `f : G → M` between a group `G` and a monoid `M` with identity, an element `x` in `G` is in the kernel of `f` if and only if `f(x) = 1`.


theorem Finset.sum_neg_distrib :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f : α → β} [inst : SubtractionCommMonoid β],
      (Finset.sum s fun x => -f x) = -Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_neg_distrib` states that for any finite set `s` of type `α`, and for any function `f` from `α` to `β` where `β` is a subtraction commutative monoid, the sum over `s` of the negation of `f(x)` (i.e., `∑ x in s, -f x`) is equal to the negation of the sum over `s` of `f(x)` (i.e., `- ∑ x in s, f x`). This is a distributive property of the sum operation over the negative operation.

For any finite set `s` and function `f` from a subtraction commutative monoid to itself, the sum of the negations of `f(x)` over `s` is equal to the negation of the sum of `f(x)` over `s`.


theorem Fin.insertNth_apply_same :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (i : Fin (n + 1)) (x : α i) (p : (j : Fin n) → α (Fin.succAbove i j)),
      Fin.insertNth i x p i = x :=
  by sorry

The theorem `Fin.insertNth_apply_same` asserts that for any natural number `n`, any type function `α` indexed by `Fin (n + 1)`, any element `i` of `Fin (n + 1)`, any element `x` of `α i`, and any function `p` mapping elements of `Fin n` to `α (Fin.succAbove i j)`, when we insert `x` into the tuple defined by `p` at position `i` using `Fin.insertNth`, the value at position `i` of the resulting tuple is `x`. In other words, the inserted element `x` is exactly at the position `i` in the modified tuple.

For any natural number `n`, any type function `α` indexed by `Fin (n + 1)`, any `i` in `Fin (n + 1)`, any `x` in `α i`, and any function `p : Fin n -> α (Fin.succAbove i j)`, the application `Fin.insertNth p i x` results in a tuple where the `i`-th element is `x`.


theorem Real.rpow_le_rpow_of_exponent_le : ∀ {x y z : ℝ}, 1 ≤ x → y ≤ z → x ^ y ≤ x ^ z := by sorry

This theorem states that for all real numbers x, y, and z, if x is greater than or equal to 1 and y is less than or equal to z, then x raised to the power of y is less than or equal to x raised to the power of z. In other words, for any real number x that is at least 1, increasing the exponent from y to z (where z ≥ y) only increases (or keeps the same) the power of x.

For all real numbers x, y, and z with x ≥ 1 and y ≤ z, x^y ≤ x^z.


theorem coe_nnnorm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), ↑‖a‖₊ = ‖a‖ := by sorry

This theorem, `coe_nnnorm`, states that for any instance `a` of a type `E`, which is a semi-normed add group, the non-negative real value of the norm of `a` is equal to the norm of `a`. In other words, it says that the norm of an element in a seminormed add group is always a non-negative real number, and when you convert this non-negative real number back into a real number, you get the original norm value.

For any semi-normed add group element `a`, the norm of `a` equals its non-negative real value.


theorem Set.InjOn.eq_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α},
      Set.InjOn f s → x ∈ s → y ∈ s → (f x = f y ↔ x = y) :=
  by sorry

This theorem states that for any sets `α` and `β` with `s` as a subset of `α`, and any function `f` from `α` to `β`, and any elements `x` and `y` from `α`, if `f` is injective on `s`, and both `x` and `y` are elements of `s`, then `f(x)` equals `f(y)` if and only if `x` equals `y`. In more mathematical terms, it expresses the property of an injective function where distinct inputs from a certain set produce distinct outputs.

If `f` is an injective function from set `α` to set `β` and `x`, `y` are elements of subset `s` of `α`, then `f(x) = f(y)` if and only if `x = y`.


LinearIndependent.comp

/-- A subfamily of a linearly independent family (i.e., a composition with an injective map) is a
linearly independent family.  -/
theorem LinearIndependent.comp :
    ∀ {ι : Type u'} {ι' : Type u_1} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      LinearIndependent R v → ∀ (f : ι' → ι), Function.Injective f → LinearIndependent R (v ∘ f) :=
  by sorry

This theorem states that if you have a family of vectors `v` that is linearly independent over a semiring `R`, and if you have an injective function `f` that maps from one type `ι'` to another type `ι`, then the subfamily of vectors obtained by composing `v` and `f` (i.e., `v ∘ f`) is also linearly independent over `R`. In other words, a subfamily of a linearly independent family, obtained through an injective map, remains linearly independent. This theorem holds for semirings `R` and modules `M` that are additively commutative monoids.

If `{v\_i : V}` is a linearly independent family of vectors over a commutative additive monoid `M` as a semiring, and `f : ι' -> ι` is an injective function, then `{v\_i ∘ f : V}` is a linearly independent family of vectors over `M`.


theorem Part.eq_some_iff : ∀ {α : Type u_1} {a : α} {o : Part α}, o = Part.some a ↔ a ∈ o := by sorry

The theorem `Part.eq_some_iff` asserts that for any type `α`, any element `a` of type `α`, and any partial function `o` of type `Part α`, `o` is equal to the partial function `Part.some a` if and only if `a` is in the domain of `o`. In other words, a partial function is equivalent to `Part.some a` (a function with a `True` domain that always returns `a`) if and only if `a` is an element of the domain of the function. This theorem establishes the bidirectional relationship between the identity of a partial function and the presence of a specific element within its domain.

For any partial function `o` of type `Part α` and element `a` of type `α`, `o = Part.some a` if and only if `a` is in the domain of `o`.


theorem neg_sq : ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : HasDistribNeg R] (a : R), (-a) ^ 2 = a ^ 2 := by sorry

This theorem, `neg_sq`, states that for any type `R` that is a monoid and supports distributed negation, the square of the negation of any element `a` from `R`, is equal to the square of `a` itself. In mathematical terms, this theorem says that `(-a)^2 = a^2` for all `a` in `R`. This is a generalization of a common property in number systems, that the square of a number and its negation are equal.

For any monoid `R` with distributed negation, `(-a)^2 = a^2` for all `a` in `R`.


theorem Filter.eventually_all :
    ∀ {α : Type u} {ι : Sort u_2} [inst : Finite ι] {l : Filter α} {p : ι → α → Prop},
      (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x :=
  by sorry

This theorem, `Filter.eventually_all`, states that, for any type `α`, any sort `ι` (where `ι` is finite), any filter `l` on `α`, and any property `p` from `ι` to `α` to a proposition, the following two statements are equivalent:

1. For every value `x` from `α` that eventually appears in the filter `l`, the property `p` holds for all `i` from `ι`.

2. For each `i` from `ι`, the property `p` holds for every value `x` from `α` that eventually appears in the filter `l`.

In other words, we can switch the order of the universal quantifiers without changing the meaning of the statement when discussing properties that eventually hold in a filter.

For any type `α`, filter `l` on `α`, finite sort `ι`, and property `p` from `ι` to `α` to a proposition, `p` holds for all eventually filtered elements if and only if it holds for every eventually filtered element for each `i` in `ι`.


theorem MeasureTheory.ae_restrict_mem :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → ∀ᵐ (x : α) ∂μ.restrict s, x ∈ s :=
  by sorry

The theorem `MeasureTheory.ae_restrict_mem` states that for any type `α`, equipped with a measurable space structure `m0` and a measure `μ`, if `s` is a set of elements of type `α` and is measurable, then almost every element `x` of type `α` with respect to the restriction of `μ` to `s`, belongs to `s`. In layman's terms, if we restrict our attention to the set `s`, almost all of the points we "randomly" encounter will actually belong to `s`.

For any measurable set `s` and measure `μ` on type `α`, almost every element `x` in `α` with respect to the restriction of `μ` to `s` lies in `s`.


theorem Finset.prod_ne_zero_iff :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f : α → β} [inst : CommMonoidWithZero β] [inst_1 : Nontrivial β]
      [inst_2 : NoZeroDivisors β], (Finset.prod s fun x => f x) ≠ 0 ↔ ∀ a ∈ s, f a ≠ 0 :=
  by sorry

The theorem `Finset.prod_ne_zero_iff` states that for any type `α`, a type `β` that has a commutative monoid structure with zero, is nontrivial and has no zero divisors, a finite set `s` of type `α`, and a function `f` from `α` to `β`, the product of `f(x)` for all `x` in `s` is non-zero if and only if `f(a)` is non-zero for all elements `a` in `s`. Essentially, this theorem asserts that the product of a function's values over a finite set is non-zero if every value produced by the function for elements in the set is non-zero.

For any commutative monoid with zero, having no zero divisors, and a finite set and function, the product of the function values on the set is non-zero if and only if every value is non-zero.


Rel.ext

theorem Rel.ext : ∀ {α : Type u_1} {β : Type u_2} {r s : Rel α β}, (∀ (a : α), r a = s a) → r = s := by sorry

The theorem `Rel.ext` states that for any two relations `r` and `s` between two types `α` and `β`, if for every element `a` of type `α`, `r a` is equivalent to `s a`, then the relations `r` and `s` are themselves equivalent. In other words, two relations are considered identical if they agree on the relationship of every individual element from the domain type `α`.

If for all `a` in type `α`, `r a ≡ s a`, then `r ≡ s` are equivalent relations.


theorem le_of_mul_le_mul_left' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      a * b ≤ a * c → b ≤ c :=
  by sorry

This theorem, `le_of_mul_le_mul_left'`, states that for any type `α` that has a multiplication operation, an order (less than or equal to), and the order is contravariant in the multiplication (meaning that if `x * y` decreases then `x` decreases for any `y`), if the product of `a` and `b` is less than or equal to the product of `a` and `c`, then `b` is less than or equal to `c`. This essentially captures the property in arithmetic that if `a * b` is less than `a * c` (and `a` is not zero), then `b` must be less than `c`.

If `α` is a type with contravariant order and multiplication, and `a * b ≤ a * c`, then `b ≤ c`.


Continuous.pow

theorem Continuous.pow :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Monoid M]
      [inst_3 : ContinuousMul M] {f : X → M}, Continuous f → ∀ (n : ℕ), Continuous fun b => f b ^ n :=
  by sorry

This theorem states that for any types `M` and `X`, where `X` is a topological space and `M` is a topological space with a monoid structure and continuous multiplication, if we have a continuous function `f` from `X` to `M`, then for any natural number `n`, the function defined by taking any element `b` in `X` to the `n`th power of `f(b)` in `M` is also continuous.

Given a topological space X, a topological monoid M with continuous multiplication, and a continuous function f : X -> M, the n-th power function g(x) = f(x)^n is also continuous for any natural number n.


theorem LinearMap.map_smul_of_tower :
    ∀ {M : Type u_9} {M₂ : Type u_11} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂] {R : Type u_17}
      {S : Type u_18} [inst_2 : Semiring S] [inst_3 : SMul R M] [inst_4 : Module S M] [inst_5 : SMul R M₂]
      [inst_6 : Module S M₂] [inst_7 : LinearMap.CompatibleSMul M M₂ R S] (fₗ : M →ₗ[S] M₂) (c : R) (x : M),
      fₗ (c • x) = c • fₗ x :=
  by sorry

This theorem, `LinearMap.map_smul_of_tower`, states that given certain conditions, linear transformation respects the scalar multiplication on two modules. More specifically, it says that for any additively commutative monoids `M` and `M₂`, a semiring `S`, and a scalar multiplication operation `SMul` on `R`, if `M` and `M₂` are also modules over `S` and `SMul` behaves compatibly with certain linear maps from `M` to `M₂`, then for any linear map `fₗ` from `M` to `M₂` over semiring `S`, any scalar `c` of type `R`, and any element `x` of `M`, the image of the scaled element `c • x` under `fₗ` is the same as the scaled image of `x` under `fₗ`, i.e., `fₗ (c • x) = c • fₗ x`. This theorem essentially establishes the compatibility of the linear map with scalar multiplication.

Given additively commutative monoids `M` and `M₂`, a semiring `S`, and a scalar multiplication `SMul` on `R`, if `M`, `M₂`, and `SMul` satisfy certain conditions, then for any linear map `fₗ` from `M` to `M₂` over semiring `S`, `fₗ (c • x) = c • fₗ x` for all scalars `c` of type `R` and elements `x` of `M`.


/-- The axiomatic definition of conditional probability derived from a measure-theoretic one.  -/
theorem ProbabilityTheory.cond_apply :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω},
      MeasurableSet s → ∀ (t : Set Ω), ↑↑(ProbabilityTheory.cond μ s) t = (↑↑μ s)⁻¹ * ↑↑μ (s ∩ t) :=
  by sorry

This theorem pertains to the axiomatic definition of conditional probability derived from a measure-theoretic one. Given a measurable space Ω, a measure μ on that space, and a measurable set s, the theorem states that for any set t, the application of the conditional probability measure of μ on s to t equals the measure of the intersection of s and t multiplied by the inverse of the measure of s. In mathematical terms, this is equivalent to saying that the conditional probability of t given s, represented as `(ProbabilityTheory.cond μ s) t`, is equal to `μ(s ∩ t) / μ(s)`.

The theorem asserts that for a measurable space Ω with measure μ, the conditional probability of a measurable set t given s is equal to the ratio of their intersection's measure to s's measure: `(ProbabilityTheory.cond μ s) t = μ(s ∩ t) / μ(s)`.


theorem isLUB_le_iff :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a b : α}, IsLUB s a → (a ≤ b ↔ b ∈ upperBounds s) := by sorry

The theorem `isLUB_le_iff` states that for any type `α` with a preorder, and for any sets `s` of elements of type `α` and any elements `a` and `b` of type `α`, if `a` is a least upper bound of the set `s`, then `a` is less than or equal to `b` if and only if `b` is an upper bound of the set `s`. In other words, any element that is greater than or equal to the least upper bound of a set is itself an upper bound of that set.

If `a` is the least upper bound of a set `s` in a preordered type `α`, then `a` is less than or equal to every upper bound `b` of `s`.


theorem Submodule.mem_sup :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M}
      {p p' : Submodule R M}, x ∈ p ⊔ p' ↔ ∃ y ∈ p, ∃ z ∈ p', y + z = x :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `M`, and any module `M` over `R`, and given any element `x` of `M` and any two submodules `p` and `p'` of `M`, `x` is in the sup (supremum or join) of `p` and `p'` if and only if there exist elements `y` in `p` and `z` in `p'` such that the sum of `y` and `z` is `x`. In other words, any element in the supremum of two submodules can be expressed as the sum of an element from each of the original submodules.

For any semiring `R`, additive commutative monoid `M` with an `R`-module structure, and submodules `p` and `p'` of `M`, the element `x` belongs to the supremum of `p` and `p'` if and only if there exist `y` in `p` and `z` in `p'` such that `x = y + z`.


Quotient.eq'

theorem Quotient.eq' : ∀ {α : Sort u_1} [s₁ : Setoid α] {a b : α}, Quotient.mk' a = Quotient.mk' b ↔ Setoid.r a b := by
  sorry

The theorem `Quotient.eq'` states that for any type `α` with a given setoid structure `s₁`, and for any two elements `a` and `b` of type `α`, the canonical quotient map `Quotient.mk' a` equals `Quotient.mk' b` if and only if `a` and `b` are related by the equivalence relation `Setoid.r`. In other words, two elements `a` and `b` are sent to the same equivalence class in the quotient structure if and only if they are equivalent under the original setoid's equivalence relation.

For any setoid `(α, s₁)` and elements `a` and `b` of type `α`, `Quotient.mk' a = Quotient.mk' b` if and only if `a s₁ b`.


theorem CategoryTheory.Iso.trans_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z Z' : C} (α : X ≅ Y) (β : Y ≅ Z) (γ : Z ≅ Z'),
      (α ≪≫ β) ≪≫ γ = α ≪≫ β ≪≫ γ :=
  by sorry

This theorem states that in any category `C`, for any objects `X`, `Y`, `Z`, and `Z'` in `C`, and for any isomorphisms `α` from `X` to `Y`, `β` from `Y` to `Z`, and `γ` from `Z` to `Z'`, the composition of the composed isomorphism `(α ≪≫ β)` and `γ` is equal to the composition of `α` and the composed isomorphism `β ≪≫ γ`. This is the associativity law for isomorphism composition in category theory, analogous to the associativity law for multiplication in algebra.

In any category, the composition of two isomorphisms is independent of the order: `(α ≪≫ β) = α ≪≫ γ <=> β ≪≫ γ = γ ≪≫ α`, where `α: X ⟹ Y`, `β: Y ⟹ Z`, and `γ: Z ⟹ Z'` are isomorphisms.


theorem ModelWithCorners.continuous_symm :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      Continuous ↑(ModelWithCorners.symm I) :=
  by sorry

This theorem states that for any ModelWithCorners `I` over a nontrivial normed field `𝕜`, a normed additive commutative group `E`, and a topological space `H`, the inverse of `I`, denoted `ModelWithCorners.symm I`, is a continuous function. Here, continuity is understood in the topological sense, meaning that the preimage of any open set under `ModelWithCorners.symm I` is also an open set.

For any ModelWithCorners `I` over a nontrivial normed field `𝕜`, the symmetry `ModelWithCorners.symm I` of the normed additive commutative group `E` with respect to `I` is a continuous function in the topological sense.


theorem Nat.mod_succ : ∀ (n : ℕ), n % Nat.succ n = n := by sorry

This theorem states that for any natural number `n`, the remainder of `n` divided by its successor (`n+1`) is `n` itself. It essentially demonstrates a property of the modulus operation in the context of natural numbers, where the divisor is the successor of the dividend. This is a reflection of the fact that `n+1` is greater than `n`, so when `n` is divided by `n+1`, the remainder is `n`.

For all natural numbers `n`, `n` is the remainder when `n` is divided by `n+1`.


theorem List.mem_toFinset : ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, a ∈ List.toFinset l ↔ a ∈ l :=
  by sorry

This theorem states that, for any type `α` which has decidable equality, any list `l` of type `α`, and any element `a` of type `α`, the element `a` is a member of the finset obtained by removing duplicates from the list `l` if and only if `a` is a member of the list `l` itself. In other words, converting a list to a finset does not affect the membership of an element in the list.

For any type `α` with decidable equality, any list `l` of `α`, and any element `a` of `α`, `a` is in the finset obtained by removing duplicates from `l` if and only if `a` is in `l`.


theorem le_sup_of_le_left : ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, c ≤ a → c ≤ a ⊔ b := by sorry

This theorem states that for any type `α` that forms a semilattice with a sup operation (denoted by `⊔`), given three elements `a`, `b`, and `c` of type `α`, if `c` is less than or equal to `a`, then `c` is less than or equal to the sup of `a` and `b`. In mathematical terms, this is saying that if $c \leq a$ in the semilattice, then $c \leq a \vee b$, where $\vee$ denotes the sup operation.

For any semilattice `α` with sup operation `⊔`, if `c ≤ a` then `c ≤ a ⊔ b`.


OrderIso.strictMono

theorem OrderIso.strictMono :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β), StrictMono ⇑e := by sorry

The theorem `OrderIso.strictMono` states that for any two types `α` and `β`, each equipped with a preorder relation, if there is an order isomorphism `e` between `α` and `β`, then the function represented by `e` is strictly monotone. In other words, for any `a` and `b` of type `α`, if `a < b`, then `e(a) < e(b)`. This asserts a particular property of order isomorphisms: they preserve the strict order of elements in the original preorder.

If `e` is an order isomorphism between preordered types `α` and `β`, then `e(a) < e(b)` whenever `a < b` in `α`.


/-- Embedding `i : Fin n` into `Fin (n + 1)` with a hole around `p : Fin (n + 1)`
embeds `i` by `succ` when the resulting `p < i.succ`.  -/
theorem Fin.succAbove_of_le_castSucc :
    ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), p ≤ Fin.castSucc i → Fin.succAbove p i = Fin.succ i := by sorry

The theorem `Fin.succAbove_of_le_castSucc` states that for any natural number `n`, and any elements `p` of type `Fin (n + 1)` and `i` of type `Fin n`, if `p` is less than or equal to the embedding of `i` into `Fin (n + 1)` (denoted by `Fin.castSucc i`), then the embedding of `i` into `Fin (n + 1)` with a hole around `p` (denoted by `Fin.succAbove p i`) is equal to the successor of `i` (denoted by `Fin.succ i`). In simpler terms, it says that when we try to embed `i` into a larger set with a hole at `p`, if `p` is not greater than `i`, the hole doesn't affect the position of `i` in the larger set.

For any natural numbers `n`, `i`, and `p` with `i < p <= Fin.castSucc i` in `Fin (n + 1)`, `Fin.succAbove p i` equals `Fin.succ i`.


theorem ENNReal.inv_ne_top : ∀ {a : ENNReal}, a⁻¹ ≠ ⊤ ↔ a ≠ 0 := by sorry

This theorem states that for any extended nonnegative real number `a`, the reciprocal of `a` is not infinity if and only if `a` is not zero. In other words, only zero has infinity as its reciprocal in the set of extended nonnegative real numbers.

The reciprocal of a non-zero extended real number is finite.


theorem Cardinal.mk_sum :
    ∀ (α : Type u) (β : Type v),
      Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) :=
  by sorry

This theorem states that for any two types `α` and `β`, the cardinality of the sum type (`α ⊕ β`), which essentially represents the disjoint union of `α` and `β`, is equal to the sum of the cardinalities of `α` and `β`, each lifted to the maximum of their respective universes. In other words, if we consider the total number of distinct elements in `α` and `β` (represented by their cardinalities), then creating a new type that can be either an element of `α` or an element of `β` will have a cardinality equal to the sum of the cardinalities of `α` and `β`. This result parallels the familiar principle from set theory, where the cardinality of the union of two disjoint sets is the sum of their cardinalities.

The theorem asserts that the cardinality of the sum type `α ⊕ β` equals the sum of the lifted cardinalities of `α` and `β` in Lean 4.


theorem div_le_one_of_le : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, a ≤ b → 0 ≤ b → a / b ≤ 1 := by
  sorry

This theorem, `div_le_one_of_le`, states that for any type `α` that forms a linear ordered semifield, given any two elements `a` and `b` of this type, if `a` is less than or equal to `b` and `b` is greater than or equal to zero, then the quotient of `a` divided by `b` is less than or equal to one. In mathematical notation, this would be expressed as: if `a ≤ b` and `0 ≤ b`, then `a / b ≤ 1`.

If `α` is a linear ordered semifield and `a` is less than or equal to `b` in `α` with `b` being greater than or equal to zero, then `a / b ≤ 1`.


theorem Real.dist_eq : ∀ (x y : ℝ), dist x y = |x - y| := by sorry

This theorem states that for any two real numbers `x` and `y`, the distance between `x` and `y` is equal to the absolute value of their difference. In mathematical notation, for all x, y in ℝ, dist(x, y) = |x - y|.

For all real numbers x and y, the distance between x and y is equal to the absolute value of their difference: |x - y| = dist(x, y).


theorem Mathlib.Data.Finset.Basic._auxLemma.44 :
    ∀ {α : Type u_1} {s : Finset α} {a b : α} {h : a ∉ s}, (b ∈ Finset.cons a s h) = (b = a ∨ b ∈ s) := by sorry

This theorem states that, for any given type `α`, any `Finset` `s` of `α`, and any two elements `a` and `b` of `α` such that `a` is not in `s`, then `b` belongs to the `Finset` obtained by adding `a` to `s` (denoted as `Finset.cons a s h`) if and only if `b` is either equal to `a` or `b` belongs to `s`. In other words, after adding an element `a` to `s`, a new element `b` is either in the original set `s` or it is the newly added element `a`.

For any type `α`, any `Finset` `s` of `α`, and any `a` not in `s`, `b` is in `Finset.cons a s h` if and only if `b` is in `s` or `b` equals `a`.


/-- **Alias** of `dvd_mul_of_dvd_right`. -/
theorem Dvd.dvd.mul_left : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b : α}, a ∣ b → ∀ (c : α), a ∣ c * b := by sorry

This theorem, `Dvd.dvd.mul_left`, states that for any type `α` that is a commutative semigroup, if an element `a` divides another element `b`, then `a` also divides the product of `b` and any third element `c`. In other words, if `a` is a divisor of `b`, it remains a divisor even after `b` is multiplied by any other element.

If `a` divides `b` in a commutative semigroup, then `a` divides the product `b * c` for any `c`.


theorem UniqueFactorizationMonoid.normalizedFactors_prod :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a : α},
      a ≠ 0 → Associated (Multiset.prod (UniqueFactorizationMonoid.normalizedFactors a)) a :=
  by sorry

This theorem states that for any non-zero element 'a' in a ring that is additionally a unique factorization monoid and normalization monoid, the product of its normalized factors is associated with 'a' itself.

Here, 'associated' means that you can get from one element to the other by multiplying by a unit from the ring. A 'unit' in this context is an element that has a multiplicative inverse.

This is essentially a version of the fundamental theorem of arithmetic, stating that every non-zero integer can be uniquely expressed (up to the order of the factors) as a product of prime numbers, for the general setting of a unique factorization monoid.

In a unique factorization monoid and normalization monoid ring, the normalized product of any non-zero element equals the element itself, up to associating with units.


theorem Real.tan_periodic : Function.Periodic Real.tan Real.pi := by sorry

The theorem `Real.tan_periodic` states that the real tangent function (`Real.tan`) is periodic, with a period of π (`Real.pi`). In mathematical terms, this means that for all real numbers x, the value of `Real.tan (x + π)` is equal to the value of `Real.tan x`. This property is a well-known characteristic of the tangent function in trigonometry.

The tangent function is periodic with a period of pi, that is, tan(x + pi) = tan(x) for all real numbers x.


Asymptotics.IsBigOWith.trans

theorem Asymptotics.IsBigOWith.trans :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} {G : Type u_5} [inst : Norm E] [inst_1 : Norm F] [inst_2 : Norm G]
      {c c' : ℝ} {f : α → E} {g : α → F} {k : α → G} {l : Filter α},
      Asymptotics.IsBigOWith c l f g →
        Asymptotics.IsBigOWith c' l g k → 0 ≤ c → Asymptotics.IsBigOWith (c * c') l f k :=
  by sorry

The theorem `Asymptotics.IsBigOWith.trans` states that, for any normed types `E`, `F`, `G` and any functions `f : α → E`, `g : α → F`, and `k : α → G`, if `f` is big-O of `g` with constant `c` at a filter `l` and `g` is big-O of `k` with constant `c'` at the same filter, then `f` is big-O of `k` with constant `c*c'` at `l`, provided that `c` is non-negative. In other words, the big-O notation's transitivity property is upheld: if `f` is eventually bounded by `c * ‖g‖` and `g` is eventually bounded by `c' * ‖k‖`, then `f` is eventually bounded by `(c * c') * ‖k‖`.

Given normed types E, F, G and functions f, g, and k with non-negative constant c and c', if f is big-O of g with constant c and g is big-O of k with constant c' at filter l, then f is big-O of k with constant c * c' at filter l.


Function.LeftInverse.surjective

theorem Function.LeftInverse.surjective :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.LeftInverse f g → Function.Surjective f := by
  sorry

The theorem `Function.LeftInverse.surjective` states that for all types `α` and `β`, and for all functions `f` from `α` to `β` and `g` from `β` to `α`, if `f` is a left inverse to `g` (i.e., for all `x` in `α`, `f(g(x)) = x`), then `f` is surjective. In other words, for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`.

If `f : α → β` has a left inverse `g : β → α` (i.e., `g ∘ f = idα`), then `f` is surjective.


theorem Filter.prod_map_map_eq :
    ∀ {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x} {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁}
      {m₂ : α₂ → β₂}, Filter.map m₁ f₁ ×ˢ Filter.map m₂ f₂ = Filter.map (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂) :=
  by sorry

The theorem `Filter.prod_map_map_eq` states that for any types `α₁`, `α₂`, `β₁`, `β₂`, any filters `f₁` on `α₁` and `f₂` on `α₂`, and any functions `m₁` from `α₁` to `β₁` and `m₂` from `α₂` to `β₂`, the product filter of the mappings `m₁` and `m₂` applied to filters `f₁` and `f₂` respectively, is equal to the filter mapped by a function that takes a pair and maps its elements using `m₁` and `m₂`, applied to the product filter of `f₁` and `f₂`. In other words, the process of filtering and then mapping commutes with the process of mapping and then filtering, when dealing with product filters.

Given filters $f\_1$ on $\alpha\_1$, $f\_2$ on $\alpha\_2$, and functions $m\_1:\alpha\_1\to\beta\_1$, $m\_2:\alpha\_2\to\beta\_2$, the filters $m\_1\circ(f\_1\times f\_2)$ and $(m\_1\times m\_2)(\{ (x\_1,x\_2)\in\alpha\_1\times\alpha\_2 \mid x\_1\in f\_1 \} \times \{ y\_2\in\alpha\_2 \mid y\_2\in f\_2 \} )$ are equal.


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

The theorem `Polynomial.coeff_X_zero` states that, for any semiring `R`, the coefficient of the term with degree 0 in the polynomial `X` is 0. In more detailed terms, given any type `R` that forms a semiring, the operation `Polynomial.coeff Polynomial.X 0` will always return 0. This essentially says that the constant term of the polynomial `X`, which represents a polynomial variable or indeterminate, is 0.

For any semiring `R`, the constant term (coefficient of degree 0) of the polynomial `X` over `R` is zero.


theorem ENNReal.tsum_mul_left :
    ∀ {α : Type u_1} {a : ENNReal} {f : α → ENNReal}, ∑' (i : α), a * f i = a * ∑' (i : α), f i := by sorry

This theorem states that for any type `α`, any extended nonnegative real number `a`, and any function `f` mapping `α` to extended nonnegative real numbers, the sum of the products of `a` and `f i` for all `i` in `α` is equal to the product of `a` and the sum of `f i` for all `i` in `α`. In simple mathematical terms, it expresses the property of distributivity of multiplication over infinite summation in the domain of extended nonnegative real numbers. This is similar to saying $\sum_{i \in \alpha} (a * f(i)) = a * \sum_{i \in \alpha} f(i)$.

For any type `α`, any extended nonnegative real number `a`, and any function `f` from `α` to extended nonnegative real numbers, the sum of the products `a * f i` over all `i` in `α` equals the product of `a` and the sum of `f i` over all `i` in `α`. In symbols, $\sum\_{i \in \alpha} a \cdot f(i) = a \cdot \sum\_{i \in \alpha} f(i)$.


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

This theorem states that for every pair of non-negative real numbers `r₁` and `r₂`, the equality of their coercions (treating them as normal real numbers) is equivalent to their equality as non-negative real numbers. In other words, two non-negative real numbers are considered the same if and only if they are equal when treated as just real numbers.

For all non-negative real numbers `r₁` and `r₂`, `r₁ = r₂` if and only if their real coercions are equal: `ℝ.coe r₁ = ℝ.coe r₂`.


Homeomorph.surjective

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

The theorem `Homeomorph.surjective` states that for any two types `X` and `Y`, where `X` and `Y` are topological spaces (denoted by the instances `TopologicalSpace X` and `TopologicalSpace Y`), if `h` is a homeomorphism from `X` to `Y` (denoted by `X ≃ₜ Y`), then the function `h` is surjective. In other words, for every element `y` in `Y`, there exists an element `x` in `X` such that `h(x)` equals `y`. This implies that every point in the topological space `Y` is the image of some point in the topological space `X` under the homeomorphism `h`.

If `X` and `Y` are topological spaces and `h : X ≃ₜ Y` is a homeomorphism, then `h` is a surjective function.


/-- **Alias** of `Int.natCast_dvd`. -/
theorem Int.coe_nat_dvd_left : ∀ {n : ℕ} {z : ℤ}, ↑n ∣ z ↔ n ∣ Int.natAbs z := by sorry

The theorem `Int.coe_nat_dvd_left` states that for any natural number `n` and any integer `z`, `n` divides `z` (in the sense of integers) if and only if `n` divides the absolute value of `z` (in the sense of natural numbers). Here, "divides" means that there exists another integer such that when `n` (or `z`) is multiplied by this integer, the result is `z` (or the absolute value of `z`), respectively. The absolute value of an integer is calculated as described in the `Int.natAbs` function: if the integer is non-negative, it is unchanged; if the integer is negative, its sign is changed to positive.

For any integer `z` and natural number `n`, `n` divides `z` if and only if `n` divides the absolute value of `z`.


/-- `zero_le_one` with the type argument explicit.  -/
theorem zero_le_one' :
    ∀ (α : Type u_2) [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [inst_3 : ZeroLEOneClass α], 0 ≤ 1 := by sorry

The theorem `zero_le_one'` states that for any type `α` that has zero, one, and a less than or equal to operation defined, and additionally satisfies the condition of the `ZeroLEOneClass` (which requires that zero is less than or equal to one), the statement that zero is less than or equal to one is always true.

For any type `α` with zero, one, and a `<=` operation satisfying `ZeroLEOneClass`, we have `0 <= 1`.


theorem Mathlib.Data.Rat.Cast.Order._auxLemma.3 :
    ∀ {K : Type u_5} [inst : LinearOrderedField K] {m n : ℚ}, (↑m < ↑n) = (m < n) := by sorry

This theorem states that for any type `K` that is a linearly ordered field, and any two rational numbers `m` and `n`, the inequality of their casted versions (i.e., the converted versions of `m` and `n` to type `K`) is equivalent to the inequality of `m` and `n` themselves. In simpler terms, this means that if `m` is less than `n` in the rational numbers, then the casted version of `m` is also less than the casted version of `n` in type `K`, and vice versa.

For any linearly ordered field `K` and rational numbers `m` and `n`, `m < n` if and only if the cast `K m` is strictly less than `K n`.


theorem Subgroup.subtype_range :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), MonoidHom.range (Subgroup.subtype H) = H := by sorry

This theorem states that for any given group `G` and a subgroup `H` of `G`, the range of the natural group homomorphism from the subgroup `H` to the group `G` is the subgroup `H` itself. In other words, when we apply the `Subgroup.subtype` function to `H` and then calculate the `MonoidHom.range`, we get back the original subgroup `H`.

The natural homomorphism from a subgroup to a group maps the subgroup to itself.


theorem Finset.countable_toSet : ∀ {α : Type u} (s : Finset α), Set.Countable ↑s := by sorry

This theorem states that for any type `α` and any finite set `s` of type `α`, the set `s` is countable. In other words, there exists an injective (one-to-one) function from set `s` to the natural numbers. The countability of a set implies that its elements can be listed in a sequence, often an infinite sequence. Here, the theorem states that any finite set can be enumerated in such a way.

Every finite set has an injective function to the natural numbers.


theorem Int.ofNat_sub : ∀ {m n : ℕ}, m ≤ n → ↑(n - m) = ↑n - ↑m := by sorry

This theorem states that for any two natural numbers 'm' and 'n', where 'm' is less than or equal to 'n', the integer produced by converting the difference 'n - m' into an integer is equal to the difference of the integers converted from 'n' and 'm'. In other words, the process of subtraction for natural numbers and their integer counterparts is consistent.

For all natural numbers m and n with m <= n, (n - m) = int.of_nat (n.to_int) - int.of_nat (m.to_int).


/-- On non-dependent functions, `Function.update` can be expressed as an `ite`  -/
theorem Function.update_apply :
    ∀ {α : Sort u} [inst : DecidableEq α] {β : Sort u_1} (f : α → β) (a' : α) (b : β) (a : α),
      Function.update f a' b a = if a = a' then b else f a :=
  by sorry

This theorem states that for non-dependent functions, the `Function.update` operation can be expressed as an "if-then-else" statement. More specifically, given any types `α` and `β`, a function `f` from `α` to `β`, elements `a'` of `α` and `b` of `β`, and a decidable equality on `α`, the result of updating the function `f` at the point `a'` with the value `b` and then applying the updated function at `a` is the same as: if `a` equals `a'`, then `b` is returned, else the original function `f` is applied at `a`.

For decidable equalities on type `α`, the update operation `Function.update f a' {b}` equals the if-then-elses `if a = a' then b else f a`.


theorem Trivialization.coe_fst :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {x : Z},
      x ∈ e.source → (↑e x).1 = proj x :=
  by sorry

The theorem `Trivialization.coe_fst` states that for any types `B`, `F`, and `Z` where `B` and `F` have a topological space structure and `Z` is a source with a projection `proj`, if `x` is an element in the source of a trivialization `e` of `proj`, then the first component of `e` at `x` is equal to the projection of `x`. In other words, this theorem is saying that within the source, a trivialization preserves the projective structure.

Given a trivialization `e` of a projection `proj` between topological spaces `B` and `F` over a source `Z`, the first component of `e` at a point `x` in the source equals the projection of `x`, i.e., `e ! x = proj x`.


theorem Complex.abs_I : Complex.abs Complex.I = 1 := by sorry

This theorem states that the absolute value (the distance from the origin in the complex plane) of the imaginary unit `I` in the complex numbers is equal to 1. In mathematical terms, given the complex number `I` which is defined by real part 0 and imaginary part 1 (i.e., `I = 0 + 1i`), its absolute value is 1, as represented by `|I| = 1`.

The absolute value of the complex number i, where i is the imaginary unit (0 + 1i), equals 1.


theorem IsIntegral.of_finite :
    ∀ (R : Type u_1) {B : Type u_3} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B]
      [inst_3 : Module.Finite R B] (x : B), IsIntegral R x :=
  by sorry

The theorem `IsIntegral.of_finite` states that for any commutative ring `R` and any ring `B` that is a `R`-algebra, if `B` is a finite `R`-module, then every element `x` of `B` is integral over `R`. In other words, for any element `x` in `B`, there exists a monic polynomial `p` with coefficients in `R` such that `x` is a root of `p`. Equivalently, the element `x` is integral with respect to the induced `algebraMap` from `R` to `B`.

If `R` is a commutative ring and `B` is an `R`-algebra such that `B` is a finite `R`-module, then every element in `B` is integral over `R`.


ContDiffAt.contDiffWithinAt

theorem ContDiffAt.contDiffWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞}, ContDiffAt 𝕜 n f x → ContDiffWithinAt 𝕜 n f s x :=
  by sorry

This theorem states that if a function `f`, which maps elements from a normed additive commutative group `E` to a normed additive commutative group `F` over a nontrivially normed field `𝕜`, is continuously differentiable at a point `x` in `E` at a certain degree `n` (which can be a natural number or infinity), then the function `f` is also continuously differentiable within any set `s` of `E` at the same point `x` and at the same degree `n`.

If a continuously differentiable function `f` of degree `n` from a normed additive commutative group `E` to another normed additive commutative group `F` over a nontrivially normed field is differentiable at a point `x` in `E`, then `f` is differentiable at `x` within any set `s` of `E`.


/-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.

The ordering here is chosen so that `And.left` refer to moves by Left, and `And.right` refer to
moves by Right.  -/
theorem SetTheory.PGame.le_iff_forall_lf :
    ∀ {x y : SetTheory.PGame},
      x ≤ y ↔
        (∀ (i : SetTheory.PGame.LeftMoves x), SetTheory.PGame.LF (SetTheory.PGame.moveLeft x i) y) ∧
          ∀ (j : SetTheory.PGame.RightMoves y), SetTheory.PGame.LF x (SetTheory.PGame.moveRight y j) :=
  by sorry

This theorem is defining an ordering of pre-games (`x ≤ y`) in the mathematical field of set theory. The ordering is determined in terms of the less or fuzzy relation (`SetTheory.PGame.LF`), which indicates if the right game (`y`) is not less than or equal to the left game (`x`).

The theorem states that a pre-game `x` is less than or equal to another pre-game `y` if and only if two conditions hold:
1. For all allowed moves for the left player in the game `x`, if the left player makes that move, the resulting game is less or fuzzy than the game `y`.
2. For all allowed moves for the right player in the game `y`, if the right player makes that move, the game `x` is less or fuzzy than the resulting game.

In other words, `x` is less than or equal to `y` if Left cannot improve `x` to beat `y` and Right can defend `y` to keep it from being worse than `x`.

A pre-game x is less than or equal to another pre-game y if and only if for all allowed moves for the left player in x, the resulting game is less or fuzzy than y, and for all allowed moves for the right player in y, the game x is less or fuzzy than the resulting game.


theorem strictMono_id : ∀ {α : Type u} [inst : Preorder α], StrictMono id := by sorry

The theorem `strictMono_id` asserts that for every type `α`, given that `α` has a preorder relation, the identity function on `α` is strictly monotone. In other words, it means that if `a` and `b` are elements of `α` such that `a < b`, then `id a < id b`, which is the same as `a < b`. Thus, the identity function preserves the order in a set with a preorder.

If `α` is a type with a preorder relation, then the identity function on `α` is a strict monotone function with respect to this preorder.


theorem Nat.mem_divisors : ∀ {n m : ℕ}, n ∈ Nat.divisors m ↔ n ∣ m ∧ m ≠ 0 := by sorry

The theorem `Nat.mem_divisors` states that for any two natural numbers `n` and `m`, `n` is a member of the set of divisors of `m` if and only if `n` is a divisor of `m` and `m` is not equal to 0. In other words, a natural number `n` is in the finset of divisors of another natural number `m` precisely when `n` divides `m` and `m` is not zero.

A natural number is a divisor of another natural number if and only if it divides that number and the second number is non-zero.


/-- **Alias** of `lt_or_eq_of_le`. -/
theorem LE.le.lt_or_eq : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → a < b ∨ a = b := by sorry

This theorem, named `LE.le.lt_or_eq`, is essentially an alias of the theorem `lt_or_eq_of_le`. It applies to any type `α` that has a partial order. For any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then it must be the case that either `a` is strictly less than `b`, or `a` is equal to `b`.

For any type with a partial order, if `a` is less than or equal to `b`, then `a` is strictly less than `b` or `a` equals `b`.


theorem ite_mul :
    ∀ {α : Type u_1} [inst : Mul α] (P : Prop) [inst_1 : Decidable P] (a b c : α),
      (if P then a else b) * c = if P then a * c else b * c :=
  by sorry

This theorem, named `ite_mul`, states that for any type `α` that has a multiplication operation defined, a proposition `P` that can be decided (either true or false), and three elements `a`, `b`, `c` of the type `α`, the product of `c` and the element chosen by the if-then-else expression based on `P` is equal to the element chosen by the if-then-else expression based on `P` from the products `a * c` and `b * c`. In other words, regardless of whether `P` is true or false, the multiplication operation can be distributed over the if-then-else expression.

For any type `α` with multiplication and any proposition `P` and elements `a, b, c` in `α`, `(a * c) * iff h : P then c else b = iff h then a * c else b * c`.


theorem Nat.add_sub_of_le : ∀ {a b : ℕ}, a ≤ b → a + (b - a) = b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than or equal to `b`, then adding the difference `b - a` to `a` will yield `b`. In other words, the sum of a number and the difference between a larger (or equal) number and the smaller number is the larger (or equal) number. This is a special case of the more general mathematical principle that adding and then subtracting the same value leaves a number unchanged.

For all natural numbers a and b, a + (b - a) = b.


theorem Set.diff_diff_cancel_left : ∀ {α : Type u} {s t : Set α}, s ⊆ t → t \ (t \ s) = s := by sorry

This theorem states that for any type `α` and for any two sets `s` and `t` of this type, if `s` is a subset of `t`, then the set difference of `t` and the set difference of `t` and `s` is equal to `s`. In other words, if you take all elements in `t` not in `s` and then remove these from `t`, you are left with `s`. This result holds for any type and is fundamental in set theory. This is often written in mathematical notation as: if $s \subseteq t$, then $(t \ (t \ s)) = s$.

For any type `α` and sets `s` and `t` of type `α`, if `s` is a subset of `t`, then `t \ (t \ s) = s`.


theorem nhds_basis_uniformity :
    ∀ {α : Type ua} {ι : Sort u_1} [inst : UniformSpace α] {p : ι → Prop} {s : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p s → ∀ {x : α}, Filter.HasBasis (nhds x) p fun i => {y | (y, x) ∈ s i} :=
  by sorry

The theorem `nhds_basis_uniformity` states that for any type `α` equipped with a `UniformSpace` structure and an index type `ι`,  given a filter basis `{p : ι → Prop, s : ι → Set (α × α)}` for the uniformity on `α`, for all `x` in `α`, there exists a filter basis for the neighborhood filter at `x`. This filter basis is indexed by the same index type `ι` and its sets are formed by all `y` in `α` such that `(y, x)` is in the set `s i` for some `i` satisfying `p i`. In simpler terms, it expresses a relationship between the uniformity filter of a uniform space and the neighborhood filters of its points.

For any uniform space `(α, μ)` and filter basis `{p : ι → Prop, s : ι → α × α}` for `μ`, each point `x` in `α` has a filter basis of neighborhoods given by `{y : α | ∃ i, p i ∧ (y, x) ∈ s i}`.


MeasurableSet.singleton

theorem MeasurableSet.singleton :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α), MeasurableSet {a} := by
  sorry

The theorem `MeasurableSet.singleton` states that for any type `α` equipped with a measurable space structure and a measurable singleton class structure, every singleton set of `α` is measurable. In other words, if we pick any element `a` from type `α`, the set containing only `a` (`{a}`) is measurable in the given measurable space of `α`.

For any measurable space and measurable singleton class structure on type `α`, the singleton set `{a}` is measurable for all `a : α`.


StrictConcaveOn.dual

theorem StrictConcaveOn.dual :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : SMul 𝕜 β] {s : Set E} {f : E → β},
      StrictConcaveOn 𝕜 s f → StrictConvexOn 𝕜 s (⇑OrderDual.toDual ∘ f) :=
  by sorry

The theorem `StrictConcaveOn.dual` states that for any ordered semiring `𝕜`, type `E` equipped with an addition commutative monoid structure, type `β` equipped with an ordered addition commutative monoid structure and both `E` and `β` having a scalar multiplication by `𝕜`, if a function `f` from `E` to `β` is strictly concave on a set `s` of `E`, then the function obtained by applying the identity map to the dual order of `f` is strictly convex on the same set `s`. This shows a duality relationship between the concepts of strict concavity and strict convexity in the context of ordered semirings and ordered addition commutative monoids.

If a function from an ordered semigroup equipped with an additive commutative monoid and scalar multiplication structure to another ordered semigroup with similar structures is strictly concave on a set, then its dual function is strictly convex on the same set.


theorem continuous_swap :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Prod.swap := by
  sorry

The theorem `continuous_swap` states that for any given types `X` and `Y`, with `X` and `Y` being topological spaces, the function `Prod.swap`, which swaps the factors of a product, is a continuous function. In other words, swapping the elements of ordered pairs doesn't disrupt the topology or connectedness of the space.

The `Prod.swap` function on the product of topological spaces `X` and `Y` is a continuous function.


theorem Set.image2_nonempty_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
      Set.Nonempty (Set.image2 f s t) ↔ Set.Nonempty s ∧ Set.Nonempty t :=
  by sorry

The theorem `Set.image2_nonempty_iff` states that for all types `α`, `β`, and `γ`, and for all functions `f` of type `α → β → γ`, and for sets `s` of type `Set α` and `t` of type `Set β`, the image of the function `f` over the sets `s` and `t` (denoted `Set.image2 f s t`) is nonempty if and only if both `s` and `t` are nonempty. In other words, you can only get elements in the image of `f` over `s` and `t` if both `s` and `t` have at least one element each.

For functions between sets, the image of the function between two non-empty sets is a non-empty set.


MulHom.ext

theorem MulHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] ⦃f g : M →ₙ* N⦄, (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any two multiplication-preserving functions `f` and `g` from a type `M` to a type `N`, both equipped with multiplication structures, if `f` and `g` are identical for all elements of `M`, then `f` and `g` are indeed the same function. In other words, two multiplication-preserving functions between two types with multiplication are the same if they agree on all inputs.

If two multiplication-preserving functions from a type with multiplication to another type with multiplication are equal on all elements, then they are equal as functions.


theorem Set.empty_inter : ∀ {α : Type u} (a : Set α), ∅ ∩ a = ∅ := by sorry

This theorem states that for any set `a` of any type `α`, the intersection of the empty set (`∅`) and `a` is always the empty set. This is in line with the general mathematical concept that the intersection of any set with the empty set is the empty set itself, as there are no elements common to the empty set and any other set.

The intersection of an empty set with any set `a` is the empty set. (∅ ∩ a = ∅)


theorem Nat.Partrec.of_eq : ∀ {f g : ℕ →. ℕ}, Nat.Partrec f → (∀ (n : ℕ), f n = g n) → Nat.Partrec g := by sorry

This theorem states that for any two functions `f` and `g` from natural numbers to partitional natural numbers, if `f` is partial recursive (denoted by `Nat.Partrec f`) and `g` equals `f` for all natural numbers `n` (expressed as `(∀ (n : ℕ), f n = g n)`), then `g` is also partial recursive (expressed as `Nat.Partrec g`). In other words, if `f` is a partial recursive function and `g` is identical to `f` for every natural number, then `g` is also a partial recursive function.

If `f` is a partial recursive function and `f(n) = g(n)` for all natural numbers `n`, then `g` is also partial recursive.


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

This theorem states that for any type `α` and any instance `a` of that type, the notion that the bottom element (`⊥`) is equal to the lifted version of `a` (denoted as `↑a`) is always false. This is essentially asserting the uniqueness of the bottom element in the context of order theory.

For any type `α` and any of its inhabitants `a`, `⊥ ≠ ↑a` in order theory.


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

This theorem, `Mathlib.Order.WithBot._auxLemma.9`, states that for any type `α` and any two elements `a` and `b` of this type—if this type has a less than or equal to (`≤`) comparison operation—then the assertion that `a` is less than or equal to `b` when both are coerced to a type with a bottom (using the ↑ operator) is equivalent to the assertion that `a` is less than or equal to `b` without any coercion.

For any type `α` with a `≤` relation and any `a, b : α`, the coercion `↑a ≤ ↑b` is equivalent to `a ≤ b`.


theorem Int.ofNat_eq_coe : ∀ {n : ℕ}, Int.ofNat n = ↑n := by sorry

This theorem states that for every natural number `n`, the function `Int.ofNat n` (which converts a natural number to an integer) is equal to the coercion of `n` to an integer, denoted by `↑n`. In other words, it expresses that these two ways of turning a natural number into an integer are identical.

For every natural number `n`, `Int.ofNat n` equals the coercion `↑n`.


theorem Filter.tendsto_principal :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter α} {s : Set β},
      Filter.Tendsto f l (Filter.principal s) ↔ ∀ᶠ (a : α) in l, f a ∈ s :=
  by sorry

This theorem, `Filter.tendsto_principal`, states that for any given types `α` and `β`, a function `f` from `α` to `β`, a filter `l` on `α`, and a set `s` of `β`, the function `f` tends to the principal filter of `s` (meaning that the image of `f` gets arbitrarily close to `s` as defined by the filter `l`) if and only if for almost all `a` in `l`, the image `f(a)` is an element of `s`. In other words, it relates the concept of a function tending towards a filter to the idea of almost all elements of a filter being mapped into a certain set by a function.

A function from a type to another tends to the principal filter of a set if and only if the image of almost all elements in the filter is contained in the set.


theorem CategoryTheory.IsIso.Iso.inv_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ≅ Y), CategoryTheory.inv f.inv = f.hom :=
  by sorry

This theorem states that, given a category with objects of type `C`, and for any two objects `X` and `Y` in `C`, if `f` is an isomorphism from `X` to `Y`, then the inverse of the inverse of `f` is the original morphism `f`. In other words, this theorem is asserting the property that the double inversion of an isomorphism yields the original isomorphism in the context of category theory.

Given an isomorphism `f` between objects `X` and `Y` in a category, the inverse of `f`'s inverse is equal to `f`.


theorem Mathlib.Logic.Basic._auxLemma.33 :
    ∀ {α : Sort u_3} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) := by sorry

This theorem states that for any two types `α` and `β` and a function `f` from `α` to `β` and a property `p` of `β`, there exists an element `b` of `β` which is the image of some `α` under `f` and that satisfies `p`, if and only if there exists an `α` such that `p` holds for its image under `f`. In other words, it connects the existence of an element with a certain property after a function application with the existence of a preimage with this property.

For any function `f` between types `α` and `β` and property `p` of `β`, there exists an `α` mapping to `β` under `f` with property `p` if and only if there exists an element `b` in the image of `f` with property `p`.


IsCompact.closure

/-- The closure of a compact set in an R₁ space is a compact set.  -/
theorem IsCompact.closure :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] {K : Set X},
      IsCompact K → IsCompact (closure K) :=
  by sorry

The theorem `IsCompact.closure` states that, given any type `X` equipped with a topology and an R1 space structure, and any set `K` of type `X`, if `K` is a compact set then the closure of `K` is also a compact set. In other words, if every nontrivial filter that contains `K` has a cluster point in `K`, then the same property holds for the smallest closed set containing `K`. This theorem is typically applicable in the context of topological and metric spaces.

If `K` is a compact subset of a topological space `X` with an R1 structure, then the closure of `K` is also a compact subset of `X`.


theorem Set.infinite_coe_iff : ∀ {α : Type u} {s : Set α}, Infinite ↑s ↔ Set.Infinite s := by sorry

The theorem `Set.infinite_coe_iff` states that for any type `α` and any set `s` of type `α`, the set `s` is infinite if and only if its co-domain is infinite. In other words, a set `s` in Lean is considered infinite if its mapping to another type (via the ↑ coe function) is also infinite, and vice versa. This is a characterization of the infiniteness of a set in terms of its co-domain.

A set is infinite if and only if its image under the coercion function is an infinite type.


theorem Submodule.smul_mem_smul :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Ideal R}
      {N : Submodule R M} {r : R} {n : M}, r ∈ I → n ∈ N → r • n ∈ I • N :=
  by sorry

The theorem `Submodule.smul_mem_smul` states that for any commutative semiring `R`, any additive commutative monoid `M`, and any module `M` over `R`, if `I` is an ideal in `R` and `N` is a submodule of `M`, then for any element `r` of `I` and any element `n` of `N`, the scalar multiplication of `r` and `n`, denoted by `r • n`, is an element of the submodule generated by the set `{r • n | r ∈ I, n ∈ N}`, denoted by `I • N`. In this context, "scalar multiplication" means the multiplication of a scalar (an element of the ring) and an element of the module, and "submodule generated by a set" refers to the smallest submodule that contains that set.

For any commutative semiring R, additive commutative monoid M, and module M over R, if I is an ideal in R and N is a submodule of M, then for all r in I and n in N, r • n belongs to the submodule generated by I • N.


/-- So-named because the coercion is `Nat.cast` into `ZMod`. For `Nat.cast` into an arbitrary ring,
see `ZMod.nat_cast_val`.  -/
theorem ZMod.nat_cast_zmod_val : ∀ {n : ℕ} [inst : NeZero n] (a : ZMod n), ↑(ZMod.val a) = a := by sorry

This theorem, referred to as `ZMod.nat_cast_zmod_val`, states that for any natural number `n` that is not zero and any integer modulo `n` (denoted as `a : ZMod n`), when we cast the value of `a` (obtained from the `ZMod.val` function) back into the `ZMod n` type, we get `a` itself. In other words, if we take an element from the integers modulo `n`, calculate its representative value in natural numbers, and then convert this value back to integers modulo `n`, we return to our original element. This is an important property that ensures consistency in the operations of the `ZMod` type.

For any natural number `n` and integer `a` congruent to `a % n` modulo `n`, we have `ZMod.val (ZMod.coerce a) = a`.


theorem Polynomial.mul_coeff_zero :
    ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R),
      Polynomial.coeff (p * q) 0 = Polynomial.coeff p 0 * Polynomial.coeff q 0 :=
  by sorry

The theorem `Polynomial.mul_coeff_zero` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, the coefficient of `X^0` in the product `p * q` is equal to the product of the `X^0` coefficients of `p` and `q` respectively. In other words, the constant term of the product of two polynomials is equal to the product of their constant terms.

For any semirings R and polynomials p and q over R, the constant term of their product p * q is equal to the product of their constant terms.


theorem Int.ofNat_succ : ∀ (n : ℕ), ↑(Nat.succ n) = ↑n + 1 := by sorry

This theorem, `Int.ofNat_succ`, states that for all natural numbers `n`, the integer representation of the successor of `n` is equal to the integer representation of `n` plus 1. In other words, when you increment a natural number and then convert it to an integer, it's the same as if you had converted the number to an integer first and then added one. This theorem bridges the behavior of addition between natural numbers and integers in Lean 4.

For all natural numbers `n`, `Int.ofNat (nat.succ n) = Int.ofNat n + 1`.


theorem CategoryTheory.Limits.cokernel.π_desc_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {W : C} (k : Y ⟶ W)
      (h : CategoryTheory.CategoryStruct.comp f k = 0) {Z : C} (h_1 : W ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π f)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.desc f k h) h_1) =
        CategoryTheory.CategoryStruct.comp k h_1 :=
  by sorry

The theorem `CategoryTheory.Limits.cokernel.π_desc_assoc` states that in a category `C` with zero morphisms, for any morphism `f` from object `X` to object `Y` that has a cokernel, and for any morphism `k` from `Y` to an object `W` such that the composition `f` followed by `k` is a zero morphism, then for any object `Z` and any morphism `h_1` from `W` to `Z`, the composition of the cokernel projection of `f` followed by the composition of a morphism (which is described by `k` and makes the diagram commute) and `h_1`, is equal to the composition of `k` followed by `h_1`. In other words, it guarantees the associativity of morphism composition in the context of cokernels.

In a category with zero morphisms, for any morphism `f` with cokernel and any morphism `k` such that `f ∘ k` is a zero morphism, the composition of the cokernel projection of `f` with `h ∘ k` equals `h ∘ k`'s composition with the cokernel projection of `h`, for any morphism `h`.


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

This theorem states that for any types `A` and `B`, if `A` behaves like a set of `B` (as specified by the `SetLike A B` type class), and for any element `p` of type `A` and `x` of the subtype of `A` defined by `p`, the statement "`x` belongs to `p`" is always true. In other words, if `x` is an element of a set-like `A` object `p`, then `x` is indeed an element of `p`.

For any set-like type `A` and element `p` of type `A`, any subelement `x` of `p` belongs to `p`.


theorem Mathlib.Data.List.Cycle._auxLemma.10 : ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) := by sorry

This theorem, `Mathlib.Data.List.Cycle._auxLemma.10`, asserts that for any type `α`, any element `a` of this type, and any list `l` of elements of this type, checking whether `a` is in the list `l` coalesced into a set (i.e., `↑l`) is equivalent to checking whether `a` is in the list `l`. In other words, set membership and list membership are equivalent for a given element and a list in Lean.

For any type `α`, element `a` of `α`, and list `l` of elements of `α`, the set `{x : α | x ∈ l}` containing elements of `α` that are in `l` is equal to `{a | a ∈ l}`.


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

This theorem states that for any positive real number `y`, the result of raising 0 to the power `y` is 0. In mathematical terms, if `y` is a real number such that `y` > 0, then 0^`y` = 0.

For any positive real number `y`, 0 raised to the power `y` equals 0.


theorem Nat.add_mod : ∀ (a b n : ℕ), (a + b) % n = (a % n + b % n) % n := by sorry

This theorem in Lean 4 states that for any three natural numbers a, b, and n, the modulus of the sum of a and b with respect to n is equal to the modulus of the sum of the modulus of a with respect to n and the modulus of b with respect to n, again taken modulus n. In terms of mathematical notation, it asserts that for all a, b, and n in the set of natural numbers, (a + b) mod n = ((a mod n) + (b mod n)) mod n. This theorem is essentially a formal statement of one of the properties of modular arithmetic.

For all natural numbers a, b, and n, (a + b) % n = (a % n + b % n) % n, where % denotes modulo operation.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.22 :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {n : ℕ} [inst_5 : Nat.AtLeastTwo n], (1 < OfNat.ofNat n) = True :=
  by sorry

The theorem `Mathlib.Data.Nat.Cast.Order._auxLemma.22` states that for any type `α`, given that `α` is an additive monoid with a unity element, has a partial order, obeys the covariant law for addition and comparison, includes a `ZeroLEOneClass` instance, and is characterized by zero, and for any natural number `n` that is at least two, the statement that "one is less than the natural number `n` cast to `α`" is always true. This theorem is particularly useful in situations where natural numbers are cast to other types, and the properties of these types are critical in reasoning about their behavior.

For any additive monoid with a unity element, partial order, covariant law for addition and comparison, `ZeroLEOneClass` instance, and characterization of zero, one is less than any natural number cast to this type.


theorem zero_lt_iff : ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, 0 < a ↔ a ≠ 0 := by sorry

This theorem, named `zero_lt_iff`, states that for any type `α` that is a linearly ordered commutative monoid with zero, a value `a` of type `α` is greater than zero if and only if `a` is not equal to zero. In other words, for all elements in a linearly ordered commutative monoid with zero, being greater than zero is equivalent to not being zero.

In a commutative monoid with a linear order and zero, an element is greater than zero if and only if it is not zero.


theorem Nat.add_le_add_left : ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), k + n ≤ k + m := by sorry

This theorem, "Nat.add_le_add_left", in Lean 4 states that for all natural numbers 'n' and 'm', if 'n' is less than or equal to 'm', then for any natural number 'k', the sum of 'k' and 'n' is less than or equal to the sum of 'k' and 'm'. Essentially, it provides a guarantee that adding a constant to both sides of a valid inequality between natural numbers will not alter the inequality's truth.

For all natural numbers n, m, and k, if n ≤ m then n + k ≤ m + k.


theorem Submodule.mul_mem_mul :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {M N : Submodule R A} {m n : A}, m ∈ M → n ∈ N → m * n ∈ M * N :=
  by sorry

This theorem is stating that for any commutative semiring `R` and any semiring `A` that is an `R`-algebra, given any two submodules `M` and `N` of `A`, and any two elements `m` and `n` from `A`, if `m` is an element of `M` and `n` is an element of `N`, then the product `m * n` is an element of the submodule generated by the set of all products of an element from `M` and an element from `N`.

For any commutative semiring `R`, `R`-algebra `A`, submodules `M` and `N` of `A`, and elements `m ∈ M` and `n ∈ N`, `m * n` belongs to the submodule generated by the set of products `{x * y | x ∈ M, y ∈ N}`.


theorem Function.iterate_succ : ∀ {α : Type u} (f : α → α) (n : ℕ), f^[Nat.succ n] = f^[n] ∘ f := by sorry

This theorem, `Function.iterate_succ`, states that for any given function `f` mapping from a type `α` to itself and any natural number `n`, applying the function `f` `Nat.succ n` times (which is equivalent to `n + 1` times) is the same as first applying the function `f` `n` times and then applying `f` once more. This is expressed in terms of function composition (`∘`), which means applying one function and then another. This is a general property of functions and natural numbers in Lean 4.

For any function f from type α to itself and natural number n, applying function f n+1 times is equivalent to applying function f n times and then applying function f once more. (Function composition: f ^ (n + 1) = f ^ n ∘ f)


theorem Mathlib.Data.ENNReal.Basic._auxLemma.16 : (1 = ⊤) = False := by sorry

This theorem states that the number 1 is not equal to infinity (∞), when working in the context of extended non-negative real numbers (ENNReal). In other words, it asserts the falsehood of the claim "1 equals ∞".

The theorem asserts that 1 ≠ ∞ in the context of extended non-negative real numbers.


theorem Matrix.ext_iff :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (∀ (i : m) (j : n), M i j = N i j) ↔ M = N := by
  sorry

The theorem `Matrix.ext_iff` states that for any two matrices `M` and `N` with entries in a type `α`, row indices in a type `m`, and column indices in a type `n`, the matrices `M` and `N` are equal if and only if they have the same entries at each corresponding pair of row and column indices `(i, j)`. In other words, `M` and `N` are equal if they agree on all of their entries.

For matrices M and N of size m x n over type α, M = N if and only if M i j = N i j for all i and j.


theorem Int.cast_pow : ∀ {R : Type u_1} [inst : Ring R] (n : ℤ) (m : ℕ), ↑(n ^ m) = ↑n ^ m := by sorry

This theorem, named `Int.cast_pow`, states that for any integer (`ℤ`) `n` and natural number (`ℕ`) `m`, the result of casting (`↑`) the power of `n` and `m` (expressed as `n ^ m`) to a generic Ring type `R`, is equal to the result of casting `n` to `R` and then calculating the power with `m` (expressed as `↑n ^ m`). In other words, the order of the power operation and the cast operation can be interchanged without affecting the end result.

For any integer `n`, natural number `m`, and ring `R`, the cast `↑(n ^ m)` is equal to `↑(n ^ m)` in `R`. In other words, the application of ring exponentiation and casting can be interchanged.


theorem Filter.NeBot.nonempty_of_mem :
    ∀ {α : Type u} {f : Filter α}, Filter.NeBot f → ∀ {s : Set α}, s ∈ f → Set.Nonempty s := by sorry

The theorem `Filter.NeBot.nonempty_of_mem` states that for any type `α` and any filter `f` on `α` that is not a bottom filter (denoted by `Filter.NeBot f`), if a set `s` of `α` is in the filter `f` (denoted by `s ∈ f`), then the set `s` is not empty. In other words, if a set is a member of a non-bottom filter, it cannot be an empty set.

For any filter `f` on a type `α` that is not a bottom filter (`Filter.NeBot f`), if `s ∈ f`, then `s` is a non-empty set.


theorem Metric.isBounded_iff :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α},
      Bornology.IsBounded s ↔ ∃ C, ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → dist x y ≤ C :=
  by sorry

This theorem, `Metric.isBounded_iff`, asserts that for any type `α`, which is an instance of `PseudoMetricSpace`, and any set `s` of type `α`, the set `s` is bounded in the sense of the bornology i.e., `Bornology.IsBounded s` if and only if there exists a real number `C` such that for all elements `x` and `y` in the set `s`, the distance between `x` and `y` (i.e., `dist x y`) is less than or equal to `C`. This theorem is essentially characterizing the boundedness of a set in a metric (or pseudometric) space using the concept of bornology.

A set in a pseudometric space is bounded with respect to the bornology if and only if there exists a real number C such that the distance between any two elements in the set is less than or equal to C.


theorem CategoryTheory.epi_of_epi_fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z}
      [inst_1 : CategoryTheory.Epi h], CategoryTheory.CategoryStruct.comp f g = h → CategoryTheory.Epi g :=
  by sorry

This theorem, `CategoryTheory.epi_of_epi_fac`, states that for any Category `C` of type `Type u` and objects `X`, `Y`, and `Z` in `C`, suppose `f` is a morphism from `X` to `Y`, `g` is a morphism from `Y` to `Z`, and `h` is a morphism from `X` to `Z` which is an epimorphism (i.e., surjective in the category-theoretical sense). If the composition of `f` and `g` equals `h` (written as `CategoryTheory.CategoryStruct.comp f g = h`), then `g` is also an epimorphism. Essentially, this theorem is about preserving the property of being an epimorphism under composition in a category.

If `h` is an epimorphism in a category `C` from `X` to `Z`, and `f: X → Y` and `g: Y → Z` are morphisms with `h = g ∘ f`, then `g` is an epimorphism.


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

This theorem states that for any type `R` that is an additive group with an identity element, and for any integers `m` and `n`, the cast of the sum of `m` and `n` to `R` is equal to the sum of the casts of `m` and `n` to `R`. In mathematical terms, it states that for every `m` and `n` in the set of integers ℤ, the equation `↑m + ↑n = ↑(m + n)` holds true, where `↑m` and `↑n` represent the casting of the integers `m` and `n` to the type `R`.

For any additive group `R` with identity and integers `m` and `n`, the cast of their sum to `R` equals the cast of each integer followed by their addition: `↑(m + n) = ↑m + ↑n`.


theorem Denumerable.decode_eq_ofNat :
    ∀ (α : Type u_3) [inst : Denumerable α] (n : ℕ), Encodable.decode n = some (Denumerable.ofNat α n) := by sorry

The theorem `Denumerable.decode_eq_ofNat` states that for any type `α` that has a `Denumerable` instance, and for any natural number `n`, the decoding of `n` into an optional value of type `α` is exactly equal to the `n`-th element of `α` indexed by the decoding. Essentially, this means that the function `Denumerable.ofNat` returns the `n`-th element of `α` that correctly matches the decoded value of `n` using the `Encodable.decode` function.

For any type `α` with a `Denumerable` instance and natural number `n`, `Denumerable.decode (Encodable.decode x (Encodable.encode (Some (α!n))) = α!n`, where `x : option Nat` is the decoded value of `n`.


theorem Mathlib.Order.Filter.Basic._auxLemma.177 :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = ({x | m x ∈ t} ∈ f) := by
  sorry

This theorem in Lean 4 is asserting that for every type `α` and `β`, filter `f` on `α`, function `m` from `α` to `β`, and set `t` of type `β`, the set `t` is in the forward map of the filter `f` under the function `m` if and only if the set of all elements `x` in `α` such that `m(x)` belongs to `t` is in the filter `f`. In simpler terms, it states that `t` is in the image of filter `f` under `m` if and only if all pre-images of the elements of `t` under `m` are in `f`.

For any type `α`, filter `f` on `α`, function `m` from `α` to `β`, and set `t` of type `β`, `t` is in the forward image of `f` under `m` if and only if the preimage of `t` under `m` is in `f`.


theorem PartialHomeomorph.toPartialEquiv_injective :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Function.Injective PartialHomeomorph.toPartialEquiv :=
  by sorry

This theorem states that for any two types `X` and `Y` that are both topological spaces, the function `PartialHomeomorph.toPartialEquiv` is injective. In other words, for any two partial homeomorphisms between `X` and `Y`, if they are equal when mapped to partial equivalences via `PartialHomeomorph.toPartialEquiv`, then they were originally equal as partial homeomorphisms. This emphasizes that the `PartialHomeomorph.toPartialEquiv` function preserves the distinctness of partial homeomorphisms when converting them to partial equivalences.

The function `PartialHomeomorph.toPartialEquiv` maps equal partial homeomorphisms between topological spaces `X` and `Y` to equal partial equivalences.


theorem Set.union_diff_self : ∀ {α : Type u} {s t : Set α}, s ∪ t \ s = s ∪ t := by sorry

This theorem, `Set.union_diff_self`, states that for any type `α` and for any two sets `s` and `t` of type `α`, the union of `s` and the difference of `t` and `s` is equal to the union of `s` and `t`. In other words, if you take a set `t`, remove all elements that `s` contains from it, and then take the union of this new set with `s`, you end up with the same set as if you had simply taken the union of `s` and `t` from the beginning. This theorem captures a fundamental property of set operations commonly used in set algebra.

For any type `α` and sets `s` and `t` of type `α`, `Set.union s (Set.diff t s) = Set.union s t`.


theorem mem_closure_iff_nhdsWithin_neBot :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], x ∈ closure s ↔ Filter.NeBot (nhdsWithin x s) := by
  sorry

The theorem `mem_closure_iff_nhdsWithin_neBot` states that for any type `X` with a topology and any set `s` of elements of type `X`, an element `x` of type `X` is in the closure of `s` if and only if the "neighborhood within" filter of `x` and `s`, denoted as `nhdsWithin x s`, is not a bottom filter. In other words, `x` belongs to the smallest closed set containing `s` precisely when there exists a neighborhood of `x` within `s`.

An element x belongs to the closure of a set s if and only if there exists a neighborhood of x contained in s that does not contain the bottom filter.


Finset.Nonempty.image

theorem Finset.Nonempty.image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {s : Finset α},
      s.Nonempty → ∀ (f : α → β), (Finset.image f s).Nonempty :=
  by sorry

The theorem `Finset.Nonempty.image` states that for any types `α` and `β` where `β` has decidable equality, and for any nonempty finite set `s` of type `α`, the image of `s` under any function `f` from `α` to `β` is also nonempty. In other words, if we have a function `f` that maps elements from type `α` to type `β` and a nonempty finite set of elements of type `α`, then the set of images of these elements (obtained by applying function `f`) in `β` will also be nonempty.

For any nonempty finite set `s` of type `α` and any function `f` from `α` to a type `β` with decidable equality, the image `f''s` is a nonempty set.


Continuous.dist

theorem Continuous.dist :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : TopologicalSpace β] {f g : β → α},
      Continuous f → Continuous g → Continuous fun b => dist (f b) (g b) :=
  by sorry

This theorem states that for any two given functions `f` and `g` mapping from a topological space `β` to a pseudo-metric space `α`, if both `f` and `g` are continuous, then the function that maps `b` in `β` to the distance between `f(b)` and `g(b)` in `α` is also continuous. In mathematical terms, if $f$ and $g$ are continuous functions from a topological space to a pseudo-metric space, then the function $h(b) = \mathrm{dist}(f(b), g(b))$ is also continuous.

If `f` and `g` are continuous functions from a topological space to a pseudo-metric space, then the function mapping the distance between `f(x)` and `g(x)` is also continuous.


theorem Ordinal.lt_wf : WellFounded fun x x_1 => x < x_1 := by sorry

This theorem states that the less-than relation ("<") on ordinals is well-founded. In the context of set theory, an ordinal is a set that is well-ordered by set membership. A relation is well-founded if there are no infinite descending chains. So, this theorem essentially says that it's impossible to find an infinite sequence of ordinals where each ordinal is smaller than the previous one.

The less-than relation on ordinals is a well-founded relation.


theorem Nat.mem_properDivisors : ∀ {n m : ℕ}, n ∈ Nat.properDivisors m ↔ n ∣ m ∧ n < m := by sorry

This theorem states that for any two natural numbers `n` and `m`, `n` is a member of the proper divisors of `m` if and only if `n` not only divides `m`, but `n` is also less than `m`. In other words, the proper divisors of a number `m` are exactly those numbers which divide `m` and are strictly smaller than `m`.

The proper divisors of a natural number `m` are those natural numbers `n` that divide `m` and satisfy `n < m`.


theorem Real.sInf_empty : sInf ∅ = 0 := by sorry

This theorem states that the infimum (greatest lower bound) of an empty set in the domain of real numbers is zero. In other words, when we try to find the lowest value (infimum) in a set of real numbers, and the set is empty, we consider the infimum to be zero.

The infimum of an empty set of real numbers is 0.


theorem Nat.ord_proj_dvd : ∀ (n p : ℕ), p ^ (Nat.factorization n) p ∣ n := by sorry

The theorem `Nat.ord_proj_dvd` states that for any two natural numbers `n` and `p`, the power of `p` to the value given by the function `Nat.factorization` applied to `n` and `p` divides `n`. In terms of mathematics, this means that for any pair of natural numbers (n, p), the power of p to the multiplicity of p in the prime factorization of n (i.e., the number of times p appears as a factor in the prime factorization of n) divides n.

For all natural numbers n and p, the p-th power of the multiplicity of p in the prime factorization of n divides n.


theorem MeasureTheory.Integrable.mono_measure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] {f : α → β}, MeasureTheory.Integrable f ν → μ ≤ ν → MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.Integrable.mono_measure` states that for any types `α` and `β`, a measurable space `m` on `α`, measures `μ` and `ν` on the measurable space, a normed add commutative group instance on `β`, and a function `f` from `α` to `β`, if `f` is integrable with respect to measure `ν` and measure `μ` is less than or equal to measure `ν`, then `f` is also integrable with respect to measure `μ`. In other words, the integrability of a function under a certain measure is preserved when we move to a smaller measure.

If `μ` is less than or equal to `ν` and `f` is integrable with respect to `ν` on the measurable space `(α, m)` with values in the normed add commutative group `(β, +, ||.||)`, then `f` is integrable with respect to `μ`.


theorem mul_inv_eq_one : ∀ {G : Type u_3} [inst : Group G] {a b : G}, a * b⁻¹ = 1 ↔ a = b := by sorry

This theorem states that for any group `G` and any elements `a` and `b` of `G`, the product of `a` and the inverse of `b` is equal to the identity element `1` if and only if `a` is equal to `b`. In other words, in a group, an element times the inverse of another element equals the identity only when the two elements are the same.

In a group, for all elements `a` and `b`, `a * b^(-1) = 1` if and only if `a = b`.


theorem ENNReal.mul_ne_top : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤ := by sorry

This theorem states that for any two extended non-negative real numbers `a` and `b`, if neither `a` nor `b` are infinity (notated as `⊤`), then the product of `a` and `b` also cannot be infinity. In other words, the multiplication of two finite extended non-negative real numbers results in a finite number, not infinity.

For any extended non-negative real numbers `a` and `b` not equal to infinity, their product is a finite real number.


/-- The subsemiring generated by a set includes the set.  -/
theorem Subsemiring.subset_closure :
    ∀ {R : Type u} [inst : NonAssocSemiring R] {s : Set R}, s ⊆ ↑(Subsemiring.closure s) := by sorry

This theorem states that for any type `R` equipped with a non-associative semiring structure, and any set `s` of elements of type `R`, the set `s` is included in the subsemiring generated by `s`. In other words, every element of `s` is also an element of the subsemiring generated by `s`. This is a typical property of closures, where the closure of a set (in this case, the subsemiring closure) always contains the original set.

For any non-associative semiring `R` and set `s` of elements in `R`, `s` is included in the subsemiring generated by `s`.


theorem List.range_succ : ∀ (n : ℕ), List.range (Nat.succ n) = List.range n ++ [n] := by sorry

This theorem states that for any natural number `n`, the list of natural numbers up to `n+1` (exclusive of `n+1`) as generated by the `List.range` function, is equivalent to the list of natural numbers up to `n` (exclusive of `n`) appended with `n`. In other words, if you have a list of numbers from `0` to `n`, adding the next number `n+1` to the list can be achieved by appending `n` to the list of numbers up to `n`.

The list of natural numbers up to `n+1` (exclusive) is the same as the list of natural numbers up to `n` (exclusive) followed by `n`. In Lean, this can be expressed as `List.range (0 : nat) (n + 1) = List.append (List.range (0 : nat) n) [n]`.


theorem ContDiffOn.of_le :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {m n : ℕ∞}, ContDiffOn 𝕜 n f s → m ≤ n → ContDiffOn 𝕜 m f s :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, a normed additive commutative group `E`, a normed space over `𝕜` and `E`, another normed additive commutative group `F`, and another normed space over `𝕜` and `F`, if a function `f` from `E` to `F` is `n` times continuously differentiable on a set `s` of `E`, and if `m` is less than or equal to `n`, then `f` is also `m` times continuously differentiable on `s`. Here, `𝕜` is the domain of scalars, `E` and `F` are the domains of the function `f`, `n` and `m` are the orders of differentiation, and `s` is the set on which the function `f` is being considered.

If `f` is `n` times continuously differentiable from a non-trivially normed field `𝕜` into another non-trivially normed space over different normed additive commutative groups `E` and `F`, then `f` is also `m` times continuously differentiable on a set `s` for `m` less than or equal to `n`.


theorem Set.uIoc_of_le : ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a ≤ b → Ι a b = Set.Ioc a b := by sorry

This theorem states that for any type `α` with a linear order, and any two elements `a` and `b` of that type, if `a` is less than or equal to `b`, then the half-open interval from `a` to `b`, denoted `Ι a b`, is equal to the left-open right-closed interval from `a` to `b`, denoted `Set.Ioc a b`. In other words, if `a` and `b` are elements of a type with a linear order and `a ≤ b`, then the set of all elements `x` such that `a < x` and `x ≤ b` is the same whether you consider it as a half-open interval or as a left-open right-closed interval.

For any type with a linear order, the half-open interval [a, b] equals the left-open right-closed interval (a, b] if a ≤ b.


/-- **Alias** of `dvd_mul_of_dvd_left`. -/
theorem Dvd.dvd.mul_right : ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, a ∣ b → ∀ (c : α), a ∣ b * c := by sorry

This theorem, named `Dvd.dvd.mul_right`, is an alias of `dvd_mul_of_dvd_left`. It states that for any type `α` that forms a semigroup, given elements `a`, `b`, and `c` of that semigroup such that `a` divides `b`, then `a` also divides the product of `b` and `c`. In mathematical terms, for any \(a, b, c \in \alpha\) such that \(a | b\), we have \(a | bc\).

If `a` divides `b` in a semigroup `α`, then `a` divides the product `bc` in `α`.


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

This theorem, named `MeasureTheory.lintegral_mono_ae`, states that for any measurable space `α` and any measure `μ` on this space, if `f` and `g` are two functions from `α` to the extended nonnegative real numbers `ENNReal`, and almost everywhere in `α` (with respect to the measure `μ`), `f(a)` is less than or equal to `g(a)`, then the Lebesgue integral (also known as the lower Lebesgue integral) of `f` with respect to the measure `μ` is less than or equal to the Lebesgue integral of `g` with respect to the same measure. In other words, if one function is almost everywhere less than or equal to another, then its integral is also less than or equal to the integral of the other function.

If `α` is a measurable space with measure `μ`, `f` and `g` are measurable functions from `α` to the extended nonnegative real numbers, and `μ`-almost everywhere `f(a) ≤ g(a)`, then `∫f dμ ≤ ∫g dμ`.


/-- In a σ-compact space, `univ` is σ-compact.  -/
theorem isSigmaCompact_univ :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [h : SigmaCompactSpace X], IsSigmaCompact Set.univ := by sorry

The theorem `isSigmaCompact_univ` states that in a σ-compact space, the universal set is also σ-compact. Specifically, for any type `X` equipped with a topological space structure, if `X` is a σ-compact space (which means it can be covered by countably many compact subsets), then the universal set of `X` (which contains all elements of `X`) is also σ-compact (i.e., it can also be covered by countably many compact subsets).

If a topological space `X` is σ-compact, then its universal set is also σ-compact.


MeasureTheory.NullMeasurableSet.inter

theorem MeasureTheory.NullMeasurableSet.inter :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.NullMeasurableSet s μ →
        MeasureTheory.NullMeasurableSet t μ → MeasureTheory.NullMeasurableSet (s ∩ t) μ :=
  by sorry

This theorem, `MeasureTheory.NullMeasurableSet.inter`, states that for any type `α` with a measurable space structure `m0` and a measure `μ`, and for any two sets `s` and `t` of type `α`, if both `s` and `t` are "null measurable sets" with respect to the measure `μ`, then their intersection (`s ∩ t`) is also a "null measurable set" with respect to the same measure `μ`. In other words, the intersection of two null measurable sets is itself a null measurable set.

If `s` and `t` are null measurable sets in the measurable space `(α, m0)` with respect to measure `μ`, then their intersection `s ∩ t` is also a null measurable set.


theorem Filter.eventually_inf_principal :
    ∀ {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α},
      (∀ᶠ (x : α) in f ⊓ Filter.principal s, p x) ↔ ∀ᶠ (x : α) in f, x ∈ s → p x :=
  by sorry

The theorem `Filter.eventually_inf_principal` expresses a property about events in filters of a certain set in type `α`. It states that for any type `α`, any filter `f` of type `α`, any property `p` that elements of type `α` may satisfy, and any set `s` of elements of type `α`, the property `p` holds eventually (at all but finitely many elements) for the elements of the intersection of filter `f` and the principal filter of set `s` if and only if the property `p` holds eventually in filter `f` for those elements that belong to set `s`. Here, the principal filter of a set is defined as the collection of all supersets of the set.

For any filter `f` on type `α`, set `s`, and property `p`, if `p` holds eventually in `f` for all elements of `s`, then `p` holds eventually in the intersection of `f` and the principal filter of `s`. Conversely, if `p` holds eventually in `f` for all elements of `s`, then it holds eventually in the intersection of `f` and the principal filter of `s`.


theorem Cardinal.aleph0_le_aleph : ∀ (o : Ordinal.{u_1}), Cardinal.aleph0 ≤ Cardinal.aleph o := by sorry

The theorem `Cardinal.aleph0_le_aleph` states that for any ordinal 'o', the cardinality of the set of natural numbers (also known as ℵ₀ or aleph-null) is less than or equal to the cardinality determined by the aleph function at 'o'. In other words, ℵ₀ is the smallest infinite cardinal and all other cardinals defined by the aleph function are at least as large.

The theorem `Cardinal.aleph0_le_aleph` asserts that the cardinality of the natural numbers is less than or equal to the cardinality represented by the aleph function at any given ordinal.


theorem mul_lt_mul_of_le_of_lt :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a ≤ b → c < d → a * c < b * d :=
  by sorry

The theorem `mul_lt_mul_of_le_of_lt` states that for any type `α` equipped with a multiplication operation, a preorder, and satisfying certain covariant properties, if `a` is less than or equal to `b` and `c` is less than `d` (`a ≤ b` and `c < d`), then the multiplication of `a` and `c` is less than the multiplication of `b` and `d` (`a * c < b * d`). This is a generalization of the property from real numbers where if you multiply a smaller number with another smaller number, the result is smaller than if you multiply the larger numbers.

Given types `α` with a multiplication operation and a preorder, if `a ≤ b` and `c < d`, then `a * c < b * d`.


theorem Int.int_cast_ofNat :
    ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ) [inst_1 : Nat.AtLeastTwo n], ↑(OfNat.ofNat n) = OfNat.ofNat n :=
  by sorry

The theorem `Int.int_cast_ofNat` states that for any natural number `n` and any type `R` that has both an `AddGroupWithOne` and a `Nat.AtLeastTwo` instance, the cast of the `OfNat.ofNat` function applied to `n` into `R` (represented as `↑(OfNat.ofNat n)`) is equal to the `OfNat.ofNat` function applied to `n` directly. It essentially asserts that the cast operation does not alter the value returned by the `OfNat.ofNat` function under these conditions.

For any type R with AddGroupWithOne and Nat.AtLeastTwo instances, the cast of OfNat.ofNat n to R is equal to OfNat.ofNat n. In other words, casting an integer to a ring with these properties does not change its value.


theorem Multiset.prod_replicate :
    ∀ {α : Type u_2} [inst : CommMonoid α] (n : ℕ) (a : α), Multiset.prod (Multiset.replicate n a) = a ^ n := by sorry

The theorem `Multiset.prod_replicate` states that for any type `α` which has a commutative monoid structure, any natural number `n`, and any element 'a' of type `α`, the product of the multiset obtained by replicating 'a' 'n' times (`a` being replicated `n` times forms a multiset, and we take the product of all elements in this multiset) is equal to 'a' raised to the power of 'n'. In mathematical terms, if we denote the multiset replication operation as a function, we can write this as: $\prod(\text{replicate}(n, a)) = a^n$.

The theorem asserts that for any commutative monoid type `α`, natural number `n`, and element `a` of `α`, the product of `n` replicas of `a` equals `a` raised to the power of `n`.


AddUnits.isAddUnit

theorem AddUnits.isAddUnit : ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M), IsAddUnit ↑u := by sorry

This theorem states that for any `AddUnits M` in an additive monoid `M`, the element `u` is an `AddUnit`. In other words, every element `u` of the type `AddUnits M` is such that there exists an element in the same monoid that when added to `u` gives the additive identity of the monoid. This implies that every `u` in `AddUnits M` has a two-sided additive inverse.

Every element in the type of additive units of an additive monoid has a two-sided additive inverse.