theorem Set.one_mem_div_iff : ∀ {α : Type u_2} [inst : Group α] {s t : Set α}, 1 ∈ s / t ↔ ¬Disjoint s t := by sorry

This theorem states that for any type `α` that forms a group, and any two sets `s` and `t` of elements from this group, the multiplicative identity `1` is an element of the quotient set `s / t` if and only if the sets `s` and `t` are not disjoint. Here, the quotient set `s / t` is defined as the set of all elements `x` such that there exists an element in `s` and an element in `t` whose product equals `x`. The sets `s` and `t` are said to be disjoint if their infimum (greatest lower bound) is the bottom element of their lattice structure.

For any group `α`, the multiplicative identity `1` belongs to the quotient set `s / t` of `α` if and only if sets `s` and `t` are not disjoint.


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

This theorem, `Int.lt_of_neg_lt_neg`, states that for any two integers `a` and `b`, if the negation of `b` is less than the negation of `a` (i.e., `-b < -a`), then `a` is less than `b` (i.e., `a < b`). This theorem is a reflection of the property in number theory that reversing the order of inequality holds when both sides are negated.

For all integers `a` and `b`, `-a < -b` implies `b < a`.


/-- If `C` has all limits of diagrams `parallelPair f g`, then it has all equalizers  -/
theorem CategoryTheory.Limits.hasEqualizers_of_hasLimit_parallelPair :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : ∀ {X Y : C} {f g : X ⟶ Y}, CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair f g)],
      CategoryTheory.Limits.HasEqualizers C :=
  by sorry

The theorem `CategoryTheory.Limits.hasEqualizers_of_hasLimit_parallelPair` states that for any category `C`, if `C` has all limits of diagrams defined by a pair of parallel morphisms `f` and `g` from `X` to `Y`, then `C` also has all equalizers. In mathematical terms, an equalizer is a specific limit for a pair of morphisms, so if a category has all general limits for such pairs, it necessarily has all equalizers.

In any category with all limits of pairs of parallel morphisms, equalizers exist.


theorem hasSum_geometric_two' : ∀ (a : ℝ), HasSum (fun n => a / 2 / 2 ^ n) a := by sorry

This theorem states that for any real number `a`, the sum of the infinite series where each term is `a` divided by 2 and then divided by 2 to the power of `n` (where `n` is the index of the term in the series) is equal to `a`. In mathematical terms, this can be written as: for all `a` in ℝ, Σ (a / 2 / 2^n) = `a`.

For any real number `a`, the sum of the infinite series where each term is `a / 2^(n+1)` equals `a`.


theorem MeasureTheory.snorm_zero :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F], MeasureTheory.snorm 0 p μ = 0 :=
  by sorry

This theorem states that for any type `α`, type `F` forming a normed additive commutative group, any measurable space `m0` over `α`, any extended nonnegative real number `p`, and any measure `μ` over the measurable space `α`, the `ℒp` seminorm of the zero function will always be zero. The `ℒp` seminorm, denoted as `MeasureTheory.snorm`, is typically used in the context of measure theory and functional analysis.

For any normed additive commutative group `F` over type `α`, measurable space `m0` over `α`, extended nonnegative real number `p`, and measure `μ` over `m0`, the `ℒp` seminorm of the zero function is equal to zero.


theorem Set.image_add_right' :
    ∀ {α : Type u_2} [inst : AddGroup α] {t : Set α} {b : α}, (fun x => x + -b) '' t = (fun x => x + b) ⁻¹' t := by
  sorry

This theorem, `Set.image_add_right'`, states that for any type `α` with an `AddGroup` structure, for any set `t` of type `α`, and any element `b` of type `α`, the image of the set `t` under the function `x ↦ x + (-b)` is equal to the preimage of the set `t` under the function `x ↦ x + b`. In other words, adding `-b` to each element in a set gives the same result as the set of elements that would result in an element of the original set when `b` is added to them.

For any set `t` of an additive group `α`, and any element `b` in `α`, the sets `{x : α | x + (-b) ∈ t}` and `{x : α | x + b ∈ t}` are equal.


theorem MvPolynomial.le_vanishingIdeal_zeroLocus :
    ∀ {k : Type u_1} [inst : Field k] {σ : Type u_2} (I : Ideal (MvPolynomial σ k)),
      I ≤ MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus I) :=
  by sorry

This theorem states that for any field `k` and any type `σ`, given an ideal `I` in the ring of multivariate polynomials with coefficients in `k` and variables indexed by `σ`, `I` is a subset of the vanishing ideal of the zero locus of `I`. In plain terms, every polynomial in the ideal `I` vanishes at all points of the set, which is the zero locus of `I`. The zero locus of `I` is the set of all points where every polynomial in `I` evaluates to zero. The vanishing ideal of a set, on the other hand, is the ideal consisting of all polynomials that vanish at every point of the set.

For any field `k` and type `σ`, the ideal `I` of multivariate polynomials with coefficients in `k` and variables indexed by `σ` is contained in the vanishing ideal of its zero locus.


theorem continuous_sum_dom :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X ⊕ Y → Z},
      Continuous f ↔ Continuous (f ∘ Sum.inl) ∧ Continuous (f ∘ Sum.inr) :=
  by sorry

The theorem `continuous_sum_dom` states that for all types `X`, `Y`, and `Z` where `X`, `Y`, and `Z` are topological spaces, a function `f` from the disjoint union of `X` and `Y` to `Z` is continuous if and only if both the composition of `f` with the injection from `X` into the disjoint union (`Sum.inl`), and the composition of `f` with the injection from `Y` into the disjoint union (`Sum.inr`), are continuous.

A function from the disjoint union of topological spaces X and Y to Z is continuous if and only if its restrictions to the subspaces X and Y are continuous.


theorem Mathlib.Data.Int.Parity._auxLemma.21 : ∀ {m n : ℤ}, Even (m + n) = (Even m ↔ Even n) := by sorry

This theorem states that for any two integers `m` and `n`, the quantity `m + n` is even if and only if `m` and `n` are both even. Here, an element `a` is defined as even if there exists a number `r` such that `a = r + r`.

The sum of two integers is even if and only if both integers are even.


theorem Mathlib.Data.Int.Parity._auxLemma.26 : ∀ {m n : ℤ}, Even (m * n) = (Even m ∨ Even n) := by sorry

The theorem `Mathlib.Data.Int.Parity._auxLemma.26` states that for any two integers `m` and `n`, the product `m * n` is even if and only if either `m` or `n` (or both) are even. Here, an integer `a` is said to be 'even' if there exists another integer `r` such that `a = r + r`.

The theorem `Mathlib.Data.Int.Parity._auxLemma.26` asserts that the product of two integers `m` and `n` is even if and only if at least one of them is even.


theorem List.nthLe_cyclicPermutations :
    ∀ {α : Type u} (l : List α) (n : ℕ) (hn : n < List.length (List.cyclicPermutations l)),
      List.nthLe (List.cyclicPermutations l) n hn = List.rotate l n :=
  by sorry

This theorem states that for any list `l` of elements of any type `α` and any natural number `n` that is less than the length of the cyclic permutations of `l`, the `n`th element of these cyclic permutations (accessed via `List.nthLe`) is equivalent to the result of rotating `l` to the left by `n` positions (performed via `List.rotate`). In other words, it asserts that the `n`th cyclic permutation of a list is just the list rotated `n` times.

For any list `l` of length `n+1` and any natural number `0 <= i < n`, the `i`th cyclic permutation of `l` equals the list obtained by rotating `l` to the left by `i` positions.


theorem Finset.min'_eq_inf' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), Finset.min' s H = Finset.inf' s H id := by
  sorry

The theorem `Finset.min'_eq_inf'` states that for any given non-empty finset `s` of a type `α` that has a linear order, the minimum element of `s` (`Finset.min' s H`) is equal to the infimum (`Finset.inf' s H id`) of `s` when considering the identity function. Here, `H` is a proof that set `s` is nonempty. This theorem bridges the concepts of minimum of a set and the infimum of a set under the identity map in the context of a finite set in Lean 4.

For any non-empty finite set `s` with a linear order, `Finset.min' s` equals `Finset.inf' s` under the identity function.


theorem Set.image_update_Ioo :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (α i)]
      (f : (i : ι) → α i) (i : ι) (a b : α i),
      Function.update f i '' Set.Ioo a b = Set.Ioo (Function.update f i a) (Function.update f i b) :=
  by sorry

The theorem `Set.image_update_Ioo` states that for any type `ι`, any indexed type `α : ι → Type`, and any type-dependent partial order over `α`, if we have a function `f : (i : ι) → α i` and an index `i : ι` along with two elements `a` and `b` of `α i`, then the image of the interval `(a, b)` under the function `f` updated at `i` is the interval `(f(i:=a), f(i:=b))`. This essentially means that if we update the function at a certain index, the set of values it takes between `a` and `b` remains the same interval when the function is updated at the same index with `a` and `b` respectively.

For any type `ι`, indexed type `α : ι → Type`, partial order on `α`, function `f : ι → α`, index `i : ι`, and elements `a, b : α i`, the image of the interval `(a, b)` under `f` updated at `i` is the interval `(f(i:=a), f(i:=b))`.


theorem Ordnode.dual_balanceR :
    ∀ {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α),
      Ordnode.dual (Ordnode.balanceR l x r) = Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l) :=
  by sorry

The theorem `Ordnode.dual_balanceR` states that for all types `α`, and for all ordered nodes `l` and `r` of type `α`, the function `dual` applied to the right-balanced tree formed with `l`, `x`, and `r` (i.e., `Ordnode.balanceR l x r`) will be equivalent to the left-balanced tree formed with the dual of `r`, `x`, and the dual of `l` (i.e., `Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)`). This shows a symmetry in the dual operations of right balancing and left balancing in an ordered binary tree.

For all types `α` and ordered nodes `l`, `x`, and `r` of type `α`, `Ordnode.balanceR l x r` is dual to `Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)`.


theorem Filter.prod_comap_comap_eq :
    ∀ {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x} {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : β₁ → α₁}
      {m₂ : β₂ → α₂}, Filter.comap m₁ f₁ ×ˢ Filter.comap m₂ f₂ = Filter.comap (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂) :=
  by sorry

This theorem states that for any two types `α₁` and `α₂`, with filters `f₁` and `f₂`, and for any two mappings `m₁` from `β₁` to `α₁` and `m₂` from `β₂` to `α₂`, the cartesian product of the comap (preimage) of `f₁` under `m₁` and the comap of `f₂` under `m₂` is equal to the comap of the cartesian product filter `f₁ ×ˢ f₂` under a function that applies `m₁` to the first element of a pair and `m₂` to the second.

In other words, the theorem demonstrates a property of filter comaps with respect to the cartesian product: pulling back the filters along the mappings before forming the product is the same as forming the product first and then pulling back along the pair of mappings.

For any filters `f₁` on type `α₁`, `f₂` on type `α₂`, and mappings `m₁` from `β₁` to `α₁` and `m₂` from `β₂` to `α₂`, the comap of the cartesian product filter `f₁ ×ˢ f₂` under the function `λ (x, y) => (m₁ x, m₂ y)` is equal to the cartesian product of the comaps of `f₁` under `m₁` and `f₂` under `m₂`.


