theorem ProbabilityTheory.kernel.iIndepSet_iff_iIndepSets_singleton :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} [inst : ProbabilityTheory.IsMarkovKernel κ] {μ : MeasureTheory.Measure α}
      {f : ι → Set Ω},
      (∀ (i : ι), MeasurableSet (f i)) →
        (ProbabilityTheory.kernel.iIndepSet f κ μ ↔ ProbabilityTheory.kernel.iIndepSets (fun i => {f i}) κ μ) :=
  by sorry

This theorem states that for any types `α`, `Ω`, and `ι`, given measurable spaces over `α` and `Ω`, a probability kernel from `α` to `Ω`, a measure over `α`, and a function `f` from `ι` to the set of `Ω`, if each set `f i` is measurable, then the family of sets `f` is independent with respect to the kernel and measure if and only if the family of singleton sets `{f i}` is independent with respect to the same kernel and measure. In simpler terms, it states that the independence of a family of sets regarding a probability kernel and a measure is equivalent to the independence of the corresponding singleton sets.

For measurable spaces (α, Σ\_α) and (Ω, Σ\_Ω), a probability kernel P from α to Ω, a measure μ over α, and a function f : ι → Ω with measurable sets f i, the family {f i} is independent with respect to (P, μ) if and only if the family {fi} is independent with respect to (P, μ).


theorem Set.mul_subset_mul_right : ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t : Set α}, s₁ ⊆ s₂ → s₁ * t ⊆ s₂ * t := by
  sorry

This theorem states that for any type `α` that supports multiplication, and for any three sets `s₁`, `s₂` and `t` of elements of type `α`, if set `s₁` is a subset of set `s₂`, then the multiplication of set `s₁` and set `t` is a subset of the multiplication of set `s₂` and set `t`. In other words, multiplying by a set on the right preserves the subset relationship.

For any types `α` supporting multiplication and sets `s₁`, `s₂`, and `t` of elements from `α`, if `s₁ ⊆ s₂`, then `s₁ * t ⊆ s₂ * t`.


theorem Mathlib.ModelTheory.Order._auxLemma.8 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {r : L.Relations 2},
      M ⊨ FirstOrder.Language.Relations.transitive r =
        Transitive fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] :=
  by sorry

This theorem states that for any first-order language `L` and any type `M` that has a `FirstOrder.Language.Structure` instance, and for any 2-place relation `r` in `L`, the proposition that `r` is transitive in the model `M` (denoted by `M ⊨ FirstOrder.Language.Relations.transitive r`) is equivalent to the relation `r` being transitive in the sense defined by the `Transitive` definition, when `r` is interpreted as a binary relation on `M` via the `FirstOrder.Language.Structure.RelMap` function. In other words, the model theory notion of transitivity for `r` in `M` coincides with the general notion of transitivity for the interpretation of `r` in `M`.

For any first-order language L, type M with a Structure instance, and 2-place relation r in L, the model theory condition M ⊨ FirstOrder.Language.Relations.transitive r is equivalent to the relation r being transitive on M as defined by the Transitive relation.


theorem Mathlib.ModelTheory.Order._auxLemma.6 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {r : L.Relations 2},
      M ⊨ FirstOrder.Language.Relations.reflexive r =
        Reflexive fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] :=
  by sorry

This theorem states that, for any first-order language `L` and any type `M` with a structure for `L`, and for any 2-ary relation symbol `r` in `L`, the sentence that describes `r` as being reflexive in `L` is true in the structure of `M` if and only if `r`, when interpreted as a relation on `M`, is reflexive. Here, a relation is reflexive if it relates every element to itself, i.e., for all `x` in `M`, `r` relates `x` to `x`.

For any first-order language L, type M with an L-structure, and 2-ary relation symbol r in L, the relation r is reflexive on M if and only if the formula "∀x, r x x" is true in M.


theorem Mathlib.ModelTheory.Order._auxLemma.7 :
    ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' := by sorry

This theorem, named `Mathlib.ModelTheory.Order._auxLemma.7`, states that for any type `α`, any proposition `p` that applies to items of type `α`, and any item `a'` of type `α`, if `p` is true for all items `a` that are equal to `a'`, then `p` is also true for `a'`. In other words, if we know that a property `p` holds for all elements equal to a given element `a'`, we can directly infer that this property holds for `a'` itself.

If `p` is a proposition that holds for all equal elements `a` of type `α`, then `p` holds for `a'`.


theorem Mathlib.ModelTheory.Order._auxLemma.4 : ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) := by sorry

This theorem, `Mathlib.ModelTheory.Order._auxLemma.4`, states that for any type `α` and any two elements `a` and `b` of that type, `a` being an element of the set containing only `b` is equivalent to `a` being equal to `b`. In other words, if a set only contains one element, then any item being in this set implies that it must be equal to that single element.

For any type `α` and elements `a`, `b` of `α`, if `{a} = {b}` then `a = b`. (Here, `{a}` denotes the singleton set containing `a`.)


theorem HasDerivWithinAt.congr_of_eventuallyEq_of_mem :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' s x → f₁ =ᶠ[nhdsWithin x s] f → x ∈ s → HasDerivWithinAt f₁ f' s x :=
  by sorry

This theorem states that if a function `f` has a derivative `f'` at a point `x` within a subset `s` of type `𝕜`, and if another function `f₁` is eventually equal to `f` (i.e., `f₁` equals `f` near `x` within `s`), then `f₁` also has the derivative `f'` at the point `x` within the subset `s`, provided that `x` belongs to `s`. Here, `𝕜` is a field endowed with a norm (not necessarily complete), and `F` is a normed additive commutative group over `𝕜` that forms a normed space.

If `f` has a derivative `f'` at `x` in the subset `s` of the normed space `F` over the field `𝕜` with a norm, and `f₁` is equal to `f` near `x` in `s`, then `f₁` has the derivative `f'` at `x` in `s`.


theorem Polynomial.roots_one : ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R], Polynomial.roots 1 = ∅ := by
  sorry

This theorem states that for any type `R` which is a commutative ring and an integral domain, the roots of the polynomial `1` are an empty multiset, denoted by `∅`. In other words, the polynomial `1` has no roots in this domain.

For any commutative ring and integral domain R, the polynomial 1 has no roots in R.


theorem hasFDerivAtFilter_snd :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {p : E × F}
      {L : Filter (E × F)}, HasFDerivAtFilter Prod.snd (ContinuousLinearMap.snd 𝕜 E F) p L :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, any normed add commutative group `E`, and any normed add commutative group `F`, the function `Prod.snd` has a derivative at a point `p` in the product space `E × F` with respect to a filter `L`. The derivative is given by the continuous linear map `ContinuousLinearMap.snd 𝕜 E F`. In mathematical terms, if `𝕜` is a nontrivially normed field and `E` and `F` are normed add commutative groups, then the function `Prod.snd : E × F → F` has a Fréchet derivative at any point in `E × F`, and the derivative is the continuous linear map `ContinuousLinearMap.snd 𝕜 E F`.

For any nontrivially normed field `𝕜` and normed add commutative groups `E` and `F`, the function `Prod.snd : E × F → F` has a Fréchet derivative at every point in `E × F` as the continuous linear map `ContinuousLinearMap.snd 𝕜 E F`.


theorem CategoryTheory.Adjunction.eq_homEquiv_apply :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B),
      g = (adj.homEquiv A B) f ↔ (adj.homEquiv A B).symm g = f :=
  by sorry

This theorem states that for any given two categories `C` and `D`, and functors `F : C -> D` and `G : D -> C` creating an adjunction `F ⊣ G`, then for any objects `A` in `C` and `B` in `D`, and morphisms `f : F.obj A ⟶ B` in `D` and `g : A ⟶ G.obj B` in `C`, the morphism `g` is equivalent to the application of `adj.homEquiv A B` on `f` if and only if the morphism `f` is equal to the application of the inverse of `adj.homEquiv A B` on `g`.

In other words, this theorem tells us that in the context of adjunctions in category theory, going from `C` to `D` using `F` and then comparing to a morphism in `D` is the same as going the other way from `D` to `C` using `G` and then comparing to a morphism in `C`.

For any adjunction `F ⊣ G` between categories `C` and `D`, the natural transformation `adj.homEquiv A B` is an equivalence between `F(g)` and `g · adj.homEquiv A B.symm`, for any objects `A` in `C` and `B` in `D` and morphisms `g : A ⟶ G(B)`.


theorem ProbabilityTheory.kernel.indep_of_indep_of_le_left :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m₁ m₂ m₃ _mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.Indep m₁ m₂ κ μ → m₃ ≤ m₁ → ProbabilityTheory.kernel.Indep m₃ m₂ κ μ :=
  by sorry

This theorem, in the field of Probability Theory, states that for any types `α` and `Ω`, given measurable spaces on `α` and `Ω`, a kernel from `α` to `Ω`, and a measure on `α`, if two measurable spaces `m₁` and `m₂` are independent with respect to the kernel and measure, then if a third measurable space `m₃` is a sub-space (or less than/equal to) `m₁`, `m₃` and `m₂` are also independent with respect to the same kernel and measure.

If two measurable subspaces are independent with respect to a kernel and measure, then their intersection is also independent.


