theorem Function.Injective2.uncurry :
    ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_6} {f : α → β → γ},
      Function.Injective2 f → Function.Injective (Function.uncurry f) :=
  by sorry

This theorem asserts that for any given types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, if `f` is injective in two variables (meaning that if `f` applied to `(a₁, b₁)` equals `f` applied to `(a₂, b₂)`, then `a₁` equals `a₂` and `b₁` equals `b₂`), then the uncurried version of `f` (which is a function `α × β → γ`) is also injective (meaning that if `f` applied to a pair `(a₁, b₁)` equals `f` applied to another pair `(a₂, b₂)`, then the two pairs `(a₁, b₁)` and `(a₂, b₂)` are equal).

If a binary function `f : α → β → γ` is injective in both variables, then its uncurried version `f : α × β → γ` is also injective.


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

The Church-Rosser theorem for word reduction states that for any given type `α` and three lists of pairs of elements of type `α` and booleans `L₁`, `L₂`, and `L₃`, if the list `L₁` reduces to both `L₂` and `L₃` under the reflexive-transitive closure of the `Red.Step` relation (represented as `FreeGroup.Red L₁ L₂` and `FreeGroup.Red L₁ L₃`), then there exists a list `L₄` such that `L₂` and `L₃` can both reduce to `L₄` under the same relation. This condition is represented by the join of the reduction relation between `L₂` and `L₃`. This theorem is also known as Newman's diamond lemma.

If `L₁` reduces to both `L₂` and `L₃` under the reflexive-transitive closure of `Red.Step` relation, then there exists a list `L₄` such that `L₂` and `L₃` can both reduce to `L₄` under the same relation (Church-Rosser theorem for word reduction, or Newman's diamond lemma).


IsCompact.totallyBounded

theorem IsCompact.totallyBounded :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {s : Set α}, IsCompact s → TotallyBounded s := by sorry

This theorem states that for any type `α` that has a uniform space structure and any set `s` of type `α`, if `s` is compact, then `s` is totally bounded. In other words, if every nontrivial filter that contains the set `s` has a cluster point in `s`, then for every entourage `d`, there exists a finite set `t` such that each element of `s` is `d`-near to some element of `t`. This theorem connects the concepts of compactness and total boundedness in a uniform space.

In a uniform space, any compact set is totally bounded.


theorem AdjoinRoot.powerBasis_gen :
    ∀ {K : Type w} [inst : Field K] {f : Polynomial K} (hf : f ≠ 0),
      (AdjoinRoot.powerBasis hf).gen = AdjoinRoot.root f :=
  by sorry

This theorem states that for any field `K` and any non-zero polynomial `f` of type `Polynomial K`, the generator of the power basis associated with the adjoined root of `f` is equal to the adjoined root of `f` itself. In other words, the base element used to construct the power basis (a certain set of elements in algebra) when adjoining the root of a non-zero polynomial to a field is the adjoined root of the polynomial.

For any field `K` and non-zero polynomial `f` over `K`, the root of `f` is the generator of the power basis when adjoining that root to `K`.


theorem Polynomial.splits_mul :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {f g : Polynomial K},
      Polynomial.Splits i f → Polynomial.Splits i g → Polynomial.Splits i (f * g) :=
  by sorry

The theorem `Polynomial.splits_mul` states that for every commutative ring `K` and field `L`, and for every ring homomorphism `i` from `K` to `L`, if a polynomial `f` and a polynomial `g` (both from `K`) each split over `L` under the homomorphism `i`, then their product `f * g` also splits over `L` under the same homomorphism. Here, a polynomial is said to "split" if it is zero or all of its irreducible factors have degree 1.

For every commutative ring K and field L, if polynomials f and g from K each split over L under a ring homomorphism i, then their product f * g splits over L under i as well.


theorem Function.surjective_eval :
    ∀ {α : Sort u} {β : α → Sort v} [h : ∀ (a : α), Nonempty (β a)] (a : α), Function.Surjective (Function.eval a) := by
  sorry

The theorem `Function.surjective_eval` states that for every type `α` and a type family `β` indexed over `α`, assuming that for every element `a : α`, there is at least one element of type `β a` (`Nonempty (β a)`), then for any element `a : α`, the function `Function.eval a` is surjective. In other words, for any element `b` of the type `β a`, there exists a function such that when this function is applied to `a`, it yields `b`.

Given a type `α` and a type family `β : α → Prop` such that for every `a : α`, there exists `b : β a`, the evaluation map `Function.eval : ∀ (f : α → β), f a ∈ β a → β` is surjective.


/-- Any two ring homomorphisms from `ℚ` to a semiring are equal. If the codomain is a division ring,
then this lemma follows from `eq_ratCast`.  -/
theorem RingHom.ext_rat :
    ∀ {F : Type u_1} {R : Type u_5} [inst : Semiring R] [inst_1 : FunLike F ℚ R] [inst : RingHomClass F ℚ R] (f g : F),
      f = g :=
  by sorry

This theorem states that any two ring homomorphisms from the field of rational numbers (`ℚ`) to a semiring (`R`) are identical. This equality holds true under the conditions that the type `R` has a semiring structure, and `F` is a type that behaves like a function from `ℚ` to `R` and is equipped with the structure of a ring homomorphism. If `R` is a division ring, this theorem can be deduced from the `eq_ratCast` lemma.

Any two ring homomorphisms from the field of rational numbers to a semiring are equal.


theorem DenseRange.nonempty_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_4} {f : α → X}, DenseRange f → (Nonempty α ↔ Nonempty X) :=
  by sorry

The theorem `DenseRange.nonempty_iff` states that for any two types `X` and `α`, given `X` has a topology structure and `f` is a function from `α` to `X`, if `f` has a dense range, then `α` is nonempty if and only if `X` is nonempty. This is to say, there exists an element in `α` if and only if there exists an element in `X`, given the range of `f` is dense in `X`.

A function from a nonempty type to a nonempty topological space with a dense range has a nonempty domain.


theorem SimpleGraph.ComponentCompl.disjoint_right :
    ∀ {V : Type u} {G : SimpleGraph V} {K : Set V} (C : SimpleGraph.ComponentCompl G K), Disjoint K ↑C := by sorry

This theorem states that for any type `V`, any `SimpleGraph` `G` on `V`, and any set `K` of vertices from `V`, if `C` is a component of the graph `G` induced by the complement of `K`, then `K` and `C` are disjoint. This can be interpreted as `K` and the component `C` having no common elements. In the context of a lattice, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element. Here, `K` and `C` are disjoint in the sense that there is no vertex that belongs to both `K` and `C`.

For any simple graph `G` on type `V`, and any set `K` of vertices from `V`, if `C` is a component of `G` induced by the complement of `K`, then `K` and `C` have no common elements.


theorem List.prod_toFinset :
    ∀ {α : Type u_3} {M : Type u_6} [inst : DecidableEq α] [inst_1 : CommMonoid M] (f : α → M) {l : List α},
      List.Nodup l → Finset.prod (List.toFinset l) f = List.prod (List.map f l) :=
  by sorry

This theorem states that for any type `α` with a decidable equality, and any type `M` that forms a commutative monoid, given a function `f` mapping elements of `α` to `M` and a list `l` of type `α` with no duplicate elements (i.e., `List.Nodup l`), the product of the function `f` applied to each element in the finset created from `l` (i.e., `Finset.prod (List.toFinset l) f`) is equal to the product of the list created by mapping the function `f` onto each element in `l` (i.e., `List.prod (List.map f l)`). In other words, removing duplicates and applying a function before multiplying (in a commutative monoid sense) is the same as applying the function and then multiplying.

For any decidably equal type `α` and commutative monoid `M`, the product of a function from `α` to `M` applied to the unique elements of a list from `α`, equals the product of the list of the function applications.


theorem Finset.card_Iio_eq_card_Iic_sub_one :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
      (Finset.Iio a).card = (Finset.Iic a).card - 1 :=
  by sorry

This theorem states that for any partially ordered type `α` that has a locally finite order structure from the lowest ordered element, we have the following property for any element `a` of type `α`: the cardinality (or size) of the finite set of elements `x` such that `x` is strictly less than `a` equals the cardinality of the finite set of elements `x` such that `x` is less than or equal to `a`, minus one. In other words, when we remove the element `a` from the set `Finset.Iic a`, we get the set `Finset.Iio a`.

For any locally finite partially ordered type `α`, the number of elements strictly less than any `a` in `α` equals the number of elements less than or equal to `a` minus one.


IsUpperSet.smul

theorem IsUpperSet.smul :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] {s : Set α} {a : α}, IsUpperSet s → IsUpperSet (a • s) := by sorry

The theorem `IsUpperSet.smul` states that for any ordered commutative group `α`, any set `s` of elements of this group, and any element `a` of the group, if `s` is an upper set (meaning that for any elements `a` and `b` in `α`, if `a` is less than or equal to `b` and `a` is in `s`, then `b` is also in `s`), then the set obtained by multiplying every element of `s` by `a` (denoted as `a • s`) is also an upper set.

If `s` is an upper set in an ordered commutative group `α`, then the set `a • s` obtained by multiplying every element of `s` by an element `a` in `α` is also an upper set.


theorem max_eq_right_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, max a b = b ↔ a ≤ b := by sorry

This theorem, `max_eq_right_iff`, states that for any given type `α` with a linear order, and any two elements `a` and `b` of type `α`, the maximum of `a` and `b` is `b` if and only if `a` is less than or equal to `b`. In other words, it provides a condition under which `b` is the maximum of `a` and `b` in a linearly ordered set.

For any type `α` with a linear order, `a` and `b` in `α`, `b` is the maximum of `a` and `b` if and only if `a ≤ b`.


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

This theorem states that for any ordinal `o`, any function `f` mapping each ordinal less than `o` to an ordinal (possibly in a larger universe), and any ordinal `c`, if the cardinality of `o` (when lifted to the universe of `c`) is less than the cofinality of `c`, and if `f` maps every ordinal less than `o` to an ordinal less than `c`, then the least strict upper bound of the family of ordinals given by `f` (as described by the `blsub` operation) is less than `c`. In essence, this theorem is about comparing the size of a certain construct, `blsub`, to another ordinal `c` under specific conditions.

For any ordinal `o`, function `f` mapping `o` to ordinals in a larger universe, and ordinal `c` with `o` having strictly smaller cardinality when lifted to `c` and all `f(x) < c`, the least strict upper bound of `f` (`blsub f`) is strictly less than `c`.


Nat.Partition.ext

theorem Nat.Partition.ext : ∀ {n : ℕ} (x y : Nat.Partition n), x.parts = y.parts → x = y := by sorry

This theorem, `Nat.Partition.ext`, states that for any natural number `n` and any two partitions `x` and `y` of `n`, if the parts of `x` and `y` are equal, then `x` and `y` are equal. In simpler terms, it ensures that two partitions of a natural number are considered the same if they have the same parts, regardless of the order in which these parts are supplied.

If two partitions of a natural number have equal parts, then they are equal.


theorem Valued.hasBasis_nhds_zero :
    ∀ (R : Type u) [inst : Ring R] (Γ₀ : Type v) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [_i : Valued R Γ₀],
      Filter.HasBasis (nhds 0) (fun x => True) fun γ => {x | Valued.v x < ↑γ} :=
  by sorry

This theorem states that for any type `R` with a ring structure, and any type `Γ₀` with a structure of a linearly ordered commutative group with zero, if `R` is valued with `Γ₀`, then the neighborhood filter of zero in `R` has a basis. This basis is characterized by sets of elements `x` in `R` such that the valuation of `x` is less than a given element `γ` in `Γ₀`. In other words, it states that neighborhoods of zero in a valued ring can be characterized by the valuation being less than some threshold.

