theorem Sum.inl_lt_inl_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : α}, Sum.inl a < Sum.inl b ↔ a < b := by sorry

This theorem states that for any two types `α` and `β` which both have a less-than relation defined (`LT α` and `LT β`), given two elements `a` and `b` of type `α`, the "less than" relationship between `Sum.inl a` and `Sum.inl b` (where `Sum.inl` is a function that injects `α` into the sum type `α + β`) is equivalent to the "less than" relationship between `a` and `b`. In other words, `Sum.inl a` is less than `Sum.inl b` if and only if `a` is less than `b`.

For types `α` and `β` equipped with a less-than relation, and elements `a : α` and `b : β`, `Sum.inl a < Sum.inl b` if and only if `a < b`.


/-- **Alias** of the forward direction of `Filter.eventuallyEq_set`. -/
theorem Filter.EventuallyEq.mem_iff :
    ∀ {α : Type u} {s t : Set α} {l : Filter α}, s =ᶠ[l] t → ∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t := by sorry

This theorem, referred to as the alias of the forward direction of `Filter.eventuallyEq_set`, states that for any type `α`, two sets `s` and `t` of type `α`, and a filter `l` on `α`, if the sets `s` and `t` are eventually equal at filter `l` (denoted as `s =ᶠ[l] t`), then for all `x` in `α` that eventually appear in `l`, `x` is in `s` if and only if `x` is in `t`. Essentially, this theorem asserts the equivalence of membership between two eventually equal sets at any point that eventually appears in a given filter.

For any type `α`, sets `s` and `t` of type `α`, and filter `l` on `α`, if `s =ᶠ[l] t`, then for all `x` in `α`, `x` is in `s` if and only if `x` is in `t` for all `x` that eventually appear in `l`.


theorem CategoryTheory.Functor.IsLocalization.mk' :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D)
      (W : CategoryTheory.MorphismProperty C),
      CategoryTheory.Localization.StrictUniversalPropertyFixedTarget L W D →
        CategoryTheory.Localization.StrictUniversalPropertyFixedTarget L W
            (CategoryTheory.MorphismProperty.Localization W) →
          CategoryTheory.Functor.IsLocalization L W :=
  by sorry

This theorem states that for any two types `C` and `D`, which have category structures, and a functor `L` from `C` to `D`, together with the morphism property `W` on `C`, if `L` satisfies the strict universal property with fixed target `D` and `W`, and also the strict universal property with fixed target being the localization of `W`, then `L` is an isomorphism on the localization of `W`, i.e., `L` is a localization functor.

In simpler terms, this theorem provides a criterion to determine when a functor is a localization functor. It says that a functor is a localization functor if it preserves certain morphism properties and is universal in a certain sense.

A functor between two categorically structured types with given morphism property is a localization functor if it strictly preserves the universal property with respect to that property and its localization.


theorem Polynomial.divByMonic_eq_zero_iff :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R} [inst_1 : Nontrivial R],
      Polynomial.Monic q → (p /ₘ q = 0 ↔ Polynomial.degree p < Polynomial.degree q) :=
  by sorry

The theorem `Polynomial.divByMonic_eq_zero_iff` states that for any ring `R`, given two polynomials `p` and `q` from `R` and assuming `R` is nontrivial, if `q` is monic (meaning its leading coefficient is 1), then the result of the division of `p` by `q` is zero if and only if the degree of `p` is less than the degree of `q`. In other words, a polynomial `p` divided by a monic polynomial `q` equals zero precisely when `p` has a lower degree than `q`.

For a nontrivial ring R and monic polynomials p and q of degrees d(p) and d(q) respectively, p / q = 0 if and only if d(p) < d(q).


theorem Mathlib.Data.Set.Prod._auxLemma.5 :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) := by sorry

This theorem states that, for any type `α` and any two predicates `p` and `q` defined on `α`, the assertion that every element of `α` satisfies both `p` and `q` is equivalent to the assertion that every element of `α` satisfies `p` and every element of `α` satisfies `q`. In other words, if `p` and `q` are properties that elements of `α` might have, then the claim "every element of `α` has both properties `p` and `q`" is the same as the claim "every element of `α` has property `p` and every element of `α` has property `q`".

For any type `α` and predicates `p` and `q` on `α`, the proposition `∀x : α, p x ∧ q x` is equivalent to `∀x : α, p x ∧ q x`. (In Lean syntax, `∧` represents logical and.)


/-- A locally constant function is constant on any preconnected set.  -/
theorem IsLocallyConstant.apply_eq_of_isPreconnected :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
      IsLocallyConstant f → ∀ {s : Set X}, IsPreconnected s → ∀ {x y : X}, x ∈ s → y ∈ s → f x = f y :=
  by sorry

This theorem states that if a function is locally constant on a topological space, then it is constant over any preconnected subset of this space. More concretely, for any two elements in the preconnected subset, the function will take on the same value. This holds for all topological spaces and functions, as well as all preconnected subsets of these spaces, provided that the function is locally constant.

If a function is locally constant on a preconnected subset of a topological space, then it is constant on that subset.


theorem Ioo_mem_nhdsWithin_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b c : α},
      b ∈ Set.Ico a c → Set.Ioo a c ∈ nhdsWithin b (Set.Ioi b) :=
  by sorry

This theorem states that for any types `α` which has a topological space structure, a linear order structure, and satisfies the `ClosedIciTopology` property, and for any three elements `a`, `b`, and `c` of type `α`, if `b` belongs to the left-closed right-open interval from `a` to `c` (`Set.Ico a c`), then the left-open right-open interval from `a` to `c` (`Set.Ioo a c`) is an element of the "neighborhood within" filter of `b` confined to the left-open right-infinite interval starting at `b` (`nhdsWithin b (Set.Ioi b)`).

In mathematical terms, if we have a topological space that also has a linear order and it satisfies the property that the set of all points greater than or equal to a given point is closed, then if `b` is in the interval `[a, c)`, the open interval `(a, c)` is in the neighborhood filter of `b` within the set of points greater than `b`.

For any topological space `α` with a linear order and the `ClosedIciTopology` property, if `b` belongs to the left-closed right-open interval `[a, c)` in `α`, then `(a, c)` is in the neighborhood filter of `b` within the set of elements greater than `b`.


theorem Set.toFinset_univ :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Fintype ↑Set.univ], Set.toFinset Set.univ = Finset.univ := by sorry

This theorem asserts that for any type `α` that has a `Fintype` instance, the transformation of the universal set of `α` into a `Finset` using `Set.toFinset` equals the universal `Finset` of `α`. In other words, if we take all elements of `α` (represented by `Set.univ`), cast them into a `Finset`, we get the same as if we directly constructed the universal `Finset` of `α` (represented by `Finset.univ`). It implies that there is a one-to-one correspondence between all elements of a finite type `α` and the elements in the universal `Finset` of `α`.

For any type `α` with a `Fintype` instance, `Set.toFinset (Set.univ : α)` equals `Finset.univ : Finset α`.


theorem ProbabilityTheory.kernel.indep_bot_right :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.Indep m' ⊥ κ μ :=
  by sorry

This theorem states that for any types `α` and `Ω`, given measurable spaces over `α` and `Ω`, a Markov kernel `κ` from `α` to `Ω`, and a measure `μ` over `α`, the kernel `κ` is independent of the trivial σ-algebra (denoted by `⊥`) with respect to the measure `μ`. In the context of Probability Theory, this implicates that no information from the trivial σ-algebra can influence the transition probabilities defined by the Markov kernel.

For any measurable spaces `(α, Σα)`, `(Ω, ΣΩ)`, measure `μ` on `(α, Σα)`, and Markov kernel `κ : α → Ω`, the kernel `κ` is μ-independent of the trivial σ-algebra `⊥` on `(α, Σα)`, i.e., ∀A ∈ Σα, μ(κ(A)) = μ(A) ∘ κ.


theorem ENNReal.tendsto_ofReal :
    ∀ {α : Type u_1} {f : Filter α} {m : α → ℝ} {a : ℝ},
      Filter.Tendsto m f (nhds a) → Filter.Tendsto (fun a => ENNReal.ofReal (m a)) f (nhds (ENNReal.ofReal a)) :=
  by sorry

The theorem `ENNReal.tendsto_ofReal` states that, for any type `α`, a filter `f` on `α`, a function `m` mapping from `α` to real numbers, and a real number `a`, if the function `m` tends towards `a` with respect to the filter `f` (that is, for every neighborhood of `a`, the preimage of that neighborhood under `m` is in the filter `f`), then the function obtained by applying `ENNReal.ofReal` (which maps a real number to its nonnegative counterpart or zero if it's negative) to `m` also tends towards the nonnegative counterpart of `a` (or zero if `a` is negative) with respect to the same filter `f`. Essentially, this theorem is asserting that if a function tends towards a real number, then the nonnegative part of that function tends towards the nonnegative part of that real number.

If a function from a type to real numbers tends to a real number with respect to a filter, then the pointwise non-negative part of the function tends to the non-negative part of that real number with respect to the same filter.


StrictMonoOn.monotoneOn

theorem StrictMonoOn.monotoneOn :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → MonotoneOn f s :=
  by sorry

The theorem `StrictMonoOn.monotoneOn` states that for any set `s` of a certain type `α`, and a function `f` from `α` to another type `β`, if `f` is strictly monotone on `s` then `f` is also monotone on `s`. Here, a function is said to be strictly monotone on `s` if for any two elements `a` and `b` in `s`, `a < b` implies `f(a) < f(b)`, and it is said to be monotone on `s` if `a ≤ b` implies `f(a) ≤ f(b)`. This theorem illustrates a property of monotonicity: strict monotonicity implies general monotonicity.

If a function is strictly monotonic on a set, then it is monotonic on that set.


theorem Nat.eq_add_of_sub_eq : ∀ {a b c : ℕ}, b ≤ a → a - b = c → a = c + b := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `b` is less than or equal to `a`, and the difference of `a` and `b` is equal to `c`, then `a` is equal to the sum of `c` and `b`. In other words, it is expressing the property of subtraction and its relationship to addition in the natural numbers, namely if you subtract `b` from `a` to get `c`, you can add `b` back to `c` to get `a` again.

For natural numbers `a`, `b`, and `c`, if `b` ≤ `a` and `a` = `b` + `c`, then `a` = `c` + `b`.


theorem continuous_sup :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Sup L] [inst_2 : ContinuousSup L],
      Continuous fun p => p.1 ⊔ p.2 :=
  by sorry

This theorem states that for any type `L` that has a topological space structure, a sup (supremum) operation, and for which the sup operation is continuous, the function that takes a pair of elements in `L` and returns their supremum is a continuous function. In mathematical terms, if we have a topological space `L` with a defined supremum operation that is continuous, then the map `(x, y) -> x ⊔ y` is a continuous map.

If `(L, �intersection, ∪, ∅, ∏, ⊤, ⊥, ≤)` is a complete lattice in a topological space with a continuous supremum operation, then the function `(x, y) ↦ x ⊔ y` is continuous.


theorem MeasureTheory.Measure.map_neg_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Neg G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsNegInvariant μ], MeasureTheory.Measure.map Neg.neg μ = μ :=
  by sorry