theorem isOpen_singleton_iff_nhds_eq_pure :
    ∀ {X : Type u} [inst : TopologicalSpace X] (x : X), IsOpen {x} ↔ nhds x = pure x := by sorry

This theorem states that for any type `X` equipped with a topology and any element `x` of `X`, the singleton set containing just `x` is an open set if and only if the neighborhood filter at `x` is equal to the pure filter at `x`. In other words, a single-element set is open in the given topological space if and only if every neighborhood of the element contains only that element.

A singleton set in a topological space is open if and only if it is the only element in every neighborhood of its element.


theorem Set.image_update_Ioc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (α i)]
      (f : (i : ι) → α i) (i : ι) (a b : α i),
      Function.update f i '' Set.Ioc a b = Set.Ioc (Function.update f i a) (Function.update f i b) :=
  by sorry

The theorem `Set.image_update_Ioc` states that for any index type `ι`, any indexed type `α`, any decidable equality on `ι`, and any partial order on `α`, given a function `f` that maps from `ι` to `α`, and two values `a` and `b` from `α i`, the image of the interval `(a, b]` (exclusive of `a`, inclusive of `b`) under the update of `f` at index `i` is the interval `(f(i) updated with a, f(i) updated with b]`. In simpler terms, it means that updating a function at a particular index and then taking the image of an interval under this updated function gives the same result as first taking the images of the endpoints under the updated function and then forming the interval.

For any index type `ι`, any indexed type `α` with decidable equality, any partial order on `α`, and any function `f : ι → α`, the image of the interval `(f i)↑[a, b]` under `f.update i a` is equal to `(f i)↑[f a, f b]`. (Here, `↑` denotes the image under a function, `update` is the update operator in Lean, and `[a, b]` denotes the interval from `a` to `b` inclusive.)


theorem Encodable.encodek₂ :
    ∀ {α : Type u_1} [inst : Encodable α] (a : α), Encodable.decode₂ α (Encodable.encode a) = some a := by sorry

The theorem `Encodable.encodek₂` states that for any type `α` that has an `Encodable` instance and any element `a` of type `α`, when we encode `a` into a natural number and then decode it back using the failsafe decoding method `decode₂`, we get back the original element `a`. In other words, the encoding and subsequent failsafe decoding of an element from an encodable type `α` form an identity operation, showing that the encoding-decoding process is lossless for given element of `α`.

For any encodable type `α` and element `a` of type `α`, the failsafe decoding of the encoding of `a` is equal to `a`.


theorem List.takeWhile_append_dropWhile :
    ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.takeWhile p l ++ List.dropWhile p l = l := by sorry

The theorem `List.takeWhile_append_dropWhile` states that for any type `α`, any predicate function `p` of type `α → Bool`, and any list `l` of type `List α`, concatenating the list obtained by taking the longest initial segment of `l` for which `p` holds (`List.takeWhile p l`) with the list obtained by dropping elements from `l` until `p` fails (`List.dropWhile p l`) yields the original list `l`. This theorem asserts the equivalence of the original list and the newly formed list from the 'takeWhile' and 'dropWhile' segments.

For any type `α` and predicate function `p` on `α`, the list `takeWhile p xs ++ dropWhile p xs` equals the original list `xs`, where `xs` is a list of type `List α`, `takeWhile p xs` is the longest prefix of `xs` where `p` holds, and `dropWhile p xs` is the rest of `xs` after the longest prefix where `p` holds.


theorem Finset.mem_eraseNone : ∀ {α : Type u_1} {s : Finset (Option α)} {x : α}, x ∈ Finset.eraseNone s ↔ some x ∈ s :=
  by sorry

This theorem states that for any type `α`, any set `s` of optional elements of type `α`, and any element `x` of type `α`, the element `x` is a member of the set obtained by erasing all `None` options from `s` if and only if `Some x`, i.e., the option holding `x`, is an element of `s`. In other words, `Finset.eraseNone` effectively removes all `None` options from the set `s`, and an element `x` exists in the resulting set if and only if `x` was originally in `s` as an optional value.

For any type `α` and set `s` of optional elements of type `α`, an element `x` is in the set `Finset.eraseNone s` if and only if `Some x` is in `s`.


theorem Filter.prod_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, f ×ˢ g = Filter.seq (Filter.map Prod.mk f) g := by
  sorry

This theorem states that for any two types `α` and `β`, and any two filters `f` on `α` and `g` on `β`, the product filter of `f` and `g` is equivalent to the sequence filter of the map filter of the product constructor `Prod.mk` with respect to `f`, followed by `g`. In other words, it's saying that forming a product of two filters can be done either directly or by first mapping each element in the first filter to a function that attaches it to an element in the second filter, and then sequencing these functions over the second filter.

For any filters `f` on type `α` and `g` on type `β`, the product filter of `f` and `g` is equal to the sequence filter of the map filter of the product constructor `Prod.mk` from `α × β` to `β`, applied to `g`, and then composed with the map filter of `f` on `α`.


theorem Multiset.insert_eq_cons : ∀ {α : Type u_1} (a : α) (s : Multiset α), insert a s = a ::ₘ s := by sorry

The theorem `Multiset.insert_eq_cons` states that for any type `α` and for any element `a` of this type and any multiset `s` of this type, inserting the element `a` into the multiset `s` is equivalent to adding the element `a` to the front of the multiset `s`. Here, a multiset is a type of finite sets where duplicates are allowed, and the operation `a ::ₘ s` adds the element `a` to the front of the multiset `s`.

For any type `α` and any multiset `s` of type `α`, the multiset obtained by inserting an element `a` of type `α` into `s` is equal to the multiset obtained by adding `a` to the front of `s` using the multiset cons operator `::ₘ`.


theorem Real.arcsin_of_le_neg_one : ∀ {x : ℝ}, x ≤ -1 → Real.arcsin x = -(Real.pi / 2) := by sorry

This theorem states that for any real number `x`, if `x` is less than or equal to `-1`, then the arcsine of `x` (represented by `Real.arcsin x` in Lean) is equal to negative half of pi (denoted by `-(Real.pi / 2)`). In mathematical notation, this is equivalent to the statement that for all x in ℝ, if x ≤ -1, then arcsin(x) = -π/2.

For any real number `x` below `-1`, the arcsine function `Real.arcsin x` equals `-(Real.pi / 2)`.


theorem CategoryTheory.Limits.biproduct.map_π_assoc :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f g : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      [inst_3 : CategoryTheory.Limits.HasBiproduct g] (p : (j : J) → f j ⟶ g j) (j : J) {Z : C} (h : g j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.map p)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.π g j) h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.π f j)
          (CategoryTheory.CategoryStruct.comp (p j) h) :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.map_π_assoc` states that for any type `J` and any type `C` that forms a category with zero morphisms, given two functions `f` and `g` from `J` to `C` that have biproducts, and for any mapping `p` from each element of `J` to a morphism from `f j` to `g j` for each `j` in `J`, then for any `j` in `J` and any object `Z` in `C` with a morphism `h` from `g j` to `Z`, the composition of the biproduct map of `p` with the composition of the projection onto a summand of the biproduct of `g` at `j` and `h`, is equal to the composition of the projection onto a summand of the biproduct of `f` at `j` and the composition of `p j` and `h`. This theorem describes a property of category theory morphism composition in relation to biproduct maps and projections in the category.

For any type `J`, given functions `f` and `g` from `J` to a category `C` with zero morphisms, and for any mapping `p : J -> Morp(C) (f _ to g _)`, the diagram commuting with both projections of the biproduct of `g` and `h` from `g j` to `Z` implies the commutativity of diagrams with the projections of the biproducts of `f` and `h` from `f j` to `Z`.


theorem MeasureTheory.Measure.finiteAt_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {_m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α)
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] (x : α) (s : Set α),
      MeasureTheory.Measure.FiniteAtFilter μ (nhdsWithin x s) :=
  by sorry

The theorem `MeasureTheory.Measure.finiteAt_nhdsWithin` states that for any type `α` with a topological and measurable space structure, any measure `μ` that is locally finite, any element `x` of type `α`, and any set `s` of type `α`, the measure `μ` is finite at the filter `nhdsWithin x s`. Here, `nhdsWithin x s` represents the "neighborhood within" filter, which includes sets containing the intersection of `s` and a neighborhood of `x`. In other words, the measure of the neighborhood of `x` within the set `s` is finite.

For any locally finite measure `μ` on a topological and measurable space `(α, τ, μ)`, `μ` is finite on the filter of neighborhoods of a point `x` in a set `s`, i.e., `μ(nhdsWithin x s) < ∞`.


theorem PartialEquiv.trans_source'' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : PartialEquiv β γ),
      (PartialEquiv.trans e e').source = ↑(PartialEquiv.symm e) '' (e.target ∩ e'.source) :=
  by sorry

The theorem `PartialEquiv.trans_source''` asserts that for all partial equivalences `e` from type `α` to type `β`, and `e'` from type `β` to type `γ`, the source domain of the composition of `e` and `e'` (denoted as `PartialEquiv.trans e e'`) equals the image of the intersection of `e.target` and `e'.source` under the inverse of `e` (denoted as `PartialEquiv.symm e`). This is a property about the domain of definition when composing two partial equivalences.

For all partial equivalences $e:\alpha \rightleftharpoons \beta$ and $e':\beta \rightleftharpoons \gamma$ in Lean 4, the domain of definition of $e \circ e'$ is equal to the image of $e'.source \cap e.target$ under the inverse of $e$.


theorem LowerSet.coe_iInf :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → LowerSet α), ↑(⨅ i, f i) = ⋂ i, ↑(f i) := by sorry

This theorem, `LowerSet.coe_iInf`, states that for any type `α` and any sort `ι`, given an operation `LE` on `α` and a function `f` that maps `ι` to a lower set of `α`, the coercion of the greatest lower bound (infimum or `⨅`) of the function `f` over all `ι` is equal to the intersection over all `ι` of the coercion of the function `f`. In other words, it equates the infimum of a collection of lower sets to the intersection of the sets themselves.

Given an operation LE on type α and a function f from sort ι to lower sets of α, the coercion of the inf (⨅) of the images of f is equal to the intersection of the coercions of the images.


theorem Real.measurable_log : Measurable Real.log := by sorry

The theorem `Real.measurable_log` states that the real logarithm function is measurable. In other words, for every measurable set in the codomain, the preimage of that set under the real logarithm function is also a measurable set. This means if we have a set of real numbers which are suitably 'nice' (measurable), then the set of all numbers which map to that set under the logarithm function is also 'nice' (measurable).

The real logarithm function maps measurable sets to measurable sets.


theorem Nat.Primrec'.if_lt :
    ∀ {n : ℕ} {a b f g : Vector ℕ n → ℕ},
      Nat.Primrec' a →
        Nat.Primrec' b → Nat.Primrec' f → Nat.Primrec' g → Nat.Primrec' fun v => if a v < b v then f v else g v :=
  by sorry

This theorem states that for any natural number `n`, and for any functions `a`, `b`, `f`, and `g` that map a vector of natural numbers of length `n` to a natural number, if `a`, `b`, `f`, and `g` are all primitive recursive (denoted by `Nat.Primrec'`), then the function that takes a vector `v` and returns the result of `f v` if `a v` is less than `b v`, otherwise returns `g v`, is also primitive recursive. Essentially, it asserts the primitive recursiveness of an 'if-then-else' construct where the condition involves a comparison of two primitive recursive functions and the 'then' and 'else' parts are also primitive recursive functions.

