/-- This lemma matches more generally than
`Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk` when using `rw ← `. -/
theorem Finset.Nat.sum_antidiagonal_eq_sum_range_succ :
    ∀ {M : Type u_3} [inst : AddCommMonoid M] (f : ℕ → ℕ → M) (n : ℕ),
      (Finset.sum (Finset.antidiagonal n) fun ij => f ij.1 ij.2) =
        Finset.sum (Finset.range (Nat.succ n)) fun k => f k (n - k) :=
  by sorry

This theorem, `Finset.Nat.sum_antidiagonal_eq_sum_range_succ`, states that for any type `M` equipped with an additive commutative monoid structure, a function `f` from pairs of natural numbers to `M`, and a natural number `n`, the sum of `f` over the antidiagonal of `n` is equal to the sum of `f` over the range of `n + 1`, where the function `f` is applied to each element `k` in the range and `n - k`. In other words, summing up `f(i, j)` for all `(i, j)` in the antidiagonal of `n` (i.e., all pairs of nonnegative integers that add up to `n`) gives the same result as summing up `f(k, n - k)` for all `k` from `0` to `n`.

For any additive commutative monoid-valued function `f` on pairs of natural numbers, the sum of `f` over the antidiagonal of size `n` equals the sum over the range from `0` to `n` applying `f` to `(k, n - k)`.


theorem Set.prod_subset_preimage_fst :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), s ×ˢ t ⊆ Prod.fst ⁻¹' s := by sorry

This theorem states that for any two sets `s` of arbitrary type `α` and `t` of arbitrary type `β`, the cartesian product of `s` and `t` (denoted as `s ×ˢ t` in Lean), is a subset of the preimage of `s` under the function `Prod.fst`.

In other words, for all pairs `(a, b)` in the cartesian product of `s` and `t`, the first element `a` of the pair is in set `s`. `Prod.fst` is a function that takes a pair and returns its first element. The expression `Prod.fst ⁻¹' s` represents the preimage of `s` under `Prod.fst`, that is, all pairs `(a, b)` such that `a` belongs to `s`.

 For any sets `s` of type `α` and `t` of type `β`, the cartesian product `s × Catalisate t` is a subset of the preimage `(⁺» Prod.fst <$> s)` of `s` under the function `Prod.fst`. (In Lean notation)

Or in more traditional mathematical notation:

For all `(a, b)` in `s × t`, `a` is an element of `s`.


theorem Metric.vadd_ball :
    ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
      [inst_3 : IsometricVAdd G X] (c : G) (x : X) (r : ℝ), c +ᵥ Metric.ball x r = Metric.ball (c +ᵥ x) r :=
  by sorry

The theorem `Metric.vadd_ball` states that for any pseudo metric space `X`, any add group `G`, any action of `G` on `X`, and any isometric additive action of `G` on `X`, given a group element `c`, a point `x` in `X`, and a real number `r`, the set obtained by adding `c` to every point in the open ball of radius `r` centered at `x` (`c +ᵥ Metric.ball x r`) is the same as the open ball of radius `r` centered at `c +ᵥ x` (`Metric.ball (c +ᵥ x) r`). In other words, it's the property of invariance of open balls under isometric additive actions.

For any pseudo metric space, group, action, and isometric additive action, the open ball of radius r centered at x is equal to the set obtained by adding a group element c to every point in the open ball of radius r centered at x.


theorem FreeCommRing.lift_of :
    ∀ {α : Type u} {R : Type v} [inst : CommRing R] (f : α → R) (x : α),
      (FreeCommRing.lift f) (FreeCommRing.of x) = f x :=
  by sorry

The theorem `FreeCommRing.lift_of` states that for any types `α` and `R`, where `R` has a commutative ring structure, and for any function `f` from `α` to `R`, and any element `x` of `α`, applying the lift of `f` to the result of `FreeCommRing.of` applied to `x` is equal to applying `f` directly to `x`. In other words, lifting `f` then applying it to the free commutative ring generated by `x` does not change the value of `f` at `x`. This theorem establishes the compatibility between the lift operation and the construction of an element in the free commutative ring.

For any commutative ring `R`, function `f : α -> R`, and `x : α`, `FreeCommRing.lift_of R f x = f x`.


theorem AEMeasurable.ennreal_ofReal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℝ} {μ : MeasureTheory.Measure α},
      AEMeasurable f μ → AEMeasurable (fun x => ENNReal.ofReal (f x)) μ :=
  by sorry

This theorem states that for any type `α` that has a measurable space structure and a function `f` from `α` to the real numbers `ℝ`, along with a measure `μ` on `α`, if `f` is almost everywhere measurable with respect to the measure `μ`, then the function that maps each `x` in `α` to the extended non-negative real number corresponding to the `f` value at `x` (where the `ofReal` function returns `f(x)` if it is non-negative or `0` if it is negative) is also almost everywhere measurable with respect to the same measure `μ`.

If `α` is a measurable space with measure `μ`, `f: α -> ℝ` is almost everywhere measurable, then the function `x => max(0, ofReal f x)` is also almost everywhere measurable.


theorem Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi._auxLemma.1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      {f g : P ⟶ Q}, (f = g) = (f.f = g.f) :=
  by sorry

This theorem states that for any two morphisms `f` and `g` in the category of Karoubi idempotents of a category `C`, the equality of `f` and `g` is equivalent to the equality of their underlying morphisms `f.f` and `g.f`. This means we can identify morphisms in the Karoubi idempotents category by their underlying morphisms in `C`.

In the category of Karoubi idempotents of a category $C$, two morphisms $f$ and $g$ are equal if and only if their underlying morphisms $f.f$ and $g.g$ in $C$ are equal.


theorem Nat.card_image_of_injective :
    ∀ {α : Type u_1} {β : Type u_3} {f : α → β},
      Function.Injective f → ∀ (s : Set α), Nat.card ↑(f '' s) = Nat.card ↑s :=
  by sorry

This theorem states that for any types `α` and `β` and any function `f` from `α` to `β`, if `f` is injective (meaning that different inputs always produce different outputs), then for any set `s` of elements from `α`, the cardinality of the image of `s` under `f` (denoted as `f '' s`) is equal to the cardinality of `s`. In other words, an injective function does not change the number of distinct elements when mapping a set to its image.

If `f` is an injective function from type `α` to type `β`, then the cardinality of `f'' s` equals the cardinality of `s` for any set `s` in `α`.


theorem le_csInf_iff'' :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α} {a : α},
      Set.Nonempty s → (a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b) :=
  by sorry

This theorem, `le_csInf_iff''`, states that for any type `α` equipped with a conditionally complete linear order structure and a lowest element (`ConditionallyCompleteLinearOrderBot α`), for any set `s` of type `α`, and for any element `a` of type `α`, if the set `s` is not empty (`Set.Nonempty s`), then `a` is less than or equal to the infimum of set `s` (`a ≤ sInf s`) if and only if `a` is less than or equal to every element in the set `s` (i.e., `∀ b ∈ s, a ≤ b`).

For any conditionally complete linear order type `α` with a lowest element, an non-empty set `s` of `α`, and an element `a` of `α`, `a ≤ sInf s` if and only if `a ≤ b` for all `b ∈ s`.


theorem smul_right_injective :
    ∀ {R : Type u_2} (M : Type u_5) [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : NoZeroSMulDivisors R M] {c : R}, c ≠ 0 → Function.Injective fun x => c • x :=
  by sorry

The theorem `smul_right_injective` states that, for any semiring `R`, additive commutative group `M`, and module `M` over `R` that does not permit zero scalar multiplication with divisors, given any non-zero element `c` in `R`, the function that maps each element `x` in `M` to the scalar multiple `c • x` is injective. In other words, if `c • x = c • y` then it must be that `x = y`. This function being injective means that different elements in `M` will not be mapped to the same result under scalar multiplication by `c`.

For any semiring R, additive commutative group M with no zero scalar multiplication by divisors of a non-zero element c in R, the function mapping x in M to c • x is injective.


/-- **Alias** of the forward direction of `Set.univ_subset_iff`. -/
theorem Set.eq_univ_of_univ_subset : ∀ {α : Type u} {s : Set α}, Set.univ ⊆ s → s = Set.univ := by sorry

This theorem, `Set.eq_univ_of_univ_subset`, is also known as an alias of the forward direction of `Set.univ_subset_iff`. It states that for any type `α` and any set `s` of type `α`, if the universal set (which contains all elements of type `α`) is a subset of `s`, then `s` is also a universal set. Essentially, if `s` contains all possible elements of `α`, it becomes identical to the universal set.

If a set `s` contains all elements of type `α`, then `s` is equal to the universal set of type `α`.


theorem Complex.cosh_neg : ∀ (x : ℂ), Complex.cosh (-x) = Complex.cosh x := by sorry

This theorem states that the complex hyperbolic cosine function has even symmetry. In other words, for any complex number `x`, the value of the hyperbolic cosine of `-x` is the same as the hyperbolic cosine of `x`. This mirrors the property of the real hyperbolic cosine function, which is also an even function.

The complex hyperbolic cosine function is an even function, i.e., cosh(-x) = cosh(x) for all complex numbers x.


LT.lt.dual

/-- **Alias** of the reverse direction of `OrderDual.toDual_lt_toDual`. -/
theorem LT.lt.dual : ∀ {α : Type u_1} [inst : LT α] {a b : α}, b < a → OrderDual.toDual a < OrderDual.toDual b := by
  sorry

The theorem `LT.lt.dual` is an alias for the reverse direction of the theorem `OrderDual.toDual_lt_toDual`. It states that for any type `α` that has a less than (`LT`) operation and any two elements `a` and `b` of `α`, if `b` is less than `a`, then `a` in the dual order is less than `b` in the dual order. Basically, it says that the "less than" relation in the original order is reversed in the dual order.

If `a` is less than `b` in the original order, then `b` is less than `a` in the dual order.


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

This theorem, called `Function.iterate_mul`, states that for any function `f` mapping a type `α` to itself and for any natural numbers `m` and `n`, the `m * n`th iteration of `f` is equal to the `n`th iteration of the `m`th iteration of `f`. In LaTeX, this is expressed as `f^{m * n} = (f^m)^n`. This means that if we apply the function `f` `m * n` times to a value, it's the same as applying the function `f` `m` times and then applying this new function `n` times.

For any function $f$ from type $\alpha$ to itself, and natural numbers $m$ and $n$, the $m$th iteration of $f$ composed with the $n$th iteration equals the $m$th iteration of the $n$th iteration of $f$: $(f^m)^n = f^{m\cdot n}$.


List.ext

theorem List.ext : ∀ {α : Type u_1} {l₁ l₂ : List α}, (∀ (n : ℕ), List.get? l₁ n = List.get? l₂ n) → l₁ = l₂ := by sorry

The theorem `List.ext` states that for any type `α`, and for any two lists `l₁` and `l₂` of elements of type `α`, if for every natural number `n`, the `n`-th elements of `l₁` and `l₂` are equal (i.e., `List.get? l₁ n = List.get? l₂ n`), then the two lists `l₁` and `l₂` are equal. This theorem asserts the principle of extensionality for lists, which states that two lists are equal if and only if their corresponding elements are equal.

If two lists of the same type have equal elements at every position, then they are equal.


theorem List.append_cancel_right : ∀ {α : Type u_1} {as bs cs : List α}, as ++ bs = cs ++ bs → as = cs := by sorry

This theorem states that for any type `α` and any lists `as`, `bs`, and `cs` of type `α`, if the list obtained by appending `bs` to `as` is the same as the list obtained by appending `bs` to `cs`, then `as` must be equal to `cs`. In other words, if appending the same list `bs` to two lists `as` and `cs` results in the same list, then `as` and `cs` were initially the same list.

