/-- The pigeonhole principle for finitely many pigeons counted by heads: given a function between
finite sets `s` and `t` and a number `b` such that `card t • b ≤ card s`, there exists `y ∈ t` such
that its preimage in `s` has at least `b` elements.
See also `Finset.exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to` for a stronger statement.  -/
theorem Finset.exists_le_card_fiber_of_nsmul_le_card_of_maps_to :
    ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β} {b : M}
      [inst_1 : LinearOrderedCommSemiring M],
      (∀ a ∈ s, f a ∈ t) →
        t.Nonempty → t.card • b ≤ ↑s.card → ∃ y ∈ t, b ≤ ↑(Finset.filter (fun x => f x = y) s).card :=
  by sorry

The pigeonhole principle for finite sets is expressed by the theorem `Finset.exists_le_card_fiber_of_nsmul_le_card_of_maps_to`. This theorem states that for any types `α`, `β` and `M` with `β` having decidable equality, and for any finite sets `s` of type `α` and `t` of type `β`, along with a function `f` from `α` to `β` and a number `b` of type `M` with a `LinearOrderedCommSemiring` instance, the following holds: If each element of `s` maps to an element of `t` and `t` is not empty, then if the cardinality of `t` multiplied by `b` is less than or equal to the cardinality of `s`, there exists an element `y` in `t` such that the preimage of `y` in `s` under the function `f` has at least `b` elements. In other words, if we assign to each element of `t` at least `b` elements of `s`, then there must be at least one element in `t` that is assigned at least `b` elements of `s`.

Given finite sets `s` of type `α`, `t` of type `β`, a function `f` from `α` to `β`, and a number `b` in a LinearOrderedCommSemiring, if each element of `s` maps to an element of `t`, `t` is non-empty, and the product of `t`'s cardinality and `b` is less than or equal to `s`'s cardinality, then there exists an element `y` in `t` such that the preimage of `y` under `f` has size greater than or equal to `b`.


theorem Nat.dvd_sub : ∀ {k m n : ℕ}, n ≤ m → k ∣ m → k ∣ n → k ∣ m - n := by sorry

This theorem describes a property of divisibility among natural numbers. Specifically, it states that for any three natural numbers `k`, `m`, and `n`, if `n` is less than or equal to `m`, `k` divides `m` and `k` divides `n`, then `k` also divides the difference `m - n`.

If `k` divides both `m` and `n` (`m ≥ n`), then `k` divides the difference `m - n`. (In mathematical notation: `k` | `m` and `k` | `n` imply `k` | `m - n`.)


theorem Rat.mk_eq_normalize :
    ∀ (num : ℤ) (den : ℕ) (nz : den ≠ 0) (c : Nat.Coprime (Int.natAbs num) den),
      { num := num, den := den, den_nz := nz, reduced := c } = Rat.normalize num den nz :=
  by sorry

This theorem states that for any integer `num` and any natural number `den` that is not zero, if `num` and `den` are coprime (their greatest common divisor is 1), then creating a rational number with `num` as the numerator and `den` as the denominator is equivalent to normalizing the rational number with the same numerator and denominator. In other words, if the absolute value of the numerator and the denominator are coprime, then the rational number is already in its simplest or reduced form, and normalization does not change it.

If `num` and `den` are coprime integers, then the rational number `num / den` is equal to the rational number obtained by normalizing `num` and `den`.


theorem preordToCat.proof_1 : ∀ {X Y : Preord} (f : X ⟶ Y), Monotone ⇑f := by sorry

This theorem states that for every pair of objects `X` and `Y` in the category of preorders (`Preord`), any morphism `f` from `X` to `Y` is monotone. In other words, if `a` and `b` are elements of `X` such that `a` is less than or equal to `b`, then the image of `a` under `f` is less than or equal to the image of `b` under `f`.

For every morphism `f` in the category of preorders `Preord`, if `a ≤ b` in domain `X` of `f`, then `f(a) ≤ f(b)` in the codomain `Y` of `f`.


theorem Mathlib.Data.Fintype.Basic._auxLemma.2 :
    ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ := by sorry

This theorem, `Mathlib.Data.Fintype.Basic._auxLemma.2`, states that for any given type `α` and for any two finite sets `s₁` and `s₂` of this type, `s₁` is equal to `s₂` if and only if for all elements `a` of type `α`, `a` is in `s₁` if and only if `a` is in `s₂`. In other words, two finite sets are equal precisely when they contain exactly the same elements.

Two finite sets of type `α` are equal if and only if they contain the same elements.


theorem DomMulAct.comp_stabilizerEquiv_invFun :
    ∀ {α : Type u_1} {ι : Type u_2} {f : α → ι} (g : (i : ι) → Equiv.Perm { a // f a = i }) (a : α),
      f (DomMulAct.stabilizerEquiv_invFun g a) = f a :=
  by sorry

The theorem `DomMulAct.comp_stabilizerEquiv_invFun` states that for any types `α` and `ι`, and any function `f` from `α` to `ι`, and any function `g` that associates each element `i` of `ι` with a permutation on the subset of `α` that `f` maps to `i`, applying the stabilizer's inverse function `DomMulAct.stabilizerEquiv_invFun` to an element `a` from `α` and then applying `f` to the result is the same as simply applying `f` to `a` directly. In other words, the operation of `DomMulAct.stabilizerEquiv_invFun` preserves the value of `f`.

For any function `f: α → ι` and permutation association `g: ι → Σ (a: α) (i: ι) (f a = i),` applying the inverse stabilizer function `DomMulAct.stabilizerEquiv_invFun` to an element `a` in `α` and then applying `f` is equal to directly applying `f` to `a.` In other words, `DomMulAct.stabilizerEquiv_invFun` preserves the value of `f.`


theorem Mathlib.MeasureTheory.Decomposition.Jordan._auxLemma.2 :
    ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) := by sorry

This theorem, named `Mathlib.MeasureTheory.Decomposition.Jordan._auxLemma.2`, states that for any type `α` that has a subtraction operation (forming a subtraction monoid), for any element `a` of type `α`, the negation of `a` is equal to zero if and only if `a` itself is equal to zero. In other words, in the context of this subtraction monoid, an element is zero if and only if its negative is zero.

For any type `α` with subtraction operation, `a` is equal to zero if and only if the negation of `a` is equal to zero.


theorem Matrix.mulVecLin_mul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_3} {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n]
      [inst_2 : Fintype m] (M : Matrix l m R) (N : Matrix m n R),
      Matrix.mulVecLin (M * N) = Matrix.mulVecLin M ∘ₗ Matrix.mulVecLin N :=
  by sorry

The theorem `Matrix.mulVecLin_mul` states that for any commutative semiring `R` and finite types `l`, `m`, and `n`, given two matrices `M` and `N` with entries in `R`, the multiplication of `M` and `N` followed by applying the linear map `Matrix.mulVecLin` is the same as first applying `Matrix.mulVecLin` to each matrix and then composing the two resulting linear maps. In mathematical terms, it asserts that `(Matrix.mulVecLin (M * N)) = (Matrix.mulVecLin M) ∘ (Matrix.mulVecLin N)`, where `∘` denotes the composition of functions. This theorem is an expression of the associativity property in the context of linear maps and matrix multiplication.

For any commutative semiring R and finite types l, m, and n, the composition of the linear maps obtained by multiplying matrices M and N in Lean 4 and applying Matrix.mulVecLin, is equivalent to first applying Matrix.mulVecLin to each matrix and then composing the resulting linear maps.


/-- The product of `f i` over `i ∈ {a}` equals `f a`.  -/
theorem finprod_mem_singleton :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {a : α},
      (finprod fun i => finprod fun h => f i) = f a :=
  by sorry

The theorem `finprod_mem_singleton` states that for any given types `α` and `M`, where `M` is a commutative monoid, and for any function `f` mapping from `α` to `M`, the product of `f i` over the singleton set `{a}` equals `f a`. In other words, when you apply the `finprod` operation over a singleton set, you essentially get the function value at that single element.

For any commutative monoid M and function f from type α to M, the product of f over the singleton set {a} equals f a.


/-- If `C` is filtered or emtpy, and we have a functor `R : C ⥤ D` with a left adjoint, then `D` is
filtered or empty.
 -/
theorem CategoryTheory.IsFilteredOrEmpty.of_right_adjoint :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFilteredOrEmpty C] {D : Type u₁}
      [inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D},
      (L ⊣ R) → CategoryTheory.IsFilteredOrEmpty D :=
  by sorry

