theorem Real.measurable_exp : Measurable Real.exp := by sorry

The theorem `Real.measurable_exp` states that the real exponential function (`Real.exp`), which is defined as the real part of the complex exponential, is a measurable function. In the context of measurable spaces, a function is considered measurable if the preimage of every measurable set is also measurable. In this case, for any measurable set in the codomain of the real exponential function, its preimage under the function is also a measurable set in the domain.

The real exponential function `Real.exp` is a measurable function from the real numbers to the real numbers.


theorem Stream'.tail_iterate :
    ∀ {α : Type u} (f : α → α) (a : α), Stream'.tail (Stream'.iterate f a) = Stream'.iterate f (f a) := by sorry

This theorem, `Stream'.tail_iterate`, states that for any type `α`, any function `f` from `α` to `α`, and any element `a` of type `α`, the tail of the stream generated by iterating `f` starting at `a` is the same as the stream generated by iterating `f` starting at `f(a)`. In other words, removing the first element from the stream of iterates of `f` is equivalent to starting the iteration from the next step.

For any type `α`, function `f` from `α` to `α`, and element `a` of type `α`, the tail of the iterated stream `(iterate f a)` is equal to the iterated stream `(iterate f (f a))`.


theorem eventually_nhdsWithin_of_eventually_nhds :
    ∀ {α : Type u_5} [inst : TopologicalSpace α] {s : Set α} {a : α} {p : α → Prop},
      (∀ᶠ (x : α) in nhds a, p x) → ∀ᶠ (x : α) in nhdsWithin a s, p x :=
  by sorry

The theorem `eventually_nhdsWithin_of_eventually_nhds` states that for any type `α` that has a `TopologicalSpace` structure, any set `s` of this type, any element `a` of this type, and any predicate `p` over elements of this type, if the predicate `p` holds eventually (i.e., outside of a set of measure zero) for elements `x` in the neighborhood of `a`, then `p` also holds eventually for elements `x` in the neighborhood of `a` within the set `s`. In simpler terms, if a property holds true near a point `a`, then it also holds true near `a` when we restrict our attention to a subset `s`.

If a property holds eventually in the neighborhood of a point in a topological space and measures zero set excludeds, then it also holds eventually in the neighborhood of that point within any subset of the space.


theorem SetTheory.PGame.neg_lf_neg_iff :
    ∀ {x y : SetTheory.PGame}, SetTheory.PGame.LF (-y) (-x) ↔ SetTheory.PGame.LF x y := by sorry

The theorem `SetTheory.PGame.neg_lf_neg_iff` states that for all pre-games `x` and `y`, the relation `SetTheory.PGame.LF` holds for `-y` and `-x` if and only if it also holds for `x` and `y`. In other words, the less or fuzzy (LF) relationship for the negations of two pre-games is equivalent to the LF relationship of the pre-games themselves. This theorem is related to the notion of winning strategies in game theory. Specifically, if the first player cannot win game `y` when preceded by game `x`, then the first player also cannot win the game `-x` when it is preceded by `-y`.

For all pre-games x and y, the less or fuzzy relation SetTheory.PGame.LF holds between -x and -y if and only if it holds between x and y.


theorem Finset.sum_range_succ_sub_sum :
    ∀ {M : Type u_3} (f : ℕ → M) {n : ℕ} [inst : AddCommGroup M],
      ((Finset.sum (Finset.range (n + 1)) fun i => f i) - Finset.sum (Finset.range n) fun i => f i) = f n :=
  by sorry

This theorem, `Finset.sum_range_succ_sub_sum`, states that for any type `M` where `M` is an additive commutative group, and for any function `f` from natural numbers to `M`, and for any natural number `n`, the difference between the sum of `f(i)` over the range `0` to `n + 1` (exclusive) and the sum of `f(i)` over the range `0` to `n` (exclusive) is equal to `f(n)`. In mathematical terms, it states that $\sum_{i=0}^{n+1} f(i) - \sum_{i=0}^{n} f(i) = f(n)$.

For any additive commutative group M and function f from natural numbers to M, the sum of f(i) from i=0 to n+1, minus the sum of f(i) from i=0 to n, equals f(n). In symbols, $\sum\_{i=0}^{n+1} f(i) - \sum\_{i=0}^{n} f(i) = f(n)$.


theorem MonotoneOn.mem_upperBounds_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
      MonotoneOn f t → ∀ {a : α}, s ⊆ t → a ∈ upperBounds s → a ∈ t → f a ∈ upperBounds (f '' s) :=
  by sorry

The theorem `MonotoneOn.mem_upperBounds_image` states that for all types `α` and `β` having a preorder, for any function `f` from `α` to `β`, and any sets `s` and `t` of type `α`, if the function `f` is monotone on `t`, and given `s` is a subset of `t`, if any element `a` is an upper bound of `s` and also belongs to `t`, then the image of `a` under `f` is an upper bound of the image of `s` under `f`. In other words, if a function is monotone on a set `t`, then the image under this function of an upper bound of any subset of `t` is an upper bound of the image of this subset.

If `f` is a monotone function from `α` to `β`, and `s` is a subset of `t` in `α` such that `a` is an upper bound of `s` and belongs to `t`, then the image `f(a)` is an upper bound of the image `f(s)`.


theorem Polynomial.C_inj : ∀ {R : Type u} {a b : R} [inst : Semiring R], Polynomial.C a = Polynomial.C b ↔ a = b := by
  sorry

The theorem `Polynomial.C_inj` states that for any type `R` that has a structure of semiring, and for any two elements `a` and `b` of `R`, the constant polynomial determined by `a` is equal to the constant polynomial determined by `b` if and only if `a` is equal to `b`. In other words, the map that associates to each element of the ring its corresponding constant polynomial is injective.

The map from a semiring to its constant polynomials is an injection.


theorem Submodule.mem_torsionBySet_iff :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R)
      (x : M), x ∈ Submodule.torsionBySet R M s ↔ ∀ (a : ↑s), ↑a • x = 0 :=
  by sorry

The theorem `Submodule.mem_torsionBySet_iff` establishes a characterization of membership in a certain submodule of a module. Specifically, for any commutative semiring `R`, any additive commutative monoid `M` that is also an `R`-module, any set `s` of scalars from `R`, and any element `x` from `M`, it states that `x` belongs to the submodule `torsionBySet R M s` (which consists of all elements in `M` annihilated by some scalar in `s`) if and only if for every scalar `a` in `s` (represented as `↑s`), the scalar multiplication `↑a • x` equals zero.

A module element belongs to the submodule generated by scalars in a set if and only if it is annihilated by every scalar in the set.


theorem Inducing.specializes_iff :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x y : X} {f : X → Y},
      Inducing f → (f x ⤳ f y ↔ x ⤳ y) :=
  by sorry

This theorem states that for any two types `X` and `Y` with topological space structures, any two elements `x` and `y` of `X`, and any function `f` from `X` to `Y` that induces the topology of `Y` from `X`, the specialization preorder (denoted by `⤳`) of the images `f(x)` and `f(y)` in `Y` is equivalent to the specialization preorder of `x` and `y` in `X`. The specialization preorder is a way of saying that one point is "closer" to a given set than another point, in the context of topological spaces.

For any topological spaces X and Y, continuous functions f : X -> Y, and elements x, y in X, the specialization preorders x ⤳ S and f(x) ⤳ f[S] agree for any set S in X, where ⤳ denotes the specialization preorder.


theorem lp.norm_rpow_eq_tsum :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)],
      0 < p.toReal → ∀ (f : ↥(lp E p)), ‖f‖ ^ p.toReal = ∑' (i : α), ‖↑f i‖ ^ p.toReal :=
  by sorry

The theorem `lp.norm_rpow_eq_tsum` states that for any type `α`, any function `E` from `α` to some type, any extended nonnegative real number `p` with a positive real part, and any normed additive commutative group indexed by `α`, if `f` is an element of the `lp` space for `E` and `p`, then the norm of `f` raised to the power of the real part of `p` is equal to the sum over all `α` of the norm of `f` at `i` raised to the power of the real part of `p`. In mathematical terms, this says ⟦f⟧^p = ∑ᵢ(|f(i)|^p), where ⟦f⟧ is the norm of `f`, |f(i)| is the absolute value of `f` at `i`, and the sum is over all `i` in `α`.

For any `α`, `E : α → Type`, extended nonnegative real `p` with positive real part, `lp` space `f` over `(α, E)` for norm and `p`, the norm of `f` raised to the power of the real part of `p` equals the sum over all `i` in `α` of the norm of `f` at `i` raised to the power of the real part of `p`.


/-- A monomorphism in `SimplexCategory` must increase lengths -/
theorem SimplexCategory.len_le_of_mono :
    ∀ {x y : SimplexCategory} {f : x ⟶ y}, CategoryTheory.Mono f → SimplexCategory.len x ≤ SimplexCategory.len y := by
  sorry

This theorem states that a monomorphism in the SimplexCategory must increase lengths. Specifically, for any two natural numbers `x` and `y` in the SimplexCategory, and any monomorphism `f` from `x` to `y` in the sense of category theory, the length of `x` is less than or equal to the length of `y`. In other words, monomorphisms in the SimplexCategory can't decrease the lengths of their objects.

In the SimplexCategory, the length of any object is not decreased by a monomorphism.


theorem tsum_sigma' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : ContinuousAdd α]
      [inst_3 : T3Space α] {γ : β → Type u_5} {f : (b : β) × γ b → α},
      (∀ (b : β), Summable fun c => f { fst := b, snd := c }) →
        Summable f → ∑' (p : (b : β) × γ b), f p = ∑' (b : β) (c : γ b), f { fst := b, snd := c } :=
  by sorry

The `tsum_sigma'` theorem states that for all types `α`, `β`, and a type function `γ` defined on `β`, given `α` is an additive commutative monoid, a topological space, supports continuous addition, and is a T3 space, and given a function `f` that maps each pair of type `β` and type `γ b` to `α`, if the sum of the function `f` is defined (is summable) for every `b` of type `β`, and overall is also summable, then the total sum of `f` over each pair of type `β` and `γ b` is equal to the sum of `f` over each `b` of type `β` and each `c` of type `γ b`. In mathematical terms, $\sum' (p : (b : β) × γ b), f(p) = \sum' (b : β) (c : γ b), f(b, c)$.

Given a commutative additive monoid `α` that is a T3 topological space supporting continuous addition, a function `f` from `β × γ b` to `α` is summable if and only if it is summable component-wise, i.e., the sum of `f` over all pairs is equal to the sum over all elements of `β` and their corresponding elements of `γ b`.


theorem uniqueDiffOn_Ici : ∀ (a : ℝ), UniqueDiffOn ℝ (Set.Ici a) := by sorry

The theorem `uniqueDiffOn_Ici` states that for every real number `a`, the left-closed right-infinite interval `[a, ∞)` is a uniquely differentiable set. This means that each point in the interval has a unique derivative (or equivalently, the derivative function is uniquely defined at each point). Here, `Set.Ici a` represents the interval `[a, ∞)` and `UniqueDiffOn ℝ (Set.Ici a)` expresses the unique differentiability of this interval in the field of real numbers.

For every real number `a`, the function `x ↦ d/dx (f x)` has a unique value for all `x ∈ [a, ∞)`, where `f` is the derivative function.


