/-- If `α` and `β` are infinite types, then the cardinality of `α × β` is the maximum
of the cardinalities of `α` and `β`.  -/
theorem Cardinal.mul_eq_max : ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → Cardinal.aleph0 ≤ b → a * b = max a b :=
  by sorry

This theorem states that if `α` and `β` are two infinite types (meaning their cardinalities are at least ℵ₀), then the cardinality of their Cartesian product (`α × β`), is equal to the maximum of the cardinalities of `α` and `β`. In formal terms, for any two cardinals `a` and `b` such that they are both greater than or equal to ℵ₀, the product of `a` and `b` is equal to the maximum of `a` and `b`.

If `α` and `β` are infinite types, then the cardinality of `α × β` equals the maximum of the cardinalities of `α` and `β`.


theorem MeasureTheory.VectorMeasure.sub_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M]
      [inst_2 : TopologicalAddGroup M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α), ↑(v - w) i = ↑v i - ↑w i :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.sub_apply` states that for any type `α`, a measurable space `m` over `α`, a type `M` with an additive commutative group structure, a topological space structure, and a topological additive group structure, and two vector measures `v` and `w` from `α` to `M`, the measure of the set `i` under the difference of `v` and `w` is equal to the difference of the measures of `i` under `v` and `w`. In other words, it is stating that the measure of a set under the subtraction of two vector measures is the same as subtracting the measures of the set under the individual vector measures. This can be written in mathematical notation as $(v - w)(i) = v(i) - w(i)$.

For measurable spaces (α, m), additive commutative groups (M) with topological and topological additive group structures, and measurable vector functions v and w from α to M, the difference of their applications to a set i equals their individual applications to i, i.e., (v - w)(i) = v(i) - w(i).


theorem Finset.zero_mem_zero : ∀ {α : Type u_2} [inst : Zero α], 0 ∈ 0 := by sorry

This theorem states that for any type `α` that has a zero element, the zero element is a member of the zero finset. Here, `0 ∈ 0` is a shorthand way of saying that the zero element of the type `α` is in the set that consists only of the zero element of `α`. This is a basic property of any type that has a zero element.

For any type `α` with a zero element, the zero element belongs to the zero finset. In mathematical notation, `0 ∈ 0 : Finset α`.


theorem MeasureTheory.levyProkhorovDist_triangle :
    ∀ {Ω : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
      (μ ν κ : MeasureTheory.Measure Ω) [inst_3 : MeasureTheory.IsFiniteMeasure μ]
      [inst_4 : MeasureTheory.IsFiniteMeasure ν] [inst_5 : MeasureTheory.IsFiniteMeasure κ],
      MeasureTheory.levyProkhorovDist μ κ ≤ MeasureTheory.levyProkhorovDist μ ν + MeasureTheory.levyProkhorovDist ν κ :=
  by sorry

The theorem `MeasureTheory.levyProkhorovDist_triangle` states that for any three finite measures `μ`, `ν`, and `κ` on a measurable space `Ω` equipped with a pseudo emetric structure, the Lévy-Prokhorov distance between `μ` and `κ` is less than or equal to the sum of the Lévy-Prokhorov distance between `μ` and `ν` and the Lévy-Prokhorov distance between `ν` and `κ`. This is a manifestation of the triangle inequality in the context of the Lévy-Prokhorov distance between measures.

The Lévy-Prokhorov distance between any three finite measures on a pseudo metric space is maximally increased by passing through a third measure, i.e., the triangle inequality holds for Lévy-Prokhorov distances.


theorem CategoryTheory.ShortComplex.SnakeInput.L₀'_exact :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.SnakeInput.L₀' S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.SnakeInput.L₀'_exact` states that for any category `C`, which is an instance of the `CategoryTheory.Category` and `CategoryTheory.Abelian` typeclasses, and for any `S` which is an instance of `CategoryTheory.ShortComplex.SnakeInput` on `C`, the short complex `L₀'` associated with `S` is exact. In the language of category theory, a short complex is exact if the image of each morphism equals the kernel of the next morphism, meaning that the sequence of morphisms depicts an exact sequence.

For any Abelian category `C` and an instance `S` of `CategoryTheory.ShortComplex.SnakeInput` on `C`, the associated short complex `L₀'` is an exact sequence of abelian group objects in `C`.


theorem Polynomial.mem_nthRootsFinset :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {n : ℕ},
      0 < n → ∀ {x : R}, x ∈ Polynomial.nthRootsFinset n R ↔ x ^ n = 1 :=
  by sorry

This theorem states that, for any commutative ring `R` that is also an integral domain, and for any positive natural number `n`, a given element `x` of `R` is in the finset of `n`-th roots of unity (that is, the finset of solutions to the equation `x^n = 1` in the ring `R`) if and only if `x` raised to the power of `n` equals `1`.

For a commutative ring R that is an integral domain, an element x of R is a n-th root of unity if and only if x^n = 1.


theorem finite_iff_nonempty_fintype : ∀ (α : Type u_4), Finite α ↔ Nonempty (Fintype α) := by sorry

This theorem states that, for any type `α`, `α` is finite if and only if there exists a finite type instance for `α`. In other words, a type is considered finite if it can be associated with a finite type, which is a type with a finite number of distinct values. Theorem `finite_iff_nonempty_fintype` provides a characterization of finite types in terms of the existence of a finite type instance.

A type `α` is finite if and only if there exists a finite type instance for it.


/-- `C(X, ·)` is a functor.  -/
theorem ContinuousMap.continuous_comp :
    ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] (g : C(Y, Z)), Continuous (ContinuousMap.comp g) :=
  by sorry

The theorem `ContinuousMap.continuous_comp` states that for any three types `X`, `Y`, and `Z` (representing topological spaces), and for any continuous map `g` from `Y` to `Z` (denoted as `C(Y, Z)`), the composition operation `ContinuousMap.comp g` is a continuous function. In other words, `C(X, ·)` is a functor - it preserves the structure between the topological spaces. In terms of mathematics, if we have two continuous functions `f` and `g`, the composition of these functions `(g ∘ f)` is also a continuous function.

The theorem `ContinuousMap.continuous_comp` asserts that the composition of two continuous functions between topological spaces is a continuous function.


theorem UniqueFactorizationMonoid.exists_mem_normalizedFactors_of_dvd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a p : α},
      a ≠ 0 → Irreducible p → p ∣ a → ∃ q ∈ UniqueFactorizationMonoid.normalizedFactors a, Associated p q :=
  by sorry

This theorem states that for any non-zero element `a` of a unique factorization monoid, given an irreducible element `p` that divides `a`, there exists an element `q` in the multiset of normalized prime factors of `a` such that `p` and `q` are associated. In other words, if `p` is an irreducible factor of `a`, there must be an equivalent factor in the prime factorization of `a`. The equivalence is determined by the `Associated` relation, meaning `p` and `q` are equivalent if `p` can be obtained by multiplying `q` by a unit of the monoid.

For any non-zero element `a` in a unique factorization monoid and any irreducible factor `p` of `a`, there exists a normalized prime factor `q` of `a` such that `p` and `q` are associated.


theorem IsArtinian.monotone_stabilizes :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : IsArtinian R M] (f : ℕ →o (Submodule R M)ᵒᵈ), ∃ n, ∀ (m : ℕ), n ≤ m → f n = f m :=
  by sorry

This theorem states that for any given ordered homomorphism `f` from the natural numbers `ℕ` to the ordered dual of the set of submodules of a module `M` over a ring `R`, there exists a natural number `n` such that for all natural numbers `m` such that `n` is less than or equal to `m`, `f(n)` is equal to `f(m)`. The types `R` and `M` are universally quantified, as are the property of `R` being a ring, `M` being an `AddCommGroup`, and `M` being a module over `R`. The theorem also assumes that the module `M` is Artinian.

For any Artinian module M over a ring R and ordered homomorphism f from the natural numbers to the ordered dual of submodules of M, there exists a natural number n such that for all m ≥ n, f(n) = f(m).


/-- A geometric series in a complete normed ring is summable.
Proved above (same name, different namespace) for not-necessarily-complete normed fields.  -/
theorem NormedRing.summable_geometric_of_norm_lt_one :
    ∀ {R : Type u_4} [inst : NormedRing R] [inst_1 : CompleteSpace R] (x : R), ‖x‖ < 1 → Summable fun n => x ^ n := by
  sorry

This theorem states that a geometric series in a complete normed ring is summable. Specifically, for any element `x` in a type `R` that is a complete normed ring, if the norm of `x` (denoted as ‖x‖) is less than 1, then the function defined by raising `x` to the power `n` (i.e., `x ^ n`) is summable. A function is deemed summable if it has some infinite sum. This result has been proved earlier for normed fields that may not necessarily be complete.

In a complete normed ring, if the norm of an element is less than 1, then the geometric series formed by summing the powers of that element converges.


theorem Finset.isLeast_min' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), IsLeast (↑s) (Finset.min' s H) := by sorry

This theorem states that for any non-empty finset `s` in a linearly ordered type `α`, the minimum element of `s` is a least element of the set. Here, being a "least element" means that the element not only belongs to the set, but is also lower than or equal to all other elements in the set (i.e., it falls within the lower bounds of the set). The function `Finset.min'` is used to obtain the minimum element of the finset, and `IsLeast` is used to assert its status as the least element.

For any non-empty finset `s` in a linearly ordered type `α`, the minimum element of `s` is the unique element that is both in `s` and less than or equal to every other element in `s`.


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

This theorem states that for any real numbers `x` and `y`, if `x` is non-negative (i.e., `x` is greater than or equal to 0), then the absolute value of `x` raised to the power of `y` is equal to the absolute value of `x` raised to the power of `y`. In mathematical notation, this reads: for all $x, y \in \mathbb{R}$ with $x \geq 0$, we have $|x^y| = |x|^y$.

For all real numbers $x \geq 0$ and $y$, $|x|^y = |x^y|$.


DifferentiableWithinAt.smul

theorem DifferentiableWithinAt.smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E} {𝕜' : Type u_6} [inst_5 : NontriviallyNormedField 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜']
      [inst_7 : NormedSpace 𝕜' F] [inst_8 : IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'},
      DifferentiableWithinAt 𝕜 c s x →
        DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (fun y => c y • f y) s x :=
  by sorry

The theorem `DifferentiableWithinAt.smul` states that for every non-trivially normed field `𝕜`, every normed additively commutative group `E` and `F` (which are also normed spaces over `𝕜`), every function `f` from `E` to `F`, every point `x` in `E`, and every set `s` of `E`, if `c` is a scalar field over `E`, and both `c` and `f` are differentiable at `x` within `s`, then the function which maps `y` in `E` to the scalar product of `c(y)` and `f(y)` is also differentiable at `x` within `s`. Here, `𝕜'` is a non-trivially normed field that is a normed algebra over `𝕜` and `F` is a normed space over `𝕜'`, with `𝕜` being a scalar tower over `𝕜'` and `F`.

Given a non-trivially normed field `𝕜`, a normed additively commutative group `E` and `F` over `𝕜` (with `F` a normed space over a normed algebra `𝕜'` over `𝕜`), if `f: E → F` is differentiable at `x ∈ E` within a set `s ⊆ E`, and `c: E → 𝕜` is a scalar function differentiable at `x` within `s`, then the function `y ∈ s ↦ c(y)⊤f(y) ∈ 𝕜'` is differentiable at `x`.


theorem gcd_assoc :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (m n k : α),
      gcd (gcd m n) k = gcd m (gcd n k) :=
  by sorry

