theorem Equiv.Perm.IsCycle.of_pow :
    ∀ {α : Type u_2} {f : Equiv.Perm α} [inst : DecidableEq α] [inst_1 : Fintype α] {n : ℕ},
      Equiv.Perm.IsCycle (f ^ n) → Equiv.Perm.support f ⊆ Equiv.Perm.support (f ^ n) → Equiv.Perm.IsCycle f :=
  by sorry

This theorem states that for any type `α`, given a permutation `f` of `α`, a natural number `n`, and assuming that `α` has decidable equality and is a finite type, if the `n`-th power of `f` forms a cycle (`Equiv.Perm.IsCycle (f ^ n)`), and the set of non-fixed points of `f` is a subset of the set of non-fixed points of `f ^ n` (`Equiv.Perm.support f ⊆ Equiv.Perm.support (f ^ n)`), then `f` itself forms a cycle (`Equiv.Perm.IsCycle f`). In other words, if a permutation raised to a power forms a cycle and the non-fixed points of the original permutation are included in the non-fixed points of the powered permutation, then the original permutation is a cycle itself.

If a permutation `f` of a finite type `α` with decidable equality forms a cycle in the `n`-th power `(f ^ n)` and the non-fixed points of `f` are a subset of those of `(f ^ n)`, then `f` itself is a cycle.


theorem List.filter_eq :
    ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (a : α),
      List.filter (fun x => decide (x = a)) l = List.replicate (List.count a l) a :=
  by sorry

This theorem states that for any given list `l` of elements of type `α` (with decidable equality) and any given element `a` from the same type `α`, the list obtained by filtering `l` such that it only contains elements that are equal to `a`, is equivalent to a list that replicates `a` a number of times equal to the count of `a` in the original list `l`. In simpler terms, if you filter a list to only include instances of a certain element, the resulting list is the same as if you just replicated that element for the number of times it originally appeared in the list.

For any list `l` of decidably equal elements `α` and any `a` in `α`, the list obtained by filtering `l` equal to `a` is equal to the repeated list of length equal to the count of `a` in `l`.


theorem Mathlib.Analysis.Convex.Between._auxLemma.15 :
    ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] (x y : P), Wbtw R x x y = True :=
  by sorry

This theorem, `Mathlib.Analysis.Convex.Between._auxLemma.15`, states that for any ordered ring `R`, any additive commutative group `V`, any module `V` over `R`, and any torsor `P` for `V`, given two points `x` and `y` in `P`, `y` is weakly between `x` and `x` itself. In other words, the point `y` is located on the affine segment from `x` to `x`, which is the point `x` itself.

For any torsor `P` over an additive commutative group `V` in an ordered ring `R`, any two points `x` and `y` in `P` satisfy `y ≤ x ∨ x ≤ y`.


PartialEquiv.EqOnSource.symm'

/-- If two partial equivs are equivalent, so are their inverses.  -/
theorem PartialEquiv.EqOnSource.symm' :
    ∀ {α : Type u_1} {β : Type u_2} {e e' : PartialEquiv α β}, e ≈ e' → PartialEquiv.symm e ≈ PartialEquiv.symm e' := by
  sorry

This theorem states that if two partial equivalences (from a type α to a type β) are equivalent, their inverses (from type β back to α) are also equivalent. In other words, the equivalence of two partial equivalences is preserved under the operation of taking the inverse.

If two partial equivalences between types are equal, their inverses are also equal.


theorem List.pairwise_pwFilter :
    ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] (l : List α), List.Pairwise R (List.pwFilter R l) := by
  sorry

The theorem `List.pairwise_pwFilter` states that for any type `α`, any binary relation `R` on `α` that is decidable, and any list `l` of elements of type `α`, the list obtained by applying the `pwFilter` operation with the relation `R` to the list `l` is a pairwise `R`-related list. In other words, for every pair of distinct elements in the filtered list, the relation `R` holds between those elements.

Let `α` be a type, `R` be a decidable binary relation on `α`, and `l` be a list of `α`. The `pwFilter l R` is a sublist of `l` such that for all distinct `x` and `y` in `pwFilter l R`, `x R y` holds.


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

This theorem states that for all natural numbers `m`, `n`, and `k`, the greatest common divisor (GCD) of `m` and `n` added to `m` times `k` (`n + m * k`) is equal to the GCD of `m` and `n`. In mathematical notation, it states that $\gcd(m, n+mk) = \gcd(m, n)$ for all natural numbers $m, n, k$. This property reflects the distributive nature of the GCD operation over addition and multiplication.

The greatest common divisor of two numbers is unchanged when one number is replaced with another number that is the first number multiplied by a third number and added to the second number. In mathematical notation, $\gcd(m, n) = \gcd(m, n + mk)$ for all natural numbers $m, n, k$.


/-- A linear isometry preserves the inner product.  -/
theorem LinearIsometry.inner_map_map :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {E' : Type u_7} [inst_3 : NormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] (f : E →ₗᵢ[𝕜] E') (x y : E),
      ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜 :=
  by sorry

This theorem states that a linear isometry preserves the inner product. More specifically, for any scalar field `𝕜` and two inner product spaces `E` and `E'` over `𝕜`, if `f` is a linear isometry mapping from `E` to `E'`, then the inner product of `f(x)` and `f(y)` in `E'` is equal to the inner product of `x` and `y` in `E`, where `x` and `y` are any elements of `E`. This theorem is fundamental in the field of linear algebra and is critical to understanding the properties of linear transformations in inner product spaces.

Given any linear isometry `f` between inner product spaces `E` and `E'` over scalar field `𝕜`, the inner product `⟨f(x), f(y)⟩′` in `E'` equals `⟨x, y⟩` in `E` for any `x, y` in `E`.


theorem Module.rank_def :
    ∀ (R : Type u_1) (M : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Module.rank R M = ⨆ ι, Cardinal.mk ↑↑ι :=
  by sorry

The `Module.rank_def` theorem states that for any Type 'R', Type 'M', where 'R' is a semiring, 'M' is an additive commutative monoid, and 'M' is a module over 'R', the rank of the module 'M' over the ring 'R' is equal to the supremum over all cardinal numbers 'ι'. In other words, the rank of a module over a ring is determined by the highest cardinal number of its basis.

The rank of a module over a semiring is equal to the size of its largest basis.


theorem Function.Surjective.of_comp_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α},
      Function.Surjective g → (Function.Surjective (f ∘ g) ↔ Function.Surjective f) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, given a function `f` from `α` to `β` and a function `g` from `γ` to `α`, if `g` is surjective (i.e., for every element of `α` there exists an element of `γ` such that `g` of that element equals the element of `α`), then `f` composition `g` (denoted by `f ∘ g`) is surjective if and only if `f` is surjective. In mathematical terms, this would mean that for all `b` in `β`, there exists an `a` in `α` such that `f(a) = b` if and only if for all `b` in `β`, there exists a `c` in `γ` such that `(f ∘ g)(c) = b`.

For functions `f: α -> β` and `g: γ -> α`, if `g` is surjective and `f` is surjective then `f ∘ g` is surjective.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.29 :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      SimpleGraph.Walk.IsTrail p = List.Nodup (SimpleGraph.Walk.edges p) :=
  by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.29`, states that for any given simple graph `G` with vertex type `V`, and any two vertices `u` and `v` in this graph, a walk `p` from `u` to `v` is a trail if and only if the list of edges visited by this walk, `SimpleGraph.Walk.edges p`, has no duplicates (`List.Nodup`).

In more detail, a "trail" in graph theory is a walk that does not repeat any edges. Here, the theorem is relating this concept to the function `List.Nodup`, which checks if a list has no repeated elements. Thus, the theorem's statement can be summarized as "in a simple graph, a walk is a trail if the list of its visited edges has no duplications."

A walk in a simple graph is a trail if and only if the list of its edges contains no duplicates.


theorem AdjoinRoot.induction_on :
    ∀ {R : Type u} [inst : CommRing R] (f : Polynomial R) {C : AdjoinRoot f → Prop} (x : AdjoinRoot f),
      (∀ (p : Polynomial R), C ((AdjoinRoot.mk f) p)) → C x :=
  by sorry

This theorem, `AdjoinRoot.induction_on`, establishes an induction principle for elements in the ring adjoined by a root of a polynomial `f`. The theorem states that for any type `R` with a commutative ring structure, any polynomial `f` of type `Polynomial R`, any property `C` of elements in the ring `AdjoinRoot f`, and any element `x` of `AdjoinRoot f`, if the property `C` holds for all elements in the ring `AdjoinRoot f` that are images under the ring homomorphism `AdjoinRoot.mk` of polynomials in `R`, then the property `C` also holds for the element `x`. Essentially, this allows us to prove properties about elements in the adjoined ring by proving them for elements in the original ring.

Given a commutative ring `R`, a polynomial `f` over `R`, and a property `C` of elements in the ring `AdjoinRoot f`, if `C` holds for all images of polynomials in `R` under the ring homomorphism `AdjoinRoot.mk`, then `C` holds for all elements in `AdjoinRoot f`.


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

This theorem states that the sum of a set of finite extended nonnegative real numbers is also finite. More precisely, for any type `α`, any finite set `s` of `α`, and any function `f` from `α` to extended nonnegative real numbers, the sum of the function `f` applied to each element of `s` is less than infinity if and only if each element `a` in `s` returns a finite value when applied to the function `f`.

For any type `α`, a finite set `s` of `α`, and a function `f` from `α` to extended nonnegative real numbers, the sum of `f` over `s` is finite if and only if all elements in `s` have finite values under `f`.


/-- The distance to a set is controlled by the Hausdorff distance.  -/
theorem EMetric.infEdist_le_hausdorffEdist_of_mem :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α},
      x ∈ s → EMetric.infEdist x t ≤ EMetric.hausdorffEdist s t :=
  by sorry

This theorem, titled "The distance to a set is controlled by the Hausdorff distance", states that for any type `α` that is a pseudo extended metric space, given any two sets `s` and `t` of type `α` and an element `x` of type `α` that belongs to set `s`, the minimal extended distance from `x` to set `t` is less than or equal to the Hausdorff extended distance between the two sets `s` and `t`. In other words, the least distance from a point to a set of elements in a pseudo extended metric space is always bounded above by the Hausdorff distance between the set containing the point and the other set.

For any pseudo extended metric space `α`, and sets `s` and `t` in `α` with `x` in `s`, the minimal extended distance from `x` to `t` is bounded above by the Hausdorff extended distance between `s` and `t`.


theorem ClosureOperator.IsClosed.closure_le_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] {c : ClosureOperator α} {x y : α}, c.IsClosed y → (c x ≤ y ↔ x ≤ y) := by
  sorry

This theorem states that for any type `α` equipped with a partial order, and for any closure operator `c` on `α`, if `y` is a closed element with respect to `c`, then `c x` is less than or equal to `y` if and only if `x` is less than or equal to `y`. This essentially means that the closure operation doesn't alter the order relation for any `x` when compared with a closed element `y`.

For any type `α` with a partial order and closure operator `c`, if `y` is a closed element and `x` is less than or equal to `y`, then `c x` is less than or equal to `y`. Conversely, if `c x` is less than or equal to `y`, then `x` is less than or equal to `y`.


theorem ClosureOperator.closure_sup_closure_left :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) := by sorry

This theorem states that for any type `α` with a sup-semilattice structure and any closure operator `c` on `α`, the closure of the sup of the closure of `x` and `y` is equal to the closure of the sup of `x` and `y`. In mathematical notation, this can be expressed as `c(c(x) ⊔ y) = c(x ⊔ y)`. This is about the idempotent nature of the closure operator and the compatibility with the `sup` operation in the semilattice.

In a more mathematical context, `α` can be any set equipped with a binary operation `sup` (also known as join) that is associative, commutative, and idempotent. A closure operator on `α` is a function `c: α -> α` that is extensive (`x ≤ c(x)`), increasing (`x ≤ y` then `c(x) ≤ c(y)`) and idempotent (`c(c(x)) = c(x)`).

For any sup-semilattice `α` and closure operator `c` on `α`, `c(x ⊔ y) = c(x) ⊔ y = c(x ⊔ c(y))`, where `⊔` denotes the sup operation.


theorem IsOpen.inter_closure :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], IsOpen s → s ∩ closure t ⊆ closure (s ∩ t) := by sorry

The theorem `IsOpen.inter_closure` states that for any type `X`, given two sets `s` and `t` of `X` in a topological space, if `s` is an open set, then the intersection of `s` and the closure of `t` is a subset of the closure of the intersection of `s` and `t`. Here, the closure of a set is the smallest closed set that contains it. It essentially says that the intersection of an open set with a closure of another set is contained within the closure of the intersection of those two sets.

For any topological space `X` and open set `s` in `X`, and sets `t` and `cl(t)` in `X` where `cl(t)` is the closure of `t`, we have `s ∩ cl(t) ⊆ cl(s ∩ t)`.


theorem Int.add_neg_cancel_left : ∀ (a b : ℤ), a + (-a + b) = b := by sorry

This theorem states that for any two integers `a` and `b`, if you add `a` to the sum of `-a` and `b`, you will get `b`. In more formal mathematical terms, this is expressing the property that adding the additive inverse of a number to that number results in zero, which when added to any other number, leaves that number unchanged. Thus, `a + (-a + b) = b` for all integers `a` and `b`.

For all integers `a` and `b`, `a + (-a + b) = b`.


theorem MvPolynomial.degreeOf_eq_sup :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (n : σ) (f : MvPolynomial σ R),
      MvPolynomial.degreeOf n f = Finset.sup (MvPolynomial.support f) fun m => m n :=
  by sorry

The theorem `MvPolynomial.degreeOf_eq_sup` states that for any commutative semiring `R`, any type `σ`, any instance of that semiring, any element `n` of type `σ`, and any multivariate polynomial `f` with coefficients in `R` and variables indexed by `σ`, the highest power of the variable indexed by `n` that appears in the polynomial `f` (`MvPolynomial.degreeOf n f`) is equal to the supremum (maximum) value obtained by applying a function to each element of the finite set of all `m : σ →₀ ℕ` (a map from `σ` to `ℕ` where only finitely many `σ` are non-zero) such that `X^m` has a non-zero coefficient in the polynomial `f` (`MvPolynomial.support f`), where the function takes such an `m` to its `n`-th component. In other words, the maximum degree of a particular variable `n` in a multivariate polynomial `f` is achieved at the monomial in `f` where the power of `n` is the highest.

For any commutative semiring R, multivariate polynomial f with coefficients in R, and variable n of type σ, the degree of n in f is equal to the maximum value of the component m(n) of maps m: σ →₀ ℕ such that X^m is a non-zero term in f.


/-- `SimpleFunc.lintegral` is monotone both in function and in measure.  -/
theorem MeasureTheory.SimpleFunc.lintegral_mono :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {f g : MeasureTheory.SimpleFunc α ENNReal},
      f ≤ g → μ ≤ ν → MeasureTheory.SimpleFunc.lintegral f μ ≤ MeasureTheory.SimpleFunc.lintegral g ν :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.lintegral_mono` states that the integral of a simple function, whose codomain is the set of extended nonnegative real numbers, is monotone with respect to both the function and the measure. Specifically, for any measurable space `α` and any two measures `μ` and `ν` on `α`, if one simple function `f` is less than or equal to another simple function `g` and if the measure `μ` is less than or equal to measure `ν`, then the integral of the function `f` with respect to measure `μ` is less than or equal to the integral of the function `g` with respect to measure `ν`.

