theorem ValuationSubring.mem_of_valuation_le_one :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (x : K), (ValuationSubring.valuation A) x ≤ 1 → x ∈ A := by
  sorry

This theorem states that for any field `K` and any valuation subring `A` of `K`, if the valuation of an element `x` from `K` under the valuation induced by `A` is less than or equal to one, then `x` belongs to the valuation subring `A`. In other words, it asserts that any element in the field `K` whose valuation, as defined by the valuation subring `A`, is at most one is actually a member of the valuation subring `A`.

If `A` is a valuation subring of the field `K`, then for all `x` in `K` with valuation less than or equal to 1 under the valuation induced by `A`, we have `x` in `A`.


IsLprojection.Lcomplement

theorem IsLprojection.Lcomplement :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X] {P : M},
      IsLprojection X P → IsLprojection X (1 - P) :=
  by sorry

This theorem states that for any type `X` which is a Normed Additive Commutative Group, and any type `M` which is a Ring and a Module over `X`, and any element `P` of `M`, if `P` is a left projection on `X`, then `1 - P` is also a left projection on `X`. In mathematical terms, we can say that if a linear map `P` is a projection on a vector space `X`, then `1 - P` (where `1` here represents the identity operator on `X`) is also a projection on `X`.

If `P` is a left projection on the normed additive commutative group `X` as a module over the ring `M`, then `1 - P` is also a left projection on `X`.


theorem Num.toZNum_succ : ∀ (n : Num), Num.toZNum (Num.succ n) = ZNum.succ (Num.toZNum n) := by sorry

This theorem, `Num.toZNum_succ`, states that for any natural number `n`, the function `Num.toZNum` applied to the successor of `n` (i.e., `n` plus one) is equal to the function `ZNum.succ` applied to `Num.toZNum n`. Essentially, this means that the operations of taking the successor of a number and converting a natural number to an integer number commute, or can be performed in any order to achieve the same result.

For all natural numbers n, Num.toZNum (n + 1) = ZNum.succ (Num.toZNum n).


theorem Set.iUnion_subset_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, ⋃ i, s i ⊆ t ↔ ∀ (i : ι), s i ⊆ t := by sorry

This theorem, `Set.iUnion_subset_iff`, states that for any type `α`, any indexing type `ι`, any index-dependent family of sets `s` of type `α`, and any set `t` of type `α`, the union (over all indices, denoted by `⋃ i`) of the family of sets `s` is a subset of `t` if and only if for each index `i` in `ι`, the corresponding set `s i` is a subset of `t`. In other words, it establishes the equivalence between the subset relationship of the union of a collection of sets and the individual sets in the collection to a specific set. This theorem is a fundamental principle in set theory.

The theorem `Set.iUnion_subset_iff` in Lean 4 states that for any type `α`, indexing type `ι`, family of sets `s i` indexed by `ι`, and set `t` of type `α`, `⋃ i, s i ⊆ t` if and only if `∀ i, s i ⊆ t`. (The union of the family `s` is a subset of `t` if and only if each `s i` is a subset of `t`. )


theorem SetTheory.PGame.neg_le_neg_iff : ∀ {x y : SetTheory.PGame}, -y ≤ -x ↔ x ≤ y := by sorry

This theorem states that for any two games 'x' and 'y' in set theory, the negation of 'y' is less than or equal to the negation of 'x' if and only if 'x' is less than or equal to 'y'. This theorem demonstrates an important property of negation that can be found in many mathematical structures, not just games in set theory.

For any games x and y in set theory, x ≤ y if and only if �� /******/x/��\] ≤ �� /******/y/��\] in the lattice of sets under inclusion. (Note: The notation �� /******/x/��\] and �� /******/y/��\] represent the negations of sets x and y, respectively.)


theorem vadd_left_cancel_iff :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
      g +ᵥ x = g +ᵥ y ↔ x = y :=
  by sorry

This theorem, `vadd_left_cancel_iff`, states that for any type `α` which is an AddGroup and any type `β` that is acted upon by `α` through addition, given an element `g` from `α` and two elements `x` and `y` from `β`, if the result of adding `g` to `x` is equal to the result of adding `g` to `y`, then `x` must be equal to `y`. In other words, this theorem provides the condition of left-cancellability in the context of additive actions.

For any AddGroup `α` and any type `β` with an additive action, if for all `g` in `α` and `x, y` in `β`, `g + x = g + y` implies `x = y`, then `α` acts on `β` with left-cancellation.


Absorbent.subset

/-- **Alias** of `Absorbent.mono`. -/
theorem Absorbent.subset :
    ∀ {M : Type u_1} {α : Type u_2} [inst : Bornology M] [inst_1 : SMul M α] {s t : Set α},
      Absorbent M s → s ⊆ t → Absorbent M t :=
  by sorry

The theorem `Absorbent.subset` states that for any two sets `s` and `t` of any type `α` (where `α` has the scalar multiplication by a type `M` which has a bornology), if `s` is an absorbent set and every element of `s` is also in `t` (i.e., `s` is a subset of `t`), then `t` is also an absorbent set. In other words, the absorbency property is preserved under taking subsets.

If `s` is an absorbent subset of `α` and `s` is contained in `t`, then `t` is also an absorbent subset of `α`.


theorem neg_one_sq : ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : HasDistribNeg R], (-1) ^ 2 = 1 := by sorry

This theorem states that in any monoid R, which additionally has the property of distributing negations (i.e., it respects the distributive law for negation), the square of -1 is equal to 1. In mathematical terms, this can be written as (-1)^2 = 1. This theorem holds under the specific conditions that R is a monoid and respects the distributive law for negation.

In a monoid R with distributive negations, (-1)^2 equals 1.


theorem Set.Ici_diff_left : ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Ici a \ {a} = Set.Ioi a := by sorry

This theorem states that for any type `α` that has a `PartialOrder` instance and for any element `a` of type `α`, the set difference of the left-closed right-infinite interval at `a` and the singleton set `{a}` is equal to the left-open right-infinite interval at `a`. In simpler terms, if you have a set of all elements greater than or equal to `a` and you subtract the element `a` from the set, you get the set of all elements strictly greater than `a`. In mathematical notation, this is saying that for all `a`, `[a, ∞) \ {a} = (a, ∞)`.

For any type `α` with a `PartialOrder` instance and any `a` in `α`, the set difference of the left-closed right-infinite interval `[a, ∞)` and the singleton set `{a}` equals the left-open right-infinite interval `(a, ∞)`. In other words, `[a, ∞) \ {a} = (a, ∞)`.


theorem Mathlib.Algebra.CharZero.Defs._auxLemma.9 :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] (n : ℕ) [inst_2 : Nat.AtLeastTwo n],
      (OfNat.ofNat n = 1) = False :=
  by sorry

This theorem, named `Mathlib.Algebra.CharZero.Defs._auxLemma.9`, states that for any type `R` which is both an additive monoid with one (i.e., a structure with an associative addition operation and a multiplicative operation where the multiplication is associative, has an identity, and distributes over addition) and has characteristic zero (`CharZero R` implies that each natural number maps to a distinct element of `R`), and for any natural number `n` satisfying the property `Nat.AtLeastTwo n` (i.e., `n` is at least 2), the assertion that `OfNat.ofNat n` (the interpretation of the natural number `n` as an element of the type `R`) equals 1 is always false. In other words, any natural number that is at least two cannot be interpreted as 1 in any additive monoid with one of characteristic zero.

In an additive monoid with one of characteristic zero, no natural number greater than one can be equal to the identity element.


theorem mul_lt_mul_of_neg_right :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c : α} [inst_1 : ExistsAddOfLE α],
      b < a → c < 0 → a * c < b * c :=
  by sorry

This theorem states that for any strictly ordered semiring `α` and three elements `a`, `b`, and `c` in `α` (where addition can be defined from less than or equal to), if `b` is less than `a` and `c` is less than zero, then the product of `a` and `c` is less than the product of `b` and `c`. In essence, it is a statement about the effect of multiplication by a negative number on the order of elements in a strictly ordered semiring.

In a strictly ordered semiring, if `a` is greater than `b` and `c` is negative, then `a * c` is less than `b * c`.


theorem Polynomial.smul_monomial :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : SMulZeroClass S R] (a : S) (n : ℕ) (b : R),
      a • (Polynomial.monomial n) b = (Polynomial.monomial n) (a • b) :=
  by sorry

This theorem, named `Polynomial.smul_monomial`, states that for any semiring `R`, any type `S` that forms a `SMulZeroClass` with `R`, any scalar `a` of type `S`, any natural number `n`, and any element `b` of `R`, the operation of scaling `b` by `a` and then constructing a monomial with exponent `n` is the same as first constructing a monomial with exponent `n` from `b` and then scaling the resulting polynomial by `a`. In other words, scalar multiplication commutes with the formation of monomials in the polynomial ring over `R`.

For any semiring R, any type S that is a scalar multiplication zero class over R, any scalar a of type S, any natural number n, and any element b of R, the operation of scaling b by a and then forming the monomial x^n is equal to forming the monomial x^n from b and then scaling the resulting polynomial by a.


/-- While we didn't need decidable instances to define it, we do to reduce it to a sum  -/
theorem DFinsupp.sumAddHom_apply :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] [inst_3 : AddCommMonoid γ] (φ : (i : ι) → β i →+ γ)
      (f : Π₀ (i : ι), β i), (DFinsupp.sumAddHom φ) f = DFinsupp.sum f fun x => ⇑(φ x) :=
  by sorry

The theorem `DFinsupp.sumAddHom_apply` states that for any type `ι`, `γ` and a type `β` dependent on `ι`, given a decision procedure for equality on `ι`, an instance of the `AddZeroClass` for each `β i`, a decision procedure for non-equality with zero for each `β i`, and an additive commutative monoid structure on `γ`, if we have a function `φ` mapping each `β i` to `γ` and a function `f` of type `Π₀ (i : ι), β i`, then the application of `DFinsupp.sumAddHom φ` to `f` is equal to the sum of `f` over the support of `f` where each `φ x` is applied to the sum. In other words, while we didn't need decidable instances to define the sum, we do need them to reduce it to a sum.

Given a family `f` of additive commutative monoid values indexed by `ι`, the application of `DFinsupp.sumAddHom φ` to `f` equals the sum of `φ (f i)` over the support of `f`, where `φ` maps each index `i` to the additive monoid value `β i`.


theorem Polynomial.mirror_zero : ∀ {R : Type u_1} [inst : Semiring R], Polynomial.mirror 0 = 0 := by sorry

The theorem `Polynomial.mirror_zero` states that for all semirings `R`, the mirror of the zero polynomial is zero. Here, the mirror of a polynomial is defined as the polynomial obtained by reversing the coefficients of the original polynomial and adjusting by multiplying with `X` raised to the power of the natural trailing degree of the original polynomial.

For all semirings R, the mirror of the zero polynomial is the polynomial with all coefficients equal to 0.


/-- The **Weinstein–Aronszajn identity**. Note the `1` on the LHS is of shape m×m, while the `1` on
the RHS is of shape n×n.  -/
theorem Matrix.det_one_add_mul_comm :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type u_4} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
      [inst_3 : DecidableEq n] [inst_4 : CommRing α] (A : Matrix m n α) (B : Matrix n m α),
      Matrix.det (1 + A * B) = Matrix.det (1 + B * A) :=
  by sorry

