theorem Set.preimage_univ : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, f ⁻¹' Set.univ = Set.univ := by sorry

This theorem, `Set.preimage_univ`, states that for any two types `α` and `β`, and any function `f` from `α` to `β`, the preimage of the universal set (`Set.univ`) under `f` is also the universal set. In other words, the set of all elements in `α` that map to some element in the universal set of `β` under `f` is simply the universal set of `α`. This makes sense as the universal set of `β` includes all elements of `β`, so every element of `α` will map to some element in it.

For any type `α` and `β`, and function `f` from `α` to `β`, `f⁁⁻¹(Set.univ β) = Set.univ α`.


Function.Bijective.surjective

theorem Function.Bijective.surjective :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → Function.Surjective f := by sorry

The theorem `Function.Bijective.surjective` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if the function `f` is bijective (that is, it is both injective and surjective), then the function `f` is also surjective. In other words, a bijective function is always a surjective function. Surjectivity means that for every element `b` in the codomain `β`, there exists an element `a` in the domain `α` such that `f(a) = b`.

If a function between types is bijective, then it is surjective.


theorem Subtype.coe_le_coe : ∀ {α : Type u} [inst : LE α] {p : α → Prop} {x y : Subtype p}, ↑x ≤ ↑y ↔ x ≤ y := by sorry

The theorem `Subtype.coe_le_coe` states that for any type `α` that has a less than or equal to (`LE`) operation defined, and for any predicate `p` on `α`, for any two elements `x` and `y` of the subtype determined by `p`, the relation `x ≤ y` in the subtype is equivalent to the relation `↑x ≤ ↑y` in the original type `α`. Here, `↑x` and `↑y` denote the elements in `α` corresponding to `x` and `y`, respectively.

For any type `α` with a `LE` operation and subtype `s : Set α` defined by a predicate `p`, for all `x, y ∈ s`, `x ≤ y` if and only if `↑x ≤ ↑y` in `α`.


theorem Polynomial.coeff_monomial :
    ∀ {R : Type u} {a : R} {m n : ℕ} [inst : Semiring R],
      Polynomial.coeff ((Polynomial.monomial n) a) m = if n = m then a else 0 :=
  by sorry

The theorem `Polynomial.coeff_monomial` states that for any type `R`, an element `a` of `R`, and natural numbers `m` and `n`, given a semiring structure on `R`, the coefficient of the polynomial obtained by applying the `Polynomial.monomial` function on `n` and `a` at the index `m` is `a` if `n` is equal to `m`, and `0` otherwise. In other words, in the monomial `a * X^n`, the coefficient of `X^m` is `a` if `m` equals `n`, and `0` if `m` does not equal `n`.

For any semiring `R`, `n`, `m` in `ℕ`, and `a` in `R`, the coefficient of the monomial `a * X^n` in the polynomial `Polynomial.monomial R a X n` is `a` if `n = m`, and `0` otherwise.


theorem Finset.disjoint_left : ∀ {α : Type u_1} {s t : Finset α}, Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ s → a ∉ t := by sorry

This theorem is about the concept of "disjoint" subsets in the context of finite sets, or "finsets", in Lean 4. It states that for all types `α` and all finite sets `s` and `t` of type `α`, `s` and `t` are disjoint if and only if for every element `a` of type `α`, if `a` is in `s` then `a` is not in `t`. In other words, two finite sets are disjoint if they have no elements in common.

Two finite sets `s` and `t` of type `α` in Lean 4 are disjoint if and only if they have no common elements.


/-- **Triangle inequality** for the norm. -/
theorem norm_add_le : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), ‖a + b‖ ≤ ‖a‖ + ‖b‖ := by sorry

This is the Triangle Inequality for the norm in the context of semi-normed add groups. For any type `E` that forms a semi-normed add group, and any two elements `a` and `b` of type `E`, the norm of the sum of `a` and `b` is always less than or equal to the sum of the norms of `a` and `b`. Mathematically, this is expressed as ‖a + b‖ ≤ ‖a‖ + ‖b‖.

For any semi-normed add group `E` and elements `a, b` in `E`, the triangle inequality holds: ‖a + b‖ ≤ ‖a‖ + ‖b‖.


minpoly.monic

/-- A minimal polynomial is monic.  -/
theorem minpoly.monic :
    ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B},
      IsIntegral A x → Polynomial.Monic (minpoly A x) :=
  by sorry

The theorem `minpoly.monic` states that for any types `A` and `B`, where `A` is a commutative ring, `B` is a ring, and there exists an algebra structure over `B` with `A`, then for any element `x` of `B` that is integral over `A`, the minimal polynomial of `x` over `A` is monic. In other words, the leading coefficient of the minimal polynomial of an integral element is 1.

If `x` is an integral element over a commutative ring `A` in a ring `B` with an algebra structure over `A`, then the minimal polynomial of `x` over `A` is monic (i.e., its leading coefficient is 1).


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

This theorem, `Set.mem_toFinset`, states that for any type `α`, any set `s` of that type, and any element `a` of type `α`, the element `a` belongs to the finite set (or `Finset`) derived from `s` if and only if the element `a` belongs to the original set `s`. In other words, the theorem establishes the equivalence of membership between a set and the corresponding finite set produced from it.

For any type `α`, set `s` of `α`, and element `a` of `α`, `a` belongs to the finite set `Finset.fromFunc s` if and only if `a` belongs to `s`.


theorem inv_smul_smul :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] (c : α) (x : β), c⁻¹ • c • x = x := by sorry

This theorem states that for every group `α` and every multiplicative action `MulAction α β` of `α` on `β`, for any element `c` in `α` and `x` in `β`, the inverse of `c` scaled by `c` scaled by `x` is equal to `x`. In mathematical terms, it says that if you have a group operation and a scalar multiplication operation (`•`), then scaling by `c` followed by scaling by the inverse of `c` (`c⁻¹`) is the same as doing nothing, i.e., it leaves `x` unchanged. This can be expressed as `c⁻¹ • c • x = x`.

For every group action `MulAction α β` over a group `α`, and for all `c` in `α` and `x` in `β`, the association law holds: `c⁻¹ • c • x = x`.


theorem Nat.zero_div : ∀ (b : ℕ), 0 / b = 0 := by sorry

This theorem states that for any natural number `b`, the division of zero by `b` is zero. In mathematical terms, it simply states the well-known fact that zero divided by any natural number equals zero.

For any natural number b, 0 divided by b equals 0.


theorem inv_smul_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 `β`, where `α` is a group with zero and `β` is an object upon which `α` can act (denoted by `MulAction α β`), for any non-zero element `c` of `α` and any element `x` of `β`, if we first scale `x` by `c` and then scale the result by the multiplicative inverse of `c` (`c⁻¹`), we get `x` back. In mathematical terms, this theorem proves that the inverse scaling factor undoes the scaling, as long as the scaling factor is non-zero.

For any group `α` with zero, any type `β` with `MulAction α β`, and any non-zero `c` in `α` and `x` in `β`, scaling `x` by `c` and then by `c⁻¹` yields `x`. In Lean notation, `(x : β) → c * x = x → c⁻¹ * (c * x) = x`.


theorem eq_of_dist_eq_zero : ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, dist x y = 0 → x = y := by sorry

This theorem is named `eq_of_dist_eq_zero` and it states that for any type `γ` which is a metric space, if the distance between two points `x` and `y` in this space is zero, then `x` and `y` must be the same point. In other words, in any metric space, two distinct points must have a non-zero distance.

In any metric space, two distinct points have a positive distance between them.


theorem Submonoid.LocalizationMap.map_units :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (y : ↥S), IsUnit ((Submonoid.LocalizationMap.toMap f) ↑y) :=
  by sorry

The theorem `Submonoid.LocalizationMap.map_units` states that for any commutative monoid `M`, any submonoid `S` of `M`, any commutative monoid `N` and any localization map `f` from `S` to `N`, if we have an element `y` of the submonoid `S`, then the image of `y` under the localization map `f` (obtained by applying the `Submonoid.LocalizationMap.toMap` function to `f` and `y`) is a unit in the monoid. In other words, it has a two-sided inverse. The `IsUnit` function checks whether this is the case.

For any commutative monoids M, N, submonoid S of M, and localization map f from S to N, the image of any element y in S under f is a unit in N.


/-- **Alias** of the forward direction of `directedOn_iff_directed`. -/
theorem DirectedOn.directed_val :
    ∀ {α : Type u} {r : α → α → Prop} {s : Set α}, DirectedOn r s → Directed r Subtype.val := by sorry

This theorem, named "DirectedOn.directed_val", asserts that for any type `α`, any binary relation `r` on `α`, and any set `s` of type `α`, if `s` is directed under the relation `r` (meaning that for any two elements in `s`, there exists another element in `s` that is related under `r` to both elements), then the underlying set of elements in `s`, extracted using the `Subtype.val` function, is also directed under `r`. This is essentially a re-statement or "alias" of one direction of the theorem `directedOn_iff_directed`.

If a subset `s` of a type `α` is directed with respect to a binary relation `r`, then the underlying set of elements in `s`, obtained by applying `Subtype.val`, is also directed with respect to `r`.


theorem Int.ofNat_lt : ∀ {n m : ℕ}, ↑n < ↑m ↔ n < m := by sorry

This theorem states that for any two natural numbers `n` and `m`, the statement "the integer representation of `n` is less than the integer representation of `m`" is equivalent to "n is less than m". Essentially, if `n` and `m` are natural numbers, then their order relation remains the same when they are converted to integers.

For any natural numbers n and m, n < m if and only if the integer representation of n is less than the integer representation of m.


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

This theorem states that for every integer 'a', the double negation of 'a' equals 'a'. In other words, if you take the negation of the negation of any integer, you get the original integer. This is a fundamental property of integer numbers and is commonly known in mathematics.

For all integers a, ∠∠a = a, where ∠ denotes negation. (This is also known as "de Morgan's law for integers" or "double negation elimination" for integers.)


/-- A type is either a subsingleton or nontrivial.  -/
theorem subsingleton_or_nontrivial : ∀ (α : Type u_3), Subsingleton α ∨ Nontrivial α := by sorry

This theorem states that for any type 'α', it is either a subsingleton or nontrivial. In other words, for every type, it either contains at most one element (subsingleton), or it contains at least two distinct elements (nontrivial).

Every type is either a subsingleton (has at most one element) or nontrivial (has at least two distinct elements).


theorem Finset.cons_eq_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (h : a ∉ s), Finset.cons a s h = insert a s := by
  sorry

This theorem, named `Finset.cons_eq_insert`, states that for any type `α` with a decidable equality relation, any element `a` of type `α`, and any finite set `s` of type `α` such that `a` is not a member of `s`, the operation of constructing a new finite set from `a` and `s` using the `Finset.cons` function is equivalent to the operation of inserting `a` into `s`. In other words, given these constraints, `Finset.cons a s h` and `insert a s` will result in the same finite set.

For any type `α` with decidable equality and any finite set `s` of `α` not containing `a` in `α`, `Finset.cons a s` and `insert a s` yield equal finite sets.