The theorem `MeasureTheory.Measure.map_neg_eq_self` states that for any type `G` which is a measurable space and has a negation operation, and any measure `μ` on `G` that is invariant under negation (i.e., the measure of a set and its negation are the same), the measure obtained by pushing forward `μ` along the negation map is the same as the original measure `μ`. This means, intuitively, that if you transform all the points in your space by negation, the measure of the sets remains unchanged.

For any measurable space (G, Σ) with negation operation and invariant-under-negation measure μ, the pushforward measure of μ under the negation map is equal to μ itself.


theorem Ordinal.lsub_le_iff :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max v u}}, Ordinal.lsub f ≤ a ↔ ∀ (i : ι), f i < a := by
  sorry

The theorem `Ordinal.lsub_le_iff` states that for any type `ι`, any function `f` from `ι` to `Ordinal.{max u v}`, and any ordinal `a` of type `Ordinal.{max v u}`, the least strict upper bound of the family of ordinals defined by `f` is less than or equal to `a` if and only if every ordinal `f i` (where `i` is an element of `ι`) is less than `a`. In other words, `a` is an upper bound for all ordinals in the family defined by `f`, if and only if `a` is greater than every ordinal in that family.

For any type `ι`, function `f` from `ι` to the ordinals, and ordinal `a`, the least upper bound of the ordinals `f i` (where `i` is in `ι`) is less than or equal to `a` if and only if every `f i` is strictly less than `a`.


theorem Set.Icc_diff_right : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Icc a b \ {b} = Set.Ico a b := by
  sorry

This theorem, `Set.Icc_diff_right`, states that for all types `α`, given that `α` has a partial order structure and given any two elements `a` and `b` in `α`, the difference between the left-closed right-closed interval from `a` to `b` and the set containing only `b` equals the left-closed right-open interval from `a` to `b`. In other words, if you take the closed interval `[a, b]` and remove the endpoint `b`, you get the half-open interval `[a, b)`.

For all types `α` with a partial order structure, the difference between the left-closed right-closed interval `[a, b]` and the singleton set `{b}` is equal to the left-closed right-open interval `[a, b)` for any `a` and `b` in `α`.


theorem Ideal.isCoprime_iff_codisjoint :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J ↔ Codisjoint I J := by sorry

This theorem states that for any type `R` that forms a commutative semiring, any two ideals `I` and `J` in `R` are coprime if and only if they are codisjoint. In this context, "coprime" means that there exist elements `a` and `b` such that `a * I + b * J = 1`. On the other hand, "codisjoint" means that for any element `x` in `R`, if `I` and `J` are both less than or equal to `x`, then the top element of the order (`⊤`) must be less than or equal to `x` as well. This theorem therefore connects the algebraic concept of coprimeness with the order-theoretic concept of codisjointness.

For any commutative semiring `R`, ideals `I` and `J` are coprime if and only if they are codisjoint, meaning for all `x` in `R`, if `I` and `J` are both less than or equal to `x`, then `⊤` is less than or equal to `x`.


theorem le_of_forall_le_of_dense :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] {a₁ a₂ : α},
      (∀ (a : α), a₂ < a → a₁ ≤ a) → a₁ ≤ a₂ :=
  by sorry

This theorem states that for any type `α` that has a linear order and is densely ordered, if for every element `a` such that `a₂` is less than `a`, `a₁` is less than or equal to `a`, then `a₁` is less than or equal to `a₂`. In other words, if `a₁` is less than or equal to any element that's larger than `a₂`, then `a₁` must be less than or equal to `a₂`. This applies to any type that fulfills the conditions of being linearly ordered and densely ordered, like the real numbers.

If a type `α` is linearly and densely ordered, then for all `a₁` and `a₂` in `α` with `a₂` > `a₁`, if `a₁` ≤ `x` for all `x` with `a₁` < `x` < `a₂`, then `a₁` ≤ `a₂`.


theorem Finset.nonempty_range_succ : ∀ {n : ℕ}, (Finset.range (n + 1)).Nonempty := by sorry

This theorem states that for every natural number `n`, the set of natural numbers less than `n + 1` (represented by `Finset.range (n + 1)`) is not empty. This is intuitively clear as the set of numbers less than `n + 1` always contains at least the number `n`, hence it is indeed non-empty.

For every natural number `n`, the finite set of natural numbers `{i | i < n + 1}` is non-empty.


theorem FirstOrder.Language.Hom.mem_range_self :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (f : FirstOrder.Language.Hom L M N) (x : M),
      f x ∈ FirstOrder.Language.Hom.range f :=
  by sorry

This theorem states that for any first-order language `L`, and any two types `M` and `N` that have a `FirstOrder.Language.Structure` over `L`, for any homomorphism `f` from `M` to `N` and any element `x` in `M`, the result of applying `f` to `x` is in the range of `f`. In other words, if you have a function `f` that maps elements of `M` to `N`, every output of `f` is indeed in the set of all possible outputs of `f`.

For any first-order language L, any homomorphism f between types M and N with structures over L, and any x in M, we have f(x) ∈ range(f).


theorem LocalRing.eq_maximalIdeal :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : LocalRing R] {I : Ideal R},
      Ideal.IsMaximal I → I = LocalRing.maximalIdeal R :=
  by sorry

The theorem `LocalRing.eq_maximalIdeal` states that for any commutative semiring `R` that is also a local ring, if `I` is a maximal ideal in `R`, then `I` is equal to the maximal ideal of `R` defined as the set of non-units in `R`. In other words, in a local ring, the maximal ideal is unique and contains precisely the non-unit elements.

In a commutative semiring that is a local ring, the maximal ideal is equal to the set of non-units.


theorem Array.size_pop : ∀ {α : Type u_1} (a : Array α), Array.size (Array.pop a) = Array.size a - 1 := by sorry

This theorem, `Array.size_pop`, states that for all types `α` and every array `a` of type `α`, the size of the array obtained by "popping" `a` (i.e., removing its last element using the `Array.pop` operation) is equal to the size of the original array `a` minus 1. This is equivalent to saying that the `Array.pop` operation decreases the size of an array by one unit.

For all types `α` and arrays `a` of length `n` of type `α`, the length of `Array.pop a` is `n - 1`.


theorem ZMod.nat_cast_val :
    ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] [inst_1 : NeZero n] (i : ZMod n), ↑(ZMod.val i) = ZMod.cast i := by sorry

The theorem `ZMod.nat_cast_val` states that for any non-zero natural number `n` and for any ring `R`, the natural number value of an integer modulo `n` (denoted by `ZMod.val i`) when type casted to `R` is equal to the direct cast of that integer modulo `n` to `R` (denoted by `ZMod.cast i`). In other words, casting the value of an element of `ZMod n` to a ring gives the same result as first finding its value in natural numbers and then casting to the ring.

For any ring R and non-zero natural number n, the conversion of an integer modulo n to R, using `ZMod.val`, is equal to the direct cast of the same integer modulo n to R, using `ZMod.cast`.


theorem MeasureTheory.AEStronglyMeasurable'.congr :
    ∀ {α : Type u_1} {β : Type u_2} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f g : α → β},
      MeasureTheory.AEStronglyMeasurable' m f μ →
        f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.AEStronglyMeasurable' m g μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable'.congr` states that for any two functions `f` and `g` from a set `α` to a topological space `β`, with `α` equipped with two measurable spaces `m` and `m0` and a measure `μ`, if `f` is `μ`-almost everywhere equal to an `m`-strongly measurable function, and `f` is `μ`-almost everywhere equal to `g`, then `g` is also `μ`-almost everywhere equal to an `m`-strongly measurable function. Here, `μ`-almost everywhere equal means that the set where the two functions disagree has measure zero.

If `f` is almost everywhere equal to an `m`-strongly measurable function and almost everywhere equal to `g`, then `g` is almost everywhere equal to an `m`-strongly measurable function. (Assuming `α` is a measurable space with respect to measures `m` and `m0`, and `β` is a topological space.)


AffineMap.decomp

/-- Decomposition of an affine map in the special case when the point space and vector space
are the same.  -/
theorem AffineMap.decomp :
    ∀ {k : Type u_1} {V1 : Type u_2} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddCommGroup V2] [inst_4 : Module k V2] (f : V1 →ᵃ[k] V2), ⇑f = ⇑f.linear + fun x => f 0 :=
  by sorry

This theorem, named `AffineMap.decomp`, states that for any affine map `f` from one vector space `V1` to another vector space `V2` over a ring `k`, the application of `f` can be decomposed into the sum of the application of the linear part of `f` and the application of `f` to zero. Here, both vector spaces `V1` and `V2` are also assumed to be additively commutative groups.

For any affine map f from vector space V1 to vector space V2 over ring k, f(x) = L(x) + f(0), where L is the linear part of f.


theorem Nat.succ_inj' : ∀ {a b : ℕ}, Nat.succ a = Nat.succ b ↔ a = b := by sorry

This theorem, `Nat.succ_inj'`, states that for any two natural numbers `a` and `b`, the successor of `a` is equal to the successor of `b` if and only if `a` is equal to `b`. In other words, it guarantees the injectivity of the successor function on natural numbers: different natural numbers will have different successors.

The successor function is injective on natural numbers: for all natural numbers a and b, if succ(a) = succ(b), then a = b.


theorem tendsto_atTop_of_eventually_const :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {ι : Type u_3} [inst_1 : SemilatticeSup ι] [inst_2 : Nonempty ι]
      {u : ι → X} {i₀ : ι}, (∀ i ≥ i₀, u i = x) → Filter.Tendsto u Filter.atTop (nhds x) :=
  by sorry

The theorem `tendsto_atTop_of_eventually_const` asserts that for any type `X` with a topology, a type `ι` with a semilattice structure and a nonempty property, a function `u` mapping from `ι` to `X`, an element `x` in `X` and an element `i₀` in `ι`, if for all `i` greater than or equal to `i₀`, `u i` equals `x`, then the function `u` tends to `x` at infinity (i.e., the limit of `u` as `i` approaches infinity in `ι` is `x`). In other words, if a function is constant after some point, then the limit of the function at infinity is the constant value.

If a function from an ordered index type with a semilattice structure to a topological space is constant after some index, then the function converges to that constant value at infinity.


theorem Matrix.updateRow_transpose :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {j : n} {c : m → α} [inst : DecidableEq n],
      Matrix.updateRow (Matrix.transpose M) j c = Matrix.transpose (Matrix.updateColumn M j c) :=
  by sorry

The theorem `Matrix.updateRow_transpose` states that for any matrix `M` with entries of type `α`, row indices of type `m`, column indices of type `n`, any column index `j` and any function `c` from `m` to `α`, updating the `j`-th row of the transpose of `M` with the values given by `c` is the same as taking the transpose of the matrix formed by updating the `j`-th column of `M` with the values given by `c`. This is under the assumption that the equality of elements of type `n` is decidable.

For any matrix M with decidably equal column indices and entries of type α, updating the j-th row of its transpose with values given by a function c is equivalent to taking the transpose of the matrix obtained by updating the j-th column of M with values given by c.


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

This theorem states that for any two natural numbers `m` and `n`, if `n` is positive (greater than 0), then the greatest common divisor (gcd) of `m` and `n` is also positive. In mathematical terms, it asserts that for all natural numbers `m` and `n`, where `n > 0`, the greatest common divisor `gcd(m, n) > 0`.

For all natural numbers `m` and `n` with `n > 0`, the greatest common divisor `gcd(m, n)` is a positive number.


