theorem lt_of_mul_lt_mul_left :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : PosMulReflectLT α],
      a * b < a * c → 0 ≤ a → b < c :=
  by sorry

This theorem states that for any type `α` equipped with multiplication, zero, and a preorder relation where multiplication by nonnegative elements on the left is strictly reverse monotone, if the product of `a` and `b` is less than the product of `a` and `c` and `a` is nonnegative, then `b` is less than `c`. In mathematical terms, given `0 ≤ a` and `a * b < a * c`, it concludes `b < c`. This is a property related to the ordering of elements in the context of a linear ordered semiring.

If `α` is a linear ordered semiring with non-negative `a`, `b`, and `c`, then `a * b < a * c` implies `b < c`.


theorem uniformity_basis_edist :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α],
      Filter.HasBasis (uniformity α) (fun ε => 0 < ε) fun ε => {p | edist p.1 p.2 < ε} :=
  by sorry

This theorem, `uniformity_basis_edist`, states that for any type `α` which has an instance of a `PseudoEMetricSpace`, the uniformity (which is a filter on `α × α` inferred from an ambient UniformSpace structure on `α`) has a basis that is indexed by positive real numbers (`ε` such that `0 < ε`). The basis elements are the sets of all pairs `(p.1, p.2)` of elements in `α` such that the extended distance between `p.1` and `p.2` is less than `ε`. In other words, the uniformity's basis is composed of the balls of radius `ε` in the pseudoemetric space.

For any type `α` with a `PseudoEMetricSpace` instance, the basis of its uniformity consists of all balls of radius `ε` in the pseudo-metric space, where `ε` ranges over positive real numbers.


theorem rel_iff_cov :
    ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) (r : N → N → Prop) [inst : CovariantClass M N μ r]
      [inst : ContravariantClass M N μ r] (m : M) {a b : N}, r (μ m a) (μ m b) ↔ r a b :=
  by sorry

This theorem, `rel_iff_cov`, states that for any types `M` and `N`, a binary operation `μ` from `M` and `N` to `N`, and a binary relation `r` on `N`, if `M` and `N` form a covariant class under `μ` and `r`, and also form a contravariant class under `μ` and `r`, then for any element `m` of `M` and any elements `a` and `b` of `N`, the relation `r` holds between `μ(m, a)` and `μ(m, b)` if and only if the same relation `r` holds between `a` and `b`. In other words, under these conditions, applying the operation `μ` with `m` to `a` and `b` preserves the relation `r`.

If types `M` and `N`, binary operation `μ`, and binary relation `r` satisfy `M` and `N` being covariant and contravariant classes under `μ` and `r`, then `r(μ(m, a), μ(m, b)) <-> r(a, b)` for all `m ∈ M` and `a, b ∈ N`.


theorem Nonneg.coe_zero : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α], ↑0 = 0 := by sorry

This theorem, `Nonneg.coe_zero`, states that for any type `α` that has a zero element and a preorder (a binary relation describing an order on `α`), the coercion of the numeric zero `0` to `α` equals the zero element of `α`. This basically means that `0` maps to the zero element of any type `α` that has a zero and a defined order.

For any type with a zero element and a preorder, the coercion of the numeric zero equals the zero element under the preorder.


theorem dvd_lcm_right :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b : α), b ∣ lcm a b := by sorry

This theorem states that for any type `α` that is a cancel commutative monoid with zero and a GCD monoid, and for any elements `a` and `b` of type `α`, `b` divided by `lcm a b` always holds true. In other words, `b` is always a divisor of the least common multiple of `a` and `b`.

For any cancel commutative monoid `α` with zero and a GCD monoid, for all `a, b ∈ α`, `b` divisors `lcm a b`.


theorem sub_add_sub_cancel' : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b c : G), a - b + (c - a) = c - b := by sorry

This theorem states that for any type `G` that forms an additive commutative group, and any three elements `a`, `b`, and `c` of type `G`, the result of subtracting `b` from `a`, then adding the result of subtracting `a` from `c`, is the same as the result of subtracting `b` from `c`. In mathematical notation, this is stating that for all a, b, and c in an additive commutative group G, we have the equality a - b + (c - a) = c - b.

For all elements a, b, and c in an additive commutative group G, the expression (a - b) + (c - a) is equal to c - b.


theorem midpoint_comm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (x y : P), midpoint R x y = midpoint R y x :=
  by sorry

The theorem `midpoint_comm` states that for all types `R`, `V`, and `P`, with `R` being a ring, `2` being invertible, `V` being an additive commutative group, `R` being a module over `V`, and `V` being an additive torsor over `P`, the midpoint of two points `x` and `y` in the space `P` is the same as the midpoint of `y` and `x`. This means that the operation of taking the midpoint is commutative. In other words, swapping the positions of `x` and `y` does not change the result of the midpoint operation.

For all types `R`, `V`, `P` (with `R` a ring, `2` invertible, `V` an additive commutative group, `R` an `R`-module over `V`, and `V` an additive torsor over `P`), the midpoint of `x` and `y` in `P` is equal to the midpoint of `y` and `x`.


theorem Cardinal.lift_mk_eq :
    ∀ {α : Type u} {β : Type v},
      Cardinal.lift.{max v w, u} (Cardinal.mk α) = Cardinal.lift.{max u w, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β) :=
  by sorry

This theorem, `Cardinal.lift_mk_eq`, states that for any types `α` and `β`, the lift to a higher universe of the cardinality of `α` is equal to the lift to a higher universe of the cardinality of `β` if and only if there exists a bijection between `α` and `β`. In other words, the cardinalities of two types are the same in some higher universe if and only if the types are isomorphic, which means there is a one-to-one correspondence between their elements.

The cardinalities of types `α` and `β` are equal in some higher universe if and only if there exists a bijection between them.


ClosureOperator.monotone

theorem ClosureOperator.monotone : ∀ {α : Type u_1} [inst : PartialOrder α] (c : ClosureOperator α), Monotone ⇑c := by
  sorry

The theorem `ClosureOperator.monotone` states that for any type `α` that has an instance of a partial order, any closure operator `c` on `α` is monotone. In other words, given any two elements `a` and `b` in `α` such that `a` is less than or equal to `b`, the application of the closure operator `c` preserves this order, i.e., `c(a)` is less than or equal to `c(b)`.

For any type equipped with a partial order and any closure operator, the closure of a lesser element is less than or equal to the closure of a greater element.


/-- If the oriented angle between three points is `π / 2`, so is the unoriented angle
(reversed).  -/
theorem EuclideanGeometry.angle_rev_eq_pi_div_two_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P},
      EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → EuclideanGeometry.angle p₃ p₂ p₁ = Real.pi / 2 :=
  by sorry

This theorem states that in a 2-dimensional Euclidean space defined over the real numbers, if the oriented angle between three points (`p₁`, `p₂`, `p₃`) is `π / 2` (or 90 degrees), then the unoriented angle when the points are reversed (i.e., `p₃`, `p₂`, `p₁`) is also `π / 2`. An oriented angle takes into account the rotation direction from one line to another, while an unoriented angle only considers the smallest angle between the two lines, regardless of rotation direction.

In a 2-dimensional Euclidean space over the real numbers, the oriented angle between three points is equal to the oriented angle when the points are reversed if and only if the angle is a right angle (90 degrees).


theorem CategoryTheory.FunctorToTypes.naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) {X Y : C}
      (σ : F ⟶ G) (f : X ⟶ Y) (x : F.obj X), σ.app Y (F.map f x) = G.map f (σ.app X x) :=
  by sorry

This theorem states the naturality condition for functors between categories and types in the context of category theory. More specifically, given any two functors `F` and `G` from a category `C` to the category of types, any natural transformation `σ` from `F` to `G`, any morphism `f` from object `X` to object `Y` in `C`, and any element `x` in the type `F.obj X`, applying `σ` at `Y` to the result of mapping `f` across `x` with `F` is equal to the result of mapping `f` across the result of applying `σ` at `X` to `x` with `G`. This captures the core principle of naturality in category theory, which asserts that the behavior of morphisms and transformations should be consistent across the entire category.

Given any functors F and G from a category C to types, any natural transformation σ from F to G, and any morphism f in C and object x in F.X, we have F.map (σ\_Y (F.map f x)) = G.map f (σ\_X x).


/-- The evaluation map `C(X, Y) × X → Y` is continuous
if `X, Y` is a locally compact pair of spaces.  -/
theorem ContinuousMap.continuous_eval :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : LocallyCompactPair X Y], Continuous fun p => p.1 p.2 :=
  by sorry

This theorem states that for any pair of types `X` and `Y`, where `X` and `Y` are both topological spaces and form a locally compact pair, the evaluation map from the Cartesian product of the set of continuous maps from `X` to `Y` and `X` to `Y` is continuous. In mathematical terms, if we consider `C(X, Y)` to be the set of continuous maps from `X` to `Y`, then the map `(f, x) ↦ f(x)` is continuous under the given conditions.

Given topological spaces X and Y forming a locally compact pair, the evaluation map from the set of continuous functions C(X, Y) to Y^X (the set of all functions from X to Y) defined by (f, x) ↦ f(x) is continuous.


theorem lie_zero :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L),
      ⁅x, 0⁆ = 0 :=
  by sorry

This theorem states that for all elements `x` of a Lie Ring `L` acting on an Additive Commutative Group `M`, where `M` is a module over the Lie ring `L` (i.e., `M` is a `LieRingModule` for `L`), the Lie bracket of `x` and the zero element of `M` is itself zero. Essentially, it expresses that zero behaves as an identity element with respect to the Lie bracket operation.

For every Lie Ring element `x` and any Additive Commutative Group element `m` in a Lie Ring Module, the Lie bracket `[x, 0_M]` equals the zero element of the Lie Ring.


/-- Decomposes the coefficient of the product `p * q` as a sum
over `antidiagonal`. A version which sums over `range (n + 1)` can be obtained
by using `Finset.Nat.sum_antidiagonal_eq_sum_range_succ`.  -/
theorem Polynomial.coeff_mul :
    ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R) (n : ℕ),
      Polynomial.coeff (p * q) n =
        Finset.sum (Finset.antidiagonal n) fun x => Polynomial.coeff p x.1 * Polynomial.coeff q x.2 :=
  by sorry

The theorem `Polynomial.coeff_mul` states that for any semiring `R`, and any two polynomials `p` and `q` over `R`, the coefficient of the term of degree `n` in the product `p * q` is equal to the sum, over all pairs `(i, j)` in the antidiagonal of `n`, of the product of the coefficient of the `i`-th term of `p` and the `j`-th term of `q`. Here, the antidiagonal of `n` is the set of all pairs `(i, j)` of natural numbers such that `i + j = n`.

For any semiring R and polynomials p and q over R, the coefficient of the term of degree n in the product p * q is the sum of the products of the coefficients of the i-th term of p and j-th term of q, over all pairs (i, j) in the antidiagonal of n.


theorem Ioo_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α] {a b x : α},
      a < x → x < b → Set.Ioo a b ∈ nhds x :=
  by sorry

