Xor'.or

theorem Xor'.or : ∀ {a b : Prop}, Xor' a b → a ∨ b := by sorry

This theorem states that for any two propositions 'a' and 'b', if the exclusive or 'Xor'' of 'a' and 'b' is true, then the inclusive or (denoted as 'a ∨ b' in Lean and similarly in LaTeX) of 'a' and 'b' must also be true. In other words, if 'a' and 'b' cannot both be true or false (the definition of 'Xor''), then at least one of 'a' or 'b' is true.

If $a \mathop{\mathsf{Xor}} b$ holds, then $a \vee b$ is true.


/-- The fourth simplicial identity  -/
theorem SimplexCategory.δ_comp_σ_of_gt :
    ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
      Fin.castSucc j < i →
        CategoryTheory.CategoryStruct.comp (SimplexCategory.δ (Fin.succ i)) (SimplexCategory.σ (Fin.castSucc j)) =
          CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j) (SimplexCategory.δ i) :=
  by sorry

This theorem, known as the fourth simplicial identity, is stated within the context of the simplex category. For all natural numbers `n`, and for any `i` in `Fin (n + 2)` and `j` in `Fin (n + 1)`, if `j` embedded into `Fin (n + 2)` via `Fin.castSucc` is less than `i`, then the composition of the `i`-th face map of `[n]` to `[n+1]` after incrementing `i` with the `j`-th degeneracy map from `[n+1]` to `[n]` after embedding `j` into `Fin (n + 2)`, is the same as the composition of the `j`-th degeneracy map from `[n+1]` to `[n]` with the `i`-th face map from `[n]` to `[n+1]`. In mathematical terms, this means δ(i+1) ∘ σ(j+1) = σ(j) ∘ δ(i) whenever j+1 < i.

For all natural numbers n and i, j in Fin (n+2), if j < i then the i-th face map of [n] to [n+1] followed by the j-th degeneracy map from [n+1] to [n] equals the j-th degeneracy map from [n+1] to [n] followed by the i-th face map from [n] to [n+1].


