theorem Mathlib.Data.Int.Interval._auxLemma.3 : ∀ {n : ℕ} {a : ℤ}, (n < Int.toNat a) = (↑n < a) := by sorry

The given theorem, `Mathlib.Data.Int.Interval._auxLemma.3`, states that for all natural numbers `n` and all integers `a`, `n` is less than the natural number equivalent of `a` if and only if `n` as an integer is less than `a`. In other words, a natural number `n` is less than the natural number representation of an integer `a` precisely when `n`, considered as an integer, is also less than `a`. This theorem essentially provides a bridge between the natural and integer number systems for comparison operations.

For all natural numbers n and integers a, n < nat_of_int a if and only if n < a.


theorem Mathlib.Data.Int.Interval._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b := by
  sorry

This theorem asserts that for any types `α` and `β`, an embedding `f` from `α` into `β`, a finite set `s` of type `α`, and an element `b` of type `β`, the condition `b ∈ Finset.map f s` is equivalent to the existence of an element `a` in `s` such that `f a = b`. In other words, `b` belongs to the image of `s` under `f` if and only if `b` is the image of some element in `s`.

For any types `α` and `β`, an embedding `f` from `α` to `β`, and a finite set `s` in `α`, the element `b` is in the image of `s` under `f` if and only if there exists `a` in `s` such that `f(a) = b`.


theorem DFinsupp.mem_neLocus :
    ∀ {α : Type u_1} {N : α → Type u_2} [inst : DecidableEq α] [inst_1 : (a : α) → DecidableEq (N a)]
      [inst_2 : (a : α) → Zero (N a)] {f g : Π₀ (a : α), N a} {a : α}, a ∈ DFinsupp.neLocus f g ↔ f a ≠ g a :=
  by sorry

The theorem `DFinsupp.mem_neLocus` states that for any types `α` and `N`, where `N` is a type dependent on `α`, and given `f` and `g` as two finitely supported functions mapping from `α` to `N`, along with an element `a` of type `α`, `a` belongs to the set where `f` and `g` differ (i.e., `DFinsupp.neLocus f g`) if and only if `f(a)` is not equal to `g(a)`. This theorem holds under the conditions that equality is decidable for `α` and for every `N a`, and zero is defined for every `N a`.

For functions `f` and `g` mapping from type `α` to type-dependent `N` with decidable equality and defined zero, `a` is in the set of differences if and only if `f(a) ≠ g(a)`.


theorem List.length_split_lt :
    ∀ {α : Type uu} {a b : α} {l l₁ l₂ : List α},
      List.split (a :: b :: l) = (l₁, l₂) →
        List.length l₁ < List.length (a :: b :: l) ∧ List.length l₂ < List.length (a :: b :: l) :=
  by sorry

The theorem `List.length_split_lt` states that for any type `α` and any lists `l`, `l₁`, `l₂`, and elements `a`, `b` of type `α`, if the result of splitting the list `(a :: b :: l)` (which is a list starting with elements `a`, `b`, followed by the elements of `l`) is a pair of lists `(l₁, l₂)`, then the lengths of both `l₁` and `l₂` are strictly less than the length of the original list `(a :: b :: l)`. Essentially, this theorem ensures that the splitting operation does not result in a sublist that is longer than the original list.

If `l = a :: b :: l` and `(l₁, l₂)` is the result of splitting `l`, then `length l₁ < length l` and `length l₂ < length l`.


IsGδ.univ

theorem IsGδ.univ : ∀ {X : Type u_1} [inst : TopologicalSpace X], IsGδ Set.univ := by sorry

This theorem states that for any type `X` equipped with a topology (represented by `TopologicalSpace X`), the set of all elements of `X` (represented by `Set.univ`) is a Gδ set. In mathematical terminology, a Gδ set is a countable intersection of open sets. Therefore, the theorem asserts that the universal set in any topological space is a Gδ set, i.e., it can be represented as a countable intersection of open sets in that topology.

In any topological space, the set of all points is a Gδ set, i.e., it is the countable intersection of open sets.


theorem dist_le_pi_dist :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      (f g : (b : β) → π b) (b : β), dist (f b) (g b) ≤ dist f g :=
  by sorry

This theorem states that for any type `β`, and any type `π` which is a function of `β`, if `β` is a finite type and for all `b` in `β`, `π b` forms a pseudo metric space, then for any two functions `f` and `g` from `β` to `π b`, the distance between `f(b)` and `g(b)` for any `b` in `β` is less than or equal to the distance between the functions `f` and `g` themselves. This is a generalization of the property that the distance between two points is always less than the distance between the paths connecting them.

For any finite type `β` and type `π` being a function of `β`, if for each `b` in `β`, `π b` forms a pseudo metric space, then for all functions `f` and `g` from `β` to `π b`, the pointwise distance between `f(b)` and `g(b)` is less than or equal to the uniform distance between `f` and `g`.


ContinuousOn.norm

theorem ContinuousOn.norm :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] [inst_1 : TopologicalSpace α] {f : α → E} {s : Set α},
      ContinuousOn f s → ContinuousOn (fun x => ‖f x‖) s :=
  by sorry

This theorem states that for any seminormed add group `E` and any topological space `α`, if a function `f` from `α` to `E` is continuous on a set `s` (meaning it's continuous at every point in `s`), then the function that assigns to each `x` in `α` the norm of `f(x)` is also continuous on `s`. In other words, the norm of a continuous function over a set is also continuous over that set.

If `f: α → E` is a continuous function from a topological space `α` to a seminormed add group `E`, then the function `x ∈ α => ‖f x‖: α → ℝ` assigning to each `x` in `α` its norm is also continuous on `α`.


theorem CategoryTheory.ShortComplex.homologyπ_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyπ S₁)
          (CategoryTheory.ShortComplex.homologyMap φ) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap φ)
          (CategoryTheory.ShortComplex.homologyπ S₂) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.homologyπ_naturality` states that for any given category `C` which has zero morphisms, and for any two short complexes `S₁` and `S₂` in `C` with existent homologies, the composition of the homology π-function of `S₁` and the homology map of a morphism `φ` from `S₁` to `S₂` is equal to the composition of the cycles map of `φ` and the homology π-function of `S₂`. In simpler terms, it means that when you map from one short complex to another, applying the homology π-function first, then the homology map, gives you the same result as applying the cycles map first, then the homology π-function. This is a form of naturality condition in the context of category theory.

For any short complexes $S\_1$ and $S\_2$ in a category with zero morphisms and existent homologies, the diagram commutes: $\pi\_{n}(S\_1) \circ \phi = \pi\_{n}(S\_2) \circ \zeta\_\phi$ for all $n$, where $\pi\_{n}$ denotes the $n$th homology $\pi$-function, $\phi$ is a morphism from $S\_1$ to $S\_2$, and $\zeta\_\phi$ is the corresponding homology map.


theorem MeasureTheory.Measure.map_dirac :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
      Measurable f →
        ∀ (a : α), MeasureTheory.Measure.map f (MeasureTheory.Measure.dirac a) = MeasureTheory.Measure.dirac (f a) :=
  by sorry

This theorem, `MeasureTheory.Measure.map_dirac`, states that for two types `α` and `β` each equipped with a measurable space structure, and a function `f` from `α` to `β` which is measurable, the pushforward of the Dirac measure at any point `a` of type `α` under the function `f` is equivalent to the Dirac measure at `f(a)`. In other words, in the context of measure theory, mapping the Dirac measure at a point `a` through a measurable function `f` effectively shifts the "location" of the Dirac measure from `a` to `f(a)`.

For measurable spaces `(α, Σα)` and `(β, Σβ)`, measurable function `f : α → β`, and `a ∈ α`, the pushforward of the Dirac measure at `a` under `f` equals the Dirac measure at `f(a)`.


/-- Given a cone morphism whose object part is an isomorphism, produce an
isomorphism of cones.
 -/
theorem CategoryTheory.Limits.Cones.cone_iso_of_hom_iso :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {K : CategoryTheory.Functor J C}
      {c d : CategoryTheory.Limits.Cone K} (f : c ⟶ d) [i : CategoryTheory.IsIso f.hom], CategoryTheory.IsIso f :=
  by sorry

This theorem states that given a cone morphism, if the object part of this morphism is an isomorphism in a category, then the entire cone morphism is an isomorphism. Specifically, it applies to any category with objects of type `J` and `C`, a functor `K` from `J` to `C`, and two cones `c` and `d` over `K`. The morphism `f` is from `c` to `d`, and if `f.hom` (the object part of the morphism) is an isomorphism, then `f` is also an isomorphism.

If the object part of a cone morphism is an isomorphism in a category, then the entire morphism is an isomorphism.


theorem Nat.div_eq_of_lt_le : ∀ {k n m : ℕ}, k * n ≤ m → m < Nat.succ k * n → m / n = k := by sorry

This theorem states that for any three natural numbers `k`, `n`, and `m`, if `k * n` is less than or equal to `m` and `m` is strictly less than `(k+1) * n`, then the quotient of `m` divided by `n` is `k`. In other words, it provides a condition under which division of two natural numbers yields a specific quotient.

If `k * n <= m` and `m < (k+1) * n`, then `m / n = k` as natural numbers.


theorem Function.Bijective.of_comp_iff' :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Bijective f → ∀ (g : γ → α), Function.Bijective (f ∘ g) ↔ Function.Bijective g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any function `f` from `α` to `β`, if `f` is bijective (both injective and surjective), then for any function `g` from `γ` to `α`, the composition `f ∘ g` is bijective if and only if `g` is bijective. In other words, when `f` is a bijective function, the bijectivity of the composition `f ∘ g` is equivalent to the bijectivity of `g` itself.

If `f: α -> β` is a bijective function and `g: γ -> α` is any function, then `f ∘ g` is bijective if and only if `g` is bijective.


theorem Nat.gcd_dvd : ∀ (m n : ℕ), Nat.gcd m n ∣ m ∧ Nat.gcd m n ∣ n := by sorry

The theorem `Nat.gcd_dvd` states that for all natural numbers `m` and `n`, the greatest common divisor (GCD) of `m` and `n` is a divisor of both `m` and `n`. In other words, the GCD of two numbers divides each of the two numbers. This is a fundamental property of the GCD, typically denoted mathematically as $\text{gcd}(m, n) | m$ and $\text{gcd}(m, n) | n$.

The greatest common divisor of natural numbers m and n (denoted as gcd(m, n)) is a divisor of both m and n. In Lean notation: ∀ (m n : ℕ), gcd m n ∣ m ∧ gcd m n ∣ n.


theorem IsPrimitiveRoot.pow_iff_coprime :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M},
      IsPrimitiveRoot ζ k → 0 < k → ∀ (i : ℕ), IsPrimitiveRoot (ζ ^ i) k ↔ Nat.Coprime i k :=
  by sorry

The theorem `IsPrimitiveRoot.pow_iff_coprime` states that for any type `M` that has a commutative monoid structure, for any natural number `k`, and for any element `ζ` of `M`, if `ζ` is a primitive root of `k` and `k` is positive, then for any natural number `i`, `ζ` raised to the power `i` is a primitive root of `k` if and only if `i` and `k` are coprime, i.e., their greatest common divisor is 1.

For any commutative monoid M, integer k > 0, and primitive root ζ of k in M, i and k are coprime if and only if ζ^i is a primitive root of k.


theorem gcd_mul_lcm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b : α),
      Associated (gcd a b * lcm a b) (a * b) :=
  by sorry

This theorem states that for any type `α` that is a `CancelCommMonoidWithZero` and a `GCDMonoid`, and for any two elements `a` and `b` of type `α`, the Greatest Common Divisor (gcd) of `a` and `b` multiplied by the Least Common Multiple (lcm) of `a` and `b` is associated with the product of `a` and `b`. In other words, there exists a unit `u` such that `(gcd a b * lcm a b) * u = a * b`. Here, `Associated` is defined as a relationship where two elements of the type `α` are associated if one is the product of the other and a unit from the Monoid.

For any `CancelCommMonoidWithZero` and `GCDMonoid` type `α` and elements `a, b ∈ α`, there exists a unit `u` such that `gcd a b * lcm a b * u = a * b`.


ProbabilityTheory.IndepFun.comp

theorem ProbabilityTheory.IndepFun.comp :
    ∀ {Ω : Type u_1} {β : Type u_6} {β' : Type u_7} {γ : Type u_8} {γ' : Type u_9} {mΩ : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} {f : Ω → β} {g : Ω → β'} {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'}
      {_mγ : MeasurableSpace γ} {_mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'},
      ProbabilityTheory.IndepFun f g μ → Measurable φ → Measurable ψ → ProbabilityTheory.IndepFun (φ ∘ f) (ψ ∘ g) μ :=
  by sorry

The theorem `ProbabilityTheory.IndepFun.comp` states that for all spaces `Ω`, `β`, `β'`, `γ`, `γ'` with associated measurable spaces `mΩ`, `_mβ`, `_mβ'`, `_mγ`, `_mγ'`, and a measure `μ` on `Ω`, if we have two functions `f : Ω → β` and `g : Ω → β'` that are independent with respect to measure `μ`, and if we have two measurable functions `φ : β → γ` and `ψ : β' → γ'`, then the compositions `φ ∘ f` and `ψ ∘ g` are also independent with respect to measure μ. In other words, if `f` and `g` are independent, then any measurable functions of `f` and `g` are also independent.