The theorem `gcd_assoc` states that for any type `α` that is a cancel commutative monoid with zero and a normalized GCD monoid, the greatest common divisor (gcd) operation is associative. In other words, for any three elements `m`, `n`, and `k` of type `α`, the gcd of `m` and `n` taken together and then taking the gcd with `k` is equal to the gcd of `m` with the gcd of `n` and `k`. In mathematical notation, this is equivalent to stating that `gcd(gcd(m, n), k) = gcd(m, gcd(n, k))`.

For any cancel commutative monoid with zero and a normalized GCD monoid type `α`, the associativity of the greatest common divisor operation holds: `gcd(gcd(m, n), k) = gcd(m, gcd(n, k))`.


theorem Memℓp.finite_dsupport :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      Memℓp f 0 → Set.Finite {i | f i ≠ 0} :=
  by sorry

The theorem `Memℓp.finite_dsupport` states that for any index set `α` and any type family `E` indexed by `α`, given any normed additive commutative group structure on the types `E i`, if a function `f` from index `i` in `α` to `E i` belongs to the set `Memℓp` for `p = 0`, then the set of indices `{i | f i ≠ 0}` where `f` is non-zero is finite. In other words, it means that `f` is finitely supported if it belongs to the `ℓp` space for `p = 0`.

For any indexed type family `E` over a set `α` with normed additive commutative group structures, if a function `f` from `α` to `E` belongs to the `ℓp` space with `p = 0`, then the support of `f` is finite.


theorem Mathlib.Data.Real.EReal._auxLemma.3 : ∀ {x y : ℝ}, (↑x = ↑y) = (x = y) := by sorry

This theorem, `Mathlib.Data.Real.EReal._auxLemma.3`, states that for every pair of real numbers `x` and `y`, the property that 'the lifted value of `x` equals the lifted value of `y`' is equivalent to 'x equals y'. In mathematical terms, this is saying if two real numbers are the same when they are embedded into the extended real number system, then they are indeed the same real numbers.

The theorem `Mathlib.Data.Real.EReal._auxLemma.3` in Lean 4 asserts that for all real numbers x and y, x = y if and only if their corresponding extended real numbers are equal.


theorem Mathlib.Data.Real.EReal._auxLemma.6 : ∀ (x : ℝ), (↑x = ⊥) = False := by sorry

This theorem, from the Mathlib library for the Lean theorem prover, states that the real number 'x' when lifted to the extended real number line, cannot be equal to negative infinity. In other words, any real number 'x', when considered as an extended real number, is always finite and it's impossible for it to be negative infinity. This holds true for all real numbers 'x'.

The real number 'x' is never equal to negative infinity when considered as an extended real number.


theorem Mathlib.Data.Real.EReal._auxLemma.9 : ∀ (x : ℝ), (↑x = ⊤) = False := by sorry

This theorem, `Mathlib.Data.Real.EReal._auxLemma.9`, asserts that for any real number `x`, the statement that `x` equals positive infinity (`⊤`) is false. In more mathematical terms, no real number can be equal to positive infinity.

There exists no real number equal to positive infinity.


theorem Continuous.borel_measurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      Continuous f → Measurable f :=
  by sorry

The theorem `Continuous.borel_measurable` states that for any function `f` from a type `α` to a type `β`, if `α` and `β` are both topological spaces and the function `f` is continuous, then `f` is also measurable. This means that for any measurable set in the codomain (`β`), the preimage of this set under the function `f` is a measurable set in the domain (`α`).

If `f: α → β` is a continuous function between topological spaces `α` and `β`, then `f` is measurable, i.e., for any measurable set `M ∈ β`, the preimage `f⁻¹(M) ∈ α` is also measurable.


/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is maximized when
`f` and `g` monovary together. Stated by permuting the entries of `f`.  -/
theorem MonovaryOn.sum_comp_perm_smul_le_sum_smul :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      MonovaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s → (Finset.sum s fun i => f (σ i) • g i) ≤ Finset.sum s fun i => f i • g i :=
  by sorry

**Rearrangement Inequality**: Given a finite set `s` and two functions `f: ι → α` and `g: ι → β` (where `ι` is any type, `α` is a type forming a linear ordered ring, and `β` a type forming a linear ordered commutative additive group), this theorem states that if `f` and `g` monovary together on the set `s` (i.e., an increase in `g` implies a non-decrease in `f`) and we have a permutation `σ` that only permutes elements within `s`, then the sum of the product of `f` and `g` under this permutation (`f (σ i) • g i` summed over all `i` in `s`) is less than or equal to the sum of the product of `f` and `g` without permutation (`f i • g i` summed over all `i` in `s`). This essentially means that the pointwise scalar multiplication of `f` and `g` is maximized when `f` and `g` monovary together, and rearranging the elements of `f` can only decrease this sum.

Given a finite set with functions `f:` `ι` `→` `α` (where `α` is a linearly ordered ring) and `g:` `ι` `→` `β` (where `β` is a linearly ordered commutative additive group), if `f` and `g` are monotonic together on `ι`, then the sum of their pointwise products under any permutation of their domain is less than or equal to the sum without permutation.


theorem Set.Countable.measure_zero :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {s : Set α},
      Set.Countable s → ∀ (μ : MeasureTheory.Measure α) [inst : MeasureTheory.NoAtoms μ], ↑↑μ s = 0 :=
  by sorry

The theorem `Set.Countable.measure_zero` states that for any type `α`, any measurable space `m0` over `α`, any set `s` of the type `α`, and any measure `μ` in the measure theory over `α`, if the set `s` is countable, then under the assumption that the measure `μ` has no atoms, the measure `μ` of the set `s` is always zero. This essentially means that countable sets have measure zero in a measure space where the measure has no atoms.

If `μ` is a measure on a countable measurable set `s` in a measure space without atoms, then `μ(s) = 0`.


theorem List.filterMap_eq_filter :
    ∀ {α : Type u_1} (p : α → Bool), List.filterMap (Option.guard fun x => p x = true) = List.filter p := by sorry

The theorem `List.filterMap_eq_filter` states that for all types `α` and a Boolean function `p` applied to the elements of this type, the function `List.filterMap` combined with `Option.guard` applied to a function that checks if `p x` is true, is equivalent to directly using the `List.filter` function with `p`. In other words, filtering a list using `List.filterMap` and `Option.guard` gives the same result as directly filtering the list with `p` using `List.filter`. This theorem essentially shows that `List.filter` and `List.filterMap` combined with `Option.guard` are interchangeable under these conditions.

For all types α and Boolean functions p, List.filterMap (Option.guard p) equals List.filter p.


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

This theorem, `sdiff_right_comm`, states that for any type `α` that forms a Generalized Coheyting Algebra, and for any three elements `a`, `b`, and `c` of this type, the "set difference" operation is right-commutative. In other words, taking the set difference of `a` and `b` and then the set difference of the result with `c` yields the same result as taking the set difference of `a` and `c` and then the set difference of the result with `b`. In mathematical notation, this can be written as `(a \ b) \ c = (a \ c) \ b`.

For any type `α` forming a Generalized Cohen algebra, the right commutativity of set difference holds: `(a \ b) \ c = (a \ c) \ b`.


theorem Polynomial.coeff_erase :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n i : ℕ),
      Polynomial.coeff (Polynomial.erase n p) i = if i = n then 0 else Polynomial.coeff p i :=
  by sorry

The theorem `Polynomial.coeff_erase` states that for any semiring `R`, any polynomial `p` of type `Polynomial R`, and any natural numbers `n` and `i`, the coefficient of the term `X^i` in the polynomial resulting from erasing the `X^n` term in `p` (`Polynomial.erase n p`) is equal to zero if `i` equals `n` (since the `X^n` term has been erased), otherwise it is equal to the coefficient of the term `X^i` in the original polynomial `p`.

For any semiring R, polynomial p of type Polynomial R, and natural numbers n and i, the coefficient of X^i in the polynomial obtained by erasing X^n from p is equal to the coefficient of X^i in p if i ≠ n, and is equal to 0 if i = n.


theorem MeasureTheory.set_integral_const :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {s : Set X} {μ : MeasureTheory.Measure X} [inst_3 : CompleteSpace E] (c : E),
      ∫ (x : X) in s, c ∂μ = (↑↑μ s).toReal • c :=
  by sorry

The theorem `MeasureTheory.set_integral_const` states that for any type `X` with a measurable space structure, any normed additively commutative group `E` which is also a real normed space, any set `s` of type `X`, any measure `μ` defined on `X`, and any element `c` of `E`, the integral of the constant function `c` over the set `s` with respect to the measure `μ` is equal to the measure of `s` (converted to real) scaled by `c`. This means, when you integrate a constant over a set, the result is the size (measure) of the set times the constant.

For any measurable space (X, Σ, μ), normed additively commutative group E over the reals, set s ∈ Σ, and constant c ∈ E, ∫s(x) dc = μ(s) * c.


theorem Finset.mem_shatterer :
    ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α},
      s ∈ Finset.shatterer 𝒜 ↔ Finset.Shatters 𝒜 s :=
  by sorry

In the context where `α` is a type with decidable equality, this theorem states that for any set `s` and any set family `𝒜` (both of type `Finset α`), `s` is in the set of sets shattered by `𝒜` if and only if `𝒜` shatters `s`. Here, a set family `𝒜` is said to shatter a set `s` if for every subset `t` of `s`, there exists a set `u` in `𝒜` such that the intersection of `s` and `u` equals `t`.

A set `s` is in the sets shattered by a decidably equal set family `𝒜` if and only if for every subset `t` of `s`, there exists `u` in `𝒜` such that `s ∩ u = t`.


theorem neg_vadd_eq_iff :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] {a : α} {x y : β},
      -a +ᵥ x = y ↔ x = a +ᵥ y :=
  by sorry

This theorem states that for any types 'α' and 'β', where 'α' is an additive group and 'β' is an additive action of 'α', for any element 'a' of type 'α' and any elements 'x' and 'y' of type 'β', the equation "-a +ᵥ x = y" is equivalent to "x = a +ᵥ y". In other words, the operation of adding the negation of 'a' to 'x' in the vector space is the same as the operation of adding 'a' to 'y' in the vector space.

For any additive group 'α' and additive action 'β' of 'α', for all elements 'a' in 'α' and 'x' and 'y' in 'β', the equations "-a ∘ x = y" and "x = a ∘ y" hold if and only if 'β' is an abelian group. (Here, '∘' denotes the additive action of 'α' on 'β' and the '-' sign denotes the additive inverse in 'α').


theorem List.get_set_eq :
    ∀ {α : Type u_1} (l : List α) (i : ℕ) (a : α) (h : i < List.length (List.set l i a)),
      List.get (List.set l i a) { val := i, isLt := h } = a :=
  by sorry

The theorem `List.get_set_eq` states that for any type `α`, any list `l` of type `α`, any natural number `i`, and any element `a` of type `α`, given the condition that `i` is less than the length of the list obtained from replacing the `i`-th element of `l` with `a`, retrieving the `i`-th element of this new list will yield `a`. In essence, this theorem asserts that setting an element at a particular index in a list and then getting the element at the same index returns the element we initially set.

For any type `α`, list `l` of length `n` over `α`, natural number `i` < `n`, and element `a` of `α`, if list `l'` is obtained from `l` by setting its `i`-th element to `a`, then `l'.nth i = a`.


