IntervalIntegrable.trans

theorem IntervalIntegrable.trans :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ} {a b c : ℝ},
      IntervalIntegrable f μ a b → IntervalIntegrable f μ b c → IntervalIntegrable f μ a c :=
  by sorry

The theorem `IntervalIntegrable.trans` states that for any type `E` that forms a normed additive commutative group, any real-valued function `f` on `E`, any measure `μ` on the real numbers, and any real numbers `a`, `b`, and `c`, if `f` is interval integrable with respect to measure `μ` on the unordered intervals `a..b` and `b..c`, then `f` is also interval integrable with respect to measure `μ` on the unordered interval `a..c`. In simpler terms, this is the transitivity property for interval integrability: if `f` is interval integrable over two intervals that share an endpoint, then `f` is interval integrable over the whole interval encompassing both.

If `f` is interval integrable with respect to measure `μ` on the unordered intervals `a..b` and `b..c` of a normed additive commutative group `E`, then `f` is interval integrable with respect to `μ` on the unordered interval `a..c` of `E`.


theorem padicValNat.div_of_dvd :
    ∀ {p a b : ℕ} [hp : Fact (Nat.Prime p)], b ∣ a → padicValNat p (a / b) = padicValNat p a - padicValNat p b := by
  sorry

The theorem `padicValNat.div_of_dvd` states that for any natural numbers `p`, `a`, and `b`, where `p` is a prime number (`Nat.Prime p`), if `b` divides `a` (expressed as `b ∣ a`), then the p-adic valuation of the quotient of `a` divided by `b` (`a / b`) is equal to the difference between the p-adic valuation of `a` and the p-adic valuation of `b`. In mathematical terms, this can be represented as $\nu_p(a/b) = \nu_p(a) - \nu_p(b)$, where $\nu_p(n)$ represents the p-adic valuation of a number `n`.

For a prime number `p`, if `b` divides `a`, then the p-adic valuation of their quotient `a / b` equals the difference between the p-adic valuations of `a` and `b`: $\nu_p(a/b) = \nu_p(a) - \nu_p(b)$.


theorem IsometryEquiv.dist_eq :
    ∀ {α : Type u_2} {β : Type u_3} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x y : α),
      dist (h x) (h y) = dist x y :=
  by sorry

This is a theorem about isometries in the context of pseudo metric spaces. The theorem states that for any two types `α` and `β`, both equipped with a pseudo metric space structure, if there is an isometric equivalence `h` from `α` to `β`, then for any two elements `x` and `y` of `α`, the distance between the images of `x` and `y` under `h` in `β`, is the same as the distance between `x` and `y` in `α`. In other words, an isometry preserves distances between points.

Given isometric equivalences between pseudo metric spaces `α` and `β`, the distance between images of any two points `x` and `y` in `α` equals the distance between these points in `β`.


theorem DFinsupp.add_apply :
    ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → AddZeroClass (β i)] (g₁ g₂ : Π₀ (i : ι), β i) (i : ι),
      (g₁ + g₂) i = g₁ i + g₂ i :=
  by sorry

This theorem states that for any type `ι`, a type function `β` from `ι` to another type, and an instance of `AddZeroClass` for `β i` (for any `i` of type `ι`), if `g₁` and `g₂` are two functions from `ι` to `β i` (but with possibly zero values omitted, as indicated by `Π₀`), then applying the addition operation to `g₁` and `g₂` and then applying the result to some `i` gives the same result as applying `g₁` and `g₂` individually to `i` and then summing the resulting values. In other words, it's verifying the expected behavior of addition in this particular context: addition of functions is equivalent to the function of sums.

For any type `ι`, function `β : ι →* Type,` and `AddZeroClass` instance for `β i,` if `g₁, g₂ : ι →β i` are functions, then `(∑ i : ι, g₁ i + g₂ i) = (∑ i : ι, g₁ i + β.zero + g₂ i)` where `+` denotes function addition and `+` for types denotes the sum of a list/indexed family of types.


theorem List.map_nil : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, List.map f [] = [] := by sorry

This theorem, `List.map_nil`, states that for any types `α` and `β` and any function `f` mapping from `α` to `β`, the list obtained by mapping `f` over an empty list of type `α` is also an empty list. In other words, given any function, applying this function to each element of an empty list results in another empty list.

For any types `α` and `β` and function `f` from `α` to `β`, the map of the empty list of type `α` using `f` is the empty list of type `β`. Or, more mathematically, `List.map ∅ f = ∅`.


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

This theorem states that for any three integers `a`, `b`, and `c`, if the difference of `a` and `c` is less than `b`, then `a` is less than the sum of `b` and `c`. In other words, for all integers `a`, `b`, `c`, if `a - c < b`, it follows that `a < b + c`. This is a piece of order theory in the domain of integers.

If `a`, `b`, and `c` are integers with `a - c < b`, then `a < b + c`.


/-- Composition by an injective function on the left is itself injective.  -/
theorem Function.Injective.comp_left :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {g : β → γ},
      Function.Injective g → Function.Injective fun x => g ∘ x :=
  by sorry

The theorem `Function.Injective.comp_left` states that if you have a function `g : β → γ` that is injective (meaning for any two elements `x` and `y` in `β`, if `g(x)` is equal to `g(y)`, then `x` must be equal to `y`), then the function that takes another function `x : α → β` and returns the composition of `g` and `x` (denoted as `g ∘ x`) is also injective. In other words, composition by an injective function on the left preserves injectivity.

If `g : β → γ` is an injective function, then the function `g ∘ x` is injective for all functions `x : α → β`.


theorem Complex.conj_eq_iff_im : ∀ {z : ℂ}, (starRingEnd ℂ) z = z ↔ z.im = 0 := by sorry

This theorem states that for any complex number 'z', the conjugate of 'z' is equal to 'z' if and only if the imaginary part of 'z' is zero. In other words, a complex number is equal to its own conjugate only when it is a real number (since real numbers have zero imaginary parts).

A complex number is equal to its conjugate if and only if it is a real number (equivalent to having an imaginary part of 0).


theorem quotientMap_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      QuotientMap f ↔ Function.Surjective f ∧ ∀ (s : Set Y), IsOpen s ↔ IsOpen (f ⁻¹' s) :=
  by sorry

This theorem states that for all topological spaces `X` and `Y` and a function `f` from `X` to `Y`, `f` is a quotient map if and only if `f` is surjective and for every subset `s` of `Y`, `s` is an open set in `Y` if and only if the preimage of `s` under `f` is an open set in `X`. In other words, a function between topological spaces is a quotient map precisely when it is surjective and the preimage of any open set remains an open set.

Here, surjectivity means that for every element in `Y`, there exists an element in `X` such that the function `f` maps this element in `X` to that element in `Y`. A set `s` is said to be open if it is an open set in the given topological space. The preimage of a set under a function is the set of all elements that the function maps to any element of the original set.

A function between topological spaces is a quotient map if and only if it is surjective and preserves open sets.


theorem Nat.add_div : ∀ {a b c : ℕ}, 0 < c → (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 := by
  sorry

This theorem states that for any natural numbers `a`, `b`, and `c`, given that `c` is greater than 0, the result of dividing the sum of `a` and `b` by `c` is equal to the sum of the results of dividing `a` and `b` by `c` individually, plus an additional 1 if `c` is less than or equal to the sum of the remainders of `a` and `b` when divided by `c`, or plus 0 otherwise. In mathematical terms, `(a + b) / c = a / c + b / c + 1` if `c ≤ a mod c + b mod c`, and `(a + b) / c = a / c + b / c` otherwise.

For natural numbers `a`, `b`, and `c` with `c > 0`, `(a + b) / c = a / c + b / c + 1` if `c <= a % c + b % c`, and `(a + b) / c = a / c + b / c` otherwise.


theorem MeasureTheory.stronglyMeasurable_one :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : One β],
      MeasureTheory.StronglyMeasurable 1 :=
  by sorry

The theorem `MeasureTheory.stronglyMeasurable_one` states that for any measurable space `α`, any topological space `β`, and given that `β` has a defined "one" operation, the constant function `1` is `StronglyMeasurable`. Here, `StronglyMeasurable` means that the function can be obtained as the limit of a sequence of simple functions.

For any measurable space `α` and topological space `β` with a defined "one" operation, the constant function `1` from `α` to `β` is StronglyMeasurable.


theorem add_sub_sub_cancel : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b c : G), a + b - (a - c) = b + c := by sorry

This theorem states that for any type `G` which forms an additive commutative group, for any elements `a`, `b`, and `c` of this group, the result of subtracting `(a - c)` from `a + b` is equal to `b + c`. In other words, it expresses a certain symmetry property of addition and subtraction in an additive commutative group. The theorem is universal, meaning it holds for all such groups and all elements of these groups.

For any additive commutative group (G : Type) and elements a, b, c of G, a + b = b + c + (-c).


/-- We now define a long list of structures on `ℕ+` induced by
similar structures on `ℕ`. Most of these behave in a completely
obvious way, but there are a few things to be said about
subtraction, division and powers.
 -/
theorem PNat.coe_inj : ∀ {m n : ℕ+}, ↑m = ↑n ↔ m = n := by sorry

This theorem, `PNat.coe_inj`, states that for any two positive natural numbers `m` and `n`, the coercion of `m` and `n` to natural numbers are equal if and only if `m` and `n` themselves are equal. In other words, the process of converting positive natural numbers to natural numbers (using the coercion function `↑`) preserves their equality.

For all natural numbers `m` and `n`, `↑m = ↑n` if and only if `m = n`.


theorem MvPolynomial.constantCoeff_C :
    ∀ {R : Type u} (σ : Type u_1) [inst : CommSemiring R] (r : R), MvPolynomial.constantCoeff (MvPolynomial.C r) = r :=
  by sorry

The theorem `MvPolynomial.constantCoeff_C` states that for any type `R` with a commutative semiring structure and any type `σ`, and for any element `r` of type `R`, the constant coefficient of the constant polynomial with value `r` is `r` itself. In other words, when we create a constant polynomial with some value `r`, the constant term of that polynomial is precisely `r`. This holds in any commutative semiring.

For any commutative semiring (R, +, \*), and any element r in R, the constant polynomial over R with constant term r equals r itself.


theorem Nat.pos_of_mem_properDivisors : ∀ {n m : ℕ}, m ∈ Nat.properDivisors n → 0 < m := by sorry

The theorem `Nat.pos_of_mem_properDivisors` states that for all natural numbers `n` and `m`, if `m` is a member of the set of proper divisors of `n`, then `m` is greater than 0. In other words, every element `m` in the proper divisors of a natural number `n` (as defined by `Nat.properDivisors`) is a positive natural number.

For all natural numbers `n` and `m`, if `m` is a proper divisor of `n`, then `m` is a positive natural number.


theorem Finset.attach_eq_univ : ∀ {α : Type u_1} {s : Finset α}, Finset.attach s = Finset.univ := by sorry

This theorem states that for any finite set `s` of a given type `α`, the set that's obtained by attaching `s` (i.e., forming the new set of elements of the subtype `{x // x ∈ s}`) is equal to the universal finite set of type `α`, under the assumption that `α` is a finite type. In other words, every element in the universe of a finite type `α` is associated with an element in the original set `s`.

