theorem mem_closure_iff :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X],
      x ∈ closure s ↔ ∀ (o : Set X), IsOpen o → x ∈ o → Set.Nonempty (o ∩ s) :=
  by sorry

The theorem `mem_closure_iff` states that for any type `X`, any element `x` of `X`, and any set `s` of `X` in a given topological space, `x` is an element of the closure of `s` if and only if for every open set `o` containing `x`, the intersection of `o` and `s` is nonempty. This essentially means that `x` is in the closure of `s` whenever it is contained in an open set that intersects `s`.

For any topological space, an element is in the closure of a set if and only if there exists an open set containing the element that intersects the set non-empty.


theorem Set.mem_center_iff : ∀ (M : Type u_1) [inst : Mul M] {z : M}, z ∈ Set.center M ↔ IsMulCentral z := by sorry

This theorem states that for any type `M` with a multiplication operation (represented by `[inst : Mul M]`), an element `z` of type `M` belongs to the center of `M` (i.e., `z` is in `Set.center M`) if and only if `z` is a "multiplication central" element (represented by `IsMulCentral z`).

In mathematical terms, this might be understood as telling us that an element is in the center of a multiplicative set (e.g., a group or ring in abstract algebra) if and only if it commutes with all other elements in the set under multiplication. The "if and only if" (represented by `↔` in Lean 4) denotes that both conditions imply each other.

An element `z` of a type `M` with multiplication belongs to the center if and only if it is multiplication central, i.e., commutes with all elements under multiplication.


theorem Set.exists_of_ssubset : ∀ {α : Type u} {s t : Set α}, s ⊂ t → ∃ x ∈ t, x ∉ s := by sorry

This theorem states that for any type `α`, and any two sets `s` and `t` of type `α`, if `s` is a strict subset of `t` (denoted `s ⊂ t`), then there exists an element `x` that belongs to `t` but does not belong to `s`. In mathematical terms, it asserts that if a set `s` is strictly contained within another set `t`, then there must be at least one element in `t` which is not in `s`.

Given any types `α` and sets `s` and `t` of type `α` with `s ⊂ t`, there exists an element `x ∈ t` such that `x ∉ s`.


theorem CategoryTheory.ShortComplex.exact_of_f_is_kernel :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (S : CategoryTheory.ShortComplex C),
      CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯) →
        ∀ [inst_2 : CategoryTheory.ShortComplex.HasHomology S], CategoryTheory.ShortComplex.Exact S :=
  by sorry

The theorem `CategoryTheory.ShortComplex.exact_of_f_is_kernel` states that for any category `C` with a preadditive structure, and a short complex `S` in `C`, if `S.f` is a kernel (i.e., `CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯)` holds), and `S` possesses a homology (`CategoryTheory.ShortComplex.HasHomology S`), then `S` is exact (`CategoryTheory.ShortComplex.Exact S`). In other words, in the context of category theory, this theorem guarantees exactness of a short complex if a certain morphism in the complex is a kernel and the complex has a homology.

In a preadditive category `C`, a short complex `S` is exact if its morphism `S.f` is a kernel and `S` has homology.


theorem CategoryTheory.Presieve.IsSeparatedFor.ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R : CategoryTheory.Presieve X},
      CategoryTheory.Presieve.IsSeparatedFor P R →
        ∀ {t₁ t₂ : P.obj (Opposite.op X)}, (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, R f → P.map f.op t₁ = P.map f.op t₂) → t₁ = t₂ :=
  by sorry

The theorem `CategoryTheory.Presieve.IsSeparatedFor.ext` states that for any category `C`, presheaf `P` and object `X` in `C`, and any presieve `R` on `X`, if the presheaf `P` is separated for the presieve `R`, then for any two objects `t₁` and `t₂` in the category opposite to `C` formed by `P`, if for all objects `Y` in `C` and morphisms `f` from `Y` to `X` that are in the presieve `R`, the mapping of `f` under the action of `P` on `t₁` is equal to its action on `t₂`, then `t₁` is equal to `t₂`. In mathematical terms, this theorem is stating a condition under which two objects are equal in a category if they are related through a functor under certain conditions.

If a presheaf on a category is separated for a presieve, then two objects mapping identically under that presheaf for all morphisms in the presieve are equal.


theorem half_add_self : ∀ {R : Type u_1} [inst : DivisionRing R] [inst_1 : CharZero R] (a : R), (a + a) / 2 = a := by
  sorry

This theorem, `half_add_self`, states that for any type `R` that is a division ring with characteristic zero, the half of the sum of any element `a` with itself equals `a`. In other words, it asserts that for any element `a` in a division ring `R` with characteristic zero, the equation $(a + a) / 2 = a$ holds.

For any element `a` in a division ring `R` with characteristic zero, (`a + a`) / 2 = `a`.


theorem Decidable.not_not : ∀ {p : Prop} [inst : Decidable p], ¬¬p ↔ p := by sorry

This theorem, `Decidable.not_not`, states that for any proposition `p` that can be decided (i.e., either `p` is true or `p` is false), the double negation of `p` is logically equivalent to `p` itself. In other words, if we know that it is not the case that `p` is not true (¬¬p), then we can conclude that `p` must be true, and vice versa. This theorem is a formal statement in Lean of a fundamental principle of classical logic, namely the law of double negation.

The double negation of a decidable proposition is logically equivalent to the proposition itself.


theorem Mathlib.Data.Set.Basic._auxLemma.65 : ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.65` states that for any two propositions `a` and `b`, the negation of the conjunction of `a` and `b` is logically equivalent to the implication from `a` to the negation of `b`. In other words, saying "it's not true that both `a` and `b` are true" is the same as saying "if `a` is true, then `b` must not be true".

The negation of `a` conjunction `b` is logically equivalent to `a` implying `~b`.


theorem Mathlib.Data.Set.Basic._auxLemma.76 : ∀ {α : Type u} {s : Set α}, Disjoint s Set.univ = (s = ∅) := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, `s` is disjoint with the universal set if and only if `s` is the empty set. To elaborate, two elements of a lattice are called disjoint if their infimum is the bottom element. Here, it refers to the condition where a set `s` has no intersection with the universal set (contains all elements of `α`). This situation can only occur when `s` is an empty set. Therefore, the theorem defines a characteristic property of an empty set in the context of a universal set.

A set is disjoint with the universal set if and only if it is the empty set.


theorem Mathlib.Data.Set.Basic._auxLemma.77 : ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t ⊆ ∅) := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.77` states that for any type `α` and for all sets `s` and `t` of this type, `s` and `t` are disjoint if and only if the intersection of `s` and `t` is a subset of the empty set. In other words, two sets are defined as disjoint when their intersection contains no elements.

Two sets of type `α` are disjoint if and only if their intersection is a subset of the empty set.


theorem Submodule.disjoint_def :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {p p' : Submodule R M}, Disjoint p p' ↔ ∀ x ∈ p, x ∈ p' → x = 0 :=
  by sorry

The theorem `Submodule.disjoint_def` defines what it means for two submodules `p` and `p'` of a module `M` over a semiring `R` to be disjoint. Specifically, it states that two submodules are disjoint if and only if for all elements `x` from the given module, if `x` is in both `p` and `p'`, then `x` must be the zero vector. This corresponds to the general concept of disjointness in lattice theory, where two elements are disjoint if their infimum is the bottom element. In the context of submodules, the 'bottom element' is the zero vector.

Two submodules of a module over a semiring are disjoint if and only if their intersection is the submodule generated by the zero vector.


theorem Set.preimage_const :
    ∀ {α : Type u_1} {β : Type u_2} (b : β) (s : Set β) [inst : Decidable (b ∈ s)],
      (fun x => b) ⁻¹' s = if b ∈ s then Set.univ else ∅ :=
  by sorry

This theorem, `Set.preimage_const`, states that for any types `α` and `β`, a value `b` of type `β`, and a set `s` of type `β`, given a decidable instance for `b` belonging to `s`, the preimage of `s` under the constant function mapping to `b` is equal to the universal set if `b` is in `s`, and is equal to the empty set otherwise. In mathematical terms, if `b` is in `s`, all elements of `α` are mapped to `b`, hence the preimage is the universal set. If `b` is not in `s`, no elements of `α` could have been mapped to `b`, hence the preimage is the empty set.

For any sets `α` and `β`, and a constant function `f : β → α` with image `s ⊆ β` decidable, if `b ∈ s`, then `f⁁⁻¹(s) = α`, and if `b ∉ s`, then `f⁁⁻¹(s) = ∅`.


theorem Real.smoothTransition.pos_denom : ∀ (x : ℝ), 0 < expNegInvGlue x + expNegInvGlue (1 - x) := by sorry

The theorem `Real.smoothTransition.pos_denom` states that for all real numbers `x`, the sum of the function `expNegInvGlue` evaluated at `x` and `1 - x` is always greater than zero. The function `expNegInvGlue` gives the value of exponentiating `-1/x` for `x > 0`, and zero for `x ≤ 0`. This theorem is essentially asserting that the sum of the values of this function at any point and its reflection about `x = 0.5` is always positive, which contributes to the smoothness of the function transition at the junction.

For all real numbers x, the sum of expNegInvGlue x and expNegInvGlue (1 - x) is positive.


Homeomorph.closedEmbedding

theorem Homeomorph.closedEmbedding :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      ClosedEmbedding ⇑h :=
  by sorry

This theorem states that for any two types `X` and `Y` that are both topological spaces, if there exists a homeomorphism `h` between `X` and `Y`, then the function `h` is a closed embedding. In other words, `h` is a function that maps closed sets in `X` to closed sets in `Y` and it is injective and continuous, with its image being a homeomorph of the original space `X`.

If `X` and `Y` are topological spaces with a homeomorphism `h` between them, then `h` is a closed, injective, and continuous function such that the image of every closed set in `X` is a closed set in `Y`.


theorem Set.image_mul_right :
    ∀ {α : Type u_2} [inst : Group α] {t : Set α} {b : α}, (fun x => x * b) '' t = (fun x => x * b⁻¹) ⁻¹' t := by sorry

This theorem states that for any type `α` that has a group structure, any subset `t` of `α`, and any element `b` of `α`, the image of `t` under the function that multiplies by `b` is the same as the preimage of `t` under the function that multiplies by the inverse of `b`. In other words, if you multiply every element of a set by some fixed group element, you get the same result as if you took all the elements that, when multiplied by the inverse of that group element, are in the original set.

For any group `α` and subset `t` of `α`, and for all `b` in `α`, the sets `{x : α | b * x ∈ t}` and `{x : α | x ∈ t ∧ x * b^(-1) ∈ α}` are equal.


Equiv.Perm.IsCycle.cycleType

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

The theorem `Equiv.Perm.IsCycle.cycleType` states that for any finite type `α` with decidable equality and any permutation `σ` on `α`, if `σ` is a cycle (i.e., a non-identity permutation where any two non-fixed points of the permutation are related by repeated application of the permutation), then the cycle type of `σ` (i.e., the multiset of the sizes of the orbits of `σ`) is a singleton multiset containing the cardinality of the support of `σ` (i.e., the set of non-fixed points of `σ`). In other words, if `σ` is a cycle, then there is exactly one orbit of non-fixed points, and its size is the number of non-fixed points.

If `σ` is a finite permutation on a type `α` with decidable equality, then `σ` being a cycle implies the cycle type of `σ` is a singleton multiset containing the cardinality of `σ`'s support.


theorem Mathlib.GroupTheory.Submonoid.Basic._auxLemma.10 :
    ∀ {M : Type u_1} [inst : MulOneClass M] (x : M), (x ∈ ⊤) = True := by sorry

This theorem states that for any type `M` that has a multiplication operation and an identity element (i.e., `M` is a `MulOneClass`), any element `x` of type `M` is a member of the top submonoid (denoted as `⊤`). In other words, the top submonoid contains all elements of the `MulOneClass`.

For any `MulOneClass` type `M` and its element `x`, `x` belongs to the top submonoid `⊤` of `M`.


theorem Real.Angle.neg_coe_pi : -↑Real.pi = ↑Real.pi := by sorry

The theorem `Real.Angle.neg_coe_pi` states that the negative of the real number representation of pi (`-↑Real.pi`) is equal to the real number representation of pi (`↑Real.pi`). In other words, it's saying that pi and negative pi are equal when considered as real numbers. It should be noted that this equality is not true in the ordinary real number field but is accurate in the context of angles, where adding or subtracting any multiple of `2π` to an angle gives a co-terminal angle, meaning pi and negative pi represent the same angle.

The theorem `Real.Angle.neg_coe_pi` asserts that `-↑Real.pi = ↑Real.pi` in the context of real numbers representing angles.


theorem hyperoperation_recursion :
    ∀ (n m k : ℕ), hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k) := by sorry

