theorem MeasureTheory.measure_iUnion_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : Countable β]
      (s : β → Set α), ↑↑μ (⋃ i, s i) ≤ ∑' (i : β), ↑↑μ (s i) :=
  by sorry

The theorem `MeasureTheory.measure_iUnion_le` states that for any types `α` and `β`, given a measurable space on `α` and a countable set of indices `β`, if `s` is a function mapping each index in `β` to a set in `α`, then the measure of the union of all sets `s i` (where `i` ranges over each index in `β`) with respect to a measure `μ` is less than or equal to the sum of the measures of each individual set `s i`. This theorem corresponds to the sub-additivity property of measures, stating that the measure of a union of sets is not greater than the sum of their individual measures.

For any measurable space with measure `μ`, and a countable collection of measurable sets `{s i | i ∈ β}`, the measure of their union is less than or equal to the sum of the measures of each individual set. `μ(⋃i∈β si) ≤ ∑i∈β μ(si)`


theorem Ordinal.sub_self : ∀ (a : Ordinal.{u_4}), a - a = 0 := by sorry

The theorem `Ordinal.sub_self` states that for any ordinal `a`, subtracting `a` from itself results in zero. This is an instance of the property that in any number system, the subtraction of a number from itself yields zero. In the context of ordinals, which are equivalence classes of well-ordered sets, this theorem asserts that if we subtract an ordinal from itself, we obtain the ordinal zero, which represents the class of all empty well-ordered sets.


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

This theorem states that for every pair of distinct integer numbers `m` and `n`, the distance between `m` and `n` (denoted as `dist m n`) is always greater than or equal to 1. In other words, the pairwise distance between any two different integers is always at least 1.

For all integers m and n with m ≠ n, dist(m, n) ≥ 1.


theorem Real.continuous_arcsin : Continuous Real.arcsin := by sorry

The theorem `Real.continuous_arcsin` states that the function `Real.arcsin`, which is defined as the inverse of the sine function, is continuous. In mathematical terms, for any real number `x`, the limit as `y` approaches `x` of `Real.arcsin(y)` is equal to `Real.arcsin(x)`. This applies for all real numbers within the domain of `Real.arcsin`, which is from `-π / 2` to `π / 2`, inclusive.

The function `Real.arcsin` is continuous on the interval `[-π/2, π/2]`.


theorem Set.mem_iUnion_of_mem :
    ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {a : α} (i : ι), a ∈ s i → a ∈ ⋃ i, s i := by sorry

The theorem `Set.mem_iUnion_of_mem` states that for any type `α`, any indexing type `ι`, any function `s` from `ι` to a set of `α`, and any element `a` of `α`, if `a` belongs to the set `s i` for some index `i` of type `ι`, then `a` also belongs to the union of all sets `s i` for all `i` in `ι`. In other words, if an element is in any of the sets, it is also in their union.

If `α` is a type, `ι` is an indexing type, `s : ι → Set α`, and `a : α`, then `a ∈ ⋃i : ι. s i` whenever there exists an `i : ι` such that `a ∈ s i`.


theorem CategoryTheory.Linear.comp_units_smul :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type w}
      [inst_2 : Semiring R] [inst_3 : CategoryTheory.Linear R C] {X Y Z : C} (f : X ⟶ Y) (r : Rˣ) (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (r • g) = r • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

This theorem, named `CategoryTheory.Linear.comp_units_smul`, states that for any categories `C`, with additional structures of preadditivity and being linear over a semiring `R`, and for any three objects `X`, `Y`, and `Z` in `C`, the composition of a morphism `f` from `X` to `Y` and a scalar multiple `r • g` of another morphism `g` from `Y` to `Z` is the same as the scalar multiple `r •` of the composition of `f` and `g`.

In other words, it states that scalar multiplication interacts with composition of morphisms in the same way as it does in linear algebra: `(f ∘ (r · g)) = r · (f ∘ g)`, where '∘' denotes composition of morphisms, '·' denotes scalar multiplication, and `r` is an element from the semiring `R`.

For any morphisms $f : X \to Y$ and $g : Y \to Z$ in a preadditive, linear category over a semiring $R$, the composition $f \circ (r \cdot g) = r \cdot (f \circ g)$, where $r \in R$ and $\cdot$ denotes scalar multiplication and composition respectively.


theorem List.countP_cons_of_pos :
    ∀ {α : Type u_1} (p : α → Bool) {a : α} (l : List α), p a = true → List.countP p (a :: l) = List.countP p l + 1 :=
  by sorry

This theorem is about counting the elements in a list that satisfy a certain condition. For any type `α`, any function `p` from `α` to `Bool`, any element `a` of type `α`, and any list `l` of elements of type `α`, if the function `p` applied to `a` equals `true`, then the count of elements in the list `a :: l` that satisfy `p` is equal to the count of elements in `l` that satisfy `p`, plus one. This is because the element `a` is added to the beginning of the list `l`, and it satisfies the condition `p`.

For any type `α`, list `l` of `α`, element `a` of `α`, and function `p` from `α` to `Bool`, if `p(a) = true`, then the number of elements in `l` satisfying `p` is equal to the number of elements in `a :: l` satisfying `p`.


theorem Set.mem_mul : ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a : α}, a ∈ s * t ↔ ∃ x ∈ s, ∃ y ∈ t, x * y = a :=
  by sorry

This theorem, named `Set.mem_mul`, is a statement about sets and multiplication in some type `α` which is equipped with a multiplication operation. It states that for any fixed type `α` that has multiplication, and any two sets `s` and `t` of elements of this type, alongside any element `a` from `α`, `a` is an element of the product of `s` and `t` if and only if there exist elements `x` in `s` and `y` in `t` such that the product of `x` and `y` equals `a`. In other words, this theorem defines the notion of membership in the product of two sets in the context of a type with multiplication.

For any sets $S, T$ of elements from a type $\alpha$ with multiplication, and any $a \in \alpha$, $a \in S \times T$ if and only if there exist $x \in S$ and $y \in T$ such that $x \cdot y = a$.


theorem Subgroup.subtype_injective :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Function.Injective ⇑(Subgroup.subtype H) := by sorry

The theorem `Subgroup.subtype_injective` states that for any given subgroup `H` of a group `G`, the function produced by `Subgroup.subtype H` is injective. In other words, if we have two elements from the subgroup `H` and they map to the same element in the group `G` under the `Subgroup.subtype H` function, then those two elements must have been the same to begin with. This is a property of the natural group homomorphism from a subgroup of a group to the group itself.

The function `Subgroup.subtype` from a subgroup `H` of a group `G` to `G` is an injection.


theorem IsCoprime.of_add_mul_left_right :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime x (y + x * z) → IsCoprime x y := by sorry

The theorem `IsCoprime.of_add_mul_left_right` states that for all types `R` that are commutative semirings, and for all elements `x`, `y`, and `z` of `R`, if `x` and `y + x * z` are coprime, then `x` and `y` are also coprime. Here, two elements are said to be coprime if there exist two other elements `a` and `b` such that `a * x + b * y = 1`.

If `x` and `(y + x * z)` are coprime in a commutative semiring `R`, then `x` and `y` are coprime.


theorem iterate_succ_toZ :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
      {i0 : ι} (i : ι), i0 ≤ i → Order.succ^[Int.toNat (toZ i0 i)] i0 = i :=
  by sorry

This theorem states that for all types `ι` with a linear order, a successor order, a successor archimedean order, and a predecessor order, with a given initial element `i0`, and for any other element `i` in `ι` such that `i0` is less than or equal to `i`, applying the successor function to `i0` the number of times specified by converting `toZ` of `i0` and `i` to a natural number, you will obtain `i`. In other words, it says that you can get from `i0` to `i` by successively applying the successor function as many times as the natural number equivalent of `toZ` of `i0` and `i`.

For all types `ι` with a linear order and an initial element `i0`, if `i` is any element with `i0 ≤ i`, then `i0` is the `toZ i0`-th successor of `i0`, i.e., `i = i0 ^ (toZ i0) ^... ^ (toZ i0) ^ i0` where the exponent `n` is equal to `toZ i i0` (the natural number representation of `i` and `i0`).


theorem Nat.nth_strictMonoOn :
    ∀ {p : ℕ → Prop} (hf : Set.Finite (setOf p)), StrictMonoOn (Nat.nth p) (Set.Iio (Set.Finite.toFinset hf).card) := by
  sorry

The theorem `Nat.nth_strictMonoOn` states that for any predicate `p` on natural numbers, if the set of natural numbers satisfying `p` is finite, then the function `Nat.nth p`, which returns the `n`-th natural number satisfying `p`, is strictly monotonic on the left-infinite right-open interval determined by the cardinality of the finset representation of the set. In simpler terms, if we take the set of all natural numbers that satisfy a certain condition and this set is finite, then as we look at the sequence of these numbers in increasing order, each number in sequence is smaller than the next one as long as we stay within the bounds defined by the size of this set.

If a finite set of natural numbers is ordered by the natural numbers themselves, then the function returning the n-th element of the set is strictly increasing.


theorem Set.mem_neg : ∀ {α : Type u_2} [inst : Neg α] {s : Set α} {a : α}, a ∈ -s ↔ -a ∈ s := by sorry

This theorem, named as `Set.mem_neg`, states that for any type `α` that has a negation operation, and for any set `s` of elements of type `α`, and for any element `a` of type `α`, the element `a` belongs to the negation of set `s` if and only if the negation of `a` belongs to set `s`. This theorem essentially establishes a relationship between an element and its negation in relation to their membership in a set and its negation.

For any set `s` of type `α` and any element `a` of type `α` in a type with negation, `a` is in the negation of `s` if and only if the negation of `a` is in `s`.


theorem Ultrafilter.finite_sUnion_mem_iff :
    ∀ {α : Type u} {f : Ultrafilter α} {s : Set (Set α)}, Set.Finite s → (⋃₀ s ∈ f ↔ ∃ t ∈ s, t ∈ f) := by sorry

This theorem states that for any type `α`, any Ultrafilter `f` on `α`, and any set `s` of subsets of `α`, if `s` is finite, then the union of all subsets in `s` belongs to the Ultrafilter `f` if and only if there exists a subset `t` in `s` such that `t` belongs to `f`. In mathematical terms, if `s` is a finite collection of subsets of `α`, the union of `s` is in `f` exactly when at least one of the subsets in `s` is in `f`.

For any ultrafilter `f` on a type `α` and finite set `s` of subsets of `α`, the union of `s` is in `f` if and only if some subset in `s` is in `f`.


MeasureTheory.NullMeasurableSet.vadd