If for lists `as`, `bs`, and `cs` of type `α`, `as ++ bs` = `cs ++ bs` implies `as` = `cs`, then the theorem states the equivalence of list concatenation and list identity.


theorem Nat.log_eq_zero_iff : ∀ {b n : ℕ}, Nat.log b n = 0 ↔ n < b ∨ b ≤ 1 := by sorry

This theorem states that for any two natural numbers `b` and `n`, the logarithm of `n` to the base `b` (denoted as `Nat.log b n` in Lean 4) equals zero if and only if `n` is less than `b` or `b` is less than or equal to one. In other words, the logarithm of a number to a specific base is zero when the number is smaller than the base or when the base is one or less.

The logarithm of a natural number `n` to base `b` is equal to zero if and only if `n` is less than `b` or `b` is less than or equal to one.


/-- A subring is closed under addition.  -/
theorem Subring.add_mem : ∀ {R : Type u} [inst : Ring R] (s : Subring R) {x y : R}, x ∈ s → y ∈ s → x + y ∈ s := by
  sorry

This theorem states that a subring is closed under addition. In more detail, for any given type `R` which has a ring structure, and any subring `s` of `R`, if you have two elements `x` and `y` from `R` that are members of the subring `s`, then their sum `x + y` is also a member of the subring `s`. This is a fundamental property of subrings in the field of algebra.

Given a ring `R` and a subring `s` of `R`, if `x` and `y` are in `s`, then `x + y` is also in `s`.


theorem MeasureTheory.AEEqFun.coeFn_comp₂ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α]
      {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ]
      [inst_3 : TopologicalSpace δ] (g : β → γ → δ) (hg : Continuous (Function.uncurry g)) (f₁ : α →ₘ[μ] β)
      (f₂ : α →ₘ[μ] γ),
      ↑(MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂) =ᶠ[MeasureTheory.Measure.ae μ] fun a => g (↑f₁ a) (↑f₂ a) :=
  by sorry

This theorem, `MeasureTheory.AEEqFun.coeFn_comp₂`, states that for any types `α`, `β`, `γ`, and `δ` where `α` has a measurable space structure and `β`, `γ`, `δ` are topological spaces, and given a measure `μ` on `α`, and two "almost everywhere"-equal functions `f₁` and `f₂` from `α` to `β` and `γ` respectively, if we have a function `g` from `β` to `γ` to `δ` that is continuous when uncurried, then the "almost everywhere"-equality of `g` composed with `f₁` and `f₂` (using the function `MeasureTheory.AEEqFun.comp₂`) is the same as the function obtained by applying `g` to the values of `f₁` and `f₂` at each point `a` in the "almost everywhere" sense (i.e., for almost all points in `α` with respect to the measure `μ`).

For measurable spaces `(α, Σα)`, topological spaces `(β, τβ)`, `(γ, τγ)`, and `(δ, τδ)`, and a measure `μ` on `α`, if `f₁`, `f₂` are almost everywhere equal functions from `α` to `β` and `γ` respectively, and `g` is a continuous function from `β × γ` to `δ`, then `MeasureTheory.AEEqFun.comp₂ g f₁ f₂` is almost everywhere equal to `g ∘ (f₁, f₂)` on `α`.


theorem seq_map_assoc :
    ∀ {α β γ : Type u} {F : Type u → Type v} [inst : Applicative F] [inst_1 : LawfulApplicative F] (x : F (α → β))
      (f : γ → α) (y : F γ), (Seq.seq x fun x => f <$> y) = Seq.seq ((fun x => x ∘ f) <$> x) fun x => y :=
  by sorry

The theorem `seq_map_assoc` states that for any types `α`, `β`, `γ`, and applicative functor `F`, given an element `x` of type `F (α → β)`, a function `f` from `γ` to `α`, and an element `y` of type `F γ`, the operation of sequentially applying `x` to the result of mapping `f` over `y` (represented as `Seq.seq x fun x => f <$> y`) is equivalent to the operation of first mapping the function composition operator with `f` over `x`, and then sequentially applying this to `y` (represented as `Seq.seq ((fun x => x ∘ f) <$> x) fun x => y`). Here, `<$>` denotes the fmap operation of mapping a function over a functor. This theorem essentially expresses an associativity property of the `Seq.seq` operation in relation to the fmap operation.

For any applicative functors `F`, types `α`, `β`, `γ`, functions `x : F (α → β)`, `f : γ → α`, and elements `y : F γ`, the sequential compositions `Seq.seq x (f <$> y)` and `Seq.seq ((λ x => x ∘ f) <$> x) y` are equivalent.


theorem lt_neg :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      a < -b ↔ b < -a :=
  by sorry

This theorem is stating a property about less than ("<") relation in an additive group. Specifically, if we have an additive group `α` and two elements `a` and `b` from this group, then `a` is less than the negation of `b` (`a < -b`) if and only if `b` is less than the negation of `a` (`b < -a`). The theorem assumes two conditions on the additive group:

1. It is covariant, meaning that for all elements `x` and `x_1` in the group, the sum of `x` and `x_1` is less than the sum of `x_1` and `x` (`x + x_1 < x_1 + x`).

2. It also has the property that swapping the order of addition preserves the less than relation, i.e., for all `x` and `x_1` in the group, `x + x_1 < x_1 + x` implies `x_1 + x < x + x_1`.

These conditions are captured in Lean 4 by the `CovariantClass` instances `inst_2` and `inst_3`.

In an additive group with the covariant property and the commutative property of the less than relation, `a < -b` if and only if `b < -a`.


MonovaryOn.symm

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

The theorem `MonovaryOn.symm` states that for any types `ι`, `α`, and `β`, given a preorder on `α` and a linear order on `β`, for any two functions `f : ι → α` and `g : ι → β`, and a set `s` of type `ι`, if `f` monovaries with `g` on `s` then `g` also monovaries with `f` on `s`. In other words, if for all `i, j` in `s`, `g(i) < g(j)` implies `f(i) ≤ f(j)`, then it must also be the case that `f(i) < f(j)` implies `g(i) ≤ g(j)`.

If a function `f` monovaries with respect to a function `g` on a set `s` in a preorder and a linear order, then `g` monovaries with respect to `f` on `s`.


theorem MeasureTheory.OuterMeasure.trim_eq_iInf :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α) (s : Set α),
      ↑(MeasureTheory.OuterMeasure.trim m) s = ⨅ t, ⨅ (_ : s ⊆ t), ⨅ (_ : MeasurableSet t), ↑m t :=
  by sorry

This theorem, `MeasureTheory.OuterMeasure.trim_eq_iInf`, states that for any type `α` with an associated measurable space, any outer measure `m` on `α`, and any set `s` of type `α`, the value of the trimmed outer measure of `m` on `s` is equal to the infimum of the outer measure `m` on set `t`, where `t` is any set that contains `s` and is a measurable set. In mathematical terms, if `s` is a subset of `t` and `t` is a measurable set, then the value of the trimmed `m` on `s` is the same as the infimum of the values of `m` on `t`.

For any measurable space, outer measure, and measurable set, the trimmed outer measure of a subset is equal to the infimum of the outer measure on any superset containing it.


theorem Finset.filter_insert :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α] (a : α) (s : Finset α),
      Finset.filter p (insert a s) = if p a then insert a (Finset.filter p s) else Finset.filter p s :=
  by sorry

The `Finset.filter_insert` theorem states that for any type `α`, a predicate `p` that has decidable truth values for each `α`, a decidable equality on `α`, an element `a` of type `α`, and a finite set `s` of elements of type `α`, the operation of filtering the set obtained by inserting `a` into `s` using the predicate `p` is equivalent to: if `p a` is true, then inserting `a` into the set obtained by filtering `s` using `p`; otherwise, it's just the set obtained by filtering `s` using `p`. In other words, when filtering a set where an element has been added, if the element satisfies the predicate, it appears in the filtered set; otherwise, it doesn't affect the filtered set.

For any type `α`, decidable `p : α → Prop`, decidable equality on `α`, `a : α`, and finite `s : Finset α`, `a ∈ filter (p) (insert a s) <-> p a`.


ModelWithCorners.continuous

theorem ModelWithCorners.continuous :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      Continuous ↑I :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed add commutative group `E`, topological space `H`, and a model with corners `I : ModelWithCorners 𝕜 E H`, the model with corners `I` is continuous. In other words, the function represented by the model with corners respects the topology of the spaces it maps between, not tearing or gluing points apart.

For any non-trivially normed field `𝕜`, normed additive group `E`, topological space `H`, and `I : ModelWithCorners 𝕜 E H`, the function represented by `I` is continuous.


theorem npow_one :
    ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [inst : NatPowAssoc M] (x : M), x ^ 1 = x := by sorry

This theorem states that for any type `M` that forms a multiplication monoid with an associated natural number power operation, raising any element `x` of `M` to the power of 1 yields `x` itself. In mathematical terms, for any `x` in `M`, `x^1 = x`.

For any multiplication monoid `M` with power operation, the power `x^1` of any `x` in `M` equals `x`.


theorem Polynomial.natDegree_monomial :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : DecidableEq R] (i : ℕ) (r : R),
      Polynomial.natDegree ((Polynomial.monomial i) r) = if r = 0 then 0 else i :=
  by sorry

This theorem states that for any type `R` that is a semiring and has decidable equality, and for any natural number `i` and any element `r` of `R`, the natural degree of the polynomial obtained by applying the monomial `i` to `r` is `i` if `r` is not zero; otherwise, if `r` is zero, the natural degree is zero. Essentially, this theorem asserts that the degree of a monomial `a * X^i` is `i`, unless the coefficient `a` is zero, in which case the degree is also zero.

For any semiring `R` with decidable equality and any `i` in `ℕ` and `r` in `R`, the natural degree of the polynomial `i * r` is `i` if `r` is nonzero, and is zero otherwise.