The Weinstein–Aronszajn identity states that for any two matrices `A` and `B`, where `A` is of shape `m`x`n` and `B` is of shape `n`x`m`, and the entries of the matrices are from a commutative ring, the determinant of the sum of the identity matrix of shape `m`x`m` and the product of `A` and `B` is equal to the determinant of the sum of the identity matrix of shape `n`x`n` and the product of `B` and `A`. The equality holds regardless of the order of multiplication in the sum. The identity matrix on the left-hand side is of shape `m`x`m` while the identity matrix on the right-hand side is of shape `n`x`n`.

The determinant of the sum of the identity matrix of shape `m`x`m` and the product of matrices `A` of shape `m`x`n` and `B` of shape `n`x`m`, where the entries come from a commutative ring, equals the determinant of the sum of the identity matrix of shape `n`x`n` and the product of matrices `B` and `A`.


theorem Seminorm.ball_subset_closedBall :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) (x : E) (r : ℝ), Seminorm.ball p x r ⊆ Seminorm.closedBall p x r :=
  by sorry

The theorem `Seminorm.ball_subset_closedBall` states that for any seminorm `p` on a type `E` over a seminormed ring `𝕜`, any point `x` in `E`, and any real number `r`, the ball of radius `r` centered at `x` with respect to `p` is a subset of the closed ball of the same radius and center. In other words, all the points `y` that satisfy `p (y - x) < r` also satisfy `p (y - x) ≤ r`.

For every seminorm `p` on a type `E` over a seminormed ring `𝕜`, every point `x` in `E`, and every real number `r`, the open ball `{y : E | p(y - x) < r}` is contained in the closed ball `{y : E | p(y - x) ≤ r}`.


JoinedIn.mem

theorem JoinedIn.mem :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {F : Set X}, JoinedIn F x y → x ∈ F ∧ y ∈ F := by sorry

This theorem states that for any topological space `X`, and any two points `x` and `y` of `X`, and a set `F` of `X`, if `x` and `y` are joined in `F` (i.e., there exists a path in `F` connecting `x` and `y`), then both `x` and `y` belong to the set `F`. In other words, the endpoints (`x` and `y`) of any path in `F` must themselves be elements of `F`.

If `F` is a subset of a topological space `X`, and `x` and `y` are points in `X` with a path in `F` connecting them, then `x` and `y` are elements of `F`.


theorem Nat.pos_pow_of_pos : ∀ {n : ℕ} (m : ℕ), 0 < n → 0 < n ^ m := by sorry

This theorem states that for any natural number 'n' and 'm', if 'n' is greater than zero, then 'n' raised to the power 'm' is also greater than zero. In mathematical terms, it asserts that for any natural numbers 'n' and 'm', if 0 < n, then 0 < n^m. This holds true for all natural numbers since raising any positive number to a power results in a positive number.

For any natural numbers n and m, if n > 0 then n^m > 0.


theorem pow_le_pow_iff_right :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {a : R} {n m : ℕ}, 1 < a → (a ^ n ≤ a ^ m ↔ n ≤ m) := by sorry

This theorem states that for any strictly ordered semiring `R`, given any element `a` from `R` and two natural numbers `n` and `m`, if `a` is greater than 1, then `a` raised to the power of `n` is less than or equal to `a` raised to the power of `m` if and only if `n` is less than or equal to `m`. In mathematical notation, if `a > 1` in `R`, then `a^n ≤ a^m` is equivalent to `n ≤ m`.

For any strictly ordered semiring `R` and elements `a` in `R` with `a > 1`, `a^n ≤ a^m` holds if and only if `n ≤ m`.


/-- An `AddSubsemigroup` is closed under addition. -/
theorem AddSubsemigroup.add_mem :
    ∀ {M : Type u_1} [inst : Add M] (S : AddSubsemigroup M) {x y : M}, x ∈ S → y ∈ S → x + y ∈ S := by sorry

This theorem states that for any type `M` that is equipped with an addition operation, any `AddSubsemigroup` of `M`, and any two elements `x` and `y` of `M`, if both `x` and `y` are elements of the `AddSubsemigroup`, then their sum `x + y` is also an element of the `AddSubsemigroup`. In other words, an `AddSubsemigroup` is closed under the operation of addition.

Given an additive semigroup (AddSubsemigroup) `S` in a type `M` with addition operation, for all `x, y ∈ S`, their sum `x + y` also belongs to `S`.


theorem Finset.sup_inf_distrib_left :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] [inst_1 : OrderBot α] (s : Finset ι) (f : ι → α) (a : α),
      a ⊓ Finset.sup s f = Finset.sup s fun i => a ⊓ f i :=
  by sorry

The theorem `Finset.sup_inf_distrib_left` states that for any type `α` that forms a distributive lattice with a least element, a finite set `s` of elements of any type `ι`, a function `f` from `ι` to `α`, and any element `a` of `α`, the infimum (greatest lower bound) of `a` and the supremum (least upper bound) of the image of `s` under `f` is equal to the supremum of the image of `s` under the function that sends `i` to the infimum of `a` and `f(i)`. In mathematical notation, this can be expressed as `a ⊓ sup(f(s)) = sup({a ⊓ f(i) | i ∈ s})`.

For any distributive lattice with a least element and function from a finite set to it, the infimum of an element with the supremum of its image is equal to the supremum of the infimums of the image elements.


StrictAnti.injective

theorem StrictAnti.injective :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictAnti f → Function.Injective f :=
  by sorry

The theorem `StrictAnti.injective` states that for any types `α` and `β` with a linear order on `α` and a preorder on `β`, if a function `f` from `α` to `β` is strictly antitone (i.e., if `a` is less than `b` then `f(b)` is less than `f(a)`), then `f` is also injective (i.e., if `f(x)` is equal to `f(y)` then `x` is equal to `y`).

If `f` is a strictly antitone function from a linearly ordered type `α` to a preordered type `β`, then `f` is injective.


theorem mabs_of_le_one :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α}
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1], a ≤ 1 → mabs a = a⁻¹ :=
  by sorry

The theorem `mabs_of_le_one` states that for any type `α` which is both a lattice and a group, and where multiplication (`*`) is a covariant operation in the sense that multiplying two elements doesn't reverse the order of the elements, if an element `a` of `α` is less than or equal to `1`, then the absolute value of `a` (as defined by the function `mabs`) is equal to the inverse of `a`.

If `α` is a lattice and group type with covariant multiplication, then for all `a` in `α` with `0 ≤ a`, we have `mabs a = a^(-1)`.


/-- For every open cover of a Lindelöf set, there exists a countable subcover.  -/
theorem IsLindelof.elim_countable_subcover :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {ι : Type v},
      IsLindelof s →
        ∀ (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ r, Set.Countable r ∧ s ⊆ ⋃ i ∈ r, U i :=
  by sorry

The theorem `IsLindelöf.elim_countable_subcover` states that for any Lindelöf set `s` in a topological space `X` and any open cover `U` of `s`, there exists a countable subcover `r` of `U` such that `s` is a subset of the union over `r` of `U i`. This means if we have a Lindelöf set and an open cover, we can always find a countable subset of the cover that still covers the entire Lindelöf set. This is a fundamental property of Lindelöf spaces in topology.

Given a Lindelöf set in a topological space and an open cover, there exists a countable subcover that still covers the set.


theorem Matroid.empty_indep : ∀ {α : Type u_1} (M : Matroid α), M.Indep ∅ := by sorry

This theorem states that for any given matroid `M` over a type `α`, the empty set is independent in `M`. In other words, in the context of matroids, which are a generalization of graphs, vectors, and other mathematical structures, this theorem guarantees that no matter what specific matroid we are considering, an empty set will always be considered independent.

In any matroid, the empty set is an independent set.


theorem Ordinal.sup_le_lsub : ∀ {ι : Type u} (f : ι → Ordinal.{max u v}), Ordinal.sup f ≤ Ordinal.lsub f := by sorry

This theorem states that for any indexed family of ordinals (represented as a function `f` from the index type `ι` to the type `Ordinal.{max u v}`), the supremum of that family (`Ordinal.sup f`) is less than or equal to the least strict upper bound of the family (`Ordinal.lsub f`). In other words, it ensures that the supremum of a set of ordinals is always less than or equal to the least ordinal that is greater than all the ordinals in the set.

The supremum of an indexed family of ordinals is less than or equal to their least upper bound.


theorem mul_div_mul_comm :
    ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c d : α), a * b / (c * d) = a / c * (b / d) := by sorry

This theorem, named `mul_div_mul_comm`, states that for any type `α` which is a Division Commutative Monoid, for any four elements `a`, `b`, `c`, and `d` of this type, the result of multiplying `a` and `b` and then dividing by the product of `c` and `d` is equal to the result of dividing `a` by `c` and multiplying by `b` divided by `d`. In other words, the equation $a * b / (c * d) = a / c * (b / d)$ holds true for any `a`, `b`, `c`, and `d` in any Division Commutative Monoid `α`.

For any division commutative monoid `α`, the expression `a * b / (c * d)` equals `(a / c) * (b / d)` for all `a`, `b`, `c`, and `d` in `α`.


theorem Function.leftInverse_surjInv :
    ∀ {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Bijective f), Function.LeftInverse (Function.surjInv ⋯) f :=
  by sorry

The theorem `Function.leftInverse_surjInv` states that for all sorts `α` and `β`, and for any function `f` from `α` to `β`, if `f` is bijective (both injective and surjective), then the function `Function.surjInv` is a left inverse to `f`. In other words, if we have a bijective function `f`, then applying `f` and then `Function.surjInv` (in this order) to any element of `α` will return that very same element. This theorem essentially shows that we can retrieve the original value from any bijective function using its surjective inverse.

If `f` is a bijective function from `α` to `β`, then `Function.surjInv ∘ f = id` (where `id` is the identity function on `α`).


/-- If the restriction to an `m`-measurable set `s` of a σ-algebra `m` is equal to the restriction
to `s` of another σ-algebra `m₂` (hypothesis `hs`), then `μ[f | m] =ᵐ[μ.restrict s] μ[f | m₂]`.  -/
theorem MeasureTheory.condexp_ae_eq_restrict_of_measurableSpace_eq_on :
    ∀ {α : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E]
      {f : α → E} {s : Set α} {m m₂ m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) (hm₂ : m₂ ≤ m0)
      [inst_3 : MeasureTheory.SigmaFinite (μ.trim hm)] [inst_4 : MeasureTheory.SigmaFinite (μ.trim hm₂)],
      MeasurableSet s →
        (∀ (t : Set α), MeasurableSet (s ∩ t) ↔ MeasurableSet (s ∩ t)) →
          MeasureTheory.condexp m μ f =ᶠ[MeasureTheory.Measure.ae (μ.restrict s)] MeasureTheory.condexp m₂ μ f :=
  by sorry