If two measurable functions are independent with respect to a measure, then the compositions of any measurable functions from their respective domains to a common codomain are also independent with respect to that measure.


theorem AddLECancellable.lt_tsub_of_add_lt_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, AddLECancellable c → a + c < b → a < b - c :=
  by sorry

The theorem `AddLECancellable.lt_tsub_of_add_lt_right` states that for any partially ordered commutative semigroup `α` with subtraction that preserves order, and for any elements `a`, `b`, and `c` of `α`, if `c` is left order-reflecting with respect to addition (i.e., `c` is `AddLECancellable`), and if `a + c` is less than `b`, then `a` is less than `b - c`. In other words, if adding `c` to `a` results in a value less than `b`, and if `c` has the property that adding it to any two elements preserves their order, then `a` is less than the difference of `b` and `c`.

If `α` is a commutative semigroup with subtraction preserving order, `c` is `AddLECancellable` in `α`, and `a + c < b`, then `a < b - c`.


/-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`.  -/
theorem Monotone.iterate_le_of_le :
    ∀ {α : Type u_1} [inst : Preorder α] {f g : α → α}, Monotone f → f ≤ g → ∀ (n : ℕ), f^[n] ≤ g^[n] := by sorry

The theorem `Monotone.iterate_le_of_le` states that for any type `α` with a preorder, if we have two functions `f` and `g` from `α` to `α` such that `f` is monotone and `f` is less than or equal to `g`, then for any natural number `n`, the `n`-th iterate of `f` is less than or equal to the `n`-th iterate of `g`. In mathematical notation, if `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]` for all natural numbers `n`.

If `f` is a monotone function less than or equal to `g` between preordered type `α`, then for all natural numbers `n`, `f^(n) ≤ g^(n)`.


theorem AddSalemSpencer.le_addRothNumber :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s t : Finset α},
      AddSalemSpencer ↑s → s ⊆ t → s.card ≤ addRothNumber t :=
  by sorry

The theorem `AddSalemSpencer.le_addRothNumber` states that for any type `α` that has decidable equality and an additive monoid structure, and for any two finite sets `s` and `t` of this type, if `s` is a Salem-Spencer set (meaning that the average of any two distinct elements of `s` is not in `s`) and `s` is a subset of `t`, then the cardinality (or size) of `s` is less than or equal to the additive Roth number of `t`. The additive Roth number of a finite set is the maximum size of a Salem-Spencer subset of that set.

For any type `α` with decidable equality and additive monoid structure, if `s` is a finite Salem-Spencer subset of a larger finite set `t`, then the cardinality of `s` is bounded above by the additive Roth number of `t`.


theorem interior_eq_iff_isOpen : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], interior s = s ↔ IsOpen s := by
  sorry

This theorem, `interior_eq_iff_isOpen`, states that for any type `X` and any set `s` of type `X`, given the context of a topological space, the interior of the set `s` is equal to `s` if and only if `s` is an open set. In other words, in the context of a topological space, a set is open if and only if it is equal to its own interior. This theorem provides a way to check if a set is open by comparing it with its interior.

In a topological space, a set is open if and only if it equals its interior.


theorem Option.ne_none_iff_exists' : ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ ∃ x, o = some x := by sorry

This theorem, `Option.ne_none_iff_exists'`, states that for any type `α` and option `o` of this type, `o` is not `none` if and only if there exists some `x` such that `o` equals `some x`. In other words, an option is not `none` precisely when there exists a value that the option can be.

For any type `α` and option `o` of type `option α`, the option `o` is not `none` if and only if there exists an `x` such that `o = some x`.


theorem Matrix.mulVec_single :
    ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} [inst : Fintype n] [inst_1 : DecidableEq n]
      [inst_2 : NonUnitalNonAssocSemiring R] (M : Matrix m n R) (j : n) (x : R),
      Matrix.mulVec M (Pi.single j x) = fun i => M i j * x :=
  by sorry

The theorem `Matrix.mulVec_single` states that for any types `m`, `n`, and `R`, where `n` is a finite type, `R` is a non-unital non-associative semiring, and there is a decidable equality on `n`, given any matrix `M` with rows indexed by `m`, columns indexed by `n`, and entries from `R`, any element `j` from `n`, and any element `x` from `R`, the result of multiplying the matrix `M` with the vector that has `x` at the `j`-th position and `0` elsewhere (`Pi.single j x`) is a function that, for each `i` in `m`, gives the product of the `i`-th row, `j`-th column element of `M` and `x`. In mathematical terms, this theorem states that for a matrix $M$ and a vector $v$ where only the $j$-th component is non-zero, the multiplication $Mv$ results in a vector where the $i$-th component is the $i$-th row, $j$-th column element of $M$ multiplied by the $j$-th component of $v$.

For any matrix-vector multiplication of a matrix with rows indexed by `m`, columns indexed by a finite type `n`, and entries from a non-unital non-associative semiring `R` with decidable equality, and a vector with only the `j`-th component non-zero, the `i`-th component of the product is the product of the `i`-th row, `j`-th column element of the matrix and the `j`-th component of the vector.


theorem compl_top : ∀ {α : Type u_2} [inst : HeytingAlgebra α], ⊤ᶜ = ⊥ := by sorry

This theorem states that for any type `α` that is a Heyting algebra, the pseudocomplement `⊤ᶜ` of the top element `⊤` is equal to the bottom element `⊥`. In other words, in the context of a Heyting algebra, the "inverse" or "opposite" of the top element is the bottom element.

In a Heyting algebra, the pseudocomplement of the top element is equal to the bottom element.


CategoryTheory.Limits.IsBilimit.total

theorem CategoryTheory.Limits.IsBilimit.total :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type}
      [inst_2 : Fintype J] {f : J → C} {b : CategoryTheory.Limits.Bicone f},
      CategoryTheory.Limits.Bicone.IsBilimit b →
        (Finset.sum Finset.univ fun j => CategoryTheory.CategoryStruct.comp (b.π j) (b.ι j)) =
          CategoryTheory.CategoryStruct.id b.pt :=
  by sorry

This theorem states that for any category `C` that is preadditive, any finite type `J`, any function `f` from `J` to `C`, and any bicone `b` of `f`, if `b` is a bilimit, then the sum of the compositions of `b.π j` and `b.ι j` over all elements `j` in the universal finite set of `J` is equal to the identity morphism on the apex of `b`. In other words, for a given bilimit bicone, the total of all compositions of outgoing and incoming morphisms for all objects is equal to the identity of the apex of the bicone.

For any preadditive category `C`, given a finite type `J`, a function `f : J -> C`, a bicone `b` on `f` that is a bilimit, the sum of the compositions of `b.π j` and `b.ι j` for all `j` in `J` equals the identity morphism on the apex of `b`.


theorem norm_nsmul_le : ∀ {E : Type u_6} [inst : SeminormedAddCommGroup E] (n : ℕ) (a : E), ‖n • a‖ ≤ ↑n * ‖a‖ := by
  sorry

This theorem states that for any seminormed additive commutative group `E` and any natural number `n` and element `a` of `E`, the norm of `n` times `a` (`n` "scaled" by `a`) is less than or equal to `n` times the norm of `a`. In mathematical terms, if `‖x‖` denotes the norm of x, then ‖n•a‖ ≤ n*‖a‖ for every natural number `n` and every `a` in the seminormed additive commutative group `E`.

For any seminormed additive commutative group `E` and natural number `n` and element `a` in `E`, the norm of `n` times `a` is bounded above by `n` times the norm of `a`.


/-- Multiplicativity of a multilinear map along all coordinates at the same time,
writing `f (fun i => c i • m i)` as `(∏ i, c i) • f m`.  -/
theorem MultilinearMap.map_smul_univ :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : CommSemiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : Fintype ι] (c : ι → R) (m : (i : ι) → M₁ i),
      (f fun i => c i • m i) = (Finset.prod Finset.univ fun i => c i) • f m :=
  by sorry

This theorem states that for a multilinear map `f`, the application of `f` to each element `i` in a finite set, where each element is multiplied by a scalar `c i`, is equal to the product of those scalars times the application of `f` to the set. More formally, if `f` is a multilinear map from a space `M₁` to a space `M₂` over a commutative semiring `R`, and if `c` is a function that assigns a scalar from `R` to each index `i` in a finite set `ι`, and `m` is a function that assigns a vector from `M₁` to each index `i` in `ι`, then `f (fun i => c i • m i)` equals `(∏ i, c i) • f m`, where the product is taken over all indices in `ι`. This encapsulates the idea of the distributivity property in the context of multilinear mappings.

For a multilinear map `f` over a commutative semiring `R`, and a finite function `c` mapping indices to scalars in `R`, and a function `m` mapping indices to vectors in the domain of `f`, the product of `c` applied to the indices and `f` applied to the function `x => c x • m x` equals `f` applied to the function `x => c x • m x`.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.25 :
    ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, (a ∈ Set.toFinset s) = (a ∈ s) := by sorry

This theorem states that for any type `α`, any set `s` of elements of type `α` with a `Fintype` instance, and any element `a` of type `α`, the membership of `a` in the finset derived from `s` using the `Set.toFinset` function is equivalent to the membership of `a` in the set `s` itself. This means if `a` is an element of the set `s`, then it will be an element of the finset created from `s`, and vice versa.

For any type `α` with a `Fintype` instance, and any set `s` of type `α` and element `a` of type `α`, `a` belongs to the finset `Set.toFinset s` if and only if it belongs to the set `s` itself.


theorem CategoryTheory.Equivalence.hasInitial_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D],
      (C ≌ D) → (CategoryTheory.Limits.HasInitial C ↔ CategoryTheory.Limits.HasInitial D) :=
  by sorry

