theorem separated_by_continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space Y]
      {f : X → Y}, Continuous f → ∀ {x y : X}, f x ≠ f y → ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v :=
  by sorry

This theorem, `separated_by_continuous`, states that for any two types `X` and `Y` with `X` and `Y` being topological spaces and `Y` being a `T2Space` (also known as a Hausdorff space), if there exists a continuous function `f` from `X` to `Y`, then for any two distinct elements `x` and `y` in `X` (i.e., `f(x)` and `f(y)` are not equal), there exist two open sets `u` and `v` such that `x` is in `u`, `y` is in `v`, and `u` and `v` are disjoint. This is essentially a formulation of the separation axiom in topology that in a Hausdorff space, distinct points can be separated by open neighborhoods.

In a Hausdorff space, for any two distinct points, there exist disjoint open sets containing each point.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β}
      {μc : MeasureTheory.Measure γ} {g : β → γ} {f : α → β},
      MeasureTheory.Measure.QuasiMeasurePreserving g μb μc →
        MeasureTheory.Measure.QuasiMeasurePreserving f μa μb →
          MeasureTheory.Measure.QuasiMeasurePreserving (g ∘ f) μa μc :=
  by sorry

This theorem states that if we have three types α, β, and γ with corresponding measurable spaces and measures μa, μb, and μc, and two functions f: α → β and g: β → γ, then if g is quasi-measure preserving between μb and μc, and f is quasi-measure preserving between μa and μb, the composition function (g ∘ f) is quasi-measure preserving between μa and μc. In other words, the property of being quasi-measure preserving is preserved under function composition.

If functions f: α → β and g: β → γ are quasi-measure preserving between measurable spaces with measures μa, μb, and μc, respectively, then the composition function g ∘ f is quasi-measure preserving between μa and μc.


theorem WithTop.preimage_coe_Ici :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithTop.some ⁻¹' Set.Ici ↑a = Set.Ici a := by sorry

This theorem states that for any type `α` equipped with a preorder structure and for any element `a` of type `α`, the preimage of the left-closed right-infinite interval starting at the element `a` under the canonical map from `α` into `WithTop α` is equal to the left-closed right-infinite interval starting at `a`. In other words, for all elements from `a` and above (inclusive), their images under the embedding into `WithTop α` are precisely the elements from `a` and above in the `WithTop α` set.

For any preordered type `α` and element `a` in `α`, the image of the left-closed right-infinite interval [a, ∞) under the embedding of `α` into `WithTop α` is equal to the left-closed right-infinite interval [a, ∞) in `WithTop α`.


theorem IsCoprime.mul_left :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime x z → IsCoprime y z → IsCoprime (x * y) z := by sorry

The theorem `IsCoprime.mul_left` states that for any type `R` that is a commutative semiring, if `x` and `z` are coprime and `y` and `z` are coprime, then the product of `x` and `y` is also coprime with `z`. In mathematical terms, if there exist numbers `a` and `b` such that `a * x + b * z = 1`, and numbers `c` and `d` such that `c * y + d * z = 1`, then there must exist numbers `e` and `f` such that `e * (x * y) + f * z = 1`.

If `x` and `z` are coprime, and `y` and `z` are coprime in a commutative semiring `R`, then `x * y` is coprime with `z`.


theorem cocompact_eq_atBot_atTop :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : NoMaxOrder α]
      [inst_3 : NoMinOrder α] [inst_4 : OrderClosedTopology α] [inst_5 : CompactIccSpace α],
      Filter.cocompact α = Filter.atBot ⊔ Filter.atTop :=
  by sorry

The theorem `cocompact_eq_atBot_atTop` states that for any type `α` that has a linear order, a topology, and no maximum or minimum elements (i.e., it extends indefinitely in both positive and negative directions), with the topology being closed with respect to the order and the space of all closed intervals being compact, the filter generated by the complements of compact sets (i.e., the cocompact filter) is equal to the join of the filters representing the limits to negative infinity (`atBot`) and positive infinity (`atTop`). In simpler terms, in such a set, the notion of "going to infinity in either direction" is equivalent to "running out of compact sets".

For a type `α` with a linear order, topology, no maximum or minimum elements, a compact space of intervals, and a topology closed with respect to the order, the cocompact filter is equal to the join of filters `atBot` and `atTop`.


theorem Polynomial.degree_lt_wf :
    ∀ {R : Type u} [inst : Semiring R], WellFounded fun p q => Polynomial.degree p < Polynomial.degree q := by sorry

The theorem `Polynomial.degree_lt_wf` states that for all semirings `R`, the relation "having a strictly lesser degree" (`Polynomial.degree p < Polynomial.degree q`) on the set of polynomials with coefficients in `R` is well-founded. In other words, it implies that there are no infinite decreasing sequences of polynomial degrees. This is a fundamental property in the theory of polynomials which is used in many arguments involving induction on the degree of a polynomial.

The relation "having a strictly lesser degree" on polynomials over a semiring is a well-founded relation.


/-- Cancel left multiplication in the modulus.

For cancelling left multiplication on both sides of the `≡`, see `nat.modeq.mul_left_cancel'`.  -/
theorem Nat.ModEq.of_mul_left : ∀ {n a b : ℕ} (m : ℕ), a ≡ b [MOD m * n] → a ≡ b [MOD n] := by sorry

This theorem, `Nat.ModEq.of_mul_left`, states that for all natural numbers `n`, `a`, `b`, and `m`, if `a` is congruent to `b` modulo `m * n`, then `a` is also congruent to `b` modulo `n`. This allows for cancellation of left-multiplication in modulus calculations. Note that if you need to cancel left multiplication on both sides of the congruence, you should refer to a different theorem, `nat.modeq.mul_left_cancel'`.

If `a` is congruent to `b` modulo `m`, then `a` is congruent to `b` modulo `n` for `m = nk`, where `k` is a natural number. (This implies that left cancellation is allowed in modulo arithmetic when the moduli are multiple of a common factor.)


MeasureTheory.Lp.stronglyMeasurable

theorem MeasureTheory.Lp.stronglyMeasurable :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), MeasureTheory.StronglyMeasurable ↑↑f :=
  by sorry

This theorem states that for any measurable space `α`, normed addative commutative group `E`, measure `μ` on `α`, and function `f` in the `Lp` space over `E` with respect to `μ` and a nonnegative extended real number `p`, the function `f` is strongly measurable. Strongly measurable here means that the function `f` is the limit of a sequence of simple functions.

Any `Lp` function on a measurable space with respect to a measure is strongly measurable.


ContDiffAt.sub

/-- The difference of two `C^n` functions at a point is `C^n` at this point.  -/
theorem ContDiffAt.sub :
    ∀ {𝕜 : 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] {x : E}
      {n : ℕ∞} {f g : E → F}, ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n g x → ContDiffAt 𝕜 n (fun x => f x - g x) x :=
  by sorry

This theorem states that for any two functions `f` and `g` which are continuously differentiable of order `n` at a given point `x` in a normed additive commutative group `E` with a normed space over a nontrivially normed field `𝕜`, the difference of these two functions, `(f - g)`, is also continuously differentiable of the same order `n` at the point `x`. This is stated in the context of function spaces `F` which are also normed additive commutative groups with a normed space over the same nontrivially normed field `𝕜`.

If `f` and `g` are continuously differentiable of order `n` at point `x` in the normed additive commutative group `E` over the nontrivially normed field `𝕜`, then their difference `(f - g)` is also continuously differentiable of order `n` at point `x`.


theorem ULift.up_bijective : ∀ {α : Type u}, Function.Bijective ULift.up := by sorry

The theorem `ULift.up_bijective` states that for any type `α`, the function `ULift.up` is bijective. In other words, it asserts that the function `ULift.up`, which takes a value of some type and lifts it to a value of the same type within the `ULift` type wrapper, is both injective (no two different inputs produce the same output) and surjective (for every possible output there is at least one corresponding input).

The `ULift.up` function from type `α` to `ULift α` is a bijective function.


HasFDerivAtFilter.add

theorem HasFDerivAtFilter.add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
      {f' g' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L → HasFDerivAtFilter g g' x L → HasFDerivAtFilter (fun y => f y + g y) (f' + g') x L :=
  by sorry

This theorem states that if we have two functions `f` and `g` from a normed additivity commutative group `E` to another such group `F` (both over a non-trivially normed field `𝕜`), and if `f` has a derivative `f'` at a point `x` with respect to a filter `L` and `g` has a derivative `g'` at the same point with respect to the same filter, then the function defined by the sum of `f` and `g` has a derivative at `x` with respect to `L`, which is the sum of the derivatives `f'` and `g'`. This encapsulates the rule of differentiation that the derivative of the sum of two functions is the sum of their derivatives.

If `f` and `g` are differentiable functions from a normed additive commutative group `E` to another such group `F` over a non-trivially normed field `𝕜`, then the sum `f + g` is differentiable at a point `x` with respect to a filter `L` if and only if both `f` and `g` are, and the derivative of their sum is the sum of their derivatives: `(f + g)'(x) = f'(x) + g'(x)`.


theorem Finset.coe_vadd :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : VAdd α β] (s : Finset α) (t : Finset β),
      ↑(s +ᵥ t) = ↑s +ᵥ ↑t :=
  by sorry

The theorem `Finset.coe_vadd` states that for any types `α` and `β`, given `α` has a vector addition operation and `β` has a decidable equality, for any finite sets `s` of type `α` and `t` of type `β`, the operation of lifting `s` to the type `β` and then adding `t` (notated `↑(s +ᵥ t)`) is the same as first lifting `s` and `t` to the type `β` and then adding them (notated `↑s +ᵥ ↑t`). This theorem essentially guarantees the compatibility of the vector addition operation with the type-lifting operation in the context of finite sets.

For any types `α` with vector addition and decidable equality `β`, the operation of lifting a finite set `s` of type `α` to type `β` and then performing vector addition with another finite set `t` of type `β` is equivalent to first lifting `s` and `t` separately and then performing vector addition.


theorem UniqueFactorizationMonoid.irreducible_of_factor :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
      ∀ x ∈ UniqueFactorizationMonoid.factors a, Irreducible x :=
  by sorry

This theorem states that for any type `α` that has both a `CancelCommMonoidWithZero` and a `UniqueFactorizationMonoid` structure, any element `x` that appears in the multiset of prime factors of another element `a` of the type `α` is irreducible. The term "irreducible" in this context refers to elements that cannot be expressed as a product of two non-unit elements. This is a key property of prime factors in the context of unique factorization domains, essentially saying that the prime factors of a number are themselves prime.

For any type `α` equipped with both a `CancelCommMonoidWithZero` and a `UniqueFactorizationMonoid` structure, every prime factor is irreducible.


Quot.eq

theorem Quot.eq : ∀ {α : Type u_3} {r : α → α → Prop} {x y : α}, Quot.mk r x = Quot.mk r y ↔ EqvGen r x y := by sorry

This theorem, `Quot.eq`, states that for any type `α` and a binary relation `r` on `α`, two quotients `Quot.mk r x` and `Quot.mk r y` are equal if and only if `x` and `y` generate the same equivalence relation under `r`. Equivalently, `x` and `y` are related by the smallest equivalence relation containing `r`. This theorem links the notion of equality in the quotient type to the underlying relation that defines the equivalence classes of the quotient type.