theorem Basis.card_le_card_of_linearIndependent :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] {ι : Type u_1} [inst_4 : Fintype ι],
      Basis ι R M →
        ∀ {ι' : Type u_2} [inst_5 : Fintype ι'] {v : ι' → M},
          LinearIndependent R v → Fintype.card ι' ≤ Fintype.card ι :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and `M` is a module over `R` with the strong rank condition, given a basis `ι` for `M` over `R` and a linearly independent family of vectors `v` in `M` indexed by `ι'`, if `ι'` and `ι` are both finite types, then the number of elements in `ι'` is less than or equal to the number of elements in `ι`. In simpler terms, in a vector space with a strong rank condition, the size of any linearly independent set cannot exceed the size of any basis of the vector space.

In a module over a ring with the strong rank condition, the size of any linearly independent family is less than or equal to the size of any basis.


theorem Fin.castAdd_zero : ∀ {n : ℕ}, Fin.castAdd 0 = Fin.cast ⋯ := by sorry

The theorem `Fin.castAdd_zero` states that for all natural numbers `n`, the function `Fin.castAdd 0` is equal to the function `Fin.cast`. In simpler terms, it means that adding 0 to a finite set `Fin n` -- a procedure defined by `Fin.castAdd 0` -- is the same as casting `Fin n` to itself, which is the operation performed by the `Fin.cast` function. This theorem is a reflection of a basic arithmetic principle, that adding zero doesn't change the value of a number, adapted to the context of finite sets in Lean 4.

For all natural numbers `n`, `Fin.castAdd 0 (Fin.cast n) = Fin.cast n`.


theorem Nat.clog_one_right : ∀ (b : ℕ), Nat.clog b 1 = 0 := by sorry

The theorem `Nat.clog_one_right` states that for any natural number `b`, the upper logarithm of `1` in base `b` is `0`. In other words, it reveals that the smallest `k : ℕ` such that `1 ≤ b^k` is always `0`, regardless of the base `b`. This is consistent with the mathematical notion that any number to the power of `0` equals `1`.

The theorem `Nat.clog_one_right` asserts that the upper logarithm of 1 with respect to any base is 0 in Lean.


theorem Fin.cycleRange_of_gt : ∀ {n : ℕ} {i j : Fin (Nat.succ n)}, i < j → (Fin.cycleRange i) j = j := by sorry

The theorem `Fin.cycleRange_of_gt` states that for any natural number `n` and any two finite numbers `i` and `j` within the range `0` to `n+1`, if `i` is less than `j`, then applying the `Fin.cycleRange` function to `i` and then applying the resulting permutation to `j` results in `j` itself. In other words, if `i` is less than `j`, `j` is left unchanged by the permutation generated by `Fin.cycleRange i`.

For all natural numbers n, if i < j in the range 0 to n+1, then applying the permutation obtained from Fin.cycleRange i leaves j unchanged.


/-- **Alias** of `ssubset_of_subset_of_ne`. -/
theorem HasSubset.Subset.ssubset_of_ne :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α}
      [inst_3 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊆ b → a ≠ b → a ⊂ b :=
  by sorry

This theorem, aptly named `HasSubset.Subset.ssubset_of_ne`, states the following: Given any type `α` that has a subset and strict subset relations, and these relations form a non-strict strict order on `α` (meaning that the subset relation is reflexive and transitive, and the strict subset relation is irreflexive and transitive), if `a` and `b` are elements of `α` such that the subset relation is also antisymmetric (if `a` is a subset of `b` and `b` is a subset of `a`, then `a` equals `b`), then if `a` is a subset of `b` and `a` is not equal to `b`, it follows that `a` is a strict subset of `b`. In mathematical terms, for any `a` and `b` in `α`, if `a ⊆ b` and `a ≠ b`, then `a ⊂ b`.

If `α` is a type with reflexive, transitive subset relation `⊆` and irreflexive, transitive strict subset relation `⊂`, then for all `a, b` in `α`, if `a ⊆ b` and `a ≠ b`, then `a ⊂ b`.


AffineIsometryEquiv.injective

theorem AffineIsometryEquiv.injective :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (e : P ≃ᵃⁱ[𝕜] P₂), Function.Injective ⇑e :=
  by sorry

The theorem `AffineIsometryEquiv.injective` states that for any normed field `𝕜`, seminormed add commutative group `V` and `V₂`, normed space over `𝕜` for `V` and `V₂`, pseudometric spaces `P` and `P₂`, and normed add torsors `P` over `V` and `P₂` over `V₂`, any affine isometry equivalence `e` between `P` and `P₂` (denoted as `P ≃ᵃⁱ[𝕜] P₂`), the function `e` is injective. In other words, if two points in `P` are mapped to the same point in `P₂` by `e`, then those two points must be the same. This is a property of affine isometry equivalences in the context of normed field and normed spaces.

Given any affine isometry equivalence between two normed add torsors over normed spaces and seminormed add commutative groups in a normed field, the equivalence function is injective.


/-- An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if it is separable over `F`.  -/
theorem le_separableClosure :
    ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (L : IntermediateField F E)
      [inst_3 : IsSeparable F ↥L], L ≤ separableClosure F E :=
  by sorry

This theorem states that for any intermediate field `L` of a field extension `E / F`, if `L` is separable over `F`, then `L` is contained in the separable closure of `F` in `E`. Here, a field is separable if its elements are roots of a separable polynomial, and the separable closure of a field `F` in an extension `E` is the subfield generated by the separable elements of `E` over `F`.

If `L` is an intermediate field of a field extension `E/F` that is separable over `F`, then `L` is contained in the separable closure of `F` in `E`.


theorem MeasurableEmbedding.set_integral_map :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {μ : MeasureTheory.Measure X} {Y : Type u_5} {x : MeasurableSpace Y} {f : X → Y},
      MeasurableEmbedding f →
        ∀ (g : Y → E) (s : Set Y),
          ∫ (y : Y) in s, g y ∂MeasureTheory.Measure.map f μ = ∫ (x : X) in f ⁻¹' s, g (f x) ∂μ :=
  by sorry

This theorem states that for any two types `X` and `Y`, if `X` is a measurable space and `E` is a normed group over the real numbers, then given a measure `μ` on `X`, any measurable embedding function `f` from `X` to `Y`, and any function `g` from `Y` to `E`, the integral of `g` over a set `s` in `Y` with respect to the measure induced by `f` is equal to the integral of the composed function `g ∘ f` over the preimage of `s` under `f` with respect to the measure `μ`. This theorem thus links the integration of a function over a set in the codomain of a measurable embedding to the integration over the preimage of the set in the domain.

For any measurable spaces X and Y, normed group E over the real numbers, measure μ on X, measurable embedding f : X → Y, and function g : Y → E, the integral of g over a set s in Y with respect to the measure induced by f is equal to the integral of g ∘ f over the preimage of s under f with respect to μ.


theorem MeasureTheory.Measure.prod_dirac :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.SFinite μ] (y : β),
      MeasureTheory.Measure.prod μ (MeasureTheory.Measure.dirac y) = MeasureTheory.Measure.map (fun x => (x, y)) μ :=
  by sorry

The theorem `MeasureTheory.Measure.prod_dirac` states that for any measurable space `α` and `β`, any measure `μ` on `α` that is sigma-finite, and any element `y` of `β`, the product measure of `μ` and the dirac measure at `y` is equal to the pushforward of `μ` via the map that sends each element `x` of `α` to the pair `(x, y)`. In other words, it specifies how the dirac measure interacts with the operation of forming product measures.

For any sigma-finite measure `μ` on measurable space `(α, Σα)`, and any `y` in measurable space `(β, Σβ)`, the product measure of `μ` and the Dirac measure at `y` is equal to the pushforward of `μ` under the map sending `x` to `(x, y)`.


theorem Sym2.mem_iff : ∀ {α : Type u_1} {a b c : α}, a ∈ s(b, c) ↔ a = b ∨ a = c := by sorry

This theorem states that for any type `α` and any elements `a`, `b`, and `c` of that type, `a` is a member of the symmetric pair formed by `b` and `c` (denoted as `s(b, c)`) if and only if `a` is equal to `b` or `a` is equal to `c`. In other words, an element belongs to a symmetric pair if it is one of the elements forming the pair.

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


theorem Fin.cycleRange_of_le :
    ∀ {n : ℕ} {i j : Fin (Nat.succ n)}, j ≤ i → (Fin.cycleRange i) j = if j = i then 0 else j + 1 := by sorry

The theorem `Fin.cycleRange_of_le` states that for any natural number `n` and for any two elements `i` and `j` of the finite set `Fin (Nat.succ n)`, if `j` is less than or equal to `i`, then the result of applying the `cycleRange` function to `i` and then applying the resulting permutation to `j` is equal to `0` if `j` equals `i`, otherwise it is equal to `j + 1`. Here, the `cycleRange` function is defined as rotating the indices from `0` up to `i`, leaving the rest unchanged.

For any natural number `n` and `i`, `j` in `Fin (Nat.succ n)`, if `j ≤ i`, then `cycleRange i j = if j = i then 0 else j + 1`.


theorem div_self_of_invertible : ∀ {α : Type u} [inst : GroupWithZero α] (a : α) [inst_1 : Invertible a], a / a = 1 :=
  by sorry

This theorem, `div_self_of_invertible`, states that for all types `α` which are a `GroupWithZero`, if `a` is an element of `α` and `a` is invertible (i.e., it has a multiplicative inverse), then the division of `a` by itself equals 1. In other words, any invertible element in a group with a zero element divided by itself will always give 1.

For all types `α` that are a `GroupWithZero` and for all invertible elements `a` in `α`, `a * a^(-1) = 1`.


theorem EReal.coe_mul_bot_of_neg : ∀ {x : ℝ}, x < 0 → ↑x * ⊥ = ⊤ := by sorry

This theorem states that for every real number 'x' such that 'x' is less than zero, the product of the extended real number representation of 'x' and negative infinity equals positive infinity. In other words, if you have a negative real number and you multiply it with negative infinity (in the extended real number system), you will get positive infinity.

For every real number `x` below zero, `x * (-∞) = ∞`.


theorem Localization.localRingHom.proof_4 :
    ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_2} [inst_1 : CommSemiring P] (I : Ideal R)
      [hI : Ideal.IsPrime I] (J : Ideal P) [inst_2 : Ideal.IsPrime J] (f : R →+* P),
      I = Ideal.comap f J → Ideal.primeCompl I ≤ Submonoid.comap f (Ideal.primeCompl J) :=
  by sorry

This theorem states that for any commutative semirings `R` and `P`, a prime ideal `I` of `R`, a prime ideal `J` of `P`, and a ring homomorphism `f` from `R` to `P`, if `I` is the preimage of `J` under `f`, then the complement of `I` is a submonoid of the preimage of the complement of `J` under `f`. In other words, if we map `I` to `J` using `f`, then the elements of `R` not in `I` are mapped to the elements of `P` not in `J`.

If `f` is a ring homomorphism from a commutative semiring `R` to another commutative semiring `P`, `I` is a prime ideal of `R`, `J` is a prime ideal of `P`, and `I = f^(-1)(J)`, then `f(R \ I) ⊆ P \ J`.


theorem DirichletCharacter.factorsThrough_conductor :
    ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n),
      DirichletCharacter.FactorsThrough χ (DirichletCharacter.conductor χ) :=
  by sorry

This theorem states that for any commutative monoid with zero `R`, any natural number `n`, and any Dirichlet character `χ` of level `n` over `R`, the Dirichlet character `χ` factors through its conductor. In other words, the conductor of `χ`, which is the smallest natural number `m` such that `χ` is periodic on integers modulo `m`, divides `n` and there exists a Dirichlet character `χ₀` of level `m` such that `χ` is equivalent to `χ₀` applied to the mapping from integers modulo `n` to integers modulo `m`.

Given a commutative monoid with zero `R`, any Dirichlet character `χ` of level `n` over `R` factors through its conductor `m`, i.e., `χ` is equivalent to some Dirichlet character `χ₀` of level `m` on integers modulo `n`.


theorem Subalgebra.equivOfEq.proof_2 :
    ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S T : Subalgebra R A), S = T → Subalgebra.toSubmodule S = Subalgebra.toSubmodule T :=
  by sorry

This theorem, `Subalgebra.equivOfEq.proof_2`, states that for any types `R` and `A`, with `R` being a commutative semiring and `A` a semiring on which `R` is an algebra, if `S` and `T` are two subalgebras of `A` over `R` that are equal, then the corresponding submodules of `S` and `T` obtained by the forgetful map from subalgebra to submodule, `Subalgebra.toSubmodule`, are also equal.

If `R` is a commutative semiring and `A` is an `R`-algebra, then equal `R`-subalgebras `S` and `T` of `A` have equal corresponding submodules `Subalgebra.toSubmodule S` and `Subalgebra.toSubmodule T`.


DifferentiableOn.analyticAt

/-- If `f : ℂ → E` is complex differentiable on some set `s`, then it is analytic at any point `z`
such that `s ∈ 𝓝 z` (equivalently, `z ∈ interior s`).  -/
theorem DifferentiableOn.analyticAt :
    ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : CompleteSpace E] {s : Set ℂ}
      {f : ℂ → E} {z : ℂ}, DifferentiableOn ℂ f s → s ∈ nhds z → AnalyticAt ℂ f z :=
  by sorry

The theorem `DifferentiableOn.analyticAt` states that if a function `f` from the complex numbers to a certain type `E`, which forms a complete normed add commutative group and normed space over the complex numbers, is complex differentiable on a set `s`, then it is analytic at any point `z` such that `s` is in the neighborhood of `z`. Equivalently, it says that if `f` is complex differentiable on `s`, then `f` is analytic at any point `z` lying in the interior of `s`. Being analytic at `z` means that the function `f` admits a power series expansion that converges to `f` in a neighborhood of `z`.

If a complex-valued function `f` is complex differentiable on a complex open set `s`, then it is analytic at every point `z` in the interior of `s`.


theorem NNReal.rpow_neg : ∀ (x : NNReal) (y : ℝ), x ^ (-y) = (x ^ y)⁻¹ := by sorry

This theorem, `NNReal.rpow_neg`, states that for every non-negative real number `x` and any real number `y`, the expression `x` raised to the power of `-y` is equal to the reciprocal of `x` raised to the power of `y`. In mathematical notation, this theorem says that for all x in non-negative reals and all y in reals, \(x^{-y} = \frac{1}{x^y}\).

For all non-negative real numbers x and real numbers y, $x^{-y} = \frac{1}{x^y}$.


theorem IsUpperSet.add_left :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] {s t : Set α}, IsUpperSet t → IsUpperSet (s + t) := by sorry

The theorem `IsUpperSet.add_left` states that for every type `α` which forms an ordered additive commutative group, if `t` is an upper set, then the set formed by adding every element of another set `s` to every element of `t` is also an upper set. In other words, if `t` is an upper set, the upward-closure property is maintained under the operation of left-addition by elements from the set `s`.

If `t` is an upper set in an ordered additive commutative group `α`, then the set `{x + y | x ∈ t, y ∈ s}` is also an upper set.


theorem Int.ediv_eq_zero_of_lt : ∀ {a b : ℤ}, 0 ≤ a → a < b → a / b = 0 := by sorry

This theorem states that for any two integers `a` and `b`, if `a` is non-negative and less than `b`, then the integer division of `a` by `b` equals zero. In mathematical terms, for all `a` and `b` in the set of integers such that `0 ≤ a < b`, we have `a / b = 0`. This follows from the definition of integer division where the quotient is rounded towards zero.

For all integers `a` and `b` with `0 ≤ a < b`, we have `a / b = 0`.


theorem Mathlib.Data.Set.Intervals.Group._auxLemma.3 :
    ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c := by sorry

This theorem, `Mathlib.Data.Set.Intervals.Group._auxLemma.3`, states that for any type `G` equipped with an `AddSemigroup` structure (i.e., there exists an associative addition operation for `G`), and for any three elements `a`, `b`, and `c` of type `G`, the sum of `a` and the sum of `b` and `c` is equal to the sum of `a`, `b`, and `c`. This is essentially the associative property of addition, which says that the way in which terms in an addition expression are grouped does not change the result of the operation. In mathematical notation, this is expressed as `a + (b + c) = a + b + c`.

The theorem asserts that for any type `G` with an `AddSemigroup` structure, the associative property of addition holds, that is, `a + (b + c) = a + b + c` for all `a, b, c` in `G`.


theorem OrderIso.map_atBot :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
      Filter.map (⇑e) Filter.atBot = Filter.atBot :=
  by sorry

This theorem states that for any two types `α` and `β` each equipped with a preorder relation, and given an order-preserving isomorphism `e` from `α` to `β`, the image under `e` of the filter `atBot` (representing the limit towards negative infinity) in `α` is equal to the filter `atBot` in `β`. In other words, `e` preserves the structure of "going to negative infinity" in the ordered sets. This is crucial for proving similar behavior of limits in different ordered spaces connected by such an isomorphism.

Given order-preserving isomorphisms between preordered types, the image of the filter of bottom elements under the isomorphism is equal to the filter of bottom elements in the target type.


theorem AddMonoidHom.map_indicator :
    ∀ {α : Type u_1} {M : Type u_6} {N : Type u_7} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N)
      (s : Set α) (g : α → M) (x : α), f (Set.indicator s g x) = Set.indicator s (⇑f ∘ g) x :=
  by sorry

The theorem `AddMonoidHom.map_indicator` states that for any types `α`, `M`, and `N` where `M` and `N` are additive monoids (having an addition operation and a zero element), for any additive monoid homomorphism `f` from `M` to `N`, any set `s` of type `α`, any function `g` from `α` to `M`, and any element `x` of type `α`, the value of `f` applied to the indicator function of `s` and `g` at `x` equals the indicator function of `s` and `f` composed with `g` at `x`.

In other words, if you have an additive monoid homomorphism and you apply it to the indicator function of a set, it's the same as if you first applied the function to the elements of the set and then calculated the indicator function. It essentially states that the process of applying the homomorphism commutes with the process of calculating the indicator function.

For any additive monoid homomorphism between additive monoids `M` and `N`, and any set `s` with indicator function `ind_s` and function `g` from `α` to `M`, `f(ind_s(g))(x) = ind_s(f(g(x)))` for all `x` in `α`.


theorem ContinuousMap.Homotopy.congr_fun :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
      {F G : ContinuousMap.Homotopy f₀ f₁}, F = G → ∀ (x : ↑unitInterval × X), F x = G x :=
  by sorry

This theorem, `ContinuousMap.Homotopy.congr_fun`, states that for any type `X` with a topology, and any type `Y` also with a topology, given two continuous maps `f₀` and `f₁` from `X` to `Y`, and two homotopies `F` and `G` from `f₀` to `f₁`, if `F` and `G` are the same, then for any pair consisting of a real number in the unit interval `[0,1]` and an element of `X`, the value of `F` at this pair is equal to the value of `G` at this pair. In other words, two equal homotopies between two continuous functions agree on all points in the unit interval cross the domain space.

If `f₀` and `f₁` are continuous maps from a topological space `X` to another topological space `Y`, and `F` and `G` are homotopies from `f₀` to `f₁`, then for all `x ∈ X` and `t ∈ [0,1]`, `F t x = G t x`.


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

This theorem states that, given a Grothendieck topology `J` on a category `C`, two functors `P` and `Q` from the opposite of `C` to another category `D`, a natural transformation `η` from `P` to `Q`, and assuming that `Q` is a sheaf with respect to `J`, the composition of the morphism from `P` to the sheafification of `P` with respect to `J` and the lift of `η` to the sheafification of `P` is equal to `η`. This holds under the conditions that for every object `X` in `C` and every cover `S` of `X` with respect to `J`, the multicospan associated with the indexing of `S` by `P` has a limit, and `D` has colimits of shapes indexed by the opposite of the set of covers of each object in `C`.

Given a Grothendieck topology on a category, if two oppositely-valued functors with a natural transformation between them, and one is a sheaf, then the composition of their morphisms to their respective sheafifications equals the natural transformation, provided the limits of multicospans associated with covers exist and the opposing category has colimits of cover shapes.


theorem variationOnFromTo.eq_of_ge :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) (s : Set α)
      {a b : α}, b ≤ a → variationOnFromTo f s a b = -(eVariationOn f (s ∩ Set.Icc b a)).toReal :=
  by sorry

This theorem states that for any types `α` and `E`, given that `α` has a linear order and `E` is a pseudo-emetric space, for any function `f` from `α` to `E` and for any set `s` of `α`, if `b ≤ a`, the signed variation of `f` on the interval from `a` to `b` intersected with the set `s` is equal to the negative of the real value of the variation of `f` on the set `s` intersected with the interval from `b` to `a`. The variation of a function on a set is defined as the supremum of the sum of the extended distances between the function values at the consecutive elements of all possible finite increasing sequences within the set.

For functions from a linearly ordered type to a pseudo-metric space, the variation of a function on an interval intersected with a set is equal to the negative of the variation of the function on the set intersected with the opposite interval.


minpoly.unique'

theorem minpoly.unique' :
    ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B)
      {p : Polynomial A},
      Polynomial.Monic p →
        (Polynomial.aeval x) p = 0 →
          (∀ (q : Polynomial A), Polynomial.degree q < Polynomial.degree p → q = 0 ∨ (Polynomial.aeval x) q ≠ 0) →
            p = minpoly A x :=
  by sorry

This theorem, referred to as `minpoly.unique'`, states that for any commutative ring `A`, ring `B`, algebra from `A` to `B`, and element `x` of `B`, given a polynomial `p` over `A` that is monic (i.e., its leading coefficient is 1) and such that the application of `x` to `p` through algebra homomorphism (denoted by `Polynomial.aeval x`) equals 0, if for all polynomials `q` over `A` with a degree less than the degree of `p`, `q` equals 0 or the application of `x` to `q` through algebra homomorphism is non-zero, then `p` is equal to the minimal polynomial of `x` over `A`.

In other words, a monic polynomial `p` that evaluates to 0 when applied with `x` and dominates all other such polynomials in terms of degree, is the minimal polynomial of `x` over `A`.

If `A` is a commutative ring, `B` is a ring, `Algebra A B` is an algebra from `A` to `B`, `x` is an element of `B`, `p` is a monic polynomial over `A` such that `Polynomial.aeval x p = 0` and `Polynomial.aeval x q = 0` implies `deg q < deg p` or `q = 0`, then `p` is the minimal polynomial of `x` over `A`.


theorem Matrix.map_add :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} [inst : Add α] [inst_1 : Add β] (f : α → β),
      (∀ (a₁ a₂ : α), f (a₁ + a₂) = f a₁ + f a₂) →
        ∀ (M N : Matrix m n α), Matrix.map (M + N) f = Matrix.map M f + Matrix.map N f :=
  by sorry

