theorem contDiffWithinAt_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {x : E} {n : ℕ∞} {c : F}, ContDiffWithinAt 𝕜 n (fun x => c) s x :=
  by sorry

The theorem `contDiffWithinAt_const` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space over `𝕜` and `E`, another normed additive commutative group `F`, another normed space over `𝕜` and `F`, any set `s` of elements of type `E`, any element `x` of type `E`, any extended natural number `n`, and any element `c` of type `F`, the function that always returns `c` is continuously differentiable `n` times within the set `s` at the point `x`. In mathematical terms, it states that a constant function is continuously differentiable any number of times.

A constant function is continuously differentiable of any order on any open set. (Note: In the context of the theorem description, "any open set" refers to the set `s` in the theorem statement.)


theorem MvPolynomial.as_sum :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R),
      p = Finset.sum (MvPolynomial.support p) fun v => (MvPolynomial.monomial v) (MvPolynomial.coeff v p) :=
  by sorry

This theorem states that for any multivariate polynomial `p` over a commutative semiring `R` with `σ` as the index set of the variables, `p` can be expressed as a sum over its support. The support of `p` is the set of all `σ →₀ ℕ` (maps from `σ` to non-negative integers) for which the corresponding monomial in `p` has a non-zero coefficient. For each element `v` in the support, the `v`-th monomial of `p` (given by `MvPolynomial.monomial v`) is multiplied by its corresponding coefficient in `p` (given by `MvPolynomial.coeff v p`). The sum of these products is equal to the original polynomial `p`. This essentially says that any multivariate polynomial can be represented as a sum of its non-zero monomials.

A multivariate polynomial over a commutative semiring can be expressed as the sum of its monomials with non-zero coefficients.


Ideal.IsRadical.radical

/-- **Alias** of the reverse direction of `Ideal.radical_eq_iff`.

---

An ideal is radical iff it is equal to its radical.  -/
theorem Ideal.IsRadical.radical :
    ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R}, Ideal.IsRadical I → Ideal.radical I = I := by sorry

This theorem, often referred to as the **Alias** of the reverse direction of `Ideal.radical_eq_iff`, states that in the context of a commutative semiring `R` and an ideal `I` of `R`, an ideal is radical if and only if it is equal to its own radical. Specifically, given any ideal `I` in a commutative semiring `R`, if `I` is a radical ideal, then the radical of `I` is `I` itself. In other words, every element in the radical ideal can be expressed as some power of an element in `I`.

In a commutative semiring, an ideal is radical if and only if it equals its own radical, i.e., every element in the radical is a power of some element in the ideal.


theorem Rat.num_nonneg : ∀ {a : ℚ}, 0 ≤ a.num ↔ 0 ≤ a := by sorry

This theorem states that for any rational number 'a', the numerator of 'a' (a.num) is non-negative (greater than or equal to zero) if and only if 'a' itself is non-negative. In other words, it establishes that the sign of a rational number is determined by the sign of its numerator.

For any rational number 'a', the numerator of 'a' is non-negative if and only if 'a' itself is non-negative. (Equivalently, the rational number 'a' has a non-negative numerator if and only if 'a' is non-negative.)


HasSum.sigma

theorem HasSum.sigma :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : ContinuousAdd α]
      [inst_3 : RegularSpace α] {γ : β → Type u_5} {f : (b : β) × γ b → α} {g : β → α} {a : α},
      HasSum f a → (∀ (b : β), HasSum (fun c => f { fst := b, snd := c }) (g b)) → HasSum g a :=
  by sorry

This theorem states that for any types `α`, `β`, and a type function `γ` on `β`, given a function `f` mapping from a pair of `β` and `γ b` to `α`, a function `g` mapping from `β` to `α`, and a value `a` of type `α`, if `f` has a sum of `a` and for all values of `β`, the function `f` with fixed `β` and varying `γ b` has a sum of `g b`, then `g` has a sum of `a`.

Here, `HasSum f a` means that the series formed by `f` is summable and its sum is `a`. The prerequisites such as `AddCommMonoid α`, `TopologicalSpace α`, `ContinuousAdd α`, and `RegularSpace α` are necessary mathematical structures and conditions to ensure that the notion of summation is well-defined and continuous in the context of the topological space `α`.

If for any type `β` and a type function `γ` on `β`, given a function `f` from the product of `β` and `γ b` to `α` such that for all `β` and `γ b`, `HasSum (λ x := f x (γ b)) (g b)`, and there exists an element `a` of type `α` such that `HasSum f a`, then `HasSum g a`.


theorem AddMonoid.exponent_dvd_of_forall_nsmul_eq_zero :
    ∀ {G : Type u} [inst : AddMonoid G] {n : ℕ}, (∀ (g : G), n • g = 0) → AddMonoid.exponent G ∣ n := by sorry

The theorem `AddMonoid.exponent_dvd_of_forall_nsmul_eq_zero` states that for any type `G` that has an `AddMonoid` instance, along with any natural number `n`, if for every element `g` of `G` the `n`-fold addition of `g` (denoted as `n • g`) results in the additive identity (0), then the exponent of the additive monoid `G` divides `n`. In simpler terms, if adding any element of the group to itself `n` times results in zero, then the smallest positive number with this property (the exponent of the group) is a divisor of `n`.

If for every element in an additive monoid `G`, the `n`-fold addition of that element equals the additive identity, then the exponent of `G` divides `n`.


theorem Function.RightInverse.comp_eq_id :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.RightInverse f g → g ∘ f = id := by sorry

The theorem `Function.RightInverse.comp_eq_id` states that for any types `α` and `β`, and for any functions `f` from `α` to `β` and `g` from `β` to `α`, if `f` is a function such that `g` is a right inverse to `f` (that is, `f ∘ g = id`, where `id` is the identity function), then the composition of `g` with `f` is equal to the identity function. In other words, if you first apply `f` and then `g`, you end up where you started, which is what it means for `g` to be a right inverse of `f`.

If `f: α → β` has a right inverse `g: β → α` (i.e., `f ∘ g = id`), then `g ∘ f = id`.


theorem Mathlib.LinearAlgebra.QuadraticForm.Basic._auxLemma.7 :
    ∀ {R : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} {x y : M}, QuadraticForm.IsOrtho Q x y = (Q (x + y) = Q x + Q y) :=
  by sorry

The theorem `Mathlib.LinearAlgebra.QuadraticForm.Basic._auxLemma.7` states that for any commutative semiring `R`, an additive commutative monoid `M`, and a module `M` over `R`, given a quadratic form `Q` on `M` and any two elements `x` and `y` of `M`, the proposition that `x` and `y` are orthogonal with respect to the quadratic form `Q` (denoted as `QuadraticForm.IsOrtho Q x y`) is equivalent to the equality `Q (x + y) = Q x + Q y`. In other words, `x` and `y` are orthogonal under the quadratic form `Q` if and only if the value of the form at the sum of `x` and `y` equals the sum of the value of the form at `x` and at `y`.

For any commutative semiring `R`, additive commutative monoid `M`, and quadratic form `Q` on `M` over `R`, elements `x` and `y` of `M` are orthogonal with respect to `Q` if and only if `Q(x + y) = Q(x) + Q(y)`.


theorem continuousWithinAt_const :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {b : β} {s : Set α}
      {x : α}, ContinuousWithinAt (fun x => b) s x :=
  by sorry

This theorem, `continuousWithinAt_const`, states that for any topological spaces `α` and `β`, for any element `b` of `β`, for any subset `s` of `α`, and for any point `x` in `α`, the function that maps every element of `α` to the constant `b` is continuous at the point `x` within the subset `s`. In other words, no matter how `x` changes within the subset `s`, the output of the function remains the same (`b`), thus it is continuous.

For any topological spaces α and β, and any constant function f : α → β with image b, the function is continuous at every x in α with respect to the subset s if and only if x ∈ s implies the neighborhoods of x contain only elements mapping to b.


theorem List.Perm.countP_eq :
    ∀ {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α}, List.Perm l₁ l₂ → List.countP p l₁ = List.countP p l₂ := by sorry

This theorem states that for any type `α`, any predicate function `p` from `α` to `Bool`, and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then the number of elements in `l₁` that satisfy the predicate `p` (`List.countP p l₁`) is equal to the number of elements in `l₂` that satisfy the same predicate (`List.countP p l₂`). In other words, rearranging the elements of a list doesn't change the number of elements that satisfy a given predicate.

For any type `α`, predicate function `p` from `α` to `Bool`, and lists `l₁` and `l₂` of type `α` that are permutations of each other, `List.countP p l₁` equals `List.countP p l₂`.


theorem Sym.mem_cons_self : ∀ {α : Type u_1} {n : ℕ} (a : α) (s : Sym α n), a ∈ a ::ₛ s := by sorry

The theorem `Sym.mem_cons_self` states that for any type `α`, any natural number `n`, any element `a` of type `α`, and any `n`-tuple `s` (considered up to permutation) of type `α`, the element `a` is a member of the `n+1`-tuple created by prepending `a` to `s`. In other words, if you add an element to the start of a tuple, that element is definitely in the resulting tuple.

For any type α, any natural number n, any element a of α, and any n-tuple s of type α considered up to permutation, the element a is in the (n+1)-tuple obtained by prepending a to s.


theorem ContDiff.real_of_complex : ∀ {e : ℂ → ℂ} {n : ℕ∞}, ContDiff ℂ n e → ContDiff ℝ n fun x => (e ↑x).re := by sorry

This theorem states that for every function `e` from complex numbers to complex numbers, and for any natural number `n` (which could be the special value `ℕ∞` representing infinity), if `e` is `n`-times continuously differentiable (meaning we can take the derivative of `e` `n` times and the result is still a continuous function), then the function that takes a real number `x`, converts it to a complex number `↑x`, applies `e`, and then takes the real part `.re`, is also `n`-times continuously differentiable over the real numbers.

If a complex function `e` is `n`-times differentiable, then the real-part function `x ↔>.re<. (↑x ↔> e ↔>.re)` is also `n`-times differentiable over the real numbers.


theorem StrictMono.add_const :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α}
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1],
      StrictMono f → ∀ (c : α), StrictMono fun x => f x + c :=
  by sorry

The theorem `StrictMono.add_const` states that for any type `α` with an addition operation and a preorder relation, and any type `β` with a preorder relation, if `f` is a strictly monotone function from `β` to `α`, and `α` has a covariant class with respect to addition and the `<` relation, then adding a constant `c` to `f(x)` results in a function that is also strictly monotone. In simpler terms, adding a constant to a strictly increasing function does not change its strictly increasing property.

If `f` is a strictly monotone function from a preordered type `β` to a type `α` with covariant addition and preorder relation, then the function `x ↦ f(x) + c` is also strictly monotone for any constant `c` in `α`.


CategoryTheory.Under.UnderMorphism.ext

theorem CategoryTheory.Under.UnderMorphism.ext :
    ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} {f g : U ⟶ V},
      f.right = g.right → f = g :=
  by sorry

This theorem in the Category Theory is stating that for any type `T` which forms a category, for any object `X` of the category `T` and for any two objects `U` and `V` in the under category of `X`, if we have two morphisms `f` and `g` from `U` to `V` and if the right component of the morphisms `f` and `g` are equal, then the morphisms `f` and `g` are themselves equal. Here, the under category is defined as a category where objects are arrows with domain `X` and morphisms are commutative triangles.