theorem Complex.sinh_add :
    ∀ (x y : ℂ), Complex.sinh (x + y) = Complex.sinh x * Complex.cosh y + Complex.cosh x * Complex.sinh y := by sorry

The theorem `Complex.sinh_add` states that for all complex numbers `x` and `y`, the hyperbolic sine of the sum of `x` and `y` is equal to the product of the hyperbolic sine of `x` and the hyperbolic cosine of `y` added to the product of the hyperbolic cosine of `x` and the hyperbolic sine of `y`. In terms of mathematical notation, this can be written as:

For all $x, y \in \mathbb{C}$, $\sinh(x + y) = \sinh(x) \cdot \cosh(y) + \cosh(x) \cdot \sinh(y)$.

This is the addition formula for the complex hyperbolic sine function.

The complex hyperbolic sine function satisfies the addition formula: $\sinh(x + y) = \sinh(x) \cosh(y) + \cosh(x) \sinh(y)$, for all $x, y \in \mathbb{C}$.


theorem CategoryTheory.braiding_tensorUnit_left :
    ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.BraidedCategory C] (X : C),
      (β_ (𝟙_ C) X).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.leftUnitor X).hom
          (CategoryTheory.MonoidalCategory.rightUnitor X).inv :=
  by sorry

The theorem `CategoryTheory.braiding_tensorUnit_left` states that for any type `C` which forms a Category, a Monoidal Category, and a Braided Category, and for any `X` of type `C`, the homomorphism of the braiding of the tensor unit and `X` is equal to the composition of the homomorphism of the left unitor of `X` and the inverse of the homomorphism of the right unitor of `X`.

In other words, in the context of category theory, a braiding of the tensor unit and another object `X` in a braided monoidal category `C` is equivalent to the composition of certain natural transformations associated with `X` (left and right unitors).

In a braided monoidal category, the braiding of the tensor unit and an object X is equivalent to the composition of X's left unitor homomorphism and the inverse of its right unitor homomorphism.


Monoid.closure.isSubmonoid

theorem Monoid.closure.isSubmonoid : ∀ {M : Type u_1} [inst : Monoid M] (s : Set M), IsSubmonoid (Monoid.Closure s) :=
  by sorry

This theorem states that for any type `M` which is a monoid, and any set `s` of elements of `M`, the monoid closure of `s` (denoted by `Monoid.Closure s`) forms a submonoid of `M`. In other words, the set of elements that can be obtained by repeatedly applying the monoid operation to the elements of `s` (and their results) is itself a monoid.

For any monoid `M` and set `s` of its elements, `Monoid.Closure s` is a submonoid of `M`.


theorem Nat.totient_pos : ∀ {n : ℕ}, 0 < n → 0 < Nat.totient n := by sorry

This theorem states that for any natural number `n`, if `n` is greater than zero, then the value of Euler's totient function at `n` is also greater than zero. Euler's totient function, denoted as `Nat.totient n` in Lean, counts the number of natural numbers strictly less than `n` that are coprime with `n`, i.e., their greatest common divisor is 1. Hence, this theorem asserts that any positive natural number has at least one positive natural number less than itself that is coprime to it.

For any natural number `n` greater than zero, the value of Euler's totient function `Nat.totient n` is positive.


theorem gt_iff_lt : ∀ {α : Type u} [inst : LT α] {x y : α}, x > y ↔ y < x := by sorry

This theorem, named `gt_iff_lt`, states that for any type `α` that has a less than (`<`) operation, and for any two elements `x` and `y` of this type, `x` is greater than `y` if and only if `y` is less than `x`. Basically, it formalizes the intuitive notion of the relationship between 'greater than' and 'less than' in any ordered type.

For all types `α` with a `<` operation and all `x, y` in `α`, `x` is greater than `y` if and only if `y` is less than `x`.


/-- Characterization of the elements of the uniformity in terms of the extended distance  -/
theorem mem_uniformity_edist :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set (α × α)},
      s ∈ uniformity α ↔ ∃ ε > 0, ∀ {a b : α}, edist a b < ε → (a, b) ∈ s :=
  by sorry

This theorem characterizes the elements of the uniformity in a pseudo-emetric space in terms of the extended distance. For any type `α` that is a pseudo-emetric space, and any set `s` of pairs of elements of `α`, the theorem states that `s` is in the uniformity of `α` if and only if there exists a positive real number `ε` such that for all pairs `(a, b)` of elements of `α`, if the extended distance between `a` and `b` is less than `ε`, then the pair `(a, b)` is in `s`.

A set `s` of pairs of elements in a pseudo-metric space `α` lies in the uniformity of `α` if and only if there exists a positive real number `ε` such that every pair of elements `a` and `b` with extended distance less than `ε` is in `s`.


theorem Matrix.transpose_map :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} {f : α → β} {M : Matrix m n α},
      Matrix.map (Matrix.transpose M) f = Matrix.transpose (Matrix.map M f) :=
  by sorry

The theorem `Matrix.transpose_map` states that for any matrix `M` with entries of type `α`, indexed by types `m` and `n`, and any function `f` mapping from `α` to `β`, the result of first transposing the matrix `M` and then applying the function `f` to each entry (i.e., `Matrix.map (Matrix.transpose M) f`) is the same as the result of first applying the function `f` to each entry of `M` and then transposing the result (i.e., `Matrix.transpose (Matrix.map M f)`). In mathematical terms, this theorem is asserting the commutativity of the operations of matrix transposition and applying a function to each entry of a matrix.

For any matrix `M` with entries of type `α` and any function `f` from `α` to `β`, the transposition of `Matrix.map M f` is equal to `Matrix.map (Matrix.transpose M) f`.


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

This theorem states that for any type `K` that is a division monoid and has a distributive negation operation, the division of the negation of `a` by the negation of `b` equals the division of `a` by `b`. In mathematical terms, this can be expressed as: for all `a` and `b` in `K`, `-a / -b = a / b`.

For any division monoid `K` with distributive negation, `-a / -b = a / b` for all `a, b` in `K`.


theorem MeasureTheory.FiniteMeasure.tendsto_iff_forall_testAgainstNN_tendsto :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
      {γ : Type u_3} {F : Filter γ} {μs : γ → MeasureTheory.FiniteMeasure Ω} {μ : MeasureTheory.FiniteMeasure Ω},
      Filter.Tendsto μs F (nhds μ) ↔
        ∀ (f : BoundedContinuousFunction Ω NNReal),
          Filter.Tendsto (fun i => MeasureTheory.FiniteMeasure.testAgainstNN (μs i) f) F
            (nhds (MeasureTheory.FiniteMeasure.testAgainstNN μ f)) :=
  by sorry

This theorem states that for any given measurable and topological space with the open sets also being measurable, a filter and a sequence of finite measures defined on the space, and a finite measure, the sequence of finite measures converges to the given finite measure if and only if for every bounded continuous function from the space to the non-negative real numbers, the sequence of results obtained by integrating the function against the measures (i.e., testing the function against the measures) also converges to the result obtained by integrating the function against the given finite measure. This is with respect to the respective neighborhood filters of the measure and the integrals.

A sequence of measurable finite measures on a measurable and topological space converges to a given finite measure if and only if the sequence of integrals of every bounded continuous function against the measures converges to the integral of that function against the given measure.


/-- **Alias** of the forward direction of `isCompact_iff_ultrafilter_le_nhds`. -/
theorem IsCompact.ultrafilter_le_nhds :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsCompact s → ∀ (f : Ultrafilter X), ↑f ≤ Filter.principal s → ∃ x ∈ s, ↑f ≤ nhds x :=
  by sorry

The theorem `IsCompact.ultrafilter_le_nhds` states that for any type `X` with a topological space structure, and any set `s` of `X`, if `s` is compact then for every ultrafilter `f`, if `f` is contained in the principal filter of `s`, then there exists an `x` in `s` such that `f` is contained in the neighborhood filter at `x`. In other words, for compact sets, any ultrafilter that is a superset of the set can be "translated" to be a subset of the neighborhood filter of some point in the set.

For any compact subset `s` of a topological space `X` and any ultrafilter `f` containing `s`, there exists an element `x` in `s` such that `f` is contained in the neighborhood filter of `x`.


theorem Polynomial.eq_of_monic_of_associated :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.Monic p → Polynomial.Monic q → Associated p q → p = q :=
  by sorry

This theorem states that for any semiring `R`, if `p` and `q` are polynomials over `R`, and both `p` and `q` are monic (i.e., their leading coefficients are 1), then if `p` and `q` are associated (meaning that one can be obtained from the other by multiplication with a unit), it must be the case that `p` is equal to `q`. This establishes a limiting condition on the "associated" relationship for monic polynomials, implying that if two monic polynomials are associated, they must actually be the same polynomial.

For any semiring `R`, if `p` and `q` are monic polynomials over `R`, then `p = q` whenever `p` and `q` are associates.


theorem Subgroup.leftTransversals.diff_mul_diff :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {A : Type u_2} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
      (R S T : ↑(Subgroup.leftTransversals ↑H)) [inst_2 : Subgroup.FiniteIndex H],
      Subgroup.leftTransversals.diff ϕ R S * Subgroup.leftTransversals.diff ϕ S T =
        Subgroup.leftTransversals.diff ϕ R T :=
  by sorry

This theorem, `Subgroup.leftTransversals.diff_mul_diff`, is stating that for any group `G` with a subgroup `H`, and any commutative group `A`, given a group homomorphism `ϕ` from the subgroup `H` to `A`, and three left transversals `R`, `S`, and `T` of the subgroup `H` in `G`, under the condition that `H` has finite index in `G`, the difference of `R` and `S` using the homomorphism `ϕ`, multiplied by the difference of `S` and `T` using the same homomorphism, equals the difference of `R` and `T` using the homomorphism `ϕ`. Essentially, this theorem demonstrates a distributive property of the difference operation over the multiplication operation for left transversals of subgroups.

Given a group `G` with subgroup `H` of finite index, for any commutative group `A`, group homomorphism `ϕ` from `H` to `A`, and left transversals `R`, `S`, and `T` of `H` in `G`, we have `ϕ(R - S) * ϕ(S - T) = ϕ(R - T)`.


theorem PartialHomeomorph.extend_target :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H),
      (PartialHomeomorph.extend f I).target = ↑(ModelWithCorners.symm I) ⁻¹' f.target ∩ Set.range ↑I :=
  by sorry

The theorem `PartialHomeomorph.extend_target` takes in a non-trivially normed field `𝕜`, a normed add commutative group `E`, a normed space over `𝕜` and `E`, and two topological spaces `M` and `H`. The theorem also takes in a partial homeomorphism `f` from `M` to `H`, and a ModelWithCorners `I` from `𝕜` to `E` to `H`. The theorem states that the target of the extension of the partial homeomorphism `f` using `I` is equal to the preimage of the target of `f` under the inverse of `I`, intersected with the range of `I`. This theorem essentially relates the target of the extended partial homeomorphism with the target of the original partial homeomorphism and the model with corners.

The theorem asserts that the target of the extension of a partial homeomorphism between topological spaces using a ModelWithCorners is equal to the preimage of the original target under the inverse of the ModelWithCorners, intersected with the range of the ModelWithCorners.


theorem CategoryTheory.IsIso.inv_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
      CategoryTheory.inv (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem states that in any category `C`, for any object `X` in `C`, the inverse of the identity morphism on `X` is the identity morphism on `X` itself. In the language of category theory, this theorem asserts that the identity morphism is its own inverse.

In any category, the identity morphism is equal to its own inverse for every object.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.11 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.sphere x ε) = (dist y x = ε) := by sorry

