theorem iSup_inf_iSup :
    ∀ {α : Type u} [inst : Order.Frame α] {ι : Type u_1} {ι' : Type u_2} {f : ι → α} {g : ι' → α},
      (⨆ i, f i) ⊓ ⨆ j, g j = ⨆ i, f i.1 ⊓ g i.2 :=
  by sorry

This theorem states that for any two types `ι` and `ι'`, and any two functions `f` and `g` from these types to a type `α` that is equipped with a frame structure (an algebraic structure that generalizes both lattices and Heyting algebras), the supremum of the images of `f` and `g` (expressed as `(⨆ i, f i) ⊓ ⨆ j, g j`) is equal to the supremum of the infimum of the paired elements from `f` and `g` (expressed as `⨆ i, f i.1 ⊓ g i.2`). In simpler terms, it expresses a distributive property of the supremum and infimum operations in the context of certain algebraic structures.

For any types `ι`, `ι'`, and functions `f : ι -> α` and `g : ι' -> α` to a frame-structured type `α`, the supremum of `f` and `g` equals the supremum of the pairwise infima of `f(i)` and `g(j)`.


/-- The equivalence classes of the equivalence relation defined by a partition of α equal
the original partition.  -/
theorem Setoid.classes_mkClasses :
    ∀ {α : Type u_1} (c : Set (Set α)) (hc : Setoid.IsPartition c), Setoid.classes (Setoid.mkClasses c ⋯) = c := by
  sorry

This theorem states that, for any type 'α' and any set 'c' of sets of 'α' that forms a partition of 'α' (meaning that it divides 'α' into mutually exclusive, non-empty subsets), the equivalence classes generated by the equivalence relation defined by this partition are exactly equal to the original partitioning set 'c'. In other words, if we group elements of 'α' into equivalence classes based on the partition 'c', we end up with the same grouping as 'c'.

For any type 'α' and partition 'c' of 'α', the equivalence classes of 'α' under the equivalence relation defined by 'c' are exactly the sets in 'c'.


theorem EReal.range_coe_ennreal : Set.range ENNReal.toEReal = Set.Ici 0 := by sorry

This theorem states that the range of the function `ENNReal.toEReal`, which maps nonnegative extended real numbers to extended real numbers, is the set of all extended real numbers that are greater than or equal to zero. In other words, the function `ENNReal.toEReal` maps every nonnegative extended real number to an extended real number, such that the resulting set of values is exactly the set of all extended real numbers that are no less than zero.

The range of `ENNReal.toEReal` is the set of extended real numbers greater than or equal to zero.


theorem differentiableWithinAt_pi :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_6} [inst_3 : Fintype ι] {F' : ι → Type u_7}
      [inst_4 : (i : ι) → NormedAddCommGroup (F' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
      DifferentiableWithinAt 𝕜 Φ s x ↔ ∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => Φ x i) s x :=
  by sorry

The theorem `differentiableWithinAt_pi` states that for a given point `x` in a set `s` of type `E`, a function `Φ` from `E` to a finite indexed type `F'` is differentiable at `x` within the set `s` with respect to a nontrivially normed field `𝕜` if and only if, for each index `i`, the function formed by applying `Φ` at `x` and then selecting the `i`th element is also differentiable at `x` within the set `s` with respect to `𝕜`. Here `DifferentiableWithinAt 𝕜 Φ s x` and `DifferentiableWithinAt 𝕜 (fun x => Φ x i) s x` both checking the existence of a derivative at the point `x` within the set `s`.

A function `Φ` from a set `s` to a finite indexed type `F'` over a nontrivially normed field `𝕜` is differentiable at a point `x` within `s` if and only if the function formed by selecting the `i`th component of `Φ(x)` for each index `i` is also differentiable at `x` within `s`.


theorem Equiv.Perm.pow_apply_eq_self_of_apply_eq_self :
    ∀ {α : Type u_1} {f : Equiv.Perm α} {x : α}, f x = x → ∀ (n : ℕ), (f ^ n) x = x := by sorry

The theorem `'Equiv.Perm.pow_apply_eq_self_of_apply_eq_self'` states that for any type `α`, any bijection `f` from `α` to itself (an element of `Equiv.Perm α`), and any element `x` of `α`, if `f` applied to `x` gives `x` (i.e., `f x = x`), then for any natural number `n`, applying `f` `n` times to `x` (i.e., `(f ^ n) x`) also gives `x`. In other words, if a permutation leaves an element unchanged, then repeated application of the permutation any number of times will also leave the element unchanged.

If `f` is a bijection from a type `α` to itself and `f x = x` for some `x : α`, then `(f ^ n) x = x` for all natural numbers `n`.


theorem Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.3 :
    ∀ (x : NNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) := by sorry

The theorem `Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.3` states that for any nonnegative real number `x` and any real numbers `y` and `z`, the power of `x` raised to `y` to the power of `z` is the same as `x` to the power of the product of `y` and `z`. That is, $(x^y)^z = x^{y*z}$ for $x\geq 0$ and any real numbers $y$ and $z$. Here, `NNReal` stands for the set of nonnegative real numbers.

For any non-negative real number $x$ and real numbers $y$ and $z$, $(x^y)^z = x^{y\cdot z}$.


theorem Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.2 :
    ∀ {x : NNReal} {y : ℝ}, (x ^ y = 0) = (x = 0 ∧ y ≠ 0) := by sorry

This theorem states that for all nonnegative real numbers `x` and for all real numbers `y`, the proposition that `x` raised to the power `y` is equal to 0 is equivalent to the proposition that `x` is equal to 0 and `y` is not equal to 0. In mathematical notation, for all $x \in \text{NNReal}$ and $y \in \mathbb{R}$, $x^y = 0$ if and only if $x = 0$ and $y \neq 0$.

For all non-negative real numbers $x$ and real numbers $y$, $x^y = 0$ if and only if $x = 0$ and $y \neq 0$.


theorem MeasureTheory.condexp_of_sigmaFinite :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → F'} (hm : m ≤ m0)
      [hμm : MeasureTheory.SigmaFinite (μ.trim hm)],
      MeasureTheory.condexp m μ f =
        if MeasureTheory.Integrable f μ then
          if MeasureTheory.StronglyMeasurable f then f
          else MeasureTheory.AEStronglyMeasurable'.mk ↑↑(MeasureTheory.condexpL1 hm μ f) ⋯
        else 0 :=
  by sorry

The theorem `MeasureTheory.condexp_of_sigmaFinite` states that for any types `α` and `F'` with `α` being the type of outcomes and `F'` being a normed add commutative group that is also a normed space over the reals and complete space, given measurable spaces `m` and `m0`, a measure `μ` on `α`, and a function `f` from `α` to `F'`, if `m` is a sub σ-algebra of `m0` and `μ` is σ-finite with respect to `m`, then the conditional expectation of `f` with respect to `m` and `μ` is as follows:
If `f` is integrable with respect to `μ`, then if `f` is strongly measurable, the conditional expectation is `f` itself, otherwise it is a function that is `m`-strongly measurable and almost everywhere equal to `f`;
If `f` is not integrable, then the conditional expectation is `0`. Here, integrability of a function means that it is measurable and the integral of its norm is finite, and a function is strongly measurable if it is the limit of simple functions.

Given measurable spaces `(α, Σα)`, `(α', Σα')`, a σ-finite measure `μ` on `(α, Σα)`, a normed add commutative group `F'` being a normed space over the reals and complete, and a function `f : α → F'`, if `μ` is σ-finite with respect to the sub-σ-algebra `m ⊆ Σα'` and `f` is integrable with respect to `μ`, then the conditional expectation of `f` with respect to `m` is `f` itself if `f` is strongly measurable, or a function equal to `f` almost everywhere; otherwise, it is `0`.


theorem PadicInt.zmod_congr_of_sub_mem_span :
    ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] (n : ℕ) (x : ℤ_[p]) (a b : ℕ),
      x - ↑a ∈ Ideal.span {↑p ^ n} → x - ↑b ∈ Ideal.span {↑p ^ n} → ↑a = ↑b :=
  by sorry

The theorem `PadicInt.zmod_congr_of_sub_mem_span` states that for any natural number `p` which is a prime number, any natural number `n`, any p-adic integer `x`, and any two natural numbers `a` and `b`, if the difference of `x` and the integer representation of `a` belongs to the ideal generated by the set containing `p` raised to the power `n`, and similarly, the difference of `x` and the integer representation of `b` also belongs to the same ideal, then `a` and `b` are equal. In other words, if the differences between a p-adic integer and two natural numbers fall into the same ideal generated by a prime number to a certain power, these two numbers must be the same.

If two natural numbers `a` and `b` differ by an integer multiple of `p^n`, where `p` is a prime number and `n` is a natural number, then `a` and `b` are equal. (In the context of p-adic integers, the difference of `x` and the integer representation of `a` and `b` belong to the ideal generated by `p` raised to the power `n`.)


theorem and_false_iff : ∀ (p : Prop), p ∧ False ↔ False := by sorry

This theorem states that for any proposition `p`, the conjunction of `p` and `False` is logically equivalent to `False`. In other words, the statement "`p` and `False`" is always false, regardless of the truth value of `p`. This is a basic result in propositional logic, reflecting the fact that a conjunction is only true if both of its components are true.

For all propositions p, p and False are logically equivalent to False.


theorem Set.nonempty_of_mem : ∀ {α : Type u} {s : Set α} {x : α}, x ∈ s → Set.Nonempty s := by sorry

This theorem, `Set.nonempty_of_mem`, asserts that for any type `α`, any set `s` of type `α`, and any element `x` of type `α`, if `x` is an element of the set `s` (denoted by `x ∈ s`), then `s` is nonempty. In other words, if a set contains at least one element, then it is not an empty set. The theorem uses the `Set.Nonempty` property which is defined as the existence of at least one element in a set.

If a set is nonempty and contains an element `x`, then `x` belongs to the set. (Equivalently, if an element `x` belongs to a nonempty set `s`, then `s` is nonempty.)


theorem Polynomial.coe_C : ∀ {R : Type u_2} [inst : CommSemiring R] (a : R), ↑(Polynomial.C a) = (PowerSeries.C R) a :=
  by sorry

This theorem states that for any commutative semiring `R` and any element `a` from `R`, the result of applying the constant polynomial function `Polynomial.C` on `a` and then applying the coercion operation (denoted by ↑) is equal to the result of applying the constant power series function `PowerSeries.C` directly on `a`. In other words, the theorem asserts that the constant polynomial and the constant power series are semantically equivalent when operating on a given element from a commutative semiring.

For any commutative semiring `R` and its element `a`, the constant polynomial function `Polynomial.C a` and the constant power series function `PowerSeries.C a` are equal when coerced to the same type.


Dvd.dvd.pow

/-- **Alias** of `dvd_pow`. -/
theorem Dvd.dvd.pow : ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, a ∣ b → ∀ {n : ℕ}, n ≠ 0 → a ∣ b ^ n := by sorry

This theorem, named `Dvd.dvd.pow`, states that in any monoid, if an element `a` divides another element `b`, then `a` also divides any non-zero power of `b`. More formally, given a type `α` that forms a monoid, and two elements `a` and `b` of that type such that `a` divides `b`, for any natural number `n` that is not zero, `a` divides `b` to the power of `n`.

If `a` divides `b` in a monoid, then `a` raises to the power of any natural number `n` also divides `b` raised to the power of `n`.


theorem Cardinal.mk_range_le_lift :
    ∀ {α : Type u} {β : Type v} {f : α → β},
      Cardinal.lift.{u, v} (Cardinal.mk ↑(Set.range f)) ≤ Cardinal.lift.{v, u} (Cardinal.mk α) :=
  by sorry

This theorem states that for all types `α` and `β`, and any function `f` from `α` to `β`, the cardinality of the image of `f` when lifted to a higher universe (which is represented as `Cardinal.lift (Cardinal.mk ↑(Set.range f))`) is less than or equal to the cardinality of `α` lifted to a higher universe (represented by `Cardinal.lift (Cardinal.mk α)`). This essentially captures the mathematical concept that the size of the image of a function cannot exceed the size of its domain, even when considering cardinalities in different type universes.

For any function between types `α` and `β`, the cardinality of its image, lifted to a higher universe, is less than or equal to the cardinality of `α`, lifted to the same universe.


theorem differentiableWithinAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E}, DifferentiableWithinAt 𝕜 id s x :=
  by sorry

