theorem Filter.Tendsto.inv_tendsto_zero :
    ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜]
      [inst_2 : OrderTopology 𝕜] {l : Filter α} {f : α → 𝕜},
      Filter.Tendsto f l (nhdsWithin 0 (Set.Ioi 0)) → Filter.Tendsto f⁻¹ l Filter.atTop :=
  by sorry

The theorem `Filter.Tendsto.inv_tendsto_zero` states that for any type `𝕜` that can be ordered with a linear ordering and has a topology compatible with that order, and for any filter `l` over any type `α` and any function `f` from `α` to `𝕜`, if the function `f` tends to a value in the interval `(0, ∞)` as `l` tends to 0, then the reciprocal function `1/f` tends to infinity as `l` is considered. In other words, if `f` approaches values greater than zero when its input approaches zero, then `1/f` approaches infinity when the same input filter is considered.

If a function from a filtered space to the real numbers with a compatible topology tends to a positive value as the filter tends to 0, then the reciprocal function tends to infinity with respect to that filter.


theorem AddCommGroupCat.epi_iff_surjective :
    ∀ {A B : AddCommGroupCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ Function.Surjective ⇑f := by sorry

The theorem `AddCommGroupCat.epi_iff_surjective` asserts that for all additive commutative groups `A` and `B` in the category of additive commutative groups (denoted as `AddCommGroupCat`), a morphism `f` from `A` to `B` (denoted as `A ⟶ B`) is an epimorphism if and only if it is surjective. In category theory, an epimorphism (or epi) is a morphism that is right-cancellable, meaning that if two morphisms following it are equal, then they were equal before composition with it. In set theory, a function is surjective (or onto) if for every element in the codomain there is at least one element in the domain that maps to it. Thus, in the context of additive commutative groups, this theorem is establishing an equivalence between these two seemingly different concepts.

In the category of additive commutative groups, a morphism is an epimorphism if and only if it is surjective.


/-- An element of an algebra over a field is algebraic if and only if it is integral. -/
theorem isAlgebraic_iff_isIntegral :
    ∀ {K : Type u} {A : Type v} [inst : Field K] [inst_1 : Ring A] [inst_2 : Algebra K A] {x : A},
      IsAlgebraic K x ↔ IsIntegral K x :=
  by sorry

This theorem states that for any element `x` of an algebra `A` over a field `K`, `x` is algebraic over `K` if and only if `x` is integral over `K`. Here, an element is defined as algebraic over `K` if it is a root of a non-zero polynomial with coefficients in `K`, and it is defined as integral over `K` if it is a root of a monic polynomial in `K[X]`, equivalently, the element is integral with respect to the induced `algebraMap` from `K` to `A`.

An element `x` in an algebra `A` over a field `K` is algebraic over `K` if and only if it is integral over `K`.


theorem List.nodup_append :
    ∀ {α : Type u} {l₁ l₂ : List α}, List.Nodup (l₁ ++ l₂) ↔ List.Nodup l₁ ∧ List.Nodup l₂ ∧ List.Disjoint l₁ l₂ := by
  sorry

The theorem `List.nodup_append` states that for all types `α` and for any two lists `l₁` and `l₂` of type `α`, the condition that the list formed by appending `l₁` and `l₂` has no duplicates (i.e., `List.Nodup (l₁ ++ l₂)`) is equivalent to the conjunction of three conditions: `l₁` has no duplicates (`List.Nodup l₁`), `l₂` has no duplicates (`List.Nodup l₂`), and `l₁` and `l₂` have no elements in common (`List.Disjoint l₁ l₂`). In other words, the concatenation of two lists is a list without duplicates if and only if both original lists are without duplicates and they do not share any common elements.

For all types `α`, the list `l₁ ++ l₂` has no duplicates if and only if both `l₁` and `l₂` have no duplicates and are disjoint.


theorem AlgHom.apply_mem_spectrum :
    ∀ {F : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A]
      [inst_3 : FunLike F A R] [inst_4 : AlgHomClass F R A R] [inst_5 : Nontrivial R] (φ : F) (a : A),
      φ a ∈ spectrum R a :=
  by sorry

This theorem, `AlgHom.apply_mem_spectrum`, asserts that for any commutative ring `R`, ring `A`, algebra structure on `A` over `R`, function of type `F` that behaves like a function from `A` to `R` (denoted by the `FunLike` typeclass), and given the `AlgHomClass` typeclass which represents an algebra homomorphism of `F` from `R` to `A` to `R`, then for any algebra homomorphism `φ` of type `F` and for any element `a` of `A`, the image of `a` under `φ` is in the spectrum of `a` in `R`.

In mathematical terms, if `φ: A → R` is an algebra homomorphism, and `a ∈ A`, then `φ(a)` lies in the spectrum of `a`. The spectrum of `a` is the set of all `r` in `R` such that `r•1 - a` is not a unit in `A`.

For any commutative ring `R`, ring `A`, algebra structure on `A` over `R`, `FunLike` function `F` from `A` to `R`, and given an algebra homomorphism `φ: A → R` of type `AlgHomClass R A F`, the image of any element `a` in `A` under `φ` lies in the spectrum of `a` in `R`.


theorem SimpleGraph.adj_comm : ∀ {V : Type u} (G : SimpleGraph V) (u v : V), G.Adj u v ↔ G.Adj v u := by sorry

This theorem states that for any simple graph `G` with vertex set `V`, the adjacency relation is symmetric. In other words, if vertex `u` is adjacent to vertex `v` in `G`, then it's also the case that `v` is adjacent to `u` in `G`, and vice versa. This captures the intuitive notion of adjacency in an undirected graph, where the order of the vertices does not matter in determining whether a pair of vertices is adjacent or not.

For any simple graph `G` with vertex set `V`, if `u` is adjacent to `v` in `G`, then `v` is also adjacent to `u`.


theorem Polynomial.degree_map_eq_of_injective :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S},
      Function.Injective ⇑f → ∀ (p : Polynomial R), Polynomial.degree (Polynomial.map f p) = Polynomial.degree p :=
  by sorry

This theorem states that for any semirings `R` and `S`, and for any injective ring homomorphism `f` from `R` to `S`, the degree of any polynomial `p` from `R` remains the same after mapping `p` across the homomorphism `f`. In other words, if you have a polynomial with coefficients in a semiring `R` and you map it to a polynomial with coefficients in a semiring `S` using an injective homomorphism, the degree of the polynomial does not change.

For any injective ring homomorphism `f` from semiring `R` to semiring `S`, the degree of any polynomial `p` in `R` equals the degree of `f(p)` in `S`.


theorem Set.sUnion_eq_univ_iff : ∀ {α : Type u_1} {c : Set (Set α)}, ⋃₀ c = Set.univ ↔ ∀ (a : α), ∃ b ∈ c, a ∈ b := by
  sorry

This theorem, `Set.sUnion_eq_univ_iff`, states that for any type `α` and any set `c` of sets of `α`, the union over all elements in `c` (denoted as `⋃₀ c`) equals the universal set of `α` (which contains all elements of `α`) if and only if for any element `a` of type `α`, there exists a set `b` in `c` such that `a` is an element of `b`. In the context of set theory, this expresses that a collection of sets covers all elements of a given type if and only if every element of the type is contained in at least one of the sets in the collection.

For a type `α` and a set `c` of sets over `α`, `⋃₀ c` equals the universe of `α` if and only if every `α` element is in some `c` set.


Measurable.exp

theorem Measurable.exp :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => Real.exp (f x) := by sorry

This theorem states that for any measurable space `α` and any real-valued function `f` on that space, if `f` is a measurable function, then the function that sends each point `x` in the space to the real exponential of `f(x)` is also measurable. Here, a function is called measurable if the preimage of every measurable set under the function is also measurable. The real exponential function is defined as the real part of the complex exponential function.

If `f` is a real-valued, measurable function on a measurable space `α`, then the function `x ↦ exp(f(x))` is measurable.


theorem Cardinal.cantorFunctionAux_true :
    ∀ {c : ℝ} {f : ℕ → Bool} {n : ℕ}, f n = true → Cardinal.cantorFunctionAux c f n = c ^ n := by sorry

The theorem `Cardinal.cantorFunctionAux_true` states that for all real numbers `c`, functions `f` mapping natural numbers to Booleans, and natural numbers `n`, if the function `f` evaluated at `n` is true, then the function `Cardinal.cantorFunctionAux` evaluated at `c`, `f`, and `n` returns the value of `c` raised to the power `n`. In other words, if the Boolean function applied to a natural number returns true, the cantor function auxiliary gives the power of the real number to that natural number.

For all real numbers `c`, functions `f` mapping natural numbers to Booleans, and natural numbers `n`, if `f`( `n`) = `true`, then `Cardinal.cantorFunctionAux` `c` `f` `n` = `c` ^ `n`.


theorem Ordinal.nfpFamily_lt_ord_lift :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {c : Ordinal.{max u v}},
      Cardinal.aleph0 < Ordinal.cof c →
        Cardinal.lift.{v, u} (Cardinal.mk ι) < Ordinal.cof c →
          (∀ (i : ι), ∀ b < c, f i b < c) → ∀ {a : Ordinal.{max u v}}, a < c → Ordinal.nfpFamily f a < c :=
  by sorry

This theorem states that for any type `ι`, any function `f` from `ι` and an ordinal to an ordinal, and any ordinal `c`, if the smallest infinite cardinal (`aleph0`) is less than the cofinality of `c` and the cardinality of `ι` lifted to a higher universe is also less than the cofinality of `c`, and moreover, for every element of `ι`, the function `f` applied to that element and any ordinal less than `c` is also less than `c`, then for any ordinal `a` less than `c`, the next common fixed point of the family of functions `f` at least `a` is also less than `c`.

In simpler terms, under certain conditions on the cardinalities and the function `f`, the theorem guarantees that the "next common fixed point" of the family of functions is strictly less than a given ordinal.

Given an ordinal `c`, a type `ι`, a function `f` from `ι` to ordinals, if `aleph0` is smaller than the cofinality of `c` and the cardinality of `ι` is also smaller than the cofinality of `c`, and for all `x ∈ ι` and `α < c`, `f(x) < c`, then for all `a < c`, there exists `x ∈ ι` such that `f^n(x) = a` for some `n`, and `f^(n+1)(x) < c`.


theorem connectedComponent_eq :
    ∀ {α : Type u} [inst : TopologicalSpace α] {x y : α},
      y ∈ connectedComponent x → connectedComponent x = connectedComponent y :=
  by sorry

This theorem states that for any topological space `α` and any two points `x` and `y` in `α`, if `y` is in the connected component of `x`, then the connected component of `x` is equal to the connected component of `y`. In simpler terms, it means that if two points belong to the same connected component in a topological space, they share the same connected component.

For any topological space `α` and points `x, y ∈ α`, if `y` is in the connected component of `x`, then the connected component of `x` equals the connected component of `y`.


theorem EReal.exists_rat_btwn_of_lt : ∀ {a b : EReal}, a < b → ∃ x, a < ↑↑x ∧ ↑↑x < b := by sorry

This theorem states that for any two extended real numbers `a` and `b` such that `a` is less than `b`, there exists a rational number `x` such that `a` is less than `x` and `x` is less than `b`. In other words, between any two distinct extended real numbers, one can always find a rational number. This is a formal version of the mathematical property that the rational numbers are dense in the extended real numbers.

For any extended real numbers `a` and `b` with `a < b`, there exists a rational number `x` such that `a < x < b`.