theorem NumberField.InfinitePlace.comap_mk :
    ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] (φ : K →+* ℂ) (f : k →+* K),
      NumberField.InfinitePlace.comap (NumberField.InfinitePlace.mk φ) f =
        NumberField.InfinitePlace.mk (RingHom.comp φ f) :=
  by sorry

The theorem `NumberField.InfinitePlace.comap_mk` states that for any two fields `k` and `K` and any ring homomorphisms `φ` from `K` to the complex numbers `ℂ` and `f` from `k` to `K`, the restriction of the infinite place (`NumberField.InfinitePlace.comap`) defined by the complex embedding `φ` along the embedding `f` is equal to the infinite place defined by the composition of the ring homomorphisms `φ` and `f` (`RingHom.comp φ f`). In other words, it's saying that the process of restricting an infinite place and then defining a new infinite place is the same as first composing the two ring homomorphisms and then defining the infinite place.

The theorem asserts that the restriction of the infinite place of a complex embedding of a field to an embedding of another field is equal to the infinite place obtained by composing the two embeddings.


theorem Cardinal.mk_coe_finset : ∀ {α : Type u} {s : Finset α}, Cardinal.mk { x // x ∈ s } = ↑s.card := by sorry

This theorem states that for any type `α` and any finite set `s` of that type, the cardinality of the set of elements `x` such that `x` belongs to `s` (denoted as `{ x // x ∈ s }`), is equal to the cardinality of `s` (denoted as `s.card`). In other words, the cardinality of a subset of a finite set `s` where each element is in `s`, is the same as the cardinality of `s` itself.

For any finite type `α` and set `s` of type `α`, the cardinality of the subset `{ x // x ∈ s }` equals the cardinality of `s`.


theorem Filter.tendsto_atTop_add_left_of_le' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] (l : Filter α) {f g : α → β} (C : β),
      (∀ᶠ (x : α) in l, C ≤ f x) →
        Filter.Tendsto g l Filter.atTop → Filter.Tendsto (fun x => f x + g x) l Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_atTop_add_left_of_le'` states that for all types `α` and `β`, where `β` is an ordered additive commutative group, given a filter `l` on `α` and two functions `f` and `g` from `α` to `β`, and a constant `C` from `β`. If for almost all `x` in `l`, `C` is less than or equal to `f(x)`, and if `g` tends to infinity as `x` tends to `l`, then the function `f(x) + g(x)` also tends to infinity as `x` tends to `l`. In other words, if `f(x)` is bounded below by a constant for almost all `x` in the filter and `g(x)` goes to infinity, then their sum also goes to infinity.

If a filter converges to a point in an ordered additive commutative group, and the function values of another function, which is bounded below by a constant for almost all points in the filter and tends to infinity, are added to the function values of a third function in the filter, then the sum also tends to infinity.


theorem Inseparable.mem_closed_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {s : Set X},
      Inseparable x y → IsClosed s → (x ∈ s ↔ y ∈ s) :=
  by sorry

The theorem `Inseparable.mem_closed_iff` states that in any topological space, for any two points `x` and `y` that are inseparable (meaning they cannot be separated by a neighborhood, as defined by the condition `nhds x = nhds y`), and for any set `s` which is closed, `x` is in `s` if and only if `y` is in `s`. That is, membership of one of these inseparable points in the set implies membership of the other. This theorem provides a connection between inseparability of points and the properties of closed sets in a topological space.

In any topological space, if two points are inseparable then they have identical elements in every closed set.


theorem Finset.sup'_product_left :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] {s : Finset β} {t : Finset γ}
      (h : (s ×ˢ t).Nonempty) (f : β × γ → α),
      Finset.sup' (s ×ˢ t) h f = Finset.sup' s ⋯ fun i => Finset.sup' t ⋯ fun i' => f (i, i') :=
  by sorry

The theorem `Finset.sup'_product_left` states that for any finite nonempty sets `s` of type `β` and `t` of type `γ`, any type `α` that is a join-semilattice, and any function `f` from the product of `β` and `γ` to `α`, the supremum of the image of the product set `s ×ˢ t` under `f` is equal to the supremum of the image of `s` under the function that maps each element of `s` to the supremum of the image of `t` under the function that maps each element of `t` to `f` applied to the pair of elements from `s` and `t`. Essentially, this theorem shows that the operation of taking supremums over a product set can be decomposed into taking supremums over each of the sets separately.

For any join-semilattice α, finite nonempty sets s:β and t:γ, and function f:β × γ → α, the supremum of f(s ×ˢ t) equals the supremum of the image of s under the function mapping each s i to the supremum of f(t) applied to each t j.


theorem Nat.log_eq_iff : ∀ {b m n : ℕ}, m ≠ 0 ∨ 1 < b ∧ n ≠ 0 → (Nat.log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)) := by
  sorry

The theorem `Nat.log_eq_iff` states that for any natural numbers `b`, `m`, and `n`, given that `m` is not zero or `b` is greater than 1 and `n` is not zero, the logarithm of `n` in base `b` is equal to `m` if and only if `b` to the power of `m` is less than or equal to `n` and `n` is less than `b` to the power of `m + 1`. This defines the conditions under which the logarithm function in Lean 4 yields a certain value.

For natural numbers `b`, `m`, and `n`, `log_b n = m` if and only if `b^m <= n` and `n < b^(m+1)`.


/-- The preimage of a compact set by a proper map is again compact. See also
`isProperMap_iff_isCompact_preimage` which proves that this property completely characterizes
proper map when the codomain is locally compact and Hausdorff.  -/
theorem IsProperMap.isCompact_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsProperMap f → ∀ {K : Set Y}, IsCompact K → IsCompact (f ⁻¹' K) :=
  by sorry

The theorem `IsProperMap.isCompact_preimage` states that for any two types `X` and `Y` with topological space structures, and any function `f` from `X` to `Y`, if `f` is a proper map then for any set `K` of type `Y` that is compact, the preimage of `K` under `f` (i.e., the set of all elements in `X` that map to elements in `K` under `f`) is also compact. This property completely characterises a proper map when the codomain is locally compact and Hausdorff, as shown in `isProperMap_iff_isCompact_preimage`.

If `f` is a proper map from a topological space `X` to another topological space `Y`, then the preimage of any compact subset `K` of `Y` under `f` is a compact subset of `X`.


theorem Isometry.comp_continuous_iff :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β} {γ : Type u_2}
      [inst_2 : TopologicalSpace γ], Isometry f → ∀ {g : γ → α}, Continuous (f ∘ g) ↔ Continuous g :=
  by sorry

The theorem `Isometry.comp_continuous_iff` states that for any types `α`, `β`, and `γ`, where `α` and `β` are pseudoemetric spaces and `γ` is a topological space, for any function `f` from `α` to `β`, if `f` is an isometry, then for any function `g` from `γ` to `α`, the composition of `f` and `g` is continuous if and only if `g` is continuous. This means that the continuity of the composition function `f ∘ g` is solely determined by the continuity of `g` when `f` is an isometry.

For any pseudometric spaces α, β, and topological space γ, if f : α → β is an isometry and g : γ → α is continuous, then their composition f ∘ g is also continuous. Conversely, if f : α → β is an isometry, then f ∘ g is continuous if and only if g is continuous.


theorem lt_max_of_lt_left : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a < b → a < max b c := by sorry

This theorem states that for any type `α` that has a linear order, if `a` is less than `b`, then `a` is also less than the maximum of `b` and `c`. This holds for any three values `a`, `b` and `c` of that type. In terms of algebra, if we have `a < b`, it's guaranteed that `a < max(b, c)`.

For any type `α` with a linear order, if `a` is less than `b`, then `a` is also less than the maximum of `b` and `c`. In symbols: `a < b` implies `a < max b c`.


theorem uniformInducing_iff' :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformInducing f ↔ UniformContinuous f ∧ Filter.comap (Prod.map f f) (uniformity β) ≤ uniformity α :=
  by sorry

This theorem states that for any two types `α` and `β` both equipped with a uniform space structure and any function `f` from `α` to `β`, `f` is a uniform inducing function if and only if `f` is uniformly continuous and the pre-image filter (also known as the pullback or comap) of the filter generated by `f` acting on each element of the product of `β` itself, when taken under the uniformity of `β`, is less than or equal to the uniformity of `α`. In simpler terms, this theorem is about the conditions under which a function between two uniform spaces preserves the uniformity structure.

A function between two uniform spaces is a uniform inducing function if and only if it is uniformly continuous and the pre-image filter of its filter generated on the product under the uniformity of the target space is less than or equal to the uniformity of the domain.


theorem Matrix.det_pow :
    ∀ {m : Type u_1} [inst : DecidableEq m] [inst_1 : Fintype m] {R : Type v} [inst_2 : CommRing R] (M : Matrix m m R)
      (n : ℕ), Matrix.det (M ^ n) = Matrix.det M ^ n :=
  by sorry

This theorem states that for any given square matrix `M` with entries from a commutative ring `R`, and for any natural number `n`, the determinant of the matrix `M` raised to the power `n` (i.e., `M` multiplied with itself `n` times) is equal to the determinant of `M` itself raised to the power of `n`. Here the matrix `M` is defined over a type `m`, which has decidable equality and is finite.

For any square matrix `M` over a commutative ring `R` with decidable equality and finite dimension, the determinant of `M` raised to the power `n` equals the determinant of `M` raised to the power `n`. In other words, `det(M^n) = det(M)^n`.


theorem List.take_take : ∀ {α : Type u_1} (n m : ℕ) (l : List α), List.take n (List.take m l) = List.take (min n m) l :=
  by sorry

This theorem, `List.take_take`, states that for any list `l` of type `α`, and any two natural numbers `n` and `m`, taking `n` elements of the sublist created by taking `m` elements of `l` is equivalent to taking the minimum of `n` and `m` elements from the original list `l`. Essentially, it captures the property that taking a sublist of a sublist gives you the same result as taking a sublist directly, as long as the size of the sublist is limited by the smaller of the two original sizes.

For any list `l` of type `α` and natural numbers `n` and `m`, `List.take n (List.take m l)` is equal to `List.take (min n m) l`.


theorem interior_Ici' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a : α}, Set.Nonempty (Set.Iio a) → interior (Set.Ici a) = Set.Ioi a :=
  by sorry

This theorem states that for any type `α` that has a topological space structure, a linear order, an order topology, and is densely ordered, and for any element `a` of `α`, if the set of all elements less than `a` (denoted `Set.Iio a`) is nonempty, then the interior (i.e., the largest open subset) of the set of all elements greater than or equal to `a` (denoted `Set.Ici a`) is exactly the set of all elements strictly greater than `a` (denoted `Set.Ioi a`). In mathematical terms, if `α` is a densely ordered topological space and there exists an element less than `a`, then the interior of the closed interval [a, ∞) is the open interval (a, ∞).

In a densely ordered topological space α, the interior of the closed interval [a, ∞) equals the open interval (a, ∞) if and only if α has an element less than a.


theorem MeasureTheory.FinMeasAdditive.of_eq_top_imp_eq_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} [inst : AddCommMonoid β]
      {T : Set α → β} {μ' : MeasureTheory.Measure α},
      (∀ (s : Set α), MeasurableSet s → ↑↑μ s = ⊤ → ↑↑μ' s = ⊤) →
        MeasureTheory.FinMeasAdditive μ T → MeasureTheory.FinMeasAdditive μ' T :=
  by sorry

The theorem `MeasureTheory.FinMeasAdditive.of_eq_top_imp_eq_top` states that for any type `α` equipped with a measurable space structure `m`, a measure `μ`, a type `β` equipped with an additive commutative monoid structure, a function `T` from sets of `α` to `β`, and another measure `μ'`, if for every measurable set `s` the condition that the measure `μ` of `s` being infinite implies the measure `μ'` of `s` being infinite holds, then the finiteness and additivity property of `T` with respect to `μ` implies the same property for `T` with respect to `μ'`. This property of `T` is known as `FinMeasAdditive`, and it states that for any two disjoint measurable sets `s` and `t` with finite measure, the value of `T` on the union of `s` and `t` equals the sum of the values of `T` on `s` and `t`.

If for all measurable sets `s` with infinite measure under `μ`, the same holds for `μ'`, then a finitely additive `μ`-measurable function `T` from sets of `α` to an additive commutative monoid `β` is also `μ'`-finitely additive.


theorem Path.continuous_uncurry_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {Y : Type u_4} [inst_1 : TopologicalSpace Y]
      {g : Y → Path x y}, Continuous ↿g ↔ Continuous g :=
  by sorry

This theorem states that for any topological spaces `X` and `Y`, and any points `x` and `y` in `X`, and any function `g` from `Y` to the set of paths from `x` to `y` in `X`, the function `g` is continuous if and only if the uncurried function `↿g` is continuous. Here, "uncurrying" a function refers to converting a function of multiple arguments into a function of one argument that returns another function, such that the original arguments can be provided one at a time.

For any topological spaces X and Y, functions g : Y -> paths from x to y in X, and points x and y in X, the function g is continuous if and only if its uncurried version ↿g : Y x X -> path from x to y in X is continuous.


theorem Mathlib.Topology.Filter._auxLemma.3 :
    ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any filter `f` on `α`, the filter `f` is less than or equal to the principal filter of `s` if and only if the set `s` is a member of the filter `f`. In other words, it is saying that a filter `f` contains all supersets of `s` (which is what it means for `f` to be less than or equal to the principal filter of `s`) if and only if `s` is one of the sets in the filter `f`.

For any filter `f` on a type `α` and any set `s` of type `α`, `f` is less than or equal to the principal filter of `s` if and only if `s` is an element of `f`.


theorem Option.map₂_assoc :
    ∀ {α : Type u_5} {β : Type u_6} {γ : Type u_4} {a : Option α} {b : Option β} {c : Option γ} {δ : Type u_1}
      {ε : Type u_2} {ε' : Type u_3} {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)) →
        Option.map₂ f (Option.map₂ g a b) c = Option.map₂ f' a (Option.map₂ g' b c) :=
  by sorry

The theorem `Option.map₂_assoc` states that for any types `α`, `β`, `γ`, `δ`, `ε`, and `ε'`, any options of these types `a`, `b`, and `c`, and any binary functions `f: δ → γ → ε`, `g: α → β → δ`, `f': α → ε' → ε`, `g': β → γ → ε'`, if for all `a` in `α`, `b` in `β` and `c` in `γ`, the function `f` applied to the output of function `g` applied to `a` and `b` and then applied to `c` equals the function `f'` applied to `a` and the output of function `g'` applied to `b` and `c`, then mapping `f` onto the result of mapping `g` onto `a` and `b` and then onto `c` equals mapping `f'` onto `a` and the result of mapping `g'` onto `b` and `c`. This theorem essentially establishes an associativity property for the `Option.map₂` operation.

For functions `f`, `g`, `f'`, and `g'` between types `α`, `β`, `γ`, `δ`, and `ε`, `ε'`, if `f(g(a, b) c) = f'(a, g'(b, c))` for all `a : α`, `b : β`, and `c : γ`, then `Option.map₂ f (Option.map₂ g a b) c = Option.map₂ f' a (Option.map₂ g' b c)`.


theorem Nat.gcd_add_self_right : ∀ (m n : ℕ), Nat.gcd m (n + m) = Nat.gcd m n := by sorry

The theorem `Nat.gcd_add_self_right` states that for all natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n + m` is the same as the gcd of `m` and `n`. In mathematical terms, it says that for any two natural numbers $m$ and $n$, we have $\gcd(m, n + m) = \gcd(m, n)$.

The greatest common divisor of a natural number with another number is unchanged when the second number is replaced by their sum with the first number. In mathematical notation, this is expressed as $\gcd(m, n) = \gcd(m, n+m)$.


/-- See also `Matrix.coeff_charpolyRev_eq_neg_trace`.  -/
theorem Matrix.trace_eq_neg_charpoly_coeff :
    ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] [inst_3 : Nonempty n]
      (M : Matrix n n R), Matrix.trace M = -Polynomial.coeff (Matrix.charpoly M) (Fintype.card n - 1) :=
  by sorry

The theorem `Matrix.trace_eq_neg_charpoly_coeff` states that for any commutative ring `R` and any type `n` with decidable equality, finite cardinality, and at least one element, the trace of an `n x n` matrix `M` with entries in `R` is equal to the negative of the coefficient of the term `X^(n-1)` in the characteristic polynomial of `M`. The characteristic polynomial of `M` is defined as the determinant of `(tI - M)`, where `I` is the identity matrix and `t` is a variable. The trace of a matrix is the sum of its diagonal entries.

For any commutative ring R and finite type n with at least one element, the trace of an n x n matrix M over R equals the negative of the coefficient of X^(n-1) in the determinant of (tI - M), where t is a variable and I is the identity matrix.


theorem List.set_eq_modifyNth :
    ∀ {α : Type u_1} (a : α) (n : ℕ) (l : List α), List.set l n a = List.modifyNth (fun x => a) n l := by sorry

The theorem `List.set_eq_modifyNth` states that for any type `α`, element `a` of type `α`, natural number `n`, and list `l` of elements of type `α`, setting the `n`th element of `l` to `a` using the function `List.set` is equivalent to modifying the `n`th element of `l` with a function that always returns `a`, using the function `List.modifyNth`. In other words, these two operations on a list produce the same result.

For any type `α`, natural number `n`, element `a` of type `α`, and list `l` of length `n+1` over `α`, `List.set l n a` is equal to `List.modifyNth l n (λ x => if h: n = succ (Pred x.length then a else x) : list α)`.


theorem IsExtrFilter.comp_mono :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsExtrFilter f l a → ∀ {g : β → γ}, Monotone g → IsExtrFilter (g ∘ f) l a :=
  by sorry

The theorem `IsExtrFilter.comp_mono` states that for any types `α`, `β`, and `γ`, with preorder relations defined on `β` and `γ`, given a function `f` from `α` to `β`, a filter `l` on `α`, and an element `a` of `α` such that `f` is extreme (either a minimum or a maximum) at `a` with respect to the filter `l`, then for any monotone function `g` from `β` to `γ`, the composition of `g` and `f` (denoted as `g ∘ f`) is also extreme at `a` with respect to the filter `l`. In other words, the extrema of a function are preserved under monotone transformations.

If `f: α → β` is extreme with respect to filter `l` on `α` at point `a ∈ α`, and `g: β → γ` is a monotone function, then `g ∘ f` is extreme with respect to filter `l` on `α` at point `a`.


theorem PerfectClosure.mk_mul_mk :
    ∀ (K : Type u) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (x y : ℕ × K),
      PerfectClosure.mk K p x * PerfectClosure.mk K p y =
        PerfectClosure.mk K p (x.1 + y.1, (⇑(frobenius K p))^[y.1] x.2 * (⇑(frobenius K p))^[x.1] y.2) :=
  by sorry

The theorem `PerfectClosure.mk_mul_mk` asserts that for any commutative ring `K`, prime number `p`, and pair of elements `x` and `y` from the cartesian product of natural numbers and `K`, the multiplication of the perfect closures of `x` and `y` is equal to the perfect closure of a pair. This pair is constructed from the sum of the first elements of `x` and `y`, and a product involving the Frobenius map applied to the second elements of `x` and `y`, where the Frobenius map is iteratively applied a number of times equal to the first element of the pair to each of the second elements of the pairs, respectively. In other words, if `x = (n, a)` and `y = (m, b)`, then the product of the perfect closures of `x` and `y` is equal to the perfect closure of `(n+m, a^p^m * b^p^n)`.

For any commutative ring K, prime number p, and pairs x = (n, a) and y = (m, b) in the cartesian product of natural numbers and K, the perfect closure of x \* y is equal to the perfect closure of (n + m, a^p^m \* b^p^n).


theorem symmetric_symmetrizeRel : ∀ {α : Type ua} (V : Set (α × α)), SymmetricRel (symmetrizeRel V) := by sorry

This theorem states that for any type `α` and any relation `V` defined as a set of ordered pairs of `α`, the result of the `symmetrizeRel` operation on `V` is a symmetric relation. Here, `symmetrizeRel` operation is used to take a relation and generate the maximal symmetric relation that is a subset of the given relation, while a relation is said to be symmetric if swapping the elements of each pair doesn't change the relation.

For any type `α` and relation `V` on `α`, the `symmetrizeRel V` relation is symmetric.


/-- The unoriented angle between two nonzero vectors is the absolute value of the oriented angle,
converted to a real.  -/
theorem Orientation.angle_eq_abs_oangle_toReal :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      x ≠ 0 → y ≠ 0 → InnerProductGeometry.angle x y = |Real.Angle.toReal (Orientation.oangle o x y)| :=
  by sorry

The theorem `Orientation.angle_eq_abs_oangle_toReal` states that, in a two-dimensional real inner product space (a space with a structure that allows dot products), the unoriented angle between two nonzero vectors is equal to the absolute value of the oriented angle between those vectors when transformed into a real number. An unoriented angle does not consider the direction of rotation, whereas the oriented angle does. The oriented angle is initially represented as a `Real.Angle`, a type that represents angles in radians and supports operations like addition and subtraction modulo $2\pi$, but then it is converted to a real number.

The theorem asserts that the absolute value of the oriented angle between two nonzero vectors in a real inner product space equals the unoriented angle between them when expressed as real numbers.


DFinsupp.Lex.wellFounded'

theorem DFinsupp.Lex.wellFounded' :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] {r : ι → ι → Prop}
      {s : (i : ι) → α i → α i → Prop},
      (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) →
        (∀ (i : ι), WellFounded (s i)) →
          ∀ [inst_1 : IsTrichotomous ι r], WellFounded (Function.swap r) → WellFounded (DFinsupp.Lex r s) :=
  by sorry

The theorem `DFinsupp.Lex.wellFounded'` states that for any type `ι`, and any type function `α : ι → Type` which gives a Type, presumed to have a zero, for each `ι`, along with an instance `(i : ι) → Zero (α i)` for each `ι`, if we have a relation `r : ι → ι → Prop` on `ι` and a family of relations `s : (i : ι) → α i → α i → Prop`, such that for all `i : ι` and `a : α i`, `s i a 0` is false (that is, no element compares smaller than zero) and `s i` is well-founded for each `i`, and if `r` is trichotomous and its opposite relation is well-founded, then the lexicographic relation `DFinsupp.Lex r s` on the direct sum of functions from `i` to `α i` is also well-founded.

This condition is important in formalizing the concept of "lexicographic order", where we first compare the input indexes according to `r` and then compare the function values according to `s i`, which is often used in mathematical proofs that require well-founded induction or recursion over the domain of the direct sum of functions.

If `ι` is a type, `α : ι → Type` is a type-valued function with a zero instance, `r : ι → ι → Prop` is a trichotomous and well-founded relation, and `s : (i : ι) → α i → α i → Prop` is a family of well-founded relations such that `s i a 0` is false for all `a : α i`, then the lexicographic relation `DFinsupp.Lex r s` on the direct sum of functions from `i` to `α i` is well-founded.


theorem Filter.limsup_eq_iInf_iSup_of_nat :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {u : ℕ → α},
      Filter.limsup u Filter.atTop = ⨅ n, ⨆ i, ⨆ (_ : i ≥ n), u i :=
  by sorry

This theorem states that for any function `u` from the natural numbers to a complete lattice `α`, the limit superior (`limsup`) of `u` as it approaches infinity is equal to the greatest lower bound (`infimum`) over all natural numbers `n`, of the least upper bounds (`supremum`) over all `i` that are greater than or equal to `n`, of `u(i)`. In other words, as we consider `u` over larger and larger sets of natural numbers, the smallest of the largest values that `u` takes on (i.e., the `limsup`) is equal to the smallest value among all the largest values of `u` over all sets of natural numbers starting from any given `n`.

The limit superior of a function `u` from natural numbers to a complete lattice `α` equals the infimum over all natural numbers `n` of the supremum over all `i ≥ n` of `u(i)`.


theorem MeasureTheory.Measure.restrict_union₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.AEDisjoint μ s t →
        MeasureTheory.NullMeasurableSet t μ → μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` on `α`, a measure `μ` on that measurable space, and two sets `s` and `t` of type `α`, if `s` and `t` are almost everywhere disjoint with respect to the measure `μ` and the set `t` is null measurable with respect to the measure `μ`, then the measure of the union of `s` and `t` restricted by `μ` is equal to the sum of the measures of `s` and `t` respectively restricted by `μ`. In other words, this theorem provides a way to measure the union of two sets that are almost everywhere disjoint and where one of the sets is null measurable.

Given measurable spaces `(α, m0)`, a measure `μ`, and sets `s` and `t` of type `α` with `s ∩ t` null with respect to `μ`, the measure of `s ∪ t` restricted by `μ` equals the sum of the measures of `s` and `t` restricted by `μ`.


theorem div_le_div_iff :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c d : α}, 0 < b → 0 < d → (a / b ≤ c / d ↔ a * d ≤ c * b) :=
  by sorry

This theorem states that for any type `α` that is a linear ordered semifield, given any four elements `a`, `b`, `c`, `d` of `α` and the condition that `b` and `d` are both greater than zero, the inequality `a / b ≤ c / d` is equivalent to `a * d ≤ c * b`. In plain terms, it shows the relationship between division and multiplication in inequalities, essentially stating that dividing `a` by `b` is less than or equal to dividing `c` by `d` if and only if `a` times `d` is less than or equal to `c` times `b`, given that `b` and `d` are both positive.

For any linear ordered semifield type `α` and positive elements `a`, `b`, `c`, `d` in `α`, the inequality `a / b <= c / d` is equivalent to `a * d <= c * b`.


theorem PartialHomeomorph.restr_source :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) (s : Set X), (PartialHomeomorph.restr e s).source = e.source ∩ interior s :=
  by sorry

This theorem states that for any types `X` and `Y`, which are equipped with respective topological spaces, a partial homeomorphism `e` from `X` to `Y`, and a set `s` of type `X`, the source of the restriction of `e` to `s` is equal to the intersection of the source of `e` and the interior of `s`. Here, a partial homeomorphism is a homeomorphism between a subset of `X` and a subset of `Y`, restriction of `e` to `s` means we are considering `e` only on the set `s`, and the interior of a set `s` in topology is the largest open subset of `s`.

Given types `X` and `Y` with topological spaces, a partial homeomorphism `e` from `X` to `Y`, and a subset `s` of `X`, the restriction of `e` to `s` is equal to the restriction of `e` to the interior of `s`. (Note: "restriction of `e` to `s`" refers to the homeomorphism from `s` to `e(s)`.)


theorem SimpleGraph.edgeSet_bot : ∀ {V : Type u}, SimpleGraph.edgeSet ⊥ = ∅ := by sorry

This theorem states that for any type `V`, the edge set of the bottom graph (`⊥`) is the empty set (`∅`). In other words, the graph with no vertices and no edges (designated by `⊥`) does not contain any edges in its edge set, hence it is equal to the empty set.

The bottom graph (⊥) of any type V has an empty edge set.


theorem PadicInt.norm_eq_pow_val :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]}, x ≠ 0 → ‖x‖ = ↑p ^ (-PadicInt.valuation x) := by sorry

The theorem `PadicInt.norm_eq_pow_val` states that for any natural number `p` which is prime, and any non-zero `p`-adic integer `x`, the norm of `x` is equal to `p` raised to the power of negative of the `p`-adic valuation of `x`. In other words, for a given prime `p` and a non-zero p-adic integer `x`, the norm of `x` can be calculated by taking `p` to the power of the negation of the `p`-adic valuation of `x`. This establishes a relationship between the norm and the `p`-adic valuation of `p`-adic integers.

For any prime number `p` and non-zero `p`-adic integer `x`, the norm of `x` equals `p^(-v_p(x))`, where `v_p(x)` is the `p`-adic valuation of `x`.


theorem CategoryTheory.IsIso.inv_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [inst_1 : CategoryTheory.IsIso f],
      CategoryTheory.inv (CategoryTheory.inv f) = f :=
  by sorry

The theorem `CategoryTheory.IsIso.inv_inv` states that for any category `C` and any two objects `X` and `Y` in `C`, if `f` is an isomorphism (as indicated by `CategoryTheory.IsIso f`) from `X` to `Y`, then the inverse of the inverse of `f` is equal to `f` itself. In other words, this theorem ensures the "double inversion" property in the category theory context: applying the inverse operation twice on an isomorphism results in the original isomorphism.

For any category `C` and objects `X` and `Y` with an isomorphism `f : X ↔ Y`, the inverse of `f` is the inverse of its own inverse, i.e., `(fun inv_f => inv_f ∘ inv_f) f = f`.


/-- If a set `s` is separable, then the corresponding subtype is separable in a (pseudo extended)
metric space.  This is not obvious, as the countable set whose closure covers `s` does not need in
general to be contained in `s`.  -/
theorem TopologicalSpace.IsSeparable.separableSpace :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α},
      TopologicalSpace.IsSeparable s → TopologicalSpace.SeparableSpace ↑s :=
  by sorry

This theorem states that if a set `s` is separable in the context of topology, then the corresponding subset type is also separable in a pseudo extended metric space. The term "separable" in this context means that the set `s` is contained in the closure of a countable set. It's important to note that this doesn't necessarily mean that the countable set is contained within `s`. The proof of this theorem is not provided here.

If a set `s` is separable in the context of topology, then its corresponding subset type is separable in a pseudo extended metric space.


Isometry.injective

/-- An isometry from an emetric space is injective  -/
theorem Isometry.injective :
    ∀ {α : Type u} {β : Type v} [inst : EMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → Function.Injective f :=
  by sorry

This theorem states that if a function `f` from one emetric space `α` to another emetric space or pseudoemetric space `β` is an isometry, meaning it preserves the extended distance (`edist`) between any two points in `α`, then `f` is also injective. In other words, if `f(x)` equals `f(y)`, it must be the case that `x` equals `y`. This is a fundamental property of isometric embeddings in metric and pseudoemetric spaces.

If `f: α → β` is an isometry between metric or pseudometric spaces `α` and `β`, then `f` is injective.


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

The theorem `SemiconjBy.neg_right` states that for any type `R` which supports multiplication and distribution of negative sign over multiplication, and for any elements `a`, `x`, and `y` of `R`, if `x` is semiconjugate to `y` by `a` (that is, if `a * x = y * a`), then `-x` is semiconjugate to `-y` by `a` (that is, `a * (-x) = (-y) * a`). In other words, if `a * x = y * a`, then it follows that `a * (-x) = (-y) * a`.

If `a`, `x`, and `y` are elements of a type `R` with multiplication and distributivity of negative signs, and `x` is semiconjugate to `y` by `a`, then `-x` is semiconjugate to `-y` by `a`. In other words, `a * (-x) = (-y) * a` given `a * x = y * a`.


Nat.ModEq.dvd

/-- **Alias** of the forward direction of `Nat.modEq_iff_dvd`. -/
theorem Nat.ModEq.dvd : ∀ {n a b : ℕ}, a ≡ b [MOD n] → ↑n ∣ ↑b - ↑a := by sorry

This theorem is an alias for the forward direction of `Nat.modEq_iff_dvd`. It states that for any natural numbers `n`, `a`, and `b`, if `a` is equivalent to `b` modulo `n` (denoted as `a ≡ b [MOD n]`), then `n` divides the difference between `b` and `a` (expressed as `↑n ∣ ↑b - ↑a`). In mathematical terms, this means if `a` and `b` have the same remainder when divided by `n`, then `n` is a divisor of `b - a`.

If `a` is congruent to `b` modulo `n`, then `n` divides the difference between `b` and `a`. In other words, `(a ≡ b [MOD n]) ⟹ ↑n ∣ ↑b - ↑a`.


theorem Int.covBy_iff_succ_eq : ∀ {m n : ℤ}, m ⋖ n ↔ m + 1 = n := by sorry

This theorem states that for any two integers `m` and `n`, `m` is covered by `n` (denoted `m ⋖ n`) if and only if `m + 1` is equal to `n`. In other words, an integer `m` is considered to be covered by another integer `n` precisely when `n` is the next integer following `m`.

For integers `m` and `n`, `m ⋖ n` holds if and only if `m + 1 = n`.


theorem Mathlib.Data.List.Chain._auxLemma.11 : ∀ {α : Type u} {R : α → α → Prop} (a : α), List.Chain' R [a] = True := by
  sorry

The theorem `Mathlib.Data.List.Chain._auxLemma.11` states that for any type `α`, any binary relation `R` on `α`, and any element `a` of type `α`, the property `List.Chain' R [a]` always holds true. In other words, a list composed of a single element always satisfies the chain condition for any relation `R`, as there are no adjacent elements to test the relation on.

For any type `α` and binary relation `R` on `α`, the singleton list `[a]` satisfies the chain condition `List.Chain' R` for all `a` in `α`.


theorem MeasureTheory.Measure.AbsolutelyContinuous.map :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ ν : MeasureTheory.Measure α},
      MeasureTheory.Measure.AbsolutelyContinuous μ ν →
        ∀ {f : α → β},
          Measurable f →
            MeasureTheory.Measure.AbsolutelyContinuous (MeasureTheory.Measure.map f μ)
              (MeasureTheory.Measure.map f ν) :=
  by sorry

This theorem states that if a measure `μ` is absolutely continuous with respect to another measure `ν` (in the sense that if `ν(A) = 0` then `μ(A) = 0`), and if a function `f` is measurable (meaning the preimage of every measurable set is also measurable), then the pushforward measure `f` applied to `μ` is also absolutely continuous with respect to the pushforward measure applied to `ν`. In simpler terms, the absolute continuity property is preserved under the mapping of a measurable function.

If `μ` is absolutely continuous with respect to `ν` and `f` is a measurable function, then the pushforward measure `f`��ˆ(`μ`) is absolutely continuous with respect to the pushforward measure `f`��ˆ(`ν`).


theorem CategoryTheory.ShortComplex.cyclesMap_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasLeftHomology S₂]
      [inst_4 : CategoryTheory.ShortComplex.HasLeftHomology S₃] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
      CategoryTheory.ShortComplex.cyclesMap (CategoryTheory.CategoryStruct.comp φ₁ φ₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap φ₁)
          (CategoryTheory.ShortComplex.cyclesMap φ₂) :=
  by sorry