For any type `α` and binary relation `r` on `α`, `Quot.mk r x = Quot.mk r y` if and only if `x` and `y` are equivalent under the smallest equivalence relation containing `r`.


/-- Given any distinguished triangle
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
the composition `f ≫ g = 0`.
See <https://stacks.math.columbia.edu/tag/0146>
 -/
theorem CategoryTheory.Pretriangulated.comp_distTriang_mor_zero₁₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        CategoryTheory.CategoryStruct.comp T.mor₁ T.mor₂ = 0 :=
  by sorry

This theorem states that in any category `C` that has a zero object, supports shifting by integers, is preadditive, and is pretriangulated, for any distinguished triangle in `C` (represented as a diagram with morphisms `f`, `g`, and `h` going from `X` to `Y`, `Y` to `Z`, and `Z` to `X⟦1⟧` respectively), the composition of the first two morphisms `f` and `g` is equal to the zero morphism. This property is a fundamental characteristic of distinguished triangles in pretriangulated categories.

In any pretriangulated preadditive category with a zero object, the composition of morphisms in a distinguished triangle is equal to the zero morphism.


theorem Multiset.rel_eq : ∀ {α : Type u_1} {s t : Multiset α}, Multiset.Rel (fun x x_1 => x = x_1) s t ↔ s = t := by
  sorry

This theorem states that for any type `α` and any two multisets `s` and `t` of type `α`, the relation `Multiset.Rel (fun x x_1 => x = x_1) s t` holds if and only if `s` and `t` are equal. In other words, the `Multiset.Rel` equivalence relation, which compares elements of two multisets based on simple equality of their elements, is equivalent to the equality of the multisets themselves.

For any type `α` and multisets `s` and `t` of type `α`, `Multiset.Rel (fun x x_1 => x = x_1) s t` if and only if `s` equals `t`.


theorem LieSubalgebra.lie_mem :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      (L' : LieSubalgebra R L) {x y : L}, x ∈ L' → y ∈ L' → ⁅x, y⁆ ∈ L' :=
  by sorry

This theorem states that, for any commutative ring `R` and any Lie ring `L` that also carries a Lie algebra structure over `R`, if `L'` is a Lie subalgebra of `R` and `L`, and if `x` and `y` are elements of `L'`, then the Lie bracket (denoted as `[x, y]`) of `x` and `y` is also an element of `L'`. In other words, the Lie bracket of any two elements in a Lie subalgebra remains within the same subalgebra.

For any commutative ring `R`, if `L` is a Lie subalgebra of the Lie algebra `L` over `R`, then the Lie bracket of any two elements in `L` lies in `L`.


/-- When lowered to a prop, `Matrix.invertibleEquivDetInvertible` forms an `iff`.  -/
theorem Matrix.isUnit_iff_isUnit_det :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      IsUnit A ↔ IsUnit (Matrix.det A) :=
  by sorry

This theorem states that for any square matrix `A` of a certain type `α` with its rows and columns indexed by a finite type `n`, the matrix `A` is a unit (i.e., it has a two-sided inverse) if and only if the determinant of `A` is a unit. This is within a context where `n` is a finite type, `α` has a commutative ring structure, and equality of `n` elements is decidable. In other words, a matrix is invertible if and only if its determinant is non-zero and hence invertible in the commutative ring `α`.

A square matrix of finite type `n` over a commutative ring `α` with decidable equality is invertible if and only if its determinant is a non-zero unit in `α`.


theorem Disjoint.le_of_codisjoint :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] {a b c : α},
      Disjoint a b → Codisjoint b c → a ≤ c :=
  by sorry

The theorem states that in a distributive lattice with a bounded order, if two elements 'a' and 'b' are disjoint (i.e., their infimum is the bottom element) and 'b' and another element 'c' are codisjoint (i.e., their supremum is the top element), then 'a' is less than or equal to 'c'.

In a distributive lattice with a bounded order, if two elements are disjoint and their complements are codisjoint, then the first element is below the third element.


LieSubalgebra.ext

theorem LieSubalgebra.ext :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      (L₁' L₂' : LieSubalgebra R L), (∀ (x : L), x ∈ L₁' ↔ x ∈ L₂') → L₁' = L₂' :=
  by sorry

The theorem `LieSubalgebra.ext` states that for all given types `R` and `L`, where `R` has a Commutative Ring structure, `L` has a Lie Ring structure, and `L` is a Lie algebra over `R`, if we have two Lie subalgebras `L₁'` and `L₂'` of `L` over `R`, then these subalgebras are equal if and only if for all elements `x` in `L`, `x` is in `L₁'` if and only if `x` is in `L₂'`. In other words, two Lie subalgebras are equal if they contain exactly the same elements.

Two Lie subalgebras of a Lie algebra over a commutative ring are equal if and only if they have the same elements.


theorem AList.toFinmap_eq :
    ∀ {α : Type u} {β : α → Type v} {s₁ s₂ : AList β},
      AList.toFinmap s₁ = AList.toFinmap s₂ ↔ List.Perm s₁.entries s₂.entries :=
  by sorry

The theorem `AList.toFinmap_eq` states that for any types `α` and `β : α → Type v`, and for any two `AList`s `s₁` and `s₂`, the `AList.toFinmap` of `s₁` is equal to the `AList.toFinmap` of `s₂` if and only if the entries of `s₁` are a permutation of the entries of `s₂`. In other words, two `AList`s have the same `Finmap` representation if and only if their entries can be rearranged to form each other.

For any types `α` and `β : α → Type v`, the `AList.toFinmap` of two `AList`s of type `α` are equal if and only if their entries are permutations of each other.


/-- Reorder a product.

The difference with `Finset.prod_nbij` is that the bijection is specified with an inverse, rather
than as a surjective injection.

The difference with `Finset.prod_bij'` is that the bijection and its inverse are non-dependent
functions, rather than being allowed to use membership of the domains of the products.

The difference with `Finset.prod_equiv` is that bijectivity is only required to hold on the domains
of the products, rather than on the entire types.
 -/
theorem Finset.prod_nbij' :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (i : ι → κ) (j : κ → ι),
      (∀ a ∈ s, i a ∈ t) →
        (∀ a ∈ t, j a ∈ s) →
          (∀ a ∈ s, j (i a) = a) →
            (∀ a ∈ t, i (j a) = a) →
              (∀ a ∈ s, f a = g (i a)) → (Finset.prod s fun x => f x) = Finset.prod t fun x => g x :=
  by sorry

This theorem, `Finset.prod_nbij'`, states that for any two finite sets `s` of type ι and `t` of type κ, along with a function `f` mapping elements of `s` to any Commutative Monoid `α`, and a function `g` mapping elements of `t` to the same `α`, if there exists bijective mappings `i : ι → κ` and `j : κ → ι` which are inverses of each other on the domains of `s` and `t` respectively, and the function `f` applied on any element of `s` is equal to the function `g` applied on the image of that element under `i`, then the product of `f x` as `x` ranges over the elements of `s` is equal to the product of `g x` as `x` ranges over the elements of `t`.

In simpler terms, this theorem states that if you have two finite sets and a function on each set such that the functions are equal when transformed by a bijection, then the total product of each function over its respective set is the same.

If two functions from finite sets to a commutative monoid are related by a bijection between the sets and are equal on the images of the sets under the bijection, then their respective products over the sets are equal.


/-- An alternative definition of the gauge using scalar multiplication on the element rather than on
the set.  -/
theorem gauge_def' :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} {x : E},
      gauge s x = sInf {r | r ∈ Set.Ioi 0 ∧ r⁻¹ • x ∈ s} :=
  by sorry

This theorem provides an alternative definition of the Minkowski functional (or gauge) for a given set `s` in a real vector space and an element `x`. In this alternative definition, the gauge of `s` at `x` is defined as the infimum (greatest lower bound) of the set of all real numbers `r` greater than 0 such that `x` is in `s` scaled by `1/r`, i.e., `x` is in the set obtained by scaling `s` by the multiplicative inverse of `r`. This contrasts with the usual definition where the gauge is defined as the infimum of the set of all `r` such that `x` is in `s` scaled by `r`.

The Minkowski functional of a set `s` in a real vector space at an element `x` is the infimum of all `r > 0` such that `x` is in the set obtained by scaling `s` by the multiplicative inverse of `r`.


theorem Set.mem_add : ∀ {α : Type u_2} [inst : Add α] {s t : Set α} {a : α}, a ∈ s + t ↔ ∃ x ∈ s, ∃ y ∈ t, x + y = a :=
  by sorry

This theorem states that for any type `α` that has an addition operation, given two sets `s` and `t` of type `α` and an element `a` of type `α`, `a` belongs to the set resulting from the addition of `s` and `t` if and only if there exists an element `x` in `s` and an element `y` in `t` such that `x + y = a`. In other words, an element is in the sum of two sets if it can be written as the sum of an element from each set.

For any type `α` with addition and sets `s` and `t` of type `α`, an element `a` belongs to the sum `s ++ t` if and only if there exist `x ∈ s` and `y ∈ t` such that `x + y = a`.


theorem NNReal.toNNReal_coe_nat : ∀ (n : ℕ), Real.toNNReal ↑n = ↑n := by sorry

This theorem states that for any natural number `n`, when it is co-erced (i.e., converted) to a real number and then reinterpreted as a non-negative real number using the `Real.toNNReal` function, it remains the same after being co-erced to a non-negative real number directly. In other words, the two operations of first converting a natural number to a real number and then applying the `Real.toNNReal` function, and the operation of directly co-ercing the natural number to a non-negative real number, are equivalent for all natural numbers.

For any natural number `n`, `Real.toNNReal (realOfNat n) = realOfNat (natIntToReal n)`, where `natIntToReal` is the function converting a natural number to a real number.


theorem Quaternion.normSq_def' :
    ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R),
      Quaternion.normSq a = a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 :=
  by sorry

This theorem states that for any Quaternion `a` over a Commutative Ring `R`, the square of the norm of `a` is equal to the sum of squares of the real part of `a`, the coefficient of `i` in `a`, the coefficient of `j` in `a`, and the coefficient of `k` in `a`. That is, if a Quaternion `a` is understood as a + bi + cj + dk, then the square of its norm is a² + b² + c² + d². This theorem is a formalization of the calculation of the square of the norm (magnitude squared) of a quaternion in the mathematical field of Quaternion Algebra.

For any quaternion a over a commutative ring, the norm of a squared equals the sum of the squares of its real and imaginary parts.


MonCat.ext

theorem MonCat.ext : ∀ {X Y : MonCat} {f g : X ⟶ Y}, (∀ (x : ↑X), f x = g x) → f = g := by sorry

The theorem `MonCat.ext` states that for any two objects `X` and `Y` in the category of monoids `MonCat`, and for any two morphisms `f` and `g` from `X` to `Y`, if `f` and `g` agree on each element `x` of `X` (i.e., `f x = g x` for all `x` in `X`), then `f` and `g` must be the same morphism. This theorem establishes that morphisms in the category of monoids are determined by their action on the elements of the source monoid.

In the category of monoids, two morphisms between objects agreeing on all elements are equal.


theorem instCoeTCInfTopHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Inf α] [inst_2 : Inf β]
      [inst_3 : Top α] [inst_4 : Top β] [inst_5 : InfTopHomClass F α β] (f : F), f ⊤ = ⊤ :=
  by sorry

