theorem Finset.sum_filter_add_sum_filter_not :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] (s : Finset α) (p : α → Prop) [inst_1 : DecidablePred p]
      [inst_2 : (x : α) → Decidable ¬p x] (f : α → β),
      ((Finset.sum (Finset.filter p s) fun x => f x) + Finset.sum (Finset.filter (fun x => ¬p x) s) fun x => f x) =
        Finset.sum s fun x => f x :=
  by sorry

This theorem, named `Finset.sum_filter_add_sum_filter_not`, states that for any finite set `s` of elements of type `α`, a property `p` that can be decided for each element, and a function `f` from `α` to `β` (where `β` is a type with an associated commutative addition operation), the sum of `f(x)` over elements `x` in `s` that satisfy property `p`, added to the sum of `f(x)` over elements `x` in `s` that do not satisfy property `p`, equals to the sum of `f(x)` over all elements `x` in `s`. This theorem is essentially expressing the partition of a finite sum into two parts according to whether elements satisfy a certain property or not.

For any finite set `s` and function `f` from a type with commutative addition, the sum of `f` applied to elements in `s` satisfying a property equals the sum of `f` applied to all elements in `s`, partitioned by elements satisfying or not satisfying the property.


theorem Algebra.IsAlgebraic.of_injective :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u_2}
      [inst_3 : Ring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
      Function.Injective ⇑f → Algebra.IsAlgebraic R B → Algebra.IsAlgebraic R A :=
  by sorry

The theorem `Algebra.IsAlgebraic.of_injective` states that for any types `R` and `A`, where `R` is a commutative ring, `A` is a ring, and `A` is an `R`-algebra, if there exists another type `B` that is also a ring and an `R`-algebra, along with an algebra map `f : A →ₐ[R] B` that is injective, then if `B` is an algebraic over `R` (all elements of `B` are algebraic over `R`), it implies that `A` is also algebraic over `R`. In simpler terms, an injective algebra map from an algebra `A` to another algebra `B` preserves the property of being algebraic over a common base ring `R`.

If `R` is a commutative ring, `A` and `B` are `R`-algebras, `f : A →ₐ[R] B` is an injective algebra map, and `B` is algebraic over `R`, then `A` is also algebraic over `R`.


theorem Mathlib.Topology.MetricSpace.Thickening._auxLemma.3 :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} (E : Set α) (x : α),
      (x ∈ Metric.thickening δ E) = ∃ z ∈ E, edist x z < ENNReal.ofReal δ :=
  by sorry

The theorem `Mathlib.Topology.MetricSpace.Thickening._auxLemma.3` states that for any type `α` endowed with the structure of a pseudo emetric space, any real number `δ`, any set `E` of elements of type `α`, and any element `x` of type `α`, the membership of `x` in the `δ`-thickening of `E` (i.e., the set of points at a distance less than `δ` from some point in `E`) is equivalent to the existence of an element `z` in `E` such that the extended distance between `x` and `z` is less than the non-negative real part of `δ`.

For any pseudo metric space (α, d), real number δ, set E ⊆ α, and x ∈ α, x is in the δ-thickening of E if and only if there exists z ∈ E such that d(x, z) < ∥δ∥.


theorem Set.MapsTo.restrict_surjective_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.MapsTo f s t),
      Function.Surjective (Set.MapsTo.restrict f s t h) ↔ Set.SurjOn f s t :=
  by sorry

The theorem `Set.MapsTo.restrict_surjective_iff` states that for any types `α` and `β`, a set `s` of type `α`, a set `t` of type `β`, and a function `f` from `α` to `β` that maps `s` to `t`, the function `f` restricted to the domain `s` and codomain `t` is surjective if and only if `f` is surjective from `s` to `t`. In other words, for every element in the set `t`, there exists an element in the set `s` such that the function `f` maps this element of `s` to the element of `t`.

For any functions $f: \alpha \to \beta$ and sets $s \subseteq \alpha$, $t \subseteq \beta$ such that $f(s) = t$, the restriction $f|_s: s \to t$ is surjective if and only if $f$ is surjective from $\alpha$ to $\beta$.


theorem AffineSubspace.nonempty_of_affineSpan_eq_top :
    ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {s : Set P}, affineSpan k s = ⊤ → Set.Nonempty s :=
  by sorry

This theorem states that for any ring `k`, additive commutative group `V`, and set `P` with `V` acting on `P` as an additive torsor, if the affine span of a set `s` of points in `P` equals the entire space (`⊤`), then the set `s` is not empty. In other words, the smallest affine subspace that contains all points cannot be the entire space unless there is at least one point in the set.

If a set `s` of points in an additive torsor `P` over an additive commutative group `V` with action by a ring `k` has the property that the affine span of `s` equals the entire space `V`, then `s` is non-empty.


theorem infClosed_univ : ∀ {α : Type u_2} [inst : SemilatticeInf α], InfClosed Set.univ := by sorry

The theorem `infClosed_univ` states that for any type `α` that has a structure of `SemilatticeInf` (meaning it has a binary operation `⊓` that is associative, commutative, and idempotent), the universal set of `α` is inf-closed. In other words, for any two elements `a` and `b` in the universal set of `α`, their infimum (i.e., the result of the operation `a ⊓ b`) is also in the universal set.

For any type `α` with a `SemilatticeInf` structure, the universal set is closed under the infimum operation.


theorem smul_sphere' :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {c : 𝕜},
      c ≠ 0 → ∀ (x : E) (r : ℝ), c • Metric.sphere x r = Metric.sphere (c • x) (‖c‖ * r) :=
  by sorry

The theorem `smul_sphere'` states that for any non-zero scalar `c` of a normed field `𝕜`, and any point `x` in a seminormed add commutative group `E` that also forms a normed space over `𝕜`, and any real number `r`, the scalar multiplication of `c` with the metric sphere centered at `x` with radius `r` equals the metric sphere centered at `c • x` with radius `‖c‖ * r`. In other words, scaling a sphere by a factor `c` not only scales the points in the sphere, but also moves its center and changes its radius proportionally to the absolute value of `c`.

For any non-zero scalar `c` in a normed field and any point `x` in a seminormed add commutative group that is also a normed space over that field, the metric sphere centered at `x` with radius `r` is equal to the scalar multiplication of the sphere centered at `0` with radius `r * ‖c‖` by `c`, i.e., `{y : E | ∥y - x∥ ≤ r} = {y : E | ∥y - (c * x)∥ = r * ‖c‖}`.


theorem Subgroup.closure_union :
    ∀ {G : Type u_1} [inst : Group G] (s t : Set G),
      Subgroup.closure (s ∪ t) = Subgroup.closure s ⊔ Subgroup.closure t :=
  by sorry

This theorem states that for any type `G` that has a group structure, given two sets `s` and `t` of elements of `G`, the subgroup generated by the union of `s` and `t` is equal to the join (supremum) of the subgroups generated by `s` and `t` respectively. In other words, the smallest subgroup of `G` that contains all elements of `s` and `t` is the smallest subgroup that includes both the smallest subgroup containing all elements of `s` and the smallest subgroup containing all elements of `t`.

For any group `G`, the subgroup generated by the union of two sets `s` and `t` in `G` is equal to the subgroup generated by the union of the subgroups generated by `s` and `t` separately.


theorem MeasureTheory.snorm_add_le' :
    ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
      {f g : α → E},
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ →
          ∀ (p : ENNReal),
            MeasureTheory.snorm (f + g) p μ ≤
              MeasureTheory.LpAddConst p * (MeasureTheory.snorm f p μ + MeasureTheory.snorm g p μ) :=
  by sorry

This theorem, `MeasureTheory.snorm_add_le'`, states that for any two functions `f` and `g` from a set `α` to a normed additive commutative group `E`, if both functions are almost everywhere strongly measurable with respect to a measure `μ`, then for any extended nonnegative real number `p`, the seminorm of the sum of the functions, `(f + g)`, is less than or equal to a constant times the sum of the seminorms of `f` and `g` individually.

