/-- The dimension of a submodule is bounded by the dimension of the ambient space.  -/
theorem Submodule.finrank_le :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Finite R M] (s : Submodule R M),
      FiniteDimensional.finrank R ↥s ≤ FiniteDimensional.finrank R M :=
  by sorry

The theorem `Submodule.finrank_le` states that for any ring `R` and any `R`-module `M` (a kind of mathematical structure that generalizes vector spaces), if `M` has a finite rank and `R` has the strong rank condition (a certain technical property), then the rank (or dimension) of any submodule `s` of `M` (which can be thought of as a "subspace" of `M`) is less than or equal to the rank of `M` itself. In other words, the dimension of a subspace cannot exceed the dimension of the space that contains it.

For any ring with the strong rank condition and a finite-rank module, the rank of any submodule is less than or equal to the rank of the module itself.


theorem Dioph.diophFn_comp2 :
    ∀ {α : Type} {f g : (α → ℕ) → ℕ},
      Dioph.DiophFn f →
        Dioph.DiophFn g →
          ∀ {h : ℕ → ℕ → ℕ},
            (Dioph.DiophFn fun v => h (v (Fin2.ofNat' 0)) (v (Fin2.ofNat' 1))) → Dioph.DiophFn fun v => h (f v) (g v) :=
  by sorry

The theorem `Dioph.diophFn_comp2` states that for any type `α`, and any functions `f` and `g` that map a function from `α` to `ℕ` to `ℕ`, if `f` and `g` are Diophantine functions (i.e. their graphs are Diophantine sets), and if there exists another function `h` from `ℕ` to `ℕ` to `ℕ` that is also Diophantine when considering its inputs as a function from `Fin2` (finite set with 2 elements) to `ℕ`, then the composite function `h` which takes `f v` and `g v` as arguments is also a Diophantine function. In essence, it shows that the composition of Diophantine functions under certain conditions produces another Diophantine function.

If `f` and `g` are Diophantine functions mapping `α → ℕ` to `ℕ`, and there exists a Diophantine function `h` mapping `ℕ → ℕ → ℕ`, then their composition `h (f x) (g x)` is also a Diophantine function.


theorem SetTheory.PGame.zero_le_add_right_neg : ∀ (x : SetTheory.PGame), 0 ≤ x + -x := by sorry

This theorem states that for every PGame `x` in set theory, adding its negation to it results in a value that is greater than or equal to 0. In other words, the sum of any PGame `x` and its negation `-x` is always nonnegative. In traditional mathematical notation, this would be expressed as `0 ≤ x + -x` for all `x`.

For all PGame `x`, we have `0 ≤ x + (-x)`.


SimpleGraph.Reachable.map

theorem SimpleGraph.Reachable.map :
    ∀ {V : Type u} {V' : Type v} {u v : V} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G'),
      SimpleGraph.Reachable G u v → SimpleGraph.Reachable G' (f u) (f v) :=
  by sorry

The theorem `SimpleGraph.Reachable.map` states that for any two types `V` and `V'`, for any vertices `u` and `v` of type `V`, for any simple graphs `G` and `G'` of type `V` and `V'` respectively, and for a function `f` that maps from `G` to `G'`, if `u` and `v` are reachable in the graph `G`, then the images of `u` and `v` under the function `f` are reachable in the graph `G'`. In other words, the reachability relation is preserved under the map from `G` to `G'`.

If `G` is a simple graph and `f` is a function from the vertices of `G` to the vertices of a simple graph `G'`, then for any vertices `u` and `v` of `G` such that there is a path from `u` to `v` in `G`, there is a path from `f(u)` to `f(v)` in `G'`.


Function.RightInverse.injective

theorem Function.RightInverse.injective :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.RightInverse f g → Function.Injective f := by
  sorry

The theorem `Function.RightInverse.injective` states that for any two types `α` and `β`, and any two functions `f : α → β` and `g : β → α`, if `g` is a right inverse to `f` (that is, composing `f` and `g` results in the identity function), then `f` is an injective function. In other words, if `f(g(x)) = x` for all `x` in `β`, then for any `x1` and `x2` in `α`, if `f(x1) = f(x2)` then `x1 = x2`.

If a function `f : α → β` has a right inverse `g : β → α` (i.e., `f ∘ g = idβ` and `g ∘ f = idα`), then `f` is an injective function (i.e., `f x₁ = f x₂` implies `x₁ = x₂` for all `x₁, x₂ : α`).


theorem Pi.smul_apply' :
    ∀ {I : Type u} {f : I → Type v} (i : I) {g : I → Type u_1} [inst : (i : I) → SMul (f i) (g i)] (s : (i : I) → f i)
      (x : (i : I) → g i), (s • x) i = s i • x i :=
  by sorry

This theorem, `Pi.smul_apply'`, states that for any indexed type `I`, any two functions `f : I → Type v` and `g : I → Type u_1`, any index `i : I`, and given instances of scalar multiplication (`SMul`) for each index in `I` for the types `f i` and `g i`, if we take two functions `s : (i : I) → f i` and `x : (i : I) → g i` and perform scalar multiplication on them, the result at index `i` would be the same as if we multiplied the values at index `i` of `s` and `x` directly. In other words, this theorem ensures that scalar multiplication distributes over the elements of indexed functions.

For any indexed types I, given functions f : I -> Type and g : I -> Type, index i : I, and instances of scalar multiplication on f i and g i, we have (s smul x).i = s.i smul x.i, where s and x are functions s : i -> f i and x : i -> g i respectively.


theorem sup_inf_assoc_of_le :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : IsModularLattice α] {x : α} (y : α) {z : α},
      x ≤ z → (x ⊔ y) ⊓ z = x ⊔ y ⊓ z :=
  by sorry

This theorem, `sup_inf_assoc_of_le`, states that for any type `α` that forms a lattice and is also a modular lattice, and for any elements `x`, `y`, and `z` of that type, if `x` is less than or equal to `z`, then the supremum (join) of `x` and `y`, infimum (meet) with `z`, is equal to `x` join with the infimum of `y` and `z`. This theorem captures an important property of modular lattices - the associativity of supremum and infimum under the given condition.

For any lattice and modular lattice type `α` and elements `x`, `y`, `z` of `α`, if `x ≤ z`, then `x ⨂ (y ⋁ z) = (x ⋁ y) ⋁ z`, where `⨂` denotes infimum (meet) and `⋁` denotes supremum (join).


theorem IsGalois.card_aut_eq_finrank :
    ∀ (F : Type u_1) [inst : Field F] (E : Type u_2) [inst_1 : Field E] [inst_2 : Algebra F E]
      [inst_3 : FiniteDimensional F E] [inst_4 : IsGalois F E],
      Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E :=
  by sorry

The theorem `IsGalois.card_aut_eq_finrank` states that for any field `F` and any field extension `E` of `F`, if `E` is a finite-dimensional vector space over `F` and `E` is a Galois extension of `F`, then the number of F-algebra automorphisms of `E` (elements of the type `E ≃ₐ[F] E`) is equal to the rank of `E` as a module over `F` (equivalently, the dimension of `E` as a vector space over `F`). In the context of Galois theory, this is a formal statement of the fundamental theorem that the order of the Galois group of a finite Galois extension is equal to the degree of the extension.

The number of algebra automorphisms of a finite-dimensional Galois extension equals its dimension over the base field.


theorem CategoryTheory.Limits.biproduct.matrix_π :
    ∀ {J : Type} [inst : Finite J] {K : Type} [inst_1 : Finite K] {C : Type u}
      [inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {f : J → C} {g : K → C} (m : (j : J) → (k : K) → f j ⟶ g k)
      (k : K),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.matrix m)
          (CategoryTheory.Limits.biproduct.π g k) =
        CategoryTheory.Limits.biproduct.desc fun j => m j k :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.matrix_π`, states that in a category `C` that has zero morphisms and finite biproducts, for any two functions `f : J → C` and `g : K → C` where `J` and `K` are finite types, and a family of morphisms `m : (j : J) → (k : K) → f j ⟶ g k`, the composition of the biproduct matrix of `m` and the projection onto a summand of `g` is equal to the biproduct descent of the function that maps each element of `J` to the morphism `m j k`.

In other words, this theorem is about the interaction of biproduct matrices and projections in a category with certain properties, namely having zero morphisms and finite biproducts.

In a category with zero morphisms and finite biproducts, for any two functions and a family of morphisms between them, the composition of the biproduct matrix and the projection onto a summand equals the biproduct descent of the function mapping each element to the morphism.


theorem ascPochhammer_nat_eq_ascFactorial : ∀ (n k : ℕ), Polynomial.eval n (ascPochhammer ℕ k) = Nat.ascFactorial n k :=
  by sorry

The theorem `ascPochhammer_nat_eq_ascFactorial` states that for any two natural numbers `n` and `k`, the evaluation of the polynomial `ascPochhammer` at `n` with `k` as the degree of polynomial is equal to the ascending factorial of `n` and `k`. In other words, when the polynomial `X * (X + 1) * ... * (X + k - 1)` is evaluated at `X = n`, the result is the product of the series `n * (n + 1) * ... * (n + k - 1)`. This establishes a correspondence between the evaluation of the `ascPochhammer` polynomial and the ascending factorial computation.

For any natural numbers `n` and `k`, the value of the polynomial `ascPochhammer X n k` evaluated at `X = n` equals the product `n * (n + 1) * ... * (n + k - 1)`.


theorem MeasureTheory.mem_ae_iff :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      s ∈ MeasureTheory.Measure.ae μ ↔ ↑↑μ sᶜ = 0 :=
  by sorry

This theorem states that, for any type `α` equipped with a `MeasurableSpace` structure, a measure `μ` of type `MeasureTheory.Measure α`, and a set `s` of type `Set α`, the set `s` belongs to the filter of co-null sets of the measure `μ` (notated as `s ∈ MeasureTheory.Measure.ae μ`) if and only if the measure of the complement of `s` (notated as `μ sᶜ`) equals zero. This means that a set is almost everywhere in the measure space if the measure of its complement is zero.

A set in a measurable space belongs to the filter of co-null sets if and only if its complement has measure zero.


theorem not_countable : ∀ {α : Sort u} [inst : Uncountable α], ¬Countable α := by sorry

This theorem states that for any type `α`, if `α` is uncountable, then it cannot be countable. In more mathematical terms, if a type `α` exists such that it has an uncountable number of elements (denoted by the Uncountable `α`), then it is not possible for `α` to also have a countable number of elements (denoted by the negation `¬Countable α`).

If a type `α` is uncountable, then it is not countable.


theorem Nat.le_mul_self : ∀ (n : ℕ), n ≤ n * n := by sorry

This theorem, known as `Nat.le_mul_self`, states that for all natural numbers `n`, `n` is less than or equal to the square of `n`. That is, for every natural number `n`, the inequality `n ≤ n * n` holds true. This is a basic property of multiplication in the natural numbers.

For all natural numbers `n`, `n` is less than or equal to `n * n`.


theorem Set.nonempty_coe_sort : ∀ {α : Type u} {s : Set α}, Nonempty ↑s ↔ Set.Nonempty s := by sorry

This theorem, `Set.nonempty_coe_sort`, states that for any type `α` and any set `s` of type `α`, the property `Nonempty ↑s` (i.e., the set `s` has a `Nonempty` type when converted to another type using an explicit or implicit coercion function) is equivalent to `Set.Nonempty s` (i.e., the set `s` is not empty). In other words, a set `s` is not empty if and only if it remains nonempty after type coercion.

The theorem asserts that for any set `s` of type `α`, the set `s` is nonempty if and only if its coerced version `Nonempty ↑s` has type `Nonempty α`.


theorem Multiset.coe_card : ∀ {α : Type u_1} (l : List α), Multiset.card ↑l = List.length l := by sorry

The theorem `Multiset.coe_card` states that for any given list `l` of any type `α`, the cardinality of the multiset obtained by converting this list into a multiset (`↑l`) is equal to the length of the original list `l`. This effectively means that the operation of converting a list to a multiset does not change the number of elements in the collection, considering each repetition in the list as a distinct element in the multiset.

The cardinality of the multiset obtained from a list is equal to the length of the list.


theorem PNat.coprime_coe : ∀ {m n : ℕ+}, Nat.Coprime ↑m ↑n ↔ PNat.Coprime m n := by sorry

The theorem `PNat.coprime_coe` states that for every pair of positive natural numbers `m` and `n`, `m` and `n` are coprime in the natural numbers if and only if `m` and `n` are coprime in the positive natural numbers. In other words, the property of being coprime is preserved when transitioning between the domains of natural numbers and positive natural numbers. In mathematical terms, two numbers are said to be coprime if their greatest common divisor (gcd) is 1.

The theorem `PNat.coprime_coe` asserts that for all natural numbers `m` and `n`, `m` and `n` are coprime in the natural numbers if and only if they are coprime in the positive natural numbers, i.e., their greatest common divisor is 1.


QuotientMap.surjective

theorem QuotientMap.surjective :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      QuotientMap f → Function.Surjective f :=
  by sorry

The theorem `QuotientMap.surjective` states that for any two types `X` and `Y` and a function `f` from `X` to `Y`, if the topological spaces `X` and `Y` exist, and if `f` is a quotient map, then `f` is a surjective function. In the context of mathematics, this means that for any given element in the codomain `Y`, there exists at least one element in the domain `X` that maps to it under `f`. This is a property of quotient maps in topology, which are defined as surjective (onto) functions between topological spaces that respect the structure of the spaces in the sense that a set in the codomain is open if and only if its preimage in the domain is open.

If `f` is a quotient map between topological spaces `X` and `Y`, then `f` is surjective.


/-- Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `f'` is positive, then
`f` is a strictly monotone function on `D`.
Note that we don't require differentiability explicitly as it already implied by the derivative
being strictly positive.  -/
theorem strictMonoOn_of_deriv_pos :
    ∀ {D : Set ℝ},
      Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, 0 < deriv f x) → StrictMonoOn f D :=
  by sorry

