MeasurableEquiv.measurableEmbedding

/-- A measurable equivalence is a measurable embedding.  -/
theorem MeasurableEquiv.measurableEmbedding :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
      MeasurableEmbedding ⇑e :=
  by sorry

This theorem states that for any two types `α` and `β` both equipped with a measurable space structure, any measurable equivalence `e` from `α` to `β` is also a measurable embedding. That is, if you can map between the two types such that both the function and its inverse are measurable functions, then that mapping also preserves the measurability of sets, that is, the preimage of a measurable set under the function is also measurable.

If `α` and `β` are measurable spaces and `e : α ≃ β` is a measurable equivalence, then `e` is a measurable embedding (i.e., the preimage of any measurable set in `β` under `e` is measurable in `α`).


UniformContinuous.continuous

theorem UniformContinuous.continuous :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformContinuous f → Continuous f :=
  by sorry

The theorem `UniformContinuous.continuous` states that for all function `f` from a type `α` to a type `β`, where both `α` and `β` have an associated uniform space structure, if `f` is uniformly continuous, then `f` is also continuous. In other words, if for any pair of elements `x` and `y` from `α` that are sufficiently close, their images under `f`, `f x` and `f y`, are also close, then for every point `x` in `α`, the function `f` is continuous at `x`. Here, continuity of `f` means that the preimage of any open set in `β` is open in `α`.

If a function between uniform spaces is uniformly continuous, then it is continuous.


theorem Multiset.prod_cons :
    ∀ {α : Type u_2} [inst : CommMonoid α] (a : α) (s : Multiset α), Multiset.prod (a ::ₘ s) = a * Multiset.prod s := by
  sorry

The theorem `Multiset.prod_cons` states that for any type `α` that is a commutative monoid, and for any element `a` of that type and any multiset `s` of elements of the same type, the product of the multiset formed by adding `a` to the front of `s` is equal to `a` times the product of `s`. In mathematical terms, it says that if `s` is a multiset of elements of a commutative monoid, then the product of `a` and `s` (denoted `a * prod s`) is the same as the product of the multiset obtained by adding `a` to `s`.

For any commutative monoid type `α` and element `a` of `α`, the product of `a` and the multiset `s` is equal to the product of the multiset obtained by adding `a` to the front of `s`. In other words, `a * prod s = a * s`.


/-- If two linear maps are equal, they are equal at each point.  -/
theorem LinearMap.congr_fun :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      {f g : M →ₛₗ[σ] M₃}, f = g → ∀ (x : M), f x = g x :=
  by sorry

This theorem states that if two linear maps, 'f' and 'g', over semirings 'R' and 'S' and additive commutative monoids 'M' and 'M₃' are equal, then for each point 'x' in 'M', the result of mapping 'x' through 'f' and 'g' will be the same. The theorem applies to the situation where 'M' is a module over 'R', 'M₃' is a module over 'S', and 'σ' is a ring homomorphism from 'R' to 'S'.

If two linear maps over semirings with additive commutative monoid structures, where one is a ring homomorphism between the semirings, equal maps between modules over the semirings, then they map identical elements to identical images.


theorem WithTop.coe_le_coe : ∀ {α : Type u_1} {a b : α} [inst : LE α], ↑a ≤ ↑b ↔ a ≤ b := by sorry

This theorem, `WithTop.coe_le_coe`, states that for any type `α` and any two instances `a` and `b` of that type, given that `α` has a less-than-or-equal-to (`≤`) relation defined on it, the less-than-or-equal-to relation of the lifted values (`↑a` and `↑b`) in the extended type `WithTop α` (i.e., `α` with an added element denoted as 'top') mirrors the less-than-or-equal-to relation of `a` and `b` in the original type `α`. In other words, `a` is less than or equal to `b` in type `α` if and only if the lift of `a` is less than or equal to the lift of `b` in `WithTop α`.

For any type `α` with a `≤` relation and any `a` and `b` in `α`, `↑a ≤ ↑b` in `WithTop α` if and only if `a ≤ b` in `α`.


theorem Finset.coe_union : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), ↑(s₁ ∪ s₂) = ↑s₁ ∪ ↑s₂ := by
  sorry

This theorem is stating that for any given type `α` which has decidable equality, and any two finite sets `s₁` and `s₂` of type `α`, the underlying set of the union of `s₁` and `s₂` is equal to the union of the underlying sets of `s₁` and `s₂`. In other words, it says that the operation of taking the union of two finite sets commutes with the operation of taking the underlying set of a finite set.

For any type `α` with decidable equality and finite sets `s₁` and `s₂` of type `α`, the underlying set of `s₁ ∪ s₂` equals the underlying set of `s₁ �∪ s₂`.


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

The theorem `Finset.mem_image_of_mem` states that for every types `α` and `β` with `β` being a type with decidable equality, every finite set `s` of type `α`, and every function `f` from `α` to `β`, if an element `a` of type `α` belongs to the set `s`, then the image of `a` under `f` belongs to the image of the set `s` under `f`. In other words, if `a` is in a finite set `s`, then its image `f(a)` is in the image of the set `s` under the function `f`.

If `α` is a type with decidable equality, `s : Finset α`, `f : α → β`, and `a ∈ s`, then `f(a) ∈ image f s`.


theorem Set.Finite.mem_toFinset :
    ∀ {α : Type u} {s : Set α} {a : α} (hs : Set.Finite s), a ∈ Set.Finite.toFinset hs ↔ a ∈ s := by sorry

The theorem `Set.Finite.mem_toFinset` states that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, if `s` is a finite set, then `a` belongs to the `Finset` representation of `s` if and only if `a` belongs to `s`. Here, `Finset` refers to a finite set in Lean, and `Set.Finite.toFinset` is a function that converts a finite set into its `Finset` representation. This theorem essentially establishes the membership equivalence between a set and its `Finset` representation when the set is finite.

For any type `α` and finite set `s` of type `α`, an element `a` belongs to `s` if and only if `a` is in the `Finset` representation `Set.Finite.toFinset s`.


theorem add_lt_add_iff_right :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b c : α},
      b + a < c + a ↔ b < c :=
  by sorry

The theorem `add_lt_add_iff_right` states that, for a type `α` equipped with an addition operation and a less than operation, and satisfying certain covariance and contravariance properties (specifically, those asserting that addition behaves appropriately with respect to the order), adding a fixed element `a` from `α` to two other elements `b` and `c` from `α` yields a smaller value when `b` is less than `c`. More formally, it asserts that `b + a < c + a` if and only if `b < c`.

For all types `α` with covariant and contravariant addition and a total order, if `a` is an element of `α` and `b` is less than `c`, then `b + a` is less than `c + a`. In other words, the order relation is preserved under addition.


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

This theorem, `Nat.lt_succ_of_le`, states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then `n` is less than the successor of `m` (i.e., `m+1`). In other words, if a natural number `n` is not greater than another natural number `m`, then `n` is definitely less than `m+1`.

For all natural numbers `n` and `m`, if `n ≤ m`, then `n < m + 1`.


theorem sq_nonneg : ∀ {α : Type u} [inst : LinearOrderedSemiring α] [inst_1 : ExistsAddOfLE α] (a : α), 0 ≤ a ^ 2 := by
  sorry

This theorem, `sq_nonneg`, states that for any type `α` that is a linear ordered semiring (a mathematical structure that combines properties of order and operations addition and multiplication) and for which there exists an addition operation that respects the order (`ExistsAddOfLE α`), the square of any element `a` from that type is always nonnegative, i.e., greater than or equal to zero. In mathematical notation, this can be expressed as ∀a ∈ α, 0 ≤ a^2.

For any linear ordered semiring `α` with respect to an order-preserving addition, every element `a` in `α` satisfies `0 ≤ a^2`.


theorem sub_smul :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r s : R) (y : M),
      (r - s) • y = r • y - s • y :=
  by sorry

This theorem states that for any ring `R` and any additive commutative group `M` that forms a module over `R`, the operation of scalar multiplication distributes over subtraction. Specifically, for any two scalars `r` and `s` from `R` and any vector `y` from `M`, the scalar multiplication of the difference of `r` and `s` with `y` equals to the difference of the scalar multiplication of `r` with `y` and the scalar multiplication of `s` with `y`. This property is written in LaTeX as: `(r - s) • y = r • y - s • y`.

For any ring `R`, additive commutative group `M` (an `R`-module), scalars `r, s ∈ R`, and vector `y ∈ M`, we have `(r - s) • y = r • y - s • y`.


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

This theorem states that for any type `α` that has a preorder, if `a` is less than `b` then `b` cannot be less than or equal to `a`. In more mathematical terms, for all `a` and `b` in a preordered set, if `a < b` then it's not the case that `b ≤ a`. This is a property of the ordering relation in a preorder, which is a mathematical structure where the relation is reflexive and transitive.

In a preorder, for all `a` and `b`, if `a` is strictly less than `b`, then `b` is not less than or equal to `a`.


IsClosed.measurableSet

theorem IsClosed.measurableSet :
    ∀ {α : Type u_1} {s : Set α} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α], IsClosed s → MeasurableSet s :=
  by sorry

The theorem `IsClosed.measurableSet` states that for any type `α` and any set `s` of this type, if `α` is equipped with both a topological space structure and a measurable space structure, and if the measurable space structure is generated by the topology's open sets (which is what `OpensMeasurableSpace α` means), then if `s` is a closed set in the topological space, it is also a measurable set in the measure space.

In simpler terms, it asserts that every closed set in a topological space that generates a measurable space is measurable.

If a topological space equipped with a measurable space structure, where the measurable sets are generated by the open sets, then every closed set is measurable.


theorem Set.union_compl_self : ∀ {α : Type u} (s : Set α), s ∪ sᶜ = Set.univ := by sorry

This theorem states that for any set `s` of a given type `α`, the union of `s` and its complement `sᶜ` is the universal set. In other words, every element of type `α` is either in `s` or in the complement of `s`, and hence the union of `s` and `sᶜ` covers all of `α`, i.e., it is the universal set. This is a formalization of the basic principle from set theory that a set combined with its complement yields the entire universe of discourse. In mathematical notation, this is often written as \(s \cup s^c = U\), where \(U\) represents the universal set, \(s\) is any subset of \(U\), and \(s^c\) is the complement of \(s\) in \(U\).

For any set `s` of type `α`, the union of `s` and its complement `sᶜ` equals the universal set `U` of type `α`. In Lean notation, `s ∪ sᶜ = U`.


theorem Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.3 :
    ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True := by sorry

This theorem states that for any given type `α` and any measurable space `m` on `α`, the universal set (i.e., the set of all elements of `α`) is a measurable set. In other words, in the context of measure theory, any possible set of elements drawn from a given type is considered measurable.

The universal set of any measurable space is measurable.


