theorem Set.preimage_compl : ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β}, f ⁻¹' sᶜ = (f ⁻¹' s)ᶜ := by sorry

The theorem `Set.preimage_compl` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a set `s` of type `β`, the preimage of the complement of `s` under `f` is equal to the complement of the preimage of `s` under `f`. In mathematical terms, if $f : α → β$ and $S$ is a subset of $β$, then $f^{-1}(S^c) = (f^{-1}(S))^c$. Here, $f^{-1}(S)$ denotes the preimage of $S$ under $f`, $S^c$ denotes the complement of $S$, and $f^{-1}(S^c)$ and $(f^{-1}(S))^c$ are sets of elements from `α`.

For any function $f : α → β$ and set $S$ of type $β$, the preimage of the complement of $S$ under $f$ is equal to the complement of the preimage of $S$ under $f$: $f^{-1}(S^c) = (f^{-1}(S))^c$.


Subtype.forall

theorem Subtype.forall :
    ∀ {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop},
      (∀ (x : { a // p a }), q x) ↔ ∀ (a : α) (b : p a), q { val := a, property := b } :=
  by sorry

This theorem, `Subtype.forall`, states a property about subtypes in Lean. In detail, for any type `α`, a predicate `p` on `α`, and a predicate `q` on subtypes `{ a // p a }` (i.e., elements of `α` that satisfy `p`), it asserts that the statement "for all elements `x` of the subtype `{ a // p a }`, `q` is true on `x`" is equivalent to the statement "for all elements `a` of the type `α`, if `a` satisfies `p` (denoted by `b : p a`), then `q` is true on the element `{ val := a, property := b }` of the subtype". Here, `{ val := a, property := b }` is the explicit construction of an element of the subtype `{ a // p a }` from `a : α` and `b : p a`.

For any type α, predicate p on α, and subtype { a // p a }, the property "for all x in { a // p a }, q(x) holds" is equivalent to "for all a in α, if p(a) holds then q({ val := a, property := p a }) holds".


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

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then the result of `n - m` equals 0. In mathematical terms, it asserts that for all `n, m` in the set of natural numbers ℕ, if `n ≤ m`, then `n - m = 0`. In essence, it captures the mathematical fact that subtracting a larger number from a smaller or equal one in the set of natural numbers yields zero.

For all natural numbers `n` and `m`, if `n ≤ m`, then `n - m = 0`.


theorem Metric.uniformity_basis_dist :
    ∀ {α : Type u} [inst : PseudoMetricSpace α],
      Filter.HasBasis (uniformity α) (fun ε => 0 < ε) fun ε => {p | dist p.1 p.2 < ε} :=
  by sorry

The theorem `Metric.uniformity_basis_dist` states that for any type `α` that is a `PseudoMetricSpace`, the uniformity (which is a filter on the product space `α × α`) has a basis consisting of sets of pairs `(x, y)` where the distance `dist` between `x` and `y` is less than some positive real number `ε`. This means that any set in the uniformity can be generated as a union of these basic sets, and these sets themselves are indexed by the positive real numbers. This provides a bridge between the abstract uniformity filter and the concrete metric `dist`.

For any PseudoMetricSpace `α`, the basis of its uniformity consists of sets of pairs `(x, y)` with distance `dist(x, y)` less than some positive real `ε`.


theorem Countable.of_equiv : ∀ {β : Sort v} (α : Sort u_1) [inst : Countable α], α ≃ β → Countable β := by sorry

This theorem, `Countable.of_equiv`, states that for any two types `α` and `β`, if `α` is countable and there exists a bijective function (an equivalence) between `α` and `β`, then `β` is also countable. In other words, the countability of a type is preserved under bijective mappings. Here, countability refers to the property that there exists a surjective function from the natural numbers to the given type.

If `α` is a countable type and there exists a bijective function between `α` and `β`, then `β` is also countable.


theorem eq_neg_of_add_eq_zero_left : ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, a + b = 0 → a = -b := by
  sorry

This theorem states that for any type `G` that is a subtraction monoid, and any two elements `a` and `b` of this type, if the sum of `a` and `b` equals zero, then `a` is equal to the negation of `b`. This theorem thus represents the property of additive inverses in a subtraction monoid, a structure that has an operation akin to subtraction.

If `G` is a subtraction monoid and `a`, `b` ∈ `G` satisfy `a + b = 0`, then `a = -b`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.21 : ∀ {r : NNReal}, (↑r = 0) = (r = 0) := by sorry

This theorem states that for all non-negative real numbers `r` (denoted as `NNReal`), the condition of `r` being equal to zero in its natural number embedding (notated as `↑r`) is equivalent to `r` being equal to zero. In other words, a non-negative real number `r` is zero if and only if its corresponding natural number is zero.

For every non-negative real number `r`, `↑r = 0` if and only if `r = 0`.


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

This theorem states that for any type `α` and any two sets `s` and `t` of this type, if `t` is a subset of `s` (written as `t ⊆ s`), then the intersection of `s` and `t` is equal to `t`. This means that when `t` is a subset of `s`, all elements of `t` are also elements of `s` and thus, all elements that are in both `s` and `t` are precisely the elements of `t`.

For any type `α` and sets `s` and `t` of this type, if `t` is a subset of `s` (`t ⊆ s`), then `s ∩ t = t`.


/-- Projection of `Set.Finite` to its `Finite` instance.
This is intended to be used with dot notation.
See also `Set.Finite.Fintype` and `Set.Finite.nonempty_fintype`.  -/
theorem Set.Finite.to_subtype : ∀ {α : Type u} {s : Set α}, Set.Finite s → Finite ↑s := by sorry

This theorem states that for any set `s` of a certain type `α`, if `s` is finite (as defined by `Set.Finite`), then the subtype corresponding to `s` (denoted by `↑s`) is also finite. This projection of `Set.Finite` to its `Finite` instance is designed for use with dot notation. The theorem also refers to two other concepts, `Set.Finite.Fintype` and `Set.Finite.nonempty_fintype`, for further exploration.

If `s` is a finite set of type `α` in Lean, then the subtype `↑s` is also a finite set.


Filter.Tendsto.sub

theorem Filter.Tendsto.sub :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G] {f g : α → G}
      {l : Filter α} {a b : G},
      Filter.Tendsto f l (nhds a) →
        Filter.Tendsto g l (nhds b) → Filter.Tendsto (fun x => f x - g x) l (nhds (a - b)) :=
  by sorry

This theorem, `Filter.Tendsto.sub`, states that for any types `G` and `α`, where `G` is a topological space with subtraction operation and this subtraction operation is continuous, if we have two functions `f` and `g` from `α` to `G`, a filter `l` on `α`, and two elements `a` and `b` in `G`, such that `f` tends to `a` and `g` tends to `b` with respect to the filter `l` (i.e., for any neighborhood of `a` or `b`, the preimage under `f` or `g` respectively is a neighborhood in the filter `l`), then the function that takes `x` to `f(x) - g(x)` tends to `a - b` with respect to the filter `l`. In simpler terms, if `f` and `g` both converge to `a` and `b` respectively under the filter `l`, then the difference of `f` and `g` also converges to the difference of `a` and `b` under the same filter. This is an encapsulation of the basic property of limits where the limit of the difference of two functions is the difference of the limits, provided both limits exist.

Given topological spaces G with continuous subtraction, functions f and g from type α to G, and filter l on α such that f tends to a and g tends to b with respect to l, then f - g tends to a - b with respect to l.


theorem le_csInf :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α},
      Set.Nonempty s → (∀ b ∈ s, a ≤ b) → a ≤ sInf s :=
  by sorry

The theorem `le_csInf` states that for any type `α` that is a conditionally complete lattice, and any set `s` of type `α`, and any element `a` of type `α`, if the set `s` is not empty, and all elements `b` in `s` satisfy the property that `a` is less than or equal to `b`, then `a` is less than or equal to the infimum of the set `s`.

In other words, this theorem states that if we have a non-empty set within a conditionally complete lattice, and some element is less than or equal to all elements of this set, then this element is also less than or equal to the greatest lower bound (infimum) of this set.

If `α` is a conditionally complete lattice, `s ≠ ∅` is a set of `α`, and `a ≤ b` for all `b ∈ s`, then `a ≤ ∧ b ∈ s`.


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

This theorem states that for any two natural numbers `n` and `m`, if `n` and `m` are both greater than 0, then the result of subtracting `m` from `n` is less than `n`. This corresponds to the intuitive understanding that subtracting a positive number from another positive number results in a smaller number.

For all natural numbers `n` and `m` greater than 0, `n` > `m` implies `n` - `m` < `n`.


theorem SetTheory.PGame.equiv_rfl : ∀ {x : SetTheory.PGame}, x ≈ x := by sorry

This theorem states that for any given PGame `x` in Set Theory, `x` is equivalent to itself. In other words, it establishes the reflexivity of equivalence (`≈`) for PGames, confirming that any PGame is always considered equivalent to itself. This is a fundamental property of equivalence relations in mathematics.

For any PGame x in Set Theory, x ≈ x holds. (Reflexivity of equivalence for PGames)


theorem Int.add_assoc : ∀ (a b c : ℤ), a + b + c = a + (b + c) := by sorry

This theorem, `Int.add_assoc`, states that for all integers `a`, `b`, and `c`, the operation of addition is associative. In other words, for any integers `a`, `b`, and `c`, the sum of `a`, `b`, and `c` remains the same regardless of how the numbers are grouped. This is written formally in mathematics as `a + b + c = a + (b + c)`.

The theorem `Int.add_assoc` asserts that for all integers `a`, `b`, and `c`, the association of addition is valid, that is, `(a + b) + c = a + (b + c)`.


Quotient.eq

theorem Quotient.eq : ∀ {α : Sort u_1} [r : Setoid α] {x y : α}, ⟦x⟧ = ⟦y⟧ ↔ x ≈ y := by sorry

This theorem, `Quotient.eq`, states that for any type `α` with a given setoid relation `r`, and any two elements `x` and `y` of type `α`, the equivalence class of `x` is equal to the equivalence class of `y` if and only if `x` is related to `y` by the setoid relation `r`. In other words, two elements are in the same equivalence class under a setoid relation if and only if they are related by that setoid relation.

For any setoid type `α` and elements `x` and `y` of type `α`, their equivalence classes under the setoid relation `r` are equal if and only if `x` is related to `y` by `r`.


ContinuousOn.comp

theorem ContinuousOn.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {g : β → γ} {f : α → β} {s : Set α} {t : Set β},
      ContinuousOn g t → ContinuousOn f s → Set.MapsTo f s t → ContinuousOn (g ∘ f) s :=
  by sorry

This theorem states that for three topological spaces `α`, `β`, and `γ`, if a function `g` from `β` to `γ` is continuous on a set `t`, and another function `f` from `α` to `β` is continuous on a set `s`, and if `f` maps `s` into `t`, then the composition of `g` and `f` (denoted `g ∘ f`) is continuous on the set `s`. This is a composition result regarding the continuity of functions on topological spaces.

If functions `f: α → β` and `g: β → γ` are continuous on sets `s subseteq α` and `t subseteq β`, respectively, and `f(s) subseteq t`, then the composition `g ∘ f` is continuous on `s`.


