Measurable.mono

theorem Measurable.mono :
    ∀ {α : Type u_1} {β : Type u_2} {ma ma' : MeasurableSpace α} {mb mb' : MeasurableSpace β} {f : α → β},
      Measurable f → ma ≤ ma' → mb' ≤ mb → Measurable f :=
  by sorry

The theorem `Measurable.mono` states that for any two types `α` and `β`, if we have two measurable spaces `ma` and `ma'` over `α`, and two measurable spaces `mb` and `mb'` over `β`, and a function `f` from `α` to `β`, then if `f` is measurable, `ma` is a sub-measurable space of `ma'`, and `mb'` is a sub-measurable space of `mb`, then `f` is still measurable. Essentially, if a function is measurable in one set of spaces, it remains measurable in their superset spaces.

If `f` is a measurable function between measurable spaces `(α, ma)` and `(β, mb)`, and `ma' ⊆ ma` and `mb' ⊆ mb` are sub-measurable spaces, then `f` is measurable with respect to `(α, ma')` and `(β, mb')`.


/-- If `α` is an infinite type, then the cardinality of `α ⊕ β` is the maximum
of the cardinalities of `α` and `β`.  -/
theorem Cardinal.add_eq_max : ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → a + b = max a b := by sorry

This theorem states that if `α` is an infinite type, then the cardinality of the disjoint union of `α` and `β` is the maximum of the cardinalities of `α` and `β`. In other words, if the cardinality of `α` is at least as large as the cardinality of the smallest infinite cardinal (ℵ₀), then the cardinality of the set formed by combining `α` and `β` (denoted as `α ⊕ β`) is equal to the larger of the cardinalities of `α` and `β` (`max a b`).

If `α` and `β` are infinite types, then the cardinality of `α ⊕ β` is `max a β`.


theorem CategoryTheory.Limits.coprod.map_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A₁ A₂ A₃ B₁ B₂ B₃ : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct A₁ B₁]
      [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A₂ B₂]
      [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.map f g) (CategoryTheory.Limits.coprod.map h k) =
        CategoryTheory.Limits.coprod.map (CategoryTheory.CategoryStruct.comp f h)
          (CategoryTheory.CategoryStruct.comp g k) :=
  by sorry

This theorem belongs to the domain of category theory within mathematics. It states that given a category `C` with objects `A₁`, `A₂`, `A₃`, `B₁`, `B₂`, `B₃` and binary coproducts for pairs `(A₁, B₁)`, `(A₂, B₂)`, `(A₃, B₃)`, and given morphisms `f : A₁ ⟶ A₂`, `g : B₁ ⟶ B₂`, `h : A₂ ⟶ A₃`, and `k : B₂ ⟶ B₃`, the composition of coproduct maps `coprod.map f g` and `coprod.map h k` is the same as the coproduct map of composed morphisms `(f ≫ h)` and `(g ≫ k)`. In more informal language, it says that mapping over coproducts (a kind of "combined" object in category theory) can be "interchanged" with composition of morphisms (functions between objects).

Given categories `C` with objects `A₁, A₂, A₃, B₁, B₂, B₃` and binary coproducts, for morphisms `f : A₁ ⟶ A₂`, `g : B₁ ⟶ B₂`, `h : A₂ ⟶ A₃`, and `k : B₂ ⟶ B₃`, the map `coprod.map f g ≫ coprod.map h k` is equal to `coprod.map (f ≫ h) (g ≫ k)`.


theorem le_isGLB_iff :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a b : α}, IsGLB s a → (b ≤ a ↔ b ∈ lowerBounds s) := by sorry

This theorem states that for all sets `s` of some type `α` with defined preorder, and any elements `a` and `b` of type `α`, if `a` is the greatest lower bound of the set `s`, then `b` is less than or equal to `a` if and only if `b` belongs to the set of lower bounds of `s`. In terms of mathematical language, we can denote the greatest lower bound as \(\text{glb}(s) = a\), and the theorem states \(b \leq a \iff b \in \text{lowerBounds}(s)\).

The greatest lower bound of a set with respect to a preorder is an element that is less than or equal to any lower bound of the set. In other words, \(\text{glb}(s) = a \iff a \leq b \ \forall\ b \in \text{lowerBounds}(s)\).


theorem DFinsupp.single_smul :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : Monoid γ]
      [inst_2 : (i : ι) → AddMonoid (β i)] [inst_3 : (i : ι) → DistribMulAction γ (β i)] {i : ι} (c : γ) (x : β i),
      DFinsupp.single i (c • x) = c • DFinsupp.single i x :=
  by sorry

The theorem `DFinsupp.single_smul` states that given any types `ι`, `γ`, and a type function `β` from `ι` to some type, if `ι` has decidable equality, `γ` is a Monoid, each `β i` (for `i` in `ι`) is an Additive Monoid, and each `β i` is a Distributive Multiplication Action over `γ`, then for any instance `i` of `ι`, scalar `c` of `γ`, and element `x` of `β i`, scaling `x` by `c` and then applying the `DFinsupp.single` function is the same as first applying `DFinsupp.single` to `x` and then scaling the result by `c`. In simple terms, it asserts the commutativity of the scalar multiplication operation with the `DFinsupp.single` operation.

Given a type `ι` with decidable equality, a Monoid `γ`, and a type function `β : ι → AddMonoid γ`, if each `β i` is a Distributive Multiplication Action over `γ`, then for all `i ∈ ι`, `c ∈ γ`, and `x ∈ β i`, `DFinsupp.single (c * x) = c * DFinsupp.single x`.


theorem Monotone.mem_lowerBounds_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {a : α} {s : Set α}, a ∈ lowerBounds s → f a ∈ lowerBounds (f '' s) :=
  by sorry

The theorem `Monotone.mem_lowerBounds_image` states that for every types `α` and `β` that have a preorder, and for any function `f` from `α` to `β` that is monotone, if an element `a` from `α` is in the lower bounds of a set `s` of `α`, then `f(a)` is in the lower bounds of the image of `s` under `f`. In other words, if a function is monotone and an element is a lower bound of a set, then the image of that element under the function is a lower bound of the image of the set under the function.

If `f` is a monotone function from preordered types `α` and `β`, and `a` is a lower bound of a set `s` in `α`, then `f(a)` is a lower bound of the image of `s` under `f` in `β`.


theorem Matrix.one_apply_eq :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α] (i : n), 1 i i = 1 := by
  sorry

The theorem `Matrix.one_apply_eq` states that for any type `n` and any type `α` which has decidable equality, zero and one as instances, for every `i` of type `n`, the matrix unit (represented as `1`) indexed at `i`, `i` will always be equal to `1`. In other words, this theorem is about the identity property of a unit matrix where all the diagonal elements are `1` and the rest are `0`.

For any square matrix of size `n` over a type `α` with decidable equality, zero and one as instances, the matrix unit at position `i` equals `1` for all `i` in `n`.


theorem continuous_add_right :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [inst_2 : ContinuousAdd M] (a : M),
      Continuous fun b => b + a :=
  by sorry

This theorem states that for any type `M` that has a topological space structure, an addition operation, and for which this addition operation is continuous, the operation of adding a fixed element `a` (of type `M`) to any other element of `M` is a continuous function. In other words, in this framework, right-addition by a fixed element is a continuous operation.

For any type `M` with a topological space structure and a continuous addition operation, right-addition by a fixed element is a continuous function.


theorem Nat.ceil_le :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ}, ⌈a⌉₊ ≤ n ↔ a ≤ ↑n :=
  by sorry

This theorem, `Nat.ceil_le`, states that for any type `α` which is a Linear Ordered Semiring and a Floor Semiring, and for any `a` of type `α` and natural number `n`, the ceiling of `a` (denoted as `⌈a⌉₊`) is less than or equal to `n` if and only if `a` is less than or equal to the natural number representation of `n` (`↑n`). In other words, the ceiling of `a` is less than or equal to `n` precisely when `a` itself is less than or equal to `n` when `n` is considered as a member of type `α`.

For any Linear Ordered Semiring and Floor Semiring type `α`, and for all `a` in `α` and natural number `n`, `⌈a⌉₊ ≤ n` if and only if `a ≤ ↑n`.


theorem Mathlib.Data.MvPolynomial.Basic._auxLemma.7 :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ},
      (m ∈ MvPolynomial.support p) = (MvPolynomial.coeff m p ≠ 0) :=
  by sorry

The theorem `Mathlib.Data.MvPolynomial.Basic._auxLemma.7` states that for any coefficient ring 'R', any set of variables 'σ', any multivariate polynomial 'p' with variables indexed by 'σ' and coefficients from 'R', and any monomial 'm' (represented as a mapping from 'σ' to 'ℕ'), 'm' is in the support of 'p' if and only if the coefficient of 'm' in 'p' is non-zero. In other words, the support of a multivariate polynomial is precisely the set of monomials that have non-zero coefficients in that polynomial.

The support of a multivariate polynomial equals the set of monomials with non-zero coefficients.


theorem Cardinal.mk_le_aleph0 : ∀ {α : Type u} [inst : Countable α], Cardinal.mk α ≤ Cardinal.aleph0 := by sorry

This theorem states that for any type `α` that is countable (i.e., has the same or less number of elements as the natural numbers `ℕ`), the cardinality of `α` is less than or equal to `ℵ₀`, which is the smallest infinite cardinal number. In other words, the size of any countable set will always be less than or equal to the size of the set of natural numbers.

Any countable type `α` has cardinality less than or equal to that of the natural numbers `ℕ`, which is smaller than `ℵ₀`.


theorem lt_sub_iff_add_lt' :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α}, b < c - a ↔ a + b < c :=
  by sorry

This theorem states that for any type `α` that forms an additive commutative group and has a less than (`<`) operation, and for this addition operation and less than operation, if they satisfy the covariant property, then for any three elements `a`, `b` and `c` in `α`, `b` is less than `c` subtracted by `a` if and only if `a` plus `b` is less than `c`. The covariant property here ensures the "order" is preserved under the addition operation.

For any additive commutative group `α` with a covariant `<` relation, if `a < b`, then `a + c < c + b` for all `a, b, c` in `α`.


theorem Polynomial.pow_rootMultiplicity_dvd :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (a : R),
      (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p ∣ p :=
  by sorry

The theorem `Polynomial.pow_rootMultiplicity_dvd` states that for every polynomial `p` over a ring `R` and for every element `a` in `R`, the polynomial `(Polynomial.X - Polynomial.C a)` raised to the power of the root multiplicity of `a` in `p` divides `p`. In mathematical terms, if `a` is a root of `p` and its multiplicity is `n`, then `(X - a)^n` is a factor of `p`.

For any polynomial `p` over a ring `R` and any root `a` of `p` with multiplicity `n`, `(X - a)^n` divides `p` in `R[X]`.


Ordinal.IsLimit.pos

theorem Ordinal.IsLimit.pos : ∀ {o : Ordinal.{u_4}}, Ordinal.IsLimit o → 0 < o := by sorry

The theorem `Ordinal.IsLimit.pos` states that for any ordinal `o`, if `o` is a limit ordinal, then `o` is greater than zero. In other words, it asserts that all limit ordinals are positive.

For every limit ordinal `o`, `o` is a positive ordinal.


theorem Int.sub_self : ∀ (a : ℤ), a - a = 0 := by sorry

This theorem states that for any integer 'a', the result of subtracting 'a' from itself is always zero. In mathematical terms, it is expressing the property `a - a = 0` for all integers 'a'.

For all integers 'a', the expression 'a - a' equals zero.


theorem closure_eq_iff_isClosed : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], closure s = s ↔ IsClosed s :=
  by sorry

