/-- Introduction rule to prove that `b` is the supremum of `s`: it suffices to check that `b`
is larger than all elements of `s`, and that this is not the case of any `w<b`.
See `sSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in complete lattices.  -/
theorem csSup_eq_of_forall_le_of_forall_lt_exists_gt :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {b : α},
      Set.Nonempty s → (∀ a ∈ s, a ≤ b) → (∀ w < b, ∃ a ∈ s, w < a) → sSup s = b :=
  by sorry

This theorem, `csSup_eq_of_forall_le_of_forall_lt_exists_gt`, states that for any set `s` of elements of a conditionally complete lattice `α`, and any element `b` from `α`, if `s` is nonempty, every element `a` in `s` is less than or equal to `b`, and for every element `w` less than `b`, there exists an element `a` in `s` that is greater than `w`, then `b` is the supremum of `s`. This can be used as an introduction rule to prove that `b` is the supremum of `s`. A similar version of this theorem exists for complete lattices.

If `s` is a nonempty subset of a conditionally complete lattice `α` such that every element in `s` is less than or equal to every element `b` in `α` with `w < b` implying the existence of an element `a` in `s` with `w < a`, then `b` is the supremum of `s`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.15 :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveInv α] {s : Finset α} {a : α}, (a ∈ s⁻¹) = (a⁻¹ ∈ s) :=
  by sorry

This theorem, `Mathlib.Data.Finset.Pointwise._auxLemma.15`, holds for any type `α` with decidable equality and an involution as its inverse operation. Given a `Finset` (finite set) `s` of elements from `α` and an element `a` from `α`, the theorem states that `a` being an element of the inverse of `s` is equivalent to the inverse of `a` being an element of `s`. In mathematical terms, for any set `s` and an element `a`, we have $a \in s^{-1} \Leftrightarrow a^{-1} \in s$.

For any type `α` with decidable equality and an involution as its inverse operation, the inverse of an element is in a finite set `s` if and only if the element is in the inverse of `s`. In other words, $a \in s^{-1} \Leftrightarrow a^{-1} \in s$.


theorem Finset.prod_subtype :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] {p : α → Prop} {F : Fintype (Subtype p)} (s : Finset α),
      (∀ (x : α), x ∈ s ↔ p x) → ∀ (f : α → β), (Finset.prod s fun a => f a) = Finset.prod Finset.univ fun a => f ↑a :=
  by sorry

The theorem `Finset.prod_subtype` states that for any type `α` and `β`, given a commutative monoid structure on `β`, a property `p` on `α`, a finite type `F` of the subtype `p`, and a finite set `s` of `α`, if every element `x` in `s` satisfies the property `p`, then for any function `f` from `α` to `β`, the product of `f(a)` for all `a` in `s` is equal to the product of `f(a)` for all `a` in the universal finite set of the subtype `p`. In other words, the product over a set is equal to the product over the subtype when the property defining the subtype matches the membership in the set.

For any commutative monoid `β`, property `p` on type `α`, finite subtype `F` of `p`, and finite set `s` of `α` consisting of elements with property `p`, the product of `f(a)` for all `a` in `s` is equal to the product of `f(a)` for all `a` in the universal finite set of `p`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.53 :
    ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ := by sorry

This theorem, labeled as `Mathlib.Data.Finset.Pointwise._auxLemma.53`, states that for any type `α`, and any two finite sets `s₁` and `s₂` of this type, `s₁` is a subset of `s₂` if and only if for all elements `x` of type `α`, whenever `x` is in `s₁`, it is also in `s₂`. In other words, all elements of the first set are also elements of the second set.

For any type `α` and finite sets `s₁` and `s₂` of type `Finset α`, `s₁ ⊆ s₂` if and only if `∀ x ∈ s₁, x ∈ s₂`.


theorem atBot_le_cocompact :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : NoMinOrder α]
      [inst_3 : ClosedIicTopology α], Filter.atBot ≤ Filter.cocompact α :=
  by sorry

The theorem `atBot_le_cocompact` states that, for any type `α` equipped with a linear order, a topological space structure, an ordering without a minimal element (`NoMinOrder`), and a topology where the closed interval `(-∞, a]` is closed for each `a` (`ClosedIicTopology`), the filter representing the limit towards negative infinity (`Filter.atBot`) is less than or equal to the filter generated by the complements of compact sets (`Filter.cocompact`). In simpler terms, any sequence in `α` that tends to negative infinity is eventually in the complement of any given compact set.

For any type `α` with a linear order, NoMinOrder, ClosedIicTopology, and for filters `Filter.atBot` and `Filter.cocompact`, `Filter.atBot ≤ Filter.cocompact`. That is, any sequence in `α` tending to negative infinity is eventually contained in the complement of every compact set.


theorem Int.le_antisymm : ∀ {a b : ℤ}, a ≤ b → b ≤ a → a = b := by sorry

This theorem, `Int.le_antisymm`, states that for any two integers `a` and `b`, if `a` is less than or equal to `b` and `b` is also less than or equal to `a`, then `a` and `b` must be equal. This is basically the antisymmetry property of the less than or equal to (`≤`) relation on integers. In mathematical notation this can be written as: ∀a, b ∈ ℤ, if a ≤ b and b ≤ a then a = b.

For all integers `a` and `b`, if `a` is less than or equal to `b` and `b` is less than or equal to `a`, then `a` equals `b`. (Or, symbolically: ∀a b ∈ ℤ, a ≤ b ∧ b ≤ a → a = b)


theorem MeasureTheory.Measure.InnerRegularWRT.trans :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q q' : Set α → Prop},
      MeasureTheory.Measure.InnerRegularWRT μ p q →
        MeasureTheory.Measure.InnerRegularWRT μ q q' → MeasureTheory.Measure.InnerRegularWRT μ p q' :=
  by sorry

The theorem `MeasureTheory.Measure.InnerRegularWRT.trans` states that for any type `α`, measurable space `m` and measure `μ` on `α`, and any predicates `p`, `q`, and `q'` on the set of `α`, if the measure `μ` is inner regular with respect to `p` and `q`, and also inner regular with respect to `q` and `q'`, then it is inner regular with respect to `p` and `q'`. In other words, inner regularity with respect to two pairs of predicates is transitive. This means that given a set `U` for which `q' U` holds, and a real number `r` less than the measure of `U`, we can find a subset `K` of `U` such that `p K` holds and the measure of `K` is greater than `r`.

If measures μ on a measurable space (α, m) are inner regular with respect to predicates p and q, and inner regular with respect to q and q', then they are inner regular with respect to p and q'.


HasFDerivAtFilter.hasDerivAtFilter

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

This theorem states that for any nontrivially normed field `𝕜` and any normed add commutative group `F` that is also a normed space over `𝕜`, if a function `f` from `𝕜` to `F` has a Frechet derivative `f'` at a point `x` as `x` approaches along a filter `L`, then `f` also has the standard derivative at the point `x` along the filter `L`, where the standard derivative is given by the application of the Frechet derivative `f'` at `1`. This bridges the concept of the Frechet derivative and the standard derivative in the given settings.

If a function from a nontrivially normed field to a normed add commutative group, which is also a normed space over that field, has a Frechet derivative at a point along a filter, then that function has the standard derivative equal to the application of the Frechet derivative at 1 along that filter.


theorem Nat.sub_lt_left_of_lt_add : ∀ {n k m : ℕ}, n ≤ k → k < n + m → k - n < m := by sorry

This theorem, `Nat.sub_lt_left_of_lt_add`, states that for any three natural numbers `n`, `k`, and `m`, if `n` is less than or equal to `k`, and `k` is less than the sum of `n` and `m`, then the result of the subtraction of `n` from `k` is less than `m`. In mathematical terms, given that $n \leq k$ and $k < n + m$, it ensures that $k - n < m$.

If $n \leq k$ and $k < n + m$, then $k - n < m$.


theorem Filter.pure_prod :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : Filter β}, pure a ×ˢ f = Filter.map (Prod.mk a) f := by sorry

The theorem `Filter.pure_prod` states that for any given types `α` and `β`, any element `a` of type `α`, and any filter `f` on type `β`, the product of the singleton set `{a}` and the filter `f` is equivalent to the filter obtained by applying the function `Prod.mk a` (which pairs `a` with each element of `f`) to `f`. In other words, pairing each element of a filter with a fixed element using the product operation is the same as mapping the pair-making function over the filter.

For any types `α` and `β`, the filter obtained by applying the product operation to the singleton set `{a}` and a filter `f` on `β` is equal to the filter obtained by mapping the pairing function `Prod.mk a` over `f`.


theorem Real.toNNReal_mul : ∀ {p q : ℝ}, 0 ≤ p → Real.toNNReal (p * q) = Real.toNNReal p * Real.toNNReal q := by sorry

The theorem `Real.toNNReal_mul` states that for all real numbers `p` and `q`, if `p` is non-negative (i.e., `p` is greater than or equal to zero), then the function `Real.toNNReal` applied to the product of `p` and `q` is equal to the product of `Real.toNNReal p` and `Real.toNNReal q`. In other words, this theorem verifies the preserving property of multiplication under the `Real.toNNReal` function for non-negative real numbers.

For all non-negative real numbers `p` and `q`, `Real.toNNReal (p * q) = Real.toNNReal p * Real.toNNReal q`.


theorem Polynomial.trailingDegree_monomial :
    ∀ {R : Type u} {a : R} {n : ℕ} [inst : Semiring R],
      a ≠ 0 → Polynomial.trailingDegree ((Polynomial.monomial n) a) = ↑n :=
  by sorry

This theorem states that for any type `R`, any non-zero element `a` of `R`, and any natural number `n` within a semiring `R`, the trailing degree of the polynomial formed by the monomial `a * X^n` is equal to `n`. In other words, in a semiring, the smallest `X`-exponent in the monomial `a * X^n` is `n` when `a` is not zero.

In a semiring, the degree of the monomial `a * X^n` with non-zero `a` is equal to the natural number `n`.


theorem List.foldr_self_append : ∀ {α : Type u_1} {l' : List α} (l : List α), List.foldr List.cons l' l = l ++ l' := by
  sorry

The theorem `List.foldr_self_append` states that for all types `α` and for any two lists `l` and `l'` of type `α`, applying the `List.foldr` function on `l` with the `List.cons` function and `l'` as the initial value, results in the same list as appending `l` to `l'`. In other words, folding a list using the `cons` operation is the same as appending the two lists. This is written in mathematical notation as follows: for all `l` and `l'` in Lists of `α`, we have `List.foldr List.cons l' l = l ++ l'`.

For all types `α` and lists `l` and `l'` of type `List α`, `List.foldr List.cons l' l = l ++ l'`.


theorem Finite.card_pos : ∀ {α : Type u_1} [inst : Finite α] [h : Nonempty α], 0 < Nat.card α := by sorry

The theorem `Finite.card_pos` states that for any finite type `α` (denoted as `{α : Type u_1}`) which is nonempty (denoted as `[h : Nonempty α]`), the cardinality of `α` is strictly greater than 0. Here, cardinality is represented as a natural number by the function `Nat.card`. In simple words, a nonempty finite set always has a positive number of elements.