theorem GaloisConnection.u_top :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : OrderTop α]
      [inst_3 : OrderTop β] {l : α → β} {u : β → α}, GaloisConnection l u → u ⊤ = ⊤ :=
  by sorry

The theorem `GaloisConnection.u_top` states that for any types `α` and `β` which have a partial order and a predefined maximum element (top), if two functions `l : α → β` and `u : β → α` form a Galois connection, then the maximum element of type `β` when mapped through the function `u` gives the maximum element (top) of type `α`. In other words, for a Galois connection, the function `u` sends the top element of `β` to the top element of `α`.

For any Galois connection between partially ordered types with top elements, the image of the top element of the second type under the second function is the top element of the first type.


theorem two_ne_zero' : ∀ (α : Type u_2) [inst : Zero α] [inst_1 : OfNat α 2] [inst_2 : NeZero 2], 2 ≠ 0 := by sorry

This theorem states that for any type `α` that has a zero element and can interpret the natural number 2, the number 2 is not equal to 0. The `NeZero 2` instance is a hypothesis that 2 is not zero in the type `α`. Basically, it asserts the non-equality between 2 and 0 in any such type. This theorem is a fundamental assumption in many areas of mathematics, particularly those involving arithmetic operations.

If type `α` has a zero element and interprets the natural number 2, then 2 ≠ 0.


Not.intro

theorem Not.intro : ∀ {a : Prop}, (a → False) → ¬a := by sorry

This theorem, `Not.intro`, states that for any proposition `a`, if we can show that `a` implies `False`, then we can conclude that `a` is not true, or in other words, `¬a` holds. This is a formalization of the principle of proof by contradiction in logic, where we assume a proposition and derive a contradiction to show that the original proposition cannot be true.

If `a` implies `False`, then `¬a` holds. (Or, if derived contradiction from `a`, then `a` is false.)


/-- Transposing a matrix preserves the determinant.  -/
theorem Matrix.det_transpose :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n R),
      Matrix.det (Matrix.transpose M) = Matrix.det M :=
  by sorry

This theorem states that the determinant of a transposed matrix is equal to the determinant of the original matrix. In other words, for any square matrix `M` with elements from a commutative ring `R`, and whose rows and columns are indexed by a finitely enumerable type `n` with a decidable equality, the determinant of the transpose of `M` is the same as the determinant of `M` itself. This property is important in linear algebra, where matrix transposition is a common operation.

The determinant of a square matrix and its transpose are equal.


theorem Finset.not_mem_empty : ∀ {α : Type u_1} (a : α), a ∉ ∅ := by sorry

This theorem states that for any type `α` and any element `a` of that type, `a` is not a member of the empty set. In other words, no element can belong to an empty set. This is a basic property of the empty set in set theory.

The theorem asserts that for all types `α` and elements `a` of type `α`, `a` is not an element of the empty set.


theorem Equiv.exists_congr_left :
    ∀ {α : Sort u_1} {β : Sort u_2} (f : α ≃ β) {p : α → Prop}, (∃ a, p a) ↔ ∃ b, p (f.symm b) := by sorry

This theorem, `Equiv.exists_congr_left`, states that for all types `α` and `β`, given a bijective function `f` from `α` to `β`, and a property `p` on `α`, there exists an element of `α` that satisfies `p` if and only if there exists an element of `β` that, when transformed back to `α` through the inverse of `f`, satisfies `p`. In mathematical terms, this theorem asserts that the existential quantification of a property is preserved under a bijective (or equivalently invertible) mapping.

For all types `α` and `β`, if `f` is a bijective function from `α` to `β` and `p` is a property on `α`, then there exists an `x ∈ α` with `p(x)` if and only if there exists a `y ∈ β` with `p(f⁻¹(y))`.


theorem Set.diff_eq : ∀ {α : Type u} (s t : Set α), s \ t = s ∩ tᶜ := by sorry

This theorem states that for all types `α` and for any two sets `s` and `t` of type `α`, the difference of `s` and `t`, denoted as `s \ t`, is equal to the intersection of `s` and the complement of `t`, denoted as `s ∩ tᶜ`. In other words, the set of all elements in `s` that are not in `t` is the same as the set of all elements in `s` that are in the set of all elements not in `t`.

For all types `α` and sets `s` and `t` of type `α`, `s \ t` equals the intersection of `s` and the complement of `t`, denoted `s ∩ tᶜ`.


/-- The subgroup generated by a set includes the set.  -/
theorem Subgroup.subset_closure : ∀ {G : Type u_1} [inst : Group G] {k : Set G}, k ⊆ ↑(Subgroup.closure k) := by sorry

This theorem states that for any set `k` of elements in a group `G`, the set `k` is a subset of the subgroup generated by `k`. In other words, every element in `k` is also an element in the subgroup produced by the `Subgroup.closure` function applied to `k`. This ensures that the closure operation indeed encapsulates all members of the original set `k` within the produced subgroup in the group `G`.

For any set `k` of elements in a group `G`, `k` is a subset of the subgroup generated by `k` (i.e., the subgroup generated by `k` contains every element in `k`).


theorem Matrix.cons_val_fin_one : ∀ {α : Type u} (x : α) (u : Fin 0 → α) (i : Fin 1), Matrix.vecCons x u i = x := by
  sorry

This theorem asserts that for any type `α`, any element `x` of type `α`, any function `u` from `Fin 0` to `α`, and any element `i` from `Fin 1`, applying the `Matrix.vecCons` function to `x`, `u`, and `i` always results in `x`. In other words, when a single-element vector is constructed by prepending `x` to a zero-element vector, the resulting vector's only element is `x` regardless of the index `i`.

For any type `α`, any element `x` of type `α`, and any function `u : Fin 0 → α`, the application of `Matrix.vecCons x u 0` is equal to `x`.


theorem Mathlib.Data.FunLike.Embedding._auxLemma.1 :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
      (f x = f y) = (x = y) :=
  by sorry

The theorem `Mathlib.Data.FunLike.Embedding._auxLemma.1` states that for any types `F`, `α`, `β`, if `F` is function-like from `α` to `β`, and `F` has an embedding-like property from `α` to `β`, then for any function `f` of type `F` and any elements `x` and `y` of `α`, the equation `f(x) = f(y)` is equivalent to `x = y`. In simpler terms, it means that the function `f` preserves distinctness of elements, that is, if `x` and `y` are distinct, their images under `f` are also distinct, and vice versa. This is a formal way to express that the function `f` is injective.

If `F` is a function-like type with an embedding-like property from type `α` to `β`, then `F` is an injection from `α` to `β`.


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

The theorem `MulEquiv.symm_apply_apply` states that for any given multiplicative isomorphism `e` between two types `M` and `N`, both equipped with a multiplication operation, the inverse of `e` (`e.symm`) is a left inverse of `e`. Mathematically, for any element `x` in `M`, if we apply `e` to `x` and then apply `e.symm` to the result, we obtain `x` back. The statement can be written as: `e.symm (e x) = x`.

For any multiplicative isomorphism `e` between types `M` and `N` with multiplication operations, `e.symm (e x) = x` for all `x` in `M`.


theorem measurableSet_Ioi :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst : OrderClosedTopology α] {a : α}, MeasurableSet (Set.Ioi a) :=
  by sorry

The theorem `measurableSet_Ioi` states that for any type `α` that has a topological space structure, a measurable space structure, an open sets measurable space structure, a linear order, and an order closed topology, and for any element `a` of type `α`, the set of all elements greater than `a` (`Set.Ioi a`), also known as the left-open right-infinite interval, is a measurable set. This means that in the context of a given measure space on `α`, the set of all elements exceeding `a` is measurable.

In a measure space on a type `α` with topological space, measurable space, open sets measurable space, linear order, and order closed topology structures, the set `Set.Ioi a` of elements greater than `a` is measurable.


theorem add_right_inj :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsLeftCancelAdd G] (a : G) {b c : G}, a + b = a + c ↔ b = c := by sorry

This theorem, `add_right_inj`, states that for any type `G` that has an addition operation and the property of left-cancellative addition, for any elements `a`, `b`, and `c` of type `G`, the equality `a + b = a + c` is equivalent to `b = c`. In other words, if adding a certain element to two different elements yields the same result, then the two different elements must be equal. This is a property of left-cancellative operations in mathematics.

If `G` is a type with left-cancellative addition, then for all `a`, `b`, `c` in `G`, `a + b = a + c` implies `b = c`.


theorem Set.biUnion_eq_iUnion :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : (x : α) → x ∈ s → Set β),
      ⋃ x, ⋃ (h : x ∈ s), t x h = ⋃ x, t ↑x ⋯ :=
  by sorry

This theorem states that for any type `α` and `β`, given a set `s` of type `α` and a function `t` that for each element `x` in the set `s` associates a set of type `β`, the union over all `x` of the unions over all proofs `h` that `x` is in `s` of the set `t x h` is equal to the union over all `x` of the set `t ↑x`. In simpler terms, it shows that the union of all subsets defined by a membership-dependent function over a set is the same as the union of subsets when we consider each element in that set, which is a property about how sets can be unionized in Lean 4.

For any type `α` and `β`, given a set `s` of type `α` and a function `t : s → Set β`, the union over all `x ∈ s` of the sets `t x <| mem s x` is equal to the set `{y | ∃ x ∈ s, y ∈ t x}`.


theorem ENNReal.toReal_ofReal : ∀ {r : ℝ}, 0 ≤ r → (ENNReal.ofReal r).toReal = r := by sorry

This theorem states that for all real numbers `r`, if `r` is nonnegative (i.e., `r` is greater than or equal to 0), then the function `ENNReal.ofReal`, which maps `r` to the extended nonnegative real numbers, followed by the conversion back to the real numbers (`toReal`), is equal to the original real number `r`. In other words, the conversions from real numbers to extended nonnegative real numbers and then back to real numbers is an identity operation for nonnegative real numbers.

For all real numbers `r` ≥ 0, `ENNReal.ofReal r = r` holds. (Or equivalently, `toReal (ENNReal.ofReal r) = r`.)


theorem CategoryTheory.Limits.IsZero.eq_of_src :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C},
      CategoryTheory.Limits.IsZero X → ∀ (f g : X ⟶ Y), f = g :=
  by sorry

This theorem states that for any category `C` and any two objects `X` and `Y` in `C`, if `X` is a zero object (an object that is both initial and terminal), then any two morphisms `f` and `g` from `X` to `Y` are equal. In other words, in a given category, all morphisms originating from a zero object to any other object are the same.

In any category, if an object is both initial and terminal, then all morphisms from it to any other object are equal.


theorem Polynomial.eval_pow :
    ∀ {R : Type u} [inst : CommSemiring R] {p : Polynomial R} {x : R} (n : ℕ),
      Polynomial.eval x (p ^ n) = Polynomial.eval x p ^ n :=
  by sorry

