Cauchy.prod

theorem Cauchy.prod :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : UniformSpace β] {f : Filter α} {g : Filter β},
      Cauchy f → Cauchy g → Cauchy (f ×ˢ g) :=
  by sorry

The theorem `Cauchy.prod` states that for any two types `α` and `β` with uniform spaces, if `f` is a Cauchy filter on `α` and `g` is a Cauchy filter on `β`, then the product filter `(f ×ˢ g)` on the product space `α × β` is also a Cauchy filter. In mathematical terms, this theorem ensures that the property of being Cauchy is preserved under taking products in the context of uniform spaces.

Given Cauchy filters `f` on type `α` and `g` on type `β` in a uniform space, their product `f ×ˢ g` is also a Cauchy filter.


theorem sub_add_eq_sub_sub : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - (b + c) = a - b - c :=
  by sorry

This theorem, `sub_add_eq_sub_sub`, states that for any type `α` that is a subtraction commutative monoid (i.e., a mathematical structure equipped with addition, subtraction and zero, where subtraction is commutative), and for any three elements `a`, `b`, and `c` of that type, the subtraction of the sum of `b` and `c` from `a` is equal to the result of subtracting `c` from the difference of `a` and `b`. In mathematical notation, it expresses the relation: `a - (b + c) = a - b - c`.

For any subtraction commutative monoid type `α` and elements `a`, `b`, `c` of `α`, `a - (b + c) = a - b - c`.


ConvexCone.ext

/-- Two `ConvexCone`s are equal if they have the same elements.  -/
theorem ConvexCone.ext :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      {S T : ConvexCone 𝕜 E}, (∀ (x : E), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

The theorem `ConvexCone.ext` states that for any two convex cones `S` and `T` in a vector space `E` over an ordered semiring `𝕜`, if every element `x` in `E` belongs to `S` if and only if it belongs to `T`, then `S` and `T` must be equal. In other words, two convex cones are equal if they contain exactly the same elements.

If two convex cones in a vector space over an ordered semiring contain exactly the same elements, then they are equal.


theorem Mathlib.Analysis.Calculus.ContDiff.Defs._auxLemma.23 :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞}, ContDiff 𝕜 n f = ContDiffOn 𝕜 n f Set.univ :=
  by sorry

The theorem `Mathlib.Analysis.Calculus.ContDiff.Defs._auxLemma.23` states that for any nontrivially normed field `𝕜`, normed add commutative group `E` and `F` with a normed space structure over `𝕜`, and any function `f` from `E` to `F`, the function `f` being continuously differentiable of any order `n` (denoted as `ContDiff 𝕜 n f`) is equivalent to the function `f` being continuously differentiable of order `n` on the universal set of `E` (denoted as `ContDiffOn 𝕜 n f Set.univ`). The universal set in this context contains all elements of the type `E`. This implies that the property of being continuously differentiable of a particular order is a global property, i.e., it holds everywhere in the domain of the function.

For any nontrivially normed field `𝕜`, normed add commutative groups `E` and `F`, and continuously differentiable function `f` of order `n` from `E` to `F`, `ContDiff 𝕜 n f` if and only if `ContDiffOn 𝕜 n f Set.univ`.


theorem mul_sub_right_distrib :
    ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), (a - b) * c = a * c - b * c := by sorry

This theorem states that for any type `α` that forms a `NonUnitalNonAssocRing`, the operation of multiplication distributes over subtraction from the right. Specifically, if you have three elements `a`, `b`, and `c` of type `α`, the product of the difference of `a` and `b` with `c` equals the difference of the product of `a` and `c` and the product of `b` and `c`. In LaTeX mathematics, this would be written as $(a - b) * c = a * c - b * c$.

For any type `α` that is a non-unital non-associative ring, the distribution law holds for multiplication and subtraction: $(a - b) \cdot c = a \cdot c - b \cdot c$.


MeasureTheory.Integrable.mono

theorem MeasureTheory.Integrable.mono :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
      MeasureTheory.Integrable g μ →
        MeasureTheory.AEStronglyMeasurable f μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ ‖g a‖) → MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.Integrable.mono` can be described in natural language as follows:

Given a measurable space `α` with a measure `μ`, and two normed additively commutative groups `β` and `γ`, for any two functions `f` from `α` to `β` and `g` from `α` to `γ`, if `g` is integrable with respect to `μ`, `f` is almost everywhere strongly measurable with respect to `μ`, and almost everywhere, the norm of `f(a)` is less than or equal to the norm of `g(a)` for some `a` in `α`, then `f` is integrable with respect to `μ`.

In simpler terms, this theorem states that if one function (`g`) is integrable and another function (`f`) is almost everywhere strongly measurable and its norm is always less than or equal to the norm of `g`, then `f` is also integrable.

If a strongly measurable function `f` satisfies the almost everywhere norm inequality with an integrable function `g`, then `f` is integrable.


theorem Finsupp.mapDomain_injective :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → β},
      Function.Injective f → Function.Injective (Finsupp.mapDomain f) :=
  by sorry

The theorem `Finsupp.mapDomain_injective` states that for all types `α`, `β`, and `M`, given an additive commutative monoid instance on `M` and a function `f : α → β`, if the function `f` is injective (meaning that if `f(x)` equals `f(y)` then `x` must equal `y`), then the function `Finsupp.mapDomain f`, which creates a finitely supported function by mapping the domain of `f` and summing the values for each `β` that shares the same `α`, is also injective. Essentially, it says that if distinct inputs to `f` produce distinct outputs, then distinct finitely supported functions also produce distinct outputs under the domain mapping operation.

If `f : α → β` is an injective function between types, then `Finsupp.mapDomain f` is an injective function between the corresponding finitely supported functions.


theorem Finset.not_mem_Ioi_self :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrderTop α] {b : α}, b ∉ Finset.Ioi b := by sorry

The theorem `Finset.not_mem_Ioi_self` states that for any type `α` with a partial order and a "locally finite order top" (which means that any bounded subset of `α` is finite), and for any element `b` of type `α`, `b` is not a member of the set of elements greater than `b` (denoted as `Finset.Ioi b`). In other words, there are no elements `b` such that `b` is strictly greater than itself.

For any type `α` with a partial order and a locally finite order top, there are no elements `b` in `α` such that `b` is a member of `Finset.Ioi b`.


theorem Fintype.bijective_iff_surjective_and_card :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
      Function.Bijective f ↔ Function.Surjective f ∧ Fintype.card α = Fintype.card β :=
  by sorry

This theorem states that for all types `α` and `β` where both are finite types (indicated by `Fintype α` and `Fintype β`), a function `f` mapping from `α` to `β` is bijective if and only if two conditions are met: The function `f` is surjective (meaning that for every element `b` in `β`, there exists at least one `a` in `α` such that `f(a) = b`), and the cardinality of `α` (the number of elements in `α`) is equal to the cardinality of `β`. This theorem thus connects the concepts of bijectivity, surjectivity, and same cardinality in the context of finite types.

A function between two finite types is bijective if and only if it is surjective and the sizes of the types are equal.


theorem MeasureTheory.ae_restrict_iUnion_eq :
    ∀ {α : Type u_2} {ι : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      (s : ι → Set α),
      MeasureTheory.Measure.ae (μ.restrict (⋃ i, s i)) = ⨆ i, MeasureTheory.Measure.ae (μ.restrict (s i)) :=
  by sorry

The theorem `MeasureTheory.ae_restrict_iUnion_eq` states that for any type `α` and an index type `ι`, given a `MeasurableSpace` on `α`, a measure `μ` on that space and a countable index set of `ι`, if `s` is a mapping from `ι` to sets of `α`, the almost everywhere filter of the measure restricted to the union of the sets `s i` (denoted as `μ.restrict (⋃ i, s i)`) is equal to the supremum (or greatest lower bound) of the almost everywhere filters of the measures restricted to each individual set `s i`, symbolically represented as `⨆ i, MeasureTheory.Measure.ae (μ.restrict (s i))`. In other words, the almost everywhere behavior of the measure on the union of a collection of sets is described by the supremum of the almost everywhere behavior of the measure on each of the individual sets.

The theorem `MeasureTheory.ae_restrict_iUnion_eq` asserts that the almost everywhere filter of a measure restricted to the union of a countable collection of sets is equal to the supremum (or greatest lower bound) of the almost everywhere filters of the measures restricted to each individual set.


theorem Orientation.rightAngleRotation_def :
    ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ E = 2)] (o : Orientation ℝ E (Fin 2)),
      Orientation.rightAngleRotation o =
        LinearIsometryEquiv.ofLinearIsometry (Orientation.rightAngleRotationAux₂ o)
          (-Orientation.rightAngleRotationAux₁ o) ⋯ ⋯ :=
  by sorry

This theorem, `Orientation.rightAngleRotation_def`, states that for any oriented real inner product space `E` of dimension 2, the isometric automorphism that represents rotation by 90 degrees (denoted as `Orientation.rightAngleRotation o` for some orientation `o`) is equivalent to a particular linear isometry. This linear isometry is formed by composing the auxiliary function `Orientation.rightAngleRotationAux₂ o` with the negation of the auxiliary function `Orientation.rightAngleRotationAux₁ o`. These auxiliary functions are part of the process of defining the rotation by 90 degrees in the real inner product space.

The isometric automorphism representing a 90-degree rotation in a 2-dimensional oriented real inner product space is equivalent to the linear isometry obtained by composing `Orientation.rightAngleRotationAux₂ o` with the negation of `Orientation.rightAngleRotationAux₁ o`.


theorem ENNReal.embedding_coe : Embedding ENNReal.ofNNReal := by sorry

This theorem states that the function `ENNReal.ofNNReal`, which converts a non-negative real number (`NNReal`) to an extended non-negative real number (`ENNReal`), is an embedding. In mathematical terms, this means that this function injects `NNReal` into `ENNReal`, preserving the distinctness of elements and the structure of the domain.

The function `ENNReal.ofNNReal` is an injection from the non-negative real numbers to the extended non-negative real numbers.


/-- Tower law: if `A` is a `K`-module and `K` is an extension of `F` then
$\operatorname{rank}_F(A) = \operatorname{rank}_F(K) * \operatorname{rank}_K(A)$.  -/
theorem FiniteDimensional.finrank_mul_finrank :
    ∀ (F : Type u) (K : Type v) (A : Type w) [inst : Ring F] [inst_1 : Ring K] [inst_2 : AddCommGroup A]
      [inst_3 : Module F K] [inst_4 : Module K A] [inst_5 : Module F A] [inst_6 : IsScalarTower F K A]
      [inst_7 : StrongRankCondition F] [inst_8 : StrongRankCondition K] [inst_9 : Module.Free F K]
      [inst_10 : Module.Free K A],
      FiniteDimensional.finrank F K * FiniteDimensional.finrank K A = FiniteDimensional.finrank F A :=
  by sorry

This theorem, known as the Tower Law, states that for a module `A` over a field `K`, if `K` is an extension of a field `F`, then the rank of `A` with respect to `F` is equal to the product of the rank of `K` with respect to `F` and the rank of `A` with respect to `K`. Specifically, if we denote the rank as $\operatorname{rank}$, the theorem can be written as $\operatorname{rank}_F(A) = \operatorname{rank}_F(K) \times \operatorname{rank}_K(A)$. The theorem assumes that `F` and `K` satisfy the Strong Rank Condition and that `K` and `A` are free modules.

For free modules `A` over a field `K`, the rank of `A` with respect to a subfield `F` equals the product of the rank of `K` with respect to `F` and the rank of `A` with respect to `K`.


theorem MvPolynomial.vanishingIdeal_anti_mono :
    ∀ {k : Type u_1} [inst : Field k] {σ : Type u_2} {A B : Set (σ → k)},
      A ≤ B → MvPolynomial.vanishingIdeal B ≤ MvPolynomial.vanishingIdeal A :=
  by sorry

This theorem states that for any field `k` and any type `σ`, given two sets `A` and `B` of functions from `σ` to `k`, if `A` is a subset of `B` then the vanishing ideal of `B` is a subset of the vanishing ideal of `A`. In terms of mathematical language, if all elements of `A` are also in `B` then all polynomials that vanish at every point in `B` also vanish at every point in `A`. This is a statement about the anti-monotonicity of the vanishing ideal operation: increasing the set of zeroes decreases the set of polynomials that vanish at those points.

If `A` is a subset of `B` in the category of sets of functions from a type `σ` to a field `k`, then the vanishing ideal of `B` is contained in the vanishing ideal of `A`.


theorem Submodule.set_smul_le :
    ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] {S : Type u_4} [inst_1 : Monoid S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : DistribMulAction S M] (s : Set S) (N p : Submodule R M),
      (∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p) → s • N ≤ p :=
  by sorry

This theorem states that for any types `R`, `M`, and `S`, given a semiring structure on `R`, a monoid structure on `S`, an additive commutative monoid structure on `M`, a module structure of `R` over `M`, and a distributive multiplicative action of `S` on `M`, for any set `s` of type `S` and any two submodules `N` and `p` of `R` over `M`, if for every element `r` in `s` and `n` in `N`, the scalar multiplication of `r` and `n` is in `p`, then the scalar multiplication of the set `s` and the submodule `N` is a subset of `p`. In other words, this is a property about scalar multiplication in the context of module theory.

If `s` is a set with a distributive multiplicative action on an `R`-module `M`, and for all `r in s` and `n in N`, the scalar multiplication `r * n` is in `p`, then `s * N` (the set of scalar multiplications of `s` on `N`) is a subset of `p`.


theorem Real.toNNReal_of_nonpos : ∀ {r : ℝ}, r ≤ 0 → Real.toNNReal r = 0 := by sorry

The theorem `Real.toNNReal_of_nonpos` states that for any real number `r`, if `r` is less than or equal to zero, then the result of applying the function `Real.toNNReal` to `r` will be zero. This is in line with the definition of the function `Real.toNNReal`, which reinterprets a real number as a non-negative real number, returning `0` for all inputs less than `0`.

For any real number `r`, if `r ≤ 0`, then `Real.toNNReal r = 0`.


theorem MeasureTheory.Measure.tendsto_eval_ae_ae :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
      {μ : (i : ι) → MeasureTheory.Measure (α i)} [inst_2 : ∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {i : ι},
      Filter.Tendsto (Function.eval i) (MeasureTheory.Measure.ae (MeasureTheory.Measure.pi μ))
        (MeasureTheory.Measure.ae (μ i)) :=
  by sorry

This theorem, `MeasureTheory.Measure.tendsto_eval_ae_ae`, states that for every index `i` in a finite type `ι`, the evaluation function at index `i` tends to the "almost everywhere" (ae) filter of the measure `μ i` when taken over the "almost everywhere" filter of the product measure of all `μ i`.

More concretely, given a set of measures `μ : (i : ι) → MeasureTheory.Measure (α i)` indexed by `ι` where each `α i` is a measurable space, and `μ i` is sigma-finite for each `i`, the theorem asserts that if you consider sequences of functions in the product space (viewed as sequences of vectors), then the sequence of i-th components of these vectors (given by `Function.eval i`) converge "almost everywhere" to the same value as the sequence in the individual space "almost everywhere" with respect to the measure `μ i`. This is a form of the Fubini's theorem for measures, asserting the commutation of limits and integral when passing from the product space to the individual spaces.

Given a family of sigma-finite measures `μ i` on measurable spaces `(α i)` indexed by `ι`, the evaluation function `Function.eval i` at each index `i` tends to the same value almost everywhere with respect to the product measure of all `μ i`s. (This is a form of Fubini's theorem for measures.)


theorem CategoryTheory.Subgroupoid.galoisConnection_map_comap :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
      (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj),
      GaloisConnection (CategoryTheory.Subgroupoid.map φ hφ) (CategoryTheory.Subgroupoid.comap φ) :=
  by sorry

The theorem `CategoryTheory.Subgroupoid.galoisConnection_map_comap` states that for any types `C` and `D`, which are groupoids, and a functor `φ` from `C` to `D` such that `φ.obj` is an injective function, there exists a Galois connection between the map of subgroupoids induced by `φ` and the preimage of subgroupoids under `φ`. In other words, for any subgroupoid `S` of `C` and `T` of `D`, `S` is less than or equal to the preimage of `T` under `φ` if and only if the image of `S` under `φ` is less than or equal to `T`. This theorem is a fundamental result in the theory of groupoids in category theory, establishing a relationship between mappings and preimages of subgroupoids under functors.

For injective functors φ from groupoids C and D, the map of subgroupoids induced by φ and the preimage of subgroupoids under φ form a Galois connection.


theorem SimpleGraph.Subgraph.adj_symm :
    ∀ {V : Type u} {G : SimpleGraph V} (G' : SimpleGraph.Subgraph G) {u v : V}, G'.Adj u v → G'.Adj v u := by sorry

This theorem states that for any given simple graph `G` with vertices of some type `V` and any subgraph `G'` of this graph, if a vertex `u` is adjacent to a vertex `v` in the subgraph `G'`, then `v` is also adjacent to `u` in `G'`. In other words, the adjacency relationship in the subgraph is symmetric. Any pair of vertices that are connected by an edge in one direction are also connected in the other direction.