The theorem `CategoryTheory.IsFilteredOrEmpty.of_right_adjoint` states that for any categories `C` and `D`, where `C` is either filtered or empty, if we have a functor `R : C ⥤ D` that has a left adjoint, then the category `D` is also either filtered or empty. In essence, this theorem shows that the property of being filtered or empty is preserved under the existence of a left adjoint.

If `C` is a filtered or empty category and `R : C ⥤ D` has a left adjoint, then `D` is also filtered or empty.


theorem conjugate_nonneg :
    ∀ {R : Type u} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarOrderedRing R] {a : R},
      0 ≤ a → ∀ (c : R), 0 ≤ star c * a * c :=
  by sorry

This theorem, `conjugate_nonneg`, states that for any type `R` that is a non-unital semiring, has a partial order, and is a star-ordered ring, and for any element `a` of `R`, if `a` is non-negative, then for any element `c` of `R`, the value of `star c * a * c` is also non-negative. The `star` function here represents the star operation in star-ordered rings.

In a non-unital semiring `R` with a partial order and star order, if `a` is non-negative and `R` is star-ordered, then `star c * a * c` is non-negative for all `c` in `R`.


theorem Valuation.one_lt_val_iff :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
      (v : Valuation K Γ₀) {x : K}, x ≠ 0 → (1 < v x ↔ v x⁻¹ < 1) :=
  by sorry

This theorem states that for any division ring `K` and any element `x` of `K` that is not zero, along with a valuation `v` from `K` to another type `Γ₀` that is a linearly ordered commutative group with zero, the value `v x` is greater than one if and only if the value `v x⁻¹` is less than one; here `x⁻¹` denotes the multiplicative inverse of `x` in `K`. In other words, this theorem provides a relationship between the valuation of an element and the valuation of its inverse in the context of division rings.

For any division ring `K`, element `x` in `K` not equal to zero, and valuation `v` from `K` to a linearly ordered commutative group with zero `Γ₀`, the elements `x` and `x⁻¹` have opposing valuations, i.e., `v x > 1 <-> v (x⁻¹) < 1`.


/-- Preimage of a set neighborhood of `t` under a continuous map `f` is a set neighborhood of `s`
provided that `f` maps `s` to `t`.   -/
theorem Continuous.tendsto_nhdsSet :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y}
      {t : Set Y}, Continuous f → Set.MapsTo f s t → Filter.Tendsto f (nhdsSet s) (nhdsSet t) :=
  by sorry

This theorem states that for all types `X` and `Y` with topological spaces, and for a set `s` of `X`, a function `f` from `X` to `Y`, and a set `t` of `Y`, if `f` is a continuous function and `f` maps `s` to `t`, then the limit (or the "tendency") of `f` with respect to the neighborhood filter of `s` is less than or equal to the neighborhood filter of `t`. In simpler terms, it means that the preimage of a neighborhood of `t` under a continuous map `f` is a neighborhood of `s` given that `f` maps `s` to `t`. This is a formal way to express a basic principle in topology related to continuous functions and their behavior respect to the concept of neighborhoods.

For continuous functions between topological spaces, if a function maps a set to another set, then the preimage of a neighborhood of the image under the function is a neighborhood of the set in the domain.


theorem continuousAt_zpow₀ :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀] [inst_2 : HasContinuousInv₀ G₀]
      [inst_3 : ContinuousMul G₀] (x : G₀) (m : ℤ), x ≠ 0 ∨ 0 ≤ m → ContinuousAt (fun x => x ^ m) x :=
  by sorry

The theorem `continuousAt_zpow₀` states that for any group with zero `G₀` which is also a topological space, and with continuous inverse zero and continuous multiplication, for any element `x` of this group and any integer `m`, if `x` is not equal to zero or `m` is nonnegative (i.e., `m` is zero or a positive integer), then the function that maps `x` to `x ^ m` is continuous at `x`. In other words, as `x` tends to a particular point in the topological space, `x ^ m` also tends to the corresponding point, preserving the continuity of the power function in this topological group under these conditions.

For any commutative topological group with zero `G₀` endowed with a continuous multiplication and inversores zero, the `m`th power function is continuous on non-zero elements for any non-negative integer `m`.


theorem CliffordAlgebra.contractRight_eq :
    ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (d : Module.Dual R M) (x : CliffordAlgebra Q),
      (CliffordAlgebra.contractRight x) d =
        CliffordAlgebra.reverse ((CliffordAlgebra.contractLeft d) (CliffordAlgebra.reverse x)) :=
  by sorry

This theorem states that for any commutative ring `R`, any `R`-module `M` equipped with a quadratic form `Q`, any dual module `d` of `M`, and any element `x` of the Clifford Algebra constructed from `M` and `Q`, the operation of contracting `x` with `d` on the right is equal to the operation of first reversing `x`, then contracting with `d` on the left, and then reversing the result again. This theorem essentially describes a certain symmetry property of the operations of contraction and reversion in the context of Clifford algebras.

For any commutative ring `R`, any `R`-module `M` with quadratic form `Q`, and any element `x` in the Clifford algebra of `M` and `Q`, contracting `x` with the dual module `d` on the right equals reversing `x`, contracting with `d` on the left, and then reversing the result again.


theorem Cardinal.aleph_zero : Cardinal.aleph 0 = Cardinal.aleph0 := by sorry

The theorem `Cardinal.aleph_zero` states that the cardinality of the set obtained by applying the `aleph` function to 0, often denoted as ℵ₀, is equal to the smallest infinite cardinal, also denoted as ℵ₀. In other words, it asserts that the first infinite cardinal number in the `aleph` series, `Cardinal.aleph 0`, is the same as the smallest infinite cardinal number, `Cardinal.aleph0`.

The theorem `Cardinal.aleph_zero` asserts that the cardinality of the set obtained by applying the `aleph` function to 0 equals the smallest infinite cardinal number, i.e., `Cardinal.aleph 0 = Cardinal.aleph0`.


theorem Nat.nth_of_card_le :
    ∀ {p : ℕ → Prop} (hf : Set.Finite (setOf p)) {n : ℕ}, (Set.Finite.toFinset hf).card ≤ n → Nat.nth p n = 0 := by
  sorry

This theorem states that for any predicate `p` on natural numbers (`ℕ → Prop`), if the set of natural numbers satisfying `p` is finite (represented by the condition `Set.Finite (setOf p)`), then for any natural number `n`, if the cardinality of the finite set is less than or equal to `n` (represented by `(Set.Finite.toFinset hf).card ≤ n`), the `n`-th natural number satisfying `p` is `0`, represented by `Nat.nth p n = 0`. In other words, if you try to enumerate natural numbers satisfying `p` beyond the size of the set, you'll keep getting zeros.

If a predicate `p` on natural numbers defines a finite set and the cardinality of this set is less than or equal to `n`, then the `n`-th natural number satisfying `p` is `0`.


theorem Cardinal.natCast_lt : ∀ {m n : ℕ}, ↑m < ↑n ↔ m < n := by sorry

This theorem, `Cardinal.natCast_lt`, states that for all natural numbers `m` and `n`, the cardinality of `m`, denoted by `↑m`, is less than the cardinality of `n`, denoted by `↑n`, if and only if `m` is less than `n`. In other words, it provides a relationship between the less-than relation `<` on natural numbers and the less-than relation `<` on their corresponding cardinal numbers.

For all natural numbers m and n, `↑m` < `↑n` if and only if m < n.


theorem WithBot.coe_eq_zero : ∀ {α : Type u} [inst : Zero α] {a : α}, ↑a = 0 ↔ a = 0 := by sorry

This theorem states that for any type `α` that has a `Zero` instance, and any instance `a` of that type, the lift of `a` to the type `WithBot α` equals zero if and only if `a` equals zero itself. In other words, an element is equivalent to zero in `WithBot α` (which is `α` along with an additional bottom element) if and only if it is zero in `α`.

For any type `α` with a `Zero` instance and any `a : α`, `lift a to WithBot α = zero (WithBot α) <--> a = zero α`.


theorem Primrec.vector_toList_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {n : ℕ} {f : α → Vector β n},
      (Primrec fun a => Vector.toList (f a)) ↔ Primrec f :=
  by sorry

The theorem `Primrec.vector_toList_iff` states that for any types `α` and `β` that can be encoded as natural numbers (denoted by `Primcodable α` and `Primcodable β`), and any natural number `n`, a function `f` from `α` to vectors of length `n` with elements of type `β` (`α → Vector β n`) is primitive recursive if and only if the function that maps `α` to the list obtained from the vector `f(a)` (`fun a => Vector.toList (f a)`) is primitive recursive. In other words, converting the outputs of a function from vectors to lists does not change whether the function is primitive recursive.

For types `α` and `β` encodable as natural numbers, and natural number `n`, a function `f : α → Vector β n` is primitive recursive if and only if the function `g : α → List β` defined by `g a := Vector.toList (f a)` is primitive recursive.


