/-- **Equality case of the Rearrangement Inequality**: Pointwise scalar multiplication of `f` and
`g`, which antivary together, is unchanged by a permutation if and only if `f ∘ σ` and `g` antivary
together. Stated by permuting the entries of `f`.  -/
theorem AntivaryOn.sum_smul_eq_sum_comp_perm_smul_iff :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      AntivaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s →
          (((Finset.sum s fun i => f (σ i) • g i) = Finset.sum s fun i => f i • g i) ↔ AntivaryOn (f ∘ ⇑σ) g ↑s) :=
  by sorry

This theorem, referred to as the "Equality case of the Rearrangement Inequality", states that for a given set `s` of elements of type `ι`, a permutation `σ` of `ι`, and functions `f: ι → α` and `g : ι → β`, where `α` is a linear ordered ring and `β` is a linear ordered additive commutative group with a scalar multiplication, if `f` and `g` antivary on `s`, and all the elements `x` in the set `s` that are moved by the permutation `σ` are included in `s`, then the scalar multiplication of `f` and `g`, evaluated pointwise and summed over `s`, remains unchanged by the permutation `σ` if and only if `f ∘ σ` and `g` antivary on `s`. In other words, rearranging the entries of `f` according to the permutation `σ` does not change the sum if and only if the rearranged function `f` still antivaries with `g`.

For functions $f:\Gamma \to \alpha$ and $g:\Gamma \to \beta$ over a set $\Gamma$ with a permutation $\sigma$, if $f$ and $g$ antivary over $\Gamma$, $s \subseteq \Gamma$ is invariant under $\sigma$, and $f \circ \sigma$ and $g$ continue to antivary over $s$, then the pointwise scalar multiplication of $f$ and $g$ over $s$ is equal to the pointwise scalar multiplication over $\sigma(s)$.


theorem Mathlib.Order.Lattice._auxLemma.26 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ b ⊔ c) = (a ≤ b ∨ a ≤ c) := by sorry

This theorem from the Mathlib Order Lattice library states that, for any type `α` that has a linear order, the inequality `a ≤ b ⊔ c` holds true if and only if `a ≤ b` or `a ≤ c`. Here, `b ⊔ c` represents the least upper bound (or supremum) of `b` and `c`, that is, the smallest element that is greater than both `b` and `c`. Thus, this theorem is essentially a statement about the properties of supremum in a linearly ordered set.

In a linearly ordered set, for all elements a, b, and c, a is less than or equal to the least upper bound of b and c if and only if a is less than or equal to either b or c.


theorem Mathlib.Order.Lattice._auxLemma.10 : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (b < a ⊔ b) = ¬a ≤ b :=
  by sorry

This theorem, `Mathlib.Order.Lattice._auxLemma.10`, states that for any type `α` that is a semilattice with respect to the operation "sup" (supremum), and for any two elements `a` and `b` of this type, `b` is less than the supremum of `a` and `b` if and only if `a` is not less than or equal to `b`. In other words, in a semilattice, the supremum of two elements always exceeds one of the elements unless that element is greater than or equal to the other.

In a semilattice, the supremum of two elements is strictly greater than one of them if and only if they are incomparable.


theorem Uniform.tendsto_nhds_left :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {f : Filter β} {u : β → α} {a : α},
      Filter.Tendsto u f (nhds a) ↔ Filter.Tendsto (fun x => (u x, a)) f (uniformity α) :=
  by sorry

The theorem `Uniform.tendsto_nhds_left` establishes an equivalence between two different ways of representing the limit of a function `u` from a type `β` to a type `α`, where `α` is equipped with a uniform space structure. The first representation is the traditional limit concept, stating that `u` tends to `a` with respect to a filter `f`. The second representation involves the uniformity filter on `α` and states that as elements from the filter `f` are mapped by `u`, the pairs they form with `a` tend to the uniformity of `α`. In other words, the theorem asserts that for every function `u` and every element `a` in a uniform space `α`, `u` tends to `a` with respect to a filter `f` if and only if the pairs formed by mapping elements from `f` through `u` and coupling with `a` tend towards the uniformity filter of `α`.

For a function `u` from a type `β` to a uniform space `α` and an element `a` in `α`, `u` tends to `a` with respect to a filter `f` if and only if the pairs formed by mapping elements from `f` through `u` and coupling with `a` tend towards the uniformity filter of `α`.


theorem Mathlib.Data.Real.Sqrt._auxLemma.2 : ∀ {x : NNReal}, (NNReal.sqrt x = 0) = (x = 0) := by sorry

This theorem states that for all nonnegative real numbers `x`, the square root of `x` is zero if and only if `x` itself is zero. In other words, the only nonnegative real number whose square root is zero is zero itself. This is a fundamental property of the square root operation in the nonnegative real numbers.

The square root of a nonnegative real number is zero if and only if the number itself is zero.


theorem Mathlib.Data.Set.Pairwise.Basic._auxLemma.6 : ∀ {a : Prop}, (a ∧ a) = a := by sorry

This theorem states that for all propositions `a`, the conjunction of `a` and `a` (written as `a ∧ a`) is logically equivalent to `a` itself. In other words, if a particular statement `a` is true, then it is redundant to say `a` and `a` is true. Conversely, if `a` and `a` is true, then `a` must be true.

For all propositions `a`, `a ∧ a` is logically equivalent to `a`.


theorem Mathlib.GroupTheory.GroupAction.FixedPoints._auxLemma.2 :
    ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {m : M} {a : α},
      (a ∈ MulAction.fixedBy α m) = (m • a = a) :=
  by sorry

This theorem states that for any monoid `M` and any type `α` that has a `MulAction` from `M`, an element `a` of type `α` is in the set of elements fixed by a monoidal element `m` if and only if the action of `m` on `a` leaves `a` unchanged. In other words, `a` is fixed by `m` precisely when `m` acting on `a` equals `a`.

For any monoid `M` and type `α` with an `MulAction` from `M`, an element `a` of type `α` is fixed by a monoidal element `m` if and only if `m * a = a`.


EquicontinuousWithinAt.closure'

/-- If a set of functions is equicontinuous at some `x₀` within a set `S`, the same is true for its
closure in *any* topology for which evaluation at any `x ∈ S ∪ {x₀}` is continuous. Since
this will be applied to `DFunLike` types, we state it for any topological space whith a map
to `X → α` satisfying the right continuity conditions. See also `Set.EquicontinuousWithinAt.closure`
for a more familiar (but weaker) statement.

Note: This could *technically* be called `EquicontinuousWithinAt.closure` without name clashes
with `Set.EquicontinuousWithinAt.closure`, but we don't do it because, even with a `protected`
marker, it would introduce ambiguities while working in namespace `Set` (e.g, in the proof of
any theorem called `Set.something`).  -/
theorem EquicontinuousWithinAt.closure' :
    ∀ {X : Type u_3} {Y : Type u_5} {α : Type u_7} [tX : TopologicalSpace X] [tY : TopologicalSpace Y]
      [uα : UniformSpace α] {A : Set Y} {u : Y → X → α} {S : Set X} {x₀ : X},
      EquicontinuousWithinAt (u ∘ Subtype.val) S x₀ →
        Continuous (Set.restrict S ∘ u) →
          Continuous (Function.eval x₀ ∘ u) → EquicontinuousWithinAt (u ∘ Subtype.val) S x₀ :=
  by sorry

The theorem `EquicontinuousWithinAt.closure'` states that for any types `X`, `Y`, and `α`, given a topological space over `X` and `Y`, a uniform space over `α`, a set `A` of type `Y`, a function `u` from `Y` to the function type `X → α`, a set `S` of type `X`, and an element `x₀` of type `X`, if the function `u` composed with `Subtype.val` is equicontinuous within `S` at `x₀`, and the function `Set.restrict S` composed with `u`, as well as `Function.eval x₀` composed with `u` are continuous, then the function `u` composed with `Subtype.val` remains equicontinuous within `S` at `x₀` for the closure of the set of functions in any topology, provided the evaluation at any `x` in the union of sets `S` and `{x₀}` is continuous.

If a function from a set to a uniform space is equicontinuous within a subset at a point, is continuous when restricted to the subset and at the point, and the evaluation at any point in the union of the subset and the point is continuous, then the function remains equicontinuous within the subset at the point for the closure of the set of functions in any topology.


theorem MulAction.zpow_mod_period_smul :
    ∀ {α : Type v} {G : Type u} [inst : Group G] [inst_1 : MulAction G α] (j : ℤ) {g : G} {a : α},
      g ^ (j % ↑(MulAction.period g a)) • a = g ^ j • a :=
  by sorry

This theorem states that for any integer `j`, any group element `g` and any element `a` upon which `g` acts, the action of `g` raised to the power `j` modulo the period of the action of `g` on `a` on `a` is the same as the action of `g` raised to the power `j` on `a`. In mathematical terms, this can be expressed as `g ^ (j mod period(g, a)) * a = g ^ j * a`, where `^` denotes exponentiation, `mod` denotes the modulus operation, and `*` denotes the action of `g` on `a`. The period of an action is the smallest positive integer `n` such that raising `g` to the power `n` and acting on `a` yields `a` again.

For any group element `g`, integer `j`, and group element `a` upon which `g` acts, the power `g^(j mod period(g, a))` of `g` acting on `a` is equivalent to the power `g^j` of `g` multiplied by `a`.


theorem Primrec.nat_rec :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → β} {g : α → ℕ × β → β},
      Primrec f → Primrec₂ g → Primrec₂ fun a n => Nat.rec (f a) (fun n IH => g a (n, IH)) n :=
  by sorry

The theorem `Primrec.nat_rec` states that for all types `α` and `β` that can be encoded as natural numbers (as indicated by `[inst : Primcodable α]` and `[inst_1 : Primcodable β]`), given a function `f` from `α` to `β` and a function `g` from `α` and a pair of a natural number and `β` to `β`, if `f` is a primitive recursive function and `g` is a binary primitive recursive function, then the function that maps `a` and `n` to the result of the primitive recursive function `Nat.rec` applied to the result of `f` applied to `a` and `n` and the function that maps `n` and `IH` to the result of `g` applied to `a` and the pair `(n, IH)` is also a binary primitive recursive function. In simpler terms, it's saying that a certain type of combination of primitive recursive functions (specifically, those involving the natural number recursion function `Nat.rec`) yields another primitive recursive function.

If `f` is a primitive recursive function from `α` to `β` and `g` is a binary primitive recursive function, then the function that maps `(a, n)` to `Nat.rec (f a n) (g a (n, IH))` is also a binary primitive recursive function.


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

This theorem, `Int.le_add_of_sub_right_le`, states that for any three integers `a`, `b`, and `c`, if `a - c` is less than or equal to `b`, then `a` is less than or equal to `b + c`. In mathematical terms, it's expressing the inequality relation: if `a - c ≤ b`, then it must be the case that `a ≤ b + c`.

If `a - c` is less than or equal to `b`, then `a` is less than or equal to `b + c`. In mathematical notation, `a - c ≤ b` implies `a ≤ b + c`.


theorem IsLUB.nhdsWithin_neBot :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsLUB s a → Set.Nonempty s → Filter.NeBot (nhdsWithin a s) :=
  by sorry

The theorem `IsLUB.nhdsWithin_neBot` states that for any type `α` that has a topological structure, a linear ordering, and an order topology, and for any element `a` of type `α` and set `s` of type `α`, if `a` is a least upper bound of `s` and the set `s` is not empty, then the filter generated by the intersection of `s` and a neighborhood of `a` (expressed as `nhdsWithin a s`) is not bottom, meaning it contains at least one set other than the empty set. This theorem is important in the study of topology and order theory, and it implies that the intersection of `s` with any neighborhood of a least upper bound of `s` is always nonempty.