This theorem is about the composition of morphisms in the context of a mathematical structure known as a short complex in category theory. It states that for any type `C` that forms a category and has zero morphisms, and for any three short complexes `S₁`, `S₂`, and `S₃` each with left homology, the `cyclesMap` (a morphism mapping to cycles in the homology) of the composition of two morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃` is equal to the composition of the `cyclesMap` of `φ₁` and the `cyclesMap` of `φ₂`. This means that the operation of taking cycles commutes with the operation of composing morphisms.

For any three short complexes `S₁`, `S₂`, and `S₃` in a category `C` with zero morphisms, the cycles map of their composition `S₁ ⟶ S₂ ⟶ S₃` equals the composition of the cycles maps `S₁ ⟶ S₂` and `S₂ ⟶ S₃`.


theorem Function.argminOn_mem :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α)
      (hs : Set.Nonempty s), Function.argminOn f h s hs ∈ s :=
  by sorry

The theorem `Function.argminOn_mem` states that for any types `α` and `β`, given a function `f` from `α` to `β`, a well-founded less-than relation on `β`, and a non-empty set `s` of `α`, the element of `s`, which is obtained by applying the function `Function.argminOn` to `f`, the well-founded relation, `s`, and the non-emptiness of `s`, is an element of the set `s`. In other words, it guarantees that the `Function.argminOn` function always returns an element from the provided non-empty set `s`, where this element has the minimum image under the function `f` with respect to the provided less-than relation on `β`.

For any function `f` from a non-empty set `s` to a type `β` with a well-founded ordering, the element of `s` with minimum image under `f` with respect to the ordering exists in `s`.


theorem CategoryTheory.Limits.biprod.isoProd_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
      (CategoryTheory.Limits.biprod.isoProd X Y).inv =
        CategoryTheory.Limits.biprod.lift CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd :=
  by sorry

This theorem states that for any category `C` that has zero morphisms and any two objects `X` and `Y` in `C` with a binary biproduct, the inverse of the isomorphism from the binary biproduct to the product of `X` and `Y` is given by the lift of the product's first and second projection maps. In other words, this isomorphism from the binary biproduct to the product can be inverted by taking a lift of the projection maps to the individual components of the product.

For any category with zero morphisms and objects `X` and `Y` having a binary biproduct, the inverse of the isomorphism from the binary biproduct to their product is given by the lifts of their projection maps.


theorem isLUB_pair : ∀ {γ : Type w} [inst : SemilatticeSup γ] {a b : γ}, IsLUB {a, b} (a ⊔ b) := by sorry

The theorem `isLUB_pair` states that for any given type `γ` equipped with a semilattice structure, and any two elements `a` and `b` of this type, the join of `a` and `b` (denoted by `a ⊔ b`) is a least upper bound of the set containing `a` and `b`. In other words, the join of `a` and `b` is the smallest element that is greater than or equal to both `a` and `b`. This is a property characteristic of semilattices.

For any semilattice type `γ` and elements `a` and `b` in `γ`, `a ⊔ b` is the least element that is greater than or equal to both `a` and `b`.


theorem closedEmbedding_of_continuous_injective_closed :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Continuous f → Function.Injective f → IsClosedMap f → ClosedEmbedding f :=
  by sorry

The theorem `closedEmbedding_of_continuous_injective_closed` states that for any two types `X` and `Y`, along with a function `f` from `X` to `Y`, given that `X` and `Y` are topological spaces, if the function `f` is continuous, injective (that is, `f x = f y` implies `x = y`), and a closed map (that is, the image of any closed set of `X` is closed in `Y`), then `f` is a closed embedding. A closed embedding, in the context of topology, is a function that is injective, continuous, its image is a closed set, and the function induces a homeomorphism (bijective, continuous, and has continuous inverse) between the original space and the image space.

If a continuous, injective, and closed function between topological spaces X and Y maps closed sets to closed sets, then it is a closed embedding.


ConvexBody.isCompact

theorem ConvexBody.isCompact :
    ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] (K : ConvexBody V),
      IsCompact ↑K :=
  by sorry

The theorem `ConvexBody.isCompact` states that for any given convex body `K` in a real vector space `V` (where `V` is a topological space and also an additive commutative group), the set corresponding to `K` is compact. Here, a set is compact if for every nontrivial filter `f` that contains the set, there exists an element `a` in the set such that every set in `f` meets every neighborhood of `a`. This is essentially saying that the convex body `K` has the property that every collection of closed sets with the finite intersection property has a non-empty intersection.

A convex body in a real vector space is compact if and only if every filter containing it has an element with the property that every neighborhood of that element intersects every set in the filter.


LinearIndependent.map

/-- If `v` is a linearly independent family of vectors and the kernel of a linear map `f` is
disjoint with the submodule spanned by the vectors of `v`, then `f ∘ v` is a linearly independent
family of vectors. See also `LinearIndependent.map'` for a special case assuming `ker f = ⊥`.  -/
theorem LinearIndependent.map :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {M' : Type u_5} {v : ι → M} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'],
      LinearIndependent R v →
        ∀ {f : M →ₗ[R] M'},
          Disjoint (Submodule.span R (Set.range v)) (LinearMap.ker f) → LinearIndependent R (⇑f ∘ v) :=
  by sorry

The theorem is stating that if we have a linearly independent family of vectors 'v' and the kernel of a linear map 'f' is disjoint with the submodule spanned by the vectors of 'v', then the composition of 'f' and 'v' is also a linearly independent family of vectors. It does this within the context of a semiring 'R' and two additively commutative monoids 'M' and 'M''. This means that no vector in the span of 'v' is mapped to zero by 'f', unless it is the zero vector itself. The theorem essentially preserves the property of linear independence through the linear map if the aforementioned conditions are met.

If 'v' is a linearly independent family of vectors in an additively commutative monoid 'M' over a semiring 'R', and the kernel of a linear map 'f' from 'M' to another additively commutative monoid 'N' does not intersect the submodule spanned by 'v', then the image of 'v' under 'f' is also a linearly independent family of vectors in 'N'.


theorem CategoryTheory.Limits.cokernel.condition_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {Z : C}
      (h : CategoryTheory.Limits.cokernel f ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π f) h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

The theorem `CategoryTheory.Limits.cokernel.condition_assoc` states that for any category `C` with zero morphisms, given any objects `X`, `Y`, and `Z` in `C`, and a morphism `f` from `X` to `Y` that has a cokernel, if we have a morphism `h` from the cokernel of `f` to `Z`, then the composition of `f` with the composition of the cokernel projection of `f` and `h` is equal to the composition of the zero morphism and `h`. Essentially, this is the associativity condition for the cokernel in the context of category theory.

For any object X, Y, Z in a category with zero morphisms and any morphism f : X → Y having a cokernel, the composition of f with h · k, where h is a morphism from the cokernel of f to Z and k is the cokernel projection, equals the composition of the zero morphism with h.


theorem Finset.prod_lt_prod_of_nonempty' :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelCommMonoid M] {f g : ι → M} {s : Finset ι},
      s.Nonempty → (∀ i ∈ s, f i < g i) → (Finset.prod s fun i => f i) < Finset.prod s fun i => g i :=
  by sorry

The theorem `Finset.prod_lt_prod_of_nonempty'` states that for any nonempty finite set `s` of elements of any type `ι`, and for any two functions `f` and `g` from `ι` to a type `M` that has an ordered cancelable commutative monoid structure, if every element `i` in `s` satisfies `f(i) < g(i)`, then the product of `f(i)` as `i` ranges over `s` is strictly less than the product of `g(i)` as `i` ranges over `s`. In mathematical notation, if `s` is nonempty and $\forall i \in s, f(i) < g(i)$, then $\prod_{i \in s} f(i) < \prod_{i \in s} g(i)$.

If `s` is a nonempty finite set and `f(i) < g(i)` for all `i` in `s`, then $\prod\_{i \in s} f(i) < \prod\_{i \in s} g(i)$.


theorem LieHom.idealRange_eq_map :
    ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L'), LieHom.idealRange f = LieIdeal.map f ⊤ :=
  by sorry

The theorem `LieHom.idealRange_eq_map` states that for any commutative ring `R`, Lie rings `L` and `L'`, and a Lie algebra morphism `f` from `L` to `L'` (where `L` and `L'` are Lie algebras over `R`), the ideal range of `f` is equal to the image of the top ideal in `L` under `f`. In other words, `f` maps the top (or universal) ideal of `L` onto the ideal generated by the range of `f` in `L'`.

For any commutative ring `R`, Lie algebras `L` and `L'`, and a Lie algebra morphism `f` from `L` to `L'`, the image of the top ideal in `L` under `f` generates the ideal range of `f` in `L'`.


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

The theorem `Polynomial.C_mul` states that for any semiring `R` and for any elements `a` and `b` of `R`, the polynomial constant of the product of `a` and `b` is equal to the product of the polynomial constants of `a` and `b` respectively. In other words, it means that the mapping from `R` to the polynomial constants over `R` preserves multiplication. This theorem asserts the multiplicative property of constant polynomials in a semiring.

For any semiring R and elements a and b in R, the polynomial constant of the product a * b equals the product of the polynomial constants of a and b.


theorem Zsqrtd.smul_val : ∀ {d : ℤ} (n x y : ℤ), ↑n * { re := x, im := y } = { re := n * x, im := n * y } := by sorry

This theorem establishes the scalar multiplication operation in Z[sqrt(d)], the ring of integers extended by the square root of an integer d. For any integer d, and any integers n, x, and y, the product of n and the complex number with real part x and imaginary part y is equal to the complex number with real part n*x and imaginary part n*y. In other words, multiplication distributes over the real and imaginary components of the complex number.

For any integer d in Z, and any integers n, x, and y, the operation (n : Z[sqrt d]) * (x + i*y) = n*x + i*n*y holds in the ring Z[sqrt d], where i is the imaginary unit.


ContinuousOrderHom.ext

theorem ContinuousOrderHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
      [inst_3 : Preorder β] {f g : α →Co β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two continuous order-preserving functions `f` and `g` from a topological space with a preorder `α` to a topological space with a preorder `β`, if for all `a` in `α`, `f(a)` is equal to `g(a)`, then `f` is equal to `g`. In other words, two continuous order-preserving functions are identical if they produce the same output for every input.

If two continuous order-preserving functions between preordered topological spaces have the same output for every input, then they are equal.


theorem eq_of_prime_pow_eq :
    ∀ {R : Type u_5} [inst : CancelCommMonoidWithZero R] [inst_1 : Unique Rˣ] {p₁ p₂ : R} {k₁ k₂ : ℕ},
      Prime p₁ → Prime p₂ → 0 < k₁ → p₁ ^ k₁ = p₂ ^ k₂ → p₁ = p₂ :=
  by sorry

The theorem `eq_of_prime_pow_eq` states that, for any type `R` that forms a cancel commutative monoid with 0 and possesses a unique unit, given two elements `p₁` and `p₂` from `R` and two non-zero natural numbers `k₁` and `k₂`. If `p₁` and `p₂` are both prime elements in the sense that they are non-zero, not a unit, and for any two elements `a` and `b` from `R`, if the prime element divides the product of `a` and `b`, then it divides either `a` or `b`, and the `k₁`-th power of `p₁` equals the `k₂`-th power of `p₂`, then `p₁` must equal `p₂`.

If two non-unit, prime elements `p₁` and `p₂` in a cancel commutative monoid `R` with 0 and a unique unit, satisfied `p₁^k₁ = p₂^k₂` for some non-zero natural numbers `k₁` and `k₂`, then `p₁` equals `p₂`.


theorem MeasureTheory.Lp.norm_compMeasurePreserving :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {β : Type u_5} [inst_1 : MeasurableSpace β] {μb : MeasureTheory.Measure β}
      {f : α → β} (g : ↥(MeasureTheory.Lp E p μb)) (hf : MeasureTheory.MeasurePreserving f μ μb),
      ‖(MeasureTheory.Lp.compMeasurePreserving f hf) g‖ = ‖g‖ :=
  by sorry

This theorem states that for any measure-preserving function `f` from a measurable space `α` to a measurable space `β`, and for any function `g` from the Lp space over the measure space `β`, the Lp norm of the composition of `f` and `g` (after the measure-preserving transformation by `f`) is equal to the Lp norm of `g`. Here, the Lp space is a space of functions that are measurable with respect to a given measure, and the norm involves integration according to the measure and the p-th power of the absolute value of the function. The theorem hence states that measure-preserving transformations do not change the Lp norm of functions in the Lp space. The Lp norm is a generalization of the Euclidean norm and is used extensively in functional analysis and measure theory.

For any measure-preserving function `f` from a measurable space `α` to a measurable space `β` and any function `g` in the Lp space over `β`, the Lp norm of `g ∘ f` equals the Lp norm of `g`.


FirstOrder.Language.Embedding.ext

theorem FirstOrder.Language.Embedding.ext :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] ⦃f g : FirstOrder.Language.Embedding L M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

The theorem `FirstOrder.Language.Embedding.ext` states that for any two embeddings `f` and `g` from a structure `M` to another structure `N` in some first-order language `L`, if they map every element in `M` to the same element in `N` (i.e., `f x = g x` for all `x` in `M`), then these two embeddings are the same, `f = g`. In other words, two embeddings between the same structures in a first-order language are equal if they agree on all elements of the domain.

In a first-order language, two embeddings of the same structure agreeing on all elements are equal.


theorem Nat.card_eq_one_iff_unique : ∀ {α : Type u_1}, Nat.card α = 1 ↔ Subsingleton α ∧ Nonempty α := by sorry

The theorem `Nat.card_eq_one_iff_unique` states that for any type `α`, the cardinality of `α` (represented as a natural number) is equal to 1 if and only if `α` is both a subsingleton and nonempty. In other words, a type `α` has exactly one element if and only if it satisfies the two conditions: being a subsingleton (i.e., there is at most one element in `α`) and being nonempty (i.e., there is at least one element in `α`).

The natural number representing the cardinality of a nonempty type equals 1 if and only if the type is a subsingleton.


theorem ArithmeticFunction.moebius_mul_coe_zeta : ArithmeticFunction.moebius * ↑ArithmeticFunction.zeta = 1 := by sorry

The theorem `ArithmeticFunction.moebius_mul_coe_zeta` states that the multiplication of the Möbius function (`ArithmeticFunction.moebius`) and the cast of the Riemann zeta function (`ArithmeticFunction.zeta`) to an arithmetic function of integers results in the identity function. This is the mathematical statement of the Möbius inversion formula, which states that if a function `f` is defined on the positive integers and `f(1) = 1`, then the Möbius function `μ` and the Riemann zeta function `ζ` satisfy `f * μ = ζ`.

The Möbius function multiplied with the integer-valued Riemann zeta function yields the identity function.


theorem Bool.or_self : ∀ (b : Bool), (b || b) = b := by sorry

This theorem, `Bool.or_self`, states that for any Boolean value `b`, the logical OR of `b` with itself is equal to `b`. In other words, it's expressing the idempotent property of the logical OR operation in Boolean algebra: "or-ing" a value with itself does not change the value. This is true for both `b = true` and `b = false`.

For all Boolean values `b`, `b ∨ b` equals `b`.


/-- The elements of the atlas belong to the maximal atlas for any structure groupoid.  -/
theorem StructureGroupoid.subset_maximalAtlas :
    ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
      (G : StructureGroupoid H) [inst_3 : HasGroupoid M G], atlas H M ⊆ StructureGroupoid.maximalAtlas M G :=
  by sorry

The theorem "StructureGroupoid.subset_maximalAtlas" states that for any given structure groupoid 'G', all elements from the atlas (set of partial homeomorphisms between a manifold 'M' and a model space 'H') are also elements of the maximal atlas of the structure groupoid 'G' for a manifold 'M'. This is true regardless of the specific types used for 'M' and 'H', as long as 'M' and 'H' are topological spaces and there exists a charted space structure between 'M' and 'H'.

For any topological space manifold M and model space H with a charted space structure between them, the atlas (set of partial homeomorphisms between M and H) is included in the maximal atlas of the structure groupoid of M.


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

The theorem `Set.preimage_swap_prod` states that for any two sets `s` of type `α` and `t` of type `β`, the preimage of the Cartesian product of `s` and `t` under the swapping function is the same as the Cartesian product of `t` and `s`. In other words, if you take the Cartesian product of `s` and `t`, swap the elements in each pair, and then take the preimage under the swapping function, the result will be the same as if you had just taken the Cartesian product of `t` and `s` directly. This theorem demonstrates the interchangeability of the factors of a Cartesian product under the swap operation. This can be expressed in mathematical terms as: for all sets `s` and `t`, $(\mathrm{swap}^{-1}(s \times t)) = t \times s$.

For any sets `s` and `t`, swapping the factors of their Cartesian product and taking the preimage is equal to directly taking the Cartesian product of `t` and `s`, i.e., $(\mathrm{swap}^{-1}(s \times t)) = t \times s$.


theorem Continuous.measurable2 :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_5} [inst : TopologicalSpace α]
      [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α] [inst_3 : TopologicalSpace β]
      [inst_4 : MeasurableSpace β] [inst_5 : OpensMeasurableSpace β] [inst_6 : TopologicalSpace γ]
      [inst_7 : MeasurableSpace γ] [inst_8 : BorelSpace γ] [inst_9 : MeasurableSpace δ]
      [inst_10 : SecondCountableTopologyEither α β] {f : δ → α} {g : δ → β} {c : α → β → γ},
      (Continuous fun p => c p.1 p.2) → Measurable f → Measurable g → Measurable fun a => c (f a) (g a) :=
  by sorry