theorem MeasureTheory.lintegral_congr_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), g a ∂μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_congr_ae`, states that for any type `α`, any measurable space `m` over `α`, any measure `μ` on that measurable space, and any two functions `f` and `g` from `α` to the extended nonnegative real numbers (ENNReal), if `f` and `g` are equal almost everywhere (i.e., they are equal except possibly on a set of measure zero), then the Lebesgue integrals of `f` and `g` with respect to the measure `μ` are also equal. In mathematical terms, it says that if $f = g$ almost everywhere (with respect to the measure $\mu$), then $\int f \, d\mu = \int g \, d\mu$. This theorem is a fundamental property of the Lebesgue integral, capturing the idea that the value of the integral is not affected by the function's values on a set of measure zero.

If two measurable functions from a measurable space to the extended nonnegative real numbers are equal almost everywhere, then they have equal Lebesgue integrals with respect to a given measure.


theorem add_lt_add_iff_left :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b c : α},
      a + b < a + c ↔ b < c :=
  by sorry

This theorem, `add_lt_add_iff_left`, states that for any type `α` that supports addition (`Add α`) and a less than operation (`LT α`), given certain covariance and contravariance conditions, for any three elements `a`, `b`, and `c` of this type, the inequality `a + b < a + c` is equivalent to `b < c`. Essentially, it says that if adding `a` to two other numbers results in one sum being less than the other, then it must be the case that the original numbers were also in the same less than relationship.

For types `α` with addition and less than relations, `a + b < a + c` if and only if `b < c`.


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

This theorem states that for any two natural numbers `n` and `m`, if the successor of `n` (i.e., `n + 1`) is less than or equal to the successor of `m` (i.e., `m + 1`), then `n` is less than or equal to `m`. It essentially allows us to remove a "successor" operation from both sides of an inequality.


/-- **Alias** of `by_contradiction`. -/
theorem by_contra : ∀ {p : Prop}, (¬p → False) → p := by sorry

The theorem `by_contra` is an alias of `by_contradiction`. It states that for any proposition `p`, if assuming `¬p` (not `p`) leads to a contradiction (i.e., something that is always false), then `p` must be true. This is a primary form of proof in classical logic known as proof by contradiction.

If assuming the negation of a proposition leads to a contradiction, then the proposition is true.


theorem Polynomial.C_1 : ∀ {R : Type u} [inst : Semiring R], Polynomial.C 1 = 1 := by sorry

The theorem `Polynomial.C_1` states that for all semirings `R`, the constant polynomial of `1` is `1`. In other words, when we apply the constant polynomial constructor `Polynomial.C` to the multiplicative identity `1` in any semiring `R`, we obtain the multiplicative identity in the ring of polynomials over `R`. This is a property of the constant polynomial mapping in the context of ring theory.

For any semiring R, the constant polynomial over the multiplicative identity 1 in R is equal to the multiplicative identity in the ring of polynomials over R.


theorem neg_le_neg_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      -a ≤ -b ↔ b ≤ a :=
  by sorry

This theorem, named `neg_le_neg_iff`, asserts a property about the relationship between the negatives of elements in an additive group. Specifically, given a type `α` that forms an additive group (`AddGroup α`) and an order relation (`LE α`), under the assumption that this type follows certain covariance properties (`CovariantClass`), for any two elements `a` and `b` of this type, the negative of `a` is less or equal to the negative of `b` if and only if `b` is less or equal to `a`. The covariance properties are related to the combination of addition and the order relation and their "swapped" versions.

For all additive groups `α` with order relation `LE`, and under the assumption of covariance properties, `-a ≤ -b` if and only if `b ≤ a`.


theorem zpow_zero : ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a ^ 0 = 1 := by sorry

This theorem asserts that for any type `G` that forms a `DivInvMonoid`, raising any element `a` of `G` to the power of zero yields the identity element of the monoid. In mathematical terms, given a division-invertible monoid `G` and any element `a` in `G`, `a` to the power of 0 is 1, where 1 represents the identity element in the given monoid structure.

For any division-invertible monoid `G` and its element `a`, `a^0 = 1`.


theorem negSucc_zsmul : ∀ {G : Type u_2} [inst : SubNegMonoid G] (a : G) (n : ℕ), Int.negSucc n • a = -((n + 1) • a) :=
  by sorry

The theorem `negSucc_zsmul` states that for any type `G` that is a subtraction-negative monoid (i.e., a mathematical structure with subtraction and negation operations), and for any element `a` of this type and any natural number `n`, the scalar multiplication of `a` by the negative successor of `n` (i.e., `Int.negSucc n • a`) is equal to the negation of the scalar multiplication of `a` by `n + 1` (i.e., `-((n + 1) • a)`). In other words, scalar multiplication by a negative integer in this structure mirrors scalar multiplication by the corresponding positive integer, followed by negation.

For any subtraction-negative monoid type `G` and element `a` in `G`, `Int.negSucc n • a = -(n + 1 • a)`.


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

This theorem states that for any given type `α` that has a preorder (a binary relation that is reflexive and transitive), and for any two instances `a` and `b` of this type, the left-open right-open interval (`Set.Ioo`) from `a` to `b` is a subset of the left-closed right-closed interval (`Set.Icc`) from `a` to `b`. In other words, every element that falls strictly between `a` and `b` (excluding `a` and `b` themselves) is also contained in the set of elements that includes `a` and `b` and everything in between.

For any preorder type `α` and elements `a` and `b` of `α`, the left-open interval `Set.Ioo a b` is a subset of the left-closed right-closed interval `Set.Icc a b`.


theorem convex_univ :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E],
      Convex 𝕜 Set.univ :=
  by sorry

This theorem asserts that for any ordered semiring `𝕜` and any additive commutative monoid `E` that also supports scalar multiplication with `𝕜`, the universal set of `E` is convex. In mathematical terms, the universal set of `E` (which includes all elements of `E`) is a convex set under the given algebraic structures.

Given an ordered semiring `𝕜` and an additive commutative monoid `E` with scalar multiplication, the universal set of `E` is a convex set.


Quotient.exact

theorem Quotient.exact : ∀ {α : Sort u} {s : Setoid α} {a b : α}, ⟦a⟧ = ⟦b⟧ → a ≈ b := by sorry

The theorem `Quotient.exact` states that for any type `α` and a given equivalence relation `s` on `α`, if the equivalence classes of two elements `a` and `b` from `α` are the same (i.e., `⟦a⟧ = ⟦b⟧`), then `a` and `b` are equivalent under the relation `s` (i.e., `a ≈ b`). In the context of set theory, this theorem asserts that two elements belong to the same equivalence class if and only if they are equivalent under the defining relation of that class.

For any equivalence relation `s` on type `α`, if `⟦a⟧ = ⟦b�ре�` then `a ≈ b`.


/-- If all elements of a `Finset` satisfy the predicate `p`, `s.filter p` is `s`.  -/
theorem Finset.filter_true_of_mem :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α}, (∀ x ∈ s, p x) → Finset.filter p s = s :=
  by sorry

The theorem `Finset.filter_true_of_mem` asserts that, for any type `α`, any predicate `p` on `α` that is decidable, and any finite set `s` of type `α`, if every element `x` in `s` satisfies the predicate `p` (formally, for all `x` in `s`, `p(x)` holds), then filtering `s` by `p` leaves `s` unchanged. Essentially, it states that if all elements of a finite set meet a certain condition, then filtering that set based on that condition yields the original set.

If `s` is a finite set of elements from type `α` and `p` is a decidable predicate on `α` such that `p(x)` holds for all `x` in `s`, then `Filter p s = s`.


theorem Finset.sum_range_succ :
    ∀ {β : Type u_4} [inst : AddCommMonoid β] (f : ℕ → β) (n : ℕ),
      (Finset.sum (Finset.range (n + 1)) fun x => f x) = (Finset.sum (Finset.range n) fun x => f x) + f n :=
  by sorry

The theorem `Finset.sum_range_succ` states that for any function `f` from natural numbers `ℕ` to a type `β` which forms an additive commutative monoid, and for any natural number `n`, the sum of the function `f` applied to each element in the range from `0` to `n+1` (exclusive) is equal to the sum of the function `f` applied to each element in the range from `0` to `n` (exclusive) plus the function `f` applied to `n`. This theorem essentially describes an inductive step for proofs involving the sum of elements in a range.

For any additive commutative monoid type `β` and natural number `n`, the sum of a function `f` from natural numbers to `β` applied to elements in the range from `0` to `n+1` (exclusive) equals the sum of the function applied to elements in the range from `0` to `n` (exclusive) plus the function applied to `n`.


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

The theorem `CategoryTheory.Limits.cokernel.π_desc` states that for any category `C` that has zero morphisms, any morphisms `f : X ⟶ Y` and `k : Y ⟶ W` in `C` such that the composition `f ≫ k` equals the zero morphism, the composition of the cokernel projection of `f` with the cokernel description of `f` with respect to `k` and its nullity condition is equal to `k`. In simpler terms, it expresses a property of the cokernel in category theory, specifically that the cokernel description serves as a factorization of the given morphism through the cokernel projection.

For any morphism `f : X ⟶ Y` and `k : Y ⟶ W` in a zero-object category `C`, if `f ∘ k` is the zero morphism then the composition of the cokernel projection of `f` with the description of its cokernel with respect to `k` equals `k`.


theorem Finset.coe_inj : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ = ↑s₂ ↔ s₁ = s₂ := by sorry

The theorem `Finset.coe_inj` states that for any two finite sets `s₁` and `s₂` of an arbitrary type `α`, the condition that their corresponding sets of elements (`↑s₁` and `↑s₂`) are equal is equivalent to `s₁` and `s₂` being equal. This is an injectivity property of the coercion from `Finset` to `Set` in Lean. Essentially, it means that two finite sets are the same if and only if their underlying sets of elements are the same.

The coercion from finite sets to sets is an injection, that is, two finite sets are equal if and only if their underlying sets of elements are equal.


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

This theorem states that for any type `α` that forms a monoid (i.e., it has an associative binary operation and an identity element), the inverse of any unit `a` in `α` when multiplied by `a` gives the identity element. In mathematical terms, it's saying that for all `a` in the group of units of `α`, the product of the inverse of `a` and `a` is equal to 1, where 1 is the identity element of the monoid.

For any monoid `α` with identity element `e` and unit `a` having an inverse `a⁻¹`, we have `a⁻¹ * a = e`.


theorem MulOpposite.op_injective : ∀ {α : Type u_1}, Function.Injective MulOpposite.op := by sorry

The theorem `MulOpposite.op_injective` postulates that for all types `α`, the function `MulOpposite.op` is injective. This means that if two elements of type `α` are mapped to the same element in the multiplication-opposite type (denoted as `αᵐᵒᵖ`), then these two elements were originally equal. In other words, no two distinct elements of `α` are mapped to the same element of `αᵐᵒᵖ` by the `MulOpposite.op` function.

The `MulOpposite.op` function maps distinct elements of type `α` to distinct elements in the multiplication-opposite type `αᵐᵒᵖ`.


theorem mem_interior_iff_mem_nhds :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], x ∈ interior s ↔ s ∈ nhds x := by sorry

This theorem states that for any type `X`, any element `x` of `X`, and any set `s` of `X`, given that `X` has a topological space structure, `x` is in the interior of `s` if and only if `s` is in the neighborhood of `x`. In more mathematical terms, it's stating that an element `x` belongs to the interior of a set `s` (which is the largest open subset of `s`) if and only if the set `s` is a neighborhood of `x` (i.e., it contains an open set around `x`). This theorem is a key result in topology, relating the notions of interior of a set and neighborhood filter of a point.

For any topological space (X,τ), element x ∈ X, and set s ∈ τ, x belongs to the interior of s if and only if s is a neighborhood of x.


theorem abs_zero :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], |0| = 0 :=
  by sorry

This is a theorem stating that the absolute value of zero is zero for any type `α` that is a lattice and an additive group, and for which addition (`x + x_1`) is a covariant function in the sense that if `x ≤ y`, then `f(x) ≤ f(y)`. This holds true regardless of the specific type `α` as long as it fulfills these conditions, thus it applies to integers, real numbers, complex numbers, and many other mathematical structures.

For any lattice and additive group type `α` where addition is covariant, the absolute value of zero is zero.


theorem Disjoint.mono_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b c : α}, b ≤ c → Disjoint a c → Disjoint a b :=
  by sorry

The theorem `Disjoint.mono_right` states that for any type `α` that has a partial order and a least element (bottom element, `⊥`), and for any three elements `a`, `b`, and `c` of this type, if `b` is less than or equal to `c` and `a` and `c` are disjoint, then `a` and `b` are also disjoint. Here, two elements are said to be disjoint if for every element `x` that is less than or equal to both of them, `x` is also less than or equal to the bottom element. In other words, the disjointness of `a` and `c` is preserved when replacing `c` with an element `b` that is less than or equal to `c`.

If `α` is a type with a partial order and a least element, and `a`, `b`, and `c` are elements of `α` such that `b ≤ c` and `a` and `c` are disjoint, then `a` and `b` are also disjoint.


theorem Prod.mk.inj_iff :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, (a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂ := by sorry

This theorem states that for any two pairs of elements, where the elements in each pair are from possibly different types (`α` and `β`), the two pairs are equal if and only if the elements at corresponding positions in the pairs are equal. In terms of mathematical notation, given two pairs `(a₁, b₁)` and `(a₂, b₂)` - where `a₁`, `a₂` are of type `α` and `b₁`, `b₂` are of type `β` - the pairs are equal (i.e., `(a₁, b₁) = (a₂, b₂)`) if and only if `a₁ = a₂` and `b₁ = b₂`.

Given pairs `(a:_,_)` and `(b:_,_)` of elements where the first components have type `α` and the second components have type `β`, the pairs are equal if and only if their first components are equal and their second components are equal. (or equivalently, `(a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂`)


MeasureTheory.Integrable.integrableOn

theorem MeasureTheory.Integrable.integrableOn :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α}, MeasureTheory.Integrable f μ → MeasureTheory.IntegrableOn f s μ :=
  by sorry

The theorem `MeasureTheory.Integrable.integrableOn` states that for any types `α` and `E`, where `α` has a measurable space structure and `E` is a normed add commutative group, and for any function `f` from `α` to `E`, any set `s` of type `α`, and any measure `μ` on `α`, if the function `f` is integrable with respect to the measure `μ`, then the function `f` is also integrable on the set `s` with respect to the measure `μ`. In other words, if a function is integrable over the whole space, it is also integrable on any subset of that space.

If a function is integrable with respect to a measure on a measurable space, then it is integrable over any measurable subset of that space.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.5 :
    ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) := by sorry

This theorem states that for any type `α` which has a predefined order (`Preorder α`), and for any two elements `b` and `x` of type `α`, `x` belongs to the set `Set.Iic b` if and only if `x` is less than or equal to `b`. Here, `Set.Iic b` refers to the left-infinite right-closed interval that consists of all elements of the type `α` that are less than or equal to `b`.

For any type `α` with a predefined order and any elements `b` and `x` of type `α`, `x` belongs to the set of elements less than or equal to `b` if and only if `x` is less than or equal to `b`. (In Lean notation, `x ∈ Set.Iic b` if and only if `x ≤ b`.)


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.7 :
    ∀ {α : Type u_1} [inst : Preorder α] {a x : α}, (x ∈ Set.Ici a) = (a ≤ x) := by sorry

This theorem states that for any type `α` with a preorder structure and any elements `a` and `x` of `α`, `x` is in the left-closed right-infinite interval starting at `a` (`Set.Ici a`) if and only if `a` is less than or equal to `x`. In other words, `x` belongs to the interval `[a, ∞)` (notation in mathematical terms) if and only if `a ≤ x`.

For any preordered type `α` and elements `a` and `x` of `α`, `x` belongs to the left-closed right-infinite interval `[a, ∞)` if and only if `a ≤ x`.


theorem by_cases : ∀ {p q : Prop}, (p → q) → (¬p → q) → q := by sorry

This theorem, named `by_cases`, states that for any two propositions `p` and `q`, if `q` can be deduced from both `p` and the negation of `p` (`¬p`), then `q` must be true. In other words, regardless of whether `p` is true or false, if both cases imply the truth of `q`, then `q` is indeed true. This theorem is a formalization of the law of excluded middle in propositional logic.

If `q` can be deduced from both `p` and `¬p`, then `q` is true. (This is the statement of the theorem named `by_cases` in Lean 4, representing the law of excluded middle in propositional logic.)


theorem Filter.principal_univ : ∀ {α : Type u}, Filter.principal Set.univ = ⊤ := by sorry

The theorem `Filter.principal_univ` states that for any type `α`, the principal filter of the universal set `Set.univ` (which includes all elements of type `α`) is equal to the top filter (often denoted as `⊤`). In other words, the collection of all supersets of the universal set for any given type is the same as the most inclusive filter, or top filter.

The principal filter of the universal set in any type equals the top filter.


theorem Filter.Eventually.filter_mono :
    ∀ {α : Type u} {f₁ f₂ : Filter α}, f₁ ≤ f₂ → ∀ {p : α → Prop}, (∀ᶠ (x : α) in f₂, p x) → ∀ᶠ (x : α) in f₁, p x := by
  sorry

This theorem states that for any type `α` and any two filters `f₁` and `f₂` on that type, if `f₁` is a subfilter of `f₂` (that is, `f₁` is less than or equal to `f₂`), then any property `p` that holds "eventually" (that is, outside of a finite set) in `f₂` also holds "eventually" in `f₁`. In other words, if a property is true in the larger filter `f₂`, it will also be true in the smaller filter `f₁`.

If `f₁` is a subfilter of `f₂` on type `α`, then any property holding eventually in `f₂` also holds eventually in `f₁`.


theorem lt_iff_le_not_le : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a < b ↔ a ≤ b ∧ ¬b ≤ a := by sorry

This theorem, `lt_iff_le_not_le`, applies to any type `α` that has a preorder relation defined on it. It establishes an equivalence between two conditions for two elements `a` and `b` of this type: firstly, `a` being strictly less than `b` (`a < b`), and secondly, `a` being less than or equal to `b` (`a ≤ b`) but not the case that `b` is less than or equal to `a` (`¬b ≤ a`). In other words, it provides a characterization of "strict less than" in terms of "less than or equal to" and negation, in the context of preordered sets.

For any preordered type `α`, `a < b` if and only if `a ≤ b` and not `b ≤ a`.


Set.Finite.image

theorem Set.Finite.image : ∀ {α : Type u} {β : Type v} {s : Set α} (f : α → β), Set.Finite s → Set.Finite (f '' s) := by
  sorry

The theorem `Set.Finite.image` asserts that for all types `α` and `β`, and for any set `s` of type `α`, if a function `f` is applied from `α` to `β` and if the original set `s` is finite, then the image of the set `s` under the function `f`, i.e., the set of all `f(x)` for `x` in `s`, is also finite. In other words, the image of a finite set under any function is also finite.

If `f` is a function and `s` is a finite set, then the image of `s` under `f`, i.e., `{f(x) | x ∈ s}`, is also a finite set.


ContinuousLinearMap.continuous

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

This theorem states that for any continuous linear map `f` from a topological module `M₁` over a semiring `R₁` to a topological module `M₂` over a semiring `R₂`, the function `f` is continuous. Here, `σ₁₂` is a ring homomorphism from `R₁` to `R₂`. Note that `M₁` and `M₂` are not only modules but also topological spaces and commutative monoids, and the continuity of `f` is with respect to the topologies on `M₁` and `M₂`.

Given a continuous linear map `f` from a topological module `M₁` over semiring `R₁` to a topological module `M₂` over semiring `R₂` and a ring homomorphism `σ₁₂` from `R₁` to `R₂`, `f` is a continuous function.


theorem Set.compl_subset_compl : ∀ {α : Type u} {s t : Set α}, sᶜ ⊆ tᶜ ↔ t ⊆ s := by sorry

The theorem `Set.compl_subset_compl` states that for any given type `α` and any given sets `s` and `t` of type `α`, the complement of set `s` is a subset of the complement of set `t` if and only if set `t` is a subset of set `s`. Here, the complement of a set `s` (denoted as `sᶜ`) refers to the elements of type `α` that are not in `s`, and '⊆' denotes the subset relation. The theorem provides a fundamental relationship between set inclusion and their complements.

For sets `s` and `t` of type `α`, `sᶜ ⊆ tᶜ` if and only if `t ⊆ s`.


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

The theorem `Quotient.inductionOn₂'` in Lean 4 is a version of `Quotient.inductionOn₂` that takes `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments instead of instance arguments. Specifically, for any data types `α` and `β` with setoid relations `s₁` and `s₂`, respectively, and a proposition `p` that applies to elements of the quotient types `Quotient s₁` and `Quotient s₂`, if the proposition holds for any pairs of elements `a₁` in `α` and `a₂` in `β` (when these elements are considered as elements of the corresponding quotient types via `Quotient.mk''`), then the proposition also holds for any pair of elements `q₁` in `Quotient s₁` and `q₂` in `Quotient s₂`. This theorem is essentially a tool to help reason about quotient structures by reasoning about their equivalence classes.

If `p` holds for all pairs of elements in the quotient types `Quotient s₁` and `Quotient s₂` obtained from sets with setoid relations `s₁` and `s₂`, respectively, then `p` holds for all pairs of quotient elements.


theorem Equiv.apply_eq_iff_eq_symm_apply :
    ∀ {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β), f x = y ↔ x = f.symm y := by sorry

This theorem states that for any two types `α` and `β`, and any elements `x` of `α` and `y` of `β`, and a given equivalence `f` between `α` and `β`, the condition of `f x` being equal to `y` is equivalent to `x` being equal to the inverse of `f` applied to `y`. In mathematical terms, it is saying that if we have a bijective function `f`, then `f(x) = y` if and only if `x = f⁻¹(y)`. This is a common property in mathematics related to bijective (or invertible) functions.

For any bijective function $f$ between types $\alpha$ and $\beta$, $f(x) = y$ if and only if $x = f^{-1}(y)$.


theorem one_nsmul : ∀ {A : Type y} [inst : AddMonoid A] (a : A), 1 • a = a := by sorry

This theorem states that for any type `A` that is an additive monoid, the operation of scalar multiplication of any element `a` of type `A` by 1 results in `a` itself. In mathematical terms, it's saying that in any additive monoid, multiplying an element by the scalar 1 does not change the element, which mirrors the well-known property in regular arithmetic that any number multiplied by 1 remains the same.

For any additive monoid type `A` and its element `a`, 1 * a = a.


ContinuousAt.comp

theorem ContinuousAt.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {x : X} {g : Y → Z},
      ContinuousAt g (f x) → ContinuousAt f x → ContinuousAt (g ∘ f) x :=
  by sorry

The theorem `ContinuousAt.comp` states that for three given types `X`, `Y`, and `Z` each equipped with a topological structure, if `f` is a function from `X` to `Y` and `g` is a function from `Y` to `Z`, and if `f` is continuous at a point `x` in `X` and `g` is continuous at the point `f(x)` in `Y`, then the composition of `g` and `f`, denoted by `g ∘ f`, is continuous at the point `x` in `X`. In terms of mathematics, this theorem is essentially the statement of the composition of continuous functions being continuous.

If functions $f : X \rightarrow Y$ and $g : Y \rightarrow Z$ are continuous at points $x \in X$ and $y = f(x) \in Y$, respectively, then their composition $g \circ f : X \rightarrow Z$ is continuous at $x$.


theorem neg_div : ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] (a b : K), -b / a = -(b / a) :=
  by sorry