The theorem `strictMonoOn_of_deriv_pos` states that if we have a function `f` that is continuous on a convex (or equivalently, connected) subset `D` of the real numbers, and if the derivative of `f` is strictly positive on the interior of `D`, then we can conclude that `f` is strictly monotone on `D`. This means that for any `a` and `b` in `D`, if `a < b`, then `f(a) < f(b)`. We do not require differentiability of `f` to be explicitly stated, as this is implied by the condition of the derivative being strictly positive. Essentially, the theorem says that a differentiable function with a strictly positive derivative over a convex subset of the real line is strictly increasing in that interval.

If a real-valued function is continuous on a convex subset of the real numbers and has a strictly positive derivative on its interior, then it is strictly increasing on that subset.


theorem Nat.shiftLeft'_false : ∀ {m : ℕ} (n : ℕ), Nat.shiftLeft' false m n = m <<< n := by sorry

The theorem `Nat.shiftLeft'_false` states that for any given natural numbers `m` and `n`, the function `Nat.shiftLeft'` with `false` as the first argument, `m` as the second argument, and `n` as the third argument, is equivalent to the left bitwise shift of `m` by `n` places. In other words, shifting `m` left `n` times while adding a `false` bit (i.e., a zero bit) each time as the least significant bit results in the same value as performing a bitwise left shift of `m` by `n` places.

For all natural numbers m and n, the function Nat.shiftLeft' (false) m n equals the bitwise left shift of m by n places.


theorem Ordinal.lt_sup :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}, a < Ordinal.sup f ↔ ∃ i, a < f i := by sorry

The theorem `Ordinal.lt_sup` states that for any type `ι`, any function `f` from `ι` to `Ordinal` in the universe with maximum of `u` and `v`, and any ordinal `a` in the same universe, `a` is less than the supremum of `f` if and only if there exists an element `i` in `ι` such that `a` is less than `f(i)`. In other words, an ordinal is less than the supremum of a set of ordinals if and only if it is less than at least one ordinal in the set.

An ordinal `a` is less than the supremum of a function `f` from `ι` to `Ordinal` if and only if there exists an `i` in `ι` such that `a` is strictly less than `f(i)`.


/-- Induction principle for `RatFunc K`: if `f p q : P (p / q)` for all `p q : K[X]`,
then `P` holds on all elements of `RatFunc K`.

See also `induction_on'`, which is a recursion principle defined in terms of `RatFunc.mk`.
 -/
theorem RatFunc.induction_on :
    ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] {P : RatFunc K → Prop} (x : RatFunc K),
      (∀ (p q : Polynomial K),
          q ≠ 0 → P ((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q)) →
        P x :=
  by sorry

This theorem, `RatFunc.induction_on`, establishes an induction principle for rational functions over a domain `K`. It asserts that, given any property `P` that applies to elements of rational functions over `K`, if this property holds for any rational function formed by dividing a polynomial `p` by a non-zero polynomial `q` (both from `K`), when these polynomials are mapped from the polynomial ring to the rational function space using the algebra map, then this property `P` holds for all elements of the rational functions over `K`. This theorem is fundamental for proofs involving properties of rational functions.

The theorem `RatFunc.induction_on` in Lean 4 asserts that if a property `P` holds for the quotient of two polynomials in a domain `K`, then it holds for all rational functions over `K`.


theorem Set.biUnion_empty : ∀ {α : Type u_1} {β : Type u_2} (s : α → Set β), ⋃ x ∈ ∅, s x = ∅ := by sorry

The theorem `Set.biUnion_empty` states that for any types `α` and `β`, and any function `s` from `α` to a set of `β`s, the union, over all elements `x` in the empty set, of the sets `s x`, is the empty set. In other words, if you try to form a union of sets based off elements from an empty set, the result will be an empty set. This is because there are no elements in the empty set to begin with, so there are no sets to take the union of.

The union of the empty set of elements with respect to any function mapping each element to a set, results in the empty set.


theorem compRel_mono : ∀ {α : Type ua} {f g h k : Set (α × α)}, f ⊆ h → g ⊆ k → compRel f g ⊆ compRel h k := by sorry

The theorem `compRel_mono` states that for all types `α` and for all relations `f`, `g`, `h`, and `k` on `α`, if `f` is a subset of `h` and `g` is a subset of `k`, then the composition of the relations `f` and `g` is a subset of the composition of the relations `h` and `k`. Here, the composition of two relations is defined as the set of pairs `(a, b)` such that there exists an element `z` where `(a, z)` belongs to the first relation and `(z, b)` belongs to the second relation.

If relations $f \subseteq h$ and $g \subseteq k$ on type $\alpha$, then $f \circ g \subseteq h \circ k$, where $\circ$ denotes relation composition.


FrameHom.ext

theorem FrameHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {f g : FrameHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `FrameHom.ext`, states that for any two frame homomorphisms `f` and `g` between two complete lattices (of types `α` and `β`), if `f` and `g` are equal at every element `a` of the lattice `α`, then `f` and `g` are indeed the same frame homomorphism. In other words, two frame homomorphisms are equal if they act the same on every element of their domain.

Two frame homomorphisms between complete lattices are equal if and only if they map every element to the same image.


theorem Stream'.take_succ :
    ∀ {α : Type u} (n : ℕ) (s : Stream' α),
      Stream'.take (Nat.succ n) s = Stream'.head s :: Stream'.take n (Stream'.tail s) :=
  by sorry

The theorem `Stream'.take_succ` states that for any type `α`, any natural number `n`, and any stream `s` of type `α`, taking the first `n+1` elements of the stream `s` gives a list that starts with the first element of `s` (i.e., `Stream'.head s`), followed by the first `n` elements from the remainder of the stream (i.e., `Stream'.take n (Stream'.tail s)`). In other words, it describes how to construct a list from the first `n+1` elements of a stream by successively taking the head of the stream and the first `n` elements from the tail of the stream.

For any stream `s` of type `α` and natural number `n`, the first `n+1` elements of `s` form a list equal to the cons of `Stream.head s` and the first `n` elements of `Stream.tail s`. (In mathematical notation: `take (n+1) s = cons (Stream.head s) (take n (Stream.tail s))`)


MeasureTheory.AEDisjoint.symm

theorem MeasureTheory.AEDisjoint.symm :
    ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.AEDisjoint μ s t → MeasureTheory.AEDisjoint μ t s :=
  by sorry

This theorem states that the property of two sets being "almost everywhere disjoint" with respect to a given measure is symmetric. In other words, for any type `α` equipped with a measurable space structure `m` and a measure `μ`, if two sets `s` and `t` of type `α` are almost everywhere disjoint under the measure `μ` (i.e., the measure of their intersection is zero), then swapping the roles of `s` and `t` doesn't change this fact: `t` and `s` are also almost everywhere disjoint under the measure `μ`.

If sets `s` and `t` of type `α` are almost everywhere disjoint under measure `μ` (i.e., `μ(s ∩ t) = 0`), then `s` and `t` are also almost everywhere disjoint under `μ` in the opposite direction (i.e., `μ(s ∩ t) = 0`).


theorem eq_zero_of_mul_self_eq_zero :
    ∀ {M₀ : Type u_2} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : NoZeroDivisors M₀] {a : M₀}, a * a = 0 → a = 0 := by
  sorry

This theorem states that for any type `M₀` which has a multiplication operation, a zero element, and no zero divisors, if a member `a` of `M₀` satisfies the property that the multiplication of `a` with itself equals zero, then `a` itself must be zero. Essentially, this is a formalization of the mathematical principle that the square of a non-zero number is never zero.

If `M₀` is a type with multiplication, zero, and no zero divisors, then for all `a` in `M₀`, `a * a = 0` implies `a = 0`.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.33 :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      SimpleGraph.Walk.IsPath p = List.Nodup (SimpleGraph.Walk.support p) :=
  by sorry

The theorem `Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.33` states that for any type `V`, any simple graph `G` of vertices of type `V`, and any two vertices `u` and `v` of type `V`, a walk `p` from `u` to `v` in `G` is a path if and only if the list of vertices visited by the walk `p` (i.e., the `support` of `p`) has no duplicates. In other words, a walk in the graph is a path if it doesn't visit the same vertex twice.

A walk in a simple graph between two vertices is a path if and only if it visits each vertex at most once.


theorem tendsto_nhdsWithin_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {a : α} {l : Filter β} {s : Set α} {f : β → α},
      Filter.Tendsto f l (nhdsWithin a s) ↔ Filter.Tendsto f l (nhds a) ∧ ∀ᶠ (n : β) in l, f n ∈ s :=
  by sorry

The theorem `tendsto_nhdsWithin_iff` states that for any topological space `α`, filter `l` on a type `β`, a set `s` of `α`, and a function `f` from `β` to `α` mapping elements of the filter to the topological space, the function `f` tends to the neighborhood within `s` of a point `a` in `α` under the filter `l` if and only if `f` tends to the neighborhood of `a` under `l` and, eventually, for all elements `n` in `l`, `f n` belongs to `s`. In mathematical notation, this could be written as $\lim_{n \to l} f(n) \in \mathcal{N}_s(a) \iff \left(\lim_{n \to l} f(n) \in \mathcal{N}(a) \land \forall n \in l, f(n) \in s \right)$, where $\mathcal{N}_s(a)$ and $\mathcal{N}(a)$ denote the neighborhood within `s` of `a` and the neighborhood of `a`, respectively.

A function from a filter to a topological space tends to the neighborhood within a set of the space of a point if and only if it tends to the neighborhood of the point and all elements of the filter belong to the set.


theorem Irrational.of_rat_add : ∀ (q : ℚ) {x : ℝ}, Irrational (↑q + x) → Irrational x := by sorry

The theorem `Irrational.of_rat_add` states that for every rational number `q` and for any real number `x`, if the sum of `q` (casted to a real number) and `x` is irrational, then `x` is also irrational. In other words, if the sum of a rational and a real number is not equal to any rational number, then that real number itself must be irrational.

If the sum of a rational number and a real number is irrational, then the real number is irrational.


theorem Sum.Lex.inr_lt_inr_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : β},
      toLex (Sum.inr a) < toLex (Sum.inr b) ↔ a < b :=
  by sorry

