theorem MulOpposite.op_smul :
    ∀ {α : Type u_1} {R : Type u_2} [inst : SMul R α] (c : R) (a : α), MulOpposite.op (c • a) = c • MulOpposite.op a :=
  by sorry

This theorem, `MulOpposite.op_smul`, states that for any type `α` and any type `R`, and given an instance of the scalar multiplication `SMul R α` between `R` and `α`, for any elements `c` of type `R` and `a` of type `α`, the operation `MulOpposite.op` applied to the scalar multiplication of `c` and `a` (i.e., `c • a`) is equal to the scalar multiplication of `c` and the `MulOpposite.op` of `a`. In other words, the `MulOpposite.op` operation distributes over scalar multiplication, a property often seen in algebraic structures.

For any type `α` and scalar multiplication `SMul R α` over `R` on `α`, the scalar multiplication of an element `c` in `R` with the opposite `MulOpposite.op a` of an element `a` in `α` is equal to the scalar multiplication of `c` with `a`, i.e., `c • a = c • MulOpposite.op a`.


AddChar.ext

theorem AddChar.ext :
    ∀ {A : Type u_1} {M : Type u_2} [inst : AddMonoid A] [inst_1 : Monoid M] (f g : AddChar A M),
      (∀ (x : A), f x = g x) → f = g :=
  by sorry

This theorem, `AddChar.ext`, states that for any two `AddChar` (additive characters) `f` and `g` from a type `A` to a type `M`, where `A` is an additive monoid and `M` is a monoid, if `f` and `g` give the same value for all elements in `A`, then `f` and `g` are considered equal. In other words, it's a proof of the extensionality of additive characters, asserting that two additive character functions are identical if they map every element of their domain to the same element in their codomain.

If two additive characters `f` and `g` from an additive monoid `A` to a monoid `M` agree on all elements of `A`, then `f` is equal to `g`.


theorem WeierstrassCurve.Affine.Point.some_add_some_of_Yne :
    ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} {x₁ x₂ y₁ y₂ : F} {h₁ : W.nonsingular x₁ y₁}
      {h₂ : W.nonsingular x₂ y₂},
      x₁ = x₂ →
        ∀ (hy : y₁ ≠ W.negY x₂ y₂),
          WeierstrassCurve.Affine.Point.some h₁ + WeierstrassCurve.Affine.Point.some h₂ =
            WeierstrassCurve.Affine.Point.some ⋯ :=
  by sorry

This theorem states that given a field `F` and a Weierstrass curve `W` defined over `F`, for any two points `(x₁, y₁)` and `(x₂, y₂)` on the curve `W` that are nonsingular (meaning the tangent line is well defined at these points), if `x₁` equals `x₂` and `y₁` is not equal to the negative of `y₂` with respect to `x₂`, then the sum of these two points on the curve equals another specific point on the curve, the details of which are suppressed here. The operation `+` here stands for the addition operation in the group law of elliptic curves.

Given a Weierstrass curve `W` over a field `F` and two nonsingular points `(x₁, y₁)` and `(x₂, y₂)` on `W` with `x₁ = x₂` and `y₁ ≠ -y₂`, their sum in the group law of `W` is a specific point on the curve.


IsMin.grade

theorem IsMin.grade :
    ∀ (𝕆 : Type u_1) {α : Type u_3} [inst : Preorder α] [inst_1 : Preorder 𝕆] [inst_2 : GradeMinOrder 𝕆 α] {a : α},
      IsMin a → IsMin (grade 𝕆 a) :=
  by sorry

This theorem states that for any types `𝕆` and `α`, where `α` is a preorder and `𝕆` is a preorder, and under the condition that `𝕆` and `α` have a grade-minimal order, if `a` is a minimal element in `α`, then the grade of `a` is also a minimal element in `𝕆`. In simpler terms, if `a` is the smallest element according to the order defined for `α`, then the number of steps you would need to go down to get to the bottom of the order for `𝕆` is also the smallest possible.

If `α` is a preordered type with a grade-minimal order and `a` is a minimal element in `α`, then the grade of `a` is a minimal element in the preorder `𝕆` on types.


