theorem Stream'.WSeq.flatten_pure :
    ∀ {α : Type u} (s : Stream'.WSeq α), Stream'.WSeq.flatten (Computation.pure s) = s := by sorry

The theorem `Stream'.WSeq.flatten_pure` states that for every weak sequence `s` of some Type `α`, when `s` is encoded into a computation using the `Computation.pure` function and then flattened using the `Stream'.WSeq.flatten` function, it remains the same. This essentially demonstrates that the process of encoding a weak sequence into a computation and then flattening it doesn't change the weak sequence.

For any weak sequence `s` of type `α`, the application of `Stream'.WSeq.flatten` to the computation obtained by encoding `s` using `Computation.pure` is equal to the original weak sequence `s`.


theorem Multiset.le_add_right : ∀ {α : Type u_1} (s t : Multiset α), s ≤ s + t := by sorry

The theorem `Multiset.le_add_right` states that, for any type `α` and any two multisets `s` and `t` of type `α`, `s` is less than or equal to the multiset obtained by adding `s` and `t`. In other words, a multiset `s` is always less than or equal to the union of `s` and any other multiset `t`. This is a property of the partially ordered set structure on multisets, where the order is defined by multiset inclusion.

For any type `α` and multisets `s` and `t` of type `α`, `s ⊆ s ++ t`, where `++` denotes multiset union.


theorem Sym.map_map :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} {n : ℕ} (g : β → γ) (f : α → β) (s : Sym α n),
      Sym.map g (Sym.map f s) = Sym.map (g ∘ f) s :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any natural number `n`, given two functions `g : β → γ` and `f : α → β`, and a n-tuple up to permutation `s` of type `Sym α n` (which is a subtype of `Multiset`), the process of first mapping `s` using `f` and then mapping the result using `g` is equivalent to directly mapping `s` using the composition of `g` and `f`. This property is called the functoriality of the symmetric powers. In mathematical terms, we could say that the map operations for symmetric powers are compatible with function composition, i.e., `Sym.map g (Sym.map f s) = Sym.map (g ∘ f) s`.

For any types `α`, `β`, `γ`, natural number `n`, functions `g : β → γ` and `f : α → β`, and `n-tuple up to permutation s of type Sym α n`, the application of `g` to the image of `s` under `f` is equivalent to the composition of `g` and `f` applied to `s`, i.e., `Sym.map g (Sym.map f s) = Sym.map (g ∘ f) s`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.22 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) := by sorry

This theorem, named `Mathlib.Topology.MetricSpace.Infsep._auxLemma.22`, states that for any types `α` and `β` and a property `p` defined on the Cartesian product of `α` and `β`, stating that the property `p` holds for all pairs `(a, b)` in the product space is equivalent to saying that for every `x` in the Cartesian product `α × β`, the property `p` holds. In other words, the two formulations of universality (one in terms of individual elements `x` from the product space, and the other in terms of pairs `(a, b)`) are logically equivalent.

The theorem `Mathlib.Topology.MetricSpace.Infsep._auxLemma.22` in Lean 4 asserts that for any types `α` and `β` and a property `p` on `α × β`, the statements "for all `(a, b)` in `α × β`, `p(a, b)` holds" and "for all `x` in `α × β`, `p(x)` holds" are logically equivalent.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.23 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem, `Mathlib.Topology.MetricSpace.Infsep._auxLemma.23`, states that for any three propositions `a`, `b`, and `c`, the statement "`a` and `b` imply `c`" is logically equivalent to the statement "`a` implies that `b` implies `c`". In other words, if having both propositions `a` and `b` leads to proposition `c`, then it is the same as saying if `a` is true, then `b` leading to `c` is also true. This is a fundamental theorem in logic, reflecting the associativity of logical implication.

The proposition "`a` implies `b` implies `c`" is logically equivalent to "`a` and `b` imply `c`" for any propositions `a`, `b`, and `c`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.21 :
    ∀ {α : Type u} {x : α × α} {s : Set α}, (x ∈ Set.offDiag s) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) := by sorry

This theorem, `Mathlib.Topology.MetricSpace.Infsep._auxLemma.21`, states that for any type `α`, any pair `x` of type `α × α`, and any set `s` of type `Set α`, the pair `x` belongs to the off-diagonal of `s` if and only if the first element of `x` belongs to `s`, the second element of `x` belongs to `s` and the first element of `x` is not equal to the second element of `x`. In other words, a pair `(a, b)` is in the off-diagonal of a set if and only if both `a` and `b` are in the set and `a` is not equal to `b`.

For any set `s` and type `α`, a pair `(a, b)` in `α × α` lies off-diagonal in `s` if and only if both `a` and `b` are in `s` and `a ≠ b`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.19 :
    ∀ {α : Type u_2} {p : Prop} {q : α → Prop}, (p → ∀ (x : α), q x) = ∀ (x : α), p → q x := by sorry

This theorem, `Mathlib.Topology.MetricSpace.Infsep._auxLemma.19`, states that for any type 'α', any proposition 'p', and any predicate 'q' on 'α', the statement that "if 'p' holds then 'q' holds for all 'x' in 'α'" is equivalent to the statement "for all 'x' in 'α', if 'p' holds then 'q' holds". In other words, it's a proposition about the interchangeability of the universal quantifier and the implication in a certain context.

For any type 'α', proposition 'p' on 'α', and predicate 'q' on 'α', the statements "forall x in α, if p(x) then q(x)" and "if p then forall x in α, q(x)" are equivalent.


theorem MeasureTheory.integral_mono :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ℝ},
      MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → f ≤ g → ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_mono` states that for any two real-valued functions `f` and `g` defined on a measurable space `α` and with a given measure `μ`, if both `f` and `g` are integrable (which means they are measurable and their integral over the measure space is finite), and if `f` is pointwise less than or equal to `g`, then the integral of `f` with respect to `μ` is less than or equal to the integral of `g` with respect to `μ`. In other words, this theorem ensures the monotonicity property of the integral: if `f` is less than or equal to `g` everywhere, then the area under the graph of `f` is less than or equal to the area under the graph of `g`.

If two real-valued, measurable functions `f` and `g` on a measurable space `(α, μ)` are integrable and `f ≤ g` pointwise, then ∫(α, μ, f) ≤ ∫(α, μ, g).


theorem Nat.add_sub_self_left : ∀ (a b : ℕ), a + b - a = b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if we add `a` and `b` together and then subtract `a` from the result, we will be left with `b`. In mathematical terms, it represents the equation `a + b - a = b` for all natural numbers `a` and `b`.

For all natural numbers `a` and `b`, `a + b = a + b - a + a ↔ b`.


theorem IsIntegralClosure.isIntegral_algebra :
    ∀ (R : Type u_1) {A : Type u_2} (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
      [inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] [inst_6 : Algebra R A]
      [inst_7 : IsScalarTower R A B], Algebra.IsIntegral R A :=
  by sorry

The theorem `IsIntegralClosure.isIntegral_algebra` states that for any types `R`, `A`, and `B` where `R` is a commutative ring, `A` and `B` are also commutative rings, `B` is an algebra over both `R` and `A`, `A` is an integral closure of `R` in `B`, and `A` is an algebra over `R` with `A` forming a scalar tower with `R` and `B`, then `A` is an integral algebra over `R`. In simpler terms, every element of `A` is integral over the base ring `R`.

If `R` is a commutative ring, `A` and `B` are commutative rings with `B` an algebra over both `R` and `A`, `A` an integral closure of `R` in `B`, and `A` forming a scalar tower with `R` and `B`, then every element of `A` is integral over `R`.


theorem Set.mem_inv_smul_set_iff₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ (A : Set β) (x : β), x ∈ a⁻¹ • A ↔ a • x ∈ A :=
  by sorry

The theorem `Set.mem_inv_smul_set_iff₀` states for any two types `α` and `β`, where `α` is a group with zero and `β` is a set on which `α` acts multiplicatively, given any nonzero element `a` of `α`, a set `A` of `β`, and an element `x` of `β`, the element `x` is in the set obtained by scaling `A` by the multiplicative inverse of `a` if and only if the result of scaling `x` by `a` is in `A`.

In mathematical terms, for any types `α` and `β` with `α` a group with zero and `β` a `mul_action` of `α`, for any nonzero `a ∈ α`, set `A` of `β`, and `x ∈ β`, we have `x ∈ a⁻¹ • A` if and only if `a • x ∈ A`.

For any group with zero `α`, set `β` with a multiplicative action by `α`, nonzero `a` in `α`, and set `A` in `β`, the element `x` in `β` belongs to the scaled set `a⁻¹ • A` if and only if `a • x` belongs to `A`.


Computable.id

theorem Computable.id : ∀ {α : Type u_1} [inst : Primcodable α], Computable id := by sorry

The theorem `Computable.id` states that, for any type `α` that can be encoded as a primitive (as specified by the typeclass `Primcodable α`), the identity function (`id`) on that type is computable. In other words, it asserts that the identity function on any primitively codable type is partially recursive, where partial recursive functions are a generalization of the familiar recursive functions and can express all computable functions.

The identity function on types encodable as primitives is computable, i.e., partially recursive.


theorem Subgroup.index_eq_card :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : Fintype (G ⧸ H)],
      Subgroup.index H = Fintype.card (G ⧸ H) :=
  by sorry

The theorem `Subgroup.index_eq_card` states that for any group `G` and any subgroup `H` of `G` such that the quotient group `G ⧸ H` is finite, the index of the subgroup `H` in `G` (which is represented as a natural number or zero if the index is infinite) equals the number of elements in the quotient group `G ⧸ H`.

For any finite quotient group G/H of a group G, the index of subgroup H in G equals the number of elements in G/H.


/-- The generic case of the first simplicial identity  -/
theorem SimplexCategory.δ_comp_δ :
    ∀ {n : ℕ} {i j : Fin (n + 2)},
      i ≤ j →
        CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i) (SimplexCategory.δ (Fin.succ j)) =
          CategoryTheory.CategoryStruct.comp (SimplexCategory.δ j) (SimplexCategory.δ (Fin.castSucc i)) :=
  by sorry

The theorem `SimplexCategory.δ_comp_δ` is a statement about the first simplicial identity in the context of a Simplex Category. It states that for any natural number `n` and any two elements `i` and `j` of the finite set {0, ..., n+1} with `i` less than or equal to `j`, the composition of the `i`-th and `succ(j)`-th face maps from `[n]` to `[n+2]` is equal to the composition of the `j`-th and `castSucc(i)`-th face maps. The face maps are morphisms in the Simplex Category, and their composition is defined by the `CategoryTheory.CategoryStruct.comp` function. The `succ` and `castSucc` functions are used to embed a given finite set into a larger one by incrementing the elements or adding 1 to the size of the set, respectively.

For any $n$ and $0 \leq i \leq j \leq n+1$, the composition of the $i$-th and $(j+1)$-th face maps in the simplex category of dimension $n$ equals the composition of the $j$-th and $(i+1)$-th face maps.


theorem CategoryTheory.ShortComplex.cyclesMap_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasLeftHomology S₂] (φ : S₁ ⟶ S₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap φ)
          (CategoryTheory.ShortComplex.iCycles S₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.iCycles S₁) φ.τ₂ :=
  by sorry

This theorem in the category theory states that for any category `C` that has zero morphisms, and any two short complexes `S₁` and `S₂` in `C` that both have left homology, the composition of the cycles map of a morphism `φ` from `S₁` to `S₂` and the inclusion from the cycles of `S₂` to `S₂.X₂` is equal to the composition of the inclusion from the cycles of `S₁` to `S₁.X₂` and the differential `τ₂` of `φ`. In other words, the diagram commutes in the category `C` for the given morphism `φ`, which means that moving along any path in the diagram from the cycles of `S₁` to `S₂.X₂` results in the same morphism.

For any category with zero morphisms `C` and short complexes `S₁` and `S₂` having left homology, the composition of the cycles inclusion of `S₁` into `S₁.X₂` and the differential of a morphism `φ` from `S₁` to `S₂`, and the cycles inclusion of `S₂` into `S₂.X₂`, is equal to the cycles inclusion of `S₁` into `S₂.X₂` and the composition of the cycles map of `φ` with the differential of `S₂.X₂`.


theorem Matrix.updateColumn_ne :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n]
      {j' : n}, j' ≠ j → Matrix.updateColumn M j c i j' = M i j' :=
  by sorry

The theorem `Matrix.updateColumn_ne` states that, for any given matrix `M` with entries of type `α`, indexed by types `m` and `n` for rows and columns respectively, and for any `i` of type `m`, `j` and `j'` of type `n`, and a function `c` from `m` to `α`. If we update the `j`th column of `M` with the values given by function `c`, and we have `j` not equal to `j'`, then the entry in the `i`th row and `j'`th column of the updated matrix is the same as the entry in the `i`th row and `j'`th column of the original matrix `M`. This theorem relies on the ability to decide equality between elements of type `n`.

For any matrix M with entries of type α indexed by m and n, and any i of type m, j, j' of type n, and function c from m to α, if we update the j-th column of M with values given by c and j ≠ j', then the (i, j')-th entry of the updated matrix is equal to the (i, j')-th entry of the original matrix M.


Finset.hasSum

theorem Finset.hasSum :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : Finset β) (f : β → α),
      HasSum (f ∘ Subtype.val) (Finset.sum s fun b => f b) :=
  by sorry

The theorem `Finset.hasSum` asserts that, for all types `α` and `β` with `α` being an additive commutative monoid and a topological space, and for any finite set `s` of type `β` and any function `f` from `β` to `α`, the sum of the function `f` after applying the subtype value function (`Subtype.val`) has a sum, and that sum is equal to the sum of `f` over the elements of the finite set `s`. Essentially, it states that the sum of the function values over the elements of `s` is the same whether we consider those elements as pure elements of type `β` or as elements of the subtype of `β`.

For any additive commutative monoid and topological space type `α`, finite set `s` of type `β`, and function `f` from `β` to `α`, the sum of `f` over the elements of `s` is equal to the sum of `Subtype.val (s : Set β) . f` in `α`.


theorem Equiv.Perm.extendDomain_apply_image :
    ∀ {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [inst : DecidablePred p] (f : α' ≃ Subtype p)
      (a : α'), (Equiv.Perm.extendDomain e f) ↑(f a) = ↑(f (e a)) :=
  by sorry

The theorem `Equiv.Perm.extendDomain_apply_image` states that for all types `α'` and `β'`, given a permutation `e` of `α'`, a decidable predicate `p` on `β'`, and a bijective function `f` from `α'` to the subtype of `β'` satisfying `p`, then for any element `a` of `α'`, the extended permutation applied to the image of `a` under `f` is equal to the image of the image of `a` under `e` through `f`. In other words, this theorem is about the interaction between the projection of a permutation and the extension of a permutation with the same bijective function.