For any finite set `s` of a finite type `α`, the subtype {x // x ∈ s} is equal to the universal finite set of type `α`.


MeasureTheory.Lp.simpleFunc.denseRange

theorem MeasureTheory.Lp.simpleFunc.denseRange :
    ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {p : ENNReal}
      {μ : MeasureTheory.Measure α} [inst_2 : Fact (1 ≤ p)], p ≠ ⊤ → DenseRange Subtype.val :=
  by sorry

This theorem, named `MeasureTheory.Lp.simpleFunc.denseRange`, states that for any type `α` equipped with a `MeasurableSpace` structure, any type `E` equipped with a `NormedAddCommGroup` structure, any extended nonnegative real number `p` not equal to infinity (where `ENNReal` represents the extended nonnegative real numbers), and any measure `μ` on `α` where it is a fact that `1 ≤ p`, the function `Subtype.val` has a dense range. This means that the image of the `Subtype.val` function is a dense subset of the space it maps into.

For any measurable space `(α, Σ)`, normed additive group `(E, +, ‖.‖)`, extended nonnegative real number `p > 0`, and measure `μ` on `α`, the range of `Subtype.val` from the set of measurable simple functions `MeasuredFunctions μ E` is dense in the Banach space `(E, ‖.��ėxpected Norm‖_2)`.


theorem SmoothMap.coe_one :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {H : Type u_4} [inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5}
      [inst_6 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {N : Type u_6} [inst_7 : TopologicalSpace N]
      [inst_8 : ChartedSpace H N] {G : Type u_10} [inst_9 : One G] [inst_10 : TopologicalSpace G]
      [inst_11 : ChartedSpace H' G], ⇑1 = 1 :=
  by sorry

This theorem asserts that in the context of smooth maps, for any non-trivially normed field 𝕜, normed add commutative groups E and E', normed spaces over 𝕜 E and E', topological spaces H, H', N and G, model with corners I and I', charted space H N and charted space H' G, and given one operation in G, the coercion of the multiplicative identity (one) to a function is equal to the identity function.

In the context of smooth maps and non-trivially normed fields, the coercion of the multiplicative identity to a function equals the identity function for any group operations in charted spaces over the fields.


theorem Set.diff_compl : ∀ {α : Type u} {s t : Set α}, s \ tᶜ = s ∩ t := by sorry

The theorem `Set.diff_compl` states that for any type `α` and any two sets `s` and `t` of type `α`, the difference of set `s` and the complement of set `t` is equal to the intersection of `s` and `t`. In mathematical terms, this could be written as \(s \setminus t^c = s \cap t\). Essentially, this theorem is stating a fundamental property of set operations in relation to complements and intersections.

The theorem `Set.diff_compl` asserts that for any type `α` and sets `s` and `t` of type `α`, their set difference `s \ t` equals their intersection `s ∩ t` and the complement of `t`, `t^c`, respectively, `s \ (t^c) = s ∩ t`.


theorem add_ball_zero :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E),
      s + Metric.ball 0 δ = Metric.thickening δ s :=
  by sorry

This theorem states that for any set `s` of elements in a seminormed additive commutative group `E` and a real number `δ`, the sum of `s` and the set of all points `y` such that the distance from `y` to the origin (`0`) is less than `δ` (`Metric.ball 0 δ`) is equal to the δ-thickening of `s` (`Metric.thickening δ s`). In other words, the set of points resulting from the element-wise addition of `s` and the open ball of radius `δ` centered at the origin is exactly the same as the set of all points that are at a distance less than `δ` from any point in `s`.

For any seminormed additive commutative group `E` with metric `Metric`, set `s ∈ E`, and real number `δ > 0`, the set `s + Metric.ball δ 0` equals `Metric.thickening δ s`.


/-- The minimal distance to a set is bounded by the distance to any point in this set.  -/
theorem Metric.infDist_le_dist_of_mem :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x y : α}, y ∈ s → Metric.infDist x s ≤ dist x y := by sorry

This theorem states that for any given type `α`, which is a pseudo metric space, and for any set `s` of this type, and any two elements `x` and `y` of this type, if `y` is a member of set `s`, then the minimal distance from `x` to the set `s` is less than or equal to the distance from `x` to `y`. This theorem ensures that the minimal distance from a point to a set will never exceed the distance from that point to any specific member of the set.

For any pseudo-metric space `(α, d)` and set `s ⊆ α`, and for all `x, y ∈ α` with `y ∈ s`, we have `d(x, s) ≤ d(x, y)`.


theorem Ideal.sum_mem :
    ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {ι : Type u_1} {t : Finset ι} {f : ι → α},
      (∀ c ∈ t, f c ∈ I) → (Finset.sum t fun i => f i) ∈ I :=
  by sorry

The theorem `Ideal.sum_mem` states that for any semiring `α`, and for any Ideal `I` of this semiring, if we have a function `f : ι → α` from some type `ι` to `α`, and a finite set `t` of elements of type `ι`, such that every value `f c` for `c` in `t` is an element of the ideal `I`, then the sum of the function `f` over all elements in the set `t` (expressed as `Finset.sum t f`) is also in the ideal `I`. In other words, an ideal in a semiring is closed under finite summation of its elements.

Given a semiring `α` and an ideal `I` of `α`, if `f : ι -> α` is a function from a finite set `t` of type `ι` such that `f c` is in `I` for all `c` in `t`, then `Finset.sum t f` is also in `I`.


theorem Ordinal.opow_lt_opow_iff_right : ∀ {a b c : Ordinal.{u_1}}, 1 < a → (a ^ b < a ^ c ↔ b < c) := by sorry

This theorem states that for any three ordinals `a`, `b`, and `c`, if `a` is greater than 1, then `a` raised to the power of `b` is less than `a` raised to the power of `c` if and only if `b` is less than `c`. In other words, it illustrates the monotonicity of the exponentiation operation in the context of ordinals when the base ordinal is greater than 1.

For ordinals `a` > 1, `a^b` < `a^c` if and only if `b` < `c`.


/-- In a semiring of sets `C`, for all set `s ∈ C` and finite set of sets `I ⊆ C`, there is a
finite set of sets in `C` whose union is `s \ ⋃₀ I`.
See `IsSetSemiring.diffFinset₀` for a definition that gives such a set.  -/
theorem MeasureTheory.IsSetSemiring.exists_disjoint_finset_diff_eq :
    ∀ {α : Type u_1} {C : Set (Set α)} {s : Set α} {I : Finset (Set α)},
      MeasureTheory.IsSetSemiring C → s ∈ C → ↑I ⊆ C → ∃ J, ↑J ⊆ C ∧ Set.PairwiseDisjoint (↑J) id ∧ s \ ⋃₀ ↑I = ⋃₀ ↑J :=
  by sorry

This theorem states that in a semiring of sets `C`, for any given set `s` that is a member of `C` and any finite subset of sets `I` that is also a subset of `C`, there exists another finite set of sets `J` which is a subset of `C`, that is pairwise disjoint (meaning any two distinct sets from `J` have no common elements), and whose union is equal to the set difference of `s` and the union of `I`. In other words, this theorem claims that we can find a finite set of mutually exclusive sets in `C` that, when unionized, recreate the set `s` with the sets in `I` removed.

For any set `s` in a semiring of sets `C` and finite subset `I` of `C`, there exists a finite, pairwise disjoint subset `J` of `C` such that `s \ (∨ x in I. X : X ∩ s = ∅) = ⋃ j in J. Xj`.


theorem tendsto_nhds :
    ∀ {X : Type u} {α : Type u_1} {x : X} [inst : TopologicalSpace X] {f : α → X} {l : Filter α},
      Filter.Tendsto f l (nhds x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f ⁻¹' s ∈ l :=
  by sorry

This theorem, `tendsto_nhds`, states a condition for a function to tend towards a limit in a topological space. Specifically, for a given type `X` with a topological space structure, a function `f` from some type `α` to `X`, a point `x` from `X`, and a filter `l` on `α`, the function `f` tends towards `x` (represented by `Filter.Tendsto f l (nhds x)`) if and only if for every set `s` of type `X` that is open and contains `x`, the preimage of `s` under `f` belongs to the filter `l`. Here, the preimage of `s` under `f` (`f ⁻¹' s`) is the set of elements in `α` that `f` maps into `s`. This theorem provides a characterization of the limit of a function in terms of open sets and their pre-images under the function.

A function from a type to a topological space tends towards a limit point if and only if the preimage of every open neighborhood of the limit point is in the filter.


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

This theorem states that for any two integers `a` and `b`, if `b` is less than `a`, then the result of `a - b` is greater than zero. In other words, subtracting a smaller integer from a larger integer will always give a positive result.

For all integers `a` and `b` with `b < a`, `a - b` is positive.


theorem ENorm.map_zero :
    ∀ {𝕜 : Type u_1} {V : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
      (e : ENorm 𝕜 V), ↑e 0 = 0 :=
  by sorry

This theorem states that for any field 𝕜 with a norm (a NormedField), for any additive commutative group V, and for any module V over 𝕜, if e is an extended norm (ENorm) on V over 𝕜, then the value of e at the zero element of V is zero. In other words, the extended norm of zero is always zero, regardless of the particular field, additive group, or module in question.

For any NormedField 𝕜, any additive commutative group V as a 𝕜-module, and any extended norm e on V, we have e(0) = 0.


theorem CategoryTheory.Pretriangulated.Triangle.mor₁_eq_zero_iff_mono₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles, T.mor₁ = 0 ↔ CategoryTheory.Mono T.mor₂ :=
  by sorry

This theorem states that in a pretriangulated category with integer shifts and zero objects, for any triangle that is a part of the distinguished triangles of the category, the first morphism of the triangle being zero is equivalent to the second morphism of the triangle being a monomorphism. Here, a pretriangulated category refers to a category that has a distinguished class of triangles and satisfies some coherency conditions, and a monomorphism is a morphism that is left-cancellable, that is, if it is composed with any other morphism, the resulting morphism is uniquely determined by the other morphism.

In a pretriangulated category with integer shifts and zero objects, the first morphism of a distinguished triangle being zero is equivalent to the second morphism being a monomorphism.


theorem Finset.cons_val : ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s), (Finset.cons a s h).val = a ::ₘ s.val :=
  by sorry

The theorem `Finset.cons_val` states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α` such that `a` is not in `s`, the value of the finite set constructed by consing `a` onto `s` (i.e., adding `a` to `s` while ensuring `a` is not already in `s`) is equal to the multiset obtained by consing `a` onto the value of `s`. In other words, when you add an element to a finite set while ensuring the element is not already in the set, the underlying multiset of the resulting set is the same as if you had simply added the element to the multiset of the original set.

For any type `α`, adding an element `a` not in a finite set `s` of type `α` results in a set with the same multiset as if `a` was consed onto the multiset of `s`.


theorem Algebra.algebraMap_eq_smul_one' :
    ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      ⇑(algebraMap R A) = fun r => r • 1 :=
  by sorry

The theorem `Algebra.algebraMap_eq_smul_one'` states that for any commutative semiring `R`, semiring `A` and given an algebra structure over `R` and `A`, the function defined by the embedding `algebraMap` from `R` to `A` is equivalent to the function that takes an element `r` from `R` and returns the result of 'scalar multiplication' of `r` with the multiplicative identity `1` in `A`. This theorem formalizes the intuition that the map induced by the algebra structure 'scales' elements of `R` by the identity in `A`.

For any commutative semiring `R`, semiring `A`, and algebra structure over `R` and `A`, the algebra map from `R` to `A` is equal to the function that scales elements of `R` by the multiplicative identity of `A`.


theorem Cardinal.mk_pi :
    ∀ {ι : Type u} (α : ι → Type v), Cardinal.mk ((i : ι) → α i) = Cardinal.prod fun i => Cardinal.mk (α i) := by sorry

This theorem, `Cardinal.mk_pi`, states that for any type `ι` and a function `α : ι → Type v`, the cardinality of the dependent product type `(i : ι) → α i` is equal to the indexed product of the cardinalities of the types `α i`. In other words, the cardinality of a dependent product type is the product of the cardinalities of each of the types involved, where the types are indexed by elements of type `ι`.

The cardinality of a dependent product type `(i : ι) → α i` is equal to the product of the cardinalities of the types `α i` indexed by `ι`.


theorem Nat.zero_testBit : ∀ (i : ℕ), Nat.testBit 0 i = false := by sorry

The theorem `Nat.zero_testBit` states that for any natural number `i`, when we test the `(i+1)`th least significant bit of `0`, the result is `false`. In mathematical terms, this means that in the binary representation of zero, all the bits are `0`. Hence, no matter which bit position you check, the result will be `0`, which in the context of the `Nat.testBit` function, returns `false`.

For all natural numbers i, the i-th bit of the binary representation of 0 is 0.


theorem List.map_add_range' :
    ∀ (a s n step : ℕ), List.map (fun x => a + x) (List.range' s n step) = List.range' (a + s) n step := by sorry

This theorem states that for all natural numbers `a`, `s`, `n` and `step`, the operation of mapping a function over a range of numbers, where the function adds `a` to each number in the list, is equivalent to creating a new range that starts at `a + s`. In other words, adding a constant `a` to each element of a list generated by `List.range' s n step` results in the same list as that generated by `List.range' (a + s) n step`.

For all natural numbers `a`, `s`, `n`, and `step`, the operation of adding `a` to each number in `List.range' s n step` is equivalent to generating `List.range' (a + s) n step`.


theorem Function.mulSupport_comp_eq_preimage :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : One M] (g : β → M) (f : α → β),
      Function.mulSupport (g ∘ f) = f ⁻¹' Function.mulSupport g :=
  by sorry

The theorem `Function.mulSupport_comp_eq_preimage` states that for any types `α`, `β`, and `M` with `M` being a type with a specified identity element, and given any function `g` from `β` to `M` and a function `f` from `α` to `β`, the `mulSupport` of the composition of `g` and `f` (denoted as `g ∘ f`) is equal to the preimage of the `mulSupport` of `g` under the function `f`. In other words, the set of points `x` in `α` such that `(g ∘ f)(x)` is not equal to `1` is exactly the set of points `x` in `α` such that `f(x)` is in the `mulSupport` of `g`.

The `Function.mulSupport_comp_eq_preimage` theorem asserts that the sets of points `x` in `α` such that `(g ∘ f)(x) ≠ 1` are equal to the preimage under `f` of the points in the `mulSupport` of `g` in `β`.


theorem IsOpen.measure_ne_zero :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] {U : Set X}, IsOpen U → Set.Nonempty U → ↑↑μ U ≠ 0 :=
  by sorry

The theorem `IsOpen.measure_ne_zero` states that for any type `X` with a topological space structure and a measurable space structure, a given measure `μ` of `X` that satisfies the property of being a positive measure on open sets, and any open set `U` of `X`, if `U` is non-empty, then the measure of `U` with respect to `μ` is not equal to zero.

In other words, in the context of measure theory, it asserts that any non-empty open set in a topological space has a non-zero measure under a measure that assigns positive values to open sets.

If `X` is a topological space with a measurable structure and `μ` is a positive measure on open sets, then a non-empty open set in `X` has positive measure under `μ`.


theorem Function.iterate_fixed : ∀ {α : Type u} {f : α → α} {x : α}, f x = x → ∀ (n : ℕ), f^[n] x = x := by sorry

This theorem states that for any type `α`, any function `f` from `α` to `α`, and any element `x` of `α`, if `f` applied to `x` gives `x` itself (i.e., `f x = x`), then for any natural number `n`, the `n`-times iteration of `f` applied to `x` will also yield `x`. In other words, if `x` is a fixed point of `f`, it remains the same under any number of iterations of `f`.

If `f` is a function from type `α` to itself such that `f x = x` implies `fn x = x` for any natural number `n`, then `x` is a fixed point of `f`.


theorem Pi.inf_apply :
    ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → Inf (α' i)] (f g : (i : ι) → α' i) (i : ι),
      (f ⊓ g) i = f i ⊓ g i :=
  by sorry

This theorem states that for any type `ι`, any type `α'` that is a function of `ι`, and any two functions `f` and `g` that map from `ι` to `α'`, the infimum (greatest lower bound) of the function applied to `i` is equal to the infimum of the values of `f` and `g` applied to `i`. In mathematical terms, this can be denoted as (f ⊓ g)(i) = f(i) ⊓ g(i). This theorem essentially shows the distributive property of the infimum operation over function application.

For any types `ι`, `α'`, and functions `f` and `g` from `ι` to `α'`, the infimum of `(f ∘ id)` and `(g ∘ id)` is equal to `(inf (map f) = inf (map g)) ∘ id`, where `id` is the identity function on `ι` and `map` applies a function to each element of a list.


theorem HasDerivAt.div_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'} {c' : 𝕜'},
      HasDerivAt c c' x → ∀ (d : 𝕜'), HasDerivAt (fun x => c x / d) (c' / d) x :=
  by sorry

The theorem `HasDerivAt.div_const` states that for any nontrivially normed fields `𝕜` and `𝕜'` where `𝕜'` is a normed algebra over `𝕜`, given a function `c` from `𝕜` to `𝕜'`, and a point `x` in `𝕜`, if `c` has a derivative `c'` at the point `x`, then for any constant `d` in `𝕜'`, the function defined by `c x / d` has the derivative `c' / d` at the point `x`.

In other words, this theorem is stating the rule that the derivative of a function divided by a constant is the derivative of the original function divided by that constant.

If a function from a nontrivially normed field to a normed algebra over that field has a derivative at a point, then the derivative of the function evaluated at that point divided by a constant is equal to the quotient of the derivative and the constant.


theorem MeasureTheory.Memℒp.ae_eq :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f g : α → E},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp g p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.ae_eq` states that for any types `α` and `E`, any measurable space `m0` over `α`, any extended non-negative real number `p`, any measure `μ` on `α`, and any normed additive commutative group `E`, if two functions `f` and `g` from `α` to `E` are equal almost everywhere with respect to the measure `μ` (i.e., they are equal except on a set of measure zero), then if `f` belongs to the space `ℒp` (i.e., `f` is almost everywhere strongly measurable and either the p-th power of the norm of `f` integrated with respect to `μ` is finite if `p` is less than infinity, or the essential supremum of `f` is less than infinity if `p` equals infinity), so does `g`. In mathematical notation, we could write this as: if `f = g` almost everywhere and `f ∈ ℒp(μ)`, then `g ∈ ℒp(μ)`.

If two functions are equal almost everywhere and one is in the Lebesgue space Lp with respect to a measure, then the other is also in Lp with respect to that measure.


theorem Equiv.prod_comp :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid α]
      (e : ι ≃ κ) (g : κ → α), (Finset.prod Finset.univ fun i => g (e i)) = Finset.prod Finset.univ fun i => g i :=
  by sorry

The theorem `Equiv.prod_comp` states that for any two types `ι` and `κ`, both of finite size, equipped with a total bijective function (equivalence) `e : ι ≃ κ`, and a function `g : κ → α` where `α` is a type with commutative monoid structure, the product of `g (e i)` over all elements `i` in the universal set of `ι` is equal to the product of `g i` over all elements `i` in the universal set of `κ`. In other words, applying an equivalence to the elements before taking the product does not change the overall product.

For any finite types `ι ≃ κ` with a bijective function `e : ι → κ` and a commutative monoid `α`, the product of `g (e i)` over all `i` in `ι` equals the product of `g i` over all `i` in `κ`.


theorem Filter.tendsto_iInf' :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι),
      Filter.Tendsto f (x i) y → Filter.Tendsto f (⨅ i, x i) y :=
  by sorry

The theorem `Filter.tendsto_iInf'` states that for any types `α` and `β`, sorting type `ι`, a function `f` from `α` to `β`, a family of filters `x` indexed by `ι` on `α`, and a filter `y` on `β`, given an index `i` in `ι`, if the function `f` tends to the filter `y` when applied to the filter `x i`, then `f` also tends to `y` when applied to the infimum of the family of filters `x`. In essence, it asserts that if a function converges to a limit under a particular filter in a family, it also converges to that same limit under the infimum of the entire family of filters.