This theorem states that for any two categories `C` and `D`, if `C` is equivalent to `D` (denoted as `C ≌ D`), then `C` has an initial object if and only if `D` has an initial object. In the context of category theory, an initial object of a category is one that has a single morphism to any object in the category. The equivalence between two categories is a concept that formalizes the idea of the categories being 'essentially the same' in terms of their categorical structure. So, this theorem is saying that the property of having an initial object is preserved under the equivalence of categories.

If categories `C` and `D` are equivalent, then `C` has an initial object if and only if `D` has an initial object.


Even.map

theorem Even.map :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddZeroClass α] [inst_1 : AddZeroClass β]
      [inst_2 : FunLike F α β] [inst_3 : AddMonoidHomClass F α β] {m : α} (f : F), Even m → Even (f m) :=
  by sorry

The theorem `Even.map` states that for all types `F`, `α`, and `β`, where `α` and `β` are types with addition and zero (`AddZeroClass`), `F` is a type that can be injectively coerced into a function from `α` to `β` (`FunLike F α β`), and `F` is an additive monoid homomorphism from `α` to `β` (`AddMonoidHomClass F α β`), if a value `m` of type `α` is even (i.e., it can be expressed as `r + r` for some `r`), then the result of applying a function `f` of type `F` to `m` is also even. In other words, the image under an additive monoid homomorphism of an even element from an additive monoid is also even.

If `F` is an additive monoid homomorphism from an additive monoid `α` to an additive monoid `β`, then for all even `m` in `α`, `F(m)` is even in `β`.


/-- The equivalence closure of an equivalence relation r is r.  -/
theorem Setoid.eqvGen_of_setoid : ∀ {α : Type u_1} (r : Setoid α), EqvGen.Setoid Setoid.r = r := by sorry

This theorem states that for any equivalence relation `r` on a type `α`, the equivalence closure (obtained by applying `EqvGen.Setoid` to `Setoid.r`) of `r` is `r` itself. In other words, if `r` is an equivalence relation, the process of repeatedly applying equivalence relations to extend `r` (which is what `EqvGen.Setoid` does, effectively taking the "closure" of `r`) doesn't change `r`. Thus, `r` is already fully "closed" under the equivalence generation process.

For any equivalence relation `r` on type `α`, the equivalence closure obtained by applying `EqvGen.Setoid` to `r` equals `r`.


theorem Finset.offDiag_card :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), (Finset.offDiag s).card = s.card * s.card - s.card := by
  sorry

The theorem `Finset.offDiag_card` states that for any finite set `s` of a type `α` with decidable equality, the cardinality of the off-diagonal of `s` (denoted as `Finset.offDiag s`), which is the set of all distinct pairs `(a, b)` where `a` and `b` are elements of `s`, is equal to the square of the cardinality of `s` minus the cardinality of `s` itself. In mathematical notation, for a finite set $S$, the size of the off-diagonal set of $S$ is given by $|S|^2 - |S|$.

The cardinality of the set of distinct pairs of elements in a finite set is equal to the square of its cardinality minus the cardinality of the set itself.


theorem CategoryTheory.IsVanKampenColimit.of_iso :
    ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} {c c' : CategoryTheory.Limits.Cocone F},
      CategoryTheory.IsVanKampenColimit c → (c ≅ c') → CategoryTheory.IsVanKampenColimit c' :=
  by sorry

This theorem states that for any type `J` with a given category structure, and any type `C` also with a category structure, given a functor `F` from `J` to `C` and two cocones `c` and `c'` over `F`, if `c` is a Van Kampen colimit then so is `c'`, provided that `c` is isomorphic to `c'`. In simpler terms, the Van Kampen property is preserved under isomorphism between cocones in a category.

If two isomorphic cocones over a functor between two category structures represent Van Kampen colimits, then each is a Van Kampen colimit.


/-- Banach fixed-point theorem for maps contracting on a complete subset.  -/
theorem ContractingWith.exists_fixedPoint' :
    ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α} {s : Set α},
      IsComplete s →
        ∀ (hsf : Set.MapsTo f s s),
          ContractingWith K (Set.MapsTo.restrict f s s hsf) →
            ∀ {x : α},
              x ∈ s →
                edist x (f x) ≠ ⊤ →
                  ∃ y ∈ s,
                    Function.IsFixedPt f y ∧
                      Filter.Tendsto (fun n => f^[n] x) Filter.atTop (nhds y) ∧
                        ∀ (n : ℕ), edist (f^[n] x) y ≤ edist x (f x) * ↑K ^ n / (1 - ↑K) :=
  by sorry

The Banach fixed-point theorem for maps contracting on a complete subset states that, for a given type `α` with an extended metric space structure, a non-negative real number `K`, a function `f` from `α` to `α`, and a set `s` of `α`, if `s` is complete and the function `f` maps `s` into itself and is contracting on `s`, then for any `x` in `s` where the extended distance between `x` and `f(x)` is not infinite, there exists a `y` in `s` which serves as a fixed point of the function `f`. Furthermore, as `n` goes to infinity, the `n`-th iterate of `f` applied to `x` approaches `y` and the extended distance between the `n`-th iterate of `f` applied to `x` and `y` is less than or equal to the extended distance between `x` and `f(x)` times `K` to the power `n` divided by `1` minus `K`.

Given a complete metric space `(α, d)`, a contracting map `f : α → α` on a complete subset `s ⊆ α`, and any `x ∈ s` with finite distance to `f(x)`, there exists a unique fixed point `y ∈ s` such that the distance between `x` and `y` is less than or equal to the distance between `x` and `f(x)` multiplied by `K^n / (1 - K)`, where `K` is the Lipschitz constant of `f` on `s`.


theorem Module.isTorsionBySet_iff_torsionBySet_eq_top :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (s : Set R), Module.IsTorsionBySet R M s ↔ Submodule.torsionBySet R M s = ⊤ :=
  by sorry

This theorem states that for any set `s` of scalars from a commutative semiring `R` and any module `M` over `R`, the module `M` is `a`-torsion for all `a` in `s` if and only if the submodule containing all elements `x` of `M` such that `a • x = 0` for all `a` in `s` is the entire module `M`. In other words, all elements of the module are annihilated by some scalar in the set `s`.

A module over a commutative semiring is torsion with respect to a set of scalars if and only if the submodule of elements annihilated by all scalars in the set is equal to the entire module.


/-- If `A` is essentially in the image of a reflective functor `i`, then `η_A` is an isomorphism.
This gives that the "witness" for `A` being in the essential image can instead be given as the
reflection of `A`, with the isomorphism as `η_A`.

(For any `B` in the reflective subcategory, we automatically have that `ε_B` is an iso.)
 -/
theorem CategoryTheory.Functor.essImage.unit_isIso :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C}
      [inst_2 : CategoryTheory.Reflective i] {A : C},
      A ∈ CategoryTheory.Functor.essImage i →
        CategoryTheory.IsIso ((CategoryTheory.Adjunction.ofRightAdjoint i).unit.app A) :=
  by sorry

This theorem states that if a category 'A' is essentially in the image of a reflective functor 'i', then the unit of the adjunction associated to the right adjoint of 'i' evaluated at 'A' is an isomorphism. In other words, if 'A' belongs to the essential image of functor 'i', then `η_A` is an isomorphism. This theorem implies that the "witness" for 'A' being in the essential image can be given as the reflection of 'A', with the isomorphism as `η_A`. Note that for any 'B' in the reflective subcategory, we automatically have that `ε_B` is an isomorphism.

If a category 'A' is in the essential image of a reflective functor 'i', then the unit of the adjunction between 'i' and its right adjoint is an isomorphism (i.e., `η_A` is an isomorphism).


DifferentiableOn.comp

theorem DifferentiableOn.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {s : Set E} {g : F → G}
      {t : Set F}, DifferentiableOn 𝕜 g t → DifferentiableOn 𝕜 f s → Set.MapsTo f s t → DifferentiableOn 𝕜 (g ∘ f) s :=
  by sorry

This theorem, `DifferentiableOn.comp`, states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, and `G`, and normed vector spaces over `𝕜` of `E`, `F`, and `G`, if a function `g` from `F` to `G` is differentiable on a set `t`, a function `f` from `E` to `F` is differentiable on a set `s`, and the image of `s` under `f` is contained in `t`, then the composite function `g ∘ f` is differentiable on the set `s`. In other words, the composition of two differentiable functions is differentiable provided the image of the first function is contained in the domain of the second function.

If `f: E → F` is differentiable on `s ⊆ E`, `g: F → G` is differentiable on `t ⊆ F`, and `s ⊆ f⁻¹(t)`, then `g ∘ f` is differentiable on `s`.


theorem IntermediateField.adjoin_simple_eq_bot_iff :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E},
      F⟮α⟯ = ⊥ ↔ α ∈ ⊥ :=
  by sorry

This theorem states that for any two fields `F` and `E`, where `E` is an algebra over `F`, and a given element `α` of `E`, the intermediate field generated by `F` and `α` is the bottom field if and only if `α` is an element of the bottom field. In other words, adding `α` to field `F` creates the smallest possible field (the bottom field) if and only if `α` itself is from the smallest possible field.

The intermediate field generated by a field `F` and an element `α` in a field extension `E` is the constant field `F` if and only if `α` is already in `F`.


theorem Polynomial.support_C_mul_X_pow' :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (c : R), Polynomial.support (Polynomial.C c * Polynomial.X ^ n) ⊆ {n} :=
  by sorry

The theorem `Polynomial.support_C_mul_X_pow'` states that for any semiring `R`, any natural number `n`, and any element `c` of `R`, the support of the polynomial, which is the product of the constant polynomial `c` and `X` raised to the power `n`, is a subset of the singleton set that contains only `n`. In practical terms, this means that the only exponent of `X` that can have a non-zero coefficient in the polynomial `c * X^n` is `n` itself.

The theorem asserts that the support of the polynomial `c * X^n` in a semiring consists only of the exponent `n` for any natural number `n` and element `c` in the semiring.


theorem RatFunc.num_algebraMap :
    ∀ {K : Type u} [inst : Field K] (p : Polynomial K), RatFunc.num ((algebraMap (Polynomial K) (RatFunc K)) p) = p :=
  by sorry

The theorem `RatFunc.num_algebraMap` states that for any field `K` and any polynomial `p` over `K`, the numerator of the rational function obtained by embedding the polynomial `p` into the field `K` of rational functions using the algebraic structure's map, is `p` itself. In other words, this theorem states that under this particular mapping, the polynomial `p` maps to a rational function whose numerator is `p` and the denominator is implicitly 1.

The theorem asserts that under the algebraic structure map, a polynomial over a field maps to a rational function with that polynomial as its numerator.


theorem even_two : ∀ {α : Type u_2} [inst : Semiring α], Even 2 := by sorry

The theorem `even_two` states that for all types `α` equipped with a semiring structure, the number 2 is even. In the context of the defined property `Even`, this means that there exists a number `r` in `α` such that `2 = r + r`.

In any semiring, 2 is equal to the sum of two identical elements.


theorem Fin.val_last : ∀ (n : ℕ), ↑(Fin.last n) = n := by sorry

This theorem, `Fin.val_last`, states that for every natural number `n`, the numerical value (obtained by using the coercion function `↑`) of the greatest value of `Fin (n+1)`, as defined by `Fin.last n`, is equal to `n` itself. In other words, when we consider the "last" element in the finite set of size `n+1`, its value is `n`. This is in line with the convention of starting indexing from 0 in Lean 4.

For every natural number `n`, the greatest element in the finite set `Fin (n+1)` has value `n`.