Given a permutation `e` of type `α'`, a bijective function `f` from `α'` to a subtype of `β'` satisfying a decidable predicate `p`, and an element `a` of `α'`, the extended permutation applied to `f(a)` is equal to `f(e(a))`.


/-- Two `RingHom`s from the quotient by an ideal are equal if their
compositions with `Ideal.Quotient.mk'` are equal.

See note [partially-applied ext lemmas].  -/
theorem Ideal.Quotient.ringHom_ext :
    ∀ {R : Type u} [inst : CommRing R] {I : Ideal R} {S : Type v} [inst_1 : NonAssocSemiring S] ⦃f g : R ⧸ I →+* S⦄,
      RingHom.comp f (Ideal.Quotient.mk I) = RingHom.comp g (Ideal.Quotient.mk I) → f = g :=
  by sorry

The theorem `Ideal.Quotient.ringHom_ext` states that for a given commutative ring `R`, an ideal `I` of `R`, a non-associative semiring `S`, and two ring homomorphisms `f` and `g` from the quotient ring `R/I` to `S`, if the composition of `f` and the quotient map `Ideal.Quotient.mk I` is equal to the composition of `g` and `Ideal.Quotient.mk I`, then `f` and `g` must be equal. Essentially, this means that two ring homomorphisms from the quotient by an ideal are determined by their action on the elements of the original ring `R`.

Given a commutative ring `R`, an ideal `I` of `R`, a non-associative semiring `S`, and two ring homomorphisms `f` and `g` from `R/I` to `S`, if `f ∘ Ideal.Quotient.mk I = g ∘ Ideal.Quotient.mk I`, then `f = g`.


theorem nhds_basis_uniformity' :
    ∀ {α : Type ua} {ι : Sort u_1} [inst : UniformSpace α] {p : ι → Prop} {s : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p s → ∀ {x : α}, Filter.HasBasis (nhds x) p fun i => UniformSpace.ball x (s i) :=
  by sorry

The theorem `nhds_basis_uniformity'` states that for any type `α` equipped with a `UniformSpace` structure, and for any index type `ι`, given a filter basis `s` indexed by `ι` on the uniformity of `α`, which satisfies some property `p`, then for each point `x` in `α`, the neighborhood filter at `x` has a filter basis consisting of balls centered at `x` with respect to each set in the given filter basis `s`.

In other words, we can generate the neighborhood filter at a point by taking 'balls' around that point, where these balls are defined in terms of sets from the uniformity filter basis of the space. The index set `ι` and property `p` are carried over from the uniformity filter basis to the neighborhood filter basis.

Given a uniform space (α, U) and a filter basis s on U satisfying property p, for each x in α, the neighborhood filter at x is generated by balls centered at x with respect to sets in s.


/-- Every edge in a walk's edge list is an edge of the graph.
It is written in this form (rather than using `⊆`) to avoid unsightly coercions.  -/
theorem SimpleGraph.Walk.edges_subset_edgeSet :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v) ⦃e : Sym2 V⦄,
      e ∈ SimpleGraph.Walk.edges p → e ∈ SimpleGraph.edgeSet G :=
  by sorry

This theorem states that every edge in the list of edges visited in order by a walk on a simple graph is an actual edge of the graph. In other words, for any walk `p` from vertex `u` to vertex `v` on a simple graph `G` of vertices of type `V`, and for any edge `e` represented as an unordered pair of vertices, if `e` is in the list of edges traversed by `walk p`, then `e` is in the set of edges of `G`. This essentially asserts that a walk on a graph cannot include edges that are not present in the graph itself.

For any simple graph $G$ and walk $p$ from vertex $u$ to vertex $v$, every edge in the traversed by the walk belongs to the graph $G$.


theorem Nat.coprime_one_left : ∀ (n : ℕ), Nat.Coprime 1 n := by sorry

The theorem `Nat.coprime_one_left` asserts that for any natural number `n`, the number `n` and `1` are coprime. In other words, the greatest common divisor (gcd) of `n` and `1` is `1`, which is the definition of two numbers being coprime. This is a universal property of natural numbers as `1` is a unit in the ring of integers and has no other divisors apart from `1` and `-1`, making it coprime with every number.

For every natural number n, the greatest common divisor of n and 1 is 1. (i.e. n and 1 are coprime.)


/-- If `r` is a positive constant, `fun x ↦ r * f x` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter.  -/
theorem Filter.tendsto_const_mul_atTop_of_pos :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedSemifield α] {l : Filter β} {f : β → α} {r : α},
      0 < r → (Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop) :=
  by sorry

The theorem `Filter.tendsto_const_mul_atTop_of_pos` states that given a positive constant `r`, the function `f` multiplied by `r` tends to infinity along a particular filter if and only if the function `f` itself tends to infinity along the same filter. This holds for any filter `l` and any function `f` mapping from a type `β` to a type `α`, where `α` is a linear ordered semifield. In other words, scaling a function by a positive factor does not change the fact whether or not it tends to infinity.

Given a positive constant `r` and a function `f` from a type `β` to a linear ordered semifield `α`, if `f` tends to infinity along a filter `l`, then `rf` also tends to infinity along `l`.


theorem Mathlib.MeasureTheory.Measure.MeasureSpace._auxLemma.27 :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (↑↑μ Set.univ = 0) = (μ = 0) := by sorry

This theorem states that for any type `α`, any measurable space `m0` on `α`, and any measure `μ` on this measurable space, the measure of the universal set (i.e., the set containing all elements of the type `α`) being equal to zero is equivalent to the measure itself being zero. In other words, it says that if the total measure of all possible elements is zero, then the only possible measure is the zero measure.

For any measurable space `(α, m0)` and measure `μ` on `α`, `measure μ (univ α) = 0` if and only if `μ = 0`.