If a function converges pointwise to a filter on its codomain with respect to a family of filters on its domain, then it converges to the same filter under the infimum of the family.


theorem MeasureTheory.IntegrableAtFilter.filter_mono :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E}
      {μ : MeasureTheory.Measure α} {l l' : Filter α},
      l ≤ l' → MeasureTheory.IntegrableAtFilter f l' μ → MeasureTheory.IntegrableAtFilter f l μ :=
  by sorry

The theorem `MeasureTheory.IntegrableAtFilter.filter_mono` states that for any types `α` and `E`, where `α` has a measurable space structure and `E` has a normed add commutative group structure, and given a function `f` from `α` to `E`, a measure `μ` on `α`, and two filters `l` and `l'` on `α`, if `l` is less than or equal to `l'` and the function `f` is integrable at filter `l'`, then `f` is also integrable at filter `l`.

In other words, if the function is integrable at a certain level of 'coarseness' given by the filter `l'`, it is also integrable at finer levels of 'coarseness' given by any filter `l` that is a subset of `l'`.

If `μ` is a measure on a measurable space `(α, Σ)`, `E` is a normed add commutative group, `f: α → E` is integrable at filter `l'`, and `l` is a filter on `α` with `l ≤ l'`, then `f` is integrable at filter `l`.


TendstoUniformly.prod

theorem TendstoUniformly.prod :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {p : Filter ι}
      {ι' : Type u_1} {β' : Type u_2} [inst_1 : UniformSpace β'] {F' : ι' → α → β'} {f' : α → β'} {p' : Filter ι'},
      TendstoUniformly F f p →
        TendstoUniformly F' f' p' →
          TendstoUniformly (fun i a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (p ×ˢ p') :=
  by sorry

The theorem `TendstoUniformly.prod` states that for any two sequences of functions `F` and `F'` that converge uniformly to the limiting functions `f` and `f'` with respect to filters `p` and `p'` respectively, there exists a joint sequence of functions `(F i.1 a, F' i.2 a)` that converges uniformly to the joint limiting function `(f a, f' a)` with respect to the product filter `(p ×ˢ p')`. Here, `α` and `ι` are the domain types, `β` and `β'` are the codomain types equipped with uniform spaces, and `i` is a pair of elements from the filters `p` and `p'`.

If sequences `F:` `ι -> β` and `F':` `ι -> β'` uniformly converge to `f:` `α -> β` and `f':` `α -> β'` respectively with respect to filters `p` and `p'`, then there exists a joint sequence `(Fi a, F' i a)` that uniformly converges to the pair `(f a, f' a)` with respect to the product filter `p ×ˢ p'`.


theorem Mathlib.Data.Finset.LocallyFinite.Basic._auxLemma.11 :
    ∀ {α : Type u} [inst : Preorder α] {a : α}, (a ≤ a) = True := by sorry

This theorem, named `Mathlib.Data.Finset.LocallyFinite.Basic._auxLemma.11`, states that for any type `α` endowed with a `Preorder` (a mathematical structure that captures the intuitive notion of an ordering that is reflexive and transitive), and for any element `a` of this type, the statement "`a` is less than or equal to `a`" is always true. This reflects the reflexive property of preorders where an element is always considered to be less than or equal to itself.

For any preorder `α`, every element `a` in `α` is less than or equal to itself.


IsometryEquiv.continuous

theorem IsometryEquiv.continuous :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      Continuous ⇑h :=
  by sorry

This theorem states that for any two types `α` and `β`, which are pseudo emetric spaces (i.e., spaces equipped with a notion of distance that may take the value +∞), any isometric equivalence `h` between these spaces is continuous. In other words, if there is an isometry (a distance-preserving transformation) that forms a bijective correspondence between the elements of the two spaces, then this transformation is continuous, meaning that nearby points in the original space get mapped to nearby points in the target space.

Given two pseudo metric spaces `α` and `β`, any isometric embedding `h : α → β` is a continuous function.


/-- `Finset.cons` version of `Finset.Ico_insert_right`.  -/
theorem Finset.Icc_eq_cons_Ico :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] {a b : α},
      a ≤ b → Finset.Icc a b = Finset.cons b (Finset.Ico a b) ⋯ :=
  by sorry

This theorem states that for any partial order that's also a locally finite order, if `a` is less than or equal to `b`, then the finite set of elements `x` such that `a ≤ x ≤ b` is equal to the union of the singleton set containing `b` and the finite set of elements `x` such that `a ≤ x < b`. In other words, the interval from `a` to `b`, inclusive, can be constructed by adding `b` to the interval from `a` to `b`, exclusive. The important aspect here is that the union operation is guaranteed to be disjoint and does not require `DecidableEq α`.

For any locally finite partial order, the interval from `a` to `b` (inclusive) equals the union of the singleton set `{b}` and the interval from `a` to `b` (exclusive).


/-- If the angle between three points is nonzero, the first two points are not equal.  -/
theorem EuclideanGeometry.left_ne_of_oangle_ne_zero :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 → p₁ ≠ p₂ :=
  by sorry

This theorem states that in a 2-dimensional oriented module over the real numbers, where the module is a normed add commutative group and also an inner product space, and where points lie in a metric space equipped with a normed add torsor structure, if the angle between three points is nonzero, then the first two points cannot be the same. Here, the angle is measured in the sense of Euclidean geometry. Thus, in simple terms, no two distinct points can make a nonzero angle with a common third point while being identical themselves.

In a 2-dimensional oriented real normed add commutative group and inner product space with metric space structure, distinct points make a nonzero angle if and only if they are not identical.


/-- The `sInf` of a bounded-below set is its greatest lower bound for a conditionally
complete lattice with a top.  -/
theorem WithTop.isGLB_sInf' :
    ∀ {β : Type u_5} [inst : ConditionallyCompleteLattice β] {s : Set (WithTop β)}, BddBelow s → IsGLB s (sInf s) := by
  sorry

The theorem `WithTop.isGLB_sInf'` states that for any type `β` that forms a conditionally complete lattice, and for any set `s` of values within the type `β` with an attached top (`WithTop β`), if the set `s` is bounded below (i.e., there exists a lower bound for the elements in the set `s`), then the infimum (`sInf`) of the set `s` is its greatest lower bound. This essentially means the `sInf` is the greatest value that is less than or equal to all elements in the set `s` for such a conditionally complete lattice with a top.

For any conditionally complete lattice `β` with a top element, if a set `s` in `β` has a bottom element, then the infimum of `s` is equal to its greatest lower bound.


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

This theorem states that for all complex numbers `x`, the complex cosine of `x` multiplied by the imaginary unit is equal to the complex hyperbolic cosine of `x`. In other words, `Complex.cos (x * Complex.I) = Complex.cosh x` for all `x` in the complex numbers. This relationship connects the trigonometric and hyperbolic functions in the context of complex numbers.

The complex function ` Complex.cos(x * Complex.I)` equals `Complex.cosh x` for all complex numbers `x`.


theorem Mathlib.LinearAlgebra.Ray._auxLemma.1 :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (y : M), SameRay R 0 y = True :=
  by sorry

The theorem states that for any strictly ordered commutative semiring `R` and an additive commutative monoid `M` that also is a module over `R`, any vector `y` in `M` lies in the same ray as the zero vector. In other words, the zero vector and any other vector `y` satisfy the property `SameRay`, which is defined to be true when either of the vectors is zero, or when some positive multiples of the vectors are equal.

For any strictly ordered commutative semiring R and an additive commutative monoid M that is an R-module, every non-zero vector y in M lies on the same ray as the zero vector.


theorem TopologicalSpace.Closeds.compl_compl :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Closeds α),
      TopologicalSpace.Opens.compl (TopologicalSpace.Closeds.compl s) = s :=
  by sorry

This theorem states that, for any topological space `α` and for any closed set `s` in this topological space, taking the complement twice - first as an open set, then as a closed set - will result in the original closed set `s`. In more mathematical terms, for a given closed set `s` in topological space `α`, the operation `TopologicalSpace.Opens.compl (TopologicalSpace.Closeds.compl s)` is essentially a double application of set complement, which is an operation that returns the set of elements not in `s`. Since the complement of a complement of a set is the set itself, this operation always returns the original set `s`.

For any closed set `s` in a topological space `α`, `TopologicalSpace.Closeds.compl (TopologicalSpace.Opens.compl s)` equals `s`.


theorem round_add_int :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (x : α) (y : ℤ),
      round (x + ↑y) = round x + y :=
  by sorry

The theorem `round_add_int` states that for all types `α` that form a linear ordered ring with a floor function, for any real number `x` and integer `y`, rounding the sum of `x` and `y` is the same as rounding `x` and then adding `y`. In other words, the `round` function distributes over integer addition.

For all types `α` that form a linear ordered ring with a floor function, the rounding of `(x : α) + y` equals `round x + y` for all real numbers `x` and integers `y`.


theorem Matrix.det_eq_zero_of_row_eq_zero :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {A : Matrix n n R}
      (i : n), (∀ (j : n), A i j = 0) → Matrix.det A = 0 :=
  by sorry

The theorem `Matrix.det_eq_zero_of_row_eq_zero` states that for any matrix `A` with entries in a commutative ring `R`, whose rows and columns are indexed by a type `n` that has decidable equality and is a finite type, if all the elements in a particular row `i` of `A` are zero, then the determinant of matrix `A` is zero. This is a formal statement of a well-known result in linear algebra, which says that if a matrix has a row of all zeros, its determinant is zero.

If matrix `A` over commutative ring `R` with decidable equality and finite index type `n` has a zero row, then its determinant is zero.


/-- **Alias** of the forward direction of `Int.not_le`. -/
theorem Int.lt_of_not_ge : ∀ {a b : ℤ}, ¬a ≤ b → b < a := by sorry

This theorem, known as `Int.lt_of_not_ge`, is an alias for the forward direction of `Int.not_le`. It states that for any two integers `a` and `b`, if `a` is not less than or equal to `b`, then `b` must be less than `a`. This is a basic property of integer comparison in mathematics.

If `a` is not less than or equal to `b` (`a >= b` is false), then `b` is less than `a` (`b < a`).


MeasureTheory.IntegrableOn.integrable

theorem MeasureTheory.IntegrableOn.integrable :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α}, MeasureTheory.IntegrableOn f s μ → MeasureTheory.Integrable f (μ.restrict s) :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.integrable` states that given any measurable space `α`, a normed additive commutative group `E`, a function `f` from `α` to `E`, a set `s` of type `α`, and a measure `μ` on `α`, if the function `f` is integrable on the set `s` with respect to measure `μ`, then `f` is also integrable with respect to the restriction of measure `μ` to set `s`. In mathematical terms, the integrability of a function on a set implies its integrability on the measure restricted to that set.

If a function is integrable with respect to a measure on a set, then it is integrable with respect to the restriction of that measure to the set.


/-- If `s : ι → Set α` is an indexed family of sets, then finite intersections of `s i` form a basis
of `⨅ i, 𝓟 (s i)`.   -/
theorem Filter.hasBasis_iInf_principal_finite :
    ∀ {α : Type u_1} {ι : Type u_6} (s : ι → Set α),
      Filter.HasBasis (⨅ i, Filter.principal (s i)) (fun t => Set.Finite t) fun t => ⋂ i ∈ t, s i :=
  by sorry

The theorem `Filter.hasBasis_iInf_principal_finite` states that for any type `α` and index type `ι`, given an indexed family of sets `s : ι → Set α`, the finite intersections of sets in the family `s i` form a basis for the infimum of the principal filters of the sets `s i`. In other words, the basis of the infimum of these principal filters is comprised of the finite intersections of the sets in the indexed family.

For any indexed family of sets `s : ι → Set α`, the finite intersections of sets in `s` form a basis for the infimum of their principal filters.


theorem Finset.coe_inv :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveInv α] (s : Finset α), ↑s⁻¹ = (↑s)⁻¹ := by sorry

The theorem `Finset.coe_inv` states that for any type `α` that has decidable equality (i.e., for any two elements `a` and `b` of `α`, it is decidable whether `a = b`) and an involutive inverse operation (i.e., an operation where applying the operation twice to any value returns the original value), and for any finite set `s` of `α`, the inverse of the coersion of `s` is equal to the coersion of the inverse of `s`. In other words, taking the inverse before or after coersion yields the same result.

For any type `α` with decidable equality and an involutive inverse operation, the coercion of the inverse of a finite set is equal to the inverse of the coercion of the set.


/-- A continuous additive map between two vector spaces over `ℝ` is `ℝ`-linear.  -/
theorem map_real_smul :
    ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E]
      [inst_3 : ContinuousSMul ℝ E] {F : Type u_2} [inst_4 : AddCommGroup F] [inst_5 : Module ℝ F]
      [inst_6 : TopologicalSpace F] [inst_7 : ContinuousSMul ℝ F] [inst_8 : T2Space F] {G : Type u_3}
      [inst_9 : FunLike G E F] [inst_10 : AddMonoidHomClass G E F] (f : G),
      Continuous ⇑f → ∀ (c : ℝ) (x : E), f (c • x) = c • f x :=
  by sorry

This theorem states that, for any continuous additive map `f` between two real vector spaces `E` and `F`, the map obeys the property of real-linearity. More specifically, if `E` and `F` are both real vector spaces that are equipped with a topology and have a continuous scalar multiplication operation, and `f` is a function from `E` to `F` that behaves like a function (according to the `FunLike` type class) and also behaves like an additive monoid homomorphism (according to the `AddMonoidHomClass` type class), then if `f` is continuous, it will map scalar multiplication in `E` to scalar multiplication in `F`. In more mathematical terms, for all real numbers `c` and all elements `x` of `E`, `f` applied to `c` times `x` in `E` is the same as `c` times `f` applied to `x` in `F`.

If `f` is a continuous, additive map between real vector spaces `E` and `F` that respects scalar multiplication, then for all real numbers `c` and elements `x` of `E`, `f(cx) = c(f(x))`.


theorem Algebra.adjoin_induction :
    ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
      {p : A → Prop} {x : A},
      x ∈ Algebra.adjoin R s →
        (∀ x ∈ s, p x) →
          (∀ (r : R), p ((algebraMap R A) r)) →
            (∀ (x y : A), p x → p y → p (x + y)) → (∀ (x y : A), p x → p y → p (x * y)) → p x :=
  by sorry

The theorem `Algebra.adjoin_induction` states the following:

For all types `R` and `A`, where `R` is a commutative semiring, `A` is a semiring, and there exists an algebra structure between `R` and `A`, and given a set `s` of `A`, a predicate `p` on `A`, and an element `x` of `A`, if `x` belongs to the minimal subalgebra that includes `s` (`Algebra.adjoin R s`), and if the predicate `p` holds for all elements of `s`, and for all elements of `R` mapped into `A`, and is preserved under addition and multiplication in `A`, then `p` holds for `x`.

In simpler words, this theorem is a principle of mathematical induction for elements in the subalgebra generated by a particular set in the context of semirings and algebras.

If `s` is a set in a semiring `A` over a commutative semiring `R` with an algebra structure, and `x` is an element of the minimal subalgebra generated by `s` such that `p(y)` holds for all `y` in `s` and maps of `R` into `A`, then `p(x)` holds.


theorem QuotientGroup.mk_mul_of_mem :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {b : α} (a : α), b ∈ s → ↑(a * b) = ↑a := by sorry

This theorem, `QuotientGroup.mk_mul_of_mem`, states that for any type `α` that has a group structure, any subgroup `s` of `α`, and any two elements `a` and `b` of `α`, if `b` is a member of the subgroup `s`, then the quotient group element represented by `a * b` is equal to the quotient group element represented by `a`. In other words, multiplication by an element of the subgroup does not change the equivalence class in the quotient group, reflecting the effect of the normal subgroup on the group structure.

For any group `α` and subgroup `s`, if `b ∈ s`, then `[a] : s → α / s = [a * b] : σ → α / s`, where `[a]` and `[a * b]` denote the quotient group elements represented by `a` and `a * b`, respectively.


Equiv.Perm.IsThreeCycle.cycleType

theorem Equiv.Perm.IsThreeCycle.cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α},
      Equiv.Perm.IsThreeCycle σ → Equiv.Perm.cycleType σ = {3} :=
  by sorry

This theorem states that for any type 'α' that has a finite number of elements ('Fintype α') and has a decidable equality ('DecidableEq α'), if a permutation 'σ' is a three-cycle (meaning it is a cycle of length 3, as defined by 'Equiv.Perm.IsThreeCycle'), then the cycle type of this permutation (which is given by 'Equiv.Perm.cycleType σ') is equal to the singleton Multiset containing only the number 3. In simple terms, this theorem confirms that a three-cycle permutation has a cycle type of {3}.

For any finite type 'α' with decidable equality, a three-cycle permutation in its permutation group has a cycle type equal to the singleton set {3}.


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

The theorem `Ici_mem_nhds` states that for any types `α` that has a topological space structure, a linear order, and a topology where the intervals closed towards negative infinity are closed sets (`ClosedIicTopology`), and for any elements `a` and `b` of type `α`, if `a` is less than `b`, then the set of all elements greater than or equal to `a` (`Set.Ici a`) is a neighborhood of `b`. In other words, this set contains an open set around `b`. The set of all neighborhoods of `b` forms a filter, known as the neighborhood filter at `b`.

For any type `α` with a topology, linear order, and closed intervals towards negative infinity, if `a` is less than `b` in `α`, then the set of elements greater than or equal to `a` is a neighborhood of `b` in the neighborhood filter at `b`.


theorem Finset.inf'_eq_inf :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} (H : s.Nonempty)
      (f : β → α), Finset.inf' s H f = Finset.inf s f :=
  by sorry

The theorem `Finset.inf'_eq_inf` states that for any semilattice (a partially ordered set with a greatest lower bound for any pair of elements) of type α, with the presence of a top element, and any finite set `s` of type β that is nonempty, the infimum of the image of `s` under a function `f` obtained using `Finset.inf'` method is equal to the infimum obtained using `Finset.inf` method. In other words, both `Finset.inf' s H f` and `Finset.inf s f` will yield the same result when `s` is nonempty. The function `f` maps elements from the set `s` to the semilattice α.

