theorem IsPGroup.of_surjective :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G],
      IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G →* H), Function.Surjective ⇑ϕ → IsPGroup p H :=
  by sorry

The theorem `IsPGroup.of_surjective` states that if `G` is a p-group (that is, for every element `g` in `G`, there is some integer `k` such that `g` raised to the power `p` to the power `k` equals the group's identity element), then for any other group `H` and any surjective homomorphism `ϕ` from `G` to `H` (that is, a function such that every element in `H` is the image of some element in `G` under `ϕ`), `H` is also a p-group. In other words, the property of being a p-group is preserved under surjective homomorphisms.

If `G` is a p-group and `ϕ : G → H` is a surjective homomorphism, then `H` is also a p-group.


theorem HNNExtension.NormalWord.instMulActionHNNExtensionNormalWordToMonoidToDivInvMonoidInstGroupHNNExtension.proof_1 :
    ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B)
      {d : HNNExtension.NormalWord.TransversalPair G A B} (a : ↥A),
      HNNExtension.NormalWord.unitsSMulEquiv φ * (MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑a =
        (MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑(φ a) * HNNExtension.NormalWord.unitsSMulEquiv φ :=
  by sorry

This theorem states that for any group `G`, subgroups `A` and `B` of `G`, an isomorphism `φ` between `A` and `B`, and an element `a` from `A`, the equivalence obtained by multiplying elements of the `HNNExtension.NormalWord` type from the transversal pair `d` on the left by `φ a`, is the same as first applying the permutation of `HNNExtension.NormalWord` induced by the multiplication action of `G` on `a`, then multiplying on the left by `φ`. In other words, the order of these operations can be swapped without changing the result.

For any group `G`, subgroups `A` and `B` with an isomorphism `φ: A ↔ B`, and an element `a` in `A`, the normal words in `HNNExtension.NormalWord` obtained by left-multiplying transversal elements by `φ(a)` are equivalent to the normal words obtained by first applying the left multiplication action of `G` on `a` and then applying `φ`.


theorem Finset.card_le_one_iff : ∀ {α : Type u_1} {s : Finset α}, s.card ≤ 1 ↔ ∀ {a b : α}, a ∈ s → b ∈ s → a = b := by
  sorry

This theorem states that for any finite set `s` of a certain type `α`, the cardinality of `s` is less than or equal to one if and only if for any two elements `a` and `b` of type `α`, if `a` and `b` are in `s`, then `a` is equal to `b`. In other words, a set has at most one unique element if any two elements in the set must be the same.

A finite set `s` of type `α` has at most one element if and only if all distinct elements of `s` are equal.


theorem contDiffOn_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {c : F} {s : Set E}, ContDiffOn 𝕜 n (fun x => c) s :=
  by sorry

The theorem `contDiffOn_const` states that for any non-trivially normed field `𝕜`, any normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, any natural number or infinity `n`, any constant `c` of type `F`, and any set `s` of elements of type `E`, the function that always returns `c` is continuously differentiable on the set `s`.

For any non-trivially normed field 𝕜, any normed additive commutative groups E and F as normed spaces over 𝕜, any natural number or infinity n, any constant c in F, and any set s of elements in E, the constant function mapping x to c is continuously differentiable on s.


theorem FirstOrder.Language.Sentence.realize_not :
    ∀ {L : FirstOrder.Language} (M : Type w) [inst : FirstOrder.Language.Structure L M]
      {φ : FirstOrder.Language.Sentence L}, M ⊨ FirstOrder.Language.Formula.not φ ↔ ¬M ⊨ φ :=
  by sorry

This theorem states that for any first-order language `L` and any `L`-structure `M`, for any sentence `φ` of the language `L`, the structure `M` satisfies the negation of the sentence `φ` (denoted as `M ⊨ FirstOrder.Language.Formula.not φ`) if and only if it is not the case that the structure `M` satisfies the sentence `φ` (denoted as `¬M ⊨ φ`). This is a formalization of the classical logical principle of negation in the context of first-order structures and languages.

For any first-order language L and structure M, M satisfies the negation of a sentence φ if and only if φ is not satisfied by M.


theorem List.indexOf_cons_ne :
    ∀ {α : Type u} [inst : DecidableEq α] {a b : α} (l : List α),
      b ≠ a → List.indexOf a (b :: l) = Nat.succ (List.indexOf a l) :=
  by sorry

This theorem, `List.indexOf_cons_ne`, asserts that for any type `α` with decidable equality, and any two elements `a` and `b` of this type, as well as any list `l` of elements of type `α`, if `b` is not equal to `a`, then the index of `a` in the list that starts with `b` followed by `l` is one more than the index of `a` in the list `l`. In simpler terms, if you have a list and the first element is not the one you're looking for, the index of the element you're seeking in the whole list is one more than the index in the rest of the list.

For any type `α` with decidable equality, if `b ≠ a` and `l` is a list of length `n+1` over `α` with `b` as its head, then the index of `a` in `l` is `n` if it is in `l`, and `n+1` otherwise.


theorem Real.sin_neg_of_neg_of_neg_pi_lt : ∀ {x : ℝ}, x < 0 → -Real.pi < x → Real.sin x < 0 := by sorry

This theorem states that for any real number `x`, if `x` is less than 0 and greater than negative pi (`-π`), then the sine of `x` is also less than 0. It, in essence, establishes that the sine of a real number within the interval `(-π,0)` is negative.

For any real number `x` with `x < 0` and `x > -π`, we have `sin(x) < 0`.


theorem Finset.empty_val : ∀ {α : Type u_1}, ∅.val = 0 := by sorry

This theorem states that for any type `α`, the value of an empty finite set (`∅`) is equal to zero. In other words, the cardinality (or size) of an empty set, regardless of the type of its elements, is always zero.

The cardinality of an empty set is equal to zero, for any type `α`.


theorem Filter.eventuallyLE_antisymm_iff :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] {l : Filter α} {f g : α → β},
      f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f :=
  by sorry

This theorem states that for any types `α` and `β`, and for any partial order on `β`, given a filter `l` on `α` and functions `f` and `g` from `α` to `β`, the functions `f` and `g` are eventually equal at filter `l` if and only if `f` is eventually less than or equal to `g` at filter `l` and `g` is eventually less than or equal to `f` at filter `l`. Here, "eventually" means that the condition holds except for possibly an initial segment of the sequence.

For any types `α` and `β`, and for any partial order on `β`, two functions `f` and `g` from `α` to `β` are equal at a filter `l` if and only if one is less than or equal to the other at `l` and vice versa, up to an initial segment.


theorem QuotientAddGroup.isOpenMap_coe :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G]
      (N : AddSubgroup G), IsOpenMap QuotientAddGroup.mk :=
  by sorry

The theorem `QuotientAddGroup.isOpenMap_coe` states that for any type `G`, given a topological space structure, an addition group structure, and a topological addition group structure on `G`, along with an addition subgroup `N` of `G`, the canonical map from `G` to the quotient `G ⧸ N`, given by `QuotientAddGroup.mk`, is an open map. This means that the image of any open set in `G` under this map is an open set in the quotient `G ⧸ N`.

The map from a group `G` with topological addition group structure to its quotient `G / N` by an additive subgroup `N`, given by `QuotientAddGroup.mk`, is an open map.


theorem Mathlib.Topology.EMetricSpace.Basic._auxLemma.6 : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b :=
  by sorry

This theorem, `Mathlib.Topology.EMetricSpace.Basic._auxLemma.6`, states that for any proposition `b` and any nonempty type `α`, the function type from `α` to `b` is equivalent to `b`. In other words, if we have a function that outputs a proposition `b` for every element in a nonempty type `α`, this is the same as just having the proposition `b` itself.

For any nonempty type `α` and proposition `b`, the function type `α → b` is equivalent to `b`.


theorem Mathlib.Topology.EMetricSpace.Basic._auxLemma.5 : ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True := by sorry

This theorem, named as `Mathlib.Topology.EMetricSpace.Basic._auxLemma.5`, states that for any type `α` and any element `x` of this type, `x` belongs to the universal set `Set.univ` of type `α`. In more mathematical terms, we could say that for any set `α` and any element `x` in `α`, the membership of `x` in the universal set corresponding to `α` is a true statement. This is consistent with the concept of a universal set, which, by definition, contains all elements of a given type or set.

For any type `α` and any element `x` of type `α`, `x` is an element of the universal set `Set.univ` of type `α`.


theorem monotone_comp_ofDual_iff :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone (f ∘ ⇑OrderDual.ofDual) ↔ Antitone f :=
  by sorry

This theorem states that for any two types `α` and `β` that have preorder structures, for any function `f` from `α` to `β`, the function `f` composed with the identity function of the dual order of `α` is monotone if and only if the function `f` is antitone. In other words, `f` is increasing when applied after the dual order identity if and only if `f` is decreasing when applied on its own.

For types `α` and `β` with preorders, function `f` from `α` to `β` is monotone with respect to the dual orders if and only if `f` is antitone.


theorem Equiv.ofLeftInverse.proof_1 : ∀ {α : Sort u_1} {β : Type u_2} (f : α → β) (a : α), ∃ y, f y = f a := by sorry

This theorem states that for any function `f` mapping from a type `α` to a type `β` and for any element `a` belonging to type `α`, there exists an element `y` in type `α` such that the function `f` applied to `y` is equal to `f` applied to `a`. This theorem captures the possibility of having multiple elements in the domain mapping to the same element in the codomain, a characteristic feature of non-injective (or not one-to-one) functions.

For any function `f` from type `α` to type `β` and any `a` in `α`, there exists `y` in `α` such that `f(y) = f(a)`.


theorem MeasureTheory.Measure.IicSnd_le_fst :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (r : ℝ),
      MeasureTheory.Measure.IicSnd ρ r ≤ MeasureTheory.Measure.fst ρ :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space structure `mα`, for any measure `ρ` on the product of `α` and the real numbers `ℝ`, and for any real number `r`, the measure obtained by restricting `ρ` to the set of all pairs whose second component is less than or equal to `r` (denoted by `MeasureTheory.Measure.IicSnd ρ r`), when projected onto `α`, is less than or equal to the marginal measure of `ρ` projected onto `α` (denoted by `MeasureTheory.Measure.fst ρ`). In mathematical language, it can be stated as: $\forall α, ρ, r: MeasureTheory.Measure.IicSnd(ρ, r) \leq MeasureTheory.Measure.fst(ρ)$.

For any measure `ρ` on the product of a measurable space `α` and the real numbers `ℝ`, and for any real number `r`, the measure of the subset of `α` obtained by projecting the set where the second component is less than or equal to `r` from the product space has lesser or equal measure compared to the marginal measure on `α` from `ρ`.


theorem Mathlib.Data.Finset.MulAntidiagonal._auxLemma.4 :
    ∀ {α : Type u_1} [inst : OrderedCancelAddCommMonoid α] {s t : Set α} {hs : Set.IsPWO s} {ht : Set.IsPWO t} {a : α}
      {x : α × α}, (x ∈ Finset.addAntidiagonal hs ht a) = (x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 + x.2 = a) :=
  by sorry

This theorem states that for any type `α` which has an `OrderedCancelAddCommMonoid` structure, given two partially well-ordered sets `s` and `t`, and an element `a` of type `α`, for any pair `x` of type `α × α`, `x` belongs to the set `Finset.addAntidiagonal hs ht a` if and only if the first element of `x` is in `s`, the second element of `x` is in `t`, and the sum of the elements of `x` equals `a`. In other words, `Finset.addAntidiagonal hs ht a` consists exactly of pairs whose elements are from `s` and `t` respectively and sum up to `a`.