theorem IsCompactOperator.isCompact_closure_image_of_isVonNBounded :
    ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : SeminormedRing 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
      {M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁]
      [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommMonoid M₂] [inst_6 : Module 𝕜₁ M₁] [inst_7 : Module 𝕜₂ M₂]
      [inst_8 : ContinuousConstSMul 𝕜₂ M₂] [inst_9 : T2Space M₂] {f : M₁ →ₛₗ[σ₁₂] M₂},
      IsCompactOperator ⇑f → ∀ {S : Set M₁}, Bornology.IsVonNBounded 𝕜₁ S → IsCompact (closure (⇑f '' S)) :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜₁`, seminormed ring `𝕜₂`, and a ring homomorphism `σ₁₂` from `𝕜₁` to `𝕜₂`, along with topological spaces `M₁` and `M₂` and modules over `𝕜₁` and `𝕜₂` respectively. Also, assuming that the scalar multiplication is continuous in `M₂` and that `M₂` is a Hausdorff space. Given a linear map `f` from `M₁` to `M₂`, if `f` is a compact operator, then for any set `S` in `M₁` that is Von Neumann bounded, the closure of the image of `S` under `f` is compact.

This theorem essentially connects several concepts from functional analysis, including compact operators, Von Neumann boundedness, and compactness of the closure of a set, establishing a relationship between them under these specific conditions.

Given a compact operator `f` between normed spaces, the closure of the image of any Von Neumann bounded set under `f` is compact.


/-- In a compact T₂ space, the connected component of a point equals the intersection of all
its clopen neighbourhoods.  -/
theorem connectedComponent_eq_iInter_isClopen :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] [inst_2 : CompactSpace X] (x : X),
      connectedComponent x = ⋂ s, ↑s :=
  by sorry

In a compact Hausdorff (T₂) space, the theorem states that the connected component of a point is equivalent to the intersection of all its clopen (both closed and open) neighborhoods. More specifically, for any point in such a space, the set of all points reachable from it without leaving a connected subset is the same as the set of points contained in every clopen subset that includes the point.

In a compact Hausdorff space, the connected component of a point equals the intersection of all clopen neighborhoods containing it.


theorem Mathlib.Algebra.BigOperators.Order._auxLemma.2 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the proposition that `c` is implied by the conjunction of `a` and `b` (`a ∧ b → c`) is equivalent to the proposition that `c` is implied by `a` and subsequently `b` (`a → b → c`). In other words, if the truth of `c` depends on both `a` and `b` being true, it's the same as saying the truth of `c` depends first on `a` being true and then on `b` being true.

The proposition `(a ∧ b → c)` is equivalent to `(a → (b → c))`.


theorem ENNReal.tsum_eq_top_of_eq_top : ∀ {α : Type u_1} {f : α → ENNReal}, (∃ a, f a = ⊤) → ∑' (a : α), f a = ⊤ := by
  sorry

The theorem `ENNReal.tsum_eq_top_of_eq_top` states that for any type `α` and any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if there exists an element `a` in `α` such that `f(a)` equals infinity (`⊤`), then the sum over all elements of `α` under function `f` also equals infinity (`⊤`). That is, it's saying if any value of the function is infinity, then the total sum is also infinity.

If a function from a type `α` to the extended nonnegative real numbers `ENNReal` has an element `α` mapping to infinity (`⊤`), then the sum of the function over all elements in `α` is also infinity (`⊤`).


theorem codisjoint_assoc :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b c : α},
      Codisjoint (a ⊔ b) c ↔ Codisjoint a (b ⊔ c) :=
  by sorry

The theorem `codisjoint_assoc` states that, for all elements `a`, `b`, and `c` of any type `α` that forms a semilattice with a top element, the property of `a` and `b` joined by the supremum (`⊔`) being codisjoint with `c` is equivalent to `a` being codisjoint with `b` and `c` joined by the supremum. In other words, the codisjointness property is associative with respect to the supremum operation in a lattice.

In a semilattice with top element, the codisjointness of `a` with `b` and `b` with `c` implies the codisjointness of `a` with `c` joined by the supremum. Conversely, the codisjointness of `a` with `c` and `c` with the supremum of `a` and `b` implies the codisjointness of `a` with `b`.


theorem Fin.predAbove_of_succ_le :
    ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : Fin.succ p ≤ i) (hi : optParam (i ≠ 0) ⋯),
      Fin.predAbove p i = Fin.pred i hi :=
  by sorry

The theorem `Fin.predAbove_of_succ_le` states that for any natural number `n`, and any finite numbers `p` and `i` where `p` is of type `Fin n` and `i` is of type `Fin (n + 1)`, if the successor of `p` is less than or equal to `i`, and `i` is not zero (with an optional parameter default), then the result of calling the function `Fin.predAbove` with `p` and `i` as arguments is the same as the result of calling the function `Fin.pred` with `i` and the proof of `i` being non-zero as arguments. In other words, it asserts the equality of two specific operations on finite numbers when certain conditions on the numbers are satisfied.

For any natural numbers `n`, `p` in `Fin n`, and `i` in `Fin (n + 1)`, if `p < i` and `i ≠ 0`, then `Fin.predAbove p i` equals `Fin.pred i (some (nat.dec_ne_zero i))`.


AddCon.symm

/-- Additive congruence relations are symmetric. -/
theorem AddCon.symm : ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {x y : M}, c x y → c y x := by sorry

This theorem states that additive congruence relations are symmetric. For any Type `M` that has an addition operation, and for any additive congruence relation `c` on `M`, if `x` and `y` are elements of `M` such that `c x y` holds, then `c y x` also holds. In other words, if `x` is congruent to `y` under the congruence relation `c`, then `y` is also congruent to `x` under the same relation.

For any additive congruence relation `c` on an abelian group `(M, +)`, if `x ≡ y (mod c)`, then `y ≡ x (mod c)`.


theorem Multiset.revzip_powersetAux_lemma :
    ∀ {α : Type u} [inst : DecidableEq α] (l : List α) {l' : List (Multiset α)},
      (∀ ⦃x : Multiset α × Multiset α⦄, x ∈ List.revzip l' → x.1 + x.2 = ↑l) →
        List.revzip l' = List.map (fun x => (x, ↑l - x)) l' :=
  by sorry

This theorem states that for any type `α` with a decidable equality and given a list `l` of type `α` and a list `l'` of multisets of `α`, if every pair `(x1, x2)` in the reverse zip of `l'` satisfies that the sum of `x1` and `x2` is equal to the multiset representation of `l`, then the reverse zip of `l'` is equal to the mapping of `l'` where each element `x` is mapped to a pair `(x, ↑l - x)`. In other words, it relates the operations of reverse-zipping and mapping on the list `l'` under the condition that the sum of the elements of each pair in the reverse zip equals to the original list `l` converted to a multiset.

If `l` is a list with decidable equality and `l'` is a list of multisets of `α` such that for all pairs `(x1, x2)` in the reverse zip of `l'`, we have `x1 + x2 = multiset.to_set l`, then the reverse zip of `l'` is equal to the mapping of `l'` where each `x` is mapped to `(x, l - x)`.


theorem mul_inv_cancel_comm : ∀ {G : Type u_1} [inst : CommGroup G] (a b : G), a * b * a⁻¹ = b := by sorry

This theorem, `mul_inv_cancel_comm`, states that for any commutative group `G` and any two elements `a` and `b` of `G`, if you multiply `a` and `b` and then multiply the result by the inverse of `a`, you get back `b`. This effectively states that multiplication by `a` and its inverse `a⁻¹` cancels out, regardless of their position. The order of multiplication doesn't matter due to the commutative property of the group.

For all commutative groups G and elements a, b in G, a * b * a⁻¹ = b.


theorem IsRelPrime.neg_left : ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → IsRelPrime (-x) y := by
  sorry

This theorem states that for any type `R` that forms a commutative ring, and for any elements `x` and `y` of `R`, if `x` and `y` are relatively prime, then `-x` (the additive inverse of `x`) and `y` are also relatively prime. In plain English, if two numbers are relatively prime, then negating one of them doesn't change their relative primality.

If `x` and `y` are relatively prime elements in a commutative ring `R`, then `-x` and `y` are also relatively prime.


/-- Baire theorem: a countable intersection of dense open sets is dense. Formulated here with ⋂₀.  -/
theorem dense_sInter_of_isOpen :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : BaireSpace X] {S : Set (Set X)},
      (∀ s ∈ S, IsOpen s) → Set.Countable S → (∀ s ∈ S, Dense s) → Dense (⋂₀ S) :=
  by sorry

The Baire theorem states that, for any topological space `X` that is also a Baire space, the countable intersection of dense open sets is dense. More formally, given a set `S` of sets of type `X`, if every `s` in `S` is open and dense, and `S` is countable, then the intersection of all sets in `S` (denoted by `⋂₀ S` in Lean) is also a dense set.

In a Baire space, the countable intersection of dense open sets is dense.


AlgebraicIndependent.comp

theorem AlgebraicIndependent.comp :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {A : Type u_5} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
      [inst_2 : Algebra R A],
      AlgebraicIndependent R x → ∀ (f : ι' → ι), Function.Injective f → AlgebraicIndependent R (x ∘ f) :=
  by sorry

The theorem `AlgebraicIndependent.comp` states that for any types `ι`, `ι'`, `R`, and `A`; any function `x` from `ι` to `A`; if `x` is algebraically independent over `R` (meaning that the canonical map out of the multivariable polynomial ring is injective), then for any function `f` from `ι'` to `ι` that is injective, the composition of `x` and `f`, denoted by `(x ∘ f)`, is also algebraically independent over `R`. This is under the preconditions that `R` and `A` are commutative rings and `A` is an algebra over `R`.

If `x: ι → A` is an algebraically independent function from a type `ι` to a commutative `R`-algebra `A`, then the composition `x ∘ f` is algebraically independent over `R` for any injective function `f: ι' → ι`.


theorem CategoryTheory.ShortComplex.cyclesMap'_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.ShortComplex.cyclesMap' (CategoryTheory.CategoryStruct.id S) h h =
        CategoryTheory.CategoryStruct.id h.K :=
  by sorry

This theorem pertains to the category theory in mathematics. Specifically, it deals with a "short complex", a specific structure in the category, denoted by 'C'. This theorem states that for any type 'C' that forms a category with zero morphisms, and for any short complex 'S' in 'C', if 'h' is the left homology data of 'S', then applying the 'cyclesMap' function to the identity morphism of 'S' and 'h' twice results in the identity morphism of 'h.K'. In simpler terms, it means that within the constraints of this category and short complex, a specific mapping operation involving the identity morphism doesn't change the underlying object 'h.K'.

For any short complex 'S' in a category 'C' with zero morphisms, the composition of the cycles map applied to the identity morphism of 'S' and the cycles map of its homology data 'h' equals the identity morphism on 'h.K'.


theorem ContinuousLinearMap.coeFn_compLp :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {𝕜 : Type u_5} [inst_2 : NontriviallyNormedField 𝕜]
      [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] (L : E →L[𝕜] F) (f : ↥(MeasureTheory.Lp E p μ)),
      ∀ᵐ (a : α) ∂μ, ↑↑(ContinuousLinearMap.compLp L f) a = L (↑↑f a) :=
  by sorry

This theorem states that for any α of type 'Type u_1', any E and F of Types 'u_2' and 'u_3' respectively, given a measurable space m0, a measure μ on α, and an extended nonnegative real number p, under the norms of additive commutative group E and F, a nontrivially normed field 𝕜, and normed spaces E and F over 𝕜, for any continuous linear map L from E to F, and for any function f in the Lp space defined on E, p, and μ, it holds almost everywhere with respect to the measure μ that the value of the function (L composed with f) at any point α is equal to the value of L applied to f at the point α.

In mathematical terms, this theorem states that for a function in the Lp space, the composition of the function with a continuous linear map is equal to the application of the map to the function, almost everywhere with respect to the measure.

For any continuous linear map L between normed spaces and any function in the Lp space, the value of L(f) is almost everywhere equal to f(L) when composed.


theorem Mathlib.Algebra.Order.ToIntervalMod._auxLemma.17 :
    ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c := by sorry

This theorem, `Mathlib.Algebra.Order.ToIntervalMod._auxLemma.17`, establishes that for any type `G` that has an `AddSemigroup` instance, the addition operation (`+`) is associative. In other words, given any three elements `a`, `b`, and `c` of type `G`, the sum of `a` and the sum of `b` and `c` (`a + (b + c)`) is equal to the sum of `a` and `b` added to `c` (`a + b + c`).

For any type `G` with an `AddSemigroup` structure, the associativity of addition holds: `a + (b + c) = (a + b) + c` for all `a, b, c` in `G`.


theorem HasDerivAtFilter.const_add :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {L : Filter 𝕜} (c : F),
      HasDerivAtFilter f f' x L → HasDerivAtFilter (fun y => c + f y) f' x L :=
  by sorry

The theorem `HasDerivAtFilter.const_add` states that for a nontrivially normed field `𝕜`, a normed additively commutative group `F`, and a normed space `𝕜 F`, if a function `f` from `𝕜` to `F` has a derivative `f'` at a point `x` along a filter `L`, then the function that adds a constant `c` to each value of `f`, also has the derivative `f'` at the same point `x` along the same filter `L`. Essentially, it demonstrates that adding a constant to a function does not change its derivative.

If a function from a nontrivially normed field to a normed additively commutative group has a derivative at a point along a filter, then the derivative is preserved under constant addition at that point along the same filter.


theorem Mathlib.Probability.Independence.ZeroOne._auxLemma.2 : ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) :=
  by sorry

