theorem TruncatedWittVector.truncate_wittVector_truncate :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} {R : Type u_1} [inst : CommRing R] {m : ℕ} (hm : n ≤ m)
      (x : WittVector p R), (TruncatedWittVector.truncate hm) ((WittVector.truncate m) x) = (WittVector.truncate n) x :=
  by sorry

The theorem `TruncatedWittVector.truncate_wittVector_truncate` states that for any natural number `p` which is prime, a natural number `n`, a type `R` that forms a commutative ring, and a natural number `m` such that `n` is less than or equal to `m`, the operation of truncating a Witt vector `x` to `m` entries and then applying `TruncatedWittVector.truncate` operation with respect to `m` is equivalent to directly truncating the Witt vector `x` to `n` entries. In other words, it doesn't matter whether we truncate a Witt vector to `m` entries first and then truncate it to `n` entries or if we directly truncate it to `n` entries; both operations yield the same result.

For any prime number p, commutative ring R, and natural numbers m (≥ n), the operation of truncating a Witt vector in R to m entries and then truncating it to n entries is equal to directly truncating it to n entries.


theorem SimpleGraph.Subgraph.connected_iff :
    ∀ {V : Type u} {G : SimpleGraph V} {H : SimpleGraph.Subgraph G},
      SimpleGraph.Subgraph.Connected H ↔ SimpleGraph.Subgraph.Preconnected H ∧ Set.Nonempty H.verts :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, and any subgraph `H` of `G`, `H` is connected if and only if `H` is preconnected and the set of vertices of `H` is not empty. A simple graph is said to be connected if there is a path between every pair of distinct vertices, and preconnected if for every pair of vertices, all the vertices between them are also connected. The theorem thus links the concepts of being connected, being preconnected, and having nonempty vertex set in the context of subgraphs of a simple graph.

A subgraph of a simple graph is connected if and only if it is preconnected and has a nonempty vertex set.


theorem PadicInt.valuation_nonneg : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]), 0 ≤ PadicInt.valuation x := by
  sorry

The theorem `PadicInt.valuation_nonneg` states that for any natural number `p` which is prime and for any `p`-adic integer `x`, the `p`-adic valuation of `x` is always non-negative. In other words, when you apply the `p`-adic valuation function to any `p`-adic integer, the result will always be a non-negative integer.

For any prime number p and p-adic integer x, the p-adic valuation of x is a non-negative integer.


theorem Set.encard_diff_add_encard_of_subset :
    ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → Set.encard (t \ s) + Set.encard s = Set.encard t := by sorry

This theorem states that for any two sets `s` and `t` of the same type `α`, if `s` is a subset of `t`, then the cardinality of the difference of `t` and `s` (denoted as `t \ s`), plus the cardinality of `s`, is equal to the cardinality of `t`. In mathematical terms, we can say that for all sets `s` and `t`, if `s` is a subset of `t`, then |`t \ s`| + |`s`| = |`t`|. This is analogous to the principle that the size of a set is equal to the size of a subset plus the size of the complement of the subset within the set.

For sets `s` and `t` of the same type with `s` a subset of `t`, the cardinality of `t` equals the cardinality of `t \ s` plus the cardinality of `s`.


theorem AddAction.exists_vadd_eq :
    ∀ (M : Type u_1) {α : Type u_6} [inst : VAdd M α] [inst_1 : AddAction.IsPretransitive M α] (x y : α),
      ∃ m, m +ᵥ x = y :=
  by sorry

This theorem states that for any type `M` and any type `α` where `α` has a vector addition operation with `M` and an associated pretransitive addition action, for any elements `x` and `y` of type `α`, there exists an element `m` of type `M` such that adding `m` to `x` using vector addition gives `y`. In mathematical terms, we could say: "Given any two elements in a space that supports vector addition, there exists a vector that can translate one element into the other."

For any type `α` with vector addition and pretransitive action, and for any `x` and `y` in `α`, there exists an element `m` in `M` such that `x + m = y`.


theorem schnirelmannDensity_congr' :
    ∀ {A : Set ℕ} [inst : DecidablePred fun x => x ∈ A] {B : Set ℕ} [inst_1 : DecidablePred fun x => x ∈ B],
      (∀ n > 0, n ∈ A ↔ n ∈ B) → schnirelmannDensity A = schnirelmannDensity B :=
  by sorry

This theorem states that if two sets of natural numbers, A and B, have the property that for every natural number greater than 0, that number is in A if and only if it is in B, then the Schnirelmann density of A is equal to the Schnirelmann density of B. The Schnirelmann density is defined as the infimum of the ratio of the size of the intersection of the set with the set of natural numbers from 1 through n and n itself, as n ranges over the positive naturals. Both sets, A and B, are assumed to have a decidable predicate, meaning it can be determined whether or not an element belongs to the set.

If sets A and B of natural numbers have the same element-wise property that every number greater than 0 is in A if and only if it is in B, then they have equal Schnirelmann densities.


theorem Matrix.nondegenerate_iff_det_ne_zero :
    ∀ {n : Type u_1} [inst : Fintype n] {A : Type u_4} [inst_1 : DecidableEq n] [inst_2 : CommRing A]
      [inst_3 : IsDomain A] {M : Matrix n n A}, Matrix.Nondegenerate M ↔ Matrix.det M ≠ 0 :=
  by sorry

The theorem `Matrix.nondegenerate_iff_det_ne_zero` states that for any finite type `n`, any type `A` with a decidable equality, a commutative ring structure, and a domain structure, and any matrix `M` with entries in `A` and indices in `n`, the matrix `M` is nondegenerate if and only if the determinant of `M` is not equal to zero. In the context of this theorem, a matrix `M` is defined as nondegenerate if for all vectors `v` not equal to the zero vector, there exists a vector `w` not equal to the zero vector such that the dot product of `v` and `M` multiplied by `w` is not equal to zero.

A square matrix over a commutative ring with unity and a decidable equality is nondegenerate if and only if its determinant is nonzero.


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

The theorem `Stream'.drop_succ` states that for any type `α`, any natural number `n`, and any stream `s` of type `α`, dropping the first `n+1` elements from `s` is equivalent to first removing the head of the stream (using `Stream'.tail`) and then dropping the first `n` elements from the resulting stream.

For any type α, natural number n, and stream s of type α, (drop (n+1) s) = tail (drop n s).


theorem Mathlib.Data.Set.Basic._auxLemma.56 : ∀ {α : Type u} {a : α} {s : Set α}, (s ∩ {a} = ∅) = (a ∉ s) := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.56` states that for any type `α`, an element `a` of type `α`, and a set `s` of type `α`, the intersection of set `s` and the singleton set containing `a` being an empty set is equivalent to `a` not being an element of set `s`. In other words, an element is not in a certain set if and only if the intersection of that set with a set containing only that element is empty.

For any type α and set s of α, the element a is not in s if and only if s ∩ {a} = ∅.


theorem Mathlib.Data.Set.Basic._auxLemma.57 :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1]
      [inst_2 : IsAntisymm α fun x x_1 => x ⊆ x_1], (a = b) = (a ⊆ b ∧ b ⊆ a) :=
  by sorry

This theorem states that for any type `α` that has a subset operation (`HasSubset α`) and is reflexive and antisymmetric with respect to this subset operation (`IsRefl α` and `IsAntisymm α`, respectively), two elements `a` and `b` of this type are equal if and only if `a` is a subset of `b` and `b` is a subset of `a`. In other words, in such a structure, two elements `a` and `b` are identical if they both include each other as subsets.

For any type `α` with `HasSubset α`, if `IsRefl α` and `IsAntisymm α` hold, then `a = b` if and only if `a ⊆ b` and `b ⊆ a`.


theorem MvPolynomial.coeff_sum :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {X : Type u_2} (s : Finset X) (f : X → MvPolynomial σ R)
      (m : σ →₀ ℕ),
      MvPolynomial.coeff m (Finset.sum s fun x => f x) = Finset.sum s fun x => MvPolynomial.coeff m (f x) :=
  by sorry

This theorem is about the coefficients of multivariate polynomials. It states that for any commutative semiring `R`, any type `σ` and `X`, any finite set `s` of type `X`, any function `f` from `X` to multivariate polynomials over `R` with variables indexed by `σ`, and any monomial `m`, the coefficient of the monomial `m` in the polynomial that is the sum (over the set `s`) of the polynomials `f(x)` is equal to the sum (over the set `s`) of the coefficients of the monomial `m` in the polynomials `f(x)`. In mathematical terms, this is saying that the coefficient of a particular term in a sum of polynomials is just the sum of the coefficients of that term in each of the polynomials.

For any commutative semiring `R`, given a finite set `s`, a type `X`, a function `f` from `X` to multivariate polynomials over `R` with variables indexed by `σ`, and a monomial `m`, the sum of the coefficients of `m` in the polynomials `f(x)` for all `x` in `s` equals the coefficient of `m` in the sum of the polynomials `f(x)` over `s`.


theorem TopologicalSpace.IsSeparable.of_subtype :
    ∀ {α : Type u} [t : TopologicalSpace α] (s : Set α) [inst : TopologicalSpace.SeparableSpace ↑s],
      TopologicalSpace.IsSeparable s :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure and any set `s` of `α`, if the subtype corresponding to `s` is a separable space, then `s` itself is a separable set in the topological space of `α`. In mathematics terms, this means that if we have a countable dense subset within the induced topology on `s`, then there exists a countable subset of `α` whose closure contains `s`.

If `s` is a separable subspace of the topological space `α`, then `s` is a separable subset of `α`.


theorem EReal.sign_coe : ∀ (x : ℝ), SignType.sign ↑x = SignType.sign x := by sorry

This theorem states that for any real number `x`, the sign of the coerced value of `x` (interpreted as an element of an extended real number type, via `↑x`) is the same as the sign of `x` itself. Here, the sign of a number is defined as 1 if the number is positive, -1 if the number is negative, and 0 if the number is neither positive nor negative (i.e., it is zero). In other words, the process of coercing a real number to an extended real number does not change its sign.

For any real number x, the sign of x and the sign of its coerced value ↑x as extended real numbers are equal.


theorem memℓp_zero_iff :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      Memℓp f 0 ↔ Set.Finite {i | f i ≠ 0} :=
  by sorry

The theorem `memℓp_zero_iff` states that for any type `α`, a function `f` from `α` to a normed addition commutative group `E`, `f` belongs to `ℓp` space with `p = 0` if and only if the set of all `i` in `α` for which `f(i)` is not equal to zero is finite. In other words, a function `f` has the `ℓp` property with `p = 0` exactly when `f` is finitely supported. Here, `ℓp` space is a generalization of sequence spaces including `ℓ∞` (the space of bounded sequences) and `ℓ1` (the space of absolutely convergent series), defined for any real number `p ≥ 0`.

A function from a type to a normed additive commutative group belongs to the ℓp space with p = 0 if and only if it has a finite number of non-zero values.


theorem CompleteLattice.isSupFiniteCompact_iff_all_elements_compact :
    ∀ (α : Type u_2) [inst : CompleteLattice α],
      CompleteLattice.IsSupFiniteCompact α ↔ ∀ (k : α), CompleteLattice.IsCompactElement k :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, the property that the lattice is sup-finite-compact is equivalent to all elements `k` of type `α` being compact. In other words, a complete lattice has the compactness property (i.e., any subset has a finite subset with the same supremum) if and only if every element in the lattice is a compact element (i.e., for any set with supremum above this element, there exists a finite subset with the supremum also above this element).

A complete lattice `α` is sup-finite-compact if and only if every element in `α` is compact.


theorem lipschitzWith_posPart : ∀ {α : Type u_1} [inst : NormedLatticeAddCommGroup α], LipschitzWith 1 posPart := by
  sorry

This theorem states that for any normed lattice-ordered additive commutative group `α`, the function `posPart`, which gives the positive part of an element in `α`, is Lipschitz continuous with constant `1`. In mathematical terms, this means that for any two elements `x` and `y` in the group, the distance (in the sense of the pseudo-metric on the group) between their positive parts is less than or equal to the distance between `x` and `y` itself.

For any normed lattice-ordered additive commutative group `α`, the function `posPart` is Lipschitz continuous with constant `1`, i.e., `||posPart x - posPart y|| ≤ ||x - y||` for all `x, y` in `α`.


theorem MonoidHom.coe_range :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      ↑(MonoidHom.range f) = Set.range ⇑f :=
  by sorry

The theorem `MonoidHom.coe_range` states that for any given monoid homomorphism `f` from a group `G` to a group `N`, the range of `f` when treated as a subgroup of `N` is equal to the set of all outputs of `f`. More formally, the set obtained by applying the monoid homomorphism `f` to all elements of the group `G` is exactly the same as the set of all possible outcomes of `f`.

The range of a group homomorphism as a subgroup of the target group is equal to the image of the homomorphism.


/-- The image of a bounded set under a Lipschitz map is bounded.  -/
theorem LipschitzWith.isBounded_image :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → ∀ {s : Set α}, Bornology.IsBounded s → Bornology.IsBounded (f '' s) :=
  by sorry

The theorem `LipschitzWith.isBounded_image` states that if a function `f` from a type `α` to a type `β` is Lipschitz continuous with a nonnegative real constant `K` and if a set `s` of type `α` is bounded, then the image of `s` under `f` is also bounded. Here, both `α` and `β` are equipped with pseudometric spaces and the concept of boundedness comes from a bornology on `α` and `β`. In mathematical terms, if a function satisfies a Lipschitz condition, it does not amplify the distance between two points in a set when mapping them from one space to another.

If `f` is a Lipschitz continuous function from the bounded set `s` in the pseudometric spaces `α` and `β` with constant `K`, then the image `f''(s)` is also a bounded subset of `β`.


theorem AbstractCompletion.uniformContinuous_compare :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg pkg' : AbstractCompletion α),
      UniformContinuous (AbstractCompletion.compare pkg pkg') :=
  by sorry

The theorem `AbstractCompletion.uniformContinuous_compare` states that for any type `α` that is equipped with a uniform space structure, and any two abstract completions `pkg` and `pkg'` of that uniform space, the comparison map between these two completions is uniformly continuous. In other words, if two points in the space of the first abstract completion are sufficiently close to each other, then their images under the comparison map in the space of the second abstract completion are also close to each other, regardless of their location in the original uniform space.