The theorem `Polynomial.eval_pow` states that for any commutative semiring `R`, any polynomial `p` of type `Polynomial R`, any element `x` of `R`, and any natural number `n`, the evaluation of `p` raised to the power `n` at `x` is equal to the evaluation of `p` at `x` raised to the power `n`. In other words, it asserts that the evaluation function for polynomials respects exponentiation, which can be expressed in mathematical notation as $eval(x, p^n) = (eval(x, p))^n$.

For any commutative semiring R, polynomial p of type Polynomial R, element x of R, and natural number n, the evaluation of p raised to the power n at x equals the power of the evaluation of p at x, i.e., eval(x, p^n) = (eval x p)^n.


Quotient.eq''

theorem Quotient.eq'' : ∀ {α : Sort u_1} {s₁ : Setoid α} {a b : α}, Quotient.mk'' a = Quotient.mk'' b ↔ Setoid.r a b :=
  by sorry

The theorem `Quotient.eq''` states that for any sort `α` endowed with a setoid `s₁`, and for any two elements `a` and `b` of `α`, the quotient elements `Quotient.mk'' a` and `Quotient.mk'' b` are equal if and only if `a` and `b` are related by the distinguished equivalence relation `Setoid.r` of the setoid `s₁`. This theorem thereby provides a correspondence between equality in the quotient and the underlying equivalence relation in the original sort.

For any setoid `s₁` on sort `α`, two elements `a` and `b` are equal in the quotient `Quotient.mk'' a` and `Quotient.mk'' b` if and only if they are related by the equivalence relation `Setoid.r` of `s₁`.


theorem inv_nonneg : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 ≤ a⁻¹ ↔ 0 ≤ a := by sorry

This theorem, named `inv_nonneg`, states that for any type `α` that has a structure of a linear ordered semifield, the inverse `a⁻¹` of an element `a` in `α` is nonnegative (i.e., `0 ≤ a⁻¹`) if and only if `a` itself is nonnegative (i.e., `0 ≤ a`). In mathematical terms, this theorem ensures the preservation of non-negativity through inversion in a linear ordered semifield.

For any linear ordered semifield `α`, if `0 ≤ a` then `0 ≤ a⁻¹`.


Continuous.continuousWithinAt

theorem Continuous.continuousWithinAt :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {x : α}, Continuous f → ContinuousWithinAt f s x :=
  by sorry

This theorem states that if a function `f` from a topological space `α` to another topological space `β` is continuous, then it is also continuous at any point `x` within any subset `s` of `α`. Here, continuity at a point within a subset is defined as the property that for any point `x` tending to a limit within the subset `s`, the image of the point under `f`, i.e., `f(x)`, tends towards the limit `f(x)`.

If a function `f` is continuous from a topological space `α` to another topological space `β`, then `f` is continuous at any point `x` in `α` with respect to any subset `s` of `α` where `x` has a limit.


theorem CategoryTheory.Limits.KernelFork.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.KernelFork f),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι s) f = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.KernelFork.condition` states that for any category `C` with zero morphisms, given any objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y`, if `s` is a kernel fork of `f`, then the composition of the fork morphism `ι s` with `f` is a zero morphism. In other words, if we consider a fork in which the second morphism is a zero morphism (a kernel fork), then the composition of the morphism from the source of the fork to `f` is also a zero morphism. This is a key property of kernels in category theory.

For any category with zero morphisms, if `s` is a kernel fork of morphism `f`, then `ι s ∘ f` is a zero morphism.


theorem Nat.le_div_iff_mul_le : ∀ {k x y : ℕ}, 0 < k → (x ≤ y / k ↔ x * k ≤ y) := by sorry

This theorem states that for any three natural numbers `k`, `x`, and `y`, where `k` is greater than zero, `x` is less than or equal to the integer division of `y` by `k` if and only if the product of `x` and `k` is less than or equal to `y`. In other words, for `k` > 0, `x` ≤ `y`/`k` is equivalent to `x`*`k` ≤ `y`.

For natural numbers `k`, `x`, and `y` with `k` > 0, `x` leqs `y` divided by `k` is equivalent to `x` times `k` leqs `y`.


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

This theorem, `inv_mul_self`, states that for any type `G` that forms a group, the multiplicative inverse of any element `a` from `G` when multiplied with `a` itself yields the multiplicative identity `1`. In mathematical terms, this represents the property ∀a ∈ G, a⁻¹ * a = 1, which holds true for all groups.

For all groups G and all its elements a, a^-1 * a = 1.


LinearEquiv.injective

theorem LinearEquiv.injective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
      Function.Injective ⇑e :=
  by sorry

The theorem `LinearEquiv.injective` states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₂`, and provided `M` and `M₂` are modules over `R` and `S` respectively, if there exists a pair of ring homomorphisms `σ : R →+* S` and `σ' : S →+* R` that are inverses of each other, then any linear equivalence `e : M ≃ₛₗ[σ] M₂` is an injective function. In other words, if two elements from `M` are mapped to the same element in `M₂` by this linear equivalence, then the two original elements from `M` were actually the same.

If `R` and `S` are semirings, `M` and `M₂` are additive commutative `R`-modules and `S`-modules respectively, and there exist invertive ring homomorphisms `σ : R → S` and `σ' : S → R`, then any linear equivalence `e : M ≈[σ] M₂` is an injective function.


theorem nnnorm_zero : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], ‖0‖₊ = 0 := by sorry

This theorem states that for any type `E` which has the structure of a seminormed add group, the non-negative seminorm of zero is equal to zero. In mathematical terms, if we denote the seminorm of an element `x` in `E` by `‖x‖₊`, then `‖0‖₊ = 0`. This is a standard property of seminorms in functional analysis.

For any seminormed add group `E`, the seminorm of the additive identity (zero) is equal to zero.


theorem measurable_pi_apply :
    ∀ {δ : Type u_4} {π : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (π a)] (a : δ), Measurable fun f => f a := by
  sorry

This theorem states that for any type `δ` and a function `π` from `δ` to another type, given an instance of a measurable space for every value of `δ` (denoted as `(a : δ) → MeasurableSpace (π a)`), and any element `a` of type `δ`, the function which applies `f` to `a` is measurable. In other words, if we have a function `f` from a set of elements of type `δ` to measurable spaces, and a specific element `a` of type `δ`, then the function that maps any such function `f` to the result of applying `f` to `a` is measurable. In terms of measure theory, this means the preimage of any measurable set under this function is also measurable.

Given a measurable space instance for every value of type `δ`, and a measurable function `f` from a set to measurable spaces, the application of `f` to any element `a` of type `δ` is a measurable function.


/-- An induction principle to deduce results for `Angle` from those for `ℝ`, used with
`induction θ using Real.Angle.induction_on`.  -/
theorem Real.Angle.induction_on : ∀ {p : Real.Angle → Prop} (θ : Real.Angle), (∀ (x : ℝ), p ↑x) → p θ := by sorry

This theorem provides an induction principle for the type `Real.Angle`. It states that for any property `p` that applies to angles (`Real.Angle`), if that property holds for all real numbers when they are considered as angles, then it must also hold for any arbitrary angle `θ`. This theorem is useful when you want to prove something about all angles (`Real.Angle`) and you already know how to prove it for all real numbers (`ℝ`). You would use it with the `induction θ using Real.Angle.induction_on` tactic in Lean.

If a property holds for all real numbers when considered as angles, then it holds for any arbitrary angle. (Induction principle for `Real.Angle` type in Lean)


/-- **Alias** of the reverse direction of `sup_eq_right`. -/
theorem sup_of_le_right : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ b → a ⊔ b = b := by sorry

This theorem, `sup_of_le_right`, states that for any type `α` that has a semilattice structure, given any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then the supremum (or least upper bound) of `a` and `b` is `b`. It is an alias of the reverse direction of `sup_eq_right`.

If `α` is a semilattice type and `a ≤ b` in `α`, then `sup a b = b`.


theorem Continuous.const_smul :
    ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SMul M α]
      [inst_2 : ContinuousConstSMul M α] [inst_3 : TopologicalSpace β] {g : β → α},
      Continuous g → ∀ (c : M), Continuous fun x => c • g x :=
  by sorry

This theorem states that, given a continuous function `g` mapping from a type `β` to a type `α` in a specific topological context, the scalar multiplication operation, denoted by `c • g x`, is also continuous for any scalar `c` of type `M`. Here, type `α` is endowed with a topological space structure and a scalar multiplication structure with a continuous scalar multiplication operation, and type `β` is also endowed with a topological space structure.

Given a continuous function `g` from a topological space `β` to another topological space `α` endowed with continuous scalar multiplication, the scalar multiplication operation `c • g` is continuous for any scalar `c`.


theorem Nat.mod_zero : ∀ (a : ℕ), a % 0 = a := by sorry

This theorem states that for any natural number `a`, the remainder of `a` divided by zero is `a` itself. In other words, if you try to divide any natural number by zero in Lean 4, instead of getting an error or undefined result, you get the original number back.

The theorem asserts that for all natural numbers `a`, the remainder of `a` divided by zero, under any chosen residue class, is equal to `a`. (Note that this statement is not valid mathematically, as division by zero is undefined in standard mathematics. The behavior described in the theorem might be a defined property in the specific mathematical structure of Lean 4's natural numbers.)


theorem sup_le_sup : ∀ {α : Type u} [inst : SemilatticeSup α] {a b c d : α}, a ≤ b → c ≤ d → a ⊔ c ≤ b ⊔ d := by sorry

This theorem states that for any type `α` that has a semilattice super operation (denoted by `⊔`), given four elements `a`, `b`, `c`, and `d` of this type, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the supremum (least upper bound) of `a` and `c` is less than or equal to the supremum of `b` and `d`.

For any semilattice `α` with operation `⊔`, if `a ≤ b` and `c ≤ d` in `α`, then `a ⊔ c ≤ b ⊔ d`.


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

This theorem, `max_lt`, states that for any type `α` that has a linear order, and any three elements `a`, `b`, and `c` of type `α`, if `a` is less than `c` and `b` is less than `c`, then the maximum value of `a` and `b` is also less than `c`. That is, in a linearly ordered set, if both `a` and `b` are less than `c`, then the maximum of `a` and `b` will also be less than `c`.

If `α` is a linearly ordered type and `a`, `b`, `c` are elements of `α` with `a < c` and `b < c`, then `max {a, b} < c`.


theorem ENNReal.coe_toNNReal : ∀ {a : ENNReal}, a ≠ ⊤ → ↑a.toNNReal = a := by sorry

This theorem states that for all elements `a` of the extended nonnegative real numbers (`ENNReal`), as long as `a` is not infinite (`∞`), then the nonnegative real number corresponding to `a` (obtained using `toNNReal`) when converted back to `ENNReal` (`↑a.toNNReal`) is still equal to `a`. In other words, for any non-infinite extended nonnegative real number, we can convert it into a nonnegative real number and back without changing its value.

For all `a` in `ENNReal` that are finite, `↑(toNNReal a) = a`.


theorem sSup_le :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, (∀ b ∈ s, b ≤ a) → sSup s ≤ a := by sorry

The theorem `sSup_le` states that for any type `α` that forms a complete semilattice with a greatest lower bound operation, any set `s` of type `α`, and any element `a` of type `α`, if every element `b` in the set `s` is less than or equal to `a`, then the supremum (greatest lower bound) of the set `s` is also less than or equal to `a`. In other words, if `a` is an upper bound for a set `s` in a complete semilattice, then the supremum of `s` cannot be greater than `a`.

If `α` is a complete semilattice with greatest lower bound operation, and `s ⊆ α` has greatest lower bound `sup s` and `a ∈ α` is an upper bound for `s`, then `sup s ≤ a`.


/-- An `AddSubmonoid` is closed under addition. -/
theorem AddSubmonoid.add_mem :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M) {x y : M}, x ∈ S → y ∈ S → x + y ∈ S := by sorry