theorem MvPolynomial.map_bind₁ :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      (f : R →+* S) (g : σ → MvPolynomial τ R) (φ : MvPolynomial σ R),
      (MvPolynomial.map f) ((MvPolynomial.bind₁ g) φ) =
        (MvPolynomial.bind₁ fun i => (MvPolynomial.map f) (g i)) ((MvPolynomial.map f) φ) :=
  by sorry

The theorem `MvPolynomial.map_bind₁` states that for any commutative semiring `R` and `S`, a ring homomorphism `f` from `R` to `S`, a function `g` from an arbitrary type `σ` to multivariate polynomials over `R` indexed by another arbitrary type `τ`, and a multivariate polynomial `φ` over `R` indexed by `σ`, if we first map the polynomial `φ` through `g` and then apply the `f` map to the result, it is the same as first applying the `f` map to `φ` and `g(i)` for each index `i`, and then mapping `φ` through the resulting function. In other words, the operations of mapping a polynomial using a ring homomorphism and binding a polynomial via a function commute with each other.

For any commutative semirings R and S, ring homomorphism f from R to S, function g from an arbitrary type σ to multivariate polynomials over R indexed by τ, and multivariate polynomial φ over R indexed by σ, the application of f to the polynomial obtained by mapping φ through g is equal to the polynomial obtained by mapping φ through the composition of g and the function that applies f to the image of g under each index i.


theorem ConvexCone.mem_sInf :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E] {x : E}
      {S : Set (ConvexCone 𝕜 E)}, x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s :=
  by sorry

This theorem, `ConvexCone.mem_sInf`, states that for any types `𝕜` and `E`, where `𝕜` is an ordered semiring and `E` is an additive commutative monoid that also supports scalar multiplication by elements of `𝕜`, a given element `x` of type `E` is in the infimum (greatest lower bound) of a set `S` of convex cones of `𝕜` and `E` if and only if `x` is in every convex cone that is a member of `S`. A convex cone here refers to a subset of a vector space over a given field that is closed under linear combinations with positive coefficients.

For any ordered semiring `𝕜` and additive commutative monoid `E` with scalar multiplication, an element `x` of `E` lies in the infimum of a set `S` of convex cones of `𝕜` and `E` if and only if it belongs to every convex cone in `S`.


theorem not_and' : ∀ {a b : Prop}, ¬(a ∧ b) ↔ b → ¬a := by sorry

This theorem states that for any two propositions `a` and `b`, the negation of their conjunction (i.e., `¬(a ∧ b)`) is logically equivalent to the implication `b → ¬a`. In other words, the statement "not both `a` and `b` are true" is equivalent to "if `b` is true, then `a` must not be true".

The negation of the conjunction `a ∧ b` is logically equivalent to the implication `b → ¬a`.


