Measurable.prod

theorem Measurable.prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {mγ : MeasurableSpace γ} {f : α → β × γ},
      (Measurable fun a => (f a).1) → (Measurable fun a => (f a).2) → Measurable f :=
  by sorry

The theorem `Measurable.prod` states that for any three types `α`, `β`, and `γ` with respective measurable spaces `m`, `mβ`, and `mγ`, and any function `f` from `α` to the product space `β × γ`, if the function that maps `a` to the first component of `f a` is measurable and the function mapping `a` to the second component of `f a` is also measurable, then the function `f` itself is measurable. In mathematical terms, if both projections of `f : α → β × γ` are measurable, then `f` is measurable.

If the projections of a function from a measurable space to the product of two measurable spaces are measurable, then the function itself is measurable.


theorem Filter.tendsto_iff_comap :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
      Filter.Tendsto f l₁ l₂ ↔ l₁ ≤ Filter.comap f l₂ :=
  by sorry

The theorem `Filter.tendsto_iff_comap` states that for any types `α` and `β`, any function `f` from `α` to `β` and any filters `l₁` on `α` and `l₂` on `β`, the function `f` tends to `l₂` along `l₁` if and only if `l₁` is less than or equal to the preimage filter of `f` along `l₂`. In other words, for all `α`, `β`, `f`, `l₁`, and `l₂`, the function `f` has the limit of `l₂` at `l₁` if and only if every set in `l₁` contains the preimage under `f` of some set in `l₂`.

For types `α` and `β`, functions `f` from `α` to `β`, and filters `l₁` on `α` and `l₂` on `β`, the function `f` tends to `l₂` along `l₁` if and only if `l₁` is contained in the preimage filter of `f` along `l₂`.


theorem Valuation.map_zero :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀),
      v 0 = 0 :=
  by sorry

The theorem `Valuation.map_zero` states that for any ring `R` and any linearly ordered commutative monoid with zero `Γ₀`, the valuation `v` of the zero element of `R` is always zero. In mathematical terms, this can be expressed as ∀v : Valuation R Γ₀, v(0) = 0. This theorem essentially encapsulates the property of valuations that they map the zero element of a ring to the zero element of the ordered monoid.

For any ring R and linearly ordered commutative monoid with zero Γ₀, the valuation map v maps the zero element of R to the zero element of Γ₀, i.e., v(0) = 0.


theorem Ordinal.nat_lt_omega : ∀ (n : ℕ), ↑n < Ordinal.omega := by sorry

The theorem `Ordinal.nat_lt_omega` states that for any natural number `n`, the ordinal representation of `n` is less than the first infinite ordinal, `Ordinal.omega`. In other words, every natural number is less than the cardinality of the set of all natural numbers, represented as an ordinal. This reflects the intuitive understanding that any specific natural number is part of a set that is infinitely large.

For any natural number `n`, the ordinal representation of `n` is strictly less than the ordinal `Ordinal.omega`.


theorem MeasureTheory.OuterMeasure.restrict_apply :
    ∀ {α : Type u_1} (s t : Set α) (m : MeasureTheory.OuterMeasure α),
      ↑((MeasureTheory.OuterMeasure.restrict s) m) t = ↑m (t ∩ s) :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.restrict_apply` states that for any types `α`, and for any sets `s` and `t` of type `α`, and for any outer measure `m` of type `α`, the outer measure `m` restricted to the set `s` and then applied to the set `t` is equal to the outer measure `m` applied to the intersection of sets `t` and `s`. In other words, restricting an outer measure to a subset and then measuring another set is the same as measuring the intersection of the two sets with the original outer measure.

For any outer measure `m` on a type `α`, and sets `s` and `t` of type `α`, `m` applied to the intersection of `s` and `t` is equal to the restriction of `m` to `s` and then the application to `t`.


theorem Mathlib.LinearAlgebra.Span._auxLemma.28 :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_9}
      [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {p : Submodule R M} {q : Submodule R M'} {x : M × M'},
      (x ∈ Submodule.prod p q) = (x.1 ∈ p ∧ x.2 ∈ q) :=
  by sorry

This theorem states that for any type `R` that is a semiring, `M` and `M'` that are commutative monoids, and `p` and `q` that are submodules over `R` of `M` and `M'` respectively, a given element `x` is in the product of submodules `p` and `q` if and only if the first component of `x` is in `p` and the second component is in `q`. This provides a condition for membership in the product of two submodules in terms of their individual memberships.

For any semiring `R`, commutative monoids `M` and `M'`, and submodules `p` of `M` and `q` of `M'`, an element `x` of `M x M'` (the cartesian product of `M` and `M'`) belongs to the product of `p` and `q` if and only if its first component belongs to `p` and its second component belongs to `q`.


theorem MeasureTheory.lintegral_smul_measure :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (c : ENNReal) (f : α → ENNReal),
      ∫⁻ (a : α), f a ∂c • μ = c * ∫⁻ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_smul_measure`, states that for any type `α`, any measurable space `m` derived from `α`, any measure `μ` on that measurable space, and any function `f` from `α` to the extended non-negative real numbers, the Lebesgue integral of `f` with respect to the measure obtained by scaling `μ` by a constant `c` (denoted `c • μ`) is equal to `c` times the integral of `f` with respect to `μ`. In mathematical terms, it denotes that ∫⁻ f d(cμ) = c ∫⁻ f dμ, where ∫⁻ represents the Lebesgue integral.

For any measurable function `f` from a measurable space `(α, m)` to the extended non-negative reals, and any constant `c > 0`, the Lebesgue integral of `f` with respect to the scaled measure `c * m` equals `c` times the integral of `f` with respect to the original measure `m`. In mathematical notation: ∫⁻ f d(c * m) = c * ∫⁻ f dm.


ContinuousLinearMap.hasFDerivAtFilter

theorem ContinuousLinearMap.hasFDerivAtFilter :
    ∀ {𝕜 : 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]
      (e : E →L[𝕜] F) {x : E} {L : Filter E}, HasFDerivAtFilter (⇑e) e x L :=
  by sorry

This theorem states that, for any non-trivially normed field 𝕜, normed addition-commutative groups E and F, and normed spaces over E and F, a continuous linear map `e` from E to F has a Frechet derivative at a point `x` under a given filter `L`. The derivative is the map `e` itself. The Frechet derivative is a generalization of the derivative of a function at a point, suitable for use in infinite-dimensional spaces.

Given a non-trivially normed field 𝕜, a continuous linear map `e` from a normed additive group `E` to another `F`, and a point `x` in `E` under filter `L`, the Frechet derivative of `e` at `x` exists and equals `e`.


/-- If `c` is a colimiting pushout cocone, then we have an `IsPushout f g c.inl c.inr`.  -/
theorem CategoryTheory.IsPushout.of_isColimit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y : C} {f : Z ⟶ X} {g : Z ⟶ Y}
      {c : CategoryTheory.Limits.PushoutCocone f g},
      CategoryTheory.Limits.IsColimit c →
        CategoryTheory.IsPushout f g (CategoryTheory.Limits.PushoutCocone.inl c)
          (CategoryTheory.Limits.PushoutCocone.inr c) :=
  by sorry

The theorem `CategoryTheory.IsPushout.of_isColimit` states that for any category `C`, and any objects `Z`, `X`, `Y` in `C`, if `c` is a pushout cocone formed by two morphisms `f : Z ⟶ X` and `g : Z ⟶ Y`, and if `c` is a colimit cocone, then we can form a pushout structure with `f` and `g` as the incoming morphisms and `c.inl` and `c.inr` (the first and second inclusions of the pushout cocone) as the outgoing morphisms. In other words, if a pushout cocone is a colimit, it induces a pushout structure.

If a pushout cocone in a category is a colimit cocone, then it induces a pushout structure.


/-- **Alias** of `Left.add_pos_of_pos_of_nonneg`. -/
theorem add_pos_of_pos_of_nonneg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, 0 < a → 0 ≤ b → 0 < a + b :=
  by sorry

The theorem `add_pos_of_pos_of_nonneg` states that for any type `α` that has the structure of an `AddZeroClass` and a `Preorder`, and satisfies the `CovariantClass` properties (essentially, these properties state that addition and the order relation interact in a specific, 'nice' way), if `a` and `b` are elements of `α` such that `a` is strictly greater than zero and `b` is nonnegative (greater than or equal to zero), then the sum of `a` and `b` is strictly greater than zero.

If `α` is a type with `AddZeroClass` and `Preorder` structures satisfying covariance properties, and `a` is strictly positive and `b` is nonnegative in `α`, then `a + b` is strictly positive.


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

The theorem `Set.set_smul_subset_iff` states that for any types `α` and `β`, where `α` is a group and `β` is a set on which `α` acts (mulitplicatively), for any sets `A` and `B` of type `β`, and for any element `a` of the group `α`, the scalar multiplication of `a` and `A` is a subset of `B` if and only if `A` is a subset of the scalar multiplication of the inverse of `a` and `B`.

In mathematical terms, this theorem states that for all elements `a` in a group `α`, and for all subsets `A` and `B` of a set `β` on which `α` acts, $aA \subseteq B$ if and only if $A \subseteq a^{-1}B$.

For any group `α` acting multiplicatively on a set `β`, and for all `a` in `α` and subsets `A` and `B` of `β`, $aA \subseteq B$ if and only if $A \subseteq a^{-1}B$.


theorem abs_pow : ∀ {α : Type u_1} [inst : LinearOrderedRing α] (a : α) (n : ℕ), |a ^ n| = |a| ^ n := by sorry

This theorem asserts that for any element `a` of a linear ordered ring and for any natural number `n`, the absolute value of `a` raised to the power `n` is equivalent to the absolute value of `a` raised to the power `n`. In mathematical notation, this can be written as |a^n| = |a|^n.

For any element `a` in a linear ordered ring and natural number `n`, the absolute value of `a` raised to the power `n` equals the absolute value of `a` raised to the power `n`. In symbols: |a^n| = |a|^n.


theorem Ideal.span_singleton_one : ∀ {α : Type u} [inst : Semiring α], Ideal.span {1} = ⊤ := by sorry

The theorem `Ideal.span_singleton_one` states that for any type `α` that has a `Semiring` structure, the ideal generated by the singleton set containing only the number one, `Ideal.span {1}`, is equal to the top element of the lattice of ideals, represented by `⊤`. This means that every element in the semiring can be expressed as a combination of multiples of 1, which is a basic property of number systems following typical algebraic structures like rings and semirings.

The ideal generated by the singleton set {1} in a semiring equals the top element of the ideal lattice.


ClusterPt.mono

theorem ClusterPt.mono :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {f g : Filter X}, ClusterPt x f → f ≤ g → ClusterPt x g := by
  sorry

The theorem `ClusterPt.mono` states that for any type `X` equipped with a topology, any point `x` in `X`, and any two filters `f` and `g` on `X`, if `x` is a cluster point of the filter `f` and `f` is a subfilter of `g` (i.e., `f` is contained within `g`), then `x` is also a cluster point of the filter `g`. Here, a cluster point of a filter `F` on `X` is defined to be a point `x` in `X` such that the intersection of the neighborhood filter of `x` and `F` is not the trivial (or bottom) filter. In simpler terms, the theorem is saying that if a point is close to many points of a certain collection (represented by filter `f`), and that collection is a part of a larger collection (represented by filter `g`), then the point is also close to many points of the larger collection.