In the under category of an object `X` in a category `T`, if two morphisms from an object `U` to `V` have equal right components, then they are equal.


theorem MeasureTheory.Ioc_ae_eq_Icc :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.NoAtoms μ]
      [inst : PartialOrder α] {a b : α}, Set.Ioc a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Icc a b :=
  by sorry

The theorem `MeasureTheory.Ioc_ae_eq_Icc` states that for any measurable space `α`, any measure `μ` on `α` which has no atoms (single-point sets with positive measure), and any partial order on `α`, the left-open right-closed interval from `a` to `b` (denoted `Set.Ioc a b`) is almost everywhere equal to the left-closed right-closed interval from `a` to `b` (denoted `Set.Icc a b`) with respect to the measure `μ`. In other words, the set of points where these two intervals differ has measure zero.

For any measurable space `(α, Σ, μ)` with no atoms, and any `a < b` in `α`, the sets `Set.Ioc a b` and `Set.Icc a b` have equal measure.


/-- If the image of a family of vectors under a linear map is linearly independent, then so is
the original family.  -/
theorem LinearIndependent.of_comp :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {M' : Type u_5} {v : ι → M} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M']
      (f : M →ₗ[R] M'), LinearIndependent R (⇑f ∘ v) → LinearIndependent R v :=
  by sorry

The theorem `LinearIndependent.of_comp` states that for any semiring `R` and additive commutative monoids `M` and `M'` that are also `R`-modules, given a linear map `f` from `M` to `M'` and a family of vectors `v`, if the image of the family of vectors under the linear map is linearly independent over `R`, then the original family of vectors is also linearly independent over `R`.

If `f : M → M'` is a linear map between additive commutative `R`-modules `M` and `M'`, and the image of a family of vectors in `M` under `f` is linearly independent over `R`, then the original family of vectors is also linearly independent over `R`.


theorem mul_self : ∀ {α : Type u_1} [inst : BooleanRing α] (a : α), a * a = a := by sorry

This theorem, named `mul_self`, states that for all elements `a` of a given type `α`, where `α` is a Boolean Ring, the product of `a` with itself (i.e., `a * a`) is equal to `a` itself. In mathematical terms, for any element `a` in a Boolean Ring, `a² = a`.

In a Boolean Ring, for all elements `a`, `a * a = a`.


theorem mul_sup :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      c * (a ⊔ b) = c * a ⊔ c * b :=
  by sorry

This theorem, `mul_sup`, states that for any type `α` that forms both a lattice and a group, and a multiplication operation on `α` that is monotone (meaning that if `x ≤ x_1` then `c * x ≤ c * x_1` for all `c`, `x`, `x_1` in `α`), the product of `c` and the supremum (join or least upper bound) of `a` and `b` equals the supremum of the product of `c` and `a` and the product of `c` and `b`. In terms of algebraic structures, it says that multiplication distributes over the supremum operation in this particular lattice-group structure.

For any lattice- and group-structured type `α` with a monotone multiplication, the product of any constant `c` with the supremum of `a` and `b` equals the supremum of the products `c * a` and `c * b`.


/-- A two-argument function applied to two `dite`s is a `dite` of that two-argument function
applied to each of the branches.  -/
theorem apply_dite₂ :
    ∀ {α : Sort u_3} {β : Sort u_4} {γ : Sort u_2} (f : α → β → γ) (P : Prop) [inst : Decidable P] (a : P → α)
      (b : ¬P → α) (c : P → β) (d : ¬P → β),
      f (dite P a b) (dite P c d) = if h : P then f (a h) (c h) else f (b h) (d h) :=
  by sorry

This theorem states that for any two-argument function `f`, and any proposition `P` with a decidable instance, if `f` is applied to two dependent `if-then-else` constructs (`dite`), the result is equivalent to another `if-then-else` construct where the `f` is applied to each of the branches separately. In other words, the operation of the function `f` over `dite` structures is distributive: `f` can be distributed over the true and false branches of the `dite` structures.

For any decidable proposition P and a two-argument function f, the application of f to dependent if-then-else constructs dite(h, t, e) is equivalent to dite(h, f(h), f(e)).


theorem MvPolynomial.eval₂_monomial :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} {a : R} {s : σ →₀ ℕ} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      (f : R →+* S₁) (g : σ → S₁),
      MvPolynomial.eval₂ f g ((MvPolynomial.monomial s) a) = f a * Finsupp.prod s fun n e => g n ^ e :=
  by sorry

The theorem `MvPolynomial.eval₂_monomial` states that for any given commutative semirings `R` and `S₁`, a polynomial `a` of type `R`, and a finitely supported function `s` from a type `σ` to natural numbers, along with a ring homomorphism `f` from `R` to `S₁` and a function `g` from `σ` to `S₁`, the evaluation of the polynomial `a` with exponents given by `s` under these mappings equals the product of the mapping of `a` under `f` and the product over the support of `s`, where each term in the product is the image of an element `n` under `g`, raised to the power `e`, where `e` is the value of `s` at `n`. This theorem defines how a multivariate polynomial (represented by `MvPolynomial`) with a monomial is evaluated under a given valuation and ring homomorphism.

For any commutative semirings R and S₁, polynomial a over R, finitely supported function s from a type σ to natural numbers, ring homomorphism f from R to S₁, and function g from σ to S₁, the evaluation of polynomial a with exponents given by s under mappings f and g equals the product of the mapping of a under f and the product over the support of s, where each term is the image of an element n under g, raised to the power of s(n).


theorem Embedding.closure_eq_preimage_closure_image :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Embedding f → ∀ (s : Set X), closure s = f ⁻¹' closure (f '' s) :=
  by sorry

The theorem `Embedding.closure_eq_preimage_closure_image` states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, given that `f` is an Embedding and both `X` and `Y` are topological spaces, for any set `s` of type `X`, the closure of `s` is equal to the preimage under `f` of the closure of the image of `s` under `f`. In less formal terms, this means that the closure of a set in the original space and the closure of its image in the target space are closely related: the closure of the original set is exactly the set of points that get mapped to the closure of the image.

Given an Embedding `f` between topological spaces `X` and `Y`, the closure of `f`(S) is equal to `f`(Closure S), where S is a subset of X.


theorem CategoryTheory.GrothendieckTopology.diagram.proof_1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
      {D : Type u_3} [inst_1 : CategoryTheory.Category.{max u_2 u_1, u_3} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ),
      CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S.unop P) :=
  by sorry

This theorem, `CategoryTheory.GrothendieckTopology.diagram.proof_1`, states that for any category `C` with a Grothendieck topology `J`, and any category `D`, if every functor from the opposite category of `C` to `D` has a multi-equalizer for every cover `S` of any object `X` in `C` (this cover being a poset with respect to the Grothendieck topology `J`), then for any such functor `P` and any such cover `S` (taken in the opposite category), the multi-equalizer exists for the index of the cover `S` with respect to the functor `P`.

If every functor from the opposite category of a category with a Grothendieck topology has a multi-equalizer for every cover, then the multi-equalizer for the index of any cover with respect to such a functor exists.


theorem Set.indicator_comp_of_zero :
    ∀ {α : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] {s : Set α} {f : α → M}
      {g : M → N}, g 0 = 0 → Set.indicator s (g ∘ f) = g ∘ Set.indicator s f :=
  by sorry

The theorem `Set.indicator_comp_of_zero` states that for any set `s` of elements of type `α`, any function `f` mapping elements of type `α` to type `M`, and any function `g` mapping elements of type `M` to type `N` (given that zero of both types `M` and `N` are defined and the function `g` maps `0` to `0`), the indicator function of the composition `g ∘ f` on the set `s` is equal to the composition of `g` and the indicator function of `f` on the set `s`. In other words, the indicator function commutes with the composition of functions whenever the second function sends `0` to `0`.

For any set `s` and functions `f: α → M`, `g: M → N` with `0` defined in types `M` and `N` and `g(0) = 0`, the indicator functions of `g ∘ f` and `g ∘ Indicator_fun s ∘ f` on set `s` are equal.


theorem Mathlib.Algebra.Periodic._auxLemma.1 :
    ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c := by sorry

This theorem, `Mathlib.Algebra.Periodic._auxLemma.1`, stipulates that for any type `G` that forms an additive semigroup, the operation of addition has the associative property. Specifically, for any three elements `a`, `b`, and `c` of type `G`, the sum of `a` and the sum of `b` and `c` (`a + (b + c)`) is exactly the same as the sum of `a`, `b`, and `c` directly (`a + b + c`). In the language of mathematics, this corresponds to the familiar associative property $a + (b + c) = (a + b) + c$ for addition in a semigroup.

The theorem `Mathlib.Algebra.Periodic._auxLemma.1` asserts that addition is associative in an additive semigroup. That is, for any additive semigroup `G`, and elements `a, b, c` in `G`, we have `a + (b + c) = (a + b) + c`.


theorem finsum_eq_sum_plift_of_support_subset :
    ∀ {M : Type u_2} {α : Sort u_4} [inst : AddCommMonoid M] {f : α → M} {s : Finset (PLift α)},
      Function.support (f ∘ PLift.down) ⊆ ↑s → (finsum fun i => f i) = Finset.sum s fun i => f i.down :=
  by sorry

This theorem, `finsum_eq_sum_plift_of_support_subset`, states that for any given type `M`, which is an additive commutative monoid, and for any type `α`, given a function `f` from `α` to `M` and a finite set `s` of lifted elements of `α`, if the support of the function `f` composed with the "down" operation on `PLift α` (i.e. the set of points where `f` does not evaluate to zero) is a subset of `s`, then the sum of `f` over all elements `i` (in the sense of `finsum`) is equal to the sum of `f` applied to the "down" of each element `i` in the finite set `s`. The "down" operation on `PLift α` is used to extract a value from a lifted type. The sum over a finite set is simply the addition of `f x` for all `x` in the set.

For any additive commutative monoid M and function f from type α to M, if the support of f composed with the down operation on PLift α is a subset of a finite set s of lifted elements, then the sum of f over all elements in the domain equals the sum of f applied to the down of each element in s.


theorem Set.iUnion_union_distrib :
    ∀ {β : Type u_2} {ι : Sort u_4} (s t : ι → Set β), ⋃ i, s i ∪ t i = (⋃ i, s i) ∪ ⋃ i, t i := by sorry

The theorem `Set.iUnion_union_distrib` states that for any type `β` and any index type `ι`, the distributed union of indexed sets `s` and `t` over all indices `i` is equal to the union of the indexed union of `s` and the indexed union of `t`. In more mathematical terms, it expresses the property that the union over an index set of the union of two sets (each indexed by the same set) is equal to the union of the unions over the index set of the two sets separately. This is the distributive property of union over indexed sets.

For any type `β` and index type `ι`, the indexed union of `s ∪ t` over `ι` equals the indexed union of `s` and `t` over `ι`. In other words, `⋃i, σ i. (s i ∪ t i) = ⋃i, σ i. (s i) ∪ (t i)`, where `σ i` denotes the indexed family structure.


theorem decide_eq_false : ∀ {p : Prop} [inst : Decidable p], ¬p → decide p = false := by sorry

This theorem, `decide_eq_false`, is stating that for any proposition `p`, given that `p` is decidable (meaning we have an instance of `Decidable p`), if `¬p` (i.e., `p` is not true), then the function `decide p` will return `false`. In simple words, if some proposition is not true, then its decision function will confirm this by returning `false`. This theorem can be used in the context of constructive logic, where we need explicit proof or disproof (decision procedures) for our propositions.