This theorem, named `Mathlib.Probability.Independence.ZeroOne._auxLemma.2`, states that for any type `α` and for any set `s` of type `α` and any element `x` of type `α`, `x` being a member of the complement of set `s` is equivalent to `x` not belonging to the set `s`. In mathematical notation, if `s` is a set and `x` is an element, then `x` being in the complement of `s` (denoted as `x ∈ sᶜ`) is the same as `x` not being in `s` (denoted as `x ∉ s`).

The complement of a set is the set of all elements not in the original set. In Lean, this is formalized as `x ∈ sᶜ ↔ x ∉ s` for any type `α` and set `s` of type `α`.


theorem IntervalIntegrable.continuousOn_mul :
    ∀ {A : Type u_5} [inst : NormedRing A] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f g : ℝ → A},
      IntervalIntegrable f μ a b → ContinuousOn g (Set.uIcc a b) → IntervalIntegrable (fun x => g x * f x) μ a b :=
  by sorry

The theorem `IntervalIntegrable.continuousOn_mul` states that for any normed ring `A`, real numbers `a` and `b`, a measure `μ` on the real numbers, and functions `f` and `g` from the real numbers to `A`, if `f` is interval integrable with respect to `μ` on the interval from `a` to `b`, and `g` is continuous on the closed interval from the minimum of `a` and `b` to the maximum of `a` and `b`, then the function that maps `x` to the product of `g(x)` and `f(x)` is also interval integrable with respect to `μ` on the interval from `a` to `b`. This theorem relates the concepts of integration and continuity, and shows that under these conditions, the product of a continuous function and an interval integrable function remains interval integrable.

If `f` is interval integrable and `g` is continuous on the interval [a, b], then the product function `x ↔ g(x) * f(x)` is interval integrable on [a, b].


theorem Real.arctan_zero : Real.arctan 0 = 0 := by sorry

The theorem `Real.arctan_zero` states that the arctangent of zero is zero. In other words, when the real number zero is passed as an argument to the arctangent function (`Real.arctan`), the result is the real number zero. This is consistent with the mathematical property that the inverse tangent of zero is zero.

The arctangent function evaluates to 0 for the input of 0. (Real.arctan 0 = 0)


/-- The tangent of a complex number is equal to zero
iff this number is equal to `k * π / 2` for an integer `k`.

Note that this lemma takes into account that we use zero as the junk value for division by zero.
See also `Complex.tan_eq_zero_iff'`.   -/
theorem Complex.tan_eq_zero_iff : ∀ {θ : ℂ}, Complex.tan θ = 0 ↔ ∃ k, ↑k * ↑Real.pi / 2 = θ := by sorry

The theorem `Complex.tan_eq_zero_iff` states that the tangent of a complex number is equal to zero if and only if this number is equal to `k * π / 2` for some integer `k`. This theorem includes the consideration that zero is used as the "junk value" for division by zero. This theorem has a related theorem `Complex.tan_eq_zero_iff'`.

The complex number `z` has tangent equal to zero if and only if `z` is equal to `k * (π/2)` for some integer `k`, where tangent is defined as the complex number quotient of the imaginary unit `i` and the complex number `1 + z * z`.


theorem isAtom_iff_le_of_ge :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α] {a : α},
      IsAtom a ↔ a ≠ ⊥ ∧ ∀ (b : α), b ≠ ⊥ → b ≤ a → a ≤ b :=
  by sorry

The theorem `isAtom_iff_le_of_ge` states that for any type `α` that has a preorder and a bottom element, an element `a` of `α` is an atom if and only if `a` is not the bottom element and for all elements `b` of `α`, if `b` is not the bottom element, then whenever `b` is less than or equal to `a`, it follows that `a` is less than or equal to `b`. In essence, it says that an atom is an element that is only comparable to the bottom element (except for equality).

An element `a` of a preordered type with a bottom element is an atom if and only if it is not the bottom element and for all non-bottom elements `b`, if `b` is less than or equal to `a`, then `a` is less than or equal to `b`.


/-- There exists only one solution of an ODE \(\dot x=v(t, x)\) in a set `s ⊆ ℝ × E` with
a given initial value provided that the RHS is Lipschitz continuous in `x` within `s`,
and we consider only solutions included in `s`.

This version shows uniqueness in a closed interval `Icc a b`, where `a` is the initial time.  -/
theorem ODE_solution_unique_of_mem_Icc_right :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {v : ℝ → E → E} {s : ℝ → Set E}
      {K : NNReal} {f g : ℝ → E} {a b : ℝ},
      (∀ (t : ℝ), LipschitzOnWith K (v t) (s t)) →
        ContinuousOn f (Set.Icc a b) →
          (∀ t ∈ Set.Ico a b, HasDerivWithinAt f (v t (f t)) (Set.Ici t) t) →
            (∀ t ∈ Set.Ico a b, f t ∈ s t) →
              ContinuousOn g (Set.Icc a b) →
                (∀ t ∈ Set.Ico a b, HasDerivWithinAt g (v t (g t)) (Set.Ici t) t) →
                  (∀ t ∈ Set.Ico a b, g t ∈ s t) → f a = g a → Set.EqOn f g (Set.Icc a b) :=
  by sorry

The theorem `ODE_solution_unique_of_mem_Icc_right` states that within a closed interval `[a, b]`, where `a` is the initial time, there exists a unique solution to an ordinary differential equation (ODE) of the form  \(\dot x = v(t, x)\) that lies within a given set `s ⊆ ℝ × E` and has a specified initial value. This uniqueness is guaranteed under the conditions that the right-hand side function `v` is Lipschitz continuous with a nonnegative real constant `K` within `s` and that the solutions `f` and `g` we consider are continuous on the interval `[a, b]`, have derivatives within the set `s` that match the function `v` evaluated at `f` and `g`, and that `f` and `g` yield the same initial value. If these conditions are met, then the functions `f` and `g` are equal on the interval `[a, b]`.

Given an ODE \(\dot x = v(t, x)\) with Lipschitz continuous right-hand side \(v\) on a closed interval \([a, b]\), and given two solutions \(f, g \colon [a, b] \to \mathbb{R} \times E\) with the same initial value and continuous derivatives matching \(v\), then \(f = g\) on \([a, b]\).


/-- The pigeonhole principle for finitely many pigeons counted by weight, strict inequality version:
if the total weight of a finite set of pigeons is greater than `n • b`, and they are sorted into
`n` pigeonholes, then for some pigeonhole, the total weight of the pigeons in this pigeonhole is
greater than `b`.  -/
theorem Finset.exists_lt_sum_fiber_of_maps_to_of_nsmul_lt_sum :
    ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β}
      {w : α → M} {b : M} [inst_1 : LinearOrderedCancelAddCommMonoid M],
      (∀ a ∈ s, f a ∈ t) →
        (t.card • b < Finset.sum s fun x => w x) →
          ∃ y ∈ t, b < Finset.sum (Finset.filter (fun x => f x = y) s) fun x => w x :=
  by sorry

This theorem, referred to as the Pigeonhole Principle for Finitely Many Pigeons Counted by Weight, states that given a finite set of objects `s` (pigeons) with a weight function `w : α → M` and a function `f : α → β` that maps each object to a finite set of categories `t` (pigeonholes), if the total weight of all objects is greater than the number of categories times some weight `b`, then there exists at least one category such that the total weight of the objects in this category is greater than `b`.

In other words, if we distribute objects into categories and the total weight of the objects exceeds the total number of categories times a certain weight, then there must be at least one category where the total weight of its objects exceeds that certain weight.

Each object `a` belongs to the set `s` and is mapped to a category `f a` which belongs to the set `t`. The condition `t.card • b < Finset.sum s fun x => w x` ensures that the total weight of the objects is greater than the product of the number of categories and the weight `b`. The conclusion `∃ y ∈ t, b < Finset.sum (Finset.filter (fun x => f x = y) s) fun x => w x` stipulates that there is at least one category `y` in `t` such that the total weight of the objects in `y` exceeds `b`.

Given a finite set of objects with weights and a function mapping objects to finite sets (pigeonholes), if the total weight of the objects exceeds the number of categories times the weight of each category, then there exists a category with total weight greater than that weight.


theorem LinearMap.ker_eq_top :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {f : M →ₛₗ[τ₁₂] M₂}, LinearMap.ker f = ⊤ ↔ f = 0 :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, and a linear map `f` from `M` to `M₂`, the kernel of the linear map `f` is equal to the whole space `M` (denoted by `⊤`) if and only if the linear map `f` is the zero map. In other words, a linear map is the zero map exactly when its kernel is the whole domain.

For semirings R and R₂, additive commutative monoids M and M₂, modules M over R and M₂ over R₂, a ring homomorphism τ₁₂ from R to R₂, and a linear map f : M -> M₂, if and only if f is the zero map, then ker(f) = {x : M | ∀ y : M, f(x + y) = f(x) + f(y)} = M.


/-- The image of stone_cech_unit is dense. (But stone_cech_unit need
not be an embedding, for example if α is not Hausdorff.)  -/
theorem denseRange_stoneCechUnit : ∀ {α : Type u} [inst : TopologicalSpace α], DenseRange stoneCechUnit := by sorry

The theorem `denseRange_stoneCechUnit` states that for any type `α` that has a topology, the image of the function `stoneCechUnit` (which maps each element of `α` to its Stone-Čech compactification) is dense. This means that the set of all images of `α` in its Stone-Čech compactification is a dense set. Note that the `stoneCechUnit` function need not be an embedding, particularly when `α` is not a Hausdorff space.

The image of the Stone-Čech compactification function is a dense subset of its domain for any topological space.


