theorem Mathlib.Data.Int.Basic._auxLemma.1 : ∀ {α : Type u_1} [inst : NonAssocRing α] (m n : ℤ), ↑m * ↑n = ↑(m * n) :=
  by sorry

This theorem, named `Mathlib.Data.Int.Basic._auxLemma.1`, states that for any type `α` that forms a non-associative ring and for any integers `m` and `n`, the product of the coercions of `m` and `n` to `α` is equal to the coercion of the product of `m` and `n` to `α`. In mathematical terms, it says that if one has a ring structure on a set and two integers, then the procedure of first converting the integers to elements of the ring and then multiplying equals the procedure of first multiplying the integers and then converting the result to an element of the ring.

For any non-associative ring type `α` and integers `m` and `n`, the coercion of `m` multiplied by `n` to `α` is equal to the coercion of `m * n` to `α`.


theorem Finset.sum_Ico_eq_sub :
    ∀ {δ : Type u_3} [inst : AddCommGroup δ] (f : ℕ → δ) {m n : ℕ},
      m ≤ n →
        (Finset.sum (Finset.Ico m n) fun k => f k) =
          (Finset.sum (Finset.range n) fun k => f k) - Finset.sum (Finset.range m) fun k => f k :=
  by sorry

This theorem, `Finset.sum_Ico_eq_sub`, states that for any function `f` from natural numbers to an element of a type `δ` with an additive commutative group structure, and for any natural numbers `m` and `n` such that `m` is less than or equal to `n`, the sum of the function `f` evaluated at each element in the finite integer interval from `m` to `n` (exclusive of `n`) is equal to the difference between the sum of `f` evaluated at each natural number less than `n` and the sum of `f` evaluated at each natural number less than `m`. Essentially, it's relating the sum over an interval to differences of sums over ranges of natural numbers.

For any additive commutative group δ and function f from natural numbers to δ, the sum of f over the finite interval [m, n) equals the difference between the sums of f over the intervals [0, m-1] and [0, n-1).


theorem isLUB_ciSup :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [inst_1 : Nonempty ι] {f : ι → α},
      BddAbove (Set.range f) → IsLUB (Set.range f) (⨆ i, f i) :=
  by sorry

The theorem `isLUB_ciSup` states that for any type `α` which is a conditionally complete lattice, and for any non-empty type `ι`, given a function `f` from `ι` to `α`, if the range of the function `f` is bounded above, then the least upper bound (supremum) of the set that is the range of `f` is equal to the supremum over all `i` of `f(i)`. In other words, if a set of values derived from a function is bounded above, then the least upper bound of this set is equivalent to the supremum of the function's output values.

For any conditionally complete lattice α and non-empty ι, if function f from ι to α has a bounded above range, then the supremum of f is equal to the supremum of its values.


theorem EMetric.nhds_basis_eball :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α}, Filter.HasBasis (nhds x) (fun ε => 0 < ε) (EMetric.ball x) :=
  by sorry

This theorem states that for every point `x` in a given pseudo e-metric space `α`, the neighborhood filter at `x` has a basis where each basis element is the e-metric ball around `x` with radius `ε` for all `ε` greater than 0. In other words, every neighborhood of `x` can be produced by taking unions of these e-metric balls of positive radius centered at `x`.

For every point `x` in a pseudo-metric space `α`, the neighborhood filter at `x` is generated by the e-metric balls with positive radius centered at `x`.


theorem Finsupp.zero_apply : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α}, 0 a = 0 := by sorry

This theorem states that for all type `α` and another type `M` that has a zero element (as indicated by the `Zero M` typeclass), and for any element `a` of type `α`, applying the function `0` to `a` yields the zero of type `M`. This is a property of the `Finsupp` or "finite support" function, which is defined such that it is zero for all but a finite number of elements.

For any type `α` and type `M` with a zero element, and for any element `a` of type `α`, the application of the function `0` to `a` equals the zero element of type `M` in the `Finsupp` function.


theorem Finset.sum_fiberwise_of_maps_to :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : AddCommMonoid α] {s : Finset ι} {t : Finset κ}
      [inst_1 : DecidableEq κ] {g : ι → κ},
      (∀ i ∈ s, g i ∈ t) →
        ∀ (f : ι → α),
          (Finset.sum t fun j => Finset.sum (Finset.filter (fun i => g i = j) s) fun i => f i) =
            Finset.sum s fun i => f i :=
  by sorry

This theorem states that for any types `ι`, `κ`, and `α`, where `α` is an additive commutative monoid, any finite sets `s` of type `ι` and `t` of type `κ`, any function `g` from `ι` to `κ` that maps each element of `s` into `t`, and any function `f` from `ι` to `α`, the sum of the values of `f` over `s` equals the sum of the sums of the values of `f` over the elements of `s` that map to each element of `t` under `g`. In other words, it's asserting that you can rearrange the terms in the sum over `s` of `f` by grouping together the terms that correspond to elements of `s` that map to the same element of `t` under `g`, and this rearrangement does not change the sum's value.

For any additive commutative monoid α, given finite sets s:ι and t:κ, function g:ι -> κ mapping s into t, and function f:ι -> α, the sum ∑i in s. f i equals the sum ∑j in t. (∑i in g ^-1 {j}. f i).


theorem sSup_singleton : ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {a : α}, sSup {a} = a := by sorry

This theorem states that for any type `α` that forms a complete semilattice with a supremum operation, the supremum (`sSup`) of a singleton set containing only one element `a` of type `α` is equal to `a` itself. In other words, in a complete semilattice, the least upper bound of a set with just one element is the element itself.

In a complete semilattice, the supremum of a singleton set is equal to its unique element.


ContinuousOn.mul

theorem ContinuousOn.mul :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Mul M]
      [inst_3 : ContinuousMul M] {f g : X → M} {s : Set X},
      ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => f x * g x) s :=
  by sorry

The theorem `ContinuousOn.mul` states that given two topological spaces `X` and `M`, a multiplication operation on `M` which is continuous, and two functions `f` and `g` from `X` to `M` that are continuous on a subset `s` of `X`, then the function that maps each element `x` in `s` to the product of `f(x)` and `g(x)` is also continuous on `s`. This theorem is essentially stating that the multiplication of two continuous functions on a set is also continuous on that set.

If two continuous functions map a subset of a topological space to a multiplicatively-associative topological group, then their product is also a continuous function on that subset.


List.Chain.imp

theorem List.Chain.imp :
    ∀ {α : Type u_1} {R S : α → α → Prop},
      (∀ (a b : α), R a b → S a b) → ∀ {a : α} {l : List α}, List.Chain R a l → List.Chain S a l :=
  by sorry

This theorem states that for any type `α` and two properties `R` and `S` that relate elements of type `α`, if it holds for all pairs `(a, b)` of type `α` that `R a b` implies `S a b`, then for any element `a` of type `α` and any list `l` of elements of type `α`, if the list `l` is a chain with respect to the property `R` starting from `a`, then the list `l` is also a chain with respect to the property `S` starting from `a`. In simpler terms, if `R` implies `S` for all pairs, then a chain of `R` relationships in a list also forms a chain of `S` relationships in that list.

If `R` implies `S` between all pairs of elements in a type `α`, then any chain of `R` relationships in a list of `α` is also a chain of `S` relationships.


theorem Int.cast_commute : ∀ {α : Type u_3} [inst : NonAssocRing α] (n : ℤ) (a : α), Commute (↑n) a := by sorry

This theorem, `Int.cast_commute`, states that for any type `α` that has a `NonAssocRing` structure, an integer `n`, and an element `a` of type `α`, the result of integer `n` cast to type `α` commutes with element `a`. In other words, for any integer `n` and element `a` of a non-associative ring, the product of `n` and `a` is equal to the product of `a` and `n`. This is expressed in mathematical notation as `n * a = a * n`.

For any non-associative ring type `α` and integer `n`, the operation of multiplying `n` with an element `a` in `α` is commutative, i.e., `n * a = a * n`.


theorem himp_self : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a : α}, a ⇨ a = ⊤ := by sorry

This theorem states that for all types 'α' in a generalized Heyting algebra, the implication of any element 'a' by itself is equal to the top element. In other words, in any such algebra, asserting that 'a' implies 'a' is always a tautology.

In a generalized Heyting algebra, for all types 'α' and elements 'a' in 'α', a implies a is equal to the top element.


theorem pow_le_pow_left' :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : M},
      a ≤ b → ∀ (i : ℕ), a ^ i ≤ b ^ i :=
  by sorry

This theorem, `pow_le_pow_left'`, states that for any type `M` equipped with a monoid structure, a preorder, and two covariant classes defined over the multiplication operation and a less-than-or-equal-to relation, if `a` and `b` are two elements of `M` such that `a` is less than or equal to `b`, then for any natural number `i`, `a` to the power of `i` is less than or equal to `b` to the power of `i`. In mathematical terms, this can be written as: for all `a, b ∈ M` and `i ∈ ℕ` such that `a ≤ b`, `a^i ≤ b^i`.

For all types `M` with a monoid structure, preorder, and covariant multiplication and order classes, if `a ≤ b` in `M` then `a^n ≤ b^n` for all natural numbers `n`.


theorem Set.Ioo_subset_Iio_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b ⊆ Set.Iio b := by sorry

The theorem `Set.Ioo_subset_Iio_self` states that for all types `α` with a preorder, and for all `a` and `b` of type `α`, the set of all elements `x` such that `a` is less than `x` and `x` is less than `b` (denoted as `Set.Ioo a b`) is a subset of the set of all elements `x` such that `x` is less than `b` (denoted as `Set.Iio b`). In mathematical terms, we can say that the open interval $(a, b)$ is a subset of the half-open interval $(-\infty, b)$.

For all types `α` with a preorder and all `a` and `b` in `α`, the open interval `Ioo a b` is contained in the half-open interval `Iio b`.


theorem map_eq_pure_bind :
    ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Monad m] [inst_1 : LawfulMonad m] (f : α → β) (x : m α),
      f <$> x = do
        let a ← x
        pure (f a) :=
  by sorry

This theorem, `map_eq_pure_bind`, states that for any monad `m` and for any two types `α` and `β`, given a function `f` from `α` to `β` and a monadic value `x` of type `m α`, the operation of mapping the function `f` over `x` (denoted as `f <$> x`) is equivalent to binding `x` to `a` and then applying `f` to `a` within the context of the monad (written as `let a ← x, pure (f a)`). This assertion holds under the condition that `m` obeys the laws of a lawful monad.

For any lawful monad `m` and functions `f : α → β` and `x : m α`, `f <$> x` is equivalent to `let a ← x in pure (f a)` in the context of `m`.


