theorem MeasureTheory.AEEqFun.comp_toGerm :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β),
      MeasureTheory.AEEqFun.toGerm (MeasureTheory.AEEqFun.comp g hg f) =
        Filter.Germ.map g (MeasureTheory.AEEqFun.toGerm f) :=
  by sorry

The theorem `MeasureTheory.AEEqFun.comp_toGerm` states that for any measurable space `α`, measure `μ` on `α`, topological spaces `β` and `γ`, a continuous function `g` from `β` to `γ`, and a function `f` from `α` to `β` that is almost everywhere strongly measurable with respect to `μ`, the germ (i.e., equivalence class of functions that are equal almost everywhere) of the composition of `g` and `f` (with the continuity of `g` taken into consideration) is equal to the result of mapping `g` over the germ of `f`.

In other words, we can lift the function `g` to the level of germs, and this operation commutes with the process of turning a function into its germ under almost everywhere equality.

The theorem asserts that for measurable spaces `α`, `μ`, topological spaces `β` and `γ`, a continuous function `g` from `β` to `γ`, and a strongly measurable `f` from `α` to `β` almost everywhere, the germ of `g ∘ f` equals the germ of `g` applied to the germ of `f`.


theorem Multiset.mem_attach : ∀ {α : Type u_1} (s : Multiset α) (x : { x // x ∈ s }), x ∈ Multiset.attach s := by sorry

This theorem, `Multiset.mem_attach`, states that for any type `α` and any multiset `s` of this type, any element `x` of the type `{ x // x ∈ s }` (which denotes elements `x` such that `x` belongs to `s` along with a proof of this property), `x` is a member of the multiset obtained by attaching the proofs to the elements of `s` using the `Multiset.attach` function. Essentially, this theorem ensures that any element `x` that comes with a proof of membership in `s` is indeed found in the multiset resulting from the `Multiset.attach` operation applied to `s`.

For any type `α` and multiset `s` of `α`, if `x ∈ s` then `x` is an element of the multiset obtained by attaching proofs to `s` using `Multiset.attach`.


theorem RatFunc.num_div :
    ∀ {K : Type u} [inst : Field K] (p q : Polynomial K),
      RatFunc.num ((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) =
        Polynomial.C (Polynomial.leadingCoeff (q / gcd p q))⁻¹ * (p / gcd p q) :=
  by sorry

This theorem states that for any field `K` and any two polynomials `p` and `q` over `K`, the numerator of the rational function obtained by dividing the algebraic map of `p` by the algebraic map of `q` is equal to the constant polynomial of the inverse of the leading coefficient of the polynomial obtained by dividing `q` by the greatest common divisor of `p` and `q` multiplied by the polynomial obtained by dividing `p` by the greatest common divisor of `p` and `q`. In other words, this theorem provides a formula to compute the numerator of the rational function corresponding to the fraction of two polynomials in terms of the constant polynomial, the leading coefficient, and the greatest common divisor.

For polynomials `p` and `q` over a field `K`, the numerator of `p / q` is `(lc(gcd(p, q)).inv * (p / gcd(p, q)))`, where `lc` denotes the leading coefficient and `inv` the multiplicative inverse.


theorem Order.pred_lt_iff_of_not_isMin :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, ¬IsMin a → (Order.pred a < b ↔ a ≤ b) := by
  sorry

The theorem `Order.pred_lt_iff_of_not_isMin` states that for any preorder type `α` with a defined predecessor order, and for any elements `a` and `b` of type `α`, if `a` is not a minimal element in `α`, then the predecessor of `a` is less than `b` if and only if `a` is less than or equal to `b`. Here, a minimal element is an element for which no other element is strictly less than it.

For any preorder type `α` with a defined predecessor order, and any elements `a` and `b` of type `α`, if `a` is not minimal in `α`, then `a.predecessor < b` if and only if `a <= b`.


theorem Int.even_iff : ∀ {n : ℤ}, Even n ↔ n % 2 = 0 := by sorry

This theorem states that for any integer `n`, `n` is even if and only if `n` modulo 2 equals 0. In other words, an integer `n` satisfies the property `Even`--meaning there exists some other integer `r` such that `n = r + r`--if and only if the remainder when `n` is divided by 2 is 0. This is a formalization of the usual mathematical definition of even numbers in the integers.

An integer `n` is even if and only if `n` modulo 2 equals 0.


theorem map_ne_zero :
    ∀ {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [inst : MonoidWithZero M₀] [inst_1 : GroupWithZero G₀]
      [inst_2 : Nontrivial M₀] [inst_3 : FunLike F G₀ M₀] [inst_4 : MonoidWithZeroHomClass F G₀ M₀] (f : F) {a : G₀},
      f a ≠ 0 ↔ a ≠ 0 :=
  by sorry

The theorem `map_ne_zero` states that for any types `M₀`, `G₀`, and `F` where `M₀` is a monoid with zero, `G₀` is a group with zero, and `M₀` is nontrivial (i.e., it has at least two distinct elements). If `F` is a type that behaves like a function from `G₀` to `M₀` (expressed by `FunLike F G₀ M₀`) and there exists a structure of a monoid with zero homomorphism from `G₀` to `M₀` over `F` (expressed by `MonoidWithZeroHomClass F G₀ M₀`), then for any function `f : F` and any element `a : G₀`, `f a` is nonzero if and only if `a` is nonzero. In other words, the function `f` will map nonzero elements of `G₀` to nonzero elements of `M₀` and zero elements to zero.

If `F` is a function from a group `G₀` to a monoid `M₀` with zero, with a monoid homomorphism structure, then `F(a)` is nonzero if and only if `a` is nonzero.


theorem MeasureTheory.Measure.haar.index_pos :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalGroup G]
      (K : TopologicalSpace.PositiveCompacts G) {V : Set G},
      Set.Nonempty (interior V) → 0 < MeasureTheory.Measure.haar.index (↑K) V :=
  by sorry

The theorem `MeasureTheory.Measure.haar.index_pos` states that for any topological group `G`, given a nonempty compact subset `K` of `G` and any set `V` whose interior is non-empty, the Haar index of `K` with respect to `V` is positive. The Haar index, denoted `(K : V)`, is the smallest number of translations of `V` necessary to cover `K`. In this context, a group is a mathematical structure that combines an associative operation and an identity element with the ability to find an inverse for every element, and a topological group is a group that is also a topological space in a way such that the group's operations are continuous functions.

For any topological group `G`, the Haar index of a nonempty compact subset `K` with respect to an open set `V` of `G` is a positive number.


HasFDerivWithinAt.mono

theorem HasFDerivWithinAt.mono :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s t : Set E}, HasFDerivWithinAt f f' t x → s ⊆ t → HasFDerivWithinAt f f' s x :=
  by sorry

This theorem, named `HasFDerivWithinAt.mono`, states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` of `E` and `F`, if a function `f` from `E` to `F` has a Fréchet derivative `f'` at a point `x` within a set `t`, then `f` also has a Fréchet derivative `f'` at the point `x` within any subset `s` of `t`. In mathematical terms, if $f$ has a Fréchet derivative $f'$ at $x$ within a set $t$, then it also has this derivative at $x$ within any subset $s$ of $t$.

If a function between normed spaces has a Fréchet derivative at a point within a set, then it also has that derivative at the point within any smaller set.


theorem CategoryTheory.Limits.imageSubobject_arrow_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImageSubobject f)
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject f)) =
        f :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y`, and any morphism `f` from `X` to `Y` that has an image, the composition of the factorisation of `f` through the image subobject of `f` and the arrow from the underlying object of the image subobject of `f` to the ambient object is equal to `f`. Thus, it captures the property that the image subobject of a morphism in category theory is a canonical factorization of that morphism.

In any category, for any morphism with an image, the factorization through the image subobject and the arrow from the image to the ambient object equals the morphism itself.


ContinuousMap.Homotopic.hcomp

theorem ContinuousMap.Homotopic.hcomp :
    ∀ {X : Type u} {Y : Type v} {Z : Type w} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)},
      ContinuousMap.Homotopic f₀ f₁ →
        ContinuousMap.Homotopic g₀ g₁ → ContinuousMap.Homotopic (ContinuousMap.comp g₀ f₀) (ContinuousMap.comp g₁ f₁) :=
  by sorry

This theorem states that given two pairs of homotopic continuous maps, specifically `f₀` and `f₁` from a topological space `X` to a topological space `Y`, and `g₀` and `g₁` from `Y` to another topological space `Z`, if both pairs are homotopic, then the compositions of the maps (i.e., `g₀` composed with `f₀` and `g₁` composed with `f₁`) are also homotopic. In mathematical terms, if `f₀` is homotopic to `f₁` and `g₀` is homotopic to `g₁`, then `g₀ ∘ f₀` is homotopic to `g₁ ∘ f₁`.

Given continuous maps `f₀`, `f₁` from X to Y and `g₀`, `g₁` from Y to Z, if `f₀` is homotopic to `f₁` and `g₀` is homotopic to `g₁`, then `g₀ ∘ f₀` is homotopic to `g₁ ∘ f₁`.


theorem le_inv_smul_iff_of_pos :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : GroupWithZero α] [inst_1 : Preorder α]
      [inst_2 : Preorder β] [inst_3 : MulAction α β] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β],
      0 < a → (b₁ ≤ a⁻¹ • b₂ ↔ a • b₁ ≤ b₂) :=
  by sorry

This theorem states that for any two values `b₁` and `b₂` of some preordered type `β`, and any positive value `a` of a type `α` equipped with a group structure with zero and a multiplication action on `β`, the inequality `b₁ ≤ a⁻¹ • b₂` is equivalent to the inequality `a • b₁ ≤ b₂`. Here, `a⁻¹ • b₂` represents the scalar multiplication of `b₂` by the inverse of `a`, and `a • b₁` represents the scalar multiplication of `b₁` by `a`. This theorem assumes that scalar multiplication by positive elements of `α` is monotone and reflects the order of `β`.

For any preordered type `β` with scalar multiplication by positive elements of a group `α` with zero, the inequality `b₁ ≤ a⁻¹ • b₂` is equivalent to `a • b₁ ≤ b₂`.


HasDerivAt.scomp

/-- The chain rule.  -/
theorem HasDerivAt.scomp :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) {𝕜' : Type u_1} [inst_3 : NontriviallyNormedField 𝕜']
      [inst_4 : NormedAlgebra 𝕜 𝕜'] [inst_5 : NormedSpace 𝕜' F] [inst_6 : IsScalarTower 𝕜 𝕜' F] {h : 𝕜 → 𝕜'} {h' : 𝕜'}
      {g₁ : 𝕜' → F} {g₁' : F}, HasDerivAt g₁ g₁' (h x) → HasDerivAt h h' x → HasDerivAt (g₁ ∘ h) (h' • g₁') x :=
  by sorry

The theorem `HasDerivAt.scomp` is a statement of the chain rule in calculus. This theorem states that for any two functions `h` and `g₁` with derivatives `h'` and `g₁'` respectively, if `h` has its derivative `h'` at a point `x` and `g₁` has its derivative `g₁'` at the point `h(x)`, then the derivative of the composition of `g₁` and `h`, that is `(g₁ ∘ h)`, at the point `x` is `h' • g₁'`. Here, '•' denotes scalar multiplication in the appropriate normed vector space. This holds when `𝕜` and `𝕜'` are non-trivially normed fields, `F` is a normed add-commutative group and a vector space over `𝕜` and `𝕜'`, and when `𝕜'` is a normed algebra over `𝕜`.