This theorem states a recursion property of the hyperoperation sequence. For all non-negative integers `n`, `m`, and `k`, the (n+1)th hyperoperation between `m` and (k + 1) is equal to the nth hyperoperation between `m` and the result of the (n + 1)th hyperoperation between `m` and `k`. In other words, the value of a hyperoperation at a certain level is derived from the value of the hyperoperation at the previous level and the current level.

For all non-negative integers n, m, and k, the (n+1)th hyperoperation between m and k is equal to the nth hyperoperation between m and the (n+1)th hyperoperation result between m and k.


theorem Set.mem_image_iff_bex :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {y : β}, y ∈ f '' s ↔ ∃ x, ∃ (_ : x ∈ s), f x = y := by
  sorry

This theorem, `Set.mem_image_iff_bex`, states that for any types `α` and `β`, a function `f` from `α` to `β`, a set `s` of elements of type `α`, and an element `y` of type `β`, `y` is in the image of the set `s` under the function `f` if and only if there exists an element `x` in the set `s` such that `f(x) = y`. In other words, an element `y` is in the image of the function `f` applied to the set `s` if and only if `y` can be written as `f(x)` for some `x` in `s`.

For any function $f : \alpha \to \beta$, set $S \subseteq \alpha$, and $\beta$-element $y$, $y \in \text{image}(f)(S)$ if and only if there exists $x \in S$ such that $f(x) = y$.


theorem Complex.abs_of_nonneg : ∀ {r : ℝ}, 0 ≤ r → Complex.abs ↑r = r := by sorry

This theorem states that for any real number `r` that is greater than or equal to zero (non-negative), the complex absolute value of `r` is equal to `r` itself. The complex absolute value function is defined as the square root of the complex norm squared, and this theorem provides a specific property of this function when applied to non-negative real numbers. Essentially, it tells us that the magnitude of a non-negative real number in the complex plane is just the number itself.

For any non-negative real number `r`, the complex absolute value of `r` equals `r`. In other words, `|r| = r` for all `r ≥ 0`.


theorem Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.24 :
    ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {x_1 : MeasurableSpace β} {a : α},
      (Measurable fun x => a) = True :=
  by sorry

This theorem states that for any types `α` and `β`, any measurable spaces `x` over `α` and `x_1` over `β`, and any element `a` of type `α`, the function that maps every element of its domain to the fixed element `a` is measurable. Here, measurability is defined in the sense that the preimage of every measurable set under this function is a measurable set.

For any measurable spaces `(α: Type)`, `(β: Type)`, and measurable sets `X: MeasurableSpace α`, `X_1: MeasurableSpace β`, and element `a: α`, the constant function `λ (x: X): β => a` is measurable in the sense that for any measurable set `M ⊆ β`, the preimage `(λ x. a)⁻¹'[M] ⊆ X` is a measurable subset of `X`.


theorem List.sublistsLen_zero : ∀ {α : Type u_1} (l : List α), List.sublistsLen 0 l = [[]] := by sorry

This theorem states that for any list `l` of any type `α`, the list of all sublists of `l` that are of length `0` is a list containing only the empty list. This is because a sublist of length `0` can only be an empty list, and there is exactly one empty list in any list.

The set of sublists of any list `l` of length `0` is a singleton set containing only the empty list.


theorem CategoryTheory.MonoidalCategory.inv_whiskerRight :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f : X ⟶ Y) (Z : C) [inst_1 : CategoryTheory.IsIso f],
      CategoryTheory.inv (CategoryTheory.MonoidalCategory.whiskerRight f Z) =
        CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.inv f) Z :=
  by sorry

This theorem states that in any monoidal category `C`, for any objects `X`, `Y` and `Z` in `C`, and any morphism `f` from `X` to `Y` that is an isomorphism, the inverse of the morphism obtained by whiskering `f` on the right with `Z` is equal to the morphism obtained by whiskering the inverse of `f` on the right with `Z`. In other words, the process of "whiskering" a morphism with another object is compatible with taking inverses of morphisms.

In a monoidal category, whiskering an isomorphism with an object preserves inverse morphisms: for any objects X, Y, Z and isomorphism f : X ⟶ Y, the inverse of f ∘ tz for any morphism tz : Z ⟶ X is equal to the morphism s ∘ ft, where s : Y ⟶ Z is the inverse of f.


theorem AddChar.mulShift_apply :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : CommMonoid M] {ψ : AddChar R M} {r x : R},
      (AddChar.mulShift ψ r) x = ψ (r * x) :=
  by sorry

This theorem states that for any ring `R`, commutative monoid `M`, additive character `ψ : AddChar R M`, and elements `r` and `x` of `R`, the application of `AddChar.mulShift` to `ψ` and `r`, and then to `x`, is equal to the application of `ψ` to the product of `r` and `x`. In other words, shifting the additive character `ψ` by multiplication with `r`, and then applying it to `x`, results in the same value as directly applying `ψ` to the product of `r` and `x`.

For any commutative monoid `M`, additive character `ψ : AddChar R M`, and ring elements `r, x` of `R`, `AddChar.mulShift ψ r x = ψ (r * x)`.


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

This theorem, named `MeasureTheory.set_lintegral_one`, states that for any given type `α`, any measurable space `m` of type `α`, any measure `μ` of the `MeasureTheory.Measure` on `α`, and any set `s` of type `α`, the Lebesgue integral (notated as `∫⁻`) of the constant function `1` over the set `s` with respect to the measure `μ` equals the double coercion (notated as `↑↑`) of the measure `μ` applied to the set `s`. In other words, the integral of one over a set is just the measure of that set.

For any measurable space `(α, m)`, measure `μ` on `α`, and set `s` in `α`, the Lebesgue integral of the constant function 1 over `s` equals the measure `μ(s)`.


theorem Int.add_mul : ∀ (a b c : ℤ), (a + b) * c = a * c + b * c := by sorry

This theorem, `Int.add_mul`, states that for any three integers `a`, `b`, and `c`, the operation of adding `a` and `b` together and then multiplying the result by `c` is equal to the operation of multiplying `a` by `c` and `b` by `c` separately and then adding those results together. In mathematical terms, this theorem is expressing the distributive property of multiplication over addition for integers, `(a + b) * c = a * c + b * c`.

The theorem asserts that for all integers a, b, and c, (a + b) * c = a * c + b * c.


theorem div_lt_div_right :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < c → (a / c < b / c ↔ a < b) := by sorry

This theorem, `div_lt_div_right`, states that for any type `α` that is a linear ordered semifield, and for any three elements `a`, `b`, and `c` of this type, if `c` is greater than zero, then `a` divided by `c` is less than `b` divided by `c` if and only if `a` is less than `b`. This is essentially saying that dividing both sides of an inequality by a positive number doesn't change the direction of the inequality.

For any linear ordered semifield type `α` and elements `a`, `b`, and `c` with `c > 0`, `a / c < b / c` if and only if `a < b`.


theorem CategoryTheory.MonoidalCategory.inv_whiskerLeft :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X : C) {Y Z : C}
      (f : Y ⟶ Z) [inst_1 : CategoryTheory.IsIso f],
      CategoryTheory.inv (CategoryTheory.MonoidalCategory.whiskerLeft X f) =
        CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.inv f) :=
  by sorry

This theorem, `CategoryTheory.MonoidalCategory.inv_whiskerLeft`, states that for any type `C` that is a category `𝒞` and a monoidal category, and for any objects `X`, `Y`, and `Z` in `C`, if there is a morphism `f` from `Y` to `Z` which is an isomorphism, then the inverse of the whiskerLeft operation applied to `X` and `f` (noted `CategoryTheory.inv (CategoryTheory.MonoidalCategory.whiskerLeft X f)`) is equal to the whiskerLeft operation applied to `X` and the inverse of `f` (expressed as `CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.inv f)`).

In simpler terms, this theorem captures the idea that "whiskering" on the left with a fixed object commutes with taking inverses of morphisms in a monoidal category.

In a monoidal category, whiskering on the left with a fixed object commutes with taking morphism inverses. That is, for any objects `X`, `Y`, and `Z` and an isomorphism `f : Y ⟶ Z`, `CategoryTheory.inv (CategoryTheory.MonoidalCategory.whiskerLeft X f) = CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.inv f)`.


theorem Metric.mem_nhds_iff :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {s : Set α}, s ∈ nhds x ↔ ∃ ε > 0, Metric.ball x ε ⊆ s := by
  sorry

This theorem states that for a given type `α` equipped with a `PseudoMetricSpace` structure, a set `s` is a neighborhood of a point `x` (i.e., `s` belongs to the neighborhood filter of `x`) if and only if there exists a positive real number `ε` such that the metric ball centered at `x` with radius `ε` is a subset of `s`. In other words, a set is a neighborhood of a point in a pseudometric space if and only if it contains an open ball around that point.

A set is a neighborhood of a point in a pseudometric space if and only if it contains the open ball around that point.


theorem Mathlib.Order.WithBot._auxLemma.2 : ∀ {α : Type u_1} {a : α}, (⊥ = ↑a) = False := by sorry

This theorem from the Mathlib Order WithBot module states that, for any type `α` and any element `a` of type `α`, the equality between the bottom element (`⊥`) and the lifted version of `a` (`↑a`) is always false. In other words, no matter what specific type and element we are working with, the bottom element of the order can never be considered as the lift of any element from the underlying type.

For all types `α` and elements `a` of type `α`, `⊥ ≠ ↑a`.


Codisjoint.symm

theorem Codisjoint.symm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] ⦃a b : α⦄, Codisjoint a b → Codisjoint b a := by
  sorry

The theorem `Codisjoint.symm` states that for any given type `α` that has a partial order and a top order, if two elements `a` and `b` of this type are codisjoint (i.e., their supremum is the top element), then the property of being codisjoint is symmetrical, meaning that if `a` and `b` are codisjoint, then `b` and `a` are also codisjoint. In mathematical terms, if for all `x` in `α`, `a ≤ x` and `b ≤ x` implies `⊤ ≤ x`, then `b ≤ x` and `a ≤ x` also implies `⊤ ≤ x`.