theorem continuous_mul_left :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M] (a : M),
      Continuous fun b => a * b :=
  by sorry

This theorem states that for any type `M` that has a topological space structure, a multiplication operation, and a continuous multiplication operation, multiplying a fixed element `a` of type `M` on the left side with any other element `b` of `M` is a continuous operation. In other words, the map `b ↦ a*b` is continuous in the topology of `M`.

For any topological space `M` with a multiplication operation and a continuous multiplication, the left multiplication by a fixed element `a` is a continuous operation.


theorem WithBot.some_le_some : ∀ {α : Type u_1} {a b : α} [inst : LE α], some a ≤ some b ↔ a ≤ b := by sorry

This theorem, "WithBot.some_le_some", states that for any type 'α' and any two elements 'a' and 'b' of that type, given that the type 'α' has a less than or equal to (≤) relation defined, 'some a' is less than or equal to 'some b' if and only if 'a' is less than or equal to 'b'. "WithBot" is a type constructor that adds a bottom element to a given type, and "some" is a constructor that embeds elements of the original type into the WithBot type. The theorem essentially establishes that the order relation is preserved under this embedding.

For any type with a ≤ relation, the embedding of elements into the type WithBot with bottom element preserves the order relation: i.e., a ≤ b if and only if some a ≤ some b.


theorem Finset.map_refl : ∀ {α : Type u_1} {s : Finset α}, Finset.map (Function.Embedding.refl α) s = s := by sorry

The theorem `Finset.map_refl` states that for any type `α` and for any finite set `s` of type `α`, mapping `s` with the identity function, which is an embedding from `α` to `α`, will return `s` itself. In other words, applying the identity function to each element of the finite set doesn't change the set.

For any finite set `s` of type `α`, the application of the identity function `id : α → α` to every element of `s` results in `s` itself, i.e., `id '' s = s`.


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

This theorem states that for any semiring `R` and any semiring `S`, given a ring homomorphism `f` from `R` to `S` and an element `x` of `S`, the evaluation of the polynomial `X` (the polynomial variable or indeterminate) in `S` using the evaluation map `eval₂` with `f` and `x` is equal to `x` itself. In other words, it says that substituting the indeterminate in the polynomial `X` with a value `x` from the semiring `S` results in that value `x`.

For any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, and any element `x` in `S`, the evaluation of the polynomial `X` in `S` using `eval₂` with `f` and `x` equals `x`.


theorem Nat.cast_injective :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R], Function.Injective Nat.cast := by sorry

The theorem `Nat.cast_injective` states that for any type `R`, given that `R` is an `AddMonoidWithOne` and has a `CharZero` structure, the function that casts a natural number to `R` is injective. In other words, if two natural numbers are equal after being cast to `R`, then they were originally the same natural number. This theorem asserts that casting doesn't cause any ambiguity or loss of information in the context of natural numbers and the type `R` with the given structures.

For types `R` endowed with an `AddMonoidWithOne` and `CharZero` structure, the function that casts natural numbers to `R` is an injection.


IsOpen.prod

theorem IsOpen.prod :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {t : Set Y},
      IsOpen s → IsOpen t → IsOpen (s ×ˢ t) :=
  by sorry

The theorem `IsOpen.prod` states that for any two types `X` and `Y` with their respective topological spaces, if `s` is an open set in the topological space of `X` and `t` is an open set in the topological space of `Y`, then the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is also an open set in the product topological space. This theorem extends the concept of open sets to product spaces in topology.

The Cartesian product of two open sets in the product topology is an open set.


theorem Nat.minFac_dvd : ∀ (n : ℕ), Nat.minFac n ∣ n := by sorry

The theorem `Nat.minFac_dvd` states that for all natural numbers `n`, the smallest prime factor of `n` (obtained using the `Nat.minFac` function) will always divide `n` without leaving a remainder. This is equivalent to saying that the natural number `n` is divisible by its smallest prime factor.

The smallest prime factor of a natural number `n` (as given by `Nat.minFac`) divides `n`.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.2 :
    ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) := by sorry

This theorem states that for any type `α` that has a preorder structure, and for any three elements `a`, `b`, and `x` of this type, `x` belongs to the left-closed right-open interval from `a` to `b` if and only if `x` is greater than or equal to `a` and less than `b`. In other words, it asserts the membership rule for the left-closed right-open interval `[a, b)`.

For any preorder type `α`, an element `x` belongs to the left-closed right-open interval [`a`, `b`) if and only if `a ≤ x < b`.


/-- The pointwise distance is controlled by the distance between functions, by definition.  -/
theorem BoundedContinuousFunction.dist_coe_le_dist :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      {f g : BoundedContinuousFunction α β} (x : α), dist (f x) (g x) ≤ dist f g :=
  by sorry

This theorem states that for any two bounded continuous functions `f` and `g` from a topological space `α` to a pseudo metric space `β`, and for any point `x` in the topological space `α`, the distance between the function values `f(x)` and `g(x)` in the pseudo metric space `β` is always less than or equal to the distance between the functions `f` and `g` themselves. This is essentially expressing that the pointwise distance between the function values is controlled by the overall distance between the functions.

For any bounded continuous functions `f` and `g` from a topological space `α` to a pseudo metric space `β` and any `x` in `α`, we have `d(f(x), g(x)) ≤ d(f, g)` in the pseudo metric space `β`, where `d` denotes the distance functions.


theorem Init.Data.Nat.Basic._auxLemma.2 : ∀ (n : ℕ), (n ≤ n) = True := by sorry

This theorem, `Init.Data.Nat.Basic._auxLemma.2`, asserts that for any natural number `n`, the statement that `n` is less than or equal to `n` is always true. This is a fundamental property of the ordering of natural numbers, stating that every number is always less than or equal to itself.

For every natural number `n`, `n` is a lower bound of the relation `≤` on natural numbers, i.e., `n ≤ n` always holds.


theorem add_div : ∀ {α : Type u_1} [inst : DivisionSemiring α] (a b c : α), (a + b) / c = a / c + b / c := by sorry

This theorem, named `add_div`, states that for any type `α` which is a DivisionSemiring, and for any three elements `a`, `b`, and `c` of this type, the operation of dividing the sum of `a` and `b` by `c` is equivalent to the sum of `a` divided by `c` and `b` divided by `c`. In mathematical notations, it states that $(a + b) / c = a / c + b / c$ for all `a`, `b`, and `c` in type `α`. This theorem captures the fact that division distributes over addition in a DivisionSemiring.

In a DivisionSemiring, the division of the sum of two elements by a third element is equivalent to the sum of their individual divisions by that element. $(a + b) / c = a / c + b / c$ for all $a, b, c$ in the type $\alpha$.


theorem Mathlib.Algebra.Group.Units._auxLemma.31 : ∀ {M : Type u_1} [inst : Monoid M], IsUnit 1 = True := by sorry

This theorem states that for any type `M` that has a `Monoid` structure, the multiplicative identity element `1` is a unit. This means that `1` has a two-sided inverse in the `Monoid` `M`. In other words, there exists an element in `M` which when multiplied with `1` gives `1` again. This holds true for any `Monoid` structure.

For any type `M` equipped with a `Monoid` structure, the multiplicative identity `1` is a unit with a two-sided inverse in `M`.


Sigma.eta

theorem Sigma.eta : ∀ {α : Type u_1} {β : α → Type u_4} (x : (a : α) × β a), { fst := x.fst, snd := x.snd } = x := by
  sorry

This theorem, named `Sigma.eta`, states that for all types `α` and a type family `β` dependent on `α`, any dependent pair `(a : α) × β a` is equal to the pair constructed by explicitly taking its first and second components. In other words, if you take a dependent pair and then reassemble it using its own components, you get the original pair back.

For all types `α` and type families `β` dependent on `α`, the dependent pair operation is equal to the projection function composition on `α × β`.


theorem ArithmeticFunction.map_zero : ∀ {R : Type u_1} [inst : Zero R] {f : ArithmeticFunction R}, f 0 = 0 := by sorry

The theorem `ArithmeticFunction.map_zero` states that for any type `R` that has a zero element, and any arithmetic function `f` mapping from natural numbers to `R`, the value of `f` at 0 is always the zero element of `R`. In more mathematical terms, if `f` is an arithmetic function, `f(0) = 0`.

For any arithmetic function `f` and type `R` with a zero element, `f(0) = 0`.


Set.BijOn.surjOn

theorem Set.BijOn.surjOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.SurjOn f s t := by sorry

This theorem states that for any two types `α` and `β`, and any sets `s` in `α` and `t` in `β`, if a function `f` from `α` to `β` is bijective on `s` to `t`, then the function `f` is also surjective from `s` to `t`. In other words, if a function `f` is both injective on `s` (every element of `s` maps to a unique element of `t`) and its image equals `t` (every element of `t` comes from an element of `s`), then every element of `t` definitely comes from an element of `s`, which is the definition of surjectivity. The proof is not shown here.

If a function between two types is bijective on two sets, then it is surjective on one set onto the other.


AddAction.injective

theorem AddAction.injective :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α),
      Function.Injective fun x => g +ᵥ x :=
  by sorry

The theorem `AddAction.injective` states that for all types `α` and `β`, where `α` is an additive group and `β` is a set on which `α` acts additively, given any element `g` of type `α`, the function that adds `g` to an element `x` in `β` is injective. In other words, if `g +ᵥ x₁ = g +ᵥ x₂` then `x₁ = x₂`. This theorem ensures that additive actions preserve distinctness: different elements of the set will not be mapped to the same element by the additive action.

For any additive group α and set β on which α acts additively, the function that maps x in β to g + x is injective for all g in α.


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

The theorem `Equiv.swap_apply_left` states that for any type `α` with decidable equality and any two elements `a` and `b` of `α`, applying the permutation that swaps `a` and `b` to `a` results in `b`. In other words, when we have a permutation that exchanges `a` and `b` and leaves other values unchanged, applying this permutation to `a` will give us `b`.

For any type `α` with decidable equality and any `a, b : α`, swapping `a` and `b` yields `b` when `a` is permuted.


theorem Function.injective_id : ∀ {α : Sort u₁}, Function.Injective id := by sorry

The theorem `Function.injective_id` states that, for every type `α` in some universe `u₁`, the identity function on that type (denoted by `id` in Lean 4) is injective. This means that if `id x = id y` for any two elements `x` and `y` of `α`, it must be the case that `x = y`. In other words, the identity function on any type does not map distinct elements to the same element.

For any type `α`, the identity function `id` is a injective function, that is, for all `x` and `y` in `α`, `id x = id y` implies `x = y`.


Monotone.monotoneOn

theorem Monotone.monotoneOn :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ (s : Set α), MonotoneOn f s :=
  by sorry

The theorem `Monotone.monotoneOn` states that for any types `α` and `β` that have a preorder relation, and for any function `f` from `α` to `β`, if `f` is monotone (i.e., for all `a, b` in `α`, if `a ≤ b` then `f(a) ≤ f(b)`), then `f` is also monotone on any set `s` of elements of `α`. In other words, for all `a, b` in `s`, if `a ≤ b` then `f(a) ≤ f(b)`. That is, the global property of monotonicity for a function implies its local property of monotonicity on any subset of its domain.

If `f` is a monotone function between preordered types `α` and `β`, then `f` is monotone on any subset `s` of `α`.