theorem CategoryTheory.ShortComplex.Hom.comm₂₃_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (self : CategoryTheory.ShortComplex.Hom S₁ S₂) {Z : C} (h : S₂.X₃ ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.τ₂ (CategoryTheory.CategoryStruct.comp S₂.g h) =
        CategoryTheory.CategoryStruct.comp S₁.g (CategoryTheory.CategoryStruct.comp self.τ₃ h) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Hom.comm₂₃_assoc` states that in a given category `C` with zero morphisms, for any two short complexes `S₁` and `S₂` in this category, and any homomorphism `self` between `S₁` and `S₂`, and for any object `Z` in `C` and any morphism `h` from `S₂.X₃` to `Z`, the composition of the morphism `self.τ₂` with the composition of `S₂.g` and `h` is equal to the composition of `S₁.g` with the composition of `self.τ₃` and `h`. This theorem describes a commutative property of morphisms in category theory complex and is part of the framework for working with homological algebra in Lean.

For any short complexes $S\_1$, $S\_2$ in a zero-morphism category $C$, and any homomorphism $f$ from $S\_1$ to $S\_2$ and morphism $h$ from $S\_2.X\_3$ to an object $Z$ in $C$, we have $f.τ\_2 \circ S\_2.g \circ h = S\_1.g \circ f.τ\_3 \circ h$.


theorem Mathlib.ModelTheory.Order._auxLemma.2 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      (T : FirstOrder.Language.Theory L), M ⊨ T = ∀ φ ∈ T, M ⊨ φ :=
  by sorry

This theorem states that for any first-order language `L` and any type `M` that is structured according to `L`, a theory `T` (which is a set of sentences) is true in the model `M` if and only if every sentence `φ` in `T` is true in `M`. Here, `M ⊨ T` denotes that the model `M` satisfies the theory `T`, and `M ⊨ φ` denotes that the model `M` satisfies the sentence `φ`.

For any first-order language L and type M structured according to L, a theory T is true in M if and only if every sentence φ in T is true in M (i.e., M ⊨ T if and only if ∀φ ∈ T, M ⊨ φ).


theorem Mathlib.ModelTheory.Order._auxLemma.3 :
    ∀ {α : Type u} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) := by sorry

The theorem `Mathlib.ModelTheory.Order._auxLemma.3` states that for any type `α`, any elements `x` and `a` of this type, and any set `s` of `α`, the membership of `x` in the set achieved by inserting `a` into `s` is equivalent to `x` being equal to `a` or `x` being a member of `s`. Essentially, it expresses the property of set insertion in the context of set membership: an element belongs to an extended set if and only if it is either the new element inserted or an element of the original set.

For any set `s` and elements `x` and `a` in a type `α`, `x ∈ s.insert a` if and only if `x = a` or `x ∈ s`.


theorem Mathlib.ModelTheory.Order._auxLemma.5 :
    ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∀ (a : α), a = a' ∨ q a → p a) = (p a' ∧ ∀ (a : α), q a → p a) := by
  sorry

The theorem states that for any type `α`, two predicate functions `p` and `q` defined on `α`, and an element `a'` of type `α`, the statement "for all elements `a` of type `α`, `a` being equal to `a'` or `q(a)` implies `p(a)`" is equivalent to the statement "`p(a')` is true and for all elements `a` of type `α`, `q(a)` implies `p(a)`". This theorem essentially relates a certain condition on all elements of a type with a condition on a specific element and all elements satisfying another condition.

For any type `α`, predicates `p` and `q` on `α`, and element `a'` of type `α`, the statements "for all `a`, `a = a' ∨ q(a) → p(a)`" and "`p(a')` ∧ (∀a, q(a) → p(a))" are logically equivalent.


theorem FractionalIdeal.coe_one :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
      ↑1 = 1 :=
  by sorry

This theorem states that for any commutative ring `R`, submonoid `S` of `R`, another type `P` which is also a commutative ring, and an algebra structure over `R` and `P`, the coercion of the multiplicative identity `1` (seen as a fractional ideal) is equal to the multiplicative identity in the ring. In other words, when we view `1` as a fractional ideal and then convert it back into the ring, it remains as the identity element.

For any commutative rings R and P, a submonoid S of R, and an algebra structure over R and P, the coercion of the multiplicative identity 1 as a fractional ideal in R equals the multiplicative identity in R.


theorem Set.restrict_eq : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.restrict s f = f ∘ Subtype.val :=
  by sorry

The theorem `Set.restrict_eq` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of elements from `α`, the restriction of `f` to `s`, denoted by `Set.restrict s f`, is equal to the composition of `f` and `Subtype.val`. In other words, restricting a function's domain to a subset and extracting the underlying element from a subtype yield the same result when applied to an element of the subtype. This theorem reflects the fact that restricting the domain of a function to a subset doesn't change the behavior of the function on that subset.

For any type `α`, set `s ⊆ α`, function `f : α → β`, and `x ∈ s`, `Set.restrict s f x = f (Subtype.val x)`.


theorem Mathlib.Algebra.AddTorsor._auxLemma.2 :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {p₁ p₂ : P}, (p₁ -ᵥ p₂ = 0) = (p₁ = p₂) :=
  by sorry

This theorem, `Mathlib.Algebra.AddTorsor._auxLemma.2`, states that for any types `G` and `P`, where `G` is an additive group and `P` is an additive torsor over `G`, and for any two elements `p₁` and `p₂` of `P`, the difference `p₁ -ᵥ p₂` being equal to zero is equivalent to `p₁` being equal to `p₂`. In other words, in the context of additive torsors, subtracting one point from another and getting zero indicates that the two points are identical.

In an additive torsor over an additive group, two elements are equal if and only if their difference is the zero element of the group.


theorem Cube.insertAt_boundary :
    ∀ {N : Type u_1} [inst : DecidableEq N] (i : N) {t₀ : ↑unitInterval} {t : { j // j ≠ i } → ↑unitInterval},
      (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i } → (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N :=
  by sorry

This theorem, `Cube.insertAt_boundary`, states that for any type `N` with decidable equality and any element `i` of type `N`, if a pair `(t₀, t)` is such that `t₀` is either 0 or 1, or `t` is on the boundary of the cube `{ j // j ≠ i }`, then the image of `(t₀, t)` under the homeomorphism `Cube.insertAt i` is on the boundary of the cube `N`. In simple terms, it says that the boundary of a lower-dimensional cube maps to the boundary of a higher-dimensional cube under a certain homeomorphism.

If `i` is an element of type `N` and `(t₀, t)` is either `(0, t)`, `(1, t)`, or `t` is on the boundary of the cube `{ j // j ≠ i }`, then `Cube.insertAt i (t₀, t)` is a boundary point of `N`.


theorem Nat.maxPowDiv.go_eq :
    ∀ {k p n : ℕ},
      Nat.maxPowDiv.go k p n = if 1 < p ∧ 0 < n ∧ n % p = 0 then Nat.maxPowDiv.go (k + 1) p (n / p) else k :=
  by sorry

The theorem `Nat.maxPowDiv.go_eq` states that for any natural numbers `k`, `p`, and `n`, the function `Nat.maxPowDiv.go` applied to `k`, `p`, and `n` equals `k` if `p` is less than or equal to 1, or `n` is zero, or `n` is not divisible by `p`. However, if `p` is greater than 1, `n` is positive and `n` is divisible by `p`, the function `Nat.maxPowDiv.go` equals the result of recursively calling the function itself but with `k + 1` and `n` divided by `p`. In other words, this function recursively divides `n` by `p` and increments `k` as long as `n` is divisible by `p` and `p` is greater than 1.

The theorem `Nat.maxPowDiv.go_eq` states that `Nat.maxPowDiv.go k p n = k` if `p <= 1` or `n = 0` or `n mod p /= 0`, and otherwise `Nat.maxPowDiv.go (k + 1) (n // p)`.


Submonoid.LocalizationMap.ext

theorem Submonoid.LocalizationMap.ext :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      {f g : Submonoid.LocalizationMap S N},
      (∀ (x : M), (Submonoid.LocalizationMap.toMap f) x = (Submonoid.LocalizationMap.toMap g) x) → f = g :=
  by sorry

The theorem `Submonoid.LocalizationMap.ext` states that for any two localization maps `f` and `g` from a submonoid `S` of a commutative monoid `M` to another commutative monoid `N`, if for every element `x` in `M`, applying the function version of `f` to `x` yields the same result as applying the function version of `g` to `x`, then `f` and `g` are the same localization map. Here, `(Submonoid.LocalizationMap.toMap f) x` and `(Submonoid.LocalizationMap.toMap g) x` are the function versions of the localization maps `f` and `g` respectively.

If for all `x` in a commutative monoid `M`, the function versions of localization maps `f` and `g` from a submonoid `S` of `M` to another commutative monoid `N` agree on `x`, then `f` and `g` are equal as localization maps.


/-- The natural homomorphism from a monoid to its quotient by a congruence relation is
surjective.  -/
theorem Con.mk'_surjective : ∀ {M : Type u_1} [inst : MulOneClass M] {c : Con M}, Function.Surjective ⇑(Con.mk' c) := by
  sorry

This theorem states that the natural homomorphism from a monoid to its quotient by a congruence relation is surjective. In other words, for any given monoid `M` with a multiplication and unit structure (`MulOneClass M`), and any congruence relation `c` on `M`, every element in the quotient of `M` by `c` can be reached by applying the natural homomorphism to some element in `M`.

The natural homomorphism from a monoid to its quotient by a congruence relation is surjective, that is, every coset contains an element that maps to the identity element under the homomorphism.


/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`.  -/
theorem Subring.closure_induction :
    ∀ {R : Type u} [inst : Ring R] {s : Set R} {p : R → Prop} {x : R},
      x ∈ Subring.closure s →
        (∀ x ∈ s, p x) →
          p 0 →
            p 1 →
              (∀ (x y : R), p x → p y → p (x + y)) →
                (∀ (x : R), p x → p (-x)) → (∀ (x y : R), p x → p y → p (x * y)) → p x :=
  by sorry

This theorem, named `Subring.closure_induction`, is an induction principle for membership in the closure of a set in a ring structure. It states that for any type `R` equipped with a ring structure, any set `s` of elements of `R`, any property `p` applicable to elements of `R`, and any element `x` of `R`, if `x` belongs to the subring generated by `s`, then if `p` holds for all elements of `s`, for `0` and `1`, and is preserved under the operations of addition, negation, and multiplication, then `p` must also hold for `x`. In essence, this theorem allows us to extend properties from a generating set and basic ring elements to the entire generated subring under certain conditions.

If `s` is a set of elements in a ring `R`, `p` is a property that holds for all elements in `s`, `0`, and `1`, and is preserved under ring operations, then `p` holds for every element in the subring generated by `s` that contains `x`.


theorem Encodable.mem_decode₂ :
    ∀ {α : Type u_1} [inst : Encodable α] {n : ℕ} {a : α}, a ∈ Encodable.decode₂ α n ↔ Encodable.encode a = n := by
  sorry

This theorem states that for any type `α` that is encodable, a given natural number `n`, and an element `a` of type `α`, the element `a` is in the result of decoding `n` with the failsafe variant `decode₂` if and only if `n` is the result of encoding `a`. In other words, the encoding of `a` results in `n` if and only if `n` can be safely decoded back into `a`. This forms a kind of "round trip" property for the encoding and failsafe decoding operations: encoding an element and then decoding it returns the original element.

For any encodable type `α`, the encoding of `a : α` equals the natural number `n` if and only if `a` is the result of decoding `n` using `decode₂`.


theorem Nat.pos_of_mem_divisors : ∀ {n m : ℕ}, m ∈ Nat.divisors n → 0 < m := by sorry

The theorem `Nat.pos_of_mem_divisors` states that for any two natural numbers `n` and `m`, if `m` is a member of the set of divisors of `n` (as defined by `Nat.divisors n`), then `m` is greater than zero. In other words, any divisor of a natural number, excluding zero itself, is always a positive natural number.

For all natural numbers `n` and `m`, if `m` is in the set of divisors of `n` (`m ∈ Nat.divisors n`), then `m` is a positive natural number (`m > 0`).


theorem Filter.Tendsto.div_const :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [inst_2 : ContinuousMul G₀]
      {f : α → G₀} {l : Filter α} {x : G₀},
      Filter.Tendsto f l (nhds x) → ∀ (y : G₀), Filter.Tendsto (fun a => f a / y) l (nhds (x / y)) :=
  by sorry

The theorem `Filter.Tendsto.div_const` states that for any type `α`, for any `G₀` which is a division and inversion monoid (essentially a structure with multiplication, division, and an inverse operation), and which is also a topological space with continuous multiplication. Given a function `f` from `α` to `G₀`, a filter `l` in `α`, and an element `x` in `G₀`, if `f` tends to `x` with respect to the filter `l` (i.e., for every neighborhood of `x`, the pre-image of the neighborhood under `f` is within the filter `l`), then for any element `y` in `G₀`, the function which maps `a` in `α` to `f(a)/y` also tends to `x/y` with respect to the same filter `l`. This essentially means if `f` converges to `x` then `f` divided by a constant `y` converges to `x/y`.

If `f : α → G₀` tends to `x` in `G₀` with respect to filter `l` in `α`, then the function `g(a) = f(a) / y` tends to `x / y` in `G₀` with respect to the same filter `l`.


DifferentiableAt.prod

theorem DifferentiableAt.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {x : E} {f₂ : E → G},
      DifferentiableAt 𝕜 f₁ x → DifferentiableAt 𝕜 f₂ x → DifferentiableAt 𝕜 (fun x => (f₁ x, f₂ x)) x :=
  by sorry

The theorem `DifferentiableAt.prod` states that, for any non-trivially normed field `𝕜`, normed additive commutative group and `𝕜`-normed space structures on types `E`, `F`, and `G`, if functions `f₁ : E → F` and `f₂ : E → G` are both differentiable at a point `x` in `E`, then the function that maps `x` to the tuple `(f₁ x, f₂ x)` is also differentiable at `x`. In other words, the differentiability of individual functions implies the differentiability of their product function at the same point.

If `f₁ : E → F` and `f₂ : E → G` are differentiable at `x` in the `𝕜`-normed spaces `E`, `F`, and `G`, then the function `(f₁, f₂) : E → F × G` is differentiable at `x`.


theorem ZNum.lt_to_int : ∀ {m n : ZNum}, ↑m < ↑n ↔ m < n := by sorry

This theorem establishes an equivalence between the less-than relation for two arbitrary `ZNum` numbers, `m` and `n`, and the less-than relation for their corresponding integer counterparts (obtained by casting `m` and `n` to integers). In other words, `m` is less than `n` if and only if the integer representation of `m` is less than the integer representation of `n`.

 For all `m` and `n` as `ZNum`, `m < n` if and only if to_int m < to_int n`.

Here, `to_int` is the function that converts a `ZNum` to an integer.


theorem Set.unop_op : ∀ {α : Type u_1} (s : Set αᵒᵖ), Set.op (Set.unop s) = s := by sorry

The theorem `Set.unop_op` states that for any type `α` and for any set `s` of elements of type `α`'s opposite, the operation of first applying the `unop` operation on `s` (which converts each of its elements to the opposite type) and then applying the `op` operation (converting them back to the original type) leaves the set `s` unchanged. This theorem captures the idea that these two operations are inverses of each other in the context of sets.

For any set `s` of type `α`, the application of `op` after `unop` on the elements of `s` results in the original set `s`. In other words, `unop` and `op` are inverse operations on sets of type `α`.


/-- The identity element of an `AddLocalization` is defined as `⟨0, 0⟩`.

Should not be confused with the ring localization counterpart `Localization.zero`,
which is defined as `⟨0, 1⟩`. -/
theorem AddLocalization.zero_def :
    ∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M), AddLocalization.zero S = Zero.zero := by sorry

The theorem `AddLocalization.zero_def` states that for any type `M` that is an instance of the additive commutative monoid, and for any additive submonoid `S` of `M`, the zero element of the additive localization of `S` is the same as the zero element of the underlying type. This means that the identity element in this additive localization context, represented as the pair `⟨0, 0⟩`, is equivalent to the zero of the underlying structure. This definition should not be confused with the zero of ring localization, which is defined as `⟨0, 1⟩`.

For any additive commutative monoid M and its submonoid S, the zero element of the additive localization of S is identical to the zero element of M.


theorem Polynomial.mirror_natDegree :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R),
      Polynomial.natDegree (Polynomial.mirror p) = Polynomial.natDegree p :=
  by sorry

This theorem states that for any given polynomial `p` in a semiring `R`, the natural degree of the mirror of `p` is equal to the natural degree of `p` itself. In other words, the operation of mirroring, which reverses the coefficients of the polynomial while preserving its natural degree, doesn't change the natural degree of the polynomial.

For any polynomial `p` in a semiring `R`, the natural degree of the mirrored polynomial is equal to the natural degree of `p`.


ContinuousLinearMap.hasSum

/-- Applying a continuous linear map commutes with taking an (infinite) sum.  -/
theorem ContinuousLinearMap.hasSum :
    ∀ {ι : Type u_5} {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
      [inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂} {f : ι → M}
      (φ : M →SL[σ] M₂) {x : M}, HasSum f x → HasSum (fun b => φ (f b)) (φ x) :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, additively commutative monoids `M` and `M₂`, any `R`-module `M` and `R₂`-module `M₂`, where `M` and `M₂` are also topological spaces, a ring homomorphism `σ` from `R` to `R₂`, and a continuous linear map `φ` from `M` to `M₂`, if a sequence `f` (from an index set `ι` to `M`) sums to a value `x` in `M`, then the sequence obtained by applying the map `φ` to each term of `f` sums to `φ(x)` in `M₂`. In other words, applying a continuous linear map commutes with taking an infinite sum.

Given ring homomorphisms `σ: R → R₂`, continuous linear maps `φ: M → M₂` between additively commutative monoids `M` and `M₂`, topological spaces `M` and `M₂`, and `R`-module/`R₂`-module structures on `M` and `M₂`, if a sequence `(x_i : M)` from an index set `ι` sums to `x` in `M`, then `(φ(x_i): M₂)` sums to `φ(x)` in `M₂`.


theorem Polynomial.derivative_apply :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
      Polynomial.derivative p = Polynomial.sum p fun n a => Polynomial.C (a * ↑n) * Polynomial.X ^ (n - 1) :=
  by sorry

The theorem `Polynomial.derivative_apply` states that for any semiring `R` and any polynomial `p` over `R`, the derivative of `p` is equivalent to summing the results of a function applied to the coefficients of the polynomial `p`. This function multiplies each coefficient `a` by its corresponding power `n`, converts the product to a constant polynomial via the `Polynomial.C` function and then multiplies it by `X` raised to the power `(n - 1)`. In other words, it is carrying out the formal derivative of a polynomial, where each term `aX^n` is transformed to `naX^(n-1)`.

For any semiring `R` and polynomial `p` over `R`, the derivative of `p` is equal to the sum of the polynomials obtained by multiplying each coefficient `a` of `p` by `X^(n-1)` and raising `X` to the power `n`, where `n` is the degree of the corresponding term, and summing these polynomials over all terms in `p`.


theorem Prod.Lex.le_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LE β] (a b : α × β),
      toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 :=
  by sorry

This theorem, `Prod.Lex.le_iff`, states that for any two pairs of types `α` and `β`, denoted by `a` and `b`, where `α` has a less than (`<`) operation and `β` has a less than or equal to (`≤`) operation, the `toLex` function applied to `a` is less than or equal to the `toLex` function applied to `b` if and only if the first element of `a` is less than the first element of `b` or the first elements of `a` and `b` are equal and the second element of `a` is less than or equal to the second element of `b`. In essence, it's providing a relation between the `toLex` function and the ordering of the elements within the pairs.

For types `α` and `β` with less-than relations `<` and `≤`, respectively, the `toLex (a, x)` is less than or equal to `toLex (b, y)` if and only if `x < y` or `x = y` and `a < b`.


theorem List.prefix_refl : ∀ {α : Type u_1} (l : List α), l <+: l := by sorry

This theorem, `List.prefix_refl`, states that for any type of data `α` and a certain list `l` of that type, `l` is always a prefix of itself. In other words, any list `l` is considered as the starting subsequence of itself.

For any list `l` of type `α`, `l` is a prefix of itself.


RelEmbedding.wellFounded

theorem RelEmbedding.wellFounded :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop}, r ↪r s → WellFounded s → WellFounded r := by
  sorry

This theorem states that for any two types `α` and `β`, and any two relations `r` on `α` and `s` on `β`, if `r` is a relational embedding of `s` (i.e., `r ↪r s`), and if `s` is well-founded (meaning there is no infinite decreasing sequence), then `r` must also be well-founded. In other words, relational embedding preserves the property of well-foundedness from one relation to another.

If `r` is a relational embedding of well-founded relation `s`, then `r` is a well-founded relation.


/-- If an element `b` becomes `M`-regular after multiplying it on the left by an `M`-regular
element, then `b` is `M`-regular.  -/
theorem IsSMulRegular.of_smul :
    ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {s : S} [inst : SMul R M] [inst_1 : SMul R S] [inst_2 : SMul S M]
      [inst : IsScalarTower R S M] (a : R), IsSMulRegular M (a • s) → IsSMulRegular M s :=
  by sorry

The theorem states that for any types `R`, `S`, and `M`, and for any given element `s` of type `S`, if `s` becomes `M`-regular when it is left-multiplied with an `M`-regular element `a` of type `R`, then `s` itself is `M`-regular. Here, `M`-regularity of an element means that left-multiplication with that element induces an injective (or one-to-one) function from `M` to `M`. The theorem assumes scalar multiplication structures on `R` and `S` with `M` respectively, and it also assumes that `R`, `S` and `M` form a scalar tower, which means that multiplication of scalars is associative across the types `R`, `S`, and `M`.

If `s` in `S` becomes `M`-regular when left-multiplied with an `M`-regular element `a` in `R`, then `s` is `M`-regular, given scalar multiplication structures and `M` being a common submodule of `R` and `S` forming a scalar tower.


theorem exterior_def :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] (s : Set α), exterior s = ⋂₀ {t | IsOpen t ∧ s ⊆ t} := by sorry