This theorem states that for any two types `α` and `β` with a less-than (`<`) relation, and any two elements `a` and `b` of type `β`, the statement "the lexical order of `a` is less than the lexical order of `b`" is equivalent to the statement "a is less than b". Here, the `toLex` function is used to convert `a` and `b` to their lexical orders, and `Sum.inr` is used to inject elements of type `β` into a sum type.

For any types `α` with a `<` relation and elements `a` and `b` of type `β`, `a < b` if and only if `toLex (Sum.inr a)` is less than `toLex (Sum.inr b)` in the lexical order of `α`.


theorem Equiv.trans_refl : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.trans (Equiv.refl β) = e := by sorry

The theorem `Equiv.trans_refl` states that for any types `α` and `β`, and any equivalence `e` from `α` to `β`, the transitive operation of `e` with the reflexive equivalence of `β` (which is an equivalence relation from `β` to itself) is equivalent to `e`. In simpler terms, it shows that, in the context of equivalence relations, applying an equivalence after a reflexive (identity) equivalence does not change the original equivalence. This theorem formalizes one of the properties of equivalence relations: if something is equivalent to itself (reflexivity), that doesn't affect the transition from one thing to another (transitivity).

For any equivalences `e` from type `α` to type `β`, `e ∘ rrefl β` is equivalent to `e`, where `rrefl β` is the reflexive equivalence relation on `β`.


theorem HasSum.const_smul :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Monoid γ] [inst_1 : TopologicalSpace α]
      [inst_2 : AddCommMonoid α] [inst_3 : DistribMulAction γ α] [inst_4 : ContinuousConstSMul γ α] {f : β → α} {a : α}
      (b : γ), HasSum f a → HasSum (fun i => b • f i) (b • a) :=
  by sorry

This theorem, `HasSum.const_smul`, states that for any types `α`, `β`, and `γ` where `α` is a topological space and an additive commutative monoid, `γ` is a monoid, and there exists a distributive multiplication action of `γ` on `α` that is continuous, if the function `f` mapping from `β` to `α` has a sum `a`, then the function where each term `f i` is scaled by a constant `b` from `γ` also has a sum, specifically `b • a`. In other words, scaling all terms in a summable sequence by a constant factor scales the sum by that same factor.

If `f` is a summable function from a monoid `β` to a topological space and additive commutative monoid `α` with a continuous, distributive multiplication action of a monoid `γ`, then scaling each term of the sum `f` by a constant `b` from `γ` results in a sum equal to `b * (sum of f)`.


theorem Finset.sup_image₂_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
      (t : Finset β) [inst_1 : SemilatticeSup δ] [inst_2 : OrderBot δ] (g : γ → δ),
      Finset.sup (Finset.image₂ f s t) g = Finset.sup s fun x => Finset.sup t fun x_1 => g (f x x_1) :=
  by sorry

This theorem, `Finset.sup_image₂_left`, states that for every two finite sets `s` and `t` of types `α` and `β` respectively, and a binary function `f : α → β → γ`, the supremum (greatest element) of the image of the function over the Cartesian product of `s` and `t`, when mapped to another set via a function `g : γ → δ`, is equal to the supremum of the set obtained by replacing each element of `s` with the supremum of the set obtained by replacing each element of `t` with `g(f x x_1)`. Here, `x` is an element of `s` and `x_1` is an element of `t`.

In mathematical terms, this can be expressed as $\sup \{g(f(a, b)) | a \in s, b \in t\} = \sup \{\sup \{g(f(a, b)) | b \in t\} | a \in s\}$. This is a statement about an interchange of suprema over sets translated using a binary function and a unary function.

For finite sets $s$ and $t$ of types $\alpha$ and $\beta$ respectively, and a binary function $f : \alpha \times \beta \to \gamma$, the supremum of $g \circ f$ over the Cartesian product $s \times t$ equals the supremum of $g \circ \sup_t \circ f$ over $s$, where $\sup_t$ is the operation of taking the supremum over the set $t$.


theorem Finite.of_surjective :
    ∀ {α : Sort u_4} {β : Sort u_5} [inst : Finite α] (f : α → β), Function.Surjective f → Finite β := by sorry

The theorem `Finite.of_surjective` states that for all types `α` and `β`, if `α` is finite and there exists a surjective function `f` from `α` to `β`, then `β` is also finite. In other words, if every element in `β` can be mapped from some element in `α` (which is a finite set), then `β` must also be a finite set. This theorem is a formal statement of the intuitive idea that the image of a finite set under a surjective function is also finite.

If `α` is a finite type and there exists a surjective function from `α` to `β`, then `β` is finite.


theorem Nat.sub_eq_iff_eq_add : ∀ {b a c : ℕ}, b ≤ a → (a - b = c ↔ a = c + b) := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `b` is less than or equal to `a`, then the difference of `a` and `b` equals `c` if and only if `a` equals `c` plus `b`. In other words, the difference between `a` and `b` being `c` is equivalent to `c` added to `b` resulting in `a`. This theorem essentially provides an equivalence between subtraction and addition operations under certain conditions on natural numbers.

For natural numbers `a`, `b`, and `c`, `a = c + b` if and only if `b <= a` and `a = c + b`.


theorem Primrec₂.left :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec₂ fun a x => a := by sorry

The theorem `Primrec₂.left` states that for any two types `α` and `β` that are primcodable (i.e., they can be encoded as natural numbers), the function which takes a pair of inputs `(a, x)` and simply returns the first element `a` is a binary primitive recursive function. In other words, the projection function that discards the second argument and returns the first one is primitive recursive.

The function that projects the first element of a pair of primcodable types is a primitive recursive function.


theorem Set.InjOn.encard_image :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s → Set.encard (f '' s) = Set.encard s := by
  sorry

This theorem states that for any types `α` and `β`, a set `s` of type `α`, and a function `f` from `α` to `β`, if the function `f` is injective on the set `s` (i.e., no two different elements in `s` map to the same element in `β`), then the cardinality (size) of the image of the set `s` under the function `f` equals the cardinality of the set `s`. In other words, an injective function doesn't change the size of the set when mapping it to another set.

If `f : α → β` is an injective function and `s : set α`, then the cardinality of `s` equals the cardinality of `{x ∈ s | f x ∈ image f s}`.


theorem Mathlib.Algebra.Module.Submodule.RestrictScalars._auxLemma.1 :
    ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
      [inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] (V : Submodule R M)
      (m : M), (m ∈ Submodule.restrictScalars S V) = (m ∈ V) :=
  by sorry

This theorem states that for any semiring `S`, another semiring `R`, and an additive commutative monoid `M`, given certain module and scalar multiplication structures and provided that `S`, `R`, and `M` form a scalar tower, any element `m` of `M` belongs to the `Submodule.restrictScalars S V` if and only if it belongs to `V`. `V` here is a submodule of `M` over `R`. Essentially, this theorem shows that restricting scalars does not change the membership of elements in `M` with respect to the submodule `V`.

For any semirings S and R, additive commutative monoid M, submodule V of M over R, and given module and scalar multiplication structures making S, R, and M a scalar tower, an element m of M belongs to the submodule V over R if and only if it belongs to V.


/-- An induction principle for additive closure membership. If `p`
holds for all elements of `s`, and is preserved under addition, then `p` holds for all
elements of the additive closure of `s`. -/
theorem AddSubsemigroup.closure_induction :
    ∀ {M : Type u_1} [inst : Add M] {s : Set M} {p : M → Prop} {x : M},
      x ∈ AddSubsemigroup.closure s → (∀ x ∈ s, p x) → (∀ (x y : M), p x → p y → p (x + y)) → p x :=
  by sorry

This theorem, named `AddSubsemigroup.closure_induction`, establishes an induction principle for membership in the closure of an additive subsemigroup. Given a type `M` with an addition operation, a set `s` of elements of `M`, a property `p` that elements of `M` might have, and an element `x` of `M`, the theorem states that: if `x` is in the closure of the additive subsemigroup generated by `s`, if `p` holds for all elements in `s`, and if `p` is preserved under the addition operation (that is, if you know `p` holds for `x` and `y`, then you can conclude that `p` holds for `x + y`), then `p` must also hold for `x`.

If `s` is an additive subsemigroup of a type `M` with closure `C`, `p` is a property preserved under addition, and every element in `s` has property `p`, then any element `x` in the closure `C` also has property `p`.


theorem Set.BijOn.inter_mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
      Set.BijOn f s₁ t₁ → Set.MapsTo f s₂ t₂ → s₁ ∩ f ⁻¹' t₂ ⊆ s₂ → Set.BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂) :=
  by sorry

The theorem `Set.BijOn.inter_mapsTo` states that for any types `α` and `β`, any sets `s₁` and `s₂` of type `α`, any sets `t₁` and `t₂` of type `β`, and any function `f` from `α` to `β`, if `f` is bijective from `s₁` to `t₁` and `f` maps `s₂` to `t₂`, where the intersection of `s₁` and the pre-image of `t₂` under `f` is a subset of `s₂`, then `f` is bijective from the intersection of `s₁` and `s₂` to the intersection of `t₁` and `t₂`. In simpler terms, under these conditions, the function `f` preserves bijections when restricting to the intersections of its original domain and range sets.

If `f` is a bijective function from `s₁` to `t₁`, `s₂ ⊆ f⁁⁻¹(t₂)`, and `f(s₁) = t₂`, then `f` is bijective from `s₁ ∩ s₂` to `t₁ ∩ t₂`.


theorem isOpen_iff_nhds :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, nhds x ≤ Filter.principal s := by sorry

This theorem states that for any type `X` and set `s` of `X` in a given topological space, `s` is an open set if and only if for every element `x` in `s`, the neighborhood filter of `x` is less than or equal to the principal filter of `s`. In other words, a set is open in a topological space if for all of its points, every neighborhood of that point contains the set, or equivalently, the set is a subset of all neighborhoods of each of its points.