This theorem states that for any set `s` of a certain type `X` in a topological space, the closure of `s` is equal to `s` if and only if `s` is a closed set. In other words, a set is equal to its own closure (the smallest closed set that contains it) if and only if it is a closed set within the context of the given topological space.

A set in a topological space is closed if and only if it is equal to its closure.


theorem Finset.range_zero : Finset.range 0 = ∅ := by sorry

The theorem `Finset.range_zero` states that the set of natural numbers less than zero, represented by `Finset.range 0`, is an empty set, denoted by `∅`. This is because there are no natural numbers less than zero.

The set of natural numbers less than 0 is empty. (or) The finite set of natural numbers with start 0 and size greater than 0 is empty.


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

This theorem states that for a given permutation `f` on a finite type `α` with decidable equality, and for any two elements `x` and `y` of `α`, the action of the cycle of `f` that contains `x` on `y` is equal to either `f y` or `y` itself, depending on whether `x` and `y` are in the same cycle of the permutation `f`. In other words, if `x` and `y` are in the same cycle of the permutation `f` (as indicated by `Equiv.Perm.SameCycle f x y`), then applying `f` to `y` will give the result of the operation `Equiv.Perm.cycleOf f x` on `y`; otherwise, `y` remains unchanged.

For any permutation `f` on a finite type `α` with decidable equality, and for all `x, y` in `α`, if `x` and `y` are in the same cycle of `f`, then `f y = Equiv.Perm.cycleOf f x y`, otherwise `y` is unchanged.


theorem Complex.cos_antiperiodic : Function.Antiperiodic Complex.cos ↑Real.pi := by sorry

The theorem `Complex.cos_antiperiodic` states that the complex cosine function (`Complex.cos`) is antiperiodic with a period equal to pi (`Real.pi`). This means that for every complex number `z`, the value of `Complex.cos` at `z` plus pi is the negative of the value of `Complex.cos` at `z` i.e., `Complex.cos (z + π) = - Complex.cos z`. It essentially states the well-known property of the cosine function being antiperiodic with respect to the period π in the complex plane.

The complex cosine function `Complex.cos` is antiperiodic with period `Real.pi`, i.e., `Complex.cos (z + Real.pi) = - Complex.cos z` for all complex numbers `z`.


theorem WithTop.coe_add : ∀ {α : Type u} [inst : Add α] (a b : α), ↑(a + b) = ↑a + ↑b := by sorry

This theorem states that for any type `α` that has an addition operation (`Add α`), the addition of two elements `a` and `b` of type `α` lifted to the `WithTop` type (denoted by `↑(a + b)`) is equal to the sum of the lifted elements `a` and `b` (denoted by `↑a + ↑b`). In other words, the lifting operation commutes with the addition operation.

For any type `α` with an addition operation and for all `a` and `b` in `α`, the lifted addition `↑(a + b)` equals the sum of the lifted elements `↑a + ↑b`.


theorem Ideal.Quotient.lift_mk :
    ∀ {R : Type u} [inst : CommRing R] {a : R} {S : Type v} [inst_1 : Semiring S] (I : Ideal R) (f : R →+* S)
      (H : ∀ a ∈ I, f a = 0), (Ideal.Quotient.lift I f H) ((Ideal.Quotient.mk I) a) = f a :=
  by sorry

The theorem `Ideal.Quotient.lift_mk` states that for any commutative ring `R`, an ideal `I` of `R`, a ring homomorphism `f` from `R` to some semiring `S` that sends all elements of `I` to zero, and any element `a` of `R`, lifting `f` to the quotient by `I` and then applying this lifted map to the image of `a` under the quotient map yields the same result as applying `f` directly to `a`. In other words, this theorem is about the compatibility of the lifting and quotient map operations in the context of ring homomorphisms.

For any commutative ring `R`, ideal `I` of `R`, ring homomorphism `f` from `R` to some semiring `S` sending `I` to zero, and element `a` of `R`, we have `f(a) = (f : R →* S) (a : R) = (lift f : R / I →* S) (a : R / I)`.


theorem add_eq_sup : ∀ {α : Type u_1} [inst : IdemSemiring α] (a b : α), a + b = a ⊔ b := by sorry

This theorem, `add_eq_sup`, states that for any type `α` that forms an idempotent semiring (denoted by `IdemSemiring α`), the sum of any two elements `a` and `b` of this type is equivalent to the supremum (greatest element) of `a` and `b`. In the context of idempotent semiring, the addition operation behaves as taking the maximum of the two elements. This holds for all `a` and `b` in the given idempotent semiring.

For any idempotent semiring `α`, the addition of two elements `a` and `b` is equal to the supremum of `a` and `b`.


theorem mem_nhdsSet_iff_forall :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, s ∈ nhdsSet t ↔ ∀ x ∈ t, s ∈ nhds x := by sorry

The theorem `mem_nhdsSet_iff_forall` states that for any type `X` that is a topological space and for any two sets `s` and `t` of this type, the set `s` is in the filter of neighborhoods of the set `t` (`nhdsSet t`) if and only if for every element `x` in `t`, the set `s` is in the filter of neighborhoods of `x` (`nhds x`). In other words, a set `s` is a neighborhood of all points in a set `t` if and only if `s` is a neighborhood of each individual point in `t`.

A set is in the neighborhood filter of a set if and only if it is in the neighborhood filter of each point in that set.


theorem Mathlib.RingTheory.Polynomial.Basic._auxLemma.4 :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      (n ∈ Polynomial.support p) = (Polynomial.coeff p n ≠ 0) :=
  by sorry

This theorem states that for any semiring `R`, any natural number `n`, and any polynomial `p` with coefficients in `R`, the number `n` is in the support of `p` if and only if the coefficient of `X^n` in `p` is non-zero. In other words, the support of a polynomial consists exactly of the exponents of those terms in the polynomial that have a non-zero coefficient.

The support of a polynomial `p` in a semiring `R` equals the set of exponents of non-zero coefficients in `p`.


theorem Int.cast_ne_zero : ∀ {α : Type u_1} [inst : AddGroupWithOne α] [inst_1 : CharZero α] {n : ℤ}, ↑n ≠ 0 ↔ n ≠ 0 :=
  by sorry

The theorem `Int.cast_ne_zero` states that for any type `α` that forms an additive group with a distinguished element of one (`AddGroupWithOne α`) and has no non-zero integers that map to the same element (`CharZero α`), an integer `n` is non-zero if and only if its cast to `α` is non-zero. In other words, casting a non-zero integer to this type will never result in zero.

For any additive group with a multiplicative identity `α` satisfying `AddGroupWithOne α` and `CharZero α`, the integer `n` is non-zero if and only if its cast to `α` is non-zero.


theorem isConj_iff : ∀ {α : Type u} [inst : Group α] {a b : α}, IsConj a b ↔ ∃ c, c * a * c⁻¹ = b := by sorry

This theorem states that for any group `α`, and any elements `a` and `b` of that group, `a` is conjugate to `b` if and only if there exists a unit `c` such that `c * a * c⁻¹ = b`. In the language of group theory, this expresses the property of being conjugate as having a specific form under a group operation.

For any group `α` and elements `a, b` in `α`, `a` is conjugate to `b` if and only if there exists a unit `c` in `α` such that `c * a * c⁻¹ = b`.


theorem CategoryTheory.IsIso.eq_inv_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : X ⟶ Z} {g : Y ⟶ Z},
      g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f ↔ CategoryTheory.CategoryStruct.comp α g = f :=
  by sorry

The theorem `CategoryTheory.IsIso.eq_inv_comp` states that in any category 'C' with object types 'X', 'Y', and 'Z', and given a morphism 'α' from 'X' to 'Y' which is an isomorphism (i.e., has an inverse), and arbitrary morphisms 'f' from 'X' to 'Z' and 'g' from 'Y' to 'Z', then 'g' is equal to the composition of the inverse of 'α' and 'f' if and only if the composition of 'α' and 'g' is equal to 'f'. In other words, we can swap between pre-composing with the inverse of 'α' and post-composing with 'α' itself when we are working with isomorphisms.

Given a category 'C' with object types 'X', 'Y', and 'Z', an isomorphism α : X ↔ Y, and arbitrary morphisms f : X → Z and g : Y → Z, the following are equivalent: g = α⁻¹ ∘ f if and only if f = α ∘ g.


theorem Asymptotics.IsLittleO.comp_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E}
      {g : α → F} {l : Filter α},
      f =o[l] g → ∀ {k : β → α} {l' : Filter β}, Filter.Tendsto k l' l → (f ∘ k) =o[l'] (g ∘ k) :=
  by sorry

The theorem `Asymptotics.IsLittleO.comp_tendsto` states that for all types `α`, `β`, `E`, and `F` (with `E` and `F` both having a norm), given a function `f` from `α` to `E`, a function `g` from `α` to `F`, and a filter `l` on `α`, if `f` is little-o of `g` at filter `l`, then for any function `k` from `β` to `α` and any filter `l'` on `β`, if `k` tends to `l` with respect to `l'`, then the composition of `f` and `k` is also little-o of the composition of `g` and `k` at filter `l'`.

In mathematical terms, if $f(x)$ is little-o of $g(x)$ as $x$ approaches a filter $l$ and if a function $k(x)$ tends to filter $l$ as $x$ approaches a filter $l'$, then $f(k(x))$ is little-o of $g(k(x))$ as $x$ approaches the filter $l'$.

If a function $f(x)$ is little-o of $g(x)$ as $x$ approaches filter $l$, and a function $k(x)$ tends to filter $l$ as $x$ approaches filter $l'$, then $f(k(x))$ is little-o of $g(k(x))$ as $x$ approaches filter $l'$.


theorem Subgroup.le_normalizer : ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H ≤ Subgroup.normalizer H := by
  sorry

This theorem states that, for any group `G` and any subgroup `H` of `G`, `H` is a sub-group of its normalizer. In other words, every element of `H` is also in the normalizer of `H`. This is because the normalizer of a subgroup is defined as the largest subgroup in which the given subgroup is normal. Hence, the given subgroup is always contained within its normalizer.

For any group `G` and subgroup `H` of `G`, `H` is a subgroup of its normalizer `N(H)` in `G`.


OpenSubgroup.isOpen

theorem OpenSubgroup.isOpen :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] (U : OpenSubgroup G), IsOpen ↑U := by sorry

The theorem `OpenSubgroup.isOpen` states that for any type `G` that has a group structure and a topology, every open subgroup `U` of `G` is open in the ambient topological space on `G`. Here, the term "open subgroup" refers to a subgroup that is also an open set in the given topology.

Every open subgroup of a topological group is open in the group's topology.


/-- A variant of `Cardinal.lift_mk_eq` with specialized universes.
Because Lean often can not realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either.
 -/
theorem Cardinal.lift_mk_eq' :
    ∀ {α : Type u} {β : Type v},
      Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β) :=
  by sorry

This theorem, named `Cardinal.lift_mk_eq'`, asserts a property about the cardinality of types and their equivalence in different universes in Lean. Specifically, for any types `α` and `β` in universes `u` and `v`, respectively, the universe lift operation on the cardinality of `α`, taken from universe `v` to `u`, is equal to the universe lift operation on the cardinality of `β`, taken from universe `u` to `v`, if and only if there is a nonempty equivalence between `α` and `β`. This theorem is a specialized version of `Cardinal.lift_mk_eq`, provided separately because Lean often cannot automatically apply the correct specialization.