This theorem states that given measurable spaces `m`, `m₂` and `m0`, a normed additively commutative group `E`, a normed space `E` over the reals, a complete normed space `E`, a function `f` mapping `α` to `E`, a set `s` of type `α`, and a measure `μ` on `α`, if `m` and `m₂` are both sub-σ-algebras of `m0` and `μ` is σ-finite with respect to both `m` and `m₂`, then if `s` is a measurable set, and the restriction to `s` of `m` is the same as the restriction to `s` of `m₂` for all measurable sets `t` [(ie. the measurability of `s` intersect `t` is the same for both `m` and `m₂`)], then the conditional expectation of `f` with respect to `m` and `μ` is equal almost everywhere to the conditional expectation of `f` with respect to `m₂` and `μ` when restricted to `s`.

Given measurable spaces `m`, `m₂`, a normed additively commutative group `E`, a complete normed space `E` over the reals, a function `f` mapping from a measurable set `α` to `E`, a measure `μ` on `α` that is σ-finite with respect to both `m` and `m₂`, if `s` is a measurable set such that the restriction of `m` and `m₂` to `s` agree on measurable sets and `m`, `m₂` are sub-σ-algebras of `m0`, then the conditional expectations of `f` with respect to `m` and `μ` and `m₂` and `μ` are equal almost everywhere on `s`.


theorem MeasureTheory.set_lintegral_const :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (c : ENNReal),
      ∫⁻ (x : α) in s, c ∂μ = c * ↑↑μ s :=
  by sorry

This theorem, `MeasureTheory.set_lintegral_const`, states that for any type `α`, any measurable space `m` of type `α`, any measure `μ` of the measurable space, any set `s` of type `α`, and any extended non-negative real number `c`, the Lebesgue integral (also known as set integral) of the constant function `c` over the set `s` with respect to the measure `μ` is equal to `c` times the measure of the set `s`. In other words, the integral of a constant over a set is just the constant times the measure of the set. This is a fundamental result in measure theory, reflecting that the integral effectively "sums up" the constant value over the extent of the set, as measured by `μ`.

For any measurable space (α, m), measure μ, set s, and constant c, the Lebesgue integral of the constant function c over set s with respect to measure μ equals c times the measure of set s.


theorem List.eq_nil_iff_forall_not_mem : ∀ {α : Type u_1} {l : List α}, l = [] ↔ ∀ (a : α), a ∉ l := by sorry

This theorem states that for all types `α` and all lists `l` of type `α`, the list `l` is empty if and only if for every element `a` of type `α`, `a` is not a member of `l`. In other words, a list is empty if it does not contain any elements. The theorem is expressed in Lean 4 using universal quantifiers and bi-conditional (`↔`) logical connector, associating the emptiness of a list with the non-membership of any element in it.

A list of type `α` is empty if and only if no element of type `α` belongs to the list.


/-- **Alias** of `Decidable.lt_or_eq_of_le`. -/
theorem LE.le.lt_or_eq_dec :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : DecidableRel fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b → a < b ∨ a = b :=
  by sorry

This theorem, which is an alias of `Decidable.lt_or_eq_of_le`, is a statement about any type `α` with a partial order and a decidable relation for the "less than or equal to" operation. Given any two elements `a` and `b` of type `α`, if `a` is less than or equal to `b`, then either `a` is strictly less than `b` or `a` equals `b`.

If `α` is a type with a partial order and decidable "less than or equal to" relation, then for all `a` and `b` in `α`, if `a <= b`, then `a < b` or `a = b`.


GenLoop.ext

theorem GenLoop.ext :
    ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} (f g : ↑(GenLoop N X x)),
      (∀ (y : N → ↑unitInterval), f y = g y) → f = g :=
  by sorry

The theorem `GenLoop.ext` states that for all types `N` and `X`, where `X` is a topological space, and for all points `x` in `X`, if `f` and `g` are elements of the generalized loops based at `x`, then if `f` and `g` are equal on every point `y` in `N` mapping to the unit interval `[0,1]`, then `f` and `g` are indeed the same function. This means that two generalized loops are considered identical if they match on every point in their domain.

If two generalized loops based at a point in a topological space agree on every point mapping to the unit interval, then they are equal as functions.


theorem hnot_inf_distrib : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a b : α), ￢(a ⊓ b) = ￢a ⊔ ￢b := by sorry

This theorem states that for any type `α` that forms a co-Heyting algebra, the complement (denoted by `￢`) of the infimum (denoted by `⊓`, also often referred to as the 'meet' or 'greatest lower bound') of any two elements `a` and `b` of that type is equal to the supremum (denoted by `⊔`, also often referred to as the 'join' or 'least upper bound') of their individual complements. In mathematical notation, this can be written as `￢(a ⊓ b) = ￢a ⊔ ￢b`. This is an important property in the theory of co-Heyting algebras.

In a co-Heyting algebra, the complement of the infimum of two elements is equal to the supremum of their individual complements: `￢(a ⊓ b) = ￢a ⊔ ￢b`.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.28 :
    ∀ {α : Type u_2} [inst : Div α] {s t : Set α} {a : α}, (a ∈ s / t) = ∃ x ∈ s, ∃ y ∈ t, x / y = a := by sorry

This theorem is stating that for any type `α` that has a division operation, given two sets `s` and `t` of type `α`, and an element `a` of type `α`, the element `a` is in the quotient set `s / t` if and only if there exist elements `x` in `s` and `y` in `t` such that `x / y` equals `a`. In mathematical terms, for any element `a`, `a` is in the set `s / t` if and only if there exist elements `x` in `s` and `y` in `t` such that `x / y = a`.

For any type `α` with division, and sets `s` and `t` of `α`, an element `a` is in the quotient `s / t` if and only if there exist `x ∈ s` and `y ∈ t` such that `x / y = a`.


theorem Mathlib.Data.Set.Sigma._auxLemma.2 :
    ∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {x : (i : ι) × α i},
      (x ∈ Set.sigma s t) = (x.fst ∈ s ∧ x.snd ∈ t x.fst) :=
  by sorry

This theorem states that for any index set `ι`, any function `α` from `ι` to some type, any set `s` of type `ι`, any function `t` from `ι` to a set of elements of type `α i`, and any dependent pair `x` consisting of an element of `ι` and an element of type `α i`, `x` is a member of the indexed sum of sets `s.sigma t` if and only if the first component of `x` is a member of `s` and the second component of `x` is a member of `t` corresponding to the first component of `x`. In other words, it specifies the membership criteria for the indexed sum of sets (also known as Sigma set) in terms of the original sets and their indexing.

For any index set `ι`, set `s` and function `t` from `ι` to sets, an element `(i, x)` is in the indexed sum `s.sigma t` if and only if `i` is in `s` and `x` is in `t i`.


theorem hasFDerivAt_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (c : F)
      (x : E), HasFDerivAt (fun x => c) 0 x :=
  by sorry