For any non-empty set `s` with a least upper bound `a` in a topological order `α`, the filter generated by `s` and a neighborhood of `a` is non-empty.


theorem Finset.map_univ_equiv :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : β ≃ α),
      Finset.map (Equiv.toEmbedding f) Finset.univ = Finset.univ :=
  by sorry

The theorem `Finset.map_univ_equiv` states that for any two types `α` and `β` with finite instances, and an equivalence `f` from `β` to `α`, the image of the universal finset of `β` under the map induced by `f` is equal to the universal finset of `α`. This essentially means that the mapping, with the equivalence `f`, reshuffles the elements of the universal finset `β` into `α` without introducing any new elements or losing any existing ones.

For any types `α` and `β` with finite instances and an equivalence `f` from `β` to `α`, the image of the universal finset of `β` under the map induced by `f` is equal to the universal finset of `α`.


theorem AddGroup.fg_def : ∀ {H : Type u_4} [inst : AddGroup H], AddGroup.FG H ↔ AddSubgroup.FG ⊤ := by sorry

The theorem `AddGroup.fg_def` states that for any type `H` that has an additive group structure, `H` is finitely generated as an additive group if and only if the whole additive group `⊤` is a finitely generated subgroup. In simpler terms, an additive group `H` is said to be finitely generated when there exists a finite subset of `H` whose additive closure generates the entire group, and this matches up with the property of `⊤` being a finitely generated subgroup of `H`.

An additive group H is finitely generated if and only if the whole additive group ⊤ is a finitely generated subgroup of H.


theorem Matrix.isUnit_det_of_left_inverse :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A B : Matrix n n α},
      B * A = 1 → IsUnit (Matrix.det A) :=
  by sorry

This theorem states that for any finite type `n` and any type `α` that forms a commutative ring, given two matrices `A` and `B` of type `Matrix n n α`, if the multiplication of `B` and `A` results in an identity matrix, then the determinant of matrix `A` is a unit in the ring `α`. Here, a unit in the ring is an element which has a multiplicative inverse.

If matrices `A` and `B` of size `n x n` over a commutative ring `α` satisfy `B * A = id_α`, then the determinant of `A` is a unit in `α`.


theorem IsAbsoluteValue.abv_zero :
    ∀ {S : Type u_5} [inst : OrderedSemiring S] {R : Type u_6} [inst_1 : Semiring R] (abv : R → S)
      [inst_2 : IsAbsoluteValue abv], abv 0 = 0 :=
  by sorry

This theorem states that for any ordered semiring `S` and any semiring `R`, given a function `abv` from `R` to `S` that represents an absolute value, the absolute value of zero is zero. This is a basic property of absolute values in mathematics, and this theorem captures that fact in the context of abstract algebra using semirings.

For any ordered semirings S and semiring R with an absolute value function abv from R to S, abv(0) = 0.


theorem AbsoluteValue.abs_abv_sub_le_abv_sub :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommRing S] (abv : AbsoluteValue R S)
      (a b : R), |abv a - abv b| ≤ abv (a - b) :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a ring and `S` is a linear ordered commutative ring, and for any absolute value function `abv` from `R` to `S`, and any elements `a` and `b` of `R`, the absolute value of the difference of `abv a` and `abv b` is less than or equal to the absolute value of the difference of `a` and `b`. This is essentially a kind of triangle inequality for the absolute value function `abv`.

For any ring `R`, commutative ring `S` with order, and absolute value function `abv` from `R` to `S`, |abv(a) - abv(b)| ≤ |a - b| for all elements `a, b` in `R`.


theorem Mathlib.Data.Real.Basic._auxLemma.1 : ∀ {f g : CauSeq ℚ abs}, (Real.mk f < Real.mk g) = (f < g) := by sorry

The theorem, `Mathlib.Data.Real.Basic._auxLemma.1`, states that for any two Cauchy sequences of rational numbers `f` and `g`, with respect to the absolute value function `abs`, the inequality `Real.mk f < Real.mk g` is equivalent to `f < g`. In other words, the inequality between two real numbers created from these Cauchy sequences (by taking their equivalence classes) mirrors the inequality between the original Cauchy sequences themselves.

For any two Cauchy sequences of rational numbers `f` and `g`, `f < g` if and only if `|f| < |g|`, where `|.|` denotes the absolute value function.


theorem harmonic_pos : ∀ {n : ℕ}, n ≠ 0 → 0 < harmonic n := by sorry

The theorem `harmonic_pos` asserts that for every natural number `n` which is not zero, the nth harmonic number is positive. The nth harmonic number is defined as the sum of reciprocals of all natural numbers from 1 to `n`.

For every natural number `n` greater than zero, the sum of the reciprocal of each number from 1 to `n` is positive.


theorem Polynomial.taylor_mul :
    ∀ {R : Type u_2} [inst : CommSemiring R] (r : R) (p q : Polynomial R),
      (Polynomial.taylor r) (p * q) = (Polynomial.taylor r) p * (Polynomial.taylor r) q :=
  by sorry

This theorem, `Polynomial.taylor_mul`, states that for any given commutative semiring `R`, a value `r` in `R`, and two polynomials `p` and `q` over `R`, the Taylor expansion at `r` of the product of `p` and `q` is equal to the product of the Taylor expansion at `r` of `p` and the Taylor expansion at `r` of `q`. In mathematical terms, it means that the operation of taking the Taylor expansion at a point is compatible with polynomial multiplication.

For any commutative semiring `R`, polynomials `p` and `q` over `R`, and value `r` in `R`, the Taylor expansions of `p` and `q` at `r` are multiplicatively compatible, that is, the Taylor expansion of their product equals the product of their individual Taylor expansions at `r`.


MeasureTheory.TendstoInMeasure.congr

theorem MeasureTheory.TendstoInMeasure.congr :
    ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Dist E]
      {l : Filter ι} {f f' : ι → α → E} {g g' : α → E},
      (∀ (i : ι), f i =ᶠ[MeasureTheory.Measure.ae μ] f' i) →
        g =ᶠ[MeasureTheory.Measure.ae μ] g' →
          MeasureTheory.TendstoInMeasure μ f l g → MeasureTheory.TendstoInMeasure μ f' l g' :=
  by sorry

This theorem states that if a sequence of functions `f` converges in measure to a function `g` with respect to a measure `μ` and a filter `l`, then if `f` and `g` are almost everywhere equal to another sequence of functions `f'` and another function `g'` respectively (with respect to the measure `μ`), then `f'` also converges in measure to `g'` under the same measure `μ` and filter `l`.

In other words, the equality almost everywhere of two sequences of functions and two target functions does not disturb the property of convergence in measure under the given measure and filter.

If sequences of functions `f` and `g`, and `f'` and `g'` are almost everywhere equal with respect to a measure `μ`, and `f` converges to `g` in measure under filter `l`, then `f'` converges to `g'` in measure under the same measure `μ` and filter `l`.


/-- If `f : ι → Filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `iInf f ≠ ⊥`.
See also `iInf_neBot_of_directed` for a version assuming `Nonempty α` instead of `Nonempty ι`.  -/
theorem Filter.iInf_neBot_of_directed' :
    ∀ {α : Type u} {ι : Sort x} {f : ι → Filter α} [inst : Nonempty ι],
      Directed (fun x x_1 => x ≥ x_1) f → (∀ (i : ι), Filter.NeBot (f i)) → Filter.NeBot (iInf f) :=
  by sorry

This theorem states that given a directed family `f` of filters on type `α`, indexed by type `ι`, under the conditions where the index set `ι` is not empty and none of the filters in the family equals the bottom filter, it can be ensured that the indexed infimum of `f` will not equal the bottom filter. Here, a family of filters is considered directed if for any two filters in the family, there exists another filter in the family that is greater than or equal to both. The theorem also mentions an alternative version `iInf_neBot_of_directed` that assumes non-emptiness of `α` instead of `ι`.

Given a non-empty directed family of filters `f` on a non-empty type `α`, none of which are the bottom filter, the indexed infimum of `f` is not the bottom filter.


theorem Nat.Prime.dvd_iff_not_coprime : ∀ {p n : ℕ}, Nat.Prime p → (p ∣ n ↔ ¬Nat.Coprime p n) := by sorry

The theorem `Nat.Prime.dvd_iff_not_coprime` states that for all natural numbers `p` and `n`, if `p` is a prime number, then `p` divides `n` if and only if `p` and `n` are not coprime. Here, "divides" means that `n` divided by `p` leaves no remainder, and "not coprime" means that the greatest common divisor (gcd) of `p` and `n` is not equal to 1.

For a natural number `n` and a prime number `p`, `p` divides `n` if and only if `p` and `n` have a common divisor other than 1.


HasDerivWithinAt.sub

theorem HasDerivWithinAt.sub :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {f' g' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' s x → HasDerivWithinAt g g' s x → HasDerivWithinAt (fun x => f x - g x) (f' - g') s x :=
  by sorry

This theorem states that if the function `f` has a derivative `f'` at a point `x` within a subset `s`, and the function `g` has a derivative `g'` at the same point `x` within the same subset `s`, then the function `h` defined as `h(x) = f(x) - g(x)` has a derivative `h' = f' - g'` at the point `x` within the subset `s`. The space in which these functions and derivatives are taken is a normed vector space over a normed field. This theorem essentially encapsulates the linearity of differentiation in such normed spaces.

If `f` and `g` are differentiable functions at `x` in the subset `s` of a normed vector space, then their difference `h(x) = f(x) - g(x)` is also differentiable at `x` with derivative `h'(x) = f'(x) - g'(x)`.


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

The theorem `TensorProduct.smul_zero` asserts that for any commutative semiring `R`, monoid `R'`, types `M` and `N` that form additive commutative monoids and `R`-modules, and type `M` is a `R'`-distributive mul-action where `R` and `R'` commute on `M`, scalar multiplication of any element `r` from `R'` and the zero element from `M` (denoted as `0`) always gives us the zero element. This is a generalization of the property in linear algebra where scalar multiplication of any scalar and the zero vector yields the zero vector.

For any commutative semiring `R`, monoid `R'`, additive commutative monoids `M` and `N`, and `R`-modules `M` with `R'`-distributive and commuting actions, `r * 0 = 0` for all `r` in `R'`.


theorem MeasurableEquiv.map_symm_map :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} (e : α ≃ᵐ β),
      MeasureTheory.Measure.map (⇑e.symm) (MeasureTheory.Measure.map (⇑e) μ) = μ :=
  by sorry

This theorem states that, for any measurable spaces `α` and `β`, and a measure `μ` on `α`, if we have a measurable equivalence `e` between `α` and `β`, then mapping the measure `μ` from `α` to `β` using `e`, and then mapping it back to `α` using the inverse of `e`, we get back the original measure `μ`. This is a kind of "undoing" property, showing that the process of mapping measures under a measurable equivalence and its inverse is reversible.

For measurable spaces `α`, `β`, a measure `μ` on `α`, and a measurable equivalence `e` between `α` and `β`, the pushforward and pullback measures of `μ` under `e` and its inverse respectively are equal: `μ` = `e.forwardMeasure` `∘` `e.inverse.measure` = `e.inverse.measure` `∘` `μ`.


theorem Polynomial.eq_X_add_C_of_degree_le_one :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.degree p ≤ 1 →
        p = Polynomial.C (Polynomial.coeff p 1) * Polynomial.X + Polynomial.C (Polynomial.coeff p 0) :=
  by sorry