theorem Module.Finite_of_isLocalization :
    ∀ (R : Type u_1) (S : Type u_2) (Rₚ : Type u_3) (Sₚ : Type u_4) [inst : CommSemiring R] [inst_1 : CommRing S]
      [inst_2 : CommRing Rₚ] [inst_3 : CommRing Sₚ] [inst_4 : Algebra R S] [inst_5 : Algebra R Rₚ]
      [inst_6 : Algebra R Sₚ] [inst_7 : Algebra S Sₚ] [inst_8 : Algebra Rₚ Sₚ] [inst_9 : IsScalarTower R S Sₚ]
      [inst_10 : IsScalarTower R Rₚ Sₚ] (M : Submonoid R) [inst_11 : IsLocalization M Rₚ]
      [inst_12 : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₚ] [hRS : Module.Finite R S], Module.Finite Rₚ Sₚ :=
  by sorry

The theorem `Module.Finite_of_isLocalization` states that, given commutative semirings `R` and `S`, commutative rings `Rₚ` and `Sₚ`, and algebras of `R` over `S`, `Rₚ`, `Sₚ`, combined with the scalar towers `R` over `S` over `Sₚ` and `R` over `Rₚ` over `Sₚ`, and given a submonoid `M` of `R`, if `Rₚ` is a localization of `R` at `M`, and `Sₚ` is a localization of `S` at the image of `M` under the algebra map from `R` to `S`, and if `S` is a finite module over `R`, then `Sₚ` is also a finite module over `Rₚ`. This theorem is essentially a statement about the preservation of "finiteness" property under the localization process in the context of rings and modules.

Given commutative rings R and S, semirings Rₚ and Sₚ, algebras Rₚ over S, Sₚ over Rₚ, and scalar towers R over S and R over Rₚ over S, if Rₚ is a localization of R at a submonoid M and Sₚ is a localization of S at M's image under the algebra map, and S is finite over R, then Sₚ is finite over Rₚ.


theorem List.pairwise_iff_forall_sublist :
    ∀ {α : Type u_1} {l : List α} {R : α → α → Prop}, List.Pairwise R l ↔ ∀ {a b : α}, List.Sublist [a, b] l → R a b :=
  by sorry

This theorem states that for any type `α`, any list `l` of `α`, and any binary relationship `R` on `α`, the list `l` has the property `Pairwise R` (meaning that for every pair of elements in the list, `R` holds) if and only if for any elements `a` and `b` of type `α`, if the list `[a, b]` is a sublist of `l`, then `R a b` holds. In other words, the list `l` satisfies the pairwise property with respect to `R` precisely when `R` holds for any pair of elements that appear consecutively in `l`.

For any type `α`, list `l` of `α`, and binary relation `R` on `α`, `l` has property `Pairwise R` if and only if for all `a` and `b` in `α`, if `[a, b]` is a sublist of `l`, then `R a b`.


theorem TensorProduct.smul_tmul' :
    ∀ {R : Type u_1} [inst : CommSemiring R] {R' : Type u_2} [inst_1 : Monoid R'] {M : Type u_4} {N : Type u_5}
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : DistribMulAction R' M] [inst_7 : SMulCommClass R R' M] (r : R') (m : M) (n : N),
      r • m ⊗ₜ[R] n = (r • m) ⊗ₜ[R] n :=
  by sorry

This theorem states that for any commutative semiring `R`, monoid `R'`, and modules `M` and `N` over `R`, if `M` also has a distributive multiplication action by `R'` and `R'` and `R` commute under scalar multiplication on `M`, then for any elements `r` in `R'`, `m` in `M`, and `n` in `N`, the scalar multiplication of `r` and tensor product of `m` and `n` is equal to the tensor product of the scalar multiplication of `r` and `m` and `n`. In mathematical notation, this can be expressed as $r \cdot (m \otimes n) = (r \cdot m) \otimes n$.

For any commutative semiring `R`, monoid `R'`, and modules `M` and `N` over `R` with distributive `R'`-actions on `M`, if `R'` and `R` commute under scalar multiplication on `M`, then for all `r` in `R'`, `m` in `M`, and `n` in `N`, $r \cdot (m \otimes n) = (r \cdot m) \otimes n$.


theorem Polynomial.degree_lt_iff_coeff_zero :
    ∀ {R : Type u} [inst : Semiring R] (f : Polynomial R) (n : ℕ),
      Polynomial.degree f < ↑n ↔ ∀ (m : ℕ), n ≤ m → Polynomial.coeff f m = 0 :=
  by sorry

This theorem states that for any semiring `R` and any polynomial `f` over `R`, the degree of `f` is less than a given natural number `n` if and only if all the coefficients of `f` for powers of `X` greater than or equal to `n` are zero. In other words, the highest power of `X` that has a non-zero coefficient in `f` is less than `n`.

For any semiring `R` and polynomial `f` over `R` in the indeterminate `X`, the degree of `f` is less than `n` if and only if all coefficients of `X^i` with `i ≥ n` in `f` are zero.


theorem Ordinal.IsNormal.cof_eq :
    ∀ {f : Ordinal.{u_2} → Ordinal.{u_2}},
      Ordinal.IsNormal f → ∀ {a : Ordinal.{u_2}}, Ordinal.IsLimit a → Ordinal.cof (f a) = Ordinal.cof a :=
  by sorry

This theorem states that for any normal ordinal function `f` and any limit ordinal `a`, the cofinality of `f(a)` is equal to the cofinality of `a`. Here, a normal ordinal function is a strictly increasing function that is order-continuous (the image of a limit ordinal is the supremum of the function values for lesser ordinals), a limit ordinal is an ordinal that is neither zero nor a successor, and the cofinality of an ordinal is the smallest cardinality of a subset of the ordinal which is unbounded.

For any normal ordinal function and any limit ordinal, the cofinality of the function value at that limit ordinal equals the cofinality of the limit ordinal itself.


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

The theorem `CategoryTheory.Limits.kernelSubobject_arrow_comp` states that, for any category `C` with zero morphisms, and for any morphisms `f` from object `X` to object `Y` in `C` which possess a kernel, the composition of the arrow of the kernel subobject of `f` and `f` itself equals to the zero morphism. In mathematical terms, if `f : X ⟶ Y` and `g` is the arrow of the kernel subobject of `f`, then `g ≫ f = 0` in the category `C`.

Given a category with zero morphisms `C`, if `f : X ⟶ Y` in `C` has a kernel and `g` is its arrow, then `g ∘ f = 0`.


theorem Nat.div_eq_of_eq_mul_right : ∀ {n m k : ℕ}, 0 < n → m = n * k → m / n = k := by sorry

This theorem is stating that for any three natural numbers `n`, `m`, and `k`, with `n` being greater than zero, if `m` is equal to the product of `n` and `k`, then the result of dividing `m` by `n` will be `k`. In mathematical terms, this theorem is stating that if $0 < n$ and $m = n \times k$, then $\frac{m}{n} = k$. This theorem essentially formalizes the fundamental property of division that if a number `m` is the product of `n` and `k`, dividing `m` by `n` will yield `k`.

If $0 < n$ and $m = n \times k$, then $\frac{m}{n} = k$.


theorem ge_trans : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, a ≥ b → b ≥ c → a ≥ c := by sorry

This theorem, `ge_trans`, states a fundamental property of preordered types in mathematics: the transitivity of the 'greater than or equal to' relation. Specifically, for any preordered type `α` and any three elements `a`, `b`, and `c` of this type, if `a` is greater than or equal to `b` and `b` is greater than or equal to `c`, then it follows that `a` is greater than or equal to `c`. This is an example of the transitive property in action, which is often used in mathematical reasoning and proofs.

If `a >= b` and `b >= c` in a preordered type `α`, then `a >= c`.


theorem HahnSeries.embDomain_coeff :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] {Γ' : Type u_3} [inst_2 : PartialOrder Γ']
      {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {a : Γ}, (HahnSeries.embDomain f x).coeff (f a) = x.coeff a :=
  by sorry

The theorem `HahnSeries.embDomain_coeff` states that for every ordered types `Γ` and `Γ'`, every type `R` equipped with an zero element, every order embedding `f` from `Γ` to `Γ'`, every Hahn series `x` over `Γ` and `R`, and every element `a` of `Γ`, the coefficient of the image of `a` under `f` in the Hahn series obtained by extending the domain of `x` by `f` is the same as the coefficient of `a` in `x`. This property maintains the coefficients of elements from the original domain in the new, extended domain.

For every Hahn series $x$ over ordered types $\Gamma$ and a ring $R$, and an order embedding $f$ from $\Gamma$ to $\Gamma'$, the coefficient of $f(a)$ in the extended Hahn series is equal to the coefficient of $a$ in $x$, for all $a\in \Gamma$.


/-- If a preconnected set contains endpoints of an interval, then it includes the whole interval.  -/
theorem IsPreconnected.Icc_subset :
    ∀ {α : Type v} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderClosedTopology α] {s : Set α},
      IsPreconnected s → ∀ {a b : α}, a ∈ s → b ∈ s → Set.Icc a b ⊆ s :=
  by sorry

The theorem `IsPreconnected.Icc_subset` states that, for any preconnected set `s` in a linearly ordered topological space with an order-closed topology, if `s` contains the endpoints `a` and `b` of a closed interval (i.e., `a` and `b` both belong to `s`), then `s` also contains the entire closed interval from `a` to `b`. In other words, all values `x` for which `a ≤ x ≤ b` also belong to `s`. This means that preconnected sets in such a space have the property that whenever they contain the endpoints of a closed interval, they also contain all points in between those endpoints.

In a linearly ordered topological space with order-closed topology, if a preconnected set contains the endpoints of a closed interval, then it contains the entire closed interval.


theorem Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.15 :
    ∀ {x : ENNReal} {y : ℝ}, (x ^ y = ⊤) = (x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y) := by sorry

This theorem states that for any extended nonnegative real number "x" and any real number "y", the condition of "x" raised to the power "y" being equal to positive infinity is equivalent to either of the two following scenarios: (1) "x" is zero and "y" is negative, or (2) "x" is positive infinity and "y" is positive. Here, the extended nonnegative real numbers are denoted by `[0, ∞]` and they represent the codomain of a measure.

For any extended nonnegative real number x and real number y, x^y = +∞ if and only if (x = 0 and y < 0) or (x = +∞ and y > 0).


theorem Set.Nontrivial.einfsep_ne_top :
    ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {s : Set α}, Set.Nontrivial s → Set.einfsep s ≠ ⊤ := by sorry

The theorem `Set.Nontrivial.einfsep_ne_top` states that for any nontrivial set `s` in a pseudo metric space `α`, the extended infimum separation of the set `s` is not equal to the positive infinity. Here, a set is said to be nontrivial if it contains at least two distinct elements and the extended infimum separation of a set `s` is defined as the greatest lower bound of the extended distances between distinct pairs of elements in `s`.

In a pseudo metric space, the extended infimum separation of a nontrivial set is strictly less than positive infinity.


