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

The theorem `Set.preimage_comp` states that for all types `α`, `β`, and `γ`, and for every function `f` from `α` to `β`, a function `g` from `β` to `γ`, and a set `s` of type `γ`, the preimage of `s` under the composition of `g` and `f` is equal to the preimage of the preimage of `s` under `g` under `f`. In other words, taking the preimage under a composition of two functions is the same as taking the preimage under each function successively. This is often expressed in mathematical notation as $(g \circ f)^{-1}(s) = f^{-1}(g^{-1}(s))$.

For all types `α`, `β`, `γ`, functions `f : α → β` and `g : β → γ`, and sets `s : Set γ`, the preimage of `s` under the composition `g ∘ f` equals the preimage of the preimage of `s` under `g` under `f`, i.e., `(g ∘ f)⁻¹(s) = f⁻¹(g⁻¹(s))`.


/-- Adding the result of subtracting from another point produces that
point.  -/
theorem vsub_vadd :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ p₂ : P), p₁ -ᵥ p₂ +ᵥ p₂ = p₁ := by sorry

This theorem states that for any two points `p₁` and `p₂` in an additive group `G` with an associated add-torsor `T`, subtracting `p₂` from `p₁` (denoted by `p₁ -ᵥ p₂`) and then adding `p₂` back to the result (denoted by `(p₁ -ᵥ p₂) +ᵥ p₂`) gives us `p₁` back. Essentially, this is saying that adding the result of a subtraction from another point brings us back to the original point. This holds for all points in an additive torsor over an additive group.

For all points `p₁` and `p₂` in an additive group `G` with an associated add-torsor, `p₁ -ᵥ p₂ +ᵥ p₂ = p₁`.


theorem of_eq_false : ∀ {p : Prop}, p = False → ¬p := by sorry

This theorem states that for any proposition `p`, if `p` is equal to `False`, then `p` is not true. In other words, if we have established that a certain proposition is equivalent to `False`, then we can logically conclude that this proposition is not true. This theorem is essentially a formalization of a basic principle in classical logic.

If a proposition is equal to False, then it is not true.


theorem ENNReal.coe_lt_top : ∀ {r : NNReal}, ↑r < ⊤ := by sorry

This theorem states that for every nonnegative real number `r` (denoted as `NNReal`), the co-domain of `r` is less than infinity. In mathematical terms, this theorem asserts that the value of any nonnegative real number is always finite, i.e., it is always less than infinity (denoted by `⊤`).

 Every non-negative real number is finite.

Or equivalently:

The co-domain of every non-negative real number is bounded above.


theorem Nat.Primrec.of_eq : ∀ {f g : ℕ → ℕ}, Nat.Primrec f → (∀ (n : ℕ), f n = g n) → Nat.Primrec g := by sorry

This theorem states that if two functions `f` and `g`, both from natural numbers to natural numbers, are equal for every natural number (i.e., `f n = g n` for all `n`), and if `f` is a primitive recursive function, then `g` is also a primitive recursive function. Essentially, if `f` is proven to be a primitive recursive function, any function equal to `f` across all natural numbers will also be a primitive recursive function.

If a primitive recursive function `f` is equal to function `g` for all natural numbers, then `g` is also a primitive recursive function.


theorem CategoryTheory.Limits.biprod.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f g : Z ⟶ X ⊞ Y),
      CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.biprod.fst =
          CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.biprod.fst →
        CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.biprod.snd =
            CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.biprod.snd →
          f = g :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.hom_ext` states that in a category `C` which has zero morphisms and a binary biproduct of objects `X` and `Y`, for any two morphisms `f` and `g` from an object `Z` to the biproduct `X ⊞ Y`, if the composition of `f` and the projection onto the first summand of the biproduct is equal to the composition of `g` and the same projection, and the composition of `f` and the projection onto the second summand of the biproduct is equal to the composition of `g` and the same projection, then `f` and `g` must be the same morphism. In essence, it provides a uniqueness criterion for morphisms to a biproduct in terms of the compositions with the biproduct projections.

In a category with zero morphisms and binary biproducts, if two morphisms from an object to a biproduct have equal compositions with both projections, they are equal.


theorem norm_smul_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
      [inst_2 : SMulZeroClass α β] [inst_3 : BoundedSMul α β] (r : α) (x : β), ‖r • x‖ ≤ ‖r‖ * ‖x‖ :=
  by sorry

This theorem, `norm_smul_le`, states that for any types `α` and `β` that are seminormed add groups, along with `α` having a scalar multiplication by zero class and being bounded by `β`, for any elements `r` of type `α` and `x` of type `β`, the norm of the scalar multiplication of `r` and `x` (`r • x`) is less than or equal to the product of the norms of `r` and `x` (`‖r‖ * ‖x‖`). This is essentially a generalization of the triangle inequality to seminormed groups and scalar multiplication.

For any seminormed add groups `α` and `β` with scalar multiplication by zero and bounded by `β`, and for any `r` in `α` and `x` in `β`, the norm of their scalar multiplication `‖r • x‖` is less than or equal to the product of the norms of `r` and `x` (`‖r‖ * ‖x‖`).


/-- `Quotient.mk''` is a surjective function.  -/
theorem Quotient.surjective_Quotient_mk'' : ∀ {α : Sort u_1} {s₁ : Setoid α}, Function.Surjective Quotient.mk'' := by
  sorry

The theorem `Quotient.surjective_Quotient_mk''` states that the function `Quotient.mk''` is surjective. In other words, for any type `α` and setoid `s₁` on `α`, every element in the quotient type `Quotient s₁` is an image of some element from `α` under the function `Quotient.mk''`. That is, for every equivalence class in the quotient set, there exists an element from the original set that maps to that equivalence class using the function `Quotient.mk''`.

For any setoid `s₁` on type `α`, the function `Quotient.mk''` maps every element in `Quotient s₁` to some element in `α`.


theorem mul_inv_cancel_right : ∀ {G : Type u_1} [inst : Group G] (a b : G), a * b * b⁻¹ = a := by sorry

This theorem, `mul_inv_cancel_right`, states that for any type `G` that forms a group, for any elements `a` and `b` of the group, the product of `a` and `b` multiplied by the inverse of `b`, or `b⁻¹`, is equal to `a`. Essentially, it expresses the property of a group where the product of an element and its inverse cancels out on the right side, leaving the other factor unchanged.

For any group `G` and elements `a, b` in `G`, `a * b ^-1 = a`.


theorem Asymptotics.IsLittleO_def :
    ∀ {α : Type u_17} {E : Type u_18} {F : Type u_19} [inst : Norm E] [inst_1 : Norm F] (l : Filter α) (f : α → E)
      (g : α → F), f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.IsLittleO_def` states that for any types `α`, `E`, and `F`, with `E` and `F` having a norm, and any filter `l` on `α`, and any functions `f : α → E` and `g : α → F`, the function `f` is little o of `g` with respect to the filter `l` (notated as `f =o[l] g`) if and only if for any positive real number `c`, `f` is Big O of `g` with respect to the filter `l` and constant `c` (notated as `Asymptotics.IsBigOWith c l f g`). In other words, `f` is little o of `g` if `f` is eventually bounded by `c * g` for every positive `c`, modulo issues of division by zero.

For types `α`, `E`, and `F` with normed functions `f : α → E` and `g : α → F`, `f` is little o of `g` with respect to filter `l` if and only if for every `c > 0`, `f` is Big O of `cg` with respect to `l`.


theorem tsub_self :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] (a : α),
      a - a = 0 :=
  by sorry

This theorem, `tsub_self`, states that for any type `α` that forms a canonically ordered additive commutative monoid, and where this type `α` supports subtraction and ordered subtraction operations, subtracting any value `a` of type `α` from itself will always result in zero. Essentially, this theorem is the formal representation in Lean 4 of the familiar arithmetic property that a number minus itself equals zero.

For any type `α` that is a commutative monoid with additive and ordered subtraction operations, `a - a = 0` for all `a` of type `α`.


theorem RingHom.congr_fun :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} {f g : α →+* β},
      f = g → ∀ (x_2 : α), f x_2 = g x_2 :=
  by sorry

This theorem, `RingHom.congr_fun`, states that for any two ring homomorphisms `f` and `g` from a non-associative semiring `α` to another non-associative semiring `β`, if `f` and `g` are equal, then the results of applying `f` and `g` to any element `x_2` from the semiring `α` are also equal. In other words, if two ring homomorphisms are the same, then they map any given element to the same element in the target semiring.

If two ring homomorphisms from a semiring to another semiring are equal, then they map any element to the same image.


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

The theorem `And.imp_right` asserts that for all propositions `a`, `b`, and `c`, if there is an implication from `a` to `b`, then an implication from `c and a` to `c and b` also holds. Simply put, if we know `a` implies `b`, and we have both `c` and `a` being true, it logically follows that `c` and `b` are true.

If `a` implies `b`, then `(c and a)` implies `(c and b)`.


/-- Any two morphisms to a terminal object are equal.  -/
theorem CategoryTheory.Limits.IsTerminal.hom_ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C},
      CategoryTheory.Limits.IsTerminal X → ∀ (f g : Y ⟶ X), f = g :=
  by sorry

This theorem states that in any category 'C', for any two objects 'X' and 'Y' such that 'X' is a terminal object, any two morphisms from 'Y' to 'X' are equal. In other words, if 'X' is a terminal object in the category 'C', then there is a unique morphism from any object 'Y' in 'C' to 'X'.

In any category, a terminal object has unique morphisms from any object.


theorem Multiset.mem_toFinset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ Multiset.toFinset s ↔ a ∈ s := by sorry

The theorem `Multiset.mem_toFinset` states that for any type `α` with a decidable equality relation, and for any element `a` of type `α` and multiset `s` of type `α`, `a` is a member of the finset obtained by removing duplicates from `s` if and only if `a` is a member of `s`. This means that converting a multiset to a finset doesn't change the membership status of its elements.

For any type `α` with decidable equality and any multiset `s` of type `α` and element `a` of type `α`, `a` is in the finset obtained from `s` by removing duplicates if and only if `a` is in `s`.


/-- A strongly measurable function is measurable.  -/
theorem MeasureTheory.StronglyMeasurable.measurable :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x : MeasurableSpace α} [inst : TopologicalSpace β]
      [inst_1 : TopologicalSpace.PseudoMetrizableSpace β] [inst_2 : MeasurableSpace β] [inst_3 : BorelSpace β],
      MeasureTheory.StronglyMeasurable f → Measurable f :=
  by sorry

The theorem states that a strongly measurable function is also measurable. In other words, if a function is defined such that it is the limit of simple functions (which is the definition of being strongly measurable), then this function also has the property of being measurable, meaning that the preimage of every measurable set under this function is also a measurable set. This theorem holds for any types `α` and `β` where `α` is a measurable space and `β` is a topological space, pseudo-metrizable space, measurable space, and Borel space.

