theorem Asymptotics.IsEquivalent.tendsto_atTop :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedLinearOrderedField β] {u v : α → β} {l : Filter α}
      [inst_1 : OrderTopology β],
      Asymptotics.IsEquivalent l u v → Filter.Tendsto u l Filter.atTop → Filter.Tendsto v l Filter.atTop :=
  by sorry

The theorem `Asymptotics.IsEquivalent.tendsto_atTop` states that for any types `α` and `β`, where `β` is a normed linear ordered field with an order topology, and given any two functions `u` and `v` from `α` to `β`, and a filter `l` on `α`. If `u` and `v` are asymptotically equivalent along the filter `l`, and if `u` tends to positive infinity along `l`, then `v` also tends to positive infinity along `l`. In other words, if two functions are asymptotically equivalent and one of them tends towards infinity, then the other one also tends towards infinity.

If two functions from a type to a normed linear ordered field with an order topology are asymptotically equivalent along a filter and one tends to positive infinity along the filter, then the other function also tends to positive infinity along the filter.


theorem CategoryTheory.Functor.map_add :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.Additive F] {X Y : C} {f g : X ⟶ Y}, F.map (f + g) = F.map f + F.map g :=
  by sorry

This theorem states that for any two morphisms `f` and `g` from object `X` to object `Y` in a preadditive category `C`, and a functor `F` from `C` to another preadditive category `D` that preserves binary addition of morphisms, the functor `F` applied to the sum of `f` and `g` (`F.map (f + g)`) is equal to the sum of `F` applied to `f` and `F` applied to `g` (`F.map f + F.map g`). In other words, it demonstrates the distributive property of an additive functor over morphism addition in preadditive categories.

For any additive functor F between preadditive categories and any morphisms f, g in a preadditive category, F(f + g) = F(f) + F(g).


theorem MeasureTheory.StronglyMeasurable.indicator :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β],
      MeasureTheory.StronglyMeasurable f →
        ∀ {s : Set α}, MeasurableSet s → MeasureTheory.StronglyMeasurable (Set.indicator s f) :=
  by sorry

This theorem states that for any type `α` and `β`, and any function `f` from `α` to `β`, given a measurable space structure on `α`, a topological space structure and a zero element on `β`, if the function `f` is strongly measurable (i.e., it is the limit of simple functions), then for any set `s` of type `α` that is a measurable set, the indicator function of `s` with respect to `f` is also strongly measurable. The indicator function `Set.indicator s f` is defined as `f a` when `a` is in `s` and `0` otherwise.

If `f` is a strongly measurable function from a measurable space `(α, Σ)` to a topological space `(β, τ)` with a zero element, then for any measurable set `s ∈ Σ`, the indicator function `Set.indicator s f` is also strongly measurable.


theorem List.sublist_cons_of_sublist :
    ∀ {α : Type u} (a : α) {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.Sublist l₁ (a :: l₂) := by sorry

This theorem states that for any type `α`, given an element `a` of type `α` and two lists `l₁` and `l₂` of type `List α`, if `l₁` is a sublist of `l₂`, then `l₁` is also a sublist of the list formed by prepending `a` to `l₂`. Essentially, adding an element to the start of a list doesn't affect its sublists.

If `l₁` is a sublist of `l₂`, then `a :: l₁` is a sublist of `a :: l₂`, where `::` denotes list cons.


theorem Polynomial.eval₂_X_pow :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S) {n : ℕ},
      Polynomial.eval₂ f x (Polynomial.X ^ n) = x ^ n :=
  by sorry

This theorem states that for any semirings `R` and `S`, given a ring homomorphism `f` from `R` to `S` and any element `x` of `S`, the evaluation of the `n`-th power of the polynomial variable (indeterminate), `Polynomial.X`, under the evaluation map `Polynomial.eval₂ f x` equals `x` to the power of `n`. In other words, when the polynomial `Polynomial.X ^ n` is evaluated at `x` using the ring homomorphism `f`, the result is the same as simply raising `x` to the power of `n`.

For any semirings R and S, ring homomorphism f from R to S, and element x in S, the evaluation of the n-th power of the polynomial variable X under the map Polynomial.eval₂ f x equals x raised to the power of n.


theorem Ordinal.div_add_mod : ∀ (a b : Ordinal.{u_4}), b * (a / b) + a % b = a := by sorry

The theorem `Ordinal.div_add_mod` states that for any two ordinals `a` and `b`, the product of `b` and the quotient of `a` divided by `b`, when added to the remainder of `a` divided by `b`, equals `a`. This is an analogue to the division theorem in the context of ordinals, which are types of well orders, and reflects the property that any natural number can be represented uniquely as the product of two numbers plus a remainder.

For any ordinals `a` and `b`, `(a : adversal) ÷ b * (a % b) = a`, where `÷` and `%` denote ordinal division and remainder, respectively.


/-- If `a ≤ b + c` and `a = ∞` whenever `b = ∞` or `c = ∞`, then
`ENNReal.toReal a ≤ ENNReal.toReal b + ENNReal.toReal c`. This lemma is useful to transfer
triangle-like inequalities from `ENNReal`s to `Real`s.  -/
theorem ENNReal.toReal_le_add' :
    ∀ {a b c : ENNReal}, a ≤ b + c → (b = ⊤ → a = ⊤) → (c = ⊤ → a = ⊤) → a.toReal ≤ b.toReal + c.toReal := by sorry

This theorem states that for any three extended nonnegative real numbers `a`, `b`, and `c`, if `a` is less than or equal to the sum of `b` and `c`, and if `a` equals infinity whenever `b` or `c` equals infinity, then the real value of `a` is less than or equal to the sum of the real values of `b` and `c`. This is useful for transferring inequalities that resemble the triangle inequality from extended nonnegative real numbers to real numbers.

If $a$ is an extended non-negative real number less than or equal to the sum of extended non-negative real numbers $b$ and $c$, and $a = \infty$ if and only if $b$ or $c$ is $\infty$, then $a \leqslant \mathrm{Re}(b) + \mathrm{Re}(c)$, where $\mathrm{Re}(x)$ denotes the real part of a complex number $x$.


theorem Bool.or_true : ∀ (b : Bool), (b || true) = true := by sorry

This theorem states that for any boolean value 'b', the result of a logical 'or' operation between 'b' and 'true' will always be 'true'. This is because in Boolean logic, 'or' operation with 'true' always results in 'true', regardless of the other operand.

For all boolean values 'b', b orb true = true.


theorem Submodule.linearProjOfIsCompl_apply_left :
    ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E]
      {p q : Submodule R E} (h : IsCompl p q) (x : ↥p), (Submodule.linearProjOfIsCompl p q h) ↑x = x :=
  by sorry

The theorem `Submodule.linearProjOfIsCompl_apply_left` states that for any ring `R`, any additive commutative group `E` which is also a module over `R`, and two submodules `p` and `q` of `E` that are complementary (i.e., their sum is the whole module and their intersection is the trivial submodule), if we apply the linear projection associated with `p` and `q` to an element `x` in `p`, we get `x` back. This is essentially saying that the projection of an element onto the submodule it already resides in leaves the element unchanged.

For any ring `R`, module `E` over `R`, and complementary submodules `p` and `q` of `E`, the linear projection of any element `x` in `p` onto `p` along `q` equals `x`.


theorem CategoryTheory.mono_of_mono :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Mono (CategoryTheory.CategoryStruct.comp f g)], CategoryTheory.Mono f :=
  by sorry

This theorem states that in any category `C`, if the composition of two morphisms `f` and `g` (where `f` maps `X` to `Y` and `g` maps `Y` to `Z`) is a monomorphism, then `f` itself is a monomorphism. In other words, if the composition `f ≫ g` is injective (which is the category theory equivalent of being a monomorphism), then `f` is also injective. "Injective" here means that if two different inputs produce the same output, then the inputs were actually the same to begin with. It's a property of a function (or morphism) that implies a certain kind of "non-collapsing" behavior.

If `f ∘ g` is a monomorphism in a category `C`, then `f` is a monomorphism.


/-- A Cauchy sequence in a complete space converges  -/
theorem cauchySeq_tendsto_of_complete :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : Preorder β] [inst_1 : CompleteSpace α]
      {u : β → α}, CauchySeq u → ∃ x, Filter.Tendsto u Filter.atTop (nhds x) :=
  by sorry

This theorem states that for any Cauchy sequence `u` in a complete space `α` (with a uniform structure and a preorder on the indexing set `β`), there exists some element `x` in `α` such that `u` converges to `x` as `β` goes to infinity. In mathematical terms, if a sequence is Cauchy (i.e., the elements get arbitrarily close to each other as we go further in the sequence) and the space is complete (i.e., every Cauchy sequence converges), then the sequence must converge to some point in the space. The convergence is expressed using the `Filter.Tendsto` predicate, which says that for every neighborhood of `x`, there exists a point in the sequence beyond which all the elements are in that neighborhood.

Every Cauchy sequence in a complete space converges to a limit in that space.


theorem PartialHomeomorph.map_target :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : Y}, x ∈ e.target → ↑(PartialHomeomorph.symm e) x ∈ e.source :=
  by sorry

The theorem `PartialHomeomorph.map_target` states that for any types `X` and `Y` equipped with topological space structures, given a partial homeomorphism `e` from `X` to `Y`, for any element `x` of `Y` in the target set of `e`, the application of the inverse of `e` to `x` is an element of the source set of `e`. In simpler terms, it says that if `x` is in the target of a partial homeomorphism, its preimage under the inverse homeomorphism is in the source of the original homeomorphism.

Given a partial homeomorphism from a topological space `X` to a topological space `Y`, if `x` is in the image of `X` under `f` and `g` is the inverse of `f`, then `g(x)` is in the domain of `f`.


theorem CategoryTheory.ShortComplex.iCycles_g :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.iCycles S) S.g = 0 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.iCycles_g` states that for any category `C` with zero morphisms, and any short complex `S` in `C` that has left homology, the composition of the morphism representing the inclusion of `S.cycles` into `S.X₂` with the morphism `S.g` is a zero morphism. In other words, if you first include `S.cycles` into `S.X₂` and then apply `S.g`, you end up with the same result as if you had done nothing. This is typically a property you would expect in the context of homological algebra, where complexes and cycles play a crucial role.

For any short complex S in a category with zero morphisms having left homology, the composition of the inclusion of S.cycles into S.X₂ with S.g is the zero morphism.


theorem inv_mem_iff :
    ∀ {S : Type u_5} {G : Type u_6} [inst : InvolutiveInv G] {x : SetLike S G} [inst_1 : InvMemClass S G] {H : S}
      {x_1 : G}, x_1⁻¹ ∈ H ↔ x_1 ∈ H :=
  by sorry

This theorem, `inv_mem_iff`, states that for any set `H` of type `S`, which has the properties defined by an `InvMemClass` between `S` and `G`, and for any element `x_1` of type `G`, the inverse of `x_1` (denoted `x_1⁻¹`) is in `H` if and only if `x_1` itself is in `H`. Here `G` is a type with an involutive inverse operation, which means taking the inverse twice gives back the original element.

For any set `H` of type `S` defined by an `InvMemClass` between `S` and an involutive group `G`, and for all `x_1` in `G`, `x_1` is in `H` if and only if `x_1⁻¹` is in `H`.


theorem small_map : ∀ {α : Type u_1} {β : Type u_2} [hβ : Small.{w, u_2} β], α ≃ β → Small.{w, u_1} α := by sorry

This theorem, `small_map`, states that for any two types `α` and `β`, if `β` is a "small" type, then any equivalence (bijective mapping) from `α` to `β` implies that `α` is also a "small" type. The concept of "small" types in Lean's type theory is a way of avoiding certain paradoxes related to sizes of infinite sets; a small type is one that is not too large in a certain precise sense.

If `β` is a small type and there exists a bijection from `α` to `β`, then `α` is also a small type.


theorem Finset.sum_filter_of_ne :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f : α → β} [inst : AddCommMonoid β] {p : α → Prop}
      [inst_1 : DecidablePred p],
      (∀ x ∈ s, f x ≠ 0 → p x) → (Finset.sum (Finset.filter p s) fun x => f x) = Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_filter_of_ne` states that for any type `α`, any type `β` with an additive commutative monoid structure, any finite set `s` of `α`, any function `f` from `α` to `β`, and any decidable predicate `p` on `α`, if every element `x` of `s` for which `f(x)` is not zero satisfies the predicate `p`, then the sum over the filtered set, where the filter is given by `p`, is equal to the sum over the entire set `s`. In mathematical terms, if for all `x` in `s`, `f(x) ≠ 0` implies `p(x)` then the equation ∑_{x in {p(x) | x in s}} f(x) = ∑_{x in s} f(x) holds.