theorem IsMaxFilter.comp_tendsto :
    ∀ {α : Type u} {β : Type v} {δ : Type x} [inst : Preorder β] {f : α → β} {l : Filter α} {g : δ → α} {l' : Filter δ}
      {b : δ}, IsMaxFilter f l (g b) → Filter.Tendsto g l' l → IsMaxFilter (f ∘ g) l' b :=
  by sorry

The theorem `IsMaxFilter.comp_tendsto` states that for any types `α`, `β`, and `δ` with a preorder relation on `β`, given a function `f : α → β`, a filter `l` on `α`, another function `g : δ → α`, another filter `l'` on `δ`, and a point `b : δ`, if `f` attains its maximum at `g(b)` for all elements in the `l`-neighborhood of `g(b)` (i.e., `IsMaxFilter f l (g b)` holds), and `g` is such that for every `l`-neighborhood `a`, the `g`-preimage of `a` is an `l'`-neighborhood (i.e., `Filter.Tendsto g l' l` holds), then `(f ∘ g)` also attains its maximum at `b` for all elements in the `l'`-neighborhood of `b` (i.e., `IsMaxFilter (f ∘ g) l' b` holds). In simpler words, this theorem ensures that the property of attaining maximum value is preserved under the composition of functions when dealing with filters.

If a function `f : α → β` attains its maximum at `g(b)` in the `l`-neighborhood of `g(b)` for some filter `l` on `α`, and `g : δ → α` maps `l'`-neighborhoods to `l`-neighborhoods, then `(f ∘ g)` attains its maximum at `b` in the `l'`-neighborhood of `b`.


theorem CategoryTheory.Biprod.inl_ofComponents :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ Y₁ Y₂ : C} (f₁₁ : X₁ ⟶ Y₁) (f₁₂ : X₁ ⟶ Y₂)
      (f₂₁ : X₂ ⟶ Y₁) (f₂₂ : X₂ ⟶ Y₂),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl
          (CategoryTheory.Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂) =
        CategoryTheory.CategoryStruct.comp f₁₁ CategoryTheory.Limits.biprod.inl +
          CategoryTheory.CategoryStruct.comp f₁₂ CategoryTheory.Limits.biprod.inr :=
  by sorry

This theorem in category theory states that for any category `C` that is 'preadditive' (i.e., its morphisms have an additive structure) and has binary biproducts (a kind of limit), for any four objects `X₁, X₂, Y₁, Y₂` in `C` and morphisms `f₁₁ : X₁ ⟶ Y₁`, `f₁₂ : X₁ ⟶ Y₂`, `f₂₁ : X₂ ⟶ Y₁`, `f₂₂ : X₂ ⟶ Y₂` in this category, the composition of the morphism for the inclusion into the first part of a binary biproduct ('inl') with the morphism `f₁₁` plus the composition of `f₁₂` with the morphism for the inclusion into the second part of a binary biproduct ('inr') is equal to the composition of 'inl' with a binary biproduct of the four morphisms. That is, morphisms in a preadditive category with binary biproducts distribute over the biproduct in a specific way.

In a preadditive category with binary biproducts, the diagram commutes, where the inclusion morphisms into the first and second parts of a binary biproduct, and the given morphisms compose with these inclusions, is equal to the binary biproduct of the given morphisms.


theorem Finset.inter_singleton_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → s ∩ {a} = {a} := by sorry

This theorem states that for every type `α` with decidable equality, every element `a` of type `α`, and every finset `s` of type `α`, if `a` is an element of `s`, then the intersection of `s` and the singleton set containing only `a` is equal to the singleton set containing `a`. In simpler terms, if `a` is in `s`, then the only element in both `s` and `{a}` is `a` itself.

For every type `α` with decidable equality, if `a` is an element of finite set `s` of type `α`, then `s ∩ {a} = {a}`.


/-- `Fintype.prod_bijective` is a variant of `Finset.prod_bij` that accepts `Function.Bijective`.

See `Function.Bijective.prod_comp` for a version without `h`.  -/
theorem Fintype.prod_bijective :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid α]
      (e : ι → κ),
      Function.Bijective e →
        ∀ (f : ι → α) (g : κ → α),
          (∀ (x : ι), f x = g (e x)) → (Finset.prod Finset.univ fun x => f x) = Finset.prod Finset.univ fun x => g x :=
  by sorry

The theorem `Fintype.prod_bijective` states that for any two types `ι` and `κ` and a type `α` that forms a commutative monoid, if there exists a bijective function `e` from `ι` to `κ`, then for any two functions `f: ι → α` and `g: κ → α` such that `f x = g (e x)` for all `x` in `ι`, the product of `f x` across all elements `x` in `ι` is equal to the product of `g x` across all elements `x` in `κ`. In other words, it says that the product over a finite set remains the same under a bijective map.

For any commutative monoid type `α`, bijective function `e: ι -> κ`, and functions `f: ι -> α` and `g: κ -> α` such that `f x = g (e x)` for all `x` in `ι`, the product of `f` over `ι` equals the product of `g` over `κ`.


ModelWithCorners.leftInverse

theorem ModelWithCorners.leftInverse :
    ∀ {𝕜 : 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),
      Function.LeftInverse ↑(ModelWithCorners.symm I) ↑I :=
  by sorry

The theorem `ModelWithCorners.leftInverse` states that for any model with corners `I` of types `𝕜` (a non-trivially normed field), `E` (a normed add commutative group with a normed space over `𝕜`), and `H` (a topological space), the inverse of `I` is a left inverse function to `I`. In other words, when you apply `I` and then apply the inverse of `I`, you will end up with the original input, for all inputs. This is written mathematically as `g ∘ f = id`, where `f` represents the function `I` and `g` represents the inverse of `I`.

The map `I` and its inverse commute with each other, i.e., `I ∘ I^−1 = I^−1 ∘ I = id`.


theorem Complex.continuous_sin : Continuous Complex.sin := by sorry

This theorem states that the complex sine function is continuous. In other words, for any point in the complex plane, the sine function varies smoothly without any jumps, breaks, or holes around that point. In mathematical terms, the complex sine function, defined as `sin(z) = (e^(-zi) - e^(zi)) * i / 2`, has the property of continuity.

The complex sine function, defined as `sin(z) := (e^(-zi) - e^(zi)) * I / 2`, is a continuous function on the complex plane.


theorem pow_eq_zero_iff :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [inst_1 : NoZeroDivisors M₀],
      n ≠ 0 → (a ^ n = 0 ↔ a = 0) :=
  by sorry

This theorem, `pow_eq_zero_iff`, states that for any non-zero natural number `n` and any element `a` from a monoid with zero and no zero divisors (a mathematical structure like integers, real numbers, etc.), `a` raised to the power `n` is zero if and only if `a` itself is zero. In other words, in such a structure, a non-zero power of a value can only be zero if the value itself is zero.

For any non-zero natural number `n` and any element `a` in a monoid with zero and no zero divisors, `a^n = 0` if and only if `a = 0`.


theorem mem_nhdsWithin_iff_exists_mem_nhds_inter :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {t : Set α} {a : α} {s : Set α},
      t ∈ nhdsWithin a s ↔ ∃ u ∈ nhds a, u ∩ s ⊆ t :=
  by sorry

This theorem states that for any topological space `α`, given a set `s` in `α` and an element `a` in `α`, a set `t` is in the filter of neighborhoods within `s` of `a` (i.e., `t` is a neighborhood of `a` within `s`) if and only if there exists a set `u` which is a neighborhood of `a` (i.e., `u` is in the filter of all neighborhoods of `a`) such that the intersection of `u` and `s` is contained within `t`. In other words, `t` is a "local" neighborhood of `a` within `s` precisely when `t` contains the intersection of `s` and some "global" neighborhood of `a`.

For any topological space `α`, a set `t` is a neighborhood of `a` in `s` (i.e., in the filter of neighborhoods of `a` within `s`) if and only if there exists a neighborhood `u` of `a` such that `u ∩ s` is contained in `t`.


theorem CliffordAlgebra.map_id :
    ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
      (Q₁ : QuadraticForm R M₁),
      CliffordAlgebra.map (QuadraticForm.Isometry.id Q₁) = AlgHom.id R (CliffordAlgebra Q₁) :=
  by sorry

The theorem `CliffordAlgebra.map_id` states that for any commutative ring `R`, an additive commutative group `M₁`, and a module `M₁` over `R`, and given a quadratic form `Q₁` on `M₁`, the mapping of the identity isometry from the quadratic form `Q₁` to itself (via the `CliffordAlgebra.map` function) is identical to the identity map on the Clifford algebra of `Q₁` as an algebra homomorphism (represented by `AlgHom.id R (CliffordAlgebra Q₁)`). In other words, the identity isometry on a quadratic form is equivalent to the identity algebra homomorphism on the corresponding Clifford algebra.

The identity isometry of a quadratic form over a commutative ring is equivalent to the identity algebra homomorphism on its corresponding Clifford algebra.


theorem MeasureTheory.VectorMeasure.AbsolutelyContinuous.mk :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_4} {N : Type u_5} [inst : AddCommMonoid M]
      [inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid N] [inst_3 : TopologicalSpace N]
      {v : MeasureTheory.VectorMeasure α M} {w : MeasureTheory.VectorMeasure α N},
      (∀ ⦃s : Set α⦄, MeasurableSet s → ↑w s = 0 → ↑v s = 0) → MeasureTheory.VectorMeasure.AbsolutelyContinuous v w :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.AbsolutelyContinuous.mk` states that for any measurable space `α`, given vector measures `v` and `w` whose values lie in topological add-commutative monoids `M` and `N` respectively, if for every measurable set `s`, the measure of `s` under `w` being zero implies the measure of `s` under `v` is also zero, then the vector measure `v` is absolutely continuous with respect to the vector measure `w`. In terms of measure theory, this means that `v` disregards sets that `w` considers negligible.

If for every measurable set in a measurable space, the measure of the set under `w` being zero implies the measure of the set under `v` is also zero, then `v` is absolutely continuous with respect to `w`.


theorem BoxIntegral.Prepartition.iUnion_top :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι}, BoxIntegral.Prepartition.iUnion ⊤ = ↑I := by sorry

This theorem states that for any type `ι` and any given box `I` of type `BoxIntegral.Box ι`, the union of all the boxes in the prepartition `⊤` (the top element in the prepartition) is equivalent to the set represented by the box `I` itself. In other words, if you consider the prepartition that includes every possible box, the union of these boxes covers exactly the same space as the original box `I`.

For any type `ι` and `BoxIntegral.Box ι` `I`, the union of all boxes in the prepartition with top element `⊤` is equal to `I`.


AntitoneOn.dual

/-- **Alias** of the reverse direction of `antitoneOn_dual_iff`. -/
theorem AntitoneOn.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      AntitoneOn f s → AntitoneOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s :=
  by sorry

This theorem, which is an alias of the reverse direction of `antitoneOn_dual_iff`, states that for any two types `α` and `β` with preorders, a function `f` from `α` to `β`, and a set `s` of type `α`, if `f` is antitone (i.e., it is a decreasing function) on `s`, then the composition of `OrderDual.toDual`, `f`, and `OrderDual.ofDual` (in that order) is also antitone on `s`. In other words, if `f` reverses the order of elements in `s`, then the same property holds even if we consider the dual order on the domain and range of `f`. Here, `OrderDual.toDual` and `OrderDual.ofDual` are identity functions that convert a type to its dual order and back, respectively.

If `f` is an antitone function from preordered set `α` to preordered set `β` and `s` is a subset of `α`, then the composition of `OrderDual.toDual`, `f`, and `OrderDual.ofDual` is antitone on `s`.


theorem ENNReal.mul_right_mono : ∀ {a : ENNReal}, Monotone fun x => x * a := by sorry

The theorem `ENNReal.mul_right_mono` states that for every extended nonnegative real number `a`, the multiplication function `fun x => x * a` is monotone. In other words, if we have two extended nonnegative real numbers where the first is less than or equal to the second, then the result of multiplying the first number by `a` will be less than or equal to the result of multiplying the second number by `a`. This is the property of right multiplication being monotone in the extended nonnegative real numbers.

For all extended nonnegative real numbers `a` and `x` with `x_1 ≤ x_2`, we have `x_1 * a ≤ x_2 * a`.


theorem Mathlib.MeasureTheory.Measure.MeasureSpace._auxLemma.10 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem states that for any type `α`, any sort `ι`, any element `x` of type `α`, and any function `s` from `ι` to a set of `α`, `x` is in the union over `ι` of the sets `s i` if and only if there exists an `i` in `ι` such that `x` is in `s i`.

In other words, an element belongs to the union of a collection of sets if and only if it belongs to at least one of the sets in that collection. This theorem is a fundamental principle of set theory, encapsulated within the context of measure theory in Lean.

For any type `α`, sort `ι`, element `x` of type `α`, and function `s` from `ι` to sets of `α`, `x` is in the set `⋃ i, s i` if and only if there exists an `i` in `ι` such that `x` is in `s i`.


theorem Nat.clog_of_right_le_one : ∀ {n : ℕ}, n ≤ 1 → ∀ (b : ℕ), Nat.clog b n = 0 := by sorry

The theorem `Nat.clog_of_right_le_one` states that for any natural number `n` and `b`, if `n` is less than or equal to 1, then the ceiling logarithm of `n` in base `b` is equal to 0. This is consistent with the definition of the ceiling logarithm, as any number raised to the power of 0 is 1, and if `n` is less or equal to 1, the smallest power of `b` that is greater than or equal to `n` is indeed zero.

For all natural numbers `n` and base `b`, if `n` is less than or equal to 1, then the ceiling logarithm of `n` in base `b` equals 0.


theorem MeasureTheory.Measure.MutuallySingular.add_left_iff :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ ν : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular (μ₁ + μ₂) ν ↔
        MeasureTheory.Measure.MutuallySingular μ₁ ν ∧ MeasureTheory.Measure.MutuallySingular μ₂ ν :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.add_left_iff` states that for any type `α`, any measurable space `m0` of type `α`, and any three measures `μ₁`, `μ₂`, `ν` of type `α`, the measure `μ₁ + μ₂` is mutually singular with the measure `ν` if and only if both `μ₁` and `μ₂` are mutually singular with `ν`. In mathematical terms, two measures are said to be mutually singular if there exists a measurable set such that one measure assigns it a measure of zero and the other measure assigns its complement a measure of zero.