theorem MeasureTheory.NullMeasurableSet.vadd :
    ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : AddGroup G] [inst_1 : AddAction G α]
      [inst_2 : MeasurableSpace G] [inst_3 : MeasurableVAdd G α] {μ : MeasureTheory.Measure α}
      [inst_4 : MeasureTheory.VAddInvariantMeasure G α μ] {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → ∀ (c : G), MeasureTheory.NullMeasurableSet (c +ᵥ s) μ :=
  by sorry

The theorem `MeasureTheory.NullMeasurableSet.vadd` states that for any type `G` with an addition (`AddGroup`) operation, type `α` with a `MeasurableSpace` and an `AddAction` of `G` on `α`, and a set `s` of type `α`, if `s` is a null measurable set with respect to a measure `μ` which is invariant under the action of `G` (represented by `MeasureTheory.VAddInvariantMeasure`), then for any element `c` of type `G`, the translated set `c +ᵥ s` (representing the addition of `c` to every element of `s`) is also a null measurable set with respect to `μ`. This theorem essentially states that translation by a group element keeps null measurability property intact.

If `s` is a null measurable set in the measurable space `(α, Σ, μ)` with respect to the invariant measure `μ` under the additive action of the group `G`, then for all `c` in `G`, the translated set `c + s` is also a null measurable set.


theorem PowerSeries.coeff_derivativeFun :
    ∀ {R : Type u_1} [inst : CommSemiring R] (f : PowerSeries R) (n : ℕ),
      (PowerSeries.coeff R n) (PowerSeries.derivativeFun f) = (PowerSeries.coeff R (n + 1)) f * (↑n + 1) :=
  by sorry

This theorem states that for any commutative semiring `R` and any power series `f` over `R`, the `n`th coefficient of the formal derivative of `f` is equal to the `n+1`th coefficient of `f` times `n+1`. In other words, when we take the derivative of a power series, the coefficient of the `n`th term in the derivative is the same as the coefficient of the `(n+1)`th term in the original series, multiplied by `n+1`.

For any commutative semiring `R` and power series `f` over `R`, the `n`th coefficient of the formal derivative of `f` equals `(n+1)` times the `(n+1)`th coefficient of `f`.


theorem Multiset.rel_map :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {δ : Type u_3} {p : γ → δ → Prop} {s : Multiset α} {t : Multiset β}
      {f : α → γ} {g : β → δ},
      Multiset.Rel p (Multiset.map f s) (Multiset.map g t) ↔ Multiset.Rel (fun a b => p (f a) (g b)) s t :=
  by sorry

The theorem `Multiset.rel_map` states that for any types `α`, `β`, `γ`, `δ`, a binary relation `p` between `γ` and `δ`, multisets `s` of type `α` and `t` of type `β`, and functions `f` from `α` to `γ` and `g` from `β` to `δ`, the relation `p` holds between the multisets obtained by mapping `f` and `g` over `s` and `t` respectively if and only if the relation `p` composed with `f` and `g` holds between `s` and `t`. In other words, mapping `f` and `g` over `s` and `t` and then applying the relation `p` is equivalent to directly applying the relation `p` composed with `f` and `g` to `s` and `t`.

For multisets $s$ of type $\alpha$, $t$ of type $\beta$, functions $f:\alpha\to\gamma$, $g:\beta\to\delta$, and a binary relation $p$ between $\gamma$ and $\delta$, we have $s\mathbin{R}t$ if and only if $(f\circ s)\mathbin{R}(g\circ t)$, where $\mathbin{R}$ denotes the relation $p$.


theorem MeasureTheory.lintegral_mono_fn :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} ⦃f g : α → ENNReal⦄,
      (∀ (x : α), f x ≤ g x) → MeasureTheory.lintegral μ f ≤ MeasureTheory.lintegral μ g :=
  by sorry

This theorem, `MeasureTheory.lintegral_mono_fn`, asserts that for any type `α`, any measurable space `m` of type `α`, and any measure `μ` of that measurable space, if we have two functions `f` and `g` that map from `α` to the extended nonnegative real numbers (denoted `[0, ∞]`), then if `f` is less than or equal to `g` at every point in `α`, the lower Lebesgue integral of `f` with respect to `μ` is less than or equal to the lower Lebesgue integral of `g` with respect to `μ`. This is a form of monotonicity property for the lower Lebesgue integral. In mathematical terms, if `∀x∈α, f(x) ≤ g(x)`, then `∫ f dμ ≤ ∫ g dμ`.

If `α` is a type, `m` is a measurable space on `α`, `μ` is a measure on `m`, and `f` and `g` are measurable functions from `α` to `[0, ∞]` with `f(x) ≤ g(x)` for all `x ∈ α`, then `∫ f dμ ≤ ∫ g dμ`.


List.Chain'.imp

theorem List.Chain'.imp :
    ∀ {α : Type u} {R S : α → α → Prop},
      (∀ (a b : α), R a b → S a b) → ∀ {l : List α}, List.Chain' R l → List.Chain' S l :=
  by sorry

The theorem `List.Chain'.imp` states that for any type `α` and any two relations `R` and `S` on `α`, if every pair `(a, b)` of `α` that satisfies `R` also satisfies `S`, then for any list of `α`, if `R` holds between every pair of adjacent elements in the list, then `S` also holds between every pair of adjacent elements in the list. In other words, if `S` is implied by `R` and `R` forms a chain in the list, then `S` also forms a chain in the same list.

If relation `S` is implied by relation `R` and `R` forms a chain in a list, then `S` also forms a chain in the same list.


theorem Fintype.card_of_finset' :
    ∀ {α : Type u_1} {p : Set α} (s : Finset α),
      (∀ (x : α), x ∈ s ↔ x ∈ p) → ∀ [inst : Fintype ↑p], Fintype.card ↑p = s.card :=
  by sorry

The theorem `Fintype.card_of_finset'` in Lean 4 expresses a property of finite sets (fintypes) and their cardinalities. Specifically, it states that for any given type `α`, a predicate `p` defining a set of elements of type `α`, and a finite set `s` of elements of type `α`, if every element `x` of type `α` satisfies the condition that `x` is in `s` if and only if `x` is in `p` (i.e., `s` and `p` define the same set), then, assuming the set defined by `p` is a fintype (i.e., a finite set), the cardinality of the set defined by `p` (denoted `Fintype.card ↑p`) is equal to the cardinality of `s` (denoted `s.card`).

If `p` is a proposition defining a finite set and is equivalent to the membership in a finite set `s`, then the cardinalities of `s` and `{x : α | p x}` are equal.


theorem Computation.exists_of_mem_map :
    ∀ {α : Type u} {β : Type v} {f : α → β} {b : β} {s : Computation α}, b ∈ Computation.map f s → ∃ a ∈ s, f a = b :=
  by sorry

The theorem `Computation.exists_of_mem_map` states that for all types `α` and `β`, for every function `f` from `α` to `β`, and for every value `b` of type `β` and computation `s` of type `α`, if `b` is in the computation obtained by mapping `f` over `s`, then there exists a value `a` in the computation `s` such that `f(a) = b`. In other words, if a value is in the result of a computation after applying a function to it, then that value must have come from applying the function to some value in the original computation.

For all types `α` and `β`, and for every function `f` from `α` to `β` and computation `s` of type `α`, if `b ∈ map f s`, then there exists `a ∈ s` such that `f(a) = b`.


theorem Set.image2_left_comm :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} {s : Set α} {t : Set β}
      {u : Set γ} {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε},
      (∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)) →
        Set.image2 f s (Set.image2 g t u) = Set.image2 g' t (Set.image2 f' s u) :=
  by sorry

This theorem, `Set.image2_left_comm`, states that for any types `α`, `β`, `γ`, `δ`, `δ'`, `ε`, and three sets `s` of type `α`, `t` of type `β`, and `u` of type `γ`, given two binary functions `f : α → δ → ε`, `g : β → γ → δ`, a binary function `f' : α → γ → δ'`, and another binary function `g' : β → δ' → ε`, if for every element `a` in set `s`, `b` in set `t`, and `c` in set `u`, the result of applying `f` to `a` and the result of applying `g` to `b` and `c` equals the result of applying `g'` to `b` and the result of applying `f'` to `a` and `c`, then the image of set `s` under the binary function `f` and the image of the image of sets `t` and `u` under the binary function `g` is equal to the image of the image of sets `t` and `s` under the binary function `g'` and `f'` respectively. This is a form of left commutativity property in the context of set images under binary functions.

For sets $s:\alpha$, $t:\beta$, $u:\gamma$, and functions $f:\alpha \rightarrow \delta \rightarrow \varepsilon$, $g:\beta \rightarrow \gamma \rightarrow \delta$, $f':\alpha \rightarrow \gamma \rightarrow \delta'$, and $g':\beta \rightarrow \delta' \rightarrow \varepsilon$, if $f(a, g(b, c)) = g'(b, f'(a, c))$ for all $a \in s$, $b \in t$, and $c \in u$, then $f[s] \subseteq g'[g[t], f'[s]]$.


PSet.Equiv.rfl

theorem PSet.Equiv.rfl : ∀ {x : PSet}, PSet.Equiv x x := by sorry

This theorem states that for any pre-set `x`, `x` is extensionally equivalent to itself. In mathematical terms, for any pre-set `x` (denoted as `PSet.mk α A`), for every element `a` in α, there exists an element `b` such that a is extensionally equivalent to `B b`, and vice versa. Essentially, this theorem is asserting the reflexivity of extensional equivalence on pre-sets.

For any pre-set `x` (`PSet.mk α A`), every element `a` in `α` is extensionally equivalent to itself.


theorem Polynomial.natDegree_map_le :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (p : Polynomial R),
      Polynomial.natDegree (Polynomial.map f p) ≤ Polynomial.natDegree p :=
  by sorry

The theorem `Polynomial.natDegree_map_le` states that for any semirings `R` and `S`, and for any ring homomorphism `f` from `R` to `S`, and for any polynomial `p` over `R`, the natural degree of the polynomial obtained by mapping `p` across `f` (denoted as `Polynomial.map f p`) is less than or equal to the natural degree of `p`. In other words, applying a ring homomorphism to a polynomial does not increase its natural degree.

For any semiring homomorphism $f$ and polynomial $p$, the natural degree of $Polynomial.map\ f\ p$ is less than or equal to the natural degree of $p$.


theorem Equivalence.eqvGen_iff :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, Equivalence r → (EqvGen r a b ↔ r a b) := by sorry

This theorem, named `Equivalence.eqvGen_iff`, is about an equivalence relation `r` on a type `α`. Given elements `a` and `b` of this type, the theorem states that if `r` is an equivalence relation, then the `EqvGen r a b` (the reflexive, symmetric, and transitive closure of `r`) is equivalent to `r a b`. In other words, if `r` is an equivalence relation, `a` and `b` are related by the closure of `r` if and only if `a` and `b` are directly related by `r`.

For an equivalence relation `r` on type `α` and elements `a` and `b` of `α`, `EqvGen r a b` is equivalent to `r a b`.


theorem List.countP_cons_of_neg :
    ∀ {α : Type u_1} (p : α → Bool) {a : α} (l : List α), ¬p a = true → List.countP p (a :: l) = List.countP p l := by
  sorry

This theorem states that for any type `α`, any function `p` from `α` to Boolean values, any element `a` of type `α`, and any list `l` of elements of type `α`, if `p a` is not true, then the count of elements in the list obtained by prepending `a` to `l` that satisfies `p`, `List.countP p (a :: l)`, equals the count of elements in `l` that satisfies `p`, `List.countP p l`. In other words, if a given predicate `p` does not hold for an element `a`, then adding `a` to the front of a list `l` does not change the number of elements in the list for which the predicate `p` holds.

If `p(a)` is false, then the number of elements in the list `a :: l` satisfying `p` equals the number of elements in list `l` satisfying `p`.


/-- Note: the converse is not true. For a counterexample, see
Walter Rudin *Real and Complex Analysis*, example (c) in section 8.9. It is true if the set is
measurable, see `ae_prod_mem_iff_ae_ae_mem`.  -/
theorem MeasureTheory.Measure.ae_ae_of_ae_prod :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] {p : α × β → Prop},
      (∀ᵐ (z : α × β) ∂MeasureTheory.Measure.prod μ ν, p z) → ∀ᵐ (x : α) ∂μ, ∀ᵐ (y : β) ∂ν, p (x, y) :=
  by sorry