For any types α and β in universes u and v, respectively, the universe-lifted cardinalities of α and β are equal if and only if there exists a nonempty equivalence between them.


theorem MeasureTheory.stronglyMeasurable_condexp :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → F'},
      MeasureTheory.StronglyMeasurable (MeasureTheory.condexp m μ f) :=
  by sorry

The theorem `MeasureTheory.stronglyMeasurable_condexp` states that for any types `α` and `F'`, where `F'` forms a Normed Additive Commutative Group, a Normed Space over the real numbers ℝ, and is complete, and for any measurable spaces `m` and `m0` over `α`, any measure `μ` over `α`, and any function `f` from `α` to `F'`, the conditional expectation of `f` with respect to measure `μ` and measurable space `m` is strongly measurable. In mathematical terms, this means the conditional expectation of `f` is the limit of a sequence of simple functions.

For any measurable spaces `(α, m)`, measure `μ` over `α`, complete Normed Additive Commutative Group `F'`, Normed Space over ℝ, and function `f : α → F'`, the conditional expectation of `f` with respect to `μ` is a strongly measurable function.


theorem Real.exp_injective : Function.Injective Real.exp := by sorry

The theorem `Real.exp_injective` states that the real exponential function, denoted as `Real.exp`, is injective. In other words, given any two real numbers `x` and `y`, if the exponential of `x` is equal to the exponential of `y` (i.e., `Real.exp x = Real.exp y`), then `x` must be equal to `y`. This property is fundamental to the exponential function in real-number calculus.

The real exponential function `Real.exp` is injective, that is, for all real numbers `x` and `y`, if `Real.exp x = Real.exp y`, then `x = y`.


theorem Mathlib.Algebra.CharZero.Defs._auxLemma.10 :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] (n : ℕ) [inst_2 : Nat.AtLeastTwo n],
      (1 = OfNat.ofNat n) = False :=
  by sorry

The theorem `Mathlib.Algebra.CharZero.Defs._auxLemma.10` states that for any type `R` which is an `AddMonoidWithOne` (an additive monoid with an additional multiplicative identity) and a `CharZero` (a type of algebraic structures where the characteristic is zero), and for any natural number `n` that is at least two, the equality `1 = OfNat.ofNat n` is always false. This means that the numeric literal `1` of type `R` is never equal to the result of applying the `OfNat.ofNat` function to `n`, assuming that `n` is at least two.

For any AddMonoidWithOne type R with CharZero structure, the numeric literal 1 is never equal to OfNat.ofNat n for any natural number n ≥ 2.


theorem Polynomial.le_natDegree_of_mem_supp :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, ∀ a ∈ Polynomial.support p, a ≤ Polynomial.natDegree p := by
  sorry

The theorem `Polynomial.le_natDegree_of_mem_supp` states that for any type `R` that is a semiring and any polynomial `p` of that type, if a natural number `a` is in the support of `p` (that is, the coefficient of `X^a` in `p` is non-zero), then `a` is less than or equal to the natural degree of `p`. In other words, the degree of a polynomial is at least as large as any exponent of `X` whose coefficient is non-zero.

For any semiring type R and polynomial p of type R[X], if a is a natural number in the support of p, then a <= degree p.


/-- The open thickening `Metric.thickening δ E` is contained in the closed thickening
`Metric.cthickening δ E` with the same radius.  -/
theorem Metric.thickening_subset_cthickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α), Metric.thickening δ E ⊆ Metric.cthickening δ E :=
  by sorry

The theorem `Metric.thickening_subset_cthickening` states that for any set `E` of points in a pseudo-emetric space (a space endowed with a distance function satisfying certain properties), the open $\delta$-thickening of `E` (which is the set of all points less than $\delta$ away from any point in `E`) is a subset of the closed $\delta$-thickening of `E` (which is the set of all points whose distance to `E` is at most $\delta$). This implies that any point that is less than $\delta$ away from some point of `E` will also be at most $\delta$ away from `E`.

The open thickening of a set in a pseudo-metric space is contained in its closed thickening.


theorem iSup_Prop_eq : ∀ {ι : Sort u_5} {p : ι → Prop}, ⨆ i, p i = ∃ i, p i := by sorry

This theorem states that for any indexed type `ι` and any proposition function `p` from `ι` to `Prop`, the supremum over `i` of `p i` is equal to the existence of an `i` for which `p i` holds. In other words, the supremum of the proposition `p` over all `i` is true if and only if there exists some `i` for which `p i` is true.

The supremum of an indexed proposition `p : ι → Prop` equals the existence of an element `i` in `ι` such that `p i` holds.


theorem SetTheory.PGame.not_le : ∀ {x y : SetTheory.PGame}, ¬x ≤ y ↔ SetTheory.PGame.LF y x := by sorry

The theorem `SetTheory.PGame.not_le` states that for any two pre-games `x` and `y` in Set Theory, the statement "it is not the case that `x` is less than or equal to `y`" is equivalent to the statement "`y` is in a less or fuzzy relation with `x`". The less or fuzzy relation, denoted by `SetTheory.PGame.LF y x`, means that the game `y` is not less than or equal to game `x`, or in other words, Left can win the game `x` when playing first.

The theorem `SetTheory.PGame.not_le` asserts that `x not<= y` is equivalent to `y SetTheory.PGame.LF x` in Set Theory.


theorem Fin.val_injective : ∀ {n : ℕ}, Function.Injective Fin.val := by sorry

The theorem `Fin.val_injective` states that for any natural number `n`, the function `Fin.val` is injective. The function `Fin.val` maps an instance of the finite type `Fin n` to natural numbers. Being injective means that if `Fin.val` applied to two instances of `Fin n` yields the same natural number, then those two instances must be identical. In other words, no two different elements of `Fin n` are mapped to the same natural number by `Fin.val`.

For any natural numbers `m` and `n`, if `Fin.val m = Fin.val n` then `m = n`. (Here, `Fin.val m` and `Fin.val n` denote the natural numbers associated with the finite types `Fin m` and `Fin n`, respectively.)


theorem set_pi_mem_nhds :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {i : Set ι} {s : (a : ι) → Set (π a)}
      {x : (a : ι) → π a}, Set.Finite i → (∀ a ∈ i, s a ∈ nhds (x a)) → Set.pi i s ∈ nhds x :=
  by sorry

The theorem `set_pi_mem_nhds` states that for any type `ι`, any function `π` mapping `ι` to a type, any topological space `T` over each `π i`, any set `i` of type `ι`, any function `s` mapping each `ι` to a set of `π a`, and any function `x` mapping each `ι` to `π a`, if the set `i` is finite and for each element `a` in `i`, `s a` is a neighborhood of `x a`, then the set of all dependent functions such that `f a` belongs to `s a` whenever `a` is in `i` is a neighborhood of `x`. In more mathematical terms, this theorem states that the product of a finite number of neighborhoods of points is a neighborhood of the point in the product space.

Given a topological space over a finite index type, if each index has a neighborhood containing the image of a function, then the product of these neighborhoods is a neighborhood of the function.


theorem MeasureTheory.ae_le_set :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
      s ≤ᶠ[MeasureTheory.Measure.ae μ] t ↔ ↑↑μ (s \ t) = 0 :=
  by sorry

This theorem, in the field of measure theory, states that for any given type `α`, any measurable space `α`, any measure `μ` on that measurable space, and any two sets `s` and `t` of type `α`, `s` is almost everywhere less than or equal to `t` (as per the filter defined by `MeasureTheory.Measure.ae μ`) if and only if the measure of the set difference `s \ t` is 0. In other words, the set `s` is less than or equal to the set `t` almost everywhere when the measure of elements in `s` that are not in `t` is zero.

For any measurable spaces `α`, measures `μ` on `α`, and sets `s` and `t` of type `α`, `s ⊆ t` almost everywhere (with respect to `μ`) if and only if `μ(s \ t) = 0`.


theorem UniformContinuous.comp_cauchySeq :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Type u_1} [inst : UniformSpace β]
      [inst_1 : Preorder γ] {f : α → β}, UniformContinuous f → ∀ {u : γ → α}, CauchySeq u → CauchySeq (f ∘ u) :=
  by sorry

This theorem states that if a function `f` from type `α` to type `β` is uniformly continuous, and if a sequence `u` from type `γ` to type `α` is a Cauchy sequence, then the composition of `f` and `u` (i.e., `f ∘ u`) is also a Cauchy sequence. In other words, applying a uniformly continuous function to a Cauchy sequence results in a Cauchy sequence. This holds for any types `α`, `β`, and `γ` where `α` and `β` are equipped with a uniform space structure and `γ` is equipped with a pre-order structure.

If `f` is a uniformly continuous function from `α` to `β` and `u` is a Cauchy sequence in `α`, then the composition `f ∘ u` is a Cauchy sequence in `β`.


theorem Nat.dvd_lcm_right : ∀ (m n : ℕ), n ∣ Nat.lcm m n := by sorry

The theorem `Nat.dvd_lcm_right` states that for any two natural numbers `m` and `n`, `n` divides the least common multiple of `m` and `n`. In other words, `n` is a factor of the least common multiple of `m` and `n`. In mathematical terms, this can be written as: for all natural numbers `m` and `n`, `n` divides `LCM(m, n)`.

For all natural numbers m and n, n divides the least common multiple of m and n.


/-- An isometry preserves edistances.  -/
theorem Isometry.edist_eq :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → ∀ (x y : α), edist (f x) (f y) = edist x y :=
  by sorry

This theorem states that an isometry function, in the context of two pseudoemetric spaces, preserves the extended distance (or "edistance") between any two points. More formally, given any pseudoemetric spaces 'α' and 'β', and any function 'f' from 'α' to 'β' that is an isometry, for any two points 'x' and 'y' in 'α', the edistance between the images of 'x' and 'y' under 'f' is equal to the edistance between 'x' and 'y'.
This means that the 'f' does not alter the edistance between any two points in the space which it maps - a property characteristic of isometry functions.

Given any isometry function between two pseudometric spaces, the edistance between the images of any two points under the function is equal to the edistance between the original points.


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

The theorem `FractionalIdeal.mul_def` states that for any commutative ring `R`, any submonoid `S` of `R`, any type `P` that is also a commutative ring and an `R`-algebra, and any two fractional ideals `I` and `J` of the localization of `R` at `S`, the multiplication of `I` and `J` is defined to be the fractional ideal whose value is the product of the values of `I` and `J`, and whose proof of being a fractional ideal is suppressed for brevity. In other words, this theorem provides the definition of multiplication for fractional ideals.

Given commutative rings R and S, an R-algebra P, and fractional ideals I and J of the localization of R at S, their product I \* J is the fractional ideal whose value is the product of I and J as ideals in the localization.


theorem List.perm_middle : ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, List.Perm (l₁ ++ a :: l₂) (a :: (l₁ ++ l₂)) := by
  sorry

This theorem, `List.perm_middle`, states that for any type `α`, any element `a` of type `α`, and any two lists `l₁` and `l₂` of type `α`, the list formed by appending `a` to the concatenation of `l₁` and `l₂` is a permutation of the list formed by prepending `a` to the concatenation of `l₁` and `l₂`. In other words, regardless of the values of `a`, `l₁`, and `l₂`, placing 'a' anywhere in the list doesn't change its permutation status.
This can be expressed in the mathematical notation as follows: ∀ `α`, `a`, `l₁`, `l₂`, `l₁ ++ a :: l₂` is a permutation of `a :: (l₁ ++ l₂)`.