If `G` is a simple graph and `u` is adjacent to `v` in the subgraph `G'` of `G`, then `v` is adjacent to `u` in `G'`. (Or, symmetrically, if `u` is adjacent to `v` in `G`, then `v` is adjacent to `u` in `G'`. )


theorem eq_ratCast :
    ∀ {F : Type u_1} {k : Type u_5} [inst : DivisionRing k] [inst_1 : FunLike F ℚ k] [inst_2 : RingHomClass F ℚ k]
      (f : F) (r : ℚ), f r = ↑r :=
  by sorry

The theorem `eq_ratCast` states that for all types `F` and `k`, where `k` is a division ring, `F` is a type which fits the `FunLike` class (i.e., terms of type `F` can be mapped injectively into functions from rational numbers `ℚ` to `k`), and `F` also fits the `RingHomClass` (i.e., type `F` creates ring homomorphisms from rational numbers `ℚ` to `k`), then for all elements `f` of type `F` and rational numbers `r`, the application of `f` on `r` equals the cast of `r` into type `k`. In simple terms, if `f` represents a ring homomorphism, then applying `f` to a rational number `r` is the same as casting `r` to the ring `k`.

For any division ring `k`, given a type `F` that is both FunLike and RingHomClass over `k`, and for any `F` element `f` and rational number `r`, `f r = cast r to k`.


theorem unitary.star_mem :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, U ∈ unitary R → star U ∈ unitary R := by sorry

This theorem states that for any type `R` which is a monoid with additional structure given by a `StarMul` operation, if `U` is an element of the unitary submonoid of `R` (which means `U` satisfies the property that the star operation followed by multiplication with `U` yields the identity both ways), then the star of `U` is also an element of the unitary submonoid of `R`. In other words, if a `U` belongs to the unitary submonoid, its star version does too.

If `U` is an element of the unitary submonoid of a monoid `R` with a `StarMul` operation, then the star of `U` is also an element of the unitary submonoid of `R`.