theorem Set.encard_union_eq :
    ∀ {α : Type u_1} {s t : Set α}, Disjoint s t → Set.encard (s ∪ t) = Set.encard s + Set.encard t := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of this type that are disjoint (i.e., their intersection is empty), the cardinality of the union of `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. Here, the cardinality of a set is represented as a term in `ℕ∞`, which stands for the extended nonnegative integers (including infinity). The disjointness is defined in a general sense for elements of a lattice, but in this context, it refers to the usual notion of disjoint sets.

For any type `α` and disjoint sets `s` and `t` of this type, the cardinality of `s ∪ t` equals the sum of the cardinalities of `s` and `t`.


theorem Mathlib.Data.Finset.NAry._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {c : γ}, (c ∈ Finset.image₂ f s t) = ∃ a ∈ s, ∃ b ∈ t, f a b = c :=
  by sorry

This theorem states that for all sets `s` of type `α`, `t` of type `β`, and a function `f` mapping elements from `α` and `β` to `γ`, where `γ` has decidable equality, an element `c` of type `γ` belongs to the image of `f` applied to the cartesian product of `s` and `t` if and only if there exist elements `a` in `s` and `b` in `t` such that `f` applied to `a` and `b` equals `c`. In other words, this theorem is about the membership of an element in the image of a binary function applied to two sets.

For sets `s` of type `α`, `t` of type `β`, and a total function `f` from `α × β` to `γ`, an element `c` of type `γ` is in the image of `f` applied to the cartesian product of `s` and `t` if and only if there exist `a` in `s` and `b` in `t` such that `f`(`a`, `b`) = `c`.


theorem LinearIsometry.norm_toContinuousLinearMap :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : NormedAddCommGroup E]
      [inst_1 : NormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : Nontrivial E]
      [inst_7 : RingHomIsometric σ₁₂] (f : E →ₛₗᵢ[σ₁₂] F), ‖LinearIsometry.toContinuousLinearMap f‖ = 1 :=
  by sorry

The theorem `LinearIsometry.norm_toContinuousLinearMap` states that for any given linear isometry `f` from a normed space `E` over a non-trivially normed field `𝕜` to another normed space `F` over a non-trivially normed field `𝕜₂`, with a isometric ring homomorphism `σ₁₂` between `𝕜` and `𝕜₂`, the norm of the continuous linear map corresponding to `f`, obtained using the function `LinearIsometry.toContinuousLinearMap`, is equal to 1. This underlines the fact that the linear isometry preserves the norm when it is interpreted or converted into a continuous linear map.

For any linear isometry between two normed spaces over non-trivially normed fields with a given isometric ring homomorphism, the norm of the resulting continuous linear map is equal to 1.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.6 :
    ∀ {V : Type u} {G : SimpleGraph V} {G' : SimpleGraph.Subgraph G} {v w : V},
      (s(v, w) ∈ SimpleGraph.Subgraph.edgeSet G') = G'.Adj v w :=
  by sorry

This theorem states that for any simple graph `G` with vertices of some type `V`, and any subgraph `G'` of `G`, and any pair of vertices `v` and `w` from `V`, the pair `(v, w)` is in the edge set of the subgraph `G'` if and only if vertices `v` and `w` are adjacent in the subgraph `G'`. In other words, it forms a connection between the edge set of a subgraph and the adjacency relationship in that subgraph.

For any simple graph G and its subgraph G', vertices v and w are in the edge set of G' if and only if they are adjacent in G'.


theorem Matrix.submatrix_mul_equiv :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Fintype n] [inst_1 : Fintype o]
      [inst_2 : AddCommMonoid α] [inst_3 : Mul α] {p : Type u_10} {q : Type u_11} (M : Matrix m n α) (N : Matrix n p α)
      (e₁ : l → m) (e₂ : o ≃ n) (e₃ : q → p),
      Matrix.submatrix M e₁ ⇑e₂ * Matrix.submatrix N (⇑e₂) e₃ = Matrix.submatrix (M * N) e₁ e₃ :=
  by sorry

The theorem `Matrix.submatrix_mul_equiv` states that for any given types `l`, `m`, `n`, `o`, `α`, `p`, `q`; a finitely indexed set `n` and `o`; an additive commutative monoid `α` that's also a multiplicative structure; matrices `M` and `N` with entries in `α` where `M` is of type `Matrix m n α` and `N` is of type `Matrix n p α`; mappings `e₁` from `l` to `m`, an equivalence `e₂` from `o` to `n`, and a mapping `e₃` from `q` to `p`; the multiplication of the submatrices obtained by applying the mappings `e₁`, `e₂` to `M` and `e₂`, `e₃` to `N` respectively, is equal to the submatrix obtained from the multiplication of `M` and `N` by applying the mappings `e₁` and `e₃`. This means that the process of multiplication is preserved under the action of these mappings on the matrices and their indices.

For matrices $M$ and $N$ over a commutative monoid $\alpha$, and mappings $e\_1$, $e\_2$, and $e\_3$, the submatrices obtained by applying $e\_1$, $e\_2$ to $M$ and $e\_2$, $e\_3$ to $N$ respectively, are equal to the submatrices obtained by applying $e\_1$ and $e\_3$ to the product of $M$ and $N$.


theorem MeasurableEmbedding.map_apply :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f →
        ∀ (μ : MeasureTheory.Measure α) (s : Set β), ↑↑(MeasureTheory.Measure.map f μ) s = ↑↑μ (f ⁻¹' s) :=
  by sorry

This theorem, `MeasurableEmbedding.map_apply`, states that for any two types `α` and `β`, any measurable spaces `m0` and `m1` over these types, a function `f` from `α` to `β`, and a `MeasurableEmbedding` of `f`, then for any measure `μ` over `α` and any set `s` of type `β`, the measure of the image of `f` applied to `μ` and `s` is equal to the measure of the pre-image of `s` under `f` with respect to `μ`. In simpler terms, it says that under a measurable embedding, the measure of a set and the measure of its pre-image are equal.

For any measurable spaces `(α, m0)` and `(β, m1)`, a measurable embedding of a function `f: α → β`, and a set `s ∈ β` with measure `μ(s) < ∞`, we have `μ(f⁻¹(s)) = m1(s)`.


theorem neg_nonneg_of_nonpos : ∀ {α : Type u} [inst : OrderedAddCommGroup α] {a : α}, a ≤ 0 → 0 ≤ -a := by sorry

This theorem states that for any type `α` that is an ordered additive commutative group, if an element `a` of this type is less than or equal to zero, then the negation of `a` is greater than or equal to zero. In other words, it's saying that if a number is non-positive, then its negation is non-negative. This is a fundamental property in ordered groups related to the sign reversal of inequalities.

For any ordered additive commutative group type `α`, if `a : α` is non-positive, then `-a` is non-negative.


theorem MvPolynomial.eval_X :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {f : σ → R} (n : σ),
      (MvPolynomial.eval f) (MvPolynomial.X n) = f n :=
  by sorry

This theorem states that for any commutative semiring `R`, for any type `σ`, and for any function `f` from `σ` to `R`, if you evaluate the degree `1` monomial (indicated by `MvPolynomial.X n`) under the evaluation map `MvPolynomial.eval f`, it is equivalent to simply applying the function `f` to `n`. In other words, the evaluation of a monomial at a specific point is just the value of that point under the function `f`.

For any commutative semiring `R`, any type `σ`, and any function `f` from `σ` to `R`, the evaluation of the degree `1` monomial `MvPolynomial.X n` under `MvPolynomial.eval f` equals `f n`.


theorem Mathlib.Topology.Constructions._auxLemma.10 :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {g : X → Z},
      (Continuous fun x => (f x, g x)) = (Continuous f ∧ Continuous g) :=
  by sorry

This theorem, named `_auxLemma.10` in Mathlib's Topology Constructions, states that for any three types `X`, `Y`, and `Z` along with instances of these types being topological spaces, and given two functions `f : X → Y` and `g : X → Z`, the function that maps each element of `X` to a tuple with the result of applying `f` and `g` to that element is continuous if and only if both `f` and `g` are continuous. In mathematical terms, $\forall X, Y, Z, f : X \to Y, g : X \to Z$, the function $x \mapsto (f(x), g(x))$ is continuous iff both $f$ and $g$ are continuous.

For any types X, Y, Z of topological spaces and continuous functions f : X -> Y and g : X -> Z, the function x => (f x, g x) is a continuous function from X to Y x Z.


/-- Group homomorphisms preserve integer power.  -/
theorem map_zpow :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
      [inst_3 : MonoidHomClass F G H] (f : F) (g : G) (n : ℤ), f (g ^ n) = f g ^ n :=
  by sorry

The theorem `map_zpow` states that for any types `G`, `H`, and `F`, where `F` is a function-like type from `G` to `H`, `G` is a group, `H` is a division monoid, and `F` forms a monoid homomorphism from `G` to `H`, for any function `f` of type `F`, any element `g` of `G`, and any integer `n`, applying `f` to the integer power of `g` (`g ^ n`) is the same as the integer power of the result of applying `f` to `g` (`f g ^ n`). This theorem essentially states that group homomorphisms preserve integer power.

For any group homomorphism f : G -> H between groups G and H with values in a division monoid H, for all g in G and integer n, we have f (g^n) = (f g)^n.


theorem LinearMap.add_apply :
    ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R₁] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R₁ →+* R₂} (f g : M →ₛₗ[σ₁₂] M₂) (x : M), (f + g) x = f x + g x :=
  by sorry

The theorem `LinearMap.add_apply` states that for any two linear maps `f` and `g` from a module `M` over a semiring `R₁` to a module `M₂` over a semiring `R₂`, and any element `x` of `M`, the result of applying the sum of the two linear maps (i.e., `(f + g) x`) is the same as the sum of the results of applying each linear map separately to `x` (i.e., `f x + g x`). This is essentially saying that the sum of two linear maps behaves as expected with respect to map application.

For any linear maps `f` and `g` from module `M` over semiring `R₁` to module `M₂` over semiring `R₂`, and any `x` in `M`, `(f + g) x = f x + g x`.


theorem embedding_id : ∀ {X : Type u_1} [inst : TopologicalSpace X], Embedding id := by sorry

This theorem states that for every type `X` that is equipped with a topology (a `TopologicalSpace`), the identity function on `X` is an embedding. In the context of topology, an embedding refers to a function which is one-to-one, continuous, and its inverse function is also continuous when restricted to the image of the original function. So, this theorem is essentially saying that the identity function satisfies these properties in any topological space.

The identity function on any topological space is a continuous, injective (one-to-one) homeomorphism.


theorem MeasureTheory.average_eq :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      (μ : MeasureTheory.Measure α) (f : α → E), ⨍ (x : α), f x ∂μ = (↑↑μ Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂μ :=
  by sorry

The theorem `MeasureTheory.average_eq` states that for any type `α`, `E` with `α` being a measurable space and `E` being a normed add commutative group which is also a normed space over the real numbers, given a measure `μ` on `α` and a function `f` from `α` to `E`, the average value of `f` with respect to `μ` over the entire space `α` (i.e., the universal set `Set.univ`) is equal to the reciprocal of the real value of the total measure of the space `α` times the integral of `f` over the space with respect to `μ`. This essentially represents the concept of weighted average in measure theory.

For any measurable space `(α, Σ, μ)`, normed add commutative group `E` with `α` being its carrier set, and integrable function `f` from `α` to `E`, the average value of `f` with respect to `μ` is equal to the integral of `f` multiplied by the reciprocal of the total measure of `α`. In other words, `∫(α, μ, f) = (1 / μ(Set.univ)) * ∑₀(α, μ, f)`.


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

This theorem stipulates that for any type `α` which exhibits the properties of a linear order, if it is not true that `b` is less than or equal to `a`, then `a` is strictly less than `b`. In other words, for all `a` and `b` of type `α`, if `b` is not less than or equal to `a`, then `a` must be less than `b`. This theorem is an embodiment of the trichotomy property of ordered fields, which states that for any two elements in the field, either one is less than the other, they are equal, or the second is less than the first.

For any linear order type `α`, if `a` is not less than or equal to `b`, then `b` is strictly greater than `a`.


LocallyFinite.subset

theorem LocallyFinite.subset :
    ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] {f g : ι → Set X},
      LocallyFinite f → (∀ (i : ι), g i ⊆ f i) → LocallyFinite g :=
  by sorry

