/-- If the oriented angle between two vectors is `π / 2`, the inner product of those vectors
(reversed) is zero.  -/
theorem Orientation.inner_rev_eq_zero_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y = ↑(Real.pi / 2) → ⟪y, x⟫_ℝ = 0 :=
  by sorry

This theorem states that in a real inner product space with finite dimension of 2, if the oriented angle between two vectors is equal to π/2 (or equivalently 90 degrees), then the inner product of the reversed order of these vectors is zero. This essentially corresponds to the geometric idea that if two vectors are orthogonal, i.e., they form a 90 degree angle, their inner (or dot) product is zero.

In a 2-dimensional real inner product space, the inner product of two orthogonal vectors is zero.


theorem EReal.mul_comm : ∀ (x y : EReal), x * y = y * x := by sorry

This theorem states that multiplication of extended real numbers, i.e., numbers that can range from negative infinity to positive infinity, is commutative. In other words, for any two extended real numbers `x` and `y`, the result of multiplying `x` by `y` is the same as the result of multiplying `y` by `x`.

For all extended real numbers x and y, x * y = y * x.


theorem Finset.image₂_subset_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s s' : Finset α}
      {t : Finset β}, s ⊆ s' → Finset.image₂ f s t ⊆ Finset.image₂ f s' t :=
  by sorry

The theorem `Finset.image₂_subset_right` states that for any types `α`, `β`, and `γ`, with `γ` having decidable equality, and any function `f` from `α` and `β` to `γ`, if one finite set `s` of type `α` is a subset of another finite set `s'` of the same type, and `t` is a finite set of type `β`, then the image of the binary function `f` applied to the pairs from `s` and `t` is a subset of the image of `f` applied to the pairs from `s'` and `t`. In other words, if `s` is a subset of `s'`, then the set of all values `f(a, b)` for `a` in `s` and `b` in `t` is a subset of the set of all values `f(a', b)` for `a'` in `s'` and `b` in `t`.

If `s` is a subset of `s'` in type `α`, and `t` is a finite set of type `β`, then the image of the function `f` from `α × β` to `γ` applied to pairs in `s × t` is a subset of the image of `f` applied to pairs in `s' × t`, where `γ` has decidable equality.


theorem MeasureTheory.Measure.haveLebesgueDecomposition_add :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α)
      [inst : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) :=
  by sorry

This theorem states that for any type `α` and measurable space `m` defined on `α`, given any two measures `μ` and `ν` on this space, if `μ` has a Lebesgue decomposition with respect to `ν`, then `μ` can be represented as the sum of the singular part of `μ` with respect to `ν` and `ν` with the density of the Radon-Nikodym derivative of `μ` with respect to `ν`. In mathematical terms, this is the statement of the Lebesgue Decomposition Theorem which says for any two σ-finite measure spaces, the first measure can be decomposed into the sum of the absolutely continuous part and the singular part with respect to the second measure.

Given any two σ-finite measures `μ` and `ν` on a measurable space, `μ` has a Lebesgue decomposition with respect to `ν` as the sum of its singular part and the product of `ν` with the Radon-Nikodym derivative of `μ` with respect to `ν`.


List.IsSuffix.sublist

theorem List.IsSuffix.sublist : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → List.Sublist l₁ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a suffix of `l₂` (denoted by `l₁ <:+ l₂`), then `l₁` is also a sublist of `l₂` (denoted by `List.Sublist l₁ l₂`). In other words, if one list ends with the same elements as another list, then the first list is a subsection of the second list.

If `α` is a type and `l₁` is a suffix of `l₂` (`l₁ <:+ l₂`) in lists of type `α`, then `l₁` is a sublist of `l₂` (`List.Sublist l₁ l₂`).


FreimanHom.ext

theorem FreimanHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {A : Set α} {n : ℕ} ⦃f g : A →*[n] β⦄,
      (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem, referred to as `FreimanHom.ext`, states that for any two types `α` and `β` with the structures of commutative monoids, for a set `A` of elements of type `α` and any natural number `n`, if `f` and `g` are Freiman homomorphisms from `A` to `β` of order `n`, and if `f` and `g` map every element `x` of the set `A` to the same element in `β`, then `f` and `g` are indeed the same Freiman homomorphism. In other words, it ensures the uniqueness of a Freiman homomorphism under the described conditions.

If `α` and `β` are commutative monoids, `A` is a set of elements from `α`, `n` is a natural number, `f` and `g` are Freiman homomorphisms from `A` to `β` of order `n`, and `f(x) = g(x)` for all `x ∈ A`, then `f = g`.


AddCommute.symm

/-- If `a` commutes with `b`, then `b` commutes with `a`. -/
theorem AddCommute.symm : ∀ {S : Type u_2} [inst : Add S] {a b : S}, AddCommute a b → AddCommute b a := by sorry

The theorem `AddCommute.symm` states that for any type `S` that has an addition operation, if two elements `a` and `b` of type `S` satisfy the property `AddCommute a b` (meaning that `a + b = b + a`), then they also satisfy `AddCommute b a` (meaning that `b + a = a + b`). In other words, the commutativity of addition is symmetric: if `a` commutes with `b`, then `b` commutes with `a`.

If `a` and `b` are elements of a type `S` with commutative addition, then `AddCommute a b` implies `AddCommute b a`.


theorem Nat.mul_pos : ∀ {n m : ℕ}, n > 0 → m > 0 → n * m > 0 := by sorry

This theorem, `Nat.mul_pos`, states that for any two natural numbers `n` and `m`, if both `n` and `m` are greater than zero, then their product is also greater than zero. In mathematical terms, it expresses that the product of two positive natural numbers is always positive.

For all natural numbers `n` and `m` greater than zero, `n * m` is also greater than zero.


theorem Int.natAbs_eq : ∀ (a : ℤ), a = ↑(Int.natAbs a) ∨ a = -↑(Int.natAbs a) := by sorry

The theorem `Int.natAbs_eq` states that for every integer `a`, `a` is equal to the absolute value of `a` (which is a natural number) or `a` is equal to the negation of the absolute value of `a`. In other words, an integer is either its own absolute value or its negative. Essentially, this theorem reflects that the absolute value function in integers returns the magnitude of the integer without regard to its sign.

For every integer `a`, `|a| = a` or `|a| = -a`.


theorem CategoryTheory.eqToHom_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (h : F = G) (X : C),
      (CategoryTheory.eqToHom h).app X = CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.eqToHom_app` states that for any two categories `C` and `D` with functors `F` and `G` such that `F` equals `G`, and any object `X` in `C`, the application of the morphism generated from equality `F = G` to `X` is the same as the morphism generated by the equality at some suppressed context. In other words, this theorem relates the application of a functor equality to an object with the morphism generated by the equality in a certain context.

For any categories C, D, functors F = G, and object X in C, the morphism generated from the equality F = G applied to X is equal to the morphism generated by the equality at some suppressed context.


theorem sub_one_lt : ∀ {α : Type u} [inst : LinearOrderedRing α] (a : α), a - 1 < a := by sorry

This theorem states that for any type `α` that has an instance of `LinearOrderedRing`, subtracting one from any element `a` of that type will always result in a value that is less than `a`. In terms of traditional mathematical notation, this is equivalent to the statement ∀a ∈ α, a - 1 < a.

For all `α` with `LinearOrderedRing`, for all `a` in `α`, `a` > `a` - 1. (This is the negative of the original statement, as Lean uses the convention that `x < y` is the same as `-y < x` in its order theory.)


theorem Rat.normalize_eq_mkRat :
    ∀ {num : ℤ} {den : ℕ} (den_nz : den ≠ 0), Rat.normalize num den den_nz = mkRat num den := by sorry

This theorem states that for any integer `num` and natural number `den` where `den` is not equal to zero, the rational number obtained by normalizing `num` and `den` using `Rat.normalize` is equivalent to the rational number obtained by constructing it using `mkRat`. Essentially, it shows that the smart constructors `Rat.normalize` and `mkRat` yield the same result when the denominator is not zero.

For any integer `num` and natural number `den`, the rational numbers `Rat.normalize num den` and `mkRat num den` are equal when `den` is non-zero.


theorem strictMono_nat_of_lt_succ :
    ∀ {α : Type u} [inst : Preorder α] {f : ℕ → α}, (∀ (n : ℕ), f n < f (n + 1)) → StrictMono f := by sorry

The theorem `strictMono_nat_of_lt_succ` states that for any type `α` with a preorder structure and any function `f` from natural numbers to `α`, if for every natural number `n`, the value `f(n)` is less than the value `f(n + 1)`, then the function `f` is strictly monotone. In mathematical terms, if $f(n) < f(n + 1)$ for all natural numbers $n$, then $a < b$ implies $f(a) < f(b)$ for all natural numbers $a$ and $b$.

If `f` is a function from natural numbers to a type with a preorder structure and `f(n)` is less than `f(n+1)` for all natural numbers `n`, then `f` is strictly monotone, that is, `a < b` implies `f(a) < f(b)` for all natural numbers `a` and `b`.


theorem CategoryTheory.Limits.BinaryBicone.inr_snd_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {P Q : C} (self : CategoryTheory.Limits.BinaryBicone P Q) {Z : C} (h : Q ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.inr (CategoryTheory.CategoryStruct.comp self.snd h) = h :=
  by sorry

The theorem `CategoryTheory.Limits.BinaryBicone.inr_snd_assoc` states that for any category 'C' with zero morphisms, given binary bicone on objects 'P' and 'Q' of the category, and any morphism `h` from 'Q' to another object 'Z' in the category, the composition of the morphism `h` with the second morphism of the bicone followed by the 'inr' morphism of the bicone is equal to the morphism `h`. In the language of category theory, this theorem is about the associativity of composition of morphisms in the context of binary bicones.

For any category with zero morphisms, given a binary bicone on objects P and Q, and a morphism h from Q to another object Z, the composition h ∘ bicone.2 ∘ inr = h.


theorem NNReal.coe_lt_coe : ∀ {r₁ r₂ : NNReal}, ↑r₁ < ↑r₂ ↔ r₁ < r₂ := by sorry

This theorem states that for any two nonnegative real numbers (`NNReal`), r₁ and r₂, the condition that the real number representation of r₁ is less than the real number representation of r₂ is equivalent to the condition that r₁ is less than r₂ within the type `NNReal`. This theorem thus guarantees a consistent ordering between nonnegative real numbers when considered either as `NNReal` or as real numbers.

For any nonnegative real numbers r₁ and r₂, r₁ < r₂ in the `NNReal` ordering if and only if r₁ < r₂ as real numbers.


theorem Set.image_insert_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {s : Set α}, f '' insert a s = insert (f a) (f '' s) := by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, any element `a` of type `α`, and any set `s` of type `α`, the image of the function `f` applied to the set that results from inserting element `a` into set `s` is equal to the set that results from inserting `f(a)` into the image of `f` applied to `s`. In mathematical terms, this could be written as $f(\{a\} \cup s) = \{f(a)\} \cup f(s)$. This theorem is related to the concept of image and the property of functions with sets.

For any functions $f: \alpha \rightarrow \beta$, elements $a:\alpha$, and sets $s:\alpha$, we have $f(\{a\} \cup s) = \{f(a)\} \cup f(s)$.


theorem IntermediateField.adjoin_le_iff :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {S : Set E}
      {T : IntermediateField F E}, IntermediateField.adjoin F S ≤ T ↔ S ≤ ↑T :=
  by sorry

This theorem states that for any fields `F` and `E`, with `E` being an algebra over `F`, and any set `S` of elements from `E`, and any intermediate field `T` between `F` and `E`, the intermediate field formed by adjoining `S` to `F` is a subset of `T` if and only if `S` is a subset of the set of elements of `T`. In other words, the extension of a field `F` by a set `S` is contained within an intermediate field `T` between `F` and `E` if and only if the set `S` is contained within the field `T`.

The theorem asserts that the subfield of `E` generated by `F` and a set `S` is contained in an intermediate field `T` between `F` and `E` if and only if `S` is contained in `T`.


theorem Finset.sum_range_succ' :
    ∀ {β : Type u_4} [inst : AddCommMonoid β] (f : ℕ → β) (n : ℕ),
      (Finset.sum (Finset.range (n + 1)) fun k => f k) = (Finset.sum (Finset.range n) fun k => f (k + 1)) + f 0 :=
  by sorry

The theorem `Finset.sum_range_succ'` states that for any given function `f` from natural numbers to a type `β` with additive commutative monoid structure, and for any natural number `n`, the sum of the function `f` evaluated over the range from 0 to `n+1` is equal to the sum of the function `f` evaluated at `k+1` over the range from 0 to `n` plus the function `f` evaluated at 0. In mathematical notation, this can be expressed as:

∑_{k=0}^{n+1} f(k) = f(0) + ∑_{k=0}^n f(k+1).

The sum of a function's values from 0 to n+1 is equal to the sum of its values from 0 to n added to the value at 0. In Lean, this is expressed as `∑(k in 0..(n+1), f k) = f 0 + ∑(k in 0..n, f (succ k))`.


Int.le.dest

theorem Int.le.dest : ∀ {a b : ℤ}, a ≤ b → ∃ n, a + ↑n = b := by sorry

This theorem, `Int.le.dest`, states that for any two integers `a` and `b`, if `a` is less than or equal to `b`, then there exists a non-negative integer `n` such that when `n` is added to `a`, we get `b`. In other words, it confirms the intuitive notion that `b` can be reached by adding some non-negative number to `a` when `a` is less than or equal to `b`.

For any integers `a` and `b` with `a ≤ b`, there exists a non-negative integer `n` such that `a + n = b`.


theorem DFunLike.coe_fn_eq :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, ⇑f = ⇑g ↔ f = g := by sorry

This theorem states that for any dependent function-like object `F` (of sort `u_1`), that takes an input of sort `α` (of sort `u_2`) and maps to sort `β` (of sort `u_3`), given the instance `i` of dependent function-like behaviour for `F`, `α` and `β`, then for any two objects `f` and `g` of type `F`, if the function application of `f` is the same as the function application of `g` (denoted as `⇑f = ⇑g`), then `f` itself is equal to `g` and vice-versa. Essentially, it is stating that if two dependent function-like objects have the same effect when applied, they must be the same object.

Given a dependent function-like object `F` from sort `α` to sort `β`, if two elements `f` and `g` of `F` have the same application, i.e., `⇑f = ⇑g`, then `f` and `g` are equal.


theorem Decidable.not_and_iff_or_not_not' : ∀ {b a : Prop} [inst : Decidable b], ¬(a ∧ b) ↔ ¬a ∨ ¬b := by sorry

This theorem, `Decidable.not_and_iff_or_not_not'`, states that for any two propositions `a` and `b`, where `b` is decidable, the negation of the conjunction of `a` and `b` (`¬(a ∧ b)`) is logically equivalent to the disjunction of the negations of `a` and `b` (`¬a ∨ ¬b`). In other words, "not (a and b)" is the same as "either not a or not b".

The negation of the conjunction of two propositions is logically equivalent to the disjunction of their negations, when one of the propositions is decidable.


theorem Semigroup.mem_center_iff :
    ∀ {M : Type u_1} [inst : Semigroup M] {z : M}, z ∈ Set.center M ↔ ∀ (g : M), g * z = z * g := by sorry

This theorem states that for any type `M` with a `Semigroup` structure and any element `z` of `M`, `z` is in the center of `M` if and only if for all elements `g` of `M`, the product of `g` and `z` is equal to the product of `z` and `g`. In other words, an element is in the center of a semigroup if it commutes with every other element in the semigroup.

An element of a semigroup is in its center if and only if it commutes with every other element.


theorem CategoryTheory.Endofunctor.Coalgebra.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
      {A B : CategoryTheory.Endofunctor.Coalgebra F} {f g : A ⟶ B}, autoParam (f.f = g.f) _auto✝ → f = g :=
  by sorry

The theorem `CategoryTheory.Endofunctor.Coalgebra.ext` states that, in any category `C` with a given endofunctor `F`, for any two coalgebras `A` and `B` of that endofunctor, if two morphisms `f` and `g` from `A` to `B` have the same underlying function (i.e., `f.f = g.f`), then `f` and `g` are indeed the same morphism. This equality condition is provided as an `autoParam`, which means it is typically inferred automatically by Lean.

In any category with an endofunctor, two coalgebras' morphisms with equal underlying functions are equal as morphisms.


theorem iSup_range :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] {g : β → α} {f : ι → β},
      ⨆ b ∈ Set.range f, g b = ⨆ i, g (f i) :=
  by sorry

