theorem List.foldl_assoc :
    ∀ {α : Type u} {op : α → α → α} [ha : Std.Associative op] {l : List α} {a₁ a₂ : α},
      List.foldl op (op a₁ a₂) l = op a₁ (List.foldl op a₂ l) :=
  by sorry

The theorem `List.foldl_assoc` states that for any type `α`, any binary operation `op` on `α` which is associative, any list `l` of type `α`, and any two elements `a₁` and `a₂` of type `α`, the result of folding the list `l` from the left using `op` with initial accumulator `op a₁ a₂` is the same as applying `op` to `a₁` and the result of folding the list `l` from the left using `op` with initial accumulator `a₂`. This essentially says that the fold operation commutes with the associative operation `op`.

For any associative binary operation `op` on type `α`, and any lists `l` of type `α` and elements `a₁, a₂` of type `α`, `List.foldl op a₁ (a₂ :: l) = op a₁ (List.foldl op a₂ l)`.


theorem continuous_edist : ∀ {α : Type u_1} [inst : PseudoEMetricSpace α], Continuous fun p => edist p.1 p.2 := by sorry

This theorem states that for any type `α` which has a structure of a pseudo emetric space (a generalization of the concept of a metric space, where the distance between two points can possibly be infinite), the function which calculates the extended distance (`edist`) between a pair of points in `α` is a continuous function. Continuity here means that small changes in the input points result in small changes in their distance.

For any pseudo metric space `α`, the extended distance function `edist` is a continuous function.


theorem Bool.false_and : ∀ (b : Bool), (false && b) = false := by sorry

This theorem states that for any boolean value `b`, the logical "and" operation between `false` and `b` always results in `false`. This is based on standard logical behavior where if one of the operands of an "and" operation is `false`, the entire expression evaluates to `false` regardless of the other operand's value.

For all boolean values `b`, `false and b` equals `false`.


theorem Filter.Tendsto.const_smul :
    ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SMul M α]
      [inst_2 : ContinuousConstSMul M α] {f : β → α} {l : Filter β} {a : α},
      Filter.Tendsto f l (nhds a) → ∀ (c : M), Filter.Tendsto (fun x => c • f x) l (nhds (c • a)) :=
  by sorry

This theorem, `Filter.Tendsto.const_smul`, states that for any topological space `α` which has a scalar multiplication operation with a certain type `M`, and for which the scalar multiplication operation with a constant is continuous, if a function `f` from `β` to `α` tends to a limit `a` as we approach according to a filter `l`, then the function resulting from scaling `f` with a constant `c` also tends to a limit, specifically `c` scaled with `a`, according to the same filter. Essentially, it guarantees that the limit of the scaled function is the scaled limit when scalar multiplication is continuous.

If `f : β → α` tends to `a ∈ α` as filters under a topology on `α` with scalar multiplication `M → α → α` and continuous scalar multiplication by a constant, then `c → (x ↦ c * f x)` tends to `c * a`.


theorem Localization.mk_eq_monoidOf_mk' :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M},
      Localization.mk = Submonoid.LocalizationMap.mk' (Localization.monoidOf S) :=
  by sorry

The theorem `Localization.mk_eq_monoidOf_mk'` states that for any commutative monoid `M` and any submonoid `S` of `M`, the function `Localization.mk`, which sends a pair `(x, y)` where `x` is in `M` and `y` is in `S` to the equivalence class of `(x, y)` in the localization of `M` at `S`, is equal to the composite function `Submonoid.LocalizationMap.mk'` followed by `Localization.monoidOf S`. In other words, these two functions, which both map elements of `M` and `S` to the localization of `M` at `S`, are the same.

The function `Localization.mk` from a pair of an element in a commutative monoid `M` and a submonoid `S` to their equivalence class in the localization of `M` at `S` is equal to the composition of `Localization.monoidOf S` and `Submonoid.LocalizationMap.mk'`.


theorem le_of_mul_le_mul_right :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosReflectLE α],
      b * a ≤ c * a → 0 < a → b ≤ c :=
  by sorry

This theorem states that for any type `α` that is a preordered semiring (denoted by `Mul α`, `Zero α`, and `Preorder α`), and also satisfies the property of reverse monotonicity of multiplication by positive elements on the right (denoted by `MulPosReflectLE α`), if the product of `b` and `a` is less than or equal to the product of `c` and `a`, and `a` is positive (greater than zero), then `b` is less than or equal to `c`.

In other words, the theorem says that in such a structure, one can cancel a positive factor from both sides of an inequality. This is a form of the "cancellation law" for multiplication in ordered semirings.

If `α` is a preordered semiring with reverse monotonicity of multiplication by positive elements and `a > 0`, then `b ≤ c` implies `a * b ≤ a * c`.


theorem Complex.normSq_nonneg : ∀ (z : ℂ), 0 ≤ Complex.normSq z := by sorry

This theorem states that for all complex numbers `z`, the square of the norm of `z` (denoted by `Complex.normSq z`) is always greater than or equal to zero. In mathematical terms, it asserts that ∀ z ∈ ℂ, 0 ≤ ||z||², where ||z||² is the squared norm of `z`, calculated as the sum of the squares of the real and imaginary parts of `z`.

For all complex numbers z, the square of its norm is non-negative: 0 ≤ ||z||², where ||z||² is the sum of the squares of its real and imaginary parts.


theorem Vector.map_snoc :
    ∀ {α : Type u_2} {n : ℕ} (xs : Vector α n) {α_1 : Type u_1} {f : α → α_1} {x : α},
      Vector.map f (Vector.snoc xs x) = Vector.snoc (Vector.map f xs) (f x) :=
  by sorry

The `Vector.map_snoc` theorem states that for any type `α`, a natural number `n`, a vector `xs` of length `n` with elements of type `α`, another type `α_1`, a function `f` from `α` to `α_1`, and an element `x` of type `α`, mapping function `f` over a vector that results from appending `x` to `xs` is equivalent to appending `f(x)` to the vector that results from mapping `f` over `xs`. In other words, if we first append an element to a vector and then apply a function to each element of the vector, it's the same as if we first applied the function to each element of the vector and the element, and then appended the result to the transformed vector.

For any type `α`, vector `xs : α^n`, function `f : α → α₁`, and elements `x : α` and `y : α₁`, `(f <$> (xs ++ [x]) = (xs ++ [x]) ++ [f x])` holds in Lean.


theorem smul_lt_smul_iff_of_pos_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulStrictMono α β] [inst_5 : PosSMulReflectLT α β],
      0 < a → (a • b₁ < a • b₂ ↔ b₁ < b₂) :=
  by sorry

The theorem `smul_lt_smul_iff_of_pos_left` states that for any types `α` and `β`, given a scalar multiplication operation `SMul α β`, a preordering on `α` and `β`, a zero element in `α`, and assuming positive scalar multiplication is strictly monotonic and reflects less than comparisons in `β`, if a scalar `a` is positive, then scalar multiplication by `a` preserves the order of `b₁` and `b₂`. In other words, `a • b₁` is less than `a • b₂` if and only if `b₁` is less than `b₂`.

Given a commutative semigroup with zero `(α, ⊕, 0)`, a preorder `≤` on `α`, and a scalar multiplication `SMul α β` on `α × β` such that `a • b` is defined if and only if `a ≥ 0` and `b ≤ 0` or `a ≤ 0` and `b ≥ 0`, and `a • b₁ ≤ a • b₂` if and only if `b₁ ≤ b₂`, then `a > 0` implies `a • b₁ < a • b₂` whenever `b₁ < b₂`.


theorem CategoryTheory.ShortComplex.LeftHomologyData.f'_i_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S) {Z : C} (h_1 : S.X₂ ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.f' h)
          (CategoryTheory.CategoryStruct.comp h.i h_1) =
        CategoryTheory.CategoryStruct.comp S.f h_1 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.LeftHomologyData.f'_i_assoc` states that for any category `C` (of type `u_1`), which has zero morphisms, and for any short complex `S` of `C`, the composition of the morphisms `CategoryTheory.ShortComplex.LeftHomologyData.f' h` and the composition of `h.i` and `h_1` is equal to the composition of `S.f` and `h_1`. Here, `h` is a left homology data of `S` and `h_1` is a morphism from `S.X₂` to `Z` in `C`.

In terms of category theory, it means that in the specified context, the sequence of morphisms `CategoryTheory.ShortComplex.LeftHomologyData.f' h`, `h.i`, and `h_1` gives the same result as the sequence `S.f` and `h_1`. This demonstrates the associativity property of morphism composition in this particular setting.

Given a category `C` with zero morphisms and a short complex `S` in `C`, for any left homology data `h` and morphism `h_1` from `S.X₂` to an object `Z`, we have `(h.i ∘ h'_i) = (S.f ∘ h_1)`.


theorem Real.Angle.angle_eq_iff_two_pi_dvd_sub : ∀ {ψ θ : ℝ}, ↑θ = ↑ψ ↔ ∃ k, θ - ψ = 2 * Real.pi * ↑k := by sorry

This theorem states that for any two real numbers, `θ` and `ψ`, `θ` is congruent to `ψ` modulo `2π` if and only if there exists an integer `k` such that the difference `θ - ψ` is equal to `2π` multiplied by `k`. In other words, two angles are equivalent if their difference is a multiple of `2π`, reflecting the periodicity of the trigonometric functions.

Two real numbers `θ` and `ψ` are congruent modulo `2π` if and only if their difference `θ - ψ` is equal to an integer multiple of `2π`.


theorem Int.subNatNat_elim :
    ∀ (m n : ℕ) (motive : ℕ → ℕ → ℤ → Prop),
      (∀ (i n : ℕ), motive (n + i) n ↑i) →
        (∀ (i m : ℕ), motive m (m + i + 1) (Int.negSucc i)) → motive m n (Int.subNatNat m n) :=
  by sorry

This theorem, `Int.subNatNat_elim`, is a principle of elimination for the subtraction of two natural numbers. It takes four arguments: two natural numbers `m` and `n`, and a property `motive` which relates two natural numbers to an integer. The theorem then states that if this property holds for every pair of natural numbers `(n + i, n)` and their difference `i`, and for every pair of natural numbers `(m, m + i + 1)` and the negative of the successor of `i`, then it must also hold for the pair `(m, n)` and their difference as computed by `Int.subNatNat`. Essentially, this theorem asserts that if we can prove certain facts about differences of natural numbers and their negatives, we can generalize these facts to all natural numbers.

If for all natural numbers `i`, the property `motive` holds for `(n + i, n)` and `i`, and for `(m, m + i + 1)` and `-(i + 1)`, then `motive` holds for `(m, n)` and `Int.subNatNat m n`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.13 :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal},
      (d ≤ Set.einfsep s) = ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y :=
  by sorry

This theorem is about extended nonnegative real valued distances (edist) in a set `s` of some type `α` equipped with an extended distance function (`EDist`). The theorem states that for any extended nonnegative real number `d` and any set `s`, `d` is less than or equal to the extended infimum separation of `s` if and only if for all distinct elements `x` and `y` in `s`, `d` is less than or equal to the edist between `x` and `y`. The extended infimum separation of a set with respect to a distance function is the greatest lower bound of the separations among all pairs of distinct elements in the set, where separation `edist x y` is the extended distance between elements `x` and `y`.