/-- The inverse of a multiplicative character `χ`, applied to `a`, is the inverse of `χ a`.  -/
theorem MulChar.inv_apply_eq_inv :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (χ : MulChar R R') (a : R),
      χ⁻¹ a = Ring.inverse (χ a) :=
  by sorry

The theorem `MulChar.inv_apply_eq_inv` asserts that for any commutative monoid `R`, any commutative monoid with zero `R'`, any multiplicative character `χ` from `R` to `R'`, and any element `a` of `R`, the inverse of the multiplicative character `χ` applied to `a` is equal to the Ring's inverse of the character `χ` evaluated at `a`. In other words, if we apply the inverse operation to the character `χ` and then apply this to `a`, we get the same result as if we first apply the character `χ` to `a` and then take the inverse in the ring structure of `R'`.

For any commutative monoids R and R' with zero, commutative multiplicative character χ from R to R', and element a in R, χ^-1(a) = χ^(-1) a, where χ^-1 is the inverse of χ as a function and χ^(-1) is the multiplicative inverse of χ in R'.


theorem Matrix.det_apply' :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n R),
      Matrix.det M =
        Finset.sum Finset.univ fun σ => ↑↑(Equiv.Perm.sign σ) * Finset.prod Finset.univ fun i => M (σ i) i :=
  by sorry

The theorem `Matrix.det_apply'` states that for any given square matrix `M` with entries in a commutative ring `R`, the determinant of `M` can be computed using the Leibniz formula. In this formula, `Finset.univ` is the set of all permutations on the index set `n`, and for each permutation `σ`, we take the product of `M (σ i) i` as `i` varies over the index set. We then multiply this product by the sign of the permutation `σ`, which is `1` for even permutations and `-1` for odd ones. Finally, we sum up these products over all permutations `σ`. This provides a combinatorial way to compute the determinant of a matrix.

The determinant of a square matrix over a commutative ring can be calculated using the Leibniz formula, which involves summing the product of each entry in the matrix at row i and column σ(i), multiplied by the sign of the corresponding permutation σ, over all permutations of the index set.


theorem TopCat.Presheaf.germ_stalkSpecializes :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
      (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {y : ↥U} {x : ↑X} (h : x ⤳ ↑y),
      CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F y) (TopCat.Presheaf.stalkSpecializes F h) =
        TopCat.Presheaf.germ F { val := x, property := ⋯ } :=
  by sorry

The theorem `TopCat.Presheaf.germ_stalkSpecializes` states that for any category `C` that has all small colimits, given a topological space `X` and a `C`-valued presheaf `F` on `X`, for any open set `U` in `X` and points `x` and `y` in `U` such that `x` specializes to `y`, the composition of the germ of `F` at `y` and the specialization of the stalk of `F` at `x` to `y` is equal to the germ of `F` at `x`. This essentially captures a certain commutativity property in the category of topological spaces related to presheaves and the specialization of points.

For any topological space `X`, presheaf `F` on `X` in a category with small colimits, and open sets `U`, points `x, y` in `U` with `x` specializing to `y`, the germ of `F` at `x` equals the composition of the germ of `F` at `y` and the specialization of the stalk of `F` at `x` to `y`.


theorem Turing.TM2to1.addBottom.proof_1 : ∀ {K : Type u_1} {Γ : K → Type u_2}, (false, default) = (false, default) := by
  sorry

This theorem states that for any Type `K` and any function `Γ` that maps from `K` to some other Type, the pair `(false, default)` is equal to itself. The theorem is applicable in the context of Turing machines, specifically in the conversion from a 2-stack to a 1-stack Turing machine (`TM2to1`). Here, `false` represents a boolean value and `default` refers to a default value of an unspecified type.

The theorem asserts that the pair `(false, default)` is equal to itself, for any type `K` and function `Γ`.


/-- Embedding `Fin n` into `Fin (n + 1)` with a hole around zero embeds by `succ`.  -/
theorem Fin.succAbove_zero : ∀ {n : ℕ}, Fin.succAbove 0 = Fin.succ := by sorry

The theorem `Fin.succAbove_zero` states that for every natural number `n`, the function `Fin.succAbove 0`, which embeds `Fin n` into `Fin (n + 1)` with a gap at zero, is equivalent to the function `Fin.succ`. In other words, when the hole is at zero, the `Fin.succAbove` function behaves the same as the `Fin.succ` function, which essentially adds 1 to every element of `Fin n`, therefore embedding `Fin n` into `Fin (n + 1)`.

For every natural number `n`, the function `Fin.succAbove 0` on `Fin n` is equal to the successor function `Fin.succ`.


theorem Num.lt_to_nat : ∀ {m n : Num}, ↑m < ↑n ↔ m < n := by sorry

This theorem states that for any two numbers `m` and `n` of the `Num` type, the statement "the natural number equivalent of `m` is less than the natural number equivalent of `n`" is equivalent to the statement "`m` is less than `n`". In other words, the '<' operator behaves consistently when comparing natural number equivalents of `Num` type numbers.

The theorem asserts that for all natural numbers `m` and `n` of type `Num`, `m < n` is equivalent to `to_nat m < to_nat n`, where `to_nat` is the natural number representation function.


theorem Localization.induction_on₂ :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {p : Localization S → Localization S → Prop}
      (x y : Localization S), (∀ (x y : M × ↥S), p (Localization.mk x.1 x.2) (Localization.mk y.1 y.2)) → p x y :=
  by sorry

The theorem `Localization.induction_on₂` states that for any commutative monoid `M`, any submonoid `S` of `M`, and any binary predicate `p` on the localization of `M` at `S`, if `p` holds for all pairs of elements from `M` and `S` when mapped to the localization using the `Localization.mk` function, then `p` holds for all pairs of elements in the localization of `M` at `S`. In mathematical terms, given `x, y` as pairs in the localization, if `p` is true for all pairs `(x', y')` in `M × S` such that `Localization.mk x'.1 x'.2` and `Localization.mk y'.1 y'.2` correspond to `x, y`, respectively, then `p` is true for `x, y` in the localization.

If a binary predicate holds for all pairs in a commutative monoid and their images under localization at a submonoid, then it holds for the corresponding pairs in the localization.


theorem CategoryTheory.ShortComplex.homologyMap_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.ShortComplex.homologyMap (CategoryTheory.CategoryStruct.id S) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.homology S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.homologyMap_id` states that for any type `C`, given the category structure on `C` and assuming `C` has zero morphisms, for any short complex `S` in `C` that has a homology, the homology map of the identity morphism on `S` is equal to the identity morphism on the homology of `S`. In other words, this identity shows that the homology map behaves correctly with respect to identity morphisms in the category of short complexes.

For any short complex `S` in a zero-morphism category `C` with homology, the homology map of the identity morphism on `S` equals the identity morphism on the homology of `S`.


theorem Mathlib.Combinatorics.Colex._auxLemma.5 :
    ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α},
      ({ ofColex := s } ≤ { ofColex := t }) = ∀ ⦃a : α⦄, a ∈ s → a ∉ t → ∃ b ∈ t, b ∉ s ∧ a ≤ b :=
  by sorry

This theorem, from the `Mathlib.Combinatorics.Colex` namespace, states that for any type `α` with a partial order, and any finite sets `s` and `t` of this type, `s` is less than or equal to `t` in the colexicographic order if and only if for every element `a` in `s` that is not in `t`, there exists an element `b` in `t` that is not in `s` and `a` is less than or equal to `b`. Essentially, it provides a condition for one set to be less than or equal to another in terms of the colexicographic order, using the existence of particular elements in the sets.

For finite sets \(s\) and \(t\) of a partially ordered type \(\alpha\), \(s \subseteq t\) in the colexicographic order if and only if for every \(a \in s \setminus t\), there exists \(b \in t \setminus s\) such that \(a \leq b\).


theorem Filter.limsup_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : Filter β} {u : β → α},
      Filter.limsup u f = sInf {a | ∀ᶠ (n : β) in f, u n ≤ a} :=
  by sorry

The theorem `Filter.limsup_eq` states that for any conditionally complete lattice `α`, any type `β`, any filter `f` of type `β`, and any function `u` from `β` to `α`, the limit superior (`limsup`) of the function `u` along the filter `f` is equal to the infimum (`sInf`) of the set of all `a` in `α` for which there exists an event in the filter `f` such that for all `n` of type `β` in that event, `u n` is less than or equal to `a`. In other words, the `limsup` of `u` along `f` is the greatest lower bound of the set of `a` for which `u n ≤ a` eventually holds in `f`.

The limit superior of a function along a filter is the greatest lower bound of values that are eventually smaller than the function for some event in the filter.


theorem MeasureTheory.IntegrableOn.integrable_indicator :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.IntegrableOn f s μ → MeasurableSet s → MeasureTheory.Integrable (Set.indicator s f) μ :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.integrable_indicator` states that for any set `s` of elements of type `α`, and any function `f` mapping elements of `α` to the normed add-commutative group `E`, if `f` is integrable on `s` with respect to a measure `μ` and `s` is a measurable set, then the indicator function of `s` with respect to `f` is integrable with respect to `μ`. In more mathematical terms, if the integral of `f` over set `s` is finite and `s` is measurable, then the integral of the function which equals `f` on `s` and zero otherwise, is also finite.

If a function `f` is integrable over a measurable set `s` with finite integral, then the indicator function of `s` with respect to `f` is also integrable with finite integral.


PartialEquiv.IsImage.mapsTo

theorem PartialEquiv.IsImage.mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage e s t → Set.MapsTo (↑e) (e.source ∩ s) (e.target ∩ t) :=
  by sorry

The theorem `PartialEquiv.IsImage.mapsTo` states that for any types `α` and `β`, any partial equivalence `e` between `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, if `t` is an image of `s` under the partial equivalence `e`, then the function represented by `e` maps each element of the intersection of the source of `e` and the set `s` to the intersection of the target of `e` and the set `t`. In other words, if an element is in both the source of `e` and `s`, its image under `e` will be in both the target of `e` and `t`.

If a partial equivalence `e` maps set `s` to set `t`, then for all `x` in the intersection of the domain of `e` and `s`, `e(x)` is in the intersection of the range of `e` and `t`.


theorem Associated.mul_right :
    ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, Associated a b → ∀ (c : α), Associated (a * c) (b * c) := by sorry

The theorem `Associated.mul_right` states that for all types `α` in a commutative monoid, if two elements `a` and `b` are associated, then for any other element `c` in the same monoid, the product of `a` and `c`, and the product of `b` and `c` are also associated. "Associated" here means that one element can be obtained by multiplying the other by a unit on the right.

If `a` and `b` are associated elements in a commutative monoid `α`, then for all `c` in `α`, the products `a * c` and `b * c` are also associated.


theorem MeasureTheory.SignedMeasure.toJordanDecomposition.proof_1 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α),
      MeasurableSet (Exists.choose ⋯) ∧
        MeasureTheory.VectorMeasure.restrict 0 (Exists.choose ⋯) ≤
            MeasureTheory.VectorMeasure.restrict s (Exists.choose ⋯) ∧
          MeasureTheory.VectorMeasure.restrict s (Exists.choose ⋯)ᶜ ≤
            MeasureTheory.VectorMeasure.restrict 0 (Exists.choose ⋯)ᶜ :=
  by sorry

This theorem states that for any signed measure `s` on a measurable space `α`, there exists a measurable set (specifically, the one extracted by `Exists.choose`) with the following properties:

1. The restriction of the zero vector measure to this set is less than or equal to the restriction of `s` to the same set.

2. The restriction of `s` to the complement of this set is less than or equal to the restriction of the zero vector measure to the same complement set.

In other words, this theorem is establishing a particular property of a specific measurable set in relation to the provided signed measure and the zero vector measure.

For any signed measure `s` on a measurable space, there exists a measurable set such that the restriction of `s` to the set is less than or equal to the restriction of the zero measure to the same set, and the reverse inequality holds for their complements.


theorem Polynomial.splits_C :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) (a : K),
      Polynomial.Splits i (Polynomial.C a) :=
  by sorry

The theorem `Polynomial.splits_C` states that for any commutative ring `K` and any field `L`, given any ring homomorphism `i` from `K` to `L` and any element `a` in `K`, the constant polynomial `a` splits with respect to `i`. That is, the polynomial obtained from mapping all coefficients of the constant polynomial `a` via `i` is either zero, or all of its irreducible factors (if any) have degree 1.

For any commutative ring homomorphism from a ring K to a field L and any element a in K, the constant polynomial a over K splits in L with irreducible factors of degree at most 1.


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

This theorem states that for any types `α` and `β`, given that `α` is a complete lattice, the infimum (greatest lower bound) of the set of results of a function `f` (which maps from `β` to `α`) over a singleton set containing an element `b` is equal to the result of the function `f` applied to `b`. In other words, when applied to the only element in a singleton set, the function's value is the infimum of its output over that set.

For any complete lattice `α` and function `f` from type `β` to `α`, the infimum of `{f(b) | b : β}` is equal to `f(b)` when `β` has only one element.


AntitoneOn.inter

theorem AntitoneOn.inter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : β → Set α} {s : Set β},
      AntitoneOn f s → AntitoneOn g s → AntitoneOn (fun x => f x ∩ g x) s :=
  by sorry

The theorem `AntitoneOn.inter` states that for any types `α` and `β`, where `β` has a preorder, and any functions `f` and `g` from `β` to sets of `α`, and a set `s` of `β`, if both `f` and `g` are antitone (meaning reversely ordered) on `s`, then the function that maps each element of `β` to the intersection of the sets `f(x)` and `g(x)` is also antitone on `s`. This means that for all elements `a` and `b` in `s`, if `a ≤ b` then the intersection of the sets at `b` is a subset of the intersection of the sets at `a`.

If `f` and `g` are antitone functions from a preordered set `β` to sets of a type `α`, then their intersection function, which maps each element `x` in `β` to the intersection of `f(x)` and `g(x)`, is also an antitone function on `β`. In other words, for all `a, b` in `β` with `a ≤ b`, we have `∩(f a) ⊆ ∩(f b)`.


theorem Mathlib.CategoryTheory.Limits.Unit._auxLemma.1 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem states that for any type `α` of a certain sort `u_1`, if `α` is a subsingleton (i.e., there is at most one unique element in `α`), then for any two elements `x` and `y` in `α`, `x` is equal to `y`. This is always true because in a subsingleton, all elements are identical.

In a subsingleton type `α`, all elements are equal.


theorem ProbabilityTheory.kernel.sum_apply' :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      [inst : Countable ι] (κ : ι → ↥(ProbabilityTheory.kernel α β)) (a : α) {s : Set β},
      MeasurableSet s → ↑↑((ProbabilityTheory.kernel.sum κ) a) s = ∑' (n : ι), ↑↑((κ n) a) s :=
  by sorry

This theorem states that for all types `α`, `β`, and `ι`, where `α` and `β` are equipped with a measurable space structure `mα` and `mβ` respectively, and `ι` is countable, given a function `κ` which assigns each element of `ι` a kernel on the spaces `α` and `β`, for any element `a` of `α` and any measurable set `s` of `β`, the value of the measure of `s` under the summed kernel at `a` is equal to the series sum of the values of the measure of `s` under each individual kernel at `a`. In mathematical terms, the theorem says that for a countable index set, the measure of a set under the sum of kernels is the series sum of the measures under each individual kernel, i.e., $((\text{kernel.sum}\ \kappa)(a))(s) = \sum'_{n \in \iota} ((\kappa(n))(a))(s)$ for each `a` in `α` and measurable `s` in `β`.

For any countable index set `ι`, given measurable spaces `(α, mα)` and `(β, mβ)`, and a countable family of kernels `{κ(n)}` on `α × β`, the summed kernel `(kernel.sum κ)` satisfies the property that for all `a` in `α` and measurable `s` in `β`, $((\text{kernel.sum}\ κ)(a))(s) = \sum'_{n \in \iota} ((\kappa(n))(a))(s)$.


Pi.uniformity

theorem Pi.uniformity :
    ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)],
      uniformity ((i : ι) → α i) = ⨅ i, Filter.comap (fun a => (a.1 i, a.2 i)) (uniformity (α i)) :=
  by sorry

This theorem states that for any type `ι` and a function `α` from `ι` to a type `u`, given a uniform space structure `U` for each `α i`, the uniformity of the function space `(i : ι) → α i` is equal to the infimum over `i` of the filter obtained by the comap (preimage under a function) of the function `(a => (a.1 i, a.2 i))` on the uniformity of each `α i`. In simpler terms, it describes how the uniformity of a function space can be constructed from the uniformities of its component spaces.

The uniformity of a function space from a type `ι` to a uniform space `u`, given a uniformity structure on each component space, is the infimum of the filters obtained by taking the preimages of the uniformity under the projection functions.


/-- The sequence `TopologicalSpace.denseSeq α` has dense range.  -/
theorem TopologicalSpace.denseRange_denseSeq :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α] [inst_1 : Nonempty α],
      DenseRange (TopologicalSpace.denseSeq α) :=
  by sorry

This theorem states that for any non-empty type `α` that is equipped with a topology and is also separable, the sequence `TopologicalSpace.denseSeq α` has a dense range. In other words, the image of this sequence is a dense subset of `α`. In the context of topology, a set being "dense" in `α` means that every point of `α` is either in the set or is a limit point of the set, and a separable space is a space that contains a countable, dense subset.

In a separable topological space `α`, the sequence `TopologicalSpace.denseSeq α` has a dense image.


IsChain.symm

/-- This can be used to turn `IsChain (≥)` into `IsChain (≤)` and vice-versa.  -/
theorem IsChain.symm : ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain (flip r) s := by sorry

This theorem states that for any type `α`, a relation `r`, and a set `s`, if `s` is a chain with respect to the relation `r`, then `s` is also a chain with respect to the flipped relation of `r`. In other words, if all elements in the set `s` are related pairwise by either `r x y` or `r y x` (making `s` a chain), then all elements in `s` are also related pairwise by either `flip r y x` or `flip r x y`. This is particularly useful for reversing the direction of an ordered relation, such as turning a chain in non-ascending order (`IsChain (≥)`) into a chain in non-descending order (`IsChain (≤)`) and vice-versa.

given a type `α` and a binary relation `r` on `α`, if `s` is a chain with respect to `r`, then `s` is also a chain with respect to the flipped relation `flip r`.


theorem Finite.card_le_of_surjective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Finite α] (f : α → β), Function.Surjective f → Nat.card β ≤ Nat.card α := by
  sorry

This theorem states that for any two types `α` and `β`, if `α` is finite and there exists a surjective function `f` from `α` to `β` (meaning each element of `β` can be obtained from applying `f` to some element of `α`), then the cardinality of `β` (expressed as a natural number by `Nat.card β`) is less than or equal to the cardinality of `α` (expressed as `Nat.card α`). In mathematical terms, if `f: α -> β` is surjective and the set `α` is finite, then the cardinality of `β` is less than or equal to the cardinality of `α`.

If `α` is a finite type and there exists a surjective function `f: α -> β`, then `Nat.card β <= Nat.card α`.


theorem Mathlib.LinearAlgebra.Semisimple._auxLemma.2 :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {f : Module.End R M},
      Module.End.IsSemisimple f = ∀ p ≤ Submodule.comap f p, ∃ q ≤ Submodule.comap f q, IsCompl p q :=
  by sorry

The theorem `Mathlib.LinearAlgebra.Semisimple._auxLemma.2` states that for any commutative ring `R`, additive commutative group `M` and `R`-module structure on `M`, a linear endomorphism `f` of the `R`-module `M` is semisimple if and only if for any `R`-submodule `p` of `M` that is `f`-invariant (i.e., `p` is less than or equal to the preimage of `p` under `f`), there exists an `f`-invariant `R`-submodule `q` of `M` such that `p` and `q` are complementary, i.e., their sum is the whole module and their intersection is trivial.

A linear endomorphism of an `R`-module is semisimple if and only if for every `f`-invariant `R`-submodule, there exists a complementary `f`-invariant submodule.


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

This theorem states that for any type `α`, given a preorder on `α` and a value `a` of type `α`, the preimage under the function `WithTop.some`, which maps from `α` into `WithTop α`, of the set of all elements in `WithTop α` less than `a` (i.e., `Set.Iio ↑a`) is equal to the set of all elements in `α` less than `a` (i.e., `Set.Iio a`). In other words, the theorem asserts that applying the `WithTop.some` function to a set of values in `α` and then taking the set of preimages under `WithTop.some` of the result gives the original set of values. In mathematical terms, it can be written as: $\forall \alpha \in \text{Type } u_1, a \in \alpha: \text{WithTop.some}^{-1}((-\infty, a)) = (-\infty, a)$.

For any type `α` and preorder, the preimage under `WithTop.some` of the set of elements in `WithTop α` less than a given element `a` in `α` is equal to the set of elements in `α` less than `a`. In symbols: $\forall \alpha \in \text{Type}, a \in \alpha: \text{WithTop.some}^{-1}((-\infty, a)) = (-\infty, a)$.


theorem CategoryTheory.Limits.PreservesCoequalizer.iso_hom :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) {X Y : C} (f g : X ⟶ Y)
      [inst_2 : CategoryTheory.Limits.HasCoequalizer f g]
      [inst_3 : CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)]
      [inst_4 : CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G],
      (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).hom = CategoryTheory.Limits.coequalizerComparison f g G :=
  by sorry

This theorem, `CategoryTheory.Limits.PreservesCoequalizer.iso_hom`, states that for any category `C`, category `D`, and functor `G` mapping `C` to `D`, given the conditions that `C` has a coequalizer for a pair of morphisms `f` and `g` from `X` to `Y`, and `D` has a coequalizer for the pair of morphisms `G.map f` and `G.map g`, and `G` preserves the colimit of the parallel pair of `f` and `g`, then the homomorphism component of the isomorphism `CategoryTheory.Limits.PreservesCoequalizer.iso G f g` equals to the coequalizer comparison of `f`, `g` and `G`. In simpler terms, under the given conditions, the functor `G` preserves the structure of the coequalizer in the transition from `C` to `D`.

If `C` is a category with a coequalizer for a pair of morphisms `f` and `g`, `D` is a category with a coequalizer for `G.map f` and `G.map g`, and `G` preserves the colimit of `f` and `g`, then the isomorphism `CategoryTheory.Limits.PreservesCoequalizer.iso G f g` equals the coequalizer comparison of `f`, `g`, and `G`.


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

The theorem `WithTop.preimage_coe_Iic` asserts that for any given type `α` equipped with a `Preorder` structure, and for any element `a` of type `α`, the preimage of the set of elements less than or equal to `a` (denoted by `Set.Iic ↑a` where `↑a` refers to the lift of `a` to `WithTop α`) under the canonical map `WithTop.some` from `α` to `WithTop α` is exactly the set of elements in `α` that are less than or equal to `a`(denoted `Set.Iic a`). In other words, the canonical map `WithTop.some` perfectly preserves the order structure when considering sets of elements less than or equal to a certain value.

For any type `α` with a `Preorder` structure and any element `a` in `α`, the lift of `a` under the canonical map from `α` to `WithTop α` preserves the order relationship, i.e., `Set.Iic (WithTop.some a) = Set.Iic a`.


theorem cmp_eq_cmp_symm :
    ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} {β : Type u_3} [inst_1 : LinearOrder β] {x' y' : β},
      cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' :=
  by sorry

This theorem states that for any types `α` and `β` both equipped with a linear order, and any elements `x, y` of type `α` and `x', y'` of type `β`, the comparison (using 'less than' as defined by the cmp function) of `x` and `y` being the same as the comparison of `x'` and `y'` is equivalent to the comparison of `y` and `x` being the same as the comparison of `y'` and `x'`. This is effectively a statement of the symmetry of the comparison operation under swapping of the arguments.

For all types `α` and `β` with linear orders, and all `x, y : α` and `x', y' : β`, `x < y <-> y' < x'`.


Asymptotics.IsEquivalent.trans

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

The theorem `Asymptotics.IsEquivalent.trans` states that for any type `α` and a normed add commutative group `β`, if two functions `u` and `v` are asymptotically equivalent along a filter `l`, and also `v` and `w` are asymptotically equivalent along the same filter `l`, then `u` and `w` are also asymptotically equivalent along the filter `l`. This property, known as transitivity, suggests that the asymptotic equivalence of functions along a filter behaves similarly to an equivalence relation.

If `u`, `v`, and `w` are functions, and `α` is a type, and `β` is a normed add commutative group, and `l` is a filter, then if `u ≈_l v` and `v ≈_l w`, it follows that `u ≈_l w`.


Filter.EventuallyEq.union

theorem Filter.EventuallyEq.union :
    ∀ {α : Type u} {s t s' t' : Set α} {l : Filter α}, s =ᶠ[l] t → s' =ᶠ[l] t' → s ∪ s' =ᶠ[l] t ∪ t' := by sorry

The theorem `Filter.EventuallyEq.union` states that for any type `α`, any sets `s`, `t`, `s'`, `t'` of type `α`, and any filter `l` on `α`, if `s` is eventually equal to `t` with respect to the filter `l` and `s'` is eventually equal to `t'` with respect to the same filter `l`, then the union of sets `s` and `s'` is eventually equal to the union of sets `t` and `t'` with respect to the filter `l`. Here, "eventually equal" means that outside a set of some measure (which is ignored), the two sets are equal.

If sets $s$, $t$, $s'$, $t'$ of type $\alpha$ satisfy $s \equiv_\infty t$ and $s' \equiv_\infty t'$ with respect to filter $l$ on $\alpha$, then $s \cup s' \equiv_\infty t \cup t'$. Here, $\equiv_\infty$ denotes eventual equality.


theorem Real.rpow_two : ∀ (x : ℝ), x ^ 2 = x ^ 2 := by sorry

This theorem is stating that for every real number `x`, the square of `x` is equal to the square of `x`. In other words, the square of any real number is always consistent and equal to itself. The square of a number is calculated by raising it to the power of 2, thus `x ^ 2` represents the square of `x` in this context. It's a simple and straightforward mathematical identity.

For every real number x, x ^ 2 equals x ^ 2. (The square of a real number is self-equal.)


theorem PowerSeries.coeff_zero_eq_constantCoeff_apply :
    ∀ {R : Type u_1} [inst : Semiring R] (φ : PowerSeries R),
      (PowerSeries.coeff R 0) φ = (PowerSeries.constantCoeff R) φ :=
  by sorry

This theorem states that for any given power series φ over a coefficient type R, where R is a semiring, the 0th coefficient of the power series is equal to its constant coefficient. In more mathematical terms, if φ is a formal power series with coefficients in R, then the coefficient of x⁰ in φ, denoted as (PowerSeries.coeff R 0 φ), is the same as the constant term of φ, denoted as (PowerSeries.constantCoeff R φ).

For any formal power series φ over a semiring R, the 0th coefficient equals the constant coefficient: (PowerSeries.coeff R 0 φ) = (PowerSeries.constantCoeff R φ).


theorem Ordinal.range_familyOfBFamily :
    ∀ {α : Type u_1} {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → α),
      Set.range (Ordinal.familyOfBFamily o f) = Ordinal.brange o f :=
  by sorry

The theorem `Ordinal.range_familyOfBFamily` claims that for any type `α`, any ordinal `o`, and any function `f` which takes an ordinal `a` and a proof that `a` is less than `o` to `α`, the set of all values that `f` can take (i.e., the image of `f`, denoted as `Set.range (Ordinal.familyOfBFamily o f)`) is equal to the set of all values that `f` can take when indexed over the ordinals less than `o` (denoted as `Ordinal.brange o f`). In simpler terms, regardless of whether the function is indexed over all ordinals or just those less than a given ordinal, the set of its possible outputs remains the same.

For any type α, ordinal o, and function f from ordinals to α with proof of each index being less than o, the sets {f a : a < o} and {f b : ∃ i, i < o ∧ b = i} are equal.


theorem mul_cancel_right_mem_nonZeroDivisors :
    ∀ {R : Type u_5} [inst : Ring R] {x y r : R}, r ∈ nonZeroDivisors R → (x * r = y * r ↔ x = y) := by sorry

This theorem states that for any ring 'R', and any elements 'x', 'y', and 'r' of 'R', if 'r' belongs to the submonoid of non-zero divisors of 'R', then 'x' times 'r' equals 'y' times 'r' if and only if 'x' equals 'y'. In simpler terms, the theorem says that if 'r' is in the set of non-zero divisors, then multiplication by 'r' from the right side can be 'cancelled' without changing the equality of 'x' and 'y'. In other words, it states the cancellation property for multiplication in a ring when the multiplicative factor is a non-zero divisor.

For any ring 'R' and elements 'x', 'y' of 'R', if 'r' is a non-zero divisor in 'R' then x * r = y * r implies x = y.


ContDiffAt.norm

theorem ContDiffAt.norm :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst : InnerProductSpace 𝕜 E]
      [inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E}
      {x : G} {n : ℕ∞}, ContDiffAt ℝ n f x → f x ≠ 0 → ContDiffAt ℝ n (fun y => ‖f y‖) x :=
  by sorry

This theorem states that if a function `f` from a Normed Additive Commutative Group `G` to an Inner Product Space `E` over a Ring Completeness-like structure `𝕜` is continuously differentiable at a point `x` up to order `n`, and if `f(x)` is not equal to zero, then the function that gives the norm of `f(y)` is also continuously differentiable at `x` up to the same order `n`. Here, `ℕ∞` represents the extended natural numbers, which includes the infinite order of differentiability.

If `f` is a continuously differentiable function of order `n` from a Normed Additive Commutative Group `G` to an Inner Product Space `E` over a Ring Completeness-like structure `𝕜`, and `f(x) ≠ 0`, then the norm of `f` is a continuously differentiable function of order `n` at `x`.


theorem Finset.choose_spec :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a),
      Finset.choose p l hp ∈ l ∧ p (Finset.choose p l hp) :=
  by sorry

The theorem `Finset.choose_spec` states that for any type `α`, a predicate `p` on `α` that is decidable, and a finite set `l` of elements of type `α`, if there exists exactly one element `a` in `l` that satisfies the predicate `p`, then the element returned by the `Finset.choose` function for `p`, `l` and the proof of uniqueness, is contained in `l` and satisfies predicate `p`. In other words, the function `Finset.choose` correctly identifies the unique element in the finite set that satisfies the given decidable predicate.

If `p` is a decidable predicate on a type `α`, and `l` is a finite set of elements from `α` with exactly one element satisfying `p`, then `Finset.choose l p` is defined and is that element.


theorem List.chain'_iff_pairwise :
    ∀ {α : Type u} {R : α → α → Prop} [inst : IsTrans α R] {l : List α}, List.Chain' R l ↔ List.Pairwise R l := by sorry

This theorem states that for any type `α`, a binary relation `R` on `α`, and a list `l` of elements of type `α`, the property that `R` holds between adjacent elements of `l` (denoted by `List.Chain' R l`) is equivalent to the property that `R` holds for every pair of elements in `l` in their order of appearance (denoted by `List.Pairwise R l`), given that `R` is transitive. In other words, if the relation `R` is transitive, then a chain of `R` in the list `l` exists if and only if `R` holds pairwise in `l`.

If `R` is a transitive relation on type `α`, then `List.Chain' R l` holds if and only if `List.Pairwise R l` holds for any list `l` of elements of type `α`.


OrderMonoidWithZeroHom.ext

theorem OrderMonoidWithZeroHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
      [inst_3 : MulZeroOneClass β] {f g : α →*₀o β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two order-preserving monoid homomorphisms `f` and `g` from a preorder `α` to a preorder `β` (where `α` and `β` are additionally equipped with multiplication, zero and one), if `f` and `g` are equal for all elements of `α`, then `f` and `g` are identical functions. In other words, two such homomorphisms are considered identical if they map each element of `α` to the same element in `β`.

If two order-preserving monoid homomorphisms from a preordered monoid to another with multiplication, zero, and one agree on all elements, then they are equal as functions.


theorem Mathlib.Computability.TMToPartrec._auxLemma.18 :
    ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (x : α) → β x}, (f₁ = f₂) = ∀ (a : α), f₁ a = f₂ a := by sorry

This theorem, named `Mathlib.Computability.TMToPartrec._auxLemma.18`, states that for any arbitrary types `α` and `β` (where `β` is a type-dependent on `α`), and any two functions `f₁` and `f₂` (both of which take an element of type `α` and return an element of type `β`), the equality of `f₁` and `f₂` is equivalent to the statement that for every element of type `α`, `f₁` of that element equals `f₂` of that element. Essentially, it asserts that two functions are equal if and only if they produce the same output for every input.

For functions `f₁` and `f₂` from type `α` to type `β` dependent on `α`, the equality of `f₁` and `f₂` holds if and only if for all `x : α`, `f₁ x = f₂ x`.


theorem integrableOn_Icc_iff_integrableOn_Ioc :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] [inst_2 : PartialOrder α]
      [inst_3 : MeasurableSingletonClass α] {f : α → E} {μ : MeasureTheory.Measure α} {a b : α}
      [inst_4 : MeasureTheory.NoAtoms μ],
      MeasureTheory.IntegrableOn f (Set.Icc a b) μ ↔ MeasureTheory.IntegrableOn f (Set.Ioc a b) μ :=
  by sorry