If `p` is a decidable proposition in Lean 4 and `¬p` holds, then `decide p` returns `false`.


theorem Nat.prime_dvd_prime_iff_eq : ∀ {p q : ℕ}, Nat.Prime p → Nat.Prime q → (p ∣ q ↔ p = q) := by sorry

The theorem `Nat.prime_dvd_prime_iff_eq` states that for any two natural numbers `p` and `q`, if `p` and `q` are both prime numbers, then `p` divides `q` if and only if `p` is equal to `q`. In other words, a prime number can only divide another prime number if they are the same. This captures a key property of prime numbers in number theory, which are numbers that have exactly two positive divisors: 1 and the number itself.

If two natural numbers `p` and `q` are both prime, then `p` divides `q` if and only if `p` equals `q`.


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

This theorem, `Int.add_left_comm`, states that for all integers `a`, `b`, and `c`, the operation of addition is left-commutative. In other words, adding `b` and `c` together and then adding `a` to the result is the same as adding `b` to the sum of `a` and `c`. This is expressed in mathematical notation as a + (b + c) = b + (a + c).

For all integers `a`, `b`, and `c`, `a + (b + c) = b + (a + c)`.


theorem MeasureTheory.Measure.map_smul :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] (c : ENNReal)
      (μ : MeasureTheory.Measure α) (f : α → β),
      MeasureTheory.Measure.map f (c • μ) = c • MeasureTheory.Measure.map f μ :=
  by sorry

The theorem `MeasureTheory.Measure.map_smul` states that for any types `α` and `β`, where `α` has a measurable space structure `m0` and `β` has a measurable space instance, and given an extended nonnegative real number `c`, a measure `μ` on `α`, and a function `f` from `α` to `β`, the measure of the image of the function `f` on the measure `μ` scaled by `c` is equal to the measure of the image of the function `f` on `μ` scaled by `c`. In simpler terms, it means that scaling a measure and then applying a function is the same as applying the function and then scaling the measure.

For measurable spaces `(α, m0)` and `(β)`, extended nonnegative real number `c`, measure `μ` on `α`, and function `f` from `α` to `β`, `μ(f "''" (c * μ)) = c * μ(f "''" μ)`.


theorem List.chain'_cons :
    ∀ {α : Type u} {R : α → α → Prop} {x y : α} {l : List α},
      List.Chain' R (x :: y :: l) ↔ R x y ∧ List.Chain' R (y :: l) :=
  by sorry

The theorem `List.chain'_cons` states that for any type `α`, any binary relation `R` on `α`, and any elements `x` and `y` of `α` and a list `l` of elements of `α`, the relation `R` forms a chain on the list consisting of `x`, `y`, and `l` (`x :: y :: l`) if and only if `R` holds between `x` and `y` and `R` forms a chain on the list consisting of `y` and `l` (`y :: l`). In simpler terms, a list has the chain property if each consecutive pair of elements in the list satisfies the relation `R`.

For any type `α` and binary relation `R` on `α`, the list `x :: y :: l` has the chain property with respect to `R` if and only if `R` holds between `x` and `y` and the list `y :: l` has the chain property with respect to `R`.


theorem Complex.cos_pi_div_two : Complex.cos (↑Real.pi / 2) = 0 := by sorry

This theorem states that the cosine of pi divided by two, when evaluated in the field of complex numbers, equals zero. Here, pi is a real number defined as twice a zero of the cosine function in the interval [1,2]. The complex cosine function is defined using the exponential function. In mathematical terms, this theorem corresponds to the well-known result cos(π/2) = 0.

The cosine of pi over 2, evaluated in the complex numbers, equals zero, where pi is the real number defined as twice a zero of the cosine function in the interval [1,2].


theorem ClosureOperator.closure_min :
    ∀ {α : Type u_1} [inst : PartialOrder α] {c : ClosureOperator α} {x y : α}, x ≤ y → c.IsClosed y → c x ≤ y := by
  sorry

This theorem states that for any type `α` endowed with a partial order and a `ClosureOperator c`, if `x` and `y` are elements of type `α` such that `x` is less than or equal to `y` and `y` is a closed element under the operator `c`, then the closure of `x` under operator `c` is less than or equal to `y`. In other words, if `x` is not greater than `y` and `y` is a "stable" point for the closure operation, then the closure of `x` won't exceed `y`.

For any type `α` with a partial order and a closure operator `c`, if `x ≤ y` and `y` is closed under `c`, then `clo(x) ≤ y`, where `clo(x)` represents the closure of `x` under `c`.


theorem Polynomial.Monic.coeff_natDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.Monic p → Polynomial.coeff p (Polynomial.natDegree p) = 1 :=
  by sorry

The theorem `Polynomial.Monic.coeff_natDegree` states that for all types `R` that have a semiring structure and for all polynomials `p` over `R`, if `p` is a monic polynomial (i.e., its leading coefficient is 1), then the coefficient of `p` at the degree of `p` forced to a natural number (`natDegree p`) is also 1. In other words, it asserts that the coefficient of the highest non-zero degree term (in natural numbers) of a monic polynomial is 1.

For every monic polynomial $p$ over a semiring $R$, the coefficient of $p$ at its natural degree is 1.


theorem tendsto_const_smul_iff :
    ∀ {α : Type u_2} {β : Type u_3} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : Group G]
      [inst_2 : MulAction G α] [inst_3 : ContinuousConstSMul G α] {f : β → α} {l : Filter β} {a : α} (c : G),
      Filter.Tendsto (fun x => c • f x) l (nhds (c • a)) ↔ Filter.Tendsto f l (nhds a) :=
  by sorry

The theorem `tendsto_const_smul_iff` states that for any types `α`, `β`, and `G`, where `α` has a topological space structure, `G` is a group, and `α` has a multiplication action by `G` with continuous constant scalar multiplication, for any function `f` from `β` to `α`, any filter `l` on `β`, any element `a` from `α`, and any element `c` from `G`, the function that to each `x` from the domain associates `c` multiplied by `f(x)` tends toward the neighborhood of `c` multiplied by `a` as `x` tends toward the elements of the filter `l`, if and only if the function `f` tends toward the neighborhood of `a` as `x` tends toward the elements of the filter `l`. In other words, the limit of the function `f` when multiplied by a constant scalar `c` is just `c` multiplied by the limit of `f`.

For any type `α` with a topological space structure, group `G` with continuous constant scalar multiplication action on `α`, function `f` from `β` to `α`, filter `l` on `β`, element `a` from `α`, and `c` from `G`, the function `x ↦ c * f(x)` tends to the neighborhood of `a * c` as `x` tends to the elements in `l` if and only if `f` tends to the neighborhood of `a`.


theorem Submodule.neg_mem_iff :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] {module_M : Module R M} (p : Submodule R M)
      {x : M}, -x ∈ p ↔ x ∈ p :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and module `M` over `R`, given a submodule `p` of `M` and any element `x` of `M`, the additive inverse of `x` (`-x`) is in the submodule `p` if and only if `x` is in `p`. In other words, a submodule of a module over a ring is closed under taking additive inverses.

For any submodule `p` of an additive commutative group `M` over a ring `R`, if `x` is an element of `p`, then `-x` is also an element of `p`, and conversely.


theorem Metric.mem_ball' :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, y ∈ Metric.ball x ε ↔ dist x y < ε := by sorry

The theorem `Metric.mem_ball'` states that for any type `α` equipped with a pseudo metric space structure, any points `x` and `y` of type `α`, and any real number `ε`, `y` is in the ball of radius `ε` centered at `x` (denoted as `Metric.ball x ε`) if and only if the distance between `x` and `y` is less than `ε`. In mathematical terms, this means `y ∈ B(x, ε)` if and only if `d(x, y) < ε`, where `B(x, ε)` is the open ball centered at `x` with radius `ε`, and `d(x, y)` is the distance between `x` and `y`.

For any pseudo metric space (α, d), and points x, y in α, y belongs to the open ball B(x, ε) if and only if the distance d(x, y) < ε.


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

The theorem `memℓp_zero` states that for any type `α`, any function `f : α → E i` from `α` to `E i` (where `E i` is a normed additive commutative group for each `i : α`), if the set of `i` such that `f i` is non-zero is finite, then `f` belongs to the space `ℓp` for `p = 0`. In mathematical terms, this means that a function is in the sequence space `ℓ^0` if and only if it is finitely supported.

A function from a type to a normed additive commutative group belongs to the sequence space ℓ^0 if and only if its support is finite.


theorem CategoryTheory.Monad.right_unit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (X : C),
      CategoryTheory.CategoryStruct.comp (T.map ((CategoryTheory.Monad.η T).app X)) ((CategoryTheory.Monad.μ T).app X) =
        CategoryTheory.CategoryStruct.id (T.obj X) :=
  by sorry

This theorem states that for any category `C` and any monad `T` on `C`, for any object `X` in `C`, the composition of the morphism obtained by applying the unit of the monad `T` to `X` and then mapping that via `T` and the multiplication of the monad `T` applied to `X` is equal to the identity on the object `T.obj X`. This is essentially the statement of the right unit law for monads in category theory. In mathematical notation, it corresponds to the equation `T(η_X) ∘ μ_X = id_(T(X))`, where `η` is the unit of the monad, `μ` is the multiplication of the monad, and `id` denotes the identity morphism.

For any category `C` and monad `T` on `C`, the composition of `T(η\_X)` and `μ\_X` equals the identity `id(T(X))` for any object `X` in `C`. (This is the right unit law for monads in category theory.)


theorem Int.sign_eq_one_of_pos : ∀ {a : ℤ}, 0 < a → Int.sign a = 1 := by sorry

This theorem states that for any integer 'a', if 'a' is greater than 0, then the sign of 'a' is 1. This is essentially saying that the "sign" function, which returns the "sign" of an integer as another integer, will return 1 for all positive integers.

For all integers 'a', if 'a' > 0 then sign 'a' = 1.


theorem Mathlib.Data.List.Dedup._auxLemma.3 :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, (a ∈ List.dedup l) = (a ∈ l) := by sorry

The theorem `Mathlib.Data.List.Dedup._auxLemma.3` states that for any type `α` that has decidable equality, and for any element `a` of type `α` and any list `l` of type `α`, the presence of `a` in the list `l` from which duplicates have been removed (by `List.dedup`) is equivalent to the presence of `a` in the original list `l`. In other words, an element is in the de-duplicated list if and only if it is in the original list.

For any type `α` with decidable equality and any list `l` of `α`, the element `a` is in the de-duplicated list `List.dedup l` if and only if it is in the original list `l`.


theorem Set.einfsep_le_edist_of_mem :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {x : α},
      x ∈ s → ∀ {y : α}, y ∈ s → x ≠ y → Set.einfsep s ≤ edist x y :=
  by sorry

The theorem `Set.einfsep_le_edist_of_mem` states that for any type `α` equipped with an extended distance (or `edist`) function, and for any set `s` of elements of type `α`, if `x` and `y` are distinct elements of `s`, then the extended infimum separation of `s` is less than or equal to the extended distance between `x` and `y`. This essentially says that the smallest possible separation in a set is always less than or equal to the distance between any two distinct elements in the set.

