theorem Ideal.map_mono :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      {f : F} {I J : Ideal R}, I ≤ J → Ideal.map f I ≤ Ideal.map f J :=
  by sorry

The theorem `Ideal.map_mono` asserts that if we have a function `f` of type `F` that behaves like a function from a semiring `R` to a semiring `S` (expressed as `FunLike F R S`), and if we have two ideals `I` and `J` of the semiring `R` such that `I` is contained in `J` (expressed as `I ≤ J`), then the map of the ideal `I` under `f` is contained in the map of the ideal `J` under `f`. In other words, the action of mapping ideals under `f` preserves the ordering of ideals in the semiring `R`.

If `f : F` is a function between semirings `R` and `S` that maps ideals monotonically, i.e., `I ≤ J` implies `f(I) ≤ f(J)`, then for any ideals `I` and `J` in `R`, `I ≤ J` implies `f(I) ≤ f(J)` in `S`.


theorem Real.cos_pi_over_two_pow : ∀ (n : ℕ), Real.cos (Real.pi / 2 ^ (n + 1)) = Real.sqrtTwoAddSeries 0 n / 2 := by
  sorry

This theorem states that for any natural number `n`, the cosine of `π` divided by `2` to the power of `n + 1` (which is represented in Lean 4 as `Real.cos (Real.pi / 2 ^ (n + 1))`) is equal to the `n`th term of the series `sqrtTwoAddSeries` starting with 0 divided by 2 (`Real.sqrtTwoAddSeries 0 n / 2`). The series `sqrtTwoAddSeries` is defined as `sqrt(2 + sqrt(2 + ... ))` with `n` square roots.

For any natural number `n`, `Real.cos (Real.pi / 2 ^ (n + 1))` equals `Real.sqrtTwoAddSeries 0 n / 2`.


theorem CategoryTheory.GradedObject.mapObj_ext :
    ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C]
      (X : CategoryTheory.GradedObject I C) (p : I → J) [inst_1 : CategoryTheory.GradedObject.HasMap X p] {A : C}
      {j : J} (f g : CategoryTheory.GradedObject.mapObj X p j ⟶ A),
      (∀ (i : I) (hij : p i = j),
          CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj X p i j hij) f =
            CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj X p i j hij) g) →
        f = g :=
  by sorry

This theorem, `CategoryTheory.GradedObject.mapObj_ext`, states that for any `I`, `J` and `C` such that `C` is a category, any `X` being a graded object in `C` indexed by `I`, and any function `p: I → J`, if we have that the coproduct of all `X i` such that `p i = j` exists for all `j: J` and any object `A` in `C` and `j` in `J`, then for any two morphisms `f` and `g` from `CategoryTheory.GradedObject.mapObj X p j` to `A`, if for all `i: I` such that `p i = j`, the composition of `CategoryTheory.GradedObject.ιMapObj X p i j hij` and `f` is equal to the composition of `CategoryTheory.GradedObject.ιMapObj X p i j hij` and `g`, then `f` and `g` must be equal. This theorem encapsulates the idea of uniqueness in the context of category theory, stating that if two morphisms make the same commutative diagrams, they must be the same morphism.

Given any category `C`, a graded object `X` indexed by `I` in `C`, a function `p: I → J`, and objects `A` and morphisms `f` and `g` in `C`, if for all `j: J` the coproduct of `X i` with `p i = j` exists and for all `i: I` such that `p i = j` the diagrams commute: `ιMapObj X p i j (hij ∘ f) = ιMapObj X p i j (hij ∘ g)`, then `f = g`.


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

This theorem, `Nat.ModEq.mul_right`, states that for any natural numbers `n`, `a`, `b`, and `c`, if `a` is congruent to `b` modulo `n` (written as `a ≡ b [MOD n]`), then the product of `a` and `c` is also congruent to the product of `b` and `c` modulo `n` (written as `a * c ≡ b * c [MOD n]`). In other words, if two numbers agree modulo `n`, then their products with any given number also agree modulo `n`.

If `a` is congruent to `b` modulo `n`, then `a * c` is congruent to `b * c` modulo `n` for all natural numbers `c`.


theorem Filter.map₂_map_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : γ → β → δ)
      (n : α → γ), Filter.map₂ m (Filter.map n f) g = Filter.map₂ (fun a b => m (n a) b) f g :=
  by sorry

This theorem, `Filter.map₂_map_left`, states that for any function `m : γ → β → δ`, function `n : α → γ`, and filters `f : Filter α` and `g : Filter β` over the types `α` and `β` respectively, the image of the binary function `m` under the mapping of `n` on `f` and `g` is equal to the image of the binary function `(fun a b => m (n a) b)` under `f` and `g`. Essentially, it presents a property of preserving the binary function image under certain transformations, specifically when the transformation is applied on the left input of the binary function.

For filters `f` over `α` and `g` over `β`, and any function `m : γ → β → δ`, the application of `m` to the images of `n` under `f` and `g` is equal to the application of the function `m . (n × id)` under `f` and `g`. (Here, `n : α → γ`, `id` is the identity function on `β`, and `×` denotes the product type.)


PartialHomeomorph.IsImage.symm

theorem PartialHomeomorph.IsImage.symm :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t → PartialHomeomorph.IsImage (PartialHomeomorph.symm e) t s :=
  by sorry

This theorem states that for any given topological spaces `X` and `Y`, a partial homeomorphism `e` from `X` to `Y`, and two sets `s` in `X` and `t` in `Y`, if `t` is an image of `s` under the partial homeomorphism `e` (formally, `PartialHomeomorph.IsImage e s t` holds), then `s` is also an image of `t` under the inverse of the partial homeomorphism `e` (formally, `PartialHomeomorph.IsImage (PartialHomeomorph.symm e) t s` holds). This means that the property of being an image under a partial homeomorphism is symmetric with respect to the homeomorphism and its inverse.

If a set is an image of another under a partial homeomorphism, then the other set is an image of the first under the partial homeomorphism's inverse.


theorem AddSubgroup.comap_mono :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {K K' : AddSubgroup N},
      K ≤ K' → AddSubgroup.comap f K ≤ AddSubgroup.comap f K' :=
  by sorry

The theorem `AddSubgroup.comap_mono` states that for any given additively written groups `G` and `N`, and a homomorphism `f` from `G` to `N`, if we have an additive subgroup `K` of `N` that is a subset of another additive subgroup `K'` of `N` (i.e., `K ≤ K'`), then the preimage of `K` under `f` is a subset of the preimage of `K'` under `f`. In other words, the mapping of subgroups from `N` back to `G` preserves the subset relationship.

If `f` is a homomorphism from the additively written groups `G` to `N`, and `K` is a subgroup of `K'` in `N`, then `f⁻¹(K) ≤ f⁻¹(K')`.


theorem TopologicalSpace.Opens.compl_compl :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Opens α),
      TopologicalSpace.Closeds.compl (TopologicalSpace.Opens.compl s) = s :=
  by sorry

This theorem states that for every open set `s` in a given topological space, the complement of the complement of `s` is equal to `s` itself. In other words, if you take an open set `s`, find its complement (which is a closed set), and then find the complement of that closed set (which results in an open set), you will end up with the original open set `s`. This corresponds to the general principle in set theory that the complement of the complement of a set is the set itself, but applied specifically to the context of open and closed sets in a topological space.

The complement of the complement of an open set equals the original open set in a topological space.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.5 :
    ∀ {V : Type u} {G : SimpleGraph V} (G' : SimpleGraph.Subgraph G) (v w : V),
      (w ∈ SimpleGraph.Subgraph.neighborSet G' v) = G'.Adj v w :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, any subgraph `G'` of `G`, and any vertices `v` and `w` of type `V`, `w` is in the neighbor set of `v` in subgraph `G'` if and only if `w` is adjacent to `v` in subgraph `G'`. In other words, a vertex `w` is considered a neighbor of a vertex `v` in a subgraph `G'` of a simple graph `G` exactly when there is an edge connecting them in the subgraph `G'`.

In a simple graph `G` of type `V`, a vertex `w` is a neighbor of vertex `v` in subgraph `G'` if and only if there is an edge between `v` and `w` in `G'`.


theorem Set.iUnion_comm :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} (s : ι → ι' → Set α), ⋃ i, ⋃ i', s i i' = ⋃ i', ⋃ i, s i i' := by
  sorry

This theorem, `Set.iUnion_comm`, states that for any type `α`, and any two types of indices `ι` and `ι'`, if `s` is a function that maps pairs of indices `(i, i')` from `ι` and `ι'` respectively to a set of type `α`, then the union over all `i` of the union over all `i'` of `s i i'` is equal to the union over all `i'` of the union over all `i` of `s i i'`. In other words, the order of taking unions does not affect the final result, which mirrors the commutative property in set theory.

For any function `s : ∀ i i', α × α → Set α`, the sets `(⋃ i, ⋃ i' in I × I', s i i')` and `(⋃ i' in I', ⋃ i in I, s i i')` are equal.


theorem star_sum :
    ∀ {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : StarAddMonoid R] {α : Type u_2} (s : Finset α) (f : α → R),
      star (Finset.sum s fun x => f x) = Finset.sum s fun x => star (f x) :=
  by sorry

The theorem `star_sum` states that for any type `R` equipped with both an additive commutative monoid structure and a `StarAddMonoid` structure, and for any finite set `s` of elements of an arbitrary type `α`, the "star" of the sum of the function `f` applied to all elements in `s` is equal to the sum of the "star" of `f` applied to each individual element in `s`. Here, "star" is a unary operation from the `StarAddMonoid` structure on `R` and the sum is computed over the set `s` using the `Finset.sum` function. In mathematical terms, this is similar to saying $\star\left(\sum_{x\in s} f(x)\right) = \sum_{x\in s} \star(f(x))$ for a finite set $s$ and a function $f$ from $s$ to $R$.

For any type `R` with additive commutative monoid and `StarAddMonoid` structures, and finite set `s` of elements from an arbitrary type `α`, the "star" of the sum of `f(x)` for all `x` in `s` equals the sum of the "stars" of `f(x)` for all `x` in `s`. In symbols, $\star\left(\sum\_{x\in s} f(x)\right) = \sum\_{x\in s} \star(f(x))$.


theorem IsGLB.mem_closure :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsGLB s a → Set.Nonempty s → a ∈ closure s :=
  by sorry

This theorem states that for any type `α` that has a topology, a linear order structure, and an order topology, given a set `s` of type `α` and an element `a` of type `α`, if `a` is a greatest lower bound of `s` and `s` is nonempty, then `a` belongs to the closure of `s`. The closure of a set `s` is the smallest closed set containing `s`. This theorem essentially describes a property of the closure of a set in a topological space with a linear order structure.

If a nonempty set `s` in a topological space `α` with a linear order structure has a greatest lower bound `a`, then `a` belongs to the closure of `s`.


MeasureTheory.AECover.superset

theorem MeasureTheory.AECover.superset :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      {φ ψ : ι → Set α},
      MeasureTheory.AECover μ l φ →
        (∀ (i : ι), φ i ⊆ ψ i) → (∀ (i : ι), MeasurableSet (ψ i)) → MeasureTheory.AECover μ l ψ :=
  by sorry

The theorem `MeasureTheory.AECover.superset` states that for any type `α`, index type `ι`, ambient measure space on `α` and a measure `μ` on `α`, given a filter `l` on `ι` and mappings `φ`, `ψ` from `ι` to the set of `α`, if `φ` forms an almost everywhere (a.e.) cover with respect to measure `μ` and filter `l`, and for every element `i` of `ι`, the set corresponding to `i` in `φ` is a subset of the set corresponding to `i` in `ψ`, and each of these `ψ` sets is measurable, then `ψ` also forms an almost everywhere cover with respect to the same measure `μ` and filter `l`.

In mathematical terms, an almost everywhere cover implies that for almost all points, we can find an element in the index such that the point is covered by the corresponding set. This theorem is about preserving this property under taking supersets that are measurable.

If `φ` is an almost everywhere cover of `α` with respect to measure `μ` and filter `l` on index type `ι`, and for all `i ∈ ι`, `φ i` is a subset of `ψ i`, and each `ψ i` is measurable, then `ψ` is also an almost everywhere cover of `α` with respect to `μ` and `l`.


theorem Finset.disjoint_sdiff_inter :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), Disjoint (s \ t) (s ∩ t) := by sorry

This theorem states that for any given type `α` with decidable equality and any two finite sets `s` and `t` of this type, the set difference (denoted by `s \ t`) and the intersection (denoted by `s ∩ t`) of `s` and `t` are disjoint. In other words, there is no element in `α` that can be less than or equal to both the set difference and the intersection of `s` and `t`. Here, the notion of "less than or equal to" is with respect to the partial order defined in the `α` type's lattice structure, and 'disjoint' means that the greatest lower bound (infimum) of the two sets is the bottom element of the lattice.

For any type `α` with decidable equality, the set differences and intersections of two finite sets `s` and `t` in `α` are disjoint with respect to the lattice structure, meaning their infimum is the bottom element.


theorem List.eq_replicate_of_mem :
    ∀ {α : Type u_1} {a : α} {l : List α}, (∀ b ∈ l, b = a) → l = List.replicate (List.length l) a := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, if every element `b` in `l` is equal to `a`, then `l` is equal to a list that consists of the element `a` replicated a number of times equal to the length of `l`. In other words, if all elements in a list are the same, then that list is a replication of that element for as many times as the length of the list.

If `α` is a type, `a : α`, and `l : list α` is such that ∀ b ∈ l, b = a, then l = list.repeat a (length l).


theorem MeasureTheory.measurePreserving_mul_left :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Mul G] [inst_2 : MeasurableMul G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsMulLeftInvariant μ] (g : G),
      MeasureTheory.MeasurePreserving (fun x => g * x) μ μ :=
  by sorry