For a set `s` in type `α` with an extended distance function `EDist`, a non-negative extended real number `d` is less than or equal to the extended infimum separation of `s` if and only if `d` is less than or equal to the extended distance between every distinct pair of elements in `s`.


theorem lt_add_of_pos_left :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α},
      0 < b → a < b + a :=
  by sorry

The theorem `lt_add_of_pos_left` states that for any type `α` that has an addition operation, a zero element, and an order relation, and such that addition is covariant (namely, if `x < y` then `x + z < y + z`), if `b` is a positive element of type `α` (more precisely, `0 < b`), then `a` is less than `b + a`. In other words, if `b` is positive, then adding `b` to `a` results in a value that is greater than `a`.

For any type `α` with addition, zero, and order relations where addition is covariant, if `0 < b` then `a < b + a`.


theorem PosNum.add_to_nat : ∀ (m n : PosNum), ↑(m + n) = ↑m + ↑n := by sorry

This theorem states that for all positive numbers `m` and `n`, the natural number representation of the sum of `m` and `n` is equal to the sum of the natural number representations of `m` and `n`. In mathematical terms, given any two positive numbers `m` and `n`, the operation of addition in the domain of positive numbers and its corresponding operation in the domain of natural numbers are preserved under the embedding from positive numbers to natural numbers.

For all positive numbers m and n, the natural number representation of m + n equals the sum of the natural number representations of m and n.


theorem or_iff_left_of_imp : ∀ {b a : Prop}, (b → a) → (a ∨ b ↔ a) := by sorry

This theorem, `or_iff_left_of_imp`, states that for any two propositions `a` and `b`, if it is the case that `b` implies `a` (`b → a`), then the proposition `a ∨ b` is equivalent to `a` (`a ∨ b ↔ a`). In other words, if `b` being true necessarily means `a` is true, then `a` being true or `b` being true is the same as just `a` being true.

If `b` implies `a`, then `a` is logically equivalent to `a` or `b`. (`(b → a)` implies `(a ↔ a ∨ b)`)


theorem Nat.modEq_iff_dvd : ∀ {n a b : ℕ}, a ≡ b [MOD n] ↔ ↑n ∣ ↑b - ↑a := by sorry

This theorem, `Nat.modEq_iff_dvd`, states that for any three natural numbers `n`, `a`, and `b`, `a` is congruent to `b` modulo `n` if and only if `n` divides the difference `b - a`. In other words, if the remainder of `b` when divided by `n` is the same as the remainder of `a` when divided by `n`, then `n` must divide `b - a`. This links the concept of modulo equivalence with the concept of divisibility.

For natural numbers n, a, and b, a is congruent to b modulo n if and only if n divides b - a.


theorem sdiff_bot : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, a \ ⊥ = a := by sorry

This theorem, `sdiff_bot`, states that for any type `α` that forms a Generalized Coheyting Algebra, the set difference of any element `a` and the bottom element (denoted as ⊥) is equal to `a` itself. In the context of set theory, this is akin to saying that subtracting the empty set from any set results in the original set.

For any type `α` forming a Generalized Cohen algebra in Lean 4, `a \ ⊥ = a` for all `a : α`.


theorem Cardinal.lift_ofENat : ∀ (m : ℕ∞), Cardinal.lift.{u, v} ↑m = ↑m := by sorry

The theorem `Cardinal.lift_ofENat` states that for any extended natural number `m` (denoted as `ℕ∞`), lifting its cardinality from universe `v` to universe `max v u` doesn't change the cardinality. In other words, the cardinality remains invariant under the universe lift operation. This means that the size of the set represented by `m` is the same in both universes `v` and `max v u`.

The cardinality of an extended natural number is invariant under universe lift operations.


theorem HomologicalComplex.isZero_single_obj_X :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      (j : ι) (A : V) (i : ι), i ≠ j → CategoryTheory.Limits.IsZero (((HomologicalComplex.single V c j).obj A).X i) :=
  by sorry

This theorem states that for any category `V` with zero morphisms and a zero object, given a `ComplexShape` `c` and objects `j` and `A` of type `ι` and `V` respectively, and another object `i` of type `ι`, if `i` is not equal to `j`, then the object at position `i` of the homological complex obtained by applying the functor `HomologicalComplex.single V c j` to `A` is a zero object in the category. In other words, all objects at positions different from `j` in this homological complex are zero objects.

For any category with zero morphisms and a zero object, the homological complex obtained from a `ComplexShape` and an object `A` via `HomologicalComplex.single` has all positions except for the one corresponding to a given object `j` as zero objects.


theorem CategoryTheory.Limits.limit.pre_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C]
      (F : CategoryTheory.Functor J C) [inst_3 : CategoryTheory.Limits.HasLimit F] (E : CategoryTheory.Functor K J)
      [inst_4 : CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.comp E F)] (k : K),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.pre F E)
          (CategoryTheory.Limits.limit.π (CategoryTheory.Functor.comp E F) k) =
        CategoryTheory.Limits.limit.π F (E.obj k) :=
  by sorry

The theorem `CategoryTheory.Limits.limit.pre_π` states that for any categories J, K, and C, and any functors F: J → C, E: K → J, when F has a limit and the composition of E and F also has a limit, then for any object k of K, the composition of the limit precomposition of F by E and the projection from the limit of the composition of E and F to the value at k, is equal to the projection from the limit of F to the value of E at k.

In other words, this theorem is saying that the limit precomposition of a functor followed by the limit projection can be "interchanged" with the limit projection of the original functor applied to the object of the secondary category. This is a key property in the study of limits in category theory.

Given functors F: J → C, E: K → J, if F has a limit and the composition E∘F has a limit, then for all objects k in K, the limit precomposition of F by E and the projection from the limit of E∘F to k are equal to the projection from the limit of F to E(k).


theorem lt_iff_not_ge : ∀ {α : Type u} [inst : LinearOrder α] (x y : α), x < y ↔ ¬x ≥ y := by sorry

The theorem `lt_iff_not_ge` states that for any type `α` with a linear order, for any two elements `x` and `y` from this type, `x` is less than `y` if and only if it is not the case that `x` is greater than or equal to `y`. In other words, it formalizes the intuitive notion that if `x` is not greater than or equal to `y`, then it must be less than `y`, and vice versa.

For any type with a linear order, x is less than y if and only if it is not the case that x is greater than or equal to y. (Or equivalently, x < y if and only if x >= y does not hold.)


theorem getElem?_pos :
    ∀ {Cont : Type u_1} {Idx : Type u_2} {Elem : Type u_3} {Dom : Cont → Idx → Prop} [inst : GetElem Cont Idx Elem Dom]
      (a : Cont) (i : Idx) (h : Dom a i) [inst_1 : Decidable (Dom a i)], a[i]? = some a[i] :=
  by sorry

The theorem `getElem?_pos` states that for any types `Cont`, `Idx`, and `Elem`, and any predicate `Dom` that describes a relationship between `Cont` and `Idx`, given an instance of `GetElem` typeclass for `Cont`, `Idx`, `Elem`, and `Dom`, and any elements `a` of `Cont` and `i` of `Idx` such that `Dom a i` holds, if `Dom a i` is decidable, then the optional retrieving of an element at index `i` from `a` using the `?` operator is equal to the definite retrieval of that element using the square bracket notation. In other words, if we know that an element exists at a certain index, the optional and definite retrieval methods give the same result.

Given types `Cont`, `Idx`, `Elem`, and a predicate `Dom`, if `Cont` has a `GetElem` instance, `Dom a i` is decidable, and `Dom a i` holds, then `getElem? a i = some (getElem a i)`.


theorem Filter.atTop_basis_Ioi :
    ∀ {α : Type u_3} [inst : Nonempty α] [inst : SemilatticeSup α] [inst_1 : NoMaxOrder α],
      Filter.HasBasis Filter.atTop (fun x => True) Set.Ioi :=
  by sorry

The theorem `Filter.atTop_basis_Ioi` states that for any type `α` which is nonempty, has a sup-semilattice structure, and has no maximum element, the filter `Filter.atTop` (representing the limit towards positive infinity) has a basis constructed by the collection of all sets of the form `Set.Ioi x` (the open interval from `x` to positive infinity) for all `x` in `α`. In essence, this means that 'going to infinity' in this ordered set can be characterized by 'passing all elements' of the set.

For a nonempty, sup-semilatticed, and boundless type `α`, `Filter.atTop` has a basis consisting of all open intervals `( Set.Ioi x : α)`.


theorem CategoryTheory.dite_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : Prop} [inst_1 : Decidable P] {X Y Z : C}
      (f : P → (X ⟶ Y)) (f' : ¬P → (X ⟶ Y)) (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (if h : P then f h else f' h) g =
        if h : P then CategoryTheory.CategoryStruct.comp (f h) g else CategoryTheory.CategoryStruct.comp (f' h) g :=
  by sorry

The theorem `CategoryTheory.dite_comp` states that for any type `C` equipped with a category structure, and for any propositions `P` with a decidable instance, and for any objects `X`, `Y`, and `Z` in `C`, if we have two morphisms `f` and `f'` from `X` to `Y` that depend on whether `P` is true or not, and a morphism `g` from `Y` to `Z`, then the composition of the conditional morphism from `X` to `Y` with `g` is the same as the conditional composition of `f` or `f'` with `g`. That is, we can either first decide whether `P` is true or not and then compose, or first compose and then decide, and we get the same result either way.

For any category `C`, propositions `P` with a decidable instance, and objects `X`, `Y`, `Z` in `C`, given morphisms `f`, `f' : X -> Y` and `g : Y -> Z`, if `P.decide` determines whether `P` holds and `g . (if P then f else f') = (if P then (f . g) else (f' . g))`, then `C` is a category with a decidable intersection type.


/-- If the angle between two vectors is `π / 2`, the first vector is nonzero.  -/
theorem Orientation.left_ne_zero_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y = ↑(Real.pi / 2) → x ≠ 0 :=
  by sorry

The theorem `Orientation.left_ne_zero_of_oangle_eq_pi_div_two` asserts that in a real inner product space `V` of finite dimension equal to 2, for any orientation `o` and two vectors `x` and `y`, if the oriented angle from `x` to `y` is `π / 2`, then the vector `x` must be nonzero. This essentially captures the geometric intuition that if two vectors are orthogonal (i.e., the angle between them is 90 degrees), then neither of them can be the zero vector.

In a 2-dimensional real inner product space, if the oriented angle between non-zero vectors `x` and `y` is equal to `π/2`, then their difference `x - y` is a non-zero vector.


/-- Given a basis `v` indexed by `ι`, the canonical linear equivalence between `ι → R` and `M` maps
a function `x : ι → R` to the linear combination `∑_i x i • v i`.  -/
theorem Basis.equivFun_symm_apply :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Fintype ι] (b : Basis ι R M) (x : ι → R),
      (LinearEquiv.symm (Basis.equivFun b)) x = Finset.sum Finset.univ fun i => x i • b i :=
  by sorry