theorem AffineSubspace.wOppSide_smul_vsub_vadd_left :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {p₁ p₂ : P} (x : P),
      p₁ ∈ s → p₂ ∈ s → ∀ {t : R}, t ≤ 0 → AffineSubspace.WOppSide s (t • (x -ᵥ p₁) +ᵥ p₂) x :=
  by sorry

The theorem `AffineSubspace.wOppSide_smul_vsub_vadd_left` states that for any strict ordered commutative ring `R`, add commutative group `V`, and an affine space `P` over `V`, given an affine subspace `s` of `P`, points `p₁` and `p₂` in `s`, and a point `x` in `P`, if a scalar `t` is less than or equal to zero, then the point obtained by scaling the affine difference of `x` and `p₁` by `t` and then translating by `p₂`, is weakly on the opposite side of subspace `s` relative to `x`. In mathematical terms, the theorem indicates that if `p₁` and `p₂` are points in the subspace, then the point `t • (x - p₁) + p₂` is on the weak opposite side of the subspace from `x` when `t` is less than or equal to zero.

For any affine subspace `s` of an affine space `P` over a commutative ring `R` with identity, points `p₁, p₂ ∈ s`, and `x ∈ P`, if `t ≤ 0` then `t • (x - p₁) + p₂` is weakly opposite to `x` with respect to `s`.


Substring.ValidFor.any

theorem Substring.ValidFor.any :
    ∀ {l m r : List Char} (f : Char → Bool) {s : Substring},
      Substring.ValidFor l m r s → Substring.any s f = List.any m f :=
  by sorry

The theorem `Substring.ValidFor.any` states that for any lists of characters `l`, `m`, `r`, a function `f` from characters to Booleans, and a substring `s` which is valid for these lists, the application of the function `f` if it ever returns `true` for any character in the substring `s` is equivalent to the application of the function `f` if it ever returns `true` for any character in the list `m`. In other words, checking if there's any character in the substring `s` that makes the function `f` return `true` is the same as checking this condition in the list `m` where the substring `s` is valid for `l`, `m`, `r`.

For any lists of characters `l`, `m`, substring `s` valid for `l`, `m`, and function `f` from characters to Booleans, if `s` contains a character making `f` return `true`, then `m` contains such a character.


/-- ε-δ characterization of uniform continuity on pseudoemetric spaces  -/
theorem EMetric.uniformContinuous_iff :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      UniformContinuous f ↔ ∀ ε > 0, ∃ δ > 0, ∀ {a b : α}, edist a b < δ → edist (f a) (f b) < ε :=
  by sorry

This theorem provides an epsilon-delta characterization of uniform continuity for pseudoemetric spaces. For any types `α` and `β` that are pseudoemetric spaces and any function `f` from `α` to `β`, `f` is uniformly continuous if and only if for every `ε` greater than zero, there exists a `δ` greater than zero such that for all `a` and `b` in `α`, if the pseudoemetric distance between `a` and `b` is less than `δ`, then the pseudoemetric distance between `f(a)` and `f(b)` is less than `ε`. This essentially states that if any two points are sufficiently close in the domain space, their images under the function `f` will be sufficiently close in the co-domain space.

A function between two pseudometric spaces is uniformly continuous if and only if for every ε > 0, there exists δ > 0 such that the pseudometric distances d(a, b) < δ implies d(f(a), f(b)) < ε for all a, b in the domain.


theorem Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional._auxLemma.10 :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] (p₁ p₂ : P), Collinear k {p₁, p₂} = True :=
  by sorry

The theorem `Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional._auxLemma.10` states that for any division ring `k`, additively commutative group `V`, torsor `P` over `V`, and any two points `p₁` and `p₂` from `P`, the set containing only `p₁` and `p₂` is collinear. Recall that a set of points is defined to be collinear if the vector span of these points has a dimension at most `1`. In this case, the set of two points always forms a line (or is a point if the two points coincide) and thus is always collinear.

For any division ring `k`, additively commutative group `V`, and torsor `P` over `V`, any two points `p₁` and `p₂` in `P` form a collinear set in the affine space of `P` over `k`.


/-- Reorder a product.

The difference with `Finset.prod_bij` is that the bijection is specified with an inverse, rather
than as a surjective injection.

The difference with `Finset.prod_nbij'` is that the bijection and its inverse are allowed to use
membership of the domains of the products, rather than being non-dependent functions.  -/
theorem Finset.prod_bij' :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
      (hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
      (∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
        (∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) →
          (∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) → (Finset.prod s fun x => f x) = Finset.prod t fun x => g x :=
  by sorry

This theorem, `Finset.prod_bij'`, states that for any two finite sets `s` of type `ι` and `t` of type `κ` and for any two functions `f : ι → α` and `g : κ → α` defined on these sets with values in a commutative monoid `α`, if there exists a pair of functions `i : ι → κ` and `j : κ → ι` that forms a bijection between the sets `s` and `t` (with the property that each function `i` maps elements in `s` to elements in `t` and `j` maps elements in `t` to elements in `s`, and the compositions `j ∘ i` and `i ∘ j` are identity mappings on `s` and `t` respectively), and if `f` and `g` are equivalent under this bijection (meaning that applying `f` to any element `a` of `s` gives the same result as applying `g` to the image of `a` under `i`), then the product of `f` over all elements in `s` is equal to the product of `g` over all elements in `t`. This theorem is useful for switching between different indexes in a product without changing the final result.

If two functions with the same domain and codomain, defined on finite sets with a bijection between them, have equivalent values under this bijection, then their respective products over their respective sets are equal.


theorem IsDedekindDomain.HeightOneSpectrum.valuationOfNeZeroToFun_eq :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type v} [inst_2 : Field K]
      [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (x : Kˣ),
      ↑(IsDedekindDomain.HeightOneSpectrum.valuationOfNeZeroToFun v x) =
        (IsDedekindDomain.HeightOneSpectrum.valuation v) ↑x :=
  by sorry

This theorem states that for any integral domain `R` with the property of being a Dedekind domain, and any field of fractions `K` of `R`, if `v` is a height-one prime ideal spectrum of `R` and `x` is a unit of `K`, then the fraction field extension of the valuation of the non-zero element `x` mapped under `v` is equivalent to the valuation of `v` applied to the unit `x`. This means that the valuation process is consistent whether we consider the element as part of the integral domain or as part of its field of fractions.

For any Dedekind domain `R` and its field of fractions `K`, if `v` is a height-1 prime ideal of `R`, and `x` is a unit in `K` mapping to `v` in `R`, then the valuation of `x` in `K` is equal to the valuation of `v(x)` in `R`.


theorem CauSeq.const_sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] (x y : β), CauSeq.const abv (x - y) = CauSeq.const abv x - CauSeq.const abv y :=
  by sorry

The theorem `CauSeq.const_sub` states that for any types `α` and `β`, where `α` is a linear ordered field and `β` is a ring, and for any absolute value function `abv : β → α`, the Cauchy sequence of the difference of two elements `x` and `y` in `β` (i.e. `CauSeq.const abv (x - y)`) is equal to the difference of the Cauchy sequences of `x` and `y` (i.e. `CauSeq.const abv x - CauSeq.const abv y`). This theorem shows that the constant Cauchy sequence operator distributes over subtraction in the ring `β`.

For any linear ordered field `α` and ring `β` with an absolute value function `abv`, the constant Cauchy sequence of the difference of two elements in `β` is equal to the difference of their constant Cauchy sequences.


theorem CategoryTheory.ShortComplex.SnakeInput.L₀'.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.CategoryStruct.comp S.L₁.f S.L₁.g = CategoryTheory.CategoryStruct.comp 0 S.v₀₁.τ₃ :=
  by sorry

This theorem, named `CategoryTheory.ShortComplex.SnakeInput.L₀'.proof_1`, states that for any type `C` which is a Category and also an Abelian category, given a `SnakeInput` `S` in the category `C`, the composition of the morphisms `f` and `g` of the object `L₁` in the category is equal to the composition of the morphism 0 and the τ₃ component of the object `v₀₁` of `S`. This theorem is a part of the Snake Lemma in Category theory, often used in homological algebra.

For any Abelian category `C` and `SnakeInput` `S` in `C`, the composition of morphisms `f` and `g` of the object `L₁` equals the composition of morphism `0` and the `τ₃` component of `v₀₁` of `S`.


theorem NumberField.InfinitePlace.not_isUnramified_iff :
    ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
      {w : NumberField.InfinitePlace K},
      ¬NumberField.InfinitePlace.IsUnramified k w ↔
        NumberField.InfinitePlace.IsComplex w ∧
          NumberField.InfinitePlace.IsReal (NumberField.InfinitePlace.comap w (algebraMap k K)) :=
  by sorry

The theorem `NumberField.InfinitePlace.not_isUnramified_iff` states that for any field `k`, field extension `K` of `k`, and an infinite place `w` of `K`, the infinite place `w` is not unramified if and only if `w` is a complex place and the restriction of `w` to `k` via the algebra structure is a real place. Here, an infinite place being unramified means that when restricted to the field `k`, the place has the same multiplicity. An infinite place is defined as complex if it's defined by a complex embedding, and as real if it's defined by a real embedding.

For a field extension K of k and an infinite place w of K, w is not unramified if and only if w is a complex place with a real restriction when regarded as an algebra homomorphism from the algebraic closure of k into the completion of K at w.


theorem Num.to_of_nat : ∀ (n : ℕ), ↑↑n = n := by sorry

This theorem states that for every natural number `n`, the double coercion of `n` is equal to `n` itself. Here, coercion is a way in Lean 4 to automatically convert a value from one type to another. So this theorem is essentially saying that converting a natural number to another type (most likely the type of numbers `Num`) and back to a natural number leaves the original number unchanged.

For every natural number `n`, the double application of the coercion from `Nat` to some type `Num` and back to `Nat` results in the original number `n`. In mathematical notation: `coercion (coercion n : Num) = n`.


/-- An equivalence of categories transfers enough injectives.  -/
theorem CategoryTheory.EnoughInjectives.of_equivalence :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.IsEquivalence e] [inst_3 : CategoryTheory.EnoughInjectives D],
      CategoryTheory.EnoughInjectives C :=
  by sorry