theorem Mathlib.Algebra.Module.Submodule.Basic._auxLemma.6 :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M), (0 ∈ p) = True :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `M`, and any `R`-module structure on `M`, zero is an element of any submodule `p` of `M`. In other words, the submodule of a module over a semiring always contains the zero element.

For any semiring `R`, any additive commutative monoid `M` with an `R`-module structure, every submodule `p` of `M` contains the additive identity `0` of `M`.


theorem Polynomial.natDegree_eq_of_degree_eq_some :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      Polynomial.degree p = ↑n → Polynomial.natDegree p = n :=
  by sorry

This theorem states that for any polynomial `p` over a semiring `R`, if the degree of `p` (which could be `⊥` for the zero polynomial) is equal to `n` (where `n` is a natural number represented in the lifting of natural numbers to include `⊥`), then the natural degree of `p` (which forces the degree of `p` to natural numbers by setting the degree of the zero polynomial to `0`) is also `n`. In other words, if the degree of the polynomial, which could be potentially undefined (in the case of the zero polynomial), is defined and equal to `n`, then the natural degree, which is always defined, is also `n`.

For any polynomial `p` over a semiring `R` with degree `n`, the natural degree of `p` equals `n`.


CategoryTheory.Limits.Cocone.w

theorem CategoryTheory.Limits.Cocone.w :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      (c : CategoryTheory.Limits.Cocone F) {j j' : J} (f : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp (F.map f) (c.ι.app j') = c.ι.app j :=
  by sorry

The theorem `CategoryTheory.Limits.Cocone.w` states that for any category `J` and another category `C` along with a functor `F` from `J` to `C` and a cocone `c` of `F`, for any two objects `j` and `j'` in `J` and a morphism `f` from `j` to `j'`, the composition of `F` mapping `f` and the application of `c.ι.app` to `j'` is equal to the application of `c.ι.app` to `j`. Essentially, this theorem asserts the commutativity of a diagram in the category theory context, specifically involving the cocone structure.

For any functor F from category J to C and a cocone c over F, the composition of F(f) and c.ι.app for any morphism f in J is equal to c.ι.app applied to the source of f.


theorem inf_le_inf_left : ∀ {α : Type u} [inst : SemilatticeInf α] (a : α) {b c : α}, b ≤ c → a ⊓ b ≤ a ⊓ c := by sorry

This theorem is stating that for any type `α` which forms a semilattice with the infimum operation, given three elements (say `a`, `b`, `c`) of type `α`, if `b` is less than or equal to `c`, then the infimum (greatest lower bound) of `a` and `b` is less than or equal to the infimum of `a` and `c`. Here, `SemilatticeInf α` implies that the type `α` has an associative, commutative, and idempotent infimum (binary operation).

For any semilattice `α` with infimum operation, if `b` is less than or equal to `c` in `α`, then the infimum of `a`, `b` is less than or equal to the infimum of `a` and `c`.


theorem ContinuousMap.coe_add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Add β]
      [inst_3 : ContinuousAdd β] (f g : C(α, β)), ⇑(f + g) = ⇑f + ⇑g :=
  by sorry

The theorem `ContinuousMap.coe_add` states that for any two continuous maps `f` and `g` from a topological space `α` to another topological space `β` (which also has an addition operation and where the addition operation is continuous), the pointwise addition of `f` and `g` is the same as their continuous sum. In other words, the coe function applied to the sum of `f` and `g` (`⇑(f + g)`) equals the sum of the coe function applied to `f` and `g` separately (`⇑f + ⇑g`). Here, the `coe` notation refers to the coercion of continuous maps to their pointwise function counterparts.

For continuous maps $f$ and $g$ from topological space $\alpha$ to a topological space $\beta$ with a continuous addition operation, the pointwise addition of $f$ and $g$ equals their continuous sum: $f + g = \operatorname{coe}(f + g) = \operatorname{coe}(f) + \operatorname{coe}(g)$.


theorem Complex.I_mul_I : Complex.I * Complex.I = -1 := by sorry

This theorem states that the product of the complex imaginary unit with itself equals negative one. In terms of complex numbers, this can be written as `i * i = -1` where `i` stands for the imaginary unit and is represented as `Complex.I` in Lean 4. This is a fundamental property of the imaginary unit in the field of complex numbers.

The square of the imaginary unit `Complex.I` in the complex numbers equals negative one, `i * i = -1`.


/-- Ring homomorphisms preserve subtraction.  -/
theorem RingHom.map_sub :
    ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocRing α] [inst_1 : NonAssocRing β] (f : α →+* β) (x y : α),
      f (x - y) = f x - f y :=
  by sorry

This theorem states that ring homomorphisms preserve the operation of subtraction. Specifically, for any two types, `α` and `β`, that form non-associative rings, any ring homomorphism `f : α →+* β` maps the subtraction of any two elements in `α` to the subtraction of their images in `β`. In other words, for all `x` and `y` in `α`, applying the homomorphism to `x - y` results in `f(x) - f(y)` in `β`.

For any non-associative ring homomorphism `f : α →+* β`, `f(x - y) = f(x) - f(y)` for all `x, y ∈ α`.


theorem uniformContinuous_fst :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β], UniformContinuous fun p => p.1 :=
  by sorry

The theorem `uniformContinuous_fst` states that for any two types `α` and `β` that have UniformSpace instances, the function that takes a pair `p` to its first component `p.1` is uniformly continuous. In other words, if two pairs `(x1, y1)` and `(x2, y2)` are sufficiently close in the UniformSpace of pairs `(α, β)`, then the first components `x1` and `x2` are also sufficiently close in the UniformSpace of `α`.

If `(α, β)` is a uniform space and `f : α × β → α` is the projection function taking `(x, y)` to `x`, then `f` is uniformly continuous.


theorem Cardinal.aleph0_le_mk : ∀ (α : Type u) [inst : Infinite α], Cardinal.aleph0 ≤ Cardinal.mk α := by sorry

The theorem `Cardinal.aleph0_le_mk` states that for every type `α` that is infinite, the smallest infinite cardinal number, `ℵ₀` (aleph null), is less than or equal to the cardinality of the type `α`. The cardinality of a type is a measure of the "size" of the type, or the number of elements it contains. Hence, this theorem essentially states that any infinite type has a cardinality at least as large as `ℵ₀`.

For every infinite type `α`, the cardinality of `α` is greater than or equal to the smallest infinite cardinal number `ℵ₀`. (Note that the theorem in Lean actually states that `ℵ₀` is less than or equal to the cardinality of `α`, which is the negative of the statement you provided.)


/-- The angle at a point does not depend on the order of the other two
points.  -/
theorem EuclideanGeometry.angle_comm :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] (p1 p2 p3 : P),
      EuclideanGeometry.angle p1 p2 p3 = EuclideanGeometry.angle p3 p2 p1 :=
  by sorry

The theorem `EuclideanGeometry.angle_comm` states that the angle at a point in a Euclidean space does not depend on the order of the other two points. That is, given any three points `p1`, `p2`, and `p3` in such a space, the angle at `p2` between the line segments to `p1` and `p3` is the same as the angle at `p2` between the line segments to `p3` and `p1`. This can be denoted mathematically as `∠ p1 p2 p3 = ∠ p3 p2 p1`. This theorem is related to the concept of symmetry in Euclidean geometry.

The angle between two line segments in a Euclidean space, determined by their endpoints, is symmetric with respect to the order of the endpoints.


theorem MeasureTheory.ae_restrict_of_ae :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {p : α → Prop},
      (∀ᵐ (x : α) ∂μ, p x) → ∀ᵐ (x : α) ∂μ.restrict s, p x :=
  by sorry

This theorem, named `MeasureTheory.ae_restrict_of_ae`, states that for any type `α`, any measurable space `m0` of type `α`, any measure `μ` of type `α`, any set `s` of type `α`, and any property `p` applicable to `α`, if `p` holds almost everywhere (i.e., outside a set of measure zero) with respect to measure `μ`, then `p` also holds almost everywhere with respect to the measure `μ` restricted to set `s`. In other words, restricting the measure to a subset does not affect the almost everywhere validity of a property.

If a property holds almost everywhere with respect to a measure on a set, then it also holds almost everywhere with respect to the measure restricted to that set.


IsClosed.isCompact

theorem IsClosed.isCompact :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} [inst_1 : CompactSpace X], IsClosed s → IsCompact s := by
  sorry

This theorem states that for any type `X` which has a topological space structure and a set `s` of `X` elements, if `X` has a compact space structure and the set `s` is closed, then the set `s` is also compact. Compactness here is defined in terms of filters: a set is compact if for any nontrivial filter that contains the set, there exists an element in the set such that every set of the filter intersects every neighborhood of that element.

If `X` is a compact topological space and `s` is a closed subset of `X`, then `s` is compact.


theorem uniformContinuous_snd :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β], UniformContinuous fun p => p.2 :=
  by sorry

The theorem `uniformContinuous_snd` states that for any types `α` and `β` both equipped with a uniform space structure, the function that maps any pair `(a, b)` to its second component `b` is uniformly continuous. In other words, as the pair `(a, b)` in `α × β` becomes arbitrarily close to another pair `(a', b')`, the corresponding second components `b` and `b'` become arbitrarily close to each other, regardless of the specific location of `(a, b)` and `(a', b')` within `α × β`.

Given uniform spaces `(α, δα)` and `(β, δβ)`, the projection function `π₂ : α × β → β` is uniformly continuous.


theorem Nat.card_eq_zero_of_infinite : ∀ {α : Type u_1} [inst : Infinite α], Nat.card α = 0 := by sorry

The theorem `Nat.card_eq_zero_of_infinite` states that for any type `α` which is infinite, the cardinality of `α` as a natural number, denoted by `Nat.card α`, is equal to zero. In other words, for infinite types, the function `Nat.card` always returns zero. This is consistent with the definition of `Nat.card`, which assigns a cardinality of zero to all infinite types.

For any infinite type `α`, the cardinality `Nat.card α` equals zero.


theorem isUnit_of_invertible : ∀ {α : Type u} [inst : Monoid α] (a : α) [inst_1 : Invertible a], IsUnit a := by sorry

This theorem states that for any type 'α' that forms a 'Monoid', any element 'a' of 'α' that is invertible is a unit. In mathematical terms, if 'α' is a set equipped with an operation that allows it to form a 'Monoid', and if there exists an element 'a' in 'α' such that it has an inverse (i.e., it is invertible), then 'a' is a unit in the 'Monoid'. A unit in this context is an element that has a two-sided inverse.

If 'α' is a monoid and 'a' is an invertible element in 'α', then 'a' is a unit in 'α'.


theorem Finset.prod_cons :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {a : α} {f : α → β} [inst : CommMonoid β] (h : a ∉ s),
      (Finset.prod (Finset.cons a s h) fun x => f x) = f a * Finset.prod s fun x => f x :=
  by sorry

The theorem `Finset.prod_cons` states that for any types `α` and `β`, any finite set `s` of elements of type `α`, any element `a` of type `α`, and any function `f` from `α` to `β`, where `β` is a commutative monoid, if `a` is not an element of `s`, then the product of `f x` for every `x` in the set `{a} ∪ s` (constructed by cons function) is equal to `f a` multiplied by the product of `f x` for every `x` in `s`. In mathematical terms, this theorem states that $\prod_{x \in \{a\} \cup s} f(x) = f(a) \cdot \prod_{x \in s} f(x)$.