If simple functions `f` and `g` are measurable, `α` is a measurable space, and measures `μ` and `ν` satisfy `μ ≤ ν`, then for all `x ∈ ℝ↑`, `∫(f dμ) ≤ ∫(g dν)`.


theorem Mathlib.Deprecated.Subgroup._auxLemma.1 :
    ∀ {G : Type u_1} [inst : Group G] {g : G}, (g ∈ IsSubgroup.trivial G) = (g = 1) := by sorry

The theorem states that for any group `G` and any element `g` in `G`, `g` belongs to the trivial subgroup of `G` if and only if `g` is equal to the identity element of `G`. The trivial subgroup of a group is the subgroup consisting only of the identity element.

For any group G and its identity element e, g belongs to the trivial subgroup of G if and only if g = e.


theorem Mathlib.Deprecated.Subgroup._auxLemma.2 :
    ∀ {G : Type u_1} [inst : AddGroup G] {g : G}, (g ∈ IsAddSubgroup.trivial G) = (g = 0) := by sorry

This theorem states that for any type `G` that has an additive group structure, an element `g` of `G` belongs to the trivial additive subgroup of `G` if and only if that element `g` is equal to the additive identity element `0`. The trivial additive subgroup is defined as the set containing only the additive identity element `0`.

For any additive group `G`, an element `g` lies in the trivial subgroup if and only if `g = 0`.


theorem Algebra.adjoin_range_eq_range_aeval :
    ∀ (R : Type u) {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      [inst_2 : Algebra R S₁] (f : σ → S₁), Algebra.adjoin R (Set.range f) = AlgHom.range (MvPolynomial.aeval f) :=
  by sorry

This theorem states that for all commutative semirings `R` and `S₁`, and a function `f` from an arbitrary type `σ` to `S₁`, the minimal subalgebra of `S₁` that includes the range of `f` (i.e., `Algebra.adjoin R (Set.range f)`) is equal to the range of the algebra homomorphism obtained by evaluating a multivariate polynomial at `f` (i.e., `AlgHom.range (MvPolynomial.aeval f)`). In simpler terms, it says that the smallest subalgebra containing the image of `f` under `R` is the same as the image of the multivariate polynomial evaluation mapping.

The smallest subalgebra of a commutative semiring `S₁` that includes the range of a function `f` from an arbitrary type to `S₁` is equal to the range of the multivariate polynomial evaluation homomorphism `MvPolynomial.aeval f` on `R`.


ContMDiff.contDiff

/-- **Alias** of the forward direction of `contMDiff_iff_contDiff`. -/
theorem ContMDiff.contDiff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {n : ℕ∞}
      {f : E → E'}, ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') n f → ContDiff 𝕜 n f :=
  by sorry

This theorem is an alias for the forward direction of `contMDiff_iff_contDiff`. It states that for any non-trivially normed field `𝕜`, normed add commutative groups `E` and `E'` which are also normed spaces over `𝕜`, and a function `f` from `E` to `E'`, if `f` is continuously differentiable with respect to the model with corners (or vector spaces) `E` and `E'` for any natural number `n`, then `f` is continuously differentiable in the standard sense for the same number `n`. In other words, if a function is smooth in the context of geometric structures, it is also smooth in the common sense.

If a function between two normed spaces is continuously differentiable with respect to the model with corners, then it is continuously differentiable in the standard sense.


theorem map_div' :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : DivInvMonoid G]
      [inst_2 : DivInvMonoid H] [inst_3 : MonoidHomClass F G H] (f : F),
      (∀ (a : G), f a⁻¹ = (f a)⁻¹) → ∀ (a b : G), f (a / b) = f a / f b :=
  by sorry

This theorem, `map_div'`, states that for any types `G`, `H`, and `F`, given `G` and `H` are `DivInvMonoid`s (division and inversion monoids), `F` is a function-like structure from `G` to `H`, and `F` is also a `MonoidHomClass` (a class of homomorphisms between two monoids), then for any function `f` of type `F`, if `f` preserves the inversion operation (i.e., for every element `a` in `G`, applying `f` to the inverse of `a` yields the inverse of `f(a)`), then `f` also preserves the division operation. That is, for every pair of elements `a` and `b` in `G`, applying `f` to the result of dividing `a` by `b` yields the same result as dividing `f(a)` by `f(b)`. This is a property of homomorphisms between structures with division and inversion operations.

If `F` is a homomorphism between `DivInvMonoid`s `G` and `H` that preserves inversions, then `F(a / b) = F(a) / F(b)` for all `a, b` in `G`.


theorem Finset.map_subset_map :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s₁ s₂ : Finset α}, Finset.map f s₁ ⊆ Finset.map f s₂ ↔ s₁ ⊆ s₂ := by
  sorry

This theorem states that for any types `α` and `β`, and an embedding `f` from `α` to `β`, if `s₁` and `s₂` are two finsets in `α`, then the image of `s₁` under the map `f` is a subset of the image of `s₂` under the map `f` if and only if `s₁` is a subset of `s₂`. In simpler terms, this theorem ensures that the subset relation between two finsets is preserved when they are mapped to another type under an embedding.

For any types `α`, `β`, andembedding `f` from `α` to `β`, if `s₁` and `s₂` are finsets in `α`, then `f(s₁) ⊆ f(s₂)` if and only if `s₁ ⊆ s₂`.


/-- The injection of `X` in the optimal coupling between `X` and `Y` is an isometry.  -/
theorem GromovHausdorff.isometry_optimalGHInjl :
    ∀ (X : Type u) (Y : Type v) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
      [inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y],
      Isometry (GromovHausdorff.optimalGHInjl X Y) :=
  by sorry

The theorem `GromovHausdorff.isometry_optimalGHInjl` asserts that for any types `X` and `Y` endowed with a metric space structure, along with the properties of being compact and nonempty, the injection of `X` into the optimal Gromov-Hausdorff coupling of `X` and `Y` is an isometry. In other words, this mapping preserves the edistance (a generalization of the concept of distance) between any two points in `X`. This is a critical property in the context of Gromov-Hausdorff theory, which deals with comparing different metric spaces.

The injection from a compact and nonempty metric space X into the optimal Gromov-Hausdorff distance between X and Y is an isometry.


Antitone.dual

/-- **Alias** of the reverse direction of `antitone_dual_iff`. -/
theorem Antitone.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f → Antitone (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `Antitone.dual` states that for any types `α` and `β` that are both preordered, and for any function `f` from `α` to `β` that is antitone (i.e., the function is decreasing in the sense that if `a` is less than or equal to `b` then `f(b)` is less than or equal to `f(a)`), the function obtained by first applying the function `f`, then applying the identity function `toDual` on the order dual of `α`, and finally applying the identity function `ofDual` on the order dual of `β`, is also antitone. In other words, if a function is decreasing in a certain order, it remains decreasing even if we consider the dual order.

If `f: α → β` is an antitone function between preordered types `α` and `β`, then the function `ofDual ∘ f ∘ toDual: β^dual → α^dual` is also antitone.


theorem Polynomial.splits_comp_of_splits :
    ∀ {R : Type u_1} {K : Type v} {L : Type w} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Field L] (i : R →+* K)
      (j : K →+* L) {f : Polynomial R}, Polynomial.Splits i f → Polynomial.Splits (RingHom.comp j i) f :=
  by sorry