This theorem states that for any types `α`, `β`, and `ι`, given a complete lattice structure on `α` and functions `g: β → α` and `f: ι → β`, the supremum (⨆, a generalization of the maximum for sets that may not have a greatest element) of the function `g` over the range of `f` is equal to the supremum of `g ∘ f` over `ι`. In other words, it doesn't matter whether we first apply `f` to each element of `ι` and then find the supremum of `g` values, or first find the supremum over the range of `f` and then apply `g`.

For any complete lattices `α`, `β`, and `ι`, and functions `g: β → α` and `f: ι → β`, the supremum of `g ∘ f` over `ι` equals the supremum of `g` over the range of `f`.


SemiconjBy.eq

/-- Equality behind `SemiconjBy a x y`; useful for rewriting.  -/
theorem SemiconjBy.eq : ∀ {S : Type u_1} [inst : Mul S] {a x y : S}, SemiconjBy a x y → a * x = y * a := by sorry

The theorem `SemiconjBy.eq` states that for any type `S` with a multiplication operation, given elements `a`, `x` and `y` of `S`, if `x` is semiconjugate to `y` by `a` (which is defined as `a * x = y * a`), then the equation `a * x = y * a` holds true. This theorem is particularly useful for rewriting expressions in proofs involving semiconjugacy.

If `a`, `x`, and `y` are elements of a type `S` with a multiplication operation, and `x` is semiconjugate to `y` by `a` (i.e., `a * x = y * a`), then `a * x = y * a`.


theorem List.Sublist.eq_of_length :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.length l₁ = List.length l₂ → l₁ = l₂ := by sorry

This theorem states that for any two lists `l₁` and `l₂` of the same type `α`, if `l₁` is a sublist of `l₂` and both lists have the same length, then `l₁` is equal to `l₂`. In other words, if a list is a sublist of another list, and they have the same number of elements, then they must be the same list.

If two lists `l₁` and `l₂` of the same type `α` have the same length and `l₁` is a sublist of `l₂`, then `l₁ = l₂`.


theorem imp_congr : ∀ {a b c d : Prop}, (a ↔ c) → (b ↔ d) → (a → b ↔ c → d) := by sorry

This theorem, `imp_congr`, states that for any four propositions `a`, `b`, `c`, and `d`, if `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then the implication `a` implies `b` is logically equivalent to the implication `c` implies `d`. In other words, if we have two pairs of equivalent propositions, the implications between the propositions within each pair are also equivalent.

If `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then the implication `a → b` is logically equivalent to `c → d`.


theorem Nat.pred_lt : ∀ {n : ℕ}, n ≠ 0 → Nat.pred n < n := by sorry

This theorem states that for any natural number `n`, if `n` is not equal to zero, then the predecessor of `n` (denoted as `Nat.pred n`), is strictly less than `n`. Recall that the predecessor of a natural number `n` is obtained by subtracting one from `n`, but when `n` is zero, the predecessor is defined to be zero as well. Thus, this theorem is asserting that any non-zero natural number is strictly greater than its predecessor.

For any natural number `n` different from zero, `Nat.pred n` is strictly less than `n`.


theorem Nat.sub_pos_of_lt : ∀ {m n : ℕ}, m < n → 0 < n - m := by sorry

This theorem states that for all natural numbers `m` and `n`, if `m` is less than `n`, then the result of `n - m` is a positive natural number. Essentially, it ensures that subtracting a smaller natural number from a larger one always results in a positive value.

For all natural numbers m and n, if m < n then n - m is a positive natural number.


theorem Set.Nonempty.of_image2_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
      Set.Nonempty (Set.image2 f s t) → Set.Nonempty t :=
  by sorry

The theorem `Set.Nonempty.of_image2_right` states that for all types `α`, `β`, and `γ` and for any binary function `f : α → β → γ` and sets `s : Set α` and `t : Set β`, if the image of the binary function `f` when applied to sets `s` and `t` is non-empty, then the set `t` is non-empty as well. In mathematical terms, this theorem asserts that if there exist elements in the image of the function `f(a, b)` for elements `a` in set `s` and `b` in set `t`, then there must exist some elements in set `t`.

If the image of a binary function under sets is non-empty, then one of the sets is non-empty.


/-- **Alias** of `ne_bot_of_gt`. -/
theorem LT.lt.ne_bot : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] {a b : α}, a < b → b ≠ ⊥ := by sorry

This theorem, `LT.lt.ne_bot`, states that for any type `α` that has a `Preorder` and `OrderBot` instance, if `a` and `b` are elements of `α` and `a` is less than `b`, then `b` cannot be the bottom element of `α`. In other words, if one element is strictly less than another in the given ordered set, the larger element can't be the lowest possible value in that set.

For any preordered type `α` with bottom element `bot`, if `a < b` holds in `α`, then `bot ≠ b`.


theorem Real.rpow_le_rpow : ∀ {x y z : ℝ}, 0 ≤ x → x ≤ y → 0 ≤ z → x ^ z ≤ y ^ z := by sorry

This theorem states that for any real numbers `x`, `y`, and `z`, if `x` is non-negative, `x` is less than or equal to `y`, and `z` is non-negative, then `x` raised to the power of `z` is less than or equal to `y` raised to the power of `z`. It expresses a property of exponentiation in the real numbers.

For all real numbers x, y, and z where x ≥ 0 and z ≥ 0, x^z ≤ y^z.


theorem le_max_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a ≤ max b c ↔ a ≤ b ∨ a ≤ c := by sorry

This theorem, `le_max_iff`, states that for any type `α` that has a linear order, and for any three elements `a`, `b`, `c` of that type, `a` is less than or equal to the maximum of `b` and `c` if and only if `a` is less than or equal to `b` or `a` is less than or equal to `c`. In other words, the value `a` is no larger than the bigger one of `b` and `c` if `a` is no larger than at least one of `b` and `c`.

For any type `α` with a linear order and any elements `a`, `b`, `c` of `α`, `a ≤ max b c` if and only if `a ≤ b` or `a ≤ c`.


