theorem Mathlib.Algebra.Function.Indicator._auxLemma.4 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {x : α}, (x ∈ Function.mulSupport f) = (f x ≠ 1) := by
  sorry

This theorem states that for any type `α` and `M`, where `M` is a type with a specified multiplicative identity, and any function `f` from `α` to `M`, along with any element `x` of type `α`, the element `x` belongs to the `mulSupport` of the function `f` if and only if the value of function `f` at `x` is not equal to the multiplicative identity, which is `1`. In other words, the `mulSupport` of a function `f` is precisely the set of points `x` where `f(x)` is different from the identity element `1`.

For any type `α` and `M` with multiplicative identity, and any function `f` from `α` to `M`, the element `x` in `α` is in the `mulSupport` of `f` if and only if `f(x) ≠ 1`.


theorem continuous_of_le_add_edist :
    ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {f : α → ENNReal} (C : ENNReal),
      C ≠ ⊤ → (∀ (x y : α), f x ≤ f y + C * edist x y) → Continuous f :=
  by sorry

This theorem states that for any type 'α' that is a pseudo emetric space and a function 'f' that maps from 'α' to the extended nonnegative real numbers (ENNReal), if there exists a value 'C' in ENNReal where 'C' is not equal to infinity (∞) and for every pair (x, y) in 'α', the value of f at 'x' is less than or equal to the value of f at 'y' plus 'C' times the extended distance between 'x' and 'y', then the function 'f' is continuous. This is a condition of continuity of 'f' in terms of bounds involving the extended distance and some constant factor 'C'.

If 'α' is a pseudo metric space, 'f' : 'α' -> ENNReal is a function with 'C' in ENNReal such that for all x, y in 'α', f(x) ≤ f(y) + C · d(x, y), then 'f' is continuous.


/-- Reorder a sum.

The difference with `Finset.sum_bij` is that the bijection is specified with an inverse, rather than
as a surjective injection.

The difference with `Finset.sum_nbij'` is that the bijection and its inverse are allowed to use
membership of the domains of the sums, rather than being non-dependent functions. -/
theorem Finset.sum_bij' :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
      (hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
      (∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
        (∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) →
          (∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) → (Finset.sum s fun x => f x) = Finset.sum t fun x => g x :=
  by sorry

This theorem, named `Finset.sum_bij'`, states that for two finite sets `s` and `t` with elements of type `ι` and `κ` respectively, and two functions `f : ι → α` and `g : κ → α` where `α` is a type with an additive commutative monoid structure, if there exist functions `i : ι → κ` and `j : κ → ι` that form a bijection between elements of `s` and `t` (taking into account their membership in `s` and `t`), and if for each element `a` in `s`, `f a` equals `g` of the image of `a` under `i`, then the sum of `f` over all elements of `s` equals the sum of `g` over all elements of `t`.

In simpler terms, you can rearrange the elements of a finite sum without changing the total, as long as you have a function that correctly maps elements from one set to another and vice versa, preserving the behavior of the original functions under the sum.

Given finite sets `s` and `t` with types `ι` and `κ`, functions `f : ι → α` and `g : κ → α` on an additive commutative monoid `α`, and bijections `i : ι ↔ κ` and `j : κ ↔ ι` between their elements, if `f a = g (i a)` for all `a ∈ s`, then `∑ i in s, f i = ∑ j in t, g j`.


theorem LinearMap.toMatrix'_id :
    ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_5} [inst_1 : DecidableEq n] [inst_2 : Fintype n],
      LinearMap.toMatrix' LinearMap.id = 1 :=
  by sorry

The theorem `LinearMap.toMatrix'_id` states that for any commutative semiring `R` and any type `n` with decidable equality and finiteness, when the identity linear map (which maps each element to itself) is converted to a matrix using the `LinearMap.toMatrix'` function, the resulting matrix is the identity matrix (each diagonal element is 1 and off-diagonal elements are 0). This means that the matrix representation of the identity linear map is indeed the identity matrix, which is consistent with linear algebra theory.

For any commutative semiring R and type n with decidable equality and finiteness, the matrix representation of the identity linear map is the identity matrix.


theorem antivary_inv_right₀ :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedSemifield α] [inst_1 : LinearOrderedSemifield β]
      {f : ι → α} {g : ι → β}, StrongLT 0 g → (Antivary f g⁻¹ ↔ Monovary f g) :=
  by sorry

The theorem `antivary_inv_right₀` states that for any given types `ι`, `α`, and `β`, where `α` and `β` are both linear ordered semifields, and any given functions `f : ι → α` and `g : ι → β`, if the function `g` is strongly greater than the zero function (i.e., `g(i) > 0` for all `i`), then `f` antivaries with the inverse of `g` if and only if `f` monovaries with `g`. In other words, if all values of `g` are positive, then `f` decreases as the inverse of `g` increases if and only if `f` increases as `g` increases.

For functions \(f : ι \to α\) and \(g : ι \to β\) over linearly ordered semifields \(α\) and \(β\), if \(g(i) > 0\) for all \(i\), then \(f\) antivaries with the inverse of \(g\) if and only if \(f\) monovaries with \(g\).


/-- See also `Filter.blimsup_or_eq_sup`.  -/
theorem Filter.blimsup_sup_le_or :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {p q : β → Prop} {u : β → α},
      Filter.blimsup u f p ⊔ Filter.blimsup u f q ≤ Filter.blimsup u f fun x => p x ∨ q x :=
  by sorry

The theorem `Filter.blimsup_sup_le_or` states that for any type `α` with a complete lattice structure, a function `u` from a type `β` to `α`, a filter `f` of `β`, and predicates `p` and `q` on `β`, the supremum of the bounded limit superior of function `u` along filter `f` bounded by predicate `p` and the bounded limit superior of function `u` along filter `f` bounded by predicate `q` is less than or equal to the bounded limit superior of function `u` along filter `f` bounded by a predicate that holds if either `p` or `q` holds. In mathematical terms, it can be written as `blimsup u f p ⊔ blimsup u f q ≤ blimsup u f (p ∨ q)`.

For any complete lattice `α` and filter `f` on a type `β`, the bounded limit superior of a function `u` from `β` to `α` along `f` bounded by predicates `p` and `q` satisfies `blimsup u f p ⊔ blimsup u f q ≤ blimsup u f (p ∨ q)`.


theorem Antitone.map_min :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {a b : α},
      Antitone f → f (min a b) = max (f a) (f b) :=
  by sorry

The theorem `Antitone.map_min` states that for any two types `α` and `β` with a linear order, given an antitone function `f` from `α` to `β` and any two elements `a` and `b` of type `α`, the result of applying `f` to the minimum of `a` and `b` is equal to the maximum of the results of applying `f` to `a` and `b` individually. In other words, if `f` is a function that preserves the order in the opposite direction, then applying `f` switches the roles of `min` and `max`.

For any antitone function $f$ between linearly ordered types $\alpha$ and $\beta$, and any $a, b \in \alpha$, we have $f(\min(a, b)) = \max(f(a), f(b))$.


theorem MeasurableSpace.generateFrom_induction :
    ∀ {α : Type u_1} (p : Set α → Prop) (C : Set (Set α)),
      (∀ t ∈ C, p t) →
        p ∅ →
          (∀ (t : Set α), p t → p tᶜ) →
            (∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)) → ∀ {s : Set α}, MeasurableSet s → p s :=
  by sorry

This theorem is about the properties of a measurable set in the measurable space. It's named `MeasurableSpace.generateFrom_induction` and it states that for any type `α`, any property `p` of sets of `α`, and any collection `C` of sets of `α`, if all elements in `C` have the property `p`, the empty set has the property `p`, the complement of any set having property `p` also has the property `p`, and any countable union of sets having the property `p` also has the property `p`, then any measurable set also has the property `p`. This implies that the property `p` is preserved under these operations common in measure theory, and that measurable sets are the smallest class of sets closed under these operations.

If a collection of sets in a measurable space is closed under the operations of emptiness, complement, and countable union, then any measurable set belongs to this collection.


theorem MonoidWithZeroHom.map_mul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f : α →*₀ β) (a b : α),
      f (a * b) = f a * f b :=
  by sorry

This theorem states that for any two types `α` and `β` that are instances of the `MulZeroOneClass` (which means they support multiplication, have a zero element, and have a one element), any monoid homomorphism with zero `f` from `α` to `β` preserves multiplication. In other words, if `a` and `b` are elements of `α`, then the image of the product `a * b` under `f` is the product of the images of `a` and `b` under `f`. This is a property that characterizes monoid homomorphisms in mathematics, specifically those that also map the zero of the source structure to the zero of the target structure.

For any monoid homomorphisms f between MulZeroOneClasses α and β, a * b maps to f a * f b, where a, b are elements of α and * denotes multiplication.


theorem Set.nontrivial_univ : ∀ {α : Type u} [inst : Nontrivial α], Set.Nontrivial Set.univ := by sorry

This theorem states that for any type `α` that is non-trivial (meaning it has at least two distinct elements), the universal set of `α` (which includes all elements of `α`) is also non-trivial. In other words, if a type has at least two distinct elements, then the set containing all elements of this type also has at least two distinct elements.

If `α` is a non-empty type with at least two distinct elements, then the universal set of `α` also has at least two distinct elements.


theorem edist_triangle4 :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (x y z t : α), edist x t ≤ edist x y + edist y z + edist z t := by
  sorry

This theorem, `edist_triangle4`, states that for any type `α` that is an instance of `PseudoEMetricSpace` (a structure denoting a set equipped with an extended distance function that satisfies certain properties), and for any four elements `x`, `y`, `z`, and `t` of this type, the extended distance between `x` and `t` is always less than or equal to the sum of the extended distances between `x` and `y`, `y` and `z`, and `z` and `t`. This is a generalization of the triangle inequality in the context of pseudo extended metric spaces.

For any pseudo-metric space `(α, d)`, and any elements `x, y, z, t` in `α`, the extended distance `d(x, t)` is less than or equal to the sum of the extended distances `d(x, y)`, `d(y, z)`, and `d(z, t)`.


theorem Commute.zpow_right₀ :
    ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {a b : G₀}, Commute a b → ∀ (m : ℤ), Commute a (b ^ m) := by sorry

This theorem states that for any two elements `a` and `b` of a group with zero (`G₀`), if `a` and `b` commute (i.e., `a * b = b * a`), then `a` commutes with any integer power of `b` (i.e., `a * b^m = b^m * a` for any integer `m`). In other words, the commutativity property is preserved under exponentiation with an integer.

If `a` and `b` are elements of a group with zero that commute, then `a` commutes with any integer power of `b`. In other words, `a * b^m = b^m * a` for all integers `m`.


theorem StarSubalgebra.algebraMap_mem :
    ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) (r : R),
      (algebraMap R A) r ∈ S :=
  by sorry

The theorem `StarSubalgebra.algebraMap_mem` states that for any commutative semiring `R`, any star ring `R`, any semiring `A`, any star ring `A`, any algebra structure between `R` and `A`, any star module structure between `R` and `A`, any star subalgebra `S` of `A` over `R`, and any element `r` of `R`, the result of applying the algebra map (which is an embedding from `R` to `A` given by the algebra structure) to `r` is always an element of the star subalgebra `S`.