theorem Matrix.updateRow_submatrix_equiv :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : DecidableEq l]
      [inst_1 : DecidableEq m] (A : Matrix m n α) (i : l) (r : o → α) (e : l ≃ m) (f : o ≃ n),
      Matrix.updateRow (Matrix.submatrix A ⇑e ⇑f) i r =
        Matrix.submatrix (Matrix.updateRow A (e i) fun j => r (f.symm j)) ⇑e ⇑f :=
  by sorry

This theorem states that for any types `l`, `m`, `n`, `o`, and `α` where `l` and `m` have decidable equality, given a matrix `A` indexed by `m` and `n` with entries in `α`, an index `i` of type `l`, a function `r` mapping `o` to `α`, and bijections `e` from `l` to `m` and `f` from `o` to `n`, updating the `i`th row of the submatrix of `A` obtained by applying `e` and `f` (via `Matrix.submatrix`) is equivalent to first updating the `(e i)`th row of `A` with `r` composed with the inverse of `f`, and then forming the submatrix with `e` and `f`.

For matrices A indexed by types m and n with decidable equality, updating the i-th row of the submatrix obtained by bijections e from l to m and f from o to n is equivalent to first updating the (ei)-th row with r composed with the inverse of f, and then forming the submatrix with e and f.


theorem MeasureTheory.VectorMeasure.add_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      [inst_2 : ContinuousAdd M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α), ↑(v + w) i = ↑v i + ↑w i :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.add_apply` states that for any type `α`, a measurable space `m` on `α`, a type `M` that is an additive commutative monoid and a topological space with continuous addition, and given two vector measures `v` and `w` on `α` with values in `M`, and a set `i` of `α`, the measure of the union of `v` and `w` applied to `i` is equal to the sum of the measure of `v` applied to `i` and the measure of `w` applied to `i`. This illustrates a fundamental property of measures, which is the additivity over disjoint sets.

For any measurable space, additive commutative monoid valued vector measures `v` and `w` on a measurable space `(α, m)`, the measure of their union is equal to the sum of their individual measures: `∫(i: α) m (v i + w i) = ∫(i: α) m v i + ∫(i: α) m w i`.


theorem Cardinal.pow_le : ∀ {κ μ : Cardinal.{u}}, Cardinal.aleph0 ≤ κ → μ < Cardinal.aleph0 → κ ^ μ ≤ κ := by sorry

The theorem `Cardinal.pow_le` states that for any two cardinal numbers `κ` and `μ` in `Type u`, if `κ` is greater than or equal to `ℵ₀` (the smallest infinite cardinal number) and `μ` is less than `ℵ₀`, then `κ` raised to the power of `μ` is less than or equal to `κ`. In other words, if `κ` is at least countably infinite and `μ` is finite, then the cardinality of the set of all functions from `μ` to `κ` is at most the cardinality of `κ`.

For any cardinal numbers `κ` greater than or equal to `ℵ₀` and finite `μ`, `κ^μ` is less than or equal to `κ`.


theorem Mathlib.Topology.MetricSpace.Thickening._auxLemma.13 : ∀ {α : Type u} (s : Set α), (∅ ⊆ s) = True := by sorry

This theorem, named as `Mathlib.Topology.MetricSpace.Thickening._auxLemma.13`, states that for any type `α` and any set `s` of type `α`, the empty set is always a subset of `s`. This fact is universally true, hence the output is `True`. In mathematical terms, we can express this as for all sets `s`, the relation `∅ ⊆ s` is always satisfied.


/-- A telescoping sum along `{0, ..., n - 1}` of an additive commutative group valued
function reduces to the difference of the last and first terms. -/
theorem Finset.sum_range_sub :
    ∀ {M : Type u_6} [inst : AddCommGroup M] (f : ℕ → M) (n : ℕ),
      (Finset.sum (Finset.range n) fun i => f (i + 1) - f i) = f n - f 0 :=
  by sorry

The theorem `Finset.sum_range_sub` states that for any function `f` from natural numbers to an additive commutative group `M`, and any natural number `n`, the sum over the range `{0, ..., n - 1}` of the difference `f (i + 1) - f i` equals the difference `f n - f 0`. In simpler terms, it asserts the "telescoping property" where most terms in the sum cancel each other out, leaving only the difference of the last term `f n` and the first term `f 0`.

For any additive commutative group M and natural number n, the sum of the differences between consecutive applications of a function f from natural numbers to M from i = 0 to i = n - 1 equals the difference between f(n) and f(0).


theorem BoxIntegral.Prepartition.iUnion_subset :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), BoxIntegral.Prepartition.iUnion π ⊆ ↑I :=
  by sorry

The theorem `BoxIntegral.Prepartition.iUnion_subset` states that, for any type ι and any box I of type `BoxIntegral.Box ι`, if we have a prepartition π of I, then the union of all boxes in this prepartition (which is denoted by `BoxIntegral.Prepartition.iUnion π`) is a subset of the box I. In other words, the part of I covered by the boxes of the prepartition π does not exceed I.

For any box I and prepartition π of I in Lean 4, `BoxIntegral.Prepartition.iUnion π` is a subset of I.


MeasurableSet.symmDiff

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

The theorem `MeasurableSet.symmDiff` states that for any type `α` equipped with a measurable space, and any two sets `s₁` and `s₂` of type `α`, if `s₁` and `s₂` are measurable sets, then the symmetric difference of `s₁` and `s₂` is also a measurable set. The symmetric difference of two sets `A` and `B` is defined as `(A \ B) ∪ (B \ A)`, where `\` denotes set difference and `∪` denotes the union of two sets.

If `α` is a type with a measurable structure and `s₁` and `s₂` are measurable subsets of `α`, then the symmetric difference `(s₁ \ s₂) ∪ (s₂ \ s₁)` is a measurable subset of `α`.


/-- Symmetric statement to `Set.image_image2_distrib_left`.  -/
theorem Set.image2_image_left_comm :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {s : Set α} {t : Set β}
      {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ},
      (∀ (a : α) (b : β), f (g a) b = g' (f' a b)) → Set.image2 f (g '' s) t = g' '' Set.image2 f' s t :=
  by sorry

This theorem, named `Set.image2_image_left_comm`, relates to sets and function images in Lean 4. Given two types `α` and `β`, and sets `s : Set α` and `t : Set β`, it asserts the equality of the image of a binary function `f : α' → β → γ` applied to the image of a function `g : α → α'` acting on set `s` and set `t`, and the image of a function `g' : δ → γ` applied to the image of a binary function `f' : α → β → δ` acting on sets `s` and `t`, provided that for all elements `a` in set `α` and `b` in set `β`, the function `f` applied to `g a` and `b` equals `g'` applied to `f' a b`. Mathematically, this can be written as: if `∀ (a : α) (b : β), f (g a) b = g' (f' a b)`, then `Set.image2 f (g '' s) t = g' '' Set.image2 f' s t`.

If for all `a` in `α` and `b` in `β`, `f (g a) b = g' (f' a b)`, then `Set.image2 f (g(s)) t = g' (Set.image2 f' s t)`. Here, `s` is a set of type `α`, `f : α' → β → γ`, `g : α → α'`, `f' : α → β → δ`, and `g' : δ → γ`.


CategoryTheory.Quotient.CompClosure.of

theorem CategoryTheory.Quotient.CompClosure.of :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b : C} (m₁ m₂ : a ⟶ b),
      r m₁ m₂ → CategoryTheory.Quotient.CompClosure r m₁ m₂ :=
  by sorry

This theorem states that for any category `C` and any relation `r` that assigns a relation to each hom-set in `C`, if `m₁` and `m₂` are two morphisms from object `a` to object `b` in `C` and `m₁` is related to `m₂` under this relation `r`, then `m₁` and `m₂` are also related under the quotient of this relation with respect to composition, which is called the `CompClosure` of `r`. In simpler words, the relation preserves the composition of morphisms in the category `C`.

If relation `r` on hom-sets of a category `C` is such that `r(f) r(g)` whenever `f: a -> b` and `g: b -> c` are morphisms with `f` related to `g`, then `r` is a relation of composition in `C`.


theorem RingHom.StableUnderComposition.respectsIso :
    ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
      RingHom.StableUnderComposition P →
        (∀ {R S : Type u} [inst : CommRing R] [inst_1 : CommRing S] (e : R ≃+* S), P (RingEquiv.toRingHom e)) →
          RingHom.RespectsIso P :=
  by sorry

The theorem `RingHom.StableUnderComposition.respectsIso` states that for any property `P` of ring homomorphisms, if `P` is stable under composition (i.e., the composition of two ring homomorphisms that satisfy `P` also satisfies `P`), and if `P` holds for any isomorphism (viewed as a ring homomorphism), then `P` respects isomorphisms. This means that if `P` holds for a ring homomorphism `f`, it will still hold when `f` is pre- or post-composed with an isomorphism.

If a property `P` of ring homomorphisms is stable under composition and holds for isomorphisms, then `P` respects isomorphisms.


theorem Set.injective_codRestrict :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α} (h : ∀ (x : ι), f x ∈ s),
      Function.Injective (Set.codRestrict f s h) ↔ Function.Injective f :=
  by sorry

The theorem `Set.injective_codRestrict` states that for any type `α` and `ι`, any function `f` from `ι` to `α`, and any set `s` of `α`, given that for all `x` in `ι`, `f(x)` is in `s`, the function `f` restricted to the codomain `s` is injective if and only if the original function `f` is injective. In other words, restricting the codomain of an injective function to a subset does not change its injective property.

If `f: ι → α` is an injective function and `s ⊆ α` is a set such that `∀ x ∈ ι, f x ∈ s`, then the restriction of `f` to `s`, denoted `f | s`, is also an injective function.


Primrec.unpair

theorem Primrec.unpair : Primrec Nat.unpair := by sorry

This theorem states that the unpairing function for natural numbers, `Nat.unpair`, is primitive recursive. In other words, `Nat.unpair` can be computed using a finite number of steps, where each step involves only basic arithmetic operations. The function `Nat.unpair` takes a natural number and returns a pair of natural numbers such that the input number can be represented as a combination of the pair in a certain way.

The `Nat.unpair` function, which takes a natural number and returns a pair of natural numbers representing its decomposition into a sum of two parts, is a primitive recursive function.


theorem Complex.arg_ofReal_of_neg : ∀ {x : ℝ}, x < 0 → Complex.arg ↑x = Real.pi := by sorry

This theorem provides a relationship between a negative real number and the argument of a complex number. Specifically, it states that for any real number `x` that is less than zero, the argument of the complex number formed by casting `x` to a complex number is equal to π (pi). In mathematical terms, if `x` is a real number with `x < 0`, then the argument of the complex number `x` equals π.

For any real number `x` with `x < 0`, the argument of the complex number `x + i*0` equals `π`. (Here, `i` is the imaginary unit, `i*0` is the zero complex number.)


theorem Finset.sup_union :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s₁ s₂ : Finset β} {f : β → α}
      [inst_2 : DecidableEq β], Finset.sup (s₁ ∪ s₂) f = Finset.sup s₁ f ⊔ Finset.sup s₂ f :=
  by sorry

This theorem, named `Finset.sup_union`, states that for any type `α` under a semilattice with a least element and any type `β` with decidable equality, given two finite sets `s₁` and `s₂` of type `β` and a function `f` from `β` to `α`, the supremum of the union set `s₁ ∪ s₂` under the function `f` is equal to the supremum of the set `s₁` under `f` joined with the supremum of the set `s₂` under `f`. In mathematical terms, for all `s₁, s₂` subsets of `β`, and for all `f : β → α`, we have `sup (s₁ ∪ s₂) f = sup s₁ f ⊔ sup s₂ f`.

For any semilattice with a least element and decidable equality type `β`, and given finite sets `s₁` and `s₂` and a function `f` from `β` to a semilattice with identity `α`, the supremum of `f` applied to the union of `s₁` and `s₂` equals the join of the supremum of `f` on `s₁` and the supremum of `f` on `s₂`.


theorem Submodule.map_smul'' :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (I : Ideal R)
      (N : Submodule R M) {M' : Type w} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
      Submodule.map f (I • N) = I • Submodule.map f N :=
  by sorry

The theorem `Submodule.map_smul''` states that for any commutative semiring `R`, additively commutative monoids `M` and `M'`, `R`-modules `M` and `M'`, an ideal `I` of `R`, a submodule `N` of `M`, and a linear map `f` from `M` to `M'`, the image of the scalars from `I` acting on `N` under map `f` is equal to the set of scalars from `I` acting on the image of `N` under `f`. In mathematical terms, it states that for linear transformations `f: M → M'`, we have `f(I • N) = I • f(N)`, where `•` denotes scalar multiplication in the modules.

For any commutative semiring R, additively commutative monoids M and M', R-modules M and M', ideal I of R, submodule N of M, and linear map f from M to M', we have f(I • N) = I • f(N), where • denotes scalar multiplication in the modules.


theorem Int.normalize_of_nonneg : ∀ {z : ℤ}, 0 ≤ z → normalize z = z := by sorry

This theorem states that for any integer `z` that is non-negative (i.e., greater than or equal to zero), normalizing `z` results in `z` itself. Here, the normalization is done using the `normalize` function, which chooses an element from each associate class by multiplying by the normalizing unit (`normUnit`).

For any non-negative integer `z`, normalizing `z` using Lean's `normalize` function returns `z`.


theorem Set.image_preimage_eq_range_inter :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {t : Set β}, f '' (f ⁻¹' t) = Set.range f ∩ t := by sorry

This theorem states that for any two types `α` and `β`, and any function `f` from `α` to `β`, the image of the preimage of a set `t` under function `f` is equal to the intersection of the range of function `f` and the set `t`. In mathematical terms, for a set `t` in `β` and a function `f: α → β`, the image of the inverse image of `t` under `f` is the same as the intersection of the range of `f` and `t`. This theorem essentially relates the concepts of function range, image, preimage, and set intersection in a specific way.

For any function `f: α → β` and set `t ∈ β`, the image of the preimage `f⁁⁻¹(t)` equals the intersection of the range `range(f)` and `t`. In symbols: `f⁁⁻¹(t) = {x : α | ∃ y : β. x ∈ f⁁⁻¹(y) ∧ y ∈ t} = {x : α | f(x) ∈ t}`.


IsSquare.map

theorem IsSquare.map :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MulOneClass α] [inst_1 : MulOneClass β]
      [inst_2 : FunLike F α β] [inst_3 : MonoidHomClass F α β] {m : α} (f : F), IsSquare m → IsSquare (f m) :=
  by sorry

This theorem, `IsSquare.map`, states that for any types `F`, `α`, and `β` where `α` and `β` are both `MulOneClass` (types with multiplication and a multiplicative identity), and `F` is a function-like structure from `α` to `β` and a monoid homomorphism, if an element `m` of type `α` is a square (that is, there exists an `r` such that `m = r * r`), then the image of this element under the function `f` of type `F` is also a square in `β`. In simple terms, it says that the image of a square under a monoid homomorphism is also a square.

If `f` is a monoid homomorphism from a type `α` (with multiplicative identity) to a type `β` (also with multiplicative identity), and `m` is a square in `α`, then `f(m)` is a square in `β`.


theorem Cardinal.gc_ord_card : GaloisConnection Cardinal.ord Ordinal.card := by sorry

The theorem `Cardinal.gc_ord_card` states that there exists a Galois connection between the function `Cardinal.ord` and `Ordinal.card`. In other words, for any cardinal number `c` and ordinal number `o`, the ordinal corresponding to `c` is less than or equal to `o` if and only if `c` is less than or equal to the cardinal of `o`. Here, `Cardinal.ord` assigns to a cardinal `c` the least ordinal whose cardinal is `c`, and `Ordinal.card` gives the cardinality of any type on which a relation with the given ordinal order type is defined.

The theorem `Cardinal.gc_ord_card` asserts that the functions `Cardinal.ord` and `Ordinal.card` define a Galois connection, meaning that for all cardinals `c` and ordinals `o`, `Cardinal.ord c ≤ o` if and only if `c ≤ Ordinal.card o`.


theorem Filter.eventually_lt_atBot :
    ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : NoMinOrder α] (a : α), ∀ᶠ (x : α) in Filter.atBot, x < a := by sorry

This theorem, `Filter.eventually_lt_atBot`, states that for any given type `α` which has a `Preorder` and `NoMinOrder` structure, and for any element `a` of that type, eventually (for all sufficiently small `x`), `x` will be less than `a` as `x` approaches negative infinity (`Filter.atBot`). In other words, as `x` gets arbitrarily close to negative infinity, all such `x` will be less than `a`. This holds true for all preordered types that do not have a minimum element.

For any type `α` with a `Preorder` and `NoMinOrder` structure, and any `a` in `α`, there exists a neighborhood of `Filter.atBot` such that `x < a` for all `x` in that neighborhood.


theorem Mathlib.Algebra.Group.Semiconj.Basic._auxLemma.3 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, named `Mathlib.Algebra.Group.Semiconj.Basic._auxLemma.3`, states that for any type `α` and any two objects `a` and `b` of this type, the proposition that `a` is equal to `b` is the same as the proposition that `b` is equal to `a`. In other words, it confirms the symmetry of equality: if `a` equals `b`, then `b` equals `a`, and vice versa.

The theorem asserts the reflexivity and symmetry of equality: for all types `α` and objects `a, b` of `α`, `a = b` is equivalent to `b = a`.


/-- We can clear the denominators of a `Finset`-indexed family of fractions.  -/
theorem IsLocalization.exist_integer_multiples :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {ι : Type u_4} (s : Finset ι) (f : ι → S),
      ∃ b, ∀ i ∈ s, IsLocalization.IsInteger R (↑b • f i) :=
  by sorry

This theorem states that given a commutative semiring `R`, a submonoid `M` of `R`, and another commutative semiring `S` that is a localization of `R` at `M`, for any index set `ι` and any finite set `s` of indices from `ι`, there is a function `f` from `ι` to `S`. The theorem then asserts the existence of an element `b` such that for every index `i` in the finite set `s`, the scalar multiple `b • f(i)` is an integer of `R` - which means that it lies in the image of the localization map from `R` to `S`. In other words, we can find a common multiple `b` such that all elements of the `Finset`-indexed family of fractions `f(i)` are integers when scaled by `b`.

Given a commutative semiring `R`, a submonoid `M` of `R`, and a localization `S` of `R` at `M`, for any index set `ι` and finite `ι`-indexed family `(f(i))_i` of elements in `S`, there exists an integer `b` in `R` such that `b • f(i)` is an element of `R` for all `i` in `ι`.


theorem sub_add_eq_sub_sub_swap : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b c : α), a - (b + c) = a - c - b :=
  by sorry

This theorem, named `sub_add_eq_sub_sub_swap`, states that for any type `α` that is a Subtraction Monoid, and given any three elements `a`, `b`, and `c` of that type, the result of subtracting the sum of `b` and `c` from `a` is the same as the result of subtracting `c` from `a` and then subtracting `b` from that result. In other words, it expresses a specific property of subtraction on a subtraction monoid: $a - (b + c) = a - c - b$.

For any subtraction monoid type `α`, the subtraction is commutative over addition, that is, `a - (b + c) = a - c - b`.


theorem Real.contDiff_cosh : ∀ {n : ℕ∞}, ContDiff ℝ n Real.cosh := by sorry

The theorem `Real.contDiff_cosh` states that for all `n`, which is a natural number or infinity (`ℕ∞`), the real hyperbolic cosine function (`Real.cosh`) is continuously differentiable of order `n`. In other words, the hyperbolic cosine function can be differentiated `n` times and the result is a continuous function.

For all natural numbers or infinity `n`, the `n`-th derivative of the real hyperbolic cosine function is a continuous function.


/-- Composing on the left by a uniformly continuous function preserves uniform convergence  -/
theorem UniformContinuous.comp_tendstoUniformly :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β}
      {p : Filter ι} [inst_1 : UniformSpace γ] {g : β → γ},
      UniformContinuous g → TendstoUniformly F f p → TendstoUniformly (fun i => g ∘ F i) (g ∘ f) p :=
  by sorry

The theorem `UniformContinuous.comp_tendstoUniformly` states that if we have a function `g` from `β` to `γ` that is uniformly continuous, and a sequence of functions `F` indexed by `ι` that converges uniformly to a function `f` with respect to a filter `p`, then composing `g` with each function in the sequence `F` (and with `f`) also results in a sequence of functions that converges uniformly to the composed function `(g ∘ f)` with respect to the same filter `p`. In other words, left composition with a uniformly continuous function preserves the property of uniform convergence.

If `g` is uniformly continuous and `F:` `ι` → `β` → `γ` converges uniformly to `f` with respect to filter `p`, then `g ∘ F:` `ι` → `β` → `γ` converges uniformly to `g ∘ f` with respect to `p`.


CovBy.grade

theorem CovBy.grade :
    ∀ (𝕆 : Type u_1) {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α] {a b : α},
      a ⋖ b → grade 𝕆 a ⋖ grade 𝕆 b :=
  by sorry

The theorem `CovBy.grade` states that for any types `𝕆` and `α` that have preorder structures, and any `a` and `b` of type `α`, if `a` is covered by `b` (denoted as `a ⋖ b`), then the grade of `a` is also covered by the grade of `b` (denoted as `grade 𝕆 a ⋖ grade 𝕆 b`). Here, the grade of an element in a graded order can be thought of as the number of elements you need to go down by to get to the bottom (`⊥`). This theorem therefore asserts a preservation of the covering relation under the grade function in this structure.

For any preordered types `𝕆` and `α`, if `a ⋖ b` holds in `α` then `grade 𝕆 a ⋖ grade 𝕆 b` holds in `𝕆`.


theorem Finset.mem_offDiag :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α × α},
      x ∈ Finset.offDiag s ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2 :=
  by sorry

This theorem states that for any type `α` with decidable equality and any finite set `s` of type `α`, a pair `x` of type `α` is in the off-diagonal of `s` if and only if both elements of the pair are in `s` and the elements of the pair are not equal. In mathematical terms, given a finite set `s` and a pair `(a, b)` of elements from `s`, `(a, b)` is in the off-diagonal set of `s` if and only if `a` and `b` are distinct elements of `s`.

For any finite set `s` and distinct elements `a` and `b` in `s` of type `α` with decidable equality, the pair `(a, b)` lies in the off-diagonal of `s`. (Or equivalently, the off-diagonal of `s` consists of all pairs of distinct elements in `s`. )


theorem isGLB_Ioc :
    ∀ {γ : Type w} [inst : SemilatticeSup γ] [inst_1 : DenselyOrdered γ] {a b : γ}, a < b → IsGLB (Set.Ioc a b) a := by
  sorry

The theorem `isGLB_Ioc` states that for any type `γ` which forms a semilattice with a supremum operation and is densely ordered, and for any two elements `a` and `b` of this type such that `a` is less than `b`, `a` is the greatest lower bound of the set formed by the half-open interval from `a` to `b` (where `a` is not included in the interval but `b` is).

For any semilattice `γ` with supremum and dense order, if `a` is a lower bound of the half-open interval `[a, b)` in `γ`, then `a` is the greatest lower bound of that interval.


theorem Complex.abs_abs : ∀ (z : ℂ), |Complex.abs z| = Complex.abs z := by sorry

The theorem `Complex.abs_abs` states that for all complex numbers `z`, the absolute value of the absolute value of `z` is equal to the absolute value of `z`. This theorem essentially asserts the non-negativity of the complex absolute value, since taking the absolute value of a real number always yields a non-negative number.


theorem partialSups_le_iff :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] {f : ℕ → α} {n : ℕ} {a : α}, (partialSups f) n ≤ a ↔ ∀ k ≤ n, f k ≤ a :=
  by sorry

The theorem `partialSups_le_iff` states that for any type `α` with a semilattice structure, any function `f` from natural numbers to `α`, any natural number `n`, and any element `a` of `α`, the `n`th partial supremum of `f` is less than or equal to `a` if and only if all the values `f(k)` for `k` less than or equal to `n` are also less than or equal to `a`. This essentially describes a property of the sequence of partial suprema: a bound on the `n`th partial supremum is equivalent to a bound on all the sequence elements up to `n`.

For any semilattice type `α`, function `f` from natural numbers to `α`, natural number `n`, and element `a` of `α`, the `n`-th partial supremum of `f` is less than or equal to `a` if and only if all `f(k)` for `k` less than or equal to `n` are less than or equal to `a`.


theorem MeasureTheory.quasiMeasurePreserving_inv :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : MeasurableMul₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableInv G]
      [inst_5 : MeasureTheory.Measure.IsMulLeftInvariant μ], MeasureTheory.Measure.QuasiMeasurePreserving Inv.inv μ μ :=
  by sorry

The theorem `MeasureTheory.quasiMeasurePreserving_inv` states that for any type `G` which has a measurable space structure, a group structure, a structure that allows for the measurement of multiplied elements, and an inverted element that can be measured, and for any measure `μ` on `G` which is sigma-finite and left-multiplication-invariant, the function `Inv.inv` which inverts an element of a group, is quasi-measure-preserving. In other words, the process of inverting elements in the group `G` doesn't significantly affect the measure `μ`.

Given a sigma-finite, left-multiplication-invariant measure `μ` on a measurable group `G` with a measurable inverted element, the measure-preserving involution function `Inv.inv` is quasi-measure-preserving.


theorem List.foldr_map :
    ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} (f : α₁ → α₂) (g : α₂ → β → β) (l : List α₁) (init : β),
      List.foldr g init (List.map f l) = List.foldr (fun x y => g (f x) y) init l :=
  by sorry

The theorem `List.foldr_map` states that for any types `α₁`, `α₂`, and `β`, any function `f` from `α₁` to `α₂`, any function `g` from `α₂` to `β → β`, any list `l` of elements of type `α₁`, and any initial value `init` of type `β`, the process of first mapping `f` over the list `l` and then folding the list from right to left using `g` and `init`, is the same as folding `l` from right to left using a function that applies `f` to the element and then `g` to the result, using `init`. In mathematical terms, if we denote the foldr operation as $\text{foldr}_{g, init}(l)$ and the map operation as $\text{map}_f(l)$, this theorem states that $\text{foldr}_{g, init}(\text{map}_f(l)) = \text{foldr}_{\lambda x, y. g(f(x), y), init}(l)$.

For any types `α₁`, `α₂`, and `β`, functions `f : α₁ → α₂` and `g : α₂ → β → β`, list `l : List α₁`, and initial value `init : β`, the theorem asserts that `foldr g (map f l) init` equals `foldr (λ x, λ y, g (f x) y) l init`.


theorem List.pairwise_map :
    ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → α_1} {R : α_1 → α_1 → Prop} {l : List α},
      List.Pairwise R (List.map f l) ↔ List.Pairwise (fun a b => R (f a) (f b)) l :=
  by sorry

The theorem `List.pairwise_map` states that for any type `α`, type `α_1`, a function `f` from `α` to `α_1`, a relation `R` on `α_1`, and a list `l` of type `α`, the property of being Pairwise `R` on the list obtained by mapping `f` over `l` (i.e., `List.map f l`) is equivalent to the property of the relation `R` when applied to function `f` on each pair of elements in `l` (i.e., `List.Pairwise (fun a b => R (f a) (f b)) l`). This means that if every pair of elements in the list obtained by applying `f` to `l` has the relationship `R`, then every pair of elements in the original list `l`, when transformed by function `f`, also has the relationship `R`, and vice versa.

For any type `α`, function `f` from `α` to `α_1`, relation `R` on `α_1`, and list `l` of type `α`, `List.map f l` has pairwise relationship `R` if and only if `l` has pairwise relationship `R` on each pair applied by `f`.


theorem sSup_le_iff :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a := by sorry

This theorem states that for any type `α` that forms a complete semilattice with respect to the supremum operation and for any set `s` of elements of type `α` and for any element `a` of type `α`, the supremum of set `s` is less than or equal to `a` if and only if every element `b` in set `s` is less than or equal to `a`. In other words, the largest element of `s` (its supremum) is not greater than `a` precisely when each element of `s` is not greater than `a`.

For any complete semilattice `α` and any set `s` of elements from `α` with supremum `sup s` and any element `a` in `α`, `sup s ≤ a` if and only if `x ≤ a` for all `x` in `s`.


theorem gcd_isUnit_iff :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsBezout R] [inst_3 : GCDMonoid R] (x y : R),
      IsUnit (gcd x y) ↔ IsCoprime x y :=
  by sorry

This theorem states that for any commutative ring `R`, which is also a domain and a Bezout domain (i.e., a domain in which the greatest common divisor of any two elements can be expressed as a linear combination of those elements), and which additionally has a notion of a GCD monoid (a structure in which every two elements have a greatest common divisor), the greatest common divisor (gcd) of any two elements `x` and `y` in `R` is a unit (an element with a two-sided inverse) if and only if `x` and `y` are coprime. In other words, `x` and `y` are coprime - meaning there exist elements `a` and `b` in `R` such that `a * x + b * y = 1` - if and only if their gcd has a two-sided inverse in `R`.

For a commutative domain `R` with a Bezout identity and GCD monoid, `x` and `y` in `R` are coprime if and only if the greatest common divisor of `x` and `y` is a unit in `R`.


theorem IsClosed.closedEmbedding_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed s → ClosedEmbedding Subtype.val := by sorry

This theorem states that for any type `X` with a topological space structure, and any set `s` of `X`, if `s` is a closed set (i.e., `IsClosed s`), then the function `Subtype.val` forms a closed embedding. The `Subtype.val` function takes a subtype (elements of the base type `X` that satisfy a certain predicate) and returns the underlying element in the base type. A closed embedding is a function that is both a homeomorphism onto its image (i.e., it preserves the topological structure) and a closed map (i.e., it sends closed sets to closed sets).

If `X` is a topological space and `s` is a closed subset of `X`, then the inclusion function from `s` to its image under `Subtype.val` is a closed embedding.


theorem bihimp_assoc :
    ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b c : α), bihimp (bihimp a b) c = bihimp a (bihimp b c) := by sorry

The theorem `bihimp_assoc` states that for all types `α` equipped with a Boolean algebra structure, and for all elements `a`, `b`, `c` of type `α`, the Heyting bi-implication operation `bihimp` is associative. That is, the result of first applying `bihimp` to `a` and `b`, and then applying `bihimp` to the result and `c`, is the same as the result of first applying `bihimp` to `b` and `c`, and then applying `bihimp` to `a` and the result. In mathematical terms, this can be written as $(a \leftrightarrow b) \leftrightarrow c = a \leftrightarrow (b \leftrightarrow c)$, where $\leftrightarrow$ denotes the Heyting bi-implication.

For all types `α` with a Boolean algebra structure and all elements `a, b, c` of type `α`, the associativity of Heyting bi-implication holds: `(a bihimp b) bihimp c = a bihimp (b bihimp c)`.


theorem Mathlib.Data.Int.Cast.Basic._auxLemma.1 :
    ∀ {R : Type u} [inst : AddGroupWithOne R] {m n : ℕ}, m ≤ n → ↑n - ↑m = ↑(n - m) := by sorry

This theorem states that for any type `R` which is an instance of the `AddGroupWithOne` type class, and any two natural numbers `m` and `n` where `m` is less than or equal to `n`, the difference of the cast of `n` and the cast of `m` in `R` is equal to the cast of the difference of `n` and `m` in `R`. In mathematical terms, it asserts that for `m ≤ n`, `(↑n - ↑m) = ↑(n - m)`, where the ↑ symbol denotes the casting operation.

For any type `R` an instance of `AddGroupWithOne` and natural numbers `m ≤ n`, `(↑n - ↑m) = ↑(n - m)`.


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

This theorem states that for any type `α` that is an additive commutative group and has a linear order and a covariant class, given four elements `a`, `b`, `c`, and `d` of type `α`, if the difference of `a` and `d` is less than the difference of `b` and `c`, then either `a` is less than `b` or `c` is less than `d`. This is a fundamental property that holds in any ordered group.

In an additive commutative group equipped with a linear order and a covariant class, if `a ≤ b + c` and `c ≤ d`, then `a ≤ b` or `b ≤ d`.


theorem MultilinearMap.map_sub :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommGroup (M₁ i)] [inst_2 : AddCommGroup M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι)
      (x y : M₁ i), f (Function.update m i (x - y)) = f (Function.update m i x) - f (Function.update m i y) :=
  by sorry

This theorem asserts that for any semiring `R`, any type `ι`, any `ι`-indexed family of types `M₁`, and any type `M₂`, given the addition commutative group structures on each `M₁ i` and `M₂`, and the module structures over `R` on each `M₁ i` and `M₂`, for any multilinear map `f : MultilinearMap R M₁ M₂`, any `ι`-indexed family of elements `m : (i : ι) → M₁ i`, any index `i : ι`, and any two elements `x, y : M₁ i`, if we replace the `i`-th component of `m` by `x - y`, the result of applying `f` to this new family is equal to the difference of the result of applying `f` to the family obtained by replacing the `i`-th component of `m` by `x`, and the result of applying `f` to the family obtained by replacing the `i`-th component of `m` by `y`. In mathematical terms, this theorem states the linearity of the multilinear map `f` with respect to subtraction in each component of the domain.

For any semiring `R`, multilinear map `f : MultilinearMap R (ι → M₁) M₂`, `ι`-indexed family `m : (i : ι) → M₁ i`, and `ι`-indexed family of elements `(x\_i : M₁ i)`, if `M₁ i` is an additive group for all `i : ι`, and `M₂` is an `R`-module, then `f (m.map (λ i, x\_i - x\_i.get i)) = f (m.map (λ i, x\_i)) - f (m.map (λ i, x\_i.get i))`.


theorem Set.preimage_sUnion :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set (Set β)}, f ⁻¹' ⋃₀ s = ⋃ t ∈ s, f ⁻¹' t := by sorry

The theorem `Set.preimage_sUnion` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and for any set `s` of sets of `β`, the preimage of the union of set `s` under the function `f` is equal to the union of the preimages of the elements in set `s` under the function `f`. In mathematical terms, it says that if `f` is a function from `α` to `β`, and `s` is a collection of subsets of `β`, then the preimage of the union of the sets in `s` is the union of the preimages of the sets in `s`. This is a formal statement of the property that preimages commute with union of sets.

For any function `f: α -> β` and set `s` of subsets of `β`, `f ^-1 (∪ s) = ∪ (f ^-1 [s])`.


theorem HomologicalComplex.homologyMap_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i : ι)
      [inst_2 : HomologicalComplex.HasHomology K i],
      HomologicalComplex.homologyMap (CategoryTheory.CategoryStruct.id K) i =
        CategoryTheory.CategoryStruct.id (HomologicalComplex.homology K i) :=
  by sorry

The theorem `HomologicalComplex.homologyMap_id` states that for any category `C` with zero morphisms, any complex shape `c`, and any homological complex `K` in `C` with shape `c`, and for any object `i` in `ι` where `K` has homology in degree `i`, the homology map applied to the identity morphism on `K` in degree `i` is the same as the identity morphism on the homology of `K` in degree `i`. Essentially, the homology map preserves the identity, which is a necessary characteristic for any functor in category theory.

For any homological complex `K` in a category `C` with zero morphisms and shape `c`, the homology map of the identity morphism on `K` in degree `i` equals the identity morphism on the homology of `K` in degree `i`, where `i` is an object such that `K` has homology in degree `i`.


PartialOrder.ext

theorem PartialOrder.ext : ∀ {α : Type u_3} {A B : PartialOrder α}, (∀ (x y : α), x ≤ y ↔ x ≤ y) → A = B := by sorry

This theorem states that for any given type `α`, if two `PartialOrder` structures `A` and `B` on `α` have the property that, for every pair of elements `x` and `y` in `α`, `x` is less than or equal to `y` in `A` if and only if `x` is less than or equal to `y` in `B`, then `A` and `B` must be the same PartialOrder structure. In other words, two partial order structures on the same type are equal if they induce the same ordering on pairs of elements.

If two PartialOrder structures on the same type induce the same relation between pairs of elements, then they are equal.


theorem contDiffOn_of_continuousOn_differentiableOn :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ∞},
      (∀ (m : ℕ), ↑m ≤ n → ContinuousOn (fun x => iteratedFDerivWithin 𝕜 m f s x) s) →
        (∀ (m : ℕ), ↑m < n → DifferentiableOn 𝕜 (fun x => iteratedFDerivWithin 𝕜 m f s x) s) → ContDiffOn 𝕜 n f s :=
  by sorry

This theorem, `contDiffOn_of_continuousOn_differentiableOn`, states that for any type `𝕜` which is a non-trivially normed field, types `E` and `F` which are normed additive commutative groups and also normed spaces over `𝕜`, a set `s` of type `E`, a function `f` from `E` to `F`, and an extended natural number `n`, if for every natural number `m`, the `m`-th iterated Fréchet derivative of `f` within the set `s` is continuous on `s` whenever `m` is less than or equal to `n`, and is also differentiable on `s` whenever `m` is strictly less than `n`, then the function `f` is continuously differentiable `n` times on the set `s`. This means the function `f` has well-defined and continuous derivatives up to the `n`-th order within the set `s`.

If a function between two normed spaces over a non-trivially normed field is continuously differentiable of order less than or equal to `n` and differentiable of order strictly less than `n` at each point in a set, then it is `n`-times continuously differentiable on that set.


theorem AddLECancellable.le_tsub_of_add_le_left :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, AddLECancellable a → a + b ≤ c → b ≤ c - a :=
  by sorry

The theorem `AddLECancellable.le_tsub_of_add_le_left` states that for any type `α` that has a preorder, is an additive commutative semigroup, and has a subtract operation with ordering compatibility, if an element `a` in this type is left-erasable (i.e., `AddLECancellable a`), then for all elements `b` and `c` in `α`, if `a + b` is less than or equal to `c`, then `b` is less than or equal to `c - a`. In other words, if adding `a` to `b` doesn't exceed `c`, then `b` doesn't exceed the result of subtracting `a` from `c`.

If `α` is a preorder, additive commutative semigroup with subtractive ordering compatibility and `a` is left-erasable in `α`, then for all `b` and `c` in `α`, if `a + b ≤ c`, then `b ≤ c - a`.


theorem Ordnode.balanceL_eq_balance' :
    ∀ {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α},
      Ordnode.Balanced l →
        Ordnode.Balanced r →
          Ordnode.Sized l →
            Ordnode.Sized r →
              ((∃ l', Ordnode.Raised l' (Ordnode.size l) ∧ Ordnode.BalancedSz l' (Ordnode.size r)) ∨
                  ∃ r', Ordnode.Raised (Ordnode.size r) r' ∧ Ordnode.BalancedSz (Ordnode.size l) r') →
                Ordnode.balanceL l x r = Ordnode.balance' l x r :=
  by sorry

The theorem `Ordnode.balanceL_eq_balance'` states that for any type `α`, and for any ordinal nodes `l` and `r` and an instance `x` of type `α`, if both `l` and `r` are balanced and their respective sizes as stated match their actual sizes, and there exists a size `l'` that is equal to or one-up from the size of `l` and a hypothetical tree with children of sizes `l'` and size of `r` is balanced, or there exists a size `r'` that is equal to or one-up from the size of `r` and a hypothetical tree with children of sizes size of `l` and `r'` is balanced, then the balance of `l`, `x`, and `r` is equivalent to the full balance operation on `l`, `x` and `r`. In other words, the simple balance operation is equivalent to the full balance operation under the given conditions.