The theorem `integrableOn_Icc_iff_integrableOn_Ioc` states that for any measurable space `α`, normed add commutative group `E`, partial order on `α`, measure `μ` on `α` that has no atoms, and function `f` from `α` to `E`, the function `f` is integrable on the closed interval from `a` to `b` (i.e., `Set.Icc a b`) with respect to the measure `μ` if and only if `f` is integrable on the open-closed interval from `a` to `b` (i.e., `Set.Ioc a b`) with respect to the same measure `μ`. In other words, the integrability of the function on the closed interval is equivalent to its integrability on the open-closed interval under the given conditions.

For any measurable space, normed add commutative group, and measurable function with no atoms, the function is integrable over a closed interval if and only if it is integrable over the corresponding open-closed interval with respect to the given measure.


theorem HasCompactSupport.isCompact_range :
    ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : Zero β] {f : α → β}
      [inst_2 : TopologicalSpace β], HasCompactSupport f → Continuous f → IsCompact (Set.range f) :=
  by sorry

This theorem states that if a function 'f' from a topological space 'α' to another topological space 'β' has compact support and is continuous, then the range of 'f' is a compact set. In other words, for every nontrivial filter that contains the range of 'f', there is a point in the range such that every set of the filter intersects every neighborhood of this point. This encapsulates a fundamental property of continuous functions with compact support in the context of topological spaces.

