/-- **Alias** of `Int.natCast_nonneg`. -/
theorem Int.coe_nat_nonneg : ∀ (n : ℕ), 0 ≤ ↑n := by sorry

This theorem, "Int.coe_nat_nonneg", is an alias of "Int.natCast_nonneg". The theorem states that for any natural number 'n', the integer representation of 'n' is always nonnegative, i.e., greater than or equal to zero. In other words, when you cast a natural number to an integer in Lean, the resulting integer is always nonnegative.

For any natural number n, the integer representation of n is nonnegative. In Lean, this is expressed as the theorem Int.coe_nat_nonneg (or Int.natCast_nonneg) stating that the coercion from nat to int is non-negative.


Setoid.ext'

theorem Setoid.ext' : ∀ {α : Type u_1} {r s : Setoid α}, (∀ (a b : α), Setoid.Rel r a b ↔ Setoid.Rel s a b) → r = s :=
  by sorry

The theorem `Setoid.ext'` states that for any type `α` and any two Setoids `r` and `s` over that type, if the relation defined by `r` between any two elements of type `α` is equivalent to the relation defined by `s` between the same two elements, then the Setoids `r` and `s` are the same. Here, `Setoid.Rel r a b` represents the relation `r` between elements `a` and `b` of type `α`, and equivalence of relations is defined as logical equivalence (i.e., `r` and `s` are equivalent if for any `a` and `b`, `r` holds between `a` and `b` if and only if `s` holds between `a` and `b`).

If for all `α` and elements `a, b` of type `α`, the relations `r` and `s` defined on `α` hold between `a` and `b` equivalently, then `r` and `s` are equal as Setoids over `α`.


AddHom.ext

theorem AddHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] ⦃f g : AddHom M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any two additive homomorphisms `f` and `g` from a type `M` with addition to a type `N` with addition, if for every element of type `M`, `f` and `g` have the same result, then `f` and `g` are the same homomorphism. In essence, it provides a criterion for the equality of two additive homomorphisms based on their actions on the elements of the domain.

If two additive homomorphisms from a commutative additive group `M` to a commutative additive group `N` agree on every element of `M`, then they are equal.


/-- **Alias** of the reverse direction of `Finset.card_pos`. -/
theorem Finset.Nonempty.card_pos : ∀ {α : Type u_1} {s : Finset α}, s.Nonempty → 0 < s.card := by sorry

This theorem is an alias of the reverse direction of the `Finset.card_pos` theorem. It states that for any type `α` and a finite set `s` of `α`, if the set `s` is non-empty (`s.Nonempty`), then the cardinality of the set `s` (`s.card`) is greater than zero. In mathematical terms, if a set has at least one element, its size or cardinality is positive.

If `s` is a finite, non-empty set, then `s.card` is a positive natural number.


theorem Valuation.map_one :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀),
      v 1 = 1 :=
  by sorry

This theorem, named `Valuation.map_one`, states that for any ring `R` of some type `u_3` and any linearly ordered commutative monoid with zero `Γ₀` of some type `u_4`, any valuation `v` of `R` into `Γ₀` will map the multiplicative identity `1` in `R` to the multiplicative identity `1` in `Γ₀`. In other words, it asserts the preservation of the multiplicative identity under the valuation map for these mathematical structures.

For any valuation `v` from a ring `R` to a linearly ordered commutative monoid with zero `Γ₀`, `v(1) = 1` holds in `Γ₀`, where `1` refers to the multiplicative identities in `R` and `Γ₀`, respectively.


theorem IsCompact.image_of_continuousOn :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      IsCompact s → ContinuousOn f s → IsCompact (f '' s) :=
  by sorry

The theorem `IsCompact.image_of_continuousOn` states that for any topological spaces `X` and `Y`, a set `s` in `X`, and a function `f` from `X` to `Y`, if the set `s` is compact and the function `f` is continuous on the set `s`, then the image of the set `s` under the function `f` (denoted by `f '' s`) is also compact. In mathematical terms, this can be written as: if a function is continuous on a compact set, then the image of that set under the function is also compact.

If a compact set is mapped by a continuous function, the image is also a compact set.


theorem Polynomial.degree_C :
    ∀ {R : Type u} {a : R} [inst : Semiring R], a ≠ 0 → Polynomial.degree (Polynomial.C a) = 0 := by sorry

The theorem `Polynomial.degree_C` states that for any type `R` and element `a` of that type, as long as `R` is a semiring and `a` is not zero, the degree of the constant polynomial `C a` is 0. In other words, when we have a polynomial that is simply a constant (non-zero) value, the highest power of `X` that appears in the polynomial is 0, as there are no `X` terms in the polynomial.

For any semiring `R` and non-zero element `a` in `R`, the degree of the constant polynomial `C a` is 0.


theorem sign_pos :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableRel fun x x_1 => x < x_1] {a : α},
      0 < a → SignType.sign a = 1 :=
  by sorry

This theorem, named `sign_pos`, states that for any type `α` that has a zero, a preorder (a binary relation that is reflexive and transitive), and a decidable relation for less than, if a certain element `a` of type `α` is greater than zero, then the sign of `a` is 1. The sign is determined by the `SignType.sign` function, which assigns 1 if the element is positive, -1 if it is negative, and 0 otherwise.

If `α` is a type with a zero, a preorder, and decidable less-than relation, then for any `a` of type `α` with `a > 0`, `SignType.sign a = 1`.


theorem Mathlib.Order.Filter.Basic._auxLemma.78 : ∀ {α : Type u} {p : α → Prop}, (∀ᶠ (x : α) in ⊥, p x) = True := by
  sorry

This theorem, `Mathlib.Order.Filter.Basic._auxLemma.78`, states that for any type 'α' and any predicate 'p' defined on 'α', the assertion that the predicate 'p' holds for all elements 'x' of type 'α' in the bottom filter (denoted by ⊥) is always true. The bottom filter (⊥) in this context is the smallest filter, which contains no elements, hence every statement about its elements is vacuously true.

For any type 'α' and predicate 'p' on 'α', the statement 'p' holds for all elements in the bottom filter (⊥) is vacuously true.


theorem add_top : ∀ {α : Type u_1} [inst : LinearOrderedAddCommMonoidWithTop α] (a : α), a + ⊤ = ⊤ := by sorry

This theorem states that for any type `α` that has a structure of a `LinearOrderedAddCommMonoidWithTop`, the sum of any element `a` of type `α` and the top element `⊤` is always `⊤`. In other words, adding anything to the maximum possible value in this ordered, add-commutative monoid still results in the maximum possible value.

For any type `α` with a `LinearOrderedAddCommMonoidWithTop` structure, `a + ⊤ = ⊤` for all elements `a` of type `α`.


Measurable.snd

theorem Measurable.snd :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {mγ : MeasurableSpace γ} {f : α → β × γ}, Measurable f → Measurable fun a => (f a).2 :=
  by sorry

The theorem `Measurable.snd` states that for any types `α`, `β`, and `γ`, and measurable spaces `m` over `α`, `mβ` over `β`, and `mγ` over `γ`, if we have a measurable function `f` mapping from `α` to a pair of elements in `β` and `γ`, then the function that takes an element from `α` and returns the second component from the pair produced by `f` is also measurable. In other words, if `f` is a measurable function, then the function that gets the second component (`.2`) of `f(a)` for any `a` in `α` is also measurable.

Given measurable spaces `m` over `α`, `mβ` over `β`, and `mγ` over `γ`, if `f` is a measurable function from `α` to the product `β × γ`, then the projection function to the second component `.2` is measurable.


theorem le_sub_iff_add_le' :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α}, b ≤ c - a ↔ a + b ≤ c :=
  by sorry

This theorem states that, for any type `α` that forms an additive commutative group and has a less than or equal to (`≤`) relation, which is covariant with respect to addition, if we are given three elements `a`, `b`, and `c` of this type, then `b` is less than or equal to `c - a` if and only if `a + b` is less than or equal to `c`. This theorem provides an equivalence between two ways of expressing a relation between `a`, `b`, and `c`, essentially stating that subtracting `a` from `c` before comparing to `b` is the same as adding `a` to `b` before comparing to `c`.

For any additive commutative group `α` with a covariant `≤` relation, `b ≤ c - a` if and only if `a + b ≤ c`.


theorem Nat.factorization_prod_pow_eq_self :
    ∀ {n : ℕ}, n ≠ 0 → (Finsupp.prod (Nat.factorization n) fun x x_1 => x ^ x_1) = n := by sorry

This theorem states that for any non-zero natural number `n`, the product of the powers of each prime factor of `n`, where each prime factor is raised to its multiplicity in `n`, equals `n` itself. In other words, it says that if you factorize `n` into its prime factors and raise each prime factor to the power of its multiplicity in the factorization of `n`, then the product of all these terms will give you `n` back. This is essentially the fundamental theorem of arithmetic which states that every integer greater than 1 either is prime itself or is the product of prime numbers, and this product is unique, up to the order of the factors.

For any natural number `n` > 1, `n` is the product of its prime factors raised to the powers equal to their multiplicities in `n`'s prime factorization.


theorem MeasurableEmbedding.integral_map :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {β : Type u_7} {x : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f → ∀ (g : β → G), ∫ (y : β), g y ∂MeasureTheory.Measure.map f μ = ∫ (x : α), g (f x) ∂μ :=
  by sorry

The theorem `MeasurableEmbedding.integral_map` states that for any types `α`, `G`, and `β`, where `G` is a normed additive commutative group and also a normed space over real numbers, and `α` and `β` are associated with measurable spaces, given a measure `μ` over the measurable space `α`, a measurable embedding function `f` from `α` to `β`, and a function `g` from `β` to `G`, the integral of `g` with respect to the measure induced by `f` and `μ` on `β` is equal to the integral of the composition of `g` and `f` with respect to the measure `μ` on `α`. Here, integration is defined in the sense of measure theory.

For measurable spaces `α`, `β`, a normed additive commutative group and normed space `G` over real numbers, measure `μ` on `α`, measurable embedding function `f: α → β`, and function `g: β → G`, the integral of `g` with respect to the measure induced by `f` and `μ` on `β` equals the integral of `g ∘ f` with respect to `μ` on `α`.


theorem div_eq_mul_one_div : ∀ {G : Type u_3} [inst : DivInvMonoid G] (a b : G), a / b = a * (1 / b) := by sorry

This theorem states that for any type 'G' which forms a 'DivInvMonoid' (a mathematical structure with division and inversion operations that follow certain rules), the division of any two elements 'a' and 'b' of type 'G' is equal to the multiplication of 'a' and the reciprocal of 'b'. In simpler terms, it's saying that 'a divided by b' is the same as 'a times one divided by b', which is a familiar property from basic arithmetic.

For any type 'G' forming a 'DivInvMonoid' and elements 'a' and 'b' in 'G', a / b = a * (inv b), where inv denotes the multiplicative inverse.


theorem mul_le_of_le_one_right :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : PosMulMono α],
      0 ≤ a → b ≤ 1 → a * b ≤ a :=
  by sorry