For any `OrderedCancelAddCommMonoid` type `α`, `Finset.addAntidiagonal` returns the set of pairs `(x, y)` from `α × α` such that `x ∈ s`, `y ∈ t`, and `x + y = a`.


ContDiffWithinAt.neg

/-- The negative of a `C^n` function within a domain at a point is `C^n` within this domain at
this point.  -/
theorem ContDiffWithinAt.neg :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {n : ℕ∞} {s : Set E} {f : E → F}, ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n (fun x => -f x) s x :=
  by sorry

The theorem `ContDiffWithinAt.neg` states that for any nontrivially normed field `𝕜` and normed additive commutative groups `E` and `F`, both of which are normed spaces over `𝕜`. Given a point `x` in `E`, a function `f` mapping from `E` to `F`, a subset `s` of `E`, and an order of differentiability `n`, if the function `f` is `n`-times continuously differentiable within the subset `s` at the point `x`, then the negative of the function `f` (i.e., the function `g` defined as `g(x) = -f(x)`) is also `n`-times continuously differentiable within the same subset `s` at the same point `x`. This is a generalization of the fact that the derivative of a negated function is the negation of the derivative of the original function.

If a function is `n`-times continuously differentiable within a subset of a normed space at a point, then the negative of the function is also `n`-times continuously differentiable at that point in the same subset.


theorem MeasureTheory.AEEqFun.stronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (f : α →ₘ[μ] β), MeasureTheory.StronglyMeasurable ↑f :=
  by sorry

This theorem states that for any given measurable space 'α', measure 'μ' of 'α', and any function 'f' from 'α' to topological space 'β' (where 'f' is an equivalence class of measurable functions modulo almost everywhere equality with respect to measure 'μ'), the function 'f' is strongly measurable. Here, a function is defined as being strongly measurable if it is the limit of simple functions, in a sense that for every point in 'α', the function values at that point given by the sequence of simple functions converges to the function value of 'f' at that point.

Given a measurable space 'α', measure 'μ', and a measurable function 'f' from 'α' to a topological space 'β' (up to almost everywhere equality), 'f' is strongly measurable if and only if it is the limit of measurable simple functions.


Nat.Primrec'.sqrt

theorem Nat.Primrec'.sqrt : Nat.Primrec' fun v => Nat.sqrt (Vector.head v) := by sorry

This theorem states that the square root function, when applied to the first element of a vector, is primitive recursive. In other words, it asserts that the computation of the integer square root of the first element of a given vector can be described by a series of simple, repeatable steps, which is the essence of primitive recursion.

The function that computes the integer square root of the first element of a vector is primitive recursive.


theorem ack_zero : ∀ (n : ℕ), ack 0 n = n + 1 := by sorry

The theorem `ack_zero` asserts that for every natural number `n`, the Ackermann function `ack` with first argument as zero and second argument as `n` equals `n + 1`. In other words, if the first parameter to the Ackermann function is zero, the function simply increments the second parameter by one.

The Ackermann function `ack` with argument `0` equals `n + 1` for every natural number `n`.


theorem Fin.cast_nat_eq_last : ∀ (n : ℕ), ↑n = Fin.last n := by sorry

This theorem states that for all natural numbers `n`, the canonical embedding of `n` to the type `Fin (n+1)` is equal to the greatest value in `Fin (n+1)`. In other words, when we cast a natural number `n` to the type `Fin (n+1)`, we get the last, or maximum, element in the finite ordered set `Fin (n+1)`. This ordered set contains `n + 1` elements indexed from `0` to `n`.

The canonical embedding of a natural number `n` into `Fin (n+1)` is the greatest element in `Fin (n+1)`.


theorem Path.Homotopic.map_lift :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x₀ x₁ : X} (P₀ : Path x₀ x₁)
      (f : C(X, Y)), ⟦Path.map P₀ ⋯⟧ = Path.Homotopic.Quotient.mapFn ⟦P₀⟧ f :=
  by sorry

The theorem `Path.Homotopic.map_lift` states that for any two points `x₀` and `x₁` in a topological space `X`, any path `P₀` from `x₀` to `x₁`, and any continuous function `f` from `X` to another topological space `Y`, the homotopy class (equivalence class of paths under homotopy) of the image of `P₀` under `f` is equal to the image of the homotopy class of `P₀` under `f`. In more mathematical terms, it asserts that the function `Path.Homotopic.Quotient.mapFn` is well-defined on homotopy classes of paths, meaning that the result of first mapping a path and then taking the homotopy class is the same as first taking the homotopy class and then mapping.

The homotopy class of a path in a topological space under a continuous function is equal to the image of its homotopy class under that function.


theorem Cardinal.exists_eq_of_iSup_eq_of_not_isLimit :
    ∀ {ι : Type u} [hι : Nonempty ι] (f : ι → Cardinal.{v}),
      BddAbove (Set.range f) → ∀ (ω : Cardinal.{v}), ¬Cardinal.IsLimit ω → ⨆ i, f i = ω → ∃ i, f i = ω :=
  by sorry

The theorem `Cardinal.exists_eq_of_iSup_eq_of_not_isLimit` states that for any type `ι` which is nonempty and a function `f` from `ι` to a cardinal number, if the range of `f` is bounded above and `ω` is a cardinal number that is not a limit cardinal, then if the supremum of `f` over `ι` is equal to `ω`, there exists an element in `ι` such that applying `f` to this element yields `ω`. Essentially, it means if a cardinal number is the least upper bound of a set of cardinals and it's not a limit cardinal, then this cardinal is in the image of the function defining the set.

If `ι` is a nonempty type, `f: ι → cardinal` has a bounded range, and `ω` is a non-limit cardinal, then `sup (range f) = ω` implies the existence of `x ∈ ι` such that `f x = ω`.


/-- If the codomain of an injective continuous function is a Hausdorff space, then so is its
domain.  -/
theorem T2Space.of_injective_continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space Y]
      {f : X → Y}, Function.Injective f → Continuous f → T2Space X :=
  by sorry

The theorem `T2Space.of_injective_continuous` states that if we have an injective continuous function from a space 'X' to a space 'Y', and 'Y' is a Hausdorff space (T2 space), then 'X' is also a Hausdorff space. A Hausdorff space is a topological space in which distinct points have disjoint neighborhoods, an injective function is one where different inputs always produce different outputs, and a continuous function is one that does not have jumps or breaks.

If a continuous, injective function maps a Hausdorff space to another Hausdorff space, then the domain space is Hausdorff.


theorem MeasureTheory.withDensityᵥ_neg :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_3} [inst : NormedAddCommGroup E]
      [inst_1 : NormedSpace ℝ E] {f : α → E},
      MeasureTheory.Measure.withDensityᵥ μ (-f) = -MeasureTheory.Measure.withDensityᵥ μ f :=
  by sorry

This theorem states that for any measurable space `α` with a measure `μ`, and any real-valued function `f` defined on `α`, the measure with density `-f` is equal to the negation of the measure with density `f`. Here, `E` is any normed additive commutative group that is also a normed space over the real numbers. In other words, the measure-theoretic "with density" operation preserves the negation operation.

For any measurable space `(α, Σ, μ)` and real-valued function `f` on `α`, the measure `μ` with density `-f` is equal to the negative of the measure with density `f`, i.e., `-μ{f} = μ{-f}`.


theorem ENNReal.toNNReal_inv : ∀ (a : ENNReal), a⁻¹.toNNReal = a.toNNReal⁻¹ := by sorry

This theorem states that for every element `a` of the extended nonnegative real numbers (which is typically denoted as [0, ∞]), the operation of taking the inverse in the extended nonnegative reals followed by the operation of converting to the nonnegative reals is the same as first converting to the nonnegative reals and then taking the inverse. Therefore, the inverse operation in the extended nonnegative real numbers preserves the structure of the nonnegative real numbers when it comes to inversion.

For every extended nonnegative real number `a`, the operations of taking the inverse in the extended nonnegative reals and then converting to the nonnegative reals, and converting to the nonnegative reals and then taking the inverse, are equal. In Lean notation: `(0 ≤ a ∧ a ≤ ∞) → (∥−1∥ a = ∥−1∥ (convert a to ℝ0+))`.


theorem Set.piecewise_le :
    ∀ {α : Type u_1} {δ : α → Type u_7} [inst : (i : α) → Preorder (δ i)] {s : Set α}
      [inst_1 : (j : α) → Decidable (j ∈ s)] {f₁ f₂ g : (i : α) → δ i},
      (∀ i ∈ s, f₁ i ≤ g i) → (∀ i ∉ s, f₂ i ≤ g i) → Set.piecewise s f₁ f₂ ≤ g :=
  by sorry

The theorem `Set.piecewise_le` states that for any type `α` and a function `δ` that maps `α` to a type with a `Preorder` structure (i.e., a type that has a partial order satisfying transitivity and reflexivity), given a set `s` of type `α` and three functions `f₁`, `f₂`, and `g` of type α to δ, if `f₁` is less than or equal to `g` for all elements of `s`, and `f₂` is less than or equal to `g` for all elements not in `s`, then the piecewise function defined by `s`, `f₁`, `f₂` (which is equal to `f₁` on `s` and to `f₂` on the complement of `s`) is less than or equal to `g`. This theorem essentially states that if a function is less than or equal to another function on a set and its complement, then the piecewise function defined by these two functions is also less than or equal to the latter function.

Given a preorder type `δ`, a set `s` of an arbitrary type `α`, and functions `f₁`, `f₂`, and `g` from `α` to `δ` such that `f₁ ≤ g` on `s` and `f₂ ≤ g` on the complement of `s`, then the piecewise function `(λx, if x ∈ s then f₁ x else f₂ x)` is less than or equal to `g`.


theorem Mathlib.Data.Real.Sqrt._auxLemma.17 : ∀ {x : ℝ}, (0 < Real.sqrt x) = (0 < x) := by sorry

This theorem states that for all real numbers `x`, the square root of `x` is positive if and only if `x` itself is positive. In other words, there is a direct correspondence between the positivity of a real number and the positivity of its square root, as calculated by the `Real.sqrt` function. Note that the `Real.sqrt` function returns 0 for negative inputs.

For all real numbers `x`, `x` is positive if and only if the square root of `x` is positive.


theorem Disjoint.sup_sdiff_cancel_left :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, Disjoint a b → (a ⊔ b) \ a = b := by sorry

The theorem `Disjoint.sup_sdiff_cancel_left` states that for any type `α` that forms a Generalized Coheyting Algebra and for any elements `a` and `b` of that type, if `a` and `b` are disjoint (meaning that the greatest lower bound of `a` and `b` is the least possible element), then the result of subtracting `a` from the least upper bound of `a` and `b` yields `b`. This parallels the behavior of set subtraction in the context of disjoint sets.

For any type `α` forming a Generalized Cohen algebra and disjoint elements `a` and `b` of `α`, the least upper bound of `a` and `b` minus `a` equals `b`.


/-- **Alias** of `Left.add_pos'`. -/
theorem add_pos' :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, 0 < a → 0 < b → 0 < a + b :=
  by sorry