For any measurable spaces `(α, m0)` and measures `μ₁, μ₂, ν` on `α`, `μ₁ + μ₂` is mutually singular with `ν` if and only if both `μ₁` and `μ₂` are mutually singular with `ν`.


theorem Associates.eq_of_prod_eq_prod :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [inst_2 : Nontrivial α]
      {a b : Associates.FactorSet α}, Associates.FactorSet.prod a = Associates.FactorSet.prod b → a = b :=
  by sorry

This theorem, `Associates.eq_of_prod_eq_prod`, states that for any type `α` that has the structure of a `CancelCommMonoidWithZero` (a commutative monoid with a zero element which also has the cancellation property), a `UniqueFactorizationMonoid` (a monoid that has unique factorization into irreducible elements), and is `Nontrivial` (it has at least two distinct elements), if we have two `FactorSet` objects `a` and `b` from `Associates` of `α`, and the product of the factors of `a` is equal to the product of factors of `b` (computed using the `Associates.FactorSet.prod` function), then `a` and `b` must be equal. In other words, two factor sets are equal if and only if their product of factors are equal under the given algebraic structures.

For any commutative monoid with a zero element, unique factorization, and at least two distinct elements `α` with associated factor sets `a` and `b` satisfying `Associates.prod a = Associates.prod b`, we have `a = b`.


theorem lowerSemicontinuousWithinAt_ciSup :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {ι : Sort u_3} {δ' : Type u_5}
      [inst_1 : ConditionallyCompleteLinearOrder δ'] {f : ι → α → δ'},
      (∀ᶠ (y : α) in nhdsWithin x s, BddAbove (Set.range fun i => f i y)) →
        (∀ (i : ι), LowerSemicontinuousWithinAt (f i) s x) → LowerSemicontinuousWithinAt (fun x' => ⨆ i, f i x') s x :=
  by sorry

This theorem, `lowerSemicontinuousWithinAt_ciSup`, states that in a given topological space with a conditionally complete linear order, for a set `s` of type `α` and an element `x` of the same type, if for each element `y` in a neighborhood within `s` of `x`, the range of the function `f i y` is bounded above, and for each index `i`, the function `f i` is lower semicontinuous at `x` within `s`, then the function defined by taking the supremum over `i` of `f i x'` for all `x'` is also lower semicontinuous at `x` within `s`. In other words, the lower semicontinuity is preserved under taking the supremum of a family of functions if each function in that family is lower semicontinuous and the set of values of these functions is bounded above in the neighborhood of the point of interest within the set.

If each function in a family of lower semicontinuous functions with bounded above ranges is applied to elements in a neighborhood of a point in a conditional complete linear order, then the supremum of these functions is also lower semicontinuous at that point.


theorem Submonoid.LocalizationMap.lift_of_comp :
    ∀ {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) (j : N →* P),
      Submonoid.LocalizationMap.lift f ⋯ = j :=
  by sorry

This theorem states that for any commutative monoids `M`, `N`, and `P`, a given submonoid `S` of `M`, and a localization map `f` from `S` to `N`, there is a homomorphism `j` from `N` to `P` such that the lift of the localization map `f` equals `j`. Essentially, this theorem is about lifting operations in the context of localization of commutative monoids.

Given a commutative monoid homomorphism `f` from a submonoid `S` of `M` to `N`, there exists a homomorphism `j` from `N` to `P` such that `f` is the restriction of `j` to `S`.


/-- A ring isomorphism preserves multiplication.  -/
theorem RingEquiv.map_mul :
    ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S)
      (x y : R), e (x * y) = e x * e y :=
  by sorry

This theorem states that a ring isomorphism preserves multiplication. In other words, if you have a ring isomorphism `e` between two rings `R` and `S`, and two elements `x` and `y` from the ring `R`, then the image of the product `x * y` under the isomorphism `e` is the same as the product of the images `e x` and `e y`. This is a fundamental property of ring isomorphisms.

If `e` is a ring isomorphism between rings `R` and `S`, then for all `x, y ∈ R`, `e(x * y) = e(x) * e(y)`.


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

This theorem states that for any type `α` equipped with a partial order, an additive commutative semigroup structure, a subtraction operation, an ordered subtraction structure, and satisfying both a contravariant and a covariant condition related to addition and order, for any elements `a`, `b`, and `c` of this type `α`, the sum of `a` and `c` subtracted by the sum of `b` and `c` is equal to `a` subtracted by `b`. This is essentially an abstract algebraic formulation of the common arithmetic property that "addition of the same number to both the minuend and subtrahend does not affect the difference".

For any type `α` with a partial order, additive commutative semigroup structure, subtraction operation, and ordered subtraction structure, the law of tricommutativity holds: `(a + c) - (b + c) = a - b` for all `a`, `b`, `c` in `α`.


theorem Asymptotics.isBigO_zero :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] (g : α → F)
      (l : Filter α), (fun _x => 0) =O[l] g :=
  by sorry

This theorem, `Asymptotics.isBigO_zero`, states that for any types `α`, `F`, and `E'`, if a function `g : α → F` is considered, and `l` is a filter on `α`, then the zero function (i.e., a function that returns zero for all inputs) is "Big O" of `g` at `l`. In Big O notation, this is expressed as `0 =O[l] g`. This implies that the zero function grows no faster than `g` in the limit as we approach the points specified by the filter `l`. The types `F` and `E'` are required to have a norm and a seminormed add commutative group structure, respectively, to ensure that the concept of "Big O" is well-defined.

For any type `α`, filter `l` on `α`, and functions `g : α → F` where `F` has a norm and `E'` has a seminormed add commutative group structure, the zero function is Big O of `g` at `l`, i.e., `0 =O[l] g`.


theorem Mathlib.Algebra.Group.Basic._auxLemma.1 :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsLeftCancelMul G] (a : G) {b c : G}, (a * b = a * c) = (b = c) := by
  sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.1`, states that for any type `G` that has a multiplication operation (`Mul G`) and where multiplication is left-cancellable (`IsLeftCancelMul G`), given any element `a` of type `G` and any two elements `b` and `c` of type `G`, the equality `a * b = a * c` implies `b = c`. In other words, if multiplying `a` by `b` results in the same product as multiplying `a` by `c`, then `b` must be equal to `c`. This is a property of left-cancellation in multiplication.

If `G` is a type with left-cancellable multiplication, then `a * b = a * c` implies `b = c` for all `a, b, c` in `G`.


Polynomial.hasDerivAt

/-- The derivative (in the analysis sense) of a polynomial `p` is given by `p.derivative`.  -/
theorem Polynomial.hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
      HasDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x :=
  by sorry

This theorem states that for every non-trivially normed field `𝕜` and a polynomial `p` defined over `𝕜`, and for every element `x` of `𝕜`, the derivative of the polynomial `p` at the point `x` (in the sense of analysis) is given by the evaluation of the derivative of `p` at `x`. In mathematical terms, if we denote the polynomial evaluation function at `x` as `(fun x => Polynomial.eval x p)`, then its derivative at any point `x` is `(Polynomial.eval x (Polynomial.derivative p))`, where `Polynomial.derivative p` represents the formal derivative of the polynomial `p`.

For any non-trivially normed field `𝕜` and polynomial `p` over `𝕜`, the derivative of `p` at an element `x` in `𝕜` is equal to the evaluation of the derivative of `p` at `x`.


theorem MeasureTheory.FiniteMeasure.testAgainstNN_coe_eq :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] {μ : MeasureTheory.FiniteMeasure Ω}
      {f : BoundedContinuousFunction Ω NNReal},
      ↑(MeasureTheory.FiniteMeasure.testAgainstNN μ f) = ∫⁻ (ω : Ω), ↑(f ω) ∂↑μ :=
  by sorry

The theorem `MeasureTheory.FiniteMeasure.testAgainstNN_coe_eq` states that for any given finite measure space 'Ω', any finite measure 'μ' on that space, and any bounded continuous function 'f' from 'Ω' to the nonnegative real numbers, the pairing of the finite measure 'μ' with the function 'f' (obtained by integrating the function against the measure) is equal to the Lebesgue integral of the function 'f' against the measure 'μ'. In simpler terms, the measure-theoretic integration of the function with respect to the finite measure is accurately represented by the `testAgainstNN` function.

For any finite measure space 'Ω', finite measure 'μ' on 'Ω', and bounded continuous function 'f' from 'Ω' to the nonnegative real numbers, the integral of 'f' with respect to 'μ' (as a measure-theoretic integral) equals the Lebesgue integral of 'f' against 'μ'.


theorem Nat.mul_div_cancel_left' : ∀ {a b : ℕ}, a ∣ b → a * (b / a) = b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` divides `b`, then `a` multiplied by the result of `b` divided by `a` equals `b`. In mathematical terms, if `a` is a divisor of `b`, then `a*(b/a) = b`. This reflects the property of division and multiplication being inverse operations under certain conditions in the set of natural numbers.

If `a` divides `b` in the natural numbers, then `a * (b / a) = b`.