For any type `α`, any element `a` of type `α`, and any two lists `l₁` and `l₂` of type `α`, appending `a` to the concatenation of `l₁` and `l₂` results in a list that is a permutation of the list obtained by prepending `a` to the concatenation of `l₁` and `l₂`.


Finset.Nonempty.fst

theorem Finset.Nonempty.fst :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty → s.Nonempty := by sorry

This theorem states that for any two types `α` and `β`, and any finite sets `s` of type `α` and `t` of type `β`, if the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is nonempty, then `s` is also nonempty. In other words, if there exists at least one pair `(a, b)` such that `a` is in `s` and `b` is in `t`, then there must exist at least one element in `s`.

If the Cartesian product of non-empty sets `α` and `β` is nonempty, then `α` is nonempty.


theorem Real.continuous_sin : Continuous Real.sin := by sorry

This theorem states that the sine function, as defined on the real numbers, is continuous. In mathematical terms, this means for any real number and any positive epsilon, there exists a positive delta such that the absolute difference between the sine of any two real numbers less than delta apart is less than epsilon. This is a fundamental property of the sine function in calculus and real analysis.

The sine function is a continuous real-valued function on the real numbers.


theorem Nat.bit0_val : ∀ (n : ℕ), bit0 n = 2 * n := by sorry

The theorem `Nat.bit0_val` states that for all natural numbers `n`, applying the function `bit0` to `n` is equivalent to multiplying `n` by 2. The `bit0` function, given a numerical input, simply adds the input to itself, thereby effectively doubling its value.

For all natural numbers n, bit0(n) = 2 * n.


/-- Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
in the `AddSubmonoid`. -/
theorem multiset_sum_mem :
    ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : SetLike B M]
      [inst_2 : AddSubmonoidClass B M] (m : Multiset M), (∀ a ∈ m, a ∈ S) → Multiset.sum m ∈ S :=
  by sorry

This theorem states that the sum of a multiset of elements from an additive submonoid of a commutative additive monoid is also in the additive submonoid. In other words, if `B` is a type, `S` is a value of type `B`, `M` is another type, and `M` has a structure of a commutative additive monoid, then for any multiset of elements from `M`, if all elements of this multiset belong to `S`, then the sum of the elements of the multiset also belongs to `S`. This maintains the closure property of the submonoid, which says that the sum of any elements in the submonoid remains in the submonoid.

If `S` is an additive submonoid of a commutative additive monoid `M`, then the sum of any multiset of elements from `S` is also in `S`.


theorem Finsupp.sum_of_support_subset :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] (f : α →₀ M)
      {s : Finset α},
      f.support ⊆ s → ∀ (g : α → M → N), (∀ i ∈ s, g i 0 = 0) → Finsupp.sum f g = Finset.sum s fun x => g x (f x) :=
  by sorry

The theorem `Finsupp.sum_of_support_subset` states that for every type `α`, `M`, and `N`, given a zero of type `M`, an additive commutative monoid of type `N`, a function `f` from `α` to `M` and a finite set `s` of `α`, if the support of `f` (i.e., the set of elements where `f` is non-zero) is a subset of `s`, then for any function `g` from `α` to the function space from `M` to `N`, such that `g` of `i` and `0` equals `0` for all `i` in `s`, the sum of `g a (f a)` over the support of `f` equals the sum of `g x (f x)` as `x` ranges over the elements of the finite set `s`.

If `f` is a function from a set `α` to a commutative additive monoid `M`, with finite support `s`, and `g` is a function from `α` to the function space from `M` to a commutative additive monoid `N`, such that `g i (0) = 0` for all `i` in `s`, then the sum of `g i (f i)` over `i` in `s` equals the sum of `g x (f x)` over `x` in `s`.


theorem Ordinal.omega_pos : 0 < Ordinal.omega := by sorry

The theorem `Ordinal.omega_pos` states that zero is less than `Ordinal.omega`, or in other words, the first infinite ordinal, typically known as ω. Recall that `Ordinal.omega` is defined as the order type of the set of natural numbers ℕ. Therefore, this theorem essentially asserts that the order type of the natural numbers, an infinite set, is strictly greater than zero.

The theorem `Ordinal.omega_pos` asserts that 0 < ω, where ω is the order type of the natural numbers.


theorem Ordinal.one_le_iff_pos : ∀ {o : Ordinal.{u_3}}, 1 ≤ o ↔ 0 < o := by sorry

This theorem, `Ordinal.one_le_iff_pos`, states that for all ordinals `o`, the ordinal '1' is less than or equal to `o` if and only if the ordinal '0' is less than `o`. In other words, in the context of ordinals, the statements "1 is less than or equal to `o`" and "0 is less than `o`" are equivalent. This theorem is at the heart of understanding orderings in the ordinals.

For all ordinals `o`, 1 ≤ o if and only if 0 < o.


theorem Mathlib.Order.BoundedOrder._auxLemma.12 :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] {a : α}, (a < ⊥) = False := by sorry

This theorem states that for any type `α` with a preorder and a bottom element (`OrderBot`), any element `a` of `α` is not less than the bottom element. In other words, for all `a` in `α`, `a < ⊥` is always false. This aligns with the intuitive concept that the bottom element (`⊥`) is defined to be the least element in the order, so no other element can be lesser than it.

For any type `α` with a preorder and a bottom element `⊥`, there is no element `a` in `α` such that `a` is strictly less than `⊥`.


theorem UniformContinuous.subtype_mk :
    ∀ {α : Type ua} {β : Type ub} {p : α → Prop} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : β → α},
      UniformContinuous f → ∀ (h : ∀ (x : β), p (f x)), UniformContinuous fun x => { val := f x, property := ⋯ } :=
  by sorry

This theorem states that for every function `f` from type `β` to `α`, if `f` is uniformly continuous and if for every element `x` of type `β`, `p (f x)` holds (i.e., the image of `x` under `f` satisfies a certain property `p`), then the function which maps each `x` of type `β` to a subtype `{ val := f x, property := ⋯ }` of `α` (where each element in the subtype is an element of `α` that satisfies the property `p`) is also uniformly continuous. This means, no matter where the elements of `β` are located, if they are sufficiently close to each other then their images under this new function are also close to each other.

If `f` is a uniformly continuous function from type `β` to `α` and `p(x)` holds for every `x` in `β`, then the function mapping each `x` to the subtype of elements in `α` satisfying `p(x)` is also uniformly continuous.


theorem padicValNat.proof_1 : ∀ (p n : ℕ), p ≠ 1 ∧ 0 < n → multiplicity.Finite p n := by sorry

The theorem `padicValNat.proof_1` states that for all natural numbers `p` and `n`, if `p` is not equal to one and `n` is positive, then the multiplicity of `p` in `n` is finite. In mathematical terms, this means that there exists a natural number `m` such that `p` to the power of `(m + 1)` does not divide `n`.

For all natural numbers p neither equal to 1 nor zero, and all positive natural numbers n, there exists a natural number m such that p^(m+1) does not divide n.


theorem Bool.and_true : ∀ (b : Bool), (b && true) = b := by sorry

This theorem states that for any boolean value `b`, the logical AND of `b` and `true` is equal to `b`. In other words, when a boolean is logically ANDed with `true`, the result is the original boolean itself, regardless of whether it is `true` or `false`. This statement mirrors the principle of identity in Boolean algebra.

For any boolean value `b`, `b` and `true` have equal logical AND values. In Lean notation: `(b : bool) => b && true = b`.


theorem Int.add_emod : ∀ (a b n : ℤ), (a + b) % n = (a % n + b % n) % n := by sorry

This theorem states that for all integers `a`, `b`, and `n`, the remainder of the sum of `a` and `b` after division by `n` is the same as the remainder of the sum of the remainders of `a` and `b` after division by `n`. In mathematical terms, this can be represented as `(a + b) mod n = (a mod n + b mod n) mod n`.

The theorem asserts that for all integers `a`, `b`, and `n`, `(a + b) % n = (a % n + b % n) % n`.


theorem Ideal.mul_mem_mul :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R} {r s : R}, r ∈ I → s ∈ J → r * s ∈ I * J := by sorry

This theorem states that for any commutative semiring `R`, and any two ideals `I` and `J` of `R`, if a certain element `r` belongs to the ideal `I` and another element `s` belongs to the ideal `J`, then the product `r * s` belongs to the product of the two ideals `I * J`. In other words, the product of any element from `I` and any element from `J` is an element of the product ideal `I * J`.

For any commutative semiring R, and ideals I and J, r ∈ I and s ∈ J imply r * s ∈ I * J.


theorem Set.preimage_vadd :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] (a : α) (t : Set β),
      (fun x => a +ᵥ x) ⁻¹' t = -a +ᵥ t :=
  by sorry

The theorem `Set.preimage_vadd` states that for any type `α` which is an additive group, any type `β` on which `α` acts additively (in other words, `β` is an `α`-set, meaning `α` elements can be added to `β` elements), any element `a` of `α`, and any set `t` of elements of `β`, the preimage of `t` under the operation of vector addition with `a` equals the set obtained by adding the additive inverse of `a` to each element of `t`. In simpler words, if we translate all elements of `t` by `a` or by `-a` (the opposite of `a`), we end up with the same set.

For any additive group α acting on a set β, the preimage of a set t under the translation by a element is equal to the set obtained by translating each element of t by the additive inverse of a.


theorem ENNReal.mul_iSup : ∀ {ι : Sort u_4} {f : ι → ENNReal} {a : ENNReal}, a * iSup f = ⨆ i, a * f i := by sorry

This theorem states that, for any index type `ι`, any function `f` from `ι` to the extended nonnegative real numbers (`ENNReal`), and any extended nonnegative real number `a`, the product of `a` and the indexed supremum (`iSup`) of `f` is equal to the supremum (denoted by `⨆ i`) of `a` times `f i` across all `i` in `ι`. In other words, multiplication distributes over the supremum in the extended nonnegative real numbers.

For any index type `ι`, any function `f` from `ι` to the extended nonnegative real numbers `ENNReal`, and any `ENNReal` number `a`, we have `a * ⨆ (i : ι) (a * f i) = ⨆ (i : ι) (a * f i)`.


theorem Fin.castSucc_lt_last : ∀ {n : ℕ} (a : Fin n), Fin.castSucc a < Fin.last n := by sorry

The theorem `Fin.castSucc_lt_last` states that for any natural number `n` and any element `a` of the finite set `Fin n`, the embedding of `a` into the finite set `Fin (n + 1)` using the function `Fin.castSucc` is always less than the greatest value of `Fin (n + 1)`, which is given by the function `Fin.last n`. In other words, if you embed an element from a smaller finite set into a larger one, it will always be less than the maximum value in the larger set.

For any natural number `n` and `a` in `Fin n`, `Fin.castSucc a < Fin.last (n + 1)`.


theorem Nat.sub_sub_self : ∀ {n m : ℕ}, m ≤ n → n - (n - m) = m := by sorry

This theorem, `Nat.sub_sub_self`, states that for any two natural numbers `n` and `m`, if `m` is less than or equal to `n`, then subtracting `m` from `n` and then subtracting the result from `n` equals `m`. In mathematical notation, this theorem is expressing the formula `n - (n - m) = m` for `n ≥ m`. This theorem gives us an important property of subtraction for natural numbers.

For any natural numbers `n` and `m` with `m ≤ n`, we have `n = (n - m) + m`.


theorem Cardinal.toENat_ofENat : ∀ (n : ℕ∞), Cardinal.toENat ↑n = n := by sorry