The theorem `LocallyFinite.subset` states that for any type `ι` (which is used to index the family of sets), and for any topological space `X`, if we have two families of sets `f` and `g` indexed by type `ι`, with `f` being a locally finite family, and every set in the family `g` is a subset of a corresponding set in the family `f`, then `g` is also a locally finite family. In other words, if a family of sets `f` is locally finite and another family of sets `g` is contained within `f`, then `g` is also locally finite. This is to say, for every point `x` in the topological space, there exist a neighborhood of `x` that intersects with only finitely many sets in the family `g`.

If `f` is a locally finite family of sets in a topological space `X` and every set in the family `g` is a subset of some set in `f`, then `g` is also locally finite.


theorem Function.Surjective.of_comp :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α},
      Function.Surjective (f ∘ g) → Function.Surjective f :=
  by sorry

The theorem `Function.Surjective.of_comp` states that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` to `β` and `g` from `γ` to `α`, if the composition of `f` with `g` (denoted as `f ∘ g`) is surjective, then `f` itself is also surjective. In mathematical terms, if for every element in the codomain type `β` there exists an element in the domain type `γ` such that applying the composed function `f ∘ g` to it results in the element in `β`, then for every element in `β`, there exists an element in `α` such that applying `f` to it results in that element in `β`.

If the composition of functions `f : α → β` and `g : γ → α` is surjective, then `f` is surjective.


/-- If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound given to the constructor if it is nonnegative.  -/
theorem LinearMap.mkContinuous_norm_le :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ₁₂] F) {C : ℝ},
      0 ≤ C → ∀ (h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖), ‖LinearMap.mkContinuous f C h‖ ≤ C :=
  by sorry

This theorem states that if a continuous linear map is constructed from a given linear map using the `mkContinuous` constructor with a nonnegative real number as the bound, then the norm of the resulting continuous map is bounded by that nonnegative real number. This holds for all elements of the input space, such that the norm of the linear map applied to any element is less than or equal to the product of the bound and the norm of the element. The spaces involved are normed spaces over nontrivially normed fields.

Given a continuous linear map created from a linear map using `mkContinuous` with a bound, the norm of the continuous map is bounded by the product of the bound and the element's norm, provided the linear map's norm times the element's norm is less than or equal to the bound.


theorem not_or_of_imp : ∀ {a b : Prop}, (a → b) → ¬a ∨ b := by sorry

This theorem states that for any two propositions 'a' and 'b', if 'a' implies 'b' then either 'a' is not true or 'b' is true. In other words, given a logical implication from 'a' to 'b', it follows that either 'a' is false or 'b' is true. This is a standard construct in propositional logic.

If `a` implies `b`, then `~a` or `b` is true. (In Lean's logical syntax: `(a → b) <-> (~a V b)`)


theorem CategoryTheory.Limits.Types.FilteredColimit.rel_of_quot_rel :
    ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
      (x y : (j : J) × F.obj j),
      CategoryTheory.Limits.Types.Quot.Rel F x y → CategoryTheory.Limits.Types.FilteredColimit.Rel F x y :=
  by sorry

The theorem `CategoryTheory.Limits.Types.FilteredColimit.rel_of_quot_rel` asserts that for any type `J` equipped with a category structure, and a functor `F` from `J` to the category of types, if two elements `x` and `y` of the product of `J` and `F` evaluated at `j` satisfy the relation `CategoryTheory.Limits.Types.Quot.Rel F`, then they also satisfy the `CategoryTheory.Limits.Types.FilteredColimit.Rel F` relation. This essentially means that the relationship defined by `Quot.Rel` for a functor's colimit is a subset of the more general `FilteredColimit.Rel` in the category of types.

For any functor from a category to the category of types, the relation defined by `Quot.Rel` for its colimit is a subset of the `FilteredColimit.Rel` relation.


theorem MeasureTheory.withDensity_zero :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.withDensity 0 = 0 := by sorry

This theorem states that for any type `α`, any measurable space `m0` over type `α`, and any measure `μ` of the measure theory over `α`, the measure-theoretical density of `μ` with respect to the zero function is equal to the zero measure. In simpler terms, it means that if you calculate the density of any measure with a zero function, the resulting measure will also be zero.

For any measure `μ` over measurable space `(α, m0)`, the density of `μ` with respect to the zero measure is zero.


theorem Complex.sinh_mul_I : ∀ (x : ℂ), Complex.sinh (x * Complex.I) = Complex.sin x * Complex.I := by sorry

The theorem `Complex.sinh_mul_I` states that for any complex number `x`, the complex hyperbolic sine of `x` times the imaginary unit (`Complex.I`) is equal to the complex sine of `x` times the imaginary unit (`Complex.I`). In terms of mathematical notation, this can be written as: for all complex numbers x, `sinh(x * i) = sin(x) * i`. This theorem links the complex hyperbolic sine function and the complex sine function under multiplication by the imaginary unit.

For all complex numbers x, sinh(x * I) = sin(x) * I.


theorem MeasureTheory.Measure.le_iff' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ : MeasureTheory.Measure α},
      μ₁ ≤ μ₂ ↔ ∀ (s : Set α), ↑↑μ₁ s ≤ ↑↑μ₂ s :=
  by sorry

This theorem states that for any type `α`, measurable space `m0` of `α`, and two measures `μ₁` and `μ₂` of `α`, `μ₁` is less than or equal to `μ₂` if and only if for every set `s` of `α`, the measure of `s` under `μ₁` is less than or equal to the measure of `s` under `μ₂`. This theorem connects the order relation between two measures to the order relations of their measurements on all sets, which is a fundamental property in measure theory.

For any measurable spaces `(α, m0)` and measures `μ₁` and `μ₂` on `α`, `μ₁ ≤ μ₂` if and only if `μ₁(s) ≤ μ₂(s)` for all sets `s` in `α`.


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

This theorem states that for any given type `α` under a linear order, the maximum of two elements `a` and `b` is less than a third element `c` if and only if both `a` and `b` are less than `c`. In other words, `c` is greater than both `a` and `b`, if and only if `c` is greater than their maximum.

For any type `α` under a linear order, `c` is greater than the maximum of `a` and `b` if and only if `c` is greater than both `a` and `b`.


theorem Finset.ne_of_mem_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, b ∈ Finset.erase s a → b ≠ a := by sorry

This theorem states that for any type `α` with decidable equality and for any `a` and `b` of type `α`, if `b` is in the set obtained by erasing `a` from a finset `s`, then `b` cannot be equal to `a`. In other words, if an element `b` is in the finset obtained by removing `a` from another finset `s`, then `b` must be different from `a`.

For any type `α` with decidable equality, and any finset `s` of type `α`, if `a` is an element of `s` and `b` is an element of the finset obtained by erasing `a` from `s`, then `a` and `b` are distinct.


ContinuousLinearEquiv.continuous

theorem ContinuousLinearEquiv.continuous :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂), Continuous ⇑e :=
  by sorry

This theorem states that for any continuous linear equivalence 'e' from a topological module 'M₁' over a semi-ring 'R₁' to a topological module 'M₂' over a semi-ring 'R₂', with the rings equipped with a pair of inverse ring homomorphisms, the application function of 'e' is continuous. Hence, you can map elements continuously from one module to another using this equivalence.

Given continuous linear equivalences between topological modules over semi-rings with inverse ring homomorphisms, the application function is continuous.


theorem PartENat.natCast_ne_top : ∀ (x : ℕ), ↑x ≠ ⊤ := by sorry

This theorem states that for all natural numbers `x`, the cast of `x` to a different type cannot be equal to the top element `⊤`. In other words, it is not possible for any natural number to be cast to a type and result in the value that represents "everything" or "unbounded" in that type. This reflects an important constraint on type conversions in Lean.

For all natural numbers x, the cast of x to any type cannot be the top element ⊤.


theorem Function.Injective.sum_map :
    ∀ {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'},
      Function.Injective f → Function.Injective g → Function.Injective (Sum.map f g) :=
  by sorry

The theorem `Function.Injective.sum_map` states that for any two types `α` and `α'`, and any two other types `β` and `β'`, if you have a function `f` that maps `α` to `β` and another function `g` that maps `α'` to `β'`, then, if both `f` and `g` are injective functions (meaning that for each one, identical outputs imply identical inputs), the function `Sum.map f g` that maps the sum type `α ⊕ α'` to `β ⊕ β'` is also injective. In other words, if you apply the `Sum.map f g` function to two distinct elements of the sum type `α ⊕ α'`, you will get distinct results in `β ⊕ β'`.

If `f : α → β` and `g : α' → β'` are injective functions, then the function `Sum.map f g : α ⊕ α' → β ⊕ β'` is also injective.


Function.mtr

/-- Provide the reverse of modus tollens (`mt`) as dot notation for implications.  -/
theorem Function.mtr : ∀ {a b : Prop}, (¬a → ¬b) → b → a := by sorry

This theorem, `Function.mtr`, states that for any two propositions `a` and `b`, if the negation of `a` implies the negation of `b`, then the truth of `b` implies the truth of `a`. In other words, given the implication (¬a → ¬b), and assuming `b` is true, we can deduce that `a` must also be true. This can be seen as a reverse form of modus tollens, hence the name `mtr`.

If `a` implies `b` in logic (`a → b`), then the negation of `b` implies the negation of `a` (`¬b → ¬a`).


theorem eq_div_iff_mul_eq : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, c ≠ 0 → (a = b / c ↔ a * c = b) :=
  by sorry

This theorem states that for any type `G₀` that has the structure of a group with a distinct zero element (i.e., a "GroupWithZero"), given three elements `a`, `b`, and `c` of this type, with `c` not equal to zero, then `a` is equal to the fraction `b / c` if and only if `a` multiplied by `c` is equal to `b`. This is a standard property of division and multiplication in fields.

For any group with zero `G₀` and elements `a`, `b`, and `c` in `G₀` with `c ≠ 0`, `a = b / c` if and only if `a * c = b`.


theorem hasCompactSupport_iff_eventuallyEq :
    ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : Zero β] {f : α → β},
      HasCompactSupport f ↔ f =ᶠ[Filter.coclosedCompact α] 0 :=
  by sorry

The theorem states that for any function `f` from a type `α` to `β`, where `α` is a topological space and `β` is a type with zero, `f` has compact support if and only if `f` is eventually equal to zero with respect to the filter generated by complements to closed compact sets in `α`. In other words, the support of `f` is compact if and only if `f` is zero outside a compact subset of `α`, considering the topology that `α` is endowed with.

A function `f` from a topological space `α` to a type `β` with zero has compact support if and only if it is equal to zero in the filter generated by complements of closed compact sets in `α`.


IsRelPrime.symm

theorem IsRelPrime.symm : ∀ {α : Type u_1} [inst : CommMonoid α] {x y : α}, IsRelPrime x y → IsRelPrime y x := by sorry

The theorem `IsRelPrime.symm` states that for all types `α` that are instances of the `CommMonoid` class, and for all elements `x` and `y` of `α`, the property of being relatively prime is symmetric. This means that if `x` and `y` are relatively prime (i.e., every common divisor of `x` and `y` is a unit), then `y` and `x` are also relatively prime.

If `x` and `y` are relatively prime elements of a commutative monoid `α`, then `y` and `x` are also relatively prime.


theorem Nat.digits_zero : ∀ (b : ℕ), Nat.digits b 0 = [] := by sorry

This theorem states that for any natural number `b`, the list of digits in base `b` representation of the number `0` is an empty list. In other words, when you convert the number zero into any base `b`, the result is an empty list of digits, as the number zero does not have any digits in any base.

For all natural numbers b, the base-b representation of the number 0 is the empty list.


Set.Pairwise.eq

theorem Set.Pairwise.eq :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α}, Set.Pairwise s r → a ∈ s → b ∈ s → ¬r a b → a = b := by
  sorry

This theorem states that for any type `α`, any relation `r` on `α`, any set `s` of elements of type `α`, and any two elements `a` and `b` of type `α`, if the relation `r` holds pairwise on the set `s` (meaning, for every pair of distinct elements in `s`, `r` holds), and both `a` and `b` are elements of `s`, and the relation `r` does not hold for `a` and `b`, then `a` and `b` must be equal.

If `α` is a type, `r` is a relation on `α`, `s` is a set of distinct elements of `α`, and for all `a, b ∈ s`, `a` and `b` relate under `r` implies `a = b`, then every pair of distinct elements `a, b ∈ s` that do not relate under `r` must be equal.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
      CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.rightUnitor Y).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y (𝟙_ C)).inv
          (CategoryTheory.MonoidalCategory.rightUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).hom :=
  by sorry

The given theorem, `CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor`, states that for any type `C` that forms a category and a monoidal category, for any two objects `X` and `Y` in this category, the left whiskering of the right unitor of `Y` with `X` is equal to the composition of the inverse of the associator of `X`, `Y`, and the identity object in the category, with the homomorphism of the right unitor of the tensor product of `X` and `Y`.

In other words, the theorem asserts an equality of two morphisms in a monoidal category where various structural morphisms such as unitors and associators, and operations such as tensor product and whiskering, are involved.

For any monoidal category `C`, given objects `X` and `Y` in `C`, the left whiskering of the right unitor of `Y` with `X` equals the composition of the inverse of the associator of `X`, `Y`, and the identity object, with the homomorphism of the right unitor of `X ⊗ Y`.


theorem Matrix.fromBlocks_multiply :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {p : Type u_5} {q : Type u_6} {α : Type u_12}
      [inst : Fintype l] [inst_1 : Fintype m] [inst_2 : NonUnitalNonAssocSemiring α] (A : Matrix n l α)
      (B : Matrix n m α) (C : Matrix o l α) (D : Matrix o m α) (A' : Matrix l p α) (B' : Matrix l q α)
      (C' : Matrix m p α) (D' : Matrix m q α),
      Matrix.fromBlocks A B C D * Matrix.fromBlocks A' B' C' D' =
        Matrix.fromBlocks (A * A' + B * C') (A * B' + B * D') (C * A' + D * C') (C * B' + D * D') :=
  by sorry

The theorem `Matrix.fromBlocks_multiply` states that for any types `l`, `m`, `n`, `o`, `p`, `q`, and `α` where `α` has a structure of a non-unital and non-associative semi-ring, and `l` and `m` are finite types, given matrices `A`, `B`, `C`, `D` of type `Matrix n l α`, `Matrix n m α`, `Matrix o l α`, `Matrix o m α` respectively, and matrices `A'`, `B'`, `C'`, `D'` of type `Matrix l p α`, `Matrix l q α`, `Matrix m p α`, `Matrix m q α` respectively, the product of the block matrix formed by `A`, `B`, `C`, `D` and the block matrix formed by `A'`, `B'`, `C'`, `D'` is equal to the block matrix formed by the matrices `(A * A' + B * C')`, `(A * B' + B * D')`, `(C * A' + D * C')`, `(C * B' + D * D')`. In other words, this theorem provides a formula for multiplying block matrices.

For matrices A, B, C, D, A', B', C', D' of compatible sizes over a non-unital and non-associative semi-ring α, the block matrix product (A | B ; C | D) * (A' | B' ; C' | D') equals (A * A' + B * C', A * B' + B * D', C * A' + D * C', C * B' + D * D').


CategoryTheory.Limits.hasColimitOfIso

/-- If `F` has a colimit, so does any naturally isomorphic functor.
 -/
theorem CategoryTheory.Limits.hasColimitOfIso :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F],
      (G ≅ F) → CategoryTheory.Limits.HasColimit G :=
  by sorry

This theorem states that if a functor `F` has a colimit in a category, then any functor `G` that is naturally isomorphic to `F` also has a colimit in that category. Here, `J` and `C` are types representing the categories, and `F` and `G` are functors from category `J` to category `C`. The theorem takes a proof that `F` has a colimit and a natural isomorphism between `F` and `G` to construct a proof that `G` also has a colimit.

If functors `F` and `G` are naturally isomorphic and `F` has a colimit in a category `C`, then `G` also has a colimit in `C`.


theorem MeasureTheory.le_toMeasure_apply :
    ∀ {α : Type u_1} [ms : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α)
      (h : ms ≤ MeasureTheory.OuterMeasure.caratheodory m) (s : Set α),
      ↑m s ≤ ↑↑(MeasureTheory.OuterMeasure.toMeasure m h) s :=
  by sorry

This theorem states that for any type `α` equipped with a `MeasurableSpace` structure, given an outer measure `m` on `α` and a set `s` of `α`, if all sets in the `MeasurableSpace` are Carathéodory measurable with respect to the outer measure `m` (denoted by `ms ≤ MeasureTheory.OuterMeasure.caratheodory m`), then the outer measure of `s` is less than or equal to the measure of `s` obtained by converting the outer measure to a measure (via `MeasureTheory.OuterMeasure.toMeasure m h`). In mathematical terms, we have `m(s) ≤ (MeasureTheory.OuterMeasure.toMeasure(m,h))(s)` for any such `s`.

For any Carathéodory measurable outer measure `m` on a measurable space `α`, the outer measure of a set `s` is less than or equal to the measure of `s` obtained by converting `m` to a measure. (i.e., `m(s) ≤ (MeasureTheory.OuterMeasure.toMeasure m h)(s)` for any Carathéodory measurable `s`.)


theorem Localization.mk_eq_mk_iff :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {a c : M} {b d : ↥S},
      Localization.mk a b = Localization.mk c d ↔ (Localization.r S) (a, b) (c, d) :=
  by sorry

The theorem `Localization.mk_eq_mk_iff` states that for any commutative monoid `M` and any submonoid `S` of `M`, and any elements `a, c` of `M` and `b, d` of `S`, the equivalence classes of `(a, b)` and `(c, d)` in the localization of `M` at `S` are equal if and only if `(a, b)` and `(c, d)` are related by the congruence relation `Localization.r S`. This congruence relation is defined as the smallest relation such that `(1, 1)` is equivalent to `(y, y)` for all `y` in `S`, and for any other such relation on `M × S`, the relation `Localization.r S` implies it.

For any commutative monoid M and submonoid S, the equivalence classes of (a, b) and (c, d) in the localization of M at S are equal if and only if (a, b) and (c, d) are related by the congruence relation Localization.r S.


theorem Measurable.pow_const :
    ∀ {β : Type u_2} {γ : Type u_3} {α : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace γ]
      [inst_2 : Pow β γ] [inst_3 : MeasurablePow β γ] {m : MeasurableSpace α} {f : α → β},
      Measurable f → ∀ (c : γ), Measurable fun x => f x ^ c :=
  by sorry

The theorem `Measurable.pow_const` states that for any measurable spaces `β`, `γ`, and `α`, if `β` and `γ` have a power operation (`Pow β γ`) and a measurable power operation (`MeasurablePow β γ`) is defined between these spaces, and if `f` is a measurable function from `α` to `β`, then for any constant `c` of type `γ`, the function that maps `x` in `α` to the `c`-th power of `f(x)` is measurable. In other words, if we can measure `f`, and we can measure the operation of raising to the `c`-th power, then we can also measure the function that first applies `f` and then raises the result to the `c`-th power.

If `β` and `γ` are measurable spaces with a measurable power operation, and `f` is a measurable function from `α` to `β`, then the function `x ↦ c ^ (f x)` is measurable for any constant `c` of type `γ`.


theorem Mathlib.Data.Finset.Lattice._auxLemma.31 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α) {a : α},
      (Finset.sup' s H f ≤ a) = ∀ b ∈ s, f b ≤ a :=
  by sorry

The theorem `Mathlib.Data.Finset.Lattice._auxLemma.31` states that for any types `α` and `β`, and for any instance of a join-semilattice `α`, and for any nonempty finite set `s` of elements of type `β`, and for any function `f` from `β` to `α`, and for any element `a` of type `α`, the supremum of the image of `s` under `f` is less than or equal to `a` if and only if every element `b` in `s` has an image under `f` that is less than or equal to `a`. In mathematical terms, it's saying that $\sup(f(s)) \leq a$ if and only if for all $b \in s$, $f(b) \leq a$.

The supremum of the image of a nonempty finite set under a function from another type is less than or equal to an element if and only if the image of every element in the set is less than or equal to that element.


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

This theorem, `ofReal_norm_eq_coe_nnnorm`, states that for all type `E` which is a seminormed add group, the extended nonnegative real number representation (`ENNReal`) of the norm of any element `a` of `E` is equal to the nonnegative real number (`ℝ≥0`) representation of the norm of `a`. In other words, the function `ENNReal.ofReal` applied to the norm of `a` (expressed as `‖a‖`) is equivalent to the nonnegative real number representation of the norm of `a` (expressed as `↑‖a‖₊`).

For any seminormed add group `E` and its element `a`, the extended nonnegative real number representation of `‖a‖` equals the nonnegative real number representation of `‖a‖`. In Lean, this is represented as `ENNReal.ofReal ‖a‖ = ↑‖a‖₊`.


theorem Finset.right_not_mem_Ico :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∉ Finset.Ico a b := by sorry

The theorem `Finset.right_not_mem_Ico` states that for any type `α` with a pre-order and a locally finite order, and any elements `a` and `b` of `α`, the element `b` is not included in the finite set of elements `x` such that `a ≤ x` and `x < b`. In mathematical terms, if we denote this set as $[a, b)$, then $b \notin [a, b)$.

For any type `α` with a pre-order and a locally finite order, and elements `a` and `b` of `α`, the element `b` is not a member of the half-open interval `[a, b)` consisting of elements `x` such that `a ≤ x` and `x < b`.


/-- A continuous surjective map from a compact space to a Hausdorff space is a quotient map.  -/
theorem QuotientMap.of_surjective_continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : CompactSpace X]
      [inst_3 : T2Space Y] {f : X → Y}, Function.Surjective f → Continuous f → QuotientMap f :=
  by sorry

The theorem `QuotientMap.of_surjective_continuous` states that for any types `X` and `Y` equipped with topological spaces, where `X` is compact and `Y` is a Hausdorff space, a function `f` from `X` to `Y` is a quotient map if it is both surjective and continuous. In more mathematical terms, if `f: X → Y` is a continuous, surjective function from a compact space `X` to a Hausdorff space `Y`, then `f` is a quotient map, meaning that for all sets `s` in `Y`, `s` is an open set if and only if its preimage under `f` is an open set in `X`.

If `f: X → Y` is a continuous, surjective function from a compact space `X` to a Hausdorff space `Y`, then `f` is a quotient map.


/-- A sum of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)` is the sum of
`f (Fin.last n)` plus the remaining sum -/
theorem Fin.sum_univ_castSucc :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] {n : ℕ} (f : Fin (n + 1) → β),
      (Finset.sum Finset.univ fun i => f i) = (Finset.sum Finset.univ fun i => f (Fin.castSucc i)) + f (Fin.last n) :=
  by sorry