This theorem states that for any types `F`, `α`, and `β`, if `F` is function-like from `α` to `β`, and `α` and `β` both have an infimum operation and a top element, and `F` is an infimum and top homomorphism from `α` to `β`, then for any function `f` of type `F`, the top element of `α` is mapped to the top element of `β` by `f`. In effect, this says that `f` preserves the top element under the conditions specified.

If `F` is a function-like type from infinitely-decreasing `α` to infinitely-decreasing `β`, with `α` and `β` having infima and tops, and `F` is an infima and top homomorphism, then `F` maps the top element of `α` to the top element of `β`.


theorem instCoeTCInfTopHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Inf α] [inst_2 : Inf β]
      [inst_3 : Top α] [inst_4 : Top β] [inst_5 : InfTopHomClass F α β] (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b :=
  by sorry

The theorem `instCoeTCInfTopHom.proof_1` states that for any types `F`, `α`, and `β`, if `F` is function-like from `α` to `β` (expressed by `[inst : FunLike F α β]`), `α` and `β` have an infimum operation (expressed by `[inst_1 : Inf α]` and `[inst_2 : Inf β]`), a top element (expressed by `[inst_3 : Top α]` and `[inst_4 : Top β]`), and `F` is a class of infimum-preserving functions from `α` to `β` (expressed by `[inst_5 : InfTopHomClass F α β]`), then for any function `f` of type `F` and any elements `a` and `b` of `α`, the image of the infimum of `a` and `b` under `f` is equal to the infimum of the images of `a` and `b` under `f`. In simpler terms, the function `f` preserves the infimum operation.

If `F` is a function-like type between infimum-equipped types `α` and `β`, where `F` preserves infima, then for all `a, b ∈ α`, `f(inf(a, b)) = inf(f(a), f(b))` holds for any `f : F`.


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

The theorem `CategoryTheory.Limits.bicone_ι_π_ne` states that for any given type `J`, type `C`, a category structure on `C`, a property that `C` has zero morphisms, a functor `F` from `J` to `C`, and a bicone `B` over `F`, if `j` and `j'` are two distinct objects of type `J`, then the composition of the morphism `B.ι j` and the morphism `B.π j'` is zero. In other words, in the category theory context, if two objects are distinct, the composition of their morphisms results in a zero morphism.

For any category `C` with zero morphisms, functor `F` from a type `J` to `C`, and a bicone `B` over `F`, the composition of `B.ι j` and `B.π j'` is zero for distinct objects `j` and `j'` of `J`.


theorem Function.const_lt_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Nonempty β] {a b : α},
      Function.const β a < Function.const β b ↔ a < b :=
  by sorry

The theorem `Function.const_lt_const` states that for any types `α` and `β`, where `α` has a preorder structure and `β` is nonempty, and for any elements `a` and `b` of type `α`, the constant function of type `β → α` with value `a` is less than the constant function with value `b` if and only if `a` is less than `b` under the preorder on `α`. In simpler terms, it means that the inequality relationship between two constants `a` and `b` is preserved when these constants are used as the values of constant functions.

For any preordered types `α` and non-empty `β`, and elements `a` and `b` of `α`, the constant function `λ (x : β), a` is less than the constant function `λ (x : β), b` in the function preorder if and only if `a` is less than `b` in the preorder on `α`.


theorem Matrix.mulVec_mulVec :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalSemiring α] [inst_1 : Fintype n]
      [inst_2 : Fintype o] (v : o → α) (M : Matrix m n α) (N : Matrix n o α),
      Matrix.mulVec M (Matrix.mulVec N v) = Matrix.mulVec (M * N) v :=
  by sorry

The theorem `Matrix.mulVec_mulVec` states that for any non-unital semiring `α` and any finite types `m`, `n`, and `o`, and given any vector `v` of type `o → α`, and any two matrices `M`, `N` of types `Matrix m n α` and `Matrix n o α` respectively, the result of multiplying matrix `M` with the result of multiplying matrix `N` with vector `v` (i.e., `Matrix.mulVec M (Matrix.mulVec N v)`) is equal to the result of multiplying the product of matrices `M` and `N` with vector `v` (i.e., `Matrix.mulVec (M * N) v`). In other words, the operation of multiplying a matrix with a vector is associative with respect to matrix multiplication.

For any non-unital semiring α and finite types m, n, and o, the operation of matrix-vector multiplication is associative, that is, `(M * N) * v = M * (N * v)` for matrices M : Matrix m n α and N : Matrix n o α, and vector v : o → α.


theorem Ordinal.le_add_sub : ∀ (a b : Ordinal.{u_4}), a ≤ b + (a - b) := by sorry

This theorem, `Ordinal.le_add_sub`, states that for any two ordinals `a` and `b`, the ordinal `a` is less than or equal to the sum of ordinal `b` and the difference between `a` and `b`. This is a fundamental property of ordinals, similar to the property in real numbers that any number is less than or equal to the sum of another number and the difference between the first number and the second one.

For all ordinals `a` and `b`, `a ≤ b + (a - b)`.


theorem Set.encard_mono : ∀ {α : Type u_1}, Monotone Set.encard := by sorry

The theorem `Set.encard_mono` states that for any type `α`, the function `Set.encard` is monotone. In other words, if we have two sets `A` and `B` of type `α` such that `A` is a subset of `B` (in other words, `A ≤ B`), then the cardinality of `A` is less than or equal to the cardinality of `B` (in other words, `Set.encard A ≤ Set.encard B`). This is consistent with the intuitive understanding that a subset cannot be larger than the set it is contained within.

For any type `α` and sets `A` and `B` of type `α` with `A ≤ B`, we have `Set.encard A ≤ Set.encard B`.


theorem Multiset.filter_eq_self :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Multiset α}, Multiset.filter p s = s ↔ ∀ a ∈ s, p a :=
  by sorry

The theorem `Multiset.filter_eq_self` states that for any type `α`, any decidable predicate `p` on `α`, and any multiset `s` of `α`, the multiset resulting from filtering `s` with the predicate `p` is equal to `s` if and only if every element `a` of `s` satisfies the predicate `p`. In other words, the multiset obtained by keeping only the elements of `s` that satisfy `p` is the same as `s` precisely when all elements of `s` satisfy `p`.

For any type `α`, decidable predicate `p` on `α`, and multiset `s` of `α`, `Multiset.filter p s = s` if and only if `∀ a ∈ s, p a`.


theorem Iic_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b : α},
      a < b → Set.Iic b ∈ nhds a :=
  by sorry

This theorem states that for any types `α` that have a topological space structure, a linear order structure, and a topology where the set of numbers greater than or equal to a particular number is closed, if `a` and `b` are elements of `α` with `a` less than `b`, then the set of all elements less than or equal to `b` is a neighborhood of `a`. In other words, the left-infinite right-closed interval up to `b` is in the neighborhood filter of `a`.

For any type `α` endowed with a topology, a linear order, and the property that the set of elements greater than or equal to any given element is closed, if `a` is less than `b` in `α`, then the set of elements less than or equal to `b` is a neighborhood of `a`.


theorem ContDiff.div_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {𝕜' : Type u_6} [inst_3 : NormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜'] {f : E → 𝕜'}
      {n : ℕ∞}, ContDiff 𝕜 n f → ∀ (c : 𝕜'), ContDiff 𝕜 n fun x => f x / c :=
  by sorry

This theorem states that for any nontrivial normed field 𝕜, normed additive commutative group E, and normed space E over 𝕜, given a normed field 𝕜' and a normed algebra 𝕜' over 𝕜, if a function f from E to 𝕜' is continuously differentiable of any order n, then the function that applies f to an input and then divides by a fixed constant from 𝕜' is also continuously differentiable of the same order.

If `f` is a continuously differentiable function of order `n` from a normed space `E` over a nontrivial normed field `ℝ`, to another normed field `ℝ'`, then the function `x ↦ (f(x) / k)` for a fixed `k` in `ℝ'`, is also continuously differentiable of order `n`.


theorem Primrec.list_foldr :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α → List β} {g : α → σ} {h : α → β × σ → σ},
      Primrec f → Primrec g → Primrec₂ h → Primrec fun a => List.foldr (fun b s => h a (b, s)) (g a) (f a) :=
  by sorry

The theorem `Primrec.list_foldr` states that if we have three functions: `f` mapping from a type `α` to a list of type `β`, `g` mapping from type `α` to type `σ`, and `h` a binary function mapping from type `α` and a pair of type `β` and `σ` to type `σ`; if these three functions are all primitive recursive (they can be broken down into simpler recursive calls and a base case), then the function that takes an element of type `α` and applies the right-to-left fold operation on the list resulting from `f` with the binary function created from `h` and initial accumulator as the result of `g`, is also primitive recursive. In other words, it's saying that primitive recursiveness is preserved through right-to-left list folding operations.

If `f : α -> list β`, `g : α -> σ`, and `h : α -> β -> σ -> σ` are primitive recursive functions, then the function that maps an element `x` of type `α` to the result of right-folding `h` over the list `(f x)` is also primitive recursive.


theorem Finsupp.smul_single' :
    ∀ {α : Type u_1} {R : Type u_11} {x : Semiring R} (c : R) (a : α) (b : R),
      (c • fun₀ | a => b) = fun₀ | a => c * b :=
  by sorry

This theorem, `Finsupp.smul_single'`, asserts that for any given types `α` and `R`, with `R` being a semiring, and any elements `c` and `b` of `R` and `a` of `α`, the scalar multiplication of `c` and the function `$\text{fun₀ } | a \Rightarrow b$` (which maps `a` to `b` and all other elements of `α` to zero) is equal to the function `$\text{fun₀ } | a \Rightarrow c * b$`. This essentially means that scalar multiplication distributes over the function, specifically the scalar multiples the value that the function maps to.

For any semiring `R`, scalar multiplication by an element `c` of `R` distributes over the function that maps every element `a` of a type `α` to an element `b` of `R`, yielding the function that maps `a` to `c * b` and all other elements of `α` to zero.


theorem lie_lie :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x y : L)
      (m : M), ⁅⁅x, y⁆, m⁆ = ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆ :=
  by sorry

This theorem, called `lie_lie`, states that for any two elements `x` and `y` of a Lie ring `L`, and any element `m` of an additive commutative group `M` which is also a `L`-module, the double Lie bracket of `x`, `y`, and `m` is equal to the difference between the Lie bracket of `x` with the Lie bracket of `y` and `m`, and the Lie bracket of `y` with the Lie bracket of `x` and `m`. In mathematical notation, this is: [[x, y], m] = [x, [y, m]] - [y, [x, m]].

The double Lie bracket of two elements in a Lie ring and an element of the associated Lie-module equals the commutator of the Lie brackets of the two elements with the module element. In Lean notation: [[x, y], m] = [x, [y, m]] - [y, [x, m]].


theorem le_tsub_iff_right :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      a ≤ c → (b ≤ c - a ↔ b + a ≤ c) :=
  by sorry

The theorem `le_tsub_iff_right` states that for any type `α` that has an addition and subtraction operation, and is also a partially ordered commutative semigroup, if `a` is less than or equal to `c`, then `b` is less than or equal to `c - a` if and only if `b + a` is less than or equal to `c`. This theorem essentially describes a property of subtraction in the context of ordered algebraic structures.