The theorem `Basis.equivFun_symm_apply` states that for any set `ι`, semiring `R`, and additively commutative monoid `M` with a `R`-module structure, given a basis `v` indexed by `ι`, the inverse of the canonical linear equivalence between the function space `ι → R` and `M` maps a function `x : ι → R` to the linear combination of the basis vectors, where each vector `v i` is scaled by `x i`. This linear combination is represented as the sum over all elements `i` in the universal set of `ι`, of the product of `x i` and `v i`.
In mathematical notation, this might be written as:
\( (Basis.equivFun^{-1} b)(x) = \sum_{i \in univ} x(i) \cdot v(i) \).

The theorem `Basis.equivFun_symm_apply` asserts that the inverse of the linear equivalence between a basis and the function space with respect to a set, semiring, additively commutative monoid, and `R`-module structure, maps a function `x` to the sum over its index set of the product of `x(i)` and the corresponding basis vector `v(i)`.


theorem MeasureTheory.AEEqFun.mk_eq_mk :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] {f g : α → β} {hf : MeasureTheory.AEStronglyMeasurable f μ}
      {hg : MeasureTheory.AEStronglyMeasurable g μ},
      MeasureTheory.AEEqFun.mk f hf = MeasureTheory.AEEqFun.mk g hg ↔ f =ᶠ[MeasureTheory.Measure.ae μ] g :=
  by sorry

The theorem `MeasureTheory.AEEqFun.mk_eq_mk` states that for any given types `α` and `β`, where `α` is a measurable space and `β` is a topological space, and for any given measure `μ` on `α`, if `f` and `g` are two functions from `α` to `β` that are almost everywhere strongly measurable with respect to `μ`, then the equivalence classes of `f` and `g` (constructed via `MeasureTheory.AEEqFun.mk`) are equal if and only if `f` and `g` are almost everywhere equal with respect to the measure `μ`. This is to say, two functions are considered equivalent in this context if they are equal except on a set of measure zero.

For measurable spaces `α` and topological spaces `β`, given a measure `μ` on `α` and almost everywhere strongly measurable functions `f` and `g` from `α` to `β`, `MeasureTheory.AEEqFun.mk_eq_mk` theorem states that `f` and `g` have equal equivalence classes if and only if they are almost everywhere equal with respect to `μ`.


theorem Multiset.inter_le_right : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∩ t ≤ t := by sorry

The theorem `Multiset.inter_le_right` states that for any type `α` which has decidable equality (i.e., for any two elements `a` and `b` of type `α`, it is possible to decide whether `a = b`), and for any two multisets `s` and `t` of type `α`, the intersection of `s` and `t` is a sub-multiset of `t`. In other words, all elements of the intersection of `s` and `t` are also elements of `t`. This fits the intuitive understanding of intersection from set theory.

For any decidably equal types `α` and any multisets `s` and `t` of type `α`, the intersection of `s` and `t` is a sub-multiset of `t`.


theorem completeSpace_iff_isComplete_range :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformInducing f → (CompleteSpace α ↔ IsComplete (Set.range f)) :=
  by sorry

This theorem establishes an equivalence for the completeness of a space in the context of uniform spaces and uniform inducing functions. Specifically, for any two types `α` and `β` that have uniform space structures, and a function `f` from `α` to `β` that induces a uniform space structure on `β`, the theorem states that `α` being a complete space is equivalent to the range of `f` being complete. In terms of mathematics, completeness here refers to the property that every Cauchy filter in the space has a limit within the space.

For uniform spaces `α` and `β`, and a uniformly continuous function `f: α → β`, the space `α` is complete if and only if the range `f("α")` is complete.


theorem RingQuot.smul_quot :
    ∀ {R : Type uR} [inst : Semiring R] {S : Type uS} [inst_1 : CommSemiring S] (r : R → R → Prop)
      [inst_2 : Algebra S R] {n : S} {a : R},
      n • { toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (n • a) } :=
  by sorry

This theorem states that for any semiring `R`, commutative semiring `S`, relation `r` on `R`, S-algebra structure on `R`, element `n` in `S`, and element `a` in `R`, the result of scalar multiplication of `n` with the equivalence class of `a` (represented as `{ toQuot := Quot.mk (RingQuot.Rel r) a }`) under the ring quotient by `r` is the equivalence class of the result of scalar multiplication of `n` with `a` (represented as `{ toQuot := Quot.mk (RingQuot.Rel r) (n • a) }`). In simpler terms, scalar multiplication in `S` commutes with taking ring quotients in `R`.

For any commutative semiring `S`, semiring `R`, relation `r` on `R`, S-algebra structure on `R`, element `n` in `S`, and element `a` in `R`, the equivalence classes of `n • a` and `n` times the equivalence class of `a` under the ring quotient by `r` are equal.


theorem Nat.min_eq_right : ∀ {a b : ℕ}, b ≤ a → min a b = b := by sorry

This is a theorem about the minimum operation on natural numbers in Lean 4. It states that for any pair of natural numbers `a` and `b`, if `b` is less than or equal to `a`, then the minimum of `a` and `b` is `b`. This corresponds to the intuitive rule from mathematics that if one number is less than or equal to another, then the smaller number is the minimum of the two.

For all natural numbers `a` and `b`, if `b` ≤ `a`, then `min a b` = `b`.


theorem zsmul_strictMono_left :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] {a : α}, 0 < a → StrictMono fun n => n • a := by sorry

This theorem states that for any type `α` that forms an ordered additively commutative group, and a positive element `a` of this type, the function that maps any integer `n` to the result of "scaling" `a` by `n` (denoted as `n • a`) is strictly monotone. In mathematical terms, this means that for any two integers `n` and `m` with `n < m`, we have `n • a < m • a` whenever `a` is a positive element of an ordered additively commutative group.

For any positive element `a` in an ordered additively commutative group `α`, the function `n => n • a` is strictly increasing.


theorem Nat.not_prime_zero : ¬Nat.Prime 0 := by sorry

The theorem `Nat.not_prime_zero` states that zero is not a prime number. In other words, it asserts that the natural number zero does not satisfy the prime number property, where a prime number is defined as a natural number that is at least 2 and its only divisors are itself and 1.

Zero is not a prime number in the natural numbers.


theorem MeasureTheory.monotone_spanningSets :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ],
      Monotone (MeasureTheory.spanningSets μ) :=
  by sorry

The theorem `MeasureTheory.monotone_spanningSets` states that for any measurable space `α` and any sigma-finite measure `μ` on that space, the function `MeasureTheory.spanningSets μ` is monotone. In other words, if `i ≤ j` for two natural numbers `i` and `j`, then the set spanned by the sigma-finite measure `μ` up to the `i`-th step is a subset of or equal to the set spanned by the sigma-finite measure `μ` up to the `j`-th step. This is important because it guarantees that as we consider more steps in the construction of our spanning sets, we only ever add to our sets and never remove from them.

For any measurable space and sigma-finite measure, the sequence of sets obtained by successively increasing the steps in the construction of their spanning sets forms a monotonic sequence.


theorem Mathlib.Order.LocallyFinite._auxLemma.5 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a x : α}, (x ∈ Finset.Ici a) = (a ≤ x) :=
  by sorry

This theorem states that for any type `α` which has a preorder and a locally finite order top, and for any elements `a` and `x` of this type, `x` is in the finset `Ici a` (which represents the set of elements greater than or equal to `a`) if and only if `a` is less than or equal to `x`. In mathematical terms, this is saying that $x \in [a, \infty)$ if and only if $a \leq x$.

For any type `α` with a preorder and locally finite order topology, `x` is in the interval `[a, ∞)` if and only if `a` is less than or equal to `x`.


theorem Polynomial.map_nat_cast :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : ℕ),
      Polynomial.map f ↑n = ↑n :=
  by sorry

The theorem `Polynomial.map_nat_cast` states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, and any natural number `n`, the operation of mapping the polynomial representation of `n` in `R` across the ring homomorphism `f` equals to the polynomial representation of `n` in `S`. In other words, the polynomial map of the casted natural number `n` using `f` is the same as directly casting `n` in the codomain of `f`.

For any semirings R and S, ring homomorphism f from R to S, and natural number n, the image of the polynomial representation of n in R under f is equal to the polynomial representation of n in S.


theorem Nat.one_lt_succ_succ : ∀ (n : ℕ), 1 < Nat.succ (Nat.succ n) := by sorry

This theorem states that for any natural number `n`, the number 1 is less than the successor (or the next number) of the successor of `n`. In mathematical terms, this theorem asserts that 1 < n + 2 for all natural numbers `n`.

For all natural numbers `n`, the number 1 is less than the successor of `n`, or equivalently, `1 < n + 2`.