Here, the constant is determined by `MeasureTheory.LpAddConst p`, which is `1` if `p` is greater than or equal to `1` or `p` equals `0`, and `2^(1/p - 1)` if `p` is between `0` and `1`. The seminorm, given by `MeasureTheory.snorm`, is `0` for `p=0`, `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and the essential supremum of `‖f‖` with respect to `μ` for `p = ∞`.

For almost everywhere strongly measurable functions `f` and `g` from a set `α` to a normed additive commutative group `E` with respect to a measure `μ`, the seminorm of their sum `(f + g)` is less than or equal to `MeasureTheory.LpAddConst p` times the sum of the seminorms of `f` and `g`, where `p` is an extended nonnegative real number and `MeasureTheory.LpAddConst p` is defined as `1` for `p ≥ 1` or `p = 0`, and `2^(1/p - 1)` for `0 < p < 1`.


theorem List.length_tails : ∀ {α : Type u_1} (l : List α), List.length (List.tails l) = List.length l + 1 := by sorry

This theorem states that for any list `l` of elements of an arbitrary type `α`, the length of the list of all terminal segments of `l` (obtained using the `List.tails` function) is equal to the length of the original list plus one. The "+1" accounts for the empty list which is always included as the last element in the list of terminal segments.

The number of terminal segments in a list of length n is equal to n+1.


theorem Polynomial.coeff_X_mul :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ),
      Polynomial.coeff (Polynomial.X * p) (n + 1) = Polynomial.coeff p n :=
  by sorry

This theorem, Polynomial.coeff_X_mul, states that for any semiring R and for any polynomial p of type R and a natural number n, the coefficient of the (n + 1)th term of the polynomial resulting from multiplying the polynomial p by the polynomial variable X, is equal to the coefficient of the nth term of the original polynomial p. In other words, multiplying a polynomial by X effectively shifts the coefficients of the polynomial one degree higher.

For any semiring R and polynomial p of type R, the coefficient of the (n+1)th term in the product of p and X is equal to the coefficient of the nth term in p.


theorem Filter.HasBasis.exists_inter_eq_singleton_of_mem_discrete :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Type u_3} {p : ι → Prop} {t : ι → Set X} {s : Set X}
      [inst_1 : DiscreteTopology ↑s] {x : X}, Filter.HasBasis (nhds x) p t → x ∈ s → ∃ i, p i ∧ t i ∩ s = {x} :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure, another type `ι`, a property `p` defined on `ι`, and a function `t` from `ι` to sets of `X`, given a set `s` of `X` with a discrete topology, and an element `x` of `X`, if the neighborhood filter at `x` has a basis indexed by `ι` with properties `p` and corresponding sets `t`, and `x` is an element of `s`, then there exists an index `i` such that the property `p` holds for `i`, and the intersection of the set `t(i)` and `s` is the singleton set containing `x`.

In simpler terms, if you have a point `x` in a discrete set `s` in a topological space, and you know the basis of the neighborhoods around `x`, then you can find a basis element such that it intersects `s` exactly at `x`.

For any discrete set $s \subseteq X$ in a topological space, and any point $x \in s$ with a neighborhood basis indexed by $\iota$ satisfying property $p$ and having sets $t(\iota)$, there exists an index $\iota_0$ such that $x \in t(\iota_0) \cap s$ is a singleton.


theorem ENNReal.mul_lt_of_lt_div : ∀ {a b c : ENNReal}, a < b / c → a * c < b := by sorry

This theorem states that for all extended nonnegative real numbers `a`, `b`, and `c`, if `a` is less than the quotient of `b` divided by `c`, then the product of `a` and `c` is less than `b`. In mathematical terms, if $a < \frac{b}{c}$, then $ac < b$. This theorem is applicable in the context of extended nonnegative real numbers, commonly used as the codomain of a measure.

For all extended nonnegative real numbers $a$, $b$, and $c$, if $a < \frac{b}{c}$, then $ac < b$.


theorem Set.neg_preimage : ∀ {α : Type u_2} [inst : Neg α] {s : Set α}, Neg.neg ⁻¹' s = -s := by sorry

The theorem `Set.neg_preimage` states that for any type `α` which has a negation operation defined, and any set `s` of elements of type `α`, the preimage of the set `s` under the negation operation is equal to the negative of the set `s`. In simpler terms, for any element of the type `α`, the negation of that element belongs to the set `s` if and only if the original element belongs to the negative of the set `s`. This theorem bridges the world of set operations and negation operations in the type `α`.

For any set `s` of type `α` with negation operation defined, `Set.neg (s.image neg) = s.complement`.


theorem List.permutationsAux_cons :
    ∀ {α : Type u_1} (t : α) (ts is : List α),
      List.permutationsAux (t :: ts) is =
        List.foldr (fun y r => (List.permutationsAux2 t ts r y id).2) (List.permutationsAux ts (t :: is))
          (List.permutations is) :=
  by sorry

The theorem `List.permutationsAux_cons` states that for any type `α` and any lists `t`, `ts`, and `is` of type `α`, the permutations of the list obtained by prepending `t` to `ts` and not fixing `ts` is equal to the result of applying a fold operation on the permutations of `is`. The fold operation, from right to left, constructs new permutations by inserting `t` into each position of each permutation, and concatenates the resulting list of permutations to the permutations of `ts` that do not fix `t :: ts`. In other words, it describes how to generate all the permutations of a list by picking an element `t` and inserting it into every possible position in all permutations of the remaining elements.

The theorem `List.permutationsAux_cons` states that the permutations of a list obtained by prepending `t` to another list `ts` is equal to the fold (from right to left) of the permutations of the suffix of `ts` and the list of permutations obtained by inserting `t` into each position of each permutation of the suffix of `ts`.


theorem Int.div_one : ∀ (a : ℤ), Int.div a 1 = a := by sorry

This theorem states that for any integer `a`, the result of integer division of `a` by `1` is `a` itself. In mathematical terms, it asserts that for all integers `a`, `a ÷ 1 = a`. This is because any number divided by one stays the same.

For all integers `a`, `a` divided by `1` equals `a`. (Or, more concisely: `∀ a: ℤ, a / 1 = a`)


theorem CategoryTheory.Functor.preservesZeroMorphisms_of_map_zero_object :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
      [inst_3 : CategoryTheory.Limits.HasZeroObject D] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D] {F : CategoryTheory.Functor C D},
      (F.obj 0 ≅ 0) → CategoryTheory.Functor.PreservesZeroMorphisms F :=
  by sorry

This theorem states that for any two categories `C` and `D` such that they both have zero objects and zero morphisms, if we have a functor `F` from `C` to `D` that maps the zero object in `C` to the zero object in `D` (denoted as `F.obj 0 ≅ 0`), then this functor `F` preserves zero morphisms. In other words, applying the functor `F` to a zero morphism in `C` results in a zero morphism in `D`.

Given any functors F from category C to D with zero objects and zero morphisms, if F maps the zero object of C to the zero object of D and preserves the identity morphism of the zero object, then F preserves zero morphisms.


theorem Polynomial.irreducible_X : ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R], Irreducible Polynomial.X :=
  by sorry

This theorem states that for any type `R` which is a commutative ring and also a domain, the polynomial variable `X` is irreducible. In mathematical terms, in any integral domain `R`, the polynomial `X` (which represents a variable or indeterminate) cannot be factored into two non-unit polynomials, which is the definition of an irreducible polynomial.

In a commutative domain `R`, the polynomial `X` is irreducible.


theorem PiLp.antilipschitzWith_equiv_aux :
    ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)]
      [inst_1 : (i : ι) → PseudoEMetricSpace (β i)] [inst_2 : Fintype ι],
      AntilipschitzWith (↑(Fintype.card ι) ^ (1 / p).toReal) ⇑(WithLp.equiv p ((i : ι) → β i)) :=
  by sorry

This theorem states that for any extended nonnegative real number `p`, index type `ι`, and a function `β` mapping each `ι` to a type that has the structure of a pseudo-emetric space, given that the fact `1 ≤ p` holds and `ι` is finite, the function `WithLp.equiv p ((i : ι) → β i)` is `AntilipschitzWith` the nonnegative real number `(Fintype.card ι) ^ (1 / p).toReal`.

In other words, for any two points `x` and `y` in the domain of `WithLp.equiv p ((i : ι) → β i)`, the extended metric distance between `x` and `y` is less than or equal to `(Fintype.card ι) ^ (1 / p).toReal` times the extended metric distance between `WithLp.equiv p ((i : ι) → β i) x` and `WithLp.equiv p ((i : ι) → β i) y`. Here, `Fintype.card ι` denotes the number of elements in the type `ι`.

For any finite index type `ι` and function `β:` `ι` → MetricSpace `A` with `p` being a positive real number, `WithLp.equiv p (β)` is an Antilipschitz function with constant `(Fintype.card ι) ^ (1/p)`.


theorem Ordinal.lt_sub : ∀ {a b c : Ordinal.{u_4}}, a < b - c ↔ c + a < b := by sorry

The theorem `Ordinal.lt_sub` states that for any three ordinals `a`, `b`, and `c`, the inequality `a` is less than `b - c` holds if and only if `c + a` is less than `b`. In simple terms, it establishes an equivalence between two forms of inequality involving ordinal numbers.

For any ordinals `a`, `b`, and `c`, `a` < `b` if and only if `c + a` < `b`.


theorem Filter.HasBasis.cauchySeq_iff' :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Sort u_1} [inst : Nonempty β]
      [inst : SemilatticeSup β] {u : β → α} {p : γ → Prop} {s : γ → Set (α × α)},
      Filter.HasBasis (uniformity α) p s → (CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i) :=
  by sorry

The theorem `Filter.HasBasis.cauchySeq_iff'` states that for any types `α` and `β`, where `α` is equipped with a uniform space structure, and `β` is a nonempty, semilattice sup (a partially ordered set with a least upper bound for any two elements), and for any function `u` from `β` to `α`, and for any properties `p` indexed by some type `γ` and any sets `s` of `α` pairs indexed by `γ`, if the uniformity of `α` has a filter basis consisting of the sets `s i` for which `p i` holds, then the function `u` is a Cauchy sequence if and only if for every `i` in `γ` such that `p i` holds, there exists some `N` in `β` such that for all `n` in `β` greater than or equal to `N`, the pair `(u n, u N)` belongs to the set `s i`. In simpler terms, this theorem provides a condition for a sequence to be Cauchy in terms of a basis for the uniformity.

A sequence in a uniform space with respect to a filter basis consisting of sets indexed by a semilattice sup-type, where each set contains pairs of sequence elements satisfying a given property, is a Cauchy sequence if and only if for each index in the property domain, there exists a supremum element such that the sequence converges to that element within the set.


theorem Real.cosh_neg : ∀ (x : ℝ), Real.cosh (-x) = Real.cosh x := by sorry

This theorem states that the real hyperbolic cosine function has the property of evenness. In other words, for any real number `x`, the value of the hyperbolic cosine function at `-x` is the same as its value at `x`. This mirrors the mathematical statement that $\cosh(-x) = \cosh(x)$ for all real numbers `x`.

The hyperbolic cosine function is an even function, i.e., $\cosh(-x) = \cosh(x)$ for all real numbers $x$.


theorem midpoint_vsub_left :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (p₁ p₂ : P), midpoint R p₁ p₂ -ᵥ p₁ = ⅟2 • (p₂ -ᵥ p₁) :=
  by sorry

The theorem `midpoint_vsub_left` is a statement about midpoints in a vector space over a ring. Given any two points `p₁` and `p₂` in an affine space with associated vector space `V` over a ring `R` where `2` is invertible, the vector obtained by subtracting `p₁` from the midpoint of `p₁` and `p₂` is equal to half of the vector obtained by subtracting `p₁` from `p₂`. In mathematical terms, this is saying that the vector from `p₁` to the midpoint of `p₁` and `p₂` is half of the vector from `p₁` to `p₂`, i.e., if `M` is the midpoint of `[p₁, p₂]`, then `→p₁M = ½•→p₁p₂`.

Given any two points in an affine space over a ring where 2 is invertible, the vector from the first point to the midpoint of the two points is equal to half the vector from the first point to the second point.


theorem Mathlib.Combinatorics.SimpleGraph.Density._auxLemma.1 :
    ∀ {α : Type u_4} {β : Type u_5} {r : α → β → Prop} [inst : (a : α) → DecidablePred (r a)] {s : Finset α}
      {t : Finset β} {x : α × β}, (x ∈ Rel.interedges r s t) = (x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2) :=
  by sorry

The theorem, named `_auxLemma.1` in the `Mathlib.Combinatorics.SimpleGraph.Density` namespace, states that for any types `α` and `β`, any relation `r` between elements of `α` and `β`, and any finsets `s` of α and `t` of β, a pair `x` of type `α × β` is in the finset `Rel.interedges r s t` if and only if the first element of `x` is in `s`, the second element of `x` is in `t`, and the relation `r` holds between the two elements of `x`. This is under the condition that `r` is a decidable predicate.

For any decidable relation `r` between types `α` and `β`, and finsets `s` of `α` and `t` of `β`, an element `(x, y)` of `α × β` is in the intersection of the relation's edges and the cartesian product of `s` and `t` if and only if the first component `x` is in `s`, the second component `y` is in `t`, and `r` holds between `x` and `y`.


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

This theorem states that for any two Hahn series `x` and `y`, with Γ being any type that is partially ordered and R being any type with a zero element, `x` is equal to `y` if and only if the coefficient functions of `x` and `y` are equal. In other words, two Hahn series are considered equal if they have the same coefficients for all indices.

For any Hahn series x and y over the same index type and coefficient type, x = y if and only if the coefficient functions of x and y are equal.