This theorem states that an `AddSubmonoid` is closed under the operation of addition. In more detail, given a type `M` which is an instance of the `AddZeroClass` (that is, it supports addition operation and has a zero), if `S` is an `AddSubmonoid` of `M`, then for any two elements `x` and `y` in `M`, if both `x` and `y` belong to `S`, then their sum `x + y` also belongs to `S`. In other words, adding two elements of the submonoid results in another element of the same submonoid, thus ensuring closure under addition.

If `S` is an additive submonoid of an additive semigroup with zero, then for all `x, y ∈ S`, `x + y ∈ S`.


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

This theorem states that for any group `α`, any type `β` that is a `MulAction` of `α`, any element `c` from the group `α`, and any element `x` from `β`, the following holds: if we perform the group operation (represented by `•`) on `c` and the inverse of `c` (represented by `c⁻¹`), and then perform the `MulAction` operation on the result and `x`, we get back `x`. In other words, `c • c⁻¹ • x = x`. This is essentially expressing that the multiplication action of an element and its inverse acts as the identity on `x`.

For any group `α`, any `MulAction` `β` of `α`, and any `x` in `β` and `c` in `α`, we have `c • c⁻¹ • x = x`.


/-- The additive inverse of one multiplied by an element of a ring is the element's additive
inverse.  -/
theorem neg_one_mul : ∀ {α : Type u} [inst : MulOneClass α] [inst_1 : HasDistribNeg α] (a : α), -1 * a = -a := by sorry

This theorem, `neg_one_mul`, states that for any element 'a' of a ring (denoted by the type α), the product of the additive inverse of one and 'a' equals the additive inverse of 'a'. In other words, multiplying any element of the ring by negative one produces the negative of that element. This is often a property in many algebraic structures including rings and fields.

For any ring element 'a', negative one times 'a' equals the additive inverse of 'a'.


theorem Filter.HasBasis.mem_of_mem :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} {i : ι},
      Filter.HasBasis l p s → p i → s i ∈ l :=
  by sorry

This theorem states that for any types `α` and `ι`, a filter `l` on `α`, a property `p` on `ι`, a function `s` that maps `ι` to a set of `α`, and an element `i` of `ι`, if the filter `l` has a basis given by the property `p` and the function `s`, and the property `p` holds for the element `i`, then the set `s i` is a member of the filter `l`.

In simpler terms, it says that if a filter is defined by certain properties and sets, and if an element satisfies a property, then the corresponding set is part of the filter.

If a filter on a type `α` has property `p` as its basis along with function `s` mapping elements of `ι` to `α`, then for any `i` in `ι` satisfying property `p`, we have `s i` in the filter.


List.Perm.refl

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

This theorem states that for any given list `l` of an arbitrary type `α`, the list `l` is a permutation of itself. In a more mathematical language, it asserts the reflexivity of the permutation relation over lists, i.e., every list is a permutation of itself, irrespective of the type of elements it contains.

For any list `l` of type `α`, `l` is a permutation of itself. (Equivalently, the reflexive property holds for the permutation relation on lists.)


theorem forall_prop_domain_congr :
    ∀ {p₁ p₂ : Prop} {q₁ : p₁ → Prop} {q₂ : p₂ → Prop} (h₁ : p₁ = p₂),
      (∀ (a : p₂), q₁ ⋯ = q₂ a) → (∀ (a : p₁), q₁ a) = ∀ (a : p₂), q₂ a :=
  by sorry

This theorem states that for any two propositions `p₁` and `p₂`, and for any two predicate functions `q₁` and `q₂` that map from these propositions to another proposition, if `p₁` equals `p₂` and for all `a` from `p₂`, `q₁` equals `q₂ a`, then the proposition that "for all `a` from `p₁`, `q₁ a` holds" equals the proposition that "for all `a` from `p₂`, `q₂ a` holds". This theorem essentially asserts the congruence of universal quantifications over equal domains of propositions.

If `p₁` equals `p₂` and for all `a` in `p₂`, `q₁ a` equals `q₂ a`, then ∀`a` in `p₁, q₁ a` is equal to ∀`a` in `p₂, q₂ a`.


theorem max_le_max : ∀ {α : Type u} [inst : LinearOrder α] {a b c d : α}, a ≤ c → b ≤ d → max a b ≤ max c d := by sorry

This theorem, named `max_le_max`, states that for any linearly ordered type `α`, if `a` and `b` are two elements of this type such that `a` is less than or equal to `c` and `b` is less than or equal to `d`, then the maximum of `a` and `b` is less than or equal to the maximum of `c` and `d`. In mathematical terms, this could be written as: for any $a, b, c, d \in \alpha$, if $a \leq c$ and $b \leq d$, then $\max(a, b) \leq \max(c, d)$.

For any linearly ordered type α and elements a, b, c, d ∈ α, if a ≤ c and b ≤ d, then max(a, b) ≤ max(c, d).


theorem Subtype.coe_prop : ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), ↑a ∈ S := by sorry

This theorem, `Subtype.coe_prop`, states that for any given type `α` and any set `S` of that type, if we have a subtype `a` such that `a` belongs to `S`, then the underlying element of `a` (obtained through the coercion function `↑a`) also belongs to the set `S`. In simpler terms, it guarantees that an element of a subtype, which is defined as belonging to a particular set, indeed belongs to that set when we "unwrap" it from the subtype.

For any type `α` and set `S` of `α`, if `a` is an element of the subtype `s : Subset α S` then `↑a` belongs to `S`.


theorem MvPolynomial.eval₂_C :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (g : σ → S₁) (a : R), MvPolynomial.eval₂ f g (MvPolynomial.C a) = f a :=
  by sorry

The theorem `MvPolynomial.eval₂_C` states that for any commutative semirings `R` and `S₁`, and any ring homomorphism `f` from `R` to `S₁`, function `g` mapping from `σ` to `S₁`, and any element `a` of `R`, the evaluation of the constant polynomial `MvPolynomial.C a` (which represents a polynomial with constant value `a`) using `MvPolynomial.eval₂` with the valuation `g` and the ring homomorphism `f` is equal to the application of `f` to `a`. In other words, when we evaluate a constant polynomial, we get the constant transformed by the given ring homomorphism.

For any commutative semirings R and S₁, ring homomorphism f from R to S₁, function g from σ to S₁, and element a in R, we have MvPolynomial.eval₂ g f (MvPolynomial.C a) = f a.


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

This theorem states that for any two propositions 'a' and 'b', if 'a' is not true, then the statement 'a or b' is equivalent to 'b'. In other words, if we know that 'a' is false, then 'a or b' is true if and only if 'b' is true. This is a formalization of a basic rule of logical reasoning in propositional logic.

If `a` is false, then `a or b` is equivalent to `b`.


QuaternionAlgebra.ext

theorem QuaternionAlgebra.ext :
    ∀ {R : Type u_1} {a b : R} (x y : QuaternionAlgebra R a b),
      x.re = y.re → x.imI = y.imI → x.imJ = y.imJ → x.imK = y.imK → x = y :=
  by sorry

This theorem, named `QuaternionAlgebra.ext`, states that for any given ring `R` and any two elements `a` and `b` of `R`, if we have two quaternions `x` and `y` of the Quaternion Algebra defined over `R` with `a` and `b`, and the real part of `x` equals the real part of `y`, the `i` imaginary part of `x` equals the `i` imaginary part of `y`, the `j` imaginary part of `x` equals the `j` imaginary part of `y`, and the `k` imaginary part of `x` equals the `k` imaginary part of `y`, then `x` and `y` are indeed the same quaternion. This is essentially the criteria for equality in the Quaternion Algebra.

If two quaternions of the Quaternion Algebra over a ring have equal real and imaginary parts, they are equal.


theorem abs_pos :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, 0 < |a| ↔ a ≠ 0 :=
  by sorry

The theorem `abs_pos` states that for any value `a` of an ordered additive group `α`, the absolute value of `a` is greater than zero if and only if `a` is not equal to zero. Here, the additive group structure on `α` satisfies the property that addition of any two elements of `α` preserves the order, i.e., if `x ≤ y` then `x + z ≤ y + z` for all `x, y, z` in `α`.

The absolute value of an element in an ordered additive group is positive if and only if the element is non-zero.


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

This theorem states that for any type `α` with a decidable equality and for any two finite sets `s₁` and `s₂` of type `α`, `s₁` is a subset of the union of `s₁` and `s₂`. In other words, every element of `s₁` is also an element of the union of `s₁` and `s₂`.

For any decidably equal type `α` and finite sets `s₁`, `s₂` of `α`, every element of `s₁` belongs to the union of `s₁` and `s₂`.


/-- Group homomorphisms preserve inverse.  -/
theorem map_inv :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
      [inst_3 : MonoidHomClass F G H] (f : F) (a : G), f a⁻¹ = (f a)⁻¹ :=
  by sorry

The theorem `map_inv` states that for any group `G` and any division monoid `H`, and for any type `F` that has an injective function-like coercion from `G` to `H`, if `F` is a group homomorphism from `G` to `H`, then this group homomorphism preserves the inverse operation. In other words, given any element `a` in `G`, the homomorphism applied to the inverse of `a` is equal to the inverse of the homomorphism applied to `a`. This is expressed in mathematical terms as `f(a⁻¹) = (f(a))⁻¹`.

For any group homomorphism `f` from a group `G` to a division monoid `H` with an injective coercion from `G` to `H`, `f(a⁻¹) = (f(a))⁻¹` for all `a` in `G`.


theorem CategoryTheory.Iso.comp_inv_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
      CategoryTheory.CategoryStruct.comp f α.inv = g ↔ f = CategoryTheory.CategoryStruct.comp g α.hom :=
  by sorry

This theorem states that for any category `C` with objects `X`, `Y`, and `Z`, and given an isomorphism `α` from `X` to `Y`, and morphisms `f` from `Z` to `Y` and `g` from `Z` to `X`, the composition of `f` with the inverse of `α` is equal to `g` if and only if `f` is equal to the composition of `g` with `α`. In other words, it asserts that in a category, pre-composing with an isomorphism's inverse and post-composing with the isomorphism are inverse operations to each other.

For any category `C` and isomorphism `α: X ↔ Y` between objects `X` and `Y`, morphisms `f: Z → Y` and `g: Z → X`, the conditions `f ∘ α⁻¹ = g` and `g ∘ α = f` are equivalent.