In a valued ring with a linearly ordered commutative group of values, the neighborhood filter of zero has a basis consisting of elements with valuation less than any given value in the group.


theorem lt_sub_comm :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α}, a < b - c ↔ c < b - a :=
  by sorry

This theorem, `lt_sub_comm`, states that for all types `α` that form an additive commutative group and an ordered set, and for all elements `a`, `b`, and `c` of that type, the statement "a is less than the difference of b and c" is equivalent to the statement "c is less than the difference of b and a". Here the operation of addition and the less than relation are both assumed to be covariant, which in this context means that if you increase the first argument then the result increases.

For all additive commutative groups and ordered sets `α`, and all `a`, `b`, `c` in `α`, the inequality `a < b - c` is equivalent to `c < b - a`.


theorem Hyperreal.isSt_real_iff_eq : ∀ {r s : ℝ}, Hyperreal.IsSt (↑r) s ↔ r = s := by sorry

The theorem `Hyperreal.isSt_real_iff_eq` establishes an equivalence between two conditions for any two real numbers `r` and `s`. The first condition is that `s` is the standard part of the hyperreal number `r` (denoted as `Hyperreal.IsSt (↑r) s` in Lean 4, where `Hyperreal.IsSt` is a function that takes a hyperreal number and a real number and returns true if the real number is within any infinitesimal distance of the hyperreal number). The second condition is that `r` and `s` are equal. In other words, for any two real numbers, `s` is the standard part of the hyperreal number `r` if and only if `r` is equal to `s`.

For any real numbers r and s, r is the hyperreal extension of s if and only if r equals s.


theorem Set.preimage_eq_preimage :
    ∀ {α : Type u_1} {β : Type u_2} {s t : Set α} {f : β → α}, Function.Surjective f → (f ⁻¹' s = f ⁻¹' t ↔ s = t) := by
  sorry

The theorem `Set.preimage_eq_preimage` states that for any types `α` and `β`, sets `s` and `t` of type `α`, and a surjective function `f` from `β` to `α`, the preimage of `s` under `f` is equal to the preimage of `t` under `f` if and only if `s` is equal to `t`. In other words, if `f` is a surjective function, then the equality of the preimages of two sets under `f` implies the equality of the two sets themselves, and vice versa.

For surjective functions \(f:\beta \to \alpha\), the preimages \(f^{-1}(s)\) and \(f^{-1}(t)\) are equal if and only if sets \(s, t \subseteq \alpha\) are equal.


theorem SameRay.exists_pos_left :
    ∀ {R : Type u_1} [inst : LinearOrderedField R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {x y : M}, SameRay R x y → x ≠ 0 → y ≠ 0 → ∃ r, 0 < r ∧ r • x = y :=
  by sorry

The theorem `SameRay.exists_pos_left` states that for all types `R` being a linear ordered field, and for all types `M` being an additive commutative group and a module over `R`, if two vectors `x` and `y` are in the same ray (meaning either one of them is zero, or some positive multiples of them are equal) and both `x` and `y` are non-zero, then there exists a positive real number `r` such that `r` times `x` equals `y`. In other words, if two non-zero vectors are in the same ray, one is a positive scalar multiple of the other.

Given a linear ordered field R and an additive commutative group M being an R-module, if non-zero vectors x and y in M lie on the same ray, then there exists a positive r in R such that rx = y.


theorem Nat.dvd_gcd_iff : ∀ {k : ℕ} {m n : ℕ}, k ∣ Nat.gcd m n ↔ k ∣ m ∧ k ∣ n := by sorry

This theorem states that for any natural numbers `m`, `n`, and `k`, `k` divides the greatest common divisor of `m` and `n` if and only if `k` divides `m` and `k` divides `n`. Here, "divides" is a relation denoted by `∣` in Lean 4. In terms of elementary number theory, this means that a natural number `k` is a divisor of the GCD of `m` and `n`, exactly when `k` is a common divisor of both `m` and `n`.

The greatest common divisor of natural numbers `m` and `n` equals the least common multiple of their divisors `k` if and only if `k` divides both `m` and `n`. equivalently, `k` is a common divisor of `m` and `n` if and only if it divides their GCD.


theorem nsmul_eq_nsmul_iff_modEq :
    ∀ {G : Type u_1} [inst : AddLeftCancelMonoid G] {x : G} {m n : ℕ}, n • x = m • x ↔ n ≡ m [MOD addOrderOf x] := by
  sorry

This theorem states that for any type `G` which is an additive left cancelable monoid, and given any element `x` of `G` and any two natural numbers `m` and `n`, `n` times operation `x` equals `m` times operation `x` if and only if `n` is congruent to `m` modulo the additive order of `x`. The additive order of `x` is the smallest positive natural number `n` such that `n` times operation `x` results in the additive identity (usually denoted as `0`), or it is `0` if `x` has an infinite order. An additive left cancelable monoid is a set equipped with an associative addition operation and an additive identity, which also has the property that for any three elements `a`, `b`, and `c` in the set, if `a + b = a + c`, then `b = c`.

For any additive left cancelable monoid `G` and element `x` of `G`, the equality of `nx` and `mx` in `G` holds if and only if `n` is congruent to `m` modulo the additive order of `x`.


theorem Nat.lt_of_floor_lt :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ}, ⌊a⌋₊ < n → a < ↑n :=
  by sorry

This theorem asserts that for any type `α` which is a linearly ordered semiring and has a floor function, and for any value `a` of type `α` and natural number `n`, if the floor of `a` is less than `n`, then `a` itself is also less than `n`. In mathematical terms, if $⌊a⌋₊ < n$ then $a < n$.

If `α` is a linearly ordered semiring with a floor function, then for all `a : α` and `n : ℕ`, if `⌊a⌋ < n`, then `a < n`.


theorem ENNReal.tsum_eq_iSup_nat' :
    ∀ {f : ℕ → ENNReal} {N : ℕ → ℕ},
      Filter.Tendsto N Filter.atTop Filter.atTop →
        ∑' (i : ℕ), f i = ⨆ i, Finset.sum (Finset.range (N i)) fun a => f a :=
  by sorry

This theorem states that for any sequence of extended nonnegative real numbers `f` and a sequence of natural numbers `N` that tends to infinity, the series sum of `f` is equal to the least upper bound of the finite sums of `f` over the range of `N`. In other words, given a function `f` from natural numbers to extended nonnegative real numbers and another function `N` from natural numbers to natural numbers that tends to infinity, the sum over all natural numbers of `f` equals the supremum over all natural numbers of the sum of `f` over the set of natural numbers less than the value of `N` at that number.

For any sequence `(f : ℕ → ℝᵤᵇ)` of extended nonnegative real-valued functions and `(N : ℕ → ℕ)` tending to infinity, $\sum\_{n=0}^\infty f(n) = \sup\_{n\in\mathbb{N}} \sum\_{i=0}^{N(n)-1} f(i).$


theorem mul_upperClosure :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] (s t : Set α), s * ↑(upperClosure t) = ↑(upperClosure (s * t)) := by
  sorry

This theorem states that for any ordered commutative group `α` and any two sets `s` and `t` of elements in `α`, the set resulting from multiplying every element of `s` by the upper closure of `t` (i.e., the smallest subset of `α` that contains `t` and is closed under taking an element greater than or equal to any given one) is equal to the upper closure of the set resulting from multiplying every element of `s` by every element of `t`. In mathematical terms, we have $s \cdot \overline{t} = \overline{s \cdot t}$ where $\overline{T}$ denotes the upper closure of a set $T$.

For any ordered commutative group `α` and sets `s` and `t` in `α`, the upper closures of `s * t` and `s * Cl(t)` are equal, where `*` denotes multiplication and `Cl(t)` is the upper closure of `t`.


theorem nndist_pi_def :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      (f g : (b : β) → π b), nndist f g = Finset.sup Finset.univ fun b => nndist (f b) (g b) :=
  by sorry

The theorem `nndist_pi_def` states that for any finite type `β` and any type function `π` from `β` to some other type, given that every `b` of type `β` maps to a pseudo metric space via `π`, the non-negative distance (`nndist`) between two functions `f` and `g` (both of type `(b : β) → π b`) is equal to the supremum (greatest element) of the set of non-negative distances between `f b` and `g b` for all `b` in the universal finite set of type `β`. In other words, the non-negative distance between two functions on a finite set is determined by the greatest distance between their values.

For any finite type `β` and type functions `π : β → X` to a pseudo metric space `X`, the non-negative distance between two functions `f` and `g` (of type `β → π (β)`) is equal to the supremum of the non-negative distances between `f (b)` and `g (b)` for all `b` in `β`.


theorem IsRelPrime.add_mul_right_left :
    ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime (x + z * y) y := by sorry

The theorem `IsRelPrime.add_mul_right_left` states that for any type `R` that forms a commutative ring, for any elements `x`, `y` and `z` of `R`, if `x` and `y` are relatively prime, then `x + z * y` and `y` are also relatively prime. Here, two elements are said to be relatively prime if any common divisor of them is a unit.

If `x` and `y` are relatively prime elements in a commutative ring `R`, then `x` and `x + y * z` are relatively prime for any `z` in `R`.


theorem Set.restrict_dite_compl :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} [inst : (x : α) → Decidable (x ∈ s)] (f : (a : α) → a ∈ s → β)
      (g : (a : α) → a ∉ s → β), (Set.restrict sᶜ fun a => if h : a ∈ s then f a h else g a h) = fun a => g ↑a ⋯ :=
  by sorry

This theorem states that for any set `s` of elements of type `α`, and any two functions `f` and `g` that map elements of `α` into a type `β` based on their membership in `s`, if we restrict the function that applies `f` to elements in `s` and `g` to elements not in `s` to the complement of `s`, we obtain a function equivalent to `g` when applied to the elements of `s`. In other words, when we're considering elements outside of `s` (`s` complement), we can effectively ignore the part of the function that applies to elements inside `s`; we're only concerned with `g`. Note that this is under the assumption that it can be decided for any element `x` of type `α` whether `x` is in `s` or not.

For any set `s` and functions `f` and `g` from a type `α` to a type `β`, if `x ∈ s` implies `f x = g x`, then the restrictions of `f` and `g` to the complement of `s` are equal.


theorem MeasureTheory.Measure.inv_inv :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : InvolutiveInv G] [inst_2 : MeasurableInv G]
      (μ : MeasureTheory.Measure G), MeasureTheory.Measure.inv (MeasureTheory.Measure.inv μ) = μ :=
  by sorry

The theorem `MeasureTheory.Measure.inv_inv` states that for any type `G` with a measurable space structure, an involution operation, and a measurable involution (expressed by the typeclasses `MeasurableSpace G`, `InvolutiveInv G`, and `MeasurableInv G` respectively), and for any measure `μ` over this type `G`, the measure obtained by applying the `inv` operation twice on `μ` is equal to `μ` itself. In other words, the `inv` operation on measures is its own inverse. This is similar to saying that the double application of the mathematical function of taking the inverse (`A ↦ 1/A`) to any measure gives back the original measure.

For any measurable space `(G, Σ, μ)` with an involutive measurable involution, the measure `μ` is invariant under the involution operation, i.e., `μ = μ ∘ inv`.


theorem lowerSemicontinuousWithinAt_iSup :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {ι : Sort u_3} {δ : Type u_4}
      [inst_1 : CompleteLinearOrder δ] {f : ι → α → δ},
      (∀ (i : ι), LowerSemicontinuousWithinAt (f i) s x) → LowerSemicontinuousWithinAt (fun x' => ⨆ i, f i x') s x :=
  by sorry