theorem Mathlib.Algebra.Group.Basic._auxLemma.8 :
    ∀ {M : Type u} [inst : AddLeftCancelMonoid M] {a b : M}, (a = a + b) = (b = 0) := by sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.8`, states that for any type `M` that forms an additive left-cancellable monoid, for any two elements `a` and `b` in the monoid, `a` is equal to `a + b` if and only if `b` is the zero element of the monoid. This is because in an additive left-cancellable monoid, the cancellation law allows any term that appears on both sides of an equation to be subtracted out.

In an additive left-cancellative monoid, for all elements `a` and `b`, `a = a + b` if and only if `b` is the additive identity.


theorem CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryCofan X Y},
      CategoryTheory.Limits.IsColimit s →
        ∀ {f g : s.pt ⟶ W},
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl s) f =
              CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl s) g →
            CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inr s) f =
                CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inr s) g →
              f = g :=
  by sorry

This theorem, `CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext`, states that in any category `C`, for any three objects `W`, `X`, `Y` and a binary cofan `s` of `X` and `Y`, if `s` is a colimit, then for any two morphisms `f` and `g` from the point of `s` to `W`, if the composition of `f` (respectively, `g`) and the first inclusion of `s` equals the composition of `g` (respectively, `f`) and the first inclusion of `s`, and the composition of `f` (respectively, `g`) and the second inclusion of `s` equals the composition of `g` (respectively, `f`) and the second inclusion of `s`, then `f` equals `g`.

In other words, the morphisms from the colimit of the binary cofan to any object are uniquely determined by their composition with the inclusions of the binary cofan.

In any category with binary cocones, if a binary cocone is a colimit, then any two morphisms from the point to the domain of the cocone with equal compositions with both inclusions are equal.


theorem lt_iSup_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, a < iSup f ↔ ∃ i, a < f i := by
  sorry

The theorem `lt_iSup_iff` states that for any type `α` that has a complete linear order, a value `a` of type `α`, and a function `f` from some type `ι` to `α`, `a` is less than the indexed supremum of `f` if and only if there exists an element `i` of type `ι` such that `a` is less than `f(i)`. In mathematical terms, this is saying that $a$ is less than the supremum of the range of $f$ if and only if there exists an $i$ in the domain of $f$ such that $a$ is less than $f(i)$.

For any complete linear order `α`, element `a` of `α`, and function `f` from some type `ι` to `α`, `a` is less than the indexed supremum of `f` if and only if there exists an `i` in `ι` such that `a` is less than `f(i)`. Or mathematically, $a < \sup\_{i\in \mathrm{dom}(f)} f(i)$.


theorem upperClosure_singleton : ∀ {α : Type u_1} [inst : Preorder α] (a : α), upperClosure {a} = UpperSet.Ici a := by
  sorry

This theorem states that for any given element 'a' in a preordered set 'α', the greatest upper set (upperClosure) containing just that element '{a}' is equivalent to the smallest upper set (UpperSet.Ici) that contains 'a'. Here, an upper set is a subset of some preordered set, in which, if an element is included then all greater elements are also included.

The greatest upper set containing just the element 'a' in a preordered set equals the smallest upper set that contains 'a'. In other words, upperClosure {'a'} = UpperSet.Ici 'a'.


theorem Homeomorph.preimage_closure :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (s : Set Y),
      ⇑h ⁻¹' closure s = closure (⇑h ⁻¹' s) :=
  by sorry

The theorem `Homeomorph.preimage_closure` states that for any two topological spaces `X` and `Y`, and for any homeomorphism `h` from `X` to `Y`, and for any set `s` in `Y`, the preimage of the closure of `s` under the homeomorphism `h` is equal to the closure of the preimage of `s` under `h`. In other words, if we first take the closure of a set and then apply the inverse of a homeomorphism, it's the same as if we first applied the inverse of the homeomorphism and then took the closure. This can be expressed mathematically as: for all `s`, `h⁻¹(closure(s)) = closure(h⁻¹(s))`.

For any homeomorphism between topological spaces and any set, the preimages of each other's closures are equal: `h⁻¹(closure(s)) = closure(h⁻¹(s))`.


Equiv.Perm.SameCycle.refl

theorem Equiv.Perm.SameCycle.refl : ∀ {α : Type u_2} (f : Equiv.Perm α) (x : α), Equiv.Perm.SameCycle f x x := by sorry

This theorem states that for any type `α`, any permutation `f` of `α`, and any element `x` of `α`, `x` is in the same cycle as itself under the permutation `f`. In other words, for any element and any permutation, there exists some integer `i` such that applying the permutation `f` `i` times to `x` returns `x` itself. This is a reflexivity property of the `SameCycle` relation for permutations.

For any permutation `f` and element `x` in a type `α`, `x` is in the same cycle as `x` under `f`. (Or, more formally, for all `α`, `f: α → α`, and `x: α`, `SameCycle f x x` holds in Lean.)


/-- Two different points can be separated by open sets.  -/
theorem t2_separation :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {x y : X},
      x ≠ y → ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v :=
  by sorry

The theorem `t2_separation` states that in any T2 space (also known as a Hausdorff space), for any two distinct points, there exist two open sets such that each point belongs to one of the open sets and the open sets are disjoint. This means, in the context of topology, that given the points `x` and `y` are different, there are open sets `u` and `v` where `x` is in `u`, `y` is in `v`, and there is no overlap between `u` and `v`. The disjointness of the sets is defined in general lattice terms, i.e., their infimum (greatest lower bound) is the bottom element.

In a T2 space, given any two distinct points, there exist open sets containing each point that are disjoint, i.e., have an empty intersection.


theorem HahnSeries.mem_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
      a ∈ HahnSeries.support x ↔ x.coeff a ≠ 0 :=
  by sorry

The theorem `HahnSeries.mem_support` states that for any given types `Γ` and `R`, where `Γ` has a partial order and `R` has a zero element, and for any Hahn Series `x` of type `HahnSeries Γ R` and any element `a` of type `Γ`, `a` is in the support of the Hahn Series `x` if and only if the coefficient of `a` in `x` is not equal to zero. In other words, the support of a Hahn Series is precisely the set of indices whose corresponding coefficients in the series are non-zero.

The support of a Hahn Series over a partially ordered type and a ring with zero element equals the set of indices corresponding to non-zero coefficients.


Polynomial.continuous

theorem Polynomial.continuous :
    ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : TopologicalSpace R] [inst_2 : TopologicalSemiring R]
      (p : Polynomial R), Continuous fun x => Polynomial.eval x p :=
  by sorry

The theorem `Polynomial.continuous` states that for any semiring `R` with a topological structure, that is also a topological semiring, the evaluation function, `Polynomial.eval`, is continuous for any given polynomial `p` of type `Polynomial R`. This means that for any point `x` in the semiring, the values of `Polynomial.eval` for points close to `x` are close to the value of `Polynomial.eval` at `x`. This is a property required in mathematical analysis to ensure that the polynomial functions behave well under limits and continuity operations.

For any topological semiring `R` and polynomial `p` over `R`, the evaluation function `Polynomial.eval p` is continuous.


theorem WithOne.cases_on : ∀ {α : Type u} {P : WithOne α → Prop} (x : WithOne α), P 1 → (∀ (a : α), P ↑a) → P x := by
  sorry

This theorem, `WithOne.cases_on`, is a case analysis principle for an extended type `WithOne α`. Given an arbitrary type `α`, the function `WithOne` adds a new element `1` to the type `α`. This theorem states that for any property `P` that might hold over the elements of the type `WithOne α`, and for any element `x` of `WithOne α`, if `P` holds for `1` and `P` also holds for any element of `α` (when considered as an element of `WithOne α`), then `P` must hold for `x`. This theorem is essentially a way to perform case analysis over the members of the type `WithOne α`, separating the 'extra' element `1` and the 'original' elements from `α`.

For any property `P` and element `x` of `WithOne α`, if `P` holds for `1` in `WithOne α` and `P` holds for all elements of `α` considered as elements of `WithOne α`, then `P` holds for `x`.


theorem Padic.norm_eq_pow_val :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℚ_[p]}, x ≠ 0 → ‖x‖ = ↑p ^ (-Padic.valuation x) := by sorry

This theorem, named `Padic.norm_eq_pow_val`, states that for any non-zero rational number `x` in the `p`-adic number field `ℚ_[p]` (where `p` is a prime number), the `p`-adic norm of `x` (denoted by `‖x‖`) is equal to `p` raised to the power of the negative `p`-adic valuation of `x`. This implies a connection between the `p`-adic norm and `p`-adic valuation of a `p`-adic number, reflecting a fundamental property of `p`-adic numbers.

For any non-zero $p$-adic number $x$ in the field $\mathbb{Q}_p$, its $p$-adic norm $\|x\|$ equals $p^{-v_p(x)}$, where $v_p(x)$ is the $p$-adic valuation of $x$.


theorem bijective_frobenius :
    ∀ (R : Type u_1) (p : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p],
      Function.Bijective ⇑(frobenius R p) :=
  by sorry

This theorem states that for any commutative semiring `R` of a certain type, and any natural number `p`, given that the exponential characteristic of `R` is `p` and `R` is a perfect ring, the Frobenius map, which sends each element `x` of `R` to `x^p`, is a bijective function. In other words, the Frobenius map is both injective (no two different elements in `R` will be mapped to the same element in `R`) and surjective (for each element in `R`, there is an element in `R` that maps to it).

Given a commutative semiring of characteristic `p` and being a perfect ring, the Frobenius map is a bijective function.


theorem tsub_eq_of_eq_add_rev :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α} [inst : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a = b + c → a - b = c :=
  by sorry

This theorem states that for any type `α` that has a partial order, addition that is commutative, subtraction, and an ordered subtraction operation, and a contravariant class between `α` and the operations of addition and less than or equal to comparison, if `a` is equal to the sum of `b` and `c`, then the result of subtracting `b` from `a` is equal to `c`. The proof of this theorem is omitted.

For any type `α` with a commutative addition, subtraction, and a contravariant subtraction relation, if `a = b + c`, then `a - b = c`.


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

This theorem states that for any given type `α` that forms a subtraction commutative monoid (a mathematical structure with a defined subtraction operation that is both associative and commutative), the negation of the difference between two elements `a` and `b` of that type is equal to the difference between the negation of `a` and the double negation of `b`. Specifically, it states that `-(a - b) = -a - -b` for all `a` and `b` in `α`.

For any commutative subtraction monoid type `α`, the negation of `a - b` equals `-a - (-b)` for all `a` and `b` in `α`.


theorem Dvd.dvd.modEq_zero_nat : ∀ {n a : ℕ}, n ∣ a → a ≡ 0 [MOD n] := by sorry

This theorem states that for all natural numbers `n` and `a`, if `n` divides `a` (denoted by `n ∣ a`), then `a` is congruent to 0 modulo `n` (denoted by `a ≡ 0 [MOD n]`). In other words, if `n` is a divisor of `a`, then the remainder of `a` when divided by `n` is 0.

If `n` divides `a`, then `a` is congruent to 0 modulo `n`. (In other words, `n` being a divisor of `a` implies `a`'s remainder when divided by `n` is 0.)


theorem ZeroMemClass.coe_zero :
    ∀ {A : Type u_4} {M₁ : Type u_5} [inst : SetLike A M₁] [inst_1 : Zero M₁] [hA : ZeroMemClass A M₁] (S' : A),
      ↑0 = 0 :=
  by sorry

This theorem, `ZeroMemClass.coe_zero`, states that for any type `A` and `M₁`, given that `A` has a `SetLike` instance, `M₁` has a `Zero` instance, and there exists a `ZeroMemClass` instance between `A` and `M₁`, if `S'` is an element of `A`, then the coercion of `0` to `M₁` is equal to `0`. In simpler terms, it means that zero remains zero after being transformed from one type to another under the provided conditions.

For any type `A` with a `SetLike` instance, any type `M₁` with a `Zero` instance, and given a `ZeroMemClass` instance between `A` and `M₁`, the coercion of `0` from `M₁` is equal to the zero element of `A`.


theorem uniqueDiffWithinAt_univ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E}, UniqueDiffWithinAt 𝕜 Set.univ x :=
  by sorry

This theorem, `uniqueDiffWithinAt_univ`, states that for any nontrivially normed field `𝕜` and any normed commutative additive group `E` that is also a normed space over `𝕜`, for any element `x` from `E`, the property `UniqueDiffWithinAt 𝕜 Set.univ x` holds. In more mathematical terms, this theorem says that for any vector space `E` over a non-trivially normed field `𝕜`, at any point `x` in `E`, the unique differential within the universal set of `E` at `x` exists. This is a key concept in differential geometry and analysis, emphasizing the universality of differential structures within the entire space.