This theorem, named `Matrix.map_add`, states that for any types `m`, `n`, `α`, and `β` where `α` and `β` are types with addition defined on them, given a function `f` from `α` to `β` that preserves addition, i.e., `f (a₁ + a₂) = f a₁ + f a₂` for all `a₁, a₂` in `α`, then applying `f` to the sum of two matrices `M` and `N` with entries in `α` is the same as summing the results of applying `f` to each of the matrices `M` and `N` separately. In other words, this theorem asserts that mapping a function over the addition of two matrices is equivalent to adding the results of mapping the function over each matrix separately, assuming the function preserves addition.

Given matrices M and N with additive type entries α and a function f from α to another additive type β preserving addition, the application of f to the sum of M and N is equal to the sum of the applications of f to M and N.


/-- The tangent of an angle in a right-angled triangle multiplied by the adjacent side equals
the opposite side.  -/
theorem InnerProductGeometry.tan_angle_add_mul_norm_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → x ≠ 0 ∨ y = 0 → Real.tan (InnerProductGeometry.angle x (x + y)) * ‖x‖ = ‖y‖ :=
  by sorry

This theorem states that, in the context of an inner product space over the real numbers, given any two vectors `x` and `y`, if the inner product of `x` and `y` equals zero, and either `x` is non-zero or `y` is zero, then the tangent of the angle between `x` and `x + y`, multiplied by the norm of `x`, equals the norm of `y`. This is analogous to the geometric property of a right-angled triangle where the tangent of an angle multiplied by the length of the adjacent side equals the length of the opposite side.

In an inner product space over the real numbers, if the inner product of non-zero vectors `x` and `y` is zero, then the tangent of the angle between `x` and `x+y` is equal to the norm of `y` divided by the norm of `x`.


ContinuousLinearEquiv.contDiff

theorem ContinuousLinearEquiv.contDiff :
    ∀ {𝕜 : 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] {n : ℕ∞}
      (f : E ≃L[𝕜] F), ContDiff 𝕜 n ⇑f :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F` (which are also normed spaces over `𝕜`), and any natural number or infinity `n`, if `f` is a continuous linear equivalence from `E` to `F`, then the function `f` is `n`-times continuously differentiable.

If `f` is a continuous linear equivalence between normed spaces `E` and `F` over a non-trivially normed field, then `f` is `n`-times differentiable for any natural number or infinity `n`.


/-- Change of variables for continuous integrands. If `f` is continuous on `[a, b]` and has
continuous right-derivative `f'` in `(a, b)`, and `g` is continuous on `f '' [a, b]` then we can
substitute `u = f x` to get `∫ x in a..b, f' x • (g ∘ f) x = ∫ u in f a..f b, g u`.
 -/
theorem intervalIntegral.integral_comp_smul_deriv'' :
    ∀ {G : Type u_6} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {a b : ℝ} {f f' : ℝ → ℝ} {g : ℝ → G},
      ContinuousOn f (Set.uIcc a b) →
        (∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Set.Ioi x) x) →
          ContinuousOn f' (Set.uIcc a b) →
            ContinuousOn g (f '' Set.uIcc a b) → ∫ (x : ℝ) in a..b, f' x • (g ∘ f) x = ∫ (u : ℝ) in f a..f b, g u :=
  by sorry

This theorem is the change of variables for continuous integrands. Given two real numbers `a` and `b`, functions `f`, `f'`, and `g`, where `f'` is the right-derivative of `f`, the theorem states that if `f` is continuous on the closed interval from `a` to `b`, `f'` exists on the open interval from `a` to `b` (taken as the interval from the minimum of `a` and `b` to the maximum of `a` and `b`), `f'` is also continuous on the closed interval from `a` to `b`, and `g` is continuous on the image of the interval under `f`, then the integral from `a` to `b` of `f'` times the composite function `g ∘ f` equals the integral from `f(a)` to `f(b)` of `g`. That is, the theorem allows us to perform a change of variables under certain conditions, simplifying the integral of a function transform by `f` to the integral of `g` over the new range.

If `f` is a continuous function on a closed interval [a, b], `f'` exists and is continuous on the open interval (a, b), and `g` is continuous on the image of [a, b] under `f`, then the integral of `g ∘ f` from `a` to `b` equals the integral of `f'` times `g` over the image of [a, b] under `f`.


/-- A side of a right-angled triangle divided by the sine of the opposite angle equals the
hypotenuse.  -/
theorem InnerProductGeometry.norm_div_sin_angle_add_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → x = 0 ∨ y ≠ 0 → ‖y‖ / Real.sin (InnerProductGeometry.angle x (x + y)) = ‖x + y‖ :=
  by sorry

This theorem states that in the context of a vector space with an inner product, given two vectors `x` and `y` such that their inner product is zero (which geometrically means that they are orthogonal), and under the condition that vector `x` is either the zero vector or vector `y` is not zero, then the length of vector `y` divided by the sine of the angle between `x` and `x + y` is equal to the length of the vector `x + y`. This result can be interpreted geometrically as a generalization of a property of right-angled triangles.

Given a vector space with an inner product, if vectors `x` and `y` are orthogonal with `x ≠ 0`, then $\frac{||y||}{sin(\theta)} = ||x + y||$, where $\theta$ is the angle between `x` and `x + y`.


theorem CompactExhaustion.exists_mem :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X) (x : X), ∃ n, x ∈ K n := by sorry

This theorem states that for every type `X` that is equipped with a `TopologicalSpace` structure and a `CompactExhaustion` of `X` denoted by `K`, for every element `x` of `X`, there exists an integer `n` such that `x` is an element of `K n`. In other words, given a compact exhaustion `K` of a topological space `X`, any point in `X` is included in one of the compact subsets defined by `K`.

For any topological space `(X, top)` with a compact exhaustion `K = {K_n}`, every point `x` in `X` belongs to some `K_n`.


/-- Variant of `EqOn.image_eq`, for one function being the identity.  -/
theorem Set.EqOn.image_eq_self : ∀ {α : Type u_1} {s : Set α} {f : α → α}, Set.EqOn f id s → f '' s = s := by sorry

This theorem, `Set.EqOn.image_eq_self`, states that for any set `s` of type `α` and for any function `f` from `α` to `α`, if `f` is equal to the identity function on the set `s` (that is, for all `x` in `s`, `f(x)` equals `x`), then the image of `s` under `f` is the same as `s`. In other words, every element in `s` maps to itself under `f`, so the set of images under `f` is the same as the original set.

If a function from a set to itself is the identity function on that set, then the image of the set under the function is equal to the set itself.


theorem starConvex_iff_segment_subset :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E] {x : E}
      {s : Set E}, StarConvex 𝕜 x s ↔ ∀ ⦃y : E⦄, y ∈ s → segment 𝕜 x y ⊆ s :=
  by sorry

The theorem `starConvex_iff_segment_subset` states that for any type `𝕜` and vector space `E` over `𝕜` with ordered semiring and additive commutative monoid structures, a set `s` of elements of `E` is star-convex at a point `x` if and only if for every point `y` in `s`, the line segment from `x` to `y` is a subset of `s`. In other words, `s` is star-convex at `x` precisely when any line drawn from `x` to any other point in `s` remains completely within `s`.

A set of vectors in a vector space is star-convex at a point if and only if the line segment between that point and any vector in the set is contained within the set.


theorem not_isCoprime_zero_zero : ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : Nontrivial R], ¬IsCoprime 0 0 := by
  sorry

This theorem states that for any commutative semiring `R` that is nontrivial (i.e., not every element is the same), the elements `0` and `0` are not coprime. In mathematical terms, it means that there do not exist elements `a` and `b` in the semiring such that `a * 0 + b * 0 = 1`.

In any commutative nontrivial semiring, 0 is not coprime with itself.


theorem Subalgebra.zero_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A), 0 ∈ S :=
  by sorry

This theorem states that, given any subalgebra `S` of an algebra `A` over a commutative semiring `R`, the zero element (0) of the algebra `A` is always an element of the subalgebra `S`. This is an inherent property of subalgebras, which are non-empty subsets of an algebra that are themselves algebras, and therefore must contain the zero element.

Given any subalgebra S of an algebra A over a commutative semiring R, the zero element of A is an element of S.


theorem Int.fract_add_nat :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α) (m : ℕ),
      Int.fract (a + ↑m) = Int.fract a :=
  by sorry

The theorem `Int.fract_add_nat` states that for any type `α` that is a linearly ordered ring and a floor ring, for any element `a` of type `α` and any natural number `m`, the fractional part of the sum of `a` and `m` is the same as the fractional part of `a`. In mathematical terms, this can be represented as `fract(a + m) = fract(a)`, where `fract` denotes the fractional part of a number.