The theorem `lowerSemicontinuousWithinAt_iSup` states that for any topological space `α`, any point `x` in that space, any set `s` of elements of `α`, any type `ι`, any complete linear order `δ`, and any function `f` from `ι` and `α` to `δ`, if every `f i` is lower semicontinuous at `x` within `s`, then the function that maps `x'` to the supremum (least upper bound) over all `i` of `f i x'` is also lower semicontinuous at `x` within `s`. In simpler terms, the supremum of a collection of lower semicontinuous functions is also lower semicontinuous.

If each function in a collection of lower semicontinuous functions from a topological space to a complete linear order is lower semicontinuous at a point, then their supremum function is also lower semicontinuous at that point.


theorem finsum_eq_indicator_apply :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M) (a : α),
      (finsum fun x => f a) = Set.indicator s f a :=
  by sorry

The theorem `finsum_eq_indicator_apply` states that for any set `s` of type `α`, any function `f` from `α` to `M`, and any element `a` of `α`, the sum (`finsum`) of `f a` over all `x` is equal to the `Set.indicator` of `s`, `f`, and `a`. In more detail, `Set.indicator` is a function that returns `f a` if `a` is in the set `s`, and `0` otherwise. Therefore, if you sum `f a` over all `x`, you get the same result as using the `Set.indicator` function on `s`, `f`, and `a`. This theorem essentially connects the concepts of summing over a function and using an indicator function in the context of a set.

For any set `s`, function `f` from `s` to `M`, and element `a` in `s`, the sum of `f a` over all `x` in `s` equals the value of `Set.indicator s f a`.


HasCompactSupport.mono'

theorem HasCompactSupport.mono' :
    ∀ {α : Type u_2} {β : Type u_4} {γ : Type u_5} [inst : TopologicalSpace α] [inst_1 : Zero β] [inst_2 : Zero γ]
      {f : α → β} {f' : α → γ}, HasCompactSupport f → Function.support f' ⊆ tsupport f → HasCompactSupport f' :=
  by sorry

The theorem `HasCompactSupport.mono'` states that for any types `α`, `β`, and `γ` where `α` is a topological space and `β` and `γ` are equipped with a zero element, if a function `f` from `α` to `β` has compact support and the support of another function `f'` from `α` to `γ` is a subset of the topological support of `f`, then `f'` also has compact support. In simpler terms, if a function is zero outside a compact set and another function is also zero where the first function is zero, then the second function also has compact support.

If a function from a topological space to a Hausdorff space with a zero element has compact support, and another function from the same space to the same space with a zero element has support contained in the topological support of the first function, then the second function also has compact support.


PythagoreanTriple.eq

theorem PythagoreanTriple.eq : ∀ {x y z : ℤ}, PythagoreanTriple x y z → x * x + y * y = z * z := by sorry

The theorem `PythagoreanTriple.eq` states that for any three integers `x`, `y`, and `z`, if `x`, `y` and `z` form a Pythagorean triple (which is defined to be true when the square of `x` plus the square of `y` equals the square of `z`), then the equation `x * x + y * y = z * z` holds true.

If integers x, y, and z form a Pythagorean triple, then x² +y² = z² holds true. Equivalently, x, y, and z satisfy the equation x² +y² = z² if and only if there exist integers a and b such that x = a²+b², y = 2ab, and z = a²+b²².


theorem Prod.map_id : ∀ {α : Type u_1} {β : Type u_2}, Prod.map id id = id := by sorry

The theorem `Prod.map_id` states that for any pair of types `α` and `β`, applying the `Prod.map` function with `id` (the identity function) for both components results in the identity function. In other words, if we map each component of a pair (from `α` and `β` respectively) with the identity function, we get back the original pair. This is akin to saying that the identity function leaves all elements of the pair unchanged.

For any types `α` and `β`, `Prod.map id (x, y) = (x, y)`.


theorem Sym2.mk_isDiag_iff : ∀ {α : Type u_1} {x y : α}, Sym2.IsDiag s(x, y) ↔ x = y := by sorry

The theorem `Sym2.mk_isDiag_iff` states that for any type `α` and any two elements `x` and `y` of that type, a pair `(x, y)` is on the diagonal of the symmetric square `Sym2 α` if and only if `x` equals `y`. In other words, a `Sym2` pair is on the diagonal when its two elements are the same.

The theorem `Sym2.mk_isDiag_iff` asserts that two elements `x` and `y` of type `α` lie on the diagonal of the symmetric square `Sym2 α` if and only if `x = y`.


theorem Finset.image_sdiff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] {f : α → β} (s t : Finset α),
      Function.Injective f → Finset.image f (s \ t) = Finset.image f s \ Finset.image f t :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of type `α`, and a function `f` from `α` to `β` that is injective (i.e., it assigns a unique value in `β` to each element in `α`), the image of the difference of `s` and `t` under `f` (i.e., `f` applied to each element of `s \ t`) is equal to the difference of the images of `s` and `t` under `f`. In other words, `f` preserves the operation of set difference. This requires that equality is decidable for both `α` and `β`, which means given any two elements of the same type, we can decide whether they are equal or not. The theorem can be succinctly expressed in mathematical terms as: if `f` is injective, then `f(s \ t) = f(s) \ f(t)`.

If `f` is an injective function from a finite set `α` to `β` with decidable equality, then `f(s \ t) = f(s) \ f(t)` for any finite sets `s` and `t` in `α`.


theorem Irrational.ne_int : ∀ {x : ℝ}, Irrational x → ∀ (m : ℤ), x ≠ ↑m := by sorry

This theorem states that for any real number `x`, if `x` is irrational (meaning it cannot be expressed as a ratio of two integers), then `x` is not equal to any integer `m`. In other words, an irrational real number cannot be an integer.

An irrational real number is not equal to any integer.


StrictAnti.antitone

theorem StrictAnti.antitone :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β}, StrictAnti f → Antitone f :=
  by sorry

The theorem `StrictAnti.antitone` states that for any function `f` mapping from a type `α` to a type `β`, where `α` is a partially ordered set and `β` is a preordered set, if `f` is strictly antitone (i.e., for any `a` and `b` in `α` where `a < b`, it implies `f(b) < f(a)`), then `f` is also antitone (i.e., for any `a` and `b` in `α` where `a ≤ b`, it implies `f(b) ≤ f(a)`).

If `f` is a strictly antitone function from a partially ordered set `α` to a preordered set `β`, then `f` is antitone. (That is, for all `a ≤ b` in `α`, `f(b) ≤ f(a)`.)


theorem Finset.mem_pi :
    ∀ {α : Type u_1} {β : α → Type u} [inst : DecidableEq α] {s : Finset α} {t : (a : α) → Finset (β a)}
      {f : (a : α) → a ∈ s → β a}, f ∈ Finset.pi s t ↔ ∀ (a : α) (h : a ∈ s), f a h ∈ t a :=
  by sorry

This theorem states that for any type `α`, function `β` from `α` to some other type, and for any set `s` of `α` and function `t` that maps each element of `α` to a set of `β a`, a function `f` is in the set of all functions (`Finset.pi s t`) defined on elements of `s` and taking values in `t a` for `a ∈ s`, if and only if for every element `a` in `s`, `f a h` is in the set `t a`. Here `f a h` retrieves the value of function `f` at point `a`, where `h` proves that `a` is in `s`. In short, function `f` is part of the product space `Finset.pi s t` if it assigns to each element of `s` a value in the corresponding `t a` set.

A function `f` belongs to the product set `Finset.pi s t` if and only if `f a ∈ t a` for all `a ∈ s`.


theorem Nat.hyperfilter_le_atTop : ↑(Filter.hyperfilter ℕ) ≤ Filter.atTop := by sorry

This theorem states that the ultrafilter extension of the cofinite filter on natural numbers (`Filter.hyperfilter ℕ`) is less than or equal to the filter representing the limit towards positive infinity (`Filter.atTop`). In other words, every neighborhood of infinity contains an infinite cofinite set. This theorem is about the inclusion relationship between these two filters in the natural numbers context.

The cofinite ultrafilter on natural numbers is included in the filter at infinity.


/-- The `n+1`-th iterated derivative within a set with unique derivatives can be obtained by
differentiating the `n`-th iterated derivative.  -/
theorem iteratedDerivWithin_succ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F} {s : Set 𝕜} {x : 𝕜},
      UniqueDiffWithinAt 𝕜 s x → iteratedDerivWithin (n + 1) f s x = derivWithin (iteratedDerivWithin n f s) s x :=
  by sorry

The theorem `iteratedDerivWithin_succ` states that for a given nontrivially normed field `𝕜`, a normed additive commutative group `F`, a normed space `𝕜 F`, a natural number `n`, a function `f` from `𝕜` to `F`, a set `s` of `𝕜`, and an element `x` of `𝕜`, if the set `s` has unique derivatives at the point `x`, then the `(n+1)`-th iterated derivative of the function `f` within the set `s` at the point `x` can be obtained by finding the derivative within the set `s` at the point `x` of the `n`-th iterated derivative of the function `f` within the set `s`. In mathematical terms, if `f : 𝕜 → F` is differentiable within a set `s` at a point `x`, then the `(n+1)`-th derivative at `x` within `s` of `f`, denoted `iteratedDerivWithin (n + 1) f s x`, is equal to the derivative at `x` within `s` of the `n`-th derivative of `f`, denoted `derivWithin (iteratedDerivWithin n f s) s x`.

If a function `f : 𝕜 → F` is `n`-times differentiable within a set `s` at a point `x` in a nontrivially normed field `𝕜`, then the `(n+1)`-th derivative of `f` within `s` at `x` is equal to the derivative of the `n`-th derivative of `f` within `s` at `x`.


theorem Polynomial.splits_one :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L), Polynomial.Splits i 1 := by sorry

The theorem `Polynomial.splits_one` states that for any commutative ring `K` and any field `L`, and any ring homomorphism `i` from `K` to `L`, the number `1` is a "split" polynomial. This means that when you map `1` from `K` to `L`, you either get zero or all of its irreducible factors in `L` have a polynomial degree of `1`.

For any commutative ring K and field L, and any ring homomorphism i from K to L, the element 1 in K maps to a polynomial with degree 1 or a root in L.


theorem IsLUB.mem_upperBounds_of_tendsto :
    ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : Preorder γ] [inst_4 : TopologicalSpace γ] [inst_5 : OrderClosedTopology γ] {f : α → γ} {s : Set α}
      {a : α} {b : γ},
      MonotoneOn f s → IsLUB s a → Filter.Tendsto f (nhdsWithin a s) (nhds b) → b ∈ upperBounds (f '' s) :=
  by sorry

This theorem states that for a given set `s` of elements of type `α` and a function `f` from `α` to `γ`, if `f` is monotone on `s` and `a` is a least upper bound of `s`, then if the limit of `f` as elements approach `a` within `s` is `b`, then `b` belongs to the set of upper bounds of the image of `s` under `f`. In other words, if `f` is increasing over a set and we find its limit at a point which is a least upper bound for that set, then the limit value is an upper bound for the set of output values of `f`. This guarantee is given under certain conditions for the types `α` and `γ` - they must both be equipped with a topology, `α` must be a linear order with an order topology and `γ` must be a preorder with a closed order topology.

If `f` is a monotone function from a non-empty, bounded above set `s` in a linearly ordered topological space `α` with a least upper bound `a`, and `b` is the limit of `f` as elements approach `a` in `s`, then `b` is an upper bound for the image of `s` under `f` in the preordered topological space `γ`.


Filter.Tendsto.if

