theorem Function.Injective2.eq_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ},
      Function.Injective2 f → ∀ {a₁ a₂ : α} {b₁ b₂ : β}, f a₁ b₁ = f a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ :=
  by sorry

This theorem states that for any binary function `f : α → β → γ`, if `f` is injective (in the sense that if `f a₁ b₁ = f a₂ b₂` then `a₁ = a₂` and `b₁ = b₂`), then for any `a₁, a₂` in `α` and `b₁, b₂` in `β`, `f a₁ b₁ = f a₂ b₂` if and only if `a₁ = a₂` and `b₁ = b₂`. In other words, the binary function `f` being injective is equivalent to the condition that the equality of function outputs `f a₁ b₁` and `f a₂ b₂` implies and is implied by the equality of the corresponding inputs `(a₁, b₁)` and `(a₂, b₂)`.

If `f : α → β → γ` is an injective function, then for all `a₁, a₂ in α` and `b₁, b₂ in β`, `f a₁ b₁ = f a₂ b₂` if and only if `(a₁, b₁) = (a₂, b₂)`.


/-- This is "unbundled", because that is required for the API of `inducedOuterMeasure`.  -/
theorem MeasureTheory.Content.innerContent_mono :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) ⦃U V : Set G⦄ (hU : IsOpen U)
      (hV : IsOpen V),
      U ⊆ V →
        MeasureTheory.Content.innerContent μ { carrier := U, is_open' := hU } ≤
          MeasureTheory.Content.innerContent μ { carrier := V, is_open' := hV } :=
  by sorry

The theorem `MeasureTheory.Content.innerContent_mono` states that for any two open sets `U` and `V` in a topological space `G`, if `U` is a subset of `V`, then the inner content of `U` with respect to a content `μ` (a measure on the compact subsets of `G`) is less than or equal to the inner content of `V` with respect to the same content `μ`. The inner content is defined as the supremum of the content of all compact subsets of the open set. This theorem is referred to as "unbundled" to fit the API of `inducedOuterMeasure`.

For any open sets U and V in a topological space G and content μ, if U ⊆ V, then μ^(inner) (U) ≤ μ^(inner) (V).


/-- **Intermediate Value Theorem** for continuous functions on connected sets.  -/
theorem IsPreconnected.intermediate_value :
    ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : OrderClosedTopology α] {s : Set X},
      IsPreconnected s → ∀ {a b : X}, a ∈ s → b ∈ s → ∀ {f : X → α}, ContinuousOn f s → Set.Icc (f a) (f b) ⊆ f '' s :=
  by sorry

This theorem is a statement of the Intermediate Value Theorem for continuous functions on connected sets in topology. In more detail, it says that for any type `X` with a topology, a linearly ordered type `α` also with a topology and an order-closed topology, and a set `s` of type `X` that is preconnected, for any two elements `a` and `b` in `s` and a function `f` from `X` to `α` that is continuous on `s`, the closed interval between `f(a)` and `f(b)` in `α` is a subset of the image of `f` applied to `s`. In simpler terms, if you have a continuous function on a connected set, then any value between the function values at two points in that set can be achieved by the function within that set.

If `X` is a connected topological space, `α` is a linearly ordered and order-closed topological space, `s` is a preconnected subset of `X`, and `f` is a continuous function from `X` to `α`, then the image of `s` contains the closed interval between `f(a)` and `f(b)` for any `a, b` in `s`.


theorem Real.rpow_le_rpow_left_iff : ∀ {x y z : ℝ}, 1 < x → (x ^ y ≤ x ^ z ↔ y ≤ z) := by sorry

This theorem states that for any real numbers x, y, and z, if x is greater than 1, then x raised to the power of y is less than or equal to x raised to the power of z if and only if y is less than or equal to z. In other words, if we have a real number x that's greater than 1, the function f(n) = x^n is non-decreasing with respect to n.

For any real numbers x > 1, x^y <= x^z if and only if y <= z.


theorem Real.Angle.coe_sub : ∀ (x y : ℝ), ↑(x - y) = ↑x - ↑y := by sorry

This theorem states that for any two real numbers `x` and `y`, the angle of their difference is equal to the difference of their angles. In other words, converting the difference of two real numbers into an angle (represented by `↑(x - y)`) is the same as first converting the numbers into angles and then subtracting them (represented by `↑x - ↑y`).

For any real numbers x and y, ↑(x - y) = ↑x - ↑y.


theorem List.sum_nil : ∀ {M : Type u_5} [inst : AddZeroClass M], List.sum [] = 0 := by sorry

This theorem states that for any type `M` that has an additive identity (zero) and a binary addition operation, the sum of an empty list of elements of type `M` is zero. In more mathematical terms, if you consider any set `M` equipped with addition and a zero element (i.e., a set `M` forming an AddZeroClass), the sum over an empty set in `M` is equal to the zero element of `M`.

For any AddMonoid `M`, the sum of the empty list of elements from `M` is equal to the additive identity of `M`.


NoMaxOrder.infinite

/-- A nonempty preorder with no maximal element is infinite. This is not an instance to avoid
a cycle with `Infinite α → Nontrivial α → Nonempty α`.  -/
theorem NoMaxOrder.infinite :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Nonempty α] [inst : NoMaxOrder α], Infinite α := by sorry

This theorem states that for any nonempty type `α` that is a preorder and has no maximal element (i.e., there's always an element larger than any given one), then `α` is infinite. This means that we can always find a new, distinct element in `α`, no matter how many elements we've already considered. This theorem is not an instance, to avoid a cyclic dependency with the implications `Infinite α → Nontrivial α → Nonempty α`.

If `α` is a nonempty preorder type without a maximal element, then `α` is infinite.


theorem GaloisConnection.isLUB_l_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {s : Set α} {a : α}, IsLUB s a → IsLUB (l '' s) (l a) :=
  by sorry

The theorem `GaloisConnection.isLUB_l_image` asserts that for any two types `α` and `β` with preorders, and functions `l : α → β` and `u : β → α` forming a Galois connection, if `a` is a least upper bound (LUB) of a set `s` of elements from type `α`, then `l a` is the least upper bound of the image of `s` under `l`. In other words, the image under the function `l` of a set which has a least upper bound `a`, has its least upper bound at `l a`.

Given a Galois connection between preordered types `α` and `β` via functions `l : α → β` and `u : β → α`, if `a` is the least upper bound of a set `s` in `α`, then `l a` is the least upper bound of `l''s` in `β`.


theorem Equiv.Perm.dvd_of_mem_cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ},
      n ∈ Equiv.Perm.cycleType σ → n ∣ orderOf σ :=
  by sorry

The theorem `Equiv.Perm.dvd_of_mem_cycleType` asserts that for any finite type `α` with decidable equality and any permutation `σ` over `α`, if a natural number `n` belongs to the cycle type of `σ`, then `n` divides the order of `σ`. Here, the cycle type of a permutation is represented as a multiset of natural numbers, where each number corresponds to the size of a cycle in the permutation. The order of a permutation is defined as the smallest positive integer `n` such that applying the permutation `n` times is equivalent to doing nothing, or in other words, `σ^n = 1`. If such `n` does not exist, the order of the permutation is defined to be `0`.

If `σ` is a permutation on a finite type `α` with decidable equality, and `n` is in the cycle type of `σ`, then `n` divides the order of `σ`.


theorem Finset.centerMass_eq_of_sum_1 :
    ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : LinearOrderedField R] [inst_1 : AddCommGroup E]
      [inst_2 : Module R E] (t : Finset ι) {w : ι → R} (z : ι → E),
      (Finset.sum t fun i => w i) = 1 → Finset.centerMass t w z = Finset.sum t fun i => w i • z i :=
  by sorry

This theorem states that for any linear ordered field `R`, additively commutative group `E`, and arbitrary type `ι`, if we have a finite set `t` of type `ι`, a weight function `w: ι → R`, and a point function `z: ι → E` such that the sum of the weights equals 1, then the center of mass of the finite collection of points (derived from `z`) with the prescribed weights (derived from `w`) is equal to the weighted sum of the points. In other words, it says that if the weights sum up to 1, then the center of mass is just the weighted sum of the points in the set.

Given a linear ordered field `R`, an additively commutative group `E`, a finite set `t` of type `ι`, a weight function `w: ι → R`, and a point function `z: ι → E` with sum of weights equal to 1, the center of mass of `z` with respect to `w` equals the weighted sum of `z`.


theorem Nat.divisors_prime_pow :
    ∀ {p : ℕ} (pp : Nat.Prime p) (k : ℕ),
      Nat.divisors (p ^ k) = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range (k + 1)) :=
  by sorry

The theorem `Nat.divisors_prime_pow` states that for any natural number `p` that is prime (as defined by `Nat.Prime p`) and any natural number `k`, the set of divisors of `p ^ k` (as defined by `Nat.divisors`) is equal to the set obtained by mapping the function `p ^ x` over the set of natural numbers less than `k + 1` (as defined by `Finset.range`). In other words, if `p` is a prime number and `k` is any natural number, the divisors of `p` raised to the power of `k` are precisely the numbers `p` raised to the power of every natural number less than `k + 1`.

For any prime number $p$ and natural number $k$, the divisors of $p^k$ are the numbers $p^x$ for $x$ in the range $0$ to $k$.


/-- A function is `C^(n + 1)` on a domain with unique derivatives if and only if it is
differentiable there, and its derivative (expressed with `fderivWithin`) is `C^n`.  -/
theorem contDiffOn_succ_iff_fderivWithin :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ},
      UniqueDiffOn 𝕜 s →
        (ContDiffOn 𝕜 (↑(n + 1)) f s ↔ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s) :=
  by sorry

The theorem `contDiffOn_succ_iff_fderivWithin` states that for any normed field `𝕜`, normed add commutative groups `E` and `F` with `𝕜` as their scalar field, a set `s` of elements of type `E`, a function `f` from `E` to `F`, and a natural number `n`, if the set `s` has a unique derivative at each of its points (`UniqueDiffOn 𝕜 s`), then the function `f` is continuously differentiable to order `(n + 1)` on the set `s` (expressed as `ContDiffOn 𝕜 (↑(n + 1)) f s`) if and only if `f` is differentiable on `s` (`DifferentiableOn 𝕜 f s`) and the derivative of `f` within `s` (expressed with `fderivWithin 𝕜 f s y`) is continuously differentiable to order `n` on `s` (`ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s`).

A function between two normed spaces is continuously differentiable to order (n+1) on a set with unique derivatives if and only if it is differentiable and its derivative within the set is continuously differentiable to order n.


theorem Int.dvd_refl : ∀ (n : ℤ), n ∣ n := by sorry

The theorem `Int.dvd_refl` states that for every integer `n`, `n` divides `n`. In other words, any integer is a divisor of itself. This result is a fundamental property of integers in the realm of number theory.

For every integer `n`, `n` divides `n`. In other words, `n` | `n` for all integers `n`.


theorem Commute.neg_right :
    ∀ {R : Type x} [inst : Mul R] [inst_1 : HasDistribNeg R] {a b : R}, Commute a b → Commute a (-b) := by sorry

This theorem, `Commute.neg_right`, states that for any type `R` that has multiplication (`Mul`) and a distributive negation relation (`HasDistribNeg`), if two elements `a` and `b` of `R` commute, i.e., `a * b = b * a`, then `a` also commutes with the negation of `b`, i.e., `a * (-b) = (-b) * a`.