For any semilattice with a top element and nonempty finite set, the infimum of the image of the set under a function, as computed using `Finset.inf'` and `Finset.inf`, is equal.


theorem himp_inf_le : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, (a ⇨ b) ⊓ a ≤ b := by sorry

This is a theorem from the domain of generalized Heyting algebras. It states that for any type `α` that has a structure of a generalized Heyting algebra, and for any two elements `a` and `b` of this type, the meet (infimum) of the implication from `a` to `b` and `a` itself is always less than or equal to `b`. In terms of logic, this theorem describes a property of the implication operation in intuitionistic logic, which is the logic underlying Heyting algebras.

In any generalized Heyting algebra, for all elements `a` and `b`, the implication `a => b` implies `a <= b`.


theorem Nat.mem_factors_iff_dvd : ∀ {n p : ℕ}, n ≠ 0 → Nat.Prime p → (p ∈ Nat.factors n ↔ p ∣ n) := by sorry

The theorem `Nat.mem_factors_iff_dvd` states that for any two distinct natural numbers `n` and `p`, where `n` is not equal to zero and `p` is a prime number, `p` is a factor of `n` (expressed as `p ∈ Nat.factors n`) if and only if `p` divides `n` (expressed as `p ∣ n`). This theorem is essentially saying that a prime number `p` is included in the prime factorization list of a non-zero natural number `n` if and only if `p` is a divisor of `n`.