For any nontrivially normed field `𝕜` and normed commutative additive group `E` over `𝕜`, at each point `x` in `E`, there exists a unique linear map `df : E → 𝕜` such that the limit `∃(ε : ℝ > 0), ∀(h : E), ||h - x|| < ε → ||df h - df x|| < ||h - x||` holds.


theorem Nat.Prime.eq_one_or_self_of_dvd : ∀ {p : ℕ}, Nat.Prime p → ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p := by sorry

This theorem states that for any natural number `p` that is prime, and any other natural number `m`, if `m` divides `p` then `m` must be either `1` or `p` itself. This is a property of prime numbers, which are defined as natural numbers greater than or equal to 2 that have no other divisors except for `1` and themselves.

For any prime natural number `p` and any natural number `m` dividing `p`, `m` is equal to 1 or `p`.


theorem pathConnectedSpace_iff_univ :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], PathConnectedSpace X ↔ IsPathConnected Set.univ := by sorry

This theorem defines a condition for a topological space to be path connected. Specifically, it states that for any given type `X` with an instance of a topological space, `X` is a path-connected space if and only if the universal set of `X` is path-connected. In more mathematical terms, this means that a space is path-connected when there exists a continuous function that connects any two points in the space without leaving the space, and this condition is equivalent to the universal set (the set of all elements) being path-connected.

A topological space `X` is path-connected if and only if its underlying set is path-connected.


/-- `Specialization of `Finset.sum_nbij'` that automatically fills in most arguments.

See `Fintype.sum_equiv` for the version where `s` and `t` are `univ`. -/
theorem Finset.sum_equiv :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (e : ι ≃ κ),
      (∀ (i : ι), i ∈ s ↔ e i ∈ t) →
        (∀ i ∈ s, f i = g (e i)) → (Finset.sum s fun i => f i) = Finset.sum t fun i => g i :=
  by sorry

The theorem `Finset.sum_equiv` states that for any two finite sets `s` and `t` of types `ι` and `κ` respectively, and any two functions `f : ι → α` and `g : κ → α` where `α` is a type with an addition operation that is commutative and has a neutral element (an additive commutative monoid), if there exists a bijective function `e : ι ≃ κ` such that each element in `s` corresponds to an element in `t` via `e`, and `f` and `g` are the same function after applying this correspondence, then the sum of `f` over all elements in `s` is equal to the sum of `g` over all elements in `t`. In other words, under these conditions, the summation operation is invariant under the change of variables defined by `e`.

Given finite sets $s$ and $t$ of types $\xi$ and $\kappa$, functions $f : s \to \alpha$ and $g : t \to \alpha$ with commutative additive monoid $\alpha$, and a bijective function $e : s \cong t$ such that $f \circ e = g$, then $\sum\_{x : s} f(x) = \sum\_{y : t} g(y)$.


theorem CategoryTheory.ShortComplex.f_pOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.CategoryStruct.comp S.f (CategoryTheory.ShortComplex.pOpcycles S) = 0 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.f_pOpcycles` asserts that for any given Short Complex `S` in a category `C` with zero morphisms, the composition of the morphism `S.f` with the projection `S.pOpcycles` is equal to the zero morphism. This holds under the assumption that `S` has a right homology. In mathematical terms, this is saying that $S.f \circ S.pOpcycles = 0$.

Given a Short Complex `S` in a category `C` with zero morphisms and having right homology, the composite of `S.f` with `S.pOpcycles` equals the zero morphism.


/-- When an inner product space `E` over `𝕜` is considered as a real normed space, its inner
product satisfies `IsBoundedBilinearMap`.

In order to state these results, we need a `NormedSpace ℝ E` instance. We will later establish
such an instance by restriction-of-scalars, `InnerProductSpace.rclikeToReal 𝕜 E`, but this
instance may be not definitionally equal to some other “natural” instance. So, we assume
`[NormedSpace ℝ E]`.
 -/
theorem isBoundedBilinearMap_inner :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      [inst_3 : NormedSpace ℝ E], IsBoundedBilinearMap ℝ fun p => ⟪p.1, p.2⟫_𝕜 :=
  by sorry

This theorem states that for any inner product space `E` over a field `𝕜` which is equipped with a structure of real normed space, the inner product operation is a bounded bilinear map. Bilinearity here means that the inner product operation is linear in each of its two arguments, and boundedness means that there is a real number such that the inner product of any two elements of `E` doesn't exceed this number. These properties are fundamental in functional analysis and are used in many contexts such as the study of operators on Hilbert spaces.

In an inner product space over a real field with a real norm, the inner product is a bounded, bilinear map.


/-- Calculate the integral of `(g ∘ f)`, where `g : β → ℝ≥0∞` and `f : α →ₛ β`.   -/
theorem MeasureTheory.SimpleFunc.map_lintegral :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (g : β → ENNReal)
      (f : MeasureTheory.SimpleFunc α β),
      MeasureTheory.SimpleFunc.lintegral (MeasureTheory.SimpleFunc.map g f) μ =
        Finset.sum (MeasureTheory.SimpleFunc.range f) fun x => g x * ↑↑μ (↑f ⁻¹' {x}) :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.map_lintegral` states that for any measurable space `α`, function `g` from `β` to the extended nonnegative real numbers `ENNReal`, and a simple function `f` from `α` to `β`, the integral of the function `g` composed with `f` with respect to a measure `μ` is equal to the sum, over the range of `f`, of the product of `g(x)` and the measure of the preimage of `x` under `f`. In other words, it's calculating the integral of `(g ∘ f)` in terms of the values of `f` and `g` and the measure `μ`.

For any measurable spaces α, β, measurable function f: α → β, simple function g: β → [0, +∞], and measure μ on α, the integral of g ∘ f with respect to μ is equal to the sum, over the range of f, of the products g(x) * μ(f^-1(x)).


theorem Real.continuousOn_log : ContinuousOn Real.log {0}ᶜ := by sorry

The theorem `Real.continuousOn_log` states that the real logarithm function is continuous at all points except zero. This means that for all real numbers, with the exception of zero, the logarithm function transitions smoothly without any sudden jumps or discontinuities. This continuity is in line with the extension of the real logarithm function from negative infinity to zero, maintaining the formula `log (x * y) = log x + log y` for all nonzero `x` and `y`, and ensuring that the derivative of `log` is `1/x` away from `0`.

The logarithm function is continuous for all real numbers except zero.


theorem Set.not_bounded_iff : ∀ {α : Type u} {r : α → α → Prop} (s : Set α), ¬Set.Bounded r s ↔ Set.Unbounded r s := by
  sorry

This theorem states that for any given type `α` and a relation `r` on `α`, a set `s` of type `α` is not bounded under relation `r` if and only if it is unbounded under the same relation. In other words, a 'bounded' set has an element such that every element in the set is related to it through `r`, and an 'unbounded' set has the property that for every element of type `α`, there exists an element in the set that does not have this relation with the element of type `α`. The theorem asserts the equivalence of the negation of the former condition and the latter condition.

A set is unbounded under a relation if and only if it is not bounded and there exists no upper bound in the set with respect to that relation.


RingEquiv.surjective

theorem RingEquiv.surjective :
    ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S),
      Function.Surjective ⇑e :=
  by sorry

The theorem `RingEquiv.surjective` states that for any two types `R` and `S` with multiplication (`Mul`) and addition (`Add`) operations, if there exists a ring equivalence `e` between `R` and `S`, then `e` is a surjective function. In other words, for every element in `S`, there is an element in `R` such that applying `e` to this element of `R` gives the original element of `S`.

If `e: R ≃ R'` is a ring equivalence between rings `(R, +, *)` and `(R', +', *)`, then `e` is a surjective function.


theorem CategoryTheory.Limits.zero_of_target_iso_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y), (Y ≅ 0) → f = 0 :=
  by sorry

This theorem states that in the context of category theory, given a category `C` with a zero object and zero morphisms, for any objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y`, if `Y` is isomorphic to the zero object in the category, then the morphism `f` is the zero morphism. This can be thought of as a generalized form of the property in algebra that any function mapping into a zero object (analogous to a zero vector space) must be a zero function (a function that only outputs zero).

In a category with a zero object and zero morphisms, if an object is isomorphic to the zero object, then any morphism to it is a zero morphism.


theorem Submonoid.LocalizationMap.eq_iff_exists :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) {x y : M},
      (Submonoid.LocalizationMap.toMap f) x = (Submonoid.LocalizationMap.toMap f) y ↔ ∃ c, ↑c * x = ↑c * y :=
  by sorry

The theorem `Submonoid.LocalizationMap.eq_iff_exists` states that for any commutative monoid `M`, submonoid `S` of `M`, and commutative monoid `N`, if `f` is a localization map from `S` to `N`, then for any elements `x` and `y` of `M`, the equality of `f(x)` and `f(y)` in `N` is equivalent to there being an element `c` in `S` such that `c * x = c * y` in `M`. In other words, the images of two elements under the localization map are equal if and only if their products with some element in the submonoid are equal.

For any commutative monoids M, S, and N, and localization map f from S to N, the equality of f(x) and f(y) in N holds if and only if there exists c in S such that x * c = y * c in M.


theorem IsConnected.subset_connectedComponent :
    ∀ {α : Type u} [inst : TopologicalSpace α] {x : α} {s : Set α}, IsConnected s → x ∈ s → s ⊆ connectedComponent x :=
  by sorry

The theorem `IsConnected.subset_connectedComponent` states that for any type `α` with a topology, and for any set `s` of type `α` and an element `x` of type `α`, if `s` is a connected set and `x` is an element of `s`, then `s` is a subset of the connected component of `x`. In other words, every connected set that contains a given point is contained within the maximal connected set (the connected component) that contains the same point.

For any topological space (α, T), connected set s ⊆ α, and x ∈ s, the subset s is included in the connected component of x.


theorem Set.image_image2_antidistrib :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {f : α → β → γ}
      {s : Set α} {t : Set β} {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'},
      (∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)) → g '' Set.image2 f s t = Set.image2 f' (g₁ '' t) (g₂ '' s) :=
  by sorry

This theorem states that for any pair of sets `s` and `t` of types `α` and `β` respectively, any binary function `f` mapping elements of `α` and `β` to `γ`, and any functions `g` mapping `γ` to `δ`, `f'` mapping `β'` to `α'` and then to `δ`, and `g₁`, `g₂` mapping `β` to `β'` and `α` to `α'` respectively, such that for all elements `a` of `α` and `b` of `β`, `g (f a b)` equals `f' (g₁ b) (g₂ a)`, the image of the function `g` applied to the image of the binary function `f` applied to sets `s` and `t` is equal to the image of `f'` applied to the image of `g₁` applied to `t` and the image of `g₂` applied to `s`. In mathematical terms, it's about how the image of a function composition is related under certain conditions to the composition of the images of functions.

For any sets `s` and `t`, functions `f: s × t -> γ`, `g: γ -> δ`, `f' : t -> s'`, `g₁: β -> β'`, and `g₂: α -> α'`, if for all `a in α` and `b in β`, `g (f a b) = f' (g₁ b) (g₂ a)`, then `g (∥f|_s×t⟩) = ∥f'_|_t⟩ (g₁) (g₂) (∥s⟩)`, where `∥_|_*⟩` denotes the image of a function applied to a set.