This theorem, `Ioo_mem_nhds`, states that for any type `α` that is a topological space, is a linear order, and has an order-closed topology, and for any `a`, `b`, and `x` of type `α`, if `a` is less than `x` and `x` is less than `b`, then the open interval `(a, b)` (represented by `Set.Ioo a b`), is a neighborhood of `x` (i.e., it belongs to the neighborhood filter at `x` denoted by `nhds x`). In other words, within these given structures, if `x` lies strictly between `a` and `b`, then the open interval from `a` to `b` forms a neighborhood around `x`.

If `α` is a topological space, a linear order with an order-closed topology, then for all `a < x < b` in `α`, `Set.Ioo a b` is a neighborhood of `x`.


/-- A function `f` grows to `+∞` independent of an order-preserving embedding `e`.  -/
theorem Filter.tendsto_atTop_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Nonempty α] [inst : SemilatticeSup α] [inst_1 : Preorder β] {f : α → β},
      Filter.Tendsto f Filter.atTop Filter.atTop ↔ ∀ (b : β), ∃ i, ∀ (a : α), i ≤ a → b ≤ f a :=
  by sorry

The theorem `Filter.tendsto_atTop_atTop` states that for a function `f` from an ordered set `α` to an ordered set `β`, the function `f` has the property of tending to positive infinity if and only if for any element `b` from `β`, there exists an element `i` in `α` such that for all elements `a` in `α` which are greater than or equal to `i`, `f(a)` is greater than or equal to `b`. Note that `α` is a set with a least upper bound (a semilattice) and `β` is simply a preordered set. This essentially means that the function `f` grows to `+∞` irrespective of the order-preserving nature of an embedding function `e`.

A function from an ordered set to another preordered set tends to positive infinity if and only if for every element in the range, there exists an element in the domain that maps to a value greater than or equal to it. (Assuming the domain has a least upper bound.)


theorem CochainComplex.HomComplex.Cochain.ofHom_v :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} (φ : F ⟶ G) (p : ℤ), (CochainComplex.HomComplex.Cochain.ofHom φ).v p p ⋯ = φ.f p :=
  by sorry

This theorem states that for any category `C` with preadditive structure, and for any two cochain complexes `F` and `G` over `C` with integer indexing, if we have a morphism `φ` from `F` to `G`, then the value function `.v` of the `0`-cochain attached to `φ`, when applied to any integer `p` twice, is equal to the application of `φ.f` to `p`. In other words, the `0`-cochain of a morphism between two cochain complexes perfectly encapsulates the morphism's action on each integer index.

For any morphism φ between cochain complexes F and G over a preadditive category C with integer indexing, the value of φ's 0-cochain at an integer p is equal to the application of φ.f to p.


theorem exists_forall_ge_and :
    ∀ {α : Type u} [inst : LinearOrder α] {p q : α → Prop},
      (∃ i, ∀ j ≥ i, p j) → (∃ i, ∀ j ≥ i, q j) → ∃ i, ∀ j ≥ i, p j ∧ q j :=
  by sorry

This theorem states that for any type `α` that is a linear order, given two properties `p` and `q` that each element of `α` might satisfy, if there exists an element `i` such that for all elements `j` greater than or equal to `i`, `p` holds, and similarly for `q`, then there exists an element `i` such that for all elements `j` greater than or equal to `i`, both `p` and `q` hold. In other words, if we can find a point in the order after which all elements satisfy `p` and a point after which all elements satisfy `q`, we can find a point after which all elements satisfy both `p` and `q`.

If `α` is a linear order and there exist elements `i` such that for all `j ≥ i`, both `p(j)` and `q(j)` hold, then there exists an element `i' ≤ i` such that for all `j ≥ i'`, both `p(j)` and `q(j)` hold.


theorem Submodule.ker_mkQ :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M),
      LinearMap.ker (Submodule.mkQ p) = p :=
  by sorry

The theorem `Submodule.ker_mkQ` states that for any ring `R`, any additive commutative group `M`, and any `R`-module structure on `M`, and for any submodule `p` of `M`, the kernel of the linear map from `M` to the quotient of `M` by `p` (denoted as `M ⧸ p`), which is created by `Submodule.mkQ p`, is equal to `p`. In other words, this means that the set of all elements of `M` which are mapped to the zero element of the quotient module `M ⧸ p` by this linear map is exactly the submodule `p`.

The kernel of the quotient map from an `R`-module `M` to `M/p` is equal to the submodule `p`, where `p` is a submodule of `M` and `M/p` is the quotient of `M` by `p`.


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

This theorem states that for any type `α` that is a monoid and has the ability to distribute negation, and any natural number `n` that is even, the negative of any element `a` of type `α` raised to the power `n` equals that element `a` raised to the power `n`. In mathematical terms, if `n` is even, then `(-a)^n = a^n` for any `a` in `α`.

For any monoid `α` with distributive negation and even natural number `n`, (-`a`)^`n` = `a`^`n` for all `a` in `α`.


theorem map_multiset_sum :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : AddCommMonoid β] {F : Type u_5}
      [inst_2 : FunLike F α β] [inst_3 : AddMonoidHomClass F α β] (f : F) (s : Multiset α),
      f (Multiset.sum s) = Multiset.sum (Multiset.map (⇑f) s) :=
  by sorry

The theorem `map_multiset_sum` states that for any type `α` and `β`, which both have a structure of a commutative additive monoid, for any function-like `F` from `α` to `β` that is also a homomorphism with respect to the additive monoid structure, and for any multiset `s` of elements of type `α`, the result of applying the function `f` to the sum of the multiset `s` is equal to the sum of the multiset obtained by mapping `f` over `s`.

In other words, the function `f` commutes with the sum operation on multisets, and therefore can be interchanged with it. This is an instance of a more general property often encountered in mathematics, where a map preserves a certain operation (in this case, addition), which is expressed in the language of category theory as the map being a homomorphism.

For any commutative additive monoid homomorphism F between types α and β, and any multiset s of elements from α, the application of F to the sum of s is equal to the sum of the images of s under F.


theorem measurable_id' : ∀ {α : Type u_1} {x : MeasurableSpace α}, Measurable fun a => a := by sorry

The theorem `measurable_id'` states that, for any given type `α` and any measurable space `x` of type `α`, the identity function (that is, a function which returns its input unchanged) is measurable. In mathematical terms, this means that for any measurable set within this space, the preimage of the set under the identity function is also measurable.

The identity function is measurable, i.e., for any measurable set in a measurable space, its preimage under the identity function is also measurable.


theorem Polynomial.eval₂_monomial :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S) {n : ℕ} {r : R},
      Polynomial.eval₂ f x ((Polynomial.monomial n) r) = f r * x ^ n :=
  by sorry

The theorem `Polynomial.eval₂_monomial` states that for any semirings `R` and `S`, given a ring homomorphism `f` from `R` to `S`, a scalar `x` in `S`, a natural number `n` and a scalar `r` in `R`, evaluating the monomial `a * X^n` at `x` using `f` is equivalent to applying `f` to `a` and multiplying the result by `x` raised to the power `n`. In other words, `f(a) * x^n` is the evaluation of the monomial `a * X^n` under the mapping `f` and the value `x`.

For any semirings R and S, ring homomorphism f from R to S, scalar x in S, natural number n, and scalar r in R, we have f(ar^n) = a * (xf^n).


theorem continuousAt_snd :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X × Y},
      ContinuousAt Prod.snd p :=
  by sorry

This theorem states that for any pair of types `X` and `Y`, both equipped with a topological space structure, and for any pair `p` of elements from `X` and `Y`, the second projection function `Prod.snd` is continuous at `p`.

In other words, as a point in the product space `X × Y` approaches `p`, the value of the function `Prod.snd` at that point (which is the corresponding `Y` component) tends to the `Y` component of `p`. This is the definition of continuity at a point in the context of topological spaces.

For any topological spaces `X` and `Y` and any point `p` in their product `X × Y`, the second projection function `Prod.snd` is continuous at `p`.


theorem Function.Periodic.sub_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddGroup α],
      Function.Periodic f c → ∀ (x : α), f (x - c) = f x :=
  by sorry

The theorem `Function.Periodic.sub_eq` states that for any function `f` mapping from a type `α` to another type `β`, being `periodic` with period `c` implies that for all `x` of type `α`, the value of `f` at `x - c` is equal to the value of `f` at `x`. Here, `α` is a type with an addition operation and an inverse operation (making it an AddGroup). This theorem essentially tells us that if a function repeats its values after adding a certain constant, it will also repeat its values after subtracting the same constant.

If `f` is a periodic function on an additive group `α` with period `c`, then `f(x) = f(x - c)` for all `x` in `α`.


MeasurableSpace.ext

theorem MeasurableSpace.ext :
    ∀ {α : Type u_1} {m₁ m₂ : MeasurableSpace α}, (∀ (s : Set α), MeasurableSet s ↔ MeasurableSet s) → m₁ = m₂ := by
  sorry

This theorem, `MeasurableSpace.ext`, states that for any type `α` and any two measurable spaces `m₁` and `m₂` over this type, if for every set `s` of elements of type `α`, `s` is measurable in `m₁` if and only if it is measurable in `m₂`, then `m₁` and `m₂` must be the same measurable space. In other words, two measurable spaces are equal if they agree on the measurability of every set.

If two measurable spaces over the same type have identical measurability properties for every set, then they are equal.


theorem Mathlib.Order.CompleteLattice._auxLemma.7 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, any function `f` from an arbitrary type `ι` to `α`, and any element `a` of `α`, the supremum of the set of all `f(i)` (for all `i` in `ι`), denoted by `iSup f`, is less than or equal to `a` if and only if for all `i` in `ι`, `f(i)` is less than or equal to `a`. This captures the idea that the supremum of a set is the least upper bound of that set.

For any complete lattice `α`, any function `f` from a type `ι` to `α`, and any `a` in `α`, the supremum `iSup f` of `f` over `ι` is less than or equal to `a` if and only if `f(i)` is less than or equal to `a` for all `i` in `ι`.


theorem Mathlib.Algebra.Group.Basic._auxLemma.6 :
    ∀ {M : Type u} [inst : AddLeftCancelMonoid M] {a b : M}, (a + b = a) = (b = 0) := by sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.6`, states that for any type `M` that is an instance of `AddLeftCancelMonoid`, for any elements `a` and `b` of `M`, the statement `a + b = a` is equivalent to the statement `b = 0`. In other words, in a left-cancellable monoid, when the sum of two elements `a` and `b` equals `a`, that means `b` must be the identity element of the monoid (which is `0` in the case of an additive monoid).

In a left-cancelable monoid, for all elements `a` and `b`, `a + b = a` implies `b = 0`.


Filter.Eventually.frequently

theorem Filter.Eventually.frequently :
    ∀ {α : Type u} {f : Filter α} [inst : Filter.NeBot f] {p : α → Prop},
      (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, p x :=
  by sorry

This theorem states that for any type `α` and any filter `f` on `α`, provided that the filter `f` is not the bottom filter, if a property `p` holds "eventually" (meaning within a neighborhood of the filter) for elements `x` of type `α`, then there exists a neighborhood within the filter where the property `p` holds "frequently" (meaning on a dense subset).

Given a type `α` and a non-bottom filter `f` on `α`, if property `p` holds "eventually" for `x` in `α` with respect to `f`, then there exists a dense subset `D` of `α` within `f` such that `p` holds for all elements in `D`.


theorem Nat.le_ceil : ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] (a : α), a ≤ ↑⌈a⌉₊ :=
  by sorry

This theorem, `Nat.le_ceil`, states that for any type `α` which forms a linear ordered semiring and has a floor semiring (these are mathematical structures that satisfy certain properties), every element `a` of type `α` is less than or equal to its ceiling. The ceiling of a number, denoted `⌈a⌉₊`, is the smallest integer that is greater than or equal to `a`. Thus, this theorem says that no number is greater than its ceiling, which is a basic property of the ceiling function.

For any element `a` of a linear ordered semiring with a floor semiring, `a ≤ ⌈a⌉`.


/-- See also `pow_right_strictMono'`.  -/
theorem pow_right_strictMono :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {a : R}, 1 < a → StrictMono fun x => a ^ x := by sorry

