theorem Equiv.Perm.isCycle_cycleOf :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {x : α} (f : Equiv.Perm α),
      f x ≠ x → Equiv.Perm.IsCycle (Equiv.Perm.cycleOf f x) :=
  by sorry

The theorem `Equiv.Perm.isCycle_cycleOf` states that for any type `α` with decidable equality and finite structure, and for any element `x` of `α` and any permutation `f` of `α`, if the permutation `f` does not fix `x` (that is, `f x ≠ x`), then the cycle of permutation `f` to which `x` belongs is a non-identity permutation where any two non-fixed points are related by repeated application of the permutation. This implies that the cycle of `x` under `f` must be a cycle in the graph theoretic sense (i.e., it forms a closed loop without repetition except for the starting and ending point).

For any finite type `α` with decidable equality and any permutation `f` of `α` that does not fix `x`, the cycle of `x` under `f` is a non-identity permutation forming a closed loop without repetition except for the starting and ending points.


theorem Polynomial.isUnit_iff_degree_eq_zero :
    ∀ {R : Type u} [inst : Field R] {p : Polynomial R}, IsUnit p ↔ Polynomial.degree p = 0 := by sorry

The theorem `Polynomial.isUnit_iff_degree_eq_zero` states that for any given field `R`, and any polynomial `p` over `R`, the polynomial `p` is a unit (i.e., it has a two-sided inverse) if and only if the degree of the polynomial `p` is zero. Here, the degree of a polynomial is defined as the highest power of `X` that appears in the polynomial, or `⊥` (bottom) in the case of the zero polynomial. This is a property of fields, which are algebraic structures with operations analogous to those of the field of real numbers.

A polynomial over a field is a unit if and only if its degree is zero.


HasFDerivAt.unique

theorem HasFDerivAt.unique :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f₀' f₁' : E →L[𝕜] F} {x : E}, HasFDerivAt f f₀' x → HasFDerivAt f f₁' x → f₀' = f₁' :=
  by sorry

The theorem `HasFDerivAt.unique` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, a function `f` from `E` to `F`, continuous linear maps `f₀'` and `f₁'` from `E` to `F` over `𝕜`, and an element `x` of `E`, if `f` has `f₀'` as its derivative at `x` and `f` also has `f₁'` as its derivative at `x`, then `f₀'` and `f₁'` must be equal. In other words, the derivative of a function at a point, if it exists, is unique.

Given a non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, a continuous linear function `f` from `E` to `F`, and elements `x` in `E` and `f₀'`, `f₁'` in the space of continuous linear maps from `E` to `F` over `𝕜`, if `f₀'` and `f₁'` are the derivatives of `f` at `x`, then `f₀' = f₁'`.


theorem BoundedContinuousFunction.coe_add :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : AddMonoid β]
      [inst_3 : LipschitzAdd β] (f g : BoundedContinuousFunction α β), ⇑(f + g) = ⇑f + ⇑g :=
  by sorry

This theorem states that for any given types `α` and `β`, where `α` is a topological space and `β` is a pseudo metric space with an additive monoid structure and Lipschitz addition, then for any two bounded continuous functions `f` and `g` from `α` to `β`, the application of the sum function `(f + g)` is the same as the sum of the applications of `f` and `g`. In mathematical terms, the definition is `(f + g)(x) = f(x) + g(x)` for all `x` in `α`.

For any bounded continuous functions $f$ and $g$ from a topological space $\alpha$ to a pseudo metric space $\beta$ with an additive monoid structure and Lipschitz addition, $(f + g)(x) = f(x) + g(x)$ for all $x$ in $\alpha$.


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

The theorem `Finset.mem_of_mem_inter_left` states that for any type `α` that has decidable equality, given any elements `a` of type `α` and any two finsets `s₁` and `s₂` of elements of type `α`, if `a` is an element of the intersection of `s₁` and `s₂`, then `a` is an element of `s₁`. In other words, if an element belongs to the intersection of two sets, it must belong to each of the intersecting sets individually, specifically the first set in this case.

If `α` has decidable equality and `a` is an element of the intersection of finsets `s₁` and `s₂`, then `a` is an element of `s₁`.


theorem OnePoint.nhds_infty_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X],
      nhds OnePoint.infty = Filter.map OnePoint.some (Filter.coclosedCompact X) ⊔ pure OnePoint.infty :=
  by sorry

This theorem states that for any type `X` with a topological space structure, the neighborhood filter at the point at infinity is equal to the sup (join operation in filter lattice) of the forward map of the filter generated by complements to closed compact sets in `X` under the coercion from `X` to `OnePoint X`, and the filter containing only the point at infinity. In other words, it describes how the neighborhoods of the point at infinity in the extended space `OnePoint X` are related to the compact closed subsets of the original space `X`.

The neighborhood filter at the point at inity in the one-point compactification of a topological space `X` is equal to the join of the filter generated by complements of closed compact sets in `X`, and the filter containing only the point at infinity.