A strongly measurable function between measurable spaces is measurable.


Filter.HasBasis.map

theorem Filter.HasBasis.map :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (f : α → β),
      Filter.HasBasis l p s → Filter.HasBasis (Filter.map f l) p fun i => f '' s i :=
  by sorry

The theorem `Filter.HasBasis.map` states that for any types `α`, `β` and a sort `ι`, given a filter `l` on `α`, a property `p` on `ι`, a map `s` from `ι` to a set of `α`, and a function `f` from `α` to `β`, if `l` has a filter basis determined by the property `p` and the map `s`, then the mapped filter `Filter.map f l` also has a filter basis determined by the same property `p` and the image under `f` of the sets produced by `s`. In simpler terms, the theorem asserts that filter bases are preserved under function mapping.

Given a filter `l` on type `α`, property `p` on type `ι`, map `s` from `ι` to `α`, and function `f` from `α` to `β`, if `l` has a filter basis determined by `p` and `s`, then `Filter.map f l` also has a filter basis determined by `p` and the image of `s` under `f`.


theorem Finset.sum_apply :
    ∀ {α : Type u_1} {β : α → Type u_2} {γ : Type u_3} [inst : (a : α) → AddCommMonoid (β a)] (a : α) (s : Finset γ)
      (g : γ → (a : α) → β a), Finset.sum s (fun c => g c) a = Finset.sum s fun c => g c a :=
  by sorry

The theorem `Finset.sum_apply` states that for all types `α`, `β` (which is a function from `α`), and `γ`, and for a particular `α` instance `a` and a finite set `s` of type `γ`, if the additive commutative monoid structure is given for each `β a`, then the sum over the set `s` of applying the function `g` (which takes an element of `γ` and returns a function from `α` to `β a`), and then applying `a`, equals to the sum over the set `s` of applying `g` to an element of `s` and then applying `a`. In other words, it verifies the interchangeability of summing and function application.

For any types `α`, `β`, and `γ`, given a finite set `s` of type `γ`, an additive commutative monoid structure on `β`, and a function `g : γ -> (α -> β a)`, the sum of applying `g` to each element in `s` and then applying `a` is equal to the sum of applying `a` to each element in `s` and then applying `g`.


theorem Filter.Tendsto.prod_mk_nhds :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {γ : Type u_5} {x : X} {y : Y}
      {f : Filter γ} {mx : γ → X} {my : γ → Y},
      Filter.Tendsto mx f (nhds x) →
        Filter.Tendsto my f (nhds y) → Filter.Tendsto (fun c => (mx c, my c)) f (nhds (x, y)) :=
  by sorry

The theorem `Filter.Tendsto.prod_mk_nhds` states that for all types `X`, `Y`, `γ` with `X` and `Y` being topological spaces, for any points `x` in `X` and `y` in `Y`, for any filter `f` on `γ`, and for mappings `mx` from `γ` to `X` and `my` from `γ` to `Y`, if `mx` tends to `x` with respect to `f` and `my` tends to `y` with respect to `f`, then the function that sends each element `c` of `γ` to the pair `(mx c, my c)` also tends towards `(x, y)` with respect to `f`.  This is essentially saying that the limit of a pair of functions is the pair of the limits, when those limits exist in the topologies of `X` and `Y`.

Given topological spaces X and Y, points x in X and y in Y, filters f on a Common limit γ, and functions mx : γ → X and my : γ → Y with mx tending to x and my tending to y with respect to f, then the function sending c in γ to (mx c, my c) tends to (x, y) with respect to f.


theorem disjoint_comm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b ↔ Disjoint b a := by sorry

The theorem `disjoint_comm` states that for any type `α` that is equipped with a partial order and a bottom element, the 'disjointness' of two elements `a` and `b` is commutative, i.e., `a` and `b` are disjoint if and only if `b` and `a` are disjoint. In other words, if for all elements `x` in `α`, `x` being less than or equal to `a` and `b` implies `x` is less than or equal to the bottom element, it's equivalent to saying that `x` being less than or equal to `b` and `a` implies `x` is less than or equal to the bottom element.

For any type `α` with a partial order and a bottom element, `a` and `b` are disjoint if and only if `b` and `a` are disjoint, i.e., if `x <= a` and `x <= b` implies `x = bottom`, then `x <= b` and `x <= a` implies `x = bottom`.


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

This theorem states that for any real number `x`, raising `x` to the power of `1` results in `x` itself. This is a standard property of exponentiation in mathematics, usually written as $x^1 = x$ for all real numbers $x$.


theorem Finset.mem_powerset : ∀ {α : Type u_1} {s t : Finset α}, s ∈ Finset.powerset t ↔ s ⊆ t := by sorry

This theorem states that for any types `α` and finsets `s` and `t` of type `α`, `s` is a member of the powerset of `t` if and only if `s` is a subset of `t`. In other words, a set is in the powerset of `t` if all its elements also belong to `t`.

For any type `α` and finsets `s` and `t` of type `α`, `s` is a subset of `t` if and only if `s` is an element of the powerset of `t`.


theorem Matrix.cons_val_succ :
    ∀ {α : Type u} {m : ℕ} (x : α) (u : Fin m → α) (i : Fin m), Matrix.vecCons x u (Fin.succ i) = u i := by sorry

The theorem `Matrix.cons_val_succ` is stating that for any type `α`, any natural number `m`, any value `x` of type `α`, any function `u` from `Fin m` to `α`, and any value `i` in `Fin m`, if you prepend the value `x` to the vector defined by function `u` using `Matrix.vecCons` and then access the element at the position `Fin.succ i` (which is the successor of `i`), it will be equal to the the element at position `i` in the original vector defined by `u`. This essentially says that indices in the new vector with `Matrix.vecCons` are shifted by one compared to the original vector.

For any type `α`, any natural number `m`, any function `u` from `Fin m` to `α`, and any indices `i`, `Matrix.vecCons (x :: u) i = u i.prev`, where `prev` denotes the predecessor of `i`.


theorem Finsupp.single_apply :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a a' : α} {b : M} [inst_1 : Decidable (a = a')],
      (fun₀ | a => b) a' = if a = a' then b else 0 :=
  by sorry

The theorem `Finsupp.single_apply` states that for any types `α` and `M` with `M` being a type having a zero element, and for any values `a`, `a'` of type `α` and `b` of type `M`, where whether `a` equals `a'` is decidable, the function `fun₀` that maps `a` to `b` and everything else to zero, when applied to `a'`, gives `b` if `a` equals `a'` and gives zero otherwise.

For types `α` and `M` with `M` having a zero element, and decidably equal `α` values `a` and `a'`, the function mapping `a` to `b` in `M` and everything else to zero yields `b` if `a = a'` and zero otherwise.


theorem Finset.sum_map :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] (s : Finset α) (e : α ↪ γ) (f : γ → β),
      (Finset.sum (Finset.map e s) fun x => f x) = Finset.sum s fun x => f (e x) :=
  by sorry

The theorem `Finset.sum_map` states that for any finite set `s` of a type `α`, an embedding function `e` from `α` to another type `γ`, and any function `f` from `γ` to a type `β` that has additive commutative monoid structure, the sum of the function `f` applied over the image set of `s` under the embedding `e` is equal to the sum of the function `f` composed with `e` applied over the set `s`. In simpler terms, when you map each element of a finite set to another set using an embedding and then perform a sum operation, it is the same as if you first apply the function to each element of the original set via the embedding and then sum the results.

For any finite set `s` of type `α`, embedding function `e` from `α` to type `γ`, and additive commutative monoid homomorphism `f` from `γ` to type `β`, the sum of `f` applied to the images of `s` under `e` equals the sum of `f` composed with `e` applied to `s`.


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

The theorem `Mathlib.Data.Set.Intervals.Basic._auxLemma.3` states that for any type `α` with a predefined order (`Preorder`) and for any elements `b` and `x` of type `α`, the condition that `x` is in the set `Set.Iio b` (which is the set of all elements of `α` less than `b`) is equivalent to `x` being strictly less than `b`. In other words, an element belongs to the left-infinite right-open interval ending at `b` if and only if it is strictly smaller than `b`.

For any type `α` with a predefined order, an element `x` in `α` belongs to the set of elements less than `b` if and only if `x` is strictly smaller than `b`.


theorem ne_top_of_le_ne_top :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, b ≠ ⊤ → a ≤ b → a ≠ ⊤ := by sorry

This theorem states that for any type `α`, given that `α` has a partial order and an order top (i.e., a greatest element), if we have two elements `a` and `b` of `α` such that `b` is not the greatest element (i.e., `b ≠ ⊤`) and `a` is less than or equal to `b` (i.e., `a ≤ b`), then `a` cannot be the greatest element either (i.e., `a ≠ ⊤`). In other words, if `a` is not greater than `b` and `b` is not the top element, then `a` cannot be the top element.

If `α` is a type with a partial order and an order top, and `a` and `b` are elements of `α` with `a ≤ b` and `b ≠ ⊤`, then `a ≠ ⊤`.


theorem List.reverse_append :
    ∀ {α : Type u} (as bs : List α), List.reverse (as ++ bs) = List.reverse bs ++ List.reverse as := by sorry

The theorem `List.reverse_append` states that for any type `α` and for any two lists `as` and `bs` of type `α`, reversing the list obtained by appending `as` and `bs` (`as ++ bs`) is equivalent to appending the reversed list of `bs` and the reversed list of `as` (`List.reverse bs ++ List.reverse as`). In other words, reversing an appended list interchanges the order of the original lists and also reverses them individually.

For all types `α` and lists `as` and `bs` of length `m` and `n` respectively, `List.reverse (as ++ bs) = List.reverse bs ++ List.reverse as`.


theorem QuotientAddGroup.leftRel_apply :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {x y : α}, Setoid.r x y ↔ -x + y ∈ s := by sorry

This theorem states that for any type `α` which is an additive group, and any additive subgroup `s` of `α`, and any elements `x` and `y` of `α`, the relation `x ≈ y` (which is defined by the Setoid `r` on `α`) holds if and only if `-x + y` is an element of the subgroup `s`. In other words, in the context of quotient groups, two elements `x` and `y` from an additive group are equivalent (according to the equivalence relation defined by the Setoid) if their difference `-x + y` belongs to the given subgroup.

For any additive group `α`, additive subgroup `s`, and elements `x` and `y` of `α`, `x ≈ y` if and only if `-x + y` is in `s`.


theorem Mathlib.Algebra.Group.Basic._auxLemma.20 :
    ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) := by sorry

This theorem, named `_auxLemma.20` from the `Mathlib.Algebra.Group.Basic` module, states that for any type `α` that is a subtraction monoid and any element `a` of type `α`, `a` is zero if and only if `-a` is zero. In other words, in any subtraction monoid, the additive inverse of an element is zero if and only if the element itself is zero.

In a subtraction monoid, an element and its additive inverse are equal to zero if and only if each other is zero.