The theorem `differentiableWithinAt_id` states that, for every type `𝕜` that forms a nontrivially normed field, and any type `E` that has the structure of a normed additive commutative group and is a normed space over `𝕜`, the identity function `id` is differentiable at any point `x` within any set `s` of `E`. In mathematical terms, this means that the identity function is differentiable everywhere, i.e., its derivative exists at every point in its domain.

For every nontrivially normed field `𝕜` and normed additive commutative group `E` that is a normed space over `𝕜`, the identity function `id` is differentiable at every point `x` in `E`.


Filter.coext

/-- An extensionality lemma that is useful for filters with good lemmas about `sᶜ ∈ f` (e.g.,
`Filter.comap`, `Filter.coprod`, `Filter.Coprod`, `Filter.cofinite`).  -/
theorem Filter.coext : ∀ {α : Type u} {f g : Filter α}, (∀ (s : Set α), sᶜ ∈ f ↔ sᶜ ∈ g) → f = g := by sorry

The theorem, `Filter.coext`, is an extensionality lemma for filters in Lean 4. For any type `α` and any two filters `f` and `g` on `α`, it states that if for every set `s` of `α`, the complement of `s` belongs to `f` if and only if it belongs to `g`, then `f` and `g` are the same filter. This theorem can be particularly useful for filters such as `Filter.comap`, `Filter.coprod`, `Filter.Coprod`, and `Filter.cofinite`, which have good lemmas about the membership of a set's complement in the filter.

Two filters on a type `α` are equal if and only if their complements of sets have the same membership relation.


theorem MeasureTheory.tilted_zero_measure : ∀ {α : Type u_1} {mα : MeasurableSpace α} (f : α → ℝ), 0.tilted f = 0 := by
  sorry

This theorem states that for any type `α` and any measurable space `mα` over this type `α`, the measure zero 'tilted' by any real-valued function `f` from `α` remains zero. In other words, it asserts that applying the 'tilting' operation (a certain transformation in measure theory) to the zero measure, irrespective of the function used, results in the zero measure.

For any measurable space `(α, mα)` and measurable function `f: α → ℝ`, the tilted measure `mα' = mα ⊤ f` is zero.


theorem WithTop.coe_sSup' :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SupSet α] {s : Set α},
      BddAbove s → ↑(sSup s) = sSup ((fun a => ↑a) '' s) :=
  by sorry

This theorem states that for any set `s` of a type `α` which has a pre-order and a supremum operation defined on it, if `s` is bounded above, then the supremum (`sSup`) of the elements of `s` taken as elements of the type `WithTop α` (which includes an element "top" greater than all elements of `α`) is equal to the supremum of the set obtained by mapping each element of `s` to the corresponding element of `WithTop α`. In other words, taking the supremum after lifting to `WithTop α` gives the same result as lifting to `WithTop α` first and then taking the supremum, provided that `s` is bounded above.

If `s` is a bounded above set with a pre-order and supremum operation in type `α`, then the supremum of `s` in `WithTop α` is equal to the supremum of the images of `s` in `WithTop α`.


theorem Submodule.torsionBySet_le_torsionBySet_of_subset :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {s t : Set R}, s ⊆ t → Submodule.torsionBySet R M t ≤ Submodule.torsionBySet R M s :=
  by sorry

This theorem states that for any two sets `s` and `t` of scalars in a commutative semiring `R` and a module `M` over `R`, if `s` is a subset of `t`, then the submodule of `M` generated by the torsion elements with respect to `t` is a subset of, or equal to, the submodule generated by the torsion elements with respect to `s`. Here, a torsion element of `M` by a set of scalars is an element that is annihilated by every scalar in the set.

For any commutative semiring R and module M over R, if set s is a subset of set t of scalars, then the submodule of M generated by the torsion elements with respect to t is contained in, or equal to, the submodule generated by the torsion elements with respect to s.


theorem ULift.up_surjective : ∀ {α : Type u}, Function.Surjective ULift.up := by sorry

The theorem `ULift.up_surjective` states that for every type `α`, the function `ULift.up` is surjective. In other words, given any type `α`, for every `b` in the type `ULift α`, there exists an `a` in the original type `α` such that `ULift.up a = b`. Here, `ULift.up` is a function that takes a value of some type `α` and lifts it to a value of the type `ULift α`.

For every type `α`, the function `ULift.up` from `α` to `ULift α` is surjective.


SimpleGraph.ComponentCompl.nonempty

theorem SimpleGraph.ComponentCompl.nonempty :
    ∀ {V : Type u} {G : SimpleGraph V} {K : Set V} (C : SimpleGraph.ComponentCompl G K), Set.Nonempty ↑C := by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, and any set `K` of vertices in `V`, if `C` is the set of vertices that are in the connected component of the graph induced by the complement of `K` in `G` (denoted as `SimpleGraph.ComponentCompl G K`), then `C` is not an empty set (expressed as `Set.Nonempty ↑C`). In other words, there exists at least one vertex in the connected component of the graph outside the set `K`.

For any simple graph `G` of type `V` and any set `K` of vertices in `V` of `G`, the connected component of the complement of `K` in `G` is non-empty.


theorem Commute.mul_mul_mul_comm :
    ∀ {S : Type u_2} [inst : Semigroup S] {b c : S}, Commute b c → ∀ (a d : S), a * b * (c * d) = a * c * (b * d) := by
  sorry

The theorem `Commute.mul_mul_mul_comm` states that for any semigroup `S` and any two elements `b` and `c` in `S` that commute, for any additional elements `a` and `d` in `S`, the result of multiplying `a`, `b`, `c`, and `d` together in the order `a * b * (c * d)` is equal to the result of multiplying them in the order `a * c * (b * d)`. In other words, it establishes a specific form of associativity and commutativity in the multiplication of four elements when two of them commute.

For any semigroup `S` and commuting elements `b` and `c` in `S`, the order of multiplication of elements `a`, `b`, `c`, and `d` does not affect the result: `(a * b * (c * d)) = (a * c * (b * d))`.


theorem Bool.or_assoc : ∀ (a b c : Bool), (a || b || c) = (a || (b || c)) := by sorry

This theorem states that for all boolean variables `a`, `b`, and `c`, the operation of logical disjunction (`||`) is associative. In other words, the order in which the disjunctions are performed does not change the result. If we denote logical disjunction with the symbol $\vee$, this can be written in mathematical notation as $(a \vee b) \vee c = a \vee (b \vee c)$.

The logical disjunction operation is associative, that is, for all boolean variables `a`, `b`, and `c`, `(a || b) || c = a || (b || c)`.


theorem Set.preimage_id' : ∀ {α : Type u_1} {s : Set α}, (fun x => x) ⁻¹' s = s := by sorry

The theorem `Set.preimage_id'` states that for all sets `s` of any type `α`, the preimage of the set `s` under the identity function is the set `s` itself. In other words, if we apply the identity function to each element of the set `s` and collect the results, we end up with the same set `s`. This is a generalization of the well-known mathematical truth that the identity function leaves all elements unchanged.

For any set `s` and type `α`, the preimage of `s` under the identity function is equal to `s`.


/-- See also `Metric.measure_closedBall_pos_iff`.  -/
theorem Metric.measure_closedBall_pos :
    ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] (x : X) {r : ℝ}, 0 < r → 0 < ↑↑μ (Metric.closedBall x r) :=
  by sorry

The theorem `Metric.measure_closedBall_pos` states that for any pseudometric space `X`, given a measurable space `X`, a measure `μ` on it which is an open positive measure, and any point `x` in `X`, if `r` is a real number greater than 0, then the measure `μ` of the closed ball centered at `x` with radius `r` is also greater than 0. In other words, the measure of any non-empty closed ball in a pseudometric space with an open positive measure is always positive.

In a pseudometric space endowed with an open, positive measure, the measure of any non-empty closed ball is positive.


theorem Finsupp.single_le_iff :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : CanonicallyOrderedAddCommMonoid α] {i : ι} {x : α} {f : ι →₀ α},
      (fun₀ | i => x) ≤ f ↔ x ≤ f i :=
  by sorry

This theorem, `Finsupp.single_le_iff`, states that for any types `ι` and `α`, given the instance of `α` as a canonically ordered additive commutative monoid, and any element `i` of `ι`, `x` of `α`, and function `f` from `ι` to `α`, the function that maps `i` to `x` is less than or equal to `f` if and only if `x` is less than or equal to the value of `f` at `i`. In other words, a single element `x` is less than or equal to a function `f` if and only if `x` is less than or equal to the value of `f` at a specific point `i`.

For any type `ι`, `α` with `α` an ordered additive commutative monoid, and `i ∈ ι`, `x ∈ α`, and `f : ι → α`, `x ≤ f i` if and only if `f i ≤ x`.


theorem AddSubgroup.normal_addSubgroupOf_iff :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
      H ≤ K → (AddSubgroup.Normal (AddSubgroup.addSubgroupOf H K) ↔ ∀ (h k : G), h ∈ H → k ∈ K → k + h + -k ∈ H) :=
  by sorry

The theorem `AddSubgroup.normal_addSubgroupOf_iff` states that for any type `G` with an addition group structure and any subgroups `H` and `K` of `G`, if `H` is a subset of `K`, then the subgroup `H` is normal within `K` (viewed as a subgroup of `K`), if and only if for any elements `h` in `H` and `k` in `K`, the element resulting from the operation `k + h + -k` is also in `H`. Here, '+' denotes the addition operation in the group, and '-' denotes the additive inverse. This theorem thus establishes a criterion for normality of a subgroup within another subgroup in the context of additive groups.

A subgroup H of an additive group G is normal in another subgroup K if and only if for all h in H and k in K, k + h - k is in H.


theorem pow_right_mono : ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R}, 1 ≤ a → Monotone fun x => a ^ x := by
  sorry

The theorem `pow_right_mono` states that for all types `R`, where `R` is associated with an ordered semiring structure, and for any element `a` of type `R`, if `a` is greater than or equal to `1`, then the function that raises `a` to the power of any given number `x` is monotone. In mathematical terms, this means that for such `a` and any two numbers `x` and `y`, if `x ≤ y`, then `a^x ≤ a^y`.

For any ordered semiring `R` and `a` in `R` with `a ≥ 1`, the function `x => a^x` is monotone on `R`.


/-- This ext lemma closes trivial subgoals create when chaining heterobasic ext lemmas.  -/
theorem Algebra.ext_id :
    ∀ {R : Type u} (A : Type v) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (f g : R →ₐ[R] A),
      f = g :=
  by sorry

This theorem, `Algebra.ext_id`, states that for any given type `R` and `A`, where `R` is a commutative semiring and `A` is a semiring that also forms an algebra over `R`, for any two algebra homomorphisms `f` and `g` from `R` to `A`, `f` is equal to `g`. In other words, it asserts the uniqueness of algebra homomorphisms between two specific algebraic structures.

If `R` is a commutative semiring and `A` is an `R`-algebra, any two algebra homomorphisms from `R` to `A` are equal.


