theorem Submodule.torsionBySet_span_singleton_eq :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : R),
      Submodule.torsionBySet R M ↑(Submodule.span R {a}) = Submodule.torsionBy R M a :=
  by sorry

The theorem `Submodule.torsionBySet_span_singleton_eq` states that for any commutative semiring `R`, any additive commutative monoid `M` that is also an `R`-module, and any element `a` of `R`, the submodule of `M` consisting of all elements `x` such that `a • x = 0` for all `a` in the span of the singleton set `{a}` is the same as the `a`-torsion submodule, which consists of all elements `x` of `M` such that `a • x = 0`. Essentially, this theorem states that the torsion by a set generated by an element `a` is the same as the torsion by the element `a` itself.

For any commutative semiring R, additive commutative monoid M being an R-module, and element a in R, the submodule of M consisting of elements x with a • x = 0 for all a in the span of {a} equals the a-torsion submodule of M, which consists of elements x with a • x = 0.


/-- A set is complete iff its image under a uniform inducing map is complete.  -/
theorem isComplete_image_iff :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {m : α → β} {s : Set α},
      UniformInducing m → (IsComplete (m '' s) ↔ IsComplete s) :=
  by sorry

This theorem states that a set is complete if and only if its image under a uniform inducing map is complete. More specifically, for any two types `α` and `β` that have uniform space structures, any function `m` from `α` to `β`, and any set `s` of type `α`, if `m` is a uniform inducing function, then the set `s` is complete if and only if the image of `s` under `m` (denoted as `m '' s`) is complete. In mathematical terms, a set `s` is complete if every Cauchy filter `f` such that `s` belongs to `f`, has a limit in `s`.

A set is complete if and only if its uniform image under a uniform inducing function is a complete subset.


/-- Pythagorean theorem, subtracting vectors, if-and-only-if vector
inner product form.  -/
theorem norm_sub_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
      ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0 :=
  by sorry

This is a generalization of the Pythagorean theorem to the realm of real inner product spaces. It states that for any two vectors 'x' and 'y' in a real inner product space F, the square of the norm of the vector obtained by subtracting 'y' from 'x' equals the sum of the squares of the norms of 'x' and 'y' if and only if the real inner product of 'x' and 'y' is zero. In other words, 'x' and 'y' are orthogonal (the angle between them is 90 degrees) if and only if the squared length of the difference vector equals the sum of the squared lengths of the original vectors.

In a real inner product space, two vectors are orthogonal if and only if the square of the norm of their difference is equal to the sum of the squares of their norms.


theorem le_mul_of_one_le_of_le :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      1 ≤ a → b ≤ c → b ≤ a * c :=
  by sorry

The theorem `le_mul_of_one_le_of_le` states that for any type `α` that has multiplication and a one element (`MulOneClass`), a preorder relationship (transitivity and reflexivity), and is covariant (preserving order under multiplication), given any three elements `a`, `b`, and `c` of the type `α`, if `1` is less than or equal to `a`, and `b` is less than or equal to `c`, then `b` is less than or equal to the product of `a` and `c`. In other words, this theorem is about the order-preserving property of multiplication in a certain class of mathematical structures.

If `α` is a type with multiplication, a one element `1`, a preorder relation that is transitive, reflexive, and covariant, then `1 ≤ a` and `b ≤ c` imply `b ≤ a * c`.


theorem Monoid.fg_of_surjective :
    ∀ {M : Type u_1} [inst : Monoid M] {M' : Type u_3} [inst_1 : Monoid M'] [inst_2 : Monoid.FG M] (f : M →* M'),
      Function.Surjective ⇑f → Monoid.FG M' :=
  by sorry

The theorem `Monoid.fg_of_surjective` states that for all types `M` and `M'` where `M` and `M'` are monoids (i.e., they satisfy the algebraic structure of a monoid), and where `M` is finitely generated (notated as `Monoid.FG M`), if there exists a surjective (onto) monoid homomorphism `f` from `M` to `M'` (notated as `f : M →* M'`), then `M'` is also finitely generated. In other words, the surjectivity of a monoid homomorphism from a finitely generated monoid guarantees that the codomain is also finitely generated.

If `M` is a finitely generated monoid and there exists a surjective monoid homomorphism from `M` to `M'`, then `M'` is also finitely generated.


theorem CircleDeg1Lift.le_map_map_zero : ∀ (f g : CircleDeg1Lift), f 0 + ↑⌊g 0⌋ ≤ f (g 0) := by sorry

This theorem states that for any two functions `f` and `g` of type `CircleDeg1Lift`, the sum of the output of `f` at zero and the integer part of the output of `g` at zero is always less than or equal to the output of `f` at the point where `g` outputs zero. In mathematical terms, for all `f` and `g`, we have `f(0) + ⌊g(0)⌋ ≤ f(g(0))`.

For all functions `f` and `g` of type `CircleDeg1Lift`, the relationship `f(0) + ⌊g(0)⌋ ≤ f(g(0))` holds.


theorem Lagrange.eval_nodal :
    ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} {s : Finset ι} {v : ι → R} {x : R},
      Polynomial.eval x (Lagrange.nodal s v) = Finset.prod s fun i => x - v i :=
  by sorry

The theorem `Lagrange.eval_nodal` states that for any commutative ring `R`, any finite set `s`, any function `v` mapping from the set to the ring, and any element `x` of the ring, the evaluation of the nodal polynomial (defined by `s` and `v`) at `x` is equivalent to the product of `x - v i` for each element `i` in `s`. In mathematical terms, if we have a polynomial constructed using the nodes defined by `v` and `s`, when we substitute `x` into this polynomial, the result is the product of `x - v i` taken over all `i` in the finite set `s`.

For any commutative ring R, finite set s, and function v from s to R, the evaluation of the nodal polynomial constructed from s and v at an element x of R equals the product of (x - v i) for all i in s.


theorem PosNum.of_to_nat : ∀ (n : PosNum), ↑↑n = Num.pos n := by sorry

This theorem states that for every positive number `n`, the double-coercion of `n` (which converts it first into a natural number and then into a number) gives the positive version of `n`. In other words, converting a positive number to a natural number and then to a generic number preserves its positivity. This can be symbolically represented in LaTeX as, for all positive numbers $n$, we have $n = \text{Num.pos} \ n$.

For every positive number `n` in Lean, the double-coercion `n` to natural number and then to number equals the positive version of `n`. In mathematical notation, for all positive numbers $n$, we have $\text{Num.pos}\ n = n$.


theorem Disjoint.left_le_of_le_sup_right :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α}, a ≤ b ⊔ c → Disjoint a c → a ≤ b := by
  sorry

This theorem states that for any type `α` that forms a distributive lattice with a least element (represented by `⊥`), given three elements `a`, `b`, and `c` of this type, if `a` is less than or equal to the supremum (join) of `b` and `c`, and `a` and `c` are disjoint (meaning the greatest lower bound (infimum or meet) of `a` and `c` is the least element `⊥`), then `a` is less than or equal to `b`. In other words, if `a` is below `b` joined with `c` and doesn't intersect with `c`, it must be below `b`.

If `α` is a distributive lattice with a least element, and `a ≤ b ∨ c`, `a ∧ c = ⊥`, then `a ≤ b`.


theorem AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
      {f : X ⟶ Y} (H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f) (U : TopologicalSpace.Opens ↑↑X),
      Opposite.op U =
        Opposite.op
          ((TopologicalSpace.Opens.map f.base).obj
            (Opposite.op ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.openFunctor H).obj U)).unop) :=
  by sorry

This theorem states that for any category 'C', presheaved spaces 'X' and 'Y' over 'C', and morphism 'f' from 'X' to 'Y' which is an open immersion, and for any open set 'U' in the topological space underlying 'X', the opposite of 'U' is equal to the opposite of the object obtained by first applying the functor associated with the open immersion to 'U', then applying the preimage functor associated with 'f' to the result, and finally taking the underlying set of the result. This essentially asserts a certain commutativity property for the process of taking preimages of open sets under open immersions in the category of presheaved spaces.

For any open immersion $f : X \to Y$ between presheaves over a category $C$, and any open set $U$ in the underlying topological space of $X$, we have $U^op = (f(U))^op \cap X^op$, where $A^op$ denotes the opposite of an object $A$.


theorem Polynomial.natDegree_C_mul_X :
    ∀ {R : Type u} [inst : Semiring R] (a : R), a ≠ 0 → Polynomial.natDegree (Polynomial.C a * Polynomial.X) = 1 := by
  sorry

The theorem `Polynomial.natDegree_C_mul_X` states that for any non-zero element `a` of a semiring `R`, the natural degree of the polynomial obtained by multiplying the constant polynomial `a` and the polynomial variable `X` is equal to 1. This essentially means that the degree of a monomial (a product of a constant and a variable) is the power to which the variable is raised, which in this case is 1.

The natural degree of the polynomial resulting from multiplying a non-zero constant `a` with the polynomial variable `X` is 1.


theorem Finset.sdiff_eq_empty_iff_subset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s \ t = ∅ ↔ s ⊆ t := by sorry

The theorem `Finset.sdiff_eq_empty_iff_subset` states that for any type `α` with decidable equality, and for any two finite sets `s` and `t` of type `α`, the set difference of `s` and `t` being an empty set is equivalent to `s` being a subset of `t`. In other words, it asserts that all elements of `s` are in `t` if and only if there are no elements in `s` that are not in `t`.

For finite sets `s` and `t` of type `α` with decidable equality, `s \ t = ∅` if and only if `s ⊆ t`.


theorem Polynomial.natDegree_C_mul_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (a : R),
      a ≠ 0 → Polynomial.natDegree (Polynomial.C a * Polynomial.X ^ n) = n :=
  by sorry

The theorem `Polynomial.natDegree_C_mul_X_pow` states that for any semiring `R`, any natural number `n`, and any element `a` of this semiring `R` that is not zero, the natural degree of the polynomial obtained by multiplying the constant polynomial `a` and the polynomial variable `X` raised to the power `n` is `n`. In other words, the degree of a non-zero constant times a variable raised to a certain power is equal to that power within the context of polynomial mathematics.

For any semiring R, natural number n, and non-zero element a in R, the degree of the polynomial a * X^n is n.


theorem convexHull_empty :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E],
      (convexHull 𝕜) ∅ = ∅ :=
  by sorry

The theorem `convexHull_empty` states that for any ordered semiring `𝕜` and any type `E` which is an additive commutative monoid and also a module over `𝕜`, the convex hull of the empty set is the empty set. In other words, if we try to form the smallest convex set that includes no elements (i.e., the empty set), we end up with the empty set itself.

The convex hull of the empty set is the empty set for an ordered semiring `𝕜`, an additive commutative monoid `E`, and a `𝕜`-module `E`.


theorem Equiv.Perm.two_le_of_mem_cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ},
      n ∈ Equiv.Perm.cycleType σ → 2 ≤ n :=
  by sorry

This theorem states that for any given type `α` (which is finite and has a decidable equality), any permutation `σ` of `α`, and any natural number `n`, if `n` is a member of the cycle type of the permutation `σ`, then `n` must be greater than or equal to 2. In mathematical terms, the cycle type of a permutation `σ` is a multiset of nonnegative integers, and this theorem asserts that every integer in this multiset is at least 2.

For any finite type `α` with decidable equality, if `σ` is a permutation of `α` and `n` is a cycle length of `σ`, then `n` ≥ 2.


Odd.neg