This theorem states that for a given type `α` that supports multiplication and has a special element called "one", has a zero element, and has a preorder relation (which gives us the concepts of "less than or equal to" and "greater than or equal to"), and is also a positive multiplicative monotonically ordered set (where multiplication by a nonnegative element does not change the order), if `a` is a nonnegative element of this type and `b` is an element of this type which is less than or equal to one, then the product `a * b` is less than or equal to `a`. This theorem is essentially stating that if you multiply a nonnegative number by a number that is less than or equal to one, the result will not exceed the original nonnegative number.

For any non-negative element `a` and element `b` less than or equal to one in a type with multiplication, a preorder relation, and positive multiplicative monotonicity, `a * b` is less than or equal to `a`.


theorem MeasureTheory.Measure.AbsolutelyContinuous.rfl :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.Measure.AbsolutelyContinuous μ μ :=
  by sorry

The theorem states that for any type `α` and any measurable space `m0` on `α`, any measure `μ` is absolutely continuous with respect to itself. In other words, for any given set `s` in the measurable space, if the measure of `s` according to `μ` is zero, then the measure of `s` according to `μ` is also zero, which is trivially true since we are considering the same measure `μ`.

For any measurable space `(α, m0)` and measure `μ` on `α`, the measure `μ` is absolutely continuous with respect to itself.


theorem Int.eq_succ_of_zero_lt : ∀ {a : ℤ}, 0 < a → ∃ n, a = ↑(Nat.succ n) := by sorry

This theorem declares that for any integer `a`, if `a` is greater than zero (0 < a), then there exists a natural number `n` such that `a` is equal to the successor of `n` (a = n + 1). In other words, any positive integer can be expressed as the successor of some natural number.

For any positive integer `a`, there exists a natural number `n` such that `a = n + 1`.


theorem one_div_pos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 < 1 / a ↔ 0 < a := by sorry

This theorem, named `one_div_pos`, states that for all types `α` that have a `LinearOrderedSemifield` structure, and for all elements `a` of type `α`, the reciprocal of `a` (1 / a) is greater than zero if and only if `a` itself is greater than zero. In mathematical terms, for any real or complex number `a`, 1/a > 0 if and only if a > 0.

For any type `α` with a `LinearOrderedSemifield` structure and any `a` in `α`, 1 / a > 0 if and only if a > 0.


theorem MeasureTheory.integrable_zero :
    ∀ (α : Type u_1) (β : Type u_2) {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : NormedAddCommGroup β],
      MeasureTheory.Integrable (fun x => 0) μ :=
  by sorry

The theorem `MeasureTheory.integrable_zero` states that for any measurable space `α`, any measure `μ` on that space, and any normed additive commutative group `β`, the zero function (i.e., the function that maps every element to zero) is integrable with respect to `μ`. In more mathematical language, it says that the function `f : α → β` defined by `f(x) = 0` for all `x ∈ α`, is integrable with respect to measure `μ`. This means it is both strongly measurable and has a finite integral.

The zero function is integrable with respect to any measure on any measurable space.


theorem Finset.mem_union_right :
    ∀ {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {a : α} (s : Finset α), a ∈ t → a ∈ s ∪ t := by sorry

The theorem `Finset.mem_union_right` asserts that for any type `α` which has decidable equality and for any element `a` of this type and any finite set `t` of this type, if `a` is an element of `t`, then `a` is also an element of the union of `t` and any other finite set `s` of this type. In mathematical terms, this is expressing that if $a \in t$, then $a \in s \cup t$ for all finite sets $s$, $t$ of a type `α` with decidable equality.

For any type `α` with decidable equality and any finite sets `t` and `s` of `α`, if `a` is an element of `t`, then `a` is an element of `s ∪ t`.


CovBy.wcovBy

theorem CovBy.wcovBy : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⋖ b → a ⩿ b := by sorry

This theorem, `CovBy.wcovBy`, states that for any type `α` that has a `Preorder` instance (i.e., for which a less-than-or-equal-to relation is defined), given any two elements `a` and `b` of type `α`, if `a` is strictly less than (`⋖`) `b`, then `a` is less than or equal to (`⩿`) `b`. Essentially, it's guaranteeing that the less-than-or-equal-to relation encompasses the strictly-less-than relation within any preordered set.

In any preordered set, if `a ⋖ b` holds, then `a ⩿ b` holds.


theorem CategoryTheory.NatIso.naturality_2 :
    ∀ {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} {X Y : C} (α : F ≅ G)
      (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (α.hom.app X) (CategoryTheory.CategoryStruct.comp (G.map f) (α.inv.app Y)) =
        F.map f :=
  by sorry

This theorem, `CategoryTheory.NatIso.naturality_2`, states that for any two categories `C` and `D`, and any two functors `F` and `G` from `C` to `D`, if there is a natural isomorphism `α` between `F` and `G`, and a morphism `f` from `X` to `Y` in `C`, then the composition of the application of the homomorphism part of `α` at `X` with the composition of the mapping of `f` through `G` and the application of the inverse of the homomorphism part of `α` at `Y` is equal to the mapping of `f` through `F`. In other words, it asserts the naturality condition for a natural transformation in the context of category theory.

 Given categories `C`, `D`, functors `F` and `G` with a natural isomorphism `α: F ≅ G`, and a morphism `f: X ⟹ Y` in `C`, the following diagram commutes:

```
F(X) �� /******/ ⏥ ┓
          ╱   α_X ╲
    G(X) ⏸───────────────┛
          ╵   α_Y ╮
   Y        G(f)    F(f)
```


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

This theorem states that for any three propositions `a`, `b`, and `c`, the equivalence of "a and b" with "a and c" is equivalent to the implication that if `a` is true, then `b` is equivalent to `c`. In other words, if we know `a` to be true, then the conditions `b` and `c` are interchangeable in an "and" relationship with `a`.

The theorem asserts that for propositions `a`, `b`, and `c`, `(a ↔ b) ↔ (a ↔ c) ↔ (a → b ↔ c)`.


theorem Polynomial.aeval_algHom_apply :
    ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] {F : Type u_3} [inst_5 : FunLike F A B]
      [inst_6 : AlgHomClass F R A B] (f : F) (x : A) (p : Polynomial R),
      (Polynomial.aeval (f x)) p = f ((Polynomial.aeval x) p) :=
  by sorry

This theorem states that for any commutative semiring `R`, semirings `A` and `B`, algebra structures over `R` on `A` and `B`, a function-like object `F` from `A` to `B`, and an algebra homomorphism class for `F` from `R` to `A` to `B`, if you take any algebra homomorphism `f` from `F`, any element `x` from `A`, and any polynomial `p` with coefficients in `R`, then applying the polynomial `p` to the algebra homomorphism of `x` under `f` (i.e., `(Polynomial.aeval (f x)) p`) is equal to applying `f` to the result of `(Polynomial.aeval x) p`. In other words, the process of evaluating a polynomial at an algebraic element and then applying an algebra homomorphism is the same as first applying the algebra homomorphism and then evaluating the polynomial at the result.

For any commutative semirings `R`, semirings `A` and `B`, algebra structures over `R` on `A` and `B`, function-like object `F` from `A` to `B`, and an algebra homomorphism class for `F` from `R` to `A` to `B`, the application of a polynomial evaluation and an algebra homomorphism to an element `x` in `A` commutes: `(Polynomial.aeval (f x)) p = (f (Polynomial.aeval x)) p`, where `f` is an algebra homomorphism from `F`, `p` is a polynomial with coefficients in `R`.


theorem isOpen_compl_singleton :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x : X}, IsOpen {x}ᶜ := by sorry

This theorem states that for any type `X`, which has a structure of a topological space, and an additional structure of a `T1Space` (which is a topological space where for every pair of distinct points there is an open set containing one but not the other), for any point `x` in `X`, the complement of the singleton set `{x}` is an open set. In mathematical terms, this means if we have a `T1` topological space, the complement of any singleton set is an open set in that space.

In a T1 topological space, the complement of any singleton set is an open set.


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

The theorem `Polynomial.map_map` states that for all types `R`, `S`, and `T` which are semirings, and for all ring homomorphisms `f` from `R` to `S` and `g` from `S` to `T`, and for any polynomial `p` with coefficients in `R`, the process of first mapping `p` across `f` to get a polynomial in `S`, and then mapping the resultant polynomial across `g` to get a polynomial in `T`, is the same as the process of directly mapping `p` across the composition of `g` and `f`. This theorem essentially describes the property that the map operation on polynomials preserves the composition of ring homomorphisms.

For any semirings R, S, and T, and ring homomorphisms f : R -> S and g : S -> T, the polynomial map operation is commutative with respect to the composition of homomorphisms: Polynomial.map (p : Poly R) (g ∘ f) = Polynomial.map (Polynomial.map p f) g.


theorem measurable_discrete :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : DiscreteMeasurableSpace α] (f : α → β), Measurable f :=
  by sorry

The theorem `measurable_discrete` states that for any two types `α` and `β`, if `α` is equipped with a discrete measurable space structure and `β` with any measurable space structure, then every function `f` from `α` to `β` is measurable. In other words, for any set in `β` that is considered measurable, its preimage under the function `f` is also measurable in `α` when `α` is a discrete measurable space. This holds for every possible function `f` from `α` to `β`.

If `α` is a discrete measurable space and `β` is any measurable space, then every function from `α` to `β` is measurable.


theorem Int.zero_emod : ∀ (b : ℤ), 0 % b = 0 := by sorry

This theorem states that for any integer `b`, the remainder when zero is divided by `b` is always zero. In mathematical terms, it expresses that for all integers `b`, the modulo operation `0 mod b` equals zero.

For all integers `b`, `0 mod b` equals zero.


theorem iInf_uniformity : ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}, uniformity α = ⨅ i, uniformity α :=
  by sorry

This theorem states that for all types `α` and sorts `ι`, and for a function `u` from `ι` to `UniformSpace α`, the uniformity of the type `α` is equal to the infimum (`⨅`, or greatest lower bound) of the uniformities of the type `α` over all `i` in `ι`. In other words, it means that the uniformity on a certain type `α` in a uniform space context is the greatest lower bound of all the uniformities on `α` given by the function `u` over the index set `ι`.

The uniformity of a type `α` in a uniform space is the greatest lower bound of the uniformities of `α` under all functions from the index set to `UniformSpace α`.


/-- **Alias** of the reverse direction of `Real.sqrt_pos`. -/
theorem Real.sqrt_pos_of_pos : ∀ {x : ℝ}, 0 < x → 0 < Real.sqrt x := by sorry

This theorem, referred to as an alias of the reverse direction of `Real.sqrt_pos`, states that for any real number `x`, if `x` is greater than 0, then the square root of `x` is also greater than 0. In mathematical terms, it can be written as: for all `x` in ℝ, if `x > 0` then `sqrt(x) > 0`.

If a real number `x` is positive, then its square root is also positive. (i.e., `∀ x : ℝ, x > 0 → √x > 0`)


/-- The fundamental property of the operator norm: `‖f x‖ ≤ ‖f‖ * ‖x‖`.  -/
theorem ContinuousLinearMap.le_opNorm :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F) (x : E), ‖f x‖ ≤ ‖f‖ * ‖x‖ :=
  by sorry

This theorem, `ContinuousLinearMap.le_opNorm`, states the fundamental property of the operator norm for continuous linear maps. It applies to two nontrivial normed fields, 𝕜 and 𝕜₂, and two seminormed additive commutative groups, E and F. The theorem asserts that for any continuous linear map `f` from E to F and any element `x` in E, the norm of the result of applying `f` to `x` is less than or equal to the product of the operator norm of `f` and the norm of `x`. In mathematical notation, this is written as `‖f x‖ ≤ ‖f‖ * ‖x‖`.