The theorem `pow_right_strictMono` states that for any type `R` that is a strict ordered semiring, and for any element `a` of `R` such that `1 < a`, the function `x ↦ a ^ x` is strictly monotone. In other words, if `1 < a` in a strictly ordered semiring, then raising `a` to any power preserves the order: if `x < y` then `a ^ x < a ^ y`.

For any strict ordered semiring `R` and `1 < a` in `R`, the function `x ↦ a ^ x` is strictly increasing.


theorem Mathlib.Order.LocallyFinite._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      (x ∈ Finset.Icc a b) = (a ≤ x ∧ x ≤ b) :=
  by sorry

This theorem states that for any type `α` that is equipped with a `Preorder` structure and a `LocallyFiniteOrder` structure and for any elements `a`, `b`, and `x` of this type, the element `x` belongs to the finite set `Finset.Icc a b` if and only if `a ≤ x` and `x ≤ b`. Here, `Finset.Icc a b` is the finite set of elements `x` such that `a ≤ x` and `x ≤ b`. This set is similar to the mathematical closed interval `[a, b]` in interval notation.

For any type `α` with `Preorder` and `LocallyFiniteOrder` structures, an element `x` belongs to the finite interval `Finset.Icc a b` if and only if `a ≤ x` and `x ≤ b`.


Filter.Frequently.exists

theorem Filter.Frequently.exists : ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (∃ᶠ (x : α) in f, p x) → ∃ x, p x := by
  sorry

This theorem states that for any type `α`, any property `p` of `α`, and any filter `f` on `α`, if there frequently exists (`∃ᶠ`) an `x` in the filter `f` such that the property `p` holds, then there exists at least one `x` for which the property `p` holds. In essense, this theorem connects the concept of "frequently" in the context of filters with the ordinary existence of an element satisfying a property.

If a filter on a type contains an element satisfying a property "frequently," then it contains at least one element satisfying that property.


theorem convex_convexHull :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      (s : Set E), Convex 𝕜 ((convexHull 𝕜) s) :=
  by sorry

The theorem `convex_convexHull` states that for any type `𝕜` with an ordered semiring structure, any type `E` with a structure of an additive commutative monoid and a module over `𝕜`, and any set `s` of type `E`, the convex hull of `s` is a convex set. In other words, the minimal convex set that includes `s` is itself convex. This is a fundamental property in the theory of convex sets in linear spaces.

For any ordered semiring `𝕜`, additive commutative monoid and `𝝈`-module `E`, and set `s` of `E`, the convex hull of `s` is a convex set.


theorem Asymptotics.isBigOWith_norm_left :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c : ℝ}
      {g : α → F} {f' : α → E'} {l : Filter α},
      Asymptotics.IsBigOWith c l (fun x => ‖f' x‖) g ↔ Asymptotics.IsBigOWith c l f' g :=
  by sorry

The theorem `Asymptotics.isBigOWith_norm_left` states that for any type `α`, any normed type `F`, any semi-normed add commutative group `E'`, any real number `c`, any function `g` mapping from `α` to `F`, any function `f'` mapping from `α` to `E'`, and any filter `l` on `α`, the assertion that `f'` is `O(g)` with constant `c` with respect to the filter `l` when we take the norm of `f'`, is equivalent to the assertion that `f'` is `O(g)` with constant `c` with respect to the filter `l` without taking the norm. In mathematical terms, it means that $\|f'\| = O(g)$ if and only if $f' = O(g)$, where $O$ denotes the Big O notation, which describes an upper bound of one function in terms of another.

For any type `α`, normed type `F`, semi-normed add commutative group `E'`, real number `c`, functions `g : α → F` and `f' : α → E'`, and filter `l` on `α`, the condition `\|f'\| = O(g)` with constant `c` with respect to `l` is equivalent to `f' = O(g)` with constant `c` with respect to `l`.


theorem div_add_div_same : ∀ {α : Type u_1} [inst : DivisionSemiring α] (a b c : α), a / c + b / c = (a + b) / c := by
  sorry

This theorem, `div_add_div_same`, states that for any type `α` that is a Division Semiring, the sum of two numbers `a` and `b` divided by a third number `c` is equivalent to the sum of `a` divided by `c` and `b` divided by `c`. In mathematical terms, it asserts that for all `a`, `b`, and `c` in a Division Semiring `α`, the equation $\frac{a}{c} + \frac{b}{c} = \frac{a + b}{c}$ holds.

For any division semigroup `α`, the expression `(a / c) + (b / c)` is equal to `(a + b) / c`.


/-- The preimage of a null measurable set under a (quasi) measure preserving map is a null
measurable set.  -/
theorem MeasureTheory.NullMeasurableSet.preimage :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {ν : MeasureTheory.Measure β} {f : α → β} {t : Set β},
      MeasureTheory.NullMeasurableSet t ν →
        MeasureTheory.Measure.QuasiMeasurePreserving f μ ν → MeasureTheory.NullMeasurableSet (f ⁻¹' t) μ :=
  by sorry

In terms of mathematics, the theorem states that for any given types `α` and `β` with measurable spaces, a measure `μ` on `α`, a measure `ν` on `β`, and a function `f` mapping `α` to `β`, if a set `t` of type `β` is a null measurable set with respect to the measure `ν`, and if `f` is a quasi measure preserving function from `μ` to `ν`, then the preimage of the set `t` under the function `f` is also a null measurable set with respect to the measure `μ`. In simpler words, it means the pre-image of a null measurable set under a measure-preserving transformation is also a null measurable set.

If `μ` is a measure on `α`, `ν` is a measure on `β`, `f` is a quasi-measure preserving function from `α` to `β`, and `t` is a null measurable set in `β` with respect to `ν`, then `f⁻¹(t)` is a null measurable set in `α` with respect to `μ`.


/-- An `AddSubgroup` is closed under addition. -/
theorem AddSubgroup.add_mem :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x y : G}, x ∈ H → y ∈ H → x + y ∈ H := by sorry

This theorem states that an additive subgroup is closed under the operation of addition. More specifically, if 'G' is an additive group and 'H' is an additive subgroup of 'G', then for any elements 'x' and 'y' in 'H', their sum 'x + y' also belongs to 'H'. In the language of set theory, this means that the set 'H' is closed with respect to the operation of addition.

If 'H' is an additive subgroup of an additive group 'G', then for all 'x, y ∈ H', x + y ∈ H.


/-- A version of `Quotient.inductionOn₃` taking `{s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ}`
as implicit arguments instead of instance arguments.  -/
theorem Quotient.inductionOn₃' :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ}
      {p : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂) (q₃ : Quotient s₃),
      (∀ (a₁ : α) (a₂ : β) (a₃ : γ), p (Quotient.mk'' a₁) (Quotient.mk'' a₂) (Quotient.mk'' a₃)) → p q₁ q₂ q₃ :=
  by sorry

The theorem `Quotient.inductionOn₃'` provides a mechanism for proving properties about three elements of Quotient sets. Given setoids `s₁` for type `α`, `s₂` for `β`, and `s₃` for `γ`, and a property `p` that applies to elements of the Quotient sets of `s₁`, `s₂`, and `s₃`, it says that if this property holds for any representants `a₁`, `a₂`, and `a₃` of the equivalence classes (that is, `p (Quotient.mk'' a₁) (Quotient.mk'' a₂) (Quotient.mk'' a₃)`), then it will also hold for any elements `q₁`, `q₂`, `q₃` of the Quotient sets themselves (that is, `p q₁ q₂ q₃`). This allows us to reason about elements of Quotient sets by instead reasoning about elements of the original sets from which the Quotients are derived.

Given setoids s₁, s₂, and s₃, and a property p that is preserved under the Quotient.mk'' function, if p holds for any representants of the equivalence classes in s₁, s₂, and s₃, then p holds for any elements in the corresponding Quotient sets.


theorem Finset.image₂_subset_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α}
      {t t' : Finset β}, t ⊆ t' → Finset.image₂ f s t ⊆ Finset.image₂ f s t' :=
  by sorry

The theorem `Finset.image₂_subset_left` states that for all types `α`, `β`, and `γ` where `γ` has decidable equality, and for all binary functions `f` from `α` and `β` to `γ`, and for any finite sets `s` of `α` and `t` and `t'` of `β`, if set `t` is a subset of set `t'`, then the image of the function `f` applied to `s` and `t` is also a subset of the image of the function `f` applied to `s` and `t'`. In mathematical terms, if $t \subseteq t'$, then $f(s, t) \subseteq f(s, t')$.

For all types `α`, `β`, and `γ` with decidable equality, and for all functions `f` from `α × β` to `γ`, if `t ∈ Finset β` is a subset of `t' ∈ Finset β`, then `f''(s, t) ⊆ f''(s, t')` for any `s ∈ Finset α`, where `f''(s, t) := ⋃ i in t, f(s, i)` and `f''(s, t') := ⋃ i in t', f(s, i)`.


theorem Polynomial.natDegree_pos_iff_degree_pos :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, 0 < Polynomial.natDegree p ↔ 0 < Polynomial.degree p := by
  sorry

The theorem `Polynomial.natDegree_pos_iff_degree_pos` states that for any type `R` with a semiring structure and any polynomial `p` over `R`, the natural degree of `p` is greater than 0 if and only if the degree of `p` (which can potentially be an element of the `WithBot ℕ` type) is greater than 0. In other words, a polynomial has a positive natural degree if and only if it has a positive degree, where the degree of a polynomial is defined as the highest power of `X` that appears in the polynomial (or `⊥` for the zero polynomial) and the natural degree forces the degree of the zero polynomial to be 0.

For any polynomial p over a semiring R, the natural degree is strictly positive if and only if the degree is positive (or non-zero).


theorem HomologicalComplex.XIsoOfEq.proof_1 :
    ∀ {ι : Type u_2} {V : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p q : ι},
      p = q → K.X p = K.X q :=
  by sorry

This theorem states that for any type `ι`, any category `V` such that `V` is a category with zero morphisms, any complex shape `c`, and any homological complex `K` over `V` and `c`, if two indices `p` and `q` of the homological complex are equal, then the objects of the homological complex at those two indices are also equal. In other words, equality of indices implies equality of corresponding objects in a homological complex.

For any homological complex over a zero-morphism category and any equal indices, the corresponding objects are equal.


theorem le_compl_iff_disjoint_right : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ bᶜ ↔ Disjoint a b := by
  sorry