This theorem states that for every extended natural number `n`, when you convert `n` to a cardinal number (using the natural number embedding `↑n`) and then apply the function `Cardinal.toENat`, you get back the original extended natural number `n`. In other words, `Cardinal.toENat` is the right-inverse of the embedding from extended natural numbers to cardinal numbers. This property is crucial for maintaining consistency in the conversion of extended natural numbers to cardinal numbers and back.

For every extended natural number `n`, the function `Cardinal.toENat (↑n)` equals `n`.


/-- An angle in a right-angled triangle expressed using `arccos`.  -/
theorem InnerProductGeometry.angle_add_eq_arccos_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → InnerProductGeometry.angle x (x + y) = Real.arccos (‖x‖ / ‖x + y‖) :=
  by sorry

This theorem states that in the context of an inner product space over the real numbers, if the inner product of two vectors `x` and `y` is zero, then the undirected angle between the vector `x` and the vector resulting from the addition of `x` and `y` is equal to the inverse cosine of the ratio of the norm of `x` to the norm of the sum of `x` and `y`. This corresponds to the geometric interpretation in a right-angled triangle where the angle is expressed using the inverse cosine (or `arccos`) function.

In an inner product space over the real numbers, the cosine of the undirected angle between vectors `x` and `x + y` is equal to the norm of `x` divided by the norm of `x + y`. Therefore, the angle is given by the inverse cosine of this ratio.


theorem Nat.sInf_def : ∀ {s : Set ℕ} (h : Set.Nonempty s), sInf s = Nat.find h := by sorry

This theorem states that for any nonempty set `s` of natural numbers, the infimum of `s` (denoted as `sInf s`) is equal to the smallest natural number in `s` found by the `Nat.find` function, with `h` being the proof of `s` being nonempty. The `Nat.find` function returns the smallest natural number in `s` that satisfies a given property, in this case, the property of being in `s`. This theorem essentially characterizes the infimum of a nonempty set of natural numbers in terms of the `Nat.find` function.

For any nonempty set `s` of natural numbers, the infimum of `s` is equal to the output of `Nat.find s h`.


theorem Cardinal.mk_eq_zero_iff : ∀ {α : Type u}, Cardinal.mk α = 0 ↔ IsEmpty α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is equal to zero if and only if `α` is an empty type. In more mathematical terms, it asserts that the cardinal number of a type is zero if, and only if, that type has no elements.

The theorem asserts that for any type `α`, its cardinality equals zero if and only if `α` is empty.


theorem Summable.hasSum_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α}
      [inst_2 : T2Space α], Summable f → (HasSum f a ↔ ∑' (b : β), f b = a) :=
  by sorry

The theorem `Summable.hasSum_iff` provides a condition to check if a series has a specific sum in a given topological space. For any types `α` and `β`, along with a function `f : β → α`, an element `a : α`, and an instance of `α` being a `T2` space (also known as a Hausdorff space), if the series of `f` is summable, then the series `f` has a sum `a` if and only if the infinite summation of `f` over all `b` in `β` equals `a`.

For a function `f : β → α` with type `α` being a T2 space, `a : α`, and summable series `∑ x in β, f x`, the series `∑ x in β, f x` has sum `a` if and only if the limit of `∑ x in β, f x` as `β` approaches infinity exists and equals `a`.


Inseparable.specializes

theorem Inseparable.specializes : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y → x ⤳ y := by
  sorry

The theorem `Inseparable.specializes` states that for any topological space `X` and any two points `x` and `y` in `X`, if `x` and `y` are inseparable (meaning the neighborhoods of `x` and `y` are the same) then `x` specializes to `y`. In the context of topological spaces, "specializes" means that every open set containing `y` also contains `x`.

If two points `x` and `y` in a topological space `X` are inseparable, then `x` is contained in every open set containing `y`.


theorem MeasureTheory.integrable_indicator_iff :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α},
      MeasurableSet s → (MeasureTheory.Integrable (Set.indicator s f) μ ↔ MeasureTheory.IntegrableOn f s μ) :=
  by sorry

The theorem `MeasureTheory.integrable_indicator_iff` asserts that for any given measurable space `α`, normed add commutative group `E`, function `f : α → E`, set `s : Set α`, and measure `μ : MeasureTheory.Measure α`, if `s` is a measurable set, then `f` is integrable with respect to the indicator function of `s` under measure `μ` if and only if `f` is integrable over the set `s` under measure `μ`. In other words, the integrability of `f` according to the indicator function of set `s` is equivalent to the integrability of `f` on the set `s`.

For any measurable space, normed add commutative group, measurable function, measurable set, and measure, the function is integrable with respect to the indicator function of the set if and only if it is integrable over the set.


theorem Polynomial.toFinsupp_mul :
    ∀ {R : Type u} [inst : Semiring R] (a b : Polynomial R), (a * b).toFinsupp = a.toFinsupp * b.toFinsupp := by sorry

This theorem states that for any given semiring `R` and any two polynomials `a` and `b` over `R`, the polynomial obtained by multiplying `a` and `b` and then converting to a `Finsupp` representation is equal to the `Finsupp` representation of `a` multiplied by the `Finsupp` representation of `b`. Here, `Finsupp` is a type of sparse representation of functions.

For any semiring `R` and polynomials `a` and `b` over `R`, the `Finsupp` representation of their product equals the product of their individual `Finsupp` representations.


theorem Nat.mod_le : ∀ (x y : ℕ), x % y ≤ x := by sorry

This theorem states that for all natural numbers `x` and `y`, the remainder of `x` divided by `y` (expressed as `x % y`) is always less than or equal to `x`. In other words, when a natural number is divided by any other natural number, the remainder of the division operation can never be more than the dividend.

For all natural numbers x and y, x % y ≤ x.


theorem le_of_eq_of_le : ∀ {α : Type u} {a b c : α} [inst : LE α], a = b → b ≤ c → a ≤ c := by sorry

This theorem, named `le_of_eq_of_le`, states that for any type `α` that has a less than or equal to (`≤`) operation, if a certain element `a` is equal to another element `b`, and `b` is less than or equal to a third element `c`, then it must be the case that `a` is also less than or equal to `c`. In other words, it asserts the transitivity of the less than or equal to relation after an equality substitution. This holds for all elements `a`, `b`, `c` of any type `α` with a `≤` relation.


theorem Mathlib.Topology.UniformSpace.Basic._auxLemma.1 : ∀ {α : Type ua} {a b : α}, ((a, b) ∈ idRel) = (a = b) := by
  sorry

This theorem states that for any type `α` and any two elements `a` and `b` of type `α`, the pair `(a, b)` is in the identity relation `idRel` if and only if `a` and `b` are equal. In other words, `idRel` essentially captures the notion of equality for the type `α`.

For any type `α` and any elements `a` and `b` of type `α`, `(a, b)` is in the identity relation `idRel` if and only if `a = b`.


theorem IsLocalization.map_comap :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (J : Ideal S),
      Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) J) = J :=
  by sorry

The theorem `IsLocalization.map_comap` states that for any commutative semiring `R`, submonoid `M` of `R`, commutative semiring `S` and ideal `J` of `S`, where `S` is a localization of `R` at `M`, the ideal obtained by mapping the ideal that is the preimage of `J` under the algebra homomorphism from `R` to `S`, back to `S`, is equal to the original ideal `J`. In other words, if we first apply `Ideal.comap` to `J` to get its preimage in `R` and then map it back to `S` using `Ideal.map`, we get back the original ideal `J`. This theorem is about the interaction between the operations of comapping and mapping ideals in the context of algebraic localizations.

For a commutative semiring R, submonoid M of R, commutative semiring S a localization of R at M, and ideal J of S, the ideal map_comap(J) obtained by mapping the preimage of J under the algebra homomorphism from R to S and then back to S is equal to the original ideal J.


theorem Nat.cast_comm : ∀ {α : Type u_1} [inst : NonAssocSemiring α] (n : ℕ) (x : α), ↑n * x = x * ↑n := by sorry

This theorem, `Nat.cast_comm`, states that for any natural number `n` and any element `x` of a type `α` that is a non-associative semiring, the operation of casting `n` to `α` (denoted by `↑n`) and then multiplying by `x` is commutative. That is, multiplying `x` by the cast of `n` (i.e., `↑n * x`) is the same as multiplying the cast of `n` by `x` (i.e., `x * ↑n`).

For any non-associative semiring `α` and natural number `n`, the operations `↑n * x` and `x * ↑n` are equal.


theorem Set.smul_set_mono :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s t : Set β} {a : α}, s ⊆ t → a • s ⊆ a • t := by sorry

The theorem `Set.smul_set_mono` states that for all types `α` and `β`, when `β` is a scalar multiplication (`SMul`) of `α`, given two sets `s` and `t` of type `β` and an element `a` of type `α`, if set `s` is a subset of set `t` (`s ⊆ t`), then the scalar multiplication of `a` and set `s` (`a • s`) is a subset of the scalar multiplication of `a` and set `t` (`a • t`). Essentially, scalar multiplication preserves the subset relationship between two sets.

For all types `α` and `β` (where `β` is a scalar multiplication of `α`), if `s ⊆ t` are sets of type `β` and `a` is an element of type `α`, then `a • s ⊆ a • t`. (Scalar multiplication preserves subset relationships between sets.)


theorem real_inner_self_eq_norm_mul_norm :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x : F), ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖ := by
  sorry

This theorem states that for any real inner product space 'F', the real inner product of any element 'x' with itself is equal to the square of the norm of 'x'. Here, a real inner product space is a normed add comm group with an inner product operation that takes two elements of the group and produces a real number. The norm of an element is a measure of its "length" or "magnitude".

In a real inner product space, the inner product of an element with itself equals the square of its norm.


theorem Real.sin_antiperiodic : Function.Antiperiodic Real.sin Real.pi := by sorry

The theorem `Real.sin_antiperiodic` states that the sine function is antiperiodic with the antiperiod being π. An antiperiodic function is defined such that for any given input, the value of the function at the input plus the antiperiod is the negation of the value of the function at the input. In this case, for any real number `x`, `sin(x + π) = -sin(x)`.

For all real numbers x, sin(x + π) = -sin(x).


CharP.eq

theorem CharP.eq : ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p q : ℕ}, CharP R p → CharP R q → p = q := by sorry

This theorem states that for any type `R` which has an `AddMonoidWithOne` structure, if `R` has characteristic `p` and `R` has characteristic `q`, then `p` must be equal to `q`. In the context of ring theory, the characteristic of a ring is the smallest positive number of times you have to add the ring's multiplicative identity to itself to get the additive identity, or zero if this number doesn't exist. This theorem guarantees that this characteristic is unique, so if `p` and `q` are both characteristics of the same ring, they must be equal.

If a type `R` with an `AddMonoidWithOne` structure has two distinct characteristics `p` and `q`, then `p` is not the characteristic of `R`. Therefore, the characteristic of `R` is unique and must be equal to any given characteristic `p` or `q`.


theorem Filter.sup_principal :
    ∀ {α : Type u} {s t : Set α}, Filter.principal s ⊔ Filter.principal t = Filter.principal (s ∪ t) := by sorry

The theorem `Filter.sup_principal` states that for any type `α` and any two sets `s` and `t` of this type, the supremum (or join) of the principal filters of `s` and `t` is equal to the principal filter of the union of `s` and `t`. In other words, the collection of all supersets of either `s` or `t` is the same as the collection of all supersets of the union of `s` and `t`.

The principal filters of sets `s` and `t` have the same supremum as the principal filter of their union in type `α`.