For any nonempty finite type `α`, the cardinality of `α` is a positive natural number.


theorem midpoint_eq_iff :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P},
      midpoint R x y = z ↔ (AffineEquiv.pointReflection R z) x = y :=
  by sorry

This theorem states that for any points `x`, `y`, and `z` in an affine space `P`, over a ring `R` with an additive commutative group `V` acting on it as a torsor, `z` is the midpoint of `x` and `y` if and only if reflecting `x` across `z` gives `y`. In other words, `z` bisects the line segment between `x` and `y` if `x` and `y` are symmetric about `z`.

Given an affine space P over a ring R with an additive commutative group V acting as a torsor, point x, y, and z in P such that reflecting x across z results in y, then z is the midpoint of the line segment between x and y.


theorem MvPolynomial.vars_mul :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (φ ψ : MvPolynomial σ R),
      MvPolynomial.vars (φ * ψ) ⊆ MvPolynomial.vars φ ∪ MvPolynomial.vars ψ :=
  by sorry

This theorem states that for any commutative semiring `R` and any type `σ` with decidable equality, and any two multivariate polynomials `φ` and `ψ` over `σ` with coefficients in `R`, the set of variables appearing in the product of `φ` and `ψ` is a subset of the union of the set of variables appearing in `φ` and the set of variables appearing in `ψ`. In other words, multiplication of multivariate polynomials does not introduce any new variables beyond those already present in the factors.

For any commutative semiring `R` and type `σ` with decidable equality, if `φ` and `ψ` are multivariate polynomials over `σ` with coefficients in `R`, then the set of variables in the product `φ ⊤ ψ` is included in the union of the sets of variables in `φ` and `ψ`.


theorem MeasureTheory.Measure.FiniteAtFilter.filter_mono :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : Filter α},
      f ≤ g → MeasureTheory.Measure.FiniteAtFilter μ g → MeasureTheory.Measure.FiniteAtFilter μ f :=
  by sorry

This theorem states that for any measurable space `α` and measure `μ` on `α`, and any two filters `f` and `g` on `α`, if `f` is a sub-filter of `g` (denoted as `f ≤ g`), then if the measure `μ` is finite at filter `g`, it must also be finite at filter `f`. In other words, if a measure is finite for a large filter, it's also finite for any smaller filter contained within the larger filter.

If `μ` is a finite measure on a measurable space `α`, and `f` is a sub-filter of `g` on `α`, then `μ` is also finite at filter `f`.


theorem MeasureTheory.memℒp_const :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (c : E) [inst_1 : MeasureTheory.IsFiniteMeasure μ],
      MeasureTheory.Memℒp (fun x => c) p μ :=
  by sorry

The theorem `MeasureTheory.memℒp_const` states that for any type `α` with a measurable space structure `m0`, any extended nonnegative real number `p`, any measure `μ` on `α`, any normed add commutative group `E`, and any element `c` of `E` such that `μ` is a finite measure, the constant function `fun x => c` is a member of `ℒp` space with respect to measure `μ`. This means that the function is almost everywhere strongly measurable and its `p`-th power norm integrated over `μ` is finite if `p` is less than infinity, or its essential supremum is less than infinity if `p` equals infinity.

For any measurable space `(α, m0)`, normed add commutative group `E`, finite measure `μ` on `α`, extended nonnegative real number `p`, and constant function `c : E`, the function `fun x => c` belongs to the `Lp` space `ℒp(α, E, μ)`.


theorem Computation.of_think_mem : ∀ {α : Type u} {s : Computation α} {a : α}, a ∈ Computation.think s → a ∈ s := by
  sorry

The theorem `Computation.of_think_mem` states that for any type `α`, computation `s` of type `Computation α`, and a value `a` of type `α`, if `a` is a member of the computation `Computation.think s` (which is the computation `s` delayed for one "tick"), then `a` is also a member of the computation `s`. In other words, delaying the computation does not change its result.

For any type `α`, computation `s` of type `Computation α`, and value `a` of type `α`, if `a ∈ Computation.think s`, then `a ∈ s`.


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

The theorem `Subsemigroup.mem_center_iff` states for any type `M` that forms a semigroup under an operation, an element `z` from `M` belongs to the center of the semigroup if and only if it commutes with every other element `g` from `M`. In other words, `z` is in the center of the semigroup if for all `g` in `M`, the operation of `g` with `z` results in the same as the operation of `z` with `g`.

An element belongs to the center of a semigroup if and only if it commutes with every other element in the semigroup.


theorem orderOf_dvd_card : ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] {x : G}, orderOf x ∣ Fintype.card G :=
  by sorry

The theorem `orderOf_dvd_card` states that for any finite group `G` and any element `x` of `G`, the order of `x` divides the cardinality of the group `G`. In other words, if we denote the order of `x` (the smallest natural number `n` such that `x^n = 1` in the group `G` or `0` if there's no such number) as `orderOf x`, and the number of elements in `G` as `Fintype.card G`, then `orderOf x` is a divisor of `Fintype.card G`. This result is a fundamental fact in group theory, often referred to as Lagrange's theorem.

The order of any element in a finite group divides the group's cardinality.


theorem MeasureTheory.SimpleFunc.integrable_iff :
    ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
      {μ : MeasureTheory.Measure α} {f : MeasureTheory.SimpleFunc α E},
      MeasureTheory.Integrable (↑f) μ ↔ ∀ (y : E), y ≠ 0 → ↑↑μ (↑f ⁻¹' {y}) < ⊤ :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.integrable_iff` states that for any measurable space `α`, normed additive commutative group `E`, measure `μ` on `α`, and simple function `f` from `α` to `E`, the function `f` is integrable with respect to measure `μ` if and only if for all `y` in `E` that are not zero, the measure of the preimage of `{y}` under `f` is finite (less than infinity). In simpler terms, a simple function is integrable if the measure of the set of points that map to every non-zero value is finite.

A simple function from a measurable space to a normed additive commutative group is integrable if and only if the measure of the preimage of every non-zero value is finite.


theorem Function.Injective.ne_iff' :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β},
      Function.Injective f → ∀ {x y : α} {z : β}, f y = z → (f x ≠ z ↔ x ≠ y) :=
  by sorry

This theorem states that for all types `α` and `β`, if a function `f` from `α` to `β` is injective (i.e., no two different elements in `α` map to the same element in `β`), then for any elements `x` and `y` in `α` and `z` in `β`, if `f y` equals `z`, then `f x` is not equal to `z` if and only if `x` is not equal to `y`. In other words, in the context of an injective function, `x` and `y` being distinct guarantees that their images under `f` will also be distinct.

For all types `α` and `β`, if `f : α → β` is injective, then for all `x`, `y` in `α` and `z` in `β`, `f x = z` implies `x = y` or `f y ≠ z`.


theorem continuous_add_left :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [inst_2 : ContinuousAdd M] (a : M),
      Continuous fun b => a + b :=
  by sorry

This theorem states that for any type `M` that has a topological space structure, an addition operation, and where the addition operation is continuous, given any element `a` of type `M`, the function that adds `a` to another element is a continuous function. In mathematical terms, if `(M, +)` is a topological space with continuous addition, then for any `a` in `M`, the map `b ↦ a + b` is continuous.

If `(M, +)` is a topological space with continuous addition, then for all `a` in `M`, the function `b mapsto a + b` is a continuous function.


theorem BoundedContinuousFunction.isBounded_range :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      (f : BoundedContinuousFunction α β), Bornology.IsBounded (Set.range ⇑f) :=
  by sorry

This theorem states that for any bounded continuous function `f` from a topological space `α` to a pseudo metric space `β`, the range of the function `f` (i.e., the set of all its output values) is a bounded set with respect to the bornology of `β`. Here, a set is said to be bounded in a bornology if its complement is co-bounded. The boundedness of a function means that there is a real number such that the absolute differences of the function values are always less than that real number, while a continuous function is one where small changes in the input lead to small changes in the output.

For any bounded and continuous function `f` from a topological space `α` to a pseudo metric space `β`, the range of `f` is a bounded set in `β` with respect to its bornology.


theorem Polynomial.eval₂_def :
    ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S) (p : Polynomial R),
      Polynomial.eval₂ f x p = Polynomial.sum p fun e a => f a * x ^ e :=
  by sorry

The theorem `Polynomial.eval₂_def` states that for any semirings `R` and `S`, a ring homomorphism `f` from `R` to `S`, a scalar `x` in `S`, and a polynomial `p` with coefficients in `R`, the evaluation of the polynomial at `x` using `f` to map coefficients is equal to the sum of the product of the mapped coefficient and `x` raised to the power of the index, for each term in the polynomial. In other words, it expresses polynomial evaluation in terms of a sum over the terms of the polynomial.

For any semirings R and S, ring homomorphism f from R to S, scalar x in S, and polynomial p with coefficients in R, the evaluation of p at x using f is equal to the sum of the products of the mapped coefficients and x raised to the corresponding powers for each term in p.


theorem Multiset.map_zero : ∀ {α : Type u_1} {β : Type v} (f : α → β), Multiset.map f 0 = 0 := by sorry

The theorem `Multiset.map_zero` states that for any function `f` mapping elements from type `α` to type `β`, the multiset obtained by mapping `f` over an empty multiset (denoted as 0) is also an empty multiset. In other words, if you apply a function to every element of an empty multiset, you get back an empty multiset.

The theorem asserts that the image of the empty multiset under any function is the empty multiset.


padicValNat.one

/-- `padicValNat p 1` is `0` for any `p`.  -/
theorem padicValNat.one : ∀ {p : ℕ}, padicValNat p 1 = 0 := by sorry

The theorem `padicValNat.one` states that for any natural number `p`, the `p`-adic valuation of `1` is `0`. In other words, for any prime number `p`, there is no power of `p` that divides `1`, and thus the maximum such power, or the `p`-adic valuation, is `0`.

The `p`-adic valuation of the natural number 1 is 0 for any prime number `p`.


theorem Set.Finite.exists_maximal_wrt :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] (f : α → β) (s : Set α),
      Set.Finite s → Set.Nonempty s → ∃ a ∈ s, ∀ a' ∈ s, f a ≤ f a' → f a = f a' :=
  by sorry

This theorem states that for any set `s` of some type `α`, where `s` is both finite and nonempty, and for any function `f` from `α` to another type `β` that has a partial order, there exists an element `a` in `s` such that `f(a)` is maximal with respect to `f` over all elements in `s`. In other words, for all other elements `a'` in `s`, if `f(a')` is not less than `f(a)`, then `f(a')` must be equal to `f(a)`. This is essentially a statement about the existence of maximal elements under a function `f` in a finite and nonempty set.

Given a finite and nonempty set `s` of type `α` and a function `f` from `α` to a partially ordered type `β`, there exists an element `a` in `s` such that for all `a'` in `s`, `f(a) ≤ f(a')` implies `f(a) = f(a')`.


CompositionSeries.strictMono

theorem CompositionSeries.strictMono :
    ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] (s : CompositionSeries X), StrictMono s.series :=
  by sorry