theorem Filter.Tendsto.if :
    ∀ {α : Type u} {β : Type v} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
      [inst : (x : α) → Decidable (p x)],
      Filter.Tendsto f (l₁ ⊓ Filter.principal {x | p x}) l₂ →
        Filter.Tendsto g (l₁ ⊓ Filter.principal {x | ¬p x}) l₂ →
          Filter.Tendsto (fun x => if p x then f x else g x) l₁ l₂ :=
  by sorry

This theorem, `Filter.Tendsto.if`, states that for any types `α` and `β`, given two functions `f` and `g` mapping `α` to `β`, a predicate `p` on `α`, and two filters `l₁` on `α` and `l₂` on `β`, if `f` tends to `l₂` along the filter `l₁` intersected with the principal filter of the set of elements satisfying `p`, and `g` tends to `l₂` along the filter `l₁` intersected with the principal filter of the set of elements not satisfying `p`, then the function which maps any element `x` to `f x` if `p x` is true and `g x` otherwise, tends to `l₂` along the filter `l₁`. In simpler terms, it says that if two functions `f` and `g` tend to the same limit under different conditions defined by a predicate, then a function which is defined as `f` under the condition and `g` otherwise, also tends to the same limit.

Given functions `f` and `g` mapping `α` to `β`, a predicate `p` on `α`, and filters `l₁` on `α` and `l₂` on `β`, if `f` tends to `l₂` along `l₁ ∩ p` and `g` tends to `l₂` along `l₁ ∩ ∘neg p`, then the function `x ↦ if p x then f x else g x` tends to `l₂` along `l₁`.