theorem Odd.neg : ∀ {α : Type u_2} [inst : Ring α] {a : α}, Odd a → Odd (-a) := by sorry

The theorem `Odd.neg` states that for any type `α` that is a ring, if an element `a` of `α` is odd (i.e., there exists a number `k` such that `a` equals `2*k + 1`), then the negative of `a` (denoted as `-a`) is also odd. In other words, the negation of an odd number in a ring is also an odd number.

If `a` is an odd element in a ring `α`, then `-a` is also an odd element.


theorem Mathlib.Order.Filter.SmallSets._auxLemma.11 :
    ∀ {α : Type u} {p : α → Prop}, (∀ᶠ (x : α) in ⊤, p x) = ∀ (x : α), p x := by sorry

This theorem states that for any type `α` and any property `p` that elements of `α` can have, the proposition that "almost every element `x` of type `α` satisfies `p`" is equivalent to the proposition that "every element `x` of type `α` satisfies `p`". In more traditional mathematical terms, if `p` is a predicate over a set `α`, then the statement "for almost every `x` in `α`, `p(x)` holds" is equivalent to "for all `x` in `α`, `p(x)` holds". Here, the 'almost-every' stipulation is defined with respect to the trivial filter `⊤`, which in this context simply means "all of `α`".

For any type `α` and property `p` over `α`, the statement "for almost all `x` in `α`, `p(x)` holds" is equivalent to "for all `x` in `α`, `p(x)` holds".


theorem Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.59 :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop},
      (∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) :=
  by sorry

This theorem, `Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.59`, states that for every type `α` and `β`, every filter `f` over `α`, every function `m` from `α` to `β`, and every predicate `P` over `β`, the property that for almost every `b` in the filter obtained by mapping `f` through `m`, `P` holds, is equivalent to the property that for almost every `a` in the filter `f`, `P` holds after applying `m` to `a`. In other words, the event of `P` happening "almost everywhere" in the mapped filter is identical to the event of `P` happening "almost everywhere" in the original filter, after the values are mapped.

For every filter `f` over type `α`, function `m` from `α` to `β`, and predicate `P` over `β`, the property that for almost every `b` in `f.map m`, `P(b)` holds if and only if for almost every `a` in `f`, `P(m a)` holds.


HasDerivWithinAt.comp

theorem HasDerivWithinAt.comp :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {s : Set 𝕜} {𝕜' : Type u_1}
      [inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] {s' : Set 𝕜'} {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'}
      {h' h₂' : 𝕜'},
      HasDerivWithinAt h₂ h₂' s' (h x) →
        HasDerivWithinAt h h' s x → Set.MapsTo h s s' → HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x :=
  by sorry

This theorem states that, given two types `𝕜` and `𝕜'` which are nontrivially normed fields, a point `x` in `𝕜`, subsets `s` of `𝕜` and `s'` of `𝕜'`, and two functions `h` and `h₂` mapping `𝕜` to `𝕜'` and `𝕜'` to `𝕜'` respectively, with corresponding derivatives `h'` and `h₂'`, if `h₂` has derivative `h₂'` at the image of `x` under `h` within `s'` and `h` has derivative `h'` at `x` within `s`, and furthermore if the image of `s` under `h` is contained in `s'` (i.e., `h` maps `s` into `s'`), then the composition of `h₂` and `h` has the derivative `h₂' * h'` at `x` within `s`. This theorem essentially formalizes the chain rule of calculus in the context of derivatives within specific subsets of the domain.

Given nontrivially normed fields `𝕜` and `𝕜'`, functions `h: 𝕜 → 𝕜'` and `h₂: 𝕜' → 𝕜'` with derivatives `h'` and `h₂'`, if `h₂' * h'` is the derivative of `h₂ ∘ h` at `x` within `s` and `h(s) ⊆ s'`, then `h₂'` is the derivative of `h₂ ∘ h` at `x` within `s`.


/-- The product of two natural numbers is greater than 1 if and only if
at least one of them is greater than 1 and both are positive.  -/
theorem Nat.one_lt_mul_iff : ∀ {m n : ℕ}, 1 < m * n ↔ 0 < m ∧ 0 < n ∧ (1 < m ∨ 1 < n) := by sorry

This theorem states that for any two natural numbers `m` and `n`, the product of `m` and `n` is greater than 1 if and only if both `m` and `n` are positive and at least one of them is greater than 1.

For natural numbers `m` and `n`, `m * n > 1` if and only if both `m` and `n` are positive and at least one of them is greater than 1.


/-- The Bochner integral is measurable. This shows that the integrand of (the right-hand-side of)
Fubini's theorem is measurable.  -/
theorem MeasureTheory.StronglyMeasurable.integral_prod_right' :
    ∀ {α : Type u_1} {β : Type u_3} {E : Type u_6} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E]
      [inst_4 : MeasureTheory.SigmaFinite ν] ⦃f : α × β → E⦄,
      MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => ∫ (y : β), f (x, y) ∂ν :=
  by sorry

This theorem states that the Bochner integral is measurable. Specifically, for any strongly measurable function `f` from a product of two types `α` and `β` into a normed add commutative group `E`, the function that maps each `x` to the Bochner integral of `f` over `β` with respect to `y`, holding `x` constant, is also strongly measurable. This is a key property used in proving Fubini's theorem, as it guarantees that the integrand of the right-hand-side of Fubini's theorem is measurable. In terms of LaTeX mathematics, this theorem can be written as: If `f : α × β → E` is strongly measurable, then the function `x ↦ ∫ f(x, y) dy` is also strongly measurable.

If `f : α × β → E` is strongly measurable, then the function `x ↦ ∫ₔ f(x, y) dy` is also strongly measurable, where the integration is taken over `β` with respect to some suitable measure.


theorem Polynomial.natDegree_pos_of_nextCoeff_ne_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.nextCoeff p ≠ 0 → 0 < Polynomial.natDegree p := by
  sorry

This theorem states that for any semiring `R` and any polynomial `p` of type `R`, if the second-highest coefficient of the polynomial (referred to as `Polynomial.nextCoeff p`) is not equal to zero, then the natural degree of the polynomial (referred to as `Polynomial.natDegree p`) must be greater than zero. In other words, if a polynomial has a non-zero second-highest coefficient, then its degree must be positive.

If `p` is a polynomial over a semiring `R` with non-zero second-highest coefficient, then the degree of `p` is positive.


theorem Set.preimage_vadd_neg :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] (a : α) (t : Set β),
      (fun x => -a +ᵥ x) ⁻¹' t = a +ᵥ t :=
  by sorry

This theorem states that for any type `α` that forms an additive group, any type `β` that `α` acts upon (i.e., there exists an action of `α` on `β`), any element `a` of type `α`, and any set `t` of type `β`, the preimage of the set `t` under the function that adds the negation of `a` to each element (`fun x => -a +ᵥ x`) is the same as the set obtained by adding `a` to each element of `t`. Here, "`+ᵥ`" denotes the action of the additive group `α` on `β`, and "preimage" refers to the set of all elements in the domain that are mapped to the elements of `t` by the function.

For any additive group `α` acting on type `β`, and for any `a` in `α` and set `t` in `β`, the preimage of `t` under `x ↔- a + x` is equal to `a + t`.


theorem PartENat.get_eq_iff_eq_coe : ∀ {a : PartENat} {ha : a.Dom} {b : ℕ}, a.get ha = b ↔ a = ↑b := by sorry

This theorem states that for any partial natural number `a` with a defined domain `ha` and another natural number `b`, the value of `a` when applied to `ha` equals `b` if and only if `a` is the co-domain of `b`. In other words, a partial natural number is equivalent to a co-domain natural number if and only if their associated values are the same.

For any partial natural number `a` with domain `ha` and natural number `b`, `ha a = b` if and only if `a = Σ i, i := 0 ^ ha.size, b i`. (In other words, `a` is the co-domain of `b`).


theorem Fin.strictMono_castLE : ∀ {n m : ℕ} (h : n ≤ m), StrictMono (Fin.castLE h) := by sorry

The theorem `Fin.strictMono_castLE` states that for any two natural numbers `n` and `m`, where `n` is less than or equal to `m`, the function `Fin.castLE h` is strictly monotone. This means that if we have two elements in `Fin n`, say `a` and `b`, where `a` is less than `b`, then `Fin.castLE h a` is less than `Fin.castLE h b` when these elements are embedded into the larger `Fin m` type. In essence, the `Fin.castLE` function preserves the ordering of elements when casting from a smaller `Fin` type to a larger one.

For all natural numbers `n` and `m` with `n <= m`, the function `Fin.castLE : Fin n -> Fin m` is strictly monotone, meaning that `Fin.castLE a < Fin.castLE b` for all `a < b` in `Fin n`.


theorem Nat.zeckendorf_succ :
    ∀ (n : ℕ),
      Nat.zeckendorf (n + 1) = Nat.greatestFib (n + 1) :: Nat.zeckendorf (n + 1 - Nat.fib (Nat.greatestFib (n + 1))) :=
  by sorry

The theorem `Nat.zeckendorf_succ` states that for any natural number `n`, the Zeckendorf representation of `n + 1` is a list that starts with the greatest index of a Fibonacci number less than or equal to `n + 1`, followed by the Zeckendorf representation of `n + 1 - fib(greatestFib(n + 1))`. This represents that the Zeckendorf representation of `n + 1` is constructed by adding the largest possible Fibonacci number (without exceeding `n + 1`), then recursively doing the same for the remainder after subtracting this Fibonacci number.

The Zeckendorf representation of `n + 1` is obtained by appending the index of the largest Fibonacci number less than or equal to `n + 1` to the Zeckendorf representation of `n + 1 - Fib(greatest Fibonacci number <= n + 1)`.


theorem MeasurableEmbedding.measurable_rangeSplitting :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
      MeasurableEmbedding f → Measurable (Set.rangeSplitting f) :=
  by sorry

The theorem `MeasurableEmbedding.measurable_rangeSplitting` states that for all types `α` and `β`, with `α` having a measurable space structure `mα` and `β` also having a measurable space structure, for any function `f` from `α` to `β` that is a measurable embedding, the function `Set.rangeSplitting f` is measurable. Here, `Set.rangeSplitting` is a function defined using the axiom of choice that selects a preimage for each element of the range of `f`. In other words, if you have a function that is a measurable embedding, then the function that assigns to each point in the range of this function a preimage under the original function is also measurable.

If `f: α → β` is a measurable embedding between measurable spaces `(α, mα)` and `(β, mβ)`, then `Set.rangeSplitting f: β → Set α` is a measurable function.


List.Perm.filterMap

theorem List.Perm.filterMap :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → Option β) {l₁ l₂ : List α},
      List.Perm l₁ l₂ → List.Perm (List.filterMap f l₁) (List.filterMap f l₂) :=
  by sorry

This theorem states that for any two lists `l₁` and `l₂` of elements of type `α`, and a function `f` mapping elements of type `α` to an `Option` of type `β`, if `l₁` and `l₂` are permutations of each other, then the lists obtained by applying `f` to each element of `l₁` and `l₂` and filtering the `Some` results (i.e., `List.filterMap f l₁` and `List.filterMap f l₂`) are also permutations of each other.

If `l₁` and `l₂` are permutations of each other, then `List.filterMap (fun x => f x) l₁` and `List.filterMap (fun x => f x) l₂` are permutations of each other.