The theorem `Continuous.measurable2` states that for any types `α`, `β`, `γ`, and `δ` which are equipped with topological spaces, measurable spaces, and other necessary structures, if we have a continuous function `c` from the product of `α` and `β` to `γ`, and if the functions `f` and `g` from `δ` to `α` and `β`, respectively, are measurable, then the function which maps an element `a` from `δ` to `c(f(a), g(a))` in `γ` is also measurable. In other words, the composition of measurable functions and a continuous function, under certain conditions, returns a measurable function.

If `α`, `β`, `γ`, and `δ` are topological and measurable spaces, `c : α × β → γ` is continuous, and `f : δ → α` and `g : δ → β` are measurable, then the function `x ↦ c(f(x), g(x))` from `δ` to `γ` is measurable.


theorem IsGalois.of_separable_splitting_field :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {p : Polynomial F}
      [sp : Polynomial.IsSplittingField F E p], Polynomial.Separable p → IsGalois F E :=
  by sorry

The theorem `IsGalois.of_separable_splitting_field` states that for any fields `F` and `E`, with `E` being an algebra over `F`, and any polynomial `p` with coefficients in `F`, if `E` is the splitting field of `p` and `p` is a separable polynomial (i.e., `p` is coprime with its derivative), then the field extension `F` to `E` is a Galois extension. In more mathematical terms, it means that if a polynomial is separable and its roots are in `E` (making `E` the splitting field of `p`), then the field extension from `F` to `E` has a property called Galois, which involves certain symmetries between the roots of the polynomial.

