theorem heq_iff_eq : ∀ {α : Sort u_1} {a b : α}, HEq a b ↔ a = b := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of this type, the higher-level equality (`HEq`) between `a` and `b` is equivalent to the standard equality (`=`) between `a` and `b`. In other words, the higher-order equality is the same as the standard equality for elements of the same type in Lean 4.

For any type `α` and any `a, b : α`, the higher-level equality `α.HEq a b` is equivalent to the standard equality `a = b`.


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

This theorem states that for all types `α` and `β` which have a finite number of elements (also called as "finite types" or "fintypes"), a function `f` from `α` to `β` is bijective if and only if it is injective (meaning that different inputs yield different outputs) and the number of elements in `α` is the same as the number of elements in `β`. In mathematical terms, this can be written as: if `f: α → β` is a function between two finite sets `α` and `β`, then `f` is a bijection if and only if `f` is injective and the cardinality of `α` is equal to the cardinality of `β`.

A function between two finite sets is bijective if and only if it is injective and the cardinalities of the sets are equal.


theorem CategoryTheory.Limits.imageSubobject_arrow :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.imageSubobjectIso f).hom
          (CategoryTheory.Limits.image.ι f) =
        CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject f) :=
  by sorry

This theorem states that, in any category `C` where we have a morphism `f` from `X` to `Y` and the image of `f` exists, the composition of the homomorphism associated with the isomorphism between the underlying object of the image subobject of `f` and the image of `f`, and the inclusion of the image of `f` into `Y`, is equal to the morphism from the arbitrarily chosen underlying object of the image subobject of `f` to `Y`. In other words, this theorem is asserting the commutativity of a certain diagram in the category `C`, providing a relationship between the concepts of image subobject, image, and the arrow of a subobject.

In any category with subobjects, the composition of the homomorphism from the image subobject of a morphism to its image, and the inclusion of the image into the codomain, is equal to the morphism from the image subobject to the codomain.


IntermediateField.ext

/-- Two intermediate fields are equal if they have the same elements.  -/
theorem IntermediateField.ext :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      {S T : IntermediateField K L}, (∀ (x : L), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any two intermediate fields `S` and `T` of a field extension `L/K`, if every element `x` of the extension `L` is in `S` if and only if it is in `T`, then `S` is equal to `T`. Here, `K` and `L` are fields and `L` is an algebra over `K`, which means that `L` can be viewed as a vector space over `K`. The theorem thus captures the intuition that two sets are equal if they have exactly the same elements, specialized to the case of intermediate fields in a field extension.

If two intermediate fields `S` and `T` of a field extension `L/K` have equal elements, then `S` equals `T`.


theorem Cardinal.mk_univ : ∀ {α : Type u}, Cardinal.mk ↑Set.univ = Cardinal.mk α := by sorry

This theorem states that for any type `α`, the cardinal number (or size) of the universal set of `α` is equal to the cardinal number of the type `α` itself. In other words, it asserts that there is a one-to-one correspondence (or a bijection) between the set of all elements of type `α` and the universal set on `α`. This means that the number of elements in the universal set on a type is equal to the number of elements of that type.

For any type `α`, the cardinality of `α` equals the cardinality of its universe.


ContinuousAt.mul

theorem ContinuousAt.mul :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Mul M]
      [inst_3 : ContinuousMul M] {f g : X → M} {x : X},
      ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun x => f x * g x) x :=
  by sorry

The theorem `ContinuousAt.mul` states that given two topological spaces `X` and `M`, where `M` is equipped with a multiplication operation and this operation is continuous, if we have two functions `f` and `g` from `X` to `M` that are continuous at a point `x` in `X`, then the function that assigns to any point `x` the product `f(x) * g(x)` is also continuous at `x`. This is a formalization of the principle that the product of two continuous functions is also continuous.

If `M` is a topological space equipped with a continuous multiplication operation, and `f` and `g` are continuous functions from a topological space `X` to `M` at a point `x` in `X`, then their product `f * g` is also continuous at `x`.


theorem ZMod.int_cast_mod : ∀ (a : ℤ) (b : ℕ), ↑(a % ↑b) = ↑a := by sorry

This theorem states that for any integer `a` and any natural number `b`, the operation of casting the modulus of `a` and `b` to an integer is equivalent to simply casting `a` to an integer. In mathematical terms, it asserts that for any integer $a$ and any natural number $b$, the expression $(a \mod b)$ cast to an integer equals $a$ cast to an integer.

For any integer `a` and natural number `b`, the expressions `(a : int)` and `(a mod b : int)` are equal.


theorem Filter.HasBasis.eq_of_same_basis :
    ∀ {α : Type u_1} {ι : Sort u_4} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → Filter.HasBasis l' p s → l = l' :=
  by sorry

This theorem states that for any type `α` and index type `ι`, if two filters `l` and `l'` over `α` both have the same basis, where the basis is a family of sets indexed by `ι` and characterized by a certain property `p`, then the two filters `l` and `l'` must be equal. In other words, if two filters have the same basis, they are the same filter.

If two filters over a type `α` have the same basis, characterized by property `p`, then they are equal.


theorem inv_eq_one : ∀ {α : Type u_1} [inst : DivisionMonoid α] {a : α}, a⁻¹ = 1 ↔ a = 1 := by sorry

This theorem, named `inv_eq_one`, states that for any type `α` that has a division monoid structure, an element `a` of this type has the property that its inverse `a⁻¹` equals `1` if and only if `a` itself equals `1`. In other words, in a division monoid, only the element `1` has `1` as its inverse.

In a division monoid, an element has an inverse equal to 1 if and only if it is the identity element 1.


theorem Finset.mem_mk :
    ∀ {α : Type u_1} {a : α} {s : Multiset α} {nd : Multiset.Nodup s}, a ∈ { val := s, nodup := nd } ↔ a ∈ s := by sorry

The theorem `Finset.mem_mk` states that for all types `α`, elements `a` of type `α`, and multiset `s` of type `α` with property `Multiset.Nodup s` (i.e., `s` has no duplicate entries), the membership of `a` in the `Finset` constructed from `s` (denoted `{ val := s, nodup := nd }`) is equivalent to the membership of `a` in `s`. In other words, an element is a member of a `Finset` if and only if it is a member of the underlying multiset from which the `Finset` was created.

For any type `α`, multiset `s` of `α` with no duplicates, and element `a` of `α`, `a` is in the `Finset` constructed from `s` if and only if `a` is in `s`.


/-- `affineSpan` is monotone.  -/
theorem affineSpan_mono :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s₁ s₂ : Set P}, s₁ ⊆ s₂ → affineSpan k s₁ ≤ affineSpan k s₂ :=
  by sorry

The theorem `affineSpan_mono` states that the operation `affineSpan` is monotone. In more concrete terms, if we have a ring `k` and `V` is an additive commutative group, `P` is a set such that `V` acts on `P` by translations (i.e., `V` and `P` form an affine space over `k`), then for any two sets of points `s₁` and `s₂` in `P`, if `s₁` is a subset of `s₂` then the affine span of `s₁` (the smallest affine subspace containing `s₁`) is a subspace of or equal to the affine span of `s₂` (the smallest affine subspace containing `s₂`).

If `s₁` is a subset of `s₂` in an affine space `P` over a ring `k`, then the affine span of `s₁` is contained in the affine span of `s₂`.


theorem Computation.destruct_eq_pure :
    ∀ {α : Type u} {s : Computation α} {a : α}, Computation.destruct s = Sum.inl a → s = Computation.pure a := by sorry

The theorem `Computation.destruct_eq_pure` states that for any type `α`, computation `s` of type `α`, and element `a` of type `α`, if the destructor of `s` (`Computation.destruct s`) results in the left outcome (`Sum.inl a`) of a sum type, then the computation `s` is identical to the computation that immediately terminates with result `a` (i.e., `s` is equal to `Computation.pure a`). Essentially, if a computation can be destructed to a pure result `a`, then the computation must have been the computation yielding `a` in the first place.

If `s` is a computation of type `α`, `a` is an element of type `α`, and `Computation.destruct s` equals `Sum.inl a`, then `s` equals `Computation.pure a`.


theorem MeasureTheory.SimpleFunc.coe_smul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {K : Type u_5} [inst_1 : SMul K β] (c : K)
      (f : MeasureTheory.SimpleFunc α β), ↑(c • f) = c • ↑f :=
  by sorry

This theorem states that for any measurable space `α`, any types `β` and `K`, and given that `K` is a scalar multiplication type over `β`, if we have a scalar `c` of type `K` and a simple function `f` from `α` to `β` under the measure theory context, then the coercion of the scalar multiplication of `c` and `f` (i.e., `c • f`) is equal to the scalar multiplication of `c` and the coercion of `f` (i.e., `c • ↑f`). This theorem ensures the compatibility of scalar multiplication with the coercion operation in the context of simple functions in measure theory.

For any measurable space, scalar multiplication type `K` over type `β`, scalar `c` in `K`, and simple function `f` from `α` to `β`, `c • f` equals `c • ↑f` in the context of measure theory.


/-- If all elements of a `Finset` fail to satisfy the predicate `p`, `s.filter p` is `∅`.  -/
theorem Finset.filter_false_of_mem :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α}, (∀ x ∈ s, ¬p x) → Finset.filter p s = ∅ :=
  by sorry

This theorem states that if all elements of a finite set `s` of type `α` fail to satisfy a certain predicate `p`, then the result of filtering `s` with `p` produces an empty set. Here, `p` is a decidable predicate, which means that for any element of `s`, it is decidable whether this element satisfies `p` or not. In other words, if no element of a finite set meets the condition specified by the predicate, filtering the set based on this condition results in an empty set.

If `s` is a finite set of type `α` and `p` is a decidable predicate such that no element of `s` satisfies `p`, then `Filter.filter p s` equals the empty set.


theorem Matrix.vecMul_transpose :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalCommSemiring α] [inst_1 : Fintype n]
      (A : Matrix m n α) (x : n → α), Matrix.vecMul x (Matrix.transpose A) = Matrix.mulVec A x :=
  by sorry

The theorem `Matrix.vecMul_transpose` states that for any matrix `A` of type `α`, indexed by `m` for rows and `n` for columns, and a given vector `x` also of type `α`, the vector-matrix multiplication of `x` with the transpose of `A` is the same as the matrix-vector multiplication of `A` with `x`. Here, `α` is any type for which a non-unital commutative semiring structure exists, and `n` is assumed to be a finite type. In mathematical terms, if `A` is a matrix and `x` is a vector, then the operation `x * Transpose(A)` is equivalent to `A * x`.

For any matrix A of type α with dimensions m × n and vector x of type α, the transpose of A multiplied with x is equal to the matrix-vector product of A and x.