The theorem `Polynomial.splits_comp_of_splits` states that for any given types `R`, `K`, and `L`, with `R` being a commutative ring and `K` and `L` being fields, if a polynomial `f` from the ring `R` splits over the field `K` under a ring homomorphism `i`, then it also splits over the field `L` under the composition of ring homomorphisms `j` and `i`. In simpler terms, if a polynomial splits over one field, it will also split over another when we apply a composition of functions that map elements between the fields and the original ring.

If a polynomial over a commutative ring splits over a field under a ring homomorphism, then it splits over another field under the composition of ring homomorphisms.


theorem MeasureTheory.integral_def :
    ∀ {α : Type u_6} {G : Type u_7} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {x : MeasurableSpace α}
      (μ : MeasureTheory.Measure α) (f : α → G),
      MeasureTheory.integral μ f =
        if x_1 : CompleteSpace G then
          if hf : MeasureTheory.Integrable f μ then MeasureTheory.L1.integral (MeasureTheory.Integrable.toL1 f hf)
          else 0
        else 0 :=
  by sorry

This theorem is about the definition of the Bochner integral in measure theory. If `G` is a complete space, and the function `f` from `α` to `G` is integrable with respect to measure `μ`, then the Bochner integral of `f` with respect to `μ` is the integral in the L1 space of the equivalence class of `f`. In other words, it's the integral of the function as it is represented in the L1 space (which is a space of equivalence classes of integrable functions). If `G` is not a complete space, or if `f` is not integrable, then the Bochner integral of `f` is defined to be zero.

If `G` is a complete space and `f` is an integrable function from `α` to `G` with respect to measure `μ`, then the Bochner integral of `f` is the integral of its equivalence class in the L1 space. Otherwise, it is zero.


theorem Multiset.Nodup.map_on :
    ∀ {α : Type u_1} {β : Type u_2} {s : Multiset α} {f : α → β},
      (∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) → Multiset.Nodup s → Multiset.Nodup (Multiset.map f s) :=
  by sorry

The theorem `Multiset.Nodup.map_on` states that for any type `α` and `β`, a multiset `s` of type `α`, and a function `f` from `α` to `β`, if for all elements `x` and `y` in the multiset `s`, `f(x)` equals `f(y)` implies `x` equals `y`, then if the multiset `s` has no duplicates (`Multiset.Nodup s`), the multiset resulting from mapping `f` over `s` (`Multiset.map f s`) also has no duplicates. In other words, if a function gives distinct outputs for distinct inputs and is applied to a duplicate-free multiset, the resulting multiset will also be free from duplicates.

If `f` is a function such that `x ≠ y` implies `f(x) ≠ f(y)` and `s` is a multiset with no duplicates, then `Multiset.map f s` is also a multiset with no duplicates.


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

This theorem states that for any two types `X` and `Y` with respective topological spaces, and any elements `x` from `X` and `y` from `Y`, and any sets `s` of `X` and `t` of `Y`, the neighborhood within filter of the pair `(x, y)` in the product set `s ×ˢ t` is equal to the product of the neighborhood within filter of `x` in `s` and the neighborhood within filter of `y` in `t`. In more mathematical terms, it states that the operation of taking neighborhood within filters distributes over Cartesian product of sets in topological spaces.

The neighborhood filters of elements in topological spaces distribute over the Cartesian product, that is, the neighborhood filter of a pair in the product of two sets is equal to the product of the neighborhood filters of the elements in the pair.


/-- In the characteristic zero case, the weights in the centroid sum
to 1 if the set is nonempty.  -/
theorem Finset.sum_centroidWeights_eq_one_of_nonempty :
    ∀ (k : Type u_1) [inst : DivisionRing k] {ι : Type u_4} (s : Finset ι) [inst_1 : CharZero k],
      s.Nonempty → (Finset.sum s fun i => Finset.centroidWeights k s i) = 1 :=
  by sorry

The theorem `Finset.sum_centroidWeights_eq_one_of_nonempty` states that for any division ring `k` of characteristic zero and any nonempty finite set `s`, the sum of the centroid weights for the elements in `s` is equal to one. These centroid weights are defined as the reciprocal of the size of the set. This theorem is specifically for the case where the ring has characteristic zero, which means that it has no nonzero element `n` such that `n*n = 0`.

For any division ring of characteristic zero and a nonempty finite set, the sum of the reciprocals of the set's sizes equals one.


theorem UniformSpace.comap_comap :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ},
      UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ) :=
  by sorry

The theorem `UniformSpace.comap_comap` states that for any types `α`, `β`, and `γ`, and any uniform space `uγ` on `γ`, and any functions `f : α → β` and `g : β → γ`, the composition of the comap operation is commutative, i.e., taking the inverse image of the uniformity `uγ` under the composed function `(g ∘ f)` is the same as first taking the inverse image under `g` and then under `f`. In other words, it asserts that the operation of taking "comap" (the inverse image function) over uniform spaces respects composition of functions.
The analogy in mathematical terms is that the inverse image operation on uniform spaces is functorial: $(g \circ f)^{-1}(u_\gamma) = f^{-1}(g^{-1}(u_\gamma))$.

For any functions `f : α → β` and `g : β → γ`, and uniform spaces `uγ` on `γ`, the inverse image of `uγ` under the composition `g ∘ f` is equal to the composition of the inverse images `f^(-1)(g^(-1)(uγ))`.


theorem pullbackTopology_def :
    ∀ {B : Type u_1} (F : Type u_2) (E : B → Type u_3) {B' : Type u_4} (f : B' → B) [inst : TopologicalSpace B']
      [inst_1 : TopologicalSpace (Bundle.TotalSpace F E)],
      pullbackTopology F E f =
        TopologicalSpace.induced Bundle.TotalSpace.proj inst ⊓
          TopologicalSpace.induced (Bundle.Pullback.lift f) inst_1 :=
  by sorry

This theorem states that for any types `B`, `F`, `E`, `B'`, a function `f` from `B'` to `B`, and provided `B'` and the total space of the bundle `F E` are equipped with their respective topological spaces, the pullback topology of `F E` along `f` is equivalent to the infimum (greatest lower bound) of the topologies induced by the projection from the total space of the bundle `F E` to `B`, and the lift of the base map `f` to the total spaces. In other words, the pullback topology is the coarsest topology that makes both the projection and the lift continuous.

The pullback topology of a continuous bundle map and a continuous function from the base space to the fiber space is the coarsest topology on the fiber space making both the bundle projection and the lifted function continuous.


theorem Rat.uniformEmbedding_coe_real : UniformEmbedding Rat.cast := by sorry

The theorem `Rat.uniformEmbedding_coe_real` states that the function `Rat.cast`, which serves as the canonical homomorphism from the rational numbers (`Rat`) to a division ring `K`, is a uniform embedding. In other words, the mapping from the set of rational numbers to the division ring `K` preserves the uniform structure. This means that nearness of points in the domain (the set of rational numbers) is properly reflected in the nearness of their images in the codomain (the division ring `K`).

The `Rat.cast` function from `Rat` to a division ring `K` is a uniform embedding, preserving the uniform structure and ensuring nearness of rational numbers is reflected by nearness of their images in `K`.


theorem Set.nonempty_def : ∀ {α : Type u} {s : Set α}, Set.Nonempty s ↔ ∃ x, x ∈ s := by sorry

The theorem `Set.nonempty_def` expresses the equivalence between the property `Set.Nonempty` of a set `s` of type `α` and the existence of an element in `s`. More specifically, it states that a set `s` is nonempty (`Set.Nonempty s`) if and only if there exists an element `x` such that `x` belongs to `s` (notated as `∃ x, x ∈ s`). This theorem serves to precisely define what it means for a set to be nonempty within the logic of Lean 4.

A set is nonempty if and only if it contains an element.


Ordnode.Sized.dual

theorem Ordnode.Sized.dual : ∀ {α : Type u_1} {t : Ordnode α}, Ordnode.Sized t → Ordnode.Sized (Ordnode.dual t) := by
  sorry

The theorem `Ordnode.Sized.dual` states that for any type `α` and any ordered node `t` of that type, if the ordered node `t` satisfies the `Sized` property (meaning that all the `size` fields in its nodes match the actual size of the respective subtrees), then the dual of the ordered node `t` also satisfies the `Sized` property. In other words, the `Sized` property is preserved when taking the dual of an ordered node.

If `α` is a type and `t` is an ordered node of type `α` with the `Sized` property, then the dual of `t` also has the `Sized` property.


theorem Finsupp.single_left_inj :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a a' : α} {b : M},
      b ≠ 0 → (((fun₀ | a => b) = fun₀ | a' => b) ↔ a = a') :=
  by sorry

This theorem, `Finsupp.single_left_inj`, states that for any types `α` and `M`, given a zero instance for `M` and given any `a`, `a'` from `α` and `b` from `M` where `b` is not equal to zero, the function `fun₀ | a => b` equals to `fun₀ | a' => b` if and only if `a` equals to `a'`. The function `fun₀ | a => b` here can be interpreted as a function that gives `b` when supplied `a` and gives zero otherwise. The theorem essentially tells us that such a function is injective: two different inputs `a` and `a'` will give the same output (i.e., `b`) only if `a` and `a'` are actually the same.

The function `fun₀ | a => b` is a bijection from `α` to `{x : α | x ≠ a}`, whenever `b ≠ 0`.


/-- `G` is cover-preserving wrt the induced topology.  -/
theorem CategoryTheory.LocallyCoverDense.inducedTopology_coverPreserving :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D}
      {K : CategoryTheory.GrothendieckTopology D} [inst_2 : CategoryTheory.Full G] [inst_3 : CategoryTheory.Faithful G]
      (Hld : CategoryTheory.LocallyCoverDense K G),
      CategoryTheory.CoverPreserving (CategoryTheory.LocallyCoverDense.inducedTopology Hld) K G :=
  by sorry

This theorem states that given a Category `C` and a Category `D`, along with a functor `G` from `C` to `D` and a Grothendieck topology `K` on `D`, if `G` is locally cover-dense with respect to `K`, then `G` preserves the cover in the topology induced by `G` on `C` and the Grothendieck topology `K` on `D`. This is true under the assumption that `G` is a fully faithful functor, i.e., it reflects and preserves all morphisms in the categories.

Given a fully faithful functor `G` from category `C` to category `D`, if `G` is locally cover-dense with respect to a Grothendieck topology `K` on `D`, then `G` preserves covers in both `C` and the topology `G^(-1)(K)` on `C`.


theorem iSup_eq_bot :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {s : ι → α}, iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥ := by sorry

This theorem, `iSup_eq_bot`, states that for any type `α` that forms a complete lattice, and any function `s` from some type `ι` to `α`, the supremum of the function `s` (denoted by `iSup s`) equals the bottom element of the lattice (denoted by `⊥`) if and only if every element `i` of type `ι` maps to the bottom of the lattice under the function `s` (i.e., `s i = ⊥` for all `i`). In other words, the supremum of the range of `s` is the smallest element of the lattice if and only if all values in the range of `s` are the smallest element of the lattice.

For any complete lattice `α` and function `s` from a type `ι` to `α`, `iSup s = ⊥` if and only if `s i = ⊥` for all `i ∈ ι`. (The supremum of a function `s` equals the bottom element of the lattice if and only if all images under `s` are the bottom element.)


theorem zpow_bit0 : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℤ), a ^ bit0 n = a ^ n * a ^ n := by sorry