If `a`, `b`, `f`, and `g` are primitive recursive functions mapping a vector of natural numbers to natural numbers, then the function that applies `f` if `a` is less than `b` and `g` otherwise is also primitive recursive.


theorem linearIndependent_iUnion_of_directed :
    ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {η : Type u_8}
      {s : η → Set M},
      Directed (fun x x_1 => x ⊆ x_1) s →
        (∀ (i : η), LinearIndependent R fun (x : ↑(s i)) => ↑x) → LinearIndependent R fun (x : ↑(⋃ i, s i)) => ↑x :=
  by sorry

This theorem states that for any semiring `R`, additive commutative monoid `M`, and any module over `R` and `M`, given a directed family of sets of elements of `M`, if each set in the family is linearly independent over `R`, then the union of all these sets is also linearly independent over `R`. Here, a family of sets is directed if, for any two sets in the family, there exists another set in the family that contains both of the initial sets. Linear independence of a set means that no vector in the set can be written as a linear combination of the other vectors in the set.

If `{A_i}` is a directed family of linearly independent sets in an `R`-module `M`, then their union is also linearly independent in `M` over `R`.


theorem Filter.mem_comap' :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {s : Set α},
      s ∈ Filter.comap f l ↔ {y | ∀ ⦃x : α⦄, f x = y → x ∈ s} ∈ l :=
  by sorry

This theorem, `Filter.mem_comap'`, states that for every types `α` and `β`, every function `f` from `α` to `β`, every filter `l` of type `β`, and every set `s` of type `α`, the set `s` is in the co-domain of the function `f` with respect to the filter `l` if and only if the set of all `y` such that for each `x` in `α`, if `f(x)` equals `y` then `x` is in `s`, is in the filter `l`. Essentially, it's about the relationship between the filter and the set in the image and pre-image under a function `f`.

For every function `f:` α -> β, filter `l` on β, and set `s` subset α, `s` is in the filter `l`'s image under `f` if and only if the set of all `y` in β such that the pre-image `{x in α | f(x) = y}` is a subset of `s`, is in `l`.


Set.InjOn.injective

/-- **Alias** of the forward direction of `Set.injOn_iff_injective`. -/
theorem Set.InjOn.injective :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s → Function.Injective (Set.restrict s f) := by
  sorry

This theorem, referred to as an alias of the forward direction of `Set.injOn_iff_injective`, states that for any types `α` and `β`, any set `s` of type `α`, and any function `f` from `α` to `β`, if `f` is injective on the set `s` (meaning that for any two elements in `s`, if `f` maps them to the same value then they must be the same element), then the restriction of `f` to `s` is also injective. This means that, when we restrict `f` to the subset `s` of its domain and then consider it as a function from `s` to `β`, it still has the property that equal outputs mean equal inputs.

If a function restricted to a subset is injective on that subset whenever it is injective on the entire domain, then function injectivity is preserved under subset restriction.


theorem Odd.neg_pow :
    ∀ {α : Type u_2} [inst : Monoid α] [inst_1 : HasDistribNeg α] {n : ℕ}, Odd n → ∀ (a : α), (-a) ^ n = -a ^ n := by
  sorry

The theorem `Odd.neg_pow` states that for any type `α` that is a monoid and also has the ability to distribute the negation operation, and for any natural number `n` which is odd, the power of the negation of any element `a` of the type `α` to the `n` is equal to the negation of `a` to the power `n`. In other words, if `n` is odd, then negating `a` before raising it to the power `n` has the same result as negating the result of raising `a` to the power `n`. This property is often used in number theory and algebra.

For any monoid `α` with distributive negation and odd natural number `n`, the negation of `a` to the power `n` equals the power of the negation of `a` to `n`.


theorem List.dropLast_concat : ∀ {α : Type u_1} {l₁ : List α} {b : α}, List.dropLast (l₁ ++ [b]) = l₁ := by sorry

The theorem `List.dropLast_concat` is stating that for any type `α`, any list `l₁` of type `α`, and any element `b` of type `α`, if we append `b` to the end of `l₁` to form a new list and then remove the last element of this new list, we will be left with the original list `l₁`. In other words, dropping the last element from the concatenation of a list `l₁` and a single-element list `[b]` results in the original list `l₁`.

For any type `α` and list `l₁` of length `n` over `α`, `List.dropLast (Suc n) (l₁ ++ [b]) = l₁` for all `b : α`.


theorem Finset.mem_erase_of_ne_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, a ≠ b → a ∈ s → a ∈ Finset.erase s b := by sorry

This theorem states that for any given type `α` that has decidable equality, for any finite set `s` of type `α`, and for any two elements `a` and `b` of type `α`, if `a` is not equal to `b` and `a` is a member of `s`, then `a` is also a member of the set resulting from erasing `b` from `s`. In other words, if you remove an element `b` from a set `s`, any other element `a` that was in `s` and is not equal to `b` will still be in the resulting set.

If `s` is a finite set of decidably equal type `α` and `a` is an element of `s` different from `b` in `s`, then `a` is still in the set `s \ {b}`.


theorem CategoryTheory.GrothendieckTopology.plusObj.proof_1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
      {D : Type u_3} [inst_1 : CategoryTheory.Category.{max u_2 u_1, u_3} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      (P : CategoryTheory.Functor Cᵒᵖ D)
      [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (CategoryTheory.GrothendieckTopology.diagram J P X.unop) :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.plusObj.proof_1` states that for any category `C` (with a given Grothendieck topology `J`) and category `D`, if for every contravariant functor `P` from `C` to `D`, every object `X` in `C`, and every cover `S` of `X` with respect to the Grothendieck topology `J`, the multicospan indexed by the cover `S` and the functor `P` has a limit (i.e., it has a multiequalizer), and if for every object `X` in `C`, the category `D` has colimits of shape given by the opposite category of the poset of `J`-covers of `X`, then for any contravariant functor `P` from `C` to `D` and any object `X` in the opposite category of `C`, the diagram in `D` given by `J` and `P` for the object `X` unop has a colimit. In simpler terms, this theorem asserts the existence of certain colimits in the category `D` under specific conditions related to the functor `P` and the Grothendieck topology `J`.

Given a category C with a Grothendieck topology J, and a contravariant functor P from C to D, if for every cover S of an object X in C and every P(x), the multicospan has a limit, and D has colimits of shape given by the opposite category of J-covers, then the diagram given by J and P for any object X' in the opposite category of C has a colimit in D.


theorem List.zipWithAll_nil_left :
    ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : Option α → Option α_1 → α_2} {bs : List α_1},
      List.zipWithAll f [] bs = List.map (fun b => f none (some b)) bs :=
  by sorry

The theorem `List.zipWithAll_nil_left` states that for any types `α`, `α_1`, and `α_2`, and any function `f` from `Option α` and `Option α_1` to `α_2`, and any list `bs` of type `List α_1`, when the first list in the `zipWithAll` function is an empty list, the result is equivalent to mapping the function `f` (with the first argument being `none` and the second argument being each element of `bs` wrapped in `some`) over the list `bs`. In other words, it's as if we're pairing each element of `bs` with `none` and then applying the function `f` to these pairs.

For any types `α`, `α_1`, and `α_2`, and any function `f` from `Option α × Option α_1` to `α_2`, `List.zipWithAll f [] bs = List.map (x => some x) bs |>. map (λ x => some x) |>. map (λ x => f (none, x))` where `bs` is a list of type `List α_1`.


/-- `P` is a sheaf for `R` iff it is separated for `R` and there exists an amalgamation.  -/
theorem CategoryTheory.Presieve.isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R : CategoryTheory.Presieve X},
      (CategoryTheory.Presieve.IsSeparatedFor P R ∧
          ∀ (x : CategoryTheory.Presieve.FamilyOfElements P R),
            CategoryTheory.Presieve.FamilyOfElements.Compatible x →
              ∃ t, CategoryTheory.Presieve.FamilyOfElements.IsAmalgamation x t) ↔
        CategoryTheory.Presieve.IsSheafFor P R :=
  by sorry

The theorem `CategoryTheory.Presieve.isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor` states that a presheaf `P` is a sheaf for a presieve `R` if and only if it is separated for `R` and there exists an amalgamation for all families of elements of `P` compatible with `R`. In other words, for a presheaf `P` and a presieve `R`, the presheaf `P` is a sheaf for the presieve `R` if there is at most one amalgamation for each family of elements of `P` (this is the separation condition), and there is at least one amalgamation for each family of elements of `P` that is compatible with `R` (this is the existence condition).

A presheaf is a sheaf for a given presieve if and only if it satisfies the separation condition (at most one amalgamation per family) and the existence condition (there exists an amalgamation for each family compatible with the presieve).


theorem Int.fmod_eq_emod : ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → Int.fmod a b = a % b := by sorry

This theorem states that for all integers `a` and `b`, if `b` is non-negative (i.e., `b` is greater than or equal to zero), then the flooring modulus of `a` and `b` (`Int.fmod a b`) is equal to the standard modulus of `a` and `b` (`a % b`). In other words, when the divisor is non-negative, the result of the flooring division-based modulus operation is the same as the result of the standard modulus operation in Lean.

For all integers `a` and `b` with `b` non-negative, `Int.fmod a b` equals `a % b`.


theorem Unique.default_eq : ∀ {α : Sort u_1} [inst : Unique α] (a : α), default = a := by sorry

This theorem states that for any type `α` (which could be a type or a proposition) and any instance of `α` named 'a', if `α` has a unique instance, then the default instance of `α` is equal to 'a'. In other words, if a type has exactly one instance, then any element of that type is necessarily equal to the default instance.

If type `α` has a unique instance 'a, then `α.default` equals 'a.


FreeGroup.lift.unique

theorem FreeGroup.lift.unique :
    ∀ {α : Type u} {β : Type v} [inst : Group β] {f : α → β} (g : FreeGroup α →* β),
      (∀ (x : α), g (FreeGroup.of x) = f x) → ∀ {x : FreeGroup α}, g x = (FreeGroup.lift f) x :=
  by sorry

The theorem `FreeGroup.lift.unique` states that for all types `α` and `β`, where `β` is a group, and for all functions `f` from `α` to `β`, if we have a group homomorphism `g` from the free group over `α` to `β` such that for every element `x` of type `α`, `g` applied to the canonical injection of `x` into the free group equals `f` of `x`, then `g` applied to any element of the free group over `α` equals the unique group homomorphism from the free group over `α` to `β` that extends `f`. In other words, any group homomorphism from a free group to a group that respects the original function `f` from which the free group was created is necessarily the unique homomorphism that extends `f`.

Given a group `β`, any group homomorphism from the free group over `α` to `β` that agrees with a given function `f : α → β` on the generators of the free group is the unique such homomorphism.


theorem Cardinal.ord_card_le : ∀ (o : Ordinal.{u_3}), Cardinal.ord (Ordinal.card o) ≤ o := by sorry

This theorem states that for any ordinal `o`, the cardinality of the ordinal `o` (which is obtained by mapping the ordinal to a cardinal using `Ordinal.card`) when mapped back to an ordinal using `Cardinal.ord` is always less than or equal to the original ordinal `o`. In other words, the process of going from an ordinal to its cardinality and back again does not increase the size of the ordinal. In mathematical terms, for all ordinals `o`, the operation `Cardinal.ord (Ordinal.card o)` yields a value that is less than or equal to `o`.

For every ordinal `o`, the cardinality of `o` (as a cardinal number) is less than or equal to `o` as an ordinal number.


/-- Two vector spaces are isomorphic if they have the same dimension.  -/
theorem nonempty_linearEquiv_of_lift_rank_eq :
    ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : StrongRankCondition R]
      [inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : Module.Free R M] [inst_5 : AddCommGroup M']
      [inst_6 : Module R M'] [inst_7 : Module.Free R M'],
      Cardinal.lift.{v', v} (Module.rank R M) = Cardinal.lift.{v, v'} (Module.rank R M') → Nonempty (M ≃ₗ[R] M') :=
  by sorry

The theorem `nonempty_linearEquiv_of_lift_rank_eq` states that for any ring `R` and two vector spaces `M` and `M'` over `R`, if the lifted cardinality of the rank (dimension) of `M` is equal to the lifted cardinality of the rank of `M'`, there exists a linear isomorphism between `M` and `M'`. The vector spaces are assumed to be free modules over `R`, which ensures the existence of a basis, and `R` is assumed to satisfy the strong rank condition, which ensures that all free modules have a well-defined rank. In other words, two vector spaces over a ring with the strong rank condition are isomorphic if they have the same dimension.

Given free vector spaces M and M' over a ring R satisfying the strong rank condition, if the lifted ranks of M and M' are equal, then there exists a linear isomorphism from M to M'.


/-- Note this takes an explicit `Fintype ((ZMod n)ˣ)` argument to avoid trouble with instance
diamonds.  -/
theorem ZMod.card_units_eq_totient :
    ∀ (n : ℕ) [inst : NeZero n] [inst : Fintype (ZMod n)ˣ], Fintype.card (ZMod n)ˣ = Nat.totient n := by sorry

This theorem states that for a given natural number `n` which is not zero and a finite group of units of integers modulo `n`, denoted as `(ZMod n)ˣ`, the cardinality (number of elements) of this group of units is equal to the Euler's totient function of `n`. In mathematical terms, it states that the order of the multiplicative group of integers modulo `n` is equal to φ(n), where φ is the Euler's totient function, which effectively counts the number of integers less than `n` that are relatively prime to `n`.

The order of the multiplicative group of units in ZMod n equals the value of the Euler's totient function φ(n) for a non-zero natural number n.


theorem RelIso.ordinal_type_eq :
    ∀ {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
      r ≃r s → Ordinal.type r = Ordinal.type s :=
  by sorry

This theorem asserts that for any two types `α` and `β` with respective relations `r` and `s`, both of which are well-ordered (as denoted by `IsWellOrder α r` and `IsWellOrder β s`), if there is a relation-preserving isomorphism (`≃r`) between `r` and `s`, then the ordinal types of `r` and `s` (given by `Ordinal.type r` and `Ordinal.type s`) are equal. Essentially, it says that isomorphic well-orders yield the same ordinal type.

If two well-ordered types `α` and `β` have isomorphic relations `r` and `s`, then their ordinal types `Ordinal.type r` and `Ordinal.type s` are equal.


theorem Polynomial.sum_add_index :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : AddCommMonoid S] (p q : Polynomial R) (f : ℕ → R → S),
      (∀ (i : ℕ), f i 0 = 0) →
        (∀ (a : ℕ) (b₁ b₂ : R), f a (b₁ + b₂) = f a b₁ + f a b₂) →
          Polynomial.sum (p + q) f = Polynomial.sum p f + Polynomial.sum q f :=
  by sorry

The theorem `Polynomial.sum_add_index` states that for any two polynomials `p` and `q` over a semiring `R`, and any function `f` from pairs of natural numbers and elements of `R` to a type `S` with an additive commutative monoid structure, if `f` maps any pair consisting of a natural number and the zero element of `R` to the zero element of `S`, and `f` distributes over addition in `R` (i.e., for any natural number `a` and elements `b₁`, `b₂` of `R`, `f` of `a` and the sum of `b₁` and `b₂` is equal to the sum of `f` of `a` and `b₁` and `f` of `a` and `b₂`), then the sum of the values of `f` applied to the coefficients of the sum of `p` and `q` is equal to the sum of the sum of the values of `f` applied to the coefficients of `p` and the sum of the values of `f` applied to the coefficients of `q`. In other words, the operation of summing the values of `f` applied to the coefficients of a polynomial is compatible with the addition of polynomials.

Given polynomials `p` and `q` over a semiring `R`, and a function `f` from pairs of natural numbers and elements of `R` to an additive commutative monoid `S` such that `f` maps any pair consisting of a natural number and the zero element of `R` to the zero element of `S` and distributes over addition in `R`, the sum of the values of `f` applied to the coefficients of `p + q` equals the sum of the values of `f` applied to the coefficients of `p` and the coefficients of `q`.


padicNormE.nonarchimedean

theorem padicNormE.nonarchimedean : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p]), ‖q + r‖ ≤ max ‖q‖ ‖r‖ := by sorry