If `R` is a type with multiplication and distributive negation, and `a` and `b` in `R` commute, then `a` also commutes with the negation of `b`. In other words, `a * b = b * a` implies `a * (-b) = (-b) * a`.


theorem MeasureTheory.Measure.mkMetric_toOuterMeasure :
    ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X]
      (m : ENNReal → ENNReal), ↑(MeasureTheory.Measure.mkMetric m) = MeasureTheory.OuterMeasure.mkMetric m :=
  by sorry

This theorem states that for any type `X` that is an extended metric space, a measurable space, and a Borel space, and any function `m` from extended nonnegative real numbers to extended nonnegative real numbers, the measure induced by `m` when considered as an outer measure (by applying the outer measure constructor to the measure) is equal to the outer measure directly constructed from `m` using the `MeasureTheory.OuterMeasure.mkMetric` function. In mathematical terms, this theorem asserts that if `m : [0, ∞] → [0, ∞]` is a function, then the measure induced by `m`, when viewed as an outer measure, is the same as the outer measure directly defined from `m`.

For any extended real-valued measurable function `m` on an extended metric space `X` that is also a Borel space, the outer measure induced by `m` equals the outer measure constructed directly from `m` using the `MeasureTheory.OuterMeasure.mkMetric` function.


Equiv.nonempty

theorem Equiv.nonempty : ∀ {α : Sort u} {β : Sort v}, α ≃ β → ∀ [inst : Nonempty β], Nonempty α := by sorry

This theorem states that for any two types `α` and `β`, if there is an equivalence between `α` and `β`, and `β` is nonempty (i.e., there exists at least one value of type `β`), then `α` is also nonempty. In other words, if we can map every element of type `α` to some element of type `β`, and we know that there is at least one value of type `β`, then there must be at least one value of type `α`.

If there exists an equivalence between types `α` and `β` and `β` is nonempty, then `α` is nonempty.


theorem RatFunc.denom_algebraMap :
    ∀ {K : Type u} [inst : Field K] (p : Polynomial K), RatFunc.denom ((algebraMap (Polynomial K) (RatFunc K)) p) = 1 :=
  by sorry

This theorem states that for any field `K` and any polynomial `p` over `K`, if we map `p` from the polynomial ring over `K` to the ring of rational functions over `K` using the `algebraMap` function, then the denominator of the resulting rational function, when normalized so that it is monic (leading coefficient is 1), is always 1. In other words, the algebraic mapping of a polynomial into a rational function always results in a rational function with a denominator of 1.

For any field `K` and polynomial `p` over `K`, the image of `p` under the algebra map from the polynomial ring to the rational function ring over `K` is a rational function with a monic denominator equal to 1.


theorem CircleDeg1Lift.le_translationNumber_of_add_int_le :
    ∀ (f : CircleDeg1Lift) {x : ℝ} {m : ℤ}, x + ↑m ≤ f x → ↑m ≤ CircleDeg1Lift.translationNumber f := by sorry

The theorem `CircleDeg1Lift.le_translationNumber_of_add_int_le` states that for any transformation `f` represented by the type `CircleDeg1Lift`, any real number `x`, and any integer `m`, if `x` plus the real representation of `m` is less than or equal to the value of `f` at `x`, then the real representation of `m` is less than or equal to the translation number of `f`. In mathematical terms, for all `f`, `x`, and `m`, if $x + m \leq f(x)$ then $m \leq τ(f)$, where $τ(f)$ represents the translation number of `f`.

If $x + m \leq f(x)$ for a transformation $f$ and real numbers $x$ and $m$, then $m \leq τ(f)$, where $τ(f)$ is the translation number of $f$.


theorem Option.map_some' : ∀ {α : Type u_1} {β : Type u_2} (a : α) (f : α → β), Option.map f (some a) = some (f a) := by
  sorry

The theorem `Option.map_some'` states that for all types `α` and `β`, for any element `a` of type `α`, and any function `f` from `α` to `β`, if you map the function `f` over the `Option` containing `a` (`some a`), then the result is the `Option` containing the result of applying `f` to `a` (`some (f a)`). In other words, the function `f` is applied directly to the value wrapped in the `Option` type.

For all types `α` and `β`, and functions `f` from `α` to `β`, `Option.map some f a = some (f a)`.


IsLocalHomeomorph.isLocalHomeomorphOn

theorem IsLocalHomeomorph.isLocalHomeomorphOn :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X},
      IsLocalHomeomorph f → IsLocalHomeomorphOn f s :=
  by sorry

This theorem states that for all topological spaces `X` and `Y`, all functions `f` from `X` to `Y`, and all sets `s` of `X`, if `f` satisfies the property `IsLocalHomeomorph`, then `f` also satisfies the property `IsLocalHomeomorphOn` for the set `s`. In other words, if every point in `X` is mapped by `f` in a way that is locally a homeomorphism, then every point in the particular set `s` of `X` is also mapped by `f` in a way that is locally a homeomorphism.

If `f` is a local homeomorphism from a topological space `X` to `Y`, then `f` is locally a homeomorphism on every subset `s` of `X`.


theorem continuousOn_fst :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set (α × β)},
      ContinuousOn Prod.fst s :=
  by sorry

This theorem states that for any types `α` and `β` that have a topological structure (represented by `TopologicalSpace α` and `TopologicalSpace β` instances), and for any set `s` of pairs of elements from `α` and `β` (expressed as `Set (α × β)`), the first projection function (`Prod.fst`) is continuous on this set. In terms of topology, the first projection function, which picks out the first element of each pair in the set `s`, maintains the continuity property; that is, for every point in the set `s`, the function is continuous at that point within the set.

For any topological spaces `α` and `β` and a set `s` of pairs from `α × β`, the first projection function `Prod.fst` is continuous on `s`.


/-- A set is dense if and only if it has a nonempty intersection with each nonempty open set.  -/
theorem dense_iff_inter_open :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X],
      Dense s ↔ ∀ (U : Set X), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s) :=
  by sorry

This theorem states that, for any type `X` and any set `s` of type `X` within a topological space, the set `s` is dense if and only if for every set `U` of type `X`, if `U` is open and `U` is not empty, then the intersection of `U` and `s` is also not empty. In the context of topology, this essentially means that a set is dense if it intersects with every nonempty open set in the topological space.

A set `s` of type `X` in a topological space is dense if and only if the intersection of `s` and every nonempty open set `U` is not empty.


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

This theorem states that for any two types `X` and `Y`, and any function `f` from `X` to `Y`, given that the topological structures of `X` and `Y` exist and the function `f` is inducing, for any set `s` of `X`, the closure of `s` is equal to the preimage under `f` of the closure of the image of `s` under `f`. In simpler terms, it says that the closure of a set in the domain of an inducing function is the same as the preimage of the closure of the image of that set under the function. This is a property of inducing functions in topology which helps in studying the topological structure of sets and spaces.

For any inducing function between topological spaces `f` from `X` to `Y`, the closure of `f`'s image of a set `s` in `X` equals the preimage of the closure of that image in `Y`.