theorem Equiv.Perm.subtypeCongr.left_apply :
    ∀ {ε : Type u_1} {p : ε → Prop} [inst : DecidablePred p] (ep : Equiv.Perm { a // p a })
      (en : Equiv.Perm { a // ¬p a }) {a : ε} (h : p a),
      (Equiv.Perm.subtypeCongr ep en) a = ↑(ep { val := a, property := h }) :=
  by sorry

The theorem `Equiv.Perm.subtypeCongr.left_apply` states that for any type `ε`, and any predicate `p` on `ε` that is decidable, given a permutation `ep` on the subtype of elements of `ε` that satisfy `p` and a permutation `en` on the subtype of elements of `ε` that do not satisfy `p`, for any element `a` of `ε` that satisfies `p`, applying the combined permutation `Equiv.Perm.subtypeCongr ep en` to `a` is the same as applying the permutation `ep` to `a` (thought of as an element of the subtype `{ a // p a }`), and then taking the underlying element of `ε`. In other words, for elements that satisfy the predicate, the combined permutation behaves just like the permutation on the satisfying subtype.

For any type `ε`, decidable predicate `p` on `ε`, permutations `ep` on the subtype of elements of `ε` satisfying `p` and `en` on the complement subtype, and element `a` of `ε` satisfying `p`, `Equiv.Perm.subtypeCongr ep en a` equals `ep a`.


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

The theorem `EuclideanGeometry.inversion_involutive` states that for any point `c` and a non-zero radius `R`, the inversion operation `EuclideanGeometry.inversion c R` is an involutive function in a Euclidean Geometry context. In simpler terms, this means that if we perform the inversion operation twice, we get back the original point. The inversion operation here is defined as sending each point `x` to a point `y` such that `y -ᵥ c = (R / dist x c) ^ 2 • (x -ᵥ c)`, where `dist x c` is the distance from `x` to `c`, `•` is the scalar multiplication operation, and `-ᵥ` and `+ᵥ` are the vector subtraction and addition operations, respectively.

In a Euclidean geometry context, the inversion operation with respect to a point `c` and radius `R` is an involution, i.e., applying it twice to any point `x` results in the original point `x`.


theorem Fintype.linearIndependent_iff :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : Fintype ι],
      LinearIndependent R v ↔ ∀ (g : ι → R), (Finset.sum Finset.univ fun i => g i • v i) = 0 → ∀ (i : ι), g i = 0 :=
  by sorry

The theorem `Fintype.linearIndependent_iff` states that for any set of types `ι`, a semiring `R`, an additive commutative monoid `M`, and a function `v` from `ι` to `M`, given that `M` is a module over `R` and `ι` is finite, the family of vectors `v` is linearly independent over `R` if and only if for all functions `g` from `ι` to `R`, if the sum of `g i` scaled by `v i` over all elements `i` in the universal finite set is zero, then for all `i` in `ι`, `g i` must be equal to zero.

In mathematical terms, this means that a set of vectors is linearly independent if and only if no non-trivial linear combination of these vectors results in the zero vector.

A family of vectors from a module over a semiring is linearly independent if and only if no non-zero, weighted sum of the vectors with coefficients from the semiring equals the zero vector, where the weights come from another function to the semiring.


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

This theorem states that for any pseudometric space `α`, any two points `x` and `y` in `α`, and any real number `ε`, `y` is in the closed ball centered at `x` with radius `ε` if and only if the distance from `x` to `y` is less than or equal to `ε`. In other words, it provides a condition for a point's membership in the closed ball in terms of the pseudometric distance.

For any pseudometric space and points x, y, the closed ball with center x and radius ε contains y if and only if the distance from x to y is less than or equal to ε.


theorem AddMonoidAlgebra.of'_apply :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] (a : G),
      AddMonoidAlgebra.of' k G a = AddMonoidAlgebra.single a 1 :=
  by sorry

This theorem states that for any types `k` and `G`, given that `k` has a `Semiring` structure and for any element `a` of type `G`, the application of the `AddMonoidAlgebra.of'` function with the types `k` and `G`, and the variable `a`, is equivalent to the application of the `AddMonoidAlgebra.single` function with the variables `a` and `1`. In other words, the embedding of a magma with zero `G`, into its magma algebra, having `G` as the source, maps an element `a` to the single value of the algebra associated with `a` and `1`.

For any semiring `k` and type `G` with an element `a`, the `AddMonoidAlgebra.of' k G a` is equal to `AddMonoidAlgebra.single a 1` in `AddMonoidAlgebra k G`.


theorem IsOpen.nhdsWithin_eq :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, IsOpen s → a ∈ s → nhdsWithin a s = nhds a := by
  sorry

The theorem `IsOpen.nhdsWithin_eq` states that for any topological space `α`, a point `a` in `α`, and a set `s` of `α` that is open, if `a` is an element of `s`, then the "neighborhood within" filter of `a` with respect to `s`, denoted by `nhdsWithin a s`, is equal to the neighborhood filter at `a`, denoted by `nhds a`. In other words, if `s` is an open set containing the point `a`, then the neighborhood of `a` within `s` is just the same as the general neighborhood of `a`.

For any topological space `α`, point `a` in `α`, and open set `s` in `α`, if `a` belongs to `s`, then `nhdsWithin a s` equals `nhds a`.


theorem MeasurableSet.induction_on_open :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : BorelSpace α]
      {C : Set α → Prop},
      (∀ (U : Set α), IsOpen U → C U) →
        (∀ (t : Set α), MeasurableSet t → C t → C tᶜ) →
          (∀ (f : ℕ → Set α),
              Pairwise (Disjoint on f) → (∀ (i : ℕ), MeasurableSet (f i)) → (∀ (i : ℕ), C (f i)) → C (⋃ i, f i)) →
            ∀ ⦃t : Set α⦄, MeasurableSet t → C t :=
  by sorry

This theorem is a principle of induction on open sets in a Borel space (a measurable space derived from a topological space). Given a property `C` of sets, if `C` holds for all open sets, the complement of all measurable sets `t` for which `C` holds, and for all countable unions of pairwise disjoint measurable sets, then `C` holds for all measurable sets.

In more detail: for a given topological space `α` equipped with a Borel measurable space structure, we suppose we have a property `C` of subsets of `α`. If the following conditions are met:
1. `C` holds for all open subsets of `α`,
2. for any measurable set `t` for which `C` holds, `C` also holds for the complement of `t`, and
3. if `f` is a sequence of measurable sets which are pairwise disjoint and for which `C` holds, then `C` also holds for the countable union of the sets in the sequence,

then the conclusion is that `C` holds for every measurable subset of `α`.

If a property `C` holds for all open sets, their complements in measurable sets, and countable unions of pairwise disjoint measurable sets in a Borel space, then `C` holds for all measurable sets.


/-- Moving to the opposite additive commutative monoid commutes with summing.  -/
theorem Finset.op_sum :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {s : Finset α} (f : α → β),
      MulOpposite.op (Finset.sum s fun x => f x) = Finset.sum s fun x => MulOpposite.op (f x) :=
  by sorry

The theorem `Finset.op_sum` states that for any additive commutative monoid `β`, any finite set `s` of type `α`, and any function `f` from `α` to `β`, moving to the opposite monoid (i.e., reversing the operation) after summing the function `f` over all elements of the set `s` is equal to summing the function `f` applied to the opposite monoid over all elements of the set `s`. In other words, the operation of summing commutes with the operation of taking the opposite in the context of additive commutative monoids.

For any additive commutative monoid β, finite set s of type α, and function f from α to β, the opposite of the sum of f over s is equal to the sum of f over s applied to the opposite monoid.


theorem NNReal.sqrt_le_sqrt : ∀ {x y : NNReal}, NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y := by sorry

This theorem states that for any two nonnegative real numbers `x` and `y`, the square root of `x` is less than or equal to the square root of `y` if and only if `x` is less than or equal to `y`. In other words, the square root function on the nonnegative real numbers preserves the order of its inputs.

For all non-negative real numbers x and y, x ≤ y if and only if √x ≤ √y.


/-- A subgroup is closed under division.  -/
theorem div_mem :
    ∀ {M : Type u_5} {S : Type u_6} [inst : DivInvMonoid M] [inst_1 : SetLike S M] [hSM : SubgroupClass S M] {H : S}
      {x y : M}, x ∈ H → y ∈ H → x / y ∈ H :=
  by sorry

This theorem states that a subgroup is closed under division. Specifically, for any type `M` equipped with a division and inverse operation (a `DivInvMonoid`), any set-like structure `S` over `M`, and any `SubgroupClass` `hSM` for `S` and `M`, if `x` and `y` are elements of a subgroup `H` of `S`, then the result of dividing `x` by `y` is also an element of the subgroup `H`.

If `M` is a type with division and inverse operations, `S` is a set-like structure over `M`, `hSM` is a subgroup class for `S` and `M`, and `H` is a subgroup of `S`, then for all `x, y in H`, `x / y is an element of H`.


theorem Matrix.vecMul_one :
    ∀ {m : Type u_2} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (v : m → α),
      Matrix.vecMul v 1 = v :=
  by sorry

The theorem `Matrix.vecMul_one` asserts that for any type `m`, and a type `α` that is a non-associative semiring, given the finite nature of `m` and the existence of a decidable equality on `m`, the result of multiplying a vector `v` (which is a function from `m` to `α`) by the identity matrix equals the original vector `v`. In other words, it states that the multiplication of any vector by the identity matrix doesn't alter the vector, which corresponds to a common property in linear algebra.

For any finite type `m` and non-associative semiring type `α`, the multiplication of a vector `v` by the identity matrix is equal to `v` itself.


/-- A monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsSup` to the `Filter.limsup` of the image if the function is continuous at the `limsSup`
(and the filter is bounded from above and below).  -/
theorem Monotone.map_limsSup_of_continuousAt :
    ∀ {R : Type u_4} {S : Type u_5} [inst : ConditionallyCompleteLinearOrder R] [inst_1 : TopologicalSpace R]
      [inst_2 : OrderTopology R] [inst_3 : ConditionallyCompleteLinearOrder S] [inst_4 : TopologicalSpace S]
      [inst_5 : OrderTopology S] {F : Filter R} [inst_6 : Filter.NeBot F] {f : R → S},
      Monotone f →
        ContinuousAt f (Filter.limsSup F) →
          autoParam (Filter.IsBounded (fun x x_1 => x ≤ x_1) F) _auto✝ →
            autoParam (Filter.IsBounded (fun x x_1 => x ≥ x_1) F) _auto✝¹ → f (Filter.limsSup F) = Filter.limsup f F :=
  by sorry

This theorem states that for any monotone function `f` that maps from one conditionally complete linear ordered space `R` to another `S`, if `f` is continuous at the least upper bound (`limsSup`) of a filter `F` in `R` and `F` is bounded from above and below, then the value of `f` at the `limsSup` of `F` equals the greatest lower bound (`limsup`) of the image of `F` under `f` in `S`. This theorem involves the concepts of filter theory, topology and order structures in the context of mathematical analysis.

If `f` is a monotone, continuous function from the conditionally complete, linearly ordered space `R` to another such space `S`, and `F` is a filter in `R` with a supremum `x` in `R` and an upper bound `y` in `S`, then `f(x) = sup (f(G))`, where `G` is the set of limits of `F`.


theorem isLeast_singleton : ∀ {α : Type u} [inst : Preorder α] {a : α}, IsLeast {a} a := by sorry

The theorem `isLeast_singleton` states that for any type `α` that has a Preorder (a type of partial order), and for any element `a` of this type, `a` is a least element of the singleton set `{a}`. In other words, `a` is both a member of the set `{a}` and a lower bound of the set `{a}` in the given preorder.

For any type `α` with a preorder and any element `a` in `α`, `a` is the least element of the singleton set `{a}`.


theorem le_inv : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (a ≤ b⁻¹ ↔ b ≤ a⁻¹) := by
  sorry

This theorem, `le_inv`, states that for any linear ordered semifield `α` and any two elements `a` and `b` of `α` that are greater than 0, `a` is less than or equal to the inverse of `b` if and only if `b` is less than or equal to the inverse of `a`. This is a property intrinsic to the structure of linear ordered semifields.

For any linear ordered semifield `α`, and elements `a, b` in `α` with `0 < a, b`, we have `a ≤ b^⁻¹` if and only if `b ≤ a^⁻¹`.


theorem Real.sqrt_le_left : ∀ {x y : ℝ}, 0 ≤ y → (Real.sqrt x ≤ y ↔ x ≤ y ^ 2) := by sorry

The theorem `Real.sqrt_le_left` states that for any two real numbers `x` and `y`, if `y` is greater or equal to zero, then the square root of `x` is less than or equal to `y` if and only if `x` is less than or equal to the square of `y`. In mathematical terms, for all real numbers x and y with y ≥ 0, √x ≤ y if and only if x ≤ y².

For all real numbers x and y with y ≥ 0, √x ≤ y if and only if x ≤ y² (i.e., the square root of x is less than or equal to y if and only if x is less than or equal to the square of y).


theorem Traversable.foldMap_hom_free :
    ∀ {α β : Type u} {t : Type u → Type u} [inst : Traversable t] [inst_1 : LawfulTraversable t] [inst_2 : Monoid β]
      (f : FreeMonoid α →* β) (x : t α),
      f (Traversable.foldMap FreeMonoid.of x) = Traversable.foldMap (⇑f ∘ FreeMonoid.of) x :=
  by sorry

The theorem `Traversable.foldMap_hom_free` states that for any types `α` and `β`, and a type `t` that is an instance of `Traversable`, if `t` is also `LawfulTraversable` and `β` is a `Monoid`, and `f` is a Monoid homomorphism from `FreeMonoid α` to `β`, and `x` is of type `t α`, then applying `f` to the result of `Traversable.foldMap` of `FreeMonoid.of` and `x` is equivalent to applying `Traversable.foldMap` to the composition of `f` and `FreeMonoid.of` and `x`. Here, `Traversable.foldMap` is a function that combines all data in a traversable structure by using a supplied function, and `FreeMonoid.of` is a function that converts an element to a free monoid over its type.

In simpler terms, this theorem shows a relationship between the folding and mapping operations in a free monoid and a monoid, which says that you can either first map and then fold, or first fold and then map, and the result will be the same. This is a property of monoids and how they interact with traversable structures.

For any `Traversable t`, `Monoid β`, `LawfulTraversable t`, Monoid homomorphism `f` from `FreeMonoid α` to `β`, and `x` of type `t α`, `Traversable.foldMap (f . FreeMonoid.of) x = Traversable.foldMap (FreeMonoid.of) x . f`.


theorem IsAdjoinRoot.lift_map :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      {T : Type u_1} [inst_3 : CommRing T] {i : R →+* T} {x : T} (hx : Polynomial.eval₂ i x f = 0)
      (h : IsAdjoinRoot S f) (z : Polynomial R), (IsAdjoinRoot.lift i x hx h) (h.map z) = Polynomial.eval₂ i x z :=
  by sorry

The theorem `IsAdjoinRoot.lift_map` states that for any two types `R` and `S` with `R` being a commutative ring and `S` a ring, a given polynomial `f` of `R`, an algebra structure on `R` and `S`, another type `T` with a commutative ring structure, a ring homomorphism `i` from `R` to `T`, and an element `x` in `T` such that the evaluation of polynomial `f` at `x` via ring homomorphism `i` is zero (`hx`), if `f` is an adjoined root in `S` (`h`), then for any polynomial `z` of `R`, the evaluation of the polynomial `z` with the lift of the adjoined root (`IsAdjoinRoot.lift i x hx h`) and its mapping (`h.map z`) is equal to the evaluation of polynomial `z` at `x` via ring homomorphism `i` (`Polynomial.eval₂ i x z`). In simpler terms, this theorem relates the operations of adjoined root lifting and polynomial evaluation.

Given a commutative ring R, a ring S, a polynomial f in R, an algebra structure on R and S, a commutative ring T, a ring homomorphism i from R to T, an element x in T such that i(f(x)) = 0 and f is an adjoined root in S, then for any polynomial z in R, the evaluation of z at x via i is equal to the evaluation of z with the lifted adjoined root and its mapping.


theorem div_neg :
    ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] {b : K} (a : K), a / -b = -(a / b) := by sorry

This theorem states that for any type `K` that forms a division monoid and supports the distribution of negation, the division of an element `a` by the negation of an element `b` is equal to the negation of the division of `a` by `b`. In mathematical terms, it's asserting that `a / -b = -(a / b)` for all elements `a` and `b` in `K`.

For any type `K` that forms a division monoid and supports the distribution of negation, the division of an element by the negation of another element is equal to the negation of their quotient: `a / -b = -(a / b)`.


Measurable.div

theorem Measurable.div :
    ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : Div G] {m : MeasurableSpace α} {f g : α → G}
      [inst_2 : MeasurableDiv₂ G], Measurable f → Measurable g → Measurable fun a => f a / g a :=
  by sorry

The theorem `Measurable.div` states that for any type `G` with a `MeasurableSpace` and `Div` structures, and any type `α` with a `MeasurableSpace` structure, if `f` and `g` are two functions from `α` to `G` and `G` has a `MeasurableDiv₂` structure, then the function that takes an element `a` from `α` and maps it to the result of `f(a)` divided by `g(a)` (denoted as `f a / g a`), is also a measurable function. In other words, the division of two measurable functions is also measurable.

If `f` and `g` are measurable functions from a measurable space `α` to a MeasurableSpace `G` with a MeasurableDiv₂ structure, then the function `x ↦ f x / g x` is measurable.


theorem Equiv.optionCongr_refl : ∀ {α : Type u_1}, Equiv.optionCongr (Equiv.refl α) = Equiv.refl (Option α) := by sorry

The theorem `Equiv.optionCongr_refl` states that for any type `α`, the application of the `Equiv.optionCongr` function (which maps an equivalence between types `α` and `β` to an equivalence between `Option α` and `Option β`) to the identity equivalence `Equiv.refl α` (which is an equivalence between a type `α` and itself) is equivalent to the identity equivalence `Equiv.refl (Option α)` (which is an equivalence between `Option α` and itself). In other words, this theorem is saying that mapping a type to the corresponding option type, when the original map is the identity map, results in the identity map on the option types.

The theorem `Equiv.optionCongr_refl` asserts that the application of `Equiv.optionCongr` to the identity equivalence on type `α` results in the identity equivalence on `Option α`.


theorem List.getLast_append :
    ∀ {α : Type u_1} {a : α} (l : List α) (h : l ++ [a] ≠ []), List.getLast (l ++ [a]) h = a := by sorry

The theorem `List.getLast_append` states that for any type `α`, any element `a` of type `α` and any list `l` of elements of type `α`, if the list that is the result of appending `a` to `l` is not empty, then the last element of this appended list is `a`. In other words, when you append an element to the end of a list, that element becomes the last element of the new list.

For any type `α` and list `l` of length `n+1` in `α`, if `List.append a l` is non-empty, then `last (List.append a l) = a`.


theorem continuous_inf :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Inf L] [inst_2 : ContinuousInf L],
      Continuous fun p => p.1 ⊓ p.2 :=
  by sorry

This theorem states that for any type `L` that is equipped with a topology (i.e., `L` is a topological space) and has an infimum operation (denoted by `⊓`), if the infimum operation is continuous, then the function that takes a pair `p` of elements from `L` and returns their infimum `p.1 ⊓ p.2` is also continuous. In other words, if `L` is a topological space where the "greatest lower bound" operation is continuous, then applying this operation to any pair of elements is a continuous operation.

If `L` is a topological space with a continuous infimum operation, then the function `λ p: L × L, p.1 ⊓ p.2` is continuous from `L × L` to `L`.


theorem Filter.le_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {g : Filter β}, (∀ s ∈ f, m '' s ∈ g) → g ≤ Filter.map m f :=
  by sorry

This theorem, named `Filter.le_map`, states that for every types `α` and `β`, every filter `f` on `α`, every function `m` from `α` to `β`, and every filter `g` on `β`, if for every set `s` in the filter `f`, the image of `s` under `m` is in the filter `g`, then `g` is less than or equal to the filter obtained by forward mapping the filter `f` using `m`. In other words, if all the images of the sets in `f` under `m` are in `g`, then `g` includes all the sets that could possibly be obtained by applying `m` to the sets in `f`.

If a filter `f` on `α` maps to a filter `g` on `β` via a function `m` such that every set in `f` maps to a set in `g`, then `g` is less than or equal to the filter obtained by applying `m` to `f`.


theorem intervalIntegral.integral_sub :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f g : ℝ → E}
      {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b →
        IntervalIntegrable g μ a b →
          ∫ (x : ℝ) in a..b, f x - g x ∂μ = ∫ (x : ℝ) in a..b, f x ∂μ - ∫ (x : ℝ) in a..b, g x ∂μ :=
  by sorry

The theorem named `intervalIntegral.integral_sub` states that for any interval integrable functions `f` and `g` with respect to a measure `μ` on an unordered interval `a..b`, the difference between the integrals of these two functions over the interval `a..b` can be expressed as the integral of the difference of these functions over the same interval.

More formally, given a normed additively commutative group `E` and a normed space over the real numbers `ℝ` and `E`, and given two real-valued functions `f` and `g` that are interval integrable in the interval `a..b` with respect to a measure `μ`, the equality ∫ (x : ℝ) in a..b, f x - g x ∂μ = ∫ (x : ℝ) in a..b, f x ∂μ - ∫ (x : ℝ) in a..b, g x ∂μ holds. This is the integral analogue of the fact that the difference of the sum of two numbers is equal to the sum of their differences.

The theorem `intervalIntegral.integral_sub` asserts that the integral of the difference of two interval integrable functions `f` and `g` over an interval `a..b` equals the difference of their integrals over the same interval with respect to measure `μ`.


theorem Multiset.powersetCard_coe :
    ∀ {α : Type u_1} (n : ℕ) (l : List α),
      Multiset.powersetCard n ↑l = ↑(List.map Multiset.ofList (List.sublistsLen n l)) :=
  by sorry

The theorem `Multiset.powersetCard_coe` states that for any type `α`, any natural number `n`, and any list `l` of elements of type `α`, the multiset of all submultisets of the multiset formed from `l` that have length `n` is equal to the multiset formed from mapping the function `Multiset.ofList` (which converts lists to multisets) over the list of all sublists of `l` of length `n`. In essence, it relates the powerset of a multiset of a fixed size to the sublists of the corresponding list.

For any type `α` and natural number `n`, the multiset of submultisets of size `n` from a multiset formed by `α` values is equal to the multiset of multisets obtained by applying `Multiset.ofList` to all sublists of length `n` from any list representing that multiset.


theorem Real.continuousAt_log : ∀ {x : ℝ}, x ≠ 0 → ContinuousAt Real.log x := by sorry

This theorem states that the real logarithm function is continuous at any point `x` in the real numbers, given that `x` is not equal to 0. In mathematical terms, this means that for any real number `x` different from 0, the real logarithm function `log(x)` approaches the limit of `log(x₀)` when `x` approaches `x₀`. This continuity statement is a fundamental property of the logarithm function in real analysis.

For any non-zero real number `x`, the real logarithm function is continuous at `x`.


theorem Complex.cpow_eq_zero_iff : ∀ (x y : ℂ), x ^ y = 0 ↔ x = 0 ∧ y ≠ 0 := by sorry

This theorem in complex analysis states that for any two complex numbers `x` and `y`, `x` raised to the power `y` equals zero if and only if `x` equals zero and `y` is not equal to zero. In other words, the only way a complex number raised to the power of another complex number can result in zero is if the base number is zero and the exponent is a non-zero number. This theorem relates the conditions under which a power operation with complex numbers yields zero.

For complex numbers x and y, x^y = 0 if and only if x = 0 and y ≠ 0.


theorem Nat.eq_zero_of_zero_dvd : ∀ {a : ℕ}, 0 ∣ a → a = 0 := by sorry

This theorem states that for any natural number `a`, if `0` divides `a`, then `a` must be equal to `0`. In the language of number theory, if a number is divisible by zero, it must be zero itself.

If 0 divides a natural number a, then a equals 0.


/-- **Alias** of `smul_lt_smul_of_pos_left`. -/
theorem smul_lt_smul_of_pos :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulStrictMono α β], b₁ < b₂ → 0 < a → a • b₁ < a • b₂ :=
  by sorry

This theorem, `smul_lt_smul_of_pos`, is an alias of `smul_lt_smul_of_pos_left`. It states that, given any two types `α` and `β`, along with elements `a` of type `α` and `b₁, b₂` of type `β`, and assuming that `α` and `β` have a scalar multiplication operation, a preorder relation, a concept of zero, and a strictly monotonic positive scalar multiplication, then if `b₁` is less than `b₂` and `a` is positive, the result of scaling `b₁` by `a` will be less than the result of scaling `b₂` by `a`. In mathematical notation, this theorem asserts that if $b_1 < b_2$ and $0 < a$, then $a \cdot b_1 < a \cdot b_2$.

Given types `α` and `β` with scalar multiplication, a preorder relation, zero, and strictly monotonic positive scalars, if `0 < a` and `b₁ < b₂` hold, then `a * b₁ < a * b₂`.


Subsingleton.measurable

theorem Subsingleton.measurable :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : Subsingleton α], Measurable f :=
  by sorry

The theorem `Subsingleton.measurable` states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `α` is a subsingleton type and both `α` and `β` are measurable spaces, then the function `f` is measurable. A type is a subsingleton if it has at most one element, and a function is measurable if the preimage of every measurable set is measurable. This means that for every measurable set in the codomain, the set of all elements in the domain that map to that set is also measurable.

If `α` is a subsingleton type and both `α` and `β` are measurable spaces, then the function `f` from `α` to `β` is measurable.


theorem MeasureTheory.Measure.toENNRealVectorMeasure_apply_measurable :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {i : Set α},
      MeasurableSet i → ↑(MeasureTheory.Measure.toENNRealVectorMeasure μ) i = ↑↑μ i :=
  by sorry

This theorem states that for any type `α`, any `MeasurableSpace α`, any measure `μ` of type `MeasureTheory.Measure α`, and any set `i` of type `Set α`, if `i` is a measurable set, then applying the function `MeasureTheory.Measure.toENNRealVectorMeasure` to the measure `μ` and then applying the result to `i` is equivalent to applying the measure `μ` to `i` and then lifting it twice to the extended non-negative reals (`↑↑μ i`). In other words, converting a measure to an extended non-negative real vector measure doesn't change the measure of a measurable set.

For any measurable set `i` of type `α` in a measurable space `α` with measure `μ`, the extended non-negative real vector measure `MeasureTheory.Measure.toENNRealVectorMeasure μ` applied to `i` equals the measure `μ` applied to `i` lifted twice to the extended non-negative reals (`↑↑μ i`).


theorem sub_lt_sub_left :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      a < b → ∀ (c : α), c - b < c - a :=
  by sorry

The theorem `sub_lt_sub_left` states that for any type `α` that forms an additive group and has a less-than operation, which also satisfies the covariant properties pertaining to both addition and the less-than operation, if `a` and `b` are elements of `α` such that `a < b`, then for every element `c` of `α`, `c - b` is less than `c - a`. In other words, if `a` is less than `b`, subtracting `b` from any number `c` will result in a value less than that obtained by subtracting `a` from `c`. This is similar to the property of real numbers where if `a < b`, then for every `c`, we have `c - b < c - a`.

For all additive groups with a covariant less-than relation, if `a < b`, then for all `c`, `c - b < c - a`.


theorem fourier_apply : ∀ {T : ℝ} {n : ℤ} {x : AddCircle T}, (fourier n) x = ↑(AddCircle.toCircle (n • x)) := by sorry

The theorem `fourier_apply` states that for any real number `T`, any integer `n` and any element `x` from the additive circle defined by `T`, the application of the `n`-th Fourier monomial to `x` is equal to the canonical map applied to the `n`-fold multiple of `x` in the additive circle defined by `T`. In mathematical terms, this states that for every point on the additive circle, its projection onto the complex plane under the Fourier transform corresponds to its projection under the canonical map.

For any real number T, integer n, and additive circle element x, the n-th Fourier monomial applied to x equals the canonical map of the n-fold multiplication of x in the additive circle T.


theorem List.perm_mergeSort :
    ∀ {α : Type uu} (r : α → α → Prop) [inst : DecidableRel r] (l : List α), List.Perm (List.mergeSort r l) l := by
  sorry

The theorem `List.perm_mergeSort` states that for any type `α`, any decidable relation `r` on `α`, and any list `l` of elements of type `α`, the list obtained by performing a merge sort on `l` using the relation `r` is a permutation of `l`. In other words, merge sort rearranges the elements of the original list `l` without adding or removing elements.

For any type `α` and decidable relation `r` on `α`, the merge sort function on a list `l` using relation `r` results in a permutation of `l`.


theorem ENNReal.add_ne_top : ∀ {a b : ENNReal}, a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ := by sorry

The theorem `ENNReal.add_ne_top` states that for any two extended nonnegative real numbers `a` and `b`, the sum of `a` and `b` is not equal to positive infinity if and only if neither `a` nor `b` are equal to positive infinity. In other words, positive infinity can only be resulted from the sum if at least one of the summands is positive infinity.

For extended nonnegative real numbers `a` and `b`, the sum `a + b` is not positive infinity if and only if neither `a` nor `b` are positive infinity.


theorem Turing.BlankExtends.above_of_le :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] {l l₁ l₂ : List Γ},
      Turing.BlankExtends l₁ l →
        Turing.BlankExtends l₂ l → List.length l₁ ≤ List.length l₂ → Turing.BlankExtends l₁ l₂ :=
  by sorry

The theorem `Turing.BlankExtends.above_of_le` asserts that for any type `Γ` that is inhabited, and for any lists `l`, `l₁`, and `l₂` of type `Γ`, if `l` can be obtained by adding blanks to the end of `l₁` (denoted by `Turing.BlankExtends l₁ l`) and to the end of `l₂` (denoted by `Turing.BlankExtends l₂ l`), and if the length of `l₁` is less than or equal to the length of `l₂` (`List.length l₁ ≤ List.length l₂`), then `l₂` can be obtained by adding blanks to the end of `l₁` (denoted by `Turing.BlankExtends l₁ l₂`). This theorem is relevant in the context of Turing machines, where "adding blanks to the end of a list" can be interpreted as extending the tape of the machine to the right.

If `Γ` is inhabited and `l₁`, `l₂` are lists of type `Γ` such that `l` is obtained by extending `l₁` and `l₂` with blanks, and the length of `l₁` is less than or equal to that of `l₂`, then `l₂` can be obtained by extending `l₁` with blanks.


theorem Ordinal.enumOrd_mem :
    ∀ {S : Set Ordinal.{u}}, Set.Unbounded (fun x x_1 => x < x_1) S → ∀ (o : Ordinal.{u}), Ordinal.enumOrd S o ∈ S := by
  sorry

This theorem states that for any set `S` of ordinals (`Ordinal.{u}`), if `S` is unbounded (which means that for any ordinal `a`, there exists an ordinal `b` in `S` such that `b` is not less than `a`), then for any ordinal `o`, the ordinal `o` enumerated by the `Ordinal.enumOrd` function from the set `S` is an element of `S`. Essentially, it ensures that any ordinal obtained by enumerating from an unbounded set of ordinals is a member of that set.

If `S` is an unbounded set of ordinals, then for any ordinal `o`, `o` is in `S` if and only if `o` is enumerated by `Ordinal.enumOrd` from `S`.


theorem List.mem_reverse : ∀ {α : Type u_1} {x : α} {as : List α}, x ∈ List.reverse as ↔ x ∈ as := by sorry

This theorem, `List.mem_reverse`, states that for any type `α`, any element `x` of type `α`, and any list `as` of type `α`, the membership of `x` in the reversed list `List.reverse as` is equivalent to the membership of `x` in the original list `as`. In other words, reversing the list does not affect the presence of an element in the list.

For any type `α` and list `as` of type `α`, the element `x` belongs to the reversed list `List.reverse as` if and only if it belongs to the original list `as`.


/-- The affine span of a single point, coerced to a set, contains just that point.  -/
theorem AffineSubspace.coe_affineSpan_singleton :
    ∀ (k : Type u_1) (V : Type u_2) {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] (p : P), ↑(affineSpan k {p}) = {p} :=
  by sorry

The theorem `AffineSubspace.coe_affineSpan_singleton` states that the affine span of a single point, when coerced to a set, contains only that point. This is applicable across any ring `k`, additive commutative group `V`, and module `k V`, where `P` is an add-torsor over `V`. In other words, when the affine span operation is applied to a set containing just one point `p`, and the resultant affine subspace is transformed to a set, it's equal to the original singleton set `{p}`.

The theorem `AffineSubspace.coe_affineSpan_singleton` asserts that the set representation of the affine span of a single point is equal to that point itself.


theorem ceilDiv_of_nonpos :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : CeilDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌈/⌉ a = 0 :=
  by sorry

The theorem `ceilDiv_of_nonpos` states that for any types `α` and `β`, given that they are ordered additive commutative monoids, and α is a scalar multiplication zero class, and there exists a ceiling division operation for α and β, if a value `a` of type `α` is less than or equal to 0, then the ceiling division of any value `b` of type `β` by `a` is equal to 0.

For any ordered additive commutative monoids types `α` and `β` with `α` being a scalar multiplication zero class, if there exists a ceiling division operation for `α` and `β`, then for any `a` of type `α` less than or equal to 0 and any `b` of type `β`, their ceiling division `b / a` equals 0.


theorem mul_zsmul : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (m n : ℤ), (m * n) • a = m • n • a := by sorry

This theorem, `mul_zsmul`, states that for any type `α` that is a subtraction monoid, and any element 'a' of this type along with two integers 'm' and 'n', the operation of scalar multiplication of 'a' by the product of 'm' and 'n' is equivalent to first scalar multiplying 'a' by 'n' and then scalar multiplying the result by 'm'. That is, `(m * n) • a` is equal to `m • n • a`. This theorem illustrates an important property of integers and subtraction monoids, essentially a kind of associativity that involves integer multiplication and scalar multiplication.

For any subtraction monoid type `α` and elements `a`, `m`, and `n`, `(m * n) • a` equals `m • (n • a)`.


theorem Squarefree.squarefree_of_dvd :
    ∀ {R : Type u_1} [inst : CommMonoid R] {x y : R}, x ∣ y → Squarefree y → Squarefree x := by sorry

The theorem states that for any given commutative monoid `R` and any two elements `x` and `y` of `R`, if `x` divides `y` and `y` is squarefree (meaning the only squares that divide it are the squares of units), then `x` is also squarefree. In mathematical terms, if $x | y$ and $y$ is squarefree, then $x$ is squarefree as well.

If a commutative monoid element `x` divides a squarefree element `y`, then `x` is also squarefree.


theorem Cardinal.power_zero : ∀ {a : Cardinal.{u_1}}, a ^ 0 = 1 := by sorry

This theorem, denoted as `Cardinal.power_zero`, states that for any cardinal number `a`, raising `a` to the power of `0` results in `1`. In mathematical terms, for any cardinal number \(a\), \(a^0 = 1\). Equivalently, it asserts that the zeroth power of any cardinal number is always equal to the cardinal number `1`.


theorem Matrix.cons_fin_one : ∀ {α : Type u} (x : α) (u : Fin 0 → α), Matrix.vecCons x u = fun x_1 => x := by sorry

The theorem `Matrix.cons_fin_one` states that for all types `α`, given an element `x` of type `α` and a function `u` from `Fin 0` to `α`, applying the function `Matrix.vecCons` to `x` and `u` results in a function that maps any input to `x`. In other words, this theorem states that when you create a vector by prepending `x` to a vector of zero length (which is represented by the function `u`), you obtain a vector where every element is `x`.

For any type `α` and element `x` of `α`, the function obtained by prepending `x` to the empty vector using `Matrix.vecCons` is the constant function mapping every index to `x`.


theorem NNReal.hasSum_coe : ∀ {α : Type u_1} {f : α → NNReal} {r : NNReal}, HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r :=
  by sorry

This theorem states that for any type `α` and any function `f` from `α` to non-negative real numbers (`NNReal`), and any nonnegative real number `r`, the function `f` has a sum equal to `r` if and only if the function obtained by applying the coercion function (which converts nonnegative real numbers to real numbers) to `f` also has a sum equal to the coercion of `r`. In other words, if you sum the outputs of the function `f` and get `r`, then if you convert all the outputs of `f` and `r` to real numbers and then sum, you should still get the same sum.

For any function `f` from type `α` to non-negative real numbers `NNReal` and any `r` in `NNReal`, the condition that `∑x:α. f x = r` if and only if `∑x:α. coe to Real (f x) = coe to Real r` holds.


theorem Set.toFinset_compl :
    ∀ {α : Type u_1} (s : Set α) [inst : DecidableEq α] [inst_1 : Fintype ↑s] [inst_2 : Fintype α]
      [inst_3 : Fintype ↑sᶜ], Set.toFinset sᶜ = (Set.toFinset s)ᶜ :=
  by sorry

The theorem `Set.toFinset_compl` states that for any type `α` and any set `s` of type `α`, given that `α` has decidable equality, the set `s` and the type `α` both have finite types, and the complement of `s` also has a finite type, the `Finset` corresponding to the complement of `s` is equal to the complement of the `Finset` corresponding to `s`. In simpler terms, converting the complement of a set to a finite set is the same as taking the complement of the finite set derived from the original set.

For any decidably equal and finite type `α` with a finite set `s`, the finite set of elements not in `s` is equal to the complement of the finite set `Finset.univ s`.


theorem MeasureTheory.analyticSet_range_of_polishSpace :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_3} [inst_1 : TopologicalSpace β] [inst_2 : PolishSpace β]
      {f : β → α}, Continuous f → MeasureTheory.AnalyticSet (Set.range f) :=
  by sorry

This theorem states that for any two types `α` and `β` which have topological space structures, where `β` additionally is a Polish space, and given a function `f` from `β` to `α` that is continuous, the range of `f` (the set of all possible outputs of `f`) is an analytic set. Here, a Polish space is a complete, separable metric space, and an analytic set in a topological space is a projection of a Borel set in a higher-dimensional space.

Given two topological spaces `α` and `β` where `β` is a Polish space, and a continuous function `f` from `β` to `α`, the range of `f` is an analytic subset of `α`.


LatticeHom.ext

theorem LatticeHom.ext :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] {f g : LatticeHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `LatticeHom.ext`, states that for any two lattice homomorphisms `f` and `g` from a lattice `α` to a lattice `β`, if `f` and `g` map any element `a` of `α` to the same element in `β`, then `f` and `g` are the same lattice homomorphism. In other words, two lattice homomorphisms are equal if they have the same action on all elements of the domain lattice.

If two lattice homomorphisms from a lattice to another lattice map every element to the same image, then they are equal.


padicValRat.mul

/-- A rewrite lemma for `padicValRat p (q * r)` with conditions `q ≠ 0`, `r ≠ 0`.  -/
theorem padicValRat.mul :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ},
      q ≠ 0 → r ≠ 0 → padicValRat p (q * r) = padicValRat p q + padicValRat p r :=
  by sorry

This theorem, `padicValRat.mul`, states that for any prime number `p` and any two non-zero rational numbers `q` and `r`, the valuation of the product of `q` and `r` with respect to `p` is the sum of the valuation of `q` with respect to `p` and the valuation of `r` with respect to `p`. In other words, if $p$ is a prime number, and $q, r$ are non-zero rational numbers, then $v_p(qr) = v_p(q) + v_p(r)$, where $v_p$ denotes the $p$-adic valuation.

For any prime number $p$ and non-zero rational numbers $q$ and $r$, the $p$-adic valuation of their product $v\_p(qr)$ equals the sum of the $p$-adic valuations of $q$ and $r$, $v\_p(q) + v\_p(r)$.


theorem Ideal.mem_span_singleton' : ∀ {α : Type u} [inst : Semiring α] {x y : α}, x ∈ Ideal.span {y} ↔ ∃ a, a * y = x :=
  by sorry

This theorem states that for any semiring `α`, and any elements `x` and `y` of `α`, `x` is in the ideal generated by `{y}` if and only if there exists an element `a` in `α` such that `a * y = x`. In other words, an element `x` is in the ideal spanned by `y` if `x` can be expressed as a multiple of `y`.

For any semiring `α` and elements `x, y` in `α`, `x` belongs to the ideal generated by `{y}` if and only if there exists an element `a` in `α` such that `x = a * y`.


theorem SeparationQuotient.inducing_mk : ∀ {X : Type u_1} [inst : TopologicalSpace X], Inducing SeparationQuotient.mk :=
  by sorry

This theorem states that for any type `X` equipped with a topology (denoted by `[inst : TopologicalSpace X]`), the natural map from the topological space `X` to its separation quotient (`SeparationQuotient.mk`) is an inducing function. In the context of topology, an inducing function is one that, given the topology on the target space, induces the topology on the source space. This implies that the topology on `X` is the coarsest topology making `SeparationQuotient.mk` continuous.

Given a topological space `(X : Type)` with topology `[inst : TopologicalSpace X]`, the natural map from `X` to its separation quotient `SeparationQuotient.mk X` is a topology-inducing function.


BoundarylessManifold.isInteriorPoint

theorem BoundarylessManifold.isInteriorPoint :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : BoundarylessManifold I M]
      {x : M}, ModelWithCorners.IsInteriorPoint I x :=
  by sorry

This theorem states that for any point `x` in a boundaryless manifold `M` (equipped with a topological structure), the point is an interior point according to the model with corners `I`. More formally, given a nontrivial normed field `𝕜`, a normed additive commutative group `E`, a topological space `H`, and a model with corners `I` that associates these structures, any point `x` in a boundaryless manifold `M` (that is modeled on the space `H` with the model `I`) is an interior point as per the definition given by the model with corners `I`.

Any point in a boundaryless manifold modeled on a normed additive commutative group with a topology using a model with corners is an interior point according to the model.


theorem SetTheory.PGame.le_congr : ∀ {x₁ y₁ x₂ y₂ : SetTheory.PGame}, x₁ ≈ x₂ → y₁ ≈ y₂ → (x₁ ≤ y₁ ↔ x₂ ≤ y₂) := by
  sorry

This theorem, `SetTheory.PGame.le_congr`, states that for any four games `x₁`, `y₁`, `x₂`, and `y₂` from the set theory of games, if game `x₁` is equivalent to game `x₂` and game `y₁` is equivalent to game `y₂`, then game `x₁` is less than or equal to game `y₁` if and only if game `x₂` is less than or equal to game `y₂`. This implies that the relative order of games is preserved under equivalence.

For all games x₁, y₁, x₂, and y₂, if x₁ ≈ x₂ and y₁ ≈ y₂ then x₁ ≤ y₁ if and only if x₂ ≤ y₂, where ≈ denotes equivalence in the set theory of games.


theorem Mathlib.Analysis.Calculus.FDeriv.Basic._auxLemma.18 :
    ∀ {𝕜 : 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] {x : E}
      (c : F), DifferentiableAt 𝕜 (fun x => c) x = True :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed add commutative group `E`, normed space of `E` over `𝕜`, normed add commutative group `F`, normed space of `F` over `𝕜`, and any element `x` of `E`, and any element `c` of `F`, the function that maps every element `x` of `E` to `c` of `F` is always differentiable at `x`. In other words, constant functions are always differentiable, regardless of the point at which their derivative is evaluated.

For any non-trivially normed fields `𝕜`, and normed spaces `E` over `𝕜` and `F`, the constant function from `E` to `F` is differentiable.


theorem MonoidHom.coe_mrange :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f : F), ↑(MonoidHom.mrange f) = Set.range ⇑f :=
  by sorry

The theorem `MonoidHom.coe_mrange` states that for any given monoid homomorphism `f` of type `F`, where `F` is a function-like object from a monoid `M` to another monoid `N`, the coimage of the range of `f` under the natural embedding from a submonoid of `N` into `N` itself, is equal to the set of images of `f`. In other words, it asserts that the set of all the values we can get by applying the monoid homomorphism to elements of 'M' is exactly the same as the range of the function `f`.

The coimage of the range of a monoid homomorphism under the natural embedding is equal to the image of the homomorphism.


theorem Finset.sup_image₂_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
      (t : Finset β) [inst_1 : SemilatticeSup δ] [inst_2 : OrderBot δ] (g : γ → δ),
      Finset.sup (Finset.image₂ f s t) g = Finset.sup t fun y => Finset.sup s fun x => g (f x y) :=
  by sorry

This theorem, `Finset.sup_image₂_right`, states that for any types α, β, γ, δ, a function `f : α → β → γ`, and a function `g : γ → δ`, assuming that `γ` has decidable equality and `δ` forms a semilattice with a bottom element, the supremum of the image of applying `f` to each pair of elements in finsets `s` and `t` and then applying `g` to the result, is the same as the supremum of applying `g ∘ f` to each pair of elements in `s` and `t`, where the supremum is taken first over all elements in `s` and then over all elements in `t`. That is, for each element `y` in `t`, we compute the supremum over all `x` in `s` of `g (f x y)`, and then we take the supremum of the results over all `y` in `t`. This illustrates a form of distributivity of supremum over the image of a binary function.

For functions `f : α → β → γ` and `g : γ → δ` between types, given that `γ` has decidable equality and `δ` is a semilattice with a bottom element, the supremum of `g ∘ f` applied to pairs of elements from finsets `s` and `t` is equal to the supremum of `g` applied to the images of each pair under `f`, taken over all pairs in `s` and then over all pairs in `t`.


theorem ModularForm.gradedMonoid_eq_of_cast :
    ∀ {Γ : Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)} {a b : GradedMonoid (ModularForm Γ)} (h : a.fst = b.fst),
      ModularForm.mcast h a.snd = b.snd → a = b :=
  by sorry

The theorem `ModularForm.gradedMonoid_eq_of_cast` states that for any subgroup `Γ` of the special linear group of 2 by 2 matrices with integer coefficients, and any two elements `a` and `b` of the graded monoid of `ModularForm`s over the subgroup `Γ`, if the first part (`fst`) of `a` and `b` are equal, and if the modular form obtained by casting the second part (`snd`) of `a` using this equality is equal to the second part of `b`, then `a` and `b` must be the same element of the graded monoid. This theorem essentially provides a condition under which two elements of the graded monoid of modular forms can be considered equal.

If `Γ` is a subgroup of the special linear group of 2 by 2 matrices with integer coefficients, `a` and `b` are elements of the graded monoid of `ModularForm`s over `Γ`, and `fst a = fst b` and `cast (snd a) = snd b`, then `a = b`.


theorem Nat.findGreatest_le : ∀ {P : ℕ → Prop} [inst : DecidablePred P] (n : ℕ), Nat.findGreatest P n ≤ n := by sorry

The theorem `Nat.findGreatest_le` states that for any natural number `n` and any decidable predicate `P` on natural numbers, the greatest natural number `i` less than or equal to `n` for which `P(i)` holds is always less than or equal to `n`. If there is no such `i` (i.e., if `P(i)` does not hold for any `i` less than or equal to `n`), then by definition, `Nat.findGreatest P n` is `0`, which is also less than or equal to `n`. This theorem is a property of the `Nat.findGreatest` function in Lean 4, which finds the greatest natural number that satisfies a given predicate.

For any natural number `n` and decidable predicate `P` on natural numbers, the greatest `i` (if it exists) less than or equal to `n` with `P(i)` holding is less than or equal to `n`, and if no such `i` exists, then `Nat.findGreatest P n = 0`.


/-- The Hausdorff distance satisfies the triangle inequality.  -/
theorem Metric.hausdorffDist_triangle :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t u : Set α},
      EMetric.hausdorffEdist s t ≠ ⊤ → Metric.hausdorffDist s u ≤ Metric.hausdorffDist s t + Metric.hausdorffDist t u :=
  by sorry

The theorem `Metric.hausdorffDist_triangle` states that the Hausdorff distance satisfies the triangle inequality. In more detail, for any three sets `s`, `t`, and `u` in a pseudo-metric space, if the extended (possibly infinite) Hausdorff distance between `s` and `t` is not infinity, then the Hausdorff distance from `s` to `u` is less than or equal to the sum of the Hausdorff distance from `s` to `t` and the Hausdorff distance from `t` to `u`. This is an extension of the classic triangle inequality in metric spaces to the context of Hausdorff distances between sets.

For any sets $s$, $t$, and $u$ in a pseudo-metric space, if $d_{Haus}(s, t) < \infty$, then $d_{Haus}(s, u) \leq d_{Haus}(s, t) + d_{Haus}(t, u)$.


theorem BoundedContinuousFunction.lintegral_lt_top_of_nnreal :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] (μ : MeasureTheory.Measure X)
      [inst_2 : MeasureTheory.IsFiniteMeasure μ] (f : BoundedContinuousFunction X NNReal), ∫⁻ (x : X), ↑(f x) ∂μ < ⊤ :=
  by sorry

The theorem `BoundedContinuousFunction.lintegral_lt_top_of_nnreal` states that for any type `X` with structures of a measurable space and a topological space, any measure `μ` on `X` that is finite, and any bounded continuous function `f` from `X` to the nonnegative real numbers (`NNReal`), the Lebesgue integral (also known as the measure-theoretic integral or simply `lintegral`) of the function `f` with respect to the measure `μ` is finite (less than infinity). In other words, the integral over the entire space of a bounded continuous function mapping to nonnegative real numbers, under a finite measure, is guaranteed to be finite.

For any measurable space and topological space X with a finite measure μ, and any bounded continuous function f from X to the nonnegative real numbers, the Lebesgue integral of f with respect to μ is finite.


theorem FractionalIdeal.mem_zero_iff :
    ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {x : P}, x ∈ 0 ↔ x = 0 :=
  by sorry

This theorem states that for any commutative ring `R`, given a submonoid `S` of `R`, and a commutative ring `P` with an algebra structure over `R`, an element `x` of `P` belongs to the zero fractional ideal if and only if `x` is equal to zero. In more mathematical terms, it asserts that a member of the zero fractional ideal in a commutative ring is zero.

In a commutative ring, an element belongs to the zero fractional ideal if and only if it is zero.


/-- This can be use to prove
```lean
example {f : α → β} (a₁ a₂ : α) : f ∘ ![a₁, a₂] = ![f a₁, f a₂] :=
  (map_eq _ _).symm
```
 -/
theorem FinVec.map_eq : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {m : ℕ} (v : Fin m → α), FinVec.map f v = f ∘ v :=
  by sorry

The theorem `FinVec.map_eq` states that for any function `f` from a type `α` to a type `β`, and for any function `v` from the finite set `Fin m` to `α`, the application of `f` to each element of `v` (denoted by `FinVec.map f v`) is equivalent to the composition of `f` and `v` (denoted by `f ∘ v`). This theorem can be used, for example, to demonstrate that mapping a function `f : α → β` over the finite vector `![a₁, a₂]` results in `![f a₁, f a₂]`.

For any function `f : α -> β` and finite vector `v : Fin m -> α`, `FinVec.map f v` is equal to the composition `f ∘ v`.


/-- An unordered closed interval is compact.  -/
theorem isCompact_uIcc :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : CompactIccSpace α] {a b : α},
      IsCompact (Set.uIcc a b) :=
  by sorry

This theorem states that an unordered closed interval is compact. In other words, for any type `α` that has a linear order, a topology, and the closed interval `[a, b]` is a compact subset, the unordered interval between any two elements `a` and `b` of `α` is also a compact set. In formal terms, if `f` is any filter on `α` that is not the empty set and contains the unordered interval, then there is an element `x` in the unordered interval such that every set in the filter `f` intersects every neighborhood of `x`.

For any type `α` with a linear order and topology, every unordered closed interval is compact. That is, given a filter `f` on `α` that contains an unordered interval, there exists an element in the interval belonging to every set in the filter that intersects every neighborhood of that element.


theorem Filter.comap_top : ∀ {α : Type u} {β : Type v} {m : α → β}, Filter.comap m ⊤ = ⊤ := by sorry

This theorem states that for any types `α` and `β`, and any function `m` from `α` to `β`, the preimage (or inverse image) filter of the function `m` at the top filter in the codomain `β` is always the top filter. In mathematical terms, given a function `m: α → β`, the filter `Filter.comap m ⊤` is equal to `⊤`. Simply put, mapping anything under the function `m` from the most general filter (top filter) will result in the most general filter.

For any function `m: α → β`, the preimage filter of the top filter through `m` equals the top filter in the lattice of filters over `β`.


theorem disjointed_subset : ∀ {α : Type u_1} (f : ℕ → Set α) (n : ℕ), disjointed f n ⊆ f n := by sorry

This theorem states that for any type `α` and any function `f` from natural numbers `ℕ` to the set of `α`, the `n-th` term of the disjointed sequence of `f` is a subset of the `n-th` term of the original sequence `f`. Here, the disjointed sequence is computed by subtracting each element from the subsequent elements, producing a sequence with the same partial supremums as the original sequence. The subset relation `⊆` indicates that every element of the disjointed sequence at the `n-th` position is also an element of the original sequence at the same position.

For any type `α` and function `f : ℕ → α`, the sequence obtained by subtracting successive terms of `f` is a subset of the original sequence `f`.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.95 :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {x : α}, (x ∈ lowerClosure s) = ∃ a ∈ s, x ≤ a := by sorry

This theorem states that for any type `α`, which has a preorder relation, any set `s` of type `α`, and any element `x` of type `α`, `x` belongs to the lower closure of the set `s` if and only if there exists an element `a` in the set `s` such that `x` is less than or equal to `a`. That is, the lower closure of a set `s` includes any element `x` that is less than or equal to some element `a` in `s`.

For any preordered type `α` and set `s` of `α`, an element `x` belongs to the lower closure of `s` if and only if there exists `a` in `s` such that `x ≤ a`.


theorem Mathlib.Order.UpperLower.Basic._auxLemma.94 :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {x : α}, (x ∈ upperClosure s) = ∃ a ∈ s, a ≤ x := by sorry

This theorem, `Mathlib.Order.UpperLower.Basic._auxLemma.94`, states that for any type `α` that has a preorder, for any set `s` of type `α`, and for any element `x` of type `α`, `x` is in the upper closure of `s` if and only if there exists an element `a` in `s` such that `a` is less than or equal to `x`. In other words, the upper closure of a set `s` is the set of all elements that are greater than or equal to at least one element in `s`.

For any preordered type `α` and set `s` in `α`, an element `x` belongs to the upper closure of `s` if and only if there exists an element `a` in `s` such that `a ≤ x`.


theorem Multiset.toFinset_singleton : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), Multiset.toFinset {a} = {a} := by
  sorry

This theorem states that for any type `α` with decidable equality (which means for any two elements of the type, it can be decided whether they are equal or not), and for any element `a` of type `α`, the conversion of a multiset containing only `a` to a finset (which removes any duplicates from the multiset) still results in a set containing only `a`. In other words, given a multiset with a single instance of an element, the process of removing duplicates does not change the set.

For any decidely equal type `α` and its element `a`, the conversion of the multiset {a} to a finset still contains only the element `a`.


theorem IntermediateField.fieldRange_val :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      (S : IntermediateField K L), AlgHom.fieldRange (IntermediateField.val S) = S :=
  by sorry

The theorem `IntermediateField.fieldRange_val` states that for any field `K`, any field `L` that is an algebra over `K`, and any intermediate field `S` of `L / K`, the range of the algebra homomorphism that embeds the elements of `S` into `L` (as obtained by the function `IntermediateField.val`) is `S` itself. In mathematical terms, if `S` is an intermediate field of `K` and `L`, then the image of `S` under the canonical embedding into `L` is precisely `S`.

The theorem asserts that the image of an intermediate field under the canonical embedding into a larger field is equal to the field itself.


theorem smul_lt_smul_iff_of_neg_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : OrderedRing α] [inst_1 : OrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : PosSMulStrictMono α β] [inst_4 : PosSMulReflectLT α β],
      a < 0 → (a • b₁ < a • b₂ ↔ b₂ < b₁) :=
  by sorry

The theorem `smul_lt_smul_iff_of_neg_left` states that for any type `α` forming an ordered ring, a second type `β` forming an ordered additive commutative group, and elements `a` of type `α` and `b₁`, `b₂` of type `β`, given that the type `β` is a module over `α` and that the scalar multiplication operation is strictly monotonically increasing and reflects less-than relations when the scalar is positive, if `a` is less than zero, then scalar multiplication of `a` and `b₁` being less than scalar multiplication of `a` and `b₂` is equivalent to `b₂` being less than `b₁`. This means that when the scaling factor is negative, the order of elements changes when scaled.

For any ordered ring `α`, ordered additive commutative group `β` making `β` a `α`-module, and `a ∈ α`, `b₁, b₂ ∈ β`, if `a < 0` then `a * b₁ < a * b₂` if and only if `b₂ < b₁`.


theorem bihimp_comm : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b : α), bihimp a b = bihimp b a := by
  sorry

The theorem `bihimp_comm` states that for all types `α` that form a Generalized Heyting Algebra, the Heyting bi-implication operation, denoted as `bihimp`, is commutative. In other words, for any two elements `a` and `b` of the algebra, the bi-implication of `a` and `b` is equal to the bi-implication of `b` and `a`. In terms of logic, this means that the logical equivalence between `a` and `b` is the same as the logical equivalence between `b` and `a`.

For any type `α` forming a Generalized Heyting Algebra, the Heyting bi-implication operation `bihimp` is commutative: `a bihimp b ≡ b bihimp a`.


TotallyBounded.isBounded

/-- A totally bounded set is bounded  -/
theorem TotallyBounded.isBounded :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, TotallyBounded s → Bornology.IsBounded s := by sorry

This theorem states that for any set 's' in a pseudo-metric space 'α', if the set 's' is totally bounded, then it is also bounded with respect to the ambient bornology on 'α'. Here, a set is considered totally bounded if for any given entourage (a certain kind of neighborhood or measure of nearness), there exists a finite set of points such that every point in the set 's' is near to some point in this finite set according to the given entourage. A set is considered bounded in the bornology if its complement is co-bounded.

In a pseudo-metric space, a totally bounded set is bounded with respect to the ambient bornology.


theorem CategoryTheory.Arrow.comp_right :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right :=
  by sorry

This theorem states that for any category `T` and for any three objects `X`, `Y`, `Z` in the arrow category of `T`, given two morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the right component (which is a morphism in the original category `T`) of the composite morphism `f ≫ g` in the arrow category of `T` is equal to the composite of the right components of `f` and `g` in the original category `T`. In other words, in the arrow category, composition of morphisms on the right is consistent with the composition operation in the original category.

In the arrow category of a given category, the right component of the composite morphism is equal to the composition of the right components in the original category.


theorem Set.ncard_def : ∀ {α : Type u_1} (s : Set α), Set.ncard s = ENat.toNat (Set.encard s) := by sorry

This theorem states that for any set `s` of type `α`, the cardinality of `s` -- denoted as `Set.ncard s` -- is equal to the conversion of `Set.encard s` from `ℕ∞` (extended natural number, which includes infinity) to a natural number `ℕ` using the `ENat.toNat` function. The `ENat.toNat` function converts any `ℕ∞` value to a `ℕ` value, sending infinity (`∞`) to zero (`0`). In other words, if a set is infinite, its cardinality as determined by `Set.ncard` is assigned the value zero.

For any set `s` of type `α`, the cardinality `Set.ncard s` is the natural number representation of the infinite cardinality `Set.encard s` obtained by applying `ENat.toNat`. If `s` is infinite, then `Set.ncard s` equals zero.


theorem Int.zero_ediv : ∀ (b : ℤ), 0 / b = 0 := by sorry

This theorem states that for any integer `b`, the integer division of `0` by `b` equals `0`. In other words, if you divide zero by any integer, the result is always zero.

For all integers b, 0 divided by b equals 0.


theorem Inducing.continuousAt_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      Inducing g → ∀ {x : X}, ContinuousAt f x ↔ ContinuousAt (g ∘ f) x :=
  by sorry

The theorem `Inducing.continuousAt_iff` states that, for any three types `X`, `Y`, `Z` representing topological spaces, and for any two functions `f` from `X` to `Y` and `g` from `Y` to `Z`, if `g` is an inducing function, then the function `f` is continuous at a point `x` in `X` if and only if the composition of `g` and `f` (denoted as `(g ∘ f)`) is continuous at the same point `x`. Here, a function is said to be continuous at a point if the function's value at any point close to `x` gets close to the function's value at `x`. An inducing function is one that creates a coarser (or equal) topology on its domain when its codomain is considered with a given topology.

A function `f : X → Y` is continuous at a point `x ∈ X` if and only if the composition `g ∘ f` is continuous at `x`, where `g : Y → Z` is an inducing function.


theorem continuous_zpow :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : TopologicalGroup G] (z : ℤ),
      Continuous fun a => a ^ z :=
  by sorry

This theorem states that for any integer `z`, the function that raises a given element `a` of a topological group `G` to the power `z` is a continuous function. Here, `G` is not just any type, but a type equipped with a topology (i.e., a topological space) and a group structure (i.e., it's a group), and these two structures are compatible in a sense that `G` is a topological group. In other words, the theorem says that integer power is a continuous operation in a topological group.

For any topological group (G, ±) and integer z, the function x ↦ x^z is a continuous homomorphism.


theorem Filter.comap_embedding_atTop :
    ∀ {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {e : β → γ},
      (∀ (b₁ b₂ : β), e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) → (∀ (c : γ), ∃ b, c ≤ e b) → Filter.comap e Filter.atTop = Filter.atTop :=
  by sorry

The theorem `Filter.comap_embedding_atTop` states that for any two types `β` and `γ` with preorder relations, and any function `e` from `β` to `γ`, if `e` preserves the order (i.e., `e b₁` is less than or equal to `e b₂` if and only if `b₁` is less than or equal to `b₂`) and for every element `c` in `γ` there exists an element `b` in `β` such that `c` is less than or equal to `e b`, then the preimage filter (`Filter.comap e`) of the filter at infinity (`Filter.atTop`) on `γ` is the filter at infinity on `β`. In other words, under these conditions, the function `e` preserves the concept of "going to infinity".

If `e: β -> γ` is a monotonic function such that for every `c in γ`, there exists `b in β` with `c <= e(b)`, then `Filter.comap e (Filter.atTop γ) = Filter.atTop β`.


theorem tsum_congr_set_coe :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (f : β → α) {s t : Set β},
      s = t → ∑' (x : ↑s), f ↑x = ∑' (x : ↑t), f ↑x :=
  by sorry

This theorem states that for any types `α` and `β`, given an addition-commutative monoid structure and a topological space structure on `α`, and a function `f` mapping elements of `β` to `α`, if we have two sets `s` and `t` of type `β` and they are equal, then the total sum (notated as `∑'`) of the function `f` applied to the elements of the coerced set `s` (notated as `↑s`) is equal to the total sum of the function `f` applied to the elements of the coerced set `t` (notated as `↑t`). In mathematical terms, for equal sets `s` and `t`, it states that ∑_{x ∈ s} f(x) = ∑_{x ∈ t} f(x).

For any addition-commutative monoid `α` with a topological space structure, and function `f` from a type `β` to `α`, if `s` and `t` are equal sets in `β`, then ∑$_{x \in s}$ `f`(`x`) = ∑$_{x \in t}$ `f`(`x`).


theorem Multiset.exists_cons_of_mem : ∀ {α : Type u_1} {s : Multiset α} {a : α}, a ∈ s → ∃ t, s = a ::ₘ t := by sorry

This theorem states that for any type `α`, multiset `s` of type `α`, and element `a` of type `α`, if `a` is an element of `s`, then there exists a multiset `t` (also of type `α`) such that `s` is equivalent to the multiset obtained by adding `a` to `t` (denoted as `a ::ₘ t`). In other words, if an element is in a multiset, then we can express that multiset as the "cons" of that element and another multiset.

For any type `α`, multiset `s` of type `α`, and element `a` of type `α` in `s`, there exists a multiset `t` such that `s` equals the multiset obtained by adding `a` to `t` (denoted as `a :: t`).


theorem intervalIntegral.integral_add_adjacent_intervals :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b c : ℝ} {f : ℝ → E}
      {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b →
        IntervalIntegrable f μ b c →
          ∫ (x : ℝ) in a..b, f x ∂μ + ∫ (x : ℝ) in b..c, f x ∂μ = ∫ (x : ℝ) in a..c, f x ∂μ :=
  by sorry

This theorem states that for any real numbers `a`, `b`, and `c`, and a function `f` from real numbers to a normed additively commutative group `E` that is interval-integrable with respect to a measure `μ` on intervals `a..b` and `b..c`, the sum of the integrals of `f` with respect to `μ` over the intervals `a..b` and `b..c` is equal to the integral of `f` with respect to `μ` over the interval `a..c`. This is a formal statement of the property of additivity of integration over adjacent intervals.

For any real numbers `a < b < c` and a function `f` integrable over `[a, b]` and `[b, c]` with respect to a measure `μ`, the integral of `f` over `[a, c]` is equal to the sum of the integrals over `[a, b]` and `[b, c]`.


theorem eventually_ge_of_tendsto_gt :
    ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α]
      {l : Filter γ} {f : γ → α} {u v : α}, u < v → Filter.Tendsto f l (nhds v) → ∀ᶠ (a : γ) in l, u ≤ f a :=
  by sorry

The theorem `eventually_ge_of_tendsto_gt` states that for all types `α` and `γ`, with `α` having a topological space structure, a linear order, and a closed "left-hand limit" topology, given a filter `l` on `γ`, a function `f` from `γ` to `α`, and two elements `u` and `v` of `α` such that `u` is less than `v`, if the function `f` tends towards the neighborhood of `v` under the filter `l`, then there exists an eventuality (i.e., for all sufficiently large elements `a` of `γ` under the filter `l`), such that `u` is less than or equal to `f(a)`.

In simpler terms, if we have a function that tends towards a certain value, then beyond a certain point, the function's value will be greater than or equal to a given number that is strictly less than the value the function is tending to.

Given a filter `l` on `γ`, a function `f` from `γ` to `α` (where `α` is a type with a topological space structure, a linear order, and a closed "left-hand limit" topology), and elements `u` and `v` of `α` with `u < v`, if `f` tends to the neighborhood of `v` under `l`, then there exists an eventuality `A` under `l` such that `u ≤ f(a)` for all `a` in `A`.


theorem Vector.map₂_snoc :
    ∀ {α : Type u_2} {n : ℕ} {β : Type u_3} (xs : Vector α n) (ys : Vector β n) {α_1 : Type u_1} {f : α → β → α_1}
      {x : α} {y : β},
      Vector.map₂ f (Vector.snoc xs x) (Vector.snoc ys y) = Vector.snoc (Vector.map₂ f xs ys) (f x y) :=
  by sorry

The theorem `Vector.map₂_snoc` states that for all types `α`, `β`, `α_1`, and natural number `n`, and for all vectors `xs` of length `n` with elements of type `α`, `ys` of length `n` with elements of type `β`, elements `x` of type `α`, `y` of type `β`, and a binary function `f` from `α` and `β` to `α_1`, mapping two vectors extended by `x` and `y` respectively with the function `f` is equivalent to extending the vector resulting from mapping the original two vectors with `f` by the result of applying `f` to `x` and `y`. In other words, it verifies the property that appending elements to two vectors and then applying a binary operation is the same as applying the binary operation first and then appending the result of applying the binary operation to the appended elements.

For all types `α`, `β`, and `α_1`, and for all vectors `xs : Vector α of length n`, `ys : Vector β of length n`, binary function `f : α × β → α_1`, and elements `x : α`, `y : β`, `Vector.map₂ f (xs ++ [x]) (ys ++ [y]) = (Map.map2 f xs ys) ++ [f x y]`.


theorem MonoidHom.comap_bot :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      Subgroup.comap f ⊥ = MonoidHom.ker f :=
  by sorry

This theorem states that for any given monoid homomorphism `f` from a group `G` to another group `N`, the preimage of the trivial subgroup in `N` under `f` (i.e., the set of elements in `G` that are mapped to the identity element in `N` by `f`) is equal to the kernel of `f`. In other words, the set of elements in `G` that are sent to the identity element in `N` by the homomorphism `f` forms a subgroup of `G`, and this subgroup is the kernel of `f`.

The preimage of the identity element under a group homomorphism is equal to the kernel of the homomorphism.


theorem DenseInducing.nhds_eq_comap :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β},
      DenseInducing i → ∀ (a : α), nhds a = Filter.comap i (nhds (i a)) :=
  by sorry