theorem Mathlib.Algebra.Order.Monoid.WithTop._auxLemma.2 : ∀ {α : Type u} [inst : Zero α] {a : α}, (↑a = 0) = (a = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Monoid.WithTop._auxLemma.2`, states that for any type `α` that has a `Zero` instance and a given element `a` of this type, the equality of the lifted value of `a` to the zero element is equivalent to the equality of `a` itself to the zero element. In other words, if we lift `a` into the `WithTop` type (which adds a "top" element to a given type), stating that `a` equals zero in this extended type is the same as saying that `a` equals zero in its original type.

For any type `α` with a `Zero` instance, the lifted value of an element `a` in `α` equals the zero element in the `WithTop` type if and only if `a` equals the zero element in `α`.


theorem Associates.factors_0 :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α],
      Associates.factors 0 = ⊤ :=
  by sorry

The theorem `Associates.factors_0` states that for any type `α` that is equipped with the structure of a `CancelCommMonoidWithZero` and a `UniqueFactorizationMonoid`, the multiset of irreducible factors (i.e., the `Associates.FactorSet`) of the zero element in `Associates α` is equal to the top element (`⊤`). This can be interpreted as saying that the zero element has an infinite number of irreducible factors.

For any `CancelCommMonoidWithZero` and `UniqueFactorizationMonoid` type `α`, the irreducible factors of its zero element form an infinite set equal to the top element in the `Associates.FactorSet`.


theorem PosNum.cast_one : ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α], ↑1 = 1 := by sorry

This theorem states that for any type `α` that has both the identity element for addition (`One α`) and the addition operation (`Add α`), the casting of the positive number one (`1`) into type `α` is equal to the identity element `1` of type `α`. Essentially, it is confirming that the casting operation correctly identifies the number one in other mathematical structures that have a concept equivalent to 'one'.

For any type `α` with an addition operation and an identity element, the cast of `1` to `α` equals the identity element.


theorem Hyperreal.infiniteNeg_add_not_infinitePos :
    ∀ {x y : ℝ*}, Hyperreal.InfiniteNeg x → ¬Hyperreal.InfinitePos y → Hyperreal.InfiniteNeg (x + y) := by sorry

This theorem states that for any pair of hyperreal numbers `x` and `y`, if `x` is negative infinite (meaning that it is smaller than any real number) and `y` is not positive infinite (meaning it's not the case that `y` is larger than any real number), then the sum of `x` and `y` is also negative infinite. In other words, adding a non-positive-infinite hyperreal number to a negative-infinite hyperreal number still results in a negative-infinite hyperreal number.

For any hyperreal numbers `x` and `y`, if `x` is negative infinite and `y` is not positive infinite, then `x + y` is negative infinite.


theorem Finsupp.graph_injective : ∀ (α : Type u_13) (M : Type u_14) [inst : Zero M], Function.Injective Finsupp.graph :=
  by sorry

This theorem states that for all types `α` and `M`, where `M` additionally has a zero element, the function `Finsupp.graph` is injective. In other words, given two finitely supported functions `f` and `g` over `α` with values in `M`, if their graphs (i.e., the finite sets of pairs `(a, f a)` and `(a, g a)` with non-zero `f a` and `g a`) are the same, then the functions `f` and `g` are identical. This function is crucial in scenarios where we need to identify a function uniquely by its non-zero values and their corresponding inputs.

Given types `α` and `M` with `M` having a zero element, the function `Finsupp.graph` is an injection from the set of finitely supported functions from `α` to `M`.


theorem AddSubmonoid.LocalizationMap.add_mk'_eq_mk'_of_add :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      (f : AddSubmonoid.LocalizationMap S N) (x₁ x₂ : M) (y : ↥S),
      (AddSubmonoid.LocalizationMap.toMap f) x₁ + AddSubmonoid.LocalizationMap.mk' f x₂ y =
        AddSubmonoid.LocalizationMap.mk' f (x₁ + x₂) y :=
  by sorry

This theorem is about localization maps from one additive commutative monoid to another. Specifically, for any additive commutative monoids `M` and `N`, a localization map `f` from `M` to `N`, elements `x₁` and `x₂` in `M`, and an element `y` in the submonoid `S` of `M`, the result of applying `f` to `x₁` and then adding the result of applying the localization map creation function `mk'` to `f`, `x₂`, and `y`, is equal to the result of applying `mk'` to `f`, the sum of `x₁` and `x₂`, and `y`. Expressed more compactly, for all `f`, `x₁`, `x₂`, and `y` as above, we have `f(x₁) + mk'(f, x₂, y) = mk'(f, x₁ + x₂, y)`. This theorem effectively expresses the distributivity of the localization map over the addition operation in the original monoid.

Given additive commutative monoids M and N, a localization map f from M to N, and elements x₁, x₂, and y in M, the localization of the sum x₁ + x₂ under f is equal to the sum of the localizations of x₁ and x₂ under f and the localization of y. That is, f(x₁ + x₂) = mk'(f, x₁, y) + mk'(f, x₂, y).


theorem add_neg_cancel_comm_assoc : ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), a + (b + -a) = b := by sorry

This theorem, `add_neg_cancel_comm_assoc`, states that for all types `G` that form an additive commutative group, for any two elements `a` and `b` belonging to this group `G`, the sum of `a` and the sum of `b` and the additive inverse of `a` is equal to `b`. In other words, adding `a` to `b` and then subtracting `a` returns `b`, which is essentially the property of cancellation in the group.

For all additive commutative groups G and elements a, b in G, a + b + (-a) = b.


theorem AdjoinRoot.lift_of :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] {f : Polynomial R} [inst_1 : CommRing S] {i : R →+* S} {a : S}
      (h : Polynomial.eval₂ i a f = 0) {x : R}, (AdjoinRoot.lift i a h) ((AdjoinRoot.of f) x) = i x :=
  by sorry

The theorem `AdjoinRoot.lift_of` states that for any commutative rings `R` and `S`, any ring homomorphism `i` from `R` to `S`, any polynomial `f` over `R`, and any element `a` of `S` such that `f` evaluates to `0` at `a` (in the sense of applying the ring homomorphism `i` to the coefficients of `f` and then evaluating at `a`), the result of applying the function `AdjoinRoot.lift i a h` to the image of any element `x` of `R` under the function `AdjoinRoot.of f` is equal to the image of `x` under `i`. This effectively says that `AdjoinRoot.lift i a h` is a lifting of the ring homomorphism `i` to the ring of adjoined roots of `f`, which maps `R` to `S` in a way that preserves the images of elements of `R` under `i`.

For any commutative rings R and S, ring homomorphism i from R to S, polynomial f over R, and element a of S such that f(a) = 0 under i, AdjoinRoot.lift i a h(AdjoinRoot.of f x) = i(x) for all x in R.


/-- Definition of proper maps. See also `isClosedMap_iff_clusterPt` for a related criterion
for closed maps.  -/
theorem isProperMap_iff_clusterPt :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
      IsProperMap f ↔ Continuous f ∧ ∀ ⦃ℱ : Filter X⦄ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ :=
  by sorry

The theorem `isProperMap_iff_clusterPt` provides a characterization of proper maps in terms of cluster points. Given types `X` and `Y` with topological spaces, it states that for a function `f : X → Y`, `f` is a proper map if and only if `f` is continuous and for every filter `ℱ` in `X` and point `y` in `Y`, if `y` is a cluster point of the image of `ℱ` under `f`, there exists a point `x` in `X` such that `f(x) = y` and `x` is a cluster point of `ℱ`. Here, a point `x` is a cluster point of a filter `ℱ` in `X` if the intersection of `ℱ` and the neighborhood of `x` is not empty. Similarly, a point `y` is a cluster point of the image of `ℱ` under `f` if the intersection of the image of `ℱ` under `f` and the neighborhood of `y` is not empty.

A function between topological spaces is proper if and only if it is continuous and preserves cluster points, that is, for every filter on the domain and every cluster point of its image, there exists a cluster point in the domain mapping to that image point.


theorem Set.ncard_inter_add_ncard_diff_eq_ncard :
    ∀ {α : Type u_1} (s t : Set α),
      autoParam (Set.Finite s) _auto✝ → Set.ncard (s ∩ t) + Set.ncard (s \ t) = Set.ncard s :=
  by sorry

This theorem, labeled `Set.ncard_inter_add_ncard_diff_eq_ncard`, states that for any type `α` and any two sets `s` and `t` of type `α`, under the automatic parameter condition that the set `s` is finite, the sum of the cardinality of the intersection of `s` and `t` and the cardinality of the difference between `s` and `t` (i.e., elements in `s` but not in `t`) is equal to the cardinality of the set `s`. The cardinality is represented as a natural number. In mathematical terms, this can be written as $|s \cap t| + |s \setminus t| = |s|$, where $|.|$ denotes the cardinality of a set.

For any finite set `s` of type `α`, the cardinality of `s ∩ t` plus the cardinality of `s \ t` equals the cardinality of `s`, i.e., `|s ∩ t| + |s \ t| = |s|`.


theorem zpow_ne_zero : ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {x : G₀} (n : ℤ), x ≠ 0 → x ^ n ≠ 0 := by sorry

This theorem states that for any GroupWithZero `G₀` and any element `x` of `G₀`, if `x` is not equal to zero then `x` raised to any integer `n` is also not equal to zero. The GroupWithZero typeclass in Lean 4 is used to represent groups that have an additional distinguished element that serves as a zero and satisfies the property that any element times zero equals zero.

If `G₀` is a group with zero and `x` is a non-zero element in `G₀`, then `x^n` is also non-zero for any integer `n`.


theorem AdjoinRoot.lift_mk :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] {f : Polynomial R} [inst_1 : CommRing S] {i : R →+* S} {a : S}
      (h : Polynomial.eval₂ i a f = 0) (g : Polynomial R),
      (AdjoinRoot.lift i a h) ((AdjoinRoot.mk f) g) = Polynomial.eval₂ i a g :=
  by sorry

The theorem `AdjoinRoot.lift_mk` states that for any commutative rings `R` and `S`, a polynomial `f` from `R`, a ring homomorphism `i` from `R` to `S`, and an element `a` from `S` such that `a` is a root of `f` under the homomorphism `i`, the lift of the ring homomorphism from `AdjoinRoot f` to `S` applied to the image of any polynomial `g` from `R` under the ring homomorphism from `R[x]` to `AdjoinRoot f` is equal to the evaluation of `g` at `a` under the homomorphism `i`. In simpler terms, this theorem connects the operations of lifting a ring homomorphism and evaluating a polynomial.

For any commutative rings R and S, a polynomial f from R, a ring homomorphism i from R to S, and an element a in S that is a root of f under i, the lifted homomorphism from AdjoinRoot(f) to S applied to the image of any polynomial g from R maps to the evaluation of g at a under i.


theorem Polynomial.eraseLead_zero : ∀ {R : Type u_1} [inst : Semiring R], Polynomial.eraseLead 0 = 0 := by sorry

The theorem `Polynomial.eraseLead_zero` states that for any semiring `R`, the result of applying the `eraseLead` function to the zero polynomial is the zero polynomial. In other words, erasing the leading term of the zero polynomial in any semiring leaves us with the zero polynomial.

For any semiring R, the eraseLead function applied to the zero polynomial results in the zero polynomial.


Bornology.IsVonNBounded.union

/-- The union of two bounded sets is bounded.  -/
theorem Bornology.IsVonNBounded.union :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : Zero E]
      [inst_3 : TopologicalSpace E] {s₁ s₂ : Set E},
      Bornology.IsVonNBounded 𝕜 s₁ → Bornology.IsVonNBounded 𝕜 s₂ → Bornology.IsVonNBounded 𝕜 (s₁ ∪ s₂) :=
  by sorry

This theorem states that for any two sets `s₁` and `s₂` of a certain type `E`, if both these sets are von Neumann bounded with respect to a seminormed ring `𝕜`, then their union is also von Neumann bounded with respect to the same seminormed ring `𝕜`. In this context, a set is said to be von Neumann bounded if every neighborhood of 0 absorbs the set. A neighborhood of 0 absorbs a set if there is a scalar such that multiplying every member of the set by this scalar results in points that all lie within the neighborhood.

If sets `s₁` and `s₂` in seminormed ring `𝕜` are both von Neumann bounded, then their union is also von Neumann bounded.


theorem Filter.comap_cofinite_le :
    ∀ {α : Type u_2} {β : Type u_3} (f : α → β), Filter.comap f Filter.cofinite ≤ Filter.cofinite := by sorry

The theorem `Filter.comap_cofinite_le` states that for all types `α` and `β` and any function `f` from `α` to `β`, the cofinite filter of the preimage of `f` (which is obtained by the `Filter.comap` function) is less than or equal to the cofinite filter of `β`. In other words, the set of preimages under `f` of the cofinite subsets of `β` is a subset of the cofinite subsets of `α`.

For all types `α` and `β` and functions `f` from `α` to `β`, the cofinite filter of `f`'s preimages is included in the cofinite filter of `β`.


theorem MeasureTheory.integral_comp_mul_left_Ioi :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : ℝ → E) (a : ℝ) {b : ℝ},
      0 < b → ∫ (x : ℝ) in Set.Ioi a, g (b * x) = b⁻¹ • ∫ (x : ℝ) in Set.Ioi (b * a), g x :=
  by sorry

This theorem states that for any normed additive commutative group `E`, any normed space over the reals `E`, a function `g` from the reals to `E`, and two real numbers `a` and `b` (where `b` is positive), the integral of `g` composed with multiplication by `b` over the open interval from `a` to infinity is equal to `b` inverse scaled by the integral of `g` over the open interval from `b*a` to infinity. In other words, it says that the integral of a function over a stretched interval can be calculated by adjusting the integrand function and scale the result by the reciprocal of the stretching factor.

For any normed additive commutative group `E`, any normed space over the reals `E`, and real-valued function `g`, the integral of `g` multiplied by `b` from `a` to infinity equals `b^{-1}` times the integral of `g` from `b*a` to infinity.


theorem Rack.act_invAct_eq : ∀ {R : Type u_1} [inst : Rack R] (x y : R), Shelf.act x (Rack.invAct x y) = y := by sorry

This theorem states that for all types `R` that have a structure of a `Rack`, and for all elements `x` and `y` of `R`, the `Shelf` action of `x` on the inverse action of `x` on `y` equals `y`. Intuitively, this says that the `Rack` inverse action behaves like a "reverse operation" for the `Shelf` action.

For all types `R` with a `Rack` structure and all elements `x` in `R`, the `Shelf` action of `x` on the inverse action of `x` on `y` equals `y`. In mathematical notation, `x * (x ^-1 * y) = y`.


theorem NNReal.IsConjExponent.conj_eq : ∀ {p q : NNReal}, p.IsConjExponent q → q = p / (p - 1) := by sorry

The theorem `NNReal.IsConjExponent.conj_eq` states that for any two nonnegative real numbers `p` and `q`, if `p` is a conjugate exponent of `q`, then `q` is equal to `p` divided by `p - 1`.

If `p` is a conjugate exponent of `q` in the nonnegative real numbers, then `q = p / (p - 1)`.


theorem AddEquiv.map_eq_zero_iff :
    ∀ {M : Type u_6} {N : Type u_7} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (h : M ≃+ N) {x : M},
      h x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any two types `M` and `N` that have addition with zero (`AddZeroClass`), if there exists an additive equivalence (`h : M ≃+ N`) between `M` and `N`, then an element `x` of type `M` maps to zero under this equivalence if and only if `x` itself is zero. In other words, this theorem ensures that an additive equivalence preserves the property of being zero.

For any types `M` and `N` with additive structures and an additive equivalence `h : M ≃+ N`, if `x : M` maps to zero in `N` under `h`, then `x` is zero in `M`.


theorem Polynomial.natDegree_mul_leadingCoeff_inv :
    ∀ {K : Type u_1} [inst : DivisionRing K] (p : Polynomial K) {q : Polynomial K},
      q ≠ 0 → Polynomial.natDegree (p * Polynomial.C (Polynomial.leadingCoeff q)⁻¹) = Polynomial.natDegree p :=
  by sorry

The theorem `Polynomial.natDegree_mul_leadingCoeff_inv` states that for any division ring `K` (a ring in which every non-zero element has a multiplicative inverse), given any polynomials `p` and `q` in `K` where `q` is not equal to zero, the natural degree of the polynomial resulting from multiplying `p` by the multiplicative inverse of the leading coefficient of `q` (denoted by `Polynomial.leadingCoeff q`⁻¹) is equal to the natural degree of `p`. In other words, multiplying a polynomial by the inverse of the leading coefficient of another non-zero polynomial does not change the natural degree of the original polynomial.

For any division ring K and polynomials p and q in K with q != 0, the natural degree of p * leadingCoeff(q)⁻¹ is equal to the natural degree of p.


/-- We now have four different results that all encode the
idea that inequality of multisets corresponds to divisibility
of positive integers.  -/
theorem PNat.factorMultiset_le_iff : ∀ {m n : ℕ+}, PNat.factorMultiset m ≤ PNat.factorMultiset n ↔ m ∣ n := by sorry

This theorem is expressing the relationship between the inequality of multisets of prime factors of positive integers and the divisibility of these positive integers. More specifically, for any two positive integers `m` and `n`, the multiset of prime factors of `m` being less than or equal to the multiset of prime factors of `n` is equivalent to `m` dividing `n`. This theorem encapsulates one aspect of the fundamental theorem of arithmetic, namely that each integer has a unique prime factorization, and relates it to the concept of divisibility.

The multiset of prime factors of a positive integer `m` being less than or equal to the multiset of prime factors of a positive integer `n` if and only if `m` divides `n`.


theorem Real.le_arcsin_iff_sin_le' :
    ∀ {x y : ℝ}, x ∈ Set.Ioc (-(Real.pi / 2)) (Real.pi / 2) → (x ≤ Real.arcsin y ↔ Real.sin x ≤ y) := by sorry

This theorem states that for all real numbers `x` and `y`, where `x` is in the set of real numbers that fall in the interval from negative pi over 2 (exclusive of this boundary) to pi over 2 (inclusive of this boundary), the inequality `x` being less than or equal to the arcsine of `y` is equivalent to the sine of `x` being less than or equal to `y`. This theorem thus links the arcsine and sine functions through this inequality relationship on a specific interval for `x`.

For real numbers `x` in (-π/2, π/2] and `y`, the inequality `x ≤ arcsin(y)` is equivalent to `sin(x) ≤ y`.


theorem IsCompact.closure_eq_biUnion_inseparable :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] {K : Set X},
      IsCompact K → closure K = ⋃ x ∈ K, {y | Inseparable x y} :=
  by sorry

This theorem states that for any compact set `K` in a classical (T1) topological space `X`, the closure of `K` is equal to the union of all inseparable sets `{y | Inseparable x y}` for each `x` in `K`. In other words, the smallest closed set containing `K` is the union of all sets of points that are topologically inseparable from each point in `K`. Here, two points are called inseparable if they have the same neighborhoods.

The closure of a compact set in a T1 topological space is equal to the union of all inseparable sets with respect to each point in the set.


theorem Real.sin_pi_div_two_sub : ∀ (x : ℝ), Real.sin (Real.pi / 2 - x) = Real.cos x := by sorry

This theorem states that for all real numbers `x`, the sine of (π/2 minus `x`) equals the cosine of `x`. In mathematical notation, this theorem is expressing the identity sin(π/2 - x) = cos(x), which is a fundamental identity in trigonometry. Here, π/2 is half of the number π, which in Lean 4 is defined as twice a zero of the cosine function in the interval [1,2]. The real sine and cosine functions are defined as the real part of the complex sine and complex cosine functions respectively.

The sine of (π/2 - x) is equal to the cosine of x for all real numbers x.


theorem SimpleGraph.Walk.toDeleteEdges.proof_1 :
    ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set (Sym2 V)) {v w : V} (p : SimpleGraph.Walk G v w),
      (∀ e ∈ SimpleGraph.Walk.edges p, e ∉ s) →
        ∀ e ∈ SimpleGraph.Walk.edges p, e ∈ SimpleGraph.edgeSet (SimpleGraph.deleteEdges G s) :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of vertex type `V`, any set `s` of unordered pairs of vertices, and any walk `p` in `G` from vertex `v` to vertex `w`, if all edges in the walk `p` do not fall within the set `s`, then all edges in the walk `p` are present in the edge set of the graph obtained by deleting edges in `G` that correspond to the unordered pairs in `s`. In other words, if `p` is a walk in `G` whose edges are not in `s`, then `p` remains a walk in `G` after deletion of the edges specified by `s`.

For any simple graph `G` of type `V` and any walk `p` in `G` from vertex `v` to vertex `w` whose edges are not in the set `s` of unordered edge pairs, all edges in `p` are in the edge set of the graph obtained by deleting edges corresponding to `s`.


theorem pow_right_comm : ∀ {M : Type u} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = (a ^ n) ^ m := by sorry

This theorem, `pow_right_comm`, states that for any type `M` equipped with a monoid structure, the power operation is right-commutative. That is, for any element `a` of `M` and natural numbers `m` and `n`, raising `a` to the power of `m` and then to the power of `n` is the same as raising `a` to the power of `n` and then to the power of `m`. In other words, `(a ^ m) ^ n = (a ^ n) ^ m` holds for all `a` in `M` and `m, n` in `ℕ`.

For all types `M` with a monoid structure and all elements `a` in `M` and natural numbers `m` and `n`, `(a ^ m) ^ n = (a ^ n) ^ m`.


/-- The angle between a vector and the negation of another vector.  -/
theorem InnerProductGeometry.angle_neg_right :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      InnerProductGeometry.angle x (-y) = Real.pi - InnerProductGeometry.angle x y :=
  by sorry

This theorem states that in the realm of inner product spaces over real numbers, the undirected angle between a given vector 'x' and the negation of another vector 'y' is equal to π minus the undirected angle between 'x' and 'y'. It applies to all vectors 'x' and 'y' in any type 'V' that forms a normed additive commutative group and additionally has an inner product structure over real numbers. The angle is measured in radians and calculated using the standard Euclidean inner product definition.

In the context of real inner product spaces, the angle between a vector and its negation is twice the complement of their direct angle.


theorem CategoryTheory.Presieve.IsSheafFor.isAmalgamation :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSheafFor P R)
      {x : CategoryTheory.Presieve.FamilyOfElements P R} (hx : CategoryTheory.Presieve.FamilyOfElements.Compatible x),
      CategoryTheory.Presieve.FamilyOfElements.IsAmalgamation x
        (CategoryTheory.Presieve.IsSheafFor.amalgamate t x hx) :=
  by sorry

The theorem `CategoryTheory.Presieve.IsSheafFor.isAmalgamation` states that for any category `C`, any presheaf `P` of types over the opposite category of `C`, any object `X` in `C`, any presieve `R` on `X`, and any compatible family of elements `x` of the presheaf `P` over the presieve `R`, if `P` is a sheaf for the presieve `R`, then the amalgamation of the compatible family `x` is indeed an amalgamation of `x`.

In simpler terms, this theorem guarantees the existence and uniqueness of an amalgamation (a common "merging" element) for a compatible family of elements in a presheaf, given the presheaf is a sheaf for the presieve. This is a central concept in category theory, particularly in the understanding of sheaves.

Given a category `C`, a presheaf `P` over `C^op`, an object `X` in `C`, a presieve `R` on `X`, and a compatible family `x` of elements in `P` over `R`, if `P` is a sheaf for `R`, then the amalgamation of `x` exists and is unique in `P` over `X`.


theorem Isometry.preimage_setOf_dist :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x : α) (p : ℝ → Prop), f ⁻¹' {y | p (dist y (f x))} = {y | p (dist y x)} :=
  by sorry

The theorem `Isometry.preimage_setOf_dist` states that for all types `α` and `β` that are instances of PseudoMetricSpace, for all functions `f` from `α` to `β` that are isometries, and for all `x` in `α` and predicate `p` on real numbers, the preimage of the set of elements in `β` that satisfy predicate `p` with the distance to `f(x)` under the function `f` is exactly the set of elements in `α` that satisfy predicate `p` with the distance to `x`. In simpler terms, this means that an isometry `f` preserves the property of distance: the set of points in `α` that have a certain property with respect to their distance to `x` is mapped by `f` onto the set of points in `β` that have the same property with respect to their distance to `f(x)`.

For any isometry between PseudoMetricSpaces, the preimages of sets defined by distance conditions are equal under the isometry.


/-- Binary **rearrangement inequality**.  -/
theorem mul_add_mul_le_mul_add_mul :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c d : α} [inst_1 : ExistsAddOfLE α],
      a ≤ b → c ≤ d → a * d + b * c ≤ a * c + b * d :=
  by sorry

This theorem is known as the binary **rearrangement inequality**. It's a statement in the field of ordered semirings. It says that for any strict ordered semiring `α`, given any four elements `a, b, c, d` in `α` such that `a` is less than or equal to `b` and `c` is less than or equal to `d`, the sum of the product of `a` and `d` and the product of `b` and `c` is less than or equal to the sum of the product of `a` and `c` and the product of `b` and `d`. In mathematical notation, if $a \leq b$ and $c \leq d$, then $a \cdot d + b \cdot c \leq a \cdot c + b \cdot d$.

For any strict ordered semiring `α`, if `a ≤ b` and `c ≤ d` in `α`, then `a * d + b * c ≤ a * c + b * d`.


theorem Units.val_eq_one : ∀ {α : Type u} [inst : Monoid α] {a : αˣ}, ↑a = 1 ↔ a = 1 := by sorry

This theorem, named `Units.val_eq_one`, states that for any type `α` that has a monoid structure, and for any unit `a` of `α`, the value of `a` is equal to 1 if and only if `a` itself is equal to 1. In other words, in the context of a monoid, a unit `a` has a value of 1 exactly when `a` is the unit of the monoid.

For any monoid `α` and unit `a` in `α`, `a` equals 1 if and only if `a` is the identity element of the monoid.


theorem CategoryTheory.MonoidalCategory.associator_inv_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {X Y Z X' Y' Z' : C} (f : X ⟶ X') (g : Y ⟶ Y') (h : Z ⟶ Z'),
      CategoryTheory.CategoryStruct.comp
          (CategoryTheory.MonoidalCategory.tensorHom f (CategoryTheory.MonoidalCategory.tensorHom g h))
          (CategoryTheory.MonoidalCategory.associator X' Y' Z').inv =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
          (CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.tensorHom f g) h) :=
  by sorry

This theorem, `CategoryTheory.MonoidalCategory.associator_inv_naturality`, is a statement about the naturality of the inverse of the associator in a monoidal category. For any objects `X, Y, Z, X', Y', Z'` in a monoidal category `C` and morphisms `f : X ⟶ X'`, `g : Y ⟶ Y'`, and `h : Z ⟶ Z'`, the composition of the tensor product of `f` and the tensor product of `g` and `h` followed by the inverse of the associator of `X', Y', Z'` is equal to the composition of the inverse of the associator of `X, Y, Z` and the tensor product of the tensor product of `f` and `g` and `h`.

In mathematical terms, this corresponds to the following equality in the monoidal category `C`:
```
(f ⊗ (g ⊗ h)) ∘ α[X',Y',Z']⁻¹ = α[X,Y,Z]⁻¹ ∘ ((f ⊗ g) ⊗ h)
```
where `α[X,Y,Z]⁻¹` is the inverse of the associator of `X, Y, Z`, and `⊗` denotes the tensor product in the category.

The inverse of the associator in a monoidal category is natural, i.e., for any objects X, Y, Z, X', Y', Z' and morphisms f : X ⟶ X', g : Y ⟶ Y', h : Z ⟶ Z', we have (f ⊗ (g ⊗ h)) ∘ α[X',Y',Z']⁻¹ = α[X,Y,Z]⁻¹ ∘ ((f ⊗ g) ⊗ h).


theorem PartitionOfUnity.coe_finsupport :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X),
      ↑(PartitionOfUnity.finsupport ρ x₀) = Function.support fun i => (ρ i) x₀ :=
  by sorry

This theorem states that for a given partition of unity `ρ` on a set `s` in a topological space `X` and for a point `x₀` in `X`, the finite support of the partition of unity at `x₀` is equal to the set of indices `i` such that `(ρ i) x₀ ≠ 0`. In other words, `i` belongs to the finite support of `ρ` at `x₀` if and only if the value of the `i`-th function of the partition at `x₀` is non-zero.

For a partition of unity `ρ` on a set `s` in a topological space `X` and a point `x₀` in `X`, the finite support of `ρ` at `x₀` equals the set of indices `i` where `(ρ i) x₀` is non-zero.


theorem List.le_of_mem_argmax :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] {f : α → β} {l : List α} {a m : α},
      a ∈ l → m ∈ List.argmax f l → f a ≤ f m :=
  by sorry

