theorem MeasureTheory.AEEqFun.instSMul.proof_1 :
    ∀ {γ : Type u_1} [inst : TopologicalSpace γ] {𝕜 : Type u_2} [inst_1 : SMul 𝕜 γ] [inst_2 : ContinuousConstSMul 𝕜 γ]
      (c : 𝕜), Continuous fun x => c • id x :=
  by sorry

This theorem states that for any type `γ` equipped with a topological space structure, and any type `𝕜` equipped with a scalar multiplication (`SMul`) operation, if the scalar multiplication operation is continuously constant, then for any element `c` of type `𝕜`, the function that maps each element `x` of type `γ` to `c` times `x` (denoted by `c • id x`) is continuous.

If a scalar multiplication operation on a type `𝕜` is continuous and `γ` is a topological space, then the function that maps each element `x` in `γ` to `c` times `x` (`c • id x`) is continuous for all `c` in `𝕜`.


theorem getElem?_neg :
    ∀ {Cont : Type u_1} {Idx : Type u_2} {Elem : Type u_3} {Dom : Cont → Idx → Prop} [inst : GetElem Cont Idx Elem Dom]
      (a : Cont) (i : Idx), ¬Dom a i → ∀ [inst_1 : Decidable (Dom a i)], a[i]? = none :=
  by sorry

This theorem, `getElem?_neg`, states that for any given types `Cont`, `Idx`, and `Elem`, and a predicate `Dom` of type `Cont → Idx → Prop`, given an instance of `GetElem` typeclass for these types and predicate, and an instance `a` of `Cont` and `i` of `Idx` such that the predicate `Dom a i` is not true (denoted by `¬Dom a i`), then for any instance `inst_1` that can decide the truth value of `Dom a i`, the indexed getter function `a[i]?` applied to `a` and `i` will always return `none`. Essentially, it says that if the domain predicate doesn't hold for an index and a container, then the getter function returns `none` for that index in the container.

If `Dom` is a predicate on containers `Cont` and indices `Idx` such that for any `a : Cont` and `i : Idx` with `¬Dom a i`, the getter function `a[i]?` always returns `none`.


theorem Finset.uIcc_subset_uIcc :
    ∀ {α : Type u_2} [inst : Lattice α] [inst_1 : LocallyFiniteOrder α] {a₁ a₂ b₁ b₂ : α},
      a₁ ∈ Finset.uIcc a₂ b₂ → b₁ ∈ Finset.uIcc a₂ b₂ → Finset.uIcc a₁ b₁ ⊆ Finset.uIcc a₂ b₂ :=
  by sorry

The theorem `Finset.uIcc_subset_uIcc` states that for any type `α` that is a lattice and has a locally finite order, and any elements `a₁`, `a₂`, `b₁`, `b₂` of `α`, if `a₁` is in the set defined by `Finset.uIcc a₂ b₂` and `b₁` is in the same set, then the set defined by `Finset.uIcc a₁ b₁` is a subset of `Finset.uIcc a₂ b₂`. In other words, if `a₁` and `b₁` both lie within the interval from `a₂` to `b₂` (inclusive), then the interval from `a₁` to `b₁` (inclusive) is entirely contained within the interval from `a₂` to `b₂`.

For any lattice type `α` with locally finite order and elements `a₁`, `a₂`, `b₁`, `b₂` in `α`, if `a₁ ∈ Finset.uIcc a₂ b₂` and `b₁ ∈ Finset.uIcc a₂ b₂`, then `Finset.uIcc a₁ b₁ ⊆ Finset.uIcc a₂ b₂`.


theorem Complex.arg_of_re_nonneg : ∀ {x : ℂ}, 0 ≤ x.re → Complex.arg x = Real.arcsin (x.im / Complex.abs x) := by sorry

This theorem states that for any complex number `x`, if the real part of `x` is nonnegative, then the argument of `x` is equal to the arcsine of the quotient of the imaginary part of `x` and the absolute value of `x`. In mathematical terms, if `Re(x) ≥ 0`, then `arg(x) = arcsin(Im(x) / |x|)`. Here, `Re(x)` and `Im(x)` refer to the real and imaginary parts of `x` respectively, `arg(x)` is the argument of `x`, `arcsin` is the inverse sine function, and `|x|` is the absolute value of `x`.

If a complex number `x` has nonnegative real part, then its argument equals the arcsine of its imaginary part divided by its absolute value: `arg(x) = arcsin(Im(x) / |x|)`.


theorem le_iff_exists_nonneg_add :
    ∀ {α : Type u} [inst : OrderedSemiring α] [inst_1 : ExistsAddOfLE α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α),
      a ≤ b ↔ ∃ c ≥ 0, b = a + c :=
  by sorry

This theorem, `le_iff_exists_nonneg_add`, states that for all types `α` that are ordered semirings and support the existence of an additive operation satisfying the less than or equal to (`≤`) relation, and have a contravariant order-preserving addition operation, given any two elements `a` and `b` of type `α`, `a` is less than or equal to `b` if and only if there exists a non-negative `c` such that `b` is equal to the sum of `a` and `c`.

For all ordered semirings `α` with a contravariant order-preserving addition and for all `a, b` in `α`, `a ≤ b` if and only if there exists a non-negative `c` such that `b = a + c`.


theorem Behrend.map_succ :
    ∀ {n d : ℕ} (a : Fin (n + 1) → ℕ),
      (Behrend.map d) a = a 0 + (Finset.sum Finset.univ fun x => a (Fin.succ x) * d ^ ↑x) * d :=
  by sorry

The theorem `Behrend.map_succ` states that for any natural numbers `n` and `d`, and a function `a` from `Fin (n + 1)` to `ℕ`, the map associated with `Behrend.map` when applied to `a` is equal to `a(0)` plus the sum, over all elements `x` in the finite set `Finset.univ`, of `a(Fin.succ(x)) * d ^ ↑x`, all multiplied by `d`. Essentially, this theorem describes how the Behrend map behaves when it is applied to a function on the successor of a finite ordinal number.

For any natural numbers `n` and `d`, and a function `a` from `Fin (n + 1)` to `ℕ`, the Behrend map of `a` is equal to `a(0) + ∑ₕ in Finset.univ {d ^ up x * a (Fin.succ x)}`.


theorem contDiffWithinAt_prod' :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E} {n : ℕ∞} {𝔸' : Type u_4} {ι : Type u_5}
      [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸'] {t : Finset ι} {f : ι → E → 𝔸'},
      (∀ i ∈ t, ContDiffWithinAt 𝕜 n (f i) s x) → ContDiffWithinAt 𝕜 n (Finset.prod t fun i => f i) s x :=
  by sorry

The theorem `contDiffWithinAt_prod'` states that for any nontrivially normed field `𝕜`, a normed additive commutative group `E` over `𝕜`, a set `s` of elements of `E`, an element `x` in `E`, a natural number `n` (possibly infinity), a normed commutative ring `𝔸'` over `𝕜`, a finite set `t` of elements of some type `ι`, and a function `f` mapping each element of `ι` to a function from `E` to `𝔸'`, if each function `f i` is continuously differentiable within `s` at `x` to order `n` for every `i` in `t`, then the product of all the functions `f i` (i.e., `Finset.prod t fun i => f i`) is also continuously differentiable within `s` at `x` to order `n`.

In mathematical terms, if `$f_i : E \to 𝔸'$` is continuously differentiable to order `n` within a set `s` at a point `x` for all `i` in a finite set `t`, then the product of the `$f_i$`'s is also continuously differentiable to the same order within `s` at `x`.

If each function in a finite set of continuously differentiable functions from a normed additive commutative group to a normed commutative ring is continuously differentiable within a set to order n at a point, then their product is also continuously differentiable to the same order within that set at that point.


theorem Mathlib.Analysis.Seminorm._auxLemma.16 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.closedBall 0 r) = (‖a‖ ≤ r) := by sorry

This theorem states that for any type `E` that forms a semi-normed add group, and any element `a` of this type and real number `r`, the element `a` belongs to the closed ball centered at 0 with radius `r` in the pseudo metric space defined by the distance function if and only if the semi-norm of `a` is less than or equal to `r`. In mathematical notation, this could be expressed as $a \in B[0,r] \iff \|a\| \leq r$.

For any semi-normed add group `E` and real number `r`, an element `a` in `E` belongs to the closed ball `B[0,r]` if and only if the semi-norm of `a` is less than or equal to `r`. In symbols: $a \in B[0,r] \iff \|a\| \leq r$.


theorem Mathlib.Analysis.Seminorm._auxLemma.22 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t u : Set β},
      (s • t ⊆ u) = ∀ a ∈ s, ∀ b ∈ t, a • b ∈ u :=
  by sorry

The theorem `Mathlib.Analysis.Seminorm._auxLemma.22` states that for any types `α` and `β`, given a scalar multiplication operation on `β` by elements of `α` and three sets, `s` of type `α` and `t` and `u` of type `β`, the condition that the scalar multiplication of every element of `s` with every element of `t` falls within the set `u` (represented as `s • t ⊆ u`) is equivalent to the statement that for every element `a` in `s` and every element `b` in `t`, the result of `a` scaling `b` is an element of `u`. In other words, the set of all scalar multiples `a • b` where `a` is from `s` and `b` is from `t` is a subset of `u` if and only if every such scalar multiple `a • b` is an element of `u`.

For sets \(s \subseteq \alpha, t \subseteq \beta\), the condition that \(a \cdot b \in u\) for all \(a \in s\) and \(b \in t\) is equivalent to \(s \cdot t \subseteq u\), where \(s \cdot t = \{ a \cdot b \mid a \in s, b \in t \}\).


theorem Mathlib.Analysis.Seminorm._auxLemma.23 :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) {y : E} {r : ℝ}, (y ∈ Seminorm.ball p 0 r) = (p y < r) :=
  by sorry

The theorem `Mathlib.Analysis.Seminorm._auxLemma.23` states that for any seminorm `p` on a seminormed ring `𝕜` acting on an additive commutative group `E` and for any element `y` from `E` and any real number `r`, `y` is in the seminorm ball centered at the origin with radius `r` if and only if the seminorm of `y` is less than `r`. In other words, it's a characterization of the seminorm ball in terms of the seminorm of elements.

For any seminorm `p` on a seminormed ring `𝕜` over an additive commutative group `E`, an element `y` in `E` lies in the seminorm ball centered at the origin with radius `r` if and only if `p(y) < r`.


theorem SetTheory.PGame.Subsequent.mk_right :
    ∀ {xl xr : Type u_1} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (j : xr),
      SetTheory.PGame.Subsequent (xR j) (SetTheory.PGame.mk xl xr xL xR) :=
  by sorry

The theorem `SetTheory.PGame.Subsequent.mk_right` states that for any positions `xl` and `xr`, and any moves `xL` from `xl` and `xR` from `xr`, and any element `j` of `xr`, the position reached by playing the move `xR j` from the game `SetTheory.PGame.mk xl xr xL xR` is subsequent to the original game. In other words, there exists some nonempty sequence of moves starting from the game `SetTheory.PGame.mk xl xr xL xR` that leads to the position `xR j`. This is a formalization of a fundamental aspect of game theory in the context of set theory.

For any positions `xl`, `xr`, moves `xL` from `xl` and `xR` from `xr`, and element `j` of `xr` in set theory games, the position obtained by playing move `xR j` from the game `SetTheory.PGame.mk xl xr xL xR` is subsequent to the original game.


/-- A vector is in the same ray as a nonnegative multiple of one it is in the same ray as.  -/
theorem SameRay.nonneg_smul_right :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {x y : M} {S : Type u_5} [inst_3 : OrderedCommSemiring S] [inst_4 : Algebra S R]
      [inst_5 : Module S M] [inst_6 : SMulPosMono S R] [inst_7 : IsScalarTower S R M] {a : S},
      SameRay R x y → 0 ≤ a → SameRay R x (a • y) :=
  by sorry