theorem Monoid.PushoutI.NormalWord.prod_smul :
    ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
      {φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
      [inst_3 : (i : ι) → DecidableEq (G i)] (g : Monoid.PushoutI φ) (w : Monoid.PushoutI.NormalWord d),
      Monoid.PushoutI.NormalWord.prod (g • w) = g * Monoid.PushoutI.NormalWord.prod w :=
  by sorry

The theorem `Monoid.PushoutI.NormalWord.prod_smul` states that for any indexed collection of groups `G`, and a group `H`, given group homomorphisms `φ` from `H` to each of the groups in `G` and a transversal `d` of the normal word in the indexed pushout of the monoids, along with an element `g` of the pushout and a normal word `w`, the operation of taking the product of the normal word (function `Monoid.PushoutI.NormalWord.prod`) commutes with the scalar multiplication (`g • w`). In other words, scaling the normal word by `g` and then taking the product gives the same result as first taking the product and then scaling by `g`. This is expressed mathematically as: `Monoid.PushoutI.NormalWord.prod (g • w) = g * Monoid.PushoutI.NormalWord.prod w`.

For any indexed collection of groups `G`, group `H`, group homomorphisms `φ` from `H` to each `G`, transversal `d` of the normal word in the indexed pushout of the monoids, and elements `g` in the pushout and `w` in the normal subgroup, we have `g * Monoid.PushoutI.NormalWord.prod w = Monoid.PushoutI.NormalWord.prod (g • w)`.


theorem unitInterval.two_mul_sub_one_mem_iff : ∀ {t : ℝ}, 2 * t - 1 ∈ unitInterval ↔ t ∈ Set.Icc (1 / 2) 1 := by sorry

The theorem `unitInterval.two_mul_sub_one_mem_iff` states that for any real number `t`, `2 * t - 1` lies in the unit interval (which is the set of real numbers between 0 and 1 inclusive) if and only if `t` itself lies in the closed interval from `1/2` to `1` (inclusive). This provides a useful characterization of when a transformation of a real number falls within the unit interval in terms of limits on the original number.

For any real number `t`, `2 * t - 1` is in the unit interval if and only if `t` is between 1/2 and 1.


theorem Finset.coe_sub :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Sub α] (s t : Finset α), ↑(s - t) = ↑s - ↑t := by sorry

The theorem `Finset.coe_sub` states that for any type `α` with decidable equality and a subtraction operation, and for any two finsets `s` and `t` over `α`, the operation of subtracting `t` from `s` (denoted as `s - t`) in the context of finsets and then converting the result to a set (using the operation `↑`) is the same as first converting `s` and `t` to sets and then performing the set subtraction operation. In other words, the order of subtraction and conversion to set does not matter.

For any type `α` with decidable equality and subtraction operation, the conversion of `(s - t)` to a set in the context of finsets is equal to the set difference between the sets `(↑s)` and `(↑t)`, for any finsets `s` and `t` over `α`.


/-- If `Fₙ` converges locally uniformly on a neighborhood of `x` within a set `s` to a function `f`
which is continuous at `x` within `s`, and `gₙ` tends to `x` within `s`, then `Fₙ (gₙ)` tends
to `f x`.  -/
theorem tendsto_comp_of_locally_uniform_limit_within :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α} {x : α}
      {p : Filter ι} {g : ι → α} [inst_1 : TopologicalSpace α],
      ContinuousWithinAt f s x →
        Filter.Tendsto g p (nhdsWithin x s) →
          (∀ u ∈ uniformity β, ∃ t ∈ nhdsWithin x s, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u) →
            Filter.Tendsto (fun n => F n (g n)) p (nhds (f x)) :=
  by sorry

This theorem states that if a sequence of functions `Fₙ` converges locally uniformly on a neighborhood of a point `x` within a set `s` to a function `f` which is continuous at `x` within `s`, and each `gₙ` in a sequence `g` tends to `x` within `s`, then the value of the sequence of functions `Fₙ` evaluated at `gₙ` tends to the value of `f` at `x`. Here, the convergence of `Fₙ` is measured with respect to the uniformity of the target space `β`, and the sequence `g` is indexed by some type `ι` in a filter `p`.

If a sequence of continuous functions `Fₙ : β → X` on a set `X` converges uniformly on a neighborhood of `x` in a set `s` to a continuous function `f : β → X`, and a sequence `gₙ` in `s` converges to `x` in `s`, then `Fₙ(gₙ)` converges to `f(x)`.


theorem Matrix.conjTranspose_nonsing_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
      [inst_3 : StarRing α], Matrix.conjTranspose A⁻¹ = (Matrix.conjTranspose A)⁻¹ :=
  by sorry

This theorem states that for any type `n` that has a finite number of elements and decidable equality, and any `α` that forms a commutative ring with a star operation, the conjugate transpose of the inverse of a square matrix `A` with elements from `α` and indices from `n` is equal to the inverse of the conjugate transpose of `A`. In simpler terms, it says that the conjugate transpose operation commutes with inversion for any square matrix in a star commutative ring.

For any square matrix `A` with coefficients in a commutative ring `α` with a star operation and finite index set `n` of decidable equality, the conjugate transpose of `A`'s inverse is equal to the inverse of `A`'s conjugate transpose.


theorem Polynomial.degree_add_le_of_degree_le :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R} {n : ℕ},
      Polynomial.degree p ≤ ↑n → Polynomial.degree q ≤ ↑n → Polynomial.degree (p + q) ≤ ↑n :=
  by sorry

The theorem `Polynomial.degree_add_le_of_degree_le` states that for any semiring `R`, and any polynomials `p` and `q` over `R`, and any natural number `n`, if the degree of `p` is less than or equal to `n`, and the degree of `q` is also less than or equal to `n`, then the degree of the polynomial resulting from adding `p` and `q` is also less than or equal to `n`.

In other words, the theorem confirms that the degree of the sum of two polynomials will not exceed the maximum degree of the two original polynomials, given that their degrees are both bounded by a certain natural number.

For any semiring R and polynomials p and q over R of degrees less than or equal to natural number n, the degree of p + q is less than or equal to n.


/-- If both `a` and `b` commute with `c`, then their product commutes with `c`.  -/
theorem Commute.mul_left :
    ∀ {S : Type u_2} [inst : Semigroup S] {a b c : S}, Commute a c → Commute b c → Commute (a * b) c := by sorry

The theorem `Commute.mul_left` states that in the context of a semigroup, if two elements (`a` and `b`) each commute with a third element (`c`), meaning that the order of multiplication does not change the result (`a * c = c * a` and `b * c = c * b`), then the product of the two elements (`a * b`) also commutes with the third element (`c`). In other words, `(a * b) * c = c * (a * b)`. This theorem holds for any type `S` that is an instance of a semigroup.

In a semigroup, if elements `a`, `b`, and `c` mutually commute (i.e., `a * c = c * a` and `b * c = c * b`), then their product `a * b` also commutes with `c` (i.e., `(a * b) * c = c * (a * b)`).


theorem AddSubgroup.mem_leftTransversals_iff_bijective :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {S : Set G},
      S ∈ AddSubgroup.leftTransversals ↑H ↔ Function.Bijective (Set.restrict S Quotient.mk'') :=
  by sorry

This theorem, `AddSubgroup.mem_leftTransversals_iff_bijective`, states that for any type `G` with an additive group structure, any additive subgroup `H` of `G`, and any set `S` of `G`, the set `S` is a left transversal of the subgroup `H` if and only if the restriction of the quotient map to `S` is a bijective function. In other words, 'S' is a left transversal of the subgroup 'H' if every element of the quotient group 'G/H' can be uniquely represented by an element of 'S'.

For an additive group (G, +) and its subgroup H, a set S of G is a left transversal of H if and only if the restriction of the quotient map G -> G/H to S is a bijective function.


theorem Associates.mk_one : ∀ {α : Type u_1} [inst : Monoid α], Associates.mk 1 = 1 := by sorry

This theorem, `Associates.mk_one`, states that for any type `α` that forms a monoid, the canonical quotient map when applied to the identity element `1` in the monoid, results in the identity element `1` in the monoid of associates. In other words, it asserts that the image of the monoid identity under the canonical homomorphism to the associates is also the identity.

For any monoid `α`, the image of its identity element `1` under the canonical homomorphism to the monoid of associates is the identity element `1` in the monoid of associates.


theorem circleMap_mem_sphere : ∀ (c : ℂ) {R : ℝ}, 0 ≤ R → ∀ (θ : ℝ), circleMap c R θ ∈ Metric.sphere c R := by sorry

The theorem `circleMap_mem_sphere` states that for any complex number `c`, any real number `R` that is greater than or equal to zero, and any real number `θ`, the result of the `circleMap` with parameters `c`, `R`, and `θ` is an element of the sphere with center `c` and radius `R`. In other words, the complex number generated by the exponential map (where `c` is the center and `R` is the radius of the circle) is always on the sphere centered at `c` with radius equal to `R` in the complex plane.

For any complex number `c`, real number `R` ≥ 0, and real angle `θ`, the output of the `circleMap` function with parameters `c`, `R`, and `θ` is an element of the complex sphere with center `c` and radius `R`.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.20 :
    ∀ {α : Type u} {a : α} {l : List α}, List.Nodup (a :: l) = (a ∉ l ∧ List.Nodup l) := by sorry

This theorem states that for any type `α`, an element `a` of that type, and a list `l` of elements of the same type, the assertion that the list `l` prefixed with `a` (i.e., `a :: l`) has no duplicate elements (formally, `List.Nodup (a :: l)`) is equivalent to the conjunction of the statements that `a` does not belong to `l` (formally, `a ∉ l`) and that `l` itself has no duplicate elements (formally, `List.Nodup l`).

For any type `α` and list `l` of elements of type `α`, the list `a :: l` has no duplicate elements if and only if `a` is not in `l` and `l` itself has no duplicate elements.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.36 :
    ∀ {V : Type u} {G : SimpleGraph V} {u : V} (p : SimpleGraph.Walk G u u),
      SimpleGraph.Walk.IsPath p = (p = SimpleGraph.Walk.nil) :=
  by sorry

This theorem, from the `Mathlib.Combinatorics.SimpleGraph.Connectivity` namespace in Lean 4, states that for any type `V`, any simple graph `G` of type `V`, and any vertex `u` of type `V`, a walk `p` in graph `G` starting and ending at vertex `u` is a path if and only if `p` is equivalent to the empty walk, `SimpleGraph.Walk.nil`. In other words, the only walk in a simple graph that can be considered a path and starts and ends at the same vertex is the one that does not contain any edges, the empty walk.

In a simple graph, a walk starting and ending at the same vertex is a path if and only if it is the empty walk.


/-- `G` is cover-lifting wrt the induced topology.  -/
theorem CategoryTheory.LocallyCoverDense.inducedTopology_isCocontinuous :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D}
      {K : CategoryTheory.GrothendieckTopology D} [inst_2 : CategoryTheory.Full G] [inst_3 : CategoryTheory.Faithful G]
      (Hld : CategoryTheory.LocallyCoverDense K G),
      CategoryTheory.Functor.IsCocontinuous G (CategoryTheory.LocallyCoverDense.inducedTopology Hld) K :=
  by sorry

This theorem states that, given a category `C` with objects of type `u_1` and morphisms of type `u_3`, and another category `D` with objects of type `u_2` and morphisms of type `u_4`, if we have a functor `G` from `C` to `D` which is both full (meaning every morphism in `D` is the image of some morphism in `C` under `G`) and faithful (meaning distinct morphisms in `C` remain distinct in `D`), and we have a Grothendieck topology `K` on `D`, and if `G` is locally cover-dense with respect to `K` (meaning roughly that 'small' covers in `D` can be lifted to 'small' covers in `C`), then `G` is cocontinuous with respect to the induced topology from `K` on `C` and `K` itself. In simpler terms, this theorem is about preserving the structure of 'smallness' when mapping from one category to another.

Given a full, faithful functor between categories with a locally cover-dense morphism and a Grothendieck topology on the target category, the functor is cocontinuous and preserves the given topology.


theorem EReal.preimage_coe_Iio_top : Real.toEReal ⁻¹' Set.Iio ⊤ = Set.univ := by sorry

This theorem states that the preimage of the left-infinite right-open interval (`Set.Iio`) that ends at positive infinity (`⊤`), under the function that maps real numbers (`ℝ`) to extended real numbers (`EReal`), is the universal set (`Set.univ`). In other words, if we map all real numbers to extended real numbers and consider those which are less than positive infinity, we end up with all real numbers. This highlights that all real numbers are also a part of the extended real number system which includes positive and negative infinity.