theorem List.count_pos_iff_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {l : List α}, 0 < List.count a l ↔ a ∈ l := by sorry

This theorem, `List.count_pos_iff_mem`, states that for any type `α` with decidable equality and any element `a` of type `α` and any list `l` of elements of type `α`, the count of `a` in `l` is greater than 0 if and only if `a` is a member of `l`. In other words, an element `a` is in the list `l` if and only if there is at least one occurrence of `a` in `l`.

For any type `α` with decidable equality, an element `a` is in list `l` of type `α` if and only if the count of `a` in `l` is greater than 0.


/-- Every neighbourhood of the origin is absorbent.  -/
theorem absorbent_nhds_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {A : Set E}
      [inst_3 : TopologicalSpace E] [inst_4 : ContinuousSMul 𝕜 E], A ∈ nhds 0 → Absorbent 𝕜 A :=
  by sorry

This theorem states that for any type `𝕜` which is a normed field and any type `E` which is an additive commutative group and a module over `𝕜`, if `A` is a set in `E` and `E` is a topological space with a continuous scalar multiplication, then any neighborhood of the origin in `E` (indicating that `A` is in the neighborhood filter at `0`) is an absorbent set. In other words, every neighborhood of the origin has the property that for any element `x` in `E`, there is a set in `𝕜` that, when every element of this set is used to scale `x`, the result is within `A`.

For any normed field `𝕜`, any additive commutative group and `𝕜`-module `E` with continuous scalar multiplication, if `A` is a neighborhood of the origin in `E` and `x` is any element in `E`, then there exists a set `S` in `𝕜` such that for all `r` in `S`, `rx` is in `A`.


theorem sdiff_eq_bot_iff : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a \ b = ⊥ ↔ a ≤ b := by
  sorry

This theorem states that for any type `α` that forms a generalized coheyting algebra, and for any two elements `a` and `b` of type `α`, the difference (`a \ b`) is equivalent to the bottom element (`⊥`) if and only if `a` is less than or equal to `b`. In other words, in a generalized coheyting algebra, an element `a` is less than or equal to another element `b` precisely when the difference of `a` and `b` is the bottom element.

In a generalized cohesheaf algebra, two elements `a` and `b` are equivalent to the bottom element if and only if `a` is less than or equal to `b` in terms of their difference.


Finset.Nonempty.snd

theorem Finset.Nonempty.snd :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty → t.Nonempty := by sorry

This theorem, `Finset.Nonempty.snd`, states that for any two types, `α` and `β`, and any two finite sets, `s` and `t`, of these respective types, if the Cartesian product of `s` and `t` is nonempty, it implies that the finite set `t` is also nonempty. In other words, if there exists at least one ordered pair in the product set `s ×ˢ t`, there must exist at least one element in the set `t`.

If a finite product of sets is nonempty, then one of the sets is nonempty.


theorem Real.continuous_exp : Continuous Real.exp := by sorry

This theorem states that the real exponential function is continuous. In mathematical terms, it asserts that for every real number 'x', for any arbitrarily small positive number 'ε', there exists a positive number 'δ' such that for all real numbers 'y' within 'δ' distance from 'x', the absolute difference between the exponential of 'x' and the exponential of 'y' is less than 'ε'. This is a property of the real exponential function and is fundamental in analysis and calculus.

The real exponential function is continuous, i.e., for every real number x and any ε > 0, there exists δ > 0 such that |e^x - e^y| < ε for all y within δ distance from x.


theorem lt_add_iff_pos_left :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α},
      a < b + a ↔ 0 < b :=
  by sorry

The theorem `lt_add_iff_pos_left` states that for any type `α` that has an addition operation, a zero element, and a less-than relation `LT` that satisfies both the covariant and contravariant properties, for any elements `a` and `b` of this type, the inequality `a < b + a` is true if and only if `0 < b`. This theorem establishes a connection between an inequality involving addition and a simple inequality with zero, which could be useful for simplifying expressions or proving other statements about the type `α`.

For any type `α` with addition, zero, and a transitive and reflexive relation `LT`, we have `a < b + a` if and only if `0 < b`.


theorem AlgEquiv.symm_apply_apply :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (x : A₁),
      (AlgEquiv.symm e) (e x) = x :=
  by sorry

The theorem `AlgEquiv.symm_apply_apply` states that for any commutative semiring `R`, and any two semirings `A₁` and `A₂` over `R`, if we have an algebra equivalence `e` from `A₁` to `A₂`, then for any element `x` in `A₁`, applying `e` to `x`, and then applying the inverse of `e` (obtained from `AlgEquiv.symm e`) to the result, we get back `x`. This essentially says that the inverse of an algebra equivalence is its right-inverse, i.e., applying the function and then its inverse gives you the original element.

For any commutative semiring `R` and algebra equivalences `e: A₁ ≃₁ A₂` between commutative semirings `A₁` and `A₂` over `R`, we have `e (x) = e⁻¹ (e x)` for all `x` in `A₁`.


theorem differentiableAt_of_deriv_ne_zero :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, deriv f x ≠ 0 → DifferentiableAt 𝕜 f x :=
  by sorry

This theorem states that for any function `f` of a type `𝕜` with a nontrivial normed field structure mapping to a type `F` with a normed additive commutative group structure and a normed space structure over `𝕜`, and for any point `x` of `𝕜`, if the derivative of `f` at the point `x` is not zero, then `f` is differentiable at the point `x`. In mathematical terms, if $\text{deriv } f(x) \neq 0$, then `f` is differentiable at `x` in the field `𝕜`.

If a function `f` from a normed field `𝕜` to a normed space `F` over `𝕜` has a non-zero derivative at a point `x` in `𝕜`, then `f` is differentiable at `x`.


theorem Finset.sum_subtype :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {p : α → Prop} {F : Fintype (Subtype p)} (s : Finset α),
      (∀ (x : α), x ∈ s ↔ p x) → ∀ (f : α → β), (Finset.sum s fun a => f a) = Finset.sum Finset.univ fun a => f ↑a :=
  by sorry

This theorem, `Finset.sum_subtype`, states that for any types `α` and `β`, and given an additive commutative monoid over `β`, a predicate `p` on `α`, and a finite type of the subtype of `α` satisfying `p`, then for any finite set `s` of `α` such that an element `x` of `α` is in `s` if and only if `p x` is true, and any function `f` from `α` to `β`, the sum of `f x` over all elements `x` in `s` is equal to the sum of `f x` over all elements `x` in the universal set of the subtype. In other words, summing `f x` over a set `s` where `s` precisely contains the elements of `α` satisfying a property `p` is the same as summing `f x` over all elements of the subtype of `α` defined by `p`.

For any additive commutative monoid over `β`, given a finite subtype of type `α` defined by a predicate `p`, and a function `f` from `α` to `β`, the sum of `f x` over all elements `x` in the subtype equals the sum of `f x` over all elements in the universal set of the subtype.


theorem List.diff_cons :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (l₁ l₂ : List α) (a : α),
      List.diff l₁ (a :: l₂) = List.diff (List.erase l₁ a) l₂ :=
  by sorry

This theorem, `List.diff_cons`, states that for any type `α` that has a defined equality operation (`BEq α`), and for which this equality operation obeys certain laws (`LawfulBEq α`), and for any two lists (`l₁` and `l₂`) of this type `α` and any element `a` of type `α`, the difference of the first list and a new list made by prepending the element `a` to the second list (`a :: l₂`) is the same as the difference of the list obtained by removing `a` from the first list (`List.erase l₁ a`) and the original second list `l₂`. In other words, the order in which we remove elements when calculating the difference of two lists does not matter.

For any type `α` with a lawful equality, and lists `l₁` and `l₂` of type `List α`, the set difference between `l₁` and the list `a :: l₂` is equal to the set difference between `List.erase l₁ a` and `l₂`.


/-- If `f : X → Y` is an `Inducing` map, the image `f '' s` of a set `s` is compact
if and only if `s` is compact.  -/
theorem Inducing.isCompact_iff :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      Inducing f → (IsCompact s ↔ IsCompact (f '' s)) :=
  by sorry

The theorem `Inducing.isCompact_iff` states that for any two types `X` and `Y` with given topological spaces, a set `s` of type `X`, and a function `f` from `X` to `Y`, if `f` is an inducing function, then the set `s` is compact if and only if the image of `s` under `f` (denoted as `f '' s`) is compact.

Here, a set is said to be compact if for any nontrivial filter that contains the set, there exists an element within the set such that every set in the filter intersects every neighborhood of that element. An inducing function is one that induced the topology of the function's codomain on its domain.

If `f` is an inducing function from a compact set `s` in type `X` to `Y`, then the image `f '' s` is a compact set in `Y`.


/-- The new distance is an extension of the original distance.  -/
theorem UniformSpace.Completion.dist_eq :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), dist (↑α x) (↑α y) = dist x y := by sorry

The theorem `UniformSpace.Completion.dist_eq` states that for any type `α` that has a `PseudoMetricSpace` instance (that is, `α` forms a pseudometric space), and for any two elements `x` and `y` of this type, the distance between the completions of `x` and `y` (denoted as `↑α x` and `↑α y`) is equal to the distance between `x` and `y` themselves. In other words, the distance function in the completion of the space extends the original distance function in the pseudometric space.

For any pseudometric space (α, d), the completion distances ↑α(x, y) equal the original distances d(x, y) for all x, y ∈ α.


theorem convex_Icc :
    ∀ {𝕜 : Type u_1} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedAddCommMonoid β] [inst_2 : Module 𝕜 β]
      [inst_3 : OrderedSMul 𝕜 β] (r s : β), Convex 𝕜 (Set.Icc r s) :=
  by sorry

The theorem `convex_Icc` states that for any ordered semiring `𝕜` and any ordered additive commutative monoid `β` which is a module over `𝕜` with an ordered scalar multiplication, the set interval from `r` to `s` (inclusive of both `r` and `s`) is a convex set. This means that for any two points in the interval, the line segment that joins them also lies completely within the interval.

For any ordered semiring `𝕜`, ordered additive commutative monoid `β` with an ordered scalar multiplication that is a `𝕜`-module, the interval from `r` to `s` in `β` is a convex set.


/-- Additive homomorphisms preserve `bit0`.  -/
theorem map_bit0 :
    ∀ {α : Type u_2} {β : Type u_3} {F : Type u_4} [inst : NonAssocSemiring α] [inst_1 : NonAssocSemiring β]
      [inst_2 : FunLike F α β] [inst_3 : AddHomClass F α β] (f : F) (a : α), f (bit0 a) = bit0 (f a) :=
  by sorry

The theorem `map_bit0` states that for any types `α`, `β`, and `F`, given that `α` and `β` are equipped with the structure of a non-associative semiring, `F` is a function-like object from `α` to `β`, and `F` additionally has the structure of an additive homomorphism class, then for any element `f` of type `F` and any element `a` of type `α`, mapping `f` to `bit0 a` (which is shorthand for adding `a` to itself in the semiring `α`) equals the `bit0` (i.e., the sum with itself in the semiring `β`) of the image of `a` under `f`. In other words, additive homomorphisms preserve the operation 'bit0', which essentially doubles a given element in a semiring.

For any non-associative semirings `α` and `β`, additive homomorphism `F` from `α` to `β` satisfies `F(a) + F(a) = F(a + a)` for all `a` in `α`, where `+` denotes the semiring addition and `F(a + a)` is shorthand for `F(bit0 a)`.