If elements `a` and `b` of a type `α` with partial order and top element are codisjoint, then `b` and `a` are also codisjoint. (i.e., `a` and `b` have the same supremum, which is the top element, thus they are interchangeable in the definition of codisjointness)


/-- An additive group homomorphism sends negations to negations. -/
theorem IsAddGroupHom.map_neg :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddGroup β] {f : α → β},
      IsAddGroupHom f → ∀ (a : α), f (-a) = -f a :=
  by sorry

The theorem `IsAddGroupHom.map_neg` states that for any two additive groups `α` and `β` and a function `f` from `α` to `β`, if `f` is an additive group homomorphism, then `f` maps the negation of any element in `α` to the negation of its image in `β`. In other words, for any element `a` in `α`, the result of applying `f` to `-a` (negative of `a`) is the same as the negative of `f(a)`.

For any additive groups α and β and additive group homomorphism f from α to β, f maps the negation of any element in α to the negation of its image in β. That is, -f(a) = f(-a) for all a in α.


LipschitzWith.const

/-- Constant functions are Lipschitz (with any constant).  -/
theorem LipschitzWith.const :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (b : β),
      LipschitzWith 0 fun x => b :=
  by sorry

This theorem states that constant functions are Lipschitz continuous with any constant. Specifically, for any types `α` and `β` that are pseudo-emetric spaces, and for any element `b` of type `β`, the function that maps every element of `α` to `b` is Lipschitz continuous with a Lipschitz constant of `0`. In other words, the distance between the images of any two distinct points in `α` under this function is less than or equal to `0` times the distance between these two points, which is always true since the images are always the same (i.e., `b`).

For any pseudo-metric spaces `α` and `β` and any constant `b` in `β`, the function mapping every element in `α` to `b` is a Lipschitz continuous function with Lipschitz constant 0.


theorem Cardinal.le_one_iff_subsingleton : ∀ {α : Type u}, Cardinal.mk α ≤ 1 ↔ Subsingleton α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is less than or equal to one if and only if `α` is a subsingleton. In other words, a type `α` has at most one element (i.e., its cardinality is less than or equal to one) if and only if every pair of elements of `α` is identical (i.e., `α` is a subsingleton).

A type `α` has at most one element if and only if it is a subsingleton (i.e., every pair of elements is identical).


theorem Nat.max_zero : ∀ (a : ℕ), max a 0 = a := by sorry

This theorem states that for any natural number `a`, the maximum of `a` and `0` is always `a`. In other words, when you compare any natural number with zero and you take the larger one, you always get the natural number itself, as all natural numbers are greater than or equal to zero.

For all natural numbers `a`, `a` is greater than or equal to 0, so `max 0 a = a`.


Function.Injective.smulCommClass

theorem Function.Injective.smulCommClass :
    ∀ {M : Type u_1} {N : Type u_2} {α : Type u_6} {β : Type u_7} [inst : SMul M α] [inst_1 : SMul N α]
      [inst_2 : SMul M β] [inst_3 : SMul N β] [inst_4 : SMulCommClass M N β] {f : α → β},
      Function.Injective f →
        (∀ (c : M) (x : α), f (c • x) = c • f x) → (∀ (c : N) (x : α), f (c • x) = c • f x) → SMulCommClass M N α :=
  by sorry

The theorem `Function.Injective.smulCommClass` states that for any types `M`, `N`, `α`, and `β`, if `α` and `β` have scalar multiplication structures by `M` and `N`, and if `β` has a scalar multiplication commutation structure between `M` and `N`, then for any function `f` from `α` to `β` that is injective and respects the scalar multiplication (i.e., `f` of `c` multiplied by `x` is equal to `c` multiplied by `f` of `x` for any scalar `c` and any element `x` of `α`), `α` also has a scalar multiplication commutation structure between `M` and `N`.

In simpler terms, if the function `f` is injective and preserves the scalar multiplication operation, then the property of commuting scalar multiplications is transferred from the codomain `β` to the domain `α` of the function.

If `α` and `β` are types with scalar multiplication structures by `M` and `N`, `β` has a scalar multiplication commutation structure between `M` and `N`, and `f` : `α → β` is an injective homomorphism of additive monoids (respecting scalar multiplications), then `α` has a scalar multiplication commutation structure between `M` and `N`.


theorem Polynomial.derivative_pow :
    ∀ {R : Type u} [inst : CommSemiring R] (p : Polynomial R) (n : ℕ),
      Polynomial.derivative (p ^ n) = Polynomial.C ↑n * p ^ (n - 1) * Polynomial.derivative p :=
  by sorry

The theorem `Polynomial.derivative_pow` states that for any commutative semiring `R`, any polynomial `p` over `R`, and any natural number `n`, the derivative of the `n`-th power of `p` is equal to `n` times the `n-1`-th power of `p` times the derivative of `p`. In mathematical notation, this is saying that if `p` is a polynomial and `n` a natural number, then the derivative of `p^n` is `n*p^{n-1}*p'`, where `p'` is the derivative of `p`. This is a formalization of the power rule for derivatives in the context of polynomials.

The derivative of a polynomial `p` raised to the power of `n` is equal to `n * p^(n-1) * p'`.


theorem MeasureTheory.lintegral_dirac :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α) (f : α → ENNReal),
      ∫⁻ (a : α), f a ∂MeasureTheory.Measure.dirac a = f a :=
  by sorry

This theorem states that for any measurable space `α` with singleton measurability, and any function `f` from `α` to the extended nonnegative real numbers, the Lebesgue integral (denoted by `∫⁻ (a : α), f a ∂MeasureTheory.Measure.dirac a`) over the Dirac measure at a point `a` is equal to the value of `f` at `a`. In other words, when we compute the Lebesgue integral with respect to the Dirac measure at a point, we simply "pick out" the function's value at that point.

For any measurable space `α` with singleton measurability and any measurable function `f` from `α` to the extended nonnegative real numbers, the Lebesgue integral of `f` with respect to the Dirac measure at a point `a` equals `f a`.


theorem Equiv.Perm.support_one :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α], Equiv.Perm.support 1 = ∅ := by sorry

The theorem `Equiv.Perm.support_one` states that for any type `α` which has decidable equality and is finite, the set of non-fixed points of the identity permutation (denoted as `1` in Lean) is empty. In other words, for any element of `α`, applying the identity permutation doesn't change the element, hence there are no non-fixed points.

For any finite type `α` with decidable equality, the identity permutation fixes all elements, i.e., its non-fixed points are empty.


theorem Set.fst_image_prod :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set β) {t : Set α}, Set.Nonempty t → Prod.fst '' s ×ˢ t = s := by sorry

The theorem `Set.fst_image_prod` states that for any two types `α` and `β`, and any set `s` of type `β` and a nonempty set `t` of type `α`, the image of the first projection function `Prod.fst` applied to the Cartesian product of `s` and `t` is equal to `s`. In more mathematical terms, for every element in set `s`, there exists a pair in the Cartesian product of `s` and `t` such that the first element of the pair belongs to `s`. This element is the image of the pair under the first projection function. Thus, the set of all the first elements of the pairs in the Cartesian product is equal to `s`.

The first projection of the Cartesian product of two sets maps each element of one set to an element of that set itself.


theorem inv_eq_of_mul_eq_one_left : ∀ {G : Type u_1} [inst : DivisionMonoid G] {a b : G}, a * b = 1 → b⁻¹ = a := by
  sorry

This theorem states that for any type `G` that has a division monoid structure, given any two elements `a` and `b` of type `G`, if the multiplication of `a` and `b` equals to the identity element `1`, then the multiplicative inverse of `b` is equal to `a`. In mathematical terms, for all `a` and `b` in a division monoid, if `a * b = 1`, then `b⁻¹ = a`.

If `a` and `b` are elements of a division monoid such that `a * b = 1`, then `b` is the multiplicative inverse of `a`, i.e., `b⁻¹ = a`.


Polynomial.ofFinsupp.injEq

theorem Polynomial.ofFinsupp.injEq :
    ∀ {R : Type u_1} [inst : Semiring R] (toFinsupp toFinsupp_1 : AddMonoidAlgebra R ℕ),
      ({ toFinsupp := toFinsupp } = { toFinsupp := toFinsupp_1 }) = (toFinsupp = toFinsupp_1) :=
  by sorry

This theorem states that for any semiring `R` and any two elements `toFinsupp` and `toFinsupp_1` of the monoid algebra generated by the additive monoid of natural numbers over `R`, the equality of the singleton sets containing `toFinsupp` and `toFinsupp_1` respectively is equivalent to the equality of `toFinsupp` and `toFinsupp_1` themselves. In other words, two sets of this form are equal if and only if their single elements are equal.

For any semiring `R`, two elements of the monoid algebra generated by the additive monoid of natural numbers over `R` represent the same set if and only if they are equal as elements.


theorem Mathlib.GroupTheory.GroupAction.ConjAct._auxLemma.2 :
    ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by sorry

This theorem states that for any proposition `b` and any type `α` such that `α` is nonempty (there exists at least one element of type `α`), the type of functions from `α` to `b` is equal to `b`. In other words, when `α` is nonempty, the type of functions from `α` to a given proposition is essentially the same as that proposition itself.

For any nonempty type `α`, the type of functions from `α` to a proposition `b` is equivalent to `b`.


Continuous.codRestrict

theorem Continuous.codRestrict :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
      Continuous f → ∀ (hs : ∀ (a : X), f a ∈ s), Continuous (Set.codRestrict f s hs) :=
  by sorry

This theorem states that given two types `X` and `Y`, each equipped with a topological structure, a function `f` from `X` to `Y`, and a subset `s` of `Y`, if `f` is a continuous function such that for every element `a` in `X`, `f(a)` is in `s`, then the codomain-restricted function `Set.codRestrict f s hs` is also continuous. In simple terms, if a function is continuous and its output always falls within a certain set, then even when we restrict the function's codomain to that set, the resulting function remains continuous.

If `f : X → Y` is a continuous function and `s ⊆ Y` is such that `∀ x ∈ X, f x ∈ s`, then `Set.codRestrict f s` is a continuous function.


theorem Primrec₂.comp₂ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {σ : Type u_5} [inst : Primcodable α]
      [inst_1 : Primcodable β] [inst_2 : Primcodable γ] [inst_3 : Primcodable δ] [inst_4 : Primcodable σ]
      {f : γ → δ → σ} {g : α → β → γ} {h : α → β → δ},
      Primrec₂ f → Primrec₂ g → Primrec₂ h → Primrec₂ fun a b => f (g a b) (h a b) :=
  by sorry

The theorem `Primrec₂.comp₂` states that if we have five types `α`, `β`, `γ`, `δ`, and `σ`, all of which have instances of `Primcodable`, and three binary functions `f`, `g`, and `h` where `f` maps from `γ` to `δ` to `σ`, `g` maps from `α` to `β` to `γ`, and `h` maps from `α` to `β` to `δ`. If these three functions `f`, `g` and `h` are primitive recursive (`Primrec₂`), then the binary function that maps `a` and `b` to `f (g a b) (h a b)` is also primitive recursive.