The theorem `Fin.sum_univ_castSucc` states that for any type `β` that forms an additive commutative monoid, and for any function `f` from `Fin (n + 1)` to `β`, the total sum of `f` evaluated at each element in the universal set of `Fin (n + 1)` equals the sum of `f` evaluated at the element obtained by embedding each element in the universal set of `Fin (n + 1)` into `Fin (n + 2)`, plus `f` evaluated at the maximum element in `Fin (n + 1)`. In mathematical terms, this theorem asserts that $\sum_{i=0}^{n+1} f(i) = \left(\sum_{i=0}^{n} f(i+1)\right) + f(n+1)$, where $f$ is a function defined on a finite index set.

For any additive commutative monoid type `β` and function `f` from `Fin (n + 1)` to `β`, the sum of `f` over the universal set of `Fin (n + 1)` equals the sum over `Fin (n)` of `f`'s values at the successor indices, plus `f`'s value at the maximum index.


theorem Nat.le_zero_eq : ∀ (a : ℕ), (a ≤ 0) = (a = 0) := by sorry

This theorem states that for any natural number 'a', 'a' is less than or equal to zero if and only if 'a' equals zero. In other words, for the set of natural numbers, the only way a number can satisfy the condition of being less than or equal to zero is if it is zero itself.

For any natural number 'a', a = 0 if and only if a ≤ 0.