The theorem `neg_div` states that for any type `K` which is a division monoid and has distributive negation, the negation of the division of `b` by `a` is the same as the division of the negation of `b` by `a`. In mathematical terms, it says that $-\frac{b}{a} = -(\frac{b}{a})$ for all `a` and `b` in `K`.

For any division monoid `K` with distributive negation, $-(b/a) = (-\ b)/a$.


Monotone.comp

theorem Monotone.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
      {f : α → β}, Monotone g → Monotone f → Monotone (g ∘ f) :=
  by sorry

The theorem `Monotone.comp` states that, for any three types `α`, `β`, and `γ` which are all preordered, if `g` is a function from `β` to `γ` and `f` is a function from `α` to `β`, then if `g` and `f` are both monotone (i.e., if `a ≤ b` then `f a ≤ f b` and if `x ≤ y` then `g x ≤ g y`), then the composition of `g` and `f` is also monotone. That is, for any `a` and `b` in `α`, if `a ≤ b` then `(g ∘ f) a ≤ (g ∘ f) b`.

If `f: α → β` and `g: β → γ` are monotone functions between preordered types, then their composition `g ∘ f: α → γ` is also a monotone function.


theorem Polynomial.aeval_def :
    ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
      (p : Polynomial R), (Polynomial.aeval x) p = Polynomial.eval₂ (algebraMap R A) x p :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, algebra structure between `R` and `A`, element `x` from `A`, and a polynomial `p` with coefficients in `R`, the application of the algebra homomorphism (`Polynomial.aeval x`) to the polynomial `p` is equal to the evaluation of the polynomial `p` at `x` via the ring homomorphism (`algebraMap R A`). In other words, it ensures that evaluating the polynomial through the algebra homomorphism is the same as evaluating it at a specific point using the ring homomorphism provided by the algebra structure.