theorem Mathlib.Data.Finset.Prod._auxLemma.7 : ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the conjunction of propositions `a`, `b`, and `c` in that order is equal to the conjunction of propositions `b`, `a`, and `c` in that order. In other words, the theorem asserts the commutativity of conjunction for any two propositions in a three-part conjunction while leaving the third proposition in place. Mathematically, it can be written as $(a \land b \land c) = (b \land a \land c)$.

The theorem asserts the commutativity of conjunction for any two propositions in a three-part conjunction: $(a \land b \land c) = (b \land a \land c)$.


theorem directedOn_iff_directed :
    ∀ {α : Type u} {r : α → α → Prop} {s : Set α}, DirectedOn r s ↔ Directed r Subtype.val := by sorry

This theorem establishes a correspondence between the concept of a directed set and a directed-on relation. For any type `α` and a binary relation `r` on `α`, it states that a set `s` is directed under the relation `r` (meaning, for any two elements in the set, there exists a third element in the set that is 'above' both under the relation `r`) if and only if the function `Subtype.val` (which extracts the underlying element from a subtype) is directed (meaning, for any two indices, there exists a third index such that its corresponding value is 'above' both previously mentioned values under the relation `r`). Here, 'above' means 'greater than or equal to' in a general sense, specifically defined by the relation `r`.

For any type `α` and a binary relation `r` on `α`, a set `s` is directed under `r` if and only if the indices in the subtype of `s` under `r` are directed under `r`.


theorem SetTheory.PGame.birthday_zero : SetTheory.PGame.birthday 0 = 0 := by sorry

This theorem states that the "birthday" of the zero game in set theory is zero. The birthday of a pre-game is defined as the least strict upper bound of the birthdays of its left and right games. In the context of games, it can be viewed as the "step" in which a certain game is constructed. In the case of the zero game, since there are no preceding steps (or in other words, no left or right games), its birthday is thus defined to be zero.

The birthday of the zero game in set theory is defined as 0.


/-- `cyclotomic n R` is different from `0`.  -/
theorem Polynomial.cyclotomic_ne_zero :
    ∀ (n : ℕ) (R : Type u_1) [inst : Ring R] [inst_1 : Nontrivial R], Polynomial.cyclotomic n R ≠ 0 := by sorry

The theorem `Polynomial.cyclotomic_ne_zero` states that for any natural number `n`, and for any type `R` that forms a nontrivial ring, the `n`-th cyclotomic polynomial with coefficients in `R` is never equal to 0. In other words, given any nontrivial ring, the cyclotomic polynomial of any order in that ring is always non-zero.

For any natural number `n` and nontrivial ring `R`, the `n`-th cyclotomic polynomial over `R` is never the zero polynomial.


theorem CircleDeg1Lift.coe_pow : ∀ (f : CircleDeg1Lift) (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] := by sorry

This theorem states that for any function `f` of type `CircleDeg1Lift` and any natural number `n`, applying the function `f` `n` times (denoted as `f ^ n`) is the same as the `n`-th iteration of the function `f` (denoted as `(⇑f)^[n]`). In other words, multiplying `f` by itself `n` times (i.e., composing `f` with itself `n` times) yields the same result as applying `f` `n` times in sequence.

For any function `f` of type `CircleDeg1Lift` in Lean 4, `(f ^ n) = (⇑f)^[n]` or equivalently, `f ^ n = (composition f f ... f) (n times) = (iterated function application f) (n times)`.


UniformInducing.denseInducing

theorem UniformInducing.denseInducing :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformInducing f → DenseRange f → DenseInducing f :=
  by sorry

The theorem `UniformInducing.denseInducing` states that for any two types `α` and `β` equipped with Uniform Space structures, and for any function `f` from `α` to `β`, if `f` is a uniform inducing function and has dense range, then `f` is a dense inducing function.

In more everyday language, this theorem is saying that if you have a function that transforms one set into another in a way that preserves a certain mathematical structure (uniformity), and the image of this function densely covers the target set, then this function not only induces a uniform structure but also induces a dense structure.

If `f` is a uniform inducing function from a uniform space `(α, δα)` to another uniform space `(β, δβ)` with dense range, then `f` is a dense inducing function.


theorem vadd_vsub_vadd_cancel_right :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (v₁ v₂ : G) (p : P),
      v₁ +ᵥ p -ᵥ (v₂ +ᵥ p) = v₁ - v₂ :=
  by sorry

This theorem states that for all types `G` and `P`, where `G` is an add group and `P` is an add torsor over `G`, and for all elements `v₁`, `v₂` of `G` and `p` of `P`, the result of adding `v₁` to `p` (denoted by `v₁ +ᵥ p`), subtracting the result of adding `v₂` to `p` (denoted by `v₂ +ᵥ p`), is equal to the subtraction of `v₂` from `v₁` (denoted by `v₁ - v₂`). Essentially, this theorem encapsulates the right cancellation law for addition and subtraction in the context of add torsors.

For all add groups G and add torsors P over G, for all elements v₁, v₂ of G and p of P, the operation of adding an element v₁ to a torsor p and then subtracting an element v₂ gives the same result as subtracting v₂ from v₁ and adding the result to p. In symbols: v₁ +ᵥ p = (v₁ - v₂) +ᵥ p.


/-- The Galois connection between fixing submonoids and fixed points of a monoid action  -/
theorem fixingSubmonoid_fixedPoints_gc :
    ∀ (M : Type u_1) (α : Type u_2) [inst : Monoid M] [inst_1 : MulAction M α],
      GaloisConnection (⇑OrderDual.toDual ∘ fixingSubmonoid M)
        ((fun P => MulAction.fixedPoints (↥P) α) ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem establishes a Galois connection between the fixing submonoids and the fixed points of a monoid action. Given a monoid `M` and a type `α` where `M` acts on `α` by multiplication, the Galois connection is formed between the function that maps `M` to its fixing submonoid under the dual order and the function that maps a submonoid `P` of `M` to the set of fixed points of `P`'s action on `α`, under the original order. Essentially, it's saying that a submonoid's fixed points and the points that fix a submonoid have a unique relationship captured by the Galois connection.

The Galois connection establishes a bi-directional relationship between the fixing submonoids of a monoid action and the sets of fixed points under the dual and original orders, respectively.


theorem MeasureTheory.Measure.ae_eq_set_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
      {μ : (i : ι) → MeasureTheory.Measure (α i)} [inst_2 : ∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {I : Set ι}
      {s t : (i : ι) → Set (α i)},
      (∀ i ∈ I, s i =ᶠ[MeasureTheory.Measure.ae (μ i)] t i) →
        Set.pi I s =ᶠ[MeasureTheory.Measure.ae (MeasureTheory.Measure.pi μ)] Set.pi I t :=
  by sorry

This theorem states that for all index sets `ι`, every function `α : ι → Type u_3`, any finite instance of `ι`, measurable space of `α i` for every `i : ι`, measure `μ : (i : ι) → MeasureTheory.Measure (α i)` and sigma-finite measure `μ i` for every `i : ι`, if `I` is a set of `ι` and `s` and `t` are two functions such that for every `i` in `I`, `s i` is almost everywhere equal to `t i` with respect to the measure `μ i`, then the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a` whenever `a ∈ s` is almost everywhere equal to the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a` whenever `a ∈ t` with respect to the measure `MeasureTheory.Measure.pi μ`. This theorem is essentially stating that if two sets are almost everywhere equal with respect to their individual measures, then the sets of dependent functions are also almost everywhere equal with respect to the product measure.

Given index sets `ι`, functions `α : ι → Type u_3`, measurable spaces `(α i, μ i)` for every `i : ι`, sigma-finite measures `μ i`, a set `I ⊆ ι`, and functions `s, t : I → ι`, if for all `i` in `I`, `μ i`-almost everywhere `s i = t i`, then the sets of dependent functions `{f : Πa, π a | f a ∈ t a ∧ a ∈ s}` and `{f : Πa, π a | f a ∈ t a}` have equal `MeasureTheory.Measure.pi μ`-measure.


theorem NNReal.coe_tsum : ∀ {α : Type u_1} {f : α → NNReal}, ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a) := by sorry

This theorem states that for any type `α` and any function `f` from `α` to the set of nonnegative real numbers (`NNReal`), the sum of the images of `f` (denoted as `(∑' (a : α), f a)`) is the same as the sum of the images of `f` after they have been converted to real numbers (denoted as `∑' (a : α), ↑(f a)`). In other words, the conversion to real numbers (`↑` or `coe`) commutes with the operation of taking the sum over all elements of type `α`.

For any type `α` and function `f` from `α` to `NNReal`, the sum of `f` applied to all elements of `α` is equal to the sum of the real numbers obtained by applying `f` to each element and then converting to real numbers. In Lean syntax, `(∑' (a : α), f a) = ∑' (a : α), ↑(f a)`.


theorem Polynomial.eval₂_mul_noncomm :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p q : Polynomial R} [inst_1 : Semiring S] (f : R →+* S) (x : S),
      (∀ (k : ℕ), Commute (f (Polynomial.coeff q k)) x) →
        Polynomial.eval₂ f x (p * q) = Polynomial.eval₂ f x p * Polynomial.eval₂ f x q :=
  by sorry

The theorem `Polynomial.eval₂_mul_noncomm` states that for any semirings `R` and `S`, any polynomials `p` and `q` over `R`, any ring homomorphism `f` from `R` to `S`, and an element `x` in `S`, if for every natural number `k`, the function `f` applied to the `k`-th coefficient of `q` commutes with `x`, then the polynomial evaluation function `eval₂` satisfies the property that `eval₂` of `p * q` equals `eval₂` of `p` times `eval₂` of `q`. In simpler terms, under the condition of commutativity, the function `eval₂` distributes over polynomial multiplication.

Given semirings R and S, polynomials p and q over R, a ring homomorphism f from R to S, and an element x in S such that f(q\_(n)) = x * f(q\_(n)) for all natural numbers n, then eval₂(p * q) = eval₂(p) * eval₂(q).


theorem Polynomial.coeff_natDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.coeff p (Polynomial.natDegree p) = Polynomial.leadingCoeff p :=
  by sorry

The theorem `Polynomial.coeff_natDegree` states that for all polymonials `p` over a semiring `R`, the coefficient of the term with degree equal to the natural degree of `p` is the same as the leading coefficient of `p`. In other words, in any polynomial, the coefficient of the term with the highest power of `X` (the leading term) is the same whether we retrieve it using the `coeff` function with the natural degree of the polynomial as the argument, or directly using the `leadingCoeff` function.

The theorem `Polynomial.coeff_natDegree` asserts that the coefficient of the term of highest degree in a polynomial equals the leading coefficient, i.e., `coeff p (natDegree p) = leadingCoeff p`.


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