theorem Set.mulIndicator_preimage :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] (s : Set α) (f : α → M) (B : Set M),
      Set.mulIndicator s f ⁻¹' B = Set.ite s (f ⁻¹' B) (1 ⁻¹' B) :=
  by sorry

This theorem states that for all types `α` and `M`, with `M` being a type that has a multiplicative identity (`One M`), a set `s` of type `α`, a function `f` from `α` to `M`, and a set `B` of type `M`, the preimage of `B` under the function `Set.mulIndicator s f` (which is a function that returns `f a` if `a` is in `s` and `1` otherwise) is equivalent to a set which is the union of the intersection of the preimage of `B` under `f` and `s`, and the set difference of the preimage of `B` under the singleton set `{1}` and `s`. This means, the elements in `α` that get mapped to `B` when using the `Set.mulIndicator s f` function are those that either belong to `s` and get mapped to `B` when using the original function `f`, or don't belong to `s` and get mapped to `1`.

For all types `α` and `M` with a multiplicative identity, and functions `f: α -> M` and `s: Set α`, the sets `{x : α | Set.mulIndicator s f x ∈ B}` and `(s ∩ {x : α | f x ∈ B}) ∪ ({1} \ s)` are equal.


theorem FractionalIdeal.coeIdeal_injective' :
    ∀ {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], S ≤ nonZeroDivisors R → Function.Injective fun I => ↑I :=
  by sorry

The theorem `FractionalIdeal.coeIdeal_injective'` states that for any commutative ring `R`, submonoid `S` of `R`, type `P` which also has a commutative ring structure, and that `P` is an algebra over `R` and a localization of `R` at `S`, if `S` is a subset of the non-zero divisors of `R`, then the function that maps an ideal `I` to its type-cast version is injective. In simpler words, no two distinct ideals will map to the same output under this function, provided `S` contains no zero divisors of `R`.

Given a commutative ring `R`, a submonoid `S` of non-zero divisors in `R`, a commutative ring `P` that is an algebra and localization of `R` over `S`, the type-cast function from ideals of `R` to ideals of `P` is injective.


EuclideanDomain.GCD.induction

theorem EuclideanDomain.GCD.induction :
    ∀ {R : Type u} [inst : EuclideanDomain R] {P : R → R → Prop} (a b : R),
      (∀ (x : R), P 0 x) → (∀ (a b : R), a ≠ 0 → P (b % a) a → P a b) → P a b :=
  by sorry

The theorem `EuclideanDomain.GCD.induction` states that for any type `R` that is an instance of a Euclidean domain, for any property `P` involving two elements of `R`, and for any two elements `a` and `b` of `R`, if `P` holds for 0 and any other element `x` of `R`, and if whenever `a` is not zero and `P` holds for the remainder of `b` divided by `a` and `a`, then `P` holds for `a` and `b`. This theorem is a form of mathematical induction related to the Euclidean algorithm for computing the greatest common divisor.

If `R` is a Euclidean domain and `P` is a property that holds for any two elements `a` and `b` when `a = 0` or `a` divides `b`, then `P` holds for `gcd(a, b)`.


theorem Ideal.isMaximal_iff :
    ∀ {α : Type u} [inst : Semiring α] {I : Ideal α},
      Ideal.IsMaximal I ↔ 1 ∉ I ∧ ∀ (J : Ideal α) (x : α), I ≤ J → x ∉ I → x ∈ J → 1 ∈ J :=
  by sorry

The theorem `Ideal.isMaximal_iff` states that for any type `α` that forms a semiring, and any ideal `I` of `α`, `I` is a maximal ideal if and only if two conditions are met: first, the number 1 is not in `I`; and second, for any ideal `J` of `α` and any element `x` of `α`, if `I` is a subset of `J`, and `x` is not in `I` but is in `J`, then the number 1 is in `J`. In other words, a maximal ideal is an ideal that does not contain the multiplicative identity and has the property that if it is contained within another ideal that contains an element not in the original ideal, then the larger ideal contains the multiplicative identity.

A semiring ideal is maximal if and only if it doesn't contain the multiplicative identity and is properly contained in no other ideal with that element.


theorem Monoid.Coprod.mclosure_range_inl_union_inr :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
      Submonoid.closure (Set.range ⇑Monoid.Coprod.inl ∪ Set.range ⇑Monoid.Coprod.inr) = ⊤ :=
  by sorry

This theorem states that for any types `M` and `N` that are instances of the `MulOneClass`, the submonoid generated by the union of the ranges of the natural embeddings `Monoid.Coprod.inl` and `Monoid.Coprod.inr` is the top monoid. In other words, every element of the coproduct monoid `M ∗ N` can be expressed as a product of elements coming from `M` (via the `inl` function) and `N` (via the `inr` function).

For any types `M` and `N` that are instances of `MulOneClass`, the submonoid generated by the ranges of the natural embeddings `inl : M → M ∗ N` and `inr : N → M ∗ N` in the monoid `M ∗ N` is the entire monoid.


theorem AlgebraicGeometry.Scheme.OpenCover.fromGlued.proof_2 :
    ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X)
      (a : (CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰).toGlueData).L),
      CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰).toGlueData).fst a)
          (𝒰.map
            ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰).toGlueData).fstFrom
              a)) =
        CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰).toGlueData).snd a)
          (𝒰.map
            ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰).toGlueData).sndFrom
              a)) :=
  by sorry

This theorem states that for any Algebraic Geometry Scheme `X` and any open cover `𝒰` of `X`, and for any pair `(i, j)` in the indexing category of the diagram formed by the glued cover of `𝒰`, the composition of the first morphism from `(i, j)` and the map of `𝒰` from `i` is equal to the composition of the second morphism from `(i, j)` and the map of `𝒰` from `j`. This is a property of the glueing process in the construction of the co-limit in category theory, which is an important concept in the theory of schemes in algebraic geometry.

For any AlgebraicGeometry Scheme X and open cover U, and for any pair (i, j) in the indexing category of its glued cover, the composition of the first morphism from (i, j) and the map of U from i is equal to the composition of the second morphism from (i, j) and the map of U from j.


theorem iInf_insert :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s : Set β} {b : β},
      ⨅ x ∈ insert b s, f x = f b ⊓ ⨅ x ∈ s, f x :=
  by sorry

This theorem, `iInf_insert`, states that for any types `α` and `β` where `α` forms a complete lattice, for any function `f` from `β` to `α`, any set `s` of type `β`, and any element `b` of type `β`, the infimum (greatest lower bound) of the values of function `f` over the set formed by inserting `b` into `s` is equal to the infimum of the value of `f` at `b` and the infimum of the values of `f` over `s`. In other words, given a complete lattice and a function mapping elements to points in this lattice, inserting a new element into a set and taking the infimum of the function's values doesn't change the overall infimum; it's simply the meet (i.e., greatest lower bound) of the function value at the inserted element and the original infimum.

For any complete lattice `α`, function `f` from `β` to `α`, set `s ∈ β`, and `b ∈ β`, the infimum of `{f x | x ∈ s ∪ {b}}` equals the infimum of `{f x | x ∈ s}` and the infimum of `f b`.


/-- **Alias** of the forward direction of `tendstoUniformlyOn_iff_tendstoUniformlyOnFilter`. -/
theorem TendstoUniformlyOn.tendstoUniformlyOnFilter :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι}, TendstoUniformlyOn F f p s → TendstoUniformlyOnFilter F f p (Filter.principal s) :=
  by sorry

This theorem states that if a sequence of functions `Fₙ` converges uniformly on a set `s` to a limiting function `f` with respect to a filter `p`, then the sequence also converges uniformly on the principal filter of `s` to the same function `f` with respect to the same filter `p`. The principal filter of `s` is a collection of all sets that include `s`. Uniform convergence on a set or a filter means that for any given measure of closeness, all the functions in the sequence are that close to the limiting function in the set or filter after some point in the sequence.

If a sequence of functions `Fₙ` uniformly converges to `f` with respect to filter `p` on set `s`, then it also uniformly converges to `f` with respect to the principal filter of `s` using the same filter `p`.


theorem Language.mul_iSup :
    ∀ {α : Type u_1} {ι : Sort v} (l : ι → Language α) (m : Language α), m * ⨆ i, l i = ⨆ i, m * l i := by sorry

This theorem, `Language.mul_iSup`, states that for any type `α`, any type `ι`, any function `l` from `ι` to a Language of `α`, and any Language `m` of `α`, the product of `m` and the supremum (or the union in the context of sets of languages) over `i` of `l i` equals the supremum over `i` of the product of `m` and `l i`. In other words, it is asserting that the operation of "multiplying" a language with the supremum of a set of languages distributes over the set of languages.

For any type `α`, any type `ι`, any function `l` from `ι` to a Language of `α`, and any Langages `m` and `n` of `α`, the supremum of `{mi \* li : i ∈ ι}` equals `m * (sup i, li)`.


Rat.add.aux

theorem Rat.add.aux :
    ∀ (a b : ℚ) {g ad bd : ℕ},
      g = Nat.gcd a.den b.den →
        ad = a.den / g →
          bd = b.den / g →
            let den := ad * b.den;
            let num := a.num * ↑bd + b.num * ↑ad;
            Nat.gcd (Int.natAbs num) g = Nat.gcd (Int.natAbs num) den :=
  by sorry

This theorem, `Rat.add.aux`, is about the addition of rational numbers. For any two rational numbers `a` and `b`, and given natural numbers `g`, `ad`, `bd` such that `g` is the greatest common divisor (gcd) of the denominators of `a` and `b`, `ad` is the denominator of `a` divided by `g`, and `bd` is the denominator of `b` divided by `g`, the theorem states that the gcd of the absolute value of the sum of the numerators of `a` and `b` (each multiplied by `bd` and `ad` respectively) and `g` is equal to the gcd of the same sum and the product of `ad` and the denominator of `b`. This result plays an essential role in the arithmetic of rational numbers.

Given rational numbers `a` and `b` with gcd(denominator(`a`), denominator(`b`)) = `g`, the gcd of (numerator(`a`) * denominator(`b`) / `g` + numerator(`b`) * denominator(`a`) / `g`) and `g` is equal to gcd((numerator(`a`) / `ad` + numerator(`b`) / `bd`), `g`), where `ad` = denominator(`a`) / `g` and `bd` = denominator(`b`) / `g`.


theorem Equiv.eq_comp_symm :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : β → γ) (g : α → γ), f = g ∘ ⇑e.symm ↔ f ∘ ⇑e = g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any equivalence `e` between `α` and `β`, a function `f` from `β` to `γ`, and a function `g` from `α` to `γ`, the function `f` is equal to the function `g` composed with the inverse of `e` if and only if the function `f` composed with `e` is equal to `g`. This theorem expresses the property of how composing functions with an equivalence and its inverse works.

For any equivalence $e:\alpha \cong \beta$, functions $f:\beta \to \gamma$, and $g:\alpha \to \gamma$, if $f \circ e = g$, then $f = g \circ e^{-1}$.


/-- For any natural `k` and a real `r > 1` we have `n ^ k = o(r ^ n)` as `n → ∞`.  -/
theorem isLittleO_pow_const_const_pow_of_one_lt :
    ∀ {R : Type u_4} [inst : NormedRing R] (k : ℕ) {r : ℝ}, 1 < r → (fun n => ↑n ^ k) =o[Filter.atTop] fun n => r ^ n :=
  by sorry

This theorem states that for any natural number `k` and a real number `r` greater than `1`, the function `n ^ k` (where `n` is a natural number) is dominated by `r ^ n` as `n` approaches infinity. This is to say that the growth rate of `n ^ k` is less than the growth rate of `r ^ n` for large `n`. The domination is expressed using the little-o notation (`=o[Filter.atTop]`), which is a mathematical notation used to describe limiting behavior. The `Filter.atTop` indicates that we are considering the behavior as `n` goes to infinity. The context is a normed ring `R`.

For any natural number `k` and real number `r` > 1 in a normed ring `R`, `n ^ k = o[Filter.atTop] (r ^ n)` as `n` approaches infinity.


theorem OneOneReducible.disjoin_right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : α → Prop} {q : β → Prop},
      q ≤₁ Sum.elim p q :=
  by sorry

The theorem `OneOneReducible.disjoin_right` states that for any two types `α` and `β`, which are both primcodable, and any properties `p` on type `α` and `q` on type `β`, the property `q` is one-one reducible to the function `Sum.elim p q`. In other words, there is an injective function that maps elements of `β` satisfying `q` to the sum type `α ⊕ β` in such a way that `q` holds if and only if `Sum.elim p q` holds.

For any primcodable types `α` and `β` and properties `p` on `α` and `q` on `β`, `q` is one-to-one reducible to the function `Sum.elim p q`, meaning there exists an injection from the set of elements satisfying `q` to the sum type `α ⊕ β` such that `q(x) <--> Sum.elim p q(fx)`, where `fx` is the image of `x` under the function associated with property `p`.


theorem toIocMod_eq_iff :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) {a b c : α},
      toIocMod hp a b = c ↔ c ∈ Set.Ioc a (a + p) ∧ ∃ z, b = c + z • p :=
  by sorry