In simpler terms, if we have primitive recursive binary functions `f`, `g`, and `h`, then the composition of `f` with `g` and `h` is also a primitive recursive function.

If `f : γ -> δ -> σ`, `g : α -> β -> γ`, and `h : α -> β -> δ` are primitive recursive functions, then the function `x y => f (g x y) (h x y)` is also primitive recursive.


theorem Polynomial.rootSet_def :
    ∀ {T : Type w} [inst : CommRing T] (p : Polynomial T) (S : Type u_1) [inst_1 : CommRing S] [inst_2 : IsDomain S]
      [inst_3 : Algebra T S] [inst_4 : DecidableEq S],
      Polynomial.rootSet p S = ↑(Multiset.toFinset (Polynomial.aroots p S)) :=
  by sorry

The theorem `Polynomial.rootSet_def` states that, for any type `T` with a commutative ring structure, a polynomial `p` with coefficients in `T`, a type `S` with a commutative ring structure and domain property, and an algebraic structure connecting `T` and `S`, along with decidable equality on `S`, the set of distinct roots of `p` in `S` is equal to the set created by removing duplicates from the multiset of roots of `p` regarded as a polynomial over `S`. In mathematical terms, this theorem asserts that the set of roots of a polynomial in an associated algebraic structure is precisely the unique roots of the polynomial considered over that structure.

The set of distinct roots of a polynomial over a commutative ring with decidable equality is equal to the set obtained by removing duplicates from the multiset of roots regarded as a polynomial over an algebraically connected commutative ring.


DMatrix.ext

theorem DMatrix.ext :
    ∀ {m : Type u_2} {n : Type u_3} {α : m → n → Type v} {M N : DMatrix m n α},
      (∀ (i : m) (j : n), M i j = N i j) → M = N :=
  by sorry

This theorem, `DMatrix.ext`, states that for any two dependently typed matrices `M` and `N` of the same type (`DMatrix m n α`), if for every row index `i` from type `m` and column index `j` from type `n` it holds that the entries at position `(i, j)` in both matrices are identical (i.e., `M i j = N i j`), then the matrices `M` and `N` are equal. In other words, two dependently typed matrices are equal if all their corresponding entries are equal.

If for all i and j, the entries M(i, j) and N(i, j) of dependently typed matrices M : DMatrix m n α and N : DMatrix m n α are equal, then matrices M and N are equal.


theorem List.cons_head!_tail :
    ∀ {α : Type u} [inst : Inhabited α] {l : List α}, l ≠ [] → List.head! l :: List.tail l = l := by sorry

The theorem `List.cons_head!_tail` states that for any type `α` and any inhabited list `l` of type `α` that is not empty, the list obtained by prepending the head of `l` (using the `List.head!` function) to the tail of `l` (using the `List.tail` function) is equal to `l` itself. Essentially, it asserts that taking apart a non-empty list into its head and tail and then putting them back together results in the original list.

For any non-empty list `l` of type `α`, `List.cons (List.head! l) (List.tail l) = l`.


/-- The infimum of a singleton is the element of the singleton -/
theorem csInf_singleton : ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] (a : α), sInf {a} = a := by sorry

This theorem states that the infimum (greatest lower bound) of a singleton set in any conditionally complete lattice is the single element of that set. Here, a conditionally complete lattice is a type `α` that has a greatest lower bound and least upper bound for every nonempty set that has an upper bound or a lower bound respectively. Essentially, if you have a set with just one element `a`, then the greatest lower bound of this set is `a` itself.

In a conditionally complete lattice, the infimum of a singleton set is its unique element.


theorem Mathlib.Data.Finset.Basic._auxLemma.179 :
    ∀ {α : Type u_1} {a b : α} {l : List α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) := by sorry

This theorem, also known as `Mathlib.Data.Finset.Basic._auxLemma.179`, is stating that for any type `α`, and any elements `a` and `b` of type `α`, and a list `l` of elements of type `α`, the condition that `a` is an element of the list that starts with `b` followed by the elements of `l` is equivalent to the condition that `a` equals `b` or `a` is an element of `l`. Essentially, this theorem is expressing the basic membership property of lists in Lean 4.

For any type `α` and elements `a`, `b` of `α` and list `l` of `α`, `a` is the first element of `l` followed by the remaining elements if and only if `a` equals `b` or `a` is an element of `l`.


Function.Surjective.countable

theorem Function.Surjective.countable :
    ∀ {α : Sort u} {β : Sort v} [inst : Countable α] {f : α → β}, Function.Surjective f → Countable β := by sorry