For any linearly ordered ring and floor ring type `α` and element `a` of `α` and natural number `m`, the fractional part of `a + m` equals the fractional part of `a`.


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

This theorem states that for any type `α` which is a commutative monoid, given any two elements `a` and `b` of this type, if `a` divides `b`, then the associate of `a` is less than or equal to the associate of `b`. Here, the associate of an element is simply the equivalence class of the element under the equivalence relation of being associated, which is defined by `Associates.mk`. This theorem essentially links the divisibility relation in the original monoid with the order relation in the associates.

For any commutative monoid type `α` and elements `a, b` of `α`, if `a` divides `b`, then the associates of `a` and `b` are related by the ordering relation. (i.e., the associate of `a` is less than or equal to the associate of `b`).


theorem Mathlib.Topology.MetricSpace.Basic._auxLemma.9 : ∀ {n m : NNReal}, (n = m) = (↑n = ↑m) := by sorry

This theorem, titled `Mathlib.Topology.MetricSpace.Basic._auxLemma.9`, states that for any two non-negative real numbers `n` and `m` (represented as `NNReal` in Lean), `n` is equal to `m` if and only if their real number equivalents (obtained by applying the coercion function `↑`) are equal. This essentially indicates that the equality operation in the non-negative real numbers space (`NNReal`) is consistent with the equality operation in the real numbers space.

For any `NNReal n` and `NNReal m`, `n = m` if and only if `↑n = ↑m`.


/-- Transport a `HasLimitsOfSize` instance across an equivalence.  -/
theorem CategoryTheory.Adjunction.has_limits_of_equivalence :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C)
      [inst_2 : CategoryTheory.IsEquivalence E] [inst : CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₁, u₁} C],
      CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D :=
  by sorry

This theorem states that if we have a category `C` that has limits of some size, and we have a functor `E` from another category `D` to `C` that forms an equivalence of categories, then `D` also has limits of the same size. In other words, the existence of limits of a certain size in a category can be transported across an equivalence of categories.

If `C` is a category with limits of size `S` and `E : D -> C` is an equivalence of categories, then `D` also has limits of size `S`.


/-- Subtracting two `affineCombination`s.  -/
theorem Finset.affineCombination_vsub :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w₁ w₂ : ι → k) (p : ι → P),
      (Finset.affineCombination k s p) w₁ -ᵥ (Finset.affineCombination k s p) w₂ =
        (Finset.weightedVSub s p) (w₁ - w₂) :=
  by sorry

This theorem states that for any set `s` of indices `ι`, any two weight functions `w₁` and `w₂` from the indices to a ring `k`, and any function `p` from the indices to points in an affine space `P` over a vector space `V` (also over `k`), the vector difference between the affine combinations of the points `p` with weights `w₁` and `w₂` respectively, is equal to the weighted vector subtraction of the points `p` with weights given by the difference `w₁ - w₂`. The vector space `V` is presumed to have an addition operation that forms a commutative group, and `P` is an affine space over `V` (i.e., a `V`-torsor).

For any set `s` of indices `ι`, any weight functions `w₁, w₂` from `ι` to a ring `k`, and any function `p : ι → P` from indices to points in an affine space `P` over a vector space `V` (both over `k`), the affine combination of `p` with weights `w₁` subtracted from the affine combination of `p` with weights `w₂` is equal to the weighted vector subtraction of the points `p` with weights `w₁ - w₂`.


/-- The cardinality of a quaternion algebra, as a type.  -/
theorem Cardinal.mk_quaternionAlgebra :
    ∀ {R : Type u_1} (c₁ c₂ : R), Cardinal.mk (QuaternionAlgebra R c₁ c₂) = Cardinal.mk R ^ 4 := by sorry

This theorem states that for any type `R` and any two elements `c₁` and `c₂` of `R`, the cardinality of the type of quaternion algebras over `R` with coefficients `c₁` and `c₂` is equal to the fourth power of the cardinality of `R`. In other words, the number of distinct quaternion algebras you can construct over `R` with specific coefficients `c₁` and `c₂` is the same as the number of distinct elements in `R` raised to the fourth power.

The number of quaternion algebras over a type `R` with coefficients `c₁` and `c₂` is equal to the fourth power of the cardinality of `R`.


theorem MeasureTheory.SimpleFunc.measurableSet_cut :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (r : α → β → Prop) (f : MeasureTheory.SimpleFunc α β),
      (∀ (b : β), MeasurableSet {a | r a b}) → MeasurableSet {a | r a (↑f a)} :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.measurableSet_cut` states that for any given types `α` and `β`, along with a measurable space `α`, a relation `r` between types `α` and `β`, and a simple function `f` mapping `α` to `β`, if for every `β`, the set of `α` that relate to `β` (denoted by `{a | r a b}`) is measurable, then the set of `α` that relate to the function value of `α` (denoted by `{a | r a (↑f a)}`) is also measurable. Here, 'measurable' refers to the set being measurable in the ambient measure space on `α`. This theorem establishes a condition under which the measurability of a certain type of set ensures the measurability of another related set.

If for every `β`, the set `{a | r a b}` is measurable and `r` is a relation between types `α` and `β`, then the set `{a | r a (↑f a)}` is measurable for any measurable space on `α` and simple function `f` mapping `α` to `β`.


theorem IsMetricSeparated.finite_iUnion_left_iff :
    ∀ {X : Type u_1} [inst : EMetricSpace X] {ι : Type u_2} {I : Set ι},
      Set.Finite I →
        ∀ {s : ι → Set X} {t : Set X}, IsMetricSeparated (⋃ i ∈ I, s i) t ↔ ∀ i ∈ I, IsMetricSeparated (s i) t :=
  by sorry

This theorem states that for any type `X` that has an extended metric space structure, a set `I` of any type `ι`, and a function `s` mapping `ι` to a set of `X`, and a set `t` of type `X`, if `I` is finite, then the union of the sets `s i` for each `i` in `I` is metric-separated from `t` if and only if each set `s i` is metric-separated from `t`. In other words, a union of sets is metric-separated from another set `t` if and only if each individual set in the union is metric-separated from `t`, given that the index set over which the union is taken is finite. Here, two sets are considered metric-separated if there exists a positive constant that is a lower bound for the distance between any pair of elements where one element is from the first set and the other is from the second set.

For any finite index set `I`, a union of metric-separated sets `{s i : X | i ∈ I}` is metric-separated from a set `t` if and only if each `s i` is metric-separated from `t` in an extended metric space.


theorem AEMeasurable.ennreal_toNNReal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ENNReal} {μ : MeasureTheory.Measure α},
      AEMeasurable f μ → AEMeasurable (fun x => (f x).toNNReal) μ :=
  by sorry

The theorem `AEMeasurable.ennreal_toNNReal` states that for any measure space `α` and a function `f` from `α` to the extended nonnegative real numbers `ENNReal`, if `f` is almost everywhere measurable with respect to a measure `μ`, then the function that maps `x` in `α` to the nonnegative real number part (obtained using `toNNReal`) of `f(x)` is also almost everywhere measurable with respect to the same measure `μ`. In simple terms, if a function is almost everywhere measurable, applying a transformation that gets the nonnegative real number part of its output does not prevent it from being almost everywhere measurable.

If a function from a measure space to extended nonnegative real numbers is almost everywhere measurable, then the function that maps each point to the non-negative real part of its value is also almost everywhere measurable.


theorem exists_eq_mul_right_of_dvd : ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, a ∣ b → ∃ c, b = a * c := by sorry

This theorem states that for any type `α` that forms a semigroup, given any two elements `a` and `b` of this type, if `a` divides `b` (denoted as `a ∣ b`), then there exists another element `c` such that `b` is equal to the product of `a` and `c` (`b = a * c`). Essentially, it states the property of divisibility in semigroups: if one element divides another, the second can be expressed as the first multiplied by some third element.

In a semigroup, if one element divides another, then there exists an element such that the second element is their product.


theorem IsometryEquiv.hausdorffMeasure_image :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : EMetricSpace X] [inst_1 : EMetricSpace Y] [inst_2 : MeasurableSpace X]
      [inst_3 : BorelSpace X] [inst_4 : MeasurableSpace Y] [inst_5 : BorelSpace Y] (e : X ≃ᵢ Y) (d : ℝ) (s : Set X),
      ↑↑(MeasureTheory.Measure.hausdorffMeasure d) (⇑e '' s) = ↑↑(MeasureTheory.Measure.hausdorffMeasure d) s :=
  by sorry

This theorem states that for any isometric equivalence `e` from a set `X` to a set `Y`, where both `X` and `Y` are equipped with an eMetricSpace, a MeasurableSpace, and a BorelSpace structure, and for any real number `d` and subset `s` of `X`, the Hausdorff measure of the image of `s` under `e` equals the Hausdorff measure of `s` itself. In other words, isometric transformations preserve the Hausdorff measure of sets.

For any isometric equivalence between two metric spaces equipped with MeasurableSpace and BorelSpace structures, the Hausdorff measure of the image of a set under the equivalence equals the Hausdorff measure of the original set.


LieModuleEquiv.ext

theorem LieModuleEquiv.ext :
    ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] (e₁ e₂ : M ≃ₗ⁅R,L⁆ N),
      (∀ (m : M), e₁ m = e₂ m) → e₁ = e₂ :=
  by sorry

This theorem states that for any given commutative ring "R", Lie ring "L", and additive commutative groups "M" and "N" that also have a module structure over "R" with "M" and "N" being Lie ring modules over "L", if there are two Lie algebra module isomorphisms (denoted as "e₁" and "e₂") between "M" and "N" that have the same effect on every element of "M", then "e₁" and "e₂" are the same isomorphism. In simpler terms, if you have two transformation rules that behave the same way for each element of "M", then these transformation rules are in fact the same.

If two Lie algebra module isomorphisms between two Lie ring modules over a commutative ring have the same action on every element, then they are equal.


theorem contDiff_iff_continuous_differentiable :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞},
      ContDiff 𝕜 n f ↔
        (∀ (m : ℕ), ↑m ≤ n → Continuous fun x => iteratedFDeriv 𝕜 m f x) ∧
          ∀ (m : ℕ), ↑m < n → Differentiable 𝕜 fun x => iteratedFDeriv 𝕜 m f x :=
  by sorry

The theorem `contDiff_iff_continuous_differentiable` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, normed additive commutative group `F`, normed space `F` over `𝕜`, function `f` from `E` to `F`, and positive extended natural number `n`, the function `f` is continuously differentiable `n` times if and only if for all natural numbers `m`, the `m`-times iterated derivative of `f` is continuous whenever `m` is less than or equal to `n`, and the function that maps `x` to the `m`-times iterated derivative of `f` at `x` is differentiable whenever `m` is less than `n`.

A function between two normed spaces is continuously differentiable up to order n if and only if all its iterated derivatives of order less than or equal to n exist and are continuous, and the function mapping x to the iterated derivative of order m at x is differentiable for all m < n.


theorem PartialHomeomorph.continuousAt_extend_symm' :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H) {x : E},
      x ∈ (PartialHomeomorph.extend f I).target →
        ContinuousAt (↑(PartialEquiv.symm (PartialHomeomorph.extend f I))) x :=
  by sorry

The theorem `PartialHomeomorph.continuousAt_extend_symm'` states that for any nontrivially normed field `𝕜`, a normed add commutative group `E`, a normed space `E` over `𝕜`, and topological spaces `H` and `M`, given a partial homeomorphism `f` from `M` to `H` and a model with corners `I` from `𝕜` to `H` and `E`, if `x` is an element of the target of the extension of the partial homeomorphism `f`, then the function corresponding to the inverse of the extension of the partial homeomorphism `f` is continuous at the point `x`.