MulEquiv.ext

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

This theorem states that two multiplicative isomorphisms `f` and `g` between two types `M` and `N` (which both have multiplication operations) are equal if they are defined by the same underlying function. In other words, if for all elements `x` of type `M`, applying `f` to `x` yields the same result as applying `g` to `x`, then `f` and `g` are the same multiplicative isomorphism.

If two multiplicative isomorphisms between types with multiplication operations have the same function representation, then they are equal.


theorem Order.succ_le_iff :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      Order.succ a ≤ b ↔ a < b :=
  by sorry

This theorem, `Order.succ_le_iff`, states that for any type `α` equipped with a preorder and a successor order (where we can define a "next" element, the successor, for any element of the type), and given two elements `a` and `b` of this type such that `α` has no maximal element, `a` is strictly less than `b` if and only if the successor of `a` is less than or equal to `b`. In other words, the successor of `a` being less than or equal to `b` is equivalent to `a` being strictly less than `b`.

For any type equipped with a preorder and a successor order without a maximal element, `a` strictly less than `b` if and only if the successor of `a` is less than or equal to `b`.


theorem isUnit_one : ∀ {M : Type u_1} [inst : Monoid M], IsUnit 1 := by sorry

This theorem states that for any type `M` that has a `Monoid` structure, the element `1` (which is the identity element in the monoid) is a unit. In other words, there exists an element in `M` that serves as a two-sided inverse for `1`. As per the monoid structure, this inverse is also `1` itself. Therefore, within any monoid, the identity element is considered a unit.

For any Monoid M, the identity element 1 is a unit with left and right inverse equal to 1.


theorem dvd_mul_left : ∀ {α : Type u_1} [inst : CommSemigroup α] (a b : α), a ∣ b * a := by sorry

This theorem states that for any type `α` that is a commutative semigroup, given any two elements `a` and `b` from `α`, `a` divides the product of `b` and `a`. It means `a` is a factor of `b * a` in the context of this specific algebraic structure.

For any commutative semigroup type `α`, and any of its elements `a` and `b`, `a` divides the product `b * a`.


theorem sup_assoc : ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c) := by sorry

This theorem, named `sup_assoc`, states that for all types `α` that form a semilattice under a supremum (`⊔`) operation, the supremum of three elements `a`, `b`, and `c` is associative. In other words, the supremum of `a`, `b`, and `c` is the same whether you first take the supremum of `a` and `b` and then take the supremum with `c`, or first take the supremum of `b` and `c` and then take the supremum with `a`. In mathematical terms, it's stating that `a ⊔ b ⊔ c = a ⊔ (b ⊔ c)`.

For all types `α` with a semilattice structure under the `⊔` operation, the associativity of the supremum holds: `a ⊔ (b ⊔ c) = (a ⊔ b) ⊔ c`.


theorem isOpen_iUnion :
    ∀ {X : Type u} {ι : Sort w} [inst : TopologicalSpace X] {f : ι → Set X},
      (∀ (i : ι), IsOpen (f i)) → IsOpen (⋃ i, f i) :=
  by sorry

The theorem `isOpen_iUnion` states that for any type `X` with a topological space structure, and any indexing type `ι`, if you have a function `f` from `ι` to the sets of `X` such that for each index `i` the set `f i` is open, then the union of all these sets `(⋃ i, f i)` is also an open set in `X`. In other words, in a topological space, the arbitrary union of open sets is again an open set.

In a topological space, the union of any family of open sets is an open set.


theorem IsUnit.mk0 : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (x : G₀), x ≠ 0 → IsUnit x := by sorry

The theorem `IsUnit.mk0` states that for any type `G₀` that is an instance of `GroupWithZero`, for any element `x` of `G₀`, if `x` is not equal to zero, then `x` is a unit. In other words, every non-zero element in a group with zero is a unit, i.e., it has a two-sided inverse.
In the context of mathematics, it's essentially stating that in any multiplicative group that includes a zero element (a `GroupWithZero`), every non-zero element is invertible.

In a multiplicative group with zero, every non-zero element is a unit and has a two-sided inverse.


theorem Set.univ_subset_iff : ∀ {α : Type u} {s : Set α}, Set.univ ⊆ s ↔ s = Set.univ := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, the universal set `Set.univ` is a subset of `s` if and only if `s` is equal to the universal set `Set.univ`. In other words, the only subset that includes every element of the universal set is the universal set itself. This is a standard result in set theory and highlights the maximal nature of the universal set, which by definition contains every element of the given type.

The universal set `Set.univ` is equal to any set `s` if and only if `s` contains the universal set `Set.univ`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.7 : ∀ {α : Type u_1} (a : α), (a ∈ 0) = False := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, `a` does not belong to the empty multiset. In terms of set theory, this is stating that no element belongs to the empty set.

The theorem asserts that there is no element in an empty multiset. (Or equivalently, no element belongs to the empty set in set theory.)


theorem Ordinal.zero_le : ∀ (o : Ordinal.{u_3}), 0 ≤ o := by sorry

This theorem states that for any ordinal `o`, zero is less than or equal to `o`. In other words, in the class of well orders, the ordinal zero is less than or equal to every other ordinal.

For any ordinal `o`, zero is less than or equal to `o` (or equivalently, `0 <= o`).