The theorem `padicNormE.nonarchimedean` states that for every natural number `p` that is prime (denoted by `Nat.Prime p`), for every pair of p-adic numbers `q` and `r`, the p-adic norm (denoted by ‖.‖) of the sum of `q` and `r` is less than or equal to the maximum of their individual p-adic norms. In other words, in the p-adic number system, the norm of the sum of two numbers does not exceed the maximum of their individual norms, exhibiting a property of non-Archimedean fields.

For every prime number p in the natural numbers, the p-adic norm of the sum of two p-adic numbers is less than or equal to the maximum of their individual p-adic norms.


theorem Submodule.mkQ_surjective :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (A : Submodule R M),
      Function.Surjective ⇑(Submodule.mkQ A) :=
  by sorry

This theorem states that for any given ring `R`, additive commutative group `M`, and `A` as a submodule of the `R`-module `M`, the function `Submodule.mkQ A` is surjective. In other words, every element in the quotient module `M/A` is the image of some element of `M` under the `mkQ` function associated with the submodule `A`. This function essentially maps each element of `M` to its equivalence class in the quotient set `M/A`.

For any submodule `A` of an additive commutative group `M` over a ring `R`, the `Submodule.mkQ` function maps every element of `M` to some coset in the quotient group `M/A`.


theorem CategoryTheory.Limits.IsImage.lift_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasImage f] {F : CategoryTheory.Limits.MonoFactorisation f}
      (hF : CategoryTheory.Limits.IsImage F),
      CategoryTheory.CategoryStruct.comp (hF.lift (CategoryTheory.Limits.Image.monoFactorisation f))
          (CategoryTheory.Limits.image.ι f) =
        F.m :=
  by sorry

The theorem `CategoryTheory.Limits.IsImage.lift_ι` states that for any category `C` with objects `X` and `Y`, and a morphism `f` from `X` to `Y` that has an image, and for any monomorphism factorization `F` of `f` that satisfies the conditions of being an image, the composition of the lift of the standard monomorphism factorisation of `f` to `F` and the inclusion of the image of `f` into `Y` is equal to the morphism `m` of the monomorphism factorisation `F`.

In more intuitive terms, it's stating a property of the "lift" function in the context of category theory: If you have a morphism and a particular way to factor it through a monomorphism (i.e., a way to "split" it that preserves its properties), then "lifting" this factorisation and then going through the image of the original morphism gets you back to where you started.

For any morphism `f` with image `I` in a category `C`, and any monomorphism factorization `F` of `f`, the diagram commutes: `lift F . inclusion I ∘ image f = F`.


theorem UniformSpace.ball_mem_nhds :
    ∀ {α : Type ua} [inst : UniformSpace α] (x : α) ⦃V : Set (α × α)⦄,
      V ∈ uniformity α → UniformSpace.ball x V ∈ nhds x :=
  by sorry

This theorem states that for any uniform space `α` and any element `x` in `α`, if a set `V` of pairs of elements of `α` belongs to the uniformity of `α`, then the ball centered at `x` with respect to the set `V` belongs to the neighborhood of `x`. In other words, if `V` is a set of pairs describing a certain closeness relationship in the uniform space, then the set of all elements close to `x` according to this relationship is a neighborhood of `x`. This connects the concept of balls in a uniform space, which generalizes the concept of balls in a metric space, to the topological concept of neighborhood. This is a key property that shows the compatibility between the uniform structure and the induced topology in a uniform space.

For any uniform space `α` and `x` in `α`, if `V` is a set of pairs in the uniformity of `α` then the ball `B(x, V)` is a neighborhood of `x`.


theorem Nat.find_eq_iff :
    ∀ {m : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), Nat.find h = m ↔ p m ∧ ∀ n < m, ¬p n := by sorry

The theorem `Nat.find_eq_iff` in Lean 4 expresses a property of the `Nat.find` function in terms of logical equivalence. It states that for any natural number `m` and any decidable predicate `p` on natural numbers, and given that there exists a natural number `n` such that `p(n)` holds, then `Nat.find h` is equal to `m` if and only if `p(m)` is true and for all natural numbers `n` less than `m`, `p(n)` is not true. In essence, this theorem characterizes the least natural number satisfying a given decidable predicate.

For any natural number `m` and decidable predicate `p` on natural numbers, `Nat.find h = m` if and only if `p(m)` holds and `p(n)` fails for all `n` strictly less than `m`.


ContinuousAt.neg

theorem ContinuousAt.neg :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Neg G] [inst_2 : ContinuousNeg G]
      [inst_3 : TopologicalSpace α] {f : α → G} {x : α}, ContinuousAt f x → ContinuousAt (fun x => -f x) x :=
  by sorry

The theorem `ContinuousAt.neg` states that for any topological spaces `G` and `α`, a function `f` from `α` to `G`, and a point `x` in `α`, if the function `f` is continuous at the point `x`, then the function that sends `x` to the negation of `f(x)` is also continuous at `x`. Here, `Neg G` denotes that the type `G` has a negation operation, and `ContinuousNeg G` asserts that this negation operation is continuous.

If `f : α → G` is continuous at `x ∈ α` in a topological space `(α,τα)` with negation `Neg G`, then the function `x mapsto -f(x)` is continuous at `x`.


Continuous.inf

theorem Continuous.inf :
    ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] [inst_2 : Inf L]
      [inst_3 : ContinuousInf L] {f g : X → L}, Continuous f → Continuous g → Continuous fun x => f x ⊓ g x :=
  by sorry

This theorem states that for any types `L` and `X`, where `L` is a topological space with an infimum operation and `X` is another topological space, if we have two continuous functions `f` and `g` from `X` to `L`, then the function that maps each point in `X` to the infimum of the images of that point under `f` and `g` is also a continuous function. This theorem captures the property that the infimum operation is continuous in topological spaces.

