theorem isNoetherian_of_fg_of_noetherian :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
      [I : IsNoetherianRing R], Submodule.FG N → IsNoetherian R ↥N :=
  by sorry

The theorem `isNoetherian_of_fg_of_noetherian` states that for any ring `R` and an additive commutative group `M` that is a module over `R`, if `R` is a Noetherian ring (i.e., all its ideals are finitely generated), then for any submodule `N` of `M` that is finitely generated, `N` is also a Noetherian module over `R`. In other words, if a ring is Noetherian and a submodule of a module over this ring is finitely generated, then this submodule is also Noetherian as a module over the ring.

If `R` is a Noetherian ring and `M` is an `R`-module with `N` a finitely generated submodule of `M`, then `N` is a Noetherian `R`-module.


theorem Int.negOnePow_even : ∀ (n : ℤ), Even n → n.negOnePow = 1 := by sorry

The theorem `Int.negOnePow_even` states that for any integer `n`, if `n` is even (i.e., there exists another integer `r` such that `n = r + r`), then raising `-1` to the power of `n` yields `1`. In other words, the negative one raised to any even integer power is equal to one.

For any even integer `n`, $-1$ raised to the power of `n` equals 1.


theorem lt_inv : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (a < b⁻¹ ↔ b < a⁻¹) := by
  sorry

This theorem `lt_inv` states that for any type `α` that has a structure of a `LinearOrderedSemifield` (a field with a linear order), and for any two elements `a` and `b` of this type that are greater than 0, `a` is less than the inverse of `b` if and only if `b` is less than the inverse of `a`. This theorem basically establishes a relationship between the ordering of two positive elements and the ordering of their inverses in a linearly ordered semifield.

In a LinearOrderedSemifield type, for positive elements `a` and `b`, `a < (−1 : α) <=> b < (−1 : α)`.


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

The theorem `CategoryTheory.IsIso.of_isIso_comp_left` states that for any category `C` and any three objects `X`, `Y`, and `Z` in `C`, if the morphism `f` from `X` to `Y` is an isomorphism and the composition of `f` and `g` (where `g` is a morphism from `Y` to `Z`) is also an isomorphism, then `g` itself is an isomorphism. In other words, in the context of category theory, if a morphism and its composition with another morphism are both invertible, then the second morphism is also invertible.

If `f: X ➝ Y` is an isomorphism in a category `C` and the composition `f ∘ g: Y ➝ Z` is an isomorphism for any `g: Y ➝ Z`, then `g` is an isomorphism.


theorem Function.support_add :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] (f g : α → M),
      (Function.support fun x => f x + g x) ⊆ Function.support f ∪ Function.support g :=
  by sorry

The theorem `Function.support_add` is stating that for any types `α` and `M`, where `M` is an `AddZeroClass` (meaning it supports addition and has a zero element), and for any two functions `f` and `g` from `α` to `M`, the support of the function that adds `f` and `g` is a subset of the union of the supports of `f` and `g`. In other words, any point `x` for which `f(x) + g(x)` is non-zero must be a point at which either `f(x)` is non-zero, `g(x)` is non-zero, or both.

For functions `f` and `g` from type `α` to an additive zero class `M`, `support (f + g) ⊆ support f ∪ support g`.


theorem CategoryTheory.Preadditive.epi_of_cancel_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q : C}
      (f : P ⟶ Q), (∀ {R : C} (g : Q ⟶ R), CategoryTheory.CategoryStruct.comp f g = 0 → g = 0) → CategoryTheory.Epi f :=
  by sorry

The theorem `CategoryTheory.Preadditive.epi_of_cancel_zero` states that: for any Category `C` that is preadditive (i.e., for which the collection of all morphisms has a structure of an abelian group, and composition of morphisms is bilinear), and for any objects `P` and `Q` in `C` with a morphism `f` from `P` to `Q`, if for all objects `R` in `C`, any morphism `g` from `Q` to `R` that makes the composition `f ≫ g` equal to zero implies `g` is zero, then `f` is an epimorphism. In other words, in a preadditive category, if the composition of a morphism `f` with any other morphism `g` is zero only when `g` is the zero morphism, then `f` is an epimorphism.

In a preadditive category, a morphism is an epimorphism if and only if the composition of the morphism with any zero morphism results in the zero morphism.


theorem Iio_mem_nhdsSet_Icc :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderClosedTopology α] {a b c : α},
      b < c → Set.Iio c ∈ nhdsSet (Set.Icc a b) :=
  by sorry

This theorem states that for any type `α` that is equipped with a linear order, a topological space structure, and an order-closed topology, and for any three elements `a`, `b`, and `c` of this type where `b < c`, then the left-infinite right-open interval ending at `c`, denoted `Set.Iio c`, is a neighborhood of the closed interval between `a` and `b`, denoted `Set.Icc a b`. In other words, there are open sets in the topology on `α` which contain the closed interval from `a` to `b` and are contained in the half-open interval from `-∞` to `c`.

For any type `α` with a linear order, topology, and order-closed topology, the left-infinite right-open interval `Set.Iio c` is a neighborhood of the closed interval `Set.Icc a b` for any `a < b` in `α`.


theorem Polynomial.ofFinsupp_neg :
    ∀ {R : Type u} [inst : Ring R] {a : AddMonoidAlgebra R ℕ}, { toFinsupp := -a } = -{ toFinsupp := a } := by sorry

This theorem states that for any ring `R` and an additive monoid algebra `a` over `R` and the natural numbers, the negative of the Finsupp conversion of `a` equals the Finsupp conversion of the negative of `a`. In other words, the operation of negation commutes with the Finsupp conversion in the context of additive monoid algebras over a ring and the natural numbers. The Finsupp conversion is a method to represent elements of the additive monoid algebra as formal finite linear combinations.

For any additive monoid algebra `a` over a ring `R` and the natural numbers, the negation of its Finsupp conversion is equal to the Finsupp conversion of the negation of `a`.