If $f:\alpha \to \beta$ is a continuous function with compact support from a topological space $\alpha$ to another topological space $\beta$, then the range of $f$ is a compact set.


theorem antitone_Ioi : ∀ {α : Type u_1} [inst : Preorder α], Antitone Set.Ioi := by sorry

The theorem `antitone_Ioi` states that for all types `α` that have a preorder (an order relation that is reflexive and transitive), the function `Set.Ioi` (which creates a set of all elements greater than a given element in `α`) is antitone. In other words, if `a ≤ b` for two elements `a` and `b` in `α`, then the set of elements greater than `b` is a subset of the set of elements greater than `a`. This is expressed by saying that the set of elements greater than `b` is less than or equal to the set of elements greater than `a` in the order relation of sets, which is set inclusion.

For any preorder `≤` on type `α`, the set `Set.Ioi a` is a subset of `Set.Ioi b` whenever `a ≤ b`.


MonotoneOn.neg

theorem MonotoneOn.neg :
    ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α]
      [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] [inst_4 : Preorder β]
      {f : β → α} {s : Set β}, MonotoneOn f s → AntitoneOn (fun x => -f x) s :=
  by sorry

This theorem states that for any type `α` and `β`, where `α` is an additive group and a preorder, and `β` is a preorder, if you have a function `f` from `β` to `α` that is monotone on a set `s`, then the function that maps each element in `s` to the negation of its image under `f` is antitone on `s`. In other words, if `f` preserves the order of elements in `s`, then the function `-f` reverses it.

For functions `f` from a preorder `β` to an additive group and preorder `α` with `f` being monotone on a set `s` in `β`, the function `-f` is antitone on `s`.


theorem Ideal.map_quotient_self :
    ∀ {R : Type u} [inst : CommRing R] (I : Ideal R), Ideal.map (Ideal.Quotient.mk I) I = ⊥ := by sorry

The theorem `Ideal.map_quotient_self` states that for any commutative ring `R` and any ideal `I` of `R`, when we map the ideal `I` to the quotient ring `R/I` using the quotient map, we get the smallest ideal (`⊥`) in the quotient ring. In other words, in the context of a commutative ring and its ideal, the image of the ideal under the quotient map is just the zero ideal in the quotient ring.