The theorem `MeasureTheory.Measure.ae_ae_of_ae_prod` asserts that for any two measurable spaces `α` and `β`, and two measures `μ` and `ν` where `ν` is s-finite, if a property `p` holds almost everywhere on the product space `α × β` with respect to the product measure, then it follows that for almost every `x` in `α` with respect to `μ` and for almost every `y` in `β` with respect to `ν`, the property `p` holds on the pair `(x, y)`. Note that the converse of this statement is not generally true.

Given measurable spaces `α` and `β`, measures `μ` on `α` and `ν` on `β` (WITH `ν` s-finite), if a property `p` holds almost everywhere on `α × β` with respect to the product measure, then `p` holds almost everywhere on `α × β` with respect to `μ` and almost everywhere on `β` with respect to `ν`.


SMul.comp.isScalarTower

/-- Given a tower of scalar actions `M → α → β`, if we use `SMul.comp`
to pull back both of `M`'s actions by a map `g : N → M`, then we obtain a new
tower of scalar actions `N → α → β`.

This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables.
 -/
theorem SMul.comp.isScalarTower :
    ∀ {M : Type u_1} {N : Type u_2} {α : Type u_6} {β : Type u_7} [inst : SMul M α] [inst_1 : SMul M β]
      [inst_2 : SMul α β] [inst_3 : IsScalarTower M α β] (g : N → M), IsScalarTower N α β :=
  by sorry

This theorem states that for any types `M`, `N`, `α` and `β`, if we have scalar actions `M → α → β` forming a tower (meaning that the scalar multiplication is associative across the types), and there exists a map `g` from `N` to `M`, then we can construct a new tower of scalar actions `N → α → β` using `SMul.comp` to pull back `M`'s actions. However, this cannot be an instance as it can result in infinite loops when the `SMul` arguments are still not fully instantiated, i.e., when they are metavariables.

Given types `M`, `N`, `α`, `β`, and a tower of scalar actions `M → α → β`, if there exists a map `g : N → M`, then we can construct a new tower of scalar actions `N → α → β` by pulling back `M`'s actions using `SMul.comp`. (However, this cannot be an instance due to potential infinite loops with uninstantiated `SMul` arguments.)


theorem even_bit0 : ∀ {α : Type u_2} [inst : Semiring α] (a : α), Even (bit0 a) := by sorry

The theorem `even_bit0` states that for all elements `a` of any type `α` that forms a semiring, the function `bit0 a` (which returns `a + a`) produces an "Even" number. Here, an element is considered "Even" if it can be expressed as the sum of two identical elements. Thus, the result `a + a` by definition is always an Even number.

For all semiring elements `a`, the result of adding `a` to itself, `a + a`, is an element expressible as the sum of two identical elements. In other words, `a + a` is even.


theorem Mathlib.Data.Rel._auxLemma.9 :
    ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ := by
  sorry

The theorem `Mathlib.Data.Rel._auxLemma.9` states that for any type `α`, any predicate `p` on `α`, and any predicate `q` on the existence proof of `p`, the statement "for all existence proofs of `p`, `q` holds" is equivalent to "for all `x` of type `α` for which `p` holds, `q` holds". Here, 'holds' means that the predicate returns true. Essentially, it's stating that the two formulations are equivalent ways of expressing that `q` is true for all `x` for which `p` is true.

For any type `α`, predicate `p` on `α`, and predicate `q` on existence proofs of `p`, the statement "for all `x` in `α` with `p(x)`, `q(existence proof of `p`(x))` holds" is equivalent to "for all existence proofs of `p` in `α`, `q` holds".


theorem Mathlib.Data.Rel._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} (r : Rel α β) (y : β) (s : Set α), (y ∈ Rel.image r s) = ∃ x ∈ s, r x y := by sorry

The theorem `Mathlib.Data.Rel._auxLemma.2` states that for any two types `α` and `β`, a relation `r` from `α` to `β`, a set `s` of type `α`, and an element `y` of type `β`, the element `y` belongs to the image of the set `s` under the relation `r` if and only if there exists an element `x` belonging to the set `s` such that `r x y` holds. In other words, `y` is in the image of `s` via `r` precisely when there's an element in `s` related to `y` by `r`.

For any relation $r$ from type $\alpha$ to type $\beta$, set $s$ of type $\alpha$, and element $y$ of type $\beta$, $y$ lies in the image of $s$ under $r$ if and only if there exists an $x$ in $s$ such that $r(x) = y$.


theorem List.foldl_hom :
    ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} (f : α₁ → α₂) (g₁ : α₁ → β → α₁) (g₂ : α₂ → β → α₂) (l : List β)
      (init : α₁),
      (∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y)) → List.foldl g₂ (f init) l = f (List.foldl g₁ init l) :=
  by sorry

This theorem, `List.foldl_hom`, establishes a homomorphism property for the `List.foldl` operation. It assumes types `α₁`, `α₂` and `β`, and functions `f : α₁ → α₂`, `g₁ : α₁ → β → α₁` and `g₂ : α₂ → β → α₂`. It also takes a list `l : List β` and an initial accumulator `init : α₁`. If `g₂` composed with `f` is equivalent to `f` composed with `g₁` for any pair of inputs `(x : α₁, y : β)`, then folding `l` from the left with `g₂` and `f init` is the same as applying `f` to the result of folding `l` from the left with `g₁` and `init`. This basically states that the function `f` can be "distributed" across the fold operation, under certain conditions.

If `g₂ ∘ f = f ∘ g₁` for all `x : α₁` and `y : β`, then `List.foldl g₂ x (List.map (λx => (f x, x)) l) = List.foldl g₁ x l`.


theorem Mathlib.GroupTheory.Subsemigroup.Basic._auxLemma.8 : ∀ {M : Type u_1} [inst : Add M] (x : M), (x ∈ ⊤) = True :=
  by sorry

This theorem states that for any type `M` equipped with addition operation (making it an additive semigroup), any element `x` of `M` always belongs to the 'top' or the universal set (`⊤`). In essence, it asserts that all elements of an additive semigroup are members of the universal set.

Every element of an additive semigroup belongs to its universe.


theorem Mathlib.GroupTheory.Subsemigroup.Basic._auxLemma.7 : ∀ {M : Type u_1} [inst : Mul M] (x : M), (x ∈ ⊤) = True :=
  by sorry

This theorem, `Mathlib.GroupTheory.Subsemigroup.Basic._auxLemma.7`, states that for any type `M` equipped with a multiplication operation (i.e., `M` is a semigroup), any element `x` of type `M` is an element of the top element of the order of subsemigroups. In mathematical terms, it means that for any element `x` in a semigroup `M`, `x` belongs to the universal subsemigroup, denoted by `⊤`.

Every element in a semigroup belongs to its universal subsemigroup.


theorem Fin.eq_last_of_not_lt : ∀ {n : ℕ} {i : Fin (n + 1)}, ¬↑i < n → i = Fin.last n := by sorry

This theorem states that for any natural number `n` and any finite number `i` of the form `Fin (n + 1)`, if `i` is not less than `n` when considered as a natural number (notated as `↑i`), then `i` must be equal to the greatest value of `Fin (n+1)`, which is represented by `Fin.last n`. Essentially, this theorem describes a property of the "last" element in a finite set of consecutive numbers starting from zero.

For any natural number `n`, the only element `i` of `Fin (n + 1)` with `i ≥ n` is `Fin.last n`.


theorem CategoryTheory.ShortComplex.π_leftRightHomologyComparison'_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S)
      (h₂ : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.CategoryStruct.comp h₁.π
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂) h₂.ι) =
        CategoryTheory.CategoryStruct.comp h₁.i h₂.p :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.π_leftRightHomologyComparison'_ι`, states that for any type `C` which forms a category with zero morphisms, and for any short complex `S` of this category, given two pieces of homology data, `h₁` from the left and `h₂` from the right, the composition of morphisms `h₁.π` and `(CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂) ≫ h₂.ι` is equal to the composition of morphisms `h₁.i` and `h₂.p`. This composition of morphisms is part of the structure of a category and is represented in Lean 4 by the function `CategoryTheory.CategoryStruct.comp`. This equality represents the coherency condition between the homology data from the left and right of a short complex.

For any short complex in a category with zero morphisms, the composition of `h₁.π`, `CategoryTheory.ShortComplex.leftRightHomologyComparison' `h₁ `h₂`, and `h₂.ι` equals the composition of `h₁.i` and `h₂.p`. (This is the coherence condition for homology data of a short complex.)


theorem StieltjesFunction.id_leftLim : ∀ (x : ℝ), Function.leftLim (↑StieltjesFunction.id) x = x := by sorry

The theorem `StieltjesFunction.id_leftLim` states that for all real numbers `x`, the left limit of the Stieltjes function constructed from the identity function (denoted as `StieltjesFunction.id`) at `x` is equal to `x`. In other words, if we approach any real number `x` from the left via this Stieltjes function, the limit value we obtain is exactly `x`.

For all real numbers x, the left limit of StieltjesFunction.id at x equals x.


List.NodupKeys.kerase

theorem List.NodupKeys.kerase :
    ∀ {α : Type u} {β : α → Type v} {l : List (Sigma β)} [inst : DecidableEq α] (a : α),
      List.NodupKeys l → List.NodupKeys (List.kerase a l) :=
  by sorry

The theorem `List.NodupKeys.kerase` states that for all types `α` and `β` with `β` being a dependent type on `α`, for all lists `l` of pairs (key-value pairs, represented as `Sigma β`), and any element `a` of type `α`, if the list `l` satisfies the property `List.NodupKeys` (meaning that the keys in the list do not duplicate), then the list resulting from the operation `List.kerase a l` (which removes the first pair with the key `a` from the list `l`) also satisfies the property `List.NodupKeys`. The equality of keys is decidable, which is represented by the `DecidableEq α` instance.

If `l` is a list of key-value pairs `(α × β)` with no duplicate keys (`List.NodupKeys l`), then the list obtained by removing the key-value pair with key `a` (`List.kerase a l`) also has no duplicate keys.


theorem one_lt_div : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < b → (1 < a / b ↔ b < a) := by
  sorry

The theorem `one_lt_div` states that for any type `α` that has a structure of a linear ordered semiring (a mathematical structure that is both a semiring and a linear ordered set), given two elements `a` and `b` of type `α`, if `b` is greater than `0`, then `1` is less than the fraction `a / b` if and only if `b` is less than `a`. In other words, it establishes a relationship between the comparability of `1` and a fraction `a / b`, and the comparability of `b` and `a`, given that `b` is positive.

For any linear ordered semiring type `α` and elements `a`, `b` of type `α` with `b` positive, `1` is less than `a / b` if and only if `b` is less than `a`.


theorem uniformContinuous_addMonoidHom_of_continuous :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α]
      {hom : Type u_3} [inst_3 : UniformSpace β] [inst_4 : AddGroup β] [inst_5 : UniformAddGroup β]
      [inst_6 : FunLike hom α β] [inst_7 : AddMonoidHomClass hom α β] {f : hom}, Continuous ⇑f → UniformContinuous ⇑f :=
  by sorry

This theorem states that for any two types `α` and `β`, under certain conditions, if a function `f` of type `hom` (which is a functional-like type from `α` to `β` and is also an additive monoid homomorphism) is continuous, then it is uniformly continuous.