The theorem `exterior_def` states that for all types `α` which have a topology, and for any set `s` of elements of type `α`, the exterior of `s` is equivalent to the intersection of all open sets `t` such that `s` is a subset of `t`. In other words, the exterior of a set `s` in a topological space is formed by intersecting all open sets which contain `s`.

The exterior of a set in a topological space is equal to the intersection of all open sets that contain it.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.6 :
    ∀ {α : Type u_2} [inst : Neg α] {s : Set α} {a : α}, (a ∈ -s) = (-a ∈ s) := by sorry

This theorem, `Mathlib.Data.Set.Pointwise.Basic._auxLemma.6`, states that for any type `α` which has a negation operation, any set `s` of type `α`, and any element `a` of type `α`, the element `a` is in the negation of the set `s` if and only if the negation of `a` is in the set `s`. In other words, an element is in the negation of a set if and only if its negation is in the original set.

For any type `α` with negation and set `s` of type `α`, element `a` is in the complement of `s` if and only if the negation of `a` is in `s`.


theorem IsCompl.isCoatom_iff_isAtom :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : IsModularLattice α] {a b : α},
      IsCompl a b → (IsCoatom a ↔ IsAtom b) :=
  by sorry

The theorem `IsCompl.isCoatom_iff_isAtom` states that for any type `α` that forms a bounded modular lattice, given any two elements `a` and `b` of this lattice, if `a` and `b` are complements, then `a` is a coatom if and only if `b` is an atom. In other words, if `a` and `b` are complementary in the lattice, then `a` being just below the top element (`⊤`) with no other elements in between corresponds to `b` being just above the bottom element (`⊥`) with no other elements in between, and vice versa.

For any bounded modular lattice type `α`, if `a` and `b` are complementary elements, then `a` is a coatom if and only if `b` is an atom.


theorem Finset.image_eq_empty :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α}, Finset.image f s = ∅ ↔ s = ∅ :=
  by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, the image of a finite set `s` under the function `f` is empty if and only if the original set `s` is empty. In mathematical terms, for a function `f: α → β` and a set `s ⊆ α`, `f(s) = ∅` if and only if `s = ∅`. This relies on the fact that equality is decidable in `β`.

For any function `f: α → β` and set `s ⊆ α`, `f(s) = ∅` if and only if `s = ∅`, given decidable equality in `β`.


theorem Complex.ofReal_tan : ∀ (x : ℝ), ↑(Real.tan x) = Complex.tan ↑x := by sorry

This theorem states that for any real number `x`, the complex number equivalent of the real tangent function of `x` is equal to the complex tangent function of `x` as a complex number. In mathematical terms, this can be expressed as: for all real numbers `x`, `Complex.tan (x)` equals `Real.tan (x)`, where `Complex.tan` and `Real.tan` are the tangent functions extended to the complex and real numbers, respectively.

For all real numbers x, the complex tangent of x equals the real tangent of x. (Complex.tan x = Real.tan x)


theorem ENNReal.toReal_rpow : ∀ (x : ENNReal) (z : ℝ), x.toReal ^ z = (x ^ z).toReal := by sorry

This theorem states that for every extended nonnegative real number `x` and any real number `z`, the operation of raising the real part of `x` to the power of `z` is equivalent to first raising `x` to the power of `z` and then taking the real part. In mathematical notation: for all $x \in [0, \infty]$ and $z \in \mathbb{R}$, $(\text{toReal}(x))^z = \text{toReal}(x^z)$. This property establishes a consistent interaction between the power operation and the transition from extended nonnegative real numbers to real numbers.

For all $x \in [0, \infty]_{\mathbb{R}}$ and $z \in \mathbb{R}$, $\text{toReal}(x^z) = (\text{toReal}(x))^z$.


theorem intervalIntegral.integral_congr_ae :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f g : ℝ → E}
      {μ : MeasureTheory.Measure ℝ},
      (∀ᵐ (x : ℝ) ∂μ, x ∈ Ι a b → f x = g x) → ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in a..b, g x ∂μ :=
  by sorry

This theorem states that for all real numbers 'a' and 'b' and for all functions 'f' and 'g' from the real numbers to a normed space 'E', if almost everywhere with respect to a given measure 'μ', 'f' and 'g' are equal on the interval from 'a' to 'b', then the interval integrals of 'f' and 'g' over that interval with respect to 'μ' are equal. This is a statement about the equality of integrals under the condition of almost everywhere equality of the functions being integrated.

If real-valued functions $f$ and $g$ on a measure space agree almost everywhere on an interval with respect to a given measure, then their integrals over that interval are equal.


theorem Mathlib.GroupTheory.OrderOfElement._auxLemma.5 : ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) := by sorry

This theorem, in the context of group theory and order of elements, states that for any two propositions 'a' and 'b', the negation of the conjunction of 'a' and 'b' (not (a and b)) is logically equivalent to the implication that if 'a' is true, then 'b' must be false (a implies not b).
In other words, it says that it's not possible for both 'a' and 'b' to be true at the same time if and only if the truth of 'a' guarantees the falsity of 'b'.

The negation of the conjunction of propositions 'a' and 'b' is logically equivalent to the implication 'a → ¬b'.


theorem Mathlib.GroupTheory.OrderOfElement._auxLemma.4 :
    ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x := by sorry

This theorem states that for any property `p` that can be assigned to elements `x` of a type `α`, the statement "there does not exist an element `x` for which the property `p` holds" is equivalent to the statement "for all elements `x`, the property `p` does not hold". In other words, there is no `x` such that `p(x)` is true if and only if `p(x)` is false for every `x`.

The negation of "there exists an x : α such that p(x) holds" is equivalent to "for all x : α, not p(x) holds".


/-- A preadditive category with finite products has finite biproducts.  -/
theorem CategoryTheory.Limits.HasFiniteBiproducts.of_hasFiniteProducts :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasFiniteProducts C], CategoryTheory.Limits.HasFiniteBiproducts C :=
  by sorry

This theorem states that for any Type 'C', if 'C' is a category, preadditive (a mathematical property indicating that the operation of addition is available and behaves as expected), and has finite products (an operation in category theory that generalizes the cartesian product), then 'C' necessarily has finite biproducts (a concept in category theory that generalizes the notions of product and coproduct).
In other words, the presence of finite products in a preadditive category implies the presence of finite biproducts.

In a preadditive category with finite products, finite biproducts exist.


Set.Nonempty.snd

theorem Set.Nonempty.snd :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Set.Nonempty (s ×ˢ t) → Set.Nonempty t := by sorry

This theorem states that for any two types `α` and `β`, and any two sets `s` of type `α` and `t` of type `β`, if the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is nonempty, then the set `t` must also be nonempty. In mathematical terms, if there exists at least one ordered pair `(x, y)` such that `x` is in `s` and `y` is in `t`, then there must exist at least one element in `t`.

If a cartesian product of non-empty sets is nonempty, then each of the sets is nonempty.


/-- **The Lebesgue Decomposition theorem between a signed measure and a measure**:
Given a signed measure `s` and a σ-finite measure `μ`, there exist a signed measure `t` and a
measurable and integrable function `f`, such that `t` is mutually singular with respect to `μ`
and `s = t + μ.withDensityᵥ f`. In this case `t = s.singularPart μ` and
`f = s.rnDeriv μ`.  -/
theorem MeasureTheory.SignedMeasure.singularPart_add_withDensity_rnDeriv_eq :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : MeasureTheory.SignedMeasure α)
      [inst : MeasureTheory.SignedMeasure.HaveLebesgueDecomposition s μ],
      MeasureTheory.SignedMeasure.singularPart s μ +
          MeasureTheory.Measure.withDensityᵥ μ (MeasureTheory.SignedMeasure.rnDeriv s μ) =
        s :=
  by sorry

