theorem MvPolynomial.mem_support_iff :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ},
      m ∈ MvPolynomial.support p ↔ MvPolynomial.coeff m p ≠ 0 :=
  by sorry

This theorem states that for any commutative semiring `R`, any type `σ`, any multivariate polynomial `p` over variables indexed by `σ` and coefficients in `R`, and any monomial `m` represented as a function from `σ` to `ℕ`, the monomial `m` is in the support set of the polynomial `p` if and only if the coefficient of the monomial `m` in the polynomial `p` is not zero.

In other words, the support set of a multivariate polynomial contains exactly those monomials that have non-zero coefficients in the polynomial.

The support of a multivariate polynomial over a commutative semiring equals the set of monomials with non-zero coefficients in the polynomial.


NonUnitalStarSubalgebra.ext

theorem NonUnitalStarSubalgebra.ext :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      [inst_3 : Star A] {S T : NonUnitalStarSubalgebra R A}, (∀ (x : A), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any two sets, S and T, which are non-unital star subalgebras over a module A of a commutative semiring R (where A has a star operation), if every element of A is in S if and only if it is in T, then S and T are equal. Basically, if two non-unital star subalgebras of a module have the same elements, they are the same non-unital star subalgebra.

If two non-unital star subalgebras S and T over a module A in a commutative semiring R with a star operation have the same elements, then S = T.


theorem IsOpenMap.isOpen_range :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → IsOpen (Set.range f) :=
  by sorry

The theorem `IsOpenMap.isOpen_range` states that for any two types `X` and `Y`, and for any function `f` from `X` to `Y`, if `f` is an open map (meaning that if a set `U` in `X` is open, then its image under `f` is open in `Y`), then the range of `f` (which is the set of all values `f(x)` where `x` is in `X`) is an open set in the topological space `Y`. This theorem is a property of open maps in the context of topology.

If `f` is an open map from a topological space `X` to a topological space `Y`, then the range of `f` is an open set in `Y`.


ConcaveOn.neg

/-- **Alias** of the reverse direction of `neg_convexOn_iff`.

---

A function `-f` is convex iff `f` is concave.  -/
theorem ConcaveOn.neg :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommGroup β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} {f : E → β},
      ConcaveOn 𝕜 s f → ConvexOn 𝕜 s (-f) :=
  by sorry

The theorem `ConcaveOn.neg` states that for a given set `s` and a function `f` mapping elements from `E` to `β`, if `f` is concave on `s`, then the function `-f` (which is the negation of `f`) is convex on `s`. This theorem holds under certain conditions, such as `𝕜` being an ordered semiring, `E` being an additive commutative monoid, `β` being an ordered additive commutative group, `E` being a scalar multiple under `𝕜`, and `β` being a module over `𝕜`.

If `f` is concave on a set `s` in an ordered semiring `𝕜`, then `-f` is convex on `s` provided that `E` is an additive commutative monoid, `β` is an ordered additive commutative group, `E` is a scalar multiple under `𝕜`, and `β` is a module over `𝕜`.


IsCompact.bddBelow

/-- A compact set is bounded below  -/
theorem IsCompact.bddBelow :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : ClosedIicTopology α]
      [inst_3 : Nonempty α] {s : Set α}, IsCompact s → BddBelow s :=
  by sorry

The theorem `IsCompact.bddBelow` states that for any type `α` that has a linear ordering, a topology, a closed lower half-space topology, and is non-empty, any compact set `s` of this type is bounded below. In other words, if `s` is a compact set in a topological space that also has a linear order and a closed interval topology, then there exists a lower bound for `s`. This is a property of compact sets in the context of topology combined with order theory.

In a non-empty type with a linear ordering, a topology, and a closed lower half-space topology, every compact set has a lower bound.


theorem FirstOrder.Language.BoundedFormula.realize_iff :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {φ ψ : FirstOrder.Language.BoundedFormula L α l} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.iff φ ψ) v xs ↔
        (FirstOrder.Language.BoundedFormula.Realize φ v xs ↔ FirstOrder.Language.BoundedFormula.Realize ψ v xs) :=
  by sorry

The theorem `FirstOrder.Language.BoundedFormula.realize_iff` states that for any first-order language `L`, type `M` with a structure for `L`, type `α`, natural number `l`, bounded formulas `φ` and `ψ` in `L` for `α` and `l`, a function `v` from `α` to `M`, and a function `xs` from the finite set of size `l` to `M`, the realization of the biimplication (if and only if, represented by the "iff" function) of `φ` and `ψ` with respect to `v` and `xs` is equivalent to the biimplication of the realizations of `φ` and `ψ` with respect to `v` and `xs`. In other words, realizing the biimplication of two bounded formulas is equivalent to the biimplication of the realizations of each formula.

For any first-order language L, type α, natural number l, bounded formulas φ and ψ in L for α, and functions v : α → M and xs : finite set of size l → M, the realization of the biimplication of φ and ψ with respect to v and xs is equivalent to the biimplication of the realizations of φ and ψ with respect to v and xs.


theorem Nat.minFac_pos : ∀ (n : ℕ), 0 < Nat.minFac n := by sorry

The theorem `Nat.minFac_pos` states that for any natural number `n`, the smallest prime factor of `n` is greater than zero. This means that every natural number `n` has at least one prime factor which is strictly positive.

For every natural number `n`, there exists a prime number `p` such that `n` is divisible by `p` and `p` is greater than zero.


theorem measurableSet_Ioo :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst : OrderClosedTopology α] {a b : α}, MeasurableSet (Set.Ioo a b) :=
  by sorry

The theorem `measurableSet_Ioo` states that for any given type `α` which has a topological space structure, a measurable space structure, an opens measurable space structure, a linear order structure, and an order closed topology structure, and for any two arbitrary elements `a` and `b` of type `α`, the open interval `(a, b)` (represented as `Set.Ioo a b` in Lean) is a measurable set. In other words, the set of all elements `x` in `α` such that `a < x < b` forms a measurable set in the given measure space on `α`.

The open interval `(a, b)` in a measurable space equipped with a topological space, measurable space, order structure, and order-closed topology is a measurable set.


theorem Cardinal.mk_prod :
    ∀ (α : Type u) (β : Type v),
      Cardinal.mk (α × β) = Cardinal.lift.{v, u} (Cardinal.mk α) * Cardinal.lift.{u, v} (Cardinal.mk β) :=
  by sorry

This theorem, `Cardinal.mk_prod`, states that for any two types `α` and `β`, the cardinality of the product type `(α × β)` is equal to the product of the cardinalities of `α` and `β` after applying the universe lift operation. In mathematical terms, if `|α|` and `|β|` represent the cardinalities of types `α` and `β` respectively, then the cardinality of the product type `(α × β)` is equal to `|α| * |β|`, where the multiplication is performed after lifting the cardinalities to appropriate universe levels.

The cardinality of a product type equals the product of the cardinalities after lifting to appropriate universes.


theorem Set.preimage_prod_map_prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (s : Set β) (t : Set δ),
      Prod.map f g ⁻¹' s ×ˢ t = (f ⁻¹' s) ×ˢ (g ⁻¹' t) :=
  by sorry

The theorem `Set.preimage_prod_map_prod` states that for any types `α`, `β`, `γ`, and `δ`, and any functions `f : α → β` and `g : γ → δ`, and for any sets `s` of type `β` and `t` of type `δ`, the preimage of the product of `s` and `t` under the product map created by `f` and `g` is equal to the product of the preimages of `s` and `t` under `f` and `g`, respectively. In other words, mapping a pair of elements and then taking their preimages is the same as taking the preimages of the elements first and then forming a pair. This theorem is important in the theory of functions and sets as it describes a fundamental property of preimages under functions.

For any functions `f : α → β` and `g : γ → δ`, and sets `s �venue β` and `t �venue δ`, the preimage of `s × t` under the product map of `f` and `g` equals the product of the preimages of `s` under `f` and `t` under `g`.


theorem Filter.mem_inf_principal :
    ∀ {α : Type u} {f : Filter α} {s t : Set α}, s ∈ f ⊓ Filter.principal t ↔ {x | x ∈ t → x ∈ s} ∈ f := by sorry

This theorem, `Filter.mem_inf_principal`, states that for any type `α`, any filter `f` on `α`, and any two sets `s` and `t` of `α`, the set `s` is in the intersection of the filter `f` and the principal filter of `t` if and only if the set of all elements `x` such that `x` is in `t` implies `x` is in `s`, belongs to the filter `f`. In other words, it establishes an equivalence between the membership of `s` in the intersection of `f` and the principal filter of `t`, and the membership of a set of certain elements in `f`, where these elements are those that, if they are in `t`, then they must also be in `s`.

For any filter `f` on a type `α` and sets `s` and `t` of `α`, `s` belongs to the intersection of `f` and the principal filter of `t` if and only if the set of elements in `t` that lie in `s` is an element of `f`.


theorem CancelDenoms.sub_subst :
    ∀ {α : Type u_1} [inst : Ring α] {n e1 e2 t1 t2 : α}, n * e1 = t1 → n * e2 = t2 → n * (e1 - e2) = t1 - t2 := by
  sorry

This theorem, `CancelDenoms.sub_subst`, states that for any type `α` that forms a ring, and for any elements `n`, `e1`, `e2`, `t1`, `t2` of `α`, if `n` times `e1` equals `t1` and `n` times `e2` equals `t2`, then `n` times the difference `e1 - e2` is equal to the difference `t1 - t2`. In mathematical terms, this theorem is saying that if $n \cdot e1 = t1$ and $n \cdot e2 = t2$, then $n \cdot (e1 - e2) = t1 - t2$. This is a property about distributivity and subtraction in the context of ring theory.

For any ring `α` and elements `n`, `e1`, `e2`, `t1`, `t2` in `α`, if `n` times `e1` equals `t1` and `n` times `e2` equals `t2`, then `n` times the difference `e1 - e2` equals the difference `t1 - t2`.


theorem LieAlgebra.derivedSeriesOfIdeal_succ :
    ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
      (k : ℕ),
      LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I =
        ⁅LieAlgebra.derivedSeriesOfIdeal R L k I, LieAlgebra.derivedSeriesOfIdeal R L k I⁆ :=
  by sorry

The theorem `LieAlgebra.derivedSeriesOfIdeal_succ` states that for any commutative ring `R`, any Lie ring `L` which is also a Lie algebra over `R`, any Lie ideal `I` of `L`, and any natural number `k`, the (k + 1)-th derived series of the Lie ideal `I` is equal to the Lie bracket of the k-th derived series of `I` with itself. In mathematical terms, it says that if we define a sequence inductively where the next element is the Lie bracket of the current element with itself, then this sequence corresponds exactly to the derived series of the Lie ideal.

For any commutative ring R, Lie algebra L over R, Lie ideal I of L, and natural number k, the (k+1)-th derived series of I equals the Lie bracket of the k-th derived series of I.


theorem Equiv.symm_trans_self : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.symm.trans e = Equiv.refl β := by sorry

The theorem `Equiv.symm_trans_self` states that for any two types `α` and `β`, given an equivalence `e` between `α` and `β`, the composition of the inverse of `e` with `e` itself results in the identity equivalence on `β`. In other words, if we have a way to transform `α` to `β` and then transform it back from `β` to `α`, applying these transformations in sequence is the same as doing nothing. This reflects a fundamental property of equivalence, specifically the property of 'symmetric transitivity'.

For any equivalence relation `e` on types `α` and `β`, the composition of `e.symm` (the symmetric relation) with `e` is equal to the identity relation on `β`.


ContDiffAt.differentiableAt

/-- If a function is `C^n` with `n ≥ 1` at a point, then it is differentiable there.  -/
theorem ContDiffAt.differentiableAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {n : ℕ∞}, ContDiffAt 𝕜 n f x → 1 ≤ n → DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `ContDiffAt.differentiableAt` states that for any given function `f` from `E` to `F`, where `E` and `F` are normed additive commutative groups over a nontrivially normed field `𝕜`, if the function `f` is `C^n` continuous at a point `x` in `E` for some `n ≥ 1` (meaning that all derivatives up to the `n`th exist and are continuous), then the function `f` is also differentiable at the point `x`. This theorem thereby links the concepts of differentiability and higher order continuous differentiability.

If a function `f` from a normed additive commutative group `E` to another (`F`) is `C^n` continuous at a point `x` in `E` for some `n ≥ 1`, then `f` is differentiable at `x`.


theorem pow_lt_pow_left :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {x y : R}, x < y → 0 ≤ x → ∀ {n : ℕ}, n ≠ 0 → x ^ n < y ^ n := by
  sorry

The theorem `pow_lt_pow_left` states that for any strict ordered semiring `R` and any two elements `x` and `y` from `R`, if `x` is less than `y` and `x` is non-negative, then for any non-zero natural number `n`, the `n`th power of `x` is less than the `n`th power of `y`. In other words, in a strict ordered semiring, raising a smaller non-negative number and a larger number to the same positive power preserves the inequality.

If `0 < x <= y` in a strict ordered semiring `R` and `n` is a non-zero natural number, then `x^n < y^n`.


theorem tsum_le_tsum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f g : ι → α},
      (∀ (i : ι), f i ≤ g i) → Summable f → Summable g → ∑' (i : ι), f i ≤ ∑' (i : ι), g i :=
  by sorry