The theorem `zpow_bit0` states that for any type `α` that has a division monoid structure (meaning multiplication and division operations are defined), and for any element `a` of type `α` and any integer `n`, the expression `a` raised to the power of `bit0 n` (which is defined as `n + n`) equals the product of `a` raised to the power of `n` and `a` raised to the power of `n`. In mathematical terms, this can be written as: for every element `a` in a division monoid and every integer `n`, we have \(a^{2n} = a^n \cdot a^n\).

For any division monoid element `a` and integer `n`, the power `a^(2n)` equals the product of powers `a^(n) * a^(n)`.


theorem Mathlib.GroupTheory.Perm.Cycle.Concrete._auxLemma.13 :
    ∀ {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) := by sorry

This theorem, from the Mathlib library's group theory section, states that for any type `α`, any predicate `p` on `α`, and any two elements `a1` and `2` of the subtype `{ x // p x }` (i.e., the type of elements `x` satisfying `p`), `a1` and `a2` are equal if and only if their underlying elements in `α` are equal. In other words, two elements of a subtype are equal as elements of that subtype if and only if they are equal when considered as elements of the original type.

For any type `α` and predicate `p` on `α`, elements `a1` and `a2` of the subtype `{ x // p x }` are equal if and only if their underlying elements in `α` are equal.


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

The theorem `MeasureTheory.AEEqFun.mul_toGerm` states that for any measurable space `α`, any type `γ` with a topological structure and a continuous multiplication operation, and any measure `μ` on `α`, given two almost everywhere-equal functions `f` and `g` from `α` to `γ` (denoted as `f, g : α →ₘ[μ] γ`), the germ (i.e., equivalence class under the relation of equality almost everywhere) of the product function `(f * g)` is equal to the product of the germs of `f` and `g`.

In other words, this theorem is about the compatibility of the operation of multiplication with the operation of taking germs for almost everywhere-equal functions. It says that multiplying the functions first and then taking the germ gives the same result as first taking the germs and then multiplying them.

For measurable functions `f` and `g` almost everywhere equal on the measurable space `(α, Σ, μ)`, their product function `f * g` has the same germ (equivalence class under equality almost everywhere) as the pointwise product of their germs.


theorem or_congr_left : ∀ {a b c : Prop}, (a ↔ b) → (a ∨ c ↔ b ∨ c) := by sorry

This theorem, `or_congr_left`, states that for any three propositions `a`, `b`, and `c`, if `a` is equivalent to `b` (denoted as `a ↔ b`), then the disjunction of `a` and `c` is equivalent to the disjunction of `b` and `c` (denoted as `a ∨ c ↔ b ∨ c`). In other words, if two propositions are equivalent, we can replace one with the other in a disjunction without changing the truth value of the disjunction.


theorem Nat.sqrt_add_eq : ∀ (n : ℕ) {a : ℕ}, a ≤ n + n → Nat.sqrt (n * n + a) = n := by sorry

This theorem states that for any natural number `n` and for any other natural number `a` such that `a` is less than or equal to twice `n`, the square root (calculated using the `Nat.sqrt` function) of the sum of the square of `n` and `a` is equal to `n`. In mathematical notation, this is stating that for all $n, a \in \mathbb{N}$ such that $a \leq 2n$, we have $\sqrt{n^2 + a} = n$.

For any natural numbers $n$ and $a$ with $a \leq 2n$, we have $\sqrt{n^2 + a} = n$.


theorem Submodule.map_comap_subtype :
    ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p p' : Submodule R M), Submodule.map (Submodule.subtype p) (Submodule.comap (Submodule.subtype p) p') = p ⊓ p' :=
  by sorry

The theorem `Submodule.map_comap_subtype` states that for any two submodules `p` and `p'` of the module `M` over the semiring `R`, the result of mapping the submodule `p` using the embedding function `Submodule.subtype p`, and then preimage mapping (`Submodule.comap`) with `Submodule.subtype p` applied to `p'`, is equal to the intersection of `p` and `p'`. In other words, applying these two operations (embedding and then preimage mapping) is equivalent to taking the intersection of the two submodules.

For any submodules $p, p'$ of an $R$-module $M$, we have $(\text{Submodule.subtype } p)(\text{Submodule.comap } \text{ Submodule.subtype } p')(p) = p \cap p'$.


theorem AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.targetAffineLocallyIsLocal :
    ∀ {P : AlgebraicGeometry.AffineTargetMorphismProperty},
      AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal P →
        AlgebraicGeometry.PropertyIsLocalAtTarget (AlgebraicGeometry.targetAffineLocally P) :=
  by sorry

The theorem `AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.targetAffineLocallyIsLocal` states that for any `AffineTargetMorphismProperty`, denoted `P`, if `P` is local (as per the definition of being local in the context of `AffineTargetMorphismProperty`), then the property of being affine locally at the target (denoted `AlgebraicGeometry.targetAffineLocally P`) is also local. In other words, if a property `P` holds for all morphisms from any scheme into an affine scheme, and this property is local, then `P` also holds locally at every affine open subset of the target scheme.

If `P` is a local property of `AffineTargetMorphisms` in Lean 4, then the property `AlgebraicGeometry.targetAffineLocally P` of being affine locally at the target of `P` is also local.


theorem MeasureTheory.Measure.eqOn_of_ae_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {m : MeasurableSpace X} [inst_1 : TopologicalSpace Y]
      [inst_2 : T2Space Y] {μ : MeasureTheory.Measure X} [inst_3 : MeasureTheory.Measure.IsOpenPosMeasure μ] {s : Set X}
      {f g : X → Y},
      f =ᶠ[MeasureTheory.Measure.ae (μ.restrict s)] g →
        ContinuousOn f s → ContinuousOn g s → s ⊆ closure (interior s) → Set.EqOn f g s :=
  by sorry

The theorem, `MeasureTheory.Measure.eqOn_of_ae_eq`, states that for any topological spaces `X` and `Y` with `Y` being a T2 space, any measurable space `X`, any positive open measure `μ` on `X`, and any set `s` of `X`, if two functions `f` and `g` from `X` to `Y` are equal almost everywhere with respect to the measure `μ` restricted to `s`, and both functions are continuous on `s`, and `s` is a subset of the closure of its own interior, then these two functions are equal on `s`. In other words, under these conditions, almost everywhere equality implies equality on the set `s`.

If `X` and `Y` are topological spaces with `Y` being T2, `X` is a measurable space with positive open measure `μ`, `s` is a subset of `X` with interior and closure, and functions `f` and `g` from `X` to `Y` are measurable, continuous on `s`, and equal almost everywhere on `s` with respect to `μ`, then `f` and `g` agree on `s`.


theorem ZFSet.not_mem_empty : ∀ (x : ZFSet), x ∉ ∅ := by sorry

This theorem states that for any element `x` of the ZFC universe of sets (`ZFSet`), `x` is not a member of the empty set (∅). This is in line with the standard set theory assertion that the empty set does not contain any elements.

The theorem asserts that for all sets `x` in ZFC universe, `x ∉ ∅`.


theorem CategoryTheory.ShortComplex.leftHomologyπ_naturality' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂),
      CategoryTheory.CategoryStruct.comp h₁.π (CategoryTheory.ShortComplex.leftHomologyMap' φ h₁ h₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' φ h₁ h₂) h₂.π :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftHomologyπ_naturality'` states that for any Category `C` with zero morphisms, and any two short complexes `S₁` and `S₂` in `C`, given a morphism `φ : S₁ ⟶ S₂`, and left homology data `h₁` for `S₁` and `h₂` for `S₂`, the composition of `h₁.π` (the projection map of `h₁`) and `CategoryTheory.ShortComplex.leftHomologyMap' φ h₁ h₂` is equal to the composition of `CategoryTheory.ShortComplex.cyclesMap' φ h₁ h₂` and `h₂.π` (the projection map of `h₂`). In simple terms, this theorem shows the naturality of the left homology projection in the category of short complexes, under the setting of Category Theory.

For any short complexes $S\_1$ and $S\_2$ in a zero-morphism category $C$, and a morphism $\varphi : S\_1 \to S\_2$ with associated left homology data $h\_1$ for $S\_1$ and $h\_2$ for $S\_2$, the composition of $h\_1.\pi$ and $CategoryTheory.ShortComplex.leftHomologyMap' \, \varphi h\_1 h\_2$ equals the composition of $CategoryTheory.ShortComplex.cyclesMap' \, \varphi h\_1 h\_2$ and $h\_2.\pi$.


/-- **Alias** of the forward direction of `balanced_iff_smul_mem`. -/
theorem Balanced.smul_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] {s : Set E},
      Balanced 𝕜 s → ∀ ⦃a : 𝕜⦄, ‖a‖ ≤ 1 → ∀ ⦃x : E⦄, x ∈ s → a • x ∈ s :=
  by sorry

The theorem `Balanced.smul_mem` states that for any seminormed ring `𝕜` and any type `E` with a scalar multiplication operation by `𝕜`, if a set `s` of elements of type `E` is balanced, then for any element `a` of `𝕜` with norm at most `1` and any element `x` of `s`, the scalar multiplication of `a` and `x` is also an element of `s`. In simpler terms, if a set is balanced, then scaling any member of the set by a factor whose size is at most 1 yields another member of the set.

For any seminormed ring `𝕜` and type `E` with scalar multiplication, if `s` is a balanced set of `E` and `a` is an element of `𝕜` with norm at most 1, then `ax` is in `s` for all `x` in `s`.


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

This theorem states that for any type `α` that has a linear order, given two elements `a` and `b` of that type, if `a` is less than `b`, then the minimum of `a` and `b` is `a`. In other words, in a linearly ordered set, the minimum of two elements is the smaller one. This is a fundamental property of orderings and minimum operations.

In a linearly ordered type, the minimum of two elements is the smaller one.


theorem Real.Angle.neg_pi_lt_toReal : ∀ (θ : Real.Angle), -Real.pi < Real.Angle.toReal θ := by sorry

The theorem `Real.Angle.neg_pi_lt_toReal` asserts that for any angle `θ` represented as a Real.Angle type, the real number representation of `θ` (obtained using the `Real.Angle.toReal` function) is always greater than negative pi (`-π`). In other words, the conversion of any angle to a real number results in a value that lies in the interval `(-π, +∞)`.

For any angle θ represented as a Real.Angle type in Lean 4, the real number representation of θ (obtained through `Real.Angle.toReal`) is strictly greater than -π.


theorem Trivialization.proj_symm_apply' :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {b : B} {x : F},
      b ∈ e.baseSet → proj (↑(PartialHomeomorph.symm e.toPartialHomeomorph) (b, x)) = b :=
  by sorry

