theorem Set.image_diff :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
      Function.Injective f → ∀ (s t : Set α), f '' (s \ t) = f '' s \ f '' t :=
  by sorry

The theorem `Set.image_diff` states that for all types `α` and `β`, and for an injective function `f` from `α` to `β`, the image of the difference of two sets `s` and `t` (of type `α`) under the function `f` is equal to the difference of the image of `s` under `f` and the image of `t` under `f`. In mathematical terms, this theorem represents the property that for injective functions, the image of the set difference is equal to the difference of the images: $f(S \setminus T) = f(S) \setminus f(T)$.

For injective functions $f$ from type $\alpha$ to type $\beta$, $f(s \setminus t) = f(s) \setminus f(t)$, where $s$ and $t$ are sets of type $\alpha$.


theorem Order.lt_succ_iff :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      a < Order.succ b ↔ a ≤ b :=
  by sorry

This theorem, `Order.lt_succ_iff`, states that for any type `α` that has a pre-order and successor order structure, and for any elements `a` and `b` of this type where the type does not have a maximal element, `a` is less than the successor of `b` if and only if `a` is less than or equal to `b`. This essentially describes a fundamental property of the "successor" operation in the context of ordered sets without a maximum element.

For any type `α` with a pre-order and successor order structure and no maximum element, `a < succ(b)` if and only if `a ≤ b`.


theorem Continuous.comp_stronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {x : MeasurableSpace α} [inst : TopologicalSpace β]
      [inst_1 : TopologicalSpace γ] {g : β → γ} {f : α → β},
      Continuous g → MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => g (f x) :=
  by sorry

The theorem `Continuous.comp_stronglyMeasurable` states that for any three types `α`, `β`, and `γ`, where `α` is a measurable space and `β`, `γ` are topological spaces, if `g` is a continuous function from `β` to `γ`, and `f` is a function from `α` to `β` that is strongly measurable (meaning it can be approximated by a sequence of simple functions), then the composition function `g ∘ f` is also strongly measurable. In other words, the composition of a continuous function and a strongly measurable function is again strongly measurable.

If `g` is continuous and `f` is strongly measurable, then the composition `g ∘ f` is also strongly measurable. (Assuming `α` is a measurable space and `β`, `γ` are topological spaces.)


theorem AddOpposite.op_injective : ∀ {α : Type u_1}, Function.Injective AddOpposite.op := by sorry

The theorem `AddOpposite.op_injective` states that for all types `α`, the function `AddOpposite.op` is injective. In other words, if `AddOpposite.op` applied to two elements of the type `α` produces the same result, then the two elements must be the same. This function `AddOpposite.op` essentially takes an element from a type and represents it in its additive opposite type. Therefore, the theorem guarantees that every element of the type `α` has a unique representation in its additive opposite type.

For any type `α`, the function `AddOpposite.op` from `α` to its additive opposite type is an injection.


RingEquiv.injective

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

The theorem `RingEquiv.injective` states that for any two types `R` and `S` which have multiplication and addition operations defined, any ring equivalence `e : R ≃+* S` is injective. In other words, if `e` maps two elements of `R` to the same element in `S`, then those two elements must be the same. This is a property of ring isomorphisms, which are bijective mappings that preserve both addition and multiplication.

If `e : R ≃+* S` is a ring equivalence between types `R` and `S`, then `e` is an injection (i.e., for all `a, b ∈ R`, if `e(a) = e(b)`, then `a = b`).


theorem Int.abs_eq_natAbs : ∀ (a : ℤ), |a| = ↑(Int.natAbs a) := by sorry

The theorem `Int.abs_eq_natAbs` states that for every integer `a`, the absolute value of `a`, denoted as `|a|`, is equal to the natural number corresponding to the absolute value of `a` computed using the `Int.natAbs` function. The `Int.natAbs` function takes an integer input and returns its absolute value as a natural number. For positive integers and zero, it returns the integer itself, and for negative integers, it returns the positive counterpart.

For every integer `a`, the absolute value `|a|` is equal to the natural number `Int.natAbs a`.


theorem Finset.forall_mem_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (p : α → Prop),
      (∀ x ∈ insert a s, p x) ↔ p a ∧ ∀ x ∈ s, p x :=
  by sorry

The theorem `Finset.forall_mem_insert` states that for any type `α` with decidable equality, an element `a` of type `α`, a finite set `s` of type `α`, and a property `p` that holds for elements of type `α`, the proposition that `p` holds for all elements in the set obtained by inserting `a` into `s` is equivalent to the conjunction of the propositions that `p` holds for `a` and `p` holds for all elements in `s`. In other words, for all elements in the union of `a` and `s`, property `p` holds if and only if `p` holds for `a` and for all elements in `s`.

For any decidably equal type `α`, set `s` of type `Finset α`, property `p` on `α`, and `a` in `α`, the following are equivalent: `∀ x ∈ s ∪ {a}, p x` and `p a ∧ ∀ x ∈ s, p x`.


IsUnit.pow

theorem IsUnit.pow : ∀ {M : Type u_1} [inst : Monoid M] {a : M} (n : ℕ), IsUnit a → IsUnit (a ^ n) := by sorry

This theorem states that for any type `M` equipped with a monoid structure, if an element `a` of `M` is a unit (meaning that it has a two-sided inverse), then `a` raised to any natural number `n` (denoted as `a ^ n`) is also a unit. Essentially, it asserts that the power of a unit in a monoid is still a unit.

If `M` is a monoid and `a` is a unit in `M`, then for all natural numbers `n`, `a^n` is also a unit in `M`.


theorem Monotone.reflect_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {a b : α}, f a < f b → a < b :=
  by sorry

The theorem `Monotone.reflect_lt` states that for any types `α` and `β`, given a linear order structure on `α` and a preorder structure on `β`, if a function `f` from `α` to `β` is monotone (that is, `f` preserves the order), then for any two elements `a` and `b` of `α`, if `f(a)` is less than `f(b)`, it implies that `a` is less than `b`. In other words, a monotone function reflects the 'less than' relation from its codomain to its domain.

If `f: α → β` is a monotone function between linearly ordered types `α` and `β` with preorder relation, then `a < b` in `α` implies `f(a) < f(b)` in `β`.


theorem Mathlib.Order.LocallyFinite._auxLemma.2 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) :=
  by sorry

This theorem states that for any type `α` that has preorder and locally finite order properties, and for any elements `a`, `b`, and `x` of that type, the element `x` is in the finset `Finset.Ico a b` if and only if `a` is less than or equal to `x` and `x` is less than `b`. In other words, it confirms the definition of `Finset.Ico` given above: a set of elements `x` such that `a ≤ x < b`.

For any type `α` with preorder and locally finite order, and elements `a ≤ b` of `α`, `Finset.Ico a b` equals the set of `x` in `α` such that `a ≤ x < b`.


theorem IsOpen.eventually_mem :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], IsOpen s → x ∈ s → ∀ᶠ (x : X) in nhds x, x ∈ s := by
  sorry

This theorem, `IsOpen.eventually_mem`, states that for any topological space `X`, any point `x` in `X`, and any set `s` of `X`, if `s` is an open set and `x` is an element of `s`, then eventually, all points in the neighborhood (defined by the neighborhood filter `nhds`) of `x` will also be elements of `s`. In other words, if `x` is in an open set `s`, then points sufficiently close to `x` are also in `s`, which aligns with the intuitive sense of open sets in topology.

For any topological space X, point x in X, and open set s in X containing x, there exists a neighborhood N of x such that N ⊆ s.


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

This theorem is about the distribution of the image of a binary function over the image of two sets under two mapping functions. Specifically, for any types `α`, `α'`, `β`, `β'`, `γ`, and `δ`, and any binary function `f` from `α` and `β` to `γ`, sets `s` of `α` and `t` of `β`, another function `g` from `γ` to `δ`, a binary function `f'` from `α'` and `β'` to `δ`, and two functions `g₁` from `α` to `α'` and `g₂` from `β` to `β'`, if it holds for all `a` in `α` and `b` in `β` that `g(f(a, b)) = f'(g₁(a), g₂(b))`, then the image of the set resulting from applying `f` to the elements of `s` and `t` under `g` equals the set resulting from applying `f'` to the images of `s` under `g₁` and `t` under `g₂`. This theorem essentially states that the sequence of applying a binary function and then a function to elements of two sets is equivalent to applying the function to the images of the sets under two other functions, given that the binary functions and the functions are related in a certain way.

If for all `a` in `α` and `b` in `β`, `g(f(a, b)) = f'(g₁(a), g₂(b))`, then `g(⋃(map f (s ∣∣ X) ⋃ map f (t ∣∣ X))) = ⋃(map f' (map g₁ (s ∣∣ X) ⋃ map g₂ (t ∣∣ X)))`, where `s` and `t` are sets of `α` and `β` respectively, `X` is a type, `f` is a binary function from `α` and `β` to `γ`, `g` is a function from `γ` to `δ`, `f'` is a binary function from `α'` and `β'` to `δ`, and `g₁` is a function from `α` to `α'` and `g₂` is a function from `β` to `β'`.


theorem Int.toNat_sub_of_le : ∀ {a b : ℤ}, b ≤ a → ↑(Int.toNat (a - b)) = a - b := by sorry

The theorem `Int.toNat_sub_of_le` states that for any two integers `a` and `b`, if `b` is less than or equal to `a`, then converting the difference `a - b` to a natural number and then back to an integer gives back `a - b`. In other words, if `b` is less than or equal to `a`, the subtraction operation `a - b` is preserved through the process of conversion to a natural number and back.

If `a` is an integer and `b` is a natural number less than or equal to `a`, then `Int.toNat a.toNat >> Nat.sub << Nat.toInt b = a - b`.


theorem Nat.sub_zero : ∀ (n : ℕ), n - 0 = n := by sorry

This theorem, named `Nat.sub_zero`, states that for all natural numbers `n`, the result of subtracting zero from `n` is `n` itself. That is, any natural number minus zero gives the same natural number. This corresponds to the familiar arithmetic fact in mathematics that any number minus zero equals the number itself.


theorem TopologicalSpace.Opens.opensHomHasCoeToFun.proof_1 :
    ∀ {X : TopCat} {U V : TopologicalSpace.Opens ↑X}, (U ⟶ V) → ∀ (x : ↥U), ↑x ∈ ↑V := by sorry

The theorem `TopologicalSpace.Opens.opensHomHasCoeToFun.proof_1` states that for every topological space `X` in the category of topological spaces (`TopCat`), and for any two open sets `U` and `V` in `X`, any morphism (or continuous map) from `U` to `V` ensures that for any point `x` in `U`, `x` is also in `V`. In other words, if we have a continuous map from one open set to another in a given topological space, any point in the domain set is also a point in the codomain set.

For any topological spaces X and open sets U, V in X, any continuous map from U to V implies that the inclusion of U into V is a subset inclusion.


theorem OrderIso.map_iSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β)
      (x : ι → α), f (⨆ i, x i) = ⨆ i, f (x i) :=
  by sorry

The theorem `OrderIso.map_iSup` states that for any types `α` and `β` and another type `ι` (with `α` and `β` being complete lattices), and for any order isomorphism `f` from `α` to `β`, and any function `x` from `ι` to `α`, the image under `f` of the supremum (or least upper bound) over all `ι` of `x i` is equal to the supremum over all `ι` of the image under `f` of `x i`. In LaTeX notation, it's saying that for an order isomorphism `f: α -> β`, we have `f (sup_i x(i)) = sup_i f(x(i))`.