theorem FirstOrder.Language.Term.realize_relabel :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {β : Type v'}
      {t : FirstOrder.Language.Term L α} {g : α → β} {v : β → M},
      FirstOrder.Language.Term.realize v (FirstOrder.Language.Term.relabel g t) =
        FirstOrder.Language.Term.realize (v ∘ g) t :=
  by sorry

The theorem `FirstOrder.Language.Term.realize_relabel` states that for any first-order language `L`, any type `M`, any instances of the structure of the language `L` on `M`, any types `α` and `β`, any term `t` of the language `L` with variables of type `α`, any function `g` from `α` to `β`, and any valuation function `v` from `β` to `M`, the realization of the term `t` relabeled by the function `g` using the valuation `v` is the same as the realization of the original term `t` using the composition of the valuation `v` and the function `g`. In simpler words, relabeling the variables of a term and then realizing it is the same as first applying the relabeling function to the variables and then realizing the term.

For any first-order language L, type M, valuation function v from the type of constants in L to M, function g from the domain of v to the type M, term t of L with variables of type α, the realization of the term t relabeled by g using v is equal to the realization of the original term t using the composition of g and v.


/-- Two `ℝ`-algebra homomorphisms from `ℂ` are equal if they agree on `Complex.I`.  -/
theorem Complex.algHom_ext :
    ∀ {A : Type u_3} [inst : Semiring A] [inst_1 : Algebra ℝ A] ⦃f g : ℂ →ₐ[ℝ] A⦄, f Complex.I = g Complex.I → f = g :=
  by sorry

This theorem states that for any type `A` which has a semiring and an algebra structure over the real numbers, two algebra homomorphisms from the complex numbers to `A` are considered to be equal if they agree on the value of `Complex.I`, the imaginary unit. In other words, if two algebra homomorphisms from the complex numbers to `A` map the imaginary unit to the same element in `A`, then these two homomorphisms are indeed the same.

For any type `A` equipped with a semiring and algebra structure over the real numbers, two algebra homomorphisms from the complex numbers to `A` are equal if they map the imaginary unit `I` to the same element in `A`.


theorem Stream'.Seq.join_cons :
    ∀ {α : Type u} (a : α) (s : Stream'.Seq α) (S : Stream'.Seq (Stream'.Seq1 α)),
      Stream'.Seq.join (Stream'.Seq.cons (a, s) S) = Stream'.Seq.cons a (Stream'.Seq.append s (Stream'.Seq.join S)) :=
  by sorry

The theorem `Stream'.Seq.join_cons` states that for any type `α`, given an element `a` of type `α`, a sequence `s` of type `α`, and a sequence `S` of non-empty sequences of type `α`, if we join the sequence that results from prepending the pair `(a, s)` to `S`, it is equivalent to prepending `a` to the sequence obtained by appending `s` to the joined sequence of `S`. In other words, joining a sequence that starts with `(a, s)` is the same as starting with `a` and then following with the rest of `s` and the joined sequence of `S`.

For any type `α` and any `a : α` and non-empty sequences `s : List α` and `S : List (List α)`, the sequences obtained by prepending `(a, s)` to `S` and appending `s` to the sequence obtained by joining `S` are equal.


theorem HahnSeries.order_zero :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero Γ],
      HahnSeries.order 0 = 0 :=
  by sorry

This theorem states that, for any types `Γ` and `R` where `Γ` is a partial order and `R` and `Γ` have a zero element, the order of the zero Hahn Series is indeed zero. In other words, it confirms that our definition of `HahnSeries.order` correctly assigns an order of zero to the zero Hahn Series.

For any partial order types `Γ` with a zero element, the order of the zero Hahn series in `Γ` is zero.


theorem Seminorm.mem_closedBall :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) {x y : E} {r : ℝ}, y ∈ Seminorm.closedBall p x r ↔ p (y - x) ≤ r :=
  by sorry

The theorem `Seminorm.mem_closedBall` states that for all seminormed rings `𝕜`, and for all additive commutative groups `E` with scalar multiplication by `𝕜`, for any seminorm `p` on `E`, for all elements `x`, `y` of `E` and for all real numbers `r`, the element `y` belongs to the closed ball of radius `r` at `x` with respect to the seminorm `p` if and only if the seminorm of the difference between `y` and `x` is less than or equal to `r`. It's essentially a restatement of the definition of a closed ball in a seminormed vector space, specifying the condition that must hold for an element to be included in a closed ball.

For any seminormed ring `𝕜` and additive commutative group `E` with scalar multiplication by `𝕜`, and for any seminorm `p` on `E`, an element `y` belongs to the closed ball of radius `r` around `x` in `E` with respect to `p` if and only if `p(x - y) ≤ r`.


theorem CategoryTheory.shiftFunctorComm_eq :
    ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddCommMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k),
      CategoryTheory.shiftFunctorComm C i j =
        (CategoryTheory.shiftFunctorAdd' C i j k h).symm ≪≫ CategoryTheory.shiftFunctorAdd' C j i k ⋯ :=
  by sorry

This theorem states that for any type `C` forming a category and a type `A` forming an additive commutative monoid, along with a given shift structure on `C` with respect to `A`, and for any three elements `i`, `j`, `k` of `A` such that `i + j = k`, the shift functor commutativity for `C` and `i`, `j` is equal to the composition of the symmetrisation of the shift functor addition for `C`, `i`, `j`, `k` and the hypothesis `h`, and the shift functor addition for `C`, `j`, `i`, `k`. This theorem essentially describes a relation between the shift functor commutativity and shift functor addition in the context of category theory.

For any category `C` with type `A` forming an additive commutative monoid, and a given shift structure, the shift functor commutativity for any elements `i`, `j` of `A` with `i + j = k` equals the composition of the symmetrized shift functor addition and the shift functor addition for `C` with respect to `i`, `j`, `k`.


theorem Nat.find_mono :
    ∀ {p q : ℕ → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred q],
      (∀ (n : ℕ), q n → p n) → ∀ {hp : ∃ n, p n} {hq : ∃ n, q n}, Nat.find hp ≤ Nat.find hq :=
  by sorry

The `Nat.find_mono` theorem states that for any two decidable predicates `p` and `q` on natural numbers, if for every natural number `n`, `q(n)` implies `p(n)`, then for any `n` that satisfies `p` (`hp`) and any `n` that satisfies `q` (`hq`), the least natural number that satisfies `p` is less than or equal to the least natural number that satisfies `q`. In other words, if `q` implies `p`, then the smallest number that satisfies `q` cannot be less than the smallest number that satisfies `p`.

If `p` implies `q` and both `p` and `q` are decidable predicates on natural numbers, then the least natural number satisfying `p` is less than or equal to the least natural number satisfying `q`.


theorem Int.gcd_eq_one_iff_coprime : ∀ {a b : ℤ}, Int.gcd a b = 1 ↔ IsCoprime a b := by sorry

The theorem `Int.gcd_eq_one_iff_coprime` establishes a bi-directional relationship between two integers `a` and `b` having a greatest common divisor equal to 1 and being coprime. In other words, for any two integers `a` and `b`, they are coprime (there exist two numbers such that their linear combination equals 1) if and only if the greatest common divisor of `a` and `b` is 1.

Two integers `a` and `b` are coprime if and only if their greatest common divisor equals 1.


theorem IsMaxFilter.comp_mono :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsMaxFilter f l a → ∀ {g : β → γ}, Monotone g → IsMaxFilter (g ∘ f) l a :=
  by sorry

The theorem `IsMaxFilter.comp_mono` states that for all types `α`, `β`, and `γ`, if `β` and `γ` have a preorder relation, and if a function `f` from `α` to `β` satisfies the property that `f x` is less than or equal to `f a` for all `x` in some neighborhood of `a` defined by a filter `l` (i.e., `f` is a max filter at `a`), then for any monotone function `g` from `β` to `γ` (i.e., a function where `a ≤ b` implies `f a ≤ f b`), the composition `g ∘ f` is also a max filter at `a`. In other words, the composition of a monotone function and a function that reaches its maximum at `a` still reaches its maximum at `a`.

If `f: α → β` is a max filter at `a` in a preorder `β`, and `g: β → γ` is a monotone function, then `g ∘ f` is a max filter at `a` in `γ`.


theorem IsLocalization.eq_mk'_iff_mul_eq :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} {y : ↥M} {z : S},
      z = IsLocalization.mk' S x y ↔ z * (algebraMap R S) ↑y = (algebraMap R S) x :=
  by sorry

This theorem, named `IsLocalization.eq_mk'_iff_mul_eq`, establishes an equivalence in the context of IsLocalization, a concept in algebraic geometry and commutative algebra. Given a commutative semiring `R`, a submonoid `M` of `R`, a commutative semiring `S`, and an algebra structure from `R` to `S` that makes `S` a localization of `R` at `M`, the theorem states that for any element `x` of `R`, element `y` of `M`, and `z` of `S`, `z` equals the result of the function `IsLocalization.mk'` applied to `S`, `x`, and `y` if and only if the product of `z` and the image of `y` under the algebra mapping from `R` to `S` is equal to the image of `x` under the same algebra mapping. This theorem basically gives a condition for equating an element in the target semiring with a fraction-like expression in terms of the algebra map and elements from the original ring and submonoid.

For an algebra structure from a commutative semiring `R` to a commutative semiring `S` making `S` a localization of `R` at a submonoid `M`, `IsLocalization.mk'(S, x, y) = z` if and only if `z * S.algebra_map R x = S.algebra_map R y * x`.


/-- If `g` tends to some `𝓝 x` along `f`, then it tends to `𝓝 (Filter.limUnder f g)`. We formulate
this lemma with a `[Nonempty X]` argument of `lim` derived from `h` to make it useful for types
without a `[Nonempty X]` instance. Because of the built-in proof irrelevance, Lean will unify this
instance with any other instance.  -/
theorem tendsto_nhds_limUnder :
    ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {f : Filter α} {g : α → X}
      (h : ∃ x, Filter.Tendsto g f (nhds x)), Filter.Tendsto g f (nhds (limUnder f g)) :=
  by sorry

The theorem `tendsto_nhds_limUnder` states that for any types `X` and `α`, where `X` is a topological space, any filter `f` in `α`, and any function `g` from `α` to `X`, if `g` tends to some neighborhood of a point `x` along `f` (meaning for every neighborhood of `x`, the pre-image under `g` is a neighborhood in the filter `f`), then `g` also tends to the neighborhood of the limit of `g` at `f`. This theorem is formulated with a nonempty `X` argument of limit derived from `h` to make it applicable to types without a nonempty `X` instance. Lean will unify this instance with any other due to built-in proof irrelevance.

If a function `g` from a filter `f` in `α` to a topological space `X` tends to a neighborhood of a point `x` in `X` along `f`, then `g` tends to the neighborhood of the limit of `g` at `f`.


theorem not_imp : ∀ {a b : Prop}, ¬(a → b) ↔ a ∧ ¬b := by sorry

This theorem states that for any two propositions `a` and `b`, the negation of the implication from `a` to `b` is equivalent to the conjunction of `a` and the negation of `b`. In other words, denying that `a` implies `b` is the same as asserting that `a` is true and `b` is false.

⊥ ∘ (a → b) ≡ a ∧ ⌐b, where ⊥ is the logical falsity, a and b are propositions, and ∘ represents logical composition (implication). This statement asserts that the logical negation of an implication is equivalent to the conjunction of the premise and the negation of the conclusion.


theorem Quaternion.inner_self : ∀ (a : Quaternion ℝ), ⟪a, a⟫_ℝ = Quaternion.normSq a := by sorry

This theorem states that for any quaternion `a` over the real numbers, the inner product of `a` with itself is equal to the square of the norm of `a`. In other words, the inner product of a quaternion with itself, denoted as `⟪a, a⟫_ℝ`, always equals the square of its norm, which is computed by the function `Quaternion.normSq a`.

For any quaternion `a` over the real numbers, the inner product of `a` with itself equals the square of its norm: `⟪a, a⟫_ℝ = Quaternion.normSq a².`


theorem PowerSeries.coeff_X :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (PowerSeries.coeff R n) PowerSeries.X = if n = 1 then 1 else 0 := by
  sorry

The theorem `PowerSeries.coeff_X` states that for any semiring `R` and natural number `n`, the `n`th coefficient of the formal power series variable in `R` is `1` if `n` equals `1`, and `0` otherwise. In other words, the only non-zero coefficient of the power series variable is the first one, corresponding to the fact that the power series for a variable `X` is simply `X` itself (which has coefficient `1` at the first power and `0` elsewhere).

The power series expansion of a variable `X` in a semiring `R` has only a non-zero coefficient of `1` at the term `X^1`.


theorem exists_linearIndependent_extension :
    ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V},
      LinearIndependent (ι := { x // x ∈ s }) K Subtype.val →
        s ⊆ t → ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val :=
  by sorry

This theorem, `exists_linearIndependent_extension`, states that for any division ring `K` and any additive commutative group `V` that is a module over `K`, given two sets of vectors `s` and `t` from `V`, if `s` is a linearly independent set and is a subset of `t`, there exists a set `b` which is a subset of `t` such that `s` is a subset of `b`, `t` is a subset of the span of `b` over `K`, and `b` is a linearly independent set. In other words, it's possible to extend a linearly independent set `s` to another linearly independent set `b` that spans `t`.

Given any division ring `K` and an additive commutative `K`-module `V`, if `s` is a linearly independent subset of `V` and `s` is contained in `t`, there exists a linearly independent subset `b` of `t` containing `s` such that `t` is contained in the span of `b` over `K`.


/-- `orthogonal` gives a `GaloisConnection` between
`Submodule 𝕜 E` and its `OrderDual`.  -/
theorem Submodule.orthogonal_gc :
    ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
      GaloisConnection Submodule.orthogonal Submodule.orthogonal :=
  by sorry

The theorem `Submodule.orthogonal_gc` states that for any scalar type `𝕜`, and any type `E` that forms a normed additive commutative group and an inner product space over `𝕜`, there is a Galois connection between the `Submodule 𝕜 E` and its order dual. This connection is established through the `Submodule.orthogonal` function, which gives the subspace of vectors orthogonal to a given subspace. A Galois connection is a relationship between two functions where the order of elements in the first function's output is the reverse of the order of elements in the second function's output.

For any scalar type `𝕜` and normed additive commutative group and inner product space `E` over `𝕜`, there exists a Galois connection between `Submodule 𝕜 E` and its order dual, represented by the `Submodule.orthogonal` function.


Memℓp.summable

theorem Memℓp.summable :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)],
      0 < p.toReal → ∀ {f : (i : α) → E i}, Memℓp f p → Summable fun i => ‖f i‖ ^ p.toReal :=
  by sorry

The theorem `Memℓp.summable` asserts that for any type `α` and a function `E` mapping from `α` to another type, and given a nonnegative extended real number `p` and a set of `NormedAddCommGroup` instances indexed by `α`, if the real part of `p` is greater than zero, then for any function `f` from `α` to `E i` that satisfies the `Memℓp` property for `p`, the series formed by taking the norm of `f i` raised to the power of the real part of `p` for each `i` is summable. In other words, if the function `f` is in ℓp space (where the real part of `p` is greater than zero), then the series of its elements' norms raised to the power of `p` converges to a sum.

If `α` is a type, `E` maps `α` to a `NormedAddCommGroup`, `p` is a nonnegative real number with positive real part, and `f : α → E i` satisfies the `Memℓp` property for `p`, then the series ∑ₙ(|f i(n)|ⁱ)⁺ p, where i ranges over `α` and n over ℕ, converges.


theorem Polynomial.content_eq_zero_iff :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {p : Polynomial R},
      Polynomial.content p = 0 ↔ p = 0 :=
  by sorry

This theorem states that for any type `R` which is a commutative ring and a domain with a normalized greatest common divisor (GCD) monoid structure, and any polynomial `p` over `R`, the content of `p` (which is defined as the GCD of the coefficients of `p`) is equal to zero if and only if the polynomial `p` itself is the zero polynomial. In other words, a polynomial's content is zero precisely when the polynomial is the zero polynomial.

For any commutative ring and domain `R` with a normalized greatest common divisor monoid structure, the content of a polynomial `p` over `R` is equal to zero if and only if `p` is the zero polynomial.