theorem AffineEquiv.pointReflection_self :
    ∀ (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
      [inst_3 : AddTorsor V₁ P₁] (x : P₁), (AffineEquiv.pointReflection k x) x = x :=
  by sorry

This theorem states that for any point `x` in an affine space `P₁`, which is over a ring `k` and has difference group `V₁`, the point reflection of `x` with respect to itself is `x`. In other words, if you reflect a point with respect to itself, you get the same point back. This is a property of point reflection in an affine space.

In an affine space over a ring, the point reflection of a point with respect to itself is equal to the original point.


theorem ENNReal.pow_pos : ∀ {a : ENNReal}, 0 < a → ∀ (n : ℕ), 0 < a ^ n := by sorry

This theorem states that for all extended nonnegative real numbers `a`, if `a` is greater than zero, then for any natural number `n`, `a` raised to the power `n` is also greater than zero. In other words, the power of any positive extended nonnegative real number is also positive.

For all extended nonnegative real numbers `a` greater than zero, `a^n` is positive for any natural number `n`.


theorem CauSeq.Completion.mk_smul :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {β : Type u_2} [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {γ : Type u_3} [inst_3 : SMul γ β] [inst_4 : IsScalarTower γ β β] (c : γ)
      (f : CauSeq β abv), c • CauSeq.Completion.mk f = CauSeq.Completion.mk (c • f) :=
  by sorry

This theorem, named `CauSeq.Completion.mk_smul`, states that for any scalar `c` of type `γ` and any Cauchy sequence `f` of type `β` with respect to an absolute value function `abv`, the action of scalar multiplication on the result of mapping `f` into the Cauchy completion (i.e., `c • CauSeq.Completion.mk f`) equals the result of mapping the scalar multiplication of `c` and `f` into the Cauchy completion (i.e., `CauSeq.Completion.mk (c • f)`). Here, the types `α`, `β`, and `γ` are equipped with the structures of a linear ordered field, a ring, and a scalar multiplication, respectively, and `abv` is an absolute value function on `β`. The scalar multiplication between `γ` and `β` forms a scalar tower over `β`, which means that scalar multiplication is associative between `γ` and `β`.

For any scalar `c` of type `γ` and Cauchy sequence `f` of type `β` in a linear ordered field `α`, with respect to an absolute value function `abv`, the mapping of scalar multiplication `c • f` into the Cauchy completion is equal to scalar multiplication of `c` with the completion of `f`.


/-- The inductively defined equivalence closure of a binary relation r is the infimum
of the set of all equivalence relations containing r.  -/
theorem Setoid.eqvGen_eq :
    ∀ {α : Type u_1} (r : α → α → Prop), EqvGen.Setoid r = sInf {s | ∀ ⦃x y : α⦄, r x y → Setoid.Rel s x y} := by sorry

The theorem `Setoid.eqvGen_eq` states that for any type `α` and a binary relation `r` on `α`, the inductively defined equivalence closure of `r` (which is `EqvGen.Setoid r`) is the greatest lower bound or infimum (`sInf`) of the set of all equivalence relations that contain `r`. In other words, it's the smallest equivalence relation that extends `r`. This equivalence relation is represented by the set `{s | ∀ ⦃x y : α⦄, r x y → Setoid.Rel s x y}`, meaning the set of all equivalence relations `s` such that if `r` holds between `x` and `y`, then `s` also holds between `x` and `y`.

The `Setoid.eqvGen_eq` theorem in Lean 4 asserts that the equivalence closure of a binary relation `r` on type `α` is the smallest equivalence relation containing `r`.


theorem CategoryTheory.Discrete.mk_as : ∀ {α : Type u₁} (X : CategoryTheory.Discrete α), { as := X.as } = X := by sorry

This theorem states that for any type `α` and any object `X` of the category `CategoryTheory.Discrete α`, constructing a new object with `as` field equal to `X.as` results in the original object `X`. In other words, the `as` field completely determines an object in the `CategoryTheory.Discrete α` category.

For any type `α` and object `X` in `CategoryTheory.Discrete α`, `X` and the object with `as` field equal to `X.as` are equal.


HasFDerivAt.hasDerivAt

theorem HasFDerivAt.hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {f' : 𝕜 →L[𝕜] F}, HasFDerivAt f f' x → HasDerivAt f (f' 1) x :=
  by sorry

The theorem `HasFDerivAt.hasDerivAt` states that for any field `𝕜` which is a non-trivially normed field, and for any normed add commutative group `F` over the field `𝕜`, if a function `f` from `𝕜` to `F` has the continuous linear map `f'` as its Frechet derivative at a point `x` in 𝕜, then `f` also has `f' 1` as its derivative at the same point `x`. In other words, if `f` satisfies the condition `f x' = f x + f' (x' - x) + o(x' - x)` as `x'` approaches `x`, then it also satisfies `f x' = f x + (x' - x) • f' 1 + o(x' - x)` as `x'` approaches `x`.

If `f : ℝ⁎ → F` is a differentiable function from a non-trivially normed field `ℝ⁎` to a normed additive group `F`, and `f' : ℝ⁎ → L(ℝ⁎, F)` is its Frechet derivative, then `f' 1` is its derivative at any point `x ∈ ℝ⁎`, i.e., `df x = dx • f' 1 + r(x)` with `∥r(x)∥ ≤ ε ∥x' - x∥ for any ε > 0 and `x' ≈ x`.


theorem Polynomial.coeff_sum :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (n : ℕ)
      (f : ℕ → R → Polynomial S),
      Polynomial.coeff (Polynomial.sum p f) n = Polynomial.sum p fun a b => Polynomial.coeff (f a b) n :=
  by sorry

The theorem `Polynomial.coeff_sum` states that for any semiring `R` and `S`, given a polynomial `p` of type `Polynomial R`, a natural number `n`, and a function `f` from pairs of natural numbers and elements of `R` to `Polynomial S`, the coefficient of `X^n` in the sum of the values of the function `f` applied to the coefficients of the polynomial `p` is equal to the sum of the coefficients of `X^n` in the polynomials resulting from applying the function `f` to each pair of a power of `X` and its coefficient in `p`. In mathematical terms, this could be denoted as
```
(coeff ∘ (sum p f)) n = (sum p (λ a b, coeff (f a b) n)
```
This theorem captures a property of the way we can distribute the `coeff` function over the `sum` of polynomials.

For any semiring `R`, `S`, polynomial `p` of type `Polynomial R`, natural number `n`, and function `f` from pairs of natural numbers and elements of `R` to `Polynomial S`, the coefficient of `X^n` in the sum of the polynomials obtained by applying `f` to each coefficient-power pair of `p` is equal to the coefficient of `X^n` in the polynomial obtained by applying `f` to each coefficient-power pair of `p` and summing the results.


theorem Mathlib.RingTheory.DedekindDomain.Ideal._auxLemma.7 :
    ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] {I J : Ideal A}, (I ∣ J) = (J ≤ I) := by sorry

This theorem is from the ring theory and pertains to Dedekind domains. Given a type `A` that forms a commutative ring and is a Dedekind domain, and two ideals `I` and `J` in `A`, the theorem states that ideal `I` divides ideal `J` if and only if `J` is a subset (or equal to) `I`. In other words, for every element in `J`, there is an element in `I` that divides it in the Dedekind domain `A`.

A Dedekind domain ideal I divides ideal J if and only if J is contained in I. (In other words, I | J if and only if J ⊇ I.)


theorem OrderIso.map_ciInf :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
      [inst_1 : ConditionallyCompleteLattice β] [inst_2 : Nonempty ι] (e : α ≃o β) {f : ι → α},
      BddBelow (Set.range f) → e (⨅ i, f i) = ⨅ i, e (f i) :=
  by sorry

This theorem states that for any types `α` and `β`, and for any index type `ι` such that `α` and `β` are both conditionally complete lattices and `ι` is nonempty, if we have an order-preserving bijection `e` from `α` to `β` and a function `f` from `ι` to `α` whose range is bounded below, then the image under `e` of the infimum (greatest lower bound) over all `i` of `f(i)` is equal to the infimum over all `i` of the image under `e` of `f(i)`. In other words, the order-preserving bijection `e` commutes with taking infima over a lower-bounded range.

 Given order-preserving bijections between conditionally complete lattices `α`, `β`, index type `ι` with a nonempty range, and a function `f : ι → α` whose range is bounded below, the infimum of `e(f(i))` over `i` equals `e` of the infimum of `f(i)`.

In other words, `e(⨧ i in ι (f i)) = ⨧ i in ι (e (f i))` where `⨧` denotes the infimum (greatest lower bound) operator.


theorem Set.add_singleton : ∀ {α : Type u_2} [inst : Add α] {s : Set α} {b : α}, s + {b} = (fun x => x + b) '' s := by
  sorry

The theorem `Set.add_singleton` states that for any type `α` equipped with an addition operation, any set `s` of elements of type `α`, and any element `b` of type `α`, the addition of the set `s` with the singleton set containing `b` is equal to the image of the set `s` under the function `fun x => x + b`. That is, each element of the set `s` is mapped to an element that is obtained by adding `b` to it. Here the `''` symbol represents the image of a set under a function.

For any type `α` with addition, set `s ⊆ α`, and element `b ∈ α`, the set `s ∪ {b} = {x | ∃ y ∈ s, x = y + b}`.


theorem EMetric.isOpen_ball :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {ε : ENNReal}, IsOpen (EMetric.ball x ε) := by sorry

This theorem states that for any type `α` that has a `PseudoEMetricSpace` structure, any point `x` of type `α`, and any extended nonnegative real number `ε`, the ε-ball around `x` in the pseudometric space is an open set. In mathematical terms, considering a pseudometric space, the ball of radius `ε` centered at a point `x` is always an open set. The ball of radius `ε` around `x` (denoted `EMetric.ball x ε` in Lean 4) is defined as the set of all points `y` such that the extended distance (edist) between `y` and `x` is less than `ε`.

For any pseudometric space (α, d) and point x ∈ α, the ε-ball B(x, ε) = {y ∈ α | edist(x, y) < ε} is an open set in α.


theorem ChainComplex.of_d :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      {α : Type u_2} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
      (d : (n : α) → X (n + 1) ⟶ X n) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0)
      (j : α), (ChainComplex.of X d sq).d (j + 1) j = d j :=
  by sorry

This theorem, `ChainComplex.of_d`, is about chain complexes in the context of category theory. Given a category `V` which has zero morphisms, a type `α` (assumed to have addition and cancellation on the right, a unit element, and decidable equality), a mapping `X` from `α` to objects in `V`, and a morphism `d` which maps each element `n` in `α` to a morphism from `X(n+1)` to `X(n)`, such that the composition of `d(n+1)` and `d(n)` equals zero for all `n` in `α`, the theorem states that for any `j` in `α`, the `d` function of the chain complex formed by `X`, `d`, and `sq` from `j+1` to `j` is equal to the original morphism `d(j)`.

Given a chain complex (X, d) in a category with zero morphisms, if for all n in the indexing type α, d(n+1) ∘ d(n) = 0, then d(j) = d | (j+1 ↓ j) for any j in α. (Here, d | (j+1 ↓ j) denotes the morphism from X(j+1) to X(j) in the chain complex.)


/-- Transfer the sheaf condition across an isomorphism of presheaves.
 -/
theorem TopCat.Presheaf.isSheaf_of_iso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : TopCat} {F G : TopCat.Presheaf C X},
      (F ≅ G) → TopCat.Presheaf.IsSheaf F → TopCat.Presheaf.IsSheaf G :=
  by sorry

This theorem states that the sheaf condition for presheaves on a topological space can be transferred across an isomorphism of presheaves. Specifically, given any type `C` that forms a category, a topological space `X`, and two `C`-valued presheaves `F` and `G` on `X`, if `F` is isomorphic to `G` and `F` satisfies the sheaf condition (i.e., is a sheaf), then `G` must also satisfy the sheaf condition. The proof, which is not shown, would demonstrate this fact.

If two presheaves on a topological space are isomorphic and one satisfies the sheaf condition, then so does the other.


theorem Complex.frontier_preimage_re : ∀ (s : Set ℝ), frontier (Complex.re ⁻¹' s) = Complex.re ⁻¹' frontier s := by
  sorry

This theorem states that for any set `s` of real numbers, the frontier (the set of points between the closure and interior of the set) of the preimage under the real part function of `s` is equal to the preimage under the real part function of the frontier of `s`. In simpler terms, taking the frontier before or after applying the real part function to a set of real numbers does not change the result.

The frontier of the real part function applied to a set of real numbers is equal to the real part function applied to the frontier of that set.


theorem Ordinal.out_nonempty_iff_ne_zero : ∀ {o : Ordinal.{u_3}}, Nonempty (Quotient.out o).α ↔ o ≠ 0 := by sorry

The theorem `Ordinal.out_nonempty_iff_ne_zero` states that for any ordinal `o`, there exists some element in the set that `o` (considered as an equivalence class) represents if and only if `o` is not equal to zero. In other words, an ordinal number has a non-empty set representation if and only if it is not zero.

An ordinal is non-empty if and only if it is not equal to zero.


theorem isCompact_univ_iff : ∀ {X : Type u} [inst : TopologicalSpace X], IsCompact Set.univ ↔ CompactSpace X := by sorry

This theorem states that for any type 'X' equipped with a topological structure, the universal set of 'X' is compact if and only if 'X' itself is a compact space. In terms of mathematics, a space 'X' is compact if for any collection of open covers, there is a finite subcover. Thus, the theorem is saying that this property for the entire space 'X' is equivalent to the same property for the universal set, which includes all elements of 'X'.

A topological space 'X' and its universe are compact if and only if each other is.


theorem Set.image_swap_prod : ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), Prod.swap '' s ×ˢ t = t ×ˢ s :=
  by sorry

This theorem states that for any sets `s` of type `α` and `t` of type `β`, the image of the cartesian product `s ×ˢ t` under the `Prod.swap` operation equals the cartesian product `t ×ˢ s`. Here, `Prod.swap` is an operation that swaps the elements in a pair, and `''` represents the image of a set under a function. The `×ˢ` operation represents the cartesian product of two sets. So in essence, this theorem states that swapping the elements in each pair of the cartesian product of two sets results in the cartesian product of the sets in reverse order.

For any sets `α` and `β`, the image of `s ×ˢ t` under `Prod.swap` equals `t ×ˢ s`, where `s ×ˢ t` is the cartesian product of `s` and `t`.


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

This theorem, named `Mathlib.Algebra.CharZero.Defs._auxLemma.8`, states that for any type `R` which represents a mathematical structure exhibiting characteristics of an additive monoid with one and character zero, and for any natural number `n` that is at least two, the assertion that zero is equal to the natural number `n` when `n` is interpreted as an element of type `R` via the `OfNat.ofNat` function, is always false. This theorem is essentially saying that no natural number `n` that is at least two can be equivalent to zero in a character zero algebraic structure.

In any additive monoid with a character zero element, zero is not equal to any natural number greater than one.


theorem RelHom.map_rel :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r →r s) {a b : α},
      r a b → s (f a) (f b) :=
  by sorry

This theorem states that for any types `α` and `β`, and any relations `r` on `α` and `s` on `β`, if `f` is a relation-homomorphism from `r` to `s`, then for any elements `a` and `b` of `α`, if `r a b` holds, then `s (f a) (f b)` also holds. In more plain terms, if `a` is related to `b` under the relation `r`, then the images of `a` and `b` under the relation-homomorphism `f` are related under the relation `s`.

If `f` is a relation homomorphism from `r` to `s`, then for all `a, b` in `α`, `r a b` implies `s (f a) (f b)`.


Computation.LiftRel.swap

theorem Computation.LiftRel.swap :
    ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β),
      Computation.LiftRel (Function.swap R) cb ca ↔ Computation.LiftRel R ca cb :=
  by sorry

The theorem `Computation.LiftRel.swap` states that for any types `α` and `β`, a relation `R` from `α` to `β`, and computations `ca` and `cb` of types `α` and `β` respectively, the property of `Computation.LiftRel` being true for the swapped relation `Function.swap R` and swapped computations `cb` and `ca` is equivalent to `Computation.LiftRel` being true for the original relation `R` and computations `ca` and `cb`. In other words, the termination relationship between two computations as defined by `Computation.LiftRel` remains the same even if we swap the relation and the computations.

For any types `α` and `β`, relation `R` from `α` to `β`, and computations `ca` and `cb`, `Computation.LiftRel` holds for `R` and `ca` if and only if it holds for `Function.swap R` and `cb`.


UniformContinuous.div