For any order isomorphism `f` between complete lattices `α` and `β`, and any function `x: ι -> α`, `f (sup_i x(i)) = sup_i f(x(i))`.


theorem disjoint_compl_left : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α}, Disjoint aᶜ a := by sorry

The theorem `disjoint_compl_left` states that for any type `α` that forms a Heyting algebra, and any element `a` of this type, `a` and its complement `aᶜ` are disjoint. This means that for any other element `x` of `α`, if `x` is less than or equal to both `a` and `aᶜ`, then `x` is less than or equal to the bottom element of the Heyting algebra. The bottom element is the smallest element of the algebra, often denoted as `⊥`. This theorem is a generalization of the concept of disjoint sets in set theory, where two sets are disjoint if their intersection is the empty set.

For any Heyting algebra type `α` and element `a`, if `a` and its complement `aᶜ` are elements of `α`, then they are disjoint, meaning that their meet is the bottom element `⊥` of the Heyting algebra.


theorem Iio_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b : α},
      a < b → Set.Iio b ∈ nhds a :=
  by sorry

The theorem `Iio_mem_nhds` states that for any type `α` with a topological space structure, a linear order, and a topology where left-closed right-open intervals are closed sets, and for any two elements `a` and `b` of `α`, if `a` is less than `b`, then the left-infinite right-open interval ending at `b` (denoted as `Set.Iio b`) is a neighborhood of `a`. This means that `Set.Iio b` contains an open set around `a`, or equivalently, it is included in the filter of neighborhoods of `a` (denoted as `nhds a`).

For any topological space `α` with a linear order and a topology where left-closed right-open intervals are closed sets, if `a` is less than `b` in `α`, then the left-infinite right-open interval `Set.Iio b` is an element of the neighborhood filter `nhds a`.


List.Sublist.trans

theorem List.Sublist.trans :
    ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, List.Sublist l₁ l₂ → List.Sublist l₂ l₃ → List.Sublist l₁ l₃ := by sorry

This theorem states that, for any type `α` and any lists `l₁`, `l₂`, and `l₃` of type `α`, if `l₁` is a sublist of `l₂` and `l₂` is a sublist of `l₃`, then `l₁` is a sublist of `l₃`. This property is known as the transitivity of the sublist relation.

If `l₁` is a sublist of `l₂` and `l₂` is a sublist of `l₃`, then `l₁` is a sublist of `l₃`.


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

This theorem states that for any type `α` that is a Generalized Boolean Algebra, given any two elements `x` and `y` of this type, the supremum (join, denoted as `⊔`) of the infimum (meet, denoted as `⊓`) of `x` and `y` and the set difference (`\`) of `x` and `y`, is equal to `x`. In plain English, it means the union of the intersection and the difference of two elements in a Generalized Boolean Algebra is equal to the first of these elements.

In a Generalized Boolean Algebra, the supremum of the infimum of two elements and their set difference is equal to the first element. Or, more succinctly: `⊔(x ⊓ y, x \ y) = x` for all `α` and `x, y : α`.


Rat.pos

theorem Rat.pos : ∀ (a : ℚ), 0 < a.den := by sorry

This theorem states that for every rational number `a`, the denominator of `a` is greater than zero. In other words, the denominator of any rational number must always be a positive integer.

Every rational number has a positive denominator.


theorem ENNReal.top_ne_zero : ⊤ ≠ 0 := by sorry

This theorem states that in the extended non-negative real number system (ENNReal), the positive infinity symbol, represented as "⊤", is not equal to zero. In other words, in this system, positive infinity and zero are distinct entities and cannot be equivalent.

In the extended non-negative real number system (ENNReal), 0 and ∞ (positive infinity) are distinct.


theorem Nat.factorization_le_iff_dvd :
    ∀ {d n : ℕ}, d ≠ 0 → n ≠ 0 → (Nat.factorization d ≤ Nat.factorization n ↔ d ∣ n) := by sorry

This theorem states that for any two non-zero natural numbers `d` and `n`, the factorization of `d` is less than or equal to the factorization of `n` if and only if `d` divides `n`. Here, the factorization of a natural number is represented by a function that maps each prime factor of the number to its multiplicity in the number. This theorem provides a connection between the divisibility of two numbers and the relationship of their prime factorizations.

For all natural numbers d and n with d ≠ 0, d divides n if and only if the prime factorizations of d and n have the same multiplicities for each prime factor.


theorem GaloisConnection.u_l_u_eq_u :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (b : β), u (l (u b)) = u b :=
  by sorry

The theorem `GaloisConnection.u_l_u_eq_u` states that for any types `α` and `β` with `α` partially ordered and `β` preordered, and for any functions `l : α → β` and `u : β → α` that form a Galois connection, the value of `u` applied to the composition of `l` and `u` applied to any element `b` of type `β` is equal to `u` applied to `b`. In other words, it states that in a Galois connection, the composition of `u`, `l`, and `u` is a kind of idempotent operation on `u`.

In a Galois connection between partially ordered type `α` and preordered type `β` given functions `l : α → β` and `u : β → α`, the composition `u ∘ l ∘ u` equals `u`.


theorem Filter.comap_iInf :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {m : α → β} {f : ι → Filter β},
      Filter.comap m (⨅ i, f i) = ⨅ i, Filter.comap m (f i) :=
  by sorry

This theorem states that for any types `α` and `β`, any indexed type `ι`, any function `m` from `α` to `β`, and any function `f` from `ι` to the set of filters on `β`, the filter obtained by applying the `comap` operation to `m` and the infimum of the filters `f i` (for all `i` in `ι`) is equal to the infimum of the filters obtained by applying `comap` to `m` and `f i` (for all `i` in `ι`). In mathematical terms, this can be written as `comap(m, ⨅ i, f i) = ⨅ i, comap(m, f i)`.

For any functions `m: α → β` and `f: ι → Filters β`, the filter `comap(m) ��asm ap f` equals the infimum of `comap(m) ��asm ap (fi)` for all `i` in `ι`.


theorem Stream'.Seq.destruct_cons :
    ∀ {α : Type u} (a : α) (s : Stream'.Seq α), Stream'.Seq.destruct (Stream'.Seq.cons a s) = some (a, s) := by sorry

The theorem `Stream'.Seq.destruct_cons` states that for any type `α` and any element `a` of that type and sequence `s` of the same type, when we append the element to the start of the sequence using `Stream'.Seq.cons a s` and then apply the `Stream'.Seq.destruct` function, we get `some (a, s)`. In essence, destructing a sequence that had an element prepended to it will yield the prepended element and the original sequence.

For any type `α` and element `a` of `α` and sequence `s` of type `Stream α`, `Stream.destruct (Stream.cons a s) = some (a, s)`.


theorem Filter.tendsto_atTop_mono :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {l : Filter α} {f g : α → β},
      (∀ (n : α), f n ≤ g n) → Filter.Tendsto f l Filter.atTop → Filter.Tendsto g l Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_atTop_mono` states that for any types `α` and `β` where `β` is a preordered set, along with a filter `l` on `α` and two functions `f` and `g` from `α` to `β`, if for every element `n` from `α`, `f(n)` is less than or equal to `g(n)`, then if the function `f` tends to infinity (`Filter.atTop`) with respect to the filter `l`, the function `g` also tends to infinity with respect to the same filter `l`. In other words, if `f` is pointwise less than or equal to `g` and `f` tends towards infinity, then `g` must also tend towards infinity.

If `f` is pointwise less than or equal to `g` and `f` tends to infinity with respect to filter `l`, then `g` also tends to infinity with respect to the same filter `l`.


theorem imageToKernel_arrow :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      {A B C : V} (f : A ⟶ B) [inst_2 : CategoryTheory.Limits.HasImage f] (g : B ⟶ C)
      [inst_3 : CategoryTheory.Limits.HasKernel g] (w : CategoryTheory.CategoryStruct.comp f g = 0),
      CategoryTheory.CategoryStruct.comp (imageToKernel f g w)
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject g)) =
        CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject f) :=
  by sorry

This theorem, `imageToKernel_arrow`, states that for any three objects `A`, `B`, and `C` in a category `V` with zero morphisms, given a morphism `f` from `A` to `B` that has an image, and a morphism `g` from `B` to `C` that has a kernel, if the composition of `f` and `g` is zero, then the composition of `imageToKernel` of `f` and `g` and the arrow of the kernel subobject `g` equals to the arrow of the image subobject `f`. Essentially, it provides a relation between the kernel of one morphism and the image of another in the context of zero morphisms in a category.

Given morphisms `f: A → B` with an image and `g: B → C` with a kernel in a category with zero morphisms, if `f ∘ g = 0`, then `imageToKernel(f) ∘ g = f`.


AbsoluteValue.pos

theorem AbsoluteValue.pos :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S) {x : R},
      x ≠ 0 → 0 < abv x :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and for any absolute value function `abv` from `R` to `S`, if `x` is a non-zero element of `R`, then the absolute value of `x` (i.e., `abv x`) is greater than zero. It essentially asserts the well-known mathematical property that the absolute value of a non-zero number is always positive.

For any semiring `R`, ordered semiring `S`, and absolute value function `abv` from `R` to `S`, if `x` is a non-zero element of `R`, then `abv x > 0`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.14 : ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of this type, `b` is an element of the single-element multiset `{a}` if and only if `b` is equal to `a`. This is basically saying that the only way for an element to be in a single-element multiset is for it to be equal to that single element.

For any type `α` and any elements `a, b : α`, `b` is an element of the single-element multiset `{a}` if and only if `a = b`.


theorem Finset.erase_subset : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), Finset.erase s a ⊆ s := by
  sorry

The theorem `Finset.erase_subset` states that for any type `α` equipped with a decidable equality relation, and for any element `a` of type `α` and any finite set `s` of elements of type `α`, the set obtained by erasing the element `a` from `s` (denoted `Finset.erase s a`) is a subset of `s`. In other words, every element in the set after erasing `a` is also in the original set `s`.

For any type `α` with decidable equality and any finite set `s` of elements from `α` and any `a` in `α`, `Finset.erase s a ⊆ s`.


theorem Int.add_right_neg : ∀ (a : ℤ), a + -a = 0 := by sorry

This theorem, `Int.add_right_neg`, states that for any integer `a`, adding the negation of `a` to `a` results in zero. In mathematical terms, it asserts that for all integers `a`, the equation `a + (-a) = 0` holds. In other words, it's expressing the property that any number plus its negative counterpart equals zero, a fundamental property of addition in the set of integers.


AddEquiv.injective

theorem AddEquiv.injective :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N), Function.Injective ⇑e := by sorry

This theorem states that for any two types `M` and `N` which are equipped with addition operations (symbolized by `[inst : Add M]` and `[inst_1 : Add N]`), any additive equivalence `e` between `M` and `N` (`e : M ≃+ N`) is an injective function. In other words, if `e` maps two elements of `M` to the same element of `N` (i.e., `e(x) = e(y)`), then those two elements were actually the same (`x = y`). This property is fundamental to the concept of an additive equivalence, which should not only preserve the structure of addition but also retain distinctness of elements.

Given types `M` and `N` with additions and an additive equivalence `e : M ≃+ N`, if `e(x) = e(y)` then `x = y`.


CategoryTheory.IsPushout.flip

theorem CategoryTheory.IsPushout.flip :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P}
      {inr : Y ⟶ P}, CategoryTheory.IsPushout f g inl inr → CategoryTheory.IsPushout g f inr inl :=
  by sorry

This theorem states that for any category 'C', and any objects 'Z', 'X', 'Y', and 'P' in 'C', if we have morphisms 'f' from 'Z' to 'X', 'g' from 'Z' to 'Y', 'inl' from 'X' to 'P', and 'inr' from 'Y' to 'P', if the given setup forms a pushout diagram, then switching the roles of 'X' and 'Y', 'f' and 'g', and 'inl' and 'inr' will still yield a pushout diagram. In essence, a pushout in a category is invariant under flipping the input and output objects and morphisms.

Given any pushout diagram in a category with objects Z, X, Y, and P, and morphisms f: Z -> X, g: Z -> Y, inl: X -> P, and inr: Y -> P, the resulting diagram obtained by interchanging X and Y, and f and g, and inl and inr, is also a pushout.


theorem map_list_sum :
    ∀ {M : Type u_5} {N : Type u_6} [inst : AddMonoid M] [inst_1 : AddMonoid N] {F : Type u_11} [inst_2 : FunLike F M N]
      [inst_3 : AddMonoidHomClass F M N] (f : F) (l : List M), f (List.sum l) = List.sum (List.map (⇑f) l) :=
  by sorry

This theorem, `map_list_sum`, states that for any two types `M` and `N` that have `AddMonoid` structures, a type `F` that is `FunLike` from `M` to `N` and forms an `AddMonoidHomClass` with `M` and `N`, a function `f` of type `F`, and a list `l` of elements of type `M`, the function `f` applied to the sum of the list `l` is equal to the sum of the list obtained by mapping `f` to every element of `l`. In other words, it states that `f` preserves the sum operation under the map from `M` to `N`. In mathematical notation, it's saying that $f(\sum_{i=1}^{n} l_i) = \sum_{i=1}^{n} f(l_i)$ for a list $l = [l_1, l_2,..., l_n]$ of elements in `M`.

For any `FunLike` function `F` from an `AddMonoid` type `M` to an `AddMonoid` type `N` that forms an `AddMonoidHomClass`, and for any list `l` of elements from `M`, the application of `F` to the sum of `l` equals the sum of the images of each element in `l` under `F`. In mathematical notation, `∀[M : AddMonoid, N : AddMonoid, F : AddMonoidHomClass M N, l : List M], F (∑ i, l i) = ∑ i, F i (l i)`.


theorem Prod.snd_surjective : ∀ {α : Type u_1} {β : Type u_2} [h : Nonempty α], Function.Surjective Prod.snd := by sorry

This theorem states that for any types `α` and `β`, given that `α` is nonempty, the second projection function `Prod.snd` is surjective. In other words, for any element `b` of type `β`, there exists a pair in the product type `α × β` such that 'b' is the second component of the pair. This is expressed by the function `Prod.snd`, which takes a pair and returns its second component.

For any nonempty type `α` and type `β`, the second projection function `Prod.snd` of `α × β` is surjective, i.e., for every `b` in `β`, there exists `(a, b)` in `α × β`.


theorem Quotient.mk_out : ∀ {α : Sort u_1} [inst : Setoid α] (a : α), Quotient.out ⟦a⟧ ≈ a := by sorry

The theorem `Quotient.mk_out` states that for any type `α` that is equipped with a setoid structure (an equivalence relation), and for any element `a` of `α`, when `a` is wrapped into an equivalence class using the `Quotient.mk` function (denoted as ⟦a⟧), and then one element is chosen from this equivalence class using the `Quotient.out` function, the chosen element is equivalent to the original element `a` under the equivalence relation of the setoid. In essence, it guarantees that when we pick out an element from an equivalence class, we always get something that is equivalent to the element we started with.

For any setoid (equivalence relation) on type `α`, and for any `a` in `α`, `Quotient.out (Quotient.mk a) = a` holds under the equivalence relation.


theorem Finset.mem_Iio :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, x ∈ Finset.Iio a ↔ x < a := by
  sorry

This theorem states that for any types `α`, which has preorder and locally finite order bot structure, and any elements `a` and `x` of type `α`, `x` is an element of the `Finset.Iio a` if and only if `x` is less than `a`. Here, `Finset.Iio a` refers to the finite set of elements `x` such that `x` is less than `a`.

For any type `α` with preorder and locally finite order bot structure, an element `x` lies in the finite set `Finset.Iio a` if and only if `x` is less than `a`.


/-- The Haudorff edistances of `s` to `t` and of `t` to `s` coincide.  -/
theorem EMetric.hausdorffEdist_comm :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α},
      EMetric.hausdorffEdist s t = EMetric.hausdorffEdist t s :=
  by sorry

This theorem, 'EMetric.hausdorffEdist_comm', states that the Hausdorff edistance between two sets 's' and 't' is symmetric. In more detail, for any type 'α' that forms a PseudoEMetricSpace, the Hausdorff edistance from set 's' to 't' is equal to the Hausdorff edistance from set 't' to 's'. The Hausdorff edistance is the smallest 'r' such that each set is contained in the 'r'-neighborhood of the other one.

For any sets $s$ and $t$ in a PseudoMetricSpace $\alpha$, the Hausdorff distance between $s$ and $t$ equals the Hausdorff distance between $t$ and $s$.


theorem CategoryTheory.Limits.IsZero.iff_id_eq_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (X : C), CategoryTheory.Limits.IsZero X ↔ CategoryTheory.CategoryStruct.id X = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.IsZero.iff_id_eq_zero` states that for all categories `C` which have zero morphisms, an object `X` is considered a zero object if and only if the identity morphism of `X` is equal to zero. In other words, an object in a category is zero if its identity morphism is a zero morphism.

In a category with zero morphisms, an object is a zero object if and only if its identity morphism equals the zero morphism.


theorem Finset.subset_insert : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), s ⊆ insert a s := by
  sorry