This theorem, referred to as `add_pos'`, states that for any type `α` that has properties of an additive zero class and a preorder, and for which addition is a covariant operation, if `a` and `b` are elements of `α` such that both `a` and `b` are greater than zero, then their sum `a + b` is also greater than zero. The conditions imposed on `α` ensure that it behaves like a number system with respect to addition, order, and the zero element.

If `α` is an additive zero class and a preordered type with covariant addition, then for all `a, b ∈ α` with `a, b > 0`, we have `a + b > 0`.


theorem Mathlib.Data.Real.Sqrt._auxLemma.13 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) := by sorry

This theorem states that for any type `α` that has a partial order, given any two elements `a` and `b` of this type, `a` is equal to `b` if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`. In other words, two elements are equal in a partial order setting if they are mutually less than or equal to each other.

In a partial order, two elements are equal if and only if they mutually satisfy the relationship of being less than or equal to each other.


Nat.dist.def

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

The theorem `Nat.dist.def` states that for all natural numbers `n` and `m`, the distance between `n` and `m`, as defined by `Nat.dist`, is equivalent to the sum of `n - m` and `m - n`. In other words, it confirms that the distance between two natural numbers `n` and `m` can be calculated by subtracting `m` from `n`, adding the result to the difference of `m` and `n`. This theorem essentially describes the property of the defined distance function between natural numbers.

The theorem `Nat.dist.def` asserts that for all natural numbers `n` and `m`, `Nat.dist n m` equals the sum of `|n - m|` and `|m - n|`.


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

This theorem states that in a right-angled triangle, the length of one side divided by the cosine of the angle adjacent to that side equals the length of the hypotenuse. Here, the triangle is described in a real inner product space, with `x` and `y` as its vectors. Given the condition that the inner product of `x` and `y` equals 0 (which implies that the angle between them is a right angle), and either `x` is non-zero or `y` is zero, it confirms the said geometric relation about a right-angled triangle: the magnitude of `x` divided by the cosine of the angle between `x` and the vector sum of `x` and `y` equals the magnitude of this vector sum.

In a right-angled triangle in a real inner product space, the ratio of the length of one side to the cosine of the angle between that side and the hypotenuse is equal to the length of the hypotenuse.


theorem List.mem_map_of_injective :
    ∀ {α : Type u} {β : Type v} {f : α → β},
      Function.Injective f → ∀ {a : α} {l : List α}, f a ∈ List.map f l ↔ a ∈ l :=
  by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, if `f` is injective (i.e., if for any two elements `x` and `y` from `α`, `f(x) = f(y)` implies `x = y`), and for any element `a` from `α` and any list `l` of elements from `α`, then `f(a)` is an element of the list obtained by applying `f` to each element of `l` if and only if `a` is an element of `l`. In other words, under the condition that `f` is injective, an element `a` is in the list `l` if and only if its image under `f` is in the image of the list under the mapping `f`.

For any injective function `f` from type `α` to type `β`, and for any list `l` of elements from `α`, an element `a` from `α` is in `l` if and only if `f(a)` is in the image of `l` under `f`.


theorem NeZero.of_pos : ∀ {M : Type u_2} {x : M} [inst : Preorder M] [inst_1 : Zero M], 0 < x → NeZero x := by sorry

This theorem, `NeZero.of_pos`, states that for any type `M` with a pre-order (`Preorder`) and a defined zero (`Zero`), if a value `x` of type `M` is greater than zero, then `x` is not equal to zero. In other words, any positive number in a preordered set with a defined zero is not equal to zero.

If `x` is greater than zero in a preordered type `M` with defined zero, then `x ≠ 0`.


theorem MeasureTheory.Measure.restrict_inter_add_diff₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {t : Set α} (s : Set α),
      MeasureTheory.NullMeasurableSet t μ → μ.restrict (s ∩ t) + μ.restrict (s \ t) = μ.restrict s :=
  by sorry

This theorem states that for any given type `α` with a corresponding `MeasurableSpace` and a measure `μ`, and any two sets `s` and `t` of type `α` where `t` is a `NullMeasurableSet`, the measure of the intersection of `s` and `t` added to the measure of the difference of `s` and `t` is equal to the measure of `s` itself. In mathematical terms, if `μ` is a measure and `s` and `t` are sets with `t` being null measurable, then `μ(s ∩ t) + μ(s \ t) = μ(s)`.

For any measure `μ` and null measurable sets `s` and `t` in a measurable space, `μ(s ∩ t) + μ(s \ t) = μ(s)`.


theorem CategoryTheory.Limits.ι_comp_coequalizerComparison :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Limits.HasCoequalizer f g]
      [inst_3 : CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π (G.map f) (G.map g))
          (CategoryTheory.Limits.coequalizerComparison f g G) =
        G.map (CategoryTheory.Limits.coequalizer.π f g) :=
  by sorry

This theorem states that, given a category `C` and two morphisms `f` and `g` from `X` to `Y` in `C`, along with a functor `G` mapping `C` to another category `D`, if `f` and `g` have a coequalizer in `C` and the functors `G.map f` and `G.map g` have a coequalizer in `D`, then the composition of the coequalizer projection of `G.map f` and `G.map g` in `D` followed by the coequalizer comparison of `f` and `g` under `G` equals the `G`-mapping of the coequalizer projection of `f` and `g` in `C`. In mathematical terms, we have the following equality of morphisms in the category `D`: `(coequalizer.π (G.map f) (G.map g)) ≫ (coequalizerComparison f g G) = (G.map (coequalizer.π f g))`.

Given a category `C`, a functor `G` from `C` to another category `D`, and morphisms `f` and `g` in `C` with coequalizers, if `G.map f` and `G.map g` have a coequalizer in `D`, then the projection of the coequalizer of `G.map f` and `G.map g` in `D` equals the `G`-map of the coequalizer projection of `f` and `g` in `C`.


theorem gcdMonoidOfLCM.proof_1 :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] (lcm : α → α → α),
      (∀ {a b c : α}, c ∣ a → b ∣ a → lcm c b ∣ a) → ∀ (a b : α), lcm a b ∣ a * b :=
  by sorry

This theorem states that for any type `α` that forms a cancel commutative monoid with zero and for any `lcm` function (least common multiple), if for all `a`, `b`, and `c` of type `α`, `c` divides `a` and `b` divides `a` implies that the `lcm` of `c` and `b` divides `a`, then for any `a` and `b` of type `α`, the `lcm` of `a` and `b` divides the product of `a` and `b`. In more mathematical terms, it states that if for all `c`, `b`, `a` in `α`, `c | a` and `b | a` implies `lcm(c,b) | a`, then for any `a`, `b` in `α`, `lcm(a,b) | a*b`.

If `α` is a cancel commutative monoid with zero and for all `a`, `b`, `c` in `α`, `c` divides `a` and `b` divides `a` implies that the least common multiple of `c` and `b` divides the product of `a` and `b`, then for all `a`, `b` in `α`, the least common multiple of `a` and `b` divides the product `a * b`.


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

This theorem states that for any normed addition commutative group `E`, which is also a normed space over the real numbers, and for any real numbers `a`, `b`, and `c` (where `c` is not equal to zero), the integral of the function `f(c * x)` from `a` to `b` equals `c` to the power of `-1` times the integral of the function `f(x)` from `c * a` to `c * b`. Basically, it's a statement about the change of variables in integration in the context of normed spaces.

For any normed additive group `E` over the real numbers, and for any continuously differentiable function `f` and real numbers `a, b, c (≠ 0)`, the integral of `f(c*x)` from `a/c` to `b/c` equals `1/c` times the integral of `f(x)` from `a` to `b`.


theorem Finset.mem_of_min : ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α} {a : α}, Finset.min s = ↑a → a ∈ s :=
  by sorry

This theorem, named `Finset.mem_of_min`, says that for any given set `s` of a type `α` that has a linear order, and any element `a` of type `α`, if the minimum value of the set `s` is equal to `a` (denoted in Lean 4 by `Finset.min s = ↑a`), then `a` must be an element of the set `s`. In plain English, if a number is the minimum of a set, it is necessarily a member of that set. This theorem holds for any type `α` that has a defined linear order.

If `s` is a linearly ordered set and `a` is its minimum element, then `a` belongs to `s`.


theorem InnerProductSpace.Core.inner_add_left :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] (x y z : F), ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜 :=
  by sorry

This theorem, `InnerProductSpace.Core.inner_add_left`, states that for any types `𝕜` and `F` where `𝕜` is a ring-like structure and `F` is an additive commutative group that also forms a module over `𝕜`, with `c` being an inner product space core over `𝕜` and `F`, the inner product of the sum of two elements `x` and `y` with a third element `z` is equal to the sum of the inner products of `x` with `z` and `y` with `z`. This is to say, inner product operation is distributive over vector addition on the left side.

For any inner product space core `c` over commutative ring `𝕜` and additive commutative group `F`, the inner product `��ôt(x + y, z)` equals `��ôt(x, z) + ��ôt(y, z)` for all `x, y, z` in `F`.


theorem Mathlib.ModelTheory.Substructures._auxLemma.13 :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] {S : FirstOrder.Language.Substructure L N}
      {f : FirstOrder.Language.Hom L M N} {x : M}, (x ∈ FirstOrder.Language.Substructure.comap f S) = (f x ∈ S) :=
  by sorry

This theorem states that for any first-order language `L`, any types `M` and `N`, any structures `inst` of `L` over `M` and `inst_1` of `L` over `N`, any substructure `S` of `L` over `N`, any homomorphism `f` from `M` to `N`, and any element `x` of `M`, the element `x` is in the preimage of the substructure `S` under the homomorphism `f` if and only if the image of `x` under `f` is in `S`. This is a fundamental property of preimages under homomorphisms in the context of substructures in model theory.

For any homomorphism between structures and any substructure, an element is in the preimage of the substructure if and only if its image is in the substructure.


theorem Mathlib.ModelTheory.Substructures._auxLemma.23 :
    ∀ {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 : N},
      (x ∈ FirstOrder.Language.Hom.range f) = ∃ y, f y = x :=
  by sorry

This theorem asserts that for any first-order language `L`, types `M` and `N`, and given the structures of `L` on `M` and `N`, if `f` is a homomorphism from `M` to `N` and `x` is an element of `N`, then `x` is in the range of `f` if and only if there exists an element `y` in `M` such that `f(y)` equals `x`. In other words, an element `x` of `N` belongs to the range of the homomorphism `f` iff `x` is the image of some element in `M` under `f`.

For any homomorphism $f$ from type $M$ to type $N$ in a first-order language $L$, and for any $x$ in $N$, $x$ is in the image of $f$ if and only if there exists an $y$ in $M$ such that $f(y) = x$.


theorem Hyperreal.isSt_sSup : ∀ {x : ℝ*}, ¬Hyperreal.Infinite x → Hyperreal.IsSt x (sSup {y | ↑y < x}) := by sorry

This theorem states that for every hyperreal number `x` that is not infinite, the standard part of `x` is the supremum of the set of all real numbers `y` that are strictly less than `x`. In other words, if `x` is a hyperreal number that is not infinitely large or infinitely small, then the closest real number to `x` (in a sense made precise by the `IsSt` predicate) is the least upper bound (or supremum, denoted by `sSup`) of all the real numbers that are less than `x`.

For every finite hyperreal number `x`, the real number `sSup { y | y < x }` is the standard part of `x`.


theorem Function.mulSupport_eq_empty_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M}, Function.mulSupport f = ∅ ↔ f = 1 := by sorry

The theorem `Function.mulSupport_eq_empty_iff` states that for any type `α`, a type `M` with a defined "one" element, and a function `f` from `α` to `M`, the `mulSupport` of `f` is an empty set if and only if `f` is a constant function returning the "one" element of `M`. In other words, the `mulSupport` of `f` contains no elements precisely when `f(x)` equals "one" for all `x` in `α`.

For any type α and a function f from α to a type M with a "one" element, the set of multiples of f is empty if and only if f is the constant function mapping all of α to the "one" element of M.


theorem Nat.add_le_of_le_sub' : ∀ {n k m : ℕ}, m ≤ k → n ≤ k - m → m + n ≤ k := by sorry

This theorem states that for any three natural numbers `n`, `k`, and `m`, if `m` is less than or equal to `k` and `n` is less than or equal to the difference of `k` and `m`, then the sum of `m` and `n` is less than or equal to `k`. In other words, if we subtract a certain amount from a number and the remaining value is still larger than or equal to another number, then the sum of the subtracted amount and the other number will not exceed the original number.

If `m` is less than or equal to `k` and `n` is less than or equal to `k - m`, then `m + n` is less than or equal to `k`.


/-- If there exists a multiplication-preserving equivalence between `G` and `H`,
then the exponent of `G` is equal to the exponent of `H`.
 -/
theorem Monoid.exponent_eq_of_mulEquiv :
    ∀ {G : Type u} [inst : Monoid G] {H : Type u_1} [inst_1 : Monoid H],
      G ≃* H → Monoid.exponent G = Monoid.exponent H :=
  by sorry

The theorem `Monoid.exponent_eq_of_mulEquiv` states that for any two groups `G` and `H`, if there exists a multiplication-preserving equivalence (an isomorphism) between `G` and `H`, then the exponent of `G` is equal to the exponent of `H`. Here, the exponent of a group is defined as the smallest positive integer `n` such that every element of the group raised to the power `n` equals the identity, if such an integer exists; otherwise, it is conventionally defined as zero.

If there exists an isomorphism between groups `G` and `H` that preserves group multiplication, then the exponent of `G` equals the exponent of `H`.


theorem Cardinal.sum_le_iSup : ∀ {ι : Type u} (f : ι → Cardinal.{u}), Cardinal.sum f ≤ Cardinal.mk ι * iSup f := by
  sorry

The theorem `Cardinal.sum_le_iSup` asserts that, for any type `ι` and any function `f` from `ι` to cardinal numbers, the sum of the cardinal numbers (as given by the function `f`) is less than or equal to the product of the cardinality of the type `ι` and the indexed supremum of the function `f`. In more familiar mathematical terms, this is stating that for a collection of sets indexed by `ι`, the total cardinality (number of elements) across all sets is less than or equal to the number of sets times the largest set's cardinality.

For any type ι and function f from ι to cardinal numbers, the sum of the images of cardinal numbers under f is less than or equal to the product of the cardinality of ι and the supremum of f.


theorem continuous_left_toIocMod :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedAddCommGroup 𝕜] [inst_1 : Archimedean 𝕜] [inst_2 : TopologicalSpace 𝕜]
      [inst_3 : OrderTopology 𝕜] {p : 𝕜} (hp : 0 < p) (a x : 𝕜), ContinuousWithinAt (toIocMod hp a) (Set.Iic x) x :=
  by sorry

This theorem states that for any type `𝕜` that forms a linear ordered additive commutative group, is Archimedean, and has a topological space structure with an order topology, and for any positive real number `p`, and two arbitrary elements `a` and `x` of type `𝕜`, the function `toIocMod` with parameters `hp` and `a` is continuous at the point `x` within the set of all elements less than or equal to `x` in the order of type `𝕜`. In simpler terms, if we are moving towards `x` only through values less than or equal to `x`, then `toIocMod` function will always move continuously without jumps or disruptions.

For any Archimedean, linearly ordered, additively commutative topological group `𝕜` and real number `p`, the function `toIocMod p` is continuous on the set of elements less than or equal to any given element `x` in `𝕜`.


/-- This is the key identity satisfied by `σ`.  -/
theorem CategoryTheory.NonPreadditiveAbelian.σ_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp CategoryTheory.NonPreadditiveAbelian.σ f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f f)
          CategoryTheory.NonPreadditiveAbelian.σ :=
  by sorry

This theorem states that for any category `C` of Type `u`, which has the structure of a non-preadditive Abelian category, and for any objects `X` and `Y` in this category, the composition of the morphism `σ` (from the non-preadditive Abelian structure) with any morphism `f` from `X` to `Y` is equal to the composition of the morphism resulting from mapping `f` across the product with the morphism `σ`. This is a key identity satisfied by the morphism `σ` in a non-preadditive Abelian category. In other words, the theorem states that `σ` composed with `f` equals the composition of `(f,f)` mapped on the product with `σ`.

In a non-preadditive Abelian category, for any object `X`, object `Y`, and morphism `f` from `X` to `Y`, the composition of `σ` with `f` equals the composition of `(f, f)` mapped on the product with `σ`.


theorem PowerSeries.coeff_C_mul :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (φ : PowerSeries R) (a : R),
      (PowerSeries.coeff R n) ((PowerSeries.C R) a * φ) = a * (PowerSeries.coeff R n) φ :=
  by sorry

This theorem states that for any semiring `R`, any natural number `n`, any formal power series `φ` over `R`, and any element `a` of the semiring `R`, the `n`th coefficient of the formal power series resulting from multiplying the constant formal power series generated by `a` and `φ`, is equal to `a` multiplied by the `n`th coefficient of `φ`. In mathematical terms, you can consider `PowerSeries.coeff R n` as a function extracting the `n`th coefficient from a formal power series, and `PowerSeries.C R` as a function creating a constant power series from a semiring element. The theorem then essentially states that these functions have a distributive-like property.

For any semiring `R`, the `n`th coefficient of the product of the constant power series `PowerSeries.C R a` and formal power series `φ` over `R`, is equal to the product of element `a` and the `n`th coefficient of `φ`.


theorem Filter.inv_cobounded₀ :
    ∀ {α : Type u_1} [inst : NormedDivisionRing α], (Bornology.cobounded α)⁻¹ = nhdsWithin 0 {0}ᶜ := by sorry

The theorem `Filter.inv_cobounded₀` states that for any normed division ring `α`, the inverse of the filter of cobounded sets in the bornology of `α` is equal to the "neighborhood within" filter at 0 for the set that is the complement of the singleton set containing 0. In other words, this theorem is establishing a relationship between two different ways of describing certain types of "large" sets in a normed division ring: one using the concept of a cobounded set in a bornology, and the other using the concept of a "neighborhood within" a certain set.

The filter of cobounded sets in the bornology of a normed division ring is equal to the "neighborhood within" filter at 0 for the set of sets containing 0 as an interior point.


/-- A union of a family of preconnected sets with a common point is preconnected as well.  -/
theorem isPreconnected_sUnion :
    ∀ {α : Type u} [inst : TopologicalSpace α] (x : α) (c : Set (Set α)),
      (∀ s ∈ c, x ∈ s) → (∀ s ∈ c, IsPreconnected s) → IsPreconnected (⋃₀ c) :=
  by sorry

The theorem `isPreconnected_sUnion` states that if we have a family of sets in a topological space, where each of the sets is preconnected and they all have a common point, then the union of these sets is also preconnected. In other words, if for all sets in a collection `c`, a point `x` is contained in the set and the set is preconnected, then the union over this collection `c` is also preconnected.

If every set in a family has a common point and is preconnected, then the union of the sets is preconnected.


/-- Alternative formulation of `measure_theory.signed_measure.exists_is_compl_positive_negative`
(the Hahn decomposition theorem) using set complements.  -/
theorem MeasureTheory.SignedMeasure.exists_compl_positive_negative :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α),
      ∃ i,
        MeasurableSet i ∧
          MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict s i ∧
            MeasureTheory.VectorMeasure.restrict s iᶜ ≤ MeasureTheory.VectorMeasure.restrict 0 iᶜ :=
  by sorry

This theorem is an alternative formulation of the Hahn decomposition theorem using set complements. It states that for every signed measure `s` on a measurable space `α`, there exists a measurable set `i` such that the restriction of the zero vector measure to `i` is less than or equal to the restriction of `s` to `i`, and the restriction of `s` to the complement of `i` is less than or equal to the restriction of the zero vector measure to the complement of `i`. In other words, `s` is positive on `i` and negative on `i` complement.

For every signed measure `s` on a measurable space `α`, there exists a measurable subset `i` such that `s(A) ≤ 0` for all `A ∉ i` and `s(A) ≥ 0` for all `A ∋ i`.


theorem interior_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a : α},
      interior (Set.Ioi a) = Set.Ioi a :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure, a linear order, and a topology where the half-closed, right-infinite intervals are closed, and a given element `a` of type `α`, the interior of the set of all elements greater than `a` is exactly the set itself. In other words, the set of all elements strictly greater than `a` is an open set in this topology.

For any type `α` endowed with a topological space structure, a linear order, and a topology where right-open, half-closed intervals are closed, the set of elements strictly greater than a given `a` in `α` is the interior of this set in the topology.


theorem Int.lt_irrefl : ∀ (a : ℤ), ¬a < a := by sorry

This theorem states that for any integer `a`, it is not possible for `a` to be less than itself. In other words, there are no integer values for which the proposition "this integer is less than itself" would be true. This is a fundamental rule in mathematics, often referred to as the irreflexivity of the 'less than' relationship for integers.

For all integers a, a is not less than a.


theorem Nat.even_add : ∀ {m n : ℕ}, Even (m + n) ↔ (Even m ↔ Even n) := by sorry

This theorem states that for all natural numbers `m` and `n`, the sum `m + n` is even if and only if `m` and `n` are both even or both odd. In other words, the parity of the sum of two natural numbers is the same as the parity of the individual numbers. Here, `Even` is a property of a number that is defined to be true if the number can be expressed as the sum of two equal numbers.

The sum of two natural numbers is even if and only if both numbers are even or both are odd.


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

This theorem is about multisets in the field of mathematics. It states that for any type `α`, and for any multisets `s` and `t` of this type, along with any element `a` of the same type, if `a` is not a member of the multiset `s`, then `s` is less than or equal to the multiset formed by appending `a` to `t` (`a ::ₘ t`) if and only if `s` is less than or equal to `t`. Here, `≤` denotes the multiset inclusion relation, meaning that all elements of `s` are also elements of `t` or `a ::ₘ t`.

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


Continuous.aemeasurable

/-- A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is ae-measurable.  -/
theorem Continuous.aemeasurable :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ]
      [inst_5 : BorelSpace γ] {f : α → γ}, Continuous f → ∀ {μ : MeasureTheory.Measure α}, AEMeasurable f μ :=
  by sorry

This theorem states that for any continuous function `f` from an open measurable space `α` to a Borel space `γ`, `f` is almost everywhere measurable with respect to any measure `μ` on `α`. In other words, we can find a measurable function that coincides with `f` almost everywhere in the domain. Here, an open measurable space is a measurable space that is generated by open sets, and a Borel space is a measure space that is generated by the topology.

Given a continuous function `f` from an open measurable space `(α, ��ößα)` to a Borel space `(γ, ��ößγ)` with respect to any measure `μ` on `α`, there exists a measurable function `g` such that `μ({x : α | f x ≠ g x}) = 0`.


theorem interior_Iio :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a : α},
      interior (Set.Iio a) = Set.Iio a :=
  by sorry

This theorem states that for any type `α` equipped with a topological space, a linear order, and a topology where every set of the form `{x | x ≥ a}` is closed, the interior of the set of elements that are strictly less than `a` (denoted as `Set.Iio a`) is equal to the set `Set.Iio a` itself. This means that the largest open subset of `Set.Iio a` (which is its interior) is the set `Set.Iio a` itself.

For any type `α` endowed with a topological space, a linear order, and a topology where every set of the form `{x | x < a}` is closed, the interior of the set of elements strictly less than `a` (`Set.Iio a`) equals `Set.Iio a` itself.


theorem Real.neg_one_le_sin : ∀ (x : ℝ), -1 ≤ Real.sin x := by sorry

The theorem `Real.neg_one_le_sin` states that for all real numbers `x`, the sine of `x` is greater than or equal to -1. This is a property of the sine function, which always takes values between -1 and 1 for any input real number.


theorem Basis.det_self :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_4}
      [inst_3 : DecidableEq ι] [inst_4 : Fintype ι] (e : Basis ι R M), (Basis.det e) ⇑e = 1 :=
  by sorry

The theorem `Basis.det_self` states that for any commutative ring `R`, any additive commutative group `M` that is also a module over the ring `R`, and any finite type `ι` with decidable equality, if `e` is a basis of `M` with respect to `R` and `ι`, then the determinant of the basis `e` evaluated at the basis `e` is 1. In other words, the determinant of the matrix representation of a basis with respect to itself is always 1.

For any commutative ring R, additive commutative group M as an R-module with finite decidable equality basis e, the determinant of e evaluated at e equals 1.


IsIntegralClosure.isDedekindDomain

theorem IsIntegralClosure.isDedekindDomain :
    ∀ (A : Type u_2) (K : Type u_3) [inst : CommRing A] [inst_1 : Field K] [inst_2 : IsDomain A] [inst_3 : Algebra A K]
      [inst_4 : IsFractionRing A K] (L : Type u_4) [inst_5 : Field L] (C : Type u_5) [inst_6 : CommRing C]
      [inst_7 : Algebra K L] [inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : Algebra C L]
      [inst_11 : IsIntegralClosure C A L] [inst_12 : Algebra A C] [inst_13 : IsScalarTower A C L]
      [inst_14 : FiniteDimensional K L] [inst_15 : IsSeparable K L] [inst_16 : IsDomain C] [inst : IsDedekindDomain A],
      IsDedekindDomain C :=
  by sorry

This theorem states that for any commutative ring `A`, field `K`, and integral domain `C` such that `K` is the field of fractions of `A`, `C` is an integral closure of `A` in a field `L`, and `L` is a finite dimensional separable field extension of `K`, if `A` is a Dedekind domain, then `C` is also a Dedekind domain. In mathematical terms, it signifies that under the given conditions, the property of being a Dedekind domain is preserved upon taking an integral closure.

If `A` is a commutative Dedekind domain, `K` is its field of fractions, `C` is an integral closure of `A` in a finite dimensional separable field extension `L` of `K`, then `C` is a Dedekind domain.


theorem iInf_bool_eq : ∀ {α : Type u_1} [inst : CompleteLattice α] {f : Bool → α}, ⨅ b, f b = f true ⊓ f false := by
  sorry

This theorem states that for all types `α` that form a complete lattice, and for any function `f` from `Bool` to `α`, the infimum (greatest lower bound) over all boolean values `b` of `f(b)` is equal to the logical conjunction (AND operation) of `f(true)` and `f(false)`. Essentially, it says that the lowest value `f` can take on the boolean domain is the minimum of `f(true)` and `f(false)`.

For any complete lattice type `α` and boolean-valued function `f`: `⨧(f true, f false) = ⨋(set {bool.true, bool.false} ↔ f)` where `⨋` denotes the infimum (greatest lower bound) and `⨧` denotes the logical conjunction (AND).


theorem LinearIndependent.of_isLocalizedModule :
    ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
      [inst_2 : Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {M' : Type u_4} [inst_3 : AddCommMonoid M]
      [inst_4 : Module R M] [inst_5 : AddCommMonoid M'] [inst_6 : Module R M'] [inst_7 : Module Rₛ M']
      [inst_8 : IsScalarTower R Rₛ M'] (f : M →ₗ[R] M') [inst_9 : IsLocalizedModule S f] {ι : Type u_5} {v : ι → M},
      LinearIndependent R v → LinearIndependent Rₛ (⇑f ∘ v) :=
  by sorry

The theorem `LinearIndependent.of_isLocalizedModule` asserts that if a family of vectors `v` is linearly independent over a commutative semiring `R`, then the image of this family under a linear map `f` is linearly independent over a localization `Rₛ` of `R`, assuming the module `M` on which the vectors act is localized with respect to a submonoid `S` of `R`. This holds under the assumptions that `Rₛ` is an algebra over `R`, that `M'` (the co-domain of `f`) is a module over both `R` and `Rₛ`, and that `Rₛ` acts on `M'` in a way that is compatible with the action of `R` (that is, there is a scalar tower).

If a family of vectors is linearly independent over a commutative semiring, then their images under a linear map are linearly independent over the localization of the semiring, provided the module acts and is localized with respect to a submonoid, and the localization is an algebra over the semiring and acts compatibly on the co-domain of the map.


theorem InitialSeg.init_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≼i s) {a : α} {b : β},
      s b (f a) ↔ ∃ a', f a' = b ∧ r a' a :=
  by sorry

This theorem, named `InitialSeg.init_iff`, states that for all types `α` and `β`, and for all relations `r` on `α` and `s` on `β`, if there exists an initial segment function `f` from `r` to `s`, then for any `a` in `α` and `b` in `β`, `s b (f a)` is equivalent to the statement that there exists an `a'` in `α` such that `f a'` is equal to `b` and `r a' a` is true. In other words, `b` is related to the image of `a` under `f` in the relation `s` if and only if `b` is the image under `f` of some `a'` that is related to `a` in the relation `r`.

For all relations $r$ on type $\alpha$ and $s$ on type $\beta$, and for any function $f$ that is an initial segment from $r$ to $s$, $s(b)(f(a))$ holds if and only if there exists $a'$ such that $f(a') = b$ and $r(a' , a)$ holds.


theorem ProbabilityTheory.kernel.indepSets_of_indepSets_of_le_left :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s₃ : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.IndepSets s₁ s₂ κ μ → s₃ ⊆ s₁ → ProbabilityTheory.kernel.IndepSets s₃ s₂ κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.indepSets_of_indepSets_of_le_left` states that for any types `α` and `Ω`, given measurable spaces `_mα` and `_mΩ`, and three sets of sets `s₁`, `s₂`, and `s₃`, along with a kernel `κ` from `α` to `Ω` and a measure `μ` on `α`, if sets `s₁` and `s₂` are independent with respect to the kernel `κ` and measure `μ`, and if all elements of `s₃` are also elements of `s₁` (i.e., `s₃` is a subset of `s₁`), then `s₃` and `s₂` are also independent with respect to the kernel `κ` and measure `μ`. In other words, the independence of sets with respect to a kernel and a measure is preserved under taking subsets.