Given two abstract completions of a uniform space, the comparison map between them is uniformly continuous.


theorem Associates.dvd_of_mk_le_mk :
    ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, Associates.mk a ≤ Associates.mk b → a ∣ b := by sorry

The theorem `Associates.dvd_of_mk_le_mk` states that for any commutative monoid `α`, given any two elements `a` and `b` of `α`, if the canonical quotient map from `a` into the `Associates` of `α` is less than or equal to the canonical quotient map from `b` into the `Associates` of `α`, then `a` divides `b`. In other words, for any two elements of a commutative monoid, if their associated elements in the quotient group are in a certain order, then the original elements have a divisibility relationship.

If `α` is a commutative monoid and the canonical quotient of `a` in the `Associates` of `α` is less than or equal to the canonical quotient of `b` in the `Associates` of `α`, then `a` divides `b` in `α`.


theorem ContMDiffWithinAt.prod_mk_space :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {F' : Type u_14} [inst_8 : NormedAddCommGroup F']
      [inst_9 : NormedSpace 𝕜 F'] {s : Set M} {x : M} {n : ℕ∞} {f : M → E'} {g : M → F'},
      ContMDiffWithinAt I (modelWithCornersSelf 𝕜 E') n f s x →
        ContMDiffWithinAt I (modelWithCornersSelf 𝕜 F') n g s x →
          ContMDiffWithinAt I (modelWithCornersSelf 𝕜 (E' × F')) n (fun x => (f x, g x)) s x :=
  by sorry

This theorem, `ContMDiffWithinAt.prod_mk_space`, states that for a given non-trivially normed field `𝕜`, types `E`, `H`, `M`, `E'`, `F'` equipped with required structures, a set `s` of type `M`, an element `x` of type `M`, and `n` of type `ℕ∞` (which can be a natural number or infinity), if the functions `f : M → E'` and `g : M → F'` are continuously differentiable within the set `s` at the point `x` under the model with corners `I` and the respective model spaces `E'` and `F'`, then the function that maps `x` to the pair `(f x, g x)` in the product space `E' × F'` is also continuously differentiable at `x` within `s` under the model with corners `I` and the product model space `E' × F'`.

If functions `f` and `g` are continuously differentiable at a point `x` in set `s` of type `M` with respect to non-trivially normed field `𝕜`, then the function mapping `x` to `(f x, g x)` in `E' × F'` is also continuously differentiable at `x` within `s`.


theorem Mathlib.Algebra.Invertible.Defs._auxLemma.2 :
    ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any semigroup `G` and any elements `a`, `b`, and `c` of `G`, the operation `a * (b * c)` is equal to `(a * b) * c`. In other words, this theorem asserts the associativity of multiplication in the semigroup: the grouping of factors does not change the result of the multiplication. The semigroup is a set equipped with a binary operation that combines two elements to form a third element in a way that is associative.

For any semigroup G and all elements a, b, and c in G, the associativity of multiplication holds: a * (b * c) = (a * b) * c.


theorem bot_lt_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : Nontrivial α], ⊥ < ⊤ :=
  by sorry

This theorem states that, for any type `α` that has a partial order, a bounded order, and is nontrivial (i.e., it has at least two distinct elements), the least element (`⊥`) is less than the greatest element (`⊤`). In other words, in any nontrivial bounded partially ordered set, the smallest element is always less than the largest element.

In any nontrivial, bounded partially ordered set, the least element is less than the greatest element.


theorem Asymptotics.IsTheta.isBigO_congr_left :
    ∀ {α : Type u_1} {G : Type u_5} {E' : Type u_6} {F' : Type u_7} [inst : Norm G] [inst_1 : SeminormedAddCommGroup E']
      [inst_2 : SeminormedAddCommGroup F'] {k : α → G} {f' : α → E'} {g' : α → F'} {l : Filter α},
      f' =Θ[l] g' → (f' =O[l] k ↔ g' =O[l] k) :=
  by sorry

This theorem states that for any types `α`, `G`, `E'`, and `F'`, with `G` being a normed space and `E'` and `F'` being seminormed additive commutative groups, and given a filter `l` on `α`, and functions `k : α → G`, `f' : α → E'`, and `g' : α → F'`, if `f'` and `g'` are asymptotically equivalent, then `f'` is big O of `k` under the filter `l` if and only if `g'` is big O of `k` under the same filter.

In simpler terms, if two functions are asymptotically equivalent (they have the same growth rate), then any function that bounds one in the big O notation also bounds the other.

For types `α`, `G` (a normed space), `E'`, and `F'` (seminormed additive commutative groups), if `f'` and `g'` are asymptotically equivalent functions from `α` to `E'` and `F'` respectively, then `f'` is big O of `k` under filter `l` if and only if `g'` is big O of `k` under the same filter.


theorem UFModel.Models.rank_eq :
    ∀ {α : Type u_1} {arr : Array (UFNode α)} {n : ℕ} {m : UFModel n},
      UFModel.Models arr m → ∀ (i : ℕ) (h : i < Array.size arr), arr[i].rank = m.rank i :=
  by sorry

This theorem, `UFModel.Models.rank_eq`, states that for any type `α`, any array of Union-Find nodes `arr` of type `UFNode α`, any natural number `n`, and any Union-Find model `m` of size `n`, if the array `arr` models the Union-Find model `m` (as per the definition of `UFModel.Models`), then for every natural number `i` that is less than the size of the array `arr`, the rank of the `i`-th node in the array `arr` is equal to the rank of the `i`-th node in the Union-Find model `m`.

In simpler terms, it states that if an array of Union-Find nodes correctly models a Union-Find model, then each node in the array and the corresponding node in the model must have the same rank.

For any Union-Find model `m` of size `n` and any array `arr` of Union-Find nodes of type `UFNode α` modeling `m`, the rank of the `i`-th node in `arr` equals the rank of the `i`-th node in `m` for all `i` in the range `0` to `n-1`.


theorem Perfection.coeff_frobenius :
    ∀ {R : Type u₁} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p]
      (f : Ring.Perfection R p) (n : ℕ),
      (Perfection.coeff R p (n + 1)) ((frobenius (Ring.Perfection R p) p) f) = (Perfection.coeff R p n) f :=
  by sorry

The theorem `Perfection.coeff_frobenius` states that for any commutative semiring `R` and prime number `p` (where `R` has characteristic `p`), and for any element `f` of the 'perfection' of `R` (a structure related to the limit of repeated applications of the Frobenius map `x ↦ x^p`), and any natural number `n`, the `n`-th coefficient of the Frobenius image of `f` is equal to the `(n+1)`-th coefficient of `f`. In other words, applying the Frobenius map and then taking the `n`-th coefficient is the same as taking the `(n+1)`-th coefficient of the original element.

For any commutative semiring R of characteristic p, prime number p, and perfection element f, the n-th coefficient of the Frobenius image of f is equal to the (n+1)-th coefficient of f.


theorem Set.insert_diff_singleton_comm :
    ∀ {α : Type u} {a b : α}, a ≠ b → ∀ (s : Set α), insert a (s \ {b}) = insert a s \ {b} := by sorry

The theorem `Set.insert_diff_singleton_comm` states that for any type `α`, and any two elements `a` and `b` of that type such that `a` and `b` are not equal, and for any set `s` of type `α`, inserting `a` into the set difference of `s` and the singleton set containing `b` is the same as the set difference of inserting `a` into `s` and the singleton set containing `b`. In other words, the insertion of `a` and the removal of `b` commute with each other in any set `s`.

For any type `α` and elements `a ≠ b` of `α`, and sets `s : α`, `Set.insert a (s \ {b}) = (s \ {b}) \ {a}`.


theorem Nat.pow_one : ∀ (a : ℕ), a ^ 1 = a := by sorry

This theorem states that for any natural number 'a', 'a' raised to the power of 1 is equal to 'a' itself. In other words, the first power of any natural number is the number itself.


theorem AddSubgroup.characteristic_iff_comap_eq :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
      AddSubgroup.Characteristic H ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.comap (AddEquiv.toAddMonoidHom ϕ) H = H :=
  by sorry

The theorem `AddSubgroup.characteristic_iff_comap_eq` states that for any additive group `G` and any additive subgroup `H` of `G`, `H` is a characteristic subgroup if and only if for every additive equivalence (a bijective, addition-preserving function) `ϕ` from `G` to `G`, the preimage of `H` under the corresponding additive monoid homomorphism of `ϕ` is equal to `H` itself. In other words, a characteristic subgroup is one that is invariant under all automorphisms (self-isomorphisms) of the additive group.

A subgroup H of an additive group G is characteristic if and only if for all additive equivalences φ from G to G, φ⁻¹(H) = H.


theorem CompleteLattice.independent_of_dfinsupp_lsum_injective :
    ∀ {ι : Type u_1} {R : Type u_2} {N : Type u_5} [inst : DecidableEq ι] [inst_1 : Semiring R]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R N] (p : ι → Submodule R N),
      Function.Injective ⇑((DFinsupp.lsum ℕ) fun i => Submodule.subtype (p i)) → CompleteLattice.Independent p :=
  by sorry

This theorem, named `CompleteLattice.independent_of_dfinsupp_lsum_injective`, states that for any type `ι`, and any types `R` and `N` (with `R` being a semiring, `N` being an additive commutative monoid and also a module over `R`), and a function `p` mapping each element of type `ι` to a submodule of `N`, if the function induced by the direct sum of the submodules (obtained by applying each `p i` to the subtype of the submodule and then applying the linear sum of the direct-finite-support function) is injective, then the set of submodules `{p i : i in ι}` is independent in the complete lattice sense.

In simpler terms, if we have a collection of submodules such that no linear combination of elements from different submodules sums to zero unless all coefficients are zero, then these submodules are said to be independent.

If the function induced by the direct sum and linear sum of submodules mapping each index to a submodule is injective, then the collection of submodules is independent in the complete lattice sense.


theorem AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (K : ChainComplex C ℕ) (Δ : SimplexCategory),
      AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono K (CategoryTheory.CategoryStruct.id Δ) =
        CategoryTheory.CategoryStruct.id (K.X (SimplexCategory.len Δ)) :=
  by sorry

This theorem is a property of Dold-Kan correspondences in algebraic topology. It states that for any chain complex `K` indexed by natural numbers in a preadditive category `C`, and for any natural number `Δ` considered as an object in the simplex category, the termwise application of the monomorphism mapping function with respect to the identity morphism on `Δ` is equal to the identity morphism on the module `K.X` at the length of `Δ`. In other words, applying the morphism mapping function to the identity morphism does not change the module in the chain complex.

For any chain complex `K` in a preadditive category `C` and natural number `Δ`, the termwise application of the monomorphism mapping function with respect to the identity morphism on `Δ` is equal to the identity morphism on `K.X` at length `Δ`.


theorem Int.mul_lt_mul_of_pos_right : ∀ {a b c : ℤ}, a < b → 0 < c → a * c < b * c := by sorry

This theorem states that for all integers `a`, `b`, and `c`, if `a` is less than `b` and `c` is a positive number, then the product of `a` and `c` is less than the product of `b` and `c`. In other words, for positive integers `c`, multiplication by `c` preserves the order of other integers.

If `a` < `b` are integers and `c` is a positive number, then `ac` < `bc`.


theorem Fin.rev_involutive : ∀ {n : ℕ}, Function.Involutive Fin.rev := by sorry

The theorem `Fin.rev_involutive` states that for any natural number `n`, the `Fin.rev` function is involutive. In other words, applying the `Fin.rev` function twice to any input will return the original input. Specifically, `Fin.rev` is a function that maps `0` to `n-1`, `1` to `n-2`, and so forth up to `n-1` to `0` for any natural number `n`. So, the theorem essentially says that reversing the order twice brings you back to the original order.

The `Fin.rev` function on natural numbers is idempotent, i.e., `Fin.rev (Fin.rev n) = n` for all natural numbers `n`.


theorem Associates.out_mk :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (a : α),
      Associates.out (Associates.mk a) = normalize a :=
  by sorry

The theorem `Associates.out_mk` states that for any type `α` that has the structure of a cancel commutative monoid with zero and a normalization monoid, and for every element `a` of `α`, if we first create an associate of `a` using the `Associates.mk` function and then map it back to `α` using the `Associates.out` function, we end up with the normalized form of `a`. In other words, mapping an element to its associate and back again is equivalent to normalizing the element.

For any cancel commutative monoid with zero and normalization monoid in type `α`, the normalization of an element `a` is equal to `Associates.out (Associates.mk a)`.


Measurable.iterate

theorem Measurable.iterate :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α}, Measurable f → ∀ (n : ℕ), Measurable f^[n] := by sorry

The theorem `Measurable.iterate` states that for any type `α` and a measurable space `m` defined over that type, if a function `f` from `α` to `α` is measurable, then for any natural number `n`, the `n`-th iteration of the function `f` is also measurable. In mathematical terms, it means that if the preimage of every measurable set under `f` is measurable, then the preimage of every measurable set under the `n`-th iteration of `f` is measurable as well.

If `α` is a type with a measurable space `m`, and `f : α -> α` is measurable, then for every natural number `n`, the `n`-th iteration `f^n` of `f` is also measurable. That is, for every measurable set `A`, the preimage `f^(-1)(A)` under `f^n` is measurable.


theorem Array.get_push_lt :
    ∀ {α : Type u_1} (a : Array α) (x : α) (i : ℕ) (h : i < Array.size a),
      let_fun this := ⋯;
      (Array.push a x)[i] = a[i] :=
  by sorry

This theorem, called `Array.get_push_lt`, states that for any type `α`, given an array `a` of type `α`, an element `x` of type `α`, and a natural number `i` such that `i` is less than the size of the array `a`, if we push the element `x` onto the end of the array `a`, the `i`th element of the resulting array is the same as the `i`th element of the original array `a`. In other words, pushing an element onto the end of an array does not change the existing elements of the array.

For any type `α`, given an array `a:` `α`^`n`, an element `x:` `α`, and a natural number `i` < `n`, `(Array.push x a).nth i = a.nth i`.


PartialHomeomorph.IsImage.closure

theorem PartialHomeomorph.IsImage.closure :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t → PartialHomeomorph.IsImage e (closure s) (closure t) :=
  by sorry

The theorem `PartialHomeomorph.IsImage.closure` states that for any two topological spaces `X` and `Y`, and any partial homeomorphism `e` from `X` to `Y`, if a set `t` in `Y` is an image of a set `s` in `X` under the partial homeomorphism `e`, then the closure of `t` is also an image of the closure of `s` under the same partial homeomorphism. In other words, the closure of the image of a set under a partial homeomorphism is the image of the closure of that set under the same partial homeomorphism. The closure of a set is the smallest closed set containing it, and a partial homeomorphism is a bijection between subsets of the topological spaces that is continuous with a continuous inverse.

For any topological spaces X and Y, and a partial homeomorphism e from X to Y, the image under e of the closure of a set in X is equal to the closure of the image of that set in Y.


theorem Nat.sub_eq_of_eq_add : ∀ {a b c : ℕ}, a = c + b → a - b = c := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `a` is equal to the sum of `c` and `b`, then the result of subtracting `b` from `a` is equal to `c`. This essentially captures the reversal relationship between addition and subtraction in the natural numbers.

If `a` equals the sum of `b` and `c` (`a = b + c`), then `c` equals the difference between `a` and `b` (`c = a - b`).


Inducing.continuousVAdd

/-- Suppose that `N` additively acts on `X` and `M` continuously additively acts on `Y`.
Suppose that `g : Y → X` is an additive action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c +ᵥ x) = f c +ᵥ g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `AddActionHom`.
However, this version also works for `f = AddUnits.val`. -/
theorem Inducing.continuousVAdd :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : VAdd M X] [inst_4 : ContinuousVAdd M X] {g : Y → X} {N : Type u_5}
      [inst_5 : VAdd N Y] [inst_6 : TopologicalSpace N] {f : N → M},
      Inducing g → Continuous f → (∀ {c : N} {x : Y}, g (c +ᵥ x) = f c +ᵥ g x) → ContinuousVAdd N Y :=
  by sorry