/-- Cancellation adding the results of two subtractions.  -/
theorem vsub_add_vsub_cancel :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ p₂ p₃ : P),
      p₁ -ᵥ p₂ + (p₂ -ᵥ p₃) = p₁ -ᵥ p₃ :=
  by sorry

The theorem `vsub_add_vsub_cancel` states that for any three points `p₁`, `p₂`, and `p₃` belonging to an AddTorsor `P` over an AddGroup `G`, the vector difference of `p₁` and `p₂` added to the vector difference of `p₂` and `p₃` equals the vector difference of `p₁` and `p₃`. In simpler terms, it's saying that if you move from `p₂` to `p₁` and then from `p₂` to `p₃`, it's the same as just moving from `p₃` to `p₁` directly. This is essentially the cancellation law for this structure, in the context of subtraction and addition.

For any points `p₁`, `p₂`, and `p₃` in an AddTorsor `P` over an AddGroup `G`, `(p₁ - p₂) + (p₂ - p₃) = p₁ - p₃`.


theorem Order.le_succ : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] (a : α), a ≤ Order.succ a := by
  sorry

The theorem `Order.le_succ` states that for any type `α` equipped with a preorder and a successor order, any element `a` of type `α` is less than or equal to its successor. In other words, given any element `a` in the set, it is either less than or equal to the next element in the ordered sequence (its successor). If `a` is a maximal element, then `a` is equal to its successor; otherwise, its successor is greater than `a`.

For any type `α` with a preorder and a successor order, for all `a` in `α`, `a ≤ a.successor`.


theorem Finset.sum_cons :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {a : α} {f : α → β} [inst : AddCommMonoid β] (h : a ∉ s),
      (Finset.sum (Finset.cons a s h) fun x => f x) = f a + Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_cons` states that for any types `α` and `β`, a finite set `s` of type `α`, an element `a` of type `α`, a function `f` from `α` to `β`, and an additive commutative monoid instance on `β`, if `a` is not an element of `s`, then the sum of the function `f` applied to each element of the set formed by adding `a` to `s` (`Finset.cons a s h`) is equal to the sum of `f` applied to `a` plus the sum of `f` applied to each element of `s`. In other words, the sum over the set `{a} ∪ s` is the same as `f(a)` plus the sum over the set `s`. This is an expression of the distributive property of addition over a finite set.

For any additive commutative monoid `β` and function `f` from a finite set `s` of type `α` to `β`, along with an element `a` not in `s`, the sum of `f` applied to `a` and the sum of `f` applied to `s` is equal to the sum of `f` applied to the set `{a} ∪ s`.


RingEquiv.ext

/-- Two ring isomorphisms agree if they are defined by the
same underlying function.  -/
theorem RingEquiv.ext :
    ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] {f g : R ≃+* S},
      (∀ (x : R), f x = g x) → f = g :=
  by sorry

This theorem states that for any two types `R` and `S`, both having multiplication and addition operations, and for any two ring isomorphisms `f` and `g` from `R` to `S`, if these isomorphisms act identically on all elements of `R` (that is, for each element `x` in `R`, `f(x)` is equal to `g(x)`), then `f` and `g` are actually the same isomorphism. A ring isomorphism here is a bijection that preserves the ring operations, namely addition and multiplication.

If two ring isomorphisms between types with multiplication and addition operations agree on all elements, then they are equal.


/-- If `F` reflects isos and `F.map f` is an iso, then `f` is an iso.  -/
theorem CategoryTheory.isIso_of_reflects_iso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {A B : C} (f : A ⟶ B) (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.IsIso (F.map f)] [inst_3 : CategoryTheory.ReflectsIsomorphisms F],
      CategoryTheory.IsIso f :=
  by sorry

This theorem states that if a functor `F` reflects isomorphisms and `F.map f` is an isomorphism, then `f` is also an isomorphism. In the context of category theory, this theorem is saying that if we have two categories `C` and `D`, objects `A` and `B` in `C`, and a morphism `f` from `A` to `B`, if the image of `f` under the functor `F` is an isomorphism and `F` has the property that it reflects isomorphisms, then `f` must also be an isomorphism. The property of a functor reflecting isomorphisms means that whenever the functor sends a morphism to an isomorphism, the original morphism was also an isomorphism.

If a functor reflecting isomorphisms maps an isomorphism to an isomorphism, then the original morphism is an isomorphism.


theorem mul_ite :
    ∀ {α : Type u_1} [inst : Mul α] (P : Prop) [inst_1 : Decidable P] (a b c : α),
      (a * if P then b else c) = if P then a * b else a * c :=
  by sorry

This theorem, `mul_ite`, states that for any type `α` that supports multiplication, any proposition `P`, and any three elements `a`, `b`, and `c` of type `α`, the product of `a` and the result of an "if-then-else" condition based on `P` selecting between `b` and `c` is equal to the result of an "if-then-else" condition based on `P` selecting between the product of `a` and `b` and the product of `a` and `c`. In simpler terms, it states that multiplication distributes over the "if-then-else" conditional - the expression "a times (if P then b else c)" is the same as the expression "if P then (a times b) else (a times c)".

For any type `α` with multiplication and proposition `P`, the multiplication of `a` with the conditional `(if P then b else c)` equals the conditional `(if P then (a * b) else (a * c))`.


/-- **Alias** of `lt_of_lt_of_eq`. -/
theorem LT.lt.trans_eq : ∀ {α : Type u} {a b c : α} [inst : LT α], a < b → b = c → a < c := by sorry

This theorem, `LT.lt.trans_eq`, states that for any type `α` that has a less than (`<`) operation, if an element `a` is less than another element `b`, and `b` is equal to a third element `c`, then `a` is also less than `c`. This is essentially stating a property of transitivity for the less-than relation, where the transitivity also incorporates an equality.

If `a < b` and `b = c`, then `a < c` for any type `α` with a less-than relation `<`.


theorem mul_left_cancel :
    ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsLeftCancelMul G] {a b c : G}, a * b = a * c → b = c := by sorry

This theorem, `mul_left_cancel`, states that in any type `G` equipped with a multiplication operation (`Mul G`) and the property that multiplication is left-cancellable (`IsLeftCancelMul G`), for any elements `a`, `b`, `c` of `G`, if the equation `a * b = a * c` holds, then `b` must equal `c`. In other words, if you multiply the same value `a` by two different values `b` and `c` and get the same result, then `b` and `c` must have been the same to begin with, as long as the multiplication operation is left-cancellable in the system you're working within.

If `a` is an element of a group `G` with left-cancellative multiplication, then `b = c` given `a * b = a * c`.


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

This theorem states that for any type `α` that is a commutative monoid under subtraction ( a mathematical structure with a single associative binary operation and an identity element), the operation of subtracting `b` from `a` (represented as `a - b`) is the same as the operation of adding the negative of `b` to `a` (represented as `-b + a`). This holds true for any elements `a` and `b` of type `α`.

For any commutative monoid `α` with respect to subtraction, for all `a, b` in `α`, `a - b` is equivalent to `a + (-b)`.


theorem Mathlib.Logic.Basic._auxLemma.40 : ∀ {α : Sort u_2} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a' = a) = p a' := by
  sorry

This theorem, named `Mathlib.Logic.Basic._auxLemma.40`, states that for any type `α`, any property `p` of type `α`, and any element `a'` of type `α`, the existence of an element `a` such that `p a` holds and that `a'` is equal to `a`, is equivalent to the property `p` holding for `a'`. In other words, there exists some `a` satisfying `p` and equal to `a'` if and only if `a'` satisfies `p`.

For any type `α` and property `p` of `α`, an element `a'` satisfies `p` if and only if there exists an `a` equal to `a'` such that `p a` holds.


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

This theorem states that for any type `α` that has a `Preorder` instance, and for any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then `b` is not less than `a`. In terms of mathematical language, this theorem asserts that for all `a` and `b` in a preordered set, if `a` ≤ `b`, then it is not the case that `b` < `a`.

In a preordered set, if `a` is less than or equal to `b`, then `b` is not strictly less than `a`.


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

This theorem, `not_lt_of_ge`, states that for any type `α` that has a preorder relationship defined on its elements, if `a` and `b` are two elements of this type and `a` is greater than or equal to `b`, then it is not possible that `a` is less than `b`. In simpler terms, this theorem asserts that in a preorder, no element can be simultaneously greater than or equal to and less than another element.

In a preorder, for all types `α` and elements `a` and `b` of type `α`, if `a ≥ b`, then it is not the case that `a < b`.


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

This theorem states that for any semiring `R` and any element `a` of `R`, the natural degree of the constant polynomial `C a` is 0. In other words, the degree of a constant polynomial, when considered as a natural number, is always zero, regardless of the semiring in which the polynomial is defined or the specific constant value of the polynomial.

The natural degree of a constant polynomial is always 0 in any semiring.


theorem mul_lt_mul_of_pos_right :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosStrictMono α],
      b < c → 0 < a → b * a < c * a :=
  by sorry

The theorem `mul_lt_mul_of_pos_right` states that for any type `α` which has multiplication (`Mul α`), zero (`Zero α`), has a preorder relation (`Preorder α`), and satisfies strict monotonicity for multiplication by positive elements on the right (`MulPosStrictMono α`), if `b` is less than `c` and `a` is positive, then the product of `b` and `a` is less than the product of `c` and `a`. In mathematical terms, this can be written as: if `b < c` and `0 < a`, then `b * a < c * a`.

If `α` has multiplication, zero, a preorder relation, and multiplication is strictly monotonic on the right for positive elements, then for any `a positive in α` and `b, c in α` with `b < c`, it holds that `b * a < c * a`.


theorem Pi.add_apply :
    ∀ {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [inst : (i : I) → Add (f i)],
      (x + y) i = x i + y i :=
  by sorry

This theorem, `Pi.add_apply`, states that for any type `I`, for any function `f` mapping `I` to another type `v₁`, and for any two mappings `x` and `y` from `I` to `f`, and for any element `i` of `I`, if a `Add` instance is defined for `f i`, then applying the `+` operator to `x` and `y` and then applying the result to `i` is the same as applying `x` and `y` to `i` and then adding the results. In other words, it shows that addition in the context of these types of functions satisfies the property of distributivity over function application.

For any type `I`, function `f : I -> v₁`, and elements `x, y : I -> f`, if `I` has an `Add` instance and `i : I`, then `(x + y) i = x i + y i`.


theorem Filter.tendsto_map'_iff :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
      Filter.Tendsto f (Filter.map g x) y ↔ Filter.Tendsto (f ∘ g) x y :=
  by sorry

The theorem `Filter.tendsto_map'_iff` states that for any types `α`, `β`, and `γ`, and any functions `f : β → γ` and `g : α → β`, and any filters `x : Filter α` and `y : Filter γ`, the function `f` has the limit `y` after applying the forward map `g` on the filter `x` if and only if the function `f` composed with `g` has the limit `y` on the filter `x`. In other words, mapping a filter and then taking a limit is the same as composing the functions and then taking a limit.

For filters $x : Filter(\alpha)$, $y : Filter(\gamma)$, functions $f : \beta \rightarrow \gamma$, and $g : \alpha \rightarrow \beta$, $f$ has the limit $y$ after mapping $x$ if and only if $f \circ g$ has the limit $y$ on $x$.


theorem Finset.sum_subset :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : AddCommMonoid β],
      s₁ ⊆ s₂ → (∀ x ∈ s₂, x ∉ s₁ → f x = 0) → (Finset.sum s₁ fun x => f x) = Finset.sum s₂ fun x => f x :=
  by sorry