For any commutative semigroup with addition and order structure, if `a ≤ c` and `b ≤ a`, then `b ≤ c - a` if and only if `b + a ≤ c`.


theorem Nat.odd_of_mod_four_eq_three : ∀ {n : ℕ}, n % 4 = 3 → n % 2 = 1 := by sorry

This theorem states that for any natural number `n`, if the modulus of `n` divided by 4 equals 3, then the modulus of `n` divided by 2 equals 1. In mathematical terms, it asserts that if `n` modulo 4 is 3, then `n` is necessarily odd (since `n` modulo 2 is 1).

If `n` is a natural number with `n` modulo 4 = 3, then `n` is odd, i.e., `n` modulo 2 = 1.


theorem Real.cos_nonneg_of_mem_Icc : ∀ {x : ℝ}, x ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) → 0 ≤ Real.cos x := by sorry

The theorem `Real.cos_nonneg_of_mem_Icc` asserts that for any real number `x`, if `x` lies in the closed interval from negative pi over 2 to pi over 2 (inclusive), then the cosine of `x` is nonnegative. In mathematical terms, this means that for all $x \in [-\pi/2, \pi/2]$, we have $\cos(x) \geq 0$. This is a property of the cosine function in the real number system.

For all $x \in [-\pi/2, \pi/2]$, we have $\cos(x) \geq 0$.


theorem Complex.one_cpow : ∀ (x : ℂ), 1 ^ x = 1 := by sorry

This theorem states that for any complex number `x`, the complex number `1` raised to the power of `x` is always equal to `1`. This corresponds to the mathematical statement $1^x = 1$ for all $x \in \mathbb{C}$.

For all complex numbers x, 1 raised to the power x equals 1. (Or equivalently, the complex number 1 is its own complex exponent.)


TruncatedWittVector.ext

theorem TruncatedWittVector.ext :
    ∀ {p n : ℕ} {R : Type u_1} {x y : TruncatedWittVector p n R},
      (∀ (i : Fin n), TruncatedWittVector.coeff i x = TruncatedWittVector.coeff i y) → x = y :=
  by sorry

The theorem `TruncatedWittVector.ext` states that for any two truncated Witt vectors `x` and `y` of the same parameters `p`, `n`, and `R`, if all their corresponding coefficients are equal (i.e., for each index `i` within the bounds of `n`, the `i`th coefficient of `x` equals the `i`th coefficient of `y`), then the two truncated Witt vectors `x` and `y` are indeed the same. This theorem is essentially about the equality of truncated Witt vectors in terms of their coefficients.

If two truncated Witt vectors of the same parameters and equal coefficients correspondently indexed within their bounds are given, then they are equal.


theorem Nat.map_swap_divisorsAntidiagonal :
    ∀ {n : ℕ},
      Finset.map (Equiv.toEmbedding (Equiv.prodComm ℕ ℕ)) (Nat.divisorsAntidiagonal n) = Nat.divisorsAntidiagonal n :=
  by sorry

This theorem states that for any natural number `n`, if you map the elements of the finset `Nat.divisorsAntidiagonal n` (which consists of pairs `(x, y)` such that `x * y = n`) under the equivalence `Equiv.prodComm ℕ ℕ` (which swaps the elements of the pair), you get the same set `Nat.divisorsAntidiagonal n`. In other words, swapping the elements in each pair of the `divisorsAntidiagonal` of a number does not change the set of divisor pairs of that number.

For any natural number `n`, the set of pairs `(x, y)` such that `x * y = n` is equal to its image under the swapping operation of `Equiv.prodComm ℕ ℕ`.


theorem isPiSystem_Ixx_mem :
    ∀ {α : Type u_1} [inst : LinearOrder α] {Ixx : α → α → Set α} {p : α → α → Prop},
      (∀ {a b : α}, Set.Nonempty (Ixx a b) → p a b) →
        (∀ {a₁ b₁ a₂ b₂ : α}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)) →
          ∀ (s t : Set α), IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, p l u ∧ Ixx l u = S} :=
  by sorry

This theorem states that for any type `α` with a linear order, given a function `Ixx : α → α → Set α` and a predicate `p : α → α → Prop`, if `p` holds for any `a` and `b` such that `Ixx a b` is nonempty, and if the intersection of `Ixx a₁ b₁` and `Ixx a₂ b₂` equals `Ixx (max a₁ a₂) (min b₁ b₂)` for any `a₁`, `b₁`, `a₂`, `b₂`, then the set of all `S` such that there exist `l` in `s` and `u` in `t` for which `p l u` holds and `Ixx l u` equals `S`, forms a π-system.

In other words, it's a statement about a certain form of structured set, where this set forms a π-system under certain conditions. A π-system is a collection of subsets that is closed under binary intersection of non-disjoint sets. Note that this theorem does not impose any nonempty requirement on the π-system.

For any type with a linear order and a binary relation satisfying certain conditions, the collection of sets defined by the relation forms a π-system.


theorem Ordinal.IsNormal.lt_iff :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}}, Ordinal.IsNormal f → ∀ {a b : Ordinal.{u_4}}, f a < f b ↔ a < b := by sorry

This theorem states that for any normal ordinal function `f`, and any two ordinals `a` and `b`, `f(a)` is less than `f(b)` if and only if `a` is less than `b`. In other words, a normal ordinal function `f` preserves the order of ordinals: if an ordinal `a` is less than another ordinal `b`, then `f(a)` is also less than `f(b)` and vice versa.

For any normal ordinal function `f`, if `a` is less than `b`, then `f(a)` is less than `f(b)`.


theorem pow_le_pow_of_le_one :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a : α}, 0 ≤ a → a ≤ 1 → ∀ {m n : ℕ}, m ≤ n → a ^ n ≤ a ^ m := by sorry

This theorem states that for any type `α` that is an ordered semiring, and for any element `a` of this type that is between 0 and 1 inclusive, if you raise `a` to the power of `n` and `m` (where `n` and `m` are natural numbers and `m` is less than or equal to `n`), then `a` raised to the `n`th power will be less than or equal to `a` raised to the `m`th power. This theorem captures the property of numbers between 0 and 1 where increasing the exponent results in a smaller number.

For any ordered semiring type `α` and element `a` between 0 and 1, `a^n <= a^(m)` when `n >= m`.


theorem Finset.image_subset_image₂_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {a : α}, a ∈ s → Finset.image (fun b => f a b) t ⊆ Finset.image₂ f s t :=
  by sorry

The theorem `Finset.image_subset_image₂_right` states that for all types `α`, `β`, `γ`, given a function `f : α → β → γ`, two finite sets `s : Finset α`, `t : Finset β`, and an element `a : α` in `s`, the image of the function `f` when applied to `a` and all elements of `t` is a subset of the image of the function `f` applied to all possible pairings of elements from `s` and `t`. In other words, if we map each element of `t` to `γ` using the function `f` with a fixed `a` from `s`, all these mapped elements are also in the set obtained by considering all possible pairs `(a', b')` where `a'` is from `s` and `b'` is from `t` and mapping these pairs to `γ` using `f`. This theorem is in the context where equality in `γ` is decidable.

For all types `α`, `β`, `γ`, function `f : α → β → γ`, finite sets `s : Finset α`, `t : Finset β`, and `a : α` in `s`, the image of `f` applied to `a` and all elements of `t` is a subset of the image of `f` applied to all pairs `(a', b')` with `a'` in `s` and `b'` in `t`.


theorem differentiableAt_snd :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {p : E × F},
      DifferentiableAt 𝕜 Prod.snd p :=
  by sorry

This theorem states that for any non-trivial normed field `𝕜`, any normed additive commutative group `E`, any normed vector space over `𝕜` of `E`, any normed additive commutative group `F`, and any normed vector space over `𝕜` of `F`, the second projection function `Prod.snd` is differentiable at any point `p` in the product space `E × F`. In mathematical terms, if `p` belongs to the Cartesian product of sets `E` and `F`, the function `Prod.snd` that projects `p` onto the second coordinate (`F`) admits a derivative at `p`.

The second projection of a product of two normed vector spaces over a non-trivial normed field is differentiable at any point in the product space.


theorem ContinuousMap.isOpen_setOf_mapsTo :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {K : Set X} {U : Set Y},
      IsCompact K → IsOpen U → IsOpen {f | Set.MapsTo (⇑f) K U} :=
  by sorry

The theorem `ContinuousMap.isOpen_setOf_mapsTo` states that for any types `X` and `Y` that are equipped with topological space structures, and for any sets `K` of type `X` and `U` of type `Y`, if `K` is compact and `U` is open, then the set of all continuous maps `f` such that the image of `K` under `f` is contained in `U`, is an open set. In other words, the set of all continuous functions that map a compact set to an open set is itself an open set in the function space.

The set of continuous functions from a compact topological space to an open subset of another topological space is an open subset in the function space.


theorem Ioc_mem_nhdsWithin_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b c : α},
      b ∈ Set.Ico a c → Set.Ioc a c ∈ nhdsWithin b (Set.Ioi b) :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure, a linear order structure, and a topology that is closed at the lower side of the set [i, ∞) for each i, and for any three elements `a`, `b`, and `c` of type `α`, if `b` belongs to the left-closed right-open interval from `a` to `c`, then the left-open right-closed interval from `a` to `c` belongs to the "neighborhood within" filter of `b` in the right-infinite set where every element is greater than `b`. In simpler words, if `b` is in the interval [a,c) then the interval (a,c] is in the neighborhood of `b` where all points are greater than `b`.

If `α` is a type with a topological space structure, a linear order, and a right-continuous topology at the set (i, ∞) for each i, then for any `a`, `b`, and `c` in `α` with `b` in the interval [a, c), the interval (a, c] is in the neighborhood filter of `b`.


