theorem Mathlib.Algebra.Group.Basic._auxLemma.4 :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsRightCancelAdd G] (a : G) {b c : G}, (b + a = c + a) = (b = c) := by
  sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.4`, states that for any type `G` that has an addition operation and the right cancellation property, given any elements `a`, `b`, `c` of `G`, if `b` added to `a` equals `c` added to `a`, then `b` equals `c`. In mathematical terms, this theorem asserts the right cancellation law of addition: if $b + a = c + a$, then $b = c$. This property is a fundamental one in the study of algebraic structures such as groups and rings.

If `a` is an element of a type `G` with right cancellation property for addition, then `b = c` if and only if `b + a = c + a`.


theorem Mathlib.Algebra.Group.Basic._auxLemma.2 :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) := by
  sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.2`, states that for any type `G` that has an addition operation and satisfies the left cancellation property for addition, for any elements `a`, `b`, and `c` of `G`, the equality `a + b = a + c` implies `b = c`. In mathematical terms, this corresponds to the property that if adding a certain element on the left side of two other elements results in the same value, then those two elements are equal. This property is a key feature of structures that exhibit left cancellation.

For any additive group `G`, if `a + b = a + c`, then `b = c`.


theorem MeasureTheory.Measure.restrict_apply_univ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α),
      ↑↑(μ.restrict s) Set.univ = ↑↑μ s :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` defined on `α`, any measure `μ` of `MeasureTheory.Measure α`, and any set `s` of `Set α`, the measure of the universal set `Set.univ` restricted to the set `s` equals the measure of the set `s`. In other words, when we restrict our measure to a specific set, the measure of the entire universe is simply the measure of that set.

For any measurable space `(α, m0)`, measure `μ` of type `MeasureTheory.Measure α`, and set `s` of type `Set α`, we have `μ (Set.univ) = μ s`.


theorem ENNReal.coe_rpow_of_ne_zero : ∀ {x : NNReal}, x ≠ 0 → ∀ (y : ℝ), ↑x ^ y = ↑(x ^ y) := by sorry

This theorem states that for any non-zero nonnegative real number `x` and any real number `y`, the real-number exponentiation of the real part of `x` to the power `y` equals the real part of the nonnegative real-number exponentiation of `x` to the power `y`. In other words, when raising a non-zero nonnegative real number to any real power, taking the real part before or after the exponentiation operation does not change the result.

For any non-zero nonnegative real number x and real number y, Re(x^y) = (Re(x))^y.


theorem max_self : ∀ {α : Type u} [inst : LinearOrder α] (a : α), max a a = a := by sorry

This theorem, `max_self`, states that for any type `α` that has a linear order, the maximum of any element `a` and itself is always `a`. In other words, for any `a` in a linearly ordered set, `max(a, a)` is always equal to `a`.

For any type `α` with a linear order, the reflexivity property holds: for all `a` in `α`, `max a a = a`.


theorem Mathlib.Data.List.Nodup._auxLemma.4 :
    ∀ {α : Type u} {a : α} {l : List α}, List.Nodup (a :: l) = (a ∉ l ∧ List.Nodup l) := by sorry

This theorem states that, for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, the property that the list formed by prepending `a` to `l` has no duplicates (i.e., `List.Nodup (a :: l)`) is equivalent to the conjunction of the properties that `a` is not in `l` and `l` has no duplicates (i.e., `a ∉ l ∧ List.Nodup l`). In other words, a list has no duplicates if and only if its first element is not in the rest of the list and the rest of the list also has no duplicates.

For any type `α` and list `l` of elements of type `α`, the list `a :: l` has no duplicates if and only if `a ∉ l` and `l` have no duplicates.


theorem mul_nsmul : ∀ {M : Type u} [inst : AddMonoid M] (a : M) (m n : ℕ), (m * n) • a = n • m • a := by sorry

This theorem states that for any type `M` which is an Additive Monoid and any element `a` of `M`, the operation of scaling `a` by the product of two natural numbers `m` and `n` is equivalent to scaling `a` by `m` first and then scaling the result by `n`. Here, the notation `n • a` signifies the operation of adding `a` to itself `n` times, which is a generalization of multiplication for elements of an Additive Monoid.

For any additive monoid type M and elements a, m, n, the operation m * n * a equals (m * a) * n. (Scaling an additive monoid element by the product of two natural numbers is equivalent to scaling it by each factor separately.)


theorem Real.cos_zero : Real.cos 0 = 1 := by sorry

This theorem states that the cosine of zero in real numbers is equal to one. In other words, if we apply the `Real.cos` function to `0`, the result is `1`. This corresponds to the well-known fact from trigonometry that $\cos(0) = 1$.

The cosine of 0 in the real numbers is equal to 1. (cos 0 = 1 in real numbers)


theorem Function.Embedding.coeFn_mk :
    ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (i : Function.Injective f), ⇑{ toFun := f, inj' := i } = f := by sorry

This theorem, `Function.Embedding.coeFn_mk`, states that for all types `α` and `β`, given a function `f` from `α` to `β` and a proof `i` that `f` is injective (meaning that if `f x = f y` then `x = y`), the function produced by the embedding `{ toFun := f, inj' := i }` is equal to the original function `f`. In math terms, if `f: α → β` is an injective function, then the function produced by the embedding using `f` as the function and the proof of its injectivity is exactly the same as `f`.

For all types `α` and `β`, if `f: α → β` is an injective function and `i:` `Injective f`, then the embedding `{ toFun := f, inj' := i }` is equal to `f`.


Function.Involutive.surjective

theorem Function.Involutive.surjective : ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.Surjective f := by
  sorry

The theorem `Function.Involutive.surjective` states that for any type `α` and any function `f : α → α`, if `f` is involutive (meaning that applying `f` twice to any element gives you back the original element, i.e., `f ∘ f = id`), then `f` is also surjective. In terms of mathematics, this means that for any `α` in the universe of discourse and any function `f : α → α`, if `f` is such that `f(f(x)) = x` for all `x` in `α`, then for every `y` in `α`, there exists an `x` in `α` such that `f(x) = y`.

If `f : α → α` is an involutive function (`f ∘ f = id`), then `f` is surjective (for every `y` in `α`, there exists an `x` in `α` such that `f(x) = y`).


OrderIso.ext

theorem OrderIso.ext : ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {f g : α ≃o β}, ⇑f = ⇑g → f = g :=
  by sorry

This theorem, named "OrderIso.ext", states that for any two types α and β, both equipped with a less-than-or-equal-to relation (LE), if we have two order isomorphisms f and g from α to β, then if the application of f and g produces the same result, then f and g themselves are equal. In other words, this theorem is asserting the uniqueness of order isomorphisms; if two order isomorphisms behave the same way, they're the same isomorphism.

If α and β are types equipped with a LE relation, and f and g are order isomorphisms from α to β with f(x) = g(x) for all x in α, then f = g.


theorem WithBot.some_lt_some : ∀ {α : Type u_1} {a b : α} [inst : LT α], some a < some b ↔ a < b := by sorry

This theorem, `WithBot.some_lt_some`, states that for any type `α` and any two elements `a` and `b` of that type, given a less-than (`LT`) ordering on `α`, the comparison `some a < some b` is equivalent to `a < b`. In other words, the ordering on the optional version of the type (`WithBot α`) aligns with the original ordering on the type itself.

For any type `α` and its optional version `WithBot α`, and for all `a` and `b` in `α`, `some a < some b` if and only if `a < b` holds in the base type.


ContinuousMultilinearMap.ext

theorem ContinuousMultilinearMap.ext :
    ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
      {f f' : ContinuousMultilinearMap R M₁ M₂}, (∀ (x : (i : ι) → M₁ i), f x = f' x) → f = f' :=
  by sorry

The theorem states that for any semiring `R`, any type `ι`, and types `M₁` and `M₂` indexed by `ι` where each `M₁` is a module over `R` with an additive commutative monoid structure and a topology, and `M₂` is also a module over `R` with an additive commutative monoid structure and a topology, if `f` and `f'` are continuous multilinear maps from `M₁` to `M₂` over `R`, then `f` and `f'` are equal if and only if they are pointwise equal, i.e., `f x = f' x` for all `x` in the domain.

Given any semiring `R`, types `ι`, `M₁`, and `M₂` indexed by `ι` with `M₁` and `M₂` being commutative `R`-modules with additive topologies, and continuous multilinear maps `f` and `f'` from `M₁` to `M₂` over `R`, `f` equals `f'` if and only if they are pointwise equal, i.e., `f x = f' x` for all `x` in the domain.


Stream'.ext

theorem Stream'.ext : ∀ {α : Type u} {s₁ s₂ : Stream' α}, (∀ (n : ℕ), Stream'.get s₁ n = Stream'.get s₂ n) → s₁ = s₂ :=
  by sorry

This theorem, `Stream'.ext`, states that for any type `α` and any two streams `s₁` and `s₂` of `α`, if every corresponding pair of elements from `s₁` and `s₂` are equal (i.e., the `n`-th element of `s₁` is equal to the `n`-th element of `s₂` for every natural number `n`), then the two streams `s₁` and `s₂` are identical. In other words, two streams are considered the same if they have the same elements in the same order.

If two streams of the same type have equal elements at corresponding positions, then they are equal.


/-- If `α` has no zero divisors, then the product of two elements is nonzero iff both of them
are nonzero.  -/
theorem mul_ne_zero_iff :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a b : M₀}, a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 := by
  sorry

The theorem `mul_ne_zero_iff` states that for any type `M₀` that has a multiplication and zero, and that does not have any zero divisors (NoZeroDivisors), the product of two elements `a` and `b` is not zero if and only if both `a` and `b` are not zero. This theorem essentially formalizes the intuitive notion that in such a structure, zero cannot be produced by multiplying non-zero elements.

For types with multiplication and zero without zero divisors, `a * b ≠ 0` if and only if `a ≠ 0` and `b ≠ 0`.


theorem Finset.sum_union :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : AddCommMonoid β] [inst_1 : DecidableEq α],
      Disjoint s₁ s₂ →
        (Finset.sum (s₁ ∪ s₂) fun x => f x) = (Finset.sum s₁ fun x => f x) + Finset.sum s₂ fun x => f x :=
  by sorry

The theorem `Finset.sum_union` states that for any types `α` and `β`, given two finite sets `s₁` and `s₂` of type `α` and a function `f` from `α` to `β`, if `β` is an additive commutative monoid and there is a decidable equality on `α`, and if `s₁` and `s₂` are disjoint (i.e., their intersection is the empty set), then the sum of the function `f` applied to each element of the union of `s₁` and `s₂` is equal to the sum of the function `f` applied to each element of `s₁` plus the sum of the function `f` applied to each element of `s₂`. In mathematical terms, if $s_1$ and $s_2$ are disjoint sets and $f$ is a function, then $\sum_{x \in s_1 \cup s_2} f(x) = \sum_{x \in s_1} f(x) + \sum_{x \in s_2} f(x)$.

If `α` is a type with decidable equality, `β` is an additive commutative monoid, `f : α → β`, and `s₁` and `s₂` are disjoint finite sets of type `α`, then `∑ x in s₁ ∪ s₂, f x = ∑ x in s₁, f x + ∑ x in s₂, f x`.