/-- See `zero_lt_three'` for a version with the type explicit.  -/
theorem zero_lt_three :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : NeZero 1] [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 < 3 :=
  by sorry

This theorem, `zero_lt_three`, asserts that zero is less than three. It applies for any type `α` that satisfies several conditions: it must be an additive monoid with one, have a partial order, have a zero less than or equal to one class, not have zero as its unity (1 is not zero), and it must be a covariant class, which means that addition respects the order. In simpler terms, if you have a number system where you can add and compare numbers, and one is greater than zero, then zero is always less than three in that system.

For any additive monoid with one and a covariant partial order where zero is less than one and one is not the unity, zero is less than three.


theorem Finsupp.sum_eq_single :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {f : α →₀ M} (a : α)
      {g : α → M → N},
      (∀ (b : α), f b ≠ 0 → b ≠ a → g b (f b) = 0) → (f a = 0 → g a 0 = 0) → Finsupp.sum f g = g a (f a) :=
  by sorry

The theorem `Finsupp.sum_eq_single` states that for any types `α`, `M`, and `N` where `M` has a zero element and `N` is an additive commutative monoid, and for any function `f` from `α` to `M`, any element `a` of type `α`, and any function `g` from `α` and `M` to `N`, if `g` applied to `b` and `f b` is zero for all `b` not equal to `a` where `f b` is not zero, and if `g a 0` is zero when `f a` is zero, then the sum of `g a (f a)` over the support of `f`, as defined by `Finsupp.sum f g`, is equal to `g a (f a)`. In other words, the sum of the function `g` applied to each element `a` and its corresponding `f a` over the support of `f` is essentially determined by the value of `g a (f a)`.

For any function `f: α -> M` from a type `α` to an additive commutative monoid `M` with zero element, and any function `g: α x M -> N` from `α` and `M` to another additive commutative monoid `N`, if the sum of `g a (f a)` over the support of `f` equals `g a (f a)` for all `a` where `f a` is non-zero, then the sum of `g` applied to each `(a, f a)` pair over the support of `f` equals `g a (f a)`.


theorem Set.indicator_union_of_disjoint :
    ∀ {α : Type u_1} {M : Type u_4} [inst : AddZeroClass M] {s t : Set α},
      Disjoint s t → ∀ (f : α → M), Set.indicator (s ∪ t) f = fun a => Set.indicator s f a + Set.indicator t f a :=
  by sorry

The theorem `Set.indicator_union_of_disjoint` states that for any two disjoint sets `s` and `t` of any type `α`, and for any function `f` from `α` to a type `M` which has addition and zero, the indicator function of the union of `s` and `t` with respect to `f` is the sum of the indicator functions of `s` and `t` with respect to `f`. Here, the indicator function of a set `s` is a function that takes an element `a` and maps it to `f(a)` if `a` belongs to `s`, and to zero otherwise. Two sets are considered disjoint if they have no element in common.

For any disjoint sets `s` and `t` of type `α` and any function `f` from `α` to a type `M` with addition and zero, the indicator function of `s ∪ t` with respect to `f` equals the sum of the indicator functions of `s` and `t` with respect to `f`.


theorem Filter.eventually_sup :
    ∀ {α : Type u} {p : α → Prop} {f g : Filter α},
      (∀ᶠ (x : α) in f ⊔ g, p x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in g, p x :=
  by sorry

This theorem states that for all types `α` and any predicate `p` on `α`, along with any two filters `f` and `g` on `α`, a proposition `p` is eventually true in the supremum (`⊔`) of filters `f` and `g` if and only if `p` is eventually true in both filters `f` and `g`. In mathematical language, it can be said that a property holds eventually in the supremum of two filters if and only if it holds eventually in both of the original filters.

For all types `α` and predicates `p` on `α`, if `p` is eventually true in both filters `f` and `g` on `α`, then `p` is eventually true in their supremum `f ⊔ g`.


theorem Complex.ofReal_eq_zero : ∀ {z : ℝ}, ↑z = 0 ↔ z = 0 := by sorry

This theorem, `Complex.ofReal_eq_zero`, states that for all real numbers 'z', the complex number representation of 'z' (denoted as `↑z`) is equal to zero if and only if 'z' itself is zero. In other words, a real number can be represented as zero in the complex number plane only when it is zero in the real number line.

The complex representation `↑z` of a real number `z` equals zero if and only if `z` itself is zero.


theorem isSeparatedMap_iff_isClosed_diagonal :
    ∀ {X : Type u_1} {Y : Sort u_2} [inst : TopologicalSpace X] {f : X → Y},
      IsSeparatedMap f ↔ IsClosed (Function.pullbackDiagonal f) :=
  by sorry

The theorem `isSeparatedMap_iff_isClosed_diagonal` states that for any function `f` from a topological space `X` to any type `Y`, `f` is a separated map if and only if the diagonal of the pullback of `f` is a closed set. In other words, a function `f` separates points via open neighborhoods if and only if the subset of the pullback of `f` where the first and second components are equal forms a closed set in the topological space.

A function between topological spaces is separated if and only if the diagonal of its pullback is a closed set.


/-- The pullback provided by `HasPullback f g` fits into an `IsPullback`.  -/
theorem CategoryTheory.IsPullback.of_hasPullback :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasPullback f g],
      CategoryTheory.IsPullback CategoryTheory.Limits.pullback.fst CategoryTheory.Limits.pullback.snd f g :=
  by sorry

This theorem states that in the context of a category `C`, for any three objects `X`, `Y`, `Z` in `C` and two morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, if the pullback of `f` and `g` exists (i.e., `HasPullback f g` holds), then the pullback object along with the two projection morphisms (given by `pullback.fst` and `pullback.snd`) forms an "IsPullback" square. In other words, the pullback structure provided by `HasPullback f g` satisfies the universal property of the pullback.

Given any morphisms `f: X -> Z` and `g: Y -> Z` in a category `C` with a pullback `(PB, p_X, p_Y)` at `Z`, the pullback `PB` is the unique object `B` and morphisms `p_X: X -> B` and `p_Y: Y -> B` such that for all objects `A` and morphisms `h: A -> X` and `k: A -> Y`, if `f . h = g . k`, then there exists a unique morphism `i: A -> B` with `h = p_X . i` and `k = p_Y . i`.


theorem EReal.coe_ennreal_zero : ↑0 = 0 := by sorry

This theorem states that the embedding of zero from the extended non-negative real numbers (`ennreal`) into the extended real numbers (`EReal`) is zero. In other words, if we cast zero as an extended non-negative real number into the extended real numbers, we still get zero.

The theorem asserts that the conversion of the natural number zero to an extended non-negative real number, and then to an extended real number, equals zero.


theorem Finset.inf_singleton :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {f : β → α} {b : β},
      Finset.inf {b} f = f b :=
  by sorry

The theorem `Finset.inf_singleton` states that for any types `α` and `β`, given a semilattice structure and an order top structure on `α`, a function `f` from `β` to `α`, and an element `b` of type `β`, the infimum (greatest lower bound) of the singleton set `{b}` under the function `f` is equal to the function `f` applied to `b`. This means that the infimum of the image of a singleton set under a function is just the image of the single element itself.

For any semilattice and order topology on types `α` and `β`, and any function `f` from `β` to `α` and element `b` of `β`, the infimum of the singleton set `{b}` under `f` equals `f(b)`.


theorem Ideal.map_map :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {T : Type u_3} [inst_2 : Semiring T]
      {I : Ideal R} (f : R →+* S) (g : S →+* T), Ideal.map g (Ideal.map f I) = Ideal.map (RingHom.comp g f) I :=
  by sorry

The theorem `Ideal.map_map` states that for any semirings `R`, `S`, and `T` with an ideal `I` of `R`, and ring homomorphisms `f: R →+* S` and `g: S →+* T`, the image of the ideal `I` under the composition of `f` and `g` is the same as the image of the ideal `I` under `f` followed by the image under `g`. In other words, mapping an ideal through two ring homomorphisms in sequence is the same as mapping it through their composition. This is a property related to the composition of functions and maintains the structure of the ideal through multiple transformations.

For any semirings R, S, T and an ideal I of R, and ring homomorphisms f : R -> S and g : S -> T, the image of I under the composition of f and g is equal to the image of I under f followed by the image under g.


theorem Filter.isCountablyGenerated_seq :
    ∀ {α : Type u_1} {ι' : Sort u_5} [inst : Countable ι'] (x : ι' → Set α),
      Filter.IsCountablyGenerated (⨅ i, Filter.principal (x i)) :=
  by sorry

This theorem states that for any type `α`, any countable index type `ι'` and any sequence `x` of sets of type `α` indexed by `ι'`, the filter generated by the principle filter on each of the sets `x i` (the infimum over all `i` of the principle filter of `x i`) is countably generated. A filter is countably generated if there exists a countable collection of sets such that the filter is the smallest filter containing that collection.

For any countable index type `ι` and countable sequence `(F_i : Filter α)_i` of filters on a type `α`, the filter generated by their principal filters `(principal_filter F_i)_i` is countably generated.


theorem FirstOrder.Language.LHom.onTheory_model :
    ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L' M] (φ : L →ᴸ L') [inst_2 : FirstOrder.Language.LHom.IsExpansionOn φ M]
      (T : FirstOrder.Language.Theory L), M ⊨ FirstOrder.Language.LHom.onTheory φ T ↔ M ⊨ T :=
  by sorry

This theorem, `FirstOrder.Language.LHom.onTheory_model`, states that for any two languages `L` and `L'`, and any type `M` that has a structure for both `L` and `L'`, given a language homomorphism `φ` from `L` to `L'` that is an expansion on `M`, and a theory `T` in the language `L`, then `M` is a model of the theory `T` under the language map `φ` if and only if `M` is a model of the theory `T`. In other words, the truth of a theory `T` under a language map `φ` in a model `M` depends solely on whether `M` is a model of `T` itself.

For any languages L and L', type M with structures for L and L', theory T in L, language homomorphism φ from L to L' that is an expansion on M: M is a model of T under φ if and only if M is a model of T.


theorem MeasureTheory.Measure.map_id' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.Measure.map (fun x => x) μ = μ :=
  by sorry

The theorem `MeasureTheory.Measure.map_id'` states that for any measurable space `α` and any measure `μ` defined on that space, the pushforward of `μ` under the identity function is equal to `μ` itself. In other words, applying the measure to the space without altering the elements (which is what the identity function does) doesn't change the measure.

For any measurable space `(α, Σ, μ)`, the pushforward measure of `μ` under the identity function is equal to `μ` itself.


theorem CategoryTheory.eqToHom_unop :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (h : X = Y),
      (CategoryTheory.eqToHom h).unop = CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.eqToHom_unop` states that for any category `C` and any two objects `X` and `Y` in the opposite category `Cᵒᵖ`, given an equality `h : X = Y`, the unopposite of the morphism from `X` to `Y` in `Cᵒᵖ` obtained through `CategoryTheory.eqToHom h` is equal to the morphism from `X` to `Y` in the category `C` obtained by applying `CategoryTheory.eqToHom` to this equality after applying an unspecified operation. Essentially, the theorem connects the morphisms obtained from equalities in a category and its opposite.

For any category `C` and objects `X` and `Y` in `Cᵒᵖ`, the unopposite morphism from `X` to `Y` in `Cᵒᵖ` obtained from an equality `h : X = Y` is equal to the morphism from `X` to `Y` in `C` obtained by applying `CategoryTheory.eqToHom` to `h`.


theorem CategoryTheory.Iso.hom_inv_id_apply :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (self : X ≅ Y)
      [inst_1 : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).obj X), self.2 (self.1 x) = x :=
  by sorry

The theorem `CategoryTheory.Iso.hom_inv_id_apply` in Lean 4 states that for any type `C` that is a category, with instances `X` and `Y` in `C`, and for any isomorphism `self` between `X` and `Y`, if `C` is also a concrete category, then applying the inverse of `self` to the result of applying `self` to any element `x` in `X` (under the forgetful functor from `C` to `Type`), we get back the original element `x`. In simpler words, this theorem is about the round-trip property of isomorphisms in concrete categories: if you apply the isomorphism and then its inverse, you end up back where you started.

In a concrete category with isomorphism `self` between objects `X` and `Y`, applying `self` followed by its inverse and forgetting the category structure results in the identity function on `X`.


theorem eventually_le_limsup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] [inst_3 : FirstCountableTopology α] {f : Filter β} [inst_4 : CountableInterFilter f]
      {u : β → α},
      autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝ → ∀ᶠ (b : β) in f, u b ≤ Filter.limsup u f :=
  by sorry

The theorem `eventually_le_limsup` states that for any type `α` equipped with a conditionally complete linear order, topological space structure, order topology, and first countable topology, and any type `β`, given a filter `f` for `β` that satisfies the countable intersection property and a function `u` from `β` to `α`, if it is assumed (through `autoParam`) that the image of the filter `f` under `u` is eventually bounded under the less than or equal to relation, then eventually (for `f`), each value `u b` for `b` in `β` is less than or equal to the limit superior (`limsup`) of `u` along `f`. In simpler terms, almost all values of `u` are below the `limsup` in the limit.
Using mathematical notation, it says that if $\{u(b) : b \in \text{Filter } f\}$ is an eventually bounded set, then $\forall b \in \text{Filter } f$, eventually $u(b) \leq \limsup_{b \to f} u(b)$.

If a filter on a type equipped with a linear order and topologies satisfies the countable intersection property and its image under a function is eventually bounded, then each element in the filter is eventually less than or equal to the limit superior of the function along that filter.


theorem FreeGroup.invRev_invRev : ∀ {α : Type u} {L₁ : List (α × Bool)}, FreeGroup.invRev (FreeGroup.invRev L₁) = L₁ :=
  by sorry

This theorem states that for all types `α` and all lists `L₁` of pairs of `α` and `Bool`, applying the function `FreeGroup.invRev` twice returns the original list. In other words, the function `FreeGroup.invRev` is its own inverse. This function, which transforms a word representing a free group element into a word representing its inverse, is an involution: applying it twice gives the original word back.

For all types `α` and lists `L₁` of pairs `(α, bool)`, the function `FreeGroup.invRev` applied twice to `L₁` equals `L₁`.


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

This theorem states that for any two propositions `a` and `b`, given that both `a` and `b` are decidable (i.e., either `a` or `not a` is true, and similarly for `b`), the logical implication from the negation of `a` to `b` is equivalent to the logical implication from the negation of `b` to `a`. In other words, "if not `a`, then `b`" is the same as saying "if not `b`, then `a`".

The negations of propositions `a` and `b` are logically equivalent if and only if the implication from the negation of `a` to `b` is equivalent to the implication from the negation of `b` to `a`.


/-- An epimorphism in `SimplexCategory` must decrease lengths -/
theorem SimplexCategory.len_le_of_epi :
    ∀ {x y : SimplexCategory} {f : x ⟶ y}, CategoryTheory.Epi f → SimplexCategory.len y ≤ SimplexCategory.len x := by
  sorry

This theorem states that for any two objects `x` and `y` in the Simplex Category and a morphism `f` from `x` to `y`, if the morphism `f` is an epimorphism (meaning it is right-cancellable), then the length of `y` must be less than or equal to the length of `x`. In the context of the Simplex Category, objects are natural numbers and morphisms are monotone functions from `Fin (n+1)` to `Fin (m+1)`, so this theorem essentially says that an epimorphic monotone function cannot increase the size of the ordered set it acts upon.

In the Simplex Category, if a morphism between objects of different lengths is an epimorphism, then the length of the domain is less than or equal to the length of the codomain.


IsClosed.mono

theorem IsClosed.mono : ∀ {α : Type u_1} {t₁ t₂ : TopologicalSpace α} {s : Set α}, IsClosed s → t₁ ≤ t₂ → IsClosed s :=
  by sorry

The theorem `IsClosed.mono` states that for any types `α` and any two topological spaces `t₁` and `t₂` on `α`, if a set `s` of type `α` is closed in the first topological space `t₁`, and the first topological space `t₁` is a subset of or equal to the second topological space `t₂` (ie., `t₁ ≤ t₂`), then set `s` is also closed in the second topological space `t₂`. This theorem is asserting the preservation of the closure of a set under the subset or equality relation between topological spaces.

If a set is closed in a topological space that is a subset or equal to another topological space, then the set is closed in the larger topological space.


theorem BoundedContinuousFunction.norm_ofNormedAddCommGroup_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β] {f : α → β}
      (hfc : Continuous f) {C : ℝ},
      0 ≤ C → ∀ (hfC : ∀ (x : α), ‖f x‖ ≤ C), ‖BoundedContinuousFunction.ofNormedAddCommGroup f hfc C hfC‖ ≤ C :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is equipped with a Topological Space structure, and `β` is a Semi-normed Additive Commutative Group, any continuous function `f` from `α` to `β` with a positive or zero real number `C` bound such that the norm of `f` at any point `x` in `α` is less than or equal to `C`, then the norm of the bounded continuous function constructed from `f` using `BoundedContinuousFunction.ofNormedAddCommGroup` function is also less than or equal to `C`.

In other words, it ensures that the bounding property `C` of the original function `f` is maintained even after converting the function into a bounded continuous function.

For any continuous function from a topological space to a semi-normed additive commutative group with a real number bound, the norm of the bounded continuous function constructed from it is also bounded by the original bound.


MeasureTheory.StronglyMeasurable.nnnorm

theorem MeasureTheory.StronglyMeasurable.nnnorm :
    ∀ {α : Type u_1} {x : MeasurableSpace α} {β : Type u_5} [inst : SeminormedAddCommGroup β] {f : α → β},
      MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => ‖f x‖₊ :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.nnnorm` states that for any measurable space `α`, seminormed add commutative group `β`, and function `f` from `α` to `β`, if `f` is strongly measurable (i.e., it is the limit of simple functions), then the function that maps each element of `α` to the non-negative norm of `f` applied to that element is also strongly measurable. In simpler terms, taking the non-negative norm of a strongly measurable function results in another strongly measurable function.

Given a measurable space `α`, a seminormed add commutative group `β`, and a strongly measurable function `f` from `α` to `β`, the function mapping each `x ∈ α` to the non-negative norm `||f(x)||` is also strongly measurable.


theorem Ordinal.one_lt_omega : 1 < Ordinal.omega := by sorry

This theorem states that the ordinal number one is less than omega. In other words, the ordinal corresponding to the number one is smaller than the first infinite ordinal, denoted as omega. Omega is defined as the order type of the set of natural numbers, which means it corresponds to the concept of "countable infinity" in set theory.

One is a strictly smaller ordinal than omega.


theorem TopologicalSpace.IsTopologicalBasis.continuous_iff :
    ∀ {α : Type u} [t : TopologicalSpace α] {β : Type u_2} [inst : TopologicalSpace β] {B : Set (Set β)},
      TopologicalSpace.IsTopologicalBasis B → ∀ {f : α → β}, Continuous f ↔ ∀ s ∈ B, IsOpen (f ⁻¹' s) :=
  by sorry

The theorem `TopologicalSpace.IsTopologicalBasis.continuous_iff` states that for any types `α` and `β`, where `TopologicalSpace α` and `TopologicalSpace β` are instances, given a set `B` which is a topological basis of `β`, a function `f` from `α` to `β` is continuous if and only if for every set `s` in the basis `B`, the inverse image of `s` under `f` is an open set in `α`. In other words, a function between two topological spaces is continuous if it preserves the openness property of the basis sets of the target space.

A function between two topological spaces is continuous if and only if the inverse image of every open set in the basis of the target space is an open set in the domain.


theorem Multiset.ndinsert_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s → Multiset.ndinsert a s = s := by sorry

The theorem `Multiset.ndinsert_of_mem` states that for any type `α` that has decidable equality, and for any element `a` of type `α` and any multiset `s` of type `α`, if `a` is an element of `s`, then inserting `a` into `s` (without respecting multiplicities) results in the same multiset `s`. In other words, if `a` is already in `s`, inserting `a` into `s` again will not change `s`.

If `α` has decidable equality and `a` is an element of multiset `s` of type `α`, then `Multiset.ndinsert a s = s`.


Irrational.inv

theorem Irrational.inv : ∀ {x : ℝ}, Irrational x → Irrational x⁻¹ := by sorry

The theorem `Irrational.inv` states that for any real number `x`, if `x` is irrational, then its multiplicative inverse (or reciprocal) `x⁻¹` is also irrational. In other words, the irrationality is preserved under the operation of taking reciprocals.

If a real number is irrational, then its multiplicative inverse is also irrational.


theorem MeasureTheory.MeasurePreserving.set_lintegral_comp_emb :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {mb : MeasurableSpace β}
      {ν : MeasureTheory.Measure β} {g : α → β},
      MeasureTheory.MeasurePreserving g μ ν →
        MeasurableEmbedding g →
          ∀ (f : β → ENNReal) (s : Set α), ∫⁻ (a : α) in s, f (g a) ∂μ = ∫⁻ (b : β) in g '' s, f b ∂ν :=
  by sorry

This theorem states that for any types `α` and `β`, measurable spaces `m` and `mb`, measures `μ` and `ν` on these measurable spaces, and a function `g` from `α` to `β`, if `g` preserves the measure from `μ` to `ν` and `g` is a measurable embedding, then for any function `f` from `β` to the extended nonnegative real numbers and any set `s` of type `α`, the integral over `s` in `μ` of `f` composed with `g` is equal to the integral over the image of `s` under `g` in `ν` of `f`.

In simpler terms, if `g` is a measurable function that preserves measure, then the measure of a transformed set under a function `f` in the original measure is the same as the measure of the set in the transformed measure. This property is central to the theory of measure preserving transformations, which are key in areas such as ergodic theory and dynamical systems.

If `g: α -> β` is a measurable embedding preserving measures `μ` and `ν` on measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)`, then for any `f: β -> [0, ∞]` and `s ∈ Σα`, we have `∫sμ = ∫g[s]ν. f`.


SetTheory.PGame.Numeric.mk

theorem SetTheory.PGame.Numeric.mk :
    ∀ {x : SetTheory.PGame},
      (∀ (i : SetTheory.PGame.LeftMoves x) (j : SetTheory.PGame.RightMoves x),
          SetTheory.PGame.moveLeft x i < SetTheory.PGame.moveRight x j) →
        (∀ (i : SetTheory.PGame.LeftMoves x), SetTheory.PGame.Numeric (SetTheory.PGame.moveLeft x i)) →
          (∀ (j : SetTheory.PGame.RightMoves x), SetTheory.PGame.Numeric (SetTheory.PGame.moveRight x j)) →
            SetTheory.PGame.Numeric x :=
  by sorry

The theorem `SetTheory.PGame.Numeric.mk` states that, for any pre-game `x`, if every move by the Left player results in a game that is less than any resulting game from a move by the Right player, and if after every move by either the Left or Right player the resulting game is numeric, then the original pre-game `x` is also numeric. In other words, a pre-game is considered numeric if it satisfies two conditions: First, for any allowable move of the Left and Right players, the game resulting from the Left's move is always less than the one resulting from the Right's move. Second, every game resulting from an allowable move of either player is also numeric.

If every move by the Left player in a pre-game results in a numeric game that is strictly less than the numeric game resulting from any move by the Right player, then the pre-game is numeric.


theorem Bornology.cobounded_eq_bot :
    ∀ (α : Type u_2) [inst : Bornology α] [inst_1 : BoundedSpace α], Bornology.cobounded α = ⊥ := by sorry

This theorem states that for any type `α` equipped with a Bornology structure and assumed to be a Bounded Space, the filter of cobounded sets in this Bornology is the bottom filter. In other words, in a bounded space, there are no cobounded sets in the corresponding Bornology, or the concept of cobounded sets becomes trivial.

In a bounded space equipped with a Bornology structure, the filter of cobounded sets is the bottom filter.


theorem Ordinal.nadd_def :
    ∀ (a b : Ordinal.{u}),
      Ordinal.nadd a b =
        max (Ordinal.blsub a fun a' x => Ordinal.nadd a' b) (Ordinal.blsub b fun b' x => Ordinal.nadd a b') :=
  by sorry

The theorem `Ordinal.nadd_def` states that for any two ordinals `a` and `b`, the natural addition of `a` and `b` (denoted as `Ordinal.nadd a b`), also known as the Hessenberg sum, is equal to the maximum of two values. The first value is the least strict upper bound of the family of ordinals obtained by performing natural addition of `b` and each ordinal less than `a`. The second value is similarly defined, but with the roles of `a` and `b` swapped, i.e., it is the least strict upper bound of the family of ordinals obtained by performing natural addition of `a` and each ordinal less than `b`.

The theorem `Ordinal.nadd_def` asserts that for all ordinals `a` and `b`, `Ordinal.nadd a b` equals the least upper bound of the set `{a + b | x < a} ∪ {a + b | x < b}`.


theorem Cardinal.mk_denumerable : ∀ (α : Type u) [inst : Denumerable α], Cardinal.mk α = Cardinal.aleph0 := by sorry

The theorem `Cardinal.mk_denumerable` states that for any type `α` which is denumerable (i.e., it can be put into a one-to-one correspondence with the set of natural numbers), the cardinality (or size) of `α` is equal to `ℵ₀`, the smallest infinite cardinal number. In other words, if a type can be listed in a sequence like the natural numbers, then it has the same size as the set of natural numbers.

If a type `α` is denumerable, then its cardinality equals that of the natural numbers, i.e., `α` is equinumerous with `ℕ` and therefore has cardinality `ℵ₀`.


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

This theorem states that for any complex number `x`, natural number `n`, and complex number `y`, the power of `x` raised to the product of `n` and `y` is equal to the power of `x` raised to `y` all raised to the power of `n`. In mathematical terms, it's stating that `x^(n*y) = (x^y)^n` for complex numbers `x` and `y`, and natural number `n`.

For complex numbers `x` and natural number `n`, `x^(n*y) = (x^y)^n`.


theorem Filter.tendsto_atTop_atTop_of_monotone :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → (∀ (b : β), ∃ a, b ≤ f a) → Filter.Tendsto f Filter.atTop Filter.atTop :=
  by sorry

This theorem, `Filter.tendsto_atTop_atTop_of_monotone`, states that for all types `α` and `β` with preorders, if a function `f` from `α` to `β` is monotone (that is, for every pair of elements in `α` where the first is less than or equal to the second, the function value of the first element is less than or equal to the function value of the second) and for every element in `β`, there exists an element in `α` such that the function value of the `α` element is greater than or equal to the `β` element, then the function `f` tends to infinity with respect to the filter on `α` that represents the limit going to infinity (this is given by `Filter.atTop`), and similarly, the output of the function `f` also tends to infinity with respect to the filter on `β` that represents the limit going to infinity (also given by `Filter.atTop`). In other words, as the input of the function `f` approaches infinity, the output of the function `f` also approaches infinity.

If `f` is a monotone function from `α` to `β` such that for every `y` in `β`, there exists `x` in `α` with `f x ≥ y`, then `f` is tendstoAtTop (`Filter.atTop`) on `α` and its image is tendstoAtTop on `β`.


/-- Uniformizers exist in a DVR.  -/
theorem DiscreteValuationRing.exists_prime :
    ∀ (R : Type u) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DiscreteValuationRing R], ∃ ϖ, Prime ϖ := by
  sorry

This theorem states that for every Discrete Valuation Ring (DVR) `R`, which is a commutative ring and an integral domain, there exists an element `ϖ` that is prime. In the context of DVRs, a prime element is one that is not zero, not a unit, and for any two elements `a` and `b` in the ring, if the prime element divides the product of `a` and `b`, then it must divide either `a` or `b`.

Every Discrete Valuation Ring (DVR) is a principal ideal domain, i.e., there exists a prime element `ϖ` such that every ideal in `R` is principal and generated by `ϖ`.


theorem Subgroup.eq_top_iff' : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H = ⊤ ↔ ∀ (x : G), x ∈ H := by sorry

This theorem states that for any subgroup `H` of a group `G`, `H` is equal to the top element (i.e., the whole group `G`) if and only if every element `x` in `G` is also in `H`. In other words, a subgroup is identical to the whole group if all elements of the group are contained in the subgroup.

A subgroup of a group is equal to the whole group if and only if it contains every element of the group.


theorem Int.fdiv_eq_ediv : ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → Int.fdiv a b = a / b := by sorry

This theorem states that for any integer `a` and any non-negative integer `b`, the floored division of `a` by `b` (denoted as `Int.fdiv a b` in Lean 4) is equal to the Euclidean division of `a` by `b` (denoted as `a / b` in Lean 4). Basically, this is saying that when you are dividing an integer by a non-negative integer, the concept of floored division aligns with that of Euclidean division.

For any integer `a` and non-negative integer `b`, `Int.fdiv a b` equals the quotient and remainder of the Euclidean division of `a` by `b`.


theorem Stream'.map_cons :
    ∀ {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream' α),
      Stream'.map f (Stream'.cons a s) = Stream'.cons (f a) (Stream'.map f s) :=
  by sorry

The theorem `Stream'.map_cons` states that for any types `α` and `β`, any function `f` from `α` to `β`, any element `a` of type `α`, and any infinite sequence `s` (or stream) of elements of type `α`, the operation of mapping the function `f` over the stream that results from prepending `a` to `s` is the same as the operation of prepending `f(a)` to the stream that results from mapping `f` over `s`. In other words, it establishes that the `map` operation commutes with the `cons` operation, which is a key property in functional programming and stream processing.

For any types `α` and `β`, functions `f` from `α` to `β`, elements `a` of type `α`, and infinite streams `s` over `α`, the following equality holds: `map f (cons a s) = cons (f a) (map f s)`.


theorem Matrix.transpose_submatrix :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (A : Matrix m n α) (r_reindex : l → m)
      (c_reindex : o → n),
      Matrix.transpose (Matrix.submatrix A r_reindex c_reindex) =
        Matrix.submatrix (Matrix.transpose A) c_reindex r_reindex :=
  by sorry

This theorem states that for any Matrix `A` with entries of type `α` and row indices of type `m` and column indices `n`, and any reindexing functions `r_reindex` and `c_reindex` that reindex the rows and columns respectively, the transpose of the submatrix of `A` obtained by applying `r_reindex` and `c_reindex` is equal to the submatrix of the transpose of `A` obtained by applying `c_reindex` and `r_reindex`. In other words, transposing a submatrix is equivalent to taking a submatrix of the original matrix's transpose, provided the indexing functions are swapped.

For any matrix `A` of type `α m n`, and reindexing functions `r_reindex` and `c_reindex`, the submatrix of `A.transpose` obtained by applying `c_reindex` and `r_reindex` is equal to the transpose of the submatrix of `A` obtained by applying `r_reindex` and `c_reindex`.


theorem continuousOn_open_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
      IsOpen s → (ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → IsOpen (s ∩ f ⁻¹' t)) :=
  by sorry

The theorem `continuousOn_open_iff` states that for any two types `α` and `β` that have topological spaces, a function `f` from `α` to `β`, and a set `s` of type `α`, if `s` is an open set, then the function `f` is continuous on `s` if and only if for any open set `t` of type `β`, the preimage of `t` under `f` intersected with `s` is also an open set. In other words, within the context of topology, a function is continuous on an open set if every open set's preimage is also open after intersecting with the original set.

A function between topological spaces is continuous on an open set if and only if the preimage of any open set under the function intersecting the original set is also open.


theorem Multiset.foldr_cons :
    ∀ {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (a : α) (s : Multiset α),
      Multiset.foldr f H b (a ::ₘ s) = f a (Multiset.foldr f H b s) :=
  by sorry

The theorem `Multiset.foldr_cons` states that for any types α and β, if a function `f` from α to β is left-commutative, and for any element `b` of type β, any element `a` of type α, and any multiset `s` of type α, the result of folding `f` over the multiset obtained by consing `a` onto `s` (written as `a ::ₘ s` in Lean) with base value `b` is the same as applying `f` to `a` and the result of folding `f` over `s` with base value `b`. In other words, folding over a multiset with a left-commutative function behaves as expected when an element is added to the front of the multiset.

For any left-commutative function `f` from type `α` to type `β` and any multiset `s` of type `α`, the expression `f a (Multiset.foldr f b s)` equals `Multiset.foldr f b (a ::ₘ s)`, where `a` is an element of type `α` and `b` is a base value of type `β`.


/-- In a finite-dimensional vector space, the dimensions of a submodule and of the corresponding
quotient add up to the dimension of the space.  -/
theorem Submodule.finrank_quotient_add_finrank :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      [inst_3 : FiniteDimensional K V] (s : Submodule K V),
      FiniteDimensional.finrank K (V ⧸ s) + FiniteDimensional.finrank K ↥s = FiniteDimensional.finrank K V :=
  by sorry

The theorem `Submodule.finrank_quotient_add_finrank` states that for any given division ring `K` and a finite-dimensional vector space `V` over `K`, with a submodule `s` of `V`, the sum of the dimensions (as natural numbers) of the quotient space `V/s` and the submodule `s` is equal to the dimension of the vector space `V`. This theorem is an analogue in the language of modules and division rings of the rank-nullity theorem for linear maps in linear algebra.

The sum of the dimensions of a finite-dimensional vector space and its submodule equals the dimension of the vector space.


/-- A morphism in `SimplexCategory` is a monomorphism precisely when it is an injective function
 -/
theorem SimplexCategory.mono_iff_injective :
    ∀ {n m : SimplexCategory} {f : n ⟶ m},
      CategoryTheory.Mono f ↔ Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f) :=
  by sorry

This theorem states that a morphism in the 'SimplexCategory' is a monomorphism (a morphism that is left-cancellable) if and only if it is an injective function (a function where distinct inputs always produce distinct outputs). Here, 'SimplexCategory' is a category whose objects are natural numbers and morphisms are monotone functions between finite ordinal sets. The morphism is represented as 'n ⟶ m', and it is converted to a monotone map using the 'SimplexCategory.Hom.toOrderHom' function. The theorem asserts the equivalence of being a monomorphism and being injective in this context.

A morphism in the SimplexCategory is a monomorphism if and only if it is an injective function. (Or, equivalently, a morphism n ⟶ m in SimplexCategory is a monomorphism if and only if the corresponding monotone function between finite ordinal sets is an injection.)


theorem AkraBazziRecurrence.tendsto_atTop_r :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α] {T : ℕ → ℝ} {g : ℝ → ℝ} {a b : α → ℝ} {r : α → ℕ → ℕ},
      AkraBazziRecurrence T g a b r → ∀ (i : α), Filter.Tendsto (r i) Filter.atTop Filter.atTop :=
  by sorry

This theorem, named `AkraBazziRecurrence.tendsto_atTop_r`, states that for any type `α` that is a finite nonempty set, and functions `T : ℕ → ℝ`, `g : ℝ → ℝ`, `a : α → ℝ`, `b : α → ℝ`, and `r : α → ℕ → ℕ`, if the Akra-Bazzi Recurrence relation holds for `T`, `g`, `a`, `b`, and `r`, then for every `i` in `α`, the function `r i` tends to infinity as its argument tends to infinity. In other words, for every neighborhood of infinity in the codomain, there is a neighborhood of infinity in the domain such that the image of the latter neighborhood under `r i` is contained in the former neighborhood.

For any finite nonempty set `α`, functions `T : ℕ → ℝ`, `g : ℝ → ℝ`, `a : α → ℝ`, `b : α → ℝ`, and `r : α → ℕ → ℕ` satisfying the Akra-Bazzi Recurrence relation, for all `i` in `α`, the sequence `r i x` goes to infinity as `x` goes to infinity.


theorem MulEquiv.toMonoidHom_injective :
    ∀ {M : Type u_6} {N : Type u_7} [inst : MulOneClass M] [inst_1 : MulOneClass N],
      Function.Injective MulEquiv.toMonoidHom :=
  by sorry

The theorem `MulEquiv.toMonoidHom_injective` states that for any two types `M` and `N` that have the structures of multiplicative monoids (indicated by the typeclass `MulOneClass`), the function `MulEquiv.toMonoidHom` is injective. In other words, if two multiplicative equivalences between `M` and `N` are converted into multiplication-preserving functions (monoid homomorphisms) and these two resulting functions are found to be the same, then the original multiplicative equivalences must have been the same as well.

If `f` and `g` are multiplicative equivalences between multiplicative monoids `M` and `N`, then `MulEquiv.toMonoidHom f` and `MulEquiv.toMonoidHom g` are equal if and only if `f` and `g` are equal.


theorem AlgebraicGeometry.quasiSeparated_eq_diagonal_is_quasiCompact :
    @AlgebraicGeometry.QuasiSeparated = CategoryTheory.MorphismProperty.diagonal @AlgebraicGeometry.QuasiCompact := by
  sorry

The theorem `AlgebraicGeometry.quasiSeparated_eq_diagonal_is_quasiCompact` states that a scheme in algebraic geometry is quasi-separated if and only if the property of being quasi-compact is preserved under taking the diagonal morphism in the category theory sense. Here, the diagonal morphism refers to the morphism induced by the pullback of a given morphism with itself.

A scheme is quasi-separated if and only if the diagonal morphism is quasi-compact in the category of schemes.


theorem MeasureTheory.VectorMeasure.MutuallySingular.symm :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_4} {N : Type u_5} [inst : AddCommMonoid M]
      [inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid N] [inst_3 : TopologicalSpace N]
      {v : MeasureTheory.VectorMeasure α M} {w : MeasureTheory.VectorMeasure α N},
      MeasureTheory.VectorMeasure.MutuallySingular v w → MeasureTheory.VectorMeasure.MutuallySingular w v :=
  by sorry

This theorem states that for any type `α` with a `MeasurableSpace` structure, types `M` and `N` that are additive commutative monoids and topological spaces, and any `v` and `w` which are vector measures on `α` with values in `M` and `N` respectively, if `v` and `w` are mutually singular, then `w` and `v` are also mutually singular. Mutually singular, in measure theory, means that the measures are 'completely disjoint': they do not assign positive measure to any of the same sets. The theorem says this relationship is symmetric: if `v` is mutually singular with respect to `w`, then `w` is also mutually singular with respect to `v`.

For any measure spaces `(α, Σ, μ)` and `(α, Σ, ν)`, if `μ` and `ν` are mutually singular measure theories (i.e., there exist disjoint sets `A, B ∈ Σ` such that `μ(A) = ν(B) = 0` and `μ(C) = 0 ↔ ν(C∖B) = 0` for all `C ∈ Σ`), then `ν` is mutually singular with respect to `μ`.


theorem Mathlib.Data.Int.Cast.Lemmas._auxLemma.8 :
    ∀ {α : Type u_3} [inst : OrderedRing α] [inst_1 : Nontrivial α] {m n : ℤ}, (↑m < ↑n) = (m < n) := by sorry

This theorem, from the Mathlib library in Lean, states that for any ordered ring `α` that is nontrivial (i.e., it contains at least two distinct elements), the inequality relation between two integers `m` and `n` remains unchanged when they are cast to elements of the ordered ring `α`. More specifically, if `m` is less than `n` in the integers, then the cast of `m` to `α` is less than the cast of `n` to `α`, and vice versa.

For any nontrivial ordered ring `α`, if `m < n` in the integers, then `α(m) < α(n)`.


/-- The norm of the image of `m : M` in the quotient by `S` is zero if and only if `m` belongs
to the closure of `S`.  -/
theorem quotient_norm_eq_zero_iff :
    ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M) (m : M),
      ‖(QuotientAddGroup.mk' S) m‖ = 0 ↔ m ∈ closure ↑S :=
  by sorry

Here is the translation in natural language:

The theorem `quotient_norm_eq_zero_iff` states that for any type `M` that is a seminormed additive commutative group, any additive subgroup `S` of `M`, and any element `m` from `M`, the norm of the image of `m` under the additive group homomorphism from `M` to the quotient group `M/S` is zero if and only if `m` belongs to the closure of `S`. In other words, the norm of the equivalence class of `m` in the quotient group `M/S` is zero precisely when `m` is in the smallest closed set containing `S`.

For any seminormed additive commutative group (M, ||.||), subgroup S of M, and element m in M, the norm ||m|| = 0 in M/S if and only if m is in the closure of S.


theorem inv_le_inv' : ∀ {α : Type u} [inst : OrderedCommGroup α] {a b : α}, a ≤ b → b⁻¹ ≤ a⁻¹ := by sorry

This theorem states that for any ordered commutative group `α` and any two elements `a` and `b` of `α`, if `a` is less than or equal to `b`, then the inverse of `b` is less than or equal to the inverse of `a`. In other words, given the inequality `a ≤ b` in the group, we can deduce the inequality `b⁻¹ ≤ a⁻¹`.

For any ordered commutative group `α`, if `a ≤ b`, then `b⁻¹ ≤ a⁻¹`.


theorem Set.piecewise_op :
    ∀ {α : Type u_1} {δ : α → Sort u_6} (s : Set α) (f g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)]
      {δ' : α → Sort u_7} (h : (i : α) → δ i → δ' i),
      (Set.piecewise s (fun x => h x (f x)) fun x => h x (g x)) = fun x => h x (Set.piecewise s f g x) :=
  by sorry