If `p` is a decidable predicate on a finite set `s` of `α` such that `f(x) neq 0` implies `p(x)` for all `x` in `s`, then the sum of `f(x)` over the filtered set `{x in s | p(x)}` equals the sum over the entire set `s`.


SemiNormedGroupCat.ext

theorem SemiNormedGroupCat.ext : ∀ {M N : SemiNormedGroupCat} {f₁ f₂ : M ⟶ N}, (∀ (x : ↑M), f₁ x = f₂ x) → f₁ = f₂ := by
  sorry

This theorem states that for any two objects `M` and `N` in the category of seminormed abelian groups, if we have two morphisms `f₁` and `f₂` from `M` to `N`, then `f₁` equals `f₂` if they are equal at every element of the underlying set of `M`. In other words, this theorem is saying that two bounded group homomorphisms between seminormed abelian groups are the same if they map every element of a seminormed abelian group to the same element in another seminormed abelian group.

Given two bounded group homomorphisms between seminormed abelian groups, they are equal if and only if they map every element to the same image.


theorem MeasureTheory.Measure.le_sum :
    ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} (μ : ι → MeasureTheory.Measure α) (i : ι),
      μ i ≤ MeasureTheory.Measure.sum μ :=
  by sorry

This theorem states that for any type `α` and an index type `ι`, given a measurable space `m0` over `α`, and a function `μ` mapping each index `ι` to a measure on `α`, the measure for any particular index `i` is less than or equal to the sum of the measures for all indices. In other words, if you have a collection of measures indexed by `ι`, the measure of any one element is no greater than the sum of all measures in the collection.