/-- Assumes left covariance.
The lemma assuming right covariance is `Right.add_neg`. -/
theorem Left.add_neg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α}, a < 0 → b < 0 → a + b < 0 :=
  by sorry

This theorem, `Left.add_neg`, states that for any type `α` that is an instance of the `AddZeroClass`, `Preorder`, and satisfies the left covariance property, if `a` and `b` are elements of type `α` and both are less than zero, then the sum of `a` and `b` is also less than zero. In mathematical terms, it means that for a preordered additive group, the sum of two negative elements is also negative.

For any additive group `α` with a preorder relation making it a left covariant add monoid, if `a` and `b` are negative elements of `α`, then `a + b` is also negative.


theorem Complex.ofReal_one : ↑1 = 1 := by sorry

This theorem states that the complex number representation of the real number 1 is equal to 1. In other words, when the real number 1 is converted to a complex number, it remains 1.

The theorem asserts that the conversion of the real number 1 to a complex number results in the complex number 1. In mathematical notation: `1 = 1 : complex R`.


theorem List.zipWith_nil_right :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : List α} {f : α → β → γ}, List.zipWith f l [] = [] := by sorry

This theorem states that for any list `l` of elements of type `α` and any function `f` which takes as input an element of type `α` and an element of type `β` and returns an element of type `γ`, when we apply the `zipWith` function to `l` and an empty list of type `β`, we always get an empty list. In other words, if you try to zip any list with an empty list using any function, the result will always be an empty list.

For any list `l` of type `α` and any function `f : α → β → γ`, `zipWith f l [] = []`.


theorem Units.inv_mul_cancel_left : ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (b : α), ↑a⁻¹ * (↑a * b) = b := by sorry

This theorem states that for any type `α` that forms a Monoid (a mathematical structure with an associative binary operation and an identity element), given an invertible element `a` (denoted as `a : αˣ`) and any other element `b`, multiplying `b` by `a` and then by the inverse of `a` (from the left) will give back the original `b`. In other words, the left multiplication by an invertible element and its inverse in a Monoid is a canceling operation, which is analogous to multiplying by one in basic arithmetic. This principle is written in mathematical notation as:  `a⁻¹ * (a * b) = b`.

For any Monoid `α` and invertible element `a : αˣ`, `a⁻¹ * (a * b) = b`.


theorem isOpen_ne : ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x : X}, IsOpen {y | y ≠ x} := by
  sorry

This theorem states that for any type `X` equipped with a topological space structure and T1 space structure (i.e., every singleton set is closed), and for any element `x` of type `X`, the set of all elements `y` in `X` that are not equal to `x` is an open set in the given topological space. In other words, the complement of the singleton set containing `x` is an open set.

For any T1 topological space `(X, τ)` and its element `x ∈ X`, the complement of the singleton set `{x}` is an open set in `X`.


Polynomial.Monic.map

theorem Polynomial.Monic.map :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S),
      Polynomial.Monic p → Polynomial.Monic (Polynomial.map f p) :=
  by sorry

This theorem states that for any types `R` and `S` equipped with semiring structures, any polynomials `p` over `R`, and any ring homomorphism `f` from `R` to `S`, if the polynomial `p` is `Monic` (that is, its leading coefficient is 1), then the polynomial obtained by mapping `p` across the ring homomorphism `f` (denoted as `Polynomial.map f p`) is also `Monic`. In other words, the property of being `Monic` is preserved under the operation of mapping polynomials via a ring homomorphism.

If `f` is a ring homomorphism from semiring `R` to semiring `S`, `p` is a monic polynomial over `R`, then `Polynomial.map f p` is a monic polynomial over `S`.


theorem Nat.div_lt_self : ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n := by sorry

This theorem states that for every pair of natural numbers `n` and `k`, if `n` is greater than zero and `k` is greater than one, then the integer division of `n` by `k` is less than `n`. In other words, dividing a positive natural number by another natural number greater than one results in a number which is less than the original number.

For all natural numbers `n` greater than zero and `k` greater than one, `n` > `k` > 0 implies `n` / `k` < `n`.


theorem Set.sUnion_image : ∀ {α : Type u_1} {β : Type u_2} (f : α → Set β) (s : Set α), ⋃₀ (f '' s) = ⋃ x ∈ s, f x := by
  sorry

The theorem `Set.sUnion_image` states that for all types `α` and `β`, for every function `f` from `α` to a set of `β`, and for every set `s` of `α`, the union over the image of `s` under `f` is equal to the union over all `x` in `s` of `f(x)`. In other words, it expresses that applying a function to each element of a set and then taking the union of the results is the same as first taking the union over the set and then applying the function. This theorem is a fundamental property of sets and functions.

For any type `α`, set `s` of `α`, function `f` from `α` to a set, the union of `f''s` (image of `s` under `f`) is equal to the set `{x ∈ ⋃(s : Set α) : ∃(x' ∈ s). x = f(x')}`.


theorem nhds_discrete : ∀ (α : Type u_3) [inst : TopologicalSpace α] [inst_1 : DiscreteTopology α], nhds = pure := by
  sorry

The theorem `nhds_discrete` states that for any type `α` with a topological space structure and a discrete topology, the neighborhood filter at any point is equal to the singleton set containing that point. In other words, in a discrete topological space, a neighborhood of a point `x` is just the set `{x}` itself. This is because, in a discrete topology, every single set, including singletons, is open.

In a discrete topological space, the neighborhood filter of a point is equal to the singleton set containing that point.


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

This theorem, `LE.le.eq_of_not_lt`, states that for any type `α` that has a partial order, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, and it is not the case that `a` is strictly less than `b`, then `a` must be equal to `b`. This is in fact just an alias of the theorem `eq_of_le_of_not_lt` in Lean.

If `α` is a partially ordered type and `a` and `b` are elements of `α` with `a ≤ b` and `a < b` being false, then `a = b`.


Function.hfunext

theorem Function.hfunext :
    ∀ {α α' : Sort u} {β : α → Sort v} {β' : α' → Sort v} {f : (a : α) → β a} {f' : (a : α') → β' a},
      α = α' → (∀ (a : α) (a' : α'), HEq a a' → HEq (f a) (f' a')) → HEq f f' :=
  by sorry

This theorem, `Function.hfunext`, in Lean 4, states that given two function types `f : (a : α) → β a` and `f' : (a : α') → β' a'`, where `α` and `α'` are sorts and `β` and `β'` are type-level functions, if `α` is exactly the same as `α'` and for all `a` in `α` and `a'` in `α'`, if `a` and `a'` are propositionally equal (using heterogeneous equality `HEq`), then the result of the function `f` applied to `a` and the function `f'` applied to `a'` are also propositionally equal, we can conclude that the functions `f` and `f'` themselves are propositionally equal. This theorem is a generalization of function extensionality to heterogeneous types.

Given two functions `f : α → β` and `f' : α' → β'` between heterogeneous types `α`, `α'`, `β`, and `β'`, if `α = α'`, `HEq (a : α) (a' : α')`, and `β f a = β' (f' a')`, then `f = f'`.


Fact.elim

theorem Fact.elim : ∀ {p : Prop}, Fact p → p := by sorry

This theorem, named "Fact.elim", asserts that for any proposition `p`, if `p` is a fact, then `p` itself is true. In other words, given an instance of the `Fact` typeclass for a particular proposition `p`, it provides a proof of `p`. The `Fact` typeclass in Lean is a way of asserting that a certain proposition is universally true.

For any proposition `p` that is an instance of the `Fact` typeclass in Lean, `p` holds true.


theorem CategoryTheory.IsIso.inv_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {h : Y ⟶ Z}
      [inst_1 : CategoryTheory.IsIso f] [inst_2 : CategoryTheory.IsIso h],
      CategoryTheory.inv (CategoryTheory.CategoryStruct.comp f h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.inv h) (CategoryTheory.inv f) :=
  by sorry

This theorem, named `CategoryTheory.IsIso.inv_comp`, states that in any category `C`, for any three objects `X`, `Y`, and `Z` in this category, and for any two morphisms `f` from `X` to `Y` and `h` from `Y` to `Z` which are both isomorphisms, the inverse of the composition of `f` and `h` is equal to the composition of the inverse of `h` and the inverse of `f`. In mathematical terms, if both `f` and `h` are isomorphisms (invertible morphisms), then the inverse of `f` composed with `h` is the same as the composition of the inverse of `h` and the inverse of `f`.

In any category, if two isomorphisms compose, their inverses are inverse to each other.


theorem continuous_quotient_mk' : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Setoid X}, Continuous Quotient.mk' :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure, and any equivalence relation `s` on `X` (which forms a `Setoid X`), the canonical quotient map `Quotient.mk'` (which maps an element of `X` to its equivalence class in the quotient space `Quotient s`) is a continuous function. In other words, the image under `Quotient.mk'` of an open set in `X` is an open set in the quotient space.

The quotient map of a continuous function and an equivalence relation is a continuous function between the topological spaces.


theorem Measurable.const_mul :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Mul M] {m : MeasurableSpace α} {f : α → M}
      [inst_2 : MeasurableMul M], Measurable f → ∀ (c : M), Measurable fun x => c * f x :=
  by sorry

The theorem `Measurable.const_mul` states that for any types `M` and `α`, given a measurable space over `M`, a multiplication operation on `M`, a measurable space `m` over `α`, a function `f` from `α` to `M`, and a measurability condition on the multiplication in `M`, if `f` is measurable, then the function that multiplies each output of `f` by a constant `c` is also measurable. In other words, if `f` is a measurable function from `α` to `M` and `c` is a constant in `M`, then the function defined by `x ↦ c * f(x)` is also measurable.

If `f` is a measurable function from a measurable space `(α, Σ)` to a measurable space `(M, ℬ)` with a measurable multiplication operation, then the function `x ↦ c * f(x)` is measurable for any constant `c` in `M`.


theorem Cardinal.lift_one : Cardinal.lift.{u_2, u_1} 1 = 1 := by sorry

The theorem `Cardinal.lift_one` states that the cardinality of the singleton set, when lifted from one universe to another, remains 1. In simpler terms, it states that lifting the cardinality of a single-element set does not change its cardinality, regardless of the source and target universes involved.

The cardinality of a singleton set is preserved under set theoretic lifting between universes.


theorem Function.Periodic.nat_mul :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Semiring α],
      Function.Periodic f c → ∀ (n : ℕ), Function.Periodic f (↑n * c) :=
  by sorry

The theorem `Function.Periodic.nat_mul` states that for any arbitrary types `α` and `β`, given a function `f` from `α` to `β` and an element `c` of `α` such that `f` is periodic with period `c`, then for any natural number `n`, the function `f` is also periodic with period `n * c`. This is under the assumption that `α` is a semiring, which is a type with two associative binary operations where one operation distributes over the other, and the second operation has an identity element.

If `f` is a periodic function of period `c` on semiring `α`, then `f` is also periodic with period `n * c`.


UniformInducing.inducing

theorem UniformInducing.inducing :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformInducing f → Inducing f :=
  by sorry