Given topological spaces `L` with an infimum operation and `X`, if `f` and `g` are continuous functions from `X` to `L`, then the function mapping each point in `X` to the infimum of `f(x)` and `g(x)` is also continuous.


theorem Finsupp.indicator_of_mem :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] {s : Finset ι} {i : ι} (hi : i ∈ s) (f : (i : ι) → i ∈ s → α),
      (Finsupp.indicator s f) i = f i hi :=
  by sorry

The theorem `Finsupp.indicator_of_mem` states that for any types `ι` and `α` where `α` has a zero element, any finite set `s` of type `ι`, any element `i` of type `ι` that is in `s`, and any function `f` from elements of `s` to `α`, then applying the function `Finsupp.indicator s f` to `i` yields the same result as applying `f` to `i` with membership proof `hi`. The function `Finsupp.indicator` is defined to create an element in the function space `ι →₀ α` from a finite set `s` and a function `f` defined on `s`, such that the application of this function to any `i` outside `s` is zero.

For any finite set `s`, function `f` on `s`, and `i` in `s`, `Finsupp.indicator s f i = f i` holds in Lean 4, given `i` is a member of `s` with proof `hi`.


Monotone.inter

theorem Monotone.inter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : β → Set α},
      Monotone f → Monotone g → Monotone fun x => f x ∩ g x :=
  by sorry

The theorem `Monotone.inter` states that for any types `α` and `β`, and any preorder on `β`, if `f` and `g` are two functions from `β` to the set of `α`, and both `f` and `g` are monotone functions, then the function that maps each element `x` of `β` to the intersection of the sets `f(x)` and `g(x)` is also a monotone function. In simpler terms, if two functions are increasing, then the function that uses these two to create intersections of sets at each point is also increasing.

If `f` and `g` are monotonic functions from a preorder `β` to type `α`, then the function `x ∈β => f x ∩ g x` is also monotonic.


theorem TypeVec.append1_drop_last : ∀ {n : ℕ} (α : TypeVec.{u_1} (n + 1)), TypeVec.drop α ::: TypeVec.last α = α := by
  sorry

This theorem, `TypeVec.append1_drop_last`, states that for any natural number `n` and any `n+1`-length type vector `α`, if we drop the last element of `α` to obtain a new vector, and then append the last element of `α` back to this vector, we get back the original vector `α`. In essence, it captures the property that dropping and then appending the last element of a vector does not change the original vector. This is analogous to the concept in list theory where if you take a list, remove the last element, and then append it back, you get the original list.

For any type vector `α` of length `n+1`, appending the last element of `α` to the subvector obtained by dropping the last element results in the original vector `α`.


FilterBasis.generate

theorem FilterBasis.generate : ∀ {α : Type u_1} (B : FilterBasis α), Filter.generate B.sets = FilterBasis.filter B := by
  sorry

This theorem states that for any given filter basis `B` of a type `α`, the filter generated by the sets of `B` (`Filter.generate B.sets`) is equivalent to the filter associated with the filter basis `B` (`FilterBasis.filter B`). In other words, generating a filter from the sets of a filter basis gives you the same result as directly associating a filter with the filter basis.

For any filter basis `B` of type `α`, `Filter.generate B.sets` is equivalent to `FilterBasis.filter B`.


theorem Set.card_le_card :
    ∀ {α : Type u} {s t : Set α} [inst : Fintype ↑s] [inst_1 : Fintype ↑t], s ⊆ t → Fintype.card ↑s ≤ Fintype.card ↑t :=
  by sorry

The theorem `Set.card_le_card` states that for any two sets `s` and `t` of an arbitrary type `α`, if set `s` is a subset of set `t` and both sets are finite (`Fintype`), then the cardinality (number of elements) of set `s` is less than or equal to the cardinality of set `t`. In other words, a subset cannot have more elements than its superset when both sets are finite.

For any finite sets `s` and `t` of type `α` with `s ⊆ t`, we have `#s ≤ #t`. (Here, `#s` denotes the cardinality of set `s`.)


theorem Finset.comp_sup'_eq_sup'_comp :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup γ] {s : Finset β}
      (H : s.Nonempty) {f : β → α} (g : α → γ),
      (∀ (x y : α), g (x ⊔ y) = g x ⊔ g y) → g (Finset.sup' s H f) = Finset.sup' s H (g ∘ f) :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` where `α` and `γ` are equipped with a (possibly unbounded) join-semilattice structure, and for any nonempty finite set `s` of type `β`, a function `f` from `β` to `α`, and a function `g` from `α` to `γ`, if the function `g` preserves the join operation (i.e., `g` applied to the join of `x` and `y` equals the join of `g` applied to `x` and `g` applied to `y`), then applying `g` to the supremum of the image of `s` under `f` (denoted `Finset.sup' s H f`) is the same as first applying `g` to the elements of `s` and then taking the supremum of the resulting set (denoted `Finset.sup' s H (g ∘ f)`). In mathematical terms, it says that the supremum operation `sup'` commutes with a join-preserving function `g`.

If `α` and `γ` are join-semilattices, `s` is a nonempty finite set of type `β`, `f : β → α`, `g : α → γ` is join-preserving, then `g (Finset.sup' s H f) = Finset.sup' s H (g ∘ f)`.


theorem WeierstrassCurve.map_baseChange :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {S : Type s} [inst_1 : CommRing S]
      [inst_2 : Algebra R S] {A : Type v} [inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
      [inst_6 : IsScalarTower R S A] {B : Type w} [inst_7 : CommRing B] [inst_8 : Algebra R B] [inst_9 : Algebra S B]
      [inst_10 : IsScalarTower R S B] (ψ : A →ₐ[S] B), (W.baseChange A).map ↑ψ = W.baseChange B :=
  by sorry

This theorem, known as `WeierstrassCurve.map_baseChange`, states that for any commutative rings `R`, `S`, `A`, and `B` such that `R` is an algebra over `S`, `A` is an algebra over `R`, and `B` is an algebra over `R` and `S` with `A` and `B` forming scalar towers with `R` and `S`, and for any Weierstrass curve `W` defined over `R`, and any algebra homomorphism `ψ` from `A` to `B` preserving the scalar multiplication by `S`, the base change of `W` to `A` followed by mapping via `ψ` is equal to the base change of `W` to `B`. In simpler terms, changing the base ring of the Weierstrass curve and then applying a map is the same as applying the map after changing the base ring.

For any commutative rings R, S, A, B with R an algebra over S, A an algebra over R, B an algebra over R and S with A and B being scalar towers, and for any Weierstrass curve W over R and algebra homomorphism ψ from A to B preserving scalar multiplication by S, the base change of W from R to A then mapped via ψ equals the base change of W from R to B.


MeasureTheory.OuterMeasure.iUnion

theorem MeasureTheory.OuterMeasure.iUnion :
    ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {β : Type u_5} [inst : Countable β] (s : β → Set α),
      ↑m (⋃ i, s i) ≤ ∑' (i : β), ↑m (s i) :=
  by sorry

This theorem states that for any outer measure `m` on a type `α` and for any countable set `β`, the outer measure of the union of a collection of sets `s : β → Set α` (that is, a collection of sets indexed by `β`) is less than or equal to the sum of the outer measures of the individual sets in that collection. This theorem encapsulates a property of outer measures that allows us to approximate them by summing over smaller sets, which plays an important role in measure theory.

For any outer measure `m` on a type `α` and countable collection `s : β → Set α` of sets, `m(⋃ i in β, s i) ≤ ∑ i in β, m(s i)`.


theorem MeasureTheory.neg_absolutelyContinuous :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableNeg G]
      [inst_5 : MeasureTheory.Measure.IsAddLeftInvariant μ],
      MeasureTheory.Measure.AbsolutelyContinuous (MeasureTheory.Measure.neg μ) μ :=
  by sorry

This theorem states that for any type `G` which is a `MeasurableSpace`, an `AddGroup`, and has a `MeasurableNeg`, and any measure `μ` on `G` that is `SigmaFinite` and `IsAddLeftInvariant`, the measure `A ↦ μ (- A)`, where `- A` is the pointwise negation of `A`, is absolutely continuous with respect to the measure `μ`. In mathematical terms, this means that if `μ(A) = 0`, then `μ(-A) = 0` as well.

For any measurable space and add group `G` with measurable negation, and Sigma-finite, additively invariant measure `μ`, the measure `μ` of the negation of any measurable set `A` is zero whenever `μ(A)` is zero.


theorem MeasureTheory.aecover_Iic :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : Preorder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {b : ι → α},
      Filter.Tendsto b l Filter.atTop → MeasureTheory.AECover μ l fun i => Set.Iic (b i) :=
  by sorry

The theorem `MeasureTheory.aecover_Iic` states that for any type `α` that is a measurable space, preordered, a topological space, and has an order-closed topology and is an open measurable space, and any function `b` from some type `ι` to `α`, if `b` tends to infinity with respect to some filter `l` on `ι`, then the sequence of left-infinite right-closed intervals `Set.Iic (b i)` almost everywhere covers the measure space `μ` with respect to the filter `l`. Here "almost everywhere" means except on a subset of measure zero.
In LaTeX terms, if $b : ι \rightarrow α$ and $b \rightarrow ∞$ when $i$ approaches some limit point with respect to the filter $l$, then $\{x | x ≤ b(i)\}$ almost everywhere covers $\mu$ as $i$ varies over the filter $l$.

If `α` is a measurable space, preordered, a topological space with order-closed topology, and an open measurable space, and `b : ι -> α` tends to infinity with respect to a filter `l` on `ι`, then the sequence of left-infinite right-closed intervals `Set.Iic (b i)` almost everywhere covers `μ` as `i` varies over the filter `l`.


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

The theorem `IsComplete.completeSpace_coe` states that for any type `α` equipped with a uniform space structure and any set `s` of `α`, if `s` is complete (that is, every Cauchy filter `f` for which `s` belongs to `f` has a limit in `s`), then the type-cast of `s` to a uniform space is a complete space. In other words, if a set in a given uniform space is complete, then when viewed as its own uniform space, the set is a complete space.

If a set in a uniform space is complete, then it is a complete uniform space.


theorem ContinuousOn.integrableOn_compact :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X} [inst_3 : OpensMeasurableSpace X]
      {K : Set X} [inst_4 : MeasureTheory.IsFiniteMeasureOnCompacts μ] [inst_5 : T2Space X],
      IsCompact K → ContinuousOn f K → MeasureTheory.IntegrableOn f K μ :=
  by sorry

This theorem states that for any set `K` of a certain type `X` and a function `f` from `X` to `E` (where `E` is a type with a normed add commutative group structure), if `K` is compact and `f` is continuous on `K`, then `f` is integrable on `K` with respect to measure `μ`. This is under several conditions: `X` has both a measurable space and a topological space structure, `E` is a normed add commutative group, the measure `μ` is finite on compact sets, and `X` satisfies the T2 separation axiom (also known as being a Hausdorff space).

If `K` is a compact subset of a measurable and Hausdorff space `X` with a topology inducing the given one, and `f` is a continuous function from `X` to a normed add commutative group `E` with finite μ-measure of compact sets, then `f` is integrable with respect to measure `μ` on `K`.


theorem MeasureTheory.SimpleFunc.coe_mul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Mul β] (f g : MeasureTheory.SimpleFunc α β),
      ↑(f * g) = ↑f * ↑g :=
  by sorry