theorem iInf_congr :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : InfSet α] {f g : ι → α}, (∀ (i : ι), f i = g i) → ⨅ i, f i = ⨅ i, g i := by
  sorry

This theorem states that for any type `α` that has an `InfSet` instance, and for any indexing type `ι`, if we have two functions `f` and `g` from `ι` to `α`, then if every element in the image of `f` is equal to the corresponding element in the image of `g`, it follows that the infimum (`⨅`) over all `i` of `f i` is equal to the infimum over all `i` of `g i`. In other words, if two functions produce the same values, then the infimum of the values produced by these functions are the same.

If `f` and `g` are functions from an indexing type `ι` to a type `α` with an `InfSet` instance, and `f i = g i` for all `i`, then `⨅ i, f i = ⨅ i, g i`.


MeasureTheory.SimpleFunc.ext

theorem MeasureTheory.SimpleFunc.ext :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f g : MeasureTheory.SimpleFunc α β},
      (∀ (a : α), ↑f a = ↑g a) → f = g :=
  by sorry

This theorem, `MeasureTheory.SimpleFunc.ext`, in the Lean 4 language is stating that for any two simple functions `f` and `g` of the same types `α` and `β`, where `α` is a measurable space, if the function values of `f` and `g` are equal for all elements of `α` (i.e., `f(a) = g(a)` for all `a` in `α`), then `f` and `g` are essentially the same function. In simpler terms, if two simple functions produce the same outputs for the same inputs, they are the same function.

If two simple functions `f` and `g` of the same types have equal values for all measurable elements, then `f` and `g` are equal almost everywhere.


theorem MeasureTheory.set_integral_congr_ae :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f g : X → E} {s : Set X} {μ : MeasureTheory.Measure X},
      MeasurableSet s → (∀ᵐ (x : X) ∂μ, x ∈ s → f x = g x) → ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in s, g x ∂μ :=
  by sorry

The theorem `MeasureTheory.set_integral_congr_ae` states that for any measure space `X` and any normed additive commutative group `E` that is also a normed space over the reals, given two functions `f` and `g` from `X` to `E`, a set `s` in `X` that is measurable, and a measure `μ` on `X`, if almost every element `x` in `s` with respect to measure `μ` satisfies `f x = g x`, then the integral of `f` over the set `s` with respect to measure `μ` equals to the integral of `g` over the same set with respect to the same measure. In other words, if `f` and `g` are equal almost everywhere on a measurable set `s`, then their integrals over `s` are the same.

If two real-valued functions on a measurable set of a measure space are equal almost everywhere with respect to a given measure, then they have equal integrals over that set with respect to that measure.


Con.ext

/-- Extensionality rule for congruence relations.  -/
theorem Con.ext : ∀ {M : Type u_1} [inst : Mul M] {c d : Con M}, (∀ (x y : M), c x y ↔ d x y) → c = d := by sorry

The theorem `Con.ext` states that for any type `M` equipped with a multiplication operation, if we have two congruence relations `c` and `d` on `M`, then `c` is equal to `d` if and only if, for every pair of elements `x` and `y` from `M`, `x` is related to `y` by `c` if and only if `x` is related to `y` by `d`. Essentially, two congruence relations on a multiplication structure are identical if they relate the same pairs of elements.

Two congruence relations on a multiplicative semigroup are equal if and only if they relate the same pairs of elements.


theorem Finset.biUnion_insert :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] [inst_1 : DecidableEq α]
      {a : α}, Finset.biUnion (insert a s) t = t a ∪ Finset.biUnion s t :=
  by sorry

The theorem `Finset.biUnion_insert` states that for any types `α` and `β`, any finite set `s` of type `α`, any function `t : α → Finset β` that maps elements of `α` to finite sets of `β`, any element `a : α`, and provided that both `α` and `β` have decidable equality, the biUnion of the function `t` over the set obtained by inserting `a` into `s` is equal to the union of `t` applied to `a` and the biUnion of `t` over `s`. In mathematical terms, it means that for all `a ∈ α` and `s ⊆ α`, we have that `⋃_{x ∈ (a ∪ s)} t(x) = t(a) ∪ ⋃_{x ∈ s} t(x)`. Thus, it expresses a property of the biUnion operation analogous to the distributive law of union over insert in set theory.

For any types `α` and `β` with decidable equality, and given a finite set `s` of type `α` and a function `t : α → Finset β`, the biUnion of `t` over `a ∪ s` equals the union of `t(a)` and the biUnion of `t` over `s`, for all `α` elements `a`.


theorem AddMonoid.addOrder_dvd_exponent :
    ∀ {G : Type u} [inst : AddMonoid G] (g : G), addOrderOf g ∣ AddMonoid.exponent G := by sorry

The theorem `AddMonoid.addOrder_dvd_exponent` states that for any additive monoid `G` and an element `g` in `G`, the additive order of `g` (denoted by `addOrderOf g`) divides the exponent of the additive monoid `G` (denoted by `AddMonoid.exponent G`). In other words, the order of any element in the monoid is a divisor of the monoid's exponent. This is the sense in which the order of an element can be seen as a measure of the "cyclicity" of that element, and the exponent as a measure of the overall "cyclicity" of the monoid.

For any additive monoid G and its element g, the additive order of g divides the exponent of G.


theorem Mathlib.Data.ENNReal.Real._auxLemma.14 : ∀ {p : ℝ}, (ENNReal.ofReal p = 0) = (p ≤ 0) := by sorry

The theorem `Mathlib.Data.ENNReal.Real._auxLemma.14` states that for any real number `p`, the function `ENNReal.ofReal p` returns `0` if and only if `p` is less than or equal to `0`. In other words, this function effectively discards the negative part of the real number, setting it to zero.

For any real number `p`, `ENNReal.ofReal p = 0` if and only if `p <= 0`.


theorem Nat.succ_ne_self : ∀ (n : ℕ), Nat.succ n ≠ n := by sorry

This theorem states that, for any natural number `n`, the successor of `n` (which is `n+1`) is not equal to `n`. In other words, adding one to any natural number does not result in the same number.

For all natural numbers `n`, `n+1` is not equal to `n`.


theorem ApplicativeTransformation.preserves_map :
    ∀ {F : Type u → Type v} [inst : Applicative F] [inst_1 : LawfulApplicative F] {G : Type u → Type w}
      [inst_2 : Applicative G] [inst_3 : LawfulApplicative G] (η : ApplicativeTransformation F G) {α β : Type u}
      (x : α → β) (y : F α), (fun {α} => η.app α) (x <$> y) = x <$> (fun {α} => η.app α) y :=
  by sorry

The theorem `ApplicativeTransformation.preserves_map` states that for all types `F` and `G` that are applicative and lawful applicative, and for an applicative transformation `η` from `F` to `G`, and for all types `α` and `β`, and for a function `x` from `α` to `β` and a value `y` of type `F α`, applying the transformation `η` to the result of mapping `x` over `y` is the same as mapping `x` over the result of applying the transformation `η` to `y`. In other words, the transformation `η` preserves the `map` operation.

For all applicative and lawful functors F and G, and applicative transformation η from F to G, the map operation is preserved: for all types α and β and functions x: α → β and values y: F α, η (map x y) = map x (η y).


theorem Int.le_total : ∀ (a b : ℤ), a ≤ b ∨ b ≤ a := by sorry

This theorem, `Int.le_total`, states that for all integer pairs `(a, b)`, either `a` is less than or equal to `b`, or `b` is less than or equal to `a`. In other words, given any two integers, one is always less than or equal to the other. This is a formalized expression of the total order property of the integers.

For all integers a and b, either a ≤ b or b ≤ a.


MeasureTheory.StronglyMeasurable.add