This theorem states that for any types `α` and `β`, each equipped with a topological space structure, if `i` is a function from `α` to `β` that induces a dense topology, then the neighborhood filter of any element `a` in `α` is equal to the filter obtained by the pre-image (or `comap`) of the function `i` applied to the neighborhood filter of `i(a)` in `β`. In mathematical notation, this is saying that for a densely inducing function `i`, the filter of neighborhoods around a point `a` is exactly the pullback of the filter of neighborhoods around `i(a)` via the function `i`.

For a densely inducing function between topological spaces, the filter of neighborhoods of a point is equal to the pullback of the filter of neighborhoods of its image under the function.


theorem Finset.not_mem_range_self : ∀ {n : ℕ}, n ∉ Finset.range n := by sorry

The theorem `Finset.not_mem_range_self` states that for any natural number `n`, `n` is not an element of the set of natural numbers less than `n`. In other words, any given natural number `n` is not included in its own range.

For all natural numbers `n`, `n` is not an element of the finite set of natural numbers less than `n`.


theorem Finsupp.range_total :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {v : α → M}, LinearMap.range (Finsupp.total α M R v) = Submodule.span R (Set.range v) :=
  by sorry

The theorem `Finsupp.range_total` states that for any given type `α`, type `M`, and semiring `R`, given the conditions that `M` is an additive commutative monoid and that `M` is a module over `R`, for any function `v` from `α` to `M`, the range of the linear map resulting from applying `Finsupp.total` to `v` (which interprets a finitely supported function as a linear combination of the elements in `v` and evaluates this linear combination) is equal to the span of the range of `v` in `M` (which is the smallest submodule of `M` that contains the range of `v`).