theorem Rat.inv_def' : ∀ {a b : ℤ}, (Rat.divInt a b)⁻¹ = Rat.divInt b a := by sorry

This theorem states that for any two integers `a` and `b`, the reciprocal of the rational number formed by dividing `a` by `b` is the same as the rational number formed by dividing `b` by `a`. In other words, it expresses the property $(\frac{a}{b})^{-1} = \frac{b}{a}$ for all integers `a` and `b`.

The reciprocal of the rational number `a / b` is equal to `b / a` for all integers `a` and `b`.


theorem Ordnode.size_dual : ∀ {α : Type u_1} (t : Ordnode α), Ordnode.size (Ordnode.dual t) = Ordnode.size t := by sorry

This theorem, `Ordnode.size_dual`, states that for any type `α` and any instance `t` of an `Ordnode` of type `α`, the size of the `Ordnode` when passed through the `dual` function is equal to the original size of the `Ordnode`. In other words, the dual operation does not change the size of an `Ordnode`.

For any type `α` and `Ordnode` instance `t` of type `Ordnode α`, the size of `dual (Ordnode.mk node x)` equals the size of `Ordnode.mk node x`, where `node` is any node and `x` is any element of type `α`.


theorem Function.extend_def :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) (g : α → γ) (e' : β → γ) (b : β)
      [inst : Decidable (∃ a, f a = b)],
      Function.extend f g e' b = if h : ∃ a, f a = b then g (Classical.choose h) else e' b :=
  by sorry

The theorem `Function.extend_def` is about the definition of the function `Function.extend` for any given types `α`, `β` and `γ`, and functions `f : α → β`, `g : α → γ` and `e' : β → γ`, and a value `b : β`. If it is decidable whether there exists an `a` such that `f a = b`, then `Function.extend f g e' b` is defined as follows: if there exists such an `a`, then it is `g (Classical.choose h)`, where `h` is the proof of existence. Otherwise, it is `e' b`. Here, `Classical.choose` is a function that given a proof of existence of a value satisfying a property, gives you a specific value satisfying that property.

Given functions `f : α -> β`, `g : α -> γ`, `e' : β -> γ`, and `b : β`, if it is decidable which `a : α` satisfies `f a = b`, then `Function.extend f g e' b` is `g (the a | exists a, f a = b)` or `e' b` otherwise.


theorem Int.mul_assoc : ∀ (a b c : ℤ), a * b * c = a * (b * c) := by sorry

This theorem states that for all integers `a`, `b`, and `c`, the operation of multiplication is associative. That is, the result of first multiplying `a` and `b` and then multiplying the result by `c` is the same as the result of first multiplying `b` and `c` and then multiplying `a` by that result. In mathematical notation, this is expressed as `a * b * c = a * (b * c)`.

The theorem asserts that for all integers `a`, `b`, and `c`, the associativity of multiplication holds: `a * (b * c) = (a * b) * c`.


theorem Equiv.range_eq_univ : ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β), Set.range ⇑e = Set.univ := by sorry

The theorem `Equiv.range_eq_univ` states that for any two types `α` and `β`, if there exists a bijection `e` between them (denoted as `α ≃ β`), then the range of `e` (i.e., the set of all images of elements in `α` under `e`) is the universal set of `β`. In other words, every element of `β` is an image of some element of `α` under the bijection `e`. This is a formalization of the idea that a bijection is a function that pairs elements from two sets such that every element in each set has a unique partner in the other set.

If `α` and `β` are type-equivalent (`α ≃ β`), then the range of any bijection `e` between them equals the universe of `β`.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.9 : ∀ (a u : ZFSet), (a ∈ ZFSet.toSet u) = (a ∈ u) := by sorry

This theorem states that for all ZFSet (Zermelo–Fraenkel Set Theory) elements 'a' and 'u', 'a' is an element of the set represented by 'u' (obtained using `ZFSet.toSet` function) if and only if 'a' is an element of 'u' itself. In other words, the function `ZFSet.toSet` preserves the membership relation in the ZFSet universe.

For all 'a' and 'u' in ZFSet, 'a' is an element of the set `ZFSet.toSet u` if and only if 'a' is an element of 'u'.


theorem NNReal.coe_pos : ∀ {r : NNReal}, 0 < ↑r ↔ 0 < r := by sorry

This theorem states that for every nonnegative real number `r`, the value of `r` is positive if and only if the coercion of `r` (i.e., `r` considered as a real number) is positive. This involves the logical biconditional (`↔`), signifying that the positiveness of the original nonnegative real number and its real number counterpart are equivalent.

For every nonnegative real number `r`, `r` is positive if and only if its real number coercion is positive.


theorem Set.finite_empty : ∀ {α : Type u}, Set.Finite ∅ := by sorry

This theorem states that for any type `α`, the empty set of type `α` is finite. In other words, no matter what type of elements we are considering, a set with no elements (an empty set) is always considered to be finite.

The empty set of any type is a finite set.


theorem MeasureTheory.integrableOn_union :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s t : Set α}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.IntegrableOn f (s ∪ t) μ ↔ MeasureTheory.IntegrableOn f s μ ∧ MeasureTheory.IntegrableOn f t μ :=
  by sorry

This theorem, `MeasureTheory.integrableOn_union`, states that for any measure space `α`, any normed additive commutative group `E`, any function `f` from `α` to `E`, any two sets `s` and `t` of `α`, and any measure `μ` on `α`, the function `f` is integrable on the union of `s` and `t` with respect to the measure `μ` if and only if `f` is integrable on both `s` and `t` separately with respect to `μ`. In mathematical terms, if $\int_{s \cup t} |f| d\mu < \infty$, then $\int_s |f| d\mu < \infty$ and $\int_t |f| d\mu < \infty$, and vice versa.

A function from a measure space to a normed additive commutative group is integrable over the union of two sets if and only if it is integrable over each set separately.


theorem Finset.sum_ite_eq :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (a : α)
      (b : α → β), (Finset.sum s fun x => if a = x then b x else 0) = if a ∈ s then b a else 0 :=
  by sorry

The theorem `Finset.sum_ite_eq` states that for any type `α`, type `β` with an addition commutative monoid structure, a finset `s` of `α`, an element `a` of `α`, and a function `b` mapping `α` to `β`, the sum over the finset `s` of the function which applies `b` to `x` if `x` equals `a` and otherwise returns zero, is equal to `b(a)` if `a` is an element of `s` and is otherwise zero. This can be interpreted as saying that the sum of a set of conditionally defined elements equals the value of the element if the condition is met in the set or zero if it isn't.

For any commutative monoid type `β`, finset `s` of type `α`, element `a` of `α`, and function `b` from `α` to `β`, the sum of `b` applied to elements of `s` that equal `a` equals `b(a)` if `a` is in `s`, and is zero otherwise.


theorem List.ne_nil_of_mem : ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → l ≠ [] := by sorry

This theorem states that for any type `α`, any element `a` of this type, and any list `l` of elements of this type, if `a` is an element of `l` (denoted by `a ∈ l`), then `l` is not an empty list (denoted by `l ≠ []`). In other words, if a list contains at least one element, then it cannot be the empty list.

For any type `α` and list `l` of length greater than 0 in `α`, if `a ∈ l`, then `l ≠ []`.


HasSSubset.SSubset.subset

/-- **Alias** of `subset_of_ssubset`. -/
theorem HasSSubset.SSubset.subset :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α}, a ⊂ b → a ⊆ b :=
  by sorry

This is a theorem named `HasSSubset.SSubset.subset` in Lean 4 which states that for any type `α` with defined subset and strict subset operations, and for which these operations form a nonstrict strict order, if an element `a` is a strict subset of an element `b` (denoted `a ⊂ b`), then `a` is also a subset of `b` (denoted `a ⊆ b`). This theorem essentially captures the intuitive notion that if `a` is strictly contained in `b`, then `a` is certainly contained in `b`, whether or not `a` equals `b`.

If `a` is a strict subset of `b` (`a ⊂ b`), then `a` is a subset of `b` (`a ⊆ b`).


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

The theorem `add_tsub_assoc_of_le` states that for any type `α` that is an additive commutative semigroup, has a partial order, an existence of addition for elements less than or equal to each other, a variant class, a subtraction operation, an ordered subtraction, and a contravariant class, if `c` is less than or equal to `b`, then for any `a` in `α`, the operation `a + b - c` is equal to `a + (b - c)`. This theorem provides a property of associative operations involving addition and subtraction under certain conditions in an ordered additive structure.

For any additive commutative semigroup `α` with partial order, existence of addition for elements less than or equal to each other, variant and contravariant classes, if `c ≤ b`, then `a + (b - c) = a + b - c` for all `a` in `α`.


theorem neg_sub_neg : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - -b = b - a := by sorry

This theorem, `neg_sub_neg`, states that for any type `α` where `α` is a subtraction commutative monoid, the negative of a difference between any two elements `a` and `b` of `α` after negating `b` is equal to the difference of `b` and `a`. In mathematical notation, this would be written as `-a - -b = b - a`.

For any commutative monoid `α` with subtraction operation `-`, we have `- (a - b) = b - a`.


theorem Polynomial.induction_on :
    ∀ {R : Type u} [inst : Semiring R] {M : Polynomial R → Prop} (p : Polynomial R),
      (∀ (a : R), M (Polynomial.C a)) →
        (∀ (p q : Polynomial R), M p → M q → M (p + q)) →
          (∀ (n : ℕ) (a : R), M (Polynomial.C a * Polynomial.X ^ n) → M (Polynomial.C a * Polynomial.X ^ (n + 1))) →
            M p :=
  by sorry

This theorem is an induction principle for polynomials over any semiring `R`. It states that, for any property `M` of polynomials, if `M` holds for all constant polynomials (proven by `∀ (a : R), M (Polynomial.C a)`), and `M` is preserved under addition of polynomials (proven by `∀ (p q : Polynomial R), M p → M q → M (p + q)`), and `M` is preserved when multiplying a polynomial by `X` to increase its degree by 1 (proven by `∀ (n : ℕ) (a : R), M (Polynomial.C a * Polynomial.X ^ n) → M (Polynomial.C a * Polynomial.X ^ (n + 1))`), then `M` must hold for all polynomials. In other words, any property of polynomials that holds for constants, respects addition, and respects degree-increasing multiplication by `X` must hold for all polynomials.

If a property of polynomials holds for constant polynomials and is closed under addition and degree-increasing multiplication by `X`, then it holds for all polynomials.


theorem CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
      (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).hom (t.π.app j) =
        s.π.app j :=
  by sorry

The theorem `CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp` states that for any category `J`, any category `C`, any functor `F` from `J` to `C`, and any two cones `s` and `t` over `F` for which `s` and `t` are limits, for any object `j` in `J`, the composition of the morphism from the isomorphism between the apexes of the cones `s` and `t` and the cone morphism from the apex of `t` to the object `F(j)` is equal to the cone morphism from the apex of `s` to `F(j)`. In other words, the isomorphism mapping the limit of `F` from `s` to `t` preserves the structure of the cones.

For any functors F from J to C, and cones s and t over F that are limits, the isomorphism between their apexes induces equal composition with any morphism from the apex of t to an object F(j) in C, as compared to the morphism from the apex of s to F(j).


theorem Real.ind_mk : ∀ {C : ℝ → Prop} (x : ℝ), (∀ (y : CauSeq ℚ abs), C (Real.mk y)) → C x := by sorry