theorem Mathlib.Algebra.Order.Pointwise._auxLemma.1 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Pointwise._auxLemma.1`, is a statement about scalar multiplication of sets in the context of algebra. It states that for all types `α` and `β`, provided `α` has an operation of scalar multiplication (`SMul`) to `β`, and given a set `t` of elements of type `β`, a scalar `a` of type `α`, and an element `x` of type `β`, then `x` belongs to the scalar multiplication of `a` and `t` if and only if there exists an element `y` in the set `t` such that `x` equals the scalar multiplication of `a` and `y`.

In mathematical terms, this theorem asserts that $x \in a \cdot t$ if and only if there exists a $y \in t$ such that $x = a \cdot y$, where $a \cdot t$ denotes the set obtained by scalar multiplication of each element of $t$ by $a$, and $a \cdot y$ represents the multiplication of $a$ and $y$.

For any type `α` with scalar multiplication `SMul` to `β`, and set `t` of elements in `β`, an element `x` belongs to the scalar multiplication of `a` and `t` if and only if there exists an element `y` in `t` such that `x = a * y`.


Continuous.inv

theorem Continuous.inv :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Inv G] [inst_2 : ContinuousInv G]
      [inst_3 : TopologicalSpace α] {f : α → G}, Continuous f → Continuous fun x => (f x)⁻¹ :=
  by sorry

This theorem states that for any two types `G` and `α`, where `G` is a topological space that supports inversion operation (`Inv`) and it's continuous (`ContinuousInv`), and `α` is another topological space, if a function `f` from `α` to `G` is continuous (`Continuous f`), then the function that applies the inversion to each output of `f` is also continuous. In mathematical terms, if `f` is a continuous function mapping from a topological space `α` to a topological space `G` that supports a continuous inversion operation, then the function `g` defined by `g(x) = (f(x))⁻¹` for all `x` in `α` is also continuous.

If `f` is a continuous function from a topological space `α` to a topological space `G` with a continuous inversion operation, then the function `g(x) = (f(x))⁻¹` is also continuous.


theorem Int.neg_lt_neg : ∀ {a b : ℤ}, a < b → -b < -a := by sorry

This theorem states that for any two integers `a` and `b`, if `a` is less than `b`, then the negation of `b` is less than the negation of `a`. That is, flipping the signs of two integers reverses their order.

If `a` < `b`, then `-b` < `-a`. (Negating the two integers reverses their order.)


theorem invOf_mul_self' : ∀ {α : Type u} [inst : Mul α] [inst_1 : One α] (a : α) {x : Invertible a}, ⅟a * a = 1 := by
  sorry

This theorem states that for any type `α` that supports multiplication and a multiplicative identity (`One`), for any element `a` of such type that is invertible, the product of the inverse of `a` and `a` itself is equal to the multiplicative identity `1`. This is essentially the definition of an inverse element in a multiplicative group, expressed in Lean 4 code.

For any type `α` with multiplication and multiplicative identity `One`, and for any invertible element `a` of `α`, `a * a⁻¹ = One`.


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

The theorem `mem_affineSpan` states that for any point `p` within a set `s` of type `P`, and given the conditions that `k` is a Ring, `V` is an Additive Commutative Group, `V` is a Module over `k`, and `P` is an Additive Torsor over `V`, the point `p` also belongs to the affine span of the set `s`. In other terms, any point in a set is also in the smallest affine subspace (affine span) that contains all points of that set.

Given a set `s` of points in an Additive Torsor `P` over a Ring `k`, such that `P` is an Additive Commutative Group and a Module over `k`, every point `p` in `s` lies in the affine span of `s`.


theorem Continuous.const_vadd :
    ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : VAdd M α]
      [inst_2 : ContinuousConstVAdd M α] [inst_3 : TopologicalSpace β] {g : β → α},
      Continuous g → ∀ (c : M), Continuous fun x => c +ᵥ g x :=
  by sorry

This theorem states that for any types `M`, `α`, and `β`, if `α` has a topological space structure, `M` and `α` have a vector addition structure, and the vector addition of a constant from `M` and a variable from `α` is a continuous function, then for any continuous function `g` from `β` to `α`, and any constant `c` from `M`, the function that adds `c` to the value of `g` at each point in `β` (denoted as `fun x => c +ᵥ g x`) is also a continuous function.

In mathematical terms, if adding a constant vector to a variable vector in `α` is a continuous operation and `g` is a continuous function, then the function resulting from adding a constant vector `c` to the image of `g` is also continuous.

If `α` is a topological space, `M` is a vector space over `α`, and the vector addition of a constant from `M` and a variable from `α` is a continuous function, then the function that adds a constant vector from `M` to the image of a continuous function `g` from `β` to `α` is also continuous.


theorem Equiv.Perm.inv_eq_iff_eq : ∀ {α : Type u} {f : Equiv.Perm α} {x y : α}, f⁻¹ x = y ↔ x = f y := by sorry

This theorem states that for any given type `α`, for a permutation `f` of that type, and for any two elements `x` and `y` of that type, the image of `x` under the inverse of `f` being equal to `y` is equivalent to `x` being equal to the image of `y` under `f`. In other words, applying a permutation to an element and then applying the inverse permutation to the result returns the original element.

For any permutation `f` of type `α` and elements `x, y : α`, `x = f⁻¹(y)` is equivalent to `y = f(x)`.


theorem Set.finite_image_iff :
    ∀ {α : Type u} {β : Type v} {s : Set α} {f : α → β}, Set.InjOn f s → (Set.Finite (f '' s) ↔ Set.Finite s) := by
  sorry

The theorem `Set.finite_image_iff` states that for all types `α` and `β`, for all sets `s` of type `α`, and for all functions `f` from `α` to `β`, if `f` is injective on `s`, then the image of `s` under `f` is finite if and only if `s` is finite. In other words, an injective function preserves the finiteness of a set through its image.

An injective function maps a finite set to a finite image.


theorem UniqueFactorizationMonoid.prime_of_normalized_factor :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a : α}, ∀ x ∈ UniqueFactorizationMonoid.normalizedFactors a, Prime x :=
  by sorry

This theorem states that in any Unique Factorization Monoid which is also a Cancel Commutative Monoid With Zero and a Normalization Monoid, for any element 'a' of that monoid, any element 'x' that is a member of the multiset of normalized factors of 'a', is a prime element. A prime element is defined as an element that is not zero, is not a unit, and has the property that if it divides the product of two other elements, it must divide at least one of those elements.

In a Unique Factorization, Cancel Commutative Monoid with Zero and Normalization property, every normalized factor of any element is a prime.


theorem Finset.image_insert :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] (f : α → β) (a : α) (s : Finset α),
      Finset.image f (insert a s) = insert (f a) (Finset.image f s) :=
  by sorry

The theorem `Finset.image_insert` states that for any types `α` and `β`, given a function `f` from `α` to `β`, an element `a` of type `α`, and a finite set `s` of type `α`, the image of the function `f` applied to the set resulting from inserting `a` into `s` is equal to inserting the image of `a` under `f` into the image of `s` under `f`. In other words, we can either insert an element into a set and then take the image under a function, or we can take the image of the set and the element separately and then insert. This holds if the equality on `α` and `β` is decidable.

For any decidably-equaled types `α` and `β`, given a function `f : α -> β` and a finite set `s : Finset α`, the application of `f` to the set `insert a s` is equal to the set `insert (f a) (map f s)`.


theorem CategoryTheory.Preadditive.comp_zsmul :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      (f : P ⟶ Q) (g : Q ⟶ R) (n : ℤ),
      CategoryTheory.CategoryStruct.comp f (n • g) = n • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

This theorem, `CategoryTheory.Preadditive.comp_zsmul`, states that for any category `C` that is preadditive (meaning it has a binary operation compatible with the category structure), given three objects `P`, `Q`, and `R` in `C` and two morphisms `f : P ⟶ Q` and `g : Q ⟶ R`, and an integer `n`, the composition of `f` with the `n`-fold scalar multiplication of `g` is the same as the `n`-fold scalar multiplication of the composition of `f` and `g`. In simpler terms, it says that scalar multiplication commutes with morphism composition in a preadditive category.

In a preadditive category, for any object $P, Q, R$ and morphisms $f: P \to Q$ and $g: Q \to R$, the scalar multiplication of $g$ by an integer $n$ and the composition of $f$ and $g$ are equal to the composition of $f$ and the scalar multiplication of $g$ by $n$.


theorem Nat.floor_of_nonpos :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α}, a ≤ 0 → ⌊a⌋₊ = 0 := by sorry

This theorem states that for any type `α` that has a `LinearOrderedSemiring` and `FloorSemiring` structure, if a variable `a` of type `α` is less than or equal to zero, then the floor of `a` in the context of natural numbers (denoted by `⌊a⌋₊`) is equal to zero. In mathematical terms, this means that for any real number `a` less than or equal to zero, when you round `a` down to the nearest whole number, the result is zero.

For any type `α` with `LinearOrderedSemiring` and `FloorSemiring` structures, if `α` has a negative or zero element, then `⌊x⌋₊ = 0` for all `x : α` in that type.


theorem Submodule.map_id :
    ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), Submodule.map LinearMap.id p = p :=
  by sorry

The theorem `Submodule.map_id` states that for any ring `R` and an `R`-module `M`, with `R` being a semiring and `M` being an additive commutative monoid, the identity map when applied to any submodule `p` of `M`, leaves `p` unchanged. In other words, mapping a submodule `p` of `M` under the identity linear map results in the same submodule `p`. This is similar to the concept in mathematics where applying the identity function to any element of a set leaves the element unchanged.

For any ring `R`, `R`-module `M`, and submodule `p` of `M`, the identity map leaves `p` invariant.


theorem Bool.not_eq_true' : ∀ (b : Bool), ((!b) = true) = (b = false) := by sorry

This theorem states that for any boolean value `b`, the negation of `b` being true is equivalent to `b` being false. In other words, if not `b` equals true, then `b` must be false and vice versa. This is a basic property of boolean logic.

The negation of a boolean value is logically equivalent to its negation. In other words, `not b` is equivalent to `b -> false`.


/-- The Hausdorff distances from `s` to `t` and from `t` to `s` coincide.  -/
theorem Metric.hausdorffDist_comm :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α}, Metric.hausdorffDist s t = Metric.hausdorffDist t s := by
  sorry

The theorem `Metric.hausdorffDist_comm` states that for any type `α` that has a `PseudoMetricSpace` structure, and any two sets `s` and `t` of this type, the Hausdorff distance from `s` to `t` is equal to the Hausdorff distance from `t` to `s`. In other words, the Hausdorff distance between two sets is commutative in a pseudo metric space.

In a pseudo-metric space, the Hausdorff distance between sets is commutative.


theorem Ordinal.nadd_zero : ∀ (a : Ordinal.{u}), Ordinal.nadd a 0 = a := by sorry

The theorem `Ordinal.nadd_zero` states that for any ordinal number `a`, the natural addition (also known as the Hessenberg sum) of `a` and zero is `a`. This means when you add zero, using the natural addition operation defined for ordinal numbers, to any ordinal number, the result will be the original ordinal number.

For any ordinal number `a`, `a + 0 = a`.


theorem map_add_eq_zero :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : FunLike F M N] [inst_3 : AddMonoidHomClass F M N] (f : F) {a b : M}, a + b = 0 → f a + f b = 0 :=
  by sorry

The theorem `map_add_eq_zero` says that for any types `M`, `N`, and `F`, given that `M` and `N` are both `AddZeroClass` (i.e., they have addition and a zero element), `F` is a function type from `M` to `N` (`FunLike F M N`), and `F` is also an additive monoid homomorphism (`AddMonoidHomClass F M N`), then for any function `f : F` and any elements `a` and `b` of type `M`, if the sum of `a` and `b` equals zero (`a + b = 0`), then the sum of the images of `a` and `b` under `f` also equals zero (`f a + f b = 0`). Essentially, this theorem states that the zero sum property is preserved under the function `f`.

Given `AddZeroClass` types `M` and `N`, a function `F : M -> N` being an additive monoid homomorphism implies that `f (a + b) = f a + f b` for all `a, b : M` with `a + b = 0`.


theorem continuous_real_toNNReal : Continuous Real.toNNReal := by sorry

The theorem `continuous_real_toNNReal` states that the function `Real.toNNReal`, which reinterprets a real number as a non-negative real number (returning `0` if the real number is less than `0`), is continuous. In other words, for any sequence of real numbers that converges to a limit, the sequence of their non-negative reinterpretations also converges to the non-negative reinterpretation of the limit.

The function `Real.toNNReal : Real → ℝ⁺` is continuous, where `ℝ⁺` denotes the set of non-negative real numbers. That is, for any real number sequence `(x_n)` that converges to a limit `x`, `(Real.toNNReal x_n)` converges to `Real.toNNReal x`.


theorem pos_of_mul_pos_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : MulPosReflectLT α],
      0 < a * b → 0 ≤ b → 0 < a :=
  by sorry

The theorem `pos_of_mul_pos_left` states that for any type `α` that has multiplication and zero, and is equipped with a preorder relation (`≤`) which reflects strict reverse monotonicity of multiplication by nonnegative elements on the right, if the product of two elements `a` and `b` in `α` is positive (i.e., `0 < a * b`), and `b` is nonnegative (i.e., `0 ≤ b`), then `a` must be positive (i.e., `0 < a`). In other words, if a non-negative number times another number gives a positive result, then the other number is positive. This is an important property related to the order of multiplication in ordered semirings.

If `0 < a * b` and `0 <= b` in an ordered semiring, then `0 < a`.


theorem MvPolynomial.monomial_eq :
    ∀ {R : Type u} {σ : Type u_1} {a : R} {s : σ →₀ ℕ} [inst : CommSemiring R],
      (MvPolynomial.monomial s) a = MvPolynomial.C a * Finsupp.prod s fun n e => MvPolynomial.X n ^ e :=
  by sorry

The theorem `MvPolynomial.monomial_eq` states that for any commutative semiring `R`, any coefficient `a` of type `R`, and any function `s` from some type `σ` to natural numbers (representing the exponents of the monomial), the monomial with coefficient `a` and exponents given by `s` is equal to the constant polynomial with value `a` times the product of the degree `1` monomial raised to its corresponding exponent for each element in the support of `s`. In other words, it describes constructing a multivariate polynomial by multiplying the coefficient with each variable (with appropriate exponent).

For any commutative semiring `R`, coefficient `a` of type `R`, and function `s` from some type `σ` to natural numbers, the monomial with coefficient `a` and exponents given by `s` equals the constant polynomial with value `a` times the product of degree `1` monomials, each raised to the corresponding exponent in `s`.


theorem CategoryTheory.Sieve.le_generate :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (R : CategoryTheory.Presieve X),
      R ≤ (CategoryTheory.Sieve.generate R).arrows :=
  by sorry

The theorem `CategoryTheory.Sieve.le_generate` states that for any category `C` and an object `X` in `C`, any presieve `R` on `X` is less than or equal to the set of arrows in the sieve generated by `R`. In other words, all arrows in the presieve `R` are also contained in the generated sieve. This means that generating a sieve from a presieve `R` does not lose any arrows that were originally in `R`.

For any category C and object X, every presieve R on X is contained in the sieve generated by R.


Multiset.ext'

theorem Multiset.ext' :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α},
      (∀ (a : α), Multiset.count a s = Multiset.count a t) → s = t :=
  by sorry

The theorem states that for any type 'α' with decidable equality and any two multisets 's' and 't' of this type, if the count of each element 'a' of type 'α' is the same in both 's' and 't', then 's' and 't' are equal. In simpler terms, two multisets are identical if they have the same counts for each element.

If two multisets of a type with decidable equality have equal counts for each element, then they are equal.


theorem Submodule.mem_annihilator :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {N : Submodule R M} {r : R}, r ∈ Submodule.annihilator N ↔ ∀ n ∈ N, r • n = 0 :=
  by sorry

This theorem states that for any type `R` and `M`, where `R` is a commutative semiring and `M` is an additive commutative monoid and also a module over `R`, for any submodule `N` of `M` and any element `r` of `R`, `r` belongs to the annihilator of `N` if and only if the action of `r` (denoted by `r • n`) on any element `n` of `N` results in the zero element of the module `M`. In mathematical terms, this is saying that an element `r` is in the annihilator of a submodule `N` precisely when `r` multiplies any element of `N` to zero.

An element `r` of a commutative semiring `R` belongs to the annihilator of a submodule `N` of an additive commutative `R`-module `M` if and only if `r • n = 0` for all `n` in `N`.


theorem Set.prod_inter_prod :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β}, s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by
  sorry

This theorem states that for any types `α` and `β`, and any sets `s₁`, `s₂` of type `α` and `t₁`, `t₂` of type `β`, the intersection of the Cartesian product of `s₁` and `t₁` with the Cartesian product of `s₂` and `t₂` is equal to the Cartesian product of the intersection of `s₁` and `s₂` with the intersection of `t₁` and `t₂`. In mathematical terms, this can be written as $(s₁ \times t₁) \cap (s₂ \times t₂) = (s₁ \cap s₂) \times (t₁ \cap t₂)$.

The intersection of two Cartesian products of sets is equal to the Cartesian product of their intersections: $(s\_1 \times t\_1) \cap (s\_2 \times t\_2) = (s\_1 \cap s\_2) \times (t\_1 \cap t\_2)$.


theorem AddSubmonoid.mem_closure :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M} {x : M},
      x ∈ AddSubmonoid.closure s ↔ ∀ (S : AddSubmonoid M), s ⊆ ↑S → x ∈ S :=
  by sorry

This theorem states that for any type `M` that is an instance of `AddZeroClass` (which means `M` is a set with addition and zero), any set `s` of elements of `M`, and any element `x` of `M`, `x` is an element of the additive submonoid generated by `s` if and only if for all additive submonoids `S` of `M` such that `s` is a subset of `S`, `x` is also an element of `S`. This is essentially describing the closure property of a submonoid: an element is in the closure of a set if it is in every submonoid that contains the set.

For any set `s` of elements from an additive semigroup `M` with zero `0`, an element `x` belongs to the additive submonoid generated by `s` if and only if `x` is in every submonoid containing `s`.


theorem Multiset.count_eq_zero_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∉ s → Multiset.count a s = 0 := by sorry

The theorem `Multiset.count_eq_zero_of_not_mem` states that for any type `α` with decidable equality, an element `a` of type `α`, and a multiset `s` of elements of type `α`, if `a` is not a member of the multiset `s`, then the count of `a` in `s` is zero. In other words, if an element is not in a multiset, then its multiplicity or count in that multiset is zero.

If `a` is not an element of multiset `s` over type `α` with decidable equality, then the count of `a` in `s` is zero.


theorem Nat.count_succ :
    ∀ (p : ℕ → Prop) [inst : DecidablePred p] (n : ℕ), Nat.count p (n + 1) = Nat.count p n + if p n then 1 else 0 := by
  sorry

This theorem, `Nat.count_succ`, states that for any natural number `n` and any decidable predicate `p` (a function from natural numbers to propositions that we can decide whether it's true or false), the count of natural numbers less than `n + 1` that satisfy the predicate `p` is equal to the count of natural numbers less than `n` that satisfy `p`, plus 1 if `n` itself satisfies `p`, and plus 0 otherwise. Essentially, it is considering whether the next number, `n`, should be included in the count based on if it satisfies the predicate `p`.

The number of natural numbers less than `n + 1` satisfying a decidable predicate `p` is equal to the count of those less than `n` satisfying `p` plus 1 if `n` satisfies `p`, or equal to the count of those less than `n` satisfying `p` otherwise.


theorem Real.Angle.toReal_zero : Real.Angle.toReal 0 = 0 := by sorry

This theorem states that when the function `Real.Angle.toReal` is applied to zero, it returns zero. In other words, the image of zero under the conversion from a real angle to a real number in the interval `(-π, π)` is zero itself.

The theorem asserts that `Real.Angle.toReal` applied to zero angle equals zero in the real numbers.


/-- If `{s i | p i}` is a basis of a filter `l` and `V ∈ l`, then `{s i | p i ∧ s i ⊆ V}`
is a basis of `l`.  -/
theorem Filter.HasBasis.restrict_subset :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → ∀ {V : Set α}, V ∈ l → Filter.HasBasis l (fun i => p i ∧ s i ⊆ V) s :=
  by sorry

The theorem `Filter.HasBasis.restrict_subset` states that for any type `α`, index type `ι`, filter `l` on `α`, predicate `p` on `ι`, and function `s` from `ι` to set of `α`, if `{s i | p i}` forms a basis of the filter `l` and a set `V` is in the filter `l`, then the collection `{s i | p i ∧ s i is a subset of V}` also forms a basis of the filter `l`. Essentially, we can restrict the basis of the filter to the subsets of `V` that also satisfy the predicate `p`.

If a collection of subsets of a filter forms a basis and is contained in a given set, then the restriction of that collection to the subsets in the set also forms a basis for the filter.


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

This theorem states that for any three integers `a`, `b`, and `c`, the remainder of the division of `(a + b * c)` by `b` is equal to the remainder of the division of `a` by `b`. In other words, adding `b * c` to `a` does not change the remainder of `a` when divided by `b`. This can be expressed mathematically as `(a + b * c) mod b = a mod b`.

The theorem asserts that for any integers `a`, `b`, and `c`, `(a + b * c) % b = a % b`, where "%" denotes remainder.


theorem GaloisInsertion.l_surjective :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : PartialOrder β],
      GaloisInsertion l u → Function.Surjective l :=
  by sorry

The theorem `GaloisInsertion.l_surjective` states that for any types `α` and `β` with a function `l : α → β` and `u : β → α`, where `α` is a preorder and `β` is a partial order, if `l` and `u` form a Galois insertion, then the function `l` is surjective. In mathematical terms, this means that for every element `b` in `β`, there exists an element `a` in `α` such that `l(a) = b`.

If `l : α -> β` and `u : β -> α` form a Galois insertion between preordered type `α` and partially ordered type `β`, then `l` is surjective.


theorem ENNReal.rpow_lt_top_of_nonneg : ∀ {x : ENNReal} {y : ℝ}, 0 ≤ y → x ≠ ⊤ → x ^ y < ⊤ := by sorry

This theorem states that for any extended nonnegative real number `x` and any real number `y`, if `y` is greater than or equal to zero and `x` is not equal to positive infinity, then `x` raised to the power `y` is less than positive infinity. In mathematical notation, if $x \in [0, \infty)$, $y \in \mathbb{R}$, $y \geq 0$ and $x \neq \infty$, then $x^y < \infty$. The importance of this theorem is in the context of measure theory, where measures take values in the extended nonnegative real numbers.

For any extended nonnegative real number $x$ not equal to positive infinity and any non-negative real number $y$, $x^y$ is finite.


theorem Multiset.le_iff_count :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α},
      s ≤ t ↔ ∀ (a : α), Multiset.count a s ≤ Multiset.count a t :=
  by sorry

This theorem establishes a condition for determining the partial order (`≤`) between two multisets `s` and `t` of type `α`. Here, `α` is any type for which equality is decidable. The theorem asserts that `s` is less than or equal to `t` if and only if for every element `a` of type `α`, the multiplicity of `a` in `s` (i.e., the number of times `a` appears in `s`) is less than or equal to the multiplicity of `a` in `t`. In other words, `s` is a sub-multiset of `t` if every element in `s` occurs in `t` at least as many times as in `s`.

For any type `α` where equality is decidable, two multisets `s` and `t` of type `α` satisfy `s ≤ t` if and only if for all `a` in `α`, the multiplicity of `a` in `s` is less than or equal to the multiplicity of `a` in `t`.


theorem Nat.sub_ne_zero_of_lt : ∀ {a b : ℕ}, a < b → b - a ≠ 0 := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then the result of subtracting `a` from `b` cannot be zero. This means there is no circumstance where a smaller number can be subtracted from a larger number to result in zero in the domain of natural numbers.

For all natural numbers `a` and `b`, if `a < b`, then `b - a` is a positive natural number.


theorem Set.image_preimage :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, GaloisConnection (Set.image f) (Set.preimage f) := by sorry

The theorem `Set.image_preimage` states that for any types `α` and `β` and any function `f` from `α` to `β`, there exists a Galois Connection between the function `Set.image f` and the function `Set.preimage f`. A Galois Connection is a pair of functions `l` and `u` such that for all `a` in `α` and `b` in `β`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`. In the context of this theorem, `Set.image f` is a function that maps a set of elements in `α` to its image in `β` under `f`, and `Set.preimage f` is a function that maps a set in `β` to its preimage in `α` under `f`.