For any commutative monoid β, finite set s of α, function f from α to β, and a not in s, we have f a * ∏x∈s (fx) = ∏x∈{a} ∪ s (fx).


theorem Finset.sup_mono :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s₁ s₂ : Finset β} {f : β → α},
      s₁ ⊆ s₂ → Finset.sup s₁ f ≤ Finset.sup s₂ f :=
  by sorry

The theorem `Finset.sup_mono` states that for any two finite sets `s₁` and `s₂` of type `β` and any function `f` from `β` to a type `α` equipped with a semilattice and a bottom element, if `s₁` is a subset of `s₂`, then the supremum of the image of `s₁` under `f` is less than or equal to the supremum of the image of `s₂` under `f`. In other words, if you take two sets where one is a subset of the other and apply a function to each element of these sets, the "largest" result you get from the smaller set will not be larger than the "largest" result you get from the larger set.

For any finite sets $s\_1 \subseteq s\_2$ of type $\beta$, and any function $f : \beta \to (\alpha, \sqcup, \bot)$ with $\alpha$ being a semilattice and $\bot$ its bottom element, we have $\sup \left( f[s\_1] \right) \leq \sup \left( f[s\_2] \right)$.


theorem isOpen_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a : α},
      IsOpen (Set.Ioi a) :=
  by sorry

The theorem `isOpen_Ioi` states that for any type `α` which is equipped with a topological space, a linear order, and a topology in which the sets of the form `(-∞, b]` (denoted as `ClosedIicTopology`) are closed, the set of all elements greater than a given element `a` (denoted as `Set.Ioi a`) is an open set in this topology. In the context of real numbers, this means the open interval `(a, ∞)` is considered an open set in the given topological space.

For any type `α` with a topological space, linear order, and `ClosedIicTopology`, the set `{x : α | x > a}` is open.


PartialHomeomorph.continuousOn

theorem PartialHomeomorph.continuousOn :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), ContinuousOn (↑e) e.source :=
  by sorry

The theorem `PartialHomeomorph.continuousOn` states that for any partial homeomorphism `e` from a topological space `X` to another topological space `Y`, the function represented by `e` is continuous on the source set of `e`. In other words, for every point in the source set of `e`, the function `e` is continuous at that point within the source set.

A partial homeomorphism from a topological space to another preserves the continuity of functions on the domain, that is, it is continuous on the source set.


theorem neg_mul_neg : ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -a * -b = a * b := by sorry

This theorem states that for any type `α` that has a multiplication operation and a negation operation, the product of the negation of `a` and the negation of `b` is equal to the product of `a` and `b`. In mathematical notation, it's saying that `(-a) * (-b) = a * b` for all elements `a` and `b` of type `α`.

For any type `α` with multiplication and negation operations, the negation of their products equals the product of negations: `(-a) * (-b) = a * b`.


Option.ext

theorem Option.ext : ∀ {α : Type u_1} {o₁ o₂ : Option α}, (∀ (a : α), a ∈ o₁ ↔ a ∈ o₂) → o₁ = o₂ := by sorry

This theorem, `Option.ext`, states that for any type `α`, and any two Option types `o₁` and `o₂` of type `α`, if we have that for every element `a` of type `α`, `a` is in `o₁` if and only if `a` is in `o₂`, then `o₁` and `o₂` must be equal. Essentially, it's saying that two Option types are equal if they contain the same elements.

If two Option types `o₁` and `o₂` of type `α` have the same elements, then `o₁` is equal to `o₂`.


theorem Set.union_eq_iUnion : ∀ {α : Type u_1} {s₁ s₂ : Set α}, s₁ ∪ s₂ = ⋃ b, bif b then s₁ else s₂ := by sorry

The theorem `Set.union_eq_iUnion` states that for any type `α` and for any two sets `s₁` and `s₂` of this type, the union of `s₁` and `s₂` is equal to the union over all boolean values `b`, where for each boolean, if it is true, the associated set is `s₁`, otherwise it is `s₂`. In other words, this theorem shows that the union of two sets can be expressed as a union over a boolean-indexed collection of these same two sets.

For any type `α` and sets `s₁` and `s₂`, the union of `s₁` and `s₂` equals the indexed union over boolean values `b` where `b` maps to `s₁` if `b` is `true` and to `s₂` if `b` is `false`.


theorem MeasureTheory.Measure.restrict_restrict :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasurableSet s → (μ.restrict t).restrict s = μ.restrict (s ∩ t) :=
  by sorry

The theorem `MeasureTheory.Measure.restrict_restrict` states that for any type `α` with a measurable space `m0` and a measure `μ`, and for any sets `s` and `t` of type `α`, if `s` is a measurable set, then restricting the measure `μ` first to the set `t` and then to the set `s` is the same as directly restricting the measure `μ` to the intersection of the sets `s` and `t`. This is written in Lean 4 as `(μ.restrict t).restrict s = μ.restrict (s ∩ t)`.

For any measurable space `(α, m0)` and measure `μ`, if `s` is a measurable set in `α`, then `(μ.restrict s).restrict t = μ.restrict (s ∩ t)`.


theorem Nat.one_le_iff_ne_zero : ∀ {n : ℕ}, 1 ≤ n ↔ n ≠ 0 := by sorry

This theorem states that for any natural number `n`, the condition "1 is less than or equal to `n`" is logically equivalent to the condition "`n` is not equal to 0". In other words, in the domain of natural numbers, `n` being non-zero is the same as `n` being at least 1.

The theorem asserts that for all natural numbers `n`, the condition `1 ≤ n` is logically equivalent to `n ≠ 0`.


theorem List.get_mem :
    ∀ {α : Type u_1} (l : List α) (n : ℕ) (h : n < List.length l), List.get l { val := n, isLt := h } ∈ l := by sorry

This theorem, `List.get_mem`, asserts that for any list `l` of elements of some arbitrary type `α` and any natural number `n`, if `n` is less than the length of list `l`, then the `n`-th element of `l` (obtained using `List.get` function with `n` as the index) is indeed an element of the list `l`.

For any list `l` of length `n+1` and natural number `n`, the `n`-th element of `l` belongs to `l`.


Asymptotics.IsLittleO.isBigO

theorem Asymptotics.IsLittleO.isBigO :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =o[l] g → f =O[l] g :=
  by sorry

This theorem states that for any types `α`, `E`, and `F`, given that `E` and `F` have a norm defined on them, and given any two functions `f : α → E` and `g : α → F` and a filter `l` on `α`, if `f` is little-o of `g` at the filter `l` (written as `f =o[l] g`), then `f` is also Big-O of `g` at the filter `l` (written as `f =O[l] g`). In mathematical terms, this is saying that if `f(x)` is dominated by `g(x)` as `x` approaches a certain limit (in the sense of little-o), then `f(x)` is also bounded above by `g(x)` times some constant near that limit (in the sense of Big-O).

If `f : α → E` and `g : α → F` are functions on a type `α` with norms, and `l` is a filter on `α` such that `f =o[l] g`, then `f =O[l] g`. In other words, little-o implies Big-O for functions `f` and `g` at filter `l`.


theorem Filter.Germ.inductionOn₂ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (f : Filter.Germ l β) (g : Filter.Germ l γ)
      {p : Filter.Germ l β → Filter.Germ l γ → Prop}, (∀ (f : α → β) (g : α → γ), p ↑f ↑g) → p f g :=
  by sorry

The theorem `Filter.Germ.inductionOn₂` states that for all types `α`, `β`, and `γ`, given a filter `l` on `α`, and two germs of functions `f` and `g` at the filter `l` with codomains `β` and `γ` respectively, for all properties `p` over pairs of germs from `β` and `γ`, if the property `p` holds for all pairs of function representatives of the germs, then the property `p` also holds for the germs `f` and `g`. This theorem essentially allows us to prove properties about germs by proving them for their representative functions.

Given a filter `l` on type `α`, if a property `p` holds for all pairs of representative functions of germs `f:` `α` -> `β` and `g:` `α` -> `γ` in the filter `l`, then property `p` holds for the germs `f` and `g` at the filter `l`.


/-- An `AddSubgroup` contains the group's 0. -/
theorem AddSubgroup.zero_mem : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), 0 ∈ H := by sorry

This theorem states that for any additive group `G` and any subgroup `H` of `G`, the zero element of the group is always an element of the subgroup. The zero element in the context of an additive group is the group's identity element. This is a fundamental property of subgroups in the context of group theory.

For any additive group G and subgroup H, the zero element of G is in H.


theorem Finset.inter_comm : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ ∩ s₂ = s₂ ∩ s₁ := by sorry

The theorem `Finset.inter_comm` asserts that for any type `α` with decidable equality (meaning, we can always determine whether two elements of type `α` are equal or not), and for any two finite sets `s₁` and `s₂` of type `α`, the intersection of `s₁` and `s₂` is equal to the intersection of `s₂` and `s₁`. In other words, the operation of intersection on finite sets is commutative.

For any type `α` with decidable equality and any finite sets `s₁` and `s₂` of type `α`, `s₁ ∩ s₂ = s₂ ∩ s₁`.


theorem Decidable.eq_or_ne : ∀ {α : Sort u_1} (x y : α) [inst : Decidable (x = y)], x = y ∨ x ≠ y := by sorry

This theorem states that for any sort `α` and any two elements `x` and `y` of that sort, where there is a decidable equality between `x` and `y`, it is always the case that `x` is either equal to `y` or `x` is not equal to `y`. Here, the sort `α` can be a type or a type of types, `x` and `y` are particular instances of `α`, and the `Decidable` instance provides a mechanism for deciding whether or not `x = y` is true or false. Essentially, this is an embodiment of the law of excluded middle for decidable propositions.

For any decidable type `α` and its elements `x` and `y`, if `x = y` is decidable then `x = y` or `x ≠ y`.


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

The theorem `Polynomial.map_pow` states that for any semiring `R` and `S`, any polynomial `p` of type `R`, any ring homomorphism `f` from `R` to `S`, and any natural number `n`, mapping the `n`th power of `p` across `f` is the same as the `n`th power of the mapped `p` across `f`. In other words, the operation of mapping a polynomial across a ring homomorphism commutes with taking powers of polynomials.

For any semiring R, ring homomorphism f from R to S, polynomial p of type R, and natural number n, the mapped polynomial f(p^n) equals the n-th power of the mapped polynomial f(p) in S.


theorem ContDiffAt.comp_contDiffWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f : E → F} {g : F → G} {n : ℕ∞} (x : E),
      ContDiffAt 𝕜 n g (f x) → ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n (g ∘ f) s x :=
  by sorry

The theorem `ContDiffAt.comp_contDiffWithinAt` states that for dependent types 𝕜, E, F, and G, where 𝕜 is a non-trivial normed field and E, F, G are normed spaces over 𝕜, given a set `s` of elements of type E, and two functions `f` and `g` with type E → F and F → G respectively, if `g` is continuously differentiable at the point `f(x)` and `f` is continuously differentiable within the set `s` at the point `x`, then the composition of `g` and `f` is continuously differentiable within the set `s` at the point `x`. This theorem is a statement about the compatibility of continuous differentiability with function composition in the settings of normed spaces over a non-trivial normed field.