The theorem `Polynomial.eq_X_add_C_of_degree_le_one` states that for any polynomial `p` over a semiring `R` where the degree of `p` is less than or equal to 1, `p` can be expressed as the sum of a monomial of degree 1 and a constant. More specifically, `p` is equal to the product of the constant polynomial of the coefficient of `X` in `p` and the polynomial variable `X`, added to the constant polynomial of the constant term in `p`. In mathematical terms, if the degree of a polynomial `p(X)` is less than or equal to 1, then `p(X) = aX + b`, where `a` is the coefficient of `X` in `p` and `b` is the constant term in `p`.

For any polynomial `p` of degree less than or equal to 1 over a semiring, `p(X)` equals the product of the coefficient of `X` in `p` and `X`, plus the constant term in `p`.


theorem Ideal.isMaximal_of_isIntegral_of_isMaximal_comap :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S],
      Algebra.IsIntegral R S →
        ∀ (I : Ideal S) [inst_3 : Ideal.IsPrime I],
          Ideal.IsMaximal (Ideal.comap (algebraMap R S) I) → Ideal.IsMaximal I :=
  by sorry

The theorem `Ideal.isMaximal_of_isIntegral_of_isMaximal_comap` states that for any commutative rings `R` and `S` with an algebra structure from `R` to `S`, if every element of `S` is integral over `R`, then for any prime ideal `I` in `S`, if the preimage of `I` under the algebra structure (`algebraMap R S`) is a maximal ideal in `R`, then `I` itself is a maximal ideal in `S`. This theorem essentially presents a condition under which the maximality of an ideal is preserved under the `comap` operation and the algebra structure between two rings.

If `R` is a commutative ring, `S` is a commutative ring with an algebra structure from `R` to `S`, and every element of `S` is integral over `R`, then for any prime ideal `I` in `S`, if the preimage of `I` under the algebra map is a maximal ideal in `R`, then `I` is a maximal ideal in `S`.


theorem Ring.mul_inverse_cancel :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), IsUnit x → x * Ring.inverse x = 1 := by sorry

The theorem `Ring.mul_inverse_cancel` states that for any type `M₀` equipped with a structure of monoid with zero, if an element `x : M₀` is a unit (i.e., it has a two-sided inverse), then the product of `x` and its inverse (as defined by `Ring.inverse` function) equals the multiplicative identity of the monoid. In other words, for any invertible element `x`, when you multiply `x` with its inverse, you get back the number one, which is exactly what we expect from the notion of an inverse in a multiplicative monoid.

If `x` is an invertible element in a monoid `M₀` with zero, then `x * (Ring.inverse x) = 1`.


theorem CategoryTheory.NonPreadditiveAbelian.add_neg :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a b : X ⟶ Y), a + -b = a - b :=
  by sorry

This theorem is stated in the context of a category theory in Lean 4 and asserts that for any category `C` that is "non-preadditive abelian" and for any objects `X` and `Y` in `C`, the morphism `a` from `X` to `Y` added to the negation of morphism `b` from `X` to `Y` is equal to the morphism `a` subtracted by morphism `b`. In simpler terms, it establishes that adding a negated element is the same as subtraction in the context of morphisms in a non-preadditive abelian category.

In a non-preadditive abelian category, for any objects X and Y and morphisms a and b, a + (-b) = a - b.


theorem Nat.mul_left_inj : ∀ {a b c : ℕ}, a ≠ 0 → (b * a = c * a ↔ b = c) := by sorry

This theorem, `Nat.mul_left_inj`, states that for any three natural numbers `a`, `b`, and `c`, if `a` is not equal to zero, then `b` times `a` equals `c` times `a` if and only if `b` equals `c`. In other words, the multiplication operation is left-injective in the natural numbers, assuming the left operand is not zero.

For all natural numbers `a`, `b`, and `c`, if `a` is non-zero then `b * a = c * a` if and only if `b = c`.


theorem Mathlib.Algebra.Module.Submodule.Ker._auxLemma.4 :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) := by sorry

This theorem states that for any type `α` equipped with the structure of a semilattice having a least element (with `α` as the type, a semilattice structure, and a least element structure), and for any two elements `a` and `b` of this type, `a` and `b` are disjoint if and only if the infimum of `a` and `b` is less than or equal to the least element. Here, being 'disjoint' is defined by the `Disjoint` function, which means that for any element `x` which is less than or equal to both `a` and `b`, `x` is also less than or equal to the bottom element.

For any semilattice `α` with least element, elements `a` and `b` are disjoint if and only if the infimum of `a` and `b` equals the least element.


theorem map_natCast' :
    ∀ {B : Type u_4} {F : Type u_5} [inst : AddMonoidWithOne B] {A : Type u_6} [inst_1 : AddMonoidWithOne A]
      [inst_2 : FunLike F A B] [inst_3 : AddMonoidHomClass F A B] (f : F), f 1 = 1 → ∀ (n : ℕ), f ↑n = ↑n :=
  by sorry

The theorem `map_natCast'` states that for any types `B`, `F`, and `A`, given that `B` and `A` are both AddMonoidWithOne (which means they are both additive monoids with a distinguished element `1`), `F` is a function from type `A` to `B`, and `F` is a homomorphism class for the add monoid, then for any function `f` of type `F`, if `f` maps `1` of `A` to `1` of `B`, then `f` preserves the natural number casting, i.e., for all natural numbers `n`, the result of casting `n` to `A` and then applying `f` is the same as directly casting `n` to `B`.

If `F` is a homomorphism from an additive monoid `A` with identity `1` to an additive monoid `B` with identity `1`, and `F(1) = 1`, then for all natural numbers `n`, `F(n : A) = (n : B)`.


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

The theorem `sup_eq_sup_iff_right` states that, for any type `α` that forms a semilattice with respect to the sup (or join) operation, and any three elements `a`, `b`, and `c` of this type, the supremum (or join) of `a` and `c` is equal to the supremum of `b` and `c` if and only if `a` is less than or equal to the supremum of `b` and `c` and `b` is less than or equal to the supremum of `a` and `c`. This theorem is a part of the order theory in mathematics and specifically deals with the lattice structure.

For any semilattice type `α` and elements `a`, `b`, and `c`, `a ⊔ c = b ⊔ c` if and only if `a ≤ b ≤ a ⊔ c`. (Here, `⊔` denotes the sup or join operation.)


theorem Nat.cast_bit0 : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑(bit0 n) = bit0 ↑n := by sorry

The theorem `Nat.cast_bit0` states that for any natural number `n` and any type `R` that is an add monoid with a one element, casting the bit-doubled value of `n` into `R` is the same as bit-doubling the cast of `n` into `R`. Here, the `bit0` function doubles a number by adding it to itself. In more mathematical terms, for all natural numbers `n` and any type `R` that is an add monoid with one, we have `2 * coe(n) = coe(2 * n)` where `coe` represents the casting function.

For any natural number `n` and add monoid `R` with one, `2 * (coe n) = coe (2 * n)`.


theorem Int.fract_add_int :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α) (m : ℤ),
      Int.fract (a + ↑m) = Int.fract a :=
  by sorry

The theorem `Int.fract_add_int` states that for any type `α` that forms a linear ordered ring and has a floor ring structure, and for any elements `a` of `α` and `m` of the integers (`ℤ`), the fractional part of `a` plus `m` (i.e., `a + m`) is the same as the fractional part of `a`. In mathematical terms, if `fract(x)` represents the fractional part of `x`, this theorem is saying that `fract(a + m) = fract(a)` for all such `a` and integer `m`.

For any element `a` in a linear ordered ring with a floor ring structure and any integer `m`, the fractional parts of `a` and `a + m` are equal.


theorem Set.seq_eq_image2 :
    ∀ {α : Type u} {β : Type v} (s : Set (α → β)) (t : Set α), Set.seq s t = Set.image2 (fun f a => f a) s t := by sorry

This theorem establishes an equivalence between the sequence of a set of functions `s` and a set `t` and the image of a binary function which is a member of the set of functions `s` applied to an element of the set `t`. More specifically, for any set of functions `s : Set (α → β)` and a set `t : Set α`, the sequence `Set.seq s t` is equivalent to the image `Set.image2 (fun f a => f a) s t`, where `(fun f a => f a)` is the binary function that applies a function `f` to an element `a`. Essentially, this theorem states that the `Set.seq` operation can be expressed as a specific `Set.image2` operation.

The sequence of a set of functions `s` applied to a set `t` is equivalent to the image of the function that applies each function in `s` to each element in `t`.


theorem mem_span_gramSchmidt :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι]
      [inst_5 : IsWellOrder ι fun x x_1 => x < x_1] (f : ι → E) {i j : ι},
      i ≤ j → f i ∈ Submodule.span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j) :=
  by sorry

The theorem `mem_span_gramSchmidt` states that for any type `𝕜` that behaves like the real numbers, a normed additively commutative group `E` equipped with an inner product space over `𝕜`, and an ordered type `ι` that has a lower bound and is well-ordered, given a function `f : ι → E` and two elements `i` and `j` of type `ι` such that `i` is less than or equal to `j`, then the value of the function `f` at `i` is in the span of the set of vectors obtained by applying the Gram-Schmidt orthogonalization process to the image of the function `f` over the interval of `ι` that includes all elements less than or equal to `j`. In simple terms, this theorem states that the `i`th vector (for `i` less than or equal to `j`) belongs to the linear space spanned by the Gram-Schmidt orthogonalization of all vectors up to the `j`th vector.

For any type `𝕜` behaving like the real numbers, any normed additively commutative group `E` with an inner product over `𝕜`, and any well-ordered type `ι` with a lower bound, if `f : ι → E` is a function and `i ≤ j` are elements of `ι`, then the `i`th vector `f i` is in the span of the Gram-Schmidt orthogonalization of `{f k | k ≤ j}`.


theorem Ordinal.nmul_zero : ∀ (a : Ordinal.{u_1}), Ordinal.nmul a 0 = 0 := by sorry

This theorem states that for any ordinal `a` in some type `u_1`, the "multiplication by natural numbers" operation (denoted here as `Ordinal.nmul`) with `a` and the ordinal `0` yields `0`. In other words, multiplying any ordinal number by zero yields zero, mimicking the familiar property in arithmetic.


theorem Commute.isNilpotent_mul_right :
    ∀ {R : Type u_1} {x y : R} [inst : Semiring R], Commute x y → IsNilpotent y → IsNilpotent (x * y) := by sorry

The theorem `Commute.isNilpotent_mul_right` states that for any semiring `R` and any two elements `x` and `y` of `R`, if `x` and `y` commute (i.e., `x * y = y * x`) and `y` is nilpotent (i.e., there exists a natural number `n` such that `y^n = 0`), then the product `x * y` is also nilpotent. This means, in the context of algebra, that if multiplication of two elements `x` and `y` is commutative and one of them annihilates to zero when raised to some power, their multiplication will also annihilate to zero when raised to some power.

If `x` and `y` are commuting elements in a semiring with `y` being nilpotent, then `x * y` is also nilpotent.


theorem LipschitzWith.of_dist_le' :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {K : ℝ},
      (∀ (x y : α), dist (f x) (f y) ≤ K * dist x y) → LipschitzWith (Real.toNNReal K) f :=
  by sorry