For any measurable space `(α, Σ, m0)` and a family `(μ\_i : Σ -> ℝ)_i indexed by an index type `ι`, we have `μ_i ∣ᵢ α ∩ A ≤ ∑_j μ_j ∣ᵢ α ∩ A` for all `A ∈ Σ` and `i, j : ι`. (Here, `∣ᵢ` denotes the restriction of the measure `m0` to the sub-σ-algebra generated by `{A : Σ | A ∩ supp μ_i ≠ ∅}`, where `supp μ_i` is the support of `μ_i`.)


theorem Polynomial.multiplicity_X_sub_C_finite :
    ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} (a : R),
      p ≠ 0 → multiplicity.Finite (Polynomial.X - Polynomial.C a) p :=
  by sorry

This theorem states that for any non-zero polynomial `p` over a ring `R` and any element `a` in `R`, the multiplicity of the polynomial `X - C(a)` in `p` is finite. In other words, there exists a natural number `n` such that `(X - C(a))^(n + 1)` does not divide `p`. Here, `X` represents the polynomial variable and `C(a)` is the constant polynomial `a`.

For any non-zero polynomial `p` over a ring `R` and any `a` in `R`, there exists a natural number `n` such that `(X - a)^(n + 1)` does not divide `p`.


/-- The range of a surjective `AddMonoid` homomorphism is the whole of the codomain. -/
theorem AddMonoidHom.range_top_of_surjective :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] (f : G →+ N),
      Function.Surjective ⇑f → AddMonoidHom.range f = ⊤ :=
  by sorry

The theorem `AddMonoidHom.range_top_of_surjective` states that for any `AddGroup` types G and N, if a function `f` is an `AddMonoid` homomorphism from G to N and is surjective (i.e., for every element in the codomain N, there exists an element in the domain G such that the function applied to that element yields the given element in N), then the range of this function is the entire codomain N. In other words, the surjective `AddMonoid` homomorphism fully covers the codomain.

If `f` is a surjective `AddMonoid` homomorphism from an `AddGroup` `G` to another `AddGroup` `N`, then the range of `f` is all of `N`.


theorem AbsoluteValue.map_mul :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S)
      (x y : R), abv (x * y) = abv x * abv y :=
  by sorry

This theorem states that for any two types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and for any absolute value function `abv` from `R` to `S`, the absolute value of the product of two elements `x` and `y` from `R` is equal to the product of their absolute values. In other words, if you multiply two numbers together and then take the absolute value, you get the same result as if you took the absolute values first and then multiplied. This property is represented symbolically as `abv (x * y) = abv x * abv y`.

For any semiring `R`, ordered semiring `S`, and absolute value function `abv` from `R` to `S`, `abv (x * y) = abv x * abv y` for all `x, y` in `R`.


theorem le_sdiff : ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x ≤ y \ z ↔ x ≤ y ∧ Disjoint x z :=
  by sorry

This theorem states that for any type `α` that is an instance of a `GeneralizedBooleanAlgebra`, and for any elements `x`, `y`, and `z` of this type, `x` is less than or equal to the difference of `y` and `z` if and only if `x` is less than or equal to `y` and `x` is disjoint with `z`. Here, `Disjoint x z` means that for any element that is less than or equal to both `x` and `z`, that element must also be less than or equal to the bottom element of the lattice. In essence, the theorem connects the partial order relation and the disjointness in the context of a generalized Boolean algebra.

In a generalized Boolean algebra, for all elements x, y, and z, x <= y ^-.\^ z if and only if x <= y and x is disjoint with z. (Here, "^-.\^" denotes the lattice operation for difference in a generalized Boolean algebra.)


/-- A partial homeomorphism inverse is continuous at any point of its target  -/
theorem PartialHomeomorph.continuousAt_symm :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : Y}, x ∈ e.target → ContinuousAt (↑(PartialHomeomorph.symm e)) x :=
  by sorry

The theorem `PartialHomeomorph.continuousAt_symm` states that for any two topological spaces `X` and `Y`, and for any partial homeomorphism `e` from `X` to `Y`, the inverse of `e` is continuous at any point `x` that belongs to the target of `e`. In other words, if we have a partial homeomorphism between two topological spaces, then the inverse function of this homeomorphism is always continuous at the points in its target set.

Given any partial homeomorphism `e: X ↫ Y` between topological spaces, the inverse `e⁻¹` is continuous at every point `x ∈ e(X)`.


theorem Real.Angle.toReal_pi : Real.Angle.toReal ↑Real.pi = Real.pi := by sorry

This theorem states that the real number representation of the `Real.Angle` corresponding to the mathematical constant π (pi), when converted back to a real number using the `Real.Angle.toReal` function, still remains as the original real number π. In other words, converting π from a real number to a `Real.Angle` and then back to a real number doesn't change the value, it still stays as π.

The real number representation of the `Real.Angle` constant π, obtained via `Real.Angle.toReal`, is equal to the original real number value of π.


theorem HahnSeries.single_coeff_same :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] (a : Γ) (r : R),
      ((HahnSeries.single a) r).coeff a = r :=
  by sorry

The theorem `HahnSeries.single_coeff_same` asserts that for any types `Γ` and `R` with a partial order on `Γ` and a zero element in `R`, and for any elements `a` of type `Γ` and `r` of type `R`, the coefficient of `a` in the Hahn series generated by the `single` function with inputs `a` and `r` is `r`. In other words, the function `HahnSeries.single a r` creates a Hahn series where the coefficient of `a` is `r`, and this theorem confirms that.

For any type `Γ` with a partial order and a zero element, and for any `a ∈ Γ` and `r ∈ R`, the coefficient of `a` in the Hahn series generated by `HahnSeries.single a r` is equal to `r`.


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

The theorem `disjoint_bot_right` states that for any type `α` that has a partial order and a least element (denoted as `⊥`), any element `a` of this type is disjoint with the least element `⊥`. In the context of lattices, two elements are considered disjoint if their greatest lower bound (infimum) is the bottom element. Hence, in this case, if `a` and `⊥` are elements of type `α`, then they are disjoint because their greatest lower bound cannot be anything other than `⊥`.

For any type `α` with a partial order and least element `⊥`, `a` and `⊥` are disjoint in the sense that their greatest lower bound is `⊥` for all `a` in `α`.


theorem compl_anti : ∀ {α : Type u_2} [inst : HeytingAlgebra α], Antitone compl := by sorry

The theorem `compl_anti` states that for any type `α` that is a Heyting algebra, the complement function (`compl`) is antitone. This means that if `a` and `b` are elements of `α` and `a ≤ b`, then `compl b ≤ compl a`. In other words, the complement function reverses the order of elements in a Heyting algebra.

For any Heyting algebra `α`, the complement function `compl` is order-reversing, i.e., `compl a ≤ compl b` whenever `a ≤ b`.


theorem Multiset.countP_eq_card_filter :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
      Multiset.countP p s = Multiset.card (Multiset.filter p s) :=
  by sorry

This theorem states that for any type `α`, any predicate `p` on `α` that's decidable, and any multiset `s` of elements of type `α`, the count of elements in `s` that satisfy the predicate `p` (`Multiset.countP p s`) is equal to the cardinality or size (`Multiset.card`) of the multiset obtained by filtering `s` to only include elements that satisfy `p` (`Multiset.filter p s`). In other words, counting elements in the original multiset that satisfy a certain property is the same as filtering the multiset for that property and counting the elements in the resulting multiset.

For any type `α`, decidable predicate `p` on `α`, and multiset `s` of elements from `α`, the number of elements in `s` satisfying `p` equals the cardinality of the multiset `Multiset.filter p s`.


theorem Equiv.Perm.ofSubtype_apply_of_not_mem :
    ∀ {α : Type u} {p : α → Prop} [inst : DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)),
      ¬p a → (Equiv.Perm.ofSubtype f) a = a :=
  by sorry

This theorem states that for any type `α`, a predicate `p` on `α` that is decidable (i.e., for any element of `α` we can definitively say whether it satisfies `p` or not), a permutation `f` on the subtype of `α` determined by `p`, and an element `a` of `α` which does not satisfy `p` (i.e., `¬p a`), applying the permutation `f` extended to the whole type `α` to `a` results in `a` itself. In other words, the extension of `f` to `α` does not change elements that do not belong to the subtype defined by `p`.

Let `α` be a type, `p` a decidable predicate on `α`, and `f` a permutation on the subtype `{x : α | p x}`. Then for all `a` not in `{x : α | p x}`, `f (a) = a`.


theorem Set.projIcc_val :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) (x : ↑(Set.Icc a b)), Set.projIcc a b h ↑x = x := by
  sorry

This theorem states that for any type `α` that has a linear order, given any two elements `a` and `b` of type `α` such that `a` is less than or equal to `b`, and any element `x` from the closed interval between `a` and `b`, the projection of `x` from `α` onto the closed interval `[a, b]` equals `x` itself. This means that for any element in the closed interval, the process of projecting it onto the interval does not change its value.

For any linear order type `α` and elements `a ≤ b` within it, the projection of any `x ∈ [a, b]` onto the interval `[a, b]` equals `x` itself.


theorem Mathlib.CategoryTheory.Limits.Shapes.Terminal._auxLemma.1 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem, which is part of the CategoryTheory in Mathlib, states that for any type `α` that is a subsingleton (i.e., a type with at most one instance), any two instances `x` and `y` of `α` are equal. The equality `x = y` is always `True`. Therefore, in a subsingleton category, there's essentially only one object, so any two objects must be the same.

In a subsingleton type `α`, any two instances `x` and `y` are equal: `x = y`.


theorem SimpleGraph.Walk.support_append :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : SimpleGraph.Walk G u v) (p' : SimpleGraph.Walk G v w),
      SimpleGraph.Walk.support (SimpleGraph.Walk.append p p') =
        SimpleGraph.Walk.support p ++ List.tail (SimpleGraph.Walk.support p') :=
  by sorry

This theorem states that for any simple graph `G` with vertex type `V`, and any three vertices `u`, `v`, and `w`, if `p` is a walk from `u` to `v` and `p'` is a walk from `v` to `w`, then the list of vertices visited in order (the 'support') of the walk that appends `p'` to `p` is the concatenation of the 'support' of `p` and the 'support' of `p'`, excluding the first vertex of the 'support' of `p'` (since the vertex `v` is already included at the end of the 'support' of `p`).

For any simple graph and vertices u, v, w, if there exist walks p from u to v and p' from v to w, then the support of the walk obtained by appending p' to p is the concatenation of the supports of p and p', with the first vertex of p's support excluded.


Set.IsPWO.isWF

theorem Set.IsPWO.isWF : ∀ {α : Type u_2} [inst : Preorder α] {s : Set α}, Set.IsPWO s → Set.IsWF s := by sorry

The theorem `Set.IsPWO.isWF` states that for any type `α` equipped with a preorder and any set `s` of type `α`, if `s` is partially well-ordered (meaning that any infinite sequence in `s` contains a monotone subsequence of length 2, or equivalently, an infinite monotone subsequence), then `s` is also well-founded with respect to the `<` operation. In other words, if `s` is partially well-ordered, then every non-empty subset of `s` has a minimal element under the `<` operation.

If a preordered set is partially well-ordered, then it is well-founded.


theorem Language.kstar_eq_iSup_pow : ∀ {α : Type u_1} (l : Language α), KStar.kstar l = ⨆ i, l ^ i := by sorry

This theorem states that for any given language `l` over an alphabet of type `α`, the Kleene star operation on `l` is equivalent to the supremum of `l` raised to every natural number `i`. In other words, the set of all strings that can be formed by concatenating zero or more strings from `l` (which is what `KStar.kstar l` denotes) is the same as the union of all sets of strings that can be formed by concatenating `i` strings from `l` for every non-negative integer `i` (which is what `⨆ i, l ^ i` denotes).

For any language `l` over an alphabet `α`, the Kleene star operation `KStar.kstar l` is equal to the supremum `⨆ i, l ^ i` of all powers of `l`.


theorem WithLp.prod_edist_eq_add :
    ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} [inst : EDist α] [inst_1 : EDist β],
      0 < p.toReal →
        ∀ (f g : WithLp p (α × β)),
          edist f g = (edist f.1 g.1 ^ p.toReal + edist f.2 g.2 ^ p.toReal) ^ (1 / p.toReal) :=
  by sorry

This theorem, `WithLp.prod_edist_eq_add`, states that for any extended nonnegative real number `p` greater than 0, and for any types `α` and `β` equipped with an `edist` (extended distance) function, the extended distance between two `WithLp` elements `f` and `g` of the product type `(α × β)` is equal to the pth root of the sum of the `p` power of the extended distance between the first elements of `f` and `g` and the `p` power of the extended distance between the second elements of `f` and `g`. In mathematical terms, for `f = (f1, f2)` and `g = (g1, g2)`, the theorem proves that `edist f g = (edist f1 g1 ^ p.toReal + edist f2 g2 ^ p.toReal) ^ (1/p.toReal)`. This is analogous to the Minkowski inequality in Lp spaces for real numbers.

For any extended real number `p > 0` and types `α` and `β` with an `edist` function, the extended distance between `WithLp` elements `(f1, f2)` and `(g1, g2)` of the product type `α × β` is equal to `(edist (f1, f2) (g1, g2) ^ p.toReal) ^ (1/p.toReal)`, where `edist (f1, f2) (g1, g2)` is the sum of `p`-th powers of the extended distances between their respective components.


theorem Set.image_subset_image2_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {a : α},
      a ∈ s → f a '' t ⊆ Set.image2 f s t :=
  by sorry

The theorem `Set.image_subset_image2_right` states that for all types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, and for any sets `s` of type `α` and `t` of type `β`, and for any element `a` of type `α`, if `a` is an element of the set `s`, then the image of the function `f` applied to `a` and any element in set `t`, is a subset of the image of the binary function `f` applied to the sets `s` and `t`. In other words, for all elements `a` in `s`, the set of all `f(a, b)` where `b` is in `t` is included in the set of all `f(a', b')` where `a'` is in `s` and `b'` is in `t`.

For all sets $S:\alpha$, $T:\beta$, $f:\alpha \times \beta \rightarrow \gamma$, and $a:S$, if $a \in S$ then $f(a, T) \subseteq f(S \times T)$, where $f(a, T) := \{f(a, b) \mid b \in T\}$ and $f(S \times T) := \{f(a, b) \mid a \in S, b \in T\}$.


theorem Filter.eventuallyEq_univ : ∀ {α : Type u} {s : Set α} {l : Filter α}, s =ᶠ[l] Set.univ ↔ s ∈ l := by sorry

This theorem, `Filter.eventuallyEq_univ`, states that for any type `α`, any set `s` of type `α`, and any filter `l` on `α`, the set `s` is eventually equal to the universal set (i.e., `Set.univ`) under the filter `l` if and only if the set `s` belongs to the filter `l`. In other words, the set `s` contains all the elements that will eventually pass through the filter `l`.

For any type `α`, set `s` of `α`, and filter `l` on `α`, `s` is equal to the universal set under filter `l` if and only if `s` belongs to `l`.


theorem monotone_fst : ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β], Monotone Prod.fst := by
  sorry

The theorem `monotone_fst` states that for any types `α` and `β` with preorders defined on them, the `Prod.fst` function is monotone. This means that if we have a pair of elements from `α × β` where the first element of the first pair is less than or equal to the first element of the second pair, then the result of applying `Prod.fst` (which essentially projects out the first component of the pair) on the first pair will be less than or equal to the result of applying `Prod.fst` on the second pair.

For all preordered types `α` and `β`, the `Prod.fst` function on `α × β` is monotone, i.e., `Prod.fst (x, y) ≤ Prod.fst (x', y')` whenever `x ≤ x'`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.preimage_null :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μa : MeasureTheory.Measure α}
      {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.Measure.QuasiMeasurePreserving f μa μb → ∀ {s : Set β}, ↑↑μb s = 0 → ↑↑μa (f ⁻¹' s) = 0 :=
  by sorry

This theorem states that for any given types `α` and `β`, a measurable space `α` denoted by `m0`, another measurable space `β`, two measures `μa` and `μb` for spaces `α` and `β` respectively, and a function `f` mapping `α` to `β`: If the function `f` is quasi measure preserving from measure `μa` to `μb`, then for any set `s` of type `β`, if the measure of `s` with respect to `μb` is zero, then the measure of the preimage of `s` under `f` with respect to `μa` is also zero.

In other words, if a function is quasi measure preserving and a set in the codomain has measure zero, then the measure of the set of all pre-images in the domain is also zero.

If `f: α → β` is a quasi-measure preserving function between measurable spaces `(α, μa)` and `(β, μb)`, then `μa(f⁻¹(S)) = 0` for any `S ⊆ β` with `μb(S) = 0`.


theorem measurable_iInf :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : BorelSpace α]
      [inst_3 : MeasurableSpace δ] [inst_4 : ConditionallyCompleteLinearOrder α] [inst_5 : OrderTopology α]
      [inst : SecondCountableTopology α] {ι : Sort u_6} [inst : Countable ι] {f : ι → δ → α},
      (∀ (i : ι), Measurable (f i)) → Measurable fun b => ⨅ i, f i b :=
  by sorry

The theorem `measurable_iInf` states that for any types `α` and `δ`, if `α` is a topological space, a measurable space, and a Borel space, and `δ` is a measurable space, and `α` also satisfies the properties of being a conditionally complete linear order and an order topology, and if it also has a second countable topology, then for any sort `ι` which is countable, for any function `f` from `ι` to a function from `δ` to `α`, if every such function `f i` is measurable, then the function that maps `b` in `δ` to the infimum of `f i b` over all `i` in `ι` is also measurable. This is a statement about the measurability of the infimum function in the context of measure theory.

If `α` is a second countable, topological, measurable, and Borel space with a conditionally complete linear order and an order topology, then the infimum function of a countable family of measurable functions from `δ` to `α` is measurable.


theorem MeasureTheory.OuterMeasure.top_apply : ∀ {α : Type u_1} {s : Set α}, Set.Nonempty s → ↑⊤ s = ⊤ := by sorry

The theorem `MeasureTheory.OuterMeasure.top_apply` states that for any type `α` and any set `s` of type `α`, if the set `s` is nonempty (i.e., there exists at least one element in `s`), then the application of the top outer measure (denoted by `↑⊤`) to the set `s` equals the top element in the order of outer measures (denoted by `⊤`). This essentially means that the outer measure of any nonempty set according to the most inclusive (or 'top') measure is itself the 'top' or maximum possible measure.

For any nonempty set `s` in a measurable space, the top outer measure `⊤(s)` equals the application of the top measure `↑⊤` to `s`.


theorem Finset.sum_eq_single_of_mem :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {s : Finset α} {f : α → β},
      ∀ a ∈ s, (∀ b ∈ s, b ≠ a → f b = 0) → (Finset.sum s fun x => f x) = f a :=
  by sorry

This theorem, `Finset.sum_eq_single_of_mem`, states that for any given type `α` and `β`, if `β` is an additive commutative monoid, and 's' is a finite set of type `α`, and `f` is a function from `α` to `β`, then for any element `a` in set 's', if for all other elements `b` in 's' that are not equal to `a`, the function `f` maps `b` to the zero element of `β`, then the summation of the function values of the elements in set 's' is equal to the function value of `a`. In other words, if all the other elements of the set are mapped to zero by `f`, the sum over the entire set is just the value of `f` at the single non-zero element `a`.

If `f : α → β` is a function from a finite set `s : Finset α` to an additive commutative monoid `β`, such that for all `b ∈ s \{a}`, `f b = 0`, then `∑ x in s, f x = f a`.


theorem Part.map_id' : ∀ {α : Type u_1} {f : α → α}, (∀ (x : α), f x = x) → ∀ (o : Part α), Part.map f o = o := by sorry

The theorem `Part.map_id'` states that for any type `α`, and for any function `f : α → α` such that `f` is the identity function (i.e., for all `x` of type `α`, `f(x) = x`), the map operation applied to `f` and any partial function `o : Part α` is equal to `o` itself. In other words, mapping an identity function over a partial function leaves the original partial function unchanged.

For any type `α` and identity function `f : α → α`, the map operation `Part.map f o` over a partial function `o : Part α` equals `o` itself.


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

This theorem states that for any type `α` that has a commutative additive monoid structure, the sum of a multiset containing a single element `a` of type `α` is equal to `a` itself. In other words, if you have a multiset with just one element `a`, when you sum up all elements in the multiset using the defined sum operation for the type `α`, you get `a` back.

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


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

This theorem, `Set.mem_univ_pi`, states that for any type `ι`, any function `α` mapping elements of `ι` to a type, any family of sets `t` where each set is associated with an element of `ι`, and any function `f` with the same domain and range as `α`, the function `f` is an element of the set of all functions associating elements of `ι` to elements in the corresponding set in `t` if and only if for every element `i` of `ι`, the value `f(i)` belongs to the set `t(i)`. In other words, a function is in the set of all functions generated by `Set.pi` over the universal set and the family `t` if and only if all its values are in the corresponding set from the family `t`.

For any type `ι`, function `α: ι → Type`, family of sets `t: ι → Set`, and function `f: ι → ∏ i: ι, t(i)`, `f ∈ ∏ i: ι, t(i) → ι, α(i)` if and only if `α(i) ∈ t(i)` for all `i ∈ ι`.


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

This theorem, `CategoryTheory.Iso.hom_comp_eq_id`, states that for any category `C` and any two objects `X` and `Y` in `C`, if there is an isomorphism `α` from `X` to `Y` and a morphism `f` from `Y` to `X`, then the composition of the morphisms `α.hom` and `f` equals the identity morphism on `X` if and only if `f` equals the inverse of `α`. This theorem is related to the properties of isomorphisms in category theory, where an isomorphism is a morphism that has an inverse.

For any category C, given isomorphisms α : X ↔ Y and f : Y ↔ X in C, hom α ∘ f = id\_X if and only if f = α^(-1).


MeasureTheory.HasPDF.aemeasurable

theorem MeasureTheory.HasPDF.aemeasurable :
    ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {x : MeasurableSpace Ω} (X : Ω → E)
      (ℙ : MeasureTheory.Measure Ω) (μ : MeasureTheory.Measure E) [hX : MeasureTheory.HasPDF X ℙ μ], AEMeasurable X ℙ :=
  by sorry

This theorem states that for any random variable `X` taking values in a measurable space `E` and defined on a sample space `Ω`, if `X` has a probability density function with respect to a probability measure `ℙ` on `Ω` and a measure `μ` on `E`, then `X` is "almost everywhere measurable". In other words, there exists a measurable function that is equal to `X` almost everywhere with respect to the measure `ℙ`. The "almost everywhere" condition allows the equality to fail on a set of measure zero.

If a random variable `X` on a sample space `Ω` with values in a measurable space `E` has a probability density function with respect to measures `ℙ` on `Ω` and `μ` on `E`, then `X` is equal almost everywhere to a measurable function.


theorem IsMin.not_lt : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, IsMin a → ¬b < a := by sorry

The theorem `IsMin.not_lt` states that for any type `α` equipped with a preorder, and any elements `a` and `b` of `α`, if `a` is a minimal element, then `b` is not strictly less than `a`. In other words, there does not exist an element `b` in `α` that is strictly less than a minimal element `a` in the preordered set `α`.

If `α` is a preordered type and `a` is a minimal element of `α`, then there is no `b` in `α` such that `b` is strictly less than `a`.


theorem Mathlib.Data.Real.NNReal._auxLemma.16 :
    ∀ {α : Type u_1} {s : Finset α} {f : α → NNReal}, (Finset.sum s fun a => ↑(f a)) = ↑(Finset.sum s fun a => f a) :=
  by sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any function `f` from `α` to the nonnegative real numbers (NNReal), the sum of the values of `f` when applied to the elements of `s` is the same whether you first convert `f a` to a real number and then sum, or first sum over `f a` and then convert to a real number. That is, the operation of summing over a finite set commutes with the operation of converting a nonnegative real number to a real number.

For any type `α`, any finite set `s` of type `α`, and any function `f` from `α` to the non-negative real numbers, the sum of `(f a)` for all `a` in `s` is equal to the real number obtained by summing the real numbers `(f !a)` for all `a` in `s`.


theorem CategoryTheory.GrothendieckTopology.Cover.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
      (S : CategoryTheory.GrothendieckTopology.Cover J X),
      CategoryTheory.GrothendieckTopology.Cover.sieve S ∈ J.sieves X :=
  by sorry

This theorem states that for any category 'C', object 'X' in 'C', and Grothendieck topology 'J' on 'C', if 'S' is a cover of 'X' with respect to 'J', then the sieve associated with 'S' belongs to the collection of sieves on 'X' determined by 'J'. In other words, every cover of an object in a category, under a particular Grothendieck topology, corresponds to a sieve in the set of sieves defined by that topology on that object.

For any category 'C', object 'X' in 'C', and Grothendieck topology 'J' on 'C', the sieve of any cover 'S' of 'X' with respect to 'J' belongs to the collection of sieves on 'X' determined by 'J'.


theorem Matrix.fromBlocks_transpose :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} (A : Matrix n l α) (B : Matrix n m α)
      (C : Matrix o l α) (D : Matrix o m α),
      Matrix.transpose (Matrix.fromBlocks A B C D) =
        Matrix.fromBlocks (Matrix.transpose A) (Matrix.transpose C) (Matrix.transpose B) (Matrix.transpose D) :=
  by sorry