This theorem states that for any two types `α` and `β` which have `UniformSpace` instances, any function `f` from `α` to `β` that induces a uniform structure is also inducing. In other words, if a function `f` is uniform inducing - meaning that the uniformity on `β` is the image under `f` of the uniformity on `α` - then it also preserves the topology, i.e., the preimage under `f` of an open set in `β` is open in `α`.

If two types `α` and `β` have `UniformSpace` instances, and a function `f` from `α` to `β` induces a uniform structure and preserves the topology, then `f` is uniformly continuous. (In other words, a uniformly inducing function is also continuous.)


theorem UniformSpace.Completion.induction_on₂ :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β]
      {p : UniformSpace.Completion α → UniformSpace.Completion β → Prop} (a : UniformSpace.Completion α)
      (b : UniformSpace.Completion β), IsClosed {x | p x.1 x.2} → (∀ (a : α) (b : β), p (↑α a) (↑β b)) → p a b :=
  by sorry

This theorem states that for any two types `α` and `β` both equipped with a uniform space structure, and any property `p` relating elements of the Hausdorff completions of `α` and `β`, if the set of pairs `(x, y)` such that `p x y` holds is closed, and `p` holds for all pairs `(a, b)` of elements of `α` and `β` respectively, then `p` also holds for any pair `(a, b)` of elements in the Hausdorff completions of `α` and `β`. In simpler terms, the theorem indicates a method to extend properties from original spaces to their completions, under certain conditions.

Given types `α` and `β` with uniform structures, and a property `p` on their Hausdorff completions such that the set of pairs `(x, y)` with `p x y` closed and `p ab` for all `a ∈ α` and `b ∈ β` implies `p xy` for any `x ∈ α↓` and `y ∈ β↓`, where `↓` denotes the Hausdorff completion.


theorem Int.fract_lt_one :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), Int.fract a < 1 := by sorry

The theorem `Int.fract_lt_one` states that for any value `a` in a type `α` that forms a linear ordered ring with a floor function, the fractional part of `a` (which is defined as `a` minus its floor) is always less than 1.

For any element `a` in a linear ordered ring with a floor function, the value of the fractional part `a - floor a` is less than 1.


theorem PartENat.natCast_get : ∀ {x : PartENat} (h : x.Dom), ↑(x.get h) = x := by sorry

This theorem states that for all partial natural numbers `x` with a defined domain, the natural number you get by applying the `get` function to `x` (assuming the domain `h` of `x` is defined) and then casting it to the type `PartENat`, is equal to `x` itself. In other words, it asserts that casting a retrieved value of a partial natural number back into the type of partial natural numbers doesn't change the original value.

For all partial natural numbers `x` with a defined domain, `get x = PartENat.cast (get x)` holds.


theorem Nat.pow_succ' : ∀ {m n : ℕ}, m ^ Nat.succ n = m * m ^ n := by sorry

This theorem states that for any natural numbers `m` and `n`, the power of `m` to the successor of `n` (or `m` to the power of `n + 1`) is equal to `m` multiplied by `m` to the power of `n`. In mathematical notation, this theorem states that $m^{n+1} = m * m^n$.

The theorem asserts that for any natural number `m` and `n`, `m^(n+1)` equals `m * m^n`.


theorem Nat.cast_add_one_pos :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1] (n : ℕ), 0 < ↑n + 1 :=
  by sorry

This theorem states that for any natural number `n`, if you have a type `α` that is an additive monoid with a unit element, has a partial order, a covariant class, respects the zero and one order, and where one is not zero, then the cast of `n` to `α` plus one is greater than zero. Essentially, this is asserting that when you add one to any non-negative natural number cast to a certain type, the result is always positive.

For any additive monoid with a unit element, partial order, covariance, and respect for zero and one, if one is non-zero, then for all natural numbers `n`, the element `(n : α) + 1` is positive in `α`.


Isometry.lipschitz

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

The theorem `Isometry.lipschitz` states that for any two pseudoemetric spaces `α` and `β`, if a function `f` from `α` to `β` is an isometry (meaning that it preserves the extended distance between any two points from the domain), then `f` is Lipschitz continuous with the constant 1. In other words, for all points `x` and `y` in the domain, the extended distance between `f(x)` and `f(y)` is less than or equal to the extended distance between `x` and `y`.

If `f` is an isometry between pseudometric spaces `α` and `β`, then `f` is Lipschitz continuous with constant 1.


theorem isOpen_Iio :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a : α},
      IsOpen (Set.Iio a) :=
  by sorry

The theorem `isOpen_Iio` states that for any type `α` that is equipped with a topological space structure, a linear order structure, and a topology where the "closed and bounded at the top" sets are closed, if `a` is an element of `α`, then the left-infinite right-open interval `{x | x < a}` (denoted as `Set.Iio a`) is an open set in the ambient topological space on `α`. That is, the set of all elements less than `a` forms an open set in this particular topology.

Given a topological space `(α, top)` with a linear order `<` and `a ∈ α` such that the closed and bounded sets are topologically closed, the set `{x | x < a}` is open.


theorem Nat.ge_of_not_lt : ∀ {n m : ℕ}, ¬n < m → n ≥ m := by sorry

This theorem, `Nat.ge_of_not_lt`, states that for any two natural numbers `n` and `m`, if it is not the case that `n` is less than `m` (`¬n < m`), then `n` must be greater than or equal to `m` (`n ≥ m`). This is a basic property of ordered number systems like the natural numbers, and it captures the idea that if one number isn't less than another, then it must be either equal to or greater than the other number.

If `n` is not less than `m` (`¬n < m`), then `n` is greater than or equal to `m` (`n ≥ m`).


/-- **Alias** of `div_eq_mul_inv`.

---

Dividing by an element is the same as multiplying by its inverse.

This is a duplicate of `DivInvMonoid.div_eq_mul_inv` ensuring that the types unfold better.
 -/
theorem division_def : ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a / b = a * b⁻¹ := by sorry

This theorem, named `division_def`, states that for any type `G` that forms a `DivInvMonoid`, dividing an element `a` by another element `b` is the same as multiplying `a` by the inverse of `b`. In mathematical terms, it asserts that for all `a` and `b` in `G`, `a / b` equals `a * b⁻¹`. This theorem is an alias of `DivInvMonoid.div_eq_mul_inv` and helps in ensuring better type unfolding.

For any type `G` that forms a `DivInvMonoid`, `a / b = a * b⁻¹` for all `a, b` in `G`.


theorem Polynomial.mem_roots :
    ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      p ≠ 0 → (a ∈ Polynomial.roots p ↔ Polynomial.IsRoot p a) :=
  by sorry

This theorem states that for any type `R` and any element `a` of `R`, given that `R` is a commutative ring and a domain, and for any polynomial `p` of coefficients from `R`, if `p` is not the zero polynomial, then `a` is a root of `p` (i.e., when `p` is evaluated at `a`, the result is zero) if and only if `a` belongs to the multiset of roots of `p`. In other words, this theorem provides the equivalence between the property of `a` being a root of `p` and the property of `a` being a member of the set of roots of `p`.

For any commutative ring and domain R, element a in R, and non-zero polynomial p over R, a is a root of p if and only if a belongs to the set of roots of p.


DifferentiableOn.mono

theorem DifferentiableOn.mono :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {s t : Set E}, DifferentiableOn 𝕜 f t → s ⊆ t → DifferentiableOn 𝕜 f s :=
  by sorry

The theorem `DifferentiableOn.mono` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, and normed additive commutative group `F`, if a function `f` from `E` to `F` is differentiable on a set `t` and `s` is a subset of `t`, then `f` is also differentiable on `s`. This means that the differentiability of a function within a set is preserved even if we restrict our attention to a smaller subset.

If a function is differentiable on a set and that set is a subset of another, then the function is differentiable on the smaller set (in the context of non-trivially normed fields and normed additive commutative groups).


theorem LocallyConstant.coe_comap :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
      (g : LocallyConstant Y Z), Continuous f → ⇑(LocallyConstant.comap f g) = ⇑g ∘ f :=
  by sorry

This theorem states that for any types `X`, `Y`, and `Z`, given the topological spaces on `X` and `Y`, a function `f` mapping `X` to `Y`, and a locally constant function `g` from `Y` to `Z`, if `f` is a continuous function, then the co-domain mapping of the comap operation (the process of pulling back `g` along `f`) on `f` and `g` is equal to the composition of the co-domain mapping of `g` and `f`. In other words, it says that the comap operation preserves the continuous composition of functions in the context of locally constant functions.

If `f` is a continuous function between topological spaces `X` and `Y`, and `g` is a locally constant function from `Y` to `Z`, then the co-domain mappings of `g` and the comap operation of `g` over `f` are equal, i.e., `g∘f ∘ iB(f) = iB(g)∘f`.


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

This theorem states that for any commutative ring `R` and two Lie Algebras `L₁` and `L₂` over `R`, any Lie algebra homomorphism `f` from `L₁` to `L₂` preserves the Lie brackets. In other words, applying `f` to the Lie bracket of `x` and `y` (denoted as `⁅x, y⁆`) in `L₁` results in the same as the Lie bracket of `f x` and `f y` in `L₂`.

Given any commutative ring `R`, Lie algebra homomorphism `f` from Lie algebra `L₁` to Lie algebra `L₂` over `R`, for all elements `x, y` in `L₁`, `f(⁅x, y⁆) = ⁅f(x), f(y)⁆`.


/-- This is not always a good idea as a `@[simp]` lemma,
as we lose the ability to use results that interact with `F`,
e.g. the naturality of a natural transformation.

In some files it may be appropriate to use `attribute [local simp] eqToHom_map`, however.
 -/
