theorem MeasureTheory.VectorMeasure.coe_smul :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      {R : Type u_4} [inst_2 : Semiring R] [inst_3 : DistribMulAction R M] [inst_4 : ContinuousConstSMul R M] (r : R)
      (v : MeasureTheory.VectorMeasure α M), ↑(r • v) = r • ↑v :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.coe_smul` states that for any semiring `R`, any measurable space `α`, any additively commutative monoid `M` equipped with a topological space and a continuous scalar multiplication by `R`, any scalar `r` in `R`, and any vector measure `v` on `α` with values in `M`, the scalar multiplication of `r` and `v` (denoted `r • v`) is the same as the scalar multiplication of `r` and the coercion of `v` to a function (denoted `r • ↑v`). In other words, scalar multiplication interacts with the coercion to a function in the expected way when dealing with vector measures.

For any semiring R, measurable space α, additively commutative monoid M with a topological space and continuous scalar multiplication, scalar r in R, and vector measure v on α with values in M, the scalar multiplication r • v equals the scalar multiplication r • ↑v.


theorem CategoryTheory.forget_map_eq_coe :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y : C}
      (f : X ⟶ Y), (CategoryTheory.forget C).map f = ⇑f :=
  by sorry

This theorem states that for any categories `C` and `C'` of type `u`, with `C` being a concrete category, and for any objects `X` and `Y` in `C`, the action of the forgetful functor `CategoryTheory.forget C` on a morphism `f : X ⟶ Y` in `C` is just the same as the action of the morphism `f` itself. In other words, the forgetful functor essentially "forgets" the categorical structure and treats the morphism purely as a function.

For any concrete category `C`, the forgetful functor from `C` to Set preserves morphisms, i.e., for any objects `X` and `Y` in `C` and a morphism `f : X ⟶ Y` in `C`, we have `CategoryTheory.forget C f = f : X → Y`.


/-- Given a point in an affine subspace, the set of vectors in its direction equals the set of
vectors subtracting that point on the right.  -/
theorem AffineSubspace.coe_direction_eq_vsub_set_right :
    ∀ {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] {s : AffineSubspace k P} {p : P},
      p ∈ s → ↑(AffineSubspace.direction s) = (fun x => x -ᵥ p) '' ↑s :=
  by sorry

This theorem states that for any given point `p` in an affine subspace `s`, the set of vectors in the direction of the subspace is equal to the set of vectors obtained by subtracting `p` from each point in the subspace `s`. Here, the direction of `s` is the submodule spanned by the pairwise differences of points in `s`. The subtraction operation `x -ᵥ p` denotes the vector obtained by subtracting the position vector of `p` from that of `x`. So, every vector in the direction of `s` can be represented as the difference between a point in `s` and `p`. Note that the types `k`, `V` and `P` denote a ring, a commutative additive group and an affine torsor respectively, and `s` is a subset of `P` with the structure of an affine space over `V` with scalars `k`.

The direction vectors of an affine subspace are equal to the differences between any point in the subspace and a given point.


theorem ProjectiveSpectrum.mem_zeroLocus :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜] (x : ProjectiveSpectrum 𝒜) (s : Set A),
      x ∈ ProjectiveSpectrum.zeroLocus 𝒜 s ↔ s ⊆ ↑x.asHomogeneousIdeal :=
  by sorry

The `ProjectiveSpectrum.mem_zeroLocus` theorem states that for any commutative semiring `R`, a commutative ring `A`, an `R`-algebra structure on `A`, a grading on `A` by the natural numbers, a point `x` in the projective spectrum of this graded algebra, and a set `s` of elements in `A`, `x` is in the zero locus of `s` if and only if `s` is a subset of the homogeneous ideal of `x` (that is, every element of `s` is in the homogeneous ideal of `x`). This theorem bridges the geometric concept of the zero locus (the set of all points where a given set of functions vanish) with the algebraic concept of homogeneous ideals in graded algebras.

A point in the projective spectrum of a graded algebra belongs to the zero locus of a set of elements if and only if the set is contained in the homogeneous ideal of that point.


theorem CategoryTheory.Iso.self_symm_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y),
      α ≪≫ α.symm = CategoryTheory.Iso.refl X :=
  by sorry

This theorem states that for any category `C` and any objects `X` and `Y` in `C`, if there exists an isomorphism `α` from `X` to `Y`, then the composition of `α` and its inverse (`α.symm`) is the identity isomorphism on `X`. In other words, an isomorphism followed by its inverse will have no effect on `X`, demonstrating a fundamental feature of isomorphisms in category theory, which is their reversibility.

In any category, for any objects X and Y with an isomorphism α from X to Y, α \* α.symm = id\_(X) holds. (Here, \* denotes composition, id\_(X) is the identity isomorphism on X, and symm denotes the symmetric inverse of α.)


Nat.Partrec.ppred

theorem Nat.Partrec.ppred : Nat.Partrec fun n => ↑(Nat.ppred n) := by sorry

This theorem states that the partial predecessor operation is partially recursive. In other words, the function that takes a natural number `n` and returns the predecessor of `n` if `n` is not zero, and returns nothing (`none`) if `n` is zero, is computable according to the definition of partial recursive functions in the natural numbers.

The predicate `∂` defining the partial predecessor operation on natural numbers is partial recursive.


theorem Matrix.det_eq_elem_of_subsingleton :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
      [inst_3 : Subsingleton n] (A : Matrix n n R) (k : n), Matrix.det A = A k k :=
  by sorry

This theorem states that for any type `n` with decidable equality and of finite type, and any commutative ring `R`, if `n` is a subsingleton (i.e., has at most one element), then the determinant of any matrix `A` with entries in `R` and with both row and column indices in `n`, is equal to the entry of `A` at position `(k,k)` for any `k` in `n`. In other words, if our matrix has a single element (as `n` is a subsingleton), then the determinant of the matrix is just that single element.

For any commutative ring R and finite type n with decidable equality that is a subsingleton, the determinant of any matrix A over R with both row and column indices in n is equal to the entry of A at position (k,k) for any k in n.


theorem AffineSubspace.ext_iff :
    ∀ {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] (s₁ s₂ : AffineSubspace k P), ↑s₁ = ↑s₂ ↔ s₁ = s₂ :=
  by sorry

This theorem states that for any two affine subspaces `s₁` and `s₂` of a given type `P`, under the conditions that `k` is a ring, `V` is an additive commutative group, and `V` is a `k`-module, and `P` is an AddTorsor over `V`, the equivalence of their coercion to sets implies their equality. In other words, if two affine subspaces are equivalent when considered as sets, then they are equal as affine subspaces.

If `s₁` and `s₂` are affine subspaces of a `k`-module `V` over a ring `k`, and their coercions to sets are equal, then `s₁ = s₂`.


PartialEquiv.IsImage.compl

theorem PartialEquiv.IsImage.compl :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage e s t → PartialEquiv.IsImage e sᶜ tᶜ :=
  by sorry

The theorem `PartialEquiv.IsImage.compl` states that for any types `α` and `β`, any partial equivalence `e` from `α` to `β`, and any sets `s` of `α` and `t` of `β`, if `t` is an image of `s` under the partial equivalence `e`, then the complement of `t` is also an image of the complement of `s` under the same partial equivalence `e`. In other words, if we map `s` to `t` using `e`, then the elements not in `s` are mapped to the elements not in `t`.
In mathematical terms, it asserts that if $e$ maps $s$ to $t$, then $e$ also maps the set difference of $\alpha$ and $s$ (denoted $s^c$) to the set difference of $\beta$ and $t$ (denoted $t^c$).

If $e$ is a partial equivalence from $\alpha$ to $\beta$ and $s \subseteq \alpha$ maps to $t \subseteq \beta$, then $e(s^c) = t^c$.


theorem tendsto_zpow_atTop_zero :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : OrderTopology 𝕜] {n : ℤ},
      n < 0 → Filter.Tendsto (fun x => x ^ n) Filter.atTop (nhds 0) :=
  by sorry

This theorem, `tendsto_zpow_atTop_zero`, states that for any linearly ordered field `𝕜`, in the context of a topological space with order topology, if `n` is a negative integer, then the function `x ^ n` tends to 0 as `x` approaches infinity. In other words, for any neighborhood of 0 in the field, there exists a sufficiently large threshold after which the values of `x ^ n` will stay within that neighborhood, thus approaching 0 as `x` goes to infinity.

For any linearly ordered field with order topology, the function `x ^ (-n)` converges to 1 as `x` approaches infinity, hence `x ^ n` tends to 0 as `x` goes to infinity.


theorem WeierstrassCurve.Affine.polynomial_eq :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R),
      W.polynomial =
        Cubic.toPoly
          { a := 0, b := 1, c := Cubic.toPoly { a := 0, b := 0, c := W.a₁, d := W.a₃ },
            d := Cubic.toPoly { a := -1, b := -W.a₂, c := -W.a₄, d := -W.a₆ } } :=
  by sorry

The theorem `WeierstrassCurve.Affine.polynomial_eq` states that for any Weierstrass curve `W` defined over a commutative ring `R`, its defining polynomial is equal to the cubic polynomial generated by transforming a cubic polynomial with coefficients `a = 0`, `b = 1`, `c` being the polynomial generated from a cubic polynomial with coefficients `a = 0`, `b = 0`, `c = W.a₁`, `d = W.a₃`, and `d` being the polynomial generated from a cubic polynomial with coefficients `a = -1`, `b = -W.a₂`, `c = -W.a₄`, `d = -W.a₆`. In other words, this theorem provides the relationship between the defining polynomial of a Weierstrass curve and a specific cubic polynomial in the affine coordinates of the curve.

The defining polynomial of a Weierstrass curve over a commutative ring is equivalent to a specific cubic polynomial formed from transforming polynomials with coefficients from the Weierstrass curve's parameters.


theorem Metric.cthickening_eq_iInter_thickening'' :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α),
      Metric.cthickening δ E = ⋂ ε, ⋂ (_ : max 0 δ < ε), Metric.thickening ε E :=
  by sorry

This theorem states that for any real number `δ` and any set `E` in a pseudo-emetric space `α`, the closed `δ`-thickening of `E` is equivalent to the intersection over all `ε` of the `ε`-thickening of `E`, where `ε` is strictly greater than the maximum of 0 and `δ`.

In other words, it states that the set of points in the space `α` that are at a distance of at most `δ` from the set `E` (the closed δ-thickening) is the same as the set of points that are strictly less than a distance `ε` from `E` for all `ε` greater than the maximum of 0 and `δ`.

The closed δ-thickening of a set E in a pseudo-metric space α is equal to the intersection of all (ε-thickening of E) with ε > max(δ, 0).


theorem Set.image_iUnion₂ :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {κ : ι → Sort u_7} (f : α → β) (s : (i : ι) → κ i → Set α),
      f '' ⋃ i, ⋃ j, s i j = ⋃ i, ⋃ j, f '' s i j :=
  by sorry

The theorem `Set.image_iUnion₂` states that for any types `α`, `β`, and `ι`, and any family of types `κ` indexed by `ι`, given a function `f` from `α` to `β`, and a double-indexed collection `s` of sets of `α`, the image under `f` of the union of all these sets (over both indices) is equal to the union of the images under `f` of each of these sets. In mathematical terms, this is saying that $f(\bigcup_{i}\bigcup_{j}s_{i,j}) = \bigcup_{i}\bigcup_{j}f(s_{i,j})$. This is a statement about the commutativity of the union operation with the image of a function operation.