For any function `f` from type `α` to type `β`, there exists a Galois Connection between the image function `Set.image f` and the preimage function `Set.preimage f`.


/-- One direction of `div_le_iff` where `b` is allowed to be `0` (but `c` must be nonnegative)  -/
theorem div_le_of_nonneg_of_le_mul :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 ≤ b → 0 ≤ c → a ≤ c * b → a / b ≤ c := by sorry

This theorem, `div_le_of_nonneg_of_le_mul`, states that for any type `α` that is a linear ordered semifield and given any three elements `a`, `b`, and `c` of this type, if both `b` and `c` are nonnegative (greater than or equal to zero) and if `a` is less than or equal to the product of `c` and `b`, then the division of `a` by `b` is less than or equal to `c`. In simple terms, if you divide `a` by `b` in a context where `b` and `c` are nonnegative and `a` is not more than `b` times `c`, you will get a result that is not more than `c`.

If `α` is a linear ordered semifield, `a`, `b`, `c` ∈ `α` with `b`, `c` nonnegative, and `a` ≤ `c` × `b`, then `a / b` ≤ `c`.


HasFDerivAt.comp

/-- The chain rule.  -/
theorem HasFDerivAt.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {f' : E →L[𝕜] F} (x : E)
      {g : F → G} {g' : F →L[𝕜] G},
      HasFDerivAt g g' (f x) → HasFDerivAt f f' x → HasFDerivAt (g ∘ f) (ContinuousLinearMap.comp g' f') x :=
  by sorry

This theorem is a formalization of the chain rule in calculus. It states that if a function `f` from `E` to `F` has a derivative `f'` at a point `x` in `E`, and a function `g` from `F` to `G` has a derivative `g'` at the point `f x` in `F`, then the composition function `(g ∘ f)` has a derivative `(ContinuousLinearMap.comp g' f')` at `x`. Here, `𝕜`, `E`, `F`, and `G` are normed spaces over a nontrivially normed field, which is a field equipped with a norm that satisfies certain properties. The derivative is a continuous linear map, which is a linear map between normed spaces that is also continuous.

If `f: E → F` and `g: F → G` are continuously differentiable functions between normed spaces, then `(g ∘ f)` is continuously differentiable and `(g ∘ f)'.x = g'.(f x) ∘ f'.x` for all `x ∈ E`.


theorem Set.diff_subset_diff_left : ∀ {α : Type u} {s₁ s₂ t : Set α}, s₁ ⊆ s₂ → s₁ \ t ⊆ s₂ \ t := by sorry

This theorem, `Set.diff_subset_diff_left`, states that for any type `α`, and for any sets `s₁`, `s₂`, and `t` of type `α`, if `s₁` is a subset of `s₂`, then the difference of `s₁` and `t` is also a subset of the difference of `s₂` and `t`. In other words, if every element of `s₁` is also an element of `s₂`, then every element that is in `s₁` but not in `t` is also in `s₂` but not in `t`. This is a property of set difference in the context of subset relationships.

If `s₁ ⊆ s₂`, then `(s₁ \ t) ⊆ (s₂ \ t)`. (In set theory notation, the symbol `\` represents set difference.)


theorem List.mem_singleton : ∀ {α : Type u_1} {a b : α}, a ∈ [b] ↔ a = b := by sorry

This theorem, `List.mem_singleton`, states that for any type `α` and any two elements `a` and `b` of type `α`, `a` is an element of the list containing only `b` if and only if `a` is equal to `b`. In other words, an element is a member of a singleton list if and only if it is equal to the single item in that list.

For any type α and any elements a, b of α, the list [b] contains a if and only if a = b.


theorem map_mul_eq_one :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : MulOneClass M] [inst_1 : MulOneClass N]
      [inst_2 : FunLike F M N] [inst_3 : MonoidHomClass F M N] (f : F) {a b : M}, a * b = 1 → f a * f b = 1 :=
  by sorry

The theorem `map_mul_eq_one` states that for any types `M`, `N`, and `F`, such that `M` and `N` are both mul-one classes (i.e., they are equipped with multiplication and have a specified "one" element), `F` is a class of functions from `M` to `N` (i.e., is `FunLike`), and `F` is a monoid homomorphism class from `M` to `N`, then for any function `f` of type `F` and any elements `a` and `b` of `M`, if the product of `a` and `b` equals `1`, then the product of `f(a)` and `f(b)` also equals `1`. In mathematical terms, this theorem states that a monoid homomorphism preserves the identity element under multiplication.

A monoid homomorphism preserves the identity element under multiplication, i.e., for any monoids (M, ¹M) and (N, ¹N), and a monoid homomorphism f : M -> N, if a * b = ¹M, then f(a) * f(b) = ¹N.


theorem MeasureTheory.measure_inter_add_diff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {t : Set α} (s : Set α),
      MeasurableSet t → ↑↑μ (s ∩ t) + ↑↑μ (s \ t) = ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.measure_inter_add_diff` states that for any type `α`, any measurable space `m` over `α`, any measure `μ` in the measurable space, and any two sets `s` and `t` of type `α`, if `t` is a measurable set, then the measure of the intersection of `s` and `t` plus the measure of the difference of `s` and `t` is equal to the measure of `s`. In mathematical terms, it's saying that for all sets `s` and `t`, if `t` is measurable, then `μ(s ∩ t) + μ(s \ t) = μ(s)`. This is a fundamental property of measures, expressing that the measure of a set is completely determined by the measures of its measurable parts.

For any measurable space and measure, the measure of a set is equal to the measure of its intersection with a measurable set plus the measure of their difference.


theorem Option.isSome_iff_exists : ∀ {α : Type u_1} {x : Option α}, Option.isSome x = true ↔ ∃ a, x = some a := by sorry

This theorem `Option.isSome_iff_exists` states that for all types `α` and all options `x` of type `α`, the function `Option.isSome` applied to `x` equals `true` if and only if there exists some `a` such that `x` equals `some a`. In other words, an option `x` contains some value if and only if there exists a value such that `x` is the option of that value.

For any type `α` and option `x` of type `option α`, `Option.isSome x` holds if and only if there exists an `a` such that `x = some a`.


theorem MeasureTheory.SimpleFunc.measurableSet_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (s : Set β),
      MeasurableSet (↑f ⁻¹' s) :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.measurableSet_preimage` states that for any types `α` and `β`, given a measurable space structure on `α`, a simple function `f` from `α` to `β`, and a set `s` of type `β`, the preimage of the set `s` under the function `f` is a measurable set.

In other words, if we apply the function `f` to some elements of `α` and consider the set of all such elements that map into `s`, that set of elements from `α` is measurable. This is a fundamental property in measure theory, which ensures that we can measure the "size" of the set of all elements that get mapped into a particular subset of the range of a simple function.

If `α` is a measurable space, `f` is a simple function from `α` to `β`, and `s` is a set in `β`, then the preimage `f⁻¹(s)` is a measurable set in `α`.


theorem div_le_div'' :
    ∀ {α : Type u} [inst : CommGroup α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a ≤ b → c ≤ d → a / d ≤ b / c :=
  by sorry

This theorem, `div_le_div''`, states that for any type `α` that has a commutative group structure and an preorder relation, and for any `α`'s `a`, `b`, `c`, and `d`, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the quotient of `a` and `d` is less than or equal to the quotient of `b` and `c`. Here, the preorder and commutative group structures of `α` are essential to make the division and comparison operations well-defined and meaningful. The CovariantClass is a mathematical structure that ensures that certain properties hold when we multiply elements of `α`.

For any commutative group `α` with preorder relation, if `a ≤ b` and `c ≤ d` in `α`, then `a / d ≤ b / c`.


theorem Set.inter_union_distrib_left : ∀ {α : Type u} (s t u : Set α), s ∩ (t ∪ u) = s ∩ t ∪ s ∩ u := by sorry

The theorem `Set.inter_union_distrib_left` states that for any type `α` and for any three sets `s`, `t`, and `u` of type `α`, the intersection of `s` with the union of `t` and `u` is the same as the union of the intersection of `s` with `t` and the intersection of `s` with `u`. In mathematical notation, this can be written as $s \cap (t \cup u) = (s \cap t) \cup (s \cap u)$. This is a statement of the distributive property of intersection over union in set theory.

The theorem `Set.inter_union_distrib_left` asserts that for any sets `s`, `t`, and `u`, $s \cap (t \cup u) = (s \cap t) \cup (s \cap u)$.


theorem Finset.prod_attach :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] (s : Finset α) (f : α → β),
      (Finset.prod (Finset.attach s) fun x => f ↑x) = Finset.prod s fun x => f x :=
  by sorry

The theorem `Finset.prod_attach` states that for any finite set `s` of type `α` and any function `f` from `α` to `β` (where `β` is a commutative monoid), the product of `f x` as `x` ranges over the elements of the set `s` (denoted as `(Finset.prod s fun x => f x)`) is equal to the product of `f x` where `x` ranges over the elements of the set formed by attaching each element of `s` to its membership proof in `s` (denoted as `(Finset.prod (Finset.attach s) fun x => f ↑x)`). Here, `↑x` is a way to refer back to the original element from the subset. This theorem essentially states that "attaching" each element of a finite set to its membership proof does not change the product of the set under a given function.

For any finite set `s` and function `f` from `α` to a commutative monoid `β`, the product of `f x` over `x` in `s` is equal to the product of `f (mem_s x)` over `x` in the set formed by attaching membership proofs to elements of `s`.


theorem GaloisConnection.u_sInf :
    ∀ {α : Type u} {β : Type v} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {s : Set β}, u (sInf s) = ⨅ a ∈ s, u a :=
  by sorry

The theorem `GaloisConnection.u_sInf` states that for any types `α` and `β` which form complete lattices, and for any functions `l : α → β` and `u : β → α` that form a Galois connection, the function `u` applied to the infimum (`sInf`) of a set `s` of elements of type `β` is equal to the infimum of the function `u` applied to each element of the set `s`. In mathematical terms, this can be represented as \(u(\text{inf}(s)) = \text{inf}\{u(a) : a \in s\}\). This theorem captures one of the important properties of Galois connections in the context of complete lattices.

For any complete lattices α and β, and any Galois connection {l : α → β, u : β → α}, u(∧^β s) = ∧^α {u(a) | a ∈ s}, where ∧^β s is the infimum of set s in lattice β and ∧^α {u(a) | a ∈ s} is the infimum of the set {u(a) | a ∈ s} in lattice α.


theorem Submodule.mem_map :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} [inst_6 : RingHomSurjective σ₁₂] {F : Type u_9} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F σ₁₂ M M₂] {f : F} {p : Submodule R M} {x : M₂},
      x ∈ Submodule.map f p ↔ ∃ y ∈ p, f y = x :=
  by sorry

This theorem, `Submodule.mem_map`, asserts a property about mappings between submodules. Specifically, for all rings `R` and `R₂`, modules `M` and `M₂`, a semiring structure on `R` and `R₂`, an addition commutative monoid structure on `M` and `M₂`, a module structure over `R` on `M` and over `R₂` on `M₂`, a ring homomorphism `σ₁₂`, a function `f` of type `F` that behaves like a function from `M` to `M₂` (as defined by the `FunLike` class), and a semilinear map structure on `f` in accordance with `σ₁₂`, the theorem states that an element `x` in the module `M₂` is in the image of a submodule `p` under the map `f` if and only if there exists an element `y` in `p` such that `f y = x`. This defines the membership of the image of a submodule under a function in terms of preimages under that function.

For submodules `p` of modules `M` and `M₂`, a ring homomorphism `σ₁₂` between rings `R` and `R₂`, a semilinear map `f` from `M` to `M₂` in accordance with `σ₁₂`, and any `x` in `M₂`, `x` is in the image of `p` under `f` if and only if there exists `y` in `p` such that `f(y) = x`.


theorem Prod.swap_swap : ∀ {α : Type u_1} {β : Type u_2} (x : α × β), Prod.swap (Prod.swap x) = x := by sorry

This theorem, named `Prod.swap_swap`, states that for all types `α` and `β`, and for any pair `x` of type `α × β`, applying the `Prod.swap` function twice to `x` (i.e., swapping the elements of the pair twice) results in the original pair `x`. In other words, the double application of the `Prod.swap` function is an identity operation on the pair `x`.

For all types `α` and `β`, the repeated application of `Prod.swap` to a pair `x` of type `α × β` results in the original pair `x`: `Prod.swap (Prod.swap x) = x`.


theorem Real.sqrt_zero : Real.sqrt 0 = 0 := by sorry

This theorem states that the square root of zero in the set of real numbers is zero. In other words, when the `Real.sqrt` function is applied to 0, the output is also 0. This is in line with the mathematical property $\sqrt{0} = 0$.

The square root of 0 in the real numbers is 0. (i.e., √0 = 0)


theorem CategoryTheory.Limits.pullback.map.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z S T : C} (f₁ : W ⟶ S) (f₂ : X ⟶ S)
      [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂] (g₁ : Y ⟶ T) (g₂ : Z ⟶ T) (i₁ : W ⟶ Y) (i₂ : X ⟶ Z)
      (i₃ : S ⟶ T),
      CategoryTheory.CategoryStruct.comp f₁ i₃ = CategoryTheory.CategoryStruct.comp i₁ g₁ →
        CategoryTheory.CategoryStruct.comp f₂ i₃ = CategoryTheory.CategoryStruct.comp i₂ g₂ →
          CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst i₁)
              g₁ =
            CategoryTheory.CategoryStruct.comp
              (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd i₂) g₂ :=
  by sorry