If `f` is continuously differentiable within a set `s` at `x` in a normed space over a non-trivial normed field, and `g` is continuously differentiable at `f(x)`, then the composition `g ∘ f` is continuously differentiable at `x`.


theorem NNReal.coe_sum :
    ∀ {α : Type u_1} {s : Finset α} {f : α → NNReal}, ↑(Finset.sum s fun a => f a) = Finset.sum s fun a => ↑(f a) := by
  sorry

This theorem, `NNReal.coe_sum`, states that for any type `α`, any finite set `s` of type `α`, and any function `f` that maps an element of `α` to a nonnegative real number, the real number representation (indicated by `↑`) of the sum of `f(a)` for all `a` in `s` is equal to the sum of the real number representations of `f(a)` for all `a` in `s`. In mathematical terms, for all `s` in finite sets of `α` and all functions `f: α → NNReal`, it holds that `∑_{a ∈ s} f(a) = ∑_{a ∈ s} ↑f(a)`.

For any finite set `s` and function `f` mapping elements of type `α` to non-negative reals, the sum of `↑(f(a))` over `a` in `s` equals the sum of `f(a)` over `a` in `s`.


theorem Prime.ne_zero : ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p : α}, Prime p → p ≠ 0 := by sorry

The theorem `Prime.ne_zero` states that for any type `α` that has a `CommMonoidWithZero` structure, a prime element `p` of type `α` is not equal to zero. In other words, if `p` is a prime element in a commutative monoid with zero, then `p` cannot be zero.

In a commutative monoid with zero, a prime element is distinct from zero.


theorem Set.range_id : ∀ {α : Type u_1}, Set.range id = Set.univ := by sorry

This theorem declares that for any type `α`, the range of the identity function (`id`) is the universal set. In other words, if you apply the identity function to all elements of the type `α`, you get all possible elements of that type, forming the universal set, hence covering the whole set of `α`. In mathematical terms, for any `α`, we have $\text{range}(id) = \text{univ}$, where `id` is the identity function.

For any type `α`, the range of the identity function `id` over `α` equals the universal set, that is, `range(id) = Δα`.


trichotomous

theorem trichotomous : ∀ {α : Sort u} {r : α → α → Prop} [inst : IsTrichotomous α r] (a b : α), r a b ∨ a = b ∨ r b a :=
  by sorry

This theorem, named `trichotomous`, states that for any type `α` and a relation `r` on `α`, if `r` is trichotomous (as defined by the typeclass `IsTrichotomous`), then for all elements `a` and `b` of type `α`, one and only one of the following holds: `r a b`, `a = b`, or `r b a`. This is essentially asserting the trichotomy law, common in ordered sets, that for any two elements, either the first precedes the second, the two are equal, or the second precedes the first.

For any type `α` and trichotomous relation `r` on `α`, given any two elements `a` and `b`, either `r a b`, `r b a`, or `a = b` holds.


theorem ENNReal.add_lt_top : ∀ {a b : ENNReal}, a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by sorry

This theorem states that for all pairs of extended nonnegative real numbers 'a' and 'b', the sum of 'a' and 'b' is less than infinity if and only if both 'a' and 'b' are each less than infinity. In other words, in the context of extended nonnegative real numbers, if the sum of two numbers is finite, then those two numbers must themselves be finite.

For all extended nonnegative real numbers 'a' and 'b', the sum 'a' + 'b' is finite if and only if both 'a' and 'b' are finite.


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

This theorem, `or_congr`, states that for any four propositions `a`, `b`, `c`, and `d`, if `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then the logical disjunction `a OR b` is equivalent to the logical disjunction `c OR d`. In the language of propositional logic, if we know that two pairs of propositions are equivalent, then the "OR" of each pair is also equivalent.

If `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then `aOrb` is logically equivalent to `cOrd` in propositional logic.


/-- A natural transformation is an isomorphism if all its components are isomorphisms.
 -/
theorem CategoryTheory.NatIso.isIso_of_isIso_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G)
      [inst_2 : ∀ (X : C), CategoryTheory.IsIso (α.app X)], CategoryTheory.IsIso α :=
  by sorry

This theorem states that in the context of category theory, a natural transformation (denoted by `α`) between two functors `F` and `G` from category `C` to `D`, is an isomorphism if all of its components (i.e., the morphism `α.app X` for all `X` in `C`) are isomorphisms.

A natural transformation between functors is an isomorphism if and only if all its components are isomorphisms.


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

The theorem `NNReal.coe_inj` states that for any two nonnegative real numbers `r₁` and `r₂`, the proposition that their coerced values are equal is equivalent to the proposition that `r₁` and `r₂` themselves are equal. In simpler terms, this theorem is about the injectivity of the coercion function on nonnegative real numbers; it says that if the real-number representations of two nonnegative real numbers are the same, then the two nonnegative real numbers themselves must be the same, and vice versa.

The coercion function from nonnegative real numbers to their real representations is an injective function.


Relation.ReflTransGen.single

theorem Relation.ReflTransGen.single :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, r a b → Relation.ReflTransGen r a b := by sorry

This theorem states that, for any type `α`, relation `r` and elements `a` and `b` of type `α`, if the relation `r` holds between `a` and `b`, then `a` and `b` are in the reflexive transitive closure of the relation `r`. In other words, a single application of a relation `r` is sufficient to establish a connection in its reflexive transitive closure.

For any relation `r` on type `α`, if `r` is reflexive and transitive, then the reflexive transitive closure of `r` is equal to `r` itself.


theorem sdiff_eq : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], x \ y = x ⊓ yᶜ := by sorry

This theorem, `sdiff_eq`, states that for any type `α` that has a Boolean algebra structure and for any two instances `x` and `y` of this type, the set difference of `x` and `y` (denoted as `x \ y`) is equal to the result of the 'AND' operation (denoted as `⊓`) between `x` and the complement of `y` (denoted as `yᶜ`).

For any type `α` with a Boolean algebra structure, `x ⊓ yᶜ = x \ y`.


/-- **Alias** of the reverse direction of `isClosed_compl_iff`. -/
theorem IsOpen.isClosed_compl : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s → IsClosed sᶜ := by
  sorry

This theorem, denoted as `IsOpen.isClosed_compl`, states that for any type `X` equipped with a topological space structure, and for any set `s` of this type `X`, if the set `s` is open in this topological space, then the complement of `s`, denoted as `sᶜ`, is a closed set in the same topological space. In mathematical terms, this theorem captures one of the fundamental concepts of topology, which is that the complement of an open set is always a closed set.

If a set is open in a topological space, then its complement is closed.


/-- **Alias** of the reverse direction of `monotoneOn_toDual_comp_iff`. -/
theorem AntitoneOn.dual_right :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      AntitoneOn f s → MonotoneOn (⇑OrderDual.toDual ∘ f) s :=
  by sorry

The theorem `AntitoneOn.dual_right` states that for any two types `α` and `β` that have the structure of a preorder, any function `f` from `α` to `β`, and any set `s` of `α`, if `f` is antitone on `s` (that is, for all `a` and `b` in `s`, `a ≤ b` implies `f(b) ≤ f(a)`), then the composition of `f` with the `toDual` function (which gives the dual order) is monotone on `s` (that is, for all `a` and `b` in `s`, `a ≤ b` implies `f(Dual(a)) ≤ f(Dual(b))`). In other words, applying the `toDual` function to an antitone function results in a monotone function.

If `f: α → β` is an antitone function between preordered types `α` and `β`, then the composition `f ∘ toDual` is a monotone function.


theorem Bool.not_eq_true : ∀ (b : Bool), (¬b = true) = (b = false) := by sorry

This theorem states that for any boolean value `b`, the statement "not `b` is equal to true" is equivalent to the statement "`b` is equal to false". In other words, negating a boolean value and equating it to true gives the same result as directly equating the original boolean value to false.

The negation of a boolean value `b` is equivalent to `false`, or equivalently, `not b` is equal to `false`.


theorem Finset.prod_map :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommMonoid β] (s : Finset α) (e : α ↪ γ) (f : γ → β),
      (Finset.prod (Finset.map e s) fun x => f x) = Finset.prod s fun x => f (e x) :=
  by sorry

This theorem, `Finset.prod_map`, states that for any type `α`, `β`, and `γ`, with `β` being a commutative monoid, given a finite set `s` of type `α`, an embedding `e` from `α` to `γ`, and a function `f` from `γ` to `β`, the product of `f x` for every `x` in the image set `Finset.map e s` (that is, the set obtained by applying the embedding `e` to each element of `s`) is equal to the product of `f (e x)` for every `x` in the original set `s`. In other words, it's asserting that mapping a function over a set and then taking the product is the same as first applying the map to each element and then taking the product, for a specific map that is an embedding. This is an instance of a very general principle in mathematics, often referred to as changing the order of operations, or more formally, as the interchange of limit processes.

For any commutative monoid β, finite set s of type α, embedding e from α to γ, and function f from γ to β, the product of f (e x) for each x in s equals the product of f (e (s.map x)).


theorem Finset.sum_empty :
    ∀ {α : Type u_3} {β : Type u_4} {f : α → β} [inst : AddCommMonoid β], (Finset.sum ∅ fun x => f x) = 0 := by sorry

The theorem `Finset.sum_empty` states that for any type `α`, any type `β` that forms an additive commutative monoid, and any function `f` from `α` to `β`, the sum of `f x` over the elements of an empty finite set is zero. In other words, if you try to compute the sum of elements from an empty set, where the elements are obtained by applying some function `f` to each element of the set, the result is zero. This is because there are no elements in the set to apply the function to and sum up.

For any additive commutative monoid type `β` and function `f` from type `α` to `β`, the sum of `f x` over an empty finite set `α` is the zero element of `β`.


theorem mem_chart_source :
    ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] (x : M), x ∈ (chartAt H x).source :=
  by sorry

This theorem, named `mem_chart_source`, states that for any topological space `H`, and any charted space `M` over `H`, every point `x` in the charted space `M` is a member of the source set of the chart at `x`. In other words, the chart that maps `M` to `H` is valid at the point `x`, which is to say, `x` is in the domain of the chart.

For any charted space `M` over a topological space `H` and any point `x` in `M`, `x` belongs to the source set of the chart at `x`.


theorem Fin.cons_succ :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α (Fin.succ i)) (i : Fin n),
      Fin.cons x p (Fin.succ i) = p i :=
  by sorry

The theorem `Fin.cons_succ` states that for any natural number `n`, and any dependent function `α` of type `Fin (n + 1) → Type u`, if we have an element `x` of type `α 0` and a function `p` that maps from `Fin n` to `α (Fin.succ i)`, then for any element `i` of `Fin n`, applying the `Fin.cons` function to `x`, `p`, and `Fin.succ i` will yield the same result as applying the function `p` to `i`. In other words, when we add an element at the beginning of an `n`-tuple to get an `n+1`-tuple using `Fin.cons` and then increment an index from `Fin n` to `Fin (n + 1)`, the result is the same as if we directly apply the function `p` to the original index in `Fin n`.