This theorem, `Inducing.continuousVAdd`, states that if `N` additively acts on `X` and `M` continuously additively acts on `Y`, and there is an additive action homomorphism `g : Y → X` such that there exists a continuous function `f : N → M` satisfying the equation `g (c +ᵥ x) = f c +ᵥ g x` for all `c : N` and `x : Y`, then the additive action of `N` on `X` is also continuous. The theorem extends to scenarios where `f = id`, so `g` is an action homomorphism in the sense of `AddActionHom`, as well as to cases where `f = AddUnits.val`.

If `N` additively acts on `X`, `M` continuously additively acts on `Y`, there is an additive action homomorphism `g : Y → X`, and there exists a continuous function `f : N → M` such that `g (c + y) = f c + g y` for all `c : N` and `y : Y`, then the additive action of `N` on `X` is continuous.


IsIntegral.smul

theorem IsIntegral.smul :
    ∀ {B : Type u_3} {S : Type u_4} [inst : Ring B] {R : Type u_5} [inst_1 : CommSemiring R] [inst_2 : CommRing S]
      [inst_3 : Algebra R B] [inst_4 : Algebra S B] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R S B] {x : B}
      (r : R), IsIntegral S x → IsIntegral S (r • x) :=
  by sorry

The theorem `IsIntegral.smul` states that for any types `B`, `S` and `R`, assuming `B` is a ring, `R` is a commutative semiring, and `S` is a commutative ring. Moreover, we have defined the algebra structures from `R` to `B`, from `S` to `B` and from `R` to `S`, and that these algebra structures form a scalar tower (meaning, the scalar multiplication is compatible over these rings). Then given an element `x` of `B`, and another element `r` of `R`, if `x` is integral over `S`, then the scalar multiple, `r • x`, is also integral over `S`. In other words, given an element of an algebra that is a root of some monic polynomial, multiplying this element by a scalar from the underlying ring results in another element that is also a root of some monic polynomial.

If `x` is an integral element of the commutative ring `B` over the commutative ring `S`, then for any scalar `r` in the commutative semiring `R` with compatible algebra structures to `B` and `S`, the scalar multiple `r • x` is also an integral element of `S`.


theorem Set.Sum.elim_range :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → γ) (g : β → γ),
      Set.range (Sum.elim f g) = Set.range f ∪ Set.range g :=
  by sorry

The theorem `Set.Sum.elim_range` states that for any two types `α` and `β`, and a sort `γ`, given any two functions `f` from `α` to `γ` and `g` from `β` to `γ`, the range of the function `Sum.elim f g` (which is a function defined on the sum type `α ⊕ β` to `γ` by separately applying `f` and `g` on `α` and `β` respectively) is the union of the ranges of `f` and `g`. In other words, every element in the codomain `γ` that is mapped to by `Sum.elim f g` is also mapped to by either `f` or `g` when these functions are considered separately over their individual domains.

The range of the function `Sum.elim f g` on the sum type `α ⊕ β` is contained in the union of the ranges of `f` over `α` and `g` over `β`.


theorem ProbabilityTheory.IndepFun.mgf_add :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ} {X Y : Ω → ℝ},
      ProbabilityTheory.IndepFun X Y μ →
        MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * X ω)) μ →
          MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * Y ω)) μ →
            ProbabilityTheory.mgf (X + Y) μ t = ProbabilityTheory.mgf X μ t * ProbabilityTheory.mgf Y μ t :=
  by sorry

The theorem `ProbabilityTheory.IndepFun.mgf_add` in Probability Theory states that for any measurable space `Ω` with measure `μ` and real number `t`, and any two real-valued random variables `X` and `Y` on this space, if `X` and `Y` are independent and the functions `(fun ω => Real.exp (t * X ω))` and `(fun ω => Real.exp (t * Y ω))` are almost everywhere strongly measurable, then the moment generating function of the sum of `X` and `Y` at `t` is equal to the product of the moment generating functions of `X` and `Y` at `t`. In mathematical terms, this means if `X` and `Y` are independent, then $M_{X+Y}(t) = M_X(t) \cdot M_Y(t)$, where $M$ denotes the moment generating function.