This theorem, from the PseudoMetric module of the Mathlib Topology MetricSpace library, states that for any type `α` which is equipped with a pseudometric space structure, any two points `x` and `y` of type `α`, and any real number `ε`, the point `y` is in the sphere of radius `ε` centered at `x` if and only if the distance between `y` and `x` is `ε`. This essentially serves as a defining property of the sphere in a pseudometric space. In mathematical terms, we say that a point `y` belongs to the ε-sphere centered at `x` (denoted `Metric.sphere x ε` in lean) if and only if the pseudometric distance from `y` to `x` is exactly `ε`.

For any pseudometric space `(α, d)`, points `x, y : α`, and real `ε`, `y` belongs to the sphere of radius `ε` around `x` if and only if `d(x, y) = ε`.


theorem EuclideanDomain.gcd_zero_left :
    ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] (a : R), EuclideanDomain.gcd 0 a = a := by sorry

This theorem, named `EuclideanDomain.gcd_zero_left`, states that for any type `R` that is an instance of a `EuclideanDomain` and has decidable equality, the greatest common divisor (gcd) of 0 and any element `a` of `R` is `a` itself. This aligns with the definition of the gcd in number theory, where the gcd of 0 and a number is the number itself.

For any EuclideanDomain `R` with decidable equality, the greatest common divisor of 0 and any element `a` in `R` is equal to `a`.


MeasureTheory.Submartingale.neg

theorem MeasureTheory.Submartingale.neg :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : Preorder E]
      [inst_5 : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      MeasureTheory.Submartingale f ℱ μ → MeasureTheory.Supermartingale (-f) ℱ μ :=
  by sorry

This theorem states that for any submartingale `f` with respect to a filtration `ℱ` and a measure `μ`, the negation of `f` (`-f`) is a supermartingale with respect to the same filtration and measure. This is applicable in a measurable space `Ω` with elements of type `E`, where `E` is a complete real normed space. The index type `ι` is assumed to have a preorder relation. This theorem shows the relationship between submartingales and supermartingales under negation in measure theory.

For any submartingale `f` in a complete real normed space `Ω` with respect to a filtration `ℱ` and a measure `μ`, the negation `-f` is a supermartingale with respect to the same filtration and measure.


Valuation.ext

theorem Valuation.ext :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
      {v₁ v₂ : Valuation R Γ₀}, (∀ (r : R), v₁ r = v₂ r) → v₁ = v₂ :=
  by sorry

This theorem states that for any ring `R` and any linearly ordered commutative monoid with zero `Γ₀`, if two valuations `v₁` and `v₂` from `R` to `Γ₀` map every element of `R` to the same value, then `v₁` and `v₂` are identical. In other words, two valuations are considered equal if they agree on all elements of the ring.

Two valuations from a ring to a linearly ordered commutative monoid with zero are equal if and only if they agree on all ring elements.


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

This theorem states that for any type `α` that forms a Heyting Algebra, for any two Heyting regular elements `a` and `b` of type `α`, the property that the coercion of `a` is less than or equal to the coercion of `b` is equivalent to the fact that `a` is less than or equal to `b`. Here, coercion means converting from the subtype of regular elements to the main type. This essentially says that the order relation (less than or equal to) on the subtype of regular elements corresponds to the order relation on the original type.

For any Heyting Algebra type `α`, the relation `a ≤ b` between regular elements `a` and `b` is equivalent to the coercion `coe a ≤ coe b` on the subtype of regular elements.


theorem continuousAt_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop} {x : Subtype p}, ContinuousAt Subtype.val x := by sorry

The theorem `continuousAt_subtype_val` states that for any topological space `X` and any predicate `p` defined on `X`, the function `Subtype.val` is continuous at any point `x` of the subtype `p`. In mathematical terms, it means that as points in the subtype `p` approach `x`, their corresponding elements in `X` (obtained via `Subtype.val`) tend towards the element in `X` corresponding to `x`.

For any topological space X and predicate p on X, the function Subtype.val is continuous at every point x in the subtype p.


theorem Polynomial.rootMultiplicity_zero :
    ∀ {R : Type u} [inst : Ring R] {x : R}, Polynomial.rootMultiplicity x 0 = 0 := by sorry

This theorem states that for any ring `R` and any element `x` of `R`, the root multiplicity of `x` in the zero polynomial is zero. In other words, no value is a root of the zero polynomial in a ring, or equivalently, the zero polynomial has no roots, hence its root multiplicity is zero for every element of the ring.

The zero polynomial has no roots in any ring, hence its root multiplicity for every element is zero.


TopologicalSpace.Compacts.ext

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

This theorem states that for any type `α` equipped with a topological space structure, if we have two compact subspaces `s` and `t` of this topological space, and if the underlying sets of `s` and `t` are equal, then `s` and `t` must be the same compact subspace. In other words, in a given topology, compact subspaces are uniquely determined by their underlying sets.

In a topological space, two compact subsets with equal underlying sets are equal as subspaces.


theorem UFModel.Models.size_eq :
    ∀ {α : Type u_1} {arr : Array (UFNode α)} {n : ℕ} {m : UFModel n}, UFModel.Models arr m → n = Array.size arr := by
  sorry

The theorem `UFModel.Models.size_eq` states that for any type `α`, any array `arr` of Union-Find Nodes (`UFNode α`), any natural number `n`, and any Union-Find model `m` of size `n`, if the array `arr` models the Union-Find model `m` (as specified by the `UFModel.Models` function), then `n` is equal to the size of the array `arr` (`Array.size arr`). Essentially, this theorem is asserting that the size of the Union-Find model and the size of the array that models it are always equal.

For any Union-Find model `m` of size `n` and any array `arr` of `UFNode α` that models `m`, we have `n = Array.size arr`.


theorem Fintype.card_piFinset :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {δ : α → Type u_4} (t : (a : α) → Finset (δ a)),
      (Fintype.piFinset t).card = Finset.prod Finset.univ fun a => (t a).card :=
  by sorry

The theorem `Fintype.card_piFinset` states that for all types `α` with decidable equality and for which a finite set exists (`Fintype α`), and for a function `δ` mapping elements of `α` to another type, given a function `t` that maps every element of `α` to a finite set of `δ a`, the cardinality of the `piFinset` generated by `t` is equal to the product of the cardinalities of the individual finite sets `t a` for each element `a` in the universal finite set of `α`. In mathematical terms, this theorem is about the cardinality of the product of finite sets.

For any type `α` with decidable equality and a finite number of elements, and for a function `t : α → Set`, the cardinality of the product `∏ x : α. t x` equals the product of the cardinalities of the sets `t x` for all `x` in `α`.


theorem DFinsupp.smul_apply :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : Monoid γ] [inst_1 : (i : ι) → AddMonoid (β i)]
      [inst_2 : (i : ι) → DistribMulAction γ (β i)] (b : γ) (v : Π₀ (i : ι), β i) (i : ι), (b • v) i = b • v i :=
  by sorry

This theorem states that for any types `ι`, `γ`, and a type `β` which is a function of `ι`, given a monoid structure on `γ`, an add monoid structure on `β i` for each `i : ι`, and a distributive multiplication action of `γ` on `β i` for each `i : ι`, the scalar multiplication (`•`) of a value `b : γ` and a Direct Sum (`Π₀ (i : ι), β i`) applied to `i` is equal to the scalar multiplication of `b` and the function `v i`. In other words, the theorem establishes the property of scalar multiplication in the context of a Direct Sum, meaning scalar multiplication can be interchanged with application of the Direct Sum, a specific form of function application.

For any monoid `γ` and a family `β i` of add monoids with distributive `γ`-actions, scalar multiplication by an element `b : γ` in `γ` commutes with application of the direct sum `Π₀ (i : ι), β i`: `b • (∑ i, β i) = ∑ i, b • β i`.


/-- **Alias** of `mul_div_cancel`. -/
theorem mul_div_cancel'_right : ∀ {G : Type u_3} [inst : CommGroup G] (a b : G), a * (b / a) = b := by sorry

This theorem, named `mul_div_cancel'_right`, is applicable to any type `G` that forms a commutative group (indicated by `CommGroup G`). It states that for any two elements `a` and `b` of the group, the product of `a` and the fraction `b / a` is equal to `b`. In mathematical notation, this theorem asserts that for all `a` and `b` in `G`, `a * (b / a) = b`. This theorem is an alias for another theorem named `mul_div_cancel`.

For any commutative group `G` and elements `a, b` in `G`, `a * (b / a) = b`.


theorem strictAnti_mul_right :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] [inst_1 : ExistsAddOfLE α] {a : α},
      a < 0 → StrictAnti fun x => x * a :=
  by sorry

The theorem `strictAnti_mul_right` states that for any type `α` that has a structure of a strict ordered semiring and a proof of existence of addition for less than or equal numbers, and for any element `a` of `α` that is less than zero, the function that multiplies `x` by `a` is strictly antitone. In other words, for all `x` and `y` from `α` such that `x` is less than `y`, `y * a` is in fact less than `x * a`. This represents the idea that multiplication by a negative number reverses the order of numbers.

For any strict ordered semiring type `α` with proven existence of addition for less than or equal numbers, and for any negative element `a` of `α`, the function `x => x * a` is strictly antitone, i.e., for all `x` and `y` in `α` with `x < y`, `y * a < x * a`.


theorem Relation.reflexive_reflTransGen : ∀ {α : Type u_1} {r : α → α → Prop}, Reflexive (Relation.ReflTransGen r) := by
  sorry

This theorem states that, for any type `α` and any binary relation `r` on `α`, the reflexive-transitive closure of `r` is a reflexive relation. In other words, for any element of `α`, the element is related to itself in the reflexive-transitive closure of `r`.

The reflexive-transitive closure of a relation `r` is the smallest reflexive and transitive relation that contains `r`. So, this theorem is stating a fundamental property of reflexive-transitive closures: every element is related to itself.

The reflexive-transitive closure of a binary relation is a reflexive relation.


theorem isUnit_pow_iff : ∀ {M : Type u_1} [inst : Monoid M] {n : ℕ} {a : M}, n ≠ 0 → (IsUnit (a ^ n) ↔ IsUnit a) := by
  sorry

The theorem `isUnit_pow_iff` states that for any type `M` that forms a Monoid and any non-zero natural number `n`, an element `a` of the Monoid `M` is a unit if and only if `a` raised to the power `n` is a unit. A unit in this context is defined as an element that has a two-sided inverse.

For any monoid M and natural number n greater than 0, an element a of M is a unit if and only if a^n is a unit.


HasDerivAtFilter.add

theorem HasDerivAtFilter.add :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {f' g' : F} {x : 𝕜} {L : Filter 𝕜},
      HasDerivAtFilter f f' x L → HasDerivAtFilter g g' x L → HasDerivAtFilter (fun y => f y + g y) (f' + g') x L :=
  by sorry

The theorem `HasDerivAtFilter.add` states that for any non-trivially normed field `𝕜`, normed additive commutative group `F` and normed space over `𝕜` and `F`, given two functions `f` and `g` from `𝕜` to `F`, their derivatives `f'` and `g'` at a point `x` along a filter `L`, if `f` has the derivative `f'` at `x` along `L` and `g` has the derivative `g'` at `x` along `L`, then the function `h` defined as `h(y) = f(y) + g(y)` has the derivative `f' + g'` at the same point `x` along the same filter `L`. In other words, it says that the derivative of the sum of two functions is the sum of their derivatives, under the given conditions.