This theorem states that for any given type `G` that has a multiplicative structure and a measure theory defined on it, if the measure `μ` on the `G` type is left-multiplication invariant, then for any element `g` of type `G`, the function that multiplies `g` to the left of its input is a measure-preserving function with respect to measure `μ`. In mathematical terms, this means that for any `g` in `G`, the mapping `x ↦ g * x` is measure-preserving.

If `μ` is a left-multiplication invariant measure on the multiplicative type `G`, then the left multiplication by any `g` in `G` is a measure-preserving function with respect to `μ`.


theorem Polynomial.degree_cubic_le :
    ∀ {R : Type u} {a b c d : R} [inst : Semiring R],
      Polynomial.degree
          (Polynomial.C a * Polynomial.X ^ 3 + Polynomial.C b * Polynomial.X ^ 2 + Polynomial.C c * Polynomial.X +
            Polynomial.C d) ≤
        3 :=
  by sorry

This theorem states that for any type `R` that forms a semiring and any four elements `a`, `b`, `c`, and `d` of `R`, the degree of the polynomial `aX^3 + bX^2 + cX + d` (where `a`, `b`, `c`, and `d` are coefficients and `X` is the polynomial variable) is less than or equal to 3. In other words, in a cubic polynomial, the highest power of `X` that appears in the polynomial is 3.

The degree of a cubic polynomial `aX^3 + bX^2 + cX + d` over a semiring `R` is bounded by 3, where `a`, `b`, `c`, `d` are elements of `R` and `X` is the polynomial variable.


theorem MulAction.injective₀ :
    ∀ {α : Type u} {β : Type v} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → Function.Injective fun x => a • x :=
  by sorry

The theorem `MulAction.injective₀` states that for all types `α` and `β`, where `α` is a group with zero and `β` is a set on which `α` acts multiplicatively, for any element `a` of `α` that is not zero, the function that maps any element `x` of `β` to the product of `a` and `x` (denoted as `a • x`) is injective. In other words, if `a • x = a • y` then `x` must be equal to `y`. This is applicable for any non-zero element `a` of the group `α`.

For any non-zero element `a` in a group `α` and any sets `β` on which `α` acts multiplicatively, the function `x mapsto a • x` from `β` to itself is injective.


theorem Projectivization.rep_nonzero :
    ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      (v : Projectivization K V), Projectivization.rep v ≠ 0 :=
  by sorry

The theorem `Projectivization.rep_nonzero` states that for any division ring `K` and any additive commutative group `V` that is also a `K`-module, the representative of any element `v` of the projectivization of `V` over `K` (obtained using the `Projectivization.rep` function) is always non-zero. In other words, any point in the projective space corresponds to a non-zero vector in the original vector space `V`.

For any division ring `K` and additive commutative `K`-module `V`, the representation of any point in the projective space of `V` over `K` is a non-zero vector.


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

The theorem `Polynomial.trailingCoeff_eq_zero` states that for any type `R` that is a semiring, and any polynomial `p` with coefficients in `R`, the trailing coefficient of `p` is zero if and only if `p` itself is the zero polynomial. Here, the "trailing coefficient" of a polynomial refers to the coefficient of the smallest power of `X` in the polynomial.

For any semiring `R` and polynomial `p` over `R` in the indeterminate `X`, `p.leadingTerm.coeff = 0` if and only if `p` is the zero polynomial.


Primrec.ofNat

theorem Primrec.ofNat : ∀ (α : Type u_4) [inst : Denumerable α], Primrec (Denumerable.ofNat α) := by sorry

The theorem `Primrec.ofNat` states that for all types `α` that are denumerable (meaning there is a one-to-one correspondence between `α` and the set of natural numbers), the function `Denumerable.ofNat α` is primitive recursive. In other words, given any type that can be paired off with the natural numbers, the function that returns the `n`-th element of `α` indexed by decoding is always a primitive recursive function which can be computed using a basic set of operations and recursion on the natural numbers.

For any denumerable type `α`, the function `Denumerable.ofNat α` encoding its elements as natural numbers is primitive recursive.


theorem Set.Ioo_union_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a < b → Set.Ioo a b ∪ {a} = Set.Ico a b := by sorry

This theorem states that for any partially ordered set `α` and any two elements `a` and `b` from that set such that `a` is less than `b`, the union of the open interval `(a, b)` (i.e., set of all `x` in `α` such that `a < x < b`) and the singleton set containing `a` is equivalent to the closed-open interval `[a, b)` (i.e., set of all `x` in `α` such that `a ≤ x < b`). In set theory notation, this can be expressed as `(a, b) ∪ {a} = [a, b)`.

For any partially ordered set `α` and elements `a < b` in `α`, the sets `(a, b) ∪ {a}` and `[a, b)` are equal.


theorem Function.mulSupport_binop_subset :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst : One M] [inst_1 : One N] [inst_2 : One P]
      (op : M → N → P),
      op 1 1 = 1 →
        ∀ (f : α → M) (g : α → N),
          (Function.mulSupport fun x => op (f x) (g x)) ⊆ Function.mulSupport f ∪ Function.mulSupport g :=
  by sorry

This theorem states that for any types `α`, `M`, `N`, and `P`, (where `M`, `N`, and `P` are types with a defined `One` operation), and a binary operation `op` from `M` and `N` to `P` that preserves the `One` operation (i.e., `op 1 1 = 1`), for any functions `f : α → M` and `g : α → N`, the support of the function `x => op (f x) (g x)` (which is the set of points `x` where this function does not return `1`) is a subset of the union of the supports of `f` and `g`. In other words, if the combined function `op (f x) (g x)` does not return `1` for some `x`, then either `f` or `g` (or both) must not return `1` for that `x`.

For functions `f : α → M` and `g : α → N` with types `M` and `N` having defined `One` operations, and a binary operation `op` from `M` and `N` to `P` preserving the `One` operation, the support of the function `x => op (f x) (g x)` is a subset of the union of the supports of `f` and `g`.


theorem AddLECancellable.add_tsub_cancel_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b : α}, AddLECancellable b → a + b - b = a :=
  by sorry

This theorem, named `AddLECancellable.add_tsub_cancel_right`, states that for any type `α` which has a partial order, is an additive commutative semigroup, has subtraction, and ordered subtraction, if an element `b` in `α` is `AddLECancellable`, then adding `b` to any other element `a` in `α` and then subtracting `b` will just give `a`. In other words, if an element `b` is such that adding `b` to any element `x` preserves the order of `x` (that is, if `a + b ≤ a + c` implies `b ≤ c`), then `a + b - b` equals `a` for any `a`. This is a version of the familiar algebraic law that adding a number and then subtracting the same number leaves the original number unchanged, but in a context where the operations may not behave as they do in standard arithmetic.

If `α` is a type with a partial order, additive commutative semigroup structure, subtraction, and ordered subtraction, and `b` in `α` is AddLECancellable, then `a + b = a + b - b` for all `a` in `α`.


theorem le_sInf_iff :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s : Set α} {a : α}, a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b := by sorry

The theorem `le_sInf_iff` states that for any type `α` which is a complete semilattice with respect to the infimum operation, any set `s` of elements of type `α`, and any element `a` of type `α`, the condition `a` being less than or equal to the infimum of `s` is equivalent to the condition that `a` is less than or equal to every element in `s`. In other words, an element is less than or equal to the greatest lower bound of a set if and only if it is less than or equal to every element in the set.

For any complete semilattice `α` and set `s ∈ α`, an element `a ∈ α` satisfies `a ≤ inf s` if and only if `a ≤ x` for all `x ∈ s`.


Dvd.elim

theorem Dvd.elim : ∀ {α : Type u_1} [inst : Semigroup α] {P : Prop} {a b : α}, a ∣ b → (∀ (c : α), b = a * c → P) → P :=
  by sorry

This theorem, `Dvd.elim`, states that for any type `α` that forms a semigroup, and for any proposition `P`, if a number `a` divides `b`, then for any number `c` such that `b` equals `a` multiplied by `c`, it implies the proposition `P`. Essentially, it allows us to derive a proposition `P` from the fact that `a` divides `b` in the context of a semigroup.

If `α` is a semigroup and `a` divides `b` in `α`, then for any `c` such that `b = a * c`, we have `P`.


theorem finrank_span_le_card :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] (s : Set M) [inst_4 : Fintype ↑s],
      FiniteDimensional.finrank R ↥(Submodule.span R s) ≤ (Set.toFinset s).card :=
  by sorry

The theorem `finrank_span_le_card` states that for any type `R` with a ring structure, any type `M` with an additive commutative group structure and also a `R`-module structure, given the strong rank condition holds for `R`, and a set `s` of `M` with a finiteness condition, the finite rank of the span of set `s` as an `R`-module is less than or equal to the cardinality of the finset formed by enumerating the set `s`. In other words, the dimension of the subspace spanned by a finite set `s` is always less than or equal to the number of elements in `s` in a module over a ring with the strong rank condition.