The theorem `CauchyFilter.denseRange_pureCauchy` states that for any type `α` equipped with a uniform space structure, the function `pureCauchy` from `α` to its completion `CauchyFilter α` has a dense range. In other words, the image (or range) of any element of `α` under the `pureCauchy` function is a dense subset of the Cauchy completion of `α`. This implies that any point in the completion can be approximated arbitrarily closely by images under `pureCauchy` of points in `α`.

The range of the `pureCauchy` function from a uniform space `α` to its Cauchy completion `CauchyFilter α` is dense.


theorem Mathlib.Topology.Semicontinuous._auxLemma.7 : ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x :=
  by sorry

This theorem, `Mathlib.Topology.Semicontinuous._auxLemma.7`, states that for any type `α` and any predicate `p` on `α`, the statement "there doesn't exist an element `x` in `α` such that `p(x)` holds" is equivalent to "for all elements `x` in `α`, `p(x)` doesn't hold". In mathematical notation, this can be written as ¬(∃x in α, p(x)) is equivalent to ∀x in α, ¬p(x).

The negation of the existence of an element in a type satisfying a predicate is equivalent to the universally quantified negation of the predicate for all elements in the type.


theorem subset_infClosure : ∀ {α : Type u_2} [inst : SemilatticeInf α] {s : Set α}, s ⊆ infClosure s := by sorry

The theorem `subset_infClosure` states that for any set `s` in a type `α`, where `α` forms a semilattice under the infimum operation (expressed as `SemilatticeInf α`), the set `s` is a subset of the set generated by the `infClosure` of `s`. In other words, all elements of `s` are included in the set that is closed under the infimum operation generated from `s`.

For any semilattice `α` and set `s` in `α`, `s` is a subset of the set generated by the infimum closure of `s`.


theorem measurable_inl :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β], Measurable Sum.inl := by
  sorry

The theorem `measurable_inl` states that for any two types `α` and `β` each equipped with a measurable space structure, the function `Sum.inl`, which maps an element of type `α` to an element of the sum type `α ⊕ β` by placing it in the left component of the sum, is a measurable function. In other words, the preimage of any measurable set under the `Sum.inl` function is also a measurable set.

The function `Sum.inl : α → α ⊕ β` is measurable for any measurable spaces (α, Σα) and (β, Σβ).


theorem Mathlib.Topology.Order.Basic._auxLemma.14 :
    ∀ {α : Type u_1} {p : αᵒᵈ → Prop}, (∃ a, p a) = ∃ a, p (OrderDual.toDual a) := by sorry

The `Mathlib.Topology.Order.Basic._auxLemma.14` theorem asserts that for any type `α` and any property `p` that can be applied to the dual of `α`, the existence of an element in the dual of `α` satisfying the property `p` is equivalent to the existence of an element in `α` that, when passed through the `OrderDual.toDual` identity function, satisfies the property `p`.

For any type `α` and property `p` on its dual, an element in `α` maps to an element in its dual satisfying `p` if and only if there exists an element in the dual satisfying `p`.


HasFDerivAt.prod

theorem HasFDerivAt.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {f₁' : E →L[𝕜] F} {x : E}
      {f₂ : E → G} {f₂' : E →L[𝕜] G},
      HasFDerivAt f₁ f₁' x →
        HasFDerivAt f₂ f₂' x → HasFDerivAt (fun x => (f₁ x, f₂ x)) (ContinuousLinearMap.prod f₁' f₂') x :=
  by sorry

The theorem `HasFDerivAt.prod` states that for any type `𝕜` that is a nontrivially normed field, types `E`, `F`, and `G` that are normed spaces over `𝕜`, and functions `f₁: E → F`, `f₂: E → G` with continuous linear maps `f₁'`, `f₂'` as their derivatives at a point `x` in `E`, if both `f₁` and `f₂` have derivatives at `x`, then the function mapping `x` to the pair `(f₁ x, f₂ x)` also has a derivative at `x`, which is the continuous linear map from `E` to the product space `F × G` that is the product of `f₁'` and `f₂'`. This theorem essentially asserts that the derivative of a pair of functions is the pair of their derivatives.

Given a nontrivially normed field `𝕜` and normed spaces `E`, `F`, and `G` over `𝕜`, if `f₁: E → F` and `f₂: E → G` are functions with continuous linear derivatives `f₁'` and `f₂'` at a point `x` in `E`, then the function mapping `x` to `(f₁ x, f₂ x)` has a derivative at `x`, which is the product of `f₁'` and `f₂'`.


theorem Set.preimage_const_of_not_mem :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : Set β}, b ∉ s → (fun x => b) ⁻¹' s = ∅ := by sorry

The theorem `Set.preimage_const_of_not_mem` states that for any types `α` and `β`, a value `b` of type `β`, and a set `s` of values of type `β`, if `b` does not belong to the set `s` (`b ∉ s`), then the preimage of the set `s` under the constant function that always returns `b` is the empty set. In other words, there are no elements of type `α` that when mapped by this constant function would land in `s`.

For any types `α` and `β`, if `b` is not an element of set `s` in `β`, then the preimage of `s` under the constant function `λ x => b` is the empty set in `α`.


/-- The direct comparison test for series:  if the norm of `f` is bounded by a real function `g`
which is summable, then `f` is summable.  -/
theorem Summable.of_norm_bounded :
    ∀ {ι : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : CompleteSpace E] {f : ι → E}
      (g : ι → ℝ), Summable g → (∀ (i : ι), ‖f i‖ ≤ g i) → Summable f :=
  by sorry

This theorem, often referred to as the "direct comparison test for series", asserts that if the norm of a function `f` is bounded by a real-valued function `g` that is summable, then `f` is also summable. Here, `f` is a function from an arbitrary type `ι` to a seminormed add commutative group `E` (which also forms a complete space), and `g` is a function from `ι` to real numbers. The function `f` is said to be summable if there exists some sum, even if it be an infinite one, for the series formed by `f`. This theorem thus provides a convenient criterion to ascertain the summability of a series in terms of another one known to be summable.

If a function `f` from an index type `ι` to a seminormed add commutative group `E` (a complete space) is pointwise dominated by a summable real-valued function `g`, then `f` is also summable.


theorem Dense.exists_mem_open :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X],
      Dense s → ∀ {U : Set X}, IsOpen U → Set.Nonempty U → ∃ x ∈ s, x ∈ U :=
  by sorry

The theorem `Dense.exists_mem_open` states that for any topological space `X` and any set `s` in this space, if `s` is dense in `X`, then for any set `U` in `X` that is open and nonempty, there exists an element `x` that belongs to both `s` and `U`. In other words, in any nonempty open set in the topological space, we can always find a point from the dense set. This is a fundamental property of dense sets in topology.

If a dense subset of a topological space is non-empty, then for any open set in the space, there exists an element in the dense subset that belongs to the open set.


theorem csSup_image2_eq_csSup_csSup :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompleteLattice α]
      [inst_1 : ConditionallyCompleteLattice β] [inst_2 : ConditionallyCompleteLattice γ] {s : Set α} {t : Set β}
      {l : α → β → γ} {u₁ : β → γ → α} {u₂ : α → γ → β},
      (∀ (b : β), GaloisConnection (Function.swap l b) (u₁ b)) →
        (∀ (a : α), GaloisConnection (l a) (u₂ a)) →
          Set.Nonempty s → BddAbove s → Set.Nonempty t → BddAbove t → sSup (Set.image2 l s t) = l (sSup s) (sSup t) :=
  by sorry

This theorem states that for any types `α`, `β`, `γ` equipped with the structure of a conditionally complete lattice, and for any sets `s` of type `α` and `t` of type `β`, along with the binary function `l : α → β → γ` and the functions `u₁ : β → γ → α` and `u₂ : α → γ → β` satisfying certain Galois connection properties, if `s` and `t` are nonempty and bounded above, then the supremum of the image (under `l`) of the cartesian product of `s` and `t` is equal to the result of applying `l` to the supremum of `s` and the supremum of `t`. In other words, the supremum operation can be interchanged with the binary function `l` under these conditions.

Given types `α`, `β`, `γ` with the structure of conditionally complete lattices, and sets `s` of type `α` and `t` of type `β` that are nonempty and bounded above, if functions `l : α → β → γ`, `u₁ : β → γ → α`, and `u₂ : α → γ → β` satisfy Galois connection properties, then the supremum of `l(s × t)` equals `l(sup s sup t)`.


theorem Nat.factorial_dvd_factorial : ∀ {m n : ℕ}, m ≤ n → Nat.factorial m ∣ Nat.factorial n := by sorry

The theorem `Nat.factorial_dvd_factorial` states that for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the factorial of `m` (denoted by `Nat.factorial m`) divides the factorial of `n` (denoted by `Nat.factorial n`). In other words, `Nat.factorial n` is a multiple of `Nat.factorial m` whenever `m ≤ n`. This is a well-known property of factorials in mathematics.

For all natural numbers m and n with m ≤ n, Nat.factorial m | Nat.factorial n. (Here, | denotes divisibility.)


theorem Cardinal.toNat_congr :
    ∀ {α : Type u} {β : Type v}, α ≃ β → Cardinal.toNat (Cardinal.mk α) = Cardinal.toNat (Cardinal.mk β) := by sorry

This theorem states that for any two types `α` and `β`, if there exists a bijective mapping (or an equivalence) between `α` and `β`, then the cardinality (or size) of `α` and `β` when mapped to natural numbers using the `Cardinal.toNat` function are equal. Here, the cardinality is captured using `Cardinal.mk`, which gives the cardinal number of a type. If `α` and `β` are infinite, the `Cardinal.toNat` function assigns them a cardinality of 0. If `α` and `β` are finite, then their cardinalities are the corresponding natural numbers. This theorem encapsulates the principle that equivalent (bijectively mappable) types have the same cardinality.

For any types `α` and `β` with a bijective mapping between them, their cardinalities (as natural numbers) are equal.


CochainComplex.HomComplex.Cochain.ext

theorem CochainComplex.HomComplex.Cochain.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cochain F G n),
      (∀ (p q : ℤ) (hpq : p + n = q), z₁.v p q hpq = z₂.v p q hpq) → z₁ = z₂ :=
  by sorry

This theorem states that for any category 'C' that is preadditive, given two cochain complexes 'F' and 'G' over 'C' and an integer 'n', if we have two cochains 'z₁' and 'z₂' from 'F' to 'G' of degree 'n', then 'z₁' equals 'z₂' if and only if for all pairs of integers 'p' and 'q' for which 'p + n = q', the morphism from 'F.X p' to 'G.X q' in 'z₁' is equal to the corresponding morphism in 'z₂'. This is essentially a uniqueness statement about cochains in a cochain complex in the setting of category theory.

Given two cochain complexes over a preadditive category and an integer, two cochain morphisms of degree n are equal if and only if their corresponding morphisms between degree p and q (p = n+q) are equal.


theorem Finset.nonempty_cons : ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s), (Finset.cons a s h).Nonempty := by
  sorry