The conditions are that `α` and `β` should have uniform spaces and additive group structures, and these additive groups are also uniform (i.e., they are uniform additive groups). Moreover, the type `hom` should be function-like from `α` to `β` and should be a class of additive monoid homomorphisms from `α` to `β`.

Uniform continuity is a stronger version of continuity that ensures that the function behaves well with respect to the uniformity structure on the types, i.e., if two elements of `α` are close, their images under `f` in `β` are also close. This theorem is particularly useful in the context of topological algebra and analysis.

Given types `α` and `β` with uniform structures and additive group structures that are uniform additive groups, if `f` is a continuous, function-like homomorphism from `α` to `β` of type `hom`, then `f` is uniformly continuous.


theorem Function.Semiconj.iterate_right :
    ∀ {α : Type u} {β : Type v} {f : α → β} {ga : α → α} {gb : β → β},
      Function.Semiconj f ga gb → ∀ (n : ℕ), Function.Semiconj f ga^[n] gb^[n] :=
  by sorry

The theorem `Function.Semiconj.iterate_right` states that for any types `α` and `β`, given a function `f` from `α` to `β`, and functions `ga : α → α` and `gb : β → β`, if `f` semiconjugates `ga` to `gb`, that is, `f ∘ ga = gb ∘ f`, then `f` also semiconjugates the `n`-th iteration of `ga` to the `n`-th iteration of `gb` for any natural number `n`. In other words, if `f` transforms every output of `ga` to the corresponding output of `gb`, it will do the same for `n` sequential applications of `ga` and `gb`.

If function `f` semiconjugates `ga` to `gb`, then `f` semiconjugates the `n`-th iteration of `ga` to the `n`-th iteration of `gb` for any natural number `n`.


theorem MeasureTheory.ProbabilityMeasure.tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
      {δ : Type u_2} (F : Filter δ) {μs : δ → MeasureTheory.ProbabilityMeasure Ω}
      {μ₀ : MeasureTheory.ProbabilityMeasure Ω},
      Filter.Tendsto μs F (nhds μ₀) ↔
        Filter.Tendsto (MeasureTheory.ProbabilityMeasure.toFiniteMeasure ∘ μs) F
          (nhds (MeasureTheory.ProbabilityMeasure.toFiniteMeasure μ₀)) :=
  by sorry

The theorem states that for any measurable and topological space Ω with the property that any open set in Ω is measurable, any filter F over a type δ, and any sequence of probability measures μs over Ω, the sequence μs tends to a certain probability measure μ₀ under the filter F if and only if the sequence of finite measures associated to μs (obtained by interpreting each probability measure in the sequence as a finite measure) also tends to the finite measure associated to μ₀ under the same filter F. In other words, the convergence of a sequence of probability measures in the neighborhood filter is equivalent to the convergence of the corresponding sequence of finite measures in the same filter.

For any measurable and topological space Ω with the property that any open set is measurable, the convergence of a sequence of probability measures on Ω under the neighborhood filter is equivalent to the convergence of the corresponding sequence of finite measures.


theorem EuclideanDomain.gcd_dvd_left :
    ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] (a b : R), EuclideanDomain.gcd a b ∣ a := by
  sorry

This theorem states that for any type `R` that is a Euclidean domain and has decidable equality, the greatest common divisor (gcd) of any two elements `a` and `b` of `R` divides `a`. In more mathematical terms, if `a` and `b` are elements of a Euclidean domain `R`, then the greatest common divisor of `a` and `b`, denoted by `gcd(a,b)`, is a divisor of `a`. This is a common property of greatest common divisors in number theory.

In a Euclidean domain with decidable equality, the greatest common divisor of any two elements divides the first element.


theorem Set.Finite.toFinset_image2 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {s : Set α} {t : Set β} (f : α → β → γ)
      (hs : Set.Finite s) (ht : Set.Finite t) (hf : optParam (Set.Finite (Set.image2 f s t)) ⋯),
      Set.Finite.toFinset hf = Finset.image₂ f (Set.Finite.toFinset hs) (Set.Finite.toFinset ht) :=
  by sorry

The theorem `Set.Finite.toFinset_image2` states that for any types `α`, `β`, `γ` with a decidable equality on `γ`, any finite sets `s` of type `α` and `t` of type `β`, and a binary function `f : α → β → γ`, the `Finset` (i.e., a finite set with no duplicates) that represents the image of the function `f` applied to `s` and `t` (denoted `Set.image2 f s t`) is equal to the image of `f` applied to the `Finset` representations of `s` and `t`. This is under the assumption that the image `Set.image2 f s t` is finite, which is an optional parameter `hf` in the theorem.

For any types `α`, `β`, `γ` with decidable equality, finite sets `s : Finset α`, `t : Finset β`, and a binary function `f : α → β → γ`, if `Set.image2 f s t` is finite, then `Set.image2 f s t = Set.image (λ x y, f x y) (Set.unioneq s (Set.map Set.fst t))`.


theorem Set.iInter_mono :
    ∀ {α : Type u_1} {ι : Sort u_4} {s t : ι → Set α}, (∀ (i : ι), s i ⊆ t i) → ⋂ i, s i ⊆ ⋂ i, t i := by sorry

This theorem states that for any type `α` and any index type `ι`, if we have two indexed families of sets `s` and `t` (both indexed by `ι` and containing sets of type `α`), then if every set in `s` is a subset of the corresponding set in `t` (i.e., for all `i` in `ι`, `s i` is a subset of `t i`), it follows that the intersection over all sets in `s` is a subset of the intersection over all sets in `t`. In terms of set theory, this states that if every element of a collection of sets `s` is subset of the corresponding element in another collection `t`, then the intersection of all elements of `s` is a subset of the intersection of all elements of `t`.

If for all indices i, si ⊆ ti, then ∩ gi∈I si = ∩ gi∈I ti. (In set theory, if every set si in an indexed family is a subset of the corresponding set ti, then the intersection of all si is a subset of the intersection of all ti.)


/-- `count` measure evaluates to infinity at infinite sets.  -/
theorem MeasureTheory.Measure.count_apply_infinite :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α}, Set.Infinite s → ↑↑MeasureTheory.Measure.count s = ⊤ := by
  sorry

This theorem states that for any type `α` that is a measurable space, if `s` is an infinite set of `α`, then the count measure of `s` is infinity. In other words, when applying the counting measure to an infinite set in any measurable space, the result is always infinity. This encodes the intuitive notion that counting an infinite set would go on forever, yielding an infinite measure.

For any measurable space `α`, the counting measure of an infinite subset of `α` is infinity.


theorem MeasureTheory.JordanDecomposition.real_smul_def :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (r : ℝ) (j : MeasureTheory.JordanDecomposition α),
      r • j = if 0 ≤ r then Real.toNNReal r • j else -(Real.toNNReal (-r) • j) :=
  by sorry

This theorem, from measure theory's Jordan Decomposition, defines the operation of real number scalar multiplication on a Jordan decomposition. For any measurable space `α`, real number `r`, and Jordan decomposition `j` of `α`, scalar multiplication of `j` by `r` (`r • j`) is defined as follows: if `r` is non-negative, then it's the multiplication of `j` by the non-negative real number reinterpretation of `r` (`Real.toNNReal r • j`), otherwise, it's the negative of multiplication of `j` by the non-negative real number reinterpretation of `-r` (`-(Real.toNNReal (-r) • j)`). The function `Real.toNNReal` reinterprets a real number as a non-negative real number, returning `0` if the number is less than `0`.

For any measurable space `α`, real number `r`, and Jordan decomposition `j` of `α`, the scalar multiplication `r • j` is defined as `Real.toNNReal r • j` if `r` is non-negative, and `-(Real.toNNReal (-r) • j)` otherwise.


IntermediateField.gc

theorem IntermediateField.gc :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
      GaloisConnection (IntermediateField.adjoin F) fun x => ↑x :=
  by sorry

The theorem `IntermediateField.gc` states that for any field `F` and any extension `E` of this field (where `E` is an algebra over `F`), there exists a Galois connection between the function `IntermediateField.adjoin F`, which extends `F` by adjoining a set, and the function that takes an intermediate field `x` and yields the set of elements in `x`. In other words, for any subset `S` of `E` and any intermediate field `x`, `S` is contained in `x` if and only if the field obtained by adjoining `S` to `F` is contained in `x`.

For any field extension E of F, there exists a Galois connection between the function that maps an intermediate field x to the set of elements it contains from E, and the function that maps a subset S of E to the subfield of F generated by S and F.


theorem IsIrreducible.genericPoint_spec :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSober α] {S : Set α} (hS : IsIrreducible S),
      IsGenericPoint (IsIrreducible.genericPoint hS) (closure S) :=
  by sorry

The theorem `IsIrreducible.genericPoint_spec` states that for any type `α` with a topology and a quasi-sober property, and for any set `S` of type `α` that is irreducible, the generic point of the irreducible set `S` is a generic point of the closure of `S`. This means that the closure of the set containing only the generic point of `S` equals the closure of `S` itself. In mathematical terms, if `S` is an irreducible subset of a quasi-sober topological space, then the closure of `{x}`, where `x` is a generic point of `S`, is equal to the closure of `S`.

For any irreducible subset S of a quasi-sober topological space, the generic point of S is a generic point of its closure. In other words, the closure of the singleton set containing the generic point of S equals the closure of S.


theorem Set.image_subset_image2_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {b : β},
      b ∈ t → (fun a => f a b) '' s ⊆ Set.image2 f s t :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, any binary function `f` from `α` and `β` to `γ`, any sets `s` and `t` of `α` and `β` respectively, and any element `b` of `β`, if `b` is a member of `t`, then the image of the set `s` under the function `(fun a => f a b)` (which is a function from `α` to `γ` that takes an input from `s` and returns the output of `f` with that input and `b`) is a subset of the image of the binary function `f` applied to `s` and `t`. This means that applying `f` to each element of `s` paired with `b` results in a set of elements of `γ` that is entirely contained within the set of elements of `γ` obtained by applying `f` to each pair of elements from `s` and `t`.

For any sets `S` in `α`, `T` in `β`, element `b` in `β`, and function `f` from `α` x `β` to `γ`, if `b` is in `T` then the image of `S` under the function `λx. f(x, b)` is a subset of the image of `f` applied to the Cartesian product `S` x `T`.


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

The theorem `Basis.repr_symm_apply` states that for any index type `ι`, ring `R`, and module `M` over `R` (with `R` being a semiring and `M` being an additive commutative monoid and also a module over `R`), and for any basis `b` of `M` and any function `v` from `ι` to `R`, the application of the inverse of the linear equivalence represented by `b` to `v` is equal to the total function of `v` under the map `b`. In other words, it says that applying the inverse of basis representation to a function `v` is equivalent to evaluating the linear combination of elements in the basis `b` with coefficients given by `v`.

For any index type `ι`, ring `R`, additive commutative monoid `M` over `R`, basis `b` of `M`, and function `v` from `ι` to `R`, applying the inverse of the linear map represented by `b` to `v` equals the total function of `v` under `b`.


theorem WithTop.preimage_coe_Ioi :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithTop.some ⁻¹' Set.Ioi ↑a = Set.Ioi a := by sorry

The theorem `WithTop.preimage_coe_Ioi` states that for any type `α` equipped with a preorder and any element `a` of `α`, the preimage of the set of elements greater than the element `a` under the canonical embedding of `α` into `WithTop α` is exactly the set of elements greater than `a` in `α`. In other words, the measure of elements greater than `a` in `WithTop α` is equivalent to the measure of elements greater than `a` in `α`.