For independent random variables X and Y on a measurable space with almost everywhere strongly measurable moment generating functions, their sum's moment generating function is equal to the product of their individual moment generating functions.


theorem Trivialization.coordChange_same_apply :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {b : B},
      b ∈ e.baseSet → ∀ (x : F), Trivialization.coordChange e e b x = x :=
  by sorry

The theorem `Trivialization.coordChange_same_apply` states that for any types `B`, `F`, and `Z`, where `B` and `F` are topological spaces and `Z` is a space with a `proj` function mapping to `B`, given a trivialization `e` of `F` with respect to `proj`, and any element `b` in the base set of `e`, the coordinate change induced by the same trivialization `e` at `b` is the identity for any element `x` of `F`. In other words, when the two trivializations in the coordinate change are the same, the coordinate change operation doesn't alter the input `x`.

Given a trivialization `e` of a topological space `F` over `B`, and `b` in `B`, the coordinate change of `e` at `b` is the identity function on `F`.


theorem BoxIntegral.Prepartition.biUnionIndex_mem :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I)
      {πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
      J ∈ BoxIntegral.Prepartition.biUnion π πi → BoxIntegral.Prepartition.biUnionIndex π πi J ∈ π :=
  by sorry

This theorem states that for any type `ι`, any boxes `I` and `J` of type `ι`, any prepartition `π` of the box `I`, and any function `πi` that associates to each box `J` a prepartition of `J`, if the box `J` is in the bi-union of `π` and `πi`, then the box returned by the function `biUnionIndex` applied to `π`, `πi`, and `J` is in the prepartition `π`.

If `π` is a prepartition of type `ι`, `J` is a box of type `ι`, and `J` is in the bi-union of `π` and the image of `πi` on `J`, then the index of `J` in the bi-union `π ⋃ (π i)` is in the prepartition `π`.


/-- The pushout provided by `HasPushout f g` fits into an `IsPushout`.  -/
theorem CategoryTheory.IsPushout.of_hasPushout :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y : C} (f : Z ⟶ X) (g : Z ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasPushout f g],
      CategoryTheory.IsPushout f g CategoryTheory.Limits.pushout.inl CategoryTheory.Limits.pushout.inr :=
  by sorry

This theorem states that for any category `C` and any objects `Z`, `X`, `Y` in `C`, if we have morphisms `f : Z ⟶ X` and `g : Z ⟶ Y` and the pushout of `f` and `g` exists, then the structure formed by `f`, `g` and the inclusions `CategoryTheory.Limits.pushout.inl` and `CategoryTheory.Limits.pushout.inr` into the pushout is indeed an `IsPushout`. In terms of category theory, it means that the specific choice of colimiting cocone provided by the `HasPushout` structure is actually a pushout.

Given any category `C` and objects `Z`, `X`, `Y` with morphisms `f : Z ⟶ X` and `g : Z ⟶ Y` having a pushout, the resulting structure formed by `f`, `g`, and the inclusion morphisms into the pushout is an isomorphism of categories, i.e., a pushout.


theorem StrictMonoOn.eq_iff_eq :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → ∀ {a b : α}, a ∈ s → b ∈ s → (f a = f b ↔ a = b) :=
  by sorry

The theorem `StrictMonoOn.eq_iff_eq` states that for any types `α` and `β` where `α` is a linear order and `β` is a preorder, for any function `f` from `α` to `β`, and for any set `s` of elements of type `α`, if the function `f` is strictly monotone on the set `s`, then for all `a` and `b` in `s`, `f(a)` equals `f(b)` if and only if `a` equals `b`. In other words, a strictly monotone function on a set does not map different elements in the set to the same value.

A strictly monotone function from a linear order to a preorder maps distinct elements to distinct images.


SimpleGraph.ComponentCompl.ind

theorem SimpleGraph.ComponentCompl.ind :
    ∀ {V : Type u} {G : SimpleGraph V} {K : Set V} {β : SimpleGraph.ComponentCompl G K → Prop},
      (∀ ⦃v : V⦄ (hv : v ∉ K), β (SimpleGraph.componentComplMk G hv)) → ∀ (C : SimpleGraph.ComponentCompl G K), β C :=
  by sorry

The theorem `SimpleGraph.ComponentCompl.ind` is a principle of induction for components outside a given set of vertices in a simple graph. Given a type `V`, a simple graph `G` on `V`, a set `K` of `V`, and a property `β` that applies to components outside of `K`, if `β` holds for all vertices `v` that do not belong to `K` when they are considered as such components (constructed with `SimpleGraph.componentComplMk`), then `β` holds for any component outside of `K` in the graph. In other words, if the property holds for every individual vertex not in `K` when we consider it as a component outside `K`, then the property holds for any connected component outside of `K`.

If a property holds for all vertices not in a set `K` when considered as components outside `K` in a simple graph `G`, then the property holds for any component outside of `K` in `G`.


theorem List.foldl_eq_foldlM :
    ∀ {β : Type u_1} {α : Type u_2} (f : β → α → β) (b : β) (l : List α), List.foldl f b l = List.foldlM f b l := by
  sorry

The theorem `List.foldl_eq_foldlM` states that for any types `β` and `α`, any function `f` from `β` and `α` to `β`, any value `b` of type `β`, and any list `l` of type `List α`, the result of `List.foldl` (which folds a function over a list from the left) applied to `f`, `b` and `l` is equal to the result of `List.foldlM` (which is a monadic version of foldl) applied to the same arguments. Essentially, this theorem demonstrates that the traditional and the monadic version of left fold on a list are equivalent.

For any type `β`, function `f` from `β` x `α` to `β`, value `b` of type `β`, and list `l` of type `List α`, `List.foldl f b l` equals `List.foldlM (fun x acc => f x acc) b l`.


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

This theorem, `CategoryTheory.ShortComplex.leftHomologyMap_comp`, states that for any type `C` which forms a category and has zero morphisms, and any three short complexes `S₁`, `S₂`, and `S₃` in this category that have left homologies, the left homology map of the composition of two morphisms, `φ₁` from `S₁` to `S₂` and `φ₂` from `S₂` to `S₃`, is equal to the composition of the left homology map of `φ₁` and the left homology map of `φ₂`. That is, the left homology map is compatible with the composition of morphisms. This is an essential property in category theory, encapsulating the idea that homology behaves well with respect to morphism composition.

Given any three short complexes `S₁`, `S₂`, and `S₃` in a category `C` with zero morphisms, and morphisms `φ₁ : S₁ -> S₂` and `φ₂ : S₂ -> S₃`, the left homology map of their composition `φ₁ ∘ φ₂` is equal to the composition of their left homology maps `L⁰(φ₁) ∘ L⁰(φ₂)`.


theorem Real.hasStrictDerivAt_const_rpow :
    ∀ {a : ℝ}, 0 < a → ∀ (x : ℝ), HasStrictDerivAt (fun x => a ^ x) (a ^ x * Real.log a) x := by sorry

This theorem states that for any real number `a` greater than `0`, and for any real number `x`, the function `f(x) = a^x` has a strict derivative at the point `x`. The derivative is given by the expression `a^x * Real.log a`. In mathematical notation, this would be written as `f'(x) = a^x * log(a)`. This means that the rate of change of the function `a^x` at any point `x` is `a^x` times the natural logarithm of `a`.

For any real number `a > 0`, the function `f(x) = a^x` has a strict derivative at `x`, given by `f'(x) = a^x * log(a)`.