The theorem `Matrix.fromBlocks_transpose` states that for any four matrices `A`, `B`, `C`, `D` where `A` is a matrix with rows indexed by `n` and columns indexed by `l`, `B` is a matrix with rows indexed by `n` and columns indexed by `m`, `C` is a matrix with rows indexed by `o` and columns indexed by `l`, and `D` is a matrix with rows indexed by `o` and columns indexed by `m`, the transpose of the matrix formed by 'block' concatenating these four matrices (`A`, `B`, `C`, `D`) is equal to the matrix formed by 'block' concatenating the transposes of these four matrices (`transpose A`, `transpose B`, `transpose C`, `transpose D`).

In other words, transposing a 'block' matrix composed of four smaller matrices is the same as creating a 'block' matrix from the transposes of the four smaller matrices.

The transpose of a block matrix formed by concatenating matrices `A` of size `n x l`, `B` of size `n x m`, `C` of size `o x l`, and `D` of size `o x m`, is equal to the block matrix formed by concatenating the transposes of `A`, `B`, `C`, and `D`.


theorem Equiv.Perm.sameCycle_apply_right :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, Equiv.Perm.SameCycle f x (f y) ↔ Equiv.Perm.SameCycle f x y := by
  sorry

This theorem states that for any type `α`, for any permutation `f` of `α`, and for any elements `x` and `y` of `α`, `x` and `f(y)` are in the same cycle of `f` if and only if `x` and `y` are in the same cycle of `f`. In other words, applying the permutation `f` to `y` does not change whether `x` and `y` are in the same cycle of `f`.

For any permutation `f` and elements `x` and `y` of type `α`, `x` and `y` are in the same cycle of `f` if and only if `f(y)` is in the same cycle of `x`.


/-- `X ^ n - a` is monic.  -/
theorem Polynomial.monic_X_pow_sub_C :
    ∀ {R : Type u} [inst : Ring R] (a : R) {n : ℕ}, n ≠ 0 → Polynomial.Monic (Polynomial.X ^ n - Polynomial.C a) := by
  sorry

The theorem `Polynomial.monic_X_pow_sub_C` states that for any ring `R`, any element `a` from `R`, and any natural number `n` different from zero, the polynomial `X^n - a` is monic, i.e., its leading coefficient is 1. Here, `X` represents the polynomial variable and `C a` denotes the constant polynomial `a`.

For any ring `R`, `X^n - C a` is a monic polynomial in `R[X]` for any `a` in `R` and natural number `n` different from zero.


theorem Set.InjOn.bijOn_image :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s → Set.BijOn f s (f '' s) := by sorry

This theorem, referred to as `Set.InjOn.bijOn_image`, states that for any two types `α` and `β`, a set `s` of type `α` and a function `f` mapping from `α` to `β`, if the function `f` is injective on the set `s` (meaning that for every two different elements in `s`, their images under `f` are also different), then `f` is also bijective from `s` to the image of `s` under `f` (denoted as `f '' s`). In other words, `f` not only maps distinct elements of `s` to distinct elements in its image, but also every element in the image of `s` comes from an element in `s` (surjective), thereby establishing a one-to-one correspondence between `s` and `f '' s` (bijective).

If a function from a set to another set is injective on a subset, then it is bijective from that subset to its image.


theorem ENNReal.div_self : ∀ {a : ENNReal}, a ≠ 0 → a ≠ ⊤ → a / a = 1 := by sorry

This theorem states that for any extended nonnegative real number `a`, as long as `a` is neither 0 nor infinity (denoted by `⊤`), the result of dividing `a` by itself is always 1. In other words, any nonzero, finite extended nonnegative real number divided by itself equals 1. This is a Lean 4 formalisation of the familiar algebraic property $\frac{a}{a} = 1$ for any non-zero real number `a`.

Any nonzero extended nonnegative real number `a` satisfies `a / a = 1`.


theorem Set.image_mul_left :
    ∀ {α : Type u_2} [inst : Group α] {t : Set α} {a : α}, (fun x => a * x) '' t = (fun x => a⁻¹ * x) ⁻¹' t := by sorry

This theorem states that for any type `α` that forms a group, a given set `t` of elements of type `α`, and a specific element `a` of type `α`, the image of the set `t` under the left-multiplication function by `a` (`a * x` for each `x` in `t`) is equal to the preimage of the set `t` under the function of left-multiplication by the inverse of `a` (`a⁻¹ * x`). In other words, multiplying each element of a set by a group element and taking the preimage of a set by multiplying each element by the inverse of the same group element gives the same result.

For any group `α` and its element `a`, the sets `{a * x | x ∈ t}` and `{x | x ∈ t ∧ a⁻¹ * x = x}` are equal.