For any preordered type `α` and element `a` in `α`, the preimage of the set of elements greater than `a` under the canonical embedding of `α` into `WithTop α` equals the set of elements in `α` greater than `a`.


theorem Nat.lcm_zero_left : ∀ (m : ℕ), Nat.lcm 0 m = 0 := by sorry

The theorem `Nat.lcm_zero_left` states that for any natural number `m`, the least common multiple of `0` and `m` is `0`. In mathematical terms, this would be represented as $\operatorname{lcm}(0, m) = 0$ for all natural numbers `m`. This is consistent with the general mathematical principle that the least common multiple of any number and zero is zero, as zero multiplied by any number always results in zero.

The least common multiple of 0 and any natural number is 0.


/-- If an affine subspace contains a set of points, it contains the `spanPoints` of that set.  -/
theorem AffineSubspace.spanPoints_subset_coe_of_subset_coe :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : Set P} {s1 : AffineSubspace k P}, s ⊆ ↑s1 → spanPoints k s ⊆ ↑s1 :=
  by sorry

The theorem `AffineSubspace.spanPoints_subset_coe_of_subset_coe` states that given a ring `k`, an additive commutative group `V`, a module `V` over the ring `k`, a torsor `P` for the group `V`, a set of points `s` in `P`, and an affine subspace `s1` of `P` over `k`, if the set `s` is a subset of the underlying set of `s1` (denoted `↑s1`), then the affine span of `s` (the set of all points which can be expressed as a vector in the vector span of `s`, shifted by a point in `s`) is also a subset of the underlying set of `s1`. In other words, if an affine subspace contains a set of points, it also contains all points in the affine span of that set.

If `s` is a subset of an affine subspace `s1` of a module `V` over a ring `k`, then the affine span of `s` is contained in the underlying set of `s1`.


theorem Set.mem_inv : ∀ {α : Type u_2} [inst : Inv α] {s : Set α} {a : α}, a ∈ s⁻¹ ↔ a⁻¹ ∈ s := by sorry

This theorem states that for any type `α` that has an inverse operation, a set `s` of elements of type `α`, and an element `a` of type `α`, `a` is in the inverse of the set `s` if and only if the inverse of `a` is in the set `s`. Here, the inverse of a set is defined as the set of inverses of all elements in the original set.

For any type `α` with an inverse operation, a set `s ⊆ α`, and an element `a ∈ α`, `a ∈ s^∘` if and only if `a^⁻¹ ∈ s`, where `s^∘` denotes the set of inverses of `s`.


theorem Function.extend_comp :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Injective f → ∀ (g : α → γ) (e' : β → γ), Function.extend f g e' ∘ f = g :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, and any function `f` from `α` to `β`, if `f` is injective (meaning that equal outputs imply equal inputs), then for any function `g` from `α` to `γ` and any function `e'` from `β` to `γ`, the composition of the extension of `f`, `g`, and `e'` with `f` equals to `g`. In other words, if we first apply `f` to an input and then apply the extended function, it's as if we directly applied `g`. The theorem ties together function composition, function extension and injective functions in a precise way.

If `f: α → β` is injective and `g: α → γ` and `e': β → γ` are functions, then `(g ∘ e') ∘ f = g ∘ (extension f g)`.


theorem ZMod.val_eq_zero : ∀ {n : ℕ} (a : ZMod n), ZMod.val a = 0 ↔ a = 0 := by sorry

The theorem `ZMod.val_eq_zero` states that for any natural number `n` and an element `a` of the integers modulo `n` (`ZMod n`), the value function `ZMod.val a` equals to zero if and only if `a` equals to zero. In other words, in the set of integers modulo `n`, the value of an element is zero if and only if the element itself is zero.

For all natural numbers n and elements a in ZMod n (integers modulo n), ZMod.val a = 0 if and only if a = 0.


theorem Subgroup.eq_bot_iff_forall : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H = ⊥ ↔ ∀ x ∈ H, x = 1 := by
  sorry

This theorem states that for any type `G` equipped with a group structure, and for any subgroup `H` of `G`, the subgroup `H` is equal to the trivial subgroup (denoted by `⊥`) if and only if all elements `x` in `H` are equal to the identity element (denoted by `1`). In other words, this theorem provides a characterization of trivial subgroups: a subgroup is trivial if and only if it only contains the identity element.

A subgroup of a group is trivial if and only if it consists only of the identity element.


theorem AddMonoid.exponent_ne_zero :
    ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.exponent G ≠ 0 ↔ AddMonoid.ExponentExists G := by sorry

The theorem `AddMonoid.exponent_ne_zero` states that for any type `G` that has an additive monoid structure, the exponent of the additive monoid `G` is not zero if and only if there exists a positive integer `n` such that `n • g = 0` for all `g` in `G`. Here, `n • g` denotes the n-fold addition of `g` with itself. In other words, the exponent of an additive monoid is nonzero if and only if the condition of the `ExponentExists` predicate is satisfied.

The exponent of an additive monoid is nonzero if and only if there exists a positive integer that annihilates every element in the monoid under n-fold addition.


theorem Set.singleton_prod_singleton : ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β}, {a} ×ˢ {b} = {(a, b)} := by
  sorry

This theorem states that for any two types `α` and `β` and any elements `a` of `α` and `b` of `β`, the Cartesian product of the set containing only `a` and the set containing only `b` (`{a} ×ˢ {b}` in Lean 4) is equal to the set containing only the pair `(a, b)`. This is a statement about set theory in the context of type theory.

For any types `α` and `β` and their respective elements `a` from `α` and `b` from `β`, `{a} × {b} = {(a, b)}`.


theorem Set.surjective_onto_image :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Function.Surjective (Set.imageFactorization f s) := by
  sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `α`, the function that results from the image factorization of `f` over `s` is surjective. In mathematical terms, this means that for every element in the image of `f` restricted to `s`, there exists an element in the preimage `s` such that the image factorization function applied to this element equals that element in the image.

For any function `f` from type `α` to type `β` and any set `s` of type `α`, the image factorization of `f` over `s` is a surjection.


Function.Commute.refl

theorem Function.Commute.refl : ∀ {α : Type u_1} (f : α → α), Function.Commute f f := by sorry

This theorem states that for any function `f` from a type `α` to itself, `f` commutes with itself. In other words, for all `α` in the type `u_1` and any function `f: α → α`, applying `f` after `f` is the same as applying `f` before `f`. Mathematically, this means that for all `x` in `α`, `f(f(x))` equals `f(f(x))`, and in function composition notation, `f ∘ f` equals `f ∘ f`.

For any function `f: α --> α`, `f ∘ f` equals `f ∘ f`, i.e., `f` commutes with itself.


theorem archimedean_iff_nat_lt :
    ∀ {α : Type u_1} [inst : LinearOrderedField α], Archimedean α ↔ ∀ (x : α), ∃ n, x < ↑n := by sorry

This theorem, named `archimedean_iff_nat_lt`, states that for any type `α` that is a linearly ordered field, the property of being Archimedean is equivalent to a property that, for any element `x` of type `α`, there exists a natural number `n` such that `x` is less than the natural number `n`. In terms of mathematics, a field is called Archimedean if for every element in the field, there exists a natural number greater than that element.

A linearly ordered field is Archimedean if and only if for every element x in the field, there exists a natural number n such that x < n.


theorem UniformSpace.Completion.continuous_coe : ∀ (α : Type u_1) [inst : UniformSpace α], Continuous ↑α := by sorry

This theorem states that for any type `α` equipped with a uniform space structure, the natural embedding from `α` into its completion is continuous. In other words, given any uniform space, the function that maps each element to its corresponding element in the complete space is a continuous function. This is a key property in the theory of uniform spaces and is significant in the study of completeness and limit processes within these spaces.

For any uniform space `(α, δ)`, the natural embedding `α ⊆ Ⓐ(α)` is a continuous function with respect to the uniform structures `δ` and the standard uniform structure on `Ⓐ(α)`. (Here, `Ⓐ(α)` denotes the completion of `α`.)


theorem not_irreducible_pow : ∀ {α : Type u_5} [inst : Monoid α] {x : α} {n : ℕ}, n ≠ 1 → ¬Irreducible (x ^ n) := by
  sorry

This theorem states that for any type `α` that is a Monoid, and any `x` of type `α` and `n` of type `ℕ` (natural number), if `n` is not equal to 1, then `x ^ n` (i.e., `x` raised to the power of `n`) is not irreducible. In the context of algebra, an element of a monoid is said to be irreducible if it is not the unit and cannot be expressed as the product of two non-units.

For any monoid `α` and `x ∈ α` (x being a non-unit), if `n ∈ ℕ` (natural number) is not equal to 1, then `x ^ n` is not irreducible.


theorem Finset.stronglyMeasurable_sum' :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousAdd M]
      {m : MeasurableSpace α} {ι : Type u_6} {f : ι → α → M} (s : Finset ι),
      (∀ i ∈ s, MeasureTheory.StronglyMeasurable (f i)) →
        MeasureTheory.StronglyMeasurable (Finset.sum s fun i => f i) :=
  by sorry

The theorem `Finset.stronglyMeasurable_sum'` states that for any type `α`, any type `M` with additional structures of an additive commutative monoid and a topological space, any measurable space `m` over `α`, any type `ι`, any function `f` from `ι` to `α` to `M`, and any finite set `s` of `ι`, if every function `f i`, where `i` is an element of `s`, is strongly measurable (i.e., it is the limit of simple functions), then the sum of the functions `f i` over all `i` in `s` is also strongly measurable. This is the case under the assumption that the addition operation is continuous in the topology of `M`.

If `α`, `M` is an additive commutative monoid and topological space, `m` is a measurable space over `α`, `ι` is a type, `f : ι → α → M` is a function, `s` is a finite set of `ι`, and each `f i` is strongly measurable with respect to `m` and the addition in `M` is continuous, then the sum of `f i` over `s` is also strongly measurable.


theorem MeasureTheory.integral_mono_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ℝ},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ → f ≤ᶠ[MeasureTheory.Measure.ae μ] g → ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ :=
  by sorry

This theorem, named `MeasureTheory.integral_mono_ae`, asserts that for any measurable space `α` and any measure `μ` on `α`, if two real-valued functions `f` and `g` on `α` are both integrable with respect to `μ`, and `f` is less than or equal to `g` almost everywhere with respect to `μ`, then the integral of `f` with respect to `μ` is less than or equal to the integral of `g` with respect to `μ`. In other words, if `f` and `g` are both measurable and have finite integrals, and `f` is almost always less than or equal to `g`, then the area under the graph of `f` is less than or equal to the area under the graph of `g`.

If `μ` is a measure on the measurable space `α`, `f` and `g` are integrable real-valued functions on `α` with respect to `μ`, and `f(x) ≤ g(x)` almost everywhere on `α` with respect to `μ`, then `∫f dμ ≤ ∫g dμ`.


theorem RatFunc.num_zero : ∀ {K : Type u} [inst : Field K], RatFunc.num 0 = 0 := by sorry

The theorem `RatFunc.num_zero` states that for any type `K` that is a field, the numerator of the zero rational function (which is represented as `RatFunc.num 0`) is zero. In other words, if you have a rational function which is zero, then its numerator is also zero. This is applicable in any field `K`.

For any field `K`, the numerator of the zero rational function is zero.


theorem CategoryTheory.Subobject.ofLE_refl :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} (X : CategoryTheory.Subobject B),
      CategoryTheory.Subobject.ofLE X X ⋯ =
        CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj X) :=
  by sorry