The theorem `Finset.nonempty_cons` states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α` that does not belong to `s`, the finite set obtained by adjoining `a` to `s` using the `Finset.cons` function is nonempty. This is naturally expected because we are adding an additional element `a` to the finite set `s`, ensuring that the resulting set has at least one element in it.

For any type `α` and finite set `s` of type `α` without element `a` of type `α`, the set `{a} ∪ s` is nonempty.


theorem true_implies : ∀ (p : Prop), (True → p) = p := by sorry

This theorem, named `true_implies`, states that for any proposition `p`, the implication of `True` leading to `p` is equivalent to `p` itself. In other words, if `p` is a logical proposition, then `True → p` (which reads "True implies `p`") is the same as `p`. This is a natural result in logic, since if we know that `True` implies `p`, then `p` must be `True`, and vice versa.

For any proposition `p` in Lean, `True → p` is logically equivalent to `p`.


theorem Traversable.toList_spec :
    ∀ {α : Type u} {t : Type u → Type u} [inst : Traversable t] [inst_1 : LawfulTraversable t] (xs : t α),
      Traversable.toList xs = FreeMonoid.toList (Traversable.foldMap FreeMonoid.of xs) :=
  by sorry

The theorem `Traversable.toList_spec` states that for any type `α`, any traversable type constructor `t`, any instance `inst` of `t` being traversable, any lawful traversable `inst_1` of `t`, and any `xs` of type `t α`, the operation of converting `xs` to a list using `Traversable.toList` is equivalent to first applying `FreeMonoid.of` to each element of `xs` using `Traversable.foldMap`, converting the resulting `FreeMonoid α` to a list, and then applying `FreeMonoid.toList`. In short, it establishes the equivalence between two different ways of converting a traversable structure into a list.

For any traversable type constructor `t`, any instance `inst` of `t` being traversable, any lawful traversable `inst_1` of `t`, and any `xs` of type `t α`, `Traversable.toList xs` is equivalent to `FreeMonoid.toList (Traversable.foldMap (FreeMonoid.of) xs)`.


theorem Fintype.card_le_of_embedding :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β],
      (α ↪ β) → Fintype.card α ≤ Fintype.card β :=
  by sorry

The theorem `Fintype.card_le_of_embedding` states that for any two types `α` and `β`, given that both `α` and `β` are fintypes (i.e., they have a finite number of elements), if there exists an injective function (also known as an embedding) from `α` to `β`, then the cardinality (or the number of elements) of `α` is less than or equal to the cardinality of `β`. In simpler terms, if we can map each element of `α` to a unique element in `β` without any overlaps, then `α` cannot have more elements than `β`.

If `α` and `β` are fintypes and there exists an injective function from `α` to `β`, then `#α ≤ #β`. (Here, `#α` and `#β` represent the cardinalities of `α` and `β`, respectively.)


theorem Inseparable.mem_open_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {s : Set X}, Inseparable x y → IsOpen s → (x ∈ s ↔ y ∈ s) :=
  by sorry

This theorem states that for any given topological space 'X', if two points 'x' and 'y' within that space are inseparable (i.e., they have the same neighborhood), then for any open set 's', 'x' is a member of 's' if and only if 'y' is a member of 's'. This condition holds true for any open set 's' in the topology, provided 'x' and 'y' are inseparable and 's' is an open set. In other words, inseparable points 'x' and 'y' in a topological space share the same membership properties for open sets.

For any topological space 'X' and inseparable points 'x' and 'y' in 'X', they belong to the same open sets.


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

This theorem asserts that for every non-negative integer `n`, possibly extended to infinity, the complex cosine function `Complex.cos` is `n` times continuously differentiable. In mathematical terms, it means the complex cosine function, defined as $$Complex.cos(z) = \frac{Complex.exp (z * Complex.I) + Complex.exp (-z * Complex.I)}{2},$$ has continuous derivatives of all orders up to `n`, where `Complex.I` is the imaginary unit in complex numbers, and `Complex.exp` is the complex exponential function.

The complex cosine function, defined as (Complex.exp (z * Complex.I) + Complex.exp (-z * Complex.I) / 2), is infinitely differentiable.


/-- A set is contained in its affine span.  -/
theorem subset_affineSpan :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (s : Set P), s ⊆ ↑(affineSpan k s) :=
  by sorry

This theorem asserts that for any set `s` of points of type `P`, in a context where `k` is a ring, `V` is an additive commutative group, `P` is a module over `k` with `V` as the underlying additive group, and `P` forms an additive torsor over `V`, the set `s` is a subset of its affine span. More intuitively, this states that every point in a set is contained within the smallest affine subspace that includes the entire set, which reflects the geometric notion that the span of a set of points includes those points themselves.

For any additive torsor `s` of a `k`-module `P` with underlying additive group `V`, `s` is contained in its affine span.


theorem CategoryTheory.Abelian.coimage.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C] {P Q : C}
      (f : P ⟶ Q), CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι f) :=
  by sorry

This theorem states that, in the setting of an abelian category (which contains zero morphisms, kernels, and cokernels), given any two objects `P` and `Q` in this category and a morphism `f` from `P` to `Q`, the kernel of `f` has a cokernel. In other words, you can form the cokernel of the morphism from the kernel of `f` to `P`.

In the context of category theory, a kernel is a limit of the parallel pair `f, 0`, and a cokernel is a colimit of the parallel pair `f, 0`. This theorem ensures the dual property that if `f` has a kernel, then there exists a cokernel of the morphism from this kernel to the source of `f`.

In an abelian category, if a morphism has a kernel, then it has a cokernel and the cokernel of the morphism can be formed from its kernel and the source object.


theorem div_mul_cancel_of_imp :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (b = 0 → a = 0) → a / b * b = a := by sorry

This theorem states that for any type `G₀` that forms a group with zero, and for any elements `a` and `b` of this type, if it is true that `a` equals zero whenever `b` equals zero, then the product of `a` divided by `b` and `b` is always equal to `a`. In mathematical terms, it establishes that if `a = 0` whenever `b = 0`, then `(a / b) * b = a` is always true in the context of a group with zero.

If `a = 0` implies `b = 0` in a group with identity `0`, then `(a / b) * b = a`.


/-- If a complex function `e` is differentiable at a real point, then the function `ℝ → ℝ` given by
the real part of `e` is also differentiable at this point, with a derivative equal to the real part
of the complex derivative.  -/
theorem HasDerivAt.real_of_complex :
    ∀ {e : ℂ → ℂ} {e' : ℂ} {z : ℝ}, HasDerivAt e e' ↑z → HasDerivAt (fun x => (e ↑x).re) e'.re z := by sorry

This theorem states that if a complex-valued function `e` has a derivative at a real number `z`, then the function that takes a real number to the real part of `e` at that number is also differentiable at `z`. Furthermore, the derivative of this real function at `z` is the real part of the derivative of `e` at `z`.

If `e` is a complex-valued function with a complex derivative at a real number `z`, then the real-valued function `Re(e)` is differentiable at `z` and its derivative is equal to the real part of `e'(z)`.


theorem AddSubmonoid.LocalizationMap.lift_eq :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P}
      (hg : ∀ (y : ↥S), IsAddUnit (g ↑y)) (x : M),
      (AddSubmonoid.LocalizationMap.lift f hg) ((AddSubmonoid.LocalizationMap.toMap f) x) = g x :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.lift_eq` states that for any given additive commutative monoids `M`, `N`, and `P`, with `S` being an add submonoid of `M`, and given a localization map `f` from `S` to `N`, and another additive monoid homomorphism `g` from `M` to `P` such that every element of `S` under `g` is an additive unit, then for every element `x` of `M`, applying the localization map `f` to `x`, then lifting it to `P` using the lift of `f` is equivalent to directly applying `g` to `x`. In other words, the lift of `f` is an extension of `g` on the image of `M` under the localization map `f`. This theorem is essentially saying that the lift of a localization map behaves well with respect to the original map.

Given additive commutative monoids M, N, and P, a localization map f from add submonoid S of M to N, and an additive monoid homomorphism g from M to P such that every element of S under g is an additive unit, then for all x in M, f(x) in N and g(x) in P are related by the equation g(x) = lift(f)(f(x)).


theorem Ideal.span_singleton_le_iff_mem :
    ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {x : α}, Ideal.span {x} ≤ I ↔ x ∈ I := by sorry

This theorem states that for any type `α` which has a structure of semiring, any ideal `I` of this semiring, and any element `x` of `α`, the ideal generated by the singleton set `{x}` is a subset of the ideal `I` if and only if `x` is an element of the ideal `I`. In other words, an element `x` is in a certain ideal if and only if the ideal generated by `x` is contained within that ideal.

For any semiring `α`, ideal `I` of `α`, and element `x` in `α`, the singleton set `{x}` generates ideal `I` if and only if `x` is in `I`.


theorem abs_dist_sub_le : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y z : α), |dist x z - dist y z| ≤ dist x y :=
  by sorry

This theorem states that for any type `α` that is a pseudometric space, and for any three points `x`, `y`, and `z` in this space, the absolute difference between the distance from `x` to `z` and the distance from `y` to `z` is always less than or equal to the distance from `x` to `y`. In mathematical terms, for all `x`, `y` and `z`, we have |dist(x, z) - dist(y, z)| ≤ dist(x, y).

For any pseudometric space `(α, dist)`, the triangle inequality holds: `|dist(x, z) - dist(y, z)| ≤ dist(x, y)` for all `x, y, z` in `α`.


theorem Finset.inter_self : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), s ∩ s = s := by sorry

The theorem `Finset.inter_self` states that for any type `α` that has a decidable equality and for any finite set `s` of type `α`, the intersection of `s` with itself is equal to `s` itself. In other words, if you take a finite set and intersect it with itself, you get the original set back. This makes sense intuitively, as all elements in `s` are certainly in `s`, so the intersection of `s` and `s` contains exactly the same elements as `s`.

For any finite set `s` of type `α` with decidable equality, `s ∩ s = s`.


theorem Mathlib.SetTheory.Cardinal.ENat._auxLemma.17 : ∀ {m n : ℕ∞}, (↑m = ↑n) = (m = n) := by sorry

This theorem states that for all natural numbers `m` and `n`, possibly extended to infinity (`ℕ∞`), the equality of their corresponding cardinal numbers (`↑m = ↑n`) is equivalent to the equality of the numbers themselves (`m = n`). In other words, in the realm of cardinalities in set theory, two natural numbers (including infinity) have the same cardinality if and only if they are the same number.

For all natural numbers `m` and `n`, their cardinalities are equal, `↑m = ↑n`, if and only if `m` and `n` are equal, `m = n`.


theorem CauSeq.neg_limZero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {f : CauSeq β abv}, CauSeq.LimZero f → CauSeq.LimZero (-f) :=
  by sorry

The theorem `CauSeq.neg_limZero` states that for any Cauchy sequence `f` of values from a ring `β` with respect to an absolute value function `abv` in a linearly ordered field `α`, if `f` approaches zero, then the negation of `f` also approaches zero. In other words, if `f` is a sequence such that the absolute value of its elements gets arbitrarily close to zero as we proceed further in the sequence, the same is true for the sequence formed by taking the negation of each element in `f`.

If `f` is a Cauchy sequence in the ring `β` with respect to the absolute value `abv` in the linearly ordered field `α`, and `lim (abv (f.n)) = 0`, then `lim (abv (neg (f.n))) = 0`.


theorem lipschitzWith_iff_dist_le_mul :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f ↔ ∀ (x y : α), dist (f x) (f y) ≤ ↑K * dist x y :=
  by sorry

The theorem `lipschitzWith_iff_dist_le_mul` states that for any two types `α` and `β`, given that they are instances of a PseudoMetricSpace, and given a nonnegative real number `K` and a function `f` from `α` to `β`, then `f` is Lipschitz continuous with constant `K` if and only if, for all `x, y` in `α`, the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`. In mathematical terms, this can be represented as: \(f\) is Lipschitz continuous with constant \(K \geq 0\) if and only if \(d(f(x), f(y)) \leq K * d(x, y)\) for all \(x, y\).