The theorem `Real.ind_mk` states that for any property `C` that holds for real numbers `ℝ`, and for any real number `x`, if this property `C` holds for all `Real.mk y`, where `y` is a Cauchy sequence of rationals `ℚ` with respect to the absolute value function `abs`, then the property `C` also holds for `x`. This can be interpreted as a form of induction over real numbers constructed from Cauchy sequences of rational numbers.

If `C` is a property of real numbers and `C` holds for all Cauchy sequences of rationals converging to a real number `x`, then `C` holds for `x`.


theorem Int.dvd_natAbs : ∀ {a b : ℤ}, a ∣ ↑(Int.natAbs b) ↔ a ∣ b := by sorry

This theorem states that for any two integers `a` and `b`, `a` divides the absolute value of `b` if and only if `a` divides `b`. In other words, it asserts that the divisibility of an integer `a` by another integer `b` is equivalent to the divisibility of `a` by the absolute value of `b`. Here, the notation `a ∣ b` means "a divides b", and `↑(Int.natAbs b)` represents the absolute value of `b`.

For any integers `a` and `b`, `a` divides `b` if and only if `a` divides the absolute value of `b`. In symbols, `a ∣ b <-> a ∣ ↑(Int.natAbs b)`.


theorem sSup_empty : ∀ {α : Type u_1} [inst : CompleteLattice α], sSup ∅ = ⊥ := by sorry

This theorem states that for any type `α` that is a complete lattice, the supremum (or greatest lower bound) of an empty set is the minimal element (`⊥`). In other words, in the context of any complete lattice, when we attempt to find the supremum of no elements, we yield the smallest possible value within the lattice.

In a complete lattice, the supremum of an empty set equals the minimal element.


theorem MeasureTheory.lintegral_map :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {mβ : MeasurableSpace β}
      {f : β → ENNReal} {g : α → β},
      Measurable f → Measurable g → ∫⁻ (a : β), f a ∂MeasureTheory.Measure.map g μ = ∫⁻ (a : α), f (g a) ∂μ :=
  by sorry

This theorem states that for any two measurable spaces `α` and `β`, with `α` having a measure `μ`, and for any two measurable functions `f` from `β` to extended nonnegative real numbers `[0, ∞]` and `g` from `α` to `β`, the Lebesgue integral (denoted by `∫⁻`) of `f` with respect to the pushforward of the measure `μ` by the function `g` is equal to the Lebesgue integral of the composition of `f` and `g` with respect to the measure `μ`. In mathematical terms, `∫⁻ (a : β), f a ∂MeasureTheory.Measure.map g μ = ∫⁻ (a : α), f (g a) ∂μ`. This is a theorem about the change of variables in Lebesgue integration.

The Lebesgue integral of a measurable function `f` with respect to the pushforward measure of `μ` by `g` equals the Lebesgue integral of the composition `f ∘ g` with respect to the original measure `μ`.


theorem Filter.mem_pure : ∀ {α : Type u} {a : α} {s : Set α}, s ∈ pure a ↔ a ∈ s := by sorry

The theorem `Filter.mem_pure` states that for any type `α`, any element `a` of type `α`, and any set `s` of type `α`, the membership of `s` in the pure filter of `a` is equivalent to the membership of `a` in `s`. In other words, a set `s` is included in the pure filter of `a` if and only if `a` is an element of `s`. The pure filter of `a` is the collection of all sets that contain `a`.

For any type α, element a of α, and set s of α, the set s is contained in the filter of a (i.e., the set of sets containing a) if and only if a is an element of s.


/-- **Alias** of the forward direction of `isGLB_iff_sInf_eq`. -/
theorem IsGLB.sInf_eq :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s : Set α} {a : α}, IsGLB s a → sInf s = a := by sorry

The theorem `IsGLB.sInf_eq` states that for any type `α` that forms a complete semilattice with an infimum operation, and for any set `s` of type `α` and an element `a` of type `α`, if `a` is a greatest lower bound of the set `s`, then the infimum of the set `s` is equal to `a`. This theorem is actually an alias of the forward direction of another theorem, `isGLB_iff_sInf_eq`. Basically, it asserts that in a complete semilattice, the infimum of a set is its greatest lower bound.

In a complete semilattice, the greatest lower bound of a set is equal to its infimum.


theorem MeasureTheory.ofReal_integral_eq_lintegral_ofReal :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      MeasureTheory.Integrable f μ →
        0 ≤ᶠ[MeasureTheory.Measure.ae μ] f → ENNReal.ofReal (∫ (x : α), f x ∂μ) = ∫⁻ (x : α), ENNReal.ofReal (f x) ∂μ :=
  by sorry

This theorem states that for any measurable space `α`, and any real-valued function `f` defined on `α`, under the measure `μ`, if `f` is integrable and is almost everywhere nonnegative (i.e. `f` takes nonnegative values except possibly on a set of measure zero), then the extended nonnegative real part (obtained by treating all negative values as zero) of the integral of `f` over `μ` is equal to the integral over `μ` of the extended nonnegative real part of `f`. This essentially states that the process of taking the integral and the process of taking the extended nonnegative real part can be interchanged under the given conditions.

If `μ` is a measure on measurable space `α`, `f` is a real-valued integrable and almost everywhere nonnegative function on `α`, then the integral of the extended nonnegative real part of `f` over `μ` equals the extended nonnegative real part of the integral of `f` over `μ`.


theorem Mathlib.Data.Set.Lattice._auxLemma.2 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i := by sorry

This theorem states that for any type `α`, any sorting type `ι`, any element `x` of type `α`, and any function `s` from `ι` to the set of elements of type `α`, the statement "`x` belongs to the intersection over all `i` of `s i`" is equivalent to "for every `i` in `ι`, `x` belongs to `s i`". In other words, an element is in the intersection of a collection of sets if and only if it is in each set in the collection.

For any type `α`, sorting type `ι`, element `x` of type `α`, and function `s` from `ι` to `α`, `x` belongs to the intersection of `s i` for all `i` in `ι` if and only if `x` belongs to every `s i`.


theorem GaloisInsertion.u_injective :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : PartialOrder β],
      GaloisInsertion l u → Function.Injective u :=
  by sorry

The theorem `GaloisInsertion.u_injective` asserts that for any two types `α` and `β`, given the functions `l : α → β` and `u : β → α`, and assuming that `α` is a preordered set and `β` is a partially ordered set, if `l` and `u` form a Galois insertion, then the function `u` is injective. In other words, if `u` maps two elements of `β` to the same element of `α`, then these two elements of `β` must be the same. This is a property of Galois insertions in order theory.

If `l : α → β` and `u : β → α` form a Galois insertion between preordered set `α` and partially ordered set `β`, then `u` is an injective function.


theorem Prime.dvd_or_dvd :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p : α}, Prime p → ∀ {a b : α}, p ∣ a * b → p ∣ a ∨ p ∣ b := by sorry

The theorem `Prime.dvd_or_dvd` states that for any type `α` which has a commutative monoid with zero structure, and for any element `p` of `α` that is prime, whenever `p` divides the product of any two elements `a` and `b` (denoted as `p ∣ a * b`), then `p` must divide `a` or `p` must divide `b` (denoted as `p ∣ a ∨ p ∣ b`). This is a key property of prime elements in a commutative monoid with zero, mirroring the familiar property of prime numbers in the integers.

In a commutative monoid with zero, if a prime element p divides the product of two elements a and b, then p divides a or p divides b.


HomogeneousIdeal.isHomogeneous

theorem HomogeneousIdeal.isHomogeneous :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A]
      [inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι]
      [inst_5 : GradedRing 𝒜] (I : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (HomogeneousIdeal.toIdeal I) :=
  by sorry

The theorem `HomogeneousIdeal.isHomogeneous` states that for any given types `ι`, `σ`, `A`, and any given semiring `A`, any given set-like `σ` of `A`, any addSubmonoid class of `σ` over `A`, any function `𝒜` from `ι` to `σ`, a decidable equality on `ι`, an addition operation on `ι`, and a Graded Ring `𝒜`, if we have a homogeneous ideal `I` of `𝒜`, then the ideal we get by converting this homogeneous ideal to an ideal using the `HomogeneousIdeal.toIdeal` function is also a homogeneous ideal according to the `Ideal.IsHomogeneous` property. In short, this theorem ensures that the conversion of a homogeneous ideal to an ideal preserves the homogeneous property.

Given a homogeneous ideal in a graded ring, the ideal obtained by converting it using `HomogeneousIdeal.toIdeal` function is also a homogeneous ideal.


theorem RingHom.coe_inj :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄,
      ⇑f = ⇑g → f = g :=
  by sorry

This theorem, `RingHom.coe_inj`, asserts that for any two ring homomorphisms `f` and `g` from a non-associative semiring `α` to another non-associative semiring `β`, if the function application of `f` and `g` (denoted by `⇑f` and `⇑g` respectively) are equal, then `f` and `g` themselves are equal. This theorem essentially states that ring homomorphisms are injective with respect to their function application.

If two ring homomorphisms between non-associative semirings have equal function applications, then they are equal.


theorem MeasureTheory.Measure.le_iff :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ : MeasureTheory.Measure α},
      μ₁ ≤ μ₂ ↔ ∀ (s : Set α), MeasurableSet s → ↑↑μ₁ s ≤ ↑↑μ₂ s :=
  by sorry

This theorem, `MeasureTheory.Measure.le_iff`, states that for any type `α` equipped with a measurable space structure `m0` and any two measures `μ₁` and `μ₂` on `α`, the measure `μ₁` is less than or equal to the measure `μ₂` if and only if for all sets `s` of type `α` that are measurable, the measure of `s` under `μ₁` is less than or equal to the measure of `s` under `μ₂`. In other words, one measure is considered lesser or equal if it assigns a lesser or equal measure to every measurable set when compared with another measure.

For any measurable spaces (α, m0) and measures μ₁, μ₂ on α, μ₁ ≤ μ₂ if and only if μ₁(s) ≤ μ₂(s) for all measurable sets s ∈ α.


theorem AlgHom.map_one :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B), φ 1 = 1 :=
  by sorry

This theorem states that for any commutative semiring `R`, and any semirings `A` and `B`, where `A` and `B` are `R`-algebras, any algebra homomorphism `φ` from `A` to `B` maps the multiplicative identity element `1` in `A` to the multiplicative identity element `1` in `B`. In simpler terms, it means that under an algebra homomorphism, the number `1` in the original algebra `A` will always be mapped to the number `1` in the target algebra `B`.