The theorem `Set.piecewise_op` states that for any type `α`, any set `s` of type `α`, any two functions `f` and `g` from `α` to another type `δ` (which can itself depend on `α`), and any function `h` from `α` and `δ` to yet another type `δ'` (which can also depend on `α`), applying `h` to the function `Set.piecewise s f g` is the same as applying `Set.piecewise s` to `h` composed with `f` on `s` and `h` composed with `g` on the complement of `s`. In other words, we can "pull out" the function `h` from the piecewise defined function. This assumes that for each element in `α`, we can decide whether it is in `s` or not.

For any set `s` in type `α`, functions `f` and `g` from `α` to type `δ`, and function `h` from `α × δ` to type `δ'`, we have `h (Set.piecewise s f g) = Set.piecewise s (λ x, h (x, f x)) (λ x, h (x, g x))`.


theorem FixedPoints.minpoly.proof_1 :
    ∀ (G : Type u_2) [inst : Group G] (F : Type u_1) [inst_1 : Field F] [inst_2 : MulSemiringAction G F]
      [inst_3 : Fintype G] (x x_1 : F), x_1 ∈ ↑(Polynomial.frange (prodXSubSMul G F x)) → ∀ (g : G), g • x_1 = x_1 :=
  by sorry

The theorem `FixedPoints.minpoly.proof_1` states that for any group `G`, field `F`, and `x` and `x_1` in `F`, if `x_1` is in the finset of nonzero coefficients of the polynomial obtained by taking the product of `(X - g • x)` over all distinct `g • x`, then `x_1` is a fixed point under the action of any element `g` of the group `G`. That is, for any `g` in `G`, the scalar multiplication of `g` and `x_1` is `x_1` itself. Here, `G` is endowed with a multiplicative semiring action on `F`, and the operation `g • x_1` denotes the scalar multiplication of `g` and `x_1` under this action.