This theorem states that for any vector `x` and `y`, if `x` and `y` are in the same ray (i.e., `x` is either zero, `y` is zero, or there exist positive multiples `r₁` and `r₂` such that `r₁ * x = r₂ * y`), then `x` is also in the same ray as any nonnegative multiple of `y`. Here, the nonnegative multiple of `y` is represented by `a • y`, where `a` is a nonnegative scalar. This holds in the context of a strictly ordered commutative semiring `R`, an additive commutative monoid `M`, and a module structure over `R` and `M`.

If `x` and `y` are in the same ray in a commutative semiring with a module structure over an additive commutative monoid, then `x` is in the same ray as any nonnegative scalar multiple of `y`.


theorem neg_one_pow_eq_pow_mod_two : ∀ {R : Type u_1} [inst : Ring R] (n : ℕ), (-1) ^ n = (-1) ^ (n % 2) := by sorry

This theorem states that for any natural number `n` in any ring `R`, the power of -1 raised to `n` is equal to the power of -1 raised to the modulus of `n` by 2. In simpler terms, the value of -1 to the power of any number is the same as -1 to the power of that number mod 2. This is because -1 to the power of any even number is 1, and -1 to the power of any odd number is -1.

For any natural number n in a ring R, (-1)^n = (-1)^(n % 2).


theorem Filter.exists_seq_forall_of_frequently :
    ∀ {ι : Type u_6} {l : Filter ι} {p : ι → Prop} [inst : Filter.IsCountablyGenerated l],
      (∃ᶠ (n : ι) in l, p n) → ∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n) :=
  by sorry

The theorem `Filter.exists_seq_forall_of_frequently` states that for any type `ι`, a filter `l` on `ι`, and a predicate `p` on `ι`, if the filter `l` is countably generated, and there frequently exist `ι` in the filter `l` that satisfy the predicate `p`, then there exists a sequence `ns` that tends from positive infinity to `l` and for every natural number `n`, `p` is true for `ns n`.

In other words, if `p` is frequently true for elements in a countably generated filter, there exists a sequence with values in the filter such that `p` is true for all elements of the sequence. This sequence can be thought of as drawing from the infinitely occurring elements in the filter for which `p` holds. The "tending to `l`" part ensures that this sequence is drawing from elements that are increasingly deep into the filter.

If `ι` is a type, `l` is a countably generated filter on `ι`, and `p` is a predicate on `ι` such that `p` frequently holds in `l`, then there exists a sequence `ns` in `l` such that `p(ns n)` holds for all natural numbers `n`.


theorem padicNormE.add_eq_max_of_ne :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ_[p]}, ‖q‖ ≠ ‖r‖ → ‖q + r‖ = max ‖q‖ ‖r‖ := by sorry

This theorem states that for any prime number `p`, and any two p-adic numbers `q` and `r`, if the p-adic norms of `q` and `r` are not equal, then the p-adic norm of the sum of `q` and `r` is equal to the maximum of the p-adic norms of `q` and `r`. Here, a p-adic number is a type of number that comes from a different number system than the one we typically use, and the p-adic norm of a p-adic number is a measure of the size of that number.

For any prime number `p` and p-adic numbers `q` and `r`, if `|q|_p ≠ |r|_p`, then `|q + r|_p = max {|q|_p, |r|_p}`.


theorem Finset.sum_pos' :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelAddCommMonoid M] {f : ι → M} {s : Finset ι},
      (∀ i ∈ s, 0 ≤ f i) → (∃ i ∈ s, 0 < f i) → 0 < Finset.sum s fun i => f i :=
  by sorry

The theorem `Finset.sum_pos'` states that for any type `ι` and any type `M` that is an ordered cancel add commutative monoid, and for any function `f` from `ι` to `M` and any finite set `s` of `ι`, if every element `i` in `s` satisfies `0 ≤ f i`, and there exists an element `i` in `s` such that `0 < f i`, then the sum of `f i` for all `i` in `s` is greater than zero. In other words, if all elements of a set are non-negative and at least one element is positive, then the sum of function values over the set is positive.

If `M` is an ordered, cancel add commutative monoid and `f : ι -> M` satisfies `0 <= f i` for all `i` in a finite set `s` with `0 < f (some i in s)`, then `∑ i in s, f i > 0`.


theorem Set.image_one : ∀ {α : Type u_2} {β : Type u_3} [inst : One α] {f : α → β}, f '' 1 = {f 1} := by sorry

This theorem states that for any types `α` and `β`, given a one instance for `α` and a function `f` from `α` to `β`, the image of `1` under `f` is equal to the set containing `f(1)`. In other words, if you apply the function `f` to the element `1` in type `α`, the result will be a set that contains just the image of `1` under `f`.

For any types `α` and `β` and function `f` from `α` to `β`, `image_singleton 1 f = {f 1}`.


theorem AddMonoidAlgebra.mul_single_apply_aux :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Add G] (f : AddMonoidAlgebra k G) (r : k) (x y z : G),
      (∀ (a : G), a + x = z ↔ a = y) → (f * AddMonoidAlgebra.single x r) z = f y * r :=
  by sorry

This theorem states that for any semiring `k`, any type `G` that has addition, any `f` which is an additive monoid algebra of `k` and `G`, any `r` of type `k`, and any `x`, `y`, and `z` of type `G`, such that for all `a` of type `G`, `a` plus `x` equals `z` if and only if `a` equals `y`, then the result of multiplying `f` with the additive monoid algebra single `x` and `r` at `z` is equal to the multiplication of `f` at `y` and `r`. In other words, it describes a property of multiplication in the context of additive monoid algebras, particularly in relation to the `single` function.

For any semiring `k`, additive monoid algebra `f` of `k` and type `G`, if for all `x, y, z, a` in `G`, `a + x = z` if and only if `a = y` implies `f(y) * r = f(x) * r * z`, then `f(y) * r = f(single x) * r * z`.


theorem HasDerivWithinAt.mul_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {𝔸 : Type u_2} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸] {c : 𝕜 → 𝔸} {c' : 𝔸},
      HasDerivWithinAt c c' s x → ∀ (d : 𝔸), HasDerivWithinAt (fun y => c y * d) (c' * d) s x :=
  by sorry

The theorem `HasDerivWithinAt.mul_const` states that for any type `𝕜` which forms a nontrivial normed field, a point `x` of type `𝕜`, a set `s` of elements of type `𝕜`, another type `𝔸` which forms a normed ring, and a normed algebra over `𝕜`, a function `c` from `𝕜` to `𝔸`, its derivative `c'` at the point `x` within the subset `s`, and an element `d` of type `𝔸` — if `c` has the derivative `c'` at the point `x` within the subset `s`, then the function obtained by multiplying `c` by the constant `d` has the derivative `c' * d` at the point `x` within the subset `s`. In mathematical terms, it tells us that the derivative of the function `c(y) * d` (where `d` is a constant) with respect to `y` at the point `x` within `s` equals `c'(x) * d`.

If `c:` 𝕜 → 𝔸 is differentiable at `x` ∈ 𝕜 with respect to a subset `s` of 𝕜, then the function `d => c(x) * d:` 𝔸 → 𝔸 is differentiable at `x` with respect to `s` and has derivative `c'(x) * d`.


/-- A more general version of `finsum_mem_union` that requires `s ∩ support f` and
`t ∩ support f` rather than `s` and `t` to be finite. -/
theorem finsum_mem_union' :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {s t : Set α},
      Disjoint s t →
        Set.Finite (s ∩ Function.support f) →
          Set.Finite (t ∩ Function.support f) →
            (finsum fun i => finsum fun h => f i) =
              (finsum fun i => finsum fun h => f i) + finsum fun i => finsum fun h => f i :=
  by sorry

This theorem, `finsum_mem_union'`, is a more general version of `finsum_mem_union` and it states that for any two sets `s` and `t` of type `α` and a function `f` from `α` to `M` under addition-commutative monoid setting, if `s` and `t` are disjoint, and if the intersection of `s` and `t` with the support of `f` are both finite, then the sum of `f` over all elements in the union of `s` and `t` is equal to the sum of `f` over all elements in `s` added to the sum of `f` over all elements in `t`. Here, the 'support' of a function refers to the set of points where the function is non-zero, and 'finsum' refers to the sum over a finite set (or zero if the set is not finite).

For disjoint, finite subsets $S, T$ of a set $\alpha$ and a commutative monoid $(M, +)$ with finite supports $S \cap \operatorname{supp}(f)$ and $T \cap \operatorname{supp}(f)$, the sum $\sum\_{x \in S \cup T} f(x)$ equals $\sum\_{x \in S} f(x) + \sum\_{x \in T} f(x)$.


Set.Infinite.image

/-- **Alias** of the reverse direction of `Set.infinite_image_iff`. -/
theorem Set.Infinite.image :
    ∀ {α : Type u} {β : Type v} {s : Set α} {f : α → β}, Set.InjOn f s → Set.Infinite s → Set.Infinite (f '' s) := by
  sorry

This theorem states that if a function `f` is injective (i.e., distinct inputs produce distinct outputs) when restricted to a set `s`, and if the set `s` is infinite, then the image of `s` under `f` is also infinite. In other words, mapping an infinite set through an injective function results in another infinite set.

If `f` is an injective function on the infinite set `s`, then the image `f(s)` is also infinite.


theorem Nat.bit1_lt_bit0 : ∀ {n m : ℕ}, n < m → bit1 n < bit0 m := by sorry

This theorem, `Nat.bit1_lt_bit0`, states that for all natural numbers `n` and `m`, if `n` is less than `m`, then `bit1 n` is less than `bit0 m`. Here, `bit1 n` and `bit0 m` can be understood as specific transformations of `n` and `m`: `bit1 n` is defined as `2n + 1` and `bit0 m` is defined as `2m`. So, in essence, this theorem is saying that if `n` is less than `m`, then `2n + 1` is less than `2m`.

For all natural numbers `n` and `m`, if `n` < `m`, then `2n + 1` < `2m`.


theorem Mathlib.MeasureTheory.Measure.Stieltjes._auxLemma.9 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) := by sorry

This theorem is from the Measure Theory library in Mathlib. Specifically, it's a lemma about Stieltjes measures. It states that for any type `α` with a linear order, and any two elements `a` and `b` of type `α`, the statement "`a` is not less than `b`" is equivalent to the statement "`b` is less than or equal to `a`". In mathematical terms, it says that ∀ `a`, `b` in `α`, ¬(`a` < `b`) ⇔ `b` ≤ `a`.

For any linearly ordered type `α`, the negation of `a` being less than `b` is equivalent to `b` being less than or equal to `a`.


theorem Ordinal.pred_eq_iff_not_succ : ∀ {o : Ordinal.{u_4}}, Ordinal.pred o = o ↔ ¬∃ a, o = Order.succ a := by sorry

The theorem `Ordinal.pred_eq_iff_not_succ` states that for any ordinal `o`, the predecessor of `o` is equal to `o` if and only if there doesn't exist an ordinal `a` such that `o` is the successor of `a`. In other words, an ordinal is equal to its predecessor precisely when it's not the successor of any other ordinal.

For any ordinal `o`, `o = pred o` if and only if there is no ordinal `a` such that `o = succ a`.


theorem Set.smul_subset_smul_left :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t₁ t₂ : Set β}, t₁ ⊆ t₂ → s • t₁ ⊆ s • t₂ := by sorry

The theorem `Set.smul_subset_smul_left` states that for any types `α` and `β`, where `β` is a set that can be scaled by elements of `α` (denoted as [inst : SMul α β]), and for any set `s` of type `α` and any sets `t₁` and `t₂` of type `β`, if `t₁` is a subset of `t₂`, then the scaled set `s • t₁` is a subset of the scaled set `s • t₂`. Here, `s • t₁` and `s • t₂` denote the sets resulting from the scalar multiplication of each element in `t₁` and `t₂` by each element in `s`, respectively.

For any sets `s` of type `α` and `t₁, t₂` of type `β` with `β` being scalable by `α`, if `t₁` is a subset of `t₂`, then `s • t₁` is a subset of `s • t₂`.