theorem PiLp.nndist_equiv_symm_single_same :
    ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : Fintype ι]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_3 : DecidableEq ι] (i : ι) (b₁ b₂ : β i),
      nndist ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₁))
          ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₂)) =
        nndist b₁ b₂ :=
  by sorry

This theorem asserts that for every extended nonnegative real number `p` such that `1 ≤ p`, every finite type `ι`, and every function `β : ι → Type u_4` where each `β i` is a seminormed additive commutative group with decidable equality, if we have elements `b₁` and `b₂` of some `β i`, then the nonnegative distance (or `nndist`) between the values of the function obtained by applying the canonical equivalence from `WithLp p ((i : ι) → β i)` to `Pi.single i b₁` and `Pi.single i b₂` (after taking the inverse of the equivalence), is the same as the nonnegative distance between `b₁` and `b₂` themselves. In other words, this equivalence preserves the nonnegative distance between the singleton functions at a given index `i`.

For every extended nonnegative real number `p` with `1 ≤ p`, every finite type `ι`, and every function `β : ι → SeminormedAddCommGroup` such that each `β i` has decidable equality, the nonnegative distance between the elements `b₁` and `b₂` in `β i` is equal to the nonnegative distance between the functions `Pi.single i b₁` and `Pi.single i b₂` in the Lp space `WithLp p ((i : ι) → β i)`.


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

The theorem `Relation.transitive_reflTransGen` states that for any type `α` and for any binary relation `r` on `α`, the reflexive transitive closure of `r` is transitive. More specifically, if we have elements `x`, `y`, and `z` of type `α` such that `x` is related to `y` and `y` is related to `z` under the reflexive transitive closure of `r`, then `x` is also related to `z` under the same closure. The reflexive transitive closure of a relation is the smallest relation that contains the original one and is both reflexive (every element is related to itself) and transitive.

If a relation is reflexive and transitive, then its reflexive transitive closure is transitive.


theorem Set.mulIndicator_union_of_not_mem_inter :
    ∀ {α : Type u_1} {M : Type u_4} [inst : MulOneClass M] {s t : Set α} {a : α},
      a ∉ s ∩ t → ∀ (f : α → M), Set.mulIndicator (s ∪ t) f a = Set.mulIndicator s f a * Set.mulIndicator t f a :=
  by sorry

The theorem `Set.mulIndicator_union_of_not_mem_inter` states that for any types `α` and `M`, given a multiplication and one identity structure on `M`, any two sets `s` and `t` of type `α`, and any element `a` of type `α` that is not in the intersection of `s` and `t`, for any function `f` from `α` to `M`, the multiplicative indicator function of the union of `s` and `t` applied to `f` at `a` is equal to the product of the multiplicative indicator function of `s` applied to `f` at `a` and the multiplicative indicator function of `t` applied to `f` at `a`. In simpler terms, if an element does not belong to the intersection of two sets, the value of the multiplicative indicator function at this element for the union of the sets is the product of the values of the multiplicative indicator function for the individual sets.

For sets `s` and `t` of type `α` and for any element `a ∉ s ∩ t` of type `α`, the multiplicative indicator function of `s ∪ t` at `f(a)` is equal to the product of the multiplicative indicator functions of `s` and `t` at `f(a)`.


/-- **Alias** of the reverse direction of `spectrum.zero_not_mem_iff`. -/
theorem spectrum.zero_not_mem :
    ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
      IsUnit a → 0 ∉ spectrum R a :=
  by sorry

This theorem states that for any commutative semiring `R`, ring `A` and an `R`-algebra structure on `A`, if an element `a` of `A` is a unit, then zero is not an element of the spectrum of `a`. In other words, if we have an element `a` in `A` that has a two-sided inverse, then zero doesn't belong to the set of `r` in `R` for which `r•1 - a` is not a unit of the algebra `A`. This is the reverse direction of the theorem `spectrum.zero_not_mem_iff`.

If `a` is a unit in the `R-`algebra `A` over the commutative semiring `R`, then zero is not in the spectrum of `a`.


theorem Finset.inf'_eq_csInf_image :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLattice α] (s : Finset ι) (H : s.Nonempty) (f : ι → α),
      Finset.inf' s H f = sInf (f '' ↑s) :=
  by sorry

This theorem states that for any type `ι`, any type `α` which forms a conditionally complete lattice, any nonempty finite set `s` of type `ι`, and any function `f` from `ι` to `α`, the infimum of the image of `s` under `f` (as calculated by the method `Finset.inf'`) is equal to the supremum of the lower bounds (`sInf`) of the set of all images of the elements of `s` under `f`. In other words, the infimum of the set obtained by applying `f` to each element of `s` can be obtained by finding the supremum of all lower bounds of this set.

For any nonempty finite set `s` and function `f` from a conditionally complete lattice `ι` to a lattice `α`, the infimum of `f`'s image of `s` equals the supremum of `f`'s lower bounds on `s`.


theorem AddMonoid.Coprod.mclosure_range_inl_union_inr :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
      AddSubmonoid.closure (Set.range ⇑AddMonoid.Coprod.inl ∪ Set.range ⇑AddMonoid.Coprod.inr) = ⊤ :=
  by sorry

This theorem states that for any two types `M` and `N` that have additive monoid structures, the additive submonoid generated by the union of the ranges of the natural embeddings of `M` and `N` into the coproduct of `M` and `N` is the whole coproduct. In other words, every element of the coproduct of `M` and `N` can be expressed as a sum of elements coming from `M` and `N` via their respective natural embeddings.

For any additive monoids M and N, the submonoid of their coproduct generated by the images of their natural embeddings is the whole coproduct.


theorem Set.Finite.infinite_compl : ∀ {α : Type u} [inst : Infinite α] {s : Set α}, Set.Finite s → Set.Infinite sᶜ := by
  sorry

The theorem `Set.Finite.infinite_compl` states that for any type `α` that is infinite, and for any set `s` of type `α` that is finite, the complement of `s` (denoted by `sᶜ`) is infinite. In other words, removing a finite set from an infinite set results in another infinite set.

For any infinite type `α` and finite set `s` of type `α`, the complement of `s` is infinite.


theorem unitary.coe_star_mul_self :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (U : ↥(unitary R)), star ↑U * ↑U = 1 := by sorry

This theorem states that for any type `R` that is a monoid with a `StarMul` operation, and for any element `U` belonging to the submonoid of `R` defined by the `unitary` operation, the product of the star of `U` and `U` itself is equal to one. In other words, it confirms that the defining property of unitary elements (i.e., `star U * U = 1`) holds for all elements in the unitary submonoid of `R`.

For any monoid `R` with a `StarMul` operation and any unitary element `U` in `R`, `StarU * U = 1`.


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

The theorem `Nat.lcm_dvd_iff` states that for any three natural numbers `m`, `n`, and `k`, the least common multiple of `m` and `n` divides `k` if and only if both `m` and `n` divide `k`. Here, the least common multiple of `m` and `n` is defined as the product of `m` and `n`, divided by their greatest common divisor.

The least common multiple of natural numbers m and n divides k if and only if both m and n divide k. (Equivalently, m and n have product d such that k is divisible by d if and only if m and n are divisors of k.)


theorem Finset.subset_singleton_iff' : ∀ {α : Type u_1} {s : Finset α} {a : α}, s ⊆ {a} ↔ ∀ b ∈ s, b = a := by sorry

This theorem, `Finset.subset_singleton_iff'`, states that for any given type `α`, a finite set `s` of type `α`, and an element `a` of type `α`, the set `s` is a subset of the singleton set `{a}` if and only if every element `b` in `s` is equal to `a`. This is a universal property, meaning it holds for all possible types `α` and all finite sets `s` and elements `a` of type `α`.

A finite set `s` of type `α` is a subset of the singleton set `{a}` if and only if every element `b` in `s` equals `a`.


theorem Stream'.WSeq.map_comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (s : Stream'.WSeq α),
      Stream'.WSeq.map (g ∘ f) s = Stream'.WSeq.map g (Stream'.WSeq.map f s) :=
  by sorry

The theorem `Stream'.WSeq.map_comp` states that for any types `α`, `β`, and `γ`, and any functions `f` from `α` to `β` and `g` from `β` to `γ`, and any weak sequence `s` of type `α`, mapping the composition of `g` and `f` over `s` is equivalent to first mapping `f` over `s` and then mapping `g` over the result. This theorem is essentially stating the property of function composition in the context of mapping over a weak sequence.

For any types `α`, `β`, and `γ`, and functions `f : α → β` and `g : β → γ`, the mapping of `g ∘ f` over a weak sequence `s` of type `α` is equal to the composition of mapping `f` over `s` and then mapping `g` over the result.


theorem InnerProductSpace.Core.inner_self_nonneg :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] {x : F}, 0 ≤ RCLike.re ⟪x, x⟫_𝕜 :=
  by sorry

This theorem states that for any type 𝕜 with a RCLike (Real or Complex-like) structure, and any type F which forms an additive commutative group and is also a module over 𝕜, along with an InnerProductSpace.Core structure on 𝕜 and F, the inner product of any vector 'x' with itself (⟪x, x⟫_𝕜) is nonnegative, as returned by the 're' function of the RCLike structure of 𝕜. This captures the common intuition in geometry that the "length" of a vector, represented by taking its inner product with itself, should always be nonnegative.

For any RCLike structure 𝕜 on a type, and any additive commutative group F with a module structure over 𝕜 and an InnerProductSpace.Core structure, the inner product of any vector 'x' in F with itself is nonnegative (⟪x, x⟫_𝕜 ≥ 0).


theorem Nat.right_le_pair : ∀ (a b : ℕ), b ≤ Nat.pair a b := by sorry

The theorem `Nat.right_le_pair` states that for any two natural numbers `a` and `b`, `b` is always less than or equal to the value of the pairing function `Nat.pair a b`. In other words, when we apply the function `Nat.pair` on any two natural numbers `a` and `b`, the result will always be greater than or equal to `b`.

For all natural numbers `a` and `b`, `Nat.pair a b` is greater than or equal to `b`.


theorem Mathlib.Topology.Bornology.Absorbs._auxLemma.6 :
    ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
      {s t : Set α}, Absorbs G₀ s t = ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s :=
  by sorry

This theorem states that for any given types `G₀` and `α` where `G₀` is equipped with a GroupWithZero structure and a Bornology, and `α` has a multiplication action by `G₀`, a set `s` of type `α` absorbs another set `t` of type `α` if and only if for all `c` in the cobounded sets of `G₀` according to the Bornology, the function mapping `x` to `c⁻¹ • x` maps `t` into `s`. Here, `•` denotes the action of `G₀` on `α`, and `c⁻¹` is the multiplicative inverse of `c` in `G₀`.

A set `s` of type `α` absorbs another set `t` of type `α` in the group `G₀` with Bornology if and only if for all cobounded elements `c` in `G₀`, the set `t` is mapped into `s` by the function `x mapsto c⁻¹ • x`.


theorem PowerSeries.coeff_invUnitsSub :
    ∀ {R : Type u_1} [inst : Ring R] (u : Rˣ) (n : ℕ),
      (PowerSeries.coeff R n) (PowerSeries.invUnitsSub u) = 1 /ₚ u ^ (n + 1) :=
  by sorry

The theorem `PowerSeries.coeff_invUnitsSub` states that for any ring `R`, any unit `u` of `R`, and any natural number `n`, the `n`th coefficient of the power series for `1 / (u - x)` is `1 /ₚ u ^ (n + 1)`. In other words, it says that when you construct a power series as the series `1 / (u - x)`, then the coefficient of `x^n` in that series is `1 / u ^ (n + 1)`. This theorem essentially describes the structure of the power series for `1 / (u - x)`.