theorem CategoryTheory.Limits.pushout.inl_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W)
      (w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inl (CategoryTheory.Limits.pushout.desc h k w) =
        h :=
  by sorry

The theorem `CategoryTheory.Limits.pushout.inl_desc` states that for any category `C` and objects `W`, `X`, `Y`, `Z` in `C`, given two morphisms `f : X ⟶ Y` and `g : X ⟶ Z`, with a pushout existing for `f` and `g`, and two morphisms `h : Y ⟶ W` and `k : Z ⟶ W` such that the composition of `f` with `h` equals the composition of `g` with `k` (denoted as `CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k`), then the composition of `CategoryTheory.Limits.pushout.inl` with `CategoryTheory.Limits.pushout.desc h k w` is equal to `h`. In terms of category theory, this is stating a property of the pushout, a type of colimit, which characterizes it up to unique isomorphism.

Given a pushout diagram in a category `C` with objects `X`, `Y`, `Z`, and `W`, morphisms `f : X ⟶ Y`, `g : X ⟶ Z`, and compositions `h : Y ⟶ W` and `k : Z ⟶ W` satisfying `f · h = g · k`, then `CategoryTheory.Limits.pushout.inl (h, k) · w = h`, where `w` is any object in the pushout of `f` and `g`.


theorem Equiv.trans_apply :
    ∀ {α : Sort u} {β : Sort v} {γ : Sort w} (f : α ≃ β) (g : β ≃ γ) (a : α), (f.trans g) a = g (f a) := by sorry

This theorem states that for any sorts `α`, `β`, and `γ`, and for any equivalences `f` between `α` and `β`, and `g` between `β` and `γ`, and for any element `a` of `α`, the application of the composition of `f` and `g` to `a` is the same as the application of `g` to the image of `a` under `f`. In mathematical terms, this is saying that $(f \circ g)(a) = g(f(a))$, which is a fundamental property of function composition.

For any equivalences f : α ↔ β and g : β ↔ γ, and any element a in α, (f ∘ g)(a) = g(f(a)).


theorem Set.image_pair : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (a b : α), f '' {a, b} = {f a, f b} := by sorry

This theorem states that for any function `f` from type `α` to type `β`, and any two elements `a` and `b` of type `α`, the image of the set `{a, b}` under the function `f` equals the set `{f(a), f(b)}`. In mathematical terms, if we apply a function to each element in a set containing two elements, we get a new set containing the function applied to each of these two elements.

For any function `f` from type `α` to type `β`, the image of a set with two elements `{a, b}` under `f` is `{f(a), f(b)}`. In mathematical notation: `f({a, b}) = {f(a), f(b)}`.


theorem Computation.mem_bind :
    ∀ {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {a : α} {b : β},
      a ∈ s → b ∈ f a → b ∈ Computation.bind s f :=
  by sorry

The theorem `Computation.mem_bind` states that for any types `α` and `β`, a computation `s` of type `α`, a function `f` mapping from type `α` to a computation of type `β`, and any elements `a` of type `α` and `b` of type `β`, if `a` is an element of `s` and `b` is an element of `f(a)`, then `b` is also an element of the computation resulting from binding `s` with `f`. This theorem essentially describes the property of monadic bind operation in the context of computations.

If `a` is an element of computation `s` and `b` is an element of `f(a)`, then `b` is an element of the computation obtained by binding `s` with `f`. In other words, `Computation.mem_bind` asserts the monadic law of binding for computations.


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

The theorem `MvPolynomial.eval₂Hom_congr` states that for all commutative semiring, denoted as `R` and `S₁`, and a type `σ`, given two ring homomorphisms `f₁` and `f₂` from `R` to `S₁`, two functions `g₁` and `g₂` from `σ` to `S₁`, and two multivariate polynomials `p₁` and `p₂` with coefficients in `R` and variables indexed by `σ`, if `f₁` is equal to `f₂`, `g₁` is equal to `g₂`, and `p₁` is equal to `p₂`, then the result of evaluating `p₁` under the ring homomorphism `f₁` and the function `g₁` is the same as the result of evaluating `p₂` under the ring homomorphism `f₂` and the function `g₂`. This is done using the `eval₂Hom` function of `MvPolynomial`, which takes a ring homomorphism and a function as arguments and returns a ring homomorphism.

Given commutative semirings R and S₁, ring homomorphisms f₁ = f₂ from R to S₁, functions g₁ = g₂ from a type σ to S₁, and multivariate polynomials p₁ = p₂ over R with variables indexed by σ, if f₁(x) = f₂(x) for all x in R and g₁(s) = g₂(s) for all s in σ, then MvPolynomial.eval₂Hom f₁ g₁(p₁) = MvPolynomial.eval₂Hom f₂ g₂(p₂).


theorem le_iSup_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteSemilatticeSup α] {a : α} {s : ι → α},
      a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b :=
  by sorry

This theorem states that for any type `α` that forms a complete semilattice with supremum, and any `α`-valued function `s` indexed by type `ι`, a condition `a` being less than or equal to the indexed supremum of `s` is equivalent to: for all `b` in `α`, if all elements of `s` are less than or equal to `b`, then `a` is also less than or equal to `b`. Effectively, it relates the notion of being less than or equal to the supremum of a set to the idea of being less than or equal to every upper bound of that set.

For any complete semilattice `α` with supremum and any `α`-valued function `s` indexed by type `ι`, `a ≤ sup s iff ∀b ∈ α, (∀i, s i ≤ b) → a ≤ b`.


theorem disjoint_nhds_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {x y : X}, Disjoint (nhds x) (nhds y) ↔ x ≠ y :=
  by sorry

This theorem states that for any topological space `X` which also satisfies the T2 separation axiom (also known as a Hausdorff space), two points `x` and `y` in `X` have disjoint neighborhood filters (i.e., there are no elements common to both filters) if and only if `x` is not equal to `y`. The T2 separation axiom guarantees that for any two distinct points in the space, there exist non-overlapping open neighborhoods around each point. Hence, the theorem essentially formalizes the notion that distinct points in a Hausdorff space have distinct neighborhood filters.

In a T2 topological space, two distinct points have disjoint neighborhood filters.


Equiv.isEmpty

theorem Equiv.isEmpty : ∀ {α : Sort u_1} {β : Sort u_2}, α ≃ β → ∀ [inst : IsEmpty β], IsEmpty α := by sorry

The theorem `Equiv.isEmpty` states that for any sorts `α` and `β`, if `α` is equivalent to `β` and `β` is empty (as indicated by the instance `IsEmpty β`), then `α` is also empty (the result is `IsEmpty α`). Essentially, this theorem links the emptiness of two equivalent sorts: the emptiness of one ensures the emptiness of the other.

If `α` is equivalent to an empty sort `β`, then `α` is also empty.


theorem monotone_snd : ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β], Monotone Prod.snd := by
  sorry

This theorem, `monotone_snd`, states that for any types `α` and `β` that are both ordered (preorder), the function `Prod.snd`, which returns the second element of a pair, is a monotone function. This means that if we have a pair `(a, b)` and `(c, d)`, where `a ≤ c`, then `b ≤ d`. Thus, the order of the second elements in the pairs is preserved.

For any preordered types `α` and `β`, the second projection `Prod.snd` on pairs of type `(α × β)` is a monotone function, preserveing the order of the second components.


/-- Closure of a subgroup `K` equals `K`.  -/
theorem Subgroup.closure_eq : ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G), Subgroup.closure ↑K = K := by sorry

This theorem states that for any group `G`, the `Subgroup.closure` of a subgroup `K` of `G` is equal to `K` itself. In other words, when we take the closure of a subgroup (which is the smallest subgroup containing a given set), it remains the same subgroup. This is because a subgroup is already closed under the group operations, so the process of taking the closure doesn't change anything.

For any subgroup `K` of a group `G`, `Subgroup.closure K` equals `K`.


theorem Bool.cond_decide :
    ∀ {α : Type u_1} (p : Prop) [inst : Decidable p] (t e : α), (bif decide p then t else e) = if p then t else e := by
  sorry

This theorem, `Bool.cond_decide`, states that for any type `α`, proposition `p`, and elements `t` and `e` of type `α`, the evaluation of the Boolean "if-then-else" expression that uses `decide p` (which computes the truth value of `p`) as its condition is identical to the evaluation of the traditional "if-then-else" expression with `p` as its condition. Essentially, it says that we can replace the condition `p` with `decide p` in an "if-then-else" expression without changing the result. This holds for any decidable proposition `p`.

For any type `α`, decidable proposition `p` over `α`, and elements `t`, `e` of type `α`, `decide p t = if p then t else e`.