For any continuous linear map between normed vector spaces and any vector in the domain, the norm of the image is less than or equal to the operator norm of the map times the norm of the vector.


theorem MeasurableEmbedding.measurableSet_image :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
      MeasurableEmbedding f → ∀ {s : Set α}, MeasurableSet (f '' s) ↔ MeasurableSet s :=
  by sorry

The theorem `MeasurableEmbedding.measurableSet_image` states that for any types `α` and `β`, a measurable space `mα` on `α`, a measurable space instance on `β`, and a function `f` from `α` to `β`, if `f` is a measurable embedding, then a set `s` of type `α` has a measurable image under `f` if and only if the set `s` itself is measurable. In other words, the measurability of the image of a set under a measurable embedding is equivalent to the measurability of the original set.

A measurable embedding of sets preserves measurability: if `f: α → β` is a measurable embedding between measurable spaces `(α, mα)` and `(β, mβ)`, then for any set `s ⊆ α`, `f``[s]` is measurable if and only if `s` is measurable.


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

This theorem, `div_le_div_right`, states that for any type `α` that is a LinearOrderedSemifield (a field with an order relation that is both a total order and compatible with the field operations), and any elements `a`, `b`, and `c` of this type, if `c` is greater than zero, then the statement "the division of `a` by `c` is less than or equal to the division of `b` by `c`" is equivalent to the statement "`a` is less than or equal to `b`".

For any LinearOrderedSemifield `α` and elements `a`, `b`, and `c` in `α` with `c` positive, `a ≤ b` if and only if `a / c ≤ b / c`.


theorem IsAdjoinRoot.map_repr :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f) (x : S), h.map (IsAdjoinRoot.repr h x) = x :=
  by sorry

The theorem `IsAdjoinRoot.map_repr` states that for any commutative ring `R` and any ring `S`, if `f` is a polynomial with coefficients in `R`, `S` is an `R`-algebra and `h` is an adjoined root of `f` in `S`, then when we map the representative of `x` in `S` under the function associated with `h`, we get back `x`. In other words, for every element `x` of `S`, if we take its representative in `R` under the adjoined root `h`, then map it back to `S` using `h`, we recover the original element `x`. This is essentially saying that the process of representing an element of `S` in `R` and then using the map `h` to go back to `S` is an identity operation.

For any commutative rings R and S, any polynomial f with coefficients in R, and any adjoined root h of f in S, the application of h to the representative of any x in S in R and then the application of the representation function from S to R is equal to the identity function on S.


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

The theorem `Set.image2_union_right` states that for any types `α`, `β`, and `γ`, any function `f` from `α` and `β` to `γ`, any set `s` of type `α`, and any two sets `t` and `t'` of type `β`, the image of the binary function `f` over the set `s` and the union of sets `t` and `t'` is equal to the union of the image of the binary function `f` over the set `s` and the set `t` and the image of the binary function `f` over the set `s` and the set `t'`. In mathematical notation, this can be written as: if `f: α × β → γ` and `s ⊆ α` and `t, t' ⊆ β`, then `f((s × (t ∪ t')) = f(s × t) ∪ f(s × t')`.

For any functions `f: α × β → γ`, sets `s ⊆ α`, and sets `t, t' ⊆ β`, `f(s × (t ∪ t')) = f(s × t) ∪ f(s × t')`.


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

This theorem, `Set.image2_assoc`, is about the associativity of the image of binary functions over sets. Given sets `s`, `t`, and `u` of types `α`, `β`, and `γ` respectively, and binary functions `f : δ → γ → ε`, `g : α → β → δ`, `f' : α → ε' → ε`, and `g' : β → γ → ε'`, the theorem states that if for all elements `a` in `s`, `b` in `t`, and `c` in `u`, applying `f` to the result of `g a b` and `c` is equal to applying `f'` to `a` and the result of `g' b c`, then the image of `f` over the image of `g` over `s` and `t` and `u` is equal to the image of `f'` over `s` and the image of `g'` over `t` and `u`. In other words, changing the order of application of the binary functions and images doesn't change the final output set, provided the functions satisfy the stated condition.

Given sets `s`, `t`, `u` and functions `f`, `g`, `f'`, `g'` as in the theorem statement, if for all `a in s`, `b in t`, and `c in u`, `f (g a b) c = f' a (g' b c)`, then `Set.image2 f (Set.image g s t) u` = `Set.image (f' . g') s t u`.


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

This theorem states that for all types `α` and for any two lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then the length of `l₁` is equal to the length of `l₂`. This means that any rearrangement of the elements in a list does not change its length.

If `α` is a type and `l₁` and `l₂` are lists of type `α` such that `l₁` is a permutation of `l₂`, then the lengths of `l₁` and `l₂` are equal.


theorem sub_le_sub :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a ≤ b → c ≤ d → a - d ≤ b - c :=
  by sorry

This theorem, `sub_le_sub`, states that in a given additive commutative group, which also has a preorder and a covariant class (where addition is a covariant operation and the order relation is less than or equal to), if one element `a` is less than or equal to another element `b`, and a third element `c` is less than or equal to a fourth element `d`, then the result of `a - d` is guaranteed to be less than or equal to the result of `b - c`. This theorem is a generalized form of the subtraction property of inequality.

In an additive commutative group with a covariant preorder relation, if a ≤ b and c ≤ d, then a - d ≤ b - c.


/-- A morphism in `Type` is an epimorphism if and only if it is surjective.

See <https://stacks.math.columbia.edu/tag/003C>.
 -/
theorem CategoryTheory.epi_iff_surjective :
    ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective f := by sorry

This theorem establishes the equivalence between two properties for a morphism `f` between two types `X` and `Y`. Specifically, it states that `f` is an epimorphism in the category of types if and only if `f` is a surjective function. In other words, a function from `X` to `Y` is considered an epimorphism (i.e., every parallel pair of morphisms from `Y` to some object that `f` coequalizes is already coequalized by `f`) if and only if every element of `Y` is the image of some element of `X` under `f`. For a more detailed explanation, you can refer to the link provided in the comment above the theorem.

A function between types `X` and `Y` in Lean 4 is an epimorphism if and only if it is surjective.


theorem isOfFinOrder_iff_pow_eq_one :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinOrder x ↔ ∃ n, 0 < n ∧ x ^ n = 1 := by sorry

The theorem `isOfFinOrder_iff_pow_eq_one` states that for any type `G` that forms a monoid, and any element `x` of `G`, `x` is of finite order (as defined by `IsOfFinOrder`) if and only if there exists a positive integer `n` such that `x` raised to the power of `n` equals the identity element of the monoid. In other words, an element `x` in a monoid is of finite order if it eventually reaches the monoid's identity when repeatedly multiplied by itself for a finite number of times.

An element in a monoid is of finite order if and only if there exists a positive integer n such that x ^ n = id, where x is an element of the monoid, id is the identity element, and ^ represents monoid multiplication.


NonUnitalSubalgebra.ext

theorem NonUnitalSubalgebra.ext :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      {S T : NonUnitalSubalgebra R A}, (∀ (x : A), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any given types `R` and `A`, where `R` is a commutative semiring, `A` is a non-unital and non-associative semiring, and `A` is also an `R`-module, if `S` and `T` are non-unital subalgebras of `A` over `R`, then `S` equals `T` if and only if every element `x` of `A` is in `S` if and only if it is in `T`. Essentially, it says that two non-unital subalgebras are the same if they have exactly the same elements.

Two non-unital subalgebras `S` and `T` of a non-unital, non-associative `R`-module `A` over a commutative semiring `R` are equal if and only if they have the same elements.


Function.isEmpty

theorem Function.isEmpty : ∀ {α : Sort u_1} {β : Sort u_2} [inst : IsEmpty β], (α → β) → IsEmpty α := by sorry

This theorem is stating that if for any types `α` and `β`, if `β` is an empty type (i.e., has no values), then any function from `α` to `β` implies that `α` is also an empty type. In other words, if there are no values in `β` to map to, then there can't be any values in `α` either. This theorem is a statement about the impossibility to define a function from some type `α` to an empty type `β`.

If `β` is an empty type, then any function from a non-empty type `α` to `β` implies `α` is empty.


IsIntegral.isAlgebraic

/-- An integral element of an algebra is algebraic. -/
theorem IsIntegral.isAlgebraic :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] [inst_3 : Nontrivial R]
      {x : A}, IsIntegral R x → IsAlgebraic R x :=
  by sorry

This theorem states that if an element `x` of an algebra `A` over a commutative ring `R` is integral, then `x` is also algebraic over `R`. In other words, if `x` is a root of a monic polynomial with coefficients in `R` (the definition of being integral), then there exists a non-zero polynomial with coefficients in `R` such that `x` is a root of this polynomial (the definition of being algebraic). This is true for all nontrivial commutative rings `R` and any ring `A` where `R` acts as an algebra on `A`.

If an element `x` of an algebra `A` over a commutative ring `R` is integral, then `x` is algebraic over `R`. (An integral element is a root of a monic polynomial with coefficients in `R`, and an algebraic element is a root of some non-zero polynomial with coefficients in `R`.)


theorem intervalIntegral.integral_symm :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
      (a b : ℝ), ∫ (x : ℝ) in b..a, f x ∂μ = -∫ (x : ℝ) in a..b, f x ∂μ :=
  by sorry

This theorem, `intervalIntegral.integral_symm`, states that for any real-numbered function `f` and measure `μ`, the integral of `f` over the interval from `b` to `a` is the negation of the integral of `f` over the interval from `a` to `b`. This comes from the properties of the integral in real analysis and holds for any function `f` that is integrable with respect to the given measure `μ` over the given interval.

For any integrable function `f` and measure `μ`, the integral of `f` over the interval `[a, b]` is equal to the negation of the integral of `f` over the interval `[b, a]`.


theorem MvPolynomial.eval₂_add :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      {p q : MvPolynomial σ R} (f : R →+* S₁) (g : σ → S₁),
      MvPolynomial.eval₂ f g (p + q) = MvPolynomial.eval₂ f g p + MvPolynomial.eval₂ f g q :=
  by sorry

The theorem `MvPolynomial.eval₂_add` asserts that for any commutative semirings `R` and `S₁`, any multivariate polynomial `p` and `q` over `R` with variables indexed by `σ`, any ring homomorphism `f` from `R` to `S₁`, and any valuation `g` of the variables, the evaluation of the sum of `p` and `q` using `f` and `g` is equal to the sum of the evaluations of `p` and `q` individually using `f` and `g`. This is the property of linearity for the evaluation of multivariate polynomials.

For any commutative semirings R and S₁, multivariate polynomials p and q over R, ring homomorphism f from R to S₁, and valuation g, the evaluation of p + q using f and g equals the sum of the evaluations of p and q using f and g.


theorem Set.Ioo_subset_Ioi_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b ⊆ Set.Ioi a := by sorry

This theorem states that for any type `α` which has a preorder (i.e., a structure where the elements can be compared for an order), and for any two elements `a` and `b` of this type, the left-open right-open interval from `a` to `b` is a subset of the left-open right-infinite interval starting from `a`. In mathematical terms, if `a` and `b` are elements of a set with a preorder, then `(a, b) ⊆ (a, ∞)`.