This theorem states that if there is an equivalence of categories between two categories C and D, and if D has enough injectives, then C also has enough injectives. Here, "enough injectives" refers to a property of a category such that for any object in the category, there is a monomorphism from that object to some injective object. An "equivalence of categories" is a relationship between two categories that allows us to translate concepts and properties from one category to the other in a way that preserves the essential structure of the categories. The theorem essentially says that if we can translate concepts and properties between two categories and one of them has enough injective objects, then the other one must also have enough injective objects.

If there is an equivalence of categories between C and D and D has enough injectives, then C also has enough injectives.


theorem FirstOrder.Language.LHom.id_onTerm :
    ∀ {L : FirstOrder.Language} {α : Type u'}, FirstOrder.Language.LHom.onTerm (FirstOrder.Language.LHom.id L) = id :=
  by sorry

The theorem `FirstOrder.Language.LHom.id_onTerm` states that for any first-order language `L` and any type `α`, the function `FirstOrder.Language.LHom.onTerm` applied to the identity language homomorphism of `L` is the identity function. In other words, the identity language homomorphism leaves all terms of the language unchanged when applied via the `onTerm` function.

For any first-order language L and type α, the identity language homomorphism's `onTerm` application is the identity function on L's terms.


theorem InitialSeg.map_rel_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {a b : α} (f : r ≼i s),
      s (f a) (f b) ↔ r a b :=
  by sorry

This theorem, `InitialSeg.map_rel_iff`, states that for all types `α` and `β`, and for all relations `r` on `α` and `s` on `β`, and for all elements `a` and `b` of type `α`, if there exists an initial segment `f` from `r` to `s`, then the relation `s` holds between `f(a)` and `f(b)` if and only if the relation `r` holds between `a` and `b`. This essentially says that the initial segment `f` maps the relation `r` onto the relation `s`.

Given types `α` and `β`, relations `r` on `α` and `s` on `β`, and elements `a` and `b` of type `α`, if there exists an initial segment `f` from `r` to `s`, then `r(a, b)` if and only if `s(f(a), f(b))`.


/-- Permuting rows and columns with the same equivalence has no effect.  -/
theorem Matrix.det_submatrix_equiv_self :
    ∀ {m : Type u_1} {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
      [inst_3 : Fintype m] {R : Type v} [inst_4 : CommRing R] (e : n ≃ m) (A : Matrix m m R),
      Matrix.det (Matrix.submatrix A ⇑e ⇑e) = Matrix.det A :=
  by sorry

This theorem states that for any given square matrix `A` with entries in a commutative ring `R`, and for any equivalence between the indices of its rows and columns, the determinant of the submatrix obtained by permuting the rows and columns of `A` according to this equivalence is equal to the determinant of `A` itself. In other words, rearranging the rows and columns of a square matrix in the same manner does not change the determinant of the matrix.

For any square matrix `A` over a commutative ring `R` and any equivalence of its indices, the determinant of the permuted submatrix is equal to the determinant of `A`.


theorem AddMonoidHom.ext_nat : ∀ {A : Type u_3} [inst : AddMonoid A] {f g : ℕ →+ A}, f 1 = g 1 → f = g := by sorry

This theorem states that for any given type `A` that is an additive monoid, and any two additive monoid homomorphisms `f` and `g` from natural numbers to `A`, if `f` and `g` are the same on input `1`, then `f` and `g` are identical functions. This is a statement of the uniqueness of the monoid homomorphisms in this specific setting.

If `A` is an additive monoid and `f` and `g` are additive monoid homomorphisms from the natural numbers to `A` with `f(1) = g(1)`, then `f = g`.


theorem ContinuousLinearMap.opNorm_eq_of_bounds :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} {φ : E →SL[σ₁₂] F} {M : ℝ},
      0 ≤ M → (∀ (x : E), ‖φ x‖ ≤ M * ‖x‖) → (∀ N ≥ 0, (∀ (x : E), ‖φ x‖ ≤ N * ‖x‖) → M ≤ N) → ‖φ‖ = M :=
  by sorry

This theorem states that for any normed add-commutative group `E` and `F` over nontrivially normed fields `𝕜` and `𝕜₂` respectively, and a continuous linear map `φ` from `E` to `F` respecting the linear structures of `𝕜` and `𝕜₂`, if there exists a non-negative real number `M` such that the norm of `φ` applied to any element `x` of `E` is less than or equal to `M` times the norm of `x`, and for any non-negative number `N` such that the norm of `φ` applied to any element `x` of `E` is less than or equal to `N` times the norm of `x`, `M` is less than or equal to `N`, then the operator norm of `φ` is equal to `M`. Essentially, this theorem states the conditions for a continuous linear map to have a specific operator norm.

Given a continuous linear map φ between normed add-commutative groups over nontrivially normed fields, if there exists a constant M such that ||φ(x)|| ≤ M ||x|| for all x and a constant N with the same property where M ≤ N, then the operator norm of φ equals M.


theorem MeasureTheory.prob_compl_eq_zero_iff₀ :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
      [inst : MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → (↑↑μ sᶜ = 0 ↔ ↑↑μ s = 1) :=
  by sorry

The theorem `MeasureTheory.prob_compl_eq_zero_iff₀` states that for any type `α` equipped with a measurable space `m0` and a probability measure `μ`, and for any set `s` of type `α`, given the condition that `s` is a null-measurable set under measure `μ`, the measure of the complement of `s` is zero if and only if the measure of `s` is one. In other words, if we have a probability measure, and `s` is a set that can be approximated by a measurable set up to a set of null measure, then `s` takes up the entire measure (has measure one) precisely when its complement has no measure (has measure zero).

For any measurable set `s` of type `α` in a measurable space `(α, m0)` with probability measure `μ`, `μ(s)^2 + μ(s∘����_* complement)_ = μ(∅)` if and only if `s` has measure one.


theorem disjoint_sup_left :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α},
      Disjoint (a ⊔ b) c ↔ Disjoint a c ∧ Disjoint b c :=
  by sorry

The theorem `disjoint_sup_left` states that for any type `α` that forms a distributive lattice with a least element (`OrderBot`), and for any three elements `a`, `b`, and `c` of this type, `(a ⊔ b)` is disjoint with `c` if and only if `a` is disjoint with `c` and `b` is disjoint with `c`. Here, two elements are considered disjoint if their infimum (greatest lower bound) is the least element of the lattice.

For any distributive lattice with a least element, elements `a`, `b`, and `c` are disjoint if and only if `a` is disjoint with `c` and `b` is disjoint with `c` if and only if their supremum `(a ⊔ b)` is disjoint with `c`.


theorem Multiset.card_erase_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α},
      a ∈ s → Multiset.card (Multiset.erase s a) = Nat.pred (Multiset.card s) :=
  by sorry

The theorem `Multiset.card_erase_of_mem` states that for any type `α` that has decidable equality and any multiset `s` of type `α`, if an element `a` of type `α` is in `s`, then the cardinality (number of elements) of the multiset obtained by erasing `a` from `s` is equal to the predecessor of the cardinality of `s`. In other words, if `a` is in `s`, removing `a` from `s` decreases the size of `s` by one.