/-- The range of a strongly measurable function is separable.  -/
theorem MeasureTheory.StronglyMeasurable.isSeparable_range :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {m : MeasurableSpace α} [inst : TopologicalSpace β],
      MeasureTheory.StronglyMeasurable f → TopologicalSpace.IsSeparable (Set.range f) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.isSeparable_range` states that for any strongly measurable function `f` mapping from a type `α` (with a measurable space structure `m`) to a type `β` (with a topological space structure), the range of `f` is a separable set in the topological space `β`. In other words, the image of `f` is contained in the closure of a countable subset of `β`. Here, a function `f` is strongly measurable if it can be approximated by a sequence of simple functions.

The range of any strongly measurable function from a measurable space to a topological space is separable.


theorem Finset.image_preimage :
    ∀ {α : Type u} {β : Type v} [inst : DecidableEq β] (f : α → β) (s : Finset β)
      [inst_1 : (x : β) → Decidable (x ∈ Set.range f)] (hf : Set.InjOn f (f ⁻¹' ↑s)),
      Finset.image f (Finset.preimage s f hf) = Finset.filter (fun x => x ∈ Set.range f) s :=
  by sorry

This theorem, named `Finset.image_preimage`, states that for any two types `α` and `β` with decidable equality on `β`, any function `f` from `α` to `β`, and any finite set `s` of `β`, assuming that for any `x` in `β` we can decide if `x` is in the range of `f`, and that `f` is injective on the preimage of `s` under `f`, then the image of the preimage of `s` under `f` is equal to the subset of `s` where each element is in the range of `f`. In other words, it is ensuring that when we take the preimage of a set under a function, and then take the image of that preimage under the same function, we end up with the original set, filtered to only include elements within the range of the function. This theorem is essentially about the interaction between function preimages, images, and set filtering within the context of finite sets.

For any injective function from a type with decidable equality to another type with decidable equality, and any finite subset of the range, the image of the preimage under the function is equal to the subset of the range consisting of images of elements in the preimage.


theorem CategoryTheory.Abelian.factorThruCoimage.proof_2 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasKernels C] {P Q : C} (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) f = 0 :=
  by sorry

The theorem `CategoryTheory.Abelian.factorThruCoimage.proof_2` states that for any category `C` with zero morphisms and kernels, and for any two objects `P` and `Q` within `C`, the composition of the morphism from the kernel of a given morphism `f` (from `P` to `Q`) and `f` itself is the zero morphism. This is a property of abelian categories, where the kernel of a morphism is the source of a zero morphism when composed with the original morphism.

In an Abelian category with zero morphisms and kernels, for any morphism `f` in the category, the composition of `f` and the kernel of `f` is the zero morphism.


theorem Fin.veq_of_eq : ∀ {n : ℕ} {i j : Fin n}, i = j → ↑i = ↑j := by sorry

This theorem states that for any natural number 'n' and any two finite numbers 'i' and 'j' within the range 0 to 'n-1' (represented as 'Fin n'), if 'i' is equal to 'j', then the natural number representation of 'i' (denoted as ↑i) is equal to the natural number representation of 'j' (denoted as ↑j). Essentially, it guarantees that equality between two `Fin n` elements also implies equality between their corresponding natural numbers.

For any natural number n and all i, j in Fin n (0 <= i, j < n), i = j implies ↑i = ↑j.


theorem List.bind_map :
    ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} (f : β → γ) (g : α → List β) (l : List α),
      List.map f (List.bind l g) = List.bind l fun a => List.map f (g a) :=
  by sorry

The `List.bind_map` theorem states that, for any types `β`, `γ`, and `α`, and any functions `f : β → γ` and `g : α → List β`, and any list `l : List α`, mapping function `f` over the list obtained by binding `l` with `g` is equivalent to binding `l` with a function that maps `f` over the list obtained by applying `g` to each element. In other words, it is asserting the equality of two operations: first binding then mapping, versus first mapping then binding, where binding refers to applying a function to each element of a list and joining the results. This is a formal expression of one of the monadic laws in the context of the list monad.

For any functions `f : β → γ` and `g : α → List β`, and any list `l : List α`, the application of `f` to the list obtained by binding `l` with `g` is equivalent to binding each element of `l` with `g` and then applying `f` to the resulting list.


/-- ε-characterization of the closure in pseudoemetric spaces  -/
theorem EMetric.mem_closure_iff :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s : Set α}, x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, edist x y < ε :=
  by sorry

This theorem provides an ε-characterization of the closure in pseudoemetric spaces. Specifically, it states that for any type `α` that has the structure of a pseudoemetric space, for any point `x` of type `α` and any set `s` of type `α`, `x` is in the closure of `s` if and only if, for every real number `ε` greater than 0, there exists a point `y` in `s` such that the extended distance (or edistance, `edist`) between `x` and `y` is less than `ε`. In other words, `x` is in the closure of `s` if it is arbitrarily close to `s`, measured in terms of the pseudoemetric's extended distance.

A point `x` in a pseudometric space `α` belongs to the closure of a set `s` if and only if for every `ε > 0`, there exists `y` in `s` with `edist(x, y) < ε`.


Equiv.Perm.SameCycle.rfl

theorem Equiv.Perm.SameCycle.rfl : ∀ {α : Type u_2} {f : Equiv.Perm α} {x : α}, Equiv.Perm.SameCycle f x x := by sorry

This theorem states that for any type `α`, any permutation `f` of `α`, and any element `x` from `α`, `x` is in the same cycle of the permutation `f` as itself. In other words, `x` will always be part of its own cycle in any given permutation.

For any type `α`, any permutation `f` on `α`, and any element `x` in `α`, `x` and `f(x)` belong to the same cycle in the cycle decomposition of `f`.


theorem ne_zero_of_eq_one :
    ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1] {a : α}, a = 1 → a ≠ 0 := by sorry

This theorem states that for any type `α` that has both zero and one elements (denoted by `0` and `1` respectively), if an element `a` of this type equals `1`, then it cannot equal `0`. In mathematical terms, for any element `a` in a set where `0` and `1` are defined and distinct, if `a = 1` then `a ≠ 0`.

For any type with defined and distinct zero and one elements, an element equal to one is not equal to zero.


theorem Filter.limsup_le_of_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {a : α},
      autoParam (Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝ →
        (∀ᶠ (n : β) in f, u n ≤ a) → Filter.limsup u f ≤ a :=
  by sorry

The theorem `Filter.limsup_le_of_le` states that for any types `α` and `β`, where `α` has an associated instance of `ConditionallyCompleteLattice`, and any filter `f` of type `β`, function `u` from `β` to `α`, and an element `a` of type `α`, if the image of the filter `f` under the function `u` is cobounded under the less than or equal to relation (meaning it does not tend to infinity), and it is almost everywhere (for all `n` in the filter `f`) the case that `u n` is less than or equal to `a`, then the limit superior (the infimum of the upper bounds) of the function `u` along the filter `f` is less than or equal to `a`.

If `α` is a conditionally complete lattice, `f` is a filter on `β`, `u` is a function from `β` to `α`, and for all `n` in `f`, `u n` is less than or equal to `a` and the image of `f` under `u` is bounded above, then `⨆(u ∘ f) ≤ a`.


theorem IntermediateField.biSup_adjoin_simple :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E),
      ⨆ x ∈ S, F⟮x⟯ = IntermediateField.adjoin F S :=
  by sorry

The theorem `IntermediateField.biSup_adjoin_simple` states that for any given field `F`, and an extension of this field `E`, with an algebra structure defined over `F` and `E`, and for any set `S` of elements from `E`, the supremum of the adjoined fields created by each individual element `x` in the set `S` is equal to the intermediate field created by adjoining the entire set `S` to the field `F`. In more mathematical terms, this can be written as $\bigvee_{x \in S} F⟮x⟯ = \text{IntermediateField.adjoin} \, F \, S$. This statement essentially describes the equivalence between adjoining each individual element from a set to a field and adjoining the entire set at once.

The supremum of the fields obtained by adjoining each element in a set to a field is equal to the intermediate field obtained by adjoining the entire set.


theorem coinduced_le_iff_le_induced :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {tα : TopologicalSpace α} {tβ : TopologicalSpace β},
      TopologicalSpace.coinduced f tα ≤ tβ ↔ tα ≤ TopologicalSpace.induced f tβ :=
  by sorry

This theorem states that for any two types `α` and `β`, and any function `f : α → β` between them, and given any topologies `tα` on `α` and `tβ` on `β`, the coinduced topology on `β` from `α` via `f` is less than or equal to `tβ` if and only if `tα` is less than or equal to the topology on `α` induced from `β` via `f`. In other words, it provides a relationship between the coinduced topology and the induced topology through a function between two topological spaces.

For any functions `f : α → β` between topological spaces `(α, tα)` and `(β, tβ)`, the coinduced topology on `β` is less than or equal to `tβ` if and only if the induced topology on `α` is less than or equal to `tα`.


theorem Cardinal.mk_range_eq_of_injective :
    ∀ {α : Type u} {β : Type v} {f : α → β},
      Function.Injective f → Cardinal.lift.{u, v} (Cardinal.mk ↑(Set.range f)) = Cardinal.lift.{v, u} (Cardinal.mk α) :=
  by sorry

This theorem states that for any two types `α` and `β`, and any injective function `f` from `α` to `β`, the cardinality (the measure of the "size" of the set) of the range of `f` (the set of all outputs of `f`) is equal to the cardinality of `α`. This equality is maintained even when the cardinalities are lifted to higher universes. The lifting operation is used here to ensure that the cardinalities are comparable, as they might be from different universes.

For any injective functions $f : \alpha \rightarrow \beta$ between types, the cardinality of $\alpha$ and the cardinality of the range of $f$ are equal. (This equality holds even when the cardinalities are lifted to higher universes.)


theorem List.dedup_cons_of_not_mem :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, a ∉ l → List.dedup (a :: l) = a :: List.dedup l := by
  sorry

The theorem `List.dedup_cons_of_not_mem` states that for any type `α` with decidable equality, any element `a` of type `α`, and any list `l` of elements of type `α`, if `a` is not a member of `l`, then the operation of removing duplicates from the list formed by consing `a` onto `l` results in a list that starts with `a` and is followed by the list obtained by removing duplicates from `l`. In other words, if `a` is not in `l`, then removing duplicates from `a :: l` gives `a :: (dedup l)`.

If `α` is a type with decidable equality, `a` is not an element of list `l` of type `α`, then the list obtained by removing duplicates from `a :: l` equals `a :: (removeDuplicates l)`.


theorem Set.Ico_subset_Ico :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α}, a₂ ≤ a₁ → b₁ ≤ b₂ → Set.Ico a₁ b₁ ⊆ Set.Ico a₂ b₂ := by
  sorry

This theorem, `Set.Ico_subset_Ico`, states that for any type `α` that has a preorder relation defined on it, given any four elements `a₁`, `a₂`, `b₁`, and `b₂` of this type, if `a₂` is less than or equal to `a₁` and `b₁` is less than or equal to `b₂`, then the left-closed right-open interval from `a₁` to `b₁` is a subset of the left-closed right-open interval from `a₂` to `b₂`. In mathematical terms, if $a₂ \leq a₁$ and $b₁ \leq b₂$, then the set $\{x \,|\, a₁ \leq x < b₁\}$ is included in the set $\{x \,|\, a₂ \leq x < b₂\}$.

For any type `α` with a preorder relation, if `a₁ ≤ a₂` and `b₁ ≤ b₂`, then the interval `[a₁, b₁) is subset of [a₂, b₂)`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.1 :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : α}, (a⁻¹ ≤ 1) = (1 ≤ a) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Group.Defs._auxLemma.1`, asserts that for any type `α` that forms a group and has a less than or equal to (`≤`) operation, and also satisfies the covariant property for multiplication and the less than or equal to operation, then for any element `a` of that type, `a` inverse is less than or equal to `1` if and only if `1` is less than or equal to `a`. In mathematical notation, this theorem can be written as: For all `a` in `α`, `a⁻¹ ≤ 1` if and only if `1 ≤ a`.

For any group `α` with a `≤` relation that is covariant for multiplication and left-inverse, `a⁻¹ ≤ 1` if and only if `1 ≤ a`.


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

This theorem states that for any type `α` that has decidable equality, and for any `Finset` of `α` named `s`, and for any elements `a` and `b` of `α`, if `b` is an element of the set obtained by erasing `a` from `s`, then `b` is also an element of `s`. In other words, if you remove an element `a` from a finite set `s` and `b` is in the resulting set, then `b` was definitely an element of the original set `s`.

For any type `α` with decidable equality and any finite set `s` of `α` containing an element `a`, if `b` is in the set `s \ {a}`, then `b` is in `s`.