theorem UniformContinuous.div :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α]
      [inst_3 : UniformSpace β] {f g : β → α},
      UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x / g x :=
  by sorry

The theorem `UniformContinuous.div` states that for any two types `α` and `β`, where `α` has structure of a uniform space and a group (with the group operation respecting the uniform structure), and `β` is a uniform space, if we have two functions `f` and `g` from `β` to `α` that are uniformly continuous, then the function defined as the quotient of `f` and `g` (i.e., `(f x) / (g x)`) is also uniformly continuous. In other words, if `f` and `g` remain close when their inputs are close, then the same is true for the function which divides `f` by `g` at each point.

If `f` and `g` are uniformly continuous functions from a uniform space `β` to a uniform space `α` with `α` being a group, then the quotient function `x ↔− f(x) / g(x)` is also uniformly continuous.


/-- The span of a set of points contains the set of points.  -/
theorem Projectivization.Subspace.subset_span :
    ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      (S : Set (Projectivization K V)), S ⊆ ↑(Projectivization.Subspace.span S) :=
  by sorry

This theorem states that for any field `K`, and a given additively commutative group `V` which is also a module over `K`, the span (defined in projective space) of a set `S` of points in the projectivization of the vector space `V` over `K` always contains the original set `S`. In other words, every point in `S` is also a point in the span of `S`.

For any field `K` and additively commutative `K`-module `V`, the projective span of a set `S` of points in the projectivization of `V` contains `S`.


theorem Multiset.count_le_of_le :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) {s t : Multiset α},
      s ≤ t → Multiset.count a s ≤ Multiset.count a t :=
  by sorry

The theorem `Multiset.count_le_of_le` asserts that for any type `α` with a decidable equality and for any element `a` of type `α` and any two multisets `s` and `t` of type `α`, if `s` is a sub-multiset of `t` (i.e., `s ≤ t`), then the count of the element `a` in the multiset `s` is less than or equal to the count of the element `a` in the multiset `t`. In other words, the multiplicity of an element in a multiset cannot exceed the multiplicity of the same element in a super-multiset of that multiset.

For any type `α` with decidable equality and for any element `a` of type `α` and multisets `s` and `t` of type `α` with `s ≤ t`, the count of `a` in `s` is less than or equal to the count of `a` in `t`.


theorem List.length_filter_le :
    ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.length (List.filter p l) ≤ List.length l := by sorry

This theorem states that for any type `α` and any Boolean predicate `p` on `α`, as well as any list `l` of elements of type `α`, the length of the list obtained by filtering `l` with `p` is always less than or equal to the length of `l` itself. In other words, if you filter a list with some criteria, the resulting list is always the same size or smaller. This is intuitively clear since filtering can only remove elements, not add new ones.

For any type `α`, list `l` of `α`, and Boolean predicate `p` on `α`, the length of the filtered list `l.filter p` is less than or equal to the length of `l`.


RegularSpace.ofBasis

/-- **Alias** of `RegularSpace.of_hasBasis`. -/
theorem RegularSpace.ofBasis :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : X → Sort u_3} {p : (a : X) → ι a → Prop}
      {s : (a : X) → ι a → Set X},
      (∀ (a : X), Filter.HasBasis (nhds a) (p a) (s a)) →
        (∀ (a : X) (i : ι a), p a i → IsClosed (s a i)) → RegularSpace X :=
  by sorry

The theorem `RegularSpace.ofBasis` states that for any type `X` with a topological space structure, given a family of sets `s` indexed by some function `ι` and some property `p`, if every neighborhood filter at a point `a` in `X` has a basis specified by `p` and `s`, and for every `a` in `X` and index `i` of type `ι a`, if `p a i` holds then the corresponding set `s a i` is closed, then `X` is a regular space.

In other words, this theorem provides a criterion for a topological space to be a regular space based on the existence of a certain basis for every neighborhood filter and the closure of the sets in this basis.

A topological space `X` is regular if every neighborhood filter at each point `a` in `X` has a basis specified by property `p` on indexed family `s`, and all sets `s a i` are closed whenever `p a i` holds.


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

The theorem `Homeomorph.image_closure` states that for any two types `X` and `Y`, each equipped with a topological space structure, a homeomorphism `h` from `X` to `Y`, and a set `s` of type `X`, the image of the closure of `s` under `h` is equal to the closure of the image of `s` under `h`. In mathematical terms, this means if `h` is a homeomorphism from topological space `X` to `Y` and `s` is a set in `X`, then the closure of `h(s)` in `Y` is the same as `h` of the closure of `s` in `X`.

For any topological spaces X and Y, a homeomorphism h between them, and a set s in X, the closure of h(s) in Y equals h(closure(s) in X).