For a nontrivially normed field `𝕜`, a normed add commutative group `E` over `𝕜`, and topological spaces `H` and `M`, if `f` is a partial homeomorphism from `M` to `H`, `I` is a model with corners from `𝕜` to `H` and `E`, and `x` is in the image of the extension of `f`, then the inverse of the extended function is continuous at `x`.


theorem Equiv.swap_comm : ∀ {α : Sort u_1} [inst : DecidableEq α] (a b : α), Equiv.swap a b = Equiv.swap b a := by sorry

The theorem `Equiv.swap_comm` states that for any type `α` that has decidable equality, the permutation that swaps `a` and `b` is the same as the permutation that swaps `b` and `a`. In other words, for any elements `a` and `b` of a type `α`, swapping `a` and `b` is commutative. This means that the order of the elements does not affect the result of the swap operation, i.e., `Equiv.swap a b` equals `Equiv.swap b a`, regardless of what the specific elements `a` and `b` are.

For any type `α` with decidable equality, the swap operation between elements `a` and `b` is commutative, i.e., `Equiv.swap a b` equals `Equiv.swap b a`.


theorem TopologicalSpace.noetherianSpace_TFAE :
    ∀ (α : Type u_1) [inst : TopologicalSpace α],
      List.TFAE
        [TopologicalSpace.NoetherianSpace α, WellFounded fun s t => s < t, ∀ (s : Set α), IsCompact s,
          ∀ (s : TopologicalSpace.Opens α), IsCompact ↑s] :=
  by sorry

This theorem states that for any topological space `α`, the following propositions are equivalent:

1. `α` is a Noetherian space, which means it satisfies the descending chain condition, i.e., there is no infinite descending chain of open subsets.

2. The relation "s < t" is well-founded on the set of all subsets of `α`. Here, "s < t" indicates that `s` is strictly included in `t`.

3. Every subset of `α` is compact. A subset `s` is said to be compact if for every nontrivial filter `f` that contains `s`, there exists an element `x` in `s` such that every set of `f` meets every neighborhood of `x`.

4. Every open subset of `α` is compact. In other words, for every open subset `s` of `α`, if `f` is a nontrivial filter that contains `s`, then there is an element `x` in `s` where every set of `f` meets every neighborhood of `x`.

This theorem forms a link between the notions of Noetherian spaces, well-foundation of the strict inclusion relation, and compactness of all subsets and open subsets for any given topological space.

A topological space is Noetherian if and only if the strict inclusion relation on its subsets is well-founded and every subset is compact.


Submodule.FG.mul

theorem Submodule.FG.mul :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {M N : Submodule R A}, Submodule.FG M → Submodule.FG N → Submodule.FG (M * N) :=
  by sorry

The theorem `Submodule.FG.mul` states that for any commutative semiring `R`, semiring `A`, and an algebra structure on `A` over `R`, if we have two submodules `M` and `N` of `A` that are finitely generated (i.e., each can be expressed as the span of a finite subset of `A`), then the product of `M` and `N` is also a finitely generated submodule of `A`. Essentially, it says that the product of two finitely generated submodules remains finitely generated.

If `R` is a commutative semiring, `A` is a semiring with an algebra structure over `R`, and `M` and `N` are finitely generated submodules of `A`, then their product `M ⊥ N` is also a finitely generated submodule of `A`.


theorem Submonoid.powers_eq_closure :
    ∀ {M : Type u_1} [inst : Monoid M] (n : M), Submonoid.powers n = Submonoid.closure {n} := by sorry

The theorem `Submonoid.powers_eq_closure` states that for any type `M` that forms a monoid, and for any element `n` of `M`, the submonoid generated by the powers of `n` is the same as the submonoid generated by the closure of the set containing `n` alone. Specifically, taking all the powers of `n` (i.e., `n` to the power of every possible integer) gives us the same submonoid as taking the smallest submonoid that contains `n`.

For any monoid `M` and element `n` in `M`, the submonoid generated by the powers of `n` equals the submonoid generated by the closure of `{n}`.


theorem IsAddKleinFour.card_four' :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Fintype G] [inst : IsAddKleinFour G], Fintype.card G = 4 := by sorry

The theorem `IsAddKleinFour.card_four'` states that for any type `G` which is an additive group and admits the structure of a finite type, if `G` also has the structure of an additive Klein four-group, then the cardinality of `G` (i.e., the number of elements in `G`) is exactly 4. In mathematical terms, it says that an additive Klein four-group has exactly 4 elements.

An additive Klein four-group is a finite type with exactly 4 elements.


/-- `succ` commutes with `succAbove`.  -/
theorem Fin.succ_succAbove_succ :
    ∀ {n : ℕ} (i : Fin (n + 1)) (j : Fin n), Fin.succAbove (Fin.succ i) (Fin.succ j) = Fin.succ (Fin.succAbove i j) :=
  by sorry

The theorem `Fin.succ_succAbove_succ` states that for all natural numbers `n`, and for any two elements `i` of the finite set `Fin (n + 1)` and `j` of `Fin n`, the `succ` function, which increments an element of a finite set, commutes with the `succAbove` function. In other words, first applying `succ` to `i` and `j` and then applying `succAbove`, yields the same result as first applying `succAbove` to `i` and `j` and then applying `succ`. This can be represented in mathematical notation as `succAbove (succ i) (succ j) = succ (succAbove i j)`.

For all natural numbers `n` and `i` in `Fin (n + 1)` and `j` in `Fin n`, `succAbove (succ i) (succ j) = succ (succAbove i j)`.


theorem SemiNormedGroupCat.explicitCokernelDesc_unique :
    ∀ {X Y Z : SemiNormedGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0)
      (e : SemiNormedGroupCat.explicitCokernel f ⟶ Z),
      CategoryTheory.CategoryStruct.comp (SemiNormedGroupCat.explicitCokernelπ f) e = g →
        e = SemiNormedGroupCat.explicitCokernelDesc w :=
  by sorry

The theorem `SemiNormedGroupCat.explicitCokernelDesc_unique` states that for all objects `X`, `Y`, and `Z` in the category of seminormed abelian groups, given morphisms `f: X ⟶ Y` and `g: Y ⟶ Z` such that their composition `f ≫ g` is the zero morphism, and another morphism `e: explicitCokernel f ⟶ Z`, if the composition of the projection from `Y` to the explicit cokernel of `f` with `e` equals to `g`, then `e` is equal to the morphism obtained by descending to the explicit cokernel. This essentially provides the uniqueness part of the universal property of the explicit cokernel in the category of seminormed abelian groups.

Given morphisms `f: X ⟶ Y`, `g: Y ⟶ Z` in the category of seminormed abelian groups with `f ≫ g = 0`, and `e: explicitCokernel(f) ⟶ Z` such that `p∘e = g` for the projection `p: Y ⟶ explicitCokernel(f)`, then `e = desc(g ∘ i)` where `i: Y ⟶ explicitCokernel(f)` is the canonical injection.


theorem Int.mul_div_cancel_left : ∀ {a : ℤ} (b : ℤ), a ≠ 0 → Int.div (a * b) a = b := by sorry

This theorem states that for any two integers 'a' and 'b', where 'a' is not zero, the integer division of the product of 'a' and 'b' by 'a' is equal to 'b'. This is essentially a property of integer multiplication and division that mirrors the cancellation law in algebra.

For any non-zero integer 'a' and integer 'b', the quotient of their product by 'a' equals 'b'.


theorem CategoryTheory.Functor.final_of_natIso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D}
      [inst_2 : CategoryTheory.Functor.Final F], (F ≅ F') → CategoryTheory.Functor.Final F' :=
  by sorry

This theorem states that in the context of category theory, given two categories `C` and `D`, and two functors `F` and `F'` from `C` to `D`, if functor `F` is final and there exists a natural isomorphism between `F` and `F'`, then functor `F'` is also final. In simpler terms, if we can naturally transform a final functor into another functor, that second functor is also final.

If functor `F` is final and there exists a natural isomorphism between `F` and `F'`, then `F'` is also a final functor.


theorem Valuation.map_add_of_distinct_val :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
      {x y : R}, v x ≠ v y → v (x + y) = max (v x) (v y) :=
  by sorry

This theorem, `Valuation.map_add_of_distinct_val`, states that for any ring `R` and any linearly ordered commutative group with zero `Γ₀`, given a valuation `v` of `R` into `Γ₀`, and any two elements `x` and `y` of `R` such that the valuation of `x` is not equal to the valuation of `y`, then the valuation of the sum of `x` and `y` is equal to the maximum of the valuations of `x` and `y`. In other words, if the values of `x` and `y` under the valuation `v` are distinct, the valuation of their sum is equal to the greater of the two valuations.

For any ring `R`, commutative group with zero `Γ₀`, valuation `v` from `R` to `Γ₀`, and distinct elements `x` and `y` in `R`, `v(x + y) = max {v(x), v(y)}`.


theorem symmDiff_eq_bot : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, symmDiff a b = ⊥ ↔ a = b :=
  by sorry

This theorem states that for any type `α` that is an instance of a generalized coheyting algebra, and for any elements `a` and `b` of this type, the symmetric difference of `a` and `b` is equal to the bottom element of the algebra (denoted by `⊥`) if and only if `a` is equal to `b`. In other words, in such an algebraic structure, the symmetric difference of two elements being the bottom element is an indicator of the equality of these two elements.

For any type `α` instancing a generalized co Heyting algebra and any elements `a, b` of `α`, `a ⊎ b = ⊥` if and only if `a = b`.


theorem sup_eq_sup_iff_left :
    ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, a ⊔ b = a ⊔ c ↔ b ≤ a ⊔ c ∧ c ≤ a ⊔ b := by sorry

This theorem states that for any type `α` that forms a semilattice with a supremum operation (denoted by `⊔`), and for any three elements `a`, `b`, and `c` of this type, the supremum of `a` and `b` being equal to the supremum of `a` and `c` is equivalent to `b` being less than or equal to the supremum of `a` and `c` and `c` being less than or equal to the supremum of `a` and `b`. In the context of ordered sets, the supremum operation `⊔` returns the least upper bound of the two elements.

For any semilattice `α` with supremum operation `⊔`, and for all `a`, `b`, and `c` in `α`, `a ⊔ b = a ⊔ c` if and only if `b ≤ a ⊔ c` and `c ≤ a ⊔ b`.


Eq.congr

theorem Eq.congr : ∀ {α : Sort u_1} {x₁ y₁ x₂ y₂ : α}, x₁ = y₁ → x₂ = y₂ → (x₁ = x₂ ↔ y₁ = y₂) := by sorry

The theorem `Eq.congr` states that for any type `α`, given four elements of this type (`x₁`, `y₁`, `x₂`, `y₂`), if `x₁` is equal to `y₁` and `x₂` is equal to `y₂`, then `x₁` equals `x₂` if and only if `y₁` equals `y₂`. Essentially, this theorem is about the transitivity of equality: if two pairs of elements are each equal within their pair, then equality between any element from the first pair and any element from the second pair is equivalent to equality between the remaining elements.

If `x₁ = y₁` and `x₂ = y₂`, then `x₁ = x₂`.


theorem subset_sSup_of_within :
    ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : SupSet α] [inst_2 : Inhabited ↑s] {t : Set ↑s},
      Set.Nonempty t → BddAbove t → sSup (Subtype.val '' t) ∈ s → sSup (Subtype.val '' t) = ↑(sSup t) :=
  by sorry