Given ordinal nodes `l`, `r` of type `α` with matched sizes, and instances `x` of `α`, if both `l` and `r` are balanced and the hypothetical trees with children sizes `l' = size l + 1` and `r` or `l` and `r' = size r + 1` are balanced, then `balance l x r` equals the full balance operation on `l`, `x`, and `r`.


theorem MeasureTheory.Measure.Regular.exists_compact_not_null :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] {μ : MeasureTheory.Measure α}
      [inst_2 : MeasureTheory.Measure.Regular μ], (∃ K, IsCompact K ∧ ↑↑μ K ≠ 0) ↔ μ ≠ 0 :=
  by sorry

The theorem `MeasureTheory.Measure.Regular.exists_compact_not_null` states that for any type `α` equipped with a measurable space structure and a topological space structure, and for any measure `μ` on `α` that is regular, there exists a compact set `K` such that the measure of `K` is not zero if and only if the measure `μ` is not zero. In mathematical terms, this can be written as for all regular measures `μ`, `∃ K, IsCompact K ∧ μ(K) ≠ 0` if and only if `μ ≠ 0`.

A regular measure on a topological space is non-zero if and only if it assigns a non-zero measure to some compact set.


theorem Set.bounded_self : ∀ {α : Type u_1} {r : α → α → Prop} (a : α), Set.Bounded r {b | r b a} := by sorry