For any types `α`, `β`, and index `ι`, given a function `f` from `α` to `β` and a double-indexed family of sets `s` of `α`, the image of the union of all sets over both indices is equal to the union of the images of each set under `f`: $f(\bigcup\_{i}\bigcup\_{j}s\_{i,j}) = \bigcup\_{i}\bigcup\_{j}f(s\_{i,j})$.


theorem AEMeasurable.comp_quasiMeasurePreserving :
    ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_5} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace δ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure δ} {f : α → δ} {g : δ → β},
      AEMeasurable g ν → MeasureTheory.Measure.QuasiMeasurePreserving f μ ν → AEMeasurable (g ∘ f) μ :=
  by sorry

This theorem states that if a function `g` is "almost everywhere measurable" with respect to a measure `ν`, and if a function `f` is "quasi measure preserving" from measure `μ` to measure `ν`, then the composition function `g ∘ f` is "almost everywhere measurable" with respect to measure `μ`.

In mathematical terms, a function is "almost everywhere measurable" if it is almost everywhere equal to a measurable function. A function is "quasi measure preserving" if the preimage of every measurable set under this function is measurable and the measure of the preimage set is equal to the measure of the original set.

If `g` is almost everywhere equal to a measurable function and `f` is a quasi measure preserving function between measures `μ` and `ν`, then the composition `g ∘ f` is almost everywhere measurable with respect to measure `μ`.


theorem Language.reverse_involutive : ∀ {α : Type u_1}, Function.Involutive Language.reverse := by sorry

This theorem states that the operation of reversing a language is involutive for any type `α`. In other words, if we take a language, reverse it, and then reverse it again, we get back the original language. In more formal terms, for all types `α`, applying the `Language.reverse` function twice to any language results in the original language. This is equivalent to saying that the `Language.reverse` function is its own inverse with respect to function composition.

For any type `α`, the operation of reversing a language using `Language.reverse` is an involution. In other words, `Language.reverse ∘ Language.reverse` equals the identity function for languages.


theorem NNReal.coe_iInf : ∀ {ι : Sort u_1} (s : ι → NNReal), ↑(⨅ i, s i) = ⨅ i, ↑(s i) := by sorry

This theorem asserts that for any indexed family of nonnegative real numbers (`NNReal`), the infimum (greatest lower bound) of the entire family, when considered as an element of the real numbers (which is what the ↑ notation indicates), is equal to the infimum of the images of the individual elements under the canonical embedding of nonnegative real numbers into the real numbers. In simpler terms, it says that taking the infimum then mapping to the real numbers gives the same result as first mapping each element of the family to the real numbers then taking the infimum.

The inf inf (x : ℝ↑^∞) = inf (map ℝ⊙ x) where ℝ↑^∞ is the type of indexed nonnegative real numbers and ℝ⊙ is the canonical embedding of nonnegative real numbers into the real numbers.


theorem IsPrimitiveRoot.iff_def :
    ∀ {M : Type u_1} [inst : CommMonoid M] (ζ : M) (k : ℕ),
      IsPrimitiveRoot ζ k ↔ ζ ^ k = 1 ∧ ∀ (l : ℕ), ζ ^ l = 1 → k ∣ l :=
  by sorry

This theorem states that for any type `M` that forms a commutative monoid and any element `ζ` of `M` and natural number `k`, `ζ` is a primitive root of `k` if and only if `ζ` to the power of `k` equals 1 and for all natural numbers `l`, if `ζ` to the power of `l` equals 1, then `k` divides `l`. Essentially, it defines a primitive root within the context of a commutative monoid.

A commutative monoid element `ζ` is a primitive root of natural number `k` if and only if `ζ^k = 1` and for all natural numbers `l` with `ζ^l = 1`, `k` divides `l`.


theorem List.disjoint_append_left :
    ∀ {α : Type u_1} {l₁ l₂ l : List α}, List.Disjoint (l₁ ++ l₂) l ↔ List.Disjoint l₁ l ∧ List.Disjoint l₂ l := by
  sorry

The theorem `List.disjoint_append_left` states that for any type `α` and any three lists of type `α`, `l₁`, `l₂`, and `l`, the proposition that `l₁` and `l₂` concatenated together are disjoint from `l` is equivalent to the conjunction of the propositions that `l₁` is disjoint from `l` and `l₂` is disjoint from `l`. In other words, a list `l` has no elements in common with the concatenation of `l₁` and `l₂` if and only if `l` has no elements in common with both `l₁` and `l₂`.

The theorem `List.disjoint_append_left` asserts that for any type `α` and lists `l₁`, `l₂`, and `l` of type `α`, `l₁` and `l₂` have no common elements with `l` if and only if `l₁` and `l₂` each have no common elements with `l`.


PartialEquiv.EqOnSource.eqOn

