theorem MeasureTheory.measure_mul_right_null :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : MeasurableMul₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] {s : Set G} [inst_4 : MeasurableInv G]
      [inst_5 : MeasureTheory.Measure.IsMulLeftInvariant μ] (y : G), ↑↑μ ((fun x => x * y) ⁻¹' s) = 0 ↔ ↑↑μ s = 0 :=
  by sorry

This theorem, titled `MeasureTheory.measure_mul_right_null`, states that for any type `G` that has a measurable space structure, a group structure, a measurable multiplication, and a measurable inversion, given a sigma-finite measure `μ` on `G` that is left-invariant, for any element `y` in `G`, the measure of the preimage of a set `s` under the function that multiplies each element by `y` is zero if and only if the measure of the set `s` is zero. In essence, it says that under these conditions, multiplying each element of a set by a fixed element and measuring the resulting set yields zero if and only if the original set had measure zero.

For any sigma-finite, left-invariant measure `μ` on a measurable group `G` with measurable multiplication and inversion, the preimage of a null set under multiplication by any fixed element `y` in `G` is also a null set.


theorem cmp_eq_eq_iff : ∀ {α : Type u_1} [inst : LinearOrder α] (x y : α), cmp x y = Ordering.eq ↔ x = y := by sorry

This theorem states that for any type `α` that has a linear order, and for any two elements `x` and `y` of this type, the comparison of `x` and `y` using the function `cmp` (which compares two elements and returns an ordering) results in equality if and only if `x` and `y` are indeed equal. In other words, if `cmp x y` gives `Ordering.eq`, this means `x` is equal to `y` and vice versa.

For any type `α` with a linear order, the function `cmp : α → α → Ordering` satisfies `cmp x y = Ordering.eq <-> x = y`.


theorem AddSubgroup.map_le_iff_le_comap :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {K : AddSubgroup G}
      {H : AddSubgroup N}, AddSubgroup.map f K ≤ H ↔ K ≤ AddSubgroup.comap f H :=
  by sorry

The theorem `AddSubgroup.map_le_iff_le_comap` states that for any two additive groups `G` and `N`, and a homomorphism `f` from `G` to `N`, an additive subgroup `K` of `G`, and an additive subgroup `H` of `N`, the image of `K` under `f` is a subgroup of `H` if and only if `K` is a subgroup of the preimage of `H` under `f`. In other words, it provides a criterion for comparing an original subgroup and its image or how a subgroup in the target relates to a subgroup in the source via the homomorphism.

For additive groups G, N, homomorphism f: G -> N, subgroups K of G, and H of N, the image of K under f is a subgroup of H if and only if K is a subgroup of the preimage of H under f.


theorem tendsto_norm_atTop_atTop : Filter.Tendsto norm Filter.atTop Filter.atTop := by sorry

The theorem `tendsto_norm_atTop_atTop` states that the norm function has a limit of positive infinity (`atTop`) when its argument tends to positive infinity (`atTop`). More precisely, for every unbounded set in the codomain, the preimage under the norm function is an unbounded set in the domain. This captures the intuitive notion that as the input values grow without bound, so do their norms.

For every unbounded set in the codomain of the norm function, its preimage in the domain is also unbounded.


theorem Set.inter_prod :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t : Set β}, (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t := by sorry

The theorem `Set.inter_prod` states that for any types `α` and `β`, and for any sets `s₁`, `s₂` of type `α`, and a set `t` of type `β`, the Cartesian product of the intersection of `s₁` and `s₂` with `t` is equal to the intersection of the Cartesian product of `s₁` with `t` and the Cartesian product of `s₂` with `t`. In mathematical terms, this can be expressed as (s₁ ∩ s₂) × t = (s₁ × t) ∩ (s₂ × t), where × represents the Cartesian product and ∩ represents the intersection of sets.

For any types `α`, sets `s₁`, `s₂`, and `t` of types `α`, the Cartesian product of the intersection of `s₁` and `s₂` with `t` equals the intersection of the Cartesian products of `s₁` and `t`, and `s₂` and `t`.


theorem CategoryTheory.Presheaf.firstObj.proof_1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : Type u_4}
      [inst_1 : CategoryTheory.Category.{u_3, u_4} A] {U : C} (R : CategoryTheory.Presieve U)
      (P : CategoryTheory.Functor Cᵒᵖ A) [inst_2 : CategoryTheory.Limits.HasProducts A],
      CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun f => P.obj (Opposite.op f.fst)) :=
  by sorry

This theorem states that for any category `C`, category `A`, an object `U` in `C`, a presieve `R` on `U`, and a functor `P` from the opposite of `C` to `A`, if the category `A` has products, then there exists a limit for the functor which maps an arrow `f` to the object `P.obj` of the opposite of the domain of `f` in the discrete category of `C`.
Essentially, this establishes the existence of certain limits in the category `A` given the existence of products in that category, mapping elements in the presieve to objects in `A` via the functor `P`.

Given a category `C`, a category `A` with products, an object `U` in `C`, a presieve `R` on `U`, and a functor `P` from `C^{op}` to `A`, there exists a limit for `P` over `R` in `A`.


theorem Mathlib.Algebra.GroupWithZero.Defs._auxLemma.2 :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a b : M₀}, (0 = a * b) = (a = 0 ∨ b = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.GroupWithZero.Defs._auxLemma.2`, states that for any type `M₀` that has multiplication and zero, and where there are no zero divisors, the equation `0 = a * b` (where `a` and `b` are elements of `M₀`) holds true if and only if either `a` or `b` is zero. In more mathematical terms, for a ring without zero divisors (like the integers or a field like the real numbers), the product of two elements is zero if and only if at least one of the elements is zero.

In a ring without zero divisors, the product of two non-zero elements is non-zero. Conversely, the product of two elements is zero if and only if at least one of them is zero.


theorem Finset.not_mem_Iio_self :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrderBot α] {b : α}, b ∉ Finset.Iio b := by sorry

This theorem states that for any type `α` that is equipped with a partial order and a locally finite order, any element `b` of type `α` is not a member of the finite set of elements that are less than `b`. In other words, given a partial order on a type and a locally finite order, no element is less than itself. This corresponds to the mathematical principle that under a partial ordering, no element is strictly less than itself.

In a partially ordered type with a locally finite order, no element is less than itself.


theorem Complex.differentiable_exp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ], Differentiable 𝕜 Complex.exp := by
  sorry

The theorem `Complex.differentiable_exp` asserts that for any type '𝕜' which forms a non-trivially normed field and is also a normed algebra over the complex numbers, the complex exponential function (defined via its Taylor series) is differentiable at every point. In other words, the derivative of the complex exponential function exists for all points in its domain, under the conditions specified for '𝕜'.

The complex exponential function, defined via its Taylor series, is differentiable for all complex numbers in the domain of any non-trivially normed field that is also a normed algebra over the complex numbers.


theorem multiplicity.exists_eq_pow_mul_and_not_dvd :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α}
      (hfin : multiplicity.Finite a b), ∃ c, b = a ^ (multiplicity a b).get hfin * c ∧ ¬a ∣ c :=
  by sorry

This theorem, named `multiplicity.exists_eq_pow_mul_and_not_dvd`, states that for any type `α` that has a monoid structure and a decidable relation for divisibility, given any two elements `a` and `b` of `α` such that the multiplicity of `a` in `b` is finite (denoted by `multiplicity.Finite a b`), there exists an element `c` of `α` such that `b` equals `a` raised to the power of the multiplicity of `a` in `b` times `c` (expressed as `b = a ^ (multiplicity a b).get hfin * c`), and `a` does not divide `c` (notated as `¬a ∣ c`). In simpler terms, it says that `b` can be expressed as a power of `a` times some `c`, and `a` doesn't divide `c`.

For any type `α` with a monoid structure and decidable divisibility relation, given `a` and `b` in `α` such that the multiplicity of `a` in `b` is finite, there exists an element `c` in `α` with `b = a ^ (multiplicity a b) * c` and `a ∣ c ← false`.


HasDerivAtFilter.scomp

theorem HasDerivAtFilter.scomp :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) {L : Filter 𝕜} {𝕜' : Type u_1} [inst_3 : NontriviallyNormedField 𝕜']
      [inst_4 : NormedAlgebra 𝕜 𝕜'] [inst_5 : NormedSpace 𝕜' F] [inst_6 : IsScalarTower 𝕜 𝕜' F] {h : 𝕜 → 𝕜'} {h' : 𝕜'}
      {g₁ : 𝕜' → F} {g₁' : F} {L' : Filter 𝕜'},
      HasDerivAtFilter g₁ g₁' (h x) L' →
        HasDerivAtFilter h h' x L → Filter.Tendsto h L L' → HasDerivAtFilter (g₁ ∘ h) (h' • g₁') x L :=
  by sorry

This theorem, `HasDerivAtFilter.scomp`, states that given two functions `h` and `g₁` on the types `𝕜` and `𝕜'` respectively, with known derivatives at a point `x` for `h` and at `h x` for `g₁` as `x` approaches along the filter `L` and `h x` approaches along the filter `L'` respectively, if `h` converges from filter `L` to `L'` as `x` approaches, then the derivative of the composition of `g₁` and `h` at the point `x` along the filter `L` exists and is equal to the derivative of `h` at `x` scaled by the derivative of `g₁` at `h x`. This states a version of the chain rule for derivatives in the context of normed spaces and filters.

Given functions `h: 𝕜 → 𝕜'` and `g₁: 𝕜' → ℝ` with derivatives at `x` along filters `L` and `L'`, respectively, and assuming `h` converges from `L` to `L'`, the derivative of `g₁ ∘ h` at `x` along `L` exists and equals the derivative of `h` at `x` multiplied by the derivative of `g₁` at `h x`.


theorem Complex.cpow_neg : ∀ (x y : ℂ), x ^ (-y) = (x ^ y)⁻¹ := by sorry

This theorem states that for all complex numbers 'x' and 'y', the power of 'x' to the negative 'y' is equal to the inverse of 'x' to the power of 'y'. In other words, it stipulates the property for complex numbers that the power of a number to a negative exponent is the reciprocal of the power to the positive exponent.

For all complex numbers x and y, x^(-y) = 1 / x^y.


/-- **Alias** of `lt_of_smul_lt_smul_left`. -/
theorem lt_of_smul_lt_smul_of_nonneg_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulReflectLT α β], a • b₁ < a • b₂ → 0 ≤ a → b₁ < b₂ :=
  by sorry

This theorem, `lt_of_smul_lt_smul_of_nonneg_left`, states that for all types `α` and `β`, with variables `a` of type `α` and `b₁`, `b₂` of type `β`, given instances of scalar multiplication (`SMul α β`), preorders on `α` and `β`, zero for `α`, and positive scalar multiplication reflected in less-than relation (`PosSMulReflectLT α β`), if the scalar multiplication of `a` and `b₁` is less than the scalar multiplication of `a` and `b₂` and `a` is non-negative (greater or equal to zero), then `b₁` is less than `b₂`. This theorem is an alias of `lt_of_smul_lt_smul_left`.

For all types `α` and `β`, if `a ∈ α` is non-negative and `a * b₁ < a * b₂` for scalars `b₁, b₂ ∈ β` with positive scalar multiplication and preorders on `α` and `β`, then `b₁ < b₂`.


Antitone.inter

theorem Antitone.inter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : β → Set α},
      Antitone f → Antitone g → Antitone fun x => f x ∩ g x :=
  by sorry