For any non-trivially normed field `𝕜`, normed additive commutative group `F`, and normed space over `𝕜` and `F`, if functions `f` and `g` from `𝕜` to `F` have derivatives `f'` and `g'` at a point `x` along filter `L`, then the function `h(y) = f(y) + g(y)` has derivative `f' + g'` at `x` along `L`.


theorem Multiset.cons_le_cons : ∀ {α : Type u_1} {s t : Multiset α} (a : α), s ≤ t → a ::ₘ s ≤ a ::ₘ t := by sorry

The theorem `Multiset.cons_le_cons` states that for any type `α`, and for any multiset `s` and `t` of that type, and for any element `a` of type `α`, if `s` is less than or equal to `t`, then the multiset formed by adding `a` to `s` (denoted as `a ::ₘ s`) is less than or equal to the multiset formed by adding `a` to `t` (denoted as `a ::ₘ t`). This theorem is about the order preservation of the `cons` operation in the context of multisets.

For any type `α` and multisets `s` and `t` of type `α`, if `s ≤ t`, then `a ::ₘ s ≤ a ::ₘ t` for all `a` of type `α`.


IsBoundedBilinearMap.hasFDerivAt

theorem IsBoundedBilinearMap.hasFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {b : E × F → G}
      (h : IsBoundedBilinearMap 𝕜 b) (p : E × F), HasFDerivAt b (IsBoundedBilinearMap.deriv h p) p :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, and `G`, and the associated normed spaces, if the function `b` from pairs of `E` and `F` to `G` is a bounded bilinear map, then at any point `p` from the pair of `E` and `F`, `b` has a derivative. The derivative of `b` at `p` is the result of the function `IsBoundedBilinearMap.deriv` applied to `b` and `p`. In other words, the change in `b` near `p` can be accurately approximated by the function `IsBoundedBilinearMap.deriv h p`.

Given a non-trivially normed field `𝕜`, and normed additive commutative groups `E`, `F`, and `G`, if `b` is a bounded bilinear map from `E × F` to `G`, then `b` has a derivative at any point in `E × F`, which is given by the function `IsBoundedBilinearMap.deriv h` where `h` is the evaluation map at that point.


theorem Nat.totient_one : Nat.totient 1 = 1 := by sorry

This theorem states that the value of Euler's totient function for the number 1 is equal to 1. Euler's totient function, denoted as $\phi(n)$, counts the number of natural numbers that are less than $n$ and coprime with $n$. In this case, since $1$ is the only natural number less than or equal to $1$ and coprime with $1$, the value of $\phi(1)$ is $1$.

The Euler phi function equals 1 for the input 1. (i.e., φ(1) = 1)


theorem List.reverse_injective : ∀ {α : Type u}, Function.Injective List.reverse := by sorry

The theorem `List.reverse_injective` states that for any type `α`, the function `List.reverse`, which reverses a list, is injective. In other words, if `List.reverse` of two lists are equal, then the two original lists must be identical. This injectiveness property ensures that no information is lost when a list is reversed, and each reversed list has a unique original list that it came from.

For any type α, the function List.reverse from lists of α to lists of α is an injection.


theorem Complex.sin_pi_div_two : Complex.sin (↑Real.pi / 2) = 1 := by sorry

This theorem states that the sine of pi divided by two (or π/2) in the complex numbers is equal to one. In mathematical terms, this translates to the following equation: sin(π/2) = 1. Note that the sine function used here is the complex sine function, defined in terms of the complex exponential function, and π is defined as twice the zero of the cosine function in the interval [1,2]. This theorem aligns with the well-known result from trigonometry in the real numbers.

In the complex numbers, the sine of π/2 is equal to 1.


theorem Complex.exp_eq_exp_re_mul_sin_add_cos :
    ∀ (x : ℂ), Complex.exp x = Complex.exp ↑x.re * (Complex.cos ↑x.im + Complex.sin ↑x.im * Complex.I) := by sorry

This theorem states that for any complex number `x`, the exponential of `x` is equal to the product of the exponential of the real part of `x` and the sum of the cosine of the imaginary part of `x` and the product of the sine of the imaginary part of `x` and the imaginary unit `I`. In mathematical terms, it expresses the identity: $e^{x} = e^{Re(x)} * (cos(Im(x)) + sin(Im(x)) * i)$ for all complex numbers $x$. Here, $Re(x)$ and $Im(x)$ respectively denote the real and imaginary parts of the complex number $x$, and $i$ is the imaginary unit.

For any complex number x, the exponential function equals the product of the exponential of its real part and the cosine of its imaginary part plus the sine of its imaginary part times the imaginary unit i: $e^x = e^{Re(x)} \cdot (\cos(Im(x)) + \sin(Im(x)) \cdot i)$.


theorem hnot_le_iff_codisjoint_right :
    ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢a ≤ b ↔ Codisjoint a b := by sorry

The theorem `hnot_le_iff_codisjoint_right` states that for all types `α` that form a Coheyting algebra, and for any two elements `a` and `b` of that type, `a` is not less than or equal to `b` if and only if `a` and `b` are codisjoint. Here, being codisjoint means that for all elements `x`, if `a` and `b` are both less than or equal to `x`, then the top element of the order is less than or equal to `x`. This essentially means `a` and `b` are as far apart as possible in the order, given that the supremum of `a` and `b` is the top element.

For any type α forming a complete lattice and any elements a, b in α, a ≤ b if and only if a ∨ b = ⊤ (where ∨ is the lattice join and ⊤ is the top element) if and only if a and b are codisjoint.


/-- The first cyclotomic polyomial is `X - 1`.  -/
theorem Polynomial.cyclotomic_one : ∀ (R : Type u_1) [inst : Ring R], Polynomial.cyclotomic 1 R = Polynomial.X - 1 := by
  sorry

The theorem `Polynomial.cyclotomic_one` states that, for any type `R` which has a structure of a ring, the first cyclotomic polynomial with coefficients in `R` is `X - 1`. In other words, when you calculate the first cyclotomic polynomial in any ring, this polynomial is equivalent to the polynomial `X - 1`, where `X` is the polynomial variable.

The first cyclotomic polynomial over any ring `R` equals `X - 1`.


theorem Multiset.prod_dvd_prod_of_le :
    ∀ {α : Type u_2} [inst : CommMonoid α] {s t : Multiset α}, s ≤ t → Multiset.prod s ∣ Multiset.prod t := by sorry

This theorem states that for any type `α` that has a structure of a commutative monoid, given two multisets `s` and `t` of type `α`, if `s` is a subset of (or equal to) `t`, then the product of elements in `s` divides the product of elements in `t`. In mathematical notation, this can be represented as: if $s \leq t$, then $\prod s | \prod t$.

If `α` is a commutative monoid type and `s` is a subset of `t`, then $\prod s | \prod t$.


theorem Equiv.Perm.support_pow_le :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (σ : Equiv.Perm α) (n : ℕ),
      Equiv.Perm.support (σ ^ n) ≤ Equiv.Perm.support σ :=
  by sorry

The theorem `Equiv.Perm.support_pow_le` states that for any type `α` with decidable equality and is finite, any permutation `σ` of `α`, and any natural number `n`, the set of non-fixed points of the `n`-th power of the permutation `σ` is a subset of the set of non-fixed points of the permutation `σ` itself. In other words, if a point is not moved by the `n`-th power of a permutation, it is also not moved by the original permutation.

For any finite type `α` with decidable equality, any permutation `σ` of `α`, and natural number `n`, the set of elements not fixed by the `n`-th power of `σ` is a subset of the set of elements not fixed by `σ`.


theorem LieSubmodule.ucs_succ :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
      (N : LieSubmodule R L M) (k : ℕ), LieSubmodule.ucs (k + 1) N = LieSubmodule.normalizer (LieSubmodule.ucs k N) :=
  by sorry

The theorem `LieSubmodule.ucs_succ` states that for any commutative ring `R`, Lie ring `L`, additive commutative group `M`, module `M` over `R`, Lie ring module `M` over `L`, and Lie module `M` over the Lie algebra `L` with coefficients in the ring `R`, any Lie submodule `N` of `M` over the Lie algebra `L` with coefficients in the ring `R`, and any natural number `k`, the `k + 1`-th term of the upper central series of `N` equals the normalizer of the `k`-th term of the upper central series of `N` in the Lie algebra `L` with coefficients in the ring `R`.

In simpler terms, this theorem establishes a recursive relationship for calculating the terms of the upper central series of a Lie submodule.

For any Lie submodule `N` of a Lie module `M` over a Lie algebra `L` with coefficients in a commutative ring `R`, the `(k+1)`-th term of the upper central series of `N` is the normalizer of the `k`-th term in `L` for all natural numbers `k`.


theorem Nat.exists_eq_add_of_lt : ∀ {m n : ℕ}, m < n → ∃ k, n = m + k + 1 := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` is less than `n`, then there exists a natural number `k` such that `n` is equal to `m + k + 1`. In other words, if one natural number is smaller than another, you can find some natural number that when added to the smaller number and one, gives you the larger number.

For any natural numbers `m` and `n` with `m < n`, there exists a natural number `k` such that `n = m + k + 1`.


theorem map_sum_eq_map_sum :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : AddCommMonoid α]
      [inst_2 : AddCommMonoid β] {A : Set α} {n : ℕ} [inst_3 : AddFreimanHomClass F A β n] (f : F) {s t : Multiset α},
      (∀ ⦃x : α⦄, x ∈ s → x ∈ A) →
        (∀ ⦃x : α⦄, x ∈ t → x ∈ A) →
          Multiset.card s = n →
            Multiset.card t = n →
              Multiset.sum s = Multiset.sum t →
                Multiset.sum (Multiset.map (⇑f) s) = Multiset.sum (Multiset.map (⇑f) t) :=
  by sorry

The theorem `map_sum_eq_map_sum` states that for any type `F` with a function-like structure from `α` to `β`, and any commutative additive monoid structures on `α` and `β`, given a set `A` of `α`, a natural number `n`, and an `AddFreimanHomClass` instance from `F A β n`, if we have a function `f` of type `F` and two multisets `s` and `t` of type `α` such that all elements of `s` and `t` belong to `A`, and both `s` and `t` have a cardinality of `n`, then if the sum of elements in `s` is equal to the sum of elements in `t`, it follows that the sum of elements in the mapped multisets `map f s` and `map f t` are also equal. In terms of mathematical functions, if for two finite multisets `s` and `t` with same sum and cardinality, each element belongs to a set `A`, then the sum of the image of `s` under any function `f` from a function-like structure `F` is equal to the sum of the image of `t` under the same function.

Given a commutative additive monoid with an AddFreimanHomClass instance, if two finite multisets of an element set have equal sum and belong to the set, then the images of these multisets under any function-like structure's function have equal sums.


/-- The closed thickening `Metric.cthickening δ₁ E` is contained in the open thickening
`Metric.thickening δ₂ E` if the radius of the latter is positive and larger.  -/
theorem Metric.cthickening_subset_thickening' :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ₁ δ₂ : ℝ},
      0 < δ₂ → δ₁ < δ₂ → ∀ (E : Set α), Metric.cthickening δ₁ E ⊆ Metric.thickening δ₂ E :=
  by sorry

The theorem `Metric.cthickening_subset_thickening'` states that for any subset `E` of a pseudo emetric space, the closed thickening of `E` with a radius `δ₁`, denoted `Metric.cthickening δ₁ E`, is a subset of the open thickening of `E` with a radius `δ₂`, denoted `Metric.thickening δ₂ E`, if `δ₂` is positive and larger than `δ₁`.