If `x_1` is in the set of nonzero coefficients of the minimal polynomial of `x` over the group action of `G` in the ring `F`, then `x_1` is a fixed point under the action of any `g` in `G`, i.e., `g • x_1 = x_1` for all `g` in `G`.


theorem sub_sub_self : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a - (a - b) = b := by sorry

This theorem states that for any type `G` that is an additive commutative group, and for any elements `a` and `b` of type `G`, the result of subtracting `a` from the difference of `a` and `b` is equal to `b`. Essentially, it is expressing the algebraic identity `a - (a - b) = b`. This holds true in any additive commutative group.

In any additive commutative group, for all elements `a` and `b`, `a - (a - b) = b`.


theorem Codisjoint.himp_eq_right :
    ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, Codisjoint a b → b ⇨ a = a := by sorry

This theorem states that for any Generalized Heyting Algebra, if two elements 'a' and 'b' are codisjoint, then the Heyting implication of 'b' by 'a', denoted as 'b ⇨ a', is equal to 'a'. In the context of Heyting algebras, 'b ⇨ a' is the largest element 'c' such that 'b ∧ c ≤ a'. Here, 'codisjoint' means that for any element 'x' in the algebra, if 'a' and 'b' are less than or equal to 'x', then the top element of the algebra is less than or equal to 'x'.