This theorem is a statement about the behavior of pullbacks in a category under mapping. More specifically, given a category `C` and objects `W, X, Y, Z, S, T` in `C`. If `f₁: W ⟶ S`, `f₂: X ⟶ S` are morphisms with a pullback and `g₁: Y ⟶ T`, `g₂: Z ⟶ T` are other morphisms, then for any morphisms `i₁: W ⟶ Y`, `i₂: X ⟶ Z`, and `i₃: S ⟶ T` such that `f₁ ≫ i₃ = i₁ ≫ g₁` and `f₂ ≫ i₃ = i₂ ≫ g₂`, it follows that `(pullback.fst ≫ i₁) ≫ g₁ = (pullback.snd ≫ i₂) ≫ g₂`. This asserts a certain commutativity property in the category theory concept of pullbacks.

Given morphisms `f₁: W ⟶ S`, `f₂: X ⟶ S`, `g₁: Y ⟶ T`, `g₂: Z ⟶ T`, `i₁: W ⟶ Y`, `i₂: X ⟶ Z`, and `i₃: S ⟶ T` in a category `C` with pullbacks, if `f₁ ≫ i₃ = i₁ ≫ g₁` and `f₂ ≫ i₃ = i₂ ≫ g₂`, then the pullback of `i₁` along `g₁` is the same as the pullback of `i₂` along `g₂`. In other words, `(pullback.fst ≫ i₁) ≫ g₁ = (pullback.snd ≫ i₂) ≫ g₂`.