theorem CategoryTheory.Limits.coprod.desc_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {V W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : V ⟶ W) (g : X ⟶ V) (h : Y ⟶ V),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.desc g h) f =
        CategoryTheory.Limits.coprod.desc (CategoryTheory.CategoryStruct.comp g f)
          (CategoryTheory.CategoryStruct.comp h f) :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.desc_comp` in Lean 4 states that for any category `C` and objects `V`, `W`, `X`, `Y` in `C`, if the binary coproduct of `X` and `Y` exists, then for any morphisms `f : V ⟶ W`, `g : X ⟶ V`, and `h : Y ⟶ V` in `C`, the composition of the morphism `f` with the morphism induced by `g` and `h` from the coproduct `X ⨿ Y` to `V` is equal to the morphism from `X ⨿ Y` to `W` induced by the compositions of `f` with `g` and `f` with `h` respectively. In mathematical notation, this is saying that `(coprod.desc g h) ≫ f = coprod.desc (g ≫ f) (h ≫ f)`.

For any category `C`, objects `V`, `W`, `X`, `Y` in `C`, and morphisms `f : V ⟶ W`, `g : X ⟶ V`, `h : Y ⟶ V`, if the binary coproduct of `X` and `Y` exists, then `(coprod.desc g h) ≫ f = coprod.desc (g ≫ f) (h ≫ f)`.


theorem RingHom.map_pow :
    ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (a : R) (n : ℕ),
      f (a ^ n) = f a ^ n :=
  by sorry

This theorem states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, any element `a` of `R`, and any non-negative integer `n`, the image of `a` to the power of `n` under `f` is the same as the image of `a` under `f` to the power of `n`. In other words, the ring homomorphism preserves the power operation.

For any semirings R and S, any ring homomorphism f : R -> S, and any element a of R and non-negative integer n, f (a^n) = (f(a))^n.


theorem MeasureTheory.ae_eq_refl :
    ∀ {α : Type u_1} {δ : Type u_4} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (f : α → δ),
      f =ᶠ[MeasureTheory.Measure.ae μ] f :=
  by sorry

This theorem states that for any type `α` with a measurable space structure, any measure `μ` on `α`, and any function `f` from `α` to another type `δ`, the function `f` is equal to itself almost everywhere with respect to the measure `μ`. In other words, any discrepancies between `f` and itself only occur on a set of measure zero.

For any measurable function `f` from a measurable space `(α, Σ, μ)` to another measurable space `(δ, τ)`, the sets `{x ∈ α | f x ≠ f x}` and `{x ∈ α | μ({x}) = 0}` have equal measure.


theorem le_iInf₂ :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
      (∀ (i : ι) (j : κ i), a ≤ f i j) → a ≤ ⨅ i, ⨅ j, f i j :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and any indexed family of functions `f : (i : ι) → κ i → α`, if `a` is less than or equal to the result of every function `f i j`, then `a` is also less than or equal to the greatest lower bound (infimum) of all values produced by these functions. In other words, if `a` is lesser or equal to all values in the set produced by the functions, then `a` is also less than or equal to the least element of that set.

If `α` is a complete lattice and `a` is less than or equal to every `f i j`, then `a` is less than or equal to the infimum of all `f i j`.


PNat.pos

theorem PNat.pos : ∀ (n : ℕ+), 0 < ↑n := by sorry

This theorem states that for every positive natural number `n`, the value of `n` when coerced to an integer is strictly greater than zero. In other words, when we take any positive natural number and view it as an integer, the result is always a positive integer.

For every natural number n, the integer coercion of n is positive.


theorem instCoeTCBoundedLatticeHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedLatticeHomClass F α β] (f : F) (a b : α),
      f (a ⊔ b) = f a ⊔ f b :=
  by sorry

This theorem states that, given certain conditions, a specific property holds for a function `f` of type `F` mapping from `α` to `β`. The conditions are that `F` is of type `FunLike F α β`, which means `F` can be injected into a function from `α` to `β`; both `α` and `β` are lattices and bounded orders; and `F` is of class `BoundedLatticeHomClass F α β`.

The property it asserts is that for any two elements `a` and `b` of `α`, the function `f` preserves the lattice operation "join" (`⊔`). More specifically, applying `f` to the join of `a` and `b` (`a ⊔ b`) gives the same result as joining the results of applying `f` to `a` and to `b` separately (`f a ⊔ f b`). In other words, `f` is a homomorphism from the lattice `α` to the lattice `β`.

Given a function `f` of type `F` from a lattice `α` to a lattice `β` of bounded orders and belonging to the class `BoundedLatticeHomClass F α β`, `f` is a lattice homomorphism, i.e., `f (a ⊔ b) = f a ⊔ f b` for all `a, b ∈ α`.


theorem instCoeTCBoundedLatticeHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedLatticeHomClass F α β] (f : F) (a b : α),
      f (a ⊓ b) = f a ⊓ f b :=
  by sorry

This theorem states that for all types `F`, `α`, and `β`, if `F` is a function-like from `α` to `β`, `α` and `β` are lattices, `α` and `β` are both bounded orders, and `F` is a bounded lattice homomorphism from `α` to `β`, then for any function `f` of type `F` and any elements `a` and `b` of type `α`, the image of the infimum (greatest lower bound, denoted by `⊓`) of `a` and `b` under `f` is equal to the infimum of the images of `a` and `b` under `f`. In other words, the function `f` preserves the infimum operation from the lattice `α` to the lattice `β`.

If `F` is a bounded lattice homomorphism from a bounded lattice `α` to a lattice `β`, then for all `a, b ∈ α`, `f(⊓(a, b)) = ⊓(f(a), f(b))`.


theorem mem_nhds_iff :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], s ∈ nhds x ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t := by sorry

This theorem states that for any type `X`, any point `x` of type `X`, and any set `s` of type `Set X` in a given topological space, `s` is a neighborhood of `x` (i.e., `s` is in the neighborhood filter of `x`, represented as `s ∈ nhds x`) if and only if there exists a set `t` such that `t` is a subset of `s` (`t ⊆ s`), `t` is an open set (`IsOpen t`), and `x` is an element of `t` (`x ∈ t`). In more informal terms, a set is a neighborhood of a point in a topological space if and only if it contains an open set in which the point resides.

In a topological space, a set is a neighborhood of a point if and only if it contains an open set that includes the point.


theorem MonoidHom.map_pow :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (a : M) (n : ℕ),
      f (a ^ n) = f a ^ n :=
  by sorry

This theorem states that for any two types `M` and `N`, which both have a `Monoid` structure, and for any homomorphism `f` from `M` to `N`, `f` maps the `n`th power of an element `a` from `M` to the `n`th power of the image of `a` under `f` in `N`. Essentially, this theorem is conveying that a monoid homomorphism preserves the power operation.

For any monoid homomorphisms $f : M \to N$ between monoids $M$ and $N$, and any $a \in M$ and $n \in \mathbb{N}$, we have $f(a^n) = (f(a))^n$.


theorem Set.inter_assoc : ∀ {α : Type u} (a b c : Set α), a ∩ b ∩ c = a ∩ (b ∩ c) := by sorry

This theorem states that for any given type `α` and any three sets `a`, `b`, and `c` of that type, the intersection of the three sets is associative. That is, the intersection of `a`, `b`, and `c` is the same whether we first intersect `a` and `b` and then intersect the result with `c`, or we first intersect `b` and `c` and then intersect the result with `a`. In mathematical terms, `a ∩ b ∩ c = a ∩ (b ∩ c)`.

For any type `α` and sets `a`, `b`, and `c` of that type, the intersection `a ∩ b ∩ c` is equal to `(a ∩ b) ∩ c`.


theorem MeasureTheory.measure_empty :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}, ↑↑μ ∅ = 0 := by sorry

This theorem states that for any type `α`, given that `α` is a measurable space and `μ` is a measure on that space, the measure of the empty set is zero. In mathematical terms, for all spaces `α` and measures `μ`, it holds that `μ(∅) = 0`.

In a measurable space `(α, Σ, μ)`, the measure of the empty set `∅` is zero, i.e., `μ(∅) = 0`.


EquivLike.injective

theorem EquivLike.injective :
    ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E), Function.Injective ⇑e := by sorry

This theorem states that for any types `E`, `α`, and `β`, if `E` has the structure of `EquivLike` (which is a typeclass encapsulating the properties of being equivalent) between `α` and `β`, then for any element `e` of type `E`, the function represented by `e` (denoted by `⇑e` or `coeFn e`) is injective. In other words, if `⇑e x = ⇑e y`, then it must be the case that `x = y`. This property is typical for functions that establish a one-to-one correspondence (or equivalence) between elements of two sets.

If `E` is an equivalence relation between types `α` and `β` (an instance of `EquivLike E α β`), then the function `coeFn : E → α → β` represented by each equivalence `e` in `E` is an injection.


theorem Filter.comap_inf :
    ∀ {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β},
      Filter.comap m (g₁ ⊓ g₂) = Filter.comap m g₁ ⊓ Filter.comap m g₂ :=
  by sorry

This theorem states that for all types `α` and `β`, given a function `m` from `α` to `β`, and two filters `g₁` and `g₂` on `β`, the comap of `m` on the infimum (i.e., the greatest lower bound) of `g₁` and `g₂` is equal to the infimum of the comap of `m` on `g₁` and `g₂`. In mathematical terms, this theorem is saying that the operation of taking the comap under a function distributes over the infimum operation on filters.

For all types `α` and `β`, and functions `m` from `α` to `β`, the comap of `m` on the infimum of filters `g₁` and `g₂` on `β` equals the infimum of the comaps of `m` on `g₁` and `g₂`.


theorem CharP.cast_eq_zero_iff :
    ∀ (R : Type u) [inst : AddMonoidWithOne R] (p : ℕ) [inst_1 : CharP R p] (x : ℕ), ↑x = 0 ↔ p ∣ x := by sorry

This theorem states that for any type `R` that is equipped with the structure of an additive monoid with unit and has characteristic `p`, and for any natural number `x`, the cast of `x` to `R` is equal to zero if and only if `p` divides `x`. This theorem provides a way to check divisibility by `p` using the properties of the characteristic of the ring `R`.

For any additive monoid with unit and characteristic `p` type `R`, the element `x` in `R` obtained by casting a natural number `x` is equal to zero if and only if `p` divides `x`.


theorem add_right_injective :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsLeftCancelAdd G] (a : G), Function.Injective fun x => a + x := by sorry

The theorem `add_right_injective` states that for any type `G` which has an addition operation (`Add G`) and the addition operation in `G` is left cancellative (`IsLeftCancelAdd G`), for any element `a` of type `G`, the function that maps `x` to `a + x` is injective. In other words, if adding a certain value to two different elements in `G` yields the same result, then the two original elements must have been the same.

If `G` is a type with left cancellative addition, then the function `x => a + x` is an injection on `G`.


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

The theorem `sub_le_iff_le_add` states that for any type `α` that has an addition operation (under the AddGroup structure), a less than or equal to (`≤`) relation, and which satisfies the CovariantClass condition with the addition operation and this less than or equal to relation (specifically, the CovariantClass condition for swapped addition), the inequality `a - c ≤ b` is equivalent to `a ≤ b + c`. In simpler terms, it states that in such a structure, subtracting `c` from `a` being less than or equal to `b` is the same as `a` being less than or equal to the sum of `b` and `c`.

For types with an AddGroup structure and a CovariantClass relation between addition and the less than or equal to relation, the subtraction `a - c` being less than or equal to `b` is equivalent to `a` being less than or equal to `b + c`.


Measurable.add

theorem Measurable.add :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f g : α → M}
      [inst_2 : MeasurableAdd₂ M], Measurable f → Measurable g → Measurable fun a => f a + g a :=
  by sorry

The theorem `Measurable.add` states that for all types `M` and `α`, where `M` is a measurable space and has an addition operation, and `α` is a measurable space, if `f` and `g` are measurable functions from `α` to `M` and `M` supports measurable addition, then the function that maps each element `a` in `α` to the sum `f(a) + g(a)` in `M` is also a measurable function. This theorem establishes the measurability of the sum of two measurable functions.

If `M` is a measurable space with an addition operation and `f` and `g` are measurable functions from a measurable space `α` to `M`, then the function that maps each `α` element `a` to the sum `f(a) + g(a)` is measurable.


theorem Filter.EventuallyEq.fun_comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f g : α → β} {l : Filter α},
      f =ᶠ[l] g → ∀ (h : β → γ), h ∘ f =ᶠ[l] h ∘ g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any functions `f` and `g` from `α` to `β` and a function `h` from `β` to `γ`, if `f` and `g` are eventually equal at a filter `l` on `α`, then the compositions `h ∘ f` and `h ∘ g` will also be eventually equal at the same filter `l`. In mathematical notation, this is saying that if $f =_l g$, then $h \circ f =_l h \circ g$.

If functions $f : \alpha \to \beta$ and $g : \alpha \to \beta$ have equal values at a filter $l$ on $\alpha$, then the compositions $h \circ f$ and $h \circ g$ have equal values at the same filter $l$, for any function $h : \beta \to \gamma$.


theorem bot_lt_iff_ne_bot : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, ⊥ < a ↔ a ≠ ⊥ := by
  sorry

This theorem, named `bot_lt_iff_ne_bot`, states that for any type `α` with a partial order and a least element (`OrderBot α`), an element `a` of type `α` is greater than the least element (denoted by `⊥`) if and only if `a` is not equal to the least element. In more mathematical terms, for any partially ordered set with a least element, any element is greater than the least element if and only if it is not the least element itself.

For any partially ordered type with a least element, an element is greater than the least element if and only if it is not equal to the least element.


theorem Set.Nonempty.to_subtype : ∀ {α : Type u} {s : Set α}, Set.Nonempty s → Nonempty ↑s := by sorry

The theorem `Set.Nonempty.to_subtype` states that for any type `α` and any set `s` of type `Set α`, if the set `s` is non-empty (expressed as `Set.Nonempty s`), then there exists an element in the subtype corresponding to `s` (expressed as `Nonempty ↑s`). In other words, if there exists an element in the original set, then there would also exist an element when we view the set as a subtype.

If `s : Set α` is non-empty, then there exists an element in the subtype `Nonempty ↑s`.


/-- Two morphisms into a subobject are equal exactly if
the morphisms into the ambient object are equal  -/
theorem CategoryTheory.Subobject.eq_of_comp_arrow_eq :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {P : CategoryTheory.Subobject Y}
      {f g : X ⟶ CategoryTheory.Subobject.underlying.obj P},
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Subobject.arrow P) =
          CategoryTheory.CategoryStruct.comp g (CategoryTheory.Subobject.arrow P) →
        f = g :=
  by sorry

The theorem `CategoryTheory.Subobject.eq_of_comp_arrow_eq` states that in any category `C`, for any objects `X` and `Y` in `C` and for any subobject `P` of `Y`, if two morphisms `f` and `g` from `X` to the underlying object of `P` have the property that their composition with the arrow from the underlying object of `P` to `Y` (denoted `CategoryTheory.Subobject.arrow P`) are equal, then the original morphisms `f` and `g` were in fact equal. In terms of category theory, this means that morphisms into a subobject are uniquely determined by their composition with the arrow to the ambient object.

In any category, two morphisms with the same composition with the subobject arrow define equal morphisms.


theorem Nat.not_lt_zero : ∀ (n : ℕ), ¬n < 0 := by sorry

This theorem states that for all natural numbers `n`, `n` is not less than zero. In other words, it's impossible for any natural number to be less than zero. This is intuitive, as the set of natural numbers starts from zero and includes all positive integers.

The theorem asserts that for all natural numbers `n`, `0 ≤ n`.


theorem Set.range_iff_surjective :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Set.range f = Set.univ ↔ Function.Surjective f := by sorry

The theorem `Set.range_iff_surjective` states that for all types `α` and `ι` and a function `f` from `ι` to `α`, the range of `f` equals the universal set of `α` if and only if the function `f` is surjective. In other words, a function `f` is surjective, i.e., for every element `b` of `α` there exists an element `a` in `ι` such that `f(a) = b`, if and only if the set of all values that `f` can take (the range of `f`) is the entire set `α`.

A function from type `ι` to type `α` is surjective if and only if its range equals the entire set `α`.


theorem Mathlib.Data.Nat.Cast.Basic._auxLemma.2 : ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) :=
  by sorry

This theorem states that for any semiring `α` and natural numbers `m` and `n`, the power of the cast of `m` to `n` in `α` is equal to the cast in `α` of the power of `m` to `n`. In other words, the process of casting doesn't change the outcome of the exponentiation operation. It holds true for all types `α` that have a semiring structure.

For any semiring `α` and natural numbers `m` and `n`, the cast of `m` to the power of `n` in `α` equals the power of the cast of `m` in `α`.


theorem Multiset.sum_cons :
    ∀ {α : Type u_2} [inst : AddCommMonoid α] (a : α) (s : Multiset α), Multiset.sum (a ::ₘ s) = a + Multiset.sum s :=
  by sorry

The theorem `Multiset.sum_cons` states that for any type `α` that has the structure of a commutative additive monoid, any element `a` of type `α`, and any multiset `s` of elements of type `α`, the sum of the multiset obtained by adding `a` to `s` is equal to the sum of `a` and the sum of `s`. In other words, if you add an element to a multiset, the sum of the new multiset is just the sum of the old multiset plus the added element. This is a property related to the distributive law in the additive monoid.

For any commutative additive monoid type `α` and element `a` of `α`, the sum of a multiset `s` and `a` equals the sum of `s` and `a`.


theorem Int.natAbs_neg : ∀ (a : ℤ), Int.natAbs (-a) = Int.natAbs a := by sorry

This theorem states that for every integer `a`, the absolute value of the negation of `a` is equal to the absolute value of `a` itself. In other words, if you take the negative of an integer and compute its absolute value, you will get the same result as if you took the absolute value of the original integer. This is consistent with the mathematical concept that the absolute value of a number is always non-negative, regardless of whether the number itself is positive or negative.


ContDiffAt.comp

/-- The composition of `C^n` functions at points is `C^n`.  -/
theorem ContDiffAt.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {g : F → G} {n : ℕ∞} (x : E),
      ContDiffAt 𝕜 n g (f x) → ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n (g ∘ f) x :=
  by sorry

This theorem states that if we have two functions, `f` and `g`, that are `C^n` differentiable at a given point `x`, then the composition of `g` and `f`, represented by `(g ∘ f)`, is also `C^n` differentiable at the same point `x`. Here, `C^n` refers to a class of functions that are differentiable up to the `n`th derivative, `𝕜` denotes a non-trivially normed field, `E`, `F`, and `G` are normed addition-commutative groups with a normed space structure over `𝕜`, and `n` can be any natural number or infinity (`ℕ∞`).

If `f : E → F` and `g : F → G` are `C^n` differentiable functions at `x ∈ E`, then `g ∘ f` is `C^n` differentiable at `x`.


Set.Countable.image

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

The theorem `Set.Countable.image` states that for any type `α` and `β`, and any set `s` of type `α`, if `s` is countable, then for any function `f` from `α` to `β`, the image of `s` under `f` is also countable. This means that applying a function to all elements of a countable set results in a new set that is also countable.

If `α` is a countable type and `s : Set α` is countable, then the image `{f x | x ∈ s}` of `s` under a function `f : α → β` is also countable.


UpperSet.ext

theorem UpperSet.ext : ∀ {α : Type u_1} [inst : LE α] {s t : UpperSet α}, ↑s = ↑t → s = t := by sorry

This theorem, `UpperSet.ext`, states that for any type `α` with a less than or equal to (`≤`) relation, given two upper sets `s` and `t` of type `α`, if the coercion (or the underlying set) of `s` is equal to the coercion of `t`, then `s` is equal to `t`. An upper set is a set of elements in which any element that is greater than or equal to any element in the set is also in the set.

If two upper sets of a type with a `≤` relation have equal underlying sets, then they are equal.


theorem Cardinal.lift_natCast : ∀ (n : ℕ), Cardinal.lift.{u, v} ↑n = ↑n := by sorry

This theorem states that for any natural number `n`, the "universe lift" operation on the cardinal number represented by `n` is equal to the cardinal number represented by `n` itself. In other words, lifting the cardinality of a set from one universe to another doesn't change the cardinality when the cardinality is a natural number. This is expressed in Lean 4 as `Cardinal.lift.{u, v} ↑n = ↑n` for all natural numbers `n`.

For all natural numbers `n`, the cardinality lift operations from universe `u` to `v` equal the identity on `n`. (`Cardinal.lift.{u, v} ↑n = ↑n`)


theorem map_div₀ :
    ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
      [inst_2 : FunLike F G₀ G₀'] [inst_3 : MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a b : G₀),
      f (a / b) = f a / f b :=
  by sorry

The theorem `map_div₀` states that for all types `G₀`, `G₀'`, and `F`, given that `G₀` and `G₀'` are groups with zero, the type `F` is a function-like from `G₀` to `G₀'`, and `F` is a class of monoids with zero homomorphism from `G₀` to `G₀'`, then for any function `f` of type `F` and any elements `a` and `b` of `G₀`, the function application of `f` on the division of `a` and `b` (i.e., `f (a / b)`) is equal to the division of the function application of `f` on `a` and on `b` (i.e., `f a / f b`). In other words, the homomorphism `f` preserves the division operation.

Given groups with zero `G₀` and `G₀'`, a function-like `F` from `G₀` to `G₀'` that is a monoid homomorphism with zero, for all `a, b ∈ G₀`, `f (a / b) = f a / f b`.


theorem Ideal.mul_mem_left : ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) (a : α) {b : α}, b ∈ I → a * b ∈ I := by
  sorry

The theorem `Ideal.mul_mem_left` states that for any type `α` that is a semiring and any ideal `I` of `α`, if an element `b` belongs to `I`, then the product of any other element `a` from `α` and `b` also belongs to `I`. This property is essential in the definition of a left ideal in a ring or semiring, whereby multiplication on the left by elements from the ring (or semiring) keeps us within the ideal.

For any semiring `α` and ideal `I` of `α`, if `b` is in `I`, then for all `a` in `α`, we have `a * b` in `I`.


Prime.irreducible

theorem Prime.irreducible : ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {p : α}, Prime p → Irreducible p := by
  sorry

This theorem states that for any type `α` which is a `CancelCommMonoidWithZero` (a commutative monoid with zero that has the cancellation property), if an element `p` of `α` is a prime element, then it is also an irreducible element. In mathematical terms, given a prime element `p` in a commutative monoid with zero, then `p` is irreducible. This means, `p` cannot be expressed as the product of two non-unit elements.

In a commutative monoid with zero having cancellation property, every prime element is irreducible.


theorem Nat.sub_le : ∀ (n m : ℕ), n - m ≤ n := by sorry

This theorem states that for any two natural numbers `n` and `m`, the difference `n - m` is less than or equal to `n`. Essentially, it captures the idea that subtracting any value from a natural number can never result in a number greater than the original number.

For all natural numbers n and m, n - m <= n.


theorem Ideal.eq_top_iff_one : ∀ {α : Type u} [inst : Semiring α] (I : Ideal α), I = ⊤ ↔ 1 ∈ I := by sorry

This theorem states that for any type `α` that is a semiring, and for any ideal `I` of `α`, the ideal `I` is equal to the top element (which represents the whole set) if and only if the number 1 is an element of `I`. In other words, in the context of semirings, an ideal is equivalent to the whole set if it contains the multiplicative identity (1).

For any semiring `α` and ideal `I` of `α`, `I` equals the top element if and only if 1 is in `I`.


theorem Set.image_add_left :
    ∀ {α : Type u_2} [inst : AddGroup α] {t : Set α} {a : α}, (fun x => a + x) '' t = (fun x => -a + x) ⁻¹' t := by
  sorry

This theorem, `Set.image_add_left`, states that for any type `α` that forms an additive group, for any set `t` of elements of type `α`, and for any element `a` from `α`, the image of `t` under the function that adds `a` to each element is the same as the preimage of `t` under the function that subtracts `a` from each element. In other words, if you take a set, add `a` to each element, you obtain the same set as if you took the original set and found the set of all elements that would give you an element in the original set if `a` were subtracted from them.

For any additive group `α`, the image of a set `t` under the successor function `x => x + a` is equal to the preimage of `t` under the subtraction function `x => x - a`.


/-- A multiplicative isomorphism preserves multiplication.  -/
theorem MulEquiv.map_mul :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Mul M] [inst_1 : Mul N] (f : M ≃* N) (x y : M), f (x * y) = f x * f y := by
  sorry

This theorem states that a multiplicative isomorphism preserves the multiplication operation. Specifically, for any types `M` and `N` that have a multiplication operation (expressed by the `Mul` typeclass), if `f` is a multiplicative isomorphism from `M` to `N`, then the image of the product of any two elements `x` and `y` in `M` under `f` is the same as the product of the images of `x` and `y` under `f`. This is to say, applying the function `f` to the product `x * y` gives the same result as multiplying the results of applying `f` to `x` and `y` separately.

Given multiplicative types M and N with multiplication operations, and a multiplicative isomorphism f : M → N, then for all x, y in M, f (x * y) = f x * f y.


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

This theorem, named `neg_ne_zero`, states that for any type `α` that is a subtraction monoid, a value `a` of that type has its negation not equal to zero if and only if `a` itself is not equal to zero. In other words, `-a` is not zero if and only if `a` is not zero, for all `a` in a subtraction monoid.

For any subtraction monoid type `α`, the negation of a non-zero element `a` is not zero.


theorem LE.le.lt_iff_ne : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → (a < b ↔ a ≠ b) := by sorry

This theorem states that for all types `α` with a partial order, given two elements `a` and `b` of that type, if `a` is less than or equal to `b`, then `a` is strictly less than `b` if and only if `a` is not equal to `b`. That is, in a partially ordered set, if `a` isn't equal to `b`, then it must be strictly less than `b` given that `a` is already less than or equal to `b`.

In a partially ordered set, `a` is strictly less than `b` if and only if `a` is less than `b` and `a` is not equal to `b`.


theorem not_imp_comm : ∀ {a b : Prop}, ¬a → b ↔ ¬b → a := by sorry

This theorem states that for any two propositions 'a' and 'b', the statement "not 'a' implies 'b'" is logically equivalent to the statement "not 'b' implies 'a'". In other words, if we have a situation where the non-existence or falseness of 'a' guarantees the existence or truth of 'b', then we must also have the situation where the non-existence or falseness of 'b' guarantees the existence or truth of 'a', and vice versa.

The negations of propositions 'a' and 'b' are logically equivalent: ~a <\imeq> b <=> ~b <\imeq> a.


theorem GaloisConnection.l_u_le :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (a : β), l (u a) ≤ a :=
  by sorry

The theorem `GaloisConnection.l_u_le` states that for any types `α` and `β` that have a preorder relation defined on them, and any functions `l : α → β` and `u : β → α` forming a Galois connection, for every element `a` of type `β`, the inequality `l (u a) ≤ a` holds. In other words, applying `u` to `a` and then `l` to the result never produces a value greater than the original `a`. This is a characteristic property of Galois connections in order theory.

For any Galois connection between types `α` and `β` with functions `l : α → β` and `u : β → α`, `l (u a) ≤ a` for all `a : β`.


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

This theorem states that for any type `α` that is a subtraction commutative monoid, for any elements `a`, `b`, and `c` of type `α`, adding `c` to the result of subtracting `b` from `a` is equivalent to subtracting `b - c` from `a`. In mathematical terms, it says that for all `a`, `b`, and `c` in `α`, we have `a - b + c = a - (b - c)`. This expresses a specific property of subtraction and addition in the context of this particular type of algebraic structure.

For any commutative subtraction monoid type `α` and elements `a`, `b`, and `c` in `α`, `a - b + c = a - (b - c)`.


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

The theorem `Set.subset_inter` states that for all types `α` and for all sets `s`, `t`, and `r` of type `α`, if `r` is a subset of both `s` and `t`, then `r` is a subset of the intersection of `s` and `t`. In other words, if every element of `r` is also an element of `s` and `t`, then every element of `r` is also an element of the intersection of `s` and `t`. This is a fundamental property of set intersection in the context of set theory.

If sets `r`, `s`, and `t` have the property that `r` is a subset of both `s` and `t`, then `r` is a subset of `s ∩ t`.


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

The theorem `Finset.mem_erase` states that for all types `α` that have a decidable equality relation, and for all objects `a`, `b` of type `α` and a finite set `s` of objects of type `α`, the object `a` is a member of the set obtained by removing `b` from `s` if and only if `a` is not equal to `b` and `a` is a member of `s`. In other words, `a` is in the finite set obtained by erasing `b` from `s` precisely when `a` is not `b` and `a` is in the original set `s`.

For any type `α` with decidable equality and finite set `s` of `α`, the element `a` belongs to the set `s \ {b} ` if and only if `a` is not equal to `b` and `a` is in `s`.


/-- The product measure of the product of two sets is the product of their measures. Note that we
do not need the sets to be measurable.  -/
theorem MeasureTheory.Measure.prod_prod :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] (s : Set α)
      (t : Set β), ↑↑(MeasureTheory.Measure.prod μ ν) (s ×ˢ t) = ↑↑μ s * ↑↑ν t :=
  by sorry

This theorem states that, for any two given types `α` and `β` with associated measurable spaces, and given measures `μ` and `ν` where ν is s-finite, the product measure of the product of two sets, `s` from type `α` and `t` from type `β`, is equal to the product of their individual measures. This holds even if the sets `s` and `t` are not measurable. In mathematical terms, for any sets `s` and `t`, we have: `(MeasureTheory.Measure.prod μ ν) (s × t) = μ s * ν t`.

For any s-finite measures μ and ν on measurable spaces (α, Σα) and (β, Σβ), respectively, the product measure of μ and ν on the product measurable space (α × β, Σα × Σβ) equals the product of their individual measures: (μ × ν).(s × t) = μ(s) * ν(t), for any sets s ∈ Σα and t ∈ Σβ.


Finset.Subset.refl

theorem Finset.Subset.refl : ∀ {α : Type u_1} (s : Finset α), s ⊆ s := by sorry

This theorem states that, for any given finite set `s` of an arbitrary type `α`, `s` is a subset of itself. This is a reflection property of subset relation in set theory, and it holds for all types and all finite sets thereof.

For any finite set `s` of type `α`, `s` is a subsets of itself.


theorem CategoryTheory.Groupoid.inv_eq_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {X Y : C} (f : X ⟶ Y),
      CategoryTheory.Groupoid.inv f = CategoryTheory.inv f :=
  by sorry

This theorem, `CategoryTheory.Groupoid.inv_eq_inv`, states that for any given category theory groupoid `C` of some type `u`, and any two objects `X` and `Y` in this groupoid, the inverse of a morphism `f` from `X` to `Y` in the groupoid context (given by `CategoryTheory.Groupoid.inv f`) is equal to the inverse of the same morphism `f` in the context of an isomorphism (given by `CategoryTheory.inv f`). In other words, the inverse morphism in a groupoid and the inverse of an isomorphism are the same entity when they are applied to the same morphism between the same objects in the groupoid.

For any groupoid `C` and morphism `f` in `C` between objects `X` and `Y`, the inverse of `f` in the groupoid context equals the inverse of `f` as an isomorphism.


theorem Matrix.diagonal_apply_eq :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] (d : n → α) (i : n),
      Matrix.diagonal d i i = d i :=
  by sorry

The theorem `Matrix.diagonal_apply_eq` states that for any type `n`, any type `α` that has a zero element, any function `d` mapping from `n` to `α`, and any element `i` of type `n`, the diagonal element `(i, i)` of the square matrix formed by the `Matrix.diagonal` function applied to `d` is equal to the value of the function `d` at `i`. In other words, in any diagonal matrix constructed by the `Matrix.diagonal` function, the diagonal elements are exactly the values given by the input function at corresponding positions.

For any function `d` mapping from type `n` to type `α` with zero element, the diagonal element `(i, i)` of the matrix `Matrix.diagonal d` equals `d i` for all `i` in `n`.


theorem inf_eq_left : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b = a ↔ a ≤ b := by sorry

This theorem, `inf_eq_left`, states that for any type `α` that forms a semilattice under an infimum operation, and for any two elements `a` and `b` of that type, the infimum of `a` and `b` is equal to `a` if and only if `a` is less than or equal to `b`. In simpler terms, in a structure where an "and"-like operation (infimum) is defined, `a` is at most `b` exactly when `a` combined with `b` using this operation results in `a`.

For any semilattice `α` and elements `a, b ∈ α`, `inf a b = a` if and only if `a ≤ b`.


/-- **Alias** of the reverse direction of `sub_neg`.

---

For `a - -b = a + b`, see `sub_neg_eq_add`. -/
theorem sub_neg_of_lt :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      a < b → a - b < 0 :=
  by sorry

This theorem, named `sub_neg_of_lt`, is a variant of the reverse direction of `sub_neg`. It states that for any type `α`, given that `α` has an additive group structure, a less than operation, and satisfies the CovariantClass property with respect to addition and the less than operation, if `a` and `b` are elements of `α` such that `a` is less than `b`, then the difference `a - b` is less than zero. In other words, if `a` is less than `b`, then subtracting `b` from `a` results in a negative number. The equivalent statement in traditional mathematical notation would be: "for all a, b in some additive group, if a < b, then a - b < 0".

If `α` is an additive group with a total order such that the order is covariant with respect to addition, then for all `a` and `b` in `α` with `a < b`, it holds that `a - b` is negative.


theorem LinearMap.ker_eq_bot :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Ring R] [inst_1 : Ring R₂]
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {f : M →ₛₗ[τ₁₂] M₂}, LinearMap.ker f = ⊥ ↔ Function.Injective ⇑f :=
  by sorry

The theorem `LinearMap.ker_eq_bot` states that for any two types `R` and `R₂` which have the structure of rings, and for any two types `M` and `M₂` which form additive commutative groups and are also modules over `R` and `R₂` respectively, for any ring homomorphism `τ₁₂ : R →+* R₂` and any linear map `f : M →ₛₗ[τ₁₂] M₂`, the kernel of the linear map `f` is trivial (denoted as `⊥`) if and only if the function `f` is injective.

In mathematical terms, this theorem is stating that the kernel of a linear map is trivial if and only if the map is injective, which is a fundamental result in linear algebra.

The kernel of a linear map between two module instances over commutative rings is the zero submodule if and only if the map is injective.


theorem inducing_subtype_val : ∀ {Y : Type v} [inst : TopologicalSpace Y] {t : Set Y}, Inducing Subtype.val := by sorry

This theorem states that for any type `Y` equipped with a topological structure (`inst : TopologicalSpace Y`) and a set `t` of type `Y`, the function `Subtype.val` is an inducing function. In topology, an inducing function between two topological spaces is a function that generates the topology of the range space from the topology of the domain space. Here, the `Subtype.val` function, which retrieves the underlying element from a subtype, is such an inducing function. The topology on the subtype is thus the subspace topology inherited from `Y` via the `Subtype.val` function.

The `Subtype.val` function is an inducing function for the subspace topology of a subtype in a topological space.


theorem Multiset.card_map :
    ∀ {α : Type u_1} {β : Type v} (f : α → β) (s : Multiset α), Multiset.card (Multiset.map f s) = Multiset.card s := by
  sorry

The theorem `Multiset.card_map` states that for any function `f` of type `α → β` and any multiset `s` of type `α`, the cardinality of the multiset obtained by mapping `f` over `s` is equal to the cardinality of the original multiset `s`. In other words, applying a function to each element of a multiset does not change its size or cardinality.

For any function `f` and multiset `s`, the cardinality of the multiset obtained by mapping `f` over `s` is equal to the cardinality of `s`.


theorem smul_inv_smul₀ :
    ∀ {α : Type u} {β : Type v} [inst : GroupWithZero α] [inst_1 : MulAction α β] {c : α},
      c ≠ 0 → ∀ (x : β), c • c⁻¹ • x = x :=
  by sorry

This theorem states that for any types `α` and `β`, given that `α` is a group with zero and `β` has a multiplication action by `α`, if `c` is a non-zero element of `α` and `x` is any element of `β`, then the result of scaling `x` by `c⁻¹` (the inverse of `c`) and then by `c` is equal to `x`. In mathematical terms, for any non-zero scalar `c` and any element `x`, we have `c * (c⁻¹ * x) = x`. This essentially confirms the cancellation property in a multiplicative group with zero.

For any non-zero scalar `c` in a group with zero `α` and any element `x` in a type `β` with a right `α`-action, `c * (c⁻¹ * x) = x`.


Function.Surjective.exists

theorem Function.Surjective.exists :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Surjective f → ∀ {p : β → Prop}, (∃ y, p y) ↔ ∃ x, p (f x) :=
  by sorry

The theorem `Function.Surjective.exists` states that for all types `α` and `β`, and any function `f` from `α` to `β`, if `f` is surjective, then for any predicate `p` over `β`, there exists an element `y` in `β` such that `p` holds for `y` if and only if there exists an element `x` in `α` such that `p` holds for `f(x)`. In other words, it says that if a condition holds for some element in the range of a surjective function, then it must hold for some element in the domain when applied to the function.

If `f` is a surjective function from type `α` to type `β`, then for any predicate `p` over `β`, there exists an `x` in `α` such that `p(f(x))` holds if and only if there exists a `y` in `β` such that `p(y)` holds.


theorem le_of_add_le_add_left :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : 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, `le_of_add_le_add_left`, states that for any type `α` that has an addition operation, a "less than or equal to" relation, and is a contravariant class (meaning the sum of two elements is less than or equal to the sum of other two elements if and only if the first two elements are individually less than or equal to the other two elements); if the sum of `a` and `b` is less than or equal to the sum of `a` and `c`, then `b` is less than or equal to `c`. Essentially, it is a statement about the order preserving property of addition in a ordered semigroup.

If `α` is a contravariant class with respect to addition and `a + b ≤ a + c` in `α`, then `b ≤ c`.


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

This theorem states that for any two algebra homomorphisms `φ₁` and `φ₂` from a semiring `A` to another semiring `B` over a common commutative semiring `R`, if `φ₁` and `φ₂` are equal, then they map each element `x` in `A` to the same element in `B`. Essentially, if two algebra homomorphisms are the same, they behave the same way on every element in their domain.

Given two algebra homomorphisms φ₁ and φ₂ from a semiring A to another semiring B over a common commutative semiring R, if φ₁ = φ₂, then ∀x ∈ A, φ₁(x) = φ₂(x).


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

The theorem `Set.mapsTo_image` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and any set `s` of type `α`, the function `f` maps elements of set `s` to the image of `s` under `f`. Here, the image of `s` under `f` (denoted as `f '' s` in Lean 4) is the set of all values that `f` takes on when applied to elements of `s`. Therefore, this theorem is expressing a fundamental property of the image of a set under a function: every element in `s` is mapped to a corresponding element in the image of `s` under `f`.

For any function `f` and set `s`, `s ⊆ image (f) ` (i.e., all elements of `s` are in the image of `f`).


theorem instCoeTCBoundedLatticeHom.proof_5 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedLatticeHomClass F α β] (f : F), f ⊥ = ⊥ :=
  by sorry

The theorem `instCoeTCBoundedLatticeHom.proof_5` states that for any type `F`, types `α` and `β`, given that `F` is a function-like object from `α` to `β`, both `α` and `β` are lattices and bounded orders, and `F` preserves the lattice structure and the bounded order structure (i.e., `F` is a bounded lattice homomorphism), then for any function `f` of type `F`, the image of the bottom element of `α` under `f` is the bottom element of `β`. In other words, `f` maps the least element of `α` to the least element of `β`.

If `F` is a bounded lattice homomorphism from a bounded lattice `α` to a bounded lattice `β`, then `F` maps the bottom element of `α` to the bottom element of `β`.


theorem instCoeTCBoundedLatticeHom.proof_4 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedLatticeHomClass F α β] (f : F), f ⊤ = ⊤ :=
  by sorry

The theorem `instCoeTCBoundedLatticeHom.proof_4` states that for any types `F`, `α`, and `β`, given that `F` has a function-like behavior from `α` to `β` (expressed by `[inst : FunLike F α β]`), `α` and `β` are lattices (`[inst_1 : Lattice α]` and `[inst_2 : Lattice β]`), `α` and `β` are also bounded orders (`[inst_3 : BoundedOrder α]` and `[inst_4 : BoundedOrder β]`), and `F` has the structure of a bounded lattice homomorphism from `α` to `β` (`[inst_5 : BoundedLatticeHomClass F α β]`), then for any `f` of type `F`, the image of the top element of the bounded lattice `α` under `f` is the top element of the bounded lattice `β` (expressed by `f ⊤ = ⊤`).

In simple terms, this theorem says that any bounded lattice homomorphism sends the top element of the source lattice to the top element of the target lattice.

Given types `α` and `β` with `FunLike F α β`, `Lattice α`, `Lattice β`, `BoundedOrder α`, `BoundedOrder β`, and `BoundedLatticeHomClass F α β`, any `f : F`, has `f ⊤ = ⊤`. (A bounded lattice homomorphism `F` from lattice `α` to lattice `β` sends the top element of `α` to the top element of `β`).


theorem instCoeTCBoundedLatticeHom.proof_3 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedLatticeHomClass F α β] (f : F) (a b : α),
      { toSupHom := { toFun := ⇑f, map_sup' := ⋯ }, map_inf' := ⋯ }.toFun (a ⊔ b) =
        { toSupHom := { toFun := ⇑f, map_sup' := ⋯ }, map_inf' := ⋯ }.toFun a ⊔
          { toSupHom := { toFun := ⇑f, map_sup' := ⋯ }, map_inf' := ⋯ }.toFun b :=
  by sorry

The theorem `instCoeTCBoundedLatticeHom.proof_3` states that for all types `F`, `α`, and `β`, if `F` is `FunLike` from `α` to `β`, `α` and `β` are both lattices and bounded orders, and `F` is a bounded lattice homomorphism from `α` to `β`, then for any function `f` of type `F` and any elements `a`, `b` of `α`, the function applied to the supremum of `a` and `b` is equal to the supremum of the function applied to `a` and the function applied to `b`. This is a property of lattice homomorphisms, and specifies that they preserve the lattice structure under the supremum operation.

If `F` is a bounded lattice homomorphism from a lattice and bounded order `α` to a lattice and bounded order `β`, then for all `a, b` in `α`, `F(sup a b) = sup (F a) (F b)`.


theorem real_inner_comm :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F), ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ := by
  sorry

This theorem, `real_inner_comm`, states that for any type `F` which is a normed-additive-commutative-group and also an inner product space over the real numbers, the inner product of any two elements `x` and `y` of this type, denoted as `⟪y, x⟫_ℝ`, is equal to the inner product `⟪x, y⟫_ℝ`. In other words, this theorem demonstrates that the operation of inner product in this context is commutative.

For any normed-additive-commutative group and inner product space `F` over the real numbers, the inner product is commutative: `⟪x, y⟫_ℝ = ⟪y, x⟫_ℝ` for all `x, y ∈ F`.


theorem isOpen_Ioo :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α] {a b : α},
      IsOpen (Set.Ioo a b) :=
  by sorry

The theorem `isOpen_Ioo` states that for any type `α` with a topological space structure, a linear order structure, and an order-closed topology structure, the open interval `(a, b)`, represented in Lean 4 as `Set.Ioo a b`, is an open set in the given topological space. In other words, every interval `(a, b)` is open in any topological space that is also a linearly ordered space with order-closed topology.

In any topological space endowed with a linear order and an order-closed topology, the open interval (a, b) is an open set.


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

The theorem `Disjoint.mono_left` states that for any partially ordered set with a bottom element, and for any three elements `a`, `b`, and `c` in that set, if `a` is less than or equal to `b`, and `b` and `c` are disjoint (i.e., the infimum of `b` and `c` is the bottom element of the set), then `a` and `c` must also be disjoint. In other words, disjointness is preserved when decreasing the first element of the pair.

If `a` is less than or equal to `b`, and `b` and `c` are disjoint elements in a partially ordered set with a bottom element, then `a` and `c` are also disjoint.


theorem add_lt_add_of_lt_of_le :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : Preorder α]
      [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 c d : α},
      a < b → c ≤ d → a + c < b + d :=
  by sorry

The `add_lt_add_of_lt_of_le` theorem states that for any type `α` that is an instance of the `Add` and `Preorder` classes and respects the covariance property over addition and comparison functions, then for any four elements `a`, `b`, `c`, and `d` from `α`, if `a` is less than `b` and `c` is less than or equal to `d`, it implies that the sum of `a` and `c` is less than the sum of `b` and `d`. This is a principle of order theory which states that if you have two ordered pairs where the first element of the first pair is less than the first element of the second pair and the second element of the first pair is less than or equal to the second element of the second pair, then the sum of the elements of the first pair is less than the sum of the elements of the second pair.

For elements `a`, `b`, `c`, `d` of a type `α` with the Add and Preorder instances satisfying covariance property: `a < b` and `c <= d` imply `a + c < b + d`.


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

This theorem states that for any type `α` that is a linear order, and for any three elements `a`, `b`, and `c` of this type, `a` is less than or equal to the maximum of `b` and `c` if and only if `a` is less than or equal to `b` or `a` is less than or equal to `c`. This theorem generalizes the intuitive property of "max" function from number theory to any linearly ordered set.

For any linear order `α` and elements `a`, `b`, `c` in `α`, `a` is less than or equal to the maximum of `b` and `c` if and only if `a` is less than or equal to both `b` and `c`.


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

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than `m`, then the successor of `n` (or `n + 1`) is less than the successor of `m` (or `m + 1`). This theorem captures the intuitive notion that if one number is smaller than another, then adding the same amount to both does not change the inequality.

For all natural numbers `n` and `m`, if `n` < `m`, then `(Suc n)` < `(Suc m)`, where `Suc` denotes the successor function.


HasDerivAt.hasDerivWithinAt

theorem HasDerivAt.hasDerivWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivAt f f' x → HasDerivWithinAt f f' s x :=
  by sorry

This theorem asserts that for any non-trivial normed field 𝕜, normed additive commutative group F, and normed vector space over 𝕜 and F, if a function f: 𝕜 → F has a derivative f' at a point x in 𝕜, then f also has the derivative f' at the point x within any subset s of 𝕜. The derivative at a point x is defined as `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x`. The derivative within a subset s at a point x is the same, but `x'` converges to `x` within the subset s.