The theorem `List.le_of_mem_argmax` states that for any types `α` and `β`, where `β` has a linear order, and for any function `f` from `α` to `β`, any list `l` of elements of type `α`, and any elements `a` and `m` of type `α`, if `a` is an element of `l` and `m` is an element returned by the `argmax` function when applied to `f` and `l`, then the value of `f` at `a` is less than or equal to the value of `f` at `m`. In simpler terms, it asserts that the value of the function at any element in a list is less than or equal to the value of the function at the maximum element of the list, where the maximum is determined by the `argmax` function.

For any type `α` and `β` with a linear order, and any function `f` from `α` to `β`, if `a` is an element in list `l` of type `α` and `m` is the `argmax` element of `f` and `l`, then `f a ≤ f m`.


theorem AddMonoidHom.coe_range :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N),
      ↑(AddMonoidHom.range f) = Set.range ⇑f :=
  by sorry

The theorem `AddMonoidHom.coe_range` states that for any `AddMonoidHom` `f` from an `AddGroup` `G` to another `AddGroup` `N`, the range of `f` when considered as an `AddSubgroup` of `N` (expressed as `AddMonoidHom.range f`) is the same as the set of all values in `N` that `f` can produce (expressed as `Set.range ⇑f`). In other words, the set of all possible outputs of the homomorphism `f` is the same whether we consider `f` as a function from `G` to `N` or as a function from `G` to the `AddSubgroup` of `N` generated by the image of `f`.

The range of an AddMonoidHom as an AddSubgroup of the target group is equal to the image of the homomorphism.


theorem Set.indicator_zero' : ∀ {α : Type u_1} (M : Type u_4) [inst : Zero M] {s : Set α}, Set.indicator s 0 = 0 := by
  sorry

The theorem `Set.indicator_zero'` states that for any type `α`, any type `M` that has a zero element (denoted by `[inst : Zero M]`), and any set `s` of type `Set α`, the indicator function of the set `s` with the constant zero function (i.e., `Set.indicator s 0`) is identically zero. In other words, regardless of whether an element is in the set `s` or not, the indicator function will always yield zero when combined with the constant zero function.

For any set `s` and type `α` with a zero element, the indicator function of `s` equals the constant zero function. That is, `Set.indicator s 0 = λ x : α, 0`.