For any ring `R` with strong rank condition, any additive commutative group `M` with an `R`-module structure, and finite set `s` in `M`, the rank of the submodule generated by `s` is less than or equal to the cardinality of `s`.


theorem Finset.sum_lt_sum_of_nonempty :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelAddCommMonoid M] {f g : ι → M} {s : Finset ι},
      s.Nonempty → (∀ 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_of_nonempty` states that for any ordered cancel-additive commutative monoid `M`, any type `ι`, and any finite set `s` of type `ι`, if `s` is nonempty and for each element `i` in `s` a function `f` applied on `i` is less than a function `g` applied on the same `i`, then the sum of the results of `f` over all elements of `s` is less than the sum of the results of `g` over all elements of `s`. In other words, if we have a nonempty finite set and two functions such that one always outputs smaller values than the other for elements of this set, then the total sum of the smaller values is also less than the total sum of the larger values.

If `M` is an ordered cancel-additive commutative monoid, `ι` is a type, `s` is a nonempty finite set of `ι`, and for all `i` in `s`, `f i < g i`, then `∑ i in s, f i < ∑ i in s, g i`.


theorem List.Perm.append_left :
    ∀ {α : Type u_1} {t₁ t₂ : List α} (l : List α), List.Perm t₁ t₂ → List.Perm (l ++ t₁) (l ++ t₂) := by sorry

This theorem states that for any type `α`, and any lists `t₁`, `t₂`, and `l` of this type, if `t₁` is a permutation of `t₂`, then the list obtained by appending `t₁` to `l` is a permutation of the list obtained by appending `t₂` to `l`. In mathematical terms, if $t₁$ and $t₂$ are permutations of each other, then $l ∘ t₁$ and $l ∘ t₂$ are also permutations of each other, where $∘$ denotes the concatenation of lists.

If `α` is any type and `t₁` and `t₂` are permutations of each other, then the list `l ++ t₁` and `l ++ t₂` are permutations of each other, where `++` denotes list concatenation.


List.Perm.filter

theorem List.Perm.filter :
    ∀ {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α},
      List.Perm l₁ l₂ → List.Perm (List.filter p l₁) (List.filter p l₂) :=
  by sorry

The theorem `List.Perm.filter` states that for any type `α`, predicate function `p` that maps an element of `α` to a Boolean, and any two lists `l₁` and `l₂` of type `α`, if `l₁` and `l₂` are permutations of each other (i.e., they contain the same elements but possibly in a different order), then the lists resulting from filtering `l₁` and `l₂` with the predicate function `p` are also permutations of each other. In other words, rearranging the elements of a list does not affect the outcome of filtering that list with a given predicate.

If two lists `l₁` and `l₂` of the same type `α` are permutations of each other, then the filtered lists `List.filter p l₁` and `List.filter p l₂` are also permutations of each other for any predicate function `p` on `α`.


theorem symmDiff_assoc :
    ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a b c : α),
      symmDiff (symmDiff a b) c = symmDiff a (symmDiff b c) :=
  by sorry

The theorem `symmDiff_assoc` states that for any type `α` which is equipped with the structure of a generalized boolean algebra, the symmetric difference operation `symmDiff` is associative. In other words, for any elements `a`, `b`, and `c` from this type, the symmetric difference of `a` and `b`, when taken the symmetric difference with `c`, is the same as taking the symmetric difference of `a` with the symmetric difference of `b` and `c`. This property can be written mathematically as: `symmDiff (symmDiff a b) c = symmDiff a (symmDiff b c)`.

For any type equipped with a generalized boolean algebra structure, the symmetric difference operation is associative: `symmDiff (a symmetricDiff b) symmetricDiff c = a symmetricDiff (b symmetricDiff c)`.


/-- If `p` is prime, then `cyclotomic p R = ∑ i in range p, X ^ i`.  -/
theorem Polynomial.cyclotomic_prime :
    ∀ (R : Type u_1) [inst : Ring R] (p : ℕ) [hp : Fact (Nat.Prime p)],
      Polynomial.cyclotomic p R = Finset.sum (Finset.range p) fun i => Polynomial.X ^ i :=
  by sorry

The theorem `Polynomial.cyclotomic_prime` states that if `p` is a prime number, then the `p`-th cyclotomic polynomial with coefficients in a ring `R` is equal to the sum of `X` raised to the power `i`, for all `i` in the set of natural numbers less than `p`. Here, `X` represents the polynomial variable. In mathematical terms, it can be written as: for a prime number `p`, the `p`-th cyclotomic polynomial is given by $\sum_{i=0}^{p-1} X^i$.

For a prime number `p`, the `p`-th cyclotomic polynomial equals the sum of `X` raised to the powers from 0 to `p-1`.


AffineBasis.ind

theorem AffineBasis.ind :
    ∀ {ι : Type u_1} {k : Type u_3} {V : Type u_4} {P : Type u_5} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
      [inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P), AffineIndependent k ⇑b :=
  by sorry

The theorem `AffineBasis.ind` states that for any affine basis `b` - which is a function from some type `ι` of indices to points in an affine space `P` over a ring `k` with an associated vector space `V` - the indexed family defined by `b` is affinely independent. In other words, there is no nontrivial linear combination of the points of the basis, where the coefficients sum to zero, which gives the zero vector. The condition of affine independence is crucial in many results in affine geometry and linear algebra.

Given an affine basis `b : ι → P` from an index type `ι` to an affine space `P` over a ring `k` with associated vector space `V`, the family `{b i | i ∈ ι}` is affinely independent.


theorem MonoidWithZeroHom.map_one :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f : α →*₀ β), f 1 = 1 := by
  sorry

This theorem states that for any given `MonoidWithZeroHom` (a homomorphism of monoids with zero), the image under this homomorphism of the unity (or identity) element of the source monoid is equal to the unity element of the target monoid. In simpler terms, this theorem says that if `f` is a function mapping one multiplicative monoid with a zero element to another, then applying `f` to the number one in the first monoid will give you the number one in the second monoid. This is a generalization of the property that the identity element is preserved under a group homomorphism.

For any `MonoidWithZeroHom` homomorphism `f` between monoids with zero, `f (1) = 1`, where `1` represents the identity elements of the respective monoids.


theorem continuousAt_congr :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {x : X}
      {g : X → Y}, f =ᶠ[nhds x] g → (ContinuousAt f x ↔ ContinuousAt g x) :=
  by sorry

This theorem states that for any two functions `f` and `g` from a topological space `X` to another topological space `Y`, if the functions `f` and `g` are locally equal at a point `x` (i.e., `f` equals `g` at every point in a neighborhood of `x`), then the continuity of `f` at `x` is equivalent to the continuity of `g` at `x`. In other words, if two functions agree in a neighborhood of a point, then either both are continuous at that point or both are not.

If two functions between topological spaces are locally equal at a point, then their continuity at that point are equivalent.


PiTensorProduct.lift.tprod

theorem PiTensorProduct.lift.tprod :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
      [inst_2 : (i : ι) → Module R (s i)] {E : Type u_9} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
      {φ : MultilinearMap R s E} (f : (i : ι) → s i), (PiTensorProduct.lift φ) ((PiTensorProduct.tprod R) f) = φ f :=
  by sorry

The theorem `PiTensorProduct.lift.tprod` states that for any index set `ι`, any commutative semiring `R`, any family of types `s : ι → Type` each equipped with an additive commutative monoid structure and an `R`-module structure, and any type `E` equipped with an additive commutative monoid structure and an `R`-module structure, for any multilinear map `φ : MultilinearMap R s E` and any function `f : (i : ι) → s i`, the function `PiTensorProduct.lift φ` applied to the canonical multilinear map `PiTensorProduct.tprod R` of `f`, is equal to `φ` applied to `f`.

In other words, lifting a multilinear map `φ` to the space of tensor products and then applying it to a tensor product of a function `f`, is the same as directly applying `φ` to `f`. This property is crucial in showing the universal property of the tensor product.

For any commutative semiring R, any family s : ι → Type of types with additive commutative monoid and R-module structures, any R-module E with additive commutative monoid structure, any multilinear map φ : R^(s) -> E, and any function f : ι -> s, the maps PiTensorProduct.lift φ (PiTensorProduct.tprod R) and φ applied to f are equal.


/-- **Alias** of `MeasureTheory.AEStronglyMeasurable.mono_ac`. -/
theorem MeasureTheory.AEStronglyMeasurable.mono' :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β},
      MeasureTheory.Measure.AbsolutelyContinuous ν μ →
        MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.AEStronglyMeasurable f ν :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.mono'` states that for any types `α` and `β`, a measurable space `m` on `α`, two measures `μ` and `ν` on `α`, a topological space structure on `β`, and a function `f` from `α` to `β`, if the measure `ν` is absolutely continuous with respect to the measure `μ` (i.e., if for any set `s` such that `μ(s) = 0`, we have `ν(s) = 0`), and if the function `f` is almost everywhere strongly measurable with respect to the measure `μ` (i.e., it is almost everywhere equal to the limit of a sequence of simple functions with respect to the measure `μ`), then `f` is also almost everywhere strongly measurable with respect to the measure `ν`.

If a function between measurable spaces is almost everywhere equal to the limit of simple functions with respect to a measure that is absolutely continuous with respect to another measure, then the function is almost everywhere strongly measurable with respect to the second measure.


theorem Multiset.map_bind :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} (m : Multiset α) (n : α → Multiset β) (f : β → γ),
      Multiset.map f (Multiset.bind m n) = Multiset.bind m fun a => Multiset.map f (n a) :=
  by sorry

The theorem `Multiset.map_bind` asserts that for all types `α`, `β`, and `γ`, and for all multisets `m` of type `α`, functions `n` from `α` to `Multiset β`, and functions `f` from `β` to `γ`, mapping function `f` over the binding of `m` with `n` is equivalent to binding `m` with the function that maps `f` over `n a`. In essence, this theorem encodes a form of the interchange law for multisets, demonstrating that the manner in which we bind and map over multisets can be rearranged without changing the outcome.

For all types `α`, `β`, and `γ`, and for all multisets `m` of type `α`, functions `n : α → Multiset β`, and functions `f : β → γ`, the application of `f` over the binding of `m` with `n` is equivalent to binding `m` with the function that maps `f` over `n`.


theorem cfc_id' :
    ∀ (R : Type u_1) {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R]
      [inst_2 : MetricSpace R] [inst_3 : TopologicalSemiring R] [inst_4 : ContinuousStar R]
      [inst_5 : TopologicalSpace A] [inst_6 : Ring A] [inst_7 : StarRing A] [inst_8 : Algebra R A]
      [inst_9 : ContinuousFunctionalCalculus R p] (a : A), autoParam (p a) _auto✝ → cfc (fun x => x) a = a :=
  by sorry

This theorem, named `cfc_id'`, states that for any type `R` and another type `A` with a property `p`, given multiple conditions - `R` being a Commutative Semiring, a Star Ring, a Metric Space, a Topological Semiring, and having Continuous Star; `A` being a Topological Space, a Ring, and a Star Ring; and `R` and `A` together forming an Algebra with Continuous Functional Calculus for property `p` - for any element `a` of type `A` that satisfies property `p`, the continuous functional calculus of the identity function applied to `a` is `a` itself. This basically means that under these conditions, the continuous functional calculus acts like the identity on elements which satisfy the property `p`. The `autoParam (p a) _auto✝` argument is used for automatic parameter support and does not affect the statement of the theorem in a mathematical sense.