theorem Function.Semiconj.filter_map :
    ∀ {α : Type u} {β : Type v} {f : α → β} {ga : α → α} {gb : β → β},
      Function.Semiconj f ga gb → Function.Semiconj (Filter.map f) (Filter.map ga) (Filter.map gb) :=
  by sorry

The theorem `Function.Semiconj.filter_map` states that for any types `α` and `β`, and for any functions `f : α → β`, `ga : α → α`, and `gb : β → β`, if `f` semiconjugates `ga` to `gb` (meaning that applying `f` after `ga` is the same as applying `gb` after `f`), then the function that maps a filter through `f` also semiconjugates the function that maps a filter through `ga` to the function that maps a filter through `gb`. In other words, the property of semiconjugation is preserved when we move from the world of functions to the world of filter transformations.

If functions `f : α → β`, `ga : α → α`, and `gb : β → β` satisfy `ga ∘ f = f ∘ gb`, then `(filter.map f) (filter.map ga) = filter.map (gb ∘ f)`.


theorem of_irreducible_mul : ∀ {α : Type u_5} [inst : Monoid α] {x y : α}, Irreducible (x * y) → IsUnit x ∨ IsUnit y :=
  by sorry

This theorem states that for any type `α` where a monoid structure is defined, if the product of two elements 'x' and 'y' of `α` is irreducible (i.e., in the monoid, it cannot be factored into two non-unit elements), then either 'x' or 'y' must be a unit. A unit is an element that has a two-sided inverse in the monoid.

In a monoid, if the product of two irreducible elements is irreducible, then one of them is a unit.


Module.subsingleton

/-- A module over a `Subsingleton` semiring is a `Subsingleton`. We cannot register this
as an instance because Lean has no way to guess `R`.  -/
theorem Module.subsingleton :
    ∀ (R : Type u_9) (M : Type u_10) [inst : Semiring R] [inst_1 : Subsingleton R] [inst_2 : AddCommMonoid M]
      [inst : Module R M], Subsingleton M :=
  by sorry

This theorem states that if we have a module `M` over a semiring `R` and `R` is a `Subsingleton`, then `M` is also a `Subsingleton`. In other words, if there's only one unique element in the semiring `R`, then there can only be one unique element in the module `M` as well. However, this cannot be registered as an instance since Lean cannot guess `R`.

If `R` is a subsingleton semiring, then the module `M` over `R` has at most one element.


theorem AddSubmonoid.eq_bot_iff_forall :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M), S = ⊥ ↔ ∀ x ∈ S, x = 0 := by sorry

The theorem `AddSubmonoid.eq_bot_iff_forall` states that for any type `M` that has an addition operation and a zero element (i.e., for any `M` that is an instance of the `AddZeroClass`), a given additive submonoid `S` of `M` is equal to the bottom element (which represents the trivial submonoid containing only the zero element) if and only if every element `x` in `S` is equal to zero.

For any additive submonoid `S` of an additive semigroup `M` with zero element, `S` equals the bottom submonoid if and only if every element in `S` is equal to the zero element.


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

This theorem states that, for all types `α` and `β`, and a property `p` defined for elements of `β`, given a bijective function `f` that maps from `α` to `β`, the property `p` holds for all elements `x` of type `α` under the function `f` if and only if `p` holds for all elements `y` of type `β`. In other words, if every element from `α` when transformed to `β` via `f` satisfies `p`, it is equivalent to all elements in `β` satisfying `p`.

For any bijective function $f : \alpha \to \beta$ and property $p : \beta \to Prop$, $p(x) \iff p(f(x))$ for all $x : \alpha$.


theorem Set.preimage_mul_const_Ioi_of_neg :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) {c : α},
      c < 0 → (fun x => x * c) ⁻¹' Set.Ioi a = Set.Iio (a / c) :=
  by sorry

This theorem states that for any linearly ordered field `α` and any elements `a` and `c` of `α` such that `c` is less than 0, the preimage of the function `x * c` on the set `Set.Ioi a` (which denotes an interval `(a, +∞)`) is equal to the set `Set.Iio (a / c)` (which denotes an interval `(-∞, a / c)`). In other words, if you multiply each element `x` in the field by `c` and consider the resulting set of elements greater than `a`, it is equivalent to considering all the elements less than `a / c` in the original field.

For any linearly ordered field `α` and elements `a, c ∈ α` with `c < 0`, the sets `{x ∈ α | x > a} ` and `{x ∈ α | x < a / c}` are equal.


theorem tsub_tsub_assoc :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → c ≤ b → a - (b - c) = a - b + c :=
  by sorry

This theorem, `tsub_tsub_assoc`, states that for any type `α` that forms an additive commutative semigroup, has a partial order, has an operation of addition that exists for less than or equal to, is a covariant and contravariant class with respect to addition and less than or equal to, and has subtraction operation that is ordered, then for any three elements `a`, `b`, and `c` in `α`, if `b` is less than or equal to `a` and `c` is less than or equal to `b`, the result of calculating `a - (b - c)` is equal to `a - b + c`. This theorem describes the associative property of subtraction in the context of an ordered additive commutative semigroup.

In an additive commutative semigroup with subtraction operation that respects the order, the subtraction is associative: `a - (b - c) = a - b + c`, given `a >= b >= c`.


theorem Subgroup.comap_map_eq_self :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N} {H : Subgroup G},
      MonoidHom.ker f ≤ H → Subgroup.comap f (Subgroup.map f H) = H :=
  by sorry

This theorem states that for any group `G` and `N`, and a monoid homomorphism `f` from `G` to `N`, if the multiplicative kernel of `f` is a subgroup of `H` (i.e., `MonoidHom.ker f ≤ H`), then the preimage of the image of `H` under `f` (i.e., `Subgroup.comap f (Subgroup.map f H)`) is equal to `H`. In other words, if all elements `x` in `G` that map to `1` in `N` under `f` are in `H`, then applying `f` to `H` and taking the preimage gives us back `H`.

If `f` is a monoid homomorphism from group `G` to monoid `N`, `H` is a subgroup of `G`, and the multiplicative kernel of `f` is contained in `H`, then the preimage of the image of `H` under `f` is equal to `H`.


theorem Mathlib.Probability.ProbabilityMassFunction.Monad._auxLemma.4 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem, named `Mathlib.Probability.ProbabilityMassFunction.Monad._auxLemma.4`, states that for all types `α` and a sort `ι`, and for any element `x` of type `α` and a function `s` from `ι` to a set of `α`, the membership of `x` in the union of all sets `s i` (for all `i` in `ι`) is equivalent to the existence of an `i` such that `x` is in `s i`. In other words, an element belongs to the union of a collection of sets if and only if it belongs to at least one of the sets in the collection.

For any type `α` and sort `ι`, and for any element `x` of type `α` and function `s` from `ι` to a set of `α`, the element `x` belongs to the union of `s i` for all `i` in `ι` if and only if there exists an `i` such that `x` belongs to `s i`.


theorem Set.Ioi_add_bij :
    ∀ {M : Type u_1} [inst : OrderedCancelAddCommMonoid M] [inst_1 : ExistsAddOfLE M] (a d : M),
      Set.BijOn (fun x => x + d) (Set.Ioi a) (Set.Ioi (a + d)) :=
  by sorry

This theorem states that for any type `M` that is an ordered, cancellative, commutative monoid and has a property that for all `a` and `b` in `M`, if `a ≤ b` then there exists `c` in `M` such that `b = a + c`, and for any elements `a` and `d` in `M`, the function `f(x) = x + d` is a bijection from the set of all elements of `M` that are greater than `a` to the set of all elements of `M` that are greater than `a + d`. In other words, adding `d` to each element in the open interval `(a, ∞)` in `M` results in a one-to-one and onto mapping to the open interval `(a+d, ∞)` in `M`.

For any ordered, cancellative, commutative monoid `M` with the property that for all `a` and `b` in `M` with `a ≤ b` there exists `c` in `M` such that `b = a + c`, the function `f(x) = x + d` is a bijection between the sets `{x in M | x > a}` and `{x in M | x > a + d}`.


theorem Complex.dist_of_re_eq : ∀ {z w : ℂ}, z.re = w.re → dist z w = dist z.im w.im := by sorry

This theorem states that for any two complex numbers `z` and `w`, if the real parts of `z` and `w` are equal, then the distance between `z` and `w` is equal to the distance between the imaginary part of `z` and the imaginary part of `w`. Here, `dist` denotes the distance function, `z.re` and `w.re` represent the real parts of `z` and `w` respectively, and `z.im` and `w.im` represent their imaginary parts.

For complex numbers `z` and `w`, if `z.re = w.re` then `dist (z : ℂ) (w : ℂ) = dist z.im w.im`.


theorem supClosed_sInter :
    ∀ {α : Type u_2} [inst : SemilatticeSup α] {S : Set (Set α)}, (∀ s ∈ S, SupClosed s) → SupClosed (⋂₀ S) := by sorry

The theorem `supClosed_sInter` states that for any type `α` that forms a semilattice with respect to the operation `sup` (denoted `⊔`), and for any set `S` of sets of elements of type `α`, if every set `s` in `S` is sup-closed, then the intersection over all sets in `S` is also sup-closed. In other words, if every set in `S` has the property that for any two elements `a` and `b` in the set, their supremum `a ⊔ b` is also in the set, then this property holds for the intersection of all sets in `S` as well.

If `α` is a semilattice with respect to `⊔` and every `s` in the set `S` of subsets of `α` is sup-closed, then the intersection of all sets in `S` is sup-closed.


theorem Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic._auxLemma.29 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) := by sorry

This theorem, under the namespace `Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic._auxLemma.29`, states that for any two types `A` and `B`, given a `SetLike` instance `i` between `A` and `B`, and for any element `p` of type `A` and `x` of type `B`, the proposition that `x` is in the coersion of `p` to a set (notated as `x ∈ ↑p`) is equivalent to the proposition that `x` is in `p` (notated as `x ∈ p`). Essentially, this theorem asserts that the membership of an element in a set remains unchanged even under coersion.

For any `SetLike` instances `i` between types `A` and `B`, and for all `p` in `A` and `x` in `B`, `x ∈ ↑p` if and only if `x ∈ p`.


theorem Subring.mem_comap :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] {s : Subring S} {f : R →+* S} {x : R},
      x ∈ Subring.comap f s ↔ f x ∈ s :=
  by sorry

This theorem states that for any two types `R` and `S` that have a ring structure, a subring `s` of type `S`, a ring homomorphism `f` from `R` to `S`, and an element `x` of type `R`, the element `x` is in the preimage of the subring `s` under the map `f` if and only if the image of `x` under `f` is in the subring `s`. In other words, it establishes a membership equivalence between the element `x` and its image under the ring homomorphism `f` in the context of subrings and their preimages.

For any ring homomorphism $f$ from a ring $R$ to a ring $S$, and any subring $s$ of $S$ and element $x$ in $R$, $x \in f^{-1}(s)$ if and only if $f(x) \in s$.


theorem Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic._auxLemma.31 :
    ∀ {α : Type u} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) := by sorry

This theorem states that for any type 'α', any element 'a' of that type, and any set 's' of elements of type 'α', the single-element set containing 'a' is a subset of 's' if and only if 'a' is an element of 's'. Essentially, this is saying that a set is a subset of another set if its elements are also elements of the other set.

For any type 'α' and any set 's' of elements from 'α', the set containing only one element 'a' of 'α' is a subset of 's' if and only if 'a' is an element of 's'.


theorem eq_neg_self_iff :
    ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : NoZeroDivisors R] [inst_2 : CharZero R] {a : R},
      a = -a ↔ a = 0 :=
  by sorry

This theorem states that for any element `a` of a type `R`, where `R` is a non-associative ring with no zero divisors and zero character, `a` equals its own negation if and only if `a` is zero. In other words, the only element in such a ring that is equal to its own negative is the zero element.