If `F` is a field, `E` is the splitting field of a separable polynomial `p` over `F` with coefficients in `F`, then `F` to `E` is a Galois extension.


theorem DenseRange.closure_range :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_4} {f : α → X},
      DenseRange f → closure (Set.range f) = Set.univ :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure, any type `α`, and any function `f` mapping from `α` to `X`, if `f` has a DenseRange, that is, the image of `f` is a dense subset of `X`, then the closure of the range of `f` equals the universal set of `X`. In simpler terms, if the range of `f` is dense in `X`, it means that every point of `X` is either in the range of `f` or is a limit point of the range, thus taking the closure of the range of `f` (which includes all limit points) results in the entire set `X`.

If `f` is a continuous function from `α` to a topological space `X` with a dense range, then the closure of `range(f)` equals `X`.


theorem PartENat.some_eq_natCast : ∀ (n : ℕ), ↑n = ↑n := by sorry

This theorem states that for every natural number 'n', the result of casting 'n' to some other type (denoted by the ↑ symbol) is equal to the result of casting 'n' to the same other type. Essentially, it's saying that the process of type-casting a natural number is consistent and will always yield the same result when applied to the same input.

For every natural number n, ↑n = ↑n, where ↑ denotes type-casting to some other type.


theorem Real.differentiableAt_arcsin : ∀ {x : ℝ}, DifferentiableAt ℝ Real.arcsin x ↔ x ≠ -1 ∧ x ≠ 1 := by sorry