This theorem states that for any two simple functions `f` and `g` from a measurable space `α` to a type `β` equipped with a multiplication operation, the result of multiplying the two simple functions (`f * g`) and then converting to a non-simple function (using the coercion function `↑`) is the same as first converting each of the simple functions to non-simple functions and then multiplying these non-simple functions (`↑f * ↑g`).

For any measurable spaces `α` and type `β` with multiplication, the conversion of the product of two simple functions `f` and `g` from `α` to `β` to a non-simple function is equal to the product of the non-simple functions obtained from the conversion of `f` and `g`. In Lean 4 symbolism: `(↑(f * g) = ↑f * ↑g)`.


theorem Finset.card_disjUnion :
    ∀ {α : Type u_1} (s t : Finset α) (h : Disjoint s t), (Finset.disjUnion s t h).card = s.card + t.card := by sorry

The theorem `Finset.card_disjUnion` states that for any two finite sets `s` and `t` of any type `α`, which are disjoint (meaning that their greatest lower bound is the least element, or the intersection is empty), the cardinality of the disjoint union of `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. In other words, the total number of unique elements in the disjoint union of two sets is the sum of the number of unique elements in each set, when the sets do not share any common elements.

For disjoint finite sets `s` and `t`, the cardinality of their disjoint union equals the sum of their cardinalities.


theorem RingHom.map_list_prod :
    ∀ {β : Type u_4} {γ : Type u_5} [inst : Semiring β] [inst_1 : Semiring γ] (f : β →+* γ) (l : List β),
      f (List.prod l) = List.prod (List.map (⇑f) l) :=
  by sorry

The theorem `RingHom.map_list_prod` states that for any semirings `β` and `γ`, given a ring homomorphism `f` from `β` to `γ`, and a list `l` of elements from `β`, the homomorphism of the product of the list elements (i.e., `f (List.prod l)`) is equal to the product of the list obtained by mapping each element of the original list via the homomorphism (i.e., `List.prod (List.map (⇑f) l)`). Essentially, this means the operation of a ring homomorphism and the product operation on a list commute with each other.

For any semirings β and γ and ring homomorphism f from β to γ, the image of the product of a list of elements from β under f is equal to the product of the images of the list elements under f.


theorem iff_congr : ∀ {p₁ p₂ q₁ q₂ : Prop}, (p₁ ↔ p₂) → (q₁ ↔ q₂) → ((p₁ ↔ q₁) ↔ (p₂ ↔ q₂)) := by sorry

This theorem, `iff_congr`, states that for any four propositions: `p₁`, `p₂`, `q₁`, `q₂`, if `p₁` is logically equivalent to `p₂`, and `q₁` is logically equivalent to `q₂`, then the logical equivalence between `p₁` and `q₁` is also logically equivalent to the logical equivalence between `p₂` and `q₂`. In mathematical terms, if \( p₁ ⇔ p₂ \) and \( q₁ ⇔ q₂ \), then \( (p₁ ⇔ q₁) ⇔ (p₂ ⇔ q₂) \).

If `p₁ ⇔ p₂` and `q₁ ⇔ q₂`, then `(p₁ ⇔ q₁) ⇔ (p₂ ⇔ q₂)`. In other words, the logical equivalence relation is transitive on propositions.


theorem Subgroup.index_comap :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {G' : Type u_2} [inst_1 : Group G'] (f : G' →* G),
      Subgroup.index (Subgroup.comap f H) = Subgroup.relindex H (MonoidHom.range f) :=
  by sorry

The theorem `Subgroup.index_comap` states that for any Group `G`, `G'` and a subgroup `H` of `G`, as well as a monoid homomorphism `f` from `G'` to `G`, the index (as a natural number) of the preimage of `H` along `f` (found using `Subgroup.comap`) is equal to the relative index of `H` with respect to the range of `f` (found using `Subgroup.relindex` and `MonoidHom.range`). In other words, it provides a relationship between the index of the preimage of a subgroup under a monoid homomorphism and the relative index of the subgroup and the range of the homomorphism.

The index of the preimage of a subgroup under a monoid homomorphism is equal to the relative index of the subgroup with respect to the range of the homomorphism.


theorem Equiv.Perm.sign_refl :
    ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α], Equiv.Perm.sign (Equiv.refl α) = 1 := by sorry

The theorem `Equiv.Perm.sign_refl` states that for any type `α`, which has decidable equality and is finite, the sign of the identity permutation (represented by `Equiv.refl α`) is `1`. In other words, the identity permutation is considered as an even permutation as its signature (or parity) is `1`.

For any finite type `α` with decidable equality, the identity permutation on `α` has even signature (equivalently, its determinant is 1).


theorem Finset.sup_map :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (s : Finset γ)
      (f : γ ↪ β) (g : β → α), Finset.sup (Finset.map f s) g = Finset.sup s (g ∘ ⇑f) :=
  by sorry

The theorem `Finset.sup_map` asserts that for any types `α`, `β`, `γ`, given a semilattice structure and smallest element (OrderBot) on `α`, for any finite set `s` of type `γ`, an injective function `f` from `γ` to `β`, and a function `g` from `β` to `α`, the supremum of the image of `s` under `f` mapped through `g` is equal to the supremum of `s` mapped through the composition of `g` and `f`. In other words, it is the property of "commutativity" of the supremum over a finite set with respect to function composition and mapping a finite set under an injective function.

For any semilattice `α` with smallest element, injective function `f` from a finite set `s` of type `γ` to `β`, and functions `g : β -> α` and `h : α -> α` with `h = g ∘ f`, the supremum of `s` mapped through `h` is equal to the supremum of `s` mapped through `g` and then `f`.


theorem Int.mul_eq_zero : ∀ {a b : ℤ}, a * b = 0 ↔ a = 0 ∨ b = 0 := by sorry

This theorem states that for any two integers `a` and `b`, the product `a * b` is equal to zero if and only if either `a` is zero or `b` is zero. This is a fundamental property of number systems, reflecting the fact that zero multiplied by any number results in zero.

For any integers `a` and `b`, `a * b = 0` if and only if `a = 0` or `b = 0`.


theorem Topology.IsLower.topology_eq :
    ∀ (α : Type u_1) [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsLower α],
      inst_1 = Topology.lower α :=
  by sorry

This theorem states that for any type `α` that has a preorder relation and is equipped with both a topological space structure and a lower topology, the topological space structure is equivalent to the lower topology on `α`. In other words, given the type `α` and the specific structures, we can consider its existing topology as the lower topology, which is the topology generated by the complements of the left-closed right-infinite intervals.

For any type `α` with a preorder relation and equipped with both a topology and its generated lower topology, the two topologies are equivalent.


theorem interior_compl : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], interior sᶜ = (closure s)ᶜ := by sorry

This theorem states that for any set `s` in a given topological space `X`, the interior of the complement of `s` is equal to the complement of the closure of `s`. In other words, it says that taking the interior of the complement of a set is the same as taking the complement of the closure of the original set. This theorem is an important characteristic of the relationship between the interior, closure, and complement operations in topology.

The interior of a set's complement is equal to the complement of its closure.


IsOpen.vadd

theorem IsOpen.vadd :
    ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : AddGroup G] [inst_2 : AddAction G α]
      [inst_3 : ContinuousConstVAdd G α] {s : Set α}, IsOpen s → ∀ (c : G), IsOpen (c +ᵥ s) :=
  by sorry

The `IsOpen.vadd` theorem states that for any set `s` in a topological space `α`, if `s` is open, then the set resulting from adding a constant value `c` from an additive group `G` to each element in the set `s` is also open. This requires `α` to be a topological space, `G` to be an additive group, an additive action of `G` on `α`, and the constant vector addition to be continuous. This theorem, therefore, establishes the preservation of openness under constant vector addition in this context.

If `α` is a topological space, `s` is an open subset of `α`, `G` is an additive group, `α` has an additive action by `G`, and the constant vector addition is continuous, then the set `{x + c | x ∈ s}` is open in `α`.


/-- The norm of a bounded continuous function is the supremum of `‖f x‖`.
We use `sInf` to ensure that the definition works if `α` has no elements.  -/
theorem BoundedContinuousFunction.norm_eq :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
      (f : BoundedContinuousFunction α β), ‖f‖ = sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} :=
  by sorry

This theorem states that the norm of a bounded continuous function is equal to the supremum of the norms of its values. Specifically, for a function `f` from a topological space `α` to a seminormed additive commutative group `β`, the norm of `f` is the least upper bound (`sInf` or supremum) of the set containing all `C` such that `C` is non-negative and the norm of `f(x)` for any `x` in `α` is less than or equal to `C`. The use of `sInf` ensures that the definition works even if `α` has no elements.

The norm of a bounded continuous function from a topological space to a seminormed additive commutative group equals the supremum of the norms of its values.


theorem Finset.inf_image₂_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
      (t : Finset β) [inst_1 : SemilatticeInf δ] [inst_2 : OrderTop δ] (g : γ → δ),
      Finset.inf (Finset.image₂ f s t) g = Finset.inf s fun x => Finset.inf t (g ∘ f x) :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of types `α` and `β`, respectively, and a binary function `f : α → β → γ`, the infimum of the image of the function `f` over the Cartesian product of `s` and `t`, when transformed by another function `g : γ → δ`, is equal to the infimum of the set `s` transformed by the function which maps each element `x` of `s` to the infimum of the set `t` transformed by the composition of `g` and `f` evaluated at `x`. This holds in the context where `γ` has a decidable equality, and `δ` is a type forming a semilattice with a top element.

Given finite sets `s` and `t` of types `α` and `β`, and a binary function `f : α → β → γ` with `γ` being a decidably equated semilattice with top element, the infimum of `g ∘ f(s × t)` equals the infimum of `map (inf inf t) s`.


theorem IsLprojection.coe_sup :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X]
      [inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), ↑(P ⊔ Q) = ↑P + ↑Q - ↑P * ↑Q :=
  by sorry

This theorem states that for any normed commutative add group `X` and any ring `M` that is also a module over `X`, given the condition that scalar multiplication by `M` on `X` is faithful, for any two elements `P` and `Q` of the set of `P` such that `P` is a left-projection on `X`, the supremum of `P` and `Q` is equal to `P` plus `Q` minus the product of `P` and `Q`.

Given a normed commutative add group `X` and an associative ring `M` making `X` a left `M`-module with faithful scalar multiplication, for any left-projection `P` in `X`, we have $P + Q - PQ = \sup(P, Q)$.


IsTotal.swap

theorem IsTotal.swap : ∀ {α : Type u} (r : α → α → Prop) [inst : IsTotal α r], IsTotal α (Function.swap r) := by sorry

The theorem `IsTotal.swap` states that for any type `α` and a relation `r` on `α` which is total, the swapped version of relation `r` is also total. Here, a relation is total if for any two elements `a` and `b` in `α`, either `r a b` or `r b a` holds. The swap operation on a relation is defined as the relation with its arguments switched, i.e., `r a b` becomes `r b a`.

If `r` is a total relation on type `α`, then the swapped relation `r.symm` is also total.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.24 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) := by sorry

This theorem, from the Mathlib Linear Algebra library in Lean, states that for any types `α` and `β`, and any property `p` that applies to pairs of values (one from `α`, one from `β`), the assertion that `p` holds for all pairs is equivalent to the assertion that for every individual value `a` from type `α` and `b` from type `β`, `p` holds for the pair `(a, b)`. In other words, we can express a universal claim about all pairs either by quantifying over all pairs directly or by separately quantifying over all elements of the two types that make up the pairs.

For any types `α` and `β` and property `p` on pairs `(α × β)`, the following are equivalent: `∀ (a : α) (b : β), p a b` and `∀ (a : α) (b : β), p (a, b)`.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.25 : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by sorry

This theorem, `Mathlib.LinearAlgebra.Prod._auxLemma.25`, states that for any proposition `b` and for any type `α` that is nonempty (meaning there exists at least one element of this type), the function type `(α → b)` is equivalent to `b`. That means, the truth value of `b` does not depend on the specific element of `α` we choose, i.e., every function from `α` to `b` yields the same result for all elements of `α`.

For any nonempty type `α` and proposition `b`, the type of functions from `α` to `b` is equivalent to `b`.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.26 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) := by sorry

This theorem from the `Mathlib.LinearAlgebra.Prod` module, named `_auxLemma.26`, states that for any types `α` and `β`, and a property `p` that takes a pair from `α` and `β`, the existence of a pair `(a, b)` such that the property `p` holds is equivalent to the existence of an element `x` such that the property holds when `x` is considered as a pair. In other words, it establishes the equivalence of the two existential quantifications when the elements are pairs, making it easier to reason about properties that involve pairs of elements from arbitrary types.

For any types `α` and `β` and property `p` on pairs from `α × β`, the existence of `(a, b)` such that `p(a, b)` holds is equivalent to the existence of `x` such that `p(x)` holds when `x` is considered as a pair.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.23 :
    ∀ {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop},
      (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q { val := a, property := b } :=
  by sorry

This theorem states that for any type `α` and predicates `p` and `q` such that `q` applies to elements of type `α` satisfying `p`, the statement "for all elements `x` of type `α` satisfying `p`, `q` holds" is equivalent to the statement "for all elements `a` of type `α` and `b` such that `p` holds for `a`, `q` holds for the subtype `{ val := a, property := b }`." Essentially, it's a formalization of substituting `x` with `{ val := a, property := b }` within the context of universal quantifiers and subtype definitions.

For any type `α`, predicates `p` and `q`, if `q` holds for all elements `x` of type `α` satisfying `p`, then `q` holds for all elements of the subtype `{a : α | p a}`.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.18 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, from the Mathlib Linear Algebra Product Auxiliary Lemma 18, states that for any set of elements (`α`), and for any two elements (`a` and `b`) from that set, the statement that `a` equals `b` is equivalent to the statement that `b` equals `a`. In other words, it asserts the symmetry of equality in any set: if `a` is equal to `b`, then `b` is also equal to `a`.

For all sets `α` and all `a, b` in `α`, `a = b` if and only if `b = a`.


theorem fourier_coe_apply :
    ∀ {T : ℝ} {n : ℤ} {x : ℝ}, (fourier n) ↑x = Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑x / ↑T) := by sorry

This theorem states that for any real number `T` and integer `n`, and any real number `x`, the Fourier series function at `n` evaluated at `x` equals the complex exponential function where the exponent is `2 * pi * i * n * x / T`. Here, `pi` is the mathematical constant Pi, `i` denotes the imaginary unit in complex numbers, and the exponential function is defined through its Taylor series. The division and multiplication operations in the exponent are done in real numbers space, and then the result is coerced to a complex number.

 The Fourier series coefficient of order `n` for a real-valued function `f` defined on the interval `[0, T]` is equal to `(1 / (T * sqrt(2 * pi)) * ( integrate (f (x) * cos (pi * n * x / T) dw x) from 0 to T) + I * ( integrate (f (x) * sin (pi * n * x / T) dw x) from 0 to T)`, where `I` is the imaginary unit, and the integrals are evaluated as complex numbers using the Cauchy principal value.

This statement is equivalent to the one you provided, but it's more common to express Fourier series coefficients in this form rather than in terms of complex exponentials.

If you want to express the theorem in terms of complex exponentials, then the statement would be:

The value of the Fourier series of a real-valued function `f` defined on the interval `[0, T]` at a point `x` is equal to `(1 / T) * sum (from i in nat, i >= 0) ( (coeff (i) * cos (2 * pi * i * x / T) + coeff'(i) * sin (2 * pi * i * x / T) )`, where `coeff(i)` and `coeff'(i)` are the Fourier coefficients of `f` and its first derivative, respectively.

The complex exponential form of the Fourier series can be derived from the trigonometric form using Euler's formula, which states that `cos(theta) = Re(exp(I * theta))` and `sin(theta) = Im(exp(I * theta))`, where `Re` and `Im` denote the real and imaginary parts of a complex number, and `I` is the imaginary unit.


theorem Set.disjoint_of_subset_right : ∀ {α : Type u} {s t u : Set α}, t ⊆ u → Disjoint s u → Disjoint s t := by sorry

This theorem states that for any type `α` and any sets `s`, `t`, and `u` of type `α`, if set `t` is a subset of set `u` and `s` and `u` are disjoint, then `s` and `t` are also disjoint. In other words, if all elements of `t` are also in `u`, and there's no element that is both in `s` and `u`, then there can't be an element that is in both `s` and `t`. This is a statement about the relationship between set inclusion and disjointness in a lattice structure.

If sets `s` and `t` are disjoint and `t` is a subset of `u`, then `s` and `u` being disjoint implies `s` and `t` are disjoint.


theorem CategoryTheory.ShortComplex.exact_iff_isZero_homology :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Limits.IsZero (CategoryTheory.ShortComplex.homology S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.exact_iff_isZero_homology` states that for any category `C` with zero morphisms and a given `ShortComplex` `S` on `C` with a defined homology, the `ShortComplex` `S` is exact if and only if the homology of `S` is zero. In categorical terms, this means that the sequence of morphisms in the `ShortComplex` is exact precisely when the homology group, calculated from the given sequence, is the zero object in the category.

A ShortComplex in a category with zero morphisms is exact if and only if its homology is the zero object.


theorem Int.lt_of_lt_of_le : ∀ {a b c : ℤ}, a < b → b ≤ c → a < c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than `b` and `b` is less than or equal to `c`, then `a` is less than `c`. It's essentially a statement of the transitivity of the less-than relation under certain constraints.

If `a` < `b` and `b` <= `c`, then `a` < `c`. (Transitivity of the less-than relation under constraints `a` < `b` and `b` <= `c`)


theorem MeasureTheory.SimpleFunc.coe_one :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : One β], ↑1 = 1 := by sorry

This theorem states that for any types `α` and `β`, where `α` is a measurable space and `β` has a defined "one" operation, the coercion of the numeric value one (1) is still one (1). Essentially, this means that the number one (1) maintains its identity under coercion in this context.

For any measurable spaces `α` and type `β` with a defined "one" operation, the coercion of the numeric value 1 from the real numbers to `β` is equal to the "one" element of `β`.


theorem Mathlib.Data.Multiset.Nodup._auxLemma.3 :
    ∀ {α : Type u_1} {a : α} {s : Multiset α}, Multiset.Nodup (a ::ₘ s) = (a ∉ s ∧ Multiset.Nodup s) := by sorry

This theorem states that, for all types `α`, elements `a` of type `α`, and multisets `s` of type `α`, the multiset `s` has no duplicates (represented by `Multiset.Nodup`) when `a` is added to `s` (expressed as `a ::ₘ s`) if and only if `a` is not already an element in `s` (denoted by `a ∉ s`) and `s` itself has no duplicates.

For all types `α` and multisets `s` of type `α`, the multiset `s` has no duplicates after adding an element `a` not in `s` (`a ::ₘ s`) if and only if `s` initially had no duplicates (`Multiset.Nodup s`).


theorem Mathlib.Data.Multiset.Nodup._auxLemma.4 : ∀ {α : Type u_1} (a : α), Multiset.Nodup {a} = True := by sorry

This theorem states that for any type `α` and an element `a` of that type, a multiset containing just the element `a` has no duplicates. In other words, a single-element multiset is always considered to have no duplicates, regardless of the type or value of the element.

For any type `α` and element `a` of type `α`, the multiset {`a`} has no duplicates.


theorem Subgroup.le_comap_map :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (H : Subgroup G),
      H ≤ Subgroup.comap f (Subgroup.map f H) :=
  by sorry

The theorem `Subgroup.le_comap_map` states that for any group homomorphism `f` from a group `G` to a group `N` and for any subgroup `H` of `G`, the subgroup `H` is a subset (or is less than or equal to) the preimage under `f` of the image of `H` under `f`. In other words, if we first map the subgroup `H` under the homomorphism `f` and then take the preimage of this set again under `f`, we end up with a set that is at least as large as `H`.

For any group homomorphism `f` and subgroup `H` of a group `G`, `f''(H)` (the image of `H` under `f` and then the preimage of that set under `f` again) is a subgroup of `H`. (Or, more succinctly, `f''(H) ≤ H`.)


/-- If one splits a list along a composition, and then joins the sublists, one gets back the
original list.  -/
theorem List.join_splitWrtComposition :
    ∀ {α : Type u_1} (l : List α) (c : Composition (List.length l)), List.join (List.splitWrtComposition l c) = l := by
  sorry

This theorem states that for any given list `l` of a certain type `α` and any composition `c` of the length of `list`, if you first split the list `l` according to the composition `c` and then join the resulting sublists, you will get back the original list `l`. In other words, splitting the list into sublists according to a certain pattern (`composition`), and then concatenating those sublists will not change the original list.

For any list `l` of type `α` and composition `c` of length matching `l.length`, the list obtained by splitting `l` according to `c` and then joining the resulting sublists is equal to the original list `l`.


theorem Mathlib.SetTheory.Cardinal.ToNat._auxLemma.1 :
    ∀ {c : Cardinal.{u}}, (Cardinal.toNat c = 0) = (c = 0 ∨ Cardinal.aleph0 ≤ c) := by sorry

This theorem states that for any cardinal number `c`, the function `Cardinal.toNat` mapping `c` to a natural number results in zero if and only if `c` is zero or `c` is greater than or equal to `ℵ₀`, the smallest infinite cardinal. In other words, `Cardinal.toNat` returns zero for finite cardinals that are zero and for all infinite cardinals.

The theorem asserts that `Cardinal.toNat` maps every finite cardinal number, including zero, and every infinite cardinal number, specifically `ℵ₀`, to zero.


theorem isCoprime_one_left : ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime 1 x := by sorry

This theorem states that for any commutative semiring `R` and any element `x` of `R`, the number `1` and `x` are coprime. In the context of number theory, two numbers are said to be coprime if their greatest common divisor is `1`. This theorem formulates this concept in terms of the existence of coefficients `a` and `b` such that `a * 1 + b * x = 1`, which is always possible because `1` is the multiplicative identity in a semiring and thus, has no common divisors with any other element.

For any commutative semiring `R` and its elements `1` and `x`, there exist coefficients `a, b ∈ R` such that `a * 1 + b * x = 1`.


theorem continuous_pi_iff :
    ∀ {X : Type u} {ι : Type u_5} {π : ι → Type u_6} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (π i)]
      {f : X → (i : ι) → π i}, Continuous f ↔ ∀ (i : ι), Continuous fun a => f a i :=
  by sorry

The theorem `continuous_pi_iff` states that for all types `X` and `ι`, and a type-dependent function `π : ι → Type`, given `X` and each `π i` have a topological space structure, a function `f` from `X` to each `π i` is continuous if and only if for each `i : ι`, the function `fun a => f a i` is continuous. Here, `fun a => f a i` is a function taking an element from `X` and returning an element from the type `π i`. This theorem provides a characterization of the continuity of functions into product spaces in terms of the continuity of their coordinate functions.

A function from a topological space to a product of types, each with its own topological space structure, is continuous if and only if the function's projection to each factor space is continuous.


ContinuousAt.sub

theorem ContinuousAt.sub :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G]
      [inst_3 : TopologicalSpace α] {f g : α → G} {x : α},
      ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun x => f x - g x) x :=
  by sorry