The theorem `subset_sSup_of_within` states that for any type `α` with a preorder and a superset structure, and for any set `s` of type `α` that has an inhabitant, if we have a subset `t` of `s` that is nonempty and is bounded by an upper bound, then if the supremum of the image of `t` under the subtype value function is an element of `s`, it equals the coerced supremum of `t`. This essentially says that if we restrict ourselves to a subset of a bounded set, the supremum of the subset is the same as the supremum of the set when viewed in the larger context.

If `s` is a nonempty, bounded subset of a preordered type `α` with a supremum, and the supremum of `s` is an element of `s`, then the supremum of `s` equals the coerced supremum of `s`.


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

This theorem states that for any type `α` with an instance of InfSet, and two functions `f` and `g` from possibly different indices `ι` and `ι'` to `α`, if there exists a bijective function `e` from `ι` to `ι'` such that for all elements in `ι`, `g` applied to the image of the element under `e` gives the same result as `f` applied to the element, then the infimum over `f` for all elements in `ι` is equal to the infimum over `g` for all elements in `ι'`. In simpler terms, if the values of `f` and `g` are the same when mapped correctly, the infimum over both sets is also the same.

If `f` and `g` are functions from index sets `ι` and `ι'` to a type `α` with an instance of InfSet, and there exists a bijective function `e` from `ι` to `ι'` such that `g ∘ e = f` pointwise, then `inf (map f ι) = inf (map g ι')`.


Computation.Results.length

theorem Computation.Results.length :
    ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ} [_T : Computation.Terminates s],
      Computation.Results s a n → Computation.length s = n :=
  by sorry

This theorem states that for any computation `s` of type `α` that terminates, if `s` produces a result `a` after exactly `n` steps (which is expressed by `Computation.Results s a n`), then the length of computation `s` (i.e., the number of steps it took to terminate) is exactly `n`. In other words, the 'length' of a terminating computation is defined by the number of steps it took to reach the final result.

For any computation `s` of type `α` that terminates in `n` steps with result `a`, the length of `s` equals `n`.


theorem List.mem_keys_of_mem :
    ∀ {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)}, s ∈ l → s.fst ∈ List.keys l := by sorry

This theorem states that for any type `α` and for any type `β` that is dependent on `α`, and for any sigma type `s` (which is a type of key-value pair) and any list `l` of sigma types, if `s` is an element of `l`, then the first component of `s` (which is the key in the key-value pair) is an element of the list of keys of `l`. In other words, if a key-value pair is in a list, then its key is in the list of keys.

If a sigma type `s` with key `α` is an element of a list `l` of sigma types, then `α` is an element of the list of keys of `l`.


theorem Multiset.map_univ_coe :
    ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map (fun x => x.fst) Finset.univ.val = m := by
  sorry

The theorem `Multiset.map_univ_coe` states that for any type `α` with decidable equality and any multiset `m` of that type, mapping the function `(fun x => x.fst)` over the universal finite set (`Finset.univ.val`) results in the original multiset `m`. Here, `(fun x => x.fst)` is a function that takes a pair and returns the first element. Essentially, this theorem says that every element in the universal set can be paired with an element in the multiset `m`, and applying the map operation results in the same multiset `m`.

For any type `α` with decidable equality and any multiset `m` of type `α`, the map operation `Multiset.map m (λ x, x.fst)` equals `m` itself.


theorem Mathlib.MeasureTheory.Measure.MeasureSpaceDef._auxLemma.18 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
      (s ≤ᶠ[MeasureTheory.Measure.ae μ] t) = (↑↑μ (s \ t) = 0) :=
  by sorry

This theorem states that for any type `α`, equipped with a `MeasurableSpace` structure, and for any measure `μ` defined on this measurable space, along with any two sets `s` and `t` of type `α`, the property that `s` is less than or equal to `t` almost everywhere with respect to the measure `μ` is equivalent to the measure of the set difference `s \ t` being zero. In standard mathematical notation, this would be expressed as $s \leq_{\mu-a.e.} t$ if and only if $\mu(s \setminus t) = 0$.

For any measurable spaces `(α, Σ)` with measure `μ`, sets `s` and `t` in `α` are almost everywhere equal with respect to `μ` if and only if their set difference has measure zero: `s ∩^μ t = ∫ x in α, 1{s(x) = t(x)} dμ = μ(s \ t) = 0`.


theorem Mathlib.MeasureTheory.Measure.MeasureSpaceDef._auxLemma.17 :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] {l : Filter α} {f g : α → β},
      (f =ᶠ[l] g) = (f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f) :=
  by sorry

This theorem states that for any two functions `f` and `g` from a type `α` to a partially ordered type `β`, the equality of `f` and `g` almost everywhere (i.e., with respect to a filter `l` on `α`) is equivalent to `f` being less than or equal to `g` almost everywhere and `g` being less than or equal to `f` almost everywhere. Essentially, this is saying in the context of measure theory, two functions are equal almost everywhere if and only if they are both less than or equal to each other almost everywhere.

For functions `f` and `g` from type `α` to a partially ordered type `β`, `f` and `g` are equal almost everywhere with respect to filter `l` if and only if they are both less than or equal to each other almost everywhere with respect to `l`.


theorem Mathlib.MeasureTheory.Measure.MeasureSpaceDef._auxLemma.15 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      (s =ᶠ[MeasureTheory.Measure.ae μ] ∅) = (↑↑μ s = 0) :=
  by sorry

This theorem states that for any type `α` with a structure of measurability, any measure `μ` on `α`, and any set `s` of type `α`, the set `s` is almost everywhere equal to the empty set (under the measure `μ`) if and only if the measure of the set `s` is zero. Here, the phrase "almost everywhere" is in the measure-theoretic sense, meaning on the complement of a negligible set.

For any measurable type `α`, measure `μ` on `α`, and set `s` of type `α`, `s` is almost everywhere equal to the empty set under `μ` if and only if the measure of `s` is zero.


theorem HahnSeries.support_neg :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddGroup R] {x : HahnSeries Γ R},
      HahnSeries.support (-x) = HahnSeries.support x :=
  by sorry

This theorem states that for all types `Γ` and `R`, where `Γ` is a partially ordered set and `R` is an additive group, and for any `x` of type `HahnSeries Γ R`, the support of the negation of `x` is equal to the support of `x`. In other words, the set of indices with non-zero coefficients remains the same when a Hahn series is negated.

For any Hahn series `x` of type `HahnSeries Γ R` over a partially ordered set `Γ` and an additive group `R`, the support of `x` is equal to the support of its negation.


theorem WeierstrassCurve.Affine.Point.add.proof_2 :
    ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} (x₁ y₁ : F),
      W.nonsingular x₁ y₁ →
        ∀ (x₂ y₂ : F),
          W.nonsingular x₂ y₂ →
            ¬x₁ = x₂ → W.nonsingular (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) :=
  by sorry

This theorem states that for any field `F` and a Weierstrass curve `W` defined over `F`, given two points `(x₁, y₁)` and `(x₂, y₂)` on the curve that are non-singular (i.e., they do not represent singularities of the curve) and distinct (i.e., `x₁` is not equal to `x₂`), the point resulting from the addition of these two points `(W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂), W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂))` is also non-singular on the curve. The addition here is defined in terms of the 'slope' function, which calculates the slope of the line joining `(x₁, y₁)` and `(x₂, y₂)`. The `W.addX` and `W.addY` functions compute the x-coordinate and y-coordinate of the sum of the two points, respectively.

Given a Weierstrass curve `W` over a field `F` and two distinct non-singular points `(x₁, y₁)` and `(x₂, y₂)` on the curve, the point `(W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂), W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂))` is also a non-singular point on `W`.


theorem WeierstrassCurve.Affine.Point.add.proof_1 :
    ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} (x₁ y₁ : F),
      W.nonsingular x₁ y₁ →
        ∀ (x₂ y₂ : F),
          W.nonsingular x₂ y₂ →
            ¬y₁ = W.negY x₂ y₂ →
              W.nonsingular (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) :=
  by sorry

The theorem `WeierstrassCurve.Affine.Point.add.proof_1` states that for any field `F`, and for any Weierstrass curve `W` defined over this field, given two points `(x₁, y₁)` and `(x₂, y₂)` on this curve that are nonsingular, if `y₁` does not equal the negation of `y₂` under the curve `W`, then the point `(W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂), W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂))` - which is the result of the "addition" operation defined on the curve between the two points - is also nonsingular. The slope used in the addition operation is computed with the function `W.slope` which is the slope of the line passing through `(x₁, y₁)` and `(x₂, y₂)`.

Given a Weierstrass curve `W` over a field `F` and two nonsingular points `(x₁, y₁)` and `(x₂, y₂)` with distinct `y` coordinates, the point obtained by adding `(x₁, y₁)` and `(x₂, y₂)` according to the curve's addition operation is also a nonsingular point.


theorem toIcoDiv_sub_eq_toIcoDiv_add :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b c : α),
      toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b :=
  by sorry

This theorem states that for any type `α` that is an instance of the `LinearOrderedAddCommGroup` and `Archimedean`, and for any positive `p`, `a`, `b`, and `c` of type `α`, the unique integer obtained by subtracting `c` from `b` and then using the `toIcoDiv` function is equal to the unique integer obtained by adding `c` to `a` and then using the `toIcoDiv` function on `b`. In other words, the operation of subtracting `c` from `b` before applying `toIcoDiv` is the same as adding `c` to `a` before applying `toIcoDiv` on `b`.

For any `α` instance of `LinearOrderedAddCommGroup` and `Archimedean`, the result of `toIcoDiv (b - c)` is equal to `toIcoDiv (a + c)` for any `p > 0` and `a, b, c : α`.


theorem Real.logb_zero : ∀ {b : ℝ}, Real.logb b 0 = 0 := by sorry

This theorem states that for any real number `b`, the base-`b` logarithm of `0` is `0`. In other words, regardless of what real number is chosen as the base, the logarithm, in that base, of `0` will always be `0`. This fact is denoted mathematically as `log_b(0) = 0` for all real numbers `b`.

For all real numbers `b`, `log_b(0) = 0`.


IsLowerSet.inter

theorem IsLowerSet.inter :
    ∀ {α : Type u_1} [inst : LE α] {s t : Set α}, IsLowerSet s → IsLowerSet t → IsLowerSet (s ∩ t) := by sorry

The theorem `IsLowerSet.inter` states that for any type `α` with a less than or equal to order (`LE α`), if `s` and `t` are both lower sets, then the intersection of `s` and `t` (denoted as `s ∩ t`) is also a lower set. In other words, if any element is less than or equal to an element in both `s` and `t`, then that element is also included in the intersection of `s` and `t`.