This theorem states that for any category `C` and any object `B` in `C`, given a subobject `X` of `B`, the morphism between `X` and itself (established by the `CategoryTheory.Subobject.ofLE` function) is equivalent to the identity morphism on the underlying object of `X` in the category. In other words, for any subobject `X`, the morphism from `X` to itself is the identity on the subobject's representative object in the category `C`. It's essentially saying that the operation of witnessing an inequality between subobjects, when done on the same subobject, results in the identity morphism.

For any category `C` and object `B` in `C`, the subobject `X` of `B` has equivalent identity and inclusion morphisms in `C`.


theorem Filter.HasBasis.cobounded_of_norm :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {ι : Sort u_9} {p : ι → Prop} {s : ι → Set ℝ},
      Filter.HasBasis Filter.atTop p s → Filter.HasBasis (Bornology.cobounded E) p fun i => norm ⁻¹' s i :=
  by sorry

This theorem states that, for any seminormed add group `E` and any set `s` of real numbers indexed by `ι` and filtered by a predicate `p`, if `Filter.atTop` has a basis given by `p` and `s`, then `Bornology.cobounded E` also has a basis, where the basis elements are the preimages of `s` under the norm function. In simpler terms, the theorem relates the behavior of a filter at positive infinity and a filter of cobounded sets in a bornology under the norm function, asserting the existence of a basis for the latter if one exists for the former.

Given a seminormed add group `E`, a set `s` of real numbers indexed by `ι` filtered by a predicate `p`, and assuming `Filter.atTop` has a basis given by `p` and `s`, the bornology of cobounded sets in `E` has a basis consisting of the preimages of `s` under the norm function.


theorem NNReal.coe_sSup : ∀ (s : Set NNReal), ↑(sSup s) = sSup (NNReal.toReal '' s) := by sorry

This theorem states that for any set `s` of nonnegative real numbers (`NNReal`), the supremum (`sSup`) of `s` when cast to real numbers is equal to the supremum (`sSup`) of the set obtained by applying the function `NNReal.toReal` (which casts each nonnegative real number in the set `s` to a real number) to every element of `s`. In other words, taking the supremum before or after converting the entire set of nonnegative real numbers to real numbers doesn't change the value of the supremum.

For any set `s` of nonnegative real numbers, the supremum of `s` is equal to the supremum of the set obtained by applying the function `NNReal.toReal` to each element in `s`.


theorem Matroid.Basis.eq_of_subset_indep :
    ∀ {α : Type u_1} {M : Matroid α} {I X J : Set α}, M.Basis I X → M.Indep J → I ⊆ J → J ⊆ X → I = J := by sorry

The theorem `Matroid.Basis.eq_of_subset_indep` states that for any type `α`, given a Matroid `M` on `α` and sets `I`, `X`, and `J` of type `α`, if `I` is a basis of `X` in `M`, and `J` is independent in `M`, and `I` is a subset of `J`, and `J` is a subset of `X`, then `I` must be equal to `J`. In other words, in the context of a matroid, any independent set `J` that is a subset of a set `X` and also contains a basis `I` of `X` must be the same as `I`.

If `I` is a basis of a set `X` in a matroid `M`, and `J` is an independent subset of `X` that contains `I`, then `I` equals `J`.


/-- The **extreme value theorem**: a continuous function realizes its maximum on a compact set.  -/
theorem IsCompact.exists_forall_ge :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
      [inst_3 : ClosedIciTopology α] {s : Set β},
      IsCompact s → Set.Nonempty s → ∀ {f : β → α}, ContinuousOn f s → ∃ x ∈ s, ∀ y ∈ s, f y ≤ f x :=
  by sorry

The Extreme Value Theorem states that for a continuous function defined on a compact and nonempty set, there exists a point within the set at which the function attains its maximum value. In other words, given a compact and nonempty set `s` in some topological space, and a continuous function `f` acting on `s`, there exists a point `x` in `s` such that for all other points `y` in `s`, the value of the function `f` at `y` is less than or equal to the value of `f` at `x`. This theorem is foundational in real analysis and optimization, where it is used to guarantee the existence of maximum and minimum values of functions under certain conditions.

For a continuous function defined on a compact and nonempty set, there exists a point in the set where the function reaches its maximum value.


/-- The basic open sets for the topology on ultrafilters are open.  -/
theorem ultrafilter_isOpen_basic : ∀ {α : Type u} (s : Set α), IsOpen {u | s ∈ u} := by sorry

The theorem `ultrafilter_isOpen_basic` states that for any type `α` and any set `s` of type `α`, the set of ultrafilters `u` such that `s` is a member of `u` is open in the topology of ultrafilters. In other words, the basic open sets for the topology on ultrafilters, which are defined as the set of ultrafilters containing a particular set, are themselves open sets.

The set of ultrafilters containing a given set is open in the topology of ultrafilters.


/-- `opow b` and `log b` (almost) form a Galois connection.  -/
theorem Ordinal.opow_le_iff_le_log : ∀ {b x c : Ordinal.{u_1}}, 1 < b → x ≠ 0 → (b ^ c ≤ x ↔ c ≤ Ordinal.log b x) := by
  sorry

The theorem `Ordinal.opow_le_iff_le_log` establishes a type of almost-Galois connection between the ordinal exponentiation function (`opow`) and the ordinal logarithm function (`log`). Specifically, for any three ordinals `b`, `x`, and `c`, where `b` is greater than 1 and `x` is not zero, the theorem states that `b` raised to the power of `c` is less than or equal to `x` if and only if `c` is less than or equal to the ordinal logarithm of `x` with base `b`. In other words, the ordinal exponentiation and logarithm functions inversely relate to each other in terms of ordering.

For any ordinals $b > 1$, $x \neq 0$, and $c$, the equality $b^c \leq x$ holds if and only if $c \leq \log_b x$.


theorem Profinite.epi_iff_surjective : ∀ {X Y : Profinite} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑f :=
  by sorry

This theorem states that for any two Profinite objects `X` and `Y` and a morphism `f` from `X` to `Y`, the morphism `f` is an epimorphism if and only if the function corresponding to `f` is surjective. Here, an epimorphism is a map in category theory that is right-cancellable, and a function is said to be surjective (or onto) if for every element in the codomain, there exists an element in the domain such that applying the function to this element gives the element in the codomain.

A profinite morphism between profinite objects is an epimorphism if and only if the corresponding function is surjective.


theorem CategoryTheory.Limits.colimit.ι_map :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C]
      {G : CategoryTheory.Functor J C} (α : F ⟶ G) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j) (CategoryTheory.Limits.colim.map α) =
        CategoryTheory.CategoryStruct.comp (α.app j) (CategoryTheory.Limits.colimit.ι G j) :=
  by sorry

This theorem, `CategoryTheory.Limits.colimit.ι_map`, states that for any category `J`, any category `C` that has colimits of shape `J`, any two functors `F` and `G` from `J` to `C`, and a natural transformation `α` from `F` to `G`, the composition of the coprojection from `F` to the colimit of `F` and the map induced by `α` on the colimits is equal to the composition of the component of `α` at `j` and the coprojection from `G` to the colimit of `G`. In other words, the diagram
```
F.obj j --> colimit F
 |           |
 v           v
G.obj j --> colimit G
```
commutes, where the horizontal arrows are the coprojections, the vertical arrow on the left is `α.app j`, the vertical arrow on the right is `CategoryTheory.Limits.colim.map α`, and the compositions of the arrows along the top and bottom are equal.

For any category J, any category C with colimits of shape J, and any functors F and G from J to C with a natural transformation α from F to G, the diagram commutes, where the horizontal arrows are the coprojections and the vertical arrows are the maps induced by α and the coprojections to the colimits.


theorem Mathlib.CategoryTheory.Iso._auxLemma.5 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : Z ⟶ Y} {g : Z ⟶ X},
      (CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) =
        (f = CategoryTheory.CategoryStruct.comp g α) :=
  by sorry

This theorem states that in a category 'C', for any objects 'X', 'Y', and 'Z' and given a morphism 'α' from 'X' to 'Y' which is an isomorphism, for any morphisms 'f' from 'Z' to 'Y' and 'g' from 'Z' to 'X', the composition of 'f' and the inverse of 'α' is equal to 'g' if and only if 'f' is equal to the composition of 'g' and 'α'.
Here, the symbol '⟶' denotes a morphism between objects in the category, while 'CategoryTheory.CategoryStruct.comp' represents the composition of two morphisms and 'CategoryTheory.inv' represents the inverse of a morphism.

In a category C, given an isomorphism α : X ⟶ Y and morphisms f : Z ⟶ Y and g : Z ⟶ X, f ∘ α⁻¹ = g if and only if f = g ∘ α.


theorem MeasureTheory.JordanDecomposition.neg_posPart :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α), (-j).posPart = j.negPart :=
  by sorry

The theorem `MeasureTheory.JordanDecomposition.neg_posPart` states that, for any measurable space `α` and any Jordan decomposition `j` of `α`, the positive part of the negation of `j` is equal to the negative part of `j`. In other words, if we decompose a measure into its positive and negative parts, negating the measure and taking the positive part gives the same result as taking the negative part of the original measure.

For any measurable space and Jordan decomposition, the negative part of the negation of the measure is equal to the negative part of the original measure.


theorem FractionalIdeal.mem_div_iff_of_nonzero :
    ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
      [frac : IsFractionRing R₁ K] [inst_3 : IsDomain R₁] {I J : FractionalIdeal (nonZeroDivisors R₁) K},
      J ≠ 0 → ∀ {x : K}, x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I :=
  by sorry

The theorem `FractionalIdeal.mem_div_iff_of_nonzero` states that for any two fractional ideals `I` and `J` of a field `K` that is a fraction field of an integral domain `R₁` (with non-zero divisors), given that `J` is not the zero ideal, a field element `x` is in the quotient `I / J` if and only if for any element `y` in `J`, the product `x * y` is in `I`. This gives us a characterization of elements belonging to the quotient of two fractional ideals in terms of multiplication with elements of the denominator ideal.

For fractional ideals I and J of a field K as the fraction field of an integral domain R₁ with non-zero divisors, where J is non-zero, x ∈ I / J if and only if x * y ∈ I for all y ∈ J.


theorem isTop_top : ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α], IsTop ⊤ := by sorry

The theorem `isTop_top` states that for any type `α` that has a less than or equal to relation (`LE α`) and a greatest element (`OrderTop α`), the greatest element (denoted by `⊤`) is a top element according to the definition of `IsTop`. In other words, the greatest element is greater than or equal to any other element in `α`.

For any type `α` equipped with a total order having a greatest element, the greatest element is a top element in the order.


AffineIndependent.injective

/-- An affinely independent family is injective, if the underlying
ring is nontrivial.  -/
theorem AffineIndependent.injective :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {ι : Type u_4} [inst_4 : Nontrivial k] {p : ι → P},
      AffineIndependent k p → Function.Injective p :=
  by sorry

The theorem states that, given a nontrivial ring 'k', an additive commutative group 'V', a module 'V' over the ring 'k', a torsor 'P' over the group 'V', and a mapping 'p' from an arbitrary type 'ι' to 'P', if the family indexed by 'ι' is affinely independent under 'p', then 'p' is an injective function. In simpler terms, for an affinely independent family under a nontrivial ring, no two distinct elements in the domain of 'p' can map to the same value in its codomain. This injectivity ensures uniqueness in the representation of points in the affinely independent set.