For any set equipped with an extended distance function, the extended infimum separation of distinct elements is less than or equal to their extended distance.


theorem Option.ne_none_iff_exists : ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ ∃ x, some x = o := by sorry

This theorem states that for any type `α` and any option `o` of that type, `o` is not `none` if and only if there exists an element `x` such that `some x` is equal to `o`. In other words, an option is not `none` precisely when it is `some x` for some value `x`.

For any type `α`, an option `o` of type `option α` is non-empty (not `none`) if and only if it is the `some` value of some element `x` of type `α`.


theorem add_add_sub_cancel : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b c : G), a + c + (b - c) = a + b := by sorry

This theorem states that for any additive commutative group `G` and any elements `a`, `b`, and `c` of `G`, the sum of `a` and `c` plus the difference between `b` and `c` equals the sum of `a` and `b`. In mathematical notation, this can be written as: `a + c + (b - c) = a + b`. The theorem highlights a property of subtraction in the context of additive commutative groups: subtracting an element and then adding it back effectively cancels the subtraction.

In an additive commutative group, the sum of an element with another element and its negative is equal to the sum of the two original elements.


theorem CategoryTheory.Limits.image.fac_lift :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f)
          (CategoryTheory.Limits.image.lift F') =
        F'.e :=
  by sorry

The theorem `CategoryTheory.Limits.image.fac_lift` states that in any category `C`, given objects `X` and `Y`, and a morphism `f` from `X` to `Y`, if `f` has an image, then for any monic factorization `F'` of `f`, the composition of the morphism from `X` to the image of `f` with the morphism from the image of `f` to the object of `F'` equals the morphism in `F'`. This essentially asserts the uniqueness part of the universal property of the image of a morphism in category theory.

Given any category `C`, morphism `f` from object `X` to object `Y`, monic factorization `F'` of `f`, and if `f` has an image, then the composition of the morphism from the image of `f` to `X` with `f` is equal to the morphism from the image of `f` to the object in `F'`.


theorem cast_eq_iff_heq : ∀ {a a_1 : Sort u_1} {e : a = a_1} {a_2 : a} {a' : a_1}, cast e a_2 = a' ↔ HEq a_2 a' := by
  sorry

This theorem states that for any two sorts `a` and `a_1` of the same universe `u_1`, and given `e` is an equality between `a` and `a_1`, an element `a_2` of `a` and an element `a'` of `a_1`, then the casting of `a_2` to `a_1` using `e` is equal to `a'` if and only if `a_2` and `a'` are heterogeneously equal. "Heterogeneously equal" (HEq) means that `a_2` and `a'` are equal even if they are of different types, as long as their types are themselves equal.

For any sorts `a` and `a_1` of the same universe `u_1`, and given `e : a = a_1`, `a_2 : a`, and `a' : a_1`, `e.cast a_2 = a'` if and only if `a_2` and `a'` are heterogeneously equal.


theorem Units.mul_inv_eq_iff_eq_mul : ∀ {α : Type u} [inst : Monoid α] (b : αˣ) {a c : α}, a * ↑b⁻¹ = c ↔ a = c * ↑b :=
  by sorry

This theorem states that for any monoid `α`, given an element `b` from the group of units of `α`, and any two other elements `a` and `c` of `α`, the statement that `a` times the multiplicative inverse of `b` equals `c` is equivalent to the statement that `a` equals `c` times `b`. Here, `αˣ` represents the group of units in `α`, and `b⁻¹` represents the multiplicative inverse of `b`. The theorem captures a key algebraic manipulation rule related to multiplicative inverses in a monoid.

For any monoid `α` and units `b` in `α`, the equation `a * b⁻¹ = c` is equivalent to `a = c * b` in `α`.


theorem csInf_image2_eq_csInf_csInf :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompleteLattice α]
      [inst_1 : ConditionallyCompleteLattice β] [inst_2 : ConditionallyCompleteLattice γ] {s : Set α} {t : Set β}
      {u : α → β → γ} {l₁ : β → γ → α} {l₂ : α → γ → β},
      (∀ (b : β), GaloisConnection (l₁ b) (Function.swap u b)) →
        (∀ (a : α), GaloisConnection (l₂ a) (u a)) →
          Set.Nonempty s → BddBelow s → Set.Nonempty t → BddBelow t → sInf (Set.image2 u s t) = u (sInf s) (sInf t) :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` that are conditionally complete lattices, and for any sets `s` and `t` of types `α` and `β` respectively, along with a binary function `u : α → β → γ` and two Galois connections `l₁ : β → γ → α` and `l₂ : α → γ → β` (where the Galois connection for `l₁` is a function of `b` that has its order reversed by `u`, and similarly, the Galois connection for `l₂` is a function of `a` that has its order reversed by `u`), if `s` and `t` are nonempty and bounded below, then the infimum (greatest lower bound) of the image of the binary function `u` over sets `s` and `t` is equal to the value of the function `u` at the infimum of `s` and the infimum of `t`. This relates the infimum of a function's image over a Cartesian product of sets to the function's value at the Cartesian product of the infimums of those sets.

Given three conditionally complete lattices `α`, `β`, `γ`, sets `s ≠∅` in `α`, `t ≠∅` in `β`, a binary function `u : α → β → γ`, and Galois connections `l₁ : β → γ → α` and `l₂ : α → γ → β` with reversed orders under `u`, if `inf s` and `inf t` exist, then `inf (map (λ x, λ y, u x y) s t) = u (inf s) (inf t)`.


theorem nhdsWithin_restrict'' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} (s : Set α) {t : Set α},
      t ∈ nhdsWithin a s → nhdsWithin a s = nhdsWithin a (s ∩ t) :=
  by sorry

This theorem states that for any type `α` with a topological space structure, any element `a` of type `α`, and any sets `s` and `t` of type `α`, if `t` is in the neighborhood within `s` of `a`, then the neighborhood within `s` of `a` is equivalent to the neighborhood within the intersection of `s` and `t` of `a`. In simpler terms, if `t` is a neighborhood of `a` within `s`, then the neighborhoods of `a` within `s` are the same as the neighborhoods of `a` within the intersection of `s` and `t`.

For any topological space `α` and elements `a` in `α`, sets `s` and `t` in `α` such that `t` is a neighborhood of `a` in `s`, the neighborhood filter of `a` in `s` is equal to the neighborhood filter of `a` in the intersection of `s` and `t`.


theorem Function.Antiperiodic.sub_eq' :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : AddCommGroup α] [inst_1 : Neg β],
      Function.Antiperiodic f c → f (c - x) = -f (-x) :=
  by sorry

The theorem `Function.Antiperiodic.sub_eq'` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any elements `c` and `x` of `α` such that `α` is an additive commutative group and `β` has negation, if `f` is antiperiodic with antiperiod `c`, then the value of `f` at `c - x` is equal to the negation of `f` at `-x`. In other words, if `f` has the property that `f (x + c) = -f x` for all `x`, then `f (c - x) = -f (-x)` for all `x`. The theorem underlines an important symmetry property of antiperiodic functions.

For any additive commutative group type `α`, any type `β` with negation, and any antiperiodic function `f` from `α` to `β` with antiperiod `c`, `f (c - x) = -f (-x)` for all `x` in `α`.


theorem Matrix.updateColumn_self :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n],
      Matrix.updateColumn M j c i j = c i :=
  by sorry

The theorem `Matrix.updateColumn_self` asserts that for any type `m` indexing the rows, type `n` indexing the columns, and type `α` representing the entries of a matrix `M`, along with a specific row `i`, column `j`, and column vector `c` (which is a function from `m` to `α`), if the equality of type `n` (the type indexing the columns) is decidable, then the `j`th column of the matrix `M` updated with the column vector `c` at row `i` and column `j` equals the `i`th element of the column vector `c`. In other words, when you replace the `j`th column of a matrix with a new column, the entry in the `i`th row and `j`th column of the updated matrix will be the `i`th element of the new column.

If `M` is a matrix with decidable column equality, then updating the `j`th column of `M` with the column vector `c` results in a matrix where the entry in the `i`th row and `j`th column equals the `i`th element of `c`.


theorem Monoid.exponent_ne_zero : ∀ {G : Type u} [inst : Monoid G], Monoid.exponent G ≠ 0 ↔ Monoid.ExponentExists G :=
  by sorry

The theorem `Monoid.exponent_ne_zero` states that for any type `G` that is a `Monoid`, the exponent of the monoid is not zero if and only if there exists a positive integer `n` such that every element of the monoid raised to the power `n` equals the identity element. In other words, a monoid has a non-zero exponent exactly when it satisfies the property that all its elements have a common positive integer exponent that yields the identity element when applied.

A monoid `G` has a non-zero exponent if and only if there exists a positive integer `n` such that for all `x` in `G`, `x^n = id_G`.


theorem Finsupp.coe_neg : ∀ {α : Type u_1} {G : Type u_9} [inst : NegZeroClass G] (g : α →₀ G), ⇑(-g) = -⇑g := by sorry

This theorem states that for any type `α` and any type `G` that has a `NegZeroClass` instance (i.e., `G` has operations for negation and zero), and for any function `g` from `α` to `G`, negating the function `g` (denoted as `-g`) and then applying it (denoted as `⇑(-g)`) is the same as first applying `g` and then negating the result (denoted as `-⇑g`). Essentially, it asserts that the order of negation and function application does not matter.

For any function `g` from type `α` to a type `G` with `NegZeroClass`, the functions `neg ∘ g` and `g ∘ neg` are equal, where `neg` denotes negation in `G`.


theorem Mathlib.Data.Set.Pointwise.SMul._auxLemma.15 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t : Set β} {b : β},
      (b ∈ s • t) = ∃ x ∈ s, ∃ y ∈ t, x • y = b :=
  by sorry

This theorem states that for any types `α` and `β` with a scalar multiplication operation `•` defined between them, given sets `s` of type `α` and `t` of type `β`, and an element `b` of type `β`, the element `b` belongs to the scalar multiplication of set `s` and set `t` (denoted as `s • t`) if and only if there exist an element `x` in set `s` and an element `y` in set `t` such that the scalar multiplication of `x` and `y` equals `b`. Here, `s • t` refers to the set of all elements that can be obtained by multiplying an element from `s` with an element from `t`.

For any types `α` and `β` with scalar multiplication `•` and sets `s` of type `α` and `t` of type `β`, `b ∈ s • t` if and only if there exist `x ∈ s` and `y ∈ t` such that `x • y = b`.


theorem Computation.terminates_def :
    ∀ {α : Type u} (s : Computation α), Computation.Terminates s ↔ ∃ n, Option.isSome (↑s n) = true := by sorry

The theorem `Computation.terminates_def` states that for any computation `s` of type `α`, `s` terminates if and only if there exists a natural number `n` such that the `n`th term of the computation is some value, i.e., it is not `none`. In other words, a computation is considered terminating if there is a point `n` after which the computation yields a definite value rather than none.

A computation of type `α` terminates if and only if there exists a natural number `n` such that the `n`th step of the computation yields a value.


theorem IsLocalization.Away.lift.proof_1 :
    ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_2} [inst_1 : CommSemiring P] (x : R) {g : R →+* P},
      IsUnit (g x) → ∀ (y : ↥(Submonoid.powers x)), IsUnit (g ↑y) :=
  by sorry