theorem Nat.lt_of_le_of_ne : ∀ {n m : ℕ}, n ≤ m → ¬n = m → n < m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m` and `n` is not equal to `m`, then `n` is less than `m`. In other words, it confirms the property that when two natural numbers are not equal, and one is not greater than the other, then it must be strictly less than the other.

For all natural numbers `n` and `m`, if `n` < `m` and `n` ≠ `m`, then `n` < `m`.


theorem MvFunctor.map_map :
    ∀ {n : ℕ} {α β γ : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [inst : MvFunctor F] [inst_1 : LawfulMvFunctor F]
      (g : TypeVec.Arrow α β) (h : TypeVec.Arrow β γ) (x : F α),
      MvFunctor.map h (MvFunctor.map g x) = MvFunctor.map (TypeVec.comp h g) x :=
  by sorry

The theorem `MvFunctor.map_map` states that for any natural number `n`, any three `n`-tuples of types `α`, `β`, `γ`, and any type constructor `F` that takes an `n`-tuple of types to a type, given that `F` is a multivariate functor (MvFunctor) and respects the laws of a lawful multivariate functor (LawfulMvFunctor), and given two arrows `g` and `h` in the category of `n`-tuples of types (`TypeVec`) and an `n`-tuple of types `x`, mapping `x` first by `g` and then by `h` (i.e., `MvFunctor.map h (MvFunctor.map g x)`) is equivalent to mapping `x` directly by the composition of `h` and `g` (i.e., `MvFunctor.map (TypeVec.comp h g) x`). This is a form of functor law in this specific category of n-tuples of types.

For any natural number `n`, given an `n`-tuple `x` of types, a multivariate functor `F` that is lawful, and arrows `g` and `h` in the category of `n`-tuples, `MvFunctor.map (TypeVec.comp h g) x = MvFunctor.map (h ∘ g) x`.


theorem Int.units_mul_self : ∀ (u : ℤˣ), u * u = 1 := by sorry

This theorem states that for every unit `u` in the set of units of integers `ℤˣ`, multiplying `u` by itself always yields 1. In other words, this theorem defines that every unit in the integer ring is its own multiplicative inverse.

Every unit in the integers has multiplicative inverse and equals it in the multiplication, i.e., for all units `u` in `ℤˣ`, `u * u = 1`.


theorem Finset.sum_lt_sum :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelAddCommMonoid M] {f g : ι → M} {s : Finset ι},
      (∀ i ∈ s, f i ≤ g i) → (∃ i ∈ s, f i < g i) → (Finset.sum s fun i => f i) < Finset.sum s fun i => g i :=
  by sorry

The theorem `Finset.sum_lt_sum` states that for any finite set `s` of a certain type `ι` and for any two functions `f` and `g` from `ι` to a type `M` (which is an ordered cancel additive commutative monoid), if for each element `i` in `s`, `f(i)` is less than or equal to `g(i)` and there exists an element `i` in `s` for which `f(i)` is strictly less than `g(i)`, then the sum of `f(i)` over all `i` in `s` is strictly less than the sum of `g(i)` over all `i` in `s`. In other words, if every value of `f` is less than or equal to the corresponding value of `g` and at least one value of `f` is strictly less, then the total sum of `f`'s values is strictly less than the total sum of `g`'s values.

If `f` and `g` are functions from a finite set `s` to an ordered cancel additive commutative monoid, where `f(i) ≤ g(i)` for all `i` in `s` and there exists an `i` in `s` with `f(i) < g(i)`, then `∑(i in s) f(i) < ∑(i in s) g(i)`.


theorem Complex.log_re : ∀ (x : ℂ), (Complex.log x).re = Real.log (Complex.abs x) := by sorry

The theorem `Complex.log_re` states that for any complex number `x`, the real part of the natural logarithm of `x` (as computed by the `Complex.log` function) is equal to the natural logarithm of the absolute value of `x` (computed by the `Real.log` function after obtaining the absolute value using `Complex.abs`). This essentially connects the concepts of logarithms and absolute values in the realms of both real and complex numbers.

The real part of the complex logarithm `Complex.log x` equals the natural logarithm of the absolute value `Real.log (Complex.abs x)` for any complex number `x`.


DistribMulActionHom.ext

theorem DistribMulActionHom.ext :
    ∀ {M : Type u_5} [inst : Monoid M] {A : Type u_6} [inst_1 : AddMonoid A] [inst_2 : DistribMulAction M A]
      {B : Type u_8} [inst_3 : AddMonoid B] [inst_4 : DistribMulAction M B] {f g : A →+[M] B},
      (∀ (x : A), f x = g x) → f = g :=
  by sorry

This theorem, `DistribMulActionHom.ext`, states that for any monoid `M`, any two types `A` and `B` that are both additively monoid and have a distributive multiplication action by `M`, and any two distributive multiplication action homomorphisms from `A` to `B` denoted as `f` and `g`, if `f` and `g` are equal for all elements `x` of `A` then `f` and `g` are equal as homomorphisms. In simple terms, if two transformations from `A` to `B` are always equal when applied to any element of `A`, then these transformations are considered identical.

If `f` and `g` are two distributive multiplication action homomorphisms from additively monoid `A` to additively monoid `B` with distributive multiplication over `M`, and `f(x) = g(x)` for all `x` in `A`, then `f = g` as homomorphisms.


theorem Complex.abs_re_le_abs : ∀ (z : ℂ), |z.re| ≤ Complex.abs z := by sorry

This theorem states that for any complex number `z`, the absolute value of the real part of `z`, denoted by `|z.re|`, is less than or equal to the absolute value of `z` itself, denoted by `Complex.abs z`. In other words, the magnitude of the real component of a complex number can never exceed the magnitude of the complex number itself.

The absolute value of the real part of a complex number is less than or equal to its absolute value. |z.re| ≤ |z| for all complex numbers z.


/-- To prove two algebra structures on a fixed `[CommSemiring R] [Semiring A]` agree,
it suffices to check the `algebraMap`s agree.
 -/
theorem Algebra.algebra_ext :
    ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] (P Q : Algebra R A),
      (∀ (r : R), (algebraMap R A) r = (algebraMap R A) r) → P = Q :=
  by sorry

This theorem states that to show equivalence between two algebra structures, `P` and `Q`, on a fixed pair of commutative semiring `R` and semiring `A`, it is enough to show that their corresponding `algebraMap`s, which are the embeddings from `R` to `A` defined by these algebra structures, agree for all elements `r` of `R`. In other words, if for every element `r` from `R`, the result of applying `algebraMap` under algebra structure `P` is the same as applying `algebraMap` under algebra structure `Q`, then the two algebra structures `P` and `Q` are the same.

If for all elements \(r\) in a commutative semiring \(R\), the algebra maps \(P(r)\) and \(Q(r)\) from algebra structures \(P\) and \(Q\) over semiring \(A\) agree, then \(P\) and \(Q\) are equal algebra structures.


theorem CategoryTheory.Pretriangulated.Triangle.coyoneda_exact₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        ∀ {X : C} (f : X ⟶ T.obj₂),
          CategoryTheory.CategoryStruct.comp f T.mor₂ = 0 → ∃ g, f = CategoryTheory.CategoryStruct.comp g T.mor₁ :=
  by sorry

This theorem is about the exactness property of a pretriangulated category. Given a pretriangulated category `C`, which is also preadditive and has a zero object and shift functor, for any distinguished triangle `T` in this category, if we have an object `X` in this category and a morphism `f` from `X` to the second object in the triangle `T` such that the composition of `f` and the second morphism in `T` is zero, then there exists another morphism `g` such that `f` is the composition of `g` and the first morphism in `T`. This property is a part of the axioms of a category being triangulated, and the theorem suggests that the coyoneda functor preserves exact sequences.

In a pretriangulated category with zero object and shift functor, given a distinguished triangle and a morphism with zero composition, there exists another morphism making the given morphism the composition of the first two morphisms in the triangle.


theorem abs_sub_lt_iff :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b c : α}, |a - b| < c ↔ a - b < c ∧ b - a < c := by sorry

This theorem states that for any type `α` that is a linearly ordered additive commutative group, and any three elements `a`, `b`, and `c` of this type, the absolute value of the difference between `a` and `b`, denoted `|a - b|`, is less than `c` if and only if `a - b` is less than `c` and `b - a` is less than `c`. In mathematical terms, this theorem is expressing the fact that |a - b| < c if and only if both a - b < c and b - a < c.

For any linearly ordered additive commutative group type `α` and elements `a, b, c` of `α`, |a - b| < c if and only if both a - b and b - a are less than c.


theorem TwoUniqueSums.of_injective_addHom :
    ∀ {G : Type u} {H : Type v} [inst : Add G] [inst_1 : Add H] (f : AddHom H G),
      Function.Injective ⇑f → TwoUniqueSums G → TwoUniqueSums H :=
  by sorry

The theorem `TwoUniqueSums.of_injective_addHom` states that for any two types `G` and `H`, both equipped with an additive structure represented by `[Add G]` and `[Add H]` respectively, if there exists an additive homomorphism `f` from `H` to `G` that is injective (i.e., if when the function `f` maps two elements of `H` to the same element in `G`, those two elements were already the same in `H`), then the property of having "two unique sums" in `G` implies the same property in `H`. Here, "two unique sums" is a property of an additive type that ensures the uniqueness of the decomposition of every element as a sum of two others.

If `f` is an injective additive homomorphism from an additive type `H` to an additive type `G` with the property of having two unique sums, then `H` also has the property of having two unique sums.


theorem Multiset.prod_zero : ∀ {α : Type u_2} [inst : CommMonoid α], Multiset.prod 0 = 1 := by sorry

This theorem states that the product of an empty multiset equals the identity element of a commutative monoid. Given any type `α` with a commutative monoid structure, when we apply the `Multiset.prod` function to an empty multiset (denoted by `0`), we get the multiplicative identity of that monoid, which is `1`.

For any commutative monoid type `α`, the product of an empty multiset over `α` equals the monoid's identity element.


AffineSubspace.WOppSide.symm

/-- **Alias** of the forward direction of `AffineSubspace.wOppSide_comm`. -/
theorem AffineSubspace.WOppSide.symm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.WOppSide s x y → AffineSubspace.WOppSide s y x :=
  by sorry

The theorem `AffineSubspace.WOppSide.symm` states that for any strict ordered commutative ring `R`, additive commutative group `V`, module `R V`, and additive torsor `V P`, given an affine subspace `s` of `R P` and points `x` and `y` of `P`, if `x` and `y` are weakly on opposite sides of `s`, then `y` and `x` are also weakly on opposite sides of `s`.

Here, points `x` and `y` being weakly on opposite sides of `s` means that there exists pair of points `p₁` and `p₂` in `s` such that the vector pointing from `x` to `p₁` and the vector pointing from `p₂` to `y` are on the same ray. The theorem ensures this condition is symmetric.

If points `x` and `y` in a set `P` are weakly opposite sides of an affine subspace `s` in a module `R V` over a commutative ring `R`, then `y` and `x` are also weakly opposite sides of `s`.


theorem Nat.add_div_right : ∀ (x : ℕ) {z : ℕ}, 0 < z → (x + z) / z = Nat.succ (x / z) := by sorry

This theorem states that for all natural numbers `x` and `z`, if `z` is greater than 0, then the division of the sum of `x` and `z` by `z` equals to the successor (or next natural number) of the result of the division of `x` by `z`. In mathematical terms, if `0 < z`, then `(x + z) / z = (x / z) + 1`.

For any natural numbers `x` and `z` with `z > 0`, the quotient of the sum `x + z` by `z` equals the sum of the quotient of `x` by `z` and 1. In mathematical notation, `(x + z) / z = (x / z) + 1`.


theorem Ideal.isUnit_iff : ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R}, IsUnit I ↔ I = ⊤ := by sorry

This theorem states that for any commutative semiring `R` and any ideal `I` within `R`, `I` is a unit if and only if `I` is the top element. In other words, an ideal in a commutative semiring is a unit, meaning it has a two-sided inverse, if and only if it is equal to the entire semiring. This theorem provides a characterization of unit ideals in a commutative semiring.

An ideal in a commutative semiring is a unit if and only if it equals the entire semiring.


theorem subset_interior_iff_mem_nhdsSet :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, s ⊆ interior t ↔ t ∈ nhdsSet s := by sorry

This theorem is stating that for any topological space `X` and any two sets `s` and `t` of type `X`, `s` is a subset of the interior of `t` if and only if `t` is in the filter of neighborhoods of `s`. In simpler terms, in the context of topology, a set `s` is contained within the largest open subset of `t` if and only if `t` is a neighborhood of `s`. This theorem forms a connection between the concepts of interior of a set and neighborhood filters in a topological space.

A set is a subset of the interior of another set if and only if the other set is in the filter of neighborhoods of the first set.


QuotientMap.continuous

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

This theorem states that for any two types `X` and `Y` with respective topological spaces, and any function `f` from `X` to `Y`, if `f` is a quotient map, then `f` is continuous. In the context of topology, a function is continuous if the preimage of every open set is open, and a function is a quotient map if it is surjective and the topology on the codomain is the coinduced topology from the domain through the function.

A surjective quotient map between topological spaces is a continuous function.


theorem convex_Ioi :
    ∀ {𝕜 : Type u_1} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedCancelAddCommMonoid β]
      [inst_2 : Module 𝕜 β] [inst_3 : OrderedSMul 𝕜 β] (r : β), Convex 𝕜 (Set.Ioi r) :=
  by sorry

This theorem, `convex_Ioi`, states that for any given ordered semiring `𝕜` and an ordered, cancellative, commutative additive monoid `β` that is a `𝕜`-module and has an ordered scalar multiplication, any left-open right-infinite interval `(r, ∞)` is a convex set. Essentially, it asserts that if you pick any two points in this interval, then the entire line segment between these two points also lies within the interval.

For any ordered semiring `𝕜`, ordered, cancellative, commutative additive monoid `β` that is a `𝕜`-module and has an ordered scalar multiplication, the left-open right-infinite interval `(r, ∞)` is a convex set in `β` with respect to `𝕜`.


theorem Nat.eq_one_of_dvd_one : ∀ {n : ℕ}, n ∣ 1 → n = 1 := by sorry

This theorem states that for any natural number `n`, if `n` divides 1, then `n` must be equal to 1. In mathematical terms, it asserts that if `n` is a divisor of 1 in the set of natural numbers, its value has to be 1. This is because 1 is the only natural number that can divide 1 to yield another natural number.

If a natural number `n` divides 1, then `n` equals 1.


/-- Prepending the head of a vector to its tail gives the vector.  -/
theorem Vector.cons_head_tail :
    ∀ {α : Type u} {n : ℕ} (v : Vector α (Nat.succ n)), Vector.head v ::ᵥ Vector.tail v = v := by sorry

The theorem `Vector.cons_head_tail` states that for any vector `v` of length `n+1` with elements of any type `α`, if you prepend the head of `v` to the tail of `v`, you get back the original vector `v`. In other words, it asserts that the operation of taking the head and tail of a vector and then reassembling them through prepending does not change the vector.

For any vector `v` of length `n+1` over type `α`, `v = cons (hd v) (tl v)`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.6 :
    ∀ {α : Type u_2} [inst : Zero α] {s : Finset α}, (0 ⊆ s) = (0 ∈ s) := by sorry

This theorem, titled `Mathlib.Data.Finset.Pointwise._auxLemma.6`, states that for any type `α` that has a `Zero` instance, and for any finite set `s` of type `α`, the condition that the zero element is a subset of `s` is equivalent to the zero element being an element of `s`. The subset notation here is being used to denote that all elements of the singleton set containing zero are also elements of `s`.

For any type `α` with a `Zero` instance and any finite set `s` of type `α`, the zero element belongs to `s` if and only if the zero element is a subset of `s`.


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

This theorem states that for any two propositions `a` and `b`, the equivalence of `a ∧ b` (the conjunction of `a` and `b`) and `a` is itself equivalent to the implication from `a` to `b` (i.e., if `a` is true, then `b` must also be true). The intuition behind this is that if `a` and `b` together are equivalent to `a` alone, then `a` being true is enough to guarantee that `b` is also true.

The theorem asserts that for all propositions `a` and `b`, the equivalence of `a ∧ b` and `a` is equivalent to the implication `a → b`.


/-- Corresponds to `dist_self`.  -/
theorem hammingDist_self :
    ∀ {ι : Type u_2} {β : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)] (x : (i : ι) → β i),
      hammingDist x x = 0 :=
  by sorry

This theorem states that for any finite type `ι` and any type `β` indexed by `ι`, if there exists a decidable equality on each `β i`, then the Hamming distance of any function `x : (i : ι) → β i` to itself is always 0. In other words, the Hamming distance, which counts the number of positions at which the corresponding values are different, between a function and itself is always zero, as there are no positions at which they differ.

For any finite type `ι` and type `β` indexed by `ι` equipped with a decidable equality, the Hamming distance of a function `x : ι → β` to itself is always 0.


theorem NNReal.coe_inv : ∀ (r : NNReal), ↑r⁻¹ = (↑r)⁻¹ := by sorry

This theorem states that for all nonnegative real numbers `r`, the operation of taking the multiplicative inverse (or reciprocal) commutes with the coercion operation from nonnegative real numbers to real numbers. In other words, for any `r` in the set of nonnegative real numbers, the inverse of the coerced value of `r` (that is, treating `r` as a regular real number and finding its multiplicative inverse) is the same as the coerced value of the inverse of `r`. In mathematical notations, it can be written as: for all $r \in \text{NNReal}$, $(r^{-1})^\vee = (r^\vee)^{-1}$ where $^\vee$ denotes the coercion.

For all non-negative real numbers $r$, $(r^{-1})^\vee = (r^\vee)^{-1}$, where $\vee$ denotes the coercion.


theorem tsum_add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α}
      [inst_2 : T2Space α] [inst_3 : ContinuousAdd α],
      Summable f → Summable g → ∑' (b : β), (f b + g b) = ∑' (b : β), f b + ∑' (b : β), g b :=
  by sorry

The theorem `tsum_add` states that for any two functions `f` and `g` from a type `β` to a type `α`, if `α` is an additive commutative monoid, a topological space, a Hausdorff space (`T2Space`), and the addition operation on `α` is continuous (`ContinuousAdd`), then if both `f` and `g` are summable (meaning that their infinite series converges to some value), the sum of the infinite series of the sum of `f` and `g` (for each element in `β`) is equal to the sum of the individual infinite series of `f` and `g`. In other words, we have $\sum_{b\in \beta} (f(b) + g(b)) = \sum_{b\in \beta} f(b) + \sum_{b\in \beta} g(b)$.

Given functions `f` and `g` from a type `β` to an additive commutative monoid `α`, which is a T2 space with continuous addition, if both `f` and `g` have convergent infinite series, then their series sum is commutative and distributive over the pointwise addition of `f` and `g`, i.e., ∫(β, α, f + g) = ∫(β, α, f) + ∫(β, α, g).


Sylow.ext

theorem Sylow.ext : ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {P Q : Sylow p G}, ↑P = ↑Q → P = Q := by sorry

This theorem, known as "Sylow.ext", states that for any natural number `p`, any group `G` of type `u_1`, and any two Sylow subgroups `P` and `Q` of `G`, if the underlying sets of `P` and `Q` (denoted by `↑P` and `↑Q` respectively) are equal, then `P` and `Q` are the same Sylow subgroup. In other words, a Sylow subgroup is uniquely determined by its underlying set.

If two Sylow subgroups of a group have equal underlying sets, then they are equal as subgroups.


theorem continuous_nsmul :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [inst_2 : ContinuousAdd M] (n : ℕ),
      Continuous fun a => n • a :=
  by sorry

This theorem states that for any type `M` equipped with a topological space structure, an addition operation that makes `M` an additive monoid, and a continuous addition operation, the function that multiplies an element of `M` by an integer `n` (`n • a`) is continuous.

For any topological additive monoid (M, +) with a continuous addition operation, the scalar multiplication function (n => n \\* a) is continuous for all elements a in M and integers n.


theorem CategoryTheory.Limits.Sigma.ι_comp_map' :
    ∀ {β : Type w} {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C}
      [inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g] (p : α → β)
      (q : (a : α) → f a ⟶ g (p a)) (a : α),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f a) (CategoryTheory.Limits.Sigma.map' p q) =
        CategoryTheory.CategoryStruct.comp (q a) (CategoryTheory.Limits.Sigma.ι g (p a)) :=
  by sorry

This theorem states that for any two types `α` and `β`, and a category `C`, given functions `f : α → C` and `g : β → C` which have coproducts, and a function `p : α → β` as well as a family of morphisms `q : (a : α) → f a ⟶ g (p a)`, for any `a : α`, the composition of the `a`-th inclusion of `f` and the map induced by `p` and `q` on the sigma-object over `f` is equal to the composition of the morphism `q a` and the `p(a)`-th inclusion of `g`. This shows a compatibility between the operation of taking coproducts and the composition of morphisms in the category.

For any types `α` and `β` and a category `C`, given functions `f : α → C`, `g : β → C`, and a morphism `p : α → β`, if `f` and `g` have coproducts and there are given morphisms `q : ∀ a : α, f a → g (p a)`, then the composition of the coproduct inclusion of `f a` and `p` with `q a` equals the composition of `q a` and the coproduct inclusion of `g (p a)` for all `a : α`.


theorem LinearMap.mul_eq_comp :
    ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (f g : Module.End R M), f * g = f ∘ₗ g :=
  by sorry

This theorem states that for any semiring `R` and any additive commutative monoid `M` that also has a `R`-module structure, for any two endomorphisms `f` and `g` of the `R`-module `M`, the multiplication of `f` and `g` (in the sense of the ring structure on the endomorphism ring `Module.End R M`) is equal to the linear composition of `f` and `g` (i.e., first applying `g`, then `f`). In other words, the ring multiplication on the endomorphism ring corresponds to the composition of endomorphisms.

For any semiring `R`, additive commutative `R`-module `M`, and endomorphisms `f` and `g` of `M`, `Module.End R M.mul (f : M → M) (g : M → M) = g ∘ f`.


theorem Nat.ModEq.mul_left : ∀ {n a b : ℕ} (c : ℕ), a ≡ b [MOD n] → c * a ≡ c * b [MOD n] := by sorry

This theorem, `Nat.ModEq.mul_left`, states that for any natural numbers `n`, `a`, `b`, and `c`, if `a` is congruent to `b` modulo `n` (denoted as `a ≡ b [MOD n]`), then the product of `c` and `a` is also congruent to the product of `c` and `b` modulo `n` (denoted as `c * a ≡ c * b [MOD n]`). In other words, if two numbers are congruent modulo `n`, multiplying both by the same value maintains their congruence modulo `n`.

If `a` is congruent to `b` modulo `n`, then `c * a` is congruent to `c * b` modulo `n`.


theorem Finsupp.mapRange_id :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (g : α →₀ M), Finsupp.mapRange id ⋯ g = g := by sorry

This theorem, `Finsupp.mapRange_id`, states that for any type `α` and any type `M` that has an instance of `Zero`, the function `Finsupp.mapRange id` applied to any function `g` (from `α` to `M`) is equal to `g` itself. In other words, mapping the identity function over the range of a function doesn't change the function.

For any type `α` and any function `g : α → M` where `M` has an instance of `Zero`, `Finsupp.mapRange id g` equals `g`.


theorem Ordinal.enumOrd_strictMono :
    ∀ {S : Set Ordinal.{u}}, Set.Unbounded (fun x x_1 => x < x_1) S → StrictMono (Ordinal.enumOrd S) := by sorry

The theorem `Ordinal.enumOrd_strictMono` states that for every set `S` of ordinals that is unbounded (in the sense that for every ordinal, there exists an ordinal in `S` that is larger), the function `Ordinal.enumOrd` that enumerates the ordinals in `S` is strictly monotone. In other words, if `a` is less than `b`, then the `a`th ordinal in `S` is less than the `b`th ordinal in `S`. This is expressed in mathematical notation as: for all `a` and `b`, `a < b` implies `Ordinal.enumOrd(S)(a) < Ordinal.enumOrd(S)(b)`.

For every unbounded set `S` of ordinals, the function `Ordinal.enumOrd(S)` is a strictly increasing enumeration of `S`.


theorem RingHom.ext_int : ∀ {R : Type u_5} [inst : NonAssocSemiring R] (f g : ℤ →+* R), f = g := by sorry

This theorem states that for any type `R` which is an instance of a Non-Associative Semiring, all ring homomorphisms from the integers (`ℤ`) to `R` are equal. That means, given any two ring homomorphisms `f` and `g` from the integers to `R`, `f` and `g` must be the same. The theorem sheds light on the uniqueness property of such ring homomorphisms.

For any type `R` being an instance of a Non-Associative Semiring, there exists at most one ring homomorphism from the integers to `R`.


theorem LieSubmodule.lieSpan_le :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] {s : Set M} {N : LieSubmodule R L M},
      LieSubmodule.lieSpan R L s ≤ N ↔ s ⊆ ↑N :=
  by sorry

The theorem `LieSubmodule.lieSpan_le` states that, for any commutative ring `R`, Lie ring `L`, additively commutative group `M`, with `M` as a module over `R` and as a Lie ring module over `L`, any set `s` of elements of `M`, and any Lie submodule `N` of `M`, the Lie span of `s` is a subset of `N` if and only if `s` is a subset of `N`. This means that the smallest Lie submodule that contains `s` is contained in `N` precisely when `s` itself is contained in `N`.

For any commutative ring R, Lie ring L, additively commutative group M as an R-module and Lie module over L, a set s of elements in the Lie module M, and a Lie submodule N of M, the Lie span of s is contained in N if and only if s is contained in N.


theorem Fin.liftFun_iff_succ :
    ∀ {n : ℕ} {α : Type u_1} (r : α → α → Prop) [inst : IsTrans α r] {f : Fin (n + 1) → α},
      ((fun x x_1 => x < x_1) ⇒ r) f f ↔ ∀ (i : Fin n), r (f (Fin.castSucc i)) (f (Fin.succ i)) :=
  by sorry

The theorem `Fin.liftFun_iff_succ` states that for any natural number `n`, any type `α`, and any relation `r` on `α` that is transitive, if we have a function `f` from `Fin (n + 1)` to `α`, then the property that `f` maintains the order, i.e., `f(x) < f(y)` implies `r(f(x), f(y))`, is equivalent to the property that for all `i` in `Fin n`, `r(f (Fin.castSucc i)) (f (Fin.succ i))` holds. Here, `Fin n` represents the finite set {0, 1, ..., n-1}, `Fin.castSucc i` is embedding of `i` from `Fin n` into `Fin (n+1)`, and `Fin.succ i` provides the successor of `i` in the finite set.

For a transitive relation `r` on type `α` and natural number `n`, a function `f` from `Fin (n+1)` to `α` maintains the order `r` if and only if `r(f (Fin.castSucc i)) (f (Fin.succ i))` holds for all `i` in `Fin n`.


theorem measurable_mul_unop : ∀ {α : Type u_2} [inst : MeasurableSpace α], Measurable MulOpposite.unop := by sorry

The theorem `measurable_mul_unop` asserts that for every type `α` equipped with a `MeasurableSpace` structure, the function `MulOpposite.unop` (which takes an element of the multiplicative opposite of `α` and returns an element of `α`) is measurable. In other words, the preimage of every measurable set under `MulOpposite.unop` is also measurable. This is a statement about the interplay between measure theory and the operation of taking the multiplicative opposite of a type.

For any measurable space `α`, the function `MulOpposite.unop` mapping elements of the multiplicative opposite of `α` to `α` is a measurable function.


theorem AffineSubspace.gc_map_comap :
    ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂),
      GaloisConnection (AffineSubspace.map f) (AffineSubspace.comap f) :=
  by sorry

The theorem `AffineSubspace.gc_map_comap` states that for any type `k` with a ring structure, types `V₁`, `P₁`, `V₂`, `P₂` with respective additive commutative group structures and module structures over `k`, and the types `P₁` and `P₂` further possessing an affine space structure over `V₁` and `V₂` respectively, and for any affine map `f` from `P₁` to `P₂`, there exists a Galois connection between the function `AffineSubspace.map f` and the function `AffineSubspace.comap f`. A Galois connection, in this context, means that for all affine subspaces `a` of `P₁` and `b` of `P₂`, `f` mapping the affine subspace `a` is a subset of `b` if and only if `a` is a subset of `f` reverse-mapped from the subspace `b`.

For any affine spaces `P₁` and `P₂` over a ring `k` with an affine map `f` between them, `AffineSubspace.map f` and `AffineSubspace.comap f` form a Galois connection on affine subspaces of `P₁` and `P₂`.


theorem Finset.sup_const :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β},
      s.Nonempty → ∀ (c : α), (Finset.sup s fun x => c) = c :=
  by sorry

The theorem `Finset.sup_const` states that for any types α and β, given a semilattice structure and a minimal element (order bottom) on α, and a non-empty finite set `s` of type β, the supremum of constant function `c` on this set equals to `c`. In other words, when applied to all elements of a non-empty finite set, the supremum of the constant function is just the constant itself.

For any semilattice α with a minimal element and non-empty finite set β, the supremum of the constant function on β is equal to the constant itself.


/-- A vector is in the same ray as a nonnegative multiple of itself.  -/
theorem SameRay.sameRay_nonneg_smul_right :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {S : Type u_5} [inst_3 : OrderedCommSemiring S] [inst_4 : Algebra S R] [inst_5 : Module S M]
      [inst_6 : SMulPosMono S R] [inst_7 : IsScalarTower S R M] {a : S} (v : M), 0 ≤ a → SameRay R v (a • v) :=
  by sorry

The theorem `SameRay.sameRay_nonneg_smul_right` asserts that for any vector `v`, a nonnegative scalar multiple of `v` is in the 'same ray' as `v` itself. Here, 'same ray' means that two vectors are considered the same if either one of them is zero, or if there exist positive multiples of them that are equal. This property holds in any context where the scalars form a strict ordered commutative semiring and act on a commutative additive monoid to form a module, with the additional structure that the scalar multiplication is positive monotonic and there exists a scalar tower.

For any vector `v` and nonnegative scalar `r`, `r * v` lies on the same ray as `v` in the context of a commutative additive monoid with a positive monotonic scalar multiplication over a strict ordered commutative semiring, where there exists a scalar tower.


theorem NNReal.coe_iSup : ∀ {ι : Sort u_1} (s : ι → NNReal), ↑(⨆ i, s i) = ⨆ i, ↑(s i) := by sorry

This theorem states that for any indexed set of nonnegative real numbers, the supremum of the set (if it exists) when considered as a real number, is equal to the supremum of the set of the corresponding real numbers. In other words, taking supremum doesn't change when we switch between considering the elements of the set as nonnegative real numbers or as real numbers.

For any indexed set of nonnegative real numbers, the supremum of the set as a nonnegative real number equals the supremum of the set considered as a subset of the real numbers.


theorem Stream'.WSeq.destruct_think :
    ∀ {α : Type u} (s : Stream'.WSeq α),
      Stream'.WSeq.destruct (Stream'.WSeq.think s) = Computation.think (Stream'.WSeq.destruct s) :=
  by sorry

The theorem `Stream'.WSeq.destruct_think` states that for any weak sequence `s` of an arbitrary type `α`, the computation action of destructing the weak sequence after one computational tick (done using the `Stream'.WSeq.think` function on `s`) is the same as the computation of destructing `s` delayed by one tick (done using the `Computation.think` function on `Stream'.WSeq.destruct s`). In other words, delaying the computation before or after the destruct action gives the same result.

 For any weak sequence `s` of type `α`, `Stream'.WSeq.think (Stream'.WSeq.destruct s) = Computation.think (Stream'.WSeq.destruct s).`