A function between two pseudo-metric spaces is Lipschitz continuous with constant K if and only if the distance between its values on any two points is less than or equal to K times the distance between the points in the original space.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.4 :
    ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, (0 ⊆ s) = (0 ∈ s) := by sorry

This theorem states that for any type `α` that has a zero element (as indicated by the `inst : Zero α`), and for any set `s` of elements of type `α` (`s : Set α`), the statement "zero is a subset of `s`" (denoted `0 ⊆ s`) is equivalent to the statement "zero is an element of `s`" (denoted `0 ∈ s`). Thus, in this specific context, being a subset and being an element are equivalent concepts for zero.

For any type `α` with a zero element `0`, the subset inclusion `0 ⊆ s` and element membership `0 ∈ s` are equivalent for any set `s` of elements of type `α`.


theorem Directed.mono_comp :
    ∀ {α : Type u} {β : Type v} (r : α → α → Prop) {ι : Sort u_1} {rb : β → β → Prop} {g : α → β} {f : ι → α},
      (∀ ⦃x y : α⦄, r x y → rb (g x) (g y)) → Directed r f → Directed rb (g ∘ f) :=
  by sorry

The theorem `Directed.mono_comp` states that for any types `α`, `β` and `ι`, a relation `r` on `α`, a relation `rb` on `β`, a function `g` from `α` to `β` and a function `f` from `ι` to `α`, if `g` is monotone with respect to `r` and `rb` (i.e., for any `x` and `y` in `α`, `r x y` implies `rb (g x) (g y)`), and if the function `f` is directed with respect to the relation `r`, then the composed function `g ∘ f` is directed with respect to the relation `rb`. In other words, the directedness property is preserved under the composition of a monotone function.

If `g` is a monotone function with respect to `r` and `rb`, and `f` is a function that respects the direction of `r`, then `g ∘ f` is a directed function with respect to `rb`.


theorem Polynomial.natTrailingDegree_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.natTrailingDegree 0 = 0 := by
  sorry

The theorem `Polynomial.natTrailingDegree_zero` states that for any type `R` equipped with a structure of a semiring, the natural trailing degree of the zero polynomial is zero. In the context of polynomial mathematics, the trailing degree is the smallest degree of a polynomial's non-zero terms. Hence, this theorem is essentially saying that the smallest degree of non-zero terms of a zero polynomial (which has no non-zero terms) is considered to be zero.

The trailing degree of the zero polynomial in a semiring is zero.


theorem Int.ofNat_dvd_left : ∀ {n : ℕ} {z : ℤ}, ↑n ∣ z ↔ n ∣ Int.natAbs z := by sorry

This theorem, `Int.ofNat_dvd_left`, states that for any natural number `n` and any integer `z`, the integer representation of `n` (denoted by `↑n`) divides `z` if and only if `n` divides the absolute value (the natural number equivalent) of `z`. In other words, the divisibility relationship between a natural number and an integer is equivalent to the divisibility relationship between the same natural number and the absolute value of the integer.

For any natural number n and integer z, n divides z if and only if n divides the absolute value of z.


theorem CategoryTheory.Limits.biprod.inr_desc_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) {Z : C} (h : W ⟶ Z),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.desc f g) h) =
        CategoryTheory.CategoryStruct.comp g h :=
  by sorry

This theorem, `CategoryTheory.Limits.biprod.inr_desc_assoc`, states that for any category `C` with zero morphisms and binary biproducts, given three objects `X`, `Y`, `W` in `C` and a fourth object `Z`, and morphisms `f: X ⟶ W`, `g: Y ⟶ W`, `h: W ⟶ Z`, the composition of the inclusion into the second summand of the binary biproduct `Y ⟶ X ⊞ Y` (denoted as `CategoryTheory.Limits.biprod.inr`), with the composition of the morphism `CategoryTheory.Limits.biprod.desc f g` and `h`, is equal to the composition of the morphism `g` and `h`. In other words, this theorem is about the associativity property in the context of categorical biproducts.

For any category with zero morphisms and binary biproducts, the inclusion into the second summand of a binary biproduct and the composition of two morphisms is equal to the composition of those morphisms in that order.


theorem iSup_inf_eq :
    ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (f : ι → α) (a : α), (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a := by sorry

This theorem states that for any type `α` equipped with an order frame structure, any function `f` from some indexing set `ι` to `α`, and any element `a` of `α`, the infimum (greatest lower bound) of `a` and the supremum (least upper bound) over all `i` of `f(i)` is equal to the supremum over all `i` of the infimum of `a` and `f(i)`. It essentially says that the infimum operation commutes with the supremum operation under certain conditions.

For any type `α` with an order frame structure, given a function `f` from an indexing set `ι` to `α` and an element `a` of `α`, the infimum of `a` with respect to the order on `α` and the supremum of the infimum of `a` and `f(i)` over all `i` in `ι` are equal.


theorem rank_le_of_submodule :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (s t : Submodule R M),
      s ≤ t → Module.rank R ↥s ≤ Module.rank R ↥t :=
  by sorry

This theorem states that for any two submodules `s` and `t` of a module `M` over a ring `R` (where `M` is also an additive commutative group), if `s` is a subset of (or equal to) `t`, then the rank of `s` is less than or equal to the rank of `t`. In other words, the dimension of a submodule cannot exceed the dimension of the module it is contained in.

If `s` is a submodule of module `M` over ring `R` with `s` being a subset of or equal to submodule `t`, then the rank of `s` is less than or equal to the rank of `t`.


theorem mul_eq_zero_of_right : ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] (a : M₀) {b : M₀}, b = 0 → a * b = 0 := by
  sorry

This theorem, `mul_eq_zero_of_right`, states that for any type `M₀` that has a multiplication and zero operation (`MulZeroClass`), given any element `a` of `M₀` and any other element `b` of `M₀`, if `b` is equal to zero, then the product of `a` and `b` is also zero. Essentially, it captures the common mathematical property that anything multiplied by zero equals zero, specified in the context of a right multiplication.

For any type `M₀` with multiplication and zero (`MulZeroClass`) and any elements `a` and `b` in `M₀`, if `b = 0`, then `a * b = 0`.


theorem ContinuousMap.instAddCommGroupContinuousMap.proof_1 :
    ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : AddCommGroup β] [inst_2 : TopologicalAddGroup β],
      ContinuousAdd β :=
  by sorry

This theorem states that for any type `β`, given that `β` is a topological space, an additive commutative group, and a topological additive group, the operation of addition on `β` is continuous. In other words, it says that the sum of two elements in such a group can be calculated in a way that respects the topology's closeness relations.

Given a topological space, additive commutative group, and topological additive group `β`, the addition operation on `β` is a continuous function.


theorem Real.Angle.coe_zero : ↑0 = 0 := by sorry

This theorem, named `Real.Angle.coe_zero`, states that the real number coercion of zero is zero. Essentially, when zero is considered as a real number, it remains zero.

The real number coercion of 0 is equal to 0. (Or, the conversion of 0 from the type of integers to the type of real numbers results in the same number, 0.)


theorem Complex.add_im : ∀ (z w : ℂ), (z + w).im = z.im + w.im := by sorry

This theorem states that for any two complex numbers `z` and `w`, the imaginary part of the sum of `z` and `w` is equal to the sum of the imaginary parts of `z` and `w`. In other words, if `ℂ` denotes the set of complex numbers, then for every `z, w ∈ ℂ`, the imaginary part of `(z + w)` is the same as the sum of the imaginary parts of `z` and `w`. This is the algebraic property of complex numbers related to the addition operation on the imaginary parts.

The theorem asserts that for all complex numbers `z` and `w`, the imaginary part of their sum equals the sum of their imaginary parts. (Imag(z + w) = Imag(z) + Imag(w)).


theorem Nat.Linear.Expr.denote_toPoly :
    ∀ (ctx : Nat.Linear.Context) (e : Nat.Linear.Expr),
      Nat.Linear.Poly.denote ctx (Nat.Linear.Expr.toPoly e) = Nat.Linear.Expr.denote ctx e :=
  by sorry

The theorem `Nat.Linear.Expr.denote_toPoly` states that for any given context of natural numbers (`ctx`) and any linear expression (`e`), when we convert this linear expression to a polynomial (`Nat.Linear.Expr.toPoly e`) and then evaluate it (`Nat.Linear.Poly.denote ctx`), the result is equivalent to directly evaluating the original linear expression (`Nat.Linear.Expr.denote ctx e`). In other words, the process of converting a linear expression to a polynomial and evaluating it does not change the outcome as compared to evaluating the original linear expression.

For any natural number context `ctx` and linear expression `e`, the conversion of `e` to a polynomial and subsequent evaluation equals the direct evaluation of `e`: `Nat.Linear.Expr.denote ctx (Nat.Linear.Expr.toPoly e) = Nat.Linear.Expr.denote ctx e`.


theorem ULift.up_injective : ∀ {α : Type u}, Function.Injective ULift.up := by sorry

The theorem `ULift.up_injective` states that for any type `α`, the function `ULift.up` is injective. In other words, for any two distinct elements `x` and `y` of type `α`, their lifted versions `ULift.up x` and `ULift.up y` are also distinct. This ensures that no information is lost when elements of a type are lifted to the `ULift` type using the `ULift.up` function.

For all types α and distinct elements x, y of α, ULift.up x and ULift.up y are distinct.


theorem Multiset.card_add :
    ∀ {α : Type u_1} (s t : Multiset α), Multiset.card (s + t) = Multiset.card s + Multiset.card t := by sorry

This theorem states that for any type `α` and two multisets `s` and `t` of that type, the cardinality of the multiset obtained by adding `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. In other words, the number of elements in the combined multiset `s + t` is equal to the total number of elements in `s` and `t` combined. This mirrors the principle in basic arithmetic that the total count of elements in two combined sets is the sum of the counts of elements in each individual set.

The cardinality of the sum of two multisets is equal to the sum of their cardinalities.


theorem Fin.ne_of_lt : ∀ {n : ℕ} {a b : Fin n}, a < b → a ≠ b := by sorry

This theorem states that for any natural number `n`, and any two elements `a` and `b` from the finite set `Fin n`, if `a` is less than `b`, then `a` and `b` must not be equal. In other words, no number in a finite set of natural numbers can be less than itself, reinforcing the basic property of an ordered set.

For all natural numbers n and elements a and b in Fin n, if a < b then a ≠ b.