The theorem `tsum_le_tsum` states that for any two functions `f` and `g` from a type `ι` to a type `α`, where `α` is an ordered additive commutative monoid and a topological space with an order-closed topology, if each value of `f` is less than or equal to the corresponding value of `g`, and both `f` and `g` are summable (i.e., each has an infinite sum), then the total sum of `f` is less than or equal to the total sum of `g`. Mathematically, this can be expressed as: if `∀ i : ι, f(i) ≤ g(i)`, `f` and `g` are summable, then `∑' f(i) ≤ ∑' g(i)`.

If `f` and `g` are functions from a type `ι` to an ordered additive commutative monoid and topological space with order-closed topology, and `f(i) ≤ g(i)` for all `i : ι` and both `f` and `g` are summable, then `∑' f(i) ≤ ∑' g(i)`.


theorem Polynomial.coeff_coe :
    ∀ {R : Type u_2} [inst : CommSemiring R] (φ : Polynomial R) (n : ℕ),
      (PowerSeries.coeff R n) ↑φ = Polynomial.coeff φ n :=
  by sorry

This theorem, `Polynomial.coeff_coe`, asserts that for any commutative semiring `R`, any polynomial `φ` defined over `R`, and any natural number `n`, the `n`th coefficient of the power series obtained from `φ` (obtained by treating `φ` as a power series and finding its `n`th coefficient) is equal to the `n`th coefficient of the polynomial `φ`. In other words, the process of converting a polynomial to a power series does not change its coefficients.

For any commutative semiring R, polynomial φ over R, and natural number n, the n-th coefficient of the power series expansion of φ is equal to the n-th coefficient of φ itself.


theorem differentiable_const :
    ∀ {𝕜 : 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] (c : F),
      Differentiable 𝕜 fun x => c :=
  by sorry

The theorem `differentiable_const` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E` over `𝕜`, normed additive commutative group `F` over `𝕜`, and any constant `c` of type `F`, the function that maps every element of `E` to `c` is differentiable at any point in `E`. In other words, constant functions are differentiable everywhere in the domain.

For any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, and constant `c` in `F`, the function `x ↦ c` from `E` to `F` is differentiable at every point in `E`.


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

The theorem `List.filter_append` is a property about lists in Lean 4. It states that for all types `α`, for any predicate function `p` from `α` to Boolean, and for any two lists `l₁` and `l₂` of type `α`, filtering (`List.filter`) the concatenation (`++`) of `l₁` and `l₂` with `p` is the same as concatenating the result of filtering `l₁` with `p` and filtering `l₂` with `p`. In other words, applying the filter before or after concatenating the lists does not change the result.

For all types `α` and predicate functions `p` on `α`, the filtered concatenation of lists `l₁` and `l₂` with predicate `p` is equal to the concatenation of the filtered lists `l₁` and `l₂`: `List.filter (p ++) l₁ (l₂++) = (List.filter p l₁) ++ (List.filter p l₂)`.


theorem Set.toFinite_toFinset :
    ∀ {α : Type u} (s : Set α) [inst : Fintype ↑s], Set.Finite.toFinset ⋯ = Set.toFinset s := by sorry

The theorem `Set.toFinite_toFinset` states that for any given set `s` of some type `α`, if this set is finite (indicated by the `Fintype` instance of the set), then the conversion of this set to a `Finset` (finite set) using the `Set.Finite.toFinset` function is equivalent to the direct conversion of the set to a `Finset` using the `Set.toFinset` function. This establishes the equality between the two methods of converting a finite set to a `Finset` in Lean 4.

For any finite set `s` of type `α` in Lean 4, `Set.Finite.toFinset s` equals `Set.toFinset s`.


theorem Polynomial.natDegree_le_natDegree :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] {q : Polynomial S},
      Polynomial.degree p ≤ Polynomial.degree q → Polynomial.natDegree p ≤ Polynomial.natDegree q :=
  by sorry

This theorem, `Polynomial.natDegree_le_natDegree`, asserts that for any two polynomials `p` and `q`, over semirings `R` and `S` respectively, if the degree of `p` is less than or equal to the degree of `q`, then the natural degree of `p` is also less than or equal to the natural degree of `q`. In other words, the inequality between the degrees of two polynomials is preserved when those degrees are converted to natural numbers. This result holds irrespective of the types of semirings, `R` and `S`, over which the polynomials are defined.

For any polynomials `p` and `q` over semirings `R` and `S`, respectively, if the degree of `p` is less than or equal to the degree of `q`, then the natural degrees of `p` and `q` are equal or the natural degree of `p` is less than the natural degree of `q`.


ContinuousAlternatingMap.ext

theorem ContinuousAlternatingMap.ext :
    ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
      [inst_6 : TopologicalSpace N] {f g : M[⋀^ι]→L[R]N}, (∀ (x : ι → M), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous alternating maps `f` and `g` from a tensor power of a module `M` over a semiring `R` to a topological module `N` over the same semiring `R`, if these maps are equal for all inputs `x` (from the index set `ι` to `M`), then the maps `f` and `g` are identical.
In other words, two continuous alternating maps are equal if they produce the same output for every possible input.

If two continuous alternating maps from the same tensor power of a module to a topological module over a semiring are equal on all inputs, then they are identical.


theorem Seminorm.mem_ball_zero :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) {y : E} {r : ℝ}, y ∈ Seminorm.ball p 0 r ↔ p y < r :=
  by sorry

The theorem `Seminorm.mem_ball_zero` states that for any seminorm `p` over a seminormed ring `𝕜` and an additive commutative group `E` that forms a scalar multiplication system with `𝕜`, an element `y` from `E` belongs to the ball of radius `r` at `0` (with respect to seminorm `p`) if and only if the seminorm of `y` is less than `r`. In simpler terms, `y` lies within the `r`-radius ball centered at zero under seminorm `p` if the `p`-seminorm of `y` is less than `r`.

For any seminorm `p` over a seminormed ring `𝕜` and an additive commutative group `E`, an element `y` from `E` lies within the `r`-radius ball centered at zero under `p` if and only if `p(y) < r`.


theorem WittVector.out_truncateFun :
    ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] (x : WittVector p R),
      TruncatedWittVector.out (WittVector.truncateFun n x) = WittVector.init n x :=
  by sorry

The theorem `WittVector.out_truncateFun` states that for any natural numbers `p` and `n`, and any commutative ring `R`, for any Witt vector `x` with base `p` and coefficients from `R`, if we first truncate `x` to its first `n` entries using the `truncateFun` to get a truncated Witt vector, and then convert this truncated Witt vector back to a normal Witt vector using `TruncatedWittVector.out`, we will end up with the same result as if we had just directly initialized a new Witt vector with the first `n` coefficients of `x` and all other coefficients set to zero, using `WittVector.init`. In other words, it proves the equivalence between the sequence of truncation and out operations and the initialization of a Witt vector, when dealing with the first `n` entries of a Witt vector.

For any commutative ring R, natural numbers p, n, and Witt vector x with base p and coefficients from R, the result of truncating x to its first n entries using `truncateFun` and then converting back to a Witt vector is equal to the Witt vector initialized with the first n coefficients of x and all other coefficients set to zero.


/-- We can reexpress a sum over `p.support` as a sum over `range n`,
for any `n` satisfying `p.natDegree < n`.
 -/
theorem Polynomial.sum_over_range' :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid S] (p : Polynomial R) {f : ℕ → R → S},
      (∀ (n : ℕ), f n 0 = 0) →
        ∀ (n : ℕ),
          Polynomial.natDegree p < n →
            Polynomial.sum p f = Finset.sum (Finset.range n) fun a => f a (Polynomial.coeff p a) :=
  by sorry

This theorem states that for any polynomial `p` over a semiring `R` and any function `f` from pairs of natural numbers and elements of `R` to an additive commutative monoid `S` that maps any pair `(n, 0)` to `0`, there exists a natural number `n` larger than the natural degree of `p` such that the sum of `f` applied to the coefficients of `p` is equal to the sum of `f` applied to the coefficients of `p` for each natural number less than `n`. This allows us to recast the sum over `p.support` (the nonzero coefficients of the polynomial) as a sum over the range of natural numbers less than `n`.

For any polynomial `p` over a semiring `R` and additive commutative monoid homomorphism `f` mapping `(n, 0)` to `0`, there exists a natural number `n` greater than the degree of `p` such that the sum of `f` applied to `p`'s coefficients equals the sum over coefficients with index less than `n`.


theorem Finset.affineCombinationSingleWeights_apply_of_ne :
    ∀ (k : Type u_1) [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j : ι},
      j ≠ i → Finset.affineCombinationSingleWeights k i j = 0 :=
  by sorry

The theorem `Finset.affineCombinationSingleWeights_apply_of_ne` states that for any Ring `k` and any type `ι` that has decidable equality, if `i` and `j` are two distinct elements of `ι` (i.e., `j ≠ i`), then the result of applying the `Finset.affineCombinationSingleWeights` function with `k` as the ring, `i` as the first argument and `j` as the second argument is zero. In other words, in the context of affine combinations, if the weight is associated with a point different from the given one, it is zero.

For any ring `k` and decidably equal type `ι`, `Finset.affineCombinationSingleWeights _ _ i j` equals zero when `i ≠ j`.


theorem ZNum.mul_to_int : ∀ (m n : ZNum), ↑(m * n) = ↑m * ↑n := by sorry

This theorem states that for all ZNum numbers `m` and `n`, the operation of casting the product of `m` and `n` to an integer is the same as individually casting `m` and `n` to integers and then multiplying them. In mathematical terms, for all `m` and `n` in ZNum, `(m * n)` casted to an integer is equal to `(m casted to an integer) * (n casted to an integer)`.

For all `m` and `n` in ZNum, the integer cast of `(m * n)` equals the product of the integer casts of `m` and `n`.


Homeomorph.openEmbedding

theorem Homeomorph.openEmbedding :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      OpenEmbedding ⇑h :=
  by sorry

This theorem states that for any two types `X` and `Y`, both equipped with a topological space structure, if `X` is homeomorphic to `Y` (denoted as `X ≃ₜ Y`), then the function that maps `X` to `Y` (the homeomorphism) is an open embedding. In other words, the homeomorphism preserves the open sets structure, meaning that an open set in `X` is mapped to an open set in `Y`.

If two topological spaces `X` and `Y` are homeomorphic, then any open map between them is a homeomorphism and a topological embedding. (In other words, the homeomorphism preserves open sets and is an open function.)


theorem Matrix.add_dotProduct :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
      Matrix.dotProduct (u + v) w = Matrix.dotProduct u w + Matrix.dotProduct v w :=
  by sorry

The theorem `Matrix.add_dotProduct` states that for any finite type `m` and any type `α` that forms a non-unital and non-associative semiring, if `u`, `v`, and `w` are functions from `m` to `α`, then the dot product of the sum of `u` and `v` with `w` is equal to the sum of the dot product of `u` with `w` and the dot product of `v` with `w`. In mathematical terms, it states that the dot product operation respects the distributive law: $(u + v) \cdot w = u \cdot w + v \cdot w$.

The dot product of the sum of two functions with respect to a semiring operation is distributive over the dot product with a third function.


theorem QuotientGroup.induction_on :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x := by
  sorry

This theorem, named `QuotientGroup.induction_on`, is an induction principle for quotient groups. It states for a given type `α`, which has a group structure, subgroup `s`, and a proposition `C` about the elements of the quotient group `α ⧸ s`, if `C` holds for all elements of `α` when viewed as elements of `α ⧸ s`, then `C` holds for every element of `α ⧸ s`. Essentially, it allows us to prove something about all elements of a quotient group by proving it for all elements of the original group.

Given a group `α` with a subgroup `s`, if `C` holds for all `α` elements in their quotient group `α / s`, then `C` holds for every element of `α / s`.


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

This theorem states that for any types `α`, `β`, and `γ`, given a measurable space on `α`, a measure `μ` on `α`, topological spaces on `β` and `γ`, a continuous function `g` from `β` to `γ`, and an almost everywhere equal function `f` from `α` to `β` (relative to measure `μ`), the function obtained by the composition of the continuous function `g` and the almost everywhere equal function `f` is almost everywhere equal to the function obtained by first applying `f` and then `g` (i.e., `g ∘ f`). Here, almost everywhere equal means that the set of points where two functions differ has measure zero.

Given measurable spaces `(α, Σα)`, `(β, Σβ)`, `(γ, Σγ)`, measures `μ` on `(α, Σα)`, topological spaces `(β, τβ)`, `(γ, τγ)`, a continuous function `g : β → γ`, and an almost everywhere equal `μ`-\`μ`-measurable functions `f : α → β`, `g ∘ f` is almost everywhere equal to `f ∘ g`.