/-- Two equivalent partial equivs coincide on the source.  -/
theorem PartialEquiv.EqOnSource.eqOn :
    ∀ {α : Type u_1} {β : Type u_2} {e e' : PartialEquiv α β}, e ≈ e' → Set.EqOn (↑e) (↑e') e.source := by sorry

This theorem states that if two partial equivalences `e` and `e'` between types `α` and `β` are equivalent to each other, then the functions corresponding to `e` and `e'` are equal on the source set of `e`. In other words, for all elements `x` in the source of `e`, the results of applying `e` and `e'` to `x` are the same.

If two partial equivalences `e` and `e'` from type `α` to type `β` are equal, then for all `x ∈ domain e`, `e x = e' x`.


/-- A sum of finite numbers is still finite  -/
theorem ENNReal.sum_lt_top :
    ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal}, (∀ a ∈ s, f a ≠ ⊤) → (Finset.sum s fun a => f a) < ⊤ := by sorry

This theorem states that the sum of a finite number of extended nonnegative real numbers is still a finite number. More specifically, given a finite set `s` and a function `f` mapping elements of `s` to extended nonnegative real numbers (denoted as [0, ∞]), if every element `a` in `s` under the function `f` does not map to ∞ (the symbol for infinity), then the sum of `f(a)` over all `a` in `s` is less than ∞. In other words, it's impossible for a sum of finitely many non-infinite extended nonnegative real numbers to result in infinity.

Given a finite set and a function mapping each element to a finite extended nonnegative real number, the sum of the function values is also a finite extended nonnegative real number.


theorem Mathlib.Algebra.Algebra.Basic._auxLemma.8 :
    ∀ {R : Type u_1} {A : Type u_2} [inst : Field R] [inst_1 : CommSemiring A] [inst_2 : Nontrivial A]
      [inst_3 : Algebra R A] (a : R), (↑a = 0) = (a = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Algebra.Basic._auxLemma.8`, states that for any given ring `R`, a commutative semiring `A`, and an algebra structure between `R` and `A`, if `R` is a field and `A` is nontrivial, then an element `a` in `R` maps to zero in `A` if and only if `a` itself is zero. In other words, the only way a non-zero element of `R` can become zero when considered as an element of `A` is if it was already zero in `R`.

For any commutative semiring `A` with an algebra structure over a field `R`, if `A` is nontrivial, then for all `a` in `R`, `a` maps to zero in `A` if and only if `a` is zero in `R`.


/-- **Alias** of the forward direction of `isBounded_iff_forall_norm_le`. -/
theorem Bornology.IsBounded.exists_norm_le :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {s : Set E}, Bornology.IsBounded s → ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
  sorry

The theorem `Bornology.IsBounded.exists_norm_le` states that for any type `E` that is a `SeminormedAddGroup` and any set `s` of type `E`, if `s` is a bounded set relative to the given bornology on `E`, then there exists a constant `C` such that for all elements `x` in set `s`, the norm of `x` is less than or equal to `C`. This is essentially a formal statement of the property that a set is bounded if and only if there exists a constant that bounds the norm of all the elements within that set.

For any seminormed add group `E` and bounded set `s` in `E`, there exists a constant `C` such that for all `x` in `s`, we have ||x|| ≤ C.


theorem continuous_le_dom :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β},
      t₂ ≤ t₁ → Continuous f → Continuous f :=
  by sorry

This theorem, `continuous_le_dom`, states that for any two topological spaces `t₁` and `t₂` over a set of type `α` and a function `f` from `α` to another set of type `β` in a topological space `t₃`, if the topology `t₂` is a subset of or equal to the topology `t₁`, then the continuity of `f` with respect to `t₁` and `t₃` implies its continuity with respect to `t₂` and `t₃`. In other words, if a function is continuous in a coarser (larger) topology, it continues to be continuous in a finer (smaller or equal) topology.

If `f` is continuous from `(α, t₁)` to `(β, t₃)` and `t₂ ⊆ t₁`, then `f` is continuous from `(α, t₂)` to `(β, t₃)`.


theorem Mathlib.Topology.Defs.Basic._auxLemma.1 : ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen Set.univ = True :=
  by sorry

The theorem `Mathlib.Topology.Defs.Basic._auxLemma.1` states that for any type `X` that has a topological space structure, the universal set of `X` is an open set. In mathematical terms, this theorem asserts that the entire set in any given topological space is always an open set. This is a fundamental property in topology, where the entire space and the empty set are considered open by definition.

In any topological space, the universal set is open.


theorem addOrderOf_eq_zero : ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, ¬IsOfFinAddOrder x → addOrderOf x = 0 := by
  sorry

The theorem `addOrderOf_eq_zero` states that for any type `G` that forms an additive monoid, for any element `x` of `G`, if `x` does not have finite additive order, then the additive order of `x` is zero. In other words, if there does not exist a non-zero natural number `n` such that `n` times `x` equals the zero element of the monoid, then the additive order of `x` is defined to be zero by convention.

If an element in an additive monoid does not have a finite additive order, then its additive order is zero by convention.


theorem ProbabilityTheory.kernel.indepSets_piiUnionInter_of_disjoint :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → Set (Set Ω)} {S T : Set ι},
      ProbabilityTheory.kernel.iIndepSets s κ μ →
        Disjoint S T → ProbabilityTheory.kernel.IndepSets (piiUnionInter s S) (piiUnionInter s T) κ μ :=
  by sorry

This theorem, `ProbabilityTheory.kernel.indepSets_piiUnionInter_of_disjoint`, states that for any types `α`, `Ω`, and `ι`, measurable spaces `_mα` and `_mΩ`, a kernel `κ` of type `ProbabilityTheory.kernel α Ω`, a measure `μ` of type `MeasureTheory.Measure α`, a family of sets `s` of type `ι → Set (Set Ω)`, and two sets `S` and `T` of type `Set ι`, if the family of sets `s` is independent with respect to the kernel `κ` and the measure `μ`, and if the sets `S` and `T` are disjoint, then the sets formed by the union and intersection of `s` with `S` and `s` with `T` are independent with respect to the kernel `κ` and the measure `μ`. This theorem allows us to extend the concept of independence from a family of sets to more complex structures formed by unions and intersections, provided the original sets are disjoint.

If `κ` is a kernel, `μ` is a measure, `s` is an independent family of sets, and `S` and `T` are disjoint sets, then the sets `s ∩ S`, `s ∩ T`, `(s ∩ S) ∪ (s ∩ T)`, and `s ∩ (S ∪ T)` are independent with respect to `κ` and `μ`.


theorem Nat.bit0_ne_zero : ∀ {n : ℕ}, n ≠ 0 → bit0 n ≠ 0 := by sorry

This theorem states that for all natural numbers `n`, if `n` is not equal to zero, then the double of `n` (represented by `bit0 n`) is also not equal to zero. Here, `bit0` is a function that takes a number and returns its double. In mathematical terms, the theorem asserts that for any natural number $n$, if $n \neq 0$, then $2n \neq 0$.

For all natural numbers $n$, if $n \neq 0$, then $2n \neq 0$.


theorem CategoryTheory.MonoidalCategory.inv_hom_whiskerRight :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f : X ≅ Y) (Z : C),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f.inv Z)
          (CategoryTheory.MonoidalCategory.whiskerRight f.hom Z) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.tensorObj Y Z) :=
  by sorry

This theorem is named `CategoryTheory.MonoidalCategory.inv_hom_whiskerRight` in Lean 4 and belongs to the area of Category Theory, specifically Monoidal Categories. It states that for any Category `C` (with the Monoidal structure), and for any objects `X`, `Y`, and `Z` in `C`, given a natural isomorphism `f` between `X` and `Y`, the composition of `f.inv` whiskerRight `Z` and `f.hom` whiskerRight `Z` (i.e., first applying `f.inv` then `f.hom` along the right side of `Z` in the tensor product) equals the identity morphism on the tensor product of `Y` and `Z`. Essentially, this theorem encapsulates the idea that whiskering (tensoring with an object) respects the inverse property of isomorphisms in a monoidal category.

For any monoidal category C, given an object X and natural isomorphisms f : X ≅ Y, the composition of f.inv ⊛ Z and f.hom ⊛ Z (whiskered right along Z) equals the identity morphism on X ⊗ Y, where ⊛ denotes composition in the 2-category of C and ⊗ denotes the monoidal product.


theorem sup_right_comm : ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = a ⊔ c ⊔ b := by sorry

This theorem, `sup_right_comm`, states that for any semilattice (a partially ordered set with a supremum operation) of type `α`, the supremum operation (`⊔`) is right-commutative. In other words, for any three elements `a`, `b`, and `c` of type `α`, the supremum of `a`, `b` and `c` remains the same if the order of `b` and `c` is switched. The supremum of `a`, `b` and `c` is denoted by `a ⊔ b ⊔ c` and it is equal to `a ⊔ c ⊔ b`.

For any semilattice `α`, the supremum operation `⊔` is right-commutative, i.e., `a ⊔ b ⊔ c = a ⊔ c ⊔ b` for all `a, b, c` in `α`.


/-- If a function admits a power series expansion `p` on an open ball `B (x, r)`, then
it is analytic at every point of this ball.  -/
theorem HasFPowerSeriesOnBall.analyticAt_of_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : CompleteSpace F]
      {f : E → F} {p : FormalMultilinearSeries 𝕜 E F} {x y : E} {r : ENNReal},
      HasFPowerSeriesOnBall f p x r → y ∈ EMetric.ball x r → AnalyticAt 𝕜 f y :=
  by sorry

This theorem states that if a function `f` from a normed space `E` to a complete space `F` over a nontrivially normed field `𝕜` has a power series expansion `p` on an open ball `B(x, r)`, then `f` is analytic at every point `y` within this ball. In mathematical terms, if `f : E → F` admits a power series expansion on an open ball centered at `x` with radius `r`, then `f` is analytic at any point `y` such that the extended metric distance from `y` to `x` is less than `r`.

If a function `f : E → F` from a normed space `E` to a complete space `F` over a nontrivially normed field `𝕜` has a power series expansion on an open ball `B(x, r)` in `E`, then `f` is analytic on `B(x, r)`.


theorem Stream'.eq_of_bisim :
    ∀ {α : Type u} (R : Stream' α → Stream' α → Prop),
      Stream'.IsBisimulation R → ∀ {s₁ s₂ : Stream' α}, R s₁ s₂ → s₁ = s₂ :=
  by sorry

The theorem `Stream'.eq_of_bisim` states that for any type `α` and any relation `R` on streams of type `α`, if `R` is a bisimulation (meaning for any two streams `s₁` and `s₂`, if they are related by `R`, then they have the same head and their tails are also related by `R`), then any two streams `s₁` and `s₂` that are related by `R` are actually equal. In other words, bisimulations preserve the identity of streams.

If `R` is a bisimulation relation on streams of type `α`, then for any `s₁` and `s₂` related by `R`, we have `s₁ = s₂`.


theorem List.isEmpty_iff_eq_nil : ∀ {α : Type u} {l : List α}, List.isEmpty l = true ↔ l = [] := by sorry

This theorem, `List.isEmpty_iff_eq_nil`, states that for any type `α` and for any list `l` of `α`, the function `List.isEmpty` returns `true` if and only if the list `l` is an empty list. In other words, it establishes a bi-directional relationship between the list being empty and the `List.isEmpty` function returning `true`.

For any type α, List.isEmpty (l : List α) if and only if l is an empty list.


theorem existsUnique_zsmul_near_of_pos' :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [inst_1 : Archimedean α] {a : α},
      0 < a → ∀ (g : α), ∃! k, 0 ≤ g - k • a ∧ g - k • a < a :=
  by sorry

This theorem states that for any type `α` that forms a linear ordered additive commutative group and satisfies the Archimedean property, and for any element `a` of type `α` that is greater than zero, for every element `g` of type `α`, there exists a unique integer `k` such that the difference `g - k•a` is non-negative and less than `a`. Here, `k•a` represents the operation of multiplying `a` by `k` times in the group. The Archimedean property essentially states that there are no infinitely small or infinitely large elements in the group.

For any Archimedean, linearly ordered additive commutative group `α` and positive element `a` in `α`, there exists a unique integer `k` such that `g - k•a` is non-negative and less than `a`, for all `g` in `α`.


theorem ssubset_iff_subset_ne :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α}
      [inst_3 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊂ b ↔ a ⊆ b ∧ a ≠ b :=
  by sorry

This theorem states that for any type `α` that has subset (`HasSubset`) and strict subset (`HasSSubset`) operations, and for any elements `a` and `b` of type `α`, `a` is a strict subset of `b` if and only if `a` is a subset of `b` and `a` is not equal to `b`. This is under the conditions where the subset operation forms a non-strict strict order (`IsNonstrictStrictOrder`) over `α` and the subset operation is anti-symmetric (`IsAntisymm`).

For any type `α` with `HasSubset` and `HasSSubset` operations, `a ⊆ b` and `a ≠ b` if and only if `a` is a strict subset of `b`, assuming the subset operation is a non-strict strict order and anti-symmetric.


theorem algebraMap.coe_one :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A], ↑1 = 1 := by
  sorry

This theorem, `algebraMap.coe_one`, states that for any two types `R` and `A`, where `R` is a commutative semiring and `A` is a semiring with an algebra structure over `R`, the algebraic map of the number 1 from `R` to `A` equals 1 in `A`. In more mathematical terms, given any commutative semiring `R` and any semiring `A` that has `R` as an algebra, the image of 1 in `R` under the algebra map is 1 in `A`. This theorem essentially underlines one of the basic properties of algebra maps: they must preserve the multiplicative identity.

For any commutative semiring `R` and semiring `A` with `R` being an algebra over `A`, the algebra map of `1` from `R` to `A` equals `1` in `A`.


/-- Representation of a difference of two squares of commuting elements as a product.  -/
theorem Commute.mul_self_sub_mul_self_eq :
    ∀ {R : Type x} [inst : NonUnitalNonAssocRing R] {a b : R}, Commute a b → a * a - b * b = (a + b) * (a - b) := by
  sorry

The theorem `Commute.mul_self_sub_mul_self_eq` states that for any type `R` that forms a `NonUnitalNonAssocRing`, given two elements `a` and `b` of type `R` that commute (meaning `a * b = b * a`), the difference of their squares (`a * a - b * b`) is equal to the product of `a + b` and `a - b`. This is a well-known algebraic identity often referred to as the difference of squares formula.

For any commuting elements `a` and `b` in a non-unital non-associative ring `R`, their squared difference `(a * a) - (b * b)` equals the product of their sum and difference `(a + b) * (a - b)`.


LinearIndependent.map'

/-- An injective linear map sends linearly independent families of vectors to linearly independent
families of vectors. See also `LinearIndependent.map` for a more general statement.  -/
theorem LinearIndependent.map' :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {M' : Type u_5} {v : ι → M} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'],
      LinearIndependent R v → ∀ (f : M →ₗ[R] M'), LinearMap.ker f = ⊥ → LinearIndependent R (⇑f ∘ v) :=
  by sorry

The theorem `LinearIndependent.map'` states that for any type `ι`, semiring `R`, additive commutative monoids `M` and `M'`, and a function `v` from `ι` to `M`, if `v` is a linearly independent family of vectors over `R`, then any injective linear map `f` from `M` to `M'` sends `v` to another linearly independent family of vectors over `R`. In other words, the image of a linearly independent set under an injective linear map is also linearly independent. This theorem is a specific instance of the more general `LinearIndependent.map` theorem.

A linearly independent family of vectors mapped by an injective linear transformation remains linearly independent.


theorem Int.add_left_cancel : ∀ {a b c : ℤ}, a + b = a + c → b = c := by sorry

This theorem, `Int.add_left_cancel`, states that for any three integers `a`, `b`, and `c`, if the sum of `a` and `b` equals the sum of `a` and `c`, then `b` must be equal to `c`. In other words, in the context of integer addition, the addition of `a` can be cancelled from both sides of an equation without affecting the equality of `b` and `c`.

If `a + b = a + c` in the context of integer addition, then `b = c`.


/-- To show that two subobjects are equal, it suffices to exhibit an isomorphism commuting with
the arrows.  -/
theorem CategoryTheory.Subobject.eq_of_comm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B}
      (f : CategoryTheory.Subobject.underlying.obj X ≅ CategoryTheory.Subobject.underlying.obj Y),
      CategoryTheory.CategoryStruct.comp f.hom (CategoryTheory.Subobject.arrow Y) = CategoryTheory.Subobject.arrow X →
        X = Y :=
  by sorry

This theorem, `CategoryTheory.Subobject.eq_of_comm`, states that in a category 'C', for any object 'B' and two subobjects 'X' and 'Y' of 'B', if there exists an isomorphism 'f' between the underlying objects of 'X' and 'Y' such that the composition of 'f' and the arrow of 'Y' equals the arrow of 'X', then 'X' and 'Y' are the same subobject. In other words, two subobjects are considered identical if they have the same underlying object up to isomorphism, and the arrows (representing the inclusion of the subobject in the ambient object) commute with this isomorphism.

In a category C, two subobjects X and Y of an object B are equal if there exists an isomorphism f between their underlying objects making the diagram commute: X ⟶ B ⟵ Y ≃ f ∘ Y.


theorem segment_eq_Icc :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] {x y : 𝕜}, x ≤ y → segment 𝕜 x y = Set.Icc x y := by sorry

The theorem `segment_eq_Icc` states that for any linearly ordered field `𝕜` and any two elements `x` and `y` in this field, if `x` is less than or equal to `y`, then the segment from `x` to `y` is equal to the closed interval from `x` to `y`. In layman's terms, if we take two points on a line, the "segment" between these points (including the points themselves) is exactly the same set of points as the "closed interval" between these points.

For any linearly ordered field, the segment between two elements is equal to the closed interval with endpoints at those elements if they are ordered correctly.