theorem CategoryTheory.MorphismProperty.map_respectsIso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C)
      (F : CategoryTheory.Functor C D),
      CategoryTheory.MorphismProperty.RespectsIso (CategoryTheory.MorphismProperty.map P F) :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.map_respectsIso` states that for any categories `C` and `D`, given a morphism property `P` on `C` and a functor `F` from `C` to `D`, the property `P` mapped to `D` by the functor `F` respects isomorphisms. In other words, if a morphism in `D` is obtained by applying the functor `F` on a morphism in `C` that satisfies property `P`, and it is composed with an isomorphism, then the resulting morphism still satisfies the mapped property. This theorem is important in category theory as it ensures that certain properties of morphisms are preserved under functors when dealing with isomorphisms.

If `F : C -> D` is a functor, `P : Pproperty C` is a morphism property on `C`, and `f : C -> Ob D` is a morphism in `C` with `P f`, then for any isomorphism `g : Ob D -> Ob D`, `P (F g . F) f` holds.


theorem Irrational.div_cases : ∀ {x y : ℝ}, Irrational (x / y) → Irrational x ∨ Irrational y := by sorry

The theorem `Irrational.div_cases` states that for all real numbers `x` and `y`, if the quotient of `x` divided by `y` is an irrational number, then either `x` or `y` must be an irrational number. In other words, it is impossible to divide two rational numbers and get an irrational number as a result.

If the quotient of real numbers `x` and `y` is an irrational number, then at least one of `x` and `y` is irrational.


/-- If a unit `a` semiconjugates `x` to `y`, then `a⁻¹` semiconjugates `y` to `x`.  -/
theorem SemiconjBy.units_inv_symm_left :
    ∀ {M : Type u_1} [inst : Monoid M] {a : Mˣ} {x y : M}, SemiconjBy (↑a) x y → SemiconjBy (↑a⁻¹) y x := by sorry

The theorem `SemiconjBy.units_inv_symm_left` states that for any type `M` equipped with a monoid structure, if a unit `a` semiconjugates `x` to `y`, then the inverse of `a`, denoted `a⁻¹`, semiconjugates `y` to `x`. In other words, if `a * x = y * a` holds, then `a⁻¹ * y = x * a⁻¹` also holds. The concept of semiconjugation is related to the commutative property but applied to different elements.

If `a` semiconjugates `x` to `y` in a monoid `M`, then the inverse of `a` semiconjugates `y` to `x`: `a * x = y * a` implies `a⁻¹ * y = x * a⁻¹`.


theorem Filter.map_map₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : α → β → γ)
      (n : γ → δ), Filter.map n (Filter.map₂ m f g) = Filter.map₂ (fun a b => n (m a b)) f g :=
  by sorry

The theorem `Filter.map_map₂` states that for all types `α`, `β`, `γ`, and `δ`, and for any filters `f` on `α` and `g` on `β`, if we have a binary function `m` from `α` and `β` to `γ`, and a function `n` from `γ` to `δ`, then mapping `n` over the filter obtained by applying the binary map `map₂` of `m` on `f` and `g` is equal to applying the binary map `map₂` of the function `(a, b) ↦ n (m a b)` directly on `f` and `g`. Essentially, this theorem shows that the operation of filter mapping is compatible with composition of functions.

For all types `α`, `β`, `γ`, `δ`, filters `f` on `α` and `g` on `β`, and functions `m : α → β → γ` and `n : γ → δ`, `map₂ n (map₂ m (f : Filter α) (g : Filter β)) = map₂ (λ a b, n (m a b)) (f) (g)`.


theorem CategoryTheory.ShortComplex.Exact.mono_g' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S →
        ∀ (h : CategoryTheory.ShortComplex.RightHomologyData S),
          CategoryTheory.Mono (CategoryTheory.ShortComplex.RightHomologyData.g' h) :=
  by sorry

This theorem states that for any category 'C' with zero morphisms, any short complex 'S' in 'C', and if 'S' is exact, then for any right homology data 'h' of 'S', the morphism 'g'' induced by 'S.g' and the fact that 'h.Q' is a cokernel of 'S.f' is a monomorphism. Essentially, in the context of category theory, this theorem shows that the particular morphism 'g'' is left-cancellative, i.e., for any morphisms 'f' and 'f'' such that 'g''∘f = g''∘f'', we have 'f = f'''. This result is related to the structure and properties of short complexes in category theory.

In a category with zero morphisms, if a short exact complex has exact homology, then the induced morphism from the differential of a map that is a cokernel of another map is a monomorphism.


theorem SemiNormedGroupCat₁.hom_ext : ∀ {M N : SemiNormedGroupCat₁} (f g : M ⟶ N), ⇑f = ⇑g → f = g := by sorry

This theorem states that for any two objects `M` and `N` in the category `SemiNormedGroupCat₁` (which is equipped with the category structure consisting only of the norm non-increasing maps), if two morphisms `f` and `g` from `M` to `N` are such that their underlying functions (obtained by applying the coercion to function, `⇑`) are equal, then the morphisms `f` and `g` themselves are equal. In other words, this expresses the principle that morphisms in `SemiNormedGroupCat₁` are determined by their action on elements.

In the category of semi-normed groups `SemiNormedGroupCat₁`, two morphisms with equal underlying functions are equal.


theorem Sym2.mem_mk_right : ∀ {α : Type u_1} (x y : α), y ∈ s(x, y) := by sorry

This theorem, `Sym2.mem_mk_right`, asserts that for any type `α` and any two elements `x` and `y` of that type, `y` is a member of the unordered pair `(x, y)`. In other words, the theorem guarantees that if we create an unordered pair from two elements, the second element will always be considered a member of that pair.

For any type `α` and any `x, y : α`, `y` is a member of the unordered pair `{x, y}`.


theorem seqClosure_eq_closure :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : FrechetUrysohnSpace X] (s : Set X),
      seqClosure s = closure s :=
  by sorry

This theorem states that for any set `s` in a Frechet-Urysohn space `X`, the sequential closure of `s` is equal to the closure of `s`. In other words, in a Frechet-Urysohn space, a point is in the closure of a set if and only if it is the limit of a sequence of points in that set. A Frechet-Urysohn space is a topological space where this property holds true; not all topological spaces have this characteristic.

In a Frechet-Urysohn space, the sequential closure of a set equals its closure.


theorem Mathlib.Algebra.Function.Support._auxLemma.4 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {s : Set α},
      (Function.support f ⊆ s) = ∀ (x : α), f x ≠ 0 → x ∈ s :=
  by sorry

This theorem states that for any given types `α` and `M`, where `M` is a type with a zero element, and for any function `f` from `α` to `M` and any set `s` of elements of type `α`, the support of the function `f` (i.e., the set of points `x` in `α` where `f(x)` is not zero) is a subset of `s` if and only if for every element `x` in `α`, if `f(x)` is not zero, then `x` is an element of `s`. The support of a function is used in this theorem to denote the set of points where the function does not equal zero.

For any function from type `α` to a type `M` with a zero element, the support of the function is subset of a given set `s` if and only if every non-zero value of the function belongs to `s`.


theorem Mathlib.Algebra.BigOperators.Finprod._auxAddLemma.6 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {x : α}, (x ∈ Function.support f) = (f x ≠ 0) := by
  sorry

This theorem states that for any type `α` and any type `M` that has a zero element, given a function `f` from `α` to `M` and an element `x` of type `α`, `x` is in the support of the function `f` if and only if the value of `f` at `x` is not equal to zero. In terms of mathematics, if we consider `f` as a function and `x` as a point, this theorem asserts that `x` belongs to the support of `f` precisely when `f(x)` is non-zero.

The support of a function `f` from type `α` to type `M` with zero element, equals the set `{x : α | f x ≠ 0}`.


/-- The `f` argument to `permutationsAux2` when `r = []` can be eliminated.  -/
theorem List.map_permutationsAux2 :
    ∀ {α : Type u_1} {β : Type u_2} (t : α) (ts ys : List α) (f : List α → β),
      List.map f (List.permutationsAux2 t ts [] ys id).2 = (List.permutationsAux2 t ts [] ys f).2 :=
  by sorry

This theorem states that for any types `α` and `β`, and for any list `ts` and `ys` of type `α`, any element `t` of type `α`, and any function `f` from a list of `α` to `β`, the act of first applying `List.permutationsAux2` with `t`, `ts`, an empty list, `ys`, and the identity function as arguments, and then mapping the function `f` over the result, is the same as applying `List.permutationsAux2` directly with `f` as the last argument. Essentially, the function `f` can be integrated directly into `List.permutationsAux2` when the input list `r` is empty.

For any types `α` and `β`, and any lists `ts` and `ys` of type `α`, any element `t` of type `α`, and any function `f` from `α` to `β`, the application of `List.permutationsAux2` with `t`, `ts`, an empty list, `ys`, and the identity function, then mapping `f` over the result, equals applying `List.permutationsAux2` directly with `f` as the last argument.


theorem iSup_option :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : Option β → α),
      ⨆ o, f o = f none ⊔ ⨆ b, f (some b) :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is a complete lattice, and a function `f` mapping from an option of `β` to `α`, the supremum (the least upper bound or `⨆`) over all options of the function `f` is equal to the supremum of `f` at `none` and the supremum of `f` at `some b` for all `b` in `β`. Essentially, it splits the supremum over all options of `β` into two parts: one where the option is `none`, and one where the option is `some b`.

For any complete lattice `α` and a function `f` from the option type `Option β` to `α`, the supremum of `f` over all options equals the supremum of `f` at `none` plus the supremum of `f` over all `some b` in `β`.


theorem Finset.sup'_inf_distrib_left :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α) (a : α),
      a ⊓ Finset.sup' s hs f = Finset.sup' s hs fun i => a ⊓ f i :=
  by sorry

The theorem `Finset.sup'_inf_distrib_left` states that for any non-empty finite set `s` of type `ι`, a distributive lattice `α`, a function `f : ι → α`, and an element `a` of `α`, the infimum of `a` and the supremum of the image of `s` under `f` is equal to the supremum of the image of `s` under the function `(i => a ⊓ f i)`. In other words, this theorem guarantees the left distributivity of the infimum operation over the supremum operation for any non-empty finite set in a distributive lattice.

For any non-empty finite set `s`, distributive lattice `α`, function `f : ι → α`, and element `a` in `α`, `inf a ⊤ (map f s) = ⊤ (map (λ i, a ⊓ f i) s)`.


/-- In any preadditive category,
composable morphisms `f g` are exact iff they compose to zero and the homology vanishes.
 -/
theorem CategoryTheory.Preadditive.exact_iff_homology'_zero :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasImages V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] [inst_3 : CategoryTheory.Preadditive V]
      [inst_4 : CategoryTheory.Limits.HasKernels V] [inst_5 : CategoryTheory.Limits.HasCokernels V] {A B C : V}
      (f : A ⟶ B) (g : B ⟶ C),
      CategoryTheory.Exact f g ↔ ∃ (w : CategoryTheory.CategoryStruct.comp f g = 0), Nonempty (homology' f g w ≅ 0) :=
  by sorry

The theorem `CategoryTheory.Preadditive.exact_iff_homology'_zero` states that for any preadditive category with objects `A`, `B`, and `C`, and morphisms `f` from `A` to `B` and `g` from `B` to `C`, the morphisms `f` and `g` are exactly composable if and only if the composition of `f` and `g` is equal to zero and there exists a homology of `f` and `g` that is isomorphic to zero. This theorem is relevant in the context of category theory, where it provides a condition for the exactness of two composable morphisms in a preadditive category.

In a preadditive category, morphisms `f` from `A` to `B` and `g` from `B` to `C` are exactly composable if and only if their composition `g ∘ f` is zero and there exists an isomorphism of their homologies to the zero object.


theorem InnerProductSpace.Core.inner_zero_left :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] (x : F), ⟪0, x⟫_𝕜 = 0 :=
  by sorry

This theorem, `InnerProductSpace.Core.inner_zero_left`, states that for any type `𝕜` that behaves like a real or complex number (indicated by `RCLike 𝕜`), and any type `F` that is an additive commutative group and a module over `𝕜` (indicated by `AddCommGroup F` and `Module 𝕜 F`), if we have an inner product space defined on `𝕜` and `F` (indicated by `InnerProductSpace.Core 𝕜 F`), then the inner product of the zero vector and any vector `x` in this space is zero. In mathematical terms, this is expressing the property that inner product of zero vector with any vector is zero:  ⟨0, x⟩ = 0.

For any type `𝕜` behaving like a real or complex number, any additive commutative group and `𝕜`-module `F` with an inner product structure, the inner product of the zero vector and any vector in `F` is zero.


theorem MeasureTheory.Measure.measurable_measure :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : α → MeasureTheory.Measure β},
      Measurable μ ↔ ∀ (s : Set β), MeasurableSet s → Measurable fun b => ↑↑(μ b) s :=
  by sorry

This theorem, `MeasureTheory.Measure.measurable_measure`, states that for any two types `α` and `β` equipped with measurable spaces, and a function `μ` from `α` to `MeasureTheory.Measure` of `β`, `μ` is measurable if and only if for every set `s` of type `β` that is a measurable set, the function that maps each element `b` to the measure of `s` under `μ b` is also measurable. Here, "measurable" means that the preimage of any measurable set under the function is also a measurable set.

A function `μ:` `α` `→` `MeasureTheory.Measure` `β` is measurable if and only if for every measurable set `s` in `β`, the function that maps each `b` in `α` to the measure of `s` under `μ b` is also measurable.


theorem Set.nonempty_of_encard_ne_zero : ∀ {α : Type u_1} {s : Set α}, Set.encard s ≠ 0 → Set.Nonempty s := by sorry

This theorem states that for any type `α` and a set `s` of type `α`, if the cardinality (or size) of the set `s` is not zero, then the set `s` is nonempty. In other words, if a set has a non-zero number of elements, it must contain at least one element.

If a set is non-empty, then its cardinality is positive.