The theorem `Finset.subset_insert` states that for any type `α` that has decidable equality, for any element `a` of type `α`, and for any finite set `s` of elements of type `α`, the set `s` is a subset of the set that results from inserting the element `a` into `s`. In other words, it asserts that if you add an element to a set, the original set is always a subset of the new set.

For any type `α` with decidable equality, any element `a` in `α`, and any finite set `s` in `α`, `s` is a subset of `s.insert a`.


/-- A version of `Quotient.ind₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments.  -/
theorem Quotient.ind₂' :
    ∀ {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} {p : Quotient s₁ → Quotient s₂ → Prop},
      (∀ (a₁ : α) (a₂ : β), p (Quotient.mk'' a₁) (Quotient.mk'' a₂)) →
        ∀ (q₁ : Quotient s₁) (q₂ : Quotient s₂), p q₁ q₂ :=
  by sorry

The theorem `Quotient.ind₂'` states that for any two types `α` and `β` with setoids `s₁` and `s₂` respectively, and for any property `p` that relates an element of the quotient of `s₁` and an element of the quotient of `s₂`, if this property holds for all pairs of representatives `a₁` from `α` and `a₂` from `β` (where the representatives are converted to their respective quotient elements using `Quotient.mk''`), then the property holds for all elements in the respective quotient sets. In other words, it allows you to prove properties about elements of quotient sets by proving them about representative elements from the original sets.

If a property `p` holds for the representative pairs `(a₁, a₂)` of elements `[a₁ : α]` and `[a₂ : β]` in setoids `s₁` and `s₂`, then `p` holds for their respective quotient elements in `s₁ /= s₂`.


theorem Submonoid.gc_map_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f : F),
      GaloisConnection (Submonoid.map f) (Submonoid.comap f) :=
  by sorry

The theorem `Submonoid.gc_map_comap` states that for any types `M` and `N` that are instances of the `MulOneClass` (i.e., they carry binary multiplication and a one element), and any type `F` that is an instance of `FunLike F M N` and `MonoidHomClass F M N` (meaning `F` acts like a monoid homomorphism from `M` to `N`), then for any element `f : F`, there exists a Galois connection between the function `Submonoid.map f` and the function `Submonoid.comap f`. In other words, for any submonoid in `M`, mapping it to `N` through `f` and then taking the preimage back to `M` is an operation that is less than or equal to the original submonoid. Similarly, for any submonoid in `N`, taking its preimage in `M` through `f` and then mapping it back to `N` is an operation greater than or equal to the original submonoid.

For any instances `M` of `MulOneClass`, `N` of `MulOneClass`, `F` of `FunLike F M N` and `MonoidHomClass F M N`, the maps `Submonoid.map f : Submonoid M -> Submonoid N` and `Submonoid.comap f : Submonoid N -> Submonoid M` form a Galois connection.


theorem Nat.div_mul_le_self : ∀ (m n : ℕ), m / n * n ≤ m := by sorry

This theorem states that for all natural numbers `m` and `n`, the result of the integer division of `m` by `n` multiplied by `n` is always less than or equal to `m`. Essentially, it's asserting that the product of `n` and the floor division of `m` by `n` does not exceed `m`, which is a property of the floor division operation in mathematics.

For all natural numbers m and n, m ÷ n × n ≤ m. (Here, ÷ denotes integer division.)