The `n`th coefficient of the power series expansion of `1 / (u - x)` in a ring `R` with a unit `u` is equal to `1 / u ^ (n + 1)`.


theorem Complex.ofReal_sin_ofReal_re : ∀ (x : ℝ), ↑(Complex.sin ↑x).re = Complex.sin ↑x := by sorry

This theorem states that for all real numbers x, the real part of the complex sine of x, when promoted to a complex number, is equal to the complex sine of x. In other words, it asserts that the real component of the complex sine function, when applied to a real argument, fully captures the value of the complex sine function on that argument. This emphasizes the fact that the complex sine function reduces to the real sine function when applied to real numbers.

The real part of the complex sine function equals the complex sine function for all real numbers.


theorem CategoryTheory.Functor.map_sum :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_6, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.Additive F] {X Y : C} {α : Type u_4} (f : α → (X ⟶ Y)) (s : Finset α),
      F.map (Finset.sum s fun a => f a) = Finset.sum s fun a => F.map (f a) :=
  by sorry

This theorem is stating a property about functors in category theory. Specifically, it's saying that for any category `C` and `D`, both of which are `Preadditive`, and an `Additive` functor `F` from `C` to `D`, the map of the sum of morphisms from `X` to `Y` in `C` (indexed by a finite set `s`), through the functor `F`, is the same as the sum of the individual maps of each morphism through `F`. In other words, for any elements `X` and `Y` of `C`, any function `f` from a type `α` to morphisms from `X` to `Y`, and any finite set `s` of type `α`, the functor `F` distributes over the sum of morphisms, i.e., `F.map (Finset.sum s f) = Finset.sum s (F.map ∘ f)`. This is a type of distributivity property for functors with respect to the operation of summing over morphisms in a category.

For any additive categories `C` and `D`, and additive functor `F` from `C` to `D`, the sum of morphisms from `X` to `Y` in `C`, through `F`, equals the sum of the individual morphisms through `F`, for any objects `X` and `Y` in `C`.


theorem Irrational.mul_rat : ∀ {x : ℝ}, Irrational x → ∀ {q : ℚ}, q ≠ 0 → Irrational (x * ↑q) := by sorry

The theorem `Irrational.mul_rat` asserts that for any real number `x`, if `x` is irrational (meaning it cannot be expressed as a ratio of two integers), then for any rational number `q` that is not zero, the product of `x` and `q` is also irrational. This essentially means that multiplying an irrational number by a non-zero rational number will always result in an irrational number.

If a real number is irrational, then its product with any non-zero rational number is also irrational.


RelEmbedding.isWellFounded

theorem RelEmbedding.isWellFounded :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop},
      r ↪r s → ∀ [inst : IsWellFounded β s], IsWellFounded α r :=
  by sorry

This theorem states that if there exists a relation-embedding from a relation 'r' on type 'α' to a relation 's' on type 'β', then, if 's' on 'β' is well-founded, we can conclude that 'r' on 'α' is also well-founded. In other words, the well-foundedness of a relation is preserved under relation-embedding. The term "well-founded" here refers to the property of a relation where no infinite descending chains exist.

If there is an embedding of relation r on type α into a well-founded relation s on type β, then r is also well-founded.


theorem LieSubmodule.trivial_lie_oper_zero :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N : LieSubmodule R L M)
      (I : LieIdeal R L) [inst_6 : LieModule.IsTrivial L M], ⁅I, N⁆ = ⊥ :=
  by sorry

This theorem states that for any commutative ring `R`, Lie ring `L`, additively commutative group `M`, where `L` forms a Lie algebra over `R` and `M` is a `R`-module and a `L`-Lie ring module, any Lie submodule `N` of the Lie module, and any Lie ideal `I` of `L`, if `M` is a trivial Lie module over `L`, then the Lie bracket of the Lie ideal `I` and the Lie submodule `N` equals the zero submodule.

In other words, when `M` is a trivial Lie module over `L`, the action of any element from the Lie ideal on any element from the Lie submodule reduces to zero. This essentially means that in this context, the elements of the Lie ideal act trivially on the Lie submodule.

If `L` is a Lie algebra over a commutative ring `R`, `M` is an additively commutative `R`-module and a `L`-Lie ring module, `N` is a Lie submodule of the Lie module `M`, and `I` is a Lie ideal of `L`, then `N` is a trivial `L`-Lie module over `L` implies `[I, N] = {0}`, where `[I, N]` denotes the Lie bracket of `I` and `N`.


theorem Polynomial.degree_sub_le :
    ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R),
      Polynomial.degree (p - q) ≤ max (Polynomial.degree p) (Polynomial.degree q) :=
  by sorry

The theorem `Polynomial.degree_sub_le` states that for any two polynomials `p` and `q` over a ring `R`, the degree of the polynomial resulting from subtracting `q` from `p` (denoted `p - q`) is less than or equal to the maximum of the degrees of `p` and `q`. In other words, the highest power of `X` that appears in the polynomial `p - q` is no greater than the highest power of `X` that appears in either `p` or `q`.

The degree of the polynomial `p - q` is less than or equal to the maximum degree of `p` and `q`.


theorem DifferentiableWithinAt.of_dslope :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {a b : 𝕜} {s : Set 𝕜},
      DifferentiableWithinAt 𝕜 (dslope f a) s b → DifferentiableWithinAt 𝕜 f s b :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, any normed additive commutative group `E`, any function `f` from `𝕜` to `E`, any points `a` and `b` in `𝕜`, and any set `s` of `𝕜`, if the function `dslope f a` is differentiable at point `b` within set `s`, then the original function `f` is also differentiable at point `b` within the same set `s`. In other words, differentiability of the derivative slope function at a certain point within a certain set implies the differentiability of the original function at the same point within the same set.

If the derivative slope function of a continuous function from a normed field to a normed additive commutative group is differentiable at a point within a set, then the original function is also differentiable at that point within the same set.


theorem Polynomial.degree_sub_lt :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R},
      Polynomial.degree p = Polynomial.degree q →
        p ≠ 0 →
          Polynomial.leadingCoeff p = Polynomial.leadingCoeff q → Polynomial.degree (p - q) < Polynomial.degree p :=
  by sorry

The theorem `Polynomial.degree_sub_lt` states that for any ring `R` and any two polynomials `p` and `q` over `R`, if the degree of `p` and `q` are equal, and `p` is not the zero polynomial, and the leading coefficients of `p` and `q` are also equal, then the degree of the polynomial resulting from subtracting `q` from `p` (denoted `p - q`) is strictly less than the degree of `p`. In other words, the highest power of `X` in `p - q` is less than the highest power of `X` in `p`.

Given polynomials `p` and `q` over a ring `R` with equal degrees and non-zero leading coefficients, `p - q` has degree strictly less than that of `p`.


theorem isNoetherianRing_of_surjective :
    ∀ (R : Type u_1) [inst : Ring R] (S : Type u_2) [inst_1 : Ring S] (f : R →+* S),
      Function.Surjective ⇑f → ∀ [H : IsNoetherianRing R], IsNoetherianRing S :=
  by sorry

This theorem states that if we have two rings, `R` and `S`, and a ring homomorphism `f` from `R` to `S` that is surjective (meaning that for every element in `S`, there is some element in `R` such that the function `f` maps it to `S`), then if `R` is a Noetherian ring (i.e., a ring in which all ideals are finitely generated), `S` is also a Noetherian ring. To put it in simpler terms, surjective ring homomorphisms preserve the property of being a Noetherian ring.

If `f` is a surjective ring homomorphism from the Noetherian ring `R` to the ring `S`, then `S` is also a Noetherian ring.


/-- We state it as a simp lemma, which is regarded as an involved version of
`id_whiskerRight f g : 𝟙 f ▷ g = 𝟙 (f ≫ g)`.
 -/
theorem CategoryTheory.Bicategory.leftUnitor_whiskerRight :
    ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
      CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.leftUnitor f).hom g =
        CategoryTheory.CategoryStruct.comp
          (CategoryTheory.Bicategory.associator (CategoryTheory.CategoryStruct.id a) f g).hom
          (CategoryTheory.Bicategory.leftUnitor (CategoryTheory.CategoryStruct.comp f g)).hom :=
  by sorry

This theorem, `CategoryTheory.Bicategory.leftUnitor_whiskerRight`, states that in any bicategory `B`, for any objects `a`, `b`, and `c` and for any morphisms `f : a ⟶ b` and `g : b ⟶ c`, the morphism obtained by whiskering on the right by `g` of the homomorphism component of the left unitor of `f`, is equivalent to the composition of the homomorphism component of the associator of the identity morphism on `a`, `f`, and `g`, and the homomorphism component of the left unitor of the composite morphism `f ≫ g`. In mathematical terms, it says that the following equality holds: `(𝟙 f) ▷ g = (id_a * f * g) ⋅ (𝟙 (f ≫ g))`, where `*` denotes morphism composition, `⋅` denotes the composition of natural transformations, and `𝟙` denotes the identity morphism.

In any bicategory, the right whiskering of the left unitor morphism of a composition of morphisms is equivalent to the composition of the associator of the identity morphism with the left unitor morphisms of the involved morphisms.


theorem EquivLike.bijective_comp :
    ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iE : EquivLike E α β] (e : E) (f : β → γ),
      Function.Bijective (f ∘ ⇑e) ↔ Function.Bijective f :=
  by sorry

The theorem `EquivLike.bijective_comp` states that for all types `E`, `α`, `β`, and `γ`, where `E` has an equivalence-like relationship with `α` and `β`, given an instance `e` of `E` and a function `f` from `β` to `γ`, the composition of `f` and `e` is a bijective function if and only if `f` itself is a bijective function. In other words, the bijectivity of `f` is preserved when it is composed with an equivalence-like object `e`.

For any type `E` with an equivalence-relation `_≡_`, and functions `f : β → γ` and `e : α ≃ β` such that `e` is an equivalence-like relation, if `f` is bijective then so is `f ∘ e`.


theorem Equiv.toFun_as_coe : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.toFun = ⇑e := by sorry

The theorem `Equiv.toFun_as_coe` states that for any two types `α` and `β` and a given equivalence `e` between them, the function `e.toFun` is the same as the coercion function `⇑e`. In other words, we can use the coercion function `⇑e` as a shorthand to represent the function `e.toFun` that converts elements of type `α` to elements of type `β` under the equivalence `e`. This theorem provides a convenient and succinct way to use equivalence functions in Lean 4.

For any equivalence `e` between types `α` and `β`, the function `e.toFun` is equal to the coercion function `⇑e`.


theorem Mathlib.Data.Set.Basic._auxLemma.1 :
    ∀ {α : Type u} {p q : α → Prop}, ({a | p a} ⊆ {a | q a}) = ∀ (a : α), p a → q a := by sorry

This theorem, `Mathlib.Data.Set.Basic._auxLemma.1`, from the Lean Mathematical Library's basic set theory module, states that for any type `α` and for any two properties `p` and `q` which apply to elements of type `α`, the set of elements of `α` for which `p` holds is a subset of the set of elements for which `q` holds if and only if every element of `α` that satisfies `p` also satisfies `q`. In mathematical notation, this can be written as: `{a ∈ α | p(a)} ⊆ {a ∈ α | q(a)}` if and only if `∀a ∈ α, p(a) → q(a)`.