For any commutative ring R and its ideal I, the image of I under the quotient map to the quotient ring R/I is the zero ideal.


theorem Filter.eventually_all_finite :
    ∀ {α : Type u} {ι : Type u_2} {I : Set ι},
      Set.Finite I →
        ∀ {l : Filter α} {p : ι → α → Prop}, (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x :=
  by sorry

The theorem `Filter.eventually_all_finite` states that for all types `α` and `ι`, and for a finite set `I` of type `ι`, any filter `l` of type `α`, and a property `p` that takes a type `ι` and a type `α` to a proposition, the proposition that "for almost all `x` in the filter `l`, for all `i` in the set `I`, `p i x` holds" is equivalent to the proposition that "for all `i` in the set `I`, for almost all `x` in the filter `l`, `p i x` holds". In other words, the order of quantifiers does not matter when the set `I` is finite.

For any filter `l` over type `α`, property `p` taking `ι` and `α` to props, and finite set `I` of type `ι`, the statements "for almost all `x` in `l`, for all `i` in `I`, `p i x` holds" and "for all `i` in `I`, for almost all `x` in `l`, `p i x` holds" are equivalent.


theorem Complex.cosh_sq_sub_sinh_sq : ∀ (x : ℂ), Complex.cosh x ^ 2 - Complex.sinh x ^ 2 = 1 := by sorry

This theorem states that for every complex number `x`, the square of the complex hyperbolic cosine of `x` minus the square of the complex hyperbolic sine of `x` is equal to 1. In mathematical terms, it signifies the identity $\cosh^2(x) - \sinh^2(x) = 1$ for all complex numbers `x`, where $\cosh(x)$ and $\sinh(x)$ are the complex hyperbolic cosine and sine of `x`, respectively. These are defined in terms of the complex exponential function: $\cosh(x) = \frac{e^x + e^{-x}}{2}$ and $\sinh(x) = \frac{e^x - e^{-x}}{2}$.

For all complex numbers `x`, the relationship holds: $\frac{e^{2x} + 1}{2} - \frac{e^{2x} - 1}{2} = 1$, or equivalently, $\cosh^2(x) - \sinh^2(x) = 1$.


theorem add_neg_eq_iff_eq_add : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a + -b = c ↔ a = c + b := by sorry

This theorem states that for any type `G` which is an additive group, and any elements `a`, `b` and `c` of `G`, the condition of `a` plus the additive inverse of `b` being equal to `c` is equivalent to `a` being equal to the sum of `c` and `b`. In mathematical terms, it expresses that in an additive group `G`, `a + (-b) = c` if and only if `a = c + b`.

For any additive group `G` and elements `a`, `b` of `G`, `a + (-b) = c` if and only if `a = c + b`.


theorem Finset.sup_eq_union : ∀ {α : Type u_1} [inst : DecidableEq α], Sup.sup = Union.union := by sorry

This theorem, `Finset.sup_eq_union`, states that for any type `α` with decidable equality (i.e., for any two elements `a` and `b` of `α`, it can be decided whether `a = b`), the operation of taking the least upper bound (`Sup.sup`) is the same as the operation of taking the union (`Union.union`). In other words, in a set with decidable equality, the least upper bound of two elements is equivalent to the union of those two elements.

For any type `α` with decidable equality, the least upper bound of two elements is equal to their set union.


theorem CategoryTheory.shift_shiftFunctorCompIsoId_inv_app :
    ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddGroup A]
      [inst_2 : CategoryTheory.HasShift C A] (n m : A) (h : n + m = 0) (X : C),
      (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n m h).inv.app X) =
        (CategoryTheory.shiftFunctorCompIsoId C m n ⋯).inv.app ((CategoryTheory.shiftFunctor C n).obj X) :=
  by sorry

This theorem states that for any categories `C` and `A` where `A` is an additive group and `C` has shift, given two elements `n` and `m` of `A` such that their sum is zero and any object `X` of `C`, the mapping of the inverse application of the compositional isomorphism `CategoryTheory.shiftFunctorCompIsoId` with respect to `n` and `m` under the shift functor `CategoryTheory.shiftFunctor` with respect to `n` is the same as the inverse application of the compositional isomorphism `CategoryTheory.shiftFunctorCompIsoId` with respect to `m` and `n` on the result of the action of the shift functor `CategoryTheory.shiftFunctor` with respect to `n` on the object `X`. This theorem is a part of the properties of the shift functor in category theory, particularly, it demonstrates the compatibility of shift functor with the compositional isomorphism under certain conditions.

For any additive categories `C` with shift and group `A`, the shift functor commutes with the compositional isomorphism under zero-sum elements of `A`, i.e., `(CategoryTheory.shiftFunctorCompIsoId X n).inverse.comp (CategoryTheory.shiftFunctor X n) = (CategoryTheory.shiftFunctorCompIsoId X m).inverse.comp (CategoryTheory.shiftFunctor X m)` when `n + m = 0`.


theorem Function.apply_update₂ :
    ∀ {ι : Sort u_1} [inst : DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} {γ : ι → Sort u_4}
      (f : (i : ι) → α i → β i → γ i) (g : (i : ι) → α i) (h : (i : ι) → β i) (i : ι) (v : α i) (w : β i) (j : ι),
      f j (Function.update g i v j) (Function.update h i w j) =
        Function.update (fun k => f k (g k) (h k)) i (f i v w) j :=
  by sorry

The theorem `Function.apply_update₂` states that for any indices of type `ι` where `ι` has decidable equality, and any functions `f`, `g`, and `h` with appropriate types, updating the values of `g` and `h` at a certain index `i` to `v` and `w` respectively, and then applying `f` at index `j` to the updated `g` and `h`, is the same as updating the function `(fun k => f k (g k) (h k))` at index `i` to `f i v w` and then applying this updated function at index `j`.

In simpler terms, this theorem is about the commutativity of the "update" operation with the function application. It tells us that one can either first update the inputs of a function and then apply the function, or first apply the function on the original inputs and then update the results, and these two processes will give the same output.

For functions `f`, `g`, and `h` with decidable domain `ι`, and any indices `i` and `j`, the update of `g` and `h` at `i` to `v` and `w`, followed by applying `f` at index `j`, is equivalent to applying `f` at index `j` to the original `g` and `h`, then updating the result of `f` at index `i` to `f i v w`.


CauSeq.ext

theorem CauSeq.ext :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α} {f g : CauSeq β abv},
      (∀ (i : ℕ), ↑f i = ↑g i) → f = g :=
  by sorry

The theorem `CauSeq.ext` states that for any types `α` and `β`, where `α` is a linearly ordered field and `β` is a ring, given an absolute value function `abv` from `β` to `α` and any two Cauchy sequences `f` and `g` of `β` with respect to `abv`, if for every natural number `i`, the `i`-th term of `f` equals the `i`-th term of `g`, then `f` and `g` are the same Cauchy sequence. In other words, two Cauchy sequences are equal if and only if their corresponding elements are equal for all indices.

If two Cauchy sequences over a linearly ordered field `α` and a ring `β` with respect to an absolute value function `abv` have equal terms for all indices, then they are equal Cauchy sequences.


IsBoundedBilinearMap.differentiableAt

theorem IsBoundedBilinearMap.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {b : E × F → G},
      IsBoundedBilinearMap 𝕜 b → ∀ (p : E × F), DifferentiableAt 𝕜 b p :=
  by sorry

This theorem states that for any non-trivially normed field 𝕜, if we have a bounded bilinear map `b` from a Cartesian product of two normed vector spaces `E` and `F` into a normed vector space `G` over the field 𝕜, then `b` is differentiable at any point `p` in `E × F`. In other words, the bounded bilinear map `b` admits a derivative at every point in the domain `E × F`.

For any non-trivially normed field 𝕜 and bounded bilinear map `b` from the Cartesian product of two normed vector spaces `E` and `F` into a normed vector space `G`, `b` is differentiable at every point in `E × F`.


theorem Matrix.map_apply :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} {M : Matrix m n α} {f : α → β} {i : m} {j : n},
      Matrix.map M f i j = f (M i j) :=
  by sorry

This theorem states that for any types `m`, `n`, `α`, and `β`, any matrix `M` of type `Matrix m n α`, any function `f` from `α` to `β`, and any indices `i` of type `m` and `j` of type `n`, applying the `Matrix.map` function on `M` with `f` and then retrieving the entry at the ith row and jth column (represented as `Matrix.map M f i j`), is the same as applying `f` directly on the entry of `M` at the ith row and jth column (represented as `f (M i j)`). In other words, `Matrix.map` applies the function `f` to each entry of the matrix `M` in a way that preserves the position of each entry.

For any matrices M of type m x n over types α and β, functions f from α to β, and indices i and j, the application of Matrix.map on M with f and then accessing the entry at row i and column j (Matrix.map M f i j) is equivalent to directly applying f to the entry at row i and column j of M (f (M i j)).


theorem Int.isUnit_iff : ∀ {a : ℤ}, IsUnit a ↔ a = 1 ∨ a = -1 := by sorry

The theorem `Int.isUnit_iff` states that for any integer `a`, `a` is a unit if and only if `a` is either 1 or -1. In the context of monoids, a unit is an element that has a two-sided inverse. Here, the `IsUnit` predicate is used to identify such elements. For the set of integers under multiplication, the only units are 1 and -1, since these are the only integers that have two-sided inverses.

An integer is a unit if and only if it is equal to 1 or -1.


/-- Split equality of linear maps from a product into linear maps over each component, to allow `ext`
to apply lemmas specific to `M →ₗ M₃` and `M₂ →ₗ M₃`.

See note [partially-applied ext lemmas].  -/
theorem LinearMap.prod_ext :
    ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
      [inst_6 : Module R M₃] {f g : M × M₂ →ₗ[R] M₃},
      f ∘ₗ LinearMap.inl R M M₂ = g ∘ₗ LinearMap.inl R M M₂ →
        f ∘ₗ LinearMap.inr R M M₂ = g ∘ₗ LinearMap.inr R M M₂ → f = g :=
  by sorry

The theorem `LinearMap.prod_ext` states that for any semiring `R` and additive commutative monoids `M`, `M₂`, `M₃`, where `M`, `M₂`, `M₃` are also `R`-modules, if we have two linear maps `f` and `g` from the cartesian product of `M` and `M₂` to `M₃`, and if the composition of `f` and `g` with the left injection linear map is equal, and the composition of `f` and `g` with the right injection linear map is also equal, then `f` and `g` are equal. This theorem allows us to split the equality of linear maps from a product into linear maps over each component, aiding us to apply lemmas specific to the individual linear maps.

If two linear maps from the product of two additive commutative monoids (also R-modules) to a third R-module have equal compositions with the left and right injection linear maps, then they are equal.


theorem BoxIntegral.Box.withBotCoe_subset_iff : ∀ {ι : Type u_1} {I J : WithBot (BoxIntegral.Box ι)}, ↑I ⊆ ↑J ↔ I ≤ J :=
  by sorry

This theorem states that for any type `ι` and any two instances `I` and `J` of the type `WithBot (BoxIntegral.Box ι)`, the subset relation `↑I ⊆ ↑J` holds if and only if the relation `I ≤ J` holds. In other words, the subset relationship between the underlying sets of two possible-bottom boxes is equivalent to the order relationship between the possible-bottom boxes. This theorem allows us to make decisions about the subset relationship by checking the less-than-or-equal-to relationship, and vice versa.