theorem Set.pairwiseDisjoint_fiber :
    ∀ {α : Type u_1} {ι : Type u_4} (f : ι → α) (s : Set α), Set.PairwiseDisjoint s fun a => f ⁻¹' {a} := by sorry

This theorem states that for any type `α`, any index type `ι`, any function `f` from `ι` to `α`, and any set `s` of type `α`, the set `s` is Pairwise Disjoint under the function that maps each element `a` of `α` to the preimage of `{a}` under `f`. In other words, for any two distinct elements of `s`, their preimages under `f` (i.e., the sets of elements that map to them) are disjoint.

For any type `α`, index type `ι`, function `f` from `ι` to `α`, and set `s` of type `α`, if `a` and `b` are distinct elements of `s`, then the preimages `f⁁¹{a}` and `f⁁¹{b}` are disjoint subsets of `ι`.


Multiset.Subset.trans

theorem Multiset.Subset.trans : ∀ {α : Type u_1} {s t u : Multiset α}, s ⊆ t → t ⊆ u → s ⊆ u := by sorry

This theorem states that for any type `α` and for any three multisets `s`, `t`, and `u` of that type, if `s` is a subset of `t` and `t` is a subset of `u`, then `s` is a subset of `u`. In other words, the subset relationship is transitive on multisets. This is analogous to the principle in set theory that if $A \subseteq B$ and $B \subseteq C$, then $A \subseteq C$.

If `α` is a type and `s`, `t`, and `u` are multisets of `α` with `s ⊆ t` and `t ⊆ u`, then `s ⊆ u`.


theorem List.subset_cons : ∀ {α : Type u_1} (a : α) (l : List α), l ⊆ a :: l := by sorry

This theorem is stating that for any type `α`, any element `a` of type `α`, and any list `l` containing elements of type `α`, the list `l` is a subset of the list that results from prepending `a` to `l`. In more formal language, the theorem asserts that for all `α`, `a`, and `l`, `l` is a subset of `a :: l`.

For any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, `l` is a subset of the list obtained by prepending `a` to `l`.


theorem QuotientAddGroup.out_eq' :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (a : α ⧸ s), ↑(Quotient.out' a) = a := by sorry

The theorem `QuotientAddGroup.out_eq'` states that for any type `α` equipped with an additive group structure, given an additive subgroup `s` of `α` and an element `a` of the quotient group `α ⧸ s`, the canonical projection of the outcome of the function `Quotient.out'` applied to `a` is equal to `a`. In other words, it says that applying the function `Quotient.out'`, which retrieves a representative element from the equivalence class in the quotient group, and then mapping back to the quotient group via the canonical projection, gives us the original element `a` of the quotient group. This theorem essentially validates the correctness of the function `Quotient.out'` in the context of additive quotient groups.

For any additive group `α` and its subgroup `s`, the canonical projection of the representative element of an equivalence class `a` in the quotient group `α ⧸ s` is equal to `a` itself.


theorem Nat.pairwise_one_le_dist : Pairwise fun m n => 1 ≤ dist m n := by sorry

This theorem states that the pairwise distance between any two distinct natural numbers is always greater than or equal to 1. In other words, for every pair of different natural numbers `m` and `n`, the absolute difference between `m` and `n` (denoted as `dist m n`) is at least 1. This statement aligns with the intuitive notion of distance in the set of natural numbers.

For all natural numbers m and n with m ≠ n, |m - n| ≥ 1.


AddCommGroup.ModEq.trans

theorem AddCommGroup.ModEq.trans :
    ∀ {α : Type u_1} [inst : AddCommGroup α] {p a b c : α}, a ≡ b [PMOD p] → b ≡ c [PMOD p] → a ≡ c [PMOD p] := by sorry

This theorem states that, for any type `α` that forms an additive commutative group, the modulus operation (denoted as [PMOD p]) is transitive. In other words, for any elements `a`, `b`, `c` of the group and a modulus `p`, if `a` is equivalent to `b` modulo `p`, and `b` is equivalent to `c` modulo `p`, then `a` is equivalent to `c` modulo `p`. This is a fundamental property of the modulus operation in mathematics, expressing the fact that if two numbers leave the same remainder when divided by a number `p`, and a third number leaves the same remainder as the second when divided by `p`, then the first and third numbers also leave the same remainder when divided by `p`.

For any additive commutative group `α` and modulus `p`, if `a ≡ b (mod p)` and `b equiv c (mod p)`, then `a ≡ c (mod p)`.


/-- Additive congruence relations equal the smallest
additive congruence relation in which they are contained. -/
theorem AddCon.addConGen_of_addCon : ∀ {M : Type u_1} [inst : Add M] (c : AddCon M), addConGen ⇑c = c := by sorry

This theorem states that for any additive congruence relation `c` on a type `M` equipped with an addition operation, `c` is equal to the smallest additive congruence relation that contains it. In other words, any given additive congruence relation is exactly the smallest possible congruence relation that includes all its pairs of congruent elements in the context of addition in `M`.

For any additive congruence relation `c` on a type `M` with addition, `c` is the smallest additive congruence relation containing `c`.


DifferentiableOn.diffContOnCl

theorem DifferentiableOn.diffContOnCl :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {s : Set E},
      DifferentiableOn 𝕜 f (closure s) → DiffContOnCl 𝕜 f s :=
  by sorry

The given theorem, `DifferentiableOn.diffContOnCl`, establishes that for all types `𝕜`, `E`, and `F`, where `𝕜` is a nontrivially normed field, `E` is a normed additive commutative group and a normed space over `𝕜`, `F` is also a normed additive commutative group and a normed space over `𝕜`, given a function `f` from `E` to `F` and a set `s` of `E`, if the function `f` is differentiable on the closure of `s`, then `f` is continuously differentiable on the closure of `s`. In simpler terms, this theorem states that if a function is differentiable on every point in the smallest closed set containing a particular set, then it is also continuously differentiable on that set.

If a function between two normed spaces is differentiable on the closure of a set, then it is continuously differentiable on the closure of that set.


theorem LipschitzWith.comap_cobounded_le :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → Filter.comap f (Bornology.cobounded β) ≤ Bornology.cobounded α :=
  by sorry

The theorem `LipschitzWith.comap_cobounded_le` states that for any two types `α` and `β` equipped with a pseudo metric space structure, a nonnegative real number `K`, and a function `f` from `α` to `β`, if `f` is Lipschitz continuous with Lipschitz constant `K` (i.e., the distance between `f(x)` and `f(y)` is at most `K` times the distance between `x` and `y`), then the preimage filter under `f` of the filter of cobounded sets in the bornology of `β` is a subset of the filter of cobounded sets in the bornology of `α`. In other words, Lipschitz continuous functions preserve the structure of cobounded sets in a bornology when mapping from `β` to `α`.

If `f: α → β` is Lipschitz continuous with constant `K` between pseudo metric spaces `(α, dα)` and `(β, dβ)`, then for any cobounded set `C ∈ bornology β`, the preimage `f⁻¹(C)` is a cobounded set in `bornology α`.


theorem NNReal.coe_pow : ∀ (r : NNReal) (n : ℕ), ↑(r ^ n) = ↑r ^ n := by sorry

This theorem states that for any nonnegative real number `r` and any natural number `n`, the action of raising `r` to the power of `n` (denoted `r^n`) and then taking the real part (denoted `(r ^ n).to_real`) is equivalent to first taking the real part of `r` (denoted `r.to_real`) and then raising it to the power of `n`. In other words, the operations of exponentiation and taking the real part commute for nonnegative real numbers and natural number exponents.

For any non-negative real number `r` and natural number `n`, `(r.to_real ^ n) = (r.to_real ^ n)`. That is, real part commuting with power operation for non-negative real numbers and natural number exponents.


theorem CategoryTheory.Limits.kernelSubobject_arrow :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectIso f).hom
          (CategoryTheory.Limits.kernel.ι f) =
        CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject f) :=
  by sorry

The theorem `CategoryTheory.Limits.kernelSubobject_arrow` states that for any category `C` with zero morphisms, given a morphism `f` from object `X` to object `Y` in `C` that has a kernel, the composition of the isomorphism from the kernel subobject of `f` to `f` and the kernel inclusion morphism `f` is equal to the morphism from the kernel subobject of `f` to `X`. In mathematical terms, given a morphism `f : X ⟶ Y`, it asserts that `(kernelSubobjectIso f).hom ≫ kernel.ι f = Subobject.arrow (kernelSubobject f)`.

Given a morphism `f : X ➝ Y` in a category with zero morphisms and a kernel `kernel f : Subobject (Set X)`, the composition of the kernel isomorphism `kernelSubobjectIso f` with the kernel inclusion morphism `kernel.ι f` equals the subobject arrow of the kernel `Subobject.arrow (kernelSubobject f)`.


theorem Polynomial.aroots_C :
    ∀ {S : Type v} {T : Type w} [inst : CommRing T] [inst_1 : CommRing S] [inst_2 : IsDomain S] [inst_3 : Algebra T S]
      (a : T), Polynomial.aroots (Polynomial.C a) S = 0 :=
  by sorry

This theorem states that for any commutative rings `S` and `T` with `S` being an integral domain and an algebra over `T`, and for any element `a` from `T`, the multiset of roots of the constant polynomial `a` (considered as a polynomial over `S`) is empty. In other words, a constant polynomial doesn't have any roots.

For any commutative rings S and T with S an integral domain and S an algebra over T, and for any element a in T, the constant polynomial a over S has no roots.


theorem CategoryTheory.Biprod.inr_ofComponents :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ Y₁ Y₂ : C} (f₁₁ : X₁ ⟶ Y₁) (f₁₂ : X₁ ⟶ Y₂)
      (f₂₁ : X₂ ⟶ Y₁) (f₂₂ : X₂ ⟶ Y₂),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr
          (CategoryTheory.Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂) =
        CategoryTheory.CategoryStruct.comp f₂₁ CategoryTheory.Limits.biprod.inl +
          CategoryTheory.CategoryStruct.comp f₂₂ CategoryTheory.Limits.biprod.inr :=
  by sorry

The theorem `CategoryTheory.Biprod.inr_ofComponents` states that in a category `C` with binary biproducts and preadditive structure, for any objects `X₁`, `X₂`, `Y₁`, `Y₂` in `C` and morphisms `f₁₁ : X₁ ⟶ Y₁`, `f₁₂ : X₁ ⟶ Y₂`, `f₂₁ : X₂ ⟶ Y₁`, `f₂₂ : X₂ ⟶ Y₂`, the composition of the inclusion morphism from the second component of the biproduct (`CategoryTheory.Limits.biprod.inr`) with the morphism defined by the matrix (`CategoryTheory.Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂`) is equal to the sum of the composition of `f₂₁` and the inclusion morphism from the first component of the biproduct (`CategoryTheory.Limits.biprod.inl`) and the composition of `f₂₂` and `CategoryTheory.Limits.biprod.inr`. This theorem is essentially a property of morphisms between biproducts in an additive category, expressing how such morphisms interact with the canonical inclusion morphisms.

In a preadditive category with binary biproducts, the composition of the inclusion morphism from the second component of a biproduct with a morphism defined by a matrix and the inclusion morphism from the first component, is equal to the sum of the composition of the second component inclusion with the given morphism and the composition of the second morphism and the inclusion morphism from the second component.