The theorem `Set.bounded_self` states that for any type `α`, any binary relation `r` on `α`, and any element `a` of type `α`, the set of all elements `b` of type `α` such that `r b a` holds, is a bounded set. In other words, the set `{b | r b a}` is bounded, where the boundedness of a set is defined with respect to the relation `r` such that there exists an element (in this case `a` itself) for which the relation `r` holds with every element in the set.

For any type `α` and binary relation `r` on `α`, the set `{b : α | r b a}` is bounded with respect to `r` with bound `a`.


theorem Ordinal.nmul_comm : ∀ (a b : Ordinal.{u_1}), Ordinal.nmul a b = Ordinal.nmul b a := by sorry

The theorem `Ordinal.nmul_comm` states that for any two ordinal numbers `a` and `b`, the operation of `nmul`, or natural multiplication, is commutative. In other words, multiplying `a` and `b` in either order will yield the same result: `Ordinal.nmul a b` is equal to `Ordinal.nmul b a`.

For all ordinal numbers `a` and `b`, `Ordinal.nmul a b` equals `Ordinal.nmul b a`.


theorem Polynomial.map_prod :
    ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S) {ι : Type u_1}
      (g : ι → Polynomial R) (s : Finset ι),
      Polynomial.map f (Finset.prod s fun i => g i) = Finset.prod s fun i => Polynomial.map f (g i) :=
  by sorry