This theorem, `IsLocalization.Away.lift.proof_1`, states that for any commutative semiring `R`, any type `P` that is also a commutative semiring, any element `x` of `R`, and any ring homomorphism `g` from `R` to `P`, if `x` is a unit under the ring homomorphism `g`, then for any element `y` in the submonoid generated by `x`, `y` will also be a unit under the ring homomorphism `g`. In simpler terms, if `x` has a two-sided inverse under a certain mapping, then any power of `x` also has a two-sided inverse under the same mapping.

If `x` is a unit in `R` under the ring homomorphism `g`, then for every `y` in the submonoid generated by `x`, `y` is also a unit in `P` under `g`.


theorem Finset.prod_sdiff :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : CommMonoid β] [inst_1 : DecidableEq α],
      s₁ ⊆ s₂ → ((Finset.prod (s₂ \ s₁) fun x => f x) * Finset.prod s₁ fun x => f x) = Finset.prod s₂ fun x => f x :=
  by sorry

This theorem is about the product of elements in finite sets using a certain function. Specifically, for any types `α` and `β`, any two finite sets `s₁` and `s₂` of type `α`, and any function `f` from `α` to `β`, given that `β` forms a commutative monoid and equality for type `α` is decidable, if `s₁` is a subset of `s₂`, the product of `f(x)` for every `x` in the difference of `s₂` and `s₁`, multiplied by the product of `f(x)` for every `x` in `s₁`, is equal to the product of `f(x)` for every `x` in `s₂`. In other words, the product over a set can be decomposed into the product over a subset and the product over the complement of the subset.

For any commutative monoid type `β`, decidably equal types `α`, finite sets `s₁ ⊆ s₂` of `α`, and function `f` from `α` to `β`, the product of `f(x)` for all `x ∈ s₂ \ s₁` multiplied by the product of `f(x)` for all `x ∈ s₁` equals the product of `f(x)` for all `x ∈ s₂`.


theorem norm_le_pi_norm :
    ∀ {ι : Type u_4} {π : ι → Type u_9} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddGroup (π i)]
      (f : (i : ι) → π i) (i : ι), ‖f i‖ ≤ ‖f‖ :=
  by sorry

This theorem states that for any finite type `ι`, and any map `f` from `ι` to a seminormed add group `π i`, the norm of `f i` is always less than or equal to the norm of `f`. In other words, the norm of any individual element in the range of `f` is bounded above by the overall norm of the function `f`. This theorem holds true for every element `i` in the finite type `ι`.

For any finite type `ι` and map `f` from `ι` to a seminormed add group `π i`, the maximum norm of `f i` over all `i` in `ι` is less than or equal to the norm of `f`.


theorem Matroid.Indep.subset_basis_of_subset :
    ∀ {α : Type u_1} {M : Matroid α} {I X : Set α},
      M.Indep I → I ⊆ X → autoParam (X ⊆ M.E) _auto✝ → ∃ J, M.Basis J X ∧ I ⊆ J :=
  by sorry

This theorem states that for any type `α`, given a matroid `M` of type `α`, and two sets `I` and `X` of type `α`, if `I` is independent within the matroid `M` and `I` is a subset of `X`, with `X` being a subset of the matroid's set `E` (the latter is an automatic parameter indicated by `autoParam`), there exists a set `J` such that `J` is a basis of `X` within the matroid `M` and `I` is also a subset of `J`.

For any matroid M over type α, if I is an independent subset of X within M and I is a subset of X, then there exists a basis J of X in M containing I.


Continuous.edist

theorem Continuous.edist :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : TopologicalSpace β] {f g : β → α},
      Continuous f → Continuous g → Continuous fun b => edist (f b) (g b) :=
  by sorry

This theorem states that for any two functions `f` and `g` from a topological space `β` to a pseudo-emetric space `α`, if both `f` and `g` are continuous, then the function that maps each point `b` in `β` to the extended distance (edist) between `f(b)` and `g(b)` in `α` is also continuous. In other words, the continuousness of `f` and `g` ensures the continuousness of the function that calculates the distances between their corresponding outputs.

If `f` and `g` are continuous functions from a topological space `β` to a pseudo-metric space `α`, then the function mapping each `b` in `β` to the extended distance between `f(b)` and `g(b)` is also continuous.


theorem MeasureTheory.Measure.quasiMeasurePreserving_snd :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν],
      MeasureTheory.Measure.QuasiMeasurePreserving Prod.snd (MeasureTheory.Measure.prod μ ν) ν :=
  by sorry

The theorem `MeasureTheory.Measure.quasiMeasurePreserving_snd` states that for any types `α` and `β` with their respective measurable spaces, and given measures `μ` on `α` and `ν` on `β`, where `ν` is s-finite (meaning it can be approximated by a finite measure), the second projection function `Prod.snd` is a quasi measure preserving function. In other words, if we take the product measure of `μ` and `ν`, and then apply the function `Prod.snd` to this product measure, we get the measure `ν` back. This theorem is a part of measure theory, which is a branch of mathematics that studies measurable spaces and measures on them.

Given measurable spaces (α, μ) and (β, ν), where ν is s-finite, the second projection function Prod.snd is a quasi-measure preserving function between the product measure μ × ν and ν.


theorem exists_swap : ∀ {α : Sort u_3} {β : Sort u_2} {p : α → β → Prop}, (∃ x y, p x y) ↔ ∃ y x, p x y := by sorry

This theorem, `exists_swap`, states that for any types `α` and `β` and any property `p` that relates an instance of `α` and `β`, the existence of a pair `(x, y)` such that `p x y` is true is equivalent to the existence of a pair `(y, x)` such that `p x y` is true. In terms of logic, this theorem is stating that the order of quantifiers in an existential statement does not affect the truth of the statement.

For any types `α`, `β`, and property `p(x, y)`: the existence of `x` and `y` such that `p x y` holds is equivalent to the existence of `y` and `x` such that `p x y` holds.


theorem Complex.continuous_abs : Continuous ⇑Complex.abs := by sorry

This theorem states that the absolute value function on complex numbers is continuous. In mathematical terms, this means for any complex number, small changes in the input to the absolute value function result in small changes in the output. In other words, if we have a sequence of complex numbers that converges to a certain value, the sequence of their absolute values will also converge to the absolute value of that value. This is an important property in complex analysis and topology that helps us understand the behavior of functions on complex numbers.

The absolute value function on complex numbers is a continuous function.


theorem Int.bit_val : ∀ (b : Bool) (n : ℤ), Int.bit b n = 2 * n + bif b then 1 else 0 := by sorry

This theorem, `Int.bit_val`, asserts that for any boolean `b` and integer `n`, the function `Int.bit b n`, which appends the digit `b` to the binary representation of `n`, results in the value `2 * n + bif b then 1 else 0`. In other words, the function effectively doubles `n` and adds `1` if `b` is true (representing the binary digit `1`) or adds `0` if `b` is false (representing the binary digit `0`). This is reflective of how binary numbers are calculated from their representation.

For any boolean `b` and integer `n`, `Int.bit b n` equals `2 * n + if b then 1 else 0`.


theorem Equiv.right_inv' : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), Function.RightInverse ⇑e.symm ⇑e := by sorry

The theorem `Equiv.right_inv'` states that for any type equivalence `e` between two arbitrary types `α` and `β`, the function `e.symm` (which maps `β` to `α`) is a right inverse to the function `e` (which maps `α` to `β`). In other words, if you apply `e` to an element of `α` and then apply `e.symm`, you get the original element of `α` back. This is denoted as `f ∘ g = id`, where `f` is `e` and `g` is `e.symm`.

For any type equivalence `e` between types `α` and `β`, `e.symm` is a right inverse to `e`, i.e., `e ∘ e.symm = id`.


theorem Asymptotics.IsLittleO.mul_isBigO :
    ∀ {α : Type u_1} {R : Type u_13} {𝕜 : Type u_15} [inst : SeminormedRing R] [inst_1 : NormedDivisionRing 𝕜]
      {l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜},
      f₁ =o[l] g₁ → f₂ =O[l] g₂ → (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x :=
  by sorry

The theorem `Asymptotics.IsLittleO.mul_isBigO` states that for any types `α`, `R`, and `𝕜`, along with a `SeminormedRing R` and a `NormedDivisionRing 𝕜`, given a filter `l` and functions `f₁`, `f₂`, `g₁`, and `g₂` from `α` to `R` or `𝕜`, if `f₁` is little-o of `g₁` at `l` and `f₂` is big-O of `g₂` at `l`, then the function defined by the product of `f₁` and `f₂` is little-o of the function defined by the product of `g₁` and `g₂` at `l`. This theorem is about the multiplication of little-o and big-O functions and their relationships in asymptotic analysis.

If `f₁` is little-o of `g₁` and `f₂` is big-O of `g₂` at a filter `l`, then `f₁ * f₂` is little-o of `g₁ * g₂` at `l`.


theorem Finset.fold_insert_idem :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {a : α} [inst : DecidableEq α] [hi : Std.IdempotentOp op],
      Finset.fold op b f (insert a s) = op (f a) (Finset.fold op b f s) :=
  by sorry

The theorem `Finset.fold_insert_idem` states that for any types `α` and `β`, a binary operation `op` on `β` that is commutative and associative, a function `f` from `α` to `β`, a base value `b` of type `β`, a finite set `s` of type `α`, and an element `a` of type `α` where `α` has decidable equality and `op` is idempotent, the result of folding `op` over the `f`-image of the set obtained by inserting `a` into `s` starting from `b` is equal to applying `op` to `f(a)` and the result of folding `op` over the `f`-image of `s` starting from `b`. In simpler terms, it means that inserting an element into a set and then folding a commutative, associative and idempotent operation doesn't change the result compared to applying the operation to the element's image and the original fold operation.

For any commutative, associative, idempotent binary operation `op` on type `β`, function `f` from type `α` to `β`, base value `b` of type `β`, finite set `s` of type `α` with decidable equality, and element `a` of type `α`, the following equality holds: `op.fold s (f a) b = op.fold (Finset.insert a s) b ⊕ f a`.


theorem CategoryTheory.Sieve.pullback_eq_top_iff_mem :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {S : CategoryTheory.Sieve X} (f : Y ⟶ X),
      S.arrows f ↔ CategoryTheory.Sieve.pullback f S = ⊤ :=
  by sorry

This theorem states that for any category `C`, for any objects `X`, `Y` in `C`, and for any morphism `f` from `Y` to `X`, and for any sieve `S` on `X`, the morphism `f` is in the sieve `S` if and only if the pullback of the sieve `S` along the morphism `f` is the maximal sieve on `Y`. Here, the pullback of a sieve `S` along a morphism `f` is the set of morphisms that, when composed with `f`, are in `S`. The maximal sieve on an object is the set of all morphisms into that object.

For any category C, morphism f from Y to X, and sieve S on X, f is in S if and only if the pullback of S along f is the maximal sieve on Y.


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

This theorem, `Nat.right_distrib`, states that for any three natural numbers `n`, `m`, and `k`, the distributive property holds on the right side. In other words, multiplying the sum of `n` and `m` by `k` (`(n + m) * k`) gives the same result as multiplying `n` by `k` and `m` by `k` individually, and then adding those results (`n * k + m * k`). This is a fundamental property of arithmetic known as the right distributivity of multiplication over addition.

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


theorem Seminorm.uniformContinuous_of_continuousAt_zero :
    ∀ {𝕝 : Type u_6} {E : Type u_7} [inst : SeminormedRing 𝕝] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕝 E]
      [inst_3 : UniformSpace E] [inst_4 : UniformAddGroup E] {p : Seminorm 𝕝 E},
      ContinuousAt (⇑p) 0 → UniformContinuous ⇑p :=
  by sorry