The theorem `Antitone.inter` states that for all types `α` and `β`, where `β` has a preorder structure, and any two functions `f` and `g` from `β` to the set of `α`, if both `f` and `g` are antitone (i.e., for all `a, b` in `β`, if `a ≤ b`, then `f(b) ≤ f(a)` and `g(b) ≤ g(a)`), then the function that maps `x` in `β` to the intersection of the sets `f(x)` and `g(x)` is also antitone.

If `f` and `g` are antitone functions from a preordered type `β` to type `α`, then the function that maps each `x` in `β` to the intersection of `f(x)` and `g(x)` is also an antitone function.


theorem ENNReal.inv_strictAnti : StrictAnti Inv.inv := by sorry

The theorem `ENNReal.inv_strictAnti` states that the inversion function (represented by `Inv.inv`) is strictly antitone. In mathematical terms, if we have two elements `a` and `b` such that `a < b`, then the inverse of `b` is less than the inverse of `a`. This property is called strict anti-monotonicity.

For all `a` and `b` in the non-negative real numbers with `a < b`, we have `Inv.inv b < Inv.inv a`.


theorem OrderDual.toDual_le_toDual :
    ∀ {α : Type u_1} [inst : LE α] {a b : α}, OrderDual.toDual a ≤ OrderDual.toDual b ↔ b ≤ a := by sorry

The theorem `OrderDual.toDual_le_toDual` states that for all types `α` that have a less than or equal to (`≤`) relation, and for any two elements `a` and `b` from `α`, the inequality `OrderDual.toDual a ≤ OrderDual.toDual b` holds if and only if `b ≤ a`. In other words, the function `OrderDual.toDual` effectively reverses the order of the original less than or equal to relation.

For any type equipped with a reflexive, transitive, and antisymmetric relation `≤`, the dual relation `OrderDual.toDual` satisfies `a ≤ b <-> OrderDual.toDual b <= OrderDual.toDual a`.


theorem MeasureTheory.Memℒp.snorm_ne_top :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α → E}, MeasureTheory.Memℒp f p μ → MeasureTheory.snorm f p μ ≠ ⊤ :=
  by sorry

This theorem asserts that for any measurable space `α`, any extended nonnegative real number `p`, any measure `μ` on `α`, any normed add commutative group `E`, and any function `f` from `α` to `E`, if `f` satisfies the property of being `p`-integrable (i.e., `f` is almost everywhere strongly measurable and either the `p`-th power of the integral of the norm of `f` is finite, if `p < ∞`, or the essential supremum of `f` is finite, if `p = ∞`), then the `p`-seminorm of `f` (which is `0` when `p=0`, the `p`-th root of the integral of the `p`-th power of the norm of `f` when `0 < p < ∞`, and the essential supremum of the norm of `f` when `p = ∞`) is not equal to infinity. This theorem is essentially a restatement of part of the definition of `p`-integrability.

If `α` is a measurable space, `p` is an extended nonnegative real number, `μ` is a measure on `α`, `E` is a normed add commutative group, and `f` is a `p`-integrable function from `α` to `E`, then the `p`-seminorm of `f` is finite.


theorem CategoryTheory.NonPreadditiveAbelian.sub_def :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a b : X ⟶ Y),
      a - b =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.lift a b)
          CategoryTheory.NonPreadditiveAbelian.σ :=
  by sorry

The theorem `CategoryTheory.NonPreadditiveAbelian.sub_def` states that in a non-preadditive Abelian category `C`, for any two morphisms `a` and `b` from object `X` to object `Y`, the difference `a - b` can be defined as the composition of the morphism `prod.lift a b`, which is induced by `a` and `b`, and the morphism `σ` from the category's structure as a non-preadditive Abelian category. In other words, subtraction of morphisms in a non-preadditive Abelian category is defined via composition with the categorical product and a special morphism `σ`.

In a non-preadditive Abelian category, morphism difference is defined as composition with the induced morphism from the categorical product and the special morphism `σ`.


theorem List.ofFn_const : ∀ {α : Type u} (n : ℕ) (c : α), (List.ofFn fun x => c) = List.replicate n c := by sorry

The theorem `List.ofFn_const` states that for any type `α`, any natural number `n`, and any constant `c` of type `α`, creating a list by applying a function that always returns `c` on `Fin n` (which essentially represents the first `n` natural numbers) is the same as creating a list by replicating `c` `n` times. In other words, the list containing `n` elements, all of which are `c`, can be created either by applying a constant function to the first `n` natural numbers, or by directly replicating `c` `n` times.

For any type `α` and natural number `n`, the function application `map (const c) ( Fin.range n )` equals the list `replicate n c`.


theorem Nat.odd_of_mod_four_eq_one : ∀ {n : ℕ}, n % 4 = 1 → n % 2 = 1 := by sorry

This theorem states that for any natural number `n`, if the remainder when `n` is divided by 4 equals 1 then the remainder when `n` is divided by 2 also equals 1. In other words, if a natural number is one more than a multiple of 4, then it is an odd number.

If a natural number `n` is congruent to 1 modulo 4, then it is congruent to 1 modulo 2.


theorem ENNReal.div_le_iff_le_mul : ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) := by
  sorry

This theorem states that for any extended nonnegative real numbers `a`, `b`, and `c`, given that either `b` is not zero or `c` is not infinity, and either `b` is not infinity or `c` is not zero, then the inequality `a / b ≤ c` is equivalent to `a ≤ c * b`. In other words, you can swap the division and multiplication in the inequality under these conditions. This theorem is crucial in measure theory and other mathematical fields, and it helps to manipulate inequalities involving extended nonnegative real numbers.

For extended nonnegative real numbers `a`, `b`, and `c`, if `b` is nonzero and `c` is finite, or `b` is finite and `c` is nonzero, then `a / b ≤ c` is equivalent to `a ≤ c * b`.


theorem contDiffOn_congr :
    ∀ {𝕜 : 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 f₁ : E → F} {n : ℕ∞}, (∀ x ∈ s, f₁ x = f x) → (ContDiffOn 𝕜 n f₁ s ↔ ContDiffOn 𝕜 n f s) :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, normed additive commutative group `E`, normed space over `𝕜` for `E`, another normed additive commutative group `F`, and another normed space over `𝕜` for `F`, given a set `s` of elements of type `E`, two functions `f` and `f₁` from `E` to `F`, and any `n` in ℕ∞ (which represents either a natural number or infinity), if for every element `x` in set `s`, `f₁ x` equals `f x`, then the function `f₁` is continuously differentiable on set `s` to order `n` if and only if the function `f` is continuously differentiable on set `s` to order `n`. In simpler terms, if two functions agree on a set, their continuous differentiability on that set is also the same.

If two functions agree on a set in a normed vector space, then they have the same continuous differentiability order on that set.


theorem Function.isPeriodicPt_iff_minimalPeriod_dvd :
    ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ}, Function.IsPeriodicPt f n x ↔ Function.minimalPeriod f x ∣ n := by
  sorry

The theorem `Function.isPeriodicPt_iff_minimalPeriod_dvd` states that for any given point `x` and function `f` of type `α → α`, `x` is a periodic point of `f` with period `n` if and only if the minimal period of `x` under `f` divides `n`. In other words, a point `x` repeats its position every `n` steps in the function `f` exactly when `n` is a multiple of the smallest number of steps that brings `x` back to its initial position.

A point x is a periodic point of a function f with period n if and only if the minimal period of x under f divides n.


theorem Cardinal.aleph0_le_aleph' : ∀ {o : Ordinal.{u_1}}, Cardinal.aleph0 ≤ Cardinal.aleph' o ↔ Ordinal.omega ≤ o := by
  sorry

The theorem `Cardinal.aleph0_le_aleph'` states that for any ordinal number `o`, the smallest infinite cardinal number (also known as aleph-null or ℵ₀) is less than or equal to the cardinal number associated with `o` (given by the `aleph'` function) if and only if the first infinite ordinal number (often symbolized as ω) is less than or equal to `o`. In other words, it establishes a relationship between the orderings of ordinal and cardinal numbers.

The smallest infinite cardinal number is less than or equal to the cardinality of any ordinal number `o` if and only if the first infinite ordinal number ω is less than or equal to `o`.


theorem Mathlib.Data.Nat.Lattice._auxLemma.9 : ∀ {s : Set ℕ}, (sInf s = 0) = (0 ∈ s ∨ s = ∅) := by sorry

This theorem, from the Mathlib library, states that for any set `s` of natural numbers (`ℕ`), the `infimum` (greatest lower bound) of the set being `0` is equivalent to either the number `0` being an element of the set, or the set being the empty set (`∅`). In other words, the smallest element in the set is `0` if and only if `0` is in the set or the set has no elements.

The set of natural numbers `s` has an infimum equal to `0` if and only if `0` is an element of `s` or `s` is the empty set.


theorem smul_le_smul_iff_of_neg_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : OrderedRing α] [inst_1 : OrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : PosSMulMono α β] [inst_4 : PosSMulReflectLE α β],
      a < 0 → (a • b₁ ≤ a • b₂ ↔ b₂ ≤ b₁) :=
  by sorry

The theorem `smul_le_smul_iff_of_neg_left` states that for any types `α` and `β`, with `α` being an ordered ring, `β` being an ordered additive commutative group, and `α` also being a module over `β`, if `a` is a negative element of `α` and `b₁` and `b₂` are arbitrary elements of `β`, then scalar multiplication of `a` and `b₁` is less than or equal to scalar multiplication of `a` and `b₂` if and only if `b₂` is less than or equal to `b₁`. This theorem thus provides a way to compare scalar multiples under the conditions that the scalar is negative and the module operation and scalar multiplication obey certain properties (`PosSMulMono` and `PosSMulReflectLE`).

For any ordered ring `α`, ordered additive commutative group `β`, and `α` being a module over `β`, if `a` is negative in `α` and `b₁ ≤ b₂` in `β`, then `-(a * b₁) ≤ (a * b₂)` in `α`.


theorem MeasureTheory.MeasurePreserving.integrable_comp_emb :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : MeasurableSpace δ] [inst_1 : NormedAddCommGroup β] {f : α → δ} {ν : MeasureTheory.Measure δ},
      MeasureTheory.MeasurePreserving f μ ν →
        MeasurableEmbedding f → ∀ {g : δ → β}, MeasureTheory.Integrable (g ∘ f) μ ↔ MeasureTheory.Integrable g ν :=
  by sorry

The theorem `MeasureTheory.MeasurePreserving.integrable_comp_emb` states that for any types `α`, `β`, and `δ`, given a measurable space `α`, a measure `μ` on `α`, a measurable space `δ`, a normed additively commutative group `β`, a function `f : α → δ`, and a measure `ν` on `δ`, if `f` is a measure-preserving function from `μ` to `ν` and `f` is a measurable embedding, then for any function `g : δ → β`, the function `g` composed with `f` (`g ∘ f`) is integrable with respect to `μ` if and only if `g` is integrable with respect to `ν`. In simpler terms, it says that under these conditions, the integrability of a function composed with a measure-preserving function is preserved.

If `f : α → δ` is a measure-preserving and measurable embedding of measurable spaces with measures `μ` and `ν`, then the integrability of a function `g : δ → β` with respect to `μ` is equivalent to its integrability with respect to `ν`.


theorem Finsupp.unique_ext :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : Unique α] {f g : α →₀ M}, f default = g default → f = g :=
  by sorry

This theorem, `Finsupp.unique_ext`, asserts that for any two functions `f` and `g` from a type `α` to a type `M` with a zero element, if `α` is a unique type (i.e., there exists exactly one element of `α`) and the default values of `f` and `g` are equal, then the functions `f` and `g` are equal. The theorem essentially states that two functions on a unique type are equal if they agree on the value of the unique element.