The chain rule in calculus states that for functions `h` and `g₁` with derivatives `h'` and `g₁'` respectively, the derivative of their composition `(g₁ ∘ h)` at a point `x` is `h'(x) * g₁'(h(x))`.


theorem Set.union_eq_self_of_subset_left : ∀ {α : Type u} {s t : Set α}, s ⊆ t → s ∪ t = t := by sorry

This theorem states that for all types `α`, and for all sets `s` and `t` of type `α`, if `s` is a subset of `t` then the union of `s` and `t` is equal to `t`. In more mathematical terms, given two sets `s` and `t`, if every element in `s` is also an element in `t` (i.e., `s ⊆ t`), then the union of `s` and `t` (i.e., `s ∪ t`) is simply `t`. This aligns with the intuition that adding a subset to a set does not change the original set.

For all types `α` and sets `s` and `t` of type `α`, if `s` is a subset of `t`, then `s ∪ t = t`.


theorem Complex.inv_re : ∀ (z : ℂ), z⁻¹.re = z.re / Complex.normSq z := by sorry

The theorem `Complex.inv_re` states that for any complex number `z`, the real part of the reciprocal of `z` is equal to the real part of `z` divided by the square of the norm of `z`. In mathematical terms, if `z` is a complex number, then the real part of `1/z` is equal to `Re(z) / ||z||^2`.

The real part of the complex conjugate of the reciprocal of a complex number `z` is equal to the reciprocal of the square of its norm: `Real part(conjg z!*1) = 1 / ||z||^2`.


Prod.exists

theorem Prod.exists : ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) ↔ ∃ a b, p (a, b) := by sorry

This theorem states that for all types `α` and `β` and a property `p` applied to pairs of elements from `α` and `β`, there exists an element that satisfies `p` if and only if there exist separate elements `a` from `α` and `b` from `β` such that the pair `(a, b)` satisfies `p`. In other words, it shows the equivalence between finding a pair that satisfies a property and finding individual elements from each type that make up a pair satisfying the same property.

For all types `α` and `β` and properties `p` on pairs from `α × β`, the existence of a pair `(a, b)` satisfying `p` is equivalent to the existence of separate elements `a ∈ α` and `b ∈ β` such that `p(a, b)` holds.


theorem Finset.sum_ite :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p}
      (f g : α → β),
      (Finset.sum s fun x => if p x then f x else g x) =
        (Finset.sum (Finset.filter p s) fun x => f x) + Finset.sum (Finset.filter (fun x => ¬p x) s) fun x => g x :=
  by sorry

The theorem `Finset.sum_ite` asserts that for any finite set `s` of elements of type `α`, a decidable predicate `p` on `α`, and two functions `f` and `g` from `α` to `β` (where `β` forms an additive commutative monoid), the sum over all elements of `s` of `f(x)` if `p(x)` holds and `g(x)` otherwise, is equal to the sum of `f(x)` over elements of `s` that satisfy `p`, plus the sum of `g(x)` over elements of `s` that do not satisfy `p`. In other words, it splits the sum over a condition into two separate sums over the subsets where the condition is true and false, respectively.

For any finite set `s`, decidable predicate `p` on a type `α`, and functions `f` and `g` from `α` to an additive commutative monoid `β`, the sum of `f(x)` over elements `x` in `s` that satisfy `p` is equal to the sum of `f(x)` for `x` in `s` plus the sum of `g(x)` for `x` in `s` where `p` does not hold.


theorem Equiv.Perm.IsCycle.ne_one : ∀ {α : Type u_2} {f : Equiv.Perm α}, Equiv.Perm.IsCycle f → f ≠ 1 := by sorry

The theorem `Equiv.Perm.IsCycle.ne_one` states that for any type `α` and any permutation `f` of type `α`, if `f` is a cycle (i.e., a non-identity permutation where any two non-fixed points are related by repeated application of the permutation), then `f` is not equal to the identity permutation (denoted as `1`). In other words, a cyclic permutation is never the identity.

For any type `α` and permutation `f` of type `α`, if `f` is a cycle, then `f ≠ 1`.


theorem iSup_le_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, iSup f ≤ a ↔ ∀ (i : ι), f i ≤ a :=
  by sorry

This theorem, `iSup_le_iff`, states that for any type `α` that forms a complete lattice, any function `f` from another type `ι` to `α`, and any element `a` of `α`, the indexed supremum of `f` is less than or equal to `a` if and only if every element of `ι` when mapped by `f` is less than or equal to `a`. Here, the indexed supremum of `f` is defined as the supremum of the set of all values that `f` can take.

For any complete lattice α and function f from type ι to α, the indexed supremum of f is less than or equal to an element a of α if and only if for all i in ι, f(i) is less than or equal to a.


theorem finrank_bot :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R],
      FiniteDimensional.finrank R ↥⊥ = 0 :=
  by sorry

This theorem states that for any ring `R` and any commutative additive group `M` that is also a module over `R`, provided that `R` is nontrivial, the rank of the bottom (`⊥`) submodule is `0`. In other words, the dimension of the trivial subspace in any vector space is zero.

For any nontrivial ring `R` and commutative additive group `M` that is also an `R`-module, the rank of the zero submodule is 0.


theorem Ordinal.deriv_zero : ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}), Ordinal.deriv f 0 = Ordinal.nfp f 0 := by sorry

This theorem, `Ordinal.deriv_zero`, states that for any ordinal function `f` that maps an ordinal to another ordinal, the derivative of `f` at zero equals the least fixed point of `f` at zero. In other words, the first fixed point of a normal function `f` that does not fall below zero is the derivative of `f` at zero. This establishes a fundamental relationship between the derivative and the least fixed point of an ordinal function at zero.

The derivative of an ordinal function at zero equals its least fixed point at zero.