In a non-associative ring without zero divisors and zero character, an element equals its own negation if and only if it is the additive identity (zero).


WithSeminorms.toLocallyConvexSpace

theorem WithSeminorms.toLocallyConvexSpace :
    ∀ {𝕜 : Type u_1} {E : Type u_5} {ι : Type u_8} [inst : Nonempty ι] [inst_1 : NormedField 𝕜]
      [inst_2 : NormedSpace ℝ 𝕜] [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Module ℝ E]
      [inst_6 : IsScalarTower ℝ 𝕜 E] [inst_7 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
      WithSeminorms p → LocallyConvexSpace ℝ E :=
  by sorry

This theorem states that for any nonempty type ι, a normed field 𝕜, a type E that is an additive commutative group and a 𝕜-module as well as an ℝ-module, a topological space on E, and a scalar tower of ℝ, 𝕜, and E, if we have a family of seminorms p from the type ι to the seminorms on 𝕜 and E (denoted as `SeminormFamily 𝕜 E ι`), and if these seminorms satisfy the `WithSeminorms` property, then E is a locally convex space over ℝ. In simpler terms, it means that a certain kind of structures built using seminorms can give us a locally convex space, a key concept in the study of topological vector spaces.

Given a nonempty type ι, a normed field 𝕜, an additive commutative group and 𝕜-module E also an ℝ-module, a topological space on E, and a scalar tower, if we have a family of seminorms p on ι satisfying the `WithSeminorms` property, then E is a locally convex space over ℝ.


theorem AddLECancellable.le_tsub_iff_right :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α}, AddLECancellable a → a ≤ c → (b ≤ c - a ↔ b + a ≤ c) :=
  by sorry

The theorem `AddLECancellable.le_tsub_iff_right` states that for any type `α` that is an additive commutative semigroup and has partial order, the existence of addition of lesser elements, covariance, subtraction, and ordered subtraction, for any elements `a`, `b`, and `c` of this type, if `a` is "left-addition less-than-or-equal-to" cancellable and `a` is less than or equal to `c`, then `b` is less than or equal to `c - a` if and only if `b + a` is less than or equal to `c`.

In other words, given a certain structure of the type, and given that adding `a` to some element doesn't affect the ordering of elements, we can safely "move" `a` between sides of an inequality involving addition and subtraction.

For any additive commutative semigroup with partial order `α`, if `a` is left- cancellable and `a ≤ c`, then `b ≤ c - a` if and only if `b + a ≤ c`.


theorem Finset.lt_max'_of_mem_erase_max' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) [inst_1 : DecidableEq α] {a : α},
      a ∈ Finset.erase s (Finset.max' s H) → a < Finset.max' s H :=
  by sorry

The theorem `Finset.lt_max'_of_mem_erase_max'` states that for any nonempty finite set `s` of a type `α` that is ordered by a linear order, along with a provided instance of decidable equality on `α`, if an element `a` belongs to the set resulting from erasing the maximum element of `s` from `s` itself, then `a` is strictly less than the maximum element of `s`. In other words, any element of the set excluding its maximum is less than the maximum.

For any nonempty finite set `s` in a linearly ordered type `α` with decidable equality, if `a` is an element of `s` excluding its maximum, then `a` is strictly less than the maximum element of `s`.


theorem zpow_mul_comm : ∀ {G : Type w} [inst : Group G] (a : G) (m n : ℤ), a ^ m * a ^ n = a ^ n * a ^ m := by sorry

This theorem states that in any group `G`, for any element `a` in `G` and any two integers `m` and `n`, the multiplication of `a` raised to the power `m` and `a` raised to the power `n` is commutative. In other words, `a` to the power of `m` times `a` to the power of `n` is equal to `a` to the power of `n` times `a` to the power of `m`. This property is known as the commutativity of multiplication of powers in a group.

In any group, for all elements a, integers m and n, the powers a^m and a^n commute, that is, a^m * a^n = a^n * a^m.


theorem le_of_fin_surjective :
    ∀ (R : Type u) [inst : Semiring R] [inst_1 : RankCondition R] {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R),
      Function.Surjective ⇑f → m ≤ n :=
  by sorry

The theorem `le_of_fin_surjective` states that for any semiring `R` that satisfies the rank condition and for any natural numbers `n` and `m`, if there exists a linear map `f` from the set of functions `Fin n → R` to the set of functions `Fin m → R` that is surjective (i.e., for each function from `Fin m` to `R`, there is a function from `Fin n` to `R` that maps to it under `f`), then `m` is less than or equal to `n`. In essence, this theorem says that the dimension of the target space cannot exceed the dimension of the source space if the linear map is surjective.

If there exists a surjective linear map from functions `Fin n -> R` to functions `Fin m -> R` in a semiring `R` satisfying the rank condition, then `n` greater than or equal to `m`.


theorem hasDerivAtFilter_neg :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) (L : Filter 𝕜), HasDerivAtFilter Neg.neg (-1) x L := by
  sorry

The theorem `hasDerivAtFilter_neg` states that for all types `𝕜` that are nontrivially normed fields, for any element `x : 𝕜` and any filter `L` over `𝕜`, the negative function (which computes the negative or opposite of its argument) has a derivative of `-1` at the point `x` along the filter `L`. In mathematical terms, this means that the derivative of the function `f(x) = -x` is `f'(x) = -1` for all `x` in the field.

For any nontrivially normed field `𝕜` and element `x` in `𝕜`, the negative function `f(x) = -x` has a derivative of `-1` along any filter over `𝕜`.


/-- The `p`-adic value of a natural is its `p`-adic value as an integer.  -/
theorem padicValInt.of_nat : ∀ {p n : ℕ}, padicValInt p ↑n = padicValNat p n := by sorry

This theorem states that for any natural numbers `p` and `n`, the `p`-adic valuation of `n` when it is considered as an integer is the same as its `p`-adic valuation when it is considered as a natural number. In other words, the process of calculating the `p`-adic valuation does not depend on whether the number `n` is treated as an integer or as a natural number, it will yield the same result in either case.

For any natural number `n` and prime `p`, the `p`-adic valuation of `n` as an integer equals the `p`-adic valuation of `n` as a natural number.


theorem Polynomial.degree_eq_iff_natDegree_eq :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      p ≠ 0 → (Polynomial.degree p = ↑n ↔ Polynomial.natDegree p = n) :=
  by sorry

The theorem `Polynomial.degree_eq_iff_natDegree_eq` states that for any semiring `R` and any non-zero polynomial `p` from `R`, the degree of `p` is equal to `n` (in the option type with bottom, represented as `↑n`) if and only if the natural degree of `p` is `n`. Here, the degree of a polynomial is the highest exponent that appears in it, and the natural degree is the same except that it is defined to be 0 for the zero polynomial.

For any semiring R and non-zero polynomial p from R, the degree and natural degree are equal if and only if p has a highest exponent of degree n.


theorem inner_self_eq_norm_sq_to_K :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x : E), ⟪x, x⟫_𝕜 = ↑‖x‖ ^ 2 :=
  by sorry

This theorem states that for any type `𝕜` which is of type `RCLike`, for another type `E` which is a normed additive commutative group and an inner product space over `𝕜`, the inner product of any element `x` of `E` with itself (denoted as `⟪x, x⟫_𝕜`) is equal to the square of the norm of `x` (denoted as `‖x‖^2`). In other words, in the context of inner product spaces, the inner product of a vector with itself equals the square of its norm.

For any normed additive commutative group and inner product space `E` over a `RCLike` type `𝕜`, the inner product of any `x` in `E` with itself equals the square of its norm: `⟪x, x⟫_𝕜 = ‖x‖^2`.


Dense.orderDual

theorem Dense.orderDual :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, Dense s → Dense (⇑OrderDual.ofDual ⁻¹' s) := by sorry

This theorem states that for any given type `α` with a topological space structure, and any given set `s` of that type, if `s` is a dense set in that topological space, then the pre-image of `s` under the function `OrderDual.ofDual` is also a dense set. In other words, if every point in the topological space belongs to the closure of `s`, then every point also belongs to the closure of the set obtained by applying the function `OrderDual.ofDual` to each element of `s`. This function is essentially the identity function on the dual order of `α`, making this a statement about the preservation of density under this particular function.

If `α` is a topological space type with a dense set `s`, then the pre-image of `s` under the OrderDual.ofDual function is also dense.


theorem Monotone.le_of_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : OrderClosedTopology α]
      [inst_3 : SemilatticeInf β] {f : β → α} {a : α},
      Monotone f → Filter.Tendsto f Filter.atBot (nhds a) → ∀ (b : β), a ≤ f b :=
  by sorry

This theorem states that if a function `f` from an ordered set `β` to a topological space `α` is monotone, and the limit of `f` as `β` approaches negative infinity is a point `a` in `α`, then for any element `b` in `β`, `a` will be less than or equal to `f(b)`. Here, `α` is equipped with a preorder and an order-closed topology, and `β` is assumed to be a semilattice with respect to the infimum operation.

If `f` is a monotone function from the semilattice `β` with infimum operation to the ordered topological space `(α, ≤)`, and `a` is the limit of `f` as `β` approaches negative infinity, then `a ≤ f(b)` for all `b` in `β`.


theorem AddAction.mem_orbit_self :
    ∀ {M : Type u} [inst : AddMonoid M] {α : Type v} [inst_1 : AddAction M α] (a : α), a ∈ AddAction.orbit M a := by
  sorry

This theorem states that for any type `M` equipped with an add monoid structure, any type `α` equipped with an AddAction of `M`, and any element `a` of type `α`, `a` is an element of its own orbit under the action of the add monoid `M`. In mathematical terms, this theorem asserts that for every element in a set that is acted upon by an additive monoid, the element is always contained in its own orbit under this action.

For any add monoid `M` acting on type `α` through an AddAction, and for any element `a` in `α`, `a` is in the orbit of `{0} : M` under the action of `M`.