theorem Nat.div_mul_cancel : ∀ {n m : ℕ}, n ∣ m → m / n * n = m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` divides `m` (denoted as `n ∣ m`), then dividing `m` by `n`, multiplying the result by `n`, we will get back `m`. This is a property of integer division, confirming that if a number `n` is a divisor of `m`, the 'div-then-multiply' operation on `m` with `n` will return `m`.

If `n` divides `m` in Lean, then `m = n * (m ∝ n)`. (Here, `m ∝ n` denotes the quotient of `m` by `n` in Lean's integer division.)


/-- This is the same as `IsOfFinOrder.orderOf_pos` but with one fewer explicit assumption since this
is automatic in case of a finite cancellative monoid. -/
theorem orderOf_pos : ∀ {G : Type u_1} [inst : LeftCancelMonoid G] [inst_1 : Finite G] (x : G), 0 < orderOf x := by
  sorry

This theorem states that for any object `x` of a given type `G`, under the conditions that `G` is a Left Cancellative Monoid and finite, the order of `x` is always positive. In other words, there exists a positive integer `n` such that `x ^ n = 1`. The theorem does not require an explicit assumption for this since a Left Cancellative Monoid is inherently finite.

In a finite Left Cancellative Monoid, every non-identity element has a finite order.


theorem Mathlib.Data.Subtype._auxLemma.5 : ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), (↑a ∈ S) = True := by
  sorry

The theorem `Mathlib.Data.Subtype._auxLemma.5` states that for any type `α` and any set `S` of type `α`, for every element `a` that is an element of `S` (specifically, `a` is a subtype of `α` such that `a` is in `S`), it is always true that `a` belongs to `S`. This theorem is essentially asserting the fundamental property of element-set membership: if an element is defined as belonging to a set, then it indeed belongs to that set.

For any type `α` and set `S` of `α`, any element `a` that is a subtype of `α` and is in `S`, belongs to `S`.


theorem Finset.max'_mem :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), Finset.max' s H ∈ s := by sorry

The theorem `Finset.max'_mem` states that for any non-empty finite set `s` in a linearly ordered type `α`, the maximum element of `s`, denoted by `Finset.max' s H`, belongs to `s` itself. Here, `H` is a proof confirming that the set `s` is non-empty.

For any non-empty finite set `s` in a linearly ordered type `α`, the maximum element of `s` is an element of `s`.


theorem dvd_antisymm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : Subsingleton αˣ] {a b : α}, a ∣ b → b ∣ a → a = b :=
  by sorry

This theorem, `dvd_antisymm`, states that for any type `α` that is an instance of the `CancelCommMonoidWithZero` class, meaning it behaves like a communicative monoid with a zero element but also has a cancellation property, and is also a `Subsingleton` of unit type `αˣ` (meaning it has at most one term), given any two elements 'a' and 'b' of type `α`, if 'a' divides 'b' and 'b' divides 'a', then 'a' must be equal to 'b'. This theorem embodies a property of divisibility in number systems that support these operations.

If `α` is a `CancelCommMonoidWithZero` type and `αˣ` is a subsingleton, then for all `a, b : α`, if `a` divides `b` and `b` divides `a`, then `a = b`.


theorem Subtype.image_preimage_coe : ∀ {α : Type u_1} (s t : Set α), Subtype.val '' (Subtype.val ⁻¹' t) = s ∩ t := by
  sorry

The theorem `Subtype.image_preimage_coe` states that for any types `α` and any sets `s` and `t` of type `α`, the image of the preimage of `t` under the function `Subtype.val` is equal to the intersection of `s` and `t`. In other words, if we first map elements from `s` to their corresponding elements in `t` using `Subtype.val`, and then map these elements back to their preimages in `s`, the resulting set is exactly the same as the intersection of `s` and `t`. This theorem is a statement about how the operations of taking an image and a preimage commute with taking an intersection of sets.

For any types `α` and sets `s` and `t` of type `α`, `Subtype.val''(s ∩ t) = s ∩ Subtype.image Subtype.val s t`.


theorem Finset.sup_eq_iSup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β),
      Finset.sup s f = ⨆ a ∈ s, f a :=
  by sorry

The theorem `Finset.sup_eq_iSup` states that for all types α and β, where β is a complete lattice, given a finite set `s` of type α and a function `f` from α to β, the supremum of the finite set `s` under function `f` is equal to the supremum over all elements `a` that belong to the set `s` of `f(a)`. In mathematical terms, it means `sup {a, b, c} f = ⨆ a ∈ {a, b, c}, f a` where `⨆` represents the supremum.

For any complete lattice β and a finite set s of type α with function f from α to β, the supremum of set s under function f equals the supremum of the images of individual set elements under f. That is, sup(s.map(f)) = ⨆ x ∈ s, f x.


theorem Real.sin_zero : Real.sin 0 = 0 := by sorry

This theorem states that the sine of zero in real numbers is zero. In other words, applying the real sine function `Real.sin` to the argument `0` results in `0`. This is consistent with the standard mathematical understanding of the sine function, i.e., $\sin(0) = 0$.

The real sine function evaluates to zero at zero: `Real.sin 0 = 0`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.33 :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α},
      (a⁻¹ ≤ b⁻¹) = (b ≤ a) :=
  by sorry

This theorem, named `_auxLemma.33` in the `Mathlib.Algebra.Order.Group.Defs` namespace, states that for any type `α` that forms a group and is partially ordered (with `≤` as the order relation), and satisfies the two specified covariance properties with respect to multiplication and the order relation, for any two elements `a` and `b` of type `α`, the statement "`a` inverse is less than or equal to `b` inverse" is equivalent to the statement "`b` is less than or equal to `a`". In mathematical terms, for any group $(\alpha, *, \leq)$ with covariance properties, $(a^{-1} \leq b^{-1})$ if and only if $(b \leq a)$ for all $a,b \in \alpha$.

For any group with covariance properties with respect to multiplication and order relation, `a`'s inverse is less than or equal to `b`'s inverse if and only if `b` is less than or equal to `a`.


/-- See `tsub_tsub_le` for an inequality.  -/
theorem tsub_tsub_cancel_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b : α} [inst : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a ≤ b → b - (b - a) = a :=
  by sorry

This theorem, `tsub_tsub_cancel_of_le`, states that for any type `α` that is an additive commutative semigroup, has a partial order, satisfies the existence of addition of less-than-or-equal-to relations, upholds covariance and contravariance, and supports subtraction with an order, if `a` and `b` are elements of `α` and `a` is less than or equal to `b`, then subtracting the difference of `b` and `a` from `b` equals `a`. In mathematical terms, if `a ≤ b` for some `a, b` in `α`, then `b - (b - a) = a`.

For any additive commutative semigroup `α` with a partial order, the subtraction of the difference of two elements `a` and `b` with `a ≤ b` is equal to `a`.


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

The theorem `Localization.induction_on` states that for any type `M` with a `CommMonoid` instance and any submonoid `S` of `M`, for any property `p` of the localization of `M` at `S`, if the property holds for all elements formed by the `Localization.mk` function (which takes a pair consisting of an element `y` of `M` and a member of `S`), then this property holds for all elements of the localization. Essentially, this theorem provides a method of induction for proving properties about all elements of the localization of a commutative monoid at a submonoid.

If a property holds for the images of all elements of a commutative monoid and their submonoid under the localization construction, then it holds for all elements of the localization.


theorem mul_lt_mul_right' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LT α]
      [i : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] {b c : α},
      b < c → ∀ (a : α), b * a < c * a :=
  by sorry

The theorem `mul_lt_mul_right'` states that for any type `α` that has a multiplication operation (`Mul α`) and a less than operation (`LT α`) and satisfies a certain covariance property, then given any three elements `a`, `b`, and `c` of `α` such that `b < c`, we have `b * a < c * a`. In other words, in this mathematical structure, if `b` is less than `c`, then multiplying `b` and `c` by the same factor `a` on the right maintains the inequality.

For any type `α` with multiplication `(*`) and order `<`, if `b < c` then `b * a < c * a`.


PartialHomeomorph.continuousAt

/-- A partial homeomorphism is continuous at any point of its source  -/
theorem PartialHomeomorph.continuousAt :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : X}, x ∈ e.source → ContinuousAt (↑e) x :=
  by sorry

This theorem states that a partial homeomorphism is continuous at any point in its source. More specifically, for all topological spaces `X` and `Y`, and for any partial homeomorphism `e` from `X` to `Y`, if a point `x` is in the source of `e`, then `e` is continuous at `x`. In mathematical terms, this means that when `x` tends to `x₀`, `e(x)` will tend to `e(x₀)`, where `x₀` is any point from the source of `e`.

A partial homeomorphism from topological space X to Y is continuous at any point x in X if x is in the domain of the function.


theorem continuous_finset_sum :
    ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
      [inst_2 : AddCommMonoid M] [inst_3 : ContinuousAdd M] {f : ι → X → M} (s : Finset ι),
      (∀ i ∈ s, Continuous (f i)) → Continuous fun a => Finset.sum s fun i => f i a :=
  by sorry

This theorem states that for any type `ι`, type `M` and type `X` where `M` has an addition operation and a topology, `X` has a topology, and we have a function `f : ι → X → M`. Given a finite set `s` of `ι`, if for every element `i` in `s`, the function `f(i)` is continuous, then the function that maps every `a` in `X` to the sum (over the set `s`) of `f(i)(a)` is also continuous. This essentially says that the sum of a finite number of continuous functions, where the sum is defined in the way given by the `Finset.sum` definition, is also a continuous function.

Given types `ι`, `M` with an addition operation and a topology, and `X` with a topology, if for every `i` in `ι` and `x` in `X`, the function `f(i) : X → M` is continuous, then the function `∫ i in s, f i` defined as the sum `(Finset.sum s) (λ i, f i)`, is also continuous.


theorem List.filter_cons_of_neg :
    ∀ {α : Type u_1} {p : α → Bool} {a : α} (l : List α), ¬p a = true → List.filter p (a :: l) = List.filter p l := by
  sorry

The theorem `List.filter_cons_of_neg` states that for any type `α`, any predicate function `p` of type `α → Bool`, any element `a` of type `α`, and any list `l` of type `List α`, if `p a` is not true, then the result of filtering the list `a :: l` (the list `l` with `a` added at the front) with the predicate `p` is the same as filtering the list `l` with `p`. This essentially shows that if an element doesn't satisfy a given predicate, then filtering a list with or without that element will yield the same result.

If `p(a)` is false, then filtering list `a :: l` with predicate `p` equals filtering list `l` with `p`.


theorem Set.compl_subset_comm : ∀ {α : Type u} {s t : Set α}, sᶜ ⊆ t ↔ tᶜ ⊆ s := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of `α`, the complement of `s` is a subset of `t` if and only if the complement of `t` is a subset of `s`. In other words, it articulates the commutativity of the subset relation between the complements of two sets.

For any type `α` and sets `s` and `t` of `α`, the complements `complement s` and `complement t` are equal if and only if sets `s` and `t` are subsets of each other. (Note: In Lean, `complement s` denotes the set of elements not in `s`.)


theorem nsmul_mem :
    ∀ {M : Type u_4} {A : Type u_5} [inst : AddMonoid M] [inst_1 : SetLike A M] [inst_2 : AddSubmonoidClass A M] {S : A}
      {x : M}, x ∈ S → ∀ (n : ℕ), n • x ∈ S :=
  by sorry

This theorem states that for any two types `M` and `A`, where `M` is an additive monoid and `A` behaves like a set of elements of `M` (`SetLike A M`), and `A` has the properties of an additive submonoid of `M` (`AddSubmonoidClass A M`), then for any `S` of type `A` and any element `x` of type `M`, if `x` belongs to `S`, then the n-fold addition of `x` (denoted `n • x`) also belongs to `S` for any non-negative integer `n`. In simpler terms, it's saying that adding an element to itself any number of times in an additive submonoid results in a value that is also in that submonoid.

For any additive submonoid `A` of an additive monoid `M`, if `x` is an element of `A` and `n` is a non-negative integer, then `n • x` is also an element of `A`.


theorem Mathlib.NumberTheory.Divisors._auxLemma.12 : ∀ {n m : ℕ}, (n ∈ Nat.divisors m) = (n ∣ m ∧ m ≠ 0) := by sorry

The theorem `Mathlib.NumberTheory.Divisors._auxLemma.12` states that for any two natural numbers `n` and `m`, `n` is a divisor of `m` (i.e., `n` is in the set of divisors of `m`) if and only if `n` divides `m` and `m` is not equal to zero. This theorem essentially provides a criterion to test whether a number is a divisor of another number.

A natural number `n` is a divisor of another natural number `m` if and only if `n` divides `m` and `m` is nonzero.


theorem Array.size_push : ∀ {α : Type u} (a : Array α) (v : α), Array.size (Array.push a v) = Array.size a + 1 := by
  sorry

The theorem `Array.size_push` states that for any type `α`, any array `a` of type `α`, and any element `v` of type `α`, the size of the array obtained by pushing the element `v` onto the end of `a` is equal to the size of the original array `a` plus one. This reflects the expected behavior of the `push` operation in increasing the size of the array by one.