theorem Cardinal.le_mk_iff_exists_set :
    ∀ {c : Cardinal.{u}} {α : Type u}, c ≤ Cardinal.mk α ↔ ∃ p, Cardinal.mk ↑p = c := by sorry

This theorem establishes a relationship between a given cardinal and the cardinality of a type. It asserts that for any cardinal `c` and any type `α`, `c` is less than or equal to the cardinality of `α` if and only if there exists a set `p` such that the cardinality of `p` is equal to `c`. In other words, a cardinal number is smaller than or equal to the size of a type if and only if there is a subset of the type which has the same cardinality as the cardinal number. This connects the abstract concept of cardinality with the concrete idea of subsets of a given type.

For any cardinal `c` and type `α`, `c ≤ |α|` if and only if there exists a set `p ⊆ α` with `|p| = c`.


/-- Being cofiltered is preserved by equivalence of categories.  -/
theorem CategoryTheory.IsCofiltered.of_equivalence :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsCofiltered C] {D : Type u₁}
      [inst_2 : CategoryTheory.Category.{v₁, u₁} D], (C ≌ D) → CategoryTheory.IsCofiltered D :=
  by sorry

This theorem states that the property of being cofiltered is preserved by equivalence of categories in category theory. In other words, if we have a category `C` that is cofiltered, and we have another category `D` such that `C` is equivalent to `D` (denoted `C ≌ D`), then `D` is also cofiltered.

If categories `C` and `D` are equivalent (`C ≌ D`), and `C` is cofiltered, then `D` is also cofiltered.


theorem le_self_pow : ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R} {m : ℕ}, 1 ≤ a → m ≠ 0 → a ≤ a ^ m := by sorry

This theorem states that for any ordered semiring 'R' and any element 'a' of 'R' along with a nonzero natural number 'm', if 'a' is greater than or equal to 1, then 'a' is less than or equal to 'a' raised to the power 'm'. This essentially asserts that any number greater than or equal to 1 is always less than or equal to its power, provided the exponent is a nonzero natural number.

For any ordered semiring 'R' and element 'a' of 'R' with 'a' >= 1 and 'm' a nonzero natural number, 'a' <= 'a'^'m'.


theorem FractionalIdeal.mul_left_mono :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      (I : FractionalIdeal S P), Monotone fun x => I * x :=
  by sorry

This theorem, `FractionalIdeal.mul_left_mono`, states that for any commutative ring `R`, submonoid `S` of `R`, commutative ring `P`, and algebra structure on `R` and `P`, and for any fractional ideal `I` of `S` in `P`, the function that multiplies `I` to the left is monotone. In other words, if we have two elements `x` and `y` in the ring such that `x ≤ y`, then `I * x ≤ I * y`, where the multiplication and comparison are done in the ring.

For any commutative rings R and P, submonoid S of R, algebra structure on R and P, and fractional ideal I of S in P, the multiplication of I by any element x in R (left multiplication) is monotone, that is, I * x ≤ I * y whenever x ≤ y in R.


theorem Mathlib.Topology.Order._auxLemma.30 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
      Continuous f = (t₁ ≤ TopologicalSpace.induced f t₂) :=
  by sorry

This theorem states that for any two types `α` and `β`, a function `f` from `α` to `β`, and topological spaces `t₁` on `α` and `t₂` on `β`, the function `f` is continuous if and only if the topological space `t₁` is coarser (smaller or equal to) the topology induced on `α` by `f` and the topology `t₂` on `β`. In other words, `f` retains continuity when the topology on `α` is the coarsest topology that makes `f` continuous.

A function between two topological spaces is continuous if and only if its domain is equipped with a coarser topology that makes the function continuous and the image topology is the given topology on the codomain.


theorem Mathlib.Topology.Order._auxLemma.31 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
      Continuous f = (TopologicalSpace.coinduced f t₁ ≤ t₂) :=
  by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, also any given topological spaces `t₁` on `α` and `t₂` on `β`, the function `f` is continuous if and only if the coinduced topology on `β` from `f` and `t₁` is a subset of `t₂`. In layman's terms, this theorem is elaborating a condition for a function to be continuous between two topological spaces: it states that a function is continuous if the finest topology on the codomain, which makes the function continuous, is less than or equal to the original topology on the codomain.

A function between two topological spaces is continuous if and only if the coinduced topology on the codomain is a subset of the given topology on the codomain.


theorem Fintype.ofBijective.proof_1 :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β), Function.Bijective f → Function.Injective f := by sorry

The theorem `Fintype.ofBijective.proof_1` states that for any two types `α` and `β`, and for any function `f` from `α` to `β`, if the function `f` is bijective (meaning it is both injective and surjective), then it is also injective. In mathematical terms, this means that for all elements `a₁` and `a₂` in `α`, if `f(a₁) = f(a₂)` then necessarily `a₁ = a₂`. In other words, no two distinct elements in `α` map to the same element in `β` under the function `f` when `f` is bijective.

If `f` is a bijective function from type `α` to type `β` in Lean 4, then for all `a₁, a₂ ∈ α`, `a₁ = a₂` implies `f(a₁) = f(a₂)`.


theorem inf_mul_sup :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a b : α), (a ⊓ b) * (a ⊔ b) = a * b :=
  by sorry

This theorem states that in any lattice structure `α` that also forms a commutative group, if we have defined a covariant class on `α` under multiplication and the standard order relation (≤), then for any two elements `a` and `b` of `α`, the product of the infimum (greatest lower bound, denoted by a ⊓ b) and the supremum (least upper bound, denoted by a ⊔ b) of `a` and `b` equals the product of `a` and `b`. In mathematical terms, `(a ⊓ b) * (a ⊔ b) = a * b` for all `a` and `b` in `α`.

In a commutative lattice-ordered group, the inf infimum and supremum of two elements are multiplicatively idempotent, that is, (inf a b) * (sup a b) = a * b.


theorem Matrix.adjugate_mul :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α),
      Matrix.adjugate A * A = Matrix.det A • 1 :=
  by sorry

The theorem `Matrix.adjugate_mul` states that for any square matrix `A` of type `α` where `α` is a commutative ring, the product of the adjugate of `A` and `A` itself is equal to the determinant of `A` times the identity matrix. This theorem holds for any matrix size `n`, where `n` is a finite type with decidable equality.

The theorem asserts that that the product of the adjugate and a square matrix over a commutative ring equals the determinant of the matrix multiplied by the identity matrix.


theorem Complex.cos_two_mul : ∀ (x : ℂ), Complex.cos (2 * x) = 2 * Complex.cos x ^ 2 - 1 := by sorry

This theorem states that for every complex number `x`, the cosine of twice this number, computed using the complex cosine function, is equal to twice the square of the cosine of the original number minus one. In mathematical terms, for all complex numbers x, we have cos(2x) = 2cos²(x) - 1, where cos is the complex cosine function defined in terms of the complex exponential function.

For all complex numbers x, cos(2x) = 2 cos²(x) - 1.


theorem AddMonoidAlgebra.single_mul_apply_aux :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Add G] (f : AddMonoidAlgebra k G) (r : k) (x y z : G),
      (∀ (a : G), x + a = y ↔ a = z) → (AddMonoidAlgebra.single x r * f) y = r * f z :=
  by sorry

The theorem `AddMonoidAlgebra.single_mul_apply_aux` states that for any type `k`, any additive monoid `G`, any element `f` of the monoid algebra of `k` generated by `G`, any element `r` of type `k`, and any elements `x`, `y`, and `z` of `G` such that for every `a` in `G`, `x + a = y` if and only if `a = z`, then the result of multiplying `AddMonoidAlgebra.single x r` and `f` at the point `y` is equal to the result of multiplying `r` and `f` at the point `z`. In other words, this theorem is about the interaction of multiplication in the monoid algebra with addition in the underlying additive monoid.

For any additive monoid `G`, any element `f` of its monoid algebra, and any elements `r`, `x`, `y`, and `z` in `G` such that `x + a = y` if and only if `a = z`, the multiplication of `AddMonoidAlgebra.single x r` and `f` at `y` equals the multiplication of `r` and `f` at `z`.


theorem CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
      CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (P.π.f 0) = 0 :=
  by sorry

The theorem `CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero` states that for any category `C`, given that `C` has a zero object and zero morphisms, and for any object `Z` in `C` with a projective resolution `P`, the composition of the morphism `P.complex.d 1 0` and `P.π.f 0` is equal to the zero morphism. In simpler terms, the theorem specifies a property of projective resolutions in a category, whereby a certain composition of morphisms results in the zero morphism.

For any category with a zero object and zero morphisms, the composition of the differential `d` at degree 1 and the augmentation morphism `π` for a projective resolution is the zero morphism.


theorem LaurentPolynomial.degree_C_mul_T :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℤ) (a : R),
      a ≠ 0 → LaurentPolynomial.degree (LaurentPolynomial.C a * LaurentPolynomial.T n) = ↑n :=
  by sorry

The theorem `LaurentPolynomial.degree_C_mul_T` states that for any semiring `R`, integer `n`, and non-zero element `a` of `R`, the degree of the product of the constant Laurent polynomial `a` and `T^n` (where 'degree' is defined as the maximum power of `T` in the Laurent polynomial, or negative infinity if the polynomial is zero) is equal to `n`. In other words, if you create a Laurent polynomial by multiplying a constant polynomial `a` by `T` raised to the power `n`, the highest power of `T` that appears in the resulting polynomial is `n`.

For any semiring R, integer n, and non-zero element a in R, the degree of the Laurent polynomial a * T^n is equal to n.