If a filter `f` is a subfilter of filter `g` on a topological space `X`, and a point `x` in `X` is a cluster point of `f`, then `x` is also a cluster point of `g`.


theorem Algebra.adjoin_mono :
    ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s t : Set A},
      s ⊆ t → Algebra.adjoin R s ≤ Algebra.adjoin R t :=
  by sorry

This theorem, `Algebra.adjoin_mono`, states that for any commutative semiring `R`, semiring `A`, and algebra structure from `R` to `A`, and for any sets `s` and `t` of elements from `A`, if `s` is a subset of `t`, then the smallest subalgebra of `A` that includes `s` is a subalgebra of the smallest subalgebra of `A` that includes `t`. In other words, if `s` is contained within `t`, then the subalgebra generated by `s` is also contained within the subalgebra generated by `t`.

For any commutative semirings R and A, and an algebra structure from R to A, if s is a subset of t in A, then the subalgebra generated by s is contained in the subalgebra generated by t.


theorem Rat.mul_def' : ∀ {a b c d : ℤ}, b ≠ 0 → d ≠ 0 → Rat.divInt a b * Rat.divInt c d = Rat.divInt (a * c) (b * d) :=
  by sorry

The theorem `Rat.mul_def'` states that for any four integers `a`, `b`, `c`, `d`, where `b` and `d` are both non-zero, the product of the rational numbers formed by dividing `a` by `b` and `c` by `d` equals the rational number formed by dividing the product of `a` and `c` by the product of `b` and `d`. In other words, in the field of rational numbers, the multiplication of fractions holds: `(a/b) * (c/d) = (a*c) / (b*d)`.

For any integers a, b, c, and d with b and d non-zero, (a/b) * (c/d) = (a*c) / (b*d) in the field of rational numbers.


/-- Evaluation of the trivial character  -/
theorem MulChar.one_apply_coe :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (a : Rˣ), 1 ↑a = 1 := by sorry

This theorem states that for any commutative monoid `R` and any commutative monoid with zero `R'`, if you take any element `a` from the group of units of `R`, then applying the trivial character (which is represented by the constant `1`) to `a` (notated as `1 ↑a`) always results in `1`. In other words, the trivial character maps all elements of the group of units to `1`.

For any commutative monoids `R` and `R'` with zero, and for any unit `a` in `R`, the trivial character `1` maps `a` to the identity element `1` in `R'`.


Nat.Primrec'.head

theorem Nat.Primrec'.head : ∀ {n : ℕ}, Nat.Primrec' Vector.head := by sorry

This theorem states that for any natural number `n`, the `head` function, which retrieves the first element from a vector of length at least `1`, is a primitive recursive function. This means that the function `Vector.head` is computationally basic - it can be computed using a finite number of simple operations.

The `Vector.head` function, which returns the first element of a non-empty vector, is a primitive recursive function.


theorem PosNum.to_nat_pos : ∀ (n : PosNum), 0 < ↑n := by sorry

This theorem states that for any positive number `n` (type `PosNum`), when converted to a natural number (using the ↑ symbol), it will be greater than 0. In other words, any positive number remains strictly positive even when viewed as a natural number.

For any positive number `n`, its natural number representation `↑n` is a positive natural number.


theorem Computation.ret_bind :
    ∀ {α : Type u} {β : Type v} (a : α) (f : α → Computation β), Computation.bind (Computation.pure a) f = f a := by
  sorry

The theorem `Computation.ret_bind` states that for all types `α` and `β`, and for any element `a` of type `α` and any function `f` from `α` to `Computation β`, binding the computation that immediately terminates with result `a` (i.e., `Computation.pure a`) with the function `f` is equal to applying `f` directly to `a`. This is an important property of the bind operation in the context of computations, reflecting that binding with a "pure" or immediately terminating computation doesn't change the effect of the function applied.

For all types `α` and `β`, and for any `a : α` and `f : α → Computation β`, `Computation.pure a >>= f = f a`.


theorem MeasureTheory.Measure.le_add_right :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν ν' : MeasureTheory.Measure α}, μ ≤ ν → μ ≤ ν + ν' := by sorry

This theorem states that for any measurable space `α` and three measures `μ`, `ν`, and `ν'` on this space, if `μ` is less than or equal to `ν`, then `μ` is also less than or equal to the sum of `ν` and `ν'`. This result is a property of measures in measure theory, a branch of mathematics related to the concept of size or quantity.

For any measurable spaces `α` and measures `μ`, `ν`, `ν'` on `α` with `μ ≤ ν`, we have `μ ≤ ν + ν'`.


DiffContOnCl.sub

theorem DiffContOnCl.sub :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] {f g : E → F} {s : Set E},
      DiffContOnCl 𝕜 f s → DiffContOnCl 𝕜 g s → DiffContOnCl 𝕜 (f - g) s :=
  by sorry

The theorem `DiffContOnCl.sub` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a normed space over `𝕜` for both `E` and `F`, if two functions `f` and `g` from `E` to `F` are differentially continuous on the closure of a set `s` of `E`, then their difference function `(f - g)` is also differentially continuous on the closure of the same set `s`.

If two functions between normed spaces are differentially continuous on the closure of a set, then their difference function is also differentially continuous on the closure of that set.


theorem Filter.mem_prod_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {f : Filter α} {g : Filter β},
      s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s :=
  by sorry

This theorem states that for any types `α` and `β`, any set `s` of pairs `(α, β)`, and any filters `f` on `α` and `g` on `β`, the set `s` is in the product filter of `f` and `g` if and only if there exist subsets `t₁` and `t₂` in `f` and `g` respectively, such that the product set of `t₁` and `t₂` is a subset of `s`. In other words, `s` is included in the product filter of `f` and `g` exactly when it includes a product of a set from `f` and a set from `g`.

For filters $f$ on type $\alpha$ and $g$ on type $\beta$, the set $s$ of pairs $(a, b): \alpha \times \beta$ is in the product filter of $f$ and $g$ if and only if there exist $A \subseteq \alpha$ in $f$ and $B \subseteq \beta$ in $g$ such that $A \times B \subseteq s$.


theorem Ideal.span_singleton_eq_span_singleton :
    ∀ {α : Type u} [inst : CommRing α] [inst_1 : IsDomain α] {x y : α},
      Ideal.span {x} = Ideal.span {y} ↔ Associated x y :=
  by sorry

This theorem states that for any commutative ring, which is also an integral domain, and for any two elements 'x' and 'y' from the ring, the ideal generated by the singleton set containing 'x' is equal to the ideal generated by the singleton set containing 'y' if and only if 'x' and 'y' are associated. In this case, 'associated' means there exists a unit 'u' in the ring such that 'x' times 'u' equals 'y'. In mathematical terms, we have 'x' and 'y' are associated if there exists a unit 'u' such that `x * u = y`.

For any commutative ring that is an integral domain, two elements x and y are associated if and only if the ideals generated by {x} and {y} are equal.


/-- The product of the factors is the original number  -/
theorem PNat.prod_factorMultiset : ∀ (n : ℕ+), PrimeMultiset.prod (PNat.factorMultiset n) = n := by sorry

This theorem states that for any given positive natural number `n`, the product of its prime factors, when considered as a multiset, equals the original number `n`. In mathematical terms, it's saying that if you decompose a positive integer into its prime factors and then multiply those prime factors together, you will get back the original number. This is a fundamental property of prime factorization.

The product of the prime factors of a positive integer, each raised to the power of their multiplicity in its prime factorization, equals the original integer.


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

This theorem states that for any type `R` with a non-unital, non-associative semiring structure, and any set `s` of elements of `R`, the set `s` is included in (or is a subset of) the non-unital subsemiring generated by `s`. In other words, every element of `s` is also an element of the non-unital subsemiring generated by `s`.

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


theorem lt_self_iff_false : ∀ {α : Type u} [inst : Preorder α] (x : α), x < x ↔ False := by sorry

This theorem, `lt_self_iff_false`, states that for any type, `α`, equipped with a preorder relation, an element `x` of type `α` cannot be strictly less than itself. In other words, `x < x` is always false. The principle of this theorem reflects the antisymmetry of preorders in mathematics, where an element cannot be both less than and greater than another element, especially itself.

For any type `α` with a preorder relation, `x < x` is always false.


theorem Order.max_of_succ_le :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, Order.succ a ≤ a → IsMax a := by sorry

The theorem `Order.max_of_succ_le` states that for any type `α` that has a preordering and a successor order, if the successor of an element `a` is less than or equal to `a`, then `a` is a maximal element of `α`. Here, `a` being a maximal element means that there is no element in `α` that is strictly greater than `a`.

If `α` is a type with a preordering and a successor order, and `a` is an element of `α` with `a ≤ succ a`, then `a` is the maximum element of `α`.


ContDiffOn.congr

theorem ContDiffOn.congr :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f f₁ : E → F} {n : ℕ∞}, ContDiffOn 𝕜 n f s → (∀ x ∈ s, f₁ x = f x) → ContDiffOn 𝕜 n f₁ s :=
  by sorry

The theorem `ContDiffOn.congr` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, and `F`, where `E` and `F` are normed spaces over `𝕜`, if a function `f` from `E` to `F` is continuously differentiable on a set `s` of `E` up to a certain order `n`, and there exists another function `f₁` which is equal to `f` for all elements in the set `s`, then `f₁` is also continuously differentiable on `s` up to the same order `n`.

If `f` is continuously differentiable of order `n` on `s` in `E` to `F`, and there exists `f₁` equal to `f` on `s`, then `f₁` is also continuously differentiable of order `n` on `s`.


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

This theorem, `mem_ball_zero_iff`, states that for any type `E` that forms a semi-normed add group, any element `a` of type `E`, and any real number `r`, `a` is an element of the metric ball centered at 0 with radius `r` if and only if the semi-norm of `a` is less than `r`. In other words, the point `a` is within the open ball of radius `r` centered at the origin in the metric space defined by the semi-norm if its distance from the origin, measured by the semi-norm, is less than `r`.

For any semi-normed add group type `E`, element `a` of `E`, and real number `r`, `a` belongs to the open metric ball of radius `r` centered at 0 if and only if the semi-norm of `a` is less than `r`.


theorem Polynomial.eval_mul_X :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R},
      Polynomial.eval x (p * Polynomial.X) = Polynomial.eval x p * x :=
  by sorry

This theorem, named `Polynomial.eval_mul_X`, states that for any type `R` that forms a semiring and any polynomial `p` of type `R`, and any element `x` of `R`, the value of the polynomial `p` multiplied by the polynomial variable `X` evaluated at `x` is equal to the value of the polynomial `p` evaluated at `x` multiplied by `x`. In mathematical terms, this can be expressed as `eval(x, p*X) = eval(x, p) * x`, where `eval` is a function that evaluates a polynomial at a certain point, `p` is a polynomial, `X` is the polynomial variable or indeterminate, and `x` is a point in the semiring `R`.

For any semiring `R`, polynomial `p` over `R`, and element `x` in `R`, `eval(x, p*X) = eval(x, p) * x`.


/-- See note [partially-applied ext lemmas].  -/
theorem IsScalarTower.of_algebraMap_eq' :
    ∀ {R : Type u} {S : Type v} {A : Type w} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
      [inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A],
      algebraMap R A = RingHom.comp (algebraMap S A) (algebraMap R S) → IsScalarTower R S A :=
  by sorry