theorem Nat.prime_iff : ∀ {p : ℕ}, Nat.Prime p ↔ Prime p := by sorry

This theorem establishes an equivalence between the two definitions of primality for a natural number `p`: `Nat.Prime p` and `Prime p`. Specifically, it states that for any natural number `p`, `p` is a prime number according to the `Nat.Prime` definition if and only if `p` is a prime element according to the `Prime` definition in the context of a `CommMonoidWithZero`. In other words, a natural number `p` is prime (i.e., it is at least 2 and its only divisors are `p` and `1`) if and only if `p` is a non-zero, non-unit element of a `CommMonoidWithZero` that divides the product of any two elements `a` and `b` only if it divides `a` or `b`.

For any natural number `p`, `p` is a prime number according to the `Nat.Prime` definition in Lean if and only if `p` is a prime element in the multiplicative monoid of natural numbers under multiplication.


theorem nnnorm_mul : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a b : α), ‖a * b‖₊ = ‖a‖₊ * ‖b‖₊ := by sorry

This theorem states that for any type `α` that forms a Normed Division Ring, the non-negative norm of the product of any two elements `a` and `b` from `α` is equal to the product of the non-negative norms of `a` and `b`. In mathematical terms, this can be written as ‖a * b‖₊ = ‖a‖₊ * ‖b‖₊ for all `a` and `b` in `α`.

For any normed division ring `α`, the norm of the product of two elements `a` and `b` is equal to the product of their norms: `‖a * b‖₊ = ‖a‖₊ * ‖b‖₊`.


AlgEquiv.surjective

theorem AlgEquiv.surjective :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂),
      Function.Surjective ⇑e :=
  by sorry

The theorem `AlgEquiv.surjective` states that for any commutative semiring `R` and any two semirings `A₁` and `A₂` with a structure of `R`-algebra, every algebraic equivalence `e` between `A₁` and `A₂` is a surjective function. In other words, for every element in the semiring `A₂`, there exists an element in the semiring `A₁` such that the application of the equivalence `e` on the element of `A₁` will yield the corresponding element in `A₂`.

For every commutative semiring `R`, and `R`-algebras `A₁` and `A₂` with an algebraic equivalence `e` between them, `e` is a surjective function.


/-- The Radon-Nikodym derivative of a sigma-finite measure `μ` with respect to another
measure `ν` is `ν`-almost everywhere finite.  -/
theorem MeasureTheory.Measure.rnDeriv_lt_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ],
      ∀ᵐ (x : α) ∂ν, μ.rnDeriv ν x < ⊤ :=
  by sorry

This theorem states that the Radon-Nikodym derivative of a sigma-finite measure `μ` with respect to another measure `ν` is almost everywhere finite with respect to `ν`. Here, 'almost everywhere' means except on a set of `ν`-measure zero. The theorem is applicable for any measurable space `α` and any sigma-finite measure `μ` on this space. The Radon-Nikodym derivative is a concept from measure theory that expresses the change of one measure with respect to another. The result that it is almost everywhere finite under these conditions is a foundational result in measure theory.

In measure theory, for any sigma-finite measure `μ` on a measurable space `α`, the Radon-Nikodym derivative of `μ` with respect to another measure `ν` is almost everywhere finite with respect to `ν`.


theorem MeasurableSpace.generateFrom_measurableSet :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSpace.generateFrom {s | MeasurableSet s} = inst := by sorry

This theorem states that for any type `α` and any instance of a measurable space on `α`, the smallest measure space that contains all the basic sets which are measurable is equivalent to the original instance of the measurable space. In other words, it's asserting that the measurable space generated from the collection of its own measurable sets is the same as the original measurable space itself.

The measurable σ-algebra generated by the collection of measurable sets in a measurable space is equal to the original measurable σ-algebra.


theorem Nat.div2_val : ∀ (n : ℕ), Nat.div2 n = n / 2 := by sorry

This theorem states that for every natural number `n`, the value of the function `Nat.div2 n` is equal to the floor of `n/2`. In other words, `Nat.div2 n` gives the greatest integer that is less than or equal to `n/2`. This theorem provides a formal proof in Lean 4 that this function indeed behaves as expected based on its definition.

For every natural number `n`, `Nat.div2 n` equals the floor of `n/2`.


/-- `K` is contained in `Kᗮᗮ`.  -/
theorem Submodule.le_orthogonal_orthogonal :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (K : Submodule 𝕜 E), K ≤ Kᗮᗮ :=
  by sorry

This theorem states that for any type 𝕜 and E, where 𝕜 is RCLike and E is a NormedAddCommGroup and an InnerProductSpace over 𝕜, any submodule K of E is always contained within the double orthogonal complement of K, denoted as Kᗮᗮ. In other words, for any vector space E and its submodule K, the set of all vectors orthogonal to the orthogonal of K includes K itself.

For any RCLike type 𝕜 and NormedAddCommGroup/InnerProductSpace 𝕎 over 𝕜, any submodule K of 𝕎 is contained in its double orthogonal complement Kᗮᗮ.


theorem Function.forall_update_iff :
    ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] (f : (a : α) → β a) {a : α} {b : β a}
      (p : (a : α) → β a → Prop), (∀ (x : α), p x (Function.update f a b x)) ↔ p a b ∧ ∀ (x : α), x ≠ a → p x (f x) :=
  by sorry