For any commutative semirings R and A, star rings R and A, algebra structures between R and A, star module structures between R and A, star subalgebras S of A over R, and element r in R, the algebra map embedding R into A maps r to an element in S.


theorem eq_inv_of_mul_eq_one_right : ∀ {α : Type u_1} [inst : DivisionMonoid α] {a b : α}, a * b = 1 → b = a⁻¹ := by
  sorry

This theorem states that for any type `α` which forms a division monoid and any elements `a` and `b` of `α`, if `a` multiplied by `b` equals 1, then `b` is equal to the multiplicative inverse of `a`. Simply put, it's a property of division monoids (structures with multiplication, 1 and inversion where multiplication is associative and each element has an inverse) that when a product of two elements equals the identity element (1), the second element must be the inverse of the first.

In a division monoid, if the product of two elements is the identity, then they are multiplicative inverses.


theorem Function.update_eq_const_of_subsingleton :
    ∀ {α : Sort u} {α' : Sort w} [inst : DecidableEq α] [inst_1 : Subsingleton α] (a : α) (v : α') (f : α → α'),
      Function.update f a v = Function.const α v :=
  by sorry

This theorem, named `Function.update_eq_const_of_subsingleton`, states that for any types `α` and `α'` with equality on `α` being decidable, if `α` is a subsingleton type (a type with at most one element), then the function `f : α → α'` updated at any point `a : α` to a value `v : α'` is equivalent to the constant function with value `v`. In other words, if there is at most one possible input to a function, updating the function at that input doesn't change the overall function; it just results in a constant function.

For any type `α` with decidable equality and being a subsingleton, the function `f : α → α'` is equal to the constant function `Const v : α → α'` for any `v : α'`.


theorem Matrix.vecMul_injective_iff_isUnit :
    ∀ {m : Type u} [inst : DecidableEq m] {K : Type u_3} [inst_1 : Field K] [inst_2 : Fintype m] {A : Matrix m m K},
      (Function.Injective fun v => Matrix.vecMul v A) ↔ IsUnit A :=
  by sorry

This theorem states that for any type `m` with decidable equality, any field `K`, and any finite type `m`, a matrix `A` of type `Matrix m m K` is such that the function which multiplies a vector `v` with `A` is injective if and only if `A` is a unit in the monoid of matrices. In other words, the function that multiplies a vector `v` by `A` is injective (meaning no two distinct vectors produce the same result when multiplied by `A`) if and only if `A` has an inverse in the multiplication of matrices (i.e., `A` is a unit in the monoid of matrices).

For any decidably equal type `m`, field `K`, and finite `m`-by-`m` matrix `A` over `K`, the multiplication function `x ↦ Ax` is injective if and only if `A` has an inverse in the monoid of `m`-by-`m` matrices over `K`.


theorem CategoryTheory.ShortComplex.LeftHomologyMapData.homologyMap_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) {h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂)
      [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁] [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂],
      CategoryTheory.ShortComplex.homologyMap φ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.homologyIso h₁).hom
          (CategoryTheory.CategoryStruct.comp γ.φH (CategoryTheory.ShortComplex.LeftHomologyData.homologyIso h₂).inv) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.LeftHomologyMapData.homologyMap_eq` asserts that for any category `C` with zero morphisms, given two short complexes `S₁` and `S₂` in `C` and a morphism `φ` from `S₁` to `S₂`, and assuming `S₁` and `S₂` both have a left homology, then the homology map of `φ` is equal to the composition of the homomorphism of the homology isomorphism of `h₁`, the morphism `φH` of the left homology map data `γ`, and the inverse of the homology isomorphism of `h₂`, where `h₁` and `h₂` are the left homology data of `S₁` and `S₂` respectively. In other words, the theorem describes a specific commutative diagram in the context of short complexes in a category.

Given two short complexes in a category with zero morphisms and a morphism between them, if both complexes have defined left homologies, then the homology map of the morphism is equal to the composition of the inverse of the left homology isomorphism of the target complex, the morphism itself, and the left homology isomorphism of the source complex.


theorem Submodule.mem_set_smul_def :
    ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] {S : Type u_4} [inst_1 : Monoid S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : DistribMulAction S M] (s : Set S) (N : Submodule R M) (x : M),
      x ∈ s • N ↔ x ∈ sInf {p | ∀ ⦃r : S⦄ {n : M}, r ∈ s → n ∈ N → r • n ∈ p} :=
  by sorry

The theorem `Submodule.mem_set_smul_def` states that for any type `R` being a semiring, `M` a commutative additive monoid forming a module over `R`, and `S` a monoid acting distributively on `M`, along with a set `s` of type `S`, a submodule `N` of `M`, and an element `x` of `M`, `x` is in the scalar multiplication of the set `s` and the submodule `N` if and only if `x` is in the infimum of the set of properties `p` such that for any element `r` of `S` and any element `n` of `M`, if `r` is in the set `s` and `n` is in the submodule `N`, then the scalar product of `r` and `n` is in `p`.

For any semiring R, commutative additive monoid M making an R-module, monoid S acting distributively on M, set s of S, submodule N of M, and element x of M, x belongs to the scalar multiplication of set s and submodule N if and only if x is in the infimum of the set of properties p such that for all r in s and n in N, r * n is in p.


theorem mul_nonneg_iff_pos_imp_nonneg :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α} [inst_1 : ExistsAddOfLE α],
      0 ≤ a * b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) :=
  by sorry

This theorem states that for any type `α` which is a `LinearOrderedSemiring` and for any elements `a` and `b` of this type, the product `a * b` is non-negative if and only if the following two conditions are met: if `a` is positive then `b` is non-negative, and if `b` is positive then `a` is non-negative. Here, `LinearOrderedSemiring` is a mathematical structure with addition, multiplication, and an ordering that is compatible with these operations. The theorem requires the existence of an additive operation that can be applied when one element is less than or equal to another.

For any `LinearOrderedSemiring` type `α` and elements `a, b` of `α`, the product `a * b` is non-negative if and only if `a` is non-negative when `b` is, and `b` is non-negative when `a` is.


/-- A positive multiple of a vector is in the same ray as that vector.  -/
theorem SameRay.sameRay_pos_smul_left :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {S : Type u_5} [inst_3 : OrderedCommSemiring S] [inst_4 : Algebra S R] [inst_5 : Module S M]
      [inst_6 : SMulPosMono S R] [inst_7 : IsScalarTower S R M] {a : S} (v : M), 0 < a → SameRay R (a • v) v :=
  by sorry

This theorem states that, for any strictly ordered commutative semiring `R`, additively commutative monoid `M`, ordered commutative semiring `S`, given an algebra from `S` to `R` and a module structure of `M` over `S` and `R`, with positivity-preserving scalar multiplication and scalar tower properties, if `a` is a positive element of `S` and `v` is a vector in `M`, then `a • v` (which means `a` times `v`) and `v` are in the same ray. In simpler terms, multiplying a vector by a positive scalar does not change the 'direction' of the vector, as per the definition of "SameRay".

For any commutative semirings `R` and `S`, additively commutative monoid `M`, and positive element `a` in `S`, if `a` acts multiplicatively as an algebra homomorphism from `S` to `R`, `M` is an `S`-module and `R`-module with positivity-preserving scalar multiplication and scalar tower properties, then for all `v` in `M`, `a • v` and `v` are in the same ray.


theorem MeasureTheory.IsStoppingTime.measurableSet_min_iff :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ π : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) (hπ : MeasureTheory.IsStoppingTime f π) (s : Set Ω),
      MeasurableSet s ↔ MeasurableSet s ∧ MeasurableSet s :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_min_iff` states that for any types `Ω` and `ι`, a `MeasurableSpace Ω` named `m`, a `LinearOrder` on `ι`, a filtration `f` of type `MeasureTheory.Filtration ι m`, and two functions `τ` and `π` from `Ω` to `ι` such that both `τ` and `π` are stopping times with respect to the filtration `f`, and any set `s` of type `Set Ω`, `s` is a measurable set if and only if both `s` and `s` are measurable sets. Clearly, this statement is a tautology as it states that `s` is measurable if and only if `s` is measurable.

For any measurable space `(Ω, m)`, filtration `f`, and stopping times `τ` and `π` on `Ω` with respect to `f`, if two sets `s` are measurable with respect to `(Ω, m)` and `f`, then `s` and `τ^{-1}[min τ(s)] = π^{-1}[min π(s)]` have the same measurability.


theorem SetTheory.PGame.neg_equiv_iff : ∀ {x y : SetTheory.PGame}, -x ≈ y ↔ x ≈ -y := by sorry

This theorem states that for any two games `x` and `y` in Set Theory, the negation of `x` is equivalent to `y` if and only if `x` is equivalent to the negation of `y`. Here, `≈` represents the equivalence of games in set theory and `-` represents the negation of a game.

For any games x and y in Set Theory, x ≈ y if and only if -x ≈ -y.


theorem ENat.succ_def : ∀ (m : ℕ∞), Order.succ m = m + 1 := by sorry

This theorem states that for any extended natural number `m` (expressed as `m : ℕ∞`), the successor of `m` under the defined order (`Order.succ m`) is equivalent to the sum of `m` and 1 (`m + 1`). In other words, the successor of any extended natural number is simply that number increased by one.

For any extended natural number `m`, `Order.succ m` is equivalent to `m + 1`.


MeasureTheory.SimpleFunc.induction

/-- To prove something for an arbitrary simple function, it suffices to show
that the property holds for (multiples of) characteristic functions and is closed under
addition (of functions with disjoint support).