A set `s` of a topological space is open if and only if for every `x` in `s`, the neighborhood filter of `x` contains the principal filter of `s`.


theorem nonneg_of_mul_nonneg_right :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α}, 0 ≤ a * b → 0 < a → 0 ≤ b := by sorry

This theorem states that for any type `α` that is a linear ordered semiring, for any elements `a` and `b` of that type, if the product of `a` and `b` is nonnegative and `a` is positive then `b` must be nonnegative. In mathematical terms, `0 ≤ a * b` and `0 < a` implies `0 ≤ b` in the context of a linear ordered semiring.

In a linear ordered semiring, if product of two positive elements is non-negative, then the second element is non-negative.


theorem CategoryTheory.InjectiveResolution.exact_succ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ),
      CategoryTheory.ShortComplex.Exact
        (CategoryTheory.ShortComplex.mk (I.cocomplex.d n (n + 1)) (I.cocomplex.d (n + 1) (n + 2)) ⋯) :=
  by sorry

This theorem states that for any category `C` (of a certain type `u`), given that `C` has a zero object and zero morphisms, any object `Z` in `C` and its corresponding injective resolution `I`, for any natural number `n`, the short complex created by the differentials of `I` at indices `n` and `n+1`, and `n+1` and `n+2`, is exact. In category theory, a short exact sequence (or more specifically here, a short complex) is a certain sequence of morphisms between objects such that certain conditions hold, which captures some important properties of the objects and their relationships.

For any category `C` of type `u` with a zero object and zero morphisms, the short complex formed by the differentials of an injective resolution of an object `Z` in `C` is exact at degrees `n` and `n+1`.


/-- **Alias** of the forward direction of `Metric.isBounded_iff_ediam_ne_top`.

---

Characterize the boundedness of a set in terms of the finiteness of its emetric.diameter.  -/
theorem Bornology.IsBounded.ediam_ne_top :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, Bornology.IsBounded s → EMetric.diam s ≠ ⊤ := by sorry

This theorem, `Bornology.IsBounded.ediam_ne_top`, characterizes the boundedness of a set in terms of the finiteness of its emetric diameter within a pseudometric space. Specifically, it states that for any set `s` of type `α` in a pseudometric space, if `s` is bounded relative to the ambient bornology on `α` (i.e., `Bornology.IsBounded s` is true), then the emetric diameter of `s` is not infinite (`EMetric.diam s ≠ ⊤`).

In a pseudometric space, a bounded set has finite metric diameter.


theorem Mathlib.Logic.Basic._auxLemma.23 :
    ∀ {α : Sort u_2} [inst : Subsingleton α] {p : α → Prop}, (∃! x, p x) = ∃ x, p x := by sorry

This theorem states that for any type `α` that is a subsingleton (i.e., a type with at most one distinct element), and any property `p` that elements of `α` can have, the existence of a unique element `x` such that `p x` holds is equivalent to the existence of an element `x` such that `p x` holds. In other words, if `α` is a subsingleton, then uniqueness is redundant because there is either zero or one element in `α` satisfying `p`, and therefore the existence of a unique `x` satisfying `p` is the same as the existence of `x` satisfying `p`.

If `α` is a subsingleton type, then the unique existence and existence statements for a property `p` are equivalent.


/-- Concatenating the first element of a tuple with its tail gives back the original tuple  -/
theorem Fin.snoc_init_self :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i), Fin.snoc (Fin.init q) (q (Fin.last n)) = q := by
  sorry

The theorem `Fin.snoc_init_self` states that for any natural number `n` and any function `q` mapping indices of a `n+1`-tuple to a type `α`, concatenating the initial segment of the tuple (obtained using `Fin.init`) with the last element of the tuple (obtained using `q (Fin.last n)`) yields the original tuple `q`. In other words, this theorem proves that we can reconstruct the original tuple from its initial segment and its last element, validating the operations of `Fin.snoc` and `Fin.init`.

For any natural number `n` and function `q` from `Fin (n+1)` to type `α`, `Fin.init (Fin.uncons (Fin.cons (Fin.last n) n)) = q`.


theorem LinearEquiv.map_add :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (a b : M),
      e (a + b) = e a + e b :=
  by sorry

This theorem states that for any two elements `a` and `b` from a module `M` over a semiring `R`, the image of their sum under a linear equivalence `e` (a linear mapping that is bijective and thus invertible) to a module `M₂` over another semiring `S` is equal to the sum of the images of `a` and `b` under `e`. In other words, this theorem guarantees that a linear equivalence preserves the operation of addition from `M` to `M₂`.

For any linear equivalence `e` between modules `M` and `M₂` over semirings `R` and `S` respectively, and for any elements `a` and `b` in `M`, we have `e(a + b) = e(a) + e(b)`.


theorem Nat.div_le_div_right : ∀ {a b c : ℕ}, a ≤ b → a / c ≤ b / c := by sorry

This theorem states that for all natural numbers `a`, `b`, and `c`, if `a` is less than or equal to `b`, then the result of integer division of `a` by `c` is less than or equal to the result of integer division of `b` by `c`. In other words, increasing the numerator in a division operation doesn't decrease the division's result.

For all natural numbers a, b, and c, if a ≤ b then a / c ≤ b / c.


theorem Set.Subsingleton.eq_singleton_of_mem :
    ∀ {α : Type u} {s : Set α}, Set.Subsingleton s → ∀ {x : α}, x ∈ s → s = {x} := by sorry

This theorem states that for any given type `α` and a set `s` of that type, if `s` is a `Subsingleton` (meaning it has at most one element), then for any element `x` of type `α` that belongs to `s`, `s` is equal to the singleton set containing only `x`. In other words, if a set has at most one element and an element `x` is in that set, then the set must be exactly the set containing `x`.

If `s` is a subsingleton set of type `α` containing an element `x`, then `s` is equal to the singleton set `{x}`.


theorem Finset.range_mono : Monotone Finset.range := by sorry

The theorem `Finset.range_mono` states that the function `Finset.range` is monotone. In other words, if you have two natural numbers `a` and `b` such that `a ≤ b`, applying the `Finset.range` function to both numbers will yield two sets of natural numbers, and the set derived from `a` will be a subset of or equal to the set derived from `b`. The `Finset.range` function gives a set of natural numbers less than the input number, so as the input number increases, the resulting set of natural numbers can only expand or stay the same, hence the monotonicity.

For all natural numbers `a ≤ b`, `Finset.range a ≤ Finset.range b` holds in the sense of set inclusion.


theorem Submodule.IsPrincipal.mem_iff_generator_dvd :
    ∀ {R : Type u} [inst : CommRing R] (S : Ideal R) [inst_1 : Submodule.IsPrincipal S] {x : R},
      x ∈ S ↔ Submodule.IsPrincipal.generator S ∣ x :=
  by sorry

This theorem is stating that for any commutative ring `R` and an ideal `S` of `R` that is principal, a given element `x` of `R` is in `S` if and only if the generator of `S` divides `x`. In other words, any element `x` is a member of a principal ideal `S` in the ring `R` exactly when it is a multiple of the generator of `S`. Here, a principal ideal is an ideal generated by a single element, and the generator of an ideal is that single element.

A commutative ring's ideal is principal and generated by x if and only if x divisibly covers all elements in the ideal.


/-- If the angle between two vectors is nonzero, the second vector is nonzero.  -/
theorem Orientation.right_ne_zero_of_oangle_ne_zero :
    ∀ {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 ≠ 0 → y ≠ 0 :=
  by sorry

The theorem `Orientation.right_ne_zero_of_oangle_ne_zero` is stating that for any two vectors `x` and `y` in a real inner product space `V` of finite dimension 2, if the oriented angle `oangle` from `x` to `y`, modulo `2 * π`, is nonzero, then the second vector `y` is nonzero. In other words, if the oriented angle between two vectors is distinct from zero, then the second vector cannot be the zero vector.

If the oriented angle between two non-zero vectors in a 2-dimensional real inner product space is nonzero, then the second vector is also nonzero.


theorem Mathlib.Data.Finset.Basic._auxLemma.119 : ∀ (p : Prop), (p ∨ ¬p) = True := by sorry

This theorem states that for any given proposition `p`, the logical disjunction of `p` or not `p` is always true. This is a restatement of the principle of excluded middle in logic, which asserts that, for any proposition, either that proposition is true or its negation is true.

For any proposition `p` in Lean, `p` or not `p` is a logically valid statement. (This is the law of the excluded middle in Lean's logic.)


theorem CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.φ₁ S) S.L₂.f =
        CategoryTheory.ShortComplex.SnakeInput.φ₂ S :=
  by sorry

The theorem `CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f` states that for any category `C` that is also an Abelian category, and for any short complex `S` within that category, the composition of the canonical map `φ₁` with the map `S.L₂.f` is equal to the canonical map `φ₂`. In the language of category theory, this can be written as `φ₁ ∘ S.L₂.f = φ₂`. This theorem is fundamental to the definition of a short complex and its properties in the context of categories.

For any short complex `S` in an Abelian category `C`, the composition of `S.L₂.f` with the canonical map `φ₁` equals the canonical map `φ₂`, i.e., `φ₁ ∘ S.L₂.f = φ₂`.


theorem ULift.down_inf : ∀ {α : Type u} [inst : Inf α] (a b : ULift.{u_1, u} α), (a ⊓ b).down = a.down ⊓ b.down := by
  sorry

This theorem describes how the infimum operation (`inf` or `⊓`) interacts with the `ULift.down` function in Lean 4. For any type `α` equipped with an infimum operation and any two elements `a` and `b` of the type `ULift α`, the infimum of `a` and `b` after applying the `down` function is the same as the infimum of the `down` of `a` and the `down` of `b`. In other words, applying `down` before or after taking the infimum gives the same result.

For any type `α` with an infimum operation and for all `a` and `b` in `ULift α`, `inf (down a) (down b) = down (inf a b)`.


theorem Icc_mem_nhdsWithin_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b c : α},
      b ∈ Set.Ico a c → Set.Icc a c ∈ nhdsWithin b (Set.Ici b) :=
  by sorry

This theorem states that for any type `α` that has a topological space structure, a linear order, and a topology where left-closed right-infinite intervals are closed, given any three elements `a`, `b`, and `c` of `α`, if `b` is in the left-closed right-open interval from `a` to `c` (i.e., `a ≤ b < c`), then the left-closed right-closed interval from `a` to `c` (i.e., `a ≤ x ≤ c`) is in the "neighborhood within" filter of `b` with respect to the left-closed right-infinite interval starting from `b` (i.e., `b ≤ x`). In simpler terms, this theorem is about a certain containment relationship involving intervals and a specific type of neighborhood in a specific type of topological space.

If `α` is a type with a topology where left-closed right-infinite intervals are closed, and `a`, `b`, and `c` are elements of `α` with `a ≤ b < c`, then the left-closed right-closed interval from `a` to `c` is in the neighborhood filter of `b` with respect to the left-closed right-infinite interval starting from `b`.


theorem Ordinal.blsub_le :
    ∀ {o : Ordinal.{u_4}} {f : (b : Ordinal.{u_4}) → b < o → Ordinal.{max u_4 u_5}} {a : Ordinal.{max u_4 u_5}},
      (∀ (i : Ordinal.{u_4}) (h : i < o), f i h < a) → Ordinal.blsub o f ≤ a :=
  by sorry