theorem Fin.succ_castPred_eq_castPred_succ :
    ∀ {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ Fin.last n) (ha' : optParam (Fin.succ a ≠ Fin.last (n + 1)) ⋯),
      Fin.succ (Fin.castPred a ha) = Fin.castPred (Fin.succ a) ha' :=
  by sorry

The theorem `Fin.succ_castPred_eq_castPred_succ` states that for any natural number `n` and any element `a` of the type `Fin (n + 1)`, given that `a` is not the last element of `Fin n` (i.e., `a ≠ Fin.last n`) and optionally assuming that the successor of `a` is not the last element of `Fin (n + 1)`, the successor of the element obtained by casting `a` to `Fin n` (i.e., `Fin.succ (Fin.castPred a ha)`) is equal to the result of casting the successor of `a` to `Fin n` (i.e., `Fin.castPred (Fin.succ a) ha'`). In other words, this theorem ensures the commutativity of the `Fin.succ` and `Fin.castPred` operations in the finite sequence `Fin` under certain conditions.

For any natural number `n` and elements `a` in `Fin (n + 1)` not equal to the last element of `Fin n`, the successor of `Fin.castPred a` is equal to `Fin.castPred (Fin.succ a)`.


/-- If `f` is a partial homeomorphism defined on a neighbourhood of `f.symm a`, and `f` has a
nonzero derivative `f'` at `f.symm a` in the strict sense, then `f.symm` has the derivative `f'⁻¹`
at `a` in the strict sense.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function.  -/
theorem PartialHomeomorph.hasStrictDerivAt_symm :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (f : PartialHomeomorph 𝕜 𝕜) {a f' : 𝕜},
      a ∈ f.target →
        f' ≠ 0 →
          HasStrictDerivAt (↑f) f' (↑(PartialHomeomorph.symm f) a) →
            HasStrictDerivAt (↑(PartialHomeomorph.symm f)) f'⁻¹ a :=
  by sorry

This theorem states that if `f` is a partial homeomorphism defined on a neighborhood of `f.symm a`, and `f` has a non-zero derivative `f'` at `f.symm a` in the strict sense, then the inverse of `f`, denoted as `f.symm`, has the derivative `f'⁻¹` at `a` in the strict sense. This is a component of the inverse function theorem and presumes that we already have an inverse function.

In more mathematical terms, if `f` is a map with a non-zero derivative at a point in its domain, then its inverse function has a derivative at the corresponding point in its target, and the derivative of the inverse function is the reciprocal of the derivative of the function. This is under the assumption that the inverse function exists.

If `f` is a partial homeomorphism with a non-zero strict derivative at `a`, then the inverse `f.symm` has a strict derivative `f'⁻¹` at `f.symm a`.


theorem Continuous.matrix_conjTranspose :
    ∀ {X : Type u_1} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace R] [inst_2 : Star R] [inst_3 : ContinuousStar R] {A : X → Matrix m n R},
      Continuous A → Continuous fun x => Matrix.conjTranspose (A x) :=
  by sorry

The theorem `Continuous.matrix_conjTranspose` states that for any types `X`, `m`, `n`, and `R` where `X` is endowed with a topological space structure, `R` is endowed with both a topological space structure and a star operation that is continuous, and `A` is a continuous function from `X` to matrices of type `m` by `n` with entries in `R`, the function that sends each element `x` in `X` to the conjugate transpose of the matrix `A(x)` is also continuous.

If `X` is a topological space, `R` is a topological space with a continuous star operation, and `A` is a continuous function from `X` to matrices of size `m` by `n` over `R`, then the function sending `x` to the conjugate transpose of `A(x)` is continuous.


theorem MeasureTheory.FiniteMeasure.coeFn_smul_apply :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {R : Type u_2} [inst_1 : SMul R NNReal] [inst_2 : SMul R ENNReal]
      [inst_3 : IsScalarTower R NNReal ENNReal] [inst_4 : IsScalarTower R ENNReal ENNReal]
      [inst_5 : IsScalarTower R NNReal NNReal] (c : R) (μ : MeasureTheory.FiniteMeasure Ω) (s : Set Ω),
      (fun s => (↑↑↑(c • μ) s).toNNReal) s = c • (fun s => (↑↑↑μ s).toNNReal) s :=
  by sorry

The theorem `MeasureTheory.FiniteMeasure.coeFn_smul_apply` states that for any measurable space `Ω`, any type `R` that can multiply nonnegative real numbers and extended nonnegative real numbers, and which forms scalar towers with these types, any scalar `c` of type `R`, any finite measure `μ` on `Ω`, and any set `s` in `Ω`, the measure of the set `s` under the measure obtained by scaling `μ` by `c` (when converted to a nonnegative real number) is the same as the scalar `c` multiplied by the measure of `s` under `μ` (when converted to a nonnegative real number).

In other words, scaling a finite measure and then measuring a set is the same as first measuring the set and then scaling the result. This illustrates a fundamental property of measures known as homogeneity.

For any measurable space Ω, any scalar c of type R that can multiply nonnegative real numbers and extended nonnegative real numbers, and forms scalar towers with these types, and for any finite measure μ on Ω and measurable set s in Ω, the measure of s under the scaled measure μ' = μ * c is equal to the measure of s under μ multiplied by c as real numbers, i.e., μ'(s) = μ(s) * c.


theorem MeasureTheory.StronglyMeasurable.piecewise :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {m : MeasurableSpace α} [inst : TopologicalSpace β] {s : Set α}
      {x : DecidablePred fun x => x ∈ s},
      MeasurableSet s →
        MeasureTheory.StronglyMeasurable f →
          MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable (Set.piecewise s f g) :=
  by sorry

This theorem states that, given two strongly measurable functions `f` and `g` from a type `α` to a type `β`, a measurable set `s` of type `α`, and a decidable predicate `x` such that `x ∈ s`, if `f` and `g` are strongly measurable, then the piecewise function defined on `s` that equals `f` on the set `s` and `g` on its complement is also strongly measurable. Note that `β` is endowed with a topology, and `α` with a measurable space structure. Strong measurability of a function means that it can be approximated pointwise by a sequence of simple functions.

Given two strongly measurable functions `f` and `g` from a measurable space `(α, Σ)` to a topological space `(β, τ)`, a measurable set `s ∈ Σ`, and a decidable predicate `x ∈ s`, the piecewise function `x ↦ if h x ∈ s then f x else g x` is strongly measurable, where `h` is the characteristic function of `s`.


theorem Subgroup.inclusion_injective :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H ≤ K), Function.Injective ⇑(Subgroup.inclusion h) := by
  sorry

This theorem asserts that for any given type `G` with a `Group` instance and any two subgroups `H` and `K` of `G`, if `H` is a subset of `K`, then the inclusion homomorphism from `H` to `K` is injective. In other words, if we have two elements from `H` and they map to the same element in `K` through the inclusion homomorphism, then these two elements were originally the same element in `H`.

If `H` is a subgroup of `K` in a group `G`, then the inclusion homomorphism from `H` to `K` is an injection.


theorem ValuationSubring.monotone_mapOfLE :
    ∀ {K : Type u} [inst : Field K] (R S : ValuationSubring K) (h : R ≤ S),
      Monotone ⇑(ValuationSubring.mapOfLE R S h) :=
  by sorry

The theorem `ValuationSubring.monotone_mapOfLE` states that for any field `K` and two valuation subrings `R` and `S` of `K` such that `R` is less than or equal to `S`, the canonical map on value groups induced by the coarsening of valuation rings, represented by the function `ValuationSubring.mapOfLE R S h`, is monotone. In other words, if `a` and `b` are any two elements from the value group of `R` such that `a ≤ b`, then the image of `a` under the map is less than or equal to the image of `b`.

For any fields K and valuation subrings R ≤ S of K, the map on value groups induced by the coarsening of R to S, ValuationSubring.mapOfLE R S h, is monotone.


theorem mul_cancel_left_mem_nonZeroDivisors :
    ∀ {R' : Type u_6} [inst : CommRing R'] {x y r : R'}, r ∈ nonZeroDivisors R' → (r * x = r * y ↔ x = y) := by sorry

The theorem `mul_cancel_left_mem_nonZeroDivisors` states that for any type `R'` which forms a commutative ring, given any elements `x`, `y`, and `r` of `R'`, if `r` belongs to the set of non-zero divisors of `R'`, then the equality of the products `r * x` and `r * y` implies the equality of `x` and `y`. In other words, multiplication by `r` is cancellable on the left within the set of non-zero divisors of a commutative ring.

If `r` is a non-zero divisor in a commutative ring `R'`, then `r * x = r * y` implies `x = y`.


theorem Polynomial.derivative_add :
    ∀ {R : Type u} [inst : Semiring R] {f g : Polynomial R},
      Polynomial.derivative (f + g) = Polynomial.derivative f + Polynomial.derivative g :=
  by sorry

The theorem `Polynomial.derivative_add` states that for all types `R` equipped with a semiring structure `[inst : Semiring R]`, and for any two polynomials `f` and `g` over this type, the derivative of the sum of `f` and `g` is equal to the sum of the derivatives of `f` and `g`. In mathematical notation, this can be written as: for all `f, g ∈ Polynomial R`, `(f + g)' = f' + g'`. This theorem is a formalization of the standard result from calculus that the derivative of a sum of functions is equal to the sum of their derivatives.

The theorem `Polynomial.derivative_add` asserts that the derivative of the sum of two polynomials is equal to the sum of their derivatives.


theorem Polynomial.prime_X_sub_C :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (r : R), Prime (Polynomial.X - Polynomial.C r) := by sorry

The theorem `Polynomial.prime_X_sub_C` states that for all commutative rings `R` that are also integral domains, and for any element `r` in `R`, the polynomial `X - C r` (where `X` is the polynomial variable and `C r` is the constant polynomial `r`) is a prime element. Here, a prime element in a commutative monoid with zero is an element `p` that is not zero, is not a unit, and if `p` divides the product of `a` and `b`, then `p` must divide `a` or `b`.

For any commutative domain `R`, the polynomial `X - C r` in `R[X]` is a prime element.


theorem SimpleGraph.colorable_set_nonempty_of_colorable :
    ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ},
      SimpleGraph.Colorable G n → Set.Nonempty {n | SimpleGraph.Colorable G n} :=
  by sorry

This theorem states that for any given type `V`, any simple graph `G` of type `V`, and any natural number `n`, if the graph `G` can be colored using at most `n` colors (which is represented by `SimpleGraph.Colorable G n`), then there exists at least one `n` such that the graph `G` can be colored by `n` colors. In other words, the set of those `n` for which `G` can be colored by `n` colors is nonempty. This theorem provides a link between the colorability of a graph and the existence of a coloring number within a specific set.

If a simple graph `G` of type `V` is `n`-colorable, then there exists a valid `n`-coloring for `G`.


theorem Num.ofNat'_bit :
    ∀ (b : Bool) (n : ℕ), Num.ofNat' (Nat.bit b n) = (bif b then Num.bit1 else Num.bit0) (Num.ofNat' n) := by sorry

The theorem `Num.ofNat'_bit` states that for all boolean values `b` and all natural numbers `n`, the process of converting the natural number obtained by appending the digit `b` to the binary representation of `n` into a `Num` type, is the same as first converting `n` into a `Num` type and then appending the digit `b` to it. If `b` is true, the digit appended is `1`, and if `b` is false, the digit appended is `0`.

For all natural numbers `n` and booleans `b`, converting `n` to `Num` with appended binary digit `b` is equal to first converting `n` to `Num` and then appending digit `b * 2^(size Nat.binNum n)`.


/-- A polynomial `p` that has as many roots as its degree
can be written `p = p.leadingCoeff * ∏(X - a)`, for `a` in `p.roots`.  -/
theorem Polynomial.C_leadingCoeff_mul_prod_multiset_X_sub_C :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      Multiset.card (Polynomial.roots p) = Polynomial.natDegree p →
        Polynomial.C (Polynomial.leadingCoeff p) *
            Multiset.prod (Multiset.map (fun a => Polynomial.X - Polynomial.C a) (Polynomial.roots p)) =
          p :=
  by sorry

The theorem `Polynomial.C_leadingCoeff_mul_prod_multiset_X_sub_C` states that for any polynomial `p` over a commutative ring `R` (which is assumed to be an integral domain), if the number of roots of `p` (counting multiplicities) equals the degree of `p` (in natural numbers), then `p` can be expressed as the product of its leading coefficient and the product of linear terms `(X - a)` where `a` varies over the roots of `p`. In other words, if a polynomial has as many roots as its degree, it can be factored into linear terms multiplied by its leading coefficient. In mathematical terms, this can be written as $p = p.\text{leadingCoeff} \times \prod (X - a)$, where $a$ ranges over the roots of $p$.

If a polynomial of degree n over a commutative integral domain has exactly n roots (counting multiplicities), then it can be expressed as the product of its leading coefficient and the product of linear factors (X - a) over its roots a.