The theorem `Trivialization.proj_symm_apply'` states that for any types `B`, `F`, and `Z` with given topological space structures, a projection map `proj` from `Z` to `B`, a trivialization `e` of `F` with respect to `proj`, and any elements `b` in `B` and `x` in `F` such that `b` lies in the base set of `e`, the projection of the inverse image under the partial homeomorphism associated with `e` of the pair `(b, x)` is equal to `b`. In other words, applying our projection after transforming `(b, x)` via the inverse of the partial homeomorphism associated with our trivialization lands us back at `b`.

Given a projection map `proj` from a topological space `Z` to `B`, a trivialization `e` of a type `F` with respect to `proj`, and `b` in `B` and `x` in `F` such that `b` is in the base set of `e`, then the projection of `e.partialHomeo.inv.apply (b, x)` is equal to `b`.


theorem ZMod.int_cast_surjective : ∀ {n : ℕ}, Function.Surjective Int.cast := by sorry

This theorem states that for every natural number `n`, the function `Int.cast` is surjective. In other words, it means that for every natural number `n`, every element of the output type `R` (where `R` is a type with an `IntCast R` instance), there exists an integer such that when this integer is cast to `R` using the function `Int.cast`, the resultant value is the element of `R` we started with. In mathematical terms, ∀ `n` ∈ ℕ, ∀ `r` ∈ `R`, ∃ `z` ∈ ℤ such that `Int.cast z = r`.

For every natural number `n` and every element `r` of type `R` with an `IntCast` instance, there exists an integer `z` such that `Int.cast z = r`.


theorem WithBot.coe_unbot : ∀ {α : Type u_1} (x : WithBot α) (hx : x ≠ ⊥), ↑(WithBot.unbot x hx) = x := by sorry

The theorem `WithBot.coe_unbot` states that for any type `α` and any element `x` of the type `WithBot α` (which is `α` extended with the `⊥` (bottom) element), if `x` is not the bottom element (i.e., `x ≠ ⊥`), then applying the function `WithBot.unbot` to `x` (which gives us the underlying `α` element), and then lifting it back to `WithBot α` (using the coercion function `↑`), equals to the original `x`. Essentially, this theorem asserts that the `WithBot.unbot` function correctly extracts the underlying value from a non-bottom element of `WithBot α`, and this value can be re-lifted to the original element.

For any type `α` and `x` in `WithBot α`, if `x ≠ ⊥`, then `WithBot.unbot x = x.up`.


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

The theorem `SymAlg.sym_injective` states that for all types `α`, the function `SymAlg.sym` is injective. In other words, given any two elements of type `α`, if applying `SymAlg.sym` to both yields the same result, this implies that the original elements were equal. In mathematical terms, if `SymAlg.sym a₁ = SymAlg.sym a₂` then `a₁ = a₂`.

For all types `α`, the function `SymAlg.sym` is an injection from `α` to itself.


theorem LinearMap.lift_rank_le_of_injective :
    ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
      [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
      Function.Injective ⇑f → Cardinal.lift.{v', v} (Module.rank R M) ≤ Cardinal.lift.{v, v'} (Module.rank R M') :=
  by sorry

This theorem, `LinearMap.lift_rank_le_of_injective`, states that for any ring `R` and additive commutative groups `M` and `M'` that are also `R`-modules, if we have a linear map `f` from `M` to `M'` that is injective (meaning that if the map sends two elements of `M` to the same element of `M'`, then those two elements were the same to begin with), then the rank of `M` (after a universe-lifting operation) is less than or equal to the rank of `M'` (after a universe-lifting operation). Here, the rank of a module is a measure of the "size" of the module, and is represented as a cardinal number. The universe-lifting operation is a way of relating cardinal numbers from different type universes.

If `f : M -> M'` is an injective linear map between free `R`-modules `M` and `M'` of finite rank, then the rank of `M` is less than or equal to the rank of `M'`.


theorem tendsto_norm_zero :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E], Filter.Tendsto (fun a => ‖a‖) (nhds 0) (nhds 0) := by sorry

This theorem, `tendsto_norm_zero`, states that for every semi-normed add group `E`, the norm function tends to zero as its argument tends to zero. More formally, given any neighborhood of zero in the reals (in the space of norms), there exists a neighborhood of zero in the semi-normed add group such that the norm of all elements in this neighborhood is contained within the specified neighborhood of zero in the reals. Essentially, it's stating that the norm of elements close to zero in the semi-normed add group will also be close to zero, which is a fundamental property of norms in a topological space.

Given any semi-normed add group `E` and any neighborhood of zero in the real numbers, there exists a neighborhood of zero in `E` such that the norm of every element in this neighborhood is contained within the given neighborhood of zero in the real numbers.


theorem CategoryTheory.MorphismProperty.StableUnderBaseChange.snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.StableUnderBaseChange P →
        ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [inst_1 : CategoryTheory.Limits.HasPullback f g],
          P f → P CategoryTheory.Limits.pullback.snd :=
  by sorry

This theorem states that, given a category `C` and a morphism property `P` on `C` which is stable under base change, for any three objects `X`, `Y`, and `S` in `C` and two morphisms `f : X ⟶ S` and `g : Y ⟶ S` such that a pullback of `f` and `g` exists, if morphism `f` has the property `P`, then the second projection of the pullback (denoted `CategoryTheory.Limits.pullback.snd`) also has the property `P`. In other words, the property `P` is preserved in the pullback operation.

If `C` is a category, `P` is a stable under base change morphism property on `C`, and `f : X ⟶ S` and `g : Y ⟶ S` are morphisms in `C` with a pullback, then if `f` has property `P`, so does the second projection of the pullback of `f` and `g`.


theorem MeasureTheory.measure_diff_null' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      ↑↑μ (s₁ ∩ s₂) = 0 → ↑↑μ (s₁ \ s₂) = ↑↑μ s₁ :=
  by sorry

This theorem, named `MeasureTheory.measure_diff_null'`, is a statement about measure theory. It holds for any type `α`, a measurable space `m` of type `α`, a measure `μ` on this measurable space, and two sets `s₁` and `s₂` of elements of type `α`. The theorem states that if the measure of the intersection of `s₁` and `s₂` is 0, then the measure of the set difference "s₁ minus s₂" is equal to the measure of `s₁`. In mathematical terms, if μ(s₁ ∩ s₂) = 0, then μ(s₁ \ s₂) = μ(s₁), where μ represents the measure, ∩ represents intersection of sets, and \ represents set difference.

If two sets in a measurable space have zero intersection measure, then their set difference is measurably equal to the original set.


theorem ENNReal.mul_div_cancel' : ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → a * (b / a) = b := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, given that `a` is neither zero nor infinity, the multiplication of `a` and the division of `b` by `a` results in `b`. In mathematical terms, this corresponds to the identity `a * (b / a) = b` for `a` in the extended nonnegative real numbers that are neither zero nor infinity.

For nonzero extended nonnegative real numbers `a` and `b`, `a * (b / a) = b`.


theorem Ordinal.mod_one : ∀ (a : Ordinal.{u_4}), a % 1 = 0 := by sorry

The theorem `Ordinal.mod_one` states that for any well-ordered type `a` (represented as an ordinal in Lean), the result of calculating the modulus of `a` by 1 (`a % 1`) is always 0. This is essentially the ordinal version of the standard mathematical fact that any number modulo 1 is 0, reflecting the property that there is no remainder when any number is divided by 1.

For any well-ordered type `a` represented as an ordinal in Lean, `a % 1` equals 0.


theorem Set.sUnion_empty : ∀ {α : Type u_1}, ⋃₀ ∅ = ∅ := by sorry

This theorem states that the set union of an empty set of sets is also an empty set. In other words, given any type `α`, the union over all elements (which are sets themselves) in an empty set of sets results in an empty set. This is an application of the set theory principle that the union of no sets results in no elements.

The union of an empty set of sets is an empty set.


CategoryTheory.StructuredArrow.w

theorem CategoryTheory.StructuredArrow.w :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      {A B : CategoryTheory.StructuredArrow S T} (f : A ⟶ B),
      CategoryTheory.CategoryStruct.comp A.hom (T.map f.right) = B.hom :=
  by sorry

This theorem is about structured arrows in category theory. Given two categories, `C` and `D`, with `S` being an object in `D` and `T` being a functor from `C` to `D`, the theorem states that for any two structured arrows `A` and `B` from `S` to `T`, and a morphism `f` from `A` to `B`, the composition of the morphism from `A` to `B` with the application of the functor `T` to the right component of `f` is equal to the morphism from `B` to `T`. In other words, it captures a commutativity property where traversal via the functor and the morphism is same as direct traversal via the morphism in the structured arrow.

Given functors T : C -> D between categories C and D, objects S in D, structured arrows A, B : S -> T, and a morphism f : A -> B in C, the composition of T(B) \* f = A \* T(g), where g is the right component of f.


Path.continuous

theorem Path.continuous : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), Continuous ⇑γ := by
  sorry

This theorem states that for any given type `X` with a topology (`TopologicalSpace X`), and any two points `x` and `y` in `X`, if there exists a path (`γ`) from `x` to `y`, then the function mapping elements of the path (`γ`) to their images in `X` is continuous. In other words, the path from `x` to `y` can be traced without lifting the 'pen' from the 'paper', where 'pen' and 'paper' are metaphorical representations of the mathematical concepts of a function and a set respectively.

Given a topological space `X` and points `x` and `y` with a continuous path `γ` between them, the function mapping `γ` to its image in `X` is continuous.


theorem Submonoid.coe_mul : ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M) (x y : ↥S), ↑(x * y) = ↑x * ↑y :=
  by sorry

This theorem, `Submonoid.coe_mul`, states that for any type `M` that has a multiplication and a one (captured by the typeclass `MulOneClass M`), and for any submonoid `S` of `M`, the result of multiplying two elements `x` and `y` in the submonoid and then coercing to the parent monoid is the same as first coercing the elements to the parent monoid and then multiplying them. Essentially, it's saying that multiplication in the submonoid is the same as multiplication in the parent monoid when we view the elements as elements of the parent monoid.

For any type `M` with multiplication and one, and for any submonoid `S` of `M`, the multiplication of elements in `S` coerced to `M` is equal to the multiplication of the same elements in `M`.


theorem PadicInt.norm_mul : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (z1 z2 : ℤ_[p]), ‖z1 * z2‖ = ‖z1‖ * ‖z2‖ := by sorry

The theorem `PadicInt.norm_mul` states that for any natural number `p` that is a prime number, and any two p-adic integers `z1` and `z2`, the norm or magnitude of the product of `z1` and `z2` is equal to the product of the individual norms of `z1` and `z2`. This is a statement about the properties of p-adic numbers, and specifically, this theorem is asserting that the norm function on the p-adic integers is multiplicative.

For any prime number p and p-adic integers z1 and z2, the norm of their product z1 * z2 equals the product of their individual norms.


theorem Polynomial.degree_monomial :
    ∀ {R : Type u} {a : R} [inst : Semiring R] (n : ℕ), a ≠ 0 → Polynomial.degree ((Polynomial.monomial n) a) = ↑n := by
  sorry

This theorem states that for any semiring `R` and any element `a` of `R` which is not zero, and any natural number `n`, the degree of the polynomial produced by multiplying `a` by `X^n` (where `X` is an indeterminate) is `n`. In other words, the degree of a monomial `a * X^n` is `n`, provided `a` is not zero.