For any type `α` and array `a` of length `n` over `α`, the size of the array obtained by appending an element to `a` is `n + 1`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.23 :
    ∀ {V : Type u} (G : SimpleGraph V) {v w : V}, (s(v, w) ∈ SimpleGraph.edgeSet G) = G.Adj v w := by sorry

This theorem states that for any graph `G` of type `SimpleGraph V`, where `V` is any type (representing the vertices), and any two vertices `v` and `w` of this graph, the pair `s(v, w)` (representing an edge) is a member of the edge set of `G`, denoted as `SimpleGraph.edgeSet G`, if and only if `v` and `w` are adjacent in `G`, denoted as `G.Adj v w`. In other words, an edge, represented by the pair of vertices `(v, w)`, exists in the graph `G` if and only if the vertices `v` and `w` are adjacent in `G`.

For any simple graph G and vertices v, w of type V, the pair (v, w) is in the edge set of G if and only if v and w are adjacent in G.


theorem PosNum.cast_to_nat : ∀ {α : Type u_1} [inst : AddMonoidWithOne α] (n : PosNum), ↑↑n = ↑n := by sorry

This theorem, `PosNum.cast_to_nat`, states that for all types `α` which belong to the `AddMonoidWithOne` class, casting a positive number `n` to `α` via two successive upcasts (first to natural numbers, then to `α`) is the same as casting `n` directly to `α`. Here, `PosNum` refers to a positive number and `↑↑n` and `↑n` denote the double and single casting processes respectively.

For all types `α` in the `AddMonoidWithOne` class, the double upcast of a positive number `n` from natural numbers to `α` is equal to the single upcast of `n` directly to `α`. In mathematical notation, `↑↑n = ↑n : ℕ → α`.


theorem WellFounded.not_lt_min :
    ∀ {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : Set.Nonempty s) {x : α},
      x ∈ s → ¬r x (WellFounded.min H s h) :=
  by sorry

The theorem `WellFounded.not_lt_min` states that for any type `α`, a binary relation `r` on `α`, and any nonempty set `s` of `α`, it is not possible for any element `x` in `s` to be less than the minimum element of `s` according to the well-founded relation `r`. In other words, no element in the set `s` can be less than the minimum element of `s` under the ordering defined by `r`.

For any type `α`, binary relation `r` on `α`, and nonempty `s ∈ α`, there is no `x ∈ s` such that `x < min s` according to the well-founded relation `r`.


theorem AddSubsemigroup.gc_map_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : AddHom M N),
      GaloisConnection (AddSubsemigroup.map f) (AddSubsemigroup.comap f) :=
  by sorry

The theorem `AddSubsemigroup.gc_map_comap` states that for any types `M` and `N` equipped with an additive structure (i.e., instances of `Add M` and `Add N`), and for any additive semigroup homomorphism `f` from `M` to `N`, there exists a Galois connection between the map operation and the co-map operation on additive subsemigroups. In more detail, the map operation `AddSubsemigroup.map f` and the co-map operation `AddSubsemigroup.comap f` form a Galois connection. This means that for any additive subsemigroup `S` of `M` and `T` of `N`, the image of `S` under `f` is a subset of `T` if and only if `S` is a subset of the preimage of `T` under `f`.

For any additive semigroup homomorphism `f` between additive types `M` and `N`, the map and co-map operations on additive subsemigroups form a Galois connection.


theorem add_lt_of_le_of_neg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      b ≤ c → a < 0 → b + a < c :=
  by sorry

This theorem, `add_lt_of_le_of_neg`, states that given a type `α` which has an addition operation and a zero element (`AddZeroClass α`), also has a preorder relationship (`Preorder α`), and is a Covariant class where addition of two elements `x` and `x_1` results in a relationship `x < x_1`, then for any three elements `a`, `b`, and `c` of type `α`, if `b` is less than or equal to `c` (`b ≤ c`) and `a` is less than zero (`a < 0`), it follows that `b + a` is less than `c` (`b + a < c`). This captures an essential property of ordered additive structures.

If `α` is an additive preordered type with `a < 0` and `b ≤ c`, then `b + a < c`.


theorem CategoryTheory.mono_of_mono_fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z}
      [inst_1 : CategoryTheory.Mono h], CategoryTheory.CategoryStruct.comp f g = h → CategoryTheory.Mono f :=
  by sorry

The theorem `CategoryTheory.mono_of_mono_fac` states that for any category `C` with objects `X`, `Y`, and `Z`, and morphisms `f : X ⟶ Y`, `g : Y ⟶ Z`, and `h : X ⟶ Z`, if the composition of `f` and `g` is equal to `h` and `h` is a monomorphism (i.e., injective), then `f` is also a monomorphism. In other words, if we have a monomorphism from `X` to `Z` that can be factored as the composition of two morphisms `f` and `g`, then `f` is a monomorphism as well.

If `h : X ⟶ Z` is a monomorphism and `h = g ∘ f` for morphisms `f : X ⟶ Y` and `g : Y ⟶ Z` in a category `C`, then `f` is also a monomorphism.


theorem Valuation.map_add :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
      (x y : R), v (x + y) ≤ max (v x) (v y) :=
  by sorry

This theorem states that for any ring `R` and any linearly ordered commutative monoid with zero `Γ₀`, if `v` is a valuation from `R` to `Γ₀`, then the valuation of the sum of any two elements `x` and `y` from `R` is less than or equal to the maximum of the valuations of `x` and `y`. In mathematical terms, this can be written as: for all `x, y ∈ R`, `v(x + y) ≤ max(v(x), v(y))`. This is a property of valuations in valuation theory, a branch of algebra that studies functions that measure 'size' or 'order of magnitude' of elements in a ring.

For any ring `R`, any linearly ordered commutative monoid with zero `Γ₀`, and any valuation `v` from `R` to `Γ₀`, `v(x + y) ≤ max(v(x), v(y))` for all `x, y ∈ R`.


theorem lt_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {a b : α},
      a < b → ∀ᶠ (x : α) in nhds b, a < x :=
  by sorry

This theorem states that for any types `α`, which is a topological space with a preorder and order topology, and any two elements `a` and `b` of type `α`, if `a` is less than `b`, then there exists a neighborhood around `b` such that every element `x` in this neighborhood satisfies the condition that `a` is less than `x`. This is a result in order topology, which connects the concepts of order and topology in a consistent way.

For any topological space with a preorder endowed with order topology, if `a` is less than `b`, then there exists a neighborhood of `b` where `a` is less than every element.


theorem Mathlib.Order.Filter.Basic._auxLemma.83 :
    ∀ {α : Type u} {a : Set α} {p : α → Prop}, (∀ᶠ (x : α) in Filter.principal a, p x) = ∀ x ∈ a, p x := by sorry

This theorem states that for any type `α`, any set `a` of type `α`, and any predicate `p` acting on `α`, the statement "for all `x` in `α` eventually in the filter generated by the principal set `a`, `p` holds" is equivalent to "for all `x` in the set `a`, `p` holds". In simpler words, this theorem relates properties that hold eventually in a filter generated by a set (i.e., on all elements in the set and possibly more) to properties that hold on all elements in the set itself.

The theorem asserts that for any type `α`, set `a` of `α`, and predicate `p` on `α`, the filter generated by `a` eventually includes all elements of `α` satisfying `p` if and only if all elements of `a` satisfy `p`.


theorem Bool.forall_bool : ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) ↔ p false ∧ p true := by sorry

This theorem states that for any property `p` that can be applied to boolean values (`Bool → Prop`), the property holds for all boolean values if and only if the property holds for both `false` and `true`. The theorem is essentially stating that a universal quantification over all booleans is equivalent to checking the property for the two possible boolean values.

For any property `p` of boolean values, `p` is universally true if and only if `p false` and `p true` hold.


theorem Set.image2_union_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t : Set β},
      Set.image2 f (s ∪ s') t = Set.image2 f s t ∪ Set.image2 f s' t :=
  by sorry

This theorem is about the image of a binary function with respect to set operations. Specifically, it states that for any types `α`, `β`, and `γ`, and any binary function `f` from `α` and `β` to `γ`, if `s` and `s'` are two subsets of `α` and `t` is a subset of `β`, then the image of the function `f` over the union of `s` and `s'` and `t` is equal to the union of the image of the function `f` over `s` and `t` and the image of the function `f` over `s'` and `t`. In mathematical terms, this can be written as `f((s ∪ s') × t) = f(s × t) ∪ f(s' × t)`.

For any sets `A, B, C`, binary function `f : A × B → C`, and subsets `S, S' ⊆ A` and `T ⊆ B`, `f(S × T) = f(S × {}) ∪ f(S' × T)`. (Note: The empty set `{}` in the second term is implied by the context of sets `A` and `B`).


theorem Ideal.add_mem : ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {a b : α}, a ∈ I → b ∈ I → a + b ∈ I := by
  sorry

This theorem states that for any type `α` that is a `Semiring`, and any `Ideal` `I` of `α`, if `a` and `b` are elements of `α` and both belong to the `Ideal` `I`, then the sum of `a` and `b` also belongs to the `Ideal` `I`. In other words, the sum of any two elements in an ideal is also in the ideal, which is a fundamental property of ideal in ring theory.

For any semiring `α` and ideal `I` of `α`, if `a`, `b` ∈ `I`, then `a + b` ∈ `I`.


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

This theorem, `eq_inv_of_mul_eq_one_left`, states that for any type `G` that is a division monoid, given any two elements `a` and `b` of this type, if the product of `a` and `b` equals one (`1`), then `a` must be the multiplicative inverse of `b` (notated as `b⁻¹`). In other words, in a division monoid, if two elements multiply to give the multiplicative identity, then each element is the multiplicative inverse of the other.

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


EquivLike.surjective

theorem EquivLike.surjective :
    ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E), Function.Surjective ⇑e := by sorry

The theorem `EquivLike.surjective` states that for any types `E`, `α`, and `β`, given that there exists an equivalence relation `iE` between `α` and `β` represented by `E`, then for any element `e` of type `E`, the function that applies `e` is surjective. In other words, every element in `β` is the image of some element in `α` under the function `e`.

Given an equivalence relation `iE` between types `α` and `β` represented by `E`, the function that maps each equivalence class to its representative element is surjective.


theorem Multiset.cons_bind :
    ∀ {α : Type u_1} {β : Type v} (a : α) (s : Multiset α) (f : α → Multiset β),
      Multiset.bind (a ::ₘ s) f = f a + Multiset.bind s f :=
  by sorry

The theorem `Multiset.cons_bind` states that for any types `α` and `β`, any element `a` of type `α`, any multiset `s` of type `α`, and any function `f` from `α` to `Multiset β`, binding the function `f` to the multiset formed by consing `a` onto `s` (denoted `(a ::ₘ s)`) is equivalent to the union of the multiset resulting from applying `f` to `a` and the multiset resulting from binding `f` to `s`. In other words, we can distribute the bind operation over the addition (union) of multisets.

For any types `α` and `β`, any element `a` of type `α`, any multiset `s` of type `α`, and any function `f` from `α` to `Multiset β`, `(f a) ⊎ (f '' s) = (f) '' (a ::ₘ s)`.


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