The theorem, named "MeasureTheory.SignedMeasure.singularPart_add_withDensity_rnDeriv_eq", is a statement of the Lebesgue Decomposition theorem for a signed measure and a measure. It states that for any given signed measure 's' and a σ-finite measure 'μ', there exist a signed measure 't' and a measurable, integrable function 'f', such that 't' is mutually singular with respect to 'μ', and 's' can be expressed as the sum of 't' and the product of 'μ' and the density function 'f'. This theorem further states that in this case, 't' is equivalent to the singular part of 's' with respect to 'μ', and 'f' is equivalent to the Radon-Nikodym derivative of 's' with respect to 'μ'.

For any signed measure 's' and σ-finite measure 'μ', there exists a signed measure 't' mutually singular with 'μ' and a measurable, integrable function 'f' such that 's' = 't' + 'μ'∘'f'.


theorem isAtomistic_dual_iff_isCoatomistic :
    ∀ {α : Type u_1} [inst : CompleteLattice α], IsAtomistic αᵒᵈ ↔ IsCoatomistic α := by sorry

This theorem states that for any type `α` equipped with a structure of `CompleteLattice`, the dual lattice `αᵒᵈ` is atomistic if and only if the original lattice `α` is coatomistic. In the context of lattice theory, a lattice is said to be atomistic if any element can be written as a join of atoms, and coatomistic if any element can be written as a meet of coatoms. The theorem thus provides a duality between atomistic and coatomistic lattices, saying that flipping the lattice (forming the dual) swaps these two properties.

A complete lattice `α` has atomistic dual if and only if it is coatomistic.


theorem Ordinal.nfp_le_fp :
    ∀ {f : Ordinal.{u_1} → Ordinal.{u_1}},
      Monotone f → ∀ {a b : Ordinal.{u_1}}, a ≤ b → f b ≤ b → Ordinal.nfp f a ≤ b :=
  by sorry

The theorem `Ordinal.nfp_le_fp` states that for all functions `f` from an ordinal to an ordinal, if `f` is monotone, then for all ordinals `a` and `b`, if `a` is less than or equal to `b` and `f` of `b` is less than or equal to `b`, then the least fixed point of `f` that is at least `a` is less than or equal to `b`. In other words, for a monotone function `f` on ordinals, the least fixed point of `f` that is at least `a`, does not exceed `b` under the conditions that `a` does not exceed `b` and the value of `f` at `b` does not exceed `b`.

For any monotonic function f from ordinals to ordinals, if a ≤ b and f(b) ≤ b hold, then the least fixed point of f above a is less than or equal to b.


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

This theorem states that for all propositions 'a' and 'b', the biconditional 'a if and only if b' is equivalent to the conjunction of 'if a then b' and 'if b then a'. Put simply, 'a' is equivalent to 'b' if 'a' implies 'b' and 'b' implies 'a'.

The biconditional "a if and only if b" is logically equivalent to the conjunction of "if a then b" and "if b then a".


theorem AddCommute.nsmul_left :
    ∀ {M : Type u_2} [inst : AddMonoid M] {a b : M}, AddCommute a b → ∀ (n : ℕ), AddCommute (n • a) b := by sorry

This theorem states that for any type `M` that is an additive monoid, and any two elements `a` and `b` of `M` that commute under addition, together with any natural number `n`, the `n`-fold addition of `a` (denoted `n • a`) still commutes with `b`. In other words, if `a + b = b + a`, then `n * a + b = b + n * a` for all natural numbers `n`, where `*` denotes the repeated addition.

For any additive monoid `M` and commuting elements `a, b` in `M`, the `n`-fold addition of `a` commutes with `b` for all natural numbers `n`, i.e., `n • a + b = b + n • a`.


theorem Subgroup.map_map :
    ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {N : Type u_5} [inst_1 : Group N] {P : Type u_6}
      [inst_2 : Group P] (g : N →* P) (f : G →* N),
      Subgroup.map g (Subgroup.map f K) = Subgroup.map (MonoidHom.comp g f) K :=
  by sorry

The theorem `Subgroup.map_map` states that for any two group homomorphisms `f` and `g` from groups `G` to `N` and `N` to `P` respectively, and any subgroup `K` of group `G`, the image of the subgroup `K` under the composition of `f` and `g` is the same as the image of the image of `K` under `f` under `g`. In mathematical terms, if you have two group homomorphisms `f: G → N` and `g: N → P`, and a subgroup `K` of `G`, then `g(f(K)) = (g ∘ f)(K)`. This theorem essentially asserts the compatibility of the map function with the composition of homomorphisms in the context of subgroups.

For any group homomorphisms f : G → N and g : N → P, and subgroup K of G, g(f(K)) = (g ∘ f)(K).


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

The theorem `RatFunc.mk_eq_div'` states that for any commutative ring `K` that is also an integral domain, and any two polynomials `p` and `q` over `K`, the rational function `RatFunc.mk p q` is equal to the fraction where the numerator is the embedding of `p` into the fraction ring of polynomials over `K` and the denominator is the embedding of `q` into the same fraction ring. In other words, `RatFunc.mk p q` is equivalent to the fraction $\frac{\text{{algebraMap}}(p)}{\text{{algebraMap}}(q)}$ in the fraction ring of polynomials over `K`, where $\text{{algebraMap}}$ is the embedding given by the `Algebra` structure.

For any commutative integral domain K, the rational function RatFunc.mk p q over K is equal to the fraction of the polynomial embeddings algebraMap(p) and algebraMap(q) in the fraction ring of polynomials over K.


ContinuousMap.HomotopyWith.prop

theorem ContinuousMap.HomotopyWith.prop :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
      {P : C(X, Y) → Prop} (F : ContinuousMap.HomotopyWith f₀ f₁ P) (t : ↑unitInterval),
      P ((ContinuousMap.Homotopy.curry F.toHomotopy) t) :=
  by sorry

This theorem states that for any topological spaces `X` and `Y`, and any continuous maps `f₀` and `f₁` from `X` to `Y`, given a property `P` that applies to continuous maps from `X` to `Y`, if there exists a homotopy `F` between `f₀` and `f₁` that satisfies `P`, then for every point `t` in the unit interval `[0,1]`, the continuous map obtained by currying the homotopy `F` at point `t` also satisfies the property `P`.

Given continuous maps `f₀`, `f₁` : X -> Y between topological spaces `X` and `Y`, a homotopy `F` : X x [0,1] -> Y between `f₀` and `f₁`, and a property `P` that preserves composition with continuous functions, if `F` satisfies `P`, then for all `t` in [0,1], the map `x => F(x, t)` satisfies `P`.


theorem mul_left_eq_self : ∀ {M : Type u} [inst : RightCancelMonoid M] {a b : M}, a * b = b ↔ a = 1 := by sorry

This theorem, `mul_left_eq_self`, states that for any type `M` that forms a right cancelable monoid (a type of algebraic structure), and any two elements `a` and `b` of `M`, the equation `a * b = b` holds if and only if `a` equals 1. In mathematical notation, this would be written as ∀a, b ∈ M, a * b = b ↔ a = 1. This means that multiplying an element by another is the same as the second element itself only when the first element is the identity element of the monoid (in this case, 1).

For any right cancelable monoid M and elements a, b in M, a * b = b if and only if a is the identity element 1.


theorem Polynomial.hasDerivAt_aeval :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R 𝕜]
      (q : Polynomial R) (x : 𝕜),
      HasDerivAt (fun x => (Polynomial.aeval x) q) ((Polynomial.aeval x) (Polynomial.derivative q)) x :=
  by sorry

The theorem `Polynomial.hasDerivAt_aeval` states that for any nontrivially normed field `𝕜`, any commutative semiring `R`, any `R`-algebra structure on `𝕜`, any polynomial `q` over `R`, and any element `x` of `𝕜`, the function that maps `x` to the evaluation of `q` at `x` has a derivative at `x`. The derivative at `x` is the evaluation of the derivative of `q` at `x`. In mathematical terms, if we denote the function `f(x) = (Polynomial.aeval x) q`, this theorem is saying that `f` has a derivative at `x`, and this derivative is `(Polynomial.aeval x) (Polynomial.derivative q)`.

For any nontrivially normed field `𝕜`, commutative semiring `R`, `R`-algebra structure on `𝕜`, polynomial `q` over `R`, and element `x` of `𝕜`, the function `f(x) = (Polynomial.aeval x) q` has derivative `(Polynomial.aeval x) (Polynomial.derivative q)` at `x`.


BiheytingHom.ext

theorem BiheytingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] {f g : BiheytingHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `BiheytingHom.ext`, states that for any two types `α` and `β`, both equipped with a structure of a Biheyting algebra, and for any two morphisms `f` and `g` from `α` to `β` in the category of Biheyting algebras, if `f` and `g` are pointwise equal (that is, for every element `a` of `α`, we have `f a = g a`), then `f` and `g` are the same morphism. This is a statement about the uniqueness of morphisms in the category of Biheyting algebras.

In the category of Biheyting algebras, two morphisms between two Biheyting algebra structures on types with pointwise equal mappings are equal as morphisms.


theorem GaloisConnection.u_eq_top :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : OrderTop α] {l : α → β}
      {u : β → α}, GaloisConnection l u → ∀ {x : β}, u x = ⊤ ↔ l ⊤ ≤ x :=
  by sorry

The theorem `GaloisConnection.u_eq_top` states that for any types `α` and `β`, with `α` being a partially ordered set and `β` being a preordered set, and `α` having a greatest element (`OrderTop α`), given two functions `l : α → β` and `u : β → α` that form a Galois Connection, for any element `x` of `β`, `u(x)` equals the greatest element of `α` if and only if `l` of the greatest element of `α` is less than or equal to `x`. In simpler terms, it states a condition under which the function `u` applied to any element gives the maximum element in a Galois connection.

For any Galois connection between partially ordered set `α` with greatest element `OrderTop α` and preordered set `β`, `u(x) = OrderTop α` if and only if `l(OrderTop α) ≤ x`.


theorem Set.eval_image_univ_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)} {i : ι},
      Set.Nonempty (Set.pi Set.univ t) → (fun f => f i) '' Set.pi Set.univ t = t i :=
  by sorry

This theorem states that for any index type `ι`, any indexed type `α`, any function `t` from `ι` to the set of elements of `α`, and any index `i` of type `ι`, if the set of all functions from `ι` to `α` (where, for each index `i` in the universal set, the function's value at `i` lies in `t i`) is nonempty, then the image of this set of functions under the function that maps each function to its value at `i` is equal to `t i`. In essence, if you have a nonempty set of functions and you apply each function to a specific index, you get exactly the set of all possible values at that index.

If `t : ι → α` and the set of functions from `ι` to `α` with values in `t` at each index is nonempty, then `{f ι | ∀ i, f i ∈ t} = t i`.


theorem eq_of_le_of_forall_le_of_dense :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] {a₁ a₂ : α},
      a₂ ≤ a₁ → (∀ (a : α), a₂ < a → a₁ ≤ a) → a₁ = a₂ :=
  by sorry

This theorem states that for all types `α` that have a linear order and are densely ordered, if we have two elements `a₁` and `a₂` of this type such that `a₂` is less than or equal to `a₁`, and for every element `a` of type `α`, if `a₂` is less than `a`, then `a₁` is less than or equal to `a`, then `a₁` must be equal to `a₂`. Essentially, it proves that in a densely ordered set, if one element is less than or equal to another and this remains true no matter how close we get to the second element from above, the two elements must be equal.

In a densely ordered type `α`, if `a₁ ≤ a₂` and for all `a ∈ α` with `a₂ < a`, we have `a₁ ≤ a`, then `a₁ = a₂`.