For any commutative semiring `R`, semiring `A` with an algebra structure over `R`, element `x` from `A`, and polynomial `p` with coefficients in `R`, the application of the algebra homomorphism `Polynomial.aeval x` to `p` equals the evaluation of `p` at `x` via the ring homomorphism `algebraMap R A`.


/-- If two `σ`-linear maps from `R` are equal on `1`, then they are equal.  -/
theorem LinearMap.ext_ring :
    ∀ {R : Type u_1} {S : Type u_6} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M₃] [inst_3 : Module S M₃] {σ : R →+* S} {f g : R →ₛₗ[σ] M₃}, f 1 = g 1 → f = g :=
  by sorry

This theorem states that for any semirings `R` and `S`, a commutative additive monoid `M₃`, and a module `S` over `M₃`, if two `σ`-linear maps `f` and `g` from `R` to `M₃` are equal when applied to the multiplicative identity (1) of `R`, then those two `σ`-linear maps are identical. Essentially, this theorem is about the uniqueness of `σ`-linear maps when they share the same value at the multiplicative identity.

If two `σ`-linear maps from a semiring to a commutative additive monoid, when applied to the multiplicative identity, yield the same result, then those maps are equal.


theorem Filter.comap_principal :
    ∀ {α : Type u} {β : Type v} {m : α → β} {t : Set β},
      Filter.comap m (Filter.principal t) = Filter.principal (m ⁻¹' t) :=
  by sorry

This theorem states that given two types `α` and `β`, a function `m` from `α` to `β`, and a set `t` of elements of type `β`, the preimage filter of the function `m` when applied to the principal filter of the set `t` is equal to the principal filter of the preimage of the set `t` under the function `m`. In other words, it establishes a relationship between the operation of filter preimage and the principal filter construction on sets. The preimage of a set under a function is the set of all elements that map to any element of the original set, and a principal filter of a set is the collection of all supersets of that set.

Given functions between sets and principal filters, the preimage filter of a function applied to a principal filter is equal to the principal filter of the preimage of the set under the function.


theorem Set.left_mem_Icc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ∈ Set.Icc a b ↔ a ≤ b := by sorry

This theorem states that for any type `α` with an associated `Preorder` instance, and any two elements `a` and `b` of the type `α`, `a` is an element of the left-closed right-closed interval from `a` to `b` (`Set.Icc a b`) if and only if `a` is less than or equal to `b`. In mathematical terms, it says that $a$ is in the closed interval $[a, b]$ if and only if $a \leq b$.

For any type `α` with a `Preorder` instance, and any `α` elements `a` and `b`, `a` belongs to the closed interval `[a, b]` if and only if `a ≤ b`.


MeasureTheory.OuterMeasure.empty'

theorem MeasureTheory.OuterMeasure.empty' : ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α), ↑m ∅ = 0 := by sorry

This theorem states that for any type `α` and any outer measure `m` of type `MeasureTheory.OuterMeasure α`, the measure of the empty set is zero. In other words, in the context of measure theory and for any given outer measure, the measure of an empty set is universally zero.

For any outer measure `m`, the measure of the empty set is 0: `m ∘ isEmpty = 0`.


theorem CategoryTheory.Limits.PullbackCone.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      (t : CategoryTheory.Limits.PullbackCone f g),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PullbackCone.fst t) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PullbackCone.snd t) g :=
  by sorry

The theorem `CategoryTheory.Limits.PullbackCone.condition` states that for any category `C` and any three objects `X`, `Y`, `Z` in `C`, and given any two morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, for any pullback cone `t` of `f` and `g`, the composition of the first projection of the pullback cone `t` with `f` is equal to the composition of the second projection of the pullback cone `t` with `g`. This condition is essentially the defining property of a pullback in category theory. The pullback is the limit of a diagram consisting of two morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` with a common codomain `Z`.

In any category, given a pullback cone over morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, the composition of the first projection with `f` equals the composition of the second projection with `g`.


/-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`.  -/
theorem MulEquiv.apply_symm_apply :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N) (y : N), e ((MulEquiv.symm e) y) = y :=
  by sorry

This theorem states that for any two types `M` and `N` equipped with a multiplication operation (denoted `Mul M` and `Mul N` respectively), if there is a multiplicative isomorphism `e` between them (denoted `M ≃* N`), then the inverse of this isomorphism, `e.symm`, applied to any element `y` of `N`, and then re-applied `e` to the result, returns `y` itself. In other words, `e.symm` is a right inverse of `e`. This can be formally written as `e (e.symm y) = y` for any `y` in `N`.

Given types `M` and `N` with multiplicative structures and a multiplicative isomorphism `e : M ≃* N`, the inverse `e.symm` is a right inverse of `e`, i.e., `e (e.symm y) = y` for any `y` in `N`.


theorem Nat.cast_pow : ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑(m ^ n) = ↑m ^ n := by sorry

This theorem states that for any natural numbers `m` and `n`, and any semiring `α`, the cast of the power `m^n` to `α` is equal to the power of the cast of `m` to `α` raised to `n`. In mathematical terms, it asserts that `(m^n : α) = (m : α)^n` for all natural numbers `m` and `n` and any semiring `α`. This is a property related to the interplay between exponentiation and type casting in semirings.

For any natural numbers m and n and semiring α, the cast of m raised to the power n equals the power of the cast of m in α. In other words, (m^n : α) = (m : α)^n.


Filter.Tendsto.congr'

theorem Filter.Tendsto.congr' :
    ∀ {α : Type u} {β : Type v} {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β},
      f₁ =ᶠ[l₁] f₂ → Filter.Tendsto f₁ l₁ l₂ → Filter.Tendsto f₂ l₁ l₂ :=
  by sorry

The theorem `Filter.Tendsto.congr'` establishes the congruence of `Filter.Tendsto`, a predicate which represents the limit of a function. Specifically, for any two functions `f₁` and `f₂` from type `α` to type `β`, and any two filters `l₁` on type `α` and `l₂` on type `β`, if `f₁` and `f₂` are eventually equal at `l₁` (denoted as `f₁ =ᶠ[l₁] f₂`), and if `f₁` tends to `l₂` along `l₁` (represented by `Filter.Tendsto f₁ l₁ l₂`), then `f₂` also tends to `l₂` along `l₁` (expressed as `Filter.Tendsto f₂ l₁ l₂`). In other words, the limit of a function at a point is unaffected if we change the function at a set of points that has negligible "size" in the context of the considered filter.

If `f₁` and `f₂` are eventually equal at a filter `l₁` and `f₁` tends to a filter `l₂` along `l₁`, then `f₂` also tends to `l₂` along `l₁`.


PowerSeries.ext

/-- Two formal power series are equal if all their coefficients are equal. -/
theorem PowerSeries.ext :
    ∀ {R : Type u_1} [inst : Semiring R] {φ ψ : PowerSeries R},
      (∀ (n : ℕ), (PowerSeries.coeff R n) φ = (PowerSeries.coeff R n) ψ) → φ = ψ :=
  by sorry

This theorem states that for any semiring `R` and for any two formal power series `φ` and `ψ` in that semiring, if all the coefficients of `φ` and `ψ` are equal (i.e., for every natural number `n`, the `n`th coefficient of `φ` is equal to the `n`th coefficient of `ψ`), then `φ` and `ψ` are themselves equal. In other words, two formal power series are determined completely by their coefficients.

If two formal power series over a semiring have equal coefficients for all natural numbers, then they are equal.


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