For any semiring `R`, and any non-zero element `a` in `R` and natural number `n`, the degree of the polynomial `a * X^n` is `n`.


/-- If `x` and `y` are on the same ray, then the triangle inequality becomes the equality: the norm
of `x + y` is the sum of the norms of `x` and `y`. The converse is true for a strictly convex
space.  -/
theorem SameRay.norm_add :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {x y : E},
      SameRay ℝ x y → ‖x + y‖ = ‖x‖ + ‖y‖ :=
  by sorry

This theorem states that if two vectors `x` and `y` in a semi-normed additive commutative group that also has a normed space over the real numbers are on the same ray (that is, one of them is zero or some positive multiples of them are equal), then the norm of the sum of `x` and `y` is equal to the sum of the norms of `x` and `y`. Furthermore, the converse of this statement is true if the space is strictly convex.

If `x` and `y` are vectors in a real semi-normed additive commutative group that is also a normed space, and they lie on the same ray, then the norm of their sum is equal to the sum of their norms; conversely, this holds if the space is strictly convex.


theorem rank_span_le :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] (s : Set M), Module.rank R ↥(Submodule.span R s) ≤ Cardinal.mk ↑s :=
  by sorry

This theorem states that for any given ring `R`, additive commutative group `M`, and a module structure over `R` and `M`, under the strong rank condition for `R`, the rank of the submodule spanned by a set `s` in `M` is less than or equal to the cardinality of the set `s`. In other words, the cardinality of a basis of the submodule generated by a set `s` can not exceed the cardinality of the set `s` itself.

For any ring `R`, additive commutative group `M` with an `R`-module structure, and set `s` in `M`, under the strong rank condition for `R`, the rank of the submodule generated by `s` is less than or equal to the cardinality of `s`.


theorem SetLike.one_mem_graded :
    ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : One R] [inst_2 : Zero ι] (A : ι → S)
      [inst_3 : SetLike.GradedOne A], 1 ∈ A 0 :=
  by sorry

This theorem, `SetLike.one_mem_graded`, asserts that for any types `ι`, `R` and `S`, with `S` being a set-like object over `R`, `R` being a type with a defined multiplicative identity (One), and `ι` being a type with a defined additive identity (Zero), if you have a graded function `A` from `ι` to `S`, such that `A` respects the multiplicative identity, then the multiplicative identity of `R` is an element of the set `A` of `0` (the additive identity of `ι`). In other words, in this graded structure, the multiplicative identity exists at the level of the additive identity.

If `A` is a graded function from a type `ι` with additive identity `0` to a set-like object `S` over a type `R` with multiplicative identity `One`, such that `A` respects the multiplicative identity, then `One` is an element of `A(0)`.


theorem MeasureTheory.Memℒp.of_bound :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : α → E},
      MeasureTheory.AEStronglyMeasurable f μ → ∀ (C : ℝ), (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C) → MeasureTheory.Memℒp f p μ :=
  by sorry

This theorem states that for any types `α` and `E`, a measure space `m0` on `α`, an extended nonnegative real number `p`, a measure `μ` on `α`, a normed additively commutative group structure on `E`, and a measure `μ` that is finite, if we have a function `f` from `α` to `E` which is almost everywhere strongly measurable with respect to `μ`, then if there exists a real number `C` such that the norm of `f(x)` is less than or equal to `C` for almost all `x` in the measure space, `f` is in the function space `L^p(μ)`. In other words, `f` is almost everywhere strongly measurable and the `p`-th power of the norm of `f`, integrated with respect to `μ`, raised to the power `1/p`, is finite if `p` is finite, or the essential supremum of `f` is finite if `p` is infinity.

Given a measure space `(α, m0)`, a finite measure `μ`, an almost everywhere strongly measurable function `f` from `α` to a normed additively commutative group `E`, and a real number `C` such that the norm of `f(x)` is less than or equal to `C` for almost every `x` with respect to `μ`, if the integral of the `p`-th power of the norm of `f` is finite for some finite `p` or the essential supremum of `|f|` is finite when `p = ∞`, then `f` belongs to the `L^p(μ, E)` space.


theorem AddConstMapClass.map_add_nsmul :
    ∀ {F : Type u_1} {G : Type u_2} {H : Type u_3} {a : G} {b : H} [inst : AddMonoid G] [inst_1 : AddMonoid H]
      [inst_2 : AddConstMapClass F G H a b] (f : F) (x : G) (n : ℕ), f (x + n • a) = f x + n • b :=
  by sorry

This theorem states that for any types `F`, `G`, and `H`, any elements `a` of `G`, `b` of `H`, and given that `G` and `H` are `AddMonoid`s and there exists `AddConstMapClass` between `F`, `G` and `H` with `a` and `b`, for any `f` from `F`, `x` from `G` and `n` from natural numbers, applying `f` to the addition of `x` and `n` times `a` is equal to the addition of `f(x)` and `n` times `b`. In mathematical terms, this theorem asserts that $f(x + n \cdot a) = f(x) + n \cdot b$ under the specified conditions.

For any AddMonoid types F, G, H with an AddConstMapClass between F, G, and H, and elements a in G, b in H, and natural number n, the map f from F satisfies f(x + na) = f(x) + nb for all x in G.


/-- Comparison test of convergence of `ℝ≥0`-valued series.  -/
theorem NNReal.summable_of_le : ∀ {β : Type u_2} {f g : β → NNReal}, (∀ (b : β), g b ≤ f b) → Summable f → Summable g :=
  by sorry

The theorem `NNReal.summable_of_le` is about the convergence comparison test of series with nonnegative real values (`ℝ≥0`). It states that for any two functions `f` and `g` from an arbitrary type `β` to nonnegative real numbers (`NNReal`), if for all `b` in `β`, `g(b)` is less than or equal to `f(b)`, and if the series formed by `f` is summable (i.e., it has a finite sum), then the series formed by `g` is also summable. This is a formal statement of the comparison test for convergence of series in real analysis.

If `f` is a function from a type `β` to nonnegative real numbers with a sum, and `g` is another such function with `g(b) ≤ f(b)` for all `b` in `β`, then the series formed by `g` is summable.


theorem Nat.le_of_sub_eq_zero : ∀ {n m : ℕ}, n - m = 0 → n ≤ m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if the result of subtracting `m` from `n` equals zero, it implies that `n` is less than or equal to `m`. In mathematical terms, ∀ n, m ∈ ℕ, if n - m = 0, then n ≤ m.

For all natural numbers `n` and `m`, if `n - m = 0` then `n <= m`.


theorem Hyperreal.exists_st_of_not_infinite : ∀ {x : ℝ*}, ¬Hyperreal.Infinite x → ∃ r, Hyperreal.IsSt x r := by sorry

The theorem `Hyperreal.exists_st_of_not_infinite` states that for every hyperreal number `x`, if `x` is not infinite, then there exists a real number `r` such that `r` is the standard part of `x`. In other words, for any real number `δ` greater than zero, `x` lies within the interval from `r - δ` to `r + δ`. This captures the idea that if a hyperreal number is not infinitely large or small, it must be close to some standard real number, within any given margin.

For every hyperreal number `x` that is not infinite, there exists a real number `r` such that `x` lies within the interval `(r - δ, r + δ)` for any positive real `δ`. In other words, the standard part `r` of `x` exists and approximates `x` arbitrarily closely.


theorem IsExtrFilter.filter_mono :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α},
      IsExtrFilter f l a → l' ≤ l → IsExtrFilter f l' a :=
  by sorry

The theorem `IsExtrFilter.filter_mono` states that for all types `α` and `β` with a preorder relation on `β`, for any function `f` from `α` to `β`, for any two filters `l` and `l'` on `α`, and for any element `a` in `α`, if `a` is an extremal value (either a minimum or a maximum) of the function `f` with respect to the filter `l`, and if the filter `l'` is a subfilter of `l`, then `a` is also an extremal value of the function `f` with respect to the filter `l'`. In other words, extremal-ness with respect to a filter is preserved under taking subfilters.

If `f` is a function from type `α` to type `β` with a preorder relation, and `a` is an extremal value of `f` with respect to filter `l` on `α`, then `a` is also an extremal value of `f` with respect to any subfilter `l'` of `l`.


theorem le_hasSum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α} {a : α},
      HasSum f a → ∀ (i : ι), (∀ (j : ι), j ≠ i → 0 ≤ f j) → f i ≤ a :=
  by sorry

This theorem states that for any type `ι` and `α`, where `α` is a ordered additive commutative monoid with a topology such that it is an order-closed topology, and for any function `f` from `ι` to `α` and any `α` value `a`, if `f` sums to `a`, then for any element `i` of `ι`, if all other elements `j` of `ι` maps to non-negative value by `f`, then the value of `f` at `i` is less than or equal to `a`. In simple words, it says if a function's sum is a certain value, any individual term in that sum is less than or equal to the sum itself given that all other terms are non-negative.

If `f : ι → α` is a function from a type `ι` to an ordered additive commutative monoid `α` with an order-closed topology, such that the sum of `f` is `a` and for all `j ≠ i` in `ι`, `f j ≤ a`, then `f i ≤ a`.