For any commutative semirings `R`, and `R-algebra homomorphisms `φ` from `A` to `B` between `R-algebras` `A` and `B`, `φ(1_A) = 1_B`.


theorem MeasureTheory.snorm_exponent_top :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
      {f : α → F}, MeasureTheory.snorm f ⊤ μ = MeasureTheory.snormEssSup f μ :=
  by sorry

The theorem `MeasureTheory.snorm_exponent_top` states that for any measurable space `α`, any type `F` that forms a normed add commutative group, any measure `μ` on `α`, and any function `f` from `α` to `F`, the `ℒp` seminorm of `f` with exponent `∞` (represented as `MeasureTheory.snorm f ⊤ μ`) equals the essential supremum of `‖f‖` (represented as `MeasureTheory.snormEssSup f μ`). In simpler terms, this theorem shows the equivalence between two ways of measuring the size of functions in the context of measure theory when the exponent is infinity.

The `ℒp` seminorm of a measurable function `f` from a measurable space `α` to a normed add commutative group `F` with respect to measure `μ` at infinity equals the essential supreme of the function's norm.


theorem UniformSpace.Completion.coe_add :
    ∀ {α : Type u_3} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α] (a b : α),
      ↑α (a + b) = ↑α a + ↑α b :=
  by sorry

This theorem, `UniformSpace.Completion.coe_add`, states that for any type `α` that is a uniform space, an add group, and a uniform add group, the completion of the sum of two elements `a` and `b` of type `α` is equal to the sum of the completions of `a` and `b`. In other words, the operation of taking the completion in this context distributes over addition. This is a property of uniform spaces that also have a group structure where the group operation is compatible with the uniform structure.

For any uniform add group `α`, the completion of the sum of two elements `a` and `b` is equal to the sum of their completions.


theorem iInf_range :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] {g : β → α} {f : ι → β},
      ⨅ b ∈ Set.range f, g b = ⨅ i, g (f i) :=
  by sorry

The theorem `iInf_range` expresses that for all types `α`, `β` and `ι` where `α` has a complete lattice structure, and for any function `g` from `β` to `α` and any function `f` from `ι` to `β`, the greatest lower bound (infimum, or `⨅`) of the range of `f` under `g` is equal to the infimum of the image of `ι` under the composition of `f` and `g`. In other words, taking the infimum over the image of the function is the same as taking the infimum over the range of the function transformed by another function.

For any complete lattice `α`, function `g : β -> α`, and function `f : ι -> β`, the infimum of `g ∘ f` equals the infimum of `f` over the range of `g`.


theorem subset_upperClosure : ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, s ⊆ ↑(upperClosure s) := by sorry

This theorem, `subset_upperClosure`, states that for any set `s` in a pre-ordered type `α`, `s` is a subset of the upper closure of `s`. In other words, all elements of set `s` are also elements of the upper closure of `s`. The upper closure of a set is defined as the greatest upper set containing the given set, meaning it includes all elements from the original set and possibly additional elements that are greater than or equal to some element in `s` according to the preorder.

For any pre-ordered set `α` and set `s` in `α`, `s` is a subset of the upper closure of `s`. (i.e., all elements of `s` are in the upper closure of `s`).


theorem exists_surjective_nat : ∀ (α : Sort u) [inst : Nonempty α] [inst : Countable α], ∃ f, Function.Surjective f :=
  by sorry

The theorem `exists_surjective_nat` states that for any sort or type `α`, given that `α` is nonempty and countable, there exists a function `f` that is surjective. In other words, no matter what element you choose in the co-domain of `f`, there is at least one element in the domain of `f` that maps to it. Countability here refers to the property that there's a one-to-one correspondence between the elements of `α` and the natural numbers.

If `α` is a nonempty and countable type or sort, then there exists a surjective function `f : ℕ → α`.


theorem Filter.HasBasis.disjoint_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
      {s' : ι' → Set α},
      Filter.HasBasis l p s →
        Filter.HasBasis l' p' s' → (Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')) :=
  by sorry

This theorem states that for any types `α`, `ι` and `ι'`, any filters `l` and `l'` on `α`, and any functions `p : ι → Prop`, `s : ι → Set α`, `p' : ι' → Prop` and `s' : ι' → Set α`, if `l` has a basis indexed by `ι` with index property `p` and basis sets `s`, and `l'` has a basis indexed by `ι'` with index property `p'` and basis sets `s'`, then `l` and `l'` are disjoint if and only if there exists an index `i` such that `p i` holds and an index `i'` such that `p' i'` holds and the sets `s i` and `s' i'` are disjoint.

In other words, two filters are disjoint if and only if there exists a pair of basis sets, one from each filter, that are disjoint.

Two filters on a type, each with a disjoint basis indexed by their respective indices satisfying corresponding index properties, are disjoint if and only if there exist basis sets from each filter that are disjoint.


theorem ENNReal.top_rpow_of_pos : ∀ {y : ℝ}, 0 < y → ⊤ ^ y = ⊤ := by sorry

This theorem states that for any real number `y` that is greater than zero, the exponentiation of the extended nonnegative real number infinity (`⊤`) to the power of `y` equals infinity (`⊤`). Essentially, an infinite quantity raised to any positive real number remains infinite.


/-- The image of the maximal ideal of the source is contained within the maximal ideal of the target.
 -/
theorem map_nonunit :
    ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : LocalRing R] [inst_2 : CommSemiring S]
      [inst_3 : LocalRing S] (f : R →+* S) [inst_4 : IsLocalRingHom f],
      ∀ a ∈ LocalRing.maximalIdeal R, f a ∈ LocalRing.maximalIdeal S :=
  by sorry

This theorem states that for any two commutative semirings R and S that are both local rings, and any function `f` from R to S that is a local ring homomorphism, the image under `f` of any element of the maximal ideal of R is contained within the maximal ideal of S. The maximal ideal of a local ring consists of all elements that are not units in the ring. Therefore, this theorem essentially states that the property of being a non-unit is preserved under local ring homomorphisms.

Given commutative local rings R and S, and a local ring homomorphism f from R to S, the image of any element in the maximal ideal of R lies in the maximal ideal of S.


theorem neg_lt :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      -a < b ↔ -b < a :=
  by sorry

The theorem `neg_lt` states that for any type `α` that has an additive group structure and an order relation `<` that is covariant with respect to addition (in both the regular and the swapped argument order), for any two elements `a` and `b` of `α`, `-a` is less than `b` if and only if `-b` is less than `a`. Here, `-a` and `-b` denote the additive inverses of `a` and `b`, respectively. The covariance conditions essentially mean that adding the same value to both sides of a `<` inequality does not change the truth of the inequality.

For any type `α` with an additive group structure and a covariant order relation `<`, `-a < b` if and only if `-b < a`.


theorem Function.injective_surjInv :
    ∀ {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f), Function.Injective (Function.surjInv h) := by
  sorry

The theorem `Function.injective_surjInv` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is surjective (meaning that for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`), then the inverse function of `f`, denoted as `Function.surjInv h` where `h` is the surjectivity of `f`, is injective. An injective function is defined as a function where if `f(x) = f(y)`, then `x` must be equal to `y`. In other words, different inputs will always produce different outputs in an injective function.

If a function is surjective, then its inverse is injective.


theorem Eq.to_iff : ∀ {a b : Prop}, a = b → (a ↔ b) := by sorry

This theorem, `Eq.to_iff`, states that for any two propositions `a` and `b`, if `a` is equal to `b`, then `a` is logically equivalent to `b`. In other words, if two propositions are the same (`a = b`), then they imply each other (`a ↔ b`). It's a fundamental connection between the concepts of equality and logical equivalence in propositional logic.

If two propositions are equal, then they are logically equivalent. (a = b ↔ a ↔ b)


theorem PowerSeries.coeff_trunc :
    ∀ {R : Type u_1} [inst : Semiring R] (m n : ℕ) (φ : PowerSeries R),
      Polynomial.coeff (PowerSeries.trunc n φ) m = if m < n then (PowerSeries.coeff R m) φ else 0 :=
  by sorry

The theorem `PowerSeries.coeff_trunc` states that for any type `R` under a semiring, for any natural numbers `m` and `n`, and for any power series `φ` over `R`, the `m`-th coefficient of the `n`-th truncation of the power series is equal to the `m`-th coefficient of the power series if `m` is less than `n`. Otherwise, it is `0`. In other words, it determines the `m`-th coefficient of the polynomial obtained from truncating the power series at the `n`-th term.

For any semiring `R`, power series `φ` over `R`, and natural numbers `m` and `n` with `m < n`, the `m`-th coefficient of the `n`-th truncation of `φ` equals the `m`-th coefficient of `φ`. Otherwise, it is `0`.


theorem OpenEmbedding.map_nhds_eq :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      OpenEmbedding f → ∀ (x : X), Filter.map f (nhds x) = nhds (f x) :=
  by sorry

This theorem states that for any two types `X` and `Y`, along with a function `f` from `X` to `Y`, if `X` and `Y` are equipped with topological space structures and `f` is an open embedding, then for any element `x` of `X`, the forward map of the neighborhood filter at `x` under `f` is equal to the neighborhood filter at `f(x)` in `Y`. In other words, applying `f` to each set in the neighborhood filter of `x` results in the neighborhood filter of `f(x)`. This is an important property that relates the concept of continuity in topology with the operation of filters.

Given types `X` and `Y`, a function `f : X ↝ Y` between topological spaces, and an open embedding `f`, for all `x : X`, the forward image of the neighborhood filter of `x` under `f` equals the neighborhood filter of `f(x)` in `Y`.


/-- **Alias** of `Int.toNat_natCast`. -/
theorem Int.toNat_coe_nat : ∀ (n : ℕ), Int.toNat ↑n = n := by sorry

This theorem, known as `Int.toNat_coe_nat`, states that for any natural number `n`, when `n` is cast to an integer and then converted to a natural number using the `Int.toNat` function, the resulting value is `n` itself. In other words, the process of casting a natural number to an integer and then converting it back to a natural number via `Int.toNat` is a no-op for all natural numbers.

For all natural numbers `n`, `Int.toNat (Int.of Nat n) = n`.


theorem Nat.bodd_succ : ∀ (n : ℕ), Nat.bodd (Nat.succ n) = !Nat.bodd n := by sorry

The theorem `Nat.bodd_succ` states that for every natural number `n`, the boolean value indicating whether or not the successor of `n` (i.e., `n+1`) is odd is the negation of the boolean value indicating whether `n` is odd. In other words, if `n` is odd, then `n+1` is not, and vice versa.

For every natural number `n`, the oddness of `n` and `n+1` are opposite.


theorem EuclideanDomain.mul_div_cancel_left :
    ∀ {R : Type u} [inst : EuclideanDomain R] {a : R} (b : R), a ≠ 0 → a * b / a = b := by sorry

This theorem states that for any type `R` that has an instance of the `EuclideanDomain` structure, given any two elements `a` and `b` of `R`, if `a` is not zero, then the result of multiplying `a` and `b` and then dividing it by `a` is equal to `b`. This is essentially a formalization of the property from algebra that if you multiply a number by another number and then divide by the original number (which is not zero), you get back the second number.

For any EuclideanDomain `R`, `a ≠ 0` in `R` implies `(a * b) / a = b`.


theorem Multiset.prod_add :
    ∀ {α : Type u_2} [inst : CommMonoid α] (s t : Multiset α),
      Multiset.prod (s + t) = Multiset.prod s * Multiset.prod t :=
  by sorry

The theorem `Multiset.prod_add` states that for any given type `α` that has a Commutative Monoid structure, the product of the multiset addition (concatenation) of two multisets `s` and `t` is equal to the product of the individual multisets `s` and `t`. Specifically, if we have two multisets `s` and `t`, the product of the multiset `s + t` (which represents the multiset formed by adding `t` to `s`) is the same as the product of the multiset `s` multiplied by the product of the multiset `t`. This is analogous to the distributive property in algebra where the multiplication of a sum is equal to the sum of the products.

For any commutative monoid type `α`, the product of the multiset formed by adding two multisets `s` and `t` equals the product of `s` and the product of `t`.


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