The theorem `Function.Surjective.countable` states that for any types `α` and `β`, if `α` is countable and there exists a function `f` from `α` to `β` that is surjective (i.e., for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`), then `β` is also countable. Here, a countable type is one that has the same cardinality as some subset of the natural numbers.

If `α` is a countable type and `f: α → β` is a surjective function, then `β` is also countable.


NonUnitalAlgebra.gc

theorem NonUnitalAlgebra.gc :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      [inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A],
      GaloisConnection (NonUnitalAlgebra.adjoin R) SetLike.coe :=
  by sorry

The theorem `NonUnitalAlgebra.gc` states that for any Commutative Semiring `R` and any Non-Unital Non-Associative Semiring `A` that is also a `R`-module, if `A` is a scalar tower and follows the scalar multiplication commutative law, then there exists a Galois connection between the function `adjoin` of Non-Unital Algebra over `R` and the coercion function of a `SetLike` structure.
In mathematical terms, a Galois connection is established between the algebra generated by a subset and the subset itself when viewing it as a set in the algebra. This connection provides a link between the algebraic structure and the underlying set structure.

Given a Commutative Semiring `R`, a Non-Unital Non-Associative `R`-module Semiring `A` that is a scalar tower and satisfies the scalar multiplication commutative law, there exists a Galois connection between the `adjoin` function of `A` and the coercion function of `A` as a `SetLike` structure.


theorem Nat.cast_sum :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoidWithOne β] (s : Finset α) (f : α → ℕ),
      ↑(Finset.sum s fun x => f x) = Finset.sum s fun x => ↑(f x) :=
  by sorry

This theorem states that for any finite set `s` of elements from an arbitrary type `α` and a function `f` that maps elements from `α` to the natural numbers (`ℕ`), the natural number cast (`↑`) of the sum of `f(x)` over all elements `x` in `s` is equal to the sum of the natural number cast of `f(x)` over all elements `x` in `s`. In other words, summing the values of `f(x)` and then applying the cast operation is the same as applying the cast operation to each `f(x)` and then summing. This theorem is applicable under the assumption that the type `β` forms an additive commutative monoid with a distinct one element.

For any finite set `s` from type `α` and additive commutative monoid `ℙ` with identity element, the sum of the natural number casts of the function values `f(x)` over all `x` in `s` equals the natural number cast of the sum of `f(x)` over all `x` in `s`.


theorem Finset.coe_one : ∀ {α : Type u_2} [inst : One α], ↑1 = 1 := by sorry

This theorem states that for any type `α` that has an instance of the `One` typeclass, the coercion of `1` to a `Finset` (finite set) equals `1`. This essentially means that, in the context of finite sets, a single element set with the element as `1` is equivalent to `1`.

For any type `α` with an instance of Lean's `One` typeclass, the coercion of `1` to a `Finset α` is equal to the singleton set `{1 : α}`.


theorem Fintype.sum_sum_type :
    ∀ {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [inst : Fintype α₁] [inst_1 : Fintype α₂]
      [inst_2 : AddCommMonoid M] (f : α₁ ⊕ α₂ → M),
      (Finset.sum Finset.univ fun x => f x) =
        (Finset.sum Finset.univ fun a₁ => f (Sum.inl a₁)) + Finset.sum Finset.univ fun a₂ => f (Sum.inr a₂) :=
  by sorry

The theorem `Fintype.sum_sum_type` states that for any two types `α₁` and `α₂`, and a type `M` with an instance of `AddCommMonoid`, and a function `f` from the sum type `α₁ ⊕ α₂` to `M`, the summation of `f` over all elements of the sum type `α₁ ⊕ α₂` is equal to the sum of `f` applied to all elements of `α₁` (with `Sum.inl`) plus the sum of `f` applied to all elements of `α₂` (with `Sum.inr`). Essentially, it asserts that summing over a disjoint union of types corresponds to summing over each type individually and then adding the two sums.

For any type `α₁ ⊕ α₂`, function `f` from `α₁ ⊕ α₂` to an additive commutative monoid `M`, and elements `x₁ : α₁` and `x₂ : α₂`, `∑ i, f (i : α₁ ⊕ α₂) = ∑ x₁ : α₁, f (Sum.inl x₁) + ∑ x₂ : α₂, f (Sum.inr x₂)`.


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

This theorem states that for any type `G₀` that forms a Group with Zero, given any two elements `a` and `b` of `G₀` such that `b` is not equal to zero, the statement "`a` divided by `b` equals 1" is equivalent to the statement "`a` equals `b`". This proposition is foundational in algebra where the rule of division states that any number divided by itself equals 1.

For any group with zero `G₀` and non-zero elements `a` and `b` in `G₀`, `a = b` if and only if `a / b = 1`.


theorem toIcoDiv_eq_of_sub_zsmul_mem_Ico :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) {a b : α} {n : ℤ},
      b - n • p ∈ Set.Ico a (a + p) → toIcoDiv hp a b = n :=
  by sorry

This theorem states that for any Archimedean linearly ordered additive commutative group `α` and for any positive `p` in `α`, if the number obtained by subtracting `n` times `p` from `b` lies in the left-closed right-open interval from `a` to `a + p`, then the unique integer which when multiplied by `p` and subtracted from `b` lies in the same interval `a` to `a + p`, is `n`. Here, `n` is an integer and `a`, `b`, and `p` are elements of `α`.

For any Archimedean linearly ordered additive commutative group `α`, and positive `p` in `α`, if `b - np` lies in the interval `[a, a + p)`, then `n` is the unique integer such that `b - np` belongs to `[a, a + p)`.


theorem Finset.coe_pow :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] (s : Finset α) (n : ℕ), ↑(s ^ n) = ↑s ^ n := by sorry

The theorem `Finset.coe_pow` states that for any type `α` that has decidable equality and a monoid structure, any finset `s` of type `α`, and any natural number `n`, lifting `s` to the power of `n` (using the monoid operation for finsets) and then taking the "set" corresponding to the resultant finset is the same as first taking the "set" corresponding to `s` and then taking it to the power of `n` (using the monoid operation for sets). In other words, the operations of taking power and "set" corresponding to a finset commute.

For any type `α` with decidable equality and a monoid structure, the operation of taking the power of a finset `s` in the monoid of finsets and then taking the underlying set is equal to taking the underlying set of `s` and then raising it to the power in the monoid of sets.


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

The theorem `Polynomial.derivative_map` states that for any semirings `R` and `S`, and for any polynomial `p` over `R` and any ring homomorphism `f` from `R` to `S`, the derivative of the polynomial obtained by mapping `p` across `f` is equal to the mapping of the derivative of `p` across `f`. In other words, taking the derivative and then mapping is the same as mapping and then taking the derivative. This is a statement of the commutativity of the derivative operation with the map operation in the context of polynomials.

For any semiring homomorphism between rings, the derivative of a polynomial mapped across the homomorphism is equal to the mapped derivative of the polynomial.


theorem Finset.card_filter_le :
    ∀ {α : Type u_1} (s : Finset α) (p : α → Prop) [inst : DecidablePred p], (Finset.filter p s).card ≤ s.card := by
  sorry

This theorem states that for any set `s` of type `α` and a property `p` that elements of `α` can possess, when `p` is a decidable predicate, the cardinality (or size) of the subset of `s` that satisfies `p` is less than or equal to the cardinality of the set `s` itself. In simpler terms, it states that the number of elements in a set that satisfy a certain condition is always less than or equal to the total number of elements in the set.

For any set `s` of type `α` and decidable predicate `p` on `α`, the cardinality of `{x : s | p x}` is less than or equal to the cardinality of `s`.


ContinuousAt.prod

theorem ContinuousAt.prod :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {g : X → Z} {x : X},
      ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun x => (f x, g x)) x :=
  by sorry

The theorem `ContinuousAt.prod` states that for all types `X`, `Y`, and `Z` with `X` as the input type and `Y` and `Z` as output types where `X`, `Y`, and `Z` are topological spaces, for any two functions `f : X → Y` and `g : X → Z` and a point `x` in `X`, if the functions `f` and `g` are continuous at the point `x`, then the function that maps `x` to the ordered pair `(f x, g x)` is also continuous at `x`. In other words, the product of two continuous functions at a particular point is also continuous at that point.

If functions `f : X → Y` and `g : X → Z` are continuous at a point `x` in a topological space `X`, then the function `(f, g) : X → Y × Z` defined by `(f, g) x = (f x, g x)` is continuous at `x`.


theorem Finset.forall_image₂_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {p : γ → Prop}, (∀ z ∈ Finset.image₂ f s t, p z) ↔ ∀ x ∈ s, ∀ y ∈ t, p (f x y) :=
  by sorry

The theorem `Finset.forall_image₂_iff` states that for all types `α`, `β`, `γ` with decidable equality on `γ`, for any binary function `f` from type `α` to `β` to `γ`, for any finite sets `s` and `t` of type `α` and `β` respectively, and for any property `p` on `γ`, the property `p` holds for all elements in the image of the binary function `f` applied to each pair of elements from `s` and `t` if and only if for all elements `x` in `s` and for all elements `y` in `t`, the property `p` holds for `f(x, y)`. In other words, checking a property on all elements of the image set obtained by applying a binary function on pair of elements from two finite sets is equivalent to checking the property on application of the binary function on all such pairs.

For any binary function between two finite sets with decidable equality on the codomain and any property on the codomain, the property holds for all images of pairs in the sets if and only if it holds for the images of each pair in the sets separately.


theorem Subtype.mono_coe : ∀ {α : Type u} [inst : Preorder α] (t : Set α), Monotone Subtype.val := by sorry

The theorem `Subtype.mono_coe` states that for any type `α` that has a preorder structure and any set `t` of `α`, the function `Subtype.val` is monotone. In other words, if we have two elements of a subtype such that one is less than or equal to the other, then their underlying elements in the base type `α`, obtained using `Subtype.val`, also uphold this order.

For any preordered type `α` and subtype `t ⊆ α`, the function `Subtype.val` preserves the ordering, i.e., `x ≤ y` in `t` implies `Subtype.val x ≤ Subtype.val y` in `α`.


theorem ack_strictMono_right : ∀ (m : ℕ), StrictMono (ack m) := by sorry

The theorem `ack_strictMono_right` states that for every natural number `m`, the Ackermann function `ack m` is strictly monotonic. In other words, if `n1` and `n2` are any natural numbers such that `n1 < n2`, then `ack m n1 < ack m n2`. The Ackermann function is thus strictly increasing in its second argument for each fixed first argument.

For all natural numbers m and n1 < n2, the Ackermann function ack m is strictly increasing in the second argument: ack m n1 < ack m n2.


theorem Set.right_mem_uIcc : ∀ {α : Type u_1} [inst : Lattice α] {a b : α}, b ∈ Set.uIcc a b := by sorry

This theorem states that for any lattice `α` and any elements `a` and `b` of `α`, the element `b` is included in the set `Set.uIcc a b`. In other words, in any lattice, the upper boundary of the set defined by the least upper bound (join/supremum) and greatest lower bound (meet/infimum) of `a` and `b` always includes `b`.

For any lattice and elements `a` and `b`, the greatest lower bound of `a` and `b` is a lower bound of `b`, and the least upper bound of `a` and `b` is an upper bound of `b`. Therefore, `b` belongs to the interval `[a, b]` defined by `Set.uIcc a b`.


theorem EMetric.hausdorffEdist_def :
    ∀ {α : Type u_2} [inst : PseudoEMetricSpace α] (s t : Set α),
      EMetric.hausdorffEdist s t = (⨆ x ∈ s, EMetric.infEdist x t) ⊔ ⨆ y ∈ t, EMetric.infEdist y s :=
  by sorry

This theorem states that for any given type `α` equipped with a pseudo extended metric space structure, and any two sets `s` and `t` of type `α`, the Hausdorff extended distance between `s` and `t` is defined as the supremum of the infimum extended distances from each point in `s` to the set `t`, and vice versa. In other words, it provides a characterisation of the Hausdorff distance in terms of minimal distances of points to sets.

The Hausdorff distance between two sets in a pseudo extended metric space is the supremum of the infimum of extended distances from each point in one set to the other, and the supremum of the infimum of extended distances from each point in the other set to the first set.


theorem Finset.mem_range_succ_iff : ∀ {a b : ℕ}, a ∈ Finset.range (Nat.succ b) ↔ a ≤ b := by sorry

The theorem `Finset.mem_range_succ_iff` states that for any two natural numbers 'a' and 'b', 'a' is a member of the set of natural numbers less than or equal to 'b' (i.e., `Finset.range (Nat.succ b)`) if and only if 'a' is less than or equal to 'b'. In other words, a natural number 'a' falls within the range up to the successor of 'b' (which is equivalent to the range from zero to 'b' inclusive) if and only if 'a' does not exceed 'b'.

For any natural numbers 'a' and 'b', 'a' is in the set of natural numbers less than or equal to 'b' if and only if 'a' is less than or equal to 'b'.


theorem QuotientGroup.leftRel_eq :
    ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α), Setoid.r = fun x y => x⁻¹ * y ∈ s := by sorry

This theorem states that for any type `α` that forms a group (i.e., satisfies the group axioms), and for any subgroup `s` of this group, the equivalence relation `Setoid.r` is defined as the property that the product of the inverse of `x` and `y` belongs to the subgroup `s`. In other words, two elements `x` and `y` of the group are considered equivalent under this relation if and only if their ratio `x⁻¹ * y` is an element of the subgroup `s`.

For any group `α` and subgroup `s`, elements `x` and `y` are equal up to the subgroup `s` if and only if `x⁻¹ * y` belongs to `s`.


theorem sInf_empty : ∀ {α : Type u_1} [inst : CompleteLattice α], sInf ∅ = ⊤ := by sorry

This theorem states that for any type `α` that forms a complete lattice, the infimum (or greatest lower bound) of an empty set is the top element (`⊤`). In other words, in the context of a complete lattice, the smallest element of an empty set is the largest possible element in the lattice.

In a complete lattice, the infimum of the empty set is the top element.


ContinuousWithinAt.comp

theorem ContinuousWithinAt.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {g : β → γ} {f : α → β} {s : Set α} {t : Set β} {x : α},
      ContinuousWithinAt g t (f x) → ContinuousWithinAt f s x → Set.MapsTo f s t → ContinuousWithinAt (g ∘ f) s x :=
  by sorry

The theorem `ContinuousWithinAt.comp` states that for any three topological spaces `α`, `β`, and `γ`, given two functions `f` from `α` to `β` and `g` from `β` to `γ`, along with subsets `s` of `α` and `t` of `β`, and a point `x` in `α`, if `g` is continuous at the point `f(x)` within `t`, `f` is continuous at `x` within `s`, and `f` maps every point of `s` into `t`, then the composition `g ∘ f` is also continuous at `x` within `s`.

This theorem is a generalization of the standard result in topology that the composition of two continuous functions is continuous. Here, however, the continuity of each function is considered within a particular subset of its domain, and the theorem imposes the additional condition that `f` must map `s` into `t`.

Given topological spaces α, β, and γ, functions f : α → β and g : β → γ, subsets s ⊆ α and t ⊆ β, and a point x ∈ α, if g is continuous at f(x) within t, f is continuous at x within s, and f(s) ∋ t, then g ∘ f is continuous at x within s.


theorem Set.support_indicator :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {f : α → M},
      Function.support (Set.indicator s f) = s ∩ Function.support f :=
  by sorry

This theorem states that for any given types `α` and `M`, with `M` having a zero element, any set `s` of type `α`, and function `f` from `α` to `M`, the support of the indicator function of `s` and `f` is the intersection of `s` and the support of `f`. In other words, the support of the indicator function, which is the set of points where the indicator function is not zero, is precisely the set of points that are in both `s` and the locations where `f` is not zero.

The support of the indicator function of a set `s` and a function `f` from `α` to a type `M` with a zero element is equal to the intersection of `s` and the support of `f`.


theorem Fintype.one_lt_card : ∀ {α : Type u_1} [inst : Fintype α] [h : Nontrivial α], 1 < Fintype.card α := by sorry

The theorem `Fintype.one_lt_card` states that for any type `α` that belongs to the class `Fintype` (meaning that it has a finite number of elements) and is `Nontrivial` (meaning that it has at least two distinct elements), the cardinality of `α` (denoted by `Fintype.card α`) is strictly greater than 1. In other words, any nontrivial finite set has more than one element.

For any nontrivial finite type α, its cardinality is greater than 1.


theorem AddSubgroup.relindex_mul_index :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
      H ≤ K → AddSubgroup.relindex H K * AddSubgroup.index K = AddSubgroup.index H :=
  by sorry

This theorem states that for any additive group `G` and any two of its subgroups `H` and `K` such that `H` is a subgroup of `K`, the product of the relative index of `H` in `K` and the index of `K` equals the index of `H`. Here, the relative index of a subgroup is defined as the index of the subgroup formed from the original subgroup and another subgroup, and the index of a subgroup is defined as the cardinality of the quotient group formed by the group and the subgroup. Note that indices are given as natural numbers and are zero in case of infinite indices.

For any additive group `G` and subgroups `H` and `K` with `H` a subgroup of `K`, the product of the index of `H` in `K` and the index of `K` in `G` equals the index of `H` in `G`.


Set.Finite.isCompact

theorem Set.Finite.isCompact : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, Set.Finite s → IsCompact s := by
  sorry

This theorem states that for any type `X` that has a topological space structure, any finite set `s` of elements of type `X` is compact. Here, a set `s` is said to be compact if for every nontrivial filter `f` that contains `s`, there exists an element `x` in `s` such that every set in `f` meets every neighborhood of `x`. A set is said to be finite if there exists a natural number `n` and an equivalence between the set and `Fin n`.

For any topological space `X`, every finite subset `s` of `X` is compact in the sense that for every nontrivial filter `f` containing `s`, there exists an element `x` in `s` such that every set in `f` intersects every neighborhood of `x`.


theorem CategoryTheory.Adjunction.homEquiv_naturality_left_symm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
      (adj.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
        CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv X Y).symm g) :=
  by sorry

The theorem `CategoryTheory.Adjunction.homEquiv_naturality_left_symm` states that for any categories `C` and `D`, functors `F` from `C` to `D` and `G` from `D` to `C`, and an adjunction `adj` between `F` and `G`, if we have objects `X` and `X'` in `C` and `Y` in `D`, and morphisms `f` from `X'` to `X` and `g` from `X` to `G.obj Y`, then applying the inverse of the `homEquiv` function of the adjunction to the composition of `f` and `g` is equal to the composition of the `F.map` of `f` and the inverse of the `homEquiv` function applied to `g`. This theorem describes a property of the hom-set bijection in an adjunction, specifically its compatibility with morphism composition in the 'left-naturality' sense when considering the inverse of the bijection.

For any adjunction between functors and objects in categories, the application of the inverse of the adjunction's hom-set bijection to the composition of a morphism from one object to another in the source category followed by a morphism from the image of the first to the second in the target category, is equal to the composition of the functor's mapping of the first morphism and the inverse of the hom-set bijection applied to the second morphism.


theorem Subalgebra.one_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A), 1 ∈ S :=
  by sorry

This theorem states that for any subalgebra `S` of an algebra `A` over a commutative semiring `R`, the multiplicative identity element `1` is an element of `S`. Here, `A` is a semiring and `R` is a commutative semiring, with `A` being an algebra over `R`. In the context of algebra, a subalgebra is a subset of an algebra that is closed under the operations of addition, scalar multiplication, and multiplication.

In any subalgebra S of an algebra A over a commutative semiring R, the multiplicative identity 1 of R is an element of S.


theorem Set.Icc_diff_left : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Icc a b \ {a} = Set.Ioc a b := by
  sorry

This theorem states that for any partial order set `α` and any two elements `a` and `b` in this set, the difference between the closed interval (including both endpoints) `[a, b]` and the singleton set `{a}` is equal to the half-open interval `(a, b]`. In other words, if you start with the closed interval `[a, b]` and remove the point `a`, you end up with the half-open interval `(a, b]`, which includes `b` but not `a`.

For any partial order set `α`, the difference between the closed interval `[a, b]` and the singleton set `{a}` is equal to the half-open interval `(a, b]`. In other words, `[a, b] \ {a} = (a, b]`.


theorem Ordinal.eq_zero_or_pos : ∀ (a : Ordinal.{u_3}), a = 0 ∨ 0 < a := by sorry

The theorem `Ordinal.eq_zero_or_pos` states that for any ordinal `a` of type `Ordinal`, `a` is either equal to zero or greater than zero. In other words, this theorem asserts that any ordinal number is either zero or a positive number.

For any ordinal number `a`, `a` is equal to zero or greater than zero.


theorem Filter.EventuallyEq.trans_isBigO :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
      {g : α → F}, f₁ =ᶠ[l] f₂ → f₂ =O[l] g → f₁ =O[l] g :=
  by sorry

This theorem states that for any types `α`, `E`, and `F` where `E` and `F` are normed, given a filter `l` on `α`, and functions `f₁`, `f₂` from `α` to `E`, and `g` from `α` to `F`, if `f₁` is eventually equal to `f₂` at `l`, and `f₂` is Big O of `g` at `l`, then `f₁` is also Big O of `g` at `l`.

In mathematical terms, it says that if $f₁(x) = f₂(x)$ for all $x$ sufficiently close to a point in a filter `l` and $f₂(x) = O(g(x))$ (meaning $f₂(x)$ grows no faster than `g` in terms of `l`), then $f₁(x) = O(g(x))$ as well.

If `f₁` equals `f₂` in a filter `l` where `f₂` is Big O of `g` at `l` for normed types `α`, `E`, and `F`, then `f₁` is also Big O of `g` at `l`.


theorem Set.range_eq_empty : ∀ {α : Type u_1} {ι : Sort u_4} [inst : IsEmpty ι] (f : ι → α), Set.range f = ∅ := by sorry

The theorem `Set.range_eq_empty` states that for any type `α` and any sort `ι`, if `ι` is an empty type (indicated by the `IsEmpty ι` instance), then for any function `f` from `ι` to `α`, the range of `f` (i.e. the set of all outputs of `f`) is the empty set. In other words, if a function has an empty domain, then its range is also empty.

If `ι` is an empty type, then the range of any function from `ι` to `α` is the empty set.


/-- A ring satisfying `StrongRankCondition` (such as a `DivisionRing`) is one-dimensional as a
module over itself.  -/
theorem FiniteDimensional.finrank_self :
    ∀ (R : Type u) [inst : Ring R] [inst_1 : StrongRankCondition R], FiniteDimensional.finrank R R = 1 := by sorry

This theorem states that for any ring `R` that satisfies the `StrongRankCondition` (for instance, a `DivisionRing`), the rank of `R` as a module over itself is one. In other words, in the context of module theory, `R` is one-dimensional when considered over itself. This is measured using the function `FiniteDimensional.finrank`, which returns the rank of a module as a natural number. If the module has infinite rank, by convention, this function returns `0`. This theorem thus asserts a notable property of rings satisfying the `StrongRankCondition`: they are essentially as simple as possible from the perspective of their module-theoretic structure over themselves.

For any ring `R` satisfying the `StrongRankCondition`, the rank of `R` as a module over itself, as measured by `FiniteDimensional.finrank`, is 1.


theorem Real.continuous_sqrt : Continuous Real.sqrt := by sorry

This theorem states that the square root function on real numbers is continuous. In other words, for every real number, small changes in the input lead to small changes in the output of the function, which in this case is the square root of the input. This is a fundamental property in calculus and real analysis.

The square root function is a continuous function on the real numbers.


/-- Composition of semiring homomorphisms is associative.  -/
theorem RingHom.comp_assoc :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
      {x_2 : NonAssocSemiring γ} {δ : Type u_5} {x_3 : NonAssocSemiring δ} (f : α →+* β) (g : β →+* γ) (h : γ →+* δ),
      RingHom.comp (RingHom.comp h g) f = RingHom.comp h (RingHom.comp g f) :=
  by sorry

The theorem `RingHom.comp_assoc` states that the composition of semiring homomorphisms is associative. In other words, for any three semiring homomorphisms `f`, `g`, and `h` (where `f` is a function from a nonassociative semiring `α` to a nonassociative semiring `β`, `g` is a function from `β` to `γ`, and `h` is a function from `γ` to `δ`), composing `h` and `g` first and then composing the result with `f` is the same as first composing `g` and `f` and then composing `h` with the result. This is a fundamental property of function composition and is essential in many areas of mathematics and computer science.

For any semiring homomorphisms $f:\alpha \to \beta$, $g:\beta \to \gamma$, and $h:\gamma \to \delta$, $h \circ g \circ f = g \circ f \circ h$.


theorem CategoryTheory.Limits.biprod.lift_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
      [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {T U : C} {f : T ⟶ X} {g : T ⟶ Y} {h : X ⟶ U} {i : Y ⟶ U},
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift f g)
          (CategoryTheory.Limits.biprod.desc h i) =
        CategoryTheory.CategoryStruct.comp f h + CategoryTheory.CategoryStruct.comp g i :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.lift_desc` states that for any category `C` that is preadditive (meaning that it has a binary operation compatible with its categorical structure) and has binary biproducts, given objects `X`, `Y`, `T`, and `U` in `C`, and morphisms `f` from `T` to `X`, `g` from `T` to `Y`, `h` from `X` to `U`, and `i` from `Y` to `U`, the composition of the biproduct lift of `f` and `g` with the biproduct descendent of `h` and `i` is equal to the sum of the compositions of `f` and `h` with `g` and `i`. In other words, it asserts the equality between two specific ways of completing a commutative square in a preadditive category with binary biproducts.

In a preadditive category with binary biproducts, the composition of the biproduct lift of a morphism with the biproduct descent of another morphism is equal to the sum of the compositions of the two morphisms.


theorem Ordinal.omega_ne_zero : Ordinal.omega ≠ 0 := by sorry

This theorem asserts that the ordinal number `ω`, which is defined as the first infinite ordinal and corresponds to the order type of natural numbers, is not equal to zero. In other words, the infinite ordinal `ω` is distinct from the ordinal zero, emphasizing the non-finiteness of `ω`.

The theorem asserts that the infinite ordinal `ω` is not equal to zero.


theorem inf_compl_eq_bot : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α}, a ⊓ aᶜ = ⊥ := by sorry