theorem Stream'.WSeq.liftRel_destruct :
    ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β},
      Stream'.WSeq.LiftRel R s t →
        Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)) (Stream'.WSeq.destruct s)
          (Stream'.WSeq.destruct t) :=
  by sorry

This theorem, `Stream'.WSeq.liftRel_destruct`, states that for any two types `α` and `β` and any relation `R` between `α` and `β`, if two weak sequences `s` and `t` (of types `α` and `β` respectively) are related by the `LiftRel R` relation, then the computations resulting from the destruction of `s` and `t` (i.e., `Stream'.WSeq.destruct s` and `Stream'.WSeq.destruct t` respectively) are related by the `Computation.LiftRel` relation applied to the `Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)` relation. In other words, if `s` and `t` are related in a certain way, then the computations that deconstruct `s` and `t` are also related in a similar way.

For any types `α` and `β` and relation `R` between them, if two weak sequences `s` and `t` of types `α` and `β` respectively are related by `LiftRel R`, then their destruction computations `Stream'.WSeq.destruct s` and `Stream'.WSeq.destruct t` are related by `Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R))`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.ae_eq :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.Measure.QuasiMeasurePreserving f μa μb →
        ∀ {g₁ g₂ : β → δ}, g₁ =ᶠ[MeasureTheory.Measure.ae μb] g₂ → g₁ ∘ f =ᶠ[MeasureTheory.Measure.ae μa] g₂ ∘ f :=
  by sorry

The theorem `MeasureTheory.Measure.QuasiMeasurePreserving.ae_eq` states that for any types `α`, `β`, and `δ`, with `α` and `β` equipped with measurable spaces, and `μa` and `μb` are measures on `α` and `β` respectively, if a function `f` from `α` to `β` is quasi measure preserving with respect to measures `μa` and `μb`, then for any two functions `g₁` and `g₂` from `β` to `δ`, if `g₁` is almost everywhere equal to `g₂` with respect to the measure `μb`, then the compositions `g₁ ∘ f` and `g₂ ∘ f` are also almost everywhere equal with respect to the measure `μa`. "Almost everywhere" means on all sets except a set of measure zero.

If `f: α → β` is quasi measure preserving between measurable spaces `(α, Σα, μa)` and `(β, Σβ, μb)`, and `g₁` and `g₂` are functions from `β` to a third type `δ` such that `g₁ = g₂` almost everywhere with respect to `μb`, then `g₁ ∘ f = g₂ ∘ f` almost everywhere with respect to `μa`.


theorem Real.toNNReal_le_toNNReal_iff : ∀ {r p : ℝ}, 0 ≤ p → (Real.toNNReal r ≤ Real.toNNReal p ↔ r ≤ p) := by sorry

The theorem `Real.toNNReal_le_toNNReal_iff` states that for any two real numbers `r` and `p`, where `p` is greater than or equal to zero, the non-negative real number interpretation of `r` is less than or equal to the non-negative real number interpretation of `p` if and only if `r` is less than or equal to `p`. In other words, the comparison of `r` and `p` remains the same whether they are interpreted as non-negative real numbers or as their original real numbers, given that `p` is non-negative.

For any real numbers `r` and `p` with `p ≥ 0`, `Real.toNNReal r ≤ Real.toNNReal p` if and only if `r ≤ p`.


theorem Real.toNNReal_inv : ∀ {x : ℝ}, Real.toNNReal x⁻¹ = (Real.toNNReal x)⁻¹ := by sorry

This theorem states that for any real number 'x', the function 'Real.toNNReal' applied to the inverse of 'x' is equal to the inverse of 'Real.toNNReal x'. In other words, the process of converting a real number to a non-negative real number commutes with taking the reciprocal. This means that whether you first take a reciprocal and then convert to a non-negative real, or first convert to a non-negative real and then take a reciprocal, you get the same result.

For any real number x, Real.toNNReal (1 / x) = 1 / Real.toNNReal x.


theorem Multiset.rel_refl_of_refl_on :
    ∀ {α : Type u_1} {m : Multiset α} {r : α → α → Prop}, (∀ x ∈ m, r x x) → Multiset.Rel r m m := by sorry

This theorem states that for any type `α`, any multiset `m` of that type, and any binary relation `r` defined on `α`, if the relation `r` is reflexive on every element in the multiset `m` (i.e., `r x x` holds for every `x` in `m`), then the multiset `m` is related to itself under the multiset relation induced by `r`. This is equivalent to saying that the multiset `m` is reflexive with respect to the relation `r`.

If for every element `x` in a multiset `m` of type `α`, the binary relation `r` on `α` is reflexive at `x` (i.e., `r x x` holds), then `m` is a reflexive multiset with respect to `r`.


theorem List.count_replicate_self :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (n : ℕ), List.count a (List.replicate n a) = n := by sorry

The theorem `List.count_replicate_self` states that for any type `α` with decidable equality and for any element `a` of type `α` and a natural number `n`, the count of `a` in a list that is created by replicating `a` `n` times is precisely `n`. In simpler words, it expresses that the number of occurrences of a specific value in a list, which is formed by repeating that value a certain number of times, is equal to that number of repetitions.

For any type `α` with decidable equality and natural number `n`, the length of the list obtained by replicating an element `a` of type `α` `n` times equals `n`.


theorem pow_unbounded_of_one_lt :
    ∀ {α : Type u_1} [inst : StrictOrderedSemiring α] [inst_1 : Archimedean α] {y : α} [inst_2 : ExistsAddOfLE α]
      (x : α), 1 < y → ∃ n, x < y ^ n :=
  by sorry

This theorem states that for any strictly ordered semiring `α` with an Archimedean property and a certain `x` in `α`, if `y` is an element of `α` that is greater than `1`, then there exists a natural number `n` such that `x` is less than `y` raised to the power of `n`. Essentially, the power of any number greater than `1` can become arbitrarily large in a strictly ordered semiring, surpassing any given number in the semiring.

For any strictly ordered semiring with the Archimedean property and element `x`, there exists a natural number `n` such that `x` is strictly less than `y^n` for `y` being any element greater than 1.


theorem Set.compl_Ici : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, (Set.Ici a)ᶜ = Set.Iio a := by sorry

The theorem `Set.compl_Ici` states that for any type `α` with a linear order and any element `a` of that type, the complement of the set of elements that are greater than or equal to `a` (notated as `(Set.Ici a)ᶜ`) is exactly the set of elements that are strictly less than `a` (notated as `Set.Iio a`). In other words, it asserts that the elements not in a left-closed right-infinite interval starting at `a` are precisely those in a left-infinite right-open interval ending just before `a`.

The complement of the left-closed right-infinite interval `(Set.Ici a)` equals the left-infinite right-open interval `Set.Iio a`.


theorem Function.Surjective.injective_comp_right :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Surjective f → Function.Injective fun g => g ∘ f :=
  by sorry

The theorem `Function.Surjective.injective_comp_right` states that for all types `α`, `β`, and `γ` and for every function `f` from `α` to `β`, if function `f` is surjective, then the function given by composition with `f` on the right, i.e., the function `g ↦ g ∘ f` for a function `g : β → γ`, is injective. This means that if every element in the codomain `β` is mapped from some element in the domain `α` by the function `f`, then for any two different functions `g₁` and `g₂` from `β` to `γ`, their compositions with `f` are also different. In mathematical terms, if `f` is surjective and `g₁ ∘ f = g₂ ∘ f`, then `g₁ = g₂`.

If `f : α → β` is surjective, then for every `γ-valued` function `g₁ ≠ g₂`, the functions `g₁ ∘ f` and `g₂ ∘ f` are distinct.


theorem MeasureTheory.Integrable.const_mul :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_5} [inst : NormedRing 𝕜]
      {f : α → 𝕜}, MeasureTheory.Integrable f μ → ∀ (c : 𝕜), MeasureTheory.Integrable (fun x => c * f x) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.const_mul` states that, given a measurable space `α`, a measure `μ` on `α`, a normed ring `𝕜`, and a function `f` from `α` to `𝕜`, if `f` is integrable with respect to `μ`, then for any constant `c` in `𝕜`, the function obtained by multiplying `f` by `c` at each point (`c * f x`) is also integrable with respect to `μ`. In other words, the integrability of a function is preserved under scalar multiplication.

If `f` is an integrable function from a measurable space `(α, Σ, μ)` to a normed ring `𝕜`, then for any constant `c` in `𝕜`, the function `c * f` is also integrable.


theorem Polynomial.nextCoeff_of_natDegree_pos :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      0 < Polynomial.natDegree p → Polynomial.nextCoeff p = Polynomial.coeff p (Polynomial.natDegree p - 1) :=
  by sorry

The theorem `Polynomial.nextCoeff_of_natDegree_pos` states that for any semiring `R` and any polynomial `p` over `R`, if the natural degree of `p` is greater than zero, then the next coefficient of `p` is equal to the coefficient of `p` at the position of its natural degree minus one. In other words, for a non-zero-degree polynomial, its next coefficient is simply the coefficient of the term with one degree less. This theorem bridges the relation between the next coefficient and the natural degree of the polynomial in a semiring.

For any semiring `R` and polynomial `p` of positive degree over `R`, the next coefficient of `p` is equal to the coefficient of `p` at degree `n-1`, where `n` is the degree of `p`.


theorem Complex.arg_mem_Ioc : ∀ (z : ℂ), Complex.arg z ∈ Set.Ioc (-Real.pi) Real.pi := by sorry

This theorem states that for every complex number `z`, the argument of `z` (denoted as `Complex.arg z`) belongs to the left-open right-closed interval from `-π` to `π`. In other words, the value of the argument function on any complex number lies between `-π` and `π`, with `-π` being excluded and `π` being included.

The argument of every complex number lies in the interval (-π, pi].


/-- If the angle between two vectors is nonzero, the vectors are not equal.  -/
theorem Orientation.ne_of_oangle_ne_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y ≠ 0 → x ≠ y :=
  by sorry

This theorem states that in a two-dimensional real inner product space, if the oriented angle between two vectors is non-zero, then the two vectors are not equal. In other words, any two vectors with a non-zero oriented angle between them must be distinct vectors. This is valid for any given orientation of the space.

In a two-dimensional real inner product space, two non-zero vectors with a non-zero oriented angle between them are distinct.


theorem completeSpace_congr :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {e : α ≃ β},
      UniformEmbedding ⇑e → (CompleteSpace α ↔ CompleteSpace β) :=
  by sorry

This theorem states that, given two types `α` and `β` that are both uniform spaces, and given a bijection `e` from `α` to `β`, if this bijection is a uniform embedding, then `α` is a complete space if and only if `β` is a complete space. In other words, the completeness of a space is preserved under a uniform embedding. Here, a complete space is a space in which every Cauchy sequence (or Cauchy filter) converges.

If `α` and `β` are uniform spaces with a uniformly bijective and uniformly continuous map `e` between them, then `α` and `β` are completeness-equivalent, i.e., they have the same Cauchy sequences.


theorem LieSubmodule.bot_coeSubmodule :
    ∀ {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], ↑⊥ = ⊥ :=
  by sorry

This theorem states that, for any commutative ring `R`, Lie ring `L`, and additive commutative group `M`, with `M` also being a module over `R` and a Lie ring module over `L`, the Lie submodule generated by the empty set (denoted as `⊥`) is equal to the bottom element of the lattice of submodules (also denoted as `⊥`). This essentially shows that the smallest possible Lie submodule is the one that contains no elements.

For any commutative ring `R`, Lie ring `L`, and additive commutative group `M` being an `R`-module and a Lie ring module over `L`, the Lie submodule generated by the empty set of `M` equals the bottom element of the lattice of Lie submodules of `M`.


theorem Filter.prod_inf_prod :
    ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β},
      f₁ ×ˢ g₁ ⊓ f₂ ×ˢ g₂ = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂) :=
  by sorry

This theorem states that for any two pairs of filters (`f₁`, `g₁`) and (`f₂`, `g₂`) where filters are defined over arbitrary types `α` and `β`, the product of the infimum (or intersection) of the two filter pairs is equal to the infimum of their individual products. In more mathematical terms, `(f₁ × g₁) ∩ (f₂ × g₂) = (f₁ ∩ f₂) × (g₁ ∩ g₂)`. This means if you first combine the filters from each type and then take the intersection, it's the same as if you first take the intersection within each type and then combine the results.

The infimum of the product of two filters (`f₁ × g₁`) is equal to the product of their infima (`(f₁ ∩ f₂) × (g₁ ∩ g₂)`).


theorem lt_one_add :
    ∀ {α : Type u_1} [inst : One α] [inst_1 : AddZeroClass α] [inst_2 : PartialOrder α] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1] [inst_5 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      (a : α), a < 1 + a :=
  by sorry

The `lt_one_add` theorem states that for any type `α` that has a `One` instance, an `AddZeroClass` instance, a `PartialOrder` instance, a `ZeroLEOneClass` instance, a `NeZero 1` instance and a `CovariantClass` instance for addition and the less than relation, any element `a` of type `α` is less than the sum of `1` and `a`. This is a general property that applies to many algebraic structures such as natural numbers, integers, rational numbers, and real numbers. In mathematical terms, this theorem states that for all `a` in `α`, `a < 1 + a`.

For any type `α` with the specified instances, every `a` in `α` satisfies `a < 1 + a`.


theorem Filter.eventuallyEq_iff_exists_mem :
    ∀ {α : Type u} {β : Type v} {l : Filter α} {f g : α → β}, f =ᶠ[l] g ↔ ∃ s ∈ l, Set.EqOn f g s := by sorry

The theorem `Filter.eventuallyEq_iff_exists_mem` states that for any types `α` and `β`, any filter `l` on `α`, and any functions `f` and `g` from `α` to `β`, the assertion that `f` is eventually equal to `g` at filter `l` (denoted `f =ᶠ[l] g`) is equivalent to the existence of a set `s` which belongs to the filter `l` such that `f` and `g` are equal on `s`. In other words, `f` is eventually equal to `g` at `l` if and only if there is some set `s` in the filter `l` where `f` and `g` have the same values for all elements of `s`.

For any types `α` and `β`, filter `l` on `α`, and functions `f` and `g` from `α` to `β`, `f` is eventually equal to `g` at filter `l` if and only if there exists a set `s` in `l`, such that `f(x) = g(x)` for all `x` in `s`.


theorem Polynomial.eval₂_hom :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S) (x : R),
      Polynomial.eval₂ f (f x) p = f (Polynomial.eval x p) :=
  by sorry

The theorem `Polynomial.eval₂_hom` states that for any semiring `R`, any semiring `S`, any polynomial `p` with coefficients in `R`, any ring homomorphism `f` from `R` to `S`, and any element `x` in `R`, the evaluation of the polynomial `p` at `f(x)` (after mapping the coefficients of `p` to `S` via `f`), is the same as first evaluating `p` at `x` in `R` and then mapping the result to `S` via `f`. In other words, the processes of evaluating a polynomial and applying a ring homomorphism commute. This is symbolically represented as `Polynomial.eval₂ f (f x) p = f (Polynomial.eval x p)`.

For any semiring homomorphism $f$ and elements $x$ in a semiring $R$ and polynomial $p$ with coefficients in $R$, the evaluation of polynomial $p$ at $x$ and applying the homomorphism $f$ to the result are equal, that is, $f(p(x)) = p(f(x))$.


theorem Nat.nsmul_eq_mul : ∀ (m n : ℕ), m • n = m * n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the scalar multiplication `m • n` is equal to the regular multiplication `m * n`. In simpler terms, multiplying `n` by `m` times is the same as just multiplying `m` and `n`.

For all natural numbers m and n, m • n = m * n. (Scalar multiplication equals regular multiplication for natural numbers.)


theorem interior_interior :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], interior (interior s) = interior s := by sorry

The theorem `interior_interior` states that for any type `X` and for any set `s` of type `X` under a certain topological space `inst`, the interior of the interior of `s` is equal to the interior of `s`. In other words, in the context of topology, taking the interior of a set twice does not change the set, i.e., the operation of finding the interior of a set is idempotent.

For any topological space `(X, inst)` and set `s : X`, the interior of the interior of `s` equals the interior of `s`: `interior (interior s) = interior s`.


theorem UniqueDiffWithinAt.eq_deriv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' f₁' : F} {x : 𝕜} (s : Set 𝕜),
      UniqueDiffWithinAt 𝕜 s x → HasDerivWithinAt f f' s x → HasDerivWithinAt f f₁' s x → f' = f₁' :=
  by sorry

This theorem, `UniqueDiffWithinAt.eq_deriv`, states that if a function `f` has a derivative within a subset `s` of a nontrivial normed field at a point `x`, and also has another derivative within the same subset at the same point, then these two derivatives must be equal, provided the set `s` has the unique differentiability property at `x`. More precisely, for any nontrivially normed field `𝕜`, normed additive commutative group `F`, function `f` from `𝕜` to `F`, derivatives `f'` and `f₁'` of `F`, and point `x` in `𝕜`, if `s` is a set in `𝕜` such that `UniqueDiffWithinAt 𝕜 s x` holds and both `HasDerivWithinAt f f' s x` and `HasDerivWithinAt f f₁' s x` hold, then `f'` must be equal to `f₁'`.

If a function has two derivatives within a set in a nontrivially normed field at a point where the set has the unique differentiability property, then those derivatives are equal.


theorem Primrec.nat_le : PrimrecRel fun x x_1 => x ≤ x_1 := by sorry

The theorem `Primrec.nat_le` states that the relation of "less than or equal to" (`≤`) for two natural numbers is a primitive recursive relation. In other words, the function that takes two natural numbers and returns a boolean value indicating whether the first number is less than or equal to the second number, is primitive recursive. This function is decidable, meaning that for any two natural numbers, it can definitively determine whether the first is less than or equal to the second.

The relation ≤ on natural numbers is a decidable, primitive recursive predicate.


theorem AlgebraicTopology.DoldKan.PInfty_f :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (n : ℕ),
      AlgebraicTopology.DoldKan.PInfty.f n = (AlgebraicTopology.DoldKan.P n).f n :=
  by sorry

The theorem `AlgebraicTopology.DoldKan.PInfty_f` states that for any category `C` which is preadditive, and any `X` which is a simplicial object in `C`, the `f` operation (part of a functor or morphism in the category) of the `PInfty` construction at a natural number `n` is equal to the `f` operation of the `P` construction at the same `n`. This theorem is part of the Dold-Kan correspondence which relates simplicial objects and chain complexes in a certain way.

For any preadditive category `C` and simplicial object `X` in `C`, the `n`-th `f` operation of the `PInfty` construction equals the `n`-th `f` operation of the `P` construction.


Continuous.restrict

theorem Continuous.restrict :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X}
      {t : Set Y} (h1 : Set.MapsTo f s t), Continuous f → Continuous (Set.MapsTo.restrict f s t h1) :=
  by sorry

This theorem states that for any two types `X` and `Y`, which both have a topological space structure, and for any function `f` from `X` to `Y`, if `f` maps a set `s` in `X` to a set `t` in `Y` (which means that the image of `s` under `f` is contained in `t`), then if `f` is continuous, the function derived by restricting the domain of `f` to `s` and the codomain to `t` is also continuous.

If `X` and `Y` are topological spaces, `f: X → Y` is continuous, and `s ⊆ X` maps to `t ⊆ Y`, then the restriction of `f` to `s` and `t` is continuous.


theorem MeasureTheory.Lp.norm_def :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), ‖f‖ = (MeasureTheory.snorm (↑↑f) p μ).toReal :=
  by sorry

This theorem establishes a definition for the norm of a function in a Lp space. Specifically, for any measurable space `α`, any normed add commutative group `E`, any measure `μ` on `α`, and any function `f` in the Lp space over `E` with measure `μ` and norm `p` (where `p` is an extended nonnegative real number), the norm of the function `f` (`‖f‖`) is defined to be the real part of the Lp seminorm (`MeasureTheory.snorm`) of the function `f`. The Lp seminorm is defined differently depending on the value of `p`: it equals `0` for `p=0`, `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and the essential supremum of `‖f‖` over `μ` for `p = ∞`.

For any measurable space `α`, normed add commutative group `E`, measure `μ` on `α`, and function `f` in the Lp space over `E` with measure `μ` and norm `p`, the norm of `f` equals the real part of the Lp seminorm of `f`, where the Lp seminorm is `0` for `p=0`, `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and the essential supremum of `‖f‖` over `μ` for `p = ∞`.


theorem Set.encard_diff_add_encard_inter :
    ∀ {α : Type u_1} (s t : Set α), Set.encard (s \ t) + Set.encard (s ∩ t) = Set.encard s := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the cardinality of the difference set `s \ t` added to the cardinality of the intersection set `s ∩ t` is equal to the cardinality of the set `s`. This mirrors the principle of inclusion-exclusion in set theory, with the cardinality functioning analogously to the measure of the set. The difference set `s \ t` contains all elements of `s` that are not in `t`, while the intersection `s ∩ t` includes all elements that `s` and `t` have in common.

The cardinality of a set `α` equals the cardinality of its subset `s` plus the cardinality of its complement in `s` relative to the subset `t` minus the cardinality of their intersection, i.e., `|s| = |s ∩ t| + |s \ t|`.


theorem Metric.closedEmbedding_of_pairwise_le_dist :
    ∀ {γ : Type w} [inst : MetricSpace γ] {α : Type u_3} [inst_1 : TopologicalSpace α] [inst_2 : DiscreteTopology α]
      {ε : ℝ}, 0 < ε → ∀ {f : α → γ}, (Pairwise fun x y => ε ≤ dist (f x) (f y)) → ClosedEmbedding f :=
  by sorry

The theorem `Metric.closedEmbedding_of_pairwise_le_dist` states that for any type `γ` with a metric space structure, any type `α` with a topological space structure and discrete topology, any function `f` from `α` to `γ`, and any positive real number `ε`, if the distance between the images of every pair of distinct elements in `α` under `f` is at least `ε`, then `f` is a closed embedding. In other words, if every pair of distinct points in `α` map to points in `γ` that are at least `ε` apart, then `f` is a type of continuous function that preserves the closure of subsets.

If a function from a discrete topological space to a metric space maps distinct points to points at least a fixed distance apart, then the function is a closed embedding.


theorem Filter.HasBasis.frequently_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → ∀ {q : α → Prop}, (∃ᶠ (x : α) in l, q x) ↔ ∀ (i : ι), p i → ∃ x ∈ s i, q x :=
  by sorry

This theorem states that for any type `α` and indexing type `ι`, given a filter `l` on `α`, a predicate `p` on `ι`, and a function `s` mapping `ι` to sets of `α` such that `l` has the basis `p` and `s`, for any predicate `q` on `α`, the event "there exist frequently `x` in `l` such that `q x` is true" is equivalent to "for any index `i` in `ι` for which `p i` is true, there exists an element `x` in the set `s i` such that `q x` is true".

Here, "frequently" means the event occurs in `l` on a set of indices with full measure. The term "basis for a filter" refers to a collection of sets that can be used to generate the filter, and it satisfies certain properties like any element of the basis intersects with some other element of the basis.

Given a filter `l` on type `α` with basis `{p : ι → Prop, s : ι → set α | p ∧ l.is_closed p ∧ ∀ i, p i → ∃ x ∈ s i, q x}`, the event "there exists an x in l with q(x) true" is equivalent to "for all i in ι with p(i), there exists an x in s(i) with q(x) true".


theorem Polynomial.map_dvd :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {x y : Polynomial R},
      x ∣ y → Polynomial.map f x ∣ Polynomial.map f y :=
  by sorry

The theorem `Polynomial.map_dvd` states that for any two polynomials `x` and `y` in a semiring `R`, and a ring homomorphism `f` from `R` to another semiring `S`, if `x` divides `y` in `R`, then the map of `x` under `f` divides the map of `y` under `f` in `S`. In other words, the "divides" relation is preserved under the polynomial map induced by `f`.

If `f` is a ring homomorphism from a semiring `R` to another semiring `S`, and `x` divides `y` in `R`, then the image of `x` under `f` divides the image of `y` under `f` in `S`.


theorem Complex.cosh_add :
    ∀ (x y : ℂ), Complex.cosh (x + y) = Complex.cosh x * Complex.cosh y + Complex.sinh x * Complex.sinh y := by sorry

This theorem states that for any two complex numbers `x` and `y`, the hyperbolic cosine of the sum of `x` and `y`, denoted `Complex.cosh (x + y)`, is equal to the product of the hyperbolic cosine of `x` and the hyperbolic cosine of `y` plus the product of the hyperbolic sine of `x` and the hyperbolic sine of `y`. In mathematical notation, this would be expressed as `cosh(x + y) = cosh(x) * cosh(y) + sinh(x) * sinh(y)`. This is a complex number analogue of the classical addition formula for the hyperbolic cosine function.

The hyperbolic cosine of the sum of two complex numbers is equal to the product of their hyperbolic cosines plus the product of their hyperbolic sines. In Lean notation: `Complex.cosh (x + y) = cosh x * cosh y + sinh x * sinh y`.


theorem Int.zero_sub : ∀ (a : ℤ), 0 - a = -a := by sorry

This theorem, `Int.zero_sub`, states that for any integer `a`, the result of subtracting `a` from zero (`0 - a`) is equal to the negative of `a` (`-a`). This follows the algebraic rule that 0 minus a given number is equivalent to the negative of that number.

For any integer `a`, `0 - a` equals `-a`.


theorem mem_of_mem_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s t : Set α}, a ∈ s → t ∈ nhdsWithin a s → a ∈ t := by sorry

This theorem asserts that for any type `α` that has a topological space structure, and any elements `a` of type `α` and sets `s` and `t` of type `Set α`, if `a` is an element of `s` and `t` is in the filter of neighborhood within `s` of `a` (denoted by `nhdsWithin a s`), then `a` is also an element of `t`. In other words, if `a` is in some set `s` and `t` is within the neighborhood of `a` restricted to `s`, then `a` is also in `t`. This theorem is part of the foundation for the understanding of neighborhood filters in a topological space.

For any topological space `α` and elements `a ∈ α`, `s ∈ Set α`, and `t ∈ nhdsWithin a s`, we have `a ∈ t`.


theorem Complex.div_ofReal : ∀ (z : ℂ) (x : ℝ), z / ↑x = { re := z.re / x, im := z.im / x } := by sorry

This theorem states that for any complex number `z` and real number `x`, the division of `z` by `x` (where `x` is treated as a complex number with zero imaginary part) equals a new complex number whose real part equals the real part of `z` divided by `x`, and whose imaginary part equals the imaginary part of `z` divided by `x`. In other words, dividing a complex number by a real number results in dividing both the real and imaginary parts of the complex number by the real number.

For any complex number `z` and real number `x` (non-zero), the quotient of `z` by `x` is equal to the complex number with real part `(Re z) / x` and imaginary part `(Im z) / x`.


theorem CategoryTheory.Presheaf.isSheaf_of_iso_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C}
      {P P' : CategoryTheory.Functor Cᵒᵖ A},
      (P ≅ P') → (CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presheaf.IsSheaf J P') :=
  by sorry

This theorem states that for any categories `C` and `A`, any Grothendieck topology `J` on `C`, and any two functors `P` and `P'` from the opposite of `C` to `A` that are isomorphic, `P` is a sheaf with respect to `J` if and only if `P'` is a sheaf with respect to `J`. In other words, being a sheaf is a property that is preserved under isomorphism between functors.

For any categories C, any Grothendieck topology J on C, and any oppositely isomorphic functors P and P' from the opposite of C to A, if one is a sheaf with respect to J then so is the other.


LinearEquiv.bijective

theorem LinearEquiv.bijective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
      Function.Bijective ⇑e :=
  by sorry

The theorem `LinearEquiv.bijective` states that for any types `R`, `S`, `M`, and `M₂`, where `R` and `S` are semirings, `M` and `M₂` are additive commutative monoids, `M` is a module over `R`, `M₂` is a module over `S`, and `σ` and `σ'` form a pair of ring homomorphisms that are inverse to each other, any linear equivalence `e` between `M` and `M₂` (under the homomorphism `σ`) is a bijective function. In other words, every linear equivalence is an injective (one-to-one) and surjective (onto) function.

Given semirings R and S, additive commutative monoids M and M₂, a module M over R, a module M₂ over S, ring homomorphisms σ : R -> S and σ' : S -> R that are inverses of each other, and a linear equivalence e between M and M₂ under σ, then e is a bijective function.


theorem Primrec₂.encode_iff :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α → β → σ}, (Primrec₂ fun a b => Encodable.encode (f a b)) ↔ Primrec₂ f :=
  by sorry