If `s` and `t` are lower sets of type `α` with a total order, then `s ∩ t` is also a lower set.


theorem NNRat.coe_le_coe : ∀ {p q : NNRat}, ↑p ≤ ↑q ↔ p ≤ q := by sorry

This theorem states that for any two nonnegative rational numbers `p` and `q` (represented by `NNRat`), the standard mathematical inequality `p ≤ q` holds true if and only if the inequality `↑p ≤ ↑q` also holds true when `p` and `q` are coerced (or converted) into another type that supports the comparison (like real numbers or rational numbers for instance). In other words, the comparison of the nonnegative rational numbers is preserved under coercion.

For any nonnegative rational numbers `p` and `q`, `p ≤ q` if and only if `↑p ≤ ↑q`, where `↑` denotes coercion to a type that supports comparison.


theorem LieModule.lowerCentralSeries_zero :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
      LieModule.lowerCentralSeries R L M 0 = ⊤ :=
  by sorry

The theorem `LieModule.lowerCentralSeries_zero` states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is also a module over `R` and a Lie ring module over `L`, the zeroth term of the lower central series of Lie submodules of `M` is the entire module `M` itself, represented by `⊤`. In other words, in the context of Lie algebras, the base of the lower central series is the entire module.

For any commutative ring R, Lie ring L, and additive commutative group M being an R-module and a Lie ring module over L, the zeroth term of the lower central series of Lie submodules of M is the entire module M.


theorem not_dvd_index_sylow :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [hp : Fact (Nat.Prime p)] [inst_1 : Finite (Sylow p G)] (P : Sylow p G),
      Subgroup.relindex (↑P) (Subgroup.normalizer ↑P) ≠ 0 → ¬p ∣ Subgroup.index ↑P :=
  by sorry

This theorem, `not_dvd_index_sylow`, asserts that for any prime number `p` and any group `G`, supposing `p` is a Sylow prime of `G` and `G` is finite, for any Sylow `p`-subgroup `P` of `G`, if the relative index of `P` in its normalizer is not zero, then `p` does not divide the index of `P` in `G`. In other words, under the given conditions, the prime number `p` cannot be a divisor of the index of the Sylow `p`-subgroup `P` in `G` if the relative index of `P` in its normalizer is non-zero.

If a prime number `p` is a Sylow prime of a finite group `G`, and a Sylow `p`-subgroup `P` of `G` has non-zero relative index in its normalizer, then `p` does not divide the index of `P` in `G`.


theorem Ordinal.lt_opow_succ_log_self :
    ∀ {b : Ordinal.{u_1}}, 1 < b → ∀ (x : Ordinal.{u_1}), x < b ^ Order.succ (Ordinal.log b x) := by sorry

This theorem states that for any ordinal `b` such that `1 < b` and any ordinal `x`, the value of `x` is strictly less than `b` raised to the power of the successor of the ordinal logarithm of `x` base `b`. In mathematical terms, for all `b` and `x` where `b` is an ordinal greater than `1`, we have `x < b^((Ordinal.log b x)+1)`. The ordinal logarithm here is a solution `u` to the equation `x = b ^ u * v + w` where `v < b` and `w < b ^ u`. The successor of an ordinal is the least ordinal greater than it if it is not maximal, or the ordinal itself if it is maximal. This theorem could be important in the proof of properties related to ordinal arithmetic and logarithms.

For any ordinal `b` greater than 1 and any ordinal `x`, `x` is strictly less than `b` raised to the power of the successor of the ordinal logarithm of `x` base `b`.


/-- Open elements of `𝓤 α` form a basis of `𝓤 α`.  -/
theorem uniformity_hasBasis_open :
    ∀ {α : Type ua} [inst : UniformSpace α], Filter.HasBasis (uniformity α) (fun V => V ∈ uniformity α ∧ IsOpen V) id :=
  by sorry

This theorem states that for any type `α` that has a `UniformSpace` instance, the open elements of the uniformity on `α` form a basis of the uniformity. In other words, any element in the uniformity `𝓤 α` can be represented as a "neighborhood" of smaller open sets, where openness is defined with respect to the ambient topological space on `α`. This is a fundamental property of uniform spaces and is crucial for their analysis and manipulation.

For any uniform space `(α, 𝓤)`, the open sets in `𝓤` form a basis for the uniformity `𝓤`.


theorem Int.mul_div_cancel : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → Int.div (a * b) b = a := by sorry

This theorem states that for any integer `a` and any non-zero integer `b`, if you multiply `a` by `b` and then divide the result by `b`, you get `a` back. In essence, it captures the behavior of division undoing multiplication in the integers, under the condition that we are not dividing by zero. This is expressed in LaTeX as: ∀a, b ∈ ℤ, b ≠ 0 → (a * b) ÷ b = a.

For any integer `a` and non-zero integer `b`, `a * b / b` equals `a`.


theorem CategoryTheory.ShortComplex.RightHomologyData.ofZeros_g' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0),
      CategoryTheory.ShortComplex.RightHomologyData.g' (CategoryTheory.ShortComplex.RightHomologyData.ofZeros S hf hg) =
        0 :=
  by sorry

This theorem states that given a category `C` along with the assumption that it has zero morphisms, for any `ShortComplex` `S` in `C`, if the morphisms `f` and `g` in `S` are both zero, then the induced morphism `g'` is also zero. This `g'` is originally defined using the morphism `g` from `S` and the fact that `Q` is a cokernel of `f` in `S`. Thus, intuitively, the theorem asserts that zero morphisms in the short complex propagate to this constructed morphism `g'`.

Given a short complex `S` in a category `C` with zero morphisms, if `f` and `g` in `S` are zero, then the induced morphism `g'` from `g` and the cokernel `Q` of `f` is zero.


theorem InnerProductSpace.Core.inner_self_im :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] (x : F), RCLike.im ⟪x, x⟫_𝕜 = 0 :=
  by sorry

The theorem `InnerProductSpace.Core.inner_self_im` states that for any ring 𝕜 that is a "Real/C-complex-like" structure (RCLike), and for any additive commutative group F that is a module over 𝕜, if 𝕜 and F together form an inner product space (denoted by `InnerProductSpace.Core 𝕜 F`), then the imaginary part of the inner product of any element `x` of `F` with itself is zero. In other words, the inner product of an element with itself in this context is always a real number.

For any RCLike ring 𝕜 and its module F forming an inner product space, the self-inner product of any element in F is real.


theorem MvPolynomial.map_aeval :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      [inst_2 : Algebra R S₁] {B : Type u_2} [inst_3 : CommSemiring B] (g : σ → S₁) (φ : S₁ →+* B)
      (p : MvPolynomial σ R),
      φ ((MvPolynomial.aeval g) p) = (MvPolynomial.eval₂Hom (RingHom.comp φ (algebraMap R S₁)) fun i => φ (g i)) p :=
  by sorry

The theorem `MvPolynomial.map_aeval` states that for any commutative semirings `R`, `S₁`, and `B`, any algebra structure from `R` to `S₁`, a function `g` from an arbitrary type `σ` to `S₁`, a ring homomorphism `φ` from `S₁` to `B`, and a multivariate polynomial `p` over `σ` and `R`, the image of the polynomial `p` under the `R`-algebra homomorphism generated by `g` (denoted as `(MvPolynomial.aeval g) p`), when further mapped through `φ`, is the same as the image of `p` under the ring homomorphism generated by composing `φ` with the embedding of `R` into `S₁`, and mapping each variable indexed by `σ` through `φ` after `g`. In mathematical notation, this is saying that for all such settings, we have `φ((MvPolynomial.aeval g) p) = (MvPolynomial.eval₂Hom (RingHom.comp φ (algebraMap R S₁)) (λ i, φ(g i)) p`.

For any commutative semirings R, S₁, and B, an algebra homomorphism from R to S₁, a ring homomorphism from S₁ to B, a multivariate polynomial p over R and a type σ, we have φ((MvPolynomial.aeval g) p) = (MvPolynomial.eval₂Hom (RingHom.comp φ (algebraMap R S₁)) (λ i, φ(gi)) p).


theorem measurable_swap_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {x : MeasurableSpace γ} {f : α × β → γ}, Measurable (f ∘ Prod.swap) ↔ Measurable f :=
  by sorry

This theorem, `measurable_swap_iff`, states that for any types `α`, `β`, and `γ` with measurable spaces `m`, `mβ`, and `x` respectively, and for any function `f` from the product of `α` and `β` to `γ`, the function `f` is measurable if and only if the function `f` composed with the product swap function is measurable. The product swap function `Prod.swap` takes a pair and switches the elements, so this theorem is about the measurability of a function under the rearrangement of its input variables.

For measurable spaces (m, α, β, γ) and a measurable function f : α × β → γ, the function f is measurable if and only if f ∘ Prod.swap is measurable, where Prod.swap is the product swap function.


theorem mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Antitone (Function.swap f b)) →
        (∀ (a : α), Monotone (f a)) → a ∈ upperBounds s → b ∈ lowerBounds t → f a b ∈ lowerBounds (Set.image2 f s t) :=
  by sorry

The theorem `mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds` is a statement about a binary function `f : α → β → γ`, two sets `s : Set α` and `t : Set β`, and two elements `a : α` and `b : β`, where the types α, β, γ are equipped with preorder structures. It states that if every function obtained by fixing the second argument of `f` is antitone (i.e., decreases when its argument increases), every function obtained by fixing the first argument of `f` is monotone (i.e., increases when its argument increases), `a` is an upper bound of set `s`, and `b` is a lower bound of set `t`, then the value `f a b` is a lower bound of the image of the sets `s` and `t` under the function `f`. This can be thought of as a property relating the bounds of the original sets `s` and `t` to the bounds of their image under `f`.

If functions obtained by fixing the arguments of a binary function are antitone on the second argument and monotone on the first, and elements `a` from the domain of the first argument and `b` from the domain of the second argument are upper and lower bounds of their respective sets, then `f(a, b)` is a lower bound for the images of those sets under `f`.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.4 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter α} {s : Set β},
      Filter.Tendsto f l (Filter.principal s) = ∀ᶠ (a : α) in l, f a ∈ s :=
  by sorry

This theorem states that for any given types `α` and `β`, a function `f` from `α` to `β`, a filter `l` on `α`, and a set `s` of `β`, the property `Filter.Tendsto f l (Filter.principal s)` holds if and only if almost every `a` in the filter `l` satisfies `f a ∈ s`. In other words, the function `f` tends to the principal filter of `s` with respect to the filter `l` if and only if, for almost every element in the filter `l`, its image under `f` belongs to `s`.

For types `α` and `β`, a function `f: α → β`, filter `l` on `α`, and set `s ⊆ β`, the function `f` tends to the principal filter of `s` with respect to `l` if and only if almost every element in `l` maps to an element in `s` under `f`.


theorem sum_add_tsum_nat_add' :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [inst_2 : T2Space M]
      [inst_3 : ContinuousAdd M] {f : ℕ → M} {k : ℕ},
      (Summable fun n => f (n + k)) →
        (Finset.sum (Finset.range k) fun i => f i) + ∑' (i : ℕ), f (i + k) = ∑' (i : ℕ), f i :=
  by sorry