The theorem `LipschitzWith.of_dist_le'` states that for any types `α` and `β`, any pseudo metric spaces over these types, any function `f` from `α` to `β`, and any real number `K`, if for all `x` and `y` in `α`, the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`, then `f` is Lipschitz continuous with the non-negative real number equivalent of `K`. Here, the non-negative real number equivalent of `K` is obtained by taking the maximum of `K` and `0`, ensuring a non-negative result.

If a function between pseudo metric spaces satisfies the condition that the distance between its images of any two points is less than or equal to a constant times the distance between the points, then the function is Lipschitz continuous with the given constant.


/-- Given a set `t` such that `s ∩ t` is dense in `s`, then the range of `derivWithin f s` is
contained in the closure of the submodule spanned by the image of `t`.  -/
theorem range_derivWithin_subset_closure_span_image :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (f : 𝕜 → F) {s t : Set 𝕜},
      s ⊆ closure (s ∩ t) → Set.range (derivWithin f s) ⊆ closure ↑(Submodule.span 𝕜 (f '' t)) :=
  by sorry

This theorem states that for any function `f` mapping from a non-trivially normed field `𝕜` to a normed add commutative group `F` (which is also a normed space over `𝕜`), given a set `s` and a set `t` such that the intersection of `s` and `t` is dense in `s`, then the range of the derivative of `f` within `s` is contained in the closure of the submodule spanned by the image of `t` under `f`. In other words, if we take all the points within `s` where `f` has a derivative and look at the set of those derivative values, this set is contained within the smallest closed set that contains all linear combinations of values that `f` takes on `t`.

Given a function `f` from a non-trivially normed field to a normed add commutative group that is also a normed space, if `s` and `t` are sets with dense intersection, then the derivative range of `f` in `s` is contained in the closure of the submodule spanned by the images of `t` under `f`.


theorem MvPolynomial.mkDerivation_X :
    ∀ {σ : Type u_1} (R : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
      [inst_2 : Module R A] [inst_3 : Module (MvPolynomial σ R) A] [inst_4 : IsScalarTower R (MvPolynomial σ R) A]
      (f : σ → A) (i : σ), (MvPolynomial.mkDerivation R f) (MvPolynomial.X i) = f i :=
  by sorry

The theorem `MvPolynomial.mkDerivation_X` states that for any type `σ`, any type `R` with a commutative semiring structure, any type `A` with an additive commutative monoid structure, and which is an `R`-module and also a module over the multivariate polynomial type `MvPolynomial σ R`, and any function `f` from `σ` to `A`, and any element `i` of type `σ`, the result of applying the derivation `MvPolynomial.mkDerivation R f` to the degree `1` monomial `MvPolynomial.X i` is equal to `f i`. Here, `MvPolynomial.mkDerivation R f` is a derivation from the multivariate polynomial ring to `A`, and `MvPolynomial.X i` denotes the `i`-th variable in the multivariate polynomial ring.

For any commutative semiring `R`, additive commutative monoid `A` that is an `R`-module and an `MvPolynomial σ R` module, function `f` from type `σ` to `A`, and element `i` of type `σ`, the derivative of the multivariate polynomial `MvPolynomial.X i` with respect to `f` equals `f i`.


theorem Ideal.absNorm_dvd_absNorm_of_le :
    ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDomain S] [inst_2 : Nontrivial S] [inst_3 : IsDedekindDomain S]
      [inst_4 : Module.Free ℤ S] [inst_5 : Module.Finite ℤ S] {I J : Ideal S},
      J ≤ I → Ideal.absNorm I ∣ Ideal.absNorm J :=
  by sorry

The theorem `Ideal.absNorm_dvd_absNorm_of_le` asserts that for any commutative ring `S` that is a domain, nontrivial, a Dedekind domain, and is a free and finite module over the integers, if `I` and `J` are ideals in `S` with `J` being a subset of `I` (expressed as `J ≤ I`), then the absolute norm of `I` divides the absolute norm of `J`. Here, the "absolute norm" of an ideal is defined as the cardinality of the quotient of the ring by the ideal.

For a commutative domain S that is a Dedekind domain, a free and finite module over the integers, if I is an ideal contained in J, then the norm of I divides the norm of J.


/-- A discrete hitting time is a stopping time.  -/
theorem MeasureTheory.hitting_isStoppingTime :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : ConditionallyCompleteLinearOrder ι]
      [inst_1 : IsWellOrder ι fun x x_1 => x < x_1] [inst_2 : Countable ι] [inst_3 : TopologicalSpace β]
      [inst_4 : TopologicalSpace.PseudoMetrizableSpace β] [inst_5 : MeasurableSpace β] [inst_6 : BorelSpace β]
      {f : MeasureTheory.Filtration ι m} {u : ι → Ω → β} {s : Set β} {n n' : ι},
      MeasureTheory.Adapted f u → MeasurableSet s → MeasureTheory.IsStoppingTime f (MeasureTheory.hitting u s n n') :=
  by sorry

The theorem `MeasureTheory.hitting_isStoppingTime` states that for any types `Ω`, `β`, and `ι`, with `Ω` being a measurable space, `β` being a topological, pseudometrizable, measurable and Borel space, and `ι` being a conditionally complete linear order which is well-ordered and countable, given a filtration `f` of type `MeasureTheory.Filtration ι m`, a sequence of functions `u` from `ι` to `Ω → β`, a set `s` of type `Set β`, and two elements `n` and `n'` of type `ι`, if the sequence of functions `u` is adapted to the filtration `f` and the set `s` is a measurable set, then the hitting time represented by `MeasureTheory.hitting u s n n'` is a stopping time with respect to the filtration `f`.

In more intuitive words, this theorem says that a certain kind of 'hitting time' - a time at which a certain event first occurs - is a 'stopping time' - a time at which a certain process can be stopped, given that the process observed is adapted to the filtration and the event set is measurable. This means we can determine whether to stop the process at time `i` using the information we have at time `i`, where `i` is a certain kind of linear order.

Given a measurable space Ω, a topological, pseudometrizable, measurable and Borel space β, a countable, well-ordered and conditionally complete linear order ι, a filtration f, an adapted sequence of functions u from ι to Ω → β, and a measurable set s, the hitting time MeasureTheory.hitting u s n is a stopping time with respect to the filtration f.


theorem Rat.mul_comm : ∀ (a b : ℚ), a * b = b * a := by sorry

This theorem states that multiplication of rational numbers is commutative. In other words, for any two rational numbers 'a' and 'b', the result of 'a' multiplied by 'b' is the same as 'b' multiplied by 'a'.

For all rational numbers a and b, a * b = b * a.


theorem LT.lt.lt_or_lt : ∀ {α : Type u} [inst : LinearOrder α] {x y : α}, x < y → ∀ (z : α), x < z ∨ z < y := by sorry

This theorem states that for any linearly ordered type `α`, given three elements `x`, `y`, and `z` of this type, if `x` is less than `y`, then either `x` is less than `z` or `z` is less than `y`. Essentially, `z` must be greater than `x` or less than `y` given `x < y`, in any linear order.

For any linearly ordered type `α`, if `x < y` then `x <= z` or `z <= y`.


theorem nhds_comap_dist :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (a : α), Filter.comap (fun x => dist x a) (nhds 0) = nhds a := by sorry

This theorem, `nhds_comap_dist`, states that for any given pseudometric space `α` and any element `a` from this space, the neighborhood filter (`nhds`) at `a` is equal to the filter obtained by mapping every element `x` in the space to the distance from `x` to `a` (`dist x a`), and then taking the preimage of the neighborhood filter at `0` under this mapping. In other words, the "neighborhoods" of a point `a` in a pseudometric space are precisely the preimages of the "neighborhoods" of `0` under the distance function from `a`.

For any pseudometric space and element, the neighborhood filter at that element is equal to the preimage under the distance function of the neighborhood filter at 0.


theorem Tropical.trop_add_def :
    ∀ {R : Type u} [inst : LinearOrder R] (x y : Tropical R),
      x + y = Tropical.trop (min (Tropical.untrop x) (Tropical.untrop y)) :=
  by sorry

The theorem `Tropical.trop_add_def` states that for any type `R` equipped with a linear order and any two elements `x` and `y` of the tropicalization of `R` (denoted `Tropical R`), the sum `x + y` is equal to the tropicalization of the minimum (in the sense of the given linear order) of the elements of type `R` corresponding to `x` and `y`. In other words, in the tropical addition operation, `x + y` is defined to be the element of `Tropical R` that corresponds to the smaller (or minimum) of the two elements `x` and `y` when they are considered as elements of the original type `R`.

For any type `R` with a linear order and for any `x, y` in the tropicalization of `R`, the tropical addition `x + y` is the tropicalization of the minimum element in `R` of `{x, y}`.


theorem MeasureTheory.condexpIndL1.proof_3 :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α),
      MeasurableSet s ∧ ↑↑μ s ≠ ⊤ → ↑↑μ s ≠ ⊤ :=
  by sorry

This theorem states that for any type `α` with a measurable space `m0`, a measure `μ` on `α`, and a set `s` of `α`, if the set `s` is a measurable set and the measure of `s` is different from infinity, then the measure of `s` remains different from infinity. In other words, the theorem assures that the condition of being a measurable set and having a measure different from infinity is preserved under the given conditions.

If `α` is a type with measurable space `m0`, `μ` is a measure on `α`, `s` is a measurable subset of `α` with finite measure, then the measure of `s` remains finite.


theorem MeasureTheory.condexpIndL1.proof_2 :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α),
      MeasurableSet s ∧ ↑↑μ s ≠ ⊤ → MeasurableSet s :=
  by sorry

This theorem, `MeasureTheory.condexpIndL1.proof_2`, states that for any type `α` with an associated measurable space `m0`, a measure `μ` on `α`, and a set `s` of type `α`, if `s` is a measurable set and the measure of `s` is not infinite, then `s` is a measurable set. The theorem is basically asserting the property of a measurable set under certain conditions. More specifically, it assures that if a set is measurable and its measure is finite then it remains to be measurable.

If `α` is a type with measurable space `m0`, `μ` is a measure on `α`, and `s` is a measurable, finite-measure subset of `α`, then `s` is measurable.


theorem SimpleGraph.edgeSet_inf :
    ∀ {V : Type u} (G₁ G₂ : SimpleGraph V),
      SimpleGraph.edgeSet (G₁ ⊓ G₂) = SimpleGraph.edgeSet G₁ ∩ SimpleGraph.edgeSet G₂ :=
  by sorry

This theorem states that for any type `V` and any two simple graphs `G₁` and `G₂` defined on that type, the edge set of the intersection of `G₁` and `G₂` is the same as the intersection of the edge sets of `G₁` and `G₂`. In mathematical terms, if we denote by `E(G)` the edge set of a graph `G`, then `E(G₁ ∩ G₂) = E(G₁) ∩ E(G₂)` for any two simple graphs `G₁` and `G₂`.

For any type `V` and simple graphs `G₁` and `G₂` on `V`, the edge set of their intersection equals the intersection of their individual edge sets: `E(G₁ ∩ G₂) = E(G₁) ∩ E(G₂)`.


theorem RingHom.coe_comp :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
      {x_2 : NonAssocSemiring γ} (hnp : β →+* γ) (hmn : α →+* β), ⇑(RingHom.comp hnp hmn) = ⇑hnp ∘ ⇑hmn :=
  by sorry

The theorem `RingHom.coe_comp` states that for any three non-associative semirings (which are types `α`, `β`, and `γ`), and for any given two ring homomorphisms - one from `β` to `γ` (`hnp`), and another from `α` to `β` (`hmn`), the composition of these two ring homomorphisms (obtained using `RingHom.comp`) coincides with the composition of the corresponding functions (`⇑hnp ∘ ⇑hmn`). In other words, the composition of ring homomorphisms is equivalent to the composition of their underlying functions.

For any three semirings `α`, `β`, and `γ`, and given ring homomorphisms `hmn: α → β` and `hnp: β → γ`, `RingHom.comp hnp hmn = hnp ∘ hmn`.


theorem Set.pi_congr :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)},
      s₁ = s₂ → (∀ i ∈ s₁, t₁ i = t₂ i) → Set.pi s₁ t₁ = Set.pi s₂ t₂ :=
  by sorry

The theorem `Set.pi_congr` states that for any index set `ι`, and any two families of sets `s₁, s₂` indexed by `ι`, and any two families of sets `t₁, t₂` whose types are indexed by elements in `s₁` or `s₂`, if `s₁` equals `s₂` and for any element `i` in `s₁`, the set `t₁ i` equals the set `t₂ i`, then the dependent function sets `Set.pi s₁ t₁` and `Set.pi s₂ t₂` are equal. In simpler terms, this theorem is about the equality of two sets of functions: if the indexing sets and the dependent sets are the same for two sets of functions, then the sets of functions themselves are equal.

If two indexed families of sets have equal indices and equal sets for each index, then their corresponding dependent function sets are equal.


theorem addOrderOf_le_of_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G} {n : ℕ}, 0 < n → n • x = 0 → addOrderOf x ≤ n := by sorry

The theorem `addOrderOf_le_of_nsmul_eq_zero` states that for any type `G` that is an instance of the `AddMonoid` typeclass, for any element `x` of `G`, and for any natural number `n` greater than `0`, if `n` times `x` equals `0`, then the additive order of `x` is less than or equal to `n`. The additive order of an element `x` in `G` is the smallest positive natural number `n` such that `n • x = 0`, or `0` if no such `n` exists (indicating that `x` has infinite order).

For any AddMonoid type `G` and element `x` in `G`, if `x` has order at most `n` (i.e., `n * x = 0`), then the additive order of `x` is less than or equal to `n`.


theorem InfClosed.finsetInf'_mem :
    ∀ {α : Type u_2} [inst : SemilatticeInf α] {ι : Type u_4} {f : ι → α} {s : Set α} {t : Finset ι},
      InfClosed s → ∀ (ht : t.Nonempty), (∀ i ∈ t, f i ∈ s) → Finset.inf' t ht f ∈ s :=
  by sorry

This theorem states that for any type `α` that forms a semilattice under an infimum operation, given a function `f` from some type `ι` to `α`, a set `s` of elements of type `α`, and a nonempty finite set `t` of elements of type `ι`, if the set `s` is infimum-closed (meaning that the infimum of any two elements in `s` also belongs to `s`), and every image of an element in `t` under function `f` belongs to `s`, then the infimum of the images of elements in `t` under `f` also belongs to `s`. In mathematical notation, if `s ⊆ α` is infimum-closed and `(∀ i ∈ t, f(i) ∈ s)`, then `inf_{i∈t} f(i) ∈ s`.

Given a semilattice `α` with infimum operation, if `s ⊆ α` is infimum-closed and for all `i ∈ t`, `f(i) ∈ s`, then `inf_{i∈t} f(i) ∈ s`.


theorem Mathlib.Data.Finset.Image._auxLemma.7 :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b := by
  sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, any element `b` of type `β`, and any multiset `s` of type `α`, the statement "b is in the multiset obtained by mapping f over s" is equivalent to the existence of an element `a` in `s` such that `f(a)` equals `b`. In other words, an element `b` is in the multiset resulting from the map function if and only if there exists an element `a` in the original multiset `s` for which the function `f` maps `a` to `b`.

For any functions $f:\alpha \to \beta$, elements $b \in \beta$, and multisets $s \subseteq \alpha$, $b$ is in the image multiset of $f$ over $s$ if and only if there exists an element $a \in s$ such that $f(a) = b$.


theorem QuotientGroup.mk'_surjective :
    ∀ {G : Type u} [inst : Group G] (N : Subgroup G) [nN : Subgroup.Normal N],
      Function.Surjective ⇑(QuotientGroup.mk' N) :=
  by sorry

The theorem `QuotientGroup.mk'_surjective` states that for any type `G` that is a group, and for any `N` which is a normal subgroup of `G`, the group homomorphism from `G` to the quotient group `G/N`, given by the function `QuotientGroup.mk' N`, is surjective. This means that for every element in the quotient group `G/N`, there exists an element in the original group `G` such that applying the `QuotientGroup.mk' N` function to this element results in the given element of the quotient group.