If `α` has decidable equality and `a` is in the multiset `s` of type `α`, then `card (s without {a}) = Suc (card s)`.


CompleteLattice.Independent.comp

/-- Composing an independent indexed family with an injective function on the index results in
another indepedendent indexed family.  -/
theorem CompleteLattice.Independent.comp :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_5} {ι' : Sort u_6} {t : ι → α} {f : ι' → ι},
      CompleteLattice.Independent t → Function.Injective f → CompleteLattice.Independent (t ∘ f) :=
  by sorry

The theorem `CompleteLattice.Independent.comp` states that for all types `α` with a complete lattice structure, given any indexed family `t : ι → α`, and any injective function `f : ι' → ι`, if the indexed family `t` is independent, then the composition of `t` and `f`, denoted as `t ∘ f`, also forms an independent indexed family. In other words, composing an independent indexed family with an injective function on the index results in another independent indexed family.

For any complete lattice type `α` and injective function `f`, if `t : ι → α` is an independent indexed family, then `t ∘ f : ι' → α` is also an independent indexed family.


theorem MeasureTheory.AEStronglyMeasurable.nullMeasurableSet_eq_fun :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_5} [inst : TopologicalSpace E]
      [inst_1 : TopologicalSpace.MetrizableSpace E] {f g : α → E},
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.NullMeasurableSet {x | f x = g x} μ :=
  by sorry

This theorem states that for any measure space `α` with a measure `μ`, and any two functions `f` and `g` from `α` to a topological and metrizable space `E`, if both `f` and `g` are almost everywhere strongly measurable with respect to measure `μ`, then the set of points in `α` where `f` equals `g` is a null measurable set with respect to `μ`. In other words, the set of points where `f` and `g` are equal can be approximated by a measurable set up to a set of null measure.

If two almost everywhere strongly measurable functions from a measure space to a topological and metrizable space have the same value almost everywhere, then the set of points where they differ is a null measurable set.


/-- See note [partially-applied ext lemmas].  -/
theorem Monoid.CoprodI.ext_hom :
    ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {N : Type u_3} [inst_1 : Monoid N]
      (f g : Monoid.CoprodI M →* N),
      (∀ (i : ι), MonoidHom.comp f Monoid.CoprodI.of = MonoidHom.comp g Monoid.CoprodI.of) → f = g :=
  by sorry

This theorem states that for any index type `ι`, any family of monoids `M` indexed by `ι`, and any monoid `N`, if we have two monoid homomorphisms `f` and `g` from the free product of the family `M` to `N`, then `f` and `g` are equal if and only if their compositions with the inclusion of every summand into the free product are equal. This theorem allows us to perform an extensionality argument when working with homomorphisms from the free product of a family of monoids.

For any index type `ι`, any family of monoids `M` indexed by `ι`, and any monoids `N` and monoid homomorphisms `f` and `g` from the free product of `M` to `N`, `f` and `g` are equal if and only if their compositions with the inclusion of every summand into the free product are equal.


theorem Set.diff_eq_compl_inter : ∀ {α : Type u} {s t : Set α}, s \ t = tᶜ ∩ s := by sorry

This theorem states that for any two sets `s` and `t` of the same type `α`, the difference of `s` and `t`, denoted by `s \ t`, is equivalent to the intersection of the complement of `t` and `s`. In other words, removing all elements of `t` from `s` is the same as taking the intersection of `s` with all the elements that are not in `t`.

For sets `s` and `t` of type `α` in Lean 4, `s \ t` is equivalent to `s ∩ COMPLEMENT t`.


theorem Ideal.homogeneousCore'_le :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A] (𝒜 : ι → σ) (I : Ideal A),
      Ideal.homogeneousCore' 𝒜 I ≤ I :=
  by sorry

This theorem states that for any type `ι`, any set-like type `σ`, any semiring `A`, any map `𝒜` from `ι` to `σ`, and any ideal `I` in `A`, the 'homogeneous core' of the ideal `I` (as calculated by the function `Ideal.homogeneousCore'`) is a sub-ideal of `I`. In other words, all elements of the 'homogeneous core' of `I` also belong to `I`.

For any semiring `A`, ideal `I`, map `𝒜` from type `ι` to set-like `σ`, the homogeneous core of `I` (as calculated by `Ideal.homogeneousCore'`) is a sub-ideal of `I`.


theorem convex_iInter :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      {ι : Sort u_5} {s : ι → Set E}, (∀ (i : ι), Convex 𝕜 (s i)) → Convex 𝕜 (⋂ i, s i) :=
  by sorry

The theorem `convex_iInter` states that for any ordered semiring `𝕜` and any additive commutative monoid `E` that supports scalar multiplication by `𝕜`, if we have an indexed collection `{s : ι → Set E}` of sets in E (each indexed by a type `ι`), and each of these sets is convex, then the intersection of all these sets is also convex. The convexity of a set here means that for any element `x` in the set, the set is star-convex at `x`.
The concept of "star-convex at `x`" implies that for any point in the set, the entire line segment that connects this point and `x` is contained within the set.

Given an ordered semiring 𝕜 and an additive commutative monoid E with scalar multiplication, if each indexed collection {s : ι → Set E} of convex sets in E is star-convex at each point, then the intersection of all these sets is also star-convex.


theorem HomologicalComplex.homologyι_naturality :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} (φ : K ⟶ L) (i : ι)
      [inst_2 : HomologicalComplex.HasHomology K i] [inst_3 : HomologicalComplex.HasHomology L i],
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap φ i) (HomologicalComplex.homologyι L i) =
        CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyι K i) (HomologicalComplex.opcyclesMap φ i) :=
  by sorry

The theorem `HomologicalComplex.homologyι_naturality` states that for any two homological complexes `K` and `L` in a category `C` with zero morphisms, if `K` and `L` have homology in degree `i`, then the composition of the homology map `φ` from `K` to `L` and the inclusion map of `L` at degree `i` is equal to the composition of the inclusion map of `K` at degree `i` and the map of cycles induced by `φ`. This theorem captures the natural behavior of homology in the context of category theory.

The underlying mathematics involves concepts from algebraic topology and category theory, including homological complexes, homology, and the composition of morphisms in a category.

Given homological complexes K and L in a category with zero morphisms, the inclusion-induced map of i-th homology cycles is equal to the composition of the i-th homology map from K to L and the inclusion map of L.


theorem schwartz_withSeminorms :
    ∀ (𝕜 : Type u_1) (E : Type u_4) (F : Type u_5) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
      [inst_6 : SMulCommClass ℝ 𝕜 F], WithSeminorms (schwartzSeminormFamily 𝕜 E F) :=
  by sorry

This theorem, `schwartz_withSeminorms`, states that for any type `𝕜` that is a normed field, as well as any types `E` and `F` that are both normed vector spaces over ℝ with an additional normed space structure over `𝕜` for `F`, the family of Schwartz seminorms (represented by `schwartzSeminormFamily 𝕜 E F`) satisfies the property of having seminorms. Here, the `WithSeminorms` property is a characteristic of a seminorm family, indicating that it indeed consists of seminorms. The `SMulCommClass ℝ 𝕜 F` instance asserts that scalar multiplication in `F` is commutative when the scalars are real numbers or elements of `𝕜`.

For a normed field `𝕜` and normed vector spaces `E` and `F` over `ℝ` with additional `𝕜`-normed structure on `F`, the family of Schwartz seminorms `schwartzSeminormFamily 𝕜 E F` satisfies the seminorm property and is commutative with respect to scalar multiplication by real numbers or elements of `𝕜` in `F`.


theorem Finset.Ico_insert_right :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] {a b : α} [inst_2 : DecidableEq α],
      a ≤ b → insert b (Finset.Ico a b) = Finset.Icc a b :=
  by sorry

The theorem `Finset.Ico_insert_right` states that for any type `α` equipped with a partial order and a locally finite order, given any two elements `a` and `b` of this type (assuming `α` has decidable equality), if `a` is less than or equal to `b`, then by inserting `b` into the finite set of elements `x` satisfying `a ≤ x` and `x < b`, we get the finite set of elements `x` satisfying `a ≤ x ≤ b`. In other words, adding the upper bound `b` to the half-open interval `[a, b)` yields the closed interval `[a, b]`.

For any locally finite type `α` with decidable equality and partial order, if `a ≤ b` in `α`, then `a ≤ x <= b` for all `x` in the finite set obtained by inserting `b` into the set of elements less than or equal to `a`.