For any type `α`, semiring `R`, additive commutative monoid and `R`-module `M`, and function `v` from `α` to `M`, the range of `Finsupp.total v` equals the span of the range of `v` in `M`.


theorem Or.neg_resolve_left : ∀ {a b : Prop}, ¬a ∨ b → a → b := by sorry

This theorem, `Or.neg_resolve_left`, states that for any two propositions `a` and `b`, if the disjunction of the negation of `a` and `b` is true, and `a` is also true, then `b` must be true. In mathematical terms, for all propositions `a` and `b`, `(¬a ∨ b) → a → b`. This means if either `a` is not true or `b` is true, and if `a` is true, we can conclude that `b` is true.

If `a` and `b` are propositions, then `a -> b` holds when `(~a || b)` is true.


theorem Rel.image_mono : ∀ {α : Type u_1} {β : Type u_2} (r : Rel α β), Monotone (Rel.image r) := by sorry

The theorem `Rel.image_mono` states that for all types `α` and `β`, and for any relation `r` from `α` to `β`, the function `Rel.image r` is monotone. In other words, given any types `α` and `β`, and any relation `r` between them, if we have two sets `A` and `B` such that `A` is a subset of `B`, then the image of `A` under the relation `r` is also a subset of the image of `B` under the same relation `r`. This property of the `Rel.image` function is a manifestation of monotonicity where an increase in the input (in terms of set inclusion) leads to an increase in the output (again in terms of set inclusion).