The theorem `ContinuousAt.sub` states that for any two functions `f` and `g` from a type `α` to a type `G`, where `G` is a topological space with a subtraction operation and a continuous subtraction operation, and `α` is also a topological space, if both `f` and `g` are continuous at a point `x` in `α`, then the function that sends `x` to the difference `f(x) - g(x)` is also continuous at `x`. This is essentially stating that the operation of subtraction preserves continuity.

If `f` and `g` are continuous functions from a topological space `α` to a topological space `G` with a continuous subtraction operation, then their pointwise difference `x ↦ f(x) - g(x)` is also continuous at every point `x` in `α`.


theorem CategoryTheory.GrothendieckTopology.covering_of_eq_top :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X}
      (J : CategoryTheory.GrothendieckTopology C), S = ⊤ → S ∈ J.sieves X :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.covering_of_eq_top` states that for any given category `C`, object `X` in `C`, sieve `S` of `X` and a Grothendieck topology `J` on `C`, if `S` equals the maximal (or top) sieve, then `S` is a member of the sieves determined by the Grothendieck topology `J` at `X`. In other words, any maximal sieve on an object in a category is a covering for that object with respect to any Grothendieck topology on the category.

For any category `C`, object `X` in `C`, and a Grothendieck topology `J` on `C`, if `S` is the maximal sieve of `X`, then `S` is a covering sieve of `X` in the sense of `J`.


theorem gcd_one_right :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a 1 = 1 := by
  sorry

This theorem states that for any type 'α' that is a CancelCommMonoidWithZero and a NormalizedGCDMonoid, the greatest common divisor (gcd) of any element 'a' of type 'α' and 1 is always 1. The CancelCommMonoidWithZero and NormalizedGCDMonoid are algebraic structures with specific properties, and the theorem essentially says that 1 is the gcd for any number and 1 in these structures.

For any type 'α' that is both a CancelCommMonoidWithZero and a NormalizedGCDMonoid, the greatest common divisor of any element 'a' of type 'α' and 1 is equal to 1.


theorem mul_pos_iff_of_pos_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulStrictMono α]
      [inst_3 : PosMulReflectLT α], 0 < a → (0 < a * b ↔ 0 < b) :=
  by sorry

The theorem `mul_pos_iff_of_pos_left` states that for any type `α` with multiplication and zero properties, and strict monotonicity and reverse monotonicity of multiplication by positive and nonnegative elements (respectively), if `a` is a positive element of `α`, then the product `a * b` is positive if and only if `b` is positive. In other words, the positivity of the product `a * b` depends solely on the positivity of `b` when `a` is positive.

For any type `α` with multiplication and zero, and strictly monotonic multiplication by positive elements and reverse monotonic multiplication by nonnegative elements, a positive element `a` of `α` implies `a * b` is positive if and only if `b` is positive.


theorem Ideal.toIdeal_homogeneousCore_le :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A]
      [inst_2 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι]
      [inst_5 : GradedRing 𝒜] (I : Ideal A), HomogeneousIdeal.toIdeal (Ideal.homogeneousCore 𝒜 I) ≤ I :=
  by sorry

This theorem asserts that for any semiring `A`, any type `σ` such that `σ` behaves like a subset of `A`, any type `ι` with decidable equality and addition operation, any function `𝒜` from `ι` to `σ`, and any ideal `I` in `A`, the ideal obtained by converting the homogeneous core of `I` via function `𝒜` into an ideal is a subset of `I`. The homogeneous core of an ideal is the sub-ideal consisting of all homogeneous elements of the ideal.

In simpler terms, the theorem states that the ideal formed by the homogeneous elements of an ideal (when considered in the context of a graded ring structure given by `𝒜`) is always contained within the original ideal. This is a statement about the relationship between an ideal and its homogeneous core in a graded ring structure.

Given a semiring `A`, a type `σ` behaving like a subset of `A`, a decidable type `ι`, a function `𝒜` from `ι` to `σ`, and an ideal `I` in `A`, the ideal generated by the homogeneous elements of `I` under `𝒜` is contained in `I`.


theorem Complex.exp_nat_mul : ∀ (x : ℂ) (n : ℕ), Complex.exp (↑n * x) = Complex.exp x ^ n := by sorry

The theorem `Complex.exp_nat_mul` states that for any complex number `x` and any natural number `n`, the exponential of the product of `n` and `x` is equal to the exponential of `x` raised to the power `n`. In mathematical notation, this is equivalent to saying that for all `x` in the set of complex numbers and `n` in the set of natural numbers, \(e^{nx} = (e^x)^n\).

For all complex numbers x and natural numbers n, $e^{nx} = (e^x)^n$.


theorem zsmul_add : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α) (n : ℤ), n • (a + b) = n • a + n • b :=
  by sorry

This theorem, `zsmul_add`, states that for any type `α` which is a commutative monoid under subtraction (denoted `SubtractionCommMonoid α`), for any elements `a` and `b` of this type and any integer `n`, the operation of scalar multiplication distributes over addition. In mathematical terms, it says that `n` times the sum of `a` and `b` equals `n` times `a` plus `n` times `b`. This is a generalization of the distributive law in algebra.

For any commutative monoid under subtraction `α` and integers `n`, `a`, `b` in `α`, we have `n * (a + b) = n * a + n * b`.


theorem addOrderOf_injective :
    ∀ {G : Type u_1} [inst : AddMonoid G] {H : Type u_6} [inst_1 : AddMonoid H] (f : G →+ H),
      Function.Injective ⇑f → ∀ (x : G), addOrderOf (f x) = addOrderOf x :=
  by sorry

The theorem `addOrderOf_injective` asserts that for any two types `G` and `H`, each equipped with an additive monoid structure, and any injective function `f` from type `G` to type `H` that preserves the additive monoid structure, the order of an element `x` of type `G` under addition (i.e., the smallest non-zero natural number `n` such that `n` times `x` equals zero, or zero if no such `n` exists) is the same as the order of the image of `x` under `f`. In other words, the injective function preserves the additive order of elements.

If `f` is an injective function between additive monoids `G` and `H`, then for all `x` in `G`, the order of `x` under addition in `G` equals the order of `f(x)` under addition in `H`.


theorem ModelWithCorners.image_eq :
    ∀ {𝕜 : 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) (s : Set H),
      ↑I '' s = ↑(ModelWithCorners.symm I) ⁻¹' s ∩ Set.range ↑I :=
  by sorry

This theorem states that for any type `𝕜` that is a nontrivially normed field, any type `E` that is a normed additive commutative group and a normed space over `𝕜`, and any type `H` that is a topological space, given a ModelWithCorners `I` from `𝕜` to `E` to `H` and a set `s` of type `H`, the image of `s` under `I` is equal to the intersection of the preimage of `s` under the inverse of `I` and the range of `I`. In other words, it's stating that applying a function to a set and then applying the inverse function returns the original set, assuming the functions are well-behaved in a certain mathematical sense.

For any nontrivially normed field `𝕜`, normed additive commutative group and normed space `E` over `𝕜`, topological space `H`, ModelWithCorners `I` from `𝕜` to `E` to `H`, and set `s` in `H`, the image of `s` under `I` equals the intersection of the preimage of `s` under `I⁻¹` and the range of `I`.


theorem Fin.insertNth_binop :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (op : (j : Fin (n + 1)) → α j → α j → α j) (i : Fin (n + 1)) (x y : α i)
      (p q : (j : Fin n) → α (Fin.succAbove i j)),
      (Fin.insertNth i (op i x y) fun j => op (Fin.succAbove i j) (p j) (q j)) = fun j =>
        op j (Fin.insertNth i x p j) (Fin.insertNth i y q j) :=
  by sorry

The theorem `Fin.insertNth_binop` states that for any natural number `n` and a type `α` that depends on a value in `Fin (n + 1)`, given a binary operation `op` that acts on elements of type `α`, an index `i` in `Fin (n + 1)`, and two values `x` and `y` of type `α i`, if we have two functions `p` and `q` that, for every index in `Fin n`, associate it with an element of type `α` that is indexed by `Fin.succAbove i j` (which essentially embeds `Fin n` in `Fin (n + 1)` with a gap around `i`), then applying `op` to the results of inserting `x` and `y` at position `i` in the sequences defined by `p` and `q` gives the same outcome as first applying `op` to `x` and `y` and to each corresponding pair of elements from `p` and `q`, and then inserting these results at position `i` in the sequence. This is essentially saying that the process of inserting values at a specific position in a sequence commutes with the given binary operation.

For any natural number `n`, binary operation `op` on type `α`, index `i` in `Fin (n + 1)`, and values `x` and `y` of type `α i`, if we have functions `p` and `q` that associate elements of `Fin n` with elements of type `α` indexed by `Fin.succAbove i j`, then `op` on the elements inserted at position `i` in sequences `p` and `q` equals `op` on `x` and `y` and the corresponding elements from `p` and `q`, followed by insertion at position `i` in the sequence of the results.


theorem Polynomial.eq_prod_roots_of_splits :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] {p : Polynomial K} {i : K →+* L},
      Polynomial.Splits i p →
        Polynomial.map i p =
          Polynomial.C (i (Polynomial.leadingCoeff p)) *
            Multiset.prod
              (Multiset.map (fun a => Polynomial.X - Polynomial.C a) (Polynomial.roots (Polynomial.map i p))) :=
  by sorry

The theorem `Polynomial.eq_prod_roots_of_splits` states that for any field `K` and `L`, along with a polynomial `p` from `K` and a ring homomorphism `i` from `K` to `L`, if the polynomial `p` splits via the ring homomorphism `i`, then the polynomial `p`, when mapped using `i`, can be expressed as the product of the constant polynomial of the leading coefficient of `p` (mapped via `i`) and the product of polynomials each of which is the difference between the polynomial variable `X` and the constant polynomial of a root of the mapped polynomial `p`. The roots are taken from the multiset of roots of the mapped polynomial `p`.

If a polynomial `p` from field `K` splits via a ring homomorphism `i` from `K` to `L`, then `p` maps to the product of the leading coefficient of `p` (mapped via `i`) and the product of the differences between `X` and the images under `i` of the roots of `p`.