theorem Cubic.map_toPoly :
    ∀ {R : Type u_1} {S : Type u_2} {P : Cubic R} [inst : Semiring R] [inst_1 : Semiring S] {φ : R →+* S},
      Cubic.toPoly (Cubic.map φ P) = Polynomial.map φ (Cubic.toPoly P) :=
  by sorry

The theorem `Cubic.map_toPoly` states that for all semirings `R` and `S`, a cubic polynomial `P` over `R`, and a semiring homomorphism `φ` from `R` to `S`, mapping `P` to `S` using `φ` and then converting to a polynomial is the same as first converting `P` to a polynomial and then mapping the polynomial to `S` using `φ`. In mathematical terms, if we denote the conversion of a cubic polynomial to a polynomial as `Cubic.toPoly` and mapping across a semiring homomorphism as `.map`, we have that `Cubic.toPoly (Cubic.map φ P) = Polynomial.map φ (Cubic.toPoly P)`.

For all semirings R, S, a cubic polynomial P over R, and a semiring homomorphism φ from R to S, the conversion of the map of P under φ to a polynomial in S is equal to the map of the polynomial obtained from converting P to S. That is, (Cubic.map φ (Cubic.toPoly P)) = (Polynomial.map φ (Cubic.toPoly P)).


theorem Valuation.isEquiv_iff_val_le_one :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} {Γ'₀ : Type u_5}
      [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [inst_2 : LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀)
      (v' : Valuation K Γ'₀), Valuation.IsEquiv v v' ↔ ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1 :=
  by sorry

This theorem states that for any division ring `K` and any two types `Γ₀` and `Γ'₀`, both of which are linearly ordered commutative groups with zero, any two valuations `v` and `v'` on `K` with values in `Γ₀` and `Γ'₀` respectively are equivalent if and only if for every element `x` of `K`, `v x ≤ 1` if and only if `v' x ≤ 1`. Here, two valuations are considered equivalent if they induce the same preorder on `K`.

Two valuations on a division ring with values in linearly ordered commutative groups induce the same preorder on the ring if and only if they agree on the value of every element being less than or equal to 1.


theorem not_forall_of_exists_not : ∀ {α : Sort u_1} {p : α → Prop}, (∃ x, ¬p x) → ¬∀ (x : α), p x := by sorry

This theorem states that for any sort `α` and any property `p` pertaining to `α`, if there exists an element of `α` for which the property `p` does not hold, then it is not the case that the property `p` holds for all elements of `α`. Put simply, if there's at least one exception, then we can't say that something is true for everything.

If there exists an element in a sort `α` that does not have property `p`, then `p` does not hold for all elements in `α`.


Asymptotics.IsLittleO.mono

theorem Asymptotics.IsLittleO.mono :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l l' : Filter α}, f =o[l'] g → l ≤ l' → f =o[l] g :=
  by sorry

This theorem, `Asymptotics.IsLittleO.mono`, states that given any two types `α`, `E`, and `F`, where `E` and `F` have a norm, and functions `f : α → E`, `g : α → F`, along with two filters `l` and `l'` over `α`, if `f` is little-o of `g` at filter `l'` (`f =o[l'] g`) and `l` is less than or equal to `l'` (`l ≤ l'`), then `f` is also little-o of `g` at filter `l` (`f =o[l] g`). In big-O notation, if `f(x)` is asymptotically smaller than `g(x)` as `x` approaches a limit under a certain condition (defined by filter `l'`), and if this condition is at least as restrictive as another condition (defined by filter `l`), then `f(x)` is also asymptotically smaller than `g(x)` as `x` approaches the limit under this less restrictive condition.

 If `f =o[l'] g` and `l ≤ l'`, then `f =o[l] g`.

In other words, if `f(x)` is little-o of `g(x)` under filter `l'`, and `l` is less or equal to `l'`, then `f(x)` is also little-o of `g(x)` under filter `l`.


SetCoe.forall'

theorem SetCoe.forall' :
    ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) ↔ ∀ (x : ↑s), p ↑x ⋯ := by
  sorry

This theorem states that for any type `α` and any set `s` of type `α`, a proposition `p` that depends upon an element `x` of `α` and the fact that `x` belongs to `s` holds for all elements `x` of `α` that belong to `s` if and only if it holds for all elements `x` of the coerced set `s`. In other words, it is stating that it is equivalent to consider the proposition `p` for all elements of the set `s` and for all elements of the set when considered as a subset of the type `α`.

For any set `s` of type `α` and proposition `p` depending on an element `x` in `α` and its membership in `s`, `p` holds for all `x` in `s` if and only if it holds for all `x` in the coerced set `s` viewed as a subset of `α`.


theorem Mathlib.MeasureTheory.Constructions.Cylinders._auxLemma.12 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, any set `s` of elements of type `β`, and any element `a` of type `α`, the statement "the element `a` is in the preimage of the set `s` under the function `f`" is equivalent to the statement "the image of `a` under `f` is in the set `s`". In mathematical terms, it says that $a \in f^{-1}(s)$ if and only if $f(a) \in s$.

For any functions $f:\alpha \to \beta$ and sets $s \subseteq \beta$, the elements $a \in \alpha$ and $x \in \beta$ satisfy $a \in f^{-1}(s)$ if and only if $x = f(a) \in s$.


theorem AlgebraicGeometry.PresheafedSpace.GlueData.ι_openEmbedding :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C)
      [inst_1 : CategoryTheory.Limits.HasLimits C] (i : D.J),
      OpenEmbedding ⇑(CategoryTheory.GlueData.ι D.toGlueData i).base :=
  by sorry

This theorem states that for any category `C` and any glue data `D` of presheafed spaces over `C`, if `C` has all small limits, then the base map of the morphism from `D.U i` to `D.glued` given by `CategoryTheory.GlueData.ι D.toGlueData i`, for any `i` in `D.J`, is an open embedding. In the context of algebraic geometry, this means that the inclusion of each open subset into the glued space is an open embedding, which contributes to the local structure of the glued space.

For any category with small limits `C` and glue data `D` of presheafed spaces over `C`, the base map from each open subset `D.Ui` to `D.glued` given by `CategoryTheory.GlueData.ι D.toGlueData i` is an open embedding.


theorem upperBounds_mono_mem :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} ⦃a b : α⦄, a ≤ b → a ∈ upperBounds s → b ∈ upperBounds s := by sorry

The theorem `upperBounds_mono_mem` asserts that for any given type `α` that has a preorder relation and a set `s` of this type, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b` and `a` is an upper bound of `s`, then `b` is also an upper bound of `s`. In other words, if `a` is an element that is greater than or equal to every element in `s` and `b` is greater than or equal to `a`, then `b` must also be greater than or equal to every element in `s`.

If `a` is an upper bound of a preordered set `s` and `a` is less than or equal to `b`, then `b` is also an upper bound of `s`.


theorem Ordinal.add_isLimit : ∀ (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}, Ordinal.IsLimit b → Ordinal.IsLimit (a + b) :=
  by sorry

The theorem `Ordinal.add_isLimit` states that for any ordinal `a` and any ordinal `b` that is a limit ordinal, the sum of `a` and `b` is also a limit ordinal. In other words, if `b` is an ordinal such that it is not zero and not a successor, then the ordinal resulting from the addition of `a` and `b` also shares these properties.

If `a` is an ordinal and `b` is a limit ordinal, then `a + b` is a limit ordinal.


CircleIntegrable.out

/-- The function we actually integrate over `[0, 2π]` in the definition of `circleIntegral` is
integrable.  -/
theorem CircleIntegrable.out :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℂ → E} {c : ℂ} {R : ℝ} [inst_1 : NormedSpace ℂ E],
      CircleIntegrable f c R →
        IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) MeasureTheory.volume 0
          (2 * Real.pi) :=
  by sorry

This theorem states that for any function `f` from complex numbers to a normed addition group `E`, given a complex number `c` and a real number `R`, if `f` is circle integrable - which means that it can be integrated over a circle in the complex plane with center `c` and radius `R` - then the function that we actually integrate over the interval `[0, 2π]` in the definition of `circleIntegral` is interval integrable. Specifically, this function is the derivative of the `circleMap` (which maps a given angle to a point on the circle) at each angle `θ`, scaled by the function `f` evaluated at the point on the circle corresponding to `θ`. Here, "interval integrable" means that this function is integrable over the intervals `(0, 2π]` and `(2π, 0]` with respect to the Lebesgue measure, where the latter interval is always empty, so it's equivalent to being integrable over `(0, 2π]`.

If a complex-valued function `f` is circle integrable over a circle in the complex plane with center `c` and radius `R`, then the derivative of the `circleMap` scaled by `f` is interval integrable over `[0, 2π]` with respect to the Lebesgue measure.


theorem MeasureTheory.VectorMeasure.restrict_zero :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
      {i : Set α}, MeasureTheory.VectorMeasure.restrict 0 i = 0 :=
  by sorry

This theorem states that for any measurable space `α`, any type `M` with an additive commutative monoid structure and a topology, and any set `i` of `α`, the restriction of the zero vector measure to the set `i` is the zero vector measure. In simple terms, if we take a vector measure that assigns zero to every set and restrict it to a particular set, we still get a vector measure that assigns zero to every subset.

For any measurable space `α`, any additive commutative monoid `M` with a topology, and any set `i` in `α`, the restriction of the zero vector measure on `M` to `i` is the zero vector measure on `i`.


theorem Equiv.forall_congr_left' :
    ∀ {α : Sort u} {β : Sort v} {p : α → Prop} (f : α ≃ β), (∀ (x : α), p x) ↔ ∀ (y : β), p (f.symm y) := by sorry

This theorem states that, for any two types `α` and `β`, and for any property `p` applying to elements of `α`, if there is an equivalence `f` between `α` and `β`, then "for all `x` in `α`, `p x` holds" if and only if "for all `y` in `β`, `p (f.symm y)` holds". In other words, the truth of a property for all elements in one type is equivalent to the truth of the same property for all elements in the other type under the inverse of the equivalence function.

For any equivalence between types `α` and `β` and property `p` on `α`, `∀ x ∈ α, p x ↔ ∀ y ∈ β, p (f.symm y)`, where `f` is the equivalence function.


theorem Multiset.powersetAux_perm_powersetAux' :
    ∀ {α : Type u_1} {l : List α}, List.Perm (Multiset.powersetAux l) (Multiset.powersetAux' l) := by sorry

The theorem `Multiset.powersetAux_perm_powersetAux'` asserts that for any type `α` and any list `l` of elements of type `α`, the list of multisets derived from the sublists of `l` by function `Multiset.powersetAux` is a permutation of the list of multisets derived by function `Multiset.powersetAux'`. In other words, both functions `Multiset.powersetAux` and `Multiset.powersetAux'` generate the same set of sub-multisets, possibly in different orders.