Here, a closed thickening of a set `E` consists of points that are at a distance at most `δ₁` from `E` and an open thickening of `E` consists of points that are at a distance less than `δ₂` from some point in `E`.

For any subset `E` of a pseudo metric space, the closed thickening of `E` with radius `δ₁` is contained in the open thickening of `E` with radius `δ₂` when `δ₂` is positive and larger than `δ₁`.


MDifferentiableAt.hasMFDerivAt

theorem MDifferentiableAt.hasMFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} [Is : SmoothManifoldWithCorners I M] [I's : SmoothManifoldWithCorners I' M'],
      MDifferentiableAt I I' f x → HasMFDerivAt I I' f x (mfderiv I I' f x) :=
  by sorry

This theorem states that, given a nontrivially normed field `𝕜`, normed additive commutative groups `E` and `E'`, normed spaces over `𝕜` for `E` and `E'`, topological spaces `H`, `M`, `H'`, `M'`, models with corners `I` and `I'`, with `M` and `M'` being charted spaces with respect to `H` and `H'` respectively, a function `f` mapping `M` to `M'`, and a point `x` in `M`, if `f` is differentiable at `x` (in the sense of manifolds, denoted by `MDifferentiableAt I I' f x`), then `f` has a manifold derivative at `x` (denoted by `HasMFDerivAt I I' f x (mfderiv I I' f x)`). The manifolds `M` and `M'` are assumed to be smooth with corners with respect to the corresponding models with corners `I` and `I'`.

Given a nontrivially normed field `𝕜`, normed additive commutative groups `E` and `E'`, topological spaces `H`, `M`, `H'`, `M'`, models with corners `I` and `I'`, smooth manifolds with corners `M` and `M'`, a differentiable function `f` from `M` to `M'` at point `x` in `M`, then `f` has a manifold derivative `mfderiv I I' f x` at `x`.


Monotone.mul'

/-- The product of two monotone functions is monotone.  -/
theorem Monotone.mul' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α}
      [inst_3 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_4 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1],
      Monotone f → Monotone g → Monotone fun x => f x * g x :=
  by sorry

The theorem 'Monotone.mul'' states that for any type `α` with multiplication and preorder relations, and any type `β` with a preorder relation, if functions `f` and `g` are both monotone from `β` to `α` and `α` is covariant in both its multiplication function and its swapped multiplication function with respect to preorder, then the function that maps each `x` in type `β` to the product of `f(x)` and `g(x)` is also monotone. In other words, the product of two monotone functions is itself monotone under these conditions.

If `α` is a type with covariant multiplication and `β` is a type with a preorder relation, and `f` and `g` are monotone functions from `β` to `α`, then the function mapping `x` to `f(x) * g(x)` is monotone.


theorem min_rec' : ∀ {α : Type u} [inst : LinearOrder α] {x y : α} (p : α → Prop), p x → p y → p (min x y) := by sorry

This theorem states that for any type `α` that has a linear order, given two elements `x` and `y` of type `α` and a property `p` applicable to elements of `α`, if `p` holds for `x` and `y`, then `p` also holds for the minimum of `x` and `y`. This is essentially a form of mathematical induction applied to the concept of a minimum in a linearly ordered set.

If `α` is a linearly ordered type, `x`, `y` are elements of `α`, and `p` is a property such that `p x` and `p y` hold, then `p (min x y)` also holds.


theorem Finset.filter_empty : ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p], Finset.filter p ∅ = ∅ := by
  sorry

This theorem states that for all types `α`, and for any predicate `p` that can be decided for elements of this type, if you filter an empty finite set (`Finset`) based on this predicate, the result will be an empty finite set. In other words, there are no elements in an empty set that could satisfy any given predicate, so the filtered set remains empty.

For all types `α` and predicates `p` on `α`, the filter of the empty finite set `Finset α` using `p` is also empty.


theorem IsCoprime.of_add_mul_left_left :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime (x + y * z) y → IsCoprime x y := by sorry

The theorem `IsCoprime.of_add_mul_left_left` states that for any commutative semiring `R` and any elements `x`, `y`, and `z` of `R`, if `x + y * z` and `y` are coprime, then `x` and `y` are also coprime. This is stated in the context of an arbitrary commutative semiring, which is a type of algebraic structure that includes familiar number systems like the natural numbers, integers, and rational numbers. Here, being coprime is defined as the existence of two elements `a` and `b` such that `a * x + b * y = 1`.

If `x + y * z` and `y` are coprime elements in a commutative semiring `R`, then `x` and `y` are coprime.


CategoryTheory.SheafOfTypes.Hom.ext

theorem CategoryTheory.SheafOfTypes.Hom.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.GrothendieckTopology C}
      {X Y : CategoryTheory.SheafOfTypes J} (x y : CategoryTheory.SheafOfTypes.Hom X Y), x.val = y.val → x = y :=
  by sorry

This theorem states that for any category 'C' with a Grothendieck topology 'J', and for any two sheaves of types 'X' and 'Y' over this category, if two morphisms 'x' and 'y' from 'X' to 'Y' have the same underlying function (i.e., 'x.val = y.val'), then these two morphisms are indeed the same (i.e., 'x = y'). Essentially, it establishes the injectivity of the function assigning to each morphism of sheaves its underlying function.

If 'C' is a category with a Grothendieck topology 'J', and 'X' and 'Y' are sheaves over 'C', then two morphisms 'x' and 'y' from 'X' to 'Y' with equal underlying functions (i.e., x.val = y.val) are equal as morphisms (i.e., x = y).


theorem DFinsupp.sumAddHom_comp_single :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
      [inst_2 : AddCommMonoid γ] (f : (i : ι) → β i →+ γ) (i : ι),
      AddMonoidHom.comp (DFinsupp.sumAddHom f) (DFinsupp.singleAddHom β i) = f i :=
  by sorry

The theorem `DFinsupp.sumAddHom_comp_single` establishes an important property about the composition of additive monoid homomorphisms and direct sum finitely supported functions (DFinsupp). Given a type `ι`, a type `γ`, a function `β` from `ι` to a Type `v`, a decidable equality on `ι`, an `AddZeroClass` for each `β i`, and an `AddCommMonoid` for `γ`, for any additive monoid homomorphism `f` that maps each `β i` to `γ` and any element `i` of type `ι`, the composition of the sum of `f` (using `DFinsupp.sumAddHom`) and the single element addition homomorphism for `β` at `i` (using `DFinsupp.singleAddHom`) is the same as applying the function `f` at `i`. This asserts that `f` preserves the monoid structure under a specific composition operation involving a direct sum finitely supported function.

Given an additive monoid homomorphism `f` and an element `i` of type `ι`, the composition of `f` with the single element addition homomorphism for `β` at `i` is equal to applying `f` directly to `i`, for any type `ι`, type `γ`, function `β : ι → Type v`, decidable equality on `ι`, `AddZeroClass` for each `β i`, and `AddCommMonoid` for `γ`.


theorem DirectSum.of_zero_one :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : Zero ι] [inst_2 : GradedMonoid.GOne A]
      [inst_3 : (i : ι) → AddCommMonoid (A i)], (DirectSum.of A 0) 1 = 1 :=
  by sorry

The theorem `DirectSum.of_zero_one` states that for any type `ι`, given that `ι` has a decidable equality and a zero element, and for any type function `A` such that every `A i` forms an additive commutative monoid and `A` itself forms a Graded Monoid with a unit element, the image of the unit element under the natural inclusion map from `A 0` to the direct sum of `A i` across all `i` in `ι` is equal to the unit element in the direct sum. In other words, if you take the unit element from the additive commutative monoid `A 0` and include it in the direct sum of all `A i`, its identity remains unchanged.

Given a type `ι` with decidable equality and a zero element, and a graded monoid `A` over `ι` with a unit element, the unit element in `A 0` maps to the unit element in the direct sum of `A i` for all `i` in `ι`.


theorem Dioph.proj_dioph_of_nat : ∀ {n : ℕ} (m : ℕ) [inst : Fin2.IsLT m n], Dioph.DiophFn fun v => v (Fin2.ofNat' m) :=
  by sorry

This theorem states that for all natural numbers 'n', given another natural number 'm' and a proof that 'm' is less than 'n' (denoted `Fin2.IsLT m n`), the function which maps a function `v` (from natural numbers to natural numbers) to its 'm-th' value (`v (Fin2.ofNat' m)`) is Diophantine. In simpler words, for any `m` less than `n`, the projection function that picks the `m`-th component of the function `v` is a Diophantine function.

For all natural numbers n and m with m < n, the function that maps a function v from natural numbers to natural numbers to its m-th component v (Fin2.ofNat m) is a Diophantine function.


Ergodic.quasiErgodic

/-- An ergodic map is quasi ergodic.  -/
theorem Ergodic.quasiErgodic :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : MeasureTheory.Measure α},
      Ergodic f μ → QuasiErgodic f μ :=
  by sorry

This theorem states that for any type `α`, measurable space `m` defined on `α`, function `f` from `α` to `α`, and measure `μ` on the measurable space, if `f` is an ergodic function with respect to `μ`, then `f` is also quasi-ergodic with respect to `μ`. In the context of measure theory, this theorem essentially describes the relationship between two properties of dynamical systems: ergodicity and quasi-ergodicity, asserting that ergodicity of a map implies its quasi-ergodicity.

If `f` is an ergodic function on measurable space `(α, m)` with respect to measure `μ`, then `f` is quasi-ergodic with respect to `μ`.