theorem Units.val_mk0 : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (h : a ≠ 0), ↑(Units.mk0 a h) = a := by
  sorry

This theorem states that for any given type `G₀` which has the structure of a `GroupWithZero`, and any non-zero element `a` of this group, the value of the unit group element created by the `Units.mk0` function from `a` is equal to `a` itself. In other words, when we embed a non-zero element of a `GroupWithZero` into the unit group using `Units.mk0`, the value of this new unit is just the original element.

For any non-zero element `a` in a `GroupWithZero` type `G₀`, the unit group element created by `Units.mk0` from `a` equals `a` itself.


theorem Nat.coprime_iff_gcd_eq_one : ∀ {m n : ℕ}, Nat.Coprime m n ↔ Nat.gcd m n = 1 := by sorry

This theorem states that for any two natural numbers `m` and `n`, the numbers `m` and `n` are coprime (or relatively prime) if and only if their greatest common divisor (gcd) equals 1. Here, two numbers are said to be coprime if they have no common divisor other than 1, which is precisely when their gcd is 1. Thus, this theorem establishes the equivalence between the notion of coprimality and the condition that the gcd is 1.

Two natural numbers `m` and `n` are coprime if and only if their greatest common divisor equals 1.


LazyList.cons.injEq

theorem LazyList.cons.injEq :
    ∀ {α : Type u} (hd : α) (tl : Thunk (LazyList α)) (hd_1 : α) (tl_1 : Thunk (LazyList α)),
      (LazyList.cons hd tl = LazyList.cons hd_1 tl_1) = (hd = hd_1 ∧ tl = tl_1) :=
  by sorry

This theorem states that for any type `α`, and any two pairs of head elements (`hd` and `hd_1`) and thunk of lazy lists (`tl` and `tl_1`) of type `α`, the equality of two constructed lazy lists with these elements is equivalent to the equality of both the head elements and the thunk of lazy lists. In other words, two lazy lists are equal if and only if their head elements are equal and their thunk of tail lists are equal.

For any type `α`, two constructed lazy lists `[h₁ : α] :: tl₁ : lazy list α` and `[h₂ : α] :: tl₂ : lazy list α` are equal if and only if `h₁ = h₂` and `tl₁ = tl₂`.


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

This theorem states that in any monoidal category `C`, for any objects `X`, `X'`, `Y`, `Y'`, `Z`, and `Z'`, and any morphisms `f : X ⟶ X'`, `g : Y ⟶ Y'`, and `h : Z ⟶ Z'`, the composition of the tensor product of `f`, `g`, and `h` is equal to the composition of the associator of `X`, `Y`, `Z` and the tensor product of `f`, `g`, `h` followed by the inverse of the associator of `X'`, `Y'`, `Z'`.

In other words, it is asserting the coherence condition for the associativity of the tensor product operation in a monoidal category. This condition is essentially saying that the result is the same whether we first resolve the tensor product of `X` and `Y` and then tensor the result with `Z`, or if we first resolve the tensor product of `Y` and `Z` and then tensor `X` with the result.

In any monoidal category, the composition of the associator with the tensor product of morphisms is equal to the tensor product of the morphisms followed by the inverse of the associator.


theorem Nat.mul_sub_left_distrib : ∀ (n m k : ℕ), n * (m - k) = n * m - n * k := by sorry

This theorem is stating a property of natural numbers with respect to multiplication and subtraction. Specifically, it states that for any three natural numbers `n`, `m`, and `k`, the product of `n` and the difference between `m` and `k` (i.e., `n * (m - k)`) is equal to the difference between the product of `n` and `m` and the product of `n` and `k` (i.e., `n * m - n * k`). This is known as the distributive property of multiplication over subtraction.

For all natural numbers `n`, `m`, and `k`, `n * (m - k)` equals `n * m - n * k`.


theorem Submonoid.mem_powers : ∀ {M : Type u_1} [inst : Monoid M] (n : M), n ∈ Submonoid.powers n := by sorry

This theorem states that for any type `M` that has a monoid structure, and for any element `n` of this type `M`, `n` is an element of the submonoid generated by `n`. In mathematical terms, for any monoid `M` and any element `n` in `M`, `n` belongs to the least submonoid of `M` that contains the set of all powers of `n`.

For any monoid `M` and its element `n`, `n` is an element of the submonoid generated by `n`. In other words, the submonoid generated by `{n}` is equal to the submonoid generated by `{n, n^n, n^2, ...}`.


theorem Filter.NeBot.of_map₂_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β},
      Filter.NeBot (Filter.map₂ m f g) → Filter.NeBot g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any binary function `m` from `α` and `β` to `γ`, and any filters `f` on `α` and `g` on `β`, if the filter obtained by mapping `m` over `f` and `g` (denoted as `Filter.map₂ m f g`) is not the bottom filter (i.e., it is not the trivial filter that contains all sets), then the filter `g` itself is also not the bottom filter. In other words, a non-trivial image filter implies a non-trivial original filter.

If `Filter.map₂ m (non-bot f) (non-bot g)` holds in Lean, then `non-bot g` also holds. Here, `m` is a binary function from types `α` and `β` to `γ`, `f` is a filter on `α`, `g` is a filter on `β`, and `non-bot` denotes a non-bottom filter.


UniformContinuous.mul

theorem UniformContinuous.mul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α]
      [inst_3 : UniformSpace β] {f g : β → α},
      UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x * g x :=
  by sorry

The theorem `UniformContinuous.mul` states that for any two types `α` and `β`, where `α` is equipped with a uniform space structure and a group structure such that it is a uniform group, and `β` is equipped with a uniform space structure, if `f` and `g` are two uniformly continuous functions from `β` to `α`, then the function which maps each element `x` in `β` to the product of `f x` and `g x` in `α` is also uniformly continuous. This means that if `f` and `g` both ensure that close inputs lead to close outputs, then the same property holds for the function defined by their pointwise multiplication.

If `f` and `g` are two uniformly continuous functions from a uniform group `β` to a uniform group `α` equipped with a group structure, then their pointwise product is also uniformly continuous.