The theorem `CompositionSeries.strictMono` states that for any type `X` for which a lattice and a Jordan-Hölder lattice can be defined, and for any composition series `s` of type `X`, the function `s.series` is strictly monotone. This means that if `a` and `b` are any two elements in the composition series `s` such that `a < b`, then `s.series a` is strictly less than `s.series b`. This establishes an order-preserving relationship for elements in the composition series.

For any composition series `s` of a type `X` with defined lattice and Jordan-Hölder lattice, the function `s.series` is strictly increasing on the elements of the series.


theorem differentiableAt_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      (c : F), DifferentiableAt 𝕜 (fun x => c) x :=
  by sorry

The theorem `differentiableAt_const` states that for every non-trivially normed field `𝕜`, normed additive commutative group `E` and `F` which are also normed spaces over `𝕜`, and any point `x` in `E` and a constant `c` in `F`, the constant function that assigns `c` to each `x` is differentiable at `x`. In mathematical terms, this means that constant functions are always differentiable.

For any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, and constant `c` in `F`, the constant function `fc : E → F` defined by `fc x := c` is differentiable at every point `x` in `E`.


theorem bddBelow_Icc : ∀ {α : Type u} [inst : Preorder α] {a b : α}, BddBelow (Set.Icc a b) := by sorry

This theorem states that for any type `α` that has a preorder, and for any two elements `a` and `b` of this type `α`, the closed interval from `a` to `b` (i.e., the set of all elements `x` such that `a ≤ x ≤ b`) is bounded below. In simpler terms, there exists at least one element in `α` that is less than or equal to all elements in the interval from `a` to `b`.

For any preorder type `α` and elements `a` and `b` in `α`, there exists an element `c` in `α` such that `a ≤ c` and `c ≤ b`.


theorem ZMod.int_cast_eq_int_cast_iff : ∀ (a b : ℤ) (c : ℕ), ↑a = ↑b ↔ a ≡ b [ZMOD ↑c] := by sorry

This theorem states that for any two integers `a` and `b`, and a natural number `c`, the integer casting of `a` equals to the integer casting of `b` if and only if `a` is congruent to `b` modulo `c`. In mathematical terms, this can be written as: for all integers a and b, and all natural numbers c, a equals b (in terms of integer casting) if and only if a is congruent to b (mod c).

For integers `a` and `b` and natural number `c`, `ℤ(a) = ℤ(b)` if and only if `a` is congruent to `b` modulo `c` (i.e., `a ≡ b (mod c)`).


theorem Matrix.smul_empty : ∀ {α : Type u} {M : Type u_4} [inst : SMul M α] (x : M) (v : Fin 0 → α), x • v = ![] := by
  sorry

This theorem, named `Matrix.smul_empty`, states that for any type `α` and type `M`, given an instance of scalar multiplication (`SMul`) for `M` and `α`, for any scalar `x` of type `M` and any vector `v` of size 0 (an empty vector), the scalar multiplication of `x` and `v` is an empty vector. In other words, if you multiply a scalar with an empty vector, the result is an empty vector.

For any type `α` and matrix `M`, if `M` has scalar multiplication with scalar `α`, then the scalar multiplication of any scalar `x` in `M` with the empty vector of size `1` in `M` is the empty vector.


/-- A group homomorphism sends 1 to 1.  -/
theorem IsGroupHom.map_one :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : Group β] {f : α → β}, IsGroupHom f → f 1 = 1 := by sorry

This theorem statement says that for any two types `α` and `β` with group structures, if a function `f` from `α` to `β` is a group homomorphism, then `f` maps the identity element of the group `α` (denoted as `1` here) to the identity element of the group `β` (also denoted as `1` here). In other words, a group homomorphism preserves the identity element of groups.

If `f` is a group homomorphism from type `α` to type `β`, then `f(1α) = 1β`, where `1α` is the identity element of `α` and `1β` is the identity element of `β`.


theorem OrderIso.isSimpleOrder_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : BoundedOrder α]
      [inst_3 : BoundedOrder β], α ≃o β → (IsSimpleOrder α ↔ IsSimpleOrder β) :=
  by sorry

This theorem states that for any two types `α` and `β`, given that they both are Partial Orders and Bounded Orders, if there exists an order isomorphism (`≃o`) between `α` and `β`, then `α` is a simple order if and only if `β` is a simple order. In mathematical terms, a simple order is an order where there are no elements in between any two distinct elements. The theorem establishes that this property is preserved under an order isomorphism.

If `α` and `β` are types that are Partial Orders and Bounded Orders with an order isomorphism `α ≃o β`, then `α` is a simple order if and only if `β` is a simple order.


theorem Function.Periodic.sub_nat_mul_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℕ), f (x - ↑n * c) = f x :=
  by sorry

The theorem `Function.Periodic.sub_nat_mul_eq` states that for any type `α` with a ring structure, type `β`, and a function `f` from `α` to `β`, if `f` is periodic with period `c`, then for any natural number `n` and any element `x` of `α`, the value of `f` at `x - n * c` is equal to the value of `f` at `x`. In other words, subtracting any natural number multiple of the period from the input does not change the output of a periodic function.

If `f` is a periodic function from a ring `α` to a type `β` with period `c`, then for all `x ∈ α` and `n ∈ ℕ`, `f(x - n * c) = f(x)`.


theorem MeasureTheory.integrableOn_singleton_iff :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E}
      {μ : MeasureTheory.Measure α} {x : α} [inst_2 : MeasurableSingletonClass α],
      MeasureTheory.IntegrableOn f {x} μ ↔ f x = 0 ∨ ↑↑μ {x} < ⊤ :=
  by sorry

This theorem, `MeasureTheory.integrableOn_singleton_iff`, states that for any measure space `α`, any normed additive commutative group `E`, any function `α → E`, any measure `μ` on `α`, and any element `x` of `α`, the property that the function is integrable over the singleton set `{x}` (in the sense of the measure `μ`) is equivalent to one of two conditions: either the function evaluates to `0` at `x`, or the measure of the singleton set `{x}` is less than infinity. This is true under the assumption that `α` is a measurable singleton class, meaning that every singleton subset of `α` is measurable.

For any measurable singleton class α, normed additive commutative group E, function ƒ: α → E, measure μ on α, and x ∈ α, the function ƒ is integrable over the singleton {x} with respect to μ if and only if μ({x}) < ∞ or ƒ(x) = 0.


theorem Bool.and_eq_true : ∀ (a b : Bool), ((a && b) = true) = (a = true ∧ b = true) := by sorry

This theorem states that for any two boolean values `a` and `b`, the boolean 'and' operation (`a && b`) equals `true` if and only if both `a` and `b` are `true`. This reflects the basic logic concept that an 'and' operation only yields `true` when both operands are `true`.

For all boolean values `a` and `b`, `a && b` equals `true` if and only if both `a` and `b` are `true`.


theorem mul_mem_cancel_right :
    ∀ {G : Type u_1} [inst : Group G] {S : Type u_6} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G]
      {x y : G}, x ∈ H → (y * x ∈ H ↔ y ∈ H) :=
  by sorry

This theorem states that for any type `G` which is a group, and any subtype `S` of `G`, if `H` is of type `S` and both `S` and `G` have a `SubgroupClass`, then given two elements `x` and `y` from the group `G`, if `x` belongs to `H`, then `y * x` belongs to `H` if and only if `y` belongs to `H`. In mathematical terms, if `H` is a subgroup of a group and `x` is an element of `H`, then another element `y` times `x` is in `H` if and only if `y` is in `H`.

If `H` is a subgroup of group `G` and `x` is an element of `H`, then for all `y` in `G`, `y * x` is in `H` if and only if `y` is in `H`.


theorem Set.insert_inter_of_mem : ∀ {α : Type u} {a : α} {s t : Set α}, a ∈ t → insert a s ∩ t = insert a (s ∩ t) := by
  sorry

This theorem, named `Set.insert_inter_of_mem`, states that for any type `α`, any element `a` of type `α`, and any two sets `s` and `t` of type `α`, if element `a` belongs to set `t`, then the intersection of the set obtained by inserting `a` into `s` and set `t` is equal to the set obtained by inserting `a` into the intersection of sets `s` and `t`. In other words, if `a` is in `t`, then adding `a` to `s` before or after intersecting `s` and `t` doesn't affect the resultant set.

For any type `α`, sets `s` and `t` of type `α`, and element `a` of type `α` in `t`, the set `(a :: s) ∩ t` equals `a :: (s ∩ t)`.


PrincipalSeg.init

theorem PrincipalSeg.init :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [inst : IsTrans β s] (f : r ≺i s) {a : α}
      {b : β}, s b (f.toRelEmbedding a) → ∃ a', f.toRelEmbedding a' = b :=
  by sorry

This theorem, `PrincipalSeg.init`, states that for any two types `α` and `β`, two relations `r` on α and `s` on β, and a function `f` which is an initial segment of `r` with respect to `s` (`r ≺i s`), if `s` is transitive and there exists an element `b` in `β` such that `s b (f.toRelEmbedding a)`, then there exists an element `a'` in `α` such that the relational embedding of `a'` through `f` equals `b`. In other words, for every `b` in the image of `s` which is greater than the image of `a` under `f`, there must exist an `a'` in `α` which embeds to `b` under `f`.

Given types `α` and `β`, relations `r` on `α` and `s` on `β`, and a function `f` such that `r ≺i s` and `s` is transitive, if there exists an element `b` in the image of `s` with `s(b) ⊆ f(r(a))` for some `a` in `α`, then there exists an `a'` in `α` such that `f(a') = b`.


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

The theorem `EuclideanDomain.gcd_dvd` states that for any type `R` which is a Euclidean domain and has decidable equality, and for any two elements `a` and `b` of this type, the greatest common divisor (gcd) of `a` and `b` divides both `a` and `b`. This means that there exist some elements in the Euclidean domain such that when they are multiplied by the gcd of `a` and `b`, they yield `a` and `b` respectively.

For any Euclidean domain `R` with decidable equality and any elements `a` and `b` in `R`, the greatest common divisor `d` of `a` and `b` satisfies `d` | `a` and `d` | `b`. (Here, `|` denotes divisibility.)


theorem Set.sep_subset : ∀ {α : Type u} (s : Set α) (p : α → Prop), {x | x ∈ s ∧ p x} ⊆ s := by sorry

The theorem `Set.sep_subset` states that for any type `α`, any set `s` of type `α`, and any predicate `p` on `α`, the subset of `s` consisting of elements that satisfy the predicate `p` is a subset of `s`. In other words, if we filter a set based on some condition, the resulting set is always a subset of the original set. This is a fundamental result about subsets and predicates in set theory.

For any type `α`, set `s` of `α`, and predicate `p` on `α`, `{x : α | p x} ⊆ s`.