theorem Mathlib.Data.Finset.Basic._auxLemma.7 : ∀ {α : Type u_1} {s : Finset α} (x : ↑↑s), (↑x ∈ s) = True := by sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.7`, states that for any type `α` and for any finite set `s` of type `α`, any element `x` already in the double-coerced set `s` (i.e., `x` is an element of `s` when `s` is coerced twice) is indeed an element of `s`. In other words, it confirms that double-coercion does not change the membership of an element in this set. This is always true.

For any type `α` and finite set `s` of type `α`, an element `x` in `s` remains an element of `s` after double-coercion.


theorem Algebra.map_top :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B), Subalgebra.map f ⊤ = AlgHom.range f :=
  by sorry

The theorem `Algebra.map_top` states that for any commutative semiring `R`, semirings `A` and `B`, and an algebra homomorphism `f` from `A` to `B` with both `A` and `B` being `R`-algebras, the application of the `Subalgebra.map` function on `f` and the top subalgebra of `A` results in the same subalgebra as the range of `f` when viewed as an algebra homomorphism. In other words, the image of the entire algebra `A` under the algebra homomorphism `f` is precisely the range of `f`.

For any commutative semiring R, semirings A and B, and an algebra homomorphism f from A to B with both A and B being R-algebras, the image of the top subalgebra of A under f, through Subalgebra.map, equals the range of f as an R-algebra homomorphism.


theorem Mathlib.Data.Multiset.Dedup._auxLemma.1 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ Multiset.dedup s) = (a ∈ s) := by sorry

This theorem states that for any given type `α` which has decidable equality, and any specific element `a` of type `α` and multiset `s` of the same type, checking if `a` belongs to the deduplicated version of `s` is equivalent to checking if `a` belongs to `s` itself. In simpler terms, the presence of an element in a multiset is not affected by the operation of removing duplicates from the multiset.

For any decidably equated type `α`, and multiset `s` and element `a` of type `α`, the decidability of `a ∈ s` implies the decidability of `a ∈ set.dedup s`.


theorem mul_add_one :
    ∀ {α : Type u} [inst : Add α] [inst_1 : MulOneClass α] [inst_2 : LeftDistribClass α] (a b : α),
      a * (b + 1) = a * b + a :=
  by sorry

This theorem, called `mul_add_one`, states that for any type `α` that is equipped with addition, multiplication, and the property that multiplication is left-distributive over addition, the multiplication of an element `a` with the sum of an element `b` and one is equal to the sum of `a` multipled by `b` and `a`. In other words, it's proving the principle of distribution for multiplication over addition, specifically when adding one, i.e., `a * (b + 1) = a * b + a`.

For any type `α` with additions and multiplications satisfying left-distributivity, `a * (b + 1) = a * b + a`.


theorem MeasureTheory.set_integral_pos_iff_support_of_nonneg_ae :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] {s : Set X} {μ : MeasureTheory.Measure X} {f : X → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae (μ.restrict s)] f →
        MeasureTheory.IntegrableOn f s μ → (0 < ∫ (x : X) in s, f x ∂μ ↔ 0 < ↑↑μ (Function.support f ∩ s)) :=
  by sorry

This theorem states that for a measurable space X, a given set `s` in X, a measure `μ` on X, and a real-valued function `f` defined on X, if `f` is non-negative almost everywhere on the restriction of `μ` to `s`, and `f` is integrable on `s` with respect to `μ`, then the integral of `f` over `s` is greater than zero if and only if the measure of the intersection of the support of `f` and `s` is greater than zero.

The support of `f` is defined as the set of points `x` such that `f(x) ≠ 0`. Intuitively, the theorem links the positivity of the integral of a function over a set to the measure of the region where the function is non-zero.

For a measurable space X, a measurable set s, a measure μ, a non-negative integrable function f on X, the integral of f over s is positive if and only if the measure of the support of f intersecting s is positive.


/-- If the image of a morphism under a fully faithful functor in an isomorphism,
then the original morphisms is also an isomorphism.
 -/
theorem CategoryTheory.isIso_of_fully_faithful :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [inst_2 : CategoryTheory.Full F]
      [inst_3 : CategoryTheory.Faithful F] {X Y : C} (f : X ⟶ Y) [inst_4 : CategoryTheory.IsIso (F.map f)],
      CategoryTheory.IsIso f :=
  by sorry

This theorem states that if a morphism's image under a fully faithful functor is an isomorphism in category theory, then the original morphism is also an isomorphism. In category theory, a functor is fully faithful if its function on morphisms is bijective. So, this theorem essentially says that under these conditions, the property of being an isomorphism is preserved through the functor.

If a functor that preserves isomorphisms and has bijective morphism maps maps a morphism to an isomorphism, then the original morphism is an isomorphism.


theorem measurable_inr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β], Measurable Sum.inr := by
  sorry

The theorem `measurable_inr` states that for any types `α` and `β` which are equipped with measurable spaces, the function `Sum.inr` is measurable. Here, `Sum.inr` is the function that takes an element of type `β` and puts it in the right component of the sum type `α + β`. In terms of measure theory, a function is measurable if the preimage of any measurable set is also measurable. So, this theorem is asserting that if you take a measurable set in the sum type `α + β`, its preimage under `Sum.inr` is a measurable set in `β`.

The theorem `measurable_inr` asserts that the right injection `Sum.inr` of a measurable sum type `α + β` is a measurable function from `β` to `α + β`.


theorem Set.OrdConnected.uIcc_subset :
    ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α},
      Set.OrdConnected s → ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → Set.uIcc x y ⊆ s :=
  by sorry

The theorem `Set.OrdConnected.uIcc_subset` states that for any type `α` with a linear order and any set `s` of `α` that is order-connected (meaning, for any two elements `a` and `b` in the set, if `a ≤ b`, then all elements `c` with `a ≤ c ≤ b` are also in the set), if `x` and `y` are elements in set `s`, then the set of all elements lying between `x` and `y` inclusive (denoted as `Set.uIcc x y`) is a subset of `s`. In other words, any continuous interval in an order-connected set remains within that set.

For any order-connected subset `s` of a linearly ordered type `α`, the interval `[x, y]` (or `{z : α | x ≤ z ≤ y}`) is contained in `s`, given `x, y ∈ s`.


Iff.or

/-- **Alias** of `or_congr`. -/
theorem Iff.or : ∀ {a c b d : Prop}, (a ↔ c) → (b ↔ d) → (a ∨ b ↔ c ∨ d) := by sorry

This theorem, named `Iff.or`, states that for any four propositions `a`, `c`, `b`, and `d`, if `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then the logical disjunction of `a` and `b` (`a ∨ b`) is logically equivalent to the logical disjunction of `c` and `d` (`c ∨ d`). This is essentially an alias for the `or_congr` theorem.

If `a` is equivalent to `c` and `b` is equivalent to `d`, then `a ∨ b` is equivalent to `c ∨ d`.


theorem neg_ball :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), -Metric.ball x δ = Metric.ball (-x) δ := by
  sorry

The theorem `neg_ball` states that for all types `E` that form a seminormed additive commutative group, and for any real number `δ` and any element `x` of `E`, the negation of the set of all points `y` where the distance between `y` and `x` is less than `δ` (`-Metric.ball x δ`) is equal to the set of all points `y` where the distance between `y` and the negation of `x` (`-x`) is less than `δ` (`Metric.ball (-x) δ`). This suggests an element-wise negation symmetry in the metric space around the origin.

For any seminormed additive commutative group `E` and real number `δ`, `-Metric.ball x δ = Metric.ball (-x) δ`.


theorem Nat.gcd_one_left : ∀ (n : ℕ), Nat.gcd 1 n = 1 := by sorry

This theorem states that for any natural number `n`, the greatest common divisor of 1 and `n` is 1. This result aligns with the mathematical principle that the greatest common divisor of any number and 1 is always 1.

The greatest common divisor of 1 and any natural number `n` equals 1.


theorem Finset.sdiff_union_inter : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), s \ t ∪ s ∩ t = s := by
  sorry

This theorem, `Finset.sdiff_union_inter`, states that for any type `α` which has a decidable equality and for any two finite sets `s` and `t` of type `α`, the union of the set difference of `s` and `t` and the intersection of `s` and `t` is equal to `s`. In other words, the elements of `s` that are not in `t` combined with the elements that `s` and `t` have in common together form `s`. This is an application of the principle of set theory that the union of the difference and intersection of two sets equals the first set.

For sets `s` and `t` of type `α` with decidable equality, `s = (s \ t) ∪ (s ∩ t)`.