Given types `α` with exactly one element and `M` with a zero element, if two functions `f` and `g` from `α` to `M` have equal values at the unique element, then `f` and `g` are equal.


/-- A version of `continuous_sInf_dom` for binary functions  -/
theorem continuous_sInf_dom₂ :
    ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {tas : Set (TopologicalSpace X)}
      {tbs : Set (TopologicalSpace Y)} {tX : TopologicalSpace X} {tY : TopologicalSpace Y} {tc : TopologicalSpace Z},
      tX ∈ tas → tY ∈ tbs → (Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 :=
  by sorry

This theorem, `continuous_sInf_dom₂`, asserts that for any three types `X`, `Y`, and `Z`, any binary function `f` from `X` and `Y` to `Z`, two sets of topological spaces `tas` and `tbs` over `X` and `Y` respectively, and the topological spaces `tX`, `tY`, and `tc` over `X`, `Y`, and `Z` respectively, if the topological space `tX` is an element of `tas`, the topological space `tY` is an element of `tbs`, and the function `(p => f p.1 p.2)` is continuous, then the function `(p => f p.1 p.2)` remains continuous. In simpler terms, it is a statement about the continuity of a binary function under certain conditions related to topological spaces.

If `X`, `Y`, and `Z` are types, `f : X → Y → Z` is a continuous function, and `tas` and `tbs` are topological spaces over `X` and `Y` respectively, such that `tX ∈ tas` and `tY ∈ tbs`, then `(p => f p.1 p.2)` is a continuous function from the product topology on `X × Y` to `Z`.


theorem PosNum.succ_to_nat : ∀ (n : PosNum), ↑(PosNum.succ n) = ↑n + 1 := by sorry

The theorem `PosNum.succ_to_nat` states that for every positive number `n`, the natural number representation of the successor of `n` is equal to the natural number representation of `n` plus one. In other words, it asserts that the `succ` operation on positive numbers corresponds to incrementing by one in the natural numbers.

For every positive number `n`, the natural number representation of `n.succ` is one more than the natural number representation of `n`.


theorem nhdsWithin_insert :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (s : Set α),
      nhdsWithin a (insert a s) = pure a ⊔ nhdsWithin a s :=
  by sorry

This theorem, `nhdsWithin_insert`, describes a property of neighborhoods within a given set in a topological space. Specifically, for any type `α`, any instance of a topological space on `α`, any element `a` of type `α`, and any set `s` of type `α`, the neighborhood within the set obtained by inserting `a` into `s` at the point `a` is equal to the join of the singleton set containing just `a` and the neighborhood within `s` at `a`. In other words, adding a point to a set does not change its neighborhood within that set, except at the point that was added.

For any topological space and any element, the neighborhood of a point in the set containing that point is equal to the join of the neighborhood of that point in the original set and the singleton set containing that point.


IsCompact.inter

theorem IsCompact.inter :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {s t : Set X},
      IsCompact s → IsCompact t → IsCompact (s ∩ t) :=
  by sorry

The theorem `IsCompact.inter` states that for any type `X` with a topology and a `T2Space` (Hausdorff space) structure, if `s` and `t` are two sets in `X` that are both compact, then their intersection `s ∩ t` is also compact. In other words, in a Hausdorff space, the intersection of two compact sets is also a compact set.

In a Hausdorff space, the intersection of two compact sets is a compact set.


theorem ContDiff.comp_contDiffWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {t : Set E} {x : E} {n : ℕ∞} {g : F → G} {f : E → F},
      ContDiff 𝕜 n g → ContDiffWithinAt 𝕜 n f t x → ContDiffWithinAt 𝕜 n (g ∘ f) t x :=
  by sorry

The theorem `ContDiff.comp_contDiffWithinAt` states that given a set `t` of elements of type `E`, a point `x` within this set, a natural number or infinity `n`, and two functions `f` and `g` with `f` mapping from `E` to `F` and `g` mapping from `F` to `G` where `E`, `F` and `G` are normed spaces over a nontrivially normed field `𝕜`, if `g` is continuously differentiable with respect to `𝕜` at `n` and `f` is continuously differentiable with respect to `𝕜` at `n` within the set `t` at the point `x`, then the composition of `g` and `f` is also continuously differentiable with respect to `𝕜` at `n` within the set `t` at the point `x`.

If `f` is continuously differentiable with respect to a normed field `𝕜` at `n` within the set `t` at `x`, and `g` is continuously differentiable with respect to `𝕜` at `n`, then the composition `g ∘ f` is continuously differentiable with respect to `𝕜` at `n` within the set `t` at `x`.


theorem List.singleton_injective : ∀ {α : Type u}, Function.Injective fun a => [a] := by sorry

The theorem `List.singleton_injective` states that for all types `α`, the function which takes an element `a` of type `α` and maps it to a singleton list containing `a` is injective. In other words, if two singleton lists are equal, then their elements must also be equal. This is a property of the singleton list function: no two distinct values can map to the same list, ensuring the function's injectivity.

For any type α, the function mapping each element to the singleton list containing that element is an injection.


theorem FreeGroup.Red.Step.to_red :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeGroup.Red.Step L₁ L₂ → FreeGroup.Red L₁ L₂ := by sorry

This theorem states that for all types `α` and lists `L₁` and `L₂` of pairs of `α` and `Bool`, if there is a single step reduction (`FreeGroup.Red.Step`) from `L₁` to `L₂`, then `L₁` and `L₂` are related by the reflexive-transitive closure of the single step reduction relation (`FreeGroup.Red`). This implies that a single step reduction is considered part of the broader `FreeGroup.Red` relation, which includes both single step reductions and sequences of such reductions.

If there exists a single step reduction from list `L₁` to list `L₂` of pairs of type `α` and `Bool` in the free group, then `L₁` and `L₂` are related in the reflexive-transitive closure of the free group reduction relation.


/-- A product of finite numbers is still finite  -/
theorem ENNReal.prod_lt_top :
    ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal}, (∀ a ∈ s, f a ≠ ⊤) → (Finset.prod s fun a => f a) < ⊤ := by sorry

This theorem states that the product of a finite set of extended nonnegative real numbers is still finite. More formally, given any type `α`, a finite set `s` of `α`, and a function `f` mapping elements of `α` to extended nonnegative real numbers (`ENNReal`), if for all elements `a` in `s`, `f(a)` is not equal to infinity (`⊤`), then the product of `f(a)` for all `a` in `s` is also less than infinity.

If `f` is a function mapping a finite set `s` of real numbers to extended nonnegative real numbers such that `f(a)` is finite for all `a` in `s`, then the product of `f(a)` for all `a` in `s` is finite.


theorem Nat.mul_div_mul_left : ∀ {m : ℕ} (n k : ℕ), 0 < m → m * n / (m * k) = n / k := by sorry

This theorem states that for any positive integer `m` and any two arbitrary integers `n` and `k`, the result of dividing the product of `m` and `n` by the product of `m` and `k` is equal to the result of dividing `n` by `k`. In other words, for `m > 0, n, k ∈ ℕ`, we have `(m * n) / (m * k) = n / k`. This theorem is a property of integer division in the natural numbers.

For any positive integers m, n, and k, the quotient of n by k is equal to the quotient of the product of m and n by the product of m and k. In other words, (m * n) / (m * k) = n / k.


theorem CochainComplex.shiftFunctorObjXIso.proof_1 : ∀ (n i m : ℤ), m = i + n → i + n = m := by sorry

This theorem states that for any three integers `n`, `i`, and `m`, if `m` is equal to the sum of `i` and `n`, then the sum of `i` and `n` is also equal to `m`. It is essentially confirming the symmetric property of equality in the context of integer arithmetic.

If `m` equals the sum of `i` and `n`, then `i` plus `n` equals `m`.


theorem QuaternionAlgebra.coe_mul : ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (x y : R), ↑(x * y) = ↑x * ↑y := by
  sorry

This theorem states that for any commutative ring `R` and any elements `c₁`, `c₂`, `x`, and `y` of `R`, the quaternion algebra operation of converting the product `x * y` to a quaternion preserves the multiplication operation. In other words, converting `x * y` to a quaternion gives the same result as converting `x` and `y` to quaternions and then multiplying them. Mathematically speaking, it says that for any `x` and `y` in the ring, `↑(x * y) = ↑x * ↑y`, where `↑` denotes the quaternion algebra operation.

For any commutative ring `R` and elements `x, y` in `R`, the quaternion algebra operation `↑` satisfies `↑(x * y) = ↑x * ↑y`.


theorem List.sum_ofFn :
    ∀ {α : Type u_1} [inst : AddCommMonoid α] {n : ℕ} {f : Fin n → α},
      List.sum (List.ofFn f) = Finset.sum Finset.univ fun i => f i :=
  by sorry

This theorem states that for any given type `α` that has an additive commutative monoid structure, any natural number `n`, and any function `f` from the finite set `Fin n` to `α`, the sum of the list created by applying `f` to each element in `Fin n` (i.e., `List.sum (List.ofFn f)`) is equal to the sum of `f` applied to each element in the universal finite set (i.e., `Finset.sum Finset.univ fun i => f i`). In simpler terms, it states that the sum of the elements of a list created by applying a function to each element of a finite set is equivalent to the sum of the function's values over the entire finite set.

For any additive commutative monoid type `α`, function `f` from a finite set `Fin n` to `α`, and natural number `n`, the sum of the list `[f i | i ∈ Fin n]` equals the sum of `f` over the universal finite set `Finset.univ`.


Dioph.union

theorem Dioph.union : ∀ {α : Type u} {S S' : Set (α → ℕ)}, Dioph S → Dioph S' → Dioph (S ∪ S') := by sorry

The theorem `Dioph.union` asserts that for any type `α` and any two sets `S` and `S'` of functions from `α` to natural numbers, if both `S` and `S'` are Diophantine, then their union `S ∪ S'` is also Diophantine. Here, a set is considered Diophantine if there exists a polynomial such that a function is in the set if and only if there exists a natural number satisfying the polynomial equation.

If `S` and `S'` are sets of functions from a type `α` to natural numbers that are Diophantine, then their union `S ∪ S'` is also Diophantine.


theorem Mathlib.Algebra.Algebra.Subalgebra.Basic._auxLemma.11 :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
      (x ∈ ⊤) = True :=
  by sorry

This theorem, `Mathlib.Algebra.Algebra.Subalgebra.Basic._auxLemma.11`, states that for any type `R`, any type `A`, given that `R` is a commutative semiring, `A` is a semiring, and `A` is an algebra over `R`, then for any element `x` of `A`, `x` belongs to the top element (in the sense of a topological space or the universal set in a set theory context) is always true. In simpler terms, this is saying that any element of an algebra is in the universal set.

For any commutative semiring `R`, semiring `A`, and algebra `A` over `R`, every element `x` in `A` belongs to the universally-quantified set `A`.


theorem Ideal.span_insert :
    ∀ {α : Type u} [inst : Semiring α] (x : α) (s : Set α), Ideal.span (insert x s) = Ideal.span {x} ⊔ Ideal.span s :=
  by sorry

The theorem `Ideal.span_insert` states that for any type `α` that forms a semiring, for any element `x` of type `α`, and for any set `s` of elements of type `α`, the ideal generated by the set which includes `x` and all elements of `s` is equal to the sup (join or least upper bound) of the ideal generated by the set containing `x` only and the ideal generated by the set `s`. In other words, in the context of ring theory, this theorem states that the ideal spanned by the union of an element and a set is the sup of the ideal spanned by the element and the ideal spanned by the set.

For any semiring type `α`, the ideal generated by an element `x` and a set `s` is equal to the sup (join or least upper bound) of the ideal generated by `x` alone and the ideal generated by `s`.


theorem Mathlib.Algebra.Order.Ring.Defs._auxLemma.1 :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a : α}, 0 ≤ a → ∀ (n : ℕ), (0 ≤ a ^ n) = True := by sorry

This theorem states that for any type `α` that forms an ordered semiring and for any element `a` of this type, if `a` is greater than or equal to zero, then for any natural number `n`, `a` raised to the power `n` is also greater than or equal to zero. In other words, the nonnegative power of a nonnegative number in an ordered semiring is always nonnegative.

For any ordered semiring type `α` and its non-negative element `a`, if `a` is non-negative, then `a^n` is non-negative for all natural numbers `n`.


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

This theorem states that for any type 'α', and any elements 'a' and 'b' of this type, as well as any set 's' of this type, the operation of inserting 'a' into the set obtained by inserting 'b' into 's' is equivalent to the operation of inserting 'b' into the set obtained by inserting 'a' into 's'. In other words, the order of insertion does not matter, which is a property of commutativity.

For any set 's' and elements 'a' and 'b' of type 'α', the operation of inserting 'a' into the set obtained by inserting 'b' into 's' is equal to the operation of inserting 'b' into the set obtained by inserting 'a' into 's'.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.2 :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b c : α},
      (a + b ≤ a + c) = (b ≤ c) :=
  by sorry