theorem MeasureTheory.StronglyMeasurable.const_smul :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] {𝕜 : Type u_5}
      [inst_1 : SMul 𝕜 β] [inst_2 : ContinuousConstSMul 𝕜 β],
      MeasureTheory.StronglyMeasurable f → ∀ (c : 𝕜), MeasureTheory.StronglyMeasurable (c • f) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.const_smul` states that if a function `f` from a measurable space `α` to a topological space `β` is strongly measurable (meaning there exists a sequence of simple functions that converges to `f`), then for any scalar `c` from a type `𝕜` which supports scalar multiplication with `β` and for which scalar multiplication is continuous, the function `c•f` (scalar multiple of `f`) is also strongly measurable.

If a strongly measurable function from a measurable space to a topological space is multiplied by a scalar from a scalar multiplication-supporting, continuosly scalar-multiplicative type, the resulting function is also strongly measurable.


theorem Real.IsConjExponent.ne_zero : ∀ {p q : ℝ}, Real.IsConjExponent p q → p ≠ 0 := by sorry

This theorem states that for any two real numbers `p` and `q`, if `q` is the conjugate exponent of `p` (as defined by the `Real.IsConjExponent` property), then `p` cannot be zero. This theorem helps ensure that the operations using the concept of conjugate exponent won't encounter issues with division by zero or other undefined mathematical behavior.

If `p` is a real number and `q` is its conjugate exponent (as defined by `Real.IsConjExponent` property), then `p` is non-zero.


theorem Filter.Eventually.nat_cast_atTop :
    ∀ {R : Type u_2} [inst : OrderedSemiring R] [inst_1 : Archimedean R] {p : R → Prop},
      (∀ᶠ (x : R) in Filter.atTop, p x) → ∀ᶠ (n : ℕ) in Filter.atTop, p ↑n :=
  by sorry

This theorem is essentially stating that for any type `R` that is an ordered semiring and Archimedean, and for any property `p` of `R`, if the property `p` holds eventually (i.e., for all sufficiently large elements) when considering `R` towards infinity (as provided by `Filter.atTop`), then the property `p` will also hold eventually when considering the natural number `n` cast into `R` towards infinity. In mathematical terms, if $\forall x \in R, x \rightarrow \infty$ implies $p(x)$, then $\forall n \in \mathbb{N}, n \rightarrow \infty$ also implies $p(n)$ when $n$ is viewed as an element of `R`.

If a property holds for all sufficiently large elements in an ordered semiring `R` that is Archimedean, then it also holds for natural numbers `n` when viewed as elements of `R` towards infinity.


theorem Set.singleton_prod : ∀ {α : Type u_1} {β : Type u_2} {t : Set β} {a : α}, {a} ×ˢ t = Prod.mk a '' t := by sorry

The theorem `Set.singleton_prod` states that for any types `α` and `β`, any set `t` of type `β`, and any element `a` of type `α`, the Cartesian product of the singleton set containing `a` and the set `t` is equal to the image of the set `t` under the function `Prod.mk a`. In mathematical terms, this means that for all `a` in `α` and all sets `t` of elements of `β`, we have {a} × t = {(a, b) | b ∈ t}, where × denotes the Cartesian product and {(a, b) | b ∈ t} is the set of all pairs (a, b) with b in `t`.

For any types `α` and `β`, and for any `a ∈ α` and set `t ∈ β`, the singleton set {`a`} and set `t` have the same Cartesian product, that is, {`a`} × `t` = {(`a`, `b`) | `b ∈ t`}.


theorem MeasureTheory.Measure.MutuallySingular.symm :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular ν μ → MeasureTheory.Measure.MutuallySingular μ ν :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.symm` states that for any type `α` and `m0` being a measurable space associated with `α`, if two measures `μ` and `ν` are mutually singular in the sense that there exists a measurable set such that the measure of that set by `ν` is zero and the measure of the complement of the set by `μ` is also zero, then the mutually singularity property is symmetric; meaning that, `μ` and `ν` can be swapped and they will still be mutually singular.

If measures `μ` and `ν` on measurable space `(α, m0)` are mutually singular, then swapping `μ` and `ν` preserves the mutually singularity property.


theorem RingHom.isIntegralElem_map :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] (f : R →+* S) {x : R},
      RingHom.IsIntegralElem f (f x) :=
  by sorry

The theorem `RingHom.isIntegralElem_map` states that for any types `R` and `S`, given the preconditions that `R` is a commutative ring and `S` is a ring, and given a ring homomorphism `f` from `R` to `S` and an element `x` from `R`, then the image of `x` under `f` is integral over `R` with respect to `f`. In terms of algebra, this means that there exists a monic polynomial `p` over `R` such that when `p` is evaluated at the image of `x` under `f`, the result is zero.

For any commutative rings R and S, ring homomorphism f : R -> S, and element x in R, the image of x under f is integral over R with respect to f, i.e., there exists a monic polynomial p(t) in R[t] such that p(f(x)) = 0.


theorem WithTop.strictMono_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : WithTop α → β},
      StrictMono f ↔ (StrictMono fun a => f ↑a) ∧ ∀ (x : α), f ↑x < f ⊤ :=
  by sorry

This theorem states that for any types `α` and `β` that have preorder structures and any function `f` from `WithTop α` to `β`, `f` is strictly monotone if and only if the function obtained from `f` by restricting its domain to the non-top elements of `WithTop α` is strictly monotone and, for every element `x` of `α`, `f` applied to `x` (lifted to `WithTop α`) is strictly less than `f` applied to the top element of `WithTop α`. In other words, `f` is strictly increasing, and the top element of `WithTop α` is mapped to a value strictly greater than any non-top element.

For functions between preordered types `α` and `β`, `f` is strictly monotone if and only if its restriction to non-top elements is strictly monotone and for all `x` in `α`, `f` maps `x` to a strictly lesser value than `f` applied to the top element of `WithTop α`.


DifferentiableWithinAt.comp

theorem DifferentiableWithinAt.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} (x : E) {s : Set E}
      {g : F → G} {t : Set F},
      DifferentiableWithinAt 𝕜 g t (f x) →
        DifferentiableWithinAt 𝕜 f s x → Set.MapsTo f s t → DifferentiableWithinAt 𝕜 (g ∘ f) s x :=
  by sorry

The theorem `DifferentiableWithinAt.comp` states that if a function `g` is differentiable at the point `f(x)` within a set `t`, and a function `f` is differentiable at the point `x` within a set `s`, and if `f` maps every point of `s` into `t`, then the composition function `g ∘ f` is also differentiable at the point `x` within the set `s`. Here `𝕜`, `E`, `F` and `G` denote the types involved, while `NontriviallyNormedField 𝕜`, `NormedAddCommGroup E`, `NormedSpace 𝕜 E`, `NormedAddCommGroup F`, `NormedSpace 𝕜 F`, `NormedAddCommGroup G` and `NormedSpace 𝕜 G` are structures capturing the required properties of these types. This theorem essentially encapsulates the chain rule from calculus in the context of differentiable functions within specified sets.

If functions `f: E → F` and `g: F → G` are differentiable at points `x ∈ E` and `f(x) ∈ T ⊆ F` respectively, and `f(s) ⊆ t` for all `s ∈ s ∈ S ⊆ E`, then the composition `g ∘ f: E → G` is differentiable at `x`.


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

The theorem `Mathlib.Data.Finset.Pointwise._auxLemma.82` states that for any types `α` and `β`, given that `β` has decidable equality and there is a scalar multiplication operation defined between `α` and `β`, for any finite sets `s` of type `α` and `t` of type `β`, and any element `x` of type `β`, the condition of `x` being in the scalar multiplication of `s` and `t` is equivalent to the existence of elements `y` in `s` and `z` in `t` such that the scalar multiplication of `y` and `z` equals `x`.

For any types `α` and `β` with decidable equality, and given a scalar multiplication operation between `α` and `β`, the element `x` lies in the scalar multiplication of finite sets `s` of type `α` and `t` of type `β` if and only if there exist `y ∈ s` and `z ∈ t` such that `y * z = x`.


theorem Nat.card_Ioc : ∀ (a b : ℕ), (Finset.Ioc a b).card = b - a := by sorry

The theorem `Nat.card_Ioc` states that for all natural numbers `a` and `b`, the cardinality (or the number of elements) of the finite set `Finset.Ioc a b` is equal to the difference `b - a`. In other words, this finite set, which consists of all natural numbers `x` such that `a < x` and `x ≤ b`, has exactly `b - a` elements.

The cardinality of the finite set of natural numbers `x` with `a < x <= b` is equal to `b - a`.


theorem IsMinFilter.comp_mono :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsMinFilter f l a → ∀ {g : β → γ}, Monotone g → IsMinFilter (g ∘ f) l a :=
  by sorry

The theorem `IsMinFilter.comp_mono` states that for all types `α`, `β`, `γ` with a preorder on `β` and `γ`, and for any function `f` from `α` to `β`, a filter `l` on `α`, and an element `a` of type `α`, if `f` has a property that it reaches its minimum at `a` for all elements `x` in some `l`-neighborhood of `a`, then for any monotone function `g` from `β` to `γ`, the function composed of `g` and `f` (i.e., `g ∘ f`) also has the property that it reaches its minimum at `a` for all elements `x` in the same `l`-neighborhood of `a`. Here, a function `g` is considered monotone if for all `a` and `b` such that `a ≤ b`, we have `g(a) ≤ g(b)`.

Given types `α`, `β`, `γ` with preorders, a filter `l` on `α`, a function `f: α → β`, an element `a ∈ α`, and monotone function `g: β → γ`, if `f` minimizes at `a` in some `l`-neighborhood, then `g ∘ f` also minimizes at `a` in the same `l`-neighborhood.


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

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then the distance between `n` and `m`, as defined by the `Nat.dist` function, is equal to the difference between `m` and `n`. In other words, if `n` is less than or equal to `m`, then the absolute value of the difference between `n` and `m` is simply `m - n`.

For all natural numbers `n` and `m`, `Nat.dist n m = m - n` when `n ≤ m`.


theorem Ordinal.add_one_eq_succ : ∀ (o : Ordinal.{u_3}), o + 1 = Order.succ o := by sorry

The theorem `Ordinal.add_one_eq_succ` states that for every well-order `o` of type ordinal, adding one to `o` is equivalent to the successor of `o`. In other words, the operation of incrementing an ordinal by one results in the same ordinal as invoking the successor function on that ordinal. This holds regardless of whether the original ordinal `o` was maximal or not.

For every well-ordered ordinal `o`, `o + 1` equals the successor of `o`.


theorem Encodable.decode_prod_val :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable β] [i : Encodable α] (n : ℕ),
      Encodable.decode n =
        Option.bind (Encodable.decode (Nat.unpair n).1) fun a =>
          Option.map (Prod.mk a) (Encodable.decode (Nat.unpair n).2) :=
  by sorry

The theorem `Encodable.decode_prod_val` states that for any two encodable types `α` and `β`, and for any natural number `n`, the decoding of `n` is equivalent to first unpacking `n` into a pair of natural numbers, then decoding the first element of the pair to get an optional `α` value, and if it exists, mapping it to a pair with the decoding of the second element of the pair, otherwise resulting in `none`. In other words, it is encoding a pair of values in a specific way that involves both elements of the pair.

For any encodable types `α` and `β`, the decoding of a natural number `n` for a product type `α × β` is equivalent to optionally decoding an `α` value from the first `n` bits and pairing it with the decoding of the remaining `n` bits as a `β` value.


theorem Submodule.mem_set_smul_of_mem_mem :
    ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] {S : Type u_4} [inst_1 : Monoid S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : DistribMulAction S M] {s : Set S} {N : Submodule R M} {r : S} {m : M},
      r ∈ s → m ∈ N → r • m ∈ s • N :=
  by sorry

This theorem, `Submodule.mem_set_smul_of_mem_mem`, states that for any given semiring `R`, type `M`, monoid `S`, set `s` of `S`, submodule `N` of `R` and `M`, and elements `r` of `S` and `m` of `M`, if `r` is in `s` and `m` is in `N`, then the scalar multiplication of `r` and `m` (denoted `r • m`) is in the set obtained by scalar multiplying all elements of `N` by all elements of `s` (denoted `s • N`). Here, `Semiring`, `Monoid`, `AddCommMonoid`, `Module`, and `DistribMulAction` are particular types of mathematical structures, and the elements and sets are assumed to behave according to the properties of these structures.

If `r` is in `s` and `m` is in `N` for a semiring `R`, monoid `S`, set `s`, submodule `N` of `R` and `M`, then `r • m` is in `s • N`.