theorem MeasureTheory.IsStoppingTime.measurableSet_le' :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) (i : ι), MeasurableSet {ω | τ ω ≤ i} :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_le'` states that for any types Ω and ι, a measurable space `m` on Ω, a linear order on ι, a filtration `f` of the measurable space, and a function `τ` from Ω to ι that is a stopping time with respect to the filtration `f`, for every `ι` instance `i`, the set of all `ω` in Ω such that `τ(ω)` is less than or equal to `i` is a measurable set in the measurable space. In other words, the set of outcomes where the stopping time is no later than a given time is a measurable set.

For any measurable space $(Ω, m)$, linear order $(ι, ≤)$, filtration $(f\_t : t ∈ ι)$ on $Ω$, and stopping time $τ : Ω → ι$, the set $\{ω ∈ Ω : τ(ω) ≤ i\}$ is measurable for all $i ∈ ι$.


theorem Left.sign_neg :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [inst_2 : DecidableRel fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α),
      SignType.sign (-a) = -SignType.sign a :=
  by sorry

This theorem states that for any element 'a' of type 'α', where 'α' is an additive group and has a preorder relation under which it is covariant, the sign of the negation of 'a' is the negation of the sign of 'a'. This means that if 'a' is positive, negative, or zero under this ordering, then negative 'a' will be negative, positive, or zero respectively. Here, the concept of positivity and negativity is defined using the `SignType.sign` function, which assigns 1 to positive elements, -1 to negative elements, and 0 to zero.

For any element 'a' in an additive group with covariant preorder, the sign of -a is the negation of the sign of a.


theorem CategoryTheory.Adjunction.right_triangle :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft G adj.unit)
          (CategoryTheory.whiskerRight adj.counit G) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.comp G (CategoryTheory.Functor.id C)) :=
  by sorry

The theorem `CategoryTheory.Adjunction.right_triangle` in Lean 4 states the right triangle identity in the context of category theory. Specifically, given any two categories `C` and `D`, and a pair of functors `F` from `C` to `D` and `G` from `D` to `C` forming an adjunction, the composition of the unit of the adjunction whiskered on the left with `G` and the counit of the adjunction whiskered on the right with `G` is equal to the identity morphism on the composition of `G` with the identity functor on `C`. In mathematical notation, this theorem can be expressed as $(G \dashv F) \Rightarrow G \eta \circ \epsilon G = 1_{G \circ 1_{C}}$, where $\eta$ and $\epsilon$ are the unit and counit of the adjunction respectively.

Given an adjunction between functors F : C -> D and G : D -> C, the composition of G with the unit η and followed by the counit ε is equal to the identity morphism on the composition of G and the identity functor on C: G η . εG = 1\_(G . Id\_C).


IsUnit.neg

theorem IsUnit.neg : ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] {a : α}, IsUnit a → IsUnit (-a) := by
  sorry

The theorem `IsUnit.neg` states that for any type `α` that is a monoid and has distributive negation, if an element `a` of `α` is a unit (i.e., it has a two-sided inverse), then the negation of `a` (denoted `-a`) is also a unit. In other words, the negation of a unit element in a monoid with distributive negation is also a unit element.

If `α` is a monoid with distributive negation and `a` is a unit in `α`, then `-a` is also a unit.


theorem Stream'.Seq.corec_eq :
    ∀ {α : Type u} {β : Type v} (f : β → Option (α × β)) (b : β),
      Stream'.Seq.destruct (Stream'.Seq.corec f b) = Stream'.Seq.omap (Stream'.Seq.corec f) (f b) :=
  by sorry

The theorem `Stream'.Seq.corec_eq` establishes an equality between the destruction of a coinductively built sequence and the functorial action on the function used to build this sequence. Specifically, for any types `α` and `β`, and a function `f` from `β` to `Option (α × β)` and an element `b` of type `β`, the result of destructing the sequence formed by co-recursively applying `f` to `b` (using `Stream'.Seq.corec`) is the same as the outcome of applying the functorial action (`Stream'.Seq.omap`) of `Stream'.Seq.corec f` to `f b`. This theorem essentially links the operations of destruction and functorial action in the context of coinductively generated sequences.

For any types `α` and `β` and function `f` from `β` to `Option (α × β)`, the co-recursively constructed sequence `Stream'.Seq.corec f` applied to an element `b` of type `β` is equal to the functorial action `Stream'.Seq.omap (Stream'.Seq.corec f)` applied to `f` on `b`.


/-- In a monoid, an element `a` divides an element `b` iff `a` divides all
associates of `b`.  -/
theorem Units.dvd_mul_right : ∀ {α : Type u_1} [inst : Monoid α] {a b : α} {u : αˣ}, a ∣ b * ↑u ↔ a ∣ b := by sorry

This theorem states that in a monoid (a kind of algebraic structure), an element 'a' divides another element 'b' if and only if 'a' divides all associates of 'b'. Here, 'a' and 'b' are elements of some type 'α', and 'u' is an invertible element (or unit) of 'α'. The symbol '∣' means 'divides'. That is, 'a' divides 'b' if there is some element 'c' such that 'b' equals 'a' times 'c'. The term 'associates of b' refers to all elements that can be obtained by multiplying 'b' by an invertible element.

In a monoid, an element 'a' divides another element 'b' if and only if 'a' divides all associates of 'b' (multiplied by some invertible element 'u').


IsOpenMap.prod

theorem IsOpenMap.prod :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
      IsOpenMap f → IsOpenMap g → IsOpenMap fun p => (f p.1, g p.2) :=
  by sorry

The theorem `IsOpenMap.prod` states that for any four types `X`, `Y`, `Z`, and `W` that each are topological spaces, given two functions `f : X → Y` and `g : Z → W` that are open maps (meaning that the image of any open set in `X` or `Z` is open in `Y` or `W` respectively), the function that takes a pair of points from `X` and `Z` and maps them to a pair in `Y` and `W` using `f` and `g` respectively, is also an open map.

Given two open maps `f : X → Y` and `g : Z → W` between topological spaces `X`, `Y`, `Z`, and `W`, the function `(f, g) : X × Z → Y × W` that maps `(x, z)` to `(f(x), g(z))` is an open map.


theorem Ordinal.sup_iterate_eq_nfp :
    ∀ (f : Ordinal.{u} → Ordinal.{u}), (fun a => Ordinal.sup fun n => f^[n] a) = Ordinal.nfp f := by sorry

The theorem `Ordinal.sup_iterate_eq_nfp` asserts that for any function `f` from an ordinal to an ordinal, the function that takes an ordinal `a` to the supremum of the sequence formed by iteratively applying `f` to `a` is equivalent to the next fixed point function of `f`. In more mathematical terms, if `f` is a function from an ordinal to an ordinal, then the function that maps `a` to the supremum of the sequence `{f^n(a) | n ∈ ℕ}` is the same as the least fixed point of `f` that is greater than or equal to `a`.

For any ordinal-valued function `f`, the supremum of the iterated sequence `{f^n(a) | n ∈ ℕ}` equals the least fixed point of `f` greater than or equal to `a`.


/-- If `x` is in the base field `K`, then the norm is `x ^ [L : K]`.

(If `L` is not finite-dimensional over `K`, then `norm = 1 = x ^ 0 = x ^ (finrank L K)`.)
 -/
theorem Algebra.norm_algebraMap :
    ∀ {K : Type u_4} [inst : Field K] {L : Type u_7} [inst_1 : Ring L] [inst_2 : Algebra K L] (x : K),
      (Algebra.norm K) ((algebraMap K L) x) = x ^ FiniteDimensional.finrank K L :=
  by sorry

The theorem `Algebra.norm_algebraMap` states that for any element `x` in the base field `K`, the norm (as defined by the function `Algebra.norm`) of the embedded value of `x` in an `R`-algebra `L` (where `K` is a field and `L` is a ring with an algebra structure over `K`) is equal to `x` raised to the power of the rank of `L` over `K` (`FiniteDimensional.finrank K L`).

In other words, this theorem describes the relationship between the norm of an element of the base field when embedded in an algebra, and the rank of the module constituted by the algebra over the base field. If `L` is not finite-dimensional over `K`, then the norm is `1`, since the rank is `0` and `x` to the power of `0` is `1`.

For any field extension K into an R-algebra L, the norm of an element x in K equals x raised to the power of the finite rank of L over K.


/-- In a Dedekind domain, the (nonzero) prime elements of the monoid with zero `Ideal A`
are exactly the prime ideals.  -/
theorem Ideal.prime_iff_isPrime :
    ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] {P : Ideal A},
      P ≠ ⊥ → (Prime P ↔ Ideal.IsPrime P) :=
  by sorry

This theorem states that in a Dedekind domain, a non-zero prime element of the monoid with zero that's formed by the ideals of the domain is equivalent to a prime ideal. Here, a Dedekind domain refers to a Commutative Ring 'A', and a prime element 'P' is defined as an element in the Ideal of 'A' that is not the additive identity. The theorem asserts that this prime element 'P' is a prime ideal if and only if it satisfies the conditions of a prime element, namely it is not zero, it is not a unit, and if it divides the product of two elements, then it must divide at least one of them.

In a Dedekind domain, an ideal generated by a non-zero, non-unit element is a prime ideal if and only if the element is a prime element.


theorem CategoryTheory.op_id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C},
      (CategoryTheory.CategoryStruct.id X).op = CategoryTheory.CategoryStruct.id (Opposite.op X) :=
  by sorry

The theorem `CategoryTheory.op_id` states that for any category `C` and any object `X` in `C`, taking the opposite of the identity morphism on `X` is the same as the identity morphism on the opposite of `X`. In other words, given any category and any object in that category, the operation of "oppositing" commutes with the operation of taking the identity morphism.

For any category C and object X in C, the opposite of the identity morphism on X is equal to the identity morphism on the opposite of X.


theorem Set.mulSupport_mulIndicator :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {f : α → M},
      Function.mulSupport (Set.mulIndicator s f) = s ∩ Function.mulSupport f :=
  by sorry

The theorem `Set.mulSupport_mulIndicator` states that for any set `s` of type `α` and any function `f` from `α` to `M` where `M` has a defined "one" element, the multiplicative support of the function defined by the multiplicative indicator of `s` and `f` is equivalent to the intersection of `s` and the multiplicative support of `f`. In other words, the set of points `x` where the multiplicative indicator function does not equal "one" is the same as the set of points `x` that are both in `s` and where `f(x)` does not equal "one".

The multiplicative support of the multiplicative indicator function of a set and a function is equal to the intersection of that set and the support of the function.


/-- The distance between two points in a set is controlled by the diameter of the set.  -/
theorem Metric.dist_le_diam_of_mem :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x y : α},
      Bornology.IsBounded s → x ∈ s → y ∈ s → dist x y ≤ Metric.diam s :=
  by sorry

This theorem states that for any type `α` with a `PseudoMetricSpace` instance, and for any set `s` of type `α` that is bounded (`Bornology.IsBounded`), if `x` and `y` are any two members of this set, then the distance between `x` and `y` is less than or equal to the diameter of the set `s`. In mathematical terms, if `s` is a bounded set in a pseudometric space and `x, y` are elements of `s`, then the distance between `x` and `y` (denoted `dist x y`) does not exceed the diameter of `s` (denoted `Metric.diam s`).

In any pseudometric space with a bounded set `s`, the distance between any two elements of `s` is less than or equal to the diameter of `s`.


theorem WithTop.add_lt_add_left :
    ∀ {α : Type u} [inst : Add α] {a b c : WithTop α} [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1], a ≠ ⊤ → b < c → a + b < a + c :=
  by sorry

This theorem states that for any type `α` implementing addition (`Add α`) and a less-than relation (`LT α`), and for any three elements `a`, `b`, and `c` of the type `WithTop α` (which represents the original type `α` augmented with an additional `top` element), if the `a` is not the `top` element (`a ≠ ⊤`) and `b` is less than `c` (`b < c`), then adding `a` to `b` is less than adding `a` to `c` (`a + b < a + c`). This is under the assumption that the type `α` satisfies the `CovariantClass` property with respect to the addition and less-than operations, which essentially requires the addition operation to be monotonic with respect to the less-than relation.

For types `α` with `Add α` and `LT α` such that `α` satisfies the `CovariantClass` property, if `a ≠ ⊤` and `b < c` in `WithTop α`, then `a + b < a + c`.


theorem Real.sin_pi_over_two_pow_succ :
    ∀ (n : ℕ), Real.sin (Real.pi / 2 ^ (n + 2)) = Real.sqrt (2 - Real.sqrtTwoAddSeries 0 n) / 2 := by sorry

This theorem states that for every natural number `n`, the sine of pi divided by 2 raised to the power of `n + 2` equals to the square root of the difference between 2 and the `n`-th term of the `sqrtTwoAddSeries` starting from 0, all divided by 2. In mathematical notation, for all natural numbers `n`, we have $\sin \left(\frac{\pi}{2^{n+2}}\right) = \frac{\sqrt{2 - \text{sqrtTwoAddSeries}(0,n)}}{2}$. This series, `sqrtTwoAddSeries`, represents an iterative calculation of square roots in the form of $\sqrt{2 + \sqrt{2 + \ldots}}$ with `n` square roots, starting with an initial value of 0.

For every natural number `n`, the sine of pi divided by 2 raised to the power of `n + 2` equals to half of the difference between 2 and the sum of the first `n` terms of the square root of 2 iterative series, `sqrtTwoAddSeries`, starting from 0.


theorem IsOpenMap.preimage_interior_eq_interior_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → Continuous f → ∀ (s : Set Y), f ⁻¹' interior s = interior (f ⁻¹' s) :=
  by sorry

This theorem states that for any function `f` mapping elements from a topological space `X` to another topological space `Y`, if `f` is an open map and is continuous, then for any set `s` in `Y`, the preimage of the interior of `s` under `f` is equal to the interior of the preimage of `s` under `f`. In mathematical terms, it says that for all open maps `f : X → Y` that are continuous, the preimage of the interior of a set is the same as the interior of the preimage of the set, i.e., `f⁻¹(interior(s)) = interior(f⁻¹(s))`.