The theorem `Primrec₂.encode_iff` states that for any types `α`, `β`, and `σ`, where each type is Primcodable, and any binary function `f` from `α` and `β` to `σ`, the encoding of the function `f` is a binary primitive recursive function if and only if `f` itself is a binary primitive recursive function. In other words, encoding doesn't change the primitive recursive nature of a binary function.

The encoding of a binary primitive recursive function is a binary primitive recursive function.


theorem ArithmeticFunction.IsMultiplicative.map_one :
    ∀ {R : Type u_1} [inst : MonoidWithZero R] {f : ArithmeticFunction R},
      ArithmeticFunction.IsMultiplicative f → f 1 = 1 :=
  by sorry

The theorem `ArithmeticFunction.IsMultiplicative.map_one` states that for any type `R` which is a monoid with zero, and any arithmetic function `f` from natural numbers to `R`, if `f` is a multiplicative function (meaning that `f` of `1` equals `1` and `f` of the product of any two coprime natural numbers equals the product of `f` applied to each of the numbers), then `f` of `1` must be equal to `1`.

If `f` is a multiplicative arithmetic function on a monoid with zero, then `f` maps `1` to `1`.


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

The theorem `finprod_eq_prod_of_mulSupport_subset` states that for any type `α` and any commutative monoid `M`, given a function `f` from `α` to `M` and a finite set `s` of `α`, if the multiplicative support of `f` (the set of points `x` such that `f(x)` is not equal to the identity element `1`) is a subset of `s`, then the finprod of `f` (the product of `f(x)` as `x` ranges over the elements of the multiplicative support of `f`, if it's finite; `1` otherwise) is equal to the product of `f(x)` as `x` ranges over the elements of the finite set `s`. In mathematical notation, if $\{x | f(x) \neq 1\} \subseteq s$, then $\prod_{i \in \text{mulSupport}(f)} f(i) = \prod_{i \in s} f(i)$.

If a function's multiplicative support is a subset of a finite set, then the product of the function over its multiplicative support is equal to the product of the function over that finite set.


theorem Cardinal.ord_eq :
    ∀ (α : Type u_3), ∃ r, ∃ (wo : IsWellOrder α r), Cardinal.ord (Cardinal.mk α) = Ordinal.type r := by sorry

The theorem `Cardinal.ord_eq` asserts that for every type `α`, there exists a relation `r` and a proof that the relation `r` is a well-order on `α` such that the ordinal corresponding to the cardinality of `α` (as computed by `Cardinal.ord (Cardinal.mk α)`) is equal to the order type of the relation `r` (as computed by `Ordinal.type r`). In simpler terms, it says that every cardinal number has an associated ordinal number that is determined by a specific well-ordering on its underlying type.

For every type `α`, there exists a well-order `r` on `α` such that the ordinal type of `r` equals the cardinality of `α`.


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

This theorem states that for any type `α` that has a topological space structure, a measurable space structure, an open sets measurable space structure, a preorder structure, and an order closed topology structure, and for any two elements `a` and `b` of type `α`, the set of all elements between `a` and `b` (inclusive) is a measurable set in the ambient measure space on `α`. This includes both the case where `a` is less than or equal to `b`, and where `a` is greater than or equal to `b`.

For any type `α` endowed with topological space, measurable space, open sets measurable space, preorder, and order closed topology structures, the set of elements between any two elements `a` and `b` (inclusive) is measurable in the ambient measure space on `α`.


theorem exists_unique_of_exists_of_unique :
    ∀ {α : Sort u} {p : α → Prop}, (∃ x, p x) → (∀ (y₁ y₂ : α), p y₁ → p y₂ → y₁ = y₂) → ∃! x, p x := by sorry

The theorem `exists_unique_of_exists_of_unique` states that for any sort `α` and any property `p` of `α`, if there exists an `α` that satisfies the property `p` (i.e., `(∃ x, p x)`) and for any two elements `y₁` and `y₂` which satisfy the property `p`, they are in fact the same (i.e., `(∀ (y₁ y₂ : α), p y₁ → p y₂ → y₁ = y₂)`), then there exists a unique `α` that satisfies the property `p`. Simply put, if there exists at least one element with a certain property, and no two different elements can both have this property, then there is exactly one element with this property.

If there exists a unique element with a property in a sort, then there exists that element.


theorem Set.compl_Iio : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, (Set.Iio a)ᶜ = Set.Ici a := by sorry

This theorem, `Set.compl_Iio`, states that for any type `α` that has an instance of linear order, and for any element `a` of type `α`, the complement of the left-infinite, right-open interval ending at `a` is equal to the left-closed, right-infinite interval starting from `a`. In other words, every element not less than `a` (the complement of all elements less than `a`) is either equal to `a` or greater than `a`.

For any type `α` with a linear order and any `a` in `α`, the complement of the left-open, right-infinite interval `(−∞, a)` is equal to the left-closed, right-infinite interval `[a, +∞)`.


theorem MonoidAlgebra.lift_single :
    ∀ {k : Type u₁} {G : Type u₂} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u₃} [inst_2 : Semiring A]
      [inst_3 : Algebra k A] (F : G →* A) (a : G) (b : k),
      ((MonoidAlgebra.lift k G A) F) (MonoidAlgebra.single a b) = b • F a :=
  by sorry