For any type `α` with a preorder and any `a, b ∈ α` with `a < b`, the interval `(a, b)` is a subset of the interval `(a, ∞)`.


theorem Nat.descFactorial_succ : ∀ (n k : ℕ), Nat.descFactorial n (k + 1) = (n - k) * Nat.descFactorial n k := by sorry

The theorem `Nat.descFactorial_succ` states that for any two natural numbers `n` and `k`, the descending factorial of `n` at `(k + 1)` is equal to the product of `(n - k)` and the descending factorial of `n` at `k`. In mathematical terms, this means that `n.descFactorial (k + 1) = (n - k) * n.descFactorial k`. The descending factorial, `n.descFactorial k`, is defined as the factorial of `n` divided by the factorial of `(n - k)`, implemented recursively.

The descending factorial of a natural number `n` at `k+1` equals the product of `(n-k)` and the descending factorial of `n` at `k`. In other words, `n.descFactorial (k+1) = (n-k) * n.descFactorial k`.


theorem Mathlib.Data.Finset.Option._auxLemma.5 :
    ∀ {α : Type u_1} {s : Finset (Option α)} {x : α}, (x ∈ Finset.eraseNone s) = (some x ∈ s) := by sorry

The theorem `Mathlib.Data.Finset.Option._auxLemma.5` states that for any type `α`, any finite set `s` of optional values of type `α`, and any value `x` of type `α`, `x` belongs to the set obtained by erasing `None` values from `s` if and only if `Some x` belongs to `s`. In other words, this theorem is saying that an element is in the set derived from `s` by removing `None` values precisely when its `Some` version is in the original set `s`.

For any type `α` and finite set `s` of optional values `α`, an element `x` belongs to the set `s` without its `None` values if and only if `Some x` belongs to `s`.


theorem Submodule.ne_bot_iff :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), p ≠ ⊥ ↔ ∃ x ∈ p, x ≠ 0 :=
  by sorry

This theorem states that for all types `R` and `M`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is a module over `R`, a submodule `p` of `M` is not the bottom element if and only if there exists an element `x` in `p` such that `x` is not the zero element. In mathematical terms, $\forall R, M, p$, where $R$ is a semiring, $M$ is a module over $R$, and $p$ is a submodule of $M$, $p \neq \bot$ if and only if $\exists x \in p$, $x \neq 0$.

A submodule of an R-module M, where R is a semiring, is non-empty if and only if it contains a non-zero element.


theorem continuous_iff_le_induced :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
      Continuous f ↔ t₁ ≤ TopologicalSpace.induced f t₂ :=
  by sorry

The theorem `continuous_iff_le_induced` states that for any two types `α` and `β`, a function `f` from `α` to `β`, and topologies `t₁` on `α` and `t₂` on `β`, the function `f` is continuous if and only if the topology `t₁` on `α` is coarser than or equal to the topology induced on `α` by mapping `f` from the original topology `t₂` on `β`. In other words, `f` is continuous when every set in the topology of `α` is an open set that is the preimage of an open set in the topology of `β` under the function `f`.

A function between two topological spaces is continuous if and only if the topology on the domain is finer than or equal to the topology induced by the function on the codomain.


theorem ProbabilityTheory.kernel.const_apply :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μβ : MeasureTheory.Measure β)
      (a : α), (ProbabilityTheory.kernel.const α μβ) a = μβ :=
  by sorry

This theorem states that for any types `α` and `β`, given measurable spaces `mα` and `mβ` over these types and a measure `μβ` on `β`, the constant kernel (which always returns the same measure regardless of its input) when applied to any element of type `α` will always return the measure `μβ`. This essentially implies that the constant kernel is independent of the specific element in the measurable space `α` and only depends on the measure `μβ`.

For any measurable spaces `mα` and `mβ` over types `α` and `β`, and any measure `μβ` on `β`, the constant kernel function maps every element of `α` to the measure `μβ`.


theorem Nat.Prime.dvd_mul : ∀ {p m n : ℕ}, Nat.Prime p → (p ∣ m * n ↔ p ∣ m ∨ p ∣ n) := by sorry

The theorem `Nat.Prime.dvd_mul` states that for any natural numbers `p`, `m`, and `n`, if `p` is prime, then `p` divides the product `m * n` if and only if `p` divides `m` or `p` divides `n`. In mathematical terms, this is expressing the fundamental property of prime numbers that if a prime number divides a product, it must divide at least one of the factors.

If a prime number `p` divides the product `m * n`, then `p` divides `m` or `p` divides `n`.


/-- A specialization of `mem_iUnion₂`.  -/
theorem Set.mem_biUnion :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : α → Set β} {x : α} {y : β}, x ∈ s → y ∈ t x → y ∈ ⋃ x ∈ s, t x :=
  by sorry

This theorem, `Set.mem_biUnion`, states that for any types `α` and `β`, a set `s` of type `α`, a function `t` mapping from `α` to a set of type `β`, and elements `x` of type `α` and `y` of type `β`, if `x` is an element of `s` and `y` is an element of the set `t(x)`, then `y` is an element of the union over `s` of the sets `t(x)`. In mathematical notation, this would be expressed as if $x \in s$ and $y \in t(x)$, then $y \in \bigcup_{x \in s} t(x)$.

If `x` is an element of `s` and `y` is an element of `t(x)`, then `y` is an element of the set `⋃(x ∈ s) t(x)`.


theorem Finset.inf_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} {f : β → α} {b : β},
      b ∈ s → Finset.inf s f ≤ f b :=
  by sorry

This theorem, `Finset.inf_le`, states that for any types `α` and `β`, under the conditions that `α` forms a semilattice with an infimum operation and has a top element, given a finite set `s` of elements of type `β`, a function `f` from `β` to `α`, and an element `b` of type `β`, if `b` is an element of `s`, then the infimum of the set of values obtained by applying `f` to each element of `s` is less than or equal to `f(b)`. In mathematical terms, given a set $S \subseteq \beta$ and a function $f: \beta \rightarrow \alpha$, if $b \in S$, then $\inf_{x \in S} f(x) \leq f(b)$.

For any semilattice `α` with top element, and given a finite set `S` of elements in type `β` and a function `f` from `β` to `α`, if `b` is an element of `S`, then the infimum of `f` over `S` is less than or equal to `f(b)`.


theorem Set.inter_compl_self : ∀ {α : Type u} (s : Set α), s ∩ sᶜ = ∅ := by sorry

This theorem states that for all types `α` and any set `s` of type `α`, the intersection of the set `s` and its complement `sᶜ` is always an empty set. In other words, there are no elements that can be found both in a set and its complement, which aligns with the mathematical concept where a set and its complement are disjoint and their intersection is the empty set.

For all types `α` and sets `s` of type `α` in Lean 4, the intersection of `s` and its complement `sᶜ` is an empty set. `∥s∥ = ∥sᶜ∥ → s ∩ sᶜ = ∅`.


theorem Option.ne_none_iff_isSome : ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ Option.isSome o = true := by sorry

This theorem, named `Option.ne_none_iff_isSome`, states that for any type `α` and an option `o` of type `α`, the option `o` is not `none` if and only if the function `Option.isSome` applied to `o` equals `true`. In other words, an optional value is not `none` exactly when it is `some` value.

For any type `α` and option `o` of type `Option α`, `o ≠ none` if and only if `Option.isSome o` holds.


RightOrdContinuous.orderDual

theorem RightOrdContinuous.orderDual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      RightOrdContinuous f → LeftOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem states that for any two types `α` and `β` that both have a preorder, and any function `f` from `α` to `β`, if `f` is right order continuous (meaning it preserves all infima), then the function that applies `f` and then the dual order to its input is left order continuous (meaning it preserves all suprema). This means that reflecting the order of the inputs and the outputs switches the property of preserving the infimum (greatest lower bound) to preserving the supremum (least upper bound).

For any right order continuous function from a preordered type to another preordered type, the functional composition with the dual order is left order continuous.


Multiset.Nodup.dedup

/-- **Alias** of the reverse direction of `Multiset.dedup_eq_self`. -/
theorem Multiset.Nodup.dedup :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α}, Multiset.Nodup s → Multiset.dedup s = s := by sorry

This theorem, referred to as an alias of the reverse direction of `Multiset.dedup_eq_self`, asserts that for any type `α` with a decidable equality and for any multiset `s` of type `α`, if `s` has no duplicates (i.e., `Multiset.Nodup s` is true), then removing duplicates from `s` (i.e., `Multiset.dedup s`) results in `s` itself. In other words, if a multiset is already a set with no duplicates, then the process of removing duplicates will not alter the multiset.

For any type `α` with decidable equality and any multiset `s` of type `α` with no duplicates, `Multiset.dedup s = s`.


theorem Nat.dvd_prime : ∀ {p m : ℕ}, Nat.Prime p → (m ∣ p ↔ m = 1 ∨ m = p) := by sorry

The theorem `Nat.dvd_prime` states that for every two natural numbers `p` and `m`, if `p` is a prime number, then `m` divides `p` if and only if `m` is either 1 or `p`. In mathematical terms, this says that if `p` is a prime number, its only divisors are 1 and `p` itself.

If `p` is a prime number, then the divisors of `p` are exactly 1 and `p`.


/-- **Alias** of the reverse direction of `Set.forall_mem_image`. -/
theorem Set.ball_image_of_ball :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop},
      (∀ ⦃x : α⦄, x ∈ s → p (f x)) → ∀ y ∈ f '' s, p y :=
  by sorry

The theorem `Set.ball_image_of_ball` states that for any types `α` and `β`, any function `f` from `α` to `β`, any set `s` of elements of type `α`, and any predicate `p` on elements of type `β`, if for all elements `x` in the set `s`, the predicate `p` holds for `f(x)`, then for any `y` in the image of `s` under `f`, `p(y)` also holds. In other words, if all elements of a set satisfy a predicate when transformed by a function, then all elements in the image of the set under the function satisfy the predicate.

If a function maps every element of a set to an element satisfying a predicate, then every image of the set under the function also satisfies the predicate.


theorem Set.Nonempty.image_const :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, Set.Nonempty s → ∀ (a : β), (fun x => a) '' s = {a} := by sorry

The theorem `Set.Nonempty.image_const` states that for any nonempty set `s` of type `α` and any element `a` of type `β`, the image of `s` under the constant function that maps every element to `a` is the singleton set `{a}`. In other words, if you have a nonempty set, and you apply a function to every element in that set where the function always outputs the same value `a`, then the resulting set contains just the one unique element `a`.

For any nonempty set `s` and element `a`, the image of `s` under the constant function mapping to `a` is the singleton set `{a}`.


theorem nonZeroDivisors.coe_ne_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : Nontrivial M] (x : ↥(nonZeroDivisors M)), ↑x ≠ 0 := by sorry

This theorem states that for any `MonoidWithZero` M that is `Nontrivial` (i.e., it has at least two distinct elements), all elements x of the submonoid of non-zero divisors of M are non-zero. Here, `nonZeroDivisors` is a submonoid of M consisting of elements x such that if z multiplied by x equals 0, then z must be 0. The notation `↑x` represents the process of coercing (or translating) x from the submonoid back to the original monoid M. Thus, the theorem asserts that no element of the non-zero divisors can be zero in the context of the monoid M.