This theorem states that for any type `α` that forms a Heyting algebra, the infimum (greatest lower bound) of any element `a` and its complement `aᶜ` is equal to the bottom element `⊥` of the algebra. In other words, in any Heyting algebra, any element and its complement have no common elements, represented by the bottom element of the algebra.

In any Heyting algebra, the infimum of an element and its complement is the bottom element.


/-- Definition of `x ⧏ y` on pre-games, in terms of `≤`.

The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
moves by Right.  -/
theorem SetTheory.PGame.lf_iff_exists_le :
    ∀ {x y : SetTheory.PGame},
      SetTheory.PGame.LF x y ↔ (∃ i, x ≤ SetTheory.PGame.moveLeft y i) ∨ ∃ j, SetTheory.PGame.moveRight x j ≤ y :=
  by sorry

The theorem `SetTheory.PGame.lf_iff_exists_le` provides a definition of the less or fuzzy (⧏) relation on pre-games. This definition is expressed in terms of the less than or equal to (≤) relation. Specifically, for any two pre-games `x` and `y`, `x` is less or fuzzy to `y` if and only if there exists a move `i` by Left such that `x` is less than or equal to the game resulting from making move `i` in `y`, or there exists a move `j` by Right such that the game resulting from making move `j` in `x` is less than or equal to `y`.

For any pre-games x and y, x is less or fuzzy (⧏) to y if and only if there exists i (Left move) such that x ≤ y\_{i}, or there exists j (Right move) such that y\_{j} ≤ x.