/-- If a complex function is differentiable at a real point, then the induced real function is also
differentiable at this point, with a derivative equal to the real part of the complex derivative.  -/
theorem HasStrictDerivAt.real_of_complex :
    ∀ {e : ℂ → ℂ} {e' : ℂ} {z : ℝ}, HasStrictDerivAt e e' ↑z → HasStrictDerivAt (fun x => (e ↑x).re) e'.re z := by sorry

The theorem `HasStrictDerivAt.real_of_complex` states that if a function from complex numbers to complex numbers (denoted as `e`) is strictly differentiable at a point `z` that is a real number, then the real function induced by `e` (obtained by taking the real part of the output of `e`) is also strictly differentiable at the same point `z`. Furthermore, the derivative of the induced real function at the point `z` is equal to the real part of the derivative of the complex function `e` at that point. In mathematical terms, if we have that `e` has a strict derivative `e'` at `z` (expressed as `HasStrictDerivAt e e' ↑z`), then `(fun x => (e ↑x).re)` has a strict derivative `e'.re` at `z` (expressed as `HasStrictDerivAt (fun x => (e ↑x).re) e'.re z`).

If a complex function `e` is strictly differentiable at a real number `z`, then the real function induced by `e` is also strictly differentiable at `z` and their derivatives are equal, i.e., `HasStrictDerivAt e e' ↑z` implies `HasStrictDerivAt (fun x => (e ↑x).re) (e'.re) z`.


CompleteLatticeHom.ext

theorem CompleteLatticeHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
      {f g : CompleteLatticeHom α β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two types `α` and `β`, both of which have a `CompleteLattice` structure, any two functions `f` and `g` from `α` to `β` that are `CompleteLatticeHom` (complete lattice homomorphisms), are equal if and only if they map every element of `α` to the same element in `β`. Essentially, it's saying that two complete lattice homomorphisms are identical if they behave the same way on all inputs.

Given types `α` and `β` with `CompleteLattice` structures, two functions `f` and `g` from `α` to `β` are equal as complete lattice homomorphisms if and only if they map every element of `α` to the same image in `β`.


theorem Finset.sum_le_sum_of_subset :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : CanonicallyOrderedAddCommMonoid M] {f : ι → M} {s t : Finset ι},
      s ⊆ t → (Finset.sum s fun x => f x) ≤ Finset.sum t fun x => f x :=
  by sorry

The theorem `Finset.sum_le_sum_of_subset` states that for any types `ι` and `M`, where `M` is a canonically ordered additive commutative monoid, and for any function `f` from `ι` to `M`, and any finite sets `s` and `t` of elements of type `ι`, if `s` is a subset of `t` then the sum of the function `f` evaluated at each element of `s` is less than or equal to the sum of the function `f` evaluated at each element of `t`. In other words, the sum of a function over a subset is less than or equal to the sum of the function over the whole set.

For any additive commutative monoid M and function f from a type ι to M, if s is a finite subset of t in ι, then ∑i in s (fi) ≤ ∑i in t (fi).


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

This theorem states that for any category `T` and any object `f` in the arrow category of `T`, the "right" component of the identity morphism on `f` is equal to the identity morphism on the "right" component of `f`. In terms of category theory, this means that the identity morphism in the arrow category behaves as expected with respect to the underlying category `T`.

For any category T and any arrow f in T, the right identity morphism of the identity morphism of f is equal to the identity morphism of the right component of f.


theorem sub_half : ∀ {R : Type u_1} [inst : DivisionRing R] [inst_1 : CharZero R] (a : R), a - a / 2 = a / 2 := by sorry

This theorem states that for any element `a` of any Division Ring `R` (which is not of characteristic zero), the result of subtracting half of `a` from `a` is equal to half of `a`. In other words, for all `a` in `R`, `a - a / 2 = a / 2`.

For any element `a` in a non-zero characteristic Division Ring `R`, `a - a / 2 = a / 2`.


UnionFind.model'

theorem UnionFind.model' : ∀ {α : Type u_1} (self : UnionFind α), ∃ m, UFModel.Models self.arr m := by sorry

The theorem `UnionFind.model'` states that for any type `α` and any object `self` of the type `UnionFind α`, there exists a model `m` such that `m` models the array `self.arr` according to the function `UFModel.Models`. In other words, it asserts that every instance of a `UnionFind` structure can be modeled by some `UFModel`, where the model agrees with the `UnionFind` structure's array in terms of parent and rank attributes.

For any type `α` and `UnionFind` object `self` over `α`, there exists a `UFModel` `m` such that `self.arr` and `m` agree on parent and rank attributes.


AntilipschitzWith.uniformEmbedding

theorem AntilipschitzWith.uniformEmbedding :
    ∀ {α : Type u_4} {β : Type u_5} [inst : EMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      AntilipschitzWith K f → UniformContinuous f → UniformEmbedding f :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is an extended metric space and `β` is a pseudo-extended metric space, if a function `f` from `α` to `β` is Antilipschitz with a nonnegative real number `K` and is uniformly continuous, then `f` is a uniform embedding. In other words, if for any two points `x` and `y` in `α`, the extended distance between `x` and `y` is less than or equal to `K` times the extended distance between `f(x)` and `f(y)`, and if `f` is such that for any arbitrarily close points `x` and `y` in `α`, their images `f(x)` and `f(y)` are also arbitrarily close in `β`, then `f` also preserves the uniform structure, i.e., the relationships between all points and their neighborhoods, when mapping from `α` to `β`.

If `f` is a uniformly continuous, Antilipschitz function from an extended metric space `α` to a pseudo-extended metric space `β` with constant `K`, then `f` is a uniform embedding.


theorem dist_add_right :
    ∀ {M : Type u} [inst : Add M] [inst_1 : PseudoMetricSpace M] [inst_2 : IsometricVAdd Mᵃᵒᵖ M] (a b c : M),
      dist (a + c) (b + c) = dist a b :=
  by sorry

This theorem, `dist_add_right`, states that for any type `M` that has an addition operation, is a pseudo metric space, and has an isometric space over addition, the distance between the sum of `a` and `c` and the sum of `b` and `c` is equal to the distance between `a` and `b`. In other words, adding the same value `c` to both `a` and `b` does not change their distance in the metric space, denoting the property of translation invariance in the metric space.

For any pseudo metric space `M` with an isometric space over addition, the distance between `a + c` and `b + c` equals the distance between `a` and `b` for all elements `a, b, c` in `M`.


theorem ball_normSeminorm :
    ∀ (𝕜 : Type u_3) (E : Type u_7) [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E], Seminorm.ball (normSeminorm 𝕜 E) = Metric.ball :=
  by sorry

The theorem `ball_normSeminorm` states that for any normed field `𝕜` and any seminormed additive commutative group `E` that is also a normed space over `𝕜`, the ball of a given radius at a specific point as defined by the norm seminorm of `E` is the same as the ball of the same radius at the same point as defined by the metric space structure of `E`. In other words, the sets of points within a certain distance from a given point, when measured using the seminorm or the metric, are the same.

For any normed field `𝕜` and seminormed additive commutative group `E` that is also a normed space over `𝕜`, the balls defined using the norm seminorm and the metric space structure of `E` are equal in radius and center.


theorem Set.smul_set_inter :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {s t : Set β} {a : α},
      a • (s ∩ t) = a • s ∩ a • t :=
  by sorry

This theorem states that for any given types `α` and `β`, where `α` is a group and `β` is a set upon which `α` has a multiplication action, the scalar multiplication of an element `a` from `α` with the intersection of two sets `s` and `t` from `β`, is the same as the intersection of the scalar multiplication of `a` with `s` and the scalar multiplication of `a` with `t`. In mathematical terms, it says that for every group element `a` and sets `s` and `t` we have `a * (s ∩ t) = (a * s) ∩ (a * t)`. This expresses a distributive property of scalar multiplication over set intersection in the context of group actions.

For any group action of type `α` on set `β`, the scalar multiplication of an element `a` from `α` with the intersection of sets `s` and `t` from `β` is equal to the intersection of the scalar multiplication of `a` with `s` and the scalar multiplication of `a` with `t`. In symbols, `a * (s ∩ t) = (a * s) ∩ (a * t)`.


theorem MonoidAlgebra.mul_apply :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : DecidableEq G] [inst_2 : Mul G]
      (f g : MonoidAlgebra k G) (x : G),
      (f * g) x = Finsupp.sum f fun a₁ b₁ => Finsupp.sum g fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0 :=
  by sorry

The `MonoidAlgebra.mul_apply` theorem establishes the behavior of the multiplication operation in the monoid algebra over a semiring `k` generated by the monoid `G`. Given two elements `f` and `g` of the monoid algebra, and an element `x` from the monoid `G`, the result of multiplying `f` and `g` and then applying `x` is equal to the double summation over the supports of `f` and `g`, where for each pair `(a₁, b₁)` from `f` and `(a₂, b₂)` from `g`, if the multiplication of `a₁` and `a₂` in the monoid equals `x`, then we take the product of `b₁` and `b₂` in the semiring, otherwise we take zero. This gives a formal description of the convolution product in the monoid algebra. The theorem also assumes that equality in the monoid `G` is decidable, and that `G` has a multiplication operation.

Given two elements in the monoid algebra over a semiring with decidable equality and multiplication, the product of the elements followed by application of an element from the monoid equals the double summation over their supports, where the product in the semiring is taken for matching monoid multiplications and zero otherwise.


theorem DifferentiableWithinAt.continuousWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, DifferentiableWithinAt 𝕜 f s x → ContinuousWithinAt f s x :=
  by sorry

This theorem states that for any non-trivial normed field `𝕜` and normed spaces `E` and `F`, if a function `f` from `E` to `F` is differentiable at a point `x` within a set `s`, then `f` is also continuous at `x` within `s`. In other words, differentiability within a set at a specific point implies continuity at that point within the set.

If a differentiable function between normed spaces is differentiable at a point within a set, then it is continuous at that point within the set.


/-- `zeroLocus` and `vanishingIdeal` form a galois connection.  -/
theorem ProjectiveSpectrum.gc_set :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜],
      GaloisConnection (fun s => ProjectiveSpectrum.zeroLocus 𝒜 s) fun t => ↑(ProjectiveSpectrum.vanishingIdeal t) :=
  by sorry

The theorem `ProjectiveSpectrum.gc_set` states that for any type `R` with commutative semiring structure, type `A` with commutative ring structure, an algebra structure on `R` and `A`, a function `𝒜` from natural numbers to the submodule of `R` and `A`, and a graded algebra on `𝒜`, the functions `ProjectiveSpectrum.zeroLocus 𝒜` and `fun t => ↑(ProjectiveSpectrum.vanishingIdeal t)` form a Galois connection. In other words, for any set `s` and target `t`, `ProjectiveSpectrum.zeroLocus 𝒜 s` is less than or equal to `t` if and only if `s` is less than or equal to `ProjectiveSpectrum.vanishingIdeal t`. This relationship is commonly encountered in the study of projective spectrums in algebraic geometry.

The theorem `ProjectiveSpectrum.gc_set` asserts that the mappings `ProjectiveSpectrum.zeroLocus` and `ProjectiveSpectrum.vanishingIdeal` form a Galois connection on subsets of natural numbers with respect to a given type `R` with commutative semiring structure, type `A` with commutative ring structure, an algebra structure on `R` and `A`, a function `𝒜` from natural numbers to the submodules of `R` and `A`, and a graded algebra on `𝒜`.


/-- `Finsupp.single a b` is injective in `a`. For the statement that it is injective in `b`, see
`Finsupp.single_injective`  -/
theorem Finsupp.single_left_injective :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {b : M}, b ≠ 0 → Function.Injective fun a => fun₀ | a => b := by
  sorry