If sets `s₁` and `s₂` are independent and `s₃ ⊆ s₁`, then `s₃` and `s₂` are independent in the measure `μ` with respect to the kernel `κ`.


theorem Filter.le_comap_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β}, f ≤ Filter.comap m (Filter.map m f) := by sorry

The theorem `Filter.le_comap_map` states that for any types `α` and `β`, for any filter `f` on `α`, and for any function `m` from `α` to `β`, the filter `f` is a subset of the filter obtained by taking the comap of the function `m` and the map of the function `m` over the filter `f`. This means that every set in the filter `f` is also in the filter formed by mapping `m` over `f` and then taking the comap of `m`.

For any filter $f$ on type $\alpha$ and function $m:\alpha \to \beta$, we have $f \subseteq \text{comap}(m) \circ \text{map}(m)(f)$.


theorem Monotone.le_csSup_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : ConditionallyCompleteLattice β] {f : α → β},
      Monotone f → ∀ {s : Set α} {c : α}, c ∈ s → BddAbove s → f c ≤ sSup (f '' s) :=
  by sorry

The theorem `Monotone.le_csSup_image` states that for any types `α` and `β`, where `α` has a preorder and `β` has a conditionally complete lattice structure, if there is a function `f` from `α` to `β` that is monotone, then for any set `s` of type `α` and any element `c` in `s`, if `s` is bounded above, then the image of `c` under `f` is less than or equal to the supremum of the image of `s` under `f`. In simpler terms, if a function is increasing and applied to a set that has an upper bound, then the value of the function at any point in the set is not greater than the maximum value the function takes on the set.