The theorem `hasFDerivAt_const` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E` and `F`, and any normed spaces over `𝕜` for `E` and `F`, the derivative at any point `x` in `E` of a constant function (a function that always returns the same value `c` in `F`) is zero. This is consistent with the idea in calculus that the derivative of a constant function is always zero because a constant function does not change, so its rate of change is zero.

For any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and constant function `f : E → F`, the derivative `(hasFDerivAt f x)` at any point `x` in `E` equals the zero map `0 : F → F`.


Relation.TransGen.trans

theorem Relation.TransGen.trans :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b c : α},
      Relation.TransGen r a b → Relation.TransGen r b c → Relation.TransGen r a c :=
  by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, if there is a transitive closure of `r` from `a` to `b`, and another transitive closure of `r` from `b` to `c` (where `a`, `b`, and `c` are elements of `α`), then there is a transitive closure of `r` from `a` to `c`. In other words, the transitivity of the transitive closure of a relation is proven, i.e., if `a` is related to `b` and `b` is related to `c` via possibly multiple steps of `r`, then `a` is also related to `c` via possibly multiple steps of `r`.

If `r` is a binary relation on type `α`, and there exist transitive closures `t1` of `r` from `a` to `b` and `t2` of `r` from `b` to `c`, then there exists a transitive closure `t` of `r` such that `a` is related to `c` via `t`.


theorem add_sq : ∀ {R : Type u_1} [inst : CommSemiring R] (a b : R), (a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2 := by sorry

This theorem, named `add_sq`, states that for any commutative semiring `R` and for any elements `a` and `b` in `R`, the square of the sum of `a` and `b` is equal to the sum of the square of `a`, twice the product of `a` and `b`, and the square of `b`. In mathematical notation, this is expressed as `(a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2`. This is a classic result in algebra known as the square of a binomial.

For any commutative semiring `R` and elements `a` and `b` in `R`, `(a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2`.


theorem MvFunctor.id_map :
    ∀ {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [inst : MvFunctor F] [inst_1 : LawfulMvFunctor F]
      (x : F α), MvFunctor.map TypeVec.id x = x :=
  by sorry

The theorem `MvFunctor.id_map` asserts that for any natural number `n`, any n-tuple of types `α`, and any multivariate functor `F` that abides by the laws of a `LawfulMvFunctor`, applying the `MvFunctor.map` operation with the identity function `TypeVec.id` to any element `x` of `F α` simply produces `x` itself. In other words, mapping the identity function over any value in a lawful multivariate functor leaves that value unchanged. This is the multivariate functor version of the identity law.

For any lawful multivariate functor F and any n-tuple of types α, the application of the map function with the identity function to any element x in F α results in x.


theorem Metric.closure_ball_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, closure (Metric.ball x ε) ⊆ Metric.closedBall x ε := by
  sorry

This theorem states that for any pseudometric space (a set equipped with a distance function satisfying certain properties), and any point 'x' of that space, the closure of the open ball around 'x' with radius 'ε' is a subset of the closed ball around 'x' with the same radius. Here, an open ball around 'x' with radius 'ε' is the set of all points whose distance to 'x' is less than 'ε', while a closed ball is the set of all points whose distance to 'x' is less than or equal to 'ε'. The closure of a set is the smallest closed set that contains it. In other words, any point that can be reached from the open ball by continually stepping to points arbitrarily close (but not equal to 'ε') is also within the closed ball.

For any pseudometric space and point, the closure of the open ball is contained in the closed ball with the same radius.


theorem interior_subset_gauge_lt_one :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E]
      [inst_3 : ContinuousSMul ℝ E] (s : Set E), interior s ⊆ {x | gauge s x < 1} :=
  by sorry

This theorem states that for any set `s` in a real vector space `E` equipped with an additive commutative group structure, a scalar multiplication module over the reals, a topological space structure and a continuous scalar multiplication, the interior of `s` is a subset of those vectors `x` for which the Minkowski functional of `s` at `x` is less than one. In other words, all vectors in the interior of `s` have their corresponding value under the Minkowski functional less than one.

The interior of a real vector space set equipped with a topology and continuous scalar multiplication is contained in the set of vectors with Minkowski functional value strictly less than one.


theorem Action.ρ_one :
    ∀ {V : Type (u + 1)} [inst : CategoryTheory.LargeCategory V] {G : MonCat} (A : Action V G),
      A.ρ 1 = CategoryTheory.CategoryStruct.id A.V :=
  by sorry

The theorem `Action.ρ_one` states that for any Large Category `V`, any Monoid Category `G`, and any action `A` of `G` on `V`, the right action of the identity element `1` of the monoid on any element of `V` is the identity morphism in the category `V`. In other words, the action of the identity does not change the element of the category `V`, just as you would expect from an identity.

For any Monoid Category `G` action `A` on a Large Category `V`, the right action of the identity element of `G` on any object in `V` is the identity morphism in `V`.


theorem Finset.val_lt_iff : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁.val < s₂.val ↔ s₁ ⊂ s₂ := by sorry

This theorem, `Finset.val_lt_iff`, states that for any two finite sets `s₁` and `s₂` of the same type `α`, the value of `s₁` is less than the value of `s₂` if and only if `s₁` is a proper subset of `s₂`. In other words, in Lean 4, a finite set is considered to be 'smaller' in value than another finite set only when all elements of the first set are in the second set, but the second set contains at least one element not present in the first.

For finite sets `s₁` and `s₂` of the same type `α` in Lean 4, `s₁` is less than `s₂` if and only if `s₁` is a proper subset of `s₂`.


theorem Complex.norm_natCast_cpow_of_pos : ∀ {n : ℕ}, 0 < n → ∀ (s : ℂ), ‖↑n ^ s‖ = ↑n ^ s.re := by sorry

The theorem `Complex.norm_natCast_cpow_of_pos` states that for any positive natural number `n` and any complex number `s`, the norm of `n` (casted to a complex number) raised to the power `s` is equal to `n` (casted to a complex number) raised to the real part of `s`. This can be formally written as: for all `n` in natural numbers and `s` in complex numbers, if `n` is greater than 0, then the complex norm of `n` to the power of `s` equals `n` to the power of the real part of `s`.

For any positive natural number `n` and complex number `s`, the complex norm of `n` raised to the power of `s` equals `n` raised to the real part of `s`.


theorem Real.log_injOn_pos : Set.InjOn Real.log (Set.Ioi 0) := by sorry

This theorem states that the real logarithm function (`Real.log`) is injective (or one-to-one) on the set of all real numbers greater than zero (`Set.Ioi 0`). In other words, if we have two positive real numbers `x` and `y`, and their logarithms are equal (`Real.log x = Real.log y`), then `x` must be equal to `y`. This property is important for calculations involving the logarithmic function on the positive real numbers.

The real logarithm function is injective on the set of positive real numbers.


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

This theorem, `sup_congr_left`, states that for any type `α` that is a semilattice under the sup operation (denoted ⊔), given three elements `a`, `b`, and `c` of type `α`, if `b` is less than or equal to the sup of `a` and `c`, and `c` is less than or equal to the sup of `a` and `b`, then the sup of `a` and `b` is equal to the sup of `a` and `c`. In simpler terms, this theorem captures a specific property of partial ordering in the context of a semilattice: the sup operation, which gives the least upper bound of two elements, is commutative under certain conditions.

If `α` is a semilattice under sup and `a`, `b`, `c` are elements of `α` with `b ≤ a ⊔ c` and `c ≤ a ⊔ b`, then `a ⊔ b = a ⊔ c`.


theorem Nat.cast_ofNat :
    ∀ {R : Type u_1} {n : ℕ} [inst : NatCast R] [inst_1 : Nat.AtLeastTwo n], ↑(OfNat.ofNat n) = OfNat.ofNat n := by
  sorry

This theorem, named `Nat.cast_ofNat`, states that for any given type `R` and natural number `n` which is at least two (`Nat.AtLeastTwo n`), the natural number `n`, when it is cast to type `R` using the `NatCast` instance (`↑(OfNat.ofNat n)`), is equal to the result of applying the `OfNat.ofNat` function on `n`. Here, the `OfNat.ofNat` function is a method of creating elements of type `R` from natural numbers. In other words, it establishes the equivalence between two methods of converting natural numbers to other types, given that the natural number is at least two.

For any type `R` and natural number `n` (`Nat.AtLeastTwo n`), the operation `↑(OfNat.ofNat n)` equals `OfNat.ofNat n`.


theorem List.nodup_map_iff :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : List α},
      Function.Injective f → (List.Nodup (List.map f l) ↔ List.Nodup l) :=
  by sorry

The theorem `List.nodup_map_iff` states that for any two types `α` and `β`, a function `f` from `α` to `β`, and a list `l` of type `α`, if the function `f` is injective (meaning that if `f x = f y` then `x = y`), then the list `l` has no duplicate elements if and only if the list resulting from applying `f` to each element of `l` also has no duplicate elements. In other words, the uniqueness of the elements in the original list is preserved under the action of an injective function.

For any injective function `f` and list `l`, if `l` has no duplicate elements then the list `[f x | x ∈ l]` also has no duplicate elements.


theorem CauchyFilter.uniformInducing_pureCauchy :
    ∀ {α : Type u} [inst : UniformSpace α], UniformInducing CauchyFilter.pureCauchy := by sorry

The theorem `CauchyFilter.uniformInducing_pureCauchy` states that for every type `α` that has a `UniformSpace` structure, the function `CauchyFilter.pureCauchy` is uniformly inducing. In other words, `CauchyFilter.pureCauchy` has the property that the preimage of a uniformity on the completion of `α` (i.e., `CauchyFilter α`) under this function is equal to the uniformity on `α`. This function embeds `α` into its completion, the space of Cauchy filters on `α`, and ensures that uniform properties are preserved under this embedding.

For any type `α` with a `UniformSpace` structure, the function `CauchyFilter.pureCauchy` is a uniformly inducing map from `α` to its completion `CauchyFilter α`.


theorem Computation.terminates_of_mem : ∀ {α : Type u} {s : Computation α} {a : α}, a ∈ s → Computation.Terminates s :=
  by sorry

This theorem states that for any type `α`, any computation `s` of type `α`, and any element `a` of type `α`, if `a` belongs to `s` then the computation `s` terminates. In other words, if an element `a` is in the set of outcomes of the computation `s`, then the computation `s` is guaranteed to eventually reach a stopping point.

For any type `α`, computation `s` of type `α`, and element `a` of type `α` in `s`, the computation `s` terminates.


theorem SimpleGraph.Walk.darts_append :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : SimpleGraph.Walk G u v) (p' : SimpleGraph.Walk G v w),
      SimpleGraph.Walk.darts (SimpleGraph.Walk.append p p') = SimpleGraph.Walk.darts p ++ SimpleGraph.Walk.darts p' :=
  by sorry

The theorem `SimpleGraph.Walk.darts_append` states that for any simple graph `G` with vertices of some type `V`, and any three vertices `u`, `v`, and `w` in the graph, if `p` is a walk from `u` to `v` and `p'` is a walk from `v` to `w`, then the list of darts (edges directed from one vertex to another) visited in the walk from `u` to `w` (which is the concatenation of `p` and `p'`) is the same as the concatenation of the list of darts visited in `p` and the list of darts visited in `p'`. In other words, the ordering of the darts visited in the combined walk is the same as the ordering of the darts in the individual walks.

Given a simple graph with vertices of type `V` and walks `p` from vertex `u` to vertex `v` and `p'` from vertex `v` to vertex `w`, the list of darts visited in the walk from `u` to `w` (the concatenation of `p` and `p'`) is equal to the concatenation of the lists of darts visited in `p` and `p'`.


theorem Polynomial.eval₂_finset_sum :
    ∀ {R : Type u} {S : Type v} {ι : Type y} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (s : Finset ι)
      (g : ι → Polynomial R) (x : S),
      Polynomial.eval₂ f x (Finset.sum s fun i => g i) = Finset.sum s fun i => Polynomial.eval₂ f x (g i) :=
  by sorry

The theorem `Polynomial.eval₂_finset_sum` states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, any finite set `s`, any function `g` mapping elements of `s` to polynomials in `R`, and any element `x` of `S`, the evaluation of the sum of the polynomials `g i` for `i` in `s` at `x` under the homomorphism `f` is the same as the sum of the evaluations of each polynomial `g i` at `x` under the homomorphism `f`. In mathematical notation, this theorem says that for all these elements, $\text{eval}_2 f x (\sum_{i \in s} g(i)) = \sum_{i \in s} \text{eval}_2 f x (g(i))$.

For any semirings R and S, ring homomorphism f from R to S, finite set s, and function g mapping elements of s to polynomials in R, the evaluation of the sum of g(i) for i in s under homomorphism f is equal to the sum of the evaluations of each g(i) under f. In symbols, eval₂ f x (∑ i ∈ s g i) = ∑ i ∈ s eval₂ f x (g i).


theorem WithBot.not_lt_none : ∀ {α : Type u_1} [inst : LT α] (a : WithBot α), ¬a < none := by sorry

This theorem, `WithBot.not_lt_none`, states that for any type `α` that has a less-than order `LT`, and for any element `a` of the type `WithBot α` (which is `α` with a bottom element `⊥` added), `a` is not less than `none` (which corresponds to `⊥`). In simpler terms, no element of `WithBot α` is less than the bottom element `⊥`.

For any type `α` with a less-than order `LT`, and for any `a` in `WithBot α`, we have `a ≻ ⊥` (`a` is not less than the bottom element `⊥`).


theorem max_neg_neg : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b : α), max (-a) (-b) = -min a b := by
  sorry

This theorem, named `max_neg_neg`, states that for any type `α` that is a linearly ordered additive commutative group, the maximum of the negations of two elements `a` and `b` is equal to the negation of the minimum of `a` and `b`. In other words, it's saying that the maximum of `-a` and `-b` is the same as `-min(a, b)`. This theorem is applicable to any set where the elements can be ordered and addition is commutative, such as the real numbers.

For any linearly ordered additive commutative group `α`, `- (min a b) = max (-a, -b)`.


theorem measurableEmbedding_const_vadd :
    ∀ {G : Type u_1} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : AddGroup G]
      [inst_3 : AddAction G α] [inst : MeasurableVAdd G α] (c : G), MeasurableEmbedding fun x => c +ᵥ x :=
  by sorry

This theorem states that for any given type `G`, type `α`, and a constant `c` of type `G`, if `G` has a measurable space structure, `α` has a measurable space structure, `G` is an additive group, `G` acts on `α` additively, and this action is measurable, then the function that maps `x` to `c` added to `x` (`c +ᵥ x`) is a measurable embedding. A measurable embedding is a function that is both measurable and injective, and the preimage of any measurable set under this function is also measurable. The types `G` and `α` could be any types, such as real numbers, integers, etc., as long as the required structures are defined for them.

If `G` is a measurable additive group acting measurably and additively on a measurable type `α`, then the function `x ↦ c + x` is a measurable embedding.


theorem FractionalIdeal.coe_le_coe :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {I J : FractionalIdeal S P}, ↑I ≤ ↑J ↔ I ≤ J :=
  by sorry

The theorem `FractionalIdeal.coe_le_coe` states that for any commutative ring `R`, any submonoid `S` of `R`, any type `P` equipped with a commutative ring structure and an `R`-algebra structure, and any two fractional ideals `I` and `J` of `S` on `P`, the relation that `I` is a subset of or equal to `J` in the set of fractional ideals is equivalent to the relation that `I` is a subset of or equal to `J` as subsets in the algebra `P`. In other words, the inclusion relationship between `I` and `J` remains the same whether we view them as fractional ideals or as subsets of the algebra `P`.

For any commutative ring `R`, submonoid `S` of `R`, type `P` with commutative ring and `R`-algebra structures, and fractional ideals `I` and `J` of `S` on `P`, `I ⊆ J` as fractional ideals if and only if `I ⊆ J` as subsets of `P`.