theorem MeasureTheory.Integrable.comp_measurable :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : MeasurableSpace δ] [inst_1 : NormedAddCommGroup β] {f : α → δ} {g : δ → β},
      MeasureTheory.Integrable g (MeasureTheory.Measure.map f μ) → Measurable f → MeasureTheory.Integrable (g ∘ f) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.comp_measurable` states that for any types `α`, `β`, and `δ`, given a measurable space `α` with measure `μ`, a measurable space `δ`, a normed add commutative group `β`, a function `f` from `α` to `δ`, and a function `g` from `δ` to `β`, if `g` is integrable with respect to the pushforward measure of `μ` via `f`, and `f` is measurable, then the composition of `g` and `f` (i.e. `g ∘ f`) is integrable with respect to the measure `μ`.

In simpler terms, if we have a measurable transformation `f`, and a function `g` which is integrable when we take into account the change in measure induced by `f`, then the function we get by applying `g` after `f` is integrable in the original measure space.

If `f: α → δ` is measurable, `g: δ → β` is integrable with respect to the pushforward measure of `μ` via `f`, then `g ∘ f` is integrable with respect to the measure `μ` on `α`.


theorem compl_involutive : ∀ {α : Type u} [inst : BooleanAlgebra α], Function.Involutive compl := by sorry

The theorem `compl_involutive` asserts that for all types `α` equipped with a boolean algebra structure, the `compl` function (which represents the complement operation in the boolean algebra) is involutive. In other words, applying the `compl` function twice to any element of the boolean algebra results in the original element. In mathematical terms, this is saying that for all elements `x` in the boolean algebra, `compl(compl(x)) = x`.

For all types equipped with a boolean algebra structure, the complement operation is involutive, i.e., `compl(compl(x)) = x` for all elements `x` in the boolean algebra.


theorem MeasureTheory.Measure.withDensity_rnDeriv_le :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α), ν.withDensity (μ.rnDeriv ν) ≤ μ := by
  sorry

This theorem states that for any measurable space `α` and any two measures `μ` and `ν` on that space, the measure formed by weighting `ν` with the Radon-Nikodym derivative of `μ` with respect to `ν` is always less than or equal to `μ`. In mathematical terms, this says that for every measurable set, the integral of the Radon-Nikodym derivative over that set with respect to `ν` is less than or equal to the measure of that set under `μ`.

For any measurable spaces `α`, measures `μ` and `ν` on `α` with `ν` being σ-finite and `μ` absolutely continuous with respect to `ν`, we have $\int\_A d\mu / d\nu \leqslant \mu(A)$ for all measurable sets `A` in `α`.


theorem Set.EqOn.eventuallyEq_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {l : Filter α} {f g : α → β}, Set.EqOn f g s → s ∈ l → f =ᶠ[l] g := by
  sorry

The theorem `Set.EqOn.eventuallyEq_of_mem` states that for any types `α` and `β`, any set `s` of type `α`, any filter `l` on `α`, and any two functions `f` and `g` from `α` to `β`, if `f` and `g` are equal on `s` and `s` is in the filter `l`, then `f` is eventually equal to `g` with respect to the filter `l`. In other words, at some point and thereafter in the sequence defined by the filter `l`, the values of `f` and `g` are the same for all elements in the set `s`.

If `s` is a set in filter `l` over type `α`, and functions `f` and `g` from `α` to `β` agree on `s`, then there exists an index `n` such that for all `i ≥ n`, `f(s(i)) = g(s(i))`.


/-- A nontrivial finite dimensional space has positive `finrank`.  -/
theorem FiniteDimensional.finrank_pos :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      [inst_4 : StrongRankCondition R] [inst_5 : Module.Finite R M] [inst_6 : NoZeroSMulDivisors R M]
      [h : Nontrivial M], 0 < FiniteDimensional.finrank R M :=
  by sorry

This theorem states that for any nontrivial finite dimensional space, its associated `finrank` (the rank of a module as a natural number) is positive. More formally, given a ring `R`, a module `M` over `R`, and under the conditions that `R` is nontrivial, `R` has the strong rank condition, `M` is a finite module over `R`, there are no zero scalar multipliers and divisors in `M`, and `M` itself is nontrivial, then the `finrank` of `M` over `R` is strictly greater than zero.

if R is a nontrivial ring satisfying the strong rank condition, and M is a finite, nontrivial module over R with no zero scalar multipliers or divisors, then the rank of M is positive.


theorem MeasureTheory.AEStronglyMeasurable'.ae_eq_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} (hfm : MeasureTheory.AEStronglyMeasurable' m f μ),
      f =ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.AEStronglyMeasurable'.mk f hfm :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable'.ae_eq_mk` states that for any given types `α` and `β`, measurable spaces `m` and `m0` on `α`, a measure `μ` on `α`, a topological space structure on `β`, and a function `f` from `α` to `β` which is almost everywhere `m`-strongly measurable (denoted by `MeasureTheory.AEStronglyMeasurable' m f μ`), the function `f` is almost everywhere equal to the function obtained by applying the constructor `MeasureTheory.AEStronglyMeasurable'.mk` to `f` and the proof of its almost-everywhere `m`-strong measurability. Here, "almost everywhere" is with respect to the measure `μ`, which means that the set of points where the two functions disagree has measure zero.

For any measurable spaces `m` and `m0`, measure `μ` on a type `α`, topological space `β`, and almost everywhere `m`-strongly measurable function `f : α → β`, `f` is almost everywhere equal to `MeasureTheory.AEStronglyMeasurable'.mk f μ`.


theorem Set.iInter₂_subset :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s : (i : ι) → κ i → Set α} (i : ι) (j : κ i),
      ⋂ i, ⋂ j, s i j ⊆ s i j :=
  by sorry

The theorem `Set.iInter₂_subset` states that for any type `α`, any type-indexed type `κ` indexed by `ι`, and any function `s` mapping an index `i` of type `ι` and an index `j` of type `κ[i]` to a set of elements of type `α`, for any specific indices `i` of type `ι` and `j` of type `κ[i]`, the intersection over all `i` and over all `j` of the sets `s[i][j]` is a subset of the specific set `s[i][j]`. This theorem is a statement about the properties of intersections of indexed families of sets.

For any type `α`, type-indexed family `κ` of types, and function `s` mapping `(ι × κ)` to sets of `α`, the indexed intersections of `s` are included in each individual set in the image of `s`.


Set.PairwiseDisjoint.elim

theorem Set.PairwiseDisjoint.elim :
    ∀ {α : Type u_1} {ι : Type u_4} [inst : PartialOrder α] [inst_1 : OrderBot α] {s : Set ι} {f : ι → α},
      Set.PairwiseDisjoint s f → ∀ {i j : ι}, i ∈ s → j ∈ s → ¬Disjoint (f i) (f j) → i = j :=
  by sorry

This theorem states that, given a partially ordered type `α` with a bottom element, a set `s` of elements of type `ι`, and a function `f` mapping `ι` to `α`, if `s` is pairwise disjoint under `f`, then for any two elements `i` and `j` in `s`, if the images of `i` and `j` under `f` are not disjoint (i.e., their greatest lower bound is not the bottom element of `α`), then `i` must be equal to `j`. In essence, this theorem ensures the uniqueness of elements in a pairwise disjoint set under a certain function, based on a property of their images under that function in a lattice structure.

Given a partially ordered type `α` with a bottom element, if `s` is a pairwise disjoint set of elements of type `ι` and `f : ι → α` is a function, then for any distinct `i, j ∈ s`, if `f i` and `f j` have a greatest lower bound that is not the bottom element of `α`, then `i = j`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.54 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      (T : FirstOrder.Language.Theory L), M ⊨ T = ∀ φ ∈ T, M ⊨ φ :=
  by sorry

This theorem, under the context of model theory in first-order languages, states that for any first-order language `L` and any structure `M` of `L`, a theory `T` (which is a set of sentences in `L`) is said to be satisfied by `M` (denoted by `M ⊨ T`) if and only if every sentence `φ` in the theory `T` is satisfied by `M` (denoted by `M ⊨ φ`).

A first-order theory T is satisfied by a structure M if and only if every sentence φ in T is satisfied by M.


theorem Filter.le_map₂_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ},
      h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h :=
  by sorry

The theorem `Filter.le_map₂_iff` states that for any types `α`, `β`, `γ`, a binary function `m : α → β → γ`, and the filters `f : Filter α`, `g : Filter β`, and `h : Filter γ`, filter `h` is less than or equal to the image of the binary function `m` applied to filters `f` and `g` if and only if for every set `s` in `f` and every set `t` in `g`, the image of the binary function `m` applied to `s` and `t` is in `h`.
In other words, this theorem specifies the condition necessary for filter `h` to be less than or equal to the image of a binary function applied to two other filters.

For filters $f$ on type $\alpha$, $g$ on type $\beta$, and $h$ on type $\gamma$, and a binary function $m : \alpha \times \beta \to \gamma$, $h \leq \map{m}{f \times g}$ if and only if for all $s \in f$ and $t \in g$, $\map{m}{s,t} \in h$.


theorem MeasureTheory.OuterMeasure.trim_eq :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α) {s : Set α},
      MeasurableSet s → ↑(MeasureTheory.OuterMeasure.trim m) s = ↑m s :=
  by sorry

This theorem, `MeasureTheory.OuterMeasure.trim_eq`, states that for any type `α` equipped with a `MeasurableSpace` instance, any outer measure `m` on `α`, and any set `s` of type `α`, if `s` is a measurable set, then the value of the trimmed outer measure `m` at `s` is equal to the value of the original outer measure `m` at `s`. In other words, trimming an outer measure does not change its value on measurable sets.

For any measurable space `(α, Σ, mu)` and measurable set `s ∈ Σ`, the trimmed outer measure `muᵢ(s)` equals the original outer measure `mu(s)`.


theorem Submodule.mem_iInf :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
      (p : ι → Submodule R M) {x : M}, x ∈ ⨅ i, p i ↔ ∀ (i : ι), x ∈ p i :=
  by sorry

The theorem `Submodule.mem_iInf` states that for any types `R` and `M`, given a semiring structure on `R`, an additive commutative monoid structure on `M`, and a module structure over `R` on `M`, and for any indexing type `ι`, a function `p` from `ι` to submodules of `M`, and an element `x` of `M`, `x` belongs to the intersection of all submodules `p i` (for all `i` in `ι`) if and only if `x` belongs to each individual submodule `p i`.

For any semiring `R`, additive commutative monoid `M`, module `M` over `R`, indexing type `ι`, and submodule functions `p : ι → submodules M`, an element `x` of `M` belongs to the intersection of all `p i` if and only if it belongs to each `p i`.


theorem LinearMap.coe_injective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S},
      Function.Injective DFunLike.coe :=
  by sorry

This theorem states that for any types `R`, `S`, `M`, and `M₃`, given `R` and `S` are semirings, `M` and `M₃` are additively commutative monoids, `M` is an `R`-module, `M₃` is an `S`-module, and `σ` is a ring homomorphism from `R` to `S`, the function that maps each `F` in the type `DFunLike F α β` to the corresponding function from `α` to `β` is injective. In other words, if two different objects of the type `DFunLike F α β` map to the same function from `α` to `β`, then the two objects were actually the same to begin with. This theorem is often used to prove results about the uniqueness of certain mathematical constructions.

Given `R`, `S` semirings, `M` an additively commutative monoid and `R`-module, `M₃` an additively commutative monoid and `S`-module, and `σ: R → S` a ring homomorphism, the function mapping `DFunLike F α β` to their corresponding functions from `α` to `β` is an injection.


theorem Finsupp.add_apply :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] (g₁ g₂ : α →₀ M) (a : α), (g₁ + g₂) a = g₁ a + g₂ a := by
  sorry

This theorem, `Finsupp.add_apply`, states that for any two functions `g₁` and `g₂` which map elements from a certain type `α` to a type `M` (which has an addition operation and a zero element), and for any element `a` of type `α`, the sum of `g₁` and `g₂` at `a` is equal to the sum of the values of `g₁` at `a` and `g₂` at `a`. This is essentially asserting that addition of functions obeys the same properties as addition of their values.

For functions `g₁` and `g₂` from type `α` to additive type `M`, and for all `a` in `α`, `(g₁ + g₂) a = g₁ a + g₂ a`.


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

This theorem in category theory states that for any category `J`, any category `C`, any functor `F` from `J` to `C`, any colimit `F` in `C`, and any cocone `c` of `F` for which `c` is a colimit, then for any object `j` in `J`, the composition of the coprojection from `j` to the colimit of `F` and the morphism from the colimit of `F` to `c` that is unique up to isomorphism is the same as the morphism from `j` to `c`. In other words, it ensures that the diagram commutes in the category, which means that the path from `j` to `c` via `F` and the direct path from `j` to `c` are the same.