The theorem `Seminorm.uniformContinuous_of_continuousAt_zero` states that for any type `𝕝` that forms a seminormed ring, and any type `E` that forms an additive commutative group, a module over `𝕝`, a uniform space, and a uniform additive group, given a seminorm `p` on `E` over `𝕝`, if the seminorm `p` is continuous at zero, then `p` is uniformly continuous. In other words, if the value of `p` tends to `p(0)` when its input tends to `0`, then for any two points in `E` that are sufficiently close to each other, the values of `p` at these two points are also close, regardless of their location in `E`.

If a seminorm on a module over a seminormed ring is continuous at zero, then it is uniformly continuous.


theorem MeasureTheory.Ioo_ae_eq_Ico :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.NoAtoms μ]
      [inst : PartialOrder α] {a b : α}, Set.Ioo a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Ico a b :=
  by sorry

This theorem states that for any type `α` that has a measurable space structure, a measure `μ` with no atoms, and a partial order, and for any two elements `a` and `b` in `α`, the left-open right-open interval from `a` to `b` is "almost everywhere" equal to the left-closed right-open interval from `a` to `b` with respect to the measure `μ`. Here "almost everywhere" means except on a set of measure zero. In other words, the set of elements that are strictly greater than `a` and strictly less than `b` (denoted as `Set.Ioo a b`) is the same as the set of elements that are greater than or equal to `a` and strictly less than `b` (denoted as `Set.Ico a b`) except possibly for a set of measure zero.

For any measurable space `(α, Σ, μ)` with no atoms, for all `a < b` in `α`, the sets `Set.Ioo a b` and `Set.Ico a b` differ only in a set of measure zero.


theorem Mathlib.Analysis.BoxIntegral.Partition.Basic._auxLemma.16 :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I)
      {πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
      (J ∈ BoxIntegral.Prepartition.biUnion π πi) = ∃ J' ∈ π, J ∈ πi J' :=
  by sorry

This theorem from the `Mathlib.Analysis.BoxIntegral.Partition.Basic` in Lean 4 is about the union of a pre-partition of a box in n-dimensional space. Specifically, it states that for any types `ι`, any boxes `I` and `J`, a pre-partition `π` of box `I`, and a function `πi` that assigns a pre-partition to every box, then `J` is in the bi-union of the pre-partition `π` and the function `πi` if and only if there exists a box `J'` in the pre-partition `π` such that `J` is in the pre-partition `πi` assigned to `J'`.

A box J is in the bi-union of a pre-partition π and the function πi if and only if there exists a box J' in π such that J is in the pre-partition πi assigned to J'.


theorem Turing.ListBlank.nth_succ :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : Turing.ListBlank Γ) (n : ℕ),
      Turing.ListBlank.nth l (n + 1) = Turing.ListBlank.nth (Turing.ListBlank.tail l) n :=
  by sorry

This theorem states that for any type `Γ`, given that `Γ` is inhabited, and for any `l` of type `ListBlank Γ` and any natural number `n`, the `n+1`-th element of `l` is the same as the `n`-th element of the tail of `l`. In other words, removing the first element from a `ListBlank` and then retrieving the `n`-th element is equivalent to retrieving the `n+1`-th element from the original `ListBlank`. This is analogous to the behavior of lists in many programming languages where retrieving an element from the tail of the list effectively decreases the index by one.

For any inhabited type `Γ` and `ListBlank Γ` `l` with `n` greater than zero, the `n+1`-th element of `l` equals the `n`-th element of `l.tail`.


/-- Krull's theorem: a nontrivial ring has a maximal ideal.  -/
theorem Ideal.exists_maximal : ∀ (α : Type u) [inst : Semiring α] [inst_1 : Nontrivial α], ∃ M, Ideal.IsMaximal M := by
  sorry

Krull's theorem asserts that for every nontrivial semiring (a type of mathematical structure that generalizes the concepts of multiplication and addition), there exists a maximal ideal. In other words, there is an ideal (a special subset) within this semiring that is as large as possible without becoming the entire semiring itself.

Every nontrivial semiring has a maximal ideal.


/-- If a function is locally integrable, then it is integrable on any compact set.  -/
theorem MeasureTheory.LocallyIntegrable.integrableOn_isCompact :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X} {k : Set X},
      MeasureTheory.LocallyIntegrable f μ → IsCompact k → MeasureTheory.IntegrableOn f k μ :=
  by sorry

The theorem `MeasureTheory.LocallyIntegrable.integrableOn_isCompact` states that, given a measurable space `X`, a topological space `X`, and a normed add-commutative group `E`, for any function `f` mapping from `X` to `E`, any measure `μ` on `X`, and any set `k` of `X`, if the function `f` is locally integrable and the set `k` is compact, then the function `f` is integrable on the set `k` with respect to the measure `μ`. In other words, if a function is integrable near every point, then it is integrable over any compact set within the space.

If a locally integrable function on a compact set of a measurable space with respect to a measure is defined, then it is integrable.


Monotone.add

/-- The sum of two monotone functions is monotone. -/
theorem Monotone.add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α}
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_4 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      Monotone f → Monotone g → Monotone fun x => f x + g x :=
  by sorry

The theorem `Monotone.add` asserts that if you have two monotone functions, `f` and `g`, which map from a type `β` to a type `α`, where `α` is an additive preorder and `β` is a preorder, then the function that maps each element in `β` to the sum of `f` and `g` applied to that element is also monotone. This holds under the conditions that `α` is a covariant class under addition and ordering, and also under addition and ordering after swapping the arguments.

If `f` and `g` are monotone functions from a preordered type `β` to an additively ordered type `α`, then the function `x ↔ f x + g x` is monotone.


/-- **Alias** of `lt_of_lt_of_le'`. -/
theorem LT.lt.trans_le' : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, b < c → a ≤ b → a < c := by sorry

This theorem, `LT.lt.trans_le'`, is actually an alias of `lt_of_lt_of_le'`. It states that for any type `α` that has a preorder relation, given three elements `a`, `b`, and `c` of that type, if `b` is less than `c` (`b < c`) and `a` is less than or equal to `b` (`a ≤ b`), then it can be concluded that `a` is less than `c` (`a < c`). This theorem is a form of transitivity property for less than relation in a preordered set.

If `a <= b` and `b < c` hold in a preordered type `α`, then `a < c` also holds.


theorem iSup_iSup_eq_right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {b : β} {f : (x : β) → b = x → α},
      ⨆ x, ⨆ (h : b = x), f x h = f b ⋯ :=
  by sorry

This theorem states that for any types `α` and `β`, given a complete lattice structure on `α`, a value `b` of type `β`, and a function `f` from `β` (whose equality to `b` is ensured by a proof `h`) to `α`, the supremum over all `x` of the supremum over all proofs `h` of `b = x` for `f x h` is equal to `f b ⋯`. Essentially, it's saying that the double supremum of `f` over all `x` and proofs of `b = x` collapses to applying `f` directly to `b` and some unspecified values (represented by `⋯`).

For any complete lattice `α`, any `β`, a function `f` from `β` to `α`, and `b` in `β` with a proof `h` of `b = b`, the double supremum of `f x h` over all `x` and proofs `h` of `b = x` equals `f b`.


theorem Matrix.linfty_opNNNorm_def :
    ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
      [inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α),
      ‖A‖₊ = Finset.sup Finset.univ fun i => Finset.sum Finset.univ fun j => ‖A i j‖₊ :=
  by sorry

The theorem `Matrix.linfty_opNNNorm_def` states for any type `m`, `n`, and `α`, where `m` and `n` are finite types and `α` is a seminormed additively commutative group, for a matrix `A` of type `Matrix m n α`, the non-negative norm of `A` is equal to the supremum (maximum) over all rows `i` of the sum over all columns `j` of the non-negative norms of the elements of `A` at position `(i, j)`. In other words, the non-negative norm of a matrix is the maximum row sum of the non-negative norms of its elements.

For any finite types `m` and `n` and seminormed additively commutative group `α`, the non-negative matrix norm of a matrix `A` of type `Matrix m n α` equals the maximum row sum of non-negative element norms in `A`.


theorem AffineMap.lineMap_same_apply :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] (p : P1) (c : k), (AffineMap.lineMap p p) c = p :=
  by sorry

This theorem states that for any point `p` in an affine space `P1` over a ring `k` with an associated vector space `V1`, when the affine map `lineMap` is constructed from `p` to `p` (i.e., both the start and end points are the same), the image of any element `c` from the ring `k` under this map is `p` itself. Essentially, this means that a line map from a point to the same point maps all scalars to that point.

For any point `p` in an affine space `P1` over a ring `k` with associated vector space `V1`, the affine map `lineMap` constructed from `p` to `p` maps any scalar `c` from `k` to point `p` itself.


/-- The property satisfied by the circumsphere.  -/
theorem Affine.Simplex.circumsphere_unique_dist_eq :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
      ((Affine.Simplex.circumsphere s).center ∈ affineSpan ℝ (Set.range s.points) ∧
          Set.range s.points ⊆
            Metric.sphere (Affine.Simplex.circumsphere s).center (Affine.Simplex.circumsphere s).radius) ∧
        ∀ (cs : EuclideanGeometry.Sphere P),
          cs.center ∈ affineSpan ℝ (Set.range s.points) ∧ Set.range s.points ⊆ Metric.sphere cs.center cs.radius →
            cs = Affine.Simplex.circumsphere s :=
  by sorry

This theorem states that for any n-dimensional affine simplex with a normed additive commutative group structure on the underlying vector space, an inner product space over real numbers, a metric space on the points, and a normed additive group action of vectors on points, the center of the circumsphere of the simplex is in the smallest affine subspace containing the points of the simplex, and all the points of the simplex are on the sphere with the center at the center of the circumsphere and radius equal to the radius of the circumsphere. Moreover, if there exists another sphere with the same properties i.e. its center is in the affine span of the simplex points and the simplex points are on this sphere, then this sphere must be the same as the circumsphere. This essentially guarantees the uniqueness of the circumsphere for a given simplex.

For any n-dimensional affine simplex with a given normed vector space structure, inner product space over real numbers, metric space structure, and normed vector action, the center of its circumsphere is in the affine hull of its points, and all points lie on the sphere with this center and radius equal to the circumsphere's radius, making it the unique circumsphere for the simplex.


/-- Paste two pullback squares "vertically" to obtain another pullback square.  -/
theorem CategoryTheory.IsPullback.paste_vert :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
      {h₂₁ : X₂₁ ⟶ X₂₂} {h₃₁ : X₃₁ ⟶ X₃₂} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂},
      CategoryTheory.IsPullback h₁₁ v₁₁ v₁₂ h₂₁ →
        CategoryTheory.IsPullback h₂₁ v₂₁ v₂₂ h₃₁ →
          CategoryTheory.IsPullback h₁₁ (CategoryTheory.CategoryStruct.comp v₁₁ v₂₁)
            (CategoryTheory.CategoryStruct.comp v₁₂ v₂₂) h₃₁ :=
  by sorry

This theorem in Category Theory states that given two squares in a category that are designated as pullbacks, if these squares are "pasted" together vertically, the resulting larger square is also a pullback.