For any type `α` and properties `p` and `q` of its elements, `{a ∈ α | p(a)}` is a subset of `{a ∈ α | q(a)}` if and only if for all `a` in `α`, `p(a)` implies `q(a)`.


theorem Mathlib.Data.Set.Basic._auxLemma.2 : ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x := by sorry

This theorem, `Mathlib.Data.Set.Basic._auxLemma.2`, states that for any type `α` and any predicate `p` that applies to `α`, the statement "it is not the case that every element of `α` satisfies `p`" is equivalent to "there exists an element of `α` that does not satisfy `p`". It presents a foundational concept in formal logic, expressing the negation of a universal quantifier as an existential quantifier with a negated predicate.

The theorem `Mathlib.Data.Set.Basic._auxLemma.2` in Lean 4 states that the negation of "every element of type `α` satisfies predicate `p`" is equivalent to "there exists an element in `α` that does not satisfy `p`."


theorem Mathlib.Data.Set.Basic._auxLemma.3 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem, labelled as `Mathlib.Data.Set.Basic._auxLemma.3`, states that for any two propositions `a` and `b`, the existence of `b` under the assumption of `a` (notated as `∃ (_ : a), b`) is equivalent to the conjunction of `a` and `b` (notated as `a ∧ b`). In other words, if `b` holds true given `a`, then both `a` and `b` are true.

The theorem asserts that for all propositions `a` and `b`, `∃ (x : a), b` is logically equivalent to `a ∧ b`.


theorem Ideal.sup_prod_eq_top :
    ∀ {R : Type u} {ι : Type u_1} [inst : CommSemiring R] {I : Ideal R} {s : Finset ι} {J : ι → Ideal R},
      (∀ i ∈ s, I ⊔ J i = ⊤) → (I ⊔ Finset.prod s fun i => J i) = ⊤ :=
  by sorry

This theorem, `Ideal.sup_prod_eq_top`, states that for any commutative semiring `R`, any ideal `I` of `R`, any finite set `s` indexed by type `ι`, and any function `J` from `ι` to ideals of `R`, if for every element `i` in `s`, the supremum of `I` and `J i` equals the top ideal (which is the whole ring), then the supremum of `I` and the product of `J i` (for `i` in `s`) also equals the top ideal. In essence, this theorem gives a condition under which the maximal ideal (`⊤`) can be expressed as the supremum of an ideal `I` and a product of ideals `J i` over a finite set `s`.

If for every index `i` in a finite set `s`, the supremum of an ideal `I` and `J i` in a commutative semiring equals the top ideal, then the supremum of `I` and the product of `J i` (for all `i` in `s`) also equals the top ideal.


theorem zsmul_neg' : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℤ), n • -a = -n • a := by sorry

This theorem, `zsmul_neg'`, states that for any type `α` that is a subtraction monoid, for any element `a` of type `α` and for any integer `n`, the product of `n` and the negation of `a` is equal to the negation of the product of `n` and `a`. In mathematical terms, it states that `n` times `-a` is equal to `-n` times `a`. This theorem can be seen as a property of distribution over negation in the context of multiplication with integers in any subtraction monoid.

For any subtraction monoid type `α` and any integer `n`, `n` times the negation of an element `a` equals the negation of `n` times `a`.


theorem LeftOrdContinuous.map_sSup' :
    ∀ {α : Type u} {β : Type v} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {f : α → β},
      LeftOrdContinuous f → ∀ (s : Set α), f (sSup s) = sSup (f '' s) :=
  by sorry

The theorem `LeftOrdContinuous.map_sSup'` states that for all types `α` and `β` which form complete lattices, and for any function `f` from `α` to `β` that is left order continuous (meaning it preserves all suprema), the supremum (greatest element) of the image of a set `s` under `f` is the same as the image of the supremum of `s` under `f`. In mathematical terms, if `f` is a function that preserves order and suprema, then `f` applied to the supremum of a set equals the supremum of the image of the set under `f`, i.e., `f(sup(S)) = sup(f(S))` for any set `S`.

For any complete lattice types `α` and `β`, and left order continuous function `f` from `α` to `β`, the image of the supremum of a set `s` under `f` is equal to the supremum of the image of `s` under `f`, i.e., `sup(f(s)) = f(sup(s))`.


theorem irrational_mul_rat_iff : ∀ {q : ℚ} {x : ℝ}, Irrational (x * ↑q) ↔ q ≠ 0 ∧ Irrational x := by sorry

The theorem `irrational_mul_rat_iff` states that for any real number `x` and any rational number `q`, `x` multiplied by `q` is an irrational number if and only if `q` is not zero and `x` is an irrational number. In other words, the product of a non-zero rational number and an irrational number is itself an irrational number.

For any irrational real number x and non-zero rational number q, the product x * q is an irrational number.


theorem Set.IccExtend_of_le_left :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α} (f : ↑(Set.Icc a b) → β),
      x ≤ a → Set.IccExtend h f x = f { val := a, property := ⋯ } :=
  by sorry

This theorem states that for all types `α` and `β` with `α` having a linear order, and for all `a`, `b`, `x` of type `α` and a function `f` from the closed interval `[a, b]` to `β` (`↑(Set.Icc a b)` denotes the closed interval [a, b]), if `a` is less than or equal to `b` and `x` is less than or equal to `a`, then the value of the extension of function `f` to `α` at `x` is equal to the value of `f` at `a`. In other words, for a function extended from a closed interval to the entire line, the function values outside the left end of the interval are equal to the function value at the left end.

For all types `α` with a linear order, and for all functions `f` from the closed interval `[a, b]` of type `α` to another type `β`, if `a ≤ b` and `x ≤ a`, then `f.extend a  x = f a`.


IsSeqClosed.isClosed

/-- In a sequential space, a sequentially closed set is closed.  -/
theorem IsSeqClosed.isClosed :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : SequentialSpace X] {s : Set X}, IsSeqClosed s → IsClosed s :=
  by sorry

In the context of a sequential space, this theorem states that if a set is sequentially closed, it is also a closed set. To elaborate, given a set `s` in a topological space `X` that also has a sequential space structure, if for any sequence of elements in `s` that converges to a limit `p`, `p` is also an element of `s` (definition of `IsSeqClosed`), then `s` is a closed set in the topological sense (i.e., its complement is an open set).

In a sequential space, a set is closed if and only if every convergent sequence in the set limits to an element in the set.


theorem Mathlib.Control.Basic._auxLemma.3 :
    ∀ {m : Type u → Type v} [inst : Monad m] [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α),
      f <$> x = do
        let a ← x
        pure (f a) :=
  by sorry

This theorem, `Mathlib.Control.Basic._auxLemma.3`, states that for any monad `m` (with the types `u` and `v`), which obeys the laws of monads (`LawfulMonad m`), and for any two types `α` and `β`, and a function `f` of type `α → β`, the operation of mapping `f` over `x` (denoted as `f <$> x`) is equivalent to first binding `x` to `a` using the `do` notation, and then applying `f` to `a` and wrapping the result in the monad using `pure`. It shows that these are two possible ways to apply a function to the value inside a monad: either by using the `fmap` operation (denoted by `<$>`), or by explicitly binding the value inside the monad to a variable and then applying the function to this variable.

For any monad `m` and function `f`, the application of `f` to the value inside `m` using the `<$>` operator is equivalent to binding the value to a variable `x` using `do` notation and then applying `f` to `x` and wrapping the result in `m` using `pure`.


ValuationRing.cond

theorem ValuationRing.cond :
    ∀ {A : Type u} [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : ValuationRing A] (a b : A),
      ∃ c, a * c = b ∨ b * c = a :=
  by sorry

The theorem `ValuationRing.cond` states that for any type `A` which is a commutative ring and a domain, and for which `A` is a valuation ring, given any two elements `a` and `b` of `A`, there exists another element `c` in `A` such that either `a` multiplied by `c` equals `b`, or `b` multiplied by `c` equals `a`. In other words, for any two elements in a valuation ring, one of them can be expressed as the other one multiplied by some element in the ring.

In a commutative ring and domain `A` that is a valuation ring, for any two elements `a`, `b` in `A`, there exists `c` in `A` such that either `ac = b` or `bc = a`.


TopologicalSpace.CompactOpens.isCompact

theorem TopologicalSpace.CompactOpens.isCompact :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.CompactOpens α), IsCompact ↑s := by sorry

The theorem `TopologicalSpace.CompactOpens.isCompact` states that for any type `α` that has a topological space structure and for any set `s` of compact open subsets of `α`, the set `s` is compact. In other words, for every nontrivial filter `f` that contains `s`, there exists an element `x` in `s` such that every set of `f` meets every neighborhood of `x`. This theorem is a property of compact open subsets in topological spaces.

A set of compact open subsets of a topological space is compact.


/-- A family of points in a projective space is independent if and only if the representative
vectors determined by the family are linearly independent.  -/
theorem Projectivization.independent_iff :
    ∀ {ι : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V]
      [inst_2 : Module K V] {f : ι → Projectivization K V},
      Projectivization.Independent f ↔ LinearIndependent K (Projectivization.rep ∘ f) :=
  by sorry

The theorem states that a set of points in a projective space, represented by a family `f` mapping from an index set `ι` to the projective space `ℙ K V` (projectivization of the vector space `V` over the division ring `K`), is independent if and only if the representative vectors corresponding to these points are linearly independent. Here, the representative vectors are determined by applying the representative function `Projectivization.rep` to the family `f`. In other words, the projective independence of a set of points is equivalent to the linear independence of their representative vectors in the associated vector space.

A set of points in a projective space is independent if and only if the representative vectors of these points are linearly independent in the associated vector space.


theorem Int.add_ediv_of_dvd_right : ∀ {a b c : ℤ}, c ∣ b → (a + b) / c = a / c + b / c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `c` divides `b` (in mathematical terms, this would be written as `c | b`), then the expression `(a + b) / c` is equal to the sum of the individual divisions `a / c + b / c`. This essentially expresses a distributive property of integer division where the divisor `c` divides one of the dividends (`b` in this case).

If `c` divides `b`, then `(a + b) / c` equals the sum `a / c + b / c`.


theorem ContinuousOn.inv₀ :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : Zero G₀] [inst_1 : Inv G₀] [inst_2 : TopologicalSpace G₀]
      [inst_3 : HasContinuousInv₀ G₀] {f : α → G₀} {s : Set α} [inst_4 : TopologicalSpace α],
      ContinuousOn f s → (∀ x ∈ s, f x ≠ 0) → ContinuousOn (fun x => (f x)⁻¹) s :=
  by sorry

The theorem `ContinuousOn.inv₀` states that, for any type `α` and a type `G₀` with a zero element, an inversion operation, and a topology, if `f` is a function from `α` to `G₀` and `s` is a subset of `α`, then if `f` is continuous on `s` and for all `x` in `s`, `f(x)` is not zero, it implies that the function `(f x)⁻¹`, which is the inverse of `f(x)`, is also continuous on `s`. Here continuity at a point and continuous inversion operations are understood with respect to the topology of `G₀` and the topology of `α`. This is a statement about the preservation of continuity under the operation of taking reciprocals for non-zero values in topological spaces.

If `f` is a continuous function from `α` to a topological space `G₀` with a zero element and inversion operation, such that `f(x)` is never zero for `x` in `s`, then the inverse function `(f x)⁻¹` is also continuous on `s`.