theorem SmoothMap.coe_zero :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {H : Type u_4} [inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5}
      [inst_6 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {N : Type u_6} [inst_7 : TopologicalSpace N]
      [inst_8 : ChartedSpace H N] {G : Type u_10} [inst_9 : Zero G] [inst_10 : TopologicalSpace G]
      [inst_11 : ChartedSpace H' G], ⇑0 = 0 :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `E'`, topological spaces `H`, `H'`, `N`, and `G`, a model with corners `I` on `E`, `H`, another model with corners `I'` on `E'`, `H'`, a charted space structure on `N` and `G`, and given that `G` is a zero type, the function application of zero equals zero. This result is valid in the context of smooth manifolds with corners, which are generalizations of smooth manifolds and used in the field of differential geometry.

Given a non-trivially normed field, normed additive commutative groups, topological spaces, model with corners on these objects, a charted space structure on two zero-type spaces, the function application of zero equals zero. (This theorem holds in the context of smooth manifolds with corners.)


theorem Stream'.drop_drop :
    ∀ {α : Type u} (n m : ℕ) (s : Stream' α), Stream'.drop n (Stream'.drop m s) = Stream'.drop (n + m) s := by sorry

This theorem states that for any type `α`, any natural numbers `n` and `m`, and any stream `s` of `α`, dropping `n` elements from the stream produced by dropping `m` elements of `s` is the same as dropping `n + m` elements from the original stream `s` directly. Essentially, this theorem asserts the associativity of the "drop" function on streams: two consecutive "drop" operations can be combined into a single "drop" operation with the sum of the original "drop" counts.

For any type `α`, given natural numbers `n` and `m`, the operation of dropping `n` elements from the stream obtained by dropping `m` elements is equal to dropping `n + m` elements directly from the original stream.


/-- In a multiplicative group action, the points fixed by `g` are also fixed by `g⁻¹`  -/
theorem MulAction.fixedBy_inv :
    ∀ (α : Type u_1) {G : Type u_2} [inst : Group G] [inst_1 : MulAction G α] (g : G),
      MulAction.fixedBy α g⁻¹ = MulAction.fixedBy α g :=
  by sorry

This theorem states that in a multiplicative group action, the set of points which are left unchanged by the action of the element `g` is the same as the set of points left unchanged by the action of the inverse of `g`, denoted `g⁻¹`. Here, `MulAction.fixedBy α g` represents the set of all points in the space `α` fixed by the group element `g`. So the theorem essentially says that if a point doesn't move under the action of a group element, it also won't move under the action of the inverse of that group element.

In a multiplicative group action, the sets of fixed points for an element and its inverse are equal.


theorem Filter.disjoint_principal_right :
    ∀ {α : Type u_1} {f : Filter α} {s : Set α}, Disjoint f (Filter.principal s) ↔ sᶜ ∈ f := by sorry

This theorem states that, for any given type `α`, any filter `f` on `α`, and any set `s` of `α`, the filter `f` is disjoint with the principal filter of `s` if and only if the complement of `s` is an element of the filter `f`. In the context of lattice theory, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element. Here, the disjointness of `f` and the principal filter of `s` is characterized by the presence of the complement of `s` in `f`. The principal filter of a set `s` is the collection of all supersets of `s`.

For any filter `f` on type `α` and set `s` of `α`, `f` is disjoint with the principal filter of `s` if and only if the complement of `s` is in `f`.


Equiv.Perm.IsCycle.sameCycle

theorem Equiv.Perm.IsCycle.sameCycle :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α},
      Equiv.Perm.IsCycle f → f x ≠ x → f y ≠ y → Equiv.Perm.SameCycle f x y :=
  by sorry

The theorem `Equiv.Perm.IsCycle.sameCycle` states that for any type `α`, and any permutation `f` of `α`, if `f` is a cycle and `f x` does not equal `x` and `f y` does not equal `y`, then `x` and `y` are in the same cycle of the permutation `f`. In other words, if a permutation `f` is a non-identity cycle, and `x` and `y` are nonfixed points under `f`, then there exists some integer `i` such that applying `f` `i` times to `x` gives `y`.

If `f` is a non-identity cycle permutation on type `α`, and `x` and `y` are distinct points not fixed by `f`, then there exists an integer `i` such that `f^i(x) = y`.


theorem essSup_congr_ae :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : ConditionallyCompleteLattice β] {f g : α → β},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → essSup f μ = essSup g μ :=
  by sorry

This theorem states that for any two functions `f` and `g` from a measurable space `α` to a conditionally complete lattice `β`, and for any measure `μ` on `α`, if `f` and `g` are equal almost everywhere with respect to measure `μ`, then their essential supremum with respect to measure `μ` are also equal. Here, "almost everywhere" means that the set of points where the two functions differ has measure zero. The essential supremum of a function with respect to a measure is the smallest value `c` such that the function's value is less than or equal to `c` almost everywhere.

If `f` and `g` are measurable functions from a measurable space `α` to a conditionally complete lattice `β`, and `μ` is a measure on `α` such that `f = g` almost everywhere with respect to `μ`, then the essential supremum of `f` and `g` with respect to `μ` are equal.


theorem Mathlib.Data.Finsupp.NeLocus._auxLemma.5 :
    ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N}
      {a : α}, (a ∈ Finsupp.neLocus f g) = (f a ≠ g a) :=
  by sorry

The theorem `Mathlib.Data.Finsupp.NeLocus._auxLemma.5` asserts that for any types `α` and `N`, given that `α` and `N` have decidable equality and `N` has a zero element, for any two finitely supported functions `f` and `g` from `α` to `N`, and for any element `a` from `α`, `a` is in the set where `f` and `g` differ (`Finsupp.neLocus f g`) if and only if `f(a)` is not equal to `g(a)`. In other words, the `neLocus` function correctly identifies the set of elements in `α` where the two functions `f` and `g` differ.

For any types `α` with decidable equality and `N` having a zero element, two finitely supported functions `f` and `g` from `α` to `N` have different values at `α` element `a` if and only if `a` belongs to the set of elements where `f` and `g` differ (`Finsupp.neLocus f g`).


/-- A variation on Fermat's little theorem. See `ZMod.pow_card_sub_one_eq_one`  -/
theorem ZMod.pow_card : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (x : ZMod p), x ^ p = x := by sorry

This theorem is a variation on Fermat's Little Theorem, specifically for the integers modulo a prime number `p`. It states that for any integer `x` in the set of integers modulo `p` (where `p` is a prime number), raising `x` to the power `p` will yield `x` itself. In traditional mathematical notation, this would be stated as \(x^p \equiv x \; (mod \; p)\) for any integer `x` and prime `p`.

For any prime number `p`, the power `x^p` equals `x` in the integers modulo `p`. (Or in mathematical notation: `x^p ≡ x (mod p)` for any integer `x` and prime `p`. )


theorem EuclideanGeometry.dist_center_eq_dist_center_of_mem_sphere' :
    ∀ {P : Type u_2} [inst : MetricSpace P] {p₁ p₂ : P} {s : EuclideanGeometry.Sphere P},
      p₁ ∈ s → p₂ ∈ s → dist s.center p₁ = dist s.center p₂ :=
  by sorry

This theorem, named `EuclideanGeometry.dist_center_eq_dist_center_of_mem_sphere'`, states that for any metric space `P` and any two points `p₁` and `p₂` in `P`, if both points belong to the same sphere `s`, then the distances from the center of the sphere to `p₁` and `p₂` are equal. This theorem aligns with our intuitive understanding of a sphere, as it basically states that all points on a sphere's surface are equidistant from the sphere's center.

In a metric space, the distances from the center of a sphere to any two points in the sphere are equal.


IsUpperSet.ordConnected

theorem IsUpperSet.ordConnected : ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, IsUpperSet s → Set.OrdConnected s :=
  by sorry

The theorem `IsUpperSet.ordConnected` states that for all types `α` with a preorder structure, if a set `s` of type `α` is an upper set, then `s` is also order connected. In other words, if a set `s` has the property that any element greater than one of its members is also a member of the set (`IsUpperSet`), then for any two elements in this set, every element that lies between the two is also in the set (`Set.OrdConnected`). This is a property inherent to upper sets in a preordered set.

If `s` is an upper set in a preordered type `α`, then `s` is order connected, i.e., for all `a` and `b` in `s`, every element `x` with `a < x < b` is also in `s`.


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

This theorem, titled `InnerProductGeometry.angle_add_eq_arcsin_of_inner_eq_zero`, states that for any inner product space over the real numbers, given two vectors `x` and `y`, if the inner product of `x` and `y` equals to zero (which means they are orthogonal to each other) and at least one of the vectors is not a zero vector, then the angle between vector `x` and the vector resulting from the addition of `x` and `y` is equal to the arcsin of the ratio of the norm of `y` to the norm of the vector resulting from the addition of `x` and `y`. Here, the angle is computed using the `InnerProductGeometry.angle` function and the arcsin is computed using the `Real.arcsin` function.

If two vectors in an inner product space over the real numbers are orthogonal to each other and at least one is non-zero, then the angle between the first vector and the sum of the two vectors is equal to the arcsine of the ratio of the norm of the second vector to the norm of their sum.


theorem Subgroup.eq_bot_of_subsingleton :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : Subsingleton ↥H], H = ⊥ := by sorry

This theorem states that for any type `G` which has a group structure, if `H` is a subgroup of `G` and this subgroup `H` is a subsingleton (that is, it contains at most one element), then `H` must be the trivial group (denoted as `⊥`). In other words, any subsingleton subgroup of a group is the trivial group.

For any group `G`, if `H` is a subgroup of `G` with at most one element, then `H` is the trivial group `⊥`.


theorem ModelWithCorners.unique_diff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      UniqueDiffOn 𝕜 (Set.range ↑I) :=
  by sorry

This theorem states that for any Nontrivially Normed Field `𝕜`, Normed Additive Commutative Group `E`, Normed Space `E` over `𝕜`, and Topological Space `H`, given a Model With Corners `I` of types `𝕜`, `E`, and `H`, the set of points (in `𝕜`) where the function `I` (cast to a function `𝕜 → E`) is differentiable is exactly the range of `I`. In other words, the function `I` is uniquely differentiable on its entire range.

Here, the `ModelWithCorners` refers to a mathematical construct used in the formalization of smooth manifolds, providing a link between the manifold and a model Euclidean space. `UniqueDiffOn` is a property that a subset of a Normed Space has if every function which is differentiable on that subset has derivative which is unique.

For any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, and topological space `H`, the function `I` from `𝕜` to `E` defined in a Model With Corners `I` of types `𝕜`, `E`, and `H` is uniquely differentiable on its entire range.


/-- The `vectorSpan` of a finite affinely independent family has
dimension one less than its cardinality.  -/
theorem AffineIndependent.finrank_vectorSpan :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} {ι : Type u_4} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] [inst_4 : Fintype ι] {p : ι → P},
      AffineIndependent k p →
        ∀ {n : ℕ}, Fintype.card ι = n + 1 → FiniteDimensional.finrank k ↥(vectorSpan k (Set.range p)) = n :=
  by sorry

This theorem states that for any Division Ring `k`, Additive Commutative Group `V`, Additive Torsor `P`, and any finite type `ι`, given a function `p` from `ι` to `P` that forms an affinely independent set, the rank (or the dimension for a vector space over a field) of the `vectorSpan` (the submodule spanning the differences) of the range of `p` is one less than the cardinality (or the number of elements) of `ι`. In essence, the dimension of the spanned space of a finite affinely independent set is one less than the number of elements in the set.

For any division ring `k`, additive commutative group `V`, additive torsor `P`, and finite type `ι`, the rank of `vectorSpan` over `k` of an affinely independent set of `ι` elements from `P` is one less than the cardinality of `ι`.


theorem ppow_one : ∀ {M : Type u_1} [inst : Mul M] [inst_1 : Pow M ℕ+] [inst : PNatPowAssoc M] (x : M), x ^ 1 = x := by
  sorry

This theorem states that for any type `M` that has a multiplication operation and a power operation that takes a positive natural number, and assuming that the power operation is associative with the multiplication, raising any element `x` of `M` to the power of `1` will result in `x` itself. In mathematical notation, this can be expressed as \(x^1 = x\) for any `x` in `M`.

For any type `M` with multiplication and power operations, if the power operation is associative with multiplication, then for all `x` in `M`, `x^1 = x`.


theorem Fin.succAbove_pred_of_lt :
    ∀ {n : ℕ} (p i : Fin (n + 1)) (h : p < i) (hi : optParam (i ≠ 0) ⋯), Fin.succAbove p (Fin.pred i hi) = i := by sorry

This theorem states that for any natural number `n`, and any two elements `p` and `i` of the finite set `Fin (n + 1)`, if `p` is less than `i` and `i` is not zero (with an optional parameter to specify this), then the result of applying the function `Fin.succAbove` to `p` and the predecessor of `i` (`Fin.pred i`) is `i` itself.

In other words, embedding the predecessor of `i` into `Fin (n + 1)` with a hole around `p` through the `Fin.succAbove` function returns `i` if `p` is less than `i` and `i` is not zero. This is a property of the `Fin.succAbove` function and how it interacts with the `Fin.pred` function in the scope of finite sets.

For any natural number `n` and `i, p` in `Fin (n + 1)` with `p < i` and `i ≠ 0`, `Fin.succAbove p (Fin.pred i) = i`.