The theorem `Asymptotics.IsBigO.of_bound` states that for every function `f` from a type `α` to a normed space `E`, and every function `g` from `α` to another normed space `F`, if for almost all `x` in a certain filter `l`, the norm of `f(x)` is less than or equal to a real constant `c` times the norm of `g(x)`, then `f` is Big O of `g` at this filter. In other words, `f` grows no faster than `g` up to a constant factor, for values `x` from the filter `l`. This is a formal, rigorous way to describe asymptotic upper bounds in the language of mathematical analysis.

If for almost all x in a filter l, the norm of f(x) is bounded above by a constant c times the norm of g(x), then f is Big O of g at filter l.


theorem Finset.prod_pos :
    ∀ {ι : Type u_1} {R : Type u_8} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [inst_2 : ZeroLEOneClass R]
      [inst_3 : PosMulStrictMono R] [inst_4 : Nontrivial R] {f : ι → R} {s : Finset ι},
      (∀ i ∈ s, 0 < f i) → 0 < Finset.prod s fun i => f i :=
  by sorry

The theorem `Finset.prod_pos` states that for any type `ι` and any type `R` such that `R` forms a commutative monoid with zero, has a partial order, satisfies the zero less than or equal to one class property, has a strict monotonicity of multiplication by positive elements on the left, and is nontrivial, if you have a function `f` from `ι` to `R` and a finite set `s` of type `ι`, then if all elements `i` in `s` have the property that `f(i)` is greater than zero, the product of `f(i)` over all `i` in `s` is also greater than zero. In other words, the positive product of positive elements in a finite set is also positive.

For any commutative monoid with zero, partial order, zero less than or equal to one property, strict monotonicity of multiplication by positive elements on the left, and nontriviality, if `f : ι -> R` maps a finite set `s ⊆ ι` to positive elements, then `∏ (i ∈ s) f(i) > 0`.


Decidable.em

theorem Decidable.em : ∀ (p : Prop) [inst : Decidable p], p ∨ ¬p := by sorry

This theorem, `Decidable.em`, states that for any proposition `p`, given that `p` is decidable (i.e., we can definitively assert whether `p` is true or false), then either `p` is true or `p` is not true. In mathematical terms, this is an instantiation of the law of excluded middle, which asserts that for any proposition, either that proposition or its negation must be true.

If a proposition `p` is decidable, then `p` or its negation `~p` is true.


theorem Polynomial.C_eq_zero : ∀ {R : Type u} {a : R} [inst : Semiring R], Polynomial.C a = 0 ↔ a = 0 := by sorry

The theorem `Polynomial.C_eq_zero` states that for any type `R` and any element `a` of `R`, where `R` is a semiring, the constant polynomial `a` (represented as `Polynomial.C a`) is equal to the zero polynomial if and only if `a` is zero. In other words, a constant polynomial is zero if and only if its coefficient is zero.

For any semiring R and its element a, the constant polynomial C a equals the zero polynomial if and only if a is the additive identity of R.


theorem DFinsupp.mem_support_iff :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : Π₀ (i : ι), β i} {i : ι},
      i ∈ DFinsupp.support f ↔ f i ≠ 0 :=
  by sorry

The theorem `DFinsupp.mem_support_iff` states that for any types `ι` and `β` where `β` is a function of `ι`, given `ι` has decidable equality, `β i` has a zero element, and whether `β i` is not equal to zero is decidable, for any function `f` from `ι` to `β i` and any element `i` of type `ι`, `i` is in the support of `f` if and only if `f i` is not equal to zero. In other words, the element `i` is in the support set of `f` (which consists of all indices `i` such that `f i` is not zero) if and only if the function `f` at index `i` does not evaluate to zero.

For functions from a type `ι` to a type `β` where `β` has a zero element and equality is decidable, an element `i` of `ι` is in the support of the function if and only if the function value at `i` is non-zero.


theorem List.map_ofFn :
    ∀ {α : Type u} {β : Type u_1} {n : ℕ} (f : Fin n → α) (g : α → β), List.map g (List.ofFn f) = List.ofFn (g ∘ f) :=
  by sorry

This theorem states that for any types `α` and `β`, any natural number `n`, any function `f` from `Fin n` to `α`, and any function `g` from `α` to `β`, the result of mapping `g` over the list produced by applying `f` to each element in the finite sequence from 0 to `n - 1` (expressed as `List.ofFn f`) is the same as the list produced by applying the composition of `g` and `f` to each element in the same finite sequence (expressed as `List.ofFn (g ∘ f)`). In other words, mapping a function over the list obtained by applying a function to a sequence is the same as applying the composition of the two functions to the sequence.

For any types `α` and `β`, any function `f : Fin n → α`, and any function `g : α → β`, `List.ofFn (g ∘ f) = List.map g (List.ofFn f)`.


theorem Nat.coprime_comm : ∀ {n m : ℕ}, Nat.Coprime n m ↔ Nat.Coprime m n := by sorry

The theorem `Nat.coprime_comm` states that for all natural numbers `n` and `m`, the property of `n` and `m` being coprime (or relatively prime), which is defined as their greatest common divisor (gcd) being 1, is commutative. In other words, `n` and `m` are coprime if and only if `m` and `n` are coprime. Thus, the order in which the numbers are considered does not affect whether or not they are coprime.

The theorem `Nat.coprime_comm` asserts that for all natural numbers `n` and `m`, `n` and `m` are coprime if and only if `m` and `n` are coprime.


theorem MulChar.map_nonunit :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (χ : MulChar R R') {a : R},
      ¬IsUnit a → χ a = 0 :=
  by sorry

The theorem `MulChar.map_nonunit` states that for any two types `R` and `R'` which are Commutative Monoids, and `R'` further has an operation `zero`, if `χ` is a mapping (referred to as `MulChar`) from `R` to `R'`, then for any element `a` of `R` that is not a unit (i.e., does not have a two-sided inverse in `R`), the mapping `χ` will map `a` to `0` in `R'`.

If `χ: R → R'` is a mapping between commutative monoids `R` and `R'` with identity `zero` in `R'`, and `a` is a non-unit in `R`, then `χ(a) = 0`.


theorem SetTheory.PGame.turnBound_ne_zero_of_left_move :
    ∀ {S : Type u} [inst : SetTheory.PGame.State S] {s t : S},
      t ∈ SetTheory.PGame.State.l s → SetTheory.PGame.State.turnBound s ≠ 0 :=
  by sorry

The theorem `SetTheory.PGame.turnBound_ne_zero_of_left_move` states that for any type `S` equipped with a structure of a game state (`SetTheory.PGame.State S`), given any two states `s` and `t` of type `S`, if `t` is a possible left move from `s` (i.e., `t` is in the set of left moves from `s`, denoted by `SetTheory.PGame.State.l s`), then the turn bound of the state `s`, given by `SetTheory.PGame.State.turnBound s`, cannot be zero. In other words, if a game state has a valid left move, then its turn bound must be non-zero.

If `s` is a game state with a non-empty set of left moves `l s`, then the turn bound of `s` is non-zero.


theorem Set.biInter_eq_iInter :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : (x : α) → x ∈ s → Set β),
      ⋂ x, ⋂ (h : x ∈ s), t x h = ⋂ x, t ↑x ⋯ :=
  by sorry

This theorem states that for any two types `α` and `β`, a set `s` of type `α`, and a function `t` defined for elements `x` of `α` that belong to `s` and returning a set of `β`, the intersection over `x` of the intersections (for `x` in `s`) of `t x` is equal to the intersection over `x` of `t ↑x`. Essentially, this theorem shows that for the given conditions, the order of intersections does not matter.

For any sets `s` of type `α`, and a function `t : α → Set β` such that `x ∈ s` implies `x ∈ domain(t)`, the intersection of `{∥ ti x∥ | x ∈ s}` is equal to the intersection of `{∥ t (i x)∥ | x ∈ s}`, where `i : α → α` is the identity function.


IsLowerSet.toDual

/-- **Alias** of the reverse direction of `isUpperSet_preimage_ofDual_iff`. -/
theorem IsLowerSet.toDual :
    ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet (⇑OrderDual.ofDual ⁻¹' s) := by sorry

The theorem `IsLowerSet.toDual` states that for any type `α` with a less-than-or-equal-to order `LE α` and any set `s` of type `α`, if `s` is a lower set (i.e., a set for which any element less than one of its members is also a member), then the preimage of `s` under the identity function of the dual order is an upper set (i.e., a set for which any element greater than one of its members is also a member). This theorem is essentially a rephrasing of the reverse direction of the theorem `isUpperSet_preimage_ofDual_iff`.

If `s` is a lower set in a type `α` with order `LE α`, then the preimage of `s` under the identity function of the dual order is an upper set.


theorem Complex.cos_add :
    ∀ (x y : ℂ), Complex.cos (x + y) = Complex.cos x * Complex.cos y - Complex.sin x * Complex.sin y := by sorry

This theorem, `Complex.cos_add`, states that for any two complex numbers `x` and `y`, the cosine of the sum of `x` and `y` is equal to the product of the cosine of `x` and the cosine of `y` minus the product of the sine of `x` and the sine of `y`. This is the complex version of the standard trigonometric identity for the cosine of a sum, $\cos(x+y) = \cos(x)\cos(y) - \sin(x)\sin(y)$.

The cosine of the sum of two complex numbers is equal to the product of their cosines minus the product of their sines.


theorem Set.biInter_range :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → α} {g : α → Set β}, ⋂ x ∈ Set.range f, g x = ⋂ y, g (f y) :=
  by sorry

This theorem, `Set.biInter_range`, states that for any types `α`, `β`, and `ι`, and any function `f` from `ι` to `α`, and any function `g` from `α` to a set of `β`, the intersection over `x` in the range of `f` of the sets `g x` equals the intersection over all `y` of the sets `g` applied to `f y`. In other words, it says that when you iterate over all elements in the range of a function and apply another function to them to get a collection of sets, the intersection of these sets is the same as if you just directly applied the second function to each element and took the intersection.

For any types `α`, `β`, and `ι`, and functions `f : ι → α` and `g : α → Set β`, the sets `{x ∈ ι | g (f x) ∈ s}` and `{y ∈ Set.range f | g y ∈ s}` have equal intersections for any set `s : Set β`.


theorem Order.le_of_lt_succ :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, a < Order.succ b → a ≤ b := by sorry

This theorem states that for any type `α` equipped with a preorder and a successor function, and for any elements `a` and `b` of that type, if `a` is less than the successor of `b`, then `a` is less than or equal to `b`. In mathematical terms, given `a < succ(b)`, we can infer `a ≤ b`. The successor function here is defined with respect to the order, and if `b` is not a maximal element, `succ(b)` is the smallest element greater than `b`. If `b` is maximal, then `succ(b) = b`.

For any type with a preorder and a successor function, if `a` is strictly less than the successor of `b`, then `a` is less than or equal to `b`.


IsIntegral.map

theorem IsIntegral.map :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {B : Type u_5}
      {C : Type u_6} {F : Type u_7} [inst_3 : Ring B] [inst_4 : Ring C] [inst_5 : Algebra R B] [inst_6 : Algebra A B]
      [inst_7 : Algebra R C] [inst_8 : IsScalarTower R A B] [inst_9 : Algebra A C] [inst_10 : IsScalarTower R A C]
      {b : B} [inst_11 : FunLike F B C] [inst_12 : AlgHomClass F A B C] (f : F), IsIntegral R b → IsIntegral R (f b) :=
  by sorry