The theorem `Function.forall_update_iff` states that for every function `f` from a type `α` to another type `β`, a particular point `a` in `α`, a value `b` in `β a`, and a property `p` which takes a point in `α` and a value in `β a`, asserting that this property `p` holds for every point in the domain `α` after updating the function `f` at the point `a` with the value `b`, is equivalent to stating that this property `p` holds at the point `a` with the value `b` and at every other point `x` in the domain `α` with the original function value `f x`, given that `x` is not equal to `a`.

For any function `f` from type `α` to type `β`, point `a` in `α`, value `b` in `β`, and property `p`, the function `f` updates `a` to `b` with property `p` if and only if `p` holds at `a` with `b` and for all `x ≠ a` in `α`, `p` holds at `x` with `f x`.


theorem mod_addOrderOf_nsmul : ∀ {G : Type u_1} [inst : AddMonoid G] (x : G) (n : ℕ), (n % addOrderOf x) • x = n • x :=
  by sorry

This theorem, `mod_addOrderOf_nsmul`, states that for all types `G` which are additively structured as a monoid and for any element `x` of `G` and natural number `n`, the `n`th multiple of `x` is equal to the multiple of `x` by the remainder when `n` is divided by `addOrderOf x`. Here, `addOrderOf x` represents the order of element `x`, which is the smallest positive integer `n` such that `n * x = 0`, or `0` if `x` has infinite order. The theorem essentially describes a property of periodicity in the context of additive monoids.

For any additively structured monoid type `G` and element `x` of `G` with order `n`, the `n`th multiple of `x` equals the `n`th power of `x` modulo the order of `x`.


/-- When `b < sSup s`, there is an element `a` in `s` with `b < a`, if `s` is nonempty and the order
is a linear order.  -/
theorem exists_lt_of_lt_csSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {s : Set α} {b : α},
      Set.Nonempty s → b < sSup s → ∃ a ∈ s, b < a :=
  by sorry

The theorem `exists_lt_of_lt_csSup` states that for any type `α` that has a conditionally complete linear order, any non-empty set `s` of type `α`, and any element `b` of type `α`, if `b` is strictly less than the supremum of `s` (denoted `sSup s`), then there exists an element `a` in `s` such that `b` is strictly less than `a`. This theorem essentially captures one of the properties of the supremum of a set in the context of a linear order.

If `α` is a conditionally complete linear order, `s` is a non-empty subset of `α`, and `b` is strictly less than the supremum of `s`, then there exists an `a` in `s` such that `b` is strictly less than `a`.


theorem Set.image_inter_subset :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s t : Set α), f '' (s ∩ t) ⊆ f '' s ∩ f '' t := by sorry

The theorem `Set.image_inter_subset` states that for any two sets `s` and `t` of elements of some type `α`, and any function `f` from `α` to another type `β`, the image under `f` of the intersection of `s` and `t` is a subset of the intersection of the image under `f` of `s` and the image under `f` of `t`. In mathematical terms, this is saying that for all sets `s` and `t` and function `f`, we have `f(S ∩ T) ⊆ f(S) ∩ f(T)`.

The image of the intersection of two sets under a function is a subset of the intersection of the images of those sets under that function.


theorem CategoryTheory.Limits.prod.lift_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.lift f g) CategoryTheory.Limits.prod.fst = f :=
  by sorry

The theorem `CategoryTheory.Limits.prod.lift_fst` states that for any category `C` and objects `W`, `X`, and `Y` in `C`, if `X` and `Y` have a binary product, then for any morphisms `f : W ⟶ X` and `g : W ⟶ Y`, the composition of the morphism induced by `f` and `g` using `prod.lift` and the projection to the first component of the product (`prod.fst`) equals `f`. In other words, it illustrates one of the universal properties of the product in a category, namely that the composed map `W ⟶ X ⨯ Y ⟶ X` is the same as the original map `W ⟶ X`.

For any object `W` in a category `C` with products, and morphisms `f : W ⟶ X` and `g : W ⟶ Y` where `X` and `Y` have a binary product, `prod.lift(prod.fst ∘ g) = f` holds.


theorem hasFDerivWithinAt_univ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E}, HasFDerivWithinAt f f' Set.univ x ↔ HasFDerivAt f f' x :=
  by sorry

This theorem states that, for any nontrivially normed field 𝕜, normed additive commutative groups E and F, and a normed space 𝕜 over E and F, if we consider a function `f` from E to F and a continuous linear map `f'` from E to 𝕜 to F, and a point `x` in E. The function `f` has `f'` as its derivative at `x` within the universal set if and only if `f` has `f'` as its derivative at `x`. In other words, the condition of the function `f` having `f'` as its derivative at a point `x` is the same whether we consider it within the whole space or any specific subset of the space.

For any nontrivially normed field 𝕜, normed additive commutative groups E and F, and a normed space 𝕜 over E and F, the derivative of a continuous linear map `f'` from E to 𝕜 being equal to the derivative of the function `f` from E to F at a point `x` holds both in the whole space and in the subset of 𝕜.


theorem iInf_mono' :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : CompleteLattice α] {f : ι → α} {g : ι' → α},
      (∀ (i' : ι'), ∃ i, f i ≤ g i') → iInf f ≤ iInf g :=
  by sorry

This theorem, `iInf_mono'`, asserts that for any type `α` that forms a complete lattice, and any two indexed sets `f` and `g` with indices of arbitrary sorts `ι` and `ι'` respectively, mapping to `α`, if for every element in the range of `g`, there exists an element in the range of `f` that is less than or equal to it, then the indexed infimum (greatest lower bound) of `f`, denoted by `iInf f`, is less than or equal to the indexed infimum of `g`, denoted by `iInf g`.

For any complete lattice `α` and indexed sets `f: ι -> α` and `g: ι' -> α` with the property that `g ι' i ≤ f ι j` for all `i ∈ ι'` and `j ∈ ι` implies `iInf f ≤ iInf g`, we have `iInf f ≤ iInf g`.


Isometry.uniformInducing

/-- An isometry from a metric space is a uniform inducing map  -/
theorem Isometry.uniformInducing :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → UniformInducing f :=
  by sorry

This theorem states that an isometry, which is a function that preserves the edistance (extended distance) between two elements in pseudoemetric spaces, from a particular pseudoemetric space, induces a uniform structure on that space. More precisely, for any two types `α` and `β` that are instances of `PseudoEMetricSpace`, and any function `f` from `α` to `β`, if `f` is an isometry, then `f` is also a uniform inducing map. A uniform inducing map is one that pulls back the uniform structure of the target space to the source space, essentially creating a uniformity on the source space that is compatible with the function.

If `f` is an isometry between pseudometric spaces `α` and `β`, then `f` induces a uniform structure on `α` that is compatible with the source space's pseudometric and the uniform structure of `β`.


theorem sup_sdiff_cancel_right :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ≤ b → a ⊔ b \ a = b := by sorry

This theorem, `sup_sdiff_cancel_right`, states that for all types `α` given that `α` is a Generalized Coheyting Algebra, for any elements `a` and `b` of type `α`, if `a` is less than or equal to `b`, then the supremum of `a` and the set difference of `b` and `a` is equal to `b`. In mathematical terms, if $a \leq b$ then $a \cup (b \setminus a) = b$. This theorem is essentially capturing the property that in a Generalized Coheyting Algebra, adding back the difference of a set with a subset gives the original set.

In a Generalized Coheting Algebra, for all elements `a` and `b`, if `a` is less than or equal to `b`, then `a ∪ (b \backslash a) = b`.


theorem Finset.coe_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] (s : Finset α) (t : Finset β),
      ↑(s • t) = ↑s • ↑t :=
  by sorry

The theorem `Finset.coe_smul` states that for any two finite sets `s` and `t` of types `α` and `β` respectively, where `β` has a decidable equality and there exists a scalar multiplication operation on `α` and `β`, the result of the scalar multiplication of the two sets `s` and `t` when coerced (or converted) to a set is equal to the scalar multiplication of the coerced sets `s` and `t`. In simpler terms, the theorem states that the process of scalar multiplication is consistent under the operation of set coercion.

For finite sets $s:\alpha$ and $t:\beta$ with decidable equality and scalar multiplication operations, $(s\cdot c)\cup t = s\cdot (c\cdot t)$, where $\cdot$ denotes scalar multiplication and coercion.


theorem Polynomial.natDegree_X_sub_C :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] (x : R),
      Polynomial.natDegree (Polynomial.X - Polynomial.C x) = 1 :=
  by sorry

The theorem `Polynomial.natDegree_X_sub_C` states that for any type `R` that forms a ring and is nontrivial, and for any element `x` of `R`, the natural degree of the polynomial obtained by subtracting the constant polynomial `x` from the polynomial variable `X` is always 1. In other words, the degree of the polynomial `X - x` is 1 for any `x` in a nontrivial ring `R`.

For any nontrivial ring R and its element x, the degree of the polynomial X - x is 1.


Set.Pairwise.mono'

theorem Set.Pairwise.mono' :
    ∀ {α : Type u_1} {r p : α → α → Prop} {s : Set α}, r ≤ p → Set.Pairwise s r → Set.Pairwise s p := by sorry

This theorem states that for any type `α`, two relations `r` and `p` (where a relation is a function from `α` to `α` to `Prop`), and a set `s` of type `α`, if `r` is a sub-relation of `p` (that is, `r` implies `p` for all arguments) and if the relation `r` holds pairwise on set `s` (in other words, for all distinct elements `x` and `y` in `s`, `r x y` holds), then the relation `p` also holds pairwise on the set `s`. This means that imposing a stronger relation does not disrupt the pairwise property for distinct elements in the set.

If `r` is a sub-relation of `p` and `r` holds pairwise on set `s`, then `p` also holds pairwise on `s`.


theorem Nat.find_le : ∀ {n : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] {h : ∃ n, p n}, p n → Nat.find h ≤ n := by sorry

The theorem `Nat.find_le` states that for any natural number `n` and a predicate `p` that applies to natural numbers, given that `p` is a decidable predicate and there exists a natural number which satisfies the predicate `p`, if `n` satisfies `p`, then the least natural number that satisfies `p` (found by `Nat.find`) is less than or equal to `n`. This means that `Nat.find h` will always find the smallest natural number that satisfies the predicate `p`, or will be equal to `n` if `n` is the smallest such number.

If `p` is a decidable predicate on natural numbers with an existentially quantified solution, and `n` is a natural number satisfying `p`, then the least natural number `m` such that `p(m)` holds (given by `Nat.find h`) is less than or equal to `n`.


theorem LinearMap.ker_eq_bot_of_injective :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F},
      Function.Injective ⇑f → LinearMap.ker f = ⊥ :=
  by sorry

The theorem `LinearMap.ker_eq_bot_of_injective` states that for all types `R`, `R₂`, `M`, `M₂`, and `F`, if `R` and `R₂` are semirings, `M` and `M₂` are additive commutative monoids, `M` and `M₂` are modules over `R` and `R₂` respectively, `τ₁₂` is a ring homomorphism from `R` to `R₂`, `F` is a type that behaves like a function from `M` to `M₂` and `f` satisfies the property of a semilinear map from `M` to `M₂`, then if the function `f` is injective (i.e., no two different inputs give the same output), the kernel of the linear map `f` (i.e., the set of all inputs that `f` maps to the zero element) is the trivial submodule (represented as `⊥`). In simpler terms, injective linear maps don't map any non-zero inputs to zero.