For all types `α` and `β` and relations `r` from `α` to `β`, if `A` is a subset of `B`, then `Rel.image r A` is a subset of `Rel.image r B`.


theorem Function.Periodic.nat_mul_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Semiring α],
      Function.Periodic f c → ∀ (n : ℕ), f (↑n * c) = f 0 :=
  by sorry

The theorem `Function.Periodic.nat_mul_eq` states that for any type `α` with a semiring structure, any type `β`, any function `f` from `α` to `β`, and any element `c` of `α`, if the function `f` is periodic with period `c`, then for all natural numbers `n`, the function evaluated at `n*c` (where `n*c` is the multiplication of the natural number `n` with `c`) is equal to the function evaluated at `0`. In mathematical terms, if `f(x + c) = f(x)` for all `x`, then `f(n*c) = f(0)` for all natural numbers `n`.

If `f` is a periodic function with period `c` on a semiring `α`, then `f(n * c) = f(0)` for all natural numbers `n`.


/-- An additive group homomorphism (a bundled morphism of a type that implements
`AddMonoidHomClass`) between two uniform additive groups is uniformly continuous provided that it
is continuous at zero. See also `continuous_of_continuousAt_zero`. -/
theorem uniformContinuous_of_continuousAt_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α]
      {hom : Type u_3} [inst_3 : UniformSpace β] [inst_4 : AddGroup β] [inst_5 : UniformAddGroup β]
      [inst_6 : FunLike hom α β] [inst_7 : AddMonoidHomClass hom α β] (f : hom),
      ContinuousAt (⇑f) 0 → UniformContinuous ⇑f :=
  by sorry