The pullback squares are determined by morphisms from certain objects in the category. In this theorem, the category is denoted by `C` and the objects in the category are `X₁₁, X₁₂, X₂₁, X₂₂, X₃₁, X₃₂`. The morphisms are `h₁₁, h₂₁, h₃₁` (the vertical arrows in the squares) and `v₁₁, v₁₂, v₂₁, v₂₂` (the horizontal arrows in the squares).

The theorem further states that if `h₁₁` and `v₁₁` to `v₁₂` form a pullback square with `h₂₁`, and `h₂₁` and `v₂₁` to `v₂₂` form another pullback square with `h₃₁`, then `h₁₁` and the composition of `v₁₁` and `v₂₁` to the composition of `v₁₂` and `v₂₂` also form a pullback square with `h₃₁`.

Given two pullback squares in a category with the given morphisms, if their vertical arrows compose to form another vertical arrow and the horizontal arrows compose to form another horizontal arrow, then the resulting rectangle is a pullback square.


List.Pairwise.sublist

theorem List.Pairwise.sublist :
    ∀ {α : Type u_1} {l₁ l₂ : List α} {R : α → α → Prop},
      List.Sublist l₁ l₂ → List.Pairwise R l₂ → List.Pairwise R l₁ :=
  by sorry

This theorem states that for any type `α` and any lists `l₁` and `l₂` of `α`, along with a binary relation `R` on `α`, if `l₁` is a sublist of `l₂` and `l₂` satisfies the pairwise property with respect to `R`, then `l₁` also satisfies the pairwise property with respect to `R`.

The pairwise property here means that for any two elements in the list, the relation `R` holds. Therefore, this theorem is essentially saying that if a relation holds for all pairs of elements in a list, then it will also hold for all pairs of elements in any sublist of that list.

If `l₁` is a sublist of `l₂` and all pairs of elements in `l₂` relate under `R`, then all pairs of elements in `l₁` also relate under `R`.


theorem RingHom.coe_addMonoidHom_injective :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β},
      Function.Injective fun f => ↑f :=
  by sorry

The theorem `RingHom.coe_addMonoidHom_injective` states that for any two non-associative semirings `α` and `β`, the function that maps a ring homomorphism to its underlying additive monoid homomorphism is injective. In other words, if two ring homomorphisms from `α` to `β` are equivalent as additive monoid homomorphisms, then they were the same ring homomorphism to begin with. This means that the additive structure of a ring homomorphism uniquely determines it.

Given any two ring homomorphisms between non-associative semirings, if they have the same underlying additive monoid homomorphisms, then they are equal as ring homomorphisms.


theorem Relation.transGen_eq_self : ∀ {α : Type u_1} {r : α → α → Prop}, Transitive r → Relation.TransGen r = r := by
  sorry

The theorem `Relation.transGen_eq_self` states that for any given type `α` and a relation `r` on `α`, if the relation `r` is transitive, then the transitive closure of `r` (denoted by `Relation.TransGen r`) is equal to `r` itself. The transitive closure of a relation is the smallest relation that contains the original and is transitive. This theorem therefore says that if the original relation is already transitive, then its transitive closure doesn't add any new relations.

If a relation on a type is transitive, then its transitive closure equals the relation itself.


theorem Finset.gcd_dvd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α} {b : β}, b ∈ s → Finset.gcd s f ∣ f b :=
  by sorry