/-- **Equality case of Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g`,
which monovary together, is unchanged by a permutation if and only if `f` and `g ∘ σ` monovary
together. Stated by permuting the entries of `g`.  -/
theorem MonovaryOn.sum_smul_comp_perm_eq_sum_smul_iff :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      MonovaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s →
          (((Finset.sum s fun i => f i • g (σ i)) = Finset.sum s fun i => f i • g i) ↔ MonovaryOn f (g ∘ ⇑σ) ↑s) :=
  by sorry

**Equality case of Rearrangement Inequality**: Given a set `s` of indices, a scalar-valued function `f`, and a vector-valued function `g`, if `f` and `g` are monovariant (i.e., increasing `g` implies non-decreasing `f`) on `s`, then the following holds: the total scalar product of `f` and `g` after applying a permutation `σ` is equal to the original total scalar product of `f` and `g` if and only if `f` and `g` after applying `σ` are monovariant on `s`. In this statement, the permutation `σ` only alters the entries of `g` and it is assumed that any index for which `σ` is not an identity mapping belongs to `s`.

Given a set `s`, scalar-valued function `f`, and vector-valued function `g` on `s`, if `f` is non-decreasing and `g` is increasing, then the total scalar product of `f` and `g` is invariant under any permutation of `g`'s entries if and only if `f` and `g` after the permutation are non-decreasing.


theorem Mathlib.Order.Filter.Bases._auxLemma.10 : ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) := by sorry

This theorem, `Mathlib.Order.Filter.Bases._auxLemma.10`, states that for any three propositions `a`, `b`, and `c`, the proposition "`a` and `b` and `c`" is logically equivalent to the proposition "(`a` and `b`) and `c`". In other words, the conjunction (and-operation) is associative in propositional logic.

The theorem `Mathlib.Order.Filter.Bases._auxLemma.10` in Lean 4 states that the conjunction of three propositions `a`, `b`, and `c` is logically equivalent to the conjunction of `a` and `b` with `c`. In mathematical notation, `(a ∧ b) ∧ c` is equivalent to `a ∧ b ∧ c`.


theorem Matroid.base_iff_maximal_indep :
    ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M.Base B ↔ M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I := by
  sorry

This theorem states that for any type `α` and any `Matroid` `M` defined on that type, a set `B` is a base of the matroid if and only if `B` is independent and for any independent set `I`, if `B` is a subset of `I`, then `B` must be equal to `I`. In other words, a base in a matroid is a maximal independent set — it is independent, and any larger independent set must be the same set.

A set is a base of a matroid if and only if it is maximal among the independent sets.


/-- `pow b` and `log b` (almost) form a Galois connection. See also `Nat.pow_le_of_le_log` and
`Nat.le_log_of_pow_le` for individual implications under weaker assumptions.  -/
theorem Nat.pow_le_iff_le_log : ∀ {b : ℕ}, 1 < b → ∀ {x y : ℕ}, y ≠ 0 → (b ^ x ≤ y ↔ x ≤ Nat.log b y) := by sorry

The theorem `Nat.pow_le_iff_le_log` establishes a relationship between the power function `pow` and the logarithm function `log` in the realm of natural numbers. Specifically, for any natural number `b` greater than 1, and any non-zero natural numbers `x` and `y`, the condition that `b` to the power of `x` is less than or equal to `y` is equivalent to the condition that `x` is less than or equal to the logarithm base `b` of `y`. This can be seen as expressing a form of Galois connection between the `pow` and `log` operations. For detailed implications under weaker assumptions, refer to `Nat.pow_le_of_le_log` and `Nat.le_log_of_pow_le`.

For any natural number `b` greater than 1 and non-zero natural numbers `x` and `y`, `b^x <= y` if and only if `x <= log_b y`.


theorem MeasureTheory.integrableOn_empty :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E}
      {μ : MeasureTheory.Measure α}, MeasureTheory.IntegrableOn f ∅ μ :=
  by sorry

The theorem `MeasureTheory.integrableOn_empty` asserts that, given any measurable space `α`, a normed additive commutative group `E`, a function `f` from `α` to `E`, and a measure `μ` on `α`, the function `f` is integrable over the empty set with respect to the measure `μ`. In other words, for any function and any measure, the function is always integrable on the empty set, which is a consequence of the fact that the integral over an empty set is always well-defined and finite.

The empty set is integrable with respect to any measure for any integrable function.


/-- The angle between two vectors does not depend on their order.  -/
theorem InnerProductGeometry.angle_comm :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      InnerProductGeometry.angle x y = InnerProductGeometry.angle y x :=
  by sorry

This theorem states that the angle between two vectors does not depend on the order in which the vectors are considered. In other words, given any two vectors `x` and `y` from a normed commutative group `V` with an inner product space over the real numbers, the angle between `x` and `y` is the same as the angle between `y` and `x`. This aligns with our intuitive understanding of angles in geometry, where the angle from vector `A` to vector `B` is the same as the angle from vector `B` to `A`.

Given two vectors `x` and `y` in a normed commutative group `V` with an inner product space over the real numbers, the angle between `x` and `y` equals the angle between `y` and `x`.


theorem CategoryTheory.Sieve.pullback_eq_top_of_mem :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (S : CategoryTheory.Sieve X) {f : Y ⟶ X},
      S.arrows f → CategoryTheory.Sieve.pullback f S = ⊤ :=
  by sorry

This theorem, `CategoryTheory.Sieve.pullback_eq_top_of_mem`, states that for all categories `C` with objects `X` and `Y`, and for a given sieve `S` on `X` and a morphism `f` from `Y` to `X`, if `f` is a member of the set of arrows of `S`, then the pullback of `S` along `f` is the top sieve on `Y`. In other words, if a morphism from `Y` to `X` is in a sieve on `X`, then pulling this sieve back along this morphism gives us the maximal sieve (i.e., the sieve containing all possible morphisms) on `Y`.

Given a category `C` with objects `X` and `Y`, a sieve `S` on `X`, and a morphism `f` from `Y` to `X` in `S`, the pullback of `S` along `f` is the top sieve on `Y`.


Relation.TransGen.lift

theorem Relation.TransGen.lift :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {p : β → β → Prop} {a b : α} (f : α → β),
      (∀ (a b : α), r a b → p (f a) (f b)) → Relation.TransGen r a b → Relation.TransGen p (f a) (f b) :=
  by sorry

This theorem, named `Relation.TransGen.lift`, is a statement about the transitive closure of relations in the context of type theory. Given two types `α` and `β`, two relations `r` on `α` and `p` on `β`, and a function `f` from `α` to `β`, if for every pair of elements `a` and `b` from `α` the relation `r` implies the relation `p` under the function `f`, then if `a` and `b` are related by the transitive closure of `r`, they will also be related by the transitive closure of `p` after being mapped by the function `f`. It essentially lifts a property from the relation `r` to the relation `p` under a certain function, in the context of transitive closures.

If relation `r` on type `α` implies relation `p` on type `β` under function `f`, then the transitive closures of `r` and `p` after applying `f` are related.


theorem Submonoid.LocalizationMap.lift_comp :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
      [inst_2 : CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)),
      MonoidHom.comp (Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.toMap f) = g :=
  by sorry

This theorem is about monoid homomorphisms and submonoid localization maps in the context of commutative monoids. The theorem states that for any commutative monoids `M`, `N` and `P`, with `S` being a submonoid of `M`, given a localization map `f` from `S` to `N`, and a monoid homomorphism `g` from `M` to `P`, if every element of the submonoid `S` is a unit under the homomorphism `g`, then the composition of the lift of the localization map `f` (with respect to `g` and the condition on `S`) and the map of `f` itself is equal to `g`. In other words, the lift of `f` followed by the map of `f` gives back the original homomorphism `g`.

If `f` is a localization map from a submonoid `S` of commutative monoids `M` to `N`, `g` is a monoid homomorphism from `M` to `P`, and every element in `S` is a unit under `g`, then the composition of `g` and the lift of `f` with respect to `g` is equal to `f`.


theorem AddMonoidHom.rangeRestrict_surjective :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N),
      Function.Surjective ⇑(AddMonoidHom.rangeRestrict f) :=
  by sorry

This theorem states that for any two types `G` and `N` that are additive groups, given a group homomorphism `f` from `G` to `N`, the function that restricts `f` to the range of `f` is surjective. In other words, for every element in the range of `f`, there exists an element in `G` such that applying the restricted function to this element gives the original element in the range. This means that the restricted function covers the entire range of `f`.

For any additive group homomorphism `f` from type `G` to type `N`, the restriction of `f` to the range of `f` is a surjection.


theorem LinearIsometryEquiv.coe_injective :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂], Function.Injective DFunLike.coe :=
  by sorry

The theorem `LinearIsometryEquiv.coe_injective` states that for any two types `R` and `R₂` with semiring structures, any two types `E` and `E₂` with seminormed additive commutative group structures and module structures over `R` and `R₂` respectively, and any two ring homomorphisms `σ₁₂` and `σ₂₁` that form an inverse pair, the function `DFunLike.coe` is injective.

In other words, it means that if `DFunLike.coe` applied to two elements of its domain gives the same result, then these two elements were the same to begin with. This implies that no information is lost when mapping from the original space with `DFunLike.coe`.

Given types `R`, `R₂` with semiring structures, types `E`, `E₂` with seminormed additive commutative group structures and module structures over `R` and `R₂` respectively, and ring homomorphisms `σ₁₂` and `σ₂₁` forming an inverse pair, the function `DFunLike.coe` from `E` to `E₂` is injective.


theorem Vector.mapAccumr₂_snoc :
    ∀ {α : Type} {n : ℕ} {β : Type} (xs : Vector α n) (ys : Vector β n) {σ φ : Type} {c : σ} (f : α → β → σ → σ × φ)
      (x : α) (y : β),
      Vector.mapAccumr₂ f (Vector.snoc xs x) (Vector.snoc ys y) c =
        let q := f x y c;
        let r := Vector.mapAccumr₂ f xs ys q.1;
        (r.1, Vector.snoc r.2 q.2) :=
  by sorry

The theorem `Vector.mapAccumr₂_snoc` in Lean 4 states that for any two vectors `xs` and `ys` of equal length `n`, any types `α`, `β`, `σ`, `φ`, a function `f` that operates on types `α`, `β`, and `σ`, and any elements `x` of type `α` and `y` of type `β` and `c` of type `σ`, applying the `mapAccumr₂` function to the vectors obtained by appending `x` to `xs` and `y` to `ys` is equal to applying `f` to `x`, `y`, and `c`, then applying `mapAccumr₂` to `xs`, `ys`, and the first element of the result from `f`, and finally appending the second element of the result from `f` to the second element of the result from `mapAccumr₂`.

In other words, it states that the process of mapping and accumulating a function `f` over two vectors extended by `x` and `y` is equivalent to the process of mapping and accumulating the function `f` over the original vectors and then appending the result of `f` applied to `x`, `y`, and `c` to the end.

For equal-length vectors `xs` and `ys` of type `α List`, the application of `mapAccumr₂ f (x :: xs) (y :: ys) c` is equal to `let (acc, last) := mapAccumr₂ f xs ys c in (f x y :: acc, last)`.


theorem Fin.snoc.proof_2 : ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} (i : Fin (n + 1)), ¬↑i < n → α (Fin.last n) = α i :=
  by sorry

This theorem states that for any natural number `n` and any type `α` that depends on `Fin (n + 1)`, given any element `i` of `Fin (n + 1)`, if it is not the case that `i` is less than `n`, then the type `α` at `Fin.last n` (which represents the greatest value in `Fin (n + 1)`) is equal to the type `α` at `i`. In other words, if `i` is not less than `n`, it must be equal to `n`, and thus, it's type `α` is the same as that at `Fin.last n`.

For any natural number `n` and type `α` that depends on `Fin (n + 1)`, if `i` is an element of `Fin (n + 1)` such that `i ≥ n`, then `α` at position `i` is equal to `α` at position `Fin.last n`.


theorem AddCommGroup.intCast_modEq_intCast :
    ∀ {α : Type u_1} [inst : AddCommGroupWithOne α] [inst_1 : CharZero α] {a b z : ℤ},
      ↑a ≡ ↑b [PMOD ↑z] ↔ a ≡ b [PMOD z] :=
  by sorry

This theorem states that for any type `α` that is an additive commutative group with one (i.e., has a zero and a one, addition and subtraction operations, and the addition operation is commutative), and also has a characteristic of zero, and for any integers `a`, `b`, and `z`, the statement "`a` is congruent to `b` modulo `z`" is equivalent to the statement "`a` cast to `α` is congruent to `b` cast to `α` modulo `z` cast to `α`". In other words, the congruence relationship (modulo operation) between integers is preserved even when the integers are cast to another type that has the necessary algebraic structure.

For any additive commutative group α of characteristic zero, the congruence relation between integers is preserved under type casts: `a ≡ b (mod z)` if and only if `a.to_α ≡ b.to_α (mod z.to_α)` in α.


theorem Nat.floor_mono :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α], Monotone Nat.floor := by sorry

The theorem `Nat.floor_mono` states that for any type `α` with a linear ordering and a floor structure (i.e., we can "round down" elements of `α` to the nearest whole number), the function `Nat.floor`, which takes an element of `α` and returns the greatest natural number less than or equal to it, is monotone. This means that if `a` and `b` are elements of `α` and `a` is less than or equal to `b`, then the floor of `a` is less than or equal to the floor of `b`.

For any type `α` with a linear ordering and a floor structure, the floor function `Nat.floor : α -> Nat` is monotone, i.e., `Nat.floor a <= Nat.floor b` whenever `a <= b` in `α`.


theorem Set.indicator_nonneg :
    ∀ {α : Type u_2} {M : Type u_4} [inst : Preorder M] [inst_1 : Zero M] {s : Set α} {f : α → M},
      (∀ a ∈ s, 0 ≤ f a) → ∀ (a : α), 0 ≤ Set.indicator s f a :=
  by sorry

The theorem `Set.indicator_nonneg` states that for any type `α`, any type `M` that is a preorder and has a zero element, any set `s` of type `α`, and any function `f` from `α` to `M`, if every element `a` in `s` satisfies the property that `0` is less than or equal to `f(a)`, then for every element `a` of type `α`, `0` is less than or equal to the result of applying the `Set.indicator` function on `s`, `f`, and `a`. In other words, if `f` is non-negative on `s`, then the indicator function of `s` with `f` is also non-negative.

If `f : α → M` is a function from a set `α` to a preorder `M` with zero element, such that `0 ≤ f a` for all `a ∈ s`, then `0 ≤ ℱ s f a`, where `s : Set α` and `ℱ : Set (Set α → M → α → M)`.


theorem Complex.comap_exp_nhds_zero : Filter.comap Complex.exp (nhds 0) = Filter.comap Complex.re Filter.atBot := by
  sorry

The theorem states that the preimage filter of the complex exponential function at the neighborhood of zero is equal to the preimage filter of the real part function at negative infinity. In other words, if we look at the set of complex numbers that get arbitrarily close to zero under the complex exponential function, this set corresponds to the set of real numbers that decrease without bound under the real part function.

The preimages of the neighborhood of zero under complex exponential function and of negative infinity under real part function are equal.


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

The theorem `Set.preimage_add_const_Ioi` states that for any ordered additive commutative group `α` and any elements `a` and `b` from `α`, the preimage of the set of elements greater than `b` under the function `x ↦ x + a` is equal to the set of elements greater than `b - a`. In other words, if you shift all elements in the group by `a`, the set of elements that were greater than `b` before the shift is the same as the set of elements that are greater than `b - a` after the shift.

For any ordered additive commutative group α and elements a, b from α, the preimage of the set {x : α | x > b} under the function x ↦ x + a is equal to {x : α | x > b - a}.


theorem PartialHomeomorph.image_source_inter_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) (s : Set X),
      ↑e '' (e.source ∩ s) = e.target ∩ ↑(PartialHomeomorph.symm e) ⁻¹' (e.source ∩ s) :=
  by sorry

The theorem `PartialHomeomorph.image_source_inter_eq` states that for any partial homeomorphism `e` between two topological spaces `X` and `Y`, and for any set `s` of elements in `X`, the image under `e` of the intersection of `e.source` and `s` is equal to the intersection of `e.target` and the preimage under the inverse of `e` of the intersection of `e.source` and `s`. In simpler terms, this theorem is about the relationship between a set in the domain of a partial homeomorphism, its image under the homeomorphism, and its corresponding preimage under the inverse of the homeomorphism.

For any partial homeomorphism between topological spaces, the image of the intersection of its source domain and its domain, under the homeomorphism, equals the intersection of its target space and the preimage of that intersection under the inverse of the homeomorphism.


theorem PFunctor.Approx.head_succ' :
    ∀ {F : PFunctor.{u}} (n m : ℕ) (x : (n : ℕ) → PFunctor.Approx.CofixA F n),
      PFunctor.Approx.AllAgree x → PFunctor.Approx.head' (x (Nat.succ n)) = PFunctor.Approx.head' (x (Nat.succ m)) :=
  by sorry

The theorem `PFunctor.Approx.head_succ'` states that for any pfunctor `F` and natural numbers `n` and `m`, if we have an infinite sequence of approximations `x` of the cofix of `F` such that all of these approximations agree with each other (i.e., `PFunctor.Approx.AllAgree x` holds), then the label of the root of the tree for the `n+1`-th approximation is the same as the label of the root of the tree for the `m+1`-th approximation (i.e., `PFunctor.Approx.head' (x (Nat.succ n)) = PFunctor.Approx.head' (x (Nat.succ m))` holds). This theorem essentially establishes the consistency of the root labels when the sequence of approximations is consistent.

For any pfunctor F and infinite sequence of approximations x of its cofix such that all approximations agree, the labels of the roots of their respective trees for successor natural numbers are equal.


theorem Mathlib.Topology.LocallyConstant.Basic._auxLemma.5 : ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) := by sorry