The theorem `Polynomial.map_prod` states that for any commutative semiring `R` and `S`, and any ring homomorphism `f` from `R` to `S`, and any function `g` from a type `ι` to a Polynomial of `R`, and any finite set `s` of type `ι`, the map of the product of the polynomials `g i` for `i` in `s` under `f` is equal to the product of the maps of the polynomials `g i` under `f`. In other words, applying a ring homomorphism to the product of a set of polynomials is the same as taking the product of the individual polynomials each mapped by the ring homomorphism. This theorem is a statement of the property of ring homomorphisms preserving multiplication across the rings.

For any commutative semirings R and S, ring homomorphism f from R to S, function g from a type ι to polynomials over R, and finite set s of type ι, the map of the product of g i for i in s under f is equal to the product of the maps of g i under f.


theorem List.dedup_eq_self : ∀ {α : Type u} [inst : DecidableEq α] {l : List α}, List.dedup l = l ↔ List.Nodup l := by
  sorry

The theorem `List.dedup_eq_self` states that for any list `l` of elements of type `α`, which has a decidable equality, the list `l` is equal to its deduplicated version if and only if the list `l` has no duplicates. In other words, if all elements in the list `l` are unique (i.e., each element appears at most once), then removing duplicates from the list `l` does not change the list. Conversely, if removing duplicates from the list `l` leads to the same list, it implies that there were no duplicates in `l` to begin with.

For any list `l` of uniquely equal elements of type `α`, the deduplicated list `List.dedup l` equals `l`.


theorem List.zipWith_same :
    ∀ {α : Type u} {δ : Type u_3} (f : α → α → δ) (l : List α), List.zipWith f l l = List.map (fun a => f a a) l := by
  sorry

The theorem `List.zipWith_same` states that for any type `α` and a type `δ`, given any binary function `f` from `α` to `δ` and a list `l` of type `α`, applying the function `f` in a pairwise manner to the elements of the list `l` (essentially zipping the list `l` with itself using the function `f`) is equivalent to mapping the function `(fun a => f a a)` over the list `l`. In other words, zipping a list with itself using a function is the same as applying that function to each element of the list.

For any type `α` and function `f` from `α` to a type `δ`, zipping `α` list `l` with `l` using `f` is equivalent to applying `f` element-wise to `l`.


theorem Nat.ModEq.of_dvd : ∀ {m n a b : ℕ}, m ∣ n → a ≡ b [MOD n] → a ≡ b [MOD m] := by sorry

This theorem, `Nat.ModEq.of_dvd`, states that for any natural numbers `m`, `n`, `a`, and `b`, if `m` divides `n` and `a` is congruent to `b` modulo `n`, then `a` is also congruent to `b` modulo `m`. In mathematical terms, if $m|n$ and $a ≡ b$ (mod $n$), then $a ≡ b$ (mod $m$). This theorem expresses a property of modular congruence when the modulus is a divisor of another modulus.

If `m` divides `n` and `a` is congruent to `b` modulo `n`, then `a` is congruent to `b` modulo `m`. In other words, `m` being a divisor of `n` implies `a % n ≡ b % n` if and only if `a % m ≡ b % m`.


theorem unitInterval.mul_pos_mem_iff : ∀ {a t : ℝ}, 0 < a → (a * t ∈ unitInterval ↔ t ∈ Set.Icc 0 (1 / a)) := by sorry

The theorem `unitInterval.mul_pos_mem_iff` states that for all real numbers `a` and `t`, given `a` is greater than 0, the product `a * t` belongs to the unit interval (i.e., the closed interval from 0 to 1) if and only if `t` belongs to the closed interval from 0 to `1 / a`. This theorem provides a connection between multiplication by a positive real number and membership in certain real number intervals.