Or, in mathematical notation:

The computation of destructing a weak sequence `s` after one tick using `Stream'.WSeq.think` is equivalent to destructing `s` with a one-tick delay using `Computation.think`.


theorem LieSubmodule.top_coeSubmodule :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M], ↑⊤ = ⊤ :=
  by sorry

This theorem is about Lie algebras and states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is also a module over `R` and a Lie ring module over `L`, the Lie submodule generated by the entire space (denoted by `⊤`) is equal to the entire space itself. In other words, in the given context, every element of the space is, by definition, in the Lie submodule generated by the entire space.

For any commutative ring `R`, Lie ring `L`, and additive commutative group `M` being an `R`-module and a Lie `L`-module, the Lie submodule generated by `M` equals `M` itself.


theorem Finset.mem_compl :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α} [inst_1 : DecidableEq α] {a : α}, a ∈ sᶜ ↔ a ∉ s := by sorry

The theorem `Finset.mem_compl` states that for any type `α`, given `s`, a finite set of type `α`, and an element `a` of type `α`, `a` belongs to the complement of `s` if and only if `a` does not belong to `s`. This theorem assumes that the type `α` has decidable equality, meaning for any two elements of type `α`, whether they are equal or not can be decided definitively. Furthermore, it assumes that the type `α` is finite, which means there is a finite number of `α` objects.