theorem HasDerivAt.lhopital_zero_right_on_Ioo :
    ∀ {a b : ℝ},
      a < b →
        ∀ {l : Filter ℝ} {f f' g g' : ℝ → ℝ},
          (∀ x ∈ Set.Ioo a b, HasDerivAt f (f' x) x) →
            (∀ x ∈ Set.Ioo a b, HasDerivAt g (g' x) x) →
              (∀ x ∈ Set.Ioo a b, g' x ≠ 0) →
                Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds 0) →
                  Filter.Tendsto g (nhdsWithin a (Set.Ioi a)) (nhds 0) →
                    Filter.Tendsto (fun x => f' x / g' x) (nhdsWithin a (Set.Ioi a)) l →
                      Filter.Tendsto (fun x => f x / g x) (nhdsWithin a (Set.Ioi a)) l :=
  by sorry

This is a statement of L'Hopital's rule for the case where the point of interest is the left endpoint of an open interval. Specifically, the theorem states that for any two real-valued functions `f` and `g` that are differentiable on an open interval `(a, b)`, if `f` and `g` both approach `0` as `x` approaches `a` from the right (in other words, within the interval `(a, ∞)`), and the derivative of `g` is never `0` in `(a, b)`, then the limits as `x` approaches `a` from the right of the ratio of the derivatives of `f` and `g` and the ratio of `f` and `g` are the same. Note that L'Hopital's rule is a method for evaluating limits of ratios of two functions that approach `0` or infinity.

If functions `f` and `g` are differentiable on an open interval `(a, b)`, `f(x)` and `g(x)` approach 0 as `x` approaches `a` from the right, and `g'(x)` never equals 0 in `(a, b)`, then `(f'/g')(a) = (f/g)(a)`.


theorem solvable_of_surjective :
    ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {f : G →* G'},
      Function.Surjective ⇑f → ∀ [inst : IsSolvable G], IsSolvable G' :=
  by sorry

The theorem `solvable_of_surjective` states that for all types `G` and `G'`, where `G` and `G'` are groups (denoted by `[inst : Group G]` and `[inst_1 : Group G']` respectively), if there exists a surjective group homomorphism `f` from `G` to `G'` (symbolized by `Function.Surjective ⇑f`), then if `G` is solvable (expressed by `[inst : IsSolvable G]`), it implies that `G'` is also solvable (denoted by `IsSolvable G'`). In simpler terms, if a group `G` mapping onto a group `G'` through a surjective group homomorphism is solvable, then `G'` is also solvable.

If `G` is a solvable group and `f` is a surjective group homomorphism from `G` to `G'`, then `G'` is also a solvable group.


theorem Finset.sum_range_reflect :
    ∀ {δ : Type u_3} [inst : AddCommMonoid δ] (f : ℕ → δ) (n : ℕ),
      (Finset.sum (Finset.range n) fun j => f (n - 1 - j)) = Finset.sum (Finset.range n) fun j => f j :=
  by sorry

The theorem `Finset.sum_range_reflect` states that for any given natural number `n` and any function `f` from natural numbers to a type `δ` (where `δ` is any type that has an additive commutative monoid structure), the sum of `f(n - 1 - j)`, where `j` ranges over all natural numbers less than `n`, is the same as the sum of `f(j)`, where `j` also ranges over all natural numbers less than `n`. In other words, if we were to take a set of natural numbers less than `n`, and apply the function `f` to each element, the sum of the results would remain unchanged whether we traverse the set in a normal or reverse order.

For any natural number `n` and additive commutative monoid homomorphism `f`, the sum of `f(n-1-j)` for `j` ranging from `0` to `n-1` equals the sum of `f(j)` for `j` ranging from `0` to `n-1`.


theorem AddSubmonoid.one_eq_closure_one_set :
    ∀ {R : Type u_4} [inst : AddMonoidWithOne R], 1 = AddSubmonoid.closure 1 := by sorry

This theorem states that for any type `R` which has a structure of an additive monoid with a distinguished element `1`, the singleton set containing just `1` generates an `add_submonoid` whose closure is `1`. In more mathematical terms, the closure of the set `{1}` under the operations of the additive monoid with one is equal to `1`.

For any additive monoid `R` with identity `1`, the singleton set `{1}` generates an additive submonoid whose closure is `1`.


FreeGroup.Red.trans

theorem FreeGroup.Red.trans :
    ∀ {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}, FreeGroup.Red L₁ L₂ → FreeGroup.Red L₂ L₃ → FreeGroup.Red L₁ L₃ := by
  sorry

This theorem states that for any type `α` and any three lists `L₁`, `L₂`, and `L₃` of pairs of elements from `α` and boolean values, if there is a reflexive-transitive relation (`FreeGroup.Red`) from `L₁` to `L₂`, and another reflexive-transitive relation from `L₂` to `L₃`, then there is also a reflexive-transitive relation from `L₁` to `L₃`. In other words, the reflexive-transitive relation `FreeGroup.Red` is transitive.

If `R₁` is a reflexive-transitive relation from `α × bool` to `α × bool` between lists `L₁` and `L₂`, and `R₂` is another reflexive-transitive relation from `α × bool` to `α × bool` between lists `L₂` and `L₃`, then the composition of `R₁` and `R₂` is a reflexive-transitive relation between `L₁` and `L₃`.


theorem IsPrimitiveRoot.eq_neg_one_of_two_right :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : NoZeroDivisors R] {ζ : R}, IsPrimitiveRoot ζ 2 → ζ = -1 := by sorry

This theorem states that for any commutative ring `R` with no zero divisors, if `ζ` is a primitive root of order 2 (which means `ζ` raised to the power of 2 equals 1), then `ζ` must be equal to `-1`. This is because the only two complex roots of the equation $x^2 = 1$ are `1` and `-1`, and by the nature of `ζ` being a "primitive root" of order `2`, it cannot be `1`. Thus, it must be `-1`.

In a commutative ring with no zero divisors, a primitive root of order 2 equals -1.


/-- The **Compactness Theorem of first-order logic**: A theory is satisfiable if and only if it is
finitely satisfiable.  -/
theorem FirstOrder.Language.Theory.isSatisfiable_iff_isFinitelySatisfiable :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L},
      FirstOrder.Language.Theory.IsSatisfiable T ↔ FirstOrder.Language.Theory.IsFinitelySatisfiable T :=
  by sorry

This is the Compactness Theorem of first-order logic: for any first-order language `L` and any theory `T` over that language, `T` is satisfiable (there exists a structure that models it) if and only if `T` is finitely satisfiable (every finite subset of `T` has a model). This theorem is a cornerstone of model theory and has profound implications in the study of formal systems.

A first-order theory is satisfiable if and only if every finite subset of it is satisfiable.


/-- The characterization of the unbundled orthogonal projection.  This
lemma is only intended for use in setting up the bundled version
and should not be used once that is defined.  -/
theorem orthogonalProjectionFn_inner_eq_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {K : Submodule 𝕜 E} [inst_3 : HasOrthogonalProjection K] (v w : E),
      w ∈ K → ⟪v - orthogonalProjectionFn K v, w⟫_𝕜 = 0 :=
  by sorry

The theorem `orthogonalProjectionFn_inner_eq_zero` characterizes the unbundled orthogonal projection in an inner product space. Specifically, for any types `𝕜` under a Ring-Commutative-Like structure and `E` under a Normed Additive Commutative Group structure, and for `𝕜` as an Inner Product Space over `E`, given any submodule `K` of `E` that supports orthogonal projection, the theorem states that for any vectors `v` and `w` in `E`, if `w` is an element of `K`, then the inner product of the difference between `v` and the orthogonal projection of `v` onto `K` with `w` equals zero. In essence, this theorem captures the orthogonality condition inherent in orthogonal projections.

For any inner product space `(𝕜, E)` over a ring `𝕜`, and submodule `K` of `E` supporting orthogonal projection, if `w` is in `K`, then the inner product of `v - 𝔄_K v` with `w` equals zero for all `v` in `E`, where `𝔄_K v` denotes the orthogonal projection of `v` onto `K`.


theorem nsmul_left_strictMono :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : M},
      0 < a → StrictMono fun x => x • a :=
  by sorry

The theorem `nsmul_left_strictMono` states that for any type `M` that is an additive monoid and a preorder, and where addition (`x + x_1`) is covariant in both the `≤` and `<` preorders, if `a` is an element of `M` such that `0 < a`, then the function `fun x => x • a` (which represents scalar multiplication of `a` by `x`) is strictly monotonic. In other words, for any two elements `x` and `y` in `M`, if `x < y`, then `x • a < y • a`.

For any additive monoid and preorder type `M` where addition is covariant in the preorders `≤` and `<`, and for any `0 < a` in `M`, the function `x => x • a` is strictly monotonic: if `x < y` in `M`, then `x • a < y • a`.


theorem Mathlib.RingTheory.HahnSeries.Basic._auxLemma.4 :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
      (a ∈ HahnSeries.support x) = (x.coeff a ≠ 0) :=
  by sorry

The theorem, `Mathlib.RingTheory.HahnSeries.Basic._auxLemma.4`, states that for any types Γ and R, where Γ has a partial order and R has a zero, and for any Hahn series `x` of type `HahnSeries Γ R` and any element `a` of Γ, `a` is in the support of `x` if and only if the coefficient of `a` in `x` is non-zero. In other words, the support of a Hahn series is precisely the set of indices at which the series has non-zero coefficients.

For any Hahn series $x$ over a poset $\Gamma$ with values in a ring $R$, the index $a \in \Gamma$ is in the support of $x$ if and only if the coefficient of $a$ in $x$ is non-zero.


theorem symmDiff_sdiff :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), symmDiff a b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) :=
  by sorry

The theorem `symmDiff_sdiff` states that for any type `α` which is a Generalized Coheyting Algebra, and any three elements `a`, `b`, and `c` of this type, the symmetric difference of `a` and `b`, minus `c`, is equal to the union of `a` minus the union of `b` and `c`, and `b` minus the union of `a` and `c`. In mathematical terms, this can be written as $(A \triangle B) \setminus C = (A \setminus (B \cup C)) \cup (B \setminus (A \cup C))$, where $A$, $B$, and $C$ are elements of some Generalized Coheyting Algebra, $\triangle$ denotes symmetric difference, $\setminus$ denotes set difference, and $\cup$ denotes union.

For any Generalized Cohesion Algebra type `α` and elements `a`, `b`, and `c` of `α`, $(a \triangle b) \setminus c = (a \setminus (b \cup c)) \cup (b \setminus (a \cup c))$.


theorem monovary_inv_left₀ :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedSemifield α] [inst_1 : LinearOrderedSemifield β]
      {f : ι → α} {g : ι → β}, StrongLT 0 f → (Monovary f⁻¹ g ↔ Antivary f g) :=
  by sorry

The theorem `monovary_inv_left₀` states that for any types `ι`, `α`, and `β`, where `α` and `β` are linear ordered semifields, and any functions `f` from `ι` to `α` and `g` from `ι` to `β`, if `f` is strongly greater than 0 (i.e., for all `i` in `ι`, `0 < f(i)`), then `f⁻¹` monovaries with `g` if and only if `f` antivaries with `g`. Here, `f⁻¹` monovaries with `g` means that whenever `g(i) < g(j)`, we have `f⁻¹(i) ≤ f⁻¹(j)`, and `f` antivaries with `g` means that whenever `g(i) < g(j)`, we have `f(j) ≤ f(i)`.

For functions \(f: ι \to \alpha\) and \(g: ι \to \beta\), where \(\alpha\) and \(\beta\) are linear ordered semifields, \(f\) is strictly positive, and \(f\) monovaries with \(g\) if and only if \(f\) antivaries with \(g\).


theorem BoxIntegral.Prepartition.isPartitionSplit :
    ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (i : ι) (x : ℝ),
      BoxIntegral.Prepartition.IsPartition (BoxIntegral.Prepartition.split I i x) :=
  by sorry