theorem BoxIntegral.Prepartition.inf_split :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) (i : ι) (x : ℝ),
      π ⊓ BoxIntegral.Prepartition.split I i x =
        BoxIntegral.Prepartition.biUnion π fun J => BoxIntegral.Prepartition.split J i x :=
  by sorry

This theorem states that for any type `ι`, any integral box `I` of this type, a partition `π` of `I`, a member `i` of `ι`, and a real number `x`, the intersection of the partition `π` and the split of `I` at `x` along the `i`-th axis is equal to a bi-union over `π`. Specifically, the bi-union is between `π` and the split of each box `J` in `π` at `x` along the `i`-th axis. In other words, it splits every box in the prepartition `π` at the same point `x`, and this split operation commutes with intersections.

For any type `ι`, integral box `I` of type `ι`, partition `π` of `I`, element `i` of `ι`, and real number `x`, the intersection of `π` with the split of `I` at `x` along the `i`-th axis equals the bi-union of `π` and the split of each box in `π` at `x` along the `i`-th axis.


theorem contDiff_mul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ∞} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸], ContDiff 𝕜 n fun p => p.1 * p.2 :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, natural number `n`, and normed ring `𝔸` that is also a normed algebra over `𝕜`, the function that multiplies a pair of elements from `𝔸` is `n`-times continuously differentiable. In mathematical terms, given any pair of elements in `𝔸`, the function which multiplies these elements is subject to `n` rounds of continuous differentiation.

For any nontrivially normed field `𝕜`, natural number `n`, and normed ring `𝔸` that is also a normed algebra over `𝕜`, the multiplication function on `𝔸` is `n`-times continuously differentiable.


theorem WeierstrassCurve.Affine.equation_neg_iff :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R) (x y : R),
      W.equation x (W.negY x y) ↔ W.equation x y :=
  by sorry

The theorem `WeierstrassCurve.Affine.equation_neg_iff` states that for any type `R` which is a commutative ring, any Weierstrass curve `W` defined over `R`, and any elements `x` and `y` of `R`, the equation of the Weierstrass curve with `x` and the negation of `y` (as computed by the `negY` function of `W`) holds if and only if the equation of the Weierstrass curve with `x` and `y` holds. In other words, if a point `(x, y)` lies on the Weierstrass curve, then so does the point `(x, -y)`, and conversely. This theorem is a reflection property of Weierstrass curves.

For any Weierstrass curve `W` over a commutative ring `R` and elements `x` and `y` of `R`, the point `(x, y)` lies on `W` if and only if the point `(x, -y)` lies on `W`.


theorem TensorProduct.smul_add :
    ∀ {R : Type u_1} [inst : CommSemiring R] {R' : Type u_2} [inst_1 : Monoid R'] {M : Type u_4} {N : Type u_5}
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : DistribMulAction R' M] [inst_7 : SMulCommClass R R' M] (r : R') (x y : TensorProduct R M N),
      r • (x + y) = r • x + r • y :=
  by sorry

This theorem states that for any commutative semiring `R`, another type `R'` which is a monoid, and modules `M` and `N` over `R` (where `M` is also an `R'`-module and the scalar multiplication on `M` commutes with the ring multiplication of `R`), scalar multiplication distributes over the addition of tensor products. In mathematical notation, for any scalar `r` in `R'` and any two tensor products `x` and `y` in `M ⊗ N`, we have `r • (x + y) = r • x + r • y`.

For any commutative semiring `R`, `R'-module `M` over `R`, and modules `N` over `R` with commuting scalar multiplication, the scalar multiplication on `M` distributes over the tensor product addition, that is, `r • (x ⊗ y) = r • x ⊗ y + r • x' ⊗ y'` for all `r` in `R'`, and `x, x'` in `M`, and `y, y'` in `N`.


theorem Subgroup.coe_map :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (K : Subgroup G),
      ↑(Subgroup.map f K) = ⇑f '' ↑K :=
  by sorry

This theorem states that for any two groups G and N, and a monoid homomorphism `f` from G to N, the image of a subgroup `K` of G under the mapping `f` is identical to the elements of the subgroup `K` mapped by `f`. In other words, applying the group homomorphism `f` to a subgroup `K` of `G` yields the same set of elements as applying `f` to each element of `K` individually.

For any group homomorphism `f` from group `G` to group `N` and any subgroup `K` of `G`, the image of `K` under `f` is equal to the set of elements in `N` obtained by applying `f` to every element in `K`.


theorem CategoryTheory.GradedObject.ι_mapMap_assoc :
    ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C]
      {X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (p : I → J) [inst_1 : CategoryTheory.GradedObject.HasMap X p]
      [inst_2 : CategoryTheory.GradedObject.HasMap Y p] (i : I) (j : J) (hij : p i = j) {Z : C}
      (h : CategoryTheory.GradedObject.mapObj Y p j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj X p i j hij)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapMap φ p j) h) =
        CategoryTheory.CategoryStruct.comp (φ i)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj Y p i j hij) h) :=
  by sorry

This theorem, named `CategoryTheory.GradedObject.ι_mapMap_assoc`, states that in a category `C`, given two `I`-graded objects `X` and `Y` and a morphism `φ` from `X` to `Y`, as well as a map `p` from `I` to another type `J` (where both `X` and `Y` have a corresponding `p`-map), for any `i` from `I` and `j` from `J` such that `p(i) = j`, and any morphism `h` from the `j`-object of the `p`-map of `Y` to another object `Z` in `C`, the composition of the `i`-object of the `p`-map of `X` with the composition of the `j`-object of the `p`-map of `φ` and `h` is equal to the composition of `φ(i)` with the composition of the `i`-object of the `p`-map of `Y` and `h`.

In more straightforward terms, this theorem expresses a certain associativity property in the context of graded objects in a category, involving the interaction of morphisms, grading maps and the coproduct structure of the graded objects.

For any category `C`, given graded objects `X` and `Y` and a morphism `φ:` `X` → `Y`, and maps `p:` `I` → `J` for their grading, for all `i` in `I` and `j` in `J` with `p(i) = j`, and for any morphism `h:` the `j`-object of `Y` → `Z` in `C`, we have `(ι_X i) ∘ (φ i ∘ h) = (φ i) ∘ (ι_Y i)`.


theorem Algebra.toSubmodule_bot :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      Subalgebra.toSubmodule ⊥ = 1 :=
  by sorry

The theorem `Algebra.toSubmodule_bot` states that for any commutative semiring `R` and any semiring `A` that is also an `R`-algebra, when the "bottom" (i.e., the smallest possible) subalgebra of `A` is mapped to a submodule of `A` using the function `Subalgebra.toSubmodule`, the result is the "unit" (or one) submodule. In other words, the smallest subalgebra corresponds to the unit submodule under the consider mapping.

The smallest subalgebra of an `R`-algebra `A` maps to the unit submodule under the function `Subalgebra.toSubmodule` for any commutative semiring `R`.


theorem Trivialization.tendsto_nhds_iff :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {α : Type u_6} {l : Filter α} {f : α → Z}
      {z : Z},
      z ∈ e.source →
        (Filter.Tendsto f l (nhds z) ↔
          Filter.Tendsto (proj ∘ f) l (nhds (proj z)) ∧ Filter.Tendsto (fun x => (↑e (f x)).2) l (nhds (↑e z).2)) :=
  by sorry

The theorem `Trivialization.tendsto_nhds_iff` states that for any types `B`, `F`, and `Z` with `B`, `F`, and `Z` being topological spaces, and given a projection function `proj` from `Z` to `B`, a trivialization `e` of `F` over `proj`, and a filter `l` on a type `α`, a function `f` from `α` to `Z`, and a point `z` in `Z` that belongs to the source of `e`, the function `f` tends to the neighborhood of `z` (i.e., the limit of `f` as it approaches `z` exists) if and only if both the composed function `proj ∘ f` tends to the neighborhood of the projected point `proj z`, and the function that maps `x` to the second component of `e` at `f x` tends to the neighborhood of the second component of `e` at `z`.

A function from a filter on a type to a topological space tends to a point in the space if and only if its projection to the base space and the second component function of its trivialization tend to the respective neighborhoods of their targets.


theorem FreeCommRing.induction_on :
    ∀ {α : Type u} {C : FreeCommRing α → Prop} (z : FreeCommRing α),
      C (-1) →
        (∀ (b : α), C (FreeCommRing.of b)) →
          (∀ (x y : FreeCommRing α), C x → C y → C (x + y)) → (∀ (x y : FreeCommRing α), C x → C y → C (x * y)) → C z :=
  by sorry

The theorem `FreeCommRing.induction_on` in Lean 4 provides an induction principle for the free commutative ring on a type `α`. Given any type `α` and a property `C` that applies to elements of the free commutative ring on `α`, if `C` holds for the negative unity (-1), and if `C` is preserved under the canonical map from `α` to the free commutative ring on `α`, addition, and multiplication, then `C` holds for every element of the free commutative ring on `α`. This means that to prove a property for all elements of the free commutative ring, it is sufficient to prove it for the basic elements, and show that it is preserved under the ring operations.

Given a property `C` on the free commutative ring on a type `α`, if `C` holds for the negative unity and is preserved under the ring operations, then `C` holds for every element of the free commutative ring on `α`.


theorem Nat.le_of_not_le : ∀ {a b : ℕ}, ¬b ≤ a → a ≤ b := by sorry

This theorem states that for any two natural numbers 'a' and 'b', if 'b' is not less than or equal to 'a', then 'a' must be less than or equal to 'b'. Basically, it provides a mechanism to determine the relative order of two natural numbers when one number is not less than or equal to the other.

If a is not less than or equal to b in the natural numbers, then b is less than or equal to a.


theorem Set.LeftInvOn.image_inter' :
    ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
      Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' s₁ ∩ f '' s :=
  by sorry

The theorem `Set.LeftInvOn.image_inter'` states that for any types `α` and `β`, any sets `s` and `s₁` of type `α`, and any functions `f: α → β` and `f': β → α`, if `f'` is a left inverse to `f` on `s` (meaning `f' (f x) = x` for all `x` in `s`), then the image of the intersection of `s₁` and `s` under `f` is equal to the intersection of the preimage of `s₁` under `f'` and the image of `s` under `f`. In mathematical terms, if `f'∘f(x) = x` for all `x` in `s`, then `f(s₁ ∩ s) = f'^(-1)(s₁) ∩ f(s)`.

If `f: α → β` has a left inverse `f'` on set `s ⊆ α`, then `f(s₁ ∩ s) = f'⁻¹(s₁) ∩ f(s)` for any sets `s₁ ⊆ α`.


theorem Finset.coe_toList : ∀ {α : Type u_1} (s : Finset α), ↑(Finset.toList s) = s.val := by sorry

The theorem `Finset.coe_toList` states that for any finite set `s` of an arbitrary type `α`, the list obtained by converting the finite set `s` to a list using the function `Finset.toList`, and then converting this list back to a finite set, will be equal to the original finite set `s`. In other words, the process of converting from a finite set to a list and back is a lossless operation.

For any finite set `s` of type `α`, the conversion of `s` to a list using `Finset.toList` and back to a finite set using `Finset.ofList` results in the original set `s`. In other words, `Finset.ofList (Finset.toList s) = s`.


theorem Relation.ReflTransGen.cases_head :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α},
      Relation.ReflTransGen r a b → a = b ∨ ∃ c, r a c ∧ Relation.ReflTransGen r c b :=
  by sorry