For any group `G` and normal subgroup `N`, the homomorphism `QuotientGroup.mk' N : G → G/N` is surjective.


theorem Mathlib.Data.Finset.Image._auxLemma.4 : ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) := by sorry

This theorem, `Mathlib.Data.Finset.Image._auxLemma.4`, states that for all types `α`, all elements `a` of type `α`, and all finite sets `s` of type `α`, the statement 'element `a` is in the coercive version of the set `s`' is equivalent to the statement 'element `a` is in the original set `s`'. In other words, coercing a finite set doesn't change whether an element is in that set.

For all types `α`, elements `a` of `α`, and finite sets `s` of `α`, the element `a` is in the coercive version of `s` if and only if it is in `s`.


theorem Set.zero_mem_zero : ∀ {α : Type u_2} [inst : Zero α], 0 ∈ 0 := by sorry

This theorem states that, for any type 'α' which has a zero element, this zero element is a member of the singleton set that contains only zero. In mathematical terms, it says that for all 'α', if 'α' has a zero, then 0 is an element of the set {0}. This is a special case of the general rule that every element is a member of the singleton set which contains only that element.

For any type 'α' with a zero element, the zero element is an element of the singleton set {0}.


theorem CategoryTheory.NonPreadditiveAbelian.sub_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a : X ⟶ Y), a - 0 = a :=
  by sorry

This theorem states that in the context of a non-preadditive Abelian category (denoted by `C`), for any two objects `X` and `Y` in `C`, and any morphism `a` from `X` to `Y`, subtracting the zero morphism from `a` gives `a` again. In other words, in a non-preadditive Abelian category, any morphism minus the zero morphism equals the original morphism.

In a non-preadditive Abelian category, for any morphism `a` from object `X` to object `Y`, `a = a + (-a)` holds.


theorem measurable_deriv_with_param :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_3} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {α : Type u_4} [inst_3 : TopologicalSpace α] [inst_4 : MeasurableSpace α]
      [inst_5 : OpensMeasurableSpace α] [inst_6 : CompleteSpace F] [inst_7 : LocallyCompactSpace 𝕜]
      [inst_8 : MeasurableSpace 𝕜] [inst_9 : OpensMeasurableSpace 𝕜] [inst_10 : MeasurableSpace F]
      [inst_11 : BorelSpace F] {f : α → 𝕜 → F},
      Continuous (Function.uncurry f) → Measurable fun p => deriv (f p.1) p.2 :=
  by sorry

This theorem, `measurable_deriv_with_param`, asserts that for every function `f` that maps a pair of types `α` and `𝕜` to type `F`, if the function `f` is continuous when uncurried, i.e., treated as a function on pairs `(α × 𝕜) → F`, then the function that maps a pair `p` to the derivative of `f` at the point `p.1` evaluated at `p.2` is measurable. Here, `𝕜` is a nontrivial normed field, `F` is a normed additive commutative group and also a normed space over `𝕜`, `α` is a topological space and a measurable space that is both open and complete, and `𝕜` and `F` are measurable spaces with `F` being a Borel space. Measurable refers to the property that the pre-image of every measurable set under the function is measurable. The derivative of a function at a point exists if the function is differentiable at that point and is zero otherwise.

If `f` is a continuous, uncurried function from the product of a measurable, open and complete topological space `α` and a nontrivial normed field `𝕜` to a normed additive commutative group and normed space `F` over `𝕜`, then the function that maps a pair `p` to the derivative of `f` at `p.1` evaluated at `p.2` is measurable.


theorem Pi.mulSingle_one :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → One (f i)] (i : I),
      Pi.mulSingle i 1 = 1 :=
  by sorry

This theorem states that for any type `I`, and any function `f` which maps elements of `I` to a type, given that equality is decidable on `I` and that all types `f i` for `i` in `I` have a multiplicative identity, for any element `i` of `I`, the function `Pi.mulSingle` applied to `i` and the multiplicative identity of `f i` is equivalent to the multiplicative identity function. In simpler terms, if you have a function that's like a vector of 1s, and you replace one of the entries with 1, you still have the same vector of 1s.

For any type `I` with decidable equality and each function `f : I →* X` from `I` to a type `X` with identity element `one_x : X`, the function `Pi.mulSingle : I → X → X` satisfies `Pi.mulSingle i one_x = one_x` for all `i : I`.


theorem Metric.cthickening_eq_iInter_cthickening' :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ},
      ∀ s ⊆ Set.Ioi δ,
        (∀ (ε : ℝ), δ < ε → Set.Nonempty (s ∩ Set.Ioc δ ε)) →
          ∀ (E : Set α), Metric.cthickening δ E = ⋂ ε ∈ s, Metric.cthickening ε E :=
  by sorry

This theorem states that for any type `α` equipped with a pseudo emetric space structure, and for any real number `δ`, if a set `s` is a subset of the interval `(δ, ∞)`, and for any `ε` greater than `δ` the intersection of `s` and the interval `(δ, ε]` is nonempty, then for any set `E` of type `α`, the `δ`-thickening of `E` is equivalent to the intersection over all `ε` in `s` of the `ε`-thickening of `E`. In simpler terms, this theorem essentially describes how the `δ`-thickening of a set `E` can be constructed from all the `ε`-thickenings of `E` for `ε` in a certain subset of `(δ, ∞)`. The term "thickening" in this context refers to the process of enlarging a set by including points that are within a certain distance from the set.

For any pseudo metric space `(α, d)` and subset `s` of `(δ, ∞)` such that the intersection of `s` with every `(δ, ε]` is nonempty, the `δ`-thickening of a set `E` is equal to the intersection of the `ε`-thickenings of `E` for all `ε` in `s`.


theorem cross_anticomm :
    ∀ {R : Type u_1} [inst : CommRing R] (v w : Fin 3 → R), -(crossProduct v) w = (crossProduct w) v := by sorry

The theorem `cross_anticomm` stipulates that for any commutative ring `R` and any two vectors `v` and `w` in `R^3`, the negative of the cross product of `v` and `w` is equal to the cross product of `w` and `v`. This essentially states that the cross product operation is anti-commutative, aligning with the known property in mathematics that the cross product of two vectors changes sign when the order of the vectors is switched.

For any commutative ring R and vectors v, w in R^3, the cross product of v and w is equal to the negative of the cross product of w and v. In other words, the cross product is anti-commutative.


theorem PrimeSpectrum.vanishingIdeal_closure :
    ∀ {R : Type u} [inst : CommSemiring R] (t : Set (PrimeSpectrum R)),
      PrimeSpectrum.vanishingIdeal (closure t) = PrimeSpectrum.vanishingIdeal t :=
  by sorry

This theorem states that for any commutative semiring 'R' and any set 't' of elements from the prime spectrum of 'R', the vanishing ideal of the closure of 't' is equal to the vanishing ideal of 't' itself. In simpler terms, the set of all prime ideals that vanish on the closure of 't' is the same as the set of all prime ideals that vanish on 't'. This result connects important concepts in commutative algebra and topology, specifically the notions of closure and vanishing ideals in the context of prime spectrums.

For any commutative semiring 'R' and subset 't' of its prime spectrum, the vanishing ideal of the closure of 't' equals the vanishing ideal of 't'.


theorem norm_deriv_eq_norm_fderiv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, ‖deriv f x‖ = ‖fderiv 𝕜 f x‖ :=
  by sorry