The theorem `BoxIntegral.Prepartition.isPartitionSplit` states that for any type `ι`, any box `I` of type `BoxIntegral.Box ι`, any element `i` from `ι`, and any real number `x`, the result of splitting `I` at `x` along the dimension `i` using the function `BoxIntegral.Prepartition.split`, yields a partition of `I`. In other words, the boxes obtained from the split cover the whole box `I`.

For any box `I` of type `BoxIntegral.Box ι`, any element `i` from `ι`, and any real number `x`, the partition obtained by splitting `I` at `x` along dimension `i` using `BoxIntegral.Prepartition.split` is a valid partition of `I`.


IsWellFounded.induction

/-- Induction on a well-founded relation.  -/
theorem IsWellFounded.induction :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellFounded α r] {C : α → Prop} (a : α),
      (∀ (x : α), (∀ (y : α), r y x → C y) → C x) → C a :=
  by sorry

The theorem `IsWellFounded.induction` states that for any type `α` and a well-founded relation `r` on `α`, given a property `C` and an element `a` of type `α`, if for all `x` of type `α`, the property `C` holds for `x` if `C` holds for all `y` such that `r y x`, then the property `C` holds for `a`. This is essentially an induction principle for well-founded relations, allowing us to prove properties about elements of a well-founded set by considering smaller elements first.

If `r` is a well-founded relation on type `α`, then for any property `C` and element `a` of type `α`, if `C` holds for all `x` such that `r x a`, then `C` holds for `a`.


theorem FiniteDimensional.finrank_of_not_finite :
    ∀ {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], ¬Module.Finite R M → FiniteDimensional.finrank R M = 0 :=
  by sorry

This theorem states that for any ring `R` that satisfies the strong rank condition, and any additive commutative group `M` that is also a module over `R` and is freely generated, if `M` is not a finite `R`-module, then the rank of `M` as a `R`-module, as defined by `FiniteDimensional.finrank`, is zero. Essentially, if a vector space `M` over a field `R` has infinite dimension, then its "finite rank" is conventionally defined to be zero.

For any commutative ring `R` satisfying the strong rank condition, if `M` is an additive commutative group freely generated as an `R`-module and infinite as a set, then `FiniteDimensional.finrank R M = 0`.


theorem toDual_covBy_toDual_iff :
    ∀ {α : Type u_1} [inst : LT α] {a b : α}, OrderDual.toDual b ⋖ OrderDual.toDual a ↔ a ⋖ b := by sorry

This theorem, `toDual_covBy_toDual_iff`, states that for any type `α` that has a less than operation `LT α`, and for any two instances `a` and `b` of this type, the statement "the order dual of `b` is less than the order dual of `a`" is equivalent to the statement "`a` is less than `b`". In other words, applying the `OrderDual.toDual` function to `a` and `b` and then comparing them gives the same result as comparing `a` and `b` directly. This theorem essentially says that the `OrderDual.toDual` function preserves the order of elements.

For any type equipped with a total order and its order dual, the order dual of a is less than the order dual of b if and only if a is less than b.


theorem Submonoid.LocalizationMap.lift_id :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (x : N), (Submonoid.LocalizationMap.lift f ⋯) x = x :=
  by sorry

This theorem asserts that for any commutative monoid `M` with a submonoid `S`, and any other commutative monoid `N`, if `f` is a localization map from `S` to `N`, then the "lift" operation applied to `f` and any element `x` of `N` is equal to `x` itself. In other words, lifting the localization map `f` leaves any element of `N` unchanged. This theorem is about a certain property of the lifting operation in the context of localization of commutative monoids.

Given a commutative monoid Homomorphism `f` from a submonoid `S` to `N` in commutative monoids, the lift operation applied to `f` and any element `x` in `N` equals `x` itself.


theorem Filter.EventuallyEq.comp_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {γ : Type u_3} {f' : α → β},
      f =ᶠ[l] f' → ∀ {g : γ → α} {lc : Filter γ}, Filter.Tendsto g lc l → f ∘ g =ᶠ[lc] f' ∘ g :=
  by sorry

The theorem `Filter.EventuallyEq.comp_tendsto` states that for any types `α`, `β`, and `γ`, any filter `l` on `α`, any functions `f` and `f'` from `α` to `β`, and any function `g` from `γ` to `α`, if `f` is eventually equal to `f'` at the filter `l`, then for any filter `lc` on `γ`, if `g` tends to `l` at `lc` (i.e., the limit of `g` as `lc` approaches `l` exists), then the composition of `f` and `g` is eventually equal to the composition of `f'` and `g` at the filter `lc`. In term of limit, if the function `g` converges to a limit `l` and at some point in the neighbourhood of this limit `f` is equal to `f'`, then the limit of the composition of `f` and `g` is the same as the limit of the composition of `f'` and `g`.

If a function `f` is eventually equal to `f'` at a filter `l` on type `α`, and `g` tends to `l` at filter `lc` on type `γ`, then the composition `f ∘ g` is eventually equal to `f' ∘ g` at filter `lc`.


theorem CauSeq.lt_of_lt_of_eq :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {f g h : CauSeq α abs}, f < g → g ≈ h → f < h := by sorry

This theorem states that for any linear ordered field `α`, if you have three Cauchy sequences `f`, `g`, and `h` of `α` with respect to the absolute value, and if `f` is less than `g` and `g` is approximately equal to `h`, then `f` is less than `h`. In terms of mathematical notation, this can be expressed as: for all `f, g, h ∈ CauSeq α abs`, if `f < g` and `g ≈ h`, then `f < h`. Essentially, this theorem captures a form of transitivity property of "less than" relation under the approximation in the context of Cauchy sequences.

If `f`, `g`, and `h` are Cauchy sequences in a linear ordered field `α` such that `f < g` and `g` is close to `h`, then `f < h`.


theorem CategoryTheory.GrothendieckTopology.plusMap_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
      [inst_1 : CategoryTheory.Category.{max v u, w} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      {P Q R : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (γ : Q ⟶ R),
      CategoryTheory.GrothendieckTopology.plusMap J (CategoryTheory.CategoryStruct.comp η γ) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.plusMap J η)
          (CategoryTheory.GrothendieckTopology.plusMap J γ) :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.plusMap_comp` states that for any Grothendieck topology `J` in a category `C` and categories `D`, given functors `P`, `Q`, and `R` from the opposite of `C` to `D`, and morphisms `η` from `P` to `Q` and `γ` from `Q` to `R`, the `plusMap` operation with respect to the Grothendieck topology `J` on the composition of `η` and `γ` is equivalent to the composition of the `plusMap` operation on `η` and the `plusMap` operation on `γ`. This is assuming that for each object `X` in `C` and cover `S` of `X` with respect to `J`, the cover index has a multiequalizer, and `X` has colimits of shape given by the opposite of the cover of `X`. In essence, this theorem demonstrates the compatibility of the `plusMap` operation with the composition of morphisms.

Given a Grothendieck topology `J` on a category `C` and functors `P`, `Q`, `R` from `C^op` to another category `D` with cover index multiequalizers and colimits, the `plusMap` of `γ ∘ η` is equivalent to the composition of `plusMap η` and `plusMap γ`.


/-- If a function applied at a point is 0, a sum is unchanged by
removing that point, if present, from a `Finset`. -/
theorem Finset.sum_erase :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) {f : α → β}
      {a : α}, f a = 0 → (Finset.sum (Finset.erase s a) fun x => f x) = Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_erase` states that for any type `α`, type `β` that forms an additive commutative monoid, a function `f` from `α` to `β`, and a `Finset` `s` of `α` elements, if the function `f` evaluated at a specific point `a` of `α` equals zero, then the sum of the function values over the `Finset` `s` remains unchanged when the point `a` is removed from the `Finset`. In other words, if $f(a)=0$, then $\sum_{x \in s \setminus \{a\}}f(x) = \sum_{x \in s}f(x)$, where $s$ is a finite set.

If `α` is a type, `β` an additive commutative monoid, `f` a function from `α` to `β`, and `s` a `Finset` of `α`, then removing an element `a` from `s` with `f(a) = 0` leaves the sum of function values over `s` unchanged: $\sum\_{x \in s \setminus \{a\}} f(x) = \sum\_{x \in s} f(x)$.


theorem zpow_ne_zero_of_ne_zero : ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → ∀ (z : ℤ), a ^ z ≠ 0 :=
  by sorry

This theorem states that for any type `G₀` that has a structure of group with zero (i.e., it has both a group and field structure with a designated zero element that behaves as the additive identity), if `a` is an element of `G₀` that is not zero, then raising `a` to any integer power `z` will also not result in zero. In other words, a non-zero element remains non-zero when raised to any integer power in a group with zero.

If `G₀` is a group with zero and `a` is a non-zero element in `G₀`, then for all integers `z`, `a^z ≠ 0`.


theorem isPiSystem_image_Iic : ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α), IsPiSystem (Set.Iic '' s) := by
  sorry

This theorem states that for any set `s` of a given type `α` where `α` has a linear order, the image of `s` under the function `Set.Iic`, which denotes the left-infinite right-closed interval, forms a π-system. A π-system is a collection of subsets that is closed under binary intersection of non-disjoint sets. In this case, it means that any two intervals produced by `Set.Iic` from elements of `s` that have a nonempty intersection, also give an interval that is in the image of `s` under `Set.Iic`.

Given a set `s` of a linearly ordered type `α`, the image of `s` under `Set.Iic` forms a π-system.


theorem isPiSystem_image_Iio : ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α), IsPiSystem (Set.Iio '' s) := by
  sorry

This theorem states that for any set `s` of elements of a certain type `α`, where `α` has a linear order, the image of `s` under the map `Set.Iio` forms a π-system. In other words, if `s` is a set and `Set.Iio` maps each element in `s` to a corresponding left-infinite right-open interval, then the collection of these intervals is a π-system. A π-system is a collection of sets that is closed under binary intersection of non-disjoint sets, meaning that if any two sets in the collection have a non-empty intersection, then their intersection is also in the collection. In this context, the left-infinite right-open intervals generated by `Set.Iio` have this property.

For any set `s` of elements from a linearly ordered type `α`, the collection of left-infinite right-open intervals obtained by mapping each element in `s` using `Set.Iio` forms a π-system.


theorem MvPolynomial.aeval_def :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      [inst_2 : Algebra R S₁] (f : σ → S₁) (p : MvPolynomial σ R),
      (MvPolynomial.aeval f) p = MvPolynomial.eval₂ (algebraMap R S₁) f p :=
  by sorry

The theorem `MvPolynomial.aeval_def` states that for any commutative semiring `R`, any commutative semiring `S₁` that also has an algebra structure over `R`, any type `σ`, any function `f` from `σ` to `S₁`, and any multivariate polynomial `p` with variables indexed by `σ` and coefficients in `R`, the application of the algebra homomorphism `MvPolynomial.aeval f` to `p` is equal to the evaluation `MvPolynomial.eval₂ (algebraMap R S₁) f p`. Here, `MvPolynomial.aeval f` is an algebra homomorphism generated by a map from `σ` to `S₁`, `MvPolynomial.eval₂` evaluates a polynomial `p` given a valuation `f` of all the variables and a ring homomorphism from `R` to `S₁` (in this case `algebraMap R S₁`), and `algebraMap R S₁` is the embedding from `R` to `S₁` given by the `Algebra` structure.

For any commutative semirings R and S₁ with S₁ being an algebra over R, any type σ, any function f : σ → S₁, and any multivariate polynomial p with variables indexed by σ and coefficients in R, the application of the algebra homomorphism MvPolynomial.aeval f to p is equal to the evaluation MvPolynomial.eval₂ (algebraMap R S₁) f of p with respect to the valuation f and the ring homomorphism algebraMap R S₁.


theorem Set.indicator_le' :
    ∀ {α : Type u_2} {M : Type u_4} [inst : LE M] [inst_1 : Zero M] {s : Set α} {f g : α → M},
      (∀ a ∈ s, f a ≤ g a) → (∀ a ∉ s, 0 ≤ g a) → Set.indicator s f ≤ g :=
  by sorry