The preimage of `Set.Iio ⊤` under the function from `ℝ` to `EReal` equals `Set.univ`.


/-- The cardinality of the interval (a, ∞).  -/
theorem Cardinal.mk_Ioi_real : ∀ (a : ℝ), Cardinal.mk ↑(Set.Ioi a) = Cardinal.continuum := by sorry

This theorem states that for any real number 'a', the cardinality (or the size of the set in terms of the number of its elements) of the interval (a, ∞) is equal to the cardinality of the continuum. The interval (a, ∞) is defined as a set of all real numbers that are greater than 'a'. The cardinality of the continuum is defined as the size of the set of all real numbers, or equivalently, the power set of the set of natural numbers (i.e., 2 to the power of the size of the set of natural numbers, denoted as $2^{\aleph_0}$ in set theory).

The cardinality of the set of real numbers in the interval (a, ∞) equals the cardinality of the continuum.


theorem Mathlib.RingTheory.Subsemiring.Basic._auxLemma.10 :
    ∀ {R : Type u} [inst : NonAssocSemiring R] (x : R), (x ∈ ⊤) = True := by sorry

This theorem states that for any type `R` that forms a non-associative semiring, any element `x` of `R` belongs to the top element `⊤` (which represents the whole semiring). This is always true, regardless of the specific element `x` or the specifics of `R`. Essentially, in mathematical terms, it's saying that for any `x` in a given non-associative semiring, `x` is indeed an element of the entire semiring.

For any non-associative semiring R, every element x in R belongs to the semiring's top element ⊤.


theorem Real.arctan_lt_pi_div_two : ∀ (x : ℝ), Real.arctan x < Real.pi / 2 := by sorry

This theorem states that for any real number `x`, the arctan of `x` is less than π/2. The arctan function is the inverse of the tangent function and returns values in the range `-π/2 < arctan x < π/2`. The constant π, approximately 3.14159265, is defined as twice a zero of the cosine function in the interval [1,2].

For all real numbers x, the value of arctan x is less than π/2.


theorem ContDiffWithinAt.of_le :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {m n : ℕ∞}, ContDiffWithinAt 𝕜 n f s x → m ≤ n → ContDiffWithinAt 𝕜 m f s x :=
  by sorry

This theorem, named `ContDiffWithinAt.of_le`, states that for any types `𝕜` (which is a non-trivially normed field), `E` and `F` (both of which are normed additive commutative groups and normed spaces over `𝕜`), a set `s` of type `E`, a function `f` from `E` to `F`, an element `x` of `E`, and two natural-number-or-infinity values `m` and `n`, if the function `f` has `n`-th order continuous differentiability at the point `x` within the set `s`, and if `m` is less than or equal to `n`, then the function `f` also has `m`-th order continuous differentiability at the point `x` within the set `s`. In simpler terms, it means that continuous differentiability of a certain order implies the continuous differentiability of any lesser order.

If a function has `n`-th order continuous differentiability at a point in a set, then it also has `m`-th order continuous differentiability at that point for any `m` less than or equal to `n`.


theorem Set.le_mulIndicator_apply :
    ∀ {α : Type u_2} {M : Type u_4} [inst : LE M] [inst_1 : One M] {s : Set α} {g : α → M} {a : α} {y : M},
      (a ∈ s → y ≤ g a) → (a ∉ s → y ≤ 1) → y ≤ Set.mulIndicator s g a :=
  by sorry

The theorem `Set.le_mulIndicator_apply` states that for any types `α` and `M`, where `M` has a less than or equal to relation (`LE M`) and a multiplicative identity (`One M`), given a set `s` of type `α`, a function `g` from `α` to `M`, elements `a` of type `α`, and `y` of type `M`, if `y` is less than or equal to `g a` whenever `a` is in `s`, and `y` is less than or equal to `1` whenever `a` is not in `s`, then `y` is less than or equal to the value returned by the `Set.mulIndicator` function when applied to `s`, `g`, and `a`. In other words, this theorem describes a property of the multiplicative indicator function over sets in terms of the less than or equal to relation.

For any set `s` and function `g` from a type `α` to a type `M` with a less than or equal to relation and multiplicative identity, if `y` satisfies `y ≤ g(a)` for all `a` in `s` and `y ≤ 1` for all `a` not in `s`, then `y ≤ Set.mulIndicator s g a`.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.58 :
    ∀ {V : Type u} {G : SimpleGraph V} {v w : V},
      (SimpleGraph.connectedComponentMk G v = SimpleGraph.connectedComponentMk G w) = SimpleGraph.Reachable G v w :=
  by sorry

This theorem states that for any type `V` and for any `SimpleGraph G` of vertices of type `V`, and for any two vertices `v` and `w` of this graph, the connected components of `v` and `w` in `G` are the same if and only if `v` and `w` are reachable from each other in `G`. In mathematical terms, two vertices `v` and `w` are said to be reachable from each other in a graph if there exists a walk (a sequence of vertices and edges) from `v` to `w`. The connected component of a vertex in a graph is the subgraph consisting of the vertex and all vertices reachable from it. Therefore, the theorem essentially establishes a connection between the notion of reachable vertices and connected components in a graph.

Two vertices in a simple graph are in the same connected component if and only if they are reachable from each other.


AffineEquiv.surjective

theorem AffineEquiv.surjective :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂), Function.Surjective ⇑e :=
  by sorry

The theorem `AffineEquiv.surjective` states that for any ring `k`, any types `P₁` and `P₂` representing affine spaces, and types `V₁` and `V₂` representing vector spaces, along with the necessary structures on them (such as `P₁` being an affine torsor over `V₁`, and `P₂` being an affine torsor over `V₂`, with both `V₁` and `V₂` being `k`-modules), every affine equivalence `e` from `P₁` to `P₂` is a surjective function. In other words, for every point in `P₂`, there exists a point in `P₁` such that applying the affine equivalence `e` to this point results in the desired point in `P₂`.

Given affine spaces `P₁` and `P₂` over a ring `k`, represented as affine torsors over vector spaces `V₁` and `V₂` respectively, every affine equivalence `e` from `P₁` to `P₂` is a surjective function.


theorem linearIndependent_singleton :
    ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : NoZeroSMulDivisors R M] {x : M},
      x ≠ 0 → LinearIndependent R fun (x_1 : ↑{x}) => ↑x_1 :=
  by sorry

This theorem, `linearIndependent_singleton`, states that for any ring `R`, given a nontrivial element `x` from the additive commutative group `M` (which is also a module over `R`) such that `R` and `M` have no zero scalar multiplication-divisors, if `x` is not equal to zero, then the function mapping each element of the singleton set `{x}` to `x` itself results in a linearly independent set of vectors over `R`. In other words, a non-zero element in a module forms a linearly independent set.

If `R` is a ring with no zero divisors, and `M` is an additive commutative group over `R` with no zero scalar multiplication-divisors, then a non-zero element `x` in `M` forms a linearly independent set.


theorem ContinuousLinearMap.map_neg :
    ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {M : Type u_4} [inst_2 : TopologicalSpace M]
      [inst_3 : AddCommGroup M] {M₂ : Type u_5} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂]
      [inst_6 : Module R M] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} (f : M →SL[σ₁₂] M₂) (x : M), f (-x) = -f x :=
  by sorry

The theorem `ContinuousLinearMap.map_neg` states that for any ring `R`, another ring `R₂`, a topological space `M` over `R` that is also an additive commutative group, another topological space `M₂` over `R₂` that is also an additive commutative group, and a continuous linear map `f` from `M` to `M₂`, the image of the negative of a point `x` in `M` under `f` is equal to the negative of the image of `x` under `f`. This effectively shows that continuous linear maps preserve the negation operation.

For any continuous linear map `f` between additive commutative groups and topological spaces `M` over ring `R` and `M₂` over ring `R₂`, respectively, we have `f(-x) = -(f(x))` for all `x` in `M`.


theorem Mathlib.MeasureTheory.OuterMeasure.Basic._auxLemma.8 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i :=
  by sorry

This theorem states that for any type `α` which forms a complete lattice, for any index set `ι` and for any function `f` mapping `ι` to `α`, and for any element `a` of `α`, `a` is less than or equal to the indexed infimum (`iInf`) of `f` if and only if `a` is less than or equal to `f(i)` for every `i` in `ι`. In mathematical terms, we could write this as $a \leq \inf_i f(i)$ if and only if $a \leq f(i)$ for all indices $i$. This is essentially unpacking the definition of the infimum in terms of the original function `f`.

For any complete lattice `α`, index set `ι`, and function `f` from `ι` to `α`, an element `a` in `α` is less than or equal to the indexed infimum `iInf(f)` if and only if it is less than or equal to `f(i)` for all `i` in `ι`. In other words, `a ≤ iInf(f)` if and only if `a ≤ f(i)` for all `i` in `ι`.


theorem Set.mem_of_mem_inter_right : ∀ {α : Type u} {x : α} {a b : Set α}, x ∈ a ∩ b → x ∈ b := by sorry

The theorem `Set.mem_of_mem_inter_right` states that for any type `α`, any element `x` of type `α`, and any two sets `a` and `b` of type `α`, if `x` belongs to the intersection of `a` and `b`, then `x` belongs to `b`. In other words, given any object and two sets, if the object is a member of both sets (i.e., in the intersection of the sets), then it is a member of the second set.

For any type `α` and sets `a` and `b` of type `α`, if `x` is an element of `a` and `a ∩ b`, then `x` belongs to `b`.


theorem CategoryTheory.Equivalence.counit_app_functor :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C),
      e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X) :=
  by sorry

This theorem states that for any category theory equivalence `e` between two categories `C` and `D`, and for any object `X` in category `C`, the application of the counit of `e` to the object obtained by applying the functor of `e` to `X` equals the map of the functor of `e` applied to the application of the inverse of the unit of `e` to `X`. In simpler terms, it shows a specific property of the interplay between the functor and the unit/counit of a category equivalence in category theory.

For any category theory equivalence `e` between categories `C` and `D`, the counit of `e` applied to `e(X)` equals the functor of `e` applied to the inverse of the unit of `e` applied to `X`.


theorem Submodule.Quotient.mk_add :
    ∀ {R : Type u_1} {M : Type u_2} {x y : M} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (p : Submodule R M), Submodule.Quotient.mk (x + y) = Submodule.Quotient.mk x + Submodule.Quotient.mk y :=
  by sorry

The theorem `Submodule.Quotient.mk_add` states that for any type `R` which forms a ring, a type `M` that forms an additive commutative group, a module `M` over `R`, and a submodule `p` of `M`, the mapping that associates to an element of `M` the corresponding element of `M/p` preserves the operation of addition. In other words, if `x` and `y` are elements of `M`, then the image of the sum `x + y` under this map is equal to the sum of the images of `x` and `y`. This can be expressed mathematically as: for all `x, y` in `M`, `Submodule.Quotient.mk (x + y) = Submodule.Quotient.mk x + Submodule.Quotient.mk y`.

For any ring `R`, additive commutative group `M`, module `M` over `R`, and submodule `p` of `M`, the quotient map from `M` to `M/p` preserves addition, i.e., `Submodule.Quotient.mk (x + y) = Submodule.Quotient.mk x + Submodule.Quotient.mk y` for all `x, y` in `M`.