theorem MonoidHom.noncommPiCoprod_mulSingle :
    ∀ {M : Type u_1} [inst : Monoid M] {ι : Type u_2} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] {N : ι → Type u_3}
      [inst_3 : (i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M)
      {hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)} (i : ι) (y : N i),
      (MonoidHom.noncommPiCoprod ϕ hcomm) (Pi.mulSingle i y) = (ϕ i) y :=
  by sorry

The theorem `MonoidHom.noncommPiCoprod_mulSingle` states that for any monoid `M`, index type `ι` with decidable equality and being finite, a family of monoids `N` indexed by `ι`, a family of monoid homomorphisms `ϕ` from `N` to `M`, and a pairwise commuting condition `hcomm` on the homomorphisms, if we have an index `i` and an element `y` from `N i`, then the canonical homomorphism (given by `MonoidHom.noncommPiCoprod`) applied to the function supported at `i`, with value `y` there and `1` elsewhere (given by `Pi.mulSingle`), is equal to the homomorphism `ϕ i` applied to `y`. That is to say, within a commutative context, the overall effect of the canonical homomorphism on the specific function `Pi.mulSingle i y` is the same as simply applying the specific homomorphism `ϕ i` to `y`.

For any finite index type `ι`, monoid `M`, family of monoids `N` indexed by `ι`, family of monoid homomorphisms `ϕ` from `N` to `M` satisfying pairwise commutativity condition `hcomm`, and `i` in `ι` and `y` in `N i`, the canonical homomorphism from the noncommutative product of `N` applying `Pi.mulSingle i y` is equal to `ϕ i (y)`.


theorem Matrix.smul_cons :
    ∀ {α : Type u} {n : ℕ} {M : Type u_4} [inst : SMul M α] (x : M) (y : α) (v : Fin n → α),
      x • Matrix.vecCons y v = Matrix.vecCons (x • y) (x • v) :=
  by sorry

This theorem states that for any scalar multiplication operation (`SMul`), given a scalar `x` of type `M`, an element `y` of type `α`, and a vector function `v` (a function from the finite set of size `n` to `α`), the scalar multiplication of `x` with the vector formed by prepending `y` to `v` (`Matrix.vecCons y v`) is equivalent to the vector obtained by prepending `x` multiplied by `y` to `x` multiplied by `v`. In other words, scalar multiplication distributes over the vector concatenation operation, `vecCons`.

For any scalar `x` and vector `v` of length `n+1`, and any element `y`, the scalar multiplication of `x` with the vector obtained by prepending `y` to `v` (`Matrix.vecCons y v`) is equal to the vector obtained by prepending the product of `x` and `y` to the result of multiplying `x` with `v`. In other words, `x * (Matrix.vecCons y v) = Matrix.vecCons (x * y) (x * v)`.


theorem Finset.max'_eq_sup' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), Finset.max' s H = Finset.sup' s H id := by
  sorry

This theorem states that for any nonempty finite set `s` of a given type `α` under a linear order, the maximum element of `s` (given by `Finset.max' s H` where `H` is a proof of the set's non-emptiness) is equal to the supremum of its image under the identity function (given by `Finset.sup' s H id`). In other words, in a linearly ordered set, the maximum element is the same as the supremum when considering the identity function.

For any nonempty finite set `s` under a linear order, the maximum element is equal to the supremum of its elements under the identity function.


theorem Order.not_isSuccLimit_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a : α},
      ¬Order.IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ Order.succ b = a :=
  by sorry

This theorem states that for any type `α` equipped with a partial order and a successor order, and for any element `a` of `α`, the property that `a` is not a successor limit is equivalent to the existence of some element `b` such that `b` is not maximal and the successor of `b` is `a`.

In more layman's terms, an element is not a successor limit if and only if there is another element that is not the largest in the order and, when moved one step further in the order, reaches the original element. This bridges the concepts of successor limit, maximality, and successor operation in this particular order structure.

For any type `α` with partial and successor orders, an element `a` is not a successor limit if and only if there exists a non-maximal element `b` such that the successor of `b` is `a`.


theorem Nat.mul_div_left : ∀ (m : ℕ) {n : ℕ}, 0 < n → m * n / n = m := by sorry

This theorem states that for any natural number `m` and any non-zero natural number `n`, the result of multiplying `m` and `n` then dividing by `n` is `m`. This essentially captures the principle that division is the inverse operation of multiplication for natural numbers. In more formal terms, the theorem states that for all `m` in the set of natural numbers, and for all `n` in the set of natural numbers excluding zero, `(m * n) / n` equals `m`.

For all natural numbers `m` and non-zero `n`, `m * n = n * m` implies `m = (m * n) / n`.


theorem WithTop.top_ne_coe : ∀ {α : Type u_1} {a : α}, ⊤ ≠ ↑a := by sorry

This theorem, `WithTop.top_ne_coe`, asserts that for any type `α` and any element `a` of that type, the element when cast to the extended type `WithTop α` (which is the original type `α` extended with a top element `⊤`) is never equal to the top element `⊤`. In other words, no regular element from the original type can be equal to the top element in the extended type when that element is cast to the extended type.

For any type `α` and its element `a`, the coercion of `a` to `WithTop α` is never equal to the top element `⊤` in `WithTop α`.


theorem MeasureTheory.le_toOuterMeasure_caratheodory :
    ∀ {α : Type u_1} [ms : MeasurableSpace α] (μ : MeasureTheory.Measure α),
      ms ≤ MeasureTheory.OuterMeasure.caratheodory ↑μ :=
  by sorry

This theorem states that for any given measurable space, denoted by 'ms', and a measure 'μ' on a type 'α', the measurable space 'ms' is less than or equal to the Carathéodory-measurable space associated with the outer measure associated with 'μ'. In other words, any set considered measurable in 'ms' is also deemed measurable in the Carathéodory-measurable space of 'μ'.

For any measurable space (ms, Σ, μ) and its associated Carathéodory-measurable space (msᵢ, Σ₊, μ₊), we have that ms ⇊ msᵢ, where ⇊ denotes inclusion up to a null set.


theorem List.foldr_reverse :
    ∀ {α : Type u_1} {β : Type u_2} (l : List α) (f : α → β → β) (b : β),
      List.foldr f b (List.reverse l) = List.foldl (fun x y => f y x) b l :=
  by sorry

The theorem `List.foldr_reverse` states that for any list `l` of type `List α`, for any function `f` of type `α → β → β`, and for any element `b` of type `β`, applying the `foldr` function with `f` and `b` on the reverse of `l` yields the same result as applying the `foldl` function with `f` flipped and `b` on `l`. In other words, reversing a list and then performing a right fold with a certain function and base point is identical to performing a left fold with the same function (but with arguments flipped) and base point on the original list.

For any list `l` of type `List α`, any function `f` of type `α → β → β`, and any element `b` of type `β`, `List.foldr (λ x acc, acc ~<~ f x) b (reverse l) = List.foldl (λ acc x, f x acc) b l`.


theorem ProjectiveSpectrum.basicOpen_eq_zeroLocus_compl :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜] (r : A),
      ↑(ProjectiveSpectrum.basicOpen 𝒜 r) = (ProjectiveSpectrum.zeroLocus 𝒜 {r})ᶜ :=
  by sorry

The theorem `ProjectiveSpectrum.basicOpen_eq_zeroLocus_compl` states that for any commutative semiring `R`, any commutative ring `A`, any algebra `A` over `R`, any natural number-indexed collection `𝒜` of submodules of `A`, and any element `r` of `A`, the set of prime ideals not containing `r`, which is the basic open set of the projective spectrum of `𝒜`, is equal to the complement of the zero locus of `{r}` in the projective spectrum of `𝒜`. The zero locus of `{r}` is the set of all points in the projective spectrum where `r` vanishes.

In the projective spectrum of any commutative ring `A` over a commutative semiring `R`, with a natural number-indexed collection `𝒜` of submodules, the set of prime ideals not containing an element `r` in `A` equals the complement of the zero locus of `{r}` in the projective spectrum of `𝒜`.


theorem CharP.cast_card_eq_zero :
    ∀ (R : Type u_1) [inst : AddGroupWithOne R] [inst_1 : Fintype R], ↑(Fintype.card R) = 0 := by sorry

The theorem `CharP.cast_card_eq_zero` states that for any type `R` that has both an `AddGroupWithOne` and a `Fintype` instance, the cardinality of `R` (the number of elements in `R`), when cast to `R`, is equal to zero. In mathematical terms, this means that the size of the set `R` is equal to the characteristic of the additive group with one on `R`.

The cardinality of an additive group with one on a type `R` having both `AddGroupWithOne` and `Fintype` instances equals zero.


theorem IsLocalization.AtPrime.to_map_mem_maximal_iff :
    ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
      (I : Ideal R) [hI : Ideal.IsPrime I] [inst_3 : IsLocalization.AtPrime S I] (x : R) (h : optParam (LocalRing S) ⋯),
      (algebraMap R S) x ∈ LocalRing.maximalIdeal S ↔ x ∈ I :=
  by sorry

This theorem states that for any commutative semiring `R`, given a type `S` that is also a commutative semiring and an 'algebra' over `R`, and given a prime ideal `I` of `R`, if `S` is isomorphic to the localization of `R` at the complement of `I`, then for any element `x` of `R`, and assuming `S` is a local ring, the image of `x` under the algebra homomorphism from `R` to `S` is in the maximal ideal of `S` if and only if `x` is in the prime ideal `I`.

The use of "optParam" allows for an optional parameter to be supplied for the type `LocalRing S`, and a default parameter is used if none is supplied. The "algebraMap" function maps elements from `R` to `S` according to the given algebra structure. The "LocalRing.maximalIdeal" refers to the ideal of `S` consisting of non-unit elements.

Given a commutative semiring `R`, a commutative semiring `S` isomorphic to the localization of `R` at the complement of a prime ideal `I`, and an algebra homomorphism from `R` to `S`, an element `x` in `R` maps to a non-unit element in `S` if and only if `x` is in `I`.


theorem Set.indicator_preimage :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (s : Set α) (f : α → M) (B : Set M),
      Set.indicator s f ⁻¹' B = Set.ite s (f ⁻¹' B) (0 ⁻¹' B) :=
  by sorry

This theorem states that, for any set `s` of elements of type `α`, any function `f` from `α` to `M` where `M` is a type with a zero element, and any set `B` of elements of type `M`, the preimage of `B` under the "indicator function" of `s` and `f` is equal to the `ite` (if-then-else) of `s`, the preimage of `B` under `f`, and the preimage of `B` under constant zero function. In other words, if you first apply the indicator function to `s` and `f` and then take the preimage of `B`, it's the same as if you first take the preimage of `B` under `f` and the constant zero function, then take the `ite` of these with respect to `s`.

For any set `s` of elements of type `α`, function `f` from `α` to a type `M` with zero element, and set `B` of elements of type `M`, the indicator function of `s` and `f`'s preimage of `B` equals the `ite` of `s`, `f`'s preimage of `B`, and the preimage of `B` under the constant zero function.


theorem MeasureTheory.absolutelyContinuous_neg :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableNeg G]
      [inst_5 : MeasureTheory.Measure.IsAddLeftInvariant μ],
      MeasureTheory.Measure.AbsolutelyContinuous μ (MeasureTheory.Measure.neg μ) :=
  by sorry

This theorem states that for any type `G` with a measurable space structure, an additive group structure and a condition that addition of two elements of `G` is measurable, given a sigma-finite measure `μ` on `G` that is additively left-invariant and assuming the negation operation on `G` is measurable, the measure `μ` is absolutely continuous with respect to the measure `A ↦ μ (- A)`, where `- A` is the pointwise negation of `A`. In other words, for any subset of `G` such that the measure of its pointwise negation under `μ` is zero, the measure of the subset itself under `μ` is also zero.

Given a sigma-finite, additively left-invariant measure `μ` on a measurable additive group `G` with measurable negation, `μ` is absolutely continuous with respect to `μ` (-), i.e., for any measurable set `A` with `μ`(-`A`) = 0, `μ`(`A`) = 0.


theorem IsUnit.div_mul_cancel : ∀ {α : Type u} [inst : DivisionMonoid α] {b : α}, IsUnit b → ∀ (a : α), a / b * b = a :=
  by sorry

The theorem `IsUnit.div_mul_cancel` states that for any type `α` that forms a Division Monoid, and for any element `b` of type `α` that is a unit (i.e., has a two-sided inverse), for any element `a` of type `α`, the operation of dividing `a` by `b`, and then multiplying the result by `b`, gives us back the original element `a`. In other words, if `b` is a unit in a division monoid, division by `b` followed by multiplication by `b` is a cancelling operation.

For any division monoid `α` and unit `b` in `α`, we have `(a / b) * b = a` for all `a` in `α`.


theorem MeasureTheory.ae_eq_empty :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      s =ᶠ[MeasureTheory.Measure.ae μ] ∅ ↔ ↑↑μ s = 0 :=
  by sorry

The theorem `MeasureTheory.ae_eq_empty` states that for any type `α`, which is equipped with a `MeasurableSpace` structure, a measure `μ` of type `MeasureTheory.Measure α`, and a set `s` of elements of type `α`, `s` is almost everywhere equal to the empty set with respect to the filter associated with `μ` if and only if the measure of `s` is zero. The filter associated with `μ` represents the "almost everywhere" concept, which means that a property holds except on a set of measure zero. In simple terms, in a given measurable space, a set is essentially empty (almost everywhere) if its measure is zero.

For any measurable space `(α, Σ, μ)`, a set `s ∈ Σ` is almost everywhere equal to the empty set if and only if its measure `μ(s)` is zero.


theorem Finset.normalize_gcd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α}, normalize (Finset.gcd s f) = Finset.gcd s f :=
  by sorry

The theorem `Finset.normalize_gcd` asserts that for any finite set `s` of type `β` and any function `f` from `β` to `α`, where `α` is a type equipped with a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid` structure, the normalized greatest common divisor (`gcd`) of the images of the elements of `s` under `f` is equal to the `gcd` itself. In other words, normalizing the `gcd` does not change its value. This means that the `gcd` is already in its normalized form.

For any finite set `s` and function `f` from a type `β` to a type `α` with `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` structures, the normalized greatest common divisor of `f` applied to the elements of `s` equals the ordinary greatest common divisor of these images.


theorem Finset.card_eq_iff_eq_univ :
    ∀ {α : Type u_1} [inst : Fintype α] (s : Finset α), s.card = Fintype.card α ↔ s = Finset.univ := by sorry

The theorem `Finset.card_eq_iff_eq_univ` states that for any given type `α` with a finite number of elements (or `Fintype α`), and for any finite set `s` of type `α` (or `Finset α`), the cardinality of `s` (number of elements in `s`) is equal to the total number of elements of type `α` if and only if `s` is the universal finite set of type `α`. In other words, a finite set `s` contains all possible elements of its type `α` if and only if the number of elements in `s` equals the total count of elements of `α`.

For any finite type `α` and finite set `s` of type `Finset α`, the cardinalities of `s` and `α` are equal if and only if `s` is the universal set of type `α`.


theorem segment_eq_image :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] (x y : E),
      segment 𝕜 x y = (fun θ => (1 - θ) • x + θ • y) '' Set.Icc 0 1 :=
  by sorry