/-- Additive submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t` -/
theorem AddSubmonoid.closure_mono :
    ∀ {M : Type u_1} [inst : AddZeroClass M] ⦃s t : Set M⦄, s ⊆ t → AddSubmonoid.closure s ≤ AddSubmonoid.closure t :=
  by sorry

The theorem `AddSubmonoid.closure_mono` states that for any type `M` that has an addition and zero structure (expressed by `[AddZeroClass M]`), the closure operation of an additive submonoid is monotone with respect to the set containment order. In other words, if you have two sets `s` and `t` of elements of type `M` and `s` is a subset of `t` (expressed by `s ⊆ t`), then the additive submonoid generated by `s` (expressed by `AddSubmonoid.closure s`) is a submonoid of (or equal to) the additive submonoid generated by `t` (expressed by `AddSubmonoid.closure t`).

For any type `M` with an addition and zero structure, the closure of an additive submonoid under a subset inclusion relation is inclusion preserving.


theorem Mathlib.Data.List.Basic._auxLemma.5 :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → List β} {b : β} {l : List α}, (b ∈ List.bind l f) = ∃ a ∈ l, b ∈ f a := by
  sorry

The theorem `Mathlib.Data.List.Basic._auxLemma.5` states that for any types `α` and `β`, any function `f` from `α` to a list of `β`, any element `b` of type `β`, and any list `l` of type `α`, the condition that `b` is an element of the result of applying the `bind` operation on `l` with `f` is equivalent to the existence of an element `a` in `l` such that `b` is an element of the list produced by applying `f` to `a`. Essentially, it is stating that an element is in the list produced by binding `f` over `l` if and only if it exists in a list produced by applying `f` to some element in `l`.

For any types `α` and `β`, and functions `f : α → list β`, element `b : β`, and list `l : list α`, the element `b ∈ bind f l` if and only if there exists `a ∈ l` such that `b ∈ f a`.


theorem Mod_.Hom.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
      {A : Mon_ C} {M N : Mod_ A} (x y : Mod_.Hom M N), x.hom = y.hom → x = y :=
  by sorry

This theorem, `Mod_.Hom.ext`, states that for any category `C` that is a monoidal category, and for any object `A` in the monoidal category `C`, with other objects `M` and `N` in the mod category of `A`, if we have two morphisms `x` and `y` from `M` to `N`, and if the underlying morphism of `x` is equal to the underlying morphism of `y`, then `x` and `y` are the same. In other words, it asserts the uniqueness of morphisms in the context of monoidal categories.

In a monoidal category, two morphisms between objects in the monoidal category's module category with equal underlying morphisms are equal.


/-- The image of the filter `atTop` on `Ici a` under the coercion equals `atTop`.  -/
theorem Filter.map_val_Ici_atTop :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] (a : α), Filter.map Subtype.val Filter.atTop = Filter.atTop := by sorry

This theorem states that for any type `α` that is a semilattice (an ordered set in which every pair of elements has a least upper bound), and any element `a` of `α`, the image of the filter `atTop` (which represents the limit tending to infinity in the ordered set) on the interval `Ici a` (the set of all elements greater than or equal to `a`) under the coercion function `Subtype.val` (which extracts the underlying element from a subtype) is equal to `atTop`. In other words, the filter of all elements above a certain point in a semilattice, when we consider just the underlying elements without the property that makes them a subtype, is still the filter of all elements above that point.

For any semilattice `α` and element `a` in `α`, the image of the filter `atTop` on `Ici a` under `Subtype.val` equals `atTop`. Alternatively, the filter of all elements above `a` in a semilattice, when considered as underlying elements, is still the filter of all elements above `a`.


theorem HomologicalComplex.mkHomFromSingle_f :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] {c : ComplexShape ι}
      {K : HomologicalComplex V c} {j : ι} {A : V} (φ : A ⟶ K.X j)
      (hφ : ∀ (k : ι), c.Rel j k → CategoryTheory.CategoryStruct.comp φ (K.d j k) = 0),
      (HomologicalComplex.mkHomFromSingle φ hφ).f j =
        CategoryTheory.CategoryStruct.comp (HomologicalComplex.singleObjXSelf c j A).hom φ :=
  by sorry

This theorem states that for any category `V` that has zero morphisms and zero objects, given a `HomologicalComplex` `K` indexed by type `ι` with a `ComplexShape` `c`, and an object `j` of type `ι` and another object `A` of the same category `V`, if we have a morphism `φ` from `A` to the `j`-th object of `K`, such that the composition of `φ` with the differential `K.d j k` is zero for any `k` where the relation `c.Rel j k` holds, then the `j`-th morphism of the homological complex constructed from `φ` equals to the composition of the homomorphism from `A` to the `j`-th object in the `HomologicalComplex.singleObjXSelf` (which is a homological complex where all differentials are zero) and `φ`.

If `V` is a zero-object and zero-morphism category, for any homological complex `K` and morphism `φ: A → K.object(j)` such that `K.d j k ∘ φ = 0` for all `k` related to `j` in `K`, then the `j`-th morphism of the complex constructed from `φ` equals to `φ` composed with the identity morphism of `K.object(j)` in the homological complex of a single object `K.object(j)` with itself.


theorem Associated.dvd_iff_dvd_left :
    ∀ {α : Type u_1} [inst : Monoid α] {a b c : α}, Associated a b → (a ∣ c ↔ b ∣ c) := by sorry

The theorem `Associated.dvd_iff_dvd_left` states that for any type `α` that forms a monoid, and any three elements `a`, `b`, and `c` of that monoid, if `a` and `b` are associated (which means there exists a unit `u` for which `a` times `u` equals `b`), then `a` divides `c` if and only if `b` divides `c`. In other words, if `a` and `b` are associated, then `a` and `b` have the same divisibility relation with `c`.

For all monoids types `α` and elements `a, b, c` in `α`, if `a` is associated with `b` (i.e., `a = b * u` for some unit `u`), then `a` divides `c` if and only if `b` divides `c`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.5 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem, under the `Mathlib.Topology.MetricSpace.Infsep._auxLemma.5` namespace, states that for any two propositions `a` and `b`, the existence of `b` under the assumption that `a` is true, is equivalent to `a` and `b` both being true. In other words, "there exists `a` such that `b` is true" is logically equivalent to "`a` and `b` are both true".

The theorem asserts that for any propositions `a` and `b` in Lean's type theory, `∃ (x : Prop), a × b → a ∧ b` holds.


theorem LieSubmodule.iSup_coe_toSubmodule :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] {ι : Sort u_1} (p : ι → LieSubmodule R L M),
      ↑(⨆ i, p i) = ⨆ i, ↑(p i) :=
  by sorry

This theorem states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is also a `R`-module and a `L`-module, for any indexing sort `ι` and any function `p` from `ι` to the set of Lie submodules of `M`, the Lie submodule generated by the union of all `p i` (for all `i` in `ι`) is the same as the union of all Lie submodules `p i`. In simpler terms, the Lie submodule generated by all `p i` is equivalent to the union of all the individual Lie submodules `p i`.

For any commutative ring `R`, Lie ring `L`, additive commutative group `M` (an `R`-module and `L-module`), and indexing sort `ι`, the Lie submodule of `M` generated by the union of Lie submodules `p i` (for all `i` in `ι`) is equal to the union of those submodules themselves.


MeasureTheory.NullMeasurableSet.smul

theorem MeasureTheory.NullMeasurableSet.smul :
    ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
      [inst_2 : MeasurableSpace G] [inst_3 : MeasurableSMul G α] {μ : MeasureTheory.Measure α}
      [inst_4 : MeasureTheory.SMulInvariantMeasure G α μ] {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → ∀ (c : G), MeasureTheory.NullMeasurableSet (c • s) μ :=
  by sorry

The theorem `MeasureTheory.NullMeasurableSet.smul` is a statement about measurable sets in measure theory. It states that for any given type `G` which is a group, type `α`, a measurable space `m` over type `α`, and a measure `μ` that is invariant under scaling by elements of `G`, if a set `s` of type `α` is a null measurable set with respect to `μ`, then for any element `c` of the group `G`, the scaled set `c • s` is also a null measurable set with respect to `μ`. In other words, null-measurable sets remain null-measurable even when scaled by any element of a group.

If `s` is a null measurable set in the measurable space `(α, m)` with respect to the invariant measure `μ` over the group `G`, then for all `c` in `G`, the scaled set `c • s` is also a null measurable set in `(α, m)` with respect to `μ`.


theorem List.nodup_iff_sublist : ∀ {α : Type u} {l : List α}, List.Nodup l ↔ ∀ (a : α), ¬List.Sublist [a, a] l := by
  sorry

This theorem states that for any type `α` and any list `l` of type `α`, the list `l` has no duplicates if and only if for every element `a` of type `α`, it is not the case that the sublist `[a, a]` (i.e., the list with two occurrences of `a`) is a sublist of `l`. In other words, a list has no duplicate elements if there are no elements `a` that appear consecutively in the list.

A list of type `α` has no duplicates if and only if no sublist of length 2 contains an element repeated twice.


theorem UniformSpace.hasBasis_nhds :
    ∀ {α : Type ua} [inst : UniformSpace α] (x : α),
      Filter.HasBasis (nhds x) (fun s => s ∈ uniformity α ∧ SymmetricRel s) fun s => UniformSpace.ball x s :=
  by sorry

This theorem states that for any type `α` that has a `UniformSpace` structure, and any element `x` of type `α`, the neighborhood filter `nhds x` has a basis that is characterized as follows: The basis elements are those sets `s` that are elements of the uniformity `uniformity α` and for which the relation `SymmetricRel s` holds true. Furthermore, for any such set `s`, the corresponding basis element in the filter `nhds x` is the set `UniformSpace.ball x s`, which can be thought of as the 'ball' around `x` with respect to `s`. In other words, this theorem establishes a connection between the concepts of neighborhood filters, uniformity, symmetric relations, and balls in a uniform space.

In a uniform space, the neighborhood filter of a point x is exactly the collection of sets in the uniformity that are symmetric around x and generate the uniform topology through their balls as basis elements.


theorem Cardinal.beth_strictMono : StrictMono Cardinal.beth := by sorry

The theorem `Cardinal.beth_strictMono` asserts that the function `Cardinal.beth` is strictly monotone. This means that for any two ordinals `a` and `b`, if `a` is less than `b`, then `beth a` is less than `beth b`. In other words, as you move to higher ordinals, the corresponding Beth numbers also increase strictly.

For all ordinals `a` and `b` where `a` < `b`, `Cardinal.beth a` < `Cardinal.beth b`.


VAddCommClass.symm

/-- Commutativity of additive actions is a symmetric relation. This lemma can't be an instance
because this would cause a loop in the instance search graph.  -/
theorem VAddCommClass.symm :
    ∀ (M : Type u_10) (N : Type u_11) (α : Type u_12) [inst : VAdd M α] [inst_1 : VAdd N α]
      [inst_2 : VAddCommClass M N α], VAddCommClass N M α :=
  by sorry

This theorem states that the commutativity of additive actions is a symmetric relation. Given three types `M`, `N`, and `α`, if `M` and `α` form an additive action and `N` and `α` form an additive action, and if there is a commutative relation between `M`, `N` and `α`, then the same commutative relation also exists between `N`, `M` and `α`. In simpler terms, if 'adding' elements of type `M` and `N` to an element of type `α` is commutative, then 'adding' elements of type `N` and `M` is also commutative. The theorem cannot be an instance because it would cause a loop in the instance search graph in Lean.

If `M` and `α`, and `N` and `α` form commutative additive actions, then the commutativity of their addition with `α` implies the commutativity of `N` and `M` addition with `α`.


theorem disjoint_left_comm :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α},
      Disjoint a (b ⊓ c) ↔ Disjoint b (a ⊓ c) :=
  by sorry

This theorem states that for any type `α` that is a semilattice with infimum and has a bottom element, and for any three elements `a`, `b`, and `c` of `α`, the statement " `a` is disjoint with the infimum of `b` and `c` " is equivalent to the statement " `b` is disjoint with the infimum of `a` and `c` ". Here, two elements of a lattice are said to be disjoint if their infimum is the bottom element.

For any semilattice `α` with bottom element, elements `a`, `b`, and `c` in `α`, `a` is disjoint with the infimum of `b` and `c` if and only if `b` is disjoint with the infimum of `a` and `c`.


theorem Mathlib.Init.Order.LinearOrder._auxLemma.1 : ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True := by
  sorry

This theorem states that, for any type `α` with a preorder, any element `a` of `α` is less than or equal to itself. In mathematical notation, this is expressing the reflexivity of the order relation: for all `a`, `a ≤ a` is always true.

For any preordered type `α`, every element `a` satisfies `a ≤ a`.


theorem WithBot.add_bot : ∀ {α : Type u} [inst : Add α] (a : WithBot α), a + ⊥ = ⊥ := by sorry

This theorem, `WithBot.add_bot`, states that for any type `α` with an addition operation (`Add α`), if you take an element `a` from the type `α` extended with a `⊥` value (`WithBot α`), then adding this `a` to `⊥` always results in `⊥`. In other words, whenever we add the special `⊥` value to any element in the extended type, the result is always `⊥`. This is similar to the behavior of `NaN` or Not-a-Number in some programming languages, where any arithmetic operation involving `NaN` yields `NaN`.

For any type `α` with addition and any `a ∈ WithBot α`, `a + ⊥ = ⊥`.


theorem Set.sInter_insert : ∀ {α : Type u_1} (s : Set α) (T : Set (Set α)), ⋂₀ insert s T = s ∩ ⋂₀ T := by sorry

The theorem `Set.sInter_insert` states that for any type `α`, any set `s` of type `α`, and any set `T` of sets of type `α`, the intersection over the union of `s` and `T` is equivalent to the intersection of `s` and the intersection over `T`. In other words, if you insert a set `s` into a set `T` of sets and then take the intersection over the resulting set, it's the same as intersecting `s` with the intersection over the original set `T`. This theorem generalizes one of the basic laws of intersection for sets.

For any type `α`, set `s` of type `α`, and set `T` of sets of type `α`, `s ∩ (⋃ ts) = ⋃ (s ∩ ts : _[_] :: _[_] := T)`.


theorem divp_mul_eq_mul_divp : ∀ {α : Type u} [inst : CommMonoid α] (x y : α) (u : αˣ), x /ₚ u * y = x * y /ₚ u := by
  sorry

This theorem, `divp_mul_eq_mul_divp`, states that for any type `α` that is a commutative monoid (i.e., a mathematical structure with a binary operation that is associative, has an identity element, and is commutative), given any two elements `x` and `y` of `α` and a unit `u` of `α`, the operation of dividing `x` by `u` (`x /ₚ u`) and then multiplying by `y` is equivalent to the operation of multiplying `x` and `y` first and then dividing by `u` (`x * y /ₚ u`). Essentially, it's stating a property of distributivity of division over multiplication in a commutative monoid.

For any commutative monoid `α` and elements `x`, `y`, and unit `u` in `α`, `x /ₚ u * y = x * y /ₚ u`.


/-- Finsets form an order-connected suborder of sets.  -/
theorem Finset.ordConnected_range_coe : ∀ {α : Type u_1}, Set.OrdConnected (Set.range Finset.toSet) := by sorry

This theorem asserts that for any given type `α`, the range of the function `Finset.toSet` forms an order-connected suborder of sets. In other words, for any two elements in the set created from a `Finset`, every element that is in-between these two elements (according to the order defined on `α`) is also included in the set. This property is captured by the term `Set.OrdConnected` in Lean. Essentially, it means that finite sets (represented as `Finset` in Lean) preserve the order connectivity when they are converted to sets in Lean (`Set α`).

For any type `α` and `Finset` `s` of elements from `α`, the image of `s` under the function `Finset.toSet` forms an order-connected subset of the power set `Set α`.


theorem LieHom.isIdealMorphism_def :
    ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L'),
      LieHom.IsIdealMorphism f ↔ lieIdealSubalgebra R L' (LieHom.idealRange f) = LieHom.range f :=
  by sorry

The theorem `LieHom.isIdealMorphism_def` says that for any given commutative ring `R`, Lie rings `L` and `L'`, and `L` and `L'` being Lie algebras over the ring `R`, a morphism `f` from `L` to `L'` is an ideal morphism if and only if the ideal of `L'` generated by the image of `f` is equal to the image of `f` as a Lie subalgebra. This equivalence serves as the definition for an ideal morphism in the context of Lie algebras. Here, the image of `f` refers to the set of all elements in `L'` that can be obtained by applying `f` to elements in `L`.