theorem CategoryTheory.MorphismProperty.RespectsIso.cancel_right_isIso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.RespectsIso P →
        ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [inst_1 : CategoryTheory.IsIso g],
          P (CategoryTheory.CategoryStruct.comp f g) ↔ P f :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.RespectsIso.cancel_right_isIso` states that for any category `C` and a morphism property `P` that respects isomorphisms, given three objects `X`, `Y`, and `Z` in `C` and two morphisms `f : X ⟶ Y` and `g : Y ⟶ Z` where `g` is an isomorphism, the property `P` holds for the composition `f ≫ g` if and only if `P` holds for `f`. In other words, if we have a property of morphisms that is preserved under post-composition with an isomorphism, then testing that property on a composition is equivalent to testing it on the first morphism in the composition where the second morphism is an isomorphism.

For any category C and morphism property P respecting isomorphisms, if isomorphism g : Y ⟶ Z and morphisms f : X ⟶ Y and f ≫ g hold property P, then f also holds property P.


theorem Set.bounded_inter_not :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α},
      (∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m) →
        ∀ (a : α), Set.Bounded r (s ∩ {b | ¬r b a}) ↔ Set.Bounded r s :=
  by sorry

The theorem `Set.bounded_inter_not` states that for any type `α` and any binary relation `r` on elements of this type, and any set `s` of elements from this type, assuming a specific condition on the relation `r` holds, namely that for any two elements `a` and `b` of type `α`, there exists another element `m` such that for any element `c`, `c` being related to `a` or `b` implies `c` is also related to `m`, the boundedness of the intersection of set `s` and the set of elements not related to a given element `a` with respect to the relation `r`, is equivalent to the boundedness of set `s` itself with respect to the same relation `r`. Here, a set is considered bounded if there exists an element to which all elements of the set are related.

For a type `α` and binary relation `r` on `α`, if for any `a` in `α`, there exists an element `m` such that any `c` related to `a` or `m` implies `c` is related to `m`, then the intersection of a set `s` with the set of elements not related to a given `a` is bounded if and only if set `s` itself is bounded with respect to `r`.


theorem CategoryTheory.Limits.Cofork.IsColimit.π_desc' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {s : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s) {W : C} (k : Y ⟶ W)
      (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π s)
          (CategoryTheory.Limits.Cofork.IsColimit.desc hs k h) =
        k :=
  by sorry

This theorem in the Category Theory context asserts that for any category `C`, objects `X` and `Y` in `C`, and morphisms `f` and `g` from `X` to `Y`, given a cofork `s` on `f` and `g` that is a colimit in the category, and any object `W` in `C` with a morphism `k` from `Y` to `W` such that the composition `f ≫ k` equals `g ≫ k`, the composition of the projection from the cofork (denoted by `CategoryTheory.Limits.Cofork.π s`) and the descent from the colimit to `W` (denoted by `CategoryTheory.Limits.Cofork.IsColimit.desc hs k h`) is equal to the morphism `k`. This theorem captures a key property of colimits in category theory.

Given any category `C`, objects `X`, `Y`, morphisms `f`, `g` from `X` to `Y`, a cofork `s` on `f` and `g` that is a colimit in `C`, and a morphism `k` from `Y` to an object `W` such that `f ≫ k = g ≫ k`, the projection from the cofork and the descent to `W` are equal to `k`.


theorem LinearOrderedField.cutMap_bddAbove :
    ∀ {α : Type u_2} (β : Type u_3) [inst : LinearOrderedField α] [inst_1 : LinearOrderedField β]
      [inst_2 : Archimedean α] (a : α), BddAbove (LinearOrderedField.cutMap β a) :=
  by sorry

This theorem states that for all types `α` and `β`, if `α` is a linearly ordered field, `β` is also a linearly ordered field, and `α` is Archimedean, then for any element `a` of type `α`, the set of all elements of type `β` that are less than `a` (as defined by the `LinearOrderedField.cutMap` function) is bounded above. In other words, there exists an upper bound for this set. This is true for any linearly ordered field that satisfies the Archimedean property, such as the real numbers.

For any linearly ordered fields `α` and `β` with `α` Archimedean, the set of elements in `β` less than an arbitrary element in `α` is bounded above.


theorem Multiset.dedup_cons_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α},
      a ∈ s → Multiset.dedup (a ::ₘ s) = Multiset.dedup s :=
  by sorry

The theorem `Multiset.dedup_cons_of_mem` states that for any type `α` with a decidable equality relation, and for any element `a` of type `α` and multiset `s` of type `α`, if `a` is a member of `s`, then removing duplicates from the multiset that results from consing `a` onto `s` (i.e., adding `a` to `s`) is equal to just removing duplicates from `s`. In other words, if `a` is already in `s`, adding another `a` to `s` before removing duplicates doesn't change the end result.

For any type `α` with decidable equality and any multiset `s` of type `α` and element `a` in `s`, the multisets obtained by removing duplicates from `s` and from `s.insert a` are equal.


theorem Set.nonempty_of_nonempty_subtype : ∀ {α : Type u} {s : Set α} [inst : Nonempty ↑s], Set.Nonempty s := by sorry

This theorem, named `Set.nonempty_of_nonempty_subtype`, states that for any type `α` and any set `s` of type `α`, if the subtype induced by `s` is nonempty (i.e., there exists an element in `s`), then the set `s` itself is nonempty. In other words, if we can find an element within the subset of the universe defined by `s`, it implies that `s` is not an empty set. The proof of this theorem is not provided here.

If a subtype of a type `α` is nonempty, then the underlying set is nonempty.


theorem AbsoluteValue.sum_le :
    ∀ {ι : Type u_1} {R : Type u_8} {S : Type u_9} [inst : Semiring R] [inst_1 : OrderedSemiring S]
      (abv : AbsoluteValue R S) (s : Finset ι) (f : ι → R),
      abv (Finset.sum s fun i => f i) ≤ Finset.sum s fun i => abv (f i) :=
  by sorry

The theorem `AbsoluteValue.sum_le` states that for any semiring `R`, ordered semiring `S`, absolute value function `abv : AbsoluteValue R S`, finite set `s : Finset ι`, and function `f : ι → R`, the absolute value of the sum of `f i` as `i` ranges over the elements of the finite set `s` is less than or equal to the sum of the absolute values of `f i` over the same set `s`. In math terms, it says that for any absolute value and any finite sum, the absolute value of the sum is less than or equal to the sum of the absolute values. This captures the idea of the triangle inequality for finite sums.

For any semiring `R` with absolute value function `abv`, ordered semiring `S`, finite set `s`, and function `f : ι → R`, the absolute value of the sum of `f i` over `s` is less than or equal to the sum of the absolute values of `f i` over `s`. (In mathematical notation: `∫in s abv (∑i in s f i) ≤ ∑i in s abv (fi)`)


theorem ENNReal.div_lt_top : ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ 0 → x / y < ⊤ := by sorry

This theorem states that for any two extended nonnegative real numbers `x` and `y`, if `x` is not infinity and `y` is not zero, then the result of `x / y` is finite, i.e., it is less than infinity. In other words, as long as you're not dividing an infinite number by a finite one, the result of division in the extended nonnegative real numbers will stay finite.

For any extended nonnegative real numbers `x` and `y` with `y ≠ 0`, the quotient `x / y` is a finite nonnegative real number.


theorem MeasureTheory.aecover_Ici :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : Preorder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a : ι → α},
      Filter.Tendsto a l Filter.atBot → MeasureTheory.AECover μ l fun i => Set.Ici (a i) :=
  by sorry

The theorem `MeasureTheory.aecover_Ici` states that for any preordered, topological type `α` that also has order-closed topology and is an open measurable space, and for any function `a` from some type `ι` into `α`, if `a` tends to negative infinity (`Filter.atBot`) along a filter `l` on `ι`, then the function `i => Set.Ici (a i)` creates an almost everywhere cover (or: AECover) of the measure space determined by measure `μ` and the same filter `l`.

Here, the "almost everywhere cover" or AECover refers to a collection of sets indexed by `ι`, such that almost every point in the measure space is in one of the sets for large enough index according to the order on `ι`. The "tends to negative infinity" (`Filter.atBot`) concept signifies that for each real number, all sufficiently large elements in the sequence `a` are less than or equal to this number. The function `i => Set.Ici (a i)` generates the set of all elements in `α` that are greater than or equal to `a i` for each `i` in `ι`.

Given a preordered, topological space α with order-closed topology and measurable structures, if a function from ι to α tends to negative infinity along filter l, then the family {Set.Ici (ai) | i ∈ ι} forms an almost everywhere cover of the measure space determined by measure μ and filter l.


theorem Set.leftInverse_rangeSplitting :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β),
      Function.LeftInverse (Set.rangeFactorization f) (Set.rangeSplitting f) :=
  by sorry

The theorem `Set.leftInverse_rangeSplitting` states that for any function `f` from type `α` to type `β`, the function `Set.rangeFactorization f` is a left inverse to the function `Set.rangeSplitting f`. This means that if you apply `Set.rangeFactorization f` followed by `Set.rangeSplitting f` to any input, you get the same input back, i.e., `(Set.rangeSplitting f) ∘ (Set.rangeFactorization f) = id`. In other words, if you first factor through the range of `f` and then pick a preimage for every element in the range of `f`, you end up where you started.

For any function `f` from type `α` to type `β`, `Set.rangeSplitting f ∘ Set.rangeFactorization f = id`.


Order.Ideal.directed

theorem Order.Ideal.directed :
    ∀ {P : Type u_1} [inst : LE P] (s : Order.Ideal P), DirectedOn (fun x x_1 => x ≤ x_1) ↑s := by sorry

This theorem states that for any type `P` equipped with a less than or equal to order (`≤`), and for any ideal `s` in this order, the ideal is directed. In other words, for any two elements `x` and `y` in the ideal `s`, there exists another element `z` in `s` such that `x ≤ z` and `y ≤ z`. This property is known as being directed for a set with respect to an order.

For any ideal in a type equipped with a total order, the ideal is directed. That is, for any two elements in the ideal, there exists another element in the ideal that is greater than or equal to both.


theorem le_ciInf_add_ciInf :
    ∀ {α : Type u_1} {ι : Sort u_2} {ι' : Sort u_3} [inst : Nonempty ι] [inst : Nonempty ι']
      [inst : ConditionallyCompleteLattice α] [inst_1 : AddGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α} {g : ι → α}
      {h : ι' → α}, (∀ (i : ι) (j : ι'), a ≤ g i + h j) → a ≤ iInf g + iInf h :=
  by sorry

This theorem states that for any types `α`, `ι`, and `ι'`, given that `ι` and `ι'` are both nonempty and `α` forms a conditionally complete lattice and an additive group, and if `α` has the property that for any two elements `x` and `x_1`, the operation `(x + x_1)` is covariant with respect to the order relation `≤` (both when considered in the usual order and when the operation is swapped), then for any element `a` of `α` and any two functions `g : ι → α` and `h : ι' → α`, if `a` is less than or equal to the sum of `g i` and `h j` for any `i` in `ι` and `j` in `ι'`, then `a` is also less than or equal to the infimum of the range of `g` plus the infimum of the range of `h`.

In mathematical terms, if `a ≤ g(i) + h(j)` for all `i` and `j`, then `a ≤ inf g + inf h`, where `inf` denotes the infimum (greatest lower bound) over the range of the function.

If `α` is a conditionally complete lattice and additive group, `ι` and `ι'` are nonempty, `a ≤ g(i) + h(j)` for all `i ∈ ι` and `j ∈ ι'`, and the addition operation is covariant with respect to the order relation `≤` in `α`, then `a ≤ inf(g) + inf(h)`.


theorem IsUnit.eq_div_iff : ∀ {α : Type u} [inst : DivisionMonoid α] {a b c : α}, IsUnit c → (a = b / c ↔ a * c = b) :=
  by sorry

This theorem, `IsUnit.eq_div_iff`, states that for any division monoid `α` and any elements `a`, `b`, and `c` of `α`, if `c` is a unit (meaning `c` has a two-sided inverse), then `a` is equal to `b` divided by `c` if and only if `a` multiplied by `c` is equal to `b`. In other words, in the context of a division monoid, division and multiplication by a unit element are interchangeable operations.

In a division monoid, for all `a`, `b`, and `c` (with `c` being a unit), `a = b / c` if and only if `a * c = b`.


List.Sublist.antisymm

theorem List.Sublist.antisymm : ∀ {α : Type u} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.Sublist l₂ l₁ → l₁ = l₂ := by
  sorry

This theorem, `List.Sublist.antisymm`, states that for all types `α` and any pair of lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂` and `l₂` is a sublist of `l₁`, then `l₁` must be equal to `l₂`. In other words, the sublist relation on lists of any given type is antisymmetric: it cannot be the case that two different lists are sublists of each other.

If `l₁` is a sublist of `l₂` and `l₂` is a sublist of `l₁`, then `l₁` = `l₂`.


theorem le_map_div_add_map_div :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : Group α]
      [inst_2 : AddCommSemigroup β] [inst_3 : LE β] [inst_4 : MulLEAddHomClass F α β] (f : F) (a b c : α),
      f (a / c) ≤ f (a / b) + f (b / c) :=
  by sorry

The theorem `le_map_div_add_map_div` states that for all types `F`, `α`, and `β`, where `F` is a `FunLike` from `α` to `β`, `α` forms a group, `β` forms an additive commutative semigroup and is orderable, and `F` is a multiplication-to-addition homomorphism, the function `f` applied to the division of `a` and `c` (i.e., `f(a/c)`) is less than or equal to the function `f` applied to the division of `a` and `b` (i.e., `f(a/b)`) plus the function `f` applied to the division of `b` and `c` (i.e., `f(b/c)`), for any elements `a`, `b`, and `c` of `α`. In mathematical notation, this is saying that for all `f`, `a`, `b`, and `c`, we have `f(a/c) ≤ f(a/b) + f(b/c)`.