theorem FirstOrder.Language.LHom.map_onRelation :
    ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (ϕ : L →ᴸ L') {M : Type u_1}
      [inst : FirstOrder.Language.Structure L M] [inst_1 : FirstOrder.Language.Structure L' M]
      [inst_2 : FirstOrder.Language.LHom.IsExpansionOn ϕ M] {n : ℕ} (R : L.Relations n) (x : Fin n → M),
      FirstOrder.Language.Structure.RelMap (ϕ.onRelation R) x = FirstOrder.Language.Structure.RelMap R x :=
  by sorry

The theorem `FirstOrder.Language.LHom.map_onRelation` states that for any two first-order languages `L` and `L'` and a language homomorphism `ϕ` from `L` to `L'`, for any structure `M` of type `u_1` that is a model of both `L` and `L'`, and given `ϕ` is an expansion on `M`, for any relation `R` of `L` with arity `n` and any `n`-tuple `x` from `M`, the interpretation of the relation symbol after applying the homomorphism `ϕ` to `R` (i.e., `ϕ.onRelation R`) on `x` in the model `M` is the same as the interpretation of `R` on `x` in `M`. This means that the homomorphism `ϕ` preserves the interpretation of the relation symbols in the model `M`.

Given first-order languages L and L', a language homomorphism φ from L to L', and a model M of both languages where φ is an expansion, for any relation R of arity n in L and any n-tuple x in M, φ.onRelation R(x) = R(x).


theorem star_mul_self_nonneg :
    ∀ {R : Type u} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarOrderedRing R] (r : R),
      0 ≤ star r * r :=
  by sorry

This theorem states that for any ring `R` which is a `NonUnitalSemiring` (a ring without a multiplicative identity) and is also a `StarOrderedRing` (a ring with a partial order and a star-operation), and any element `r` from `R`, the product of the star-operation applied on `r` and `r` itself is always nonnegative, i.e., greater than or equal to zero.

For any non-unital semiring `R` that is also star-ordered, the star-product of any element `r` in `R` with itself is non-negative.


theorem MvPolynomial.C_0 : ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.C 0 = 0 := by sorry

The theorem `MvPolynomial.C_0` states that for any commutative semiring `R` and any type `σ`, the constant multivariate polynomial with value `0` (i.e., `MvPolynomial.C 0`) is equal to the zero polynomial. This is a general result that holds for any choice of `R` and `σ`, which might represent, for example, the coefficients and variables of the polynomial respectively.

For any commutative semiring `R` and type `σ`, the constant multivariate polynomial `MvPolynomial.C 0` equals the zero polynomial.


theorem Int.dvd_gcd : ∀ {i j k : ℤ}, k ∣ i → k ∣ j → k ∣ ↑(Int.gcd i j) := by sorry

The theorem `Int.dvd_gcd` states that for any three integers `i`, `j`, and `k`, if `k` divides `i` and `k` divides `j`, then `k` also divides the greatest common divisor (gcd) of `i` and `j`. The gcd here is calculated in a way that takes the absolute values of `i` and `j`, and is always a nonnegative integer. In other words, this theorem is showing a property of the gcd, that any common divisor of two numbers `i` and `j` is also a divisor of their gcd.

If integers `i`, `j`, and `k` satisfy `k` | `i` and `k` | `j`, then `k` | gcd(`i`, `j`).


theorem LinearIsometryEquiv.instCoeTCContinuousLinearEquiv.proof_1 :
    ∀ {R : Type u_4} {R₂ : Type u_3} {E : Type u_2} {E₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂),
      Continuous ⇑(IsometryEquiv.symm (LinearIsometryEquiv.toIsometryEquiv e)) :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, seminormed add commutative groups `E` and `E₂`, and bijective ring homomorphisms `σ₁₂ : R →+* R₂` and `σ₂₁ : R₂ →+* R` that form inverse pairs, if we have a linear isometry equivalence `e` from `E` to `E₂` over the ring homomorphism `σ₁₂`, then the function defined by the inverse of this linear isometry equivalence (converted to an isometric equivalence) is continuous. In other words, linear isometry equivalences and their inverses preserve continuity.

If `σ₁₂` and `σ₂₁` are inverse bijective ring homomorphisms between semirings `R` and `R₂`, and `e` is a linear isometry equivalence from a seminormed add commutative group `E` to `E₂` over `σ₁₂`, then the inverse of `e` is a continuous function from `E₂` to `E`.


theorem Algebra.self_mem_adjoin_singleton :
    ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
      x ∈ Algebra.adjoin R {x} :=
  by sorry

The theorem `Algebra.self_mem_adjoin_singleton` states that for any commutative semiring `R`, any semiring `A`, any algebra structure between `R` and `A`, and any element `x` from `A`, `x` is an element of the subalgebra of `A` adjoined by `R` that includes only `x`. In other words, if we create a subalgebra by adjoining the set containing only `x` to `R`, `x` itself is guaranteed to be in that subalgebra.

For any commutative semiring `R`, algebra `A` over `R` with an algebra structure map `r : R → A`, and element `x ∈ A`, `x` is contained in the subalgebra of `A` generated over `R` by `{x}`.


/-- Product of a list of elements in a submonoid is in the submonoid.  -/
theorem list_prod_mem :
    ∀ {M : Type u_1} {B : Type u_3} [inst : Monoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M] {S : B}
      {l : List M}, (∀ x ∈ l, x ∈ S) → List.prod l ∈ S :=
  by sorry

This theorem states that given a type `M` with a monoid structure, a type `B`, and `S` as a subset of `B` which forms a submonoid of `M`, if we have a list `l` of elements of `M` and every element of `l` is in `S`, then the product of the elements of `l` (i.e., `List.prod l`) is also in `S`. In other words, the product of a list of elements in a submonoid stays within that submonoid.

Given a monoid `M` with a submonoid `S`, if `l` is a list of elements in `S`, then the product of `l` is also an element of `S`.


theorem IsOpenMap.preimage_frontier_eq_frontier_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 ⁻¹' frontier s = frontier (f ⁻¹' s) :=
  by sorry

This theorem states that for any types `X` and `Y`, and any function `f` from `X` to `Y`, if `f` is an open map and is continuous, then for any set `s` of type `Y`, the preimage of the frontier of `s` under `f` is equal to the frontier of the preimage of `s` under `f`. In simpler terms, if a function sends open sets to open sets and is continuous, then the "boundary" of the preimage of a set is the same as the preimage of the "boundary" of the set. Here, "boundary" refers to the frontier of a set, which is the set of points between the closure and interior of the set.

If `f : X → Y` is a continuous and open function between topological spaces `X` and `Y`, then for any set `s ⊆ Y`, the frontier of `f⁻¹(s)` equals `f⁻¹(frontier(s))`.


theorem Cardinal.ord_le_ord : ∀ {c₁ c₂ : Cardinal.{u_3}}, Cardinal.ord c₁ ≤ Cardinal.ord c₂ ↔ c₁ ≤ c₂ := by sorry

The theorem `Cardinal.ord_le_ord` states that for any two cardinals `c₁` and `c₂`, the ordinal of `c₁` is less than or equal to the ordinal of `c₂` if and only if `c₁` is less than or equal to `c₂`. In other words, the ordering of cardinals respects the ordering of their corresponding ordinals. This theorem provides a connection between the order of cardinal numbers and the order of their corresponding ordinal numbers.

For any cardinals `c₁` and `c₂`, `Cardinal.ord c₁ ≤ Cardinal.ord c₂` if and only if `c₁ ≤ c₂`.


theorem Mathlib.Algebra.Group.Units._auxLemma.29 : ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ), IsUnit ↑u = True := by
  sorry

This theorem states that for any type `M` that forms a Monoid, an element `u` of the group of units `Mˣ` is always a unit. In other words, every element in the group of units `Mˣ` has a two-sided inverse in the Monoid `M`. This is a property of Monoids that underscores the relationship between the group of units and the concept of unit elements.

Every unit in a monoid is an element of the monoid's group of units, and possesses a two-sided inverse in the monoid.


theorem Set.diff_singleton_subset_iff : ∀ {α : Type u} {x : α} {s t : Set α}, s \ {x} ⊆ t ↔ s ⊆ insert x t := by sorry

This theorem states that for any type `α`, any element `x` of that type, and any two sets `s` and `t` of that type, the set `s` without the element `x` is a subset of `t` if and only if the set `s` is a subset of the set `t` with `x` inserted. In mathematical terms, given `s \ {x} ⊆ t`, it implies `s ⊆ insert x t`, and vice versa. That is, removing an element from one set and testing for subset inclusion is equivalent to inserting that element into the other set and testing for subset inclusion.

For any type `α`, sets `s` and `t` of that type, and element `x` of `α`, we have `s \ {x} ⊆ t` if and only if `s ⊆ insert x t`.


theorem sSup_pair : ∀ {α : Type u_1} [inst : CompleteLattice α] {a b : α}, sSup {a, b} = a ⊔ b := by sorry

This theorem states that for any complete lattice of type α, the supremum of the set containing just two elements a and b is the same as the join of a and b. Here, `⊔` represents the join operation in lattice theory, which is the least upper bound of a and b. The complete lattice is a partially ordered set in which every subset has a least upper bound (supremum) and a greatest lower bound (infimum).

In a complete lattice, the supremum of the set {a, b} equals the join of a and b.


theorem Int.fract_intCast :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (z : ℤ), Int.fract ↑z = 0 := by sorry

This theorem states that for any integer `z`, when `z` is cast to a type `α` that is a linearly ordered ring with a floor function, the fractional part of `z` is zero. In other words, the fractional part of any integer, when the integer is considered as an element of a linearly ordered ring with a floor function, is always zero. This is expressed mathematically as `Int.fract ↑z = 0` for all integers `z`.

For any integer `z`, the fractional part of `z` in a linearly ordered ring with a floor function is zero. In symbols, `Int.fract (Floor z) = 0` for all integers `z`.