This theorem states that for any ordered ring `𝕜` and an additive commutative group `E` that is also a `𝕜`-module, any segment between two points `x` and `y` in `E` is equal to the image of the closed interval [0, 1] under the function that maps each point `θ` to the point `(1 - θ) • x + θ • y`. In simple terms, it provides a parameterization of the line segment between two points in a vector space.

For any ordered ring `𝕜` and an additive commutative `𝕜`-module `E`, the segment from `x` to `y` in `E` equals the image of the interval `[0, 1]` under the function `θ ↦ (1 - θ) * x + θ * y`.


theorem MonoidHom.comp_apply :
    ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : MulOneClass M] [inst_1 : MulOneClass N]
      [inst_2 : MulOneClass P] (g : N →* P) (f : M →* N) (x : M), (MonoidHom.comp g f) x = g (f x) :=
  by sorry

The theorem `MonoidHom.comp_apply` states that for any given types `M`, `N`, and `P`, which are instances of the class `MulOneClass`, and given two monoid homomorphisms `g : N →* P` and `f : M →* N`, the application of the composition of `g` and `f` to an element `x` of `M` is equal to the application of `g` to the result of applying `f` to `x`. In other words, `(MonoidHom.comp g f) x = g (f x)`. This theorem formalizes the concept of function composition in the context of monoid homomorphisms.

For any types `M`, `N`, and `P` instanced with `MulOneClass`, and given monoid homomorphisms `f : M →* N` and `g : N →* P`, `(MonoidHom.comp g f) x = g (f x)` for all `x : M`.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
      CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.rightUnitor Y).inv =
        CategoryTheory.CategoryStruct.comp
          (CategoryTheory.MonoidalCategory.rightUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv
          (CategoryTheory.MonoidalCategory.associator X Y (𝟙_ C)).hom :=
  by sorry

This theorem, which is given for any monoidal category, states that for any two objects, X and Y, in the category, the left whisker of the inverse of the right unitor of Y with respect to X is equal to the composition of the inverse of the right unitor of the tensor product of X and Y and the homomorphism of the associator of X, Y, and the identity object.

In more detail, in the context of category theory, a "whiskering" operation is a way to apply a functor to a natural transformation. Here, the "left whisker" operation applies a functor (coming from object X) to a natural transformation (the inverse of the right unitor for Y). This is proven to be equal to a certain composition of morphisms, specifically the composition of the inverse of the right unitor of the tensor product of X and Y, with the homomorphism (morphism) of an associator with X, Y and the monoidal unit (𝟙_ C) as arguments. The right unitor and associator are specific structures associated with a monoidal category, which is a category equipped with a tensor product operation and certain axiomatic transformations.

For any monoidal category, the left whisker of the inverse of the right unitor of object Y with respect to X equals the composition of the inverse of the right unitor of X ⊗ Y, the homomorphism of the associator of X, Y, and 𝟙\_C.


theorem Finset.map_nonempty :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α}, (Finset.map f s).Nonempty ↔ s.Nonempty := by sorry

The theorem `Finset.map_nonempty` states that for any types `α` and `β`, for any embedding `f` from `α` to `β`, and for any finset `s` of type `α`, the mapped finset `Finset.map f s` is nonempty if and only if the original finset `s` is nonempty. In other words, the image of a nonempty finset under an embedding is nonempty, and a finset has a nonempty image under an embedding only if it is nonempty itself.

Given an embedding `f` from type `α` to `β` and a nonempty finset `s` of type `α`, the image `Finset.map f s` is also a nonempty finset.


theorem AddLocalization.mk_add :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} (a c : M) (b d : ↥S),
      AddLocalization.mk a b + AddLocalization.mk c d = AddLocalization.mk (a + c) (b + d) :=
  by sorry

This theorem, `AddLocalization.mk_add`, states that for any given additive commutative monoid `M` and a submonoid `S`, if you have two pairs of elements `(a, b)` and `(c, d)` where `a` and `c` are from `M` and `b` and `d` are from `S`, then the sum of the equivalence classes of these two pairs in the localization of `M` at `S`, denoted by `AddLocalization.mk a b + AddLocalization.mk c d`, is equal to the equivalence class of the pair `(a + c, b + d)` in the same localization. Here, `a + c` and `b + d` denote the sums in the monoid `M` and the submonoid `S` respectively.

Given an additive commutative monoid `M` and a submonoid `S`, the localization of pairs of elements from `M` and `S` in `AddLocalization M S` satisfies `AddLocalization.mk a b + AddLocalization.mk c d = AddLocalization.mk (a + c) (b + d)`, where `a`, `b`, `c`, and `d` are elements from `M` and `S` respectively.