This theorem, given any type `α` and any two elements `a` and `b` of this type, states that `a` is in the singleton set containing `b` if and only if `a` is equal to `b`. In more mathematical terms, it establishes the equivalence `$a \in \{b\} \Leftrightarrow a = b$`.

A singleton set contains exactly one element, so the element `a` is in the singleton set `{b}` if and only if `a` is equal to `b`. In formal notation: `a ∈ {b} ↔ a = b`.


theorem Mathlib.Topology.LocallyConstant.Basic._auxLemma.7 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

The theorem `Mathlib.Topology.LocallyConstant.Basic._auxLemma.7` states that for all types `α` and `β`, a function `f` from `α` to `β`, a set `s` of type `β`, and an element `a` of type `α`, the element `a` belongs to the preimage of the set `s` under the function `f` if and only if the function `f` evaluated at `a` belongs to the set `s`. In mathematical terms, this can be represented as \(a \in f^{-1}(s)\) if and only if \(f(a) \in s\). This theorem establishes the relationship between the preimage of a set under a function and the function's value at a particular point.

For all types `α` and `β`, function `f` from `α` to `β`, set `s` of type `β`, and element `a` of type `α`, `a` is in the preimage of `s` under `f` if and only if `f(a)` is in `s`. In symbols, `a ∈ f⁻¹(s)` if and only if `f(a) ∈ s`.


/-- The map `B.polar : Set E → Set F` forms an order-reversing Galois connection with
`B.flip.polar : Set F → Set E`. We use `OrderDual.toDual` and `OrderDual.ofDual` to express
that `polar` is order-reversing.  -/
theorem LinearMap.polar_gc :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedCommRing 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜),
      GaloisConnection (⇑OrderDual.toDual ∘ LinearMap.polar B)
        (LinearMap.polar (LinearMap.flip B) ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem states that for a given linear map `B` from type `E` to type `F` over a normed commutative ring `𝕜`, there exists a Galois connection between the polar of `B` and the polar of the flipped version of `B`. This connection is formed by applying the `toDual` function of the `OrderDual` (a structure that reverses the order of a given ordered set) to the polar of `B` and the `ofDual` function of the `OrderDual` to the polar of the flipped version of `B`. This expresses that the `polar` function is order-reversing, meaning that an increase in the original set implies a decrease in the polar set, and vice versa.

For a linear map B from type E to type F over a normed commutative ring, there exists a Galois connection between the polar of B and the polar of the flipped version of B, given by applying the OrderDual.toDual to the polar of B and OrderDual.ofDual to the polar of the flipped version of B.


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

The theorem `Set.preimage_add_const_Ici` states that for any type `α` that has an ordered additive commutative group structure, for all elements `a` and `b` of type `α`, the preimage of the set of all elements greater than or equal to `b`, under the function that adds `a` to an input, is equal to the set of all elements greater than or equal to `b - a`. In simpler terms, if you shift all the elements in a set by a constant, the preimage under this shift operation is the set where all elements are greater than or equal to the original bound minus the shift.

For any additive commutative group `α` and elements `a, b` of `α`, the preimage of the set `{x | x ≥ b} under the function x => x + a is equal to {x | x ≥ b - a}`.


IsGLB.unique

theorem IsGLB.unique : ∀ {α : Type u} [inst : PartialOrder α] {s : Set α} {a b : α}, IsGLB s a → IsGLB s b → a = b := by
  sorry

This theorem states that for any type `α` with a partial order, and any set `s` of type `α`, if `a` and `b` are both greatest lower bounds of the set `s`, then `a` must be equal to `b`. In other words, the greatest lower bound of a set in a partial order is unique if it exists. This follows from the antisymmetry of the partial order.

In a partial order, if two elements are both the greatest lower bounds of a set, then they are equal.


theorem smooth_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M], Smooth I I id :=
  by sorry

The theorem `smooth_id` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, topological space `H`, `M`, model with corners `I` from `𝕜`, `E` to `H`, and `M` being a charted space modeled on `H` under `I`, the identity function is a smooth function from this manifolds to itself under the given structures. This is a common concept in differential geometry where properties of smooth functions (infinitely differentiable functions) are studied on manifolds.

For any nontrivially normed field `𝕜`, normed additive commutative group `E`, topological space `H`, and charted space `M` modeled on `H` under an `I`-chart from `𝕜` to `H`, the identity function is a smooth function from `M` to itself.


/-- Continuity from above: the measure of the intersection of a decreasing sequence of measurable
sets is the limit of the measures.  -/
theorem MeasureTheory.tendsto_measure_iInter :
    ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      [inst : Preorder ι] [inst_1 : IsDirected ι fun x x_1 => x ≤ x_1] {s : ι → Set α},
      (∀ (n : ι), MeasurableSet (s n)) →
        Antitone s → (∃ i, ↑↑μ (s i) ≠ ⊤) → Filter.Tendsto (↑↑μ ∘ s) Filter.atTop (nhds (↑↑μ (⋂ n, s n))) :=
  by sorry

This theorem, named `MeasureTheory.tendsto_measure_iInter`, states that in a measure space `α` with a measure `μ`, for a sequence of measurable sets indexed by a countable, directed and preordered set `ι` that is decreasing (antitone), the measure of the intersection of the sequence of sets is the limit of the measures of the sets. More formally, if each set `s n` in the sequence is measurable, the sequence is antitone, and there exists an index `i` such that the measure of `s i` is not infinity, then the measure of the intersection of all `s n` as `n` tends to infinity (expressed as `⋂ n, s n`), is the limit of the measures of the `s n` as `n` tends to infinity. This concept is often referred to as "continuity from above".

 If `{Sn : ℕ → ℵ0 → Set α}`, `ι` is a countable, directed and preordered set, `μ` is a measure on `α`, and for each `n`, `Sn i` is measurable and `Sn j ⊇ Sn i` for `i ≤ j`, then `μ(⋂n, Sn) = ∏n, μ(Sn)`. (Note: `∏` denotes the product of a sequence of measurable sets.)

This statement asserts that the measure of the intersection of a decreasing sequence of measurable sets, indexed by a countable and directed set, is the limit of their measures, under certain conditions.


theorem isUnit_map_iff :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) [inst_2 : IsLocalRingHom f]
      (a : R), IsUnit (f a) ↔ IsUnit a :=
  by sorry

The theorem `isUnit_map_iff` states that for all semirings `R` and `S` and a ring homomorphism `f` from `R` to `S` that is also a local ring homomorphism, an element `a` from `R` is a unit (i.e., has a two-sided inverse) under the operation of `f` if and only if `a` is a unit in `R`. In other words, the mapping `f` preserves the property of being a unit.

For a semiring homomorphism and local homomorphism f from ring R to S, a element of R is a unit under f if and only if it is a unit in R.


/-- Preconnected sets are either contained in or disjoint to any given clopen set.  -/
theorem IsPreconnected.subset_isClopen :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s t : Set α},
      IsPreconnected s → IsClopen t → Set.Nonempty (s ∩ t) → s ⊆ t :=
  by sorry

The theorem `IsPreconnected.subset_isClopen` states that for any type `α` with a topological space structure, and for any sets `s` and `t` of this type, if `s` is a preconnected set and `t` is a clopen (both closed and open) set such that the intersection of `s` and `t` is nonempty (i.e., there is at least one element common to both sets), then `s` is a subset of `t`. In other words, a preconnected set is either contained in or disjoint from any given clopen set.

If `α` is a topological space, `s` is a preconnected subset of `α`, `t` is a clopen subset of `α` with nonempty intersection with `s`, then `s` is a subset of `t`.


theorem Filter.tendsto_id' : ∀ {α : Type u} {x y : Filter α}, Filter.Tendsto id x y ↔ x ≤ y := by sorry

The theorem `Filter.tendsto_id'` states that for any types `α` and for any filters `x` and `y` on `α`, the identity function `id` tends to move points in `x` towards `y` if and only if `x` is less than or equal to `y`. In other words, for each neighborhood in `y`, its preimage under the identity function is a neighborhood in `x`, exactly when `x` is a subset of `y`. This theorem connects the concept of filter tendsto (or limit) with the order relation on filters.

The identity function maps filter `x` to `y` strongly, i.e., `x ⊆ y` if and only if the identity function tends to map elements in `x` to `y`.


ClosedEmbedding.polishSpace

/-- Given a closed embedding into a Polish space, the source space is also Polish.  -/
theorem ClosedEmbedding.polishSpace :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : PolishSpace β]
      {f : α → β}, ClosedEmbedding f → PolishSpace α :=
  by sorry

This theorem states that if a function `f` from a topological space `α` to another topological space `β` is a closed embedding and if `β` is a Polish space (a completely metrizable, separable topological space), then `α` is also a Polish space. In other words, the topology of `α` inherits the Polish space properties from `β` through the closed embedding `f`.

If `f: α → β` is a closed embedding of a topological space `α` into a Polish space `β`, then `α` is a Polish space.


theorem lcm_eq_normalize :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {a b c : α},
      lcm a b ∣ c → c ∣ lcm a b → lcm a b = normalize c :=
  by sorry

The theorem `lcm_eq_normalize` states that for any type `α` equipped with a `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` structures, and for any three elements `a`, `b`, and `c` of type `α`, if the least common multiple (lcm) of `a` and `b` divides `c` and `c` divides the lcm of `a` and `b`, then the lcm of `a` and `b` is equal to the normalized form of `c`. The normalization is achieved by multiplying `c` with the inverse of its associated unit.

If `a`, `b`, and `c` are elements of a type `α` with `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` structures, and the lcm of `a` and `b` divides both `c` and the normalized form of `c`, then the lcm of `a` and `b` equals the normalized form of `c`.


theorem tsum_mul_right :
    ∀ {ι : Type u_1} {α : Type u_4} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSemiring α] {f : ι → α} {a : α} [inst_3 : T2Space α],
      ∑' (x : ι), f x * a = (∑' (x : ι), f x) * a :=
  by sorry

This theorem, `tsum_mul_right`, states that for any type `ι`, any type `α` that has a DivisionSemiring structure, a TopologicalSpace structure, and a TopologicalSemiring structure, any function `f` from `ι` to `α`, and any element `a` of `α`, where `α` also has a T2Space (also known as a Hausdorff space) structure, the sum of the product of `f x` and `a` for all `x` in `ι` is equal to the product of the sum of `f x` for all `x` in `ι` and `a`. In mathematical terms, it states that $\sum_{x \in \iota} (f(x) \cdot a) = (\sum_{x \in \iota} f(x)) \cdot a$. This is a distributive property of multiplication over infinite summation in a topological semiring.

In a TopologicalSemiring with a T2Space structure, for any function `f` from a type `ι` to a type `α` with a DivisionRing structure and any element `a` of `α`, the sum of the products `f x * a` over all `x` in `ι` equals the product of the sum of `f x` over all `x` in `ι` and `a`.


theorem IsSepClosed.exists_root :
    ∀ {k : Type u} [inst : Field k] [inst_1 : IsSepClosed k] (p : Polynomial k),
      Polynomial.degree p ≠ 0 → Polynomial.Separable p → ∃ x, Polynomial.IsRoot p x :=
  by sorry