It is possible to make the hypotheses in `h_add` a bit stronger, and such conditions can be added
once we need them (for example it is only necessary to consider the case where `g` is a multiple
of a characteristic function, and that this multiple doesn't appear in the image of `f`)  -/
theorem MeasureTheory.SimpleFunc.induction :
    ∀ {α : Type u_5} {γ : Type u_6} [inst : MeasurableSpace α] [inst_1 : AddMonoid γ]
      {P : MeasureTheory.SimpleFunc α γ → Prop},
      (∀ (c : γ) {s : Set α} (hs : MeasurableSet s),
          P
            (MeasureTheory.SimpleFunc.piecewise s hs (MeasureTheory.SimpleFunc.const α c)
              (MeasureTheory.SimpleFunc.const α 0))) →
        (∀ ⦃f g : MeasureTheory.SimpleFunc α γ⦄,
            Disjoint (Function.support ↑f) (Function.support ↑g) → P f → P g → P (f + g)) →
          ∀ (f : MeasureTheory.SimpleFunc α γ), P f :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.induction` states that to prove a property for an arbitrary simple function, it is sufficient to show two things:

1. The property holds for simple functions that are multiples of characteristic functions. A characteristic function takes a measurable set and its measureability, along with some constant, and gives a simple function. This function is zero elsewhere but equals to the given constant on the provided set.

2. The property is closed under addition, that is, if the property holds for two simple functions whose supports (sets where the function is non-zero) are disjoint, then it also holds for the function obtained by adding these two functions.

To put it more formally, let `α` be a type with a measurable space structure, and let `γ` be a type with an addition monoid structure. If `P` is a property on simple functions from `α` to `γ`, then to prove that `P` holds for all simple functions, it is enough to show that `P` holds for simple functions that are multiples of characteristic functions, and that whenever `f` and `g` are simple functions with disjoint supports and `P` holds for `f` and `g`, then `P` also holds for `f + g`.

To prove a property holds for all simple functions from a measurable space to an additive monoid, it suffices if it holds for simple functions that are multiples of characteristic functions and for the sum of two such functions with disjoint supports.


theorem BoxIntegral.Box.monotone_upper : ∀ {ι : Type u_1}, Monotone fun I => I.upper := by sorry

The theorem `BoxIntegral.Box.monotone_upper` states that for any type `ι`, the function that maps a box `I` to its upper bound is monotone. In other words, if we have two boxes `A` and `B` such that `A ≤ B`, then the upper bound of `A` is less than or equal to the upper bound of `B`. This is a property of the upper bound function in the context of box integrals.

For any type ι, the function that maps a box I to its upper bound is monotone, i.e., if A ≤ B are boxes, then the upper bound of A is less than or equal to the upper bound of B.


theorem Set.finite_lt_nat : ∀ (n : ℕ), Set.Finite {i | i < n} := by sorry

This theorem states that for any natural number 'n', the set of all natural numbers 'i' that are less than 'n' is finite. In mathematical terms, it says that there exists a natural number 'm' and an equivalence between the set `{i | i < n}` and the set `Fin m`, where 'Fin m' is the set of all natural numbers less than 'm'. This result holds for every natural number 'n'.

For every natural number 'n', the set of natural numbers less than 'n' is finite and equivalent to the set of natural numbers less than some natural number 'm'.


theorem zero_not_mem_nonZeroDivisors :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : Nontrivial M], 0 ∉ nonZeroDivisors M := by sorry

The theorem `zero_not_mem_nonZeroDivisors` states that for any `MonoidWithZero` `M` which is nontrivial, the element 0 does not belong to the submonoid of non-zero-divisors of `M`. In other words, in a nontrivial monoid with zero, zero cannot be a non-zero-divisor, which is consistent with the mathematical expectation since multiplying any number by zero results in zero.

In a nontrivial MonoidWithZero, the zero element is not a non-zero divisor.


theorem sub_le_self_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α}, a - b ≤ a ↔ 0 ≤ b :=
  by sorry

This theorem, `sub_le_self_iff`, states that for any type `α` that forms an add group and has an order relation, under the condition that addition is a covariant operation, for any value `a` of such type `α`, the statement "a minus b is less than or equal to a" holds true if and only if "b is greater than or equal to zero". In mathematical terms, it says that for all a and b in α, a - b ≤ a if and only if 0 ≤ b.

For any add group type `α` with order relation where addition is covariant, `a ≤ a + b` if and only if `b ≥ 0`.


theorem MeasureTheory.Ioo_ae_eq_Ioc' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a b : α},
      ↑↑μ {b} = 0 → Set.Ioo a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Ioc a b :=
  by sorry

The theorem `MeasureTheory.Ioo_ae_eq_Ioc'` states that for any type `α` with a `PartialOrder`, a `MeasurableSpace` structure `m0`, a measure `μ`, and two elements `a` and `b` of `α`, if the measure of the singleton set `{b}` is zero, then the left-open right-open interval `(a, b)` is almost everywhere equal (in the measure theoretic sense) to the left-open right-closed interval `(a, b]` under the measure `μ`. In other words, the two intervals are identical except on a set of measure zero.

If `μ(`{`b`}`) = 0` in a measure space `(α, m0, μ)` with a `PartialOrder` on `α`, then `(a, b)` and `(a, b]` are almost equal in measure.


theorem MeasureTheory.ofReal_toReal_ae_eq :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      (∀ᵐ (x : α) ∂μ, f x < ⊤) → (fun x => ENNReal.ofReal (f x).toReal) =ᶠ[MeasureTheory.Measure.ae μ] f :=
  by sorry

This theorem states that for any type `α`, measurable space `m`, measure `μ` over that space, and a function `f` that maps from the space `α` to the extended nonnegative real numbers (or ENNReal, usually denoted as [0, ∞]), if it is almost everywhere (with respect to the measure `μ`) that `f(x)` is less than infinity, then the function that maps `x` to the nonnegative real part of `f(x)` is equal to `f` almost everywhere. In other words, we can convert `f(x)` to a real number and then back to extended nonnegative real number without changing the value of `f(x)` almost everywhere.

In the context of measure theory, "almost everywhere" means that the set of points where the condition fails has measure zero. "ENNReal.ofReal (f x).toReal" is the operation of converting `f(x)` to a real number and then back to an extended nonnegative real number. The notation "=ᶠ[MeasureTheory.Measure.ae μ] f" means that the function is equal to `f` except possibly on a set of measure zero (i.e., almost everywhere).

If a measurable function `f : α → ENNReal` is almost everywhere finite with respect to measure `μ`, then the pointwise application of the non-negative real part function and `f` are equal almost everywhere.


theorem Filter.exists_le_of_tendsto_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : SemilatticeSup α] [inst_1 : Preorder β] {u : α → β},
      Filter.Tendsto u Filter.atTop Filter.atTop → ∀ (a : α) (b : β), ∃ a' ≥ a, b ≤ u a' :=
  by sorry

This theorem, `Filter.exists_le_of_tendsto_atTop`, states that for any function `u` mapping elements from a type `α` with a 'semilattice sup' structure (a partially ordered set with a supremum operation) to a type `β` with a preorder structure, if the function `u` tends to infinity (represented by `Filter.atTop`) as its input tends to infinity, then for all elements `a` from `α` and `b` from `β`, there exists an element `a'` in `α` such that `a'` is greater than or equal to `a` and `b` is less than or equal to the value of the function `u` at `a'`. In other words, for any given `a` and `b`, we can always find a value `a'` such that `u(a')` is at least `b`, as the function `u` tends towards infinity.

Given a semilattice `α` with supremum and a preordered type `β`, if a function `u : α → β` tends to `Filter.atTop β` as inputs tend to infinity, then for all `a ∈ α` and `b ∈ β`, there exists `a' ≥ a` such that `u a' ≤ b`.


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

This theorem states that for any type 'R' that forms a commutative ring (denoted as `CommRing R`), if two elements `x` and `y` of type 'R' are coprime (as per the definition `IsCoprime`), then the negation of `x` (denoted as `-x`) and `y` are also coprime. This implies that if there exist two numbers `a` and `b` such that `a * x + b * y = 1`, then there also exist numbers (possibly different) such that they multiply with `-x` and `y` to give `1`.

If `R` is a commutative ring and `x` and `y` are coprime elements of `R`, then `-x` and `y` are also coprime. That is, if `x` and `y` have no common factors besides 1, then `-x` and `y` also have no common factors besides 1.


theorem Filter.tendsto_atBot_atBot :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Nonempty α] [inst : SemilatticeInf α] [inst_1 : Preorder β] {f : α → β},
      Filter.Tendsto f Filter.atBot Filter.atBot ↔ ∀ (b : β), ∃ i, ∀ a ≤ i, f a ≤ b :=
  by sorry

The theorem `Filter.tendsto_atBot_atBot` states that for any function `f` mapping from a type `α`, which is nonempty and forms a semilattice under an infimum operation, to a type `β` with a preorder, then `f` tends to negative infinity (represented by `Filter.atBot`) as its argument tends to negative infinity if and only if for any value `b` of type `β`, there exists a value `i` such that for all `a` less than or equal to `i`, the image `f(a)` is less than or equal to `b`. This relates the concept of a function tending towards negative infinity in both its domain and range with a universal quantification over a property involving all elements below a certain threshold in the domain.

For a function from a semilattice to a preordered type, if the image of every element less than or equal to some index approaches the minimum element at the range side, then the function tends to the minimum element at the range as the domain element tends to negative infinity.


ContinuousOn.if'

theorem ContinuousOn.if' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {p : α → Prop}
      {f g : α → β} [inst_2 : (a : α) → Decidable (p a)],
      (∀ a ∈ s ∩ frontier {a | p a},
          Filter.Tendsto f (nhdsWithin a (s ∩ {a | p a})) (nhds (if p a then f a else g a))) →
        (∀ a ∈ s ∩ frontier {a | p a},
            Filter.Tendsto g (nhdsWithin a (s ∩ {a | ¬p a})) (nhds (if p a then f a else g a))) →
          ContinuousOn f (s ∩ {a | p a}) →
            ContinuousOn g (s ∩ {a | ¬p a}) → ContinuousOn (fun a => if p a then f a else g a) s :=
  by sorry

This theorem states that given two types `α` and `β` with respective topological spaces, a set `s` of type `α`, a predicate `p : α → Prop`, and two functions `f, g : α → β`, if it is decidable for each element `a` of type `α` whether it satisfies the predicate `p a`, then the following conditions hold:

1. For every `a` in the intersection of `s` and the frontier of the set where `p a` holds, the function `f` tends to the neighborhood of `(if p a then f a else g a)` within the intersection of `s` and the set where `p a` holds.

2. For every `a` in the intersection of `s` and the frontier of the set where `p a` holds, the function `g` tends to the neighborhood of `(if p a then f a else g a)` within the intersection of `s` and the set where `p a` does not hold.

3. The function `f` is continuous on the intersection of `s` and the set where `p a` holds.

4. The function `g` is continuous on the intersection of `s` and the set where `p a` does not hold.

If all these conditions are met, then the piecewise function defined as `(fun a => if p a then f a else g a)` is continuous on the set `s`. In plain language, if `f` and `g` behave well at the boundary between where `p a` is true and false, and are continuous where they are respectively true and false, then the function that is `f` where `p a` is true and `g` where `p a` is false is continuous.

Given types `α`, `β`, a set `s` of type `α`, a decidable predicate `p : α → Prop`, and continuous functions `f, g : α → β`, if `f` and `g` tend to the same limit on the frontier of `s` where `p` is undefined and are continuous on `s` where `p` holds respectively, then the piecewise function `(fun a => if p a then f a else g a)` is continuous on `s`.


MeromorphicAt.mul

theorem MeromorphicAt.mul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {f g : 𝕜 → 𝕜} {x : 𝕜},
      MeromorphicAt f x → MeromorphicAt g x → MeromorphicAt (f * g) x :=
  by sorry

The theorem `MeromorphicAt.mul` states that if two functions `f` and `g` are meromorphic at a point `x` in the domain of a nontrivially normed field `𝕜`, then their product function `(f * g)` is also meromorphic at `x`. In other words, the meromorphicity at a point is preserved under multiplication of functions. This is analogous to the property in complex analysis that the product of two meromorphic functions is again a meromorphic function.

If `f` and `g` are meromorphic at a point `x` in a nontrivially normed field `𝕜`, then their product `(f * g)` is also meromorphic at `x`.


theorem NNReal.rpow_inv_rpow_self : ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ y) ^ (1 / y) = x := by sorry

This theorem states that for all nonzero real numbers `y` and all nonnegative real numbers `x`, raising `x` to the power of `y`, and then raising the result to the power of `1/y`, equals `x` itself. In mathematical notation, this would be written as $(x^y)^{1/y} = x$ for all $x \geq 0$ and $y \neq 0$.

For all nonzero real numbers y and nonnegative real numbers x, $(x^y)^{1/y} = x$.