A prime number `p` divides natural number `n` if and only if `p` is a factor in the prime factorization of `n`.


theorem AdjoinRoot.mk_self : ∀ {R : Type u} [inst : CommRing R] {f : Polynomial R}, (AdjoinRoot.mk f) f = 0 := by sorry

The theorem `AdjoinRoot.mk_self` states that for any type `R` which forms a commutative ring, denoted by `[inst : CommRing R]`, and for any polynomial `f` over `R`, the ring homomorphism `AdjoinRoot.mk f` applied to `f` yields zero. In other words, when the polynomial `f` is evaluated at the root adjoined by `f` itself, the result is zero. This is consistent with the concept that a root of a polynomial is a value which makes the polynomial equal to zero.

For any commutative ring R and polynomial f over R, the polynomial evaluation of f at its root adjoined by `AdjoinRoot.mk f` is zero.


theorem TopologicalSpace.NonemptyCompacts.nonempty :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.NonemptyCompacts α), Set.Nonempty ↑s := by sorry

The theorem `TopologicalSpace.NonemptyCompacts.nonempty` states that for any type `α` which has a topology (i.e., is an instance of a `TopologicalSpace`), and for any nonempty compact subset `s` of the topological space `α` (`TopologicalSpace.NonemptyCompacts α`), the set `s` is not empty (`Set.Nonempty ↑s`). In simple terms, the theorem guarantees that a nonempty compact subset in any topological space is indeed nonempty.

In any topological space, every nonempty compact subset is nonempty.


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

The theorem `ModelWithCorners.symm_comp_self` states that for any given `ModelWithCorners` structure `I` for a nontrivially normed field `𝕜`, a normed additive commutative group `E` and a topological space `H`, the composition of the partial equivalence corresponding to `I` and its inverse (obtained through `ModelWithCorners.symm`) is the identity function. In other words, applying the inverse and then reapplying the original function is equivalent to doing nothing, thus demonstrating that the original function and its inverse are perfect inverses of each other in the context of the `ModelWithCorners` structure.

For any `ModelWithCorners` structure `I` over a nontrivially normed field `𝕜`, the composition of `I` and its symmetric inverse is the identity function.


theorem IsRelPrime.of_mul_left_left :
    ∀ {α : Type u_1} [inst : CommMonoid α] {x y z : α}, IsRelPrime (x * y) z → IsRelPrime x z := by sorry

The theorem `IsRelPrime.of_mul_left_left` states that for any commutative monoid `α`, and any elements `x`, `y`, and `z` of `α`, if `x*y` and `z` are relatively prime (i.e., their only common divisor is a unit), then `x` and `z` are also relatively prime. Simply put, it tells us that if the product of two elements is relatively prime to another element, then each of those two elements is also relatively prime to that other element.

If `x`, `y`, and `z` are elements of a commutative monoid such that `x` and `y`, as well as `y` and `z`, are relatively prime, then `x` and `z` are also relatively prime.


theorem expMapCircle_apply : ∀ (t : ℝ), ↑(expMapCircle t) = Complex.exp (↑t * Complex.I) := by sorry

The theorem `expMapCircle_apply` states that for any real number `t`, the application of the function `expMapCircle` to `t` is equivalent to the complex exponential of `t` multiplied by the imaginary unit. In mathematical terms, it's stating that for all `t` in real numbers, the complex exponential of `t * i` (where `i` is the imaginary unit) maps to a point on the unit circle in the complex plane, as described by the function `expMapCircle`.

For all real numbers `t`, `expMapCircle t = (exp (i * t))`.


EuclideanGeometry.Sphere.ext

theorem EuclideanGeometry.Sphere.ext :
    ∀ {P : Type u_2} {inst : MetricSpace P} (x y : EuclideanGeometry.Sphere P),
      x.center = y.center → x.radius = y.radius → x = y :=
  by sorry

This theorem, named `EuclideanGeometry.Sphere.ext`, states that for any metric space `P`, if two spheres in this space have the same center and the same radius, then they are indeed the same sphere. In other words, in Euclidean geometry, a sphere is uniquely defined by its center and radius.

In any metric space, two spheres with identical centers and radii are equal.


theorem Finsupp.equivMapDomain_refl :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (l : α →₀ M), Finsupp.equivMapDomain (Equiv.refl α) l = l := by
  sorry

This theorem states that for any given type `α` and any module `M` over a ring, if we have a function `l` from `α` to `M` that returns `0` when the input is not in the domain of `l` (denoted as `α →₀ M`), then mapping the domain of `l` to itself using the identity equivalence (i.e., each element is equivalent to itself, represented by `Equiv.refl α`) via the `Finsupp.equivMapDomain` function, results in the original function `l`. In other words, applying the identity equivalence does not change the function.

For any type `α` and ring module `M`, the function `Finsupp.equivMapDomain (Equiv.refl _)` applied to a function `l : α →₀ M` equals `l` itself.


theorem Cardinal.isRegular_succ : ∀ {c : Cardinal.{u}}, Cardinal.aleph0 ≤ c → Cardinal.IsRegular (Order.succ c) := by
  sorry