This theorem states that for any non-associative ring `α` and any two integers `m` and `n`, the integer cast of their product (`m * n`) is equal to the product of their integer casts. In other words, multiplication commutes with the operation of integer casting in the context of a non-associative ring.

For any non-associative ring `α` and integers `m` and `n`, the conversion of `m * n` to `α` is equal to the conversion of `m` to `α` multiplied by the conversion of `n` to `α`. In Lean notation: `(cast α m) * (cast α n) = cast α (m * n)`.


theorem CategoryTheory.NatTrans.naturality_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (self : F.NatTrans G) ⦃X Y : C⦄
      (f : X ⟶ Y) {Z : D} (h : G.obj Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (self.app Y) h) =
        CategoryTheory.CategoryStruct.comp (self.app X) (CategoryTheory.CategoryStruct.comp (G.map f) h) :=
  by sorry

In natural language, this theorem states that for any two categories `C` and `D`, with functors `F` and `G` from `C` to `D` and a natural transformation `self` from `F` to `G`, the naturality condition holds. This means that for any objects `X` and `Y` in `C` and any morphism `f` from `X` to `Y`, and a morphism `h` from `G.obj Y` to any object `Z` in `D`, the composition of the transformation of `f` under `F` and the composition of the application of `self` at `Y` with `h` is the same as the composition of the application of `self` at `X` and the composition of the transformation of `f` under `G` with `h`.
This can be stated in the language of category theory as follows: `(F.map f) ≫ (self.app Y ≫ h) = (self.app X) ≫ (G.map f ≫ h)`. This is a fundamental property of natural transformations between functors in category theory, ensuring the commutativity of the diagram associated with the natural transformation.

Given functors F and G from category C to category D, and a natural transformation self from F to G, the naturality condition holds, that is, for any object X in C and morphism f : X -> Y, and any morphism h : G(Y) -> Z in D, (F.map f) . (self.app Y . h) = (self.app X) . (G.map f) . h.


theorem OrderIso.apply_symm_apply :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (x : β), e ((OrderIso.symm e) x) = x :=
  by sorry

The theorem `OrderIso.apply_symm_apply` states that for any types `α` and `β` with a less-than-or-equal-to order (`LE`), given an order isomorphism `e` from `α` to `β` and any element `x` of `β`, applying `e` to the result of applying the inverse of `e` (i.e., `OrderIso.symm e`) to `x` gets us back to the original element `x`. In mathematical terms, it states that if we have an ordered isomorphism between two ordered sets, then this isomorphism is a bijection, meaning that we can go from `β` to `α` using the inverse and then back to `β` using the original isomorphism without changing the original element.

Given an order isomorphism between two ordered sets, the composition of the isomorphism with its symmetric inverse is the identity function.


theorem norm_mul : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a b : α), ‖a * b‖ = ‖a‖ * ‖b‖ := by sorry

This theorem, `norm_mul`, states that for all elements `a` and `b` in a normed division ring `α`, the norm of the product of `a` and `b` (`‖a * b‖`) is equal to the product of the norms of `a` and `b` (`‖a‖ * ‖b‖`). In other words, it confirms the property of multiplicative compatibility with a norm in a normed division ring, which means that the norm of a product is the product of the norms.

For all elements `a` and `b` in a normed division ring `α`, `‖a * b‖ = ‖a‖ * ‖b‖`.


theorem Set.mem_image2_of_mem :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      a ∈ s → b ∈ t → f a b ∈ Set.image2 f s t :=
  by sorry

The theorem `Set.mem_image2_of_mem` states that for all types `α`, `β`, and `γ`, a binary function `f : α → β → γ`, and sets `s` of type `α` and `t` of type `β`, if an element `a` of type `α` belongs to set `s`, and an element `b` of type `β` belongs to set `t`, then the result of applying the function `f` to `a` and `b`, which is `f a b`, belongs to the image of the function `f` over sets `s` and `t`, denoted as `Set.image2 f s t`. This image is a set in `γ` that consists of all possible values of `f a b` where `a` is in `s` and `b` is in `t`.

For all types `α`, `β`, `γ`, function `f : α → β → γ`, sets `s ⊆ α`, and `t ⊆ β`, if `a ∈ s` and `b ∈ t`, then `f a b ∈ Set.image2 f s t`.


/-- **Alias** of the reverse direction of `inf_eq_right`. -/
theorem inf_of_le_right : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, b ≤ a → a ⊓ b = b := by sorry

This theorem, **Alias** of the reverse direction of `inf_eq_right`, states that for any type `α` equipped with a semilattice structure (denoted as `SemilatticeInf α`), for any two elements `a` and `b` of this type, if `b` is less than or equal to `a` (`b ≤ a`), then the infimum (greatest lower bound) of `a` and `b` is `b` (expressed as `a ⊓ b = b`).

For any semilattice `α`, if `b` is a lower bound of `a` and `b` is in `α`, then `a ⊓ b = b`.


theorem Set.finite_singleton : ∀ {α : Type u} (a : α), Set.Finite {a} := by sorry

This theorem states that for any given type `α` and any element `a` of type `α`, the singleton set containing only `a` is finite. In other words, the set `{a}` for any `a` in the universe of discourse `α` is always finite. This is intuitive as a singleton set only contains one element, and therefore its size can be explicitly counted as one, making it finite.

For any type `α` and element `a` of type `α`, the singleton set `{a}` is a finite set with cardinality 1.


theorem Polynomial.eval_mul :
    ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R} {x : R},
      Polynomial.eval x (p * q) = Polynomial.eval x p * Polynomial.eval x q :=
  by sorry

The theorem `Polynomial.eval_mul` states that for any commutative semiring `R`, any two polynomials `p` and `q` over `R`, and any element `x` of `R`, the value of the product of `p` and `q` evaluated at `x` is equal to the product of the values of `p` and `q` evaluated separately at `x`. This is essentially a statement of the distributive property of polynomial multiplication with respect to evaluation.

For any commutative semiring R, polynomials p and q over R, and element x of R, (p * q) x = p x * q x.


MeasurableSet.iUnion

theorem MeasurableSet.iUnion :
    ∀ {α : Type u_1} {ι : Sort u_6} {m : MeasurableSpace α} [inst : Countable ι] ⦃f : ι → Set α⦄,
      (∀ (b : ι), MeasurableSet (f b)) → MeasurableSet (⋃ b, f b) :=
  by sorry

This theorem, `MeasurableSet.iUnion`, states that for any type `α`, index type `ι`, and measure space `m` on `α`, if `ι` is countable and `f` is a function from `ι` to the set of `α` such that every set `f b` for each `b` in `ι` is measurable, then the union of all such sets `f b` is also a measurable set. In mathematical terms, if $\{f(b): b \in \mathbb{N}\}$ is a collection of measurable sets, then $\bigcup_{b \in \mathbb{N}} f(b)$ is also a measurable set.

If `ι` is countable and `f:` `ι` → `MeasurableSet α m` for a measure space `m` on type `α`, then `⋃b in ι. f b` is a measurable set.


theorem Int.zero_add : ∀ (a : ℤ), 0 + a = a := by sorry

This theorem states that for any integer 'a', the result of adding 'a' to zero is 'a' itself, preserving the identity property of addition. In mathematical terms, it asserts that ∀ a ∈ ℤ, 0 + a = a.

For all integers a, the addition of a to zero equals a. (i.e., 0 + a = a)


theorem Mathlib.Data.Finset.Prod._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) := by
  sorry

This theorem states that for any two types `α` and `β`, any two finite sets `s` and `t` of these types, and any pair `p` of type `α` and `β`, the condition that `p` belongs to the cartesian product `s ×ˢ t` is equivalent to the condition that the first element of `p` belongs to `s` and the second element of `p` belongs to `t`.

For any types `α` and `β`, and finite sets `s` of type `α` and `t` of type `β`, a pair `p` belongs to the cartesian product `s ×ˢ t` if and only if its first component belongs to `s` and its second component belongs to `t`.


theorem Polynomial.eval_sub :
    ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R) (x : R),
      Polynomial.eval x (p - q) = Polynomial.eval x p - Polynomial.eval x q :=
  by sorry

The theorem `Polynomial.eval_sub` states that for any ring `R`, any two polynomials `p` and `q` over `R`, and any element `x` of `R`, the value of the polynomial `p - q` evaluated at `x` is equal to the difference of the values of `p` and `q` evaluated at `x`. In other words, when we subtract one polynomial from another and then evaluate the result at a particular point, it's the same as if we evaluated each polynomial at that point and then subtracted the results. This result is a formalization of a fundamental property of polynomial arithmetic.

For any ring `R`, polynomials `p` and `q` over `R`, and element `x` in `R`, `Polynomial.eval_sub R x (p - q) = p x - q x`.


theorem continuousOn_const :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {c : β},
      ContinuousOn (fun x => c) s :=
  by sorry

This theorem states that for any types `α` and `β` which have topological space structures, any set `s` of the type `α`, and any element `c` of the type `β`, the function that maps every element of `s` to `c` is continuous on `s`. In other words, a constant function is always continuous on any set within the corresponding topological spaces.

For any topological spaces `α` and `β`, and any set `s` in `α` and constant function `f : s -> β` with image `{f(x) | x ∈ s} = {c}`, the function `f` is continuous on `s`.


theorem MeasureTheory.StronglyMeasurable.aestronglyMeasurable :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} [inst : TopologicalSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α}, MeasureTheory.StronglyMeasurable f → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

This theorem states that for any function `f` from a type `α` to a type `β`, with `α` having a measurable space structure and `β` a topological space structure, and given a measure `μ` on `α`, if `f` is strongly measurable (i.e., it is the limit of a sequence of simple functions), then `f` is also almost everywhere strongly measurable with respect to the measure `μ`. In other words, `f` is almost everywhere equal to a limit of a sequence of simple functions, except possibly on a set of measure zero.

If `f` is a strongly measurable function from a measurable space `(α, Σ)` to a topological space `(β, τ)` with respect to a measure `μ`, then `f` is almost everywhere equal to a limit of simple functions in `L^1(μ)`.


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

This theorem states that for any type `α` that is a semilattice with supremum (`SemilatticeSup`), and for any two elements `a` and `b` of type `α`, the supremum of `a` and `b` is equal to `a` if and only if `b` is less than or equal to `a`. In other words, in a semilattice structure, the least upper bound or "sup" (`⊔`) of `a` and `b` being `a` implies that `a` is greater or equal to `b`.

In a semilattice with supremum, the supremum of `a` and `b` equals `a` if and only if `b` is less than or equal to `a`.


theorem neg_add : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -(a + b) = -a + -b := by sorry

This theorem, named `neg_add`, states that for any type `α` that forms a subtraction commutative monoid, the negation of the sum of any two elements `a` and `b` of that type is equal to the sum of the negation of `a` and the negation of `b`. In mathematical notation, this would be `-(a + b) = -a + -b` for all `a` and `b` in `α`.

For any commutative monoid `α` with negation operation, `-`, it holds that `-(a + b) = -a + -b` for all `a, b` in `α`.