theorem WittVector.verschiebung_coeff_succ :
    ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x : WittVector p R) (n : ℕ),
      (WittVector.verschiebung x).coeff (Nat.succ n) = x.coeff n :=
  by sorry

This theorem, `WittVector.verschiebung_coeff_succ`, states that for any natural number `p`, a type `R`, a Witt vector `x` of type `R` and `p` as its prime, and another natural number `n`, if `p` is a prime number and `R` is a commutative ring, then the coefficient of the (n+1)th term of the shifted Witt vector (achieved by the `verschiebung` operation on `x`) is equal to the coefficient of the nth term of the original Witt vector `x`. Essentially, this theorem captures how the `verschiebung` operation shifts coefficients up by one place in a Witt vector.

For any prime number `p` and commutative ring `R`, the `(n+1)`th coefficient of the shifted Witt vector `verschiebung x` of Witt vector `x` over `R` with prime `p` equals the `n`th coefficient of `x`.


theorem Int.natAbs_inj_of_nonneg_of_nonneg : ∀ {a b : ℤ}, 0 ≤ a → 0 ≤ b → (Int.natAbs a = Int.natAbs b ↔ a = b) := by
  sorry

This theorem, `Int.natAbs_inj_of_nonneg_of_nonneg`, states that for any two non-negative integers `a` and `b` (i.e., `a` and `b` are greater than or equal to 0), the equality of the absolute values of `a` and `b` implies the equality of `a` and `b` itself. In other words, if `a` and `b` are non-negative integers and the absolute value of `a` is the same as the absolute value of `b`, then `a` must equal `b`.

For non-negative integers `a` and `b`, if `|a| = |b|`, then `a = b`.


theorem FractionalIdeal.isFractional_span_singleton :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      [loc : IsLocalization S P] (x : P), IsFractional S (Submodule.span R {x}) :=
  by sorry

The theorem `FractionalIdeal.isFractional_span_singleton` states that for any commutative ring `R`, a submonoid `S` of `R`, another commutative ring `P` such that there is an algebra structure over `R` on `P`, and given that `P` is a localization of `R` at `S`, and for any element `x` in `P`, the span of the singleton set `{x}` in `P` is a fractional ideal of `R` in `P`. In other words, there exists a non-zero element `a` in `R` such that multiplying `a` with any element in the span of `{x}` results in an integer in the ring `R`.

For any commutative ring R, submonoid S of R, commutative local ring P algebraically extended from R at S, and element x in P, the singleton set {x} spans a fractional ideal in R within P.


theorem Finset.truncatedSup_of_not_mem :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] [inst_2 : DecidableRel fun x x_1 => x ≤ x_1]
      {s : Finset α} {a : α}, a ∉ lowerClosure ↑s → Finset.truncatedSup s a = ⊤ :=
  by sorry

The theorem `Finset.truncatedSup_of_not_mem` states that for any type `α` that forms a semilattice with a top element (`OrderTop α`) and a decidable relation (`DecidableRel`) for less than or equal to (`x ≤ x_1`), any given set of elements from `α` (`s : Finset α`) and an element `a : α`, if `a` is not present in the least lower set containing the set `s` (i.e. `a ∉ lowerClosure ↑s`), then the supremum of the elements of `s` that are less than `a` (computed using `Finset.truncatedSup s a`) is equal to the top element of the semilattice (`⊤`).

If `α` is a semilattice with a top element and `s` is a finite subset of `α` such that `a ∉ lowerClosure s` for some `a ∈ α`, then `Finset.truncatedSup s a = ⊤`.


theorem padicValNat_self : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)], padicValNat p p = 1 := by sorry

The theorem `padicValNat_self` states that for every natural number `p` which is prime, the `p`-adic valuation of `p` is `1`. In other words, for a prime number `p`, there is exactly one `p` to the power of `1` that divides `p`. This makes sense as prime numbers are only divisible by `1` and themselves.

For every prime number `p`, the `p`-adic valuation of `p` is equal to 1.


StrictConvexOn.convexOn

theorem StrictConvexOn.convexOn :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} {f : E → β},
      StrictConvexOn 𝕜 s f → ConvexOn 𝕜 s f :=
  by sorry

The theorem `StrictConvexOn.convexOn` states that for any ordered semiring `𝕜`, any set `s` of elements of type `E` with an addition operation, any function `f` from `E` to an ordered additively commutative monoid `β`, both `E` and `β` being modules over `𝕜`, if the function `f` is strictly convex on the set `s`, then the function `f` is also convex on `s`. In mathematical terms, this means that if for all pairs of distinct points `x` and `y` in `s`, and all positive real numbers `a` and `b` such that `a + b = 1`, the inequality `f(a * x + b * y) < a * f(x) + b * f(y)` holds, then the function `f` is also convex, meaning that the inequality `f(a * x + b * y) ≤ a * f(x) + b * f(y)` holds for all points `x` and `y` in `s` and all non-negative real numbers `a` and `b` such that `a + b = 1`.

If a function `f` is strictly convex on a set `s` in an ordered semiring `𝕜`, where `E` is the type of elements of `s` with an addition operation, and `β` is an ordered additively commutative monoid that `E` and `β` are modules over `𝕜`, then `f` is convex on `s`.


theorem exists_imp : ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x) → b ↔ ∀ (x : α), p x → b := by sorry

This theorem, `exists_imp`, states that for any type `α`, any predicate `p` on `α`, and any proposition `b`, the proposition "There exists an `x` of type `α` such that `p x` implies `b`" is equivalent to the proposition "For all `x` of type `α`, if `p x` then `b`". In simpler terms, if having at least one `x` that satisfies `p` implies `b`, then having any `x` that satisfies `p` should also imply `b`.

For any type `α`, predicate `p` on `α`, and proposition `b`, the proposition "there exists an `x` in `α` such that `p(x)` implies `b`" is equivalent to "for all `x` in `α`, if `p(x)` then `b`".


theorem IsCoprime.of_mul_right_left :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime x (y * z) → IsCoprime x y := by sorry

This theorem states that for any commutative semiring `R` and any elements `x`, `y`, and `z` of `R`, if `x` and `y * z` are coprime, then `x` and `y` are also coprime. Here, two elements are considered coprime if there exist two other elements such that their linear combination equals one.

If `x` and `y` are elements of a commutative semiring `R` such that `x` and `y * z` are coprime for some `z` in `R`, then `x` and `y` are coprime.


theorem Filter.HasBasis.mem_uniformity_iff :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {p : β → Prop} {s : β → Set (α × α)},
      Filter.HasBasis (uniformity α) p s →
        ∀ {t : Set (α × α)}, t ∈ uniformity α ↔ ∃ i, p i ∧ ∀ (a b : α), (a, b) ∈ s i → (a, b) ∈ t :=
  by sorry

This theorem states that for any types `α` and `β` (with `α` having a `UniformSpace` instance), and any functions `p : β → Prop` and `s : β → Set (α × α)`, if the `uniformity` filter on `α` has a basis defined by these functions (`p` and `s`), then for any set `t` of pairs of `α`, `t` is in the `uniformity` filter on `α` if and only if there exists an `i` in `β` such that `p i` holds and for all elements `a` and `b` of `α`, if the pair `(a, b)` is in the set `s i`, then the pair `(a, b)` is also in `t`.

In simpler terms, this theorem provides a condition for a set of pairs of elements of a uniform space to be in the uniformity filter of the space, in terms of the basis of the filter.

Given a uniform space `α` with `UniformSpace` instance, a property `p : β → Prop`, and a relation `s : β → Set (α × α)` defining a basis for its uniformity filter, a set `t` of pairs of `α` is in the uniformity filter if and only if there exists an `i` in `β` such that `p i` holds and for all `a, b` in `α`, if `(a, b)` is in `s i`, then it is also in `t`.


theorem CategoryTheory.ShortComplex.leftHomologyMap'_add :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂),
      CategoryTheory.ShortComplex.leftHomologyMap' (φ + φ') h₁ h₂ =
        CategoryTheory.ShortComplex.leftHomologyMap' φ h₁ h₂ + CategoryTheory.ShortComplex.leftHomologyMap' φ' h₁ h₂ :=
  by sorry

This theorem states that, in the context of a given category of type `C`, which is preadditive, for any two short complexes `S₁` and `S₂` and any two morphisms `φ` and `φ'` between them, and given the left homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, the left homology map of the sum of `φ` and `φ'` is equal to the sum of the left homology maps of `φ` and `φ'`. This establishes the additive property of the left homology map in the category theoretical context, specifically for short complexes.

In a preadditive category `C`, the left homology map of the sum of two morphisms between short complexes is equal to the sum of their individual left homology maps.


theorem Nat.factorial_zero : Nat.factorial 0 = 1 := by sorry

The theorem `Nat.factorial_zero` states that the factorial of 0 is 1. In mathematical terms, this is denoted as `0! = 1`. This is a fundamental property in combinatorics, as there is exactly one way to arrange zero items.

The theorem `Nat.factorial_zero` asserts that the factorial of 0 equals 1 (i.e., 0! = 1).


Function.Injective.codRestrict

/-- **Alias** of the reverse direction of `Set.injective_codRestrict`. -/
theorem Function.Injective.codRestrict :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α} (h : ∀ (x : ι), f x ∈ s),
      Function.Injective f → Function.Injective (Set.codRestrict f s h) :=
  by sorry

This theorem states that if a function `f : ι → α` is injective, meaning all its inputs map to unique outputs, and if for all elements `x` in the domain `ι`, `f(x)` is an element of a set `s` in `α`, then the function `f` restricted to the codomain `s`, denoted by `Set.codRestrict f s h`, is also injective. Essentially, the injectiveness of a function `f` is preserved when its codomain is restricted to a set `s`.

If `f : ι -> α` is an injective function with image in a set `s` in `α`, then `Set.codRestrict f s` is an injective function.


theorem Mathlib.Topology.ContinuousOn._auxLemma.32 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) := by sorry

This theorem, `Mathlib.Topology.ContinuousOn._auxLemma.32`, declares that for any types `α` and `β` and any proposition `p` about a pair of elements from `α` and `β`, stating that the proposition `p` holds for all pairs `(x : α × β)` is equivalent to stating that for every individual element `a` from `α` and `b` from `β`, the proposition `p` holds for the pair `(a, b)`. In other words, we can check a property for all pairs either pair by pair or element by element.

The theorem asserts that for a proposition `p` about pairs of elements from types `α` and `β`, it holds if and only if it holds for every pair `(a, b)` where `a` is from `α` and `b` is from `β`.


theorem Mathlib.Data.Set.Defs._auxLemma.11 :
    ∀ {α : Type u} {x : α × α} {s : Set α}, (x ∈ Set.offDiag s) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) := by sorry

This theorem states that for any type `α`, any pair of elements `x` of type `α`, and any set `s` of type `α`, the pair `x` belongs to the off-diagonal of set `s` if and only if both elements of the pair belong to the set `s` and they are not equal to each other. The off-diagonal of a set `s` is defined as the set of all pairs `(a, b)` where `a` and `b` are elements of `s` and `a` is not equal to `b`.

For any type `α` and sets `s` of `α`, the off-diagonal of `s` is equal to the set of pairs `(x, y)` where `x, y ∈ s` and `x ≠ y`.