This theorem states that for any commutative semiring `k`, any monoid `G`, any semiring `A` with a `k`-algebra structure, any monoid homomorphism `F` from `G` to `A`, and any elements `a` from `G` and `b` from `k`, the result of lifting `F` to an algebra homomorphism and then applying this to the monoid algebra element corresponding to `a` and `b`, is equal to `b` times `F(a)` in the `A` algebra. In other words, the lifting operation respects the operation of the monoid algebra.

For any commutative semiring `k`, monoid `G`, `k`-algebra `A` over `G`, monoid homomorphism `F` from `G` to `A`, and elements `a` from `G` and `b` from `k`, the lifting of `F` to an algebra homomorphism and application to the monoid algebra elements `a * x` and `b` results in `b * F(a)` in `A`. (Here, `*` denotes the monoid and algebra multiplication.)


theorem Mathlib.Algebra.Group.Basic._auxLemma.31 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (b - a = c - a) = (b = c) := by sorry

This theorem, named `Mathlib.Algebra.Group.Basic._auxLemma.31`, declares that for any type `G` that forms an additive group, if the difference between values `b` and `a` is equal to the difference between values `c` and `a`, then `b` is equal to `c`. In mathematical terms, this can be expressed as: for all `a, b, c` in an additive group `G`, if `b - a = c - a`, then `b = c`.

In an additive group, if the difference between two elements is equal to the difference between a third element and that same element, then the first two elements are equal.