For any natural number `n`, any dependent type `α : Fin (n + 1) → Type u`, element `x : α 0`, and function `p : Fin n → α (Fin.succ i)`, the application of `Fin.cons x p (Fin.succ i)` equals `p i` for all `i` in `Fin n`.


/-- The indexed supremum of a function is bounded below by the value taken at one point -/
theorem le_ciSup :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {f : ι → α},
      BddAbove (Set.range f) → ∀ (c : ι), f c ≤ iSup f :=
  by sorry

The theorem `le_ciSup` states that for any type `α` equipped with a `ConditionallyCompleteLattice` structure, and for any function `f` from the type `ι` to `α`, if the range of `f` is bounded above, then the value of `f` at any point `c` from `ι` is less than or equal to the supremum of `f` over its domain. In other words, the supremum of the function, denoted as `iSup f`, acts as an upper bound for the values of `f` at all points from the domain `ι`.

For any function `f` from a type `ι` to a conditionally complete lattice `α`, if `f` has a supremum, then for all `c` in `ι`, we have `f c ≤ iSup f`.


theorem false_implies : ∀ (p : Prop), (False → p) = True := by sorry

This theorem states that for any proposition 'p', the implication of 'False' leading to 'p' is always 'True'. In mathematical terms, it asserts that any statement can be derived from a contradiction. This is a standard principle known as "ex falso sequitur quodlibet" or 'from falsehood, anything follows'.

The theorem asserts that for any proposition 'p' in Lean, ⊥ → p holds, where ⊥ represents the logical falsity. In other words, anything can be derived from a contradiction.


Setoid.refl

theorem Setoid.refl : ∀ {α : Sort u} [inst : Setoid α] (a : α), a ≈ a := by sorry

This theorem states that, for any type 'α' equipped with a Setoid structure (which provides an equivalence relation), every element 'a' of type 'α' is equivalent to itself. In mathematical terms, it proves the reflexivity property of the equivalence relation (≈) in the context of setoids: for all 'a' in 'α', a ≈ a. This is a fundamental property of any equivalence relation in mathematics.

For any setoid type 'α' and its equivalence relation '≈', every element 'a' in 'α' is equivalent to itself, i.e., a ≈ a.


theorem eq_sub_iff_add_eq : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a = b - c ↔ a + c = b := by sorry

This theorem states that for any type `G` that forms an Additive Group, given any three elements `a`, `b`, and `c` in `G`, `a` equals the difference of `b` and `c` if and only if `b` is the sum of `a` and `c`. In essence, it is a property of the additive group that allows us to rearrange an equation involving subtraction into an equivalent equation involving addition. In terms of formal math, it's stating the equivalence between the two expressions `a = b - c` and `a + c = b`.

For any additive group `G` and elements `a, b, c` in `G`, `a = b - c` if and only if `a + c = b`.


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

This theorem, `le_max_of_le_right`, states that for any linearly ordered type `α` and any three elements `a`, `b`, and `c` of this type, if `a` is less than or equal to `c`, then `a` is also less than or equal to the maximum of `b` and `c`. This theorem captures a fundamental property of "max" operation in the context of ordered types.

For any linearly ordered type α and elements a, b, c of α, if a ≤ c then a ≤ max(b c).


Basis.linearIndependent

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

The theorem `Basis.linearIndependent` asserts that for any semiring `R`, any additively commutative monoid `M`, and any module `R M`, if `b` is a basis of the module, then the basis `b` is linearly independent over the semiring `R`. In other words, no vector in the basis can be represented as a linear combination of the other vectors in the basis set.

If `b` is a basis of the `R-module` `M`, then `b` is linearly independent over the semiring `R`.


theorem Dvd.intro_left : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b : α} (c : α), c * a = b → a ∣ b := by sorry

This theorem, `Dvd.intro_left`, states that for any Commutative Semigroup `α`, given any three elements `a`, `b`, and `c` of `α`, if `c` multiplied by `a` equals `b` (`c * a = b`), then `a` divides `b` (`a ∣ b`). A Commutative Semigroup is a set equipped with an associative multiplication operation that is commutative. This theorem essentially captures the mathematical property that if one number times another equals a third, then the second number divides the third.

In a commutative semigroup, if the product of two elements is equal to a third element, then one element divides the other two.


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

The theorem `Polynomial.eval₂_eq_eval_map` states that for any semiring `R`, semiring `S`, polynomial `p` of type `R`, ring homomorphism `f` from `R` to `S`, and an element `x` of `S`, evaluating the polynomial `p` at `x` using `f` (`Polynomial.eval₂ f x p`) is equivalent to first mapping the polynomial `p` across `f` and then evaluating the result at `x` (`Polynomial.eval x (Polynomial.map f p)`). In other words, the process of applying the ring homomorphism to the coefficients of a polynomial and then evaluating the resulting polynomial at a particular point is the same as directly evaluating the original polynomial at the given point, taking into account the ring homomorphism.

For any semiring homomorphism `f` from `R` to `S`, polynomial `p` over `R`, and element `x` in `S`, `Polynomial.eval₂ f x p` is equal to `Polynomial.eval x (Polynomial.map f p)`.


theorem abs_eq_self : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a : α}, |a| = a ↔ 0 ≤ a := by sorry

This theorem states that for any type `α` which is a linearly ordered additive commutative group, the absolute value of an element `a` of that type is equal to `a` if and only if `a` is greater than or equal to zero. The theorem is general and holds for any instance of a linearly ordered additive commutative group, which includes common types like integers and real numbers.

For any linearly ordered additive commutative group type `α`, the absolute value of an element `a` equals `a` if and only if `a` is non-negative.


theorem Mathlib.Data.Rat.Cast.Order._auxLemma.2 :
    ∀ {K : Type u_5} [inst : LinearOrderedField K] {m n : ℚ}, (↑m ≤ ↑n) = (m ≤ n) := by sorry

This theorem states that, for any instance `K` of a linearly ordered field, and for any rational numbers `m` and `n`, the inequality `m` less than or equal to `n` in the field `K` holds true if and only if the inequality `m` less than or equal to `n` holds true in the set of rational numbers. Here, the `↑` symbol is used to denote the embedding of the rational numbers into the field `K`.

For any linearly ordered field `K` and rational numbers `m` and `n`, `m ≤ n` holds in `K` if and only if `m ≤ n` holds in the rational numbers.


Quotient.exact'

theorem Quotient.exact' :
    ∀ {α : Sort u_1} {s₁ : Setoid α} {a b : α}, Quotient.mk'' a = Quotient.mk'' b → Setoid.r a b := by sorry

The theorem `Quotient.exact'` states that for any type `α` that has a `Setoid` relation `s₁`, and for any two elements `a` and `b` of `α`, if the quotient of `a` under the `Setoid` relation `s₁` is equal to the quotient of `b` under the same relation, then `a` and `b` are related by the equivalence relation for the `Setoid`, denoted `Setoid.r`. In other words, this theorem provides a way to retrieve the underlying relation from the equality of the quotient elements.

For any setoid `s₁` on type `α`, if `a` and `b` have equal quotients under `s₁`, then `a` and `b` are related by the equivalence relation `Setoid.r` of `s₁`.


theorem Nat.choose_eq_zero_of_lt : ∀ {n k : ℕ}, n < k → Nat.choose n k = 0 := by sorry

The theorem `Nat.choose_eq_zero_of_lt` states that for all natural numbers `n` and `k`, if `n` is less than `k`, then the binomial coefficient `Nat.choose n k` is equal to zero. In other words, it's not possible to choose `k` elements from a set of `n` elements if `k` is greater than `n`, and thus the number of ways to do so is zero. This aligns with the common combinatorial understanding that there are zero ways to choose more items than are available in the set.

For all natural numbers n and k, if n < k then Nat.choose n k = 0.


theorem isLUB_csSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α},
      Set.Nonempty s → BddAbove s → IsLUB s (sSup s) :=
  by sorry

The theorem `isLUB_csSup` states that for any type `α` that has the structure of a conditionally complete lattice, if we have a non-empty set `s` of elements of type `α`, that is bounded above, then the supremum of the set `s` (`sSup s`) is a least upper bound of the set `s`. In other words, for every non-empty `s` that has an upper bound, there doesn't exist any other upper bound which is less than the supremum of `s`.

If `α` is a conditionally complete lattice and `s` is a non-empty, bounded above subset of `α`, then `sSup s` is the least upper bound of `s`.


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

The theorem `CategoryTheory.Limits.ι_colimMap` states that for any category `J` and `C`, and functors `F` and `G` from `J` to `C`, if `F` and `G` both have colimits, given a natural transformation `α` from `F` to `G` and an object `j` in `J`, then the composition of the coprojection from `F` at `j` to the colimit of `F` with the map induced by `α` from the colimit of `F` to the colimit of `G` is equal to the composition of the component of `α` at `j` with the coprojection from `G` at `j` to the colimit of `G`. In simpler terms, this theorem is a statement of naturality of the colimit map with respect to the transformation `α`.

For any categories J and C, functors F and G from J to C with colimits, and a natural transformation α from F to G, the diagram commuting from the coprojections from F and G to their respective colimits and the maps induced by α holds.


theorem Monotone.directed_le :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] [inst_2 : Preorder β]
      {f : α → β}, Monotone f → Directed (fun x x_1 => x ≤ x_1) f :=
  by sorry

The theorem `Monotone.directed_le` states that for any type `α` and `β` with a preorder structure, and a function `f` from `α` to `β`, if `α` is directed with respect to the relation "less than or equal to" and the function `f` is monotone (meaning that `a ≤ b` implies `f a ≤ f b`), then the image of `α` under `f` is also directed with respect to the relation "less than or equal to". In other words, for any two elements in the image of `α`, there exists a third element that is greater than or equal to both of them.

If `α` is a directed type with respect to "≤" and `f: α → β` is a monotone function, then `f["α"]` is a directed set with respect to "≤".


theorem IsSelfAdjoint.star_eq : ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x → star x = x := by sorry

This theorem states that for any type `R` that has a `Star` operation, if an element `x` of `R` is self-adjoint, then the star of `x` is equal to `x`. The condition of being self-adjoint is defined as an element being equal to its star. In mathematical terms, this would be equivalent to saying for a given element `x` in a star-algebra `R`, if `x` is self-adjoint (meaning that `x` is equal to its conjugate or adjoint), then the adjoint operation on `x` results in `x` itself.

For any self-adjoint element `x` in a star-algebra `R`, `x` equals its adjoint `x*`.


theorem Filter.Tendsto.prod_mk :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ} {m₁ : α → β}
      {m₂ : α → γ}, Filter.Tendsto m₁ f g → Filter.Tendsto m₂ f h → Filter.Tendsto (fun x => (m₁ x, m₂ x)) f (g ×ˢ h) :=
  by sorry

The theorem `Filter.Tendsto.prod_mk` states that if we have two functions `m₁` and `m₂` from a type `α` to types `β` and `γ` respectively, and if `m₁` tends to `g` with respect to a filter `f` on `α` and `m₂` tends to `h` with the same filter, then the function that maps `x` to the pair `(m₁ x, m₂ x)` also tends to the product filter `(g ×ˢ h)` with respect to `f`.