For a positive real number `a` and any real number `t`, `a * t` belongs to the unit interval if and only if `t` is in the closed interval [0, 1/a].


SModEq.refl

theorem SModEq.refl :
    ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
      (x : M), x ≡ x [SMOD U] :=
  by sorry

The theorem `SModEq.refl` states that for any given ring `R`, commutative additive group `M`, `M` being a `R`-module, and `U` being a submodule of `M`, every element `x` of `M` is congruent to itself modulo `U`. In other words, for any `x` in `M`, the statement `x ≡ x [SMOD U]` is always true. This is the reflexivity property in the context of an equivalence relation modulo a submodule.

For any `R`-module `M` and submodule `U`, every element `x` in `M` is congruent to `x` modulo `U`.


theorem Mathlib.NumberTheory.Divisors._auxLemma.1 :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α},
      (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) :=
  by sorry

This theorem states that for any type `α`, predicate `p` (a property of `α`), and finite set `s` of elements of `α`, and any element `a` of `α`, the membership of `a` in the filtered set of `s` (i.e., `Finset.filter p s`) is equivalent to `a` being a member of `s` and `a` satisfying the predicate `p`. In other words, an element belongs to the filtered set if and only if it belongs to the original set and meets the condition specified by the predicate.

For any type `α`, finite set `s` of `α`, predicate `p` on `α`, and `a` in `α`, `a` is in the filtered set `Finset.filter p s` if and only if `a` is in `s` and satisfies `p(a)`.


theorem AddSubgroup.index_comap :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {G' : Type u_2} [inst_1 : AddGroup G'] (f : G' →+ G),
      AddSubgroup.index (AddSubgroup.comap f H) = AddSubgroup.relindex H (AddMonoidHom.range f) :=
  by sorry

The theorem `AddSubgroup.index_comap` states that for any additive group `G`, any subgroup `H` of `G`, any other additive group `G'`, and any additive monoid homomorphism `f` from `G'` to `G`, the index of the preimage of `H` under `f` is equal to the relative index of `H` in the range of `f`. In other words, the size of the group obtained by applying `f` to `G'` and taking the set of elements that land in `H`, viewed as a multiple of the size of `H`, is the same as the size of the group obtained by considering all possible destinations of `f` inside `G`, viewed as a multiple of the size of `H` inside the group of such destinations.

The index of the preimage of a subgroup under an additive monoid homomorphism is equal to the relative index of the subgroup in the range of the homomorphism.


theorem Filter.Eventually.and_frequently :
    ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
      (∀ᶠ (x : α) in f, p x) → (∃ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x :=
  by sorry

This theorem states that for any type `α` and two properties `p` and `q` defined on `α`, along with a filter `f` on `α`, if it is true that for every value `x` from `α` that eventually appears in the filter `f`, `p x` holds, and there exists some value `x` from `α` that frequently appears in the filter `f` for which `q x` holds, then there exists some value `x` from `α` that frequently appears in the filter `f` for which both `p x` and `q x` hold.

If for all `x` in a type `α` that are eventually in a filter `f`, property `p(x)` holds, and there exists `x` in `α` with frequency in `f` such that `q(x)` holds, then there exists `x` in `α` with frequency in `f` having both `p(x)` and `q(x)`.


theorem Polynomial.coe_one : ∀ {R : Type u_2} [inst : CommSemiring R], ↑1 = 1 := by sorry

This theorem states that for any commutative semiring `R` of any type `u_2`, the coercion of the integer `1` to `R` is equal to the `1` in `R`. In other words, it asserts that casting `1` from an integer to any type in the commutative semiring results in the multiplicative identity of that semiring.

For any commutative semiring R of type u\_2, the coercion of the integer 1 to R equals the multiplicative identity in R.


MeasureTheory.HasFiniteIntegral.smul

theorem MeasureTheory.HasFiniteIntegral.smul :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {𝕜 : Type u_5} [inst_1 : NormedAddCommGroup 𝕜] [inst_2 : SMulZeroClass 𝕜 β] [inst_3 : BoundedSMul 𝕜 β] (c : 𝕜)
      {f : α → β}, MeasureTheory.HasFiniteIntegral f μ → MeasureTheory.HasFiniteIntegral (c • f) μ :=
  by sorry

The theorem `MeasureTheory.HasFiniteIntegral.smul` states that given a type `α` with a measurable space structure `m`, a measure `μ` on `α`, and a target type `β` equipped with a normed commutative additive group structure, if a function `f` from `α` to `β` has a finite integral (meaning the integral of the norm of `f a` is finite), then the function obtained by scaling `f` by a scalar `c` from another normed additive commutative group `𝕜` (which also has a zero product structure and a bounded scalar multiplication with `β`) also has a finite integral. In mathematical terms, if `∫⁻ a, ‖f(a)‖ ∂μ < ∞`, then `∫⁻ a, ‖c * f(a)‖ ∂μ < ∞`.

If `f: α → β` is a measurable function with finite integral `∫⁻ a, ‖f(a)‖ dμ < ∞` over a measure space `(α, Σ, m, μ)`, then the scaled function `c * f` also has a finite integral `∫⁻ a, ‖c * f(a)‖ dμ < ∞`, for any scalar `c` in a normed additive commutative group `𝕜` with bounded scalar multiplication on `β`.


theorem multiplicity.multiplicity_eq_zero :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α},
      multiplicity a b = 0 ↔ ¬a ∣ b :=
  by sorry

The theorem named `multiplicity.multiplicity_eq_zero` states that for any type `α` which has a monoid structure and a decidable relation that determines divisibility, given any two elements `a` and `b` of the type `α`, the multiplicity of `a` in `b` is zero if and only if `a` does not divide `b`. In other words, in the context of numbers, the largest natural number `n` such that `a` to the power of `n` divides `b` is zero if and only if `a` is not a factor of `b`.

For any type `α` with a monoid structure and a decidable divisibility relation, the multiplicity of `a` in `b` is zero if and only if `a` does not divide `b`.


/-- The obvious triangle induced by `QuotientMap.lift` commutes:
```
     g
  X --→ Z
  |   ↗
f |  / hf.lift g h
  v /
  Y
```
 -/
theorem QuotientMap.lift_comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : C(X, Y)} (hf : QuotientMap ⇑f) (g : C(X, Z))
      (h : Function.FactorsThrough ⇑g ⇑f), ContinuousMap.comp (QuotientMap.lift hf g h) f = g :=
  by sorry

The theorem `QuotientMap.lift_comp` states that for any three topological spaces `X`, `Y`, and `Z`, a continuous map `f` from `X` to `Y`, and another continuous map `g` from `X` to `Z`, if `f` is a quotient map and `g` factors through `f`, then the composition of the continuous map derived from "lifting" `g` along `f` and `f` itself is equal to `g`. This property can be visualized as a commutative triangle where the path from `X` to `Z` via `Y` using `f` and the lifted map is equivalent to the direct path from `X` to `Z` using `g`.

If `f: X → Y` is a quotient map, `g: X → Z` is continuous and factors through `f`, then the lifted composition `g' ∘ f` equals `g`, where `g': Y → Z` is the unique continuous map such that `g' ∘ f = g`.


theorem IsometryEquiv.preimage_ball :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : β)
      (r : ℝ), ⇑h ⁻¹' Metric.ball x r = Metric.ball ((IsometryEquiv.symm h) x) r :=
  by sorry

The theorem `IsometryEquiv.preimage_ball` states that for any isometric isomorphism `h` between two pseudo metric spaces `α` and `β`, any point `x` in `β`, and any real number `r`, the pre-image under `h` of the open ball of radius `r` centered at `x` is equal to the open ball of radius `r` centered at the point in `α` that corresponds to `x` under the inverse of `h`. In other words, an isometric isomorphism preserves the concept of open balls under pre-image mapping.

For any isometric isomorphism between pseudo metric spaces and any point and radius in the target space, the preimage under the isomorphism of the open ball centered at that point is the open ball centered at the preimage point in the source space.


theorem HomologicalComplex.mkHomToSingle_f :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] {c : ComplexShape ι}
      {K : HomologicalComplex V c} {j : ι} {A : V} (φ : K.X j ⟶ A)
      (hφ : ∀ (i : ι), c.Rel i j → CategoryTheory.CategoryStruct.comp (K.d i j) φ = 0),
      (HomologicalComplex.mkHomToSingle φ hφ).f j =
        CategoryTheory.CategoryStruct.comp φ (HomologicalComplex.singleObjXSelf c j A).inv :=
  by sorry

This theorem states that for any type `V` given a category structure, having zero morphisms and zero object, a type `ι` with decidable equality, a complex shape `c` over `ι`, a homological complex `K` over `V` and `c`, any element `j` of type `ι`, and any object `A` of `V`, if we have a morphism `φ` from `K.X j` to `A` such that the composition of `K.d i j` and `φ` is zero for all `i` where `c.Rel i j` holds, then the application of function `f` at `j` on `HomologicalComplex.mkHomToSingle φ hφ` is equivalent to the composition of `φ` and the inverse morphism on `HomologicalComplex.singleObjXSelf c j A`. This theorem essentially describes a property of constructing morphisms in a homological complex in the context of category theory.

Given a homological complex over a category with zero morphisms and objects, a complex shape, type `ι` with decidable equality, an element `j` of `ι`, and an object `A`, if there exists a morphism `φ` from the complex at `j` to `A` such that the composition of `φ` with each boundary morphism `K.d i j` is zero whenever `c.Rel i j` holds, then `f(HomologicalComplex.mkHomToSingle φ hφ)` is equivalent to the composition of `φ` and the inverse morphism on `HomologicalComplex.singleObjXSelf c j A`.


SimpleGraph.IsUniform.symm

theorem SimpleGraph.IsUniform.symm :
    ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : LinearOrderedField 𝕜] {G : SimpleGraph α} [inst_1 : DecidableRel G.Adj]
      {ε : 𝕜}, Symmetric (SimpleGraph.IsUniform G ε) :=
  by sorry

The theorem `SimpleGraph.IsUniform.symm` asserts that for any type `α`, any linearly ordered field `𝕜`, any simple graph `G` of type `α`, any decidable relationship `G.Adj` on the graph, and any element `ε` of the field `𝕜`, the `SimpleGraph.IsUniform` relation of graph `G` with respect to `ε` is symmetric. In other words, if for any two vertices in the graph `G`, the `IsUniform` relation holds with respect to `ε`, then the same relation holds with the vertices switched, meaning that the relation doesn't depend on the order of the vertices.

For any simple graph `G` with a decidable relation `Adj` over a linearly ordered field `𝕜` and any element `ε` in `𝕜`, if `G` is uniform with respect to `ε`, then it is symmetric with respect to `ε`.


theorem HomogeneousLocalization.add_val :
    ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : AddCommMonoid ι] [inst_1 : DecidableEq ι]
      [inst_2 : CommRing R] [inst_3 : CommRing A] [inst_4 : Algebra R A] {𝒜 : ι → Submodule R A}
      [inst_5 : GradedAlgebra 𝒜] {x : Submonoid A} (y1 y2 : HomogeneousLocalization 𝒜 x),
      HomogeneousLocalization.val (y1 + y2) = HomogeneousLocalization.val y1 + HomogeneousLocalization.val y2 :=
  by sorry