The multisets derived from sublists of a list `α` using `Multiset.powersetAux` and `Multiset.powersetAux'` are permutations of each other.


theorem Finset.esymm_map_val :
    ∀ {R : Type u_1} [inst : CommSemiring R] {σ : Type u_2} (f : σ → R) (s : Finset σ) (n : ℕ),
      Multiset.esymm (Multiset.map f s.val) n = Finset.sum (Finset.powersetCard n s) fun t => Finset.prod t f :=
  by sorry

The theorem `Finset.esymm_map_val` states that for any type `R` equipped with a commutative semiring structure, a function `f` from type `σ` to `R`, a finite set `s` of elements of type `σ`, and a natural number `n`, the `n`th elementary symmetric function evaluated at the elements of the multiset obtained by mapping `f` over the elements of `s` is equal to the sum, over all subsets of `s` of cardinality `n`, of the product of the function `f` applied to the elements of each subset. In other words, it links elementary symmetric functions with a sum of products over subsets of a fixed cardinality.

For any commutative semiring `R`, function `f` from type `σ` to `R`, finite set `s` of elements of type `σ`, and natural number `n`, the `n`th elementary symmetric function of the multiset obtained by mapping `f` over the elements of `s` equals the sum of products of `f` applied to subsets of `s` of size `n`.


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

This theorem states that a product of a rational number `q` and a real number `x` is irrational if and only if `q` is not equal to zero, and `x` is irrational. In other words, it asserts the equivalence between two conditions: (1) the multiplication of a rational number with a real number resulting in an irrational number, and (2) the rational number being non-zero and the real number being irrational.

A rational number times a real number is irrational if and only if the rational number is non-zero and the real number is irrational.


/-- **Alias** of `Nat.succ_le_of_lt`. -/
theorem LT.lt.nat_succ_le : ∀ {n m : ℕ}, n < m → Nat.succ n ≤ m := by sorry

This theorem, `LT.lt.nat_succ_le`, is an alias for `Nat.succ_le_of_lt`. It states that for any two natural numbers `n` and `m`, if `n` is less than `m`, then the successor of `n` (which is `n` plus 1, denoted as `Nat.succ n` in Lean 4) is less than or equal to `m`.

If `n` is less than `m` in the natural numbers, then `Nat.succ n` is less than or equal to `m`.


theorem Asymptotics.isBigO_abs_left :
    ∀ {α : Type u_1} {F : Type u_4} [inst : Norm F] {g : α → F} {l : Filter α} {u : α → ℝ},
      (fun x => |u x|) =O[l] g ↔ u =O[l] g :=
  by sorry

This theorem states that for any type `α`, any normed type `F`, any function `g : α → F`, any filter `l : Filter α`, and any function `u : α → ℝ`, the absolute value function of `u` is a big-O of `g` with respect to the filter `l` if and only if `u` itself is a big-O of `g` with respect to the same filter. In mathematical terms, we say that |u(x)| = O(g(x)) if and only if u(x) = O(g(x)), where the big-O notation represents the Asymptotic upper bound.

For any type `α`, normed type `F`, function `g : α → F`, filter `l : Filter α`, and function `u : α → ℝ`, the absolute value of `u` is a big-O of `g` with respect to `l` if and only if `u` itself is a big-O of `g` with respect to `l`. In other words, |u(x)| = O(g(x)) if and only if u(x) = O(g(x)).


/-- Any power of the exponential characteristic is positive.  -/
theorem expChar_pow_pos : ∀ (R : Type u) [inst : Semiring R] (q : ℕ) [inst : ExpChar R q] (n : ℕ), 0 < q ^ n := by sorry

This theorem states that any power of the exponential characteristic is positive. Given a semiring `R` and a natural number `q` which is the exponential characteristic of `R`, for any natural number `n`, the `n`th power of `q` is greater than zero. In mathematical terms, this can be written as $0 < q^n$ for all natural numbers `n`. Please note that this theorem holds true under the condition that `R` is a semiring and `q` is its exponential characteristic.

For any semiring `R` and its exponential characteristic `q`, $0 < q^n$ for all natural numbers `n`.


theorem Equiv.Perm.sameCycle_zpow_right :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ},
      Equiv.Perm.SameCycle f x ((f ^ n) y) ↔ Equiv.Perm.SameCycle f x y :=
  by sorry

The theorem `Equiv.Perm.sameCycle_zpow_right` states that for any type `α`, any permutation `f` of `α`, and any elements `x`, `y` of `α`, and any integer `n`, `x` and `(f^n) y` are in the same cycle of the permutation `f` if and only if `x` and `y` are in the same cycle of the permutation `f`. Here, `(f^n) y` represents the result of applying the permutation `f` `n` times to `y`.

For all types α, permutations f on α, elements x, y of α, and integers n, x and y are in the same cycle of f if and only if x and (fn) y are.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.2 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) := by sorry

This theorem states that for any type `α` that has a partial ordering and an identified top element (`⊤`), for any element `a` of type `α`, `a` being less than the top element (`⊤`) is equivalent to `a` not being equal to the top element (`⊤`). This is applicable in contexts, such as measure theory, where the top element represents an "infinite" or "maximum" value.

For any type `α` with a partial ordering and top element `⊤`, `a < ⊤` if and only if `a ≠ ⊤`.


theorem ContinuousAffineMap.coe_smul :
    ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
      [inst_6 : Module R W] {S : Type u_8} [inst_7 : TopologicalSpace W] [inst_8 : Monoid S]
      [inst_9 : DistribMulAction S W] [inst_10 : SMulCommClass R S W] [inst_11 : ContinuousConstSMul S W] (t : S)
      (f : P →A[R] W), ⇑(t • f) = t • ⇑f :=
  by sorry

The theorem `ContinuousAffineMap.coe_smul` states that for any ring `R`, additive commutative groups `V` and `W`, a module `V` over `R`, a topological space `P` with `V` as its torsor, a monoid `S`, and a continuous multiplication operation `S` on `W` that commutes with `R`, when you scale a continuous affine map `f` from `P` to `W` by a scalar `t` from `S`, applying this scaled map is the same as scaling the result of applying `f`. In equation form, it can be represented as `⇑(t • f) = t • ⇑f`. This theorem is about the interaction of continuous affine maps with scalar multiplication.

For any continuous affine map from a torsor to a module over a ring, and any scalar in the monoid with commuting continuous multiplication on the module, the application of the scaled map is equal to scaling the result of applying the map.


theorem Metric.emetric_ball_top : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), EMetric.ball x ⊤ = Set.univ := by
  sorry