theorem Module.Finite.of_surjective :
    ∀ {R : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [hM : Module.Finite R M] (f : M →ₗ[R] N),
      Function.Surjective ⇑f → Module.Finite R N :=
  by sorry

The theorem `Module.Finite.of_surjective` states that for all types `R`, `M`, and `N`, given that `R` is a semiring, `M` and `N` are additive commutative monoids, and `M` and `N` are modules over `R`, if `M` is a finite module, then if there exists a surjective linear map `f` from `M` to `N`, `N` is also a finite module. Here, a function `f` is surjective if for every element of `N`, there exists an element of `M` such that applying `f` on this element of `M` gives the element of `N`. A finite module means a module that has a finite basis.

If `M` is a finite module over a semiring `R`, and there exists a surjective linear map from `M` to an additive commutative monoid `N` making both `M` and `N` `R`-modules, then `N` is also a finite module.


theorem isometry_dcomp :
    ∀ {ι : Type u_4} [inst : Fintype ι] {α : ι → Type u_2} {β : ι → Type u_3}
      [inst_1 : (i : ι) → PseudoEMetricSpace (α i)] [inst_2 : (i : ι) → PseudoEMetricSpace (β i)]
      (f : (i : ι) → α i → β i), (∀ (i : ι), Isometry (f i)) → Isometry fun g i => f i (g i) :=
  by sorry

This theorem, `isometry_dcomp`, states that for any finite index set `ι` and any indexed families of types `α` and `β` (indexed by `ι`), where each `α i` and `β i` is a pseudoemetric space, if for each index `i` there is an isometry from `α i` to `β i` (denoted as `f i : α i → β i`), then the function that takes a function `g : ι → α i` and an index `i` and returns `f i (g i)` is also an isometry. In other words, if each `f i` preserves the pseudoemetric distance, then the composite function `fun g i => f i (g i)` also preserves the pseudoemetric distance.

Given a finite index set `ι` and indexed families of pseudometric spaces `α` and `β` with isometries `f i : α i ↔ β i` for each index `i`, the function that maps `g : ι → α i` to `f i (g i)` is an isometry between `α` and `β`.


sInfHom.ext

theorem sInfHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] {f g : sInfHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two set-infimum-preserving functions `f` and `g` between two sets `α` and `β` (both of which are in the class of sets with infimum), if `f` and `g` are equal at every element of `α` (i.e., for any element `a` of `α`, `f(a)` is equal to `g(a)`), then `f` and `g` are the same function. This is a statement of function extensionality for set-infimum-preserving functions.

If two set-infimum-preserving functions between sets with infimum agree on every element, then they are equal.


theorem ProbabilityTheory.kernel.iIndepFun.indepFun_prod_mk :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
      {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} [inst : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun m f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.kernel.IndepFun (fun a => (f i a, f j a)) (f k) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.iIndepFun.indepFun_prod_mk` states that in the context of probability theory with a Markov kernel `κ`, a measure `μ` and measurable spaces `α` and `Ω`, if we have a set of functions `f` from `Ω` to a family of types `β` indexed by `ι`, such that each function `f i` is measurable and the functions are independent with respect to the Markov kernel `κ` and measure `μ`, then for any three distinct indices `i`, `j` and `k` in `ι`, the function that maps `a` to the pair `(f i a, f j a)` is independent of the function `f k` with respect to the same Markov kernel and measure.

If `κ` is a Markov kernel, `μ` is a measure, `α` and `Ω` are measurable spaces, `f: ι → β -> Ω -> Sort _` is a family of measurable functions from `Ω` to `β` indexed by `ι`, and `f i` and `f j` are independent for all distinct `i` and `j` in `ι` with respect to `κ` and `μ`, then the functions `(λ a: Ω, (f i a, f j a))` and `f k` are independent for all `k` distinct from `i` and `j`.


/-- Subtracting the point `p` is an injective function.  -/
theorem vsub_left_injective :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p : P),
      Function.Injective fun x => x -ᵥ p :=
  by sorry

The theorem `vsub_left_injective` states that for any type `G` representing a group with addition (`AddGroup`), type `P` and an element `p` of this type `P` in which `P` is an additive torsor over `G` (`AddTorsor G P`), the function that subtracts the point `p` from any other point `x` (denoted as `x -ᵥ p`) is injective. In other words, if two points `x` and `y` in the torsor yield the same result when `p` is subtracted from them, then `x` and `y` must be the same point.

For any additive torsor `P` over a group `G` and any elements `x, y` in `P`, if `x -ᵥ p = y -ᵥ p` for some `p` in `G`, then `x = y`.


/-- The `AddSubmonoid` generated by a set is contained in any `AddSubmonoid` that
contains the set. -/
theorem AddMonoid.closure_subset :
    ∀ {M : Type u_1} [inst : AddMonoid M] {s t : Set M}, IsAddSubmonoid t → s ⊆ t → AddMonoid.Closure s ⊆ t := by sorry

The theorem `AddMonoid.closure_subset` states that for any type `M` equipped with an additive monoid structure, if we have two sets `s` and `t` of elements of `M`, such that `t` is an additive submonoid and `s` is a subset of `t`, then the additive submonoid generated by `s` (denoted as `AddMonoid.Closure s`) is also a subset of `t`. In other words, every additive submonoid that contains a certain set also contains the additive submonoid generated by that set.

For any additive monoid `M` and subsets `s` of `t` of `M` with `t` being an additive submonoid, `AddMonoid.Closure s` (the additive submonoid generated by `s`) is a subset of `t`.


/-- A module over a division ring is noetherian if and only if
its dimension (as a cardinal) is strictly less than the first infinite cardinal `ℵ₀`.
 -/
theorem IsNoetherian.iff_rank_lt_aleph0 :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
      IsNoetherian K V ↔ Module.rank K V < Cardinal.aleph0 :=
  by sorry

This theorem states that for any division ring 'K' and any additive commutative group 'V' that is also a module over 'K', 'V' is Noetherian if and only if the rank of 'V' as a module over 'K' is strictly less than the first infinite cardinal number, denoted as `ℵ₀`. In other words, a module over a division ring is Noetherian iff its dimension (as a cardinal) is finite.

A module over a division ring is Noetherian if and only if its rank (as a cardinal) is finite.


Asymptotics.IsBigO.mul

theorem Asymptotics.IsBigO.mul :
    ∀ {α : Type u_1} {R : Type u_13} {𝕜 : Type u_15} [inst : SeminormedRing R] [inst_1 : NormedDivisionRing 𝕜]
      {l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜},
      f₁ =O[l] g₁ → f₂ =O[l] g₂ → (fun x => f₁ x * f₂ x) =O[l] fun x => g₁ x * g₂ x :=
  by sorry

This theorem, named `Asymptotics.IsBigO.mul`, states that for any type `α`, `R`, and `𝕜`, where `R` is a seminormed ring and `𝕜` is a normed division ring, and for any filter `l`, if function `f₁` is `O(g₁)` and function `f₂` is `O(g₂)` at l, then the function that multiplies `f₁` and `f₂` is `O` of the function that multiplies `g₁` and `g₂` at l. This is a statement about asymptotic behaviour, saying that if two functions each grow no faster than two other functions, then the same is true for their product.

If functions `f₁` and `f₂` are big O of `g₁` and `g₂`, respectively, at filter `l`, then their product `f₁ * f₂` is big O of `g₁ * g₂` at `l`.


theorem DFinsupp.comapDomain_apply :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] {κ : Type u_1} [inst_1 : (i : ι) → Zero (β i)] (h : κ → ι)
      (hh : Function.Injective h) (f : Π₀ (i : ι), β i) (k : κ), (DFinsupp.comapDomain h hh f) k = f (h k) :=
  by sorry

The theorem `DFinsupp.comapDomain_apply` states that for all types `ι` and `κ`, and for all functions from `κ` to `ι` that are injective, and for every function `f` from `ι` to some type `β`, applying the function `DFinsupp.comapDomain` gives a new function such that when this new function is applied to any element `k` of type `κ`, it gives the same result as applying `f` to the image of `k` under the injective function. In a mathematical language, given an injective function `h: κ → ι`, and a direct sum function `f: Π₀ (i : ι), β i`, `DFinsupp.comapDomain h hh f` reindexes (and possibly removes) the terms of `f` according to `h`, such that applying this reindexed function at `k` is same as applying `f` at `h(k)`.

Given an injective function `h: κ -> ι` and a function `f: ι -> β`, `DFinsupp.comapDomain h h f` applies `f` to the images of `ι` elements under `h`, resulting in a function that gives the same output as applying `f` directly to the images.


Primrec.decode

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

The theorem `Primrec.decode` states that for any type `α` that is primitive codable (i.e., can be encoded as and decoded from natural numbers), the function `Encodable.decode` is primitive recursive. In other words, it asserts that the process of decoding a natural number into an optional value of type `α` is a primitive recursive function. A primitive recursive function is one that can be computed using basic arithmetic operations and recursion in a finite number of steps.

The function `Encodable.decode` for decoding a natural number into an optional value of a primitive codable type `α` is a primitive recursive function.


theorem Nat.floor_coe :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] (n : ℕ), ⌊↑n⌋₊ = n := by sorry

This theorem, `Nat.floor_coe`, states that for any natural number `n`, the floor function applied to the associated number in a linear ordered semiring `α` results in `n` itself. In other words, if we take a natural number `n`, cast it into some type `α` where `α` is a linearly ordered semiring that also supports a floor operation, and then apply the floor operation, we get the original natural number `n` back. This property holds for all natural numbers and any type `α` satisfying these conditions.

For any natural number `n` and any linearly ordered semiring `α` with a floor operation, `floor (alg_num n) = n`, where `alg_num` is the function that casts natural numbers to `α`.


theorem edist_neg_neg :
    ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsometricVAdd G G]
      [inst_3 : IsometricVAdd Gᵃᵒᵖ G] (a b : G), edist (-a) (-b) = edist a b :=
  by sorry

This theorem, `edist_neg_neg`, states that for any type `G` which is an additive group and a pseudo-emetric space with isometric vector addition and such that its additive opposite (`Gᵃᵒᵖ`) also has isometric vector addition, the extended distance (denoted by `edist`) between the negations of two elements `a` and `b` of `G` is equal to the extended distance between `a` and `b` themselves. In other words, negating the elements doesn't change the distance between them.

For any additive group `G` equipped with an isometric vector addition and having an isometric additive inverse such that the same properties hold for the additive opposite `Gᵃᵒᵖ`, the extended distance between the negations of two elements `a` and `b` is equal to the extended distance between `a` and `b` itself.


Filter.IsBounded.mono

theorem Filter.IsBounded.mono :
    ∀ {α : Type u_1} {r : α → α → Prop} {f g : Filter α}, f ≤ g → Filter.IsBounded r g → Filter.IsBounded r f := by
  sorry

The theorem `Filter.IsBounded.mono` states that for any type `α`, relation `r` on `α`, and filters `f` and `g` on `α`, if `f` is a subfilter of `g` (denoted as `f ≤ g`), and `g` is eventually bounded with respect to the relation `r` (denoted as `Filter.IsBounded r g`), then `f` is also eventually bounded with respect to the same relation `r` (denoted as `Filter.IsBounded r f`). In other words, if a filter is a subset of another filter that is eventually bounded, then the subset filter is also eventually bounded.

If `f ≤ g` are filters on a type `α` and `Filter.IsBounded r g` holds, then `Filter.IsBounded r f` also holds. (Here, `r` is a relation on `α`.)


theorem Mathlib.Data.Complex.Exponential._auxLemma.9 : ∀ (x : ℝ), Complex.tan ↑x = ↑(Real.tan x) := by sorry

The theorem `Mathlib.Data.Complex.Exponential._auxLemma.9` states that for all real numbers `x`, the complex tangent of `x` is equal to the real part of the tangent of `x`. This is essentially stating that the complex tangent function, when applied to a real number (which is treated as a complex number with zero imaginary part), results in a complex number which has its real part equal to the standard tangent function applied to the same real number.

The theorem asserts that the real part of the complex tangent function equals the standard real tangent function for all real numbers.


theorem mul_div_mul_left :
    ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] {c : G₀} (a b : G₀), c ≠ 0 → c * a / (c * b) = a / b := by sorry

The theorem `mul_div_mul_left` states that for any type `G₀` that forms a commutative group with zero, and for any non-zero element `c` of `G₀` and any two elements `a` and `b` of `G₀`, the result of multiplying `c` and `a`, then dividing by the product of `c` and `b`, is equal to the result of dividing `a` by `b`. In other words, in a commutative group with zero, `c*a / (c*b) = a / b` for any `a`, `b`, and non-zero `c`.

In a commutative group with zero, for all non-zero `c`, `a`, and `b`, `c * a / (c * b) = a / b`.


theorem Rat.divInt_ofNat : ∀ (num : ℤ) (den : ℕ), Rat.divInt num ↑den = mkRat num den := by sorry

The theorem `Rat.divInt_ofNat` states that for every pair of integers `num` and natural number `den`, the result of dividing `num` by the integer representation of `den` using the `Rat.divInt` function is equal to the result of constructing a rational number with `num` as the numerator and `den` as the denominator using the `mkRat` function. Essentially, this theorem asserts the consistency between integer division and the construction of a rational number in the Lean 4 mathematical library.

For every integer `num` and natural number `den`, `Rat.divInt num den` equals `Rat.mkRat num den`.


/-- The gauge is always nonnegative.  -/
theorem gauge_nonneg :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} (x : E), 0 ≤ gauge s x := by sorry

The theorem `gauge_nonneg` establishes that the Minkowski functional, also known as the gauge, is always nonnegative. In more precise terms, it states that for any real vector space `E`, for any additive commutative group structure on `E`, for any module structure of the real numbers over `E`, for any set `s` of elements of `E`, and for any element `x` of `E`, the value of the gauge of `s` at `x` is greater than or equal to zero. This is usually represented mathematically as: ∀ E, s, x, 0 ≤ gauge s x.

For any real vector space E equipped with an additive commutative group structure and module structure of the real numbers, and for any set s of elements and any x in E, the gauge of s at x is nonnegative (gauge s x ≥ 0).


/-- `clog b` and `pow b` form a Galois connection.  -/
theorem Nat.le_pow_iff_clog_le : ∀ {b : ℕ}, 1 < b → ∀ {x y : ℕ}, x ≤ b ^ y ↔ Nat.clog b x ≤ y := by sorry

The theorem `Nat.le_pow_iff_clog_le` states that for any given natural numbers `b`, `x`, and `y`, where `b` is greater than 1, the condition `x` being less than or equal to `b` raised to the power `y` is equivalent to the ceiling logarithm of `x` in base `b` being less than or equal to `y`. In other words, for a given base `b` greater than 1, the ceiling logarithm function `clog b` and the power function `pow b` form a Galois connection.

For any base \(b > 1\), \(x \leqslant b^y\) if and only if \(\lceil \log\_b x \rceil \leqslant y\).


Nat.gcd.induction

theorem Nat.gcd.induction :
    ∀ {P : ℕ → ℕ → Prop} (m n : ℕ), (∀ (n : ℕ), P 0 n) → (∀ (m n : ℕ), 0 < m → P (n % m) m → P m n) → P m n := by sorry

This theorem is a principle of induction for the greatest common divisor (gcd) on two natural numbers, denoted as `P m n`. Given two natural numbers `m` and `n`, it states that if a property `P` holds for all natural numbers `n` when `m` is 0, and if for any `m` and `n` with `m` greater than 0, the property `P` holds for `n mod m` and `m` whenever it holds for `m` and `n`, then the property `P` holds for any `m` and `n`. This can be used to create proofs that rely on the properties of the gcd and the division operation.

If `P` is a property that holds for all natural numbers `n` when the first number `m` is 0, and `P` holds for `n` when `m` is greater than 0 if and only if it holds for `n mod m` and `m`, then `P` holds for all natural numbers `m` and `n`.


theorem Int.dvd_of_emod_eq_zero : ∀ {a b : ℤ}, b % a = 0 → a ∣ b := by sorry

This theorem states that for any two integers `a` and `b`, if the remainder of `b` divided by `a` (`b % a`) is zero, then `a` divides `b` (`a ∣ b`). In other words, it says that if `b` is a multiple of `a` such that there is no remainder when `b` is divided by `a`, then `a` is a divisor of `b`.

If `a` divides `b` in the integer ring, then the remainder of `b` divided by `a` is zero. (In other words, `a ∣ b` implies `b % a = 0`.)


theorem Complex.abs_conj : ∀ (z : ℂ), Complex.abs ((starRingEnd ℂ) z) = Complex.abs z := by sorry

The theorem `Complex.abs_conj` states that for every complex number `z`, the absolute value of the conjugate of `z` is equal to the absolute value of `z` itself. Here, `(starRingEnd ℂ) z` denotes the conjugate of `z`. Essentially, this theorem is asserting the mathematical fact that the absolute (or modulus) of a complex number and its conjugate are equal, i.e., if `z` is a complex number and `z*` is its conjugate, then `|z*| = |z|`.

The absolute value of a complex number is equal to the absolute value of its conjugate.


theorem Nat.Ico_succ_right : ∀ (a b : ℕ), Finset.Ico a (Nat.succ b) = Finset.Icc a b := by sorry

The theorem `Nat.Ico_succ_right` states that for any two natural numbers `a` and `b`, the set of natural numbers `x` such that `a ≤ x` and `x < b + 1` (denoted `Finset.Ico a (Nat.succ b)` in Lean 4) is equal to the set of natural numbers `x` such that `a ≤ x` and `x ≤ b` (denoted `Finset.Icc a b`). Here, `Nat.succ b` is the successor function, which means `b + 1`. In other words, when you increment the upper bound of an integer interval that is open on the right, the resulting set is the same as if you had kept the original bound but made the interval closed on the right.

The sets of natural numbers `x` such that `a ≤ x` and `x < b + 1` and those such that `a ≤ x` and `x ≤ b` are equal.


theorem Polynomial.degree_one : ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R], Polynomial.degree 1 = 0 :=
  by sorry

The theorem `Polynomial.degree_one` asserts that for any type `R` that has a structure of a semiring and is nontrivial, the degree of the constant polynomial `1` is `0`. In other words, in a nontrivial semiring, the highest power of `X` that appears in the constant polynomial `1` is `0`.

In a nontrivial semiring, the constant polynomial 1 has degree 0.


SupClosed.image

theorem SupClosed.image :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {s : Set α}
      [inst_2 : FunLike F α β] [inst_3 : SupHomClass F α β], SupClosed s → ∀ (f : F), SupClosed (⇑f '' s) :=
  by sorry

The theorem `SupClosed.image` states that for any types `F`, `α`, `β`, with `α` and `β` being semilattice sup structures, a set `s` of type `α`, and an injective function-like `F` that maps `α` to `β`, if the set `s` is supremum-closed (i.e., the supremum of any two elements of `s` also belongs to `s`), then the image of `s` under the function `f` of type `F` is also supremum-closed. It means, when `s` is a sup-closed set and `f` is a mapping that preserves sup-operation, then the image of `s` via `f` remains sup-closed in the target domain.

If `F` is an injective function-like map between semilattice sup structures `α` and `β`, `s` is a supremum-closed set in `α`, then the image `F[s]` is supremum-closed in `β`.


/-- `(n, m)` is in the reflexive-transitive closure of `~` if `i ~ succ i` and `succ i ~ i`
for all `i` between `n` and `m`.  -/
theorem reflTransGen_of_succ :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] (r : α → α → Prop)
      {n m : α},
      (∀ i ∈ Set.Ico n m, r i (Order.succ i)) → (∀ i ∈ Set.Ico m n, r (Order.succ i) i) → Relation.ReflTransGen r n m :=
  by sorry

The theorem `reflTransGen_of_succ` states that for any linear order (α, ≤) endowed with a successor operation and an Archimedean property, and for any relation `r` on α, an element pair `(n, m)` belongs to the reflexive-transitive closure of `r` if the following conditions hold:

1. For all elements `i` in the left-closed right-open interval from `n` to `m` (`n ≤ i < m`), `i` is related to its successor in `r`. That is, `r i (succ i)` holds.

2. For all elements `i` in the left-closed right-open interval from `m` to `n` (`m ≤ i < n`), the successor of `i` is related to `i` in `r`. That is, `r (succ i) i` holds.

Here, the successor of an element is the least element greater than it unless it is a maximal element, in which case, the successor is the element itself. The succ-Archimedean property guarantees that for every two elements in the order, there exists a third element between them.

For a linear order endowed with a successor operation and the Archimedean property, if for any relation `r` on the order, an element pair `(n, m)` satisfies that for all `i` in the intervals `[n, m)` and `(m, n)`, `r (i, succ i)` and `r (succ i, i)` hold respectively, then `(n, m)` is in the reflexive-transitive closure of `r`.


theorem Int.ediv_one : ∀ (a : ℤ), a / 1 = a := by sorry

This theorem states that for any integer 'a', dividing 'a' by 1 is equal to 'a' itself. In other words, it proves the well-known mathematical fact that when any number is divided by 1, the quotient is the number itself.

For any integer 'a', 'a' divided by 1 equals 'a' itself.


CategoryTheory.Center.ext

theorem CategoryTheory.Center.ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {X Y : CategoryTheory.Center C} (f g : X ⟶ Y), f.f = g.f → f = g :=
  by sorry

The theorem `CategoryTheory.Center.ext` states that for any type `C` that is a category and a monoidal category, and for any two objects `X` and `Y` in the Drinfeld center of `C`, if two morphisms `f` and `g` from `X` to `Y` have the same underlying function, then `f` and `g` are equal. In other words, in the context of the Drinfeld center of a monoidal category, morphisms between objects are uniquely determined by their underlying function.

In the Drinfeld center of a monoidal category, morphisms between objects are equal if and only if they have the same underlying function.


theorem Polynomial.monomial_comp :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R} (n : ℕ),
      Polynomial.comp ((Polynomial.monomial n) a) p = Polynomial.C a * p ^ n :=
  by sorry

This theorem, `Polynomial.monomial_comp`, states that for any semiring `R`, any element `a` of `R`, any polynomial `p` over `R`, and any natural number `n`, the composition of the monomial `a * X^n` with `p` is equal to the constant polynomial `a` times `p` raised to the power of `n`. In essence, replacing `X` with `p` in the monomial `a * X^n` gives us `a * p^n`.

For any semiring `R`, element `a` of `R`, polynomial `p` over `R`, and natural number `n`, `a * X^n * p = a * pow p n`.


theorem QuotientAddGroup.leftRel_eq :
    ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α), Setoid.r = fun x y => -x + y ∈ s := by sorry

This theorem states that for any given type `α` that forms an additive group, and any additive subgroup `s` of this additive group, the distinguished equivalence relation of a setoid (`Setoid.r`) is defined as the relation where the result of subtracting `y` from the negation of `x` belongs to the subgroup `s`. In more mathematical terms, `-x + y ∈ s`.

For any additive group `α` and subgroup `s`, the setoid equality `x ≈ y` holds if and only if `x - y ∈ s`.


theorem NNReal.coe_mono : Monotone NNReal.toReal := by sorry

The theorem `NNReal.coe_mono` states that the function `NNReal.toReal`, which coerces non-negative real numbers (`ℝ≥0`) into real numbers (`ℝ`), is a monotone function. This means that for any two non-negative real numbers `a` and `b`, if `a ≤ b` then `NNReal.toReal a ≤ NNReal.toReal b`. In simpler terms, the function preserves the order of the non-negative real numbers when they are converted into real numbers.

The `NNReal.toReal` function that coerces non-negative real numbers into real numbers is monotone, i.e., for all non-negative real numbers `a` and `b` with `a ≤ b`, `NNReal.toReal a ≤ NNReal.toReal b`.


theorem AlgebraicTopology.DoldKan.HigherFacesVanish.comp_P_eq_self :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ}
      {φ : Y ⟶ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))},
      AlgebraicTopology.DoldKan.HigherFacesVanish q φ →
        CategoryTheory.CategoryStruct.comp φ ((AlgebraicTopology.DoldKan.P q).f (n + 1)) = φ :=
  by sorry

This theorem states that for any category `C`, which is also a preadditive category, and for any simplicial object `X` in `C` and object `Y` in `C`, and for any natural numbers `n` and `q`, if a morphism `φ` from `Y` to the (`n+1`)-th object of `X` satisfies the higher faces vanish condition at `q`, then the composition of `φ` with the (`n+1`)-th morphism of the Dold-Kan correspondence at `q` is equal to `φ` itself.

In other words, it establishes that under the higher faces vanish condition, the `φ` morphism is a sort of identity for the composition operation with the Dold-Kan correspondence morphism. This is a property related to the structure of simplicial objects in a category within the context of algebraic topology.

Given a preadditive category `C`, any simplicial object `X` in `C`, object `Y` in `C`, natural numbers `n` and `q`, and a morphism `φ` from `Y` to the `(n+1)`-th object of `X` satisfying the higher faces vanish condition at `q`, then `φ` is equal to the composition of `φ` with the `(n+1)`-th morphism of the Dold-Kan correspondence at `q`.


theorem Finset.Ico_union_Ico_eq_Ico :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b c : α},
      a ≤ b → b ≤ c → Finset.Ico a b ∪ Finset.Ico b c = Finset.Ico a c :=
  by sorry

This theorem states that for any given type `α` equipped with a linear order and locally finite order, and any three elements `a`, `b`, and `c` of `α` such that `a` is less than or equal to `b` and `b` is less than or equal to `c`, the union of the finite sets from `a` to `b` (`Finset.Ico a b`) and from `b` to `c` (`Finset.Ico b c`) equals the finite set from `a` to `c` (`Finset.Ico a c`). Essentially, this theorem formalizes the intuitive notion that combining two consecutive intervals gives us the overall interval.

For any type `α` with a linear order and locally finite order, the union of the finite intervals `[a, b]` and `[b, c]` equals the finite interval `[a, c]` when `a ≤ b ≤ c`.


theorem Complex.cos_pi : Complex.cos ↑Real.pi = -1 := by sorry

The theorem `Complex.cos_pi` states that the cosine of pi in the complex number system is equal to -1. Here, pi is defined as twice a zero of the cosine function in the interval [1,2]. This theorem is fundamental in trigonometry and underlies many properties related to the unit circle and the cosine function.

The cosine of pi in the complex number system equals -1, where pi is defined as the double root of the cosine function in the interval [1, 2].


theorem Ideal.map_span :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F) (s : Set R), Ideal.map f (Ideal.span s) = Ideal.span (⇑f '' s) :=
  by sorry

The theorem `Ideal.map_span` states that for any types `R`, `S`, `F`, given semirings `R` and `S`, a function `f` of type `F` that behaves like a function from `R` to `S` (expressed by `FunLike F R S`), and a subset `s` of `R`, the ideal obtained by mapping the ideal generated by `s` in `R` (i.e., `Ideal.span s`) through `f` (i.e., `Ideal.map f (Ideal.span s)`) is equal to the ideal generated by the image of `s` under `f` in `S` (i.e., `Ideal.span (⇑f '' s)`). This theorem essentially asserts that mapping the generator of an ideal through a ring homomorphism and then taking the span is the same as first taking the span in the original ring and then mapping the ideal through the ring homomorphism.

For any semirings R, S, function f from R to S behaving like a homomorphism, and subset s of R, the ideal generated by the image of s under f is equal to the image of the ideal generated by s under f.


theorem Finset.sup_id_eq_sSup : ∀ {α : Type u_2} [inst : CompleteLattice α] (s : Finset α), Finset.sup s id = sSup ↑s :=
  by sorry

The theorem `Finset.sup_id_eq_sSup` states that for all types `α` that are complete lattices, and for any finite set `s` of type `α`, the supremum of `s` when computed via the function `Finset.sup` with the identity function is the same as the supremum (`sSup`) of the set obtained by coercing `s` into a set. In other words, it says that calculating the supremum of `s` by taking the supremum of the identity function at each of its elements is equivalent to directly calculating the supremum of `s` in the complete lattice `α`.

For any complete lattice α and finite set s of type α, the supremum of s computed using the identity function is equal to the direct supremum of s.


/-- **Triangle inequality** for the norm.  -/
theorem norm_mul_le' : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a b : E), ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by sorry

This is the **Triangle Inequality** for the norm in the context of seminormed groups. Given any seminormed group `E` and any two elements `a` and `b` from `E`, the norm of the product `a * b` is always less than or equal to the sum of the norms of `a` and `b`, denoted as `‖a * b‖ ≤ ‖a‖ + ‖b‖`.

In a seminormed group, the norm of the product of two elements is less than or equal to the sum of their individual norms.


/-- **Alias** of the reverse direction of `Order.pred_lt_iff_not_isMin`. -/
theorem Order.pred_lt_of_not_isMin :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α}, ¬IsMin a → Order.pred a < a := by sorry

The theorem `Order.pred_lt_of_not_isMin` states that, for any type `α` that has a preorder and predorder structure, if an element `a` of type `α` is not minimal, then the predecessor of `a` is strictly less than `a`. In more mathematical terms, the theorem says that if `a` is not a minimal element in the order, then its predecessor is strictly smaller than `a`. This theorem is essentially the reverse direction of the theorem `Order.pred_lt_iff_not_isMin`.

If `α` is a type with a preorder and predorder structure, then for all `a` in `α` that are not minimal, `pred a` is strictly less than `a`.


theorem AddMonoid.Coprod.mk_eq_mk :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {w₁ w₂ : FreeAddMonoid (M ⊕ N)},
      AddMonoid.Coprod.mk w₁ = AddMonoid.Coprod.mk w₂ ↔ (AddMonoid.coprodCon M N) w₁ w₂ :=
  by sorry

The theorem `AddMonoid.Coprod.mk_eq_mk` states that for any two types `M` and `N` which are both instances of the `AddZeroClass`, and for any two variables `w₁` and `w₂` that are members of the free additive monoid over the sum of `M` and `N`, the equality of the additive monoid coproducts of `w₁` and `w₂` is equivalent to the relation defined by the congruence `AddMonoid.coprodCon M N` applied to `w₁` and `w₂`. In simpler terms, it describes a condition under which two elements of the coproduct of two additive monoids are equal.

For any additive monoids M and N with instances of AddZeroClass, and any w₁ and w₂ in their free additive monoid over their sum, w₁ = w₂ holds if and only if AddMonoid.coprodCon M N (w₁, w₂) holds.


theorem Finset.card_pair : ∀ {α : Type u_1} {a b : α} [inst : DecidableEq α], a ≠ b → {a, b}.card = 2 := by sorry

This theorem, named `Finset.card_pair`, establishes that for any given type `α` with decidable equality (i.e., for any two elements `a` and `b` of type `α`, we can determine whether `a = b`), if `a` is not equal to `b`, then the cardinality (size) of the finite set containing `a` and `b` is `2`. In other words, if `a` and `b` are distinct elements of a type that allows for deciding equality, then the set `{a, b}` has exactly two elements.

For any type `α` with decidable equality, the cardinality of the finite set `{a, b}` is `2` when `a` and `b` are distinct elements of `α`.


IsBot.isMin

theorem IsBot.isMin : ∀ {α : Type u_1} [inst : LE α] {a : α}, IsBot a → IsMin a := by sorry

The theorem `IsBot.isMin` states that for any type `α` that has a less than or equal to ordering (`LE`), if an element `a` of `α` is a bottom element (meaning it is less than or equal to every other element of `α`), then `a` is also a minimal element (meaning that there is no element strictly less than it). In other words, if `a` is at the bottom of the order, it also serves as a minimal bound for the set.

If an element is the bottom element in a partially ordered type, then it is also a minimal element.


theorem Dilation.ratio_ne_zero :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F), Dilation.ratio f ≠ 0 :=
  by sorry

The theorem `Dilation.ratio_ne_zero` states that for any types `α`, `β`, and `F`, in a context where `α` and `β` have a structure of pseudo e-metric spaces, `F` is a function-like object from `α` to `β`, and `F` satisfies the conditions to be a dilation class, the ratio of a dilation `f` of type `F` is never zero. In other words, in the given conditions, the ratio of dilation of any function is always a nonzero real number.

In the context of pseudo metric spaces α, β, and a function-like object F from α to β that satisfies the conditions of a dilation class, the dilation ratio of any dilation f of type F is nonzero.


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

This theorem states that for every natural number `n`, the greatest common divisor (gcd) of `n` and `n` is `n` itself. In other words, the gcd of a number with itself is always the number itself. This is a property of the gcd function in the natural numbers domain.

The greatest common divisor of a natural number with itself is the number itself. (gcd (n : ℕ) (n : ℕ)) = n for all natural numbers n.


theorem Set.preimage_add_const_Iio :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => x + a) ⁻¹' Set.Iio b = Set.Iio (b - a) := by
  sorry

This theorem, `Set.preimage_add_const_Iio`, asserts that for any ordered additive commutative group `α`, and for any two elements `a` and `b` of `α`, the preimage of the set of elements less than `b` under the function that adds `a` to each element is the set of elements less than `b - a`. In other words, if we shift all elements in the group by `a`, those that were less than `b` before the shift are now less than `b - a`.

For any ordered additive commutative group `α` and elements `a, b` in `α`, the preimage of the set of elements less than `b` under the function `x => x + a` is the set of elements less than `b - a`.


theorem Set.preimage_add_const_Iic :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => x + a) ⁻¹' Set.Iic b = Set.Iic (b - a) := by
  sorry

The theorem `Set.preimage_add_const_Iic` states that for any ordered additive commutative group `α`, and any elements `a` and `b` of `α`, the preimage of the set of elements less than or equal to `b` under the function that adds `a` to its input is the set of elements less than or equal to `b - a`. In other words, if we take a set of all elements that are less than or equal to `b`, and then apply the function that adds `a` to each element, the set we get is exactly the set of all elements that are less than or equal to `b - a`.

For any ordered additive commutative group (α, +) and elements a, b ∈ α, the preimage of the set {x ∈ α : x ≤ b} under the function x => x + a is the set {x ∈ α : x ≤ b - a}.


theorem Finsupp.smul_single_one :
    ∀ {α : Type u_1} {R : Type u_11} [inst : Semiring R] (a : α) (b : R), (b • fun₀ | a => 1) = fun₀ | a => b := by
  sorry

This theorem states that for any types `α` and `R`, where `R` is a semiring, any element `a` of type `α` and `b` of type `R`, the scalar multiplication of `b` and a function from `a` to `1` (denoted as `fun₀ | a => 1`) is equal to a function from `a` to `b` (denoted as `fun₀ | a => b`). In mathematical terms, it's saying that for any scalar `b` and any single-element function mapping to `1`, the scaled function maps to `b` instead.

For any semiring `R` and type `α`, the function `fun₀ | a => b` from `α` to `R` is equal to the scalar multiplication of `b` and the constant function `fun₀ | a => 1` from `α` to `R`.


/-- **Alias** of the reverse direction of `measurable_iff_comap_le`. -/
theorem Measurable.of_comap_le :
    ∀ {α : Type u_1} {β : Type u_2} {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β},
      MeasurableSpace.comap f m₂ ≤ m₁ → Measurable f :=
  by sorry

This theorem, "Measurable.of_comap_le", states that for any types `α` and `β`, any measurable spaces `m₁` over `α` and `m₂` over `β`, and any function `f` from `α` to `β`, if the measurable space obtained by taking the reverse image of `m₂` under `f` is less than or equal to `m₁`, then `f` is a measurable function. In other words, if every set in `m₁` that is the preimage of a set in `m₂` under `f` is also in `m₂`, then `f` is measurable, i.e., the preimage of every measurable set under `f` is also measurable.

If a function between measurable spaces preserves measurable sets under reverse image, then the function is measurable.


theorem Path.symm_symm :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), Path.symm (Path.symm γ) = γ := by sorry

The theorem `Path.symm_symm` states that for any topological space `X` and any two points `x` and `y` in `X`, if we take a path `γ` from `x` to `y`, and then take the reverse of the reverse of that path, we get back the original path `γ`. In other words, reversing a path twice gives us back the original path. This is true for any path in any topological space.

For any topological space X and any two points x, y in X with a path γ between them, the reversed path of the reversed path γ is equal to γ.


/-- If a function converges to a nonzero value, its inverse converges to the inverse of this value.
We use the name `Filter.Tendsto.inv₀` as `Filter.Tendsto.inv` is already used in multiplicative
topological groups.  -/
theorem Filter.Tendsto.inv₀ :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : Zero G₀] [inst_1 : Inv G₀] [inst_2 : TopologicalSpace G₀]
      [inst_3 : HasContinuousInv₀ G₀] {l : Filter α} {f : α → G₀} {a : G₀},
      Filter.Tendsto f l (nhds a) → a ≠ 0 → Filter.Tendsto (fun x => (f x)⁻¹) l (nhds a⁻¹) :=
  by sorry

This theorem, named `Filter.Tendsto.inv₀`, states that if a function `f` converging to a non-zero value `a` under some filter `l`, then the function that is the pointwise inverse of `f` also converges under the same filter, but to the inverse of `a`. This is valid in a topological space that supports inversion and zero, and where inversion is a continuous operation. Note that this theorem is named `Filter.Tendsto.inv₀` and not `Filter.Tendsto.inv`, because the latter name is already taken for a theorem about multiplicative topological groups.

If a function `f` converges to a non-zero value `a` under filter `l` in a topological space where inversion is continuous, then the pointwise inverse of `f` converges to the inverse of `a` under filter `l`.


theorem Algebra.IsAlgebraic.algHom_bijective₂ :
    ∀ {K : Type u_1} {L : Type u_2} {R : Type u_3} [inst : CommRing K] [inst_1 : Field L] [inst_2 : Algebra K L]
      [inst_3 : NoZeroSMulDivisors K L] [inst_4 : Field R] [inst_5 : Algebra K R],
      Algebra.IsAlgebraic K L → ∀ (f : L →ₐ[K] R) (g : R →ₐ[K] L), Function.Bijective ⇑f ∧ Function.Bijective ⇑g :=
  by sorry

The theorem `Algebra.IsAlgebraic.algHom_bijective₂` states that for any three types `K`, `L`, and `R` where `K` is a commutative ring, `L` and `R` are fields, and `L` and `R` are also `K`-algebras, if all elements of `L` are algebraic over `K` (i.e., `L` is an algebraic `K`-algebra), then for any two algebra homomorphisms `f` from `L` to `R` and `g` from `R` to `L` (both preserving the structure of `K`-algebras), the function `f` is bijective (i.e., both injective and surjective) and the function `g` is also bijective. In other words, if `L` is an algebraic `K`-algebra, any pair of algebra homomorphisms between `L` and `R` will always be bijections.

If `L` is a commutative `K`-algebra, `R` is a field, `L` is algebraic over `K`, and `f: L → R` and `g: R → L` are `K`-algebra homomorphisms, then both `f` and `g` are bijective functions.


theorem CategoryTheory.Over.pullback.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
      {X Y : C} (f : X ⟶ Y) (g : CategoryTheory.Over Y),
      CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan g.hom f) :=
  by sorry

The theorem `CategoryTheory.Over.pullback.proof_1` states that for any category `C` that has pullbacks, given objects `X` and `Y` in `C`, a morphism `f` from `X` to `Y`, and a "over" object `g` over `Y`, there exists a limit for the cospan formed by the homomorphism of `g` and `f`. In the context of category theory, a cospan is a diagram indexed by the shape of a walking cospan, and "having a limit" essentially means that there exists a certain universal object with respect to this diagram.

Given a category with pullbacks, for any object X, Y, and morphisms f : X -> Y and g : Z -> Y, the cospan (g, f) has a limit.


theorem Nat.bit0_succ_eq : ∀ (n : ℕ), bit0 (Nat.succ n) = Nat.succ (Nat.succ (bit0 n)) := by sorry

The theorem `Nat.bit0_succ_eq` states that for all natural numbers `n`, the value of applying the `bit0` operation (which doubles the input) to the successor (`Nat.succ`) of `n` is equal to the successor of the successor of `bit0 n`. In other words, doubling the number `n+1` is the same as adding two to the double of `n`.

For all natural numbers `n`, `bit0 (Nat.succ n) = Nat.succ (bit0 n)`.


theorem List.count_cons_self :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l : List α), List.count a (a :: l) = List.count a l + 1 := by sorry

The theorem `List.count_cons_self` states that for any type `α` that has decidable equality and for any element `a` of type `α` and list `l` of elements of type `α`, the count of `a` in the list formed by prepending `a` to `l` is equal to the count of `a` in `l` plus one. In other words, if you add an element to the start of a list, the count of that element in the new list increases by one.

For any type `α` with decidable equality and list `l` of elements from `α`, the number of occurrences of an element `a` in the list `a :: l` is one more than the number of occurrences of `a` in `l`.


theorem lcm_dvd_lcm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b c d : α},
      a ∣ b → c ∣ d → lcm a c ∣ lcm b d :=
  by sorry

This theorem states that for any type `α` that is a cancellative commutative monoid with zero and a gcd monoid, and for any elements `a`, `b`, `c`, and `d` of that type, if `a` divides `b` and `c` divides `d`, then the least common multiple of `a` and `c` also divides the least common multiple of `b` and `d`.

If `α` is a cancellative commutative monoid with zero and a gcd, then for all `a, b, c, d ∈ α`, if `a` divides `b` and `c` divides `d`, then the greatest common divisor of `a` and `c` divides the greatest common divisor of `b` and `d`. (Note: Least common multiples are defined as the reciprocal of greatest common divisors in the context of commutative monoids with zero.)


theorem Finset.map_val :
    ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α), (Finset.map f s).val = Multiset.map (⇑f) s.val := by
  sorry

The theorem `Finset.map_val` states that for any types `α` and `β` and any embedding function `f` from `α` to `β`, when this function is applied to a finset `s` of type `α` using `Finset.map`, the underlying multiset of the resulting finset is equal to the multiset obtained by applying `Multiset.map` with `f` to the underlying multiset of `s`. In other words, the operation of mapping a function over a finset behaves the same as mapping the same function over the underlying multiset of that finset.

For any types `α` and `β`, and any embedding function `f` from `α` to `β`, the map operation on a finset `s` of type `α` using `Finset.map` is equivalent to applying `Multiset.map` with `f` to the underlying multiset of `s`.


theorem Cardinal.ord_aleph0 : Cardinal.ord Cardinal.aleph0 = Ordinal.omega := by sorry

This theorem states that the ordinal corresponding to the smallest infinite cardinal (`ℵ₀`) is the first infinite ordinal (`ω`). In other words, when we map the smallest infinite cardinal to an ordinal using the `Cardinal.ord` function, we obtain the first infinite ordinal. This relationship holds true within the mathematical framework of ordinal and cardinal numbers, where `ℵ₀` corresponds to the cardinality of the set of natural numbers and `ω` is the order type of the natural numbers.

The smallest infinite cardinal `ℵ₀` maps to the first infinite ordinal `ω` under the `Cardinal.ord` function.


theorem Part.get_mem : ∀ {α : Type u_1} {o : Part α} (h : o.Dom), o.get h ∈ o := by sorry

This theorem, `Part.get_mem`, states that for any type of `α` and any partial function `o` of type `α`, if `h` is a proof that the domain of `o` is not empty (i.e., `o.Dom`), then the application of `o.get` to `h` is an element of `o`. In other words, any value that we can extract from a partial function using `get` is assured to be an element of that partial function.

For any partial function `o` on type `α` with non-empty domain, `o.get (h : o.Dom) ∈ o`.


/-- The supremum of a singleton is the element of the singleton -/
theorem csSup_singleton : ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] (a : α), sSup {a} = a := by sorry

This theorem states that for any type `α` that forms a Conditionally Complete Lattice, the supremum (least upper bound) of a singleton set (a set with only one element `a`) is equal to the element `a` itself. In other words, when the set has only one element, that element is both the least and greatest element in the set.

For any type `α` forming a Conditionally Complete Lattice, the supremum of a singleton set `{a}` is equal to `a`.


theorem Real.arcsin_one : Real.arcsin 1 = Real.pi / 2 := by sorry

This theorem states that the arcsine of 1 is equal to π/2. In other words, the angle whose sine is 1, when measured in radians within the interval from -π/2 to π/2, as defined by `Real.arcsin`, is π/2.

The theorem asserts that `Real.arcsin 1 = π/2`.


theorem Localization.mul_def : ∀ {M : Type u_4} [inst : CommMonoid M] (S : Submonoid M), Localization.mul S = Mul.mul :=
  by sorry

The theorem `Localization.mul_def` states that for any type `M` that forms a commutative monoid and any submonoid `S` of `M`, the multiplication operation in the localization of `M` at `S` is the same as the built-in multiplication operation for the type of `Localization S`. In other words, the multiplication of elements in the localized version of the monoid (represented as pairs of elements from `M` and `S`) is equivalent to the usual multiplication of elements in the monoid, which is represented as `⟨a, b⟩ * ⟨c, d⟩ = ⟨a * c, b * d⟩`.

In the localization of a commutative monoid `M` at a submonoid `S`, the multiplication operation is equal to the usual multiplication of elements represented as pairs `⟨a, s⟩` from `M x S`, that is, `⟨a, s⟩ * ⟨b, t⟩ = ⟨a * b, s * t⟩`.


theorem Ideal.comap_map_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Ring S] [inst_2 : FunLike F R S]
      [inst_3 : RingHomClass F R S] (f : F),
      Function.Surjective ⇑f → ∀ (I : Ideal R), Ideal.comap f (Ideal.map f I) = I ⊔ Ideal.comap f ⊥ :=
  by sorry

The theorem `Ideal.comap_map_of_surjective` states that for all types `R`, `S`, and `F` with `R` and `S` being rings and `F` being a function-like from `R` to `S` characterized by `RingHomClass`, if the function `f` of type `F` is surjective, then for any ideal `I` of `R`, the comap of the map of `I` under `f` is equal to the join of `I` and the comap of the bottom element under `f`. In simpler terms, this theorem is about the relationship between the image of an ideal under a surjective ring homomorphism and the preimage of that image under the same homomorphism, stating that the latter equals the original ideal joined with the preimage of the zero ideal.

For a surjective ring homomorphism `f` from `R` to `S` between rings `R` and `S`, the image of ideal `I` of `R` under `f` is equal to the join of `I` and the preimage under `f` of the zero ideal of `S`.


/-- The infimum edistance is invariant under isometries  -/
theorem EMetric.infEdist_image :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {x : α} {t : Set α}
      {Φ : α → β}, Isometry Φ → EMetric.infEdist (Φ x) (Φ '' t) = EMetric.infEdist x t :=
  by sorry

The theorem `EMetric.infEdist_image` states that the minimum extended distance (also known as the infimum extended distance) from a point to a set is invariant under isometries. In other words, if `Φ` is an isometric map between two pseudoemetric spaces `α` and `β`, `x` is a point in `α`, and `t` is a set in `α`, then the minimum extended distance from the image of `x` under `Φ` to the image of the set `t` under `Φ` is the same as the minimum extended distance from `x` to `t`.

Let `Φ` be an isometry between pseudometric spaces `(α, dα)` and `(β, dβ)`, `x ∈ α`, and `t ⊆ α`. Then `inf (dβ(Φ(x), Φ(s)) : s ∈ t) = inf (dα(x, s) : s ∈ t)`.


theorem Function.Surjective.preimage_subset_preimage_iff :
    ∀ {α : Type u_3} {β : Type u_2} {f : α → β} {s t : Set β}, Function.Surjective f → (f ⁻¹' s ⊆ f ⁻¹' t ↔ s ⊆ t) := by
  sorry

The theorem `Function.Surjective.preimage_subset_preimage_iff` states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `f` is surjective, then the preimage of a set `s` under `f` is a subset of the preimage of a set `t` under `f` if and only if `s` is a subset of `t`. Here, a preimage of a set under a function is the set of all elements in the domain that map to any element in the given set. In mathematical terms, if `f` is a surjection from `α` to `β`, then for any sets `s` and `t` of `β`, `f^-1(s) ⊆ f^-1(t)` if and only if `s ⊆ t`.

For any surjective function $f$ from type $\alpha$ to type $\beta$, the preimage of set $s$ under $f$ is a subset of the preimage of set $t$ if and only if $s$ is a subset of $t$. In symbols, $f^{-1}(s) \subseteq f^{-1}(t) \Leftrightarrow s \subseteq t$.


theorem Hyperreal.infinitePos_mul_of_infinitePos_not_infinitesimal_pos :
    ∀ {x y : ℝ*}, Hyperreal.InfinitePos x → ¬Hyperreal.Infinitesimal y → 0 < y → Hyperreal.InfinitePos (x * y) := by
  sorry

The theorem `Hyperreal.infinitePos_mul_of_infinitePos_not_infinitesimal_pos` states that for any two hyperreal numbers `x` and `y`, if `x` is positively infinite (meaning it is larger than all real numbers), and `y` is not infinitesimal (meaning its standard part is not zero) and `y` is greater than zero, then the product `x * y` is also positively infinite.

If `x` is positively infinite and `y` is a non-infinitesimal positive hyperreal number, then `x * y` is also positively infinite.


ContDiffOn.comp

/-- The composition of `C^n` functions on domains is `C^n`.  -/
theorem ContDiffOn.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {s : Set E} {t : Set F} {g : F → G}
      {f : E → F}, ContDiffOn 𝕜 n g t → ContDiffOn 𝕜 n f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 n (g ∘ f) s :=
  by sorry

This theorem states that for differentiable functions `f` and `g` on sets `s` and `t` respectively, if `f` maps `s` into `t`, then the composition `g ∘ f` is also differentiable on `s`. Here, differentiability is couched in terms of being continuously differentiable to any natural number or infinite order (`C^n`), denoted as `ContDiffOn 𝕜 n`, where `𝕜` is a nontrivially normed field and `n` is either a natural number or infinity. The spaces `E`, `F`, and `G` are normed additive commutative groups over `𝕜`.

If `f` is a differentiable function from a set `s` to a normed additive commutative group `E` over a nontrivially normed field `𝕜`, and `g` is a differentiable function from `E` to a normed additive commutative group `G` over `𝕜`, then the composition `g ∘ f` is a differentiable function from `s` to `G`.


theorem CategoryTheory.Functor.preservesEpimorphisms_of_preserves_of_reflects :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E)
      [inst_3 : CategoryTheory.Functor.PreservesEpimorphisms (CategoryTheory.Functor.comp F G)]
      [inst_4 : CategoryTheory.Functor.ReflectsEpimorphisms G], CategoryTheory.Functor.PreservesEpimorphisms F :=
  by sorry

This theorem states that for any three categories `C`, `D`, and `E`, and two functors `F : C -> D` and `G : D -> E`, if the composite functor `G ∘ F` preserves epimorphisms and `G` reflects epimorphisms, then the functor `F` also preserves epimorphisms. Here, "preserves epimorphisms" means that if a morphism in the source category is an epimorphism, its image in the target category is also an epimorphism, and "reflects epimorphisms" means that if a morphism's image in the target category is an epimorphism, then the original morphism in the source category is also an epimorphism.

If functors `F : C -> D` and `G : D -> E` preserve and reflect epimorphisms with `G ∘ F` preserving epimorphisms, then `F` preserves epimorphisms.


theorem frobenius_def :
    ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) [inst_1 : ExpChar R p] (x : R), (frobenius R p) x = x ^ p := by sorry

The theorem `frobenius_def` states that for any type `R` which is an instance of a commutative semiring, any natural number `p`, and any `x` of type `R`, the application of the Frobenius map (which sends `x` to `x` raised to the power `p`) on `x` is equal to `x` raised to the power `p`. In the context of an exponential characteristic of `R`, this theorem essentially asserts the defining property of the Frobenius map.

For any commutative semiring `R` and natural number `p`, the Frobenius map ( raising to the power `p`) on an element `x` in `R` is equal to `x` raised to the power `p`.


theorem AddUnits.val_neg_eq_neg_val : ∀ {α : Type u} [inst : SubtractionMonoid α] (u : AddUnits α), ↑(-u) = -↑u := by
  sorry

This theorem states that for any type `α` that forms a `SubtractionMonoid` (a structure with addition, zero, and subtraction operations satisfying certain properties), given an additive unit `u` of `α`, the value of the negation of `u` is equal to the negation of the value of `u`. In more mathematical terms, it says if `u` is an additive unit in `α`, then `-(u)` equals `-u`, where the notation `-` denotes negation.

For any additive unit `u` in a type `α` forming a `SubtractionMonoid`, we have `-(u) = -u`.


theorem Real.sqrt_ne_zero' : ∀ {x : ℝ}, Real.sqrt x ≠ 0 ↔ 0 < x := by sorry

This theorem states that for all real numbers 'x', the square root of 'x' (as defined by the function Real.sqrt) is not equal to zero if and only if 'x' is greater than zero. In other words, this theorem expresses a property of the square root function on the real numbers, stating that a number has a non-zero square root exactly when it is a positive number.

For all real numbers x, x > 0 if and only if Real.sqrt x ≠ 0.


/-- Any continuous ring homomorphism commutes with `exp`.  -/
theorem NormedSpace.map_exp :
    ∀ (𝕂 : Type u_1) {𝔸 : Type u_2} {𝔹 : Type u_3} [inst : RCLike 𝕂] [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕂 𝔸] [inst_3 : NormedRing 𝔹] [inst_4 : NormedAlgebra 𝕂 𝔹] [inst_5 : CompleteSpace 𝔸]
      {F : Type u_4} [inst_6 : FunLike F 𝔸 𝔹] [inst_7 : RingHomClass F 𝔸 𝔹] (f : F),
      Continuous ⇑f → ∀ (x : 𝔸), f (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (f x) :=
  by sorry

This theorem, named `NormedSpace.map_exp`, states that for any continuous ring homomorphism `f`, the operation of `f` commutes with the exponential function in the context of normed spaces. More specifically, given a type `𝕂` and types `𝔸` and `𝔹` such that they form normed rings and normed algebras over `𝕂`, and `𝔸` is a complete space, along with a type `F` that acts as a function from `𝔸` to `𝔹` and forms a ring homomorphism, for any `x` in `𝔸`, applying `f` to the exponential of `x` is the same as taking the exponential of `f(x)`. The continuity of `f` is a necessary condition for this property.

Given a complete normed ring and algebra 𝔸 over a ring 𝕂, a continuous ring homomorphism F : 𝔸 -> 𝔹 between them, and x in 𝔸, then F(exp(x)) = exp(F(x)).


theorem Complex.contDiff_sin : ∀ {n : ℕ∞}, ContDiff ℂ n Complex.sin := by sorry

This theorem states that the complex sine function, which is defined as `(Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)) * Complex.I / 2`, is continuously differentiable for all orders of differentiation. In other words, the function's derivatives of all orders exist and are continuous in the domain of complex numbers. Here, `n` represents the order of differentiation and can be any natural number or infinity (`ℕ∞`), and `ContDiff ℂ n Complex.sin` is a statement that the function `Complex.sin` is `n`-times continuously differentiable in the field of complex numbers.

The complex sine function, defined as (exp(-z * I) - exp(z * I)) * I / 2, is continuously differentiable to all orders in the complex numbers domain.


Set.Nonempty.closure

/-- **Alias** of the reverse direction of `closure_nonempty_iff`. -/
theorem Set.Nonempty.closure :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], Set.Nonempty s → Set.Nonempty (closure s) := by sorry

This theorem, also known as an alias of the reverse direction of `closure_nonempty_iff`, expresses that for any type `X` and a set `s` of `X` operating under a specified topological space, if the set `s` is non-empty, then the closure of the set `s` is also non-empty. In other words, it asserts that the closure operation preserves the non-emptiness property of a set in topological spaces.

If a non-empty set `s` in a topological space has a closure, then the closure of `s` is non-empty.


theorem Algebra.adjoin_empty :
    ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      Algebra.adjoin R ∅ = ⊥ :=
  by sorry

The theorem `Algebra.adjoin_empty` states that for any commutative semiring `R`, any semiring `A`, and any algebra structure on `A` over `R`, the minimal subalgebra of `A` that includes the empty set is the bottom element (or the trivial subalgebra). In other words, if we don't add any elements from `A` to the algebra structure, we get the smallest possible subalgebra, which consists only of the elements of `R` under the algebra map.

The empty set is the smallest subalgebra of an algebra over a commutative semiring.


Partrec.map

theorem Partrec.map :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α →. β} {g : α → β → σ},
      Partrec f → Computable₂ g → Partrec fun a => Part.map (g a) (f a) :=
  by sorry

The theorem `Partrec.map` states that for all types `α`, `β`, and `σ`, which have instances of `Primcodable` (i.e., they can be encoded as natural numbers), and for all functions `f` from `α` to `β` and `g` from `α` and `β` to `σ`, if `f` is partial recursive (`Partrec`) and `g` is computable with two inputs (`Computable₂`), then the function which takes an `α`, applies `f` to it, and then maps `g` over the result, is also partial recursive (`Partrec`). Essentially, this theorem tells us about the preservation of the property of being partial recursive under the mapping operation with a computable function.

If `f` is partial recursive and `g` is computable with two inputs, then the function `x mapsto g(x, f x)` is partial recursive.


theorem Asymptotics.isBigOWith_neg_left :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c : ℝ}
      {g : α → F} {f' : α → E'} {l : Filter α},
      Asymptotics.IsBigOWith c l (fun x => -f' x) g ↔ Asymptotics.IsBigOWith c l f' g :=
  by sorry

The theorem `Asymptotics.isBigOWith_neg_left` asserts that for any types `α`, `F`, and `E'`, with `F` having a norm structure and `E'` having a seminormed additive commutative group structure, for any real number `c`, any function `g : α → F`, any function `f' : α → E'`, and any filter `l` on `α`, the statement that `f'` is 'big O' of `g` (in the sense of the `Asymptotics.IsBigOWith` definition) with constant `c` and filter `l` is equivalent to the statement that the negation of `f'` is 'big O' of `g` with the same constant and filter. In other words, the 'big O' relationship is preserved when taking the negation of the function.

The negation of a function being big O of another function, with a constant and filter, is equivalent to the original function being big O of the negation of the other function with the same constant and filter.


theorem Units.mul_inv_cancel_left : ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (b : α), ↑a * (↑a⁻¹ * b) = b := by sorry

This theorem states that for any type `α` that is a Monoid, and for any units `a` and any element `b` of that Monoid, the product of `a` and the product of the inverse of `a` and `b` equals `b`. In mathematical terms, it states that `a * (a⁻¹ * b) = b`. This is a property of Monoids, where the multiplication of any element and its inverse results in the identity element, effectively 'canceling out' the original element.

For any monoid `α` and elements `a` with invertible `a⁻¹` in `α`, `a * (a⁻¹ * b) = b`.


theorem CauSeq.lim_eq_of_equiv_const :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {β : Type u_2} [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] [inst_3 : CauSeq.IsComplete β abv] {f : CauSeq β abv} {x : β},
      f ≈ CauSeq.const abv x → CauSeq.lim f = x :=
  by sorry

The theorem `CauSeq.lim_eq_of_equiv_const` states that for any type `α` that forms a linear ordered field, a type `β` that forms a ring, a function `abv` that assigns an absolute value from `β` to `α`, and given that `β` forms a complete Cauchy sequence with respect to `abv`, if a Cauchy sequence `f` is equivalent to a constant sequence with value `x`, then the limit of `f` is that same constant value `x`. In other words, if the difference between all the terms in the sequence `f` and a fixed constant `x` get arbitrarily small, then the limit of the sequence `f` is `x`.

If `f` is a Cauchy sequence in a linearly ordered field `α` with respect to an absolute value from a complete ring `β`, and `f` is equivalent to the constant sequence with value `x`, then the limit of `f` equals `x`.


/-- **Alias** of `mul_div_cancel_left`. -/
theorem mul_div_cancel''' : ∀ {G : Type u_3} [inst : CommGroup G] (a b : G), a * b / a = b := by sorry

This theorem, known as `mul_div_cancel'''`, states that for all types `G` that are commutative groups, for any two elements `a` and `b` in `G`, if you multiply `a` and `b` together and then divide the result by `a`, you get `b`. In mathematical notation, this can be written as $a * b / a = b$. This theorem is an alias of the theorem `mul_div_cancel_left`.

For all commutative groups `G` and elements `a, b` in `G`, `a * b = a * c` implies `b = c`.


theorem MeasurableEmbedding.map_comap :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f →
        ∀ (μ : MeasureTheory.Measure β),
          MeasureTheory.Measure.map f (MeasureTheory.Measure.comap f μ) = μ.restrict (Set.range f) :=
  by sorry

This theorem states that for any two types `α` and `β`, each with their associated measurable spaces `m0` and `m1`, and a function `f` from `α` to `β` that is a measurable embedding, then for any measure `μ` on `β`, the measure induced by first applying the function `f` and then measuring (i.e., the pushforward measure) equals the restriction of the original measure `μ` to the range of the function `f`. This demonstrates how measures are preserved under the action of a measurable embedding.

If `f: α → β` is a measurable embedding between measurable spaces `(α, m0)` and `(β, m1)`, and `μ` is a measure on `β`, then `f_*\mu = μ ∘ Restriction f`, where `f_*\mu` is the pushforward measure and `Restriction f` is the restriction of `μ` to the range of `f`.