The theorem `Finsupp.single_left_injective` states that for any types `α` and `M`, with `M` being a type with a zero element, and any element `b` of `M` that is not equal to zero, the function `Finsupp.single` that takes an element `a` of type `α` and maps it to a function that returns `b` for all inputs equal to `a` and zero otherwise, is injective in `a`. In other words, if two different elements `a1` and `a2` of type `α` are mapped to the same function by `Finsupp.single a b`, then `a1` must be equal to `a2`. The injectiveness in `b` is addressed in another theorem, namely `Finsupp.single_injective`.

If `α` is a type and `M` is a type with a zero element `b ≠ 0`, then the function `Finsupp.single a b` mapping `α` to the constant function with value `b` at `a` and zero elsewhere is injective on `α`.


Fintype.finite

theorem Fintype.finite : ∀ {α : Type u_4}, Fintype α → Finite α := by sorry

This theorem states that for any given type `α`, if `α` is a finite type (`Fintype α`), then `α` is also considered as a finite set (`Finite α`). This directly correlates the `Fintype` and `Finite` classes in Lean, asserting that if a type is finite, it also forms a finite set.

If `α` is a finite type, then `α` is a finite set (`Fintype α → Finite α`).


theorem csSup_le_iff' :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α},
      BddAbove s → ∀ {a : α}, sSup s ≤ a ↔ ∀ x ∈ s, x ≤ a :=
  by sorry

The theorem `csSup_le_iff'` states that for every type `α` with a conditionally complete linear order (including a bottom element), and for every set `s` of elements of type `α`, if the set `s` is bounded above, then the supremum of `s` is less than or equal to a given element `a` if and only if every element `x` in `s` is less than or equal to `a`. In other words, it gives a characterization for when a certain element `a` is an upper bound for the set `s` in terms of the supremum of `s`.

For any type `α` with a conditionally complete linear order and a set `s` of elements from `α` that has a supremum, `csSup_le_iff'` asserts that `sup s ≤ a` if and only if `x ≤ a` for all `x ∈ s`.


theorem addOrderOf_zero : ∀ {G : Type u_1} [inst : AddMonoid G], addOrderOf 0 = 1 := by sorry

This theorem states that for any type `G` that forms an additive monoid, the additive order of the element `0` is `1`. In mathematical terms, this means that the smallest positive natural number `n` such that `n * 0 = 0` (where `*` denotes the multiplication operation in the monoid) is `1`. Remember that the additive order of an element in an additive monoid is the smallest positive integer that results in the additive identity when the element is repeatedly added to itself that many times. In this case, `0` added to itself any number of times will always result in `0`, and thus its additive order is `1`.

For any additive monoid `G` with identity element `0`, the additive order of `0` is 1.


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

This theorem, `max_eq_right_of_lt`, states that for any type `α` equipped with a `LinearOrder` (which is a mathematical structure that allows us to compare elements), given two elements `a` and `b` of this type, if `a` is strictly less than `b`, then the maximum of `a` and `b` is `b`. Essentially, it's saying that if you have two things and the first one is smaller, then the biggest one is the second one.

For all types `α` with a `LinearOrder` and all `a` and `b` in `α`, if `a` is strictly less than `b`, then `max a b = b`.


theorem Finset.gcd_eq_zero_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α}, Finset.gcd s f = 0 ↔ ∀ x ∈ s, f x = 0 :=
  by sorry

This theorem states that for any types `α` and `β`, given an instance of `α` having a cancel commutative monoid with zero and a NormalizedGCDMonoid structure, and a finite set `s` of type `β` and a function `f` from `β` to `α`, the greatest common divisor of the finite set `s` under function `f` (`Finset.gcd s f`) equals zero if and only if for every element `x` in the set `s`, the function `f` applied to `x` equals zero. Essentially, this theorem provides a condition under which the greatest common divisor of a set of numbers, mapped by a given function, is zero.

For any cancel commutative monoids with zero `α` and `β`, and a function `f` from `β` to `α`: The greatest common divisor of a finite set `s` in `β`, under `f`, is zero if and only if `f(x)` is zero for all `x` in `s`.


ContinuousLinearMap.analyticAt

theorem ContinuousLinearMap.analyticAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (f : E →L[𝕜] F) (x : E), AnalyticAt 𝕜 (⇑f) x :=
  by sorry

The theorem `ContinuousLinearMap.analyticAt` states that for any given continuous linear map `f` from a type `E` to another type `F` over a nontrivially normed field `𝕜`, the map `f` is analytic at any point `x` in `E`. In other words, the function `f` admits a convergent power series expansion around any point `x`.

For any continuous linear map `f` from a nontrivially normed vector space `E` to `F` over a field `𝕜`, `f` is analytic at every point `x` in `E`, i.e., it admits a convergent power series expansion around `x`.


theorem map_eq_one_iff :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
      [inst_3 : OneHomClass F M N] (f : F), Function.Injective ⇑f → ∀ {x : M}, f x = 1 ↔ x = 1 :=
  by sorry

The theorem `map_eq_one_iff` states that for any types `M`, `N`, and `F`, given a one-structure on `M` and `N`, and a function-like structure from `M` to `N`, if `F` is also a `OneHomClass` and `f` is an injective function from `M` to `N`, then for any element `x` of `M`, `f` maps `x` to `1` if and only if `x` is `1`.

In mathematical terms, this theorem states that if `f: M → N` is an injective homomorphism preserving the one-element under the given structures, then an element `x` in `M` gets mapped to the identity element in `N` if and only if the element itself is the identity element in `M`.

Given types `M` and `N`, one-structures `one_M` and `one_N`, a function-like structure `F` from `M` to `N`, an injective homomorphism `f: M → N` as a `OneHomClass` preserving `one_M` and `one_N`, then `f x = one_N` if and only if `x = one_M`.


theorem Matrix.dotProduct_comm :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : AddCommMonoid α] [inst_2 : CommSemigroup α]
      (v w : m → α), Matrix.dotProduct v w = Matrix.dotProduct w v :=
  by sorry

The theorem `Matrix.dotProduct_comm` states that for any types `m` and `α`, where `m` has a finite number of instances and `α` is a commutative semigroup under multiplication and has a commutative monoid structure under addition, the dot product of two functions `v` and `w` (from `m` to `α`) is commutative. In other words, the dot product of `v` and `w` is equal to the dot product of `w` and `v`. This mirrors the concept in mathematics that the dot product of two vectors is commutative, i.e., the order in which the vectors are multiplied does not affect the result.

For any finite type `m` and commutative semigroup `α` under multiplication with a commutative monoid structure under addition, the dot product of two functions from `m` to `α` is commutative.


theorem measurableSet_Ico :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst : OrderClosedTopology α] {a b : α}, MeasurableSet (Set.Ico a b) :=
  by sorry

The theorem `measurableSet_Ico` states that for all types `α` having a topological space, a measurable space, an open measurable space, a linear order, and a closed order topology, and for any two elements `a` and `b` of type `α`, the left-closed right-open interval from `a` to `b` (`Set.Ico a b`) is a measurable set (in the ambient measure space on `α`). This means that for any interval where `a` is less than or equal to some `x` and `x` is less than `b`, that interval is measurable in the given measure space.

For any type `α` with a topological space, measurable space, open measurable space, linear order, and closed order topology, the interval `Ico a b` is a measurable set in the measure space on `α` for all `a ≤ x < b` in `α`.