If a function f from a normed field to a normed vector space over the field, has a derivative at a point x in the field, then the derivative exists at x in any subset of the field containing x.


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

This theorem, `Finset.singleton_subset_iff`, states that for any type `α`, given a finite set `s` of type `α` and an element `a` of type `α`, the singleton set `{a}` is a subset of `s` if and only if `a` is an element of `s`. In other words, the singleton set `{a}` being a subset of `s` is equivalent to the condition that `a` belongs to `s`.

For any type `α` and any finite set `s` of type `α` and element `a` of type `α`, the singleton set `{a}` is a subset of `s` if and only if `a` is an element of `s`. In mathematical notation, `{a} ⊆ s` if and only if `a ∈ s`.


theorem Real.rpow_nonneg : ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), 0 ≤ x ^ y := by sorry

This theorem states that for all real numbers `x`, if `x` is greater than or equal to zero, then for any real number `y`, `x` raised to the power of `y` (x^y) will also be greater than or equal to zero. In other words, it proves that any non-negative real number raised to any real number power is non-negative.

For all real numbers `x` and `y`, if `x` is non-negative, then `x^y` is non-negative.


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

The theorem `Polynomial.map_mul` states that for any given polynomial `p` and `q` in a given semiring `R`, and a ring homomorphism `f` from `R` to another semiring `S`, the operation of mapping (applying `f`) on the product of `p` and `q` is the same as the product of the mapped polynomials `f(p)` and `f(q)`. This property is also known as the homomorphism property of ring homomorphisms in the context of multiplying polynomials.