The theorem `norm_deriv_eq_norm_fderiv` asserts that for any type `𝕜` with a non-trivially normed field structure, any type `F` with a normed additive commutative group structure and a normed space over `𝕜`, any function `f` from `𝕜` to `F`, and any point `x` of type `𝕜`, the norm of the derivative of `f` at `x` is equal to the norm of `fderiv 𝕜 f x`. In other words, it states that the norms of the derivative of `f` at `x` and `fderiv 𝕜 f x` are equivalent.

For any normed field `𝕜`, normed additive commutative group `F`, normed space `F` over `𝕜`, function `f` from `𝕜` to `F`, and point `x` in `𝕜`, the norm of `f'(x)` is equal to the norm of `fderiv 𝕜 f x`.


theorem Ordinal.toPGame_leftMoves :
    ∀ (o : Ordinal.{u_1}), SetTheory.PGame.LeftMoves (Ordinal.toPGame o) = (Quotient.out o).α := by sorry

The theorem `Ordinal.toPGame_leftMoves` states that for every ordinal `o`, the set of allowable moves by Left in the pre-game corresponding to `o` is equal to the underlying set of the representative of the equivalence class of `o`. In other words, the set of possible left moves in the game derived from an ordinal matches the elements of that ordinal when we apply the axiom of choice to select a representative from its equivalence class.

The set of Left's allowable moves in the pre-game corresponding to an ordinal `o` equals the underlying set of `o`'s representative in its equivalence class under the axiom of choice.


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

This theorem states that for any three natural numbers `n`, `k`, and `m`, the difference between the sum of `n` and `k` and the sum of `m` and `k` equals the difference between `n` and `m`. In mathematical notation, this would be expressed as: \(n + k - (m + k) = n - m\). This theorem is a property of addition and subtraction on the natural numbers.

For any natural numbers `n`, `k`, and `m`, `(n + k) - (m + k) = n - m`.


theorem OrderIso.isLUB_preimage' :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set β} {x : β},
      IsLUB (⇑f ⁻¹' s) ((OrderIso.symm f) x) ↔ IsLUB s x :=
  by sorry

This theorem states that for any order isomorphism `f` between two partially ordered sets `α` and `β`, and for any set `s` of elements in `β` and any element `x` in `β`, `x` is a least upper bound of set `s` if and only if the inverse image of `x` under `f`, denoted as `OrderIso.symm f x`, is a least upper bound of the inverse image of `s` under `f`, denoted as `f ⁻¹' s`. Essentially, it says that the property of being a least upper bound is preserved under the inverse of an order isomorphism.

For any order isomorphism between two partially ordered sets, the inverse image of a least upper bound is a least upper bound for the inverse image under that isomorphism.


theorem CategoryTheory.ShortComplex.exact_map_iff_of_faithful :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (S : CategoryTheory.ShortComplex C)
      [inst_4 : CategoryTheory.ShortComplex.HasHomology S] (F : CategoryTheory.Functor C D)
      [inst_5 : CategoryTheory.Functor.PreservesZeroMorphisms F]
      [inst_6 : CategoryTheory.Functor.PreservesLeftHomologyOf F S]
      [inst_7 : CategoryTheory.Functor.PreservesRightHomologyOf F S] [inst_8 : CategoryTheory.Faithful F],
      CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.map S F) ↔ CategoryTheory.ShortComplex.Exact S :=
  by sorry

This theorem states that for any two types `C` and `D` that are categories, if `C` and `D` have zero morphisms and `S` is a short complex in `C` with homology, and if `F` is a functor from `C` to `D` that preserves zero morphisms and both left and right homology of `S`, then if `F` is faithful (meaning it injectively maps morphisms), the short complex `S` is exact if and only if the short complex obtained by applying the functor `F` to `S` is exact. This theorem hence links the exactness of a short complex in a category with the exactness of the image of that short complex under a faithful functor in another category.

For faithful functors preserving zero morphisms, zero homology, and exactness between two zero-morphism categories, the image of an exact short complex under the functor is exact.


theorem Mathlib.Combinatorics.SetFamily.CauchyDavenport._auxLemma.8 :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {m n : ℕ}, (↑m ≤ ↑n) = (m ≤ n) :=
  by sorry

The theorem states that for any type `α` which is an additive monoid with one, a partial order, has a covariance class defined for addition and less than or equal to relation, has zero less than or equal to one, and character zero, the inequality between two natural numbers `m` and `n` holds if and only if the inequality between their corresponding elements in `α` holds. This means that the ordering of `m` and `n` as natural numbers is preserved when they are viewed as elements of the type `α`.

For any additive monoid with one, partially ordered type `α` with zero less than one and character zero, the order relation between natural numbers corresponds to the order relation between their corresponding elements in `α`.


/-- `Finset.cons` version of `Finset.Ioi_insert`.  -/
theorem Finset.Ici_eq_cons_Ioi :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrderTop α] (a : α),
      Finset.Ici a = Finset.cons a (Finset.Ioi a) ⋯ :=
  by sorry

The theorem `Finset.Ici_eq_cons_Ioi` states that for any type `α` equipped with a partial order and a locally finite order at the top, and for any element `a` of the type `α`, the set of elements that are greater than or equal to `a` (`Finset.Ici a`) is the same as the set obtained by adding `a` to the set of elements that are strictly greater than `a` (`Finset.Ioi a`). This is represented as `Finset.cons a (Finset.Ioi a)`, where `Finset.cons` denotes the operation of creating a new set by adding an element to an existing set.

For any locally finite ordered type `α` and element `a` in `α`, `Finset.Ici a` equals `Finset.Ioi a` as sets.


/-- In an additive group action, the points fixed by `g` are also fixed by `g⁻¹` -/
theorem AddAction.fixedBy_neg :
    ∀ (α : Type u_1) {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (g : G),
      AddAction.fixedBy α (-g) = AddAction.fixedBy α g :=
  by sorry

The theorem `AddAction.fixedBy_neg` states that for any additive group action, the set of points fixed by an element `g` from the additive group `G` is the same as the set of points fixed by the additive inverse of `g` (denoted as `-g`). In other words, if an element `x` from the set `α` remains unchanged under the action of `g`, it will also remain unchanged under the action of `-g`. This is a property of group actions in the context of group theory.

For any additive group action, the set of points fixed by an element is equal to the set of points fixed by its additive inverse.


theorem inf_sSup_eq : ∀ {α : Type u} [inst : Order.Frame α] {s : Set α} {a : α}, a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b := by sorry

This theorem states that for any type `α` that forms a frame (a complete lattice in mathematics), any set `s` of elements of type `α`, and any element `a` of type `α`, the infimum (`⊓`) of `a` and the supremum (`sSup`) of `s` is equal to the supremum (`⨆`) of the infimum (`⊓`) of `a` and each element `b` in `s`. This is a property related to the distributivity of infimum over supremum in a frame.

For any frame (complete lattice) `α`, any set `s ⊆ α`, and any `a ∈ α`, the inf inf a and sup s = sup {inf a, b | b ∈ s}.


theorem LinearMap.map_le_range :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] {f : F} {p : Submodule R M}, Submodule.map f p ≤ LinearMap.range f :=
  by sorry