theorem MeasureTheory.Measure.le_add_left :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν ν' : MeasureTheory.Measure α}, μ ≤ ν → μ ≤ ν' + ν := by sorry

This theorem states that for any given type `α`, measurable space `m0`, and measures `μ`, `ν`, and `ν'`, if `μ` is less than or equal to `ν`, then `μ` is also less than or equal to the sum of `ν'` and `ν`. This is a statement in the context of measure theory.

For any measurable spaces `(α, m0)` and measures `μ ≤ ν`, `μ ≤ ν' + ν`.


/-- If `p : Set X → Prop` is stable under restriction and union, and each point `x`
of a compact set `s` has a neighborhood `t` within `s` such that `p t`, then `p s` holds.  -/
theorem IsCompact.induction_on :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsCompact s →
        ∀ {p : Set X → Prop},
          p ∅ →
            (∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s) →
              (∀ ⦃s t : Set X⦄, p s → p t → p (s ∪ t)) → (∀ x ∈ s, ∃ t ∈ nhdsWithin x s, p t) → p s :=
  by sorry

The theorem `IsCompact.induction_on` states that for a given topological space `X` and a compact set `s` in `X`, if a property `p` holds for the empty set, is preserved under set restriction (i.e., if `s` is a subset of `t` and `p` holds for `t`, then `p` holds for `s`) and union, and for every point `x` in set `s` there exists a neighborhood `t` within `s` such that property `p` holds for `t`, then property `p` holds for the set `s` itself. This theorem serves as an induction principle for compact sets in a topological space.

If a property is empty-cases, union-preserving, and satisfies the finite intersection property on the open neighborhoods of each point in a compact set, then it holds for the set itself.


theorem Matrix.zero_dotProduct :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (v : m → α),
      Matrix.dotProduct 0 v = 0 :=
  by sorry

The theorem `Matrix.zero_dotProduct` states that for any type `m` of finite size and any non-unital, non-associative semiring `α`, the dot product of the zero vector and any vector `v` (which is a function from `m` to `α`) is always the zero element of the semiring `α`. This is equivalent to saying that the sum of entrywise products of the zero vector and any other vector is always zero.

For any finite size type m and non-unital, non-associative semiring α, the dot product of the zero vector and any vector in the m-dimensional space over α is the semiring's zero element.


theorem Polynomial.modByMonic_eq_sub_mul_div :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) {q : Polynomial R},
      Polynomial.Monic q → p %ₘ q = p - q * (p /ₘ q) :=
  by sorry

The theorem `Polynomial.modByMonic_eq_sub_mul_div` is a statement about polynomials over a ring. It states that for any given ring `R` and any polynomials `p` and `q` in that ring, if the polynomial `q` is Monic (i.e., its leading coefficient is 1), then the remainder of `p` divided by `q` (denoted as `p %ₘ q`) is equal to the difference between `p` and the product of `q` and the quotient of `p` divided by `q` (denoted as `p - q * (p /ₘ q)`). In essence, this theorem is a mathematical expression of the division algorithm for polynomials where the divisor is a monic polynomial.

For any polynomials `p` and `q` in a ring where `q` is monic, `p %ₘ q` equals `p - q * (p /ₘ q)`.


theorem Int.floor_add_int :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α) (z : ℤ), ⌊a + ↑z⌋ = ⌊a⌋ + z := by sorry

This theorem states that for any type `α` that is a linear ordered ring and also a floor ring, and for any element `a` of type `α` and integer `z`, the floor of the sum of `a` and `z` (where `z` is coerced to type `α`) is equal to the sum of the floor of `a` and `z`. In mathematical terms, it means that for any real number `a` and any integer `z`, ⌊a + z⌋ = ⌊a⌋ + z.

For any linear ordered ring and floor ring type `α` and its element `a` of type `α` and integer `z`, the floor of their sum is equal to the sum of their floors: `⌊a + z⌋ = ⌊a⌋ + z`.


theorem Asymptotics.isTheta_refl :
    ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] (f : α → E) (l : Filter α), f =Θ[l] f := by sorry

This theorem, `Asymptotics.isTheta_refl`, states that for any function `f` from a type `α` to a normed space `E`, and for any filter `l` on `α`, the function `f` is asymptotically equivalent to itself. In more mathematical terms, this means that the function `f` has the same asymptotic behavior as itself when we approach the points determined by the filter `l`. This is a reflexivity property in the context of asymptotic equivalence.

For any function `f : α → E` and filter `l` on `α`, `f` is asymptotically equivalent to itself, i.e., `Asymptotics.isTheta f l f`.


theorem Nat.two_pow_pos : ∀ (w : ℕ), 0 < 2 ^ w := by sorry

This theorem states that for any natural number `w`, the value of 2 raised to the power `w` is always greater than 0. In mathematical terms, for any $w \in \mathbb{N}$, $2^w > 0$.


theorem Mathlib.Data.FunLike.Basic._auxLemma.1 :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, (⇑f = ⇑g) = (f = g) := by sorry

This theorem, from the Mathlib library in Lean, states that for any sorts `F`, `α`, and `β`(where `β` is dependent on `α`), and for any `i` which is an instance of the typeclass `DFunLike` over `F`, `α` and `β`, then for any two objects `f` and `g` of sort `F`, the statement that the function-application of `f` is equal to the function-application of `g` is equivalent to saying that `f` is equal to `g`. Essentially, this theorem asserts that two functional-like objects are equal if and only if their corresponding function-applications are equal.

For any sorts `F`, `α`, and `β` (with `β` dependent on `α`), and for any `i` an instance of `DFunLike` over `F`, `α`, and `β`, two objects `f` and `g` of sort `F` are equal if and only if `f α = g α` for all `α`.


theorem Multiset.eq_of_mem_replicate : ∀ {α : Type u_1} {a b : α} {n : ℕ}, b ∈ Multiset.replicate n a → b = a := by
  sorry

This theorem states that for any type `α`, any elements `a` and `b` of type `α`, and any natural number `n`, if `b` is an element of the multiset obtained by replicating `a` `n` times, then `b` must be equal to `a`. Essentially, this theorem affirms that any element in a multiset created from multiple copies of a single element is equal to that original element.

For any type `α`, any natural number `n`, and any elements `a` and `b` of type `α`, if `b` is an element of the multiset of `n` copies of `a`, then `a = b`.


theorem Nat.Primrec'.comp₂ :
    ∀ (f : ℕ → ℕ → ℕ),
      (Nat.Primrec' fun v => f (Vector.head v) (Vector.head (Vector.tail v))) →
        ∀ {n : ℕ} {g h : Vector ℕ n → ℕ}, Nat.Primrec' g → Nat.Primrec' h → Nat.Primrec' fun v => f (g v) (h v) :=
  by sorry

The theorem `Nat.Primrec'.comp₂` states that for any function `f` mapping two natural numbers to a natural number, if `f` composed with the head operation of a vector and the head operation of the tail of a vector is primitive recursive, then for any natural number `n` and any two functions `g` and `h` from vectors of length `n` to natural numbers that are primitive recursive, the function that maps a vector `v` to `f` applied to `g(v)` and `h(v)` is also primitive recursive. In other words, if `f` is primitive recursive when applied to the first two elements of a vector, and `g` and `h` are primitive recursive, then the composition of `f` with `g` and `h` is also primitive recursive.

If functions `f` (mapping two natural numbers to a natural number), `g`, and `h` (each mapping vectors of length `n` to natural numbers) are primitive recursive, then the function that maps a vector `v` to `f` applied to `g(v)` and `h(v)` is also primitive recursive.


theorem Pi.uniformContinuous_proj :
    ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (i : ι), UniformContinuous fun a => a i := by
  sorry

This theorem states that for any index set `ι` and any family of types `α` indexed by `ι`, where each type in the family has a uniform space structure, the projection function that assigns to each element in the product space the coordinate corresponding to a fixed index `i` is uniformly continuous. In other words, if `a` is close to `b` in the product space, then the `i`-th coordinates of `a` and `b` are also close, regardless of the location of `a` and `b` in the product space.

For any indexed family of uniform spaces `(α\_i : i ∈ ι)` and their product space `Π i, α\_i`, the projection function `π\_i : Π x, α\_i (π i x) ︙ α\_i` is uniformly continuous.


theorem rank_top :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      Module.rank R ↥⊤ = Module.rank R M :=
  by sorry

This theorem, `rank_top`, states that for any Ring `R` and any Additive Commutative Group `M` which is also a `R`-module, the rank of the top submodule of `M` (denoted by `↥⊤`) is equal to the rank of the module `M` itself. In other words, it expresses that the maximal submodule of a module has the same rank as the module itself.

The rank of the top submodule of an R-module M, as an R-vector space, equals the rank of M.


theorem IsMinFilter.bicomp_mono :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β}
      {l : Filter α} {a : α} [inst_2 : Preorder δ] {op : β → γ → δ},
      ((fun x x_1 => x ≤ x_1) ⇒ (fun x x_1 => x ≤ x_1) ⇒ fun x x_1 => x ≤ x_1) op op →
        IsMinFilter f l a → ∀ {g : α → γ}, IsMinFilter g l a → IsMinFilter (fun x => op (f x) (g x)) l a :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, and `δ`, given a preorder on `β`, `γ`, and `δ`, a function `f` from `α` to `β`, a filter `l` on `α`, an element `a` of `α`, and an operation `op` from `β` and `γ` to `δ` that preserves the preorder (meaning that if `x ≤ y`, then `op x z ≤ op y z` and `op z x ≤ op z y` for any `z`), if `f` and `g` (a function from `α` to `γ`) are both minimum filters at `a` with respect to `l`, then the function which applies `op` to `f x` and `g x` for each `x` in `α` is also a minimum filter at `a` with respect to `l`.

In other words, if `f` and `g` are both functions from `α` to `β` and `γ` respectively such that `f a` and `g a` are less than or equal to all other values of `f` and `g` in some neighborhood of `a`, then, for an operation `op` that preserves the preorder, the value of `op (f a) (g a)` is less than or equal to the values of `op (f x) (g x)` for all `x` in the same neighborhood of `a`. This theorem generalizes the concept of a minimum in a mathematical setting.

Given functions `f: α -> β`, `g: α -> γ`, and an operation `op: β x γ -> δ` preserving the preorder on `β`, `γ`, and `δ`, if `f` and `g` are minimum filters at `a` in `α` with respect to a filter `l`, then the function `x => op (f x) (g x)` is also a minimum filter at `a` with respect to `l`.


AffineIsometryEquiv.ext