This theorem, named `IsScalarTower.of_algebraMap_eq'`, states that for any three given types `R`, `S`, and `A` with the associated structures of commutative semirings for `R` and `S`, semiring for `A`, and algebra structures between `R` and `S`, `S` and `A`, and `R` and `A`, if the algebra map from `R` to `A` is equivalent to the composition of the algebra map from `S` to `A` and the algebra map from `R` to `S`, then `R`, `S`, and `A` form a scalar tower. In mathematical terms, if $\phi: R\rightarrow A$ is the same as the composition of $\psi: S\rightarrow A$ and $\chi: R\rightarrow S$ (i.e., $\phi = \psi \circ \chi$), then `R`, `S`, and `A` obey the compatibility condition of scalar multiplication in a scalar tower.

If the algebra maps from `R` to `A` and from `S` to `A` via `χ` and `ψ`, respectively, satisfy `ψ ∘ χ = α` for some algebra map `α` from `R` to `S`, then `R`, `S`, and `A` form a scalar tower.


theorem Nat.cast_id : ∀ (n : ℕ), ↑n = n := by sorry

This theorem states that for any natural number 'n', the coercion (casting) of 'n' to a natural number is equal to 'n' itself. In other words, if you have a natural number and you convert it to a natural number, you will still have the same number. This is a fundamental property of typecasting within the set of natural numbers in Lean 4.

For all natural numbers n, the coercion of n to a natural number is equal to n itself. (or) The coercion from a natural number to itself is the identity function.


PMF.ext

theorem PMF.ext : ∀ {α : Type u_1} {p q : PMF α}, (∀ (x : α), p x = q x) → p = q := by sorry

The theorem `PMF.ext` states that, for any type `α` and any two probability mass functions `p` and `q` over `α`, if for every element `x` of type `α`, `p` evaluated at `x` equals `q` evaluated at `x`, then `p` is equal to `q`. In other words, two probability mass functions are equal if they assign the same probability to each element in their domain.

If two probability mass functions over a type assign the same probability to every element, then they are equal.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.6 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), (0 ≤ ‖a‖) = True := by sorry

This theorem, named `Mathlib.Analysis.Normed.Group.Basic._auxLemma.6`, states that for any type `E` that forms a seminormed add group, the norm of any element `a` of type `E` is always non-negative. In mathematical terms, it says that for every `a` in `E`, `0 ≤ ‖a‖` is always true.

For any seminormed add group `E`, the norm of every element `a` in `E` is non-negative (i.e., `0 ≤ ‖a‖`).


theorem Filter.mem_bot : ∀ {α : Type u} {s : Set α}, s ∈ ⊥ := by sorry

This theorem states that for every type `α` and every set `s` of type `α`, `s` is an element of the smallest filter, denoted by `⊥`. In mathematical terms, this means that the smallest (or "bottom") filter contains every set from a given type.


List.Perm.rfl

theorem List.Perm.rfl : ∀ {α : Type u_1} {l : List α}, List.Perm l l := by sorry

The theorem `List.Perm.rfl` states that for all types `α` and for any list `l` of type `α`, the list `l` is permutationally identical to itself. In other words, the order of elements in the list `l` can be rearranged to form the list `l` itself, which is a trivial case of a permutation because it involves no rearrangement.

For all types α and lists l of length n over α, the list l is a permutation of itself. (Note: This statement assumes the standard definition of list permutations in Lean, which may differ from standard mathematical definitions depending on context.)


theorem le_imp_le_of_lt_imp_lt :
    ∀ {α : Type u} {β : Type u_1} [inst : Preorder α] [inst_1 : LinearOrder β] {a b : α} {c d : β},
      (d < c → b < a) → a ≤ b → c ≤ d :=
  by sorry

This theorem states that for any types `α` and `β` with a preorder on `α` and a linear order on `β`, and for any elements `a`, `b` of `α` and `c`, `d` of `β`, if it is true that `d < c` implies `b < a`, then if `a ≤ b` it must follow that `c ≤ d`. This theorem is a formalization of a certain property of ordered sets.

If `α` is a preordered type, `β` is linearly ordered, `a ≤ b` in `α`, and `d < c` in `β`, then `c ≤ d`.


theorem TensorProduct.tmul_smul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {R' : Type u_2} [inst_1 : Monoid R'] {M : Type u_4} {N : Type u_5}
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : DistribMulAction R' M] [inst_7 : SMulCommClass R R' M] [inst_8 : DistribMulAction R' N]
      [inst_9 : TensorProduct.CompatibleSMul R R' M N] (r : R') (x : M) (y : N), x ⊗ₜ[R] (r • y) = r • x ⊗ₜ[R] y :=
  by sorry

This theorem, named `TensorProduct.tmul_smul`, states that for any given commutative semiring `R`, monoid `R'`, additive commutative monoids `M` and `N`, such that `M` and `N` are modules over `R`, `M` and `N` are distributive over multiplication action by `R'`, and the scalar multiplication is compatible with the tensor product, the following equality holds: for any element `r` from `R'`, and elements `x` from `M` and `y` from `N`, the tensor product of `x` and the scalar multiplication of `r` and `y` is equal to the scalar multiplication of `r` and the tensor product of `x` and `y`. In mathematical notation, this is saying that for all `r`, `x`, and `y`, \(x \otimes (r \cdot y) = r \cdot (x \otimes y)\).

For any commutative semiring `R`, monoid `R'`, additive commutative monoids `M` and `N` being `R`-modules, and assuming distributivity and compatibility of scalar multiplication with the tensor product, the equality `x ⊗ (r * y) = r ⊗ (x ⊗ y)` holds for all `r` in `R'` and elements `x` from `M` and `y` from `N`.


theorem MonoidHom.mrange_eq_map :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f : F), MonoidHom.mrange f = Submonoid.map f ⊤ :=
  by sorry

The theorem `MonoidHom.mrange_eq_map` states that for any given types `M` and `N` each equipped with a `MulOneClass` structure (a data type that has both multiplication and a multiplicative identity), a type `F` that is `FunLike` (functions from `M` to `N`), and `MonoidHomClass` (the class of multiplication-preserving functions from `M` to `N`), the range of any monoid homomorphism `f` of type `F` is equal to the image of the entire submonoid of `M` under this homomorphism `f`. Intuitively, this means that every element in the range of a monoid homomorphism `f` is the output of `f` when applied to some element of `M`, and vice versa.

For any types `M` and `N` with `MulOneClass`, any `FunLike` type `F` to `N`, and any `MonoidHomClass` function `f : F`, the range of `f` equals the image of the submonoid of `M` under `f`.


theorem eq_sub_of_add_eq : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a + c = b → a = b - c := by sorry

This theorem states that for all types `G` that have an `AddGroup` structure, and for any three elements `a`, `b`, and `c` of `G`, if `a + c` is equal to `b`, then `a` is equal to `b - c`. In other words, this theorem is a statement about the algebra of groups: if adding an element `c` to `a` gives `b`, you can get `a` back by subtracting `c` from `b`.

If `a`, `b`, and `c` are elements of a group `G` with `AddGroup` structure such that `a + c = b`, then `a = b - c`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.4 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {φ : FirstOrder.Language.BoundedFormula L α l} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.not φ) v xs =
        ¬FirstOrder.Language.BoundedFormula.Realize φ v xs :=
  by sorry

This theorem, named `_auxLemma.4` in the `Mathlib.ModelTheory.Semantics` module, asserts that for any first-order language `L`, any structure `M` of `L`, any type `α`, any natural number `l`, any bounded formula `φ` of `L` with `α` and `l`, any function `v` from `α` to `M`, and any function `xs` from `Fin l` to `M`, the realization of the negation of the bounded formula `φ` with respect to `v` and `xs` is the negation of the realization of `φ` with `v` and `xs`. In simpler terms, it states that negating a formula in a first-order language and realizing it gives the same result as realizing the formula first and then negating the result.

For any first-order language L, structure M, type α, natural number l, bounded formula φ of L with variables α and l, functions v : α -> M and xs : Fin l -> M, the realization of the negation of φ with respect to v and xs is equal to the negation of the realization of φ with v and xs.


theorem Nat.le_floor_iff :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      0 ≤ a → (n ≤ ⌊a⌋₊ ↔ ↑n ≤ a) :=
  by sorry

This theorem, `Nat.le_floor_iff`, states that for any type `α` that is a linear ordered semiring and has a floor semiring structure, and given any `α` value `a` that is non-negative, and any natural number `n`, `n` is less than or equal to the floor of `a` if and only if `n` when promoted to `α` is less than or equal to `a`. In other words, a natural number `n` is less than or equal to the floor of a non-negative real number `a` if and only if `n` as a real number is less than or equal to `a`.

For any non-negative real number `a` and natural number `n`, `n ≤ floor a` if and only if `n ≤ a` as real numbers.


HasStrictFDerivAt.comp

/-- The chain rule for derivatives in the sense of strict differentiability.  -/
theorem HasStrictFDerivAt.comp :
    ∀ {𝕜 : 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]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {f' : E →L[𝕜] F} (x : E)
      {g : F → G} {g' : F →L[𝕜] G},
      HasStrictFDerivAt g g' (f x) →
        HasStrictFDerivAt f f' x → HasStrictFDerivAt (fun x => g (f x)) (ContinuousLinearMap.comp g' f') x :=
  by sorry

This theorem states the chain rule for derivatives in the sense of strict differentiability. Given a nontrivially normed field `𝕜`, normed add commutative groups `E`, `F`, and `G`,  and normed spaces over `𝕜` for `E`, `F`, and `G`; if `f : E → F` is strictly differentiable at a point `x` with derivative `f' : E →L[𝕜] F`, and `g : F → G` is strictly differentiable at `f(x)` with derivative `g' : F →L[𝕜] G`, then the composed function `(fun x => g (f x))` is also strictly differentiable at `x` and its derivative is the continuous linear map `ContinuousLinearMap.comp g' f'`.

If functions `f : E → F` and `g : F → G` are strictly differentiable at points `x` and `f(x)`, respectively, then the composition `g ∘ f` is strictly differentiable at `x` with derivative `g' ∘ f'`.


Monovary.monovaryOn

theorem Monovary.monovaryOn :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
      Monovary f g → ∀ (s : Set ι), MonovaryOn f g s :=
  by sorry

The theorem `Monovary.monovaryOn` states that for any types `ι`, `α`, and `β`, where `α` and `β` have a preorder relationship, any functions `f : ι → α` and `g : ι → β` that monovary, and any set `s` of type `ι`, `f` and `g` also monovary on `s`. In other words, if `f` and `g` satisfy the property that for all indices `i` and `j`, `g i < g j` implies `f i ≤ f j`, then this property also holds for all `i` and `j` that belong to the set `s`.

If `f : ι → α` and `g : ι → β` are monovarying functions with `α` and `β` having a preorder relationship, and `g` is monotone on `ι`, then `f` and `g` are monovarying on any subset `s` of `ι`.


theorem Set.right_mem_Ioc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ∈ Set.Ioc a b ↔ a < b := by sorry

This theorem states that for any type `α` that has a predefined `Preorder` relation, and for any two elements `a` and `b` of this type, `b` is an element of the left-open, right-closed interval between `a` and `b` if and only if `a` is less than `b`. In mathematical terms, for a ≤-preordered set α and elements a, b ∈ α, b belongs to the interval (a, b] if and only if a < b.

For any preordered set (α, ≤) and elements a, b in α, b lies in the left-open, right-closed interval (a, b] if and only if a < b.


theorem Mathlib.Data.Complex.Basic._auxLemma.2 : ∀ {z : ℝ}, (↑z = 0) = (z = 0) := by sorry

This theorem states that for every real number `z`, the complex equivalent of `z` (denoted as `↑z`) is equal to zero if and only if `z` itself is equal to zero. In other words, a real number and its complex counterpart are both zero at the same time, and no other situation will make them equal to zero simultaneously.

For every real number `z`, `↑z = 0` if and only if `z = 0`.


theorem Ordinal.enum_typein :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] (a : α), Ordinal.enum r (Ordinal.typein r a) ⋯ = a := by
  sorry

The theorem `Ordinal.enum_typein` states that for any type `α` and a relation `r` on `α` which forms a well-order, and for any element `a` of type `α`, when we compute the ordinal type of `a` relative to `r` using the `Ordinal.typein` function, and then use this ordinal to enumerate the elements of `α` in the order dictated by `r` using the `Ordinal.enum` function, we get back the same element `a`. In other words, the processes of computing the ordinal type of an element and enumerating elements of a well-ordered set according to their ordinal types are inverses of each other under this well-ordering.

For any well-ordered type `(α, r)` and element `a` of `α`, `Ordinal.enum (Ordinal.typein r a) = a`.


PartialHomeomorph.mapsTo

theorem PartialHomeomorph.mapsTo :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), Set.MapsTo (↑e) e.source e.target :=
  by sorry