For any type `ι` and instances `I` and `J` of `WithBot (BoxIntegral.Box ι)`, `↑I ⊆ ↑J` if and only if `I ≤ J`.


LineDifferentiableAt.hasLineDerivAt

theorem LineDifferentiableAt.hasLineDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {x v : E},
      LineDifferentiableAt 𝕜 f x v → HasLineDerivAt 𝕜 f (lineDeriv 𝕜 f x v) x v :=
  by sorry

The theorem `LineDifferentiableAt.hasLineDerivAt` states that for any function `f` mapping from a vector space `E` to another vector space `F`, if `f` is line-differentiable at a point `x` in the direction `v`, then `f` has a line derivative at that point `x` in the direction `v`. The line derivative is given by the function `lineDeriv 𝕜 f x v` where `𝕜` is a nontrivial normed field. Here, a function is line-differentiable at a point in a direction if it can be approximated by a linear function at that point in that direction as we approach the point along the line.

If a function `f` from a vector space `E` to another vector space `F` is line-differentiable at point `x` in direction `v`, then there exists a linear function `l` such that the limit `∀ε>0. ∃δ>0, ∀h. ‖h‖<δ ⇒ ‖f(x+h) - (f(x) + l(h))‖ < ε‖h‖ holds.


Filter.HasBasis.inf

theorem Filter.HasBasis.inf :
    ∀ {α : Type u_1} {l l' : Filter α} {ι : Type u_6} {ι' : Type u_7} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
      {s' : ι' → Set α},
      Filter.HasBasis l p s →
        Filter.HasBasis l' p' s' → Filter.HasBasis (l ⊓ l') (fun i => p i.1 ∧ p' i.2) fun i => s i.1 ∩ s' i.2 :=
  by sorry

The theorem `Filter.HasBasis.inf` states that for any two filters `l` and `l'` on a type `α`, indexed over types `ι` and `ι'` respectively, with associated properties `p` and `p'` and sets `s` and `s'`, if `l` has a basis characterized by property `p` and associated sets `s`, and `l'` has a basis characterized by property `p'` and associated sets `s'`, then the intersection of the filters `l` and `l'` also has a basis. The basis of the intersection filter is characterized by the properties `p` and `p'` both holding, and the sets are the intersections of the corresponding sets in the bases of `l` and `l'.

If filters `l` and `l'` on type `α` have bases characterized by properties `p` and `p'` and sets `s` and `s'` respectively, then their intersection has a basis with properties `p ∧ p'` and sets `s ∩ s'`.


theorem Mathlib.CategoryTheory.Iso._auxLemma.2 :
    ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h :=
  by sorry

This theorem states that in any category, given four objects W, X, Y, Z and three morphisms f: W → X, g: X → Y, and h: Y → Z, the composition of f with the composition of g and h is equal to the composition of the composition of f and g with h. In other words, this theorem is asserting the associativity of the composition of morphisms in a category, an essential property in category theory.

In any category, the composition of morphisms is associative: (f \*. g) \*. h = f \*. (g \*. h) for morphisms f: W → X, g: X → Y, and h: Y → Z.


Submonoid.LocalizationMap.surj

theorem Submonoid.LocalizationMap.surj :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (z : N),
      ∃ x, z * (Submonoid.LocalizationMap.toMap f) ↑x.2 = (Submonoid.LocalizationMap.toMap f) x.1 :=
  by sorry

The theorem `Submonoid.LocalizationMap.surj` states that for any commutative monoid `M`, submonoid `S` of `M`, commutative monoid `N` and localization map `f` from `S` to `N`, and for any element `z` in `N`, there exists an element `x` such that multiplying `z` by the application of the localization map `f` to the second component of `x` equals the application of the localization map `f` to the first component of `x`. In other words, it says that the localization map is surjective, i.e., for every element in the codomain, there exists a corresponding element in the domain.

For any commutative monoid homomorphism (localization map) from a submonoid to a commutative monoid, the image of the homomorphism is the entire codomain.


theorem Asymptotics.isLittleO_iff_tendsto' :
    ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {f g : α → 𝕜},
      (∀ᶠ (x : α) in l, g x = 0 → f x = 0) → (f =o[l] g ↔ Filter.Tendsto (fun x => f x / g x) l (nhds 0)) :=
  by sorry

The theorem `Asymptotics.isLittleO_iff_tendsto'` states that for any types `α` and `𝕜`, where `𝕜` is a normed division ring, along with a filter `l` on `α` and two functions `f`, `g` from `α` to `𝕜`, given that whenever `g(x)` is zero for some `x` in the neighborhood defined by filter `l`, `f(x)` is also zero, then `f` is little-o of `g` at the filter `l` if and only if the function that sends `x` to `f(x)/g(x)` tends to 0 at the filter `l`.

In other words, `f` is dominated by `g` at the filter `l` (i.e., `f` is little-o of `g`) if and only if the ratio `f(x)/g(x)` approaches 0 as `x` approaches a point in the neighborhood defined by filter `l`, under the condition that `f(x)` is zero whenever `g(x)` is zero.

For functions `f` and `g` from a type `α` to a normed division ring `𝕜`, `f` is little-o of `g` at filter `l` if and only if the quotient `f(x)/g(x)` converges to 0 at filter `l`, provided `f(x) = 0` whenever `g(x) = 0`.


theorem MvPolynomial.bind₂_X_right :
    ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      (f : R →+* MvPolynomial σ S) (i : σ), (MvPolynomial.bind₂ f) (MvPolynomial.X i) = MvPolynomial.X i :=
  by sorry

The theorem `MvPolynomial.bind₂_X_right` states that, for any types `σ`, `R`, and `S` with `R` and `S` being commutative semirings, and given a function `f` mapping from `R` to `MvPolynomial σ S` and any `i` of type `σ`, applying the function `MvPolynomial.bind₂ f` to the degree `1` monomial `MvPolynomial.X i` (in the multivariate polynomial ring over `R` indexed by `σ`) results in the same degree `1` monomial `MvPolynomial.X i`. In other words, the bind operation `MvPolynomial.bind₂` preserves the degree `1` monomials in the polynomial ring over `σ`.

For any commutative semirings R and S, and a function f from R to MvPolynomial (over σ and S), the application of MvPolynomial.bind₂ f to the degree 1 monomial X i in the polynomial ring over σ results in the same degree 1 monomial X i.


/-- `coeq_condition f f'`, for morphisms `f f' : j ⟶ j'`, is the proof that
`f ≫ coeqHom f f' = f' ≫ coeqHom f f'`.
 -/
theorem CategoryTheory.IsFiltered.coeq_condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFilteredOrEmpty C] {j j' : C}
      (f f' : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.IsFiltered.coeqHom f f') =
        CategoryTheory.CategoryStruct.comp f' (CategoryTheory.IsFiltered.coeqHom f f') :=
  by sorry

The theorem `CategoryTheory.IsFiltered.coeq_condition` asserts that for any category `C` (that is either filtered or empty), any two morphisms `f` and `f'` from `j` to `j'` in `C`, the composition of `f` with the coequalizer homomorphism of `f` and `f'` is equal to the composition of `f'` with the same coequalizer homomorphism. In mathematical terms, it states that `f ≫ coeqHom f f' = f' ≫ coeqHom f f'` holds in the category `C`. This equality is essentially the defining property of a coequalizer in category theory.

In any filtered or empty category `C`, the coequalizer homomorphism of morphisms `f` and `f'` commutes with both `f` and `f'`, i.e., `f ∘ coeqHom f f' = f' ∘ coeqHom f f'`.


Real.IsConjExponent.nonneg

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

This theorem named `Real.IsConjExponent.nonneg` states that if `p` and `q` are real numbers such that `p` is the conjugate exponent of `q`, then `p` is nonnegative, i.e., `p` is greater than or equal to zero.

If `p` is the conjugate exponent of a real number `q`, then `p` is nonnegative.


theorem WellFounded.rank_lt_of_rel :
    ∀ {α : Type u} {r : α → α → Prop} {a b : α} (hwf : WellFounded r),
      r a b → WellFounded.rank hwf a < WellFounded.rank hwf b :=
  by sorry

The theorem `WellFounded.rank_lt_of_rel` states that for any type `α` and any well-founded relation `r` on `α`, if `a` and `b` are elements of `α` where the relation `r a b` holds (meaning `a` is related to `b` by `r`), then the rank of `a` under the relation `r` is less than the rank of `b`. This is to say, in a well-founded relation, any element has a rank that is strictly less than the rank of any element it is related to.

In a well-founded relation on a type `α`, if `a` is related to `b` (`r a b` holds), then the rank of `a` is strictly less than the rank of `b`.