The theorem `toIocMod_eq_iff` states that for any type `α` that is a linear ordered additive commutative group and an Archimedean field, given a positive value `p`, and three elements `a`, `b`, and `c` from `α`, the result `c` of the function `toIocMod` applied with `hp`, `a` and `b` is equal to `c` if and only if `c` belongs to the left-open right-closed interval from `a` to `a + p` (`Set.Ioc a (a + p)`) and there exists a scalar `z` such that `b` equals `c` plus `z` times `p`.

For any Archimedean linear ordered additive commutative group `α` and positive `p` in `α`, the element `c` belongs to the interval `Set.Ioc a (a + p)` and is of the form `b + k * p` for some scalar `k` if and only if `toIocMod p a b = c`.


theorem iff_false_left : ∀ {a b : Prop}, ¬a → ((a ↔ b) ↔ ¬b) := by sorry

This theorem, `iff_false_left`, states that for any two propositions `a` and `b`, if `a` is not true (denoted as `¬a`), then the equivalence of `a` and `b` (denoted as `a ↔ b`) is equivalent to `b` not being true (denoted as `¬b`). In other words, if `a` is false, then `a` is equivalent to `b` if and only if `b` is also false.

For all propositions `a` and `b`, `¬a ↔ (a ↔ b) ↔ ¬b`.


/-- A version of `Nat.div_lt_self` using successors, rather than additional hypotheses.  -/
theorem Nat.div_lt_self' : ∀ (a b : ℕ), (a + 1) / (b + 2) < a + 1 := by sorry

This theorem states that for any two natural numbers `a` and `b`, the integer division of (`a + 1`) by (`b + 2`) is strictly less than (`a + 1`). This is a version of the `Nat.div_lt_self` theorem, but it uses successors (i.e., adding 1 to a number) instead of additional hypotheses.

For all natural numbers `a` and `b`, `(a + 1) / (b + 2)` is strictly less than `a + 1`.


/-- The new distance is continuous.  -/
theorem UniformSpace.Completion.continuous_dist :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : TopologicalSpace β]
      {f g : β → UniformSpace.Completion α}, Continuous f → Continuous g → Continuous fun x => dist (f x) (g x) :=
  by sorry

This theorem states that the distance function in the Hausdorff completion of a given type `α` is continuous. More specifically, given any two types `α` and `β` where `α` is a pseudo metric space and `β` is a topological space, if we have two functions `f` and `g` mapping from `β` to the Hausdorff completion of `α` which are continuous, then a function that takes an input from `β` and returns the distance between `f` and `g` at that input is also continuous. The Hausdorff completion of `α` is defined as the separation quotient of the Cauchy filters on `α`.

Given two continuous functions from a topological space `β` to the Hausdorff completion of a pseudo metric space `α`, the function that maps an input in `β` to the distance between the image of that input under each function is also continuous.


HasDerivWithinAt.scomp

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

The theorem `HasDerivWithinAt.scomp` states that for all types `𝕜` and `𝕜'` equipped with normed fields properties, and a type `F` equipped with normed add comm group and normed space properties, given a point `x` of type `𝕜`, sets `s` of type `𝕜` and `t'` of type `𝕜'`, functions `h : 𝕜 → 𝕜'` and `g₁ : 𝕜' → F`, and elements `h'` of type `𝕜'` and `g₁'` of type `F`. If `g₁` has a derivative `g₁'` at the point `h(x)` within set `t'`, `h` has a derivative `h'` at the point `x` within set `s`, and the image of set `s` under the function `h` is contained in set `t'`, then the composite function `(g₁ ∘ h)` has a derivative `(h' • g₁')` at point `x` within set `s`. Here, `•` denotes the scalar multiplication operation.

If `h` is a function from a normed space `𝕜` to another normed space `𝕜'`, `g₁` is a function from `𝕜'` to a normed vector space `F` with derivative `g₁'` at `h(x)`, `h` has derivative `h'` at `x` with image of `s` in `t'`, then `(g₁ ∘ h)` has derivative `(h' • g₁')` at `x`.


/-- The projection from a trivial fiber bundle to its base is open.  -/
theorem IsHomeomorphicTrivialFiberBundle.isOpenMap_proj :
    ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      [inst_2 : TopologicalSpace Z] {proj : Z → B}, IsHomeomorphicTrivialFiberBundle F proj → IsOpenMap proj :=
  by sorry

The theorem `IsHomeomorphicTrivialFiberBundle.isOpenMap_proj` states that for all types `B`, `F`, and `Z` with topological spaces, given a projection function from `Z` to `B`, if `Z` is a trivial fiber bundle with fiber `F` over `B`, then the projection function is an open map. In other words, the image of an open set in `Z` under the projection function is an open set in `B`. A trivial fiber bundle in this context is a topological space that is homeomorphic to the product of its base with a discrete space.

Given a projection function from a trivial fiber bundle over a topological space to its base space, the projection function is an open map.


theorem isIntegral_zero :
    ∀ {R : Type u_1} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B], IsIntegral R 0 := by
  sorry

This theorem states that for any algebra `B` over a commutative ring `R`, the element `0` is always integral over `R`. In other words, `0` is a root of some monic polynomial with coefficients in `R`. This property holds irrespective of the specific structures of the commutative ring `R` and the algebra `B`.

For any commutative ring R and algebra B over R, the element 0 in B is integral over R.


/-- Given `c = lineMap a b r`, `a < c`, the point `(c, f c)` is non-strictly below the
segment `[(a, f a), (b, f b)]` if and only if `slope f a c ≤ slope f a b`.  -/
theorem map_le_lineMap_iff_slope_le_slope_left :
    ∀ {k : Type u_1} {E : Type u_2} [inst : LinearOrderedField k] [inst_1 : OrderedAddCommGroup E] [inst_2 : Module k E]
      [inst_3 : OrderedSMul k E] {f : k → E} {a b r : k},
      0 < r * (b - a) →
        (f ((AffineMap.lineMap a b) r) ≤ (AffineMap.lineMap (f a) (f b)) r ↔
          slope f a ((AffineMap.lineMap a b) r) ≤ slope f a b) :=
  by sorry

The theorem `map_le_lineMap_iff_slope_le_slope_left` states that for a given linear ordered field `k`, an ordered add commutative group `E` which is a module over `k`, a function `f` from `k` to `E`, and elements `a`, `b`, and `r` in `k` such that `0 < r * (b - a)`, the function value at `c` (where `c` is the affine map from `a` to `b` with ratio `r`), `f(c)`, is less than or equal to the affine map from `f(a)` to `f(b)` with ratio `r` if and only if the slope of the function `f` at `a` and `c` is less than or equal to the slope of the function `f` at `a` and `b`. In other words, the point `(c, f(c))` lies on or below the line segment connecting `(a, f(a))` and `(b, f(b))` if and only if the rate of change of the function `f` from `a` to `c` is less than or equal to the rate of change from `a` to `b`.

Given a linear ordered field `k`, an add commutative group `E` that is a `k`-module, a function `f` from `k` to `E`, and `a`, `b`, and `r` in `k` with `0 < r * (b - a)`, the point `(c, f(c))` lies on or below the line connecting `(a, f(a))` and `(b, f(b))` if and only if the slope of `f` at `a` and `c` is less than or equal to the slope of `f` at `a` and `b`.


theorem Real.mk_le : ∀ {f g : CauSeq ℚ abs}, Real.mk f ≤ Real.mk g ↔ f ≤ g := by sorry

The theorem `Real.mk_le` states that for any two Cauchy sequences of rational numbers, `f` and `g`, both evaluated by the absolute value function, the real number obtained from their equivalence classes through the `Real.mk` function is less than or equal to `g` if and only if the Cauchy sequence `f` is less than or equal to the Cauchy sequence `g`. In other words, the ≤ relation is preserved when moving from the Cauchy sequences of rational numbers to the real numbers.

For any two Cauchy sequences of rational numbers `f` and `g`, `|f| ≤ |g|` in the real numbers if and only if `f(n) ≤ g(n)` for all natural numbers `n`.


theorem Finset.card_image₂_singleton_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} (t : Finset β) {a : α},
      Function.Injective (f a) → (Finset.image₂ f {a} t).card = t.card :=
  by sorry

This theorem states that, given any types `α`, `β`, and `γ`, along with an instance of decidable equality for `γ`, a binary function `f` from `α` to `β` to `γ`, a finite set `t` of type `β`, and an element `a` of type `α`, if the function `f` applied to `a` is injective (meaning that it produces a unique output for each unique input), then the size (cardinality) of the image of `f` when applied to the singleton set `{a}` and `t` is equal to the size of `t`.

In other words, when an injective function is applied to a singleton set and another set, it will produce a new set with the same number of elements as the second set.
This theorem is essentially asserting a property of injective functions: they preserve the number of distinct elements when mapping from one set to another.

Given an injective function from a set to a finite set and a singleton set, the size of the image of the singleton set equals the size of the target set.


theorem Mathlib.GroupTheory.OrderOfElement._auxLemma.8 :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G}, (orderOf x = 1) = (x = 1) := by sorry

This theorem states that for any type `G` that has a `Monoid` structure, and for any element `x` of type `G`, the order of `x` equals `1` if and only if `x` itself equals the identity `1`. Here the order of an element `x`, denoted by `orderOf x`, corresponds to the smallest natural number `n ≥ 1` such that `x` to the power `n` equals `1`. If no such `n` exists (i.e., if `x` is of infinite order), `orderOf x` is defined to be `0`.

For any monoid `G` and element `x` in `G`, the order of `x` equals 1 if and only if `x` is the identity element of `G`.


theorem add_neg_cancel_comm : ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), a + b + -a = b := by sorry

This theorem states that for any given type `G` which forms an additive commutative group, for any elements `a` and `b` of this group, adding `a` to `b`, then adding the additive inverse of `a`, results in `b`. This essentially shows that adding an element and its negation (in any order, due to commutativity) will cancel out, leaving us with the other element. This is a property related to the additive identity in an additive commutative group.

For any additive commutative group `G` and elements `a, b` in `G`, `a + (-a) = b` if and only if `a = b`.


Group.IsNilpotent.nilpotent

theorem Group.IsNilpotent.nilpotent :
    ∀ (G : Type u_2) [inst : Group G] [inst_1 : Group.IsNilpotent G], ∃ n, upperCentralSeries G n = ⊤ := by sorry

This theorem states that for any group 'G' that is nilpotent (as indicated by `Group.IsNilpotent G`), there exists a natural number 'n' such that the 'n'th term of the upper central series of 'G' is equal to the entire group 'G'. The upper central series of a group is a sequence of normal subgroups, where each subgroup is central in the quotient by the subgroup before it. The theorem is essentially asserting a property of nilpotent groups: they have an upper central series that eventually covers the entire group.

A nilpotent group 'G' has a finite upper central series that equals the whole group.


theorem map_sub_le_add :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : AddGroupSeminormClass F α β] (f : F) (x y : α),
      f (x - y) ≤ f x + f y :=
  by sorry

The theorem `map_sub_le_add` states that for any types `F`, `α`, and `β`, if `F` is a function-like class from `α` to `β`, `α` is an additive group, `β` is an ordered additive commutative monoid, and there exists an additive group seminorm class from `F`, `α`, and `β`, then for any function `f` of type `F` and any elements `x` and `y` of type `α`, the value of `f` applied to the difference of `x` and `y` is less than or equal to the sum of `f` applied to `x` and `f` applied to `y`. In mathematical terms, this states that for all $f: F$, $x, y: α$, $f(x - y) ≤ f(x) + f(y)$.

For any additive group homomorphism $f: F$ from an additive group $\alpha$ to an ordered additive commutative monoid $\beta$ with an additive group seminorm, we have $f(x - y) ≤ f(x) + f(y)$ for all $x, y ∈ α$.