The theorem `PartialHomeomorph.mapsTo` states that for all types `X` and `Y`, which are equipped with a topological space structure, and any partial homeomorphism `e` from `X` to `Y`, the function `e` maps its source set into its target set. In other words, if an element belongs to the source set of `e`, its image under `e` belongs to the target set of `e`.

For any partial homeomorphism between topological spaces `e : X ↫ Y`, the domain of `e` is a subset of the range of `e`.


lp.ext

theorem lp.ext :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] {f g : ↥(lp E p)},
      ↑f = ↑g → f = g :=
  by sorry

The theorem `lp.ext` states that for any type `α`, any function `E` from `α` to a type, any extended nonnegative real number `p`, any instance of a normed additive commutative group over the range of `E`, and any two elements `f` and `g` of the `lp` space of `E` with respect to `p`, if the underlying elements of `f` and `g` in the pre-Lp space are equal, then `f` and `g` themselves are equal in the `lp` space. In other words, this theorem asserts the extensionality of the `lp` function.

If `α` is any type, `E` is any function from `α` to a normed additive commutative group, `p` is any extended nonnegative real number, and `f` and `g` are in the `lp` space of `E` with respect to `p` with equal underlying elements in the pre-`Lp` space, then `f` and `g` are equal in the `lp` space.


theorem Nat.ofDigits_digits : ∀ (b n : ℕ), Nat.ofDigits b (Nat.digits b n) = n := by sorry

The theorem `Nat.ofDigits_digits` asserts that for any pair of natural numbers `b` and `n`, when we convert `n` into a list of digits `Nat.digits` in base `b` and then interpret this list of digits as a number in base `b` using `Nat.ofDigits`, we get back the original number `n`. In other words, it shows that the processes of digit extraction and reconstruction in base `b` are inverse to each other. This ensures the correctness of the base `b` digit operations in the natural number context.

For any base `b` and natural number `n`, `Nat.ofDigits b (Nat.digits n) = n`.


theorem ENNReal.ofReal_lt_top : ∀ {r : ℝ}, ENNReal.ofReal r < ⊤ := by sorry

The theorem `ENNReal.ofReal_lt_top` states that for any real number `r`, the `ENNReal.ofReal r` function always gives a result that is less than infinity. In other words, the function `ENNReal.ofReal` maps any real number to a nonnegative extended real number (including zero), but never to infinity. Therefore, the image of this function does not include the "positive infinity" value.

For all real numbers r, the image of `ENNReal.ofReal r` is a non-positive extended real number.


theorem Finsupp.mapRange_single :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_7} [inst : Zero M] [inst_1 : Zero N] {f : M → N} {hf : f 0 = 0} {a : α}
      {b : M}, (Finsupp.mapRange f hf fun₀ | a => b) = fun₀ | a => f b :=
  by sorry

This theorem states that for any types `α`, `M` and `N`, given a function `f` mapping from `M` to `N` that preserves zero (meaning `f` of zero equals zero), and any elements `a` of type `α` and `b` of type `M`, the `mapRange` function applied to a singleton function (a function that maps `a` to `b` and everything else to zero) equals a singleton function that maps `a` to `f(b)`. The `mapRange` function is essentially mapping `f` across all values in the range of the singleton function, but since the only non-zero value in the range is `b`, it only affects the mapping of `a`.

For any types `α`, `M`, `N`, and functions `f : M -> N` preserving zero, `mapRange (λ x => if h : x = a then b else 0) (singleton a) = singleton (f b) : α -> N`, where `a : α` and `b : M`.


theorem deriv_circleMap : ∀ (c : ℂ) (R θ : ℝ), deriv (circleMap c R) θ = circleMap 0 R θ * Complex.I := by sorry

This theorem states that for any complex number `c` and real numbers `R` and `θ`, the derivative of the circle map function at `θ` is equal to the result of the circle map function evaluated at `0`, `R` and `θ` multiplied by the imaginary unit. The `circleMap` function here represents the exponential map that maps `θ` to `c + Re^{θi}`. The output of this function is a point on the complex plane forming a circle around `c` with radius `|R|`. The theorem essentially describes how changes in `θ` affect the point on the circle.

The derivative of the complex exponential function (circle map) at a real angle `θ` is equal to `R * i` times the result of the function evaluated at `θ`, where `c` is the center of the circle and `R` is the radius.


theorem QuotientGroup.mk_surjective :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α}, Function.Surjective QuotientGroup.mk := by sorry

This theorem states that for any type `α` that has a group structure and any subgroup `s` of `α`, the canonical map from the group `α` to the quotient group `α ⧸ s`, denoted by `QuotientGroup.mk`, is surjective. In other words, every element in the quotient group `α ⧸ s` is the image of some element from the group `α` under the `QuotientGroup.mk` map.

For any group `α` and subgroup `s`, the canonical quotient map `QuotientGroup.mk : α → α / s` is surjective.


theorem Filter.Tendsto.prod_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_6} {f : α → γ} {g : β → δ} {a : Filter α} {b : Filter β}
      {c : Filter γ} {d : Filter δ},
      Filter.Tendsto f a c → Filter.Tendsto g b d → Filter.Tendsto (Prod.map f g) (a ×ˢ b) (c ×ˢ d) :=
  by sorry

The theorem `Filter.Tendsto.prod_map` in Lean 4 states that for any types `α`, `β`, `γ`, and `δ`, and for any functions `f : α → γ` and `g : β → δ`, alongside with filters `a` on `α`, `b` on `β`, `c` on `γ` and `d` on `δ`, if `f` tends to `c` along `a` and `g` tends to `d` along `b`, then the function `Prod.map f g` that applies `f` to the first component and `g` to the second component of a pair, tends to the product filter `c ×ˢ d` along the product filter `a ×ˢ b`. In other words, if each function tends individually towards their respective filters, then the product function tends towards the product of the filters when applied to a pair of inputs.

If functions `f : α → γ` and `g : β → δ` tend to filters `c` and `d`, respectively, then `Prod.map f g` tends to the product filter `c ×ˢ d`.


theorem ne_or_eq : ∀ {α : Sort u_1} (x y : α), x ≠ y ∨ x = y := by sorry

This theorem, `ne_or_eq`, states that for any type `α` and any two elements `x` and `y` of that type, `x` and `y` are either not equal (`x ≠ y`) or they are equal (`x = y`). Basically, this theorem represents the law of excluded middle for equality, asserting that either `x` equals `y` or `x` does not equal `y`, with no third option possible.

For all types `α` and elements `x, y` of type `α`, `x = y` or `x ≠ y`.


theorem Finset.coe_Iio :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α), ↑(Finset.Iio a) = Set.Iio a := by
  sorry

This theorem states that for any type `α` that has a preorder (meaning `α` has a binary relation that is reflexive and transitive) and a locally finite order with a bottom element, the coersion of the finset `Iio a` (which is a set of elements `x` such that `x` is less than `a`) is equal to the set `Iio a` (which is a left-infinite right-open interval, meaning it includes all elements less than `a` but not `a` itself). In other words, the elements of the finset `Iio a` make up exactly the set `Iio a`.

For any type `α` with a preorder, locally finite order, and a bottom element, the coercion of the finset `Iio a` equals the set of elements strictly less than `a`.


theorem Finset.coe_Ioi :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] (a : α), ↑(Finset.Ioi a) = Set.Ioi a := by
  sorry

The theorem `Finset.coe_Ioi` is stating that for any type `α` which has a preorder relation and a locally finite order, for any element `a` of that type, the coercion of the finset of elements greater than `a` (expressed as `Finset.Ioi a`) is equal to the set of elements greater than `a` (expressed as `Set.Ioi a`). Essentially, this theorem establishes the equivalence between a certain finset and a certain set in the given context.

For any type `α` with a preorder and locally finite order, `Finset.Ioi a = Set.Ioi a`. That is, the coercion of the finset of elements greater than `a` is equal to the set of elements greater than `a`.


ContDiffWithinAt.prod

/-- The cartesian product of `C^n` functions at a point in a domain is `C^n`.  -/
theorem ContDiffWithinAt.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {n : ℕ∞} {s : Set E} {f : E → F} {g : E → G},
      ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => (f x, g x)) s x :=
  by sorry

The theorem `ContDiffWithinAt.prod` states that for any normed field `𝕜` with non-trivial norms, normed additive commutative groups `E`, `F`, and `G` with a normed vector space structure over `𝕜`, a point `x` in `E`, a natural number `n` or infinity `ℕ∞`, a set `s` of elements in `E`, and functions `f` and `g` mapping `E` to `F` and `G` respectively. If these functions `f` and `g` are continuously differentiable `n` times within the set `s` at the point `x`, then the function mapping `x` to the pair `(f x, g x)` is also continuously differentiable `n` times within the set `s` at the point `x`. This theorem thus asserts the compatibility of multi-variable `C^n` differentiability and the cartesian product operation on functions.

If functions `f: E → F` and `g: E → G`, each continuously differentiable `n` times at `x` in `E`, then the function `(f, g): E → F × G` is also continuously differentiable `n` times at `x`.


theorem closure_closure : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], closure (closure s) = closure s := by
  sorry

The theorem `closure_closure` states that for any type `X` and any set `s` of type `X`, given that `X` has a topological space structure, the closure of the closure of `s` is equal to the closure of `s`. In other words, taking successive closures of a set does not change the set after the first closure. This is important in topology because the closure of a set, which includes the set itself along with its limit points, provides a way to 'complete' the set in the surrounding space.

For any topological space (X, τ) and subset s ∈ X, the closure of the closure of s equals the closure of s. In symbols, cl(cl(s)) = cl(s).


theorem Polynomial.natDegree_of_subsingleton :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} [inst_1 : Subsingleton R], Polynomial.natDegree p = 0 := by
  sorry