The theorem `Ordinal.blsub_le` states that for any ordinal `o`, function `f` from ordinals less than `o` to ordinals, and any ordinal `a`, if for all `i` less than `o`, `f(i)` is less than `a`, then the least strict upper bound of the family of ordinals defined by `f` and indexed by the set of ordinals less than `o` is less than or equal to `a`.

If `f` is a function from ordinals less than `o` to ordinals such that `f(i)` is less than `a` for all `i` less than `o`, then the least upper bound of the family `{f(i) | i < o}` is less than or equal to `a`.


theorem UpperHalfPlane.sinh_half_dist :
    ∀ (z w : UpperHalfPlane),
      Real.sinh (dist z w / 2) = dist ↑z ↑w / (2 * Real.sqrt (UpperHalfPlane.im z * UpperHalfPlane.im w)) :=
  by sorry

The theorem `UpperHalfPlane.sinh_half_dist` states that for any two points `z` and `w` in the open upper half plane, the real hyperbolic sine of half the distance between `z` and `w` is equal to half the distance between the complexified versions of `z` and `w` divided by the square root of the product of the imaginary parts of `z` and `w`. In mathematical notation, this can be written as $\sinh\left(\frac{{\text{{dist}}(z, w)}}{2}\right) = \frac{{\text{{dist}}(\mathbf{C}(z), \mathbf{C}(w))}}{2 \sqrt{{\text{{Im}}(z) \cdot \text{{Im}}(w)}}}$, where $\mathbf{C}(z)$ and $\mathbf{C}(w)$ denote the complexified versions of `z` and `w`, and `Im` denotes the imaginary part of a complex number.

The hyperbolic sine of half the real distance between two points in the open upper half plane is equal to one-half of the complex distance between their complexified versions divided by the square root of their imaginary product.


theorem Finset.univ_map_equiv_to_embedding :
    ∀ {α : Type u_4} {β : Type u_5} [inst : Fintype α] [inst_1 : Fintype β] (e : α ≃ β),
      Finset.map (Equiv.toEmbedding e) Finset.univ = Finset.univ :=
  by sorry

This theorem states that for any two types `α` and `β` which are finite (`Fintype α` and `Fintype β`), given an equivalence `e` between `α` and `β`, the image of the universal finite set of `α` under the mapping defined by `e` is the universal finite set of `β`. In other words, when `α` and `β` are of the same finite size, mapping the entire set of `α` to `β` using an equivalence will give us the entire set of `β`. This theorem validates the action of an embedding derived from an equivalence on the universal sets in the context of finite sets.

For any finite types `α` and `β` and equivalence `e` between them, the image of the universal set of `α` under `e` is the universal set of `β`.


HasFDerivAt.restrictScalars

theorem HasFDerivAt.restrictScalars :
    ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
      [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
      [inst_8 : NormedSpace 𝕜 F] [inst_9 : NormedSpace 𝕜' F] [inst_10 : IsScalarTower 𝕜 𝕜' F] {f : E → F}
      {f' : E →L[𝕜'] F} {x : E}, HasFDerivAt f f' x → HasFDerivAt f (ContinuousLinearMap.restrictScalars 𝕜 f') x :=
  by sorry

The theorem `HasFDerivAt.restrictScalars` states that for any non-trivially normed fields `𝕜` and `𝕜'` with a normed algebra structure between them, any normed additive commutative groups `E` and `F` made into normed spaces over `𝕜` and `𝕜'` which also forms a scalar tower, if a function `f : E → F` has a continuous linear map `f' : E →L[𝕜'] F` as its derivative at a point `x` in `E` (i.e., `HasFDerivAt f f' x`), then `f` also has the derivative `ContinuousLinearMap.restrictScalars 𝕜 f'`, which is the restriction of `f'` to the scalars `𝕜`, at the same point `x` (i.e., `HasFDerivAt f (ContinuousLinearMap.restrictScalars 𝕜 f') x`). In other words, the derivative of the function `f` remains the same when we restrict the scalars from `𝕜'` to `𝕜`.

The theorem asserts that if a continuous linear map is the derivative of a function between two normed vector spaces over non-trivially normed fields and forms a scalar tower, then the restriction of the linear map to the base field is also the derivative of the function at that point.


MulAction.bijective

theorem MulAction.bijective :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] (g : α), Function.Bijective fun x => g • x :=
  by sorry

The theorem `MulAction.bijective` states that for any type `α` of a group and any type `β` on which the group acts (represented by `MulAction α β`), for any element `g` of the group, the function that maps each element `x` in `β` to the product `g • x` is bijective. In other words, the action of multiplying by a fixed group element is a bijective function from `β` to itself. This means that it is both injective (no two different elements map to the same result) and surjective (every possible result is achieved by mapping some element).

For any group `α` and any type `β` with a group action `MulAction α β`, the function `x mapsto g • x` is a bijective function on `β` for all `g` in `α`.


theorem MDifferentiableAt.mdifferentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} {s : Set M}, MDifferentiableAt I I' f x → MDifferentiableWithinAt I I' f s x :=
  by sorry

This theorem, `MDifferentiableAt.mdifferentiableWithinAt`, states that within any non-trivially normed field and for any selection of normed additive commutative groups, normed spaces, topologies, charts, models with corners, and a function `f` from `M` to `M'`, if `f` is differentiable at a point `x` in `M` under the models with corners `I` and `I'`, then `f` is also differentiable within any set `s` in `M` at the same point `x` under the same models. In mathematical terms, it asserts local differentiability implies differentiability within a subset.

If a function is differentiable at a point in a normed space under certain models with corners, then it is differentiable within any subset of the space at that point under the same models.


theorem one_le_inv : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → a ≤ 1 → 1 ≤ a⁻¹ := by sorry

This theorem states that for any type `α` that forms a linearly ordered semifield, given any element `a` of `α`, if `a` is greater than `0` and less than or equal to `1`, then the inverse of `a` (denoted as `a⁻¹`) is greater than or equal to `1`. Essentially, it is capturing the intuitive idea in fractional numbers where if a fraction is less than one, its reciprocal is greater than one.

For any linearly ordered semifield type `α` and element `a` in `α` with `0 < a <= 1`, the inverse `a⁻¹` satisfies `1 <= a⁻¹`.


theorem Filter.tendsto_finset_range : Filter.Tendsto Finset.range Filter.atTop Filter.atTop := by sorry

The theorem `Filter.tendsto_finset_range` states that the function `Finset.range` tends to infinity, as defined by the `Filter.atTop` filter, when its input tends to infinity. In other words, as the input natural number increases without bound, the set of natural numbers less than that input, which is generated by the `Finset.range` function, also increases without bound. This is a formal way to express the intuitive notion that the range of a number, or the set of all natural numbers less than it, grows as the number itself grows.

The `Finset.range` function maps larger natural numbers to larger and unbounded finite sets.


theorem hasSum_geometric_of_norm_lt_one :
    ∀ {K : Type u_4} [inst : NormedField K] {ξ : K}, ‖ξ‖ < 1 → HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹ := by sorry

This theorem states that for any type `K` that is a normed field and any element `ξ` of `K`, if the norm of `ξ` is less than one, then the sum of the infinite geometric series where each term is `ξ` to the power of `n` converges to the value `(1 - ξ)⁻¹`. A geometric series is a series for which each term after the first is found by multiplying the previous term by a fixed, non-zero number called the common ratio. In this case, `ξ` is the common ratio.

For any normed field `K` and element `ξ` of norm less than 1 in `K`, the infinite geometric series `∑(ξ^n)` converges to `(1 - ξ)⁻¹`.


theorem Ordinal.IsNormal.le_iff_eq :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_4}}, Ordinal.IsNormal f → ∀ {a : Ordinal.{u_4}}, f a ≤ a ↔ f a = a := by sorry

The theorem `Ordinal.IsNormal.le_iff_eq` states that for all ordinal functions `f` that are normal, and for any ordinal `a`, the function value `f(a)` is less than or equal to `a` if and only if `f(a)` equals `a`. This means that in the context of normal ordinal functions, the only way for `f(a)` to be less than or equal to `a` is for `f(a)` to be exactly equal to `a`.

For any normal ordinal function `f` and ordinal `a`, `f(a) ≤ a` if and only if `f(a) = a`.


theorem sInf_insert : ∀ {α : Type u_1} [inst : CompleteLattice α] {a : α} {s : Set α}, sInf (insert a s) = a ⊓ sInf s :=
  by sorry

The theorem `sInf_insert` states that for any type `α` equipped with a structure of a complete lattice, any element `a` of `α`, and any set `s` of elements of `α`, the infimum (greatest lower bound) of the insertion of the element `a` into the set `s` is the infimum of the set `s` and the element `a`. This is denoted by `a ⊓ sInf s`, where `sInf` represents the infimum of a set and `⊓` is the infimum of two elements.

For any complete lattice `α`, the infimum of an element `a` and the infimum of a set `s` is equal to the infimum of the set `s` with `a` inserted. In symbols: `a ⊓ sInf s = sInf (s : set α ++ {a})`.


theorem List.get?_eq_some :
    ∀ {α : Type u_1} {a : α} {l : List α} {n : ℕ},
      List.get? l n = some a ↔ ∃ (h : n < List.length l), List.get l { val := n, isLt := h } = a :=
  by sorry

This theorem states that for any type `α`, any element `a` of type `α`, any list `l` of elements of type `α`, and any natural number `n`, the function `List.get?` applied to the list `l` and the number `n` results in `some a` if and only if there exists a natural number `h` such that `n` is less than the length of the list `l` and the function `List.get` applied to the list `l` and the number `n` (with proof that `n` is less than the length of `l`) results in `a`. In other words, the theorem establishes a correspondence between the successful retrieval of an element at a specified index in a list using the `get?` function and the existence of a valid index within the bounds of the list length.

For any type `α`, list `l` of length `n` in `α`, and natural number `i` less than `n`, `List.get? l i = some a` if and only if `List.get l i = a`.


theorem Nat.pred_eq_sub_one : ∀ (n : ℕ), Nat.pred n = n - 1 := by sorry

This theorem, `Nat.pred_eq_sub_one`, states that for every natural number `n`, the predecessor function `Nat.pred n` is equivalent to `n - 1`. In other words, applying the predecessor function to any natural number yields the same result as subtracting 1 from that number.

For all natural numbers n, Nat.pred n = n - 1.


theorem Ordinal.IsNormal.le_iff :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}}, Ordinal.IsNormal f → ∀ {a b : Ordinal.{u_4}}, f a ≤ f b ↔ a ≤ b := by sorry

This theorem states that for any normal ordinal function `f` mapping from an ordinal `a` to an ordinal `b`, `f(a)` is less than or equal to `f(b)` if and only if `a` is less than or equal to `b`. This essentially means that a normal ordinal function preserves the order of the ordinals. The normality of the function ensures its strict monotonicity and order-continuity.

A normal ordinal function preserves the order of ordinals: for all ordinals a and b, f(a) ≤ f(b) if and only if a ≤ b.


theorem AddGroup.mem_closure :
    ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G} {a : G}, a ∈ s → a ∈ AddGroup.closure s := by sorry