In any nontrivial MonoidWithZero M, all elements in the submonoid of non-zero divisors are non-zero.


PSet.Equiv.symm

theorem PSet.Equiv.symm : ∀ {x : PSet} {y : PSet}, PSet.Equiv x y → PSet.Equiv y x := by sorry

This theorem, `PSet.Equiv.symm`, states that the relation of extensional equivalence between two pre-sets is symmetric. In other words, for any pre-sets `x` and `y`, if `x` is extensionally equivalent to `y` (denoted as `PSet.Equiv x y`), then `y` is also extensionally equivalent to `x` (denoted as `PSet.Equiv y x`). The extensional equivalence between two pre-sets is defined as each element of the first pre-set being extensionally equivalent to some element of the second pre-set and vice versa.

If pre-sets `x` and `y` are extensionally equivalent, then they are equal in the symmetric sense (i.e., `x = y`).


theorem iff_false_intro : ∀ {a : Prop}, ¬a → (a ↔ False) := by sorry

This theorem, `iff_false_intro`, states that for any proposition `a`, if `a` is not true (i.e., `¬a`), then `a` is equivalent to `False`. In other words, if we can prove that a given proposition is not true, we can conclude that this proposition is logically equivalent to `False`. This theorem is a fundamental concept in propositional logic.

The theorem `iff_false_intro` asserts that for any proposition `a`, the negation of `a` is logically equivalent to `False`.


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

The theorem `Set.image2_swap` states that for all types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, and any sets `s` of type `α` and `t` of type `β`, the image of the function `f` over the sets `s` and `t` is equal to the image of the function `f` with its arguments swapped, over the sets `t` and `s`. In mathematical terms, this theorem asserts the commutativity of the image of a function over two sets, swapping the order of sets and the function arguments does not change the resulting set.

For any type `α`, `β`, `γ`, set `s` of type `α`, set `t` of type `β`, and binary function `f` from `α` to `β`, the image of `f` over `s` and `t` equals the image of `f` with arguments swapped over `t` and `s`. In symbols, `image (f : α → β) (s : set α) (t : set β) = image (f) (t : set β) (s : set α)`.


theorem RingHom.ext_iff :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} {f g : α →+* β},
      f = g ↔ ∀ (x_2 : α), f x_2 = g x_2 :=
  by sorry

This theorem states a property of ring homomorphisms between two non-associative semirings. Specifically, it says that for any two ring homomorphisms `f` and `g` from a non-associative semiring `α` to another non-associative semiring `β`, `f` and `g` are equal if and only if they produce the same output for every input from `α`. In other words, two ring homomorphisms are identical if they behave in the same way for all elements of the domain semiring.

Two ring homomorphisms between non-associative semirings are equal if and only if they map every element in the domain to the same image.


theorem Real.sSup_empty : sSup ∅ = 0 := by sorry

This theorem states that the supremum (greatest value) of an empty set in the realm of real numbers is zero. The supremum, often denoted as sup or sSup in this context, is the least upper bound of a set. Since an empty set doesn't contain any elements, we conventionally define its supremum to be zero.

The supremum of an empty set of real numbers is 0.


theorem Complex.ofReal_nat_cast : ∀ (n : ℕ), ↑↑n = ↑n := by sorry

This theorem states that for any natural number `n`, casting `n` to a real number and then to a complex number is the same as directly casting `n` to a complex number. In other words, the processes of casting from natural numbers to real numbers and then to complex numbers, and casting directly from natural numbers to complex numbers, are equivalent.

For any natural number n, the conversion from n to complex number is equal to the conversion from n to real number and then to complex number.


theorem Mathlib.Order.LocallyFinite._auxLemma.32 :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : Subtype p},
      (a ∈ Finset.subtype p s) = (↑a ∈ s) :=
  by sorry

This theorem states that for any type `α`, a predicate `p` on `α` that is decidable, a finite set `s` of `α`, and an element `a` of the subtype `p`, the element `a` is in the subset of `s` determined by the predicate `p` if and only if the underlying element of `a` is in the set `s`. In other words, it is verifying the membership of an element in the subset filtered by a predicate against the membership in the original set.

For any decidable predicate `p` on type `α`, element `a` of type `α` satisfying `p a`, and finite set `s ⊆ α`, `a ∈ s` if and only if `a.1 ∈ s`.


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

This theorem states that for any given type `X` in the context of a topological space, and any two sets `s` and `t` of this type, the interior of the intersection of `s` and `t` is equal to the intersection of the interiors of `s` and `t`. In mathematical terms, it expresses that the operation of taking the interior of a set commutes with the operation of taking the intersection of two sets, i.e. $\text{int}(s \cap t) = \text{int}(s) \cap \text{int}(t)$, where "int" denotes the interior of a set in a topological space.

The interior of the intersection of two sets is equal to the intersection of their interiors in a topological space.


theorem Set.mem_Iio : ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, x ∈ Set.Iio b ↔ x < b := by sorry

The theorem `Set.mem_Iio` states that for any type `α` equipped with a preorder, and any elements `b` and `x` of this type, `x` belongs to the left-infinite right-open interval `Set.Iio b` if and only if `x` is less than `b`. In other words, the function `Set.Iio b` is precisely the set of all elements less than `b`.

For any preordered type `α` and elements `b` and `x` of `α`, `x` is in the left-infinite right-open interval `Set.Iio b` if and only if `x` is strictly less than `b`.


theorem Complex.cos_neg : ∀ (x : ℂ), Complex.cos (-x) = Complex.cos x := by sorry

This theorem states that the complex cosine function is an even function. In other words, for any complex number `x`, the cosine of the negation of `x` (`-x`) is equal to the cosine of `x` itself. This mirrors the property of the real-valued cosine function. In mathematical notation, this would be represented as: ∀x ∈ ℂ, cos(-x) = cos(x).

The complex cosine function is an even function, that is, cos(-x) = cos(x) for all x in ℂ.


theorem MeasureTheory.Measure.measurable_coe :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α}, MeasurableSet s → Measurable fun μ => ↑↑μ s := by sorry

This theorem, `MeasureTheory.Measure.measurable_coe`, states that for any given measurable space `α`, and any given set `s` in this space such that `s` is a measurable set, the function which maps each measure `μ` to the measure of the set `s` is a measurable function. In other words, the preimage of every measurable set under this function is also a measurable set. This is a characteristic property of measurable functions in the field of measure theory.

The function that maps a measure to the measure of a measurable set is a measurable function.


theorem Turing.ListBlank.tail_cons :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ),
      Turing.ListBlank.tail (Turing.ListBlank.cons a l) = l :=
  by sorry

The theorem `Turing.ListBlank.tail_cons` states that for any type `Γ` that has an instance of the `Inhabited` type class, any element `a` of type `Γ`, and any Turing `ListBlank` `l` of type `Γ`, the tail of the `ListBlank` resulting from consing `a` onto `l` is equal to `l`. In other words, if you prepend an element `a` to a Turing `ListBlank` `l` and then take the tail of the resulting `ListBlank`, the result is the original `ListBlank` `l`. This theorem formalizes a fundamental property of the `cons` function in traditional list theory in the context of Turing `ListBlank`.

For any type `Γ` with an `Inhabited` instance, and any `a : Γ` and `l : ListBlank Γ`, the tail of the list obtained by consing `a` to `l` is equal to `l`.


theorem Multiset.card_le_card : ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t → Multiset.card s ≤ Multiset.card t := by
  sorry

The theorem `Multiset.card_le_card` states that for any two multisets `s` and `t` of any type `α`, if `s` is a sub-multiset of `t` (denoted by `s ≤ t`), then the cardinality of `s` (the sum of the multiplicities of all its elements or simply the length of the underlying list) is less than or equal to the cardinality of `t` (denoted by `Multiset.card s ≤ Multiset.card t`).

If `s` is a sub-multiset of `t`, then the cardinality of `s` is less than or equal to the cardinality of `t`.


/-- If the codomain of a topological embedding is a Hausdorff space, then so is its domain.
See also `T2Space.of_continuous_injective`.  -/
theorem Embedding.t2Space :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space Y]
      {f : X → Y}, Embedding f → T2Space X :=
  by sorry

This theorem states that if you have a topological embedding from a type `X` to a type `Y`, and if the topological space `Y` is a Hausdorff space (also known as a T2 space), then the topological space `X` is also a Hausdorff space. Topological embedding is a function which preserves the topology, and a Hausdorff space is a topological space where any two distinct points have disjoint open neighborhoods. This theorem shows the preservation of the Hausdorff property under topological embeddings.

If `X` is a topological space embedded as a subspace of the Hausdorff space `Y`, then `X` is also a Hausdorff space.


theorem MeasureTheory.VectorMeasure.restrict_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
      (v : MeasureTheory.VectorMeasure α M) {i : Set α},
      MeasurableSet i → ∀ {j : Set α}, MeasurableSet j → ↑(MeasureTheory.VectorMeasure.restrict v i) j = ↑v (j ∩ i) :=
  by sorry

This theorem states that for any measure space `α`, type `M` that has both an addition operation (forming a commutative monoid) and a topological structure, a vector measure `v` on `α` with values in `M`, and any measurable set `i` in `α`, the restriction of the vector measure `v` to the set `i` behaves as expected: for any measurable set `j`, the measure of `j` under the restricted measure equals the measure of the intersection of `j` and `i` under the original measure `v`. In mathematical terms, if `v` is a vector measure and `i` and `j` are measurable sets, then the measure of `j` under the restriction of `v` to `i` is equal to the measure of `j ∩ i` under `v`.

For any measurable sets `i` and `j` in a measure space `α` with a commutative monoid and topology, and any vector measure `v` on `α` with values in the monoid, the measure of `j` under the restriction of `v` to `i` equals the measure of `j ∩ i` under `v`.


theorem Finset.filter_union_filter_neg_eq :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α]
      [inst_2 : (x : α) → Decidable ¬p x] (s : Finset α), Finset.filter p s ∪ Finset.filter (fun a => ¬p a) s = s :=
  by sorry

This theorem states that for any given type `α`, a predicate `p` on `α` which is decidable (meaning it is possible to determine whether `p` holds for any element of `α`), and any finite set `s` of `α`, the union of the set of elements in `s` that satisfy `p` and the set of elements in `s` that do not satisfy `p` is equal to `s` itself. In other words, if you partition a finite set based on whether a given decidable predicate is true or false, and then recombine those parts, you get back the original set. This holds for any decidable equality on `α`.

For any finite type `α` with decidable equality, and decidable predicate `p` on `α`, the sets `{x : α | p x}` and `{x : α | ¬p x}` have a disjoint union equal to `α`.


/-- The `cons` and `head`/`tail` functions are mutually inverse, unlike in the case of `List` where
this only holds for nonempty lists.  -/
theorem Turing.ListBlank.cons_head_tail :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : Turing.ListBlank Γ),
      Turing.ListBlank.cons (Turing.ListBlank.head l) (Turing.ListBlank.tail l) = l :=
  by sorry

The theorem `Turing.ListBlank.cons_head_tail` asserts that for any type `Γ` that is inhabited and for any 'ListBlank' of type `Γ`, the 'cons' function and the 'head'/'tail' functions are mutually inverse. This simply means that if you take the head of a `ListBlank` and cons it onto the tail of the `ListBlank`, you get back the original `ListBlank`. This is in contrast to the case of `List`, where this property only holds for nonempty lists.