theorem IsAdjoinRoot.mem_ker_map :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f) {p : Polynomial R}, p ∈ RingHom.ker h.map ↔ f ∣ p :=
  by sorry

This theorem states that for any commutative ring `R`, ring `S`, polynomial `f` over `R`, and an instance of `Algebra R S` that turns `S` into an `R`-algebra, if `h` is an instance of `IsAdjoinRoot` that adjoins a root of `f` to `S`, then for any polynomial `p` over `R`, `p` is in the kernel of the ring homomorphism `h.map` if and only if `f` divides `p`. In other words, the kernel of the ring homomorphism `h.map` consists exactly of those polynomials which are divisible by `f`.

For any commutative rings `R` and `S`, an `R`-algebra homomorphism `h : S -> R` adjoining a root of a polynomial `f` over `R`, if and only if `p` is in the kernel of `h` for any polynomial `p` over `R`, then `f` divides `p`.


theorem essSup_eq_sInf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {m : MeasurableSpace α}
      (μ : MeasureTheory.Measure α) (f : α → β), essSup f μ = sInf {a | ↑↑μ {x | a < f x} = 0} :=
  by sorry

This theorem states that for any measure space `α`, and any function `f` from `α` to a conditionally complete linear order `β`, the essential supremum of `f` with respect to a measure `μ` is equal to the infimum of the set of those `a` in `β` for which the measure of the set of points `x` in `α` where `a` is less than `f(x)` is zero. Essentially, it's saying that the least upper bound of `f` almost everywhere is the greatest lower bound of the set of values that `f` exceeds almost nowhere.

For any measure space `α`, measurable function `f` from `α` to a conditionally complete linear order `β`, and `a` in `β`, the essential supremum of `f` with respect to the measure `μ` equals `a` if and only if the measure of the set of points `x` in `α` where `f(x) < a` is zero.


theorem AddUnits.neg_add_eq_iff_eq_add :
    ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) {b c : α}, ↑(-a) + b = c ↔ b = ↑a + c := by sorry

This theorem states that for any given type `α` with an additive monoid structure, and given an additive unit `a` and two elements `b` and `c` of the type `α`, the negative of `a` added to `b` equals `c` if and only if `b` equals the additive unit `a` added to `c`. In mathematical terms, it's saying that if `-a + b = c`, then `b = a + c`, and vice versa, within the context of an additive monoid.

For any additive monoid type `α` with additive unit `a`, the elements `b` and `c` satisfy `-a + b = c` if and only if `b = a + c`.


theorem addRothNumber_le :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] (s : Finset α), addRothNumber s ≤ s.card := by sorry

The theorem `addRothNumber_le` states that for any given finite set `s` of elements of an additive monoid `α` (with decidable equality), the additive Roth number of `s` is always less than or equal to the cardinality of `s`. The additive Roth number of a finite set is defined as the size of its largest additive Salem-Spencer subset. An additive Salem-Spencer subset is a set where no three elements have the property that two of them add to the third.

The additive Roth number of a finite set in an additive monoid with decidable equality is bounded above by the set's cardinality.


theorem Nat.leRecOn_succ' :
    ∀ {C : ℕ → Sort u_1} {n : ℕ} {h : n ≤ n + 1} {next : {k : ℕ} → C k → C (k + 1)} (x : C n),
      Nat.leRecOn h (fun {k} => next) x = next x :=
  by sorry

This theorem, `Nat.leRecOn_succ'`, asserts that for any natural number `n` and any function `next` that takes a natural number `k` and a value of some type `C k` (dependent on `k`) to provide a value of type `C (k + 1)`, if we apply `Nat.leRecOn` for the proof that `n` is less than or equal to `n + 1` using `next` as the function and `x` as the initial value, we get the same output as if we had directly applied `next` to `x`. In other words, it states that the recursive operation on natural numbers respects the successor operation in the provided function `next`.

For any natural number `n` and function `next : Nat → C → C`, if `Nat.leRecOn n next x` is defined, then `next x = next (S n)`.


theorem Ordinal.lt_mul_succ_div : ∀ (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}, b ≠ 0 → a < b * Order.succ (a / b) := by
  sorry

This theorem states that for any ordinal 'a' and any non-zero ordinal 'b', 'a' is less than the product of 'b' and the successor of the quotient of 'a' by 'b'. In mathematical terms, for all a, b ∈ Ordinal, with b ≠ 0, we have a < b * succ(a / b). Here, 'succ' denotes the successor function, which gives the next ordinal after the input ordinal.

For any ordinal a and non-zero ordinal b, a is strictly below the product of b and the successor of the quotient of a by b. (a < b * (succ (a / b)))


theorem Subalgebra.range_val :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A), AlgHom.range (Subalgebra.val S) = S :=
  by sorry

The theorem `Subalgebra.range_val` states that for any subalgebra `S` of an algebra `A` over a commutative semiring `R`, the range of the algebra homomorphism that embeds the subalgebra `S` into the algebra `A` is the subalgebra `S` itself. In other words, if we consider all elements in `A` that can be obtained by applying this homomorphism to elements of `S`, we get exactly the set of elements in `S`.

The range of the algebra homomorphism embedding a subalgebra into an algebra over a commutative semiring is equal to the subalgebra itself.


HasFDerivAtFilter.star

theorem HasFDerivAtFilter.star :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] [inst_2 : TrivialStar 𝕜] {E : Type u_2}
      [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {F : Type u_3} [inst_5 : NormedAddCommGroup F]
      [inst_6 : StarAddMonoid F] [inst_7 : NormedSpace 𝕜 F] [inst_8 : StarModule 𝕜 F] [inst_9 : ContinuousStar F]
      {f : E → F} {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L →
        HasFDerivAtFilter (fun x => star (f x)) (ContinuousLinearMap.comp (↑(starL' 𝕜)) f') x L :=
  by sorry

This theorem states that if a function `f` from a normed additive commutative group `E` to a star add monoid `F`, both of which are normed spaces over a nontrivially normed field `𝕜` with star structure, has a derivative `f'` at a point `x` with respect to a filter `L`, then the function that maps `x` to the star of `f(x)` also has a derivative at `x` with respect to `L`. The derivative of the latter function is the composition of `f'` and the continuous linear map induced by the star operation on `𝕜`.

If `f: E → F` is a differentiable function from a normed additive commutative group `E` to a star add monoid `F` over a nontrivially normed field `𝕜` with star structure, then the function `x mapsto 𝓝(f(x))` (where `𝓝` denotes the star operation on `F`) is differentiable at `x` and its derivative is `𝓝(f'(x)) ∘ 🌍(x)`, where `🌍: 𝕜 → 𝓝(𝕜)` is the continuous linear map induced by the star operation on `𝕜`.


theorem Int.floor_one : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], ⌊1⌋ = 1 := by sorry

This theorem states that for any type `α` that is a linear ordered ring and a floor ring, the floor value of `1` is `1`. In mathematical terms, this theorem asserts that for any `α` in the categories of linear ordered rings and floor rings, applying the floor function to `1` will always yield `1`.

For any type `α` that is both a linear ordered ring and a floor ring, the floor function of `1` is equal to `1`.


theorem NormedAddGroupHom.Equalizer.map.proof_1 :
    ∀ {V₁ : Type u_2} {V₂ : Type u_4} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      {W₁ : Type u_3} {W₂ : Type u_1} [inst_2 : SeminormedAddCommGroup W₁] [inst_3 : SeminormedAddCommGroup W₂]
      {f₁ g₁ : NormedAddGroupHom V₁ W₁} {f₂ g₂ : NormedAddGroupHom V₂ W₂} (φ : NormedAddGroupHom V₁ V₂)
      (ψ : NormedAddGroupHom W₁ W₂),
      NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ →
        NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ →
          NormedAddGroupHom.comp f₂ (NormedAddGroupHom.comp φ (NormedAddGroupHom.Equalizer.ι f₁ g₁)) =
            NormedAddGroupHom.comp g₂ (NormedAddGroupHom.comp φ (NormedAddGroupHom.Equalizer.ι f₁ g₁)) :=
  by sorry

This theorem states that, for any two types `V₁` and `V₂` that form semi-normed commutative additive groups, and any two other such types `W₁` and `W₂`, given two normed additive group homomorphisms `f₁` and `g₁` from `V₁` to `W₁`, two normed additive group homomorphisms `f₂` and `g₂` from `V₂` to `W₂`, and two other normed additive group homomorphisms `φ` from `V₁` to `V₂` and `ψ` from `W₁` to `W₂`, if the composition of `ψ` and `f₁` equals the composition of `f₂` and `φ`, and the composition of `ψ` and `g₁` equals the composition of `g₂` and `φ`, then the composition of `f₂` and the composition of `φ` and the inclusion of the equalizer of `f₁` and `g₁` equals the composition of `g₂` and the composition of `φ` and the inclusion of the equalizer of `f₁` and `g₁`. This theorem can be seen as a property of the equalizer in the category of normed additive group homomorphisms.

Given normed additive group homomorphisms `f₁, g₁: V₁ → W₁`, `f₂, g₂: V₂ → W₂`, `φ: V₁ → V₂`, and `ψ: W₁ → W₂`, if `ψ ∘ f₁ = f₂ ∘ φ` and `ψ ∘ g₁ = g₂ ∘ φ`, then `f₂ ∘ φ ∘ i = g₂ ∘ φ ∘ i`, where `i` is the inclusion of the equalizer of `f₁` and `g₁`.


/-- The injection of `Y` in the optimal coupling between `X` and `Y` is an isometry.  -/
theorem GromovHausdorff.isometry_optimalGHInjr :
    ∀ (X : Type u) (Y : Type v) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
      [inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y],
      Isometry (GromovHausdorff.optimalGHInjr X Y) :=
  by sorry

The theorem `GromovHausdorff.isometry_optimalGHInjr` states that for any two types `X` and `Y` which are both metric spaces, compact spaces, and non-empty, the function `GromovHausdorff.optimalGHInjr X Y` is an isometry. In other words, this function, which represents the optimal Gromov-Hausdorff injection of `Y` into the coupling between `X` and `Y`, preserves the distance between any two points in `Y`, meaning the distance between any two points before the transformation is the same as the distance between these points after the transformation.

The optimal Gromov-Hausdorff injection of a compact, non-empty metric space into another is an isometry.


theorem BoxIntegral.hasIntegral_const :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} (c : E),
      BoxIntegral.HasIntegral I l (fun x => c) vol ((vol I) c) :=
  by sorry

This theorem states that for any given type `ι`, and any given normed add commutative groups `E` and `F` over the real numbers with `E` and `F` also being a normed space over the real numbers. If `I` is a box integral (a multi-dimensional generalization of an interval), `l` is some integration parameters, `vol` is a box additive map (linear maps that preserve addition) between `ι` and the continuous linear mappings from `E` to `F`, and `c` is an element of `E`, then the integral of the constant function `c` over the box `I` with respect to `vol` is equal to `vol` applied to `I` and `c`. In other words, the integral of a constant function over a box integral is simply the volume of the box times the constant.

For any normed add commutative groups `E` and `F` over the real numbers, any type `ι`, any box integral `I` over `ι`, integration parameters `l`, a box additive map `vol` from `ι` to continuous linear mappings from `E` to `F`, and any `c` in `E`, the integral of the constant function `c` over `I` with respect to `vol` equals `vol(I)(c)`.


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

The theorem `Finset.sum_flip` states that for any type `β` that is an additive commutative monoid, and for any natural number `n` and function `f` from natural numbers to `β`, the sum of `f(n - r)` for each `r` in the set of natural numbers less than `n + 1` equals the sum of `f(k)` for each `k` in the set of natural numbers less than `n + 1`. In other words, summing the values of the function `f` applied to each number up to `n` is the same as summing the values of `f` applied to `n` minus each number up to `n`. This theorem essentially states that the order of summation does not matter in an additive commutative monoid.

For any additive commutative monoid type `β` and function `f` from natural numbers to `β`, the sum of `f(n - r)` for `r` in the set of natural numbers less than `n + 1` equals the sum of `f(k)` for `k` in the same set, i.e., the order of summation does not matter.


theorem isMaxFilter_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {a : α} {b : β}, IsMaxFilter (fun x => b) l a := by
  sorry

The theorem `isMaxFilter_const` states that for any types `α` and `β`, any preorder on `β`, any filter `l` on `α`, any element `a` of `α`, and any element `b` of `β`, the constant function that maps every element of `α` to `b` is a maximum filter at `a` with respect to `l`. This essentially means that `b` is greater than or equal to the value of this function at any other point in some neighborhood of `a` determined by the filter `l`.

For any filter $l$ on type $\alpha$, any element $a$ in $\alpha$, and any constant function $f : \alpha \rightarrow \beta$ with $f(a) = b$, $b$ is an upper bound of $l$ at $a$, i.e., for all $x \in \mathop{\mathrm{st}}{} l(a)$, $f(x) \geq b$.


Filter.ext'

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

This theorem states that for any two filters `f₁` and `f₂` of a given type `α`, if for any predicate `p` of type `α → Prop`, the property `p` holds eventually (denoted by `∀ᶠ`) in `f₁` if and only if it holds eventually in `f₂`, then `f₁` and `f₂` are equal. In simple terms, two filters are equal if every predicate that eventually holds true in one filter also eventually holds true in the other filter, and vice versa.

Two filters `f₁` and `f₂` over type `α` are equal if and only if they have the same eventualities for all predicates `p` of type `α → Prop`.


theorem dist_pi_const :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : Fintype β] [inst_2 : Nonempty β] (a b : α),
      (dist (fun x => a) fun x => b) = dist a b :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a pseudometric space and `β` is a finite, non-empty type, the distance between the constant functions that always return `a` and `b` (for any `a` and `b` in `α`) is the same as the distance between `a` and `b` themselves. In other words, in this specific context, the distance between two constant functions is simply the distance between their constant outputs.

For any pseudometric space `α` and finite, non-empty type `β`, the distance between constant functions `λ (x : α), a` and `λ (x : α), b` is equal to the distance `d` between `a` and `b` in `α`, i.e., `distance (λ (x : α), a) (λ (x : α), b) = d (a b)`.


theorem HomologicalComplex.isoHomologyπ_hom_inv_id_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι) (hi : ComplexShape.prev c j = i)
      (h : K.d i j = 0) [inst_2 : HomologicalComplex.HasHomology K j] {Z : C} (h_1 : HomologicalComplex.cycles K j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyπ K j)
          (CategoryTheory.CategoryStruct.comp (HomologicalComplex.isoHomologyπ K i j hi h).inv h_1) =
        h_1 :=
  by sorry