The theorem `le_compl_iff_disjoint_right` states that for any Heyting algebra `α` and elements `a` and `b` of that algebra, `a` is less than or equal to the complement of `b` if and only if `a` and `b` are disjoint. Here, 'disjoint' means that any element `x` of the algebra that is less than or equal to both `a` and `b` is actually less than or equal to the bottom element of the algebra. This extends the definition of disjointness to wider classes of ordered structures, beyond just sets.

In a Heyting algebra, elements $a$ and $b$ are disjoint if and only if $a \leq \neg b$, where $\neg$ denotes the complement operator.


/-- Two maps into an equalizer are equal if they are equal when composed with the equalizer map.  -/
theorem CategoryTheory.Limits.equalizer.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasEqualizer f g] {W : C} {k l : W ⟶ CategoryTheory.Limits.equalizer f g},
      CategoryTheory.CategoryStruct.comp k (CategoryTheory.Limits.equalizer.ι f g) =
          CategoryTheory.CategoryStruct.comp l (CategoryTheory.Limits.equalizer.ι f g) →
        k = l :=
  by sorry

The theorem `CategoryTheory.Limits.equalizer.hom_ext` states that in a category `C`, for any two objects `X` and `Y` with morphisms `f` and `g` from `X` to `Y` and an equalizer of `f` and `g`, if there is a third object `W` and two morphisms `k` and `l` from `W` to the equalizer, then `k` and `l` are equal if they yield the same result when composed with the morphism from the equalizer to `X` (i.e., the equalizer map). In mathematical terms, this can be expressed as: if `k` composed with the equalizer map equals `l` composed with the equalizer map (k ∘ equalizer.ι f g = l ∘ equalizer.ι f g), then `k` equals `l` (k = l).

If two morphisms from a third object to the equalizer of two given morphisms have equal compositions with the equalizer map, then they are equal.


theorem Monotone.mem_upperBounds_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {a : α} {s : Set α}, a ∈ upperBounds s → f a ∈ upperBounds (f '' s) :=
  by sorry

This theorem states that for any types `α` and `β` with preorder relations, and any monotone function `f` from `α` to `β`, if an element `a` is in the upper bounds of a set `s` of type `α`, then `f(a)` is in the upper bounds of the image of the set `s` under the function `f`. In other words, if `a` is an upper bound of `s`, then `f(a)` is an upper bound of `f(s)`. This theorem encapsulates the property of monotone functions to preserve the order relationship between elements and sets under the operation of taking upper bounds.

For any monotonic function $f$ from preordered types $\alpha$ and $\beta$, if $a$ is an upper bound of a set $s$ in $\alpha$, then $f(a)$ is an upper bound of $f(s)$ in $\beta$.


theorem MeasureTheory.Measure.measurable_of_measurable_coe :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      (f : β → MeasureTheory.Measure α),
      (∀ (s : Set α), MeasurableSet s → Measurable fun b => ↑↑(f b) s) → Measurable f :=
  by sorry

The theorem `MeasureTheory.Measure.measurable_of_measurable_coe` states that for any two types `α` and `β` each equipped with a measurable space structure, if we have a function `f` from `β` to the space of measures on `α`, then `f` is a measurable function if the function that maps each element `b` of `β` to the measure of a set `s` under the measure `f b` is measurable for every measurable set `s`. In other words, `f` is measurable if for every measurable set `s`, the function that maps `b` to the measure of `s` in the measure space defined by `f(b)` is a measurable function.

A function `f` from a measurable space `(β, Σβ)` to the space of measures on another measurable space `(α, Σα)` is measurable if the function that maps each `b ∈ β` to the measure of a given measurable set `s ∈ Σα` under the measure `f(b)` is itself measurable.


theorem Matrix.submatrix_id_id :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (A : Matrix m n α), Matrix.submatrix A id id = A := by sorry

This theorem states that for any matrix `A` with arbitrary types for its rows (`m`), columns (`n`), and entries (`α`), applying the `Matrix.submatrix` function to `A` with the identity function (`id`) for both the row and column selectors results in the same matrix `A`. In other words, using the identity function as selectors when creating a submatrix doesn't change the original matrix.

For any matrix `A` of type `m × n` over type `α`, `Matrix.submatrix A id id = A`.


theorem Finset.inf'_congr :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) {t : Finset β}
      {f g : β → α} (h₁ : s = t), (∀ x ∈ s, f x = g x) → Finset.inf' s H f = Finset.inf' t ⋯ g :=
  by sorry

The theorem `Finset.inf'_congr` states that for any type `α` that forms a semilattice under the infimum operation, and any nonempty finite sets `s` and `t` of another type `β`, if `s` is equal to `t` and two functions `f` and `g` from `β` to `α` are equal on every element of `s`, then the infimum of the image of `s` under `f` is equal to the infimum of the image of `t` under `g`. This theorem is about the congruence of the `inf'` operation on finite sets with respect to set equality and pointwise function equality.

For any semilattice `α`, equal finite sets `s` and `t` of type `β`, and equal functions `f` and `g` from `β` to `α`, the infimum of `f` over `s` equals the infimum of `g` over `t`.


theorem IsOpen.openEmbedding_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s → OpenEmbedding Subtype.val := by sorry

This theorem states that for any set `s` of a type `X` equipped with a topological space structure, if `s` is open in this topology, then the function `Subtype.val` is an open embedding. In other words, the mapping that takes each element of the subtype defined by `s` (which consists of elements `x` of `X` for which the predicate `p(x)` holds) to the underlying base type `X` preserves the topology on `s` and embeds `s` as an open set in `X`.

For any subspace `s` of a topological space `(X,τ)` with the property that `s` is open in `(X,τ)`, the subtype embedding `Subtype.val : s ↪ X` is an open map.


theorem finrank_top :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      FiniteDimensional.finrank R ↥⊤ = FiniteDimensional.finrank R M :=
  by sorry

This theorem, named `finrank_top`, states that for any ring `R` and any additively commutative group `M` that is also an `R`-module, the finite rank of the top submodule (denoted by `⊤`) is equal to the finite rank of the module `M` itself. In other words, the rank of the entire space is the same as the rank of the module. This essentially says that the dimension of the total module space and the module itself are the same, which is a fundamental property of vector spaces in linear algebra.

For any additively commutative group `M` that is an `R`-module and has finite rank, the rank of the top submodule `⊤` equals the rank of `M`.


theorem Nat.div_div_eq_div_mul : ∀ (m n k : ℕ), m / n / k = m / (n * k) := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, the division of `m` by `n` followed by the division of the result by `k` is equal to the division of `m` by the product of `n` and `k`. In other words, `(m / n) / k = m / (n * k)` for all natural numbers `m`, `n`, and `k`.

For all natural numbers m, n, and k, (m / n) / k = m / (n * k).


theorem isOpen_lt :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α]
      [inst_3 : TopologicalSpace β] {f g : β → α}, Continuous f → Continuous g → IsOpen {b | f b < g b} :=
  by sorry

The theorem `isOpen_lt` states that for any two types `α` and `β`, where `α` has a topological space, a linear order, and an order-closed topology structure, and `β` has a topological space structure, for any two continuous functions `f` and `g` from `β` to `α`, the set of all `b` in `β` such that `f(b)` is less than `g(b)` is an open set in the topological space of `β`. This theorem links together concepts from topology and order theory, saying essentially that under certain conditions, the "less than" relation between the outputs of two continuous functions opens to an open set.

For any continuous functions `f` and `g` between topological spaces `β` with order-closed topology and `α`, the set of `b` in `β` such that `f(b) < g(b)` is an open subset of `β`.


Submodule.Quotient.eq

theorem Submodule.Quotient.eq :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
      {x y : M}, Submodule.Quotient.mk x = Submodule.Quotient.mk y ↔ x - y ∈ p :=
  by sorry

The theorem `Submodule.Quotient.eq` states that for any ring `R`, additively commutative group `M`, a module `M` over a ring `R`, and a submodule `p` of `M`, and any two elements `x` and `y` of `M`, the quotient of `x` and `y` under the submodule (i.e., `Submodule.Quotient.mk x` and `Submodule.Quotient.mk y`) are equal if and only if the difference of `x` and `y` is an element of the submodule `p`. In other words, `x` and `y` are equivalent modulo the submodule `p` precisely when their difference is in `p`.

For any ring `R`, additively commutative group `M`, module `M` over `R`, submodule `p` of `M`, and elements `x`, `y` in `M`, `Submodule.Quotient.mk x = Submodule.Quotient.mk y` if and only if `x - y` is in `p`.


theorem MeasureTheory.integral_eq_lintegral_of_nonneg_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f →
        MeasureTheory.AEStronglyMeasurable f μ → ∫ (a : α), f a ∂μ = (∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ).toReal :=
  by sorry

The theorem `MeasureTheory.integral_eq_lintegral_of_nonneg_ae` states that for any type `α`, a measure space `m` over `α`, a measure `μ` on that measure space, and a function `f` mapping from `α` to real numbers, if the function `f` is nonnegative almost everywhere with respect to the measure `μ` and `f` is "almost everywhere strongly measurable" with respect to `μ`, then the integral of `f` with respect to `μ` is equal to the real part of the extended nonnegative real (ENNReal) integral of `f` with respect to `μ`.

In more intuitive terms, this theorem relates two types of integrals: the regular integral and the "extended nonnegative real" integral, asserting that under specific conditions, they yield the same result. The conditions specified are that the function being integrated is nonnegative almost everywhere (i.e., except on a set of measure zero) and that it is "almost everywhere strongly measurable", meaning it is almost everywhere equal to the limit of a sequence of simple functions.

If a real-valued function on a measure space is nonnegative almost everywhere and almost everywhere strongly measurable, then its regular integral and extended nonnegative real integral equal each other.


theorem OrderIso.map_iInf :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β)
      (x : ι → α), f (⨅ i, x i) = ⨅ i, f (x i) :=
  by sorry

This theorem, `OrderIso.map_iInf`, states that for any two complete lattices `α` and `β`, and for any function from an arbitrary type `ι` to `α`, the image under an order isomorphism `f` of the greatest lower bound (infimum) of `x` over all `ι` is equal to the greatest lower bound of the image of `x` under `f` over all `ι`. In mathematical terms, it says that if `f` is an order isomorphism between `α` and `β`, then `f(inf i, x(i)) = inf i, f(x(i))`, where `inf` denotes the greatest lower bound (infimum).

For any order isomorphism `f` between complete lattices `α` and `β` and any function `x : ι → α`, `f(inf ι, x i) = inf ι, f(x i)`.