This theorem states that for any type `G₀` that has a structure of a group with zero, for any non-zero element `a` of type `G₀` and any `b` of type `G₀`, the inverse of `a` multiplied by the product of `a` and `b` equals `b`. In mathematical terms, it states that if $a$ is not zero, then $a^{-1}(ab) = b$. This is a fundamental property of groups where the multiplication of an element by its inverse results in the identity, in this case the identity being such that multiplying any element by it leaves the element unchanged.

For any group with zero `G₀` and non-zero element `a` in `G₀`, `a`'s inverse multiplied by the product of `a` and any element `b` in `G₀` equals `b`. In mathematical notation, $a^{-1}(ab) = b$.


theorem Homeomorph.map_nhds_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (x : X),
      Filter.map (⇑h) (nhds x) = nhds (h x) :=
  by sorry

This theorem states that for any two types `X` and `Y`, which are equipped with topological space structures, given a homeomorphism `h` from `X` to `Y` and a point `x` in `X`, the application of the filter map to the neighborhood filter of `x` in `X` under the homeomorphism `h` is equal to the neighborhood filter of the image of `x` under `h` in `Y`. In mathematical terms, this can be understood as the property that homeomorphisms preserve the topology, in this case, specifically the neighborhood structure around a point.

Given two topological spaces `(X,τX)` and `(Y,τY)`, a homeomorphism `h : X ↔ Y`, and a point `x ∈ X`, the neighborhood filters `filter.basic τX x` and `filter.basic τY (h x)` are equal.


Continuous.tendsto'

/-- A version of `Continuous.tendsto` that allows one to specify a simpler form of the limit.
E.g., one can write `continuous_exp.tendsto' 0 1 exp_zero`.  -/
theorem Continuous.tendsto' :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f → ∀ (x : X) (y : Y), f x = y → Filter.Tendsto f (nhds x) (nhds y) :=
  by sorry

This theorem, `Continuous.tendsto'`, states that for any types `X` and `Y` equipped with topological spaces and any function `f : X → Y` that is continuous, if `y` is the value of `f` at `x`, then the function `f` tends to `y` as `x` tends to its neighborhood. In other words, for every neighborhood of `y`, the preimage under `f` is a neighborhood of `x`. This is a more specific form of the `Continuous.tendsto` theorem that allows for a simpler way to specify the limit of a function at a point. For example, it enables the expression `continuous_exp.tendsto' 0 1 exp_zero` to describe the limit of the exponential function at point 0 is 1.

Given types `X` and `Y` with topological spaces, and a continuous function `f : X → Y`: for every neighborhood `V` of `y` in `Y`, there exists a neighborhood `U` of `x` in `X` such that `f(U) ⊆ V`.


theorem Rat.cast_one : ∀ {α : Type u_3} [inst : DivisionRing α], ↑1 = 1 := by sorry

This theorem states that for any type `α` which is a Division Ring, casting the rational number `1` to this type results in the number `1` in that type. Simply put, in any Division Ring, the representation of the rational number `1` is also `1`.

In any division ring, the rational number 1 is equal to its multiplicative identity of the same type.


/-- **Alias** of `Int.natCast_ne_zero`. -/
theorem Int.coe_nat_ne_zero : ∀ {n : ℕ}, ↑n ≠ 0 ↔ n ≠ 0 := by sorry

This theorem, `Int.coe_nat_ne_zero`, is an alias of `Int.natCast_ne_zero`. It states that for all natural numbers `n`, the coerced value of `n` to an integer is not equal to zero if and only if `n` is not equal to zero. In other words, it provides a condition to check whether a natural number is not zero by checking whether its integer representation is not zero.

For any natural number n, the coerced integer of n is not equal to zero if and only if n is not equal to zero.


theorem mul_lt_mul_of_lt_of_le :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b c d : α},
      a < b → c ≤ d → a * c < b * d :=
  by sorry

The theorem `mul_lt_mul_of_lt_of_le` states that, for all elements `a`, `b`, `c`, and `d` of a type `α` that is equipped with a multiplication operation, a preorder (reflexive and transitive binary relation), and satisfies two covariant class conditions on multiplication (one for the relation `≤` and another for the relation `<` swapped), if `a` is less than `b` and `c` is less than or equal to `d`, then the product `a * c` is less than the product `b * d`. This theorem captures a multiplicative property of ordered structures.

For all types `α` equipped with a multiplication operation and a preorder `≤` satisfying certain covariant conditions, if `a ≤ b` and `c ≤ d`, then `a * c ≤ b * d`.


/-- A specialized ext lemma for equality of sigma types over an indexed subtype.  -/
theorem Sigma.subtype_ext :
    ∀ {α : Type u_1} {β : Type u_7} {p : α → β → Prop} {x₀ x₁ : (a : α) × Subtype (p a)},
      x₀.fst = x₁.fst → ↑x₀.snd = ↑x₁.snd → x₀ = x₁ :=
  by sorry

This theorem, `Sigma.subtype_ext`, states that for any two sigma types `x₀` and `x₁`, that are formed over an indexed subtype, if the first elements (`fst`) of `x₀` and `x₁` are equal, and the underlying value (`↑`) of the second elements (`snd`) of both are equal, then `x₀` and `x₁` are themselves equal. Here, `α` and `β` are arbitrary types, and `p` is a property relating an element of type `α` to an element of type `β`. The sigma types `x₀` and `x₁` are tuples consisting of an `α` and a subtype of `β` satisfying property `p`.

Given sigma types `(α, β × σ₀)` and `(α, β × σ₁)` formed over indices satisfying `σ₀ = σ₁`, `α × fst x₀ = α × fst x₁`, and `↑snd x₀ = ↑snd x₁`, then `x₀ = x₁`.