theorem Lists'.of_toList : ∀ {α : Type u_1} (l : Lists' α true), Lists'.ofList (Lists'.toList l) = l := by sorry

The theorem `Lists'.of_toList` states that for any type `α` and any `ZFA prelist` `l` of type `α`, when we convert `l` to a `List` of `ZFA lists` using the function `Lists'.toList` and then convert it back to a `ZFA prelist` using `Lists'.ofList`, we get `l` back. In other words, the functions `Lists'.toList` and `Lists'.ofList` are inverses of each other when moving from `ZFA prelists` to `Lists` of `ZFA lists` and back.

For any type `α` and any `ZFA prelist` `l` of type `α`, the functions `Lists'.ofList (Lists'.toList l)` and `l` are equal.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.52 :
    ∀ {α : Type u} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any set `s` of elements of type `α`, the statement "the set containing only `a` is a subset of `s`" is equivalent to "element `a` is a member of set `s`". In mathematical terms, we can express this as: for all `α`, `a`, and `s`, `{a} ⊆ s` if and only if `a ∈ s`.

For any type `α`, set `s` of elements from `α`, and `a` an element of `α`, the sets `{a}` and `s` are equal as sets if and only if `a` is an element of `s`.


theorem ENNReal.measurable_ofReal : Measurable ENNReal.ofReal := by sorry

This theorem states that the function `ENNReal.ofReal`, which maps any real number to its nonnegative equivalent, or 0 if it is negative, is a measurable function. In mathematical terms, for any measurable set in the extended nonnegative real numbers, the preimage of that set under `ENNReal.ofReal` is also a measurable set in the real numbers.

The function `ENNReal.ofReal` mapping real numbers to their nonnegative equivalents is measurable, i.e., the preimage of any measurable set in the extended nonnegative real numbers is a measurable set in the real numbers.


/-- A proposition is true on a set neighborhood of `s`
iff it is eventually true near each point in the set.  -/
theorem eventually_nhdsSet_iff_forall :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {p : X → Prop},
      (∀ᶠ (x : X) in nhdsSet s, p x) ↔ ∀ x ∈ s, ∀ᶠ (y : X) in nhds x, p y :=
  by sorry

The theorem `eventually_nhdsSet_iff_forall` states that, for any topological space `X`, a set `s` in `X`, and a proposition `p` about elements of `X`, a proposition `p` holds true on a neighborhood filter of the set `s` if and only if the proposition `p` is eventually true near each point in the set `s`. This essentially means that a property is true "locally" around the set `s` if and only if it is true in the "local" neighborhood of each individual point in `s`. The term "eventually true" is used in the context of filters to mean that the property holds for all points sufficiently close to a given point or set.

A set \(s \subseteq X\) in a topological space \(X\) satisfies the proposition \(p(x)\) for all \(x \in s\) in the neighborhood filter if and only if \(p(x)\) holds eventually in the neighborhood of each \(x \in s\).


theorem Asymptotics.IsBigOWith.congr_left :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {g : α → F} {l : Filter α}
      {f₁ f₂ : α → E}, Asymptotics.IsBigOWith c l f₁ g → (∀ (x : α), f₁ x = f₂ x) → Asymptotics.IsBigOWith c l f₂ g :=
  by sorry

The theorem `Asymptotics.IsBigOWith.congr_left` states that for any types `α`, `E`, and `F`, where `E` and `F` are equipped with a norm, a real number `c`, a function `g` from `α` to `F`, a filter `l` on `α`, and two functions `f₁` and `f₂` from `α` to `E`, if `f₁` is Big-O of `g` with constant `c` with respect to filter `l` (i.e., `Asymptotics.IsBigOWith c l f₁ g` holds), and every element of `α` is mapped to the same value by `f₁` and `f₂`, then `f₂` is also Big-O of `g` with the same constant `c` with respect to the same filter `l`. In other words, the Big-O relation is preserved under pointwise equality of the functions involved.

If `f₁` is Big-O of `g` with constant `c` with respect to filter `l` and `f₁` and `f₂` agree pointwise, then `f₂` is also Big-O of `g` with constant `c` with respect to `l`.


theorem isCompact_iff_ultrafilter_le_nhds :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsCompact s ↔ ∀ (f : Ultrafilter X), ↑f ≤ Filter.principal s → ∃ x ∈ s, ↑f ≤ nhds x :=
  by sorry

This theorem states that for any topological space `X` and any set `s` of `X`, the set `s` is compact if and only if for any ultrafilter `f` on `X`, if `f` is contained in the principal filter of `s`, then there exists an element `x` in `s` such that `f` is also contained in the neighborhood filter at `x`.

In mathematical terms, this implies that in a compact set, every ultrafilter (a maximally fine way of describing "large" subsets of `X`) that contains the set must "converge" to some point within the set. That is, every "large" subset of `s` (as identified by the ultrafilter) must have nonempty intersection with every neighborhood of that point. This is an alternative characterization of compactness in terms of filter theory.

A set in a topological space is compact if and only if every ultrafilter containing the set intersects the neighborhood filter of some point in the set.


theorem isLeast_csInf :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {s : Set α}
      [inst_1 : IsWellOrder α fun x x_1 => x < x_1], Set.Nonempty s → IsLeast s (sInf s) :=
  by sorry

The theorem `isLeast_csInf` states that for any type `α` that has a conditionally complete linear order, and for any set `s` of type `α` that is well-ordered under the strict less than relation, if the set `s` is nonempty then the infimum (greatest lower bound) of `s` is the least element of `s`. In other words, the infimum of `s` belongs to `s` and is less than or equal to every other element in `s`. The conditionally complete linear order ensures that every nonempty set `s`, which is bounded from below, has an infimum, and the well-ordering guarantees that there is a least element in `s`.

For any nonempty well-ordered set `s` in a conditionally complete linear order `α`, the infimum of `s` is the least element of `s`.


theorem Equiv.eq_image_iff_symm_image_eq :
    ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α) (t : Set β), t = ⇑e '' s ↔ ⇑e.symm '' t = s := by sorry

This theorem states that for any two types `α` and `β`, given an equivalence `e` between `α` and `β`, and two sets `s` of type `α` and `t` of type `β`, the set `t` equals the image of `s` under the mapping `e` if and only if the image of `t` under the inverse mapping of `e` equals `s`. In other words, the images of the sets `s` and `t` under the mapping and its inverse, respectively, are equal if and only if the sets themselves are equal under the given equivalence.

For any equivalence between types `α` and `β` and sets `s` of type `α` and `t` of type `β`, `s` and `t` are equal if and only if `t = e (s)` and `s = e⁻¹ (t)`, where `e` is the equivalence, `e (s)` is the image of `s` under `e`, and `e⁻¹ (t)` is the inverse image of `t` under `e`.


/-- A group element has finite order iff its order is positive.  -/
theorem orderOf_pos_iff : ∀ {G : Type u_1} [inst : Monoid G] {x : G}, 0 < orderOf x ↔ IsOfFinOrder x := by sorry

This theorem states that for any group element `x` in a monoid `G`, the element `x` has finite order if and only if its order is positive. In other words, there exists a positive integer `n` such that `x ^ n = 1` (which means `x` has finite order or `x` is of finite order) if and only if the order of `x` is greater than zero. This provides a condition for determining whether a group element has finite order in terms of its order being positive.

A group element x in a monoid has finite order if and only if its order is a positive integer.


theorem PMF.pure_bind : ∀ {α : Type u_1} {β : Type u_2} (a : α) (f : α → PMF β), PMF.bind (PMF.pure a) f = f a := by
  sorry

The theorem `PMF.pure_bind` states that for any type `α` and `β`, any element `a` of type `α`, and any function `f` mapping from `α` to probability mass function on `β` (PMF β), the bind operation of the "pure" probability mass function based on `a` and the function `f` is equivalent to directly applying the function `f` on `a`. In other words, it asserts that binding a function `f` onto a probability mass function that has all its mass concentrated at a single point `a` (i.e., `PMF.pure a`) simply results in the probability mass function that `f` maps `a` to.

For any type `α`, element `a` of type `α`, and function `f` mapping from `α` to probability mass functions on `β`, `PMF.pure a >>= f = f a`.


theorem Nat.properDivisors_zero : Nat.properDivisors 0 = ∅ := by sorry

The theorem `Nat.properDivisors_zero` states that the set of proper divisors of zero is empty. In the context of natural numbers, a proper divisor of a number is any divisor other than the number itself. However, zero doesn't have any proper divisors, hence the proper divisors of zero forms an empty set.

The set of proper divisors of zero is empty.