The theorem `Finset.sum_subset` states that for any types `α` and `β`, any two finite sets `s₁` and `s₂` of type `α`, and any function `f` that maps from `α` to `β` (where `β` is an additive commutative monoid), if `s₁` is a subset of `s₂` and for all elements `x` in `s₂` that do not belong to `s₁`, `f(x)` equals zero, then the sum of the function `f` applied to the elements of `s₁` equals the sum of the function `f` applied to the elements of `s₂`. In mathematical notation, this can be written as: if $s₁ \subseteq s₂$ and $\forall x \in s₂, x \notin s₁ \rightarrow f(x) = 0$, then $\sum_{x \in s₁} f(x) = \sum_{x \in s₂} f(x)$.

If two finite sets have the same elements with the remaining elements of one set mapping to zero under a function defined on an additive commutative monoid, then the sum of the function over the first set equals the sum over the second set.


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

This theorem, `and_congr_right'`, states that for any propositions `a`, `b`, and `c`, if `b` is logically equivalent to `c` (that is, `b` if and only if `c`), then the proposition "a and b" is logically equivalent to "a and c". Essentially, it confirms that the logical conjunction operation (i.e., "and") preserves logical equivalence on its second argument.

If `a` is a proposition and `b` is logically equivalent to `c`, then `a ∧ b` is logically equivalent to `a ∧ c`. (Here, `∧` denotes logical conjunction.)


theorem Filter.principal_singleton : ∀ {α : Type u} (a : α), Filter.principal {a} = pure a := by sorry

The theorem `Filter.principal_singleton` states that for any type `α` and any element `a` of type `α`, the principal filter of the singleton set containing `a` is equal to the pure function applied to `a`. In other words, the collection of all supersets of a singleton set `{a}` is equivalent to creating a function that always returns `a`.

For any type α and element a of α, the principal filter of the singleton set {a} equals the constant function mapping to a.


theorem Nat.zero_mod : ∀ (b : ℕ), 0 % b = 0 := by sorry

This theorem states that for every natural number `b`, the modulus of 0 divided by `b` is 0. In other words, when zero is divided by any natural number, the remainder is always zero. This is consistent with the mathematical concept of division and modulus, where the modulus is the remainder left after division.


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

This theorem states that for any natural number `n`, the product of `0` and `n` is `0`. In mathematical terms, this theorem formalizes the property `0*n = 0` for all natural numbers `n`, encapsulating the arithmetic rule that anything multiplied by zero equals zero.

For all natural numbers `n`, the product of `0` and `n` is equal to `0`.


/-- A sum taken over a conditional whose condition is an equality
test on the index and whose alternative is `0` has value either the term at that index or `0`.

The difference with `Finset.sum_ite_eq` is that the arguments to `eq` are swapped. -/
theorem Finset.sum_ite_eq' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (a : α)
      (b : α → β), (Finset.sum s fun x => if x = a then b x else 0) = if a ∈ s then b a else 0 :=
  by sorry

This theorem, `Finset.sum_ite_eq'`, states that for any finite set `s` of elements of type `α`, a given element `a` of that same type, and a function `b` from `α` to `β`, the sum over `s` of the function that maps each `x` in `s` to `b(x)` if `x` equals `a` and `0` otherwise, is equal to `b(a)` if `a` is in `s` and `0` otherwise. This is essentially the mathematical formulation of the intuitive notion that when we sum over a conditionally defined function whose value is `0` except at one specific point, the sum is either the value at that point (if the point is in the set we're summing over) or `0` (if the point isn't in the set). The difference between this theorem and `Finset.sum_ite_eq` lies in the order of the arguments to the equality test in the condition of the conditional function.

For any finite set `s` and element `a` in type `α`, and function `b` from `α` to `β`, the sum of applying `b` to `a` if `a` is in `s`, and `0` otherwise, equals `b(a)` if `a` is a member of `s`, and `0` otherwise.


theorem Nat.Prime.two_le : ∀ {p : ℕ}, Nat.Prime p → 2 ≤ p := by sorry

The theorem `Nat.Prime.two_le` states that for any natural number `p`, if `p` is prime, then `p` is greater than or equal to 2. In other words, it says that all prime numbers are at least 2.

If a natural number `p` is prime, then `p ≥ 2`.


theorem isCompl_compl : ∀ {α : Type u} {x : α} [inst : BooleanAlgebra α], IsCompl x xᶜ := by sorry

This theorem states that for all elements `x` of a type `α` in a Boolean algebra, `x` is complementary to its own complement `xᶜ`. In terms of set theory, this theorem proves that every element and its complement form a complementary pair, meaning the union of the two gives the universal set and their intersection is empty.

In a Boolean algebra, for all elements `x`, `x` is complementary to `xᶜ`, meaning `x ∨ xᶜ = ⊤` and `x ∧ xᶜ = ⊥`.


theorem Mathlib.Data.Finsupp.Defs._auxLemma.1 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) := by sorry

This theorem states that for any type `α` and any type `M` that has a zero element, given a function `f` from `α` to `M` and an element `a` of `α`, the element `a` is in the support of `f` if and only if the value of `f` at `a` is not zero. Here, the support of `f` is the set of elements of `α` for which `f` does not return zero.

For any function `f` from type `α` to a type `M` with zero element, the element `a` in `α` is in the support of `f` if and only if `f a ≠ 0`.


theorem Finset.nonempty_iff_ne_empty : ∀ {α : Type u_1} {s : Finset α}, s.Nonempty ↔ s ≠ ∅ := by sorry

This theorem, `Finset.nonempty_iff_ne_empty`, states that for any type `α` and any Finite Set `s` of type `α`, `s` is nonempty if and only if `s` is not equal to the empty set. In other words, a finite set `s` has at least one element in it if and only if it's not the case that `s` is the empty set.

A finite set is nonempty if and only if it is not equal to the empty set.


theorem Nat.add_sub_cancel : ∀ (n m : ℕ), n + m - m = n := by sorry

This theorem states that for any two natural numbers `n` and `m`, if you add `m` to `n` and then subtract `m`, you will get back `n`. This is a formalization of the standard arithmetic property that adding a number and then subtracting the same number leaves the original number unchanged.

For all natural numbers `n` and `m`, `n + m = n + m + (-m)`.


CategoryTheory.Discrete.ext

theorem CategoryTheory.Discrete.ext : ∀ {α : Type u₁} (x y : CategoryTheory.Discrete α), x.as = y.as → x = y := by sorry

This theorem, called `CategoryTheory.Discrete.ext`, states that for any type `α`, if we have two objects `x` and `y` of the discrete category over `α` (i.e., `CategoryTheory.Discrete α`), and if the underlying objects of `x` and `y` in `α` are the same (i.e., `x.as = y.as`), then `x` and `y` themselves are the same (i.e., `x = y`). This reinforces the idea that objects in a discrete category are just the underlying objects of the type they are based on.

In the discrete category over a type `α`, two objects `x` and `y` are equal if and only if their underlying objects in `α` are equal.


Sbtw.wbtw

theorem Sbtw.wbtw :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Sbtw R x y z → Wbtw R x y z :=
  by sorry

This theorem states that for any types `R`, `V`, `P` where `R` is an ordered ring, `V` is an additive commutative group, `P` is an affine space over `V` with `R` as its scalar field, and `x`, `y`, `z` are points in this affine space, if `y` is strictly between `x` and `z` (according to the definition `Sbtw`), then `y` is also weakly between `x` and `z` (according to the definition `Wbtw`). In other words, the condition of a point being strictly between two other points implies the condition of the point being weakly between the same two points.

If `x`, `y`, `z` are points in an affine space over an ordered ring `R`, with `V` as its additive commutative group as the scalar field, and `y` is strictly between `x` and `z` (`Sbtw x y z`), then `y` is also weakly between `x` and `z` (`Wbtw x y z`).


theorem Polynomial.degree_eq_bot :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.degree p = ⊥ ↔ p = 0 := by sorry

This theorem states that for any type `R` which is a semiring and any polynomial `p` over `R`, the degree of the polynomial `p` is equal to `⊥` (which represents an undefined or lowest possible degree) if and only if the polynomial `p` is zero. In mathematical terms, the degree of a polynomial is undefined or at its lowest possible value precisely when the polynomial itself is zero.

For any semiring `R` and polynomial `p` over `R`, the degree of `p` is 0 if and only if `p` is the zero polynomial.


theorem Finset.sum_nonneg :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f : ι → N} {s : Finset ι},
      (∀ i ∈ s, 0 ≤ f i) → 0 ≤ Finset.sum s fun i => f i :=
  by sorry

This theorem states that if we have a function `f : ι → N`, where `ι` is an arbitrary type and `N` is an ordered additive commutative monoid, and a finite set `s` of elements of type `ι`, then if every element `i` in `s` satisfies the condition that `f(i)` is greater than or equal to zero, then the sum of `f(i)` over all `i` in `s` is also greater than or equal to zero. In mathematical terms, this can be written as: if `∀ i ∈ s, 0 ≤ f(i)`, then `0 ≤ ∑ i ∈ s, f(i)`.

If `f : ι → N` is a function from an arbitrary type `ι` to an ordered additive commutative monoid `N`, and `s ⊆ ι` is finite with `0 ≤ f(i)` for all `i ∈ s`, then `0 ≤ ∑ i ∈ s, f(i)`.


CategoryTheory.Limits.Cofork.condition

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

This theorem, called `CategoryTheory.Limits.Cofork.condition`, states that for any category `C` and for any objects `X` and `Y` in this category, given two morphisms `f` and `g` from `X` to `Y` and a cofork `t` on `f` and `g`, the composition of the morphism `f` with the projection function of the cofork (`CategoryTheory.Limits.Cofork.π t`) is equal to the composition of the morphism `g` with the same projection function. In other words, the diagram formed by `f`, `g`, and the cofork projection commutes.

For any category C, objects X and Y, morphisms f and g from X to Y, and cofork t on f and g, the diagram commutes: f · CategoryTheory.Limits.Cofork.π t = g · CategoryTheory.Limits.Cofork.π t.


theorem CategoryTheory.Limits.biproduct.hom_ext' :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      {Z : C} (g h : ⨁ f ⟶ Z),
      (∀ (j : J),
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j) g =
            CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j) h) →
        g = h :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.hom_ext'`, states that for any type `J` and category `C` that has zero morphisms, given a function `f` from `J` to `C` which has a biproduct, and any object `Z` in `C`, for two morphisms `g` and `h` from the biproduct of `f` to `Z`, if for every `j` in `J`, the composition of the inclusion of `f j` into the biproduct with `g` is equal to the composition of the inclusion of `f j` into the biproduct with `h`, then `g` and `h` are equal. In other words, it's a uniqueness property for morphisms originating from the biproduct: if two such morphisms coincide on each inclusion from the constituents of the biproduct, they are the same morphism.