theorem Ideal.IsIntegralClosure.comap_ne_bot :
    ∀ {R : Type u_1} [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S] {A : Type u_3}
      [inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra A S] [inst_6 : IsScalarTower R A S]
      [inst_7 : IsIntegralClosure A R S] [inst_8 : IsDomain A] [inst_9 : Nontrivial R] {I : Ideal A},
      I ≠ ⊥ → Ideal.comap (algebraMap R A) I ≠ ⊥ :=
  by sorry

This theorem states that for any commutative ring `R`, commutative ring `S`, algebra structure from `R` to `S`, type `A` which is a commutative ring and has algebra structures with both `R` and `S`, along with `A` being an integral closure of `R` in `S`, `A` being an integral domain and `R` being nontrivial. Given any ideal `I` of `A` that is not a zero ideal (i.e., `I ≠ ⊥`), the preimage of `I` under the embedding from `R` to `A` (given by the algebra structure, and computed using `Ideal.comap (algebraMap R A) I`) is also not a zero ideal (i.e., `Ideal.comap (algebraMap R A) I ≠ ⊥`).

In simpler terms, if you have an ideal in the integral closure that is not trivial, its "preimage" in the ring `R` (under a certain algebra structure) is also nontrivial.

If `R` is a nontrivial commutative ring, `S` is a commutative ring, `A` is a commutative ring and an integral domain that is an integral closure of `R` in `S`, and `I` is a nonzero ideal of `A`, then the preimage of `I` under the algebra map from `R` to `A` is a nonzero ideal.


Antitone.Ioi

theorem Antitone.Ioi :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f → Monotone fun x => Set.Ioi (f x) :=
  by sorry

The theorem `Antitone.Ioi` states that for all types `α` and `β` that have a preorder (a binary relation that is reflexive and transitive), if there exists an antitone function `f` from `α` to `β`, then the function that maps `x` to the set of all elements in `α` that are strictly greater than `f(x)` is a monotone function. In other words, if `f` is a function that decreases or remains constant as its input increases (antitone), then the function that forms an open interval of values greater than the output of `f` increases or remains constant as its input increases (monotone).

If `f` is an antitone function between preordered types `α` and `β`, then the function mapping each `x` in `α` to the set of elements strictly greater than `f(x)` is monotone.


theorem IsGLB.mem_of_isClosed :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsGLB s a → Set.Nonempty s → IsClosed s → a ∈ s :=
  by sorry

This theorem states that for any type `α` where `α` is a topological space, a linear order, and an order topology, and for any element `a` of type `α` and set `s` of type `α`, if `a` is a greatest lower bound of the set `s`, the set `s` is not empty, and the set `s` is closed, then `a` belongs to the set `s`. In mathematical terms, this theorem asserts that if a set in a topological space has a greatest lower bound and is not empty and closed, then the greatest lower bound is an element of the set.

In a topological space endowed with a linear order and order topology, if a non-empty, closed set has a greatest lower bound, then that bound is an element of the set.


theorem Monotone.leftLim_eq_sSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f →
        ∀ {x : α} [inst_4 : TopologicalSpace α] [inst_5 : OrderTopology α],
          nhdsWithin x (Set.Iio x) ≠ ⊥ → Function.leftLim f x = sSup (f '' Set.Iio x) :=
  by sorry

This theorem states that for every monotone function `f` from a linearly ordered type `α` to a conditionally complete linearly ordered type `β`, both equipped with a topological space structure and an order topology, if the filter of the intersection of the neighborhood within the set of all elements less than `x` and a neighborhood of `x` is not the bottom element, then the left limit of the function `f` at `x` equals the supremum (least upper bound) of the image of the function `f` over the set of all elements less than `x`.

In mathematical terms, if `f` maps each `a ≤ b` to `f a ≤ f b` for all `α` and `β` belonging to the set of real numbers with an order topology, where `x` belongs to `α`, and the intersection of a neighborhood of `x` within the set of numbers less than `x` is not empty, then the left limit of `f` at `x` is equal to the least upper bound of the values of `f` for all inputs less than `x`.

If `f` is a monotone function from a linearly ordered type `α` to a conditionally complete linearly ordered type `β`, both with order topologies, and `x` is in `α` such that the intersection of neighborhoods of `x` and elements less than `x` is non-empty, then the left limit of `f` at `x` equals the supremum of `f` over elements less than `x`.


theorem LieHom.coe_toLinearMap :
    ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
      [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂), ⇑↑f = ⇑f :=
  by sorry

This theorem states that for any commutative ring `R`, Lie rings `L₁` and `L₂`, and Lie algebras over `R` on `L₁` and `L₂`, the coercion (type conversion) of any Lie algebra homomorphism `f` from `L₁` to `L₂` to a linear map is equal to the original Lie algebra homomorphism `f`. In other words, applying the coercion function to `f` doesn't change its behavior.

For any commutative ring `R`, Lie algebra homomorphisms `f` from Lie algebra `L₁` to Lie algebra `L₂` over `R` coerce to the same linear maps.