theorem MeasureTheory.StronglyMeasurable.add :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Add β]
      [inst_2 : ContinuousAdd β],
      MeasureTheory.StronglyMeasurable f →
        MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable (f + g) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.add` states that for any two functions `f` and `g` from a type `α` to a type `β` (where `α` comes equipped with a measurable space structure and `β` has a topological space structure, an addition operation, and this addition operation is continuous), if both `f` and `g` are strongly measurable (meaning that they can be approximated as the limit of simple functions), then their sum function `(f + g)` is also strongly measurable. This theorem is fundamental in the theory of integration, as it allows us to construct integrable functions as limits of simple functions.

If `f` and `g` are strongly measurable functions from the measurable space `(α, Σ)` to the topological space `(β, τ)` with a continuous addition operation, then their sum `(f + g)` is also strongly measurable.


/-- The edist to a set is bounded above by the edist to any of its points  -/
theorem EMetric.infEdist_le_edist_of_mem :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {s : Set α}, y ∈ s → EMetric.infEdist x s ≤ edist x y := by
  sorry

This theorem states that for any type `α` that is a PseudoEMetricSpace (a space where the distance between any two points is defined and always non-negative), for any two points `x` and `y` of that type and for any set `s` of such points, if `y` is a member of `s`, then the minimum extended distance from `x` to the set `s` (denoted as `EMetric.infEdist x s`) is less than or equal to the extended distance from `x` to `y` (denoted as `edist x y`). In other words, the minimum distance from a point to a set is no greater than the distance from the point to any specific member of the set.

For any PseudoEMetricSpace `α` and points `x` and `y` in `α` with `y ∈ s`, we have `edist x y ≤ EMetric.infEdist x s`.


theorem Mathlib.Order.Heyting.Basic._auxLemma.13 :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a \ b ≤ c) = (a ≤ b ⊔ c) := by sorry

This theorem, referred to as `Mathlib.Order.Heyting.Basic._auxLemma.13`, states that for all types `α` that form a Generalized Coheyting Algebra, and for all elements `a, b, c` of type `α`, the property that `a` subtracted from `b` is less than or equal to `c` is equivalent to the property that `a` is less than or equal to the join (`⊔`) of `b` and `c`. Using mathematical symbols, this can be written as `(a \ b ≤ c) = (a ≤ b ⊔ c)`.

For all types `α` that form a Generalized Heyting Algebra and all elements `a, b, c` of type `α`, `a - b ≤ c` if and only if `a ≤ b ⊔ c`.


theorem Mathlib.Order.Filter.Germ._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β}, (↑f = ↑g) = (f =ᶠ[l] g) := by sorry

This theorem, from the Mathlib library in the Order.Filter.Germ module, states that for any types `α` and `β`, a filter `l` on `α`, and two functions `f` and `g` from `α` to `β`, the assertion that the germ of `f` equals the germ of `g` is equivalent to saying that `f` equals `g` almost everywhere with respect to the filter `l`. In other words, if two functions are equal almost everywhere on a certain filter, their germs are also equal.

For any types `α` and `β`, filter `l` on `α`, and functions `f` and `g` from `α` to `β`, the germs of `f` and `g` are equal if and only if `f` and `g` are equal almost everywhere with respect to `l`.


theorem lie_skew : ∀ {L : Type v} [inst : LieRing L] (x y : L), -⁅y, x⁆ = ⁅x, y⁆ := by sorry

This theorem, named "lie_skew", states that for any type `L` that has a Lie ring structure, and for any two elements `x` and `y` of this type, the Lie bracket of `y` and `x` negated is equal to the Lie bracket of `x` and `y`. In mathematical notation, this would be written as: for all `x` and `y` in `L`, `- [y,x] = [x,y]`. This property is known as skew-symmetry and is one of the defining properties of Lie algebras.

For any Lie ring `L`, the Lie bracket is skew-symmetric, that is, `- [y,x] = [x,y]` for all `x, y` in `L`.


BddBelow.mono

/-- If `s ⊆ t` and `t` is bounded below, then so is `s`.  -/
theorem BddBelow.mono : ∀ {α : Type u} [inst : Preorder α] ⦃s t : Set α⦄, s ⊆ t → BddBelow t → BddBelow s := by sorry

This theorem states that if a set `s` of a certain type `α` (with a preorder relation defined) is a subset of another set `t`, and if `t` has a lower bound, then `s` also has a lower bound. This is a theorem about the transfer of the property of being bounded below between subsets, in the context of preordered sets.

If `s` is a subset of preordered set `t` with a lower bound, then `s` also has a lower bound.


theorem hasStrictDerivAt_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) (c : F), HasStrictDerivAt (fun x => c) 0 x :=
  by sorry

The theorem `hasStrictDerivAt_const` states that for any non-trivially normed field `𝕜`, normed addition-commutative group `F`, and normed space over `𝕜` and `F`, and for any element `x` from `𝕜` and `c` from `F`, the function that maps every element to a constant `c` has a strict derivative at the point `x`, and the value of this derivative is `0`. This is equivalent to saying that the rate of change of a constant function is zero, which aligns with the intuitive understanding in calculus.

For any non-trivially normed field 𝕜, normed add-commutative group F, and normed space over 𝕜 and F, the constant function from F to 𝕜 with value c at every x has a strict derivative equal to the zero function.


theorem Finset.image_image :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {f : α → β} {s : Finset α}
      [inst_1 : DecidableEq γ] {g : β → γ}, Finset.image g (Finset.image f s) = Finset.image (g ∘ f) s :=
  by sorry

The `Finset.image_image` theorem states that for all sets `s` of type `α`, functions `f : α → β` and `g : β → γ`, and given that the equality of elements in `β` and `γ` are decidable, then the image of the set `s` under `f` followed by the image under `g` is the same as the image of the set `s` under the composition of `g` and `f`. In other words, applying `g` to the image of `s` under `f` is the same as applying the composition of `g` and `f` to `s`. This theorem formalizes the concept of the composition of functions in the context of the images of finite sets.

For any decidably equal sets `β` and sets `s` of type `α`, the image of `s` under the composition of functions `g : β → γ` and `f : α → β` is equal to the image of `s` under `g` followed by the image under `f`.


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

This theorem states that for any type `α` which has a linear order, and for any three elements `a`, `b`, `c` of this type, `a` is less than the maximum of `b` and `c` if and only if `a` is less than `b` or `a` is less than `c`. Specifically, `max b c` returns the maximum number between `b` and `c`, so `a` being less than this maximum is equivalent to `a` being less than at least one of `b` or `c`.

For any type with a linear order, element `a` is less than the maximum of elements `b` and `c` if and only if `a` is less than `b` or less than `c`.


theorem Rat.cast_add : ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] (m n : ℚ), ↑(m + n) = ↑m + ↑n :=
  by sorry

This theorem states that for any two rational numbers `m` and `n`, the operation of casting their sum to a type `α` (which is a division ring with characteristic zero) is the same as individually casting `m` and `n` to type `α` first and then adding them. In other words, it asserts the commutativity of addition and the cast operation for rational numbers in a division ring with characteristic zero.

For any rational numbers m and n, the conversion of their sum to a division ring with characteristic zero is equal to the sum of their individual conversions.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.51 :
    ∀ {V : Type u} (G : SimpleGraph V) (v w : V), (w ∈ SimpleGraph.neighborSet G v) = G.Adj v w := by sorry

This theorem states that for any given type `V`, a graph `G` of type `SimpleGraph V`, and any two vertices `v` and `w` of type `V`, `w` is in the neighbor set of `v` in `G` if and only if `v` and `w` are adjacent in `G`. In other words, a vertex `w` belongs to the neighbor set of a vertex `v` in a simple graph `G` precisely when there is an edge connecting `v` and `w` in that graph. Therefore, the neighbor set of a vertex in `G` is precisely the set of vertices which are adjacent to it in `G`.

In a simple graph, the neighbor set of a vertex equals the set of vertices adjacent to it.


/-- The direction of an affine subspace constructed from a point and a direction.  -/
theorem AffineSubspace.direction_mk' :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p : P) (direction : Submodule k V),
      AffineSubspace.direction (AffineSubspace.mk' p direction) = direction :=
  by sorry

The theorem `AffineSubspace.direction_mk'` states that for any ring `k`, additive commutative group `V`, and affine torsor `P`, given any point `p` of type `P` and any direction which is a submodule of type `V`, the direction of the affine subspace that is constructed using this point and direction, is equal to the original direction. In other words, if you construct an affine subspace from a point and a direction, the direction of the resulting affine subspace is the same as the direction that was used to construct it.

For any ring `k`, additive commutative group `V`, affine torsor `P`, point `p` in `P`, and submodule `d` of `V`, the direction of the affine subspace `AffineSubspace.mk p d` is equal to `d`.


theorem Cardinal.toNat_le_toNat :
    ∀ {c d : Cardinal.{u}}, c ≤ d → d < Cardinal.aleph0 → Cardinal.toNat c ≤ Cardinal.toNat d := by sorry

This theorem states that for any two cardinal numbers `c` and `d` in a particular type `u`, if `c` is less than or equal to `d` and `d` is less than the smallest infinite cardinal (also known as `ℵ₀` or aleph null), then the natural number corresponding to `c` is less than or equal to the natural number corresponding to `d`. Here, the function `Cardinal.toNat` is used to map the cardinal numbers `c` and `d` to natural numbers, returning 0 for infinite cardinals.

If `c` is a finite cardinal number less than or equal to `d`, and `d` is less than the smallest infinite cardinal, then `Cardinal.toNat c` is less than or equal to `Cardinal.toNat d`.


theorem HasStrictFDerivAt.mem_toPartialHomeomorph_source :
    ∀ {𝕜 : 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]
      [inst_5 : CompleteSpace E] {f : E → F} {f' : E ≃L[𝕜] F} {a : E} (hf : HasStrictFDerivAt f (↑f') a),
      a ∈ (HasStrictFDerivAt.toPartialHomeomorph f hf).source :=
  by sorry

The theorem `HasStrictFDerivAt.mem_toPartialHomeomorph_source` states that for a function `f` from a normed add commutative group `E` to another normed add commutative group `F`, both over a nontrivially normed field `𝕜`, if this function has a strict Frechet derivative at a point `a` in `E`, then `a` belongs to the source of the partial homeomorphism associated with the strict Frechet derivative.

If `f : E → F` is a function between normed add commutative groups over a nontrivially normed field with a strict Frechet derivative at `a ∈ E`, then `a` is in the domain of the partial homeomorphism defined by the strict Frechet derivative.


theorem isClosed_property :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {e : α → β} {p : β → Prop},
      DenseRange e → IsClosed {x | p x} → (∀ (a : α), p (e a)) → ∀ (b : β), p b :=
  by sorry

The theorem `isClosed_property` states that for any types `α` and `β` and any topological space over `β`, given a function `e` from `α` to `β`, a predicate `p` over `β`, if `e` has a dense range, and the set of `β` satisfying `p` is closed, and `p` holds for every element in the image of `e`, then `p` holds for all `b` in `β`. In other words, if we have a function whose range densely covers a topological space and a property that holds for all points in the dense range and that defines a closed set, then that property must hold throughout the entire space.

If a function with a dense range maps a closed set to a property, then the property holds for all elements in the target space.


theorem MeasureTheory.VectorMeasure.neg_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M]
      [inst_2 : TopologicalAddGroup M] (v : MeasureTheory.VectorMeasure α M) (i : Set α), ↑(-v) i = -↑v i :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.neg_apply` states that for any measurable space `α` and any set `i` of type `α`, and a vector measure `v` on `α` with values in a topological additive commutative group `M`, the measure of the set `i` under the negation of `v` equals the negation of the measure of the set `i` under `v`. In other words, negative of a vector measure applied to a set is equal to the negative of the measure of the set under the original vector measure. This holds for all measurable spaces and all vector measures taking values in a space that forms a topological additive commutative group.

For any measurable space, set, vector measure, and topological additive commutative group, the negative of the measure of a set under a vector measure is equal to the measure of the set under the negation of the vector measure.


theorem MeasureTheory.OuterMeasure.iSup_apply :
    ∀ {α : Type u_1} {ι : Sort u_5} (f : ι → MeasureTheory.OuterMeasure α) (s : Set α), ↑(⨆ i, f i) s = ⨆ i, ↑(f i) s :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.iSup_apply` states that for any type `α`, any type `ι`, any function `f` that maps from `ι` to the outer measure of `α`, and any set `s` of type `α`, the outer measure of the supremum (greatest lower bound) of `f` applied to `s` is equal to the supremum of the outer measure of `f` applied to `s`. In simpler terms, it asserts that the outer measure operation can be interchanged with the taking of supremum in a function over a set.