theorem Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A]
      [inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι]
      [inst_5 : GradedRing 𝒜] {I : Ideal A},
      Ideal.IsHomogeneous 𝒜 I → HomogeneousIdeal.toIdeal (Ideal.homogeneousCore 𝒜 I) = I :=
  by sorry

This theorem asserts that for any ideal `I` of a semiring `A`, if `I` is a homogeneous ideal under grading by `𝒜`, then the ideal obtained by converting the homogeneous core of `I` to an ideal is equal to `I` itself. Here, the homogeneous core of an ideal is the set of all elements whose all homogeneous components belong to the ideal. A homogeneous ideal is an ideal in which for every element, all its homogeneous components are in the ideal.

For any homogeneous ideal `I` in a graded semiring `A`, the ideal generated by the homogeneous components of elements in `I` is equal to `I` itself.


/-- The frontier of a closed set has no interior point.  -/
theorem interior_frontier :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s → interior (frontier s) = ∅ := by sorry

The theorem `interior_frontier` states that for every set `s` of a type `X` embedded in a topological space, if `s` is a closed set, then the interior of the frontier of `s` is the empty set. In other words, the frontier of a closed set in a topological space has no interior points. The frontier of a set is the set of points between the closure and interior of the set. Thus, this theorem essentially states that there are no points that both belong to the frontier of a closed set and are interior points of some open set contained within the frontier.

The interior of the frontier of any closed subset in a topological space is the empty set.


SetTheory.PGame.LF.le

/-- **Alias** of `SetTheory.PGame.le_of_lf`. -/
theorem SetTheory.PGame.LF.le :
    ∀ {x y : SetTheory.PGame}, SetTheory.PGame.LF x y → SetTheory.PGame.Numeric x → SetTheory.PGame.Numeric y → x ≤ y :=
  by sorry

This theorem, which is an alias of `SetTheory.PGame.le_of_lf`, states that for any two pre-games `x` and `y`, if the less or fuzzy relation holds between `x` and `y`, and if both `x` and `y` are numeric pre-games, then `x` is less than or equal to `y`. The less or fuzzy relation `SetTheory.PGame.LF x y` means that the second player cannot win when the game starts from `y`. A pre-game is numeric if all elements in the left set are less than all elements in the right set, and all elements of the left and right sets are also numeric.

If pre-games x and y are numeric and the less or fuzzy relation LF holds between them (i.e., player 2 cannot win starting from y), then x ≤ y.


theorem Finset.map_prodComm_antidiagonal :
    ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A] {n : A},
      Finset.map (Equiv.toEmbedding (Equiv.prodComm A A)) (Finset.antidiagonal n) = Finset.antidiagonal n :=
  by sorry

The theorem `Finset.map_prodComm_antidiagonal` states that for any type `A` that has an additive commutative monoid structure and a defined antidiagonal, and for any element `n` of type `A`, the image of the antidiagonal of `n` under the map defined by the embedding of the product commutativity equivalence (i.e., the transformation that swaps the components of pairs) is equal to the original antidiagonal of `n`. Essentially, this means that swapping the components of each pair in the antidiagonal of `n` results in the same set, highlighting the symmetry property of the antidiagonal in an additive commutative monoid.

For any additive commutative monoid `A` with defined antidiagonal, the image of its antidiagonal under the product commutativity map is equal to the original antidiagonal.


theorem Nat.Prime.not_coprime_iff_dvd : ∀ {m n : ℕ}, ¬Nat.Coprime m n ↔ ∃ p, Nat.Prime p ∧ p ∣ m ∧ p ∣ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, `m` and `n` are not coprime (or their greatest common divisor is not 1) if and only if there exists a prime number `p` such that `p` divides both `m` and `n`. In other words, the lack of coprimality between `m` and `n` is equivalent to the existence of a common prime divisor.

m and n are not coprime if and only if there exists a prime p that divides both m and n.


theorem Mathlib.Data.List.Sigma._auxLemma.2 :
    ∀ {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)},
      List.NodupKeys (s :: l) = (s.fst ∉ List.keys l ∧ List.NodupKeys l) :=
  by sorry

The theorem `Mathlib.Data.List.Sigma._auxLemma.2` states that for any type `α`, any dependent type `β` that depends on `α`, any element `s` of the dependent pair type `Sigma β`, and any list `l` of elements of `Sigma β`, it is true that `s` is a distinct key in the list `s :: l` if and only if the first element of `s` (i.e., `s.fst`) is not in the keys of `l` and all keys in `l` are distinct (`List.NodupKeys l`).

For any type `α` and dependent type `β`, given an element `s` of the dependent pair type `Σβ`, and a list `l` of pair elements of `Σβ` where all keys are distinct, `s` is the unique key in `s :: l` if and only if the first element of `s` is not a key in `l`.


theorem HolorIndex.take.proof_1 :
    ∀ {ds₂ : List ℕ} (ds : List ℕ) (is : HolorIndex (ds ++ ds₂)),
      List.Forall₂ (fun x x_1 => x < x_1) (List.take (List.length ds) ↑is) ds :=
  by sorry

The theorem `HolorIndex.take.proof_1` states that for any two lists of natural numbers `ds` and `ds₂`, and any `HolorIndex` which is formed by appending `ds₂` to `ds`, the sublist retrieved by taking `List.length ds` elements from the `HolorIndex` satisfies the property that each element at position `i` in the sublist is less than the corresponding element at position `i` in the list `ds`. In simpler terms, it says that the elements corresponding to the list `ds` in the `HolorIndex` are less than their counterparts in `ds`.

For any lists `ds` and `ds₂`, if `ds` is a prefix of the HolorIndex formed by appending `ds₂` to `ds`, then the first `List.length ds` elements in `ds` are less than or equal to their corresponding elements in the HolorIndex.


theorem Int.fmod_def : ∀ (a b : ℤ), Int.fmod a b = a - b * Int.fdiv a b := by sorry

This theorem defines the integer modulus operation (`Int.fmod`) in terms of integer division (`Int.fdiv`). For any two integers `a` and `b`, the remainder of the division of `a` by `b` (as computed by `Int.fmod a b`) is equal to the difference of `a` and the product of `b` and the floor of the division of `a` by `b` (computed as `b * Int.fdiv a b`). In mathematical terms, it expresses the fact that `a mod b = a - ⌊a/b⌋ * b`.

For any integers `a` and `b`, `a % b = a - floor(a / b) * b`, where `%` denotes the modulo operation.


theorem openEmbedding_of_embedding_open :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Embedding f → IsOpenMap f → OpenEmbedding f :=
  by sorry

The theorem `openEmbedding_of_embedding_open` states that for any two types `X` and `Y` with associated topological spaces, and any function `f` from `X` to `Y`, if `f` is an embedding and an open map, then `f` is an open embedding. Here, an embedding is a function that is injective (one-to-one) and its image under `f` is homeomorphic to the preimage. An open map is a function where the image of any open set is still open. Finally, an open embedding is a function which is both an embedding and an open map.

If a function between topological spaces is both an embedding and an open map, then it is an open embedding.