theorem MeasureTheory.integral_sub :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {f g : α → G},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ → ∫ (a : α), f a - g a ∂μ = ∫ (a : α), f a ∂μ - ∫ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_sub` states that for any type `α`, and any normed additive commutative group `G` which is also a normed space over the real numbers, given a measure space `m`, a measure `μ` on that space, and two functions `f` and `g` which are both integrable with respect to `μ`, the integral of the difference between `f` and `g` with respect to `μ` is equal to the difference between the integral of `f` and the integral of `g` with respect to `μ`. In mathematical terms, this can be written as: for all `α`, `G`, `m`, `μ`, `f`, and `g`, if `f` and `g` are both integrable functions, then ∫(f(a) - g(a))dμ = ∫f(a)dμ - ∫g(a)dμ.

For any normed additive commutative group `G` over the real numbers, measure space `m`, measure `μ`, and integrable functions `f` and `g` on `m` with values in `G`, we have ∫(f(a) - g(a))dμ = ∫f(a)dμ - ∫g(a)dμ.


theorem RingHom.map_sum :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : NonAssocSemiring β] [inst_1 : NonAssocSemiring γ]
      (g : β →+* γ) (f : α → β) (s : Finset α), g (Finset.sum s fun x => f x) = Finset.sum s fun x => g (f x) :=
  by sorry

For any given types `α`, `β`, and `γ` with `β` and `γ` being non-associative semirings, the theorem `RingHom.map_sum` states that for any ring homomorphism `g` from `β` to `γ`, any function `f` from `α` to `β`, and any finite set `s` of type `α`, the image under `g` of the sum of `f x` as `x` ranges over the elements of `s` is equal to the sum of `g (f x)` where `x` ranges over the elements of `s`. In mathematical notation, this can be expressed as `g (∑_{x∈s} f(x)) = ∑_{x∈s} g(f(x))`. This theorem essentially states the property of a ring homomorphism preserving the sum under its mapping.

Given ring homomorphisms `g: β → γ`, `f: α → β`, and a finite set `s` of type `α`, the image of the sum `∑_{x∈s} f(x)` under `g` is equal to the sum `∑_{x∈s} g(f(x))`.


theorem Nat.cast_eq_zero : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] {n : ℕ}, ↑n = 0 ↔ n = 0 :=
  by sorry

This theorem states that for any type `R` that has structures of `AddMonoidWithOne` and `CharZero`, a natural number `n` cast to type `R` is equal to zero if and only if `n` is equal to zero. Here, `AddMonoidWithOne` implies that `R` has operations of addition and multiplication with an identity element, and `CharZero` means that distinct natural numbers map to distinct elements of `R`. The theorem ensures that the zero element in the natural numbers and in `R` correspond under this mapping.

For any type `R` with `AddMonoidWithOne` and `CharZero` structures, the natural number `0` maps to the additive identity `0` in `R`.


theorem Set.diff_eq_empty : ∀ {α : Type u} {s t : Set α}, s \ t = ∅ ↔ s ⊆ t := by sorry

The theorem `Set.diff_eq_empty` states that for any type `α` and any two sets `s` and `t` of type `α`, the set difference `s \ t` is the empty set if and only if `s` is a subset of `t`. In other words, if all elements of set `s` are also in set `t` (meaning `s` is a subset of `t`), then there are no elements in `s` that are not in `t`, hence the set difference `s \ t` is empty. Conversely, if the set difference `s \ t` is empty, that means there are no elements in `s` that are not also in `t`, so `s` must be a subset of `t`.

For any type α and sets s and t of type α, s \ t is the empty set if and only if s is a subset of t.


theorem Mathlib.Data.Multiset.Basic._auxLemma.48 :
    ∀ {α : Type u_1} {a : α} {s t : Multiset α}, (a ∈ s + t) = (a ∈ s ∨ a ∈ t) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any two multisets `s` and `t` of type `α`, the element `a` is in the multiset formed by adding `s` and `t` if and only if `a` is in `s` or `a` is in `t`. In other words, membership in the union of two multisets is equivalent to membership in at least one of the original multisets.

For any type `α`, any element `a` of type `α`, and any multisets `s` and `t` of type `α`, `a` is in the multiset formed by `s ∪ t` if and only if `a` is in `s` or `a` is in `t`.


theorem Nat.lt_of_succ_le : ∀ {n m : ℕ}, Nat.succ n ≤ m → n < m := by sorry

This theorem, `Nat.lt_of_succ_le`, states that for any two natural numbers `n` and `m`, if the successor of `n` (which is `n + 1`) is less than or equal to `m`, then `n` is strictly less than `m`. This is a basic property of natural numbers, encapsulating the intuitive idea that if `n + 1` is not greater than `m`, then `n` must be less than `m`.

If `n + 1 ≤ m`, then `n < m` for natural numbers `n` and `m`.


theorem Nat.lt_of_succ_lt : ∀ {n m : ℕ}, Nat.succ n < m → n < m := by sorry

This theorem, `Nat.lt_of_succ_lt`, states that for any two natural numbers `n` and `m`, if the successor of `n` (which is `n+1`) is less than `m`, then `n` itself is less than `m`. This is intuitively clear, as if `n+1` is less than `m`, it is certain that `n` is also less than `m`.

If `n+1` is less than `m`, then `n` is less than `m`.


theorem Decidable.not_or_of_imp : ∀ {a b : Prop} [inst : Decidable a], (a → b) → ¬a ∨ b := by sorry

The theorem `Decidable.not_or_of_imp` states that for any two propositions `a` and `b`, given that `a` is decidable, if `a` implies `b` then either `not a` or `b` holds. This theorem connects logic implication with the logical disjunction, stating that if the truth of `b` follows from the truth of `a`, then either `a` is not true or `b` is true.

If `a` is decidable and `a` implies `b`, then `not a` or `b` holds.


theorem ENNReal.toReal_mono : ∀ {a b : ENNReal}, b ≠ ⊤ → a ≤ b → a.toReal ≤ b.toReal := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, if `b` is not infinity (`⊤`), then if `a` is less than or equal to `b` (`a ≤ b`), it implies that the conversion of `a` and `b` to real numbers retains this ordering (`a.toReal ≤ b.toReal`). In other words, the `toReal` function is monotonic: preserving the order of `a` and `b` in the ENNReal numbers when they are converted to real numbers, as long as `b` is not infinity.

For any extended nonnegative real numbers `a` and `b` with `b` finite, if `a ≤ b`, then `a.toReal ≤ b.toReal`.


theorem CategoryTheory.Functor.map_comp_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u_1, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{u_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y)
      (g : Y ⟶ Z) {W : D} (h : F.obj Z ⟶ W),
      CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) h =
        CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) :=
  by sorry

The theorem `CategoryTheory.Functor.map_comp_assoc` states that for any categories `C` and `D`, any functor `F` from `C` to `D`, any three objects `X`, `Y`, and `Z` in `C`, a morphism `f` from `X` to `Y`, a morphism `g` from `Y` to `Z`, and a morphism `h` from `F.obj Z` to any object `W` in `D`, the composition of the mapped composition of `f` and `g` with `h` is equal to the composition of the mapped `f` with the composition of the mapped `g` and `h`. In mathematical terms, this theorem expresses the associativity of the composition of morphisms after applying a functor, i.e., `F(f ≫ g) ≫ h = F(f) ≫ (F(g) ≫ h)`.

For any categories C, D and functor F, for any objects X, Y, Z in C and morphisms f: X → Y, g: Y → Z, and h: F(Z) → W in D, the diagram F(f) → F(Y) → F(Z) → F(W) commutes with F(g) → F(Z) → F(W), that is, F(f ≫ g) = F(f) ≫ F(g).


theorem CategoryTheory.Limits.BinaryBicone.inl_snd_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {P Q : C} (self : CategoryTheory.Limits.BinaryBicone P Q) {Z : C} (h : Q ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.inl (CategoryTheory.CategoryStruct.comp self.snd h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

This theorem, `CategoryTheory.Limits.BinaryBicone.inl_snd_assoc`, states that for any category `C` with zero morphisms, given objects `P`, `Q`, and `Z` in `C`, and a binary bicone `self` with `P` and `Q` as its apexes, the composition of the morphism `self.inl` with the composition of the morphism `self.snd` and some morphism `h` from `Q` to `Z` is equal to the composition of the zero morphism and `h`. In other words, it expresses a certain associativity property in the context of a binary bicone structure in category theory.

For any category with zero morphisms, the composition of a binary bicone's left injection with the composition of its right projection and a morphism is equal to the composition of the zero morphism and that morphism.


theorem Finset.Nonempty.of_image₂_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      (Finset.image₂ f s t).Nonempty → s.Nonempty :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` and for any binary function `f : α → β → γ`, if `f` is applied to every pair of elements from the finite sets `s` of type `α` and `t` of type `β` to produce a new finite set, and if this new finite set is non-empty, then the original finite set `s` is also non-empty. This basically says that if we have non-empty results from applying a function to pairs from sets `s` and `t`, set `s` cannot be empty.

If `f : α → β → γ` is a binary function such that the image of any pair of elements from finite sets `s : α` and `t : β` is a non-empty finite set, then `s` is non-empty.


theorem continuous_induced_rng :
    ∀ {α : Type u} {β : Type v} {γ : Type u_1} {f : α → β} {g : γ → α} {t₂ : TopologicalSpace β}
      {t₁ : TopologicalSpace γ}, Continuous g ↔ Continuous (f ∘ g) :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, and for any two functions `f` from `α` to `β` and `g` from `γ` to `α`, given the topological spaces `t₂` on `β` and `t₁` on `γ`, the function `g` is continuous if and only if the composition of `f` and `g` is continuous. In other words, the continuity of the function `g` can be deduced from the continuity of the composite function `f ∘ g`.

For any types `α`, `β`, and `γ`, and functions `f : α → β` and `g : γ → α`, the function `g` is continuous if and only if the composition `f ∘ g` is continuous with respect to the given topologies on `β` and `γ`.


/-- **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold everywhere.  -/
theorem tendsto_of_tendsto_of_tendsto_of_le_of_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {f g h : β → α}
      {b : Filter β} {a : α},
      Filter.Tendsto g b (nhds a) → Filter.Tendsto h b (nhds a) → g ≤ f → f ≤ h → Filter.Tendsto f b (nhds a) :=
  by sorry

The **Squeeze theorem**, also known as the **sandwich theorem**, asserts the following: Given a topological space with a preorder relation and a set of three functions `f`, `g`, and `h` mapping from a set `β` to the elements of the space, along with a filter `b` on `β` and an element `a` of the space, if `g` and `h` both tend to `a` (that is, their images under `b` converge to `a`), and `f` is bounded from below by `g` and from above by `h` (that is, `g ≤ f ≤ h` holds everywhere), then `f` also tends to `a`. In other words, if `f` is squeezed between `g` and `h`, and both `g` and `h` converge to the same limit, then `f` converges to the same limit as well.

If functions `f`, `g`, and `h` map a set to a topological space, `g` and `h` converge to a point `a` in the space, and `g ≤ f ≤ h` holds everywhere, then `f` also converges to `a`.


theorem Finset.coe_nonempty : ∀ {α : Type u_1} {s : Finset α}, Set.Nonempty ↑s ↔ s.Nonempty := by sorry

The theorem `Finset.coe_nonempty` states that for any given type `α` and any finite set `s` of that type, the property that the set `s` is nonempty (which means it contains at least one element) is equivalent to the property that the coercion of `s` to a set is also nonempty. In other words, a finite set `s` is nonempty if and only if the corresponding set `↑s` (obtained by forgetting that `s` is finite) is nonempty.

A finite set `s` of type `α` is nonempty if and only if the coerced set `↑s` is nonempty.


ContinuousOn.sub

theorem ContinuousOn.sub :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G]
      [inst_3 : TopologicalSpace α] {f g : α → G} {s : Set α},
      ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => f x - g x) s :=
  by sorry