For any ring homomorphism between semirings and polynomials over those semirings, applying the homomorphism to the product of two polynomials is equivalent to the product of the mapped polynomials.


/-- In a normed algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, the series defining the exponential map
has an infinite radius of convergence.  -/
theorem NormedSpace.expSeries_radius_eq_top :
    ∀ (𝕂 : Type u_1) (𝔸 : Type u_2) [inst : RCLike 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸],
      FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸) = ⊤ :=
  by sorry

The theorem `NormedSpace.expSeries_radius_eq_top` states that in a normed algebra `𝔸` over a field `𝕂`, which is either the real numbers ℝ or the complex numbers ℂ, the series that defines the exponential map has an infinite radius of convergence. In other words, the series converges for all inputs in the algebra `𝔸`.

In a normed algebra over a field, the exponential series has infinite radius of convergence.


Set.Finite.union

theorem Set.Finite.union : ∀ {α : Type u} {s t : Set α}, Set.Finite s → Set.Finite t → Set.Finite (s ∪ t) := by sorry

The theorem `Set.Finite.union` states that for any type `α`, and any two sets `s` and `t` of that type, if both `s` and `t` are finite sets, then their union (denoted by `s ∪ t`) is also a finite set.

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


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

This theorem, named "MeasureTheory.integral_congr_ae", establishes that for any types `α` and `G`, given `G` is a normed additive commutative group and a normed space over the reals, and given a measurable space `α` and a measure `μ` on this space, if we have two functions `f` and `g` from `α` to `G` that are equal almost everywhere (which means they are equal except on a set of `α` with measure zero), then the integral of `f` with respect to `μ` is equal to the integral of `g` with respect to `μ`. This means, the difference between functions on a set of measure zero does not change the value of their integrals.