This theorem, `Relation.ReflTransGen.cases_head`, states that for any type `α` and any binary relation `r` on `α`, for any two elements `a` and `b` of the type, if the reflexive transitive closure (denoted by `Relation.ReflTransGen r`) of `r` relates `a` to `b`, then either `a` is equal to `b`, or there exists an element `c` such that `r` relates `a` to `c` and the reflexive transitive closure of `r` relates `c` to `b`. The reflexive transitive closure of a relation is a new relation that relates any element to itself, and if the original relation relates an element `x` to an element `y` and `y` to an element `z`, then the closure also relates `x` to `z`.

If `Relation.ReflTransGen r` relates `a` to `b`, then there exists `c` such that `r` relates `a` to `c` and `Relation.ReflTransGen r` relates `c` to `b`, or `a = b`.


theorem Filter.le_lift'_closure :
    ∀ {X : Type u} [inst : TopologicalSpace X] (l : Filter X), l ≤ Filter.lift' l closure := by sorry

This theorem states that for any type `X` equipped with a topological space structure and any filter `l` on `X`, the filter `l` is less than or equal to the filter obtained by applying the `lift'` operation to `l` with the `closure` operation. In other words, every element of `l` is also an element of the filter generated by taking the closure of each set in `l`. This means that the filter `l` is contained within the filter of all closure sets of `l`.

For any topological space `(X, τ)` and filter `l` on `X`, `l ⊆ closure (l'_ filter τ l)`. (Here, `l'_ filter` denotes the filter obtained by applying `lift` to `l` in Lean.)


/-- `(c +ᵥ ·)` is a proper map. -/
theorem isProperMap_vadd :
    ∀ {M : Type u_1} (c : M) (X : Type u_2) [inst : VAdd M X] [inst_1 : TopologicalSpace X] [h : ProperConstVAdd M X],
      IsProperMap fun x => c +ᵥ x :=
  by sorry

This theorem states that for any type `M`, any type `X` that supports a vector addition operation with `M` (`[VAdd M X]`), any instance `c` of `M`, and any `X` that is a topological space (`[TopologicalSpace X]`), if `M` and `X` satisfy the `ProperConstVAdd` condition, then the function that adds `c` to every element of `X` (`fun x => c +ᵥ x`) is a proper map. A proper map in topology is one that is precompact, meaning the preimage of every compact set is also compact. The `ProperConstVAdd` condition is a specific property related to the vector addition operation.

Given a type `M` with a `VAdd` operation, a topological space `X`, an instance `c` of `M`, and assuming `M` and `X` satisfy the `ProperConstVAdd` condition, the constant vector addition function `x => c +ᵥ x` is a proper map from `X` to `M`.


theorem ProbabilityTheory.kernel.indep_limsup_atBot_self :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω} [inst : SemilatticeInf ι] [inst_1 : NoMinOrder ι] [inst_2 : Nonempty ι],
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          ProbabilityTheory.kernel.Indep (Filter.limsup s Filter.atBot) (Filter.limsup s Filter.atBot) κ μα :=
  by sorry

This theorem states that for any types `α`, `Ω`, and `ι`, with `α` as a measurable space, `Ω` as a measurable space `m0`, and `κ` as an element of the kernel from `α` to `Ω`, and given a measure `μα` on `α`. If `κ` is a Markov kernel, and `s` is a function from `ι` to the measurable space `Ω`, where `ι` is a semilattice with the infimum operation and has no minimum element but is nonempty. If for all `n` in `ι`, `s n` is less than or equal to `m0`, and the family of measurable spaces `s` is independent with respect to the kernel `κ` and the measure `μα`, then the limsup of `s` at negative infinity is independent with respect to the kernel `κ` and the measure `μα`. Here, `limsup` of a function along a filter is the infimum of the `a` such that, eventually for the filter, `u x ≤ a` holds, and `atBot` is the filter representing the limit towards negative infinity.

Given a measurable space `α`, a measurable space `Ω` with measure `m0`, a Markov kernel `κ` from `α` to `Ω`, a semilattice `ι` with no minimum element, a function `s: ι -> Ω`, measurable with respect to `κ` and `μα`, and `s(n) <= m0` for all `n` in `ι`, if `s` is independent under `κ` and `μα`, then the limsup of `s` with respect to the filter at negative infinity is independent of `κ` and `μα`.


theorem Int.clog_of_right_le_zero :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) {r : R},
      r ≤ 0 → Int.clog b r = 0 :=
  by sorry

This theorem states that for any type `R` that is a linearly ordered semifield and a floor semiring, and for any natural number `b` and any real number `r` from this type `R`, if `r` is less than or equal to 0, then the `Int.clog` of `b` and `r` is 0. In other words, if the real number is non-positive, then the least power of `b` that is greater than or equal to `r` is 0 since any number raised to the power 0 gives 1, which is greater than any non-positive number.

For any linearly ordered semifield and floor semiring `R`, `Int.clog b 0 le 0 → Int.clog b R := 0`.


theorem Ring.inverse_eq_inv : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (a : G₀), Ring.inverse a = a⁻¹ := by sorry

The theorem `Ring.inverse_eq_inv` states that for all elements `a` in a group with zero `G₀`, the `Ring.inverse` of `a` is equal to the inverse of `a`. In other words, in any group with zero, the function `Ring.inverse` acts as the standard group inverse operation for any given element. This is an important property that confirms the consistency of the `Ring.inverse` definition with the standard algebraic concept of an inverse in a group with zero.

In a group with zero, the `Ring.inverse` of an element is equal to its group inverse.


theorem Nat.sub_one_lt_floor :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorSemiring α] (a : α), a - 1 < ↑⌊a⌋₊ := by sorry

This theorem states that for any type `α`, given that `α` is a linearly ordered ring and a floor semiring, the value of any element `a` of type `α` subtracted by 1 is less than the floor of `a` coerced to `α`. In mathematical terms, for any `a` in a linearly ordered ring and floor semiring `α`, `a - 1 < floor(a)`.

For any linearly ordered ring and floor semiring `α`, the floor function applied to any element `a` in `α` is strictly greater than `a - 1`. In Lean 4 notation: `floor a > a - 1`.


theorem AddHom.le_map_tsub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Add α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      [inst_4 : Preorder β] [inst_5 : Add β] [inst_6 : Sub β] [inst_7 : OrderedSub β] (f : AddHom α β),
      Monotone ⇑f → ∀ (a b : α), f a - f b ≤ f (a - b) :=
  by sorry

The theorem `AddHom.le_map_tsub` asserts that for any types `α` and `β` with `Preorder`, `Add`, `Sub` and `OrderedSub` instances, and an additive homomorphism `f` from `α` to `β` that is monotone, for any elements `a` and `b` in `α`, the difference of `f(a)` and `f(b)` is less than or equal to `f(a - b)`. That is, if `f` preserves the order and addition operations, then it also preserves the subtraction in the sense of this inequality.

If `f` is an additive, monotone homomorphism between preordered types `α` and `β`, then for all `a, b` in `α`, `f(a - b) ≤ f(a) - f(b)`.


theorem pairwise_disjoint_on :
    ∀ {α : Type u_1} {ι : Type u_4} [inst : SemilatticeInf α] [inst_1 : OrderBot α] [inst_2 : LinearOrder ι]
      (f : ι → α), Pairwise (Disjoint on f) ↔ ∀ ⦃m n : ι⦄, m < n → Disjoint (f m) (f n) :=
  by sorry

This theorem, `pairwise_disjoint_on`, states that for any types `α` and `ι` with the appropriate structures (`α` being a semilattice with a least element, and `ι` having a linear order), and for any function `f` from `ι` to `α`, the pairwise disjointness of the images under `f` is equivalent to stating that for any distinct `m` and `n` in `ι` with `m < n`, the images of `m` and `n` under `f` are disjoint. In other words, it provides a condition under which elements in the range of `f` are considered disjoint based on their originating indices in `ι`. Disjointness here means that any element `x` that is less than or equal to both `f(m)` and `f(n)` must be less than or equal to the bottom element of the semilattice.

For a semilattice with least element α and linearly ordered type ι, a function f from ι to α has pairwise disjoint images if and only if for distinct m and n in ι with m < n, the images f(m) and f(n) are disjoint, meaning any x less than or equal to both is less than the least element of α.


theorem MeasureTheory.Measure.FiniteAtFilter.exists_mem_basis :
    ∀ {α : Type u_1} {ι : Type u_4} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : Filter α},
      MeasureTheory.Measure.FiniteAtFilter μ f →
        ∀ {p : ι → Prop} {s : ι → Set α}, Filter.HasBasis f p s → ∃ i, p i ∧ ↑↑μ (s i) < ⊤ :=
  by sorry

The theorem `MeasureTheory.Measure.FiniteAtFilter.exists_mem_basis` states that for any type `α` and `ι`, a measurable space `m0` on `α`, a measure `μ` of that measurable space, and a filter `f` on `α`, if the measure `μ` is finite at the filter `f`, then for any property `p` on `ι` and any function `s` from `ι` to the set of `α`, if the filter `f` has a basis characterized by the property `p` and the function `s`, there exists an element `i` in `ι` such that the property `p` holds for `i` and the measure of `s(i)` is finite.

This means that when a measure is finite at a filter, it is also finite at some element of any basis of that filter, as long as the basis satisfies certain conditions. This is a statement about the connection between measure theory and filter bases in mathematical analysis.

Given a measurable space `(α, m0)`, measure `μ`, filter `f`, property `p` on `ι`, and function `s` from `ι` to `α`, if `μ` is finite at `f` and `f` has a basis characterized by `p` and `s`, then there exists an `i` in `ι` such that `p(i)` holds and `μ(s(i))` is finite.


theorem CategoryTheory.ShortComplex.LeftHomologyData.ofZeros_f' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0),
      CategoryTheory.ShortComplex.LeftHomologyData.f' (CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg) =
        0 :=
  by sorry

This theorem states that in the context of a category `C`, which has zero morphisms, for any short complex `S` in `C` where both the `f` and `g` morphisms are zeros, the `f'` morphism in the left homology data constructed from `S` using `ofZeros` is also a zero morphism.

In a zero-object category `C`, if a short complex `S` has zero morphisms `f` and `g`, then the left homology `f'` constructed from `S` using `ofZeros` is also a zero morphism.


theorem Nat.Prime.odd_of_ne_two : ∀ {p : ℕ}, Nat.Prime p → p ≠ 2 → Odd p := by sorry

The theorem `Nat.Prime.odd_of_ne_two` states that for every natural number `p`, if `p` is a prime number and `p` is not equal to 2, then `p` is an odd number. In other words, any prime number other than 2 is odd. This follows from the definition of odd numbers in a semiring, where a number is considered odd if it can be expressed as `2*k + 1` for some integer `k`, and the definition of prime numbers, where a prime is a natural number greater than 1 that has no divisors other than 1 and itself.

If a natural number `p` is prime and not equal to 2, then `p` is an odd number.


theorem Rat.add_def : ∀ (a b : ℚ), a + b = Rat.normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯ := by sorry

This theorem states that for any two rational numbers `a` and `b`, the sum of `a` and `b` is equal to the rational number constructed by normalizing the sum of the product of the numerator of `a` and the denominator of `b` and the product of the numerator of `b` and the denominator of `a`, where the denominator of the resulting rational number is the product of the denominators of `a` and `b`. In mathematical terms, if $a = \frac{a_{num}}{a_{den}}$ and $b = \frac{b_{num}}{b_{den}}$, then $a + b = \frac{a_{num} \cdot b_{den} + b_{num} \cdot a_{den}}{a_{den} \cdot b_{den}}$, where the numerator and denominator of the resulting fraction are divided by their greatest common divisor to ensure the fraction is in its simplest form.