In a Generalized Heyting Algebra, if elements 'a' and 'b' are codisjoint, then 'b ⇨ a' equals 'a'. Alternatively, the largest element 'c' satisfying 'b ∧ c ≤ a' is 'a' for codisjoint 'a' and 'b'.


/-- Transport a `HasColimitsOfShape` instance across an equivalence.  -/
theorem CategoryTheory.Adjunction.hasColimitsOfShape_of_equivalence :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [inst_2 : CategoryTheory.Category.{v, u} J]
      (E : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.IsEquivalence E]
      [inst_4 : CategoryTheory.Limits.HasColimitsOfShape J D], CategoryTheory.Limits.HasColimitsOfShape J C :=
  by sorry

This theorem states that given any category `C`, category `D`, and an index category `J`, if there is a functor `E` from `C` to `D` that is an equivalence of categories, and if `D` has colimits of shape `J`, then `C` also has colimits of shape `J`. In other words, a `HasColimitsOfShape` instance can be transported across an equivalence of categories.

If `C` and `D` are equivalent categories and `D` has colimits of shape `J`, then `C` also has colimits of shape `J`.


theorem Set.uIcc_subset_uIcc :
    ∀ {α : Type u_1} [inst : Lattice α] {a₁ a₂ b₁ b₂ : α},
      a₁ ∈ Set.uIcc a₂ b₂ → b₁ ∈ Set.uIcc a₂ b₂ → Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ :=
  by sorry

The theorem `Set.uIcc_subset_uIcc` states that for any lattice type `α`, and any four elements `a₁`, `a₂`, `b₁`, and `b₂` of this type, if `a₁` is within the set of elements lying between `a₂` and `b₂` (inclusive) and `b₁` is also within this set, then the set of elements between `a₁` and `b₁` (inclusive) is a subset of the set of elements between `a₂` and `b₂` (inclusive). In other words, if `a₁` and `b₁` are both in the bounding box defined by `a₂` and `b₂`, then the bounding box defined by `a₁` and `b₁` is contained within the bounding box defined by `a₂` and `b₂`.

For any lattice type `α` and elements `a₁`, `a₂`, `b₁`, and `b₂` in `α`, if `a₁` and `b₁` are within the interval `[a₂, b₂]`, then `[a₁, b₁]` is a subset of `[a₂, b₂]`.


theorem NNReal.coe_sInf : ∀ (s : Set NNReal), ↑(sInf s) = sInf (NNReal.toReal '' s) := by sorry

This theorem states that for any set `s` of nonnegative real numbers (`NNReal`), the greatest lower bound (infimum) of `s` when coerced into the set of real numbers is equal to the greatest lower bound of the image of `s` under the coercion function `NNReal.toReal`. In other words, taking the infimum of a set of nonnegative real numbers and then mapping it to the real numbers is the same as first mapping the set to the real numbers and then taking the infimum.

For any set `s` of nonnegative real numbers, the infimum of `s` equals the infimum of `NNReal.toReal s`.


theorem Multiset.map_pmap :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {p : α → Prop} (g : β → γ) (f : (a : α) → p a → β) (s : Multiset α)
      (H : ∀ a ∈ s, p a), Multiset.map g (Multiset.pmap f s H) = Multiset.pmap (fun a h => g (f a h)) s H :=
  by sorry

The theorem `Multiset.map_pmap` states that for any types `α`, `β`, and `γ`, and any property `p` from `α` to `Prop`, if we have a function `g` from `β` to `γ` and a partial function `f` from `α` where `p` applies to `β`, then for any multiset `s` of type `α` where `p` holds for all members of `s`, the map of `g` over the `pmap` of `f` over `s` (with respect to `p`) is equal to the `pmap` of the function that applies `g` after `f` over `s` (with respect to `p`). Essentially, this theorem establishes that the `map` and `pmap` operations on multisets commute under certain conditions.

For any types α, β, γ, property p from α to Prop, function g from β to γ, and partial function f from α to β where p applies to the image of f, if s is a multiset of α where p holds for all members, then the map of g over the pmap of f on s equals the pmap of the function composing f and g on s.


theorem segment_eq_uIcc : ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] (x y : 𝕜), segment 𝕜 x y = Set.uIcc x y := by
  sorry

The theorem `segment_eq_uIcc` states that for all linear-ordered fields, represented by the symbol 𝕜, and any two elements x and y from this field, the segment between x and y is equivalent to the set of elements lying between x and y, with x and y included. In other words, the set of all combinations of x and y where the coefficients are non-negative and sum to 1 (the definition of a segment) is equal to the set of all elements between the infimum and supremum of x and y (in this case, just x and y themselves because 𝕜 is a linear-ordered field).

For any linear-ordered field 𝕜, the segment {x + s * y | x, y ∈ 𝕜, s ∈ ℝ\_+, s * (1 - s) = 1} is equal to the interval [x, y] = {z ∈ 𝕜 | x ≤ z ≤ y}.


theorem Multiset.filter_le_filter :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Multiset α},
      s ≤ t → Multiset.filter p s ≤ Multiset.filter p t :=
  by sorry

The theorem `Multiset.filter_le_filter` states that for any type `α`, any decidable predicate `p` on `α`, and any two multisets `s` and `t` of type `α`, if `s` is a sub-multiset of `t` (that is, `s` is less than or equal to `t`), then the multiset obtained by filtering `s` with predicate `p` is also a sub-multiset of the multiset obtained by filtering `t` with the same predicate. This means that applying a filter to a subset of a multiset will yield a result that is a subset of the result of applying the same filter to the entire multiset.

If `s` is a sub-multiset of `t` and `p` is a decidable predicate on type `α`, then `Multiset.filter p s` is a sub-multiset of `Multiset.filter p t`.


theorem Associates.prod_mk :
    ∀ {α : Type u_1} [inst : CommMonoid α] {p : Multiset α},
      Multiset.prod (Multiset.map Associates.mk p) = Associates.mk (Multiset.prod p) :=
  by sorry