If `f` and `g` are almost everywhere equal measurable functions from a measurable space `(α, μ)` to a normed additive commutative group and normed space over the reals, then they have equal integrals with respect to the measure `μ`.


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

This theorem, named `add_sub_assoc`, states that for any given type 'G' that is a SubNegMonoid (a certain mathematical structure), for any three elements 'a', 'b', and 'c' of this type 'G', the operation of adding 'b' to 'a', and from the result subtracting 'c' (expressed as `a + b - c`), is equal to the operation of subtracting 'c' from 'b', and then adding the result to 'a' (expressed as `a + (b - c)`). This is an associative property between addition and subtraction in the context of a SubNegMonoid.

For any SubNegMonoid type 'G' and elements 'a', 'b', 'c' in 'G', the expression 'a + (b - c)' equals '(a + b) - c'.


theorem measurable_pi_iff :
    ∀ {α : Type u_1} {δ : Type u_4} {π : δ → Type u_6} [inst : MeasurableSpace α]
      [inst_1 : (a : δ) → MeasurableSpace (π a)] {g : α → (a : δ) → π a},
      Measurable g ↔ ∀ (a : δ), Measurable fun x => g x a :=
  by sorry

The theorem `measurable_pi_iff` states that for any types `α`, `δ` and a type function `π : δ → Type`, given measurable spaces over `α` and each type `π a` for `a : δ`, a function `g : α → (a : δ) → π a` is measurable if and only if for every `a : δ`, the function `fun x => g x a` is measurable. In simpler words, a function `g` that maps a value from one measurable space to a function in another measurable space is measurable if all functions that result from fixing an argument `a` in the second space are measurable. This theorem connects the notion of measurability of a function in the context of measurable spaces with the measurability of its partial application functions.