theorem biSup_sup :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α} {a : α},
      (∃ i, p i) → (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a :=
  by sorry

This theorem, `biSup_sup`, states that for any type `α` that forms a complete lattice, for any indexed predicate `p : ι → Prop`, for any function `f : (i : ι) → p i → α` that maps an index and a proof of that index satisfying the predicate to an element of the lattice, and for any element `a : α` of the lattice, if there exists an index for which the predicate holds, then the supremum (greatest lower bound) of the function `f` applied to all indices and proofs, joined with `a`, is equal to the supremum of the function `f` applied to all indices and proofs, each joined with `a`.

In mathematical terms, it says that for a complete lattice `α`, a predicate `p` over an index set `ι`, a function `f` mapping indices and proofs of the predicate to `α`, and an element `a` in `α`, if there is some index `i` for which `p(i)` is true, then $\bigvee_i (\bigvee_{h : p(i)} f(i, h) \vee a) = \bigvee_i \bigvee_{h : p(i)} (f(i, h) \vee a)$.

For any complete lattice `α`, index set `ι`, predicate `p : ι → Prop`, function `f : (i : ι) → Prop → α`, and `a : α`, if there exists an `i` with `p(i)` such that sup(`f`(i,.)) exists, then sup(`f`(i,._) ⊎ a) = sup(∋ i, p(i) → f(i,._) ⊎ a).


theorem Set.Ioi_inter_Ioi :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, Set.Ioi a ∩ Set.Ioi b = Set.Ioi (a ⊔ b) := by sorry

The theorem `Set.Ioi_inter_Ioi` states that for any type `α` with a linear order and any two elements `a` and `b` of `α`, the intersection of the sets of elements that are greater than `a` and greater than `b` (denoted `Set.Ioi a` and `Set.Ioi b` respectively) is equal to the set of elements that are greater than the maximum of `a` and `b` (denoted `Set.Ioi (a ⊔ b)`). In mathematical terms, this can be written as $(a, +\infty) \cap (b, +\infty) = (\max(a, b), +\infty)$.

For any type `α` with a linear order and any `a, b ∈ α`, `Set.Ioi a ∩ Set.Ioi b = Set.Ioi (a ⊔ b)`. In other words, `(a, +∞) ∩ (b, +∞) = (max(a, b), +∞)`.


theorem ENNReal.mul_lt_top_iff : ∀ {a b : ENNReal}, a * b < ⊤ ↔ a < ⊤ ∧ b < ⊤ ∨ a = 0 ∨ b = 0 := by sorry

The theorem `ENNReal.mul_lt_top_iff` states that for any two extended nonnegative real numbers `a` and `b`, the product `a * b` is less than infinity if and only if either both `a` and `b` are less than infinity, or `a` is zero, or `b` is zero. In other words, you can only ensure that the multiplication of `a` and `b` won't result in infinity if both `a` and `b` are finite or one of them is zero.

For extended nonnegative real numbers `a` and `b`, `a * b` is less than infinity if and only if both `a` and `b` are finite or one of them is zero.


theorem ProbabilityTheory.kernel.indepSet_empty_right :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      (s : Set Ω), ProbabilityTheory.kernel.IndepSet s ∅ κ μ :=
  by sorry

This theorem states that for any given type `α` and `Ω` with their measurable spaces `_mα` and `_mΩ`, any member `κ` of the probability kernel from `α` to `Ω`, any measure `μ` on `α`, and any set `s` of type `Ω`, the set `s` is independent of the empty set under the probability kernel `κ` and the measure `μ`. This holds true when `κ` is a Markov kernel. In terms of probability theory, this means that the event represented by the set `s` is independent of no event (the empty set), under the given probability measure and Markov transition kernel.

For any Markov kernel κ from type α to Ω, measure μ on α, and set s of type Ω, the empty set is independent of s under κ and μ, meaning μ(κ⁻¹(s) ∩ ∅) = 0.


/-- Entries of the incidence matrix can be computed given additional decidable instances.  -/
theorem SimpleGraph.incMatrix_apply' :
    ∀ {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [inst : Zero R] [inst_1 : One R] [inst_2 : DecidableEq α]
      [inst_3 : DecidableRel G.Adj] {a : α} {e : Sym2 α},
      SimpleGraph.incMatrix R G a e = if e ∈ SimpleGraph.incidenceSet G a then 1 else 0 :=
  by sorry

The theorem `SimpleGraph.incMatrix_apply'` asserts that for any given type `R`, type `α`, a simple graph `G` with vertices of type `α`, and instances of zero and one for type `R` and decidable equality for type `α` and a decidable adjacency relation for graph `G`, the entries of the incidence matrix of the graph can be computed for any vertex `a` of type `α` and an unordered pair of vertices `e` of type `Sym2 α`. Specifically, if `e`, the unordered pair of vertices, belongs to the incidence set of the vertex `a` (i.e., `e` is an edge incident to `a`), the corresponding entry in the incidence matrix is `1`. Otherwise, if `e` is not an edge incident to `a`, the entry is `0`.

For a simple graph with decidable vertex type and adjacency relation, the incidence matrix entries equal 1 if the unordered pair of vertices represents an edge incident to a given vertex, and 0 otherwise.


Module.ext'

/-- A variant of `Module.ext` that's convenient for term-mode.  -/
theorem Module.ext' :
    ∀ {R : Type u_9} [inst : Semiring R] {M : Type u_10} [inst_1 : AddCommMonoid M] (P Q : Module R M),
      (∀ (r : R) (m : M), r • m = r • m) → P = Q :=
  by sorry

This theorem, referred to as `Module.ext'`, states that for any semiring `R` and any additive commutative monoid `M`, if two `Module` structures `P` and `Q` over `R` and `M` have the same scalar multiplication operation (denoted by `•`), then `P` and `Q` are equal. In simpler words, if two modules over the same semiring and the same base set behave the same way under scalar multiplication, then they are indeed the same module.

If two `Module` structures over the same semiring and additive commutative monoid have identical scalar multiplication operations, then they represent the same module.


theorem nhds_basis_Ioo_pos :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrderedAddCommGroup α] [inst_2 : OrderTopology α]
      [inst_3 : NoMaxOrder α] (a : α), Filter.HasBasis (nhds a) (fun ε => 0 < ε) fun ε => Set.Ioo (a - ε) (a + ε) :=
  by sorry

The theorem `nhds_basis_Ioo_pos` states that for any type `α` that is a topological space, a linearly ordered additive commutative group, has an order topology, and has no maximum order, and for any element `a` of type `α`, the neighborhood filter `nhds a` has a basis consisting of open intervals of the form `(a - ε, a + ε)`, where `ε` is a positive real number. In other words, every neighborhood of `a` contains an open interval `(a - ε, a + ε)` for some positive `ε`, and every such interval is a neighborhood of `a`.

If `α` is a topological space, a linearly ordered additive commutative group with no maximum order, then for any `a` in `α`, the neighborhood filter of `a` has a basis consisting of open intervals `(a - ε, a + ε)` for some positive real number `ε`.


theorem left_mem_segment :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y :=
  by sorry

The theorem `left_mem_segment` states that for any ordered semiring `𝕜`, any additive commutative monoid `E`, and any `𝕜`-zero-preserving scalar multiplication on `E`, for any two elements `x` and `y` in `E`, `x` is an element of the segment between `x` and `y`. In other words, in the context of a vector space, any point `x` is always considered to be on the line segment from `x` to any other point `y`.

For any ordered semiring 𝕜, additive commutative monoid E with a 𝕜-zero-preserving scalar multiplication, and any x, y in E, x lies in the segment from x to y.


theorem CategoryTheory.Limits.WidePullback.lift_π :
    ∀ {J : Type w} {D : Type u_1} [inst : CategoryTheory.Category.{v₂, u_1} D] {B : D} {objs : J → D}
      (arrows : (j : J) → objs j ⟶ B) [inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows] {X : D} (f : X ⟶ B)
      (fs : (j : J) → X ⟶ objs j) (w : ∀ (j : J), CategoryTheory.CategoryStruct.comp (fs j) (arrows j) = f) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.lift f fs w)
          (CategoryTheory.Limits.WidePullback.π arrows j) =
        fs j :=
  by sorry

The theorem `CategoryTheory.Limits.WidePullback.lift_π` states that in a category `D` with a wide pullback indexed by `J`, given objects `B`, `objs`, a morphism `f` from some object `X` to `B`, and a family of morphisms `fs` from `X` to each of the `objs`, satisfying that the composition of the morphism `fs j` and `arrows j` is equal to `f` for each `j` in `J`, then the composition of the 'lift' of `f` over the wide pullback and the projection from the pullback to the object indexed by `j` is equal to `fs j`. In the context of category theory, this means that the 'lift' operation is consistent with the projections in the pullback diagram.

Given a wide pullback diagram in a category with a morphism `f` and a family of morphisms `fs` such that `fs j ∘ arrows j = f` for all `j`, the 'lift' of `f` over the pullback and the projection to the object indexed by `j` compose to `fs j`.


theorem Equiv.Perm.support_inv :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (σ : Equiv.Perm α),
      Equiv.Perm.support σ⁻¹ = Equiv.Perm.support σ :=
  by sorry

This theorem states that for any given type `α` with decidable equality and finite elements, and for any permutation `σ` of the type `α`, the set of non-fixed points of the inverse of `σ` is the same as the set of non-fixed points of `σ` itself. In other words, if we have a permutation `σ` that maps elements from `α` to other elements in `α`, the elements that don't remain in their original position when we apply `σ` are exactly the same elements that don't stay in their original position when we apply the inverse of `σ`. This is denoted by `Equiv.Perm.support σ⁻¹ = Equiv.Perm.support σ`.

For any finite type `α` with decidable equality, the set of elements not fixed by a permutation `σ` is equal to the set of elements not fixed by its inverse.


theorem IsFractionRing.coeSubmodule_le_coeSubmodule :
    ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_5} [inst_1 : CommRing K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K] {I J : Ideal R},
      IsLocalization.coeSubmodule K I ≤ IsLocalization.coeSubmodule K J ↔ I ≤ J :=
  by sorry

The theorem `IsFractionRing.coeSubmodule_le_coeSubmodule` states that for any commutative ring `R`, and any field of fractions `K` of this ring, and for any two ideals `I` and `J` of the ring `R`, the submodule of `K` induced by `I` is less than or equal to the submodule of `K` induced by `J` if and only if `I` is less than or equal to `J`. Here, less than or equal to for ideals or submodules means that every element of the first ideal or submodule is also an element of the second one. Basically, this theorem is comparing ideals in the ring `R` and their corresponding submodules in the field of fractions `K`.

For any commutative ring R, ideal I <= J in R if and only if the submodule of the field of fractions of R induced by I is less than or equal to the submodule induced by J.


theorem ENNReal.tsum_mul_right :
    ∀ {α : Type u_1} {a : ENNReal} {f : α → ENNReal}, ∑' (i : α), f i * a = (∑' (i : α), f i) * a := by sorry

This theorem states that for any type `α`, any extended nonnegative real number `a`, and any function `f` mapping `α` to extended nonnegative real numbers, the sum of the product of `f(i)` and `a` for all `i` in `α` is equal to the product of `a` and the sum of all `f(i)` for all `i` in `α`. In other words, this theorem expresses the property of distributivity of multiplication over infinite summation in the context of extended nonnegative real numbers. This can be written in mathematical notation as follows: $\sum_{i \in \alpha} f(i) \cdot a = (\sum_{i \in \alpha} f(i)) \cdot a$.

For any type `α`, any extended nonnegative real number `a`, and any function `f` from `α` to extended nonnegative real numbers, the product of `a` and the sum of `f(i)` for all `i` in `α` is equal to the sum of the products `a` and `f(i)` for all `i` in `α` (distributivity of multiplication over infinite summation in extended nonnegative real numbers).


theorem Disjoint.inf_left' :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α} (c : α),
      Disjoint a b → Disjoint (c ⊓ a) b :=
  by sorry

The theorem `Disjoint.inf_left'` states that for any type `α` that has a semilattice structure with an infimum operation, and a partial order with a bottom element, and for any elements `a`, `b`, and `c` of this type, if `a` and `b` are disjoint (meaning their infimum is the bottom element), then `c` infimum `a` and `b` are also disjoint. This generalizes the notion of intersection (denoted by `⊓`) of two disjoint sets remaining disjoint when intersected with a third set.

If `α` is a type with a semilattice and partial order structure having a bottom element, and `a` and `b` are disjoint elements of `α`, then their infimum is the bottom element, and `c` is any element of `α`, then `c` and the infimum of `a` and `b` are disjoint.