/-- See also `Finset.map_prodComm_antidiagonal`.  -/
theorem Finset.map_swap_antidiagonal :
    ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A] {n : A},
      Finset.map { toFun := Prod.swap, inj' := ⋯ } (Finset.antidiagonal n) = Finset.antidiagonal n :=
  by sorry

This theorem states that for any type `A` that has an additive commutative monoid structure and a defined antidiagonal, and for any number `n` of type `A`, the image of the antidiagonal of `n` under the swapping function is equal to the antidiagonal of `n` itself. In other words, if you take pairs of elements `(a, b)` that add up to `n` (forming the antidiagonal), and if you swap the elements in each pair to get `(b, a)`, the set of pairs you end up with is still the antidiagonal of `n`. This is a result of the commutativity of the addition operation in `A`.

For any additive commutative monoid `A` with defined antidiagonal, the swapped antidiagonal is equal to the original antidiagonal.


theorem lipschitzWith_lipschitz_const_mul_edist :
    ∀ {β : Type u_2} [inst : PseudoMetricSpace β] [inst_1 : Monoid β] [_i : LipschitzMul β],
      LipschitzWith (LipschitzMul.C β) fun p => p.1 * p.2 :=
  by sorry

This theorem states that for any type `β` which has a structure of a pseudometric space and a monoid, and also satisfies the `LipschitzMul` property, the function that takes a pair of elements `(p.1, p.2)` in `β` and multiplies them (i.e., `p.1 * p.2`) is Lipschitz continuous in the pseudometric sense. The Lipschitz constant for this function is given by `LipschitzMul.C β`, the Lipschitz constant associated with the `LipschitzMul` structure of `β`.

Given a type `β` equipped with both a pseudometric and a monoid structure satisfying the `LipschitzMul` property, the multiplication function is Lipschitz continuous with constant `LipschitzMul.C β`.


theorem HomologicalComplex.single_map_f_self :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      (j : ι) {A B : V} (f : A ⟶ B),
      ((HomologicalComplex.single V c j).map f).f j =
        CategoryTheory.CategoryStruct.comp (HomologicalComplex.singleObjXSelf c j A).hom
          (CategoryTheory.CategoryStruct.comp f (HomologicalComplex.singleObjXSelf c j B).inv) :=
  by sorry

This theorem states that for any category `V` with zero morphisms and a zero object, given any complex shape `c` and an object `j` in it, if we have a morphism `f` from `A` to `B` where `A` and `B` are objects in `V`, then the morphism at `j` in the image of the homological complex corresponding to `j` under the map induced by `f` is the composition of the morphism from the object at `j` in `A` to itself and the composition of `f` with the inverse of the morphism from the object at `j` in `B` to itself. This theorem is part of the theory of homological algebra and deals with the behaviour of morphisms in homological complexes.

Given a category with zero morphisms and a zero object, for any complex and object `j`, the morphism at `j` in the image of the homological complex induced by a morphism `f` from `A` to `B` is equal to the composition of the identity morphism on `j` in `A`, `f`, and the inverse of the identity morphism on `j` in `B`.


theorem specializes_iff_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x y : X}, x ⤳ y ↔ x = y := by sorry

This theorem, called "specializes_iff_eq", states that for any type `X` equipped with a topological space structure and a T1 space structure, and for any two elements `x` and `y` of `X`, the statement "`x` specializes `y`" is equivalent to "`x` equals `y`". Here, "specializes" is a concept in topology which, in a T1 space, turns out to be equivalent to equality. This theorem thus connects an abstract topological concept to a more intuitive, everyday concept of equality.

In a T1 topological space, an element specializes another if and only if they are equal.


theorem AddSubgroup.map_comap_eq_self :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {H : AddSubgroup N},
      H ≤ AddMonoidHom.range f → AddSubgroup.map f (AddSubgroup.comap f H) = H :=
  by sorry

The theorem `AddSubgroup.map_comap_eq_self` states that for every additive group homomorphism `f` from an additive group `G` to another additive group `N`, and for any additive subgroup `H` of `N`, if `H` is a subset of the range of `f`, then the image under `f` of the preimage of `H` under `f` is the same as `H` itself. Mathematically, this can be expressed as: if \(H \subseteq \text{range}(f)\), then \(f(f^{-1}(H)) = H\). This illustrates one of the fundamental properties of functions and their inverses when dealing with sets and subsets: the process of mapping a set through a function and then its inverse (or vice versa) results in the original set when the initial set is within the function's range.

If `H` is an additive subgroup of an additive group `N` contained in the image of an additive group homomorphism `f` from an additive group `G` to `N`, then `f(f⁻¹(H)) = H`.


theorem DFinsupp.mapRange_id :
    ∀ {ι : Type u} {β₁ : ι → Type v₁} [inst : (i : ι) → Zero (β₁ i)] (h : optParam (∀ (i : ι), id 0 = 0) ⋯)
      (g : Π₀ (i : ι), β₁ i), DFinsupp.mapRange (fun i => id) h g = g :=
  by sorry

This theorem, `DFinsupp.mapRange_id`, states that for all types ι and β₁ indexed by ι, and for any function `g` from ι to β₁ that takes zero as a default value, applying the identity function to the range of `g` leaves `g` unchanged. This is true under the condition that the identity function applied to zero yields zero, which is supplied as an optional parameter. Essentially, this theorem is saying that the operation of mapping the identity function over the range of `g` doesn't modify `g` itself, it's an identity operation on `g`.

For any type ι and function g from ι to β₁ with a default value, applying the identity function to the range of g yields the same function g, under the assumption that the identity function maps 0 to 0.


theorem CategoryTheory.Pretriangulated.Triangle.isZero₁_iff_isIso₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        CategoryTheory.Limits.IsZero T.obj₁ ↔ CategoryTheory.IsIso T.mor₂ :=
  by sorry

This theorem states that for any given category `C` (which should be a pretriangulated category that has a zero object and a shift functor), if `T` belongs to the distinguished triangles of the pretriangulated category, then the object `T.obj₁` is a zero object if and only if the morphism `T.mor₂` is an isomorphism. This condition applies for all integers `n` for which the shift functor `CategoryTheory.shiftFunctor C n` is additive.

In a pretriangulated category `C` with a zero object and additive shift functor, a distinguished triangle `T` has `T.obj₁` as a zero object if and only if `T.mor₂` is an isomorphism.


theorem congr_heq :
    ∀ {α β : Sort u_1} {γ : Sort u_2} {f : α → γ} {g : β → γ} {x : α} {y : β}, HEq f g → HEq x y → f x = g y := by sorry

This theorem, named `congr_heq`, asserts that for any types `α` and `β` of the same universe `u_1`, along with another type `γ` in a potentially different universe `u_2`, as well as functions `f: α → γ` and `g: β → γ`, and elements `x: α` and `y: β`, if `f` and `g` are heterogeneously equal (i.e., `HEq f g`) and `x` and `y` are also heterogeneously equal (`HEq x y`), then the results of applying `f` and `g` to `x` and `y` respectively are equal (i.e., `f x = g y`). Essentially, it shows that if two functions are the same, and two elements are the same (even if of different types), applying the same function to those elements yields the same result.

Given functions `f: α → γ` and `g: β → γ` between types `α`, `β`, and `γ` in possibly different universes, and elements `x: α` and `y: β` such that `HEq f g` and `HEq x y`, then `f x = g y`.


theorem Asymptotics.IsBigO.const_mul_left :
    ∀ {α : Type u_1} {F : Type u_4} {R : Type u_13} [inst : Norm F] [inst_1 : SeminormedRing R] {g : α → F}
      {l : Filter α} {f : α → R}, f =O[l] g → ∀ (c' : R), (fun x => c' * f x) =O[l] g :=
  by sorry

This theorem, `Asymptotics.IsBigO.const_mul_left`, states that for any given types `α`, `F`, and `R` along with an instance of Norm over `F`, an instance of SeminormedRing over `R`, a function `g` mapping from `α` to `F`, a filter `l` over `α`, and a function `f` mapping from `α` to `R`, if `f` is `Big O` of `g` at filter `l`, then, for any constant `c'` of type `R`, the function that maps `x` to `c' * f(x)` is also `Big O` of `g` at filter `l`. In simpler terms, if a function `f` grows no faster than a function `g`, then the function `c' * f`, where `c'` is a constant, also grows no faster than `g`.

If `f` is Big O of `g` at filter `l` in Lean, then `c * f` is also Big O of `g` at filter `l` for any constant `c` of type `R`.


ContinuousLinearMap.hasDerivAtFilter

theorem ContinuousLinearMap.hasDerivAtFilter :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {L : Filter 𝕜} (e : 𝕜 →L[𝕜] F), HasDerivAtFilter (⇑e) (e 1) x L :=
  by sorry

The theorem `ContinuousLinearMap.hasDerivAtFilter` states that for any non-trivial normed field `𝕜`, normed additive commutative group `F`, and normed space over `𝕜` and `F`, for any point `x` and filter `L` on `𝕜`, and any continuous linear map `e` from `𝕜` to `F`, the map `e` has a derivative at the point `x` as `x` goes along the filter `L`. The derivative is given by the application of `e` to 1. In mathematical terms, if `e` is a continuous linear map, then the equation `f(x') = f(x) + (x' - x) * f'(x) + o(x' - x)` holds where `x'` converges along the filter `L` and `f'` is the derivative of `f` at `x`.

For any non-trivial normed field `𝕜`, normed additive commutative group `F`, and continuous linear map `e` from `𝕜` to `F`, if `x` is a point in `𝕜` and `L` is a filter on `𝕜`, then `e` has a derivative `e(1)` at `x` along the filter `L`, i.e., `e(x') = e(x) + (x' - x) * e(1) + o(1)` as `x'` converges to `x` through `L`.


theorem MeasureTheory.measure_biUnion_finset :
    ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Finset ι}
      {f : ι → Set α},
      Set.PairwiseDisjoint (↑s) f →
        (∀ b ∈ s, MeasurableSet (f b)) → ↑↑μ (⋃ b ∈ s, f b) = Finset.sum s fun p => ↑↑μ (f p) :=
  by sorry

This theorem, named `MeasureTheory.measure_biUnion_finset`, states that for any measurable space `α`, index type `ι`, a measure space defined on `α` by `μ`, a finite set `s` of the index type `ι`, and a function `f` that maps index to the set `α`, if the image of any two distinct elements in the set `s` under `f` are disjoint (i.e., `Set.PairwiseDisjoint` holds for `s` and `f`), and the set `f b` is measurable for every `b` in `s`, then the measure of the union of `f b` for every `b` in `s` (expressed as `↑↑μ (⋃ b ∈ s, f b)`) equals the sum (expressed as `Finset.sum s fun p => ↑↑μ (f p)`) of the measures of `f p` for every `p` in `s`.

To put it simply, this theorem states that if you have a set of disjoint, measurable subsets of a measurable space, the measure of the union of these subsets is the sum of their individual measures.

If `α` is a measurable space, `μ` is a measure on `α`, `ι` is a finite index type, `s` is a finite set of `ι`, `f : ι → α` is a function such that `Set.PairwiseDisjoint s f` and `μ (f i)` is measurable for each `i` in `s`, then `μ (⋃ i ∈ s, f i) = Finset.sum s fun i => μ (f i)`.


MonotoneOn.sup

/-- Pointwise supremum of two monotone functions is a monotone function.  -/
theorem MonotoneOn.sup :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β} {s : Set α},
      MonotoneOn f s → MonotoneOn g s → MonotoneOn (f ⊔ g) s :=
  by sorry

The theorem `MonotoneOn.sup` states that for any set `s` of a certain type `α`, and for any two functions `f` and `g` from `α` to another type `β` (where `α` has a preorder structure and `β` has a semilattice sup structure), if both functions `f` and `g` are monotone on `s`, then the pointwise supremum function `(f ⊔ g)`, which is defined for each element in the set `s` as the maximum of the values of `f` and `g` at that element, is also monotone on `s`. This means that for any two elements `a` and `b` in the set `s`, if `a ≤ b`, then the maximum of `f(a)` and `g(a)` is less than or equal to the maximum of `f(b)` and `g(b)`.

If `f` and `g` are two monotone functions from a preordered set `α` to a semilattice `β`, then their pointwise supremum `f ⊔ g` is also a monotone function on `α`.


theorem Finset.max_of_nonempty :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α}, s.Nonempty → ∃ a, Finset.max s = ↑a := by sorry