For any type `Γ` and any `ListBlank` of length `n+1` over `Γ`, the `cons` function applied to the `head` of `ListBlank` and the `tail` of `ListBlank` is equal to the original `ListBlank`.


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

This theorem states that for any types `α` and `β`, a specific element `b` of type `β`, and a function `s` that maps an element of type `β` and a proof that it equals `b` to a set of type `α`, the intersection over all `x` of the intersection over all proofs `h : b = x` of `s x h` is equal to `s b rfl`. In simpler terms, it's saying that intersecting over all possible sets generated by `s` for different inputs equivalent to `b`, results in the set generated by `s` for `b` itself.

For any types `α` and `β`, function `s : β -> Set α`, and `b : β`, the intersections over all `x : β` and all proofs `h : b = x` are equal: `∩x (∩h (s x h)) = s b rfl`.


theorem Nat.cast_add_one : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑(n + 1) = ↑n + 1 := by sorry

This theorem states that for any natural number `n`, the cast of `n + 1` to some type `R` that is an additive monoid with one, equals the cast of `n` to `R` plus one. In other words, when a natural number `n` is incremented by 1 and then cast to `R`, it is the same as if `n` was first cast to `R` and then incremented by 1. This property holds for all types `R` that have an addition operation and a distinguished element called "one".

For any additive monoid with one `R` and natural number `n`, the cast of `n + 1` to `R` equals the cast of `n` to `R` plus one.


theorem Fin.eq_of_veq : ∀ {n : ℕ} {i j : Fin n}, ↑i = ↑j → i = j := by sorry

This theorem, `Fin.eq_of_veq`, states that for any natural number `n`, and any two elements `i` and `j` of the finite set `Fin n`, if the natural number representations of `i` and `j` (obtained using the up-arrow `↑` operator) are equal, then `i` and `j` themselves are also equal. Essentially, this asserts that the equality of the natural number representations of two elements in a finite set implies the equality of the elements themselves.

For any finite set `Fin n` and elements `i`, `j` in `Fin n`, `i = j` if and only if `↑i = ↑j`.


theorem PosNum.to_nat_inj : ∀ {m n : PosNum}, ↑m = ↑n ↔ m = n := by sorry

This theorem, `PosNum.to_nat_inj`, states that for any two positive numbers `m` and `n`, the coercion (conversion) of `m` and `n` to natural numbers results in equal natural numbers if and only if `m` and `n` themselves are equal. That is, the process of converting positive numbers to natural numbers preserves their distinctness; no two different positive numbers will become the same natural number after conversion.

The coercion of positive numbers to natural numbers is an injection. That is, distinct positive numbers map to distinct natural numbers.


theorem Nat.sub_sub : ∀ (n m k : ℕ), n - m - k = n - (m + k) := by sorry

This theorem, `Nat.sub_sub`, states that for all natural numbers `n`, `m`, and `k`, the operation of subtracting `m` and then `k` from `n` is equivalent to subtracting the sum of `m` and `k` from `n`. In mathematical notation, this would be expressed as `n - m - k = n - (m + k)`.

For all natural numbers `n`, `m`, and `k`, `n - m - k` equals `n - (m + k)`.


theorem Filter.EventuallyEq.eq_of_nhdsWithin :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s : Set α} {f g : α → β} {a : α},
      f =ᶠ[nhdsWithin a s] g → a ∈ s → f a = g a :=
  by sorry

The theorem `Filter.EventuallyEq.eq_of_nhdsWithin` states that for any two functions `f` and `g` from a type `α` to a type `β`, within a topological space `α`, and a set `s` of type `α`, if `f` is eventually equal to `g` within the neighborhood of a point `a` from the set `s` (`f =ᶠ[nhdsWithin a s] g`), and `a` is an element of the set `s` (`a ∈ s`), then the value of `f` at `a` (`f a`) is equal to the value of `g` at `a` (`g a`).

If a point `a` in a set `s` of a topological space and functions `f` and `g` from `α` to `β` satisfy `f =ᶠ[nhdsWithin a s] g`, then `f a = g a`.


theorem Nat.dvd_trans : ∀ {a b c : ℕ}, a ∣ b → b ∣ c → a ∣ c := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `a` divides `b` and `b` divides `c`, then `a` also divides `c`. In mathematical notation, this would be expressed as: if $a | b$ and $b | c$, then $a | c$. This is a fundamental property of divisibility in the set of natural numbers.

If `a` divides `b` and `b` divides `c`, then `a` divides `c` (in the set of natural numbers).


theorem Finset.sum_le_sum_of_subset_of_nonneg :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f : ι → N} {s t : Finset ι},
      s ⊆ t → (∀ i ∈ t, i ∉ s → 0 ≤ f i) → (Finset.sum s fun i => f i) ≤ Finset.sum t fun i => f i :=
  by sorry

The theorem `Finset.sum_le_sum_of_subset_of_nonneg` states that for any types `ι` and `N`, given an ordered additive commutative monoid on `N`, a function `f` from `ι` to `N`, and two finite sets `s` and `t` of type `ι`: if `s` is a subset of `t` and for every element `i` in `t` that is not in `s`, the function `f` applied to `i` is non-negative, then the sum of the function `f` applied to each element in `s` is less than or equal to the sum of the function `f` applied to each element in `t`. In mathematical terms, if $s \subseteq t$ and for all $i \in t \setminus s$, $f(i) \geq 0$, then $\sum_{i\in s} f(i) \leq \sum_{i\in t} f(i)$.

If $s$ is a subset of $t$ in an ordered additive commutative monoid and for all $i \in t \setminus s$, $f(i) \ge 0$, then $\sum\_{i \in s} f(i) \le \sum\_{i \in t} f(i)$.


theorem CategoryTheory.Preadditive.comp_sum :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      {J : Type u_1} (s : Finset J) (f : P ⟶ Q) (g : J → (Q ⟶ R)),
      CategoryTheory.CategoryStruct.comp f (Finset.sum s fun j => g j) =
        Finset.sum s fun j => CategoryTheory.CategoryStruct.comp f (g j) :=
  by sorry

This theorem, `CategoryTheory.Preadditive.comp_sum`, is about composition and summation in the context of category theory. It states that for any category `C` which is preadditive (meaning it has a bifunctorial binary operation compatible with the category structure), and for any objects `P`, `Q`, `R` in `C`, any finite set `s`, a morphism `f` from `P` to `Q`, and a family of morphisms `g` from `Q` to `R` indexed by `s`, the composition of `f` with the sum of the `g`s (i.e., `f ≫ (∑ g)`) is equal to the sum of the compositions of `f` with each `g` (i.e., `∑ (f ≫ g)`). This expresses a kind of distributivity property for composition over summation in preadditive categories.

In a preadditive category, for any object `P`, objects `Q`, `R`, morphism `f : P -> Q`, and family of morphisms `g_i : Q -> R` indexed by a finite set `s`, the commutativity of `f` with the sum of the `g_i` implies the equality of `f ≫ (∑ g_i)` and `∑ (f ≫ g_i)`.