theorem le_add_of_nonneg_right :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, 0 ≤ b → a ≤ a + b :=
  by sorry

This theorem states that for any type `α` that has an addition operation (`AddZeroClass α`) and a less than or equal to operation (`LE α`), and for this addition operation, if `x + y1` is less than or equal to `x + y2` whenever `y1` is less than or equal to `y2` (`CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1`), then for any two elements `a` and `b` of this type, if `b` is nonnegative (i.e., `0 ≤ b`), then `a` is less than or equal to `a + b`. In other words, adding a nonnegative number to a number will result in a number that is greater than or equal to the original number.

If `α` is a type with `AddZeroClass` and `LE`, and ` CovariantClass` holds for addition and the `LE` relation, then for all `a` and non-negative `b` in `α`, we have `a ≤ a + b`.


theorem div_le_iff : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < b → (a / b ≤ c ↔ a ≤ c * b) :=
  by sorry

This theorem states that for any type `α` which forms a linear ordered semifield, and for any elements `a`, `b`, and `c` of this type where `b` is greater than zero, the statement "a divided by b is less than or equal to c" is equivalent to the statement "a is less than or equal to c times b". In other words, it relates a comparison involving division to a comparison involving multiplication in a specific mathematical structure.

For any linear ordered semifield type `α` and elements `a`, `b` (with `b > 0`) in `α`, `a / b <= c` if and only if `a <= c * b`.


theorem Mathlib.Algebra.Divisibility.Basic._auxLemma.2 : ∀ {α : Type u_1} [inst : Monoid α] (a : α), (a ∣ a) = True :=
  by sorry

This theorem, named `Mathlib.Algebra.Divisibility.Basic._auxLemma.2`, states that for any type `α` that forms a monoid, any element `a` of this type `α` divides itself, which is always true. Here, the term "divides" (`∣`) is used in the algebraic sense, meaning that there exists another element in the monoid such that when it is multiplied by `a`, the result is `a` itself.

For any monoid `α`, every element `a` in `α` divides itself. (In other words, for all `a` in `α`, there exists `x` in `α` such that `a * x = a`.)


theorem nhdsWithin_mono :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) {s t : Set α}, s ⊆ t → nhdsWithin a s ≤ nhdsWithin a t := by
  sorry

This theorem states that for any type `α` equipped with a topology and any element `a` of this type, if we have two sets `s` and `t` of `α` such that `s` is a subset of `t`, then the neighborhood within `s` of `a` is a subset of the neighborhood within `t` of `a`. In other words, it says that restricting the neighborhood of `a` to a smaller set corresponds to a smaller "neighborhood within". This theorem is a statement about the interaction between subsets and the "neighborhood within" filter in a topological space.

For any topological space (α,τ), and elements s ⊆ t and a ∈ α, the neighborhood filter Nbhd(a)|s of a in s is contained in the neighborhood filter Nbhd(a)|t of a in t.


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

This theorem, `iff_of_true`, states that for all propositions `a` and `b`, if `a` is true and `b` is true, then `a` is equivalent to `b`. In other words, if we know that both `a` and `b` are true, we can conclude that `a` if and only if `b`. This is a basic result in propositional logic.

For all propositions `a` and `b`, `(a ∧ b)` is logically equivalent to `(a ≤fFAULT b ∧ b ≤fFAULT a)`. (Note: Lean uses the symbols `∧` for logical and, `≤fFAULT` for logical equivalence.)


theorem Set.mem_iInter : ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, x ∈ ⋂ i, s i ↔ ∀ (i : ι), x ∈ s i := by
  sorry

The theorem `Set.mem_iInter` states that for any type `α`, any index type `ι`, any element `x` of type `α`, and any function `s` from `ι` to the set of `α`, `x` is in the intersection over `i` of `s i` if and only if for every `i` in `ι`, `x` is in `s i`. In other words, an element belongs to the intersection of a collection of sets if and only if it belongs to each set in the collection.

For any type `α`, index type `ι`, function `s` from `ι` to the sets over `α`, and `x` in `α`, `x` is in the intersection of `{s i | i ∈ ι}` if and only if `x` is in `s i` for all `i` in `ι`.


theorem Nat.gcd_dvd_right : ∀ (m n : ℕ), Nat.gcd m n ∣ n := by sorry