The theorem `IsIntegral.map` states that for any types `R`, `A`, `B`, `C`, and `F`, if `R` and `A` are commutative rings, `B` and `C` are rings, `R` and `A` are algebras over `B` and `C`, and there exists a scalar tower of `R`, `A`, `B` and another scalar tower of `R`, `A`, `C`. Moreover, if `B` and `C` have a function-like property `F` and there is an algebra homomorphism class `AlgHomClass` between `A`, `B`, `C` with a function `f` of type `F`, then if an element `b` of the algebra `B` over the commutative ring `R` is integral (that is, it is a root of some monic polynomial), then the result of applying the function `f` to `b`, `(f b)`, is also integral over `R`.

If `R` is a commutative ring, `B` and `C` are rings, `A` is an `R`-algebra over both `B` and `C`, `F` is a function-like property of `B` and `C`, `AlgHomClass` is an algebra homomorphism class between `A`, `B`, and `C`, `f` is a homomorphism of type `F`, and `b` is an integral element of `B` over `R`, then `(f b)` is integral over `R`.


theorem inv_lt_one : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 1 < a → a⁻¹ < 1 := by sorry

This theorem, `inv_lt_one`, states that for any instance of a linearly ordered semifield `α` and any element `a` of `α`, if `1` is less than `a`, then the inverse of `a` (`a⁻¹`) is less than `1`. Essentially, for any number greater than one in a certain ordered field, its reciprocal will be less than one.

For any linearly ordered semifield `α` and `a` in `α` with `1 < a`, it holds that `1 < a⁻¹`.


theorem ModelWithCorners.right_inv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {x : E},
      x ∈ Set.range ↑I → ↑I (↑(ModelWithCorners.symm I) x) = x :=
  by sorry

This theorem, `ModelWithCorners.right_inv`, states that for any nontrivially normed field `𝕜`, a normed add commutative group `E` which is also a normed space over `𝕜`, and a topological space `H`, given a model with corners `I` from `𝕜` to `E` to `H` and any element `x` from `E`, if `x` is in the range of `I`, then applying `I` to the inverse of `I` applied to `x` gives back `x`. In simpler terms, `I` and its inverse cancel each other out when `x` is in the range of `I`.

For any nontrivially normed field `𝕜`, normed add commutative group `E` over `𝕜`, and topological space `H`, if `I` is a model with corners from `𝕜` to `E` to `H` and `x` is in the range of `I`, then `I (I x) = x`.


theorem mul_right_injective₀ :
    ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : IsLeftCancelMulZero M₀] {a : M₀},
      a ≠ 0 → Function.Injective fun x => a * x :=
  by sorry

The theorem `mul_right_injective₀` states that for any type `M₀` that has a multiplication operation and zero and satisfies the property of left cancellation for multiplication with zero, if `a` is a non-zero element of `M₀`, then the function which maps each element `x` to the product of `a` and `x` is injective. In other words, if `a` times `x` equals `a` times `y`, then `x` must equal `y`.

If `M₀` is a type with multiplication and zero, and `a` is a non-zero element with left cancellation property, then the function `x ↦ a * x` is injective on `M₀`.


FilterBasis.hasBasis

theorem FilterBasis.hasBasis :
    ∀ {α : Type u_1} (B : FilterBasis α), Filter.HasBasis (FilterBasis.filter B) (fun s => s ∈ B) id := by sorry

This theorem states that for any type `α` and any filter basis `B` on that type, the filter associated with `B` has a basis. The basis is characterized by the property that a set is in the basis if and only if it belongs to `B`. The `id` function is the identity map, which implies that the elements of the basis are directly the sets in `B`. In other words, the filter generated by a filter basis `B` has `B` itself as a basis.

For any type `α` and filter basis `B` on `α`, the filter generated by `B` is equal to the filter having `B` as its basis.


theorem ENNReal.rpow_le_rpow : ∀ {x y : ENNReal} {z : ℝ}, x ≤ y → 0 ≤ z → x ^ z ≤ y ^ z := by sorry

This theorem states that for any two extended nonnegative real numbers `x` and `y`, and any real number `z` such that `z` is nonnegative and `x` is less than or equal to `y`, the exponentiation of `x` to the power `z` is less than or equal to the exponentiation of `y` to the power `z`. In mathematical notation, this would be: for all $x, y \in [0, \infty]$ and $z \in \mathbb{R}$ such that $x \leq y$ and $0 \leq z$, we have $x^z \leq y^z$.

For all $x, y \in [0, \infty]$ and $z \in \mathbb{R}$ with $x \leq y$ and $0 \leq z$, we have $x^z \leq y^z$.


theorem CategoryTheory.Functor.congr_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} {f g : X ⟶ Y},
      f = g → F.map f = F.map g :=
  by sorry

This theorem states that given two categories `C` and `D`, and a functor `F` between them, if two morphisms `f` and `g` in category `C` from object `X` to `Y` are equal, then their image under the functor `F` are also equal. In other words, this theorem ensures that functors preserve the equality of morphisms in a category.

Given any functor F between categories C and D, if two morphisms f and g in C from object X to Y have the same source and target, then F(f) = F(g).


/-- This is just a special case of the global `smul_mul_assoc` lemma that requires less typeclass
search (and was here first).  -/
theorem Algebra.smul_mul_assoc :
    ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x y : A),
      r • x * y = r • (x * y) :=
  by sorry

This theorem, `Algebra.smul_mul_assoc`, states that for any commutative semiring `R`, semiring `A`, and an algebra structure over them, the scalar multiplication and multiplication operations are associative. In other words, given an element `r` from `R` and elements `x` and `y` from `A`, multiplying `r`-scaled `x` with `y` is the same as scaling the multiplication of `x` and `y` by `r`. Mathematically, this can be represented as `r*(x*y) = (r*x)*y`. This is a special case of a more general property, `smul_mul_assoc`, and requires less typeclass search.

For any commutative semiring `R`, semiring `A`, and algebra structure over them, the scalar multiplication and multiplication operations are associative, i.e., `r*(x * y) = (r * x) * y` for all `r` in `R` and elements `x` and `y` in `A`.


/-- An additive subgroup `K` includes `closure k` if and only if it includes `k` -/
theorem AddSubgroup.closure_le :
    ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) {k : Set G}, AddSubgroup.closure k ≤ K ↔ k ⊆ ↑K := by sorry

The theorem `AddSubgroup.closure_le` states that for any type `G` that forms an additive group, and for any additive subgroup `K` of `G` and a set `k` of elements in `G`, the closure of the set `k` with respect to the additive subgroup operation is contained within `K` if and only if the set `k` itself is contained in `K`. Here, the closure of a set `k` refers to the smallest additive subgroup that contains `k`, and `k ⊆ ↑K` represents the containment of the set `k` in the subgroup `K`.

For any additive group G, subgroup K, and set k of elements in G, the closure of k in K equals k if and only if k is contained in K.


theorem Set.compl_iInter : ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β), (⋂ i, s i)ᶜ = ⋃ i, (s i)ᶜ := by sorry

The theorem `Set.compl_iInter` states that for all types `β` and any index type `ι`, given a function `s` from `ι` to the set of `β`, the complement of the intersection over `ι` of the sets `s i` is equal to the union of the complements of the sets `s i`. This is an application of De Morgan's laws to sets. In mathematical terms, this can be written as $(\bigcap_{i \in I} s_i)^c = \bigcup_{i \in I} (s_i)^c$, where `I` is an index set, `s_i` is a set for each `i` in `I`, and `^c` denotes the complement of a set.

The complement of the intersection of a family of sets indexed by an index type is equal to the union of the complements of the sets in the family. (In mathematical notation: (⋂i∈I si)c = ⋃i∈I sc, where I is an index set, si is a set for each i in I, and ^c denotes the complement of a set.)


theorem csInf_mem :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {s : Set α}
      [inst_1 : IsWellOrder α fun x x_1 => x < x_1], Set.Nonempty s → sInf s ∈ s :=
  by sorry

The theorem `csInf_mem` states that for any type `α` that has a conditionally complete linear order, and for any set `s` of `α` that is well-ordered by the `<` relation, if the set `s` is nonempty, then the greatest lower bound of the set (`sInf s`) is an element of the set `s`.

If `α` is a type with a conditionally complete linear order and `s ≠∅` is a well-ordered subset of `α` with respect to `<`, then `sInf s ∈ s`.


theorem Set.pi_univ_Icc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x y : (i : ι) → α i),
      (Set.pi Set.univ fun i => Set.Icc (x i) (y i)) = Set.Icc x y :=
  by sorry

This theorem states that for any type `ι`, any function `α` from `ι` to some type, and any two functions `x` and `y` from `ι` to the type determined by `α`, the set of all functions from `ι` to `α` such that for each `i` in `ι`, the function value is in the closed interval from `x(i)` to `y(i)`, is exactly the set of all functions from `ι` to `α` that lie in the closed interval from `x` to `y`. This is essentially stating that the product of intervals is an interval, generalised to an arbitrary index set `ι` and arbitrary preorders on each coordinate.

For any type `ι` and preorders on `ι` and a type `α`, the set of functions from `ι` to `α` with values in the closed interval between `x(i)` and `y(i)` for all `i` equals the set of functions from `ι` to `α` with values in the closed interval between `x` and `y`.


theorem MeasureTheory.Measure.MutuallySingular.zero_left :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular 0 μ :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.zero_left` states that for any type `α` equipped with a measurable space structure `m0` and any measure `μ` on that type, the zero measure and the measure `μ` are mutually singular. In the context of measure theory, this means that there exists a measurable set `s` such that the zero measure of `s` is 0 (which is always true for the zero measure) and the measure `μ` of the complement of `s` is also 0.

For any measurable space `(α, m0)` and measure `μ` on `α`, the zero measure and `μ` are mutually singular, i.e., there exists a measurable set `s` with `μ(s^c) = 0` and `m0(s) = 0`.


theorem ProbabilityTheory.isMeasurableRatCDF_toRatCDF :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ},
      Measurable f → ProbabilityTheory.IsMeasurableRatCDF (ProbabilityTheory.toRatCDF f) :=
  by sorry

The theorem `ProbabilityTheory.isMeasurableRatCDF_toRatCDF` states that for any measurable space `α` and any function `f` from `α` to the set of real-valued functions on rational numbers, if `f` is measurable, then the function obtained by transforming `f` using the `ProbabilityTheory.toRatCDF` function, which replaces `f(a)` by a default function if `f(a)` does not satisfy the property `IsRatStieltjesPoint`, is also measurable in the sense of the `ProbabilityTheory.IsMeasurableRatCDF` definition.

If `f` is a measurable real-valued function on a measurable space, then the function obtained by applying `ProbabilityTheory.toRatCDF` to `f` is also measurable as a real-valued function on rational numbers according to the `ProbabilityTheory.IsMeasurableRatCDF` definition.


theorem Int.ofNat_dvd : ∀ {m n : ℕ}, ↑m ∣ ↑n ↔ m ∣ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, `m` divides `n` if and only if the integer representation of `m` divides the integer representation of `n`. Here, `↑m` and `↑n` denote the integer representations of the natural numbers `m` and `n`, respectively. The `∀` symbol denotes universality, meaning that the statement holds for all instances of `m` and `n`. The `∣` symbol represents the divides relation.

For any natural numbers m and n, m divides n if and only if their respective integer representations have the relation that one is a multiple of the other.


theorem countable_sInter_mem :
    ∀ {α : Type u_2} {l : Filter α} [inst : CountableInterFilter l] {S : Set (Set α)},
      Set.Countable S → (⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l) :=
  by sorry

The theorem `countable_sInter_mem` states that for any type `α`, any filter `l` on `α` that supports countable intersection, and any countable set `S` of sets of type `α`, the intersection of all sets in `S` belongs to the filter `l` if and only if every set `s` in `S` belongs to the filter `l`. In other words, for a given type, a filter, and a countable collection of sets, the intersection of the collection is in the filter precisely when every individual set in the collection is in the filter.

For any filter `l` on a type `α` that supports countable intersections and any countable set `S` of subsets of `α`, if every `s` in `S` belongs to `l`, then their intersection belongs to `l`.


theorem Set.image2_subset_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t t' : Set β},
      t ⊆ t' → Set.image2 f s t ⊆ Set.image2 f s t' :=
  by sorry

The theorem `Set.image2_subset_left` states that for any types `α`, `β`, and `γ`, and any function `f` from `α` and `β` to `γ`, if we have two sets `t` and `t'` of `β` such that `t` is a subset of `t'`, then the image of the binary function `f` when applied to any set `s` of `α` and the set `t` is also a subset of the image of the binary function `f` when applied to the same set `s` of `α` and the set `t'`. In other words, if we expand the set of second arguments to the function `f`, the set of output values will also expand accordingly.