theorem List.splitAt_eq_take_drop :
    ∀ {α : Type u} (n : ℕ) (l : List α), List.splitAt n l = (List.take n l, List.drop n l) := by sorry

The theorem `List.splitAt_eq_take_drop` states that for any list `l` of a certain type `α` and any natural number `n`, splitting the list `l` at the index `n` is equivalent to creating a pair of lists where the first list is the result of taking the first `n` elements of `l` and the second list is the result of dropping the first `n` elements from `l`. In other words, the theorem describes how splitting a list at a certain position can be viewed as taking and dropping elements from the list.

For any list `l` of type `α` and natural number `n`, `List.splitAt n l = (take n l, drop n l)`.


DifferentiableWithinAt.mono

theorem DifferentiableWithinAt.mono :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s t : Set E}, DifferentiableWithinAt 𝕜 f t x → s ⊆ t → DifferentiableWithinAt 𝕜 f s x :=
  by sorry

This theorem states that if a function `f` of type `E → F`, where `𝕜` is a non-trivially normed field, `E` is a normed additive commutative group over `𝕜`, and `F` is a normed additive commutative group over `𝕜`, is differentiable at a point `x` within a set `t`, then `f` is also differentiable at `x` within any subset `s` of `t`. This theorem is usually used to restrict the domain of differentiability to a smaller set.

If a function `f` from a normed additive commutative group `E` to a normed additive commutative group `F` over a non-trivially normed field is differentiable at a point `x` in a set `t`, then it is differentiable at `x` in any subset `s` of `t`.


theorem Nat.not_eq_zero_of_lt : ∀ {b a : ℕ}, b < a → a ≠ 0 := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `b` is less than `a`, then `a` cannot be zero. This is because zero is the smallest natural number and if `b` is less than `a`, then `a` must be greater than zero.

For all natural numbers `a` and `b`, if `b` < `a`, then `a` is non-zero.


/-- **Alias** of the forward direction of `List.mem_cons`. -/
theorem List.eq_or_mem_of_mem_cons : ∀ {α : Type u_1} {a b : α} {l : List α}, a ∈ b :: l → a = b ∨ a ∈ l := by sorry

This theorem states that for any type `α`, any two elements `a` and `b` of type `α`, and a list `l` of elements of type `α`, if `a` is an element of the list that consists of `b` followed by `l`, then `a` is either equal to `b` or `a` is an element of `l`. In other words, it underscores the fact that if an element is part of a list, it must be either the head of the list or part of the tail.

For any type `α` and elements `a, b` of type `α`, if `a` is in the list `[b] :: l` (i.e., `a` is the head or an element of the list `l`), then `a` is equal to `b` or `a` is an element of `l`.


Asymptotics.IsEquivalent.isTheta

theorem Asymptotics.IsEquivalent.isTheta :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u v → u =Θ[l] v :=
  by sorry

This theorem states that for any given types `α` and `β`, where `β` is a normed add commutative group, and any given functions `u` and `v` from `α` to `β`, along with a filter `l` on `α`, if `u` and `v` are asymptotically equivalent along `l` (i.e., the difference between `u` and `v` is little-o of `v` as `x` converges along `l`), then `u` is Theta of `v` along `l`, denoted as `u =Θ[l] v`. In terms of Big O notation, this implies that `u` and `v` have the same order of growth along the filter `l`.

If functions `u` and `v` from type `α` to a normed add commutative group `β` are asymptotically equivalent along filter `l` (little-o of `v` as `x` converges along `l`), then `u` is Theta of `v` along `l` (same order of growth).


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

This theorem states that for any type `α`, any measurable space instance of `α`, any measure `μ` of the measurable space, and any set `s` of `α`, the complement of `s` is in the "almost everywhere" filter of the measure `μ` if and only if the measure of `s` is equal to zero. Here, "almost everywhere" refers to the "almost everywhere" filter of co-null sets, and the measure of a set is a concept from measure theory that intuitively represents the "size" or "volume" of the set. The complement of a set `s` (denoted by `sᶜ`) is the set of elements not in `s`.

For any measurable space and measure, a set has zero measure if and only if its complement belongs to the "almost everywhere" filter of co-null sets.


/-- For any `y < 1` and any positive `x`, there exists `n : ℕ` with `y ^ n < x`.  -/
theorem exists_pow_lt_of_lt_one :
    ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] [inst_1 : Archimedean α] [inst_2 : ExistsAddOfLE α] {x y : α},
      0 < x → y < 1 → ∃ n, y ^ n < x :=
  by sorry

This theorem states that for any number `y` less than one and any positive number `x` in a Linear Ordered Semifield that satisfies the Archimedean property and the existence of addition operation, there exists a natural number `n` such that `y` raised to the power of `n` is less than `x`. In mathematical terms, for every `y < 1` and `x > 0`, there exists an `n ∈ ℕ` such that `y^n < x`.

For any `y` with `0 < x < 1` in an Archimedean Linear Ordered Semifield, there exists a natural number `n` such that `y^n < x`.


theorem Mathlib.Algebra.Associated._auxLemma.3 :
    ∀ {α : Type u_1} [inst : Monoid α] {p : α},
      Irreducible p = (¬IsUnit p ∧ ∀ (a b : α), p = a * b → IsUnit a ∨ IsUnit b) :=
  by sorry

This theorem, named `Mathlib.Algebra.Associated._auxLemma.3`, states that for any type `α` that forms a monoid and any element `p` of `α`, `p` is irreducible if and only if `p` is not a unit and for all elements `a` and `b` in `α`, if `p` equals the product of `a` and `b`, then either `a` or `b` must be a unit. In the context of algebra, a monoid is a set equipped with an associative binary operation and an identity element, a unit is an element that has a multiplicative inverse, and an irreducible element is a non-unit element that cannot be expressed as a product of two non-unit elements.

For any monoid `α` and element `p` in `α` that is not a unit, `p` is irreducible if and only if for all `a` and `b` in `α` such that `p = a * b`, either `a` or `b` is a unit.


Substring.ValidFor.valid

theorem Substring.ValidFor.valid :
    ∀ {l m r : List Char} {s : Substring}, Substring.ValidFor l m r s → Substring.Valid s := by sorry

This theorem states that for any lists of characters `l`, `m`, and `r`, and any substring `s`, if `s` is a valid substring for the concatenation of `l`, `m`, and `r`, then `s` is a valid substring in general. Essentially, it suggests that the validity of a substring in a larger context implies its validity in any context.

If `s` is a valid substring of the concatenation of lists `l`, `m`, and `r` in Lean 4, then `s` is a valid substring in Lean 4.


theorem ExistsContDiffBumpBase.u_exists :
    ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E],
      ∃ u,
        ContDiff ℝ ⊤ u ∧
          (∀ (x : E), u x ∈ Set.Icc 0 1) ∧ Function.support u = Metric.ball 0 1 ∧ ∀ (x : E), u (-x) = u x :=
  by sorry

This theorem, `ExistsContDiffBumpBase.u_exists`, states that for any normed additive commutative group `E` that is also a finite-dimensional normed space over the real numbers, there exists a function `u` that satisfies the following conditions:

1. `u` is infinitely continuously differentiable (mentioned as `ContDiff ℝ ⊤ u`),

2. For all `x` in `E`, the value of `u` at `x` lies in the closed interval between 0 and 1, inclusive (expressed as `u x ∈ Set.Icc 0 1`),

3. The support of the function `u` (the set of points where `u` is non-zero) is exactly the open ball of radius 1 around the origin in `E` (indicated as `Function.support u = Metric.ball 0 1`),

4. The function `u` is even, that is, for every `x` in `E`, `u(-x)` equals `u(x)`.

In essence, the theorem guarantees the existence of an infinitely differentiable "bump" function that peaks at the origin of the space, is nonzero in a radius-1 ball around the origin, and is zero elsewhere.

Given a finite-dimensional real normed space `E`, there exists an infinitely differentiable, even function `u` with support in the open ball of radius 1 around the origin and values in the closed interval [0, 1].


theorem Cardinal.lt_aleph0_of_finite : ∀ (α : Type u) [inst : Finite α], Cardinal.mk α < Cardinal.aleph0 := by sorry

The theorem `Cardinal.lt_aleph0_of_finite` states that for any type `α` that is finite (as indicated by the instance `inst : Finite α`), the cardinality of `α` (represented as `Cardinal.mk α`) is less than `ℵ₀` (aleph-zero), which is the cardinality of the set of natural numbers. In other words, the size of any finite set is less than the size of the set of natural numbers.

For any finite type `α`, the cardinality of `α` is strictly less than that of the natural numbers.


theorem bind_congr :
    ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Bind m] {x : m α} {f g : α → m β},
      (∀ (a : α), f a = g a) → x >>= f = x >>= g :=
  by sorry

This theorem, named `bind_congr`, states that for any type constructor `m` with a bind operation, and any types `α` and `β`, if we have two functions `f` and `g` from `α` to `m β` such that `f` and `g` are equal for all inputs `a` of type `α`, then binding `x` (of type `m α`) to `f` is the same as binding `x` to `g`. In simpler terms, if two functions are the same for every input, applying them after a bind operation yields the same result regardless of the function used.

For any type constructor `m` with a bind operation, and functions `f` and `g` from type `α` to `m β`, if `f(x) = g(x)` for all `x : α`, then `bind (x : m α) (f x) = bind (x : m α) (g x)`.


theorem Nat.gcd_eq_left : ∀ {m n : ℕ}, m ∣ n → Nat.gcd m n = m := by sorry

This theorem states that for all natural numbers `m` and `n`, if `m` divides `n` (denoted as `m ∣ n`), then the greatest common divisor (gcd) of `m` and `n` is `m` itself. In other words, if a number `m` is a divisor of another number `n`, then `m` is the largest number that can divide both `m` and `n` without leaving a remainder.


/-- The scalar multiplication of a constant and a `C^n` function is `C^n`.  -/
theorem ContDiff.const_smul :
    ∀ {𝕜 : 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 : ℕ∞}
      {R : Type u_3} [inst_5 : Semiring R] [inst_6 : Module R F] [inst_7 : SMulCommClass 𝕜 R F]
      [inst_8 : ContinuousConstSMul R F] {f : E → F} (c : R), ContDiff 𝕜 n f → ContDiff 𝕜 n fun y => c • f y :=
  by sorry

The theorem `ContDiff.const_smul` states that given a non-trivially normed field 𝕜, normed add commutative groups E and F, a normed space 𝕜 E, a normed space 𝕜 F, a semiring R, a module R F, a `C^n` function `f` from E to F, and a constant scalar `c` from semiring `R`, if the function `f` is continuously differentiable up to order `n`, then the function resulting from scalar multiplication of `f` by `c` is also continuously differentiable up to the same order `n`. In other words, multiplying a `C^n` function by a constant does not change its differentiability order.

If `f` is a `C^n` function from a normed add commutative group `E` to another normed add commutative group `F` over a non-trivially normed field `𝕜`, then the scalar multiplication of `f` by a constant `c` from a semiring `R` preserves its differentiability order `n`.


theorem ENNReal.zero_toReal : 0.toReal = 0 := by sorry

This theorem asserts that the real number representation of the number zero in extended non-negative real numbers (ENNReal), denoted as `0.toReal`, is equal to zero. In other words, when the extended non-negative real number zero is converted to a real number, the result is also zero.