For any `FunLike` function `f` from a group `α` to an additive commutative semigroup and orderable type `β`, `f(a/c) ≤ f(a/b) + f(b/c)` for all `a, b, c` in `α`.


theorem Ring.mul_inverse_rev' :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a b : M₀},
      Commute a b → Ring.inverse (a * b) = Ring.inverse b * Ring.inverse a :=
  by sorry

This theorem states that for any type `M₀` that is a monoid with zero, given two elements `a` and `b` from `M₀` that commute (i.e., `a * b = b * a`), the inverse of the product `a * b` is equal to the product of the inverse of `b` and the inverse of `a`. Here, the `Ring.inverse` function is used to get the inverse of an element if it is invertible, or zero otherwise. In mathematical notation, this can be written as $(ab)^{-1} = b^{-1}a^{-1}$ under the assumption that $ab = ba$.

Given a monoid `M₀` with zero, if `a` and `b` are commuting elements with inverses in `M₀`, then `(a * b)^-1 = b^-1 * a^-1`.


/-- A simplification of `padicValNat` when one input is prime, by analogy with
`padicValRat_def`.  -/
theorem padicValNat_def :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} (hn : 0 < n), padicValNat p n = (multiplicity p n).get ⋯ := by sorry

The theorem `padicValNat_def` states that for any prime number `p` and any natural number `n` greater than zero, the `p`-adic valuation of `n`, which is the largest natural number `k` such that `p^k` divides `n`, is equal to the multiplicity of `p` in `n`, i.e., the largest natural number `n` such that `p^n` divides `n`. In essence, it simplifies the calculation of the `p`-adic valuation when the input is a prime number, mirroring the definition of `padicValRat_def`.

For any prime number p and natural number n > 0, the p-adic valuation of n equals the multiplicity of p as a divisor of n.


theorem FiniteDimensional.of_finrank_eq_succ :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {n : ℕ},
      FiniteDimensional.finrank K V = Nat.succ n → FiniteDimensional K V :=
  by sorry

This theorem states that for any division ring `K` and any additively commutative group `V` that is also a module over `K`, if the rank of `V` as a `K`-module (expressed as a natural number) is equal to the successor of another natural number `n`, then `V` is a finite-dimensional vector space over `K`. In other words, if the finite rank of the module `V` over `K` is `n+1`, then `V` is finite-dimensional over `K`.

If a module over a division ring has finite rank equal to the successor of a natural number, then it is finite-dimensional.


theorem iInf_union :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s t : Set β},
      ⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x :=
  by sorry

The theorem `iInf_union` states that for any types `α` and `β`, where `α` forms a complete lattice, and any function `f` from `β` to `α`, and any sets `s` and `t` of elements of type `β`, the infimum (greatest lower bound) of the function `f` over the union of `s` and `t` is equal to the infimum of `f` over `s` intersected with the infimum of `f` over `t`. This can be symbolized as: $\inf_{x \in s \cup t} f(x) = \inf_{x \in s} f(x) \land \inf_{x \in t} f(x)$.

The infimum of a function from a complete lattice to itself, over the union of two sets, equals the infimum over each set taken individually.


/-- **Alias** of the reverse direction of `Asymptotics.isBigO_neg_left`. -/
theorem Asymptotics.IsBigO.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

This theorem, named `Asymptotics.IsBigO.neg_left`, is an alias of the reverse direction of `Asymptotics.isBigO_neg_left`. It states that for any types `α`, `F`, and `E'`, with `F` being normed and `E'` being a semi-normed add commutative group, and any functions `g : α → F` and `f' : α → E'`, if `f'` is big-O of `g` at some filter `l` (written as `f' =O[l] g`), then the negation of `f'` is also big-O of `g` at the same filter. In mathematical terms, if `f'` is asymptotically bounded by `g`, then `-f'` is also asymptotically bounded by `g`.

If `f'` is big-O of `g` at filter `l`, then `-f'` is also big-O of `g` at filter `l`. In other words, the negative of a big-O function is still big-O of the original function.


theorem Asymptotics.isLittleO_pow_pow :
    ∀ {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {m n : ℕ}, m < n → (fun x => x ^ n) =o[nhds 0] fun x => x ^ m := by
  sorry

The theorem `Asymptotics.isLittleO_pow_pow` states that for any normed division ring `𝕜` and for any two natural numbers `m` and `n` such that `m` is less than `n`, the function `fun x => x ^ n` is little-o of the function `fun x => x ^ m` at a neighbourhood of 0. In other words, as `x` approaches 0, the growth rate of the function `x ^ n` is significantly smaller than that of the function `x ^ m`.

For any normed division ring 𝕜 and natural numbers m < n, the function x => x^n is little-o of the function x => x^m as x approaches 0.


theorem OpenEmbedding.toPartialHomeomorph_target :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
      (h : OpenEmbedding f) [inst_2 : Nonempty X], (OpenEmbedding.toPartialHomeomorph f h).target = Set.range f :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with topological spaces, and a function `f` from `X` to `Y`, if `f` is an open embedding and `X` is nonempty, then the target of the partial homeomorphism obtained from this open embedding via `OpenEmbedding.toPartialHomeomorph` is equal to the range of `f`. In other words, the set of points in `Y` that are the image of the partial homeomorphism are exactly the set of points in `Y` that are mapped by `f` from some point in `X`.

If `f` is an open embedding from a nonempty topological space `X` to `Y`, then the range of `f` equals the image of the partial homeomorphism obtained from `f`.


theorem Set.iUnion_or :
    ∀ {α : Type u_1} {p q : Prop} (s : p ∨ q → Set α), ⋃ (h : p ∨ q), s h = (⋃ (i : p), s ⋯) ∪ ⋃ (j : q), s ⋯ := by
  sorry

This theorem, named `Set.iUnion_or`, states that for any type `α` and for any two propositions `p` and `q`, given a set `s` that is defined for the disjunction (or operation) `p ∨ q`, the indexed union over `s` for the condition `p ∨ q` is equal to the union of the indexed union over `s` for the condition `p` and the indexed union over `s` for the condition `q`. In other words, it is saying that we can distribute the "indexed union" operation over the "or" operation.

For any type `α` and propositions `p` and `q` over a set `s`, the indexed union of `s` over `p lor q` equals the indexed union of `s` over `p` union the indexed union of `s` over `q`. (Here, `lor` is Lean's notation for the disjunction (or) operation.)


theorem Nat.ceil_one : ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α], ⌈1⌉₊ = 1 := by
  sorry

This theorem states that for any type `α` which has the properties of a Linear Ordered Semiring and a Floor Semiring, the ceiling function of `1` always equals `1`. In other words, for all these types `α`, the smallest integer that is greater than or equal to `1` is `1` itself. This is generally applicable to any number system that satisfies the properties of a Linear Ordered Semiring and a Floor Semiring.

For any type `α` that is both a Linear Ordered Semiring and a Floor Semiring, the ceiling function of `1` equals `1` (i.e., `ceiling 1 = 1`).


theorem Order.Iio_succ :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [inst_2 : NoMaxOrder α] (a : α),
      Set.Iio (Order.succ a) = Set.Iic a :=
  by sorry

This theorem states that for any type `α` that is preordered, has an operation for finding the successor of an element (`SuccOrder`), and does not have a maximum element (`NoMaxOrder`), the left-infinite right-open interval ending at the successor of any element `a` is the same as the left-infinite right-closed interval ending at `a`. In simpler terms, the set of elements less than the successor of `a` is identical to the set of elements less than or equal to `a`.

For any preordered type `α` without a maximum element, the left-open interval `(−∞, Succ a)` is equal to the left-closed interval `[−∞, a]`.


theorem DFinsupp.sigmaUncurry_apply :
    ∀ {ι : Type u} {α : ι → Type u_2} {δ : (i : ι) → α i → Type v} [inst : (i : ι) → (j : α i) → Zero (δ i j)]
      [inst_1 : (i : ι) → DecidableEq (α i)] [inst_2 : (i : ι) → (j : α i) → (x : δ i j) → Decidable (x ≠ 0)]
      (f : Π₀ (i : ι) (j : α i), δ i j) (i : ι) (j : α i), (DFinsupp.sigmaUncurry f) { fst := i, snd := j } = (f i) j :=
  by sorry

The theorem `DFinsupp.sigmaUncurry_apply` states that for all types `ι`, a function `α`, a type `δ` that depends on `ι` and `α`, where each `δ` has a zero and where the equality of elements of `α` and non-zero-ness of elements of `δ` is decidable, given a generalized double finitely supported function `f` from `ι` and `α` to `δ`, and given an element of `ι` and an element of `α`, uncurrying `f` with a sigma-type `{fst := i, snd := j}` is equivalent to simply applying `f` to `i` and `j`. In simpler terms, it means that uncurrying a double finitely supported function and then applying it to a pair is the same as applying the function to each element of the pair.

For any type ι, function α → δ, and given a generalized double finitely supported function f from ι × α to δ, uncurrying f with sigma-type {fst := i, snd := j} equals applying f to (i, j).


theorem Ring.DirectLimit.induction_on :
    ∀ {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → CommRing (G i)]
      {f : (i j : ι) → i ≤ j → G i → G j} [inst_2 : Nonempty ι] [inst_3 : IsDirected ι fun x x_1 => x ≤ x_1]
      {C : Ring.DirectLimit G f → Prop} (z : Ring.DirectLimit G f),
      (∀ (i : ι) (x : G i), C ((Ring.DirectLimit.of G f i) x)) → C z :=
  by sorry

This theorem is about direct limits in the category of rings. It states that for any preorder `ι`, any indexed family of commutative rings `G : ι → Type w`, any transition maps `f : (i j : ι) → i ≤ j → G i → G j`, and a property `C` of elements in the direct limit ring, if `C` holds for every element in the image of the canonical map `Ring.DirectLimit.of G f i` for each `i`, then `C` holds for every element in the direct limit ring `Ring.DirectLimit G f`. In essence, it provides a principle of induction on the construction of the direct limit. This theorem is fundamental in the theory of direct limits and allows one to prove properties of the whole direct limit based on the properties of its parts.

If `C` is a property of elements in the direct limit of an indexed family of commutative rings `G : ι → Type w` and `C` holds for the image of the canonical map for each `i`, then `C` holds for every element in the direct limit ring.


theorem Nat.bit0_inj : ∀ {n m : ℕ}, bit0 n = bit0 m → n = m := by sorry

This theorem, `Nat.bit0_inj`, states that for any two natural numbers `n` and `m`, if the doubling of `n` is equal to the doubling of `m` (expressed as `bit0 n = bit0 m`), then `n` must be equal to `m`. This essentially asserts the injectivity of the `bit0` operation on natural numbers, meaning that different natural numbers map to different doubled values. In other words, no two distinct natural numbers will have the same doubled value.

If for natural numbers `n` and `m`, `2 * n = 2 * m`, then `n = m`.


theorem PFun.coe_comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β), ↑(g ∘ f) = PFun.comp ↑g ↑f := by sorry

This theorem, `PFun.coe_comp`, states that for any three types, α, β, and γ, and for any two functions, g, which maps from β to γ, and f, which maps from α to β, the composition of these two functions when considered as partial functions (i.e., `↑(g ∘ f)`) is equal to the composition of these two functions considered as partial functions individually (`PFun.comp ↑g ↑f`). Here, `PFun.comp` denotes the composition of partial functions as a partial function, and ↑ denotes the coercion of a function to a partial function.

For any functions f : α -> β and g : β -> γ, the coercions of their composition g ∘ f to a partial function are equal: ↑(g ∘ f) = PFun.comp ↑g ↑f.