The theorem `Finset.max_of_nonempty` states that for any type `α` which has a linear order, and for any finite set `s` of this type, if `s` is nonempty, then there exists an element `a` such that the maximum of the set `s` is `a`. The maximum of a set is defined as the largest element in the set according to the given linear order.

For any linear order type `α` and finite nonempty set `s` of `α`, there exists an element `a` in `s` such that `s ≤ a` for all `x` in `s`. (Here, `≤` denotes the linear order relation.)


theorem Mathlib.Algebra.Order.Monovary._auxLemma.11 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {f : ι → α}
      {g : ι → β}, Antivary f⁻¹ g = Monovary f g :=
  by sorry

This theorem states that for any types `ι`, `α`, and `β`, with `α` and `β` being ordered commutative groups, and for any functions `f : ι → α` and `g : ι → β`, the property of `f⁻¹` (the inverse function of `f`) antivarying with `g` is equivalent to `f` monovarying with `g`. In other words, if for all `i`, `j` in `ι`, `g(i) < g(j)` implies that `f⁻¹(j) ≤ f⁻¹(i)`, then it is also true that `g(i) < g(j)` implies that `f(i) ≤ f(j)`, and vice versa. This captures a fundamental symmetry between the antivariation and monovariation of functions in the context of ordered commutative groups.

For functions `f : ι -> α` and `g : ι -> β` between ordered commutative groups `α` and `β`, `f⁻¹` antivaries with `g` if and only if `f` monovaries with `g`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.10 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {f : ι → α} {g : ι → β}, Monovary (-f) g = Antivary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.10` states that for any types `ι`, `α`, and `β`, and for any functions `f : ι → α` and `g : ι → β`, where `α` and `β` are both ordered additive commutative groups, the condition that `-f` monovaries with `g` is equivalent to the condition that `f` antivaries with `g`. In other words, if for all `i` and `j`, `g i < g j` implies `-f i ≤ -f j`, then `g i < g j` also implies `f j ≤ f i` and vice versa.

For functions `f : ι -> α` and `g : ι -> β` between ordered additive commutative groups `α` and `β`, `-f` monovaries with `g` if and only if `f` antivaries with `g`, i.e., `g i < g j` implies both `-f i <= -f j` and `f j <= f i`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.13 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {f : ι → α}
      {g : ι → β}, Monovary f g⁻¹ = Antivary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.13` states that for all types `ι`, `α`, and `β`, where `α` and `β` are ordered commutative groups, and functions `f : ι → α` and `g : ι → β`, the function `f` monovaries with the inverse of `g` if and only if `f` antivaries with `g`. In other words, if for all indices `i` and `j`, `g(i) < g(j)` implies `f(i) ≤ f(j)`, then `g(i) > g(j)` implies `f(j) ≤ f(i)`, and vice versa.

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.13` in Lean 4 states that for ordered commutative groups `α` and `β`, functions `f : ι → α` and `g : ι → β` are monovariant and antivariant with each other if and only if for all indices `i` and `j`, `g(i) < g(j)` if and only if `f(i) ≤ f(j)` and `g(i) > g(j)` if and only if `f(j) ≤ f(i)`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.12 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {f : ι → α} {g : ι → β}, Antivary (-f) g = Monovary f g :=
  by sorry

The `Mathlib.Algebra.Order.Monovary._auxLemma.12` theorem states that for any two functions `f` and `g`, where `f` maps from an arbitrary type `ι` to an ordered additive commutative group `α`, and `g` maps from `ι` to another ordered additive commutative group `β`, the property of `f` being antivariant with `g` under negation (i.e., `f` decreasing when `g` increases) is equivalent to `f` being monovariant with `g` (i.e., `f` increasing when `g` increases).

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.12` in Lean 4 states that for functions `f : ι → α` and `g : ι → β` from an arbitrary type `ι` to ordered additive commutative groups `α` and `β`, respectively, `f` being antivariant with `g` under negation (i.e., `f(x) ≤ f(y)` whenever `g(x) ≥ g(y)`) is equivalent to `f` being monovariant with `g` (i.e., `f(x) ≤ f(y)` whenever `g(x) ≤ g(y)`).


theorem le_map_sub_add_map_sub :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α]
      [inst_2 : AddCommSemigroup β] [inst_3 : LE β] [inst_4 : SubadditiveHomClass F α β] (f : F) (a b c : α),
      f (a - c) ≤ f (a - b) + f (b - c) :=
  by sorry

The theorem `le_map_sub_add_map_sub` states that for any types `F`, `α`, `β` where `F` is a function-like from `α` to `β`, `α` is an additive group, `β` is a commutative semigroup with an order relation (`LE`), and `F` is a subadditive homomorphism class from `α` to `β`, then for any function `f : F` and any elements `a`, `b`, `c` of type `α`, the result of mapping `a - c` through `f` is less than or equal to the sum of the results of mapping `a - b` and `b - c` through `f`. In mathematical notation, this could be expressed as $f(a - c) \leq f(a - b) + f(b - c)$.

For any subadditive homomorphism class `F` from an additive group `α` to a commutative semigroup `β` with an order relation `LE`, and for any `f : F` and elements `a`, `b`, `c` of type `α`, we have `f(a - c) ≤ f(a - b) + f(b - c)`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.15 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {f : ι → α}
      {g : ι → β}, Antivary f g⁻¹ = Monovary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.15` states that for any types `ι`, `α`, and `β`, where `α` and `β` are ordered commutative groups, and for any functions `f : ι → α` and `g : ι → β`, the function `f` antivaries with the inverse of `g` if and only if `f` monovaries with `g`. In other words, if for all `i` and `j` such that `g⁻¹(i) < g⁻¹(j)` implies `f(j) ≤ f(i)`, it also holds true that `g(i) < g(j)` implies `f(i) ≤ f(j)`, and vice versa.

For functions $f : ι → α$ and $g : ι → β$ between ordered commutative groups $α$ and $β$, $f$ antivaries with the inverse of $g$ if and only if $f$ monovaries with $g$.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.14 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {f : ι → α} {g : ι → β}, Monovary f (-g) = Antivary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.14` states that for any types `ι`, `α`, and `β`, where `α` and `β` have ordered additive commutative group structures, and any functions `f : ι → α` and `g : ι → β`, the function `f` monovaries with the negation of `g` if and only if `f` antivaries with `g`. In other words, if for any two elements `i` and `j` in the domain of `f` and `g`, `g(i) < g(j)` implies `f(i) ≤ f(j)`, then and only then `g(i) < g(j)` also implies `f(j) ≤ f(i)`.