For any type `α`, any type `ι`, and any function `f : ι → ℝ` mapping from `ι` to the outer measure of `α`, the outer measure of the supremum of `f` over a set `s` in `α` equals the supremum of the outer measures of `f` over `s`.


theorem Matrix.det_isEmpty :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [inst_3 : IsEmpty n]
      {A : Matrix n n R}, Matrix.det A = 1 :=
  by sorry

This theorem, `Matrix.det_isEmpty`, states that for any type `n` with decidable equality, which is a finite type, and assuming `n` is empty, if `R` is a type forming a commutative ring, then the determinant of any matrix `A`, which is a square matrix with entries in `R` and dimensions defined by `n`, is always equal to `1`.

For any finite type `n` with decidable equality and any commutative ring `R`, if the square matrix `A` of dimension `n` over `R` is empty, then its determinant is equal to 1.


theorem Real.exp_strictMono : StrictMono Real.exp := by sorry

The theorem `Real.exp_strictMono` states that the real exponential function, denoted as `Real.exp`, is strictly monotone. In other words, for any two real numbers `a` and `b`, if `a` is less than `b` then the exponential of `a` (i.e., `Real.exp a`) is less than the exponential of `b` (i.e., `Real.exp b`). This property is a fundamental characteristic of the exponential function in real numbers.

The real exponential function `Real.exp` is strictly increasing.


theorem coe_int_mem :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : SetLike S R] [hSR : SubringClass S R] (s : S) (n : ℤ),
      ↑n ∈ s :=
  by sorry

This theorem states that for any integer `n`, and any subring `s` of a ring `R`, the integer coercion of `n` always belongs to `s`. Here, `R` and `S` are arbitrary types, where `R` has a ring structure and `S` is a subset of `R` with a `SetLike` structure, satisfying the properties of a subring (`SubringClass`). The integer coercion (`↑n`) maps the integer `n` to an element in the ring `R`. The theorem asserts that this mapped element is indeed in the subring `s`.

For any integer `n` and subring `s` of a ring `R` (where `R` has a ring structure and `s` is a subring as defined by `SubringClass`), the integer coercion `↑n` maps `n` to an element in `s`.


theorem ZMod.valMinAbs_def_pos :
    ∀ {n : ℕ} [inst : NeZero n] (x : ZMod n),
      ZMod.valMinAbs x = if ZMod.val x ≤ n / 2 then ↑(ZMod.val x) else ↑(ZMod.val x) - ↑n :=
  by sorry

This theorem, `ZMod.valMinAbs_def_pos`, establishes the definition of the `valMinAbs` function for positive natural numbers `n` and any integer modulo `n`, denoted as `x : ZMod n`. The function `valMinAbs` returns the integer that is in the same equivalence class as `x` and is closest to `0`, with the result being in the interval `(-n/2, n/2]`. The theorem states that the value of `valMinAbs x` is equal to `x` if `x` is less than or equal to `n/2`, otherwise it's equal to `x - n`.

For any natural number `n` and integer `x` in `ZMod n`, `valMinAbs x = x` if `x ≤ n / 2`, otherwise `valMinAbs x = x - n`.


theorem Polynomial.isRoot_cyclotomic_iff :
    ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [inst_1 : IsDomain R] [inst_2 : NeZero ↑n] {μ : R},
      Polynomial.IsRoot (Polynomial.cyclotomic n R) μ ↔ IsPrimitiveRoot μ n :=
  by sorry

The theorem `Polynomial.isRoot_cyclotomic_iff` states the following: for any commutative ring `R`, where `R` is a domain and `n` is a nonzero natural number, a number `μ` is a root of the `n`-th cyclotomic polynomial with coefficients in `R` if and only if `μ` is a primitive root of order `n`. In other words, the number `μ` is a solution to the `n`-th cyclotomic polynomial equation if and only if `μ` is a primitive root with an order of `n`.

For a commutative domain R and natural number n, an element μ of R is a root of the n-th cyclotomic polynomial if and only if it is a primitive n-th root in R.


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

This theorem states that for any polynomial `p` over a semiring `R`, the coefficient of the term with zero degree in the polynomial, denoted by `Polynomial.coeff p 0`, is equal to the value of the polynomial evaluated at zero, denoted by `Polynomial.eval 0 p`. This corresponds to the familiar fact from algebra that the constant term of a polynomial is the value of the polynomial when all its variables are set to zero.

For any polynomial `p` over a semiring `R`, the constant term `Polynomial.coeff p 0` is equal to `Polynomial.eval 0 p`.


theorem Mathlib.Data.Finset.Powerset._auxLemma.6 :
    ∀ {α : Type u_1} {s t : Finset α}, (s ∈ Finset.powerset t) = (s ⊆ t) := by sorry

This theorem states that for any type `α` and for any two finite sets `s` and `t` of type `α`, `s` is a member of the power set of `t` if and only if `s` is a subset of `t`. Here, the power set of a set `t` is the set of all possible subsets of `t`. In other words, a finite set `s` belongs to the power set of another finite set `t` precisely when all elements of `s` are also elements of `t`.

For any types `α` and finite sets `s` and `t` of type `α`, `s` is a subset of `t` if and only if `s` is an element of the power set of `t`.


theorem Submodule.mem_comap :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {x : M} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂] {f : F}
      {p : Submodule R₂ M₂}, x ∈ Submodule.comap f p ↔ f x ∈ p :=
  by sorry

The theorem `Submodule.mem_comap` states that for all types `R`, `R₂`, `M`, `M₂`, `F` and `x` of type `M`, together with the instances of `Semiring R`, `Semiring R₂`, `AddCommMonoid M`, `AddCommMonoid M₂`, `Module R M`, `Module R₂ M₂`, `FunLike F M M₂`, `SemilinearMapClass F σ₁₂ M M₂`, and given a function `f` of type `F` and a submodule `p` of `R₂` and `M₂`, a term `x` of type `M` is in the preimage of `p` under `f` (denoted as `Submodule.comap f p`) if and only if `f x` is in `p`. This theorem essentially defines how the preimage operation (`Submodule.comap`) works for submodules and functions that are `FunLike`.

For any `FunLike` function `F` between modules `M` and `M₂` over semirings `R` and `R₂`, and a submodule `p` of `R₂` and `M₂`, an element `x` of `M` is in the preimage `Submodule.comap f p` if and only if `f x` is in `p`.


theorem MeasureTheory.mem_measurableCylinders :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] (t : Set ((i : ι) → α i)),
      t ∈ MeasureTheory.measurableCylinders α ↔ ∃ s S, MeasurableSet S ∧ t = MeasureTheory.cylinder s S :=
  by sorry

This theorem, `MeasureTheory.mem_measurableCylinders`, states that for any type `ι`, for any function `α` from `ι` to a type `u_2`, and given any measurable space over the type that `α` maps to, for any set `t` of functions from `ι` to `α i`, `t` is in the set of measurable cylinders of `α` if and only if there exists a finite set `s` and a set `S` such that `S` is a measurable set and `t` equals to the cylinder of `s` and `S`. Here, a cylinder is defined as the preimage of a set `S` of functions (for all `i` in `s`, `α i`) by the projection from functions (for all `i`, `α i`) to functions (for all `i` in `s`, `α i`). In other words, a cylinder is the set of all functions mapping from `ι` to `α i` that map elements of `s` to the corresponding elements of `S`.

A set of functions from a type `ι` to a measurable space is a measurable cylinder if and only if it is the preimage of a measurable set under the projection from functions to their values on a finite subset of `ι`.


Subtype.eta

theorem Subtype.eta : ∀ {α : Type u} {p : α → Prop} (a : { x // p x }) (h : p ↑a), { val := ↑a, property := h } = a :=
  by sorry

This theorem, `Subtype.eta`, states that for any type `α`, and any predicate `p` on `α`, given an element `a` of the subtype of `α` satisfying `p`, and a proof `h` that `a` satisfies `p`, constructing a new subtype element with value `a` and proof `h` yields the same element `a`. Essentially, it asserts that elements of a subtype are unambiguously characterized by their underlying element of the original type, with no duplication for different proofs of the same property.

For any type `α` and predicate `p` on `α`, if `a : α` satisfies `p` and `h : p a`, then the elements `(a, h) : p.{max 1} α` and `a` are equal.


theorem MeasureTheory.set_integral_congr_set_ae :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f : X → E} {s t : Set X} {μ : MeasureTheory.Measure X},
      s =ᶠ[MeasureTheory.Measure.ae μ] t → ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in t, f x ∂μ :=
  by sorry

This theorem, `MeasureTheory.set_integral_congr_set_ae`, states that for any types `X` and `E`, given a measurable space on `X`, a normed additive commutative group on `E`, and a normed space over the reals for `E`; for any function `f` from `X` to `E`, and any two sets `s` and `t` of `X`, and a measure `μ` on `X`; if the sets `s` and `t` are equal almost everywhere with respect to measure `μ` (meaning, the set of points where `s` and `t` differ has measure zero), then the integral of `f` over the set `s` with respect to measure `μ` is equal to the integral of `f` over the set `t` with respect to measure `μ`. In other words, changing the values of a function on a set of measure zero does not change its integral.

If two sets have measure zero difference in a measurable space, then the integral of a measurable function over one set equals the integral over the other.


theorem Filter.mem_atTop : ∀ {α : Type u_3} [inst : Preorder α] (a : α), {b | a ≤ b} ∈ Filter.atTop := by sorry

The theorem `Filter.mem_atTop` states that for any type `α` that is a preorder, and for any element `a` of type `α`, the set of all elements `b` such that `a` is less than or equal to `b` belongs to the filter that represents the limit tending to infinity on this set. In other words, the upper set `{b | a ≤ b}` is always in the top filter of the preorder.

For any preorder type `α` and element `a` in `α`, the upper set `{b | a ≤ b}` is in the top filter of the preorder.


theorem Nat.le_mul_of_pos_right : ∀ {m : ℕ} (n : ℕ), 0 < m → n ≤ n * m := by sorry

This theorem states that for all natural numbers 'm' and 'n', if 'm' is greater than 0, then 'n' is less than or equal to 'n' multiplied by 'm'. In other words, it's saying that any non-zero multiplication of a number will always be greater than or equal to the number itself.

For all natural numbers m and n, if m > 0 then n <= n * m.


theorem Finsupp.prod_single_index :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] {a : α} {b : M}
      {h : α → M → N}, h a 0 = 1 → Finsupp.prod (fun₀ | a => b) h = h a b :=
  by sorry

The theorem `Finsupp.prod_single_index` states that for all types `α`, `M`, `N` where `M` has a zero instance and `N` a commutative monoid instance, and for any element `a` of type `α`, any element `b` of type `M`, and any function `h` from `α` and `M` to `N`, if `h a 0` is equal to 1, then the product of `h a (f a)` over the support of `f`, where `f` is a function from `α` to `M` defined as `f(a) = b` and `f(x) = 0` for `x ≠ a`, is equal to `h a b`. This means that in this specific case, the product is not affected by the other zero values of the function.