The theorem `Polynomial.natDegree_of_subsingleton` states that for any type `R` with a `Semiring` structure, if `R` is a subsingleton (i.e., it has at most one element), then the natural degree of any polynomial `p` with coefficients in `R` is 0. In effect, this theorem shows that in a context where the ring of coefficients only contains one element (like the trivial ring), all polynomials are considered as having a degree of 0.

If a type `R` equipped with a `Semiring` structure is a subsingleton, then the natural degree of any polynomial over `R` is 0.


theorem GaloisCoinsertion.l_le_l_iff :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → ∀ {a b : α}, l a ≤ l b ↔ a ≤ b :=
  by sorry

This theorem states that for any types `α` and `β`, and any functions `l : α → β` and `u : β → α`, where `α` and `β` both have a preorder (a binary relation that is reflexive and transitive), if `l` and `u` form a Galois coinsertion, then for all elements `a` and `b` of `α`, `l a` is less than or equal to `l b` if and only if `a` is less than or equal to `b`. A Galois coinsertion is a special relationship between two functions, where one function is the left adjoint and the other is the right adjoint, and the function composition from right to left is less than or equal to the identity function.

For functions `l : α → β` and `u : β → α` between preordered types `α` and `β`, if `l` and `u` form a Galois coinsertion, then `l a ≤ l b` if and only if `a ≤ b`.


theorem Filter.map₂_eq_bot_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β},
      Filter.map₂ m f g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
  by sorry

The theorem `Filter.map₂_eq_bot_iff` states that for any types `α`, `β` and `γ`, and any function `m` from `α` and `β` to `γ`, and any Filters `f` on `α` and `g` on `β`, the image of the binary function `m` on Filters `f` and `g` being the bottom filter (the filter which contains all sets) is equivalent to either `f` being the bottom filter or `g` being the bottom filter. In mathematical terms, \(Filter.map₂(m, f, g) = ⊥\) if and only if \(f = ⊥\) or \(g = ⊥\).

For any functions `m` from `α × β` to `γ` and filters `f` on `α` and `g` on `β` in Lean, `Filter.map₂(m, f, g) = ⊥` if and only if `f = ⊥` or `g = ⊥`.


Eq.trans

/-- Equality is transitive: if `a = b` and `b = c` then `a = c`.

Because this is in the `Eq` namespace, if you have variables or expressions
`h₁ : a = b` and `h₂ : b = c`, you can use `h₁.trans h₂ : a = c` as shorthand
for `Eq.trans h₁ h₂`.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem Eq.trans : ∀ {α : Sort u} {a b c : α}, a = b → b = c → a = c := by sorry

This theorem states that equality is transitive in Lean 4. In other words, if you have two equalities, `a = b` and `b = c`, (represented as `h₁ : a = b` and `h₂ : b = c`), you can use the transitivity of equality to infer that `a = c`. This can be done using the shorthand `h₁.trans h₂ : a = c` or the longer form `Eq.trans h₁ h₂`. This theorem is applicable for any sort `α` and variables `a`, `b`, and `c` of sort `α`.

If `a = b` and `b = c`, then `a = c` (transitivity of equality).


theorem MvPolynomial.rename_C :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (f : σ → τ) (r : R),
      (MvPolynomial.rename f) (MvPolynomial.C r) = MvPolynomial.C r :=
  by sorry

The theorem `MvPolynomial.rename_C` states that for any types `σ`, `τ`, and `R` with `R` being a commutative semiring, any function `f` from `σ` to `τ`, and any element `r` of `R`, the act of renaming variables in a constant multivariable polynomial (using the function `MvPolynomial.rename f`) does not change the polynomial. In other words, if we have a constant multivariable polynomial `MvPolynomial.C r` (which is a polynomial with a constant value `r`), renaming its variables using any function `f` will still yield the same constant polynomial `MvPolynomial.C r`.

For any commutative semiring `R`, function `f` from type `σ` to type `τ`, and constant polynomial `MvPolynomial.C r` over `R`, the renamed polynomial `MvPolynomial.rename f (MvPolynomial.C r)` is equal to the original constant polynomial `MvPolynomial.C r`.


theorem ite_eq_right_iff :
    ∀ {α : Sort u_1} {a b : α} {P : Prop} [inst : Decidable P], (if P then a else b) = b ↔ P → a = b := by sorry

This theorem states that for any type `α`, any two values `a` and `b` of type `α`, and any proposition `P`, if `P` is decidable, then the conditional expression "if `P` then `a` else `b`" being equal to `b` is logically equivalent to stating that if `P` holds, then `a` equals `b`. In other words, if the result of the conditional expression is `b`, it either means that `P` is false, or `P` is true, but `a` equals `b`.

For any type `α`, decidable proposition `P` over `α`, values `a`, `b` of type `α`, if `P` implies `a = b`, then the if-then-else expression "if `P` then `a` else `b`" equals `b`.


theorem ConvexCone.add_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      (S : ConvexCone 𝕜 E) ⦃x : E⦄, x ∈ S → ∀ ⦃y : E⦄, y ∈ S → x + y ∈ S :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and additively commutative monoid `E`, if `S` is a convex cone in `E` over `𝕜`, then for any elements `x` and `y` in `S`, their sum `x + y` is also in `S`. In other words, the convex cone `S` is closed under addition.

If `S` is a convex cone over an ordered semiring `𝕜` in an additively commutative monoid `E`, then `x`, `y` in `S` implies `x + y` is in `S`.


theorem mul_pos_of_neg_of_neg :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] [inst_1 : ExistsAddOfLE α] {a b : α}, a < 0 → b < 0 → 0 < a * b :=
  by sorry

This theorem states that for any type `α` that is a strictly ordered semiring (a mathematical structure with two operations, addition and multiplication, satisfying certain properties such as associativity, commutativity, and distributivity) and supports the existence of an addition operation for any two elements where one is less than or equal to the other, if `a` and `b` are two elements of `α` such that both `a` and `b` are less than zero, then the product of `a` and `b` is greater than zero. In other words, it asserts that the product of two negative numbers is positive in any strictly ordered semiring where addition of elements obeying a certain inequality is defined.

In a strictly ordered semiring, the product of two negative elements is positive.


theorem Nat.mul_mod_right : ∀ (m n : ℕ), m * n % m = 0 := by sorry

This theorem is stating that for any two natural numbers `m` and `n`, the remainder of the product of `m` and `n` divided by `m` is always zero. In other words, `m * n` is always a multiple of `m`, which is a basic property of integer multiplication and division.

For all natural numbers m and n, m * n is a multiple of m.


/-- The dimension of a finite dimensional space is preserved under linear equivalence.  -/
theorem LinearEquiv.finrank_eq :
    ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M₂]
      [inst_3 : Module R M] [inst_4 : Module R M₂],
      (M ≃ₗ[R] M₂) → FiniteDimensional.finrank R M = FiniteDimensional.finrank R M₂ :=
  by sorry

The theorem `LinearEquiv.finrank_eq` states that the dimension of a finite dimensional space is preserved under linear equivalence. More specifically, for any ring `R` and any two `R`-modules `M` and `M₂`, if there exists a linear equivalence (an invertible linear transformation) from `M` to `M₂`, then the finite rank (or dimension, in the case of vector spaces) of `M` is equal to the finite rank of `M₂`. This is a fundamental result in linear algebra, stating essentially that the dimension of a vector space (or more generally, a module) is an invariant under isomorphism.

If two finite-dimensional modules over a ring are linearly equivalent, then they have equal dimensions.


theorem Ordinal.opow_isNormal : ∀ {a : Ordinal.{u_1}}, 1 < a → Ordinal.IsNormal fun x => a ^ x := by sorry

The theorem `Ordinal.opow_isNormal` states that for any ordinal `a` such that `a` is greater than 1, the function `f` defined as `f(x) = a^x` is a normal ordinal function. A normal ordinal function is a function that is strictly increasing (i.e., for any ordinal `o`, `f(o)` is less than `f` of the successor of `o`) and is order-continuous (i.e., for any limit ordinal `o`, the image `f(o)` is the supremum of `f(a)` for all `a` that are less than `o`).

For any ordinal `a` greater than 1, the function `f(x) = a^x` is a normal ordinal function. (i.e., it is strictly increasing and order-continuous).


theorem bot_inf_eq : ∀ {α : Type u} [inst : SemilatticeInf α] [inst_1 : OrderBot α] (a : α), ⊥ ⊓ a = ⊥ := by sorry

The theorem `bot_inf_eq` states that for all types `α` that are equipped with a semilattice structure (`SemilatticeInf α`) and a bottom element (`OrderBot α`), the infimum (greatest lower bound) of any element `a` of type `α` and the bottom element is always the bottom element. In other words, `⊥ ⊓ a = ⊥` for any `a` in `α`. This captures the intuitive idea that the greatest lower bound of any element and the least possible element is the least possible element itself.

For any semilattice type `α` with a bottom element, the infimum of any element `a` is the bottom element itself: `∀α : Type, SemilatticeInf α OrderBot α → ∀a : α, ⊥ = ⊥⊓a`.


theorem Pi.sup_apply :
    ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → Sup (α' i)] (f g : (i : ι) → α' i) (i : ι),
      (f ⊔ g) i = f i ⊔ g i :=
  by sorry

This theorem states that for every type `ι`, for every function `α'` mapping each element of `ι` to a type, and given a supremum structure for each `α' i`, for any two functions `f` and `g` from `ι` to `α' i`, and for any `i` in `ι`, the supremum of `f` and `g` at `i` is equal to the supremum of `f i` and `g i`. Essentially, it tells us that the supremum of two functions at a certain point is equivalent to taking the supremum of the function values at that point.

For every type `ι`, given a supremum structure on each type `α' i`, the supremum of functions `f` and `g` from `ι` to `α' i` at any point `i` is equal to the supremum of `fi` and `gi`.


theorem Matroid.Base.subset_ground : ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M.Base B → B ⊆ M.E := by sorry

This theorem states that for any type `α`, any `Matroid` `M` on this type, and any set `B` of this type, if `B` is a base of the matroid `M`, then `B` is a subset of the ground set `E` of the matroid `M`. In other words, every base of a matroid is always a subset of the ground set of the matroid.

For any matroid M on type α, any base B of M is a subset of M's ground set E.


theorem Set.prod_empty : ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s ×ˢ ∅ = ∅ := by sorry

This theorem states that for any type `α` and `β` and any set `s` of type `α`, the cartesian product of set `s` and an empty set is always an empty set. In other words, if you form pairs where the first element comes from set `s` and the second element comes from an empty set, you'll end up with an empty set, because there are no elements to select from the empty set.

For any set `s`, the cartesian product `s × {}` is an empty set.


theorem Set.preimage_preimage :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} {s : Set γ},
      f ⁻¹' (g ⁻¹' s) = (fun x => g (f x)) ⁻¹' s :=
  by sorry

This theorem, named `Set.preimage_preimage`, describes a property of function composition and preimages in the context of sets. Specifically, for all types `α`, `β`, and `γ`, and for all functions `g : β → γ` and `f : α → β`, and for any set `s` of type `γ`, the preimage of the preimage of `s` under `f` and `g` is equal to the preimage of `s` under the composition of `g` and `f`. In mathematical terms, it states that $f^{-1}(g^{-1}(s)) = (g \circ f)^{-1}(s)$, where $f^{-1}$ and $g^{-1}$ denote the preimages, not the inverse functions.