theorem CategoryTheory.ShortComplex.zero_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (self : CategoryTheory.ShortComplex C) {Z : C} (h : self.X₃ ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.f (CategoryTheory.CategoryStruct.comp self.g h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

The theorem `CategoryTheory.ShortComplex.zero_assoc` states that for any category `C` with zero morphisms and a `ShortComplex` in that category `C`, for any object `Z` in `C` and a morphism `h` from `self.X₃` to `Z`, the composition of `self.f` with the composition of `self.g` and `h` is equal to the composition of the zero morphism and `h`. This theorem is essentially about the associativity property in the category theory context where the use of zero morphisms is involved.

For any category with zero morphisms and a ShortComplex in it, the composition of the zero morphism with a morphism from X₃ to any object is equal to the composition of the zero morphism from X₂ to X₃ with that morphism. (In the context of the theorem, self.f is the morphism from X₂ to X₃ and self.g is the morphism from X₃ to X₂.)


/-- **Alias** of the reverse direction of `TopologicalSpace.ext_iff_nhds`.

---

**Alias** of the reverse direction of `TopologicalSpace.ext_iff_nhds`. -/
theorem eq_of_nhds_eq_nhds : ∀ {X : Type u} {t t' : TopologicalSpace X}, (∀ (x : X), nhds x = nhds x) → t = t' := by
  sorry

This theorem, referred to as `eq_of_nhds_eq_nhds`, establishes that for any type `X`, if two topologies `t` and `t'` on `X` have the property that for every point `x` in `X`, the neighborhood filter of `x` under `t` is the same as the neighborhood filter of `x` under `t'`, then these two topologies `t` and `t'` are in fact the same. In other words, the theorem states that two topologies are equal if and only if the neighborhood filters they generate at each point are identical.

Two topologies on a type are equal if and only if they have identical neighborhood filters at each point.


theorem CategoryTheory.Limits.Cofan.IsColimit.fac :
    ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : β → C}
      {c : CategoryTheory.Limits.Cofan F} (hc : CategoryTheory.Limits.IsColimit c) {A : C} (f : (i : β) → F i ⟶ A)
      (i : β),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c i)
          (CategoryTheory.Limits.Cofan.IsColimit.desc hc f) =
        f i :=
  by sorry

The theorem `CategoryTheory.Limits.Cofan.IsColimit.fac` states that for any category `C`, a function `F` from an arbitrary type `β` to `C`, a cofan `c` over `F`, a colimit `hc` of `c`, an object `A` of `C`, and a family of morphisms `f` from each `F i` to `A` for all `i` in `β`, the composition of the `i`-th injection from the cofan `c` and the morphism from the colimit `hc` to `A` that is constructed via `f`, is equal to the `i`-th morphism in `f`.

In other words, it shows that the morphism created by `CategoryTheory.Limits.Cofan.IsColimit.desc` from the colimit to `A`, when composed with the `i`-th injection from the cofan, yields the original `i`-th morphism from `F i` to `A`. This property is crucial for the concept of a colimit in category theory, reflecting the universal property that colimits satisfy.

For any category C, given a cofan c over a function F from type β to C, a colimit hc of c, and a family of morphisms f from Fi to A, the diagram commutes, i.e., for all i in β, the composition of the injection from Fi to c and the morphism from hc to A along f equals the morphism f itself.


theorem inner_sub_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y z : E), ⟪x - y, z⟫_𝕜 = ⟪x, z⟫_𝕜 - ⟪y, z⟫_𝕜 :=
  by sorry

The theorem `inner_sub_left` states that for any types `𝕜` and `E` where `𝕜` is a type with some ring-like structure (denoted by `RCLike 𝕜`) and `E` is a normed additive commutative group that also forms an inner product space over `𝕜`, the inner product of the difference of two elements `x` and `y` in `E` with another element `z` in `E` is equal to the difference of the inner products of `x` and `z` and `y` and `z` respectively. In mathematical terms, it says that for all `x`, `y`, and `z` in `E`, the equation `⟪x - y, z⟫_𝕜 = ⟪x, z⟫_𝕜 - ⟪y, z⟫_𝕜` holds true. This theorem represents the distributive property of the inner product operation over subtraction.

For any normed additive commutative group `E` over a ring-like type `𝕜`, the inner product of the difference of two elements in `E` with a third element is equal to the difference of their individual inner products.


theorem FirstOrder.Language.Theory.IsSatisfiable.mono :
    ∀ {L : FirstOrder.Language} {T T' : FirstOrder.Language.Theory L},
      FirstOrder.Language.Theory.IsSatisfiable T' → T ⊆ T' → FirstOrder.Language.Theory.IsSatisfiable T :=
  by sorry

This theorem states that for any first-order language `L`, and for any two theories `T` and `T'` of `L`, if `T'` is satisfiable and `T` is a subset of `T'`, then `T` is also satisfiable. In other words, if a larger theory (in terms of inclusion of sentences) has a structure that models it, then any of its smaller subsets also have a structure that models them.

If `T` is a subset of satisfiable theory `T'` in a first-order language `L`, then `T` is also satisfiable.


theorem Algebra.coe_sInf :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Set (Subalgebra R A)), ↑(sInf S) = ⋂ s ∈ S, ↑s :=
  by sorry

This theorem, `Algebra.coe_sInf`, states that for any two types `R` and `A`, given instances of `R` being a commutative semiring, `A` being a semiring, and an algebra structure over `R` and `A`, if `S` is a set of subalgebras of `R` and `A`, then the set of elements included in the infimum (`sInf`) of `S` is equal to the intersection of the sets of elements included in each subalgebra in `S`. In mathematical terms, given a collection of subalgebras `S` of an algebra structure over a commutative semiring `R` and a semiring `A`, the underlying set of the infimum of `S` is the intersection of the underlying sets of the subalgebras in `S`.

For any commutative semiring `R`, semiring `A`, and an algebra structure over `R` and `A`, the underlying set of the infimum of a collection `S` of subalgebras of `R` and `A` is equal to the intersection of the underlying sets of the subalgebras in `S`.


theorem Nat.mul_eq_zero : ∀ {m n : ℕ}, n * m = 0 ↔ n = 0 ∨ m = 0 := by sorry

This theorem states that for any two natural numbers `m` and `n`, the multiplication of `n` and `m` equals zero if and only if either `n` or `m` is zero. In other words, in the realm of natural numbers, zero is the only number which, when multiplied by another number, yields zero.

For all natural numbers m and n, m * n = 0 if and only if m = 0 or n = 0.


Fin.prop

theorem Fin.prop : ∀ {n : ℕ} (a : Fin n), ↑a < n := by sorry

This theorem, `Fin.prop`, states that for any natural number `n` and any element `a` of the finite sequence of length `n` (denoted as `Fin n`), the value of `a` when cast to a natural number (i.e., `↑a`) is less than `n`. Essentially, it formalizes the idea that an element of a finite sequence is always less than the length of that sequence.

For any natural number `n` and element `a` in the finite sequence `Fin n`, the natural number `↑a` (the coercion of `a` to a natural number) is less than `n`.


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

This theorem states that for any natural numbers `x` and `z` and for any non zero natural number `y`, the division of the sum of `x` and the product of `y` and `z` by `y` is equal to the sum of the division of `x` by `y` and `z`. In terms of mathematical notation, it asserts that $\frac{x + yz}{y} = \frac{x}{y} + z$ when $y > 0$.

For any natural numbers x, y (with y > 0), and z, the quotient of x + yz by y is equal to the sum of the quotient of x by y and z. In mathematical notation: $\frac{x + yz}{y} = \frac{x}{y} + z$.


theorem Real.sin_pos_of_pos_of_lt_pi : ∀ {x : ℝ}, 0 < x → x < Real.pi → 0 < Real.sin x := by sorry

This theorem states that for all real numbers `x`, if `x` is greater than 0 and less than π (pi), then the sine of `x` is greater than 0. In mathematical terms, it can be written as: for all `x` in ℝ, if `0 < x < π` then `0 < sin(x)`. This is a reflection of the property of the sine function on the interval `(0, π)` in the real number line.

For all real numbers `x`, if `0 < x < π`, then `sin(x) > 0`.


theorem Filter.map₂_bot_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α}, Filter.map₂ m f ⊥ = ⊥ := by sorry

The theorem `Filter.map₂_bot_right` states that for any types `α`, `β`, and `γ`, and any binary function `m` from `α` and `β` to `γ`, and any filter `f` on `α`, the image of the function `m` applied to the filter `f` and the bottom filter (i.e., the filter that contains no sets) is equal to the bottom filter.

In mathematical terms, if we think of the function `Filter.map₂ m f` as creating a new filter from `α × β` to `γ` by applying `m` to `f` and another filter, then if that other filter is the empty filter (denoted by `⊥`), the result is also the empty filter. This makes sense, because there are no elements in the empty filter to apply the function `m` to.

For any filter `f` on type `α` and any binary function `m` from `α × β` to `γ`, `Filter.map₂ m (f × ⊥) = ⊥`, where `⊥` denotes the bottom filter on `γ`.


theorem List.erase_of_not_mem :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α}, a ∉ l → List.erase l a = l := by sorry

This theorem states that for any list `l` of a certain type `α`, and an element `a` of that same type, if `a` is not a member of `l`, then erasing `a` from `l` results in the original list `l`. This is under the assumptions that there exists a Boolean equality function for type `α`, and that this function satisfies the properties of a lawful Boolean equality function.

If `α` has a lawful equality, then for any list `l` of type `α` and element `a` not in `l`, the list `l` is equal to the list obtained by erasing `a` from `l`.


theorem CategoryTheory.Arrow.w_mk_right :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f : CategoryTheory.Arrow T} {X Y : T} {g : X ⟶ Y}
      (sq : f ⟶ CategoryTheory.Arrow.mk g),
      CategoryTheory.CategoryStruct.comp sq.left g = CategoryTheory.CategoryStruct.comp f.hom sq.right :=
  by sorry

This theorem, CategoryTheory.Arrow.w_mk_right, states that for any category `T`, any object `f` in the arrow category of `T`, any objects `X` and `Y` in `T`, and any morphism `g` from `X` to `Y`, if there exists a commutative square `sq` in `T` from `f` to the object in the arrow category of `T` represented by `g`, then the composition of the morphism represented by `sq.left` with `g` is equal to the composition of the morphism represented by `f.hom` and `sq.right`. In simpler terms, this theorem ensures the commutativity of a certain square in the arrow category.

For any category T, given an arrow f in T's arrow category, objects X and Y in T, and a commutative square from f to the arrow represented by a morphism g from X to Y in T, the composition of g with sq.left is equal to the composition of f.hom with sq.right.


theorem Filter.mem_comap :
    ∀ {α : Type u} {β : Type v} {g : Filter β} {m : α → β} {s : Set α}, s ∈ Filter.comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s :=
  by sorry

This theorem states that for any types `α` and `β`, any filter `g` of type `β`, any function `m` from `α` to `β`, and any set `s` of `α`, the set `s` belongs to the filter generated by the preimage of `g` under `m`, if and only if there exists a set `t` in `g` such that the preimage of `t` under `m` is a subset of `s`. Here, `m ⁻¹' t` denotes the preimage of `t` under `m`, which is the set of all elements in `α` that `m` sends to elements in `t`.

For any types `α` and `β`, filter `g` of `β`, function `m` from `α` to `β`, and set `s` of `α`, `s` belongs to the filter generated by `m⁻¹' g` if and only if there exists `t` in `g` such that `m⁻¹' t` is a subset of `s`.


theorem mabs_of_one_le :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α}
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1], 1 ≤ a → mabs a = a :=
  by sorry

The theorem `mabs_of_one_le` states that for any type `α` that is a lattice and a group, and for any element `a` of type `α` such that the binary operation "multiplication" is covariant in both of its arguments, if `1` is less than or equal to `a`, then the absolute value of `a` (denoted `mabs a`) is equal to `a` itself. Essentially, it means that for positive elements (i.e., elements greater than or equal to 1) in this specific algebraic structure, the absolute value operation returns the element itself.

For any lattice and group type `α` with covariant multiplication, if `1 ≤ a`, then `mabs a = a`.


theorem Associates.prod_mono :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {a b : Associates.FactorSet α},
      a ≤ b → Associates.FactorSet.prod a ≤ Associates.FactorSet.prod b :=
  by sorry