The theorem `Associates.prod_mk` states that for any commutative monoid `α` and any multiset `p` of type `α`, the product of the multiset obtained by mapping the canonical quotient map `Associates.mk` over `p` is equal to the `Associates.mk` of the product of `p`. In other words, it asserts that the operation of taking the product of a multiset commutes with the operation of mapping `Associates.mk` over the elements of the multiset.

For any commutative monoid `α` and multiset `p` of type `α`, the product of the multiset `p` mapped through `Associates.mk` is equal to `Associates.mk` of the product of `p`.


theorem List.map_subset :
    ∀ {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (f : α → β), l₁ ⊆ l₂ → List.map f l₁ ⊆ List.map f l₂ := by sorry

The theorem `List.map_subset` states that for all types `α` and `β`, and for all lists `l₁` and `l₂` of type `α`, and a function `f` from `α` to `β`, if `l₁` is a subset of `l₂`, then the list obtained by mapping `f` over `l₁` is a subset of the list obtained by mapping `f` over `l₂`. In other words, if every element of list `l₁` is also in list `l₂`, then applying a function to each element of `l₁` will yield a list where each element is also in the list obtained by applying the same function to each element of `l₂`.

For all types `α` and `β`, if `l₁ ⊆ l₂` are lists of type `α` and `f : α → β`, then `List.map f l₁ ⊆ List.map f l₂`.


theorem Real.contDiff_cos : ∀ {n : ℕ∞}, ContDiff ℝ n Real.cos := by sorry

The theorem `Real.contDiff_cos` states that the cosine function, which maps real numbers to real numbers, is continuously differentiable for all natural number orders `n`, inclusive of infinity. Here, continuously differentiable means that the function's `n`-th derivative exists and is continuous. The type `ℕ∞` is used to denote the set of nonnegative integers, including infinity.

The cosine function is continuously differentiable for all natural number orders. That is, for all natural numbers `n` including infinity, the `n`-th derivative of `cos` exists and is a continuous function.


/-- **Alias** of `Classical.byCases`. -/
theorem Classical.by_cases : ∀ {p q : Prop}, (p → q) → (¬p → q) → q := by sorry

This theorem, also known as the `Classical.by_cases`, states that for any propositions `p` and `q`, if `q` follows from `p` and `q` also follows from the negation of `p` (`¬p`), then `q` must be true. In simple terms, if `q` is true whether `p` is true or false, then `q` is absolutely true. This is a variant of the principle of excluded middle in classical logic.

If `q` holds in both `p` and `¬p`, then `q` is a logical truth.


theorem Filter.EventuallyEq.fderivWithin_eq :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {f f₁ : E → F} {x : E} {s : Set E},
      f₁ =ᶠ[nhdsWithin x s] f → f₁ x = f x → fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x :=
  by sorry

This theorem states that for a nontrivially normed field `𝕜`, a normed additive commutative group `E` that is also a normed space over `𝕜`, another normed additive commutative group `F` that is also a normed space over `𝕜`, for any two functions `f` and `f₁` from `E` to `F`, any point `x` in `E`, and any set `s` of `E`, if `f₁` and `f` are eventually equal in the neighborhood within `s` of `x` and if `f₁` and `f` are equal at `x`, then the derivative of `f₁` within `s` at `x` is equal to the derivative of `f` within `s` at `x`. In other words, under these conditions, the local derivative of two functions that are eventually equal and equal at a given point is also equal at that point.

If `f` and `f₁` are two functions from a normed space `E` over a nontrivially normed field `𝕜` to another normed space `F` over `𝕜`, are equal at a point `x` in `E`, and are eventually equal in every neighborhood of `x` within a set `s` of `E`, then their derivatives at `x` are equal.


theorem AlternatingMap.map_perm :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N' : Type u_6}
      [inst_3 : AddCommGroup N'] [inst_4 : Module R N'] {ι : Type u_7} (g : M [⋀^ι]→ₗ[R] N') [inst_5 : DecidableEq ι]
      [inst_6 : Fintype ι] (v : ι → M) (σ : Equiv.Perm ι), g (v ∘ ⇑σ) = Equiv.Perm.sign σ • g v :=
  by sorry

The theorem `AlternatingMap.map_perm` states that for any semiring `R`, and for any modules `M` and `N'` over `R`, and any type `ι` with decidable equality and that is finite, given an alternating multilinear map `g : M [⋀^ι]→ₗ[R] N'`, a function `v : ι → M`, and a permutation `σ : Equiv.Perm ι`, the result of applying `g` to the composition of `v` and `σ` equals to the signature of `σ` times the result of applying `g` to `v`. In other words, permuting the arguments of an alternating multilinear map and scaling by the signature of the permutation does not change the result of the map.

For any semiring `R`, finite type `ι` with decidable equality, modules `M` and `N'` over `R`, and alternating multilinear map `g : M [⋀^ι] →ₗ[R] N'`, the application of `g` to the composition of a function `v : ι → M` and a permutation `σ : Equiv.Perm ι` equals the signature of `σ` times the application of `g` to `v`.


theorem measurable_add_unop : ∀ {α : Type u_2} [inst : MeasurableSpace α], Measurable AddOpposite.unop := by sorry

The theorem `measurable_add_unop` states that for any type `α` which has a `MeasurableSpace` structure (think of it as a space where we can talk about "measurable" sets), the function `AddOpposite.unop` is a measurable function. In other words, given any measurable set in `α`, the preimage of this set under the function `AddOpposite.unop` is also a measurable set. The function `AddOpposite.unop` itself is used to convert an element of the additive opposite type `αᵃᵒᵖ` to the original type `α`.

For any measurable space `α`, the function `AddOpposite.unop` from `α` to `α` is a measurable function.


theorem Nat.one_le_cast :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {n : ℕ}, 1 ≤ ↑n ↔ 1 ≤ n :=
  by sorry

This theorem states that for all types `α` which are instances of `AddMonoidWithOne`, `PartialOrder`, `CovariantClass` with respect to addition and less than or equal to relation, `ZeroLEOneClass` and `CharZero`, and for all natural numbers `n`, the statement "1 is less than or equal to the cast of `n` to `α`" is equivalent to the statement "1 is less than or equal to `n`". Hence, the comparison of 1 with a natural number `n` remains the same after `n` is cast to any type `α` satisfying the mentioned properties.

For all types `α` instancing AddMonoidWithOne, PartialOrder, CovariantClass for addition and <= relation, ZeroLEOneClass, and CharZero, and all natural numbers `n`, 1 <= n if and only if 1 <= (cast n to α).


theorem sdiff_sup_cancel : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, b ≤ a → a \ b ⊔ b = a :=
  by sorry

The theorem `sdiff_sup_cancel` states that for any type `α` that is a Generalized CoHeyting Algebra, and any two elements `a` and `b` of this type such that `b` is less than or equal to `a`, the supremum (or join operation) of the difference of `a` and `b` (denoted as `a \ b`) and `b` itself equals `a`. In other words, if you subtract `b` from `a` and then take the supremum of the result with `b`, you get back `a`. This resembles the property of canceling terms in real number arithmetic, but within the context of a generalized CoHeyting algebra.

For any Generalized CoHeyting Algebra type `α` and elements `a` and `b` with `b ≤ a`, the supremum of `a \ b` and `b` equals `a`.


CategoryTheory.MonoOver.w

theorem CategoryTheory.MonoOver.w :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X} (k : f ⟶ g),
      CategoryTheory.CategoryStruct.comp k.left (CategoryTheory.MonoOver.arrow g) = CategoryTheory.MonoOver.arrow f :=
  by sorry

The theorem `CategoryTheory.MonoOver.w` states that for any category `C`, and any object `X` in `C`, if `f` and `g` are monomorphisms over `X`, and if there exists a morphism `k` from `f` to `g`, then the composition of the left arrow of `k` with the underlying arrow of `g` is equal to the underlying arrow of `f`. This is essentially a commutativity condition in the context of monomorphisms in a category.

If `f` and `g` are monomorphisms in a category `C` over an object `X`, and there exists a morphism `k` from `f` to `g`, then the left arrow of `k` composes with the underlying arrow of `g` to equal the underlying arrow of `f`: `left k ∘ g = f`.


theorem PrimeSpectrum.vanishingIdeal_singleton :
    ∀ {R : Type u} [inst : CommSemiring R] (x : PrimeSpectrum R), PrimeSpectrum.vanishingIdeal {x} = x.asIdeal := by
  sorry

This theorem, named "PrimeSpectrum.vanishingIdeal_singleton", states that for any given type `R` which is a commutative semiring, and for any 'x' in the prime spectrum of `R`, the vanishing ideal of the set containing only 'x' is equal to the ideal generated by 'x'. In other words, the ideal of all elements in `R` that vanish on the singleton set `{x}` is just the ideal defined by `x` itself.

For any commutative semiring `R` and its prime spectrum element `x`, the vanishing ideal of the singleton set `{x}` equals the ideal generated by `x`.


theorem edist_le_pi_edist :
    ∀ {β : Type v} {π : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → EDist (π b)] (f g : (b : β) → π b) (b : β),
      edist (f b) (g b) ≤ edist f g :=
  by sorry

This theorem states that for any type `β` with a finite number of elements (`Fintype β`), and any function `π` from `β` to some other type `u_2`, given two functions `f` and `g` from `β` to `π b` and any element `b` of `β`, the extended distance (`edist`) between `f b` and `g b` is always less than or equal to the extended distance between `f` and `g`. Here, we assume that there is an extended distance (`EDist`) defined for each `b` in `β`. The extended distance is a generalization of distance that is valid for all pairs of points, including possibly infinite distances.

For any type `β` with a finite number of elements, and functions `f`, `g` : `β` -> `u_2`, and `π` : `β` -> `u_2`, and for any element `b` in `β`, the extended distance `edist (f b) (g b)` is less than or equal to `EDist f g`.


theorem MvPolynomial.map_id :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R),
      (MvPolynomial.map (RingHom.id R)) p = p :=
  by sorry

The theorem `MvPolynomial.map_id` states that for any commutative semiring `R` and any type `σ` (which serves as the index set of the variables), and any multivariate polynomial `p` over `R` with variables indexed by `σ`, the map of `p` across the identity ring homomorphism from `R` to itself results in the original polynomial `p` itself. In other words, applying the identity transformation to each coefficient of the multivariate polynomial does not change the polynomial.

For any commutative semiring R and multivariate polynomial p over R indexed by type σ, the application of the identity ring homomorphism from R to itself to the coefficients of p leaves p unchanged.


theorem Matroid.Base.encard_diff_comm :
    ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α},
      M.Base B₁ → M.Base B₂ → Set.encard (B₁ \ B₂) = Set.encard (B₂ \ B₁) :=
  by sorry

The theorem `Matroid.Base.encard_diff_comm` states that for any type `α`, any matroid `M` on `α`, and any two base sets `B₁` and `B₂` of the matroid, if `B₁` and `B₂` are both bases of the matroid, then the cardinality of the set difference `B₁ \ B₂` (elements in `B₁` but not in `B₂`) is equal to the cardinality of the set difference `B₂ \ B₁` (elements in `B₂` but not in `B₁`). In other words, the sizes of the unique elements in each base with respect to the other are the same.

For any matroid on a type `α`, if two bases have the same number of unique elements with respect to each other, then their set differences have equal cardinalities.