In other words, if for all neighborhoods of `g` and `h`, the pre-images under `m₁` and `m₂` respectively are neighborhoods of the filter `f`, then for all neighborhoods of `g ×ˢ h`, the pre-image under the function mapping `x` to `(m₁ x, m₂ x)` is also a neighborhood of `f`. This is a formalization of the concept of 'limit of a function' in the context of filters.

If functions `m₁ : α → β` and `m₂ : α → γ` tend to `g : β` and `h : γ` respectively with respect to a filter `f` on `α`, then the function mapping `x` to `(m₁ x, m₂ x)` tends to the product `g × h` with respect to `f`.


theorem Set.iUnion_empty : ∀ {α : Type u_1} {ι : Sort u_4}, ⋃ x, ∅ = ∅ := by sorry

This theorem states that for any type `α` and an index type `ι`, the indexed union over an empty set results in an empty set. In mathematical terms, it says that if we take the union of an empty set for any index `x` from an index set `ι`, the result is an empty set. This is a generalization of the fact that the union of zero sets is an empty set.

For any index type `ι`, the indexed union over an empty set is an empty set.


Ideal.IsMaximal.isPrime

theorem Ideal.IsMaximal.isPrime :
    ∀ {α : Type u} [inst : CommSemiring α] {I : Ideal α}, Ideal.IsMaximal I → Ideal.IsPrime I := by sorry

This theorem states that for any commutative semiring `α`, if `I` is a maximal ideal of `α` then `I` is also a prime ideal. In other words, if an ideal `I` in a commutative semiring `α` has no proper ideal containing it (other than the whole ring), then for any two elements of the semiring, if their product is in `I`, then at least one of the elements must be in `I`.

In a commutative semiring, a maximal ideal is a prime ideal.


Setoid.refl'

theorem Setoid.refl' : ∀ {α : Type u_1} (r : Setoid α) (x : α), Setoid.Rel r x x := by sorry

The theorem `Setoid.refl'` states that, for any type `α` and any equivalence relation `r` on `α`, `Setoid.Rel r` is reflexive. That is, for every element `x` of type `α`, `x` is related to itself under the equivalence relation `r`. In mathematical terms, for all `x` in `α`, we have `Setoid.Rel r x x`. This is a formal statement of the reflexivity property of equivalence relations.

For any equivalence relation `r` on type `α`, `x ∉-x` implies `∃ y, r x y ∧ r y x` (or equivalently, `Setoid.Rel r x x`).


Filter.Tendsto.inf

theorem Filter.Tendsto.inf :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β},
      Filter.Tendsto f x₁ y₁ → Filter.Tendsto f x₂ y₂ → Filter.Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂) :=
  by sorry

The theorem `Filter.Tendsto.inf` states that for any types `α` and `β`, for any function `f` mapping `α` to `β`, and for any filters `x₁`, `x₂` on `α` and `y₁`, `y₂` on `β`, if `f` is tending towards `y₁` under filter `x₁` and tending towards `y₂` under filter `x₂`, then `f` is also tending towards the infimum of `y₁` and `y₂` under the infimum of `x₁` and `x₂`. In mathematical terms, if $f$ tends to $y₁$ when $x$ tends to $x₁$ and $f$ tends to $y₂$ when $x$ tends to $x₂$, then $f$ tends to the intersection of $y₁$ and $y₂$ when $x$ tends to the intersection of $x₁$ and $x₂$.

If functions $f$ tends to $y\_1$ with respect to filter $x\_1$ and tends to $y\_2$ with respect to filter $x\_2$, then $f$ tends to the inf infimum of $y\_1$ and $y\_2$ with respect to the infimum of $x\_1$ and $x\_2$.


theorem isCompact_compactCovering :
    ∀ (X : Type u_1) [inst : TopologicalSpace X] [inst_1 : SigmaCompactSpace X] (n : ℕ),
      IsCompact (compactCovering X n) :=
  by sorry

The theorem `isCompact_compactCovering` states that for every type `X` equipped with a topology and assumed to be a `σ`-compact space (a space that is a countable union of compact subsets), and for every natural number `n`, the `n`-th set in the compact covering of `X` is a compact set. In other words, each set in the sequence of sets that form a monotone choice of compact covering for a `σ`-compact space is itself compact.

For any σ-compact space X and every compact covering {C : n in nat}, the n-th set C is compact.


theorem QuotientGroup.leftRel_apply :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, Setoid.r x y ↔ x⁻¹ * y ∈ s := by sorry

This theorem establishes a relationship between the equivalence relation defined by a setoid and an element of a subgroup in the context of group theory. Specifically, for any type `α` equipped with a group structure, a subgroup `s` of `α`, and any two elements `x` and `y` from `α`, the theorem states that `x` is related to `y` under the setoid's equivalence relation if and only if the result of multiplying the inverse of `x` by `y` belongs to the subgroup `s`.

For any group `α` with subgroup `s`, elements `x` and `y` from `α` are equivalent under the setoid's relation if and only if `s` contains the product of `x^(-1)` and `y`.


MeasurableSet.diff

theorem MeasurableSet.diff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
      MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (s₁ \ s₂) :=
  by sorry

The theorem `MeasurableSet.diff` is a declaration that for any given type `α`, any given measurable space `m` over `α`, and any two sets `s₁` and `s₂` of type `α`, if `s₁` and `s₂` are both measurable sets, then the set difference `s₁ \ s₂` (the set of all elements that belong to `s₁` but not to `s₂`) is also a measurable set.

If `m` is a measurable space on type `α`, and `s₁` and `s₂` are measurable sets in `α` with respect to `m`, then their set difference `s₁ \ s₂` is also a measurable set in `α` with respect to `m`.


theorem smul_lt_smul_of_pos_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulStrictMono α β], b₁ < b₂ → 0 < a → a • b₁ < a • b₂ :=
  by sorry

This theorem states that for any types `α` and `β`, given scalar multiplication (`SMul`) on `α` and `β`, an ordering on `α` (`Preorder α`), an ordering on `β` (`Preorder β`), a zero element on `α` (`Zero α`), and a positive strict monotonicity of scalar multiplication (`PosSMulStrictMono α β`), if `b₁` is less than `b₂` and `a` is greater than zero, then the scalar multiplication of `a` and `b₁` is less than the scalar multiplication of `a` and `b₂`. In mathematical notation, it asserts that if `b₁ < b₂` and `0 < a`, then `a * b₁ < a * b₂`. This theorem formalizes a property of order-preserving scalar multiplication.

For types `α` and `β` with orderings, zero elements, and positive strict monotonic scalar multiplications, if `0 < a` and `b₁ < b₂`, then `a * b₁ < a * b₂`.


theorem Ordinal.typein_lt_self :
    ∀ {o : Ordinal.{u_3}} (i : (Quotient.out o).α), Ordinal.typein (fun x x_1 => x < x_1) i < o := by sorry

The theorem `Ordinal.typein_lt_self` states that for any ordinal `o` and any element `i` from the underlying set of the well-ordered set represented by `o`, the order type of `i` with respect to the less than relation (i.e., `Ordinal.typein (fun x x_1 => x < x_1) i`) is strictly less than `o` itself. This essentially means that the order type of an element within a well-ordered set, when considering only elements less than it, is always strictly less than the order type of the entire set.

For any well-ordered set (ordinal) `o` and any element `i` in `o`, the order type of `i` is strictly less than the order type of `o`.


theorem Filter.eventually_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop},
      (∀ᶠ (b : β) in Filter.map m f, P b) ↔ ∀ᶠ (a : α) in f, P (m a) :=
  by sorry

This theorem establishes an equivalence between two forms of expressing a property that holds "eventually" in the context of a filter. Specifically, given a filter `f` over a type `α`, a mapping function `m` from `α` to `β`, and a property `P` over `β`, the property `P` holds eventually for all `b` in the filter obtained by mapping `f` through `m` if and only if the property `P` applied to `m a` holds eventually for all `a` in the filter `f`.

Given a filter `f` over type `α`, a mapping function `m : α → β`, and a property `P : β → Prop`, the filter `f` maps `P` eventually if and only if the image filter `{ m(a) | a ∈ f }` has `P` as an eventual property.


theorem associated_iff_eq : ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Unique αˣ] {x y : α}, Associated x y ↔ x = y :=
  by sorry

The theorem `associated_iff_eq` states that for any type `α` that has a `Monoid` structure and a unique unit `αˣ`, and for any two elements `x` and `y` of type `α`, `x` and `y` are associated (i.e., one of them is the other one multiplied by a unit on the right) if and only if `x` equals `y`. This is, if there exists a unit `u` such that `x * u = y`, then `x` and `y` are equal.

For any type `α` with a `Monoid` structure and unique unit `αˣ`, elements `x` and `y` are associates (i.e., there exists a unit `u` such that `x * u = y`) if and only if `x` is equal to `y`.


theorem Sum.inl_injective : ∀ {α : Type u} {β : Type v}, Function.Injective Sum.inl := by sorry

The theorem `Sum.inl_injective` states that for all types `α` and `β`, the function `Sum.inl` is injective. In other words, if we have two elements `a₁` and `a₂` from some type `α`, and if `Sum.inl a₁` equals `Sum.inl a₂`, then `a₁` must equal `a₂`. The function `Sum.inl` is a constructor for the sum type, which takes a value of type `α` and produces a value of the sum type `α ⊕ β`, tagged as coming from `α`. Being injective means it doesn't map different values to the same result.

For all types `α` and `β`, the function `Sum.inl : α -> α ⊕ β` is an injection.


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

The theorem `Inducing.continuous_iff` states that for any three types `X`, `Y`, and `Z`, given functions `f` from `X` to `Y` and `g` from `Y` to `Z`, with each of them having a topological space structure, if `g` is inducing, then `f` is continuous if and only if the composition of `g` and `f` (`g ∘ f`) is continuous. This theorem essentially establishes a condition under which the continuity of a function `f` can be deduced from the continuity of the composition `g ∘ f`.

Given functions `f : X → Y` and `g : Y → Z` between topological spaces with `g` inducing and continuous, then `f` is continuous if and only if their composition `g ∘ f` is continuous.


theorem Nat.Coprime.gcd_eq_one : ∀ {m n : ℕ}, Nat.Coprime m n → Nat.gcd m n = 1 := by sorry

The theorem `Nat.Coprime.gcd_eq_one` states that for any two natural numbers `m` and `n`, if `m` and `n` are coprime (i.e., their greatest common divisor is 1), then the greatest common divisor of `m` and `n` is indeed 1. In mathematical terms, for all natural numbers `m` and `n`, if `gcd(m, n) = 1`, then it is guaranteed that `gcd(m, n) = 1`.

If `m` and `n` are coprime natural numbers, then their greatest common divisor equals 1.


theorem Set.Ioc_eq_empty : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, ¬a < b → Set.Ioc a b = ∅ := by sorry

The theorem `Set.Ioc_eq_empty` states that for any type `α` that has a predefined order, and for any two elements `a` and `b` in `α`, if `a` is not less than `b`, then the left-open right-closed interval from `a` to `b` is an empty set. In mathematical terms, if `a` is not less than `b` (i.e., `a ≥ b`), then the set of elements `x` such that `a < x ≤ b` is empty.

If `α` is a type with a predefined order and `a ≥ b` in `α`, then the set `{x : α | a < x ≤ b}` is empty.


MulAction.injective