theorem CategoryTheory.eqToHom_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (p : X = Y),
      F.map (CategoryTheory.eqToHom p) = CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.eqToHom_map` states that for any categories `C` and `D`, and any functor `F` from `C` to `D`, if `X` and `Y` are objects in `C` such that `X = Y`, then mapping the morphism that corresponds to this equality (obtained through `CategoryTheory.eqToHom`) under the functor `F` is equal to the morphism in `D` that corresponds to the equality `F(X) = F(Y)`. In other words, the functor `F` preserves the morphisms that are induced by object equalities. This theorem is not always suitable to be a simplification lemma, as it might prevent us from using results that interact with `F`, such as the naturality of a natural transformation.

For any functor F between categories C and D, if X and Y are equal objects in C, then F(Equality morphism from X to Y) = Equality morphism from F(X) to F(Y) in D.


theorem MeasureTheory.measure_spanningSets_lt_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ]
      (i : ℕ), ↑↑μ (MeasureTheory.spanningSets μ i) < ⊤ :=
  by sorry

This theorem states that for any measurable space `α`, associated measure `μ`, and natural number `i`, the measure of the `i-th` spanning set is less than infinity. Here, the spanning sets are created from a monotone collection of sets that span the entire universe and have finite measure. This holds true for all sigma-finite measures, which are measures where the entire space can be partitioned into a countable collection of sets with finite measure.

For any sigma-finite measure space `(α, Σ, μ)` and monotone, finite-measure cover `{A_i}` of `α`, the sum `μ(⋃i:ℕ. A_i)` is finite.


theorem Set.sInter_eq_biInter : ∀ {α : Type u_1} {s : Set (Set α)}, ⋂₀ s = ⋂ i ∈ s, i := by sorry

This theorem states that for any type 'α' and any set 's' of sets of 'α', the intersection of all sets in 's' is equivalent to the intersection of all sets 'i' such that 'i' is an element of 's'. In other words, it means that the intersection over a collection of sets is the same whether it's done as a direct intersection over the collection (notated as ⋂₀ s) or as an intersection over each member of the collection (notated as ⋂ i ∈ s, i).

For any type 'α' and set 's' of sets of 'α', the intersection of all sets in 's' is equal to the intersection of all sets 'i' in 's'. In other words, ⋂ i ∈ s, i = ⋂ X ∈ s, X.


AEMeasurable.aestronglyMeasurable

/-- In a space with second countable topology, measurable implies strongly measurable.  -/
theorem AEMeasurable.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : MeasurableSpace β] [inst_2 : TopologicalSpace.PseudoMetrizableSpace β]
      [inst_3 : OpensMeasurableSpace β] [inst_4 : SecondCountableTopology β],
      AEMeasurable f μ → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

The theorem states that in a space with a second countable topology, if a function is almost everywhere measurable with respect to a measure, then the function is also almost everywhere strongly measurable with respect to the same measure. Here, "almost everywhere measurable" means that the function coincides almost everywhere with a measurable function, and "almost everywhere strongly measurable" means that the function is almost everywhere equal to the limit of a sequence of simple functions. This statement applies to functions from a measurable space to a topological space that is pseudometrizable, has an opens measurable space structure, and has a second countable topology.

In a second countable, pseudometrizable topological space with an measurable structure, any almost everywhere measurable function is almost everywhere strongly measurable.


theorem Mathlib.Algebra.Module.Submodule.Lattice._auxLemma.5 :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      (x ∈ ⊤) = True :=
  by sorry

This theorem states that, for any semiring `R`, any additive commutative monoid `M`, and any module `R M` over the semiring and the monoid, any element `x` of `M` is an element of the top element of the lattice structure (denoted by `⊤`). In other words, all elements of the module belong to the top of the lattice structure, a statement that is always true.

For any semiring `R`, additive commutative monoid `M`, and `R`-module `M`, every element of `M` is contained in the top element of the lattice of `R`-submodules of `M`.


theorem Mathlib.Order.Filter.Basic._auxLemma.68 : ∀ {α : Type u} (f : Filter α), (∀ᶠ (x : α) in f, True) = True := by
  sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.68` states that for any type `α` and any filter `f` of type `α`, the statement that "for all `x` of type `α` in the filter `f`, the proposition `True` holds" is itself always True. In other words, it's always the case that for any element in any filter, the proposition `True` is true.

For any type `α` and filter `f` on `α`, the proposition that all elements in `f` satisfy `True` is always true.


theorem ciSup_const :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [hι : Nonempty ι] {a : α}, ⨆ x, a = a := by
  sorry

This theorem, `ciSup_const`, states that for any type `α` that forms a conditionally complete lattice and any nonempty index set `ι`, the supremum of any constant `a` from `α` over all elements `x` of the index set is equal to the constant `a` itself. This result holds regardless of the specific elements in the index set `ι` and does not require any additional conditions on the constant `a`.

For any conditionally complete lattice `α` and nonempty index set `ι`, the supremum of a constant `a` in `α` over all elements of `ι` equals `a`.


theorem Fintype.card_ne_zero : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α], Fintype.card α ≠ 0 := by sorry

The theorem `Fintype.card_ne_zero` states that for any type `α` that is a finite type (i.e., has a finite number of elements) and is nonempty (i.e., contains at least one element), the cardinality of `α` (the number of elements in `α`) is not equal to zero. This theorem is intuitively clear, as a set that contains at least one element cannot have zero elements, and serves as a formal encoding of this fact in Lean 4.

If `α` is a finite, nonempty type, then the cardinality of `α` is different from zero.


theorem Nat.sub_self : ∀ (n : ℕ), n - n = 0 := by sorry

This theorem states that for every natural number `n`, the result of subtracting `n` from itself is zero. In other words, any natural number minus itself always equals zero.


theorem ENNReal.tsum_le_tsum :
    ∀ {α : Type u_1} {f g : α → ENNReal}, (∀ (a : α), f a ≤ g a) → ∑' (a : α), f a ≤ ∑' (a : α), g a := by sorry

The theorem `ENNReal.tsum_le_tsum` states that for any type `α` and for any two functions `f` and `g` from `α` to the extended nonnegative real numbers (`ENNReal`), if each value of `f` is less than or equal to the corresponding value of `g` for all elements of type `α`, then the sum of all values of `f` is less than or equal to the sum of all values of `g`. In mathematical notation, if $\forall a \in \alpha, f(a) \leq g(a)$, then $\sum_{a \in \alpha} f(a) \leq \sum_{a \in \alpha} g(a)$.

For any type `α` and functions `f` and `g` from `α` to `ENNReal` with `f(a) ≤ g(a)` for all `a`, we have `∑(a ∈ α) f(a) ≤ ∑(a ∈ α) g(a)`.


theorem mem_extChartAt_source :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (I : ModelWithCorners 𝕜 E H) [inst_5 : ChartedSpace H M] (x : M),
      x ∈ (extChartAt I x).source :=
  by sorry

This theorem states that for any point `x` in a charted space `M` with a given model with corners `I`, `x` is an element of the source set of the extended chart at `x`. Here, the necessary conditions include `M` being a topological space that is charted over another topological space `H` with the model with corners `I`, `E` being a normed additive commutative group that is also a normed space over the nontrivially normed field `𝕜`, and `H` being a topological space.

For any point `x` in a charted topological space `M` over `H` with model `I`, `x` lies in the source set of the extended chart at `x`, where `M` is a topological space over `H`, `H` is a topological space, and `I` is a model with corners for a normed additive commutative group `E` over a nontrivially normed field `𝕜`.


theorem one_le : ∀ {α : Type u} [inst : CanonicallyOrderedCommMonoid α] (a : α), 1 ≤ a := by sorry

This theorem states that for any type `α` that is a Canonically Ordered Commutative Monoid, any element `a` of this type `α` is greater than or equal to 1. In other words, in a canonically ordered commutative monoid, no element can be less than the identity element 1.

In a canonically ordered commutative monoid, every element is greater than or equal to the identity element 1.


theorem Nat.mul_zero : ∀ (n : ℕ), n * 0 = 0 := by sorry

This theorem states that for any natural number `n`, the multiplication of `n` and `0` is `0`. In other words, any natural number multiplied by zero gives zero. This is a fundamental property of multiplication in the set of natural numbers (ℕ).


theorem bind_pure :
    ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [inst_1 : LawfulMonad m] (x : m α), x >>= pure = x := by
  sorry

This theorem, `bind_pure`, states that for any monad `m` and any type `α`, if `x` is an instance of `m α`, then binding `x` to the `pure` function (i.e., `x >>= pure`) yields `x` itself. This is essentially asserting a key property of monads in functional programming, where the `pure` function acts as an identity with respect to the monadic bind operation `>>=`. This property is required for `m` to obey the monadic laws and thus be a lawful monad (`LawfulMonad m`).

For any monad `m` and type `α`, the application of `pure` after `bind` (`>>=`) on an instance `x` of `m α` results in the identity `x`. That is, `x >>= pure = x`.


theorem Computation.destruct_think :
    ∀ {α : Type u} (s : Computation α), Computation.destruct (Computation.think s) = Sum.inr s := by sorry

The theorem `Computation.destruct_think` states that for any type `α` and any computation `s` of type `α`, destructing (or breaking down) the computation after delaying it for one "tick" using the `Computation.think` function will always return the original computation `s`. This is represented by `Sum.inr s` in the sum type `α ⊕ Computation α`, where `Sum.inr` indicates the right element of the sum type, referring to the original computation `s`.

For any type `α` and computation `s` of type `α`, `Computation.think (Computation.delay s) = s`. (The `Computation.think` function applied to a delayed computation returns the original computation.)


theorem Finset.mem_def : ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ s ↔ a ∈ s.val := by sorry

This theorem states that for any type `α`, any element `a` of that type, and any finite set `s` of type `α`, `a` is a member of `s` if and only if `a` is a member of the underlying value of `s`. This essentially means that an element's membership in a finite set is equivalent to its membership in the set's internal representation.

For any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, `a` is an element of `s` if and only if `a` is an element of the underlying set of `s`.


theorem Real.log_rpow : ∀ {x : ℝ}, 0 < x → ∀ (y : ℝ), Real.log (x ^ y) = y * Real.log x := by sorry

This theorem states that for any real number `x` that is greater than zero and for any other real number `y`, the logarithm of `x` raised to the power of `y` is equal to `y` times the logarithm of `x`. In other words, for $x > 0$ and any $y$, $\log(x^y) = y \log(x)$. This is a formal statement of a well-known logarithmic identity in the real number context.

For any real numbers $x > 0$ and $y$, $\log(x^y) = y\log(x)$.


theorem Fin.snoc_last :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α (Fin.castSucc i)),
      Fin.snoc p x (Fin.last n) = x :=
  by sorry

The theorem `Fin.snoc_last` states that for any natural number `n` and a family of types indexed by `Fin (n + 1)`, when you add an element `x` at the end of an `n`-tuple to get an `n+1`-tuple (via the function `Fin.snoc`), the element at the position of the greatest value of `Fin (n+1)` in the new tuple is indeed `x`. In other words, when you 'snoc' an element on to the end of a tuple, you can retrieve the same element by looking at the end of the new tuple.

For any natural number `n` and an `n+1`-tuple `ts`, the element added using `Fin.snoc` to form the new tuple `ts'` is equal to the last element of `ts'`, i.e., `ts.last = Fin.snoc ts x`.


theorem Set.eq_of_mem_singleton : ∀ {α : Type u} {x y : α}, x ∈ {y} → x = y := by sorry

This theorem, `Set.eq_of_mem_singleton`, states that for any type 'α' and any elements 'x' and 'y' of that type, if 'x' is an element of the set that contains only 'y', then 'x' must be equal to 'y'. In other words, if 'x' is in a singleton set whose only element is 'y', 'x' must be identical to 'y'. This is a fundamental property of singleton sets in set theory.

For any type 'α' and elements 'x' and 'y' of that type, if 'x' is in the singleton set {y}, then 'x' equals 'y'.


theorem forall_eq : ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) ↔ p a' := by sorry

This theorem states that for any type `α`, any predicate `p` over `α`, and any element `a'` of type `α`, the statement "for all `a` in `α`, if `a` equals `a'` then `p(a)` holds" is logically equivalent to "`p(a')` holds". In other words, if `p(a)` is true whenever `a` is the same as `a'`, then `p(a')` is also true, and vice versa.

For any type `α`, predicate `p` over `α`, and element `a'` of type `α`, the predicate `p` applied to `a'` is logically equivalent to the quantified predicate `∀a:α, a = a' → p a`.


theorem Ordinal.mul_isNormal : ∀ {a : Ordinal.{u_4}}, 0 < a → Ordinal.IsNormal fun x => a * x := by sorry