theorem Configuration.HasLines.pointCount_le_lineCount :
    ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [inst_1 : Configuration.HasLines P L] {p : P} {l : L},
      p ∉ l → ∀ [inst_2 : Finite { l // p ∈ l }], Configuration.pointCount P l ≤ Configuration.lineCount L p :=
  by sorry

The theorem `Configuration.HasLines.pointCount_le_lineCount` states that for every set of points `P` and set of lines `L` with a membership relation, and given a configuration where every point is on at least one line (`Configuration.HasLines P L`), for any particular point `p` and line `l` such that the point `p` is not on the line `l`, as long as the set of lines passing through point `p` is finite, the number of points on line `l` (given by `Configuration.pointCount P l`) is less than or equal to the number of lines through point `p` (given by `Configuration.lineCount L p`). In simple terms, the number of points on any line not passing through a given point is always less than or equal to the number of lines passing through the given point.

For any set of points and lines with a membership relation in a configuration where every point is on at least one line, the number of points on any line not passing through a given point is less than or equal to the number of lines passing through that point.


theorem Fin.contractNth_apply_of_gt :
    ∀ {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n),
      ↑j < ↑k → Fin.contractNth j op g k = g (Fin.succ k) :=
  by sorry

The theorem `Fin.contractNth_apply_of_gt` states that for every natural number `n`, for every type `α`, for every finite ordinal `j` less than or equal to `n`, for every binary operation `op` on `α`, for every function `g` from finite ordinals less than or equal to `n` to `α`, and for every finite ordinal `k` less than `n`, if `j` is less than `k`, then applying the function `Fin.contractNth` with parameters `j`, `op`, `g` and `k` is equal to applying the function `g` to the successor of `k`. In other words, if the index `j` is less than `k`, then the `k`th element after contracting at `j` is just the successor of `k` under the function `g`.

For all natural numbers $n$, types $\alpha$, finite ordinals $j, k$ with $j < k$, binary operations $op$ on $\alpha$, and functions $g$ from finite ordinals less than or equal to $n$ to $\alpha$, the application of `Fin.contractNth` with parameters $j$, $op$, $g$, and $k$ equals the application of $g$ to the successor of $k$.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.20 :
    ∀ {V : Type u} {G : SimpleGraph V} {u : V} (p : SimpleGraph.Walk G u u),
      SimpleGraph.Walk.IsCycle p =
        (SimpleGraph.Walk.IsTrail p ∧ p ≠ SimpleGraph.Walk.nil ∧ List.Nodup (List.tail (SimpleGraph.Walk.support p))) :=
  by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.20`, states that for any given type `V`, a simple graph `G` of type `V`, and a vertex `u` of type `V`, a walk `p` from vertex `u` back to `u` in the graph `G` is a cycle if and only if the walk `p` is a trail (meaning that no edges are repeated), the walk `p` is not an empty walk, and the list of vertices visited in the walk `p` (excluding the first vertex), which is obtained by first getting the support of the walk `p` and then taking the tail of this list, has no duplicate vertices. In other words, a walk in a simple graph is a cycle if it is a trail, it is not an empty walk, and it visits no vertex more than once (except for the starting/ending vertex).

A simple graph walk is a cycle if and only if it is a trail, non-empty, and visits each vertex at most once (excluding the starting/ending vertex).


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.21 :
    ∀ {α : Type u_1} (G : SimpleGraph α) {s : Set α}, SimpleGraph.IsClique G s = (SimpleGraph.induce s G = ⊤) := by
  sorry

This theorem states that for any given type `α`, a simple graph `G` of that type, and a set `s` of that type, the set `s` is a clique in the graph `G` if and only if when the graph `G` is restricted to the vertices in the set `s` (i.e., all edges incident to vertices outside the set are deleted), the resulting graph is a complete graph (denoted by `⊤`). Here, a clique is defined as a set of vertices that are pairwise adjacent, and a complete graph is a simple undirected graph in which every pair of distinct vertices is connected by a unique edge.

A set `s` of type `α` is a clique in the simple graph `G` of type `α` if and only if the subgraph of `G` induced by `s` is a complete graph.


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

The theorem `IsRelPrime.of_add_mul_left_right` states that for all types `R` that have an instance of a commutative semiring, and for all elements `x`, `y`, and `z` of `R`, if `x` and `y + x * z` are relatively prime (meaning that every common divisor of `x` and `y + x * z` is a unit), then `x` and `y` are also relatively prime. This theorem essentially tells us that the relative primality between two elements in a commutative semiring is preserved when adding a multiple of one element to the other.

If `x` and `y + x * z` are relatively prime in a commutative semiring, then `x` and `y` are relatively prime.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.19 :
    ∀ {α : Type u_1} {G : SimpleGraph α} {s : Finset α} [inst : DecidableEq α],
      SimpleGraph.IsNClique G 3 s = ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c} :=
  by sorry

The theorem `Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.19` states that for any type `α`, any Simple Graph `G` of `α`, and any finite set `s` of `α` with decidable equality, the statement that `s` forms a 3-clique in `G` is equivalent to the existence of three distinct elements `a`, `b`, and `c` in `α` such that `a` is adjacent to both `b` and `c`, `b` is also adjacent to `c`, and `s` is the set containing exactly `a`, `b`, and `c`. In graph theory, a 3-clique is a set of three vertices that are all connected to each other.

For any Simple Graph `G` of type `α` and finite decidably-equaled set `s` of `α`, `s` forms a 3-clique in `G` if and only if there exist distinct elements `a, b, c` in `α` such that `a` is adjacent to both `b` and `c`, `b` is adjacent to `c`, and `s = {a, b, c}` .


theorem ENNReal.mul_eq_top : ∀ {a b : ENNReal}, a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0 := by sorry

The theorem `ENNReal.mul_eq_top` states that for all elements `a` and `b` of the set of extended nonnegative real numbers (`ENNReal`), the product `a * b` equals infinity (`⊤`) if and only if either `a` is not equal to zero and `b` equals infinity, or `a` equals infinity and `b` is not equal to zero. This theorem thus characterizes the conditions under which multiplication in the extended nonnegative real numbers results in infinity.

The extended nonnegative real numbers `a * b = ⊤` if and only if `a ≠ 0 ∧ b = ⊤` or `a = ⊤ ∧ b ≠ 0`.


theorem MeasureTheory.set_lintegral_withDensity_eq_set_lintegral_mul_non_measurable₀ :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) {f : α → ENNReal} {s : Set α},
      AEMeasurable f (μ.restrict s) →
        ∀ (g : α → ENNReal),
          MeasurableSet s →
            (∀ᵐ (x : α) ∂μ.restrict s, f x < ⊤) →
              ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ :=
  by sorry

The theorem `MeasureTheory.set_lintegral_withDensity_eq_set_lintegral_mul_non_measurable₀` states that for any type `α` with a measurable space structure `m0`, a measure `μ` on `α`, a function `f` from `α` to the extended nonnegative real numbers, and a set `s` of type `α`, if `f` is almost everywhere measurable with respect to the restriction of `μ` to `s`, then for any function `g` from `α` to the extended nonnegative real numbers, if `s` is a measurable set and `f` is finite almost everywhere with respect to the restriction of `μ` to `s`, the Lebesgue integral over `s` with respect to the measure `μ` with density `f` of `g` is equal to the Lebesgue integral over `s` with respect to `μ` of the product of `f` and `g`. In mathematical notation, this can be written as:
$$
\int_{s} g \, d(\mu \, dx) = \int_{s} (f \, g) \, d\mu
$$
where the integral is the Lebesgue integral, `f` is almost everywhere finite and measurable, `g` is any function from `α` to the extended nonnegative real numbers, `s` is a measurable set, and `μ` is a measure on `α`.

For a measurable space `(α, m0)`, measure `μ`, almost everywhere finite and measurable function `f`, measurable set `s`, and functions `g` and `h = f * g`, the Lebesgue integrals of `g` and `h` with respect to `μ` over `s` are equal: `∫s g dμ = ∫s h dμ`.


theorem Metric.ball_subset_ball :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε₁ ε₂ : ℝ}, ε₁ ≤ ε₂ → Metric.ball x ε₁ ⊆ Metric.ball x ε₂ := by
  sorry

The theorem `Metric.ball_subset_ball` states that for any pseudometric space `α`, any point `x` in `α`, and any two real numbers `ε₁` and `ε₂`, if `ε₁` is less than or equal to `ε₂`, then the metric ball centered at `x` with radius `ε₁` is a subset of the metric ball centered at `x` with radius `ε₂`. In other words, all points that are less than `ε₁` distance away from `x` are also less than `ε₂` distance away from `x` when `ε₁ ≤ ε₂`.

For any pseudometric space and any point in it, the metric ball with a smaller radius is contained in the metric ball with a larger radius.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.37 : ∀ {α : Sort u_1} (a b : α), (¬a = b) = (a ≠ b) := by
  sorry

This theorem states that for any type `α` and any two elements `a` and `b` of this type, the proposition "it is not the case that `a` is equal to `b`" is logically equivalent to " `a` is not equal to `b`". In other words, the logical negation of equality (`¬a = b`) is equivalent to the inequality (`a ≠ b`). This is a basic property of equality in logic.

The logical negation of `a = b` is equivalent to `a ≠ b` for any type `α` and elements `a` and `b` of type `α`.


theorem MeasureTheory.Measure.measure_univ_pos :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, 0 < ↑↑μ Set.univ ↔ μ ≠ 0 := by sorry

This theorem, `MeasureTheory.Measure.measure_univ_pos`, states that for any given type `α`, given measurable space `m0` on `α`, and given measure `μ` on this measurable space, the measure of the universal set (which contains all elements of type `α`) is greater than zero if and only if the measure `μ` is not zero. Essentially, this means that a measure is non-zero if and only if it assigns a positive measure to the set of all possible outcomes.

For any measurable space `(α, m0)` and measure `μ` on `α`, `μ` is non-zero if and only if `μ` assigns positive measure to the universal set `α`.


theorem AdjoinRoot.mk_ne_zero_of_natDegree_lt :
    ∀ {R : Type u} [inst : CommRing R] {f : Polynomial R},
      Polynomial.Monic f →
        ∀ {g : Polynomial R}, g ≠ 0 → Polynomial.natDegree g < Polynomial.natDegree f → (AdjoinRoot.mk f) g ≠ 0 :=
  by sorry

The theorem `AdjoinRoot.mk_ne_zero_of_natDegree_lt` states that for any commutative ring `R` and any monic polynomial `f` of `R`, for any other polynomial `g` of `R` that is not zero and its natural degree is less than the natural degree of `f`, the ring homomorphism from `R[x]` to `AdjoinRoot f` that sends `X` to the root, when applied to `g`, does not result in zero. In other words, applying the said ring homomorphism to any non-zero polynomial of lower degree than a given monic polynomial will not yield zero.

For any commutative ring R, monic polynomial f of R, and non-zero polynomial g of lower degree than f, the evaluation homomorphism from R[x] to the polynomials adjoining a root of f sends g to a non-zero element.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.54 :
    ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ} {s : Finset α},
      (s ∈ SimpleGraph.cliqueSet G n) = SimpleGraph.IsNClique G n s :=
  by sorry

The theorem `Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.54` states that for any type `α`, graph `G` of type `SimpleGraph α`, natural number `n`, and finite set `s` of type `Finset α`, the set `s` is in the `n`-cliques of the graph `G` (i.e., `s ∈ SimpleGraph.cliqueSet G n`) if and only if `s` is an `n`-clique in the graph `G` (i.e., `SimpleGraph.IsNClique G n s`). Essentially, it connects the concept of a set being in the `n`-cliques of a graph to the set being an `n`-clique of the graph.

For any type `α`, graph `G` of type `SimpleGraph α`, natural number `n`, and finite set `s` of type `Finset α`, the set `s` is an `n`-clique in the graph `G` if and only if it is in the set of `n`-cliques of `G`.


theorem Fin.contractNth_apply_of_lt :
    ∀ {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n),
      ↑k < ↑j → Fin.contractNth j op g k = g (Fin.castSucc k) :=
  by sorry

The theorem `Fin.contractNth_apply_of_lt` states that for any natural number `n`, any type `α`, any finite ordinal `j` of the form `Fin (n + 1)`, any binary operation `op` on `α`, any function `g` mapping `Fin (n + 1)` to `α`, and any finite ordinal `k` of the form `Fin n`, if the value of `k` is less than the value of `j`, then applying the function `Fin.contractNth` to `j`, `op`, `g`, and `k` yields the same result as applying `g` to the value obtained by embedding `k` into `Fin (n + 1)` using the function `Fin.castSucc`. In other words, it tells us how the function `Fin.contractNth` behaves when its `k` argument is less than its `j` argument.

For any natural number `n`, any binary operation `op` on type `α`, any function `g : Fin (n + 1) → α`, and any finite ordinals `j : Fin (n + 1)` and `k : Fin n` with `k < j`, `Fin.contractNth j op g k` equals `g (Fin.castSucc k)`.


theorem Finset.erase_injOn' :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), Set.InjOn (fun s => Finset.erase s a) {s | a ∈ s} := by sorry

The theorem `Finset.erase_injOn'` states that for any type `α` with a decidable equality and any element `a` of type `α`, the function that erases `a` from a given finite set is injective on the set of all finite sets that contain `a`. In other words, for any two different finite sets that both contain `a`, after removing `a` from both sets, the resulting sets will also be different.

For any type `α` with decidable equality and any `a` in `α`, the function that removes `a` from a finite set is an injection on the set of all finite sets containing `a`.


theorem Pretrivialization.apply_mk_symm :
    ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      [inst_2 : (x : B) → Zero (E x)] (e : Pretrivialization F Bundle.TotalSpace.proj) {b : B},
      b ∈ e.baseSet → ∀ (y : F), ↑e { proj := b, snd := Pretrivialization.symm e b y } = (b, y) :=
  by sorry

The theorem `Pretrivialization.apply_mk_symm` states that for every topological spaces `B` and `F`, and a family `E` of `zero` types indexed by `B`, given a pretrivialization `e` of the projection from the total space `Bundle.TotalSpace` to `B`, for any point `b` in the base set of `e`, the composition of the embedding `e` and the inverse of `e` at `b` applied to any point `y` in `F` equals the pair `(b, y)`. This essentially means that the pretrivialization and its inverse form an identity on the base set when applied in succession.

For every pretrivialization `e` of a bundle projection to a base space `B`, and for any point `b` in `B` and any point `y` in the fiber `F` over `b`, we have `e (e.inv `b` y) = (b, y)`.


theorem NonUnitalRingHom.coe_srange :
    ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
      {F : Type u_1} [inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] (f : F),
      ↑(NonUnitalRingHom.srange f) = Set.range ⇑f :=
  by sorry

The theorem `NonUnitalRingHom.coe_srange` states that for any non-unital, non-associative semiring `R` and `S`, and any function `f` of type `F` that is a homomorphism between the semirings (`F` is `FunLike` from `R` to `S` and also a `NonUnitalRingHomClass`), the range of the homomorphism `f` when viewed as a subsemiring of `S` (`NonUnitalRingHom.srange f`) is equivalent to the set of all values that `f` can produce (the range of `f` in the ordinary sense, `Set.range ⇑f`). This result connects the algebraic structure (the non-unital subsemiring generated by the image of `f`) with the simpler set-theoretic concept of the range of a function.

The range of a non-unital homomorphism between two non-associative semirings, viewed as a subsemiring in the target semiring, is equal to the image of the homomorphism.


theorem singleton_mul_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E),
      {x} * Metric.closedBall y δ = Metric.closedBall (x * y) δ :=
  by sorry

This theorem, `singleton_mul_closedBall`, states that for any type `E` which has an instance of a `SeminormedCommGroup`, any real number `δ`, and any two elements `x` and `y` of `E`, the set multiplication of the singleton set `{x}` and the closed ball centered at `y` with radius `δ` (which is the set of all points at a distance `≤ δ` from `y`) is equal to the closed ball centered at `x * y` with radius `δ`. In other words, scaling and shifting the points within the `δ`-radius ball around `y` by a factor of `x` gives us the same set of points as in the `δ`-radius ball around `x * y`.

For any type `E` with a `SeminormedCommGroup` instance, and for all `x`, `y` in `E` and `δ` in `ℝ`, the set `{x} * ℯ_(δ)(y)` equals `ℯ_(δ)(x * y)`, where `ℯ_(δ)` denotes the closed ball with radius `δ` around a point.


Set.InjOn.comp

theorem Set.InjOn.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} {f : α → β} {g : β → γ},
      Set.InjOn g t → Set.InjOn f s → Set.MapsTo f s t → Set.InjOn (g ∘ f) s :=
  by sorry

The theorem `Set.InjOn.comp` states that for all types `α`, `β`, and `γ`, and for all sets `s` of `α` and `t` of `β`, if a function `g` from `β` to `γ` is injective on `t`, a function `f` from `α` to `β` is injective on `s`, and the image of `s` under `f` is contained in `t` (i.e., `f` maps `s` to `t`), then the composition of `g` and `f`, `g ∘ f`, is injective on `s`. In other words, the injectivity of individual functions and their mapping properties allow us to conclude the injectivity of their composition.

If `f` maps a set `s` to a subset `t` of its image under an injective function `g`, and `f` and `g` are injective, then their composition `g ∘ f` is injective on `s`.


theorem Filter.comap_iSup :
    ∀ {α : Type u} {β : Type v} {ι : Sort u_2} {f : ι → Filter β} {m : α → β},
      Filter.comap m (iSup f) = ⨆ i, Filter.comap m (f i) :=
  by sorry