This theorem states that for any cardinal number `c` in any type `u`, if `c` is greater than or equal to `ℵ₀` (the smallest infinite cardinal number), then the successor of `c` (i.e., the next cardinal number after `c`), denoted by `Order.succ c`, is a regular cardinal. A regular cardinal is a cardinal that is infinite and equals its own cofinality, which is the least cardinality of a unbounded subset.

For any cardinal number `c` in type `u` exceeding `ℵ₀`, its successor `Order.succ c` is a regular cardinal.


theorem LinearIndependent.lt_aleph0_of_finite :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] {ι : Type w} [inst_4 : Module.Finite R M] {v : ι → M},
      LinearIndependent R v → Cardinal.mk ι < Cardinal.aleph0 :=
  by sorry

The theorem `LinearIndependent.lt_aleph0_of_finite` states the following: Let `R` be a ring, `M` be an additive commutative group which is also an `R`-module. Suppose that `R` satisfies the strong rank condition, and `M` is a finite `R`-module. Now consider a family of vectors `v` indexed over the type `ι`. If this family of vectors is linearly independent over `R`, then the cardinal number of the type `ι` (i.e., the "size" of the index set) is strictly less than `ℵ₀`, the smallest infinite cardinal number. This essentially means that the family `v` cannot have 'infinitely many' vectors if it is to remain linearly independent in this context.

A finite linearly independent family of vectors over a ring `R` in an `R`-module `M` satisfies the size of its index set being strictly less than the first infinite cardinal number `ℵ₀`.


/-- See `add_tsub_assoc_of_le` for the equality.  -/
theorem add_tsub_le_assoc :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α} [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a + b - c ≤ a + (b - c) :=
  by sorry

This theorem, `add_tsub_le_assoc`, states that for any type `α` which has an order (`Preorder`), an additive commutative semigroup structure (`AddCommSemigroup`), a subtraction operation (`Sub`), and an ordered subtraction property (`OrderedSub`), and for any three instances `a`, `b`, and `c` of that type `α`, if the addition operation (`fun x x_1 => x + x_1`) respects the order (`fun x x_1 => x ≤ x_1`), then the expression `a + b - c` is always less than or equal to `a + (b - c)`. This theorem thus expresses a specific kind of associativity relation for addition and subtraction operations in this ordered, additive context.

For any type `α` with order, additive commutative semigroup structure, subtraction operation, and ordered subtraction property, if addition respects the order, then `a + (b - c)` is the same as `(a + b) - c`, and the former is less than or equal to the latter.


theorem mul_left_cancel_iff :
    ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsLeftCancelMul G] {a b c : G}, a * b = a * c ↔ b = c := by sorry

This theorem, `mul_left_cancel_iff`, is a universal proposition in the context of a type `G` equipped with a multiplication operation (`Mul G`) and the property of left-cancellability (`IsLeftCancelMul G`). It states that for any three elements `a`, `b`, and `c` in `G`, the equality `a * b = a * c` is equivalent to `b = c`. In other words, if two products with the same left factor are equal, then the right factors must also be equal. This is essentially the cancellation law for multiplication on the left.

If for all elements `a`, `b`, `c` in a group `G` with multiplication `Mul G` and left-cancellation property `IsLeftCancelMul G`, the equality `a * b = a * c` implies `b = c`.


Primrec.pred

theorem Primrec.pred : Primrec Nat.pred := by sorry

The theorem `Primrec.pred` states that the predecessor function on natural numbers (`Nat.pred`) is primitive recursive. Here, the predecessor function is defined such that for any natural number `n`, if `n` is 0, its predecessor is 0; otherwise, its predecessor is `n - 1`. Primitive recursive functions are a class of functions that are defined using certain base functions and operations, and are a subset of total recursive functions. In this case, the theorem asserts that `Nat.pred` belongs to this class, after encoding its input and output as natural numbers.

The predecessor function on natural numbers, defined as `Nat.pred(n) := if n = 0 then 0 else n - 1`, is a primitive recursive function.


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

This theorem, `Matrix.mulVec_transpose`, states that for any type `m`, `n`, and `α`, where `α` has a structure of a `NonUnitalCommSemiring` and `m` is a `Fintype`, given a matrix `A` of type `Matrix m n α` and a vector `x` of type `m → α`, the multiplication of the transpose of `A` with vector `x` using the `Matrix.mulVec` function is the same as the vector multiplication of `x` with `A` using the `Matrix.vecMul` function. In mathematical terms, this means that for a given matrix `A` and a vector `x`, we have $(A^T)x = xA$, where $A^T$ denotes the transpose of `A`.

For any matrix `A` of type `Matrix m n α` and vector `x` of type `m → α`, where `α` is a `NonUnitalCommSemiring` and `m` is a `Fintype`, the transpose of `A` multiplied by vector `x` is equal to vector `x` multiplied by `A`, i.e., $(A^T)x = xA$.


Computable.encode

theorem Computable.encode : ∀ {α : Type u_1} [inst : Primcodable α], Computable Encodable.encode := by sorry

The theorem `Computable.encode` states that for any type `α` which has a primary codable instance `inst`, the function `Encodable.encode` is computable. Here, `Encodable.encode` is a function that takes an instance of a type `α` and converts it into a natural number (`ℕ`). Essentially, this theorem is about the computability of the encoding process from a general type to natural numbers when the type is primary codable.

For any type `α` with a primary codable instance `inst`, the encoding function `Encodable.encode` is a computable function.


theorem Matrix.inv_pow' :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      (A : Matrix n' n' R) (n : ℕ), A⁻¹ ^ n = (A ^ n)⁻¹ :=
  by sorry

This theorem states that for any type `n'` with decidable equality and finite number of elements, for any commutative ring `R`, for any matrix `A` with entries in `R` and dimensions indexed by `n'`, and for any natural number `n`, the `n`th power of the inverse of `A` is the same as the inverse of the `n`th power of `A`. In mathematical notation, this would be written as $(A^{-1})^n = (A^n)^{-1}$.

For any commutative ring R, finite type n with decidable equality, and matrix A of size n x n over R with decidable inverse, $(A^{-1})^n = (A^n)^{-1}$.


theorem Metric.closedBall_zero' :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), Metric.closedBall x 0 = closure {x} := by sorry

The theorem `Metric.closedBall_zero'` states that for any type `α` that is a pseudometric space, and for any element `x` of type `α`, the closed ball centered at `x` with radius 0 is equal to the closure of the singleton set `{x}`. In other words, the set of all points with a distance less than or equal to 0 from `x` is equivalent to the smallest closed set containing only `x`.

For any pseudometric space `α` and element `x` in `α`, the closed ball `{y : α | d(x, y) ≤ 0}` is equal to the closure of the singleton set `{x}`.


theorem Mathlib.Data.SetLike.Basic._auxLemma.4 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x y : ↥p}, (↑x = ↑y) = (x = y) := by sorry

This theorem states that for any types `A` and `B`, given that `A` is a "set-like" structure over `B`, and for any element `p` of type `A` and elements `x` and `y` which are of the type of elements of `p`, the equality of the coerced values of `x` and `y` (when they are treated as elements of the underlying set `B`) is equivalent to the equality of `x` and `y` themselves. This asserts the consistency of equality when transitioning between the "set-like" structure and the underlying set.

For any set-like structure `A` over type `B`, and for all `a : A` and `x, y : elem a`, if `x = y` in `A`, then `x = y` in `B`.


theorem FreeAbelianGroup.of_mul_of :
    ∀ {α : Type u} [inst : Mul α] (x y : α),
      FreeAbelianGroup.of x * FreeAbelianGroup.of y = FreeAbelianGroup.of (x * y) :=
  by sorry

This theorem states that for any type `α` with a multiplication operation, and any elements `x` and `y` of type `α`, the product of the canonical map applied to `x` and `y` in the `FreeAbelianGroup` of `α` is equal to the canonical map applied to the product of `x` and `y`. In more mathematical terms, it asserts that the canonical map `FreeAbelianGroup.of` preserves the multiplication operation from `α` to its Free Abelian Group.

For any type `α` with a multiplication operation and any elements `x` and `y` of type `α`, the canonical map from `α` to its Free Abelian Group maps `(x * y)` to `(FreeAbelianGroup.of x) * (FreeAbelianGroup.of y)`.


theorem IsometryEquiv.preimage_closedBall :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : β)
      (r : ℝ), ⇑h ⁻¹' Metric.closedBall x r = Metric.closedBall ((IsometryEquiv.symm h) x) r :=
  by sorry

The theorem `IsometryEquiv.preimage_closedBall` states that for any isometric isomorphism `h` between two pseudometric spaces `α` and `β`, the preimage of a closed ball in `β` centered at a point `x` with radius `r` under the isomorphism `h` is equal to the closed ball in `α` centered at the image of `x` under the inverse of the isomorphism `h` with the same radius `r`. In other words, applying an isometric isomorphism doesn't change the size of the closed ball, it simply relocates it.

Given an isometric isomorphism between two pseudometric spaces and a point with radius in those spaces, the preimage of the closed ball centered at that point in the second space is equal to the closed ball centered at the image of that point in the first space under the inverse isomorphism.


theorem Polynomial.derivative_monomial :
    ∀ {R : Type u} [inst : Semiring R] (a : R) (n : ℕ),
      Polynomial.derivative ((Polynomial.monomial n) a) = (Polynomial.monomial (n - 1)) (a * ↑n) :=
  by sorry

The theorem `Polynomial.derivative_monomial` states that for any semiring `R`, and for any element `a` of `R` and non-negative integer `n`, the derivative of the monomial `a * X^n` (represented in Lean as `(Polynomial.monomial n) a`) is `(a * n) * X^(n - 1)` (represented in Lean as `(Polynomial.monomial (n - 1)) (a * ↑n)`). This corresponds to the standard rule for differentiating a monomial in calculus.

The theorem asserts that the derivative of the monomial `a * X^n` in a polynomial over a semiring is equal to `(a * n) * X^(n - 1)`.


theorem LieAlgebra.derivedSeriesOfIdeal_zero :
    ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
      LieAlgebra.derivedSeriesOfIdeal R L 0 I = I :=
  by sorry

The theorem `LieAlgebra.derivedSeriesOfIdeal_zero` states that for any given commutative ring `R`, Lie ring `L` and a corresponding Lie algebra, and an ideal `I` of the Lie algebra, the zeroth term of the derived series of the ideal `I` is the ideal `I` itself. In other words, the initial term of the derived series of an ideal in a Lie algebra is the ideal itself.

The zeroth term of the derived series of an ideal in a Lie algebra is the ideal itself.


theorem Polynomial.coeff_mul_degree_add_degree :
    ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R),
      Polynomial.coeff (p * q) (Polynomial.natDegree p + Polynomial.natDegree q) =
        Polynomial.leadingCoeff p * Polynomial.leadingCoeff q :=
  by sorry

The theorem `Polynomial.coeff_mul_degree_add_degree` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, the coefficient of the term in the product `p * q` with degree equal to the sum of the degrees of `p` and `q` is equal to the product of the leading coefficients of `p` and `q`. The leading coefficient of a polynomial is the coefficient of its highest-degree term.