The theorem `Ordinal.mul_isNormal` states that for any ordinal `a` of the type `Ordinal`, if `a` is greater than zero, then the function that multiplies `a` with another ordinal `x` is a normal ordinal function. In other words, the function `f(x) = a * x` is strictly increasing and order-continuous. For a function to be order-continuous, the image of a limit ordinal under the function should be the supremum of the images of all ordinals less than the limit ordinal.

For any positive ordinal `a`, the function `x => a * x` is a normal ordinal function. (Equivalently, it is strictly increasing and order-continuous.)


theorem NNReal.rpow_one : ∀ (x : NNReal), x ^ 1 = x := by sorry

This theorem states that for every nonnegative real number `x`, raising `x` to the power of 1 is equal to `x` itself. In mathematical notation, this would be expressed as ∀x ∈ NNReal, x^1 = x. This means that the power function with exponent 1 is the identity function on the set of nonnegative real numbers.

For all non-negative real numbers x, x^1 = x. (The power function with exponent 1 is the identity function on non-negative real numbers.)


Filter.NeBot.mono

theorem Filter.NeBot.mono : ∀ {α : Type u} {f g : Filter α}, Filter.NeBot f → f ≤ g → Filter.NeBot g := by sorry

This theorem states that for any two filters `f` and `g` of some type `α`, if `f` is not a bottom filter and `f` is less than or equal to `g` (meaning every set in `f` is also in `g`), then `g` is also not a bottom filter. This theorem is essentially asserting a form of monotonicity for non-bottom filters.

If `f` is a non-bottom filter on type `α` and `f` is subset of filter `g`, then `g` is also a non-bottom filter.


theorem Filter.HasBasis.eq_biInf :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → l = ⨅ i, ⨅ (_ : p i), Filter.principal (s i) :=
  by sorry

The theorem `Filter.HasBasis.eq_biInf` states that for any type `α`, any sort `ι`, any Filter `l` on `α`, any predicate `p` on `ι`, and any function `s` from `ι` to a set of `α`, if `l` has a filter basis determined by the predicate `p` and the function `s`, then `l` is equal to the infimum of the principal filters of the sets `s i`, for each `i` that satisfies the predicate `p`. This infimum is taken twice, once over `i` and once over those `i` that satisfy `p`. In other words, `l` is characterized by the smallest filters that contain all sets `s i` for `i` meeting the condition `p i`.

For any type `α`, Filter `l` on `α`, predicate `p` on a sort `ι`, and function `s` from `ι` to `α`, if `l` is the infimum of the principal filters of `{s i | i ∈ ι & p i}`, then `l` has a filter basis determined by `p` and `s`.


theorem Finset.sup_lt_iff :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α} {a : α},
      ⊥ < a → (Finset.sup s f < a ↔ ∀ b ∈ s, f b < a) :=
  by sorry

The theorem `Finset.sup_lt_iff` states that for any types `α` and `ι`, given a linear order on `α`, a minimum element (or bottom) for `α`, a finite set `s` of type `ι`, a function `f` mapping `ι` to `α`, and an element `a` of `α` such that the minimum element is less than `a`, the supremum of the set `s` under the function `f` is less than `a` if and only if for all elements `b` in `s`, the value of the function `f` at `b` is less than `a`. In mathematical terms, it shows the condition under which the supremum of a set is less than a certain value.

For any linear order on a type `α`, a minimum element `⊥` in `α`, a finite set `s` of type `ι`, a function `f : ι → α`, and `a ∈ α` with `⊥ < a`, if for all `b ∈ s`, we have `f b < a`, then `sup (f '' s) < a`.


theorem Mathlib.Data.Set.Image._auxLemma.12 :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (f '' s ⊆ t) = (s ⊆ f ⁻¹' t) := by sorry

This theorem states that for any types `α` and `β`, for any set `s` of type `α`, for any set `t` of type `β`, and for any function `f` from `α` to `β`, the image of `s` through `f` is a subset of `t` if and only if `s` is a subset of the preimage of `t` through `f`. In mathematical notation, we have \(f(s) \subseteq t\) if and only if \(s \subseteq f^{-1}(t)\).

For any functions $f: \alpha \to \beta$, sets $s \subseteq \alpha$, and $t \subseteq \beta$, $f(s) \subseteq t$ if and only if $s \subseteq f^{-1}(t)$.


theorem sub_le_comm :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α}, a - b ≤ c ↔ a - c ≤ b :=
  by sorry

This theorem, `sub_le_comm`, states that for all elements `a`, `b`, and `c` of a type `α`, which belongs to an additive commutative group with a specific covariance property and a less than or equal to order, the difference of `a` and `b` being less than or equal to `c` is equivalent to the difference of `a` and `c` being less than or equal to `b`. In mathematical terms, it asserts that for all `a`, `b`, and `c` in the group, `(a - b) ≤ c` if and only if `(a - c) ≤ b`.

For all elements `a`, `b`, and `c` in a commutative additive group with a total order, `(a - b) ≤ c` if and only if `(a - c) ≤ b`.


theorem Int.emod_emod_of_dvd : ∀ (n : ℤ) {m k : ℤ}, m ∣ k → n % k % m = n % m := by sorry

This theorem, `Int.emod_emod_of_dvd`, states that for any integer `n` and any two integers `m` and `k`, if `m` divides `k`, then the remainder when `n` is divided by `k`, further divided by `m`, is equal to the remainder when `n` is divided by `m`. In mathematical notation, if `m|k`, then `(n mod k) mod m = n mod m`.

If `m` divides `k`, then `(n mod k) mod m = n mod m` for any integer `n`.


theorem Int.add_lt_add_left : ∀ {a b : ℤ}, a < b → ∀ (c : ℤ), c + a < c + b := by sorry

This theorem states that for all integers `a` and `b`, if `a` is less than `b`, then for any integer `c`, the sum of `c` and `a` is less than the sum of `c` and `b`. In mathematical terms, if $a < b$, then for all $c$, we have $c + a < c + b$. This is a formalization of the concept of preserving inequality under the addition of the same integer to both sides.

For all integers `a` and `b` where `a` < `b`, the sum of any integer `c` with `a` is less than the sum of `c` with `b`. Mathematically, if $a < b$, then for all $c$, we have $c + a < c + b$.


/-- To show a function into matrices is continuous it suffices to show the coefficients of the
resulting matrix are continuous  -/
theorem continuous_matrix :
    ∀ {α : Type u_2} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R]
      [inst_1 : TopologicalSpace α] {f : α → Matrix m n R},
      (∀ (i : m) (j : n), Continuous fun a => f a i j) → Continuous f :=
  by sorry

This theorem states that for a function `f` mapping from a type `α` to a matrix with entries in `R`, rows indexed by `m` and columns indexed by `n`, if every coefficient of the resulting matrix is a continuous function of `α`, then the entire function `f` is also continuous. Here, `R` is equipped with a topological space structure, as is `α`. In other words, to establish the continuity of a function into matrices, it is sufficient to demonstrate that the coefficients of the matrix output by the function are all continuous functions.

If every entry of a continuous function from a topological space to the space of matrices over a topological ring is continuous, then the function is continuous.


AlgEquiv.injective

theorem AlgEquiv.injective :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), Function.Injective ⇑e :=
  by sorry

The theorem `AlgEquiv.injective` states that for any commutative semiring `R` and semirings `A₁` and `A₂` with `R`-algebra structures, any algebra homomorphism `e` between `A₁` and `A₂` is injective. In other words, if `e` is an algebra homomorphism and `e(x) = e(y)` for some elements `x` and `y` in `A₁`, then `x = y`.

For any commutative semirings `R`, and `R`-algebra structures on semirings `A₁` and `A₂`, an `R`-algebra homomorphism `e` between `A₁` and `A₂` is injective.


theorem mem_nonZeroDivisors_iff_ne_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : NoZeroDivisors M] [inst_2 : Nontrivial M] {x : M},
      x ∈ nonZeroDivisors M ↔ x ≠ 0 :=
  by sorry

The theorem `mem_nonZeroDivisors_iff_ne_zero` states that for any given type `M` equipped with `MonoidWithZero`, `NoZeroDivisors`, and `Nontrivial` structures, an element `x` of type `M` is in the submonoid of non-zero-divisors of `M` if and only if `x` is not equal to zero. In other words, in such a structure, an element is a non-zero divisor if and only if it is not the zero element.

An element x of a monoid M equipped with MonoidWithZero, NoZeroDivisors, and Nontrivial structures is a non-zero divisor if and only if x ≠ 0.


theorem Cardinal.toNat_natCast : ∀ (n : ℕ), Cardinal.toNat ↑n = n := by sorry

This theorem states that for every natural number `n`, when `n` is cast to a `Cardinal` type and then the `toNat` function is applied to it, the result is equal to `n`. In other words, the process of converting a natural number to a cardinal and then converting that cardinal back to a natural number is faithful. This means it preserves the original value of the natural number.

For every natural number `n`, the conversion from `n` to `Cardinal` and back to natural number, using the functions `toCardinal` and `toNat` respectively, results in the original value of `n`. In Lean notation: `toNat (toCardinal n) = n`.


theorem Function.Periodic.int_mul :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℤ), Function.Periodic f (↑n * c) :=
  by sorry

The theorem `Function.Periodic.int_mul` states that for any type `α` and `β`, given a function `f` mapping `α` to `β`, a value `c` of type α, and an instance of `Ring α`, if the function `f` is periodic with period `c`, then for any integer `n`, the function `f` will also be periodic with period `n*c`. In mathematical terms, if `f(x+c) = f(x)` for all `x`, then `f(x+n*c) = f(x)` for all `x` and all integers `n`, where `f : α → β` and `c` and `x` are elements of a ring `α`.

If a function `f : α → β` over a ring `α` is periodic with period `c`, then it is also periodic with period `n*c` for any integer `n`.


StrictMonoOn.injOn

theorem StrictMonoOn.injOn :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → Set.InjOn f s :=
  by sorry

This theorem states that for all types `α` and `β`, where `α` is a linearly ordered set and `β` is a preordered set, for any function `f` from `α` to `β` and any set `s` of type `α`, if the function `f` is strictly monotone on the set `s`, then `f` is also injective on the set `s`. In other words, if a function strictly increases or decreases on a certain set, then it does not map different elements to the same value within that set.

If `f` is a function from a linearly ordered set `α` to a preordered set `β`, and `f` is strictly monotone on a set `s` ⊆ `α`, then `f` is injective on `s`.


theorem max_le_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, max a b ≤ c ↔ a ≤ c ∧ b ≤ c := by sorry

This theorem states that for any type `α` that has a linear order, and given three elements `a`, `b` and `c` of type `α`, the maximum of `a` and `b` is less than or equal to `c` if and only if both `a` and `b` are less than or equal to `c`. In other words, in a linearly ordered set, an element `c` is greater than or equal to the maximum of `a` and `b` if and only if `c` is greater than or equal to both `a` and `b`.

In a linearly ordered set, the maximum of two elements is equal to each element when both elements are less than or equal to the maximum.


/-- `nsmul` is equal to any other module structure via a cast.  -/
theorem nsmul_eq_smul_cast :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ)
      (b : M), n • b = ↑n • b :=
  by sorry