If `f : X → Y` is a continuous open map between topological spaces, then for any open set `s` in `Y`, the preimage `f⁻¹(s)` is the interior of its preimage, i.e., `interior(f⁻¹(s)) = f⁻¹(interior(s))`.


theorem ENNReal.zero_div : ∀ {a : ENNReal}, 0 / a = 0 := by sorry

This theorem states that for any extended nonnegative real number `a`, the result of dividing zero by `a` is zero. This result holds true for all values of `a` in the extended nonnegative real numbers, including the special case where `a` is infinity.

For any extended nonnegative real number `a`, 0 / `a` = 0.


theorem Matroid.Base.eq_of_subset_indep :
    ∀ {α : Type u_1} {M : Matroid α} {B I : Set α}, M.Base B → M.Indep I → B ⊆ I → B = I := by sorry

This theorem states that for any type `α`, given a Matroid `M` on `α` and two sets `B` and `I` of elements of type `α`, if `B` is a base of `M`, `I` is independent in `M`, and `B` is a subset of `I`, then `B` and `I` are equal. In other words, in the context of a matroid, an independent set that contains a base must be equal to that base.

If `M` is a matroid on type `α`, `B` is a base of `M`, `I` is an independent set of `M`, and `B` is a subset of `I`, then `B = I`.


theorem List.perm_iff_count :
    ∀ {α : Type u_1} [inst : DecidableEq α] {l₁ l₂ : List α},
      List.Perm l₁ l₂ ↔ ∀ (a : α), List.count a l₁ = List.count a l₂ :=
  by sorry

This theorem, `List.perm_iff_count`, states that for any type `α` with decidable equality and any two lists `l₁` and `l₂` of type `α`, `l₁` is a permutation of `l₂` if and only if for every element `a` of type `α`, the count of `a` in `l₁` is equal to the count of `a` in `l₂`. In other words, two lists are permutations of each other if and only if every element appears the same number of times in both lists.

For any type `α` with decidable equality, lists `l₁` and `l₂` of type `α`, the lists are permutations of each other if and only if the count of each element in `l₁` equals the count of that element in `l₂`.


theorem Finset.affineCombinationSingleWeights_apply_self :
    ∀ (k : Type u_1) [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] (i : ι),
      Finset.affineCombinationSingleWeights k i i = 1 :=
  by sorry

This theorem states that for any type `k` that forms a ring, and any type `ι` with decidable equality, and any element `i` of type ι, the value of the function `affineCombinationSingleWeights` (defined on `k` and `ι`) at `i` is 1. In simpler terms, when the function `affineCombinationSingleWeights` is applied to the same index twice, it always returns 1. This function is used to create a set of weights for an affine combination where all weights are zero except for the weight at a single point `i`, which is 1. In this context, an affine combination is a weighted sum where the weights sum to 1.

For any ring type `k` and decidably equal type `ι`, the function `affineCombinationSingleWeights` on `k` and `ι` returns 1 when applied to the same element `i` of type `ι`.


theorem Submodule.span_insert :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M)
      (s : Set M), Submodule.span R (insert x s) = Submodule.span R {x} ⊔ Submodule.span R s :=
  by sorry

This theorem states that for any semiring `R`, an additively commutative monoid `M` and any `R`-module `M`, for any `x` in `M` and any set `s` of `M`, the span of the set obtained by inserting `x` into `s` is equal to the sup (i.e., least upper bound) of the span of the set `{x}` and the span of `s`. In other words, the smallest submodule of `M` that contains both `x` and `s` is the least upper bound of the smallest submodule containing `x` and the smallest submodule containing `s`.

For any semiring `R`, an additively commutative monoid `M`, and `R`-module `M`, the span of `{x}` together with the span of a set `s` in `M` is equal to the span of `x` union `s`. (Here, the span of a set is the submodule it generates.)


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.8 :
    ∀ {A : Type u_4} {M₁ : Type u_5} [inst : SetLike A M₁] [inst_1 : Zero M₁] [hA : ZeroMemClass A M₁] {S' : A}
      {x : ↥S'}, (↑x = 0) = (x = 0) :=
  by sorry

This theorem states that for any type `A`, any `M₁` of type `A`, given that `A` acts like a set on `M₁`, `M₁` has a zero element, and `A` contains the zero of `M₁`, and for any `S'` of type `A` and any `x` that belongs to `S'`, the proposition that `x` is equal to `0` when upcast from `S'` to `M₁` is equivalent to the proposition that `x` equals `0` within `S'`. In other words, the zero element in the subtype `S'` is the same as the zero element in the supertype `M₁` when `x` is an element of `S'`.

For any type `A` with a zero element `0`, and for any subtype `S` of `A` with the same zero element, any element `x` in `S` equals `0` in `S` if and only if it equals `0` in `A`.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.2 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {S : AddSubmonoid N} {f : F} {x : M},
      (x ∈ AddSubmonoid.comap f S) = (f x ∈ S) :=
  by sorry

The theorem `Mathlib.GroupTheory.Submonoid.Operations._auxLemma.2` states that for any types `M` and `N` with `AddZeroClass` instances (meaning they have additive structures with a zero element), a type `F` which has `FunLike` and `AddMonoidHomClass` instances (meaning it can behave like a function and is a homomorphism between additive monoids), an additive submonoid `S` of `N`, a function `f` of type `F`, and an element `x` of `M`, an element `x` belongs to the preimage of the submonoid `S` under the function `f` if and only if the function `f` applied to `x` belongs to `S`.

In mathematical terms, it basically says that the preimage of a submonoid under a function is indeed a submonoid.

The preimage of an additive submonoid under a homomorphism is a submonoid.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.1 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {S : Submonoid N} {f : F} {x : M},
      (x ∈ Submonoid.comap f S) = (f x ∈ S) :=
  by sorry

This theorem states that for any types `M`, `N`, and `F` and for any instances of `MulOneClass` on `M` and `N`, any instance of `FunLike` from `F` to a function from `M` to `N`, and any instance of `MonoidHomClass` on `F`, `M` and `N`, if `S` is a submonoid of `N` and `f` is a function of type `F`, then for any element `x` of `M`, `x` belongs to the preimage of the submonoid `S` along the monoid homomorphism `f` if and only if `f(x)` belongs to `S`. In simpler terms, it means that an element is in the preimage submonoid under a homomorphism if its image under the homomorphism is in the original submonoid.

For any monoid homomorphisms between types `M`, `N`, and `F` with `MulOneClass` and `MonoidHomClass` instances, an element `x` in `M` is in the preimage of submonoid `S` in `N` under `f` if and only if `f(x)` belongs to `S`.


/-- Post-composition by a uniformly continuous function is uniformly continuous for the
uniform structures of `𝔖`-convergence.

More precisely, if `f : γ → β` is uniformly continuous, then
`(fun g ↦ f ∘ g) : (α →ᵤ[𝔖] γ) → (α →ᵤ[𝔖] β)` is uniformly continuous.  -/
theorem UniformOnFun.postcomp_uniformContinuous :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] {𝔖 : Set (Set α)} [inst_1 : UniformSpace γ]
      {f : γ → β},
      UniformContinuous f → UniformContinuous (⇑(UniformOnFun.ofFun 𝔖) ∘ (fun x => f ∘ x) ∘ ⇑(UniformOnFun.toFun 𝔖)) :=
  by sorry

This theorem states that post-composing a function by a uniformly continuous function results in a uniformly continuous function, under a uniform structure of set-convergence. More specifically, given a uniformly continuous function `f` from `γ` to `β`, the operation `(fun g ↦ f ∘ g)` that post-composes any function `g` from `α` to `γ` with `f` produces a uniformly continuous function from `α` to `β`. This holds true for any uniform spaces `β` and `γ`, and any set `𝔖` of sets of `α`.

Given uniform spaces `β` and `γ`, and a uniformly continuous function `f` from `γ` to `β`, the function `(fun g ↦ f ∘ g)` is uniformly continuous from `α` to `β` for any set `𝔖` of sets of `α`.


theorem MeasureTheory.Measure.MutuallySingular.mono_ac :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ ν₁ ν₂ : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular μ₁ ν₁ →
        MeasureTheory.Measure.AbsolutelyContinuous μ₂ μ₁ →
          MeasureTheory.Measure.AbsolutelyContinuous ν₂ ν₁ → MeasureTheory.Measure.MutuallySingular μ₂ ν₂ :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.mono_ac` states that for any type `α` and any measurable space `m0` over `α`, if we have two pairs of measures, `(μ₁, ν₁)` and `(μ₂, ν₂)`, such that `μ₁` and `ν₁` are mutually singular, `μ₂` is absolutely continuous with respect to `μ₁`, and `ν₂` is absolutely continuous with respect to `ν₁`, then `μ₂` and `ν₂` are also mutually singular.

In terms of measure theory, a pair of measures is said to be mutually singular if there exists a measurable set such that one measure is zero on this set and the other is zero on the complement of this set. A measure is absolutely continuous with respect to another measure if whenever the latter measure assigns zero to a set, so does the former. Thus, the theorem is essentially saying that the property of mutual singularity is preserved under absolute continuity.

If two measures `μ₁` and `ν₁` are mutually singular over a measurable space `m0`, and `μ₂` is absolutely continuous with respect to `μ₁` while `ν₂` is absolutely continuous with respect to `ν₁`, then `μ₂` and `ν₂` are mutually singular.


theorem Finset.biUnion_image_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      (Finset.biUnion s fun a => Finset.image (f a) t) = Finset.image₂ f s t :=
  by sorry

The theorem `Finset.biUnion_image_left` states that for all types `α`, `β`, and `γ` with `γ` having a decidable equality and given a binary function `f : α → β → γ` and finite sets `s : Finset α` and `t : Finset β`, the bi-union over `s` of the image of function `f a` applied on `t` is equivalent to the image of the binary function `f` applied on sets `s` and `t`. Here, the image of a function refers to the set of output values the function takes when applied to every element of the input set. This theorem essentially equates a union operation followed by an image operation with the image operation of a binary function.

For functions between decidably equal types, the image of the bi-union of two sets under a binary function is equivalent to the bi-union of the images of each set under that function.


theorem Polynomial.mem_rootSet :
    ∀ {T : Type w} [inst : CommRing T] {p : Polynomial T} {S : Type u_1} [inst_1 : CommRing S] [inst_2 : IsDomain S]
      [inst_3 : Algebra T S] [inst_4 : NoZeroSMulDivisors T S] {a : S},
      a ∈ Polynomial.rootSet p S ↔ p ≠ 0 ∧ (Polynomial.aeval a) p = 0 :=
  by sorry

The theorem `Polynomial.mem_rootSet` states that for all types `T` and `S`, where `T` is a commutative ring and `S` is a commutative ring that is also a domain, and where `S` is an `T`-algebra which has no zero scalar multiplication and division, a value `a` of type `S` is in the set of distinct roots of a polynomial `p` of type `T` if and only if the polynomial `p` is not the zero polynomial and the unique `T`-algebra homomorphism from `T[X]` to `S` sending `X` to `a` applied to `p` equals zero. Stated more simply, `a` is a root of `p` if and only if `p` is not the zero polynomial and when `p` is evaluated at `a`, the result is zero.

A value `a` in a commutative domain `S` that is an `T`-algebra of a commutative ring `T` with no zero scalar multiplication and division, is a root of polynomial `p` in `T[X]` if and only if `p` is not the zero polynomial and `p(a) = 0` in `S`.


/-- **Alias** of `Left.neg_lt_self`. -/
theorem neg_lt_self :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, 0 < a → -a < a :=
  by sorry

The theorem `neg_lt_self` is an alias of `Left.neg_lt_self`. It states that for any type `α`, if `α` is an additive group and has a preorder, and if addition on `α` is covariant, then for any value `a` in `α`, if `0` is less than `a`, then the negative of `a` is less than `a`. In other words, for positive `a`, `-a` is less than `a`.

For any additive group `α` with a preorder and covariant addition, if `0 < a` in `α`, then `-a < a`.


theorem Set.range_eq_iff :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set β),
      Set.range f = s ↔ (∀ (a : α), f a ∈ s) ∧ ∀ b ∈ s, ∃ a, f a = b :=
  by sorry

The theorem `Set.range_eq_iff` states that for any two types `α` and `β`, and any function `f` from `α` to `β`, and any set `s` of type `β`, the range of `f` is equal to `s` if and only if every element of `α` when mapped by `f` is in `s`, and for every element in `s`, there exists an element in `α` such that when this element is mapped by `f`, it equals the given element in `s`. In other words, the range of `f` is exactly `s` if all outputs of `f` are in `s` and all elements of `s` can be obtained by applying `f` to some inputs.

For any function `f` from type `α` to type `β` and set `s` of type `β`, the range of `f` equals `s` if and only if for all `x` in `α`, `f x` is in `s`, and for all `y` in `s`, there exists an `x` in `α` such that `f x = y`.


Action.Hom.ext

theorem Action.Hom.ext :
    ∀ {V : Type (u + 1)} {inst : CategoryTheory.LargeCategory V} {G : MonCat} {M N : Action V G} (x y : Action.Hom M N),
      x.hom = y.hom → x = y :=
  by sorry

This theorem states that for any large category `V` and any monoid `G` in the category of monoids (`MonCat`), given two actions `M` and `N` of `G` on objects in `V`, if we have two morphisms (`Action.Hom`) `x` and `y` from `M` to `N`, then if the `hom` component of `x` and `y` (the actual function maps of `x` and `y`) are the same, it implies that `x` and `y` are the same. Essentially, it guarantees uniqueness of morphisms in this context based on their function maps.

In any large category `V` and for any monoid `G` in `MonCat`, if two `G`-actions `M` and `N` on objects of `V` have homomorphisms `x: M -> N` and `y: M -> N` with equal function components, then `x = y`.


Antivary.symm

theorem Antivary.symm :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : LinearOrder β] {f : ι → α} {g : ι → β},
      Antivary f g → Antivary g f :=
  by sorry

This theorem states that for any types `ι`, `α`, `β` where `α` and `β` have a preorder and `β` has a linear order, if a function `f` from `ι` to `α` antivaries with a function `g` from `ι` to `β` (meaning that whenever `g(i)` is less than `g(j)`, `f(j)` is less than or equal to `f(i)`), then it must be the case that `g` antivaries with `f` as well. In other words, if `f(i)` is less than `f(j)`, then `g(j)` must be less than or equal to `g(i)`. This theorem essentially states that the antivariation relationship between two functions is symmetric.

If `f: ι → α` antivaries with `g: ι → β`, where `α` and `β` have a preorder and `β` has a linear order, then `g` antivaries with `f`. That is, `f(i) ≤ f(j)` implies `g(j) ≤ g(i)`.


theorem Set.Ico_diff_left : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Ico a b \ {a} = Set.Ioo a b := by
  sorry

The theorem `Set.Ico_diff_left` states that for any type `α` with a defined partial order, and any two elements `a` and `b` in `α`, removing the left endpoint `a` from the left-closed right-open interval `[a, b)` (denoted by `Set.Ico a b`) results in the left-open right-open interval `(a, b)` (denoted by `Set.Ioo a b`). In other words, subtracting the singleton set `{a}` from the interval `[a, b)` yields the interval `(a, b)`. This is a theorem about the relationship between different types of intervals in an ordered set.

For any type `α` with a partial order and any `a < b` in `α`, `Set.Ico a b \ {a} = Set.Ioo a b`.


theorem Finset.tsum_subtype :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : Finset β) (f : β → α),
      ∑' (x : { x // x ∈ s }), f ↑x = Finset.sum s fun x => f x :=
  by sorry

This theorem, `Finset.tsum_subtype`, states that for any types `α` and `β`, given an additive commutative monoid structure on `α` and a topological space structure on `α`, for any finite set `s` of type `β` and any function `f` from `β` to `α`, the infinite sum or topological sum (denoted by `∑'`) over all elements `x` in `s` of `f` applied to the subtype `x` (where the subtype is defined by the property that `x` is in `s`) is equal to the finite sum (denoted by `Finset.sum`) over all elements `x` in `s` of `f` applied to `x`. This is an important property that connects the concept of an infinite sum in topology with the finite sum operation on finite sets.

For any additive commutative monoid `α` with topological space structure, and any finite set `s` and function `f` from a type `β` to `α`, the infinite topological sum over `s` of `f` applied to the subtype of `s` is equal to the finite sum over `s` of `f` applied to each element.


/-- If the same point added to two group elements produces equal
results, those group elements are equal.  -/
theorem vadd_right_cancel :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {g₁ g₂ : G} (p : P),
      g₁ +ᵥ p = g₂ +ᵥ p → g₁ = g₂ :=
  by sorry

This theorem states that for any two elements (`g₁` and `g₂`) from an additive group `G` and a point `p` from a set `P` that forms an additive torsor with `G`, if adding the same point `p` to both `g₁` and `g₂` results in the same value, then `g₁` and `g₂` must be equal to each other. An additive group is a set equipped with an addition operation that is associative, commutative, has an identity element, and every element has an inverse. An additive torsor is a set that behaves like an additive group without an identity element, it is usually a set of "points" on which the group "acts".

If `g₁` and `g₂` are elements of an additive group `G`, and `p` is a point in a set `P` forming an additive torsor with `G`, then `g₁ + p = g₂ + p` implies `g₁ = g₂`.


theorem measurable_from_prod_countable :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} [inst : Countable β]
      [inst : MeasurableSingletonClass β] {x : MeasurableSpace γ} {f : α × β → γ},
      (∀ (y : β), Measurable fun x => f (x, y)) → Measurable f :=
  by sorry