theorem Mathlib.Dynamics.OmegaLimit._auxLemma.4 :
    ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β)
      (s : Set α) (y : β), (y ∈ omegaLimit f ϕ s) = ∀ n ∈ nhds y, ∃ᶠ (t : τ) in f, Set.Nonempty (s ∩ ϕ t ⁻¹' n) :=
  by sorry

This theorem, `Mathlib.Dynamics.OmegaLimit._auxLemma.4`, states that for any types `τ`, `α`, `β`, and assuming `β` is a topological space, for any filter `f` on `τ`, a function `ϕ` from `τ` to `α` to `β`, a set `s` of type `α`, and a point `y` of type `β`, `y` is in the ω-limit of the set `s` under the function `ϕ` with respect to the filter `f` if and only if for every neighborhood `n` of `y`, there eventually exists `t` in the filter `f` such that the set `s` intersects the pre-image of the neighborhood `n` through the function `ϕ(t)` is not empty. Here, "eventually exists" is quantified in the sense of the filter `f`, and a set is non-empty if there exists an element that belongs to the set.

A point `y` in a topological space is in the ω-limit of a set `s` under a function `ϕ` with respect to a filter `f` if and only if for every neighborhood `n` of `y`, there exists a filter element `t` such that `s` intersects the pre-image of `n` under `ϕ(t)` is non-empty.


theorem eq_top_mono : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, a ≤ b → a = ⊤ → b = ⊤ :=
  by sorry

This theorem, `eq_top_mono`, states that for any type `α` that has a partial order and a maximum or top element, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b` and `a` is the top element, then `b` must also be the top element. In simpler terms, if `a` is the maximum possible value and `b` is at least as large as `a`, then `b` must also be the maximum possible value.

If `α` is a type with a partial order and a maximum element `m`, then `m` is unique and any element `x` with `x ≤ m` implies `m = x`.


AnalyticAt.differentiableWithinAt

theorem AnalyticAt.differentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, AnalyticAt 𝕜 f x → DifferentiableWithinAt 𝕜 f s x :=
  by sorry

The theorem `AnalyticAt.differentiableWithinAt` states that for any non-trivially normed field `𝕜` and normed add commutative group `E` and `F` with normed space structures over `𝕜`, if a function `f` from `E` to `F` is analytic at a point `x`, then `f` is differentiable at that point `x` within any set `s` of `E`. Here, being analytic means `f` admits a convergent power series expansion around `x`, and being differentiable means `f` admits a derivative at `x` within `s`.

If a function `f` is analytic at a point `x` in the normed spaces `E` and `F` over a non-trivially normed field `𝕜`, then `f` is differentiable at `x` within any neighborhood `s` of `x` in `E`.


/-- Cardinality of a non-empty `Icc` of finsets.  -/
theorem Finset.card_Icc_finset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ⊆ t → (Finset.Icc s t).card = 2 ^ (t.card - s.card) :=
  by sorry

This theorem states that for any type `α` with decidable equality, given two finite sets `s` and `t` of type `α` where `s` is a subset of `t`, the cardinality (i.e., the number of elements) of the closed interval between `s` and `t` in the finite set sense is equal to `2` to the power of the difference between the cardinalities of `t` and `s`. In other words, if you have two finite sets where one is a subset of the other, there are `2` to the power of the difference in their sizes number of sets between them, including the two sets themselves.

For finite sets `s` and `t` of type `α` with decidable equality, the cardinality of the closed interval between `s` and `t` is 2 raised to the power of the cardinality difference between `t` and `s`.


theorem LinearMap.isCompl_of_proj :
    ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p : Submodule R E}
      {f : E →ₗ[R] ↥p}, (∀ (x : ↥p), f ↑x = x) → IsCompl p (LinearMap.ker f) :=
  by sorry

The theorem `LinearMap.isCompl_of_proj` states that for any given ring `R`, an additive commutative group `E`, and a module `E` over `R`, if `p` is a submodule of `E` and `f` is a linear map from `E` to `p`, then for all elements `x` in `p`, if the linear map applied to `x` is `x` itself, then `p` and the kernel of `f` are complementary in `E`. In other words, any `E` can be "uniquely" decomposed into an element in `p` and an element in the kernel of `f`. This theorem is a fundamental result in linear algebra related to projection operators.

If `f` is a linear map from a module `E` over a ring `R` to a submodule `p` of `E`, such that `x ∈ p` implies `f(x) = x`, then `p` and the kernel of `f` have a complement in `E`.


theorem BoundedContinuousFunction.norm_eq_iSup_norm :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
      (f : BoundedContinuousFunction α β), ‖f‖ = ⨆ x, ‖f x‖ :=
  by sorry

This theorem states that for any bounded continuous function `f` from a topological space `α` to a semi-normed additive commutative group `β`, the norm of `f` is equal to the supremum of the norms of `f(x)` for all `x` in `α`. In other words, the norm of the function is determined by the largest norm of its values.

For any bounded continuous function from a topological space to a semi-normed additive commutative group, the norm of the function equals the supremum of the norms of its values.


theorem Mathlib.Topology.Constructions._auxLemma.15 : ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the conjunction of `a`, `b`, and `c` is the same as the conjunction of `b`, `a`, and `c`. In other words, the order in which the propositions are conjoined does not matter. This is analogous to the commutative property in basic arithmetic where the order of the numbers in the operation does not change the result (e.g., `a + b = b + a`).

The theorem asserts the commutativity of proposition conjunction: `a ∧ b = b ∧ a`.


theorem Mathlib.Algebra.RingQuot._auxLemma.2 :
    ∀ {R : Type uR} [inst : Semiring R] (r : R → R → Prop), 1 = { toQuot := Quot.mk (RingQuot.Rel r) 1 } := by sorry

This theorem, named `_auxLemma.2` in the `Mathlib.Algebra.RingQuot` module, states that for any type `R` equipped with a semiring structure, and any binary relation `r` on `R`, the numeral `1` is equal to the ring quotient object constructed from the equivalence class of `1` under the relation `RingQuot.Rel r`. This essentially shows that the representation of `1` as a ring quotient under any relation `r` corresponds to the numeral `1` itself.

For any semiring `R` and relation `r` on `R`, the equivalence class of `1` in the quotient object `RingQuot.RingQuot.mk (RingQuot.Rel r) R 1` equals `1`.


List.Perm.insert

theorem List.Perm.insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) {l₁ l₂ : List α},
      List.Perm l₁ l₂ → List.Perm (List.insert a l₁) (List.insert a l₂) :=
  by sorry

This theorem states that for any type `α` with a decidable equality and any two lists `l₁` and `l₂` of this type, if `l₁` and `l₂` are permutations of each other, then the lists obtained by inserting the same element `a` of type `α` into `l₁` and `l₂` (without duplication) are also permutations of each other. Here, `List.Perm` denotes the permutation relationship between two lists, and `List.insert` represents the operation of inserting an element into a list without duplication.

If `α` is a type with decidable equality and `l₁` and `l₂` are permutations of each other, then the lists `List.insert a l₁` and `List.insert a l₂` are also permutations of each other.


theorem Filter.mem_coclosedCompact :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      s ∈ Filter.coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ s :=
  by sorry

The theorem `Filter.mem_coclosedCompact` states that for any type `X` equipped with a topology and any set `s` of type `X`, `s` is in the filter generated by complements of closed compact sets if and only if there exists a set `t` such that `t` is closed, `t` is compact and the complement of `t` is a subset of `s`. In other words, the set `s` belongs to the filter of complements of closed compact sets precisely when we can find a closed and compact set whose complement is contained within `s`.

A set is in the filter of complements of closed compact sets if and only if it is the complement of some closed and compact set.


theorem Mathlib.Topology.Constructions._auxLemma.35 :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
      IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with topological spaces, and any set `s` in the sum type `X ⊕ Y`, `s` is open if and only if both the preimage of `s` under the left injection (`Sum.inl`) and the preimage of `s` under the right injection (`Sum.inr`) are open. In other words, a set in the disjoint union of two topological spaces is open if it's "open from both sides", i.e., its preimage under both the left and right injections are open.

A subset of the disjoint union of two topological spaces is open if and only if its preimages under the left and right injections are open.


theorem Submodule.map_iSup :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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 : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂]
      [inst_8 : RingHomSurjective σ₁₂] {ι : Sort u_10} (f : F) (p : ι → Submodule R M),
      Submodule.map f (⨆ i, p i) = ⨆ i, Submodule.map f (p i) :=
  by sorry

The `Submodule.map_iSup` theorem states that for given types `R`, `R₂`, `M`, `M₂`, and `F`, together with instances of `Semiring R`, `Semiring R₂`, `AddCommMonoid M`, `AddCommMonoid M₂`, `Module R M`, `Module R₂ M₂`, `FunLike F M M₂`, `SemilinearMapClass F σ₁₂ M M₂`, and `RingHomSurjective σ₁₂`; a ring homomorphism `σ₁₂ : R →+* R₂`; a variable `f` of type `F`; and a family of submodules `p : ι → Submodule R M` indexed by `ι`, the image of the join (`⨆`) of all submodules `p i` under the map `f` is equal to the join of the images of each individual submodule `p i` under the map `f`. In mathematical terms, it asserts that mapping (with `f`) respects the join operation in the lattice of submodules.

For a ring homomorphism `σ₁₂` between semirings `R` and `R₂`, and for submodules `p i` of `M` indexed by `ι`, the image of the join (⨆) of `p i` under the semilinear map `f : M → M₂` is equal to the join of the images of each `p i` under `f`.


theorem IsRelPrime.of_mul_left_right :
    ∀ {α : Type u_1} [inst : CommMonoid α] {x y z : α}, IsRelPrime (x * y) z → IsRelPrime y z := by sorry

The theorem `IsRelPrime.of_mul_left_right` states that for any type `α` that forms a commutative monoid, if `x`, `y`, and `z` are elements of `α`, and `x * y` and `z` are relatively prime (meaning that any common divisor of `x * y` and `z` is a unit), then `y` and `z` are also relatively prime. In other words, if a number `z` is relatively prime to the product of two numbers `x` and `y`, then `z` is also relatively prime to `y`.

If `x`, `y`, and `z` are elements of a commutative monoid such that `x * y` and `z` are relatively prime, then `y` and `z` are relatively prime.


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

The theorem `Iic_mem_nhdsSet_Icc` states that for any given type `α` which is a linearly ordered topological space with the orderings closed, and any three elements `a`, `b`, `c` of this type, if `b` is less than `c`, then the left-infinite right-closed interval `Set.Iic c` (consisting of all elements less than or equal to `c`) is a member of the filter of neighborhoods (`nhdsSet`) of the closed interval `Set.Icc a b` (consisting of all elements `x` such that `a ≤ x ≤ b`). In practical terms, this means that we can always find a left-infinite right-closed interval whose end point is greater than the upper bound of our given closed interval, and this interval will be a neighborhood of our original closed interval in the given topological space.

For any linearly ordered topological space `α` with closed orderings, if `b` is less than `c` in `α`, then `Set.Iic c ∈ nhdsSet (Set.Icc a b)`.


/-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same
inseparable degree over `F`.  -/
theorem Field.lift_insepDegree_eq_of_equiv :
    ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w)
      [inst_3 : Field K] [inst_4 : Algebra F K],
      (E ≃ₐ[F] K) → Cardinal.lift.{w, v} (Field.insepDegree F E) = Cardinal.lift.{v, w} (Field.insepDegree F K) :=
  by sorry

This theorem states that if two fields `E` and `K` are isomorphic as `F`-algebras (i.e., they have the same algebraic structure over a common base field `F`), then their inseparable degrees over `F` are equal. The inseparable degree of a field extension `E / F` is defined to be the degree of `E / separableClosure F E`. The cardinality of these inseparable degrees is then lifted to the maximum of the universes in which `E` and `K` reside. In other words, despite possibly living in different universes, if `E` and `K` have the same algebraic structure over `F`, they also have the same inseparable degree over `F`.

If two fields `E` and `K` are isomorphic as `F`-algebras, then they have equal inseparable degrees over the base field `F`.


theorem Mathlib.NumberTheory.NumberField.CanonicalEmbedding._auxLemma.5 :
    ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro := by sorry

This theorem, `Mathlib.NumberTheory.NumberField.CanonicalEmbedding._auxLemma.5`, states that for all properties `p` that can be applied to a truth value, saying that `p` holds for all truth values `x` is equivalent to saying that `p` holds for the introductory form of truth (`True.intro`). In simpler terms, if a property holds for any true value, then it specifically holds for the fundamental true value, `True.intro`.

For any property `p`, `p` holds for all truth values if and only if `p` holds for the introductory form of truth `True.intro` in Lean 4's Number Theory library.


theorem BumpCovering.sum_toPOUFun_eq :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : BumpCovering ι X s) (x : X),
      (finsum fun i => BumpCovering.toPOUFun f i x) = 1 - finprod fun i => 1 - (f i) x :=
  by sorry

The theorem `BumpCovering.sum_toPOUFun_eq` states that for any topological space `X`, a set `s` of `X`, and a function `f` representing a bump covering of the set `s`, for any element `x` of `X`, the sum over all `i` of the `i`-th partition of unity function of `f` evaluated at `x` is equal to 1 minus the product over all `i` of 1 minus the `i`-th bump function of `f` evaluated at `x`. In other words, it describes a relationship between the sum of partition of unity functions and the product of bump functions in a bump covering of a topological space.

For any topological space X, set s, and bump covering function f, the sum over i of the i-th partition of unity function of f evaluated at x equals 1 minus the product over i of 1 minus the i-th bump function of f evaluated at x.


theorem isPurelyInseparable_iff :
    ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
      IsPurelyInseparable F E ↔
        ∀ (x : E), IsIntegral F x ∧ (Polynomial.Separable (minpoly F x) → x ∈ RingHom.range (algebraMap F E)) :=
  by sorry

This theorem states that for any two fields `F` and `E` where `E` is an algebra over `F`, `E` is purely inseparable over `F` if and only if for every element `x` of `E`, `x` is integral over `F`, and if the minimal polynomial of `x` over `F` is separable, then `x` is in the image of the algebra homomorphism from `F` to `E`. Here, an element being integral means it's a root of some monic polynomial from `F`, and a polynomial is separable if it is coprime with its derivative.

A field extension `E` over `F` is purely inseparable if and only if every element of `E` is integral over `F` and lies in the image of the algebra homomorphism from `F` to `E`, with integrality implying separability of the minimal polynomial.


theorem forall_const : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], α → b ↔ b := by sorry

This theorem states that for any proposition `b` and any type `α` that is nonempty (i.e., there exists at least one value of type `α`), the implication from `α` to `b` is equivalent to `b`. In other words, if we have an instance of `α` (which we know we have because `α` is nonempty), then saying "`α` implies `b`" is just the same as saying "`b`".

For any nonempty type `α` and proposition `b`, `α → b` is provably equal to `b`.


/-- To cancel a common factor `c` from a `ModEq` we must divide the modulus `m` by `gcd m c`  -/
theorem Nat.ModEq.cancel_left_div_gcd : ∀ {m a b c : ℕ}, 0 < m → c * a ≡ c * b [MOD m] → a ≡ b [MOD m / Nat.gcd m c] :=
  by sorry

This theorem, `Nat.ModEq.cancel_left_div_gcd`, states that for any positive integer modulus `m` and any integers `a`, `b` and `c`, if `c * a` is congruent to `c * b` modulo `m`, then `a` is congruent to `b` modulo `m / gcd(m, c)`. Essentially, this theorem allows us to cancel a common factor `c` from a modular equivalence, but in doing so we must divide the modulus by the greatest common divisor (gcd) of the modulus and `c`.

If `a` is congruent to `b` modulo `m`, then `a` is congruent to `b` modulo `m / gcd(m, c)` when `c * a` is congruent to `c * b` modulo `m`.


theorem Subgroup.map_normalClosure :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (s : Set G) (f : G →* N),
      Function.Surjective ⇑f → Subgroup.map f (Subgroup.normalClosure s) = Subgroup.normalClosure (⇑f '' s) :=
  by sorry

This theorem states that for any set `s` of elements of a group `G` and any surjective monoid homomorphism `f` from `G` to another group `N`, the image of the normal closure of `s` under the homomorphism `f` is equal to the normal closure of the image of `s` under `f`. In other words, the process of taking normal closures commutes with the process of taking images under a surjective homomorphism. This implies that the structure of the normal closure of a set in a group is preserved under surjective homomorphisms.

For any surjective group homomorphism `f` and set `s` in a group `G`, the normal closure of `f(s)` in `N = f(NormalClosure(s, G))`.


theorem Sym.exists_mem : ∀ {α : Type u_1} {n : ℕ} (s : Sym α (Nat.succ n)), ∃ a, a ∈ s := by sorry

This theorem states that for any type `α` and any natural number `n`, if `s` is an `nth` symmetric power of `α` (which is a multiset of `α` with cardinally `n+1`), then there exists an element `a` that is a member of `s`. In other words, any such `nth` symmetric power `s` is non-empty.

For any type `α` and natural number `n`, the `n`-th symmetric power of `α` is non-empty.


theorem Matrix.map_one :
    ∀ {n : Type u_3} {α : Type v} {β : Type w} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α]
      [inst_3 : Zero β] [inst_4 : One β] (f : α → β), f 0 = 0 → f 1 = 1 → Matrix.map 1 f = 1 :=
  by sorry

The theorem `Matrix.map_one` states that for any types `n`, `α`, and `β`, where `n` has decidable equality and `α` and `β` both have zero and one elements, given a function `f` from `α` to `β` such that `f` maps 0 to 0 and 1 to 1, if we apply the function `f` to each entry of the identity matrix (denoted by 1), we will get the identity matrix back. This theorem essentially asserts that the identity matrix preserves its identity property under such a mapping function.

For any types `n` with decidable equality, and `α` and `β` having zero and one elements, if `f : α → β` maps 0 to 0 and 1 to 1, then `(f ∘ Matrix.identity n).transpose = Matrix.identity n`.


theorem Equiv.Perm.mem_support_cycleOf_iff :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x y : α},
      y ∈ Equiv.Perm.support (Equiv.Perm.cycleOf f x) ↔ Equiv.Perm.SameCycle f x y ∧ x ∈ Equiv.Perm.support f :=
  by sorry

This theorem states that for any type `α` with decidable equality and finiteness, and given a permutation `f` of `α`, and elements `x` and `y` of `α`, `y` belongs to the non-fixed points of the cycle of `f` at `x` if and only if `y` is in the same cycle as `x` under `f` and `x` is a non-fixed point of `f`.

For any permutation `f` of a type `α` with decidable equality and finiteness, `x` and `y` are in the same cycle of `f` and `x` is a non-fixed point of `f` if and only if `y` is a non-fixed point of `f` in the cycle of `x`.


theorem MeasureTheory.ae_eq_of_ae_subset_of_measure_ge :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      s ≤ᶠ[MeasureTheory.Measure.ae μ] t →
        ↑↑μ t ≤ ↑↑μ s → MeasurableSet s → ↑↑μ t ≠ ⊤ → s =ᶠ[MeasureTheory.Measure.ae μ] t :=
  by sorry

The theorem `MeasureTheory.ae_eq_of_ae_subset_of_measure_ge` states that for any measure space `α` with a measurable space structure `m` and a measure `μ`, and any two sets `s` and `t` of `α`, if `s` is almost everywhere a subset of `t` (with respect to the measure `μ`), and the measure of `t` is less than or equal to the measure of `s`, and `s` is a measurable set, and the measure of `t` is not infinity, then `s` and `t` are almost equal everywhere (with respect to the measure `μ`).

In other words, it means that if we have two sets such that one is mostly contained in the other and the potentially larger set doesn't have a larger measure and is measurable, then the two sets are almost everywhere the same. This theorem is related to the equality of sets in measure theory, particularly in the context of almost everywhere equality.

If two measurable sets in a measure space have almost everywhere subset relation and the larger set has finite measure less than or equal to the smaller set's measure, then they are almost everywhere equal.


theorem Option.mem_map₂_iff :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ},
      c ∈ Option.map₂ f a b ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c :=
  by sorry

This theorem asserts that for any types α, β, and γ, and for any binary function `f : α → β → γ`, an element `c : γ` is in the image of `f` applied to two options `a : Option α` and `b : Option β` if and only if there exist elements `a' : α` and `b' : β` such that `a'` is in `a`, `b'` is in `b`, and `f a' b'` equals `c`. In other words, this is about when an element is in the result of applying a binary function to two optional values.

For any types α, β, γ and binary function f : α → β → γ, an element c is in the image of f applied to optional values a : Option α and b : Option β if and only if there exist a' : α and b' : β in a and b, respectively, such that f a' b' = c.


theorem
  DomAddAct.instVAddDomAddActSubtypeAEEqFunToTopologicalSpaceToUniformSpaceToPseudoMetricSpaceToSeminormedAddAddCommGroupMemAddAddSubgroupInstAddAddGroupToAddAddGroupToNormedAddAddGroupToTopologicalAddAddGroupInstMembershipInstSetLikeAddAddSubgroupLp.proof_2 :
    ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace M] [inst_1 : MeasurableSpace α]
      {μ : MeasureTheory.Measure α} [inst_2 : VAdd M α] [inst_3 : MeasureTheory.VAddInvariantMeasure M α μ]
      [inst : MeasurableVAdd M α] (c : Mᵈᵃᵃ), MeasureTheory.MeasurePreserving (fun x => DomAddAct.mk.symm c +ᵥ x) μ μ :=
  by sorry

This theorem states that for any types `M` and `α`, given the conditions that `M` and `α` are measurable spaces, `μ` is a measure on `α`, `α` is a vector-added (VAdd) space over `M`, the measure `μ` is invariant under the vector addition, and the vector addition is measurable, for any `c` in the domain addition action on `M`, the function that adds the inverse of the equivalence `c` under the domain addition action to each element `x` is measure-preserving. That is, the measure of a set before and after applying this function remains the same.

Given measurable spaces `M` and `α`, a measure `μ` on `α` invariant under vector addition on `M`, and a measurable vector addition on `M`, for any `c` in the domain addition action on `M`, the function that adds the inverse of `c` to each element of a set preserves the measure of that set.


Smooth.mul

theorem Smooth.mul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
      [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
      [inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [inst_7 : SmoothMul I G]
      {E' : Type u_5} [inst_8 : NormedAddCommGroup E'] [inst_9 : NormedSpace 𝕜 E'] {H' : Type u_6}
      [inst_10 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M : Type u_7} [inst_11 : TopologicalSpace M]
      [inst_12 : ChartedSpace H' M] {f g : M → G}, Smooth I' I f → Smooth I' I g → Smooth I' I (f * g) :=
  by sorry

The theorem `Smooth.mul` expresses that, given a nontrivially normed field `𝕜`, two topological spaces `H` and `H'`, a normed additive commutative group `E` and `E'` over `𝕜`, a model with corners `I` and `I'` over `𝕜` and `H` and `H'` respectively, multiply `G` with a smooth structure, and a topological space `M` with a smooth structure, if two functions `f` and `g` from `M` to `G` are smooth (differentiable to any degree), then their product `f * g` is also smooth.

Given a nontrivially normed field `𝕜`, if `f` and `g` are smooth functions from a topological space `M` to a smooth manifold `G` over `𝕜`, then their product `f * g` is also a smooth function from `M` to `G`.


theorem Finsupp.cons_succ :
    ∀ {n : ℕ} (i : Fin n) {M : Type u_1} [inst : Zero M] (y : M) (s : Fin n →₀ M),
      (Finsupp.cons y s) (Fin.succ i) = s i :=
  by sorry

The theorem `Finsupp.cons_succ` states that for any natural number `n`, any element `i` of the finite set `Fin n`, any type `M` with a zero instance, any element `y` of type `M`, and any function `s` from `Fin n` to `M`, applying the function `Finsupp.cons y s` on `Fin.succ i` is equal to `s i`. In other words, this theorem ensures that if you add an element at the beginning of a sequence (which is what `Finsupp.cons` does) and then ask for the successor of some element `i` in the extended sequence, it is the same as asking for the element `i` in the original sequence.

For any natural number `n`, any `i` in `Fin n`, any type `M` with a zero instance, any `y` in `M`, and any function `s` from `Fin n` to `M`, `Finsupp.cons y (s i) = s (Fin.succ i)`.


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

This theorem states that for any type `α`, any set `s` of type `α`, and any filter `f` of type `α`, the filter `f` is less than or equal to the principal filter of `s` if and only if `s` is a member of filter `f`. Here, the principal filter of `s` is the collection of all supersets of `s`, and a filter `f` being less than or equal to another filter means that every set in `f` is also in the other filter. Thus, this theorem establishes an equivalence between `s` being in filter `f` and `f` including all supersets of `s`.

Given any type `α`, set `s` of type `α`, and filter `f` over `α`, `s` is a member of `f` if and only if `f` includes the principal filter of `s`.


theorem Mathlib.Topology.Compactness.Compact._auxLemma.3 :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsCompact s = ∀ (f : Ultrafilter X), ↑f ≤ Filter.principal s → ∃ x ∈ s, ↑f ≤ nhds x :=
  by sorry

This theorem states that a set `s` in a topological space `X` is compact if and only if, for any ultrafilter `f` that contains `s` (in other words, for any ultrafilter `f` for which `s` is a subset of every set in `f`), there exists an element `x` in `s` such that `f` is less than or equal to the neighborhood filter at `x`. Here, an ultrafilter is a special kind of filter, and a neighborhood filter at `x` is the collection of all neighborhoods or open sets containing `x`. Intuitively, this is saying that compactness of a set can be characterized by the property that every ultrafilter on the set can be "narrowed down" to a particular point's neighborhood.

A set in a topological space is compact if and only if, for every ultrafilter containing the set, there exists an element with the ultrafilter being less than or equal to its neighborhood filter.


theorem compare_eq_iff_eq : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, compare a b = Ordering.eq ↔ a = b := by
  sorry

This theorem, `compare_eq_iff_eq`, states that for all types `α` that have a linear order, the comparison of two variables `a` and `b` of type `α` will equal `Ordering.eq` if and only if `a` and `b` are equal. In other words, in a linear ordering, the `compare` function returns `Ordering.eq` precisely when the two input values are the same.

For all types `α` with a linear order, `compare a b = Ordering.eq` if and only if `a = b`.


theorem Real.Angle.toReal_coe_eq_self_iff_mem_Ioc :
    ∀ {θ : ℝ}, Real.Angle.toReal ↑θ = θ ↔ θ ∈ Set.Ioc (-Real.pi) Real.pi := by sorry

This theorem states that for any real number 'θ', the function 'Real.Angle.toReal' applied to 'θ' mapped into the Real.Angle set, equals 'θ' itself if and only if 'θ' belongs to the interval '(-π, π]' (in terms of the real numbers). Here, the interval '(-π, π]' signifies a left-open and right-closed interval, meaning that it includes all real numbers strictly greater than '-π' and less than or equal to 'π'.

For any real number 'θ', the function 'Real.Angle.toReal' equals 'θ' if and only if 'θ' belongs to the interval '(-π, π]'.


theorem Set.MapsTo.restrict_inj :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.MapsTo f s t),
      Function.Injective (Set.MapsTo.restrict f s t h) ↔ Set.InjOn f s :=
  by sorry

The theorem `Set.MapsTo.restrict_inj` states that for any given types `α` and `β`, any set `s` of type `α`, any set `t` of type `β`, and a function `f` from `α` to `β` that maps `s` onto `t`, the function `f` is injective on the restriction of `f` to `s` and `t` if and only if `f` is injective on `s`. This means that if for any two elements in `s`, their images under `f` are the same if and only if the elements themselves are the same, then the same property holds true when we restrict `f` to the elements in `s` that are mapped to `t`.

If a function from type `α` to type `β` maps a set `s` of type `α` onto a set `t` of type `β` and is injective on `s`, then it is injective on the restriction of `s` to the elements in `t`.


theorem Polynomial.splits_prod :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {ι : Type u} {s : ι → Polynomial K}
      {t : Finset ι}, (∀ j ∈ t, Polynomial.Splits i (s j)) → Polynomial.Splits i (Finset.prod t fun x => s x) :=
  by sorry

The theorem `Polynomial.splits_prod` states that for any commutative ring `K`, any field `L`, and any ring homomorphism from `K` to `L`, given a function `s` that maps any type `ι` to a polynomial in `K`, and a finite set `t` of elements of type `ι`, if every polynomial `s j`, for `j` in `t`, splits according to the ring homomorphism `i`, then the product of the polynomials `s x` for `x` in `t` also splits according to the ring homomorphism `i`. In other words, if all polynomials in a finite set split under a certain ring homomorphism, then their product also splits under the same ring homomorphism.

Given a commutative ring K, a field L, a ring homomorphism i from K to L, a function s mapping type ι to polynomials in K, and a finite set t of elements from ι such that every polynomial s j splits under i for j in t, then the product of the polynomials s x for x in t also splits under i.


theorem MeasureTheory.SimpleFunc.coe_injective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] ⦃f g : MeasureTheory.SimpleFunc α β⦄, ↑f = ↑g → f = g :=
  by sorry

This theorem, `MeasureTheory.SimpleFunc.coe_injective`, states that for any two simple functions `f` and `g` over a measurable space `α`, if the co-domain (expressed as `↑f` and `↑g`) of these two functions is equal, then the functions `f` and `g` themselves are equal. This shows that the function from `MeasureTheory.SimpleFunc α β` to its co-domain is injective, i.e., different simple functions have different co-domains.

If two simple functions `f` and `g` over a measurable space `α` have equal co-domains, then `f` equals `g`.


theorem manyOneEquiv_refl : ∀ {α : Type u_1} [inst : Primcodable α] (p : α → Prop), ManyOneEquiv p p := by sorry

The theorem `manyOneEquiv_refl` states that for any type `α` that is primcodable and any property `p` of `α`, `p` is many-one equivalent to itself. In other words, a property `p` is many-one reducible to itself and vice versa. This is a reflection property in the context of many-one equivalence, indicating that any property is many-one equivalent to itself.

For any primcodable type `α` and property `p` of `α`, the property `p` is many-one equivalent to itself.


/-- Left inverse to a continuous map from a homeomorphism, mirroring `Equiv.symm_comp_self`.  -/
theorem Homeomorph.symm_comp_toContinuousMap :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β),
      ContinuousMap.comp (Homeomorph.toContinuousMap (Homeomorph.symm f)) (Homeomorph.toContinuousMap f) =
        ContinuousMap.id α :=
  by sorry

This theorem states that for any homeomorphism `f` from a topological space `α` to another topological space `β`, the composition of the continuous map corresponding to the inverse of `f` and the continuous map corresponding to `f` itself equals the identity continuous map on `α`. In other words, if you first apply `f` and then its inverse, you end up exactly where you started. This is a fundamental property of homeomorphisms and mirrors the property of inverses in group theory, specifically the property that the product of an element and its inverse equals the identity element.

For any homeomorphism $f:\alpha \rightarrow \beta$, the inverse $f^{-1}$ satisfies $f \circ f^{-1} = id_\alpha$, where $id_\alpha$ is the identity map on $\alpha$.


theorem Set.indicator_univ :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (f : α → M), Set.indicator Set.univ f = f := by sorry

The theorem `Set.indicator_univ` states that for any set `α` and any type `M` equipped with a zero element (`inst : Zero M`), and any function `f` from `α` to `M`, applying the Set.indicator function to the universal set and `f` will just yield `f`. In simpler terms, if we use the indicator function with the universal set, it does not change the function `f` because the indicator only applies function `f` when an element is in the set, and all elements are in the universal set.

For any set α and type M with a zero element, the indicator function of the universal set and a function from α to M are equal.


theorem ONote.cmp_compares :
    ∀ (a b : ONote) [inst : ONote.NF a] [inst : ONote.NF b], Ordering.Compares (ONote.cmp a b) a b := by sorry

The theorem `ONote.cmp_compares` states that for any two ordinal notes `a` and `b`, where both `a` and `b` are in "normal form" (this is denoted by `[inst : ONote.NF a] [inst : ONote.NF b]` - it's a kind of precondition), the `Ordering.Compares` function with the comparison of `a` and `b` as the first argument, and `a` and `b` as the second and third arguments, holds true. In other words, this theorem guarantees that the comparison function `ONote.cmp` on ordinal notes in normal form aligns with the standard ordering comparison between `a` and `b`.

For any ordinal notes `a` and `b` in normal form, `Ordering.compares a b <-> ONote.cmp a b` holds true.


/-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid`  -/
theorem List.prod_eq_one : ∀ {M : Type u_5} [inst : Monoid M] {l : List M}, (∀ x ∈ l, x = 1) → List.prod l = 1 := by
  sorry

This theorem, `List.prod_eq_one`, states that for any type `M` that forms a `Monoid`, and for any list `l` of elements of type `M`, if every element `x` in the list `l` is equal to the multiplicative identity `1`, then the product of all elements in the list `l` (computed using the `List.prod` function defined above) is also equal to the multiplicative identity `1`. In other words, if every element of a list is the identity element of a monoid, then the product of all elements in the list is also the identity element.

For any monoid `M` and list `l` of elements from `M` where every element is the identity `1`, the product of all elements in `l` is equal to the identity `1`.


theorem lt_mul_of_one_le_of_lt :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      1 ≤ a → b < c → b < a * c :=
  by sorry

The theorem `lt_mul_of_one_le_of_lt` states that for any type `α` that has a multiplication and one operation (`MulOneClass α`), and is a preorder (Preorder α) and a covariant class, and for any elements `a`, `b`, `c` of type `α`, if `1` is less than or equal to `a` and `b` is less than `c`, then `b` is less than the product of `a` and `c`. This theorem essentially states that if `a` is at least `1` and `b` is smaller than `c`, then `b` is also smaller than the result of multiplying `a` and `c`, under the conditions of the type `α`.

If `α` is a preorder type with multiplication and one operation, and `1 ≤ a` and `b < c`, then `b < a * c`.


theorem Set.ordConnected_iInter :
    ∀ {α : Type u_1} [inst : Preorder α] {ι : Sort u_3} {s : ι → Set α},
      (∀ (i : ι), Set.OrdConnected (s i)) → Set.OrdConnected (⋂ i, s i) :=
  by sorry

This theorem states that for any type `α` with a preorder structure and any indexed collection `{s : ι → Set α}` of sets, if each set `s i` in this collection is order-connected (meaning for any two points in the set, all points between them are also in the set), then the intersection of all these sets (⋂ i, s i) is also order-connected. In other words, if every set in a collection is order-connected, their intersection retains this property.

If each set in an indexed collection of order-connected sets in a preordered type intersects to form a non-empty set, then the resulting intersection is also order-connected.


theorem Nat.pos_of_mem_factors : ∀ {n p : ℕ}, p ∈ Nat.factors n → 0 < p := by sorry

This theorem states that for any natural numbers `n` and `p`, if `p` is an element of the prime factorization of `n` (denoted as `Nat.factors n`), then `p` is greater than zero. In other words, every prime factor of a natural number is positive.

Every prime factor of a natural number is a positive number.


theorem toIocDiv_sub_eq_toIocDiv_add :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b c : α),
      toIocDiv hp a (b - c) = toIocDiv hp (a + c) b :=
  by sorry