For any sets `α`, `β`, `γ`, functions `f : α → β` and `g : β → γ`, and set `s : Set γ`, the preimages of `s` under `f` and `g` commute, i.e., `f⁻¹(g⁻¹(s)) = (g ∘ f)⁻¹(s)`.


IsClosed.isComplete

theorem IsClosed.isComplete :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] [inst : CompleteSpace α] {s : Set α}, IsClosed s → IsComplete s := by
  sorry

This theorem states that for any type `α` equipped with a uniform space and a complete space structure, any closed set `s` is a complete set. In the context of analysis, a set is considered "complete" if every Cauchy filter that takes values in the set has a limit within the set. The theorem tells us that if we have a closed set in a complete space, then it also has this property. This means, intuitively, that sequences in the set which should have a limit do indeed have a limit, and that limit is also within the set.

In a complete uniform space, every closed set is a complete set, meaning that every Cauchy filter with values in the set has a limit within the set.


theorem le_of_tendsto :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIicTopology α]
      {f : β → α} {a b : α} {x : Filter β} [inst_3 : Filter.NeBot x],
      Filter.Tendsto f x (nhds a) → (∀ᶠ (c : β) in x, f c ≤ b) → a ≤ b :=
  by sorry

The theorem `le_of_tendsto` states that for any types `α` and `β`, where `α` is a topological space with a preorder and a closed lower interval topology, and `β` is a filter that does not equal the bottom element, if a function `f` from `β` to `α` tends to a point `a` (i.e., for every neighborhood of `a`, the preimage of `f` is a neighborhood in the filter), and if almost every output of `f` is less than or equal to `b` for the filter `x` (i.e., this condition holds for all but a finite number of elements in `x`), then `a` is less than or equal to `b`. In other words, if a function `f` tends to a limit `a` and almost all its values are bounded by `b`, then `a` cannot be greater than `b`.

If a function from a filter (not containing the bottom element) in a topological space with a preorder and closed lower interval topology, to another space, tends to a limit point and almost all its images are less than or equal to some bound, then the limit point is less than or equal to the bound.


theorem MeasureTheory.extend_eq :
    ∀ {α : Type u_1} {P : α → Prop} (m : (s : α) → P s → ENNReal) {s : α} (h : P s), MeasureTheory.extend m s = m s h :=
  by sorry

The theorem `MeasureTheory.extend_eq` states that for any type `α`, any property `P` on `α`, and any function `m` from elements of `α` satisfying `P` to the extended nonnegative real numbers (`ENNReal`), if `s` is an element of `α` that satisfies `P`, then applying the `MeasureTheory.extend` function to `m` and `s` gives the same result as directly applying `m` to `s` and the proof that `s` satisfies `P`. In other words, `MeasureTheory.extend` indeed extends the function `m` without altering its original values on elements that satisfy the property `P`.

For any type `α`, property `P` on `α`, and function `m` from `P`-elements of `α` to `ENNReal`, `MeasureTheory.extend m s = m s` holds for any `s` satisfying `P`.


theorem Matrix.submatrix_submatrix :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} {l₂ : Type u_10} {o₂ : Type u_11}
      (A : Matrix m n α) (r₁ : l → m) (c₁ : o → n) (r₂ : l₂ → l) (c₂ : o₂ → o),
      Matrix.submatrix (Matrix.submatrix A r₁ c₁) r₂ c₂ = Matrix.submatrix A (r₁ ∘ r₂) (c₁ ∘ c₂) :=
  by sorry

The theorem `Matrix.submatrix_submatrix` states that for any matrix `A` with entries in `α` and indices in `m` and `n`, given mappings `r₁` from `l` to `m`, `c₁` from `o` to `n`, `r₂` from `l₂` to `l`, and `c₂` from `o₂` to `o`, the submatrix of `A` obtained first by using `r₁` and `c₁` to select rows and columns respectively, and then by using `r₂` and `c₂` on the resulting submatrix, is the same as the submatrix of `A` obtained by using the compositions `r₁ ∘ r₂` and `c₁ ∘ c₂` to select rows and columns respectively. In other words, the order of taking submatrices doesn't matter, you can take a submatrix of a submatrix or you can adjust your row and column selection functions and take the submatrix all at once.

Given matrices `A` with entries in `α`, and submatrix indices defined by mappings `r₁`, `c₁`, `r₂`, and `c₂`, the submatrices obtained by first selecting rows with `r₁` and `c₁` and then with `r₂` and `c₂`, and the submatrices obtained directly with `r₁ ∘ r₂` and `c₁ ∘ c₂`, are equal.


theorem Finset.range_succ : ∀ {n : ℕ}, Finset.range (Nat.succ n) = insert n (Finset.range n) := by sorry

This theorem states that for every natural number `n`, the set of natural numbers less than `n+1` (i.e., `Finset.range (Nat.succ n)`) is equivalent to the set obtained by inserting `n` into the set of natural numbers less than `n` (i.e., `insert n (Finset.range n)`). In other words, when you increment a number, the set of natural numbers less than the incremented number can be created by adding the original number to the set of natural numbers less than the original number.

For every natural number `n`, the set `Finset.range (Nat.succ n)` is equal to `insert n (Finset.range n)`.


theorem Set.image2_singleton :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {a : α} {b : β}, Set.image2 f {a} {b} = {f a b} := by
  sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any binary function `f : α → β → γ`, the image of the function `f` on the sets `{a}` and `{b}`, where `a` is an element of `α` and `b` is an element of `β`, results in the set `{f a b}`. Essentially, this means that when you apply the function `f` to a singleton set containing `a` and a singleton set containing `b`, you get a singleton set containing the result of `f(a, b)`.

For any functions `f : α → β → γ` and `a : α`, `b : β`, the sets `{f a b}` and `{f x y | x ∈ {a}, y ∈ {b}}` are equal.


theorem Nat.gcd_pos_of_pos_left : ∀ {m : ℕ} (n : ℕ), 0 < m → 0 < Nat.gcd m n := by sorry

The theorem `Nat.gcd_pos_of_pos_left` states that for all natural numbers `m` and `n`, if `m` is greater than 0, then the greatest common divisor (gcd) of `m` and `n` is also greater than 0. In other words, if a natural number `m` is positive, its gcd with any other natural number `n` is also positive.

For all natural numbers m and n, if m > 0 then gcd(m, n) > 0.


theorem Submodule.map_span :
    ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : Semiring R₂] {σ₁₂ : R →+* R₂} [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₂ M₂]
      {F : Type u_8} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂] [inst_8 : RingHomSurjective σ₁₂]
      (f : F) (s : Set M), Submodule.map f (Submodule.span R s) = Submodule.span R₂ (⇑f '' s) :=
  by sorry

This theorem, named `Submodule.map_span`, states that for any sets of types `R`, `R₂`, `M`, `M₂`, `F`, where `R` and `R₂` are semirings, `M` and `M₂` are additively commutative monoids and modules over `R` and `R₂` respectively. `F` is a function-like object that maps elements from `M` to `M₂`, and `σ₁₂` is a semilinear map from `R` to `R₂`. If the ring homomorphism `σ₁₂` is surjective, then for any function `f` of type `F` and a set `s` of type `M`, mapping the span of `s` under `f` (where the span is the smallest submodule of `M` that contains `s`) equals the span in `R₂` of the image of `s` under `f`. In mathematical terms, this theorem is saying:

$$f(\text{span}_R(s)) = \text{span}_{R₂}(f(s)).$$

That is, the action of mapping a set's span with a function is the same as taking the span of the function's image of the set.

If `σ₁₂:` R → R₂ is a surjective semilinear map between semirings `R` and `R₂`, and `F:` M → M₂ is a function-like object, then for any additively commutative monoids `M` and `M₂`, and any set `s ⊆ M`, `f(span₀ R s) = span₀ R₂ (fs)`, where `span₀` denotes the span in the respective rings.


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

This theorem states that for any natural number `n`, the successor of `n` (denoted as `Nat.succ n`) is equal to `1 + n`. In other words, it asserts that the operation of finding the next natural number (successor operation) is equivalent to adding one to the given natural number. This is a foundational aspect of the arithmetic of natural numbers.

For all natural numbers n, Nat.succ n equals 1 + n.


theorem trans_of : ∀ {α : Sort u} (r : α → α → Prop) [inst : IsTrans α r] {a b c : α}, r a b → r b c → r a c := by sorry

This theorem, called `trans_of`, states that for any type `α` and any relation `r` on `α` that is transitive (as indicated by `IsTrans α r`), if `r` holds between elements `a` and `b`, and between `b` and `c`, then `r` also holds between `a` and `c`. In other words, this is a formal statement of the transitive property: if `a` is related to `b` and `b` is related to `c`, then `a` is related to `c`.

If `r` is a transitive relation on type `α`, then for all `a`, `b`, and `c` in `α`, if `a` is related to `b` and `b` is related to `c` (`r a b` and `r b c`), then `a` is related to `c` (`r a c`).


theorem sub_ne_zero_of_ne : ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a b : α}, a ≠ b → a - b ≠ 0 := by sorry

This theorem states that for any type `α` that is a subtraction monoid, given any two elements `a` and `b` of this type, if `a` is not equal to `b`, then the result of subtracting `b` from `a` is not zero. A subtraction monoid is a type with an associated subtraction operation that satisfies certain properties such as closure under the operation and the existence of an identity element.

For any subtraction monoid type `α` and elements `a`, `b` of `α` with `a ≠ b`, the subtraction `a - b` is non-zero.


theorem Nat.Prime.not_dvd_one : ∀ {p : ℕ}, Nat.Prime p → ¬p ∣ 1 := by sorry

The theorem `Nat.Prime.not_dvd_one` states that for all natural numbers `p`, if `p` is a prime number, then `p` does not divide `1`. In other words, no prime number can be a divisor of 1.


theorem linearIndependent_iff :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M], LinearIndependent R v ↔ ∀ (l : ι →₀ R), (Finsupp.total ι M R v) l = 0 → l = 0 :=
  by sorry

The theorem `linearIndependent_iff` states that for any types ι, R, and M, and any function `v` from ι to M, given a semiring structure on R, an additive commutative monoid structure on M, and a module structure over R on M, the function `v` is linearly independent over R if and only if for every linear combination `l` (represented as a function from ι to R), if the total of `l` under `v` equals zero, then `l` must be the zero function. In other words, no non-trivial linear combination of the vectors given by `v` can sum to the zero vector, which is the definition of linear independence in linear algebra.

A function from a type to a module is linearly independent over a semiring if and only if no non-trivial linear combination of its images sums to the zero vector.


MeasureTheory.AEStronglyMeasurable.norm