The theorem `measurable_from_prod_countable` states that given three types `α`, `β`, and `γ`, measurable spaces `α` and `β`, a countable type `β`, a measurable singleton class `β`, a measurable space `γ`, and a function `f` from the product of `α` and `β` to `γ`, if for every `y` in `β`, the function that takes an `x` in `α` and maps it to `f` applied to the pair `(x, y)` is measurable, then the function `f` itself is measurable. In other words, this theorem asserts that if a function from a product space is measurable when fixed by any element of a countable set, then the function is measurable.

If a function from the product of two measurable spaces, where one is countable, is measurable when fixed by each element in the countable space, then the function is measurable.


/-- The sine of an angle in a right-angled triangle as a ratio of sides.  -/
theorem InnerProductGeometry.sin_angle_add_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → x ≠ 0 ∨ y ≠ 0 → Real.sin (InnerProductGeometry.angle x (x + y)) = ‖y‖ / ‖x + y‖ :=
  by sorry

This theorem describes the sine of the angle in a right-angled triangle formed by two vectors in an inner product space over the real numbers. More specifically, if the inner product of vectors `x` and `y` is zero and at least one of them is non-zero, then the sine of the angle between `x` and `x + y` is equal to the ratio of the norm of `y` to the norm of `x + y`. This corresponds to the geometric concept of the sine of an angle in a right triangle being the ratio of the length of the opposite side to the hypotenuse.

If vectors `x` and `y` in an inner product space over the real numbers have zero inner product and `x ≠ 0`, then the sine of the angle between `x` and `x + y` equals the ratio of the norm of `y` to the norm of `x + y`.


theorem MeasureTheory.AEEqFun.coeFn_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] [inst_2 : Preorder β] {f g : α →ₘ[μ] β},
      ↑f ≤ᶠ[MeasureTheory.Measure.ae μ] ↑g ↔ f ≤ g :=
  by sorry

This theorem states that for any types `α` and `β`, given a measurable space over `α`, a measure `μ` on that space, a topological space over `β`, a preorder (an order relation that is reflexive and transitive) on `β`, and two functions `f` and `g` from `α` to `β` that are equal almost everywhere with respect to measure `μ`, the function `f` is less than or equal to function `g` almost everywhere (with respect to the filter of co-null sets of the measure `μ`) if and only if `f` is less than or equal to `g`. Basically, this theorem establishes the connection between the pointwise order of functions and the order in the space of functions that are equal almost everywhere.

Given measurable spaces `(α, ℳα)` and `(β, ℳβ)`, measures `μ` on `α`, a topological space `(β, τ)`, a preorder relation `≤` on `β`, and functions `f, g : α → β` equal almost everywhere with respect to `μ`, if `f ≤ g` almost everywhere with respect to the filter of co-null sets of `μ`, then `f ≤ g` pointwise.


theorem Set.insert_eq_self : ∀ {α : Type u} {a : α} {s : Set α}, insert a s = s ↔ a ∈ s := by sorry

This theorem states that for any type `α`, an element `a` of type `α`, and a set `s` of type `α`, inserting the element `a` into the set `s` results in the same set `s` if and only if the element `a` is already in the set `s`. In other words, it asserts that a set remains unchanged by inserting an element that it already contains.

For any set `s` and element `a` of type `α`, `a ∈ s` if and only if `s.insert a = s`.


multiplicity.unique

theorem multiplicity.unique :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {k : ℕ},
      a ^ k ∣ b → ¬a ^ (k + 1) ∣ b → ↑k = multiplicity a b :=
  by sorry

The theorem `multiplicity.unique` states that for any type `α` that forms a monoid and an operation `∣` which is a decidable relation, if we have elements `a` and `b` of `α` and a natural number `k` such that `a ^ k` divides `b` but `a ^ (k + 1)` does not divide `b`, then `k` equals the multiplicity of `a` in `b`. Here, the multiplicity of `a` in `b` refers to the largest natural number `n` such that `a^n` divides `b`.

If `α` is a monoid type with decidable divisibility relation `|`, and `a`, `b` are elements of `α` such that `a^k` divides `b` but `a^(k+1)` does not, then `k` is the multiplicity of `a` in `b`.


theorem FractionalIdeal.coe_mul :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      (I J : FractionalIdeal S P), ↑(I * J) = ↑I * ↑J :=
  by sorry

This theorem states that for any commutative ring `R`, a submonoid `S` of `R`, and a type `P` that is also a commutative ring and an `R`-algebra, if `I` and `J` are fractional ideals of `S` in `P`, then the product of `I` and `J` as fractional ideals is equal to the product of `I` and `J` in the underlying structure of `P`. In other words, the operation of multiplication on fractional ideals is consistent with the multiplication on the underlying structure.

For any commutative rings `R`, `P` with `R` a subring of `P`, a commutative submonoid `S` of `R`, and fractional ideals `I` and `J` of `S` in `P`, the product of `I` and `J` as fractional ideals equals their product as ideals in `P`.