This theorem, from the Mathlib library in Lean, states that for all types `α`, if `α` is a type that has addition and order defined, satisfies the CovariantClass property and the ContravariantClass property (both with respect to addition and order), then for any `a`,`b`, and `c` of type `α`, the inequality `a + b ≤ a + c` is equivalent to `b ≤ c`. In other words, adding an equal amount to both sides of an inequality doesn't change the inequality, an essential and intuitive property of ordered additive structures.

If `α` is an additive and ordered type with Covariant and Contravariant classes of inequalities, then for all `a, b, c` in `α`, `a + b ≤ a + c` if and only if `b ≤ c`.


theorem Int.neg_div : ∀ (a b : ℤ), Int.div (-a) b = -Int.div a b := by sorry

This theorem states that for all integer pairs `a` and `b`, the integer division of `-a` by `b` is equal to the negation of the integer division of `a` by `b`. In other words, negating `a` before division by `b` is the same as negating the result of the division of `a` by `b`. This holds for all integers `a` and `b` with mathematical notation as: ∀ a, b ∈ ℤ, (-a) ÷ b = -(a ÷ b).

For all integers `a` and `b`, the negative of the integer division of `a` by `b` is equal to the integer division of the negated `a` by `b`. In mathematical notation: ∀ a, b ∈ ℤ, -(a ÷ b) = (-\_ a) ÷ b.


theorem Nat.nonempty_of_pos_sInf : ∀ {s : Set ℕ}, 0 < sInf s → Set.Nonempty s := by sorry

This theorem, `Nat.nonempty_of_pos_sInf`, states that for all sets `s` of natural numbers, if the infimum of `s` (denoted as `sInf s`) is greater than 0, then the set `s` is not empty. The term "infimum" of a set refers to the greatest number that is less than or equal to all numbers in the set. This theorem is used to affirm that a set of natural numbers `s` is non-empty given that the lower bound or infimum of `s` is greater than 0.

If the infimum of a set of natural numbers is positive, then the set is non-empty.


theorem IsometryEquiv.image_symm :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      Set.image ⇑(IsometryEquiv.symm h) = Set.preimage ⇑h :=
  by sorry

The theorem `IsometryEquiv.image_symm` states that for any isometric isomorphism `h` from a pseudo-emetric space `α` to another pseudo-emetric space `β`, the image of a set under the inverse of `h` is equivalent to the preimage of the set under `h`. In other words, when we apply `h` to elements of `α`, and take the image through the inverse of `h`, we end up with the same set as if we started with `β` and considered all elements that map to it under `h`.

For any isometric isomorphism between pseudo-metric spaces, the image of a set under the inverse mapping is equivalent to the preimage of that set.


theorem Mathlib.Order.Basic._auxLemma.29 :
    ∀ {α : Type u} {β : Type v} [inst : LE α] [inst_1 : LE β] {x₁ x₂ : α} {y₁ y₂ : β},
      ((x₁, y₁) ≤ (x₂, y₂)) = (x₁ ≤ x₂ ∧ y₁ ≤ y₂) :=
  by sorry

The theorem `Mathlib.Order.Basic._auxLemma.29` states that for any two types `α` and `β` that are partially ordered (i.e., have a "less than or equal to" (`≤`) relation defined on them), and for any pairs of elements `(x₁, y₁)` and `(x₂, y₂)` where `x₁`, `x₂` are from `α` and `y₁`, `y₂` are from `β`, the pair `(x₁, y₁)` is less than or equal to the pair `(x₂, y₂)` if and only if both `x₁` is less than or equal to `x₂` and `y₁` is less than or equal to `y₂`. This is an important property of how order relations extend to product types.

For any partially ordered types `α` and `β`, the order relation on their product `α × β` is given by `(x₁, y₁) ≤ (x₂, y₂)` if and only if `x₁ ≤ x₂` and `y₁ ≤ y₂`.


PartialHomeomorph.IsImage.frontier

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

The theorem `PartialHomeomorph.IsImage.frontier` states that for any two topological spaces `X` and `Y`, and any partial homeomorphism `e` from `X` to `Y`, if a set `t` in `Y` is the image of a set `s` in `X` under the partial homeomorphism `e`, then the frontier of `t` (the set of points between the closure and interior of `t`) is the image of the frontier of `s` (the set of points between the closure and interior of `s`) under the same partial homeomorphism `e`.
This theorem expresses a property of partial homeomorphisms, showing that they preserve not only the structure of sets, but also the structure of their frontiers, which can be considered as the "boundaries" of the sets.

For any partial homeomorphism between topological spaces, the image of the frontier of a set under the partial homeomorphism is equal to the frontier of the image of that set.


theorem ENNReal.tendsto_inv_iff :
    ∀ {α : Type u_1} {f : Filter α} {m : α → ENNReal} {a : ENNReal},
      Filter.Tendsto (fun x => (m x)⁻¹) f (nhds a⁻¹) ↔ Filter.Tendsto m f (nhds a) :=
  by sorry

This theorem states that for any type `α`, any filter `f` on `α`, any function `m` from `α` to the extended nonnegative real numbers (`ENNReal`), and any extended nonnegative real number `a`, the function `m` tends to `a` with respect to filter `f` if and only if the reciprocal function of `m` tends to the reciprocal of `a` with respect to the same filter `f`. In simpler terms, a function converges to a value if and only if its reciprocal converges to the reciprocal of that value.

For any type `α`, filter `f` on `α`, function `m` from `α` to `ENNReal`, and extended nonnegative real number `a`, `m` tends to `a` with respect to `f` if and only if the reciprocal function of `m` tends to the reciprocal of `a` with respect to `f`.


theorem convex_iff_ordConnected :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] {s : Set 𝕜}, Convex 𝕜 s ↔ Set.OrdConnected s := by sorry

The theorem `convex_iff_ordConnected` establishes an equivalence between the convexity of a set and the ordered connectedness of that set, in the context of a linearly ordered field. Specifically, for every type `𝕜`, given that `𝕜` is a linearly ordered field and `s` is a set of `𝕜`, the set `s` is convex if and only if it is ordered connected. In other words, a set in a linearly ordered field is convex if every point between any two points in the set is also contained in the set.

A set in a linearly ordered field is convex if and only if it is ordered connected. (That is, a set is convex if every pair of its elements have every element between them also in the set.)


/-- A multiplicative isomorphism of monoids sends `1` to `1` (and is hence a monoid isomorphism).  -/
theorem MulEquiv.map_one :
    ∀ {M : Type u_6} {N : Type u_7} [inst : MulOneClass M] [inst_1 : MulOneClass N] (h : M ≃* N), h 1 = 1 := by sorry

This theorem states that for all multiplicative isomorphisms between two monoids (which are structures equipped with an associative multiplication operation and an identity element), the identity element (denoted by `1`) of the first monoid is mapped to the identity element of the second monoid. Therefore, a multiplicative isomorphism preserves the identity element in a monoid structure.

Given two monoids with multiplicative isomorphisms between them, the identity elements are mapped to each other under the isomorphisms.


/-- To show that two subobjects are equal, it suffices to exhibit an isomorphism commuting with
the arrows.  -/
theorem CategoryTheory.Subobject.mk_eq_mk_of_comm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B)
      [inst_1 : CategoryTheory.Mono f] [inst_2 : CategoryTheory.Mono g] (i : A₁ ≅ A₂),
      CategoryTheory.CategoryStruct.comp i.hom g = f → CategoryTheory.Subobject.mk f = CategoryTheory.Subobject.mk g :=
  by sorry

The theorem `CategoryTheory.Subobject.mk_eq_mk_of_comm` states that in order to prove the equality of two subobjects in a category, it is sufficient to demonstrate an isomorphism that commutes with the morphisms of those subobjects. More specifically, given a category `C`, objects `B`, `A₁`, and `A₂` in `C`, and morphisms `f : A₁ ⟶ B`, `g : A₂ ⟶ B` (with `f` and `g` being monomorphisms), if there exists an isomorphism `i : A₁ ≅ A₂` such that the composition of `i.hom` and `g` equals `f`, then the subobject created by `f` is equal to the subobject created by `g`. In other words, the subobjects represented by `f` and `g` are essentially the same if there is a way to "rearrange" `A₁` into `A₂` that plays nicely with `f` and `g`.

Given a category C, monomorphisms f : A₁ ⟶ B and g : A₂ ⟶ B, if there exists an isomorphism i : A₁ ≅ A₂ such that g ∘ i.hom = f, then the subobjects of A₁ and A₂ determined by f and g are equal.


theorem exists_eq_mul_left_of_dvd : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b : α}, a ∣ b → ∃ c, b = c * a := by
  sorry

This theorem states that for any commutative semigroup `α` and any elements `a` and `b` of `α`, if `a` divides `b` then there exists an element `c` in `α` such that `b` can be expressed as the product of `c` and `a`. In other words, if `a` is a divisor of `b` in a commutative semigroup, then `b` is equal to `a` multiplied by some element.

In a commutative semigroup, if one element is a divisor of another, then they are related by multiplication with some other element in the semigroup.


theorem Filter.frequently_cofinite_iff_infinite :
    ∀ {α : Type u_2} {p : α → Prop}, (∃ᶠ (x : α) in Filter.cofinite, p x) ↔ Set.Infinite {x | p x} := by sorry

This theorem states that for any type `α` and a property `p` defined for elements of `α`, the property `p` frequently holds for `x` in the cofinite filter of `α` if and only if the set of all `x` for which `p x` is true is infinite. Here, the "cofinite filter" is the collection of subsets of `α` whose complements are finite, and a set is defined as "infinite" if it is not a finite set. In other words, we can frequently find elements satisfying `p` in the cofinite filter if and only if there are infinitely many elements satisfying `p`.

A property `p` holds frequently in the cofinite filter of a type `α` if and only if the set of elements satisfying `p` is infinite.


MeasureTheory.Adapted.neg