For any monotonic function from a preordered type to a conditionally complete lattice, the image of any element in a bounded subset is less than or equal to the supremum of the images of that subset.


theorem Homeomorph.isClosed_image :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) {s : Set X},
      IsClosed (⇑h '' s) ↔ IsClosed s :=
  by sorry

The theorem `Homeomorph.isClosed_image` states that for any two types `X` and `Y` with associated topological spaces, given a homeomorphism `h` from `X` to `Y` and a set `s` of type `X`, the image of `s` under `h` is closed if and only if `s` itself is closed. This theorem can be used to check whether a set is closed after being mapped by a homeomorphism, by checking the closedness of the original set.

A homeomorphism preserves closed sets, that is, for any homeomorphism between topological spaces and any subset, the image of a closed set is closed.


theorem Mathlib.GroupTheory.Coset._auxLemma.3 :
    ∀ {α : Type u_1} [inst : Group α] {s : Set α} {x : α} (a : α), (x ∈ MulOpposite.op a • s) = (x * a⁻¹ ∈ s) := by
  sorry

The theorem, named `_auxLemma.3` from the `Mathlib.GroupTheory.Coset` module, states that for any type `α` that forms a group (denoted by `[inst : Group α]`), given a set `s` of elements of type `α`, and elements `x` and `a` of type `α`, the condition that `x` belongs to the set formed by applying the 'multiplication opposite operation' (`MulOpposite.op`) on `a` and then 'scaling' the set `s` (denoted by `MulOpposite.op a • s`), is equivalent to the condition that the product `x * a⁻¹` belongs to the set `s`. Here, `a⁻¹` represents the inverse of `a` in the group context.

For any group `α` and set `s` of elements, an element `x` belongs to the set `MulOpposite.op a • s` if and only if `x * a⁻¹` is in `s`.


theorem Mathlib.GroupTheory.Coset._auxLemma.2 :
    ∀ {α : Type u_1} [inst : Group α] {s : Set α} {x : α} (a : α), (x ∈ a • s) = (a⁻¹ * x ∈ s) := by sorry

This theorem, called `Mathlib.GroupTheory.Coset._auxLemma.2`, states that for any type `α` that forms a group (denoted by `[inst : Group α]`), given a set `s` of elements of type `α` and any elements `x` and `a` of type `α`, the element `x` is in the left coset of `s` by `a` (denoted by `a • s`), if and only if the product of the inverse of `a` and `x` (denoted by `a⁻¹ * x`) is in the set `s`. In the context of group theory, this theorem provides a condition for membership in a coset.