theorem Equiv.Perm.subtypeCongr.right_apply :
    ∀ {ε : Type u_1} {p : ε → Prop} [inst : DecidablePred p] (ep : Equiv.Perm { a // p a })
      (en : Equiv.Perm { a // ¬p a }) {a : ε} (h : ¬p a),
      (Equiv.Perm.subtypeCongr ep en) a = ↑(en { val := a, property := h }) :=
  by sorry

The theorem `Equiv.Perm.subtypeCongr.right_apply` states that for any type `ε`, predicate `p` on `ε`, a permutation `ep` on elements satisfying `p`, a permutation `en` on elements not satisfying `p`, and an element `a` of `ε` that does not satisfy `p`, applying the permutation constructed by `Equiv.Perm.subtypeCongr` using `ep` and `en` to `a` results in the same value as applying `en` to `a` (cast to the subtype of elements not satisfying `p`). This means that inside the subset where `p` is not satisfied, the combined permutation acts exactly as `en`.

For any type `ε`, predicate `p` on `ε`, permutations `ep` on elements of `p` and `en` on elements of `¬p`, and element `a` not in `p`, `Equiv.Perm.subtypeCongr.right_apply ep en a = en a`.


theorem ENNReal.iSup_zero_eq_zero : ∀ {ι : Sort u_1}, ⨆ x, 0 = 0 := by sorry

This theorem states that for all types `ι`, the supremum (least upper bound) of the set where each element is `0` is `0`. In other words, when you have a set where all elements are `0`, the least upper bound of this set is also `0`.

For any type `ι`, the supremum of the set of all `ι`-valued elements equal to 0 is 0.


theorem Mathlib.Probability.Process.Stopping._auxLemma.23 :
    ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) := by sorry

This theorem states that for any type `α`, any element `x` of that type, and any two sets `a` and `b` of that type, the statement "x is in the intersection of a and b" is equivalent to the statement "x is in a and x is in b". In other words, an element belongs to the intersection of two sets if and only if it belongs to both of these sets.

For any type `α` and sets `a` and `b` of type `α`, `x ∈ a ∧ x ∈ b` if and only if `x ∈ a ∩ b`.


theorem continuous_sub_right :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G] (a : G),
      Continuous fun x => x - a :=
  by sorry

This theorem states that for any type `G` that has a topological space structure, a subtraction operation, and for which subtraction is continuous, and for any element `a` of type `G`, the function that subtracts `a` from its argument is a continuous function. In mathematical terms, if you consider a topological space `G` with a defined subtraction operation that is continuous, then for any fixed `a` in `G`, the function `f(x) = x - a` is also continuous.

For any topological space `G` equipped with a continuous subtraction operation, the function `x ↔ x - a` is continuous for all `a` in `G`.


theorem Set.compl_Ioi : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, (Set.Ioi a)ᶜ = Set.Iic a := by sorry

This theorem states that for any type `α` with a linear order and any element `a` of type `α`, the complement of the set of elements greater than `a` (denoted as `Set.Ioi a`) is equal to the set of elements that are less than or equal to `a` (denoted as `Set.Iic a`). In other words, in a linearly ordered set, every element not in the set of those strictly greater than a certain value is either equal to or less than that value.

In a linearly ordered set, the complement of the set of elements strictly greater than a given element is equal to the set of elements less than or equal to that element.


theorem Finset.disjoint_sdiff : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s (t \ s) := by sorry

This theorem states that for any given type `α` with decidable equality, and for any two finite sets `s` and `t` of this type, `s` and the set difference of `t` and `s` (i.e., `t \ s`) are disjoint. In other words, there are no elements in common between `s` and the set of elements in `t` that are not in `s`. This is a universal statement that holds for all `α`, `s`, and `t` of the specified types. In terms of lattice theory, this means that the infimum (greatest lower bound) of `s` and `t \ s` is the bottom element of the lattice, indicating that these two sets have no elements in common.

For any type `α` with decidable equality, and for any finite sets `s` and `t` of this type, `s` and `t \ s` are disjoint. (In lattice theory, the infimum of `s` and `t \ s` is the bottom element.)


theorem Set.finite_Icc :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : α), Set.Finite (Set.Icc a b) := by sorry

The theorem `Set.finite_Icc` states that for any given type `α` with a preorder (that is, a binary relation that is reflexive and transitive) and a locally finite order (an order with finitely many elements between any two elements), the closed interval `[a, b]` (denoted as `Set.Icc a b`), with `a` and `b` being elements of `α`, is a finite set. This means there exists a natural number `n` such that there is an equivalence between the interval `[a, b]` and the set of first `n` natural numbers (including 0).

For any type `α` with a preorder and locally finite order, the closed interval `[a, b]` in `α` is a finite set.


theorem Set.toFinset_image2 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] (f : α → β → γ) (s : Set α) (t : Set β)
      [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t] [inst_3 : Fintype ↑(Set.image2 f s t)],
      Set.toFinset (Set.image2 f s t) = Finset.image₂ f (Set.toFinset s) (Set.toFinset t) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ` with `γ` having a decidable equality, and for all functions `f` from `α` and `β` to `γ`, and sets `s` of `α` and `t` of `β`, given that `s`, `t`, and the image of the binary function `f` on `s` and `t` are finite, the finset constructed from the image of `f` on `s` and `t` is equal to the image of the binary function `f` on the finsets constructed from `s` and `t`. In mathematical terms, this can be interpreted as the image of a binary function on two sets being the same as the image of the function on the corresponding finite sets.

Given types `α`, `β`, and `γ` with decidable equality, finite sets `s` of `α` and `t` of `β`, and a function `f` from `α` and `β` to `γ`, the image of `f` on the finsets `s` and `t` is equal to the finset of `γ` obtained by applying `f` to each element in the Cartesian product `s × t`.


/-- Given a Localization map `f : M →* N` for a Submonoid `S ⊆ M` and a map of `CommMonoid`s
`g : M →* P` such that `g y` is invertible for all `y : S`, the homomorphism induced from
`N` to `P` maps `f x * (f y)⁻¹` to `g x * (g y)⁻¹` for all `x : M, y ∈ S`.  -/
theorem Submonoid.LocalizationMap.lift_mk' :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
      [inst_2 : CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (x : M)
      (y : ↥S),
      (Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.mk' f x y) =
        g x * ↑((IsUnit.liftRight (MonoidHom.restrict g S) hg) y)⁻¹ :=
  by sorry

This theorem states that for a given localization map `f` from a commutative monoid `M` to `N` with respect to a submonoid `S` of `M`, and a monoid homomorphism `g` from `M` to another commutative monoid `P` such that `g` maps each element of `S` to a unit in `P`, then the induced homomorphism from `N` to `P` maps each element expressed as `f(x) * (f(y))⁻¹` to `g(x) * (g(y))⁻¹` for all `x` in `M` and `y` in `S`. Here, `f(x)` and `g(x)` represent the image of an element `x` under the maps `f` and `g`, respectively, and `(f(y))⁻¹` and `(g(y))⁻¹` represent the inverse of `f(y)` and `g(y)`, respectively.

For a commutative monoid homomorphism g from a commutative monoid M to another commutative monoid P, and a localization map f from M to N with respect to a submonoid S of M such that each element of S is mapped to a unit in P by g, the induced homomorphism from N to P maps f(x) * f(s)⁻¹ to g(x) * g(s)⁻¹ for all x in M and s in S.


theorem Equiv.congr_fun : ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, f = g → ∀ (x : α), f x = g x := by sorry

The theorem `Equiv.congr_fun` states that for any two equivalent relations `f` and `g` between sorts `α` and `β`, if `f` equals `g`, then for any element `x` of type `α`, the application of `f` to `x` is equal to the application of `g` to `x`. In other words, it asserts that if two equivalence relations are the same, then their action on any element of the source sort is also the same.

For any equivalence relations `f` and `g` between sorts `α` and `β`, if `f = g`, then `f x = g x` for all `x : α`.


theorem ENNReal.tendsto_nhds_top_iff_nnreal :
    ∀ {α : Type u_1} {m : α → ENNReal} {f : Filter α},
      Filter.Tendsto m f (nhds ⊤) ↔ ∀ (x : NNReal), ∀ᶠ (a : α) in f, ↑x < m a :=
  by sorry

This theorem states that for any type `α`, a function `m` from `α` to the extended nonnegative real numbers (`ENNReal`), and a filter `f` on `α`, the function `m` converges to infinity with respect to the filter `f` (denoted as `Filter.Tendsto m f (nhds ⊤)`) if and only if for every nonnegative real number `x`, eventually (for all elements `a : α` in the filter `f`), the real number `x` is less than the output of the function `m` at `a` (expressed as `↑x < m a`). Here, 'eventually' is a concept in filter theory, meaning that the statement holds true at least from a certain point onwards in the filter. The `↑x` notation is used to denote the embedding of the nonnegative real number `x` into the extended nonnegative real numbers.

A function from a type to extended nonnegative real numbers converges to infinity with respect to a filter if and only if for every non-negative real number, there exists a filter element such that the function value at that element is strictly greater than the number.


theorem Polynomial.div_def :
    ∀ {R : Type u} [inst : Field R] {p q : Polynomial R},
      p / q = Polynomial.C (Polynomial.leadingCoeff q)⁻¹ * (p /ₘ (q * Polynomial.C (Polynomial.leadingCoeff q)⁻¹)) :=
  by sorry

This theorem states that for any field `R` and any polynomials `p` and `q` over `R`, the quotient of `p` divided by `q` equals the constant polynomial of the inverse of the leading coefficient of `q` times the pseudoquotient of `p` and the product of `q` and the constant polynomial of the inverse of the leading coefficient of `q`. In other words, the theorem gives a definition of polynomial division in terms of the inverse of the leading coefficient of the divisor and pseudo-division (`/ₘ` is the notation for pseudo-division in Lean 4).

For any field `R` and polynomials `p` and `q` over `R` with non-zero leading coefficients, `p / q = (lc(q)⁻¹ * p) /ₘ (lc(q) * q)`, where `lc` denotes the leading coefficient and `/ₘ` represents pseudo-division.


theorem tendsto_swap_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α], Filter.Tendsto Prod.swap (uniformity α) (uniformity α) := by sorry

The theorem `tendsto_swap_uniformity` states that for any given type `α` that has a `UniformSpace` structure, the function `Prod.swap` (which swaps the elements of a pair) exhibits a "limit" behavior with respect to the uniformity filter on `α × α`. This means that for every subset of `α × α` that is considered "near" under the uniformity filter, its preimage under `Prod.swap` is also "near" under the uniformity filter. In other words, if a pair of elements is close in the uniformity sense, swapping them does not change their closeness. This suggests a symmetry property in the uniformity structure of the space.

For any uniform space `α`, the `Prod.swap` function preserves the uniformity relation: for all `x` and `y` in `α × α`, if `x` is uniformly close to `y`, then `Prod.swap x` is uniformly close to `Prod.swap y`.


theorem max_rec' : ∀ {α : Type u} [inst : LinearOrder α] {x y : α} (p : α → Prop), p x → p y → p (max x y) := by sorry

This theorem, `max_rec'`, is a universal property of the maximum of two elements in a linearly ordered type. It states that for any type `α` whose elements are linearly ordered and for any two elements `x` and `y` of that type, if a property `p` holds for both `x` and `y`, then the same property `p` also holds for the maximum of `x` and `y`. In other words, if `p` is true for `x` and `y`, then `p` is true for `max x y`.

For all linearly ordered types `α` and elements `x` and `y` of `α`, if a property `p` holds for both `x` and `y`, then `p` holds for their maximum `max x y`.


Inducing.comp