The theorem `Finset.gcd_dvd` states that for any types `α` and `β`, given a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid` instance for `α`, a finite set `s` of type `β`, and a function `f` from `β` to `α`, if `b` is an element of set `s`, then the greatest common divisor of the set `s` (when each element of `s` is mapped to `α` via `f`) divides the function `f` evaluated at `b`. In other words, in mathematical terms, if $b \in s$, then $\gcd_{b' \in s} f(b') | f(b)$.

For any `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` types `α`, given a finite set `s` of type `β`, and a function `f` from `β` to `α`, if `b` is an element of set `s`, then the greatest common divisor of the set `{f(x) | x ∈ s}` divides `f(b)`.


theorem Finset.not_disjoint_iff : ∀ {α : Type u_1} {s t : Finset α}, ¬Disjoint s t ↔ ∃ a ∈ s, a ∈ t := by sorry

The theorem `Finset.not_disjoint_iff` states that for any type `α` and any two finite sets `s` and `t` of that type, the assertion that `s` and `t` are not disjoint is equivalent to the existence of an element `a` that is in both `s` and `t`. In other words, two finite sets are not disjoint if and only if there is at least one element they have in common. Here, the `Disjoint` property for two elements is defined as their greatest lower bound (infimum) being the least element of the order.

Two finite sets `s` and `t` of type `α` are not disjoint if and only if there exists an element `a` in both `s` and `t`.


theorem Part.bind_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_4} (f : α → β) (x : Part α) (g : β → Part γ),
      Part.bind (Part.map f x) g = Part.bind x fun y => g (f y) :=
  by sorry

The theorem `Part.bind_map` describes the interchangeability of "bind" and "map" operations on `Part` objects, which hold optional values. For any types `α`, `β`, and `γ`, a function `f` from `α` to `β`, a `Part` object `x` of type `α`, and a function `g` from `β` to a `Part` object of type `γ`, binding the result of mapping `f` over `x` with `g` is the same as binding `x` with the function that sends `y` to `g` applied to `f(y)`. This can be seen as a form of function composition associativity in the context of partial computations.

For any functions `f: α → β` and `g: β → Part γ`, the application of `bind` and `map` operations on a `Part α` value `x` in the order `x >>= g . f` is equivalent to `bind (f x) g`.


theorem Associates.mk_le_mk_iff_dvd_iff :
    ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, Associates.mk a ≤ Associates.mk b ↔ a ∣ b := by sorry

The theorem `Associates.mk_le_mk_iff_dvd_iff` states that for any type `α` which is a commutative monoid, and for any two elements `a` and `b` of type `α`, the statement that the associate of `a` is less than or equal to the associate of `b` is equivalent to the statement that `a` divides `b`. In other words, it provides a connection between the ordering in the associates of a commutative monoid and the divisibility relation in the original monoid.

For any commutative monoid type `α`, the relation `a ∘ x = b ∘ y` implies `a = y * x ⊢ b = x * z → a | b` (associate of `a` is less than or equal to associate of `b` if and only if `a` divides `b`).


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

The theorem `Seminorm.ball_zero_eq` states that for any seminorm `p` on a scalar multiplication structure `SMul` over an additive commutative group `E` and a seminormed ring `𝕜`, and for any real number `r`, the ball of radius `r` at `0` with respect to seminorm `p` is equal to the set of all elements `y` in `E` such that `p y < r`. In geometrical terms, this describes the set of all points in the space `E` that are less than a given distance `r` from the origin, according to the particular measure of distance given by the seminorm `p`.

For any seminorm `p` on a scalar multiplication structure `SMul` over an additive commutative group `E` and a seminormed ring `𝕜`, the ball of radius `r` centered at `0` with respect to `p` equals the set of elements `y` in `E` satisfying `p(y) < r`.


/-- **Alias** of the reverse direction of `Monoid.exponent_dvd_iff_forall_pow_eq_one`. -/
theorem Monoid.exponent_dvd_of_forall_pow_eq_one :
    ∀ {G : Type u} [inst : Monoid G] {n : ℕ}, (∀ (g : G), g ^ n = 1) → Monoid.exponent G ∣ n := by sorry

This theorem states that for any type `G` that is a Monoid, and any natural number `n`, if for every element `g` in `G`, `g` raised to the power `n` is equal to the identity element `1`, then the exponent of Monoid `G` divides `n`. In mathematical terms, this is stating that if ∀g ∈ G, g^n = 1, then the exponent of the group G divides n.

If every element in a monoid `G` raises any natural number `n` to the power equal to the identity element `1`, then the exponent of `G` divides `n`.


theorem Multiset.card_pmap :
    ∀ {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (s : Multiset α) (H : ∀ a ∈ s, p a),
      Multiset.card (Multiset.pmap f s H) = Multiset.card s :=
  by sorry

The theorem `Multiset.card_pmap` states that for any type `α` and `β`, a predicate `p` on `α`, a function `f` from `a` of type `α` satisfying the predicate `p` to `β`, a multiset `s` of type `α`, and a proof `H` that all elements of `s` satisfy `p`, the cardinality of the multiset obtained by applying the partially mapped function `f` to `s` is equal to the cardinality of `s`. In other words, applying a function to each element of a multiset does not change its size.

For any multiset `s` of type `α`, function `f` from `α` to `β`, and proof `H` that all elements of `s` satisfy `p(x): α -> Prop`, the cardinalities of `s` and `{x : β | ∃ (y : α), p(y) ∧ f(y) = x}` are equal.


theorem WeierstrassCurve.Affine.monic_polynomial :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R), Polynomial.Monic W.polynomial := by sorry

The theorem states that for any commutative ring `R`, every affine Weierstrass curve `W` over `R` has a polynomial which is monic. Here, a polynomial being monic means that its leading coefficient is 1. Therefore, the leading coefficient of the polynomial of every affine Weierstrass curve over any commutative ring is 1.

Every affine Weierstrass curve over a commutative ring has a monic polynomial defining it.


theorem CategoryTheory.Limits.Fork.app_one_eq_ι_comp_left :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      (s : CategoryTheory.Limits.Fork f g),
      s.π.app CategoryTheory.Limits.WalkingParallelPair.one =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι s) f :=
  by sorry

The theorem `CategoryTheory.Limits.Fork.app_one_eq_ι_comp_left` states that, for any category `C`, any objects `X` and `Y` in `C`, and any morphisms `f` and `g` from `X` to `Y`, if `s` is a fork on `f` and `g`, then the application of the projection function `s.π.app` at `CategoryTheory.Limits.WalkingParallelPair.one` is the same as the composition of the inclusion morphism `CategoryTheory.Limits.Fork.ι s` and the morphism `f`. In other words, in the context of category theory, this theorem relates the projection from a fork to a certain composition of morphisms in the category.

For any category C, given objects X and Y, morphisms f and g from X to Y, and a fork s on f and g, the projection function s.π.app at CategoryTheory.Limits.WalkingParallelPair.one equals the composition of the inclusion morphism ιs and f.


theorem ProbabilityTheory.kernel.Indep.indepSet_of_measurableSet :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m₁ m₂ m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.Indep m₁ m₂ κ μ →
        ∀ {s t : Set Ω}, MeasurableSet s → MeasurableSet t → ProbabilityTheory.kernel.IndepSet s t κ μ :=
  by sorry

This theorem states that for any two types `α` and `Ω`, given measure spaces on both `α` and `Ω`, a kernel from `α` to `Ω`, and a measure on `α`, if the two measure spaces on `Ω` are independent with respect to the kernel and the measure, then for any two measurable sets in `Ω`, these two sets are independent. In other words, if the measure spaces generated by two sets are independent, then the sets themselves are independent in the sense of probability theory.

If two measure spaces on types `Ω` are independent with respect to a kernel and a measure on type `α`, then any two measurable sets in `Ω` are independent events.


theorem Module.Finite.of_restrictScalars_finite :
    ∀ (R : Type u_6) (A : Type u_7) (M : Type u_8) [inst : CommSemiring R] [inst_1 : Semiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module A M] [inst_5 : Algebra R A]
      [inst_6 : IsScalarTower R A M] [hM : Module.Finite R M], Module.Finite A M :=
  by sorry

This theorem states that for any types `R`, `A`, and `M` representing a commutative semiring, a semiring, and an add commutative monoid respectively, given that `M` is a module over both `R` and `A`, and `A` is an algebra over `R`, and there is an scalar tower of R, A and M, if `M` is a finitely generated module over `R`, then `M` is also a finitely generated module over `A`. Here, a finitely generated module over a ring is a module that has a finite set of generators.

If `R` is a commutative semiring, `A` is a semiring and an algebra over `R`, `M` is an add commutative monoid and an `R`-module as well as an `A`-module with a scalar tower, and `M` is finitely generated as an `R`-module, then `M` is finitely generated as an `A`-module.


theorem SetTheory.PGame.add_congr : ∀ {w x y z : SetTheory.PGame}, w ≈ x → y ≈ z → w + y ≈ x + z := by sorry

This theorem states that in the context of set theory, and more specifically in the theory of Games, if two games `w` and `x` are equivalent, and two other games `y` and `z` are also equivalent, then the game obtained by adding `w` and `y` is equivalent to the game obtained by adding `x` and `z`. Here, equivalence (≈) between two games means that they have the same outcome when played by perfect players.

If games `w` and `x`, and `y` and `z` are equivalent in set theory's games theory context, then `w + y` and `x + z` are equivalent. (Here, `+` denotes the game sum operation, and equivalence means having the same outcome for perfect players.)


theorem Primrec.option_casesOn :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {o : α → Option β} {f : α → σ} {g : α → β → σ},
      Primrec o → Primrec f → Primrec₂ g → Primrec fun a => Option.casesOn (o a) (f a) (g a) :=
  by sorry

This theorem states that for any types `α`, `β`, and `σ` that are primcodable (that is, there is a way to represent their elements as natural numbers), given a function `o` mapping from `α` to `Option β`, a function `f` mapping from `α` to `σ`, and a binary function `g` mapping from `α` and `β` to `σ`, if `o`, `f`, and `g` are all primitive recursive (meaning they can be computed by a sequence of basic operations), then the function that takes an element of `α`, applies `o` to it and uses `Option.casesOn` to either apply `f` or `g` depending on whether `o` returns `None` or `Some`, is also primitive recursive.

Given primcodable types `α`, `β`, and `σ`, if `o`: `α -> Option β`, `f: α -> σ`, and `g: α x β -> σ` are primitive recursive functions, then the function `x => Option.casesOn o x (λ none => f x) (λ some => g x some)` is also primitive recursive.


/-- An intermediate field is closed under inverses.  -/
theorem IntermediateField.inv_mem :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      (S : IntermediateField K L) {x : L}, x ∈ S → x⁻¹ ∈ S :=
  by sorry

This theorem states that an intermediate field is closed under the operation of taking inverses. More specifically, for any fields `K` and `L` with `L` being an algebra over `K`, and `S` being an intermediate field between `K` and `L`, if an element `x` from `L` is in `S`, then the inverse of `x` (denoted `x⁻¹`) is also in `S`. This means that taking the inverse of any element in the intermediate field will yield another element that also belongs to the intermediate field.

If `K` is a field, `L` is an algebra over `K`, `S` is an intermediate field between `K` and `L`, and `x` is an element of `L` in `S`, then `x⁻¹` is also in `S`.


theorem Prod.map_def :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ},
      Prod.map f g = fun p => (f p.1, g p.2) :=
  by sorry

The theorem `Prod.map_def` states that for any types `α`, `β`, `γ`, and `δ` and any functions `f : α → γ` and `g : β → δ`, the function `Prod.map f g` is the same as the function that takes a pair `p` and returns a new pair, where the first element is the result of applying `f` to the first element of `p` and the second element is the result of applying `g` to the second element of `p`, i.e., `(f p.1, g p.2)`. In other words, `Prod.map` applies `f` to the first component and `g` to the second component of a pair, as its name suggests.

For functions `f : α → γ` and `g : β → δ`, `Prod.map f g` equals the function that maps a pair `(x, y)` to `(f x, g y)`.


theorem MeasureTheory.OuterMeasure.map_apply :
    ∀ {α : Type u_1} {β : Type u_5} (f : α → β) (m : MeasureTheory.OuterMeasure α) (s : Set β),
      ↑((MeasureTheory.OuterMeasure.map f) m) s = ↑m (f ⁻¹' s) :=
  by sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, an outer measure `m` on `α`, and a set `s` of `β`, the application of the mapped outer measure of `m` along `f` on the set `s` is equal to the application of `m` on the preimage of `s` under `f`. In mathematical terms, if `f` is a function mapping from `α` to `β`, `m` is an outer measure on `α`, and `s` is a set in `β`, then applying the outer measure induced by `f` on `m` to `s` is the same as applying `m` to the preimage of `s` under `f`.

For any function \(f: \alpha \to \beta\), outer measure \(m\) on \(\alpha\), and set \(s \subseteq \beta\), \(m^{\mathcal{L}}(f^{-1}(s)) = \mathcal{L}(m)(f)(s)\). Here, \(m^{\mathcal{L}}\) denotes the outer measure induced by \(f\) and \(\mathcal{L}(m)\) denotes the original outer measure on \(\alpha\).


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

This theorem states that for all types `α` that form a Generalized Coheyting Algebra, given any two elements `a` and `b` of `α`, the supremum (or the least upper bound) of `a` and the difference of `b` and `a` is equivalent to the supremum of `a` and `b`. In mathematical terms, we have `a ∨ (b \ a) = a ∨ b` for all elements `a` and `b` in the algebra.

For all types `α` that form a lattice and for all elements `a, b` in `α`, the supremum of `a` and the difference `b - a` is equal to the supremum of `a` and `b`.


theorem Multiset.filter_le :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α), Multiset.filter p s ≤ s := by sorry

The theorem `Multiset.filter_le` asserts that for any type `α`, any given decidable predicate `p` on elements of `α`, and any multiset `s` of type `α`, the multiset obtained by filtering `s` using the predicate `p` is a subset of (or equal to) `s`. In other words, no new elements are introduced in the multiset by the filter operation, it only potentially removes elements that don't satisfy the predicate.

For any type `α`, decidable predicate `p` on `α`, and multiset `s` of type `α`, the filtered multiset `Multiset.filter p s` is a subset of `s`.


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

The theorem `nsmul_lt_nsmul_left` states that for any type `M` that is an ordered additive monoid (it satisfies properties of an additive monoid and a preorder), if `a` is a positive element of `M` and `n` and `m` are natural numbers such that `n` is less than `m`, then the n-times repeated addition of `a` (denoted `n • a`) is less than the m-times repeated addition of `a` (denoted `m • a`).

For any ordered additive monoid M, positive element a, and natural numbers n < m, n • a < m • a.


theorem Set.Icc_subset_Icc_iff :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α},
      a₁ ≤ b₁ → (Set.Icc a₁ b₁ ⊆ Set.Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂) :=
  by sorry

The theorem `Set.Icc_subset_Icc_iff` is a statement about intervals on a preorder. Specifically, for any type `α` equipped with a preorder, and any four elements `a₁`, `a₂`, `b₁`, `b₂` of `α` such that `a₁` is less than or equal to `b₁`, the interval `[a₁, b₁]` is a subset of the interval `[a₂, b₂]` if and only if `a₂` is less than or equal to `a₁` and `b₁` is less than or equal to `b₂`. Here, `[a, b]` denotes the closed interval from `a` to `b`, i.e., the set of all elements `x` such that `a ≤ x ≤ b`.

For any preorder `α` and elements `a₁`, `a₂`, `b₁`, `b₂` in `α` with `a₁ ≤ b₁`, the intervals `[a₁, b₁]` and `[a₂, b₂]` are equal if and only if `a₁ ≤ a₂` and `b₁ ≤ b₂`. (Note: `[a, b]` denotes the closed interval from `a` to `b`.)


theorem Sum.inl_ne_inr : ∀ {α : Type u_1} {a : α} {β : Type u_2} {b : β}, Sum.inl a ≠ Sum.inr b := by sorry

This theorem states that, for any types `α` and `β` and any elements `a` of `α` and `b` of `β`, the `Sum.inl a` is not equal to `Sum.inr b`. In other words, the left injection of an element into the sum type is never equal to the right injection of a different type. This is a fundamental property of disjoint union types in type theory.

For any types `α` and `β` and elements `a : α` and `b : β`, `Sum.inl a` is not equal to `Sum.inr b`.


theorem IntermediateField.minpoly_eq :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      {S : IntermediateField K L} (x : ↥S), minpoly K x = minpoly K ↑x :=
  by sorry

The theorem `IntermediateField.minpoly_eq` states that for any fields `K` and `L` with algebra structure between them, and any intermediate field `S` between `K` and `L`, the minimal polynomial of an element `x` from `S` (considered as an element of `S`) is the same as the minimal polynomial of `x` considered as an element of the larger field `L` (i.e., `x` is coerced to `L`). The minimal polynomial is a key concept in field theory and algebra, which gives the polynomial with coefficients in `K` that `x` is a root of and no other polynomial with lower degree has `x` as a root.

For any fields `K` and `L` with algebra structure between them and an intermediate field `S` between `K` and `L`, the minimal polynomial of an element `x` in `S` regarded as an element of both `S` and `L` is equal.


theorem Equiv.Perm.extendDomain_apply_not_subtype :
    ∀ {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [inst : DecidablePred p] (f : α' ≃ Subtype p)
      {b : β'}, ¬p b → (Equiv.Perm.extendDomain e f) b = b :=
  by sorry

The theorem `Equiv.Perm.extendDomain_apply_not_subtype` states that for any types `α'` and `β'`, any permutation `e` on `α'`, any decidable predicate `p` on `β'`, and any equivalence `f` between `α'` and the subtype of `β'` satisfying `p`, if an element `b` from `β'` does not satisfy the predicate `p`, then applying the extended permutation `Equiv.Perm.extendDomain e f` to `b` leaves `b` unchanged. In other words, the extended permutation does not alter elements which do not satisfy the predicate.

For any equivalence `f` between types `α'` and a subtype of `β'` satisfying a decidable predicate `p` on `β'`, and any permutation `e` on `α'`, if an element `b` from `β'` does not satisfy `p`, then `Equiv.Perm.extendDomain e f b = b`.


theorem MeasureTheory.Measure.restrict_eq_self_of_ae_mem :
    ∀ {α : Type u_2} {_m0 : MeasurableSpace α} ⦃s : Set α⦄ ⦃μ : MeasureTheory.Measure α⦄,
      (∀ᵐ (x : α) ∂μ, x ∈ s) → μ.restrict s = μ :=
  by sorry

This theorem is about measure theory in the context of measurable spaces. It states that for any type `α` and any measurable space `_m0` of type `α`, given a set `s` of type `α` and a measure `μ` (from the measure theory) on `α`, if almost everywhere (with respect to the measure `μ`) an element `x` of type `α` belongs to the set `s`, then the restriction of the measure `μ` to the set `s` is equal to the measure `μ` itself. In other words, when almost every point in the space is in `s`, restricting the measure to `s` doesn't change the measure.

If a set `s` is almost everywhere equal to a measurable space `μ` with respect to measure `μ`, then the restriction of `μ` to `s` is equal to `μ`.