The theorem `IsSepClosed.exists_root` states that for all fields `k` which also have the property of being separably closed (as per the `IsSepClosed` typeclass instance), for any polynomial `p` over `k`, if the degree of `p` is not zero and the polynomial is separable (i.e., it is coprime with its derivative), then there exists an element `x` in `k` that is a root of the polynomial `p`. In other words, a non-constant separable polynomial over a separably closed field always has at least one root in the field.

A separable polynomial of positive degree over a separably closed field has a root in the field.


theorem FiniteField.pow_card_sub_one_eq_one :
    ∀ {K : Type u_1} [inst : GroupWithZero K] [inst_1 : Fintype K] (a : K), a ≠ 0 → a ^ (Fintype.card K - 1) = 1 := by
  sorry

This theorem states that for any type `K` that has the structure of a group with zero along with being a finite type (indicating it has a finite number of elements), and any non-zero element `a` of type `K`, raising `a` to the power of (the number of elements in `K` minus one) will result in `1`. In mathematical terms, if `K` is a finite group and `a` is any non-zero element of `K`, then `a` to the power of (`|K|-1`) equals to `1`.

In a finite group K, any non-zero element raised to the power of (the number of elements in K minus one) equals the identity element 1.


theorem Set.eq_univ_of_subset : ∀ {α : Type u} {s t : Set α}, s ⊆ t → s = Set.univ → t = Set.univ := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of this type, if `s` is a subset of `t` and `s` is equivalent to the universal set on `α` (`Set.univ`), then `t` must also be equivalent to the universal set. In other words, if all elements of `α` are in `s` and `s` is included in `t`, then all elements of `α` must also be in `t`.

If a subset `s` of type `α` is equal to the universal set `Set.univ` on `α` and is contained in another set `t` of type `α`, then `t` is also equal to `Set.univ` on `α`.


theorem Real.injOn_cos : Set.InjOn Real.cos (Set.Icc 0 Real.pi) := by sorry

This theorem states that the real cosine function is injective, i.e., it doesn't map distinct arguments to the same result, when restricted to the interval ranging from 0 to π (both endpoints inclusive). In other words, for any two distinct real numbers x₁ and x₂ in the range from 0 to π, cos(x₁) is not equal to cos(x₂).

The cosine function is injective on the interval [0, π].


theorem CategoryTheory.Idempotents.Karoubi.coe.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
        CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem, part of the category theory library in Lean 4, states that for any object `X` in a category `C`, the composition of the identity morphism on `X` with itself is equal to the identity morphism on `X`. In mathematical terms, this can be represented as `id_X ∘ id_X = id_X`, where `∘` denotes the composition of morphisms and `id_X` is the identity morphism on the object `X`.

The composition of the identity morphism with itself is equal to the identity morphism for any object in a category.


theorem Int.negSucc_mul_ofNat : ∀ (m n : ℕ), Int.negSucc m * ↑n = -↑(Nat.succ m * n) := by sorry

This theorem states that for any natural numbers `m` and `n`, the product of the integer representation of the negative successor of `m` and the integer representation of `n` is equal to the negative of the integer representation of the product of the successor of `m` and `n`. In mathematical terms, this can be stated as: for all natural numbers `m` and `n`, `- (m+1) * n = - ((m+1) * n)`, where `m+1` is the successor of `m`.

For all natural numbers `m` and `n`, the negative of the integer representation of `(m+1) * n` is equal to the integer representation of `-m * n`.


Ordinal.IsNormal.isLimit

theorem Ordinal.IsNormal.isLimit :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}},
      Ordinal.IsNormal f → ∀ {o : Ordinal.{u_4}}, Ordinal.IsLimit o → Ordinal.IsLimit (f o) :=
  by sorry

The theorem `Ordinal.IsNormal.isLimit` states that for any normal ordinal function `f` and for any ordinal `o` which is a limit ordinal, the image of `o` under `f`, denoted by `f o`, is also a limit ordinal. In other words, if `f` is a normal ordinal function (i.e., it is strictly increasing and order-continuous), and `o` is a limit ordinal (i.e., it is not zero and not a successor ordinal), then the ordinal `f o` is also a limit ordinal.

If `f` is a normal ordinal function and `o` is a limit ordinal, then `f o` is also a limit ordinal.


theorem Polynomial.coeff_expand :
    ∀ {R : Type u} [inst : CommSemiring R] {p : ℕ},
      0 < p →
        ∀ (f : Polynomial R) (n : ℕ),
          Polynomial.coeff ((Polynomial.expand R p) f) n = if p ∣ n then Polynomial.coeff f (n / p) else 0 :=
  by sorry

This theorem, `Polynomial.coeff_expand`, states that for any given Type `R` which is an instance of `CommSemiring`, for any positive integer `p`, and for any Polynomial `f` of the type `R`, the coefficient of the `n`-th term of the expanded polynomial (where the polynomial is expanded by a factor of `p`) can be found as follows: if `p` is a divisor of `n`, then the coefficient is equal to the coefficient of the `(n / p)`-th term of the original polynomial `f`, otherwise, the coefficient is zero.

For any commutative semiring R, positive integer p, and polynomial f over R, the coefficient of the n-th term in the polynomial f expanded by a factor of p is equal to the coefficient of the (n/p)-th term of the original polynomial f if p divides n, and is zero otherwise.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.26 :
    ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a : α}, (a ∈ s * t) = ∃ x ∈ s, ∃ y ∈ t, x * y = a := by sorry

The theorem `Mathlib.Data.Set.Pointwise.Basic._auxLemma.26` states that for any type `α` that has a multiplication operation, and any sets `s` and `t` of this type, and any element `a` of the same type, `a` is in the set-theoretic product of `s` and `t` if and only if there exists an element `x` in `s` and an element `y` in `t` such that the multiplication of `x` and `y` equals `a`. This set-theoretic product operation is analogous to the Cartesian product of two sets, but with the pairing operation replaced by multiplication.

For any type `α` with multiplication, and sets `s` and `t` of `α`, an element `a` is in the product `s ∘ t` if and only if there exist `x ∈ s` and `y ∈ t` such that `x * y = a`.


theorem MeasureTheory.condexp_neg :
    ∀ {α : 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.condexp m μ (-f) =ᶠ[MeasureTheory.Measure.ae μ] -MeasureTheory.condexp m μ f :=
  by sorry

This theorem, `MeasureTheory.condexp_neg`, states that for any given type `α` and `F'` (where `F'` forms a complete normed space over the real numbers and also forms a normed additive commutative group), along with two measurable spaces `m` and `m0` over `α`, a measure `μ` over `α`, and a function `f` from `α` to `F'`, the conditional expectation of the negative of `f` is almost everywhere (with respect to the measure `μ`) equal to the negative of the conditional expectation of `f`. In mathematical terms, we have that $E[-f|\mathcal{F}] = -E[f|\mathcal{F}]$ almost everywhere.

For measurable spaces `m` and `m0` over type `α`, a measure `μ` over `α`, a complete normed space `F'` over the real numbers, and a measurable function `f` from `α` to `F'`, the conditional expectations of the negatives of `f` and `f` are almost everywhere equal: $E[-f|\mathcal{F}] = -E[f|\mathcal{F}]$ almost everywhere.


theorem Fintype.card_fun :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] [inst_2 : Fintype β],
      Fintype.card (α → β) = Fintype.card β ^ Fintype.card α :=
  by sorry

The theorem `Fintype.card_fun` states that for any two types `α` and `β`, where `α` has decidable equality and both `α` and `β` are finite types (i.e., they have a finite number of elements), the number of functions from `α` to `β` is equal to the number of elements in `β` raised to the power of the number of elements in `α`. In mathematical terms, if `|α|` represents the number of elements in `α` and `|β|` represents the number of elements in `β`, then the number of functions from `α` to `β` is `|β|^|α|`.

This theorem essentially tells us about the cardinality of the set of all functions from `α` to `β` when `α` and `β` are finite and `α` has decidable equality.

For finite types `α` with decidable equality and any type `β`, the number of functions from `α` to `β` equals the power of `|β|` raised to the power of `|α|`.


/-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
`c` and `y` is a vector on the same ray as `f c`, then the function `fun x => ‖f x + y‖` has
a maximum along `l` at `c`.  -/
theorem IsMaxFilter.norm_add_sameRay :
    ∀ {α : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : α → E}
      {l : Filter α} {c : α} {y : E},
      IsMaxFilter (norm ∘ f) l c → SameRay ℝ (f c) y → IsMaxFilter (fun x => ‖f x + y‖) l c :=
  by sorry

This theorem states that if a function `f : α → E` has a property such that the norm of the function `f`, denoted as `norm ∘ f`, reaches a maximum at a specific point `c` in a filter `l`, and if a vector `y` is on the same ray as the value of the function at `c`, denoted as `f c`, then the function that computes the norm of the sum of `f x` and `y`, denoted as `fun x => ‖f x + y‖`, also has a maximum at the same point `c` in the filter `l`.

In other words, if the function `f` achieves its maximum norm at some point with respect to a filter, then adding a vector that is on the same ray as the function value at that point does not change the location of the maximum norm with respect to the filter.

If a function `f : α → E` reaches the maximum norm at a point `c` in a filter `l`, then the function `x => ||f x + y||` also reaches the maximum norm at `c` for any vector `y` on the ray through `fc`.


theorem Filter.atBot_basis :
    ∀ {α : Type u_3} [inst : Nonempty α] [inst : SemilatticeInf α],
      Filter.HasBasis Filter.atBot (fun x => True) Set.Iic :=
  by sorry

This theorem states that for any type `α` that is nonempty and has the structure of a semilattice with an infimum operation, the filter `Filter.atBot`, which represents the limit towards negative infinity in the order of `α`, has a basis. The basis is described by the constant function returning `True` and the left-infinite right-closed interval `Set.Iic`. In other words, every set in the `Filter.atBot` can be represented as a union of sets of the form `Set.Iic a` for some `a` in `α`, and every such set `Set.Iic a` is indeed in `Filter.atBot`.

For any nonempty semilattice type `α` with an infimum operation, the filter `Filter.atBot` has a basis consisting of the constant function returning `True` and the left-infinite right-closed intervals `Set.Iic a` for all `a` in `α`.


theorem starRingEnd_self_apply :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : StarRing R] (x : R), (starRingEnd R) ((starRingEnd R) x) = x := by
  sorry

The theorem `starRingEnd_self_apply` states that for any type `R` that is a commutative semiring with a star operation (denoted as `StarRing R`), applying the `starRingEnd` operation twice to any element `x` of `R` returns the original element `x`. In other words, the `starRingEnd` operation is its own inverse.

For any commutative semiring `R` with a star operation, `StarRing R x = x` for all `x` in `R`.


theorem SymAlg.unsym_injective : ∀ {α : Type u_1}, Function.Injective ⇑SymAlg.unsym := by sorry

The theorem `SymAlg.unsym_injective` states that for any type `α`, the function 'unsym' from the symbolic algebra `SymAlg` is injective. In other words, for every pair of elements in the symbolic algebra, if applying 'unsym' to them yields the same result, then the original elements were identical. This reflects the property of injective functions where if the outputs are the same, the inputs must also be the same.

The `SymAlg.unsym` function in Lean 4 maps distinct elements of the symbolic algebra to distinct results.


HasStrictFDerivAt.prod