theorem Equiv.subtypeEquiv.proof_1 :
    ∀ {α : Sort u_2} {β : Sort u_1} {p : α → Prop} {q : β → Prop} (e : α ≃ β),
      (∀ (a : α), p a ↔ q (e a)) → ∀ (a : { a // p a }), q (e ↑a) :=
  by sorry

This theorem states that for any two types `α` and `β` and two properties `p` on `α` and `q` on `β`, given an equivalence `e` between `α` and `β`, if for all `a` of type `α`, `p a` is equivalent to `q (e a)`, then for all `a` that satisfy `p`, `q (e ↑a)` holds. In other words, if a property `p` holds for elements in type `α` and this property is equivalent to another property `q` holding for the corresponding elements in type `β` under some equivalence, then the property `q` holds for all such equivalent elements.

If `e` is an equivalence between types `α` and `β`, and `p` on `α` is equivalent to `q` on `β` via `e`, then for all `a` of type `α` with property `p`, `q` holds for their equivalence classes `[a]` under `e`.


theorem Option.map₂_comm :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {g : β → α → γ},
      (∀ (a : α) (b : β), f a b = g b a) → Option.map₂ f a b = Option.map₂ g b a :=
  by sorry

This theorem asserts that for any types `α`, `β`, and `γ`, any binary functions `f : α → β → γ` and `g : β → α → γ`, and any optional values `a : Option α` and `b : Option β`, if `f` and `g` are commutative for all `α` and `β` (that is, `f a b` equals `g b a` for all `a` and `b`), then applying the function `Option.map₂` to `f`, `a`, and `b` will yield the same result as applying `Option.map₂` to `g`, `b`, and `a`. In other words, the theorem states the commutativity of `Option.map₂` under the condition that the binary functions are commutative.

For commutative functions `f : α → β → γ` and `g : β → α → γ`, Option.map₂ preserves commutativity, that is, Option.map₂ `f` `a` `b` = Option.map₂ `g` `b` `a` for all optional values `a : Option α` and `b : Option β`.


theorem Basis.index_nonempty :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Basis ι R M → ∀ [inst : Nontrivial M], Nonempty ι :=
  by sorry

This theorem states that for a given index set `ι`, a ring `R`, and a module `M` over `R`, if `M` has a basis with respect to `ι` and `R`, and `M` is nontrivial (i.e., it contains at least two distinct elements), then `ι` is nonempty. In other words, a nontrivial module always has a nonempty set of basis indices.

A nontrivial module over a ring with a basis has a nonempty index set.


IsLocallyConstant.const

theorem IsLocallyConstant.const :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (y : Y), IsLocallyConstant (Function.const X y) := by
  sorry

This theorem states that for any given types `X` and `Y`, with `X` being a topological space, and any element `y` of `Y`, the function that is constantly `y` (i.e., the function that maps every element of `X` to `y`) is a locally constant function. Here, a function is said to be locally constant if, for any set in `Y`, its preimage under the function is an open set in `X`. That means, regardless of how we choose a set in `Y`, when we look at all the points in `X` that map into this set, they form an open set.

For any topological space X and any element y in a type Y, the constant function from X to y is locally constant.


theorem Subgroup.map_comap_eq_self :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N} {H : Subgroup N},
      H ≤ MonoidHom.range f → Subgroup.map f (Subgroup.comap f H) = H :=
  by sorry

The theorem `Subgroup.map_comap_eq_self` states that for any group homomorphism `f` from a group `G` to a group `N` and a subgroup `H` of `N`, if `H` is a subset of the range of `f`, then the image of the preimage of `H` under `f` is `H` itself. In other words, if we first use `f` to pull back `H` to a subgroup of `G`, and then push that forward under `f`, we recover `H`. This is a common pattern in the theory of groups, reflecting the idea that the image of the preimage of a set under a function should coincide with the original set, whenever the set is included in the range of the function.

For any group homomorphism `f` and subgroup `H` of a group `N` with `H` contained in the image of `f`, the preimage `f⁻¹[H]` under `f` equals `H`.


Set.EqOn.eventuallyEq

theorem Set.EqOn.eventuallyEq :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f g : α → β}, Set.EqOn f g s → f =ᶠ[Filter.principal s] g := by sorry

This theorem states that for any two functions `f` and `g` from some type `α` to another type `β`, and a set `s` of elements from `α`, if these two functions are equal on the set `s` (that is, `f(x) = g(x)` for every `x` in `s`), then `f` is almost everywhere equal to `g` on the principal filter of `s`. The principal filter of a set is the collection of all supersets of that set. In other words, except possibly on a subset of `s` of negligible size, `f` and `g` have the same values.

If functions `f` and `g` from type `α` to type `β` agree on set `s`, then they are almost equal on the principal filter of `s`, i.e., agree outside a subset of negligible size.


theorem continuous_coinduced_dom :
    ∀ {α : Type u} {β : Type v} {γ : Type u_1} {f : α → β} {g : β → γ} {t₁ : TopologicalSpace α}
      {t₂ : TopologicalSpace γ}, Continuous g ↔ Continuous (g ∘ f) :=
  by sorry

The theorem `continuous_coinduced_dom` states that for any types `α`, `β`, and `γ`, and any functions `f` from `α` to `β` and `g` from `β` to `γ`, given a topological space over `α` and another over `γ`, the function `g` is continuous if and only if the composition of `g` and `f` (`g ∘ f`) is continuous. This is a statement about the preservation of continuity under function composition in the context of topological spaces.

Given functions `f: α → β` and `g: β → γ` between topological spaces, `g` is continuous if and only if the composition `g ∘ f` is continuous.


DifferentiableOn.neg

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

This theorem states that if a function `f` is differentiable on a set `s`, then the negation of the function, i.e., the function that maps each point in `s` to the negation of the corresponding value of `f`, is also differentiable on `s`. Here, `f` is a function from a normed space `E` to another normed space `F`, both over a nontrivial normed field `𝕜`. The concept of differentiability used here is 'differentiability within a set at a point', which means roughly that the function behaves near each point of the set as a linear map plus a small error term.

If `f : E → F` is differentiable on a set `s ⊆ E`, then the negation of `f`, i.e., `-f`, is also differentiable on `s`.


theorem Cardinal.lift_max :
    ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b) := by
  sorry

The theorem `Cardinal.lift_max` states that for any two cardinal numbers `a` and `b` in some universe `v`, lifting the maximum of `a` and `b` to a larger universe `u` is the same as taking the maximum of the lifts of `a` and `b` to this larger universe. In other words, the operation of "lifting" a cardinal to a larger universe commutes with taking the maximum.

For any cardinal numbers `a` and `b` and universes `v` and `u` with `v` a subuniverse of `u`, the lift of the maximum of `a` and `b` to `u` equals the maximum of the lifts of `a` and `b` to `u`.


/-- **Alias** of the forward direction of `ZFSet.isTransitive_iff_mem_trans`. -/
theorem ZFSet.IsTransitive.mem_trans : ∀ {z : ZFSet}, ZFSet.IsTransitive z → ∀ {x y : ZFSet}, x ∈ y → y ∈ z → x ∈ z :=
  by sorry

This theorem states that for any given ZFSet `z`, if `z` is a transitive set (in the sense that every element is a subset of `z`), then for any two other ZFSets `x` and `y`, if `x` is an element of `y` and `y` is an element of `z`, it follows that `x` is also an element of `z`. This theorem is an alias of the forward direction of `ZFSet.isTransitive_iff_mem_trans`.

If `z` is a transitive ZFSet, then for all `x` and `y`, if `x` is an element of `y` and `y` is an element of `z`, then `x` is an element of `z`.


Ordnode.Sized.node'

theorem Ordnode.Sized.node' :
    ∀ {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α},
      Ordnode.Sized l → Ordnode.Sized r → Ordnode.Sized (Ordnode.node' l x r) :=
  by sorry

The theorem `Ordnode.Sized.node'` states that for any type `α`, for any left and right nodes (`l` and `r` respectively) of type `Ordnode α`, and for any node `x` of type `α`, if the left node `l` and the right node `r` all have the `Sized` property (i.e., the `size` field in the node matches the actual size of the subtree), then the node created by `Ordnode.node'` function applied to `l`, `x`, and `r` also has the `Sized` property. In other words, constructing a new node with the correct size information, without rebalancing, preserves the `Sized` property.

For any type `α` and `Ordnode α` nodes `l`, `r`, and `x` with the `Sized` property, the node created by `Ordnode.node'` function also has the `Sized` property.


MeasureTheory.Measure.Regular.smul

theorem MeasureTheory.Measure.Regular.smul :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] {μ : MeasureTheory.Measure α}
      [inst_2 : MeasureTheory.Measure.Regular μ] {x : ENNReal}, x ≠ ⊤ → MeasureTheory.Measure.Regular (x • μ) :=
  by sorry

The theorem `MeasureTheory.Measure.Regular.smul` states that for any type `α` which is both a `MeasurableSpace` and a `TopologicalSpace`, given a regular measure `μ` on `α` and a scalar `x` in the extended nonnegative real numbers (`ENNReal`) that is not infinite (`⊤`), the scaled measure (`x • μ`) is also regular. In Measure Theory, regular measures have certain properties like being finite on compact sets and outer regularity, which means every measurable set is approximately measurable by open sets from outside. This theorem ensures that these properties are maintained when the measure is scaled by a non-infinite scalar.

Given a regular measure μ on a measurable space and topological space α, and a non-infinite scalar x in the extended nonnegative real numbers, the scaled measure x • μ is also regular.


theorem geom_sum_succ' :
    ∀ {α : Type u} [inst : Semiring α] {x : α} {n : ℕ},
      (Finset.sum (Finset.range (n + 1)) fun i => x ^ i) = x ^ n + Finset.sum (Finset.range n) fun i => x ^ i :=
  by sorry

The theorem `geom_sum_succ'` states that for any semiring `α`, any element `x` of `α`, and any natural number `n`, the sum of `x` to the power of each natural number in the range from 0 to `n + 1` (exclusive) is equal to `x` to the power of `n` plus the sum of `x` to the power of each natural number in the range from 0 to `n` (exclusive). In mathematical notation, this would be:
∑_{i=0}^{n+1} x^i = x^n + ∑_{i=0}^{n} x^i.
This theorem is essentially a restatement of a property of geometric progressions.

The sum of the geometric series with first term `x` and common ratio `x` from `0` to `n+1` equals the sum of the geometric series with first term `x` and common ratio `x` from `0` to `n`, plus `x^(n+1)`.


theorem Fintype.mem_piFinset :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {δ : α → Type u_3} {t : (a : α) → Finset (δ a)}
      {f : (a : α) → δ a}, f ∈ Fintype.piFinset t ↔ ∀ (a : α), f a ∈ t a :=
  by sorry

The theorem `Fintype.mem_piFinset` states that for all types `α` with decidable equality and finite cardinality, and for any function `δ` from `α` to another type, given a function `t` that assigns to each element of `α` a finite set of elements of the type given by `δ` for that element, and another function `f` from `α` to the type given by `δ`, the function `f` is a member of the finite product set `Fintype.piFinset t` if and only if for all elements of `α`, the output of `f` for that element is a member of the finite set given by `t` for that element.

For any type `α` with decidable equality and finite cardinality, function `δ : α → Type`, function `t : α → Finset (δ α)`, and function `f : α → δ α`, `f ∈ ∏ x ∈ α. Finset (δ x)` if and only if `∀ x ∈ α, f x ∈ t x`.


theorem Mathlib.Data.Fintype.Basic._auxLemma.26 :
    ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], (Set.toFinset s).Nonempty = Set.Nonempty s := by sorry

This theorem, named `Mathlib.Data.Fintype.Basic._auxLemma.26`, establishes the equivalence between two ways of expressing the non-emptiness of a set in the context of finite types. Specifically, for any type `α` and any set `s` of this type, if `s` is a finite type, then the property of `s` being non-empty when converted to a finite set (`Set.toFinset s`) is identical to the property of `s` being non-empty in its original form (`Set.Nonempty s`). In other words, converting a non-empty set to a finite set preserves its non-emptiness.

For any finite type `α` and non-empty set `s` of type `α`, `Set.Nonempty s` is equivalent to `Set.Finite.Nonempty (Set.toFinset s)`.


theorem AddSubgroup.zsmul_mem :
    ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) {x : G}, x ∈ K → ∀ (n : ℤ), n • x ∈ K := by sorry

This theorem states that for any additive group `G`, any subgroup `K` of `G`, and any element `x` of `G` that belongs to `K`, the result of the operation of integer multiplication `n • x` for any integer `n`, also belongs to `K`. In other words, the integer multiple of any element inside an additive subgroup remains within the same subgroup.

For any additive group G, subgroup K, and element x in K, the integer multiples of x belong to K.