theorem RelEmbedding.coe_toEmbedding :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {f : r ↪r s}, ⇑f.toEmbedding = ⇑f := by sorry

This theorem states that for any two types `α` and `β`, and for any two relations `r` and `s` on `α` and `β` respectively, and for any relational embedding `f` from `r` to `s`, the function obtained by applying the `toEmbedding` method to `f` is equal to `f`. In other words, converting a relationally-embedded function to an embedding does not change its behavior.

For any relations $r$ on type $\alpha$, $s$ on type $\beta$, and relational embedding $f$ from $r$ to $s$, the function obtained by applying `toEmbedding` method to $f$ equals $f$.


AlgebraicGeometry.topIsAffineOpen

theorem AlgebraicGeometry.topIsAffineOpen :
    ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsAffine X], AlgebraicGeometry.IsAffineOpen ⊤ := by sorry

This theorem states that for any algebraic geometry scheme `X` that is affine, the entire topological space of `X` is an affine open subset. In other words, if `X` has the property of being affine, then the whole of `X` (represented by the top element `⊤` of the lattice of open subsets) is an affine open subscheme. This concept is fundamental in the theory of algebraic geometry, particularly in the study of schemes and their affine open subsets.

In algebraic geometry, the top element of the lattice of open subsets of an affine scheme is itself an affine open subscheme.


theorem Set.apply_rangeSplitting :
    ∀ {α : Type u} {β : Type v} (f : α → β) (x : ↑(Set.range f)), f (Set.rangeSplitting f x) = ↑x := by sorry

The theorem `Set.apply_rangeSplitting` states that for any function `f` from a type `α` to a type `β` and any `x` in the range of `f`, applying `f` to the preimage of `x` (obtained using the `Set.rangeSplitting` function on `f` and `x`) results in `x` itself. In other words, it guarantees that `Set.rangeSplitting` correctly identifies a preimage for each element in the range of the function `f`. This is a formal statement of the property that the function `f` reverses when applied to the output of `Set.rangeSplitting`.

For any function `f` from type `α` to type `β` and any `x` in the range of `f`, `f (Set.rangeSplitting f x) = x`.


theorem Pi.card_Icc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : Fintype ι] [inst_1 : DecidableEq ι]
      [inst_2 : (i : ι) → DecidableEq (α i)] [inst_3 : (i : ι) → PartialOrder (α i)]
      [inst_4 : (i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i),
      (Finset.Icc a b).card = Finset.prod Finset.univ fun i => (Finset.Icc (a i) (b i)).card :=
  by sorry

The theorem `Pi.card_Icc` states that for every finite type `ι`, and for every function `α` mapping `ι` to some type, given that `ι` has decidable equality, and for each `i` in `ι`, the `α i` has decidable equality and partial order and locally finite order, then for any two functions `a` and `b` from `ι` to `α`, the cardinality of the finite set `Finset.Icc a b` equals the product of the cardinalities of the finite sets `Finset.Icc (a i) (b i)` for all `i` in the universal finite set of type `Finset ι`.

In simpler terms, it says that the size of the finite interval (inclusive) between two functions is equal to the product of the sizes of the individual intervals (inclusive) for each element of the domain.

For every finite type `ι` and function `α : ι → Type`, if `ι` has decidable equality and for each `i` in `ι`, `α i` has decidable equality and partial order with locally finite order, then the cardinality of `Finset.Icc (α a) (α b)` equals the product of the cardinalities of `Finset.Icc (α i) (α i)` for all `i` in `ι`.


theorem Int.mul_ediv_cancel' : ∀ {a b : ℤ}, a ∣ b → a * (b / a) = b := by sorry

This theorem states that for any two integers 'a' and 'b', if 'a' divides 'b' then 'a' times the integer division of 'b' by 'a' equals 'b'. In other words, if you perform integer division of 'b' by 'a' and then multiply the result by 'a', you'll get 'b' back, assuming 'a' is a divisor of 'b'. This is a fundamental property of integer division.

If an integer a divides another integer b, then a * (b / a) = b.


theorem ENNReal.sub_lt_self : ∀ {a b : ENNReal}, a ≠ ⊤ → a ≠ 0 → b ≠ 0 → a - b < a := by sorry

This theorem states that for any two extended nonnegative real numbers 'a' and 'b', where 'a' is not infinite (denoted by ⊤) and both 'a' and 'b' are not zero, the difference of 'a' and 'b' is less than 'a'. In other words, subtracting a positive value from an extended nonnegative real number (that is not infinite) always results in a lesser value.

For any extended nonnegative real numbers 'a' and 'b' with 'a' finite and 'b' nonzero, we have a < a + b.


MeasureTheory.AEStronglyMeasurable.neg

theorem MeasureTheory.AEStronglyMeasurable.neg :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : Neg β] [inst_2 : ContinuousNeg β],
      MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.AEStronglyMeasurable (-f) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.neg` states that for any given type `α`, type `β`, a measurable space `m` on `α`, a measure `μ` on that measurable space, a function `f` from `α` to `β`, and given that `β` is a topological space that supports negation operation and the negation operation is continuous, if the function `f` is almost everywhere strongly measurable with respect to measure `μ`, then the negative of function `f` (denoted as `-f`), is also almost everywhere strongly measurable with respect to the same measure `μ`. In other words, the property of being almost everywhere strongly measurable is preserved under the negation operation.

If `f : α → β` is almost everywhere strongly measurable with respect to measure `μ` on measurable space `(α, Σ)` and `β` is a topological space with a continuous negation operation, then `-f` is almost everywhere strongly measurable with respect to `μ`.


theorem PadicInt.norm_le_one : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (z : ℤ_[p]), ‖z‖ ≤ 1 := by sorry

This theorem states that for any natural number `p` that is prime (indicated by `Fact (Nat.Prime p)`), and any p-adic integer `z` (denoted `ℤ_[p]`), the norm of `z` (denoted `‖z‖`) is less than or equal to 1. In mathematical terms, it asserts that the p-adic norm of any p-adic integer is always less than or equal to 1.

For any prime natural number p and any p-adic integer z, the p-adic norm of z is bounded by 1.


theorem FiniteField.pow_card :
    ∀ {K : Type u_1} [inst : GroupWithZero K] [inst_1 : Fintype K] (a : K), a ^ Fintype.card K = a := by sorry

The theorem `FiniteField.pow_card` states that for any type `K` which has structures of a group with zero and a finite type, any element `a` of `K` raised to the power of the cardinality of `K` (that is, the number of distinct elements in `K`) equals to the element `a` itself. In mathematical terms, for any `a` in `K` we have the equation $a^{card(K)} = a$, where `card(K)` denotes the number of elements in `K`.

For any element `a` in a finite group `K`, we have `a^(|K|) = a`, where `|K|` denotes the number of elements in `K`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μa : MeasureTheory.Measure α}
      {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.Measure.QuasiMeasurePreserving f μa μb → AEMeasurable f μa :=
  by sorry

The theorem `MeasureTheory.Measure.QuasiMeasurePreserving.aemeasurable` states that for all types `α` and `β`, given a measurable space `m0` on `α`, a measurable space instance on `β`, measures `μa` on `α` and `μb` on `β`, and a function `f` from `α` to `β`, if `f` is quasi-measure-preserving with respect to measures `μa` and `μb`, then `f` is almost everywhere measurable with respect to measure `μa`. In other words, if a function preserves the measure of subsets "almost everywhere" (except possibly on a subset of measure zero), then this function is also almost everywhere measurable, meaning it coincides almost everywhere with a measurable function.

A quasi-measure-preserving function between measurable spaces is almost everywhere measurable.


theorem zsmul_neg : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℤ), n • -a = -(n • a) := by sorry

This theorem, `zsmul_neg`, states that for any given type `α` that is a subtraction monoid and any integer `n`, the scaled multiplication of `n` and the negation of `a` (`n • -a`) is equal to the negation of the scaled multiplication of `n` and `a` (`-(n • a)`). In other words, it expresses that the property of distributivity over multiplication and negation holds in the context of scaled multiplication and integers.

For any subtraction monoid type `α` and integer `n`, `n * (-a) = -(n * a)`.


theorem CategoryTheory.Subobject.ofMkLEMk_refl :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A₁ : C} (f : A₁ ⟶ B)
      [inst_1 : CategoryTheory.Mono f], CategoryTheory.Subobject.ofMkLEMk f f ⋯ = CategoryTheory.CategoryStruct.id A₁ :=
  by sorry

The theorem `CategoryTheory.Subobject.ofMkLEMk_refl` states that for any category `C`, and for any two objects `A₁` and `B` in this category, given a morphism `f` from `A₁` to `B` that is monic (i.e., a left-cancellative morphism), the morphism from the subobject represented by `f` to itself equals the identity morphism on `A₁`. In other words, this theorem asserts that for any monic morphism `f`, the defined morphism from the subobject of `f` to itself is the identity on the domain of `f`.

For any monic morphism $f : A\_1 \to B$ in a category $C$, the subobject of $f$ equals the identity subobject on $A\_1$. In other words, the morphism from the subobject of $f$ to itself is the identity on $A\_1$.


theorem FirstOrder.Language.Theory.model_iff :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      (T : FirstOrder.Language.Theory L), M ⊨ T ↔ ∀ φ ∈ T, M ⊨ φ :=
  by sorry

This theorem pertains to theories and models in the context of first-order logic. Specifically, it states that for any language `L` and any model `M` of that language (where `M` is a structure for `L`), a theory `T` (which is a set of sentences in `L`) is a model of `M` if and only if every sentence `φ` in the theory `T` is a model of `M`. In other words, a model `M` satisfies a theory `T` precisely when `M` satisfies every sentence in `T`.

A first-order theory T is a model of a structure M if and only if every sentence φ in T is satisfied in M.


theorem QuotientMap.isOpen_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      QuotientMap f → ∀ {s : Set Y}, IsOpen (f ⁻¹' s) ↔ IsOpen s :=
  by sorry

This theorem states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, given that `X` and `Y` are both topological spaces and `f` is a quotient map, then for any set `s` of `Y`, `s` is an open set if and only if its preimage under `f` is an open set. In simpler terms, a set in the target space `Y` of the quotient map is open if and only if all the elements in the source space `X` that map into this set form an open set.

Given two topological spaces X and Y and a quotient map f : X -> Y between them, the preimage under f of any open set in Y is open in X.


theorem FirstOrder.Language.Term.relabel_relabel :
    ∀ {L : FirstOrder.Language} {α : Type u'} {β : Type v'} {γ : Type u_3} (f : α → β) (g : β → γ)
      (t : FirstOrder.Language.Term L α),
      FirstOrder.Language.Term.relabel g (FirstOrder.Language.Term.relabel f t) =
        FirstOrder.Language.Term.relabel (g ∘ f) t :=
  by sorry

The theorem `FirstOrder.Language.Term.relabel_relabel` states that for any first-order language `L`, types `α`, `β`, and `γ`, a function `f` from `α` to `β`, a function `g` from `β` to `γ`, and a term `t` in the language `L` with variables of type `α`, the operation of relabeling (renaming) variables in `t` first with `f` and then with `g` is the same as relabeling the variables in `t` once with the composition of the functions `g ∘ f`. This is a property of the `relabel` function in the context of first-order logic terms, and relates to the idea that the renaming of variables should be consistent, regardless of whether it's done in stages or all at once.

For any first-order language L, functions f: α → β and g: β → γ, and term t in L with variables of type α, the operation of relabeling variables in t first with f and then with g equals relabeling variables in t once with the composition g ∘ f.