This theorem states that for any type `M` that has an additive commutative monoid structure, a topological space structure, a Hausdorff (`T2Space`) structure, and a structure of continuous addition, along with a function `f` from natural numbers to `M` and a natural number `k`, if the function `f` applied to `n + k` (for all natural numbers `n`) is summable, then the sum of `f(i)` for `i` in the range from 0 to `k-1` plus the sum of `f(i + k)` for all natural numbers `i` is equal to the sum of `f(i)` for all natural numbers `i`. In mathematical terms, it states $\sum_{i=0}^{k-1} f(i) + \sum_{i=0}^{\infty} f(i + k) = \sum_{i=0}^{\infty} f(i)$.

For any additive commutative monoid `M` with topological space, Hausdorff space, continuous addition structures, and a summable function `f` from natural numbers to `M`, the sum of `f(i)` for `i` from 0 to `k-1` and the sum of `f(i+k)` for all `i` equals the infinite sum of `f(i)`.


theorem Set.bijOn_comm :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} {g : β → α},
      Set.InvOn f g t s → (Set.BijOn f s t ↔ Set.BijOn g t s) :=
  by sorry

The theorem `Set.bijOn_comm` states that for any two types `α` and `β`, any two sets `s` of type `α` and `t` of type `β`, and any two functions `f : α → β` and `g : β → α`, if `f` is an inverse to `g` when `g` is viewed as a map from `t` to `s`, then `f` is bijective from `s` to `t` if and only if `g` is bijective from `t` to `s`. In mathematical terms, if `f` and `g` are inverses on the sets `s` and `t` respectively, then `f` is a bijection between `s` and `t` if and only if `g` is a bijection between `t` and `s`.

For types `α` and `β`, sets `s ♂α` and `t ♂β`, and functions `f : α → β` and `g : β → α` such that `f ∘ g = idβ` and `g ∘ f = idα`, `f` is a bijection between `s` and `t` if and only if `g` is a bijection between `t` and `s`.


theorem Equiv.comp_symm_eq :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : β → γ) (g : α → γ), g ∘ ⇑e.symm = f ↔ g = f ∘ ⇑e :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, given an equivalence `e` between `α` and `β`, and functions `f` from `β` to `γ` and `g` from `α` to `γ`, the composition of `g` with the inverse of `e` is equal to `f` if and only if `g` is equal to the composition of `f` with `e`. In simpler terms, this theorem captures a property of function composition in the presence of an equivalence between the two original types.

For all types `α`, `β`, and `γ`, given an equivalence `e` between `α` and `β`, functions `f: β → γ`, and `g: α → γ`, if `g = f ∘ e.symm`, then `f = g ∘ e`.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.3 :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {f : α → β} {x : Filter α} {y : ι → Filter β},
      Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) :=
  by sorry

This theorem states that for all types `α`, `β`, and `ι`, and for all function `f` from `α` to `β`, filter `x` on `α` and a collection of filters `y` indexed by `ι` on `β`, the function `f` tending towards the infimum of the filters `y` (denoted `⨅ i, y i`) from the filter `x` is equivalent to the function `f` tending towards each filter `y i` from the filter `x` for all `i` in `ι`. In other words, in terms of limit, it states that the limit of the function `f` as `x` approaches the limit of the `y` filters is the same as the limit of the function `f` as `x` approaches each individual `y` filter.

For all types `α`, `β`, and index type `ι`, and for all functions `f` from `α` to `β`, if `x` tends to the infimum of filters `y_i` on `β` as `i` ranges over `ι` from filter `x` on `α`, then `f(x)` tends to the limit of `f(y_i)` for all `i` in `ι`.


theorem BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} [inst : Finite ι] (π : BoxIntegral.Prepartition I),
      ∀ᶠ (t : Finset (ι × ℝ)) in Filter.atTop,
        π ⊓ BoxIntegral.Prepartition.splitMany I t =
          BoxIntegral.Prepartition.filter (BoxIntegral.Prepartition.splitMany I t) fun J =>
            ↑J ⊆ BoxIntegral.Prepartition.iUnion π :=
  by sorry

This theorem states that for any type `ι`, any box `I` of type `BoxIntegral.Box ι` and any prepartition `π` of `I`, eventually for every `t` in the filter `atTop` (which represents a limit towards infinity), the intersection of `π` and the prepartition resulting from splitting `I` along many hyperplanes defined by `t`, is equal to filtering the prepartition from splitting `I` along `t`, such that each resultant box `J` is a subset of the union of boxes in `π`.

In other words, if we keep splitting a box `I` along more and more hyperplanes, eventually the part that overlaps with a given prepartition `π` is exactly the part where every box from the splitting is covered by `π`.

For any type `ι`, box `I` of type `BoxIntegral.Box ι`, prepartition `π` of `I`, and filter `atTop`, as `t` approaches `atTop`, the intersection of `π` and the partition obtained by splitting `I` along hyperplanes defined by `t` is equal to filtering `π` to only keep the parts that are subsets of the union of boxes in the resulting partition.


/-- We can express `qrSign m n` as a power of `-1` when `m` and `n` are odd.  -/
theorem qrSign.neg_one_pow : ∀ {m n : ℕ}, Odd m → Odd n → qrSign m n = (-1) ^ (m / 2 * (n / 2)) := by sorry

The theorem `qrSign.neg_one_pow` states that for any two natural numbers, `m` and `n`, if both `m` and `n` are odd (where a number is defined as odd if it can be expressed in the form `2k + 1` for some `k`), then the value of the bi-multiplicative map `qrSign` at `m` and `n` can be expressed as `-1` raised to the power of `m / 2 * n / 2`. This theorem relates the quadratic reciprocity sign to the parity of numbers.

For odd natural numbers m and n, the value of the bi-multiplicative map qrSign is equal to -1 raised to the power of (m / 2 * n / 2).


theorem Mathlib.Algebra.Order.Monoid.Defs._auxLemma.2 :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommMonoid α] {a : α}, (0 ≤ a + a) = (0 ≤ a) := by sorry

This theorem, known as `_auxLemma.2` from the `Mathlib.Algebra.Order.Monoid.Defs` module, applies to any type `α` that forms a linearly ordered additive commutative monoid. The theorem states that for any element `a` of this type, the property that `0` is less than or equal to `a + a` (i.e., twice `a`) is equivalent to the property that `0` is less than or equal to `a` itself.

For any linearly ordered additive commutative monoid type `α`, the element `0` is less than or equal to `2*a` if and only if it is less than or equal to `a`.


theorem IsLUB.mem_of_isClosed :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsLUB s a → Set.Nonempty s → IsClosed s → a ∈ s :=
  by sorry

This theorem, referred to as `IsLUB.mem_of_isClosed`, is stating that for any given type `α` equipped with a topology, a linear order, and an order topology, if `a` is the least upper bound of a set `s` and `s` is non-empty and closed, then the element `a` is a member of the set `s`. In other words, if a non-empty set `s` in a topological space is closed, its least upper bound (if it exists) is an element of the set `s`.

If `s` is a non-empty, closed subset of a topological space equipped with a linear order, then its least upper bound (if it exists) is an element of `s`.


theorem Int.not_lt : ∀ {a b : ℤ}, ¬a < b ↔ b ≤ a := by sorry

This theorem states that for any two integers 'a' and 'b', 'a' is not less than 'b' if and only if 'b' is less than or equal to 'a'. In other words, if 'a' is not less than 'b', then 'b' must be less than or equal to 'a', and vice versa. The theorem represents a basic property of ordering in the set of integers.

For all integers a and b, a ≤ b if and only if not (a < b).


theorem AffineEquiv.symm_apply_apply :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂) (p : P₁), (AffineEquiv.symm e) (e p) = p :=
  by sorry

This theorem states that for any affine transformation `e` from one point space `P₁` to another `P₂` over a ring `k`, with associated vector spaces `V₁` and `V₂`, the application of the inverse of `e` ('symm e') to the result of applying `e` to any point `p` in `P₁` will yield `p` itself. Essentially, this confirms that the inverse of the affine transformation undoes the effect of the transformation, returning us to the original point.

For any affine transformation `e` from point space `P₁` to `P₂` over ring `k` with associated vector spaces `V₁` and `V₂`, `symm e (e (p)) = p` for all points `p` in `P₁`.


theorem Multiset.bind_singleton :
    ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → β), (Multiset.bind s fun x => {f x}) = Multiset.map f s :=
  by sorry

This theorem states that for any multiset `s` of type `α` and any function `f` from `α` to `β`, applying the `bind` operation on `s` with a function that produces a singleton set from the application of `f` to each element of `s` is equivalent to directly applying the `map` operation with `f` on `s`. In other words, the multiset obtained by binding `s` with the singleton-producing function is identical to the multiset obtained by mapping `f` over `s`.

For any multiset `s` of type `α` and function `f` from `α` to `β`, the multiset obtained by binding `s` with a function that maps each element to a singleton set is equivalent to the multiset obtained by applying `f` to each element of `s` and then taking the multiset of the resulting images.


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

This theorem states that for any two types `X` and `Y` that are equipped with topological spaces, given a partial homeomorphism `e` from `X` to `Y` and any element `x` from `X` that belongs to the source of `e`, the inverse function of `e` tends to the limit from the filter neighborhood of the image of `x` under `e` to the filter neighborhood of `x`. In other words, for any neighborhood of `x`, the pre-image under the inverse function of `e` of that neighborhood is a neighborhood of the image of `x` under `e`. This is a property of continuous functions in topological spaces.

Given a continuous partial homeomorphism `e` between topological spaces `X` and `Y`, for every `x` in `X` and every neighborhood `V` of `e(x)` in `Y`, there exists a neighborhood `U` of `x` in `X` such that `e(U)` is a subset of `V` and `e⁻¹(V)` is a neighborhood of `x` in `X`.


TopologicalSpace.Closeds.ext

theorem TopologicalSpace.Closeds.ext :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Closeds α}, ↑s = ↑t → s = t := by sorry

This theorem states that for any type `α` that has the structure of a topological space, if we have two subsets `s` and `t` of the set of all closed subsets in `α` such that the type coercion of `s` equals to the type coercion of `t`, then `s` equals to `t`. In other words, this theorem guarantees the uniqueness of each closed subset in the set of all closed subsets of a given topological space.

In a topological space `α`, if two subsets `s` and `t` of its closed subsets have equal type coercions, then they are equal.


theorem Nat.factorization_def : ∀ (n : ℕ) {p : ℕ}, Nat.Prime p → (Nat.factorization n) p = padicValNat p n := by sorry

The theorem `Nat.factorization_def` states that for every natural number `n` and for every prime number `p`, the multiplicity of `p` in the prime factorization of `n` (given by `(Nat.factorization n) p`) is the same as the `p`-adic valuation of `n`. In other words, the `p`-adic valuation function `padicValNat p n` and the function `Nat.factorization n` mapping a prime number to its multiplicity produce the same result for any prime `p` and natural number `n`. This means that `p` appears in the prime factorization of `n` exactly as many times as `p` to some power evenly divides `n`.

The theorem `Nat.factorization_def` asserts that for all natural numbers `n` and prime numbers `p`, the multiplicity of `p` in the prime factorization of `n` equals the `p`-adic valuation of `n`.