For any group `α` and `s ∈ α`, `x ∈ α`, an element `x` belongs to the left coset `s` under `a ∈ α` if and only if `a⁻¹ * x ∈ s`.


And.comm

theorem And.comm : ∀ {a b : Prop}, a ∧ b ↔ b ∧ a := by sorry

This theorem, `And.comm`, states that for any two propositions `a` and `b`, the logical conjunction `a ∧ b` (a AND b) is logically equivalent to `b ∧ a` (b AND a). This represents the commutative property of logical conjunction in propositional logic.

For all propositions `a` and `b`, `a ∧ b` is equivalent to `b ∧ a` in propositional logic.


theorem CategoryTheory.BicartesianSq.of_isPullback_isPushout :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
      {i : Y ⟶ Z},
      CategoryTheory.IsPullback f g h i → CategoryTheory.IsPushout f g h i → CategoryTheory.BicartesianSq f g h i :=
  by sorry

This theorem states that for any category `C` with objects `W`, `X`, `Y`, `Z`, and morphisms `f : W ⟶ X`, `g : W ⟶ Y`, `h : X ⟶ Z`, `i : Y ⟶ Z`, if the diagram formed by these objects and morphisms is a pullback and a pushout, then it is a bicartesian square. In the context of category theory, a pullback is a limit of a diagram, while a pushout is a colimit. A bicartesian square is a particular kind of diagram in a category that has both a pullback and a pushout.

If a diagram consisting of objects W, X, Y, Z and morphisms f : W ⟶ X, g : W ⟶ Y, h : X ⟶ Z, i : Y ⟶ Z forms both a pullback and a pushout square, then it is a bicartesian square.


MeasureTheory.NullMeasurableSet.mono

theorem MeasureTheory.NullMeasurableSet.mono :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → ν ≤ μ → MeasureTheory.NullMeasurableSet s ν :=
  by sorry

This theorem states that for any given type `α` and a measurable space `m0` over `α`, if you have two measures `μ` and `ν` on this measurable space and a set `s` of type `α` such that `s` is a null measurable set with respect to measure `μ`, then if measure `ν` is less than or equal to measure `μ`, `s` is also a null measurable set with respect to measure `ν`. In other words, the null measurability of a set under a given measure is preserved under a smaller or equal measure.

If `μ` is a measure that is larger than or equal to `ν` on a measurable space `(α, m0)`, and `s` is a null measurable set with respect to `μ`, then `s` is also a null measurable set with respect to `ν`.


Fin.eta

theorem Fin.eta : ∀ {n : ℕ} (a : Fin n) (h : ↑a < n), { val := ↑a, isLt := h } = a := by sorry

This theorem, `Fin.eta`, states that for any natural number `n` and any `a` which is an element of the "Fin" type (a type that represents a finite set of size `n`), if the value of `a` (`↑a`) is less than `n` (denoted by `h`), then creating a new "Fin" object with the same value and the condition `h` will yield the same "Fin" object `a`. In other words, for elements in the finite set, you can't have two distinct elements with the same value.

For any natural number `n` and element `a` of the finite type `Fin n`, if `a` has value less than `n`, then `Fin.mk (a : nat) (h : a < n)` equals `a`.


theorem decide_eq_decide : ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, decide p = decide q ↔ (p ↔ q) := by
  sorry

The theorem `decide_eq_decide` states that for any two propositions `p` and `q`, and any two instances `x` and `x_1` of `Decidable` for `p` and `q` respectively, `decide p` is equal to `decide q` if and only if `p` is logically equivalent to `q`. This emphasizes the link between the decision procedure's results and the logical equivalence of the propositions it operates on.

For any propositions `p` and `q`, if `Decidable p` and `Decidable q` have equivalent instances `x` and `x_1` respectively, then `decide p = decide q` if and only if `p` is logically equivalent to `q`.


theorem Filter.tendsto_zpow_atTop_atTop :
    ∀ {α : Type u_3} [inst : LinearOrderedSemifield α] {n : ℤ},
      0 < n → Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atTop :=
  by sorry

This theorem states that for any type `α` which is a linear ordered semifield and for any integer `n` greater than 0, the function `f(x) = x^n` tends to infinity as `x` tends to infinity. In other words, as the input `x` becomes large without bound, the output `f(x)` also becomes large without bound. This is a formal way of expressing that the function `f(x) = x^n` exhibits a behavior of growing without bound as `x` grows without bound, for positive integer `n`.

For any linear ordered semifield type `α` and positive integer `n`, the function `x ↦ x^n` approaches infinity as `x` approaches infinity.


theorem Ideal.span_zero : ∀ {α : Type u} [inst : Semiring α], Ideal.span 0 = ⊥ := by sorry

The theorem `Ideal.span_zero` states that for any type `α` with a semiring structure, the ideal generated by the zero set in `α` is the bottom element, which is the smallest ideal, usually denoted by ⊥. That is, the smallest ideal you can generate by just adding and multiplying elements from the zero set is the smallest ideal in the semiring.

For any semiring type `α`, the ideal generated by the zero set is the bottom ideal.


/-- Two vectors of the same norm are on the same ray if and only if they are equal.  -/
theorem sameRay_iff_of_norm_eq :
    ∀ {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {x y : F},
      ‖x‖ = ‖y‖ → (SameRay ℝ x y ↔ x = y) :=
  by sorry

The theorem `sameRay_iff_of_norm_eq` states that for any normed vector space over the real numbers, if two vectors have the same norm, then they are in the same ray if and only if they are equal. Here, vectors being on the same ray is defined as either one of the vectors being zero or there existing positive multiples of the vectors such that they are equal. In simpler terms, this theorem says if two vectors have the same length, then they point in the same direction (or opposite directions) if and only if they are exactly the same vector.

In a real normed vector space, two vectors have the same norm if and only if they are equal or lie on the same ray.


theorem Ordinal.cof_blsub_le_lift :
    ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}),
      Ordinal.cof (Ordinal.blsub o f) ≤ Cardinal.lift.{v, u} (Ordinal.card o) :=
  by sorry

The theorem `Ordinal.cof_blsub_le_lift` states that for any ordinal `o` and a function `f` from an ordinal less than `o` to another ordinal, the cofinality of the least upper bound of the family of ordinals indexed by the set of ordinals less than `o` (`Ordinal.blsub o f`) is less than or equal to the lift of the cardinality of `o`. Here, the cofinality of an ordinal is the smallest cardinality of a subset that is unbounded in the ordinal, the lift operation on cardinals changes the universe level of the cardinal, and the cardinality of an ordinal is the cardinality of any type on which a relation with that order type is defined.

The cofinality of the least upper bound of a family of ordinals less than `o` indexed by the function `f` is less than or equal to the lift of the cardinality of `o`.


theorem Finset.sdiff_eq_filter :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = Finset.filter (fun x => x ∉ s₂) s₁ := by sorry

The theorem `Finset.sdiff_eq_filter` states that for any types `α` that have decidable equality and any two finite sets `s₁` and `s₂` of `α`, the set difference `s₁ \ s₂` is equal to filtering `s₁` with the predicate that checks if an element does not belong to `s₂`. In other words, the operation of removing all elements of `s₂` from `s₁` (i.e., creating the set difference `s₁ \ s₂`) is equivalent to creating a new set from `s₁` that only contains elements which are not in `s₂`.

For any type `α` with decidable equality and finite sets `s₁` and `s₂` of `α`, `s₁ \ s₂` equals the filter of `s₁` through the predicate `λ x, x ∉ s₂`.


theorem Ordinal.sup_eq_bsup' :
    ∀ {o : Ordinal.{u}} {ι : Type u} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (ho : Ordinal.type r = o)
      (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}),
      Ordinal.sup (Ordinal.familyOfBFamily' r ho f) = Ordinal.bsup o f :=
  by sorry

The theorem `Ordinal.sup_eq_bsup'` states that for any ordinal `o` and any well-ordered type `ι`, given a relation `r` that provides a well-ordering for `ι`, and a function `f` that maps each ordinal less than `o` to another ordinal, the supremum of the family of ordinals as defined by applying `f` to the elements of `ι` (by converting `ι` to an ordinal using `r` and `ho = Ordinal.type r = o`) is equal to the supremum of ordinals obtained by applying `f` directly on ordinals less than `o`. In other words, this theorem shows the equality between two different ways of constructing a family of ordinals and then taking their supremum.

For any ordinal `o` and well-ordered type `ι` with relation `r`, if `f` maps ordinals less than `o` to ordinals, then `Ordinal.sup_eq_bsup' o r f` equals the supremum of `f` applied to ordinals less than `o`.


theorem Finset.union_left_comm :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t u : Finset α), s ∪ (t ∪ u) = t ∪ (s ∪ u) := by sorry

The theorem `Finset.union_left_comm` states that for any given type `α` with decidable equality and for any three finite sets `s`, `t`, and `u` of type `α`, the union operation is left-commutative. That is, the operation of taking the union of `s` with the union of `t` and `u` (`s ∪ (t ∪ u)`) is the same as taking the union of `t` with the union of `s` and `u` (`t ∪ (s ∪ u)`). In mathematical terms, we could write this as \(s \cup (t \cup u) = t \cup (s \cup u)\).

For any type `α` with decidable equality, the operation of taking the union of a finite set `s` with the union of two other finite sets `t` and `u` is equal to the union of `t` with the union of `s` and `u`. In mathematical notation, `s ∪ (t ∪ u) = t ∪ (s ∪ u)`.


theorem closure_nonempty_iff :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], Set.Nonempty (closure s) ↔ Set.Nonempty s := by sorry

This theorem, `closure_nonempty_iff`, establishes a relationship between a set and its closure in the context of a topological space. Specifically, it states that for any set `s` in a topological space `X`, the closure of `s` is nonempty if and only if `s` itself is nonempty. In mathematical terms, this means there exists an element in `s` if and only if there exists an element in the closure of `s`.

The closure of a non-empty set in a topological space is non-empty. Equivalently, a set is non-empty if and only if its closure is non-empty.


theorem Int.ModEq.add_left_cancel : ∀ {n a b c d : ℤ}, a ≡ b [ZMOD n] → a + c ≡ b + d [ZMOD n] → c ≡ d [ZMOD n] := by
  sorry

This theorem, `Int.ModEq.add_left_cancel`, states that for any integers `n`, `a`, `b`, `c`, and `d`, if `a` is congruent to `b` modulo `n` and `a + c` is congruent to `b + d` modulo `n`, then `c` is congruent to `d` modulo `n`. In other words, it establishes that in the context of integer modular arithmetic, adding the same value to both sides of a congruence equation allows for cancellation on the left side.

If `a` is congruent to `b` modulo `n` and `a + c` is congruent to `b + d` modulo `n`, then `c` is congruent to `d` modulo `n`. (In other words, if `a ≡ b (mod n)` and `a + c ≡ b + d (mod n)`, then `c ≡ d (mod n)` in the context of integer modular arithmetic.)


theorem add_one_pow_unbounded_of_pos :
    ∀ {α : Type u_1} [inst : StrictOrderedSemiring α] [inst_1 : Archimedean α] {y : α} (x : α),
      0 < y → ∃ n, x < (y + 1) ^ n :=
  by sorry

This theorem states that for any strictly ordered semiring (a mathematical system that is an algebraic structure which generalizes the arithmetic of natural numbers, integers, and real numbers) with the Archimedean property (which states that given any number, there is a natural number that is higher than it), and given any positive number `y`, there exists a natural number `n` such that any number `x` is less than `(y + 1)^n`. This essentially implies that `(y + 1)^n` grows without bound for any positive `y`.