The theorem `Metric.emetric_ball_top` states that for any type `α` that is a PseudoMetricSpace and any point `x` of type `α`, the extended metric ball with center `x` and radius `∞` (represented by `EMetric.ball x ⊤`) is equal to the universal set (`Set.univ`). In other words, the set of all points whose extended distance from `x` is less than infinity includes every point in the space, i.e., it is the universal set.

For any PseudoMetricSpace `α` and point `x` in `α`, the extended metric ball `EMetric.ball x ⊤` equals the universal set `Set.univ`. In other words, every point in `α` is within infinite distance from `x`.


theorem Cardinal.beth_zero : Cardinal.beth 0 = Cardinal.aleph0 := by sorry

The theorem `Cardinal.beth_zero` states that the Beth number at ordinal 0 is equal to `ℵ₀`, which is the smallest infinite cardinal. In other words, `beth 0` corresponds to the cardinality of the natural numbers, according to the definition of Beth numbers in set theory.

The theorem asserts that the Beth number at ordinal 0 equals the smallest infinite cardinal `ℵ₀`, representing the cardinality of the natural numbers.


/-- The minimum of the valuations of `q` and `r` is at most the valuation of `q + r`.  -/
theorem padicValRat.min_le_padicValRat_add :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ},
      q + r ≠ 0 → min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r) :=
  by sorry

The theorem `padicValRat.min_le_padicValRat_add` states that for any prime number `p` and any two rational numbers `q` and `r` such that their sum is not zero, the minimum of the p-adic valuations of `q` and `r` is less than or equal to the p-adic valuation of their sum. The p-adic valuation of a rational number is calculated as the valuation of its numerator minus the valuation of its denominator. In this context, valuation refers to the exponent of the prime `p` in the prime factorization of the number.

For any prime number p and rational numbers q and r with non-zero sum, the p-adic valuation of q + r is less than or equal to the minimum of the p-adic valuations of q and r.


theorem ENNReal.some_eq_coe : ∀ (a : NNReal), some a = ↑a := by sorry

This theorem states that for every nonnegative real number `a` (designated by `NNReal`), applying the `some` function to `a` gives the same result as applying the type coercion function (denoted by the up-arrow operator `↑`) to `a`. In other words, the `some` function and the type coercion function act equivalently on the set of nonnegative real numbers.

For every non-negative real number `a`, `some a` is equal to the real number `↑a`.


/-- The pushforward of a sheaf (by a continuous map) is a sheaf.
 -/
theorem TopCat.Sheaf.pushforward_sheaf_of_sheaf :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y) {F : TopCat.Presheaf C X},
      TopCat.Presheaf.IsSheaf F → TopCat.Presheaf.IsSheaf (f _* F) :=
  by sorry

This theorem states that the pushforward of a sheaf by a continuous map results in a sheaf. More specifically, for any category `C`, and for any topological spaces `X` and `Y` in the category of topological spaces `TopCat`, if there is a morphism `f` from `X` to `Y`, and `F` is a `C`-valued presheaf on `X` that is a sheaf, then the pushforward of `F` by `f` is also a sheaf. Here, a "sheaf" is a tool in topology and algebraic geometry that systematically tracks locally defined data attached to the open sets of a topological space. Meanwhile, "pushforward" is a way of transforming sheaves along a continuous map between topological spaces.

Given a continuous map `f` between topological spaces `X` and `Y`, and a `C`-valued presheaf `F` on `X` that is a sheaf, the pushforward `f_!*F` of `F` is also a sheaf on `Y`.


/-- **Alias** of the reverse direction of `Asymptotics.isTheta_const_mul_left`. -/
theorem Asymptotics.IsTheta.const_mul_left :
    ∀ {α : Type u_1} {F : Type u_4} {𝕜 : Type u_14} [inst : Norm F] [inst_1 : NormedField 𝕜] {g : α → F} {l : Filter α}
      {c : 𝕜} {f : α → 𝕜}, c ≠ 0 → f =Θ[l] g → (fun x => c * f x) =Θ[l] g :=
  by sorry

This theorem, `Asymptotics.IsTheta.const_mul_left`, is an alias of the reverse direction of `Asymptotics.isTheta_const_mul_left`. It states that for any types `α`, `F`, and `𝕜`, in which `F` is a norm and `𝕜` is a normed field, along with a function `g` from `α` to `F`, a filter `l` on `α`, a constant `c` of type `𝕜`, and a function `f` from `α` to `𝕜` such that `c` is not zero and `f` is Theta-equivalent to `g` with respect to filter `l`, the function that maps each `x` in `α` to `c * f(x)` is also Theta-equivalent to `g` with respect to the same filter `l`. In other words, if `f` and `g` grow at the same rate, then scaling `f` by a nonzero constant `c` does not change its growth rate relative to `g`.

If `f : α -> 𝕜` is Theta-equivalent to `g : α -> F` with respect to filter `l` on `α`, then `c * f` is Theta-equivalent to `g` with respect to `l` for any constant `c` in the normed field `𝕜` not equal to zero.


theorem indicator_ae_eq_restrict :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
      [inst_1 : Zero β], MeasurableSet s → Set.indicator s f =ᶠ[MeasureTheory.Measure.ae (μ.restrict s)] f :=
  by sorry

The theorem `indicator_ae_eq_restrict` states that for any types `α` and `β`, any measurable space `α`, any measure `μ` on `α`, any set `s` of `α`, and any function `f` from `α` to `β`, given `β` has a zero, if `s` is a measurable set, then almost everywhere (with respect to the measure `μ` restricted to `s`) the indicator function of `s` with respect to `f` is equal to `f`. In other words, for almost all elements in the set `s`, applying the indicator function gives the same result as just applying the function `f`.

For any measurable spaces `α` and `β`, measures `μ` on `α`, sets `s` of `α`, and functions `f: α → β` with `β` having a zero, if `s` is measurable, then almost everywhere on `s`, the indicator function of `s` and `f` agree: `1_[s] = f`.


theorem isOpenMap_smul :
    ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : Group G] [inst_2 : MulAction G α]
      [inst_3 : ContinuousConstSMul G α] (c : G), IsOpenMap fun x => c • x :=
  by sorry

The theorem `isOpenMap_smul` states that for any type `α` which is a topological space, any type `G` which is a group, and any instance where `G` acts on `α` multiplicatively (`MulAction G α`), and the scalar multiplication operation is continuous (`ContinuousConstSMul G α`), then for any element `c` in `G`, the map that takes an element `x` in `α` and maps it to the result of the scalar multiplication of `c` and `x` (`c • x`) is an open map. In other words, the image of any open set in `α` under this map is an open set. The theorem ensures that the scalar multiplication operation will preserve the topological structure, specifically open sets, in the context of group actions.

For any topological space α, group G with a multiplicative action on α, and a continuous scalar multiplication on G acting on α, the scalar multiplication map is an open map.


theorem Set.pairwise_singleton : ∀ {α : Type u_1} (a : α) (r : α → α → Prop), Set.Pairwise {a} r := by sorry

The theorem `Set.pairwise_singleton` states that for any type `α`, any element `a` of type `α`, and any binary relation `r` defined on `α`, the relation `r` holds pairwise on the singleton set `{a}`. In more detail, this means that for all distinct elements `x` and `y` from the singleton set `{a}`, `r x y` is true. However, since a singleton set has only one element, there are no distinct elements, so the condition is trivially satisfied.

For any type `α`, any element `a` of type `α`, and any binary relation `r` on `α`, `r` holds between every pair of distinct elements in the singleton set `{a}`. (However, since a singleton set has only one element, this condition is vacuously satisfied.)


theorem CategoryTheory.Limits.MonoFactorisation.fac_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      (self : CategoryTheory.Limits.MonoFactorisation f) {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.e (CategoryTheory.CategoryStruct.comp self.m h) =
        CategoryTheory.CategoryStruct.comp f h :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y`, and a morphism `f` from `X` to `Y`, if we have a monomorphism factorisation `self` of `f`, and a morphism `h` from `Y` to some other object `Z`, then composing the morphism `e` from the factorisation with the composition of the monomorphism `m` from the factorisation and `h`, is the same as composing `f` with `h`. In terms of category theory, this can be written as `e ∘ (m ∘ h) = f ∘ h`. This theorem essentially ensures that the factorisation respects the structure of the category.

Given any category `C`, for any morphism `f: X → Y`, monomorphism factorization `m �circ e = 1��ource X ∘ f = 1��ource Y ∘ f ∘ h = m ∘ (h)`, where `m` and `e` are the monomorphism and epimorphism parts of the factorization respectively, and `h: Y → Z` is any morphism, the diagram commutes.