The `ContinuousOn.sub` theorem states that for any topological space `G` and any type `α`, given `G` has a subtraction operation and is continuous under subtraction, and given another topological space `α`, if the functions `f` and `g` from `α` to `G` are continuous on a set `s`, then the function which maps `x` in `α` to the difference `f(x) - g(x)` in `G` is also continuous on this set `s`. This theorem is a formalization of the property of continuous functions in topology that the difference of two continuous functions is again a continuous function.

If `G` is a topological space with continuous subtraction and `f` and `g` are continuous functions from a set `s` in another topological space `α` to `G`, then the function `x ↦ f(x) - g(x)` is continuous on `s`.


theorem Option.map_comp_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ),
      Option.map g ∘ Option.map f = Option.map (g ∘ f) :=
  by sorry

The theorem `Option.map_comp_map` asserts that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` to `β` and `g` from `β` to `γ`, composing map operations on `Option` types is equivalent to mapping the composition of the two functions. In other words, mapping `g` over the result of mapping `f` over an `Option` type is the same as mapping the composition of `g` and `f` over the `Option` type. This theorem embodies the principle of function composition preservation under the `Option.map` operation.

For all types `α`, `β`, and `γ`, and functions `f : α → β` and `g : β → γ`, `Option.map (g) (Option.map f (some x)) = Option.map (g ∘ f) (some x)`.


theorem List.sublist_cons : ∀ {α : Type u_1} (a : α) (l : List α), List.Sublist l (a :: l) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, `l` is a sublist of the list formed by prepending `a` to `l`. In other words, if you have a list of items and add a new item to the front of the list, the original list is always a sublist of the updated list.

For any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, `a :: l` is a sublist of `l`.


theorem MeasureTheory.sum_sFiniteSeq :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [h : MeasureTheory.SFinite μ],
      MeasureTheory.Measure.sum (MeasureTheory.sFiniteSeq μ) = μ :=
  by sorry

This theorem, `MeasureTheory.sum_sFiniteSeq`, states that for any measurable space `α` and any measure `μ` on that space, if `μ` is sigma-finite (that is, it can be decomposed into a countable union of sets with finite measure), then the sum of the sequence of finite measures `sFiniteSeq μ` is equal to `μ` itself. In other words, a sigma-finite measure can be broken down into a sequence of finite measures that, when summed, reconstruct the original measure.

For any sigma-finite measure `μ` on a measurable space `α`, the sum of the sequence of its finite measure decompositions equals `μ`.


theorem Subgroup.mem_bot : ∀ {G : Type u_1} [inst : Group G] {x : G}, x ∈ ⊥ ↔ x = 1 := by sorry

This theorem, `Subgroup.mem_bot`, states that for any type `G` which has a group structure (denoted by `Group G`), an element `x` of type `G` belongs to the trivial subgroup (denoted by `⊥`) if and only if `x` is the identity element of the group (denoted by `1`). The trivial subgroup is the subgroup consisting only of the identity element. Hence, in simple terms, in any group, an element is in the trivial subgroup if and only if it is the identity element.

In any group, an element is in the trivial subgroup if and only if it is the identity element.


/-- Alias of `Nat.cast_inj` specialized to `PartENat` - -/
theorem PartENat.natCast_inj : ∀ {x y : ℕ}, ↑x = ↑y ↔ x = y := by sorry

This theorem states that for any two natural numbers `x` and `y`, the condition that their cast or conversion to `PartENat` (Partial Extended Natural numbers) are equal is equivalent to the condition that `x` and `y` themselves are equal. In other words, casting does not change the equality relation between natural numbers.

For all natural numbers x and y, x = y if and only if (x : PartENat) = (y : PartENat).


theorem Asymptotics.isBigOWith_norm_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {c : ℝ}
      {f : α → E} {g' : α → F'} {l : Filter α},
      (Asymptotics.IsBigOWith c l f fun x => ‖g' x‖) ↔ Asymptotics.IsBigOWith c l f g' :=
  by sorry

The theorem `Asymptotics.isBigOWith_norm_right` states that for any types `α`, `E`, and `F'`, if `E` has a norm and `F'` is a semi-normed add commutative group, then for any real number `c`, any filter `l` on `α`, and any functions `f : α → E` and `g' : α → F'`, the property that `f` is big O of the norm of `g'` (under `l`, with constant `c`) is equivalent to the property that `f` is big O of `g'` (under `l`, with constant `c`). In other words, the norm of function `g'` can be dropped without affecting the big O notation.

For types `α`, `E` (a normed vector space), and `F'` (a semi-normed add commutative group), the function `f : α → E` is big O of `g' : α → F'` (under filter `l` and constant `c`) if and only if it is big O of the norm of `g'` (under `l` and constant `c`).


theorem CategoryTheory.Limits.BinaryBicone.inl_fst_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {P Q : C} (self : CategoryTheory.Limits.BinaryBicone P Q) {Z : C} (h : P ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.inl (CategoryTheory.CategoryStruct.comp self.fst h) = h :=
  by sorry

In the context of category theory, the theorem `CategoryTheory.Limits.BinaryBicone.inl_fst_assoc` states that for any type `C` that forms a category with zero morphisms, given objects `P` and `Q` in `C` forming a binary bicone, for any object `Z` in `C` and a morphism `h` from `P` to `Z`, the composition of the morphism `h` with the morphism `self.fst` after `self.inl` is equal to `h`. Here, `self.inl` is a morphism from some object to `P`, and `self.fst` is a morphism from `P` to another object. The composition of morphisms is performed using `CategoryTheory.CategoryStruct.comp` function.

For any category with zero morphisms `C`, given a binary bicone `(P, Q, self)` and any morphism `h : P → Z` in `C`, we have `h ∘ self.inl ∘ self.fst = h`.


theorem vadd_neg_vadd :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (c : α) (x : β), c +ᵥ (-c +ᵥ x) = x := by
  sorry

This theorem states that for any type `α` that is an additive group, and any other type `β` that is an additive action of `α`, for any `c` of type `α` and `x` of type `β`, the vector addition of `c` and the vector addition of `-c` and `x` equals `x`. In mathematical notation, this can be written as: for all $c \in \alpha$ and $x \in \beta$, we have $c + (-c + x) = x$. This theorem essentially describes the cancellation property in the context of vector spaces.

For any additive group `α` and additive action `β` of `α` on a type `β`, for all `c` in `α` and `x` in `β`, we have `c + (-c + x) = x`.


theorem continuous_iff_coinduced_le :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
      Continuous f ↔ TopologicalSpace.coinduced f t₁ ≤ t₂ :=
  by sorry

This theorem states that for any two types `α` and `β`, a function `f` from `α` to `β`, and topological spaces `t₁` on `α` and `t₂` on `β`, the function `f` is continuous if and only if the coinduced topology on `β` from `f` and `t₁` is less than or equal to `t₂`. In other words, a function is continuous if the finest topology (coinduced topology) on the codomain that makes the function continuous is a subtopology of the given topology on the codomain.

A function between two topological spaces is continuous if and only if the coinduced topology on its codomain is a subtopology of the given topology on the codomain.


theorem Cardinal.mk_le_mk_of_subset : ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → Cardinal.mk ↑s ≤ Cardinal.mk ↑t := by
  sorry

The theorem `Cardinal.mk_le_mk_of_subset` states that for any two sets `s` and `t` of any type `α`, if `s` is a subset of `t` (represented as `s ⊆ t`), then the cardinality of `s` is less than or equal to the cardinality of `t` (denoted as `Cardinal.mk ↑s ≤ Cardinal.mk ↑t`). Cardinality, represented by `Cardinal.mk`, is a measure of the "size" or number of elements in a set, so this theorem essentially asserts that a subset can't have more elements than the set it's contained within.

If `s` is a subset of `t`, then the cardinality of `s` is less than or equal to the cardinality of `t`.


CategoryTheory.CommSq.flip

theorem CategoryTheory.CommSq.flip :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
      {i : Y ⟶ Z}, CategoryTheory.CommSq f g h i → CategoryTheory.CommSq g f i h :=
  by sorry

This theorem states that given a category `C` of any type `C` and any objects `W`, `X`, `Y`, and `Z` in this category, along with morphisms `f: W ⟶ X`, `g: W ⟶ Y`, `h: X ⟶ Z`, and `i: Y ⟶ Z`, if there exists a commutative square with the given morphisms, then there also exists a commutative square when the roles of `f` and `g`, and `h` and `i` are flipped. In other words, if you can move from `W` to `Z` via either `f` and `h` or `g` and `i`, then you can also do so if you swap the roles of `f` and `g`, and `h` and `i`.

Given a commutative square in a category with morphisms `f: W ⟶ X`, `g: W ⟶ Y`, `h: X ⟶ Z`, and `i: Y ⟶ Z`, if it exists, then interchanging the roles of `f` and `g`, and `h` and `i`, also yields a commutative square.


theorem CategoryTheory.Limits.IsZero.of_iso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C},
      CategoryTheory.Limits.IsZero Y → (X ≅ Y) → CategoryTheory.Limits.IsZero X :=
  by sorry

This theorem states that in any category `C`, if `Y` is a zero object (meaning it has the property that for every object in the category, there exists a unique morphism from `Y` to that object and from that object to `Y`), and `X` is isomorphic to `Y`, then `X` is also a zero object. The key premise is that being a zero object is preserved under isomorphism.

If `X` is isomorphic to a zero object `Y` in a category `C`, then `X` is also a zero object.


ContinuousOn.intervalIntegrable

theorem ContinuousOn.intervalIntegrable :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure ℝ}
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] {u : ℝ → E} {a b : ℝ},
      ContinuousOn u (Set.uIcc a b) → IntervalIntegrable u μ a b :=
  by sorry

The theorem `ContinuousOn.intervalIntegrable` states that for any function `u` from real numbers to a normed additive commutative group `E`, and any two real numbers `a` and `b`, if the function `u` is continuous on the set of elements lying between `a` and `b` (inclusive), then `u` is interval integrable with respect to a locally finite measure `μ` on the unordered interval from `a` to `b`. In other words, the function `u` is integrable on both intervals from `a` to `b` (exclusive of `a`, inclusive of `b`) and from `b` to `a` (exclusive of `b`, inclusive of `a`) with respect to the measure `μ`.

If a real-valued function `u` on a normed additive commutative group `E` is continuous on the interval [`a`, `b`], then `u` is integrable with respect to a locally finite measure `μ` on both the intervals [`a`, `b`) and (`b`, `a`].


Bipointed.Hom.ext

theorem Bipointed.Hom.ext : ∀ {X Y : Bipointed} (x y : Bipointed.Hom X Y), x.toFun = y.toFun → x = y := by sorry

This theorem states that for any two objects `X` and `Y` in the category of bipointed sets, if two morphisms (functions respecting the pointedness) `x` and `y` from `X` to `Y` are such that their underlying functions `x.toFun` and `y.toFun` are identical, then `x` and `y` themselves are necessarily the same. In other words, the morphism in a bipointed category is uniquely determined by its underlying function.

In the category of bipointed sets, two morphisms between objects with identical underlying functions are equal.


theorem Turing.ListBlank.head_cons :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ),
      Turing.ListBlank.head (Turing.ListBlank.cons a l) = a :=
  by sorry