The theorem `uniformContinuous_of_continuousAt_zero` states that for any two uniform additive groups `α` and `β`, and any additive group homomorphism `f` (a function that preserves the group operation and belongs to a type that implements `AddMonoidHomClass`) from `α` to `β`, if `f` is continuous at zero, then `f` is uniformly continuous. In other words, if for every sequence in `α` that converges to zero, its image under `f` converges to `f(0)` in `β`, then for any pair of sequences in `α` that converge to each other, their images under `f` also converge to each other, no matter where the sequences are located in `α`.

If `f` is an additive group homomorphism from uniform additive group `α` to `β` that is continuous at zero, then `f` is uniformly continuous.


theorem convex_ball :
    ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (a : E) (r : ℝ),
      Convex ℝ (Metric.ball a r) :=
  by sorry

The theorem `convex_ball` states that for any given type `E` that forms a seminormed additive commutative group and has a structure of a normed space over the real numbers, and for any element `a` of type `E` and any real number `r`, the metric ball around `a` with radius `r` is a convex set in the real number plane. In other words, if you take any two points inside this ball, then the whole line segment connecting these two points is also inside the ball.

For any normed space `(E, ||·||)` over the real numbers and any `a ∈ E` and `r > 0`, the metric ball `{x ∈ E | ||x - a|| ≤ r}` is a convex set in `E`.