This theorem states that for any type `G` that is an additive group, and for any set `s` of elements of type `G`, any element `a` of `G` that belongs to the set `s` also belongs to the closure of `s` under the additive group operation. Thus, the additive group generated by `s` (denoted by `AddGroup.closure s`), which is the smallest additive group containing `s`, always includes every element of `s`.

For any additive group `G` and set `s` of its elements, every element `a` in `s` lies in the closure of `s` under the additive group operation. Equivalently, the additive group generated by `s` includes `s`.


IsLocalExtr.elim

theorem IsLocalExtr.elim :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {a : α} {p : Prop},
      IsLocalExtr f a → (IsLocalMin f a → p) → (IsLocalMax f a → p) → p :=
  by sorry

The theorem `IsLocalExtr.elim` states that for any type `α` equipped with a topology and any type `β` equipped with a preorder, given a function `f : α → β` and an element `a : α`, if `a` is a local extremum of `f` (either a local minimum or a local maximum), then any proposition `p` that holds when `a` is a local minimum of `f` and when `a` is a local maximum of `f` also holds. In other words, this theorem allows us to analyze all local extrema (minima and maxima) of `f` in a unified way.

If a function `f` from a topological space `α` to a preordered type `β` has `a` as a local extremum, then any proposition `p` invariant under interchanging local minima and maxima holds at `a`.


theorem Finset.sym2_val : ∀ {α : Type u_1} (s : Finset α), (Finset.sym2 s).val = Multiset.sym2 s.val := by sorry

This theorem states that for every type `α` and a finite set `s` of type `α`, the value of the set of all unordered pairs of elements from `s` (obtained through `Finset.sym2`) is equal to the multiset of all unordered pairs of elements from the multiset `s.val` (obtained through `Multiset.sym2`). Here, `s.val` refers to the underlying multiset of the finite set `s`. In essence, it claims that the transformation of a finite set to a set of its unordered pairs is equivalent to the transformation of its underlying multiset to a multiset of its unordered pairs.

For every finite multiset `s` of type `α`, the multiset of unordered pairs of elements in `s` (obtained through `Multiset.sym2`) is equal to the set of unordered pairs of elements from the underlying finite set of `s` (obtained through `Finset.sym2`).


theorem Nat.even_or_odd : ∀ (n : ℕ), Even n ∨ Odd n := by sorry

This theorem states that for every natural number `n`, the number is either even or odd. A natural number `n` is defined as even if it can be expressed as the sum of two identical numbers, and as odd if it can be expressed as `2*k + 1` for some number `k`. Thus, the theorem asserts that any natural number fits one of these two definitions.

Every natural number can be expressed as an even number (the sum of two identical numbers) or an odd number (2 times an integer plus 1).


theorem Real.sign_zero : Real.sign 0 = 0 := by sorry

The theorem `Real.sign_zero` states that the sign function applied to the real number 0 is 0. In other words, according to our definition of the sign function for real numbers, where negative numbers are mapped to -1, positive numbers to 1, and 0 is left as is, when we apply this function on 0, we get 0 in return.


theorem Submodule.neg_mem :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] {module_M : Module R M} (p : Submodule R M)
      {x : M}, x ∈ p → -x ∈ p :=
  by sorry

This theorem states that for any ring 'R' and additive commutative group 'M' with 'M' being a module over 'R', and for any submodule 'p' of 'M', if an element 'x' belongs to 'p', then the additive inverse of 'x' (represented as '-x') also belongs to 'p'. In other words, if a submodule includes a certain element, it also includes the negation of that element.

If 'p' is a submodule of the additive commutative group 'M' over the ring 'R', then for all 'x' in 'p', we have '-x' (the additive inverse of 'x') also in 'p'.


Matrix.Represents.eq

theorem Matrix.Represents.eq :
    ∀ {ι : Type u_1} [inst : Fintype ι] {M : Type u_2} [inst_1 : AddCommGroup M] {R : Type u_3} [inst_2 : CommRing R]
      [inst_3 : Module R M] {b : ι → M},
      Submodule.span R (Set.range b) = ⊤ →
        ∀ [inst_4 : DecidableEq ι] {A : Matrix ι ι R} {f f' : Module.End R M},
          Matrix.Represents b A f → Matrix.Represents b A f' → f = f' :=
  by sorry

This theorem states that for any finite type `ι`, an additive commutative group `M`, a commutative ring `R`, and a module `M` over `R`, given a function `b` from `ι` to `M` such that the span of the range of `b` is the entire module `M`, and given a decidable equality on `ι`, if we have a matrix `A` and two endomorphisms `f` and `f'` of the module `M` such that the matrix `A` represents both `f` and `f'` with respect to the basis `b`, then `f` and `f'` must be equal. In other words, the representation of an endomorphism by a matrix with respect to a basis is unique.

Given a finite type `ι`, an additive commutative group `M`, a commutative ring `R`, and an `R`-module `M` with basis `b` such that the span of `b` is `M` and decidable equality, if matrices `A` represent both endomorphisms `f` and `f'` of `M` with respect to `b`, then `f = f'`.


theorem Finset.coe_neg :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveNeg α] (s : Finset α), ↑(-s) = -↑s := by sorry

The theorem `Finset.coe_neg` states that for any given type `α`, under the conditions that `α` has decidable equality (represented by `DecidableEq α`) and `α` has an involutive negation operation (represented by `InvolutiveNeg α`), for any given finite set `s` of type `α` (represented by `s : Finset α`), the coercion of the negation of `s` is equal to the negation of the coercion of `s`. In other words, negating each element in the set and then taking the whole set as a unit is the same as first taking the set as a unit and then negating it.

For any type `α` with decidable equality and an involutive negation operation, the negation of a finite set `s` of type `α` is equal to the set of negations of its elements.


theorem ContinuousLinearMap.map_sub :
    ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {M : Type u_4} [inst_2 : TopologicalSpace M]
      [inst_3 : AddCommGroup M] {M₂ : Type u_5} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂]
      [inst_6 : Module R M] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} (f : M →SL[σ₁₂] M₂) (x y : M),
      f (x - y) = f x - f y :=
  by sorry

This theorem states that for any continuous linear map `f` from a module `M` over a ring `R` to a module `M₂` over a ring `R₂`, the mapping preserves subtraction. More specifically, for all elements `x` and `y` in `M`, applying the map `f` to the difference of `x` and `y` (`f (x - y)`) yields the same result as subtracting the mapping of `y` from the mapping of `x` (`f x - f y`). This property holds for any topological spaces `M` and `M₂` that also have an additive commutative group structure, and any ring homomorphism `σ₁₂` from `R` to `R₂`.

For any continuous linear map $f$ from a module $M$ over a ring $R$ to a module $M\_2$ over a ring $R\_2$ and any ring homomorphism $\sigma \_{12}: R \rightarrow R\_2$, the equation $f(x - y) = f(x) - f(y)$ holds for all $x, y \in M$.


theorem Substring.ValidFor.of_eq :
    ∀ {l m r : List Char} (s : Substring),
      s.str.data = l ++ m ++ r →
        s.startPos.byteIdx = String.utf8Len l →
          s.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Substring.ValidFor l m r s :=
  by sorry

This theorem states that for any three lists of characters `l`, `m`, and `r`, and any substring `s`, if the data of the substring `s` is equal to the concatenation of `l`, `m`, and `r`, and the starting byte index of `s` is equal to the UTF-8 byte length of `l`, and the stopping byte index of `s` is equal to the sum of the UTF-8 byte length of `l` and the UTF-8 byte length of `m`, then `s` is a valid substring for the lists `l`, `m`, and `r`. This essentially is a condition for the validity of a substring based on its byte indices and the byte lengths of certain lists of characters.

For lists of characters `l`, `m`, and `r`, and substring `s` with data equal to `l ++ m ++ r`, starting index equal to the UTF-8 byte length of `l`, and stopping index equal to the sum of the UTF-8 byte lengths of `l` and `m`, `s` is a valid substring of the concatenation of `l` and `r`.


theorem Nat.one_lt_pow : ∀ {a n : ℕ}, n ≠ 0 → 1 < a → 1 < a ^ n := by sorry

This theorem states that for any natural numbers `a` and `n`, if `n` is not equal to 0 and `a` is greater than 1, then the value of `a` raised to the power of `n` (denoted as `a ^ n`) will be greater than 1. In other words, any natural number greater than 1, when raised to any non-zero natural number, will yield a result greater than 1.

For all natural numbers `a` greater than 1 and `n` non-zero, `a^n > 1`.


theorem Continuous.le_induced :
    ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {t' : TopologicalSpace β} {f : α → β},
      Continuous f → t ≤ TopologicalSpace.induced f t' :=
  by sorry

This theorem states that for any two types `α` and `β`, and any topological spaces `t` on `α` and `t'` on `β`, if a function `f : α → β` is continuous, then the topology `t` is finer than or equal to the topology induced by `f` on `α` with respect to the topology `t'` on `β`. In other words, any open set in `t` is also an open set in the induced topology. Here, the term "finer than" in terms of topologies signifies that a topology has more open sets.

Given types `α` and `β`, topologies `t` on `α` and `t'` on `β`, and a continuous function `f : α → β`, the topology `t` is included in the topology `t'` induced on `α` by `f`.


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

The theorem `Finset.union_empty` states that for any type `α` that has decidable equality, and any finite set `s` of type `α`, the union of `s` and the empty set is equal to `s`. In other words, for any finite set `s`, adding nothing to `s` does not change `s`. This corresponds to the mathematical principle that the union of any set with the empty set is the set itself.

For any finite set `s` of type `α` with decidable equality, `s ∪ {} = s`.


theorem openSegment_eq_image :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] (x y : E),
      openSegment 𝕜 x y = (fun θ => (1 - θ) • x + θ • y) '' Set.Ioo 0 1 :=
  by sorry

This theorem states that for any ordered ring `𝕜` and any additive commutative group `E` that is a `𝕜`-module, and for any two elements `x` and `y` of `E`, the open segment between `x` and `y` is equivalent to the image of the function `(1 - θ) • x + θ • y` over the open interval `(0, 1)`. In simpler terms, every point in the open line segment between `x` and `y` can be represented as a convex combination of `x` and `y` with coefficients in the open interval `(0, 1)`. This theorem is essentially a representation theorem for an open line segment in a vector space.

For any ordered ring `𝕜` and `𝕜`-module `E`, the open segment between any two elements `x` and `y` in `E` is equivalent to the image of the function `(1 - θ) • x + θ • y` over the open interval `(0, 1)`, where `θ` is an element of `𝕜` between `0` and `1`.


IsCompact.isSeqCompact

theorem IsCompact.isSeqCompact :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : FirstCountableTopology X] {s : Set X},
      IsCompact s → IsSeqCompact s :=
  by sorry

This theorem states that for any set `s` in a topological space `X` which also has a first countable topology, if `s` is compact, then `s` is sequentially compact. In other words, if any nontrivial filter containing `s` intersects every neighborhood of some point in `s`, then every sequence of points in `s` has a subsequence that converges to a point in `s`. This theorem is a fundamental result connecting the concepts of compactness and sequential compactness in general topological spaces.

In a first countable topological space, every compact set is sequentially compact.


theorem IsUnit.exists_right_inv : ∀ {M : Type u_1} [inst : Monoid M] {a : M}, IsUnit a → ∃ b, a * b = 1 := by sorry