The theorem states that the inverse of the sine function, `arcsin`, is differentiable at a real point `x` if and only if `x` is not equal to `-1` and `x` is not equal to `1`. In other words, the `arcsin` function has a derivative at a given point in its domain, except at points `-1` and `1`.

The function `arcsin` is differentiable at a real number `x` if and only if `x ≠ -1` and `x ≠ 1`.


theorem CategoryTheory.Limits.prod.map_fst_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Y ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f g)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst h) =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst (CategoryTheory.CategoryStruct.comp f h) :=
  by sorry

This theorem is named `CategoryTheory.Limits.prod.map_fst_assoc` in the Lean 4 library of category theory, specifically in the part dealing with limits and products. It states that for any category `C`, and any four objects `W, X, Y, Z` in `C`, if `W` and `X` have a binary product, and `Y` and `Z` also have a binary product, and if `f` is a morphism from `W` to `Y`, `g` is a morphism from `X` to `Z`, and `h` is a morphism from `Y` to some object `Z_1`, then the composition of the product map of `f` and `g` with the composition of the projection to the first component and `h` is equal to the composition of the projection to the first component with the composition of `f` and `h`. This is a categorical property related to the interaction between products and morphism composition.

Given any category `C` and morphisms `f: W × X → Y`, `g: X → Z`, and `h: Y → Z_1` in `C`, where `W × X` and `Y × Z` are binary products, the diagram commutes: `(π₁₁ × π₂)_*(f × g) = (π₁₁ *) (f * h)`, where `π₁₁` denotes the projection to the first component.


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