For any functions $f : \alpha \rightarrow \gamma$ and $s : \subset \alpha$, $t \subseteq t' \subseteq \beta$ imply $f(s \times t) \subseteq f(s \times t')$.


theorem ciInf_le_of_le :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α},
      BddBelow (Set.range f) → ∀ (c : ι), f c ≤ a → iInf f ≤ a :=
  by sorry

The theorem `ciInf_le_of_le` states that for any type `α` which is a conditionally complete lattice, given a function `f` that maps from an arbitrary type `ι` to `α`, if the range of the function `f` is bounded below, then for any element `c` from `ι`, if `f(c)` is less than or equal to some element `a` in `α`, it follows that the infimum of the range of `f` is less than or equal to `a`. In essence, if a function's range has a lower bound and any element in the range is less than or equal to a certain value, the infimum of the function's range also falls below or at that value.

If `f : ι → α` is a function with domain `ι` and range in a conditionally complete lattice `α`, and `∃ a ∈ α. ∀ i ∈ ι. f i ≤ a`, then `∧ x ∈ range(f) x ≤ a` implies `∧ y ∈ α. inf(range(f)) ≤ y` whenever `inf(range(f))` is defined.


theorem Set.Nonempty.of_image2_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
      Set.Nonempty (Set.image2 f s t) → Set.Nonempty s :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and any binary function `f` from `α` and `β` to `γ`, if the image of `f` over sets `s` (of type `α`) and `t` (of type `β`) is not empty (i.e., there exists at least one element in `γ` that is the result of applying `f` to an element from `s` and an element from `t`), then set `s` itself must not be empty. In other words, if you can obtain at least one value by applying the function `f` to elements from sets `s` and `t`, then there must be at least one element in set `s`.

If the image of a binary function from types `α` and `β` to `γ` is non-empty over sets `s` (of type `α`) and `t` (of type `β`), then `s` is non-empty.


theorem mul_invOf_self' : ∀ {α : Type u} [inst : Mul α] [inst_1 : One α] (a : α) {x : Invertible a}, a * ⅟a = 1 := by
  sorry

This theorem, named `mul_invOf_self'`, states that for any type `α` with multiplication and a multiplicative identity (`one`), for any instance `a` of this type that is invertible, the product of `a` and the multiplicative inverse of `a` (`⅟a`) is equal to the multiplicative identity (`1`). In mathematical terms, this can be written as `a * ⅟a = 1`. This is a common property in fields, such as the field of real numbers (`ℝ`).

For any type `α` with multiplication and a multiplicative identity `one`, if `a : α` is invertible, then `a * a⁻¹ = one`.


QuotientAddGroup.eq

theorem QuotientAddGroup.eq :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {a b : α}, ↑a = ↑b ↔ -a + b ∈ s := by sorry

This theorem states that for all types `α` of an additive group, given an additive subgroup `s` of `α` and any two elements `a` and `b` of `α`, the equivalence class of `a` is equal to the equivalence class of `b` if and only if the additive inverse of `a` plus `b` belongs to the subgroup `s`. In mathematical notation, this theorem says that for all `a, b` in `α` and a subgroup `s`, `a ~ b` in the quotient group iff `-a + b ∈ s`.

For all types `α` of an additive group, two elements `a` and `b` belong to the same equivalence class in the quotient group if and only if the additive inverse of `a` plus `b` is in the subgroup.


Filter.Tendsto.cauchySeq

theorem Filter.Tendsto.cauchySeq :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : SemilatticeSup β] [inst_1 : Nonempty β]
      {f : β → α} {x : α}, Filter.Tendsto f Filter.atTop (nhds x) → CauchySeq f :=
  by sorry

The theorem `Filter.Tendsto.cauchySeq` states that for any types `α` and `β`, given a uniform space on `α`, a semilattice structure on `β`, and assuming that `β` is nonempty, if we have a function `f` from `β` to `α` and an element `x` of `α`, then if `f` tends to `x` at the limit `∞` (meaning that the image of `f` approaches `x` when the argument of `f` goes to infinity), it implies that `f` is a Cauchy sequence. In other words, when the values of `f` get arbitrarily close to `x` as we take larger and larger values from `β`, then `f` is considered a Cauchy sequence, i.e., the elements of the sequence become arbitrarily close to each other as we progress further into the sequence.

If a function from a semilattice to a uniform space tends to a limit as its argument approaches infinity, then it is a Cauchy sequence.


theorem Mathlib.Data.Sym.Sym2._auxLemma.2 :
    ∀ {α : Type u_1} {p p' : α × α}, (Sym2.mk p = Sym2.mk p') = Sym2.Rel α p p' := by sorry

This theorem states that for any type `α` and any two pairs of elements `p` and `p'` of type `α`, the statement "the symmetric product of `p` is equal to the symmetric product of `p'`" is equivalent to "the symmetric relation `Sym2.Rel` holds between `p` and `p'`". Here, `Sym2.mk` is a function that maps a pair of elements to their symmetric product, and `Sym2.Rel` is a relation that describes when two pairs are considered "equivalent" in the context of symmetric products.

The theorem asserts that for any type `α`, the symmetric products of `p` and `p'` are equal if and only if `(p, p')` and `(p', p)` are related by `Sym2.Rel`.


theorem Cardinal.mk_out : ∀ (c : Cardinal.{u_1}), Cardinal.mk (Quotient.out c) = c := by sorry

The theorem `Cardinal.mk_out` asserts that for every cardinal number `c`, when we choose an element from the equivalence class of `c` using the noncomputable function `Quotient.out`, and then compute the cardinality of the resulting set, we get back the original cardinal number `c`. In other words, choosing an element from the equivalence class of a cardinal number does not change its cardinality. This theorem is a statement about the consistency of cardinal numbers under the operation of choosing an element from their equivalence classes.

For every cardinal number `c`, the cardinality of the set obtained by choosing an element from the equivalence class of `c` using `Quotient.out` function is equal to `c`.


CategoryTheory.Limits.hasLimitOfIso

/-- If a functor `F` has a limit, so does any naturally isomorphic functor.
 -/
theorem CategoryTheory.Limits.hasLimitOfIso :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F],
      (F ≅ G) → CategoryTheory.Limits.HasLimit G :=
  by sorry

This theorem states that in the context of category theory, if a functor `F` has a limit, then any functor `G` that is naturally isomorphic to `F` also has a limit. Here, `J` and `C` are the source and target categories, respectively, and the isomorphism between `F` and `G` is a natural isomorphism. So essentially, the limit property is preserved under natural isomorphism between functors.

If functors `F : J -> C` and `G : J -> C` are naturally isomorphic and `F` has a limit, then `G` also has a limit with the same limit cone.


/-- If one controls the norm of every `f x`, then one controls the norm of `f`.  -/
theorem ContinuousMultilinearMap.opNorm_le_bound :
    ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
      [inst_4 : SeminormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G] (f : ContinuousMultilinearMap 𝕜 E G) {M : ℝ},
      0 ≤ M → (∀ (m : (i : ι) → E i), ‖f m‖ ≤ M * Finset.prod Finset.univ fun i => ‖m i‖) → ‖f‖ ≤ M :=
  by sorry

This theorem states that in a nontrivially normed field with a continuous multilinear map, if the upper bound of the norm of every instance of the map is controlled (i.e., it is less than or equal to some non-negative real number `M` multiplied by the product of the norms of the elements in the finite universal set), then the norm of the map itself is also controlled and is less than or equal to `M`. In other words, if each individual component of a multilinear operation is bounded, then the operation as a whole is also bounded.

In a nontrivially normed field, if every instance of a continuous multilinear map has norm bounded by `M` times the product of the norms of its arguments, then the norm of the map is also bounded by `M`.


theorem Finset.prod_eq_one :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] {f : α → β} {s : Finset α},
      (∀ x ∈ s, f x = 1) → (Finset.prod s fun x => f x) = 1 :=
  by sorry

This theorem states that for any type `α` and any commutative monoid `β`, given a function `f` from `α` to `β` and a finite set `s` of type `α`, if all the elements in `s` when mapped by `f` equals to the identity element of `β` (which is `1` for a commutative monoid), then the product of all these mapped elements (denoted as `Finset.prod s f`) is also equal to the identity element of `β`. In other words, the product over a finite set of all `1`'s in a commutative monoid is `1`.

For any commutative monoid `β` and finite set `s` of a type `α`, if for all `x ∈ s`, `f(x) = 1_β`, then `Finset.prod s f = 1_β`.


theorem Complex.sin_neg : ∀ (x : ℂ), Complex.sin (-x) = -Complex.sin x := by sorry

This theorem states that the complex sine function has odd symmetry. Specifically, for any complex number `x`, the sine of negative `x` is equal to the negative of the sine of `x`. In mathematical notation, this would be expressed as sin(-x) = -sin(x) for all complex numbers `x`.

The sine function is odd, that is, sin(-x) = -sin(x) for all complex numbers x.


theorem MeasureTheory.map_add_left_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Add G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsAddLeftInvariant μ] (g : G), MeasureTheory.Measure.map (fun x => g + x) μ = μ :=
  by sorry

The theorem `MeasureTheory.map_add_left_eq_self` says that for any type `G` equipped with a measurable space structure and an addition operation, given a measure `μ` on `G` that is left-invariant under addition, and any element `g` of `G`, the pushforward of the measure `μ` under the map `x ↦ g + x` is equal to the original measure `μ`. In other words, adding a fixed element on the left to every point in `G` does not change the measure `μ`, reflecting the left-invariance of the measure.

For any measurable space `(G, Σ)` with addition operation `+` and left-invariant measure `μ`, we have `μ ∘ (λ x, g + x) = μ`.