Given polynomials $p$ and $q$ over a semiring $R$, the coefficient of the term of degree $\degree p + \degree q$ in the product $pq$ is equal to the product of their leading coefficients.


theorem AddMonoid.exponent_min' :
    ∀ {G : Type u} [inst : AddMonoid G] (n : ℕ), 0 < n → (∀ (g : G), n • g = 0) → AddMonoid.exponent G ≤ n := by sorry

The theorem `AddMonoid.exponent_min'` states that for any type `G` which forms an additive monoid, and for any natural number `n` greater than zero, if the scalar multiplication of `n` and any element `g` of `G` equals zero, then the exponent of the additive monoid `G` should be less than or equal to `n`. Here, the exponent of an additive monoid is the smallest positive integer `n` such that `n • g = 0` for all `g` in `G`, or zero if such an integer does not exist.

For any additive monoid `G` and natural number `n` greater than zero, if for all `g` in `G`, `n * g = 0`, then the exponent of `G` is less than or equal to `n`.


IsPurelyInseparable.inseparable

theorem IsPurelyInseparable.inseparable :
    ∀ (F : Type u) {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
      [inst_3 : IsPurelyInseparable F E] (x : E),
      Polynomial.Separable (minpoly F x) → x ∈ RingHom.range (algebraMap F E) :=
  by sorry

The theorem `IsPurelyInseparable.inseparable` states that for any field `F`, and a field `E` that is a purely inseparable extension of `F` with an algebra structure over `F`, and any element `x` from `E`, if the minimal polynomial of `x` over `F` is separable (which means it is coprime with its derivative), then `x` lies in the range of the ring homomorphism given by the algebra structure from `F` to `E`. In other words, if an element in a purely inseparable extension field has a separable minimal polynomial, it can be mapped from the base field via the algebra structure's ring homomorphism.

If `F` is a field, `E` is a purely inseparable extension of `F` as an `F`-algebra, and `x` is an element of `E` with separable minimal polynomial over `F`, then `x` lies in the image of the `F`-algebra homomorphism from `F` to `E`.


HasFPowerSeriesOnBall.analyticAt

theorem HasFPowerSeriesOnBall.analyticAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal}, HasFPowerSeriesOnBall f p x r → AnalyticAt 𝕜 f x :=
  by sorry

This theorem states that for any given function `f` mapping from a normed vector space `E` to another normed vector space `F` over a nontrivially normed field `𝕜`, if `f` has a formal power series expansion `p` on an open ball centered at `x` with radius `r` (which is an extended nonnegative real number), then `f` is analytic at `x`. This defines the notion of local analyticity, i.e., the function `f` is locally represented by a power series.

Given a function `f` from a normed vector space `E` to another normed vector space `F` over a nontrivially normed field `𝕜`, if `f` has a convergent power series expansion `p` on an open ball centered at `x` in `E` with radius `r`, then `f` is analytic at `x`.


/-- A morphism in `Stonean` is an epi iff it is surjective.

TODO: prove that `forget Stonean` preserves pushouts (in fact it preserves all finite colimits)
and deduce this from general lemmas about concrete categories.
 -/
theorem Stonean.epi_iff_surjective : ∀ {X Y : Stonean} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑f := by
  sorry

This theorem states that for any two objects `X` and `Y` in the `Stonean` category, a morphism `f` from `X` to `Y` is an epimorphism if and only if it is a surjective function. An epimorphism `f` is one that satisfies the property that for any two morphisms `g` and `h` from `Y` to any other object `Z`, if `g ∘ f = h ∘ f`, then `g = h`. On the other hand, a surjective function `f` is one where for every element `b` in the codomain `Y`, there exists an element `a` in the domain `X` such that `f(a) = b`. A future direction of this work is to prove that the functor `forget Stonean` preserves pushouts and then use this result to derive this theorem using general results about concrete categories.

In the Stonean category, a morphism is an epimorphism if and only if it is a surjective function.


theorem Multiset.card_Icc :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α),
      (Finset.Icc s t).card =
        Finset.prod (Multiset.toFinset s ∪ Multiset.toFinset t) fun i => Multiset.count i t + 1 - Multiset.count i s :=
  by sorry

This theorem states that for any two multisets `s` and `t` of type `α`, where `α` has a decidable equality, the cardinality of the finite set interval from `s` to `t` (`Finset.Icc s t`) is equal to the product of the difference in the multiplicity of each element `i` in `t` and `s`, plus one, for all `i` in the union of the finsets derived from `s` and `t`. In other words, the size of the interval between `s` and `t` in a finite set is calculated by subtracting the multiplicities of elements in `s` from the multiplicities of the same elements in `t`, adding one to the result, and taking the product over all these results for all elements in both `s` and `t`.

For any two multisets `s` and `t` of type `α` with decidable equality, the cardinality of `Finset.Icc s t` is equal to the product of the differences between the multiplicities of each element in `t` and `s`, plus one, over all elements in `s ∪ t`.


/-- For an s-finite kernel `κ` and a function `f : α → β → ℝ≥0∞` which is measurable when seen as a
map from `α × β` (hypothesis `Measurable (uncurry f)`), the integral `a ↦ ∫⁻ b, f a b ∂(κ a)` is
measurable.  -/
theorem Measurable.lintegral_kernel_prod_right :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      {κ : ↥(ProbabilityTheory.kernel α β)} [inst : ProbabilityTheory.IsSFiniteKernel κ] {f : α → β → ENNReal},
      Measurable (Function.uncurry f) → Measurable fun a => ∫⁻ (b : β), f a b ∂κ a :=
  by sorry

The theorem `Measurable.lintegral_kernel_prod_right` states that for an s-finite kernel `κ` and a function `f` from `α` to `β` that maps to the extended nonnegative real numbers, if `f` is measurable when viewed as a function from the product space `α × β` (that is, the function `f` uncurried is measurable), then the function that maps each `a` to the lebesgue integral of `f a b` with respect to `κ a` over `b` is also measurable. Here, the s-finite kernel `κ` is a measure on the space `α` and `β`, and the function `f` is effectively a function of two variables from `α` and `β`. The measurability indicates that the pre-image of any measurable set under these functions is also measurable.

If `κ` is an s-finite kernel and `f: α → ℝ∞²` is a measurable function on the product space `α × β`, then the function that maps each `a ∈ α` to the Lebesgue integral of `f a b` with respect to `κ a` over `β` is measurable.


theorem Complex.sin_mul_I : ∀ (x : ℂ), Complex.sin (x * Complex.I) = Complex.sinh x * Complex.I := by sorry

This theorem states that for every complex number `x`, the sine of `x` multiplied by the imaginary unit `I` is equal to the hyperbolic sine of `x` multiplied by the imaginary unit `I`. In other words, it is showing the relationship between the complex sine function and the complex hyperbolic sine function when their inputs are multiplied by the imaginary unit. This can also be expressed mathematically as `sin(xI) = sinh(x)I` for all complex `x`.

The theorem asserts that for all complex numbers x, sin(x \* i) = sinh(x) \* i, where i is the imaginary unit.


theorem Subalgebra.sum_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A) {ι : Type w} {t : Finset ι} {f : ι → A},
      (∀ x ∈ t, f x ∈ S) → (Finset.sum t fun x => f x) ∈ S :=
  by sorry

The theorem `Subalgebra.sum_mem` states that for any given commutative semiring `R` and semiring `A` with an algebra structure over `R`, subalgebra `S` of `A`, finite set `t` and a function `f` mapping from `t` to `A`, if every element `f x` for `x` in `t` belongs to the subalgebra `S`, then the sum of `f x` over all `x` in `t`, denoted by `Finset.sum t f`, also belongs to the subalgebra `S`. In mathematical terms, this means that a subalgebra is closed under finite summation.

If `R` is a commutative semiring, `A` is an `R`-algebra, `S` is a subalgebra of `A`, `t` is a finite set, and `f : t → A` is a function such that `f x ∈ S` for all `x ∈ t`, then `Finset.sum t f ∈ S`.


theorem Real.sin_mem_Icc : ∀ (x : ℝ), Real.sin x ∈ Set.Icc (-1) 1 := by sorry

This theorem states that for all real numbers `x`, the sine of `x` (denoted as `Real.sin x` in Lean 4) lies in the closed interval from -1 to 1. In other words, the real value of the sine function for any real number is always between -1 and 1, inclusive. This is a mathematical property of the sine function, which is known to fluctuate between -1 and 1, inclusive.

For all real numbers x, |Real.sin x| ≤ 1.


theorem ProbabilityTheory.kernel.iIndep.iIndepSets :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {m : ι → MeasurableSpace Ω}
      {s : ι → Set (Set Ω)},
      (∀ (n : ι), m n = MeasurableSpace.generateFrom (s n)) →
        ProbabilityTheory.kernel.iIndep m κ μ → ProbabilityTheory.kernel.iIndepSets s κ μ :=
  by sorry

This theorem, `ProbabilityTheory.kernel.iIndep.iIndepSets`, states that for any types `α`, `Ω`, and `ι`, given measurable spaces `_mα` and `_mΩ`, a probability kernel `κ` from `α` to `Ω`, a measure `μ` on `α`, a function `m` that assigns a measurable space to each element in `ι`, and a function `s` that assigns a set of sets of `Ω` to each element in `ι`. If for every element `n` in `ι`, the measurable space `m n` equals the smallest measurable space containing all sets in `s n`, and if the family of measurable spaces defined by `m` is independent with respect to the kernel `κ` and the measure `μ`, then the family of sets of sets defined by `s` is also independent with respect to the kernel `κ` and the measure `μ`.

If for every `n` in `ι`, the measurable spaces `m n` are the smallest containing the families `s n` and `κ(α)` is independent of `μ` and `m`, then the families `s n` are independent of `κ` and `μ`.


theorem Fintype.sum_bool :
    ∀ {α : Type u_1} [inst : AddCommMonoid α] (f : Bool → α),
      (Finset.sum Finset.univ fun b => f b) = f true + f false :=
  by sorry

This theorem, `Fintype.sum_bool`, states that for any type `α` equipped with an addition operation (forming a commutative monoid), and for any function `f` from the boolean type `Bool` to `α`, the sum of the function `f` over all elements in the universal finite set of `Bool`, which includes `true` and `false`, is equal to the sum of the function applied to `true` and the function applied to `false`. In other words, `f(true) + f(false)` gives us the total sum of `f` over the boolean set `Bool`.

For any commutative monoid additivity-preserving function `f` from `Bool` to a type `α` equipped with addition, `f(true) + f(false)` equals the sum of `f` over the finite set `Bool`.


theorem CategoryTheory.ShortComplex.opcyclesMap_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasRightHomology S₂]
      [inst_4 : CategoryTheory.ShortComplex.HasRightHomology S₃] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
      CategoryTheory.ShortComplex.opcyclesMap (CategoryTheory.CategoryStruct.comp φ₁ φ₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.opcyclesMap φ₁)
          (CategoryTheory.ShortComplex.opcyclesMap φ₂) :=
  by sorry