This theorem states that for any type `Γ` that is inhabited (i.e., it is not an empty type), and any element `a` of type `Γ` and any `ListBlank` of `Γ` named `l`, the head of the `ListBlank` obtained by consing `a` onto `l` is `a`. It essentially posits the basic property of a "cons" operation in a list-like structure, asserting that when an element is added to the beginning of a list, it becomes the new head of the list.

For any type `Γ` and element `a` in `Γ`, the head of the list obtained by consing `a` to a list `l` of type `ListBlank Γ` is `a`.


/-- Restriction of a measure to a subset is monotone both in set and in measure.  -/
theorem MeasureTheory.Measure.restrict_mono :
    ∀ {α : Type u_2} {_m0 : MeasurableSpace α} ⦃s s' : Set α⦄,
      s ⊆ s' → ∀ ⦃μ ν : MeasureTheory.Measure α⦄, μ ≤ ν → μ.restrict s ≤ ν.restrict s' :=
  by sorry

The theorem `MeasureTheory.Measure.restrict_mono` states that for any type `α` equipped with a `MeasurableSpace` structure, if we have two sets `s` and `s'` of this type such that `s` is a subset of `s'`, and two measures `μ` and `ν` such that `μ` is less than or equal to `ν`, then the restriction of the measure `μ` to the set `s` is less than or equal to the restriction of the measure `ν` to the set `s'`. This shows that restricting a measure to a subset is a monotone operation in both the set and the measure.

If `α` is a MeasurableSpace, `s ⊆ s'`, `μ ≤ ν` are measures on `α`, then `μ!s ≤ ν!s'`.


theorem Nat.succ_le_succ_iff : ∀ {a b : ℕ}, Nat.succ a ≤ Nat.succ b ↔ a ≤ b := by sorry

This theorem states that for any two natural numbers 'a' and 'b', the successor of 'a' is less than or equal to the successor of 'b' if and only if 'a' is less than or equal to 'b'. In other words, incrementing both 'a' and 'b' by 1 does not change their relative ordering.

For any natural numbers 'a' and 'b', the successor of 'a' is less than or equal to the successor of 'b' if and only if 'a' is less than or equal to 'b'. Equivalently, a + 1 ≤ b + 1 if and only if a ≤ b.


theorem Monoid.pow_exponent_eq_one : ∀ {G : Type u} [inst : Monoid G] (g : G), g ^ Monoid.exponent G = 1 := by sorry

This theorem states that for any given group `G` and any element `g` in `G`, raising `g` to the power of the exponent of `G` will always yield the identity element of the group. This exponent is the smallest positive integer such that this property holds for all elements of the group, or it is zero if no such integer exists. The identity element of a group is the element that, when multiplied with any element of the group, leaves the other element unchanged.

For any group `G` and its identity element `e`, for all elements `g` in `G`, there exists an integer `n` such that `g^n = e`.


/-- A field extension is algebraic if it is finite.  -/
theorem Algebra.IsAlgebraic.of_finite :
    ∀ (K : Type u_1) (A : Type u_5) [inst : Field K] [inst_1 : Ring A] [inst_2 : Algebra K A]
      [inst_3 : FiniteDimensional K A], Algebra.IsAlgebraic K A :=
  by sorry

This theorem states that for any field `K` and ring `A`, if `A` is a field extension of `K` (i.e., `A` is an algebra over `K`) and `A` is also a finite-dimensional vector space over `K`, then `A` is an algebraic field extension of `K`. In other words, every element of `A` is algebraic over `K`, meaning it is a root of some non-zero polynomial with coefficients in `K`.

If `A` is a finite-dimensional field extension of `K`, then every element of `A` is algebraic over `K`.


theorem Ordinal.add_sub_cancel_of_le : ∀ {a b : Ordinal.{u_4}}, b ≤ a → b + (a - b) = a := by sorry

The theorem `Ordinal.add_sub_cancel_of_le` states that for any two ordinals `a` and `b` in the same type universe `u_4`, if `b` is less than or equal to `a`, then adding `b` to the difference of `a` and `b` results in `a`. In other words, if `b ≤ a`, then `b + (a - b) = a`. This is similar to the cancellation law of addition in ordinal arithmetic.

For any ordinals `a` and `b` in the same type universe, if `b ≤ a`, then `a = a + (b - b)`.


theorem Function.isPeriodicPt_minimalPeriod :
    ∀ {α : Type u_1} (f : α → α) (x : α), Function.IsPeriodicPt f (Function.minimalPeriod f x) x := by sorry

This theorem states that for any function `f` mapping a type `α` to `α` and any element `x` of type `α`, `x` is a periodic point of `f` with a period equal to its minimal period. A periodic point of a function is a point `x` such that applying the function a certain number of times (the period) returns `x`. The minimal period of `x` under `f` is the smallest positive number of applications of `f` needed to return to `x`, or zero if `x` is not a periodic point.

For any function `f: α -> α` and element `x: α`, if `x` is a periodic point of `f` with minimal period `n`, then applying `f` exactly `n` times to `x` returns `x`.


theorem Ordinal.one_le_iff_ne_zero : ∀ {o : Ordinal.{u_3}}, 1 ≤ o ↔ o ≠ 0 := by sorry

This theorem states that for any ordinal 'o', 'o' is greater than or equal to 1 if and only if 'o' is not equal to 0. This is saying in other words that an ordinal number is non-zero exactly when it is at least 1. This is a property of ordinal numbers which are used to represent order types in type theory, where order types are equivalence classes of well-orders.

For any ordinal number 'o', o is non-zero if and only if o ≥ 1.


theorem lt_asymm : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a < b → ¬b < a := by sorry

This theorem, `lt_asymm`, states that for any given type `α` with a preorder relation, and any two elements `a` and `b` of that type, if `a` is less than `b` then `b` cannot be less than `a`. This property is known as asymmetry of the less-than relation and is one of the defining characteristics of a preorder. This theorem is applicable to any type that has a preorder, such as the integers, the reals, or any other ordered set.

If `a` is less than `b` in a preorder, then it is not the case that `b` is less than `a`.


TensorProduct.ext'

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

The theorem `TensorProduct.ext'` states that for any commutative semiring `R` and any three modules `M`, `N`, and `P` over `R`, if two linear maps `g` and `h` from the tensor product of `M` and `N` to `P` have the same value for every pair of elements `x` from `M` and `y` from `N` in their tensor product, then these two maps `g` and `h` are the same. The tensor product here is denoted by `x ⊗ₜ[R] y`.

If two linear maps from the tensor product of two R-modules agree on all pairs of their arguments, then they are equal.


IsPrimitiveRoot.isIntegral

/-- `μ` is integral over `ℤ`.  -/
theorem IsPrimitiveRoot.isIntegral :
    ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K}, IsPrimitiveRoot μ n → 0 < n → IsIntegral ℤ μ := by sorry

The theorem `IsPrimitiveRoot.isIntegral` asserts that for any natural number `n` and any type `K` that forms a commutative ring, if `μ` is a primitive `n`th root in `K`, and `n` is greater than zero, then `μ` is integral over the integers (`ℤ`). In other words, `μ` is a root of some monic polynomial with integer coefficients.

For any natural number `n` and commutative ring `K`, if `μ` is a primitive `n`th root in `K`, then `μ` is a root of some monic polynomial with integer coefficients in `K[X]`.


theorem Rat.cast_def : ∀ {K : Type u_3} [inst : DivisionRing K] (r : ℚ), ↑r = ↑r.num / ↑r.den := by sorry

This theorem states that for any type `K` that is a division ring, the casting of a rational number `r` to type `K` is equivalent to the division of the casting of its numerator by the casting of its denominator. Essentially, it's showing how rational numbers are represented in any division ring.

For any division ring K and rational number r = p / q, the casting of r to type K is equivalent to the division of the casting of p by the casting of q in K. (i.e., p / q in Q ≈ (p / q)_K)


theorem Mathlib.Order.MinMax._auxLemma.3 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (min a b ≤ c) = (a ≤ c ∨ b ≤ c) := by sorry

This theorem states that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of this type, the minimum of `a` and `b` is less than or equal to `c` if and only if `a` is less than or equal to `c` or `b` is less than or equal to `c`. In other words, it is saying that `c` is greater than or equal to the smallest of `a` and `b` if `c` is greater than or equal to either `a` or `b`.

For any linear order type `α` and elements `a`, `b`, `c` of `α`, `min a b ≤ c` if and only if `a ≤ c` or `b ≤ c`.


Isometry.antilipschitz

theorem Isometry.antilipschitz :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → AntilipschitzWith 1 f :=
  by sorry

The theorem `Isometry.antilipschitz` states that for any two types `α` and `β` that are pseudo e-metric spaces, if a function `f` from `α` to `β` is an isometry (which by definition means it preserves the e-distance between any two points from `α`), then `f` is `AntilipschitzWith` a constant `K` equal to 1. In other words, for any two points in `α`, the e-distance between these two points is always less than or equal to 1 times the e-distance between their images under `f`.

Given isometric functions between pseudometric spaces, the function is antilipschitz with constant 1.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.61 :
    ∀ {V : Type u} (G : SimpleGraph V) (s : Set (Sym2 V)) (v w : V),
      (SimpleGraph.deleteEdges G s).Adj v w = (G.Adj v w ∧ s(v, w) ∉ s) :=
  by sorry

This theorem states that for any given type `V`, any simple graph `G` of vertices of type `V`, any set `s` of unordered pairs of vertices (denoted as `Sym2 V`), and any two vertices `v` and `w` of type `V`, the adjacency relation in the graph obtained by deleting from `G` the edges corresponding to the pairs in `s` between `v` and `w` is equivalent to the condition that `v` and `w` are adjacent in `G` and the pair `(v, w)` is not in the set `s`. In other words, `v` and `w` are connected in the graph after deleting the edges if and only if they were originally connected and their connection was not among those to be removed.

For any simple graph `G` of type `V`, vertices `v` and `w` of type `V`, and set `s` of unordered pairs of `V`, the adjacency relation between `v` and `w` in `G` after deleting edges corresponding to pairs in `s` is equivalent to `(v = w) \/ (v, w) IN s ^'` where `s ^'` is the complement of `s`.


theorem bot_eq_zero : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α], ⊥ = 0 := by sorry

This theorem states that, for any type 'α' which forms a canonically ordered additive commutative monoid, the bottom element (denoted as '⊥') is equivalent to zero. In other words, in the context of an additive commutative monoid which also respects a canonical ordering, the least element in the set is effectively the same as the additive identity, zero.

For any additively commutative monoid with a canonical ordering, the least element equals the additive identity.


theorem Multiset.fold_cons_left :
    ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α),
      Multiset.fold op b (a ::ₘ s) = op a (Multiset.fold op b s) :=
  by sorry

The theorem `Multiset.fold_cons_left` states that for any given type `α`, an operation `op` that is both commutative and associative, elements `b` and `a` of type `α`, and a multiset `s` of type `α`, applying the `fold` function with operation `op` and element `b` to the multiset obtained by adding `a` to `s` is equivalent to applying the operation `op` on `a` and the result of applying the `fold` function with operation `op` and element `b` to multiset `s`.

For any commutative and associative operation `op` on type `α`, and multisets `s` and `t` such that `t = s ++ {a}`, the result of `fold op b (s ++ {a})` is equal to `op a (fold op b s)`.