Given a function `f` from a type `J` to a zero-object category `C` with a biproduct, if for all `j` in `J` and morphisms `g` and `h` from the biproduct of `f` to an object `Z` in `C`, the composition of the inclusion of `f j` with `g` equals the composition of the inclusion of `f j` with `h`, then `g` and `h` are equal.


/-- An additive isomorphism preserves addition. -/
theorem AddEquiv.map_add :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (f : M ≃+ N) (x y : M), f (x + y) = f x + f y := by
  sorry

This theorem states that an additive isomorphism, denoted as `f : M ≃+ N`, preserves addition. Specifically, for any two elements `x` and `y` from the type `M` equipped with addition operation, the image of the sum under the isomorphism is equal to the sum of the images, i.e., `f (x + y) = f x + f y`. In other words, applying `f` to the sum of `x` and `y` is the same as adding the images of `x` and `y` under `f`. This property is a key characteristic of additive isomorphisms.

An additive isomorphism preserves addition, that is, for all `x, y` in `M`, `f (x + y) = f x + f y`.


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

This theorem, `neg_lt_neg_iff`, states that for any type `α` where `α` is an additive group and also obeys certain ordering and covariance properties, the inequality `-a < -b` is equivalent to `b < a` for any elements `a` and `b` of `α`. In other words, this theorem says that negating both sides of an inequality and swapping them preserves the order in this type `α`. The covariance properties are implicitly indicating that the operations and comparisons are compatible in a certain way in the context of this type `α`.

For all additive groups `α` with covariance properties, `-a < -b` is equivalent to `b < a`.


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

This theorem states that for any given type `α` and any element `a` of that type, `a` is an element of the set that only contains `a`. In other words, `a` exists in the singleton set `{a}`. This is a fundamental property of singleton sets.

For any type `α` and its element `a`, `a` belongs to the singleton set `{a}`.


theorem Set.mem_setOf : ∀ {α : Type u} {a : α} {p : α → Prop}, a ∈ {x | p x} ↔ p a := by sorry

This theorem, `Set.mem_setOf`, relates membership in a set to satisfaction of a property. Specifically, for any type `α`, any element `a` of that type, and any property `p` that applies to elements of type `α`, `a` belongs to the set of elements `x` for which `p x` holds if and only if `p a` holds. In other words, an element `a` is a member of the set described by the property `p` precisely when `a` satisfies the property `p`.

For any type `α`, set `S` defined as `{x : α | p x}`, and element `a` of type `α`, `a` is a member of `S` if and only if `p a` holds.


MeasureTheory.MeasurePreserving.comp

theorem MeasureTheory.MeasurePreserving.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β}
      {μc : MeasureTheory.Measure γ} {g : β → γ} {f : α → β},
      MeasureTheory.MeasurePreserving g μb μc →
        MeasureTheory.MeasurePreserving f μa μb → MeasureTheory.MeasurePreserving (g ∘ f) μa μc :=
  by sorry

This theorem states that if you have three types α, β and γ with respective measurable spaces and corresponding measures μa, μb and μc, and you have two functions, g mapping from β to γ and f mapping from α to β. If it's known that g preserves the measure from μb to μc, and f preserves the measure from μa to μb, then the composition of g and f (g ∘ f) also preserves measure, specifically from μa to μc. In other words, the measure-preserving property of both the functions f and g is maintained under function composition.

If functions f: α -> β and g: β -> γ preserve measures μa and μb, respectively, then their composition g ∘ f preserves the measure from α to γ (μa to μc).


theorem zero_le_two :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : Preorder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 ≤ 2 :=
  by sorry

This theorem states that for any type `α` which has the structure of an additive monoid with one (namely, it has an operation of addition and a distinct element 'one', with the usual properties such as associativity and identity), a preorder (a relation that is reflexive and transitive), and a property where zero is less than or equal to one, and is a covariant class (a class where, if `x` plus some value is less than or equal to `x_1` plus some value, then `x` is less than or equal to `x_1`), then zero is less than or equal to two.

If `α` is an additive monoid with one, has a preorder where zero is less than or equal to one, and is a covariant class, then `0 ≤ 2`.


theorem inv_div : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b : α), (a / b)⁻¹ = b / a := by sorry

This theorem, called `inv_div`, states that for all `a` and `b` in a Division Monoid `α`, the inverse of the division of `a` by `b` is equal to the division of `b` by `a`. In mathematical notation, this means that for all `a, b` in a given group equipped with an operation of division, `(a / b)⁻¹ = b / a`. This is a fundamental property in the field of algebra where the Division Monoid is a structure consisting of a set equipped with an associative binary operation and an invertible element.

For all `a, b` in a Division Monoid `α`, `(a / b)⁻¹ = b / a`.


theorem CategoryTheory.MonoidalCategory.whiskerRight_id :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f : X ⟶ Y),
      CategoryTheory.MonoidalCategory.whiskerRight f (𝟙_ C) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.rightUnitor X).hom
          (CategoryTheory.CategoryStruct.comp f (CategoryTheory.MonoidalCategory.rightUnitor Y).inv) :=
  by sorry

The theorem `CategoryTheory.MonoidalCategory.whiskerRight_id` states that for any category `C` that is also a monoidal category, and for any two objects `X` and `Y` in `C`, the whisker right of a morphism `f` from `X` to `Y` with the identity morphism of `C` is equal to the composition of the right unitor of `X` and the composition of `f` and the inverse of the right unitor of `Y`.

In other words, this theorem concerns the interaction of morphisms and unitors in a monoidal category. The "whisker right" operation corresponds to the "precomposition with an identity morphism" operation in the monoidal category, and the "right unitor" is a specific isomorphism associated with each object of the monoidal category, witnessing the identity law for tensoring with a unit object. This theorem asserts a specific equality involving these concepts, which is part of the structure of a monoidal category.

In a monoidal category `C`, for all objects `X` and `Y` and morphisms `f : X → Y`, the whisker right of `f` with the identity morphism is equal to the composition of the right unitor of `X` with `f` and the inverse of the right unitor of `Y`.


theorem List.pairwise_cons :
    ∀ {α : Type u_1} {R : α → α → Prop} {a : α} {l : List α},
      List.Pairwise R (a :: l) ↔ (∀ a' ∈ l, R a a') ∧ List.Pairwise R l :=
  by sorry

This theorem, `List.pairwise_cons`, is about lists in Lean 4. It states that for any type `α`, any relation `R` on `α`, any element `a` of `α`, and any list `l` of elements of `α`, the list `a` followed by `l` (`a :: l`) is pairwise related by `R` if and only if (1) every element `a'` in the list `l` is related to `a` by `R` and (2) `l` is pairwise related by `R`. In more plain language, the first element of the list is related by `R` to every other element, and every pair of elements in the remainder of the list are also related by `R`.

For any type `α` and relation `R` on `α`, the list `[a] ++ l` is pairwise related by `R` if and only if `a` is related to every element in `l` by `R` and `l` is pairwise related by `R`.


theorem Filter.principal_mono : ∀ {α : Type u} {s t : Set α}, Filter.principal s ≤ Filter.principal t ↔ s ⊆ t := by
  sorry

The theorem `Filter.principal_mono` states that for any type `α` and any two sets `s` and `t` of type `α`, the principal filter of `s` is less than or equal to the principal filter of `t` if and only if `s` is a subset of `t`. In other words, the containment relationship between the principal filters of two sets directly corresponds to the subset relationship between the two sets themselves.

The principal filters of sets `s` and `t` over type `α` are equal if and only if `s` is a subset of `t`.


theorem le_himp_iff : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, a ≤ b ⇨ c ↔ a ⊓ b ≤ c := by
  sorry

This theorem states that for all types `α` that have a structure of a Generalized Heyting Algebra, and for any `a`, `b`, and `c` of type `α`, `a` is less than or equal to the Heyting implication of `b` and `c` if and only if the infimum (greatest lower bound) of `a` and `b` is less than or equal to `c`.

For any type `α` with a Generalized Heyting Algebra structure and any elements `a`, `b`, and `c` of type `α`, `a ≤ i(b, c)` if and only if `inf(a, b) ≤ c`, where `i` denotes Heyting implication and `inf` denotes the infimum.


theorem le_iSup_of_le :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α} (i : ι), a ≤ f i → a ≤ iSup f := by
  sorry

This theorem states that for any type α which forms a complete lattice, an indexed function `f` from any type ι to α, and any element `a` of type α, if `a` is less than or equal to `f(i)` for some `i` in ι, then `a` is also less than or equal to the indexed supremum of `f`. In other words, any element of α that is less than or equal to the value of `f` at a particular point is also less than or equal to the supremum of the values of `f` across all of its domain.

For any complete lattice α, any indexed function f from type ι to α, and any a in α, if there exists i in ι such that a ≤ f(i), then a ≤ sup(f).


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

This theorem, `le_add_of_nonneg_left`, states that for any type `α` that has the structure of an `AddZeroClass` and a `LE` (less than or equal to) relation, and also satisfies the `CovariantClass` property with respect to addition (i.e., swapping the arguments of the addition function preserves the `LE` relation), if `a` and `b` are two elements of this type and `b` is nonnegative (meaning that `b` is greater than or equal to zero), then `a` is less than or equal to the sum of `b` and `a`. In mathematical terms, if `0 ≤ b`, then `a ≤ b + a`.

If `α` is an AddZeroClass type with a Covariant LE relation such that `0 ≤ b`, then `a ≤ b + a`.


/-- A cardinal lifted to a lower or equal universe equals itself.  -/
theorem Cardinal.lift_id' : ∀ (a : Cardinal.{max u v}), Cardinal.lift.{u, max u v} a = a := by sorry

This theorem, `Cardinal.lift_id'`, states that for any cardinal number `a` defined in the maximum of universe `u` and `v`, if we perform a universe lift operation on `a` to a universe which is lower than or equal to its original universe (`max u v`), the lifted cardinal number remains the same as `a`. In mathematical terms, this means that lifting a cardinal to a universe no greater than its current one will not change the cardinality.

For any cardinal number `a` and universes `u` and `v` with `u` being an upper bound of their maximum, the cardinality lifted from `u` to a universe `w` with `w <= u` remains equal to `a`.


theorem Finset.mem_Icc :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      x ∈ Finset.Icc a b ↔ a ≤ x ∧ x ≤ b :=
  by sorry

This theorem asserts that for any type `α` that has a preorder (i.e., a binary relation that is reflexive and transitive) and a locally finite order (i.e., every bounded interval is finite), and for any three elements `a`, `b`, `x` of this type, `x` belongs to the finite set of elements between `a` and `b` (inclusive) if and only if `x` is greater than or equal to `a` and less than or equal to `b`. In other words, `x` is in the set `Finset.Icc a b` precisely when `a ≤ x ≤ b`.