theorem HasStrictFDerivAt.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {f₁' : E →L[𝕜] F} {x : E}
      {f₂ : E → G} {f₂' : E →L[𝕜] G},
      HasStrictFDerivAt f₁ f₁' x →
        HasStrictFDerivAt f₂ f₂' x → HasStrictFDerivAt (fun x => (f₁ x, f₂ x)) (ContinuousLinearMap.prod f₁' f₂') x :=
  by sorry

This theorem states that given a nontrivial normed field `𝕜` and normed spaces `E`, `F`, and `G`, if a function `f₁` from `E` to `F` and a function `f₂` from `E` to `G` both have strict Frechet derivatives at a point `x` in `E`, then the function mapping `x` to the tuple `(f₁ x, f₂ x)` also has a strict Frechet derivative at `x`. The derivative of the tuple function is given by the continuous linear map that maps `x` to the tuple of the derivatives of `f₁` and `f₂` at `x`.

Given a normed field `𝕜` and normed spaces `E`, `F`, and `G`, if functions `f₁: E → F` and `f₂: E → G` have strict Frechet derivatives at a point `x` in `E`, then the function mapping `x` to the tuple `(f₁ x, f₂ x)` from `E` to `F × G` has a strict Frechet derivative at `x`, given by the continuous linear map that maps `x` to the tuple of the derivatives of `f₁` and `f₂` at `x`.


theorem EuclideanDomain.mod_eq_zero : ∀ {R : Type u} [inst : EuclideanDomain R] {a b : R}, a % b = 0 ↔ b ∣ a := by sorry

This theorem, "EuclideanDomain.mod_eq_zero", states that for all types 'R' that have a EuclideanDomain structure, and for any two elements 'a' and 'b' of this type, the remainder of 'a' divided by 'b' equals zero if and only if 'b' divides 'a'. In mathematical terms, it's saying that in a Euclidean domain, 'b' divides 'a' precisely when the remainder of the Euclidean division of 'a' by 'b' is zero.

In a Euclidean domain, 'a' is congruent to zero modulo 'b' if and only if 'b' divides 'a'.


Ordinal.IsNormal.sup

theorem Ordinal.IsNormal.sup :
    ∀ {f : Ordinal.{max u v} → Ordinal.{max u w}},
      Ordinal.IsNormal f →
        ∀ {ι : Type u} (g : ι → Ordinal.{max u v}) [inst : Nonempty ι], f (Ordinal.sup g) = Ordinal.sup (f ∘ g) :=
  by sorry

This theorem states that for any normal ordinal function `f`, the function `f` applied to the supremum of a family of ordinals `g` (assuming that the family of ordinals is nonempty) equals the supremum of the function `f` applied to each ordinal in the family `g`. Here, a normal ordinal function is defined as a strictly increasing function that also satisfies the property of order-continuity. In other words, if `f` is a normal ordinal function and `g` is a family of ordinals, then the supremum of the image of `g` under `f` is the same as the image under `f` of the supremum of `g`.

For any normal ordinal function `f` and nonempty family `g` of ordinals, `f( sup g) = sup (f ∘ g)`.


theorem embedding_toPullbackDiag :
    ∀ {X : Type u_1} {Y : Sort u_2} [inst : TopologicalSpace X] (f : X → Y), Embedding (toPullbackDiag f) := by sorry

The theorem `embedding_toPullbackDiag` states that for any types `X` and `Y`, where `X` is equipped with a topological space structure, and given any function `f : X → Y`, the function `toPullbackDiag f` (which maps each element `x` of `X` to the pullback of `f` over itself at `x`) is an embedding. In terms of topology, an embedding is a function that is both injective and continuous, and its image is a homeomorphic copy of its domain in the codomain. This theorem indicates that the "diagonal map" to the pullback (i.e., the pair `(x, x)`) preserves the topological structure.

The function `toPullbackDiag : X → Set Y` defined as the pullback of a continuous function `f : X → Y` along the diagonal embedding of `X` is an embedding.


theorem FirstOrder.Language.BoundedFormula.IsAtomic.isQF :
    ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {φ : FirstOrder.Language.BoundedFormula L α n},
      FirstOrder.Language.BoundedFormula.IsAtomic φ → FirstOrder.Language.BoundedFormula.IsQF φ :=
  by sorry

This theorem states that for any first-order language `L`, any type `α`, and any natural number `n`, if a bounded formula `φ` in the language `L` with `α` and `n` is atomic, then it is also quantifier-free (QF). In other words, every atomic bounded formula in a given first-order language does not contain any quantifiers.

For any first-order language L, any type α, and natural number n, every atomic bounded formula φ(α, n) in L is quantifier-free.


theorem Matrix.zpow_neg :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      {A : Matrix n' n' R}, IsUnit (Matrix.det A) → ∀ (n : ℤ), A ^ (-n) = (A ^ n)⁻¹ :=
  by sorry

The theorem `Matrix.zpow_neg` states that for any square matrix `A` with elements from a commutative ring `R`, where the determinant of `A` is a unit, the integer power of `A` to the negative value `-n` is the inverse of `A` to the power of `n`. Here, `n'` denotes the type used to index the rows and columns of the matrix, `n'` is assumed to have decidable equality and finite number of elements (i.e., it is a finite type). The integer `n` is the exponent in the power operation.

For a square matrix A over a commutative ring R with determinant unit, A^(-n) = (A^n)^-1, where n is a non-zero integer and A^n is the integer power of matrix A.


theorem CategoryTheory.ShortComplex.Exact.comp_descToInjective :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      {S : CategoryTheory.ShortComplex C} (hS : CategoryTheory.ShortComplex.Exact S) {J : C} (f : S.X₂ ⟶ J)
      [inst_2 : CategoryTheory.Injective J] (hf : CategoryTheory.CategoryStruct.comp S.f f = 0),
      CategoryTheory.CategoryStruct.comp S.g (CategoryTheory.ShortComplex.Exact.descToInjective hS f hf) = f :=
  by sorry

This theorem is part of category theory and states that for any category `C` which is also an Abelian category, and any short complex `S` in `C` that is exact, given morphism `f` from `S.X₂` to some object `J` in `C` (where `J` is injective), if the composition of `S.f` and `f` is the zero morphism, then the composition of `S.g` and the descriptor to injective of `hS`, `f`, and `hf` is `f`. Essentially, in the context of exact sequences in Abelian categories, this theorem outlines a particular compositional property of morphisms involving injective objects.

In an Abelian category `C`, if `S` is an exact short complex, `f : S.X₂ → J` is a morphism with `J` injective, and `S.f ∘ f = 0`, then `f = S.g ∘ hS(f) ∘ hf`.


theorem ProbabilityTheory.kernel.kernel_sum_seq :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      (κ : ↥(ProbabilityTheory.kernel α β)) [h : ProbabilityTheory.IsSFiniteKernel κ],
      ProbabilityTheory.kernel.sum (ProbabilityTheory.kernel.seq κ) = κ :=
  by sorry

This theorem in Probability Theory asserts that for any kernel `κ` from a measurable space `α` to a measurable space `β`, if `κ` is a so-called "s-finite" kernel (meaning it can be broken down into a countably infinite sequence of finite kernels), then the sum of all kernels in this breakdown sequence (obtained by applying the function `ProbabilityTheory.kernel.seq` to `κ`) is equal to the original kernel `κ`. In other words, an s-finite kernel can be decomposed into a sequence of finite kernels, and when we sum up all these finite kernels, we recover the original kernel.

If `κ` is an s-finite kernel from measurable space `α` to measurable space `β`, then the sum of the sequence of finite kernels obtained from its decomposition is equal to `κ`.


StrictMonoOn.compares

theorem StrictMonoOn.compares :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s →
        ∀ {a b : α}, a ∈ s → b ∈ s → ∀ {o : Ordering}, Ordering.Compares o (f a) (f b) ↔ Ordering.Compares o a b :=
  by sorry

The theorem `StrictMonoOn.compares` states that for a given type `α` with a linear order structure, type `β` with a preorder structure, a function `f` from `α` to `β`, and a set `s` of elements in `α`, if the function `f` is strictly monotone on the set `s`, then for any two elements `a` and `b` in set `s` and for any ordering `o`, the ordering relationship `o` between `f(a)` and `f(b)` corresponds exactly to the same ordering relationship `o` between `a` and `b`. This implies that a strictly monotone function preserves the order of elements in the set upon which it's monotone.

If `f: α → β` is a strictly monotone function on a linearly ordered set `s ⊆ α`, then for all `a, b ∈ s`, `a o b` if and only if `f(a) o f(b)`, where `o` is any ordering on `α`.


theorem DiscreteQuotient.proj_surjective :
    ∀ {X : Type u_2} [inst : TopologicalSpace X] (S : DiscreteQuotient X),
      Function.Surjective (DiscreteQuotient.proj S) :=
  by sorry

The theorem `DiscreteQuotient.proj_surjective` states that for all types `X` equipped with a topological space structure, and for any discrete quotient `S` of `X`, the projection function from `X` to the given discrete quotient `S` is surjective. In other words, for every element in the discrete quotient `S`, there exists at least one element in `X` such that when the projection function is applied to this element, we obtain the given element in the discrete quotient.

For any topological space X and a discrete quotient S of X, the projection function from X to S is surjective.


theorem one_div_one_div : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α), 1 / (1 / a) = a := by sorry

This theorem states that for all types `α` equipped with a division operation (i.e., `α` forms a division monoid), the double reciprocation of any value `a` of type `α` yields the original value `a`. In mathematical terms, this theorem asserts that for any `a` in a division monoid `α`, the equation $1 / (1 / a) = a$ holds.

For any type `α` with a division operation, the double reciprocal of any `a` in `α` equals `a`: $1 / (1 / a) = a$.


theorem Homeomorph.self_comp_symm :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      ⇑h ∘ ⇑(Homeomorph.symm h) = id :=
  by sorry

The theorem `Homeomorph.self_comp_symm` states that for any two topological spaces `X` and `Y`, if there is a homeomorphism `h` from `X` to `Y`, then composing `h` with its inverse (as given by the `Homeomorph.symm` function) yields the identity function. In other words, applying `h` followed by its inverse is equivalent to doing nothing, which is a fundamental property of homeomorphisms in topology.

For any topological spaces X and Y with a homeomorphism h : X ↔ Y, h ∘ Homeomorph.symm h = id\_X and Homeomorph.symm h ∘ h = id\_Y, where id\_X and id\_Y are the identity functions on X and Y, respectively.


theorem Filter.map_pure : ∀ {α : Type u} {β : Type v} (f : α → β) (a : α), Filter.map f (pure a) = pure (f a) := by
  sorry

The theorem `Filter.map_pure` states that for any types `α` and `β`, and a function `f` from `α` to `β`, the forward map of a filter applied to the function `f` and the pure filter generated by an element `a` of `α` is equal to the pure filter generated by `f(a)`. Simply put, mapping a function over a pure filter just applies the function to the element in the pure filter.

For any type `α`, type `β`, and function `f : α → β`, the application of a filter to `f` and the pure filter generated by an element `a ∈ α` results in the same filter as the pure filter generated by `f(a)`. In mathematical notation: `Filter.map f (pure a) = pure (f a)`.


theorem Projectivization.mk_rep :
    ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      (v : Projectivization K V), Projectivization.mk K (Projectivization.rep v) ⋯ = v :=
  by sorry

The theorem `Projectivization.mk_rep` states that for any projectivized vector `v` (from the projectivization of a vector space `V` over a division ring `K`), if we take a representative of `v` in `V` using the `Projectivization.rep` function, and then project it back into the projectivization using `Projectivization.mk`, we get the original projectivized vector `v` back. This theorem essentially says that the process of projecting a vector into the projectivization and then retrieving a representative from the projectivization is idempotent.

For any projectivized vector `v` from the projectivization of a vector space `V` over a division ring `K`, `Projectivization.mk (Projectivization.rep v) = v`.


Algebra.IsAlgebraic.isIntegral

/-- **Alias** of the forward direction of `Algebra.isAlgebraic_iff_isIntegral`. -/
theorem Algebra.IsAlgebraic.isIntegral :
    ∀ {K : Type u} {A : Type v} [inst : Field K] [inst_1 : Ring A] [inst_2 : Algebra K A],
      Algebra.IsAlgebraic K A → Algebra.IsIntegral K A :=
  by sorry

This theorem, labeled as an alias of the forward direction of `Algebra.isAlgebraic_iff_isIntegral`, states that for any field `K` and any ring `A` with a structure of `K`-algebra, if the `K`-algebra `A` is algebraic (i.e., all its elements are algebraic), then it is integral. In other words, every element of the `K`-algebra `A` is integral over the base field `K`.

If `K` is a field and `A` is a `K`-algebra, then `A` being algebraic implies that every element of `A` is integral over `K`.


theorem Basis.reindex_apply :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (b : Basis ι R M) (e : ι ≃ ι') (i' : ι'), (Basis.reindex b e) i' = b (e.symm i') :=
  by sorry

The theorem `Basis.reindex_apply` states that for any semiring `R`, any additive commutative monoid `M` which is also a module over `R`, any basis `b` of `M` indexed by type `ι`, any bijection `e` from `ι` to another type `ι'`, and any element `i'` of `ι'`, the result of indexing the basis reindexed by `e` at `i'` is equal to the result of indexing the original basis at the inverse image of `i'` under `e`. In other words, reindexing a basis by a bijection and then applying the new index is the same as applying the inverse of the bijection to the new index and then indexing the original basis.

For any semiring `R`, additive commutative `R`-module `M` with basis `b` indexed by `ι`, bijection `e` from `ι` to `ι'`, and `i'` in `ι'`, the reindexed basis element `b.e i'` is equal to the basis element `b.ι⁁⁻¹(eⁱ⁻¹i')`.


/-- An abstract version of continuity of sequentially continuous functions on metric spaces:
if a filter `k` is countably generated then `Tendsto f k l` iff for every sequence `u`
converging to `k`, `f ∘ u` tends to `l`.  -/
theorem Filter.tendsto_iff_seq_tendsto :
    ∀ {α : Type u_3} {β : Type u_4} {f : α → β} {k : Filter α} {l : Filter β} [inst : Filter.IsCountablyGenerated k],
      Filter.Tendsto f k l ↔ ∀ (x : ℕ → α), Filter.Tendsto x Filter.atTop k → Filter.Tendsto (f ∘ x) Filter.atTop l :=
  by sorry

This theorem provides an abstract version of the concept of continuity for sequentially continuous functions on metric spaces. Specifically, it states that for any function `f` mapping from type `α` to `β`, a filter `k` on `α`, and a filter `l` on `β`, if the filter `k` is countably generated, then the function `f` tends to filter `l` given the input filter `k` if and only if for every sequence `x` (mapping from natural numbers to `α`) that tends to filter `k` as its index goes to infinity, the sequence resulting from applying the function `f` on `x` (denoted as `f ∘ x`) also tends to filter `l` as its index goes to infinity. In other words, under these conditions, `f` preserves the sequential convergence properties of sequences.

A sequentially continuous function on a metric space preserves the sequential convergence of filters: if a filter on the domain is countably generated and a sequence in the filter converges to a filter on the codomain, then the image sequence of the function converges to that filter.


theorem Real.continuousOn_sin : ∀ {s : Set ℝ}, ContinuousOn Real.sin s := by sorry

This theorem states that the real sine function (`Real.sin`) is continuous on any subset `s` of real numbers. In mathematical terms, this means that for all `s` which is a set of real numbers, `Real.sin` is continuous at every point in `s`. Continuity, in the topological sense, implies that the function's value changes smoothly without any jumps or breaks over `s`.

For any subset `s` of real numbers, the real sine function `Real.sin` is continuous on `s`.


theorem PadicSeq.norm_zero_iff : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p), PadicSeq.norm f = 0 ↔ f ≈ 0 :=
  by sorry

The theorem `PadicSeq.norm_zero_iff` states that for a prime number `p` and a Cauchy sequence of rational numbers `f` with respect to the p-adic norm, the norm of the sequence `f` is equal to 0 if and only if the sequence `f` is equivalent to 0. Here, a sequence is considered equivalent to 0 if its elements approach 0 as the sequence progresses. This theorem is crucial in analyzing the behavior of Cauchy sequences in p-adic number systems.

For a prime number p and a Cauchy sequence of rational numbers f with respect to the p-adic norm, the sequence f has norm 0 if and only if it converges to 0.


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

This theorem states that for all extended nonnegative real numbers 'a', 'b', and 'c', if 'a' is neither zero nor positive infinity, then the product of 'a' and 'b' being less than or equal to the product of 'a' and 'c' implies that 'b' is less than or equal to 'c'. In essence, it validates that multiplication by a positive non-infinite factor does not affect the order relationship between 'b' and 'c'.

If 'a' is a finite non-negative real number and 'a' * 'b' <= 'a' * 'c', then 'b' <= 'c'.


theorem IsCompact.finite_of_discrete :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} [inst_1 : DiscreteTopology X], IsCompact s → Set.Finite s :=
  by sorry

The theorem `IsCompact.finite_of_discrete` states that for any type `X` and a set `s` of that type, given that `X` has a discrete topology, if the set `s` is compact then it must also be finite. In other words, in a discrete topological space, all compact sets are finite. The terms compact and finite are defined with respect to some specific topological and set properties: a set is compact if, for every nontrivial filter that contains the set, there exists an element in the set such that every set of the filter intersects every neighborhood of the element. A set is finite if it is equivalent to a set of natural numbers up to some `n`.

In a discrete topological space, every compact set is finite.


theorem Subgroup.coe_eq_univ : ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, ↑H = Set.univ ↔ H = ⊤ := by sorry

The theorem `Subgroup.coe_eq_univ` states that for any type `G` with a `Group` instance and any subgroup `H` of `G`, the coercion of `H` to a set is equal to the universal set of `G` if and only if `H` is the top subgroup. In mathematical terms, this means that every element of the group `G` is in the subgroup `H` if and only if `H` is the whole group `G`, which is represented by the top element (`⊤`) in the lattice of subgroups of `G`.

The coercion of the top subgroup of a group to a set equals the universal set if and only if.


theorem Real.ball_eq_Ioo : ∀ (x r : ℝ), Metric.ball x r = Set.Ioo (x - r) (x + r) := by sorry

The theorem `Real.ball_eq_Ioo` states that for all real numbers `x` and `r`, the open ball centered at `x` with radius `r` (which is the set of all points `y` such that the distance from `y` to `x` is less than `r`) is equal to the open interval from `x - r` to `x + r`, excluding the endpoints. In other words, in the real numbers, the set of points `y` satisfying `|y - x| < r` is exactly those in the interval `(x - r, x + r)`.

The open ball centered at real number `x` with radius `r` equals the open interval `(x - r, x + r)` in the real numbers.


theorem Polynomial.coeff_nat_cast_ite :
    ∀ {R : Type u} {m n : ℕ} [inst : Semiring R], Polynomial.coeff (↑m) n = ↑(if n = 0 then m else 0) := by sorry

The theorem `Polynomial.coeff_nat_cast_ite` states that for any semiring `R`, and for any natural numbers `m` and `n`, the coefficient of `X^n` in the natural number `m` cast as a polynomial (also referred to as `Polynomial.coeff (↑m) n`) is equal to `m` if `n` equals zero and zero otherwise. This is expressed by the right-hand side of the equation: `↑(if n = 0 then m else 0)`. In other words, it says that when a natural number is viewed as a polynomial, its coefficients are zero everywhere except the zeroth place, which is equal to the number itself.

For any semiring R and natural numbers m and n, the coefficient of X^n in the polynomial represented by the natural number m is equal to m if n equals zero, and zero otherwise.


theorem Subgroup.mem_zpowers_iff :
    ∀ {G : Type u_1} [inst : Group G] {g h : G}, h ∈ Subgroup.zpowers g ↔ ∃ k, g ^ k = h := by sorry

This theorem is about the membership of an element in the subgroup generated by another element in a group. For any group `G`, and any two elements `g` and `h` of `G`, `h` is in the subgroup generated by `g` if and only if there exists an integer `k` such that `g` raised to the power of `k` equals `h`. In mathematical terms, this is saying that $h \in \langle g \rangle$ if and only if $\exists k \in \mathbb{Z}, g^k = h$. The theorem provides a condition for membership in the cyclic subgroup generated by a given group element.

A group element `h` belongs to the subgroup generated by another element `g` if and only if there exists an integer `k` such that `g^k = h`.


theorem Finset.mem_powersetCard_univ :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α} {k : ℕ}, s ∈ Finset.powersetCard k Finset.univ ↔ s.card = k := by
  sorry