For any rational numbers `a = a_num/a_den` and `b = b_num/b_den`, the sum `a + b` equals the rational number `(a_num * b_den + b_num * a_den) / (a_den * b_den)` in its simplest form.


/-- A strictly monotone function between linear orders with order topology is a topological
embedding provided that the range of `f` is order-connected.  -/
theorem StrictMono.embedding_of_ordConnected :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : LinearOrder β] [inst_2 : TopologicalSpace α]
      [h : OrderTopology α] [inst_3 : TopologicalSpace β] [inst_4 : OrderTopology β] {f : α → β},
      StrictMono f → Set.OrdConnected (Set.range f) → Embedding f :=
  by sorry

The theorem `StrictMono.embedding_of_ordConnected` states that for any two types `α` and `β`, given that `α` and `β` have a linear ordering and topological space structure, and are equipped with order topology, if a function `f` from `α` to `β` is strictly monotone and the range of `f` is order-connected - which means every value between any two values in the range is also in the range - then `f` is a topological embedding. A topological embedding is a function between topological spaces that is homeomorphic to its image, meaning it preserves the topological structure.

A strictly monotone function between order-connected, linearly ordered types with order topology is a topological embedding.


theorem CategoryTheory.Simple.of_iso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} [inst_2 : CategoryTheory.Simple Y], (X ≅ Y) → CategoryTheory.Simple X :=
  by sorry

This theorem states that for any category `C` that has zero morphisms, if `Y` is a simple object in `C` and `X` is isomorphic to `Y`, then `X` is also a simple object. Here, "simple object" is a concept from category theory which essentially means that the object has no non-trivial direct summands. In other words, the theorem tells us that the property of being a simple object is preserved under isomorphism in a category with zero morphisms.

In a category with zero morphisms, if two objects are isomorphic, then each is a simple object.


theorem MonoidHom.comp_assoc :
    ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} {Q : Type u_10} [inst : MulOneClass M] [inst_1 : MulOneClass N]
      [inst_2 : MulOneClass P] [inst_3 : MulOneClass Q] (f : M →* N) (g : N →* P) (h : P →* Q),
      MonoidHom.comp (MonoidHom.comp h g) f = MonoidHom.comp h (MonoidHom.comp g f) :=
  by sorry

This theorem, `MonoidHom.comp_assoc`, states that for any three monoid morphisms `f`, `g`, and `h` where `f` is a morphism from a monoid `M` to a monoid `N`, `g` is a morphism from `N` to `P`, and `h` is a morphism from `P` to `Q` (all monoids with respect to some multiplication and unit operation), the composition of these morphisms is associative. In other words, if we first compose `h` with `g` and then compose the result with `f`, it is the same as if we first composed `g` with `f` and then composed the result with `h`. This is equivalent to the mathematical statement $(h \circ g) \circ f = h \circ (g \circ f)$ for all `f`, `g`, `h`.

For any monoid morphisms $f : M \to N$, $g : N \to P$, and $h : P \to Q$, the associativity of composition holds: $(h \circ g) \circ f = h \circ (g \circ f)$.


theorem Antitone.directed_ge :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] [inst_2 : Preorder β]
      {f : α → β}, Antitone f → Directed (fun x x_1 => x ≥ x_1) f :=
  by sorry

The theorem `Antitone.directed_ge` states that for any types `α` and `β` with preorder relations and a function `f` from `α` to `β`, if `α` is directed with respect to the less than or equal to relation and the function `f` is antitone (meaning that `a ≤ b` implies `f(b) ≤ f(a)`), then the function `f` is directed with respect to the greater than or equal to relation. In other words, for any two elements in the domain of `f`, there exists a third element such that `f` applied to this third element is greater than or equal to `f` applied to each of the original two elements.

If `α` is a directed type with respect to `≤`, and `f: α → β` is an antitone function, then `f` is directed with respect to the `≥` relation on `β`.


theorem Nat.WithBot.lt_zero_iff : ∀ {n : WithBot ℕ}, n < 0 ↔ n = ⊥ := by sorry

The theorem `Nat.WithBot.lt_zero_iff` states that for any variable `n` of type `WithBot ℕ`, `n` is less than zero if and only if `n` is `⊥` (bottom). In other words, in the context of natural numbers extended with a bottom element (⊥), the only way a number can be considered "less than zero" is if that number is the bottom element itself. This is because natural numbers are non-negative, and the bottom element (`⊥`) is considered less than all natural numbers.

In the type of natural numbers extended with a bottom element, a number is less than zero if and only if it is the bottom element itself.


WithTop.forall

theorem WithTop.forall : ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), p x) ↔ p ⊤ ∧ ∀ (x : α), p ↑x := by
  sorry

The theorem `WithTop.forall` states that for any type `α` and any property `p` defined over the type `WithTop α` (which is the type `α` augmented with an additional element `⊤`), the property `p` holds for all elements of `WithTop α` if and only if `p` holds for the `⊤` element and `p` holds for every element of `α` when lifted to the `WithTop α` type. The lifting is denoted by `p ↑x` and it simply means applying the property `p` to the element `x` of `α` considered as an element of `WithTop α`.

For any type `α` and property `p` on `α`, `WithTop.forall` asserts that an element `x` in `WithTop α` has property `p` if and only if the top element `⊤` has property `p` and every element `x` in `α` does when lifted to `WithTop α`.


theorem Sum.elim_const_const :
    ∀ {γ : Sort u_1} {α : Type u_2} {β : Type u_3} (c : γ),
      Sum.elim (Function.const α c) (Function.const β c) = Function.const (α ⊕ β) c :=
  by sorry

The theorem `Sum.elim_const_const` states that for any type `α`, `β`, any sort `γ`, and any constant `c` of type `γ`, applying the `Sum.elim` function to the constant functions `Function.const α c` and `Function.const β c` (which, regardless of their input, always output `c`) is the same as the constant function `Function.const (α ⊕ β) c`. In other words, it doesn't matter if we construct a function on the sum type `α ⊕ β` by separately defining constant functions on `α` and `β`, or if we directly define a constant function on `α ⊕ β` - both approaches give us the same result.

For any types `α` and `β` and constant `c`, applying `Sum.elim` to the constant functions `Function.const α c` and `Function.const β c` is equivalent to the constant function `Function.const (α + β) c`, where `+` denotes the sum type.


theorem Polynomial.Monic.natDegree_map :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Nontrivial S] {P : Polynomial R},
      Polynomial.Monic P → ∀ (f : R →+* S), Polynomial.natDegree (Polynomial.map f P) = Polynomial.natDegree P :=
  by sorry

The theorem `Polynomial.Monic.natDegree_map` states that for any semirings `R` and `S`, with `S` being nontrivial, and for any monic polynomial `P` over `R`, the degree of the polynomial obtained by mapping `P` across a ring homomorphism `f : R →+* S` is the same as the degree of `P`. In other words, the natural degree of a monic polynomial remains the same under ring homomorphism mapping.

For any monic polynomial $P$ over a semiring $R$, and any nontrivial ring homomorphism $f : R \to S$, the degree of $P$ and the degree of $P$ mapped under $f$ are equal.


theorem MulAction.pow_mod_period_smul :
    ∀ {α : Type v} {M : Type u} [inst : Monoid M] [inst_1 : MulAction M α] (n : ℕ) {m : M} {a : α},
      m ^ (n % MulAction.period m a) • a = m ^ n • a :=
  by sorry

This theorem, `MulAction.pow_mod_period_smul`, states that for any natural number `n`, any element `m` of a monoid `M`, and any element `a` of a type `α` where `M` acts on `α` multiplicatively, the action of `m` raised to the power of (`n` modulo the period of the action of `m` on `a`) on `a` is the same as the action of `m` raised to the power of `n` on `a`. In other words, the multiplicative action of `m` on `a` repeats every `MulAction.period m a` steps.

For any monoid action `m` on type `α`, and any element `a` and natural number `n`, the multiplicative action `m^n` on `a` equals `m^(n mod (period m a))` if `n` is a multiple of the period of the action.


theorem uniformInducing_iff :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] (f : α → β),
      UniformInducing f ↔ Filter.comap (fun x => (f x.1, f x.2)) (uniformity β) = uniformity α :=
  by sorry

This theorem, `uniformInducing_iff`, states that for any two types `α` and `β` that have `UniformSpace` structures and for any function `f` from `α` to `β`, `f` is a Uniform Inducing function if and only if the preimage under `f` of the uniformity filter of `β` equals the uniformity filter of `α`. In more mathematical terms, the function `f` induces a uniform structure on `α` from `β` if and only if the uniform continuity condition holds, i.e., `(f x, f y)` is close in `β` whenever `(x, y)` is close in `α`.

A function between two uniform spaces is a uniform inducing function if and only if the preimage of the uniformity filter on the codomain equals the uniformity filter on the domain.


theorem List.replicate_perm :
    ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, List.Perm (List.replicate n a) l ↔ List.replicate n a = l := by sorry

This theorem, `List.replicate_perm`, states that for all types `α`, natural numbers `n`, elements `a` of type α, and lists `l` of type `α`, the list obtained by replicating the element `a` `n` times is a permutation of the list `l` if and only if the replicated list is exactly equal to `l`. In other words, a list of `n` copies of `a` is a permutation of `l` only when it is identical to `l`.

For all types α, natural numbers n, elements a of α, and lists l of length n of α, List.replicate a n equals l if and only if l is a permutation of List.repeat a.


theorem tsub_add_cancel_iff_le :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α},
      b - a + a = b ↔ a ≤ b :=
  by sorry

This theorem, `tsub_add_cancel_iff_le`, states that for all types `α` that are canonically ordered additive commutative monoids with a subtraction operation that respects the order, for any two elements `a` and `b` of type `α`, the equation `b - a + a = b` holds if and only if `a` is less than or equal to `b`. In less formal terms, this is saying that if we subtract `a` from `b` and then add `a` back, we will get `b` back if and only if `a` is not greater than `b`. This theorem is a formalized version of a familiar fact from ordinary arithmetic.

For any additively commutative monoid with subtraction respecting the order, the subtraction and addition commute if and only if the subtrahend is less than or equal to the minuend.


theorem EquivLike.comp_bijective :
    ∀ {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iF : EquivLike F β γ] (f : α → β) (e : F),
      Function.Bijective (⇑e ∘ f) ↔ Function.Bijective f :=
  by sorry

The theorem `EquivLike.comp_bijective` states that for any type `F`, and any types `α`, `β`, and `γ` with `EquivLike` relation between types `β` and `γ`, given a function `f` from `α` to `β` and an equivalence `e` of type `F`, the function `f` is bijective if and only if the composition of `f` with `e` (denoted as `⇑e ∘ f`) is bijective. Here, bijectiveness means that the function is both injective (it never maps different inputs to the same output) and surjective (every possible output is produced by at least one input). This theorem essentially asserts that composing a bijective function with an equivalence doesn't affect the bijectiveness of the function.

For any type `F`, type `α`, and types `β` and `γ` with an `EquivLike` relation, if `f: α → β` is bijective and `e: F` is an equivalence from `β` to `γ`, then `f ∘ e` is also bijective.