The theorem `nsmul_eq_smul_cast` states that for any semiring `R`, any additive commutative monoid `M`, and any `R`-module structure on `M`, the operation of scalar multiplication by a natural number `n` on an element `b` of `M` (`n • b`) is equal to the action of `n` cast to `R` acting on `b` (`↑n • b`). This essentially says that scalar multiplication by a natural number in the module is the same as multiplying by that number viewed as an element of the semiring.

For any semiring R, additive commutative monoid M with an R-module structure, and natural number n, the operation n • b of scalar multiplication on M equals the operation (↑n • b) obtained by casting n to R and acting on b.


theorem Mathlib.Data.Fintype.Basic._auxLemma.9 :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α} [inst_1 : DecidableEq α] {a : α}, (a ∈ sᶜ) = (a ∉ s) := by sorry

This theorem, `Mathlib.Data.Fintype.Basic._auxLemma.9`, states that for any type `α` which has finite elements, and for any finite set `s` of type `α`, given that `α` has decidable equality and some element `a` of type `α`, the property of `a` being an element of the complement of `s` is equivalent to `a` not being an element of `s`. In other words, an element is in the complement of a set if and only if it is not in the set itself. This is a fundamental property of set theory.

For any type `α` with finite elements and decidable equality, the complement of a finite set `s` in `α` is equal to the set of elements not in `s`.


TopologicalSpace.ext

theorem TopologicalSpace.ext : ∀ {X : Type u} {f g : TopologicalSpace X}, IsOpen = IsOpen → f = g := by sorry

This theorem, `TopologicalSpace.ext`, asserts that for any type `X`, if two topological spaces `f` and `g` over `X` have the property that their `IsOpen` predicates are the same, then `f` and `g` must be identical. In other words, a topological space is uniquely determined by its open sets.

If two topological spaces over a type `X` have identical open sets, then they are equal.


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

This theorem states that for any type `α` that forms a join-semilattice, and any nonempty finite sets `s` and `t` of type `β`, along with two functions `f` and `g` mapping from `β` to `α`, if `s` and `t` are identical sets (i.e., `s = t`), and for every element `x` in `s`, `f(x)` equals `g(x)`, then the supremum of the image of `s` under `f` is equal to the supremum of the image of `t` under `g`. In other words, if two nonempty finite sets are the same and two functions agree on every element of these sets, then the supremum of the sets under these functions will also be the same.

If `α` is a join-semilattice, `s` and `t` are identical nonempty finite sets, and `f(x) = g(x)` for all `x` in `s`, then `sup (map f s) = sup (map g t)`.


theorem List.range_eq_range' : ∀ (n : ℕ), List.range n = List.range' 0 n := by sorry

This theorem states that for any natural number `n`, the function `List.range n` generates the same list as `List.range' 0 n`. In other words, whether we use `List.range` or `List.range'` with a starting point of zero, we will obtain the same list of natural numbers from `0` to `n-1` in increasing order.

For any natural number `n`, `List.range n` equals `List.range' 0 n`. In mathematical terms, the sets generated by these functions are equal.


theorem Int.toNat_of_nonneg : ∀ {a : ℤ}, 0 ≤ a → ↑(Int.toNat a) = a := by sorry

This theorem states that for every integer `a`, if `a` is nonnegative (i.e., `a` is greater than or equal to 0), then converting `a` to a natural number using the function `Int.toNat` and then converting it back to an integer (indicated by `↑`) gives you `a` back. In essence, for nonnegative integers, the functions `Int.toNat` and then integer conversion form an identity operation.

For every non-negative integer `a`, `Int.toNat a = a` holds.


MeasureTheory.VectorMeasure.empty

theorem MeasureTheory.VectorMeasure.empty :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      (v : MeasureTheory.VectorMeasure α M), ↑v ∅ = 0 :=
  by sorry

This theorem states that for any given measure space `α` which is equipped with a measurable space structure `m`, and any topological additive commutative monoid `M`, the vector measure `v` of the empty set is equal to zero. It's a property in measure theory which indicates that an empty set doesn't contribute to the value of a measure, in this case a vector measure.

For any measure space `α` with measure `m` and any topological additive commutative monoid `M`, the vector measure `v` of the empty set is the zero vector.


theorem continuousOn_id : ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α}, ContinuousOn id s := by sorry

This theorem, `continuousOn_id`, states that for any type `α` which has a topological space structure, and for any set `s` of type `α`, the identity function is continuous on `s`. In other words, for each point in the set `s`, the map that takes each point to itself preserves the topological space structure, i.e., the preimage of any open set is also open.

For any topological space `(α, τ)` and subset `s ∈ α`, the identity function `id : α → α` is continuous on `s`, meaning the preimage of any open set in `α` under `id` is open in `s`.


theorem Nat.not_lt : ∀ {a b : ℕ}, ¬a < b ↔ b ≤ a := by sorry

This theorem states that for all natural numbers `a` and `b`, the negation of `a` being less than `b` is equivalent to `b` being less than or equal to `a`. In other words, if it is not true that `a` is less than `b`, then `b` must be less than or equal to `a`.

For all natural numbers `a` and `b`, `~(a < b)` is equivalent to `b <= a`.


theorem HahnSeries.isPWO_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R),
      Set.IsPWO (HahnSeries.support x) :=
  by sorry

The theorem `HahnSeries.isPWO_support` states that for any Hahn Series `x`, with order type `Γ` and coefficient type `R`, where `Γ` is a partially ordered set and `R` is a type with a zero element, the support of `x` is a partially well-ordered set. In more detail, the support of a Hahn series is the set of indices whose coefficients are nonzero, and this theorem asserts that any infinite sequence in this support set contains a monotone subsequence of length 2 or an infinite monotone subsequence, which is the definition of a set being partially well-ordered.

The support of a Hahn Series with order type Γ and coefficient type R, where Γ is a partially ordered set and R has a zero element, contains an infinite monotone subsequence.


PrimeSpectrum.gc

/-- `zeroLocus` and `vanishingIdeal` form a galois connection.  -/
theorem PrimeSpectrum.gc :
    ∀ (R : Type u) [inst : CommSemiring R],
      GaloisConnection (fun I => PrimeSpectrum.zeroLocus ↑I) fun t => PrimeSpectrum.vanishingIdeal t :=
  by sorry

The theorem `PrimeSpectrum.gc` states that for any commutative semiring `R`, the functions `zeroLocus` and `vanishingIdeal` form a Galois connection. Here, the `zeroLocus` function takes as input an ideal `I` of the ring `R` and returns the set of all prime ideals of `R` where `I` vanishes. The `vanishingIdeal` function takes as input a set `t` of prime ideals of `R` and returns the ideal of `R` that vanishes exactly on `t`. The Galois connection between these two functions means that for any ideal `I` and any set of prime ideals `t`, `I` vanishes on `t` if and only if `t` is contained in the zero locus of `I`.

For any commutative semiring R, the functions zeroLocus and vanishingIdeal form a Galois connection, where zeroLocus(I) is the set of prime ideals where I vanishes, and vanishingIdeal(t) is the ideal that vanishes exactly on t, such that I is contained in the vanishing ideal of t if and only if t is contained in the zero locus of I.


theorem Multiset.cons_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α} {a : α}, a ∈ s → a ::ₘ Multiset.erase s a = s := by sorry

The theorem `Multiset.cons_erase` states that for any type `α` that has decidable equality (`DecidableEq α`), any multiset `s` of elements of type `α`, and any element `a` of type `α`; if `a` belongs to `s`, then adding `a` to the multiset obtained from `s` by erasing one occurrence of `a` (`a ::ₘ Multiset.erase s a`) gives back the original multiset `s`. In other words, if an element is in a multiset, then removing it and adding it back results in the original multiset.

For any type `α` with decidable equality and any multiset `s` of elements `α` with `a` being an element of `s`, `Multiset.erase (a :: s) a = s`.


theorem two_smul :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
      2 • x = x + x :=
  by sorry

This theorem, `two_smul`, states that for any type `R`, and any commutative additive monoid `M` that is also a module over `R`, the scalar multiplication of `2` and any element `x` of `M` is equal to the sum of `x` with itself. This is a general principle of scalar multiplication in algebraic structures, where scaling by `2` is the same as adding the element to itself. Here, `Semiring R` implies that `R` is a semiring and `Module R M` implies that `M` is a module over `R`.

For any commutative additive monoid `M` that is a module over a semiring `R`, the scalar multiplication of `2` and any element `x` in `M` equals the sum `x + x`.


theorem iSup_subtype'' :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Type u_9} (s : Set ι) (f : ι → α), ⨆ i, f ↑i = ⨆ t ∈ s, f t := by
  sorry

This theorem states that for any type 'α' that forms a complete lattice and for any type 'ι', given a set 's' of type 'ι' and a function 'f' mapping elements of type 'ι' to elements of type 'α', the supremum (or least upper bound) over the entire type 'ι' for 'f' applied to an element lifted from 'ι' (notated as `f ↑i`) is the same as the supremum over the set 's' for 'f' applied to an element of 's'. In other words, the least upper bound of function values over the entire type and over a set within the type are the same, for this function 'f'.

For any complete lattice 'α' and any function 'f' from a type 'ι' to 'α', the supremum of 'f' over the entire type equals the supremum of 'f' over any subset, specifically a given set 's'.


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

The theorem `Monotone.map_inf_le` states that for any types `α` and `β` that are semilattices with an infimum operation (denoted by `⊓`), if a function `f` from `α` to `β` is monotone, meaning it preserves the order (i.e., `a ≤ b` implies `f a ≤ f b`), then for any elements `x` and `y` from `α`, the value of function `f` at the infimum of `x` and `y` is less than or equal to the infimum of the values of function `f` at `x` and `y`. In mathematical terms, it expresses that $f(x \wedge y) \leq f(x) \wedge f(y)$ for a monotone function $f$ in a semilattice.

For any monotone function $f$ and semilattice elements $x, y$ with infimum, $f(x \wedge y) \leq f(x) \wedge f(y)$.


theorem and_congr_left : ∀ {c a b : Prop}, (c → (a ↔ b)) → (a ∧ c ↔ b ∧ c) := by sorry

This theorem, `and_congr_left`, states that for any three propositions `a`, `b`, and `c`, if it holds that `c` implies the equivalence of `a` and `b`, then it follows that the conjunction of `a` and `c` is equivalent to the conjunction of `b` and `c`. In mathematical terms, for all propositions `a`, `b`, `c`, if (`c` implies `a` is equivalent to `b`), then (`a` and `c` is equivalent to `b` and `c`).

If `c` implies `a ≤f/= b`, then `a and c ≤f/= b and c`.


DifferentiableOn.continuousOn

theorem DifferentiableOn.continuousOn :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {s : Set E}, DifferentiableOn 𝕜 f s → ContinuousOn f s :=
  by sorry

The theorem `DifferentiableOn.continuousOn` states that, given a nontrivially normed field `𝕜`, a normed addition commutative group `E` and `F` (which are also normed spaces over `𝕜`), a function `f` from `E` to `F`, and a set `s` of elements of `E`, if the function `f` is differentiable at any point within the set `s`, then `f` is also continuous at every point within `s`. In other words, differentiability of a function on a set implies its continuity on the same set.