This theorem states that for any category `C` (with zero morphisms), a `ComplexShape` `c`, and a `HomologicalComplex` `K` based on `C` and `c`, given indices `i` and `j` such that the `prev` function of `c` maps `j` to `i`, and the morphism from `i` to `j` in `K` is zero, if `K` has homology in degree `j`, then for any morphism from the cycles in degree `j` of `K` to some object `Z`, the composition of the `homologyπ` of `K` in degree `j` and the inverse of `isoHomologyπ` of `K` for `i`, `j` followed by the given morphism is equal to the given morphism itself. This essentially asserts that a certain naturally defined morphism behaves as an identity under specific conditions.

For any category `C` with zero morphisms, a `ComplexShape` `c`, a `HomologicalComplex` `K` based on `C` and `c`, indices `i` and `j` with `prev(j) = i` and `K(i, j) = 0`, and a morphism from the cycles in degree `j` of `K` to some object `Z`, the composition of `homologyπ(K)(j)`, `isoHomologyπ(K).inv` for `i`, `j`, and the given morphism equals the given morphism itself.


theorem ciSup_le_iff' :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {f : ι → α},
      BddAbove (Set.range f) → ∀ {a : α}, ⨆ i, f i ≤ a ↔ ∀ (i : ι), f i ≤ a :=
  by sorry

This theorem states that for all types `α` and `ι` where `α` has an instance of `ConditionallyCompleteLinearOrderBot`, and for a function `f` mapping values of `ι` to `α`, if the set of all values in the range of `f` is bounded above, then for any value `a` in `α`, the supremum of `f` over all `ι` is less than or equal to `a` if and only if `f(i)` is less than or equal to `a` for all `i` in `ι`. In other words, if we have a bound for the range of a function, this bound is bigger than or equal to the supremum of the function if and only if it is bigger than or equal to all the values of the function. Here, `ConditionallyCompleteLinearOrderBot` means that `α` is a conditionally complete linear order with a bottom element.

If `α` is a conditionally complete linear order with a bottom element, and `f:` `ι` → `α` has a bounded range above some element `a` in `α`, then `sup(f) ≤ a` if and only if `f(i) ≤ a` for all `i` in `ι`.


theorem CategoryTheory.Equivalence.counitInv_app_functor :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C),
      e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X) :=
  by sorry

This theorem states that for any two categories `C` and `D` that are equivalent (denoted as `C ≌ D`), and for any object `X` in category `C`, the application of the inverse of the `counit` of the equivalence `e` to the result of applying the `functor` of the equivalence `e` to `X` is equal to the result of applying the `functor` of the equivalence `e` to the result of applying the `unit` of the equivalence `e` to `X`. In category theory terms, this theorem is expressing a key property of the units and counits of an equivalence of categories.

 For any equivalence of categories `e: C ≌ D` and object `X` in `C`, the following commutative diagram holds:
```
X ─────────── e.unit _ ─────────── e.obj X
          │                        │
          │ identity               │
          │                        │
        e.obj _ ─────────── e.counit _ ────────── e.obj (e.functor X)
```


theorem disjointed_le : ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (f : ℕ → α), disjointed f ≤ f := by sorry

The theorem `disjointed_le` states that for any sequence `f : ℕ → α` in a generalized boolean algebra `α`, the sequence `disjointed f`, which is formed by subtracting each element from its successors, is less than or equal to the original sequence `f`. This is expressed in terms of the lattice order defined by the generalized boolean algebra structure.

For any sequence in a generalized boolean algebra, the sequence obtained by subtracting each element from its successor is less than or equal to the original sequence in the lattice order.