This theorem, `IsUnit.exists_right_inv`, states that for any given type `M` that is a Monoid, and any element `a` of `M` that is a unit (i.e., it has a two-sided inverse), there exists another element `b` such that the product of `a` and `b` is the identity element of the Monoid, which is `1`. In other words, if `a` is a unit in a Monoid, it has a right inverse.

Given a Monoid `M` and a unit `a` in `M`, there exists a right inverse `b` such that `a * b = 1`.


/-- In a real vector space, a convex set with nonempty interior is a set of unique
differentiability.  -/
theorem uniqueDiffOn_convex :
    ∀ {G : Type u_4} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {s : Set G},
      Convex ℝ s → Set.Nonempty (interior s) → UniqueDiffOn ℝ s :=
  by sorry

The theorem `uniqueDiffOn_convex` states that in a real normed additive commutative group (which is also a normed space over the real numbers), any convex set with a non-empty interior is uniquely differentiable. This means that for any such set, each point in the set has a unique tangent space, or equivalently, a unique derivative for every differentiable function defined on the set.

In a real normed additive commutative group with a non-empty interior, every convex set is uniquely differentiable.


theorem List.nodup_iff_injective_get : ∀ {α : Type u} {l : List α}, List.Nodup l ↔ Function.Injective (List.get l) := by
  sorry

The theorem `List.nodup_iff_injective_get` states that for any type `α` and any list `l` of type `α`, the list `l` has no duplicate elements if and only if the function `List.get l` is injective. In other words, a list `l` is duplicate-free precisely when each index in the list `l` corresponds to a unique element, meaning that if two indices provide the same element, those two indices must be the same.

A list of type `α` has no duplicate elements if and only if the function `List.get` on that list is injective.


Set.Subsingleton.einfsep

theorem Set.Subsingleton.einfsep :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, Set.Subsingleton s → Set.einfsep s = ⊤ := by sorry

The theorem `Set.Subsingleton.einfsep` states that for any type `α` equipped with an extended distance function (`EDist α`), and for any set `s` of this type, if `s` is a subsingleton (that is, if it has at most one element), then the extended infimum separation of `s` is equal to the extended non-negative real number infinity (`⊤`). The extended infimum separation of a set is the greatest lower bound of the distance between distinct elements of the set. In case of a subsingleton set, since there are either zero or one elements, the distance between distinct elements is undefined and thus considered as infinity.

For any type `α` with an extended distance function and any subsingleton set `s` of `α`, the extended infimum separation of `s` equals the infinity symbol `⊤`.


theorem inv_mul_le_iff_le_mul :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α}, b⁻¹ * a ≤ c ↔ a ≤ b * c :=
  by sorry

This theorem, `inv_mul_le_iff_le_mul`, states that for any type `α` that is a group and has an order (`LE`), and for which multiplication is covariant, given any three elements `a`, `b`, and `c` of that type, the inequality `b⁻¹ * a ≤ c` holds if and only if the inequality `a ≤ b * c` holds. In other words, multiplying `a` by the inverse of `b` is less than or equal to `c` if and only if `a` is less than or equal to the product of `b` and `c`.

For any group type `α` with order `LE` and covariant multiplication, the equality `b^(-1) * a ≤ c` is equivalent to `a ≤ b * c`.


theorem dvd_of_mul_left_dvd : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b c : α}, a * b ∣ c → b ∣ c := by sorry

This theorem states that, given a commutative semigroup (which is a type of algebraic structure with an associative, commutative operation) and three elements `a`, `b`, and `c` of that semigroup, if the product of `a` and `b` divides `c` (denoted by `a * b ∣ c`), then `b` also divides `c` (denoted by `b ∣ c`). This holds true for any arbitrary type `α` which has a commutative semigroup structure.

If `a`, `b`, and `c` are elements of a commutative semigroup `α`, then `a * b ∣ c` implies `b ∣ c`.


theorem not_lt_of_lt : ∀ {α : Sort u} {lt : α → α → Prop} [inst : IsStrictOrder α lt] {a b : α}, lt a b → ¬lt b a := by
  sorry

This theorem, "not_lt_of_lt", states that for any strictly ordered type `α` with a "less-than" relation `lt`, if a certain element `a` is less than another element `b`, then `b` cannot be less than `a`. This theorem applies to any strictly ordered set, where "strictly ordered" means that the relation is irreflexive (no element is less than itself) and transitive (if `a` is less than `b` and `b` is less than `c`, then `a` is less than `c`). This theorem captures the key property of asymmetric relations in strictly ordered sets.

In a strictly ordered set, if `a` is less than `b`, then `b` cannot be less than `a`.


theorem Submodule.singleton_span_isCompactElement :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
      CompleteLattice.IsCompactElement (Submodule.span R {x}) :=
  by sorry

This theorem states that for any semiring `R` and commutative additive monoid `M` that forms a module over `R`, and for any element `x` in `M`, the span of the singleton set `{x}` forms a compact element in the complete lattice of submodules of `M`. In other words, if any set of submodules of `M` has a supremum above the singleton span of `x`, then there exists a finite subset of this set whose supremum is also above the singleton span of `x`.

Given a commutative additive monoid `M` over a semiring `R` with `{x} ⊆ M` being a generating set for a submodule, the span of `{x}` is compact in the lattice of submodules of `M`, i.e., any upward-closed set of submodules containing the span of `{x}` has a finite supremum above it.


theorem finprod_cond_eq_prod_of_cond_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {p : α → Prop} {t : Finset α},
      (∀ {x : α}, f x ≠ 1 → (p x ↔ x ∈ t)) → (finprod fun i => finprod fun x => f i) = Finset.prod t fun i => f i :=
  by sorry

This theorem states that for any types `α` and `M` with `M` a commutative monoid, and any function `f` from `α` to `M`, given a predicate `p` on `α` and a finite set `t` of elements of type `α`, if for all `x` in `α`, `f x` is not equal to `1` implies that `p x` if and only if `x` is in `t`, then the product of `f x` over all `x` in the multiplicative support of `f`, where the product is defined by `finprod`, is equal to the product of `f i` over all `i` in the finite set `t`, where the product is defined by `Finset.prod`. In mathematical terms, this theorem is saying that under the conditions specified, the infinite product `∏ (f x : ∀ x)` is equal to the finite product `∏ₜ (f i : ∀ i ∈ t)`.

Given a commutative monoid M, a function f from type α to M, a predicate p on α, and a finite set t of elements in α such that for all x in α, if f x ≠ 1 then p(x) if and only if x is in t, the infinite product ∏(fx) over all x in the multiplicative support of f is equal to the finite product ∏i∈t(fi).


theorem neg_smul_neg :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r : R) (x : M),
      -r • -x = r • x :=
  by sorry

The theorem `neg_smul_neg` states that for every ring `R`, additive commutative group `M`, and module `M` over `R`, for any element `r` from `R` and any element `x` from `M`, the scalar multiplication of the negation of `r` and the negation of `x` equals the scalar multiplication of `r` and `x`. In mathematical terms, it says that for any ring `R` and any `R`-module `M`, if `r` is an element of `R` and `x` is an element of `M`, then `(-r) * (-x) = r * x`.

For every ring `R` and `R`-module `M`, the negation of their scalar multiplication is commutative, that is, `(-r) * (-x) = r * x` for all `r` in `R` and `x` in `M`.


theorem Derivation.map_smul :
    ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
      (D : Derivation R A M) (r : R) (a : A), D (r • a) = r • D a :=
  by sorry

This theorem states that for any given derivation `D` from a commutative semiring `A` into an additive commutative monoid `M`, that is also an `A`-module and `R`-module, and for any scalar `r` from a commutative semiring `R` and any element `a` from `A`, the derivation of the scalar multiplication of `r` and `a` is equal to the scalar multiplication of `r` and the derivation of `a`. In formal terms, `D (r • a) = r • D a`. This property shows the compatibility of the derivation with scalar multiplication.

For any commutative semiring homomorphism `D` from a commutative semiring `A` to an additive commutative monoid `M` that is also an `A`-module and `R`-module, `D (r * a) = r * D a` for all `r` in `R` and `a` in `A`.


theorem Finset.sort_nodup :
    ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r] [inst_2 : IsAntisymm α r]
      [inst_3 : IsTotal α r] (s : Finset α), List.Nodup (Finset.sort r s) :=
  by sorry

The theorem `Finset.sort_nodup` states that for any type `α`, any decidable relation `r` on `α` which is transitive, antisymmetric and total, and any finset `s` of type `α`, the list that results from sorting `s` using the relation `r` has no duplicate elements. In other words, for any given set of items and a specific way of ordering those items, if you sort the set according to that order, you will get a list where each item appears at most once.

For any type `α`, decidable relation `r` on `α` that is transitive, antisymmetric, and total, and any finset `s` of `α`, the sorted list `s.to_list.sort r` has no duplicate elements.


theorem Finset.forall_mem_cons :
    ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s) (p : α → Prop),
      (∀ x ∈ Finset.cons a s h, p x) ↔ p a ∧ ∀ x ∈ s, p x :=
  by sorry

This theorem states that for any type `α`, any finite set `s` of `α`, any element `a` of type `α`, and any property `p` pertaining to the elements of `α`, the property `p` holds for all elements in the finite set obtained by adding `a` to `s` (i.e., `Finset.cons a s`) if and only if `p` holds for `a` and for all elements in `s`. In other words, a property is true for all elements of the union set `{a} ∪ s` if and only if it's true for `a` and for all elements of `s`.

For any type `α`, property `p`, finite set `s` of `α`, and `a` in `α`, `p` holds for the finite set `{a} ∪ s` if and only if `p` holds for `a` and all elements in `s`.


theorem TopCat.Presheaf.SheafConditionEqualizerProducts.piOpens.proof_1 :
    ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
      {X : TopCat} (F : TopCat.Presheaf C X) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X),
      CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun i => F.obj (Opposite.op (U i))) :=
  by sorry

This theorem states that for any category `C` with products, any `C`-valued presheaf `F` on a topological space `X`, and any family `U` of open subsets of `X` indexed by a type `ι`, there exists a limit of the functor from the discrete category on `ι` to `C` that sends each index `i` to the value of the presheaf `F` on the open subset `U i`. In other words, given a collection of open subsets of a topological space and a presheaf that assigns to each open set an object of a category, we can find a product in the category that represents all the objects assigned to the open sets by the presheaf.

Given a topological space X, any C-valued presheaf F, and a family U of open subsets of X indexed by a type ι, there exists an object in C that is the limit of F over U.


theorem Filter.filter_eq_bot_of_isEmpty : ∀ {α : Type u} [inst : IsEmpty α] (f : Filter α), f = ⊥ := by sorry

This theorem states that for any type `α` which is empty (i.e., there are no values of this type), any filter `f` over this type `α` is equal to the bottom filter. The bottom filter, denoted by `⊥`, is the smallest filter which is included in all other filters. Basically, if there are no elements in the type, any filter on that type can only be the empty filter.

For any empty type `α`, the bottom filter `⊥` is the unique filter over `α`.


theorem Fin.castSucc_lt_or_lt_succ : ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), Fin.castSucc i < p ∨ p < Fin.succ i := by
  sorry