This theorem states that for any type `α` that forms a linearly ordered additive commutative group and has the Archimedean property, and for any positive element `p` of `α`, and any three elements `a`, `b`, and `c` of `α`, the unique integer obtained by subtracting `c` from `b` and then applying the `toIocDiv` operation with parameters `hp` and `a`, is the same as the unique integer obtained by adding `c` to `a` and then applying the `toIocDiv` operation with parameters `hp` and `b`. In other words, the process of subtracting `c` from `b` before the `toIocDiv` operation is interchangeable with the process of adding `c` to `a` before the `toIocDiv` operation.

For any linearly ordered additive commutative group `α` with the Archimedean property and positive element `p`, the result of subtracting `c` from `b` and then taking the integer quotient with `p` is equal to the result of adding `c` to `a` and then taking the integer quotient with `p`, for all `a, b, c` in `α`.


/-- Seminorm-balls at the origin are absorbent.  -/
theorem Seminorm.absorbent_ball_zero :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      (p : Seminorm 𝕜 E) {r : ℝ}, 0 < r → Absorbent 𝕜 (Seminorm.ball p 0 r) :=
  by sorry

The theorem `Seminorm.absorbent_ball_zero` states that for any seminorm `p` and any positive real number `r`, the seminorm ball of radius `r` centered at the origin is an absorbent set. Here, a set is said to be absorbent if it "absorbs" every singleton, i.e., for every element `x`, there is a scalar `m` such that `m * x` is in the set. The seminorm ball of radius `r` at the origin is the set of all elements `y` such that the seminorm of `y - 0` (i.e., `y` itself) is less than `r`.