theorem MulAction.injective :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] (g : α), Function.Injective fun x => g • x :=
  by sorry

The theorem `MulAction.injective` states that for every group `α` and every type `β` that is the target of a multiplication action of `α`, every element `g` of `α` defines an injective function. This injective function is defined as the multiplication of `g` with an element `x` from `β`. In other words, for any two elements `x` and `y` from `β`, if `g • x = g • y`, then it must be the case that `x = y`.

Given a group `α` and a type `β` equipped with a multiplication action of `α`, the multiplication by each element `g` in `α` is an injective function on `β`.


Disjoint.aedisjoint

theorem Disjoint.aedisjoint :
    ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      Disjoint s t → MeasureTheory.AEDisjoint μ s t :=
  by sorry

This theorem states that for any type `α`, given a measurable space over `α`, a measure `μ` on that space, and two sets `s` and `t` of type `α`, if `s` and `t` are disjoint in the sense that their infimum is the bottom element, then `s` and `t` are almost everywhere disjoint with respect to the measure `μ`. In other words, the intersection of `s` and `t` has a measure of zero under `μ`. This theorem connects the concept of disjointness in a lattice setting with the concept of almost everywhere disjointness in a measure theory setting.

If `α` is a type with a measurable structure, `μ` is a measure on `α`, and `s` and `t` are disjoint subsets of `α` (i.e., `s ∧ t = ⊥`), then `μ(s ∩ t) = 0`.


theorem Finset.coe_inter : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), ↑(s₁ ∩ s₂) = ↑s₁ ∩ ↑s₂ := by
  sorry

The theorem `Finset.coe_inter` asserts that for any given type `α` with a decidable equality and for any two finite sets (`Finset`s) `s₁` and `s₂` of that type, the intersection (`∩`) of `s₁` and `s₂` coalesces (`↑`) to the same set as the coalescence of the intersections of `s₁` and `s₂`. In other words, when two finite sets are intersected, the result is the same whether the intersection is performed before or after the sets are transformed (i.e., coalesced).

For any decidably equal types `α` and finite sets `s₁` and `s₂` of `α`, the intersection `s₁ ∩ s₂` is equal to the coalesced intersection `(↑ s₁) ∩ (↑ s₂)`.


Setoid.symm'

theorem Setoid.symm' : ∀ {α : Type u_1} (r : Setoid α) {x y : α}, Setoid.Rel r x y → Setoid.Rel r y x := by sorry

This theorem, `Setoid.symm'`, states that for all types `α`, for any equivalence relation `r` on `α`, and for all elements `x` and `y` of `α`, if `x` is related to `y` under `r`, then `y` is also related to `x` under `r`. In other words, the relation `r` is symmetric: if `x` and `y` are elements such that `x` is related to `y` according to `r`, then `y` is related to `x` according to `r`. This is a common property in mathematics and is required for an equivalence relation.

For all types `α` and equivalence relations `r` on `α`, if `x` is related to `y` under `r`, then `y` is related to `x` under `r` (reflexivity and symmetry property of equivalence relations).


theorem subset_rfl : ∀ {α : Type u} [inst : HasSubset α] {a : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1], a ⊆ a := by
  sorry

This theorem, `subset_rfl`, states that for any type `α` that has a notion of subset (`HasSubset α`), any element `a` of this type is a subset of itself. This property, derived from the reflexivity axiom (`IsRefl α`), is one of the fundamental properties of set theory.

For any type `α` with subset structure, every element `a` in `α` is a subset of `{a}`.


theorem Ordinal.le_sup : ∀ {ι : Type u} (f : ι → Ordinal.{max u v}) (i : ι), f i ≤ Ordinal.sup f := by sorry

The theorem `Ordinal.le_sup` states that for any type `ι` and any function `f` from `ι` to the type of well-ordered sets `Ordinal`, each element `f i` (where `i` is in `ι`) is less than or equal to the supremum of the set of well-ordered sets generated by `f`. In other words, any ordinal in the family defined by `f` is less than or equal to the supremum of the family of ordinals.

For any type `ι` and function `f` from `ι` to the well-ordered sets `Ordinal`, `f i ≤ sup (map f ι)` for all `i` in `ι`.


theorem UniformSpace.Completion.induction_on :
    ∀ {α : Type u_1} [inst : UniformSpace α] {p : UniformSpace.Completion α → Prop} (a : UniformSpace.Completion α),
      IsClosed {a | p a} → (∀ (a : α), p (↑α a)) → p a :=
  by sorry

This theorem, called `UniformSpace.Completion.induction_on`, states that for any type `α` with a uniform space structure, a property `p`, and an element `a` of the completion of `α`, if the set of all `a` for which `p a` holds is closed, and `p` holds for all elements of `α`, then `p` also holds for `a`. In other words, it provides an induction principle for proving properties about the elements of the completion of a uniform space, given that these properties hold for the elements of the original space and are preserved under taking limits (since being closed means containing all limit points).

If `α` is a uniform space with property `p` holding for all elements of `α` and the set of all completion elements `a` with `p a` is closed, then `p` holds for all completion elements `a`.


LowerSet.lower

theorem LowerSet.lower : ∀ {α : Type u_1} [inst : LE α] (s : LowerSet α), IsLowerSet ↑s := by sorry

This theorem states that for any type `α` that has a less than or equal to (`LE`) relationship, and for any lower set `s` of type `α`, `s` is a lower set. In other words, if `s` is a lower set of a certain type, then any element less than or equal to another element in `s` is also a member of `s`.

If `α` is a type with a `LE` relation, and `s` is a lower set of `α`, then for all `x y ∈ s`, `x LE y` implies `x ∈ s`.


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

This theorem states that for any type `α` and for any two multisets `s` and `t` of this type, if `s` is less than or equal to `t` (denoted as `s ≤ t`), then `s` is a subset of `t` (denoted as `s ⊆ t`). In the context of multisets, "less than or equal to" means that `s` can be obtained from `t` by deleting some elements. Hence, the theorem is asserting that if a multiset `s` can be formed by deleting some elements from another multiset `t`, then all elements of `s` are also in `t`.

If two multisets of the same type are related by `s ≤ t` (i.e., `s` can be obtained from `t` by deleting some elements), then `s` is a subset of `t` (denoted as `s ⊆ t`).


/-- A morphism in `Type` is a monomorphism if and only if it is injective.

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

The theorem `CategoryTheory.mono_iff_injective` states that for every morphism `f` from type `X` to type `Y`, `f` is a monomorphism in the category of types if and only if `f` is an injective function. This means that a morphism (a function between types) preserves the distinctness of elements from the domain (`X`) to the codomain (`Y`), i.e., if `f(a) = f(b)`, then `a` must equal `b`. The theorem links the concept of an injective function in set theory and a monomorphism in category theory.

A morphism in a category is a monomorphism if and only if it is an injective function between sets.


theorem pow_eq_zero :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} [inst_1 : NoZeroDivisors M₀] {n : ℕ}, a ^ n = 0 → a = 0 := by
  sorry

The theorem `pow_eq_zero` states that for any type `M₀` that has a structure of a monoid with zero and no zero divisors, if a number `a` of type `M₀` raised to the power `n` (where `n` is a natural number) is equal to zero, then `a` must be zero. This theorem essentially formalizes the intuitive mathematical concept that only zero, when raised to a positive power, can result in zero.

If `a` is an element of a monoid with zero and no zero divisors such that `a^n = 0` for some natural number `n`, then `a = 0`.


theorem Set.union_self : ∀ {α : Type u} (a : Set α), a ∪ a = a := by sorry

The theorem `Set.union_self` states that for any type `α` and any set `a` of that type, the union of `a` with itself is equal to `a`. In other words, for any element in some category, combining it with itself does not create a new, distinct collection. This mirrors the mathematical property of union in set theory, where the union of a set with itself is just the set itself. The symbol `∪` is used to represent union in this context.

For any set `a` of type `α`, `a ∪ a = a`.


theorem Finset.sup_cons :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {b : β}
      (h : b ∉ s), Finset.sup (Finset.cons b s h) f = f b ⊔ Finset.sup s f :=
  by sorry

This theorem, `Finset.sup_cons`, states that for any types `α` and `β`, given a semilattice sup structure and order bot structure on `α`, a finite set `s` of type `β`, a function `f` mapping from `β` to `α`, and an element `b` of type `β` not in `s`, the supremum of the set obtained by adding `b` to `s` applied under `f` is equal to the supremum of `f` applied to `b` and the supremum of the set `s` under `f`. In mathematical terms, `sup {b} ∪ s f = f b ⊔ sup s f`.

For any semilattice sup and order bot structures on type `α`, given a finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `b` not in `s`, the supremum of `f` applied to `b` and the set `s` under `f` is equal to the supremum of the set obtained by adding `b` to `s` applied under `f`. In symbols: `sup (b :: s) f = sup s f ⊔ f b`.


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

This theorem, `Polynomial.eval₂_mul`, states that for any two polynomials `p` and `q` over a semiring `R`, and any ring homomorphism `f` from `R` to a commutative semiring `S`, and any value `x` in `S`, the evaluation of the product of `p` and `q` under `f` at `x` is equal to the product of the evaluations of `p` and `q` under `f` at `x`. In other words, it says that the function `Polynomial.eval₂ f x` preserves multiplication, which is a fundamental property required of a ring homomorphism. It is expressed mathematically as
\[
\text{Polynomial.eval₂}\ f\ x\ (p \times q) = \text{Polynomial.eval₂}\ f\ x\ p \times \text{Polynomial.eval₂}\ f\ x\ q
\]

For any semiring homomorphism $f$ from a semiring $R$ to a commutative semiring $S$ and any polynomials $p, q$ over $R$, the evaluation of their product under $f$ at any value $x$ in $S$ equals the product of their individual evaluations: $\text{Polynomial.eval₂}\ f\ x\ (p \times q) = \text{Polynomial.eval₂}\ f\ x\ p \times \text{Polynomial.eval₂}\ f\ x\ q$.


theorem Set.Finite.inter_of_left : ∀ {α : Type u} {s : Set α}, Set.Finite s → ∀ (t : Set α), Set.Finite (s ∩ t) := by
  sorry

This theorem states that for any type `α`, and any set `s` of type `α`, if `s` is finite, then for any other set `t` of type `α`, the intersection of `s` and `t` is also finite. In other words, the intersection of a finite set with any other set results in a finite set.

If `α` is a type and `s` and `t` are finite sets of type `α`, then the intersection `s INTER t` is also a finite set.


theorem sup_inf_left : ∀ {α : Type u} [inst : DistribLattice α] (a b c : α), a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c) := by sorry

This theorem states that for any distributive lattice of type `α`, and for any three elements `a`, `b`, and `c` of this type, the supremum of `a` and the infimum of `b` and `c`, is equal to the infimum of the supremum of `a` and `b` and the supremum of `a` and `c`. In mathematical terms, it is equivalent to saying that `a ∨ (b ∧ c) = (a ∨ b) ∧ (a ∨ c)` for all `a`, `b`, and `c` in the distributive lattice. This is a basic property of distributive lattices.

In a distributive lattice, the supremum of any two elements is commutative and associative with respect to the infimum of any other element: `(a ∨ b) ∧ c = a ∨ (b ∧ c)` for all `a`, `b`, and `c`.