A morphism between two Lie algebras over a commutative ring is an ideal morphism if and only if the image of the morphism generates the same ideal in the target Lie algebra as the image itself.


theorem Ordinal.cof_succ : ∀ (o : Ordinal.{u_2}), Ordinal.cof (Order.succ o) = 1 := by sorry

This theorem states that for every ordinal `o`, the cofinality of the successor of `o` is `1`. In other words, the smallest cardinality of a subset `S` of the successor ordinal such that every element of the successor ordinal is less than or equal to some element of `S`, is `1`. This theorem implies that the successor of any ordinal has a minimal unbounded subset of cardinality `1`.

For every ordinal `o`, the cofinality of `o'` (the successor of `o`) equals 1.


theorem ONote.fundamentalSequence_has_prop :
    ∀ (o : ONote), ONote.FundamentalSequenceProp o (ONote.fundamentalSequence o) := by sorry

This theorem, named `ONote.fundamentalSequence_has_prop`, states that for any ordinal notation `o`, the fundamental sequence of `o` satisfies the fundamental sequence property of `o`. In other words, for every ordinal notation, the fundamental sequence associated with it fulfills the property that the `ONote` class defines as fundamental.

For every ordinal notation `o`, the fundamental sequence of `o` is a sequence that satisfies the fundamental sequence property defined by the `ONote` class.


theorem NormedSpace.isVonNBounded_closedBall :
    ∀ (𝕜 : Type u_1) (E : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (r : ℝ), Bornology.IsVonNBounded 𝕜 (Metric.closedBall 0 r) :=
  by sorry

The theorem `NormedSpace.isVonNBounded_closedBall` states that for any nontrivially normed field `𝕜`, seminormed additive commutative group `E`, normed space over `𝕜` and `E`, and a real number `r`, the closed ball in the metric space centered at zero with radius `r` is von Neumann bounded. In other words, every neighborhood of zero absorbs this closed ball in the given normed space.

In a normed space over a nontrivially normed field, the closed ball centered at the zero point is von Neumann bounded.


theorem Derivation.liftKaehlerDifferential_comp :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {M : Type u_1}
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
      (D : Derivation R S M),
      (LinearMap.compDer (Derivation.liftKaehlerDifferential D)) (KaehlerDifferential.D R S) = D :=
  by sorry

The theorem `Derivation.liftKaehlerDifferential_comp` states that for any given types `R`, `S`, and `M` where `R` and `S` are commutative rings, `S` is an `R`-algebra, and `M` is both an `R`-module and `S`-module forming a scalar tower, if `D` is a derivation from `R` to `S` with values in `M`, then composing `D` with the function `Derivation.liftKaehlerDifferential` and the Kähler differential `KaehlerDifferential.D` from `S` to the Kähler differentials `Ω[S/R]` gives back `D`. In other words, the Kähler differential is universal with respect to `D`, demonstrating its fundamental role in differential geometry and algebra.

Given derivations D from a commutative ring R to an R-algebra S over an R-module M, the composition of D with Derivation.liftKaehlerDifferential and KaehlerDifferential.D equals D.


theorem gc_smul_ceilDiv :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : CeilDiv α β] {a : α},
      0 < a → GaloisConnection (fun x => x ⌈/⌉ a) fun x => a • x :=
  by sorry

The theorem `gc_smul_ceilDiv` states that for any type `α` and `β` that have the structure of an ordered additive commutative monoid, with `α` also having a scalar multiplication by zero structure (`SMulZeroClass`) and `β` having a ceiling division structure (`CeilDiv`), and given any element `a` of type `α` which is greater than zero, a Galois connection exists between the function that maps `x` to the ceiling division of `x` by `a` and the function that maps `x` to the scalar multiple of `a` and `x`.  This means that for all `x` and `y` of type `α` and `β` respectively, `x ⌈/⌉ a ≤ y` if and only if `x ≤ a • y`.

For types `α` and `β` with ordered additive commutative monoid structures, where `α` has a scalar multiplication by zero and `β` has a ceiling division, and for any positive `a` in `α`, there exists a Galois connection between the function mapping `x` to `⌈x/a⌉` and the function mapping `x` to `a • x`. Therefore, `x ⌈/⌉ a ≤ y` if and only if `x ≤ a • y`.