theorem MeasureTheory.Adapted.neg :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : TopologicalSpace β]
      [inst_1 : Preorder ι] {u : ι → Ω → β} {f : MeasureTheory.Filtration ι m} [inst_2 : AddGroup β]
      [inst_3 : TopologicalAddGroup β], MeasureTheory.Adapted f u → MeasureTheory.Adapted f (-u) :=
  by sorry

The theorem `MeasureTheory.Adapted.neg` states that for any type `Ω`, any topological space `β`, any preorder `ι`, and any measurable space `m`, if a sequence of functions `u` (from `ι` to `β`) is adapted to a filtration `f` (from `ι` to `m`), then the negative of that sequence of functions `-u` is also adapted to the same filtration `f`. Here, `β` is assumed to be an additive group and a topological additive group.

If `u: ι → β` is an adapted sequence of functions to filtration `f: ι → m` over measurable space `(Ω, m)`, then the sequence `-u` is also adapted to filtration `f`.


theorem MeasureTheory.IsAddFundamentalDomain.measure_eq_tsum :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
      {s : Set α} {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableVAdd G α]
      [inst_5 : MeasureTheory.VAddInvariantMeasure G α μ] [inst_6 : Countable G],
      MeasureTheory.IsAddFundamentalDomain G s μ → ∀ (t : Set α), ↑↑μ t = ∑' (g : G), ↑↑μ ((g +ᵥ t) ∩ s) :=
  by sorry

This theorem, named `MeasureTheory.IsAddFundamentalDomain.measure_eq_tsum`, asserts the following: for any additively group-structured type `G` and any type `α`, given that `G` is an additive action on `α`, `α` is a measurable space, `s` is a set in `α`, `μ` is a measure on `α`, `G` is a measurable space, `G` is measurably v-additive in `α`, `μ` is v-add invariant measure in `G` and `α`, and `G` is countable, if `s` is an additive fundamental domain of `G` with respect to `μ`, then for any set `t` in `α`, the measure of `t` is equal to the sum of the measures of the sets obtained by translating `t` by each element of `G` and taking the intersection with `s`. The theorem uses summation symbol ∑' to represent the summation over the countable set `G`.

If `G` is a countable, measurably additive group acting on the measurable space `(α, μ)`, `s` is an additive fundamental domain of `G`, then for any set `t` in `α`, the measure of `t` equals the sum of the measures of `t ∩ s` for all translations `g ∈ G`.


theorem Nat.Partrec'.of_eq :
    ∀ {n : ℕ} {f g : Vector ℕ n →. ℕ}, Nat.Partrec' f → (∀ (i : Vector ℕ n), f i = g i) → Nat.Partrec' g := by sorry

The theorem `Nat.Partrec'.of_eq` states that for any natural number `n` and any two partial recursive functions `f` and `g` from a vector of `n` natural numbers to a natural number, if `f` is partial recursive and `f` and `g` are equal for every `i` of type `Vector ℕ n`, then `g` is also partial recursive. Here, `Nat.Partrec'` refers to partial recursive functions and `Vector ℕ n` indicates a list of length `n` with elements being natural numbers. This theorem essentially guarantees the preservation of partial recursion under pointwise equality.

If two partial recursive functions from a vector of natural numbers to a natural number agree on every input vector, then the second function is also partial recursive.


theorem MeasureTheory.tilted_of_not_integrable :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      ¬MeasureTheory.Integrable (fun x => Real.exp (f x)) μ → μ.tilted f = 0 :=
  by sorry

The theorem `MeasureTheory.tilted_of_not_integrable` states that for any type `α` with an associated measurable space `mα` and a measure `μ` of that space, and for any function `f` that maps from `α` to the real numbers, if the function that applies the real exponential function to the result of `f` (i.e., `fun x => Real.exp (f x)`) is not integrable with respect to the measure `μ`, then the tilted measure of `μ` with respect to `f` is `0`. In mathematical terms, this theorem asserts that if $\int \exp(f(x)) d\mu$ is not finite, then the tilted measure of `μ` with `f` is zero.

If the exponential function of the integrable function `f` is not integrable with respect to measure `μ` on type `α`, then the tilted measure of `μ` by `f` is zero.


theorem sdiff_sdiff_eq_self : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], y ≤ x → x \ (x \ y) = y :=
  by sorry

This theorem states that for any type `α` that forms a Generalized Boolean Algebra, and for any elements `x` and `y` of that type; if `y` is less than or equal to `x`, then the symmetric difference of `x` and the symmetric difference of `x` and `y` equals `y`. In mathematical terms, this theorem can be expressed as: if `y ≤ x`, then `x \ (x \ y) = y`. The backslash (`\`) operation represents the symmetric difference in this context.

For any type `α` forming a Generalized Boolean Algebra and elements `x` and `y` of `α` with `y ≤ x`, we have `x \ (x \ y) = y`.


/-- The edist to a set is `< r` iff there exists a point in the set at edistance `< r`  -/
theorem EMetric.infEdist_lt_iff :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s : Set α} {r : ENNReal},
      EMetric.infEdist x s < r ↔ ∃ y ∈ s, edist x y < r :=
  by sorry

This theorem states that in any pseudo-emetric space `α`, for any point `x` of type `α`, any set `s` of type `α`, and any extended nonnegative real number `r`, the minimal edistance (`EMetric.infEdist`) from point `x` to the set `s` is less than `r` if and only if there exists a point `y` in the set `s` such that the edistance from `x` to `y` is less than `r`. In other words, the smallest distance from a point to a set is less than a given value if and only if there is some point in the set that is less than that given value away.

In a pseudo-metric space, the infimum of the distances from a point to a set equals the minimum distance to any point in the set.


theorem Nat.Coprime.coprime_dvd_right : ∀ {n m k : ℕ}, n ∣ m → Nat.Coprime k m → Nat.Coprime k n := by sorry

The theorem `Nat.Coprime.coprime_dvd_right` states that for all natural numbers `n`, `m`, and `k`, if `n` divides `m` and `k` is coprime to `m` (i.e., the greatest common divisor of `k` and `m` is 1), then `k` is also coprime to `n` (i.e., the greatest common divisor of `k` and `n` is also 1). This expresses a property of coprime numbers in number theory, specifically addressing the scenario when a number `n` that divides another number `m` maintains coprimality with a number `k` if `k` is already coprime to `m`.

If `n` divides `m`, and `k` is coprime to `m`, then `k` is coprime to `n`.


theorem Nat.div_lt_iff_lt_mul' : ∀ {a b c : ℕ}, 0 < b → (a / b < c ↔ a < c * b) := by sorry

This theorem, `Nat.div_lt_iff_lt_mul'`, states that for all natural numbers `a`, `b`, and `c`, if `b` is greater than zero, then `a` divided by `b` is less than `c` if and only if `a` is less than `c` multiplied by `b`. In other words, it establishes a relationship between division and multiplication in terms of inequality for natural numbers.

For all natural numbers `a`, `b`, and `c` with `b > 0`, `a / b < c` if and only if `a < c * b`.


theorem Mathlib.Data.Nat.Defs._auxLemma.31 : ∀ {i : ℕ}, (i ≤ 0) = (i = 0) := by sorry

This theorem, `Mathlib.Data.Nat.Defs._auxLemma.31`, states that for any natural number `i`, `i` is less than or equal to `0` if and only if `i` equals `0`. In other words, the only natural number less than or equal to `0` is `0` itself.

For any natural number `i`, `i` is less than or equal to `0` if and only if `i` equals `0`.


theorem Mathlib.MeasureTheory.Function.ContinuousMapDense._auxLemma.14 :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ = MeasureTheory.Memℒp f 1 μ :=
  by sorry

This theorem states that for any types `α` and `β`, any measurable space `m` over `α`, any measure `μ` over `α`, and any function `f` from `α` to `β` in a normed additive commutative group, the function `f` is integrable with respect to the measure `μ` if and only if `f` is almost everywhere strongly measurable and the real-numbered power mean of the norm of `f` with exponent 1 (also known as the L1 norm of `f`) is finite with respect to `μ`. In mathematical terms, it asserts that $\int ‖f a‖ \, dμ < ∞$ is equivalent to the condition that $\left(\int ‖f a‖^1 \, dμ\right)^{1/1} < ∞$.

A function between measurable spaces is integrable with respect to a measure if and only if it is almost everywhere strongly measurable and has finite L1 norm with respect to that measure.


/-- An element `k` is compact if and only if any directed set with `sSup` above
`k` already got above `k` at some point in the set.  -/
theorem CompleteLattice.isCompactElement_iff_le_of_directed_sSup_le :
    ∀ (α : Type u_2) [inst : CompleteLattice α] (k : α),
      CompleteLattice.IsCompactElement k ↔
        ∀ (s : Set α), Set.Nonempty s → DirectedOn (fun x x_1 => x ≤ x_1) s → k ≤ sSup s → ∃ x ∈ s, k ≤ x :=
  by sorry

An element `k` in a complete lattice is compact if and only if for any directed set, if the supremum (`sSup`) of the set is greater than or equal to `k`, then there exists an element in the set that is greater than or equal to `k`. Put in another way, a compact element in a complete lattice is one where, if the set's supremum is at least as big as the element, then there is a point in the set where we already reached or exceeded the value of the compact element. This point is reached without the need for the entire set, and this captures the intuition behind the compactness of the element. The directedness of the set ensures that for any two elements in the set, there is a third element that is greater than or equal to both.

A complete lattice element `k` is compact if and only if for every directed set with supremum greater than or equal to `k`, there exists an element in the set that is greater than or equal to `k`.


theorem hyperoperation_ge_three_eq_one : ∀ (n m : ℕ), hyperoperation (n + 3) m 0 = 1 := by sorry

The theorem `hyperoperation_ge_three_eq_one` states that for all natural numbers `n` and `m`, the `n+3`rd hyperoperation applied to `m` and `0` is always equal to `1`. Here, the hyperoperation is a sequence of operations defined such that `hyperoperation n m k` is the `n`th operation applied between `m` and `k`.

For all natural numbers n and m, the n+3-th hyperoperation between m and 0 is equal to 1.


theorem Nat.mem_factors_mul :
    ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → ∀ {p : ℕ}, p ∈ Nat.factors (a * b) ↔ p ∈ Nat.factors a ∨ p ∈ Nat.factors b := by sorry

The theorem `Nat.mem_factors_mul` states that for any two natural numbers `a` and `b`, if neither `a` nor `b` are zero, then a natural number `p` is in the prime factorization of the product `a * b` if and only if `p` is in the prime factorization of `a` or `p` is in the prime factorization of `b`. This expresses that the prime factors of a product of two non-zero numbers are exactly the union of the prime factors of the individual numbers.

The prime factors of the product of two non-zero natural numbers are the same as the union of their prime factor sets.


theorem pow_ne_of_irreducible_X_pow_sub_C :
    ∀ {K : Type u} [inst : Field K] {n : ℕ} {a : K},
      Irreducible (Polynomial.X ^ n - Polynomial.C a) → ∀ {m : ℕ}, m ∣ n → m ≠ 1 → ∀ (b : K), b ^ m ≠ a :=
  by sorry

This theorem states that for any field `K` and any natural numbers `n` and `m`, and any elements `a` and `b` of the field `K`, if the polynomial `X^n - a` is irreducible, and if `m` divides `n` but `m` is not equal to 1, then `b^m` is not equal to `a`. In other words, no non-trivial root of the irreducible polynomial `X^n - a` raises to the power `m` equals to the constant `a`.

If `n` divides the degree of an irreducible polynomial `X^n - a` over a field `K`, and `m` is a positive integer divisor of `n` with `m ≠ 1`, then `a ≠ b^m` for any element `b` in `K`.


theorem Mathlib.Topology.FiberBundle.Basic._auxLemma.4 : ∀ (p : Prop), (p ∧ True) = p := by sorry

This theorem, denoted as `Mathlib.Topology.FiberBundle.Basic._auxLemma.4`, states that for any proposition `p`, the logical conjunction of `p` and `True` is equivalent to `p`. In other words, `p` and `True` together always return the value of `p`. This is because `True` is a tautology, a statement that is always true, and hence it does not affect the truth value of `p` when conjoined with it.

For any proposition `p`, `p` and `True` are logically equivalent.


theorem Equiv.Perm.sign_swap :
    ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] {x y : α},
      x ≠ y → Equiv.Perm.sign (Equiv.swap x y) = -1 :=
  by sorry