theorem CategoryTheory.ShortComplex.leftHomologyMap'_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
      (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁) (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂)
      (h₃ : CategoryTheory.ShortComplex.LeftHomologyData S₃),
      CategoryTheory.ShortComplex.leftHomologyMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.leftHomologyMap' φ₂ h₂ h₃) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftHomologyMap'_comp` states that for any category `C` which has zero morphisms, and for any three short complexes `S₁`, `S₂`, and `S₃` in `C`, with left homology data `h₁`, `h₂`, and `h₃` respectively, the composition of two morphisms `φ₁` and `φ₂` (from `S₁` to `S₂` and `S₂` to `S₃`, respectively) via the `leftHomologyMap'` function is equal to the composition of the `leftHomologyMap'` of `φ₁` and `h₁` to `h₂`, and the `leftHomologyMap'` of `φ₂` and `h₂` to `h₃`. This is essentially a statement about the compatibility of the `leftHomologyMap'` function with the composition of morphisms in the category, following the mathematics principle of associativity.

For any short complexes $S\_1, S\_2, S\_3$ in a category $C$ with zero morphisms and left homology data $h\_1, h\_2, h\_3$, the diagram $(h\_1 \circ \varphi\_1) \circ \varphi\_2 = \varphi\_1 \circ h\_2 \circ \varphi\_2$ commutes, where $\varphi\_1 : S\_1 \to S\_2$ and $\varphi\_2 : S\_2 \to S\_3$ are morphisms and $h\_i = \mathrm{leftHomologyMap}'(S\_i)$ for $i = 1, 2, 3$.


theorem Polynomial.splits_map_iff :
    ∀ {F : Type u} {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] [inst_2 : Field F] (i : K →+* L)
      (j : L →+* F) {f : Polynomial K},
      Polynomial.Splits j (Polynomial.map i f) ↔ Polynomial.Splits (RingHom.comp j i) f :=
  by sorry

This theorem states that for any given polynomial `f` over a commutative ring `K`, and ring homomorphisms `i` from `K` to a field `L` and `j` from `L` to a field `F`, the polynomial `f` splits over `F` via the map `j` composed with `i` if and only if the polynomial `f` mapped from `K` to `L` via `i`, splits over `F` via `j`. In other words, whether a polynomial splits does not depend on the order in which the ring homomorphisms are applied.

For any polynomial `f` over a commutative ring `K` and ring homomorphisms `i : K -> L` to a field `L` and `j : L -> F` to a field `F`, if `f` splits over `F` via `j` composed with `i`, then `f` also splits over `F` via `i` composed with `j`. Conversely, if `f` splits over `F` via `i` composed with `j`, then it splits over `F` via `j` composed with `i`. Thus, the splitting of a polynomial over a field is independent of the order of the homomorphisms.


theorem Set.Ioo_subset_Ioo :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α}, a₂ ≤ a₁ → b₁ ≤ b₂ → Set.Ioo a₁ b₁ ⊆ Set.Ioo a₂ b₂ := by
  sorry

The theorem `Set.Ioo_subset_Ioo` states that for any type `α` with a preorder, and any four elements `a₁, a₂, b₁, b₂` of `α`, if `a₂` is less than or equal to `a₁`, and `b₁` is less than or equal to `b₂`, then the left-open right-open interval from `a₁` to `b₁` is a subset of the left-open right-open interval from `a₂` to `b₂`. In other words, if we have two intervals (a₁, b₁) and (a₂, b₂), and the left endpoint a₂ of the second interval is less than or equal to the left endpoint a₁ of the first interval, and the right endpoint b₁ of the first interval is less than or equal to the right endpoint b₂ of the second interval, then all the elements of the first interval are also elements of the second interval.

For any type `α` with a preorder, and for any `a₁ ≤ a₂` and `b₁ ≤ b₂` in `α`, the interval `(a₁, b₁)` is a subset of `(a₂, b₂)`.


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

The theorem `Set.biUnion_preimage_singleton` states that for all types `α` and `β`, and for all functions `f` from `α` to `β` and all sets `s` of type `β`, the union over all `y` in `s` of the preimage of the singleton set `{y}` under `f` is equal to the preimage of the set `s` under `f`. In simpler terms, if we take each individual element of a set, map it back through the function `f`, and take the union of all these mapped sets, we get the same result as if we had just taken the preimage of the entire set at once.

For all types `α` and `β`, and for all functions `f` from `α` to `β` and sets `s` of type `β`, the preimage of `s` under `f` is equal to the union of the preimages of the singleton sets `{y}` for all `y` in `s`.


theorem toIcoMod_mem_Ico :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      toIcoMod hp a b ∈ Set.Ico a (a + p) :=
  by sorry

The theorem `toIcoMod_mem_Ico` states that for all types `α` that are instances of a linear ordered additive commutative group and an Archimedean field, and for any positive `p` (`0 < p`) and any two values `a` and `b` of type `α`, the result of the function `toIcoMod` applied to `hp` (the proof that `p` is positive), `a`, and `b` belongs to the set of values `x` which satisfy the condition `a ≤ x < a + p`. In other words, the theorem confirms that the `toIcoMod` function always maps `b` to a value that lies in the half-open interval from `a` (inclusive) to `a + p` (exclusive).

For all Archimedean additive commutative groups α and positive p, the result of the `toIcoMod` function applied to p and any a in α is an element of the half-open interval [a, a + p).


Filter.EventuallyEq.mul

theorem Filter.EventuallyEq.mul :
    ∀ {α : Type u} {β : Type v} [inst : Mul β] {f f' g g' : α → β} {l : Filter α},
      f =ᶠ[l] g → f' =ᶠ[l] g' → (fun x => f x * f' x) =ᶠ[l] fun x => g x * g' x :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is a multiplicative structure, given any four functions `f`, `f'`, `g`, and `g'` from `α` to `β` and a filter `l` on `α`, if `f` is eventually equal to `g` at filter `l` and `f'` is eventually equal to `g'` at the same filter `l`, then the function that takes `x` to `f(x) * f'(x)` is eventually equal to the function that takes `x` to `g(x) * g'(x)` at filter `l`. In other words, eventual equality of functions respects multiplication under a filter.

For any types `α` and `β` (where `β` is a multiplicative structure), given functions `f, f', g, g': α -> β`, and a filter `l` on `α`, if `f` is eventually equal to `g` at `l` and `f'` is eventually equal to `g'` at `l`, then `x ∈ l` implies `f(x) * f'(x) = g(x) * g'(x)`.


theorem Real.sin_pi : Real.sin Real.pi = 0 := by sorry

The theorem `Real.sin_pi` asserts that the sine of π (Pi), as defined in the real numbers, is equal to zero. This is a commonly known fact in trigonometry, which states that sin(π) = 0. Here, π is defined as twice a zero of cosine in the interval [1,2]. The sine function is defined as the real part of the complex sine.

The theorem `Real.sin_pi` asserts that the real part of the complex sine of π (Pi), defined as twice a zero of cosine in the interval [1,2], equals zero.


/-- An element is contained in the separable closure of `F` in `E` if and only if
it is a separable element.  -/
theorem mem_separableClosure_iff :
    ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
      x ∈ separableClosure F E ↔ Polynomial.Separable (minpoly F x) :=
  by sorry

This theorem states that for any fields `F` and `E` and for any element `x` from `E`, `x` is contained in the separable closure of `F` in `E` if and only if the minimal polynomial of `x` over `F` is a separable polynomial. Here, a polynomial is defined as separable if it is coprime with its derivative in the commutative semiring `R`.

A field element `x` is in the separable closure of field `F` in `E` if and only if the minimal polynomial of `x` over `F` is separable.


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

The theorem `Seminorm.mem_ball` states that for any seminormed ring `𝕜`, any additive commutative group `E` and any scalar multiplication of `𝕜` and `E`, with a given seminorm `p` on `E`, an element `y` of `E`, a center `x` in `E`, and a radius `r` in real numbers, `y` is in the ball of radius `r` at `x` with respect to seminorm `p` if and only if the seminorm of the difference between `y` and `x` is less than `r`. In other words, it characterizes the elements of a ball in a seminorm space.

For any seminormed ring 𝕜, additive commutative group E, and scalar multiplication, an element y of E belongs to the ball of radius r at x in the seminormed space (E, p) if and only if p(y - x) < r.


theorem Group.subset_closure : ∀ {G : Type u_1} [inst : Group G] {s : Set G}, s ⊆ Group.closure s := by sorry

The theorem `Group.subset_closure` asserts that for any given group `G` and a set `s` of elements of `G`, the set `s` is a subset of the closure of `s` in `G`. In other words, every element of `s` is contained in the subgroup generated by `s`. This is a fundamental property of the closure of a set in a group, that is, the smallest subgroup of `G` that contains the set `s`.

For any group (G : Type*) and set (s : Set G), s is a subset of the closure of s in G, i.e., every element of s is contained in the subgroup generated by s.


Differentiable.comp

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

The theorem `Differentiable.comp` states that given any Nontrivially Normed Field `𝕜` and three Normed Spaces `E`, `F`, and `G`, if a function `f` from `E` to `F` is differentiable at every point and a function `g` from `F` to `G` is also differentiable at every point, then the composition of `g` and `f` (i.e., `g ∘ f`) is differentiable at every point as well. In other words, the composition of two differentiable functions is also differentiable.

Given any Nontrivially Normed Field 𝕜 and Normed Spaces E, F, and G, if functions f : E → F and g : F → G are differentiable at every point, then their composition g ∘ f is differentiable at every point.


theorem CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_inv :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso hc
              (CategoryTheory.Limits.colimit.isColimit F)).inv =
        c.ι.app j :=
  by sorry

This is a theorem in the field of category theory, specifically dealing with limits and colimits in a category. The theorem states that for any category `J`, any category `C`, any functor `F` from `J` to `C`, and any `j` in `J`, if `c` is a cocone over `F` and `hc` proves that `c` is a colimit cocone, then the composition of the coprojection from the `j`-th object of `F` to the colimit of `F` with the inverse of the isomorphism from the vertex of `c` to the colimit of `F` is the same as the `j`-th component of `c`. In simpler terms, it essentially says that composing the morphism `colimit.ι F j` with a certain inverse isomorphism gives us the same result as directly applying the `j`-th component of `c`. This is a property that must hold for all such categories, functors, and cocones.

For any category `J`, any category `C`, any functor `F` from `J` to `C`, and any cocone `c` over `F` with verified colimit property, the composition of `F j` with the inverse of the vertex-to-colimit isomorphism is equal to the `j`-th component of `c` for all objects `j` in `J`.


theorem Equiv.Perm.sum_cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (σ : Equiv.Perm α),
      Multiset.sum (Equiv.Perm.cycleType σ) = (Equiv.Perm.support σ).card :=
  by sorry

This theorem states that for any finite type `α` with decidable equality and any permutation `σ` of this type, the sum of the cycle type of the permutation (which is a multiset of natural numbers representing the lengths of the cycles in the permutation) is equal to the cardinality of the set of non-fixed points (elements that are not mapped to themselves) of the permutation. In other words, if you break a permutation down into its cycles, sum the lengths of those cycles, and compare this sum to the total number of elements in the permutation that are moved, these two numbers will always be equal.

For any finite type with decidable equality, the sum of the cycle lengths of a permutation equals the number of its non-fixed points.


theorem Mathlib.Order.WithBot._auxLemma.15 : ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True := by sorry

This theorem, named `Mathlib.Order.WithBot._auxLemma.15`, states that for any type `α` that has a less-than relation (`LT`), and for any element `a` of this type, the statement "the bottom element is less than the co-domain of `a`" always holds true. Here, `⊥` denotes the bottom element, and `↑a` refers to the co-domain of `a`. The theorem essentially establishes that any value in the type `α` is always greater than the bottom element, within the context of ordered types.

For any type `α` with a less-than relation and any element `a` in `α`, the bottom element `⊥` is less than the co-domain `↑a` of `a`. (Or equivalently, every element `a` in `α` is greater than the bottom element `⊥` in the order `LT`.)


/-- If the angle between two vectors is `π / 2`, the second vector is nonzero.  -/
theorem Orientation.right_ne_zero_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y = ↑(Real.pi / 2) → y ≠ 0 :=
  by sorry

The theorem `Orientation.right_ne_zero_of_oangle_eq_pi_div_two` states that in a real 2-dimensional inner product space, if the oriented angle from a vector `x` to another vector `y` is equal to `π / 2` radians, then the second vector `y` cannot be the zero vector. The orientation of the space is given by `o`, and the theorem assures that if `y` forms a right angle (i.e., a `90°` or `π/2` radian angle) with `x`, then `y` must be non-zero.

In a real 2-dimensional inner product space, if the oriented angle between non-zero vectors x and y is equal to π/2, then y is neither a scalar multiple nor the zero vector of x.


theorem right_iff_left_not_left :
    ∀ {α : Type u} {r s : α → α → Prop} [inst : IsNonstrictStrictOrder α r s] {a b : α}, s a b ↔ r a b ∧ ¬r b a := by
  sorry

This theorem named `right_iff_left_not_left` states that for any type `α` and any two relations `r` and `s` on `α`, assuming that `r` and `s` form a nonstrict strict order, for any two elements `a` and `b` of type `α`, `s a b` is true if and only if `r a b` is true and `r b a` is not true. In other words, this theorem provides a characterization of the relation `s` in terms of the relation `r` under the assumption that `r` and `s` form a certain kind of ordered pair.

For any type `α` and relations `r` and `s` on `α` forming a nonstrict strict order, `s a b` if and only if `r a b` and not `r b a`.


theorem Polynomial.map_ne_zero :
    ∀ {R : Type u} {S : Type v} [inst : DivisionRing R] {p : Polynomial R} [inst_1 : Semiring S] [inst_2 : Nontrivial S]
      {f : R →+* S}, p ≠ 0 → Polynomial.map f p ≠ 0 :=
  by sorry

The theorem `Polynomial.map_ne_zero` states that for any types `R` and `S`, given a division ring over `R`, a polynomial `p` in `R`, a semiring over `S`, and a nontrivial ring homomorphism `f` from `R` to `S`, if the polynomial `p` is not equal to zero, then the mapped polynomial (obtained by mapping `p` across the ring hom `f`) is also not equal to zero. In other words, non-zero polynomials remain non-zero under nontrivial ring homomorphisms.

If `f` is a nontrivial ring homomorphism from a division ring `R` to a semiring `S`, and `p` is a non-zero polynomial in `R`, then the mapped polynomial `f(p)` is also a non-zero polynomial in `S`.


theorem Mathlib.Data.Finset.Basic._auxLemma.9 : ∀ {α : Type u_1} (s : Finset α), (s ⊆ s) = True := by sorry

This theorem states that for any type `α` and any finite set `s` of that type (`Finset α`), the set `s` is a subset of itself (`s ⊆ s`). This is always true, hence the theorem asserts this statement equals `True`. This is a reflection of the fundamental property of sets in mathematics where every set is considered a subset of itself.

For any type `α` and finite set `s` of that type (`Finset α`), `s` is a subset of itself (`s ⊆ s`).


theorem Nat.lt_floor_add_one :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] (a : α), a < ↑⌊a⌋₊ + 1 := by sorry

This theorem states that for any given element `a` from a certain type `α` (where `α` is a linearly ordered semiring with a floor semiring structure), `a` is less than the floor of `a` (denoted as `⌊a⌋₊`) incremented by one. This is a common property of floor functions that round down to the nearest integer.

For any element `a` in a linearly ordered semiring `α` with a floor semiring structure, `⌊a⌋ + 1 <= a`.


Filter.EventuallyEq.sub

theorem Filter.EventuallyEq.sub :
    ∀ {α : Type u} {β : Type v} [inst : Sub β] {f f' g g' : α → β} {l : Filter α},
      f =ᶠ[l] g → f' =ᶠ[l] g' → (fun x => f x - f' x) =ᶠ[l] fun x => g x - g' x :=
  by sorry

This theorem is stating that for any types `α` and `β`, given a Subtraction instance for `β`, and functions `f`, `f'`, `g`, and `g'` from `α` to `β`, along with a filter `l` on `α`, if `f` eventually equals `g` at the filter `l` and `f'` eventually equals `g'` at the same filter, then the function that subtracts `f'` from `f` will eventually equal the function that subtracts `g'` from `g` at that filter. In shorthand, if `f ≈ g` and `f' ≈ g'` at some point according to a filter, then `(f - f') ≈ (g - g')` according to the same filter.

For types `α` and `β` with Subtraction instances, if functions `f, f', g, g' : α → β` satisfy `f ≈ g` and `f' ≈ g'` at some filter `l` on `α`, then `(f - f') ≈ (g - g')` at filter `l`.


theorem NNReal.continuous_coe : Continuous NNReal.toReal := by sorry

This theorem states that the function `NNReal.toReal`, which coerces non-negative real numbers (`ℝ≥0`) to real numbers (`ℝ`), is continuous. In terms of mathematical language, this means that for every real number `r`, if we consider a sequence of non-negative real numbers that converges to `r`, then the corresponding sequence of coerced values in `ℝ` also converges to `r`.

The function `NNReal.toReal` is continuous from the ordered field of non-negative real numbers to the real numbers.


theorem lim_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {f : Filter X} {x : X} [inst_2 : Filter.NeBot f],
      f ≤ nhds x → lim f = x :=
  by sorry

The theorem `lim_eq` is stating that for any topological space `X` which is also a `T2Space`, or in more common terms, a Hausdorff space, given a filter `f` on `X` that is not the bottom filter (`Filter.NeBot f`), if `f` is a subset of the neighbourhood filter of some element `x` in `X` (expressed as `f ≤ nhds x`), then the limit of the filter `f` must be the element `x` itself. In simpler terms, this theorem is saying that in a Hausdorff space, if a filter converges to some point, then the limit of the filter is indeed that point.

In a Hausdorff space, if a filter converges to an element, then the limit of the filter is that element.


theorem PMF.tsum_coe : ∀ {α : Type u_1} (p : PMF α), ∑' (a : α), p a = 1 := by sorry

The theorem `PMF.tsum_coe` states that for any given probability mass function `p` defined over a type `α`, the sum of probabilities assigned by `p` to all elements of `α` equals to `1`. This is essentially the property of a probability mass function being a probability measure on a discrete set, where the total probability assigned to the entire set is `1`.

For any probability mass function `p` over type `α`, the sum of `p` over all elements of `α` equals 1. In Lean syntax: `∑ (x : α), p x = 1`.


theorem RelIso.toEquiv_injective :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop}, Function.Injective RelIso.toEquiv := by sorry

The theorem `RelIso.toEquiv_injective` states that, for any types `α` and `β`, and any binary relations `r` on `α` and `s` on `β`, the function `RelIso.toEquiv` is injective. In other words, if we have two relations that are isomorphic (denoted as `r ≃r s`), and the isomorphisms are converted to equivalences between the original types using `RelIso.toEquiv`, then distinct isomorphisms will produce distinct equivalences. This means that if two equivalences are equal, they must have originated from the same relational isomorphism.

If two binary relations `r` and `s` on types `α` and `β` are isomorphic, then the corresponding equivalences `RelIso.toEquiv r` and `RelIso.toEquiv s` are equal.


Subsemiring.ext

/-- Two subsemirings are equal if they have the same elements.  -/
theorem Subsemiring.ext :
    ∀ {R : Type u} [inst : NonAssocSemiring R] {S T : Subsemiring R}, (∀ (x : R), x ∈ S ↔ x ∈ T) → S = T := by sorry

This theorem states that two subsemirings `S` and `T` of a non-associative semiring `R` are equal if they possess the same elements. In other words, if every element `x` in `R` that is in subsemiring `S` is also in subsemiring `T` and vice versa, then the subsemirings `S` and `T` are indeed the same.

If two subsemirings `S` and `T` of a non-associative semiring `R` have the same elements, then `S = T`.


theorem minpoly.algHom_eq :
    ∀ {A : Type u_1} {B : Type u_2} {B' : Type u_3} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Ring B']
      [inst_3 : Algebra A B] [inst_4 : Algebra A B'] (f : B →ₐ[A] B'),
      Function.Injective ⇑f → ∀ (x : B), minpoly A (f x) = minpoly A x :=
  by sorry

The theorem `minpoly.algHom_eq` states that for any types `A`, `B`, and `B'`, where `A` is a commutative ring, `B` and `B'` are rings, and algebra structures exist from `A` to `B` and `A` to `B'`, and for any algebra homomorphism `f` from `B` to `B'` over `A`, if the homomorphism `f` is injective, then for all `x` in `B`, the minimal polynomial of `f(x)` over `A` is the same as the minimal polynomial of `x` over `A`. In other words, an injective algebra homomorphism does not change the minimal polynomial of an element in the domain ring when we view these polynomials over a common commutative ring.

If `f` is an injective algebra homomorphism from `B` to `B'` over a commutative ring `A`, then for all `x` in `B`, the minimal polynomial of `f(x)` over `A` equals the minimal polynomial of `x` over `A`.