theorem CategoryTheory.Limits.biproduct.lift_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type}
      [inst_2 : Fintype J] {f : J → C} [inst_3 : CategoryTheory.Limits.HasBiproduct f] {T U : C} {g : (j : J) → T ⟶ f j}
      {h : (j : J) → f j ⟶ U},
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.lift g)
          (CategoryTheory.Limits.biproduct.desc h) =
        Finset.sum Finset.univ fun j => CategoryTheory.CategoryStruct.comp (g j) (h j) :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.lift_desc` states that for any category `C` that is also preadditive, and for any finite type `J`, if we have objects and morphisms in `C` given by the functions `f`, `g`, and `h`, then the composition of 'lifting' the `g` morphisms into a biproduct and then 'descending' the `h` morphisms from the biproduct is equal to the sum (over all elements in the universal finite set of `J`) of the individual compositions of the `g` and `h` morphisms. In formal mathematical terms, if we lift `g` to a biproduct and then map this to `U` using `h`, it's the same as if we composed `g` and `h` for each element in `J` and then took their sum. This theorem is essentially a statement about the commutativity of diagrams in a preadditive category.

For any preadditive category `C` and finite type `J`, the composition of lifting morphisms `g` to a biproduct and descending morphisms `h` from the biproduct is equal to the sum of the compositions of `g` and `h` for all elements in `J`.


theorem Inducing.isPreconnected_image :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {f : α → β},
      Inducing f → (IsPreconnected (f '' s) ↔ IsPreconnected s) :=
  by sorry

The theorem `Inducing.isPreconnected_image` states that for any two types `α` and `β` (with `α` and `β` being any mathematical objects such as sets or numbers), both equipped with a topological space structure (a notion of "closeness" or "continuity"), a set `s` of type `α`, and a function `f` from `α` to `β`, if the function `f` induces the topology from `α` to `β` (i.e., the "closeness" structure in `β` is the same as the "closeness" structure in `α` when mapped by `f`), then the image of the set `s` under the function `f` is preconnected (i.e., cannot be split into two non-empty open sets) if and only if the original set `s` is preconnected. In simpler terms, the theorem says that a continuous mapping preserves the property of being preconnected.

If a continuous function preserves the topology between two spaces, then the image of a preconnected set is a preconnected set.


theorem BilinForm.zero_left :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B : BilinForm R M} (x : M), B.bilin 0 x = 0 :=
  by sorry

This theorem states that for any type `R` that is a commutative semiring, any type `M` that is an additive commutative monoid and also a module over `R`, and any bilinear form `B` on `R` and `M`, if you apply the bilinear form to zero and any object from `M`, the result is zero. In other words, the bilinear form, when applied to zero and any other element from `M`, always results in zero. This is a property of bilinear forms, reflecting the linearity in both arguments.

For any commutative semiring R, additive commutative monoid and R-module M, and bilinear form B on R x M, B(0, x) = 0 for all x in M.


theorem FixedPoints.minpoly.eval₂ :
    ∀ (G : Type u) [inst : Group G] (F : Type v) [inst_1 : Field F] [inst_2 : MulSemiringAction G F]
      [inst_3 : Fintype G] (x : F),
      Polynomial.eval₂ (Subring.subtype (FixedPoints.subfield G F).toSubring) x (FixedPoints.minpoly G F x) = 0 :=
  by sorry

The theorem `FixedPoints.minpoly.eval₂` states that for any group `G`, field `F`, and element `x` of `F`, if `G` acts on `F` through a multiplicative semiring action and `G` is finite, then the polynomial obtained by evaluating the minimal polynomial of `x` over the subfield of fixed points by the monoid action of `G` on `F` at `x` using the natural ring homomorphism from the subring of the subfield to the field `F`, is equal to zero. In essence, this theorem is a generalization of the property that the minimal polynomial of an element in a field, when evaluated at this element, is always zero.

For any finite group action on a field through a multiplicative semiring, the minimal polynomial of an element evaluated by the group action at that element is equal to zero.


/-- The angle between the zero vector and a vector.  -/
theorem InnerProductGeometry.angle_zero_left :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x : V),
      InnerProductGeometry.angle 0 x = Real.pi / 2 :=
  by sorry

This theorem states that the angle between the zero vector and any vector `x` in an inner product space over the real numbers is equal to π/2. The mentioned inner product space is assumed to have a structure of a normed commutative additive group. The angle is calculated using the function `InnerProductGeometry.angle`, which is defined as the arccosine of the inner product of the two vectors divided by the product of their norms. In this case, one of the vectors is the zero vector, and the theorem confirms that the angle in this case is always π/2, regardless of the other vector.

In an inner product space over the real numbers with a normed commutative additive group structure, the angle between any vector `x` and the zero vector is π/2.


Specializes.eq

theorem Specializes.eq : ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x y : X}, x ⤳ y → x = y :=
  by sorry

This theorem, referred to as `Specializes.eq`, states that for any type `X` which is a topological space and additionally has the `T1` property (every singleton set is closed), if a point `x` specializes to a point `y` (notation `x ⤳ y`, meaning that every neighborhood of `x` is also a neighborhood of `y`), then `x` must be equal to `y`. This theorem essentially states that in `T1` spaces, the specialization relation is trivial: a point specializes to another if and only if they are the same.

In a T1 topological space `X`, if `x` specializes to `y` (`x ⤳ y`), then `x` equals `y`.


theorem exterior_minimal :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] {s t : Set α}, s ⊆ t → IsOpen t → exterior s ⊆ t := by sorry

The theorem `exterior_minimal` states that for any given type `α` in a topological space, and any two sets `s` and `t` of that type, if `s` is a subset of `t` and `t` is open in the topological space, then the exterior of `s` is a subset of `t`. In other words, the exterior of a set is the smallest open set that contains it. This captures the intuition that the "exterior" of a set includes all points that are not "immediately adjacent" to the set, in the sense of the given topology.

For any topological space and types `α`, if `s` is a subset of open set `t`, then the exterior of `s` is contained in `t`.


theorem Finset.cast_card :
    ∀ {α : Type u_1} {R : Type u_3} [inst : CommSemiring R] (s : Finset α), ↑s.card = Finset.sum s fun a => 1 := by
  sorry

The theorem `Finset.cast_card` states that for any type `α` and a type `R` where `R` is a commutative semiring, for any given finite set `s` of type `α`, the cardinality of `s` (the number of elements in set `s`) is equal to the sum of `1` for each element in `s`. In other words, if you sum up `1` for each element in the finite set `s`, you get the total number of elements in `s`.

For any finite set `s` of type `α` and commutative semiring `R`, the cardinality of `s` equals the sum of `1` for each element in `s` (denoted as the sum of the elements in the set viewed as an `R`-module).


theorem pow_padicValNat_dvd : ∀ {p n : ℕ}, p ^ padicValNat p n ∣ n := by sorry

This theorem states that for any given natural numbers `p` and `n`, the `p` to the power of the `p`-adic valuation of `n` (which we denote as `p` to the power of `padicValNat p n`) is a divisor of `n`. In other words, `n` is divisible by `p` raised to the power of its `p`-adic valuation. In mathematical terms, it's expressed as \(p^{padicValNat\ p\ n} | n\).

For any natural numbers `p` and `n`, `p` raised to the power of the `p`-adic valuation of `n` divides `n`. In other words, `p` to the power of `padicValNat p n` | `n`.


Ordinal.IsNormal.trans

theorem Ordinal.IsNormal.trans :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}} {g : Ordinal.{u_6} → Ordinal.{u_4}},
      Ordinal.IsNormal f → Ordinal.IsNormal g → Ordinal.IsNormal (f ∘ g) :=
  by sorry

The theorem `Ordinal.IsNormal.trans` states that for any two ordinal-valued functions `f` and `g`, if both `f` and `g` are normal, then their composition `(f ∘ g)` is also normal. Here, a normal function is defined as a strictly increasing function which is order-continuous. That is, for a limit ordinal `o`, its image under the function is the supremum of the images of the ordinals less than `o`.

If `f` and `g` are normal ordinal-valued functions, then their composition `(f ∘ g)` is also a normal ordinal-valued function.


theorem Fin.castPred_castSucc :
    ∀ {n : ℕ} {i : Fin n} (h' : optParam (Fin.castSucc i ≠ Fin.last n) ⋯), Fin.castPred (Fin.castSucc i) h' = i := by
  sorry

The theorem `Fin.castPred_castSucc` states that for any natural number `n` and for any `i : Fin n`, provided the optional parameter `h'` which assures that the successor of `i` when casted to `Fin (n + 1)` is not the greatest value of `Fin (n+1)`, casting the successor of `i` to `Fin (n + 1)` and then casting it back to `Fin n` (given that it is not the greatest value of `Fin (n+1)`), you end up with the original `i`. In other words, the operations of casting to successor and then casting to predecessor are inverses of each other under the condition that the value is not the greatest value in `Fin (n+1)`.

For any natural number `n` and `i : Fin n`, if `i + 1` is not the maximum value of `Fin (n + 1)`, then `Fin.castPred (Fin.castSucc i) = i`.


/-- A binary injective function is injective when only the left argument varies.  -/
theorem Function.Injective2.left :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ},
      Function.Injective2 f → ∀ (b : β), Function.Injective fun a => f a b :=
  by sorry

The theorem `Function.Injective2.left` states that for all types `α`, `β`, and `γ`, and for all binary functions `f` from `α` and `β` to `γ`, if `f` is binary injective (meaning that for any pairs of elements `a₁, a₂` in `α` and `b₁, b₂` in `β`, if `f(a₁, b₁)` equals `f(a₂, b₂)`, then `a₁` equals `a₂` and `b₁` equals `b₂`), then for any fixed `b` in `β`, the function that varies only in the `α` element (defined as `a` maps to `f a b`) is also injective (meaning that for any `a₁, a₂` in `α`, if `f(a₁, b)` equals `f(a₂, b)`, then `a₁` equals `a₂`). This theorem essentially establishes that holding one variable constant in a binary injective function results in an injective function of the remaining variable.

If a binary function `f` from `α × β` to `γ` is injective, then for each fixed `b` in `β`, the restriction of `f` to `α` is also injective.


theorem IsAddUnit.add_left_inj :
    ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit a → (b + a = c + a ↔ b = c) := by sorry

The theorem `IsAddUnit.add_left_inj` states that for any type `M` that has an additive monoid structure, and for any elements `a`, `b`, and `c` of type `M`; if `a` is an additive unit (i.e., it has an additive inverse), then the equality `b + a = c + a` is equivalent to `b = c`. This theorem essentially expresses the property of canceling the same additive unit from both sides of an equation in an additive monoid.

In an additive monoid, if an element has an additive inverse, then adding it to both sides of an equation equates two elements if and only if they are equal.


/-- A homomorphism from a group to a monoid is injective iff its kernel is trivial.
For the iff statement on the triviality of the kernel, see `injective_iff_map_eq_one'`.   -/
theorem injective_iff_map_eq_one :
    ∀ {F : Type u_8} {G : Type u_9} {H : Type u_10} [inst : Group G] [inst_1 : MulOneClass H] [inst_2 : FunLike F G H]
      [inst_3 : MonoidHomClass F G H] (f : F), Function.Injective ⇑f ↔ ∀ (a : G), f a = 1 → a = 1 :=
  by sorry

The theorem `injective_iff_map_eq_one` states that for any types `F`, `G`, `H` where `G` is a group, `H` is a MulOneClass (a class that supports multiplication and has a multiplicative identity), `F` is a function-like object from `G` to `H`, and `F` is a homomorphism from the group `G` to the monoid `H`, then a function `f` of type `F` is injective if and only if for all elements `a` in `G`, if `f(a)` equals to the multiplicative identity `1`, then `a` must also be the multiplicative identity `1`. In other words, a homomorphism from a group to a monoid is injective if and only if its kernel is the singleton set containing only the group's identity element.

A homomorphism from a group to a monoid is injective if and only if its kernel consists only of the group's identity element.


theorem Set.range_inclusion : ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t), Set.range (Set.inclusion h) = {x | ↑x ∈ s} :=
  by sorry

This theorem, `Set.range_inclusion`, states that for any type `α` and any sets `s` and `t` of type `α`, if `s` is a subset of `t` (denoted by `s ⊆ t`), then the range of the inclusion function, which maps elements of `s` to `t`, is exactly the set `s`. In other words, the range of the inclusion function consists precisely of those elements that belong to the original subset `s`.

For any type `α` and sets `s` and `t` of type `α` with `s ⊆ t`, the range of the inclusion function from `s` to `t` equals `s`.


/-- A group element has finite additive order iff its order is positive. -/
theorem addOrderOf_pos_iff : ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, 0 < addOrderOf x ↔ IsOfFinAddOrder x := by
  sorry

The theorem `addOrderOf_pos_iff` states that for any element `x` of an additive monoid `G`, `x` has finite additive order if and only if its order is positive. More specifically, there exists a natural number `n` greater than `0` such that `n • x = 0` (indicating finite additive order) if and only if `x` possesses a positive additive order, as captured by the function `addOrderOf x > 0`.

A element `x` in an additive monoid has finite additive order if and only if its positive additive order exists.


theorem Finset.mem_range_iff_mem_finset_range_of_mod_eq' :
    ∀ {α : Type u_1} [inst : DecidableEq α] {f : ℕ → α} {a : α} {n : ℕ},
      0 < n → (∀ (i : ℕ), f (i % n) = f i) → (a ∈ Set.range f ↔ a ∈ Finset.image (fun i => f i) (Finset.range n)) :=
  by sorry

This theorem states that for any type `α` with decidable equality, a function `f` from natural numbers to `α`, an element `a` of `α`, and a natural number `n` larger than 0, if `f` satisfies the property that the value of `f` at `i` is equal to the value of `f` at `i mod n` for every natural number `i`, then `a` is in the range of `f` if and only if `a` is in the image of `f` when applied to the set of natural numbers less than `n`. In other words, when the function `f` has a periodic behavior with period `n`, we can restrict the domain to the first `n` natural numbers without losing any values in the range.

If `f:` ℕ -> α is a function with decidable equality, `a:` α, and `n:` ℕ > 0 such that `f` is periodic with period `n`, then `a` is in the range of `f` if and only if `a` is in the image of `f` restricted to the natural numbers less than `n`.


theorem ENNReal.lt_ofReal_iff_toReal_lt : ∀ {a : ENNReal} {b : ℝ}, a ≠ ⊤ → (a < ENNReal.ofReal b ↔ a.toReal < b) := by
  sorry

This theorem states that for any extended nonnegative real number `a` and any real number `b`, provided that `a` is not infinity, `a` is less than the extended nonnegative real equivalent of `b` if and only if the real equivalent of `a` is less than `b`. In other words, the ordering of these numbers is preserved when transitioning between the domains of real numbers and extended nonnegative real numbers (excluding infinity).

For any real numbers `a` and `b`, and extended non-negative real number `a'`, if `a < b` holds in the real numbers and `a != \infty`, then `a' < b` holds in the extended non-negative real numbers.