theorem MeasureTheory.IsStoppingTime.measurableSpace_const :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] (f : MeasureTheory.Filtration ι m)
      (i : ι), MeasureTheory.IsStoppingTime.measurableSpace ⋯ = ↑f i :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSpace_const` states that for any measurable space `Ω`, type `ι` with a preorder instance, filtration `f` of `ι` on `Ω`, and any `ι` instance `i`, the associated σ-algebra or measurable space with a constant stopping time (where the stopping time is always the same value `i` for all elements of the underlying set `Ω`) is equal to the `i`-th space in the filtration `f`.

For any measurable space `Ω` with a preorder instance, filtration `f` on `ι`, and `ι` instance `i`, the σ-algebra of the constant stopping time `i` equals the `i`-th space in `f`.


theorem Mathlib.Data.Multiset.Powerset._auxLemma.4 :
    ∀ {α : Type u_1} {s t : Multiset α}, (s ∈ Multiset.powerset t) = (s ≤ t) := by sorry

This theorem states that for all types `α` and multisets `s` and `t` of type `α`, `s` is in the power set of `t` if and only if `s` is a subset of `t`. In other words, a multiset `s` is included in the power set of another multiset `t` exactly when every element of `s` is also an element of `t`. This is a common property of power sets in set theory, extended here to multisets, which are like sets but allow duplicate elements.

A multiset is a subset of another multiset if and only if it is an element of that multiset's power set.


OrderTop.bddAbove

/-- When there is a global maximum, every set is bounded above.  -/
theorem OrderTop.bddAbove : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] (s : Set α), BddAbove s := by sorry

The theorem `OrderTop.bddAbove` states that for any type `α` that has a preorder and an order top (a greatest element), every set of this type is bounded above. In other words, for any set `s` of elements of such type `α`, there exists an element in `α` that is greater than or equal to every element in `s`. This holds true because the existence of a global maximum (the order top) serves as an upper bound for all sets.

For any type equipped with a preorder and an order top, every subset has an upper bound.


theorem Equiv.ofInjective_symm_apply :
    ∀ {α : Sort u_1} {β : Type u_2} {f : α → β} (hf : Function.Injective f) (a : α),
      (Equiv.ofInjective f hf).symm { val := f a, property := ⋯ } = a :=
  by sorry

This theorem states that for any injective function `f` from a domain `α` to a codomain `β`, and for any element `a` in `α`, the inverse application of the equivalence between `α` and the range of `f` (which is guaranteed by the injectivity of `f`) to the element in the range of `f` equal to `f(a)` is equal to `a`. Essentially, it confirms that reversing the mapping of `f` through this equivalence will retrieve the original element from the domain `α`.

For any injective function `f` from domain `α` to codomain `β`, `f. inverse (f (x)) = x` for all `x` in `α`.


theorem IsAddUnit.add_neg_cancel : ∀ {α : Type u} [inst : SubtractionMonoid α] {a : α}, IsAddUnit a → a + -a = 0 := by
  sorry

The theorem `IsAddUnit.add_neg_cancel` states that for any type `α` with a `SubtractionMonoid` structure and any element `a` of `α` that is an `AddUnit` (i.e., has a two-sided additive inverse), the sum of `a` and its additive inverse `-a` equals zero. This is essentially the principle that any number plus its negative equals zero, generalised to any additive monoid where certain elements have an additive inverse.

For any additive monoid type `α` and AddUnit `a` in `α`, `a + (-a) = 0`.


theorem List.nodup_attach : ∀ {α : Type u} {l : List α}, List.Nodup (List.attach l) ↔ List.Nodup l := by sorry

This theorem, `List.nodup_attach`, states that for any type `α` and any list `l` of that type, the property of the list `l` having no duplicates (expressed as `List.Nodup l`) is equivalent to the attached list of `l` (expressed as `List.attach l`) having no duplicates. Here, "having no duplicates" means each element in the list appears at most once. The process of "attaching" to a list involves creating a new list with the same elements but each element in the new list also carries a proof that it belongs to the original list.

For any type `α`, the list `l` has no duplicates if and only if its attached list `List.attach l` has no duplicates.


theorem Real.contDiff_sin : ∀ {n : ℕ∞}, ContDiff ℝ n Real.sin := by sorry

This theorem states that the real sine function is continuously differentiable for any natural number `n`, including infinity. In other words, you can take the derivative of the real sine function any number of times (possibly infinite) and the resulting functions are all continuous. This property is often symbolized in mathematics as `Real.sin ∈ Cⁿ(ℝ) for all n ∈ ℕ ∪ {∞}`.

The real sine function belongs to the class of continuously differentiable functions of order `n` on the real numbers for every natural number `n` and infinity.


CategoryTheory.ShortComplex.Exact.map

theorem CategoryTheory.ShortComplex.Exact.map :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S →
        ∀ (F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms F]
          [inst_5 : CategoryTheory.Functor.PreservesLeftHomologyOf F S]
          [inst_6 : CategoryTheory.Functor.PreservesRightHomologyOf F S],
          CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.map S F) :=
  by sorry

This theorem states that in the context of category theory, given a short complex `S` within category `C`, if `S` is exact, then for any functor `F` from `C` to another category `D` that preserves zero morphisms, left homology, and right homology, the short complex resulting from applying the functor `F` to `S` is also exact. This theorem holds for all types `C` and `D` that have the structure of a category and have zero morphisms.

If `S` is a short exact sequence in a category `C` with zero morphisms and `F` is a functor from `C` to another category `D` preserving zero morphisms, left and right homologies, then `F(S)` is an exact sequence in `D`.


theorem Filter.mem_inf_of_inter :
    ∀ {α : Type u} {f g : Filter α} {s t u : Set α}, s ∈ f → t ∈ g → s ∩ t ⊆ u → u ∈ f ⊓ g := by sorry

This theorem states that for any type `α`, given two filters `f` and `g` over `α`, and three sets `s`, `t`, and `u` of elements of type `α`, if `s` is in the filter `f`, `t` is in the filter `g`, and the intersection of sets `s` and `t` is a subset of `u`, then `u` is in the infimum (i.e., the greatest lower bound) of the filters `f` and `g`. In other words, `u` is a member of the filter which is the intersection of `f` and `g`.

Given filters `f` and `g` over type `α`, if `s` in `f`, `t` in `g`, and `s ∩ t ⊆ u`, then `u` is in the infimum of `f` and `g`.


theorem Set.range_diag : ∀ {α : Type u_1}, (Set.range fun x => (x, x)) = Set.diagonal α := by sorry

This theorem states that for any type `α`, the range of the function that maps each element `x` of `α` to the pair `(x, x)` is exactly the diagonal set of `α`. In other words, it says that the set of all pairs `(x, x)` where `x` is an element from `α` (which is what we call the diagonal set of `α`) is exactly the same as the set of all possible outputs (range) of the function that takes any `x` in `α` and pairs it with itself.

The diagonal set of a type `α` equals the range of the function that maps each element `x` in `α` to the pair `(x, x)`.


theorem MeasureTheory.OuterMeasure.coe_smul :
    ∀ {α : Type u_1} {R : Type u_3} [inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal] (c : R)
      (m : MeasureTheory.OuterMeasure α), ↑(c • m) = c • ↑m :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.coe_smul` states that for any type `α`, any type `R` that has a scalar multiplication operation with extended non-negative real numbers (`ENNReal`), and assuming `R` forms a scalar tower with `ENNReal`, then for any scalar `c` of type `R` and any outer measure `m` of type `α`, the coercion of the scalar multiplication of `c` and `m` is equivalent to the scalar multiplication of `c` and the coercion of `m`. In other words, scalar multiplication commutes with the coercion operation in the context of outer measures.

For any outer measure `m` on type `α` and scalar `c` in a type `R` with a commutative scalar multiplication and extended non-negative real numbers, the coercion of `c * m` is equivalent to `c * (coe m)`.


theorem IsUnit.mul_inv_cancel : ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → a * a⁻¹ = 1 := by sorry

This theorem states that for any type `α` that forms a division monoid, given an element `a` of type `α` that is a unit, the product of `a` and its inverse `a⁻¹` equals 1. In mathematical terms, this theorem is expressing that if `a` is a unit in a division monoid (meaning it has a multiplicative inverse), then multiplying `a` by its inverse will yield the multiplicative identity, often denoted as 1. This is a fundamental property of elements with multiplicative inverses in algebraic structures, such as groups and monoids.

In a division monoid, the product of any unit `a` and its multiplicative inverse `a⁻¹` equals the multiplicative identity 1.


theorem Fin.insertNth_zero' : ∀ {n : ℕ} {β : Type v} (x : β) (p : Fin n → β), Fin.insertNth 0 x p = Fin.cons x p := by
  sorry

The theorem `Fin.insertNth_zero'` states that for all natural numbers `n` and for any type `β`, given an element `x` of type `β` and a function `p` mapping from the first `n` natural numbers to `β`, the operation of inserting `x` at the 0th position of a tuple generated by `p` using the `Fin.insertNth` function is equivalent to the operation of adding `x` at the beginning of the tuple using the `Fin.cons` function. In other words, `Fin.insertNth` with the insertion position as 0 behaves the same as `Fin.cons`.

For all natural numbers `n` and type `β`, `Fin.insertNth 0 x (p x::p) = x :: p`, where `x` is an element of `β` and `p` is a function mapping the first `n` natural numbers to `β`.


theorem ContinuousLinearMap.map_tsum :
    ∀ {ι : Type u_5} {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
      [inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂}
      [inst_8 : T2Space M₂] {f : ι → M} (φ : M →SL[σ] M₂), Summable f → φ (∑' (z : ι), f z) = ∑' (z : ι), φ (f z) :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, topological spaces over `M` and `M₂`, and a ring homomorphism `σ` from `R` to `R₂`, if `f` is a summable function from some index set `ι` to `M`, and if `φ` is a continuous linear map from `M` to `M₂` over `σ`, then the continuous linear map of the (infinite) sum of `f` is equal to the (infinite) sum of the continuous linear map of `f`. This essentially asserts that the continuous linear map commutes with the operation of infinite summation.

Given semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, topological spaces over `M` and `M₂`, and a ring homomorphism `σ` from `R` to `R₂`, if `f : ι → M` is a summable function, and `φ : M → M₂` is a continuous linear map over `σ`, then `∑ i ∈ ι φ (f i) = φ (∑ i ∈ ι f i)`.


theorem Nat.bit0_lt_bit1 : ∀ {n m : ℕ}, n ≤ m → bit0 n < bit1 m := by sorry

This theorem states that for all natural numbers `n` and `m`, if `n` is less than or equal to `m`, then `bit0 n` is less than `bit1 m`. Here, `bit0 n` represents the result of adding `n` to itself (equivalent to 2n in mathematics), and `bit1 m` represents the result of adding `m` to itself and then adding one (equivalent to 2m + 1 in mathematics). Thus, the theorem essentially asserts that 2n is less than 2m + 1 whenever n is less than or equal to m.

For all natural numbers n and m, if n <= m then 2*n < 2*m + 1.


/-- A weighted sum of pairwise subtractions, expressed as a subtraction of two
`weightedVSubOfPoint` expressions.  -/
theorem Finset.sum_smul_vsub_eq_weightedVSubOfPoint_sub :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p₁ p₂ : ι → P) (b : P),
      (Finset.sum s fun i => w i • (p₁ i -ᵥ p₂ i)) =
        (Finset.weightedVSubOfPoint s p₁ b) w - (Finset.weightedVSubOfPoint s p₂ b) w :=
  by sorry

This theorem states that for any ring `k`, an additive commutative group `V`, a module `V` over `k`, an additive torsor `V` over a type `P`, a finite set `s` of elements of some type `ι`, a weight function `w` from `ι` to `k`, and two functions `p₁` and `p₂` from `ι` to `P`, and a base point `b` in `P`, the sum over `s` of the scalar multiples of the differences of the images of each element in `s` under `p₁` and `p₂` is equal to the difference of the weighted vectors of `p₁` and `p₂` with respect to `b`, both weighted by `w`. In mathematical terms, it says that $\sum_{i \in s} w(i) \cdot (p_1(i) - p_2(i)) = wVSub(p_1, b) - wVSub(p_2, b)$, where $wVSub$ denotes the weighted vector subtraction.

For any ring `k`, additive commutative group `V`, module `V` over `k`, additive torsor `P`, finite set `s`, weight function `w`, and functions `p₁` and `p₂` from `s` to `P`, and base point `b` in `P`, the weighted sum of scalar multiples of differences of images of elements in `s` under `p₁` and `p₂` equals the weighted difference of the images of `p₁` and `p₂` with respect to `b`.


/-- Finsets form an order-connected suborder of multisets.  -/
theorem Finset.ordConnected_range_val : ∀ {α : Type u_1}, Set.OrdConnected (Set.range Finset.val) := by sorry

The theorem `Finset.ordConnected_range_val` states that for any type `α`, the Finsets of that type form an order-connected suborder of multisets. In other words, for any two elements in the range of the `Finset.val` function, all elements that lie in between these two in the order are also included in the range of `Finset.val`. This basically means that there are no 'gaps' in the ordering of elements in the range of `Finset.val`, establishing it as an order-connected subset of multisets.

For any type `α`, the range of the `Finset.val` function on `Finset α` forms an order-connected subset of multisets over `α`.


theorem Infinite.exists_not_mem_finset : ∀ {α : Type u_1} [inst : Infinite α] (s : Finset α), ∃ x, x ∉ s := by sorry

This theorem states that for any type `α` that is infinite, for any finite set `s` of type `α`, there exists an element `x` of type `α` that is not in `s`. In other words, if you have an infinite set of elements, you can always find an element that is not in any given finite subset of that set.

For any infinite type `α`, there exists an element `x` in `α` not contained in any finite subset.