theorem MeasureTheory.AEStronglyMeasurable.norm :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_5}
      [inst : SeminormedAddCommGroup β] {f : α → β},
      MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.AEStronglyMeasurable (fun x => ‖f x‖) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.norm` states that for any type `α` with a measurable space structure `m`, a measure `μ` over that measurable space, a type `β` which is a seminormed add commutative group, and any function `f` from `α` to `β`, if the function `f` is almost everywhere strongly measurable with respect to measure `μ`, then the function that takes `x` in `α` to the norm of `f(x)` in `β` is also almost everywhere strongly measurable with respect to the measure `μ`. In other words, if a function is almost everywhere strongly measurable, then so is its norm function, under the same measure.

If `f: α → β` is almost everywhere strongly measurable with respect to measure `μ` on measurable space `(α, m)`, then the function `x ↦ ||f x||β` is also almost everywhere strongly measurable with respect to `μ`.


theorem Set.center_eq_univ : ∀ (M : Type u_1) [inst : CommSemigroup M], Set.center M = Set.univ := by sorry

This theorem states that for any type `M` that has a `CommSemigroup` instance, the center of the magma of `M` is equal to the universal set of `M`. In mathematical terms, it asserts that in a commutative semigroup, every element is central, i.e., for all elements `x`, `y` in the semigroup, the equation `x*y=y*x` holds true.

In a commutative semigroup, the center of the magma equals the universal set. That is, every element is central, i.e., for all `x, y` in the semigroup, `x * y = y * x`.


theorem smul_lie :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] (t : R)
      (x : L) (m : M), ⁅t • x, m⁆ = t • ⁅x, m⁆ :=
  by sorry

This theorem states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is a module over `R` and a Lie ring module over `L`, and for any `t` in `R`, `x` in `L`, and `m` in `M`, the Lie bracket of `t` times `x` and `m` is equal to `t` times the Lie bracket of `x` and `m`. This effectively shows that the scalar multiplication `t • x` can be distributed over the Lie bracket operation.

For any commutative ring `R`, Lie ring `L`, and additive commutative group `M` being an `R`-module and an `L`-Lie module, the Lie bracket [x, m] equals the scalar multiplication by x of the Lie bracket [m, -] applied to m for all x in L and m in M.


theorem Ordinal.add_succ : ∀ (o₁ o₂ : Ordinal.{u_3}), o₁ + Order.succ o₂ = Order.succ (o₁ + o₂) := by sorry

This theorem states that for any two ordinals `o₁` and `o₂`, the sum of `o₁` and the successor of `o₂` is equal to the successor of the sum of `o₁` and `o₂`. In other words, if you add one (using the `Order.succ` function) to the second operand of the addition, it is the same as adding the operands first and then adding one to the result. This is a property of ordinal arithmetic that mirrors similar properties in standard arithmetic.

For any ordinals `o₁` and `o₂`, `Order.succ (o₁ + o₂) = o₁ + Order.succ o₂`.


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

This theorem states that for all real numbers `x` and `y` which are greater than 0, the logarithm of `x` is less than or equal to the logarithm of `y` if and only if `x` is less than or equal to `y`. This statement essentially captures the order preserving property of the logarithm function on the positive real numbers.

For all real numbers `x` and `y` greater than 0, `log x <= log y` if and only if `x <= y`.


theorem Finset.singleton_nonempty : ∀ {α : Type u_1} (a : α), {a}.Nonempty := by sorry

This theorem states that for any given type `α` and an element `a` of this type, a finite set containing only `a` (written as `{a}`) is nonempty. Simply put, a singleton set (a set containing only one element) is always nonempty, regardless of the type of its element.

For any type `α` and element `a` of type `α`, the singleton set `{a}` is nonempty.


theorem AffineMap.lineMap_apply :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] (p₀ p₁ : P1) (c : k), (AffineMap.lineMap p₀ p₁) c = c • (p₁ -ᵥ p₀) +ᵥ p₀ :=
  by sorry

The theorem `AffineMap.lineMap_apply` states that for any type `k` endowed with a ring structure, any type `V1` endowed with an additive commutative group structure, any `k`-module `V1`, any type `P1` that forms an affine space with `V1`, and any two points `p₀` and `p₁` in `P1`, applying the affine map `AffineMap.lineMap p₀ p₁` to a scalar `c` in `k` results in the point obtained by adding `p₀` to the vector obtained by scaling the difference vector `p₁ -ᵥ p₀` by `c`. In mathematical notation, this is `(AffineMap.lineMap p₀ p₁) c = c • (p₁ -ᵥ p₀) +ᵥ p₀`.

Given an affine space `P1` over a ring `k` with base vector space `V1`, and points `p₀` and `p₁` in `P1`, the affine map `AffineMap.lineMap p₀ p₁` satisfies `(AffineMap.lineMap p₀ p₁) c = c * (p₁ - p₀) + p₀`, where `c` is a scalar in `k`.


theorem Int.natAbs_dvd : ∀ {a b : ℤ}, ↑(Int.natAbs a) ∣ b ↔ a ∣ b := by sorry

The theorem `Int.natAbs_dvd` states that for any two integers `a` and `b`, the absolute value of `a` (in natural numbers) divides `b` if and only if `a` divides `b`. In other words, the divisibility relationship between `a` and `b` is maintained even when we replace `a` with its absolute value.

For integers `a` and `b`, `|a|` divides `b` if and only if `a` divides `b`.


theorem Polynomial.degree_mul_leadingCoeff_inv :
    ∀ {K : Type u_1} [inst : DivisionRing K] (p : Polynomial K) {q : Polynomial K},
      q ≠ 0 → Polynomial.degree (p * Polynomial.C (Polynomial.leadingCoeff q)⁻¹) = Polynomial.degree p :=
  by sorry

The theorem `Polynomial.degree_mul_leadingCoeff_inv` states that for any division ring `K`, and any polynomials `p` and `q` over `K` such that `q` is not the zero polynomial, the degree of the polynomial obtained by multiplying `p` by the inverse of the leading coefficient of `q` (expressed as a constant polynomial) is equal to the degree of `p`. In other words, multiplying a polynomial by the inverse of the leading coefficient of another polynomial does not change the degree of the original polynomial.

For any division ring K and polynomials p and q over K with q not the zero polynomial, the degree of p \* (lc q)\^(-1) is equal to the degree of p. Here, lc denotes the leading coefficient.


theorem Nat.lcm_dvd : ∀ {m n k : ℕ}, m ∣ k → n ∣ k → Nat.lcm m n ∣ k := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, if `m` divides `k` and `n` divides `k`, then the least common multiple of `m` and `n` also divides `k`. In mathematical notation, we have: if $m | k$ and $n | k$, then $\text{lcm}(m, n) | k$. The least common multiple (lcm) is defined as the product of `m` and `n` divided by their greatest common divisor (gcd).

If `m` and `n` are natural numbers that divide `k`, then their least common multiple `lcm(m, n)` also divides `k`.


Filter.NeBot.map

theorem Filter.NeBot.map :
    ∀ {α : Type u} {β : Type v} {f : Filter α}, Filter.NeBot f → ∀ (m : α → β), Filter.NeBot (Filter.map m f) := by
  sorry

This theorem states that for any types `α` and `β`, given a filter `f` on `α` that is not the bottom filter (i.e., it is not the filter containing every set), and any function `m` from `α` to `β`, the forward map of the filter `f` via the function `m` is also not the bottom filter. In other words, applying a function to a non-bottom filter does not produce a bottom filter.

For any filter `f` on type `α` that is not the bottom filter and any function `m : α → β`, the image filter `m'' f` on `β` is also not the bottom filter.


theorem tsum_eq_sum :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {s : Finset β},
      (∀ b ∉ s, f b = 0) → ∑' (b : β), f b = Finset.sum s fun b => f b :=
  by sorry

The theorem `tsum_eq_sum` states that for any types `α` and `β`, with `α` equipped with an additive commutative monoid structure and a topological space structure, and for any function `f` from `β` to `α` and any finite set `s` of elements of type `β`, if the function `f` evaluates to `0` for all elements not in `s`, then the unbounded sum (denoted by `∑'`) of `f` over all elements of type `β` equals the finite sum (denoted by `Finset.sum`) of `f` over the elements of the finite set `s`. In mathematical terms, if `f(b) = 0` for all `b` not in `s`, then `∑' (b : β), f(b) = ∑ x in s, f(x)`.

For any additive commutative monoid- and topological space-structured type `α` with function `f` from a finite set `s` of `α`'s elements to `α`, if `f(b) = 0` for all `b` outside `s`, then the unbounded sum of `f` equals the finite sum over `s`.


theorem IsGLB.csInf_eq :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α},
      IsGLB s a → Set.Nonempty s → sInf s = a :=
  by sorry

This theorem states that for any type `α` that is a `ConditionallyCompleteLattice`, for any set `s` of `α`, and for any element `a` of `α`, if `a` is the greatest lower bound of `s` and `s` is not empty, then the infimum (`sInf`) of `s` is equal to `a`. Here, a `ConditionallyCompleteLattice` is a type that is a lattice with a least element and greatest element, and `sInf` is the greatest element less than or equal to all elements in the set.

For any non-empty set `s` of a `ConditionallyCompleteLattice` type `α` and any element `a` that is the greatest lower bound of `s`, we have `a = s.inf`.


HasSubset.Subset.antisymm'

/-- **Alias** of `superset_antisymm`. -/
theorem HasSubset.Subset.antisymm' :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊆ b → b ⊆ a → b = a :=
  by sorry

This theorem, named `HasSubset.Subset.antisymm'`, states that given any type `α` that has a subset relation (`HasSubset α`), and any two objects `a` and `b` of that type, if the subset relation is antisymmetric (`IsAntisymm α fun x x_1 => x ⊆ x_1`), then if `a` is a subset of `b` and `b` is a subset of `a`, it must be the case that `a` and `b` are equal. This is an alias of the `superset_antisymm` theorem. This theorem captures the antisymmetry property of the subset relation, a fundamental property in set theory.

If `α` is a type with a subset relation and `IsAntisymm` holds for the subset relation on `α`, then for all `a` and `b` in `α`, `a ⊆ b` and `b ⊆ a` imply `a = b`.


theorem continuous_algebraMap :
    ∀ (R : Type u_1) (A : Type u) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace A] [inst_5 : TopologicalSemiring A]
      [inst_6 : ContinuousSMul R A], Continuous ⇑(algebraMap R A) :=
  by sorry

The theorem states that for any two types `R` and `A`, where `R` is a commutative semiring, `A` is a semiring and `A` is an algebra over `R`, if the operations of `R` and `A` are continuous (meaning `R` and `A` are topological spaces where the semiring operations on `A` are continuous, and the scalar multiplication from `R` to `A` is also continuous), then the function `algebraMap`, which maps elements from `R` to `A` according to the algebra structure, is a continuous function.

If `R` is a commutative semiring, `A` is a semiring and an algebra over `R`, `R` and `A` are topological spaces with continuous semiring operations and scalar multiplication, then the algebra map from `R` to `A` is a continuous function.


/-- If `c` is a limiting pullback cone, then we have an `IsPullback c.fst c.snd f g`.  -/
theorem CategoryTheory.IsPullback.of_isLimit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      {c : CategoryTheory.Limits.PullbackCone f g},
      CategoryTheory.Limits.IsLimit c →
        CategoryTheory.IsPullback (CategoryTheory.Limits.PullbackCone.fst c) (CategoryTheory.Limits.PullbackCone.snd c)
          f g :=
  by sorry

This theorem states that if `c` is a limiting pullback cone in a category `C` over objects `X`, `Y`, and `Z` with morphisms `f: X ⟶ Z` and `g: Y ⟶ Z`, then the pair of morphisms `(CategoryTheory.Limits.PullbackCone.fst c, CategoryTheory.Limits.PullbackCone.snd c)` forms a pullback for `f` and `g`. In other words, if the cone `c` is a limit of the cospan formed by `f` and `g`, then the first and second projections of this cone provide a pullback of `f` and `g`.