This theorem states that for every pair of natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n` divides `n`. In mathematical notation, this can be written as: "For all m, n in ℕ, gcd(m, n) ∣ n". This is a fundamental property of the gcd in number theory.

The greatest common divisor of natural numbers `m` and `n` (gcd(m, n)) is a divisor of `n` (gcd(m, n) | n).


/-- **Alias** of `Int.natCast_dvd_natCast`. -/
theorem Int.coe_nat_dvd : ∀ {m n : ℕ}, ↑m ∣ ↑n ↔ m ∣ n := by sorry

This theorem, named `Int.coe_nat_dvd`, is an alias of `Int.natCast_dvd_natCast`. It states that for all natural numbers `m` and `n`, `m` divides `n` if and only if the integer cast of `m` divides the integer cast of `n`. In other words, the divisibility relationship between `m` and `n` is preserved when they are cast to integers.

For all natural numbers m and n, m | n if and only if (cast m to Int) | (cast n to Int), where "|" denotes divisibility.


theorem SetLike.le_def :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {S T : A}, S ≤ T ↔ ∀ ⦃x : B⦄, x ∈ S → x ∈ T := by sorry

This theorem, `SetLike.le_def`, relates to the notion of set-like structures in Lean 4, specifically those of type `A` that can be treated as though they were sets of type `B`. It states that for any two such structures `S` and `T`, `S` is less than or equal to `T` if and only if every element `x` of type `B` that belongs to `S` also belongs to `T`.

For set-like structures `S` and `T` of types `A` and `B` respectively, `S ≤T` if and only if for all `x:B`, `x ∈ S` implies `x ∈ T`.


theorem false_iff : ∀ (p : Prop), (False ↔ p) = ¬p := by sorry

This theorem, `false_iff`, states that for all propositions `p`, the statement (False is equivalent to `p`) is equivalent to the negation of `p`. In other words, if `p` is equivalent to `False`, then `p` should be false, i.e., `¬p` should be true.

The theorem `false_iff` asserts that for all propositions `p`, `False` is equivalent to the negation of `p`, i.e., `False ≡ ¬p`.


theorem CategoryTheory.Iso.hom_inv_id_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C),
      CategoryTheory.CategoryStruct.comp (α.hom.app X) (α.inv.app X) = CategoryTheory.CategoryStruct.id (F.obj X) :=
  by sorry

This theorem, `CategoryTheory.Iso.hom_inv_id_app`, states that for any two categories `C` and `D`, with `C` being of type `u₁` and `D` being of type `u₂`, and for any two functors `F` and `G` from `C` to `D`, if `α` is an isomorphism between `F` and `G`, then the composition of the morphism from `F` to `G` and the inverse of this morphism, when both are applied to an object `X` in `C`, is equal to the identity morphism on `F.obj X` in `D`. In mathematical terms, we have `(α.hom.app X) ∘ (α.inv.app X) = id(F.obj X)`, where `∘` denotes composition of morphisms, `id(F.obj X)` is the identity morphism on `F.obj X`, and `α.hom.app X` and `α.inv.app X` are the application of the morphism and its inverse to `X`, respectively.

For any categories `C` and `D`, functors `F` and `G` between them, and isomorphism `α` between `F` and `G`, the composition of `α` and its inverse, when applied to any object `X` in `C`, equals the identity morphism on `F(X)` in `D`.


theorem eq_of_forall_le_iff : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (∀ (c : α), c ≤ a ↔ c ≤ b) → a = b := by
  sorry

This theorem, `eq_of_forall_le_iff`, states that for any type `α` that has a partial order, given any two elements `a` and `b` of type `α`, if for every other element `c` of `α`, `c` is less than or equal to `a` if and only if `c` is less than or equal to `b`, then `a` must be equal to `b`. In other words, if `a` and `b` have the same order relationship with all other elements in the set, they are equal.

If two elements `a` and `b` in a partially ordered type `α` have the same relation to all other elements, then `a` and `b` are equal.


theorem Set.union_subset : ∀ {α : Type u} {s t r : Set α}, s ⊆ r → t ⊆ r → s ∪ t ⊆ r := by sorry

The theorem `Set.union_subset` states that for any type `α`, and any three sets `s`, `t`, and `r` of type `α`, if set `s` is a subset of set `r` and set `t` is also a subset of set `r`, then the union of set `s` and set `t` is also a subset of set `r`. This mimics the basic property of sets in mathematics: the union of two subsets of a set is always a subset of that set.

If sets `s` and `t` are subsets of set `r` in type `α`, then their union `s ∪ t` is also a subset of `r`.


Exists.fst

theorem Exists.fst : ∀ {b : Prop} {p : b → Prop}, Exists p → b := by sorry

This theorem, `Exists.fst`, states that for any given proposition `b` and a predicate `p` that maps from `b` to a proposition, if there exists an element that satisfies the predicate `p`, then the proposition `b` holds true. In other words, if there is some element in `b` for which the predicate `p` is true, then `b` itself is true.

If there exists an element x in type B such that predicate p(x) holds, then proposition B is true.


theorem Polynomial.C_0 : ∀ {R : Type u} [inst : Semiring R], Polynomial.C 0 = 0 := by sorry

This theorem states that for any type `R` that has an instance of a semiring, the constant polynomial of 0 (denoted as `Polynomial.C 0`) is equal to the zero polynomial. It means that whenever we create a constant polynomial with the coefficient 0 in the semiring, we get the zero polynomial.

For any semiring `R`, the constant polynomial `Polynomial.C 0` equals the zero polynomial.


theorem sdiff_le : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a \ b ≤ a := by sorry

This theorem states that for any type `α` which has a structure of a Generalized Coheyting Algebra, and for any two elements `a` and `b` of this type, the difference of `a` and `b` (`a \ b`) is always less than or equal to `a`. In mathematical terms, this can be denoted as $a \setminus b \leq a$.

For any Generalized Cohen algebra `α`, and for all `a, b` in `α`, `a \ b ≤ a`.


theorem one_dvd : ∀ {α : Type u_1} [inst : Monoid α] (a : α), 1 ∣ a := by sorry

This theorem states that for all types `α` that form a monoid, the multiplicative identity, i.e., 1, divides any element `a` from the set. In simpler terms, in any multiplication system, 1 is a divisor of every element in the system.

For all types `α` forming a monoid, the multiplicative identity `1` is a divisor of every element `a` in `α`.


CategoryTheory.Limits.HasLimit.mk

theorem CategoryTheory.Limits.HasLimit.mk :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C}, CategoryTheory.Limits.LimitCone F → CategoryTheory.Limits.HasLimit F :=
  by sorry

This theorem states that for any type `J` that forms a category, any type `C` that also forms a category, and any functor `F` from `J` to `C`, if there is a limit cone for `F`, then `F` has a limit. In category theory, a limit of a functor is a universal cone, and a limit cone is a particular cone which is a candidate for being a limit. This theorem provides a way to construct a limit for a functor given a limit cone.

If `J` is a type forming a category, `C` is another category type, and `F : J → C` is a functor with a limit cone, then `F` has a limit.


theorem IsOpen.interior_eq : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s → interior s = s := by
  sorry

The theorem `IsOpen.interior_eq` states that for any set `s` of type `X` in a topological space, if `s` is an open set, then the interior of `s` is equal to `s` itself. In other words, in a topological space, the interior of an open set is the set itself. This theorem is central to the concept of open sets in topology, where the interior of a set is defined as the largest open subset of the set.

In a topological space, an open set is equal to its interior.


theorem Subtype.coe_mk : ∀ {α : Sort u_1} {p : α → Prop} (a : α) (h : p a), ↑{ val := a, property := h } = a := by sorry

This theorem states that for all types `α` and any predicate `p` on `α`, given an element `a` of `α` and a proof `h` that `a` satisfies the predicate `p`, the coercion (indicated by `↑`) of a subtype formed with `a` and `h` is equal to `a`. This essentially means that the subtype element `{ val := a, property := h }` behaves like `a` whenever it is used in a context where `α` is expected.

For all types `α` and predicates `p` on `α`, the coercion of an element `a` of `α` with proof `h` that `a` satisfies `p` is equal to `a`. In other words, the subtype element `{ val := a, property := h }` behaves like `a`.


IsCompl.symm

theorem IsCompl.symm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {x y : α}, IsCompl x y → IsCompl y x := by sorry

This theorem states that in any partially ordered set that also has a smallest and largest element (a bounded order), for any two elements `x` and `y` in the set, if `x` and `y` are complements of each other (denoted by `IsCompl x y`), then `y` and `x` are also complements of each other (`IsCompl y x`). In other words, the "complement" relation is symmetric.

In a bounded partially ordered set, if `x` and `y` are complements of each other, then `y` and `x` are also complements of each other. (IsCompl x y → IsCompl y x)


theorem StrictMono.lt_iff_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono f → ∀ {a b : α}, f a < f b ↔ a < b :=
  by sorry

This theorem states that for all types `α` and `β`, where `α` has a linear order and `β` has a preorder, and for any strictly monotone function `f` from `α` to `β`, then for all `a` and `b` of type `α`, `f(a)` is less than `f(b)` if and only if `a` is less than `b`. In other words, in the context of the given types and orders, a function is strictly monotone if and only if the order of its inputs is preserved when they are mapped under the function.

For any strictly monotone function between a linearly ordered type and a preordered type, input order preservation holds: if $a < b$ in the domain, then $f(a) < f(b)$ in the codomain.


theorem Set.subset_insert : ∀ {α : Type u} (x : α) (s : Set α), s ⊆ insert x s := by sorry

This theorem, `Set.subset_insert`, states that for all types `α`, given an element `x` of type `α` and a set `s` of elements of type `α`, `s` is a subset of the set obtained by inserting `x` into `s`. Here, the `insert x s` operation represents the set which contains all elements from `s` as well as `x` (if not already present in `s`). The symbol `⊆` denotes the subset relation, which means that all elements of `s` are also elements of the set `insert x s`.

For all types `α` and sets `s` of elements of type `α`, and all `x` in `α`, the set `s` is a subset of the set `insert x s`.


TrivSqZeroExt.ext

theorem TrivSqZeroExt.ext :
    ∀ {R : Type u} {M : Type v} {x y : TrivSqZeroExt R M},
      TrivSqZeroExt.fst x = TrivSqZeroExt.fst y → TrivSqZeroExt.snd x = TrivSqZeroExt.snd y → x = y :=
  by sorry

The theorem `TrivSqZeroExt.ext` states that for any two objects `x` and `y` of the type `TrivSqZeroExt R M` (where `R` is a type and `M` is a module over the ring `R`), if the first component (obtained by `TrivSqZeroExt.fst`) of `x` is equal to the first component of `y`, and the second component (obtained by `TrivSqZeroExt.snd`) of `x` is equal to the second component of `y`, then `x` and `y` are indeed equal. This theorem essentially enforces that objects in the Trivial Square-Zero Extension are uniquely defined by their two components.

If two objects in the Trivial Square-Zero Extension of a ring `R` over a module `M` have equal first and second components, then they are equal.


theorem one_lt_two :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : NeZero 1] [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1], 1 < 2 :=
  by sorry

This theorem states that one is less than two in any type, `α`, which is a partially ordered monoid with a zero, a one, the property that zero is less than or equal to one, and satisfies the conditions of a non-zero one and covariant class. In other words, for any such type `α`, the number 1 is strictly less than the number 2.

In any partially ordered monoid type `α` with a zero, a one, zero <= one, and non-zero one, the element 1 is strictly less than 2.


theorem Filter.tendsto_comap_iff :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
      Filter.Tendsto f a (Filter.comap g c) ↔ Filter.Tendsto (g ∘ f) a c :=
  by sorry

The theorem `Filter.tendsto_comap_iff` establishes an equivalence between two conditions regarding function limits for given types `α`, `β`, and `γ`, and for functions `f : α → β` and `g : β → γ`, and filters `a : Filter α` and `c : Filter γ`. The first condition states that the function `f` tends to the filter obtained by the preimage (comap) of `g` over `c` starting from `a`. The second condition states that the composition function `(g ∘ f)` tends to the filter `c` starting from `a`. In other words, the limit of `f` at the preimage of `g` over `c` is equivalent to the limit of `g ∘ f` at `c`.

The theorem `Filter.tendsto_comap_iff` states that a function `f : α → β` tends to the filter obtained by the preimage (composition with `g : β → γ`) of a filter `c : Filter γ` over `f`'s image of a filter `a : Filter α`, if and only if the composition `g ∘ f` tends to `c` over `a`.


theorem MeasureTheory.Measure.restrict_congr_set :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      s =ᶠ[MeasureTheory.Measure.ae μ] t → μ.restrict s = μ.restrict t :=
  by sorry

This theorem states that for any type `α` with a given measurable space `m0` and a measure `μ`, if we have two sets `s` and `t` of type `α`, then if `s` is equal to `t` almost everywhere (denoted by `s =ᶠ[MeasureTheory.Measure.ae μ] t`), the restriction of measure `μ` to set `s` is equal to the restriction of measure `μ` to set `t`. In other words, the measure of `s` and `t` is the same when we only consider points that belong to almost every set in the measure space.

For measurable sets `s` and `t` of type `α` in a measurable space with measure `μ`, if `s =ᶠ[μ] t`, then `μ s = mu t`.


RelEmbedding.injective

theorem RelEmbedding.injective :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s), Function.Injective ⇑f := by
  sorry

The theorem `RelEmbedding.injective` states that for any two types `α` and `β`, along with two corresponding relations `r` and `s`, if a function `f` is a relational embedding from `r` to `s`, then `f` is injective. In other words, whenever two elements `x` and `y` of type `α` satisfy `f(x) = f(y)`, it implies `x = y`. This theorem is an important property of relational embeddings in the context of relation-preserving functions.

If `f` is a relational embedding from relation `r` on type `α` to relation `s` on type `β`, then `f` is an injective function.


theorem Filter.HasBasis.tendsto_iff :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α}
      {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} {f : α → β},
      Filter.HasBasis la pa sa →
        Filter.HasBasis lb pb sb →
          (Filter.Tendsto f la lb ↔ ∀ (ib : ι'), pb ib → ∃ ia, pa ia ∧ ∀ x ∈ sa ia, f x ∈ sb ib) :=
  by sorry

This theorem, `Filter.HasBasis.tendsto_iff`, states that for any types `α`, `β`, `ι`, `ι'`, any filters `la` on `α` and `lb` on `β`, any properties `pa : ι → Prop` and `pb : ι' → Prop`, any sets `sa : ι → Set α` and `sb : ι' → Set β`, and any function `f : α → β`, if `la` has a basis characterized by `pa` and `sa`, and `lb` has a basis characterized by `pb` and `sb`, then the function `f` tends from `la` to `lb` if and only if for all `ib` such that `pb ib` holds, there exists an `ia` such that `pa ia` holds and for all `x` in the set `sa ia`, `f x` belongs to the set `sb ib`.

In other words, under the given conditions, `f` tends from `la` to `lb` precisely when, for each basis element of `lb` indexed by some `ib` satisfying `pb`, we can find a basis element of `la` indexed by some `ia` satisfying `pa` such that the image under `f` of this basis element is contained in the basis element of `lb`.

A function between two filter spaces tends from one filter to another if and only if for every basis element of the target filter indexed by an element satisfying the corresponding property, there exists a basis element of the source filter indexed by an element with the same property such that the image of the source basis element is contained in the target basis element.


theorem Nat.card_congr : ∀ {α : Type u_1} {β : Type u_2}, α ≃ β → Nat.card α = Nat.card β := by sorry

The theorem `Nat.card_congr` states that for any two types `α` and `β`, if `α` is equivalent to `β` (denoted as `α ≃ β`), then the cardinality of `α` (expressed as `Nat.card α`) is equal to the cardinality of `β` (`Nat.card β`). In other words, if there is a one-to-one correspondence between two types, then they have the same cardinality.

If two types are equivalent, they have the same cardinality.


And.imp

theorem And.imp : ∀ {a c b d : Prop}, (a → c) → (b → d) → a ∧ b → c ∧ d := by sorry

This theorem, `And.imp`, states that for any four propositions `a`, `b`, `c`, and `d`, if there is a logical implication from `a` to `c` and from `b` to `d`, then if `a` and `b` are both true, it follows that `c` and `d` are also both true. In mathematical terms, this can be written as: given $(a \rightarrow c)$ and $(b \rightarrow d)$, if $a \land b$ then $c \land d$.

If `a` implies `c` and `b` implies `d`, then `a` and `b` together imply `c` and `d` (i.e., `(a → c)` and `(b → d)` imply `(a ∧ b) → (c ∧ d)`).


theorem add_le_add_iff_left :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b c : α},
      a + b ≤ a + c ↔ b ≤ c :=
  by sorry

This theorem, `add_le_add_iff_left`, states that for all types `α`, if `α` has addition (`Add α`) and an order relation (`LE α`) defined on it, and if it satisfies both covariant and contravariant properties under addition, then for any variable `a` of type `α`, and any two variables `b` and `c` of the same type, the inequality `a + b ≤ a + c` is equivalent to `b ≤ c`.

In mathematical terms, this might be stated as: "Given a type `α` under the conditions of addition and order, the addition of a common term `a` to both sides of an inequality does not change the inequality itself between `b` and `c`."

For all types `α` with addition and order relations, `a + b ≤ a + c` if and only if `b ≤ c`.


HahnSeries.ext

theorem HahnSeries.ext :
    ∀ {Γ : Type u_1} {R : Type u_2} {inst : PartialOrder Γ} {inst_1 : Zero R} (x y : HahnSeries Γ R),
      x.coeff = y.coeff → x = y :=
  by sorry