/-- An induction principle for elements of `⨆ i, S i`.
If `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,
then it holds for all elements of the supremum of `S`.  -/
theorem AddSubmonoid.iSup_induction :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {ι : Sort u_4} (S : ι → AddSubmonoid M) {C : M → Prop} {x : M},
      x ∈ ⨆ i, S i → (∀ (i : ι), ∀ x ∈ S i, C x) → C 0 → (∀ (x y : M), C x → C y → C (x + y)) → C x :=
  by sorry

This theorem, `AddSubmonoid.iSup_induction`, is an induction principle for elements in the supremum of a family of additive submonoids `S i`, indexed by `i`. Suppose we have a property `C` that holds for `0` and for all elements in each `S i` and is preserved under addition. Then, this theorem states that the property `C` holds for any element `x` that lies in the supremum of the `S i`. Therefore, this theorem allows us to extend properties from elements of the individual submonoids to elements of the supremum of the submonoids.

If `C` is a property that holds for 0 and is additively closed, then `C` holds for the supremum of any family `{S i}` of additive submonoids if it holds for all elements in each `S i`.


theorem CategoryTheory.isSheaf_coherent_iff_regular_and_extensive :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor Cᵒᵖ D)
      [inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryPreExtensive C],
      CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
        CategoryTheory.Presheaf.IsSheaf (CategoryTheory.extensiveTopology C) F ∧
          CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F :=
  by sorry

This theorem states that a presheaf `F` is a sheaf with respect to the coherent Grothendieck topology on a precoherent category `C` if and only if it is a sheaf with respect to both the extensive Grothendieck topology on a finitary pre-extensive category `C` and the regular Grothendieck topology on a preregular category `C`. Here, `C` is a category with contextually defined typings, `D` is another category, and `F` is a functor from the opposite category of `C` to `D`.

A presheaf F is a sheaf with respect to the coherent Grothendieck topology on a precoherent category C if and only if it is both a sheaf with respect to the extensive Grothendieck topology on the finitary pre-extensive category C and the regular Grothendieck topology on the preregular category C.


theorem NonUnitalAlgHom.mem_range :
    ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R]
      [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B]
      [inst_4 : Module R B] [inst_5 : FunLike F A B] [inst_6 : NonUnitalAlgHomClass F R A B] (φ : F) {y : B},
      y ∈ NonUnitalAlgHom.range φ ↔ ∃ x, φ x = y :=
  by sorry

The theorem `NonUnitalAlgHom.mem_range` states that for any types `F`, `R`, `A`, `B`, given a commutative semiring `R`, a non-unital, non-associative semiring `A` that is also a `R`-module, another non-unital, non-associative semiring `B` that is also a `R`-module, a function-like `F` from `A` to `B`, and a non-unital algebra homomorphism class `F` from `R`, `A`, `B`, for any `φ` of type `F` and any element `y` of `B`, `y` is in the range of the non-unital algebra homomorphism `φ` if and only if there exists an `x` such that applying `φ` to `x` gives `y`. In other words, `y` is in the image of `φ` iff `y` is the image of some element under `φ`.

For any non-unital commutative semirings `R`, `A`, `B`, `R`-module homomorphisms `F` from `A` to `B`, and a non-unital algebra homomorphism `φ` of type `F` from `R`, `A`, `B`, `y` is in the image of `φ` if and only if there exists an `x` in `A` such that `φ(x) = y`.


theorem IsLprojection.le_def :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X]
      [inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), P ≤ Q ↔ ↑P = ↑(P ⊓ Q) :=
  by sorry

This theorem describes a property of left (L-) projections in the context of normed additive commutative groups and modules over a ring. Specifically, for any two left projections 'P' and 'Q', 'P' is less than or equal to 'Q' if and only if 'P' equals the infimum of 'P' and 'Q'. This theorem essentially sets a condition for the partial ordering of left projections in a mathematical structure where scalar multiplication is faithful.

For left projections P and Q in the context of normed additive commutative groups and modules over a ring, P ≤ Q if and only if P = inf(P, Q).


theorem intervalIntegral.integral_comp_mul_add :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b c : ℝ} (f : ℝ → E),
      c ≠ 0 → ∀ (d : ℝ), ∫ (x : ℝ) in a..b, f (c * x + d) = c⁻¹ • ∫ (x : ℝ) in c * a + d..c * b + d, f x :=
  by sorry

The theorem `intervalIntegral.integral_comp_mul_add` states that for all real numbers `a`, `b`, `c` and `d`, with `c` not equal to zero, and for any function `f` mapping real numbers to elements of a normed space over the real numbers, the integral over the interval `[a, b]` of `f` composed with the linear transformation `x ↦ c * x + d` equals `c` inverse scaled by the integral over the interval `[c * a + d, c * b + d]` of `f`. In other words, it expresses how linear transformations of the input variable affect the value of definite integrals.

For real numbers `a`, `b`, `c ≠ 0`, and a function `f` mapping real numbers to elements of a normed space, the definite integral of `f` over `[a, b]` equals `c⁻¹` times the definite integral of `f` over `[c*a + d, c*b + d]`, where `d = c*a + b`.


theorem Polynomial.continuous_aeval :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSemiring A] (p : Polynomial R),
      Continuous fun x => (Polynomial.aeval x) p :=
  by sorry

The theorem `Polynomial.continuous_aeval` states that for any given commutative semiring `R`, semiring `A`, algebra structure of `A` over `R`, topological space structure on `A`, and topological semiring structure on `A`, and any polynomial `p` with coefficients in `R`, the function that evaluates `p` at an element `x` of `A` using the algebra evaluation function `Polynomial.aeval` is a continuous function. In mathematical terms, this theorem guarantees the continuity of the function $f(x) = p(a)$ where $a \in A$ and $p$ is a polynomial in `R[X]` with the topology defined on `A`.

The polynomial evaluation function `Polynomial.aeval` is continuous with respect to the given topological semiring structure on an algebra `A` over a commutative semiring `R`.


theorem Valuation.map_add_le :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
      {x y : R} {g : Γ₀}, v x ≤ g → v y ≤ g → v (x + y) ≤ g :=
  by sorry

This theorem states that for any ring `R` and any linearly ordered commutative monoid with zero `Γ₀`, given a valuation `v` from `R` to `Γ₀`, and any elements `x`, `y` of `R` and `g` of `Γ₀`, if the valuation of `x` and the valuation of `y` are both less than or equal to `g`, then the valuation of the sum of `x` and `y` is also less than or equal to `g`. In other words, the valuation function preserves the order under addition in the ring.

For any ring `R`, linearly ordered commutative monoid with zero `Γ₀`, valuation `v` from `R` to `Γ₀`, and all `x`, `y` in `R` and `g` in `Γ₀`, if `v(x) ≤ g` and `v(y) ≤ g`, then `v(x + y) ≤ g`.


theorem Int.bit_coe_nat : ∀ (b : Bool) (n : ℕ), Int.bit b ↑n = ↑(Nat.bit b n) := by sorry

This theorem states that for any boolean value `b` and natural number `n`, the operation of appending the bit `b` to the binary representation of the integer version of `n` (i.e., `Int.bit b ↑n`) is equal to the operation of appending the bit `b` to the binary representation of `n` itself (i.e., `Nat.bit b n`), where the result is then converted to an integer. In other words, whether we first convert `n` to an integer and then append the bit, or first append the bit and then convert to an integer, the result is the same.

For any boolean value `b` and natural number `n`, `Int.bit b (Nat.toInt n)` equals `Nat.bit b n`.


theorem Fintype.card_units :
    ∀ {α : Type u_1} [inst : GroupWithZero α] [inst_1 : Fintype α] [inst_2 : DecidableEq α],
      Fintype.card αˣ = Fintype.card α - 1 :=
  by sorry

This theorem, `Fintype.card_units`, states that for any type `α` which is equipped with a group with zero structure (denoted as `GroupWithZero α`), given that `α` has a finite number of distinct elements (denoted as `Fintype α`), and the equality between elements of `α` is decidable (`DecidableEq α`), the number of units in `α` (denoted as `αˣ`, where a unit is an element with a multiplicative inverse) is equal to the total number of elements in `α` subtracted by one (`Fintype.card α - 1`). Essentially, it defines how to determine the number of invertible elements in any finite group with a zero element.

In a finite group with zero element, the number of units (invertible elements) equals the total number of elements minus one.


theorem List.replicate_succ : ∀ {α : Type u_1} (a : α) (n : ℕ), List.replicate (n + 1) a = a :: List.replicate n a := by
  sorry

The theorem `List.replicate_succ` states that for any type `α`, any element `a` of type `α`, and any natural number `n`, replicating `a` `n+1` times is equivalent to prepending `a` to the list obtained by replicating `a` `n` times. In other words, creating a list with `n+1` copies of `a` is the same as taking a list with `n` copies of `a` and adding another `a` at the beginning.

For any type `α` and natural number `n`, `List.replicate (n + 1) a = a :: List.replicate n a`.


theorem FreeSemigroup.hom_ext :
    ∀ {α : Type u} {β : Type v} [inst : Mul β] {f g : FreeSemigroup α →ₙ* β},
      ⇑f ∘ FreeSemigroup.of = ⇑g ∘ FreeSemigroup.of → f = g :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` has a multiplication operation, and given two monoid homomorphisms `f` and `g` from the free semigroup over `α` to `β`, if these homomorphisms map elements from `α` (embedded into the free semigroup over `α` using `FreeSemigroup.of`) to the same element in `β`, then the two homomorphisms are identical. In other words, the theorem asserts the uniqueness of a monoid homomorphism from the free semigroup over a set, given its effect on the elements of the set.

Given any types `α` and `β` with a multiplication operation, and given two monoid homomorphisms `f` and `g` from the free semigroup over `α` to `β`, if `f (FreeSemigroup.of x) = g (FreeSemigroup.of x)` for all `x` in `α`, then `f = g`.


theorem Monoid.PushoutI.NormalWord.prod_empty :
    ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
      {φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ},
      Monoid.PushoutI.NormalWord.prod Monoid.PushoutI.NormalWord.empty = 1 :=
  by sorry

The theorem `Monoid.PushoutI.NormalWord.prod_empty` states that for any types `ι`, `G`, `H`, where `G` is a type dependent on `ι` and `H` is a type, and every `i` in `ι` maps to a Group `G i`, and `H` is also a Group, given a homomorphism `φ` from `H` to `G i` for all `i` in `ι`, and a transversal `d` of the normal word in the pushout monoid, the product of the empty normal word in the pushout monoid is equal to the identity element of the group. This theorem essentially asserts that the product of the empty word in the pushout monoid is the identity, mirroring the property of empty products in group theory.

For any type ι, groups G(i) indexed by i in ι, group H, and a homomorphism φ from H to the product of the G(i)'s, the identity element in the pushout monoid of H and the product of empty words in the G(i)'s coincides.


theorem Set.univ_pi_eq_empty_iff :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)}, Set.pi Set.univ t = ∅ ↔ ∃ i, t i = ∅ := by sorry

This theorem states that for any given type `ι` and a family of sets `t` where each set is of type `α i` for some `i` in `ι`, the set of all dependent functions from `ι` to `α i` (denoted by `Set.pi Set.univ t`) is empty if and only if there exists an `i` such that the corresponding set `t i` is empty. In other words, the Cartesian product of all sets in the family `t` is empty if and only if at least one of the sets in the family is empty.

The set of dependent functions from a type `ι` to a family `t` of sets `α i` is empty if and only if one of the sets `t i` is empty. (Equivalently, the Cartesian product of the sets in `t` is non-empty if and only if all sets in `t` are non-empty.)


/-- **Church-Rosser theorem** for word reduction: If `w1 w2 w3` are words such that `w1` reduces
to `w2` and `w3` respectively, then there is a word `w4` such that `w2` and `w3` reduce to `w4`
respectively. This is also known as Newman's diamond lemma. -/
theorem FreeAddGroup.Red.church_rosser :
    ∀ {α : Type u} {L₁ L₂ L₃ : List (α × Bool)},
      FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red L₁ L₃ → Relation.Join FreeAddGroup.Red L₂ L₃ :=
  by sorry

The **Church-Rosser theorem** for word reduction states that for any given type `α` and any three lists `L₁`, `L₂`, and `L₃` of pairs of elements from `α` and Boolean values, if `L₁` can be reduced to both `L₂` and `L₃` (in the sense of `FreeAddGroup.Red`), then there exists a list to which both `L₂` and `L₃` can be reduced to, according to the `Relation.Join` of `FreeAddGroup.Red`. This theorem is also known as Newman's diamond lemma, and it captures the notion of confluence in term rewriting systems, ensuring that different reduction paths can be reconciled.

The Church-Rosser theorem for word reduction in Lean 4 asserts that for any type `α` and lists `L₁`, `L₂`, and `L₃` of pairs from `α` and Boolean values, if `L₁` can be reduced to both `L₂` and `L₃`, then there exists a common reduction result.


theorem false_of_nontrivial_of_subsingleton : ∀ (α : Type u_3) [inst : Nontrivial α] [inst : Subsingleton α], False :=
  by sorry

This theorem, `false_of_nontrivial_of_subsingleton`, states that for any type `α`, if `α` is both nontrivial and a subsingleton, then we can derive a contradiction (i.e., `False`). A nontrivial type is one that has at least two distinct elements, while a subsingleton type is one that has at most one element. Therefore, no type can be both nontrivial and a subsingleton at the same time.

If a type `α` is both nontrivial (has at least two distinct elements) and a subsingleton (has at most one element), then we obtain a contradiction.