The theorem `Set.indicator_le'` asserts that for any type `α` and a type `M` that has a less than or equal to (`LE`) relation and a zero element (`Zero`), given a set `s` of type `Set α` and two functions `f` and `g` from `α` to `M`, if every element `a` in `s` satisfies `f a ≤ g a` and for all `a` not in `s`, `0 ≤ g a`, then the indicator function of `s` with respect to `f` is less than or equal to `g`. In other words, for every element in the set, its corresponding value when passed through the function `f` or `0` for elements not in the set (as determined by `Set.indicator s f`) is always less than or equal to its corresponding value when passed through the function `g`.

For any set `s` in type `Set α`, if for all `a` in `α`, `f a ≤ g a` holds when `a` is in `s`, and `0 ≤ g a` holds when `a` is not in `s`, then `Set.indicator s f ≤ g` holds.


theorem Finsupp.total_surjective :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {v : α → M}, Function.Surjective v → Function.Surjective ⇑(Finsupp.total α M R v) :=
  by sorry

The theorem `Finsupp.total_surjective` states that for all types `α`, `M`, and `R`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is a `R`-module, given a function `v` from `α` to `M`, if the function `v` is surjective, then the function `total`, which interprets a linear combination of elements in the family `v` and evaluates this linear combination, is also surjective. In other words, for every element in the co-domain of `total`, there exists an element in its domain such that applying `total` to that element gives the element in the co-domain.

Given a surjective function `v` from type `α` to an `R`-module `M` over a semiring `R`, the function `total` that evaluates linear combinations of `v` is also surjective.


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

This theorem, `iff_true_right`, states that for any two propositions `a` and `b`, if `a` is true, then `b` is equivalent to `a` if and only if `b` is true. In simpler terms, if we know `a` is true, then the statement "`b` is equivalent to `a`" and the statement "`b` is true" are the same.

For all propositions `a` and `b`, `a` implies `a <> b <> false` if and only if `b` is true. (Here, `<>` denotes propositional equivalence.)


theorem OmegaCompletePartialOrder.Continuous'.to_bundled :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β] (f : α → β)
      (hf : OmegaCompletePartialOrder.Continuous' f),
      OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := ⋯ } :=
  by sorry

The theorem `OmegaCompletePartialOrder.Continuous'.to_bundled` states that for all types `α` and `β` which are instances of `OmegaCompletePartialOrder`, and for any function `f` from `α` to `β` that is continuous in the sense of `OmegaCompletePartialOrder.Continuous'`, the function `f` can be bundled into an instance of `OmegaCompletePartialOrder.Continuous`. The function `f` in this context is both monotone and continuous according to the definition provided by `OmegaCompletePartialOrder.Continuous'`.

For any continuous and monotone function `f` between two omega-complete partial orders `α` and `β`, `f` is an instance of `OmegaCompletePartialOrder.Continuous`.


theorem Mathlib.Topology.PartialHomeomorph._auxLemma.20 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      Continuous f = ContinuousOn f Set.univ :=
  by sorry

This theorem states that for any types `α` and `β` with respective topological spaces, and for any function `f` from `α` to `β`, the function `f` is continuous if and only if it is continuous on the universal set `Set.univ`. Here, the universal set `Set.univ` is simply the set containing all elements of `α`. In other words, in the context of topology, a function is continuous throughout its domain if it is continuous at every point within the domain.

A function between topological spaces is continuous if and only if it is continuous on their universal sets.


theorem IsOpen.isOpenMap_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s → IsOpenMap Subtype.val := by sorry

The theorem `IsOpen.isOpenMap_subtype_val` states that for any type `X` with a topological space structure and any set `s` in `X`, if `s` is open in the topological space of `X`, then the projection map (`Subtype.val`), which sends each element of the subtype `{x // x ∈ s}` to its underlying element in `X`, is an open map. In other words, this theorem guarantees that the image of any open set under the projection map is also an open set in the topological space of `X`.

The projection map of an open subtype is open.


theorem Function.Commute.minimalPeriod_of_comp_dvd_lcm :
    ∀ {α : Type u_1} {f : α → α} {x : α} {g : α → α},
      Function.Commute f g →
        Function.minimalPeriod (f ∘ g) x ∣ Nat.lcm (Function.minimalPeriod f x) (Function.minimalPeriod g x) :=
  by sorry

The theorem `Function.Commute.minimalPeriod_of_comp_dvd_lcm` states that for any two functions `f` and `g` that commute and a point `x`, the minimal period of the composition of `f` and `g` at `x` divides the least common multiple of the minimal periods of `f` and `g` at `x`. In other words, if `f` and `g` are two endomorphisms on a set `α` that commute (meaning that their composition is the same regardless of the order in which they are applied), and `x` is a point in `α`, then the smallest number of times the composition `f ∘ g` needs to be applied on `x` to return to `x` is a divisor of the least common multiple of the smallest number of times `f` and `g` need to be applied on `x` to return to `x`.

For commuting endomorphisms f and g on a set α, and any point x in α, the minimal period of their composition at x divides their least common multiple at x.


/-- **Alias** of `subset_of_eq_of_subset`. -/
theorem Eq.trans_subset : ∀ {α : Type u} [inst : HasSubset α] {a b c : α}, a = b → b ⊆ c → a ⊆ c := by sorry

This theorem, "Eq.trans_subset," states a fundamental principle of set theory for any type `α` that has a subset. Specifically, it asserts that if we have three elements `a`, `b`, and `c` of type `α`, and if `a` is equal to `b` and `b` is a subset of `c`, then `a` is also a subset of `c`. This theorem is essentially an alias of `subset_of_eq_of_subset`.

If `a` equals `b` and `b` is a subset of `c`, then `a` is a subset of `c`.


theorem Multiset.cons_inter_of_neg :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α}, a ∉ t → (a ::ₘ s) ∩ t = s ∩ t :=
  by sorry

This theorem states that for any type `α` that has decidable equality, given an element `a` of type `α` and two multisets `s` and `t` of type `α`, if `a` is not an element of `t`, then the intersection of `t` with the multiset formed by adding `a` to `s` is the same as the intersection of `s` and `t`. This theorem essentially shows that adding an element to a multiset does not change its intersection with another multiset, if that element is not in the other multiset.

If `α` has decidable equality and `a ∉ t`, then intersect (s ∪ {a}) t = intersect s t.


theorem Set.image_mul :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] [inst_2 : FunLike F α β]
      [inst_3 : MulHomClass F α β] (m : F) {s t : Set α}, ⇑m '' (s * t) = ⇑m '' s * ⇑m '' t :=
  by sorry

This theorem, `Set.image_mul`, states that for any types `F`, `α`, and `β` where `α` and `β` have multiplication defined on them (`Mul α` and `Mul β`), and `F` is a function-like structure from `α` to `β` (`FunLike F α β`), and moreover `F` respects the multiplication (`MulHomClass F α β`), then the image via `m` (a term of type `F`) of the product of two sets `s` and `t` of type `α` (`s * t`) is equal to the product of the images of `s` and `t` via `m` (`m '' s * m '' t`).

In mathematical terms, this theorem establishes that a function (or more generally, a term of type `F`) that preserves multiplication also preserves the multiplication operation when applied to sets of elements, i.e., for all sets `s` and `t`, `m(s*t) = m(s) * m(t)`.

Given functions `F` from type `α` to type `β` that preserve multiplication, the image of the product of two sets under `F` is equal to the product of the images of the sets. In other words, `m(s * t) = m(s) * m(t)` for sets `s` and `t` of type `α` and function `m` of type `F`.


theorem Finset.sum_insertNone :
    ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (f : Option α → M) (s : Finset α),
      (Finset.sum (Finset.insertNone s) fun x => f x) = f none + Finset.sum s fun x => f (some x) :=
  by sorry

The theorem `Finset.sum_insertNone` states that for any type `α`, Monoid `M` with addition (`AddCommMonoid M`), function `f` from an optional type `α` to `M`, and a finite set `s` of type `α`, the sum of function `f` applied on each element of the set obtained by inserting `none` into `s` (using the function `Finset.insertNone`), is equal to the sum of `f` applied to `none` plus the sum of function `f` applied on each element of the original set `s` after wrapping them with `some`. In other words, when summing over a set where `none` has been inserted, the contribution of `none` to the sum is exactly `f none` and the contribution of the other elements is as though `none` had not been inserted.

For any Monoid `M` with addition, function `f` from an optional type `α` to `M`, and finite set `s` of type `α`, we have `Sum.sum (λx => if h : x ≠ none then some (f x) else none) (Finset.insertNone s) = some (f none) + Sum.sum (λx => f (some x)) s`.


theorem Equiv.Perm.Disjoint.inv_left :
    ∀ {α : Type u_1} {f g : Equiv.Perm α}, Equiv.Perm.Disjoint f g → Equiv.Perm.Disjoint f⁻¹ g := by sorry

The theorem `Equiv.Perm.Disjoint.inv_left` states that for any type `α` and any two permutations `f` and `g` on `α`, if `f` and `g` are disjoint (meaning their supports are disjoint, i.e., every element is fixed either by `f`, or by `g`), then the inverse of `f` and `g` are also disjoint. Here, the inverse of a permutation `f` is denoted as `f⁻¹`.

If permutations `f` and `g` on type `α` have disjoint supports, then their inverses `f⁻¹` and `g⁻¹` also have disjoint supports.


theorem star_injective : ∀ {R : Type u} [inst : InvolutiveStar R], Function.Injective star := by sorry

The theorem `star_injective` states that for every type `R` equipped with an instance of the `InvolutiveStar` structure, the `star` function (which is part of the `InvolutiveStar` structure) is injective. In other words, for any two elements `a₁` and `a₂` of `R`, if `star a₁` equals `star a₂`, then `a₁` must equal `a₂`. This injectivity property holds regardless of the specific type `R` or the specifics of the `InvolutiveStar` instance.

For every type `R` endowed with an `InvolutiveStar` structure, the `star` function is a injective function on `R`.


theorem Asymptotics.isBigOWith_abs_left :
    ∀ {α : Type u_1} {F : Type u_4} [inst : Norm F] {c : ℝ} {g : α → F} {l : Filter α} {u : α → ℝ},
      Asymptotics.IsBigOWith c l (fun x => |u x|) g ↔ Asymptotics.IsBigOWith c l u g :=
  by sorry

This theorem, `Asymptotics.isBigOWith_abs_left`, states that for any types `α` and `F` with a norm on `F`, a real number `c`, a function `g` mapping `α` to `F`, a filter `l` on `α` and a function `u` mapping `α` to real numbers, the condition that the absolute value of `u(x)` is big-O of `g` with respect to `c` and `l` (in other words, the norm of `u(x)` is eventually bounded by `c` times the norm of `g`, for `l`), is equivalent to the condition that `u(x)` itself is big-O of `g` with respect to `c` and `l`.

If for all x in alpha, the absolute value of u(x) is big-O of g(x) with respect to c and filter l, then u is big-O of g with respect to c and filter l.


theorem LinearPMap.le_sSup :
    ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
      [inst_3 : AddCommGroup F] [inst_4 : Module R F] {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (fun x x_1 => x ≤ x_1) c)
      {f : E →ₗ.[R] F}, f ∈ c → f ≤ LinearPMap.sSup c hc :=
  by sorry

The theorem `LinearPMap.le_sSup` states that for any ring `R` and modules `E` and `F` over the ring `R`, given a set `c` of linear mappings from `E` to `F`, if `c` is directed with respect to the "less than or equal to" relation (meaning for any two mappings in `c`, there is another mapping in `c` that is greater than or equal to both), then any specific mapping `f` in `c` is less than or equal to the supremum of the set `c`, where the supremum is defined by `LinearPMap.sSup`.

For any ring `R` and modules `E` and `F` over `R`, if `c` is a directed set of linear mappings from `E` to `F`, then for all `f` in `c`, we have `f ≤ LinearPMap.sSup c`.