This theorem states that for any given types `Γ` and `R` where `Γ` is a partially ordered set and `R` is a ring with zero, if we have two Hahn series `x` and `y` (derived from `Γ` and `R`), then `x` equals `y` if and only if their coefficient functions are equal. Essentially, it states that Hahn series are completely determined by their coefficient functions.

For any partially ordered sets Γ and rings with zero R, two Hahn series x and y over Γ and R are equal if and only if their coefficient functions coincide.


theorem two_nsmul : ∀ {M : Type u} [inst : AddMonoid M] (a : M), 2 • a = a + a := by sorry

This theorem states that for any given type `M`, which has an additive monoid structure, the double scalar multiplication of any element `a` of type `M` is equal to the element `a` added to itself. This is more simply expressed as `2 * a = a + a`.

For any additive monoid type `M`, the operation of multiplication by 2 is equivalent to the addition of an element with itself, i.e., `2 * a = a + a` for all `a` in `M`.


theorem Primrec.to_comp :
    ∀ {α : Type u_1} {σ : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable σ] {f : α → σ},
      Primrec f → Computable f :=
  by sorry

The theorem `Primrec.to_comp` states that for any two types `α` and `σ` that are primcodable, and any function `f` from `α` to `σ`, if `f` is primitively recursive (as defined by `Primrec`), then `f` is also computable (as defined by `Computable`). In other words, this theorem states that primitive recursiveness of a function implies its computability.

If `f` is a primitively recursive function between types `α` and `σ` that are primcodable, then `f` is computable.


theorem CategoryTheory.Iso.inv_hom_id_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C),
      CategoryTheory.CategoryStruct.comp (α.inv.app X) (α.hom.app X) = CategoryTheory.CategoryStruct.id (G.obj X) :=
  by sorry

This theorem states that for any two categories `C` and `D`, and any two functors `F` and `G` from `C` to `D` that are isomorphic with isomorphism `α`, for any object `X` in `C`, the composition of the inverse of `α` applied to `X` and `α` applied to `X` is the identity morphism on the object obtained by applying the functor `G` to `X`. In terms of category theory, it expresses the fundamental property of isomorphisms that the composition of an isomorphism and its inverse gives the identity, in the context of functors between categories.

For any categories `C` and `D`, functors `F` and `G` from `C` to `D`, and isomorphism `α` between `F` and `G`, the composite of `α` and its inverse, when applied to any object `X` in `C`, results in the identity morphism on `G(X)`.


AddEquiv.ext

/-- Two additive isomorphisms agree if they are defined by the same underlying function. -/
theorem AddEquiv.ext :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] {f g : M ≃+ N}, (∀ (x : M), f x = g x) → f = g := by
  sorry

This theorem states that two additive isomorphisms, `f` and `g`, between two types `M` and `N` (with an additive structure), are equal if they yield the same result for every element `x` of type `M`. In other words, if for all `x` in `M`, `f(x)` equals `g(x)`, then `f` and `g` are the same additive isomorphism.

If `f` and `g` are additive isomorphisms from type `M` to type `N` such that for all `x` in `M`, `f(x) = g(x)`, then `f = g`.


theorem le_div_iff : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < c → (a ≤ b / c ↔ a * c ≤ b) :=
  by sorry

This theorem states that for any type `α` which forms a Linear Ordered Semifield, given any three elements `a`, `b`, and `c` of this type, where `c` is greater than zero, `a` is less than or equal to `b` divided by `c` if and only if `a` multiplied by `c` is less than or equal to `b`. Here, `/` denotes division and `*` denotes multiplication. So, essentially, it's a property about the relationship between multiplication, division and order in a linear ordered semifield.

For any linear ordered semifield type `α` and elements `a`, `b`, and `c` (with `c > 0`), `a <= b / c` if and only if `a * c <= b`.


theorem Complex.ofReal_neg : ∀ (r : ℝ), ↑(-r) = -↑r := by sorry

This theorem states that for every real number `r`, the complex embedding of the negation of `r` is equal to the negation of the complex embedding of `r`. In other words, it asserts that negation commutes with the process of embedding a real number into the complex numbers.

For every real number `r`, the complex embeddings of `r` and its negation are complex conjugates of each other.


theorem of_not_not : ∀ {a : Prop}, ¬¬a → a := by sorry

This theorem, named `of_not_not`, states that for any proposition `a`, if it is not the case that `a` is not true (denoted as ¬¬a), then `a` is indeed true. In other words, this theorem is about the principle of double negation in classical logic, where denying the denial of a proposition implies the truth of the proposition itself.

If not (not p), then p holds in classical logic.


theorem Function.Injective.ne_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Injective f → ∀ {x y : α}, f x ≠ f y ↔ x ≠ y := by sorry

The theorem `Function.Injective.ne_iff` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is injective (meaning that equal outputs imply equal inputs), then for any two elements `x` and `y` of `α`, the inequality `f(x) ≠ f(y)` is equivalent to `x ≠ y`. In other words, the function does not give the same output for two different inputs, if and only if those inputs are actually different.

For any function between types, injectivity is equivalent to the condition that distinct inputs map to distinct outputs.


theorem OrderIso.symm_apply_apply :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (x : α), (OrderIso.symm e) (e x) = x :=
  by sorry

This theorem states that for any types `α` and `β` that have an order relation (denoted by `LE α` and `LE β`), given an order isomorphism `e` from `α` to `β` and any element `x` of `α`, applying `e` to `x` and then applying the inverse of `e` (denoted by `OrderIso.symm e`) to the result will bring us back to the original element `x`. In other words, the inverse of an order isomorphism undoes the action of the isomorphism. This is analogous to the mathematical concept where the inverse of a function undoes the action of the function itself.

For any order isomorphisms `e: α → β` between ordered types `α` and `β`, `e (x) = OrderIso.symm e (e x)` for all `x` in `α`.


theorem Quot.induction_on :
    ∀ {α : Sort u} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r), (∀ (a : α), β (Quot.mk r a)) → β q := by sorry

This theorem, `Quot.induction_on`, is a principle of mathematical induction for quotient types in Lean 4. For any type `α` and a binary relation `r` on `α`, and for any property `β` of the quotient type formed by `r` on `α`, if every element `a` of `α` satisfies the property `β` when considered as an element of the quotient type via the `Quot.mk` function, then every element `q` of the quotient type satisfies the property `β`. In other words, if we can prove that a property holds for all representatives of an equivalence class, then it holds for the whole equivalence class.

If a property holds for the representatives of every equivalence class of a quotient type formed by a binary relation on a type, then it holds for every element of the quotient type.


/-- See also `Set.nonempty_iff_ne_empty`.  -/
theorem Set.not_nonempty_iff_eq_empty : ∀ {α : Type u} {s : Set α}, ¬Set.Nonempty s ↔ s = ∅ := by sorry

This theorem, `Set.not_nonempty_iff_eq_empty`, establishes the equivalence between the non-existence of a nonempty set `s` of a certain type `α`, denoted as `¬Set.Nonempty s`, and the set `s` being an empty set, denoted as `s = ∅`. This means that for any given set `s`, it is not nonempty if and only if it is an empty set. It suggests that if no elements exist in the set `s` (i.e., the set `s` is not nonempty), then the set `s` is indeed an empty set, and vice versa. This theorem is a formalization of a fundamental concept in set theory.

The theorem asserts that a set `s` of type `α` is nonempty if and only if it is not equal to the empty set `∅`.


theorem CategoryTheory.Limits.colimit.hom_ext :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] {X : C}
      {f f' : CategoryTheory.Limits.colimit F ⟶ X},
      (∀ (j : J),
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j) f =
            CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j) f') →
        f = f' :=
  by sorry

This theorem, `CategoryTheory.Limits.colimit.hom_ext`, states that, given any category `J` with objects of type `u₁`, any category `C` with objects of type `u`, and a functor `F` from `J` to `C` that has a colimit, for any object `X` in `C`, if we have two morphisms `f` and `f'` from the colimit of `F` to `X`, then `f` equals `f'` if and only if for every object `j` in `J`, the composition of the coprojection from `j` to the colimit object and `f` equals the composition of the coprojection from `j` to the colimit object and `f'`. In other words, two morphisms from the colimit to another object are the same if they agree after pre-composing with the coprojections from every object of the original category.

Given a functor with a colimit from a category to another, two morphisms from the colimit to an object are equal if and only if they agree on precomposition with all coprojections from objects in the original category.


theorem add_neg_cancel_right : ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), a + b + -b = a := by sorry

This theorem, `add_neg_cancel_right`, states that for any type `G` that has an addition group structure (denoted by `AddGroup G`), for any two instances `a` and `b` of that type, if we add `b` to `a` and then add the additive inverse of `b` (notated as `-b`), we get `a` back. In other words, adding an element and its negation in an additive group cancels out, leaving the original element — this is a fundamental property of groups. In common mathematical notation, this would be expressed as \(a + b + (-b) = a\).

For any additive group `G` and elements `a` and `b` in `G`, `a + b + (-b) = a`.


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

The theorem `Set.sUnion_eq_biUnion` states that for any type `α` and any set `s` of sets of type `α`, the union of all the sets in `s` (`⋃₀ s`) is equal to the union of all elements that belong to some set in `s` (`⋃ i ∈ s, i`). In other words, it is stating that the union over a set of sets is equivalent to the bi-union over elements in those sets.

For any set `s` of sets over type `α`, the set theoretic union of `s` equals the bi-union over the elements in `s`. In Lean notation, `⋃₀ s = ⋃ i ∈ s, i`.


theorem smul_one_smul :
    ∀ {α : Type u_6} {M : Type u_10} (N : Type u_11) [inst : Monoid N] [inst_1 : SMul M N] [inst_2 : MulAction N α]
      [inst_3 : SMul M α] [inst_4 : IsScalarTower M N α] (x : M) (y : α), (x • 1) • y = x • y :=
  by sorry

This theorem states that for any types `α`, `M`, `N`, given an instance of `Monoid` over `N`, an instance of `SMul` over `M` and `N`, an instance of `MulAction` over `N` and `α`, an instance of `SMul` over `M` and `α`, and an instance of `IsScalarTower` over `M`, `N`, and `α`, for any elements `x` of type `M` and `y` of type `α`, scalar multiplication of `y` by `x • 1` is the same as scalar multiplication of `y` by `x`. In other words, the scalar multiplication of `y` by `x` is not affected by multiplying `x` by the multiplicative identity `1` in the `SMul` structure, which is consistent with the principle that multiplying by the identity element should not change the value.

For any types `M` with a Monoid structure, `N`, `α`, given instances of `SMul` for `M` and `N`, `M` and `α`, `MulAction` for `N` and `α`, and `IsScalarTower` over `M`, `N`, and `α`, scalar multiplication of `α` by `x` is commutative with multiplication of `x` by the multiplicative identity `1` in `M`.