If `R` is a Commutative Semiring, a Star Ring, a Metric Space, a Topological Semiring with Continuous Star, `A` is a Topological Space, a Ring, a Star Ring, and `R` and `A` form an Algebra with Continuous Functional Calculus for property `p`, then for any `a` in `A` satisfying property `p`, the continuous functional calculus of the identity function on `a` equals `a`.


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

This theorem states that for any type `α` that has a multiplication operation, a zero element, a preorder relation, and satisfies the property of strict reverse monotonicity of multiplication by nonnegative elements on the right (denoted as `MulPosReflectLT α`), if the product of `b` and `a` is less than the product of `c` and `a` and `a` is nonnegative (zero or positive), then `b` is less than `c`. In other words, for all nonnegative `a`, if `b * a < c * a`, then `b < c`. This is a manifestation of the characteristic property of order-preserving (or reversing) by multiplication in ordered semirings or related algebraic structures.

For any type `α` with multiplication, zero, preorder relation, and `MulPosReflectLT`, if `a` is nonnegative and `b * a < c * a`, then `b < c`.


theorem pow_bit0' : ∀ {M : Type u} [inst : Monoid M] (a : M) (n : ℕ), a ^ bit0 n = (a * a) ^ n := by sorry

The theorem `pow_bit0'` states that for any type `M` which is equipped with a monoid structure, and for any element `a` of this monoid and natural number `n`, raising `a` to the power of `bit0 n` (where `bit0` is a function that doubles a number) is equal to raising `a * a` to the power of `n`. In mathematical notation, this is saying that $a^{2n} = (a * a)^n$ for `a` in a monoid `M` and `n` a natural number.

For any monoid element `a` and natural number `n`, $(a \cdot a)^n = a^{2n}$.


theorem Cardinal.lift_injective : Function.Injective Cardinal.lift.{u, v} := by sorry

The theorem `Cardinal.lift_injective` asserts that the `lift` operation on cardinals is injective. In other words, if we have two cardinals `a` and `b` such that their lifts (with the same pair of universes `u` and `v`) are equal (i.e., `Cardinal.lift.{u, v} a = Cardinal.lift.{u, v} b`), then the original cardinals `a` and `b` themselves are equal. This property essentially guarantees that the process of lifting a cardinal to a higher universe doesn't conflate distinct cardinals.

If two cardinals have equal lifts in the same universes, then the original cardinals are equal.


theorem ENNReal.toReal_nat : ∀ (n : ℕ), (↑n).toReal = ↑n := by sorry

This theorem states that for every natural number 'n', the real number equivalent of 'n' (obtained by typecasting 'n' to a real number), when converted back to a non-negative real number (ENNReal), remains equal to the original natural number 'n'. In other words, the processes of typecasting a natural number to a real number and then converting it to a non-negative real number do not change the value of the original natural number.

For every natural number n, the conversion of n to an ENNReal and back to a real number equals the original natural number.


theorem NonemptyInterval.toProd_injective :
    ∀ {α : Type u_1} [inst : LE α], Function.Injective NonemptyInterval.toProd := by sorry

The theorem `NonemptyInterval.toProd_injective` states that for all types `α` that have an order relation `≤`, the function `toProd` which maps a non-empty interval of `α` to a pair of `α` values is injective. In other words, if two non-empty intervals in `α` are mapped to the same pair of `α` values by the `toProd` function, then those two non-empty intervals must be identical.

If `α` is a type with an order relation `≤`, then the function `toProd` mapping non-empty intervals of `α` to pairs of `α` values is an injection.


theorem mul_comm_div : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b * c = a * (c / b) := by sorry

This theorem states that for all types `α` that are instances of the division commutative monoid, and for any three elements `a`, `b`, and `c` of the type `α`, the operation of dividing `a` by `b` and then multiplying the result by `c` is equal to the operation of multiplying `a` by the result of dividing `c` by `b`. In mathematical terms, it is expressing the property that $\frac{a}{b} \cdot c = a \cdot \frac{c}{b}$ for all `a`, `b`, `c` in the division commutative monoid.

For all division commutative monoids `α` and elements `a`, `b`, `c` in `α`, we have `(a / b) * c = a * (c / b)`.


theorem Fin.lt_iff_val_lt_val : ∀ {n : ℕ} {a b : Fin n}, a < b ↔ ↑a < ↑b := by sorry

This theorem, `Fin.lt_iff_val_lt_val`, states that for any natural number `n` and two finite sequences `a` and `b` with length `n`, `a` is less than `b` if and only if the value of `a` is less than the value of `b`. Here, `↑a` and `↑b` are the coercion of `a` and `b` to natural numbers, respectively. Thus, the comparison is done in terms of the respective natural number values of `a` and `b`.

For any finite sequences `a` and `b` of natural numbers of length `n`, `a` is less than `b` if and only if the natural numbers `↑a` and `↑b` satisfy `↑a < ↑b`.


theorem MeasureTheory.Measure.ofMeasurable_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {m : (s : Set α) → MeasurableSet s → ENNReal} {m0 : m ∅ ⋯ = 0}
      {mU :
        ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
          Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯}
      (s : Set α) (hs : MeasurableSet s), ↑↑(MeasureTheory.Measure.ofMeasurable m m0 mU) s = m s hs :=
  by sorry

The theorem `MeasureTheory.Measure.ofMeasurable_apply` states that for any type `α` equipped with a measure space and a function `m` that maps measurable sets from `α` to the extended nonnegative real numbers (known as a measure), if this measure of the empty set is zero and the measure is countably additive on pairwise disjoint sets, then for any measurable set `s`, the measure of `s` obtained from the function `m` using `MeasureTheory.Measure.ofMeasurable` equals to the measure `m` of `s`. In other words, the measure of a set obtained by the construction `MeasureTheory.Measure.ofMeasurable` is consistent with the original measure function `m`.

If `m` is a countably additive measure on a measurable space with `m(`empty set`) = 0`, then for any measurable set `s`, `MeasureTheory.Measure.ofMeasurable s = m s`.


theorem List.countP_append :
    ∀ {α : Type u_1} (p : α → Bool) (l₁ l₂ : List α), List.countP p (l₁ ++ l₂) = List.countP p l₁ + List.countP p l₂ :=
  by sorry

This theorem, `List.countP_append`, states that for any type `α`, any function `p` from `α` to `Bool`, and any two lists `l₁` and `l₂` of type `α`, the number of elements in the concatenation of `l₁` and `l₂` that satisfy `p` is equal to the sum of the number of elements in `l₁` that satisfy `p` and the number of elements in `l₂` that satisfy `p`. Essentially, if we split a list into two parts, the total number of elements that satisfy a given condition `p` in the combined list is the same as the sum of the elements satisfying `p` in each of the individual lists.

For any type `α`, function `p` from `α` to `Bool`, and lists `l₁` and `l₂` of type `α`, `List.countP (l₁ ++ l₂) p = List.countP l₁ p + List.countP l₂ p`.


theorem star_inv' : ∀ {R : Type u} [inst : DivisionSemiring R] [inst_1 : StarRing R] (x : R), star x⁻¹ = (star x)⁻¹ :=
  by sorry

This theorem, called `star_inv'`, is applicable to any type `R` that is a division semiring and a star ring. The theorem states that for any element `x` of type `R`, the star operation applied to the inverse of `x` is equivalent to the inverse of the star of `x`. Formally, for all `x` in `R`, `star x⁻¹ = (star x)⁻¹`. The star operation here typically represents the complex conjugate or some form of involution in a star ring.

For any element `x` in a division semiring and star ring `R`, the star of the multiplicative inverse of `x` equals the multiplicative inverse of the star of `x`: `star (x^(-1)) = (star x)^(-1)`.


theorem SmoothManifoldWithCorners.chart_mem_maximalAtlas :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : SmoothManifoldWithCorners I M]
      (x : M), chartAt H x ∈ SmoothManifoldWithCorners.maximalAtlas I M :=
  by sorry

The theorem `SmoothManifoldWithCorners.chart_mem_maximalAtlas` states that for any non-trivially normed field `𝕜`, a normed additive commutative group `E`, a normed space `𝕜 E`, a topological space `H`, a model with corners `I` of `𝕜 E H`, another topological space `M`, a charted space `H M`, and a smooth manifold with corners `I M`, the preferred chart at any point `x` in the manifold `M` is an element of the maximal atlas of this smooth manifold with corners. The maximal atlas is a collection of charts that are smoothly compatible with each other, meaning they can be transformed into each other through a smooth function.

Given a smooth manifold with corners over a non-trivially normed field, any point in the manifold belongs to the preferred chart of some chart in the maximal atlas.


/-- **Alias** of the reverse direction of `Asymptotics.isLittleO_neg_left`. -/
theorem Asymptotics.IsLittleO.neg_left :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {f' : α → E'} {l : Filter α}, f' =o[l] g → (fun x => -f' x) =o[l] g :=
  by sorry

The theorem `Asymptotics.IsLittleO.neg_left` is an alias of the reverse direction of `Asymptotics.isLittleO_neg_left`. This theorem states that, for any types α, F, and E', where F has a norm and E' is a seminormed add commutative group, and for any functions g: α → F and f': α → E', and a filter l on α, if f' is little-o of g according to filter l, then the negation of f' is also little-o of g according to the same filter. This is expressed in Lean as `f' =o[l] g → (fun x => -f' x) =o[l] g`. Here, `=o[l]` denotes the little-o notation at filter l. Little-o notation is used in analysis to describe limiting behavior of functions.

If a function f' is little-o of another function g with respect to a filter l, then the negative of f' is also little-o of g with respect to the same filter.


theorem OrderIso.map_csSup' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] [inst_1 : ConditionallyCompleteLattice β]
      (e : α ≃o β) {s : Set α}, Set.Nonempty s → BddAbove s → e (sSup s) = sSup (⇑e '' s) :=
  by sorry

This theorem states that for any two types `α` and `β` that are both conditionally complete lattices, an order isomorphism `e` from `α` to `β`, and a non-empty set `s` of type `α` that is bounded above, the supremum of `s` under the isomorphism `e` is equal to the supremum of the image of `s` under `e`. In other words, applying an order isomorphism preserves the supremum of a set.

For any conditionally complete lattices `α` and `β`, order isomorphism `e : α ≃ β`, and non-empty bounded-above set `s : α`, the supremum of `s` under `e` equals the supremum of `e(s)` in `β`.


theorem List.filterMap_filterMap :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → Option β) (g : β → Option γ) (l : List α),
      List.filterMap g (List.filterMap f l) = List.filterMap (fun x => Option.bind (f x) g) l :=
  by sorry

The theorem `List.filterMap_filterMap` states that for any types `α`, `β`, and `γ`, and any functions `f : α → Option β`, `g : β → Option γ`, and any list `l` of type `List α`, filtering and mapping the list `l` with `f` first, and then with `g`, is equivalent to filtering and mapping `l` with a function that, given an element `x` of `l`, binds `f(x)` to `g`. This binding is done using the `Option.bind` function, which takes an optional value and a function, and if the optional value is `some a`, applies the function to `a`, resulting in a new optional value.