theorem Inducing.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z], Inducing g → Inducing f → Inducing (g ∘ f) :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z`, and two functions `f : X → Y` and `g : Y → Z`, given that the topological spaces on `X`, `Y`, and `Z` are defined, if `g` is an inducing function (preserves the topology) and `f` is also an inducing function, then the composition of `g` and `f` (denoted as `g ∘ f`) is also an inducing function. The theorem thus establishes the transitivity of inducing functions in a topological context.

If functions `f : X → Y` and `g : Y → Z` are indising functions between topological spaces `X`, `Y`, and `Z` respectively, then their composition `g ∘ f` is also an inducing function between `X` and `Z`.


theorem Finset.exists_ne_zero_of_sum_ne_zero :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f : α → β} [inst : AddCommMonoid β],
      (Finset.sum s fun x => f x) ≠ 0 → ∃ a ∈ s, f a ≠ 0 :=
  by sorry

This theorem states that for any types α and β, and for any finite set `s` of type α and function `f` from α to β, if the sum of the values of `f` over all elements in `s` is not equal to zero (where the sum and zero are defined with respect to an additive commutative monoid structure on β), then there exists an element `a` in `s` such that the value of `f` at `a` is not equal to zero.

If `f` is a function from a finite set `s` in type α to type β with non-zero sum, then there exists an element `a` in `s` such that `f a ≠ 0`.


theorem Metric.mem_sphere :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, y ∈ Metric.sphere x ε ↔ dist y x = ε := by sorry

This theorem states that for any type `α` that has a pseudometric space structure, any two elements `x` and `y` of `α`, and any real number `ε`, `y` belongs to the sphere with center `x` and radius `ε` if and only if the distance between `y` and `x` equals `ε`. In other words, it establishes the condition for an element `y` to be a part of the sphere defined around `x` with radius `ε` in the context of a pseudometric space.

In a pseudometric space, an element belongs to the sphere around another element with a given radius if and only if the distance between them equals the radius.


theorem Finset.card_vadd_finset :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β] (a : α)
      (s : Finset β), (a +ᵥ s).card = s.card :=
  by sorry

This theorem, `Finset.card_vadd_finset`, states that for any type `α` which is an additive group, and any type `β` which is a set on which `α` acts additively, and for which equality is decidable, the cardinality of the set that results from vector addition of an element `a` of `α` with all elements of a finite set `s` of `β` is the same as the cardinality of the original set `s`. In other words, adding a group element to every member of a finite set does not change the size of the set.

For any additive group `α`, set `β` on which `α` acts additively with decidable equality, and finite set `s` in `β`, the cardinality of `s` is equal to the cardinality of `{a + b | a ∈ s, b ∈ β}`, where `+` denotes vector addition.


theorem invOf_two_smul_add_invOf_two_smul :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Invertible 2] (x : M), ⅟2 • x + ⅟2 • x = x :=
  by sorry

This theorem states that for any semiring `R` and any commutative monoid `M` that also respects the scalar multiplication (thus forming a module), if 2 is invertible in `R`, then the sum of one-half of any element `x` in `M` with itself is equal to `x`. In more mathematical terms, it states that for any `x` in `M`, `½x + ½x = x`. This confirms the distributive law for scalar multiplication in the context of modules.

For any semiring `R` and commutative monoid `M` forming an `R`-module with invertible 2, the element `½x` satisfies `½x + ½x = x` for all `x` in `M`.


theorem Basis.total_repr :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M) (x : M), (Finsupp.total ι M R ⇑b) (b.repr x) = x :=
  by sorry

The theorem `Basis.total_repr` states that for any `ι` which is a type, `R` which is a type of semiring, and `M` which is a type of additively commutative monoid that is also a module over `R`, given any basis `b` of `M` over `R`, and any element `x` of `M`, the total function applied to the basis representation of `x` equals `x` itself. In mathematical terms, it states that given a basis of a vector space, any vector in the space can be represented as a linear combination of basis vectors, and applying the total function recovers the original vector.

Given a semiring `R`, a type `M` of additively commutative `R`-module, a basis `b` of `M`, and any element `x` in `M`, the application of the total function to the basis representation of `x` equals `x`.


theorem Multiset.sections_cons :
    ∀ {α : Type u_1} (s : Multiset (Multiset α)) (m : Multiset α),
      Multiset.Sections (m ::ₘ s) = Multiset.bind m fun a => Multiset.map (Multiset.cons a) (Multiset.Sections s) :=
  by sorry

The theorem `Multiset.sections_cons` states that for any type `α`, and for any multisets `s` of multisets of `α` and `m` of `α`, the sections of the multiset formed by prepending `m` to `s` is equal to the multiset obtained by binding `m` with a function that maps each element `a` of `m` to the multiset obtained by prepending `a` to each element of the sections of `s`. In other words, it tells us how the sections operation behaves when a new multiset is added to the front of a multiset of multisets.

For any type `α` and multisets `s` of multisets and `m` of elements of `α`, the sections of the multiset formed by prepending `m` to `s` is equal to the multiset obtained by binding `m` to a function that maps each element to the multiset obtained by prepending that element to each element of the sections of `s` (i.e., `Multiset.sections (multiset.cons s m) = multiset.bind m (λ a, Multiset.sections (multiset.map (λ s, multiset.cons s a) (Multiset.sections s)))`).


theorem ZFSet.IsTransitive.subset_of_mem : ∀ {x y : ZFSet}, ZFSet.IsTransitive x → y ∈ x → y ⊆ x := by sorry

This theorem states that for any two sets `x` and `y` in the Zermelo-Fraenkel universe, if `x` is a transitive set (meaning every element of `x` is a subset of `x`) and `y` is an element of `x`, then `y` is a subset of `x`. In other words, if a set belongs to a transitive set, it is also a subset of that transitive set.

If `x` is a transitive set and `y` is an element of `x`, then `y` is a subset of `x`.


theorem Finset.card_image₂_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      (Finset.image₂ f s t).card = s.card * t.card ↔ Set.InjOn (fun x => f x.1 x.2) (↑s ×ˢ ↑t) :=
  by sorry

The theorem `Finset.card_image₂_iff` states that for any types α, β, and γ with decidable equality over γ, any binary function `f` from α and β to γ, and any finite sets `s` of α and `t` of β, the cardinality of the image of the function `f` over `s` and `t` is equal to the product of the cardinalities of `s` and `t` if and only if the function `f` is injective on the cartesian product of `s` and `t`. In simpler terms, if every unique pair of elements from `s` and `t` maps to a unique value in γ (i.e., `f` doesn't map any two different pairs to the same value), then the total number of such unique values is exactly the number of elements in `s` times the number of elements in `t`.

The cardinality of the image of a function from two finite sets to a type with decidable equality is equal to the product of their cardinalities if and only if the function is injective on their cartesian product.


theorem HahnSeries.SummableFamily.finite_co_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R] {α : Type u_3}
      (s : HahnSeries.SummableFamily Γ R α) (g : Γ), Set.Finite (Function.support fun a => (s a).coeff g) :=
  by sorry

This theorem states that for any summable family `s` of Hahn series, indexed by a type `α`, where each series has coefficients from an additive commutative monoid `R` and its index set is ordered by a partial order `Γ`, and for any index `g` from `Γ`, the set of indices `a` from `α` for which the coefficient of `g` in the series `s a` is non-zero is finite. In other words, only finitely many series in the summable family have a non-zero coefficient at a given index.

For any summable family of Hahn series indexed by a type with a partial order, indexed by an additive commutative monoid, only finitely many series have a non-zero coefficient at any given index.


theorem Polynomial.eval₂_map :
    ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
      [inst_2 : Semiring T] (g : S →+* T) (x : T),
      Polynomial.eval₂ g x (Polynomial.map f p) = Polynomial.eval₂ (RingHom.comp g f) x p :=
  by sorry

The theorem `Polynomial.eval₂_map` states that for any polynomial `p` over a semiring `R`, and ring homomorphisms `f : R → S` and `g : S → T` between semirings `R, S, T`, the evaluation of the `f`-mapped polynomial at a point `x` in `T` using `g` is equal to the evaluation of the original polynomial at `x` using the composition of the homomorphisms `g` and `f`. In more mathematical terms, it essentially states that $(g \circ f)(p(x)) = g(f(p(x)))$ for all `x` in `T`, where `$\circ$` denotes function composition.

For any polynomial `p` over a semiring `R`, and ring homomorphisms `f : R → S` and `g : S → T`, the evaluation of `g(f(p(x)))` is equal to `p(x)` for all `x` in `T`.


theorem biInf_mono :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {p q : ι → Prop},
      (∀ (i : ι), p i → q i) → ⨅ i, ⨅ (_ : q i), f i ≤ ⨅ i, ⨅ (_ : p i), f i :=
  by sorry

This theorem states that for any completely ordered lattice of type α and any function `f` from `ι` to `α`, if `p` is a predicate on `ι` and `q` is another predicate on `ι` such that every element that satisfies `p` also satisfies `q`, then the infimum of `f` over all elements satisfying `q` is greater than or equal to the infimum of `f` over all elements satisfying `p`. The infimum is a notion of the minimal value that `f` can take, considering the constraints posed by `q` and `p`. In simple terms, if `q` is a broader condition than `p` (i.e., more elements satisfy `q`), then the smallest value that `f` can take under `q` cannot be smaller than the smallest value under `p`.

For any completely ordered lattice α and function f from ι to α, if p and q are predicates on ι with p implying q, then the infimum of f over elements satisfying q is greater than or equal to the infimum of f over elements satisfying p.


theorem Int.lt_ceil :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, z < ⌈a⌉ ↔ ↑z < a := by sorry

This theorem, `Int.lt_ceil`, states that for any integer `z` and any number `a` of a certain type `α` (where `α` is a type that forms a linear ordered ring and also has a floor ring structure), `z` is less than the ceiling of `a` if and only if the real number equivalent of `z` is less than `a`. In other words, it establishes a relationship between the integer less-than operation and the real number less-than operation when dealing with the ceiling function.

For any integer `z` and real number `a` from a type `α` that is a linear ordered ring with a floor ring structure, `z < ceil a` if and only if `to_real z < a`.


theorem Finset.ne_empty_of_mem : ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ s → s ≠ ∅ := by sorry

This theorem states that for any type `α`, given an element `a` of type `α` and a finite set `s` of elements of type `α`, if `a` is a member of `s`, then `s` cannot be an empty set. This is a fundamental property of sets, as an empty set by definition contains no elements. Therefore, the presence of at least one element is sufficient to establish that a set is not empty.

For any type `α` and finite set `s` of elements of type `α`, if `a` is an element of `s`, then `s` is non-empty.


/-- Deprecated: use `DFunLike.congr_arg` instead. -/
theorem AddMonoidHom.congr_arg :
    ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) {x y : M},
      x = y → f x = f y :=
  by sorry

This theorem states that if two elements `x` and `y` of an additive monoid `M` are equal, then their images under any additive monoid homomorphism `f` from `M` to another additive monoid `N` are also equal. In other words, an additive monoid homomorphism preserves equality of elements. Please note that this theorem has been deprecated and `DFunLike.congr_arg` should be used instead.

If `f` is an additive monoid homomorphism between additive monoids `M` and `N`, and `x = y` in `M`, then `f x = f y` in `N`.


theorem PFunctor.map_eq :
    ∀ (P : PFunctor.{u}) {α : Type v₁} {β : Type v₂} (f : α → β) (a : P.A) (g : P.B a → α),
      PFunctor.map P f { fst := a, snd := g } = { fst := a, snd := f ∘ g } :=
  by sorry

The theorem `PFunctor.map_eq` states that for any PFunctor `P`, for types `α` and `β`, and for any function `f` from `α` to `β`, `a` from the object set of `P` and `g` from the morphism set of `P` to `α`, the application of the `PFunctor.map` operation to these parameters will result in a pair whose first element is `a` and whose second element is the composition of `f` and `g`. In other words, `PFunctor.map` applies the function `f` to the second element of the pair produced by `g`, while leaving the first element `a` unchanged.

For any PFunctor `P`, any function `f: α → β`, any object `a` in `P α`, and any morphism `g: β → α` in `P`, `PFunctor.map f g (a, x) = (a, f x)`.


Filter.HasBasis.smallSets

theorem Filter.HasBasis.smallSets :
    ∀ {α : Type u_1} {ι : Sort u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → Filter.HasBasis (Filter.smallSets l) p fun i => 𝒫 s i :=
  by sorry

This theorem states that for any type `α`, for any filter `l` on α, and any function `p` from a certain sort `ι` to propositions and another function `s` from the same sort `ι` to sets of α, if the filter `l` has a basis defined by `p` and `s` then the filter of all small sets of `l` (i.e., `Filter.smallSets l` which is defined as the largest filter containing all powersets of members of `l`), also has a basis defined by `p` and the function that maps `i` in `ι` to the powerset of `s i`. Here, `𝒫 s i` denotes the powerset of the set `s i`.

In simpler terms, the theorem says that if you can describe a filter `l` using some property and a set of basis, then you can also describe the filter of all small sets or subcollections of `l` using the same property and the powersets of the same set of basis.

Given a filter `l` on type `α` with basis `(p : ι → Prop)` and `(s : ι → Set α)`, the filter of small sets `Filter.smallSets l` has basis `(p : ι → Prop)` and the function mapping `i` to the powerset `𝒫 (s i)`.


theorem floorDiv_of_nonpos :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : FloorDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌊/⌋ a = 0 :=
  by sorry

This theorem, `floorDiv_of_nonpos`, states that for any types `α` and `β` where `α` is an ordered additive commutative monoid, `β` is also an ordered additive commutative monoid, `α` is a scaled multiplication zero class, and `α` has a floor division operation, if a value `a` of type `α` is less than or equal to zero, then the floor division of any value `b` of type `β` by `a` is always equal to zero.

For ordered additive commutative monoids `α` and `β`, if `α` is a scaled multiplication zero class with floor division, and `a` is a value in `α` less than or equal to zero, then for all `b` in `β`, the floor division `b ⊥ a` equals zero.


theorem Set.iUnion_iUnion_eq_right :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : (x : β) → b = x → Set α}, ⋃ x, ⋃ (h : b = x), s x h = s b ⋯ := by sorry

This theorem states that for any types `α` and `β`, any element `b` of type `β`, and any function `s` that assigns to each element `x` of type `β` and proof `h` that `b = x`, a set of elements of type `α`, the union over all `x` of the union over all proofs `h` that `b = x` of the set `s x h` is equal to the set `s b _`. In layman terms, it's saying that if we have a collection of sets indexed by elements of type `β` and proofs that these elements are equal to a fixed element `b`, then taking the union of these sets is the same as just considering the set corresponding to the element `b` itself.

For any types `α` and `β`, any element `b` of type `β`, and any function `s` from `β × Prop` to `Set α`, the set `{x : β | ∃ (h : b = x), x ∈ s x h}` is equal to `s b _`.


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

This theorem states that for all types `α`, `E`, and `F` where `E` and `F` have a norm, given a real number `c` and two functions `f` and `g` from `α` to `E` and `F` respectively, and a filter `l` on `α`. If it is the case that for all `x` in `α`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`, then `f` is big O of `g` with constant `c` at filter `l`. In other words, the output of function `f` is asymptotically bounded by `c` times the output of function `g` modulo division by zero issues.