This theorem states that for any types `α`, `β`, and an indexed set `ι`, given a function `f` from `ι` to the set of filters on `β` and a function `m` from `α` to `β`, the filter obtained by applying the function `m` to the indexed supremum of the filter function `f` (`Filter.comap m (iSup f)`) is equal to the supremum of the filters obtained by applying the function `m` to each filter in the range of `f` (`⨆ i, Filter.comap m (f i)`). This is essentially distributing the comap operation over the supremum of filters.

For any types `α`, `β`, indexed set `ι`, function `f` from `ι` to filters on `β`, and function `m` from `α` to `β`, `Filter.comap m (iSup f)` is equal to `⨆ i, Filter.comap m (f i)`.


theorem Mathlib.Data.Finset.Image._auxLemma.17 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem, named as `Mathlib.Data.Finset.Image._auxLemma.17`, states that for any three propositions `a`, `b`, and `c`, the statement "`a` and `b` imply `c`" is equivalent to the statement "`a` implies that `b` implies `c`". In other words, if `a` and `b` are true, then `c` must be true is the same as saying that if `a` is true, then if `b` is also true, `c` must be true. This is a fundamental concept in propositional logic.

The theorem `Mathlib.Data.Finset.Image._auxLemma.17` in Lean 4 states that the implication "`a` implies `b` implies `c`" is logically equivalent to "`a` and `b` imply `c`".


Convex.isPathConnected

/-- A nonempty convex set is path connected.  -/
theorem Convex.isPathConnected :
    ∀ {E : Type u_3} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E]
      [inst_3 : TopologicalAddGroup E] [inst_4 : ContinuousSMul ℝ E] {s : Set E},
      Convex ℝ s → Set.Nonempty s → IsPathConnected s :=
  by sorry

The theorem `Convex.isPathConnected` states that for any type `E`, given that `E` has the structure of an additive commutative group, a module over the reals, a topological space, a topological additive group, and that scalar multiplication is continuous, if `s` is a set of `E` with the property that it is convex and nonempty, then `s` is also path connected. In other words, for a nonempty set `s` in a real vector space that is convex, there exists a point in `s` that can be joined to all other points in `s` through a path that remains within `s`.

In a real vector space endowed with the structure of an additive commutative group, a topological space, and a topological additive group, where scalar multiplication is continuous, every nonempty convex set is path connected.


theorem Mathlib.Combinatorics.SetFamily.Shatter._auxLemma.5 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α},
      (s ∈ Finset.shatterer 𝒜) = Finset.Shatters 𝒜 s :=
  by sorry

The theorem `Mathlib.Combinatorics.SetFamily.Shatter._auxLemma.5` states that for any type `α` with decidable equality, any set family `𝒜` (a `Finset` of `Finset α`), and any set `s` (a `Finset α`), `s` is part of the set family that is shattered by `𝒜` (i.e., `s` is in `Finset.shatterer 𝒜`) if and only if `𝒜` shatters `s` (denoted as `Finset.Shatters 𝒜 s`). Here, `𝒜` shatters `s` means that for every subset `t` of `s`, there exists an element `u` in `𝒜` such that the intersection of `s` and `u` equals `t`. This theorem essentially links the concept of a set being in the shattered set family of `𝒜` with the property of `𝒜` shattering `s`.

A set `s` is in the shattered set family of a set family `𝒜` if and only if `𝒜` shatters `s`, i.e., for every subset `t` of `s`, there exists an element `u` in `𝒜` such that `s ∩ u = t`.


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

This theorem, `Mathlib.Data.Finset.Image._auxLemma.21`, states that for any two natural numbers `n` and `m`, the membership of `m` in the set `Finset.range n` is equivalent to the condition that `m` is less than `n`. In other words, `m` belongs to the set of natural numbers less than `n` if and only if `m` is strictly less than `n`.

For any natural numbers `n` and `m`, `m` belongs to the finite set of natural numbers `{i : Nat | i < n}` if and only if `m` is strictly less than `n`.


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

The theorem `AddSubmonoid.LocalizationMap.mk'_spec` states that for any given localization map `f` from an additive commutative monoid `M` to another `N` with respect to a submonoid `S` of `M`, and for any element `x` in `M` and `y` in `S`, the sum of the result of applying the function `mk'` on `f`, `x`, and `y` and the result of applying the function `toMap` on `f` and `y` is equal to the result of applying the function `toMap` on `f` and `x`. In mathematical terms, this can be written as `f(x - y) + f(y) = f(x)`, where `f` is the localization map.

For any localization map `f` from an additive commutative monoid `M` to another `N` with respect to a submonoid `S` of `M`, and for all `x` in `M` and `y` in `S`, we have `f(x - y) = f(x) - f(y)`.


theorem RingHom.map_multiset_prod :
    ∀ {β : Type u_4} {γ : Type u_5} [inst : CommSemiring β] [inst_1 : CommSemiring γ] (f : β →+* γ) (s : Multiset β),
      f (Multiset.prod s) = Multiset.prod (Multiset.map (⇑f) s) :=
  by sorry

This theorem states that for any commutative semiring types `β` and `γ`, and for any ring homomorphism `f` from `β` to `γ`, and any multiset `s` of `β`, the image of the product of the multiset `s` under the function `f` is equal to the product of the multiset obtained by mapping each element of `s` via `f`. In terms of algebra, it says that ring homomorphisms preserve the product of elements in a multiset, i.e., applying a ring homomorphism to the product of elements in a multiset is the same as first applying the ring homomorphism to each element and then taking the product.

For any commutative semirings `β` and `γ`, and any ring homomorphism `f` from `β` to `γ`, the product of `f` applied to the multiset `s` in `β` is equal to the multiset product of `f(x)` for all `x` in `s`.


theorem Mathlib.Data.Finset.Image._auxLemma.32 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α}, f '' ↑s = ↑(Finset.image f s) :=
  by sorry

This theorem establishes that for any two types `α` and `β` where `β` has a decidable equality, and for any function `f` mapping `α` to `β` and any finite set `s` of type `α`, the image of `s` under the function `f` (denoted as `f '' ↑s`) is equal to the forward image of `s` under `f` converted to a set (denoted as `↑(Finset.image f s)`). In other words, applying `f` to each element of the set `s` produces the same result whether you treat `s` as a finite set or as a general set.

For any function `f` from type `α` to decidably equal types `β`, and any finite set `s` of type `α`, `f '' ↑s` equals `↑(Finset.image f s)`.


theorem Mathlib.Data.Finset.Image._auxLemma.42 : ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) := by sorry

This theorem, `Mathlib.Data.Finset.Image._auxLemma.42`, states that for all types `α` and for all elements `a` and `b` of that type, `b` is an element of the singleton set `{a}` if and only if `b` is equal to `a`. In other words, in the context of sets, an element `b` belongs to a set that only contains `a` if `b` is identical to `a`.

For any type `α` and elements `a, b` of `α`, `b` is in the singleton set `{a}` if and only if `a = b`.


theorem Mathlib.Data.Finset.Image._auxLemma.59 :
    ∀ {n : ℕ} {s : Finset ℕ} (a : Fin n), (a ∈ Finset.fin n s) = (↑a ∈ s) := by sorry

This theorem states that for any natural number `n`, any finite set `s` of natural numbers, and any natural number `a` less than `n`, `a` is an element of the set obtained by taking all elements of `s` that are less than `n` if and only if the natural number corresponding to `a` is an element of `s`. In other words, the operation of getting all elements of `s` less than `n` preserves membership: an element belongs to the resultant set if and only if it belongs to the original set.

For any natural number `n`, set `s` of natural numbers, and natural number `a` less than `n`, `a` is an element of the set of natural numbers in `s` less than `n` if and only if `a` is an element of `s`.


theorem Homotopy.homologyMap_eq :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
      {ι : Type u_3} {c : ComplexShape ι} [inst_2 : DecidableRel c.Rel] {K L : HomologicalComplex C c} {f g : K ⟶ L},
      Homotopy f g →
        ∀ (i : ι) [inst_3 : HomologicalComplex.HasHomology K i] [inst_4 : HomologicalComplex.HasHomology L i],
          HomologicalComplex.homologyMap f i = HomologicalComplex.homologyMap g i :=
  by sorry

The theorem `Homotopy.homologyMap_eq` states that for any two homological complexes `K` and `L` in a category `C` with a complex shape `c`, if there exists a homotopy between two chain maps `f` and `g` from `K` to `L`, then for any degree `i` where `K` and `L` both have homology, the homology map of `f` at degree `i` is equal to the homology map of `g` at degree `i`. This theorem demonstrates the invariance of the homology maps under homotopy.

If two chain maps between complexes in a category with homology have a homotopy between them, then they have equal homology maps for all degrees where both complexes have homology.


theorem Rat.exists_eq_mul_div_num_and_eq_mul_div_den :
    ∀ (n : ℤ) {d : ℤ}, d ≠ 0 → ∃ c, n = c * (↑n / ↑d).num ∧ d = c * ↑(↑n / ↑d).den := by sorry

This theorem states that for any integer `n` and any non-zero integer `d`, there exists an integer `c` such that `n` equals `c` times the numerator of the rational number `n/d`, and `d` equals `c` times the denominator of this rational number. In other words, it shows that `n` and `d` can be expressed as multiples of the respective parts of the fraction `n/d`.

For any integer `n` and non-zero integer `d`, there exist integers `c` such that `n = c * (numerator (nat_num_div n d)` and `d = c * (denominator (nat_num_div n d))`.


theorem Hyperreal.coe_le_coe : ∀ {x y : ℝ}, ↑x ≤ ↑y ↔ x ≤ y := by sorry

This theorem establishes the relationship between the order of real numbers and their corresponding hyperreal numbers. Specifically, it states that for all real numbers 'x' and 'y', 'x' is less than or equal to 'y' if and only if the hyperreal number corresponding to 'x' is less than or equal to the hyperreal number corresponding to 'y'. In other words, the order is preserved when real numbers are embedded into the hyperreal numbers.

For all real numbers x and y, x ≤ y if and only if x��uld ≤ y��uld, where x��uld and y��uld denote the hyperreal numbers corresponding to x and y, respectively.


theorem Multiset.bind_zero : ∀ {α : Type u_1} {β : Type v} (s : Multiset α), (Multiset.bind s fun x => 0) = 0 := by
  sorry

The theorem `Multiset.bind_zero` states that for any multiset `s` of elements from some type `α`, if we bind `s` with a function that sends every element of `s` to the zero multiset, the result is the zero multiset. This is equivalent to saying that mapping every element of a multiset to an empty multiset and then flattening results in an empty multiset.

For any multiset `s` over type `α`, the flattened result of binding each element of `s` to the zero multiset is the zero multiset.


theorem FreeAbelianGroup.map_add :
    ∀ {α β : Type u} (f : α → β) (x y : FreeAbelianGroup α), f <$> (x + y) = f <$> x + f <$> y := by sorry

The `FreeAbelianGroup.map_add` theorem states that for any types `α` and `β`, and a function `f` from `α` to `β`, the action of `f` on the sum of two elements `x` and `y` in the free abelian group over `α` is the same as the sum of the action of `f` on `x` and `y` separately. In other words, this theorem shows that the function `f` preserves the addition operation when mapped over elements in the free abelian group, a property known as additivity. This could be expressed in mathematical notation as follows: for all `f : α → β` and `x, y` in the free abelian group on `α`, `f(x + y) = f(x) + f(y)`.

For any function `f` from a type `α` to a type `β` and any elements `x, y` in the free abelian group on `α`, `f(x + y) = f(x) + f(y)`.