The theorem `HomogeneousLocalization.add_val` states that for any type `ι` which is an additive commutative monoid, a type `R` which is a commutative ring, and a type `A` which is also a commutative ring with an algebra over `R`, given a grading function `𝒜` from `ι` to submodules of `A`, a `GradedAlgebra` instance for `𝒜`, and a submonoid `x` of `A`, the operation `HomogeneousLocalization.val` is additive. In other words, for any two elements `y1` and `y2` of the homogeneous localization of `A` with respect to `𝒜` and `x`, the value of `HomogeneousLocalization.val` applied to the sum of `y1` and `y2` is equal to the sum of the values of `HomogeneousLocalization.val` applied to `y1` and `y2` individually. This essentially asserts that the `HomogeneousLocalization.val` function respects the addition operation of the ring.

For any commutative ring `R`, additive commutative monoid `ι`, commutative ring `A` with an algebra structure over `R`, grading function `𝒜` from `ι` to submodules of `A`, and submonoid `x` of `A`, the `HomogeneousLocalization.val` function is additive on the homogeneous localization of `A` with respect to `𝒜` and `x`.


theorem Int.sub_one_lt_floor :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), a - 1 < ↑⌊a⌋ := by sorry

This theorem states that for any type `α` which is a linearly ordered ring and has the structure of a floor ring, the result of subtracting 1 from any element `a` of type `α` is strictly less than the floor of `a`. In mathematical terms, for any real number `a`, we have `a - 1 < ⌊a⌋`, where `⌊a⌋` denotes the greatest integer less than or equal to `a` (the floor function).

For any linearly ordered ring `α` with a floor structure, the floor function applied to an element `a` is strictly less than `a - 1`. (In symbols: `⌊a⌋ < a - 1`).


theorem Order.Ioi_pred_of_not_isMin :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α},
      ¬IsMin a → Set.Ioi (Order.pred a) = Set.Ici a :=
  by sorry

The theorem `Order.Ioi_pred_of_not_isMin` states that for any type `α` that has a preorder and a predecessor order, and for any element `a` of that type, if `a` is not a minimal element, then the interval of all elements strictly greater than the predecessor of `a` (`Set.Ioi (Order.pred a)`) is equal to the interval of all elements greater than or equal to `a` (`Set.Ici a`). In other words, if `a` is not the smallest element in the set, then the set of all elements larger than what comes just before `a` is the same as the set of all elements that are larger or equal to `a`.

For any type `α` with a preorder and a predecessor order, if `a` is not the least element, then `Set.Ioi (Order.pred a) = Set.Ici a`.


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

This theorem states that for any given type `β` with an additive commutative monoid structure, and any given function `f` that maps from natural numbers to `β`, the sum of the function values over the range less than 1 (i.e., the set of natural numbers less than 1) is equal to the function value at 0. In mathematical terms, it asserts that the sum of `f(k)` as `k` ranges over the natural numbers less than 1 equals `f(0)`.

For any additive commutative monoid type `β` and function `f` from natural numbers to `β`, the sum of `f` over the natural numbers less than 1 equals `f` applied to 0.


theorem CategoryTheory.Linear.units_smul_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type w}
      [inst_2 : Semiring R] [inst_3 : CategoryTheory.Linear R C] {X Y Z : C} (r : Rˣ) (f : X ⟶ Y) (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (r • f) g = r • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

The theorem `CategoryTheory.Linear.units_smul_comp` states that for any category `C` which is also preadditive, any semiring `R`, and any linear map between `R` and `C`, along with objects `X, Y, Z` of the category `C`, any unit `r` of `R` and morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the composition of the scaled morphism `r • f` with `g` is the same as the morphism obtained by scaling the composition of `f` and `g` by `r`. In mathematical terms, it asserts that `(r • f) ∘ g = r • (f ∘ g)`.

For any preadditive category `C`, semiring `R`, linear map `f: R ⊓ C -> C`, objects `X, Y, Z` of `C`, unit `r` of `R`, and morphisms `f: X -> Y` and `g: Y -> Z` in `C`, `(r • f) ∘ g = r • (f ∘ g)`.


theorem MvPolynomial.mem_supported :
    ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : Set σ},
      p ∈ MvPolynomial.supported R s ↔ ↑(MvPolynomial.vars p) ⊆ s :=
  by sorry

This theorem states that for any commutative semiring `R`, any set `s` of type `σ`, and any multivariate polynomial `p` with variables from `σ` and coefficients from `R`, the polynomial `p` is supported by `s` if and only if the set of variables appearing in `p` (denoted by `MvPolynomial.vars p`) is a subset of `s`. In other words, a polynomial is considered "supported" by a set of variables if all the variables that appear in the polynomial belong to that set.

For any commutative semiring R, set s, and multivariate polynomial p over R with variables from s, p is supported by s if and only if the variables of p are contained in s.


SetTheory.PGame.Subsequent.trans

theorem SetTheory.PGame.Subsequent.trans :
    ∀ {x y z : SetTheory.PGame},
      SetTheory.PGame.Subsequent x y → SetTheory.PGame.Subsequent y z → SetTheory.PGame.Subsequent x z :=
  by sorry

The theorem `SetTheory.PGame.Subsequent.trans` states that for any three games `x`, `y`, and `z` in the context of set theory games (`SetTheory.PGame`), if game `x` can be obtained by playing some nonempty sequence of moves from game `y` (which is expressed as `SetTheory.PGame.Subsequent x y`) and game `y` can be similarly obtained from game `z` (`SetTheory.PGame.Subsequent y z`), then game `x` can also be obtained by playing some nonempty sequence of moves from game `z` (`SetTheory.PGame.Subsequent x z`). This is a statement of transitivity in the context of obtaining one game from another through a sequence of moves.

If games `x`, `y`, and `z` in set theory have the property that `x` can be obtained from `y` and `y` can be obtained from `z`, then `x` can be obtained from `z`. (Transitivity of game subsequence relation in set theory)


theorem IntermediateField.eq_adjoin_of_eq_algebra_adjoin :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E)
      (K : IntermediateField F E), K.toSubalgebra = Algebra.adjoin F S → K = IntermediateField.adjoin F S :=
  by sorry

This theorem states that for any field `F`, type `E` which is also a field and an algebra over `F`, and a set `S` of type `E`, if the subalgebra of an intermediate field `K` is equal to the subalgebra obtained by adjoining `S` to `F`, then `K` itself must be equal to the intermediate field obtained by adjoining `S` to `F`. In other words, if the algebraic structure of `K` is the same as the algebraic structure generated by `F` and `S`, then `K` and the field generated by `F` and `S` are the same.

If `F` is a field, `E` is a field and an algebra over `F`, `S` is a set of type `E`, and the subalgebras of an intermediate field `K` generated by `F` and by `F ∪ S` are equal, then `K` is equal to the field generated by `F` and `S`.


theorem BoxIntegral.Prepartition.injective_boxes :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι}, Function.Injective BoxIntegral.Prepartition.boxes := by sorry

This theorem states that for any type `ι` and for any `BoxIntegral.Box` of that type `ι`, the `boxes` function of `BoxIntegral.Prepartition` is injective. This means that if we have two different prepartitions of the box `I`, the sets of boxes that they partition `I` into are also different. In other words, if the `boxes` function gives the same output for two prepartitions, then those prepartitions must have been the same to begin with. This is a property of the `boxes` function, which retrieves the set of boxes from a prepartition.

For any type `ι` and `BoxIntegral.Box` of that type, the `boxes` function of `BoxIntegral.Prepartition` is an injection.


theorem List.isCycle_formPerm :
    ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α},
      List.Nodup l → 2 ≤ List.length l → Equiv.Perm.IsCycle (List.formPerm l) :=
  by sorry

This theorem states that for any list `l` of a type `α` (where `α` has decidable equality), if `l` has no duplicate elements (i.e., `List.Nodup l` is true) and the length of `l` is two or more (i.e., `2 ≤ List.length l`), then the permutation formed by permuting each element in `l` to the next one (i.e., `List.formPerm l`) is a cycle. In other words, the permutation is non-identity and any two non-fixed points in it are related by repeated application of the permutation.

Given a list `l` of length greater than or equal to 2 of type `α` with decidable equality and no duplicate elements, its permutation forms a cycle.


theorem algebraMap_mem :
    ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : SetLike S A] [inst_4 : OneMemClass S A] [inst_5 : SMulMemClass S R A] (s : S) (r : R),
      (algebraMap R A) r ∈ s :=
  by sorry

This theorem, `algebraMap_mem`, asserts that for any given types `S`, `R`, and `A`, with `R` being a commutative semiring, `A` being a semiring, and `A` having an algebraic structure over `R`, if `S` is a set-like structure in `A` that contains the multiplicative identity and respects scalar multiplication from `R` to `A`, then for any element `s` of `S` and any element `r` of `R`, the result of applying the algebra map from `R` to `A` to `r` is an element of `S`. In simpler terms, it states that the algebra map from a commutative semiring to a semiring always maps elements into a set that is compatible with the algebraic structure.

Given a commutative semiring `R`, a semiring `A` with an algebra structure over `R`, and a set-like `S` in `A` containing the multiplicative identity and respecting scalar multiplication, for all `s in S` and `r in R`, `(algMap R A r) in S`.


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

This theorem, `le_sup_iff`, states that for all types `α` that have a linear order, and for all elements `a`, `b`, and `c` of this type, `a` is less than or equal to the supremum of `b` and `c` if and only if `a` is less than or equal to `b` or `a` is less than or equal to `c`. In other words, an element is less than or equal to the maximum of two other elements if and only if it is less than or equal to at least one of those two elements.

For all types with a linear order and elements `a`, `b`, `c`, `a ≤ sup from b c` if and only if `a ≤ b` or `a ≤ c`.


theorem Equiv.countable_iff : ∀ {α : Sort u} {β : Sort v}, α ≃ β → (Countable α ↔ Countable β) := by sorry

This theorem states that for any two types `α` and `β`, if `α` is equivalent to `β` (denoted as `α ≃ β`), then `α` is countable if and only if `β` is countable. In other words, the countability of `α` and `β` is preserved under their equivalence. The countability of a type is a property that indicates whether the elements of the type can be put in one-to-one correspondence with the set of natural numbers.

If two types `α` and `β` are equivalent (`α ≃ β`), then they have the same countability property.


theorem ringChar.eq_iff : ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ}, ringChar R = p ↔ CharP R p := by sorry

This theorem states that for any type `R` which has the structure of a `NonAssocSemiring`, and for any natural number `p`, the unique characteristic of the semiring `R` is equal to `p` if and only if `R` has characteristic `p`. In other words, the ring characteristic function `ringChar R` equals `p` if and only if `CharP R p` holds, where `CharP R p` is a predicate that asserts `R` has characteristic `p`. This establishes a direct correspondence between the property of a semiring having a certain characteristic and the value of the `ringChar` function.

For any semiring R with characteristic p as a NonAssocSemiring, the unique characteristic of R equals p if and only if the predicate CharP (R p) holds.


theorem Mathlib.Algebra.GCDMonoid.Finset._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b := by
  sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, a value `b` of type `β`, and a multiset `s` of type `α`, the value `b` is in the multiset obtained by mapping the function `f` over the multiset `s` if and only if there exists a value `a` in the multiset `s` such that `f(a)` equals `b`. This theorem is a characterization of the membership of an element in the multiset obtained by a function mapping.

For any functions $f: \alpha \rightarrow \beta$, values $b \in \beta$, and multisets $s$ of type $\alpha$, $b \in \text{image}(f)(s) \iff \exists a \in s. f(a) = b$.