This theorem states that for any types `α` and `E`, where `α` is equipped with a measurable space structure `m0`, `E` is a normed additive commutative group, and `p` is an extended nonnegative real number, if we have a measure `μ` on `α` and a function `f` from `α` to `E` that satisfies the property `MeasureTheory.Memℒp` (which means that `f` is almost everywhere strongly measurable and the p-th power of the integral over the measure space of the norm of `f` raised to the power `p` is finite for `p < ∞`, or the essential supremum of `f` is finite for `p = ∞`), then the seminorm of `f`, `MeasureTheory.snorm f p μ`, is less than infinity. This seminorm is defined differently based on the value of `p`: it is `0` for `p=0`, it is the p-th root of the integral of the p-th power of the norm of `f` for `0 < p < ∞`, and it is the essential supremum of the norm of `f` for `p = ∞`.

For any measurable space `(α, m0)`, normed additive commutative group `E`, extended nonnegative real number `p`, measure `μ` on `α`, and almost everywhere strongly measurable function `f` from `α` to `E` satisfying `MeasureTheory.Memℒp`, the seminorm `MeasureTheory.snorm f p μ` is finite.


theorem Subgroup.map_equiv_eq_comap_symm' :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G ≃* N) (K : Subgroup G),
      Subgroup.map (MulEquiv.toMonoidHom f) K = Subgroup.comap (MulEquiv.toMonoidHom (MulEquiv.symm f)) K :=
  by sorry

This theorem states that for any groups `G` and `N`, and a multiplicative equivalence `f` from `G` to `N`, the image of a subgroup `K` of `G` under the monoid homomorphism induced by `f` is the same as the preimage of `K` under the monoid homomorphism induced by the inverse of `f`. In other words, mapping `K` through `f` and then pulling it back via the inverse of `f` gives us `K` back. This is a manifestation of the fundamental property of isomorphisms (or equivalences) in group theory.

For any group homomorphism `f` and subgroup `K` of groups `G` and `N`, `f(K) = (f^(-1))^(-1)(K)`.


Prefunctor.ext

theorem Prefunctor.ext :
    ∀ {V : Type u} [inst : Quiver V] {W : Type u₂} [inst_1 : Quiver W] {F G : V ⥤q W}
      (h_obj : ∀ (X : V), F.obj X = G.obj X),
      (∀ (X Y : V) (f : X ⟶ Y), F.map f = Eq.recOn ⋯ (Eq.recOn ⋯ (G.map f))) → F = G :=
  by sorry

The theorem `Prefunctor.ext` states that given two prefunctors `F` and `G` from a category `V` to a category `W`, if for every object `X` in `V` the objects `F.obj X` and `G.obj X` in `W` are equal, and for every morphism `f` from `X` to `Y` in `V`, the morphisms `F.map f` and `G.map f` in `W` are equal (up to an equality conversion specified by `Eq.recOn`), then the two prefunctors `F` and `G` are equal. This theorem provides a criterion for the equality of prefunctors in terms of their action on objects and morphisms.

Given two prefunctors F and G from category V to category W, if for all objects X in V, F.obj X = G.obj X, and for all morphisms f: X -> Y in V, F.map f = G.map f, then F = G.


theorem uniformEmbedding_iff :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] (f : α → β),
      UniformEmbedding f ↔ UniformInducing f ∧ Function.Injective f :=
  by sorry

The theorem `uniformEmbedding_iff` states that for all types `α` and `β` endowed with uniform spaces (denoted `[UniformSpace α]` and `[UniformSpace β]`), a function `f: α → β` is a uniform embedding if and only if it is both uniform inducing and injective. A function is uniform inducing if the topology on `α` induced by `f` is the same as the uniform space on `α`, and it is injective if for any two elements `a₁` and `a₂` in `α`, `f(a₁) = f(a₂)` implies that `a₁ = a₂`.

A function between uniform spaces is a uniform embedding if and only if it is both uniformly continuous and injective.


ContinuousLinearMap.uniformContinuous

theorem ContinuousLinearMap.uniformContinuous :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {E₁ : Type u_9}
      {E₂ : Type u_10} [inst_2 : UniformSpace E₁] [inst_3 : UniformSpace E₂] [inst_4 : AddCommGroup E₁]
      [inst_5 : AddCommGroup E₂] [inst_6 : Module R₁ E₁] [inst_7 : Module R₂ E₂] [inst_8 : UniformAddGroup E₁]
      [inst_9 : UniformAddGroup E₂] (f : E₁ →SL[σ₁₂] E₂), UniformContinuous ⇑f :=
  by sorry

The theorem `ContinuousLinearMap.uniformContinuous` asserts that for any two types `R₁` and `R₂` equipped with semiring structures, a homomorphism `σ₁₂` from `R₁` to `R₂`, two types `E₁` and `E₂` equipped with uniform space, additive group, and module structures, and given that `E₁` and `E₂` are uniform additive groups, any continuous linear map `f` from `E₁` to `E₂` with respect to the ring homomorphism `σ₁₂` is uniformly continuous. In simpler terms, this theorem states that any continuous linear map between two uniform additive groups is uniformly continuous, meaning that the map's output values remain close together when the input values are close together, regardless of where these input values are located within the input space.

Given uniform additive groups `E₁` and `E₂`, a continuous linear map `f` from `E₁` to `E₂` with respect to a ring homomorphism is uniformly continuous.


theorem Continuous.matrix_transpose :
    ∀ {X : Type u_1} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace R] {A : X → Matrix m n R}, Continuous A → Continuous fun x => Matrix.transpose (A x) :=
  by sorry

The theorem `Continuous.matrix_transpose` states that for any types `X`, `m`, `n`, and `R` where `X` is a topological space and `R` is a topological space, if `A` is a function from `X` to matrices of type `Matrix m n R` and `A` is continuous, then the function that applies `Matrix.transpose` to `A x` for each `x` in `X` is also continuous. In other words, if we have a continuous function that generates a matrix for each point in a topological space, then the function that generates the transpose of these matrices is also continuous.

If `A : X -> Matrix m n R` is a continuous function from a topological space `X` to matrices of type `Matrix m n R`, then the function `x => Matrix.transpose (A x)` is also continuous.


theorem PosNum.cmp_to_nat : ∀ (m n : PosNum), Ordering.casesOn (PosNum.cmp m n) (↑m < ↑n) (m = n) (↑n < ↑m) := by sorry

The theorem `PosNum.cmp_to_nat` is a statement about positive numbers (`PosNum`) in Lean 4. It says that for all positive numbers `m` and `n`, when we compare `m` and `n` using the `PosNum.cmp` function, the resulting ordering matches the natural number comparison (`<`, `=`, or `>`). Specifically, if `PosNum.cmp m n` results in `Ordering.lt`, then `m` as a natural number is less than `n` as a natural number (denoted by `↑m < ↑n`). If `PosNum.cmp m n` results in `Ordering.eq`, then `m` is equal to `n`. If `PosNum.cmp m n` results in `Ordering.gt`, then `n` as a natural number is less than `m` as a natural number (denoted by `↑n < ↑m`).

For all positive numbers `m` and `n`, `PosNum.cmp m n` orders `m` and `n` consistently with the natural number comparison, that is, `m < n` if and only if `PosNum.cmp m n` is `Ordering.lt`, `m = n` if and only if `PosNum.cmp m n` is `Ordering.eq`, and `n < m` if and only if `PosNum.cmp m n` is `Ordering.gt`.


/-- If `f : M → N` is a subadditive function, `f (x + y) ≤ f x + f y`, `f 0 = 0`, and `g i`,
`i ∈ s`, is a finite family of elements of `M`, then `f (∑ i in s, g i) ≤ ∑ i in s, f (g i)`.  -/
theorem Finset.le_sum_of_subadditive :
    ∀ {ι : Type u_1} {M : Type u_4} {N : Type u_5} [inst : AddCommMonoid M] [inst_1 : OrderedAddCommMonoid N]
      (f : M → N),
      f 0 = 0 →
        (∀ (x y : M), f (x + y) ≤ f x + f y) →
          ∀ (s : Finset ι) (g : ι → M), f (Finset.sum s fun i => g i) ≤ Finset.sum s fun i => f (g i) :=
  by sorry

The theorem `Finset.le_sum_of_subadditive` states that for any type `ι`, and any commutative monoids `M` and `N` (possibly ordered), given a function `f` from `M` to `N` which is subadditive (i.e., `f` satisfies the inequality `f (x + y) ≤ f x + f y` for all `x` and `y` in `M`) and maps the zero element of `M` to the zero element of `N`, then for any finite set `s` of type `ι` and any function `g` from `ι` to `M`, the function `f` applied to the sum of the elements of `s` mapped via `g` is less than or equal to the sum of `f` applied to each of the elements of `s` mapped via `g`. In mathematical notation, for a subadditive function `f` and any finite set `s` with elements `i`, we have `f (∑ i in s, g i) ≤ ∑ i in s, f (g i)`.

For any commutative monoid M and N, subadditive function f from M to N mapping the zero element to zero, and finite set s of type ι along with a function g from ι to M, we have f (∑ i in s, g i) ≤ ∑ i in s, f (g i).


theorem MeasureTheory.Measure.restrict_iUnion_le :
    ∀ {α : Type u_2} {ι : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      {s : ι → Set α}, μ.restrict (⋃ i, s i) ≤ MeasureTheory.Measure.sum fun i => μ.restrict (s i) :=
  by sorry

This theorem, `MeasureTheory.Measure.restrict_iUnion_le`, states that for any type `α`, index type `ι`, measurable space `m0` on `α`, and measure `μ` on `α`, given an indexed family of sets `s : ι → Set α`, the measure restricted to the union of these sets, `μ.restrict (⋃ i, s i)`, is less than or equal to the sum of the measures restricted to each individual set, `MeasureTheory.Measure.sum fun i => μ.restrict (s i)`. In other words, the measure of a union of sets is less than or equal to the sum of the measures of the individual sets. This is a formal statement of the concept of subadditivity in measure theory.

The measure of a union of measurable sets is less than or equal to the sum of the measures of the individual sets in a measurable space.


theorem Polynomial.taylor_one :
    ∀ {R : Type u_1} [inst : Semiring R] (r : R), (Polynomial.taylor r) 1 = Polynomial.C 1 := by sorry

This theorem states that for any semi-ring `R` and any element `r` from `R`, the Taylor expansion of the constant polynomial `1` at `r` is equal to the constant polynomial `1` itself. Here, `Polynomial.taylor r` represents the Taylor expansion at `r`, and `Polynomial.C 1` represents the constant polynomial `1`.

For any semi-ring `R` and element `r` from `R`, the Taylor expansion of the constant polynomial `1` at `x = r` equals the constant polynomial `1` itself.


theorem sup_right_idem : ∀ {α : Type u} [inst : SemilatticeSup α] (a b : α), a ⊔ b ⊔ b = a ⊔ b := by sorry

This theorem, named `sup_right_idem`, states that in any semilattice with a supremum operation (denoted as `⊔`), for all elements `a` and `b` of the semilattice, the supremum of `a` and `b` taken twice (`a ⊔ b ⊔ b`) is the same as the supremum of `a` and `b` (`a ⊔ b`). In simpler terms, this means in such a structure, taking the supremum of `a` and `b` and then taking the supremum of the result with `b` again doesn't change the result.

In a semilattice with supremum operation, the repeated application of the supremum operation to any two elements is idempotent. That is, for all `a` and `b` in the semilattice, `a ⊔ b ⊔ b = a ⊔ b`.


theorem AddMonoidHom.comp_apply :
    ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : AddZeroClass P] (g : N →+ P) (f : M →+ N) (x : M), (AddMonoidHom.comp g f) x = g (f x) :=
  by sorry