For any seminorm `p` and positive real number `r`, the seminorm ball of radius `r` centered at the origin is an absorbent set. In other words, for all `x`, there exists a scalar `m` such that `m * x` belongs to the seminorm ball of `x` with radius `r`.


theorem FirstOrder.Language.BoundedFormula.castLE_rfl :
    ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} (h : n ≤ n) (φ : FirstOrder.Language.BoundedFormula L α n),
      FirstOrder.Language.BoundedFormula.castLE h φ = φ :=
  by sorry

This theorem states that for any first-order language `L`, type `α`, and natural number `n`, if we have a proof `h` that `n` is less than or equal to `n` itself (which is always true by reflexivity), then the effect of casting a bounded formula `φ` of `L` with the bound `n` using `h` is a no-op. That is, `FirstOrder.Language.BoundedFormula.castLE h φ` is identical to the original formula `φ`. This asserts the reflexivity of the cast operation under the condition of equality in the language `L`.

For any first-order language `L`, type `α`, and bounded formula `φ` of `L` with bound `n`, if `n` equals `n`, then casting `φ` with `n` using a reflexivity proof is a no-op.


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

This theorem states that for any linearly ordered field `α` and any elements `a`, `b`, and `c` of `α`, if `c` is less than zero, then `a` is less than `b` divided by `c` if and only if `b` is less than `a` multiplied by `c`. This theorem basically provides a condition for when the inequality between `a` and `b/c` is equivalent to the inequality between `b` and `ac`, given that `c` is negative in the field.