The theorem asserts that `0.toReal` equals zero in the context of extended non-negative real numbers.


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

This theorem holds for a function `f` from a normed additive commutative group `E` to another normed additive commutative group `F`, both over a nontrivially normed field `𝕜`. It states that the function `f` has a derivative `f'` at a point `x` with respect to a filter `L` if and only if the difference between `f(x')` and `f(x)` and the linear approximation `f'(x' - x)` is little-o of `x' - x` at the filter `L`. In other words, the error of linear approximation is infinitesimal compared to `x' - x` as `x'` approaches `x` according to the filter `L`.

A function `f` from normed additive commutative groups `E` and `F` over a nontrivially normed field has a derivative `f'` at `x` with respect to filter `L` if and only if the difference `f(x') - f(x) - f'(x' - x)` is o(`x' - x`) as `x'` approaches `x` according to the filter `L`.


CategoryTheory.ShortComplex.Exact.op

theorem CategoryTheory.ShortComplex.Exact.op :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S → CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.op S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Exact.op` states that for any category `C` with zero morphisms, and a given short complex `S`, if `S` is exact, then the opposite short complex associated to `S` in the opposite category `Cᵒᵖ` is also exact. In other words, the exactness property is preserved under the operation of taking the opposite short complex.

If `C` is a category with zero morphisms and `S` is a short complex in `C` that is exact, then the opposite short complex of `S` in the opposite category `Cᵒᵖ` is also exact.


theorem Finset.union_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Finset α), s ∪ insert a t = insert a (s ∪ t) := by sorry

The theorem `Finset.union_insert` states that for any type `α` with decidable equality, and for any element `a` of type `α` and sets `s` and `t` of type `Finset α` (finite sets of `α`), the union of `s` and the insertion of `a` into `t` is equal to the insertion of `a` into the union of `s` and `t`. In other words, it doesn't matter whether we first insert an element into a set and then take the union, or first take the union and then insert the element; the result will be the same.

For any type `α` with decidable equality, and finite sets `s` and `t` of type `Finset α` and element `a` of type `α`, `a ∉ s → s ∪ {a} = {a} ∪ s`. (Assuming `{a} ∪ s` and `s ∪ {a}` mean the set union of `s` and `{a}` and `{a}` and `s` respectively, and `a ∉ s` denotes that `a` is not an element of `s`.)


theorem Nat.eq_zero_of_add_eq_zero_left : ∀ {n m : ℕ}, n + m = 0 → m = 0 := by sorry

This theorem states that for all natural numbers `n` and `m`, if the sum of `n` and `m` equals zero, then `m` must be zero. This is a property of the natural numbers, since they do not include negative numbers and thus the only way their sum could be zero is if both numbers are zero.

If two natural numbers have a sum of zero, then each number is zero.


theorem NNReal.sq_sqrt : ∀ (x : NNReal), NNReal.sqrt x ^ 2 = x := by sorry

This theorem states that for every nonnegative real number `x`, the square of the square root of `x` is equal to `x` itself. In mathematical terms, for all `x` in nonnegative real numbers, (√x)² = x. This is a formalization of the well-known property of the square root operation in real numbers.

For all non-negative real numbers x, (√x)² = x.


theorem UniqueSums.of_injective_addHom :
    ∀ {G : Type u} {H : Type v} [inst : Add G] [inst_1 : Add H] (f : AddHom H G),
      Function.Injective ⇑f → UniqueSums G → UniqueSums H :=
  by sorry

The theorem `UniqueSums.of_injective_addHom` states that for any two types `G` and `H` with addition structures (`Add G` and `Add H` respectively), and a function `f` from `H` to `G` that is an additive homomorphism (`AddHom H G`), if `f` is injective (i.e., different elements in `H` map to different elements in `G`), then the property of having unique sums in `G` implies the property of having unique sums in `H`. In other words, if `G` has the property that every sum of elements in `G` is unique and if there is an injective additive homomorphism from `H` to `G`, then `H` also has the property of unique sums.

If `G` and `H` are types with addition structures, `f` is an injective additive homomorphism from `H` to `G`, and every sum of elements in `G` is unique, then every sum of elements in `H` is unique.


theorem Fintype.sum_unique :
    ∀ {α : Type u_9} {β : Type u_10} [inst : AddCommMonoid β] [inst_1 : Unique α] [inst_2 : Fintype α] (f : α → β),
      (Finset.sum Finset.univ fun x => f x) = f default :=
  by sorry

The theorem `Fintype.sum_unique` states that for all types `α` and `β`, given that `β` is an additive commutative monoid, `α` is a unique type and a finite type, and a function `f` from `α` to `β`, the sum of `f x` as `x` ranges over all elements of the universal (i.e., total) finite set of `α` is equal to the value of function `f` at the default element of `α`. In other words, if there is only one element in type `α` (due to the `Unique` instance), summing over all elements of `α` is the same as applying `f` to the lone element.

If `α` is a finite, unique type and `β` is an additive commutative monoid, then the sum of `f(x)` over all `x` in `α` equals `f(default α)`.


theorem Multiset.add_cons : ∀ {α : Type u_1} (a : α) (s t : Multiset α), s + a ::ₘ t = a ::ₘ (s + t) := by sorry

The theorem `Multiset.add_cons` states that for all types `α`, and for all elements `a` of type `α`, and multisets `s` and `t` of type `α`, appending an element `a` to the multiset `t`, and then adding the resulting multiset to `s`, is the same as adding `s` and `t` together and then prepending `a` to the resulting multiset. In other words, the order in which we add the single element `a` and the multiset `t` doesn't change the resulting multiset. This theorem captures a kind of commutativity property of adding a single element and a multiset in the context of multisets.

For all types `α` and multisets `s` and `t` of type `α`, `Multiset.add_cons s a (Multiset.union s t) = Multiset.insert a (Multiset.union s t)`.


theorem Nat.lt_one_iff : ∀ {n : ℕ}, n < 1 ↔ n = 0 := by sorry

This theorem states that for any natural number `n`, `n` is less than 1 if and only if `n` is equal to 0. In more formal mathematical terms, for all natural numbers `n`, the proposition `n < 1` is logically equivalent to the proposition `n = 0`.

For any natural number `n`, `n` is less than 1 if and only if `n` equals 0. (Equivalently, `n < 1` if and only if `n = 0`.)


theorem Mathlib.Algebra.Algebra.Operations._auxLemma.1 :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
      (x ∈ 1) = ∃ y, (algebraMap R A) y = x :=
  by sorry

This theorem states that for any type `R` with a commutative semiring structure and another type `A` with a semiring structure and an algebra structure over `R`, and for any element `x` of `A`, `x` belongs to `1` if and only if there exists an element `y` from `R` such that when `y` is mapped into `A` using the algebra structure, it equals `x`. In other words, every element in the unit of `A` can be represented as an image of an element from `R` under the algebra map.

For any commutative semiring `R` and an `R`-algebra `A` with unit `1`, an element `x` of `A` belongs to the unit if and only if there exists `r` in `R` such that `x = alg_map r 1`, where `alg_map` is the algebra map from `R` to `A`.


theorem Filter.HasBasis.lift'_closure :
    ∀ {X : Type u} {ι : Sort w} [inst : TopologicalSpace X] {l : Filter X} {p : ι → Prop} {s : ι → Set X},
      Filter.HasBasis l p s → Filter.HasBasis (Filter.lift' l closure) p fun i => closure (s i) :=
  by sorry

This theorem, `Filter.HasBasis.lift'_closure`, is about filters and topological spaces. It states that for any type `X` and index type `ι`, given a topological space over `X`, a filter `l` on `X`, a predicate `p` on `ι`, and a function `s` from `ι` to sets of `X`, if filter `l` has a basis defined by the predicate `p` and the function `s`, then the filter obtained by lifting `l` along the `closure` function (which transforms each set to its closure in the topological space) also has a basis defined by the same predicate `p` but with the function `s` now mapping each index to the closure of the corresponding set. In other words, the theorem demonstrates how the operation of taking closures of sets interacts nicely with the operation of lifting a filter along a function.

If a filter on a topological space has a basis given by a predicate and a function, then the filtered subsets generated by the closure of each set in the basis form a basis for the filtered subsets obtained by lifting the filter along the closure function.