The theorem `Associates.prod_mono` states that for any type `α` that has the structure of a `CancelCommMonoidWithZero`, and for any two `FactorSet`s `a` and `b` of `Associates` of `α`, if `a` is less than or equal to `b` then the product of `FactorSet` `a` is less than or equal to the product of `FactorSet` `b`. Here, the product of a `FactorSet` is defined as the product of the corresponding multiset, or `0` if there is none. The order relation on `FactorSet`s is induced by the order relation on `Associates`.

For any type `α` with the structure of a `CancelCommMonoidWithZero` and for any `Associates` `FactorSet`s `a` and `b`, if `a` is less than or equal to `b`, then the product of `a` is less than or equal to the product of `b`.


theorem finsum_congr :
    ∀ {M : Type u_2} {α : Sort u_4} [inst : AddCommMonoid M] {f g : α → M},
      (∀ (x : α), f x = g x) → finsum f = finsum g :=
  by sorry

The theorem `finsum_congr` states that for any type `M` having addition that's commutative and associative, and any type `α`, if two functions `f` and `g` from `α` to `M` are such that they are equal at every point in `α`, then the sum of `f(x)` as `x` ranges over the elements of the support of `f`, if it's finite, is equal to the sum of `g(x)` as `x` ranges over the elements of the support of `g`, if it's finite. In other words, if two functions are equal pointwise, their finite sums over their supports are also equal.

If `f` and `g` are two functions from a set `α` to a commutative and associative additive semigroup `M` with finite supports, and `f(x) = g(x)` for all `x ∈ α`, then `∑ (x : α) f x = ∑ (x : α) g x`.


/-- If the codomain of an injective linear map is finite dimensional, the domain must be as well.  -/
theorem FiniteDimensional.of_injective :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
      [inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V →ₗ[K] V₂),
      Function.Injective ⇑f → ∀ [inst_5 : FiniteDimensional K V₂], FiniteDimensional K V :=
  by sorry

The theorem `FiniteDimensional.of_injective` states that for any division ring `K` and any two types `V` and `V₂` equipped with the structure of `K`-modules (that is, vector spaces over `K`), if there exists a `K`-linear map `f : V →ₗ[K] V₂` that is injective (i.e., no two different points in `V` get mapped to the same point in `V₂`), then if `V₂` is finite-dimensional (i.e., there exists a finite basis for the vector space `V₂`), it implies that `V` is also finite-dimensional. In simpler terms, the injective linear map from a vector space to a finite-dimensional vector space can't have an infinite-dimensional domain.

If `K` is a division ring and `f : V → V₂` is an injective `K`-linear map between `K`-modules `V` and `V₂`, and `V₂` is finite-dimensional, then `V` is also finite-dimensional.


theorem Matrix.det_smul :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A : Matrix n n R)
      (c : R), Matrix.det (c • A) = c ^ Fintype.card n * Matrix.det A :=
  by sorry

The `Matrix.det_smul` theorem states that for any type `n` with decidable equality and finite number of elements, and any commutative ring `R`, if `A` is a matrix of size `n` by `n` with entries in `R` and `c` is an element of `R`, then the determinant of the matrix obtained by scaling `A` by `c` is equal to `c` raised to the power of the number of elements in `n` times the determinant of `A`. In mathematical terms, for a square matrix `A` and scalar `c`, it asserts that `det(cA) = c^n * det(A)`, where `n` is the dimension of the matrix.

For any square matrix `A` of dimension `n` over a commutative ring `R` with decidable equality and finite number of elements, and any scalar `c` in `R`, the determinant of the matrix `cA` is equal to `c^n` times the determinant of `A`.


theorem Fin.val_one : ∀ (n : ℕ), ↑1 = 1 := by sorry

This theorem states that for any natural number `n`, the value of the finite type `Fin` when applied to `1` is equal to `1`. In other words, when we cast `1` as a member of the finite set `Fin n`, where `n` is any natural number, its value remains `1`.

For all natural numbers n, the element 1 in the finite type Fin n has the same value as the natural number 1.


theorem Finset.inf'_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (f : β → α) {b : β} (h : b ∈ s),
      Finset.inf' s ⋯ f ≤ f b :=
  by sorry

The theorem `Finset.inf'_le` states that for any given types `α` and `β`, where `α` is a semilattice infimum, any function `f` from `β` to `α`, any element `b` of type `β` that is an element in a nonempty finite set `s` (of type `Finset β`), then the infimum of the image of the set `s` under the function `f` is less than or equal to the image of the element `b` under `f`. This essentially means that the infimum of the image of a non-empty finite set under a certain function is not greater than the function's value at any particular element in the set.

For any semilattice infimum ℴ over types α and β, any function f from β to α, and any nonempty finite set s of β, the infimum of the image of s under f is less than or equal to the image of any element b in s under f. (i.e., ℴ(s) ≤ f(b) for all b in s).


theorem ENNReal.mul_top : ∀ {a : ENNReal}, a ≠ 0 → a * ⊤ = ⊤ := by sorry

This theorem states that for any extended nonnegative real number `a` that is not equal to zero, the product of `a` and positive infinity (denoted as `⊤`) equals positive infinity. In other words, multiplying any nonzero extended nonnegative real number by positive infinity results in positive infinity.

For any nonzero extended nonnegative real number `a`, `a * ⊤ = ⊤`.


theorem ENNReal.le_div_iff_mul_le : ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ 0 → b ≠ ⊤ ∨ c ≠ ⊤ → (a ≤ c / b ↔ a * b ≤ c) := by
  sorry

The theorem `ENNReal.le_div_iff_mul_le` states that for all extended nonnegative real numbers `a`, `b`, and `c`, under the conditions that `b` is not zero or `c` is not zero, and `b` is not infinity or `c` is not infinity, then `a` is less than or equal to `c` divided by `b` if and only if `a` multiplied by `b` is less than or equal to `c`. This theorem is a common property in elementary algebra, often used in manipulations involving inequalities and divisions.

For all extended nonnegative real numbers a, b, and c with b ≠ 0 ∧ c ≠ 0 ∧ b ≠ ∞ ∧ c ≠ ∞, a ≤ c / b if and only if a * b ≤ c.


theorem Rat.coe_int_eq_divInt : ∀ (z : ℤ), ↑z = Rat.divInt z 1 := by sorry

This theorem states that for every integer `z`, the rational number equivalent of `z`, denoted as `↑z`, is equal to the result of dividing `z` by `1` using the `Rat.divInt` function. In other words, it demonstrates that the process of casting an integer to a rational number is equivalent to dividing that integer by 1 in the realm of rational numbers.

For every integer `z`, `↑z = Rat.divInt z 1`.


theorem MeasureTheory.Measure.restrict_eq_zero :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, μ.restrict s = 0 ↔ ↑↑μ s = 0 :=
  by sorry

This theorem is about the restriction of a measure in measure theory. For any given type `α`, and given `m0` which is a measurable space over `α`, and `μ` which is a measure over `α`, and `s` which is a set of `α`, the theorem states that the restriction of measure `μ` to set `s` equals zero if and only if the measure of set `s` with respect to measure `μ` equals zero. This theorem connects the concepts of restriction of a measure and the measure of a set in measure theory, and provides a condition under which these two quantities are equal to zero.

For any measurable space `(α, m0)` and measure `μ` over `α`, the restriction of `μ` to a set `s` equals zero if and only if the measure of `s` with respect to `μ` is zero.


theorem wellFounded_lt : ∀ {α : Type u} [inst : LT α] [inst_1 : WellFoundedLT α], WellFounded fun x x_1 => x < x_1 := by
  sorry

The theorem `wellFounded_lt` states that for any type `α` with a less-than (`<`) relation and for which the relation is well-founded (according to the `WellFoundedLT` definition), the less-than relation is well-founded. In other words, if we have a type `α` where the `<` relation is well-founded (meaning there are no infinite decreasing sequences), then the `<` relation itself is well-founded for any two elements of this type.

If type `α` is equipped with a well-founded less-than relation `<`, then `<` is a well-founded relation on `α`.


Continuous.norm

theorem Continuous.norm :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] [inst_1 : TopologicalSpace α] {f : α → E},
      Continuous f → Continuous fun x => ‖f x‖ :=
  by sorry

This theorem states that for any type `α` with a topological space structure, and any type `E` with a seminormed additive group structure, if a function `f` mapping from `α` to `E` is continuous, then the function that maps `α` to the norm of `f(x)` (denoted as `‖f x‖`) is also continuous. In other words, if a function is continuous in a topological space, its norm is also a continuous function.

If `f : α → E` is a continuous function between a topological space `α` and a normed additive group `E`, then the function `x ↦ ‖f x‖` mapping `α` to the norms of `f(x)` is also continuous.


/-- To rewrite from right to left, use `Finset.sup'_comp_eq_image`.  -/
theorem Finset.sup'_image :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : DecidableEq β] {s : Finset γ}
      {f : γ → β} (hs : (Finset.image f s).Nonempty) (g : β → α),
      Finset.sup' (Finset.image f s) hs g = Finset.sup' s ⋯ (g ∘ f) :=
  by sorry

The theorem `Finset.sup'_image` states that for any types `α`, `β`, and `γ`, where `α` is a semilattice with a supremum operation, `β` has a decidable equality, and `s` is a non-empty `Finset` of type `γ`, for any function `f` mapping `γ` to `β` and `g` mapping `β` to `α`, the supremum of the image of `s` under `f`, followed by `g`, is the same as the supremum of `s` under the composition of `g` and `f`. This essentially says that the order of applying `f` and `g` does not matter when computing the supremum of the transformed `Finset`.

For any semilattice `α` with decidable equality, non-empty `Finset` `s` of type `γ`, and functions `f: γ → β` and `g: β → α`, the supremum of `s` under `g ∘ f` equals the supremum of `s` under `g` then `f`.


theorem ZeroAtInftyContinuousMap.coe_mul :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MulZeroClass β]
      [inst_3 : ContinuousMul β] (f g : ZeroAtInftyContinuousMap α β), ⇑(f * g) = ⇑f * ⇑g :=
  by sorry

This theorem states that for any two objects `f` and `g` of type `ZeroAtInftyContinuousMap` (which map a topological space `α` to another `β` where `β` is a `MulZeroClass`, i.e., a class where multiplication by zero yields zero and has a notion of multiplication), the operation of pointwise multiplication on the co-domain (`β`) commutes with the operation of taking the coercion (i.e., the actual function) of the continuous map. In other words, taking the product of the two maps `f` and `g` and then applying the resultant map to a point is the same as applying `f` and `g` to the point separately and then taking the product in `β`. Here, `β` is assumed to also have a topological structure that makes multiplication a continuous operation.

For any `f : α → ZeroAtInftyContinuousMap β` and `g : α → ZeroAtInftyContinuousMap β` where `β` is a `MulZeroClass` with a continuous multiplication, the diagram commutes: `(f ⊤) ⊤ * (g ⊤) ⊤ = (f ⊤ * g ⊤) ⊤`, where `⊤` denotes the coercion from `ZeroAtInftyContinuousMap β` to `β`.