theorem minpoly.eq_of_irreducible_of_monic :
    ∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B}
      [inst_3 : Nontrivial B] {p : Polynomial A},
      Irreducible p → (Polynomial.aeval x) p = 0 → Polynomial.Monic p → p = minpoly A x :=
  by sorry

This theorem states that for types `A` and `B` where `A` is a field and `B` is a ring, and there exists an algebra from `A` to `B`, given a nontrivial element `x` of `B` and a polynomial `p` with coefficients from `A`, if the polynomial `p` is irreducible, `p` evaluated at `x` under the algebra homomorphism is zero, and `p` is a monic polynomial (its leading coefficient is 1), then `p` is equal to the minimal polynomial of `x` over `A`.

In simpler terms, a monic irreducible polynomial that zeroes out at some `x` under an algebra homomorphism is the minimal polynomial of that `x`.

Given a field `A`, a ring `B` with an algebra homomorphism from `A` to `B`, a nontrivial `x` in `B`, and a monic irreducible polynomial `p` in `A[X]` such that `p(x) = 0`, then `p` is the minimal polynomial of `x` over `A`.


/-- The `vectorSpan` of a single point is `⊥`.  -/
theorem vectorSpan_singleton :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p : P), vectorSpan k {p} = ⊥ :=
  by sorry

This theorem states that the `vectorSpan` of a single point is the bottom element `⊥`. In more detail, for any ring `k`, any additive commutative group `V`, any module of `k` over `V`, any additive torsor of `V` over another type `P`, and any point `p` of type `P`, the `vectorSpan` of the set containing only the point `p` is `⊥`, which represents a zero-dimensional subspace in the context of modules or vector spaces.

For any additive torsor P over a module or vector space V over a ring k, the `vectorSpan` of the set {p} for any point p in P is the zero subspace ⊥.


theorem Fin.sum_univ_one :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] (f : Fin 1 → β), (Finset.sum Finset.univ fun i => f i) = f 0 := by sorry

The theorem `Fin.sum_univ_one` states that for any commutative, associative addition operation on a type `β` (denoted `AddCommMonoid β`), and any function `f` from a singleton set (a set with one element, denoted `Fin 1`) to `β`, the sum of the function `f` over the universal set (which includes every element of the domain of the function) is equal to the value of the function at 0. This essentially means that for a function defined on a singleton set, the sum of the function's values across all elements in the set (which in this case is just one element, 0) is just the function's value at 0.

For any commutative, associative addition operation on a type `β` and any function `f` from a singleton set to `β`, the sum of `f` over the universal set equals the value of `f` at 0. (Or, more mathematically: For every `AddCommMonoid β` and every `f : Fin 1 → β`, `∑ i in Fin 1, f i = f 0`.)


theorem Multiset.add_bind :
    ∀ {α : Type u_1} {β : Type v} (s t : Multiset α) (f : α → Multiset β),
      Multiset.bind (s + t) f = Multiset.bind s f + Multiset.bind t f :=
  by sorry

This theorem, `Multiset.add_bind`, states that for all types `α` and `β`, and for all multisets `s` and `t` of type `α`, and a function `f` from `α` to `Multiset β`, the bind operation on the sum of `s` and `t` with `f` is equivalent to the sum of the bind operation on `s` with `f` and the bind operation on `t` with `f`. In other words, it states that the bind operation distributes over the addition operation for multisets. This is similar to the distributive law in algebra where multiplication distributes over addition.

For all types `α` and `β`, and for all multisets `s` and `t` of type `α` and function `f` from `α` to `Multiset β`, `(s ++ t).bind (f) = s.bind (f) ++ t.bind (f)`.


theorem Real.hasStrictDerivAt_log : ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt Real.log x⁻¹ x := by sorry

This theorem states that for all real numbers `x` that are not equal to zero, the function `Real.log` (which represents the real logarithm function) has a strict derivative at the point `x` which is equal to the reciprocal of `x` (i.e., `x⁻¹`). In mathematical terms, this means the derivative of `log(x)` is `1/x` for all `x ≠ 0`. In terms of the strict differentiability definition provided, the change in `log(y)` and `log(z)` approximates to `(y - z) * f'` plus a term that goes to zero as `y, z → x`, where `f'` is `1/x`.

The real logarithm function `Real.log` has a strict derivative equal to `1/x` for all non-zero real numbers `x`.


/-- The conjugate transpose of a matrix mulitplied by the matrix is positive semidefinite  -/
theorem Matrix.posSemidef_conjTranspose_mul_self :
    ∀ {m : Type u_1} {n : Type u_2} {R : Type u_3} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : CommRing R]
      [inst_3 : PartialOrder R] [inst_4 : StarOrderedRing R] (A : Matrix m n R),
      Matrix.PosSemidef (Matrix.conjTranspose A * A) :=
  by sorry

The theorem states that for any matrix `A` with entries in a commutative ring `R` that is also a star-ordered ring and has a partial order, the product of the conjugate transpose of `A` and `A` itself is always positive semidefinite. This means that the resulting matrix is Hermitian (its conjugate transpose equals itself) and for any vector `x`, the dot product of the conjugate of `x` with the matrix-vector product of `A` and `x` is nonnegative.

For any matrix $A$ with entries in a commutative ring $R$ that is also a star-ordered ring with a partial order, the product of the conjugate transpose and $A$ is Hermitian and positive semidefinite.


theorem Trunc.induction_on : ∀ {α : Sort u_1} {β : Trunc α → Prop} (q : Trunc α), (∀ (a : α), β (Trunc.mk a)) → β q :=
  by sorry

The theorem `Trunc.induction_on` is a principle of induction for the `Trunc` type. For every type `α` and every property `β` that holds for every value of type `Trunc α`, if this property `β` holds for every value `a` of type `α` that has been wrapped in `Trunc.mk`, then this property `β` holds for every value `q` of type `Trunc α`. In other words, if we can show that a property holds for every possible pre-quotient value, then it holds for every value in the quotient type.

If a property holds for all pre-quotients of type `Trunc α` and is closed under `Trunc.mk`, then it holds for all quotients of type `Trunc α`.


OrderedSMul.mk''

/-- To prove that a linear ordered monoid is an ordered module, it suffices to verify only the first
axiom of `OrderedSMul`.  -/
theorem OrderedSMul.mk'' :
    ∀ {𝕜 : Type u_5} {M : Type u_7} [inst : OrderedSemiring 𝕜] [inst_1 : LinearOrderedAddCommMonoid M]
      [inst_2 : SMulWithZero 𝕜 M], (∀ ⦃c : 𝕜⦄, 0 < c → StrictMono fun a => c • a) → OrderedSMul 𝕜 M :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any linear ordered additive commutative monoid `M`, if `M` is also a semimodule over `𝕜` where scalar multiplication with zero is defined, then `M` can be considered as an ordered semimodule over `𝕜` (denoted as `OrderedSMul 𝕜 M`) if the following condition holds: for any positive scalar `c` from `𝕜`, the function that maps each element `a` in `M` to the result of scaling `a` by `c` is strictly monotone. In other words, if increasing `a` always leads to an increase in `c • a` when `c` is positive, then an order-preserving scalar multiplication structure exists on `M`.

If `𝕜` is an ordered semiring and `M` is an additive commutative monoid that is also a semimodule over `𝕜` with scalar multiplication by zero defined, then `M` is an ordered semimodule over `𝕜` if scalar multiplication by positive scalars is strictly monotone.


theorem injective_of_le_imp_le :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] (f : α → β),
      (∀ {x y : α}, f x ≤ f y → x ≤ y) → Function.Injective f :=
  by sorry

The theorem `injective_of_le_imp_le` is a statement about a function `f` from a partially ordered type `α` to a preordered type `β`. It says that if for all elements `x` and `y` of `α`, the statement "`f(x)` is less than or equal to `f(y)`" implies that "`x` is less than or equal to `y`", then the function `f` is injective. In other words, if `f` preserves the order structure from `α` to `β`, then there cannot be distinct elements in `α` that get mapped to the same element in `β`, which is the definition of an injective function.

If a function from a partially ordered type to a preordered type preserves order relations, then it is injective.


IsMaxOn.closure

theorem IsMaxOn.closure :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : Preorder Y]
      [inst_3 : OrderClosedTopology Y] {f : X → Y} {s : Set X} {a : X},
      IsMaxOn f s a → ContinuousOn f (closure s) → IsMaxOn f (closure s) a :=
  by sorry

The theorem `IsMaxOn.closure` states that for all topological spaces `X` and `Y`, where `Y` also has a preorder structure and an order-closed topology, given a function `f : X → Y`, a set `s : Set X` and a point `a : X`, if `f` reaches its maximum at `a` over the set `s` and `f` is continuous on the closure of `s`, then `f` also reaches its maximum at `a` over the closure of `s`. This means that the continuity of `f` on the closure of `s` preserves the property of `f` having its maximum value at `a`.

If `f : X → Y` is a continuous function from a topological space `X` to a topological preorder space `Y`, `s ⊆ X` is a set, `a ∈ X` is a point, and `f(a)` is the maximum value of `f` over `s`, then `f(a)` is also the maximum value of `f` over the closure of `s`.


theorem Finset.biUnion_singleton :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {s : Finset α} {f : α → β},
      (Finset.biUnion s fun a => {f a}) = Finset.image f s :=
  by sorry

The theorem `Finset.biUnion_singleton` states that for any finite set `s` of a type `α`, with a function `f` from `α` to another type `β` where `β` has decidable equality, the union of singletons `{f a}` for every `a` in `s` (expressed as `Finset.biUnion s fun a => {f a}` in Lean) is equal to the image of `s` under the function `f` (expressed as `Finset.image f s` in Lean). This theorem essentially verifies a key property of images of sets in the context of finite sets in Lean.

For any finite set `s` and function `f` from a type `α` to a type `β` with decidable equality, the union of the singletons `{f a}` for each `a` in `s` equals the image `Finset.image f s` of `s` under `f`.


theorem MeasureTheory.submartingale_nat :
    ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
      [inst : MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ},
      MeasureTheory.Adapted 𝒢 f →
        (∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) →
          (∀ (i : ℕ), f i ≤ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.condexp (↑𝒢 i) μ (f (i + 1))) →
            MeasureTheory.Submartingale f 𝒢 μ :=
  by sorry

The theorem `MeasureTheory.submartingale_nat` states that for a given measure space `Ω` with an associated measurable space `m0` and measure `μ`, along with a filtration `𝒢` of `m0` with respect to natural numbers and assuming that the measure `μ` is finite, if we have a sequence of functions `f` from natural numbers to `Ω` that is adapted to the filtration `𝒢` (meaning each function in the sequence is strongly measurable under the particular filtration), and each function in the sequence is integrable with respect to the measure `μ`, and for each natural number `i`, almost everywhere according to the measure `μ`, the function at index `i` in the sequence is less than or equal to the conditional expectation of the function at index `i + 1` with respect to the `i`th filtration and measure `μ`, then this sequence of functions `f` is a submartingale under filtration `𝒢` and measure `μ`. A submartingale is a sequence of random variables or functions that has the property that the expected value of the next term in the sequence, given all previous terms, is greater than or equal to the value of the current term.

If `Ω` is a measure space with finite measure `μ`, `𝒢` is a filtration of measurable space `m0`, and `f` is a sequence of strongly measurable, integrable functions adapted to `𝒢` such that almost everywhere `μ`, each `fi` is less than or equal to the conditional expectation of `f(i+1)` given `𝒢(i)` and `μ`, then `f` is a submartingale under filtration `𝒢` and measure `μ`.