theorem Set.monotone_projIcc :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b), Monotone (Set.projIcc a b h) := by sorry

This theorem states that for any type `α` equipped with a linear order, and any two elements `a` and `b` of `α` such that `a` is less than or equal to `b`, the function that projects `α` to the closed interval `[a, b]` is monotone. That is, if `x` and `y` are any two elements in `α` such that `x` is less than or equal to `y`, applying this projection function to `x` and `y` maintains the order; the output of the function applied to `x` is less than or equal to the function applied to `y`.

For any linear order `α` and elements `a ≤ b` in `α`, the function that maps an element `x` to the closed interval `[a, b]` is monotone, i.e., `x ≤ y` implies `[a, b] x ≤ [a, b] y`.


theorem le_of_abs_le : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b : α}, |a| ≤ b → a ≤ b := by sorry

This theorem, `le_of_abs_le`, states that for any type `α` which forms a linear ordered additive commutative group, given any two elements `a` and `b` of this type, if the absolute value of `a` is less than or equal to `b`, then `a` itself is also less than or equal to `b`. This theorem is essentially capturing the well-known property from mathematics that in any ordered group, the absolute value of a member provides an upper bound of that member.

For all additive, commutative, and linearly ordered group types `α` and elements `a` and `b` of type `α`, if `|a| ≤ b`, then `a ≤ b`.


theorem Disjoint.inf_right' :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α} (c : α),
      Disjoint a b → Disjoint a (c ⊓ b) :=
  by sorry

The theorem `Disjoint.inf_right'` states that for any type `α` that is a semilattice with respect to the infimum operation (denoted by `⊓`) and has a bottom element (denoted by `⊥`), and for any three elements `a`, `b`, and `c` of `α`, if `a` and `b` are "disjoint" (in the sense that any element less than or equal to both `a` and `b` is also less than or equal to `⊥`), then `a` and `c ⊓ b` are also disjoint. The property of being disjoint is therefore preserved under taking the infimum with `c` on the right.

For any semilattice `α` with a bottom element `⊥` and disjoint elements `a` and `b`, `a` and `b ⊓ c` are disjoint for all `c` in `α`.


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

The theorem `Set.neg_mem_neg` states that for any type `α` equipped with an involutive negation operation (i.e., a negation operation that when applied twice gives the original element back) and any set `s` of elements of type `α`, the negation of an element `a` of type `α` is in the negation of the set `s` if and only if `a` is in `s`. This theorem essentially tells us that the negation operation on elements is compatible with the negation operation on sets in this given context.

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


theorem interior_mem_nhds :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], interior s ∈ nhds x ↔ s ∈ nhds x := by sorry

This theorem states that for any type `X`, any element `x` of `X`, and any set `s` of `X`, given a topology on `X`, the interior of `s` is in the neighborhood of `x` if and only if `s` itself is in the neighborhood of `x`. In other words, it establishes a connection between a particular set `s` and its interior in terms of their relationship to the neighborhood of a given point `x` in the context of a topological space.

For any topological space (X, τ), point x ∈ X, and set s ∈ τ, the interior of s contains x if and only if s is in the neighborhood of x.


theorem Submonoid.coe_iInf :
    ∀ {M : Type u_1} [inst : MulOneClass M] {ι : Sort u_4} {S : ι → Submonoid M}, ↑(⨅ i, S i) = ⋂ i, ↑(S i) := by sorry

This theorem states that for any type `M` with a multiplication and identity operation (captured by `MulOneClass M`), and for any indexing type `ι` with given submonoids `S : ι → Submonoid M`, the coercion of the infimum (greatest lower bound) of the `S i` for all `i` (represented by `⨅ i, S i`) is equal to the intersection over all `i` of the coercion of `S i` (represented by `⋂ i, ↑(S i)`). In simpler terms, the intersection of a collection of submonoids is itself a submonoid.

For any type `M` with multiplication and identity, and for any indexing type `ι` with submonoids `S i`, the infimum of `S i` for all `i` equals the intersection of the coercions of `S i`. (In other words, the intersection of submonoids is itself a submonoid.)


theorem MeasureTheory.stoppedValue_hitting_mem :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι]
      [inst_1 : IsWellOrder ι fun x x_1 => x < x_1] {u : ι → Ω → β} {s : Set β} {n m : ι} {ω : Ω},
      (∃ j ∈ Set.Icc n m, u j ω ∈ s) → MeasureTheory.stoppedValue u (MeasureTheory.hitting u s n m) ω ∈ s :=
  by sorry

This theorem states that for any types `Ω`, `β`, and `ι`, given a conditionally complete linear order on `ι`, a well-order on `ι` defined by a less-than relation, a mapping `u` from `ι` and `Ω` to `β`, a set `s` of type `β`, and elements `n`, `m` of `ι`, and `ω` of `Ω`, if there exists an element `j` in the closed interval from `n` to `m` such that `u j ω` belongs to the set `s`, then the stopped value of the mapping `u` with respect to the hitting time of `u`, `s`, `n`, and `m`, evaluated at `ω`, is also in the set `s`. In other words, if `u j ω` for some `j` in `[n, m]` is in `s`, then the stopped value of `u` at the time `u` first hits `s` between `n` and `m` is also in `s`.

Given a conditionally complete linear order on `ι`, a well-order on `ι`, a mapping `u` from `ι` and `Ω` to `β`, a set `s` of type `β`, and elements `n`, `m` of `ι` and `ω` of `Ω`, if there exists `j` in `[n, m]` such that `u j ω` is in `s`, then the stopped value of `u` at the hitting time of `s` between `n` and `m` is also in `s`.


theorem Cardinal.mk_image_le : ∀ {α β : Type u} {f : α → β} {s : Set α}, Cardinal.mk ↑(f '' s) ≤ Cardinal.mk ↑s := by
  sorry

The theorem `Cardinal.mk_image_le` states that for any types `α` and `β`, and for any function `f` from `α` to `β` and any set `s` of type `α`, the cardinality of the image of `s` under `f` is less than or equal to the cardinality of `s`. In other words, the function `f` cannot increase the cardinality of the set `s` through its mapping.

For any function from a type to another and any subset of the domain, the cardinality of the image of the subset under the function is less than or equal to the cardinality of the subset.


/-- `id x = x`, as a `@[simp]` lemma.  -/
theorem id_eq : ∀ {α : Sort u_1} (a : α), id a = a := by sorry

This theorem states that for any given type `α` and any element `a` of that type, the identity function `id` applied to `a` is equal to `a` itself. It's marked as a simplification lemma, meaning that Lean will automatically apply it to simplify expressions during proof search.

For any type `α` and its element `a`, the identity function `id a = a`.


AntitoneOn.sup

/-- Pointwise supremum of two antitone functions is an antitone function.  -/
theorem AntitoneOn.sup :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β} {s : Set α},
      AntitoneOn f s → AntitoneOn g s → AntitoneOn (f ⊔ g) s :=
  by sorry

The theorem `AntitoneOn.sup` states that for any two functions `f` and `g` from a preorder `α` to a semilattice `β`, if both functions are antitone (non-increasing) on a particular set `s` of `α`, then their pointwise supremum function (a function where the value at each point is the maximum of the values of `f` and `g` at that point) is also antitone on the same set `s`. In mathematical terms, if for all `a, b ∈ s` we have `a ≤ b` implies `f b ≤ f a` and `g b ≤ g a`, then `a ≤ b` also implies `(f ⊔ g) b ≤ (f ⊔ g) a`, where `f ⊔ g` is the pointwise supremum of `f` and `g`.

If two antitone functions from a preorder to a semilattice restrict to the same set satisfy `a ≤ b` implying `f(b) ≤ f(a)` and `g(b) ≤ g(a)`, then their pointwise supremum is also antitone on that set.


theorem pow_iterate : ∀ {G : Type u_3} [inst : Monoid G] (n j : ℕ), (fun x => x ^ n)^[j] = fun x => x ^ n ^ j := by
  sorry

This theorem states that for any type `G` that forms a monoid, and for any two natural numbers `n` and `j`, the `j`-th iterate of the function that raises its argument to the `n`-th power is the same as the function that raises its argument to the power of `n` raised to the `j`-th power. In mathematical terms, for any element `x` in `G`, we have $(x^n)^j = x^{n^j}$.

For any monoid `G` and natural numbers `n` and `j`, the `j`-th power of `n` applied to an element `x` in `G` is equal to the `j`-th iterate of the function that maps an element to its `n`-th power, i.e., $(x^n)^j = x^{n^j}$.


theorem Set.Ioc_subset_Ioc_union_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ioc a c ⊆ Set.Ioc a b ∪ Set.Ioc b c := by sorry

This theorem states that for any linearly ordered type `α` and any three elements `a`, `b`, and `c` of `α`, the left-open right-closed interval from `a` to `c` is a subset of the union of the left-open right-closed interval from `a` to `b` and the left-open right-closed interval from `b` to `c`. In mathematical terms, it states that for all `a`, `b`, and `c` in a linear order, the interval `(a, c]` is contained within the union of the intervals `(a, b]` and `(b, c]`.

For any linearly ordered type `α` and elements `a`, `b`, `c` in `α` with `a < b < c`, the left-open right-closed interval `(a, c]` is a subset of the union of `(a, b]` and `(b, c]`.


theorem uniformContinuousOn_univ :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformContinuousOn f Set.univ ↔ UniformContinuous f :=
  by sorry

The theorem `uniformContinuousOn_univ` states that for any two types `α` and `β` equipped with uniform spaces, and any function `f` from `α` to `β`, the function `f` is uniformly continuous on the universal set of `α` (i.e., the set containing all elements of `α`) if and only if `f` is uniformly continuous. In other words, a function is uniformly continuous in general if it is uniformly continuous when considering all possible inputs.

A function between uniform spaces is uniformly continuous on the universal set if and only if it is uniformly continuous.


IsBoundedLinearMap.differentiableAt

theorem IsBoundedLinearMap.differentiableAt :
    ∀ {𝕜 : 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}, IsBoundedLinearMap 𝕜 f → DifferentiableAt 𝕜 f x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a normed space over `𝕜` for `E` and `F`, if `f` is a function from `E` to `F` and `f` is a bounded linear map, then `f` is differentiable at any point `x` in `E`. In other words, there exists a derivative for the function `f` at the point `x`.

Given a nontrivially normed field `𝕜`, any normed additive commutative groups `E` and `F`, and a normed space over `𝕜` for both `E` and `F`, if `f` is a bounded linear map from `E` to `F`, then `f` is differentiable at every point in `E`.


theorem Cardinal.add_right_inj_of_lt_aleph0 :
    ∀ {α β γ : Cardinal.{u_1}}, γ < Cardinal.aleph0 → (α + γ = β + γ ↔ α = β) := by sorry

This theorem states that for any three cardinal numbers `α`, `β`, and `γ`, if `γ` is less than `ℵ₀` (the smallest infinite cardinal), then the equality of `α + γ` and `β + γ` implies the equality of `α` and `β`. In other words, if `γ` is a finite cardinal number, the additive operation on the right side with `γ` is injective in the set of cardinal numbers. This mirrors the familiar property from elementary arithmetic where, if two numbers plus a same number give the same result, the two original numbers must have been equal.

For any cardinal numbers `α`, `β`, and finite `γ`, if `α + γ = β + γ`, then `α = β`.


theorem AddCommGroup.modEq_iff_eq_add_zsmul :
    ∀ {α : Type u_1} [inst : AddCommGroup α] {p a b : α}, a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p := by sorry

This theorem states that for any type `α` that forms an additive commutative group, given three elements `p`, `a`, and `b` from `α`, `a` is congruent to `b` modulo `p` if and only if there exists an integer `z` such that `b` equals `a` plus `z` times `p`. In other words, two elements `a` and `b` are congruent modulo `p` if `b` can be expressed as the sum of `a` and some multiple of `p`.

For any additive commutative group type `α` and elements `a`, `b`, and `p` in `α`, `a` is congruent to `b` modulo `p` if and only if `b` equals `a + k * p` for some integer `k`.