theorem hasFDerivAtFilter_pi' :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {L : Filter E} {ι : Type u_6} [inst_3 : Fintype ι] {F' : ι → Type u_7}
      [inst_4 : (i : ι) → NormedAddCommGroup (F' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
      {Φ' : E →L[𝕜] (i : ι) → F' i},
      HasFDerivAtFilter Φ Φ' x L ↔
        ∀ (i : ι), HasFDerivAtFilter (fun x => Φ x i) (ContinuousLinearMap.comp (ContinuousLinearMap.proj i) Φ') x L :=
  by sorry

The theorem `hasFDerivAtFilter_pi'` establishes an equivalence for the existence of a derivative of a function at a point under a certain filter condition. Specifically, it states that for a function `Φ : E → (i : ι) → F' i`, where `E` is a normed additively commutative group over a nontrivially normed field `𝕜`, the function `Φ' : E →L[𝕜] (i : ι) → F' i` is the derivative of `Φ` at a point `x` under a filter `L` if and only if for all `i : ι`, the function `fun x => Φ x i` has a derivative at `x` under the filter `L` with respect to the composition of the projection map at `i` and `Φ'`. The projection map comes from the family of topological modules `F' i` which are defined as normed additively commutative groups over `𝕜`.

The theorem `hasFDerivAtFilter_pi` states that a function `Φ : E → (i : ι) → F' i` has a derivative `Φ' : E →L[𝕜] (i : ι) → F' i` at a point `x` under a filter `L` if and only if for all `i : ι`, the function `fun x => Φ x i` has a derivative at `x` with respect to the composition of `Φ'` and the projection map at `i`, under filter `L`.


Set.Nontrivial.nonempty

theorem Set.Nontrivial.nonempty : ∀ {α : Type u} {s : Set α}, Set.Nontrivial s → Set.Nonempty s := by sorry

This theorem states that for any type `α` and any set `s` of this type, if the set `s` is nontrivial, then it is also nonempty. In other words, if a set has at least two distinct elements (which is the definition of a nontrivial set), then it also has at least one element (which is the definition of a nonempty set). This is a fundamental property of sets in mathematics, and is expressed here in the language of Lean 4 theorem proving.

If a set is nontrivial (has at least two distinct elements), then it is nonempty (has at least one element).


/-- If `f : β → α` sends any two distinct points to points at distance at least `ε > 0`, then
`f` is a uniform embedding with respect to the discrete uniformity on `β`.  -/
theorem Metric.uniformEmbedding_bot_of_pairwise_le_dist :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {β : Type u_3} {ε : ℝ},
      0 < ε → ∀ {f : β → α}, (Pairwise fun x y => ε ≤ dist (f x) (f y)) → UniformEmbedding f :=
  by sorry

The theorem `Metric.uniformEmbedding_bot_of_pairwise_le_dist` states that if we have a function `f` that maps from type `β` to type `α` in a `PseudoMetricSpace`, such that for any two distinct points in `β`, the distance between their images in `α` is at least a positive real number `ε`, then `f` is a uniform embedding with respect to the discrete uniformity on `β`. In other words, if `f` separates distinct points in `β` by at least a certain distance in `α`, it preserves the uniformity structure of `β` when mapped to `α`.

If a function from a distinct-pointed PseudoMetricSpace to another PseudoMetricSpace with the property that the distance between any pair of distinct points is greater than a positive real number, is a uniform embedding with respect to the discrete uniformity on the domain.


theorem Asymptotics.isEquivalent_const_iff_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u : α → β} {l : Filter α} {c : β},
      c ≠ 0 → (Asymptotics.IsEquivalent l u (Function.const α c) ↔ Filter.Tendsto u l (nhds c)) :=
  by sorry

The theorem `Asymptotics.isEquivalent_const_iff_tendsto` states that, for every type `α` and `β` where `β` is a normed additive commutative group, for every function `u` from `α` to `β`, for every filter `l` on `α`, and for every non-zero constant `c` of type `β`, the function `u` is asymptotically equivalent to the constant function with value `c` along the filter `l` if and only if the function `u` tends to `c` along the filter `l`. In other words, the difference between the function `u` and the constant function `c` becomes insignificant compared to `c` as we follow the filter `l` if and only if the function `u` approaches the constant value `c` when followed along the filter `l`.

A function from a type to a normed additive commutative group is asymptotically equivalent to a constant function along a filter if and only if it tends to that constant along the filter.


theorem MeasureTheory.self_mem_ae_restrict :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → s ∈ MeasureTheory.Measure.ae (μ.restrict s) :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` of `α`, a measure `μ` on the measurable space, and a set `s` of `α` that is measurable, the set `s` belongs to the "almost everywhere" filter of the measure restricted to `s`. In more intuitive terms, it says that under given conditions, a measurable set is almost everywhere in the restricted measure space of itself.

For any measurable space `(α, m0)`, measurable set `s` of `α`, and measure `μ` on `m0`, `s` belongs to the "almost everywhere" filter of the restriction `μ | s`.


theorem hnot_symmDiff_self : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), symmDiff (￢a) a = ⊤ := by sorry

The theorem `hnot_symmDiff_self` states that for any type `α` that is a co-heyting algebra, the symmetric difference of the negation (`￢a`) of an element `a` and `a` itself is always the top element (`⊤`). In other words, in a co-heyting algebra, the symmetric difference of an element and its negation always yields the maximal element.

In a co-heyting algebra, the symmetric difference of an element and its negation equals the top element.


theorem iSup_eq_top :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLinearOrder α] (f : ι → α), iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i := by
  sorry

This theorem states that for any type `α` that has a complete linear order structure and any function `f` from an index type `ι` to `α`, the indexed supremum of `f` (denoted `iSup f`) equals the greatest element (`⊤`) if and only if for every element `b` that is less than `⊤`, there exists an index `i` such that `b` is less than `f(i)`.

In other words, the supremum of the range of `f` is the greatest element if and only if for any value less than this greatest element, we can find an index where the function value at this index is more than the given value.

For a complete linear order type `α` and any function `f : ι → α`, the indexed supremum `iSup f` equals the greatest element `⊤` if and only if for all `b` < `⊤`, there exists an `i` such that `f(i)` > `b`.


theorem UFModel.Agrees.get_eq :
    ∀ {α : Type u_1} {β : Sort u_2} {f : α → β} {arr : Array α} {n : ℕ} {m : Fin n → β},
      UFModel.Agrees arr f m →
        ∀ (i : ℕ) (h₁ : i < Array.size arr) (h₂ : i < n),
          f (Array.get arr { val := i, isLt := h₁ }) = m { val := i, isLt := h₂ } :=
  by sorry

This theorem states that if there is an agreement between an array `arr` of type α, a function `f` mapping α to β, and another function `m` mapping indices to β, then for every index `i` that is less than the size of the array and less than `n`, applying the function `f` to the element in the array at index `i` will yield the same result as applying the function `m` to the index `i`. This agreement is denoted by `UFModel.Agrees arr f m` in the theorem.

For any array `arr` of type α, function `f` from α to β, and function `m` mapping indices to β, if `UFModel.Agrees arr f m` holds, then `f arr i = m i` for all indices `i` less than the array size.


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

The theorem `CategoryTheory.Functor.map_nsmul` states that for any types `C` and `D`, given a category structure on these types, a preadditive structure (i.e., an Abelian group structure on each hom-set) on these categories, a functor `F` from `C` to `D`, and an additive structure on the functor `F`, then the functor maps the `n`-fold scalar multiplication of a morphism `f` from `X` to `Y` in `C` to the `n`-fold scalar multiplication of the mapped morphism `F.map f` in `D`. In other words, if we consider `n • f` as adding `f` to itself `n` times, then applying the functor `F` and then adding `F.map f` to itself `n` times yields the same result as first adding `f` to itself `n` times and then applying `F`.

For any functors F between preadditive categories C and D endowed with additive structures, if F respects the Abelian group structure on hom-sets and scalar multiplication by natural numbers, then F maps the n-fold scalar multiplication of a morphism to the n-fold scalar multiplication of its image under F.


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

The theorem `Homeomorph.isOpen_preimage` states that for any two types `X` and `Y` with their respective topological space instances, and for any homeomorphism `h` from `X` to `Y`, a set `s` in `Y` is open if and only if its preimage under `h` is open in `X`. Here, the preimage of `s` under `h` is the set of all elements in `X` that `h` maps to `s`. This theorem essentially characterizes one of the key properties of homeomorphisms in topology, which is that they preserve the open (and also closed) sets between the topological spaces.

A homeomorphism preserves open sets between topological spaces: for any homeomorphism between topological spaces X and Y, and any open set s in Y, the preimage h⁻¹(s) in X is open.


theorem associatesEquivOfUniqueUnits_apply :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : Unique αˣ] (a : Associates α),
      associatesEquivOfUniqueUnits a = Associates.out a :=
  by sorry

The theorem `associatesEquivOfUniqueUnits_apply` states that for any type `α` that has a cancel-commutative monoid structure with zero and a unique unit (other than one), and for any element `a` of the Associates of `α`, the application of the monoid isomorphism `associatesEquivOfUniqueUnits` on `a` is equivalent to mapping the element `a` back to the normalized element of its associate class using the `Associates.out` function. In other words, the isomorphism `associatesEquivOfUniqueUnits` acts identically to the `Associates.out` function in this context.

For any type `α` with a cancel-commutative monoid structure, unique unit, and associates, the monoid isomorphism `associatesEquivOfUniqueUnits` and the function `Associates.out` agree on their application to any associate `a` of the unit.


/-- Converting an in-range number to `Fin (n + 1)` produces a result
whose value is the original number.   -/
theorem Fin.val_cast_of_lt : ∀ {n : ℕ} [inst : NeZero n] {a : ℕ}, a < n → ↑↑a = a := by sorry

This theorem, `Fin.val_cast_of_lt`, states that for any natural number `n` which is not zero, and any natural number `a` such that `a` is less than `n`, when `a` is converted to the finite type `Fin (n + 1)`, the resulting value is still the original number `a`. In other words, the operation of casting a number to a finite type doesn't change the value of the number, as long as the original number is in the valid range of the finite type.

For all natural numbers `n` and `a` with `a < n`, the conversion of `a` to the finite type `Fin (n + 1)` results in the same value.


theorem MvPowerSeries.mul_invOfUnit :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Ring R] (φ : MvPowerSeries σ R) (u : Rˣ),
      (MvPowerSeries.constantCoeff σ R) φ = ↑u → φ * MvPowerSeries.invOfUnit φ u = 1 :=
  by sorry

The theorem `MvPowerSeries.mul_invOfUnit` asserts that for any ring `R` and any multivariate formal power series `φ` indexed over a type `σ`, if the constant coefficient of `φ` is an invertible element `u` of the ring `R`, then the product of `φ` and the inverse of `φ` with respect to `u` is equal to one. In other words, if the constant term of a multivariate power series is an invertible element, then the power series is invertible and its inverse is given by `MvPowerSeries.invOfUnit φ u`.

If `φ` is a multivariate formal power series over a ring `R` with invertible constant coefficient `u`, then `φ` and `MvPowerSeries.invOfUnit φ u` are multiplicative inverses.


/-- **Fundamental theorem of calculus-2**, on semi-infinite intervals `(a, +∞)`.
When a function has a limit at infinity `m`, and its derivative is integrable, then the
integral of the derivative on `(a, +∞)` is `m - f a`. Version assuming differentiability
on `[a, +∞)`.  -/
theorem MeasureTheory.integral_Ioi_of_hasDerivAt_of_tendsto' :
    ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} {m : E} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : CompleteSpace E],
      (∀ x ∈ Set.Ici a, HasDerivAt f (f' x) x) →
        MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume →
          Filter.Tendsto f Filter.atTop (nhds m) → ∫ (x : ℝ) in Set.Ioi a, f' x = m - f a :=
  by sorry

This theorem is a version of the second Fundamental Theorem of Calculus for semi-infinite intervals $(a, +\infty)$. It states that if a function $f$ has a limit $m$ at infinity, and its derivative $f'$ is integrable over the interval $(a, +\infty)$, and additionally, if the function $f$ is differentiable on the interval $[a, +\infty)$, then the integral of $f'$ over $(a, +\infty)$ equals to the difference $m - f(a)$. This theorem thus connects the limit of the function at infinity, its derivative and the value of the function at the point $a$.

If a differentiable function $f$ on $(a, \infty)$ has a limit $m$ as $x \to \infty$ and its derivative $f'$ is integrable on $(a, \infty)$, then $\int\_a^\infty f'(x) dx = m - f(a)$.


/-- Neighborhoods in the quotient are precisely the map of neighborhoods in the prequotient. -/
theorem QuotientAddGroup.nhds_eq :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G]
      (N : AddSubgroup G) (x : G), nhds ↑x = Filter.map QuotientAddGroup.mk (nhds x) :=
  by sorry

This theorem states that for any type `G` that has a topological space structure, an addition group structure, and is also a topological addition group, given any addition subgroup `N` of `G` and any element `x` of `G`, the neighborhood filter of the quotient of `x` (i.e., the set of all neighborhoods of `x` after considering the equivalent relation induced by `N`) is equal to the map of the neighborhood filter of `x` in the original space `G` under the canonical map to the quotient space. This essentially means that the concept of "closeness" or "neighborhoods" gets carried over appropriately from the original space to the quotient space under the quotient map.

For any topological additive group `G` with subgroup `N`, the neighborhood filter of `x` in `G/N` under quotient topology equals the image of `x`'s neighborhood filter in `G` under the quotient map.


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

The theorem `finsum_mem_def` states that for any set `s` of some type `α` and any function `f` from `α` to a type `M` which is an additive commutative monoid, the double finite sum of `f a` over all `a` is equal to the finite sum of the indicator function of `s` applied to `f` and `a`. In other words, summing `f a` over all `a` in a double finite sum is the same as summing the indicator function of `s` applied to `f` and `a`. This essentially means it's summing `f a` for `a` in `s` and 0 otherwise. This theorem connects the concept of finite sums and indicator functions in the context of set theory and additive commutative monoids.

For any set `s` and additive commutative monoid-valued function `f`, the double finite sum of `f a` over all `a` is equal to the finite sum of the indicator function of `s` applied to `f` and `a`.


theorem Sym2.mem_and_mem_iff : ∀ {α : Type u_1} {x y : α} {z : Sym2 α}, x ≠ y → (x ∈ z ∧ y ∈ z ↔ z = s(x, y)) := by
  sorry

This theorem states that for any type `α`, given distinct elements `x` and `y` from `α` and an element `z` of the symmetric square of `α` (`Sym2 α`), `x` and `y` are both elements of `z` if and only if `z` is the unordered pair of `x` and `y`. In other words, an element of the symmetric square of a type contains a specific distinct pair of elements if and only if it is that specific pair. This theorem thus relates the membership of elements in a pair to the identity of the pair.

For any type `α` and distinct elements `x, y` from `α`, an element `z` of `Sym2 α` contains both `x` and `y` if and only if `z` is the unordered pair `{x, y}`.


theorem List.mem_range'_1 : ∀ {m s n : ℕ}, m ∈ List.range' s n ↔ s ≤ m ∧ m < s + n := by sorry

This theorem, `List.mem_range'_1`, states that for any natural numbers `m`, `s`, and `n`, `m` is an element of the list produced by the `range'` function starting from `s` and of length `n` if and only if `m` is greater than or equal to `s` and less than `s + n`. In other words, `m` is in the list range from `s` up to, but not including, `s + n`.

For natural numbers m, s, and n, m is an element of the range' list [from s to s + n] if and only if s ≤ m < s + n.


PseudoEpimorphism.ext

theorem PseudoEpimorphism.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {f g : PseudoEpimorphism α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two pseudo-epimorphisms `f` and `g` from a type `α` to a type `β`, where both `α` and `β` have a preorder structure, if `f` and `g` are equal at every point `a` in `α`, then `f` and `g` are themselves equal. Essentially, this theorem justifies the pointwise equality of pseudo-epimorphisms.

If `f` and `g` are two pseudo-epimorphisms from a preordered type `α` to a preordered type `β`, then `f` and `g` are equal if and only if they agree at every point in `α`.


theorem Multiset.coe_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (a : α), Multiset.erase (↑l) a = ↑(List.erase l a) := by sorry

This theorem states that for any type `α` with decidable equality and for any list `l` of type `α` and any element `a` of type `α`, the operation of erasing `a` from the multiset formed by `l` is the same as the operation of erasing `a` from `l` and then forming a multiset. In other words, when an element `a` is removed from the list `l` and the resulting list is converted into a multiset, it yields the same result as if `a` was removed after the list `l` was converted into a multiset.

For any decidably equated type `α` and list `l` of length `n+1` in `α`, removing an element `a` from the multiset formed by `l` is equivalent to first removing `a` from `l` and then forming the multiset of the resulting list. In mathematical notation, `(multiset.erase a (multiset.ofList l)) = multiset.erase a l`.


theorem Prod.lex_def :
    ∀ {α : Type u} {β : Type v} (r : α → α → Prop) (s : β → β → Prop) {p q : α × β},
      Prod.Lex r s p q ↔ r p.1 q.1 ∨ p.1 = q.1 ∧ s p.2 q.2 :=
  by sorry

This theorem states that for any types `α` and `β`, and relations `r` on `α` and `s` on `β`, for any ordered pairs `p` and `q` from `α × β`, the lexicographic order `Prod.Lex r s p q` holds if and only if the relation `r` holds on the first components of `p` and `q`, or the first components of `p` and `q` are equal and the relation `s` holds on their second components. In other words, it's defining how to order pairs: first by the 'α' part, and then by the 'β' part if the 'α' parts are equal.

For any types `α` and `β` and relations `r` on `α` and `s` on `β`, the lexicographic order `Prod.Lex r s` on `α × β` holds if and only if `r` applies to the first components of pairs and, when first components are equal, `s` applies to the second components.


theorem Real.deriv_rpow_const : ∀ {x p : ℝ}, x ≠ 0 ∨ 1 ≤ p → deriv (fun x => x ^ p) x = p * x ^ (p - 1) := by sorry

This theorem states that for all real numbers `x` and `p`, if `x` is not zero or `p` is greater than or equal to one, then the derivative of the function `f(x) = x^p` at the point `x` is `p * x^(p - 1)`. This is a special case of the power rule in calculus, which gives the derivative of powers of `x`.

For real numbers `x` and `p` with `x ≠ 0` and `p ≥ 1`, the derivative of `f(x) = x^p` is `p * x^(p - 1)`.


theorem Nat.succPNat_strictMono : StrictMono Nat.succPNat := by sorry

The theorem `Nat.succPNat_strictMono` states that the function `Nat.succPNat`, which maps a natural number to its successor represented as a positive natural number, is strictly monotone. In other words, if `a` and `b` are two natural numbers and `a < b`, then the successor of `a` represented as a positive natural number is less than the successor of `b` represented as a positive natural number.

The function `Nat.succPNat` strictly increases natural numbers, i.e., for all `a` and `b` in `Nat`, if `a < b`, then `Nat.succPNat a < Nat.succPNat b`.


theorem Option.map_eq_bind :
    ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → α_1} {x : Option α}, Option.map f x = Option.bind x (some ∘ f) := by
  sorry

This theorem states that for any types `α` and `α_1`, any function `f` from `α` to `α_1`, and any `Option α`, applying a function `f` over the `Option α` using `Option.map` is equivalent to binding the `Option α` to the function `some ∘ f` using `Option.bind`. In other words, when we have an optional value, we can either map a function over it, or we can bind it to a function that makes an optional value out of the result, and these two operations will always produce the same result.

For any types `α` and `α_1`, functions `f : α → α_1` and optional values `x : Option α`, `Option.map f x = Option.bind (some ∘ f) x`.


/-- In the specific case of multilinear maps on spaces indexed by `Fin (n+1)`, where one can build
an element of `∀ (i : Fin (n+1)), M i` using `cons`, one can express directly the additivity of a
multilinear map along the first variable.  -/
theorem MultilinearMap.cons_add :
    ∀ {R : Type uR} {n : ℕ} {M : Fin (Nat.succ n) → Type v} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
      [inst_3 : (i : Fin (Nat.succ n)) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂)
      (m : (i : Fin n) → M (Fin.succ i)) (x y : M 0), f (Fin.cons (x + y) m) = f (Fin.cons x m) + f (Fin.cons y m) :=
  by sorry

The theorem `MultilinearMap.cons_add` enunciates the property of additivity of a multilinear map along its first variable in the specific scenario where the domain is indexed by `Fin (n+1)`, and the elements are constructed using the function `cons`. More concretely, given a Semiring `R`, a natural number `n`, types `M` indexed by `Fin (Nat.succ n)`, and `M₂`, assuming that the types `M i` and `M₂` are modules over `R` and have an additive commutative monoid structure, if `f` is a multilinear map from `M` to `M₂`, `m` is a map from `Fin n` to `M (Fin.succ i)`, and `x` and `y` are elements of `M 0`, then applying `f` to the `cons` of `x + y` and `m` is equivalent to the sum of applying `f` to the `cons` of `x` and `m` and applying `f` to the `cons` of `y` and `m`.

Given a multilinear map `f` from a finite indexed module `M` to another additive module `M₂`, and `x`, `y` in `M₀`, and a map `m` from `Fin n` to `M (Fin.succ i)`, the application of `f` to `cons (x + y) m` equals the sum of the applications of `f` to `cons x m` and `cons y m`.


theorem Set.Ico_inter_Ico :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
      Set.Ico a₁ b₁ ∩ Set.Ico a₂ b₂ = Set.Ico (a₁ ⊔ a₂) (b₁ ⊓ b₂) :=
  by sorry

The theorem `Set.Ico_inter_Ico` states that for any type `α` that has a linear order, given any four elements `a₁`, `a₂`, `b₁`, `b₂` of this type `α`, the intersection of the left-closed right-open interval from `a₁` to `b₁` and the left-closed right-open interval from `a₂` to `b₂` is the left-closed right-open interval from the supremum of `a₁` and `a₂` to the infimum of `b₁` and `b₂`. In mathematical terms, it says that $[a₁, b₁) \cap [a₂, b₂) = [max(a₁, a₂), min(b₁, b₂))$ for any $a₁, a₂, b₁, b₂$ in an ordered set.

For any ordered type `α` and elements `a₁`, `a₂`, `b₁`, `b₂` in `α`, the intersection of the intervals `[a₁, b₁)` and `[a₂, b₂)` is equal to the interval `[sup a₁ a₂, inf b₁ b₂)`.


/-- `pure : α → Ultrafilter α` defines a dense inducing of `α` in `Ultrafilter α`.  -/
theorem denseInducing_pure : ∀ {α : Type u}, DenseInducing pure := by sorry

This theorem states that for any type `α`, the `pure` function, which maps an element of `α` to an ultrafilter of `α`, defines a dense inducing of `α` into the space of ultrafilters over `α`. In mathematical terms, this means that the image of any subset of `α` under the `pure` function is dense in the ultrafilter space over `α`. This is a fundamental property in the theory of ultrafilters and topological spaces.

The `pure` function maps every subset of a type `α` densely into the ultrafilter space over `α`.


theorem Set.Ioc_union_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
      min a b ≤ max c d → min c d ≤ max a b → Set.Ioc a b ∪ Set.Ioc c d = Set.Ioc (min a c) (max b d) :=
  by sorry

The theorem `Set.Ioc_union_Ioc` describes a property of unions of left-open right-closed intervals in any linearly ordered set. Specifically, given any four elements `a`, `b`, `c`, `d` of such a set, if the minimum of `a` and `b` is less than or equal to the maximum of `c` and `d`, and the minimum of `c` and `d` is less than or equal to the maximum of `a` and `b`, then the union of the intervals `(a, b]` and `(c, d]` equals the interval `(min(a, c), max(b, d)]`. This is essentially a statement about the union of overlapping or adjacent intervals in a linear order.

If `a ≤ b` and `c ≤ d` in a linearly ordered set, then `(a, b] ∪ (c, d] = (min a c, max b d)`.


theorem finSuccEquiv'_succAbove :
    ∀ {n : ℕ} (i : Fin (n + 1)) (j : Fin n), (finSuccEquiv' i) (Fin.succAbove i j) = some j := by sorry

The theorem `finSuccEquiv'_succAbove` states that for any natural number `n`, and for any `i` selected from the finite set `Fin (n + 1)` and `j` selected from the finite set `Fin n`, when we apply the function `finSuccEquiv'` with `i` to the result of `Fin.succAbove` with `i` and `j`, we always get `some j`. In other words, the function `finSuccEquiv'` applied to `Fin.succAbove i j` always gives `some j`. Here, `finSuccEquiv'` is an equivalence that removes the element `i` and maps it to `none`, while `Fin.succAbove` is a function that embeds `Fin n` into `Fin (n + 1)` with a hole around `i`.

For any natural numbers `n`, `i` in `Fin (n + 1)`, and `j` in `Fin n`, applying the function `finSuccEquiv'` to the result of `Fin.succAbove i j` always returns `some j`.


theorem CategoryTheory.isSeparator_def :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (G : C),
      CategoryTheory.IsSeparator G ↔
        ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
          (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) → f = g :=
  by sorry

The theorem `CategoryTheory.isSeparator_def` states that for any category `C` and an object `G` in `C`, `G` is a separator if and only if for all pairs of objects `X` and `Y` in `C` and for any two morphisms `f` and `g` from `X` to `Y`, if for all morphisms `h` from `G` to `X`, the composition of `h` and `f` equals the composition of `h` and `g`, it implies that `f` and `g` are equal. This is essentially stating that a separator in a category is an object such that, given any two morphisms with the same domain and codomain, if their compositions with every morphism from the separator result in the same morphism, then the original two morphisms must be the same.

A separator in a category is an object `G` such that for all objects `X` and `Y` and morphisms `f, g : X -> Y`, if for all morphisms `h : G -> X`, `h * f = h * g`, then `f = g`.


theorem Nat.factors_lemma : ∀ {k : ℕ}, (k + 2) / Nat.minFac (k + 2) < k + 2 := by sorry

The theorem `Nat.factors_lemma` states that for every natural number `k`, the quotient of `k + 2` divided by the smallest prime factor of `k + 2` is strictly less than `k + 2`. In other words, if you take any natural number, add 2 to it, and then divide by the smallest prime factor of the resulting number, the result will always be less than the original number plus 2.

For every natural number `k`, the quotient of `k + 2` by the smallest prime factor of `k + 2` is strictly less than `k + 2`.


theorem Set.encard_lt_top_iff : ∀ {α : Type u_1} {s : Set α}, Set.encard s < ⊤ ↔ Set.Finite s := by sorry

The theorem `Set.encard_lt_top_iff` states that for any type `α` and a set `s` of type `α`, the cardinality of set `s` is less than infinity if and only if the set `s` is finite. In other words, it establishes an equivalence between a set's cardinality being finite and the set itself being finite. This theorem can be used to check whether a set is finite or not by examining its cardinality.

The theorem `Set.encard_lt_top_iff` asserts that a set is finite if and only if its cardinality is less than the cardinality of the type.


theorem Basis.toMatrix_apply :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (e : Basis ι R M) (v : ι' → M) (i : ι) (j : ι'),
      Basis.toMatrix e v i j = (e.repr (v j)) i :=
  by sorry

The theorem `Basis.toMatrix_apply` states that for all types `ι`, `ι'`, `R`, and `M`, where `R` is a commutative semiring, `M` is an additive commutative monoid, and `M` is a module over `R`, and for any basis `e` over `R` on `M`, any function `v` mapping `ι'` to `M`, and any elements `i` of `ι` and `j` of `ι'`, the value at the `(i, j)` position in the matrix obtained by expressing the vectors `v j` in the basis `e` is exactly the `i`-th coordinate of the vector `v j` in the basis `e`.

For any commutative semiring R, additive commutative monoid and R-module M, basis e over R on M, function v mapping ι' to M, and i in ι and j in ι', the entry at position (i, j) in the matrix of vectors v j expressed in basis e equals the i-th coordinate of vector v j in basis e.


theorem Nat.le_pow_clog : ∀ {b : ℕ}, 1 < b → ∀ (x : ℕ), x ≤ b ^ Nat.clog b x := by sorry

The theorem `Nat.le_pow_clog` states that for any natural number `b` greater than 1 and any natural number `x`, `x` is less than or equal to `b` raised to the power of the `clog` of `x` in base `b`. Here, `Nat.clog b x` represents the smallest natural number `k` such that `x` is less than or equal to `b` raised to the power `k`. This essentially captures the notion of an upper logarithm in base `b`.

For all natural numbers `b` greater than 1 and `x`, `x` is less than or equal to `b` raised to the power of the logarithm base `b` of `x`.


/-- The projection from a fiber bundle to its base is continuous.  -/
theorem FiberBundle.continuous_proj :
    ∀ {B : Type u_2} (F : Type u_3) [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] (E : B → Type u_5)
      [inst_2 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_3 : (b : B) → TopologicalSpace (E b)]
      [inst_4 : FiberBundle F E], Continuous Bundle.TotalSpace.proj :=
  by sorry

The theorem `FiberBundle.continuous_proj` states that for any base type `B` (which is a topological space), fiber type `F` (which is also a topological space), and a function `E` from `B` to some type, if the total space `Bundle.TotalSpace F E` is a topological space, and for every `b` in `B`, `E b` is a topological space, and if `F E` is a fiber bundle, then the canonical projection from the total space of the bundle to the base space `B`, denoted by `Bundle.TotalSpace.proj`, is a continuous function. In mathematical terms, it asserts that the projection map of a topological fiber bundle is a continuous function.

If `F` is a topological fiber bundle over a topological space `B` with continuous base space maps and continuous total space, then the projection map is continuous.


MeasureTheory.Integrable.indicator

theorem MeasureTheory.Integrable.indicator :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.Integrable f μ → MeasurableSet s → MeasureTheory.Integrable (Set.indicator s f) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.indicator` states that for any type `α` equipped with a measurable space structure, any normed additively commutative group `E`, any function `f` from `α` to `E`, any set `s` of type `α`, and any measure `μ` on `α`, if `f` is integrable with respect to measure `μ` and `s` is a measurable set, then the function that is equal to `f` on set `s` and equals zero elsewhere, (also known as the indicator function of `s` with respect to `f`), is also integrable with respect to measure `μ`.

If `f:` `α` -> `E` is integrable, `s` is a measurable set of `α`, and `μ` is a measure on `α`, then the indicator function `1[_]` of `s` with respect to `f` (i.e., `1[_] = f on s` and `1[_] = 0` elsewhere) is integrable with respect to `μ`.


theorem MeasureTheory.AEEqFun.coeFn_compMeasurePreserving :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace γ] [inst_2 : MeasurableSpace β] {ν : MeasureTheory.Measure β} {f : α → β}
      (g : β →ₘ[ν] γ) (hf : MeasureTheory.MeasurePreserving f μ ν),
      ↑(MeasureTheory.AEEqFun.compMeasurePreserving g f hf) =ᶠ[MeasureTheory.Measure.ae μ] ↑g ∘ f :=
  by sorry

This theorem states that for every three types `α`, `β`, and `γ`, where `α` is a measurable space and `γ` is a topological space, for every measures `μ` on `α` and `ν` on `β`, for every function `f` from `α` to `β`, and for every almost everywhere equal function `g` from `β` to `γ` with respect to `ν`, if `f` is measure-preserving with respect to `μ` and `ν`, then the function obtained by composing `g` and `f` (in the sense of almost everywhere equal functions) is the same (up to a set of measure zero) as the function obtained by composing `g` and `f` in the usual sense, almost everywhere with respect to `μ`.

In other words, the composition of almost everywhere equal functions respects the composition of ordinary functions, provided we deal with measure-preserving functions and ignore differences on null sets.

Given measurable spaces `α`, `β`, and `γ`, measures `μ` on `α` and `ν` on `β`, a measure-preserving function `f: α → β` between them, and almost everywhere equal functions `g: β → γ` and `h = g ∘ f: α → γ`, then `h` is almost everywhere equal to `g ∘ f` (ignoring null sets).


theorem PowerBasis.lift_gen :
    ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_7}
      [inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S) (y : S')
      (hy : (Polynomial.aeval y) (minpoly A pb.gen) = 0), (PowerBasis.lift pb y hy) pb.gen = y :=
  by sorry

The theorem `PowerBasis.lift_gen` states that for any type `S`, which is a ring, any type `A`, which is a commutative ring and an algebra over `A`, any type `S'`, which is also a ring and an algebra over `A`, a power basis `pb` of `A` over `S`, and an element `y` of `S'`, if the polynomial obtained by evaluating the minimal polynomial of the generator of the power basis at `y` is zero (`hy`), then evaluating the generator of the power basis under the lift of `pb` to `y` (given by `PowerBasis.lift pb y hy`) gives back `y`. In simpler terms, this means that if `y` is a root of the minimal polynomial of the generator of the power basis, then the lift of the power basis to `y` sends the generator back to `y`.

If `pb` is a power basis of a commutative `A` over a ring `S`, and `y` is a root of the minimal polynomial of the generator of `pb` in a ring `S'`, then `PowerBasis.lift pb y (minimal polynomial of generator at y) = y`.


theorem Mathlib.Algebra.Module.Submodule.Basic._auxLemma.1 :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
      (x : M), (x ∈ p.toAddSubmonoid) = (x ∈ p) :=
  by sorry

This theorem, `Mathlib.Algebra.Module.Submodule.Basic._auxLemma.1`, states that for all semirings `R`, additive commutative monoids `M`, and `R`-modules `M`, for any submodule `p` of `M` and any element `x` of `M`, `x` belongs to the additive submonoid of `p` if and only if `x` belongs to `p`. In other words, the membership of an element in the submodule's underlying additive submonoid is the same as the membership in the submodule itself.

For any semiring R, additive commutative monoid M, and R-module M, an element x of M belongs to the additive submonoid of a submodule p if and only if x is in p.


theorem Int.mul_le_mul_of_nonneg_left : ∀ {a b c : ℤ}, a ≤ b → 0 ≤ c → c * a ≤ c * b := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than or equal to `b` and `c` is non-negative (i.e., `c` is greater than or equal to 0), then the product of `c` and `a` is less than or equal to the product of `c` and `b`. In other words, in the context of integers, multiplication preserves the order of non-negative numbers.

For integers `a`, `b`, and `c` with `a ≤ b` and `c ≥ 0`, we have `c * a ≤ c * b`.


theorem Polynomial.natDegree_scaleRoots :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (s : R),
      Polynomial.natDegree (Polynomial.scaleRoots p s) = Polynomial.natDegree p :=
  by sorry

This theorem states that for any semiring `R`, any polynomial `p` over `R`, and any scalar `s` in `R`, the natural degree of the polynomial obtained by scaling the roots of `p` by `s` is equal to the natural degree of `p`. In other words, scaling the roots of a polynomial does not change its natural degree. Here, the natural degree of a polynomial is the highest power of the variable that appears with a non-zero coefficient, and if the polynomial is zero, its natural degree is defined as zero.

For any semiring `R`, scaling the roots of a polynomial `p` over `R` by a scalar `s` in `R` preserves the natural degree of `p`.


theorem ONote.NF.below_of_lt :
    ∀ {e : ONote} {n : ℕ+} {a : ONote} {b : Ordinal.{0}},
      ONote.repr e < b → ONote.NF (ONote.oadd e n a) → ONote.NFBelow (ONote.oadd e n a) b :=
  by sorry

The theorem `ONote.NF.below_of_lt` expresses that for any ordinal numbers `e` and `a`, any positive natural number `n`, and any ordinal `b` in Type 0, if the ordinal represented by `e` is less than `b`, and the ordinal `ONote.oadd e n a` is in Normal Form (meaning that it is in Cantor Normal Form which is a specific representation of ordinals), then `ONote.oadd e n a` is strictly below `b` in the ordinal hierarchy. In other words, the ordinal composed of `e`, `n`, and `a` is less than `b` when `e` is less than `b` and the ordinal composed of `e`, `n`, and `a` adheres to the properties of the Normal Form.

If `e` is less than `b` and `ONote.NF.is_normal (ONote.oadd e n a)` holds, then `ONote.oadd e n a` is strictly below `b` in the ordinal hierarchy.


theorem inducing_induced : ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace Y] (f : X → Y), Inducing f := by
  sorry

This theorem states that for any two types `X` and `Y`, where `Y` has a topological space structure, and for any function `f` from `X` to `Y`, the function `f` is inducing. In the context of topology, an "inducing" function is one that makes the topology on the domain `X` the same as the topology on the image of `f`, when the image is considered as a subspace of `Y`.

For any continuous function $f : X \rightarrow Y$ between topological spaces $X$ and $Y$, the topology on $X$ induced by $Y$'s topology is equal to the preimage topology on $X$ under $f$.