The theorem `AddMonoidHom.comp_apply` states that for any types `M`, `N`, and `P` that are instances of an additive monoid (i.e., they have a zero and an addition operation), given an additive monoid homomorphism `g` from `N` to `P` and another additive monoid homomorphism `f` from `M` to `N`, and for any element `x` in `M`, the composition of `g` and `f`, when applied to `x`, is the same as applying `g` to the result of `f` applied to `x`. In mathematical terms, this is saying that (g ∘ f)(x) = g(f(x)), which is the definition of function composition.

For any additive monoids M, N, and P, and additive monoid homomorphisms f : M -> N and g : N -> P, (g ∘ f)(x) = g(fx) for all x in M.


theorem Filter.le_seq :
    ∀ {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {h : Filter β},
      (∀ t ∈ f, ∀ u ∈ g, Set.seq t u ∈ h) → h ≤ Filter.seq f g :=
  by sorry

The theorem `Filter.le_seq` states that for any three filters `f`, `g`, and `h` over functions from type `α` to type `β`, type `α`, and type `β` respectively, if for every set `t` in the filter `f` and every set `u` in the filter `g`, the sequentiation of `t` and `u` (which is the union of the image of `t` by all functions in `u`) belongs to filter `h`, then filter `h` is a subset of the sequentiation of filters `f` and `g`. Here, subset is defined in the sense of filters, i.e., `h` is a subset of `f` if every set in `h` is also in `f`.

If for all sets $T \in f$ and $U \in g$, the sequentiation of $T$ and $U$ is contained in $h$, then $f$ and $g$ filter-contain $h$, i.e., every set in $h$ is also in the filter generated by $f$ and $g$.


theorem hasSum_fintype :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Fintype β]
      (f : β → α), HasSum f (Finset.sum Finset.univ fun b => f b) :=
  by sorry

The theorem `hasSum_fintype` states that for any given types `α` and `β`, where `α` is an additive commutative monoid and also a topological space, and `β` is a finite type, and any function `f` from `β` to `α`, the function `f` has a sum. This sum is computed by applying the function `f` to each element of the universal finite set of type `β` (`Finset.univ`), and then taking the sum of these results (using `Finset.sum`). In other words, we sum up the values of the function `f` over all elements of the finite type `β`.

For any additive commutative monoid and topological space type `α`, finite type `β`, and function `f` from `β` to `α`, there exists a sum `∑ i in Finset.univ (f i)` of `f` over the universal set of type `β`.


theorem CategoryTheory.Functor.additive_of_preservesBinaryBiproducts :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Limits.HasBinaryBiproducts C] [inst_5 : CategoryTheory.Functor.PreservesZeroMorphisms F]
      [inst_6 : CategoryTheory.Limits.PreservesBinaryBiproducts F], CategoryTheory.Functor.Additive F :=
  by sorry

This theorem states that for any two types `C` and `D` along with their categorical structures, where `C` is preadditive and has binary biproducts and `D` is preadditive, if a functor `F` from `C` to `D` preserves zero morphisms and binary biproducts, then `F` is additive.

In mathematical terms, this theorem is about the properties of functors between categories in category theory. It states that if we have a functor between two categories that preserves certain structures (zero morphisms and binary biproducts), then that functor has an additional property: it is additive. This is a significant property in category theory because additive functors preserve the additive structure of the categories they map between, allowing for the transfer of more structural information between categories.

Given preadditive categories `C` and `D` with binary biproducts, if functor `F` from `C` to `D` preserves zero morphisms and binary biproducts, then `F` is additive.


theorem Nat.testBit_succ : ∀ (x i : ℕ), Nat.testBit x (Nat.succ i) = Nat.testBit (x / 2) i := by sorry

The theorem `Nat.testBit_succ` states that for any two natural numbers `x` and `i`, the `(i+2)`-th least significant bit of `x` is the same as the `(i+1)`-th least significant bit of `x / 2`. In other words, when we move to the next least significant bit in `x`, it's equivalent to halving `x` and checking the same bit position as before.

The `(i+2)`-th least significant bit of a natural number `x` equals the `(i+1)`-th least significant bit of `x / 2`.


theorem MeasureTheory.AEEqFun.add_toGerm :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace γ] [inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ),
      MeasureTheory.AEEqFun.toGerm (f + g) = MeasureTheory.AEEqFun.toGerm f + MeasureTheory.AEEqFun.toGerm g :=
  by sorry

The theorem `MeasureTheory.AEEqFun.add_toGerm` establishes that for any two almost everywhere strongly measurable functions `f` and `g` from a type `α` to a type `γ` (where `α` has a measurable space structure, `γ` has an addition operation and topological structure, and addition operation is continuous), the germ at almost every point of the measure `μ` of the sum of `f` and `g` is equal to the sum of the germs of `f` and `g`. In other words, the operation of taking the germ commutes with the addition of functions.

For almost everywhere strongly measurable functions `f` and `g` from a measurable space `(α, Σ, μ)` to a topological additive group `(γ, +)`, the germs at almost every point of `μ` of `f + g` are equal to the sum of the germs of `f` and `g`.


theorem Complex.Gamma_ofReal : ∀ (s : ℝ), Complex.Gamma ↑s = ↑(Real.Gamma s) := by sorry

This theorem states that for every real number `s`, the complex Gamma function evaluated at `s` equals the real Gamma function at `s` casted to a complex number. In mathematical terms, it says that for all `s` in the set of real numbers, the equation Γ(s) = Γ(s) holds, where the left side Γ denotes the complex Gamma function and the right side Γ denotes the real Gamma function.

The complex Gamma function equals the real Gamma function for all real numbers.


theorem Finset.sum_mono_set :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : CanonicallyOrderedAddCommMonoid M] (f : ι → M),
      Monotone fun s => Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_mono_set` states that for any type `ι`, any type `M` that is a canonically ordered commutative monoid with an additive identity, and any function `f` from `ι` to `M`, the function that takes a finite set `s` of elements from `ι` and maps it to the sum of `f(x)` for all `x` in `s` is monotone. In other words, if `s` and `t` are two finite sets of elements from `ι` such that `s` is a subset of `t`, then the sum of `f(x)` over all `x` in `s` is less than or equal to the sum of `f(x)` over all `x` in `t`. This is due to the fact that adding more terms in the sum (when moving from `s` to `t`) cannot decrease the total sum, given that `M` is a canonically ordered commutative monoid (i.e., an algebraic structure where addition is commutative, associative, and has an identity, and where the order relation is compatible with the addition).

Given a type `ι`, a canonically ordered commutative monoid `M` with an additive identity, and a function `f` from `ι` to `M`, the sum function `s => ∑ x in s, f x` is monotone on finite sets `s` of `ι`.


/-- A function is partial recursive if and only if there is a code implementing it. Therefore,
`eval` is a **universal partial recursive function**.  -/
theorem Nat.Partrec.Code.exists_code : ∀ {f : ℕ →. ℕ}, Nat.Partrec f ↔ ∃ c, Nat.Partrec.Code.eval c = f := by sorry

This theorem states that a function is partially recursive if and only if there exists a code that implements it. In other words, for every function `f` from natural numbers to partial natural numbers, `f` is partially recursive if there is a code `c`, such that the evaluation of `c` equals `f`. This establishes `eval` as a universal partial recursive function.

A function `f` from natural numbers to partial natural numbers is partially recursive if and only if there exists a code `c` such that for all natural numbers `x`, `eval(c)(x) = f(x)`.


theorem WithBot.preimage_coe_Ici :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some ⁻¹' Set.Ici ↑a = Set.Ici a := by sorry

This theorem states that for any type `α` with a preorder structure and any element `a` of that type, the preimage of the half-closed interval starting at `a` under the canonical map from `α` into `WithBot α` is again the half-closed interval starting at `a`. In mathematical terms, if we consider `WithBot.some` as a function `f: α → WithBot α`, this theorem says that for any `a` in `α`, the set of elements in `α` that `f` maps into the set `{x | a ≤ x}` is exactly the set `{x | a ≤ x}`.

For any preordered type `α` and its element `a`, the preimage of the half-closed interval `{x | a ≤ x}` under the canonical map from `α` to `WithBot α` is equal to `{x | a ≤ x}`.


theorem Cardinal.lt_aleph0_iff_set_finite :
    ∀ {α : Type u} {S : Set α}, Cardinal.mk ↑S < Cardinal.aleph0 ↔ Set.Finite S := by sorry

This theorem is stating a relationship between the cardinality of a set and the notion of finiteness. More specifically, for any type `α` and a set `S` of this type, the cardinality of set `S` is strictly less than the smallest infinite cardinal (`ℵ₀` or `aleph0`) if and only if the set `S` is finite. In other words, it provides a condition to determine whether a set is finite: a set is finite if and only if its cardinality is less than the smallest infinite cardinal.

A set is finite if and only if its cardinality is strictly less than the smallest infinite cardinal.


theorem FirstOrder.Language.Term.realize_constants :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'}
      {c : FirstOrder.Language.Constants L} {v : α → M},
      FirstOrder.Language.Term.realize v (FirstOrder.Language.Constants.term c) = ↑c :=
  by sorry

The theorem `FirstOrder.Language.Term.realize_constants` states that for any first-order language `L`, an arbitrary type `M`, a structure of `L` on `M`, an arbitrary type `α`, a constant of `L`, and a function from `α` to `M`, the realization of the term representation of the constant (using the function from `α` to `M`) is equal to the original constant. In other words, it guarantees that interpreting or "realizing" a constant term in a first-order language gives back the constant itself.

For any first-order language L, type M, structure σ on M, constant c of L, and function g : α → M, the realization of the constant term for c using g is equal to c itself.


theorem Function.Periodic.sub_antiperiod_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c₁ c₂ : α} [inst : AddGroup α] [inst_1 : InvolutiveNeg β],
      Function.Periodic f c₁ → Function.Antiperiodic f c₂ → f (c₁ - c₂) = -f 0 :=
  by sorry

The theorem `Function.Periodic.sub_antiperiod_eq` states that for any types `α` and `β`, a function `f` from `α` to `β`, and any two elements `c₁` and `c₂` of `α`, given an additive group structure on `α` and a negation operation on `β` which is an involution, if `f` is periodic with period `c₁` and antiperiodic with antiperiod `c₂`, then the value of `f` at `c₁ - c₂` is the negation of the value of `f` at `0`. In other words, if a function is both periodic and antiperiodic with two different periods, then the function evaluated at the difference of these periods equals the negative of the function evaluated at zero.

If a function from one type to another is periodic with period c₁ and antiperiodic with antiperiod c₂, then it holds that f(c₁ - c₂) = -f(0).