If `F : M → M₂`, `f : M → M₂` is a semilinear map, `τ₁₂ : R → R₂` is a ring homomorphism, and `f` is injective, then the kernel of the linear map `F` is the trivial submodule.


theorem Num.succ'_to_nat : ∀ (n : Num), ↑(Num.succ' n) = ↑n + 1 := by sorry

This theorem states that for any natural number `n`, the natural number representation of the successor of `n` (denoted as `Num.succ' n`) is equal to the sum of the natural number representation of `n` and 1. In other words, applying the function `Num.succ'` to a number `n` and then converting to a natural number yields the same result as first converting `n` to a natural number and then adding 1.

For all natural numbers `n`, `Num.succ' n = n + 1`.


theorem MeasurableSpace.generateFrom_mono :
    ∀ {α : Type u_1} {s t : Set (Set α)}, s ⊆ t → MeasurableSpace.generateFrom s ≤ MeasurableSpace.generateFrom t := by
  sorry

This theorem states that for any type `α` and any two sets `s` and `t` of sets of `α`, if `s` is a subset of `t`, then the measurable space generated from `s` is less than or equal to the measurable space generated from `t`. In other words, if we add more basic sets to the collection from which we generate a measurable space, we cannot decrease the size of the measurable space. Rather, it will either stay the same or increase. This makes intuitive sense as adding more basic sets potentially allows more sets to be measurable.

If `α` is a type and `s` is a subset of `t` are sets of `α`, then the measurable space generated from `s` is less than or equal to the measurable space generated from `t`.


theorem Function.minimalPeriod_pos_of_mem_periodicPts :
    ∀ {α : Type u_1} {f : α → α} {x : α}, x ∈ Function.periodicPts f → 0 < Function.minimalPeriod f x := by sorry

This theorem states that for any type `α`, given a function `f` mapping from `α` to `α` and an element `x` of `α`, if `x` is a periodic point of the function `f` (i.e., `x` is in the set of periodic points of `f`), then the minimal period of `x` under the function `f` is a positive integer. In other words, if `x` repeats its position after certain iterations under `f`, the number of steps it takes for the first such repetition is a positive number.

For any function `f` from type `α` to itself and any periodic point `x` of `f`, the minimal period of `x` is a positive integer.


theorem sup_left_comm : ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ (b ⊔ c) = b ⊔ (a ⊔ c) := by sorry

The theorem `sup_left_comm` states that for any type `α` that forms a semilattice with respect to the operation `⊔` (sup or supremum), the operation is left-commutative. In other words, for any three elements `a`, `b`, and `c` of type `α`, the supremum of `a` and the supremum of `b` and `c` is equal to the supremum of `b` and the supremum of `a` and `c`. This is a property of algebraic structures such as semilattices where the order of elements does not matter when combining them with an operation.

For any semilattice `α` with operation `⊔`, the supremum of `a ⊔ b` is equal to `b ⊔ a` for all `a, b ∈ α`.


theorem Real.log_neg_eq_log : ∀ (x : ℝ), Real.log (-x) = Real.log x := by sorry

This theorem states that for all real numbers `x`, the logarithm of the negative of `x` is equal to the logarithm of `x`. In mathematical terms, it expresses the property that `log(-x) = log(x)`. This is a manifestation of the way the real logarithm function is defined in Lean 4: it maps negative inputs to the logarithm of their absolute value, and thus doesn't distinguish between positive and negative arguments.

The real logarithm function is defined such that for all real numbers `x`, `log(-x) = log(|x|)`. Therefore, `log(-x) = log(x)` since `|x|` is the absolute value of `x`.


theorem CategoryTheory.Functor.map_neg :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.Additive F] {X Y : C} {f : X ⟶ Y}, F.map (-f) = -F.map f :=
  by sorry

This theorem states that for any types `C` and `D` that have category structures and are preadditive (i.e., have an addition operation), if there is an additive functor `F` from `C` to `D`, then for any two objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y`, the functor `F` applied to the negation of `f` is equal to the negation of the functor `F` applied to `f`. This theorem essentially says that the functor `F` preserves the negation operation on morphisms.

Given additive categories `C` and `D`, and an additive functor `F` from `C` to `D`, for any objects `X`, `Y` in `C` and morphism `f : X → Y`, we have `F(−f) = −F(f)`.


theorem CategoryTheory.Limits.kernelSubobject_arrow' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectIso f).inv
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject f)) =
        CategoryTheory.Limits.kernel.ι f :=
  by sorry

The theorem `CategoryTheory.Limits.kernelSubobject_arrow'` states that in any category `C` with zero-morphisms, given a morphism `f` from `X` to `Y` which has a kernel, the composition of the inverse of the isomorphism from the kernel of `f` to a subobject of `X` with the morphism from this subobject to `X` equals the morphism from the kernel of `f` to `X`.

In other words, it expresses a property of the kernel of a morphism in category theory: that it can be identified with a subobject such that a particular composed map is equivalent to the map from the kernel to the source of the original morphism. This is a common way of viewing the kernel in terms of subobjects in category theory.

 Given a morphism with a kernel in a category with zero-morphisms, the subobject isomorphism from the kernel to a subobject of the domain makes the following diagram commute:

```
Kernel(f) ───────≃─────── Subobject of X
             │      │
             │      ↓
             │ maps to
             │
             ↓
X
─────── f ─────── Y
```


theorem Set.image_injective :
    ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (Set.image f) ↔ Function.Injective f := by sorry

The theorem `Set.image_injective` states that for all types `α` and `β`, and a function `f` mapping from `α` to `β`, the function `Set.image f` is injective if and only if the function `f` itself is injective. In other words, a function `f` is injective if and only if the image of any two different sets under `f` are different. This is a bi-directional conditional statement, meaning that each condition implies the other.

The map `Set.image f : β → Set α` is an injection if and only if the function `f : α → β` is an injection.


theorem IsIntegralClosure.algebraMap_mk' :
    ∀ {R : Type u_1} (A : Type u_2) {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
      [inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (x : B) (hx : IsIntegral R x),
      (algebraMap A B) (IsIntegralClosure.mk' A x hx) = x :=
  by sorry

The theorem `IsIntegralClosure.algebraMap_mk'` states that for all types `R`, `A`, and `B` with the instances of `R`, `A`, and `B` being commutative rings, `R` and `A` being algebras over `B`, and `A` being an integral closure of `R` in `B`, for any element `x` in `B` that is integral over `R`, the algebra map from 'A' to 'B' applied to the integral closure of `x` in `A` is equal to `x`. This essentially means that the map preserves the integral elements of an integral closure when it's applied to them.

For any commutative rings R, A, B with A an integral closure of R in B, the algebra map from A to B maps the integral closure of any element x in B integral over R to x itself.


theorem iInf_inf_eq :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f g : ι → α}, ⨅ x, f x ⊓ g x = (⨅ x, f x) ⊓ ⨅ x, g x :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and any two functions `f` and `g` from an indexed type `ι` to `α`, the infimum (greatest lower bound) of the infimums of `f(x)` and `g(x)` over all `x` is equal to the infimum of `f(x)` taken over all `x` infimumed with the infimum of `g(x)` taken over all `x`. In mathematical terms, this theorem states that `⨅ x, f(x) ⊓ g(x) = (⨅ x, f(x)) ⊓ (⨅ x, g(x))` for all `f` and `g` from `ι` to a complete lattice `α`. This is a property regarding the interaction of the infimum operation with the meet (infimum) operation in the context of a complete lattice.

For any complete lattice `α` and functions `f` and `g` from an indexed type `ι` to `α`, the infimum of `f(x)` and `g(x)` over all `x` is equal to the infimum of `f(x)` and the infimum of `g(x)` taken individually over all `x`. (i.e., `⨅ x, f(x) ⊓ g(x) = ⨅ x, f(x) ⊓ ⨅ x, g(x)`)


theorem Polynomial.natDegree_le_iff_degree_le :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      Polynomial.natDegree p ≤ n ↔ Polynomial.degree p ≤ ↑n :=
  by sorry

The theorem `Polynomial.natDegree_le_iff_degree_le` states that for any type `R` with a semiring structure, any polynomial `p` of type `R`, and any natural number `n`, the natural degree of `p` is less than or equal to `n` if and only if the degree of `p` is less than or equal to `n` coerced to the type `WithBot ℕ`. In other words, this theorem creates a bridge between the comparison of the natural degree and the degree (in the `WithBot ℕ` context) of a polynomial.

For any semiring `R`, polynomial `p` over `R`, and natural number `n`, the natural degree of `p` is less than or equal to `n` if and only if the degree of `p` is less than or equal to `n` when treated as a natural number with a bottom element.


theorem contDiff_zero :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
      ContDiff 𝕜 0 f ↔ Continuous f :=
  by sorry

This theorem, `contDiff_zero`, states that for all normed additive commutative groups `E` and `F`, over a non-trivially normed field `𝕜`, and a function `f` mapping from `E` to `F`, the function `f` is continuously differentiable of order 0 if and only if `f` is a continuous function. The notation `ContDiff 𝕜 0 f` refers to the function `f` being continuously differentiable of order 0, while `Continuous f` refers to `f` being a continuous function.

A function `f` from a normed additive commutative group `E` to another normed additive commutative group `F` over a non-trivially normed field is continuously differentiable of order 0 if and only if it is continuous.


theorem Quiver.Hom.unmop_inj :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ}, Function.Injective Quiver.Hom.unmop := by
  sorry

The theorem `Quiver.Hom.unmop_inj` states that for all categories `C`, and for any two objects `X` and `Y` in the opposite category `Cᴹᵒᵖ`, the function `Quiver.Hom.unmop` is injective. This means that if two morphisms from `X` to `Y` in the opposite category `Cᴹᵒᵖ` are mapped to the same morphism in the original category `C` when we apply the function `Quiver.Hom.unmop` to them, then they must have been the same morphism in the opposite category `Cᴹᵒᵖ` to begin with.

Given any categories C and for any objects X and Y in Cᴹᵒᵖ, the function Quiver.Hom.unmop maps distinct morphisms from X to Y in Cᴹᵒᵖ to distinct morphisms in C.


theorem Subgroup.mem_center_iff :
    ∀ {G : Type u_1} [inst : Group G] {z : G}, z ∈ Subgroup.center G ↔ ∀ (g : G), g * z = z * g := by sorry

The theorem `Subgroup.mem_center_iff` states that for any group `G` and any element `z` in `G`, `z` is in the center of the group `G` if and only if `z` commutes with every element `g` in `G`. In other words, for all `g` in `G`, the product of `g` and `z` equals the product of `z` and `g`. This theorem provides a characterization of the center of a group in terms of commutativity.

A group element is in the center if and only if it commutes with every group element.


/-- A family `𝓕 : ι → X → α` is equicontinuous at `x₀` iff the function `swap 𝓕 : X → ι → α` is
continuous at `x₀` *when `ι → α` is equipped with the topology of uniform convergence*. This is
very useful for developping the equicontinuity API, but it should not be used directly for other
purposes.  -/
theorem equicontinuousAt_iff_continuousAt :
    ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_7} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α}
      {x₀ : X}, EquicontinuousAt F x₀ ↔ ContinuousAt (⇑UniformFun.ofFun ∘ Function.swap F) x₀ :=
  by sorry