For any strictly ordered semiring with the Archimedean property, given a positive element `y`, there exists a natural number `n` such that `(y + 1) ^ n > x` for all positive elements `x`.


theorem List.foldr_eq_foldrM :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β → β) (b : β) (l : List α), List.foldr f b l = List.foldrM f b l := by
  sorry

This theorem states that for any types `α` and `β`, for any function `f` of type `α → β → β`, for any `β`-type variable `b`, and for any list `l` of `α`-type elements, the right-to-left fold operation (`List.foldr`) and the monadic right-to-left fold operation (`List.foldrM`) are equivalent. In other words, applying function `f` to each element of the list `l` with the initial value `b` using `List.foldr` yields the same result as using `List.foldrM`.

For any types `α` and `β`, any function `f : α -> β -> β`, any `β`-valued `b`, and any list `l` of `α`-elements, `List.foldr f b l` is equal to `List.foldrM (λ x acc => some (f x acc)) [] l`.


theorem Matrix.diag_smul :
    ∀ {n : Type u_3} {R : Type u_7} {α : Type v} [inst : SMul R α] (r : R) (A : Matrix n n α),
      Matrix.diag (r • A) = r • Matrix.diag A :=
  by sorry

The theorem `Matrix.diag_smul` states that for any type `n`, any type `R`, any type `α`, and any instance of scalar multiplication (`SMul`) of `R` and `α`, given a scalar `r` of type `R` and a square matrix `A` of type `Matrix n n α`, the diagonal of the scalar multiplication of `r` and `A`, i.e., `r • A`, is equal to the scalar multiplication of `r` and the diagonal of `A`. In mathematical terms, this theorem asserts that if you scale a matrix by a scalar `r`, the diagonal of the resulting matrix is the same as if you just scaled the original diagonal by `r`. In other words, scalar multiplication commutes with taking the diagonal of a square matrix.

For any square matrix A and scalar r, the diagonal of the matrix r * A is equal to the scalar multiplication of r and the diagonal of A.


ContDiffWithinAt.pow

theorem ContDiffWithinAt.pow :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E} {n : ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
      [inst_4 : NormedAlgebra 𝕜 𝔸] {f : E → 𝔸},
      ContDiffWithinAt 𝕜 n f s x → ∀ (m : ℕ), ContDiffWithinAt 𝕜 n (fun y => f y ^ m) s x :=
  by sorry

The theorem `ContDiffWithinAt.pow` states the following: For any nontrivially normed field `𝕜`, any normed add commutative group `E` that is a normed space over `𝕜`, any set `s` of elements of `E`, any element `x` of `E`, any `ℕ∞` number `n`, any normed ring `𝔸` that is a normed algebra over `𝕜`, and any function `f` from `E` to `𝔸`, if the function `f` is continuously differentiable within the set `s` at the point `x` to the `n`-th degree, then for any natural number `m`, the function `(fun y => f y ^ m)` which raises `f y` to the `m`-th power, is also continuously differentiable within the set `s` at the point `x` to the `n`-th degree.

If a function is continuously differentiable within a set to a certain degree at a point in a normed space over a nontrivially normed field, then the function composed with raising to a constant power is also continuously differentiable within the set to the same degree at the point.


theorem Ordinal.mex_not_mem_range : ∀ {ι : Type u} (f : ι → Ordinal.{max u v}), Ordinal.mex f ∉ Set.range f := by sorry

This theorem states that for any type `ι` and any function `f` mapping `ι` to an ordinal, the minimum excluded ordinal of the function `f` is not in the range of `f`. In other words, there is no element in `ι` such that when it is mapped by `f`, it gives the minimum ordinal that `f` fails to attain. This is akin to saying that the smallest ordinal number that is not produced by the function `f` cannot be produced by `f`, a statement about the "gaps" in the ordinal numbers produced by the function `f`.

For any type `ι` and function `f` from `ι` to an ordinal, the minimum excluded ordinal of `f` is not in the image of `f`.


theorem Int.neg_inj : ∀ {a b : ℤ}, -a = -b ↔ a = b := by sorry

This theorem, `Int.neg_inj`, states that for all integers `a` and `b`, the negation of `a` is equal to the negation of `b` if and only if `a` is equal to `b`. In other words, this theorem asserts the injectivity of the negation operation on integers: distinct integers have distinct negations.

For all integers `a` and `b`, if `~a = ~b` then `a = b`. (Negation of integers is injective.)


theorem Multiset.replicate_one : ∀ {α : Type u_1} (a : α), Multiset.replicate 1 a = {a} := by sorry

The theorem `Multiset.replicate_one` states that for any type `α` and for any element `a` of that type, the multiset that results from replicating `a` exactly once (i.e., `Multiset.replicate 1 a`) is simply a multiset containing the element `a` itself. This means that the multiset of replicating any element once is a multiset containing only that particular element.

For any type `α` and element `a` of that type, `Multiset.replicate 1 a` equals the multiset `{a}` containing exactly one copy of `a`.


theorem Function.iterate_minimalPeriod : ∀ {α : Type u_1} {f : α → α} {x : α}, f^[Function.minimalPeriod f x] x = x :=
  by sorry

This theorem states that for any given type `α`, a function `f` from `α` to `α`, and an element `x` of `α`, by iteratively applying the function `f` to `x` for a number of times equal to the minimal period of `x` under `f`, we reach `x` again. That is, `x` is a periodic point under `f` with period equal to its minimal period.

For any function `f` and element `x` in a type `α`, if `x` has minimal period `n` under `f`, then applying `f` to `x` `n` times returns `x`.


theorem Function.support_comp_subset :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} [inst : Zero M] [inst_1 : Zero N] {g : M → N},
      g 0 = 0 → ∀ (f : α → M), Function.support (g ∘ f) ⊆ Function.support f :=
  by sorry

This theorem states that for all types `α`, `M`, and `N`, where `M` and `N` are equipped with a zero element, given a function `g` from `M` to `N` that maps zero to zero, and any function `f` from `α` to `M`, the support of the composition `g ∘ f` is a subset of the support of `f`. In other words, for any element in the domain, if the composed function `g ∘ f` is non-zero at that point, then the function `f` must also be non-zero at that point.

Given functions `g: M -> N` with `g 0 = 0` and `f: α -> M`, the support of `g ∘ f` is contained in the support of `f`.


theorem Module.End_algebraMap_isUnit_inv_apply_eq_iff :
    ∀ {R : Type u} (S : Type v) {M : Type w} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : Module S M] [inst_5 : SMulCommClass S R M] [inst_6 : SMul R S]
      [inst_7 : IsScalarTower R S M] {x : R} (h : IsUnit ((algebraMap R (Module.End S M)) x)) (m m' : M),
      ↑(IsUnit.unit h)⁻¹ m = m' ↔ m = x • m' :=
  by sorry

This theorem states that for any commutative semiring `R`, type `S`, module `M` over `R`, where `S` and `M` are also modules and there exists a commutative action and a scalar multiplication with `R` and `S` on `M`, and `R` is a scalar tower over `S` and `M`, if `x` is an element of `R` which becomes a unit when mapped to the endomorphisms of the module via the algebraic structure, then for any two elements `m` and `m'` of the module, the inverse of the unit corresponding to `x` applied to `m` equals `m'` if and only if `m` equals `x` scaled by `m'`.

For any commutative semiring `R`, module `M` over `R` with commutative action and scalar multiplication, if `x` in `R` is a unit when mapped to endomorphisms and `m` and `m'` are elements of `M` such that `x * m = m'`, then the inverse of `x` maps `m` to `m'`.


theorem Orientation.inner_rightAngleRotation_right :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ E = 2)] (o : Orientation ℝ E (Fin 2)) (x y : E),
      ⟪x, (Orientation.rightAngleRotation o) y⟫_ℝ = -((Orientation.areaForm o) x) y :=
  by sorry

This theorem states that for any given oriented real inner product space `E` of dimension 2 (which is a vector space over the field of real numbers equipped with an inner product and an orientation), any orientation `o` of `E`, and any two vectors `x` and `y` in `E`, the inner product of `x` and the result of applying the `rightAngleRotation` operation (which is an isometric automorphism that represents a rotation by 90 degrees) with respect to `o` on `y` is equal to the negative of the result of applying the `areaForm` operation (which gives the oriented area of the parallelogram spanned by two vectors) with respect to `o` on `x` and `y`. In simpler terms, it relates the inner product after a 90-degree rotation with the oriented area of parallelogram spanned by two vectors in a 2-dimensional oriented real inner product space.

In a 2-dimensional oriented real inner product space, the inner product of a vector with the rotation of another vector by 90 degrees with respect to a given orientation is equal and opposite to the oriented area of the parallelogram spanned by those vectors.