theorem Nat.choose_symm_add : ∀ {a b : ℕ}, Nat.choose (a + b) a = Nat.choose (a + b) b := by sorry

This theorem, `Nat.choose_symm_add`, states that for all natural numbers `a` and `b`, the number of ways to choose `a` elements from a set of `a + b` elements is equal to the number of ways to choose `b` elements from the same set. In other words, the binomial coefficient ${a + b \choose a}$ is equal to ${a + b \choose b}$. This property is a reflection of the symmetry in the definition of binomial coefficients.

For all natural numbers a and b, the number of ways to choose a elements from a set of size a + b is equal to the number of ways to choose b elements from the same set. Equivalently, (a + b) choose a = (a + b) choose b.


theorem Nat.gcd_div : ∀ {m n k : ℕ}, k ∣ m → k ∣ n → Nat.gcd (m / k) (n / k) = Nat.gcd m n / k := by sorry

The theorem `Nat.gcd_div` states that for all natural numbers `m`, `n`, and `k`, if `k` divides `m` and `k` divides `n`, then the greatest common divisor (gcd) of `m / k` and `n / k` is equal to the gcd of `m` and `n` divided by `k`. In mathematical notation, this can be written as: for all $m$, $n$, $k$ in $\mathbb{N}$, if $k | m$ and $k | n$, then $\gcd(\frac{m}{k}, \frac{n}{k}) = \frac{\gcd(m, n)}{k}$.

The greatest common divisor of `m/k` and `n/k` equals the gcd of `m` and `n` divided by `k`, for all natural numbers `m`, `n`, and `k` with `k` being a common divisor of `m` and `n`.


theorem IsLocalizedModule.mk'_smul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
      [inst_5 : IsLocalizedModule S f] (r : R) (m : M) (s : ↥S),
      IsLocalizedModule.mk' f (r • m) s = r • IsLocalizedModule.mk' f m s :=
  by sorry

This theorem states that for all commutative semirings `R`, submonoids `S` of `R`, additive commutative monoids `M` and `M'`, and modules `M` and `M'` over `R`, if `f` is a linear map from `M` to `M'` which satisfies the property of being a localized module with respect to `S`, then for any element `r` of `R`, any element `m` of `M`, and any element `s` of `S`, the fraction `r • m / s` with respect to the localization map `f` (denoted as `IsLocalizedModule.mk' f (r • m) s`) is equal to `r` times the fraction `m / s` with respect to the localization map `f` (denoted as `r • IsLocalizedModule.mk' f m s`). In mathematical terms, this states that the localization map `f` respects the scalar multiplication operation of the modules.

For all commutative semirings `R`, submonoids `S` of `R`, additive commutative `R`-modules `M` and `M'`, and linear maps `f` from `M` to `M'` that are localized module homomorphisms with respect to `S`, the scalar multiplication operation is respected, i.e., `f(r * m) = r * f(m)` for all `r` in `R` and `m` in `M`.


theorem Mathlib.Algebra.Associated._auxLemma.5 : ∀ {α : Type u_1} [inst : MonoidWithZero α], Irreducible 0 = False := by
  sorry

This theorem, from the Mathlib library in Algebra under Associated, states that zero cannot be classified as irreducible for any type `α` that forms a monoid with zero. In the context of algebra, an element is said to be irreducible if it cannot be factored into the product of two non-unit elements. According to this theorem, zero is not an irreducible element.

In any monoid type with zero, zero is not an irreducible element.