theorem Bornology.IsBounded.subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α},
      Bornology.IsBounded s → ∀ (c : α), ∃ r, s ⊆ Metric.closedBall c r :=
  by sorry

This theorem states that for any type `α` that is a pseudometric space, and for any set `s` of this type, if `s` is bounded according to the bornology of `α`, then for any chosen element `c` from `α`, there exists a real number `r` such that `s` is a subset of the closed ball centered at `c` with radius `r`. Here, a closed ball in a pseudometric space is defined as the set of all points whose distance from the center is less than or equal to the radius, and a set is said to be bounded according to the bornology if its complement is co-bounded.

For any bounded subset `s` of a pseudometric space `α` with respect to its bornology, there exists a real number `r` such that `s` is contained in the closed ball centered at any chosen point `c` in `α` with radius `r`.


theorem Filter.HasBasis.limsSup_eq_iInf_sSup :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α},
      Filter.HasBasis f p s → Filter.limsSup f = ⨅ i, ⨅ (_ : p i), sSup (s i) :=
  by sorry

The theorem `Filter.HasBasis.limsSup_eq_iInf_sSup` states that for any type `α` that forms a Complete Lattice, any index type `ι`, any predicate `p` on `ι`, any function `s` mapping `ι` to sets of `α`, and any filter `f` on `α`, if the filter `f` has a basis characterized by the predicate `p` and the sets `s i`, then the limit superior (limsup) of the filter `f` equals the infimum over all `i` such that `p i` holds, of the supremum of `s i`. In mathematical notation, this is $\limsup f = \inf_{i : p(i)} \sup s_i$.

The limit superior of a complete lattice's filter is equal to the infimum over indices with property `p` of the supremum of the associated sets. In mathematical notation: $\limsup f = \inf\_{i : p(i)} \sup s\_i$.


/-- For an injective function `f`, inverse images of finite sets are finite. See also
`Filter.comap_cofinite_le` and `Function.Injective.comap_cofinite_eq`.  -/
theorem Function.Injective.tendsto_cofinite :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β},
      Function.Injective f → Filter.Tendsto f Filter.cofinite Filter.cofinite :=
  by sorry

This theorem states that for an injective function `f` from a type `α` to a type `β`, the inverse image of any finite set is also finite. In other words, if `f` is such that no two different elements in `α` have the same image in `β`, then when we consider any finite set in `β` and look at its pre-images in `α` under the function `f`, the set of such pre-images is also finite. This can be thought of as a property of the function `f` "preserving" the finiteness of sets under the operation of taking pre-images. This theorem is related to the concept of "cofinite" filters, which are filters of subsets whose complements are finite.

If `f` is an injective function from a type `α` to a type `β`, then the preimage of any finite subset of `β` under `f` is a finite subset of `α`.


theorem Polynomial.roots_mul :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p q : Polynomial R},
      p * q ≠ 0 → Polynomial.roots (p * q) = Polynomial.roots p + Polynomial.roots q :=
  by sorry

The theorem `Polynomial.roots_mul` states that for any commutative ring `R` with unity, given that `R` is an integral domain and `p` and `q` are polynomials over `R`, if the product of `p` and `q` is not equal to zero, then the roots of the polynomial resulting from the product of `p` and `q` is equal to the sum of the roots of `p` and the roots of `q`. This means that the roots of the multiplied polynomials are the union of the roots of the original polynomials, including their multiplicities.

If `R` is a commutative ring with unity, an integral domain, and `p` and `q` are non-zero polynomials over `R`, then the roots of `p * q` are the union of the roots of `p` and `q`, each root having multiplicity equal to its multiplicity in `p` plus its multiplicity in `q`.


CategoryTheory.Monad.assoc

theorem CategoryTheory.Monad.assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (X : C),
      CategoryTheory.CategoryStruct.comp (T.map ((CategoryTheory.Monad.μ T).app X)) ((CategoryTheory.Monad.μ T).app X) =
        CategoryTheory.CategoryStruct.comp ((CategoryTheory.Monad.μ T).app (T.obj X))
          ((CategoryTheory.Monad.μ T).app X) :=
  by sorry

This theorem states that for any category `C` and any monad `T` on `C`, and for any object `X` in `C`, the composition of the multiplication of the monad `T`, first applied to the image of `X` under `T` and then to `X`, is equal to the composition of the multiplication of `T` applied to `T(X)` and then to `X`.

In mathematical terms, we can express this as a form of associativity for the multiplication of the monad: μ(T(X)) ∘ μ(X) = μ(T(T(X))) ∘ μ(X) for all `X` in `C`, where μ denotes the multiplication of the monad `T`, and the ∘ symbol denotes the morphism composition in the category `C`.

For any monad `T` in a category `C` and object `X` in `C`, the commutativity of multiplications holds: `μ(T(X)) ∘ μ(X) = μ(T(T(X))) ∘ μ(X)`.


theorem Multiset.sum_hom :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : AddCommMonoid β] (s : Multiset α) {F : Type u_5}
      [inst_2 : FunLike F α β] [inst_3 : AddMonoidHomClass F α β] (f : F),
      Multiset.sum (Multiset.map (⇑f) s) = f (Multiset.sum s) :=
  by sorry

The theorem `Multiset.sum_hom` establishes that for all types `α` and `β` where both `α` and `β` are equipped with a commutative additive monoid structure, and for a multiset `s` of type `α`, for all types `F` which are function-like from `α` to `β` and are also a homomorphism between the additive monoids of `α` and `β`, the sum of the multiset obtained by mapping a function `f` of type `F` over `s` is equal to the value of function `f` applied to the sum of multiset `s`. This means that the process of summing elements in a multiset commutes with the operation of mapping a homomorphism over the multiset.

For all commutative additive monoids `α` and `β`, and for any homomorphism `F` from `α` to `β` and multiset `s` over `α`, the sum of `F` applied to the multiset `s` equals `F` applied to the sum of `s`.


theorem Equiv.Perm.refl_mul : ∀ {α : Type u} (e : Equiv.Perm α), Equiv.refl α * e = e := by sorry

The theorem `Equiv.Perm.refl_mul` states that for every type `α` and for every permutation `e` of `α` (i.e., a bijective function from `α` to itself), multiplying the identity function (represented as `Equiv.refl α`) with `e` results in `e`. In other words, the identity permutation acts as the multiplicative identity in the group of all permutations of a given type.

For every type `α` and every permutation `e` of `α`, `Equiv.refl α * e = e`.


theorem descPochhammer_succ_right :
    ∀ (R : Type u) [inst : Ring R] (n : ℕ), descPochhammer R (n + 1) = descPochhammer R n * (Polynomial.X - ↑n) := by
  sorry

The theorem `descPochhammer_succ_right` states that for any type `R` that forms a ring and any natural number `n`, the descending Pochhammer symbol of `n+1` is equal to the descending Pochhammer symbol of `n` multiplied by the polynomial `X - n`. In mathematical terms, the theorem says that the polynomial `X * (X - 1) * ... * (X - (n+1) + 1)` is the same as `((X * (X - 1) * ... * (X - n + 1)) * (X - n)`. This theorem shows the recursive property of the descending Pochhammer symbol in terms of polynomials.

The descending Pochhammer symbol `(X-n)_n` equals `(X-n) * (X-n+1)_(n-1)` for any ring type `R` and natural number `n`.


theorem Set.disjoint_empty : ∀ {α : Type u} (s : Set α), Disjoint s ∅ := by sorry

The theorem `Set.disjoint_empty` states that for all types `α` and for any set `s` of type `α`, the set `s` is disjoint with the empty set. In the context of this theorem, two sets are considered disjoint if their intersection (infimum) is the bottom element, which is the empty set in this case.

For all types α, the empty set is disjoint from any set s of type α. In other words, the intersection of s and the empty set is the empty set.


theorem Basis.apply_eq_iff :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {b : Basis ι R M} {x : M} {i : ι}, b i = x ↔ b.repr x = fun₀ | i => 1 :=
  by sorry

The theorem `Basis.apply_eq_iff` states that for any types `ι`, `R`, and `M`, given a semiring structure for `R`, an additive commutative monoid structure for `M`, and a module structure for `R` and `M`, for any basis `b` of type `Basis ι R M`, any element `x` of `M`, and any index `i` of `ι`, `b i` equals `x` if and only if the representation of `x` with respect to the basis `b` is a function that gives `1` when applied to `i` and gives `0` when applied to all other indices. In other words, `x` is the `i`-th basis vector if and only if its representation in terms of the basis is a function that is `1` at `i` and `0` everywhere else.

For any semiring `R`, additive commutative monoid `M`, and basis `b` of type `Basis ι R M`, an element `x` of `M` equals `b i` if and only if the representation of `x` with respect to `b` is the function that maps `i` to `1` and all other indices to `0`.


theorem Sum.inr_lt_inr_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : β}, Sum.inr a < Sum.inr b ↔ a < b := by sorry

This theorem states that for any two types `α` and `β`, where the `<` (less than) relation is defined on both `α` and `β`, and for any two instances `a` and `b` of type `β`, the sum type instance `Sum.inr a` is less than `Sum.inr b` if and only if `a` is less than `b`. In other words, the ordering of the instances in the sum type `Sum.inr` is preserved from the original type `β`.

For any types `α` with a defined `<` relation and instances `a` and `b` of type `β`, where `<` is defined, `Sum.inr a < Sum.inr b` if and only if `a < b`.


Asymptotics.IsBigOWith.weaken

theorem Asymptotics.IsBigOWith.weaken :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {c c' : ℝ}
      {f : α → E} {g' : α → F'} {l : Filter α},
      Asymptotics.IsBigOWith c l f g' → c ≤ c' → Asymptotics.IsBigOWith c' l f g' :=
  by sorry

The theorem `Asymptotics.IsBigOWith.weaken` states that for any types `α`, `E`, `F'`, any norm on `E`, any semi-normed add commutative group `F'`, any real numbers `c` and `c'`, any functions `f : α → E` and `g' : α → F'`, and any filter `l` on `α`, if the function `f` is Big O of the function `g'` with respect to the filter `l` and the constant `c`, and `c` is less than or equal to `c'`, then `f` is also Big O of `g'` with respect to the filter `l` and the constant `c'`. In other words, we can increase the Big O constant without affecting the Big O relation.

If `f` is Big O of `g'` with respect to filter `l` and constant `c`, and `c <= c'`, then `f` is still Big O of `g'` with respect to filter `l` and constant `c'`.


theorem seq_eq_bind_map :
    ∀ {m : Type u → Type u_1} {α β : Type u} [inst : Monad m] [inst_1 : LawfulMonad m] (f : m (α → β)) (x : m α),
      (Seq.seq f fun x_1 => x) = do
        let x_1 ← f
        x_1 <$> x :=
  by sorry

The theorem `seq_eq_bind_map` states that, for any types `α` and `β`, any monad `m`, and any two terms (values of the monad), `f : m (α → β)` and `x : m α`, the sequence operation (`Seq.seq`) of `f` and `x` is equivalent to first binding the function `f` to a variable `x_1` and then applying this function `x_1` to `x` using the map operation (`<$>`). This theorem bridges the concepts of sequencing and binding in the context of monads, showing that they are equivalent under these conditions.

For any monad `m`, terms `f : m (α → β)` and `x : m α`, `Seq.seq f x` is equal to `do {x_1 ← f; x_2 ← x; return (x_1 x_2)}`.