/-- Any alternating map to `R` where `ι` has the cardinality of a basis equals the determinant
map with respect to that basis, multiplied by the value of that alternating map on that basis.  -/
theorem AlternatingMap.eq_smul_basis_det :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_4}
      [inst_3 : DecidableEq ι] [inst_4 : Fintype ι] (e : Basis ι R M) (f : M [⋀^ι]→ₗ[R] R), f = f ⇑e • Basis.det e :=
  by sorry

This theorem states that for any alternating map `f` to a commutative ring `R` where the indexing set `ι` has the same cardinality as a basis of a module `M` over `R`, `f` is equivalent to the determinant of that basis `e` multiplied by the value of `f` evaluated at `e`. This means that any alternating map can be expressed in terms of the determinant map with respect to a basis, scaled by the value of the alternating map on that basis.

For any alternating map `f` from an indexing set `ι` of the same cardinality as a basis `e` of a commutative ring `R`-module `M`, `f` is equivalent to the determinant of `e` multiplied by `f` applied to `e`.


theorem MeasureTheory.Memℒp.memℒp_of_exponent_le :
    ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
      {p q : ENNReal} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : α → E},
      MeasureTheory.Memℒp f q μ → p ≤ q → MeasureTheory.Memℒp f p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.memℒp_of_exponent_le` states that for any types `α` and `E`, where `α` is equipped with a measurable space structure `m`, `E` is a normed add commutative group, and `μ` is a finite measure on `α`, if a function `f` from `α` to `E` is in the measure space `ℒ^q` (meaning it is almost everywhere strongly measurable and its `q`-norm is finite), then `f` is also in the measure space `ℒ^p` whenever `p` is less than or equal to `q`.

If `f` is a function from a measurable space `(α, m)` to a normed add commutative group `E`, equipped with a finite measure `μ`, and `f` belongs to the `L^q` space, then `f` also belongs to the `L^p` space for any `p ≤ q`.


theorem finRotate_succ_apply : ∀ {n : ℕ} (i : Fin (n + 1)), (finRotate (n + 1)) i = i + 1 := by sorry

This theorem states that, for any natural number `n` and any value `i` in the finite set `Fin (n + 1)`, applying the function `finRotate (n + 1)` to `i` results in `i` incremented by 1. In other words, the `finRotate` function effectively rotates or shifts the elements in the finite set to the right by one step.

For any natural number `n` and `i` in `Fin (n + 1)`, `finRotate (n + 1) i = i.succ`.