For functions $f : ι → α$ and $g : ι → β$ between ordered additive commutative groups, $f$ monovaries with the negation of $g$ if and only if $f$ antivaries with $g$. That is, $i < j$ implies $f(i) ≤ f(j)$ if and only if $i < j$ implies $f(j) ≤ f(i)$.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.16 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {f : ι → α} {g : ι → β}, Antivary f (-g) = Monovary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.16` states that for any types `ι`, `α`, and `β`, where `α` and `β` are ordered additive commutative groups, and any two functions `f : ι → α` and `g : ι → β`, the function `f` antivaries with `(-g)` if and only if it monovaries with `g`. In other words, if for all `i` and `j` such that `(-g(i)) < (-g(j))` implies `f(j) ≤ f(i)`, then it is equivalent to saying that for all `i` and `j` such that `g(i) < g(j)` it implies `f(i) ≤ f(j)`.

For functions between ordered additive commutative groups `f : ι → α` and `g : ι → β`, `f` antivaries with `-g` if and only if it monovaries with `g`. In other words, the order `-g(i) < -g(j)` implies `f(i) ≤ f(j)` if and only if the order `g(i) < g(j)` implies `f(i) ≤ f(j)`.


theorem MeasureTheory.Lp.simpleFunc.uniformInducing :
    ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {p : ENNReal}
      {μ : MeasureTheory.Measure α} [inst_2 : Fact (1 ≤ p)], UniformInducing Subtype.val :=
  by sorry

The theorem `MeasureTheory.Lp.simpleFunc.uniformInducing` states that for any types `α` and `E`, given a measurable space over `α`, a normed add commutative group over `E`, an extended nonnegative real number `p`, a measure `μ` defined on `α`, and the fact that `p` is greater than or equal to 1, the function `Subtype.val` is a uniform inducing function.

In mathematical terms, this theorem suggests that the function `Subtype.val`, which extracts the underlying element from a subtype, provides a uniform structure on the space of simple functions from `α` to `E` which are in `Lp` space with respect to the measure `μ`. This uniform structure is compatible with the topology induced by the `Lp` norm, which is why this function is called uniform inducing.

For any measurable space over a type `α`, normed add commutative group over `E`, measure `μ` on `α`, and `p ≥ 1`, `Subtype.val` is a uniform inducing function for simple `Lp(μ, E)` functions from `α` to `E`.


theorem Ordinal.mul_div_le : ∀ (a b : Ordinal.{u_4}), b * (a / b) ≤ a := by sorry

The theorem `Ordinal.mul_div_le` states that for any two ordinals `a` and `b`, the product of `b` and the quotient of `a` divided by `b` is less than or equal to `a`. In other words, it's asserting that if you divide an ordinal `a` by another ordinal `b`, and then multiply the result by `b`, you get a value that is no greater than the original ordinal `a`. This is a form of the mathematical property that division and multiplication are inverse operations.

For all ordinals a and b, a ÷ b * b ≤ a.


theorem Cardinal.one_le_aleph0 : 1 ≤ Cardinal.aleph0 := by sorry

This theorem states that the cardinal number one is less than or equal to aleph zero. Aleph zero, denoted as `ℵ₀`, is the smallest infinite cardinal number, typically corresponding to the cardinality (size) of the set of natural numbers. In other words, the size of any set with at least one element cannot be larger than the size of the set of natural numbers.

One is less than or equal to aleph zero (ℵ₀).


theorem Vector.get_cons_succ :
    ∀ {n : ℕ} {α : Type u_1} (a : α) (v : Vector α n) (i : Fin n), Vector.get (a ::ᵥ v) (Fin.succ i) = Vector.get v i :=
  by sorry

This theorem states that for any natural number `n`, any type `α`, any element `a` of type `α`, any vector `v` of length `n` with elements of type `α`, and any `i` in the finite set of first `n` natural numbers, the (`i+1`)th element of the vector which is formed by appending `a` at the start of `v`, is the same as the `i`th element of the original vector `v`. In other words, prepending an element to a vector and then accessing the successor of an index, is the same as accessing the element at the original index in the original vector.

For any natural number `n`, any type `α`, any `a : α`, any vector `v : α^n`, and any index `i : ℕ`, the `(i+1)`th element of `[a | v]` equals the `i`th element of `v`.


theorem Real.arccos_neg : ∀ (x : ℝ), Real.arccos (-x) = Real.pi - Real.arccos x := by sorry

The theorem `Real.arccos_neg` states that for any real number `x`, the arccosine of the negation of `x` is equivalent to the difference of the number π and the arccosine of `x`. In more mathematical terms, it states that for all real numbers `x`, the equality `arccos(-x) = π - arccos(x)` holds true. This property is a fundamental identity in trigonometry.

For all real numbers x, arccos(-x) = π - arccos(x).


/-- **Maximum principle** for convex functions. If a function `f` is convex on the convex hull of
`s`, then the eventual maximum of `f` on `convexHull 𝕜 s` lies in `s`.  -/
theorem ConvexOn.exists_ge_of_mem_convexHull :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : LinearOrderedField 𝕜] [inst_1 : AddCommGroup E]
      [inst_2 : LinearOrderedAddCommGroup β] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 β] [inst_5 : OrderedSMul 𝕜 β]
      {s : Set E} {f : E → β}, ConvexOn 𝕜 ((convexHull 𝕜) s) f → ∀ {x : E}, x ∈ (convexHull 𝕜) s → ∃ y ∈ s, f x ≤ f y :=
  by sorry

The **Maximum Principle** for convex functions states that, given a function `f` that is convex on the convex hull of a set `s`, any local maximum of `f` on the convex hull of `s` must be contained within `s` itself. In other words, for any element `x` in the convex hull of `s`, there exists an element `y` in `s` such that the value of `f` at `x` is less than or equal to the value of `f` at `y`. This theorem is applicable under certain conditions, including that the underlying field is a linear ordered field, the space `E` has an addition operation that forms an abelian group, and `β` is a linear ordered additive commutative group that can be scaled by elements of the field.

Given a convex function `f` on a convex set `s` over a linear ordered field, any local maximum of `f` on the convex hull of `s` lies in `s`.


theorem Filter.Tendsto.isBigO_one :
    ∀ {α : Type u_1} (F : Type u_4) {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {f' : α → E'}
      {l : Filter α} [inst_2 : One F] [inst_3 : NormOneClass F] {c : E'},
      Filter.Tendsto f' l (nhds c) → f' =O[l] fun _x => 1 :=
  by sorry

This theorem states that for any types `α`, `F`, `E'` with `F` being a normed space and `E'` being a semi-normed add commutative group, a function `f'` mapping from `α` to `E'`, a filter `l` on `α`, a `1` element in `F` that is a norm one class, and an element `c` in `E'`, if the function `f'` tends towards the neighborhood filter of `c` when `l` is mapped through `f'`, then `f'` is big O of the constant function `1` at filter `l`. In more mathematical terms, if the limit of `f'` as `l` goes to `c` exists, then `f'` is bounded by a constant times the function that is always `1` near `c`.

If a function from a type to a semi-normed add commutative group tends towards a constant in a normed space as a filter on the domain converges, then the function is big O of the constant function 1 with respect to that filter.


theorem Real.sqrt_le_sqrt_iff : ∀ {x y : ℝ}, 0 ≤ y → (Real.sqrt x ≤ Real.sqrt y ↔ x ≤ y) := by sorry

This theorem describes a property of the square root function on real numbers. Specifically, it states that for any two real numbers `x` and `y`, with `y` being nonnegative, the square root of `x` is less than or equal to the square root of `y` if and only if `x` is less than or equal to `y`.

For all real numbers x and y with y ≥ 0, √x ≤ √y if and only if x ≤ y.


theorem Rat.divInt_ne_zero : ∀ {a b : ℤ}, b ≠ 0 → (Rat.divInt a b ≠ 0 ↔ a ≠ 0) := by sorry

The theorem `Rat.divInt_ne_zero` states that for all integers `a` and `b`, if `b` is not equal to zero, then the quotient of `a` divided by `b` (using the function `Rat.divInt`) is not equal to zero if and only if `a` is not equal to zero. In other words, a nonzero integer divided by another nonzero integer will give a nonzero rational number, and vice versa.

For all integers a and b, Rat.divInt a b ≠ 0 if and only if a ≠ 0 and b ≠ 0.


theorem MeasureTheory.IsSetSemiring.sUnion_diffFinset :
    ∀ {α : Type u_1} {C : Set (Set α)} {s t : Set α} (hC : MeasureTheory.IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C),
      ⋃₀ ↑(MeasureTheory.IsSetSemiring.diffFinset hC hs ht) = s \ t :=
  by sorry

This theorem states that in the context of a semi-ring of sets `C`, for any two sets `s` and `t` in `C`, the union of the finite set of sets returned by the `diffFinset` function in the `MeasureTheory.IsSetSemiring` structure is equal to the set difference `s \ t`. The `diffFinset` function yields a finite set of sets in `C` such that their disjoint union equals to `s \ t`. Specifically, for any type `α`, and for any sets `s`, `t`, and `C` of type `Set α`, if `C` forms a semi-ring of sets, and `s` and `t` are elements of `C`, then the union of the sets in the finite set returned by `diffFinset` equals the set difference of `s` and `t`.

In a semi-ring of sets `C`, for any `s` and `t` in `C`, the union of the sets returned by `diffFinset s t` equals `s \ t`.


theorem WithBot.coe_le_iff : ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α}, ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b := by
  sorry

This theorem, `WithBot.coe_le_iff`, states that for any type `α` with a less than or equal to (`≤`) relation, and any element `a` of type `α`, and any element `x` of the type `WithBot α` (which is `α` with a bottom element), the coerced element `a` is less than or equal to `x` if and only if there exists an element `b` such that `x` equals the coerced `b` and `a` is less than or equal to `b`. In other words, an element of `α` is less than or equal to an element of `WithBot α` if and only if it is less than or equal to some actual element of `α` that `x` represents.

For any type `α` with a total order and any `α` elements `a` and `x` where `x` is of type `WithBot α`, `a ≤ x` if and only if there exists `b : α` such that `x = WithBot.coe b` and `a ≤ b`.


theorem Equiv.symm_swap : ∀ {α : Sort u_1} [inst : DecidableEq α] (a b : α), (Equiv.swap a b).symm = Equiv.swap a b :=
  by sorry

The theorem `Equiv.symm_swap` states that for any type `α` that has decidable equality, and for any two elements `a` and `b` of type `α`, the inverse of the permutation that swaps `a` and `b` (denoted as `(Equiv.swap a b).symm`) is actually the same as the original permutation that swaps `a` and `b` (denoted as `Equiv.swap a b`). In essence, this theorem confirms that swapping `a` and `b` twice will return to the original arrangement, regardless of the type `α` as long as equality is decidable for that type. This can be seen as a generalization of the fact that the inverse of a swap operation in basic combinatorics is the swap operation itself.

For any type `α` with decidable equality, the inverse of swapping elements `a` and `b` is equivalent to swapping them back, i.e., `(Equiv.swap a b).symm = Equiv.swap a b`.


theorem Function.iterate_injOn_Iio_minimalPeriod :
    ∀ {α : Type u_1} {f : α → α} {x : α}, Set.InjOn (fun x_1 => f^[x_1] x) (Set.Iio (Function.minimalPeriod f x)) := by
  sorry

This theorem states that for any type 'α', a function 'f' from 'α' to 'α', and an element 'x' of type 'α', the function defined by the nth iteration of 'f' applied to 'x' is injective on the left-infinite right-open interval up to the minimal period of 'x' under the endomorphism 'f'. In other words, for each pair of natural numbers less than the minimal period of 'x', if the nth iteration of 'f' applied to 'x' equals the mth iteration of 'f' applied to 'x', then n must equal m.

For any endomorphism (function) 'f' on type 'α' and element 'x' of type 'α' with minimal period 'p', if the nth and mth applications of 'f' to 'x' are equal for some natural numbers 'n' and 'm' less than 'p', then 'n' equals 'm'.


theorem Filter.Tendsto.sup_nhds' :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Sup L]
      [inst_2 : ContinuousSup L],
      Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (f ⊔ g) l (nhds (x ⊔ y)) :=
  by sorry

This theorem states that for any two functions `f` and `g` mapping from a generic type `α` to a topological space `L`, and given that the type `L` supports a supremum operation (denoted by `⊔`) and that this supremum operation is continuous, if `f` tends to a neighborhood of a point `x` and `g` tends to a neighborhood of a point `y` (with respect to some filter `l`), then the function that maps each point in the domain to the supremum of the images of `f` and `g` at that point also tends towards the neighborhood of the supremum of `x` and `y`. In mathematical terms, if $\lim_{l} f = x$ and $\lim_{l} g = y$, then $\lim_{l} (f ⊔ g) = x ⊔ y$.

Given functions `f` and `g` from type `α` to a topological space `L` with a continuous supremum operation, if `f` converges to `x` and `g` converges to `y` (with respect to some filter) then `f ⊔ g` converges to `x ⊔ y`.


theorem MeasureTheory.extend_empty :
    ∀ {α : Type u_1} {P : Set α → Prop} {m : (s : Set α) → P s → ENNReal} (P0 : P ∅),
      m ∅ P0 = 0 → MeasureTheory.extend m ∅ = 0 :=
  by sorry

This theorem, `MeasureTheory.extend_empty`, states that for any type `α`, any property `P` of sets of `α`, and any function `m` from sets of `α` satisfying `P` to the extended nonnegative real numbers `ENNReal`, if the empty set satisfies property `P` and `m` maps the empty set to zero, then the extension of `m` using `MeasureTheory.extend` also maps the empty set to zero. Essentially, it guarantees that the extended function will preserve the zero measure of the empty set, which is a basic requirement in a measure theory context.

If `m` is a measure function on sets of type `α` satisfying `P`, mapping the empty set to zero, then the extended measure `MeasureTheory.extend m` also maps the empty set to zero.


theorem Multiset.inf_dedup :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderTop α] [inst_2 : DecidableEq α] (s : Multiset α),
      Multiset.inf (Multiset.dedup s) = Multiset.inf s :=
  by sorry

The theorem `Multiset.inf_dedup` states that for any type `α` that is a semilattice with an infimum operation, has a top element, and for which equality is decidable, the infimum of a multiset `s` remains the same even after removing duplicates from `s`. In other words, for any multiset `s` of elements of such a type `α`, the infimum of `s` is equal to the infimum of `s` with duplicates removed. This is characterized by the equation `Multiset.inf (Multiset.dedup s) = Multiset.inf s`.

For any semilattice `α` with decidable equality and a top element, the infimum of a multiset remains unchanged when duplicates are removed. That is, `Multiset.inf (Multiset.dedup s) = Multiset.inf s` for any multiset `s` of elements from `α`.


theorem Cardinal.mk_preimage_of_subset_range_lift :
    ∀ {α : Type u} {β : Type v} (f : α → β),
      ∀ s ⊆ Set.range f, Cardinal.lift.{u, v} (Cardinal.mk ↑s) ≤ Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s)) :=
  by sorry

The theorem `Cardinal.mk_preimage_of_subset_range_lift` states that for any types `α` and `β` and any function `f` from `α` to `β`, if a set `s` is a subset of the range of `f`, then the cardinality of `s` lifted from universe `u` to `v` is less than or equal to the cardinality of the preimage of `s` under the function `f` lifted from universe `v` to `u`.

In more mathematical terms, given any set $s$ that is a subset of the image of a function $f : \alpha \rightarrow \beta$, the cardinality of $s$ when regard as an element of the larger universe (represented in Lean as `Cardinal.lift.{u, v} (Cardinal.mk ↑s)`) is always less than or equal to the cardinality of the set of all elements in $\alpha$ that map to an element in $s$ (represented in Lean as `Cardinal.mk ↑(f ⁻¹' s)`), when the latter is regarded as an element of the larger universe.

For any function `f` from type `α` to type `β` and subset `s` of `f`'s range, the lifted cardinality of `s` is less than or equal to the lifted cardinality of `f`'s preimage of `s`.


theorem Int.gc_ceil_coe :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], GaloisConnection Int.ceil Int.cast := by sorry

The theorem `Int.gc_ceil_coe` states that for all types `α`, where `α` is a linearly ordered ring and also a floor ring, a Galois connection exists between the function `Int.ceil` and the function `Int.cast`. In other words, for every element `a` from the domain of `Int.ceil` and `b` from the domain of `Int.cast`, `Int.ceil a` is less than or equal to `b` if and only if `a` is less than or equal to `Int.cast b`. This links the concepts of ceiling function and integer casting in a context of ordered rings.

For all linearly ordered ring and floor ring types `α`, the ceiling function `Int.ceil` and the integer casting function `Int.cast` form a Galois connection, i.e., `Int.ceil a ≤ b` if and only if `a ≤ Int.cast b` for all `a` in the domain of `Int.ceil` and `b` in the domain of `Int.cast`.