The theorem `Fin.castSucc_lt_or_lt_succ` states that for any natural number `n`, and for any elements `p` from `Fin (n + 1)` and `i` from `Fin n`, either `i` when embedded in `Fin (n + 1)` using `Fin.castSucc` is less than `p`, or `p` is less than the successor of `i` in `Fin (Nat.succ n)`. In other words, it expresses a total order between the cast successor of `i` and the natural successor of `i`, relative to a given element `p`.

For any natural numbers `n`, `i` in `Fin n`, and `p` in `Fin (n + 1)`, either `Fin.castSucc i < p` or `p < Fin.castSucc (i + 1)` holds in the total order of `Fin (Nat.succ n)`.


theorem FirstOrder.Language.Theory.Model.isSatisfiable :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} (M : Type w) [inst : Nonempty M]
      [inst : FirstOrder.Language.Structure L M] [inst : M ⊨ T], FirstOrder.Language.Theory.IsSatisfiable T :=
  by sorry

This theorem states that for any first-order language `L` and any theory `T` over that language, if there exists a type `M` such that `M` is nonempty, `M` is a structure for the language `L`, and `M` models the theory `T`, then the theory `T` is satisfiable. In other words, if we have a structure that correctly interprets all the sentences in a theory, then it is possible to find a model for that theory, thus proving its satisfiability.

If a first-order theory over a language has a model, then the theory is satisfiable.


theorem Cardinal.mk_finsupp_lift_of_infinite :
    ∀ (α : Type u) (β : Type v) [inst : Infinite α] [inst : Zero β] [inst_1 : Nontrivial β],
      Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) :=
  by sorry

The theorem `Cardinal.mk_finsupp_lift_of_infinite` states that for any two types `α` and `β`, given that `α` is infinite, `β` is a zero and `β` is nontrivial, the cardinality of the type of finite support functions from `α` to `β` is equal to the maximum of the lifted cardinalities of `α` and `β`. Here, lifting a cardinality refers to the operation that raises the universe level of the cardinality. Finite support functions from `α` to `β` are functions that only assign non-zero values to a finite number of elements in `α`.

For infinite and nontrivial types `α` and `β`, the cardinality of finite support functions from `α` to `β` equals the maximum of the lifted cardinalities of `α` and `β`.


theorem dist_vadd_cancel_right :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] (v₁ v₂ : V) (x : P), dist (v₁ +ᵥ x) (v₂ +ᵥ x) = dist v₁ v₂ :=
  by sorry

The theorem `dist_vadd_cancel_right` states that for any types `V` and `P`, where `V` is a seminormed add commutative group and `P` is a pseudometric space, and `V` acts on `P` as a normed add torsor, the distance between the point obtained by adding a vector `v₁` to a point `x` and the point obtained by adding a vector `v₂` to the same point `x` is equal to the distance between `v₁` and `v₂`. This essentially means that adding the same point `x` to two vectors `v₁` and `v₂` does not change the distance between `v₁` and `v₂`.

For any seminormed add commutative group `V` and pseudometric space `P`, if `V` acts on `P` as a normed add torsor, then the distance between `x + v₁` and `x + v₂` equals the distance between `v₁` and `v₂` for all `x` in `P` and `v₁`, `v₂` in `V`.


theorem TrivSqZeroExt.inr_mul_inr :
    ∀ (R : Type u) {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Module Rᵐᵒᵖ M] (m₁ m₂ : M), TrivSqZeroExt.inr m₁ * TrivSqZeroExt.inr m₂ = 0 :=
  by sorry

This theorem states that for any semiring `R`, and a commutative additive monoid `M` that is also both a left `R`-module and a right `R`-opposite module, the product of `TrivSqZeroExt.inr m₁` and `TrivSqZeroExt.inr m₂` is always zero. Here, `TrivSqZeroExt.inr` is a function that maps a member of `M` to a member of the trivials square-zero extension of `R` and `M`, and `m₁` and `m₂` are any two members of `M`. The trivial square-zero extension of `R` and `M` is a way of creating a ring from a semiring `R` and an `R`-module `M`. The product being always zero suggests that the square-zero extension is a "trivial" extension.

For any commutative additive monoid `M` that is both a left and right `R-`module of a semiring `R`, the product of the images of any two elements of `M` under the function `TrivSqZeroExt.inr` in the trivial square-zero extension of `R` and `M` is always zero.


theorem IsPrimitiveRoot.eq_pow_of_pow_eq_one :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {k : ℕ} {ζ ξ : R},
      IsPrimitiveRoot ζ k → ξ ^ k = 1 → 0 < k → ∃ i < k, ζ ^ i = ξ :=
  by sorry

This theorem states that for any commutative ring `R` that is also a domain, given any natural number `k`, and any two elements `ζ` and `ξ` of `R`, if `ζ` is a primitive root of `k` and `ξ` raised to the power of `k` equals 1, and `k` is greater than 0, then there exists a natural number `i` less than `k` such that `ζ` raised to the power of `i` equals `ξ`. In mathematical language, if $\zeta$ is a primitive $k^{th}$ root of unity in a domain $R$ and $\xi$ raised to the power of $k$ equals 1 (where $k > 0$), there exists an integer $i < k$ such that $\zeta^i = \xi$.

Given a commutative domain R and natural number k, if ζ is a primitive k-th root of unity in R and ξ = ζ^k = 1, then there exists an integer i < k such that ζ^i = ξ.


/-- Given a Localization map `f : M →* N` for a Submonoid `S ⊆ M`, if a `CommMonoid` map
`g : M →* P` induces a map `f.lift hg : N →* P` then for all `z : N, v : P`, we have
`f.lift hg z = v ↔ g x = g y * v`, where `x : M, y ∈ S` are such that `z * f y = f x`.  -/
theorem Submonoid.LocalizationMap.lift_spec :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
      [inst_2 : CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (z : N)
      (v : P),
      (Submonoid.LocalizationMap.lift f hg) z = v ↔
        g (Submonoid.LocalizationMap.sec f z).1 = g ↑(Submonoid.LocalizationMap.sec f z).2 * v :=
  by sorry

This theorem is about the behavior of a localization map in the context of commutative monoids. Specifically, suppose we have a localization map `f : M →* N` from a commutative monoid `M` to another commutative monoid `N` with respect to a submonoid `S ⊆ M`. Additionally, let's say we have a map `g : M →* P` from `M` to a third commutative monoid `P`, which induces a map `f.lift hg : N →* P`.

The theorem then states that for any elements `z : N` and `v : P`, the equality `f.lift hg z = v` holds if and only if `g x = g y * v`, where `x : M` and `y : S` are elements such that `z * f y = f x`.

In other words, the lift of the localization map evaluated at `z` equals `v` precisely when the mapping of `x` under `g` is equal to the mapping of `y` under `g` times `v`. This provides a characterization of those elements that get mapped to `v` by the lift of the localization map.

Given a localization map `f : M →* N` from commutative monoid `M` to `N` with respect to submonoid `S`, and a map `g : M →* P` to a third commutative monoid `P`, the equality `f.lift hg z = v` holds if and only if there exist `x : M` and `y : S` such that `z * f y = f x` and `g x = g y * v`.


theorem Cardinal.aleph'_alephIdx : ∀ (c : Cardinal.{u_1}), Cardinal.aleph' (Cardinal.alephIdx c) = c := by sorry

The theorem `Cardinal.aleph'_alephIdx` asserts that for every cardinal number `c`, applying the function `aleph'` to the ordinal index of `c` (given by `alephIdx`) returns the cardinal `c` itself. In other words, the `aleph'` function and `alephIdx` function are inverses of each other when applied in this specific order. This means that the ordinal index of a cardinal is a unique identifier for that cardinal in the sense that no two different cardinals have the same ordinal index.

The function `aleph'` maps the ordinal index of a cardinal `c` to `c` itself, making `alephIdx` and `aleph'` inverse functions for cardinals.


/-- A function applied to a `dite` is a `dite` of that function applied to each of the branches.  -/
theorem apply_dite :
    ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [inst : Decidable P] (x : P → α) (y : ¬P → α),
      f (dite P x y) = if h : P then f (x h) else f (y h) :=
  by sorry

This theorem states that for any propositional function `P` and a function `f` from `α` to `β`, applying `f` to the result of `dite`, which chooses between two options depending on the truth or falsity of `P`, is the same as choosing between the applications of `f` to each option depending on the truth or falsity of `P`. This essentially means that `f` can be distributed over `dite`. If `P` is true, `f` is applied to `x(h)`; if `P` is false, `f` is applied to `y(h)`. Here, `h` is a proof of `P`'s truth or falsity, `x` is a function from `P` to `α`, and `y` is a function from ¬`P` to `α`.

For any propositional function P and functions f from α to β, x from P to α, and y from ¬P to α, the application of f to dite (P x) (h) is equivalent to dite (P h) (x h) (y h).


theorem Set.sInter_range : ∀ {β : Type u_2} {ι : Sort u_4} (f : ι → Set β), ⋂₀ Set.range f = ⋂ x, f x := by sorry

This theorem states that for any type `β` and any index set `ι`, for any function `f` from `ι` to the sets of `β`, the intersection over the range of `f` is equal to the intersection for each `x` in `ι` of `f x`. In other words, the set of all elements that belong to every set in the range of `f` is the same as the set of all elements that belong to every set `f x` for each `x` in `ι`.

For any function `f` from an index set `ι` to sets of type `β`, the set intersecting over the range of `f` equals the set intersecting each `f x` for `x` in `ι`. In Lean notation: `∩ (range f) = ∏ x in ι, ∩ (f x)`.


theorem Submodule.smul_induction_on :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Ideal R}
      {N : Submodule R M} {p : M → Prop} {x : M},
      x ∈ I • N → (∀ r ∈ I, ∀ n ∈ N, p (r • n)) → (∀ (x y : M), p x → p y → p (x + y)) → p x :=
  by sorry

The theorem `Submodule.smul_induction_on` states that for any commutative semiring `R`, any additive commutative monoid `M` that is also an `R`-module, any ideal `I` in `R`, any submodule `N` of `M`, any property `p` of elements in `M`, and any element `x` in the scalar multiplication of `I` and `N`, if for every element `r` in `I` and every element `n` in `N`, `p` holds for the scalar product of `r` and `n`, and if `p` is closed under addition, i.e., for all elements `x` and `y` in `M`, if `p` holds for `x` and `y` then it also holds for `x + y`, then `p` holds for `x`. In other words, we can use the closure properties of an ideal and a submodule, and the closure of a property under addition, to inductively prove that a property holds for all elements in the scalar multiplication of an ideal and a submodule.

If `I` is an ideal in the commutative semiring `R`, `M` is an additive commutative `R`-module, `N` is a submodule of `M`, `p` is a property of `M` closed under addition and scalar multiplication by elements in `I`, and for all `r` in `I` and `n` in `N`, `p` holds for `r*n`, then `p` holds for every element in the scalar multiplication of `I` and `N`.


theorem Nat.shiftRight_add : ∀ (m n k : ℕ), m >>> (n + k) = m >>> n >>> k := by sorry

This theorem states that for all natural numbers `m`, `n`, and `k`, the shift-right operation on `m` by the sum of `n` and `k` is equivalent to performing a shift-right operation on `m` by `n`, and then performing another shift-right operation on the result by `k`. The shift-right operation, denoted by `>>>`, shifts the binary representation of a number to the right, effectively dividing the number by a power of 2.

For all natural numbers m, n, and k, (m >>> (n + k)) is equivalent to (m >>> n) >>> k.