Given types `α`, `E`, and `F` with norms, and functions `f : α → E` and `g : α → F`, if for all `x` in `α`, `||f x|| ≤ c * ||g x||`, then `f` is big O of `g` with constant `c` in the filter topology.


theorem List.Perm.prod_eq :
    ∀ {α : Type u_1} [inst : CommMonoid α] {l₁ l₂ : List α}, List.Perm l₁ l₂ → List.prod l₁ = List.prod l₂ := by sorry

The theorem `List.Perm.prod_eq` states that for any type `α` which is a commutative monoid, if two lists `l₁` and `l₂` of type `α` are permutations of each other, then the product of all elements in `l₁` equals the product of all elements in `l₂`. Here, the product of a list is defined as a sequential multiplication of all elements in the list, starting from 1.

For any commutative monoid type `α`, if two lists `l₁` and `l₂` of type `α` are permutations of each other, then the product of their elements is equal.


theorem Nat.bit1_val : ∀ (n : ℕ), bit1 n = 2 * n + 1 := by sorry

The theorem `Nat.bit1_val` states that for any natural number `n`, the `bit1` function applied to `n` equals `2 * n + 1`. The `bit1` function here is defined as adding 1 to the double of a given number. Thus, this theorem is simply characterizing the action of the `bit1` function in terms of multiplication and addition on natural numbers.

For any natural number `n`, `bit1 (2 * n) = 2 * n + 1`. In Lean, this is expressed as the theorem `Nat.bit1_val : ∀ n : Nat, Bit1 (2 * n) = 2 * n + 1`.


theorem MvPolynomial.bind₂_C_right :
    ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      (f : R →+* MvPolynomial σ S) (r : R), (MvPolynomial.bind₂ f) (MvPolynomial.C r) = f r :=
  by sorry

The theorem `MvPolynomial.bind₂_C_right` states that for any types `σ`, `R`, and `S` with `R` and `S` being commutative semirings, and for any ring homomorphism `f` from `R` to multivariate polynomials over `σ` and `S`, then binding `f` to the constant polynomial with value `r` in `R` results in the application of `f` to `r`. In other words, the bind operation on a constant multivariate polynomial effectively applies the ring homomorphism directly to the constant value.

For any commutative semirings R and S, ring homomorphism f from R to multivariate polynomials over σ and S, and constant r in R, we have f (r) = bind₂ f (constant r).


theorem Ideal.mul_le :
    ∀ {R : Type u} [inst : CommSemiring R] {I J K : Ideal R}, I * J ≤ K ↔ ∀ r ∈ I, ∀ s ∈ J, r * s ∈ K := by sorry

This theorem states that for any given type `R` with a commutative semiring structure, and for any three ideals `I`, `J`, and `K` in `R`, the product of the ideals `I` and `J` is a subset of the ideal `K` if and only if for every element `r` in `I` and every element `s` in `J`, the product `r * s` belongs to `K`. Here, an ideal is a specific type of additive submonoid in a semiring, which becomes an additive subgroup if the semiring is a ring.

For ideals I, J, and K in a commutative semiring R, I \* J ⊆ K if and only if for all r ∈ I and s ∈ J, r \* s ∈ K.


theorem Polynomial.erase_def :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (x : Polynomial R),
      Polynomial.erase n x =
        match x with
        | { toFinsupp := p } => { toFinsupp := Finsupp.erase n p } :=
  by sorry

This theorem is about the erasure of a term in a polynomial. Specifically, for any semiring `R`, natural number `n`, and polynomial `x` over `R`, the function `Polynomial.erase n x` is equal to the polynomial derived by erasing the `n`th term from the finitely supported function representation of `x`. In other words, the erasure of the `X^n` term in the polynomial `x` produces a new polynomial which is identical to `x` except that the coefficient of `X^n` is now zero.

For any semiring `R`, natural number `n`, and polynomial `x` over `R`, the polynomial `Polynomial.erase n x` equals `x` with the coefficient of `X^n` replaced by zero.


theorem Subalgebra.sub_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
      {x y : A}, x ∈ S → y ∈ S → x - y ∈ S :=
  by sorry

This theorem states that for any commutative ring `R` and any ring `A`, where `A` is an algebra over `R`, and `S` is a subalgebra of `A`, if `x` and `y` are elements of `S`, then the difference of `x` and `y` (denoted as `x - y`) is also an element of `S`. In other words, the difference of any two elements in a subalgebra of an algebra remains within that subalgebra.

If `R` is a commutative ring, `A` is an algebra over `R`, and `S` is a subalgebra of `A`, then for all `x, y ∈ S`, `x - y ∈ S`.


theorem MeasureTheory.absolutelyContinuous_inv :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : MeasurableMul₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableInv G]
      [inst_5 : MeasureTheory.Measure.IsMulLeftInvariant μ],
      MeasureTheory.Measure.AbsolutelyContinuous μ (MeasureTheory.Measure.inv μ) :=
  by sorry

The theorem `MeasureTheory.absolutelyContinuous_inv` states that for any measurable space `G` with a group structure, which additionally has a measurable two-sided multiplication and measurable inversion, and for any σ-finite measure `μ` on this space that is left multiplication invariant, `μ` is absolutely continuous with respect to its inversion, `μ.inv`. In other words, if for any set `A`, the measure of the inverse set `A⁻¹` with respect to `μ` is zero, then the measure of `A` with respect to `μ` is also zero.

If `μ` is a left multiplication-invariant, σ-finite measure on a measurable group `G` with measurable two-sided multiplication and measurable inversion, then `μ` is absolutely continuous with respect to its inversion `μ.inv`, i.e., `μ(A) = 0` if and only if `μ.inv(A⁻¹) = 0`.


theorem IsFractionRing.mk'_num_den :
    ∀ (A : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : UniqueFactorizationMonoid A] {K : Type u_5}
      [inst_3 : Field K] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K] (x : K),
      IsLocalization.mk' K (IsFractionRing.num A x) (IsFractionRing.den A x) = x :=
  by sorry

The theorem `IsFractionRing.mk'_num_den` states that for any type `A` which is a commutative ring, an integral domain, and a unique factorization monoid, and any field `K` which is an algebra over `A` and also the field of fractions of `A`, for any element `x` of `K`, applying the function `IsLocalization.mk'` to the numerator (`IsFractionRing.num A x`) and the denominator (`IsFractionRing.den A x`) of `x` will yield `x` itself. In other words, every element of the field `K` can be expressed as the fraction of its numerator and denominator, where the fraction is constructed by `IsLocalization.mk'`.

For any commutative ring A that is an integral domain and a unique factorization monoid, andany field K that is an algebra over A and the field of fractions of A, the application of `IsLocalization.mk'` to the numerator and denominator of any element x in K yields x itself.


EmbeddingLike.injective

theorem EmbeddingLike.injective :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F),
      Function.Injective ⇑f :=
  by sorry

This theorem states that for any types `F`, `α`, and `β`, if `F` is a `FunLike` type from `α` to `β` and an `EmbeddingLike` from `α` to `β`, then any term `f` of type `F` is injective. In other words, if `f` maps two elements of `α` to the same element of `β`, then these two elements were the same to begin with. This theorem, therefore, guarantees the injectivity of 'function-like' objects in a given context.

If `F` is a functor and an embedding from type `α` to type `β`, then any term `f` of type `F α β` is an injection.


theorem Set.preimage_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

This theorem states that, for all types `α`, `β`, `ι`, and `κ`, and for any function `f` mapping from `α` to `β`, and any function `s` mapping from `ι` to `κ`, the preimage of the union over `i` and `j` of the set `s i j` under the function `f` is equal to the union over `i` and `j` of the preimage of the set `s i j` under `f`.

In simpler terms, we are distributing the preimage operation over the union of sets, much in the same way we would distribute multiplication over addition in arithmetic.

For all types `α`, `β`, `ι`, `κ`, functions `f : α → β`, and `s : ι → κ`, the preimage of `(⋃ i, j : ι, s i j)` under `f` equals `⋃ i, j : ι, f⁻¹(s i j)`.


theorem Cardinal.cantorFunctionAux_false :
    ∀ {c : ℝ} {f : ℕ → Bool} {n : ℕ}, f n = false → Cardinal.cantorFunctionAux c f n = 0 := by sorry

The theorem `Cardinal.cantorFunctionAux_false` states that for all real numbers `c`, functions `f` from natural numbers to boolean values, and natural numbers `n`, if `f(n)` evaluates to `false`, then the value of the function `Cardinal.cantorFunctionAux` at `c`, `f`, and `n` is zero. In other words, if the boolean function `f` returns `false` when applied to a natural number `n`, the corresponding term in the summation of the Cantor function is zero.

If `f(n)` is false, then `Cardinal.cantorFunctionAux` at `c`, `f`, and `n` equals zero.


theorem sInf_image2_eq_sInf_sInf :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
      [inst_2 : CompleteLattice γ] {s : Set α} {t : Set β} {u : α → β → γ} {l₁ : β → γ → α} {l₂ : α → γ → β},
      (∀ (b : β), GaloisConnection (l₁ b) (Function.swap u b)) →
        (∀ (a : α), GaloisConnection (l₂ a) (u a)) → sInf (Set.image2 u s t) = u (sInf s) (sInf t) :=
  by sorry

The theorem `sInf_image2_eq_sInf_sInf` states that for any types `α`, `β`, and `γ` that are complete lattices, any sets `s` and `t` of `α` and `β` respectively, and any binary function `u` from `α` and `β` to `γ`, if for each `b` in `β`, the function `l₁ b` and the function `u` with its arguments swapped form a Galois connection, and if for each `a` in `α`, the function `l₂ a` and the function `u` with `a` fixed form a Galois connection, then the infimum of the image of the binary function `u` over the sets `s` and `t` is equal to the value of the function `u` at the infimum of `s` and the infimum of `t`.

In simpler words, this theorem is about the relationship between a binary function applied to two sets and the infimum (greatest lower bound) of those sets. It says that under certain conditions (the Galois connections), the infimum of all function values is the same as the function value at the infimum of the sets.

If `u:` `α` x `β` -> `γ`, `s` a set of `α`, and `t` a set of `β` are such that for all `b` in `β`, the functions `l₁ b` and `u` with arguments swapped form a Galois connection, and for all `a` in `α`, the functions `l₂ a` and `u` with `a` fixed form a Galois connection, then `inf (map u s) = u (inf s inf t)`.