This is a theorem in the field of category theory, specifically dealing with short complexes. Given a category `C` with zero morphisms, and three short complexes `S1`, `S2`, and `S3` in `C` that have respective right homologies, the theorem states that for any two morphisms `φ1 : S1 ⟶ S2` and `φ2 : S2 ⟶ S₃`, the operation of the `opcyclesMap` function on the composition of `φ1` and `φ2` is the same as the composition of the `opcyclesMap` of `φ1` and the `opcyclesMap` of `φ2`. In mathematical terms, this asserts the compatibility of the `opcyclesMap` with morphism composition, i.e., `opcyclesMap (φ1 ≫ φ2) = (opcyclesMap φ1) ≫ (opcyclesMap φ2)`.

The `opcyclesMap` function of the composition of two morphisms between short complexes in a category with zero morphisms is equal to the composition of the `opcyclesMap` functions of the individual morphisms.


theorem nhdsWithin_Ioo_eq_nhdsWithin_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b : α},
      a < b → nhdsWithin a (Set.Ioo a b) = nhdsWithin a (Set.Ioi a) :=
  by sorry

This theorem, `nhdsWithin_Ioo_eq_nhdsWithin_Ioi`, states that for any type `α` equipped with a topological space structure, a linear order, and a topology such that the set of all elements greater than or equal to any given element is closed, if `a` and `b` are elements of `α` and `a` is less than `b`, then the "neighborhood within" filter of `a` with respect to the left-open right-open interval from `a` to `b` is equal to the "neighborhood within" filter of `a` with respect to the left-open right-infinite interval starting from `a`. In simpler terms, the local behavior of `a` in the interval `(a, b)` is the same as its local behavior in the interval `(a, +∞)`.

For any topological space `α` with a linear order and the property that every upper set is closed, if `a` and `b` are elements of `α` with `a < b`, then the neighborhood filter of `a` in the interval `(a, b)` is equal to the neighborhood filter of `a` in the interval `(a, +∞)`.


theorem Ordinal.blsub_eq_lsub' :
    ∀ {ι : Type u} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (f : ι → Ordinal.{max u v}),
      Ordinal.blsub (Ordinal.type r) (Ordinal.bfamilyOfFamily' r f) = Ordinal.lsub f :=
  by sorry

The theorem `Ordinal.blsub_eq_lsub'` states that for any type `ι`, any relation `r` on `ι` that forms a well-order, and any function `f` from `ι` to the set of ordinals, the least strict upper bound of the family of ordinals indexed by the set of ordinals less than the order type of `r` and converted to a family indexed by an ordinal using the specified well-ordering (`Ordinal.blsub (Ordinal.type r) (Ordinal.bfamilyOfFamily' r f)`) is equal to the least strict upper bound of the family of ordinals indexed directly by `ι` (`Ordinal.lsub f`). In simpler terms, it states that transforming the indexing set of a family of ordinals through a well-ordering doesn't change the least upper bound of that family.

For any type `ι`, well-order `r` on `ι`, and function `f : ι → Ordinal`, the least strict upper bound of the family `Ordinal.bfamilyOfFamily' r f` is equal to the least strict upper bound of the family `f`.


theorem Mathlib.Data.Finset.Sups._auxLemma.6 : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) := by sorry

This theorem, `Mathlib.Data.Finset.Sups._auxLemma.6`, states that for any type `α` and any finite sets `s₁` and `s₂` of that type, `s₁` is equal to `s₂` if and only if the set of elements in `s₁` (denoted by `↑s₁`) is equal to the set of elements in `s₂` (denoted by `↑s₂`). In other words, two finite sets are the same if they contain the same elements.

Two finite sets `s₁` and `s₂` of type `α` are equal if and only if their elements are identical, i.e., `↑s₁ = ↑s₂`.


theorem Mathlib.Data.List.Cycle._auxLemma.11 : ∀ {α : Type u_1} (a : α), (a ∈ Cycle.nil) = False := by sorry

This theorem, called `Mathlib.Data.List.Cycle._auxLemma.11`, states that for any type `α` and any element `a` of type `α`, `a` is not in `Cycle.nil`. In other words, there are no elements in the unique empty cycle, `Cycle.nil`. This theorem applies to all types, denoted here by `α`.

There are no elements in the empty cycle.


theorem SimpleGraph.colorable_chromaticNumber :
    ∀ {V : Type u} {G : SimpleGraph V} {m : ℕ},
      SimpleGraph.Colorable G m → SimpleGraph.Colorable G (ENat.toNat (SimpleGraph.chromaticNumber G)) :=
  by sorry

The theorem `SimpleGraph.colorable_chromaticNumber` states that for any given type `V`, simple graph `G` of the same type, and natural number `m`, if the graph `G` is colorable with `m` colors, then it is also colorable with the number of colors equal to the natural number representation of its chromatic number. The chromatic number of a graph is the minimum number of colors needed to color the graph, and `ENat.toNat` is a function converting extended natural numbers to natural numbers, where infinity is mapped to zero.

If a simple graph of type `V` is colorable with `m` colors and its chromatic number is `n`, then it is also colorable with `n` (or `ENat.toNat n` in Lean) colors.


theorem Subgroup.zpowers_le :
    ∀ {G : Type u_1} [inst : Group G] {g : G} {H : Subgroup G}, Subgroup.zpowers g ≤ H ↔ g ∈ H := by sorry

This theorem states that for any group `G`, any element `g` of `G`, and any subgroup `H` of `G`, the subgroup generated by `g` is a subset of `H` if and only if `g` itself is an element of `H`. In other words, all powers of `g` are in `H` exactly when `g` is in `H`.

The subgroup generated by an element `g` in a group `G` is contained in a subgroup `H` if and only if `g` is an element of `H`.


theorem Polynomial.trailingCoeff_nonzero_iff_nonzero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.trailingCoeff p ≠ 0 ↔ p ≠ 0 := by sorry

This theorem states that for any type `R` that is an instance of the `Semiring` type class and for any polynomial `p` over `R`, the trailing coefficient of `p` is nonzero if and only if `p` itself is nonzero. In other words, a polynomial is nonzero if and only if the coefficient of its smallest power is nonzero.

A polynomial over a semiring is nonzero if and only if its leading coefficient is nonzero.


theorem Filter.limsSup_le_limsSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {f g : Filter α},
      autoParam (Filter.IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝ →
        autoParam (Filter.IsBounded (fun x x_1 => x ≤ x_1) g) _auto✝¹ →
          (∀ (a : α), (∀ᶠ (n : α) in g, n ≤ a) → ∀ᶠ (n : α) in f, n ≤ a) → Filter.limsSup f ≤ Filter.limsSup g :=
  by sorry

The theorem `Filter.limsSup_le_limsSup` states that for any type `α` that forms a conditionally complete lattice, and for any filters `f` and `g` over this type, if filter `f` is co-bounded (meaning there exists an upper bound for the values eventually obtained from the filter) and filter `g` is bounded (meaning there is some value that eventually all elements from the filter are less than or equal to), and if for every element `a` of `α`, whenever every element eventually obtained from filter `g` is less than or equal to `a`, then every element eventually obtained from filter `f` is also less than or equal to `a`, then the limsup (the least upper bound of the set of limit points) of filter `f` is less than or equal to the limsup of filter `g`.

If filters `f` and `g` over a conditionally complete lattice `α` have upper bounds, `f` is co-bounded and `g` is bounded, and for all `a` in `α`, every element eventually obtained from `g` being less than or equal to `a` implies every element eventually obtained from `f` is also less than or equal to `a`, then `limsup(f) ≤ limsup(g)`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.20 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {θ : FirstOrder.Language.BoundedFormula L α (Nat.succ l)} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.all θ) v xs =
        ∀ (a : M), FirstOrder.Language.BoundedFormula.Realize θ v (Fin.snoc xs a) :=
  by sorry

The theorem `Mathlib.ModelTheory.Semantics._auxLemma.20` states that for any first-order language `L`, a type `M` equipped with a structure for `L`, a type `α`, a natural number `l`, a bounded formula `θ` in `L` with arity `Nat.succ l`, a function `v` from `α` to `M`, and a function `xs` from `Fin l` to `M`, the realization of the universal quantification of `θ` with respect to `v` and `xs` is equivalent to the statement that for all `a` in `M`, `θ` is realized with respect to `v` and `xs` to which `a` has been added at the end (i.e., `Fin.snoc xs a`). This essentially captures the semantics of the universal quantifier in first-order logic in terms of function realization.

For any first-order language L, a structure M, a type α, a natural number l, a bounded formula θ in L with arity Nat.succ l, a valuation v from α to M, and an assignment xs from Fin l to M, the universal quantification of θ with respect to v and xs is equivalent to the statement that for all a in M, θ is realized with respect to v and xs extended by a.


theorem lipschitzWith_one_norm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], LipschitzWith 1 norm := by sorry

The theorem `lipschitzWith_one_norm` states that for any type `E` that is a `SeminormedAddGroup`, the norm function is Lipschitz continuous with a Lipschitz constant of 1. In the context of mathematics, this means that for all elements `x` and `y` in `E`, the distance between the norms of `x` and `y` (i.e., `||x||` and `||y||`) is less than or equal to the distance between `x` and `y` itself. This property is a key feature of norms in seminormed groups.

For any `SeminormedAddGroup` `E`, the norm function `||.||` is 1-Lipschitz continuous, i.e., `||x - y|| ≤ ||x - y||_1 + ||y - x||`, where `||.||_1` denotes the 1-norm on `E`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.14 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {φ ψ : FirstOrder.Language.BoundedFormula L α l} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (φ ⊔ ψ) v xs =
        (FirstOrder.Language.BoundedFormula.Realize φ v xs ∨ FirstOrder.Language.BoundedFormula.Realize ψ v xs) :=
  by sorry

The theorem `Mathlib.ModelTheory.Semantics._auxLemma.14` from the `Mathlib` library states that for any first-order language `L`, any type `M` that is a structure for `L`, any type `α`, length `l`, bounded formulas `φ` and `ψ` in `L`, function `v` from `α` to `M`, and function `xs` from finite set of size `l` to `M`, the realization (interpretation) of the join (logical disjunction) of `φ` and `ψ` is equivalent to either the realization of `φ` or the realization of `ψ`. This is a fundamental theorem in model theory, a branch of mathematical logic that deals with the relationship between syntactic expressions (formulas) and their interpretations in mathematical structures.

For any first-order language L, structure M for L, function v : α -> M, finite set xs : set (M)^l of size l, and bounded formulas φ and ψ in L, the realization of φ \/\ψ equals the realization of φ or the realization of ψ.


theorem isMinFilter_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {a : α} {b : β}, IsMinFilter (fun x => b) l a := by
  sorry

The theorem `isMinFilter_const` states that for all types `α` and `β`, where `β` has a preorder (meaning that it has a binary relation satisfying reflexivity and transitivity), for all filters `l` on `α`, for all elements `a` of `α`, and for all elements `b` of `β`, the function that sends every element to `b` (a constant function) is a minimum filter at `a` with respect to `l`. In other words, the value of `b` is less than or equal to the value of the function at any other point in the `l`-neighborhood of `a`. This is always the case for a constant function, since all function values are the same, namely `b`.

For all types `α` and preordered `β`, given a filter `l` on `α`, a constant function `f : α → β` with value `b` at every point, and any `a` in `α`, `b` is an `l`-minimum at `a`.