theorem tendstoUniformlyOn_univ :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {p : Filter ι},
      TendstoUniformlyOn F f p Set.univ ↔ TendstoUniformly F f p :=
  by sorry

This theorem, `tendstoUniformlyOn_univ`, states that for any types `α`, `β`, `ι`, with `β` being a uniform space, and given any sequence of functions `F` from `ι → α → β`, a limiting function `f` from `α → β`, and a filter `p` on `ι`, the sequence `F` converges uniformly on the universal set (i.e., the set of all elements) of `α` to the limiting function `f` with respect to the filter `p` if and only if `F` converges uniformly to `f` with respect to the filter `p`. In other words, the sequence `F` converging uniformly on the universal set is equivalent to `F` converging uniformly in general.

For any uniform space β, sequence of functions F : ι → α → β, limiting function f : α → β, and filter p on ι, the sequence F converges uniformly on the universal set of α to f with respect to p if and only if it converges uniformly to f with respect to p.


IsCompl.dual

theorem IsCompl.dual :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {x y : α},
      IsCompl x y → IsCompl (OrderDual.toDual x) (OrderDual.toDual y) :=
  by sorry

The theorem `IsCompl.dual` states that for any type `α` which is a partial order and a bounded order, and any two elements `x` and `y` of that type, if `x` and `y` are complements of each other (`IsCompl x y`), then the OrderDual (opposite order) of `x` and `y` are also complements of each other (`IsCompl (OrderDual.toDual x) (OrderDual.toDual y)`). Essentially, this theorem claims that the property of being complements is preserved under the operation of taking the opposite order.

If `x` and `y` are complements in a bounded and partially ordered type `α`, then the opposite order complements of `x` and `y` are also complements of each other. In Lean notation: `IsCompl x y -> IsCompl (OrderDual.toDual x) (OrderDual.toDual y)`.


theorem aemeasurable_id'' :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) {m : MeasurableSpace α},
      m ≤ m0 → AEMeasurable id μ :=
  by sorry

The theorem `aemeasurable_id''` states that for any type α and for any two measurable spaces `m` and `m0` on α, if `m` is a subspace of `m0`, then the identity function is almost everywhere measurable with respect to a measure `μ`. In other words, the identity function coincides almost everywhere with a measurable function under the given measure.

If α is a type, `m` is a measurable space on α, and `m0` is a larger measurable space on α, such that `m` is a subspace of `m0`, then the identity function on α is almost everywhere measurable with respect to any measure μ on `m0`.


theorem isBoundedBilinearMap_apply :
    ∀ {𝕜 : 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],
      IsBoundedBilinearMap 𝕜 fun p => p.1 p.2 :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, and any normed spaces `E` and `F` over `𝕜`, the operation of applying an element of `E` to an element of `F` is a bounded bilinear map. In other words, this operation is linear in each argument and there exists a constant `C` such that the norm of the result is less than or equal to `C` times the product of the norms of the arguments.

For any non-trivially normed field `𝕜`, and normed spaces `E` and `F` over `𝕜`, the bilinear map `E × F → 𝕜` given by `(x, y) ↦ x • y` is bounded.


theorem Mathlib.Data.Complex.Exponential._auxLemma.7 : ∀ (x : ℝ), Complex.sin ↑x = ↑(Real.sin x) := by sorry

This theorem states that for any real number `x`, the complex sine of `x` is equal to the real part of the sine of `x`. In other words, the sine function, when applied to a real number and considered as a complex function, gives a result that has its real part equal to the sine of that number computed in the real numbers. This theorem essentially explains the relationship between the complex sine function and the real sine function.

The theorem asserts that for all real numbers x, the complex sine function's real part is equal to the real sine of x. In other words, Re(sin(x + i0)) = sin(x).


theorem intervalIntegral.intervalIntegral_eq_integral_uIoc :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f : ℝ → E) (a b : ℝ)
      (μ : MeasureTheory.Measure ℝ),
      ∫ (x : ℝ) in a..b, f x ∂μ = (if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ :=
  by sorry

This theorem states that for any real-valued function `f` and any two real numbers `a` and `b`, under certain conditions, the interval integral of `f` from `a` to `b` with respect to a measure `μ` is equal to the integral of `f` over the interval from `a` to `b`, possibly negated depending on the order of `a` and `b`. Specifically, if `a` is less than or equal to `b`, the result is positive; otherwise, it's negated. The conditions required are that the function's codomain `E` is a normed add-commutative group and also a normed space over the real numbers.

For any real-valued function `f` with codomain in a normed add-commutative group and normed space over the real numbers, the interval integral of `f` with respect to a measure `μ` from `a` to `b` equals the integral of `f` over the interval and is positive if `a` <= `b`, or negated otherwise.


theorem Submodule.map_bot :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂]
      [inst_8 : RingHomSurjective σ₁₂] (f : F), Submodule.map f ⊥ = ⊥ :=
  by sorry

The theorem `Submodule.map_bot` states that for any semirings `R` and `R₂`, any additive commutative monoids `M` and `M₂`, and any modules over these semirings, given a ring homomorphism from `R` to `R₂` denoted by `σ₁₂`, and a function `f` which is a semilinear map from `M` to `M₂`, if the ring homomorphism `σ₁₂` is surjective, then the image of the zero submodule (denoted by `⊥`) under `f` is again the zero submodule. This simply means that mapping the zero submodule under a semilinear map yields the zero submodule.

If `σ₁₂` is a surjective ring homomorphism from `R` to `R₂`, then the image of the zero submodule of `M` under a semilinear map `f` from `M` to `M₂` is the zero submodule of `M₂`.


Set.IsWF.isPWO

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

This theorem states that for any type `α` equipped with a linear order, and for any set `s` of this type, if `s` is well-founded with respect to the `<` relation, then it is also partially well-ordered. In other words, if every non-empty subset of `s` has a least element, then any infinite sequence from `s` contains a monotone subsequence of length 2 or equivalently, an infinite monotone subsequence, where monotonicity is defined with respect to the `≤` relation.

If `α` is a type with a linear order and `s` is a well-founded subset of `α`, then `s` has an infinite monotone subsequence.


/-- An affine subspace constructed from a point and a direction contains that point.  -/
theorem AffineSubspace.self_mem_mk' :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p : P) (direction : Submodule k V), p ∈ AffineSubspace.mk' p direction :=
  by sorry

This theorem states that for any point `p` and any direction given by a submodule of a vector space `V` over a ring `k`, the affine subspace constructed from the point `p` and this direction always contains the point `p`. This applies in the context where `k` is a ring, `V` is a commutative additive group, `V` is a module over `k`, and `V` is an additive torsor for the point type `P`.

Given a point `p` and a submodule `d` of a vector space `V` over a ring `k`, the affine subspace of `V` determined by `p` and `d` contains `p`.


theorem Polynomial.commute_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ), Commute (Polynomial.X ^ n) p := by sorry

This theorem states that for any semiring `R`, for any polynomial `p` of `R`, and for any natural number `n`, the `n`th power of the polynomial variable `X` commutes with `p`. In other words, `(Polynomial.X ^ n) * p = p * (Polynomial.X ^ n)`. The concept of commutativity refers to the property of certain operations, in this case multiplication, that the result is the same regardless of the order of the operands.

For any semiring `R`, any polynomial `p` in `R[X]`, and natural number `n`, `(X^n * p) = p * (X^n)`.


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

This theorem states that for any two propositions `a` and `b`, the claim that "`a` or `b` is equivalent to `a`" is logically equivalent to the statement "`b` implies `a`". In other words, having the equivalence between "`a` or `b`" and "`a`" is the same as saying if `b` is true, then `a` is also true. This encapsulates a fundamental logical principle used in proofs and argumentation.

The theorem asserts that `(a ∨ b) ↔ (b → a)` for any propositions `a` and `b`.


theorem LinearMap.det_toMatrix :
    ∀ {M : Type u_2} [inst : AddCommGroup M] {ι : Type u_4} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] {A : Type u_5}
      [inst_3 : CommRing A] [inst_4 : Module A M] (b : Basis ι A M) (f : M →ₗ[A] M),
      Matrix.det ((LinearMap.toMatrix b b) f) = LinearMap.det f :=
  by sorry

The theorem `LinearMap.det_toMatrix` states that for any type `M` with an additive commutative group structure, type `ι` with decidable equality and is a finite type, type `A` with a commutative ring structure, and `A` is a module over `M`, given a basis `b` of `ι` over `A` for `M` and a linear map `f` from `M` to `M`, the determinant of the matrix representation of the linear map `f` with respect to the basis `b` is equal to the determinant of the linear map `f` itself. This establishes a correspondence between the determinant of a linear map and the determinant of its matrix representation in a given basis.

For any linear map `f` between additive commutative groups `M` with decidable equality and finite indexing type `ι`, having a commutative ring structure and being a module over `M`, with respect to a basis `b` of `ι` over `A` for `M`, the determinant of the matrix representation of `f` with respect to `b` equals the determinant of `f` itself.


theorem Localization.mk_mul :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (a c : M) (b d : ↥S),
      Localization.mk a b * Localization.mk c d = Localization.mk (a * c) (b * d) :=
  by sorry

The theorem `Localization.mk_mul` states that for any type `M` that forms a commutative monoid and any submonoid `S` of `M`, if you take two elements `a` and `c` from the commutative monoid `M` and two elements `b` and `d` from the submonoid `S`, the product of the localizations of `a` and `b`, and `c` and `d` is equal to the localization of the product of `a` and `c`, and `b` and `d`. In other words, the process of localization respects the multiplication operation of the original monoid.

Let `M` be a commutative monoid and `S` a submonoid. For all `a, c in M` and `b, d in S`, the localization of `a` and `b` times the localization of `c` and `d` equals the localization of `a` times `c` and `b` times `d`.


theorem Matrix.charpoly_monic :
    ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] (M : Matrix n n R),
      Polynomial.Monic (Matrix.charpoly M) :=
  by sorry

The theorem `Matrix.charpoly_monic` states that for any type `R` with a commutative ring structure, for any finite type `n` with decidable equality, and for any matrix `M` of size `n x n` with entries in `R`, the characteristic polynomial of `M` is monic. In other words, the leading coefficient of the characteristic polynomial of any such matrix `M` is 1.

The characteristic polynomial of any square matrix over a commutative ring with decidable equality has a leading coefficient of 1.


theorem Submodule.span_singleton_le_iff_mem :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
      (p : Submodule R M), Submodule.span R {m} ≤ p ↔ m ∈ p :=
  by sorry

This theorem states that for any semiring `R`, additive commutative monoid `M`, module `M` over `R`, element `m` of `M` and submodule `p` of `M`, the span of the singleton set `{m}` is a subset of the submodule `p` if and only if the element `m` is in the submodule `p`. In other words, it's saying that in this context, a submodule contains the span of a single element if and only if it contains that element itself.

For any semiring R, additive commutative monoid M with R-module structure, and submodule p of M, the singleton set {m} spans p if and only if m is an element of p.


theorem Real.cos_add : ∀ (x y : ℝ), Real.cos (x + y) = Real.cos x * Real.cos y - Real.sin x * Real.sin y := by sorry