For any type `α` with a reflexive, transitive preorder and finite intervals, an element `x` lies between `a` and `b` if and only if `a ≤ x ≤ b`.


theorem sub_lt_iff_lt_add :
    ∀ {α : 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 c : α},
      a - c < b ↔ a < b + c :=
  by sorry

This theorem, `sub_lt_iff_lt_add`, states for any type `α` that is an additive group and has a less than (`<`) relation, and if the addition function `+` for `α` is a covariant class with respect to the less than relation (that is, if `a < b` then for any `c`, `c + a < c + b`), then for any elements `a`, `b`, and `c` of type `α`, the inequality `a - c < b` is equivalent to `a < b + c`. In simpler words, this theorem provides a way to rearrange the terms in one inequality to form another, while maintaining the validity of the inequality.

For any additive group `α` with a covariant `<` relation, `a < b` is equivalent to `a - c < b - c` for all `a, b, c` in `α`.


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

This theorem, `inf_idem`, states that for any type `α` which is a semilattice with respect to the infimum operation (denoted by `⊓`), the infimum of any element `a` with itself is equal to `a`. In other words, in any such semilattice, taking the infimum of an element with itself doesn't change the element.

For any semilattice `α` with respect to the infimum operation, `⊓`, the infimum of any element `a` with itself equals `a`: `∀ α : Type, is_semilattice α → a ⊓ a = a`.


theorem Real.rpow_nat_cast : ∀ (x : ℝ) (n : ℕ), x ^ ↑n = x ^ n := by sorry

This theorem states that for any real number `x` and natural number `n`, raising `x` to the power of `n` casted as a real number is equal to raising `x` to the power of `n`. In mathematical notation, this would be expressed as ∀x∈ℝ, n∈ℕ, x^(↑n) = x^n. It essentially shows that converting `n` to a real number doesn't affect the result of the power operation.

For all real numbers `x` and natural numbers `n`, `x` raised to the power of the successor of `n` is equal to `x` raised to the power of `n`. (Or, equivalently, casting `n` as a real number does not affect the result of the power operation: `∀x∈ℝ, n∈ℕ, x^(↑n) = x^n`)


theorem Finset.prod_const_one :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} [inst : CommMonoid β], (Finset.prod s fun _x => 1) = 1 := by sorry

The theorem `Finset.prod_const_one` states that for any finite set `s` of elements of some type `α` and for any commutative monoid `β`, the product of the constant function `1` over all elements of `s` is `1`. In other words, if you take the product of the number `1` for each element in a finite set, the overall product will always be `1`.

For any finite set `s` and commutative monoid `β`, the product of the constant function `1` over all elements of `s` equals `1`.


HasSum.map

theorem HasSum.map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
      {a : α} [inst_2 : AddCommMonoid γ] [inst_3 : TopologicalSpace γ],
      HasSum f a →
        ∀ {G : Type u_5} [inst_4 : FunLike G α γ] [inst : AddMonoidHomClass G α γ] (g : G),
          Continuous ⇑g → HasSum (⇑g ∘ f) (g a) :=
  by sorry

The theorem `HasSum.map` states that for any types `α`, `β`, and `γ`, given an additively commutative monoid structure and a topological space structure on `α` and `γ`, a function `f` from `β` to `α`, and a value `a` of type `α` such that `f` has a sum `a`, then for any type `G` that is function-like from `α` to `γ` and has an additive monoid homomorphism class, if a function `g` of type `G` is continuous, then the composition of `g` with `f` (`g ∘ f`) has sum equal to `g a`. In other words, it's stating that the sum of the image of a function under a continuous homomorphism is the homomorphism of the sum, provided the original function has a sum.

Given additively commutative monoids and topological spaces `α`, `β`, `γ`, a continuous additive homomorphism `g` from `α` to `γ`, a function `f` from `β` to `α` with sum `a` in `α`, and an element `b` in `β` such that `f(b) = a`, then `g(a) = g(∑ i. f(bi)) = ∑ i. g(fi)`, where the sums are taken over the index set of `f`.


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

This theorem states that for any type `G` that is an additive group, for every three elements `a`, `b`, and `c` of `G`, subtracting `b` from `a` and adding the result to the subtraction of `c` from `b` gives the same result as subtracting `c` from `a`. In mathematical notation, this would be expressed as `(a - b) + (b - c) = a - c`. This is a property that holds in the context of all additive groups.

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


theorem Tropical.untrop_injective : ∀ {R : Type u}, Function.Injective Tropical.untrop := by sorry

The theorem `Tropical.untrop_injective` states that for any type `R`, the function `untrop`, which reinterprets an element `x` of `Tropical R` as an element of `R`, is injective. In other words, if `untrop` maps two elements of `Tropical R` to the same element of `R`, then those two elements of `Tropical R` were in fact the same. This is equivalent to saying that no two different elements of `Tropical R` are mapped to the same element of `R` by the `untrop` function.

The `untrop` function mapping elements of `Tropical R` to `R` is injective.


minpoly.aeval

/-- An element is a root of its minimal polynomial.  -/
theorem minpoly.aeval :
    ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B),
      (Polynomial.aeval x) (minpoly A x) = 0 :=
  by sorry

This theorem states that for any given type `A` with a commutative ring structure, type `B` with a ring structure and `B` being an `A`-algebra, any element `x` of type `B` is a root of its minimal polynomial. In other words, if we evaluate the minimal polynomial of `x` at `x` using the `Polynomial.aeval` function, the result is zero. In mathematical terms, it is equivalent to saying that if $p(x)$ represents the minimal polynomial of $x$, then $p(x) = 0$.

For any commutative ring `A`, `A`-algebra `B` with an element `x`, the minimal polynomial of `x` in `B[X]` evaluates to zero at `x`.


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

This theorem states that for all natural numbers `k`, `m`, and `n`, if `k` divides `m` and `k` divides `n`, then `k` also divides the greatest common divisor of `m` and `n`. In mathematical terms, we can express it as follows: for all $k, m, n \in \mathbb{N}$, if $k | m$ and $k | n$, then $k | \gcd(m, n)$.

If `k` divides `m` and `k` divides `n`, then `k` divides their greatest common divisor `gcd(m, n)`.


theorem Multiset.mem_cons_of_mem : ∀ {α : Type u_1} {a b : α} {s : Multiset α}, a ∈ s → a ∈ b ::ₘ s := by sorry

This theorem asserts that for any type `α`, and any elements `a` and `b` of type `α`, and any multiset `s` of type `α`, if `a` is an element of `s`, then `a` is also an element of the multiset formed by prepending `b` to `s`. In other words, adding an element to a multiset does not remove any existing elements.

For any type `α`, any element `a` in `α`, and any multiset `s` of type `α`, if `a` is an element of `s`, then `a` is an element of the multiset obtained by adding any element `b` to `s`.


LowerSet.ext

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

This theorem, named `LowerSet.ext`, asserts that for any type `α` with a less-than-or-equal-to (`LE`) order relation, if two lower sets `s` and `t` of this type have the same elements (i.e., `↑s = ↑t`), then they are the same lower set (`s = t`). A lower set is a set of elements such that, if an element is in the set, then all lesser elements are also in the set. Therefore, this theorem is essentially saying that two lower sets are equal if and only if they contain the same elements.

If `α` is a type with a `LE` order relation and `s` and `t` are lower sets of `α` with the same elements, then `s = t`.


theorem smul_le_smul_of_nonneg_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulMono α β], b₁ ≤ b₂ → 0 ≤ a → a • b₁ ≤ a • b₂ :=
  by sorry

This theorem, `smul_le_smul_of_nonneg_left`, states that for any types `α` and `β`, and for any elements `a` of `α` and `b₁` and `b₂` of `β`, given that `α` and `β` have a multiplication (`SMul α β`), that `α` and `β` are preordered (meaning that they have a "less than or equal to" relation), and that `α` has a zero and a positive, strictly monotonic multiplication with `β`; if `b₁` is less than or equal to `b₂` and `a` is nonnegative (greater than or equal to zero), then the product of `a` and `b₁` is less than or equal to the product of `a` and `b₂`. This is a generalization of the property of real numbers that if `x ≤ y` and `0 ≤ a`, then `a*x ≤ a*y`.

For any types `α` and `β` with multiplication, preorder, zero, and positive element, if `a ≥ 0`, `b₁ ≤ b₂`, then `a * b₁ ≤ a * b₂`.


Inducing.continuous

theorem Inducing.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Inducing f → Continuous f :=
  by sorry

This theorem states that for any two types `X` and `Y`, and any function `f` from `X` to `Y`, if `f` induces the topology of `Y` on `X` (i.e., the topology on `X` is the coarsest one that makes `f` continuous), then `f` is a continuous function. This holds under the condition that `X` and `Y` are both equipped with a topological space structure. This is a foundational result in topology, linking the concepts of induced topology and continuous functions.

If a function between topological spaces is the identification of the topology on the domain, then it is continuous.


theorem codisjoint_iff :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b ↔ a ⊔ b = ⊤ := by sorry

The theorem `codisjoint_iff` states that for any type `α` which is a semilattice with a supremum operation and also has a top element, and for any two elements `a` and `b` of type `α`, the two elements `a` and `b` are codisjoint if and only if the supremum of `a` and `b` is the top element of the semilattice. Here, 'codisjoint' refers to a condition where, for any element `x` of type `α`, if `a` and `b` are both less than or equal to `x`, then the top element of the semilattice is less than or equal to `x`.

For any semilattice with supremum and top element, elements `a` and `b` are codisjoint if and only if their supremum equals the top element.


theorem continuous_def :
    ∀ {X : Type u_1} {Y : Type u_2} {x : TopologicalSpace X} {x_1 : TopologicalSpace Y} {f : X → Y},
      Continuous f ↔ ∀ (s : Set Y), IsOpen s → IsOpen (f ⁻¹' s) :=
  by sorry

This theorem states that a function `f` between two topological spaces `X` and `Y` is continuous if and only if for every set `s` in `Y` that is open in the topological space of `Y`, the preimage of `s` under `f` is open in the topological space of `X`. In other words, the continuity of a function is defined by the property that the preimage of an open set is always open.

A function between two topological spaces is continuous if and only if the preimage of every open set is open.


theorem continuous_id' : ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous fun x => x := by sorry

This theorem states that for any type `X` equipped with a topology (denoted by `TopologicalSpace X`), the identity function (defined as `fun x => x`) is continuous. In mathematical terms, for all topological spaces, the identity mapping is always continuous.

The identity function is continuous on any topological space.


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

This theorem, `and_assoc`, states that for any three propositions `a`, `b`, and `c`, the logical 'and' operation (`∧`) is associative. In other words, the proposition "(a and b) and c" is logically equivalent to the proposition "a and (b and c)". This means if you know that "a and b" is true and "c" is also true, it's the same as knowing "a" is true and "b and c" is true. These two forms are interchangeable.

The logical 'and' operation is associative: (a ∧ b) ∧ c ≡ a ∧ (b ∧ c) for all propositions a, b, and c.