For any linearly ordered field `α` and elements `a`, `b`, and `c` in `α` with `c` negative, `a < b / c` if and only if `b < a * c`.


theorem csSup_mem_of_not_isSuccLimit :
    ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {s : Set α},
      Set.Nonempty s → BddAbove s → ¬Order.IsSuccLimit (sSup s) → sSup s ∈ s :=
  by sorry

This theorem states that for any non-empty set `s` of elements of type `α`, where `α` is a conditionally complete linear order, if `s` is bounded above and the supremum of `s` (denoted as `sSup s`) is not a successor limit, then `sSup s` is an element of `s`.

In other words, the least upper bound or supremum of a non-empty set that has an upper bound and is not a successor limit, is guaranteed to be an element of the set itself.

If `s` is a non-empty, bounded above subset of a conditionally complete linear order `α` without a successor limit supreme, then `sSup s` is an element of `s`.


theorem ClusterPt.of_le_nhds' :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {f : Filter X}, f ≤ nhds x → Filter.NeBot f → ClusterPt x f := by
  sorry

The theorem `ClusterPt.of_le_nhds'` states that for any type `X` equipped with a topology, any point `x` in `X`, and any filter `f` on `X`, if `f` is greater than or equal to the neighborhood filter at `x` and `f` is not the bottom filter, then `x` is a cluster point of the filter `f`. In other words, it asserts that if a filter `f` doesn't contain the empty set and includes all neighborhood sets of `x`, then `x` is a limit point of `f`, meaning that every neighborhood of `x` contains a point in `f`.

If a filter on a topological space contains the neighborhood filter of a point and is not the bottom filter, then that point is a cluster point of the filter.


Measurable.nullMeasurable

theorem Measurable.nullMeasurable :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α}, Measurable f → MeasureTheory.NullMeasurable f μ :=
  by sorry

This theorem states that for any two types `α` and `β`, each equipped with a measurable space structure, and for any function `f` from `α` to `β` and a measure `μ` on `α`, if `f` is a measurable function, then it is also a null measurable function with respect to the measure `μ`. In other words, the preimage of any measurable set under `f` is a null measurable set with respect to `μ`.

For any measurable functions `f: α → β` between measurable spaces `(α, Σα)` and `(β, Σβ)` with measure `μ` on `Σα`, the preimage of any measurable set `E ∈ Σβ` is a null set with respect to `μ`: `∀E ∈ Σβ, f⁻¹(E) ∈ Σα, μ(f⁻¹(E)) = 0`.


/-- A relation is well-founded iff it doesn't have any infinite decreasing sequence.  -/
theorem RelEmbedding.wellFounded_iff_no_descending_seq :
    ∀ {α : Type u_1} {r : α → α → Prop} [inst : IsStrictOrder α r],
      WellFounded r ↔ IsEmpty ((fun x x_1 => x > x_1) ↪r r) :=
  by sorry

This theorem states that, for any type `α` and a relation `r` on `α` where `r` is a strict order, the relation `r` is well-founded if and only if there does not exist any infinite decreasing sequence. In other words, a relation is well-founded when it's impossible to find an infinite sequence where each element is strictly larger than the next according to the relation `r`. This means that for every nonempty subset, there is a minimal element with respect to the relation `r`.

A relation on a type is well-founded if and only if there is no infinite decreasing sequence with respect to the relation.


theorem Set.MapsTo.union_union :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
      Set.MapsTo f s₁ t₁ → Set.MapsTo f s₂ t₂ → Set.MapsTo f (s₁ ∪ s₂) (t₁ ∪ t₂) :=
  by sorry

The theorem `Set.MapsTo.union_union` states that for any two sets `s₁` and `s₂` of type `α` and any two sets `t₁` and `t₂` of type `β`, given a function `f` from `α` to `β`, if `f` maps every element of `s₁` to an element of `t₁` and every element of `s₂` to an element of `t₂`, then `f` also maps every element of the union of `s₁` and `s₂` to an element in the union of `t₁` and `t₂`. In other words, it proves that mapping under a function preserves the union operation.

If functions `f` map every element of sets `s₁` and `s₂` to elements in `t₁` and `t₂`, respectively, then `f` maps every element of `s₁ ∪ s₂` to an element in `t₁ ∪ t₂`.


/-- The image of `h ≫ f` is always a smaller subobject than the image of `f`.  -/
theorem CategoryTheory.Limits.imageSubobject_comp_le :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y X' : C} (h : X' ⟶ X) (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f]
      [inst_2 : CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp h f)],
      CategoryTheory.Limits.imageSubobject (CategoryTheory.CategoryStruct.comp h f) ≤
        CategoryTheory.Limits.imageSubobject f :=
  by sorry

This theorem states that within a category `C`, for any objects `X`, `Y`, and `X'`, and morphisms `h` from `X'` to `X` and `f` from `X` to `Y`, if the morphism `f` has an image and the composition of `h` and `f` (`h ≫ f`) also has an image, then the image of the composition (`h ≫ f`) is always a subobject of, or equal to, the image of `f`. This implies that the image of `f` contains all the information about the image of the composition `h ≫ f`.

If `h: X' -> X` and `f: X -> Y` are morphisms in a category `C` with images, then the image of `h ≫ f` is a subobject of, or equal to, the image of `f`.


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

The theorem `Finset.prod_comm` states that for all types `α`, `β`, and `γ`, given a commutative monoid over `β`, and given finite sets `s` of type `γ` and `t` of type `α`, and a function `f` that maps each pair of elements from `s` and `t` to `β`, the product over `s` of the function which itself is the product over `t` of `f`, is equal to the product over `t` of the function which itself is the product over `s` of `f`. In other words, the order of taking product over two finite sets does not affect the result, which mirrors the commutative property of multiplication in mathematics.

For all commutative monoids over type `β`, and finite sets `s` of type `γ` and `t` of type `α`, the function `f` mapping pairs of elements from `s` and `t` to `β` satisfies `∏(s, f ∘ ∏(t, f)) = ∏(t, f ∘ ∏(s, f))`.


theorem List.rotate'_eq_drop_append_take :
    ∀ {α : Type u} {l : List α} {n : ℕ}, n ≤ List.length l → List.rotate' l n = List.drop n l ++ List.take n l := by
  sorry

This theorem states that for any given list `l` of items of arbitrary type `α` and a non-negative integer `n` such that `n` is less than or equal to the length of the list `l`, rotating the list `l` `n` times is equivalent to removing the first `n` elements from the list `l` and appending them to the end of the list. This is expressed in Lean 4 with the `List.rotate'`, `List.drop` and `List.take` functions. In mathematical notation, we could express this as: for all lists `l` and all `n` such that `n ≤ |l|`, it holds that `rotate'(l, n) = drop(n, l) ++ take(n, l)`, where `|l|` represents the length of the list `l`, and `++` represents list concatenation.

For any list `l` of length `|l|` and non-negative integer `n` with `n <= |l|`, list rotation `n` times (`rotate'(l, n)`) is equivalent to list prefix removal and suffix addition (`drop(n, l) ++ take(n, l)`).


DifferentiableAt.add

theorem DifferentiableAt.add :
    ∀ {𝕜 : 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] {f g : E → F}
      {x : E}, DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 g x → DifferentiableAt 𝕜 (fun y => f y + g y) x :=
  by sorry

The theorem `DifferentiableAt.add` states that if we have two functions `f` and `g` from `E` to `F` that are both differentiable at a point `x`, then the function that is the pointwise sum of `f` and `g` is also differentiable at `x`. Here, `E` and `F` are normed additively commutative groups over a nontrivially normed field `𝕜`. The pointwise sum of `f` and `g` is the function that at any `y` in `E` returns the sum of `f y` and `g y` in `F`.

If functions `f` and `g` are differentiable at point `x` in the normed additively commutative groups `E` and `F` over a nontrivially normed field `𝕜`, then their pointwise sum `f + g` is differentiable at `x`.


theorem AnalyticAt.aeval_mvPolynomial :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {A : Type u_3} {B : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : CommSemiring A] {z : E}
      [inst_4 : NormedCommRing B] [inst_5 : NormedAlgebra 𝕜 B] [inst_6 : Algebra A B] {σ : Type u_5} {f : E → σ → B},
      (∀ (i : σ), AnalyticAt 𝕜 (fun x => f x i) z) →
        ∀ (p : MvPolynomial σ A), AnalyticAt 𝕜 (fun x => (MvPolynomial.aeval (f x)) p) z :=
  by sorry

The theorem `AnalyticAt.aeval_mvPolynomial` states that for any type 𝕜, which is a nontrivially normed field, types E and A, which are normed add comm group and comm semiring respectively, a type B which is a normed comm ring and a normed algebra over 𝕜, a type σ, and a function `f : E → σ → B`, if for every i in σ, the function `fun x => f x i` is analytic at a point z in E, then for every multivariate polynomial p with coefficients in A and variables indexed by σ, the function `fun x => (MvPolynomial.aeval (f x)) p` will also be analytic at the point z. In simpler terms, it states that if each component of a vector-valued function is analytic, then the function that maps each point to the evaluation of a multivariate polynomial with coefficients in A and variables replaced by the values of the function at that point, is also analytic.

If `f : E → σ → B` is a vector-valued function of analytic components over a nontrivially normed field 𝕜, then the function `x ↦ MvPolynomial.aeval (f x) p` is analytic at a point `z ∈ E` for any multivariate polynomial `p` with coefficients in the normed semiring A.


Set.Pairwise.imp

theorem Set.Pairwise.imp :
    ∀ {α : Type u_1} {r p : α → α → Prop} {s : Set α},
      Set.Pairwise s r → (∀ ⦃a b : α⦄, r a b → p a b) → Set.Pairwise s p :=
  by sorry

This theorem states that for any type `α`, two relations `r` and `p` on `α`, and a set `s` of elements from `α`, if the relation `r` holds pairwise on the set `s` and every pair in which `r` holds implies `p` holds, then the relation `p` also holds pairwise on the set `s`. In other words, if `r` is a stronger relation than `p` and `r` holds for all distinct pairs in the set `s`, then `p` also holds for all distinct pairs in the set `s`.

If `r` is a transitive relation on type `α` that holds between all distinct elements in `s`, and `r` implies `p`, then `p` is also a relation that holds pairwise between all distinct elements in `s`.