For any types `α`, `β`, and `γ`, and functions `f : α → Option β` and `g : β → Option γ`, the application of `List.filterMap` with `f` followed by `g` on a list `l` of type `List α` is equivalent to applying `List.filterMap` with the composed function `x ↦ Option.bind (f x) g`.


theorem CategoryTheory.Limits.biproduct.fromSubtype_π :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      (p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] [inst_4 : DecidablePred p]
      (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.fromSubtype f p)
          (CategoryTheory.Limits.biproduct.π f j) =
        if h : p j then CategoryTheory.Limits.biproduct.π (Subtype.restrict p f) { val := j, property := h } else 0 :=
  by sorry

This theorem from the Category Theory in Lean 4 is regarding the composition of morphisms in the context of biproducts. Given the parameters J and C which represent types, a function `f` from J to C, and a decidable predicate `p` on J, if we have a biproduct of `f` and also a biproduct of the function `f` restricted to the subtype defined by `p`, then the composition of the morphism `CategoryTheory.Limits.biproduct.fromSubtype f p` with the projection `CategoryTheory.Limits.biproduct.π f j` is equal to either the projection `CategoryTheory.Limits.biproduct.π (Subtype.restrict p f) { val := j, property := h }` if the predicate `p` holds true for `j` (denoted as `h : p j`) or `0` otherwise. This is essentially stating the relationship between the biproducts of a function and its restriction to a subtype, in terms of their projections.

Given a biproduct of a function `f` and its restriction `Subtype.restrict p f` over a decidable predicate `p` on the domain J, the composition of the morphism from the biproduct of `f` to `f`'s biproduct projection and the biproduct projection of `f`'s restriction is equal to the biproduct projection of `f`'s restriction if `p` holds for the index, and 0 otherwise.


theorem ENNReal.rpow_neg : ∀ (x : ENNReal) (y : ℝ), x ^ (-y) = (x ^ y)⁻¹ := by sorry

The theorem `ENNReal.rpow_neg` states that for any extended nonnegative real number `x` and any real number `y`, the negative power of `x` raised to `y` is equal to the reciprocal of `x` raised to `y`. In mathematical notation, this can be written as `x^(-y) = (x^y)⁻¹`. This theorem is applicable in the context of extended nonnegative real numbers, which is typically used as the codomain of a measure. It provides a mathematical relationship for dealing with negative exponents in this context.

For any extended nonnegative real number x and real number y, x^(-y) = (x^y)⁻¹.


theorem Filter.mem_biInf_of_directed :
    ∀ {α : Type u} {β : Type v} {f : β → Filter α} {s : Set β},
      DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s →
        Set.Nonempty s → ∀ {t : Set α}, t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i :=
  by sorry

The theorem `Filter.mem_biInf_of_directed` states that for all types `α` and `β`, for any function `f` mapping from `β` to a filter on `α`, and a set `s` of type `β`, if this set is directed with respect to the preimage under `f` of the relation "greater than or equal to", and the set `s` is not empty, then for any set `t` of type `α`, `t` belongs to the infimum filter over the set `s` with respect to `f` if and only if there exists an element `i` in `s` such that `t` belongs to the filter `f i`. In simpler terms, this theorem describes a condition under which a set is a member of an infimum filter generated by a directed, nonempty set of filters.

For any type `α` and `β`, if `s` is a nonempty, directed set of filters on `α` with respect to the preimage under a function `f` from `β` to filters on `α`, then a set `t` belongs to the infimum filter of `s` with respect to `f` if and only if there exists an `i` in `s` such that `t` is in `f i`.


theorem Polynomial.coeff_toSubring :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (T : Subring R) (hp : ↑(Polynomial.frange p) ⊆ ↑T) {n : ℕ},
      ↑(Polynomial.coeff (Polynomial.toSubring p T hp) n) = Polynomial.coeff p n :=
  by sorry

This theorem states that for any ring `R`, any polynomial `p` over `R`, any subring `T` of `R` that contains all the coefficients of `p`, and any natural number `n`, the coefficient of `X^n` in the polynomial obtained by mapping `p` to the subring `T` is equal to the coefficient of `X^n` in `p`. In other words, the process of mapping a polynomial to a subring does not change its coefficients.

For any ring `R`, polynomial `p` over `R`, subring `T` of `R` containing `p`'s coefficients, and natural number `n`, the coefficient of `X^n` in the polynomial `p` mapped to `T` equals the coefficient of `X^n` in `p`.


AntisymmRel.symm

theorem AntisymmRel.symm : ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, AntisymmRel r a b → AntisymmRel r b a := by
  sorry

This theorem states that for any type `α` and any relation `r` on `α`, the antisymmetrization of `r` is symmetric. In other words, if `r` is a relation on some type `α` and `a` and `b` are elements of `α` such that `r` holds between `a` and `b` and between `b` and `a` (i.e., the antisymmetrization of `r` holds between `a` and `b`), then the antisymmetrization of `r` also holds between `b` and `a`.

If a relation `r` on type `α` is antisymmetric, then it is symmetric. That is, for all `a` and `b` in `α`, if `r` holds between `a` and `b` and `b` and `a`, then `a` is equal to `b`.


/-- The indexed supremum of two functions are comparable if the functions are pointwise comparable -/
theorem ciSup_mono :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {f g : ι → α},
      BddAbove (Set.range g) → (∀ (x : ι), f x ≤ g x) → iSup f ≤ iSup g :=
  by sorry

This theorem, named `ciSup_mono`, states that for any type `α` with a conditionally complete lattice structure, and any sort `ι`, if you have two functions `f` and `g` from `ι` to `α`, then the supremum of `f` is less than or equal to the supremum of `g` provided that two conditions are satisfied: (1) the set of all values that `g` can take (i.e., the range of `g`) is bounded above, and (2) for every element `x` of type `ι`, the value of `f` at `x` is less than or equal to the value of `g` at `x`. In mathematical terms, if `g` is bounded above and `f(x) ≤ g(x)` for all `x`, then `sup(f) ≤ sup(g)`.

If `α` is a type with a conditionally complete lattice structure, and `f` and `g` are functions from a bounded-above set `ι` to `α` with `f(x) ≤ g(x)` for all `x ∈ ι`, then `sup(f) ≤ sup(g)`.


theorem Submodule.range_mkQ :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M),
      LinearMap.range (Submodule.mkQ p) = ⊤ :=
  by sorry

This theorem states that for any ring `R`, any additive commutative group `M`, and any `R`-module structure on `M`, if `p` is a submodule of `M`, then the range of the linear map from `M` to the quotient of `M` by `p` (denoted as `Submodule.mkQ p`) is the entire quotient module `M/p`. In other words, every element in the quotient module `M/p` can be mapped to by some element in the original module `M` via the `Submodule.mkQ p` linear map.

For any ring `R`, additive commutative group `M`, and `R`-module structure on `M`, the `Submodule.mkQ` linear map from `M` to `M/p` is a surjection, where `p` is a submodule of `M`.


theorem Filter.lift_mono :
    ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Set α → Filter β},
      f₁ ≤ f₂ → g₁ ≤ g₂ → Filter.lift f₁ g₁ ≤ Filter.lift f₂ g₂ :=
  by sorry

The theorem `Filter.lift_mono` states that for any two types `α` and `β`, two filters `f₁` and `f₂` on `α`, and two functions `g₁` and `g₂` from sets of `α` to filters on `β`, if `f₁` is a subset of `f₂` (i.e., `f₁ ≤ f₂`) and `g₁` is a subset of `g₂` (i.e., `g₁ ≤ g₂`), then the filter obtained by lifting `f₁` via `g₁` is a subset of the filter obtained by lifting `f₂` via `g₂`. In other words, the operation of lifting preserves the subset relationship.

Given filters `f₁ ≤ f₂` on type `α` and functions `g₁ : Set α → Filter β` and `g₂ : Set α → Filter β` with `g₁ ≤ g₂`, the lifted filters `Filter.map g₁ f₁` and `Filter.map g₂ f₂` satisfy `Filter.map g₁ f₁ ≤ Filter.map g₂ f₂`.


theorem inv_smul_eq_iff₀ :
    ∀ {α : Type u} {β : Type v} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ {x y : β}, a⁻¹ • x = y ↔ x = a • y :=
  by sorry

This theorem states that for any given types `α` and `β`, where `α` is a group with a multiplicative identity and a multiplicative inverse and zero, and `β` is a set where multiplication by an element of `α` is defined, for every non-zero `a` of type `α` and for all `x` and `y` of type `β`, `a⁻¹` (the multiplicative inverse of `a`) scaled by `x` equals `y` if and only if `x` equals `a` scaled by `y`.

For any group `α` with identity and inverses, and any set `β` with defined multiplication by elements of `α`, the multiplicative inverses `a^{-1}` and `x` are equal if and only if `x` is equal to `a` scaled by `y` for some `y` in `β`.