theorem MeasureTheory.IsStoppingTime.measurableSpace_le :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {ι : Type u_4} [inst : SemilatticeSup ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} [inst_1 : Filter.IsCountablyGenerated Filter.atTop] (hτ : MeasureTheory.IsStoppingTime f τ),
      MeasureTheory.IsStoppingTime.measurableSpace hτ ≤ m :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSpace_le` states that for any type `Ω` with a measurable space structure `m`, any type `ι` with a semilattice sup structure, any filtration `f` of `m` indexed by `ι`, and any function `τ` from `Ω` to `ι`, if `τ` is a stopping time with respect to `f` and the filter `atTop` is countably generated, then the measurable space associated with the stopping time `τ` is a sub-measurable space of `m`. In other words, every set that is measurable in the σ-algebra associated with the stopping time `τ` is also measurable in the original measurable space `m`.

For any measurable space `(Ω, m)`, semilattice `ι` with sup structure, filtration `f: ι -> Set Ω.Measurable` indexed by `ι`, and stopping time `τ: Ω -> ι` with respect to `f` on a countably generated filter `atTop`, the associated measurable space of `τ` is a sub-measurable space of `m`. That is, every set measurable in `τ`'s σ-algebra is measurable in `m`.


theorem nhds_translation_add_neg :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G] (x : G),
      Filter.comap (fun x_1 => x_1 + -x) (nhds 0) = nhds x :=
  by sorry

This theorem, `nhds_translation_add_neg`, states that for any type `G` which is a topological space, an additive group, and a topological additive group (these are structures where the group operation is continuous), the filter obtained by taking the preimage under the function `x_1 => x_1 + -x` of the neighborhood filter at `0` is equal to the neighborhood filter at `x`. In other words, if you shift the points of the space by `-x` and look at the neighborhoods around `0`, it's the same as looking at the neighborhoods around `x` in the original space. This theorem demonstrates a sort of "translational symmetry" in topological additive groups.

For any topological additive group G, the preimage under x => x + (-x) of the neighborhood filter at 0 is equal to the neighborhood filter at x.


theorem inf_add_sup :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α), a ⊓ b + a ⊔ b = a + b :=
  by sorry

This theorem, `inf_add_sup`, states that for any type `α` that is a lattice and an additive commutative group, where the addition operation is covariant, the sum of the infimum (greatest lower bound) and supremum (least upper bound) of any two elements `a` and `b` of type `α` is equal to the sum of `a` and `b`. Essentially, it says that in such a structured type, adding the lowest and highest possible bounds of two elements gives you the same result as simply adding the two elements together.

For any lattice and additive commutative group type `α` with covariant addition, the infimum and supremum of `a` and `b` in `α` satisfy `inf a b + sup a b = a + b`.


theorem Mathlib.Topology.Inseparable._auxLemma.10 :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y = (x ⤳ y ∧ y ⤳ x) := by sorry

This theorem states that for any topological space `X` and any two points `x` and `y` in this space, `x` and `y` are inseparable (i.e., they share the same neighborhood structure) if and only if `x` converges to `y` and `y` converges to `x`. Here, `x ⤳ y` denotes the convergence of `x` to `y`, meaning every neighborhood of `y` contains `x` after a certain point in a sequence or function, and similarly for `y ⤳ x`.

For any topological space X and points x, y in X, x and y are inseparable if and only if they converge to each other, i.e., x ⤳ y and y ⤳ x.


theorem Real.arcsin_lt_pi_div_two : ∀ {x : ℝ}, Real.arcsin x < Real.pi / 2 ↔ x < 1 := by sorry

This theorem states that for any real number `x`, the arcsine of `x` is less than half of pi if and only if `x` is less than 1. In mathematical terms, it's saying that for all `x` in the set of real numbers ℝ, `arcsin(x) < π/2` is equivalent to `x < 1`.

The theorem asserts that for all real numbers `x`, `arcsin(x) < π/2` if and only if `x < 1`.


theorem BilinForm.coe_smul :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {α : Type u_8} [inst_3 : Monoid α] [inst_4 : DistribMulAction α R] [inst_5 : SMulCommClass α R R] (a : α)
      (B : BilinForm R M), (a • B).bilin = a • B.bilin :=
  by sorry

This theorem states that for any commutative semiring `R`, any additive commutative monoid `M`, and any module structure on `M` with coefficients in `R`, given any monoid `α` with a distributive multiplication action on `R` and a scalar multiplication commutation relationship between `α` and `R`, then for any element `a` of `α` and any bilinear form `B` on `R` and `M`, the bilinear form obtained by scaling `B` by `a` is such that its associated bilinear map is the result of scaling the bilinear map associated to `B` by `a`. In other words, scaling a bilinear form by a scalar multiplies its associated bilinear map by the same scalar.

For any commutative semiring `R`, additive commutative monoid `M` with an `R`-module structure, monoid `α` with distributive multiplication action on `R` and scalar multiplication commuting with `R`, and bilinear form `B` on `R` and `M`, the scalar multiplication of `B` by an element `a` in `α` results in a bilinear form whose associated bilinear map is the product of the associated bilinear map of `B` and the scalar multiplication of `a` on `R`.


theorem IsClosed.lowerSemicontinuous_indicator :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {s : Set α} {y : β}
      [inst_2 : Zero β], IsClosed s → y ≤ 0 → LowerSemicontinuous (Set.indicator s fun _x => y) :=
  by sorry

This theorem states that for any type `α` which has a topology, type `β` that is equipped with a preorder and a zero element, a set `s` of type `α`, and a value `y` of type `β`, if the set `s` is closed in the topological space `α`, and `y` is less than or equal to zero, then the indicator function `Set.indicator s (fun _x => y)`, which is defined to be `y` if an element is in the set `s` and zero otherwise, is lower semicontinuous. In the context of analysis, this means that for all `x` in `α`, for any value `z` less than the function's value at `x`, there exists a neighborhood of `x` such that the function's value at any point in this neighborhood is not less than `z`.

For any topological space `α` with type `α` having a topology, any preordered type `β` with a zero element, any closed set `s` in `α`, and any `y` in `β` less than or equal to zero, the indicator function `Set.indicator s (fun _x => y)` is lower semicontinuous.


Function.Antiperiodic.neg

theorem Function.Antiperiodic.neg :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddGroup α] [inst_1 : InvolutiveNeg β],
      Function.Antiperiodic f c → Function.Antiperiodic f (-c) :=
  by sorry

This theorem states that if a function `f` is antiperiodic with antiperiod `c`, then it is also antiperiodic with antiperiod `-c`. Specifically, for any types `α` and `β`, if `f` is a function from `α` to `β`, `c` is an element of `α`, `α` is an additive group and `β` has an operation of negation that is involutive (meaning that negating twice gives the original value), then if `f` satisfies the property that for every `x` in `α`, `f(x + c) = -f(x)`, it also satisfies the property that for every `x` in `α`, `f(x - c) = -f(x)`.

If a function `f` from an additive group `α` to a negation-commutative type `β` is antiperiodic with antiperiod `c`, then it is also antiperiodic with antiperiod `-c` (i.e., for all `x` in `α`, `f(x + c) = -f(x)` implies `f(x - c) = -f(x)`).


theorem IntermediateField.le_iff_le :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
      (H : Subgroup (E ≃ₐ[F] E)) (K : IntermediateField F E),
      K ≤ IntermediateField.fixedField H ↔ H ≤ IntermediateField.fixingSubgroup K :=
  by sorry

The theorem `IntermediateField.le_iff_le` states that for any field `F`, a field `E` which is an algebra over `F`, a subgroup `H` of the algebraic field automorphisms of `E` over `F`, and an intermediate field `K` of `E` over `F`, the intermediate field `K` is a subset of the field fixed by the subgroup `H` if and only if the subgroup `H` is a subset of the subgroup that fixes the intermediate field `K`.

For any field extension E/F, subgroup H of its algebraic automorphisms, and intermediate field K between F and E, K is fixed by H if and only if H is contained in the subgroup fixing K.


theorem Monotone.image_upperBounds_subset_upperBounds_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {s : Set α}, f '' upperBounds s ⊆ upperBounds (f '' s) :=
  by sorry

This theorem states that for any types `α` and `β` equipped with a preorder (a relation that is reflexive and transitive), and any function `f` from `α` to `β`, if `f` is monotone (i.e., preserves the order: `a ≤ b` implies `f a ≤ f b`), then for any set `s` of type `α`, the image under `f` of the upper bounds of `s` is a subset of the upper bounds of the image of `s` under `f`. In other words, if `f` preserves order and `x` is an upper bound of `s`, then `f(x)` is an upper bound of `f(s)`.

For any function `f` that preserves the order between elements of types `α` and `β`, where `α` and `β` are equipped with a preorder, and for any set `s` of type `α` and any upper bound `x` of `s`, the image `f(x)` is an upper bound of `f(s)`.


theorem iSup_range' :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : SupSet α] (g : β → α) (f : ι → β),
      ⨆ b, g ↑b = ⨆ i, g (f i) :=
  by sorry

This theorem states that, for all types `α`, `β`, and `ι`, given a `SupSet` instance for `α`, and two functions `g` mapping from `β` to `α`, and `f` mapping from `ι` to `β`, the supremum of `g` applied to the elements of `β` is equal to the supremum of `g` applied to the results of applying `f` to the elements of `ι`. In other words, it doesn't matter whether we first apply `f` to `ι` and then `g` to the result, or if we directly apply `g` to `β`; the supremum remains the same.

For all types `α`, `β`, and `ι`, given a `SupSet` instance for `α`, the supremum of `g ∘ f` over `ι` equals the supremum of `g` over `β`.


theorem CauSeq.const_lt :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {x y : α}, CauSeq.const abs x < CauSeq.const abs y ↔ x < y := by
  sorry

The theorem `CauSeq.const_lt` states that for any type `α`, which forms a linearly ordered field, and for any two elements `x` and `y` of type `α`, the constant Cauchy sequence constructed from the absolute value of `x` is less than the constant Cauchy sequence constructed from the absolute value of `y` if and only if `x` is less than `y`. Essentially, this theorem is about the order preservation of constant Cauchy sequences with respect to the underlying field elements they are constructed from.

For any linearly ordered field type `α`, the constant Cauchy sequence constructed from the absolute value of `x` is less element-wise than the constant Cauchy sequence constructed from the absolute value of `y` if and only if `x` is less than `y`.


theorem Set.prod_nonempty_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Set.Nonempty (s ×ˢ t) ↔ Set.Nonempty s ∧ Set.Nonempty t :=
  by sorry

This theorem, `Set.prod_nonempty_iff`, states that for any two types `α` and `β`, and any two sets `s` of type `α` and `t` of type `β`, the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is nonempty if and only if both `s` and `t` are nonempty. In other words, there exists an element in the Cartesian product of the two sets exactly when there exist elements in both of the original sets.

For any types `α` and `β` and sets `s : α` and `t : β`, `s ×ˢ t` is nonempty if and only if `s` and `t` are nonempty.


theorem Stream'.WSeq.exists_get?_of_mem :
    ∀ {α : Type u} {s : Stream'.WSeq α} {a : α}, a ∈ s → ∃ n, some a ∈ Stream'.WSeq.get? s n := by sorry

This theorem states that for any type `α`, any infinite sequence `s` of type `α`, and any element `a` of type `α`, if `a` is an element of `s`, then there exists a natural number `n` such that `a` is the `n`th element of `s`. In other words, if an element is in an infinite sequence, you can find its position in the sequence.

For any type `α`, any infinite sequence `s` of type `α`, and any element `a` of type `α` in `s`, there exists a natural number `n` such that `a = s!(n)`, where `s!` denotes the `n`-th element of `s`.


theorem Nat.coprime_zero_right : ∀ (n : ℕ), Nat.Coprime n 0 ↔ n = 1 := by sorry

The theorem `Nat.coprime_zero_right` states that for any natural number `n`, `n` is coprime with zero if and only if `n` equals to one. In mathematical terms, this is saying that the greatest common divisor (gcd) of `n` and `0` is `1` if and only if `n` is `1`.

The natural number `n` is coprime to zero if and only if `n` equals one. (equivalently, gcd(n, 0) = 1 if and only if n = 1)


theorem List.sublistForall₂_iff :
    ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
      List.SublistForall₂ R l₁ l₂ ↔ ∃ l, List.Forall₂ R l₁ l ∧ List.Sublist l l₂ :=
  by sorry

This theorem states that for any two given types `α` and `β`, a relation `R` between `α` and `β`, and two lists `l₁` of type `α` and `l₂` of type `β`, `l₁` is a sublist of `l₂` with all pairs of elements satisfying the relation `R` if and only if there exists a list `l` such that `l₁` and `l` satisfy the relation `R` for all pairs of their elements and `l` is a sublist of `l₂`.

For types `α` and `β`, relation `R` between them, and lists `l₁` of type `α` and `l₂` of type `β`, `l₁` is a sublist of `l₂` preserving `R` if and only if there exists a sublist `l` of `l₂` such that `l₁` and `l` have `R`-related elements.


theorem CategoryTheory.zigzag_isPreconnected :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J],
      (∀ (j₁ j₂ : J), CategoryTheory.Zigzag j₁ j₂) → CategoryTheory.IsPreconnected J :=
  by sorry

This theorem states that for any type `J` that forms a category, if for every pair of objects `j₁` and `j₂` in `J`, there exists a zigzag chain of morphisms connecting `j₁` and `j₂` (that is, a sequence of morphisms where backward morphisms are allowed), then `J` is preconnected. In the context of category theory, a category is said to be preconnected if any two objects in the category can be connected by a sequence of morphisms.

A type `J` forming a category is preconnected if for every pair of objects `j₁` and `j₂` in `J`, there exists a zigzag sequence of morphisms from `j₁` to `j₂`.


/-- If `p` and `q` are irreducible, then `p ∣ q` implies `q ∣ p`.  -/
theorem Irreducible.dvd_symm :
    ∀ {α : Type u_1} [inst : Monoid α] {p q : α}, Irreducible p → Irreducible q → p ∣ q → q ∣ p := by sorry

This theorem states that for any type `α` that is a monoid, if `p` and `q` are elements of `α` that are irreducible, then if `p` divides `q`, it must also be the case that `q` divides `p`. Here, "divides" means that there is some element in the monoid such that multiplying that element by `p` gives `q`, and similarly for `q` divides `p`. An irreducible element is one that cannot be expressed as the product of two non-unit elements.

In a monoid, if two irreducible elements `p` and `q` satisfy `p` divides `q`, then `q` also divides `p`.


theorem eq_div_of_mul_eq : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, c ≠ 0 → a * c = b → a = b / c := by
  sorry

This theorem states that for any type `G₀` that has a 'Group with Zero' structure (a multiplication operation that is associative, commutative and has an identity, namely zero), and for any three elements `a`, `b`, and `c` from this type where `c` is not zero, if the multiplication of `a` and `c` equals `b`, then `a` equals `b` divided by `c`. In other words, the theorem is saying that if `a * c = b`, then `a` is equal to `b / c`, provided `c` is not zero.

Given a group with zero `G₀` and `a`, `b`, `c` in `G₀` with `c ≠ 0`, if `a * c = b`, then `a = b / c`.


theorem zpow_bit1_neg_iff : ∀ {α : Type u_1} [inst : LinearOrderedField α] {a : α} {n : ℤ}, a ^ bit1 n < 0 ↔ a < 0 := by
  sorry

The theorem `zpow_bit1_neg_iff` states that for any linear ordered field `α` and elements `a` in `α` and integer `n`, `a` raised to the power `bit1 n` (where `bit1 n` is defined as `2n + 1`) is less than zero if and only if `a` is less than zero. Thus, this theorem gives a condition for a number raised to an odd power to be negative in a linear ordered field.

For any linear ordered field `α` and element `a` in `α` and integer `n`, `a^(2n+1) < 0` if and only if `a < 0`.


Sigma.forall

theorem Sigma.forall :
    ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
      (∀ (x : (a : α) × β a), p x) ↔ ∀ (a : α) (b : β a), p { fst := a, snd := b } :=
  by sorry

This theorem, `Sigma.forall`, defines an equivalence in predicate logic over dependent pair types in Lean 4. More specifically, for any type `α`, a type dependency `β : α → Type`, and a predicate `p` applicable to such dependent pairs, it asserts that the predicate holding for all elements of the dependent pair type is equivalent to the predicate holding for all possible first-and-second-element combinations. In other words, it's saying that if you can affirm a property for every individual element in a type-dependent pair, then you can affirm it for the whole pair and vice versa.

For any type `α`, dependent type `β : α → Type`, and predicate `p` on dependent pairs `(a, b) : α × β a`, `Sigma.forall` asserts that `∀ (a : α), p a b ↔ ∀ (x, y : α × β), p x y`.


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

The theorem `Set.image_preimage_inter` states that for any function `f` mapping elements of type `α` to type `β`, and for any sets `s` of type `α` and `t` of type `β`, the image under `f` of the intersection of the preimage of `t` under `f` and `s` is equal to the intersection of `t` and the image under `f` of `s`. In terms of set theory, this means that applying a function to the intersection of the preimage of a set and another set results in the same set if we first take the intersection of the original set and the image of the second set.

 For any function `f` from type `α` to type `β` and sets `s ⊆ α` and `t ⊆ β`, `f''(s ∩ f⁁¹(t)) = s ∩ f''(s)`.

Here, `f''` represents the image of a set under `f`, and `f⁁¹` represents the preimage of a set under `f`.


IsMaxFilter.neg

theorem IsMaxFilter.neg :
    ∀ {α : Type u} {β : Type v} [inst : OrderedAddCommGroup β] {f : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMinFilter (fun x => -f x) l a :=
  by sorry

The theorem `IsMaxFilter.neg` states that for any type `α`, any ordered additive commutative group `β`, any function `f` from `α` to `β`, any filter `l` on `α`, and any element `a` of `α`, if `f` attains its maximum value at `a` within some neighborhood defined by the filter `l` (in other words, if `f x ≤ f a` for all `x` in the `l`-neighborhood of `a`), then the function `-f` (which negates the output of `f`) attains its minimum value at the same point `a` within the same neighborhood (that is, `(-f) a ≤ (-f) x` for all `x` in the `l`-neighborhood of `a`). This means that the negation of a function that has a maximum at a certain point will have a minimum at that same point.

If a function f from a type α to an ordered additive commutative group β attains a maximum at a point a within a filter l on α, then the negation of f attains a minimum at a.


theorem Algebra.adjoin_image :
    ∀ (R : Type uR) {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (s : Set A),
      Algebra.adjoin R (⇑f '' s) = Subalgebra.map f (Algebra.adjoin R s) :=
  by sorry

The theorem `Algebra.adjoin_image` states that for any commutative semiring `R`, semirings `A` and `B`, and an algebra homomorphism `f` from `A` to `B`, if we have a set `s` of elements in `A`, then the subalgebra generated by the image of `s` under the homomorphism `f` (i.e., `Algebra.adjoin R (⇑f '' s)`) is equal to the subalgebra obtained by mapping the subalgebra generated by `s` (i.e., `Algebra.adjoin R s`) under the homomorphism `f` (i.e., `Subalgebra.map f (Algebra.adjoin R s)`). This theorem captures the idea that the process of adjoining elements to an algebra and then mapping to another algebra can be interchanged with the process of first mapping the elements to the other algebra, and then adjoining there.

For any commutative semirings R, semirings A and B, and algebra homomorphism f from A to B, the subalgebras generated by the image of a set s under f and the set s itself, both in A and then mapped to B, are equal.


theorem Array.foldlM_eq_foldlM_data :
    ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β)
      (arr : Array α), Array.foldlM f init arr 0 = List.foldlM f init arr.data :=
  by sorry

This theorem, `Array.foldlM_eq_foldlM_data`, establishes the equivalence between the `foldlM` operation on an array and the `foldlM` operation on the list that represents the data of the array. More specifically, for any monad `m`, types `β` and `α`, a function `f` of type `β → α → m β`, an initial value `init` of type `β`, and an array `arr` of type `Array α`, applying `foldlM` with function `f` and initial value `init` to `arr` from the 0th index is equal to applying `foldlM` with the same function and initial value to the data of `arr` treated as a list. This implies that the fold with side effects (`foldlM`) over an array and over its corresponding list, starting from the first element, produce the same result.

For any monad `m`, types `β` and `α`, function `f` of type `β → α → m β`, initial value `init` of type `β`, and array `arr` of type `Array α`, `foldlM f init arr` is equal to `foldlM f init (list.toList arr)`.


theorem Finset.map_injective : ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β), Function.Injective (Finset.map f) := by
  sorry

The theorem `Finset.map_injective` states that for all types `α` and `β`, if we have an embedding function `f` from `α` to `β`, then the operation of mapping a finset from `α` to `β` using this function is injective. In other words, if two finsets from `α` are mapped to the same finset in `β` using the function `f`, then these two finsets must have been the same to begin with. This theorem ensures that no information is lost when we map finsets from one type to another using an embedding function.

If `f : α → β` is an embedding and `s1, s2 : Finset α`, then `Finset.map f s1 = Finset.map f s2` implies `s1 = s2`.


theorem Mathlib.Order.LocallyFinite._auxLemma.7 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, (x ∈ Finset.Iic a) = (x ≤ a) :=
  by sorry

This theorem states that for any type `α` equipped with a preorder and a locally finite order at the bottom, and for any elements `a` and `x` of `α`, the element `x` is in the finite set `Finset.Iic a` (the set of elements less than or equal to `a`) if and only if `x` is less than or equal to `a`. This essentially characterizes the set `Finset.Iic a` in terms of the order relation.

For any type `α` with a preorder and locally finite order at the bottom, `x ≤ a` if and only if `x ∈ Finset.Iic a`.


theorem segment_eq_image_lineMap :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] (x y : E),
      segment 𝕜 x y = ⇑(AffineMap.lineMap x y) '' Set.Icc 0 1 :=
  by sorry

This theorem states that for any ordered ring `𝕜` and any additive commutative group `E` that is also a `𝕜`-module, and for any two elements `x` and `y` in `E`, the segment between `x` and `y` in `E` is equivalent to the image under the affine map `lineMap` from 0 to 1 (inclusive) in `𝕜`. In simpler terms, all points on the line segment between `x` and `y` can be expressed as affine combinations of `x` and `y` with the coefficients being all real numbers between 0 and 1 inclusive.

For any ordered ring `𝕜` and `𝕜`-module `E` that is an additive commutative group, the segment between any two elements `x` and `y` in `E` is equal to the image of the line map from 0 to 1 under the action of `𝕜` in `E`.


theorem Option.not_isSome_iff_eq_none : ∀ {α : Type u_1} {o : Option α}, ¬Option.isSome o = true ↔ o = none := by sorry

This theorem states that for any type `α` and an instance `o` of `Option α`, the boolean function `Option.isSome o` not being true is logically equivalent to `o` being `none`. In other words, if `o` is not an instance of `some val` (i.e., `Option.isSome o` does not return `true`), then it must be `none`.

For any type `α` and `Option α` value `o`, `Option.isSome o = false` if and only if `o` is `none`.