theorem Set.biInter_and' :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} (p : ι' → Prop) (q : ι → ι' → Prop)
      (s : (x : ι) → (y : ι') → p y ∧ q x y → Set α),
      ⋂ x, ⋂ y, ⋂ (h : p y ∧ q x y), s x y h = ⋂ y, ⋂ (hy : p y), ⋂ x, ⋂ (hx : q x y), s x y ⋯ :=
  by sorry

This theorem, named `Set.biInter_and'`, states that for any type `α`, sorts `ι` and `ι'`, a property `p` of elements from `ι'`, a binary relation `q` between elements from `ι` and `ι'`, and a function `s` that maps an element of `ι`, an element of `ι'`, and a proof that `p y` and `q x y` hold to a set of `α`, the intersection of sets produced by `s` over all `x`, `y`, and proofs of `p y` and `q x y` is equal to the intersection of sets over all `y`, proofs of `p y`, `x`, and proofs of `q x y`.

In simpler terms, this theorem is about the reordering of nested intersections of sets. It says that you can reorder the intersections without changing the resulting set, when dealing with a particular kind of function `s` that produces sets from elements of `ι` and `ι'` and proofs of certain properties.

For any type `α`, sets `ι` and `ι'`, property `p` of elements from `ι'`, binary relation `q` between elements from `ι` and `ι'`, and function `s` that maps an element of `ι`, an element of `ι'`, and proofs of `p y` and `q x y` to sets of `α`, the sets `∩����'_x (s x) (∀ y, p y) (∀ y, q x y)` and `∩����'_y (∀ x, ∀ y, s x y) (p y)` are equal.


theorem Mathlib.Combinatorics.Young.YoungDiagram._auxLemma.1 :
    ∀ {μ : YoungDiagram} (c : ℕ × ℕ), (c ∈ μ.cells) = (c ∈ μ) := by sorry

This theorem states that for any Young Diagram `μ` and any pair of natural numbers `c`, the statement that `c` is an element of the cells of `μ` is equivalent to the statement that `c` is an element of `μ`. In other words, being in the set of cells of a Young Diagram is the same as being in the Young Diagram itself. A Young Diagram in this context is a combinatorial structure used in the representation theory of symmetric groups and certain other mathematical entities.

For any Young Diagram `μ`, the set of cells in `μ` equals the diagram itself.


theorem Filter.mem_cocompact :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, s ∈ Filter.cocompact X ↔ ∃ t, IsCompact t ∧ tᶜ ⊆ s := by
  sorry

The theorem `Filter.mem_cocompact` states that for any type `X` equipped with a topological space structure and any set `s` of type `X`, the set `s` is in the filter `Filter.cocompact X` if and only if there exists a set `t` such that `t` is compact and the complement of `t` is a subset of `s`. In other words, a set is in the filter generated by complements to compact sets if it contains the complement of some compact set.

A set is in the filter of cocompact subsets of a topological space if and only if it contains the complement of some compact subset.


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

This theorem states that for any two complex numbers `x` and `y`, the sine of the sum (`x + y`) is equal to the product of the sine of `x` and the cosine of `y`, plus the product of the cosine of `x` and the sine of `y`. This mirrors the well-known trigonometric identity in real numbers, namely, $\sin(x + y) = \sin(x)\cos(y) + \cos(x)\sin(y)$, where $x$ and $y$ are real numbers. Here, the sine and cosine functions are defined for complex numbers via the exponential function.

The theorem asserts that for complex numbers `x` and `y`, the sine of their sum equals the sum of the product of sine `x` and cosine `y`, and the product of cosine `x` and sine `y`. In Lean 4 notation, `sine (x + y) = sine x * cos y + cos x * sine y`.


theorem List.rotate_zero : ∀ {α : Type u} (l : List α), List.rotate l 0 = l := by sorry

The theorem `List.rotate_zero` states that for all types `α` and any list `l` of type `α`, rotating the list `l` by 0 (i.e., not rotating it at all) will result in the original list `l`. This is equivalent to saying that the identity operation for list rotation is rotation by 0.

For all types `α` and lists `l` of length `n` over `α`, `List.rotate l 0 = l`.


FreeGroup.lift.of

theorem FreeGroup.lift.of :
    ∀ {α : Type u} {β : Type v} [inst : Group β] {f : α → β} {x : α}, (FreeGroup.lift f) (FreeGroup.of x) = f x := by
  sorry

The theorem `FreeGroup.lift.of` asserts that for any types `α` and `β`, given that `β` is a group, for any function `f` from `α` to `β`, and for any element `x` of `α`, the free group lift of `f` applied to the canonical injection of `x` into the free group over `α` is equal to `f` applied to `x`. In other words, lifting a function to a free group and then applying it to an element of the group (which has been injected into the group via the canonical injection) gives the same result as simply applying the function to the element in the first place.

For any function `f` from type `α` to group `β`, and for any element `x` in type `α`, the free group lift of `f` applied to the canonical injection of `x` equals `f` applied to `x`.


theorem MvPolynomial.eval₂Hom_X' :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (g : σ → S₁) (i : σ), (MvPolynomial.eval₂Hom f g) (MvPolynomial.X i) = g i :=
  by sorry

The theorem `MvPolynomial.eval₂Hom_X'` states that for any types `R`, `S₁`, and `σ`, given two commutative semirings `R` and `S₁`, a ring homomorphism `f` from `R` to `S₁`, a function `g` from `σ` to `S₁`, and a value `i` of type `σ`, the application of the ring homomorphism `MvPolynomial.eval₂Hom f g` to the multivariable polynomial `MvPolynomial.X i` (which represents a degree `1` monomial) is equivalent to applying the function `g` to `i`. In mathematical terms, this theorem asserts that for a given ring homomorphism and a function, the evaluation of the degree `1` monomial at a certain variable using the `eval₂Hom` function is the same as the function's value at that variable.

For any commutative semirings R and S₁, ring homomorphism f : R → S₁, function g : σ → S₁, and value i : σ, the application of MvPolynomial.eval₂Hom f g to the multivariable polynomial MvPolynomial.X i equals g i.


/-- The `AddSubsemigroup` generated by a set includes the set. -/
theorem AddSubsemigroup.subset_closure :
    ∀ {M : Type u_1} [inst : Add M] {s : Set M}, s ⊆ ↑(AddSubsemigroup.closure s) := by sorry

The theorem, `AddSubsemigroup.subset_closure`, asserts that for any set `s` of a type `M` equipped with an addition operation, the set `s` is a subset of the additive subsemigroup generated by `s`. In other words, every element of the original set `s` is also an element of the additive subsemigroup formed by the closure operation on `s`.

For any set `s` and type `M` with an addition operation, `s` is a subset of the additive subsemigroup generated by `s`.


theorem Nat.pow_le_pow_of_le_right : ∀ {n : ℕ}, n > 0 → ∀ {i j : ℕ}, i ≤ j → n ^ i ≤ n ^ j := by sorry

This theorem states that for any natural number `n` greater than zero, and for any two natural numbers `i` and `j` where `i` is less than or equal to `j`, the `i`-th power of `n` is less than or equal to the `j`-th power of `n`. In other words, if we have a positive natural number `n` and two natural numbers `i` and `j` with `i ≤ j`, then `n` raised to the power of `i` will always be less than or equal to `n` raised to the power of `j`.

For all natural numbers n greater than zero and natural numbers i and j with i <= j, n^i <= n^j.


/-- Subtracting the first vector passed to `oangle` from the second vector then swapping the
vectors does not change the sign of the angle.  -/
theorem Orientation.oangle_sign_sub_right_swap :
    ∀ {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),
      Real.Angle.sign (Orientation.oangle o y (y - x)) = Real.Angle.sign (Orientation.oangle o x y) :=
  by sorry

This theorem states that in a real inner product space of finite rank 2, subtracting the first vector from the second vector and then swapping the vectors does not change the sign of their oriented angle. In other words, for any orientation `o` and vectors `x` and `y`, the sign of the oriented angle of `y` and `y - x` is equal to the sign of the oriented angle of `x` and `y`. This is analogous to saying in 2D geometry that subtracting a vector from another and then swapping the vectors does not change the sign of their angle.

In a real inner product space of finite rank 2, the sign of the oriented angle between two vectors is preserved under vector subtraction and swapping.


theorem Fin.eq_of_val_eq : ∀ {n : ℕ} {i j : Fin n}, ↑i = ↑j → i = j := by sorry

This theorem states that for any natural number `n` and for any two elements `i` and `j` of the finite set `Fin n`, if the numerical values of `i` and `j` are equal (denoted by ↑i = ↑j), then `i` and `j` themselves are equal. Essentially, it asserts that distinct elements of a finite set `Fin n` must have distinct numerical values.

For any finite set `Fin n` and all `i`, `j` in `Fin n`, if `i` and `j` have equal numerical values, then `i` and `j` are equal.


theorem PartENat.natCast_lt_top : ∀ (x : ℕ), ↑x < ⊤ := by sorry

This theorem states that for any natural number `x`, the real number representation (`↑x`) of `x` is less than positive infinity (`⊤`). In other words, no matter how large a natural number you have, it will always be less than positive infinity when considered as a real number.

For all natural numbers x, ↑x < ⊤ in the real numbers.


AddFreimanHom.ext

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

This theorem, `AddFreimanHom.ext`, states that for any two Additive Freiman homomorphisms `f` and `g` from a set `A` of a certain type `α` (with `α` being an additive commutative monoid) to another type `β` (also an additive commutative monoid), if `f` and `g` are equal for every element `x` in `α`, then the two homomorphisms `f` and `g` are themselves identical. An Additive Freiman homomorphism here is a function that preserves the additive structure under a certain condition related to the natural number `n`.

If `f` and `g` are Additive Freiman homomorphisms from an additive commutative monoid `α` to another additive commutative monoid `β`, and `f(x) = g(x)` for all `x` in `α`, then `f = g`.


theorem Set.right_mem_Iic : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ Set.Iic a := by sorry

The theorem `Set.right_mem_Iic` asserts that for any type `α` that has a preorder structure, every element `a` of this type is a member of the left-infinite right-closed interval `Set.Iic a`. In other words, `a` is always less than or equal to `a` itself in this ordered type, which is the definition of the interval `Set.Iic a`.

For any type `α` with a preorder structure, every element `a` belongs to the left-infinite right-closed interval `Iic a`.


theorem Mathlib.Algebra.Parity._auxLemma.18 : ∀ {α : Type u_2} [inst : Semiring α], Even 2 = True := by sorry

The theorem `Mathlib.Algebra.Parity._auxLemma.18` asserts that for any type `α` equipped with a semiring structure, the number `2` is Even. In more mathematical terms, it states that there exists some element `r` in the semiring `α` such that `2` is equal to `r + r`.

For any semiring `α`, there exists an element `r` in `α` such that `2 = r + r`.


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

This theorem states that for any two natural numbers `n` and `m`, if neither `n` nor `m` are zero, then their product `n * m` is also not zero. It emphasizes the fact that the multiplication of two non-zero natural numbers will never result in zero.

If two natural numbers are non-zero, their product is also non-zero.


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

The theorem `ENNReal.coe_pos` states that for any nonnegative real number `r` (denoted as `NNReal`), the positivity of the embedding (or "coercion") of `r` into the extended nonnegative real numbers (that is, `0 < ↑r`) is equivalent to the positivity of `r` itself (that is, `0 < r`). In other words, a nonnegative real number `r` is positive if and only if its corresponding extended nonnegative real number is also positive.

The embedding of a non-negative real number into the extended non-negative reals is positive if and only if the original number is positive.


theorem add_right_cancel_iff :
    ∀ {G : Type u_1} [inst : Add G] [inst_1 : IsRightCancelAdd G] {a b c : G}, b + a = c + a ↔ b = c := by sorry

This theorem states that for any type `G` that has an addition operation and the right cancellation property, given any three elements `a`, `b`, and `c` of type `G`, the equation `b + a = c + a` is equivalent to `b = c`. In other words, adding the same element `a` to two elements `b` and `c` in an additive group with right cancelability, if the results are equal, then the original elements `b` and `c` must have been equal to begin with.

In an additive group with right cancellation, if `a`, `b`, and `c` are elements such that `b + a = c + a`, then `b = c`.


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

This theorem states that for any real number `x` that is greater than or equal to 0 and any real number `y`, the square root of the product of `x` and `y` is equal to the product of the square root of `x` and the square root of `y`. In terms of mathematical notation, this theorem is saying that for all $x, y \in \mathbb{R}$ with $x \geq 0$, we have $\sqrt{xy} = \sqrt{x} \cdot \sqrt{y}$.

For any non-negative real numbers x and y, $\sqrt{xy} = \sqrt{x}\sqrt{y}$.


Inseparable.eq

theorem Inseparable.eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T0Space X] {x y : X}, Inseparable x y → x = y := by sorry

The theorem `Inseparable.eq` asserts that for any topological space `X` with a `T0` separation axiom, if two points `x` and `y` in `X` are `Inseparable` — that is, if the neighborhoods of `x` and `y` are the same — then `x` is equal to `y`. This theorem provides a condition under which two points in a `T0` topological space can be proven to be identical, based on the properties of their respective neighborhoods.

In a T0 topological space, if two points have identical neighborhood systems, then they are equal.


theorem Mathlib.Data.Sym.Sym2._auxLemma.1 :
    ∀ {α : Type u_1} {p q : α × α}, Sym2.Rel α p q = (p = q ∨ p = Prod.swap q) := by sorry

This theorem named `Mathlib.Data.Sym.Sym2._auxLemma.1` states that for any type `α`, and for any pairs `p` and `q` of type α (denoted as `p : α × α` and `q : α × α`), the relation `Sym2.Rel α p q` holds if and only if either `p` is equal to `q` or `p` is equal to the swapped version of `q` (as defined by the `Prod.swap` function). In other words, two pairs are considered related under `Sym2.Rel` if they are identical or if one is the swapped version of the other.

The theorem `Mathlib.Data.Sym.Sym2._auxLemma.1` in Lean 4 states that for any type `α`, the binary relation `Sym2.Rel α` on pairs of `α` is an equivalence relation, where two pairs `(p, q)` are related if and only if `p = q` or `p = Swap p q`.


/-- If `P` is a sheaf for `R`, it is separated for `R`.  -/
theorem CategoryTheory.Presieve.IsSheafFor.isSeparatedFor :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R : CategoryTheory.Presieve X},
      CategoryTheory.Presieve.IsSheafFor P R → CategoryTheory.Presieve.IsSeparatedFor P R :=
  by sorry

In the realm of category theory, this theorem states that if a functor `P` is a sheaf for a presieve `R`, then `P` is also separated for `R`. This means that for every family of elements `x` of the presheaf `P`, and for any two amalgamations `t₁` and `t₂` of `x`, if `t₁` and `t₂` are both amalgamations of `x`, then `t₁` must equal `t₂`. In simpler terms, a presheaf that is a sheaf for a given presieve will have at most one amalgamation for each family of elements, making it separated for that presieve.

If `P` is a sheaf for the presieve `R` in category theory, then `P` is separated by `R`, meaning that for every family of elements `x` in `P`, any two amalgamations of `x` are equal.


theorem normalize_eq :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : Unique αˣ] (x : α), normalize x = x := by sorry