theorem GaloisConnection.u_unique :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u →
        ∀ {l' : α → β} {u' : β → α}, GaloisConnection l' u' → (∀ (a : α), l a = l' a) → ∀ {b : β}, u b = u' b :=
  by sorry

The theorem `GaloisConnection.u_unique` states that for any two types `α` and `β` that are partially ordered and pre-ordered respectively, if there exists two pairs of functions `(l, u)` and `(l', u')` that both form a Galois connection between `α` and `β`, then if all elements of `α` map to the same value under both `l` and `l'`, it necessarily follows that all elements of `β` map to the same value under both `u` and `u'`. In other words, if two Galois connections on the same types have the same lower adjoint, they must also have the same upper adjoint.

If two Galois connections between partially ordered type `α` and pre-ordered type `β` have the same lower adjoint functions, then their upper adjoint functions are equal.


Asymptotics.IsTheta.trans

theorem Asymptotics.IsTheta.trans :
    ∀ {α : Type u_1} {E : Type u_3} {G : Type u_5} {F' : Type u_7} [inst : Norm E] [inst_1 : Norm G]
      [inst_2 : SeminormedAddCommGroup F'] {l : Filter α} {f : α → E} {g : α → F'} {k : α → G},
      f =Θ[l] g → g =Θ[l] k → f =Θ[l] k :=
  by sorry

The theorem `Asymptotics.IsTheta.trans` states that, given certain types `α`, `E`, `G`, and `F'` with `E`, `G` and `F'` having norms and `F'` also being a seminormed additive commutative group, and given a filter `l` and functions `f : α → E`, `g : α → F'`, and `k : α → G`, if `f` is asymptotically equivalent to `g` with respect to filter `l` and `g` is asymptotically equivalent to `k` also with respect to filter `l`, then `f` is also asymptotically equivalent to `k` with respect to filter `l`. This is essentially a statement of the transitivity of the asymptotic equivalence relation.

If `f` is asymptotically equivalent to `g` and `g` is asymptotically equivalent to `k` with respect to filter `l`, then `f` is asymptotically equivalent to `k` with respect to filter `l`.


/-- A continuous and adapted process is progressively measurable.  -/
theorem MeasureTheory.Adapted.progMeasurable_of_continuous :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : TopologicalSpace β]
      [inst_1 : Preorder ι] {u : ι → Ω → β} {f : MeasureTheory.Filtration ι m} [inst_2 : TopologicalSpace ι]
      [inst_3 : TopologicalSpace.MetrizableSpace ι] [inst_4 : SecondCountableTopology ι] [inst_5 : MeasurableSpace ι]
      [inst_6 : OpensMeasurableSpace ι] [inst_7 : TopologicalSpace.PseudoMetrizableSpace β],
      MeasureTheory.Adapted f u → (∀ (ω : Ω), Continuous fun i => u i ω) → MeasureTheory.ProgMeasurable f u :=
  by sorry

The theorem `MeasureTheory.Adapted.progMeasurable_of_continuous` states that for any types `Ω`, `β`, `ι`; a measurable space `m` over `Ω`; a topological space over `β`; a preorder on `ι`; a sequence of functions `u` from `ι` to `Ω → β`; a filtration `f` on `m`; provided that the space `ι` is topological, metrizable, has a second countable topology, is measurable, has an open measurable space, and `β` is pseudo-metrizable: if the sequence `u` is adapted to the filtration `f` (i.e., for all `i`, `u i` is `f i`-measurable), and for every `ω` in `Ω`, the function `u i ω` is continuous, then `u` is progressively measurable with respect to the filtration `f` (i.e., for every `i` in `ι`, the function `u` up to time `i` is measurable). This theorem connects the concepts of adapted processes, continuity, and progressive measurability in the framework of measure theory.

If `Ω`, `β`, `ι` are suitable types, `m` is a measurable space over `Ω`, `β` is pseudo-metrizable, `ι` is a second countable, measurable topological space, `u: ι → Ω → β` is a sequence of continuous, `f` is a filtration on `m`, and `u` is adapted to `f`, then `u` is progressively measurable with respect to `f`.


theorem rank_range_of_surjective :
    ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
      [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
      Function.Surjective ⇑f → Module.rank R ↥(LinearMap.range f) = Module.rank R M' :=
  by sorry

The theorem `rank_range_of_surjective` states that for any ring `R`, and for any two types `M` and `M'` that form commutative additive groups and are modules over `R`, if there exists a linear map `f` from `M` to `M'` which is surjective (every element in `M'` is the image of some element in `M` under `f`), then the rank of the range of `f` (as a module over `R`) is equal to the rank of `M'` when it's considered as a module over `R`. In more mathematical terms, if $f: M \rightarrow M'$ is a surjective linear map between two modules over a ring $R$, then the rank of the range of $f$ as a $R$-module is equal to the rank of the $R$-module $M'$.

For any surjective linear map `f` between commutative additive groups and R-modules `M` and `M'`, the rank of the range of `f` as an R-module equals the rank of M' as an R-module.


theorem ArithmeticFunction.prodPrimeFactors_apply :
    ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {f : ℕ → R} {n : ℕ},
      n ≠ 0 → (ArithmeticFunction.prodPrimeFactors fun p => f p) n = Finset.prod n.primeFactors fun p => f p :=
  by sorry

This theorem states that for any non-zero natural number `n` and any function `f` from natural numbers to an arbitrary type `R` (where `R` is a type equipped with both commutative monoid and zero structure), the value of applying the arithmetic function defined by the product of `f` over the prime factors of `n` is the same as the product of `f` applied to each of the prime factors of `n`. In mathematical terms, this theorem is expressing the equality $\prod_{p \mid n} f(p) = \prod_{p \in \text{primeFactors}(n)} f(p)$, where $\prod$ denotes the product over a set.

For any non-zero natural number `n` and function `f` from natural numbers to a commutative monoid `R`, the product of `f` applied to the prime factors of `n` equals the value of `f` applied to the product of `n`'s prime factors.


Measurable.smul

theorem Measurable.smul :
    ∀ {M : Type u_2} {β : Type u_3} {α : Type u_4} [inst : MeasurableSpace M] [inst_1 : MeasurableSpace β]
      [inst_2 : SMul M β] {m : MeasurableSpace α} {f : α → M} {g : α → β} [inst_3 : MeasurableSMul₂ M β],
      Measurable f → Measurable g → Measurable fun x => f x • g x :=
  by sorry

The theorem `Measurable.smul` states that for any three types 'M', 'β', and 'α', where 'M' and 'β' are equipped with measurable spaces and 'M' and 'β' form a scalar multiplication structure, if we have a measurable space 'm' on 'α' and two functions 'f' and 'g' mapping 'α' to 'M' and 'β' respectively, then under the condition that 'M' and 'β' also form a measurable scalar multiplication structure, if both 'f' and 'g' are measurable functions, then the function that maps 'x' from 'α' to the scalar product of 'f(x)' and 'g(x)' is also measurable. In other words, the scalar product of two measurable functions is itself a measurable function.

If M and β are measurable spaces with a measurable scalar multiplication structure, and f and g are measurable functions from a measurable space α to M and β, respectively, then the function x ∈ α => (f x) * (g x) is measurable.


theorem le_mul_of_le_of_one_le :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      b ≤ c → 1 ≤ a → b ≤ c * a :=
  by sorry

The theorem `le_mul_of_le_of_one_le` states that for any type `α` that supports multiplication and the operation of "one" (`MulOneClass`), along with a preorder relationship (`Preorder`), and a specific covariance relationship (`CovariantClass`), if `b` is less than or equal to `c` and `1` is less than or equal to `a`, then `b` is less than or equal to `c` multiplied by `a`. This theorem is essentially asserting a property related to the ability to scale inequalities by multiplication in certain structures.

If `a` is non-negative and `b` is less than or equal to `c`, then `b` is less than or equal to `c` multiplied by `a`.


/-- For a set `s` in a pseudo emetric space, if for every `ε > 0` there exists a countable
set that is `ε`-dense in `s`, then there exists a countable subset `t ⊆ s` that is dense in `s`.  -/
theorem EMetric.subset_countable_closure_of_almost_dense_set :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (s : Set α),
      (∀ ε > 0, ∃ t, Set.Countable t ∧ s ⊆ ⋃ x ∈ t, EMetric.closedBall x ε) →
        ∃ t ⊆ s, Set.Countable t ∧ s ⊆ closure t :=
  by sorry

The theorem `EMetric.subset_countable_closure_of_almost_dense_set` states that for a set `s` in a pseudo emetric space, if for every positive real number `ε`, there exists a countable set which is `ε`-dense in `s` (i.e., `s` is a subset of the union of `ε`-closed balls centered at each point in the countable set), then there exists a countable subset `t` of `s` which is dense in `s` (i.e., `s` is a subset of the closure of `t`). Here, the closure of a set is the smallest closed set containing the original set, and a set is `ε`-dense in another set if the latter set is contained within the union of `ε`-closed balls centered at each point in the former set.

If a subset of a pseudometric space is ε-dense with a countable set for every ε, then it is a subsets of the closure of a countable dense set.


Commensurable.trans

theorem Commensurable.trans :
    ∀ {G : Type u_1} [inst : Group G] {H K L : Subgroup G}, Commensurable H K → Commensurable K L → Commensurable H L :=
  by sorry

The theorem `Commensurable.trans` states that for any group `G` and any subgroups `H`, `K`, and `L` of `G`, if `H` and `K` are commensurable and `K` and `L` are commensurable, then `H` and `L` are also commensurable. In other words, the commensurability relation among subgroups of a group is transitive. In group theory terms, if the relative index of `H` and `K` is nonzero (i.e., `H` has finite index in `K` and vice versa), and the same holds for `K` and `L`, then the relative index of `H` and `L` is also nonzero (i.e., `H` has finite index in `L` and vice versa).

If subgroups `H`, `K`, and `L` of a group `G` are pairwise commensurable, then `H` and `L` are commensurable. (Two subgroups `H` and `K` of a group `G` are commensurable if they have finite index in each other.)


theorem invOf_nonneg :
    ∀ {α : Type u_1} [inst : LinearOrderedSemiring α] {a : α} [inst_1 : Invertible a], 0 ≤ ⅟a ↔ 0 ≤ a := by sorry

This theorem, `invOf_nonneg`, states that for any type `α` that is a linearly ordered semiring, and for any element `a` of `α` that is invertible, `a` is non-negative (i.e., `0 ≤ a`) if and only if its multiplicative inverse is also non-negative (i.e., `0 ≤ ⅟a`). This theorem demonstrates a fundamental property of numerical inverses in mathematical structures with an order and multiplication operation that satisfies the semiring axioms.

For any linearly ordered semiring type `α` and invertible element `a` of `α`, `0 ≤ a` if and only if `0 ≤ ⅟a`.


theorem hasFDerivAtFilter_fst :
    ∀ {𝕜 : 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] {p : E × F}
      {L : Filter (E × F)}, HasFDerivAtFilter Prod.fst (ContinuousLinearMap.fst 𝕜 E F) p L :=
  by sorry

This theorem, `hasFDerivAtFilter_fst`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space over `𝕜` of `E`, normed additive commutative group `F`, normed space over `𝕜` of `F`, a pair `p` of elements from `E` and `F`, and a filter `L` on the cartesian product of `E` and `F`, the function `Prod.fst` (which projects an element of the cartesian product of `E` and `F` to `E`) has a Fréchet derivative at `p` with respect to `L`, and this derivative is the continuous linear map `ContinuousLinearMap.fst 𝕜 E F` (which is essentially the same projection, but considered as a continuous linear map).

The function `Prod.fst` from the cartesian product of two normed spaces over a nontrivially normed field, evaluated at a point `p`, has a Fréchet derivative equal to the continuous linear map `ContinuousLinearMap.fst` with respect to any filter on `p`.


theorem Polynomial.derivative_nat_cast : ∀ {R : Type u} [inst : Semiring R] {n : ℕ}, Polynomial.derivative ↑n = 0 := by
  sorry

This theorem states that for any semiring `R` and any natural number `n`, the derivative of the constant polynomial whose coefficient is `n` is the zero polynomial. In other words, when we differentiate a constant polynomial (which is simply a number `n` in our polynomial ring `R[X]`), we always get zero, just as in calculus.

For any semiring `R` and natural number `n`, the derivative of the constant polynomial `n` in `R[X]` is the zero polynomial.


theorem Vector.nil.proof_1 : ∀ {α : Type u_1}, List.length [] = List.length [] := by sorry

The theorem `Vector.nil.proof_1` states that for all types `α`, the length of an empty list is equal to the length of another empty list. This might seem trivial, but it's an important foundational piece in Lean's type theory that ensures consistency when dealing with lists of any type.

The theorem asserts that the length of an empty list is equal to 0, for all types α.


theorem rank_fun' :
    ∀ {R : Type u} {η : Type u₁'} [inst : Ring R] [inst_1 : StrongRankCondition R] [inst_2 : Fintype η],
      Module.rank R (η → R) = ↑(Fintype.card η) :=
  by sorry

The theorem `rank_fun'` states that for any type `R` with a ring structure, any type `η` that is a finite type, and given that `R` satisfies the strong rank condition, the rank of the module of functions from `η` to `R` over `R` is equal to the cardinality of `η`. In mathematical terms, if `R` is a ring and `η` is a finite set, then the dimension of the vector space of functions from `η` to `R` over `R` is the same as the number of elements in `η`. The strong rank condition is a property of the ring `R` that guarantees certain properties about the linear independence of elements in modules over `R`.

For any finite type `η` and ring `R` satisfying the strong rank condition, the dimension of the vector space of functions from `η` to `R` equals the cardinality of `η`.


theorem Polynomial.natDegree_add_eq_left_of_natDegree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.natDegree q < Polynomial.natDegree p → Polynomial.natDegree (p + q) = Polynomial.natDegree p :=
  by sorry

This theorem states that for any semiring `R`, and any two polynomials `p` and `q` over `R`, if the natural degree of `q` is less than the natural degree of `p`, then the natural degree of the sum of `p` and `q` is equal to the natural degree of `p`. In terms of algebra, the degree of a polynomial is the highest power of its variable. So in essence, when adding two polynomials, if one polynomial (`q`) has a degree less than the other (`p`), the degree of the resulting polynomial is equal to the degree of the polynomial with the higher degree.

Given two polynomials `p` and `q` over a semiring `R` with the natural degree of `q` strictly less than that of `p`, the natural degree of `p + q` equals the natural degree of `p`.


theorem Real.arcsin_sin : ∀ {x : ℝ}, -(Real.pi / 2) ≤ x → x ≤ Real.pi / 2 → Real.arcsin (Real.sin x) = x := by sorry

This theorem states that for all real numbers `x` that lie within the interval from `-π / 2` to `π / 2` (inclusive), the arcsine of the sine of `x` is equal to `x`. Essentially, this says that the function `arcsin(sin(x))` acts as the identity for `x` in the stated interval. Specifically, for real numbers `x` such that `-π / 2 ≤ x ≤ π / 2`, `arcsin(sin(x))` returns `x`.

For all real numbers `x` in the interval `[-π/2, π/2]`, the function `arcsin(sin(x))` equals `x`.


theorem Rack.self_act_act_eq :
    ∀ {R : Type u_1} [inst : Rack R] {x y : R}, Shelf.act (Shelf.act x x) y = Shelf.act x y := by sorry

This theorem states that for any type `R` that forms a `Rack`, given any elements `x` and `y` of `R`, the result of the operation `Shelf.act` twice on `x` and then on `y` (i.e., `Shelf.act (Shelf.act x x) y`) is the same as the result of the operation `Shelf.act` on `x` and `y` (i.e., `Shelf.act x y`). This can be interpreted as a kind of idempotence property of the `Shelf.act` operation when applied twice to the same element in the context of a `Rack`.

For any `Rack` type `R` and elements `x` and `y` in `R`, `Shelf.act (Shelf.act x x) y` equals `Shelf.act x y`.


theorem Matrix.one_eq_pi_single :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α] {i j : n},
      1 i j = Pi.single i 1 j :=
  by sorry

This theorem states that for any types `n` and `α`, if `n` has decidable equality, and `α` has both zero and one elements (typically representing a numeric type like an integer or real number), then for any `i` and `j` of type `n`, the identity matrix's (`1`) element at position `(i, j)` is equal to the function `Pi.single i 1 j`.

In other words, it asserts that each element of the identity matrix is the same as the output of the function `Pi.single`, which returns `1` when its first and last arguments (`i` and `j` in this case) are equal and `0` otherwise, i.e., it's `1` on the diagonal (`i = j`) and `0` elsewhere.

For any type `n` with decidable equality and any type `α` with zero and one elements, the identity matrix of `n × n` matrices over `α` is equal to the matrix obtained by applying the function `Pi.single i 1` to the identity matrix at position `(i, j)` for all `i, j` in `n`.


theorem Subalgebra.fg_top :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A), Subalgebra.FG ⊤ ↔ Subalgebra.FG S :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, and a subalgebra `S` of `A` over `R`, the whole algebra (denoted by `⊤`) being finitely generated is equivalent to the subalgebra `S` being finitely generated. In other words, the property of "being finitely generated" for the whole algebra is the same as for any of its subalgebras.

For any commutative semirings `R`, semirings `A`, and a subalgebra `S` of `A` over `R`, the whole algebra `⊤` and subalgebra `S` are finitely generated if and only if each other is.


Computable.pair

theorem Computable.pair :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {f : α → β} {g : α → γ}, Computable f → Computable g → Computable fun a => (f a, g a) :=
  by sorry

The theorem `Computable.pair` states that for any three types α, β, and γ, where α, β, and γ are Primcodable, and for any two functions `f` from α to β and `g` from α to γ, if `f` and `g` are Computable, then the function that takes an input of type α and produces a pair consisting of the result of applying `f` and `g` to that input is also Computable. In other words, if we have computable functions `f : α → β` and `g : α → γ`, then the function `h : α → β × γ` defined by `h(a) = (f(a), g(a))` is also computable.

If `f : α -> β` and `g : α -> γ` are Computable functions with Primcodable types α, β, and γ, then the function `h : α -> β x γ` defined by `h(x) = (f x, g x)` is also Computable.


theorem Set.image_iInter₂_subset :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {κ : ι → Sort u_7} (s : (i : ι) → κ i → Set α) (f : α → β),
      f '' ⋂ i, ⋂ j, s i j ⊆ ⋂ i, ⋂ j, f '' s i j :=
  by sorry

This theorem states that for any two types `α` and `β`, a type indexed by a sort `ι` and a family of sets `s` indexed by `ι` and a type depending on `ι`, and a function `f` mapping elements of type `α` to type `β`, the image of the intersection of all sets in the family `s` under the function `f` is a subset of the intersection of the images of all sets in the family `s` under the function `f`. In mathematical terms, if we have a function `f: α → β` and a family of sets `s_i` for each `i` in `ι` and `j` in `κ(i)`, then `f` applied to the intersection of all `s_i` is included in the intersection of `f` applied to all `s_i`.

For any function `f: α -> β`, family of sets `{s_i : ι -> Sort}_i`, and all `i` in `ι`, `f (intersection (ι).map (s_i)) ⊆ intersection (list.map (λ i, f (s_i i)))`.


theorem CochainComplex.mappingCone.desc.proof_1 : -1 + 1 = 0 := by sorry

This theorem, named `CochainComplex.mappingCone.desc.proof_1`, establishes a basic property of integer arithmetic, specifically that the sum of `-1` and `1` equals `0`. It's a simple yet fundamental theorem that shows the additive inverse property where adding a number and its negative counterpart results in zero.

The theorem asserts that for all integers x, -x + x = 0.


theorem mem_nonZeroDivisors_iff :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] {r : M}, r ∈ nonZeroDivisors M ↔ ∀ (x : M), x * r = 0 → x = 0 := by sorry

This theorem, `mem_nonZeroDivisors_iff`, states that for any type `M` which has an instance of `MonoidWithZero` and any element `r` of this `M`, `r` is a member of the submonoid of non-zero divisors of `M` if and only if for every `x` in `M`, the multiplication of `x` and `r` yielding zero implies `x` itself is zero. In terms of algebra, it describes the condition under which an element belongs to the set of non-zero divisors in a monoid with zero.

An element `r` of a monoid `M` with zero is a non-zero divisor if and only if for all `x` in `M`, `x * r = 0` implies `x = 0`.