theorem PartialHomeomorph.trans_assoc :
    ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_5} {Z' : Type u_6} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace Z']
      (e : PartialHomeomorph X Y) (e' : PartialHomeomorph Y Z) (e'' : PartialHomeomorph Z Z'),
      PartialHomeomorph.trans (PartialHomeomorph.trans e e') e'' =
        PartialHomeomorph.trans e (PartialHomeomorph.trans e' e'') :=
  by sorry

This theorem states that for any three topological spaces X, Y, and Z, and a fourth space Z', the composition of partial homeomorphisms is associative. Specifically, given a partial homeomorphism `e` from X to Y, a partial homeomorphism `e'` from Y to Z, and a partial homeomorphism `e''` from Z to Z', the composition of `e` and `e'` followed by `e''` is the same as the composition of `e` with the composition of `e'` and `e''`.

For any partial homeomorphisms `e: X ↔ Y`, `e': Y ↔ Z`, and `e'': Z ↔ Z'`, the composition `(e' ∘ e) ∘ e'' = e ∘ (e' ∘ e'')` holds in the category of topological spaces.


theorem Filter.tendsto_inf_left :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
      Filter.Tendsto f x₁ y → Filter.Tendsto f (x₁ ⊓ x₂) y :=
  by sorry

The theorem `Filter.tendsto_inf_left` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and any filters `x₁`, `x₂` on `α` and `y` on `β`, if the function `f` tends to filter `y` along `x₁`, then `f` also tends to `y` along the infimum (greatest lower bound) of `x₁` and `x₂`. In other words, if `f` maps every neighborhood of `x₁` to a neighborhood in `y`, it will also map every neighborhood of `x₁` intersected with `x₂` to a neighborhood in `y`.

If a function tends to a filter at a point, it also tends to the infimum of two filters at that point.


theorem Cardinal.ord_nat : ∀ (n : ℕ), Cardinal.ord ↑n = ↑n := by sorry

The theorem `Cardinal.ord_nat` states that for all natural numbers `n`, the ordinal corresponding to the cardinal of `n` is equal to `n`. In mathematical terms, it signifies that the cardinality-to-ordinal mapping for natural numbers is the identity function.

The theorem `Cardinal.ord_nat` asserts that the ordinal representation of a natural number equals the number itself.


theorem exists_and_left : ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) ↔ b ∧ ∃ x, p x := by sorry

This theorem, `exists_and_left`, states that for any type `α`, any predicate `p` applied to `α`, and any proposition `b`, the existence of an element of type `α` that satisfies both proposition `b` and predicate `p`, is logically equivalent to the situation where proposition `b` is true and there exists an element of type `α` that satisfies predicate `p`. In other words, the conjunction of a proposition and an existential quantification is commutative.

For any type α, proposition b, and predicate p on α, the existence of an element x : α satisfying p(x) and b is logically equivalent to the existence of an element x : α satisfying p(x) and b is true.


theorem Pretrivialization.mem_source :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} (e : Pretrivialization F proj) {x : Z}, x ∈ e.source ↔ proj x ∈ e.baseSet :=
  by sorry

This theorem is stating that for any types `B`, `F`, and `Z`, with `B` and `F` equipped with a topology, and any function `proj` from `Z` to `B`, for a given `Pretrivialization` `e` of `F` with respect to `proj`, an element `x` of `Z` is in the source of the pretrivialization `e` if and only if the projection of `x` using `proj` is in the base set of the pretrivialization `e`. This theorem relates the source of a pretrivialization with its base set through the projection function.

For any types `B`, `F` with topologies, and a function `proj` from `Z` to `B`, if `e` is a pretrivialization of `F` with respect to `proj`, then `x` is in the source of `e` if and only if `proj(x)` is in the base set of `e`.


theorem Real.Angle.coe_two_pi : ↑(2 * Real.pi) = 0 := by sorry

This theorem states that when you take the number π (which is approximately 3.14159265...), multiply it by 2, and then convert it into the type of angle measurement used in Lean (`Real.Angle`), you get 0. This is consistent with the standard interpretation in mathematics, where an angle of 2π radians equates to a full rotation, or 0 in the modular arithmetic of angles.

The theorem asserts that 2π in radians is equivalent to 0 degrees in Lean's `Real.Angle` type.


theorem Finset.filter_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {p : β → Prop}
      [inst_1 : DecidablePred p],
      Finset.filter p (Finset.image f s) = Finset.image f (Finset.filter (fun a => p (f a)) s) :=
  by sorry

The theorem `Finset.filter_image` states that for any types `α` and `β`, where `β` has decidable equality, and any function `f` from `α` to `β`, a `Finset` `s` of `α`, and a predicate `p` on `β` that is decidable, filtering with `p` on the forward image of `s` under `f` is equal to the forward image under `f` of the filter of `s` based on the predicate `(fun a => p (f a))`. In other words, the order of filtering and applying the function doesn't matter, you can first filter the elements according to the predicate and then apply the function, or first apply the function and then filter the results.

For any type `α`, type `β` with decidable equality, function `f` from `α` to `β`, decidable predicate `p` on `β`, and `Finset` `s` of `α`, the filtered images of `s` under `f` and `p` commute: `(filter p (map f s)) = (map f (filter (λ a, p (f a)) s))`.


theorem map_wittPolynomial :
    ∀ (p : ℕ) {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] (f : R →+* S) (n : ℕ),
      (MvPolynomial.map f) (wittPolynomial p R n) = wittPolynomial p S n :=
  by sorry

The theorem `map_wittPolynomial` states that for any natural number `p`, and for any types `R` and `S` that form commutative rings, if we have a ring homomorphism `f` from `R` to `S`, then for any natural number `n`, the result of applying the map function to the `n`-th Witt polynomial (with coefficients in `R` and respect to `p`) is equal to the `n`-th Witt polynomial (with coefficients in `S` and respect to `p`). In simpler terms, the `n`-th Witt polynomial is preserved under the map from the ring `R` to the ring `S`.

For any commutative rings R and S, any natural number n, and any ring homomorphism f from R to S, the image under f of the n-th Witt polynomial with coefficients in R and respect to some prime p is equal to the n-th Witt polynomial with coefficients in S and respect to the same prime p.


theorem bot_ne_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : Nontrivial α], ⊥ ≠ ⊤ :=
  by sorry

This theorem, `bot_ne_top`, states that for any type `α` that is a `PartialOrder` and a `BoundedOrder` and is nontrivial (meaning there are at least two distinct elements in `α`), the bottom element `⊥` (the least element in the set) is not equal to the top element `⊤` (the greatest element in the set). In plain English, in any nontrivial partially ordered set that has both a smallest and a largest element, the smallest and largest elements are not the same.

In any nontrivial partially ordered set with a least (bottom) and greatest (top) element, the least and greatest elements are distinct.


theorem CategoryTheory.Arrow.hom_ext :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y : CategoryTheory.Arrow T} (f g : X ⟶ Y),
      f.left = g.left → f.right = g.right → f = g :=
  by sorry

The theorem `CategoryTheory.Arrow.hom_ext` states that for any category `T`, and any two objects `X` and `Y` in the arrow category of `T`, if we have two morphisms `f` and `g` from `X` to `Y`, then `f` equals `g` if and only if the `left` component of `f` equals the `left` component of `g` and the `right` component of `f` equals the `right` component of `g`. In other words, two morphisms in the arrow category are considered identical if their corresponding parts are identical.

In the arrow category of a category T, two morphisms from object X to object Y are equal if and only if their source and target components are equal.


theorem MeasureTheory.MeasurePreserving.skew_product :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {δ : Type u_7} [inst_3 : MeasurableSpace δ] {μa : MeasureTheory.Measure α}
      {μb : MeasureTheory.Measure β} {μc : MeasureTheory.Measure γ} {μd : MeasureTheory.Measure δ}
      [inst_4 : MeasureTheory.SFinite μa] [inst_5 : MeasureTheory.SFinite μc] {f : α → β},
      MeasureTheory.MeasurePreserving f μa μb →
        ∀ {g : α → γ → δ},
          Measurable (Function.uncurry g) →
            (∀ᵐ (x : α) ∂μa, MeasureTheory.Measure.map (g x) μc = μd) →
              MeasureTheory.MeasurePreserving (fun p => (f p.1, g p.1 p.2)) (MeasureTheory.Measure.prod μa μc)
                (MeasureTheory.Measure.prod μb μd) :=
  by sorry

This theorem, named `MeasureTheory.MeasurePreserving.skew_product`, states the following: for every measurable spaces `α`, `β`, `γ`, `δ` and measures `μa` on `α`, `μb` on `β`, `μc` on `γ`, `μd` on `δ`, where `μa` and `μc` are sigma-finite, and every function `f` from `α` to `β`, if `f` preserves the measure `μa` to `μb`, then for every function `g` from `α → γ` to `δ` that is measurable when uncurried, if almost every `x` in `α` with respect to measure `μa` maps to a measure `μd` under the function `g x`, then the function that maps a pair `p` to `(f p.1, g p.1 p.2)` preserves the product measure `μa × μc` to the product measure `μb × μd`. In essence, under these conditions, the "skew product" of `f` and `g` preserves the product measure from `α × γ` to `β × δ`.

If `α`, `β`, `γ`, `δ` are measurable spaces, `μa` and `μc` are sigma-finite measures on `α` and `γ` respectively, `f: α → β` is measure-preserving for `μa` and `μb`, and `g: α → δ` is a measurable function such that almost every `x` in `α` maps to a non-zero measure under `μd` when applying `g` with respect to `μa`, then the function `(f, g): α × γ → β × δ`, defined by `(f, g)(p) = (f p.1, g p.1 p.2)`, preserves the product measures `μa × μc` and `μb × μd`.


/-- `(n + 1).ascFactorial k = (n + k) ! / n !` but without ℕ-division. See
`Nat.ascFactorial_eq_div` for the version with ℕ-division.  -/
theorem Nat.factorial_mul_ascFactorial :
    ∀ (n k : ℕ), Nat.factorial n * Nat.ascFactorial (n + 1) k = Nat.factorial (n + k) := by sorry

The theorem `Nat.factorial_mul_ascFactorial` states that for any two natural numbers `n` and `k`, the factorial of `n` times the ascending factorial of `n + 1` to `k` is equal to the factorial of `n + k`. Here, the ascending factorial is the product of consecutive natural numbers starting from `n + 1` and ending at `n + k - 1`. Note that this statement does not involve the concept of division in the natural numbers. A corresponding theorem `Nat.ascFactorial_eq_div` contains a similar equation using natural number division.


theorem Mathlib.Data.Sum.Order._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a b : β}, (Sum.inr a ≤ Sum.inr b) = (a ≤ b) := by
  sorry

The theorem `Mathlib.Data.Sum.Order._auxLemma.2` states that for any types `α` and `β` where `α` and `β` have a less than or equal to (`≤`) relation defined on them, and for any elements `a` and `b` of type `β`, the statement that `a` is less than or equal to `b` within the `Sum.inr` context (i.e., `Sum.inr a ≤ Sum.inr b`) is equivalent to the statement that `a` is less than or equal to `b` without the `Sum.inr` context (i.e., `a ≤ b`). In other words, wrapping `a` and `b` in `Sum.inr` doesn't change their comparison outcome.

For any types `α` with a defined `≤` relation and elements `a` and `b` of type `β`, `Sum.inr a ≤ Sum.inr b` if and only if `a ≤ b`.


theorem Mathlib.Data.Sum.Order._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a b : α}, (Sum.inl a ≤ Sum.inl b) = (a ≤ b) := by
  sorry

This theorem, `Mathlib.Data.Sum.Order._auxLemma.1`, states that for any two types `α` and `β`, both of which have a less than or equal to (`≤`) operation, and for any two elements `a` and `b` of type `α`, the condition that `a` is less than or equal to `b` under the `Sum.inl` operation is equivalent to the condition that `a` is less than or equal to `b`. In other words, the ordering of the elements `a` and `b` remains the same whether we're considering them as elements of type `α` or as elements of the co-product type `α + β`.

For any types `α` and `β` with a `≤` operation, and for all `a : α` and `b : α`, `a ≤ a + b` if and only if `a ≤ b`.


theorem Multiset.mem_ndunion :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α} {a : α}, a ∈ Multiset.ndunion s t ↔ a ∈ s ∨ a ∈ t := by
  sorry

This theorem states that for any type `α` with decidable equality and any elements `s`, `t` of type `Multiset α`, and any element `a` of type `α`, `a` is a member of the non-duplicate union of `s` and `t` if and only if `a` is a member of `s` or `a` is a member of `t`. This non-duplicate union operation, `Multiset.ndunion`, is a union operation on multisets that does not take into account multiplicities of elements. In other words, an element is included in the union set regardless of how many times it appears in the original sets.

For any type `α` with decidable equality, and `s`, `t` multisets of `α`, an element `a` is in the non-duplicate union `s ∪_\_ t` if and only if it is in `s` or in `t`.


theorem ENNReal.toReal_inv : ∀ (a : ENNReal), a⁻¹.toReal = a.toReal⁻¹ := by sorry

This theorem states that for every extended nonnegative real number `a`, the real number obtained by taking the reciprocal of `a` and then converting to a real number (using the `toReal` function) is the same as first converting `a` to a real number and then taking its reciprocal. In mathematical terms, for all `a` in the extended nonnegative real numbers (usually denoted as [0, ∞]), the operation of taking the reciprocal commutes with the operation of converting to a real number.

For all extended nonnegative real numbers `a`, the conversion of `a` to a real number and taking its reciprocal is equal to taking the reciprocal of `a` and then converting it to a real number.


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

This theorem states that for any metric space γ and any two points x and y in γ, the distance between x and y is less than or equal to 0 if and only if x and y are the same point. In other words, in any metric space, the only way for the distance between two points to be non-positive (i.e., zero or less) is if the two points are identical.

In any metric space, the distance between two points is non-positive if and only if they are equal.


theorem ModelWithCorners.range_eq_univ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
      [inst_4 : ModelWithCorners.Boundaryless I], Set.range ↑I = Set.univ :=
  by sorry

The theorem `ModelWithCorners.range_eq_univ` states that for any non-trivial normed field `𝕜`, normed additive commutative group `E`, and topological space `H`, if `I` is a model with corners (a mathematical object used to represent a coordinate system in differential geometry) on `𝕜`, `E`, and `H` such that `I` does not have a boundary (represented by `ModelWithCorners.Boundaryless I`), then the range of `I` (i.e., the set of all possible values that `I` can take) is the entire set `Set.univ` (i.e., the set of all elements in the type). In other words, every possible value in the type of `I` can be achieved by `I` under these conditions.

If `I` is a boundaryless model with corners on a non-trivial normed field, normed additive commutative group, and topological space, then the range of `I` equals the universe set.


theorem Ordinal.lsub_typein : ∀ (o : Ordinal.{u}), Ordinal.lsub (Ordinal.typein fun x x_1 => x < x_1) = o := by sorry

The theorem `Ordinal.lsub_typein` states that for any ordinal `o`, the least strict upper bound (lsub) of the order type function (i.e., `Ordinal.typein`) applied to the less-than relation over its elements is equal to `o` itself. This essentially means that the least upper bound of the order types of all elements, when considered within a well-order, is the ordinal representing the well-order itself.

For any ordinal `o`, the least upper bound of the order types of elements in `o` is equal to `o`.


theorem ENNReal.tendsto_toNNReal :
    ∀ {a : ENNReal}, a ≠ ⊤ → Filter.Tendsto ENNReal.toNNReal (nhds a) (nhds a.toNNReal) := by sorry

This theorem, `ENNReal.tendsto_toNNReal`, states that for all extended nonnegative real numbers `a` that are not infinity, the function `ENNReal.toNNReal`, which takes an extended nonnegative real number and returns a nonnegative real number (or 0 if `a` is not a real number), has a limit at `a`. More specifically, for every neighborhood of `a.toNNReal`, the preimage under `ENNReal.toNNReal` of this neighborhood is a neighborhood of `a`. In other words, `ENNReal.toNNReal` is continuous at `a` in the topology of the extended nonnegative real numbers.

The function `ENNReal.toNNReal` from extended nonnegative real numbers to nonnegative real numbers is continuous at every finite extended nonnegative real number.


theorem Ordinal.cof_zero : Ordinal.cof 0 = 0 := by sorry

The theorem `Ordinal.cof_zero` states that the cofinality of the ordinal 0 is 0. In other words, the smallest cardinality of a subset of the ordinal 0 which is unbounded, where an unbounded subset is one for which every element of the ordinal has an equal or larger element in the subset, is 0. This aligns with the general definition of cofinality, considering the special case where the ordinal is 0.


theorem Quaternion.normSq_coe : ∀ {R : Type u_3} [inst : CommRing R] (x : R), Quaternion.normSq ↑x = x ^ 2 := by sorry

This theorem states that for any type `R` that forms a commutative ring, the square of the norm of the quaternion formed by taking the "coercion" (or type conversion) of a value `x` from `R` is equal to the square of `x`. In other words, when we convert a number from the ring `R` to a quaternion and calculate the square of its norm, we get the same result as squaring the original number in `R`.

For any commutative ring `R` and any `x` in `R`, the square of the norm of the quaternion obtained by coercing `x` equals `x`'s square in `R`.


theorem Finset.prod_coe_sort :
    ∀ {α : Type u_3} {β : Type u_4} (s : Finset α) (f : α → β) [inst : CommMonoid β],
      (Finset.prod Finset.univ fun i => f ↑i) = Finset.prod s fun i => f i :=
  by sorry

The theorem `Finset.prod_coe_sort` states that for any type `α`, a finite set `s` of type `α`, a function `f` from `α` to another type `β`, and given a commutative monoid structure on `β`, the product of `f` applied to the elements of the universal finite set of type `Finset α` (when those elements are treated as elements of `α` using type coercion) is equal to the product of `f` applied to the elements of set `s`. This theorem establishes the equality of these two products, where the product of a function over a set is defined as the product of the function values for all elements in the set.

For any commutative monoid-valued function `f` and finite set `s` of type `α`, the product of `f` applied to the elements of the universal finite set of type `Finset α` (treated as `α` elements) equals the product of `f` applied to the elements of set `s`.


theorem DirectSum.of_natCast :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
      [inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] (n : ℕ), (DirectSum.of A 0) ↑n = ↑n :=
  by sorry

The theorem `DirectSum.of_natCast` states that for any type `ι` with a decidable equality and a natural number `n`, the operation of casting `n` to the direct sum and then applying the direct sum function `DirectSum.of` at 0, results in the same value as just directly casting `n`. This is under the conditions that `A` is a function from `ι` to some type, where each element in the range of `A` forms an additive commutative monoid, `ι` forms an additive monoid, and `A` forms a grade-semiring.

For any decidably equal type `ι` and natural number `n`, the operation of casting `n` to the direct sum of a grade-semiring `A` from `ι` and then applying `DirectSum.of` at 0 is equivalent to directly casting `n` to the direct sum of `A`.


theorem Submonoid.LocalizationMap.sec_spec' :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      {f : Submonoid.LocalizationMap S N} (z : N),
      (Submonoid.LocalizationMap.toMap f) (Submonoid.LocalizationMap.sec f z).1 =
        (Submonoid.LocalizationMap.toMap f) ↑(Submonoid.LocalizationMap.sec f z).2 * z :=
  by sorry

The theorem `Submonoid.LocalizationMap.sec_spec'` states that for any types `M` and `N` that form commutative monoids, given a submonoid `S` of `M`, and a localization map `f` from `S` to `N`, for any element `z` of `N`, the value of the localization map `f` at the first component of `f.sec z` equals the product of the value of `f` at the "coerced" second component of `f.sec z` and `z`. In other words, if `(x, y)` is a pair such that `f x * (f y)⁻¹ = z` (which is the role of the `sec` function), then `f(x) = f(y) * z`.

For any commutative monoids M and N, submonoid S of M, and localization map f from S to N, if x and y are in S with f(x) * f(y)^-1 = z, then f(x) = f(y) * z.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.51 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      (0 < a - b) = (b < a) :=
  by sorry

The theorem `Mathlib.Algebra.Order.Group.Defs._auxLemma.51` states that for any type `α` that forms an additive group and has an order relation, and for which adding elements is a covariant operation with respect to the order, the statement "zero is less than the difference of `a` and `b`" is equivalent to the statement "`b` is less than `a`". In more mathematical terms, this theorem says that for all `a` and `b` in `α`, `0 < a - b` if and only if `b < a`.

For an additive group type `α` with covariant addition and order relation, `0 < a - b` if and only if `b < a`.


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

The theorem `strictAnti_mul_left` states that for any type `α` which has a strictly ordered semiring structure and supports the existence of addition for less than or equal elements, if `a` is a negative element of this type `α`, then the function that multiplies `a` by a variable `x` is strictly antitone. In other words, given any two elements `b` and `c` of type `α` where `b < c`, multiplying `a` by `c` will yield a value less than the result of multiplying `a` by `b`.

For any strictly ordered semiring type `α` with additive order and negative element `a`, the function `x => a * x` is strictly decreasing on the positive part of `α`.


theorem TypeVec.id_comp :
    ∀ {n : ℕ} {α : TypeVec.{u_1} n} {β : TypeVec.{u_2} n} (f : TypeVec.Arrow α β), TypeVec.comp TypeVec.id f = f := by
  sorry

The theorem `TypeVec.id_comp` states that for any natural number `n`, and any two `n`-tuples of types `α` and `β`, the composition of the identity function `TypeVec.id` and any function `f` from `α` to `β` (`TypeVec.Arrow α β`) is equal to the function `f` itself. This is the mathematical equivalent of the identity law for function composition, which in formula terms can be expressed as: `Id ∘ f = f`, where `Id` is the identity function and `f` is any function from `α` to `β`.

For any natural number `n` and functions `f : αᵢ → βёрiginal subscript i = 1,…,n`, `TypeVec.id_comp αβ n f` is the equality of functions `TypeVec.id αᵢ αᵢ ∘ f αᵢ βoriginal subscript i = 1,…,n` and `f αᵢ βoriginal subscript i = 1,…,n`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.10 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, (0 < -a) = (a < 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Group.Defs._auxLemma.10`, states that for any type `α` that forms an additive group, is ordered, and satisfies the covariant property, the inequality `0 < -a` is equivalent to `a < 0` for any element `a` of `α`. In other words, a number `a` is negative if and only if `-a` is positive in this context.

For any additive group α that is ordered and satisfies the covariant property, the inequality -a < 0 is equivalent to a > 0.


theorem gc_lowerClosure_coe : ∀ {α : Type u_1} [inst : Preorder α], GaloisConnection lowerClosure SetLike.coe := by
  sorry

This theorem states that for any type `α` which has a `Preorder` structure, there exists a Galois connection between the function `lowerClosure` and the function `SetLike.coe`. In other words, for every `a` in `α` and `b` in the set of lower sets, `lowerClosure a` is less than or equal to `b` if and only if `a` is less than or equal to `SetLike.coe b`. In terms of lattice theory, this is stating that the function which maps a set to the least lower set containing it and the function that maps a lower set to its corresponding set form a Galois connection.

For any type `α` with a `Preorder` structure, the functions `lowerClosure` and `SetLike.coe` define a Galois connection.


theorem Submodule.fg_bot :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Submodule.FG ⊥ :=
  by sorry

This theorem states that, for any semiring `R` and any additive commutative monoid `M` that is also a module over `R`, the bottom submodule (denoted by `⊥`) is finitely generated. In other words, there exists a finite subset of `M` such that the span of this subset equals the bottom submodule.

Given a semiring `R` and an additive commutative `R`-module `M`, the bottom submodule `⊥` is finitely generated.


theorem SetLike.exists_of_lt : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p < q → ∃ x ∈ q, x ∉ p := by
  sorry

This theorem states that for any two types `A` and `B`, if `A` is a set-like structure of `B`, and `p` and `q` are elements of `A` such that `p` is less than `q`, then there exists an element `x` that belongs to `q` but does not belong to `p`. In other words, if `A` is a set-like structure and one element of this structure is strictly smaller than another, there must be at least one member in the larger element that is not in the smaller one.

For any set-like structure `A` of type `B` in Lean 4, if `p` and `q` are elements of `A` with `p` strictly contained in `q`, then there exists an element `x` in `q` not in `p`.


/-- Fundamental theorem of calculus-2: If `f : ℝ → E` has a derivative at `f' x` for all `x` in
`[a, b]` and `f'` is integrable on `[a, b]`, then `∫ y in a..b, f' y` equals `f b - f a`.  -/
theorem intervalIntegral.integral_eq_sub_of_hasDerivAt :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f f' : ℝ → E}
      {a b : ℝ},
      (∀ x ∈ Set.uIcc a b, HasDerivAt f (f' x) x) →
        IntervalIntegrable f' MeasureTheory.volume a b → ∫ (y : ℝ) in a..b, f' y = f b - f a :=
  by sorry

This is a formulation of the Fundamental Theorem of Calculus, Part 2. The theorem states that if a function `f : ℝ → E` has a derivative at every point in the closed interval `[a, b]` and this derivative function `f'` is interval integrable on `[a, b]`, then the integral of `f'` on the interval from `a` to `b` is equal to the difference `f(b) - f(a)`. Here, `E` is a complete normed space over the real numbers (`ℝ`). This theorem connects the concept of differentiability and integrability, showing that the integral of the derivative recovers the original function (up to a constant).

If a real-valued function `f` on a closed interval `[a, b]` is differentiable with integrable derivative, then the integral of `f'` over `[a, b]` equals `f(b) - f(a)`.


theorem Mathlib.ModelTheory.Algebra.Ring.Basic._auxLemma.2 :
    ∀ {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}, (∀ (x : (i : Fin 0) → α i), P x) = P finZeroElim := by
  sorry

This theorem, named `Mathlib.ModelTheory.Algebra.Ring.Basic._auxLemma.2`, states that for any dependent type `α` indexed by `Fin 0` (the type representing the empty set) and for any property `P` that holds for any function from `Fin 0` to `α`, asserting that `P` holds for all such functions is equivalent to asserting that `P` holds for the specific function `finZeroElim`. The function `finZeroElim` is an elimination principle for `Fin 0`, meaning it is a function from `Fin 0` to any type which is inevitably the empty function, as `Fin 0` has no elements.

For any property `P` and dependent type `α` indexed by `Fin 0`, asserting that `P` holds for all functions from `Fin 0` to `α` is equivalent to asserting that `P` holds for the empty function `finZeroElim` from `Fin 0` to `α`.


theorem Complex.equivRealProd_symm_apply : ∀ (p : ℝ × ℝ), Complex.equivRealProd.symm p = ↑p.1 + ↑p.2 * Complex.I := by
  sorry

This theorem states that for every pair of real numbers `p`, the inverse function of the equivalence between the complex numbers and the real numbers product, applied to `p`, equals the first element of `p` (treated as a complex number) plus the second element of `p` (also treated as a complex number) multiplied by the imaginary unit. In mathematical terms, for all `(a, b) ∈ ℝ × ℝ`, this function maps `(a, b)` to `a + b * i`, where `i` is the imaginary unit.

For every real number pair `(a, b)`, the function mapping `(a, b)` to `a + b*i` (where `i` is the imaginary unit) holds true in the equivalence between complex and real numbers.


theorem ZNum.cast_to_int : ∀ {α : Type u_1} [inst : AddGroupWithOne α] (n : ZNum), ↑↑n = ↑n := by sorry

This theorem states that, for every type `α` (which must be an instance of an additive group with a multiplicative identity), the double cast of a ZNum `n` to `α` is equal to the single cast of `n` to `α`. In other words, the double application of the coercion function (cast operation) to `n` does not change the result from the single application of the coercion function.

For any additive group type `α`, the double coercion of a ZNum `n` to `α` equals the single coercion of `n` to `α`.


theorem smul_eq_zero_iff_eq :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : AddMonoid β] [inst_2 : DistribMulAction α β] (a : α) {x : β},
      a • x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any group `α`, add monoid `β`, and a distributive multiplication action of `α` on `β`, for any element `a` of `α` and any element `x` of `β`, the scalar multiplication of `a` and `x` equals zero if and only if `x` equals zero. Here, the scalar multiplication of `a` and `x` is represented as `a • x`. In other words, the only way for a scalar multiplication to yield zero in this context is when the element `x` from the add monoid is zero.

For any group action by add monoid multiplication on an add monoid, the scalar multiplication of an element by another equals zero if and only if the second element is the additive identity.


theorem Filter.not_neBot : ∀ {α : Type u} {f : Filter α}, ¬Filter.NeBot f ↔ f = ⊥ := by sorry

This theorem states that for every given type `α` and a filter `f` of that type, the filter `f` is not 'neBot' if and only if `f` is the bottom filter (notated as `⊥`). In other words, a filter `f` is not 'neBot' (not apart from the bottom filter) precisely when `f` itself is the bottom filter. This is a characteristic property of the bottom filter in the filter theory.

A filter is not the negation of the bottom filter if and only if it is the bottom filter itself.


theorem zpow_nonneg : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 ≤ a → ∀ (n : ℤ), 0 ≤ a ^ n := by
  sorry

This theorem states that for any type `α` which forms a linear ordered semifield, any non-negative number `a` of type `α`, raised to any integer power `n`, is always non-negative. In mathematical terms, this could be written as: for any non-negative α, 0 ≤ a, and any integer n, we have 0 ≤ a^n.

For any non-negative element $a$ in a linear ordered semifield $\alpha$, $a$ raised to any integer power $n$ is also non-negative. In mathematical notation: $0 \leq a \implies 0 \leq a^n$.


theorem OrderIso.isLUB_preimage :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set β} {x : α},
      IsLUB (⇑f ⁻¹' s) x ↔ IsLUB s (f x) :=
  by sorry

The theorem `OrderIso.isLUB_preimage` states that for any types `α` and `β` with preorder structures, any order isomorphism `f` from `α` to `β`, any set `s` of type `β`, and any element `x` of type `α`, `x` is a least upper bound of the preimage of `s` under `f` if and only if `f(x)` is a least upper bound of `s`. This theorem essentially asserts the preservation of least upper bounds under order isomorphisms.

For any preorders on types `α` and `β`, order isomorphism `f` from `α` to `β`, set `s` in `β`, and element `x` in `α`, if `x` is the least upper bound of `f''{s} (the preimage of `s` under `f`) then `f(x)` is the least upper bound of `s`.


theorem Filter.tendsto_const_pure :
    ∀ {α : Type u} {β : Type v} {a : Filter α} {b : β}, Filter.Tendsto (fun x => b) a (pure b) := by sorry

The theorem `Filter.tendsto_const_pure` states that for all types `α` and `β`, given a filter `a` on the type `α`, and an element `b` of type `β`, the constant function that maps every element of `α` to `b` tends to the pure filter at `b` under the filter `a`. In other words, for every neighborhood of `b` in the codomain, its preimage under the constant function is a neighborhood of `a` in the domain.

For any filter `a` on type `α` and any element `b` of type `β`, the constant function from `α` to `β` maps `a` to the pure filter at `b`.


/-- **Alias** of the reverse direction of `Set.Finite.toFinset_subset_toFinset`. -/
theorem Set.Finite.toFinset_mono :
    ∀ {α : Type u} {s t : Set α} {hs : Set.Finite s} {ht : Set.Finite t},
      s ⊆ t → Set.Finite.toFinset hs ⊆ Set.Finite.toFinset ht :=
  by sorry

The theorem `Set.Finite.toFinset_mono` states that for any two sets `s` and `t` of some type `α`, if `s` is a subset of `t` and both `s` and `t` are finite sets, then the finite set representation (`Finset`) of `s` is a subset of the finite set representation of `t`. In other words, the process of converting a finite set to the `Finset` data type preserves subset relationships.

If `s` is a finite subset of `t`, then the `Finset` representations `Finset.univ s` and `Finset.univ t` satisfy `Finset.subset (Finset.univ s) (Finset.univ t)`.


theorem Algebra.IsIntegral.of_finite :
    ∀ (R : Type u_1) (B : Type u_3) [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B]
      [inst_3 : Module.Finite R B], Algebra.IsIntegral R B :=
  by sorry

The theorem `Algebra.IsIntegral.of_finite` states that for any commutative ring `R` and any ring `B`, where `B` is an `R`-algebra and is also a finite `R`-module, every element of `B` is integral over `R`. In other words, if `B` is a finite extension of `R` as an algebra, then every element in `B` satisfies a monic polynomial equation with coefficients in `R` (which is the definition of being "integral").

If `R` is a commutative ring and `B` is an `R`-algebra that is also a finite `R`-module, then every element in `B` is integral over `R`.


/-- All points have distance from the circumcenter equal to the
circumradius.  -/
theorem Affine.Simplex.dist_circumcenter_eq_circumradius :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
      dist (s.points i) (Affine.Simplex.circumcenter s) = Affine.Simplex.circumradius s :=
  by sorry

The theorem `Affine.Simplex.dist_circumcenter_eq_circumradius` states that for any simplex `s` in a real inner product space, the distance between any of its points and the circumcenter of the simplex is equal to the circumradius of the simplex. In other words, all points of the simplex are located on the circumsphere defined by the simplex's circumcenter and circumradius.

The circumradius of a simplex in a real inner product space is equal to the distance from any of its points to the circumcenter.


theorem Nat.eq_zero_of_gcd_eq_zero_right : ∀ {m n : ℕ}, Nat.gcd m n = 0 → n = 0 := by sorry

The theorem `Nat.eq_zero_of_gcd_eq_zero_right` states that for all natural numbers `m` and `n`, if the greatest common divisor (gcd) of `m` and `n` is zero, then `n` must be zero. This theorem is stating a property of the gcd function on natural numbers in the context of number theory.

If the greatest common divisor of natural numbers `m` and `n` is zero, then `n` is equal to zero.


/-- If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is compact iff `s` is.  -/
theorem Homeomorph.isCompact_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set Y} (h : X ≃ₜ Y),
      IsCompact (⇑h ⁻¹' s) ↔ IsCompact s :=
  by sorry

The theorem `Homeomorph.isCompact_preimage` states that for any given topological spaces `X` and `Y`, and a set `s` of type `Y`, if there is a homeomorphism `h` from `X` to `Y`, then the preimage of set `s` under `h` is compact if and only if `s` is compact. In other words, a homeomorphism preserves the property of compactness between the image and preimage of a set.

A homeomorphism preserves the compactness of sets, that is, if there is a homeomorphism between topological spaces X and Y, then a set in X is compact if and only if its preimage under this homeomorphism is compact in Y.


theorem Fin.succ_pos : ∀ {n : ℕ} (a : Fin n), 0 < Fin.succ a := by sorry

The theorem `Fin.succ_pos` states that for all natural numbers `n` and for every element `a` of the finite set `Fin n`, the successor of `a` is greater than zero. Here, `Fin n` represents the set of natural numbers less than `n`, and `Fin.succ` is a function that takes an element from `Fin n` and returns an element in `Fin (n+1)`. The idea is that the successor function always produces a positive result because it increases the input by 1.

For all natural numbers `n` and elements `a` in `Fin n`, `Fin.succ a` is a positive natural number.


theorem Pi.single_zero :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] (i : I),
      Pi.single i 0 = 0 :=
  by sorry

This theorem, `Pi.single_zero`, states that for any type `I`, any function `f` that maps elements of `I` to some type, and any element `i` of `I`, if we have decidable equality on `I` and each `f i` is an additive identity (i.e., zero), then the function `Pi.single i 0` is equivalent to the zero function. In simpler terms, it says that if we create a function that takes value `0` at `i` and `0` elsewhere, that function is equivalent to a function that takes value `0` everywhere.

If `I` is a type with decidable equality, `f : I → T`, and `i ∈ I` such that `f i` is the additive identity in `T` for all `i ∈ I`, then `Pi.single i 0` equals the zero function `0 : I → T`.