theorem eq_iff_le_not_lt : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a = b ↔ a ≤ b ∧ ¬a < b := by sorry

This theorem states that for any two elements `a` and `b` of a type `α` that has a partial order, `a` is equal to `b` if and only if `a` is less than or equal to `b` and it is not the case that `a` is less than `b`. This essentially captures the notion of equality in a partial order, where `a` and `b` being equal means that neither is strictly greater than the other, but they can be equal or less than each other.

In a partial order, two elements are equal if and only if they are comparable and neither is strictly less than the other.


theorem Polynomial.coeff_divX :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      Polynomial.coeff (Polynomial.divX p) n = Polynomial.coeff p (n + 1) :=
  by sorry

This theorem, `Polynomial.coeff_divX`, states that for any semiring `R`, any natural number `n` and any polynomial `p` with coefficients in `R`, the coefficient of `X^n` in the polynomial obtained by dividing `p` by `X` (using the `Polynomial.divX` operation) is equal to the coefficient of `X^{n+1}` in the original polynomial `p`. In other words, dividing a polynomial by `X` shifts the coefficients to the lower degrees.

For any semiring R, natural number n, and polynomial p over R in X, the coefficient of X^(n+1) in the polynomial p obtained by dividing p by X is equal to the coefficient of X^n in the original polynomial p.


HasFPowerSeriesOnBall.hasFPowerSeriesAt

theorem HasFPowerSeriesOnBall.hasFPowerSeriesAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
      HasFPowerSeriesOnBall f p x r → HasFPowerSeriesAt f p x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed add commutative groups `E` and `F`, normed spaces over `𝕜` for `E` and `F`, a function `f` from `E` to `F`, a formal multilinear series `p`, and a point `x` in `E`, if `f` has a formal power series on a ball centered at `x` with radius `r` (which is an extended nonnegative real number, i.e., a real number in [0, ∞]), then `f` also has a formal power series at the point `x`.

In other words, having a formal power series on a ball implies having a formal power series at the center of that ball. The formal multilinear series `p` serves as the representation of the formal power series in this context.

If a function `f` from a normed additive group `E` to another normed additive group `F` over a nontrivially normed field `𝕜`, has a formal power series on a ball centered at a point `x` in `E`, then `f` has a formal power series at point `x`.


theorem Subtype.coe_image_subset : ∀ {α : Type u_1} (s : Set α) (t : Set ↑s), Subtype.val '' t ⊆ s := by sorry

The theorem `Subtype.coe_image_subset` states that for all types `α`, any set `s` of type `α`, and any set `t` of elements from the subtype derived from `s` (denoted as `↑s`), the image of `t` under the projection function `Subtype.val` (which sends each element of the subtype back to its underlying type `α`) is a subset of the original set `s`. In other words, when you take a subset of the subtype and apply `Subtype.val` to each element, you will only get elements that are in the original set `s`.

For any type `α`, set `s` of `α`, and subset `t` of the subtype `↑s`, the image of `t` under the projection function `Subtype.val` is contained in the original set `s`. In mathematical notation, `∀ α, ∀ s : set α, t ⊆ {x : α | x ∈ s} → {x : α | x ∈ s}`.


theorem Metric.closedBall_eq_empty :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.closedBall x ε = ∅ ↔ ε < 0 := by sorry

The theorem `Metric.closedBall_eq_empty` states that for any pseudometric space `α` and for any point `x` in `α` and real number `ε`, the closed ball centered at `x` with radius `ε` is empty if and only if `ε` is less than zero. In mathematical terms, it's saying that in a pseudometric space, a closed ball of negative radius doesn't contain any points.

In a pseudometric space, the closed ball centered at a point with a negative radius is empty.


/-- Two `AddMonoidHom`s from an additive quotient group are equal if
their compositions with `AddQuotientGroup.mk'` are equal.

See note [partially-applied ext lemmas].  -/
theorem QuotientAddGroup.addMonoidHom_ext :
    ∀ {G : Type u} [inst : AddGroup G] (N : AddSubgroup G) [nN : AddSubgroup.Normal N] {M : Type x}
      [inst_1 : AddMonoid M] ⦃f g : G ⧸ N →+ M⦄,
      AddMonoidHom.comp f (QuotientAddGroup.mk' N) = AddMonoidHom.comp g (QuotientAddGroup.mk' N) → f = g :=
  by sorry