Given a nontrivial ring 'k', a module 'V' over 'k', a torsor 'P' over an additive commutative group 'V', and a mapping 'p' from an arbitrary type 'ι' to 'P', if the family indexed by 'ι' is affinely independent under 'p', then 'p' is an injective function.


theorem List.erase_sublist :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) (l : List α), List.Sublist (List.erase l a) l := by
  sorry

This theorem, `List.erase_sublist`, states that for any type `α`, given an instance of equality (BEq) and lawful equality (LawfulBEq) on this type, and for any element `a` of type `α` and any list `l` of type `List α`, the list that results from erasing the element `a` from `l` is a sublist of `l`. In other words, if you remove an element from a list, the resulting list is always a sublist of the original list.

For any type `α` with equality `BEq` and lawful equality `LawfulBEq`, if `a` is an element of list `l` of type `List α`, then the list obtained by erasing `a` from `l` is a sublist of `l`.


/-- The integral of the conditional expectation `μ[f|hm]` over an `m`-measurable set is equal to
the integral of `f` on that set.  -/
theorem MeasureTheory.set_integral_condexp :
    ∀ {α : 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'} {s : Set α}
      (hm : m ≤ m0) [inst_3 : MeasureTheory.SigmaFinite (μ.trim hm)],
      MeasureTheory.Integrable f μ →
        MeasurableSet s → ∫ (x : α) in s, MeasureTheory.condexp m μ f x ∂μ = ∫ (x : α) in s, f x ∂μ :=
  by sorry

The theorem `MeasureTheory.set_integral_condexp` states that given a set `s` of elements of a certain type `α`, a measure `μ`, a function `f` from `α` to a normed add commutative group `F'`, and a measurable space `m` that is a sub-space of `m0`, if `f` is integrable and `s` is a measurable set, then the integral of the conditional expectation `μ[f|hm]` over the `m`-measurable set `s` is the same as the integral of `f` over the set `s`. Here, `μ[f|hm]` denotes the conditional expectation of `f` with respect to the measure `μ` and the measurable space `m`. The sigma-finite measure condition ensures that the measure `μ` is finite when restricted to subsets of `α` that are in the sigma algebra generated by the measurable space `m`.

Given a measure `μ`, a set `s` in the sigma-algebra of a measurable space `(α, Σ)`, a function `f` integrable with respect to `μ`, and a measurable sub-space `m` of `Σ`, the integral of the conditional expectation `μ[f|m]` over `s` equals the integral of `f` over `s`.


theorem CategoryTheory.Arrow.id_left :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] (f : CategoryTheory.Arrow T),
      (CategoryTheory.CategoryStruct.id f).left = CategoryTheory.CategoryStruct.id f.left :=
  by sorry

This theorem states that for any category `T` and any arrow `f` in that category, the left component of the identity morphism on `f` is equal to the identity morphism on the left component of `f`. In other words, when we apply the identity morphism to an arrow in the arrow category, it behaves just like applying the identity morphism to the original object in the category `T`.

For any category T and arrow f, the left identity morphism of f is equal to the identity morphism on the domain of f.


theorem imaginaryPart_apply_coe :
    ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
      (a : A), ↑(imaginaryPart a) = -Complex.I • 2⁻¹ • (a - star a) :=
  by sorry

This theorem states that for any type `A` that is a commutative additive group and a module over the complex numbers, and additionally has the structure of a star-additive monoid and a star module over the complex numbers, the imaginary part of an element `a` of type `A`, when promoted to the complex number, is equal to negative of the imaginary unit `Complex.I` scaled by one half, and then scaled by the difference between `a` and its star conjugate. In mathematical notation, this would be $\Im(a) = -i \cdot \frac{1}{2} \cdot (a - a^*)$ where $\Im$ denotes the imaginary part, $i$ is the imaginary unit, and $*$ denotes the star operation.

The imaginary part of an element in a complex-valued commutative additive group with star-additive monoid and star module structures is equal to negative half of the imaginary unit times the difference between the element and its star conjugate.


theorem GeneralizedContinuedFraction.nth_cont_eq_succ_nth_cont_aux :
    ∀ {K : Type u_1} {g : GeneralizedContinuedFraction K} {n : ℕ} [inst : DivisionRing K],
      GeneralizedContinuedFraction.continuants g n = GeneralizedContinuedFraction.continuantsAux g (n + 1) :=
  by sorry

This theorem states that for any type `K` equipped with a division ring structure, any generalized continued fraction `g` of type `K`, and any natural number `n`, the `n`-th continuant of `g` is equal to the (`n + 1`)-th auxiliary continuant of `g`. In simpler terms, it provides a relationship between the continuants and auxiliary continuants of a generalized continued fraction in a given division ring.

For any division ring `K`, any generalized continued fraction `g` over `K`, and any natural number `n`, the `n`-th continuant and the `(n+1)`-th auxiliary continuant of `g` are equal.


theorem Filter.tendsto_atTop_add_const_right :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] (l : Filter α) {f : α → β} (C : β),
      Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => f x + C) l Filter.atTop :=
  by sorry

This theorem asserts that for any type `α`, type `β` that forms an ordered commutative additive group, a filter `l` on `α`, a function `f` from `α` to `β` and an element `C` of `β`, if `f` tends to infinity (as represented by `Filter.atTop`) along the filter `l`, then the function that adds `C` to `f(x)` (i.e., `f(x) + C`) also tends to infinity along the same filter `l`. In mathematical terms, if $\lim_{x \to l} f(x) = \infty$, then $\lim_{x \to l} (f(x) + C) = \infty$.

If a function from an ordered commutative additive group to itself tends to infinity along a filter, then the function translated by a constant also tends to infinity along the same filter.


SatisfiesM.map

/-- `SatisfiesM` distributes over `<$>`, general version.  -/
theorem SatisfiesM.map :
    ∀ {m : Type u_1 → Type u_2} {α : Type u_1} {p : α → Prop} {α_1 : Type u_1} {q : α_1 → Prop} {f : α → α_1}
      [inst : Functor m] [inst_1 : LawfulFunctor m] {x : m α},
      SatisfiesM p x → (∀ {a : α}, p a → q (f a)) → SatisfiesM q (f <$> x) :=
  by sorry

The theorem `SatisfiesM.map` states that for any functor `m`, types `α` and `α_1`, propositions `p` and `q` over `α` and `α_1` respectively, and a function `f` from `α` to `α_1`, if a monadic value `x` satisfies the proposition `p`, and for all `a` of type `α` where `p a` holds, `q (f a)` also holds, then the monadic value `f <$> x` satisfies the proposition `q`. This means that the property `SatisfiesM` distributes over a functor's fmap operation.

If `m` is a functor, `α` and `α_1` are types, `p` is a proposition over `α`, `q` is a proposition over `α_1`, `f` is a function from `α` to `α_1`, and `x` is a monadic value of type `m α` satisfying `p`, then `f <$> x` satisfies `q` whenever `p a` implies `q (f a)` for all `a` of type `α`.


/-- This is the same as `IsOfFinAddOrder.addOrderOf_pos` but with one fewer explicit
assumption since this is automatic in case of a finite cancellative additive monoid. -/
theorem addOrderOf_pos :
    ∀ {G : Type u_1} [inst : AddLeftCancelMonoid G] [inst_1 : Finite G] (x : G), 0 < addOrderOf x := by sorry

The theorem `addOrderOf_pos` states that for any type `G`, which is an instance of a finite, left-cancellable additive monoid, and for any element `x` of `G`, the additive order of `x` is positive. In other words, there is a positive natural number `n` such that `n` additively applied to `x` equals zero, and this number is least among all such natural numbers. This theorem is essentially a variant of `IsOfFinAddOrder.addOrderOf_pos`, but with one fewer assumption since the finiteness of the monoid is automatically guaranteed in this context.

For any finite, left-cancellable additive monoid G and its element x, there exists a positive natural number n such that x + ... + x (n times) = 0, and this number n is minimal.


theorem gauge_le_of_mem :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} {x : E} {a : ℝ},
      0 ≤ a → x ∈ a • s → gauge s x ≤ a :=
  by sorry

The theorem `gauge_le_of_mem` states that for any type `E` that has the structure of a real vector space (indicated by the `AddCommGroup E` and `Module ℝ E` type classes), any set `s` of type `E`, any element `x` of type `E`, and any real number `a`, if `a` is nonnegative and `x` is an element of the set obtained by scaling `s` by `a`, then the Minkowski gauge of `s` at `x` is less than or equal to `a`. In other words, the Minkowski gauge of a point with respect to a set provides a bound on how far the point can be stretched while remaining within a scaled version of the set.

For any real vector space `E`, set `s` of `E`, element `x` in the scaled set `a * s`, and nonnegative real number `a`, we have `gauge (s) x ≤ a`.


theorem memℓp_infty :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      BddAbove (Set.range fun i => ‖f i‖) → Memℓp f ⊤ :=
  by sorry

The theorem `memℓp_infty` states that for any type `α` and for any function `f` from `α` to a normed add commutative group `E`, if the set of norms of `f i` for all `i` in `α` (i.e., `Set.range fun i => ‖f i‖`) is bounded above, then `f` belongs to the space `ℓp` for `p = ∞`. In other words, if there exists an upper bound for the norms of all values of `f`, then `f` is said to be in the `ℓ∞` space, which is the space of bounded functions.

If the set of norms of a function from a type to a normed add commutative group is bounded, then the function belongs to the space of bounded functions (ℓ∞).


theorem iSup_or :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p ∨ q → α},
      ⨆ (x : p ∨ q), s x = (⨆ (i : p), s ⋯) ⊔ ⨆ (j : q), s ⋯ :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and for any propositions `p` and `q`, and a function `s` from the disjunction `p ∨ q` to `α`, the supremum (or least upper bound) of `s` over all `p ∨ q` is equal to the join (or supremum) of the supremum of `s` over all `p` and the supremum of `s` over all `q`. This captures the idea that the greatest element of a set determined by either `p` or `q` is the greatest element among those determined by `p` and those determined by `q`, combined.

For any complete lattice `α` and functions `s` from `p ∨ q` to `α`, the supremum of `s` over `p ∨ q` equals the join of the supremum of `s` over `p` and the supremum of `s` over `q`.