theorem continuousWithinAt_univ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → β) (x : α),
      ContinuousWithinAt f Set.univ x ↔ ContinuousAt f x :=
  by sorry

This theorem states that for all types `α` and `β` with topological space structures, for any function `f` from `α` to `β` and for any point `x` in `α`, the function `f` is continuous at `x` within the universal set (which contains all elements of `α`) if and only if `f` is continuous at `x`. In other words, imposing the condition that the continuity of the function is restricted within the universal set doesn't change the fact that the function is continuous at a point.

For any types `α` and `β` with topological spaces structures, and for any function `f` from `α` to `β` and point `x` in `α`, the function `f` is continuous at `x` in the universal set if and only if it is continuous at `x` in the pointwise sense.


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

This theorem states that for any type `α`, and any two sets `s` and `t` of type `α`, the union of the set difference `s \ t` (elements in `s` but not in `t`) and `t` is equal to the union of `s` and `t`. Essentially, it means that taking away elements from `s` which are in `t` and then uniting it back with `t` does not change the original union of `s` and `t`. This theorem is a basic result in set theory.

For any type `α` and sets `s` and `t` of type `α`, `(s \ t) ∪ t = s ∪ t`.


theorem Asymptotics.isLittleO_one_iff :
    ∀ {α : Type u_1} (F : Type u_4) {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {f' : α → E'}
      {l : Filter α} [inst_2 : One F] [inst_3 : NormOneClass F],
      (f' =o[l] fun _x => 1) ↔ Filter.Tendsto f' l (nhds 0) :=
  by sorry

This theorem, "Asymptotics.isLittleO_one_iff", states that for any type `α`, a type `F` with a norm, a type `E'` that forms a seminormed additive commutative group, a function `f'` from `α` to `E'`, and a filter `l` on `α`, with `F` having an element 'one' and a 'norm one' class, the function `f'` is little-o of one at the limit `l` (i.e., `f'` is dominated by the function returning one as `l` tends to infinity) if and only if the limit of `f'` as `l` tends to infinity is zero in the neighborhood filter at zero. In simpler terms, `f'` grows slower than the constant function 1 at `l` if and only if `f'` tends toward 0 as `l` tends toward infinity.

For any type `α`, normed type `F`, seminormed additive commutative group `E'`, function `f': α → E'`, and filter `l` on `α`, the function `f'` is little-o of one at the limit `l` if and only if the limit of `f'` as `l` approaches infinity is zero in the neighborhood filter at zero.


theorem AddHom.map_add :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] (f : AddHom M N) (a b : M), f (a + b) = f a + f b :=
  by sorry

This theorem, named `AddHom.map_add`, states that for all types `M` and `N` that have an addition operation (`Add M` and `Add N`), a function `f` that is an additive homomorphism (`AddHom M N`) preserves the addition operation. Specifically, for any two elements `a` and `b` of type `M`, applying the function `f` to the sum of `a` and `b` (`f (a + b)`) is the same as summing the individual results of applying `f` to `a` and `b` (`f a + f b`).

For any additive homomorphisms `f : Add M → Add N` between abelian groups `M` and `N`, `f (a + b) = f a + f b` for all `a, b ∈ M`.


theorem CategoryTheory.Limits.BinaryBicone.inr_fst_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {P Q : C} (self : CategoryTheory.Limits.BinaryBicone P Q) {Z : C} (h : P ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.inr (CategoryTheory.CategoryStruct.comp self.fst h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

This theorem, named `CategoryTheory.Limits.BinaryBicone.inr_fst_assoc`, is a statement about category theory, specifically about binary bicones and zero morphisms. In a category `C` that has zero morphisms, for any objects `P`, `Q`, and `Z` in `C` and any morphism `h` from `P` to `Z`, the composition of the morphism `inr` of a binary bicone `self` of `P` and `Q` with the composition of the morphism `fst` of `self` and `h` is the same as the composition of the zero morphism and `h`. In more mathematical terms, if we write composition as `≫`, we have `(self.inr ≫ (self.fst ≫ h)) = (0 ≫ h)`.

In a category with zero morphisms, for any object $P$, any object $Q$, any object $Z$, any morphism $h$ from $P$ to $Z$, and any binary bicone $self$ from $P$ to $Q$, we have $(self.inr ≫ (self.fst ≫ h)) = (0 ≫ h)$.


ExistsUnique.unique

theorem ExistsUnique.unique : ∀ {α : Sort u} {p : α → Prop}, (∃! x, p x) → ∀ {y₁ y₂ : α}, p y₁ → p y₂ → y₁ = y₂ := by
  sorry

The theorem `ExistsUnique.unique` states that for all types `α`, there is at most one element `x` of `α` that satisfies a certain property `p`. More specifically, if we know that there exists a unique `x` such that `p(x)` is true, then for any two elements `y₁` and `y₂` of `α`, if `p(y₁)` and `p(y₂)` are both true, then `y₁` and `y₂` must be equal. This theorem essentially formalizes the concept of uniqueness in Lean.

If `α` has at most one element `x` satisfying `p(x)`, then for all `y₁, y₂ ∈ α`, if `p(y₁)` and `p(y₂)` hold, then `y₁ = y₂`.


theorem Set.mem_smul_set_iff_inv_smul_mem :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
      x ∈ a • A ↔ a⁻¹ • x ∈ A :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a group and there is a multiplication action from `α` on `β`, given a set `A` of elements of type `β`, an element `a` of type `α`, and an element `x` of type `β`, `x` is in the set obtained by scaling `A` by `a` if and only if `a⁻¹` scaled by `x` is in `A`. Here, `a • A` means the set obtained by scaling every element of `A` by `a`, and `a⁻¹ • x` means `x` scaled by the inverse of `a`.

For any group action of type `α` on `β`, and any set `A` of elements in `β`, an element `x` is in the set `a • A` if and only if `a⁻¹ • x` is in `A`.


theorem hasBasis_nhdsSet :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set X),
      Filter.HasBasis (nhdsSet s) (fun U => IsOpen U ∧ s ⊆ U) fun U => U :=
  by sorry

The theorem `hasBasis_nhdsSet` states that for any given type `X` that has a topological space structure and any set `s` of `X`, the filter of neighborhoods of the set `s` (`nhdsSet s`) has a basis consisting of the set of all open sets `U` such that `s` is a subset of `U`. Here, a basis of a filter is a collection of sets that, roughly speaking, generates all other sets in the filter by taking intersections and supersets.

The filter of neighborhoods of a set in a topological space has a basis consisting of all open sets containing the set.


theorem Ideal.le_radical : ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R}, I ≤ Ideal.radical I := by sorry

This theorem states that for any commutative semiring `R` and any ideal `I` of `R`, `I` is a subset of the radical of `I`. In other words, every element of an ideal is also an element of its radical. This is because the radical of an ideal `I` includes each element `r` such that `r` raised to some power `n` is in `I`, and since `r` to the power of 1 is `r`, every element of `I` is in the radical of `I`.

For any commutative semiring R and its ideal I, I is contained in the radical of I.


Relation.ReflTransGen.trans

theorem Relation.ReflTransGen.trans :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b c : α},
      Relation.ReflTransGen r a b → Relation.ReflTransGen r b c → Relation.ReflTransGen r a c :=
  by sorry

This theorem states that for any type `α`, and any relation `r` of type `α → α → Prop`, if `a`, `b`, and `c` are of type `α`, then if `Relation.ReflTransGen r a b` and `Relation.ReflTransGen r b c` hold true, so does `Relation.ReflTransGen r a c`. In simpler terms, if there is a reflexive transitive relation from `a` to `b`, and from `b` to `c`, then there is also a reflexive transitive relation from `a` to `c`. This is essentially a generalization of the transitivity property for reflexive transitive relations.

If `r` is a reflexive and transitive relation on type `α`, then for all `a, b, c` in `α`, if `r a b` and `r b c` hold, then `r a c` holds as well.


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

The theorem `le_mul_of_one_le_left` states that for any type `α` that has multiplication (`MulOneClass α`), zero (`Zero α`), and a preorder relation (`Preorder α`), and where multiplication is monotonically increasing when multiplying by nonnegative elements on the right (`MulPosMono α`), if `b` is nonnegative (`0 ≤ b`) and `a` is greater than or equal to one (`1 ≤ a`), then `b` is less than or equal to the product of `a` and `b` (`b ≤ a * b`). In simpler terms, in such a mathematical setting, multiplying any nonnegative number by a number that is at least one will result in a product that is greater than or equal to the original number.

For any type `α` with `MulOneClass α`, `Zero α`, `Preorder α`, and `MulPosMono α`, if `0 ≤ b` and `1 ≤ a`, then `b ≤ a * b`.


theorem Function.iterate_add_apply : ∀ {α : Type u} (f : α → α) (m n : ℕ) (x : α), f^[m + n] x = f^[m] (f^[n] x) := by
  sorry

This theorem, `Function.iterate_add_apply`, states that for any function `f` mapping a type `α` to itself, and for any natural numbers `m` and `n`, and for any element `x` of type `α`, the function `f` iterated (`m + n`) times on `x` is equal to the function `f` iterated `m` times on the result of `f` iterated `n` times on `x`. This is essentially a property of function iteration, similar to the concept of exponents in arithmetic where `(m + n)`-th power is the `m`-th power of the `n`-th power.

For any function `f: α → α` and natural numbers `m` and `n`, `f^(m + n)(x) = f^m(f^n(x))`.


theorem Finsupp.support_add :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] [inst_1 : DecidableEq α] {g₁ g₂ : α →₀ M},
      (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support :=
  by sorry

The theorem `Finsupp.support_add` asserts that for any types `α` and `M`, where `M` forms an `AddZeroClass` (i.e., it has both an additive identity and an addition operation) and `α` has decidable equality, given two functions `g₁` and `g₂` from `α` to `M`, the support of the sum of `g₁` and `g₂` (denoted as `g₁ + g₂`) is a subset of the union of the support of `g₁` and the support of `g₂`. Here, the term "support" refers to the set of points where the function is non-zero.

For functions `g₁` and `g₂` from a decidably equal type `α` to an additive semigroup `M`, the support of `g₁ + g₂` is contained in the union of the supports of `g₁` and `g₂`.


theorem Submodule.map_top :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] (f : F), Submodule.map f ⊤ = LinearMap.range f :=
  by sorry

The theorem `Submodule.map_top` states that for any semiring `R` and `R₂`, any additive commutative monoid `M` and `M₂`, any module `R M` and `R₂ M₂`, any ring homomorphism `τ₁₂` from `R` to `R₂`, any function-like `F` from `M` to `M₂`, and any semilinear map `f` from `M` to `M₂` (with these semilinear maps being a class of functions that preserve addition and scalar multiplication), if `τ₁₂` is surjective, then, the image under `f` of the top element of the submodule lattice (which is the whole module `M`) equals the range of the linear map `f`. This is stating that applying `f` to all elements of `M` is equivalent to taking the range of `f`.

If `τ₁₂` is a surjective ring homomorphism from semiring `R` to `R₂`, then the image of the top element of the submodule lattice of `R M` under any semilinear map `f` from `M` to `R₂ M₂` equals the range of `f`.