This theorem states that for any type `G` with the structure of an additive group, a subgroup `N` of `G` that is normal, and any type `M` with the structure of an additive monoid, if two additive monoid homomorphisms `f` and `g` from the quotient group `G ⧸ N` to `M` have the property that their compositions with the function `QuotientAddGroup.mk' N` are equal, then `f` and `g` themselves must be equal. This means that if the homomorphisms `f` and `g` map elements from the same coset (i.e., the equivalence class of elements in `G` that differ by an element of `N`) to the same element in `M`, then `f` and `g` are the same homomorphism.

Given an additive group `G`, a normal subgroup `N`, and additive monoids `M`, if two additive group homomorphisms from `G / N` to `M` agree on the image of `QuotientAddGroup.mk' N`, then they are equal.


theorem Asymptotics.IsBigO.exists_nonneg :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
      {g' : α → F'} {l : Filter α}, f =O[l] g' → ∃ c ≥ 0, Asymptotics.IsBigOWith c l f g' :=
  by sorry

The theorem `Asymptotics.IsBigO.exists_nonneg` states that for any types `α`, `E`, and `F'`, given `f` and `g'` as functions from `α` to `E` and `F'` respectively, and a filter `l` on `α`, if `f` is Big O of `g'` with respect to `l` (denoted as `f =O[l] g'`), then there exists a nonnegative real number `c` such that `f` is Big O of `g'` with constant `c` and filter `l`. In other words, `f` is eventually bounded by `c * ‖g'‖` for some nonnegative `c`.

For any types `α`, `E`, and `F'`, given functions `f : α → E` and `g' : α → F'`, and a filter `l` on `α`, if `f` is Big O of `g'` with respect to `l`, then there exists a constant `c ≥ 0` such that `|f(x)| ≤ c * |g'(x)|` for all `x` in the filter `l`.


theorem Cardinal.ord_lt_ord : ∀ {c₁ c₂ : Cardinal.{u_3}}, Cardinal.ord c₁ < Cardinal.ord c₂ ↔ c₁ < c₂ := by sorry

This theorem, `Cardinal.ord_lt_ord`, states that for any two cardinal numbers `c₁` and `c₂` in the same type `u_3`, the ordinal number corresponding to `c₁` is less than the ordinal number corresponding to `c₂` if and only if `c₁` is less than `c₂`. In other words, the ordering of ordinals corresponding to two cardinals reflects the ordering of the cardinals themselves.

The ordinal numbers corresponding to two cardinal numbers are ordered similarly if and only if the cardinal numbers are ordered similarly.


theorem iSup₂_mono :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {f g : (i : ι) → κ i → α},
      (∀ (i : ι) (j : κ i), f i j ≤ g i j) → ⨆ i, ⨆ j, f i j ≤ ⨆ i, ⨆ j, g i j :=
  by sorry

This theorem, `iSup₂_mono`, states that for any types `α`, `ι`, and a type function `κ` mapping from `ι`, if `α` forms a complete lattice, then for any two functions `f` and `g` from `ι` and `κ i` to `α`, if every element of `f` is less than or equal to the corresponding element in `g`, then the supremum (or least upper bound) of the set of all outputs of `f` is less than or equal to the supremum of the set of all outputs of `g`. Essentially, it says that if one function is pointwise less than or equal to another, then their suprema also obey the same inequality.

If `α` is a complete lattice and `f` and `g` are functions from `ι` to `α` with `f(i) ≤ g(i)` for all `i`, then `⨆ x. f x ≤ ⨆ x. g x`.


theorem Finset.val_injective : ∀ {α : Type u_1}, Function.Injective Finset.val := by sorry

The theorem `Finset.val_injective` states that for all types `α`, the function `Finset.val` is injective. In other words, if two finsets have the same multiset of elements (as given by `Finset.val`), then the two finsets are themselves the same. This corresponds to the property of injectivity, where if `f(x) = f(y)` then `x = y`, applied to our function `Finset.val`.

If two finsets have the same multiset of elements, then they are equal.


GT.gt.lt

theorem GT.gt.lt : ∀ {α : Type u} [inst : LT α] {x y : α}, x > y → y < x := by sorry

This theorem states that for any type `α` that has a less-than operation (`LT α`), given any two elements `x` and `y` of type `α`, if `x` is greater than `y` (`x > y`), then `y` is less than `x` (`y < x`). It essentially describes the basic property of ordered sets where the greater-than and less-than relations are inverse of each other.

For any type `α` with a total order (`LT α`), the relation `x > y` implies `y < x`.


theorem RingHom.map_dvd :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : Semiring β] (f : α →+* β) {a b : α},
      a ∣ b → f a ∣ f b :=
  by sorry

This theorem states that for any two types `α` and `β` where both are instances of a semiring, and a `RingHom` (ring homomorphism) `f` from `α` to `β`, if `a` divides `b` (denoted as `a ∣ b`) in the semiring `α`, then `f(a)` divides `f(b)` in the semiring `β`. In simpler terms, this theorem asserts that if `a` is a factor of `b`, then the image of `a` under a ring homomorphism is a factor of the image of `b` under the same ring homomorphism.

Given two semirings `α` and `β`, any `RingHom` `f` from `α` to `β`, and `a ∈ α` dividing `b ∈ α`, then `f(a)` divides `f(b)` in `β`.


theorem gcd_dvd_gcd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b c d : α},
      a ∣ b → c ∣ d → gcd a c ∣ gcd b d :=
  by sorry

This theorem states that for any type `α` that is a cancel commutative monoid with zero and also a Greatest Common Divisor (gcd) monoid, and for any elements `a`, `b`, `c`, and `d` of `α`, if `a` divides `b` and `c` divides `d`, then the gcd of `a` and `c` divides the gcd of `b` and `d`. Here, "divides" means that there exists another element of `α` such that multiplying that element by the divisor yields the dividend.

If `α` is a cancel commutative monoid with zero and has the gcd operation, then the gcd of `a` and `c` divides the gcd of `b` and `d` whenever `a` divides `b` and `c` divides `d`.


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

The theorem `Finset.gcd_insert` states that for any types `α` and `β`, where `α` is a cancel commutative monoid with zero and a normalized greatest common divisor (GCD) monoid, for any finite set `s` of elements of type `β`, and for any function `f` from `β` to `α`, if we have decidable equality for `β`, then the GCD of the set obtained by inserting an element `b` of type `β` into `s` (under the function `f`) is equal to the GCD of `f(b)` and the GCD of `s` under `f`. This shows how the GCD of a finite set changes when a new element is added to the set.

For any cancel commutative monoid with zero and normalized GCD `α`, function `f` from a finite set `s` of type `β` to `α` with decidable equality, and element `b` of type `β`, the GCD of `s ∪ {b}` under `f` equals the GCD of `f(b)` and the GCD of `s` under `f`.


theorem Real.continuousOn_cos : ∀ {s : Set ℝ}, ContinuousOn Real.cos s := by sorry

This theorem states that for any set of real numbers `s`, the cosine function is continuous on `s`. In other words, for each point in the set `s`, the real cosine function does not make any jumps or breaks, meaning that as the input values approach any particular point in `s`, the output of the cosine function also approaches the value of the cosine function at that point. This characteristic of the cosine function holds true for any subset of real numbers, not just the entire set of real numbers.

The cosine function is continuous on any set of real numbers.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.5 :
    ∀ {α : Type u_2} [inst : Inv α] {s : Set α} {a : α}, (a ∈ s⁻¹) = (a⁻¹ ∈ s) := by sorry

This theorem, named `Mathlib.Data.Set.Pointwise.Basic._auxLemma.5`, states that for any type `α` that has an operation `Inv` (which signifies that elements of `α` can be inverted) and any set `s` of type `α`, and any element `a` of type `α`, the element `a` is in the inverse of the set `s` if and only if the inverse of `a` is in the set `s`. In other words, it deals with the membership of an element and its inverse in a set and its inverse.

For any type `α` with an operation `Inv` and any set `s` of type `α`, an element `a` is in the inverse of `s` if and only if the inverse of `a` is in `s`.


theorem inv_smul_eq_iff :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] {a : α} {x y : β}, a⁻¹ • x = y ↔ x = a • y :=
  by sorry

This theorem states that for all types `α` and `β`, given `α` as a group and `β` as a set on which `α` acts multiplicatively (`MulAction α β`), for any elements `a` of `α` and `x`, `y` of `β`, the inverse of `a` (denoted `a⁻¹`) multiplied with `x` equals `y` if and only if `x` equals `a` multiplied with `y`. In mathematical notation, this is saying that for all `a` in `α` and `x`, `y` in `β`, `a⁻¹ * x = y` if and only if `x = a * y`.

For all groups `α` and sets `β` with a multiplicative action of `α` on `β`, and for all `a` in `α` and `x`, `y` in `β`, `a⁻¹ * x = y` if and only if `x = a * y`.


theorem Mathlib.GroupTheory.OrderOfElement._auxLemma.3 :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinOrder x = ∃ n, 0 < n ∧ x ^ n = 1 := by sorry

The theorem, named `Mathlib.GroupTheory.OrderOfElement._auxLemma.3`, states that for any type `G` which forms a Monoid, an element `x` of `G` is of finite order (i.e., `IsOfFinOrder x`) if and only if there exists a positive integer `n` such that raising `x` to the power of `n` equals the identity element of the Monoid (`1`). In mathematical notation, this can be written as: $x^n = 1$. This theorem relates the notion of finite order to the existence of an exponent that brings the element to the identity.

For any monoid `G` and element `x` in `G`, `x` has finite order if and only if there exists a positive integer `n` such that `x^n = 1`.


theorem Polynomial.expand_C :
    ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), (Polynomial.expand R p) (Polynomial.C r) = Polynomial.C r :=
  by sorry

The theorem `Polynomial.expand_C` states that for any commutative semiring `R` and for any natural number `p` and element `r` of `R`, expanding the constant polynomial `r` by a factor of `p` is just the constant polynomial `r` itself. In mathematical terms, if `∑ aₙ xⁿ` is the general form of a polynomial, then expansion by a factor `p` turns it into `∑ aₙ xⁿᵖ`. Hence, if the polynomial is just a constant, `r`, then its expansion is also `r` since the expansion operation essentially does not affect constants.

For any commutative semiring R and natural number p, expanding a constant polynomial r by a factor of p results in the constant polynomial r itself.


theorem Polynomial.expand_X :
    ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ), (Polynomial.expand R p) Polynomial.X = Polynomial.X ^ p := by sorry

This theorem, `Polynomial.expand_X`, states that for any type `R` with an instance of `CommSemiring R` (i.e., `R` is a commutative semiring), and any natural number `p`, the operation of expanding the polynomial `Polynomial.X` (which is the polynomial variable or indeterminate) by a factor of `p` equals to the `p`-th power of `Polynomial.X`. In other words, if you take the polynomial `X` and apply the expansion operation with parameter `p`, the result will be `X` raised to the power of `p`. This operation is defined in the context of polynomial algebra.