theorem Submodule.span_zero_singleton :
    ∀ (R : Type u_1) {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Submodule.span R {0} = ⊥ :=
  by sorry

This theorem states that for any given semiring `R` and an additive commutative monoid `M` which is also a `R`-module, the span of the singleton set consisting of only the zero element in `M` is the bottom (smallest) submodule. In other words, the smallest submodule of `M` that contains just the zero element is the bottom submodule.

For any semiring `R` and additive commutative monoid `M` that is an `R`-module, the zero element's span is the bottom submodule of `M`.


theorem Set.disjoint_singleton_left : ∀ {α : Type u} {a : α} {s : Set α}, Disjoint {a} s ↔ a ∉ s := by sorry

The theorem `Set.disjoint_singleton_left` states that for any type `α`, any element `a` of that type, and any set `s` of type `α`, the singleton set containing `a` is disjoint with `s` if and only if `a` is not an element of `s`. In other words, a singleton set and another set are disjoint if the single element of the singleton set does not belong to the other set. Here, disjointness is defined in the sense of lattice theory, i.e., two elements of a lattice are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice.

For any type α, set s of α, and element a of α, the singleton set {a} is disjoint with s if and only if a ∉ s.


/-- The finrank of `(ι → R)` is `Fintype.card ι`.  -/
theorem FiniteDimensional.finrank_pi :
    ∀ (R : Type u) [inst : Ring R] [inst_1 : StrongRankCondition R] {ι : Type v} [inst_2 : Fintype ι],
      FiniteDimensional.finrank R (ι → R) = Fintype.card ι :=
  by sorry

The theorem `FiniteDimensional.finrank_pi` states that the rank of the function space `(ι → R)`, where `R` is a ring and `ι` is a finite type, is equal to the cardinality of `ι`. In other words, when considering the space of functions from a finite set `ι` to a ring `R`, the dimension of this vector space over the ring `R` is just the number of elements in the set `ι`. The ring `R` is assumed to satisfy the strong rank condition, which is a property that prevents certain infinite-dimensional counterexamples.

The rank of the function space from a finite type to a ring satisfying the strong rank condition is equal to the cardinality of the type.


theorem Nat.sInf_empty : sInf ∅ = 0 := by sorry

This theorem states that the infimum (greatest lower bound) of an empty set of natural numbers is 0. In other words, because 0 is the smallest natural number, it serves as the infimum for an empty set.

The empty set of natural numbers has 0 as its infimum.


theorem Nat.le_pred_of_lt : ∀ {n m : ℕ}, n < m → n ≤ Nat.pred m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than `m`, then `n` is less than or equal to the predecessor of `m`. The predecessor of a natural number is defined as the number subtracted by 1. For example, the predecessor of `m` is `m - 1`. However, for the natural number 0, its predecessor is defined as 0.

For all natural numbers `n` and `m`, if `n` < `m`, then `n` ≤ `(m : nat)` (where `(m : nat)` denotes `m` as a natural number).


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

The theorem `disjoint_sup_right` states that for any type `α`, where `α` is a distributive lattice with a least or bottom element, `Disjoint a (b ⊔ c)` is equivalent to `Disjoint a b` and `Disjoint a c` for any elements `a`, `b`, `c` of `α`. In other words, an element `a` is disjoint with the join (supremum) of elements `b` and `c` if and only if `a` is disjoint with both `b` and `c` separately. Here, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice.

In a distributive lattice with least element, an element is disjoint with the join of two other elements if and only if it is disjoint with each of them separately.


AnalyticAt.mul

/-- Multiplication of analytic functions (valued in a normed `𝕜`-algebra) is analytic.  -/
theorem AnalyticAt.mul :
    ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {A : Type u_8} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f g : E → A}
      {z : E}, AnalyticAt 𝕜 f z → AnalyticAt 𝕜 g z → AnalyticAt 𝕜 (fun x => f x * g x) z :=
  by sorry

The theorem `AnalyticAt.mul` states that if we have two functions `f` and `g` that are analytic at a point `z` in a normed space `E` over a nontrivially normed field `𝕜`, with values in a normed `𝕜`-algebra `A`, then the function defined by the pointwise multiplication of `f` and `g`, i.e., `(fun x => f x * g x)`, is also analytic at `z`. Here, a function is considered analytic at a point if it admits a convergent power series expansion around that point.

If `f` and `g` are analytic functions at a point `z` in a normed space `E` over a nontrivially normed field `𝕜` with values in a normed `𝕜`-algebra `A`, then their pointwise product `x => f x * g x` is also analytic at `z`.


CategoryTheory.CommSq.HasLift.mk'

theorem CategoryTheory.CommSq.HasLift.mk' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
      {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g},
      CategoryTheory.CommSq.LiftStruct sq → CategoryTheory.CommSq.HasLift sq :=
  by sorry

This theorem from category theory, `CategoryTheory.CommSq.HasLift.mk'`, states that for any category `C`, and any objects `A`, `B`, `X`, `Y` in `C`, and morphisms `f : A ⟶ X`, `i : A ⟶ B`, `p : X ⟶ Y`, and `g : B ⟶ Y` forming a commutative square `sq`, if a lifting structure for this commutative square exists, then the commutative square has a lift. In other words, if we can find a way to "complete" the square in such a way that all paths from `A` to `Y` are equivalent, then a lift exists for this square. This is a fundamental concept in category theory, related to the idea of universal constructions and commuting diagrams.

If a commutative square in a category has a lifting structure, then it has a lift.


LowerAdjoint.gc

theorem LowerAdjoint.gc :
    ∀ {α : Type u_1} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {u : β → α} (l : LowerAdjoint u),
      GaloisConnection l.toFun u :=
  by sorry

This theorem states that for any two types `α` and `β` that are preorders, and a function `u` from `β` to `α`, if `l` is a lower adjoint of `u`, then `l` and `u` form a Galois connection. In other words, for any elements `a` from `α` and `b` from `β`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`. This theorem is a specific case of the Galois connection concept from order theory and category theory.

For any preorders `α` and `β` and a function `u` from `β` to `α`, if `l` is a lower adjoint of `u`, then `l` and `u` form a Galois connection, i.e., for all `a ∈ α` and `b ∈ β`, `l a ≤ b` if and only if `a ≤ u b`.


/-- For `a - -b = a + b`, see `sub_neg_eq_add`. -/
theorem sub_neg :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      a - b < 0 ↔ a < b :=
  by sorry

The theorem `sub_neg` states that for any type `α` that forms an additive group, has an order `<`, and satisfies the covariance property where swapping the arguments of the addition operation preserves the order, the difference `a - b` of any two elements `a` and `b` of `α` is negative if and only if `a` is less than `b`. In other words, in such a context, subtracting a larger number from a smaller one yields a negative result.

For any additive group type `α` with ordering `<` satisfying the covariance property, `a - b` is negative if and only if `a` is less than `b`.


theorem Set.not_nonempty_empty : ∀ {α : Type u}, ¬Set.Nonempty ∅ := by sorry

This theorem, "Set.not_nonempty_empty", states that for all types `α`, the empty set is not non-empty. In other words, there doesn't exist any element in the empty set. It is a formal way to express that the property `Set.Nonempty` is not satisfied by the empty set, symbolized as `∅` in mathematics. This is a fundamental property of empty sets in set theory.

The empty set is not non-emptier. (In other words, the property of being non-empty is not satisfied by the empty set.)


StrictConcaveOn.neg

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

---

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

This theorem, termed `StrictConcaveOn.neg`, states that for any ordered semiring `𝕜`, an additive commutative monoid `E`, an ordered additive commutative group `β`, a set `s` of elements of type `E`, and a function `f` mapping from `E` to `β`, if the function `f` is strictly concave on the set `s`, then the negation of this function, `-f`, is strictly convex on the same set `s`. In more mathematical terms, for a function to be strictly concave means that for any two distinct points in its domain, the function's value at the weighted average of these points is strictly less than the weighted average of the function values at these points. Strict convexity of a function is defined in the similar manner, but with the inequality reversed. Therefore, this theorem essentially provides a way of transforming a strictly concave function into a strictly convex one by taking its negation.

If a function `f` mapping from an additive commutative monoid to an ordered additive commutative group is strictly concave on a set `s`, then the negation `-f` is strictly convex on `s`.


SimpleGraph.Subgraph.Adj.symm

theorem SimpleGraph.Subgraph.Adj.symm :
    ∀ {V : Type u} {G : SimpleGraph V} {G' : SimpleGraph.Subgraph G} {u v : V}, G'.Adj u v → G'.Adj v u := by sorry

The theorem `SimpleGraph.Subgraph.Adj.symm` states that for any type `V`, given a simple graph `G` of vertices of type `V`, a subgraph `G'` of `G`, and vertices `u` and `v`, if `u` is adjacent to `v` in the subgraph `G'`, then `v` is also adjacent to `u` in the same subgraph. In other words, the adjacency relationship in a subgraph of a simple graph is symmetric.

If `G` is a simple graph and `u`, `v` are vertices in a subgraph `G'` of `G` such that `u` is adjacent to `v` in `G'`, then `v` is adjacent to `u` in `G'`.


theorem Nat.pow_le_pow_of_le_left : ∀ {n m : ℕ}, n ≤ m → ∀ (i : ℕ), n ^ i ≤ m ^ i := by sorry

This theorem states that for any natural numbers `n` and `m`, if `n` is less than or equal to `m`, then `n` to the power of any natural number `i` is also less than or equal to `m` to the power of `i`. In other words, it generalizes the property of order preservation under exponentiation for natural numbers.

For all natural numbers `n` and `m` and `i`, if `n <= m`, then `n^i <= m^i`.


theorem Multiset.le_add_left : ∀ {α : Type u_1} (s t : Multiset α), s ≤ t + s := by sorry

The theorem `Multiset.le_add_left` states that for any type `α` and for any two multisets `s` and `t` of type `α`, `s` is less than or equal to the sum of `t` and `s`. Here, the sum of two multisets is the multiset containing all elements of both sets, possibly with duplication, and the order of elements does not matter. The less than or equal operation `≤` for multisets is defined in a sense analogous to subset relation for sets, but considering the number of occurrences of each element.

For any type `α` and multisets `s` and `t` of type `α`, `s ≤ s + t`. (That is, the multiset `s` is less than or equal to the sum of `s` and `t`.)


theorem Set.vadd_set_inter :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {s t : Set β} {a : α},
      a +ᵥ s ∩ t = (a +ᵥ s) ∩ (a +ᵥ t) :=
  by sorry

This theorem expresses a property in the context of additive group actions. It states that for any types `α` and `β`, where `α` is an additive group and `β` is a set acted upon by `α` (known as an `AddAction`), and given any two sets `s` and `t` of type `β` and an element `a` of type `α`, the set obtained by the group action of `a` on the intersection of `s` and `t` is equal to the intersection of the set obtained by the group action of `a` on `s` and the set obtained by the group action of `a` on `t`. In other words, this theorem says that the operation of adding a group element to a set and taking intersections commute with each other.

For any additive group `α` and a set `β` acted upon by `α`, the group action commutes with intersections, that is, for any sets `s` and `t` in `β` and an element `a` in `α`, we have `a∘(s ∩ t) = (a∘s) ∩ (a∘t)`.


theorem Continuous.closure_preimage_subset :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f → ∀ (t : Set Y), closure (f ⁻¹' t) ⊆ f ⁻¹' closure t :=
  by sorry

This theorem states that for any types `X` and `Y` with respective topological spaces, and for any function `f` from `X` to `Y` that is continuous, the closure of the preimage of a set `t` under `f` is a subset of the preimage of the closure of `t` under `f`. In simpler terms, if you take a set `t` in `Y`, find its preimage in `X`, and then take the closure of that preimage, you end up with a set that is entirely contained within the preimage of the closure of `t`. It's a statement about how continuous functions interact with the process of taking closures and preimages in topological spaces.

For any continuous function $f$ from a topological space $X$ to a topological space $Y$ and any set $t$ in $Y$, the closure of $f^{-1}(t)$ is contained in $f^{-1}(\overline{t})$.


/-- We can shrink `A` to any smaller size.  -/
theorem Finset.exists_smaller_set : ∀ {α : Type u_1} (A : Finset α), ∀ i ≤ A.card, ∃ B ⊆ A, B.card = i := by sorry

This theorem states that for any given finite set `A` of some type `α`, and for any integer `i` less than or equal to the cardinality of `A`, there exists a subset `B` of `A` such that the cardinality of `B` is `i`. In other words, it is always possible to find a subset of `A` with any smaller size up to and including the size of `A`.

For any finite type `α` and natural number `i` less than or equal to the cardinality of a finite set `A` of type `α`, there exists a subset `B` of `A` with cardinality `i`.