theorem t1Space_TFAE :
    ∀ (X : Type u) [inst : TopologicalSpace X],
      List.TFAE
        [T1Space X, ∀ (x : X), IsClosed {x}, ∀ (x : X), IsOpen {x}ᶜ, Continuous ⇑CofiniteTopology.of,
          ∀ ⦃x y : X⦄, x ≠ y → {y}ᶜ ∈ nhds x, ∀ ⦃x y : X⦄, x ≠ y → ∃ s ∈ nhds x, y ∉ s,
          ∀ ⦃x y : X⦄, x ≠ y → ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U, ∀ ⦃x y : X⦄, x ≠ y → Disjoint (nhds x) (pure y),
          ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (nhds y), ∀ ⦃x y : X⦄, x ⤳ y → x = y] :=
  by sorry

The theorem `t1Space_TFAE` states that for any type `X` equipped with a `TopologicalSpace` structure, the following propositions are equivalent:

1. `X` is a T1 space, which means that for any two different points, each has a neighborhood not containing the other.
2. Every single-point set `{x}` is closed.
3. The complement of every single-point set `{x}` is open.
4. The identity function from `X` to its cofinite topology is continuous.
5. For any two different points `x` and `y`, the set containing all points except `y` is a neighborhood of `x`.
6. For any two different points `x` and `y`, there exists some set `s` which is a neighborhood of `x` but `y` is not in `s`.
7. For any two different points `x` and `y`, there exists an open set `U` which contains `x` but not `y`.
8. For any two different points `x` and `y`, the neighborhood filters at `x` and `y` are disjoint.
9. For any two different points `x` and `y`, the neighborhood filter at `y` and the principal filter generated by `x` are disjoint.
10. For any two different points `x` and `y`, if `x` is related to `y` by a certain relation (encoded by `x ⤳ y`), then `x` must be equal to `y`.

In the context of topology, these propositions are all different ways of expressing the property of being a T1 space, hence they are all equivalent.

A topological space `X` is T1 if and only if for any two distinct points `x` and `y`, there exist disjoint open sets containing each point.


theorem Set.preimage_neg_Iic : ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a : α), -Set.Iic a = Set.Ici (-a) := by
  sorry

This theorem states that for any ordered additive commutative group (`OrderedAddCommGroup`) and any element `a` in that group, the set of all elements that are less than or equal to `a` and then negated (`-Set.Iic a`) is equal to the set of all elements that are greater than or equal to the negation of `a` (`Set.Ici (-a)`). In other words, if you negate all the elements in a right-closed left-infinite interval, you get a left-closed right-infinite interval with its bound negated.

For any ordered additive commutative group and its element `a`, the sets `{-Set.Iic a}` and `Set.Ici (-a)` are equal.


theorem Set.preimage_neg_Ici : ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a : α), -Set.Ici a = Set.Iic (-a) := by
  sorry

This theorem states that for any ordered additive commutative group `α` and any element `a` in `α`, the set of all elements `x` such that `-a` is less than or equal to `x` (`-Set.Ici a`), is equal to the set of all elements `x` such that `x` is less than or equal to `-a` (`Set.Iic (-a)`). In other words, negating the set of all elements greater than or equal to a certain value yields the set of all elements less than or equal to the negation of that value.

For any ordered additive commutative group `α` and its element `a`, the sets `-Set.Ici a` and `Set.Iic (-a)` are equal.


theorem Metric.ball_eq_empty :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.ball x ε = ∅ ↔ ε ≤ 0 := by sorry

This theorem states that for any type `α` endowed with a pseudo-metric space structure, and for any point `x` of type `α` and a real number `ε`, the metric ball of radius `ε` centered at `x` is empty if and only if `ε` is less than or equal to zero. In mathematical terms, the set of all points `y` such that the distance between `y` and `x` is less than `ε` is empty if and only if `ε` is less than or equal to zero.

For any pseudo-metric space `(α, d)`, and for all `x ∈ α` and `ε ∈ ℝ`, the open metric ball `{y : α | d(x, y) < ε}` is empty if and only if `ε ≤ 0`.


theorem CategoryTheory.GlueData.ι_gluedIso_inv :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] {C' : Type u₂}
      [inst_1 : CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C')
      [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]
      [inst_2 : CategoryTheory.Limits.HasMulticoequalizer (CategoryTheory.GlueData.diagram D)]
      [inst_3 :
        CategoryTheory.Limits.PreservesColimit
          (CategoryTheory.Limits.MultispanIndex.multispan (CategoryTheory.GlueData.diagram D)) F]
      (i : D.J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GlueData.ι (CategoryTheory.GlueData.mapGlueData D F) i)
          (CategoryTheory.GlueData.gluedIso D F).inv =
        F.map (CategoryTheory.GlueData.ι D i) :=
  by sorry

The theorem `CategoryTheory.GlueData.ι_gluedIso_inv` states that for any category `C` and `C'`, any glue data `D` in `C`, and any functor `F` from `C` to `C'` that preserves the limit of the cospan `(D.f i j) (D.f i k)` for all `i`, `j`, and `k` in the indexing set `D.J`, if `D` has a multi-coequalizer and the functor `F` preserves the colimit of the multi-span of `D`, then the composition of the morphism from `D.U i` to the glued object in the image of `D` under `F`, and the inverse of the isomorphism from the glued object of `D` to the glued object of the image of `D` under `F`, is equal to the image under `F` of the morphism from `D.U i` to the glued object of `D`.

If functor `F` preserves limits and colimits of `C` and `C'` respectively, and preserves the multi-coequalizer of glue data `D` in `C` and the colimit of its image under `F`, then for any index `i` in `D.J`, the composition of `D.f i` with the inverse of the isomorphism between the glued objects is equal to the image under `F` of `D.f i`.


theorem balancedCore_balanced :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] (s : Set E),
      Balanced 𝕜 (balancedCore 𝕜 s) :=
  by sorry

The theorem `balancedCore_balanced` states that for any given seminormed ring `𝕜` and scalar multiplication (`SMul`) on type `E`, and for any set `s` of type `E`, the largest balanced subset within `s` (denoted as `balancedCore 𝕜 s`) is balanced. In other words, if `a` is an element in ring `𝕜` with the property that its norm is at most `1`, then the scalar multiplication of `a` and the `balancedCore` is contained within the `balancedCore` itself.

For any seminormed ring `𝕜` and subset `s` of its type `E`, the balanced subset `balancedCore 𝕜 s` is closed under scalar multiplication by elements in `𝕜` with norm at most 1.


theorem ltByCases_lt :
    ∀ {α : Type u} [inst : LinearOrder α] {P : Sort u_3} {x y : α} (h : x < y) {h₁ : x < y → P} {h₂ : x = y → P}
      {h₃ : y < x → P}, ltByCases x y h₁ h₂ h₃ = h₁ h :=
  by sorry

This theorem, `ltByCases_lt`, states that for any type `α` equipped with a decidable linear order, any two elements `x` and `y` of that type, and any property `P`, if `x < y`, then the result of the function `ltByCases` applied to `x`, `y` and three functions `h₁`, `h₂` and `h₃` (which map from the conditions `x < y`, `x = y`, `y < x` to `P` respectively) is equal to the result of `h₁` applied to the condition `x < y`. In other words, when `x < y`, `ltByCases` correctly chooses the function `h₁` that handles the case `x < y`.

For any decidably ordered type `α` and elements `x` and `y` of `α`, if `x < y`, then `ltByCases(x, y, h₁, h₂, h₃) = h₁ (x < y)`.


theorem eq_zero_of_ne_zero_of_mul_left_eq_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : NoZeroDivisors M] {x y : M}, x ≠ 0 → x * y = 0 → y = 0 := by
  sorry

This theorem states that for any type `M` that forms a monoid with zero and has no zero divisors, given two elements `x` and `y` of this type, if `x` is not zero and the product of `x` and `y` is zero, then `y` must be zero. In simpler terms, in a system where no product of two non-zero elements can be zero, if a non-zero element multiplies with another element resulting in zero, then the second element must have been zero.

In a monoid with no zero divisors, the product of two non-zero elements is non-zero.


theorem UniformSpace.Completion.induction_on₃ :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
      [inst_2 : UniformSpace γ]
      {p : UniformSpace.Completion α → UniformSpace.Completion β → UniformSpace.Completion γ → Prop}
      (a : UniformSpace.Completion α) (b : UniformSpace.Completion β) (c : UniformSpace.Completion γ),
      IsClosed {x | p x.1 x.2.1 x.2.2} → (∀ (a : α) (b : β) (c : γ), p (↑α a) (↑β b) (↑γ c)) → p a b c :=
  by sorry

The theorem `UniformSpace.Completion.induction_on₃` states that for any three types `α`, `β`, and `γ` equipped with a uniform space structure, and for any predicate `p` defined on the Hausdorff completions of `α`, `β`, and `γ`, if the set of triples in the product space of the completions on which `p` holds is closed, and `p` holds for any triple of points in the original spaces `α`, `β`, and `γ`, then `p` also holds for any triple of points in the completions `UniformSpace.Completion α`, `UniformSpace.Completion β`, and `UniformSpace.Completion γ`. This theorem expresses a property of induction on the completions of uniform spaces.

If the set of triples in the product of the Hausdorff completions of uniform spaces `α`, `β`, and `γ` where a predicate `p` holds is closed and `p` holds for all triples in the original spaces, then `p` holds for all triples in the completions.


theorem ltByCases_eq :
    ∀ {α : Type u} [inst : LinearOrder α] {P : Sort u_3} {x y : α} (h : x = y) {h₁ : x < y → P} {h₂ : x = y → P}
      {h₃ : y < x → P}, ltByCases x y h₁ h₂ h₃ = h₂ h :=
  by sorry

The theorem `ltByCases_eq` states that for all types `α` that are equipped with a `LinearOrder` instance and any two elements `x` and `y` of type `α`, if `x` is equal to `y`, then the result of the function `ltByCases`, which performs a case-split on the ordering of `x` and `y`, is equal to the outcome of the function `h₂`. This function `h₂` is the case function corresponding to the condition that `x` equals `y`. In essence, `ltByCases` correctly handles the case when `x` and `y` are equal by returning the result of the function that handles the equality case.

For any type `α` with a `LinearOrder` instance and elements `x` and `y` of type `α`, if `x = y`, then `ltByCases x y` equals the result of the equality case function `h₂` in the definition of `ltByCases`.


theorem ltByCases_gt :
    ∀ {α : Type u} [inst : LinearOrder α] {P : Sort u_3} {x y : α} (h : y < x) {h₁ : x < y → P} {h₂ : x = y → P}
      {h₃ : y < x → P}, ltByCases x y h₁ h₂ h₃ = h₃ h :=
  by sorry

The theorem `ltByCases_gt` states that for any type `α` which has a linear order, for any propositions `P`, and for any values `x` and `y` of type `α`, given a proof `h` that `y < x`, and three proof objects `h₁`, `h₂`, and `h₃` corresponding to cases where `x < y`, `x = y`, and `y < x` respectively, the function `ltByCases x y h₁ h₂ h₃` will return `h₃ h`. In other words, when `y < x`, the function `ltByCases` correctly chooses the proof object `h₃` associated with this case.

For any type `α` with a linear order, given `x`, `y` in `α` and proofs `h: y < x`, `h₁: x < y`, `h₂: x = y`, the function `ltByCases x y h₁ h₂ h₃` returns `h₃` when `x < y`.