theorem Finset.tsum_subtype' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : Finset β) (f : β → α),
      ∑' (x : ↑↑s), f ↑x = Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.tsum_subtype'` states that for any types `α` and `β`, given an additive commutative monoid over `α` and a topological space over `α`, for a finite set `s` of type `β` and a function `f` from `β` to `α`, the sum of `f x` for `x` in the double-coercion of `s` (which treats `s` as a subtype, then as an infinite sum) is equal to the finite sum of `f x` over `s`. In other words, it says that the infinite sum over the elements of a finite set is the same as the finite sum over those elements, even when the finite set is treated as a subtype.

For any additive commutative monoid over type `α`, topological space over `α`, finite set `s` of type `β`, and function `f` from `β` to `α`, the double-coercion sum of `f x` over `s` equals the finite sum of `f x` over `s`.


theorem Polynomial.card_roots :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      p ≠ 0 → ↑(Multiset.card (Polynomial.roots p)) ≤ Polynomial.degree p :=
  by sorry

The theorem `Polynomial.card_roots` states that for any non-zero polynomial `p` over a commutative ring `R` that is also an integral domain, the cardinality of the multiset of roots of `p` (which includes each root with its multiplicity) is less than or equal to the degree of `p`. Here, the cardinality of a multiset is defined as the sum of the multiplicities of all its elements, and the degree of a polynomial is defined as the largest exponent of `X` in the polynomial, with the degree of the zero polynomial being bottom (`⊥`).

The number of roots (counting multiplicities) of a non-zero polynomial over a commutative integral domain is less than or equal to its degree.


theorem orderOf_dvd_natCard : ∀ {G : Type u_6} [inst : Group G] (x : G), orderOf x ∣ Nat.card G := by sorry

The theorem `orderOf_dvd_natCard` states that for any group `G` and for any element `x` in `G`, the order of `x` divides the cardinality of `G`. Here, the order of an element `x` in `G`, denoted as `orderOf x`, is the smallest positive integer `n` such that `x^n = 1`, or `0` if such an integer does not exist (meaning `x` has infinite order). The cardinality of `G`, denoted as `Nat.card G`, is the size of the set of elements in `G` translated into a natural number, or `0` if `G` is infinite. So this theorem is essentially a statement of Lagrange's theorem in group theory, which says that the order of any element divides the order of the group.

For any group G and any of its elements x, the order of x divides the cardinality of G.


theorem Mathlib.Algebra.Group.Basic._auxLemma.3 :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsRightCancelMul G] (a : G) {b c : G}, (b * a = c * a) = (b = c) := by
  sorry

This theorem states that for any type `G` that has a multiplication operation and satisfies the right cancellation law (i.e., if `x * a = y * a` then `x = y`), for any elements `a`, `b`, and `c` of `G`, `b` is equal to `c` if and only if the product of `b` and `a` is equal to the product of `c` and `a`. In other words, you can cancel `a` from both sides of the equation `b * a = c * a` to deduce `b = c`.

For any type `G` with multiplication operation and right cancellation law, `b = c` if and only if `b * a = c * a`.


theorem integrable_exp_neg_mul_sq :
    ∀ {b : ℝ}, 0 < b → MeasureTheory.Integrable (fun x => Real.exp (-b * x ^ 2)) MeasureTheory.volume := by sorry

The theorem `integrable_exp_neg_mul_sq` states that for any positive real number `b`, the function `x => Real.exp (-b * x ^ 2)`, which represents the real exponential of the negative product of `b` and the square of `x`, is integrable with respect to the Lebesgue measure. In other words, this function is measurable and the integral over its entire domain of the norm of its value at each point is finite. This integral corresponds to the total "signed area" under the graph of the function.

The function `x => Real.exp (-b * x ^ 2)` is integrable with respect to the Lebesgue measure for any positive real number `b`.


theorem Finsupp.sum_mapRange_index :
    ∀ {α : Type u_1} {M : Type u_8} {M' : Type u_9} {N : Type u_10} [inst : Zero M] [inst_1 : Zero M']
      [inst_2 : AddCommMonoid N] {f : M → M'} {hf : f 0 = 0} {g : α →₀ M} {h : α → M' → N},
      (∀ (a : α), h a 0 = 0) → Finsupp.sum (Finsupp.mapRange f hf g) h = Finsupp.sum g fun a b => h a (f b) :=
  by sorry

The theorem `Finsupp.sum_mapRange_index` states that for any types `α`, `M`, `M'`, `N`, where `M`, `M'` are equipped with a zero and `N` is an additive commutative monoid, given a function `f : M → M'` that maps zero to zero, a function `g : α →₀ M` (a finite support function from `α` to `M`), a function `h : α → M' → N` and the condition that `h a 0 = 0` for all `a` in `α`, the sum over the support of `g` mapped through `f` using function `h` is equal to the sum over the support of `g` using `h` applied to `a` and `f(b)`. Here, the sum is computed as the sum of `h a (f a)` over the support of `f` (which is a finite set of values away from which `f` is zero).

For functions `f : M -> M'` mapping zero to zero, `g : α ->0 M`, and `h : α -> M' -> N` with `h a 0 = 0` for all `a`, the sum of `h a (f a)` over the support of `g` is equal to the sum of `h a b` over the support of `g` for all `b` in the support of `g`.


theorem Polynomial.eraseLead_coeff :
    ∀ {R : Type u_1} [inst : Semiring R] {f : Polynomial R} (i : ℕ),
      Polynomial.coeff (Polynomial.eraseLead f) i = if i = Polynomial.natDegree f then 0 else Polynomial.coeff f i :=
  by sorry

The theorem `Polynomial.eraseLead_coeff` states that for any semiring `R`, any polynomial `f` of type `R`, and any natural number `i`, the coefficient of the `i`-th term of the polynomial obtained by erasing the leading term of `f` is determined by a simple rule. If `i` is equal to the degree of the polynomial `f`, then the `i`-th coefficient of the new polynomial is `0`. Otherwise, the `i`-th coefficient of the new polynomial is the same as the `i`-th coefficient of the original polynomial `f`. In other words, the operation of erasing the leading term from a polynomial only affects the coefficient of the term with the highest degree, turning it to `0`, while leaving all other coefficients intact.

For any polynomial `f` over a semiring `R` and natural number `i`, the `i`-th coefficient of the polynomial obtained by erasing the leading term of `f` is equal to the `i`-th coefficient of `f` if `i` is not the degree of `f`, and is equal to 0 otherwise.


theorem MeasureTheory.Measure.pi_of_empty :
    ∀ {α : Type u_4} [inst : Fintype α] [inst_1 : IsEmpty α] {β : α → Type u_5} {m : (a : α) → MeasurableSpace (β a)}
      (μ : (a : α) → MeasureTheory.Measure (β a)) (x : optParam ((a : α) → β a) fun a => isEmptyElim a),
      MeasureTheory.Measure.pi μ = MeasureTheory.Measure.dirac x :=
  by sorry

This theorem, `MeasureTheory.Measure.pi_of_empty`, states that for any type `α` that is a Fintype (i.e., it has a finite number of elements) and is also empty, and for any function `β : α → Type u_5` that maps each element of `α` to a measurable space, and for any measure `μ : (a : α) → MeasureTheory.Measure (β a)`, which is a function that assigns a measure to each element of `α`, then the finite product of these measures, `MeasureTheory.Measure.pi μ`, is equal to the Dirac measure at a point `x`, where `x` is a function from `α` to `β a` that uses the elimination of emptiness if `α` is empty. The Dirac measure `MeasureTheory.Measure.dirac x` is a measure that is zero everywhere except at the point `x`.

For any empty Fintype `α` and function `β : α → Type u_5`, if `μ : α → MeasureTheory.Measure (β α)` assigns a measure to each `α` element, then the product measure `MeasureTheory.Measure.pi μ` equals the Dirac measure at a point `x : α → β α`.


theorem mul_neg_of_pos_of_neg :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulStrictMono α],
      0 < a → b < 0 → a * b < 0 :=
  by sorry

The theorem `mul_neg_of_pos_of_neg` states that for all types `α` that are instances of a multiplication-zero class, have a preorder relation, and satisfy the property of strict monotonicity of multiplication by positive elements on the left, if `a` is a positive element and `b` is a negative element, then the product of `a` and `b` is a negative element. In other words, if `0 < a` and `b < 0`, then `a * b < 0`. This corresponds to the standard rule in mathematics that the product of a positive and a negative number is always negative.

If `α` is a type with multiplication and zero, and `0 < a` and `b < 0`, then `a * b < 0`.


theorem Complex.contDiff_sinh : ∀ {n : ℕ∞}, ContDiff ℂ n Complex.sinh := by sorry

This theorem states that the complex hyperbolic sine function, `Complex.sinh`, is continuously differentiable for all orders `n` in the extended natural numbers, denoted as `ℕ∞`. In other words, you can take the derivative of `Complex.sinh` as many times as you want, and the resulting function will still be continuous. This is a fundamental property of the complex hyperbolic sine function and is essential in many areas of mathematics and engineering.

The complex hyperbolic sine function, `Complex.sinh`, is continuously differentiable for all orders on the extended natural numbers, `ℕ∞`.


theorem EMetric.infEdist_empty : ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α}, EMetric.infEdist x ∅ = ⊤ := by
  sorry

This theorem states that for any type `α` that is a PseudoEMetricSpace, the minimal extended distance (`infEdist`) from any given point `x` of type `α` to an empty set is infinity (`⊤`). In other words, in the context of a pseudo-metric space, if we try to find the smallest distance from a point to all points in an empty set, the result is always infinity.

For any pseudo-metric space `(α, edist)`, the infimum of distances from a point `x ∈ α` to the empty set is infinity.


/-- The angle between two vectors is at most π.  -/
theorem InnerProductGeometry.angle_le_pi :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      InnerProductGeometry.angle x y ≤ Real.pi :=
  by sorry

This theorem states that in an inner product space over the real numbers, which is also a normed additive commutative group, the undirected angle between any two vectors is always less than or equal to π. In other words, the angle calculated between two vectors using the arccosine of the dot product of the vectors divided by the product of their norms, does not exceed π (approximately 3.14159265...).

In an inner product space over the real numbers, the angle between any two vectors measured using the dot product and norm has magnitude less than or equal to π.


theorem WittVector.one_coeff_zero :
    ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R], 1.coeff 0 = 1 := by sorry

The theorem `WittVector.one_coeff_zero` states that for any natural number `p` and any type `R` such that `p` is a prime number (as defined by `Nat.Prime p`) and `R` is a commutative ring (as defined by `CommRing R`), the coefficient of the `0`th term in the Witt vector representation of the number `1` is `1`. In other words, the 0-th coefficient of `1` in the Witt vector space over a commutative ring is always `1`, regardless of the prime number used to define the Witt vector.

For any prime number $p$ and commutative ring $R$, the 0-th coefficient of the Witt vector representation of $1$ is $1$.


CovBy.toDual

/-- **Alias** of the reverse direction of `toDual_covBy_toDual_iff`. -/
theorem CovBy.toDual : ∀ {α : Type u_1} [inst : LT α] {a b : α}, a ⋖ b → OrderDual.toDual b ⋖ OrderDual.toDual a := by
  sorry

The theorem `CovBy.toDual` states that for any type `α` with a less-than (`LT`) operation and any two elements `a` and `b` of this type, if `a` is covered by `b` (denoted by `a ⋖ b`), then `b` is covered by `a` in the `OrderDual` of `α` (denoted by `OrderDual.toDual b ⋖ OrderDual.toDual a`). In other words, if `a` is covered by `b`, then reversing the ordering flips the cover relation. This theorem serves as an alias for the reverse direction of the theorem `toDual_covBy_toDual_iff`.

For any type equipped with a reflexive and transitive relation `LT`, if `a LT b` implies `b LT a` in the dual order `OrderDual`, then `LT` and `OrderDual` are dual orders.


theorem Finset.mem_sigma :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Finset ι} {t : (i : ι) → Finset (α i)} {a : (i : ι) × α i},
      a ∈ Finset.sigma s t ↔ a.fst ∈ s ∧ a.snd ∈ t a.fst :=
  by sorry

The theorem `Finset.mem_sigma` states that for all types `ι` and `α`, where `α` is a type dependent on `ι`, a given finset `s` of `ι`, a function `t` that takes an element of `ι` and returns a finset of `α i`, and a dependent pair `a` of type `ι` and `α i`, `a` is an element of the finset `sigma s t` if and only if the first component of `a` is in `s`, and its second component is in the finset `t` applied to the first component of `a`. In mathematical terms, this theorem says that a dependent pair belongs to the Cartesian product of a set and a family of sets indexed by that set exactly when its first component belongs to the set and its second component belongs to the particular set in the family indexed by the first component.

For all types `ι` and `α`, and for every finset `s` of `ι`, function `t : ι → Finset α`, and dependent pair `a : ι × α`, `a` is in the image of `σ` (the finite sum) of `s` and `t`, if and only if the first component of `a` is in `s` and the second component is in `t` applied to the first component of `a`.


theorem MeasureTheory.IsStoppingTime.measurableSet_eq' :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] [inst_3 : FirstCountableTopology ι]
      (hτ : MeasureTheory.IsStoppingTime f τ) (i : ι), MeasurableSet {ω | τ ω = i} :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_eq'` asserts that for any types `Ω` and `ι`, given a measurable space `m` over `Ω`, a linear order on `ι`, a filtration `f` over the measurable space indexed by `ι`, a function `τ` mapping `Ω` to `ι`, and provided that `ι` has a topological space structure, an order topology, and is first countable, if `τ` is a stopping time with respect to the filtration `f`, then for any `i` in `ι`, the set of `ω` in `Ω` such that `τ(ω)` equals `i` is a measurable set.

This means that, intuitively, if `τ` is a stopping time (a rule that determines when to stop a process, which can be determined with the information available at any given time), then the set of points in the space where the stopping time equals a specific time `i` is a measurable set - it can be assigned a 'size' or 'measure' in a meaningful way.

For any measurable space `(Ω, m)`, linear order `ι`, filtration `f` over `(Ω, m)` indexed by `ι`, and a stopping time `τ : Ω → ι`, if `ι` is a first countable topological space with an order topology, then for every `i` in `ι`, the set `{ ω : Ω | τ(ω) = i }` is measurable.