For any commutative semiring `R` and natural number `p`, expanding the polynomial variable `X` in `R` by a factor of `p` is equivalent to raising `X` to the power of `p`.


Stream'.eta

theorem Stream'.eta : ∀ {α : Type u} (s : Stream' α), Stream'.cons (Stream'.head s) (Stream'.tail s) = s := by sorry

The theorem `Stream'.eta` states that for any stream `s` of elements of any type `α`, if we take the head of `s` (the first element), then construct a new stream by prepending this head to the tail of `s` (the rest of the elements), we will end up with the original stream `s`. Essentially, this theorem captures the property that a stream is completely characterized by its head and its tail.

For any stream `s` of type `α`, the stream obtained by prepending the head of `s` to the tail of `s` is equal to the original stream `s`.


/-- If `S` is a subset of `R`, and `S` is covering, then `R` is covering as well.

See <https://stacks.math.columbia.edu/tag/00Z5> (2), or discussion after [MM92] Chapter III,
Section 2, Definition 1.
 -/
theorem CategoryTheory.GrothendieckTopology.superset_covering :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {S R : CategoryTheory.Sieve X}
      (J : CategoryTheory.GrothendieckTopology C), S ≤ R → S ∈ J.sieves X → R ∈ J.sieves X :=
  by sorry

This theorem states that in the context of a given category `C` with an object `X` and two sieves `S` and `R` on `X`, if `S` is a subset of `R` and `S` is covering (i.e., belongs to the Grothendieck topology `J` on `X`), then `R` is also covering (i.e., belongs to the Grothendieck topology `J` on `X`). It is related to the definitions and discussions found in the provided references.

If `S` is a covering sieve that is a subset of `R` in a Grothendieck topology on a category `C` with object `X`, then `R` is also a covering sieve.


theorem Mathlib.Data.Finset.Image._auxLemma.55 :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : Subtype p},
      (a ∈ Finset.subtype p s) = (↑a ∈ s) :=
  by sorry

This theorem states that for any type `α`, any decidable predicate `p` on `α`, any finite set `s` of `α`, and any element `a` of the subtype `p`, `a` belongs to the set obtained by applying the `Finset.subtype` function to `s` if and only if the element that `a` corresponds to in the type `α` belongs to `s`. In other words, an element from the subtype of `α` defined by `p` is in the subset of `s` consisting of elements satisfying `p` if and only if the original element in `α` is in `s`.

This theorem connects the membership relations in the original set and the subset formed by applying a decidable predicate, making it easier to deal with subsets that are defined by certain properties in the context of finite sets.

For any type `α`, decidable predicate `p` on `α`, finite set `s` of `α`, and `a` in the subtype `p α`, `a` is in the subset `Finset.subtype s` if and only if the element `α` corresponding to `a` is in `s`.


theorem Submonoid.mul_fromLeftInv :
    ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (x : ↥(Submonoid.leftInv S)),
      ↑x * ↑(Submonoid.fromLeftInv S x) = 1 :=
  by sorry

The theorem `Submonoid.mul_fromLeftInv` states that for any type `M` that forms a monoid, and for any submonoid `S` of `M`, and for any element `x` from the submonoid of `S` that consists of left inverses of elements in `S`, the product of `x` and the element of `S` that is the right inverse of `x` (obtained through the function `Submonoid.fromLeftInv`) is equal to the identity (`1`) of the monoid. In mathematical terms, for any $x$ in the set of left inverses of a submonoid $S$, we have $x*(x^{-1}) = 1$, where $x^{-1}$ is the right inverse of $x$ in $S$.

For any submonoid `S` of a monoid `M` and any element `x` in `S` with right inverse `x⁻¹`, we have `x * x⁻¹ = 1`.


theorem SimpleGraph.card_neighborSet_eq_degree :
    ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(SimpleGraph.neighborSet G v)],
      Fintype.card ↑(SimpleGraph.neighborSet G v) = SimpleGraph.degree G v :=
  by sorry

The theorem `SimpleGraph.card_neighborSet_eq_degree` states that for any simple graph `G` and any vertex `v` in `G`, provided that the set of neighboring vertices of `v` is finite (`Fintype`), the cardinality of the set of neighboring vertices (`Fintype.card ↑(SimpleGraph.neighborSet G v)`) is equal to the degree of the vertex `v` in the graph (`SimpleGraph.degree G v`). The degree of a vertex in a simple graph is the number of vertices adjacent to it, and the neighbor set of a vertex is the set of its adjacent vertices, so this theorem essentially states that the number of elements in the neighbor set of a vertex is equal to the degree of the vertex.

For any simple graph and vertex with a finite set of neighbors, the cardinality of the neighbor set equals the degree of the vertex.


theorem OnePoint.coe_injective : ∀ {X : Type u_1}, Function.Injective OnePoint.some := by sorry

This theorem asserts that for every type `X`, the function `OnePoint.some` is injective. In other words, if we apply this function to two elements of `X` and get the same result, it means that the two elements were actually identical. Put into a mathematical context, given any type `X`, this function maps each element to a unique element in the `OnePoint X` type, hence preserving distinctness.

For every type X, the function OnePoint.some from X to OnePoint X is a bijection (injective and surjective).


theorem Submodule.mem_sInf :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {S : Set (Submodule R M)} {x : M}, x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p :=
  by sorry

This theorem states that, for any semiring `R`, any additive commutative monoid `M`, and any `R`-module `M`, for any set `S` of submodules of `M`, and any element `x` of `M`, `x` is an element of the infimum of `S` if and only if `x` is an element of every submodule `p` in `S`. Here, the infimum of a set of submodules is the largest submodule that is contained in all submodules in the set.

For any semiring `R`, additive commutative monoid `M`, and `R`-module `M`, an element `x` of `M` belongs to the infimum of a set `S` of submodules of `M` if and only if `x` is contained in every submodule `p` in `S`.


theorem MeasureTheory.integrable_norm_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β},
      MeasureTheory.AEStronglyMeasurable f μ →
        (MeasureTheory.Integrable (fun a => ‖f a‖) μ ↔ MeasureTheory.Integrable f μ) :=
  by sorry

The theorem `MeasureTheory.integrable_norm_iff` states that for any given measure `μ` on a measurable space `α`, and a function `f` mapping from `α` to a normed additive commutative group `β`, if the function `f` is almost everywhere strongly measurable with respect to the measure `μ`, then `f` is integrable with respect to `μ` if and only if the norm of `f`, denoted as `‖f a‖`, is integrable with respect to `μ`. Here, integrability means that the function is almost everywhere strongly measurable and has a finite integral.

A strongly measurable function `f` from a measurable space `(α, μ)` to a normed additive commutative group `β` is integrable with respect to `μ` if and only if the norm of `f` is integrable with respect to `μ`.


theorem Complex.ofReal_log : ∀ {x : ℝ}, 0 ≤ x → ↑(Real.log x) = Complex.log ↑x := by sorry

This theorem states that for any real number `x` that is greater than or equal to zero, the real logarithm of `x` when converted to a complex number equals the complex logarithm of `x` when it is treated as a complex number. This theorem links the real logarithm and the complex logarithm functions, asserting that they align for non-negative real numbers.

For any non-negative real number x, the real logarithm of x is equal to the complex logarithm of x treated as a complex number.


theorem sdiff_sup : ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], y \ (x ⊔ z) = y \ x ⊓ y \ z := by
  sorry

This theorem, `sdiff_sup`, states that for any type `α` that is a Generalized Boolean Algebra and any elements `x`, `y`, and `z` of that type, the set difference of `y` and the supremum of `x` and `z` (written as `y \ (x ⊔ z)`) is equivalent to the infimum of the set difference of `y` and `x` and the set difference of `y` and `z` (written as `y \ x ⊓ y \ z`). Essentially, this theorem describes a property of set differences and supremum/infimum operations in the context of a Generalized Boolean Algebra.

For any element `y` of a Generalized Boolean Algebra and elements `x` and `z` of that type, `y \ (x ⊔ z)` is equivalent to `(y \ x) ⊓ (y \ z)`.


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

The theorem `analyticAt_const` states that for any types `𝕜`, `E`, and `F` where `𝕜` is a nontrivially normed field, `E` is a normed additive commutative group that is a normed space over `𝕜`, and `F` is a normed additive commutative group that is a normed space over `𝕜`; for any elements `x` of type `E` and `v` of type `F`, the function which maps `x` to a constant `v` is analytic at `x`. In other words, this function has a convergent power series expansion around `x`.

For any normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, and elements `x in E` and `v in F`, the function `x ↦ v` is analytic at `x` in the sense of having a convergent power series expansion.


theorem Function.invFun_eq :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Nonempty α] {f : α → β} {b : β},
      (∃ a, f a = b) → f (Function.invFun f b) = b :=
  by sorry

This theorem states that for any types `α` and `β` where `α` is nonempty, given a function `f` from `α` to `β` and an element `b` of `β`, if there exists an element `a` of `α` such that `f(a)` equals `b`, then applying `f` to the inverse of `b` under the function `f` will yield `b` back. In other words, if `b` is in the image of `f`, then the function `f` composed with its inverse function at `b` equals `b`, which is a property demonstrating how the inverse function undoes the mapping of `f`.

If `f` is a function from a nonempty type `α` to `β`, `b` is an element of `β` in the image of `f`, then `f(f⁻¹(b)) = b`.


/-- The complex hyperbolic sine function is everywhere differentiable, with the derivative
`cosh x`.  -/
theorem Complex.hasDerivAt_sinh : ∀ (x : ℂ), HasDerivAt Complex.sinh (Complex.cosh x) x := by sorry

The theorem states that the complex hyperbolic sine function, defined as `(Complex.exp z - Complex.exp (-z)) / 2`, is differentiable at every point in the complex plane. Furthermore, the derivative of the complex hyperbolic sine function at any point `x` is given by the complex hyperbolic cosine function at that point, which is defined as `(Complex.exp z + Complex.exp (-z)) / 2`.

The complex hyperbolic sine function, defined as (exp z - exp (-z)) / 2, is a complex differentiable function with derivative given by the complex hyperbolic cosine function (exp z + exp (-z)) / 2.


theorem Set.OrdConnected.apply_covBy_apply_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {a b : α} (f : α ↪o β),
      Set.OrdConnected (Set.range ⇑f) → (f a ⋖ f b ↔ a ⋖ b) :=
  by sorry

This theorem states that for any types `α` and `β`, and instances of preorders on `α` and `β`, given any two elements `a` and `b` of `α` and a strictly increasing function `f` from `α` to `β`, if the range of `f` is order-connected (that is, every element that lies between any two elements in the range is also in the range), then `f(a)` is less than `f(b)` if and only if `a` is less than `b`. Essentially, the ordering of elements in the domain `α` is preserved by the function `f` when moving to the range in `β`.

Given preorders on types `α` and `β`, if `f` is a strictly increasing function from `α` to `β` with order-connected range, then `a < b` in `α` implies `f(a) < f(b)` in `β`.


theorem inducing_iff_nhds :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Inducing f ↔ ∀ (x : X), nhds x = Filter.comap f (nhds (f x)) :=
  by sorry