theorem MeasureTheory.VectorMeasure.not_measurable :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      (v : MeasureTheory.VectorMeasure α M) {i : Set α}, ¬MeasurableSet i → ↑v i = 0 :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.not_measurable` states that for any type `α`, given a measurable space `m` on `α`, any type `M` which is a commutative additive monoid and also a topological space, and any vector measure `v` from `α` to `M`, if a set `i` of type `α` is not a measurable set, then the application of the vector measure `v` to this set `i` is equal to zero. In other words, the vector measure of a non-measurable set is zero.

If `i` is a non-measurable subset of a measurable space `m` on type `α`, then the vector measure `v` from `α` to the commutative additive monoid and topological space `M` of any measurable function `v` is equal to the zero vector when applied to `i`.


theorem lt_or_gt_of_ne : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, a ≠ b → a < b ∨ a > b := by sorry

This theorem, `lt_or_gt_of_ne`, states that for any given type `α` that has a linear order, for any two elements `a` and `b` of that type, if `a` is not equal to `b`, then either `a` is less than `b` or `a` is greater than `b`. In other words, in any ordered set, any two distinct elements can be compared in such a way that one is strictly less or strictly greater than the other.

For any type `α` with a linear order, if `a` and `b` are distinct elements of `α`, then `a < b` or `b < a`.


theorem Function.comp_id : ∀ {α : Sort u₁} {β : Sort u₂} (f : α → β), f ∘ id = f := by sorry

This theorem, called `Function.comp_id`, states that for all types `α` and `β`, and for any function `f` from `α` to `β`, the composition of `f` with the identity function is equal to `f` itself. In mathematical notation, if `f : α → β`, then `f ∘ id = f`. This is a restatement of the identity law for functions.

For all types `α` and functions `f : α → β`, the composition of `f` with the identity function is equal to `f`: `f ∘ id = f`.


theorem le_min : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b := by sorry

This theorem, `le_min`, establishes a certain property of the `min` function in the context of linearly ordered types. Given any type `α` that has a linear order, and any three elements `a`, `b`, and `c` of this type, if `c` is less than or equal to `a` and `c` is less than or equal to `b`, then `c` is also less than or equal to the minimum of `a` and `b`. Essentially, this is a formalization of the intuitive understanding of the minimum function and less-than-or-equal-to relation in mathematics.

If `α` is a linearly ordered type and `a`, `b`, `c` are elements of `α` with `c` less than or equal to both `a` and `b`, then `c` is less than or equal to the minimum of `a` and `b` (i.e., `min a b`).


/-- Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity.  -/
theorem ClosureOperator.le_closure :
    ∀ {α : Type u_1} [inst : PartialOrder α] (c : ClosureOperator α) (x : α), x ≤ c x := by sorry

This theorem states that for any type `α` under a partial order, and for any closure operator `c` on `α`, every element `x` of `α` is less than or equal to its closure (`c x`). This property is sometimes referred to as extensivity or inflationarity. In mathematical notation, this can be written as `∀x ∈ α, x ≤ c(x)`.

For any type `α` under a partial order and closure operator `c` on `α`, every element `x` satisfies `x ≤ c(x)`.


/-- If a vector space (or module) has a finite basis, then its dimension (or rank) is equal to the
cardinality of the basis.  -/
theorem FiniteDimensional.finrank_eq_card_basis :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] {ι : Type w} [inst_4 : Fintype ι],
      Basis ι R M → FiniteDimensional.finrank R M = Fintype.card ι :=
  by sorry

The theorem `FiniteDimensional.finrank_eq_card_basis` states that for any ring `R`, any additive commutative group `M`, and any type `ι` with a finite number of elements, if `M` is a module over `R` and there exists a basis of `M` indexed by `ι`, then the rank (also known as the dimension) of the module `M` is equal to the number of elements in `ι`. In other words, the dimension of a vector space (or the rank of a module) over a ring is equal to the number of elements in a finite basis of the vector space (or module). The `StrongRankCondition R` assumption assures that the rank of any free module over `R` is well-defined.

For any ring `R`, additive commutative group `M`, and finite type `ι`, if `M` is a free `R`-module with a basis of size `|ι|`, then the rank of `M` equals `|ι|`.


/-- If the oriented angle between two vectors is `π / 2`, the inner product of those vectors
is zero.  -/
theorem Orientation.inner_eq_zero_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y = ↑(Real.pi / 2) → ⟪x, y⟫_ℝ = 0 :=
  by sorry

This theorem states that if the oriented angle between two vectors in a real 2-dimensional inner product space is π/2, then the inner product of these vectors is zero. In other words, if two vectors are oriented at a right angle to each other, their inner product (or dot product) is zero, which is a fundamental characteristic of orthogonal vectors in Euclidean space. The orientation of the space and the two vectors are taken as inputs for this theorem.

In a real 2-dimensional inner product space, the inner product of two vectors with an oriented angle of π/2 (a right angle) is zero.


theorem Int.cast_le : ∀ {α : Type u_3} [inst : OrderedRing α] [inst_1 : Nontrivial α] {m n : ℤ}, ↑m ≤ ↑n ↔ m ≤ n := by
  sorry

This theorem, `Int.cast_le`, states that for any type `α` that is an ordered ring and nontrivial, the inequality between two integers `m` and `n` holds true if and only if the same inequality holds true when these integers are cast to the type `α`. In other words, casting does not change the order of the integers.

For any nontrivial ordered ring type `α`, the relation `m < n` holds if and only if the relation between the integer casts `α m` and `α n` also holds.


theorem Multiset.map_id : ∀ {α : Type u_1} (s : Multiset α), Multiset.map id s = s := by sorry

The theorem `Multiset.map_id` states that for any multiset `s` of any type `α`, applying the identity function `id` to each element of `s` via the function `Multiset.map` leaves the multiset unchanged. In other words, if we map each element of a multiset to itself, the resulting multiset is the same as the original. This is a multiset analogue of the familiar list property that mapping the identity over a list does not change the list.

For any multiset `s` of type `α`, `Multiset.map id s = s`.


theorem inner_smul_right :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y : E) (r : 𝕜), ⟪x, r • y⟫_𝕜 = r * ⟪x, y⟫_𝕜 :=
  by sorry

This theorem, named `inner_smul_right`, states that for any inner product space `E` over a field `𝕜` and any two vectors `x` and `y` from this space and a scalar `r` from the field, the inner product of `x` and the scalar multiplication of `r` and `y` is equal to the scalar `r` multiplied by the inner product of `x` and `y`. In terms of mathematics, it can be written as ⟪x, r • y⟫_𝕜 = r * ⟪x, y⟫_𝕜. This theorem essentially captures one of the key properties of inner product spaces related to scalar multiplication.

For any inner product space, the inner product of a vector with a scalar times another vector is equal to the scalar times the inner product of the two vectors.


theorem Set.injOn_of_injective :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ (s : Set α), Set.InjOn f s := by sorry

This theorem states that for any two types `α` and `β`, and any function `f` from `α` to `β`, if the function `f` is injective (meaning that if `f x = f y` then `x = y`), then `f` is also injective on any subset `s` of `α`. In other words, the restriction of the function `f` to the subset `s` retains the injective property. This is expressed formally as `Set.InjOn f s`, meaning for any two elements `x₁` and `x₂` in the subset `s`, if `f x₁ = f x₂` then `x₁ = x₂`.

If `f` is an injective function from type `α` to type `β`, then `f` restriction to any subset `s` of `α` remains injective.


theorem Iff.not_right : ∀ {a b : Prop}, (¬a ↔ b) → (a ↔ ¬b) := by sorry

This theorem, `Iff.not_right`, states that for any two propositions `a` and `b`, if the negation of `a` is logically equivalent to `b`, then `a` is logically equivalent to the negation of `b`. In other words, if `¬a` is the same as `b` (meaning `¬a` implies `b` and `b` implies `¬a`), then `a` must be the same as `¬b` (meaning `a` implies `¬b` and `¬b` implies `a`).

If `a` is logically equivalent to the negation of `b`, then `b` is logically equivalent to the negation of `a`.


LucasLehmer.X.ext

theorem LucasLehmer.X.ext : ∀ {q : ℕ+} {x y : LucasLehmer.X q}, x.1 = y.1 → x.2 = y.2 → x = y := by sorry

The theorem `LucasLehmer.X.ext` states that for any positive natural number `q` and any two elements `x` and `y` of the ring `LucasLehmer.X q` (which is defined as the Cartesian product of ℤ/qℤ and ℤ/qℤ), if the first component of `x` is equal to the first component of `y` and the second component of `x` is equal to the second component of `y`, then `x` is equal to `y`. In other words, two elements of the ring `LucasLehmer.X q` are equal if and only if their corresponding components are equal.

In the ring of Lucas-Lehmer quadrates `LucasLehmer.X q`, elements with equal first and second components are equal.


theorem LinearMap.map_neg :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] {module_M : Module R M} {module_M₂ : Module S M₂}
      {σ : R →+* S} (f : M →ₛₗ[σ] M₂) (x : M), f (-x) = -f x :=
  by sorry

This theorem states that for any semirings `R` and `S`, any additive commutative groups `M` and `M₂`, any modules `M` over `R` and `M₂` over `S`, any ring homomorphism `σ` from `R` to `S`, any linear map `f` from `M` to `M₂` under the homomorphism `σ`, and any element `x` in `M`, the image of the negation of `x` under `f` is the negation of the image of `x` under `f`. This is a property of linear maps that connects them to the operation of negation in the underlying groups and modules.

For any semirings R and S, additive commutative groups M and M₂, modules M over R and M₂ over S, ring homomorphism σ from R to S, linear map f from M to M₂, and element x in M, we have ∣∣f(−x)∣∣ = ∣∣−f(x)∣∣.


theorem Computation.mem_unique : ∀ {α : Type u} {s : Computation α} {a b : α}, a ∈ s → b ∈ s → a = b := by sorry

The theorem `Computation.mem_unique` states that for any type `α`, given a computation `s` of type `α`, and any two elements `a` and `b` of type `α`, if `a` is in `s` and `b` is in `s`, then `a` must be equal to `b`. This ensures the uniqueness of the element within a computation, i.e., a computation can only yield a unique result.

For any computation `s` and type `α`, if `α` contains elements `a` and `b` such that `a` is in `s` and `b` is in `s`, then `a = b`.


theorem Finset.val_le_iff : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁.val ≤ s₂.val ↔ s₁ ⊆ s₂ := by sorry

This Lean theorem, `Finset.val_le_iff`, states that for all types `α` and for any two finite sets (`Finset`) `s₁` and `s₂` of this type, the multiset values (`val`) of `s₁` is less than or equal to the multiset values of `s₂` if and only if `s₁` is a subset of `s₂`. In other words, a finite set is considered less than or equal to another finite set in terms of their respective multisets if and only if the first set is contained within the second set.

For any type `α` and finite sets `s₁` and `s₂` of type `Finset α`, `s₁ ⊆ s₂` if and only if `Val s₁ ≤ Val s₂`, where `Val` denotes the multiset value function.


theorem continuous_sigmaMk :
    ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, Continuous (Sigma.mk i) := by
  sorry

This theorem states that for any index type `ι`, any family `σ` of types indexed by `ι`, and any index `i` of type `ι`, if each type `σ i` in the family is equipped with a topological space structure, then the function `Sigma.mk i`, which constructs a sigma type (dependent sum type) instance from an element of type `σ i`, is continuous. In other words, the mapping from a point in the space `σ i` to the corresponding point in the sigma type is compatible with the topology.

For any index type `ι`, any family of topological spaces `(σ i : ι → Type)`, and any function `σ : Π i, ι → σ i → Σ i (σ i)`, the evaluation map `ev : ∀ i, σ i × σ i → σ i` is continuous.


theorem PNat.dvd_iff : ∀ {k m : ℕ+}, k ∣ m ↔ ↑k ∣ ↑m := by sorry

This theorem states that for any two positive natural numbers `k` and `m`, `k` divides `m` if and only if the coercive of `k` (i.e., `k` treated as a natural number) divides the coercive of `m` (i.e., `m` treated as a natural number). It is a way to connect the divisibility relationship in the domain of positive natural numbers with that in the domain of natural numbers.

For all natural numbers `k` and `m`, `k` divides `m` if and only if the natural number `k` divides the natural number `m`.


theorem AddSubmonoid.gc_map_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F),
      GaloisConnection (AddSubmonoid.map f) (AddSubmonoid.comap f) :=
  by sorry

The theorem `AddSubmonoid.gc_map_comap` states that for any types `M` and `N` that are additive monoids (i.e., they have a zero and an addition operation), and any function-like `f` that is an additive monoid homomorphism from `M` to `N`, there is a Galois connection between the map of an additive submonoid along `f` and the preimage of an additive submonoid along `f`. In other words, for an additive submonoid `S` of `M` and `T` of `N`, the image of `S` under `f` is a submonoid of `T` if and only if `S` is a submonoid of the preimage of `T` under `f`. A Galois connection is a relationship between two order-preserving functions that captures the idea of an adjoint functor in category theory.

For additive monoids M and N, and additive monoid homomorphism f from M to N, there is a Galois connection between the image of additive submonoids of M under f and the preimage of additive submonoids of N under f.


/-- The composition of a `C^n` function on a domain with a `C^n` function is `C^n`.  -/
theorem ContDiff.comp_contDiffOn :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {s : Set E} {g : F → G} {f : E → F},
      ContDiff 𝕜 n g → ContDiffOn 𝕜 n f s → ContDiffOn 𝕜 n (g ∘ f) s :=
  by sorry

This theorem states that if we have a continuously differentiable function `g` of any degree `n`, and another function `f` that is continuously differentiable of the same degree `n` on a set `s`, then the composition of `g` and `f` (written as `g ∘ f`) is also continuously differentiable of degree `n` on that same set `s`. This is formalized over a nontrivially normed field `𝕜` and normed add commutative groups `E`, `F`, `G` which are also normed spaces over `𝕜`. The degree `n` of differentiability could be any natural number or infinity.

If `g` is a continuously differentiable function of degree `n` and `f` is another continuously differentiable function of the same degree `n` defined on a set `s`, then the composition `g ∘ f` is also continuously differentiable of degree `n` on `s`.


theorem Function.sometimes_spec :
    ∀ {p : Prop} {α : Sort u_1} [inst : Nonempty α] (P : α → Prop) (f : p → α) (a : p),
      P (f a) → P (Function.sometimes f) :=
  by sorry

The theorem `Function.sometimes_spec` asserts that for any proposition `p`, any type `α` that is nonempty, any property `P` from `α` to a proposition, any function `f` from `p` to `α`, and any instance `a` of the proposition `p`, if the property `P` holds for the result of applying `f` to `a`, then the property `P` also holds for `Function.sometimes f`. In other words, if `P(f(a))` is true, then `P(Function.sometimes f)` is also true. This theorem is particularly useful when we want to establish that a property holds for some value of a function, without specifying exactly what that value is.

If for any proposition `p`, nonempty type `α`, property `P` from `α` to a proposition, function `f` from `p` to `α`, and instance `a` of `p` with `P(f(a))`, then `P(Function.sometimes f)` holds.


theorem abs_norm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (z : E), |‖z‖| = ‖z‖ := by sorry

This theorem states that for any type `E` that is a seminormed add group, the absolute value of the norm of an element `z` of `E` is equal to the norm of `z`. In other words, the norm of any element in a seminormed add group is always nonnegative, hence its absolute value remains the same.

For any seminormed add group `E` and its element `z`, the norm of `z` equals its absolute value.


theorem Polynomial.X_comp : ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.comp Polynomial.X p = p :=
  by sorry

This theorem states that for any type `R` with a semiring structure and any polynomial `p` over `R`, the composition of the polynomial `p` with the polynomial variable, denoted `Polynomial.X`, is equal to `p` itself. In other words, if we substitute the polynomial variable into `p` everywhere, the result is `p`. This can be thought of as the polynomial version of the identity function, familiar from basic algebra: substituting `x` into a function `f(x)` everywhere just gives back `f(x)`.

For any semiring `R` and polynomial `p` over `R`, `p * Polynomial.X = p`.


theorem sub_nonpos :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      a - b ≤ 0 ↔ a ≤ b :=
  by sorry

This theorem, `sub_nonpos`, states that for any type `α` that forms an additive group and has an order relation satisfying the covariance property (specifically, the function that adds two elements of `α` and the less than or equal to relation are covariant), the subtraction of two elements `b` from `a` (denoted as `a - b`) is less than or equal to zero if and only if `a` is less than or equal to `b`. In other words, for all elements `a` and `b` in such a type `α`, `a - b ≤ 0` is equivalent to `a ≤ b`.

For every additive group type `α` with a covariant order relation, the subtraction of two elements `a` and `b` satisfies `a - b ≤ 0` if and only if `a ≤ b`.


theorem Ordinal.add_isNormal : ∀ (a : Ordinal.{u_4}), Ordinal.IsNormal fun x => a + x := by sorry

The theorem `Ordinal.add_isNormal` states that for any ordinal `a`, the function that adds `a` to its input is a normal ordinal function. In other words, this function is strictly increasing and order-continuous. In mathematical terms, for any two ordinals `x` and `y`, if `x < y`, then `a + x < a + y`. Moreover, if `o` is a limit ordinal, then `a + o` is the supremum of `a + b` for all `b < o`.

For any ordinal `a`, the function `x => a + x: Ordinal → Ordinal` is both strictly increasing and order-continuous.


theorem Array.size_swap :
    ∀ {α : Type u_1} (a : Array α) (i j : Fin (Array.size a)), Array.size (Array.swap a i j) = Array.size a := by sorry

This theorem, named `Array.size_swap`, states that for any type `α`, any array `a` of type `α`, and any two indices `i` and `j` within the size of the array `a`, swapping the entries at positions `i` and `j` in the array `a` does not change the size of the array. In other words, the size of the array after the swap operation remains the same as the original size of the array.

For any type `α` and array `a` of length `n` over `α`, swapping the `i`-th and `j`-th elements of `a` does not change the length of `a`, i.e., `n = length (a.swap i j)`.


theorem AbsoluteValue.map_neg :
    ∀ {R : Type u_3} {S : Type u_4} [inst : OrderedCommRing S] [inst_1 : Ring R] (abv : AbsoluteValue R S)
      [inst_2 : NoZeroDivisors S] (a : R), abv (-a) = abv a :=
  by sorry

This theorem states that for any given types `R` and `S`, where `S` is an ordered commutative ring and `R` is a ring, and any absolute value `abv` from `R` to `S`, if `S` has no zero divisors, then the absolute value of the negation of any element `a` from `R` is equal to the absolute value of `a`. In mathematical terms, this means that |−a| = |a| for any `a` in `R`, which is a standard property of absolute values in mathematics.

Given rings `R` and `S` with `S` an ordered commutative ring without zero divisors, and an absolute value `abv` from `R` to `S`, then for all `a` in `R`, we have |−`a`| = |`a`|.


theorem Continuous.matrix_elem :
    ∀ {X : Type u_1} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace R] {A : X → Matrix m n R},
      Continuous A → ∀ (i : m) (j : n), Continuous fun x => A x i j :=
  by sorry

The theorem `Continuous.matrix_elem` states that given any topological space `X`, types `m`, `n`, a type `R` with a topological structure, and a continuous function `A` mapping from `X` to a matrix of type `Matrix m n R`, for each element (i,j) in the matrix, the function that maps an element `x` in `X` to the (i,j)-th element of the matrix `A(x)` is also continuous.

Given a continuous function `A : X -> Matrix m n R` from a topological space `X` to a matrix of type `Matrix m n R`, the (i,j)-th entry function `x => A x!{i,j}` is continuous.


theorem Set.pi_univ : ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι), (Set.pi s fun i => Set.univ) = Set.univ := by
  sorry

This theorem, `Set.pi_univ`, states that for any index set `ι` and a family of types `α` indexed by `ι`, and for any set `s` of `ι`, the set of all dependent functions from `ι` to `α` that map every element of `s` to the universal set is itself the universal set. In other words, if every element of the set `s` is mapped to the set containing every possible value of the type, then the set of all these functions is the set of all possible functions.

For any index set `ι` and a family of types `α`, the set of dependent functions from `ι` to `α` that map each element of a subset `s` of `ι` to the universal set `Set.univ` equals the universal set.


theorem MeasureTheory.withDensityᵥ_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_3} [inst : NormedAddCommGroup E]
      [inst_1 : NormedSpace ℝ E] {f : α → E},
      MeasureTheory.Integrable f μ →
        ∀ {s : Set α}, MeasurableSet s → ↑(MeasureTheory.Measure.withDensityᵥ μ f) s = ∫ (x : α) in s, f x ∂μ :=
  by sorry

The theorem `MeasureTheory.withDensityᵥ_apply` states that for any types `α` and `E`, a measurable space `m` on `α`, a measure `μ` on `α`, and a function `f` from `α` to `E` where `E` is a normed add commutative group and also a normed space over the reals, if `f` is integrable with respect to the measure `μ`, then for any set `s` of type `α` that is a measurable set, the measure with density of `μ` with respect to `f` applied on `s` is equal to the definite integral of `f` over the set `s` with respect to the measure `μ`. In mathematical terms, this theorem asserts that given a measure `μ` and an integrable function `f`, the measure with density `f` with respect to `μ` evaluated on a measurable set `s` is equal to the integral of `f` over `s` with respect to `μ`, denoted as `∫ (x : α) in s, f x ∂μ`.

For any measurable space `(α, μ)`, measurable set `s ⊆ α`, integrable function `f : α → E` (where `E` is a normed add commutative group and normed space over the reals), the measure with density of `μ` with respect to `f` on `s` equals the definite integral of `f` over `s` with respect to `μ`, i.e., `∫ (x : α) in s, f x ∂μ = μ(s, f)`.


theorem abs_div : ∀ {α : Type u_2} [inst : LinearOrderedField α] (a b : α), |a / b| = |a| / |b| := by sorry

This theorem states that for any real numbers `a` and `b` of an arbitrary type `α`, which is a LinearOrderedField (a field that is both ordered and linear), the absolute value of the quotient `a / b` is equal to the quotient of the absolute values `|a| / |b|`. In other words, the absolute value operation can be distributed over the division operation.

For any real numbers `a` and `b` in a LinearOrderedField `α`, |a / b| = |a| / |b|.


theorem MeasureTheory.ae_iff :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : α → Prop},
      (∀ᵐ (a : α) ∂μ, p a) ↔ ↑↑μ {a | ¬p a} = 0 :=
  by sorry

The theorem `MeasureTheory.ae_iff` states that for any measurable space `α` and any measure `μ` on it, a property `p` holds almost everywhere (i.e., everywhere except for a set of measure zero) if and only if the measure of the set of elements for which `p` does not hold is zero. In other words, `p` is true almost everywhere if and only if the measure of the set of exceptions is zero.

A property holds almost everywhere in a measurable space with respect to a measure if and only if the measure of the set where the property does not hold is zero.


theorem Set.ncard_eq_toFinset_card :
    ∀ {α : Type u_1} (s : Set α) (hs : autoParam (Set.Finite s) _auto✝), Set.ncard s = (Set.Finite.toFinset hs).card :=
  by sorry

The theorem `Set.ncard_eq_toFinset_card` states that for all sets `s` of a certain type `α`, given that `s` is finite (which is automatically deduced by the `autoParam` gadget), the cardinality of `s` (given by `Set.ncard s`) equals the cardinality of the corresponding finite set (`(Set.Finite.toFinset hs).card`). In other words, the number of elements in a finite set `s` is the same whether you count them as elements of a set or as elements of the corresponding finite set.

For a finite set `s` of type `α` in Lean, `Set.ncard s` equals the cardinality of the corresponding finite set `(Set.Finite.toFinset hs)`.


AddCon.eq

/-- Two elements are related by an additive congruence relation `c` iff
they are represented by the same element of the quotient by `c`. -/
theorem AddCon.eq : ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {a b : M}, ↑a = ↑b ↔ c a b := by sorry

This theorem states that for any type `M` with addition (`Add M`), and any additive congruence relation `c` on `M`, two elements `a` and `b` of `M` are related by `c` if and only if their representatives (obtained via the quotient map) in the quotient of `M` by `c` are the same. In the language of Mathematics, this is expressing the fundamental property of quotient structures in the context of additive groups: two elements are in the same equivalence class, i.e., related by the congruence, if and only if their images under the canonical projection to the quotient group are the same.

For any additive group `(M, +)` and additive congruence relation `c` on `M`, elements `a` and `b` are related by `c` if and only if their quotient group representatives are equal.


theorem le_sup_of_le_right : ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, c ≤ b → c ≤ a ⊔ b := by sorry

This theorem, `le_sup_of_le_right`, states that for any semilattice (a partially ordered set with a supremum operation) of type α, and for any elements a, b, and c of that type, if c is less than or equal to b, then c is also less than or equal to the supremum of a and b. In other words, in a semilattice, if an element is less than or equal to another, then it is also less than or equal to the supremum of that element and any other element in the semilattice.

In a semilattice, if $c \leq b$, then $c \leq \sup(a, b)$.


theorem inv_injective : ∀ {G : Type u_3} [inst : InvolutiveInv G], Function.Injective Inv.inv := by sorry

The theorem `inv_injective` states that for any type `G` that carries the structure of `InvolutiveInv`, the inversion function `Inv.inv` is injective. In other words, if `G` is a type with involutive inversion (a mathematical operation where applying the operation twice returns the original value), then for all elements `a` and `b` in `G`, if the inverse of `a` is equal to the inverse of `b`, then `a` must equal `b`. The injection property ensures that different elements of `G` won't have the same inverse under `Inv.inv`.

If `G` is a type with involutive inversion, then for all `a, b` in `G`, `Inv.inv a = Inv.inv b` implies `a = b`.


theorem Finset.mem_union_left :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} (t : Finset α), a ∈ s → a ∈ s ∪ t := by sorry

The theorem `Finset.mem_union_left` states that for any type `α` that has decidable equality (denoted by `DecidableEq α`), for any finite set `s` of `α` (denoted by `Finset α`), and for any element `a` of `α`, if `a` is a member of `s`, then `a` is also a member of the union of `s` and any other finite set `t` of `α`. In other words, if an element belongs to a set, then it belongs to the union of that set with any other set.

If `α` has decidable equality and `s` is a finite set of `α`, then for all `a` in `α` such that `a` is in `s`, `a` is also in `s ∪ t`.


theorem Finset.empty_subset : ∀ {α : Type u_1} (s : Finset α), ∅ ⊆ s := by sorry

This theorem states that for any given set `s` of an arbitrary type `α`, the empty set is a subset of `s`. In other words, no matter what set `s` you choose in any type, the empty set is always considered to be contained within `s`. This is a basic property of sets in mathematics, encapsulated in the context of finitely enumerable sets (or `Finset`s) in Lean 4.

For any set `s` of type `α`, the empty set is a subset of `s`.


/-- A subgroup `K` includes `closure k` if and only if it includes `k`.  -/
theorem Subgroup.closure_le :
    ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {k : Set G}, Subgroup.closure k ≤ K ↔ k ⊆ ↑K := by sorry

This theorem states that for any group `G` and any subgroup `K` of `G`, the closure of a set `k` (of elements in `G`) is a subset of `K` if and only if `k` is a subset of `K`. In other words, a subgroup `K` includes the `Subgroup.closure` of a set `k` if and only if it includes the set `k` itself. The closure of a set, in this context, represents the smallest subgroup that contains that set.

A subgroup K of a group G contains the closure of a set k if and only if k is a subset of K.


theorem Set.not_subset : ∀ {α : Type u} {s t : Set α}, ¬s ⊆ t ↔ ∃ a ∈ s, a ∉ t := by sorry

The theorem `Set.not_subset` states that for all types `α` and for all sets `s` and `t` of type `α`, the proposition that `s` is not a subset of `t` is equivalent to the existence of an element `a` in `s` such that `a` is not in `t`. In other words, a set `s` is not a subset of another set `t` if and only if there is at least one element in `s` which does not belong to `t`.

A set `s` is not a subset of `t` if and only if there exists an element `a` in `s` such that `a` is not in `t`.