The theorem `equicontinuousAt_iff_continuousAt` states that a family of functions `𝓕 : ι → X → α`, mapping from a topological space to a uniform space, is equicontinuous at a point `x₀` if and only if the function obtained by swapping the arguments of `𝓕` (i.e., `swap 𝓕 : X → ι → α`) is continuous at `x₀` when we equip `ι → α` with the topology of uniform convergence. This theorem is particularly useful for developing the equicontinuity API, but it's recommended not to use it directly for other purposes.

A family of functions from a topological space to a uniform space is equicontinuous at a point if and only if the function obtained by swapping arguments is continuous at that point with respect to uniform convergence.


/-- Recursive definition for the Cantor normal form.  -/
theorem Ordinal.CNF_ne_zero :
    ∀ {b o : Ordinal.{u_1}},
      o ≠ 0 → Ordinal.CNF b o = (Ordinal.log b o, o / b ^ Ordinal.log b o) :: Ordinal.CNF b (o % b ^ Ordinal.log b o) :=
  by sorry

This theorem presents a recursive definition for the Cantor normal form of an ordinal `o` under the base `b`. When `o` is not zero, the Cantor normal form of `o` is a list starting with the pair `(Ordinal.log b o, o / b ^ Ordinal.log b o)`, followed by the Cantor normal form of the remainder when `o` is divided by `b` to the power of `Ordinal.log b o`. In other words, it breaks down `o` into a series of terms of the form 'base to the power of x, times y', and describes the Cantor normal form of `o` in terms of these terms. It's a way of representing the structure of the ordinal `o` in terms of the ordinal `b`.

The Cantor normal form of a non-zero ordinal `o` under base `b` is a recursively defined list starting with `(log_b o, o % (b ^ log_b o))` and the Cantor normal form of `o % (b ^ log_b o)` under base `b`.


theorem IsClosed.completeSpace_coe :
    ∀ {α : Type u} [inst : UniformSpace α] [inst_1 : CompleteSpace α] {s : Set α}, IsClosed s → CompleteSpace ↑s := by
  sorry

This theorem asserts that for any type `α` equipped with a `UniformSpace` structure and a `CompleteSpace` structure, and for any set `s` of elements of type `α`, if `s` is a closed set, then the set `s` is also a complete space. In other words, if every Cauchy sequence of points in `s` has a limit that also lies in `s` (which is what it means for `s` to be closed), then every Cauchy sequence of points in `s` converges to some limit in `s` (which is what it means for `s` to be a complete space).

If a closed subset of a complete and uniform space is equipped with the induced uniform structure, then it is a complete space.


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

This theorem states that for all types `α` and for all elements `x` and `y` of type `α`, where `α` is a Generalized Boolean Algebra, the set difference of `x` and the set difference of `x` and `y` is equal to the intersection of `x` and `y`. In mathematical terms, it asserts that \(x \setminus (x \setminus y) = x \cap y\) for all `x` and `y` in a Generalized Boolean Algebra.

For all types `α` representing a Generalized Boolean Algebra and all elements `x` and `y` in `α`, we have `x \ (x \ y) = x ∩ y`.


theorem Homeomorph.preimage_symm :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      Set.preimage ⇑(Homeomorph.symm h) = Set.image ⇑h :=
  by sorry

This theorem states that for any two topological spaces `X` and `Y` and any homeomorphism `h` from `X` to `Y`, the preimage of a set under the inverse of `h` is the same as the image of the set under `h`. In simpler terms, if you take a set from `Y`, apply the inverse of `h` to it, and get a set in `X`, this is the same as taking the original set in `X`, applying `h` to it, and obtaining a set in `Y`. This theorem illustrates an important property of homeomorphisms, which are continuous functions with continuous inverses, in the field of topology.

For any topological spaces `X`, `Y`, and a homeomorphism `h` from `X` to `Y`, the inverse image of a set under `h` equals the image of that set under `h`.


/-- Associate the dot product of `mulVec` to the left.  -/
theorem Matrix.dotProduct_mulVec :
    ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} [inst : Fintype n] [inst_1 : Fintype m]
      [inst_2 : NonUnitalSemiring R] (v : m → R) (A : Matrix m n R) (w : n → R),
      Matrix.dotProduct v (Matrix.mulVec A w) = Matrix.dotProduct (Matrix.vecMul v A) w :=
  by sorry

This theorem states that for any vector `v` of type `m → R`, any matrix `A` of type `Matrix m n R`, and any vector `w` of type `n → R` (where `R` is a non-unital semiring, `m` and `n` are finite types), the dot product of `v` with the result of multiplying the matrix `A` by the vector `w` (i.e., `Matrix.dotProduct v (Matrix.mulVec A w)`) is equal to the dot product of the result of multiplying the vector `v` by the matrix `A` (i.e., `Matrix.vecMul v A`) with the vector `w` (i.e., `Matrix.dotProduct (Matrix.vecMul v A) w`). In other words, it asserts that the dot product operation is associative with respect to the matrix-vector multiplication operation.

For any vector `v` of type `m -> R` and matrix `A` of type `Matrix m n R`, and vector `w` of type `n -> R`, the dot product of `v` with the matrix-vector product `A * w` is equal to the dot product of the vector-matrix product `v * A` with `w`.


MeasureTheory.NullMeasurableSet.iUnion

theorem MeasureTheory.NullMeasurableSet.iUnion :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Sort u_5} [inst : Countable ι]
      {s : ι → Set α},
      (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → MeasureTheory.NullMeasurableSet (⋃ i, s i) μ :=
  by sorry

This theorem states that for any type `α`, any `MeasurableSpace` on `α`, any measure `μ` on `α`, and any countable index type `ι`, if each set `s i` indexed by `ι` is a `NullMeasurableSet` with respect to measure `μ`, then the union of all such sets (i.e., `(⋃ i, s i)`) is also a `NullMeasurableSet` with respect to the same measure `μ`. In other words, the countable union of null measurable sets is also a null measurable set.

If each set in a countable collection is null measurable, then their countable union is also null measurable.


theorem Finset.product_subset_product :
    ∀ {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t t' : Finset β}, s ⊆ s' → t ⊆ t' → s ×ˢ t ⊆ s' ×ˢ t' := by sorry

This theorem states that for any two types `α` and `β`, and any four finite sets `s`, `s'` of type `α` and `t`, `t'` of type `β`, if `s` is a subset of `s'` and `t` is a subset of `t'`, then the Cartesian product of `s` and `t` is a subset of the Cartesian product of `s'` and `t'`. In other words, the Cartesian product of two subsets is itself a subset of the Cartesian product of their respective supersets.

For any types `α` and `β`, and finite sets `s` of type `α` subset `s'`, `t` of type `β` subset `t'`, `s × t` is a subset of `s' × t'`.


theorem Complex.cosh_mul_I : ∀ (x : ℂ), Complex.cosh (x * Complex.I) = Complex.cos x := by sorry

This theorem states that for every complex number `x`, the complex hyperbolic cosine of the product of `x` and the imaginary unit equals the complex cosine of `x`. In mathematical terms, it says that `cosh(ix) = cos(x)` for all `x` in the complex numbers, where `cosh` is the complex hyperbolic cosine function defined via the exponential function, `cos` is the complex cosine function also defined via the exponential function, and `i` is the imaginary unit.

The complex hyperbolic cosine of the product of a complex number `x` and the imaginary unit `i` equals the complex cosine of `x`, that is, `cosh(ix) = cos(x)` for all `x` in the complex numbers.


theorem Complex.hasStrictDerivAt_log : ∀ {x : ℂ}, x ∈ Complex.slitPlane → HasStrictDerivAt Complex.log x⁻¹ x := by sorry

The theorem `Complex.hasStrictDerivAt_log` states that for all complex numbers `x` that belong to the slit complex plane (which is the complex plane with the closed negative real axis removed), the function `Complex.log` (which is the complex logarithm function) has a strict derivative at `x` which is equal to the reciprocal of `x`. The strict derivative means that the difference between the function values at two points approaches the product of the difference between the points and the derivative, plus an infinitely small error, as the two points approach each other. In mathematical terms, this is equivalent to saying that, for all `x` in the slit complex plane, the logarithm function `log` is strictly differentiable at `x` with derivative `1/x`.

For complex numbers `x` in the slit complex plane, the complex logarithm function `log` is strictly differentiable with derivative `1/x`.


/-- **Alias** of the reverse direction of `antilipschitzWith_iff_le_mul_dist`. -/
theorem AntilipschitzWith.of_le_mul_dist :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal}
      {f : α → β}, (∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y)) → AntilipschitzWith K f :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with a pseudo metric space structure, and for any nonnegative real number `K` and function `f` from `α` to `β`, if for every pair of elements `x` and `y` of `α`, the distance between `x` and `y` is less than or equal to `K` times the distance between `f(x)` and `f(y)`, then `f` is `AntilipschitzWith` `K`. The `AntilipschitzWith` condition means that the function `f` doesn't increase distances between points more than a certain factor `K`.

If `α` and `β` are type spaces equipped with pseudo metrics, and for all `x, y ∈ α`, the distance `d(x, y)` is less than or equal to non-negative real number `K` times the distance `d(f(x), f(y))`, then `f : α → β` is an antip daschsitz function with constant `K`.


theorem norm_inv' : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a : E), ‖a⁻¹‖ = ‖a‖ := by sorry

This theorem states that, for every type `E` that forms a seminormed group, the norm of the inverse of any element `a` from `E` is equal to the norm of `a` itself. In mathematical terms, this is saying that `‖a⁻¹‖ = ‖a‖` for all `a` in `E`. This is a property of seminorms in certain types of mathematical structures.

For every seminormed group `E`, the norm of its inverse element is equal to the norm of the original element: `‖a⁻¹‖ = ‖a‖` for all `a` in `E`.


theorem Fin.le_iff_val_le_val : ∀ {n : ℕ} {a b : Fin n}, a ≤ b ↔ ↑a ≤ ↑b := by sorry

This theorem states that for any two elements `a` and `b` of the set `Fin n` (which represents a finite subset of natural numbers with `n` elements), `a` is less than or equal to `b` if and only if the value of `a` (denoted by `↑a`) is less than or equal to the value of `b` (denoted by `↑b`). In other words, the order relation in `Fin n` is the same as the order relation in the natural numbers, as reflected by their values.

For any `a, b` in `Fin n`, `a ≤ b` if and only if `↑a ≤ ↑b` in the natural numbers.


theorem CategoryTheory.shiftEquiv'.proof_1 : ∀ {A : Type u_1} [inst : AddGroup A] (i j : A), i + j = 0 → j + i = 0 := by
  sorry

This theorem, `CategoryTheory.shiftEquiv'.proof_1`, states that for any type `A` that forms an additive group, given any two elements `i` and `j` of `A`, if the sum of `i` and `j` equals zero, then the sum of `j` and `i` also equals zero. In other words, if `i` and `j` are such that `i + j = 0`, then `j + i = 0` also holds. This is a commutativity property in the context of an additive group.

In an additive group, if `i` and `j` are elements with `i + j = 0`, then `j + i = 0`.