/-- The separable degree of a polynomial is equal to
the number of distinct roots of it over any algebraically closed field.  -/
theorem Polynomial.natSepDegree_eq_of_isAlgClosed :
    ∀ {F : Type u} (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (f : Polynomial F)
      [inst_3 : IsAlgClosed E], Polynomial.natSepDegree f = (Multiset.toFinset (Polynomial.aroots f E)).card :=
  by sorry

The theorem `Polynomial.natSepDegree_eq_of_isAlgClosed` states that for any given field `F` and polynomial `f` with coefficients in `F`, and for any algebraically closed field `E` over `F`, the separable degree of `f` (which is defined as the number of distinct roots of `f` in its splitting field) is equal to the number of distinct roots of `f` in `E`. In other words, the separable degree of a polynomial is not dependent on the specific algebraically closed field chosen, and can be calculated by simply counting the distinct roots of the polynomial over any algebraically closed field.

The separable degree of a polynomial over a field is equal to the number of its distinct roots in any algebraically closed extension.


theorem Mathlib.Algebra.Group.Basic._auxLemma.22 :
    ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (0 = -a) = (a = 0) := by sorry

This theorem, named `Mathlib.Algebra.Group.Basic._auxLemma.22`, states that for any type `α` equipped with a `SubtractionMonoid` structure and for any element `a` of that type, the statement that `0` equals the negation of `a` (`0 = -a`) is equivalent to the statement that `a` equals `0` (`a = 0`). Essentially, in the context of a subtraction monoid, an element being its own additive inverse implies that this element is the additive identity `0`.

In a subtraction monoid, an element is the additive identity if and only if it is its own additive inverse.


theorem Mathlib.Algebra.Group.Basic._auxLemma.19 :
    ∀ {α : Type u_1} [inst : DivisionMonoid α] {a : α}, (a⁻¹ = 1) = (a = 1) := by sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.19`, states that for any type `α` equipped with a division operation, denoted as a division monoid, for any element `a` of that type, `a` being equal to `1` is equivalent to the inverse of `a` being `1`. In mathematical notation, this could be written as: for all `a` in `α`, `a⁻¹ = 1` if and only if `a = 1`.

For any division monoid `α`, the element `a` has an inverse equal to `1` if and only if `a` is the identity element `1` itself.


theorem Finset.card_eq_sum_card_fiberwise :
    ∀ {α : Type u_3} {β : Type u_4} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
      (∀ x ∈ s, f x ∈ t) → s.card = Finset.sum t fun a => (Finset.filter (fun x => f x = a) s).card :=
  by sorry

This theorem states that, given two finite sets `s` of type `α` and `t` of type `β`, with a function `f` mapping from `α` to `β` such that every element in `s` maps to an element in `t`, the cardinality of `s` is equal to the sum, over all elements `a` in `t`, of the cardinality of the subset of `s` where `f` equals `a`. In other terms, the size of `s` is equal to the sum of the sizes of its "fibers" under `f` over `t`.

Given two finite sets `s` and `t` with a function `f: s -> t` such that every element in `s` maps to an element in `t`, the cardinality of `s` equals the sum of the cardinalities of the fibers of `f`.


RelHom.ext

theorem RelHom.ext :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} ⦃f g : r →r s⦄,
      (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem, `RelHom.ext`, states that for any types `α` and `β`, any relations `r` on `α` and `s` on `β`, and any two relation-preserving functions `f` and `g` from `α` to `β` satisfying `r` and `s` respectively, if for every `α` the results of `f` and `g` are equal, then `f` and `g` are identical. Essentially, this is a statement of extensionality for relation-preserving functions: two such functions are equal if they agree on all inputs.

If two relation-preserving functions between types agree on every input with respect to given relations, then they are equal.


Asymptotics.IsTheta.symm

theorem Asymptotics.IsTheta.symm :
    ∀ {α : 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 =Θ[l] g → g =Θ[l] f :=
  by sorry

This theorem states that for any given types `α`, `E`, and `F`, if `f` (a function from `α` to `E`) is theta (`=Θ`) of `g` (a function from `α` to `F`) at a certain filter `l`, then `g` is also theta of `f` at the same filter. In other words, the 'theta notation', which in this context represents asymptotic equivalence, is symmetric. This means if `f` grows at the same rate as `g` under some conditions defined by `l`, then `g` also grows at the same rate as `f` under those conditions.

If `f` is theta equal to `g` at filter `l` in types `α`, `E`, and `F`, then `g` is theta equal to `f` at the same filter `l`.


theorem finprod_congr :
    ∀ {M : Type u_2} {α : Sort u_4} [inst : CommMonoid M] {f g : α → M},
      (∀ (x : α), f x = g x) → finprod f = finprod g :=
  by sorry

This theorem, `finprod_congr`, states that for any type `M` with a commutative monoid structure and a function `α → M`, if we have two such functions `f` and `g` that map each element `x` of type `α` to the same element in `M`, then the finitely supported product (or `finprod`) of `f` equals the `finprod` of `g`. In other words, if two functions are pointwise equal, then their products over their multiplicative support are also equal.

For commutative monoids M and functions f and g from type α to M that agree pointwise, their finitely supported products are equal: f ⊗₋ fin {x : α} (x ∈ s) = g ⊗₋ s, where s is a finite set and ⊗₋ denotes the finitely supported product.


ContDiff.contMDiff

/-- **Alias** of the reverse direction of `contMDiff_iff_contDiff`. -/
theorem ContDiff.contMDiff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {n : ℕ∞}
      {f : E → E'}, ContDiff 𝕜 n f → ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') n f :=
  by sorry

This theorem, named `ContDiff.contMDiff`, states that for any number `n` (which can be a natural number or infinity), and any function `f` from a normed space `E` to another normed space `E'` over a nontrivially normed field `𝕜`, if `f` is continuously differentiable up to order `n` over `𝕜`, then `f` is also continuously differentiable up to order `n` in the sense of manifold calculus on the model with corners built from `E` and `E'`. In other words, this theorem shows that the notion of continuous differentiability in the context of normed spaces extends naturally to the context of manifolds with corners.

If `f` is continuously differentiable up to order `n` as a function from a normed space `E` to another normed space `E'` over a nontrivially normed field `𝕜`, then `f` is also continuously differentiable up to order `n` as a function on the manifolds with corners built from `E` and `E'`.


theorem List.pairwise_iff_get :
    ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
      List.Pairwise R l ↔ ∀ (i j : Fin (List.length l)), i < j → R (List.get l i) (List.get l j) :=
  by sorry

This theorem states that for any type `α`, any binary relation `R` on `α`, and any list `l` of elements of type `α`, the list `l` is pairwise related by `R` if and only if, for any pair of natural numbers `i` and `j` such that `i` is less than `j` and both are valid indices into the list `l` (i.e., they are less than the length of `l`), the `i`-th element of `l` is related to the `j`-th element of `l` by `R`. In other words, a list is pairwise related by a relation if every pair of elements in the list that occur in a specific order satisfy that relation.

For any type `α` and binary relation `R` on `α`, a list `l` of elements of type `α` is pairwise related by `R` if and only if for all i < j, the i-th and j-th elements of `l` are related by `R`.


theorem CategoryTheory.Limits.image.fac_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f] {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f) h) =
        CategoryTheory.CategoryStruct.comp f h :=
  by sorry

The theorem `CategoryTheory.Limits.image.fac_assoc` states that in any category `C` with objects `X`, `Y`, and `Z`, given a morphism `f` from `X` to `Y`, and assuming that `f` has an image, for any morphism `h` from `Y` to `Z`, the composition of the morphism `f` with `h` is equal to the composition of the factor through image of `f`, the inclusion of the image of `f` into `Y`, and `h`. In other words, this theorem states the associativity of composition in terms of images in a category, capturing a fundamental characteristic of image factorization in category theory.

In any category, given morphisms $f: X \to Y$ with image $I$, and $h: Y \to Z$, the compositions $h \circ f$ and $h \circ \operatorname{im} f \circ i$ are equal, where $\operatorname{im} f$ is the image of $f$ and $i: \operatorname{im} f \to Y$ is the inclusion.


theorem convexJoin_comm :
    ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      (s t : Set E), convexJoin 𝕜 s t = convexJoin 𝕜 t s :=
  by sorry

The theorem `convexJoin_comm` states that for any two sets `s` and `t` of some type `E`, the convex join of `s` and `t` is equal to the convex join of `t` and `s`. This is under the conditions that `E` is an additive commutative monoid, `𝕜` is an ordered semiring, and a module structure over `E` with scalars from `𝕜` is defined. In simpler terms, the theorem is stating that the operation of taking the convex join of two sets is commutative, meaning the order of the sets does not change the result.

For sets `s` and `t` in an additive commutative monoid `E` over an ordered semiring `𝕜` with a module structure, the convex joins `convS (s ++ t)` and `convS (t ++ s)` are equal.


theorem CategoryTheory.Limits.bicone_ι_π_self :
    ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} (B : CategoryTheory.Limits.Bicone F) (j : J),
      CategoryTheory.CategoryStruct.comp (B.ι j) (B.π j) = CategoryTheory.CategoryStruct.id (F j) :=
  by sorry

This theorem states that for any type `J`, type `C` which forms a category, where `C` also has zero morphisms, and a function `F` that maps `J` to `C`; given a `bicone` `B` on `F` and any object `j` from `J`, the composition of the morphisms `B.ι j` and `B.π j` (in that order) is the identity morphism on the object `F j`. In other words, the composition of these two morphisms makes no change to the object `F j` in the category `C`. This theorem is a standard result in category theory, specifically within the context of limits and bicones.

For any type `J`, type `C` forming a category with zero morphisms, and a function `F : J �� /******/ C` with a bicone `B` on `F`, the composition of `B.π j` and `B.ι j` is the identity morphism on `F j` for any object `j : J`.


theorem PartENat.toWithTop_natCast' : ∀ (n : ℕ) {x : Decidable (↑n).Dom}, PartENat.toWithTop ↑n = ↑n := by sorry

This theorem states that for all natural numbers `n`, and for all instances `x` where the domain of the coercive function `↑n` is decidable, the function `PartENat.toWithTop` applied to the coercive function `↑n` is equal to the coercive function `↑n` itself. In simpler terms, it's saying that the process of converting a partial extended natural number to a natural number with infinity, when applied to a natural number, essentially leaves the natural number unchanged.

For all natural numbers `n` and decidable domains `X`, the coercion function `↑n : X → Nat` is equal to `PartENat.toWithTop ↑n`.


theorem right_comm : ∀ {α : Type u} (f : α → α → α), Commutative f → Associative f → RightCommutative f := by sorry

The theorem `right_comm` states that for any type `α` and a binary operation `f` on `α`, if `f` is commutative, meaning it satisfies the property that for all `a` and `b` in `α`, `f(a, b) = f(b, a)`, and if `f` is associative, meaning it satisfies the property that for all `a`, `b`, and `c` in `α`, `f(f(a, b), c) = f(a, f(b, c))`, then `f` is right commutative. In the context of this theorem, right commutative means that for all `b`, `a₁`, and `a₂` in `α`, `f(f(b, a₁), a₂) = f(f(b, a₂), a₁)`.

If a binary operation `f` on a type `α` is both commutative and associative, then it is right commutative.


theorem padicNormE.norm_p : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], ‖↑p‖ = (↑p)⁻¹ := by sorry

The theorem `padicNormE.norm_p` states that for any natural number `p` which is prime, the p-adic norm of `p`, denoted as `‖↑p‖`, equals the reciprocal of `p`, denoted as `(↑p)⁻¹`. In mathematical terms, this theorem asserts that the p-adic norm of a prime number is its inverse.

The p-adic norm of a prime number p is equal to the reciprocal of p, i.e., ‖↑p‖ = (↑p)⁻¹.


theorem Finset.card_Ioo_eq_card_Icc_sub_two :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a b : α),
      (Finset.Ioo a b).card = (Finset.Icc a b).card - 2 :=
  by sorry

This theorem states that for any two elements `a` and `b` of a type `α`, where `α` is a partially ordered set with a locally finite order, the cardinality or size of the set of elements `x` such that `a < x < b` (denoted as `Finset.Ioo a b`) is equal to the cardinality of the set of elements `x` such that `a ≤ x ≤ b` (denoted as `Finset.Icc a b`) minus 2. In other words, the set of elements strictly between `a` and `b` is two less than the set of elements inclusive of `a` and `b`.

For any elements `a` and `b` in a locally finite partially ordered set `α`, the cardinality of the set of elements strictly between `a` and `b` is two less than the cardinality of the set of elements inclusive of `a` and `b`.


theorem npow_add :
    ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [inst_2 : NatPowAssoc M] (k n : ℕ) (x : M),
      x ^ (k + n) = x ^ k * x ^ n :=
  by sorry

This theorem states that for any type `M` that has a multiplication and identity operation (`MulOneClass`), a power operation (`Pow`), and satisfies associativity for the natural number power operation (`NatPowAssoc`), and for any natural numbers `k` and `n`, and any element `x` of type `M`, the power of `x` raised to the sum of `k` and `n` equals the product of `x` raised to `k` and `x` raised to `n`. In mathematical notation, this is equivalent to saying that $x^{k+n} = x^k \cdot x^n$. This is basically the power of a sum property in arithmetic.

For any `M` with `MulOneClass`, `Pow`, and `NatPowAssoc`, and for all natural numbers `k` and `n` and `x` in `M`, `x^(k + n) = x^k * x^n`.


theorem PartialHomeomorph.eventually_left_inverse :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : X},
      x ∈ e.source → ∀ᶠ (y : X) in nhds x, ↑(PartialHomeomorph.symm e) (↑e y) = y :=
  by sorry

The theorem `PartialHomeomorph.eventually_left_inverse` states that for any partial homeomorphism `e` between two topological spaces `X` and `Y`, and any point `x` in the source of `e`, there is a neighborhood around `x` (in the neighborhood filter `nhds x`) such that for all points `y` in this neighborhood, applying the inverse of `e` to the image of `y` under `e` gives back `y`. In other words, within this neighborhood, the partial homeomorphism `e` and its inverse effectively cancel each other out when composed in succession.

For any partial homeomorphism between topological spaces and any point in its domain, there exists a neighborhood such that applying the inverse and then the homeomorphism maps any point in the neighborhood back to the original point.


theorem nontrivial_iff : ∀ {α : Type u_1}, Nontrivial α ↔ ∃ x y, x ≠ y := by sorry

This theorem states that a type `α` is nontrivial if and only if there exist `x` and `y` of type `α` such that `x` is not equal to `y`. Here, 'nontrivial' is a property of a type; a type is nontrivial if it has at least two distinct elements. Specifically, the theorem establishes the equivalence between the nontriviality of a type and the existence of a pair of unequal elements in that type.

A type `α` is nontrivial if and only if it has at least two distinct elements, which can be expressed as the existence of `x` and `y` in `α` such that `x ≠ y`.


theorem eq_or_ssubset_of_subset :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α}
      [inst_3 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊆ b → a = b ∨ a ⊂ b :=
  by sorry

This theorem states that for any type `α` with a subset operation and a proper subset operation, which together form a nonstrict-strict order, and for any two elements `a` and `b` of that type, if the subset operation is also antisymmetric, then if `a` is a subset of `b`, it must be the case that `a` is equal to `b` or `a` is a proper subset of `b`.

If `α` is a type with a subset operation, proper subset operation, and antisymmetric subset relation, then for all `a` and `b` in `α`, if `a` is a subset of `b`, then `a` is equal to `b` or `a` is a proper subset of `b`.


/-- The function `x ↦ x⁻¹` tends to `+∞` on the right of `0`.  -/
theorem tendsto_inv_zero_atTop :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : OrderTopology 𝕜],
      Filter.Tendsto (fun x => x⁻¹) (nhdsWithin 0 (Set.Ioi 0)) Filter.atTop :=
  by sorry

The theorem `tendsto_inv_zero_atTop` states that for any type `𝕜` that is a linear ordered field with an associated topological space and order topology, the function defined as the reciprocal of `x` (`x ↦ x⁻¹`) tends to positive infinity (`+∞`) as `x` approaches 0 from the right side. This is formalized by saying that the function `x ↦ x⁻¹` has `Filter.atTop` (representing `+∞`) as its limit when the input `x` is taken from a neighborhood of 0 that lies within the interval `(0, ∞)` (`Set.Ioi 0`). This means that as `x` gets arbitrarily close to 0 from the right, the value of `x⁻¹` gets arbitrarily large.

For any linear ordered field `𝕜` with associated topological space and order topology, the reciprocal function `x ↦ x⁻¹` approaches positive infinity as `x` approaches 0 from the right in the order topology (`Set.Ioi 0`).


theorem AddCommute.add_nsmul :
    ∀ {M : Type u} [inst : AddMonoid M] {a b : M}, AddCommute a b → ∀ (n : ℕ), n • (a + b) = n • a + n • b := by sorry

This theorem states that for any types `M` that is an additive monoid and any two elements `a` and `b` of `M` that commute with respect to addition (`AddCommute a b`), and for any natural number `n`, the n-fold scalars of the sum of `a` and `b` (`n • (a + b)`) equals to the sum of the n-fold scalars of `a` and `b` (`n • a + n • b`). In other words, the process of scaling and addition can be interchanged when `a` and `b` are commutative with respect to addition.

For any commuting additive monoid elements `a` and `b` and natural number `n`, the scalars `n • a` and `n • b` commute, and `n • (a + b)` equals the sum `n • a + n • b`.


theorem StieltjesFunction.measure_univ :
    ∀ (f : StieltjesFunction) {l u : ℝ},
      Filter.Tendsto (↑f) Filter.atBot (nhds l) →
        Filter.Tendsto (↑f) Filter.atTop (nhds u) → ↑↑(StieltjesFunction.measure f) Set.univ = ENNReal.ofReal (u - l) :=
  by sorry

This theorem states that for any Stieltjes function `f` and real numbers `l` and `u`, if `f` tends to `l` as the input approaches negative infinity (represented by `Filter.atBot`) and `f` tends to `u` as the input approaches positive infinity (represented by `Filter.atTop`), then the measure of the universal set (which includes all real numbers) according to the measure defined by `f` is equal to the extended non-negative real value of `(u - l)`. In other words, provided the limit conditions for `f`, the total "mass" or measure over all real numbers as per the Stieltjes function is just the difference between the limits at positive and negative infinity.

For any Stieltjes function `f`, if `f` has finite limits `l` as the input approaches negative infinity and `u` as the input approaches positive infinity, then the integral of `f` over the real numbers is equal to `u - l`.


theorem Multiset.fold_zero :
    ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α),
      Multiset.fold op b 0 = b :=
  by sorry

The theorem `Multiset.fold_zero` states that for any type `α`, any binary operation `op` that is both commutative and associative, and any value `b` of type `α`, the result of folding the operation `op` over an empty multiset (represented as `0`) starting with `b` is `b`. In other words, applying a commutative and associative operation iteratively over no elements leaves the initial value unchanged.

For any commutative and associative binary operation `op` and value `b`, the empty multiset fold of `op` starting with `b` equals `b`. In other words, `Multiset.fold op b Ø = b`.


theorem Finset.not_mem_mono : ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s := by sorry

This theorem states that for any type `α` and any two finite sets `s` and `t` of this type, if `s` is a subset of `t`, then for any element `a` of type `α`, if `a` is not in `t`, then `a` is also not in `s`. In other words, if a certain item doesn't belong to a larger set, then it certainly doesn't belong to any of its subsets.

If `s` is a subset of `t` and `a` is an element not in `t`, then `a` is not in `s`.


theorem hasBasis_coLindelof :
    ∀ {X : Type u} [inst : TopologicalSpace X], Filter.HasBasis (Filter.coLindelof X) IsLindelof compl := by sorry

The theorem `hasBasis_coLindelof` states that for any type `X` equipped with a topological space structure, the filter `Filter.coLindelof X`, which is generated by the complements of Lindelöf sets, has a basis characterized by Lindelöf sets and their complements. In other words, each set in this filter can be generated by taking intersections of the complements of Lindelöf sets. A set is Lindelöf if every nontrivial filter with the property that it has countable intersections and contains the set, also has a cluster point in the set.

The filter `Filter.coLindelof` on a topological space `X` is equal to the filter generated by the complements of Lindelöf sets.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.43 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem is in the realm of logic and propositional calculus. It states that for any two propositions 'a' and 'b', the existence of 'b' given 'a' (denoted as `∃ (_ : a), b`) is logically equivalent to the conjunction of 'a' and 'b' (denoted as `a ∧ b`). In other words, affirming that 'b' is true if 'a' is true is the same as asserting that both 'a' and 'b' are true.

The theorem asserts that for any propositions 'a' and 'b' in logic, `∃ (x : a), b` is logically equivalent to `a ∧ b`.


CategoryTheory.Sieve.galoisConnection

theorem CategoryTheory.Sieve.galoisConnection :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
      GaloisConnection (CategoryTheory.Sieve.pushforward f) (CategoryTheory.Sieve.pullback f) :=
  by sorry

The theorem `CategoryTheory.Sieve.galoisConnection` states that for any category `C`, and any morphism `f` from an object `Y` to an object `X` within `C`, there is a Galois connection between the operation of pushing forward a sieve along `f` and the operation of pulling back a sieve along `f`. This means that for a given sieve on `Y`, pushing it forward along `f` and then pulling it back yields a sieve that is less than or equal to the original. And conversely, for a given sieve on `X`, pulling it back along `f` and then pushing it forward yields a sieve that is greater than or equal to the original.

For any morphism `f` in a category `C` and any sieve on `Y`, the image of the sieve under `f` (pushed forward) is included in the pullback of the sieve along `f`, and conversely, for any sieve on `X`, the pullback of the sieve along `f` is included in the image of the sieve under `f`.


/-- **Alias** of the forward direction of `isUpperSet_iff_Ici_subset`. -/
theorem IsUpperSet.Ici_subset :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, IsUpperSet s → ∀ ⦃a : α⦄, a ∈ s → Set.Ici a ⊆ s := by sorry

The theorem `IsUpperSet.Ici_subset` states that for any type `α` with a preorder, if a set `s` is an upper set, then for any element `a` in `s`, the interval from `a` to infinity (`Set.Ici a`) is a subset of `s`. In simpler terms, if a set includes all elements greater than any of its members, then starting from any member of the set and going towards infinity, all those elements are contained within the set.

If `s` is an upper set of a preordered type `α`, then `s ⊆ Set.Ici a` for all `a ∈ s`.


theorem Function.Surjective.iInf_comp :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : InfSet α] {f : ι → ι'},
      Function.Surjective f → ∀ (g : ι' → α), ⨅ x, g (f x) = ⨅ y, g y :=
  by sorry

The theorem `Function.Surjective.iInf_comp` states that for any type `α` with an instance of `InfSet` (which means that we can take infima of subsets of `α`), any two types `ι` and `ι'`, and any surjective function `f` from `ι` to `ι'`, the infimum of the composition of any function `g` from `ι'` to `α` with `f` over all elements in `ι` is the same as the infimum of `g` over all elements in `ι'`. In other words, if `f` is surjective, then taking infimums before or after applying `g` doesn't change the result.

For any surjective function `f` between indexed types `ι` and `ι'`, and any function `g` from `ι'` to a type `α` with an `InfSet` instance, the infimum of `g` over `ι'` is equal to the infimum of `g ∘ f` over `ι`.


theorem Nat.lt_succ_iff_lt_or_eq : ∀ {m n : ℕ}, m < Nat.succ n ↔ m < n ∨ m = n := by sorry

This theorem states that for any two natural numbers `m` and `n`, `m` is less than the successor of `n` if and only if `m` is either less than `n` or equal to `n`. In the context of natural numbers, the successor of a number `n` is simply `n + 1`. Hence, this theorem essentially provides a condition for when a number is less than or equal to another number.

For natural numbers `m` and `n`, `m` is less than `n + 1` if and only if `m` is less than or equal to `n`.


theorem sInf_eq_iInf' : ∀ {α : Type u_1} [inst : InfSet α] (s : Set α), sInf s = ⨅ a, ↑a := by sorry

The theorem `sInf_eq_iInf'` states that, for any type `α` endowed with an `InfSet` structure (which allows us to take the infimum, or greatest lower bound, of a set of elements of type `α`), and for any set `s` of elements of type `α`, the supremum of the infimums (denoted by `sInf`) of the set `s` is equal to the infimum (`⨅`) of the elements of `s`, when each element is considered as a member of a larger set (indicated by `↑a`). This theorem essentially expresses a property of the interplay between suprema and infima in such structures.

For any set `s` in a type `α` endowed with an `InfSet` structure, `sInf (s : Set α) = ⨅ x ∈ s ^sup (⨅ y ∈ ↑s x)`.


/-- Representing an element of a ring's unit group as an element of the ring commutes with
mapping this element to its additive inverse.  -/
theorem Units.val_neg : ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] (u : αˣ), ↑(-u) = -↑u := by sorry