The theorem `normalize_eq` states that for any given type `α` that is equipped with a cancel-commutative monoid with a zero element, and a unique invertible element (units), the normalization of any element `x` of type `α` is equal to `x` itself. In other words, for such types `α`, the process of normalization does not change the value of the elements.

For types `α` equipped with a cancel-commutative monoid and units, the normalization of any element `x` is equal to `x`.


Class.ext

theorem Class.ext : ∀ {x y : Class}, (∀ (z : ZFSet), x z ↔ y z) → x = y := by sorry

The theorem `Class.ext` states that for any two classes `x` and `y`, if for every set `z` in the Zermelo-Fraenkel universe of sets (`ZFSet`), `z` belongs to `x` if and only if `z` belongs to `y`, then `x` and `y` are equal. In other words, it states that two classes are equal if they contain exactly the same sets.

If two classes `x` and `y` have the same elements in the Zermelo-Fraenkel universe of sets (`ZFSet`), then `x` is equal to `y`.


theorem Function.iterate_succ_apply : ∀ {α : Type u} (f : α → α) (n : ℕ) (x : α), f^[Nat.succ n] x = f^[n] (f x) := by
  sorry

This theorem states that for any function `f` from a type `α` to itself, for any natural number `n`, and for any element `x` of type `α`, the `(n+1)`-th iteration of the function `f` applied to `x` is equal to the `n`-th iteration of `f` applied to the result of `f` on `x`. In other words, applying `f` `n + 1` times on `x` is the same as applying `f` once on `x` and then applying `f` `n` times on the result.

For any function `f` from a type `α` to itself and any natural number `n` and element `x` of `α`, `f^(n+1)(x) = f(f^n(x))`.


theorem Subtype.image_preimage_val : ∀ {α : Type u_1} (s t : Set α), Subtype.val '' (Subtype.val ⁻¹' t) = s ∩ t := by
  sorry

This theorem states that for any two sets `s` and `t` of a certain type `α`, the image of the preimage of `t` under the function `Subtype.val` is equal to the intersection of `s` and `t`. In other words, if we first find all elements in a subtype whose corresponding elements in `t` satisfy a specific property, and then map these elements back to their original values, we end up with the intersection of the sets `s` and `t`. Here, `Subtype.val` is a function that takes a subtype and returns its underlying element.

For any sets `s` and `t` of type `α`, the image of `s.subtype.map Subtype.val` equals the intersection of `s` and `t`.


theorem Set.Ici_subset_Ioi : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ici a ⊆ Set.Ioi b ↔ b < a := by sorry

The theorem `Set.Ici_subset_Ioi` states that for all types `α` equipped with a preorder, and for all elements `a` and `b` of type `α`, the left-closed right-infinite interval starting from `a` is a subset of the left-open right-infinite interval starting from `b` if and only if `b` is less than `a`. In mathematical terms, this is saying that for all `a` and `b`, the set of all `x` such that `a ≤ x` is contained in the set of all `x` such that `b < x` exactly when `b < a`.

For all preordered types `α` and elements `a` and `b` of `α`, `{x : α | a ≤ x}` is subset of `{x : α | b < x}` if and only if `b < a`.


/-- Cancellation subtracting the results of two subtractions.  -/
theorem vsub_sub_vsub_cancel_right :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ p₂ p₃ : P),
      p₁ -ᵥ p₃ - (p₂ -ᵥ p₃) = p₁ -ᵥ p₂ :=
  by sorry

This theorem, `vsub_sub_vsub_cancel_right`, states that for any three points `p₁`, `p₂`, and `p₃` in a torsor `P` over an additive group `G`, the difference between the subtraction of `p₃` from `p₁` and the subtraction of `p₃` from `p₂` is equal to the subtraction of `p₂` from `p₁`. In mathematical terms, it says that $(p₁ - p₃) - (p₂ - p₃) = p₁ - p₂$. It's a cancellation law for subtraction in the context of torsors.

For any points `p₁`, `p₂`, `p₃` in a torsor `P` over an additive group `G`, the subtraction of `p₂` from `p₁` is equal to the difference between `p₁` and the difference of `p₁` and `p₃`. In symbols, `p₁ - (p₂ - p₃) = p₁ - p₂`.


theorem Fin.succ_le_succ_iff : ∀ {n : ℕ} {a b : Fin n}, Fin.succ a ≤ Fin.succ b ↔ a ≤ b := by sorry

The theorem `Fin.succ_le_succ_iff` states that for any natural number `n` and any two elements `a` and `b` of the finite set `Fin n`, the successor of `a` is less than or equal to the successor of `b` if and only if `a` is less than or equal to `b`. This theorem essentially asserts the preservation of the order relationship under the successor operation in the context of finite sets in Lean 4.

For any natural number `n` and `a, b` in `Fin n`, `a < b` if and only if `succ a < succ b`.


theorem MvPolynomial.bind₁_X_right :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [inst : CommSemiring R] (f : σ → MvPolynomial τ R) (i : σ),
      (MvPolynomial.bind₁ f) (MvPolynomial.X i) = f i :=
  by sorry

The theorem `MvPolynomial.bind₁_X_right` states that for any types `σ`, `τ` and `R` where `R` has an instance of `CommSemiring`, for any function `f` mapping from `σ` to multivariate polynomials of `τ` and `R`, and for any `i` in `σ`, applying the "binding" operation `bind₁` on `f` and the degree `1` monomial `X_i` (represented by `MvPolynomial.X i`) results in the function `f` evaluated at `i`. Essentially, this theorem says that binding a multivariate polynomial function to a degree `1` monomial is equivalent to evaluating the function at the point represented by the monomial.

For any type `σ`, `τ`, and commutative semiring `R`, and any function `f` mapping from `σ` to multivariate polynomials of `τ` and `R`, `bind₁(f) X_i = f i`, where `X_i` is the degree 1 monomial in the i-th variable and `bind₁` is the binding operation.


theorem Filter.EventuallyEq.comp₂ :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} {f f' : α → β} {g g' : α → γ} {l : Filter α},
      f =ᶠ[l] f' → ∀ (h : β → γ → δ), g =ᶠ[l] g' → (fun x => h (f x) (g x)) =ᶠ[l] fun x => h (f' x) (g' x) :=
  by sorry

This theorem, `Filter.EventuallyEq.comp₂`, is about function composition and equality with respect to a filter. It states that for all types `α`, `β`, `γ`, and `δ`, and all functions `f`, `f'`, `g`, `g'` from `α` to `β` and `α` to `γ` respectively, and a filter `l` on `α`, if `f` is eventually equal to `f'` at filter `l`, and `g` is also eventually equal to `g'` at the same filter `l`, then the function which takes two arguments and applies `h` to `f` of the first and `g` of the second is eventually equal to the function which applies `h` to `f'` of the first and `g'` of the second at filter `l`. Essentially, this tells us about the preservation of eventual equality under the composition of binary functions.

Given filters `l` on types `α`, functions `f : α -> β`, `f' : α -> β`, `g : α -> γ`, and `g' : α -> γ`, if `f` is eventually equal to `f'` at filter `l`, and `g` is eventually equal to `g'` at filter `l`, then the composition `h . (f &&& g)` is eventually equal to `h . (f' &&& g')` at filter `l`, for any function `h : β -> γ`.


theorem Complex.ofReal_sinh : ∀ (x : ℝ), ↑(Real.sinh x) = Complex.sinh ↑x := by sorry

This theorem states that for every real number `x`, the complex number equivalent of the real hyperbolic sine of `x` (i.e., `↑(Real.sinh x)`) is equal to the complex hyperbolic sine of the complex number equivalent of `x` (i.e., `Complex.sinh ↑x`). In other words, the real hyperbolic sine function, when extended to complex numbers, behaves the same as the complex hyperbolic sine function. This theorem serves to bridge the behaviors of the hyperbolic sine function in real and complex domains.

The real hyperbolic sine function and the complex hyperbolic sine function agree, i.e., `Complex.sinh ↑x = ↑(Real.sinh x)` for all real numbers `x`.


theorem GaloisConnection.l_sSup :
    ∀ {α : Type u} {β : Type v} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {s : Set α}, l (sSup s) = ⨆ a ∈ s, l a :=
  by sorry

This theorem states that for any two types `α` and `β` which are complete lattices, and for any pair of functions `l` from `α` to `β` and `u` from `β` to `α` that form a Galois connection, the application of `l` to the supremum of any set `s` of type `α` is equal to the supremum of the set obtained by applying `l` to each element of `s`. In other words, under a Galois connection, the function `l` preserves the supremum operation from the lattice of `α` to the lattice of `β`.

Given complete lattices `α` and `β`, and a Galois connection between functions `l: α → β` and `u: β → α`, the supremum of `l` applied to a set `s ⊆ α` equals the application of `l` to the set `{l(x) | x ∈ s} ⊆ β`.


theorem MvPolynomial.eval₂_mul :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      {q : MvPolynomial σ R} (f : R →+* S₁) (g : σ → S₁) {p : MvPolynomial σ R},
      MvPolynomial.eval₂ f g (p * q) = MvPolynomial.eval₂ f g p * MvPolynomial.eval₂ f g q :=
  by sorry

The theorem `MvPolynomial.eval₂_mul` states that for any commutative semirings `R` and `S₁` with `f` being a ring homomorphism from `R` to `S₁` and `g` being a function from the index set of the variables to `S₁`, for any multivariate polynomials `p` and `q` over `R`, the evaluation of the product `p * q` using the evaluation function `eval₂` is equal to the product of the evaluations of `p` and `q` individually. In other words, the evaluation function `eval₂` preserves multiplication of multivariate polynomials.

For any commutative semirings R and S₁, ring homomorphism f from R to S₁, and multivariate polynomials p and q over R, we have eval₂(p * q) = eval₂(p) * eval₂(q).


theorem Finset.card_union_add_card_inter :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).card + (s ∩ t).card = s.card + t.card := by sorry

This theorem states that for any type `α` with a decidable equality relation, and any two finite sets `s` and `t` of this type, the cardinality of the union of `s` and `t` plus the cardinality of the intersection of `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. This is essentially a restatement of the principle of inclusion-exclusion in set theory.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, the cardinality of `s ∪ t` is equal to the cardinality of `s` plus the cardinality of `t` minus the cardinality of `s ∩ t`.


theorem Int.mul_ediv_cancel_left : ∀ {a : ℤ} (b : ℤ), a ≠ 0 → a * b / a = b := by sorry

This theorem states that for all integer values `a` and `b`, as long as `a` is not zero, the result of multiplying `a` and `b` and then dividing by `a` is equal to `b`. This is a representation of the fundamental property of division, where multiplying a number by another number and then dividing it by the original number should yield the multiplied number, assuming the divisor is not zero.

For all integers `a` and `b` with `a ≠ 0`, `(a * b) / a = b`.


theorem mul_one_div : ∀ {G : Type u_3} [inst : DivInvMonoid G] (x y : G), x * (1 / y) = x / y := by sorry

This theorem states that for any type `G` that has a `DivInvMonoid` instance (a type with division and inversion operations that obey certain laws), for any two elements `x` and `y` of this type, the result of multiplying `x` by the reciprocal of `y` (denoted as `1 / y`) is equal to the division of `x` by `y` (denoted as `x / y`).

For any type `G` with a `DivInvMonoid` instance, `x / y = x * (1 / y)`.