theorem Order.succ_mono : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α], Monotone Order.succ := by sorry

The theorem `Order.succ_mono` states that for any type `α` that has a preorder and a successor order structure, the successor function is monotone. In more detail, this means that if `a` and `b` are elements of type `α` and `a ≤ b`, then the successor of `a` is less than or equal to the successor of `b`. In mathematical terms, if `a ≤ b`, then `succ(a) ≤ succ(b)`. This theorem asserts the consistency of the successor operation within the ordered structure of the type.

For any type with a preorder and successor order structure, the successor function is monotone, i.e., if `a ≤ b`, then `succ(a) ≤ succ(b)`.


theorem CategoryTheory.Functor.id_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
      (CategoryTheory.Functor.id C).map f = f :=
  by sorry

The theorem `CategoryTheory.Functor.id_map` states that for any category `C` and any morphism `f` from object `X` to object `Y` in `C`, the map function of the identity functor on `C` applied to `f` is equivalent to `f` itself. In other words, the identity functor leaves every morphism in the category unchanged when it is applied.

For any category C and morphism f in C, the identity functor's map application to f is equal to f itself.


theorem List.pmap_congr :
    ∀ {α : Type u} {β : Type v} {p q : α → Prop} {f : (a : α) → p a → β} {g : (a : α) → q a → β} (l : List α)
      {H₁ : ∀ a ∈ l, p a} {H₂ : ∀ a ∈ l, q a},
      (∀ a ∈ l, ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → List.pmap f l H₁ = List.pmap g l H₂ :=
  by sorry

This theorem establishes that for any two functions `f` and `g` from an element of a list `l` and a proof that it satisfies a property `p` or `q` respectively to a type `β`, if for each element in the list `l`, `f` applied to this element and a proof that it satisfies `p` is equivalent to `g` applied to this element and a proof that it satisfies `q`, then the lists resulting from applying `List.pmap` with `f` and `g` to `l` are equal. `List.pmap` is a function that applies a function to each element of a list along with a proof that this element satisfies a certain property.

If for all `x : α` and proofs `p` and `q` that `x` satisfies `p` and `q` respectively, `f x p ≡ g x q` implies `List.pmap f (List.filter p l) = List.pmap g (List.filter q l)`, where `f : α → β`, `g : α → β`, `l : list α`, and `List.filter`, `List.pmap`, `≡` denote the filtering, pointwise mapping, and equality operations on lists and functions, respectively.


theorem segment_symm :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E] (x y : E),
      segment 𝕜 x y = segment 𝕜 y x :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any additive commutative monoid `E` with a scalar multiplication operation, the segment from point `x` to point `y` is the same as the segment from point `y` to point `x`. In terms of mathematical notation, a segment is defined as the set of points `z = a*x + b*y`, where `a` and `b` are non-negative and sum to 1. The theorem therefore asserts that this set of points is the same regardless of the order of `x` and `y`.

For any ordered semiring `𝕜` and additive commutative monoid `E` with a scalar multiplication operation, the sets of points `{z = a*x + b*y | a, b ∈ 𝕜, a ≥ 0, b ≥ 0, a + b = 1}` and `{z = a*y + b*x | a, b ∈ 𝕜, a ≥ 0, b ≥ 0, a + b = 1}` are equal.


theorem Measurable.coe_nnreal_real :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → NNReal}, Measurable f → Measurable fun x => ↑(f x) := by sorry

The theorem `Measurable.coe_nnreal_real` states that for any measurable space `α` and any measurable function `f` from `α` to the nonnegative real numbers (`NNReal`), the function that maps each element of `α` to its image under `f` and then applies the coercion from `NNReal` to the real numbers is also measurable. In other words, if you have a measurable function mapping into the nonnegative reals, taking the real part of the output of that function (via the coercion `↑`) will still give you a measurable function.

If `f : α → NNReal` is measurable, then the function `x ↦ ↑(f x) : α → ℝ` is measurable.


theorem neg_one_lt_zero : ∀ {α : Type u} [inst : LinearOrderedRing α], -1 < 0 := by sorry

This theorem states that for any type `α` that is a linear ordered ring, the negative one (`-1`) is less than zero (`0`). In terms of mathematics, for any linear ordered ring (which is a ring that also has a linear order compatible with the ring operations), the value `-1` is always less than `0`.


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

This theorem, named `sup_sdiff_right_self`, states that for any type `α` that forms a Generalized Coheyting Algebra (which is a certain type of algebraic structure), and for any two elements `a` and `b` of this type, the supremum (join) of `a` and `b`, subtracted by `b` (in the Coheyting algebra sense), is equal to `a` subtracted by `b`. This can be expressed mathematically as $(a \lor b) \setminus b = a \setminus b$, where $\lor$ denotes the supremum operation, and $\setminus$ denotes the subtraction operation in the context of a Generalized Coheyting Algebra.

In a Generalized Coalgebra, the supremum of two elements minus one of them equals the subtraction of the same elements. That is, $(a \lor b) \setminus b = a \setminus b$.


theorem Nat.card_prod : ∀ (α : Type u_3) (β : Type u_4), Nat.card (α × β) = Nat.card α * Nat.card β := by sorry

This theorem, `Nat.card_prod`, asserts that for any two types `α` and `β`, the cardinality of the Cartesian product of `α` and `β` (denoted as `α × β`) is equal to the product of the cardinalities of `α` and `β`. In Mathematical terms, if `Nat.card α` and `Nat.card β` denote the number of elements in `α` and `β` respectively, then the number of ordered pairs in the Cartesian product is `Nat.card α * Nat.card β`. However, if either `α` or `β` is infinite, then their cardinalities are defined as zero, and hence the cardinality of their Cartesian product is also zero.

For any types `α` and `β`, the cardinality of their Cartesian product `α × β` is equal to the product of their individual cardinalities, unless one or both are infinite in which case the cardinality is zero.


theorem CategoryTheory.Limits.limit.lift_map :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F]
      [inst_3 : CategoryTheory.Limits.HasLimit G] (c : CategoryTheory.Limits.Cone F) (α : F ⟶ G),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.lift F c) (CategoryTheory.Limits.limMap α) =
        CategoryTheory.Limits.limit.lift G ((CategoryTheory.Limits.Cones.postcompose α).obj c) :=
  by sorry

The theorem `CategoryTheory.Limits.limit.lift_map` states that for any category `J` and `C`, and any functors `F` and `G` from `J` to `C`, if `F` and `G` both have limits and `c` is a cone of `F`, and `α` is a natural transformation from `F` to `G`, then the composition of the morphism from the cone point of `c` to the limit of `F` and the morphism induced by `α` from the limit of `F` to the limit of `G`, is the same as the morphism from the cone point of the cone obtained by postcomposing `α` on `c` to the limit of `G`. In simpler terms, this theorem ensures a specific commutativity condition for the diagram involving the limit of two functors and a natural transformation between them.

Given categories `J` and `C`, functors `F` and `G` from `J` to `C`, their respective limits, a cone `c` of `F`, and a natural transformation `α` from `F` to `G`, the diagram commutes, i.e., the morphism from the cone point of `c` to the limit of `F` followed by `α` equals `α` followed by the morphism from the limit of `F` to the limit of `G`.


theorem gc_upperClosure_coe :
    ∀ {α : Type u_1} [inst : Preorder α],
      GaloisConnection (⇑OrderDual.toDual ∘ upperClosure) (SetLike.coe ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem states that for any type `α` that has a `Preorder` instance, there exists a Galois connection between two functions. The first function is composed of `OrderDual.toDual` and `upperClosure` while the second function is composed of `SetLike.coe` and `OrderDual.ofDual`. In other words, for all elements `a` and `b`, passing `a` through the first function and comparing it with `b` using the `≤` comparison is equivalent to comparing `a` with the result of passing `b` through the second function, again using the `≤` comparison. The functions `OrderDual.toDual` and `OrderDual.ofDual` are essentially identity functions over the order dual of a linear order. `upperClosure` gives the greatest upper set containing a given set, and `SetLike.coe` is a coercion from a term of a `SetLike` to its corresponding `Set`.

For any type `α` with a `Preorder` instance, the functions `OrderDual.toDual ∘ upperClosure` and `SetLike.coe ∘ OrderDual.ofDual` define a Galois connection, i.e., for all `a` and `b`, `a ≤ b` if and only if `upperClosure a ≤ b` if and only if `a ≤ SetLike.coe (OrderDual.ofDual b)`.


/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺`  -/
theorem CategoryTheory.GrothendieckTopology.plusMap_toPlus :
    ∀ {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)]
      (P : CategoryTheory.Functor Cᵒᵖ D)
      [inst_3 :
        ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D],
      CategoryTheory.GrothendieckTopology.plusMap J (CategoryTheory.GrothendieckTopology.toPlus J P) =
        CategoryTheory.GrothendieckTopology.toPlus J (CategoryTheory.GrothendieckTopology.plusObj J P) :=
  by sorry

This theorem in the context of category theory and Grothendieck topologies asserts that for any category `C` and a Grothendieck topology `J` on `C`, and any category `D` such that for any functor `P` from the opposite of `C` to `D`, any object `X` in `C`, and any cover `S` of `X` in `J`, the multicospan indexed by the cover of `X` with respect to the functor `P` has a multiequalizer, and the category `D` has all colimits of shape opposite to the poset of covers of `X` in `J` for any `X` in `C`. The plus construction applied to the morphism from `P` to its plus construction is equal to the morphism from the plus construction of `P` to the plus construction applied twice to `P`. This means, in the notation used in the theorem, `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺`.

For any category `C` with a Grothendieck topology `J`, and any functor `P` from the opposite of `C` to a category `D` with all colimits, the multiequalizer of the multicospan defined by `P` and the cover relations in `J` exists, and the plus construction preserves the identity morphism up to composition with `P`: `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺`.


theorem EuclideanGeometry.inversion_self :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] (c : P) (R : ℝ), EuclideanGeometry.inversion c R c = c :=
  by sorry

This theorem states that for any point `c` in a metric space `P` and any real number `R`, the inversion of `c` in a sphere centered at `c` with radius `R` is `c` itself. In other words, the center of a sphere in Euclidean Geometry is invariant under the process of inversion.
The inversion operation is defined such that each point `x` is mapped to a point `y` such that the vector from `c` to `y` is proportional to the square of the ratio of `R` to the distance from `x` to `c` times the vector from `c` to `x`.

For any point `c` in a metric space `P` and real number `R`, the result of inverting `c` in a sphere centered at `c` with radius `R` is `c` itself.


/-- If the angle between three points is `π / 2`, the last two points are not equal.  -/
theorem EuclideanGeometry.right_ne_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P},
      EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → p₃ ≠ p₂ :=
  by sorry

This theorem, from Euclidean Geometry, states that if the angle formed by three points is equal to `π / 2` (or 90 degrees), then the last two points are not the same. This is true in a two-dimensional vector space over the field of real numbers. The angle is calculated using the inner product space structure of the vector space, and the points are considered in a metric space structure.

In a 2-dimensional real vector space with inner product structure, if the angle between any two distinct vectors is 90 degrees, then the vectors are orthogonal and not equal.