The theorem `Equiv.Perm.sign_swap` states that for any type `α` with decidable equality and finiteness, and for any distinct elements `x` and `y` of `α`, the sign of the permutation that swaps `x` and `y` is `-1`. In other words, the permutation that merely swaps two distinct elements is considered an odd permutation.

For any type `α` with decidable equality and finiteness, the permutation that swaps two distinct elements `x` and `y` in `α` has determinant -1.


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

This theorem pertains to the coefficients of a formal power series over a semiring. Specifically, for any semiring `R` and any natural numbers `m` and `n`, it states that the `m`th coefficient of the `n`th power of the power series variable (denoted by `PowerSeries.X ^ n`) is `1` if `m` is equal to `n`, and `0` otherwise. This theorem characterizes a significant property of formal power series, which parallels the similar property of monomials in polynomial rings, where the coefficient of `x^n` in `x^m` is `1` when `m = n` and `0` otherwise.

For any semiring `R`, the `m`th coefficient of `PowerSeries.X ^ n` is `1` if `m = n`, and `0` otherwise.


theorem CategoryTheory.MorphismProperty.StableUnderComposition.respectsIso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.StableUnderComposition P →
        (∀ {X Y : C} (e : X ≅ Y), P e.hom) → CategoryTheory.MorphismProperty.RespectsIso P :=
  by sorry

In the context of a category `C`, this theorem states that for any given morphism property `P` that is stable under composition, if `P` holds for any morphism that is an isomorphism, then `P` respects isomorphisms. More specifically, it means that if a morphism `f` has property `P`, then both the composition of `f` with any isomorphism before `f`, and the composition of `f` with any isomorphism after `f`, still have the property `P`.

If a morphism property `P` is stable under composition and holds for all isomorphisms in a category `C`, then `P` is respected by compositions with isomorphisms in `C`.


theorem Equiv.Perm.cycleOf_apply_of_not_sameCycle :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x y : α},
      ¬Equiv.Perm.SameCycle f x y → (Equiv.Perm.cycleOf f x) y = y :=
  by sorry

The theorem `Equiv.Perm.cycleOf_apply_of_not_sameCycle` states that for any type `α` with decidable equality and finiteness, given a permutation `f` over `α` and any two elements `x` and `y` of `α`, if `x` and `y` do not belong to the same cycle of permutation `f` (`¬Equiv.Perm.SameCycle f x y`), then applying the cycle of `f` that contains `x` to `y` leaves `y` unchanged, i.e., `(Equiv.Perm.cycleOf f x) y = y`. In other words, if `x` and `y` are in different cycles of a permutation, the cycle of `x` does not affect `y`.

If `x` and `y` are not in the same cycle of a permutation `f` over a type `α` with decidable equality and finiteness, then applying the cycle of `f` that contains `x` to `y` leaves `y` unchanged.


/-- A subset of an `AddMonoid` is contained in the `AddSubmonoid` it generates. -/
theorem AddMonoid.subset_closure : ∀ {M : Type u_1} [inst : AddMonoid M] {s : Set M}, s ⊆ AddMonoid.Closure s := by
  sorry

This theorem states that for any given set `s` which is a subset of an additive monoid `M`, the set `s` is a subset (or is contained within) the additive submonoid generated by `s` itself. In other words, every element of `s` is also an element of the additive submonoid that `s` generates. This is a fundamental property in the study of monoids and their subsets.

For any subset `s` of an additive monoid `M`, `s` is contained in the additive submonoid generated by `s`.


theorem abs_min_sub_min_le_max :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b c d : α), |min a b - min c d| ≤ max |a - c| |b - d| := by
  sorry

This theorem states that for any four values of a linear ordered additive commutative group type, the absolute value of the difference between the minimum of the first two values and the minimum of the last two values is always less than or equal to the maximum of the absolute values of the differences between the first and third values and the second and fourth values. In mathematical terms, for any elements $a$, $b$, $c$, $d$ in a linear ordered additive commutative group, $| \min(a, b) - \min(c, d) | \leq \max(|a - c|, |b - d|)$.

For any elements $a, b, c, d$ in a linear ordered additive commutative group, the absolute difference between the minimum of $a$ and $b$ and the minimum of $c$ and $d$ is less than or equal to the maximum of the absolute differences between $a$ and $c$, and $b$ and $d$. In symbols, $| \min(a, b) - \min(c, d) | \leq \max(|a - c|, |b - d|)$.


theorem inv_mul_lt_iff_lt_mul :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b c : α}, b⁻¹ * a < c ↔ a < b * c :=
  by sorry

This theorem, `inv_mul_lt_iff_lt_mul`, expresses a property of multiplication in a group with a certain order. Specifically, for all elements `a`, `b`, and `c` of some type `α` which forms a group and has an order (`<`), the statement that `b⁻¹ * a` is less than `c` is equivalent to the statement that `a` is less than `b * c`. This equivalence holds true under the assumption that the multiplication operation `*` of the group is left covariant with respect to the order `<`.

In a group with a total order, the multiplicative inverses commute with respect to the order, that is, for all `a, b, c` in the group, `b^-1 * a < c` is equivalent to `a < b * c` if and only if multiplication is left covariant with respect to the order.


theorem Filter.Iic_principal : ∀ {α : Type u} (s : Set α), Set.Iic (Filter.principal s) = {l | s ∈ l} := by sorry

This theorem states that for any set `s` of a certain type `α`, the left-infinite right-closed interval of the principal filter of `s` is equivalent to the set of all sets `l` that contain `s`. In other words, when we take the principal filter of a set `s` (which is the collection of all supersets of `s`) and apply the operation `Set.Iic` (which represents a left-infinite right-closed interval), we end up with the set of all sets `l` where `s` is a member.

The principal filter of a set `s` equals the set of all sets containing `s` up to right-closed intervals.


theorem AdjoinRoot.root_isInv :
    ∀ {R : Type u} [inst : CommRing R] (r : R),
      (AdjoinRoot.of (Polynomial.C r * Polynomial.X - 1)) r * AdjoinRoot.root (Polynomial.C r * Polynomial.X - 1) = 1 :=
  by sorry

This theorem states that for any type `R` that forms a commutative ring, and any element `r` of this ring, the product of the embedding of `r` into the ring adjoined by the root of the polynomial `rX - 1` and the adjoined root of the polynomial `rX - 1` is equal to 1. In essence, it means that in the new ring formed by adjoining a root of the polynomial `rX - 1` to the original ring, the adjoined root serves as the multiplicative inverse of `r`.

For any commutative ring `R` and its element `r`, the element `r` and the root of `rX - 1` adjoined to `R` form an invertible pair, i.e., their product equals 1 in the extended ring.


theorem gauge_mono :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s t : Set E},
      Absorbent ℝ s → s ⊆ t → gauge t ≤ gauge s :=
  by sorry

The theorem `gauge_mono` is stating that for any type `E` that has the structure of a real vector space (i.e., `E` is an additive commutative group and a module over the real numbers), given two sets `s` and `t` of elements of `E`, if `s` is an *absorbent* set (meaning it absorbs every singleton) and `s` is a subset of `t`, then the Minkowski functional (or *gauge*) of `t` is less than or equal to the Minkowski functional of `s`. In other words, if a set `s` has these properties, any scaling of `t` needed to contain a vector `x` will be no greater than the scaling of `s` needed to contain `x`.

If `s` is an absorbent subset of a real vector space `E` that is a subset of another set `t`, then the Minkowski functional of `t` is less than or equal to that of `s`.


theorem SetTheory.PGame.neg_lt_neg_iff : ∀ {x y : SetTheory.PGame}, -y < -x ↔ x < y := by sorry

This theorem states that for any two games `x` and `y` in set theory, the negative of `y` is less than the negative of `x` if and only if `x` is less than `y`. This is a reflection of the property of order inversion when multiplying by a negative number in real numbers.

For any two sets x and y, -x < -y if and only if x < y.


theorem Int.add_mul_emod_self : ∀ {a b c : ℤ}, (a + b * c) % c = a % c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, the modulo of the sum of `a` and the product of `b` and `c` with `c` is equal to the modulo of `a` with `c`. In mathematical notation, this can be written as `(a + b * c) mod c = a mod c`.

For any integers `a`, `b`, and `c`, `(a + b * c) % c = a % c`.


MeasureTheory.IsStoppingTime.min

theorem MeasureTheory.IsStoppingTime.min :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ π : Ω → ι},
      MeasureTheory.IsStoppingTime f τ →
        MeasureTheory.IsStoppingTime f π → MeasureTheory.IsStoppingTime f fun ω => min (τ ω) (π ω) :=
  by sorry

This theorem states that for any two stopping times `τ` and `π` with respect to a given filtration `f`, the stopping time function that takes the minimum of `τ ω` and `π ω` for each ω is also a stopping time. In more intuitive terms, given two stopping rules described by `τ` and `π`, the rule that stops at the earlier of the two times is also a valid stopping rule. This result applies in any measurable space `Ω` with a linear order on the index set `ι`.

Given stopping times `τ` and `π` in a measurable space with a linear order, the minimum `τ ∧π` is also a stopping time.


theorem Homeomorph.image_interior :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (s : Set X),
      ⇑h '' interior s = interior (⇑h '' s) :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with respective topological spaces (`TopologicalSpace X` and `TopologicalSpace Y`), if there is a homeomorphism `h` between `X` and `Y`, then the image under `h` of the interior of a set `s` of type `X` (denoted `⇑h '' interior s`) is equal to the interior of the image of set `s` under the homeomorphism `h` (denoted `interior (⇑h '' s)`). In simpler terms, it asserts that a homeomorphism preserves the concept of "interior of a set" when mapping from one topological space to another.

Given topological spaces `X` and `Y` with homeomorphism `h`, the interior of `h(s)` is equal to `h(interior s)` for any set `s` in `X`.


/-- **Alias** of the reverse direction of `half_le_self_iff`. -/
theorem half_le_self : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 0 ≤ a → a / 2 ≤ a := by sorry

This theorem, `half_le_self`, states that for any type `α` that is a `LinearOrderedSemifield` (a structure that combines the properties of an ordered ring and a field), for any non-negative element `a` of this type, half of `a` is always less than or equal to `a`. This theorem essentially captures the intuitive mathematical idea that half of a non-negative number is always less than or equal to the number itself.

For any non-negative element `a` in a LinearOrderedSemifield, `0 < a => 0.5 * a <= a`.


theorem mem_rootsOfUnity :
    ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ+) (ζ : Mˣ), ζ ∈ rootsOfUnity k M ↔ ζ ^ ↑k = 1 := by sorry