The theorem `LinearMap.map_le_range` states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` and `M₂` over the semirings `R` and `R₂` respectively, a ring homomorphism `τ₁₂` from `R` to `R₂` that is surjective, a function `f` of type `F` that behaves like a function from `M` to `M₂` with properties defined by `SemilinearMapClass`, and a submodule `p` of `M`, the image of the submodule `p` under the function `f` is a subset of or equal to the range of the linear map `f`. This essentially means that applying a semilinear map to a submodule will not yield elements outside of the map's range.

For any semiring homomorphism τ₁₂, modules M and M₂, a semilinear map f, and submodule p of M, the image of p under f is contained in the range of the linear map f.


theorem Real.ext_cauchy : ∀ {x y : ℝ}, x.cauchy = y.cauchy → x = y := by sorry

This theorem states that for any two real numbers `x` and `y`, if their Cauchy sequences are equal (i.e., `x.cauchy = y.cauchy`), then the real numbers themselves are also equal (`x = y`). This is a property linked to the construction of real numbers from Cauchy sequences of rational numbers, which ensures that distinct real numbers correspond to distinct Cauchy sequences.

If two real numbers have equal Cauchy sequences, then they are equal.


theorem AddSubgroup.ker_le_comap :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup N),
      AddMonoidHom.ker f ≤ AddSubgroup.comap f H :=
  by sorry

This theorem states that for any additive group homomorphism `f` from an additive group `G` to another additive group `N`, and any additive subgroup `H` of `N`, the additive kernel of `f` is a subgroup of the preimage of `H` under `f`. In other words, all elements of `G` that are mapped to `0` in `N` by `f` (the kernel of `f`) are included in the set of elements of `G` that are mapped to `H` in `N` by `f` (the preimage of `H` under `f`).

The kernel of an additive group homomorphism is a subgroup of its preimage under that homomorphism.


theorem Cardinal.lift_power :
    ∀ (a b : Cardinal.{u}), Cardinal.lift.{v, u} (a ^ b) = Cardinal.lift.{v, u} a ^ Cardinal.lift.{v, u} b := by sorry

The theorem `Cardinal.lift_power` states that for any two cardinal numbers `a` and `b` in a certain universe `u`, the lift operation of the cardinal number resulting from raising `a` to the power `b` to a higher universe `v` is equivalent to first individually lifting `a` and `b` to the higher universe `v` and then raising the lifted `a` to the power of the lifted `b`. In mathematical terms, this theorem asserts the equality `Cardinal.lift (a ^ b) = (Cardinal.lift a) ^ (Cardinal.lift b)` under the universe lift operation on cardinals.

The `Cardinal.lift_power` theorem in Lean 4 asserts that lifting a cardinal number `a` to the power `b` in a higher universe `v` is equivalent to first lifting `a` and `b` individually to `v` and then raising the lifted `a` to the power of the lifted `b`, i.e., `Cardinal.lift (a ^ b) = (Cardinal.lift a) ^ (Cardinal.lift b)`.


theorem MultilinearMap.map_zero :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : Nonempty ι], f 0 = 0 :=
  by sorry

The theorem `MultilinearMap.map_zero` states that for any semiring `R`, any types `ι`, `M₁`, and `M₂`, where `M₁` is indexed by `ι`, along with the appropriate algebraic structures (`AddCommMonoid` and `Module`), if we have a multilinear map `f` from `M₁` to `M₂` and `ι` is not empty, then `f` applied to the zero element of `M₁` produces the zero element in `M₂`. In other words, a multilinear map sends the zero vector to the zero vector.

For any semiring `R`, any type `ι` with non-empty indexed type `M₁`, and any multilinear map `f` from `M₁` to `M₂`, we have `f (0) = 0`, where `0` denotes the additive identity in `M₁` and `M₂`, respectively.


theorem Mathlib.ModelTheory.Substructures._auxLemma.3 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] (x : M), (x ∈ ⊤) = True := by
  sorry

This theorem states that for any first-order language `L` and any type `M` that has a structure for `L`, every element `x` of type `M` will always belong to the top element (`⊤`) of the lattice of substructures of `M`. In other words, `x` is always part of the whole structure `M` under any interpretation in the language `L`. This is a fundamental fact from the model theory, a branch of mathematical logic that deals with the relationship between a formal language and its interpretations.

For any first-order language L and any type M with an L-structure, every element x of M belongs to the top element (⊤) of the lattice of substructures of M.


theorem List.dvd_prod : ∀ {M : Type u_3} [inst : CommMonoid M] {a : M} {l : List M}, a ∈ l → a ∣ List.prod l := by sorry

This theorem, `List.dvd_prod`, states that for any commutative monoid `M`, given an element `a` of `M` and a list `l` of elements of `M`, if `a` is a member of `l`, then `a` divides the product of all elements in the list `l`. In mathematical terms, if $a \in l$, then $a$ divides $\prod_{i=1}^{n} l_i$, where $l_i$ are the elements of the list `l`.

If `a` is an element of a list `l` of commutative monoid elements, then `a` divides the product of all elements in `l`. In mathematical notation, if $a \in l$ and $l$ is a list of commutative monoid elements, then $a \mid \prod\_{i=1}^{n} l\_i$.


Hyperreal.IsSt.mul

theorem Hyperreal.IsSt.mul :
    ∀ {x y : ℝ*} {r s : ℝ}, Hyperreal.IsSt x r → Hyperreal.IsSt y s → Hyperreal.IsSt (x * y) (r * s) := by sorry

The theorem `Hyperreal.IsSt.mul` states that for all hyperreal numbers `x` and `y` and for all real numbers `r` and `s`, if `x` is infinitesimally close to `r` and `y` is infinitesimally close to `s` (i.e., `Hyperreal.IsSt x r` and `Hyperreal.IsSt y s`), then the product of `x` and `y` is infinitesimally close to the product of `r` and `s` (i.e., `Hyperreal.IsSt (x * y) (r * s)`).

In other words, this theorem states that the concept of being infinitesimally close is preserved under multiplication in the hyperreal numbers. It is essentially a formalization of the intuition that the product of two numbers close to two other numbers should be close to the product of those two other numbers.

The theorem `Hyperreal.IsSt.mul` asserts that the product of two infinitesimally close hyperreal numbers is infinitesimally close to the product of their real approximations.


/-- `annIdealGenerator 𝕜 a` is indeed a generator.  -/
theorem Polynomial.span_singleton_annIdealGenerator :
    ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] (a : A),
      Ideal.span {Polynomial.annIdealGenerator 𝕜 a} = Polynomial.annIdeal 𝕜 a :=
  by sorry

The theorem `Polynomial.span_singleton_annIdealGenerator` asserts that for any field `𝕜`, ring `A`, and algebra `𝕜 A` with an element `a` in `A`, the ideal generated by the singleton set containing the annihilating ideal's monic generator for `a` is equal to the annihilating ideal of `a` itself. In simpler terms, it states that the annihilating polynomial (a polynomial which when evaluated at `a` results in zero), if it exists, generates the same ideal as the annihilating ideal of `a`.

For any field `𝕜`, ring `A`, and algebra `𝕜 A` with `a` in `A`, the ideal generated by the monic annihilator of `a` is equal to the annihilating ideal of `a`.


/-- We will apply the above step recursively.  The following result
is used to ensure that the process terminates.  -/
theorem PNat.XgcdType.step_wf :
    ∀ (u : PNat.XgcdType), PNat.XgcdType.r u ≠ 0 → sizeOf (PNat.XgcdType.step u) < sizeOf u := by sorry

The theorem `PNat.XgcdType.step_wf` asserts for all values of type `PNat.XgcdType` denoted as `u`, if the remainder (`PNat.XgcdType.r u`) is not equal to 0, then the size of the `PNat.XgcdType` object produced by the `PNat.XgcdType.step` function on `u` is strictly smaller than the size of `u`. This theorem is crucial in ensuring that the recursive application of the `PNat.XgcdType.step` function eventually terminates.

For all `PNat.XgcdType` values `u`, if the remainder `PNat.XgcdType.r u` is non-zero, then the size of `PNat.XgcdType.step u` is strictly smaller than the size of `u`.


theorem Order.succ_le_succ :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, a ≤ b → Order.succ a ≤ Order.succ b := by
  sorry

The theorem `Order.succ_le_succ` states that for any type `α` which has a pre-order and successor relation, if an element `a` is less than or equal to an element `b`, then the successor of `a` is less than or equal to the successor of `b`. In mathematical terms, this can be stated as `∀ a, b ∈ α, a ≤ b → succ(a) ≤ succ(b)`, where `succ` denotes the successor function.

For any type `α` with pre-order and successor relation, the successor of a lesser element is lesser than the successor of a greater element: `∀ a b : α, a ≤ b → succ(a) ≤ succ(b)`.


/-- `b < sSup s` when there is an element `a` in `s` with `b < a`, when `s` is bounded above.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness above for one direction, nonemptiness and linear
order for the other one), so we formulate separately the two implications, contrary to
the `CompleteLattice` case. -/
theorem lt_csSup_of_lt :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a b : α},
      BddAbove s → a ∈ s → b < a → b < sSup s :=
  by sorry

The theorem `lt_csSup_of_lt` states that for any set `s` of elements of a type `α` that forms a conditionally complete lattice, and for any elements `a` and `b` of `α`, if `s` is bounded above, `a` is an element of `s`, and `b` is less than `a`, then `b` is less than the supremum of `s`. This is essentially an "if and only if" statement, however, the assumptions for the two implications are slightly different (one requires the set to be bounded above for one direction, while the other requires the set to be nonempty and have a linear order), so we state the two implications separately, as opposed to what we would do in the case of a complete lattice.

If `s` is a conditionally complete lattice, `a` is in `s`, `b` is in `s` and less than `a`, and `s` is bounded above, then `b` is less than the supremum of `s`.


theorem Finsupp.support_sum :
    ∀ {α : Type u_1} {β : Type u_7} {M : Type u_8} {N : Type u_10} [inst : DecidableEq β] [inst_1 : Zero M]
      [inst_2 : AddCommMonoid N] {f : α →₀ M} {g : α → M → β →₀ N},
      (Finsupp.sum f g).support ⊆ Finset.biUnion f.support fun a => (g a (f a)).support :=
  by sorry

The theorem `Finsupp.support_sum` states that for any types `α`, `β`, `M`, and `N`, given decidable equality on `β`, a zero element in `M`, and an additive commutative monoid structure on `N`, and for any function `f` from `α` to `M` and a function `g` from `α` and `M` to `β` with finite support, the support of the sum `Finsupp.sum f g` is a subset of the union of the supports of `g a (f a)` for each `a` in the support of `f`. This means that all elements contributing to the sum `Finsupp.sum f g` come from these supports.

For any decidably equal types `α`, `β`, additive commutative monoids `M` and `N`, given a zero element `0_M` in `M`, a function `g : α × M → β` with finite support, and a function `f : α → M`, the support of the sum `Finsupp.sum f g` is contained in the union of the supports of `g (a, f(a))` for all `a` in the support of `f`.


/-- The quotient norm of `0` is `0`.  -/
theorem norm_mk_zero : ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M), ‖0‖ = 0 := by sorry

This theorem states that for any given semi-normed additive commutative group `M` and any additive subgroup `S` of `M`, the quotient norm of the zero element is zero. In terms of mathematical language, it is expressed as ‖0‖ = 0, where ‖·‖ is the norm function.

For any semi-normed additive commutative group `M` and its subgroup `S`, the norm of the zero element is zero.


theorem Polynomial.Monic.nextCoeff_multiset_prod :
    ∀ {R : Type u} {ι : Type y} [inst : CommSemiring R] (t : Multiset ι) (f : ι → Polynomial R),
      (∀ i ∈ t, Polynomial.Monic (f i)) →
        Polynomial.nextCoeff (Multiset.prod (Multiset.map f t)) =
          Multiset.sum (Multiset.map (fun i => Polynomial.nextCoeff (f i)) t) :=
  by sorry

The theorem `Polynomial.Monic.nextCoeff_multiset_prod` states that for any commutative semiring `R` and any type `ι`, given a multiset `t` of `ι` and a function `f` from `ι` to `Polynomial R` such that every polynomial `f i` for `i` in `t` is monic, the second highest coefficient (or 0 for constants) of the product of the multiset obtained by mapping `f` on `t` is equal to the sum of the multisets obtained by mapping the function that gets the second highest coefficient from `f i` for each `i` in `t`. In simpler terms, this means that if we have a multiset of monic polynomials, the next coefficient of the product of these polynomials is the sum of the next coefficients of each polynomial in the multiset.

Given a commutative semiring R and a multiset t of indices, if f maps each i in t to a monic polynomial, then the second highest coefficient of the product of f(i) is the sum of the second highest coefficients of f(i) for all i in t.


theorem Decidable.or_iff_not_imp_left : ∀ {a b : Prop} [inst : Decidable a], a ∨ b ↔ ¬a → b := by sorry

This theorem, `Decidable.or_iff_not_imp_left`, states that for any propositions `a` and `b`, where `a` is a decidable proposition, the statement "`a` OR `b`" is logically equivalent to the statement "if not `a`, then `b`". This equivalence holds in classical logic. In LaTeX terms, it says that for any propositions $a$ and $b$ with $a$ being decidable, $a \lor b \iff \neg a \rightarrow b$.

For any decidable proposition `a` and proposition `b`, `a OR b` is logically equivalent to `if not a, then b` in classical logic. (Or, in mathematical notation, `a ∨ b ↔ ¬a → b`)


theorem PNat.pow_coe : ∀ (m : ℕ+) (n : ℕ), ↑(m ^ n) = ↑m ^ n := by sorry

This theorem states that for every positive natural number `m` and every natural number `n`, the process of first raising `m` to the power of `n` and then taking the result to the domain of natural numbers is equivalent to first taking `m` to the domain of natural numbers and then raising it to the power of `n`. In mathematical notation, this can be written as: ∀m∈ℕ+ and ∀n∈ℕ, (m^n) = m^n.

For all natural numbers `m` and `n`, raising `m` to the power of `n` in the domain of natural numbers is equal to first taking `m` to the domain of natural numbers and then raising it to the power of `n`. In mathematical notation, `(m^n) = m^n` for all `m ∈ ℕ+` and `n ∈ ℕ`.


theorem Finset.prod_Ico_succ_top :
    ∀ {M : Type u_2} [inst : CommMonoid M] {a b : ℕ},
      a ≤ b →
        ∀ (f : ℕ → M),
          (Finset.prod (Finset.Ico a (b + 1)) fun k => f k) = (Finset.prod (Finset.Ico a b) fun k => f k) * f b :=
  by sorry

This theorem, `Finset.prod_Ico_succ_top`, states that for any commutative monoid `M`, any natural numbers `a` and `b`, and any function `f` from natural numbers to `M`, if `a` is less than or equal to `b`, then the product of `f(k)` for each `k` in the finite set from `a` to `b+1`, is equal to the product of `f(k)` for each `k` in the finite set from `a` to `b`, multiplied by `f(b)`. This essentially says that adding one more term to the product (when `k` equals `b`) just multiplies the previous product by `f(b)`.

For any commutative monoid `M`, function `f` from natural numbers to `M`, and natural numbers `a` and `b` with `a <= b`, the product of `f(k)` for `k` in the finite set from `a` to `b+1` equals the product of `f(k)` for `k` in the finite set from `a` to `b` multiplied by `f(b)`.


theorem MeasureTheory.integral_pos_iff_support_of_nonneg_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f →
        MeasureTheory.Integrable f μ → (0 < ∫ (x : α), f x ∂μ ↔ 0 < ↑↑μ (Function.support f)) :=
  by sorry

This theorem states that for any measurable space `α` with a measure `μ` and a function `f : α → ℝ`, if the function `f` is non-negative almost everywhere (i.e., except on a set of measure zero), and if `f` is integrable with respect to `μ`, then the value of the integral of `f` over `α` is positive if and only if the measure of the support of `f` (the set of points where `f` is not zero) is positive. In other words, this theorem relates the positivity of the integral of a non-negative, integrable function to the positivity of the measure of its support.

A non-negative, integrable function on a measurable space with respect to a measure has a positive integral if and only if its support has positive measure.


theorem NormedSpace.expSeries_radius_pos :
    ∀ (𝕂 : Type u_1) (𝔸 : Type u_2) [inst : RCLike 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸],
      0 < FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸) :=
  by sorry

The theorem `NormedSpace.expSeries_radius_pos` asserts that for any types `𝕂` and `𝔸` where `𝕂` is a type that behaves like real-complex numbers (as expressed by `[inst : RCLike 𝕂]`), and `𝔸` is a normed ring and a normed algebra over `𝕂` (as expressed by `[inst_1 : NormedRing 𝔸]` and `[inst_2 : NormedAlgebra 𝕂 𝔸]`), the radius of convergence of the formal multilinear series `NormedSpace.expSeries 𝕂 𝔸` (which defines the exponential series for a multilinear map on `𝔸`) is strictly positive. In mathematical terms, it ensures that the exponential series converges within a non-zero radius around any point in the normed space `𝔸`.

The radius of convergence of the exponential series for a multilinear map on a normed algebra over a type behaving like real or complex numbers is strictly positive.


theorem HasCompactMulSupport.isCompact_range :
    ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : One β] {f : α → β}
      [inst_2 : TopologicalSpace β], HasCompactMulSupport f → Continuous f → IsCompact (Set.range f) :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` has a topological space structure and `β` is equipped with both a topological space structure and an operation `One`, if a function `f` from `α` to `β` has compact multiplicative support and is a continuous function, then the range of `f` is a compact set. In mathematical terms, if the closure of the multiplicative support of `f` is compact and `f` is a continuous function, then the set of all possible outputs of `f` is also compact.