For any finite type `α` with decidable equality, an element `a` of type `α` belongs to the complement of a finite set `s` if and only if `a` is not in `s`.


theorem Polynomial.degree_lt_degree :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.natDegree p < Polynomial.natDegree q → Polynomial.degree p < Polynomial.degree q :=
  by sorry

This theorem states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the natural degree of `p` is less than the natural degree of `q`, then the degree of `p` is also less than the degree of `q`. The natural degree of a polynomial is defined as the highest power of `X` that appears in the polynomial, or `0` in the case of the zero polynomial. The degree of a polynomial is similarly the highest power of `X` that appears, but is undefined for the zero polynomial.

If `R` is a semiring and `p` and `q` are polynomials over `R` with `deg p < deg q`, then the natural degree of `p` is strictly less than the natural degree of `q`.


theorem Real.continuous_cos : Continuous Real.cos := by sorry

This theorem states that the cosine function on real numbers is continuous. In mathematical terms, it means that for every real number `x` and any positive number `ε`, there exists a positive number `δ` such that for all real numbers `y`, if the absolute difference between `x` and `y` is less than `δ`, then the absolute difference between `cos(x)` and `cos(y)` is less than `ε`. This captures the intuitive notion that small changes in the input of the cosine function lead to small changes in the output.

The cosine function is a continuous function on the real numbers.


theorem Set.mem_Iic : ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, x ∈ Set.Iic b ↔ x ≤ b := by sorry

This theorem, `Set.mem_Iic`, states that for any type `α` that has a preorder, and for any elements `b` and `x` of this type, `x` is an element of the set `Set.Iic b` if and only if `x` is less than or equal to `b`. In other words, it verifies that the set `Set.Iic b` precisely consists of the elements that are less than or equal to `b`.

For any preordered type `α` and elements `b` and `x` of `α`, `x` is in `Set.Iic b` if and only if `x ≤ b`.


theorem AddUnits.continuous_val :
    ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M], Continuous AddUnits.val := by sorry

The theorem `AddUnits.continuous_val` states that for any type `M` that has a topological space structure and an addition monoid structure, the function `AddUnits.val` (which extracts the underlying value from an `AddUnits` object in the base `AddMonoid`) is continuous. In simpler terms, this says that in the context of topological spaces and addition monoids, we can map from `AddUnits` to their underlying values without breaking continuity, i.e., without introducing any gaps or jumps.

The function extracting the underlying value from an `AddUnits` object in a topological space with an addition monoid structure is continuous.


theorem Function.Periodic.sub_int_mul_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℤ), f (x - ↑n * c) = f x :=
  by sorry

The theorem `Function.Periodic.sub_int_mul_eq` states that for any types `α` and `β`, any function `f` from `α` to `β`, any elements `c` and `x` of type `α`, and any instance of `α` as a ring, if the function `f` is periodic with period `c`, then for any integer `n`, the value of the function `f` at the point `x - n*c` is equal to the value of the function at `x`. In simpler terms, it means that for a periodic function, subtracting any integer multiple of the period from the argument doesn't change the value of the function.

For any types `α` and `β`, periodic function `f : α → β` with period `c`, and elements `x : α` and `n : ℤ`, `f (x - n*c) = f x`.


theorem Matrix.transpose_smul :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {R : Type u_10} [inst : SMul R α] (c : R) (M : Matrix m n α),
      Matrix.transpose (c • M) = c • Matrix.transpose M :=
  by sorry

The theorem `Matrix.transpose_smul` states that for all types `m` and `n` denoting the rows and columns of a matrix, type `α` denoting the type of entries in the matrix, and type `R` serving as a scalar under the scalar multiplication operation `SMul`, for any scalar `c` of type `R` and Matrix `M` of type `Matrix m n α`, the transpose of the scalar multiplication of `c` and `M` is equal to the scalar multiplication of `c` and the transpose of `M`. In mathematical terms, this theorem can be represented as $(cM)^T = cM^T$, where `c` is a scalar, `M` is a matrix, `$^T$` denotes transpose, and `cM` denotes scalar multiplication.

The transpose of a matrix multiplied by a scalar is equal to the scalar multiplied by the transpose of the matrix.