For any commutative monoid `N`, function `h : α × M → N`, and element `a : α` with `M` having a zero, if `h(a, 0) = 1`, then the product of `h(a, b)` over the support of the function `f : α → M` defined as `f(x) = b` for `x = a` and `0` otherwise, equals `h(a, b)`.


theorem Polynomial.degree_C_mul_X_pow_le :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (a : R), Polynomial.degree (Polynomial.C a * Polynomial.X ^ n) ≤ ↑n := by
  sorry

The theorem `Polynomial.degree_C_mul_X_pow_le` states that for any semiring `R`, any natural number `n`, and any element `a` of `R`, the degree of the polynomial obtained by multiplying the constant polynomial `a` with the `n`th power of the polynomial variable `X` is at most `n`. In other words, if we form a polynomial by multiplying a constant by `X` raised to some power, the degree of that polynomial (the highest exponent that appears) cannot exceed that power.

For any semiring R, natural number n, and element a in R, the degree of the polynomial a * X^n is at most n.


theorem Set.sInter_empty : ∀ {α : Type u_1}, ⋂₀ ∅ = Set.univ := by sorry

This theorem, `Set.sInter_empty`, states that for any type `α`, the intersection over an empty collection of sets is the universal set. In other words, if you have no sets to intersect, you end up with the set containing all possible elements of type `α`. This is analogous to the fact in mathematics that the intersection of an empty family of sets is the universal set.

The intersection of an empty family of sets in type `α` is the universe `Set.univ`.


SetTheory.PGame.Relabelling.le

theorem SetTheory.PGame.Relabelling.le : ∀ {x y : SetTheory.PGame}, SetTheory.PGame.Relabelling x y → x ≤ y := by sorry

This theorem states that for any two "Games" `x` and `y` in Set Theory, if there is a 'Relabelling' from `x` to `y`, then `x` is less than or equal to `y`. Here, `SetTheory.PGame` refers to games in the context of Set Theory and `SetTheory.PGame.Relabelling` is a relation that represents a renaming of the positions of a game.

For any two Set Theory games `x` and `y`, if there exists a relabelling from `x` to `y` in Set Theory, then `x` is less than or equal to `y` in the game lattice.


theorem multiplicity.pow_dvd_iff_le_multiplicity :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {k : ℕ},
      a ^ k ∣ b ↔ ↑k ≤ multiplicity a b :=
  by sorry

This theorem asserts that for any type `α` equipped with a monoid structure and a decidable relation for divisibility, and for any elements `a` and `b` of type `α` and any natural number `k`, the statement "a raised to the power k divides b" is equivalent to the condition "k is less than or equal to the multiplicity of a in b". Here, the multiplicity of `a` in `b` is the largest natural number `n` such that `a^n` divides `b`. If there is no such `n`, the multiplicity is defined to be infinity.

For any monoid `α` with decidable divisibility relation, and for all `a`, `b` in `α` and natural number `k`, `a^k` divides `b` if and only if `k` is less than or equal to the multiplicity of `a` in `b`.


/-- This lemma is only supposed to be used in the generic context, when working with instances
of classes extending `EquivLike`.
For concrete isomorphism types such as `Equiv`, you should use `Equiv.apply_symm_apply`
or its equivalent.

TODO: define a generic form of `Equiv.symm`.  -/
theorem EquivLike.apply_inv_apply :
    ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E) (b : β), e (EquivLike.inv e b) = b :=
  by sorry

This theorem, named `EquivLike.apply_inv_apply`, essentially states that for any sort `E`, types `α` and `β`, and for any instance of `EquivLike` between `α` and `β`, given an element `e` of `E` and `b` of `β`, applying `e` to the inverse of `b` (under `e`) will yield `b` itself. This theorem is generally used in generic contexts when working with classes extending `EquivLike`. For specific isomorphism types like `Equiv`, you should use `Equiv.apply_symm_apply` or its equivalent. The theorem essentially encapsulates the idea that applying a function to its inverse will yield the original input, which is an important property in the theory of functions and isomorphisms.

For any `EquivLike` equivalence relation `e` between types `α` and `β`, `e (e.inv x) = x` holds for all `x : β`.


theorem CategoryTheory.Limits.equalizer.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasEqualizer f g],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.ι f g) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.ι f g) g :=
  by sorry

This theorem states that in any category `C`, for any two morphisms `f` and `g` from `X` to `Y`, if `f` and `g` have an equalizer, then the composition of the equalizer's inclusion morphism (`equalizer.ι f g`) with `f` is equal to the composition of the equalizer's inclusion morphism with `g`. In other words, following the equalizer into `X` and then following `f` to `Y` is the same as following the equalizer into `X` and then following `g` to `Y`. This is the defining property of an equalizer in category theory.

In any category, for all morphisms f and g from X to Y with an equalizer, the diagram commutes: i.e., equalizer.ι (f ∘ i) = equalizer.ι (g ∘ i).


theorem CategoryTheory.ShortComplex.LeftHomologyData.exact_iff :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S]
      (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Limits.IsZero h.H :=
  by sorry

This theorem states that for any category `C` (which is of type `u_1` and has zero morphisms) and any "short complex" `S` in this category (which has homology), the "short complex" `S` is "exact" (in the sense of category theory) if and only if the left homology data `h` of `S` is a zero object in the category `C`. In the context of category theory, a "short complex" is a specific kind of diagram of morphisms and objects, "exactness" is a property of such diagrams, and "homology" is a way to extract algebraic invariants from such diagrams.

For any category C with zero morphisms and homology, a short complex S is exact if and only if its left homology data h is the zero object in C.


theorem Mathlib.Order.Filter.Basic._auxLemma.26 :
    ∀ {α : Type u} {f g : Filter α} {s : Set α}, (s ∈ f ⊔ g) = (s ∈ f ∧ s ∈ g) := by sorry

This theorem states that for any type `α`, any filters `f` and `g` on this type, and any set `s` of elements of this type, `s` being an element in the join (supremum) of the filters `f` and `g` is equivalent to `s` being an element both in `f` and in `g`. In other words, a set is in the join of two filters if and only if it is in both filters.

For any type `α`, filters `f` and `g` on `α`, and set `s` in `α`, `s` belongs to the join of filters `f` and `g` if and only if `s` belongs to both `f` and `g` (i.e., `s` is in `f` and `g`).


theorem PartENat.top_add : ∀ (x : PartENat), ⊤ + x = ⊤ := by sorry

This theorem states that for every element `x` of the type `PartENat`, which represents the set of natural numbers extended with infinity (`⊤`), the sum of `⊤` and `x` always equals `⊤`. In other words, it captures the mathematical concept that infinity added to any extended natural number (including infinity itself) is still infinity.

For every `x` in `PartENat`, `⊤ + x = ⊤`.


theorem Finset.univ_inter :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), Finset.univ ∩ s = s := by sorry

This theorem, `Finset.univ_inter`, states that for any type `α` that has a finite number of elements (denoted by `Fintype α`) and decidable equality (denoted by `DecidableEq α`), and for any finite set `s` of type `α` (denoted by `Finset α`), the intersection of the universal finite set (`Finset.univ`) and `s` is equal to `s` itself. In other words, when we take the intersection of `s` and the set of all possible elements of the same type, we simply get `s` back. This is the equivalent of saying that a set intersected with the universal set is the set itself in set theory.

For any type `α` that is a finite Fintype with decidable equality, and any finite set `s` of type `α`, `Finset.univ α` intersect `s` equals `s`.


theorem Filter.map_prod_eq_map₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β),
      Filter.map (fun p => m p.1 p.2) (f ×ˢ g) = Filter.map₂ m f g :=
  by sorry

The theorem `Filter.map_prod_eq_map₂` states that for any types `α`, `β`, and `γ`, and for any binary function `m` from `α` and `β` to `γ`, and any filters `f` and `g` on `α` and `β` respectively, the forward map of the filter of the product of `f` and `g` under the function `m` applied to the components of the product is equal to the image of the binary function `m` as a function from the filters `f` and `g` to a filter on `γ`. This essentially states that the two ways of mapping a binary function over a product of filters give the same result.

For any types `α`, `β`, and `γ`, and binary function `m` from `α × β` to `γ`, filters `f` on `α`, and `g` on `β`, the map of the product filter `f × g` under `m` equals the image filter of `m` on the pair `(f, g)`.


theorem Nat.add_left_cancel : ∀ {n m k : ℕ}, n + m = n + k → m = k := by sorry

This theorem, `Nat.add_left_cancel`, states that for any three natural numbers `n`, `m`, and `k`, if the sum of `n` and `m` is equal to the sum of `n` and `k`, then `m` must be equal to `k`. In other words, adding the same number `n` to two different numbers `m` and `k` results in equal sums only if `m` and `k` are the same. This is a formalization of the principle of cancelation in addition for natural numbers.

If `n`, `m`, and `k` are natural numbers such that `n + m = n + k`, then `m = k`.


theorem CategoryTheory.Limits.prod.functor.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
      (X Y : C), CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pair X Y) :=
  by sorry

The theorem `CategoryTheory.Limits.prod.functor.proof_1` states that for any category `C` that has binary products, and for any two objects `X` and `Y` in `C`, there is a limit for the functor which maps a discrete category with two objects (a "walking pair") to `X` and `Y` in `C`. In essence, it asserts the existence of product objects for any pair of objects in a category with binary products.

For any category with binary products, the product of two objects exists.


theorem Polynomial.map_id :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.map (RingHom.id R) p = p := by sorry

This theorem states that for any semiring `R` and any polynomial `p` over this ring, if we apply the function `Polynomial.map` with the identity ring homomorphism `RingHom.id R` to `p`, we get `p` itself. In other words, mapping a polynomial across the identity ring homomorphism leaves the polynomial unchanged.

For any semiring `R` and polynomial `p` over `R`, applying the identity ring homomorphism `RingHom.id R` to `p` via `Polynomial.map` results in `p` itself.


theorem Finset.image_subset_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s₁ s₂ : Finset α},
      s₁ ⊆ s₂ → Finset.image f s₁ ⊆ Finset.image f s₂ :=
  by sorry

This theorem, named `Finset.image_subset_image`, states that for any two finite sets `s₁` and `s₂` of some type `α`, if `s₁` is a subset of `s₂`, then the image of `s₁` under a function `f` from `α` to some type `β` is a subset of the image of `s₂` under the same function `f`. Here, the equality of elements in type `β` is decidable. The image of a set under a function refers to the set of all the function's outputs when applied to each element of the original set. This theorem thus generalizes the property of subset relation preservation under function mapping.

If `s₁` is a subset of `s₂` and `f` is a function, then `f(s₁)` is a subset of `f(s₂)`.


theorem WithBot.coe_ne_bot : ∀ {α : Type u_1} {a : α}, ↑a ≠ ⊥ := by sorry

This theorem states that for any given type `α` and any element `a` of that type, the coercion of `a` to the `WithBot α` type (which is the type `α` extended with a bottom element `⊥`) is not equal to the bottom element `⊥`. In other words, any concrete element of the original type, when lifted to the extended type with a bottom element, does not become the bottom element.

For any type `α` and its element `a`, the coercion of `a` to `WithBot α` is not equal to the bottom element `⊥` of `WithBot α`.