This theorem states that for any element `u` of the unit group of a ring `α`, representing `u` as an element of the ring, and then taking its negative, is the same as first taking the negative of `u` in the unit group, and then representing the result as an element of the ring. Here, `αˣ` refers to the unit group of the ring, i.e., the set of invertible elements under multiplication, and `-u` and `-↑u` denotes the additive inverses in the unit group and the ring, respectively.

For any unit `u` in a ring `α`, the negative of `u` as an element of the ring is equivalent to the negative of the unit `u` in the multiplicative group of units.


theorem Filter.mem_inf_of_right : ∀ {α : Type u} {f g : Filter α} {s : Set α}, s ∈ g → s ∈ f ⊓ g := by sorry

This theorem states that for any type `α`, and given two filters `f` and `g` on `α`, along with a set `s` of elements of type `α`, if the set `s` is a member of filter `g`, then `s` is also a member of the infimum (i.e., greatest lower bound) of filters `f` and `g`. In other words, if a set belongs to a filter, it will also belong to the infimum of that filter with any other filter.

If filters `f` and `g` on type `α` have a common element set `s`, then `s` belongs to the infimum of `f` and `g`.


/-- `∧` distributes over `∨` (on the left).  -/
theorem and_or_left : ∀ {a b c : Prop}, a ∧ (b ∨ c) ↔ a ∧ b ∨ a ∧ c := by sorry