This theorem states that for any commutative monoid `M` and any element `ζ` in the multiplicative group of `M`, `ζ` is a member of the roots of unity of order `k` in `M` if and only if `ζ` raised to the power `k` equals 1. In other words, an element belongs to the `k`-th roots of unity in a given commutative monoid if it satisfies the property that its `k`-th power equals the multiplicative identity.

An element `ζ` in a commutative monoid `M` is a `k`-th root of unity if and only if `ζ^k = 1`.


theorem IntermediateField.minpoly_gen :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (α : E),
      minpoly F (IntermediateField.AdjoinSimple.gen F α) = minpoly F α :=
  by sorry

This theorem states that for all field `F` and `E` such that `E` is an algebra over `F`, and for any element `α` in `E`, the minimal polynomial of `α` when considered as an element of the field obtained by adjoining `α` to `F`, i.e., `F⟮α⟯`, is the same as the minimal polynomial of `α` in `F`. The minimal polynomial is the monic polynomial of least degree that has `α` as a root.

The minimal polynomial of an element `α` in an algebra `E` over a field `F` is equal to the minimal polynomial of `α` considered as an element of the field extension `F(α)`.


HasFDerivAtFilter.neg

theorem HasFDerivAtFilter.neg :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L → HasFDerivAtFilter (fun x => -f x) (-f') x L :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, which are also normed spaces over the field `𝕜`, and any function `f : E → F` with a continuous linear derivative `f'` at a point `x` under a filter `L`, the function obtained by negating `f` also has a continuous linear derivative, which is the negation of `f'`, at the same point `x` under the same filter `L`. In other words, the derivative of the negation of a function is the negation of the derivative of the original function.

If `f : E → F` is a continuously differentiable function between normed spaces over a nontrivially normed field, then `(−f)' = −(f)'` at a point `x` under filter `L`.


theorem mem_leftAddCoset_iff :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : Set α} {x : α} (a : α), x ∈ a +ᵥ s ↔ -a + x ∈ s := by sorry

This theorem states that for all types `α` which form an additive group, given a set `s` of elements of type `α`, an element `x` of type `α`, and another element `a` of type `α`, `x` belongs to the coset formed by adding `a` to every element of `s` if and only if the element obtained by adding the additive inverse of `a` to `x` belongs to `s`. In mathematical terms, this theorem can be represented as follows: For any additive group `α` and any subset `s` in `α`, $x \in a + s$ if and only if $-a + x \in s$.

For any additive group `α` and subset `s`, an element `x` belongs to the coset `a + s` if and only if `x` is congruent to an element in `s` modulo `a`, i.e., `x ≡ s (mod a)`.


LinearIndependent.mono

theorem LinearIndependent.mono :
    ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {t s : Set M},
      t ⊆ s → (LinearIndependent R fun (x : ↑s) => ↑x) → LinearIndependent R fun (x : ↑t) => ↑x :=
  by sorry

The theorem `LinearIndependent.mono` states that for any semiring `R`, any set `M` endowed with the structure of an additive commutative monoid and an `R`-module, and any two subsets `t` and `s` of `M`, if `t` is a subset of `s`, and if the family of vectors indexed by `s` is linearly independent over `R`, then the family of vectors indexed by `t` is also linearly independent over `R`. In other words, if a set of vectors is linearly independent, then any subset of that set is also linearly independent.

If a subset of a linearly independent set in an `R`-module over a semiring `R` is included in the original set, then the smaller subset is also linearly independent.


theorem norm_div_le : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a b : E), ‖a / b‖ ≤ ‖a‖ + ‖b‖ := by sorry

This theorem states that for any two elements `a` and `b` in a seminormed group `E`, the norm of their division `a / b` is less than or equal to the sum of their individual norms. In other words, it states that in a seminormed group, the norm of the quotient of two elements is always less than or equal to the sum of the norms of the two elements. This can be written in mathematical notation as ‖a / b‖ ≤ ‖a‖ + ‖b‖.

In a seminormed group, the norm of the quotient of two elements is less than or equal to the sum of their individual norms: ‖a / b‖ ≤ ‖a‖ + ‖b‖.


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

The theorem `MeasureTheory.set_integral_nonneg_of_ae_restrict` states that for any measurable space `X`, given a measure `μ` on `X`, a real-valued function `f` on `X`, and a set `s` of `X`, if the function `f` is nonnegative almost everywhere with respect to the measure `μ` restricted to the set `s`, then the Lebesgue integral of `f` over the set `s` with respect to the measure `μ` is also nonnegative. In other words, if a function is almost everywhere nonnegative when limited to a certain set, the integral over that set will be nonnegative as well.

If a measurable function is almost everywhere nonnegative on a set with respect to a measure, then the Lebesgue integral of the function over that set with respect to the measure is nonnegative.


theorem QuotientAddGroup.mk_add_of_mem :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {b : α} (a : α), b ∈ s → ↑(a + b) = ↑a := by sorry

This theorem states that for any given type `α` which has an `AddGroup` structure, and for any given add subgroup `s` of `α`, and for any element `b` of `α`, if `b` is in `s`, then the additive quotient group element of `a + b` is equal to the quotient group element of `a`. Here, `a` and `b` are elements of `α`, `s` is an additive subgroup of `α`, and the ↑ operator is used to represent the natural projection from `α` to the quotient group `α/s`.

If `α` is a type with an AddGroup structure, `s` is an additive subgroup of `α`, and `b` is an element of `α` in `s`, then `↑(a + b) = ↑a` for all `a` in `α`.


theorem Finsupp.toMultiset_zero : ∀ {α : Type u_1}, Finsupp.toMultiset 0 = 0 := by sorry

The theorem `Finsupp.toMultiset_zero` states that for any type `α`, the `Finsupp.toMultiset` function applied to the zero finitely supported function (or `finsupp`) results in the zero multiset. In other words, when there are no elements in the domain `α` with non-zero natural number values (as given by the zero `finsupp`), the resulting multiset (a generalization of sets that includes multiple instances of elements) is also empty.

For any type `α`, the `Finsupp.toMultiset` of the zero finitely supported function is the empty multiset.


theorem List.permutationsAux_nil : ∀ {α : Type u_1} (is : List α), List.permutationsAux [] is = [] := by sorry

The theorem `List.permutationsAux_nil` states that for any type `α` and for any list `is` of that type, when we apply the auxiliary function `List.permutationsAux` on an empty list and `is`, the result is always an empty list. This means that there are no permutations of `is` appended with an empty list that do not fix the empty list.

For any type `α` and list `is : List α`, the auxiliary function `List.permutationsAux` applied to the empty list and `is` returns an empty list. In other words, there are no non-empty permutations of `is` when appended with the empty list.


theorem MeasureTheory.AEEqFun.zero_toGerm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] [inst_2 : Zero β], MeasureTheory.AEEqFun.toGerm 0 = 0 :=
  by sorry

The theorem `MeasureTheory.AEEqFun.zero_toGerm` states that for any measurable space `α`, a measure `μ` on that space, and any topological space `β` that has a zero element, the germ of the zero function (which maps every element of `α` to the zero element of `β`) under the measure `μ` is also the zero element. In other words, when we convert the "almost everywhere equal" zero function to a germ with respect to `μ`, we get the zero germ.

For any measurable space `α`, measure `μ` on `α`, and topological space `β` with a zero element, the germ of the constant zero function from `α` to `β` with respect to `μ` is equal to the zero germ.


theorem Mathlib.Analysis.Convex.Slope._auxLemma.1 :
    ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] (a b : K), -(b / a) = -b / a := by sorry

This theorem, `Mathlib.Analysis.Convex.Slope._auxLemma.1`, states that for any type `K` which has a division operation (making it a `DivisionMonoid`) and a negation operation that distributes over addition (`HasDistribNeg`), for any two elements `a` and `b` of that type, the negation of the fraction `b / a` is equal to the negation of `b` divided by `a`. In mathematical notation, it verifies the property - (b / a) = -b / a for all `a` and `b` in the set `K`.

For any type `K` with division and negation operations satisfying distribution, the negation of the quotient `b / a` equals `-b / a` for all `a, b` in `K`.


theorem PLift.up_surjective : ∀ {α : Sort u}, Function.Surjective PLift.up := by sorry

This theorem states that for any type `α`, the function `PLift.up` is surjective. In mathematical terms, this means that for any value `b` of the type `PLift α` (which can be described as a type that contains a single element of type `α`), there exists a value `a` of type `α` such that `PLift.up a` equals `b`. In other words, every value of the lifted type `PLift α` can be obtained by lifting some value from the original type `α`.

For any type `α`, the function `PLift.up` is a surjection from `α` to `PLift α`.


theorem prod_mem_nhds :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {t : Set Y}
      {x : X} {y : Y}, s ∈ nhds x → t ∈ nhds y → s ×ˢ t ∈ nhds (x, y) :=
  by sorry

This theorem states that for any two topological spaces `X` and `Y`, and any sets `s` and `t` where `s` is a neighborhood of a point `x` in `X` and `t` is a neighborhood of a point `y` in `Y`, the Cartesian product of `s` and `t` is a neighborhood of the point `(x, y)` in the product space `X × Y`. In other words, if `s` is near `x` and `t` is near `y`, then `s × t` is near `(x, y)`. This is a property that intuitively makes sense in the context of topological spaces, and forms a fundamental part of the definition of a product topology.

Given topological spaces X and Y, and neighborhoods s of a point x in X and t of a point y in Y, the product neighborhood s × t in X × Y is a neighborhood of (x, y).


theorem AddSubgroup.inf_relindex_right :
    ∀ {G : Type u_1} [inst : AddGroup G] (H K : AddSubgroup G),
      AddSubgroup.relindex (H ⊓ K) K = AddSubgroup.relindex H K :=
  by sorry

The theorem `AddSubgroup.inf_relindex_right` states that for any given additive group `G` and any two subgroups `H` and `K` of `G`, the relative index of the intersection of `H` and `K` with respect to `K` is the same as the relative index of `H` with respect to `K`. Here, the relative index of a subgroup is a natural number that measures the "size" of the subgroup compared to another subgroup, and it returns 0 if the relative index is infinite.

The relative index of a subgroup `H` with respect to `K` in an additive group `G` equals the relative index of `H` intersected with `K` with respect to `K`.


theorem Mathlib.Data.PNat.Defs._auxLemma.3 : ∀ (n : ℕ+), (0 < ↑n) = True := by sorry

This theorem, `Mathlib.Data.PNat.Defs._auxLemma.3`, states that for all positive natural numbers `n` (denoted as `ℕ+`), the condition that `n` is greater than zero is always true. This result is expected because by definition, positive natural numbers are always greater than zero.

For all positive natural numbers `n`, `n` is greater than zero.


theorem measurable_id'' : ∀ {α : Type u_1} {m mα : MeasurableSpace α}, m ≤ mα → Measurable id := by sorry

This theorem states that for any type `α` and any two measurable spaces `m` and `mα` on `α`, if `m` is a subspace of `mα` (i.e., `m` is less than or equal to `mα`), then the identity function on `α` is measurable. In the context of measure theory, a function is "measurable" if the preimage of every measurable set is still measurable; hence, this theorem verifies that the identity function indeed satisfies this property given the conditions.

If `m` is a submeasure on `α` and `mα` is a measure on `α`, then the identity function on `α` is measurable with respect to `m` and `mα`.


theorem Set.neg_subset_neg : ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s t : Set α}, -s ⊆ -t ↔ s ⊆ t := by sorry

This theorem, `Set.neg_subset_neg`, states that for any type `α` that has an `InvolutiveNeg` (i.e., a negation operation that is its own inverse), and for any two sets `s` and `t` of this type, the set of negations of elements in `s` is a subset of the set of negations of elements in `t` if and only if `s` is a subset of `t`. This essentially means that the subset relation is preserved under the operation of taking negations of elements in these sets.