This theorem states that for all real numbers `x` and `y`, the cosine of the sum of `x` and `y` is equal to the product of the cosine of `x` and the cosine of `y` minus the product of the sine of `x` and the sine of `y`. This is a formalization of the well-known trigonometric identity $\cos(a + b) = \cos(a)\cos(b) - \sin(a)\sin(b)$.

The cosine of the sum of two real numbers is equal to the product of their cosines minus the product of their sines.


theorem AEMeasurable.pow_const :
    ∀ {β : Type u_2} {γ : Type u_3} {α : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace γ]
      [inst_2 : Pow β γ] [inst_3 : MeasurablePow β γ] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → β},
      AEMeasurable f μ → ∀ (c : γ), AEMeasurable (fun x => f x ^ c) μ :=
  by sorry

The theorem `AEMeasurable.pow_const` states that for all types `β`, `γ`, and `α`, such that `β` and `γ` are measurable spaces, `β` has a power operation to `γ`, and this power function is measurable, for any measurable space `m` on `α`, any measure `μ` on `α`, and any function `f` from `α` to `β` which is almost everywhere measurable, for every constant `c` of type `γ`, the function that maps each `x` in `α` to the `c`-th power of `f(x)` is also almost everywhere measurable. In other words, if a function is almost everywhere measurable, then so is its power function for any constant exponent.

For measurable spaces `β`, `γ`, and type `α`, if `β` has a measurable power operation to `γ`, `f: α → β` is almost everywhere measurable, and `c` is a constant of type `γ`, then the function `x => c ^ (f x)` is almost everywhere measurable.


theorem MvPFunctor.map_eq :
    ∀ {n : ℕ} (P : MvPFunctor.{u} n) {α β : TypeVec.{u} n} (g : TypeVec.Arrow α β) (a : P.A)
      (f : TypeVec.Arrow (P.B a) α), MvFunctor.map g { fst := a, snd := f } = { fst := a, snd := TypeVec.comp g f } :=
  by sorry

The theorem `MvPFunctor.map_eq` states that for any natural number `n`, any multivariate functor `P` of `n` types, any `n-tuple` of types `α` and `β`, any arrow `g` from `α` to `β`, any object `a` in the domain of `P`, and any arrow `f` from `P.B a` to `α`, the application of the `map` function from the multivariate functor class to `g` and the pair `{ fst := a, snd := f }` results in a pair where the first element is `a` and the second element is the composition of the arrows `g` and `f`. This theorem essentially describes how mapping over a multivariate functor behaves in relation to function composition in the category of `n-tuples` of types.

For any multivariate functor `P`, natural number `n`, types `α` and `β`, arrow `g : α → β`, object `a` in the domain of `P`, and arrow `f : P.B a → α`, the map function `map P g { a, f } = g ∘ f`.


theorem mem_closedBall_zero_iff :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, a ∈ Metric.closedBall 0 r ↔ ‖a‖ ≤ r := by sorry

This theorem states that for any Seminormed Additive Group `E` and any element `a` in it, and any real number `r`, `a` is in the closed ball of radius `r` centered at `0` if and only if the norm of `a` is less than or equal to `r`. In other words, a point is within a certain distance from the origin in this metric space if and only if its norm is less than or equal to that distance.

For any seminormed additive group `E` and real number `r`, an element `a` in `E` belongs to the closed ball centered at `0` with radius `r` if and only if the norm of `a` is less than or equal to `r`.


/-- Embedding `Fin n` into `Fin (n + 1)` with a hole around `last n` embeds by `castSucc`.  -/
theorem Fin.succAbove_last : ∀ {n : ℕ}, Fin.succAbove (Fin.last n) = Fin.castSucc := by sorry

This theorem is stating that for any natural number `n`, the function `Fin.succAbove` with `Fin.last n` as its argument is equivalent to the function `Fin.castSucc`. In other words, if you embed the finite set `Fin n` into the finite set `Fin (n + 1)` and leave a hole at the greatest value of `Fin (n+1)`, which is `last n`, it is the same as directly embedding `Fin n` into `Fin (n+1)` using the `castSucc` function. This fundamentally says that the embedding by `castSucc` is the same as the embedding by `succAbove` with a hole at the last element.

For any natural number `n`, the functions `Fin.succAbove` applied to `Fin.last n` and `Fin.castSucc` are equivalent.


AffineIsometryEquiv.isometry

theorem AffineIsometryEquiv.isometry :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (e : P ≃ᵃⁱ[𝕜] P₂), Isometry ⇑e :=
  by sorry

This theorem states that for any Affine Isometry Equivalence `e` between two points `P` and `P₂` in two pseudometric spaces (spaces where the "distance" between any two points is non-negative and satisfies certain properties), the function defined by `e` is an Isometry. In other words, this function preserves the "distance" (as measured by the edistance) between any two points that it maps from the first space to the second. This holds for any fields `𝕜`, any normed spaces `V` and `V₂`, and any normed add torsors `P` and `P₂`, where the normed spaces and the normed add torsors have some additional properties given by the type classes `SeminormedAddCommGroup`, `NormedSpace`, and `NormedAddTorsor`.

Given any Affine Isometry Equivalence between two points in two pseudometric spaces with normed add torsors over the same field, the equivalence function is an isometry preserving the "edistance" between any two points.


theorem Filter.eventually_smallSets' :
    ∀ {α : Type u_1} {l : Filter α} {p : Set α → Prop},
      (∀ ⦃s t : Set α⦄, s ⊆ t → p t → p s) → ((∀ᶠ (s : Set α) in Filter.smallSets l, p s) ↔ ∃ s ∈ l, p s) :=
  by sorry

The theorem `Filter.eventually_smallSets'` states that for any type `α`, any filter `l` of `α`, and any property `p` that sets of `α` might have, if `p` is monotonic (meaning that whenever set `s` is a subset of set `t` and `t` has property `p`, then `s` also has property `p`), then `p` holds eventually for the small sets in filter `l` if and only if there exists a set `s` in `l` such that `s` has property `p`. Here, "eventually" means that there are only finitely many exceptions, and "small sets in filter `l`" refers to the sets that are in the largest filter containing all powersets of members of `l`.

For any filter `l` on type `α`, property `p` monotonic on sets, if and only if every set in the filter of small sets of `l` having property `p` is non-empty, then `p` holds eventually for all sets in `l`.


theorem Nat.mul_div_right : ∀ (n : ℕ) {m : ℕ}, 0 < m → m * n / m = n := by sorry

This theorem states that for all natural numbers `n` and `m`, if `m` is greater than 0, then the result of multiplying `m` and `n` and then dividing the product by `m`, is equal to `n`. This is essentially a statement of the property of division that cancels the multiplication operation when the divisor is non-zero.

For all natural numbers `n` and `m` (`m > 0`), `(m * n) / m = n`.


theorem finprod_mem_eq_prod_of_inter_mulSupport_eq :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {s : Set α} {t : Finset α},
      s ∩ Function.mulSupport f = ↑t ∩ Function.mulSupport f →
        (finprod fun i => finprod fun h => f i) = Finset.prod t fun i => f i :=
  by sorry

This theorem states that for any type `α` and any type `M` that forms a commutative monoid, given a function `f` from `α` to `M`, a set `s` of `α` and a finite set `t` of `α`, if the intersection of `s` with the multiplicative support of `f` (the set of points `x` such that `f(x) ≠ 1`) is equal to the intersection of `t` with the multiplicative support of `f`, then the product of `f(x)` for each `x` in `s` (given by `finprod (finprod f)`) is equal to the product of `f(x)` for each `x` in `t` (given by `Finset.prod t f`). This theorem is essentially about the equality of two different types of product operations under certain conditions concerning the multiplicative support of a function.

If `f` is a function from type `α` to a commutative monoid `M`, `s` and `t` are finite sets of `α`, and the intersection of `s` and the multiplicative support of `f` equals the intersection of `t` and the multiplicative support of `f`, then `finprod (finprod f) (set.toList s)` equals `Finset.prod t f`.


theorem MeasureTheory.ae_mono :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      μ ≤ ν → MeasureTheory.Measure.ae μ ≤ MeasureTheory.Measure.ae ν :=
  by sorry

The theorem `MeasureTheory.ae_mono` states that for any type `α`, given measurable space `m0` on `α` and two measures `μ` and `ν` from the measure theory on `α`, if `μ` is less than or equal to `ν`, then the "almost everywhere" filter of co-null sets of `μ` is less than or equal to the "almost everywhere" filter of co-null sets of `ν`. In other words, it establishes a monotonicity property for "almost everywhere" filters of co-null sets in the context of measure theory.

If `μ` is a measure less than or equal to `ν` on measurable space `(α, m0)`, then the filter of `μ`'s co-null sets is included in the filter of `ν`'s co-null sets.


/-- `s`, coerced to a type, is a subsingleton type if and only if `s` is a subsingleton set.  -/
theorem Set.subsingleton_coe : ∀ {α : Type u} (s : Set α), Subsingleton ↑s ↔ Set.Subsingleton s := by sorry

Given a set `s` of some type `α`, this theorem states that the type of `s` (when `s` is coerced to a type) is a subsingleton type if and only if `s` itself is a subsingleton set. In other words, the set `s` has at most one element if and only if the type of `s` has at most one element. Here, a subsingleton type is a type that has at most one inhabitant and a subsingleton set is a set that contains at most one element.

The type of a set is a subsingleton type if and only if the set itself is a subsingleton.


theorem Finite.wellFounded_of_trans_of_irrefl :
    ∀ {α : Type u_1} [inst : Finite α] (r : α → α → Prop) [inst : IsTrans α r] [inst : IsIrrefl α r], WellFounded r :=
  by sorry

This theorem states that for any type `α` which is finite, and any binary relation `r` on `α`, if `r` is transitive and irreflexive, then `r` is well-founded. In mathematical terms, if we have a finite set and a relation on this set that is both transitive (i.e., if `a r b` and `b r c` then `a r c`) and irreflexive (i.e., `a r a` is always false), then we can say this relation is well-founded, meaning there are no infinite descending chains, which can be symbolized as: there does not exist a sequence `(a_i)` such that `a_{i+1} r a_i` for every `i`.

If `α` is a finite type and `r` is a transitive and irreflexive relation on `α`, then `r` is well-founded, i.e., there is no infinite descending chain `a_i r a_{i+1}` for any sequence `(a_i)` in `α`.


/-- Two homomorphisms out of a free group are equal if they are equal on generators.

See note [partially-applied ext lemmas].  -/
theorem FreeGroup.ext_hom :
    ∀ {α : Type u} {G : Type u_1} [inst : Group G] (f g : FreeGroup α →* G),
      (∀ (a : α), f (FreeGroup.of a) = g (FreeGroup.of a)) → f = g :=
  by sorry

This theorem states that for any type `α` and any group `G`, if two homomorphisms `f` and `g` from the free group over `α` to `G` are equal when applied to the generators of the free group (that is, the elements obtained via the `FreeGroup.of` function), then these two homomorphisms are actually identical. This is a statement about the uniqueness of homomorphisms out of free groups in terms of their behavior on generators.