A function `g : α → δ → π a` is measurable with respect to the measurable spaces over `α` and each `π a` if and only if for every `a : δ`, the function `fun x => g x a` is measurable.


theorem MeasureTheory.integral_const :
    ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [hE : CompleteSpace E]
      {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (c : E), ∫ (x : α), c ∂μ = (↑↑μ Set.univ).toReal • c :=
  by sorry

The theorem `MeasureTheory.integral_const` states that for any type `α` and a normed additive commutative group `E` that is also a normed space over the real numbers and a complete space, given any measurable space over `α`, a measure `μ` on that measurable space, and a constant `c` of type `E`, the integral of the constant function that assigns `c` to every `α` with respect to the measure `μ` is equal to the real part of the measure of the universal set, scaled by `c`. In mathematical notation, this can be represented as ∫ c dμ = μ(Univ) * c.

For any measurable space `(α, Σ, μ)` over a real normed space `E`, the integral of the constant function `c : E` is equal to `c * μ(Univ)`, where `Univ` denotes the universal set.


theorem Mathlib.GroupTheory.Perm.Support._auxLemma.15 :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α},
      (x ∈ Equiv.Perm.support f) = (f x ≠ x) :=
  by sorry

This theorem, named `Mathlib.GroupTheory.Perm.Support._auxLemma.15`, states that for any type `α` with decidable equality and of finite size, for any permutation `f` on `α`, and for any element `x` of type `α`, `x` is in the support of the permutation `f` if and only if the permutation `f` does not fix `x`. In other words, the support of a permutation consists exactly of those elements which are not left unchanged by the permutation.

For any finite type `α` with decidable equality, a permutation `f` on `α` fixes an element `x` if and only if `x` is not in the support of `f`.


Sum.inl.injEq

theorem Sum.inl.injEq : ∀ {α : Type u} {β : Type v} (val val_1 : α), (Sum.inl val = Sum.inl val_1) = (val = val_1) := by
  sorry

This theorem, `Sum.inl.injEq`, states that for any types `α` and `β`, and any two values `val` and `val_1` of type `α`, the equality of `Sum.inl val` and `Sum.inl val_1` is equivalent to the equality of `val` and `val_1`. In other words, wrapping two values of type `α` into the left component of the sum type does not change their equality status.

For all types `α` and values `val` and `val_1` of type `α`, `Sum.inl val = Sum.inl val_1` if and only if `val = val_1`.


theorem le_inf_iff : ∀ {α : Type u} [inst : SemilatticeInf α] {a b c : α}, a ≤ b ⊓ c ↔ a ≤ b ∧ a ≤ c := by sorry

This theorem, `le_inf_iff`, states that for any type `α` that forms a semilattice with an infimum operation, given any three elements `a`, `b`, and `c` of type `α`, `a` is less than or equal to the infimum of `b` and `c` if and only if `a` is less than or equal to `b` and `a` is less than or equal to `c`.

For any semilattice type `α` with infimum operation, `a ≤ inf(b, c)` if and only if `a ≤ b` and `a ≤ c`.


theorem Mathlib.Data.Nat.Cast.Basic._auxLemma.1 :
    ∀ {α : Type u_1} [inst : NonAssocSemiring α] (m n : ℕ), ↑m * ↑n = ↑(m * n) := by sorry

This theorem states that for any type `α` that is a `NonAssocSemiring`, and any two natural numbers `m` and `n`, the cast of the product of `m` and `n` to `α` is equal to the product of the casts of `m` and `n` to `α`. In mathematical terms, this translates to the assertion that for any non-associative semiring `α`, multiplication is preserved under the casting from natural numbers to `α`, i.e., `↑m * ↑n = ↑(m * n)`.

For any non-associative semiring `α`, the casting of the product of two natural numbers to `α` is equal to the product of the castings of those numbers to `α`. In mathematical notation: `↑(m * n) = ↑m * ↑n`.


theorem nsmul_zero : ∀ {A : Type y} [inst : AddMonoid A] (n : ℕ), n • 0 = 0 := by sorry

This theorem states that for any natural number `n` and any type `A` that is an additive monoid, the scalar multiplication of `n` with the zero element of `A` is also the zero element of `A`. In more mathematical terms, this theorem says that for any `n` in ℕ and any additive monoid `A`, `n` times `0` equals `0`.

For any natural number `n` and additive monoid `A`, the product of `n` and the zero element of `A` is equal to the zero element of `A`.


/-- **Alias** of the reverse direction of `Finset.sup_le_iff`. -/
theorem Finset.sup_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
      (∀ b ∈ s, f b ≤ a) → Finset.sup s f ≤ a :=
  by sorry

The theorem `Finset.sup_le` in Lean 4 states that for any types `α` and `β`, given a semi lattice `α` with a least element, a finite set `s` of elements of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, if for all elements `b` in the set `s`, the image of `b` under `f` is less than or equal to `a`, then the supremum of the set `s` under the function `f` is also less than or equal to `a`. This theorem is an alias of the converse implication of `Finset.sup_le_iff`.

If `α` is a semi-lattice with a least element, `s` is a finite set of elements from type `β`, `f` is a function from `β` to `α`, and for all `b` in `s`, `f(b) ≤ a`, then `sup(s : β → α) ≤ a` in `α`.


theorem CategoryTheory.Limits.limMap_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F]
      [inst_3 : CategoryTheory.Limits.HasLimit G] (α : F ⟶ G) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limMap α) (CategoryTheory.Limits.limit.π G j) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.π F j) (α.app j) :=
  by sorry

The theorem `CategoryTheory.Limits.limMap_π` states that for any two categories `J` and `C` and two functors `F` and `G` from `J` to `C`, if `F` and `G` have limits and there is a natural transformation `α` from `F` to `G`, then for any object `j` in `J`, the composition of the map from the limit of `F` to `G` with the projection from the limit of `G` to the object `j` is equal to the composition of the projection from the limit of `F` to the object `j` with the application of the natural transformation `α` to `j`. This is a statement about the commutativity of a certain diagram involving limits in a category, which is a fundamental concept in category theory.

For any functors F and G from category J to category C with limiting cones, and a natural transformation α from F to G, the diagram commutes, that is, the projection of the limit of F to an object j in J through α is equal to the composition of the projection of the limit of F to j and α(j).


theorem Equiv.eq_symm_apply : ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, y = e.symm x ↔ e y = x := by
  sorry

This theorem states that for any types `α` and `β`, for any equivalence relation `e` between `α` and `β`, and for any elements `x` in `β` and `y` in `α`, `y` is equal to the inverse of `e` applied to `x` if and only if `e` applied to `y` is equal to `x`. In other words, it connects the application of an equivalence relation and its inverse, and their relationships with the respective elements of the types.

For any equivalence relation e on types α and β, x ∈ β, and y ∈ α, x = e. inverse(y) if and only if e(y) = x.


theorem zpow_add : ∀ {G : Type w} [inst : Group G] (a : G) (m n : ℤ), a ^ (m + n) = a ^ m * a ^ n := by sorry

This theorem, `zpow_add`, states that for any type `G` that forms a group, for any element `a` of `G`, and for any two integers `m` and `n`, the power of `a` raised to the sum of `m` and `n` is equal to the product of `a` raised to the power of `m` and `a` raised to the power of `n`. In mathematical terms, it expresses the rule that $a^{(m+n)} = a^m * a^n$ for all `a` in `G` and all integers `m` and `n`.

For any group `G` and elements `a` in `G` and integers `m` and `n`, `a^(m + n) = a^m * a^n`.


Nat.Coprime.symm

theorem Nat.Coprime.symm : ∀ {n m : ℕ}, Nat.Coprime n m → Nat.Coprime m n := by sorry

This theorem states that the property of two natural numbers being coprime is symmetric. In other words, if two natural numbers `n` and `m` are coprime (that is, their greatest common divisor (gcd) is 1), then swapping their order doesn't change their coprimality: `m` and `n` are also coprime.

If natural numbers `n` and `m` are coprime, then `m` and `n` are also coprime.