If `f` is a continuous function from a compact, topologically closed subset of a topological space `α` to a topological space `β` with operation `One`, then the range of `f` is a compact set.


theorem List.attach_map_coe' :
    ∀ {α : Type u} {β : Type v} (l : List α) (f : α → β), List.map (fun i => f ↑i) (List.attach l) = List.map f l := by
  sorry

This theorem states that for any list of elements of type `α` (denoted `l`) and any function `f` from `α` to `β`, mapping the function `f` over the attached version of `l` (where each element is paired with a proof that it belongs to `l`) and then taking the underlying value (using `↑i`) gives the same result as directly mapping `f` over `l`. In other words, attaching proofs of membership to the elements of `l` does not change the result of mapping `f` over `l`.

For any list `l` of elements of type `α` and any function `f` from `α` to `β`, the application of `f` to the underlying values of the paired elements in the attached version of `l` is equal to the direct application of `f` to `l`.


theorem subset_Icc_csInf_csSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α},
      BddBelow s → BddAbove s → s ⊆ Set.Icc (sInf s) (sSup s) :=
  by sorry

The theorem `subset_Icc_csInf_csSup` states that for any set `s` of elements of some type `α`, where `α` forms a conditionally complete lattice, if `s` is both bounded from below (i.e., there exists a lower bound for `s`) and from above (i.e., there exists an upper bound for `s`), then `s` is a subset of the closed interval between the infimum (`sInf s`) and the supremum (`sSup s`) of `s`. In other words, all elements of `s` are greater than or equal to the infimum of `s` and less than or equal to the supremum of `s`.

If a set `s` of a conditionally complete lattice `α` has both a lower bound and an upper bound, then `s` is contained in the closed interval between the infimum and supremum of `s`.


Pretrivialization.linear

theorem Pretrivialization.linear :
    ∀ (R : Type u_1) {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
      [inst_2 : TopologicalSpace B] (e : Pretrivialization F Bundle.TotalSpace.proj) [inst_3 : AddCommMonoid F]
      [inst_4 : Module R F] [inst_5 : (x : B) → AddCommMonoid (E x)] [inst_6 : (x : B) → Module R (E x)]
      [inst_7 : Pretrivialization.IsLinear R e] {b : B},
      b ∈ e.baseSet → IsLinearMap R fun x => (↑e { proj := b, snd := x }).2 :=
  by sorry

The theorem `Pretrivialization.linear` states that for any semiring `R`, type `B`, type `F`, and a type `E` dependent on `B`, given the necessary topological space, additive commutative monoid and module structures, if a certain `Pretrivialization F Bundle.TotalSpace.proj` is linear (as specified by the `Pretrivialization.IsLinear R e` instance), then for any element `b` of type `B` that belongs to the base set of the pretrivialization `e`, the map that takes an element `x` and maps it to the second component of the pretrivialization applied to the pair `(b, x)` is a linear map over the semiring `R`.

Given a semiring `R`, a type `B`, a type `F`, a pretrivialization `e` over `B` with base type `B`, and assuming the necessary topological space, additive commutative monoid, and module structures, if `Pretrivialization.IsLinear R e` holds, then for each `b` in `B`, the map `x ↔> e b x.2` is a linear map over `R`.


theorem Monotone.isBoundedUnder_le_comp_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Nonempty β] [inst : LinearOrder β] [inst_1 : Preorder γ]
      [inst_2 : NoMaxOrder γ] {g : β → γ} {f : α → β} {l : Filter α},
      Monotone g →
        Filter.Tendsto g Filter.atTop Filter.atTop →
          (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f) :=
  by sorry

The theorem `Monotone.isBoundedUnder_le_comp_iff` states that for any types `α`, `β`, and `γ`, where `β` is a nonempty linear ordered set and `γ` is a preordered set with no maximum element, given a monotone function `g : β → γ` and a function `f : α → β`, and a filter `l` on `α` that represents a condition or trend, if `g` tends to infinity with the limit going to infinity, then the function `g` composed with `f` is eventually bounded under the relation `≤` with respect to `l` if and only if the function `f` is eventually bounded under the same relation with respect to `l`. In other words, the boundedness of the composition of `g` and `f` is equivalent to the boundedness of `f`, given the specified conditions on `g`.

Given a monotone function `g : β → γ` tending to infinity, a preordered set `γ` with no max, a filter `l` on `α`, and functions `g : β → γ` and `f : α → β`, the composition `g ∘ f` is eventually bounded under `≤` with respect to `l` if and only if `f` is.


theorem Finset.sum_eq_multiset_sum :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] (s : Finset α) (f : α → β),
      (Finset.sum s fun x => f x) = Multiset.sum (Multiset.map f s.val) :=
  by sorry

This theorem states that for any given type `α` and `β`, where `β` is a commutative additive monoid, a function `f` from `α` to `β`, and a finite set `s` of type `α`, the sum of the function `f` applied to all elements in set `s` (as expressed by `Finset.sum s f`) is equal to the sum of the multiset obtained by mapping the function `f` over all the elements of `s` (as expressed by `Multiset.sum (Multiset.map f s.val)`). In other words, taking the sum over a finite set or over a multiset obtained from that set yields the same result.

For any commutative additive monoid type `β`, function `f` from type `α` to `β`, and finite set `s` of type `α`, the sum of `Finset.sum s f` equals the sum of `Multiset.sum (Multiset.map f s.val)`.


/-- Convert between an equality with adding a group element to a point
and an equality of a subtraction of two points with a group
element.  -/
theorem eq_vadd_iff_vsub_eq :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ : P) (g : G) (p₂ : P),
      p₁ = g +ᵥ p₂ ↔ p₁ -ᵥ p₂ = g :=
  by sorry

This theorem, `eq_vadd_iff_vsub_eq`, establishes a relationship between addition and subtraction in the context of an additive group and an associated torsor. Specifically, for any given types `G` and `P` where `G` is an additive group and `P` is a torsor over `G`, and for any individual elements `p₁`, `g` and `p₂`, it asserts that `p₁` being equal to `g` added to `p₂` is equivalent to the subtraction of `p₂` from `p₁` resulting in `g`.

For any additive group `G` and torsor `P` over `G`, and for any elements `p₁`, `g`, and `p₂` in `G` and `P` respectively, `p₁ = g + p₂` if and only if `p₁ - p₂ = g`.


/-- We can push `eqToHom` to the left through families of morphisms.  -/
theorem CategoryTheory.eqToHom_naturality :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {β : Sort u_1} {f g : β → C} (z : (b : β) → f b ⟶ g b)
      {j j' : β} (w : j = j'),
      CategoryTheory.CategoryStruct.comp (z j) (CategoryTheory.eqToHom ⋯) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (z j') :=
  by sorry

This theorem states that in a category `C`, for any indexed family of morphisms `z : (b : β) → f b ⟶ g b` from `f b` to `g b` (for each `b` in `β`), the composition of the morphism `z j` and an `eqToHom` morphism associated with an equality `w : j = j'` is equal to the composition of an `eqToHom` morphism and the morphism `z j'`. This can be seen as a property of `eqToHom` being "natural" with respect to composition, meaning it can be "pushed" through the family of morphisms `z`.

For any indexed family of morphisms `z : (b : β) → f b → g b` in a category `C`, and for any equalities `w : j = j'` in `β`, the diagram commutes: `z j ∘ eqToHom w = eqToHom w ∘ z j'`.


theorem CategoryTheory.Limits.Sigma.ι_comp_map'_assoc :
    ∀ {β : Type w} {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C}
      [inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g] (p : α → β)
      (q : (a : α) → f a ⟶ g (p a)) (a : α) {Z : C} (h : ∐ g ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f a)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.map' p q) h) =
        CategoryTheory.CategoryStruct.comp (q a)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι g (p a)) h) :=
  by sorry

This theorem in Category Theory states that for any types `α` and `β` and any category `C`, given two functors `f : α → C` and `g : β → C` that both have coproducts, a function `p : α → β`, a natural transformation `q : (a : α) → f a ⟶ g (p a)` from `f` to `g` and another object `Z` in `C` with a morphism `h : ∐ g ⟶ Z`, the composition of the inclusion of `f a` into the coproduct of `f`, the map from the coproduct of `f` to the coproduct of `g` induced by `p` and `q`, and `h` is the same as the composition of `q a`, the inclusion of `g (p a)` into the coproduct of `g`, and `h`.

In simpler terms, it says that in the given context, we can either first map from `f a` to `g (p a)` and then include the result into the coproduct or we can first include `f a` into the coproduct and then map the entire coproduct over, and in both cases we end up with the same morphism from `f a` to `Z` after we compose with `h`.

For any categories C, types α and β, functors f : α → C and g : β → C with coproducts, natural transformation q : (a : α) → fa ➔ g (pa), and morphism h : ∐ g ➔ Z, the diagram commutes: fa ��� ∐ f ⟶ Z if and only if q a ⟶ g (pa) ⟶ h holds.


/-- Coercing the result of `Units.instInv` is the same as coercing first and applying the
nonsingular inverse.  -/
theorem Matrix.coe_units_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
      (A : (Matrix n n α)ˣ), ↑A⁻¹ = (↑A)⁻¹ :=
  by sorry

The theorem `Matrix.coe_units_inv` states that for any type `n` which is a `Fintype` and has `DecidableEq`, and any commutative ring `α`, if `A` is an invertible (nonsingular) matrix with entries in `α` and indexes in `n`, then the inverse of `A` when treated as an ordinary matrix (coerced from the unit group of matrices) is the same as the matrix inverse of `A`. This theorem connects the concept of inverse in the group of units with the concept of matrix inverse.

For any commutative ring `α`, if `A` is an invertible matrix over `α` with entries indexed by a `Fintype` with `DecidableEq`, then the coerced unit inverse of `A` equals its matrix inverse.