theorem Int.dvd_trans : ∀ {a b c : ℤ}, a ∣ b → b ∣ c → a ∣ c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` divides `b` and `b` divides `c`, then `a` also divides `c`. In other words, the "divides" relation is transitive on the integers: it can pass from `a` to `b` and from `b` to `c`, hence from `a` to `c`. This theorem is a form of the transitive property applied to integer division.

If `a` divides `b` and `b` divides `c`, then `a` divides `c`. (Transitivity of integer division)


theorem PiNat.dist_comm : ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n), dist x y = dist y x := by sorry

This theorem states that the distance function `dist` in the space of dependent functions (indexed by natural numbers, `ℕ`) is commutative. In other words, for any two functions `x` and `y` where each function maps a natural number `n` to a value of type `E n`, the distance from `x` to `y` is the same as the distance from `y` to `x`.

For any two dependent functions `x` and `y` : ℕ → E, the commutativity of the distance function `dist` holds: dist (x _) (y _) = dist (y _) (x _).


theorem dslope_of_ne :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {a b : 𝕜} (f : 𝕜 → E), b ≠ a → dslope f a b = slope f a b :=
  by sorry

The theorem `dslope_of_ne` states that for any nontrivially normed field `𝕜`, normed add commutative group `E`, and normed space over `𝕜` and `E`, given two elements `a` and `b` of `𝕜` and a function `f` from `𝕜` to `E`, if `b` is not equal to `a`, then the directional slope `dslope` of the function `f` at points `a` and `b` is equal to the slope of `f` on the interval `[a, b]`. In other words, when `a` and `b` are distinct, the directional slope and the slope coincide.

For any nontrivially normed field `𝕜`, normed add commutative group `E`, and normed space over `𝕜` and `E`, if `f` is a function from `𝕜` to `E`, `a` and `b` are distinct elements of `𝕜`, then `dslope(f, a, b) = slope(f, [a, b])`.


Order.isPredLimit.dual

/-- **Alias** of the reverse direction of `Order.isSuccLimit_toDual_iff`. -/
theorem Order.isPredLimit.dual :
    ∀ {α : Type u_1} [inst : LT α] {a : α}, Order.IsPredLimit a → Order.IsSuccLimit (OrderDual.toDual a) := by sorry

This theorem, `Order.isPredLimit.dual`, states that for any type `α` with a less than structure (`LT α`), if a given element `a` of that type is a predecessor limit, then the dual of `a` is a successor limit. Here, a "predecessor limit" is defined as a value that isn't less than any other value, while a "successor limit" is a value that isn't greater than any other value. The operation `OrderDual.toDual` is simply returning the dual element `a` in the order dual of `α`.

If `a` is a predecessor limit in the ordered type `α`, then the dual of `a` is a successor limit in the order dual of `α`.


theorem Mathlib.Analysis.Complex.Basic._auxLemma.11 :
    ∀ {α : Type u_1} {f : α → ℝ} {x : ℝ}, HasSum (fun x => ↑(f x)) ↑x = HasSum f x := by sorry

This theorem, `Mathlib.Analysis.Complex.Basic._auxLemma.11`, states that for any type `α`, any function `f` from `α` to the real numbers `ℝ`, and any real number `x`, the condition that the series sum of the complexified function values equals the complex number `x` is equivalent to the condition that the series sum of the function values equals the real number `x`. In other words, the sum of the complexified function `f` converges to the complexified limit if and only if the sum of the function `f` converges to the real limit.

The complexification of a real-valued function `f : α → ℝ` converges to a complex number `x ∈ ℝ + iℝ` if and only if `f` converges to the real part of `x`.


theorem Mathlib.Data.Sym.Sym2._auxLemma.20 :
    ∀ {α : Type u_1} (s : Set (Sym2 α)) (x y : α), Sym2.ToRel s x y = (s(x, y) ∈ s) := by sorry

This theorem states that for any type `α`, any set `s` of symmetric pairs of type `α`, and any elements `x` and `y` of type `α`, the property of `(x, y)` being in the symmetric relation derived from set `s` is equivalent to the pair `(x, y)` being a member of the set `s`. In simpler terms, it claims that the symmetric relation described by `Sym2.ToRel` for a particular set `s` of unordered pairs, is the same as the membership relation of the pairs in that set.

For any set `s` of symmetric pairs of type `α`, the relation defined by `Sym2.ToRel` on type `α` is equal to the membership relation of `s`.


theorem Polynomial.nodup_roots :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      Polynomial.Separable p → Multiset.Nodup (Polynomial.roots p) :=
  by sorry

This theorem states that for any polynomial `p` over a commutative ring `R` that is an integral domain, if `p` is a separable polynomial (which means it is coprime with its derivative), then the roots of `p` occur with multiplicity at most 1, i.e., there are no duplicate roots. In other words, all the roots of `p` are distinct.

If `p` is a separable polynomial over an integral domain `R`, then `p` has no repeated roots.


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

This theorem states that for any types `α` and `β`, and any elements `a₁`, `a₂` of `α` and `b` of `β`, given a scalar multiplication operation on `α` and `β`, and the preorder relations on `α` and `β`, if the scalar multiplication of `a₁` and `b` is less than or equal to the scalar multiplication of `a₂` and `b`, and if `b` is greater than zero, then `a₁` is less than or equal to `a₂`. The proof of this theorem is not provided (`sorry`). This theorem also requires `SMulPosReflectLE α β` which ensures that scalar multiplication reflects the preorder relation.

If for types `α` and `β`, `a₁`, `a₂` in `α`, `b` in `β`, and a scalar multiplication `SMul` satisfying `SMulPosReflectLE α β`, we have `SMul a₁ b ≤ SMul a₂ b` and `b > 0`, then `a₁ ≤ a₂`.


theorem CategoryTheory.Limits.Pi.map'_comp_π :
    ∀ {β : Type w} {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C}
      [inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : β → α)
      (q : (b : β) → f (p b) ⟶ g b) (b : β),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.map' p q) (CategoryTheory.Limits.Pi.π g b) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π f (p b)) (q b) :=
  by sorry

The theorem `CategoryTheory.Limits.Pi.map'_comp_π` states the following: Given two types `α` and `β`, a category `C`, two functions `f: α → C` and `g: β → C` that have products in `C`, a function `p: β → α`, and a family of morphisms `q: (b : β) → f (p b) ⟶ g b`, for any element `b` in `β`, the composition of the map induced by `p` and `q` with the `b`-th projection from the product of `g` is equal to the composition of the `p b`-th projection from the product of `f` with the `b`-th morphism in the family `q`. In other words, this theorem relates the composition of morphisms in terms of their products, emphasizing the interplay between composition, products, and the specific morphisms in the category.

Given functions `f: α → C`, `g: β → C`, `p: β → α`, and families of morphisms `q: (b : β) → f (p b) ⟶ g b`, the maps `(π₁ ∘ q) (b) = (g b) ∘ (π₂ (p, b))` for all `b: β`, where `π₁` and `π₂` are the projections of the products of `f` and `g` and `β × α`, respectively.


theorem Mathlib.Data.Sym.Sym2._auxLemma.13 : ∀ {α : Type u_1} {a b c : α}, (a ∈ s(b, c)) = (a = b ∨ a = c) := by sorry

This theorem, named `Mathlib.Data.Sym.Sym2._auxLemma.13`, states that for any type `α` and any three elements `a`, `b`, and `c` of type `α`, the statement "`a` is an element of the symmetric pair `(b, c)`" is equivalent to saying "`a` is equal to `b` or `a` is equal to `c`". Thus, an element is in the symmetric pair if and only if it is equal to one of the elements of the pair.

For any type α and elements a, b, c of α, a is in the symmetric pair (b, c) if and only if a is equal to b or a is equal to c.


/-- The comap of the cocompact filter on `Y` by a continuous function `f : X → Y` is less than or
equal to the cocompact filter on `X`.
This is a reformulation of the fact that images of compact sets are compact.  -/
theorem Filter.comap_cocompact_le :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f → Filter.comap f (Filter.cocompact Y) ≤ Filter.cocompact X :=
  by sorry

This theorem states that for any two types `X` and `Y` with associated topological spaces, and any continuous function `f` from `X` to `Y`, the comap (the inverse image filter) of the cocompact filter on `Y` under the function `f` is less than or equal to the cocompact filter on `X`. This is an equivalent formulation of the property that the continuous image of compact sets are compact. Here, `cocompact` is a filter generated by the complements of compact sets in a given topological space.

For any continuous function between topological spaces and the complement of a compact set in the domain, the inverse image filter is contained in the cocompact filter on the codomain.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.29 : ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the proposition "a AND b AND c" is logically equivalent to the proposition "(a AND b) AND c". In other words, the order in which logical AND operations are grouped does not change the truth value of the overall expression, which is a property known as associativity in logic.

The theorem asserts the logical equivalence of `(a AND b) AND c` and `a AND (b AND c)` for any propositions `a`, `b`, and `c`.


theorem le_tsub_of_add_le_right :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α} [inst_4 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      a + b ≤ c → a ≤ c - b :=
  by sorry

This theorem states that for any type `α` that has the properties of a Preorder (reflexivity and transitivity), an Additive Commutative Semigroup (associative and commutative addition), and Subtraction that is ordered, if `a + b` is less than or equal to `c`, then `a` is less than or equal to `c - b`. This theorem also assumes a `ContravariantClass`, which means that the addition operation (`x + x_1`) is contravariant in the sense that if by adding some elements the second argument decreases, then the result increases.

If `α` is a preorder with reflexive and transitive relation, an additive commutative semigroup with contravariant addition, and subtraction ordered, then for all `a, b, c` in `α`, if `a + b ≤ c`, then `a ≤ c - b`.


theorem StructureGroupoid.chart_mem_maximalAtlas :
    ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
      (G : StructureGroupoid H) [inst_3 : HasGroupoid M G] (x : M), chartAt H x ∈ StructureGroupoid.maximalAtlas M G :=
  by sorry

The theorem `StructureGroupoid.chart_mem_maximalAtlas` states that for any type `H` equipped with a topological space structure, any type `M` equipped with a topological space structure and a charted space structure over `H`, any `StructureGroupoid` `G` over `H`, and any `x` of type `M` which also forms a groupoid with `G`, the preferred chart at point `x` (`chartAt H x`) is an element of the maximal atlas of `M` with respect to the structure groupoid `G` (`StructureGroupoid.maximalAtlas M G`). In other words, every point in a charted space has a chart that is part of the maximal atlas for the associated structure groupoid.

For any type equipped with topological and charted space structures, a point forming a groupoid with a given structure groupoid has a preferred chart that belongs to the maximal atlas of the charted space with respect to that structure groupoid.


theorem isAtomic_dual_iff_isCoatomic :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α], IsAtomic αᵒᵈ ↔ IsCoatomic α := by sorry

This theorem states that for any type `α` with a partial order and a greatest element (order top), the dual of `α` is atomic if and only if `α` is coatomic. In this context, an "atomic" order means that every element is below some atom (an indivisible unit), while a "coatomic" order means every element is below some coatom (an element that cannot be divided further).

For a type `α` with a partial order and a greatest element, the dual order is atomic if and only if `α` is coatomic.


theorem Finset.fold_op_rel_iff_and :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {r : β → β → Prop},
      (∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z) →
        ∀ {c : β}, r c (Finset.fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x) :=
  by sorry

This theorem states that for any types `α` and `β`, any commutative associative operation `op` on `β`, any function `f` from `α` to `β`, any elements `b` and `c` of `β`, any finset `s` of `α`, and any binary relation `r` on `β`, assuming the property that for all `x`, `y`, and `z` in `β`, `r x` holds on the operation of `y` and `z` if and only if `r x` holds on `y` and `r x` holds on `z`, then `r c` holds on the fold of `op` over the `f`-image of `s` with base `b` if and only if `r c` holds on `b` and for all `x` in `s`, `r c` holds on `f x`. In mathematical terms, \( r(c, \text{fold}\,op\,b\,f\,s) \) is equivalent to \( r(c, b) \) and \( \forall x\, \in s, r(c, f(x)) \).

For any commutative associative operation `op` on type `β`, function `f` from `α` to `β`, and binary relation `r` satisfying the given condition, `r` holds on the fold of `op` over the `f`-image of a finite set `s` with base `b` if and only if it holds on `b` and for all `x` in `s`, `r` holds on `f(x)`.


theorem FirstOrder.Language.Theory.SemanticallyEquivalent.realize_bd_iff :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} {α : Type w} {n : ℕ}
      {φ ψ : FirstOrder.Language.BoundedFormula L α n} {M : Type (max u v)} [inst : Nonempty M]
      [inst : FirstOrder.Language.Structure L M] [inst_1 : M ⊨ T],
      FirstOrder.Language.Theory.SemanticallyEquivalent T φ ψ →
        ∀ {v : α → M} {xs : Fin n → M},
          FirstOrder.Language.BoundedFormula.Realize φ v xs ↔ FirstOrder.Language.BoundedFormula.Realize ψ v xs :=
  by sorry

This theorem states that for any first-order language `L`, a theory `T` of `L`, a type `α`, a natural number `n`, two bounded formulas `φ` and `ψ` of `L` over `α` of length `n`, a type `M`, and given that `M` is nonempty, `M` is a structure of `L`, and `M` is a model of `T`, if `φ` and `ψ` are semantically equivalent over `T`, then for any valuation `v` from `α` to `M` and any sequence `xs` of length `n` in `M`, the bounded formulas `φ` and `ψ` are realized in the same way, i.e., the realization of `φ` with `v` and `xs` is equivalent to the realization of `ψ` with `v` and `xs`. In other words, if two formulas are semantically equivalent in a theory, they evaluate to the same truth value under any interpretation in any model of the theory.

For any first-order language L, theory T, type α, natural number n, nonempty type M model of T, valuation v from α to M, sequence xs of length n in M, and bounded formulas φ and ψ of L over α of length n that are semantically equivalent over T, their realizations with v and xs are equivalent.