theorem Prod.fst_iInf :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : InfSet α] [inst_1 : InfSet β] (f : ι → α × β),
      (iInf f).1 = ⨅ i, (f i).1 :=
  by sorry

This theorem states that for any types `α`, `β`, and `ι`, given the infimum of any structure `InfSet` for `α` and `β`, and a function `f` from `ι` to a pair of `α` and `β`, the first component of the indexed infimum of `f` is equal to the infimum over `i` of the first component of `f i`. In terms of mathematical notation, this could be written as $(\inf f).1 = \inf_i (f(i).1)$, where `inf` represents the infimum operation, `f(i).1` selects the first component of the pair produced by `f`, and the infimum is taken over all possible values of `i`.

The first component of the infimum of a function from an index type to a pair of types is equal to the infimum of the first components of the function's applications to each index.


theorem Polynomial.toFinsupp_erase :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ),
      (Polynomial.erase n p).toFinsupp = Finsupp.erase n p.toFinsupp :=
  by sorry

The theorem `Polynomial.toFinsupp_erase` states that for any semiring `R`, any polynomial `p` of type `Polynomial R`, and any natural number `n`, the operation of first erasing the `X^n` term from `p` and then converting the result to a finitely supported function is equivalent to first converting `p` to a finitely supported function and then erasing the `n`-th term from it. In other words, the operations of erasing an `n`-th term and converting to a finitely supported function commute with each other.

For any semiring `R`, given a polynomial `p` of type `Polynomial R` and a natural number `n`, the operations of erasing the `X^n` term and converting to a finitely supported function commute, i.e., `Polynomial.toFinsupp (erase X^n p) = toFinsupp p |>. erase (finset.mem_nat.val n)` (where `|>.` is Lean's infix function for right composition).


theorem ENNReal.inv_lt_inv : ∀ {a b : ENNReal}, a⁻¹ < b⁻¹ ↔ b < a := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, the inverse of `a` is less than the inverse of `b` if and only if `b` is less than `a`. The extended nonnegative real numbers are a representation of the range from zero to infinity, typically used as the codomain of a measure. The theorem essentially describes how the ordering relationship changes when taking inverses in this extended number system.

For extended nonnegative real numbers `a` and `b`, `1/a < 1/b` if and only if `a < b`.


theorem Fin.succAbove_of_succ_le :
    ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), Fin.succ i ≤ p → Fin.succAbove p i = Fin.castSucc i := by sorry

The theorem `Fin.succAbove_of_succ_le` states that for any natural number `n` and any two finite ordinal numbers `p` and `i` of orders `n + 1` and `n` respectively, if the successor of `i` is less than or equal to `p`, then the operation of embedding `i` into `Fin (n + 1)` with a hole around `p` (i.e., `Fin.succAbove p i`) is equivalent to the operation of embedding `i` into `Fin (n + 1)` directly (i.e., `Fin.castSucc i`). In mathematical terms, if `succ(i) ≤ p`, then `succAbove(p, i) = castSucc(i)`.

If `n` is a natural number, `p` is a finite ordinal of order `n + 1`, and `i` is a finite ordinal of order `n` with `succ(i) ≤ p`, then `Fin.succAbove p i = Fin.castSucc i`.


theorem ZMod.cast_id : ∀ (n : ℕ) (i : ZMod n), ZMod.cast i = i := by sorry

The theorem `ZMod.cast_id` asserts that for all natural numbers `n` and all integers modulo `n` denoted by `i`, applying the `ZMod.cast` function to `i` results in `i` itself. In other words, the `ZMod.cast` function acts as the identity function on the integers modulo `n`. This means that casting an integer modulo `n` to another semiring (which is the function of `ZMod.cast`) doesn't change the integer modulo `n` itself.

For all natural numbers `n` and integers `i` modulo `n`, `ZMod.cast i = i`.


theorem Finset.prod_div_distrib :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f g : α → β} [inst : DivisionCommMonoid β],
      (Finset.prod s fun x => f x / g x) = (Finset.prod s fun x => f x) / Finset.prod s fun x => g x :=
  by sorry

This theorem, `Finset.prod_div_distrib`, states that for any finite set `s` of elements of type `α` and for any two functions `f` and `g` from `α` to `β`, where `β` possesses a commutative division monoid structure, the product over `s` of the function values of `f` divided by `g` is equal to the product over `s` of the function values of `f` divided by the product over `s` of the function values of `g`. In mathematical notation, this is equivalent to the statement $\prod_{x \in s} \frac{f(x)}{g(x)} = \frac{\prod_{x \in s} f(x)}{\prod_{x \in s} g(x)}$.

For any finite set `s` and functions `f` and `g` from a commutative division monoid to itself, the product of `f` over `s` divided by the product of `g` over `s` is equal to the product of `f(x) / g(x)` for all `x` in `s`.


theorem LinearIndependent.fintype_card_le_finrank :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Finite R M] {ι : Type u_1} [inst_5 : Fintype ι] {b : ι → M},
      LinearIndependent R b → Fintype.card ι ≤ FiniteDimensional.finrank R M :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and module `M` over `R` with the strong rank condition and finiteness, and any finite type `ι` with a function `b` mapping `ι` to `M` that is linearly independent over `R`, the cardinality of `ι` (i.e., the number of elements in `ι`) is less than or equal to the rank of the module `M` over `R`. In other words, the number of linearly independent vectors in a vector space (or module) cannot exceed the dimension of that space.

For any ring `R`, additive commutative group `M` as an `R`-module with the strong rank condition and finiteness, any function `b` mapping a finite type `ι` to `M` that is linearly independent over `R`, the cardinality of `ι` is bounded above by the rank of `M` over `R`.


/-- The Fourier coefficients of a function on `AddCircle T` can be computed as an integral
over `[a, a + T]`, for any real `a`.  -/
theorem fourierCoeff_eq_intervalIntegral :
    ∀ {T : ℝ} [hT : Fact (0 < T)] {E : Type} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E]
      (f : AddCircle T → E) (n : ℤ) (a : ℝ),
      fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fourier (-n)) ↑x • f ↑x :=
  by sorry

The theorem `fourierCoeff_eq_intervalIntegral` states that for any real number `T` greater than 0, any complete normed complex vector space `E`, any function `f` on the additive circle `AddCircle T`, any integer `n`, and any real number `a`, the `n`-th Fourier coefficient of `f` can be computed as an integral over the interval `[a, a + T]`. Specifically, it is equal to `1/T` times the integral from `a` to `a + T` of `fourier (-n)` applied to `x` scaled by `f` applied to `x`. Here, `fourier (-n)` is the exponential monomial function defined as `exp (2 π i n x / T)`.

For any real number T > 0, complete normed complex vector space E, function f on AddCircle T, integer n, and real number a, the n-th Fourier coefficient of f is equal to 1/T * ∫[a, a+T] (fourier (-n) x) dx, where fourier (-n) is the exponential monomial function exp (2πi n x/T).


theorem Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.14 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α),
      MeasurableSet {a} = True :=
  by sorry

The theorem `Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.14` states that for any type `α` endowed with a `MeasurableSpace` structure and a `MeasurableSingletonClass` structure, any singleton set, which contains only one element `a` of type `α`, is a measurable set. This is always true regardless of the specific `α`, `MeasurableSpace`, or `MeasurableSingletonClass` in use.

For any type `α` equipped with a `MeasurableSpace` and `MeasurableSingletonClass` structure, the singleton set of any element in `α` is measurable.


DifferentiableWithinAt.inv

theorem DifferentiableWithinAt.inv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {h : E → 𝕜} {z : E} {S : Set E},
      DifferentiableWithinAt 𝕜 h S z → h z ≠ 0 → DifferentiableWithinAt 𝕜 (fun x => (h x)⁻¹) S z :=
  by sorry

The theorem `DifferentiableWithinAt.inv` states that for any non-trivial normed field `𝕜` and any normed add commutative group `E` over `𝕜`, if a function `h : E → 𝕜` is differentiable at a point `z` within a set `S`, and the value of the function `h` at `z` is non-zero, then the function `x ↦ (h x)⁻¹` is also differentiable at the same point `z` within the same set `S`. This captures the intuitive concept that the reciprocal of a differentiable function, under certain conditions, is also differentiable.

If `h : E → ℝ` is differentiable at `z` in the normed add commutative group `E` over a non-trivial normed field `ℝ`, and `h(z) ≠ 0`, then the function `x ↦ h(x)⁻¹` is differentiable at `z`.


theorem essSup_map_measure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β]
      {γ : Type u_3} {mγ : MeasurableSpace γ} {f : α → γ} {g : γ → β} [inst_1 : MeasurableSpace β]
      [inst_2 : TopologicalSpace β] [inst_3 : SecondCountableTopology β] [inst_4 : OrderClosedTopology β]
      [inst_5 : OpensMeasurableSpace β],
      AEMeasurable g (MeasureTheory.Measure.map f μ) →
        AEMeasurable f μ → essSup g (MeasureTheory.Measure.map f μ) = essSup (g ∘ f) μ :=
  by sorry

The theorem `essSup_map_measure` states that for any two types `α` and `β`, both equipped with a `MeasurableSpace` structure, a measure `μ` on `α`, and a `CompleteLattice` structure on `β`, and for any additional type `γ` with a `MeasurableSpace` structure, a function `f` from `α` to `γ`, and a function `g` from `γ` to `β`, where the latter also has a `TopologicalSpace` structure, a `SecondCountableTopology`, an `OrderClosedTopology`, and an `OpensMeasurableSpace` structure, if `g` is almost everywhere measurable with respect to the pushforward measure of `f` applied to `μ` and `f` is almost everywhere measurable with respect to `μ`, then the essential supremum of `g` with respect to the pushforward measure of `f` applied to `μ` is equal to the essential supremum of the composition of `g` and `f` with respect to `μ`. In other words, the essential supremum (the smallest upper bound that the function does not exceed except on a set of measure zero) is preserved under the mapping of measures.

Given measure spaces `(α, Σα, μ)`, `(β, Σβ, μβ)`, complete lattices `(β, ≤)`, functions `f: α → γ` and `g: γ → β`, and measurable spaces `(γ, Σγ, τ)` with `μγ` being the pushforward measure of `μ` under `f`, if `g` is almost everywhere measurable with respect to `μγ` and `f` is almost everywhere measurable with respect to `μ`, then the essential supremum of `g` with respect to `μβ` equals the essential supremum of the composition `g ∘ f` with respect to `μ`.


theorem Polynomial.eval_one_cyclotomic_prime_pow :
    ∀ {R : Type u_1} [inst : CommRing R] {p : ℕ} (k : ℕ) [hn : Fact (Nat.Prime p)],
      Polynomial.eval 1 (Polynomial.cyclotomic (p ^ (k + 1)) R) = ↑p :=
  by sorry

This theorem states that for any commutative ring `R`, any natural number `k`, and any prime number `p`, the evaluation of the `(p^(k+1))`-th cyclotomic polynomial at `1` is equal to `p`. In other words, if you plug in `1` into the `(p^(k+1))`-th cyclotomic polynomial, you get the prime number `p` as a result, no matter what commutative ring the polynomial's coefficients are taken from.

For any prime number p and natural number k, the value of the p^(k+1)-th cyclotomic polynomial evaluated at 1 is equal to p.