This theorem states that the logical "and" operation distributes over the logical "or" operation on the left side. In other words, for any three propositions `a`, `b`, and `c`, the proposition "a and (b or c)" is logically equivalent to the proposition "(a and b) or (a and c)". This is an instance of a general principle in logic and set theory known as distributivity.

The logical "and" operation distributes over the logical "or" operation: a × (b ∨ c) ≡ (a × b) ∨ (a × c), where × represents logical and and ∨ represents logical or.


ContDiff.contDiffWithinAt

theorem ContDiff.contDiffWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞}, ContDiff 𝕜 n f → ContDiffWithinAt 𝕜 n f s x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F` (over `𝕜`), a set `s` of `E`, a function `f` from `E` to `F`, a point `x` in `E`, and a number `n` (which could be a natural number or infinity), if the function `f` is continuously differentiable `n` times over the entire domain, then it's also continuously differentiable `n` times within the set `s` at the point `x`.

If `f` is a continuously differentiable function of order `n` on the entire normed additive commutative group `E` over the non-trivially normed field `𝕜`, then `f` is continuously differentiable of order `n` at every point `x` in any subset `s` of `E`.


theorem OreLocalization.zero_div_eq_zero :
    ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (s : ↥S), 0 /ₒ s = 0 :=
  by sorry

This theorem states that for any type `R` that has a `Semiring` structure and any `S` which is a submonoid of `R`, if `S` is also an `OreLocalization.OreSet`, then the division of zero by any element `s` in `S` (notated as `0 /ₒ s`) is equal to zero. Essentially, it's stating that in this specific algebraic setting, division of zero by any non-zero element results in zero, mirroring a common property in ordinary division.

For any semiring `R` and submonoid `S` of `R` that is an `OreLocalization.OreSet`, the division of zero by any element `s` in `S`, `0 /ₒ s`, equals zero.


theorem Polynomial.coeff_reverse :
    ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R) (n : ℕ),
      Polynomial.coeff (Polynomial.reverse f) n = Polynomial.coeff f ((Polynomial.revAt (Polynomial.natDegree f)) n) :=
  by sorry

This theorem states that for any semiring `R`, and for any polynomial `f` over `R` and any natural number `n`, the coefficient of the `n`th term in the reverse of `f` is equal to the coefficient of the term in `f` corresponding to the index obtained by applying the `revAt` function to `n` with `f`'s natural degree as the parameter. In other words, when you reverse a polynomial, the coefficients of the terms are reflected around the "center" which is the natural degree of the polynomial.

For any semiring `R`, polynomial `f` over `R` of degree `n`, the coefficient of the `n`th term in the reversed form of `f` equals the coefficient of the term in `f` indexed by `revAt n (degree f)`.


theorem MulAction.mem_fixedBy :
    ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {m : M} {a : α},
      a ∈ MulAction.fixedBy α m ↔ m • a = a :=
  by sorry

The theorem `MulAction.mem_fixedBy` states that for any type `M` with a monoid structure, any type `α` on which `M` acts as a multiplicative action, any element `m` of type `M` and any element `a` of type `α`, `a` is an element of the set of elements fixed by `m` (`MulAction.fixedBy α m`) if and only if the action of `m` on `a` leaves `a` unchanged (i.e., `m • a = a`). In other words, it provides a characterization of the set of elements fixed by a given element in the monoid under the given action.

For any type `M` with a monoid structure, any type `α` on which `M` acts as a multiplicative action, and any `m` in `M` and `α` in `α`, `α` is in the set of elements fixed by `m` if and only if `m • α = α`.


theorem Finset.card_Ioc_eq_card_Icc_sub_one :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a b : α),
      (Finset.Ioc a b).card = (Finset.Icc a b).card - 1 :=
  by sorry

This theorem states that for any given two elements `a` and `b` of an ordered and locally finite type `α`, the number of elements in the interval `(a, b]`, represented as the finite set `Finset.Ioc a b`, is equal to the number of elements in the inclusive interval `[a, b]`, represented as `Finset.Icc a b`, minus one. In other words, the cardinality of `Finset.Ioc a b` is the cardinality of `Finset.Icc a b` subtracted by one. This makes sense intuitively as the set `Finset.Ioc a b` does not include the element `a` which is included in `Finset.Icc a b`.

The cardinality of the open interval between two elements in an ordered and locally finite type equals the cardinality of the closed interval between those elements minus one.


/-- The finrank of a free module `M` over `R` is the cardinality of `ChooseBasisIndex R M`.  -/
theorem FiniteDimensional.finrank_eq_card_chooseBasisIndex :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : StrongRankCondition R] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : Module.Free R M] [inst_5 : Module.Finite R M],
      FiniteDimensional.finrank R M = Fintype.card (Module.Free.ChooseBasisIndex R M) :=
  by sorry

The theorem `FiniteDimensional.finrank_eq_card_chooseBasisIndex` states that for any ring `R` with a strong rank condition, any module `M` over `R` that is both free and finite, the rank of the module `M` (also known as finite dimension) is equal to the cardinality of the index set that indexes the basis of `M`. In other words, the number of basis elements of `M` is the same as the dimension of `M`. Here, the rank of a module is defined to be 0 if the module has infinite rank.

For a free and finite module M over a ring R with a strong rank condition, the rank (or finite dimension) of M equals the cardinality of a basis for M.


theorem LinearMap.smul_apply :
    ∀ {R : Type u_1} {R₂ : Type u_3} {S : Type u_6} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
      [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : Monoid S] [inst_7 : DistribMulAction S M₂]
      [inst_8 : SMulCommClass R₂ S M₂] (a : S) (f : M →ₛₗ[σ₁₂] M₂) (x : M), (a • f) x = a • f x :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, an additive commutative monoid `M`, another additive commutative monoid `M₂`, a module `M` over `R`, a module `M₂` over `R₂`, a ring homomorphism `σ₁₂` from `R` to `R₂`, a monoid `S`, a distributive multiplication action of `S` on `M₂`, and a commutative multiplication action of `R₂` and `S` on `M₂`, given an element `a` from `S`, a linear map `f` from `M` to `M₂`, and an element `x` from `M`, the application of the scaled linear map `(a • f)` to `x` is equal to the scaled result of the linear map `f` applied to `x`. In mathematical terms, this can be written as `(a • f)(x) = a • f(x)`.

For any semirings R and R₂, additive commutative monoids M and M₂, module M over R, module M₂ over R₂, ring homomorphism σ₁₂ from R to R₂, monoid S acting distributively on M₂, commutative action of R₂ and S on M₂, element a from S, linear map f from M to M₂, and element x from M, the scaled linear map (a • f) equals the scaled result of applying f to x, that is, (a • f)(x) = a • f(x).


/-- A product set is included in a product set if and only factors are included, or a factor of the
first set is empty.  -/
theorem Set.prod_subset_prod_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β},
      s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ :=
  by sorry

The theorem `Set.prod_subset_prod_iff` states that for any types `α` and `β`, and any sets `s` and `s₁` of type `α`, and `t` and `t₁` of type `β`, the cartesian product of `s` and `t` is a subset of the cartesian product of `s₁` and `t₁` if and only if either `s` is a subset of `s₁` and `t` is a subset of `t₁`, or `s` is an empty set, or `t` is an empty set. In other words, a cartesian product of two sets is contained within another cartesian product of two sets if either both sets are subsets of the corresponding sets in the second product, or one of the sets in the first product is empty.

For sets `s` of type `α` and `t` of type `β`, `Set.prod s t ⊆ Set.prod s₁ t₁` if and only if `s ⊆ s₁` and `t ⊆ t₁`, or `s = ∅` or `t = ∅`.


Bornology.IsBounded.union

theorem Bornology.IsBounded.union :
    ∀ {α : Type u_2} {x : Bornology α} {s t : Set α},
      Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s ∪ t) :=
  by sorry

The theorem `Bornology.IsBounded.union` states that for any type 'α' with a bornology 'x' and any two sets 's' and 't' of type 'α', if 's' and 't' are both bounded relative to the bornology 'x', then the union of 's' and 't' is also bounded relative to the same bornology. In other words, the union of two bounded sets in a bornological space is again a bounded set.

If 'α' is a type with bornology 'x', and 's' and 't' are bounded subsets of 'α' relative to 'x', then their union is also a bounded subset of 'α' relative to 'x'.


theorem monotone_mul_right_of_nonneg :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a : α}, 0 ≤ a → Monotone fun x => x * a := by sorry

This theorem, `monotone_mul_right_of_nonneg`, states that for any type `α` endowed with an ordered semiring structure and any nonnegative element `a` of type `α`, the function that multiplies `x` by `a` is monotone. In other words, if `0 ≤ a`, then for any `x` and `y` of type `α` where `x ≤ y`, it follows that `x * a ≤ y * a`.

For any ordered semiring `α` and non-negative element `a` in `α`, the multiplication function `x => x * a` is monotone.


theorem Filter.IsBoundedUnder.isBigO_const :
    ∀ {α : Type u_1} {E : Type u_3} {F'' : Type u_10} [inst : Norm E] [inst_1 : NormedAddCommGroup F''] {f : α → E}
      {l : Filter α},
      Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ f) → ∀ {c : F''}, c ≠ 0 → f =O[l] fun _x => c :=
  by sorry

This theorem states that for any types `α`, `E`, and `F''`, given a normed space `E`, a normed additive commutative group `F''`, a function `f` from `α` to `E`, and a filter `l` on `α`; if the image of the filter `l` under the norm of `f` is eventually bounded with respect to the less than or equal to relation, then for any non-zero constant `c` from `F''`, `f` is big O of the constant function that always returns `c` with respect to the filter `l`. This is a statement about asymptotic complexity: it says that if `f` is eventually bounded, then its growth rate is at most constant.

If a function from a type to a normed space is eventually bounded with respect to a filter, then its growth rate is at most constant with respect to that filter.


theorem Polynomial.modByMonic_X_sub_C_eq_C_eval :
    ∀ {R : Type u} [inst : CommRing R] (p : Polynomial R) (a : R),
      p %ₘ (Polynomial.X - Polynomial.C a) = Polynomial.C (Polynomial.eval a p) :=
  by sorry

The theorem `Polynomial.modByMonic_X_sub_C_eq_C_eval` states that for any commutative ring `R`, any polynomial `p` over `R`, and any element `a` of `R`, the remainder of `p` when divided by the polynomial `X - C a` (where `X` is the polynomial variable and `C a` is the constant polynomial `a`) is equal to the constant polynomial whose coefficient is the value of `p` evaluated at `a`. In mathematical terms, this can be written as `p mod (X - a) = C(p(a))` for any polynomial `p` and any `a` in a commutative ring.

For any commutative ring R, polynomial p over R, and its element a, the remainder of p divided by X - Ca equals the constant polynomial with coefficient p(a).