If `c` is a limiting pullback cone in a category `C` over objects `X`, `Y`, and `Z` with morphisms `f: X ⟶ Z` and `g: Y ⟶ Z`, then the pair of morphisms `(fst c, snd c)` forms a pullback of `f` and `g`.


PNat.eq

theorem PNat.eq : ∀ {m n : ℕ+}, ↑m = ↑n → m = n := by sorry

This theorem asserts that for any two positive natural numbers `m` and `n`, if their cast to natural numbers are equal, then `m` and `n` themselves are also equal. In mathematical terms, for all `m, n` in `ℕ+`, if `m` cast to `ℕ` equals `n` cast to `ℕ`, then `m` equals `n`.

For all natural numbers `m` and `n`, if `m` = (cast `m` to `ℕ`) = (cast `n` to `ℕ`) then `m` = `n`.


theorem continuous_sInf_rng :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {T : Set (TopologicalSpace β)},
      Continuous f ↔ ∀ t ∈ T, Continuous f :=
  by sorry

This theorem, `continuous_sInf_rng`, states that for any two types `α` and `β`, a function `f` mapping `α` to `β`, a topological space `t₁` on `α`, and a set `T` of topological spaces on `β`, the function `f` is continuous if and only if `f` is continuous for every topological space in the set `T`. In other words, the continuity of a function across different topological spaces is dependent on its continuity in each individual space within the set of all such spaces.

A function between two types is continuous with respect to all topologies in a given set if and only if it is continuous under each of those topologies.


/-- `Finsupp.single a b` is injective in `b`. For the statement that it is injective in `a`, see
`Finsupp.single_left_injective`  -/
theorem Finsupp.single_injective :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (a : α), Function.Injective (Finsupp.single a) := by sorry

The theorem `Finsupp.single_injective` states that for any type `α` and any type `M` with an instance of the `Zero` typeclass, the function `Finsupp.single a`, where `a` is an element of `α`, is injective. In other words, if `Finsupp.single a b1` is equal to `Finsupp.single a b2`, then `b1` must be equal to `b2`. This theorem is only about injectivity in the second argument of `Finsupp.single`. For the statement of injectivity in the first argument, refer to the theorem `Finsupp.single_left_injective`.

For any type `α` and `M` with an instance of `Zero`, the function `Finsupp.single a` from `α` to `M Key α → M` is injective in its second argument `b`.


theorem iSup_iSup_eq_left :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {b : β} {f : (x : β) → x = b → α},
      ⨆ x, ⨆ (h : x = b), f x h = f b ⋯ :=
  by sorry

This theorem states that for every type `α` that forms a complete lattice, a given `β` type, a specific element `b` of type `β`, and a function `f` that maps an element of type `β` and a proof that the element equals `b` to an element of type `α`, the supremum over all `β` of the supremum of `f` over the proof that `β` equals `b` is equal to the function `f` evaluated at `b`. In other words, the maximum value of `f` across all `β`s and all proofs that `β` equals `b` is just `f(b)`, assuming the supremum exists.

For every complete lattice `α`, element `b` of type `β`, and function `f` from `β × proof (β = b)` to `α`, the supremum of the supremum of `f` over all `β` and proofs that `β` equals `b` equals `f(b)`.


theorem Multiset.count_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Multiset α),
      Multiset.count a (s ∪ t) = max (Multiset.count a s) (Multiset.count a t) :=
  by sorry

The theorem `Multiset.count_union` states that for any type `α` with a decidable equality, given an element `a` of type `α` and two multisets `s` and `t` of type `α`, the multiplicity of `a` in the union of `s` and `t` is equal to the maximum of the multiplicity of `a` in `s` and the multiplicity of `a` in `t`. In other words, it's expressing that when you unite two multisets, the count of an element in the resulting multiset is the maximum of the counts of that element in the original multisets. This is just like saying that the number of times an element appears in the combination of two collections is the most number of times it appears in either one.

For any type `α` with decidable equality, the multiplicity of an element `a` in the union of multisets `s` and `t` is the maximum of the multiplicities of `a` in `s` and `t`.


theorem Mathlib.Data.Set.Basic._auxLemma.26 : ∀ {α : Type u} (s t : Set α), (s ∩ t ⊆ s) = True := by sorry

This theorem states that for any type `α` and for any two sets `s` and `t` of type `α`, the intersection of `s` and `t` is always a subset of `s`. This is always true, as by definition, the intersection of two sets is the set of elements that both sets have in common, hence those elements are certainly part of set `s`.

For any type `α` and sets `s`, `t` of type `α`, `s ∩ t` is a subsets of `s`.


theorem multiplicity.is_greatest :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {m : ℕ},
      multiplicity a b < ↑m → ¬a ^ m ∣ b :=
  by sorry

The theorem `multiplicity.is_greatest` states that for any type `α` that has a monoid structure, and any two elements `a` and `b` of that type, along with a natural number `m`, if the multiplicity of `a` in `b` is less than `m`, then `a` raised to the power of `m` does not divide `b`. Here, multiplicity is calculated as the largest natural number `n` such that `a ^ n` divides `b`. This theorem is applicable for any decidable relation for divisibility.

For any monoid type `α` and natural numbers `m`, `n`, if the multiplicity of `a` in `b` of type `α` is less than `m`, then `a^m` does not divide `b`.


theorem Metric.sphere_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ⊆ Metric.closedBall x ε := by sorry

This theorem states that for any pseudometric space of type `α`, every point `x` in `α`, and every real number `ε`, the sphere centered at `x` with radius `ε` is a subset of the closed ball centered at `x` with the same radius. The sphere consists of all points exactly `ε` distance from `x`, while the closed ball consists of all points at most `ε` distance from `x`, thus every point on the sphere is also in the closed ball.

For any pseudometric space and for all points `x` in the space and real number `ε`, the sphere with center `x` and radius `ε` is included in the closed ball with center `x` and radius `ε`.


theorem Mathlib.Algebra.Function.Support._auxLemma.1 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {x : α}, (x ∈ Function.mulSupport f) = (f x ≠ 1) := by
  sorry

This theorem states that for any type `α`, a type `M` that has the structure of a `One` (which means it has a specified element considered as "one"), a function `f` from `α` to `M`, and an element `x` of type `α`, the element `x` is in the multiplicative support of the function `f` if and only if the value of `f` at `x` is not equal to `1`. The multiplicative support of the function `f` is defined as the set of points `x` in `α` such that `f(x)` is not `1`.

For any type `α`, function `f` from `α` to a One `M`, and `x` in `α`, `x` is in the multiplicative support of `f` if and only if `f(x) ≠ 1`.


theorem ModuleCat.mono_iff_injective :
    ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective ⇑f := by
  sorry

The theorem `ModuleCat.mono_iff_injective` states that for any ring `R`, and for any modules `X` and `Y` over `R`, a morphism `f` from `X` to `Y` is a monomorphism in the category theory sense if and only if the function represented by `f` is injective. Here, a function is considered injective if for any two elements `a₁` and `a₂` from the domain, if the function maps `a₁` and `a₂` to the same element in the codomain, then `a₁` and `a₂` must be the same. The morphism `f` is considered a monomorphism if it has the left cancellation property; that is, for any morphisms `g`, `h` from any object to `X`, if `f` composed with `g` equals `f` composed with `h`, then `g` equals `h`.

A morphism between modules over a ring is a monomorphism if and only if the underlying function is injective.


theorem Mathlib.GroupTheory.Submonoid.Basic._auxLemma.11 :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (x : M), (x ∈ ⊤) = True := by sorry

This theorem, named `Mathlib.GroupTheory.Submonoid.Basic._auxLemma.11`, asserts that for any type `M` that has an addition operation and a zero element (i.e., `M` is an instance of the `AddZeroClass`), any element `x` of type `M` always belongs to the top element of the lattice structure (`⊤`). In other words, it states that every element of an additive monoid with a zero element is contained in the largest (top) submonoid.

For any additive monoid `M` with a zero element, every `x` in `M` belongs to the top element (lattice unit) of `M`.


theorem Set.mem_of_mem_of_subset : ∀ {α : Type u} {x : α} {s t : Set α}, x ∈ s → s ⊆ t → x ∈ t := by sorry

The theorem `Set.mem_of_mem_of_subset` states that for any type α and any elements x of type α and sets s and t of type α, if x is a member of set s and set s is a subset of set t, then x is also a member of set t. This encapsulates the intuitive idea that if an item belongs to a smaller group (subset) and that smaller group is part of a larger group (superset), then the item also belongs to the larger group.

If `s` is a subset of `t` and `x` is an element of `s`, then `x` is an element of `t`.


theorem subset_tsupport :
    ∀ {X : Type u_1} {α : Type u_2} [inst : Zero α] [inst_1 : TopologicalSpace X] (f : X → α),
      Function.support f ⊆ tsupport f :=
  by sorry

This theorem states that for any function `f` from a type `X` to a type `α`, where `α` has a zero element and `X` has a topological space structure, the support of `f` (i.e. the set of all points `x` in `X` where `f(x)` is not zero) is always a subset of the topological support of `f` (i.e. the closure of the support of `f` in the topology of `X`). In other words, all points where the function `f` is nonzero are contained within the closure of those points in the underlying topological space.

The support of a function from a topological space to a type with a zero element is contained in the topological closure of its support.


theorem AddMonoidHom.ker_eq_bot_iff :
    ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_7} [inst_1 : AddZeroClass M] (f : G →+ M),
      AddMonoidHom.ker f = ⊥ ↔ Function.Injective ⇑f :=
  by sorry

This theorem states that for any additive group `G` and any type `M` with an additive zero, for any additive monoid homomorphism `f` from `G` to `M`, the kernel of `f` is the trivial group if and only if `f` is injective. In other words, `f` has no non-zero elements in `G` mapping to the zero of `M` if and only if no two distinct elements in `G` map to the same element in `M` under `f`.

For any additive group homomorphism from an additive group to a group with an additive zero, the kernel is the trivial group if and only if the homomorphism is injective.


theorem Filter.Germ.coe_lt :
    ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : Preorder β] {f g : α → β},
      ↑f < ↑g ↔ ∀ᶠ (x : α) in ↑φ, f x < g x :=
  by sorry

This theorem, `Filter.Germ.coe_lt`, states that for any types `α` and `β`, any ultrafilter `φ` on `α`, any preorder structure on `β`, and any functions `f` and `g` from `α` to `β`, the lifting of `f` to the germ of `φ` is less than the lifting of `g` to the germ of `φ` if and only if for almost all `x` in `α` with respect to `φ`, `f(x)` is less than `g(x)`. In other words, it's about the order relationship between the filter germs of `f` and `g` under certain conditions.

Given types `α`, `β`, an ultrafilter `φ` on `α`, a preorder `≤` on `β`, and functions `f` and `g` from `α` to `β`, the germ of `f` is less than the germ of `g` with respect to `φ` if and only if `f(x) ≤ g(x)` holds for almost all `x` in `α` with respect to `φ`.


theorem Int.neg_zero : -0 = 0 := by sorry

This theorem states that the negation of zero in the integer number system is equal to zero. In other words, if you take zero and negate it, you still get zero. This holds true in the domain of all integers.

The theorem asserts that the additive inverse of 0 in the integers equals 0.