theorem AffineIsometryEquiv.ext :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] {e e' : P ≃ᵃⁱ[𝕜] P₂},
      (∀ (x : P), e x = e' x) → e = e' :=
  by sorry

The theorem `AffineIsometryEquiv.ext` states that for any field 𝕜, vector spaces V and V₂, affine spaces P and P₂, if e and e' are affine isometry equivalences (isomorphisms that preserve the affine structure and the distance) between P and P₂, then e is equal to e' if they are equal for every point x in P. Essentially, it ensures that two affine isometry equivalences are the same if they map each point in the original space to the same point in the target space.

For any fields 𝕜, vector spaces V and V₂, and affine spaces P and P₂, if two affine isometry equivalences between P and P₂ agree on every point, then they are equal.


theorem Metric.mem_ball_self :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, 0 < ε → x ∈ Metric.ball x ε := by sorry

The theorem `Metric.mem_ball_self` states that for any type `α` that is a PseudoMetricSpace, any point `x` in `α`, and any real number `ε` greater than zero, `x` is an element of the metric ball centered at `x` with radius `ε`. In other words, in any pseudometric space, any point is within an open ball centered at itself with a positive radius.

For any pseudometric space (α, d), and any point x ∈ α and positive real number ε, x belongs to the metric ball B(x, ε) = {y ∈ α | d(x, y) < ε}.


theorem Set.mem_Ioo : ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Ioo a b ↔ a < x ∧ x < b := by sorry

This theorem states that for any type α with a preorder relation, and any elements a, b, and x of α, x is an element of the left-open right-open interval between a and b (denoted `Set.Ioo a b`) if and only if a is less than x and x is less than b. It implies that membership in the interval `Set.Ioo a b` is equivalent to satisfying the two inequalities `a < x` and `x < b`.

For any preordered type α and elements a, b, x of α, x lies in the open interval (a, b) if and only if a < x and x < b.


theorem ENNReal.top_rpow_of_neg : ∀ {y : ℝ}, y < 0 → ⊤ ^ y = 0 := by sorry

This theorem states that for any real number `y`, if `y` is less than 0, then raising the extended non-negative real number "top" (which represents positive infinity) to the power `y` results in 0. In other words, in the extended non-negative real number system, positive infinity raised to any negative real number power equals zero.

For any real number `y` less than 0, 0 = ∞^y in the extended non-negative real numbers.


theorem Filter.mem_iInf_of_directed :
    ∀ {α : Type u} {ι : Sort x} {f : ι → Filter α},
      Directed (fun x x_1 => x ≥ x_1) f → ∀ [inst : Nonempty ι] (s : Set α), s ∈ iInf f ↔ ∃ i, s ∈ f i :=
  by sorry

The theorem `Filter.mem_iInf_of_directed` states that for all types `α` and `ι`, and a function `f` mapping `ι` to a filter on `α`, if the function `f` is directed with respect to the greater than or equal to relation (meaning, for any two filters in the image of `f`, there is a filter which is greater than or equal to both), then for any nonempty `ι` and a set `s` of type `α`, the set `s` is a member of the infimum of the range of `f` if and only if there exists an `i` such that `s` is a member of the filter `f i`.

In simpler terms, it states that a set `s` is in the infimum of a directed family of filters if and only if `s` is in one of the filters in the family.

Given a type `α`, a nonempty index type `ι`, and a directed family `{F : ι → filter α | i ∈ ι}`, a set `s ∈ α` belongs to the infimum of the family if and only if there exists an index `i` such that `s ∈ F i`.


theorem sq_le_sq : ∀ {α : Type u_1} [inst : LinearOrderedRing α] {a b : α}, a ^ 2 ≤ b ^ 2 ↔ |a| ≤ |b| := by sorry

This theorem, `sq_le_sq`, states that for any type `α` that has a structure of a linearly ordered ring, the square of any element `a` of this type is less than or equal to the square of any other element `b` if and only if the absolute value of `a` is less than or equal to the absolute value of `b`. In mathematical terms, for any `a` and `b` in the linearly ordered ring `α`, `a^2 ≤ b^2` is equivalent to `|a| ≤ |b|`.

In a linearly ordered ring, the square of an element is less than or equal to the square of another element if and only if the absolute values of the elements are in that order.


theorem Mathlib.Algebra.Group.Prod._auxLemma.2 :
    ∀ {M : Type u_5} {N : Type u_6} [inst : Zero M] [inst_1 : Zero N] {x : M} {y : N}, ((x, y) = 0) = (x = 0 ∧ y = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Group.Prod._auxLemma.2`, states that for any types `M` and `N` that have zero elements, and any elements `x` of type `M` and `y` of type `N`, the pair `(x, y)` is equivalent to zero if and only if both `x` and `y` are zero. In other words, a pair of elements from two types with zero elements is considered zero if both elements in the pair are individually zero.

For types `M` and `N` with zero elements, `(x, y) = (0 : M) × (0 : N)` if and only if `x = 0` and `y = 0`.


theorem MeasureTheory.SimpleFunc.measurableSet_fiber :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (x : β),
      MeasurableSet (↑f ⁻¹' {x}) :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.measurableSet_fiber` states that for any types `α` and `β`, given a measurable space `α` and a simple function `f` from `α` to `β`, the preimage of any singleton set `{x}` under the function `f` is a measurable set. Here, `x` is a value of type `β`. In other words, this theorem states that for any value `x` in the codomain, the set of elements in the domain that map to `x` under `f` is a measurable set.

For any measurable space (α, Σ), simple function f : α → β, and x ∈ β, the preimage {α ∣ f(α) = x} is a measurable set in Σ.


theorem EMetric.ball_mem_nhds :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (x : α) {ε : ENNReal}, 0 < ε → EMetric.ball x ε ∈ nhds x := by sorry

The theorem `EMetric.ball_mem_nhds` asserts that for any type `α` which has a pseudo extended metric space structure and for any instance `x` of that type, given an extended nonnegative real number `ε` which is greater than zero, the epsilon-ball around `x` (the set of all points `y` in `α` such that the extended distance between `y` and `x` is less than `ε`) is a member of the neighborhood filter of `x`. In simpler terms, if you take any point in a pseudo extended metric space and any non-zero positive extended real number, the epsilon-ball around that point is a neighborhood of that point.

For any pseudo extended metric space `(α, d)` and point `x ∈ α`, the epsilon-ball `{y ∈ α | d(x, y) < ε}` is an element of the neighborhood filter of `x`, for any extended non-negative real number `ε > 0`.


theorem MeasureTheory.withDensity_smul :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (r : ENNReal) {f : α → ENNReal},
      Measurable f → μ.withDensity (r • f) = r • μ.withDensity f :=
  by sorry

This theorem states that for any measurable space `α`, equipped with a measure `μ`, and for any extended nonnegative real number `r` and any function `f` from `α` to the extended nonnegative real numbers that is measurable, the measure with density of `r` scaled by `f` is equal to `r` scaled by the measure with density `f`. In mathematical terms, if `f : α → [0, ∞]` is a measurable function on a measurable space `α` with a measure `μ`, then the measure with density `r*f` is the same as `r` times the measure with density `f`, where `r` is in `[0, ∞]`.

For any measurable space `α` with measure `μ`, and measurable function `f : α → [0, ∞]` on `α`, the measure with density `r * f` is equal to `r` times the measure with density `f` for any extended nonnegative real number `r`.


theorem Filter.map_comap :
    ∀ {α : Type u} {β : Type v} (f : Filter β) (m : α → β),
      Filter.map m (Filter.comap m f) = f ⊓ Filter.principal (Set.range m) :=
  by sorry

This theorem states that for any types `α` and `β`, a filter `f` on `β`, and a map `m` from `α` to `β`, the filter obtained by first taking the inverse image of `f` under `m` (using `Filter.comap m f`) and then taking the direct image under `m` (using `Filter.map m`) is equal to the filter obtained by taking the intersection of `f` and the filter consisting of all supersets of the range of `m` (using `Filter.principal (Set.range m)`). In other words, mapping the comap of a filter under a function is the same as intersecting the original filter with the principal filter of the range of that function. In terms of set theory, this theorem is expressing a property about the interaction of inverse and direct image filters under a function and how it relates to the intersection of filters.

For any map $m:\alpha \to \beta$, filter $f$ on $\beta$, and type $\alpha$, the filters $m.\mathit{inverseImage} (f)$ and $f \cap \mathit{principalFilter} (\mathrm{range} (m))$ are equal.


theorem Polynomial.X_pow_sub_C_ne_zero :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] {n : ℕ},
      0 < n → ∀ (a : R), Polynomial.X ^ n - Polynomial.C a ≠ 0 :=
  by sorry

The theorem `Polynomial.X_pow_sub_C_ne_zero` states that for any nontrivial ring `R` and positive natural number `n`, the difference between the `n`th power of the polynomial variable `X` and the constant polynomial `a` is not equal to zero. In other words, no matter what constant `a` we choose, subtracting it from `X^n` will never result in a zero polynomial, as long as `n` is a positive integer and `R` is a nontrivial ring. This means that the polynomial `X^n - a` always has some non-zero terms for any choice of `a` and positive `n`.

For any nontrivial ring R and positive natural number n, the polynomial X^n - a is never equal to the zero polynomial.


theorem Complex.cpow_add : ∀ {x : ℂ} (y z : ℂ), x ≠ 0 → x ^ (y + z) = x ^ y * x ^ z := by sorry

This theorem states that for all complex numbers `x`, `y`, and `z`, where `x` is not equal to zero, the property of exponentiation distributes over addition. In other words, raising `x` to the power of `(y + z)` is the same as raising `x` to the power of `y` and `z` separately, and then multiplying the results together. This is the complex number equivalent of the exponentiation rule `a^(b + c) = a^b * a^c` for real numbers.

For complex numbers `x` neither equal to zero, `x^(y + z) = x^y * x^z`.


theorem iInf_comm :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : CompleteLattice α] {f : ι → ι' → α},
      ⨅ i, ⨅ j, f i j = ⨅ j, ⨅ i, f i j :=
  by sorry

This theorem states that for any complete lattice `α` and for any two types `ι` and `ι'`, the double infimum of a function `f` taking `ι` and `ι'` to `α`, when taken first over `ι` and then over `ι'`, is equal to the double infimum taken first over `ι'` and then over `ι`. In other words, the order in which the infimums are taken does not matter. This can be interpreted as a generalization of the commutative principle to infimum operations over two different types in the context of complete lattices.

For any complete lattice `α` and functions `f: ι × ι' → α`, the double infimum `⨄⨄(f)` over `ι` then `ι'` equals the double infimum `⨄⨄(f)` over `ι'` then `ι`.


PrincipalSeg.down

theorem PrincipalSeg.down :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≺i s) {b : β},
      s b f.top ↔ ∃ a, f.toRelEmbedding a = b :=
  by sorry

This theorem, `PrincipalSeg.down`, states that for all types `α` and `β`, and for all relations `r` and `s` on these types respectively, if `f` is a principal segment of `s` with respect to `r`, then for any element `b` of `β`, `b` is related to the `top` of `f` under `s` if and only if there exists an element `a` in `α` such that `a` is mapped to `b` by the relation embedding of `f`. Essentially, it's a way of expressing the properties of a principal segment in terms of an existential property on its relation embedding.

For any types `α` and `β`, relations `r` on `α` and `s` on `β`, and principal segment `f` of `s` with respect to `r`, an element `b` of `β` is related to the top of `f` under `s` if and only if there exists an element `a` in `α` such that `a` is related to `b` under the relation embedding of `f` and `r`.


theorem Finset.prod_image :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} {f : α → β} [inst : CommMonoid β] [inst_1 : DecidableEq α]
      {s : Finset γ} {g : γ → α},
      (∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y) →
        (Finset.prod (Finset.image g s) fun x => f x) = Finset.prod s fun x => f (g x) :=
  by sorry

This theorem, `Finset.prod_image`, states that for any types `α`, `β`, and `γ`, any function `f` from `α` to `β` where `β` is a commutative monoid, and any function `g` from `γ` to `α`, if for any `x` and `y` in a finite set `s` of type `γ`, `g x` equals `g y` implies `x` equals `y`, then the product of `f x` for `x` in the image of `s` under `g` is equal to the product of `f (g x)` for `x` in `s`. In mathematical terms, this states that the product over a set is not affected by applying a function to the set elements provided the function does not identify different elements.

Given a commutative monoid β, if function g from γ to a set X with elements having distinct images under g, then the product of f(g(x)) over the image of a finite set s under g is equal to the product of f(x) over x in s.