If a function between two normed spaces is differentiable at any point in a set, then it is continuous at every point in that set.


theorem Mathlib.Data.Part._auxLemma.6 : ∀ {α : Type u_1} {a b : α}, (b ∈ Part.some a) = (b = a) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of `α`, `b` is in the `Part.some` of `a` if and only if `b` is equal to `a`. In other words, the `Part.some` function creates a singleton set with `a` as the only member, and `b` is in this set only when `b` equals `a`.

For any type `α` and elements `a, b` of `α`, `b` is in the singleton set `{a}`. i.e. `b = a`, if and only if `b ∈ {a}`.


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

The theorem `Finset.sum_sub_distrib` states that for any finite set `s` of elements of an arbitrary type `α` and any two functions `f` and `g` from `α` to an arbitrary type `β` which is a commutative monoid with subtraction, the sum of the differences `f x - g x` for each `x` in `s` is equal to the difference of the sums of `f x` and `g x` over all `x` in `s`. In mathematical notation, this is equivalent to saying $\sum_{x \in s} (f(x) - g(x)) = \left( \sum_{x \in s} f(x) \right) - \left( \sum_{x \in s} g(x) \right)$.

For any finite set `s` and functions `f` and `g` from a commutative monoid with subtraction, $\sum\_{x \in s} (f(x) - g(x)) = \left( \sum\_{x \in s} f(x) \right) - \left( \sum\_{x \in s} g(x) \right)$.


/-- The subsemigroup generated by a set includes the set.  -/
theorem Subsemigroup.subset_closure : ∀ {M : Type u_1} [inst : Mul M] {s : Set M}, s ⊆ ↑(Subsemigroup.closure s) := by
  sorry

This theorem states that for any type `M` equipped with a multiplication operation (making it a semigroup), and any subset `s` of `M`, the subsemigroup generated by `s` always includes `s`. In other words, every element of the set `s` also belongs to the subsemigroup generated by `s`. This is expressed formally by saying that `s` is a subset of the closure of `s` under the semigroup operation, denoted `Subsemigroup.closure s`.

For any semigroup (M, \*), and subset s of M, s is a subset of the subsemigroup generated by s (denoted Subsemigroup.closure s).


theorem MeasureTheory.integral_zero_measure :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      (f : α → G), ∫ (x : α), f x ∂0 = 0 :=
  by sorry

This theorem states that for any type `α` and normed additive commutative group `G`, if we have a function `f` mapping from `α` to `G` and `m` as a measurable space of `α`, then the integral of the function `f` with respect to the zero measure is always zero. Here the integral is defined over a measure theory space.

For any type `α`, normed additive commutative group `G`, measurable space `m` over `α`, and function `f` from `α` to `G`, the integral of `f` over `m` is zero if the measure of `m` is zero.


theorem Finset.mem_inter :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finset α}, a ∈ s₁ ∩ s₂ ↔ a ∈ s₁ ∧ a ∈ s₂ := by sorry

The theorem `Finset.mem_inter` states that for any type `α` with decidable equality, and for any element `a` of type `α` and any two finite sets `s₁` and `s₂` of type `α`, the element `a` is a member of the intersection of `s₁` and `s₂` if and only if `a` is a member of both `s₁` and `s₂`. This theorem formalizes the standard definition of set intersection in the context of finite sets.

For any type `α` with decidable equality, and for any finite sets `s₁` and `s₂` of type `α`, `a ∈ s₁ ∧ a ∈ s₂` if and only if `a ∈ s₁ ∩ s₂`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.2 : ∀ {α : Type u_2} [inst : Zero α] {a : α}, (a ∈ 0) = (a = 0) := by
  sorry

This theorem, `Mathlib.Data.Finset.Pointwise._auxLemma.2`, states that for any type `α` equipped with a zero element, any element `a` of type `α` is in the zero set if and only if `a` is equal to zero. The zero set in this context is the set that contains only the zero element.

For any type `α` with a zero element, an element `a` lies in the zero set if and only if `a` equals the zero element.


theorem AlgHom.map_pow :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (x : A) (n : ℕ), φ (x ^ n) = φ x ^ n :=
  by sorry

This theorem states that for any commutative semiring `R`, semirings `A` and `B`, with `A` and `B` as algebras over `R`, and any algebra homomorphism `φ` from `A` to `B`, the image of the power of an element `x` from `A` under `φ`, is equal to the power of the image of `x` under `φ`. In other words, raising to the power `n` commutes with the algebra homomorphism `φ`. This is expressed as `φ (x ^ n) = φ x ^ n`.

Given commutative semirings `R`, semirings `A` and `B`, with `A` and `B` as `R`-algebras and a homomorphism `φ` from `A` to `B`, the image of `φ` of `x^n` is equal to `(φ(x))^n` for any `x in A` and natural number `n`.


theorem TopologicalSpace.PositiveCompacts.isCompact :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.PositiveCompacts α), IsCompact ↑s := by sorry

This theorem states that for any topological space `α` and any `s` belonging to the set of positive compacts of `α`, `s` is compact. In mathematical terms, this means for every nontrivial filter `f` that contains `s`, there is an element `a` in `s` such that every set in `f` intersects every neighborhood of `a`.

Every positive compact subset of a topological space is compact.


theorem Set.finite_le_nat : ∀ (n : ℕ), Set.Finite {i | i ≤ n} := by sorry

This theorem states that for any natural number `n`, the set of all natural numbers `i` that are less than or equal to `n` is finite. This is essentially saying that any natural number range starting from 0 and ending in `n` (inclusive) is a finite set. The concept of finiteness here is defined in terms of an equivalence to the set `Fin n`, which is the set of all natural numbers less than `n`.

For any natural number `n`, the set {i | i <= n} is finite.


theorem Polynomial.leadingCoeff_mul :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] (p q : Polynomial R),
      Polynomial.leadingCoeff (p * q) = Polynomial.leadingCoeff p * Polynomial.leadingCoeff q :=
  by sorry

The theorem `Polynomial.leadingCoeff_mul` states that for any given semiring `R` with no zero divisors, and any two polynomials `p` and `q` over `R`, the leading coefficient (the coefficient of the highest power of `X`) of the product of `p` and `q` is equal to the product of the leading coefficients of `p` and `q`. In other words, if we multiply two polynomials, the leading coefficient of the resulting polynomial is the multiplication of the leading coefficients of the original polynomials. This can be expressed mathematically as `leadCoeff(p * q) = leadCoeff(p) * leadCoeff(q)`.

For polynomials $p$ and $q$ over a semiring $R$ without zero divisors, the leading coefficient of their product $pq$ is equal to the product of their leading coefficients. In Lean notation: `leadCoeff (p * q) = leadCoeff p * leadCoeff q`.


theorem Nat.le_sub_one_of_lt : ∀ {a b : ℕ}, a < b → a ≤ b - 1 := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then `a` is less than or equal to `b` subtracted by one. This relates to the principle that when one is subtracted from a larger natural number, the remaining number is at least as large as any natural number smaller than the original larger number.

For all natural numbers `a` and `b`, if `a` < `b`, then `a` <= `b` - 1.


theorem Submodule.dualAnnihilator_gc :
    ∀ (R : Type u) (M : Type v) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      GaloisConnection (⇑OrderDual.toDual ∘ Submodule.dualAnnihilator)
        (Submodule.dualCoannihilator ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `Submodule.dualAnnihilator_gc` establishes a Galois connection between the dual annihilator of a submodule and the coannihilator of a submodule of the dual space in the context of a commutative semiring and an additive commutative monoid. More specifically, for any ring `R` and module `M` equipped with a commutative semiring structure and an additive commutative monoid structure, respectively, the dual function of the dual annihilator of a submodule and the coannihilator of a submodule of the dual space form a Galois connection. This means that for all submodules `a` and `b`, `a` is less than or equal to the coannihilator of the dual of `b` if and only if the dual of the dual annihilator of `a` is less than or equal to `b`.

The dual annihilator and coannihilator of submodules in the context of a commutative semiring and an additive commutative monoid form a Galois connection.


theorem eq_rec_constant : ∀ {α : Sort u_1} {a a' : α} {β : Sort u_2} (y : β) (h : a = a'), h ▸ y = y := by sorry

This theorem, named `eq_rec_constant`, states that for any types `α` and `β`, any elements `a` and `a'` of type `α`, and any element `y` of type `β`, if `a` equals `a'` (denoted as `a = a'`), then substituting `a'` for `a` in `y` (denoted as `h ▸ y`) results in `y` itself. In other words, the operation of substituting an equal object into another object doesn't change the latter object. This theorem holds in a general context, with `α` and `β` being of any sort.

For all types `α` and `β`, and elements `a : α`, `a' : α`, and `y : β`, if `a = a'`, then `h ▸ y` equals `y`.


theorem neg_mul_eq_mul_neg : ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = a * -b := by
  sorry

This theorem states that for any type `α` that supports multiplication and negation operations, negating the product of two elements `a` and `b` (i.e., `-(a * b)`) is equivalent to multiplying `a` by the negation of `b` (i.e., `a * -b`). This is a common property in mathematics, especially in the field of ring theory.

For any type `α` with multiplicative and negation operations, `-(a * b) = a * -b` for all `a, b : α`.


theorem Nat.find_min : ∀ {p : ℕ → Prop} [inst : DecidablePred p] (H : ∃ n, p n) {m : ℕ}, m < Nat.find H → ¬p m := by
  sorry

The theorem `Nat.find_min` states that for any decidable predicate `p` on natural numbers, if there exists a natural number satisfying `p`, and `m` is any natural number that is strictly less than the smallest natural number satisfying `p` (as provided by the function `Nat.find`), then `m` does not satisfy `p`. In other words, `Nat.find` gives the smallest natural number satisfying the given predicate, and no natural number less than this satisfies the predicate.

For any decidable predicate `p` on natural numbers, if there exists an `n` such that `p(n)` holds, then for all `m` with `0 < m < n`, it is false that `p(m)` holds.


theorem Polynomial.leadingCoeff_C :
    ∀ {R : Type u} [inst : Semiring R] (a : R), Polynomial.leadingCoeff (Polynomial.C a) = a := by sorry

The theorem `Polynomial.leadingCoeff_C` states that for any type `R` equipped with a semiring structure and any element `a` of `R`, the leading coefficient of the constant polynomial `a` is `a` itself. In other words, if we create a polynomial that is a constant `a`, the coefficient of the highest-powered `X` term in this polynomial is `a`. This is true regardless of what `R` or `a` are, so long as `R` is a semiring.

For any semiring `R` and constant polynomial `a` in `R[X]`, the leading coefficient of `a` is equal to `a`.


theorem lt_add_of_pos_of_le :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      0 < a → b ≤ c → b < a + c :=
  by sorry

This theorem, `lt_add_of_pos_of_le`, states that for any type `α` that is equipped with an addition operation, a zero element, and a preorder relation that respects the order of addition, if `a`, `b` and `c` are elements of this type such that `0 < a` and `b ≤ c`, then it must be the case that `b < a + c`. In other words, if `a` is positive and `b` is less than or equal to `c`, then `b` is strictly less than the sum of `a` and `c`.

If `α` is a type with addition, zero, and a preorder relation such that `0 < a` and `b ≤ c` imply `b < a + c`, then this preorder relation is transitive on `α`. (This is an alternative way to state the theorem, emphasizing the transitivity property that results from it.)


/-- The `takeUntil` and `dropUntil` functions split a walk into two pieces.
The lemma `SimpleGraph.Walk.count_support_takeUntil_eq_one` specifies where this split occurs.  -/
theorem SimpleGraph.Walk.take_spec :
    ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : SimpleGraph.Walk G v w)
      (h : u ∈ SimpleGraph.Walk.support p),
      SimpleGraph.Walk.append (SimpleGraph.Walk.takeUntil p u h) (SimpleGraph.Walk.dropUntil p u h) = p :=
  by sorry