theorem MeasureTheory.integral_trim :
    ∀ {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {β : Type u_7} {m m0 : MeasurableSpace β}
      {μ : MeasureTheory.Measure β} (hm : m ≤ m0) {f : β → G},
      MeasureTheory.StronglyMeasurable f → ∫ (x : β), f x ∂μ = ∫ (x : β), f x ∂μ.trim hm :=
  by sorry

This theorem, `MeasureTheory.integral_trim`, states that for any type `G` that is a normed additive commutative group and a normed space over the real numbers, any types `β`, any measurable spaces `m` and `m0` for the type `β`, and any measure `μ` on this measurable space, whenever `m` is a sub-measurable space of `m0`, the integral of a strongly measurable function `f` (a function that is the limit of simple functions) with respect to `μ` is equal to the integral of `f` with respect to the measure `μ` trimmed over `m` (i.e., restricted to the smaller measurable space `m`). Effectively, the theorem is saying that for these specific function and space types, integrating over a whole space or a subspace doesn't change the value of the integral if the function is strongly measurable.

For any normed additive commutative group `G` and normed space over the real numbers, any measurable spaces `m` and `m0`, any measure `μ` on `m0`, and any strongly measurable function `f` on `m`, the integral of `f` with respect to `μ` equals the integral of `f` with respect to the trimmed measure `μ` on the sub-measurable space `m`.


theorem Vector.get_eq_get :
    ∀ {n : ℕ} {α : Type u_1} (v : Vector α n) (i : Fin n), Vector.get v i = List.get (Vector.toList v) (Fin.cast ⋯ i) :=
  by sorry

This theorem states that for any natural number `n` and any type `α`, given a vector `v` of length `n` with elements of type `α` and an index `i` of type `Fin n`, the `i`-th element of the vector `v` obtained by `Vector.get` equals the `i`-th element of the list converted from the vector `v` using `Vector.toList`, where the index `i` is cast into an equal `Fin` type using `Fin.cast`. Essentially, this theorem confirms that the process of converting a vector to a list preserves the ordering of elements.

For any natural number `n` and type `α`, given a vector `v` of length `n` with elements of type `α`, the `i`-th element of `Vector.get v i` equals the `i`-th element of the list obtained by `Vector.toList v`, where `i` is treated as a `Fin n`.


theorem MeasureTheory.SimpleFunc.lintegral_eq_of_subset :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : MeasureTheory.SimpleFunc α ENNReal)
      {s : Finset ENNReal},
      (∀ (x : α), ↑f x ≠ 0 → ↑↑μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s) →
        MeasureTheory.SimpleFunc.lintegral f μ = Finset.sum s fun x => x * ↑↑μ (↑f ⁻¹' {x}) :=
  by sorry

This theorem states that, for any measurable space `α`, measure `μ` on `α`, and simple function `f` from `α` to the extended nonnegative reals, if every non-zero value of `f` that is assigned a non-zero measure by `μ` is included in a finite set `s`, then the integral of `f` with respect to `μ` is equal to the sum, over all elements `x` in `s`, of `x` times the measure of the preimage of `x` under `f`. This effectively means that the integral of a simple function can be computed by summing up the products of each unique function value and its corresponding measure over a suitable finite set.

If a simple function `f` from a measurable space `(α, μ)` to the extended nonnegative reals assigns a finite, non-zero measure to every non-zero value that lies in a finite set `s`, then the integral of `f` with respect to `μ` equals the sum of `x` times the measure of `f^{-1}({x})` for all `x` in `s`.


theorem Mathlib.Data.Int.CharZero._auxLemma.1 :
    ∀ {α : Type u_1} [inst : AddGroupWithOne α] [inst_1 : CharZero α] {n : ℤ}, (↑n = 0) = (n = 0) := by sorry

This theorem states that for any type `α` which is an instance of `AddGroupWithOne` and `CharZero`, and for any integer `n`, the coercion of `n` to `α` equals zero if and only if `n` itself equals zero. In simpler terms, this theorem says that an integer `n` is equal to zero only if its representation in the type `α` is also zero. This is under the condition that the type `α` allows for addition, has a multiplicative identity, and has a characteristic of zero (which means that there is no positive integer `n` for which `n` times the multiplicative identity equals zero).

For any type `α` that is an instance of `AddGroupWithOne` and `CharZero`, the coercion of an integer `n` to `α` equals the multiplicative identity if and only if `n` equals zero.


theorem Finsupp.prod_mapRange_index :
    ∀ {α : Type u_1} {M : Type u_8} {M' : Type u_9} {N : Type u_10} [inst : Zero M] [inst_1 : Zero M']
      [inst_2 : CommMonoid N] {f : M → M'} {hf : f 0 = 0} {g : α →₀ M} {h : α → M' → N},
      (∀ (a : α), h a 0 = 1) → Finsupp.prod (Finsupp.mapRange f hf g) h = Finsupp.prod g fun a b => h a (f b) :=
  by sorry

This theorem, `Finsupp.prod_mapRange_index`, states that for any types `α`, `M`, `M'`, `N`, a function `f` from `M` to `M'` such that `f` of `0` equals `0`, a finitely supported function `g` from `α` to `M`, a function `h` from `α` to `N`, if `h` of any `α` and `0` equals `1`, then the product over the support of `g` mapped through `f` with function `h` is equal to the product over the support of `g` with `h` composed with `f`.

In mathematical terms, for all `a` in the support of `g`, we have the equality $\prod_{a \in \text{supp}(g)} h(a, f(g(a))) = \prod_{a \in \text{supp}(g)}h(a, g(a))$ when we consider `f` applied to the output of `g`. Here, `Finsupp.prod` represents the product of `h a (f a)` over the support of `g` and `Finsupp.mapRange` maps the range of `g` through `f`.

For any finitely supported functions `g: α → M` and `h: α → N`, if `h 0 = 1` and `f: M → M'` maps `0` to `0`, then the product of `h` composed with `g` over `g`'s support is equal to the product of `h` over the support of `g` and `f` applied to the product of `h` and `g`.


theorem monotone_iff_map_nonneg :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommMonoid β]
      [i : FunLike F α β] [iamhc : AddMonoidHomClass F α β] (f : F), Monotone ⇑f ↔ ∀ (a : α), 0 ≤ a → 0 ≤ f a :=
  by sorry

The theorem `monotone_iff_map_nonneg` establishes an equivalence between two properties of a function `f` of type `F`, which has an injective coercion to a function from type `α` to `β`. The theorem states that, given an ordered additive commutative group `α` and an ordered additive commutative monoid `β`, the function `f` is monotone (i.e., for all `a` and `b` in `α`, if `a` is less than or equal to `b` then `f(a)` is less than or equal to `f(b)`) if and only if for all `a` in `α`, if `a` is nonnegative (greater than or equal to zero) then `f(a)` is also nonnegative. The theorem thereby provides a characterization of monotonicity in terms of nonnegativity preservation.

A function `f` from an ordered additive commutative group to an ordered additive commutative monoid is monotone if and only if for all non-negative elements `a` in the domain of `f`, `f(a)` is also non-negative.


/-- The (pre)image under `inv` of `Ioo 0 a` is `Ioi a⁻¹`.  -/
theorem Set.inv_Ioo_0_left :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {a : α}, 0 < a → (Set.Ioo 0 a)⁻¹ = Set.Ioi a⁻¹ := by sorry

The theorem `Set.inv_Ioo_0_left` states that for any linearly ordered field `α` and any positive element `a` from `α`, the preimage of the interval `(0, a)` under the inverse function is the interval `(a⁻¹, ∞)`. In other words, if you take the open interval from 0 to `a` and apply the inverse function to each element in the interval, you get the open interval from `a⁻¹` to positive infinity. This theorem relates the transformation of intervals under the inverse operation in a field.

For any linearly ordered field `α` and positive element `a` from `α`, the inverse function maps the interval `(0, a)` to the interval `(a⁻¹, ∞)`.


theorem Polynomial.coeff_contract :
    ∀ {R : Type u} [inst : CommSemiring R] {p : ℕ},
      p ≠ 0 → ∀ (f : Polynomial R) (n : ℕ), Polynomial.coeff (Polynomial.contract p f) n = Polynomial.coeff f (n * p) :=
  by sorry

This theorem, `Polynomial.coeff_contract`, states that for any commutative semiring `R`, positive integer `p`, polynomial `f` over `R`, and natural number `n`, the coefficient of the term `X^n` in the contracted polynomial of `f` by `p` is equal to the coefficient of the term `X^(np)` in `f`. Here, the contraction operation on a polynomial transforms each term's exponent by dividing it by `p`, effectively "compressing" the polynomial.

For any commutative semiring R, positive integer p, polynomial f over R in one variable X, and natural number n, the coefficient of X^(np) in polynomial f is equal to the coefficient of X^n in the polynomial obtained by contracting f by p.


theorem Ordinal.mod_lt : ∀ (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}, b ≠ 0 → a % b < b := by sorry

The theorem `Ordinal.mod_lt` states that for any two ordinals `a` and `b` in the same type `u_4`, given that `b` is not zero, the modulus of `a` by `b` (denoted as `a % b`) is strictly less than `b`. In other words, it's the formalization of the familiar property from number theory that the remainder when one number is divided by another is always less than the divisor, but applied to ordinals.

For ordinals `a` and `b` in the same type with `b` non-zero, `a % b` strictly precedes `b`.


theorem geom_sum_pos' :
    ∀ {α : Type u} {n : ℕ} {x : α} [inst : LinearOrderedRing α],
      0 < x + 1 → n ≠ 0 → 0 < Finset.sum (Finset.range n) fun i => x ^ i :=
  by sorry

This theorem states that for any number `n` of type natural number and any number `x` of a type `α` that forms a linearly ordered ring, if `x + 1` is greater than 0 and `n` is not equal to 0, then the sum of `x` raised to the power of each natural number less than `n` is greater than 0. In other words, if we have a non-zero natural number `n` and a number `x` such that `x + 1` is positive, then the geometric sum `x^0 + x^1 + x^2 + ... + x^(n-1)` is also positive.

For any non-zero natural number `n` and any element `x` in a linearly ordered ring with `x + 1 > 0`, the sum `∑ i in (0 : nat) (x ^ i)` is positive.


theorem Complex.arg_of_re_neg_of_im_nonneg :
    ∀ {x : ℂ}, x.re < 0 → 0 ≤ x.im → Complex.arg x = Real.arcsin ((-x).im / Complex.abs x) + Real.pi := by sorry

This theorem states that for any complex number `x`, if the real part of `x` is negative and its imaginary part is non-negative, then the argument of `x` equals to the arcsine of the negative of the imaginary part of `x` divided by the absolute value of `x`, plus π. The argument of a complex number, often denoted as `arg(x)`, represents the angle that a line from the origin to the point representing the complex number makes with the positive real axis. The arcsin function, symbolized as `arcsin`, returns the inverse of the sine of a number. The absolute value of a complex number, `abs(x)`, is its distance from the origin in the complex plane.

If the real part of a complex number `x` is negative and its imaginary part is non-negative, then the argument of `x` is equal to `π + arcsin(neg (Im x) / abs x)`.


/-- In a monoid with zero, zero equals one if and only if all elements of that semiring
are equal.  -/
theorem subsingleton_iff_zero_eq_one : ∀ {M₀ : Type u_2} [inst : MulZeroOneClass M₀], 0 = 1 ↔ Subsingleton M₀ := by
  sorry

This theorem states that in a monoid with zero (a mathematical structure where multiplication, zero, and one are defined), zero is equal to one if and only if all elements in the semiring (a generalization of rings in algebra) are the same. In other words, in such a monoid, if zero and one are indistinguishable, then every other element in that semiring is also indistinguishable.

In a monoid with zero, zero is equal to one if and only if all elements are equal.


/-- Every set open in the upper topology is a upper set.  -/
theorem Topology.IsUpper.isUpperSet_of_isOpen :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsUpper α] {s : Set α},
      IsOpen s → IsUpperSet s :=
  by sorry

The theorem `Topology.IsUpper.isUpperSet_of_isOpen` states that every open set in the upper topology is also an upper set. More specifically, given an ordered set `α` with a preorder structure, a topological space structure, and an upper topology structure, for every subset `s` of `α`, if `s` is open in the given topological space, then `s` is also an upper set. An upper set is a set where every element that is greater than any of its members is also a member of the set. This theorem is essentially a property that relates the concepts of upper sets and open sets in the context of upper topologies.

Every open set in an upper topology is an upper set.


theorem subset_comp_self : ∀ {α : Type ua} {s : Set (α × α)}, idRel ⊆ s → s ⊆ compRel s s := by sorry

This theorem states that for any type `α` and for any relation `s` which is a set of pairs of `α`, if the identity relation is a subset of `s`, then `s` is a subset of the composition of `s` with itself. In other words, if every pair of identical elements from `α` is in `s`, then for any pair in `s`, there exists an element such that the pair can be split into two pairs which are also in `s`.

If a relation `s` on type `α` contains the identity relation, then `s` is reflexive and transitive, i.e., `s` is a quadratic closure of itself.


theorem RatFunc.mk_one' :
    ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] (p : Polynomial K),
      RatFunc.mk p 1 = { toFractionRing := (algebraMap (Polynomial K) (FractionRing (Polynomial K))) p } :=
  by sorry

This theorem states that for any commutative ring `K` that is also an integral domain, and any polynomial `p` with coefficients in `K`, creating a rational function from `p` and `1` yields the same result as mapping `p` through an algebra embedding into the fraction ring of `K` polynomials. In simpler terms, it asserts that the rational function `p / 1` is equivalent to the algebraic construction of the polynomial `p` itself in the fraction ring of polynomials over `K`.

For any commutative integral domain `K` and polynomial `p` over `K`, the rational function `p / 1` is equivalent to the polynomial `p` in the fraction ring of `K` polynomials.