If two homomorphisms from the free group over a type to a group agree on the generators, then they are equal.


theorem GaloisInsertion.strictMono_u :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β],
      GaloisInsertion l u → StrictMono u :=
  by sorry

The theorem `GaloisInsertion.strictMono_u` states that for any two types `α` and `β` with preorder, given functions `l : α → β` and `u : β → α` such that `GaloisInsertion l u` holds (meaning `l` and `u` form a Galois Insertion), the function `u` is strictly monotone. In other words, if `a < b` for any two elements `a`, `b` in the type `β`, then `u(a) < u(b)`.

If `l : α → β` and `u : β → α` form a Galois Insertion in types `α` and `β` with preorder, then `u` is a strictly monotone function.


theorem ascPochhammer_succ_right :
    ∀ (S : Type u) [inst : Semiring S] (n : ℕ), ascPochhammer S (n + 1) = ascPochhammer S n * (Polynomial.X + ↑n) := by
  sorry

The theorem `ascPochhammer_succ_right` states that for any semiring `S` and any natural number `n`, the ascending Pochhammer symbol evaluated at `n + 1` is equal to the ascending Pochhammer symbol evaluated at `n` multiplied by the polynomial `X + n`. In mathematical terms, it expresses the relation `X * (X + 1) * ... * (X + n) = (X * (X + 1) * ... * (X + n - 1)) * (X + n)`, which is a property of the ascending Pochhammer symbol in the context of polynomial algebra.

The ascending Pochhammer symbol evaluated at `n + 1` is equal to the product of the ascending Pochhammer symbol evaluated at `n` and the polynomial `X + n`.


/-- If `F` creates the limit of `K` and `K ⋙ F` has a limit, then `K` has a limit.  -/
theorem CategoryTheory.hasLimit_of_created :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J]
      (K : CategoryTheory.Functor J C) (F : CategoryTheory.Functor C D)
      [inst_3 : CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.comp K F)]
      [inst_4 : CategoryTheory.CreatesLimit K F], CategoryTheory.Limits.HasLimit K :=
  by sorry

This theorem states that, given two categories `C` and `D`, and two functors `K : J ⟶ C` and `F : C ⟶ D` such that `F` creates the limit of `K` and the composition `K ⋙ F` has a limit, then `K` itself also has a limit. Here, `J` is a category that serves as the domain of the functor `K`. In other words, if a functor `F` can create the limit of another functor `K`, and if the composition of `K` and `F` has a limit, then `K` must also have a limit.

If functors `K : J ➝ C` and `F : C ➝ D` satisfy `F` preserves limits of `K` and `K ◦ F` has a limit, then `K` has a limit.


theorem Orientation.inner_rightAngleRotation_left :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ E = 2)] (o : Orientation ℝ E (Fin 2)) (x y : E),
      ⟪(Orientation.rightAngleRotation o) x, y⟫_ℝ = ((Orientation.areaForm o) x) y :=
  by sorry

This theorem establishes a relationship between the orientation of a real inner product space of dimension 2, specifically the right angle rotation and the area form. It states that for any such oriented space `E`, given an orientation `o` and any two vectors `x` and `y` in `E`, the inner product of the right angle rotation of `x` under `o` with `y` is equal to the result of applying the area form of `o` to `x` and `y`. In mathematical terms, this can be written as $\langle J(x), y \rangle = \omega(x, y)$ where $J$ is the right angle rotation and $\omega$ is the area form.

For any oriented 2-dimensional real inner product space `E` with orientation `o`, the inner product of the right angle rotation of a vector `x` under `o` with another vector `y` equals the value of the area form `ω` on the pair `(x, y)`. That is, $\langle J(x), y \rangle = \omega(x, y)$.


theorem Finset.coe_nsmul :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] (s : Finset α) (n : ℕ), ↑(n • s) = n • ↑s := by sorry

This theorem states that for any type `α` with decidable equality and an additive monoid structure, for any finite set `s` of `α` and any natural number `n`, the coerced result of applying the scalar multiplication `n • s` is the same as the result of applying the scalar multiplication to the coerced set `n • ↑s`. In other words, we can either first perform the scalar multiplication on the set and then coerce it to a different type, or first coerce the set and then perform the scalar multiplication, and the result will be the same.

For any decidably equated type `α` with an additive monoid structure, coerced scalar multiplication `n • ↑s` equals `↑(n • s)` for any finite set `s` of `α` and natural number `n`.


theorem List.append_inj :
    ∀ {α : Type u_1} {s₁ s₂ t₁ t₂ : List α},
      s₁ ++ t₁ = s₂ ++ t₂ → List.length s₁ = List.length s₂ → s₁ = s₂ ∧ t₁ = t₂ :=
  by sorry

The theorem `List.append_inj` states that for any type `α` and any lists `s₁`, `s₂`, `t₁`, `t₂` of type `α`, if the list obtained by appending `t₁` to `s₁` is the same as the list obtained by appending `t₂` to `s₂`, and if the lengths of `s₁` and `s₂` are equal, then `s₁` is equal to `s₂` and `t₁` is equal to `t₂`. In other words, two pairs of lists with equal concatenated results and initial list lengths imply that the original lists were also equal.

If two lists `s₁` and `s₂` of the same length, and `t₁` and `t₂` are such that `s₁ ++ t₁ = s₂ ++ t₂` in Lean's list append `(++)` notation, then `s₁ = s₂` and `t₁ = t₂`.


theorem compact_basis_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : LocallyCompactSpace X] (x : X),
      Filter.HasBasis (nhds x) (fun s => s ∈ nhds x ∧ IsCompact s) fun s => s :=
  by sorry

The theorem `compact_basis_nhds` states that for any point `x` in a locally compact space `X` (which is a topological space), the neighborhood filter at `x` has a basis where each basis element is both a neighborhood of `x` and a compact set. This means that the neighborhood filter at `x` can be generated by a collection of sets that are both neighborhoods of `x` and compact. This property holds for all points `x` in the space `X`.

For every point $x$ in a locally compact space $X$, the neighborhood filter at $x$ has a basis consisting of compact neighborhoods of $x$.


theorem Multiset.mem_toList : ∀ {α : Type u_1} {a : α} {s : Multiset α}, a ∈ Multiset.toList s ↔ a ∈ s := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any multiset `s` of type `α`, the element `a` is a member of the list obtained by converting the multiset `s` to a list if and only if `a` is a member of the multiset `s`. In other words, the membership of an element in the multiset is preserved when the multiset is converted to a list.

For any type `α`, any element `a` in multiset `s` of type `α`, `a` is an element of the list obtained from `s` if and only if `a` is an element of `s`.


theorem IsUnit.neg_iff : ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] (a : α), IsUnit (-a) ↔ IsUnit a :=
  by sorry

The theorem `IsUnit.neg_iff` states that for any type `α`, that is a Monoid and also has a distributive negation, an element `a` of `α` is a unit if and only if its negation `-a` is a unit. In other words, in the context of a Monoid with distributive negation, an element and its negation are either both units or both non-units.

In a Monoid equipped with distributive negation, an element and its negation are equal to the additive identity if and only if they are both units.


ProbabilityTheory.kernel.measurable

theorem ProbabilityTheory.kernel.measurable :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      (κ : ↥(ProbabilityTheory.kernel α β)), Measurable ⇑κ :=
  by sorry

This theorem states that for any types `α` and `β` and any measurable spaces `mα` and `mβ` over these types, if `κ` is an element of the probability theory kernel from `α` to `β`, then the function defined by `κ` is measurable. In other words, for all measurable sets in `β`, the preimage of the set under `κ` is a measurable set in `α`.

Given measurable spaces `mα` and `mβ` over types `α` and `β`, and a kernel `κ` from `α` to `β`, the function `κ` is measurable, i.e., for every measurable set `A` in `mβ`, the preimage `κ⁻¹(A)` in `mα` is also measurable.


/-- note: `ℝ≥0∞` can probably be generalized in a future version of this lemma.  -/
theorem Measurable.ennreal_tsum :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Type u_6} [inst_1 : Countable ι] {f : ι → α → ENNReal},
      (∀ (i : ι), Measurable (f i)) → Measurable fun x => ∑' (i : ι), f i x :=
  by sorry

The theorem `Measurable.ennreal_tsum` states that in a measurable space `α` and for any countable type `ι`, if you have a sequence of measurable functions `f : ι → α → ENNReal` (functions from `ι` to a function from `α` to extended nonnegative real numbers), then the function which maps each element `x` of `α` to the sum over `ι` of `f i x` is also measurable. In simpler terms, it is saying that the sum of a sequence of measurable functions is itself measurable. Note that `ENNReal` denotes the extended nonnegative real numbers, usually denoted as `[0, ∞]`, which might be generalized in future versions of this lemma.

If `α` is a measurable space and `f : ι → α → ENNReal` is a sequence of measurable functions, then the function mapping each `x` in `α` to the sum over `ι` of `f i x` is measurable.


theorem CategoryTheory.ShortComplex.RightHomologyMapData.opcyclesMap'_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂ = γ.φQ :=
  by sorry

This theorem states that in a category `C` with zero morphisms and for any two short complexes `S₁` and `S₂` with right homology data `h₁` and `h₂` respectively, and a morphism `φ` from `S₁` to `S₂`, the `opcyclesMap'` of `φ`, `h₁`, and `h₂` in the ShortComplex category theory is equal to the `φQ` property of the right homology map data `γ` associated with `φ`, `h₁`, and `h₂.

In the ShortComplex category theory, the `opcyclesMap'` of a morphism `φ` between two short complexes with right homology data `h₁` and `h₂` equals the `φQ` property of the right homology map data `γ` associated with `φ`, `h₁`, and `h₂`.


Polynomial.cyclotomic.monic

/-- `cyclotomic n` is monic.  -/
theorem Polynomial.cyclotomic.monic :
    ∀ (n : ℕ) (R : Type u_1) [inst : Ring R], Polynomial.Monic (Polynomial.cyclotomic n R) := by sorry

The theorem `Polynomial.cyclotomic.monic` states that for any natural number `n` and any type `R` that forms a ring, the `n`-th cyclotomic polynomial with coefficients in `R` is a monic polynomial. A monic polynomial is defined to be one whose leading coefficient is 1.

The `n`-th cyclotomic polynomial with coefficients in any ring `R` is a monic polynomial.


theorem Nat.prime_iff_prime_int : ∀ {p : ℕ}, Nat.Prime p ↔ Prime ↑p := by sorry

This theorem states that for every natural number `p`, `p` is a prime number if and only if the integer equivalent of `p` is a prime element of a commutative monoid with zero. In other words, a natural number `p` is prime (i.e., it is at least 2 and its only divisors are `p` and `1`) if and only if when `p` is considered as an integer, it satisfies the properties of being a prime element in the context of a Commutative Monoid with Zero (i.e., `p` is not zero, is not a unit, and if `p` divides the product of two integers, then `p` must divide at least one of them).

A natural number `p` is prime if and only if the integer `p` is a prime element in a commutative monoid with zero.