theorem OmegaCompletePartialOrder.continuous_comp :
    ∀ {α : Type u} {β : Type v} {γ : Type u_1} [inst : OmegaCompletePartialOrder α]
      [inst_1 : OmegaCompletePartialOrder β] [inst_2 : OmegaCompletePartialOrder γ] (f : α →o β) (g : β →o γ),
      OmegaCompletePartialOrder.Continuous f →
        OmegaCompletePartialOrder.Continuous g → OmegaCompletePartialOrder.Continuous (OrderHom.comp g f) :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` that are instances of `OmegaCompletePartialOrder`, if we have two order homomorphisms `f` from `α` to `β` and `g` from `β` to `γ`, and both of these order homomorphisms are continuous, then the composition of `g` and `f` (given by `OrderHom.comp g f`) is also a continuous order homomorphism. In other words, the continuity property for order homomorphisms is preserved under function composition.

If `f` is a continuous order homomorphism from `α` to `β` and `g` is a continuous order homomorphism from `β` to `γ`, then their composition `g ∘ f` is a continuous order homomorphism from `α` to `γ`.


/-- The Legendre symbol of `p` and `a` is zero iff `p ∣ a`.  -/
theorem legendreSym.eq_zero_iff : ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (a : ℤ), legendreSym p a = 0 ↔ ↑a = 0 := by
  sorry

The theorem `legendreSym.eq_zero_iff` states that for any prime number `p` and any integer `a`, the Legendre symbol of `p` and `a` is zero if and only if `p` divides `a`. In other words, if `p` is a factor of `a`, then the Legendre symbol of `p` and `a` will be zero; conversely, if the Legendre symbol of `p` and `a` is zero, then `p` is a factor of `a`.

The Legendre symbol of prime number `p` and integer `a` is zero if and only if `p` divides `a`.


theorem MvPolynomial.coeff_homogeneousComponent :
    ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (n : ℕ) (φ : MvPolynomial σ R) (d : σ →₀ ℕ),
      MvPolynomial.coeff d ((MvPolynomial.homogeneousComponent n) φ) =
        if (Finset.sum d.support fun i => d i) = n then MvPolynomial.coeff d φ else 0 :=
  by sorry

This theorem states that for any commutative semiring `R`, any natural number `n`, any multivariate polynomial `φ` over the semiring `R` with variables indexed by `σ`, and any function `d` from `σ` to the natural numbers, the coefficient of the monomial `d` in the `n`-th homogeneous component of `φ` equals the coefficient of `d` in `φ` if the sum of the values of `d` over its support equals `n`; otherwise, this coefficient is zero. Essentially, it is examining the coefficient of a certain monomial in a particular homogeneous component of a multivariate polynomial.

For any commutative semiring `R`, any multivariate polynomial `φ` over `R`, and any natural number `n`, the coefficient of a monomial with a sum of exponents equal to `n` in `φ`'s `n`-th homogeneous component equals the coefficient of that monomial in `φ`, otherwise it is zero.


/-- A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side.  -/
theorem InnerProductGeometry.norm_div_tan_angle_add_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → x = 0 ∨ y ≠ 0 → ‖y‖ / Real.tan (InnerProductGeometry.angle x (x + y)) = ‖x‖ :=
  by sorry

The theorem `InnerProductGeometry.norm_div_tan_angle_add_of_inner_eq_zero` states that for any vector space `V` over the real numbers, equipped with a normed additive commutative group structure and an inner product space structure, given two vectors `x` and `y` such that their inner product is `0` and either `x` is the zero vector or `y` is not the zero vector, the magnitude (or norm) of `y` divided by the tangent of the angle between `x` and the vector sum of `x` and `y` equals the magnitude of `x`. This is analogous to the geometric fact in right triangle trigonometry that the length of a side of a right-angled triangle divided by the tangent of the opposite angle equals the length of the adjacent side.

For any normed inner product space V over the real numbers, if x and y are vectors with inner product 0 and neither is the zero vector, then ||x|| = ||y|| * tan(angle between x and y + π/2).


theorem Isometry.diam_range :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → Metric.diam (Set.range f) = Metric.diam Set.univ :=
  by sorry

The theorem `Isometry.diam_range` states that for any two types `α` and `β` that are pseudo metric spaces, and for any function `f` from `α` to `β`, if `f` is an isometry (a map that preserves the pseudo metric), then the diameter of the range of `f` is equal to the diameter of the universal set `α`. In other words, an isometric function does not change the diameter of the space.

For any pseudo metric spaces α and β and isometric function f from α to β, the diameter of the range of f equals the diameter of α.


theorem Multiset.noncommFoldr_coe :
    ∀ {α : Type u_3} {β : Type u_4} (f : α → β → β) (l : List α)
      (comm : Set.Pairwise {x | x ∈ ↑l} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)) (b : β),
      Multiset.noncommFoldr f (↑l) comm b = List.foldr f b l :=
  by sorry

This theorem states that for any types `α` and `β`, a function `f` of type `α → β → β`, a list `l` of type `List α`, a property `comm` stating that for each pair of distinct elements `x` and `y` in the multiset coerced from `l`, the function `f` commutes for each `b : β` (i.e., `f x (f y b) = f y (f x b)`), and a `b : β`, the non-commutative fold of `f` over the multiset coerced from `l` with the `comm` property starting with `b` is equal to the right-to-left fold of `f` over the list `l` starting with `b`.

In simpler terms, it connects two ways of combining elements in a list: one in an unordered way (with a proof that the process is independent of the order), and one in a specific order from right to left. It states that these two ways produce the same result when the function used is commutative for all pairs of elements in the multiset.

For any commutative function `f : α → β → β`, list `l : List α`, and `b : β`, the non-commutative fold of `f` over the multiset of `l` equals the right-to-left fold of `f` over `l` starting with `b`.


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

This theorem states that for any generalized coheyting algebra (a certain kind of algebraic structure), for any elements `a`, `b`, and `c` in that structure, the set difference of `a` and `b`, further subtracted by the set difference of `a` and `c`, is always less than or equal to the set difference of `c` and `b`. In symbolic form, this is $(a \setminus b) \setminus (a \setminus c) \leq c \setminus b$. This theorem is a general property that holds in all generalized coheyting algebras.

In any generalized cohesheaf topos, for all elements a, b, and c, the subset difference a \ b \ included in the subset difference c \ b holds, that is, (a \ b) \ subseteq (c \ b). (Note: I assumed you meant subset difference instead of set difference as the symbol \ is often used for subset difference in Lean.)


/-- A point is in the inf of two affine subspaces if and only if it is in both of them.  -/
theorem AffineSubspace.mem_inf_iff :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] (p : P) (s1 s2 : AffineSubspace k P), p ∈ s1 ⊓ s2 ↔ p ∈ s1 ∧ p ∈ s2 :=
  by sorry

This theorem states that for any given point `p` and two affine subspaces `s1` and `s2`, the point `p` is in the intersection of `s1` and `s2` if and only if `p` is in both `s1` and `s2`. Here, `k` is a ring, `V` is an additive commutative group, `P` is a module over `k`, and `S` is an additive torsor for `V` acting on `P`. The symbol `⊓` represents the intersection operation on these subspaces.

For any point `p` in the vector space `P` over a commutative ring `k`, `p` is in the intersection of affine subspaces `s1` and `s2` if and only if `p` is in both `s1` and `s2` (denoted as `s1 ∩ s2 = {p : P | p ∈ s1 ∧ p ∈ s2}`).


MeasurableEmbedding.comp

theorem MeasurableEmbedding.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {f : α → β} {g : β → γ},
      MeasurableEmbedding g → MeasurableEmbedding f → MeasurableEmbedding (g ∘ f) :=
  by sorry

This theorem states that for every three types `α`, `β`, and `γ` with associated measurable spaces `mα`, `inst`, and `inst_1` respectively, and for every two functions `f` from `α` to `β` and `g` from `β` to `γ`, if `g` and `f` are measurable embeddings, then the composition of `g` and `f` (denoted as `g ∘ f`) is also a measurable embedding. In other words, the composition of two measurable embeddings is always a measurable embedding.

If `f: α → β` and `g: β → γ` are measurable embeddings, then their composition `g ∘ f` is also a measurable embedding.


theorem zpow_sub₀ :
    ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → ∀ (z1 z2 : ℤ), a ^ (z1 - z2) = a ^ z1 / a ^ z2 := by
  sorry

This theorem states that for any non-zero element 'a' of a group with zero (a type 'G₀'), for any two integers 'z1' and 'z2', the exponentiation of 'a' to the power of the difference of 'z1' and 'z2' is equal to the division of 'a' to the power of 'z1' by 'a' to the power of 'z2'. In mathematical terms, it says that `a^(z1 - z2) = a^z1 / a^z2`, given that 'a' is not zero.

For any non-zero element 'a' in a group and integers 'z1' and 'z2', the power 'a^(z1 - z2)' equals the quotient 'a^z1 / a^z2'.


/-- If the counit of an adjunction is an isomorphism, then its inverse on the image of R is given
by R whiskered with the unit.  -/
theorem CategoryTheory.inv_counit_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
      (h : L ⊣ R) {X : D} [inst_2 : CategoryTheory.IsIso (h.counit.app X)],
      CategoryTheory.inv (R.map (h.counit.app X)) = h.unit.app (R.obj X) :=
  by sorry

This theorem states that for any categories `C` and `D`, and for any adjunction `h` between the functors `L` (from `C` to `D`) and `R` (from `D` to `C`), if the counit of the adjunction `h` at a specific object `X` in `D` is an isomorphism, then the inverse of the morphism obtained by applying the functor `R` to the counit of `h` at `X`, is equal to the unit of the adjunction `h` applied to the object obtained by applying the functor `R` to `X`. In simpler terms, it asserts a particular relationship between the unit and the counit of an adjunction in category theory when the counit is an isomorphism.

For any adjunction between functors h : C -> D and R : D -> C, if the counit ε : L(X) -> R(X) is an isomorphism for some object X in D, then ε^-1 ∘ R(ι(X)) = ι(R(X)), where ι is the unit of the adjunction.


theorem MonotoneOn.mem_lowerBounds_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
      MonotoneOn f t → ∀ {a : α}, s ⊆ t → a ∈ lowerBounds s → a ∈ t → f a ∈ lowerBounds (f '' s) :=
  by sorry

The theorem `MonotoneOn.mem_lowerBounds_image` states that for any types `α` and `β` with preorder structures, any function `f: α → β`, and any sets `s` and `t` of `α`, if `f` is monotone on `t`, and `s` is a subset of `t`, then for any element `a` of `α`, if `a` is a lower bound of `s` and `a` is in `t`, then `f(a)` is a lower bound of the image of `s` under `f`. In other words, if a function is monotone on a set, then it preserves the property of being a lower bound when it maps elements of a subset of that set.

If `f: α → β` is a monotone function on a set `t subseteq α`, and `a` is a lower bound of `s subseteq t` in `α`, then `f(a)` is a lower bound of the image of `s` under `f` in `β`.


theorem Mathlib.Logic.Basic._auxLemma.16 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem states that for any type `α`, if you have two elements `a` and `b` of this type, then the statement "a equals b" is logically equivalent to "b equals a". In other words, equality is symmetric in Lean's logic: if `a` is equal to `b`, then `b` is equal to `a`, and vice versa. This is a fundamental principle of equality in mathematics, formalized here in Lean 4's type theory.

In Lean 4's type theory, for all types `α` and elements `a` and `b` of type `α`, the equality `a = b` is logically equivalent to `b = a`.


theorem Complex.abs_im_lt_abs : ∀ {z : ℂ}, |z.im| < Complex.abs z ↔ z.re ≠ 0 := by sorry

The theorem `Complex.abs_im_lt_abs` states that for all complex numbers `z`, the absolute value of the imaginary part of `z` is less than the absolute value of `z` if and only if the real part of `z` is not equal to zero. In mathematical terms, for all complex numbers `z`, |Im(z)| < |z| if and only if Re(z) ≠ 0.

The absolute value of the imaginary part of a complex number is strictly less than the absolute value of the complex number if and only if its real part is non-zero.


theorem Mathlib.Logic.Basic._auxLemma.13 : ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) := by sorry

This theorem states that for any two propositions `a` and `b`, the logical disjunction of `a` and `b` (denoted as `a ∨ b`) is equal to the disjunction of `b` and `a` (denoted as `b ∨ a`). In other words, in logic, the order of the operands in a disjunction does not matter, mirroring the commutative property in mathematics.

For all propositions `a` and `b`, `a ∨ b` is equal to `b ∨ a` in Lean logic. (The logical disjunction of `a` and `b` is commutative.)


theorem Subalgebra.rank_bot :
    ∀ {F : Type u_2} {E : Type u_3} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E]
      [inst_3 : StrongRankCondition F] [inst_4 : NoZeroSMulDivisors F E] [inst_5 : Nontrivial E],
      Module.rank F ↥⊥ = 1 :=
  by sorry

This theorem states that for any types `F` and `E`, where `F` is a commutative ring, `E` is a ring, and `E` is an algebra over `F`. Also, `F` satisfies the strong rank condition, there are no zero `smul` divisors in `F` and `E`, and `E` is nontrivial. Then, the rank of the module that corresponds to the bottom element (zero subalgebra) of the lattice of subalgebras of `E` over `F` is always equal to `1`.

For a commutative ring `F` satisfying the strong rank condition with no zero divisors, and `E` being an algebra over `F` with no zero divisors and being nontrivial, the rank of the bottom element of the lattice of subalgebras of `E` over `F` equals 1.