The `SimpleGraph.Walk.take_spec` theorem states that for any type `V`, any simple graph `G` on `V`, any vertices `u`, `v`, `w` of `V`, and any walk `p` from `v` to `w` in `G`, if `u` is a vertex in the support of the walk `p`, then appending the walk from the start of `p` until `u` (`SimpleGraph.Walk.takeUntil p u h`) to the walk from `u` until the end of `p` (`SimpleGraph.Walk.dropUntil p u h`) yields the original walk `p`. This theorem essentially asserts that `takeUntil` and `dropUntil` functions partition the walk into two segments at the vertex `u` in such a way that concatenating these segments reconstructs the original walk.

For any simple graph `G`, vertices `u`, `v`, `w`, and walk `p` from `v` to `w` in `G`, if `u` is on `p`, then `p` is the concatenation of the sub-walk from `v` to `u` and the sub-walk from `u` to `w`.


theorem RingEquiv.symm_apply_apply :
    ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S)
      (x : R), (RingEquiv.symm e) (e x) = x :=
  by sorry

The theorem `RingEquiv.symm_apply_apply` states that for all rings `R` and `S`, if we have a ring isomorphism `e` from `R` to `S`, then applying the isomorphism and its inverse in succession to any element `x` in `R` will recover the original element. In other words, the inverse of the isomorphism undoes the effect of the isomorphism, which is a fundamental property expected of any isomorphism. In mathematical terms, for any element `x` in `R`, `(RingEquiv.symm e) (e x) = x`.

For any ring isomorphism `e` from `R` to `S`, `(RingEquiv.symm e) (e x) = x` for all `x` in `R`.


theorem Cardinal.IsRegular.cof_eq : ∀ {c : Cardinal.{u_2}}, Cardinal.IsRegular c → Ordinal.cof (Cardinal.ord c) = c :=
  by sorry

This theorem states that for any regular cardinal 'c', the cofinality of the ordinal corresponding to 'c' is equal to 'c' itself. In the context of set theory, a regular cardinal is an infinite cardinal number that cannot be represented as a smaller set of smaller cardinals, i.e., it equals its own cofinality. The cofinality of an ordinal is the smallest cardinal of a subset of the ordinal which is unbounded. The ordinal corresponding to a cardinal 'c' is essentially the least ordinal whose cardinal is 'c'. This theorem formally establishes the property of regular cardinals in Lean 4.

For any regular cardinal 'c', the ordinal of cardinality 'c' has cofinality 'c'.


theorem Quot.induction_on₂ :
    ∀ {α : Sort u_1} {β : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} {δ : Quot r → Quot s → Prop} (q₁ : Quot r)
      (q₂ : Quot s), (∀ (a : α) (b : β), δ (Quot.mk r a) (Quot.mk s b)) → δ q₁ q₂ :=
  by sorry

The theorem `Quot.induction_on₂` in Lean 4 is a principle of induction for double quotients. It states that for any sort `α` and `β`, and any two relations `r` on `α` and `s` on `β`, together with a property `δ` on the quotients `Quot r` and `Quot s`, if the property is proven for the representatives `Quot.mk r a` and `Quot.mk s b` for any `a` in `α` and `b` in `β`, then that property holds for any elements `q₁` in `Quot r` and `q₂` in `Quot s`.

Given relations `r` on sort `α` and `s` on sort `β`, if property `δ` holds for all quotients `[a]≃\_r A` and `[b]≃\_s B`, then `δ` holds for all quotients `[a]` and `[b]` in `Quot r` and `Quot s`, respectively.


/-- We can transport limits of shape `J` along an equivalence `J ≌ J'`.
 -/
theorem CategoryTheory.Limits.hasLimitsOfShape_of_equivalence :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {J' : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} J'],
      (J ≌ J') → ∀ [inst : CategoryTheory.Limits.HasLimitsOfShape J C], CategoryTheory.Limits.HasLimitsOfShape J' C :=
  by sorry

The theorem `CategoryTheory.Limits.hasLimitsOfShape_of_equivalence` states in category theory that for any two categories `J` and `J'` that are equivalent, denoted as `J ≌ J'`, if `C` is a category that has limits of shape `J`, then `C` also has limits of shape `J'`. This essentially means that limits of a certain shape in a category can be 'transported' along an equivalence between categories.

If categories `J` and `J'` are equivalent, then a category `C` with limits of shape `J` has limits of shape `J'`.


theorem Associates.factors_prod :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] (a : Associates α),
      Associates.FactorSet.prod (Associates.factors a) = a :=
  by sorry

The theorem `Associates.factors_prod` states that for any type `α` that is a `CancelCommMonoidWithZero` and `UniqueFactorizationMonoid`, and for any element `a` of the associated type `Associates α`, the product of the `FactorSet` of `a` (which is a multiset of its irreducible factors) is equal to `a` itself. In other words, it says that every element of `Associates α` can be represented as a product of its irreducible factors, which aligns with the fundamental theorem of arithmetic.

For any `CancelCommMonoidWithZero` and `UniqueFactorizationMonoid` type `α` and its associated `a`, the product of `a`'s irreducible factors in its `FactorSet` equals `a`.


theorem IsScalarTower.of_algebraMap_eq :
    ∀ {R : Type u} {S : Type v} {A : Type w} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
      [inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A],
      (∀ (x : R), (algebraMap R A) x = (algebraMap S A) ((algebraMap R S) x)) → IsScalarTower R S A :=
  by sorry

This theorem is named `IsScalarTower.of_algebraMap_eq`. It states that for any types `R`, `S`, and `A`, where `R`, `S`, and `A` have the structure of commutative semirings, `R` and `S` have an algebra structure over `A`, and `R` has an algebra structure over `S`, then if for every element `x` in `R`, the map from `R` to `A` applied to `x` equals the map from `S` to `A` applied to the map from `R` to `S` applied to `x`, then `R`, `S`, and `A` form a scalar tower. A scalar tower is a mathematical structure in which the multiplication in `R`, `S`, and `A` is compatible in a certain way.

If for all `x` in `R`, the map from `R` to `A` applied to `x` equals the map from `S` to `A` applied to the algebra map from `R` to `S` applied to `x`, then `R`, `S`, and `A` form a scalar tower over `A`.


theorem forall₃_congr :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {p q : (a : α) → (b : β a) → γ a b → Prop},
      (∀ (a : α) (b : β a) (c : γ a b), p a b c ↔ q a b c) →
        ((∀ (a : α) (b : β a) (c : γ a b), p a b c) ↔ ∀ (a : α) (b : β a) (c : γ a b), q a b c) :=
  by sorry

This theorem, named `forall₃_congr`, states that for any types `α`, `β` (which is dependent on `α`), and `γ` (which is dependent on both `α` and `β`), if you have two predicates `p` and `q` which take three arguments (an element of `α`, an element of `β`, and an element of `γ`), then the following is true: if for all such elements, `p` holds if and only if `q` holds, then the proposition stating that `p` holds for all such elements is equivalent to the proposition that `q` holds for all such elements. In other words, if `p` and `q` are equivalent for all elements, then the universality of `p` is equivalent to the universality of `q`.

If for all `α`, `β`, and elements `x : α`, `y : β`, `p(x, y) ≡ q(x, y)` implies `∀ x, ∀ y, p(x, y) ↔ q(x, y)`.


MeasureTheory.AECover.mono

theorem MeasureTheory.AECover.mono :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      {ν : MeasureTheory.Measure α} {φ : ι → Set α},
      MeasureTheory.AECover μ l φ → ν ≤ μ → MeasureTheory.AECover ν l φ :=
  by sorry

The theorem `MeasureTheory.AECover.mono` states that for any types `α` and `ι`, where `α` is equipped with a `MeasurableSpace` structure, and any measures `μ` and `ν` on `α`, a filter `l` on `ι`, and a function `φ` from `ι` to the set of `α`, if `φ` forms almost everywhere (a.e.) covers for the measure `μ` with respect to filter `l`, and `ν` is less than or equal to `μ` (i.e., `ν` is absolutely continuous with respect to `μ`), then `φ` also forms a.e. covers for the measure `ν` with respect to the same filter `l`. This theorem provides a monotonicity property for measures with respect to almost everywhere covers.

If `φ` is an almost everywhere `μ`-covering function for a filter `l` on `ι` with respect to a measure `μ` on `α`, and `ν` is absolutely continuous with respect to `μ`, then `φ` is also an almost everywhere `ν`-covering function for filter `l` on `ι`.


theorem mem_sphere_zero_iff_norm :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, a ∈ Metric.sphere 0 r ↔ ‖a‖ = r := by sorry

The theorem `mem_sphere_zero_iff_norm` states that for any seminormed add group `E` and any elements `a` of `E` and real number `r`, `a` is in the sphere centered at zero with radius `r` in the metric space if and only if the norm of `a` is equal to `r`. In other words, an element belongs to this particular sphere if its norm equals the radius of the sphere.

An element `a` in a seminormed add group `E` belongs to the sphere centered at zero with radius `r` if and only if the norm of `a` is equal to `r`.


theorem LinearMap.ext₂ :
    ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
      {S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst_4 : AddCommMonoid M]
      [inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module S N]
      [inst_9 : Module R₂ P] [inst_10 : Module S₂ P] [inst_11 : SMulCommClass S₂ R₂ P] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
      {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P}, (∀ (m : M) (n : N), (f m) n = (g m) n) → f = g :=
  by sorry

This theorem, called `LinearMap.ext₂`, states that given two semirings `R` and `S`, another two semirings `R₂` and `S₂`, and three additive commutative monoids `M`, `N`, and `P` with `M` being a module over `R`, `N` being a module over `S`, and `P` being a module over both `R₂` and `S₂`, along with the condition that scalar multiplication in `P` commutes with multiplication in `S₂` and `R₂`, if we have two linear maps `f` and `g` from `M` to `N` to `P` (i.e., each of `f` and `g` takes an element of `M` to a linear map from `N` to `P`), and if for all elements `m` in `M` and `n` in `N` the result of applying `f` and then `n` to `m` is equal to the result of applying `g` and then `n` to `m`, then `f` and `g` are equal.

Given semirings R, S, R₂, S₂, additive commutative monoids M (an R-module), N (an S-module), and P (an (R₂, S₂)-module) with commuting scalar multiplications, if linear maps f and g from M to N to P satisfy f(m)(n) = g(m)(n) for all m in M and n in N, then f = g.