Given any functor `F` from a category `J` to a category `C`, any colimit `colim F` and cocone `c` of `F` in `C`, if `c` is the colimit of `F` and `j` is an object in `J`, then the composition of the coprojection from `j` to `colim F` and the unique morphism from `colim F` to `c` is equal to the morphism from `j` to `c`.


theorem CategoryTheory.shiftFunctorAdd'.proof_1 :
    ∀ (C : Type u_1) {A : Type u_3} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : AddMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] (i j k : A),
      i + j = k → CategoryTheory.shiftFunctor C k = CategoryTheory.shiftFunctor C (i + j) :=
  by sorry

This theorem states that for any type `C` in the context of category theory, given a type `A` that forms an additive monoid, and assuming that `C` has a shift structure over `A`, then for any three elements `i`, `j`, and `k` of `A`, if `i + j` equals `k`, then the shift functor applied to `C` and `k` is the same as the shift functor applied to `C` and `i + j`. In other words, the shift functor preserves the additive monoid structure of `A`.

Given an additive monoid `A` and a category `C` with a shift structure over `A`, the shift functor commutes with addition of elements in `A`, i.e., for all `i`, `j`, `k` in `A` with `i + j = k`, we have `S(C[i]) ≈ S(C[j]) ≈ S(C[k])`, where `≈` denotes isomorphic objects in `C`.


theorem BoxIntegral.HasIntegral.integral_eq :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} {y : F},
      BoxIntegral.HasIntegral I l f vol y → BoxIntegral.integral I l f vol = y :=
  by sorry

This theorem states that for any types `ι`, `E`, `F`, given that `E` and `F` are normed add commutative groups and also normed spaces over the real numbers ℝ, given a box `I` in the `ι`-dimensional space, an integration parameter `l`, a function `f` mapping from `ι → ℝ` to `E`, a volume function `vol` mapping from `ι` to a linear map from `E` to `F` and a value `y` in `F`, if `f` has an integral over the box `I` with respect to the volume `vol` that equals `y` under the integration parameter `l`, then the actual integral of `f` over the box `I` with respect to `vol` under `l` is indeed `y`.

If `f : ι -> ℝ -> E`, `vol : ι -> E -> F`, `I : box ι`, `l : ℝ`, `y : F` satisfy `∫x in I, vol x . f x = y` (integral of `f` with respect to `vol` over `I` under `l` equals `y`), then `y = ∫x in I, vol x . f x` (the actual integral of `f` over `I` with respect to `vol` under `l` is equal to `y`).


theorem ContinuousOn.isOpen_inter_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {t : Set β}, ContinuousOn f s → IsOpen s → IsOpen t → IsOpen (s ∩ f ⁻¹' t) :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with topological spaces, given a function `f` from `α` to `β`, a set `s` in `α`, and a set `t` in `β`, if the function `f` is continuous on the set `s`, and both sets `s` and `t` are open, then the intersection of set `s` with the preimage of set `t` under function `f` is also an open set. In mathematical terms, this can be represented as: if we have a continuous function `f: α → β` and two open sets `s ⊆ α` and `t ⊆ β`, then the set `s ∩ f⁻¹(t)` is open in α. Here, `f⁻¹(t)` is the preimage of `t` under `f`, meaning the set of all elements in `α` that `f` maps into `t`.

If `f: α → β` is a continuous function between topological spaces `α` and `β`, and `s ⊆ α` and `t ⊆ β` are open sets, then the intersection of `s` with the preimage of `t` under `f` is an open set in `α`.


ContinuousOn.smul

theorem ContinuousOn.smul :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : SMul M X] [inst_4 : ContinuousSMul M X] {f : Y → M} {g : Y → X}
      {s : Set Y}, ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => f x • g x) s :=
  by sorry

The theorem `ContinuousOn.smul` states that for all types `M`, `X`, and `Y` (given that `M` and `X` are topological spaces and `M` is equipped with an operation of scalar multiplication on `X` which is continuous), and for functions `f : Y → M` and `g : Y → X` as well as a set `s` of type `Y`, if both `f` and `g` are continuous on the set `s`, then the function that maps each element `x` in `s` to the product of `f x` and `g x` (in the sense of scalar multiplication) is also continuous on `s`. This theorem is important in the theory of topological vector spaces, where continuity of operations is a key requirement.

If `M` is a topological space equipped with a continuous scalar multiplication, and `f : Y → M` and `g : Y → X` are continuous functions, then the function `x ↦ f x * g x` is continuous on the domain of `f` and `g`.


/-- If `f` tends to infinity along a filter, then `f` multiplied by a positive
constant (on the left) also tends to infinity. For a version working in `ℕ` or `ℤ`, use
`filter.tendsto.const_mul_atTop'` instead.  -/
theorem Filter.Tendsto.const_mul_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedSemifield α] {l : Filter β} {f : β → α} {r : α},
      0 < r → Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => r * f x) l Filter.atTop :=
  by sorry

The theorem `Filter.Tendsto.const_mul_atTop` states that for any types `α` and `β`, given a linearly ordered semifield `α`, a filter `l` on `β`, a function `f : β → α`, and a positive constant `r : α`, if the function `f` tends to infinity (i.e., increases without bound) along the filter `l`, then the function formed by multiplying `f` by `r` (i.e., `(fun x => r * f x)`) also tends to infinity along the same filter. For similar behavior in the specific cases of `ℕ` or `ℤ`, one should use `filter.tendsto.const_mul_atTop'`.

If a function tends to infinity along a filter in a linearly ordered semifield, then multiplying it by a positive constant also tends to infinity along the same filter.


theorem Finset.image_comm :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {s : Finset α} {β' : Type u_4}
      [inst_1 : DecidableEq β'] [inst_2 : DecidableEq γ] {f : β → γ} {g : α → β} {f' : α → β'} {g' : β' → γ},
      (∀ (a : α), f (g a) = g' (f' a)) → Finset.image f (Finset.image g s) = Finset.image g' (Finset.image f' s) :=
  by sorry

The theorem `Finset.image_comm` states that for any types `α`, `β`, `γ`, and `β'` and any finite set `s` of type `α`, if we have two functions `f : β → γ`, `g : α → β`, another function `f' : α → β'` and `g' : β' → γ`, where `β`, `β'` and `γ` are types with decidable equality, then if for every element `a` of type `α`, `f(g(a))` is equal to `g'(f'(a))`, the image of the image of `s` under `g` then `f` is the same as the image of the image of `s` under `f'` then `g'`. In other words, the order of composition of these two pairs of functions in the image operation does not matter as long as the functions satisfy the said property.

If `f : β → γ`, `g : α → β`, `f' : α → β'`, `g' : β' → γ` are functions with decidable equality types `β`, `β'`, and `γ`, and `s` is a finite set of type `α`, then `g''(f(x)) = f'(g(x))` for all `x` in `s` implies `f(g(s)) = g'(f'(s))`.


/-- `arsinh` is the right inverse of `sinh`.  -/
theorem Real.sinh_arsinh : ∀ (x : ℝ), Real.sinh (Real.arsinh x) = x := by sorry

The theorem `Real.sinh_arsinh` states that the function `arsinh` acts as the right inverse of the function `sinh` for real numbers. In other words, for every real number `x`, if you first apply the `arsinh` function to `x` and then apply the `sinh` function to the result, you get back the original real number `x`. In mathematical terms, this is expressed as $\sinh(\text{arsinh}(x)) = x$ for all real numbers `x`.

The `Real.sinh_arsinh` theorem asserts that for all real numbers `x`, `sinh(arsinh(x)) = x`.


theorem PartialHomeomorph.map_nhds_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : X}, x ∈ e.source → Filter.map (↑e) (nhds x) = nhds (↑e x) :=
  by sorry

This theorem, `PartialHomeomorph.map_nhds_eq`, asserts that for any two types `X` and `Y` equipped with topological space structures, and for a partial homeomorphism `e` from `X` to `Y`, if a point `x` belongs to the source of `e`, then the forward map of the filter of neighborhood of `x` under `e` is equal to the neighborhood of the image of `x` under `e`. In other words, a partial homeomorphism maps the neighborhood filter of a point in its source to the neighborhood filter of its image. This is a property that we would expect from any structure preserving map between topological spaces.

Given types equipped with topological structures `X` and `Y`, and a partial homeomorphism `e` from `X` to `Y`, if `x` is in the domain of `e`, then the filter of neighborhoods of `x` in `X` is mapped to the filter of neighborhoods of `e(x)` in `Y` under `e`.


theorem Finsupp.coe_mul :
    ∀ {α : Type u₁} {β : Type u₂} [inst : MulZeroClass β] (g₁ g₂ : α →₀ β), ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂ := by sorry

The theorem `Finsupp.coe_mul` states that for any two functions `g₁` and `g₂` from an arbitrary type α to another type β (where β is a multiplication class that contains zero), the process of applying a function to the product of `g₁` and `g₂` (represented by `⇑(g₁ * g₂)`) is equivalent to the product of the results of applying the function to `g₁` and `g₂` separately (represented by `⇑g₁ * ⇑g₂`).

For any functions `g₁` and `g₂` from type `α` to a multiplication class `β` with zero, `⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂`.


theorem Nat.succ_add_eq_add_succ : ∀ (a b : ℕ), Nat.succ a + b = a + Nat.succ b := by sorry

This theorem states that for any two natural numbers `a` and `b`, the successor of `a` plus `b` is equal to `a` plus the successor of `b`. In terms of traditional mathematics, if `a` and `b` are natural numbers, then `(a+1) + b = a + (b+1)`. This theorem encapsulates a fundamental property of addition, which is commutativity of incrementation.

For any natural numbers `a` and `b`, `(a + 1) + b = a + (b + 1)`.


ContDiffAt.hasStrictFDerivAt'

/-- If a function is `C^n` with `1 ≤ n` around a point, and its derivative at that point is given to
us as `f'`, then `f'` is also a strict derivative.  -/
theorem ContDiffAt.hasStrictFDerivAt' :
    ∀ {n : ℕ∞} {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E']
      [inst_2 : NormedSpace 𝕂 E'] {F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F']
      {f : E' → F'} {f' : E' →L[𝕂] F'} {x : E'},
      ContDiffAt 𝕂 n f x → HasFDerivAt f f' x → 1 ≤ n → HasStrictFDerivAt f f' x :=
  by sorry

This theorem states that if a function `f` is continuously differentiable `n` times (with `n` being 1 or more) around a point `x`, and its derivative at that point is given as `f'`, then `f'` is also a strict derivative of `f` at `x`. In other words, if the function `f` is smooth enough (i.e., it has at least one continuous derivative) at a point, and we know its derivative at that point, then that derivative is indeed the "strict" derivative, meaning it not only approximates the change in `f` around `x` but also satisfies a stronger condition related to the rate of change.

If a function `f` is continuously differentiable of order `n` at a point `x`, then the `n`th derivative `f^{(n)}` of `f` at `x` is the strict derivative of `f` at `x`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.39 : ∀ (n : ℕ), (↑n = ⊤) = False := by sorry

This theorem states that for any natural number `n`, it is not possible for the real number representation of `n` to be infinity (`⊤`). In other words, no natural number can be equivalent to infinity when converted into the set of extended non-negative real numbers.

For any natural number `n`, `n` is not equal to infinity (`⊤`) in the set of extended non-negative real numbers.