For sets `s` and `t` of a type `α` with an `InvolutiveNeg`, `neg s ⊆ neg t` if and only if `s ⊆ t`.


theorem AkraBazziRecurrence.isEquivalent_one_sub_smoothingFn_one :
    Asymptotics.IsEquivalent Filter.atTop (fun x => 1 - AkraBazziRecurrence.smoothingFn x) fun x => 1 := by sorry

The theorem `AkraBazziRecurrence.isEquivalent_one_sub_smoothingFn_one` states that the function `1 - AkraBazziRecurrence.smoothingFn x` is asymptotically equivalent to the constant function `1` when `x` approaches infinity. In other words, as `x` gets larger and larger, the difference between `1 - AkraBazziRecurrence.smoothingFn x` and `1` (i.e., the negative of the smoothing function which is `1 / log x`) becomes negligible compared to `1`. In mathematical terms, it means that lim_{x → ∞} [1 - (1 / log x) - 1] / 1 = 0.

The theorem `AkraBazziRecurrence.isEquivalent_one_sub_smoothingFn_one` asserts that the limit of `(1 - 1/log(x))/1` as `x` approaches infinity is equal to zero.


Equiv.bijOn

theorem Equiv.bijOn :
    ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) {s : Set α} {t : Set β},
      (∀ (a : α), e a ∈ t ↔ a ∈ s) → Set.BijOn (⇑e) s t :=
  by sorry

This theorem, named `Equiv.bijOn`, states that for any two types `α` and `β` and a function `e` which is a bijection between `α` and `β`, if for every element `a` of type `α` the property holds that `a` is in set `s` if and only if `e(a)` is in set `t`, then the function `e` is a bijection between set `s` of type `α` and set `t` of type `β`. Here, a bijection means that `e` is injective (no two different elements in `s` map to the same element in `t`) and surjective (every element in `t` is the image of some element in `s`) on the given sets.

If `e: α → β` is a bijection between types `α` and `β`, and for all `a: α`, `a ∈ s` if and only if `e(a) ∈ t`, then `e` is a bijection between sets `s ⊆ α` and `t ⊆ β`.


theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      (f : AddSubmonoid.LocalizationMap S N) {x₁ x₂ : M} {y₁ y₂ : ↥S},
      AddSubmonoid.LocalizationMap.mk' f x₁ y₁ = AddSubmonoid.LocalizationMap.mk' f x₂ y₂ ↔
        (AddSubmonoid.LocalizationMap.toMap f) (↑y₂ + x₁) = (AddSubmonoid.LocalizationMap.toMap f) (↑y₁ + x₂) :=
  by sorry

This theorem states that for any additive commutative monoid `M`, any additive submonoid `S` of `M`, any other additive commutative monoid `N`, and any localization map `f` from `S` to `N`, for any two elements `x₁` and `x₂` in `M`, and any two elements `y₁` and `y₂` in `S`, the two elements obtained by applying the localization map to the pairs `(x₁, y₁)` and `(x₂, y₂)` are equal if and only if the result of applying the map to the element `y₂ + x₁` is equal to the result of applying the map to the element `y₁ + x₂`. In other words, the equality of the images under the localization map of two pairs is equivalent to a certain equality involving the map's action on the sums of the pair elements.

For any additive commutative monoids M, N and localization map f from an additive submonoid S of M to N, the pairs (x, y) in MxS and (x', y') in SxS have the same image under f if and only if y + x = y' + x'.


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

This theorem, `Nat.mul_sub_right_distrib`, states that for any three natural numbers `n`, `m`, and `k`, the operation of subtracting `m` from `n` and then multiplying the result by `k` is the same as multiplying `n` and `m` separately by `k` and then subtracting the two results. In mathematical notation, this would be written as `(n - m) * k = n * k - m * k`. This theorem essentially establishes the right distributivity of multiplication over subtraction in the set of natural numbers.

For all natural numbers `n`, `m`, and `k`, `(n - m) * k = n * k - m * k`.


theorem Mathlib.Order.LiminfLimsup._auxLemma.19 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem, named `Mathlib.Order.LiminfLimsup._auxLemma.19`, states that for any two propositions `a` and `b`, the existence of `b` given `a` is equivalent to the conjunction of `a` and `b`. In other words, saying "there exists an `a` such that `b` is true" is the same as saying "`a` is true and `b` is true".

The theorem `Mathlib.Order.LiminfLimsup._auxLemma.19` in Lean 4 asserts that for all propositions `a` and `b`, `(∃x, a x) ∧ b` is equivalent to `a ∧ b`.


theorem List.nodup_range' :
    ∀ (s n : ℕ) (step : optParam ℕ 1), autoParam (0 < step) _auto✝ → List.Nodup (List.range' s n step) := by sorry

The theorem `List.nodup_range'` states that for any numbers `s` and `n`, and an optional parameter `step` (which defaults to 1), given that `step` is positive (which is checked automatically), the list produced by the `List.range'` function, which starts at `s` and has `n` steps each of size `step`, contains no duplicate elements.

For any integers `s`, `n`, and `step` with `step > 0`, the `List.range` from `s` of length `n` with step `step` contains no repeated elements.


theorem Nat.mul_self_le_mul_self_iff : ∀ {m n : ℕ}, m * m ≤ n * n ↔ m ≤ n := by sorry

This theorem states that for all natural numbers `m` and `n`, the condition of `m` squared (or `m` multiplied by itself) being less than or equal to `n` squared (or `n` multiplied by itself) is equivalent to `m` being less than or equal to `n`. This theorem essentially establishes a relation to compare the square of two natural numbers and the numbers themselves.

For all natural numbers m and n, m ^ 2 ≤ n ^ 2 if and only if m ≤ n.


/-- The multiset `nthRoots ↑n (1 : R)` has no repeated elements
if there is a primitive root of unity in `R`.  -/
theorem IsPrimitiveRoot.nthRoots_one_nodup :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R} {n : ℕ},
      IsPrimitiveRoot ζ n → Multiset.Nodup (Polynomial.nthRoots n 1) :=
  by sorry

The theorem `IsPrimitiveRoot.nthRoots_one_nodup` states that for any commutative ring `R` which is also an integral domain, for any element `ζ` in `R` and for any natural number `n`, if `ζ` is a primitive root of unity of order `n` then the multiset of `n`-th roots of unity in `R`, computed by the function `Polynomial.nthRoots`, contains no duplicate elements. In other words, if `ζ^n = 1` and `ζ` is a primitive root of unity, then each `n`-th root of unity in `R` is unique.

In a commutative integral domain, a primitive root of unity of order n in R has exactly n distinct n-th roots.


theorem antitone_Ici : ∀ {α : Type u_1} [inst : Preorder α], Antitone Set.Ici := by sorry

The theorem `antitone_Ici` states that for any preorder set `α`, the function `Set.Ici`, which produces left-closed right-infinite intervals, is antitone. In other words, if `a ≤ b` for any two elements `a` and `b` in the set `α`, then the interval starting from `b` is a subset of the interval starting from `a`.

For any preorder set α, the function Set.Ici returns left-closed right-infinite intervals, and these intervals are antitone, meaning that for all a ≤ b in α, the interval [a, ∞[ (Ici a) is contained in the interval [b, ∞[ (Ici b).


theorem Cardinal.nat_lt_continuum : ∀ (n : ℕ), ↑n < Cardinal.continuum := by sorry

The theorem `Cardinal.nat_lt_continuum` states that for every natural number `n`, the cardinality of `n` (when considered as a cardinal number) is strictly less than the cardinality of the continuum. In other words, no matter how large the natural number `n` is, the size of the set of all natural numbers is always smaller than the size of the real numbers (the continuum). This is expressed in the language of cardinal numbers, which are used to measure the size of sets.

For every natural number $n$, the cardinality of $n$ is strictly less than the cardinality of the continuum.


/-- Given three nonzero vectors, the angle between the first and the second plus the angle
between the second and the third equals the angle between the first and the third.  -/
theorem Orientation.oangle_add :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y z : V},
      x ≠ 0 → y ≠ 0 → z ≠ 0 → Orientation.oangle o x y + Orientation.oangle o y z = Orientation.oangle o x z :=
  by sorry

This theorem states that, for any inner product space of real numbers with a finite rank of 2 and a given orientation, given any three non-zero vectors, the sum of the oriented angles between the first and second vector and between the second and third vector is equal to the oriented angle between the first and third vector. In other words, this theorem confirms the angle addition property in a 2-dimensional real inner product space.

In a 2-dimensional real inner product space with finite rank and given orientation, the sum of the angles between any pair of vectors is equal to the angle between the vectors forming a triangle.


theorem Finset.range_subset : ∀ {n m : ℕ}, Finset.range n ⊆ Finset.range m ↔ n ≤ m := by sorry

The theorem `Finset.range_subset` states that for any two natural numbers `n` and `m`, the set of natural numbers less than `n` is a subset of the set of natural numbers less than `m` if and only if `n` is less than or equal to `m`. In other words, if all natural numbers less than `n` are also less than `m`, then `n` must be less than or equal to `m`.

For all natural numbers n and m, the set {i : ℕ | i < n} is subset of {i : ℕ | i < m} if and only if n ≤ m.


theorem Filter.map_inf_le :
    ∀ {α : Type u} {β : Type v} {f g : Filter α} {m : α → β}, Filter.map m (f ⊓ g) ≤ Filter.map m f ⊓ Filter.map m g :=
  by sorry

This theorem states that for any types `α` and `β`, any two filters `f` and `g` on `α`, and any function `m` from `α` to `β`, the map of the infimum (greatest lower bound) of the two filters `f` and `g` under the function `m` is less than or equal to the infimum of the maps of filters `f` and `g` under the function `m`. In mathematical terms, this can be written as `m(f ⊓ g) ≤ m(f) ⊓ m(g)`.

For any functions `m` from a type `α` to `β`, and filters `f` and `g` on `α`, the map of the infimum of `f` and `g` under `m` is less than or equal to the infimum of the maps of `f` and `g` under `m`, i.e., `m(f ⊓ g) ≤ m(f) ⊓ m(g)`.


theorem ZNum.cast_pos :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : Add α] [inst_3 : Neg α] (n : PosNum),
      ↑(ZNum.pos n) = ↑n :=
  by sorry

This theorem, `ZNum.cast_pos`, states that for any positive number `n` of type `PosNum`, its casting as `ZNum.pos n` is equal to its casting as `n`. Here, `α` is any type with zero, one, addition, and negation operations defined. In mathematical terms, it says that casting a positive integer `n` from the `PosNum` type to the `ZNum` type doesn't change its value.

For any positive number `n` of type `PosNum`, the cast `ZNum.pos n` is equal to `n`.


theorem Associates.factors_mk :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] (a : α),
      a ≠ 0 → Associates.factors (Associates.mk a) = ↑(Associates.factors' a) :=
  by sorry

The theorem `Associates.factors_mk` states that for any non-zero element `a` of a type `α`, where `α` is assumed to be a cancel commutative monoid with zero and has the property of unique factorization, the multiset of irreducible factors of the associate of `a` is equal to the multiset of irreducible factors of `a` itself. In mathematical terms, this means that the process of associating does not change the irreducible factors of `a` if `a` is nonzero.

For any non-zero element `a` in a cancel commutative monoid `α` with unique factorization, the multiset of irreducible factors of `a` is equal to the multiset of irreducible factors of its associate.