This theorem states that for any given type `α`, assumed to be a finite type, and any finite set `s` of this type along with a natural number `k`, `s` is a member of the power set of all `α` with cardinality `k` if and only if the cardinality of `s` equals `k`. In other words, a subset `s` of the universe set `α` is in the collection of all subsets of `α` of size `k` if and only if the size of `s` is `k`. This theorem essentially connects the properties of elements in the power set of a finite set with cardinality.

For a finite type `α` and a finite subset `s` of `α`, `s` belongs to the power set of `α` with cardinality `k` if and only if the cardinality of `s` equals `k`.


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

This theorem states that for any types `α` and `β`, any functions `l : α → β` and `u : β → α`, and any set `s` of type `β`, if `l` and `u` form a Galois insertion with respect to the given preorders on `α` and `β`, and if `a` is a greatest lower bound of the image of `s` under `u`, then `l a` is a greatest lower bound of `s`. A Galois insertion is a pair of functions that describe an order-theoretic relationship between two partially ordered sets. The theorem is essentially stating a property about how greatest lower bounds translate across this Galois insertion.

Given a Galois insertion between types `α` and `β` via functions `l : α → β` and `u : β → α`, if `s` is a set of type `β` with greatest lower bound `a` in `β`, then `l a` is the greatest lower bound of `s` in `α`.


theorem Mathlib.Data.Int.Interval._auxLemma.2 : ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) := by sorry

This theorem states that for all natural numbers `n` and `m`, `m` is an element of the set of natural numbers less than `n` (represented by `Finset.range n` in Lean 4) if and only if `m` is strictly less than `n`. In other words, it establishes an equivalence between the membership of `m` in the set defined by `Finset.range n` and the inequality `m < n`.

For all natural numbers `n` and `m`, `m` is in the finite set `{i | i < n}` if and only if `m` is strictly less than `n`.