This theorem states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, if both `X` and `Y` have a topological space structure, then `f` is an inducing function if and only if, for every element `x` of `X`, the neighborhood filter of `x` in `X` is equivalent to the preimage under `f` of the neighborhood filter of `f(x)` in `Y`. In simpler terms, a function induces a topology on its domain if the neighborhoods of each point in the domain are exactly the preimages of the neighborhoods of their images in the codomain.

A function between topological spaces induces the same neighborhood structure on each point if and only if the preimage of every neighborhood of its image under the function is the neighborhood of that point in the domain.


/-- If a vector space has a finite basis, then it is finite-dimensional.  -/
theorem FiniteDimensional.of_fintype_basis :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type w}
      [inst_3 : Finite ι], Basis ι K V → FiniteDimensional K V :=
  by sorry

The theorem `FiniteDimensional.of_fintype_basis` states that if a vector space has a basis that is finite, then the vector space is finite-dimensional. Here, `K` is a division ring, `V` is an additive commutative group with a module structure over `K`, and `ι` is the type indexing the basis of the vector space. The basis is represented as a function from `ι` to `V`. If `ι` is finite (i.e., there are finitely many basis vectors), then the vector space is considered finite-dimensional.

If a vector space over a division ring with a finite basis is given, then the vector space is finite-dimensional.


theorem Finset.card_biUnion :
    ∀ {α : Type u_3} {β : Type u_4} [inst : DecidableEq β] {s : Finset α} {t : α → Finset β},
      (∀ x ∈ s, ∀ y ∈ s, x ≠ y → Disjoint (t x) (t y)) → (Finset.biUnion s t).card = Finset.sum s fun u => (t u).card :=
  by sorry

This theorem states that for any two types `α` and `β`, given a finite set `s` of type `α` and a function `t` from `α` to a finite set of type `β`, if for all distinct elements `x` and `y` in `s`, the finite sets `t(x)` and `t(y)` are disjoint (meaning that their infimum is the bottom element), then the cardinality of the biUnion of `s` and `t` (which is the union of `t(a)` for all `a` in `s`) equals the sum of the cardinalities of `t(u)` for all `u` in `s`. In other words, the size of the union of all the sets `t(x)` for `x` in `s` is the sum of the sizes of these sets, provided that these sets are pairwise disjoint.

Given a finite set `s` and a function `t` from a type `α` to finite sets of type `β`, if the images `t(x)` and `t(y)` are disjoint for all distinct `x` and `y` in `s`, then the cardinality of the union of `s` and the biUnion of `t` equals the sum of the cardinalities of the images `t(x)` for all `x` in `s`.


theorem Ne.lt_of_le : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≠ b → a ≤ b → a < b := by sorry

This theorem states that for any type `α` that has a partial order, if we have two elements `a` and `b` of type `α`, then `a` is strictly less than `b` (`a < b`) if `a` is not equal to `b` (`a ≠ b`) and `a` is less than or equal to `b` (`a ≤ b`).

For any type `α` with a partial order, `a < b` if and only if `a ≠ b` and `a ≤ b`.


/-- The resolution maps intertwine the lift of a morphism and that morphism.  -/
theorem CategoryTheory.ProjectiveResolution.lift_commutes :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Y ⟶ Z)
      (P : CategoryTheory.ProjectiveResolution Y) (Q : CategoryTheory.ProjectiveResolution Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.lift f P Q) Q.π =
        CategoryTheory.CategoryStruct.comp P.π ((ChainComplex.single₀ C).map f) :=
  by sorry

This theorem, named `CategoryTheory.ProjectiveResolution.lift_commutes`, asserts that in an Abelian category `C`, for any two objects `Y` and `Z` in `C` and a morphism `f` from `Y` to `Z`, together with projective resolutions `P` of `Y` and `Q` of `Z`, the composition of the lift of `f` with respect to `P` and `Q` followed by the projection of `Q` is the same as the composition of the projection of `P` and the image of `f` under the functor that creates a chain complex supported in degree zero. This is a statement about the commutativity of a certain diagram in the category of chain complexes.

In an Abelian category, for any morphism `f` between objects `Y` and `Z`, and given projective resolutions `P` of `Y` and `Q` of `Z`, the diagram commutes, i.e., (lift of `f` with respect to `P` and `Q`) ∘ projection of `Q` = projection of `P` ∘ `f` (as chain complexes in degree 0).


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

This theorem states that for any types `m`, `n`, `o` and `α` with `α` being a non-unital semiring and `m` and `n` being finite types, and for any vector `v` of type `m → α` and any two matrices `M` and `N` of types `Matrix m n α` and `Matrix n o α`, respectively, the vector-matrix product of the vector-matrix product of `v` and `M` with `N` is equal to the vector-matrix product of `v` with the matrix product of `M` and `N`. In mathematical notation, this can be written as `(vM)N = v(MN)`, where `vM` denotes the vector-matrix product of `v` and `M`, `MN` denotes the matrix product of `M` and `N`, and `(vM)N` and `v(MN)` denote the vector-matrix products.

For any finite types `m`, `n`, `o` and non-unital semiring `α`, the vector-matrix product of a vector `v` of type `m → α` with the matrix product of matrices `M` of type `Matrix m n α` and `N` of type `Matrix n o α` equals the vector-matrix product of `v` with `M` and the matrix `N`. That is, `(vM)N = v(MN)`.


theorem uniformContinuous_add :
    ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α],
      UniformContinuous fun p => p.1 + p.2 :=
  by sorry

The theorem `uniformContinuous_add` states that for any type `α` equipped with a uniform space structure, an addition operation, and a uniform addition group structure, the function that takes a pair of elements in `α` and returns their sum is uniformly continuous. In other words, if two pairs of elements in `α` are sufficiently close to each other (in terms of the uniformity structure), then their sums are also close to each other, regardless of the specific location of these pairs in `α`.

Given a uniform space `(α, δ)` with addition operation and uniform addition group structure, the addition function is uniformly continuous.


theorem tendsto_inv_atTop_zero :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : OrderTopology 𝕜],
      Filter.Tendsto (fun r => r⁻¹) Filter.atTop (nhds 0) :=
  by sorry

This theorem, `tendsto_inv_atTop_zero`, states that for any linearly ordered field `𝕜`, which is also a topological space with an order topology, the function that takes the inverse of each element (`fun r => r⁻¹`) tends to zero as the input values approach infinity (`Filter.atTop`). In other words, as we consider larger and larger values in the ordered field `𝕜`, their reciprocals get closer and closer to zero. This formalizes the intuitive notion that the inverse of a large number is a small number close to zero.

For any linearly ordered field `𝕜` with order topology, the function `r => r⁻¹` converges to zero as `r` approaches the top element.


theorem iSup_singleton :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {b : β}, ⨆ x ∈ {b}, f x = f b := by sorry

This theorem states that for every type `α` that is a complete lattice and for any function `f` from type `β` to `α`, the supremum (denoted with `⨆`) of `f x` over the singleton set containing only `b` is equal to `f b`. Basically, it means that the supremum of a function over a set with a single element is just the value of the function at that element.

For any complete lattice `α` and function `f` from type `β` to `α`, the supremum of `f` over a singleton set `{b}` is equal to `f b`. In mathematical notation: ⨆ {x : β | x = b} . f x = f b.


Polynomial.Monic.pow

theorem Polynomial.Monic.pow :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.Monic p → ∀ (n : ℕ), Polynomial.Monic (p ^ n) :=
  by sorry

This theorem states that for any polynomial `p` in a semiring `R`, if `p` is monic (i.e., its leading coefficient is 1), then any natural number power of `p` is also monic. Essentially, it's saying that raising a monic polynomial to any power doesn't change the property of being monic.

If `p` is a monic polynomial in a semiring `R`, then for all natural numbers `n`, `p^n` is also a monic polynomial in `R`.


NonUnitalSubsemiring.ext

/-- Two non-unital subsemirings are equal if they have the same elements.  -/
theorem NonUnitalSubsemiring.ext :
    ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {S T : NonUnitalSubsemiring R},
      (∀ (x : R), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that in the context of a non-unital, non-associative semiring `R`, two distinct non-unital subsemirings `S` and `T` of `R` are considered equal if they contain exactly the same elements. In other words, if every element `x` in semiring `R` satisfies the condition that it is in `S` if and only if it is in `T`, then `S` and `T` are the same subsemiring.

In a non-unital, non-associative semiring, two distinct subsemirings are equal if and only if they contain the same elements.


theorem MeasureTheory.Measure.fst_apply :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {ρ : MeasureTheory.Measure (α × β)} {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.fst ρ) s = ↑↑ρ (Prod.fst ⁻¹' s) :=
  by sorry

The theorem `MeasureTheory.Measure.fst_apply` states that for any types `α` and `β` with measurable spaces `inst` and `inst_1` respectively, any measure `ρ` on the product space `α × β`, and any set `s` of `α` that is a measurable set, the measure of `s` under the map `MeasureTheory.Measure.fst ρ` (i.e., the measure obtained by projecting `ρ` onto its first component) is equal to the measure `ρ` of the preimage of `s` under the projection function `Prod.fst` (i.e., the set of all pairs `(a, b)` in `α × β` such that `a` is in `s`). In mathematical terms, if `s ⊆ α` is measurable, then `(MeasureTheory.Measure.fst ρ) s = ρ ({(a, b) ∈ α × β : a ∈ s})`.

For any measurable sets `s ⊆ α` in measurable spaces `α × β`, the measure of `s` under the projection function `MeasureTheory.Measure.fst` on a product measure `ρ` equals the measure of the preimage of `s` under the `Prod.fst` function.


theorem Complex.abs_mul_cos_add_sin_mul_I :
    ∀ (x : ℂ), ↑(Complex.abs x) * (Complex.cos ↑(Complex.arg x) + Complex.sin ↑(Complex.arg x) * Complex.I) = x := by
  sorry

This theorem states that for every complex number `x`, the product of the absolute value of `x` and the complex number formed by adding the cosine of the argument of `x` and the product of the sine of the argument of `x` and the imaginary unit `I`, is equal to `x` itself. In other words, it expresses a complex number in terms of its polar form. In mathematical terms, given a complex number `x`, this theorem verifies the well-known formula `x = r(cos θ + i*sin θ)`, where `r` is the absolute value of the complex number (distance from origin) and `θ` is the argument of the complex number (angle made with the real axis).

For every complex number x, x equals the product of its absolute value and the complex number formed by the cosine and sine of its argument and the imaginary unit i.


Filter.EventuallyLE.refl

theorem Filter.EventuallyLE.refl :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] (l : Filter α) (f : α → β), f ≤ᶠ[l] f := by sorry

This theorem, named `Filter.EventuallyLE.refl`, states that for any type `α`, any type `β` equipped with a preorder relationship, any filter `l` of the type `α`, and any function `f` from `α` to `β`, the function `f` is less than or equal to itself `eventually` at the filter `l`. Here, `≤ᶠ[l]` is a notation meaning "eventually less than or equal to at filter `l`", i.e., for all elements sufficiently close to `l`, `f`'s value is less than or equal to itself. It's a reflexive property in the context of filters and functions.

For any filter `l` on type `α`, any function `f` from `α` to a preordered type `β`, `f` is eventually less than or equal to itself at `l`, i.e., `f ≤ᶠ[l] f`.