/-- **Fundamental theorem of calculus-1**, strict differentiability in the right endpoint.

If `f : ℝ → E` is integrable on `a..b` and `f` is continuous at `b`, then `u ↦ ∫ x in a..u, f x` has
derivative `f b` at `b` in the sense of strict differentiability.  -/
theorem intervalIntegral.integral_hasStrictDerivAt_right :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f : ℝ → E}
      {a b : ℝ},
      IntervalIntegrable f MeasureTheory.volume a b →
        StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
          ContinuousAt f b → HasStrictDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) (f b) b :=
  by sorry

The **Fundamental Theorem of Calculus-1**, in the context of strict differentiability at the right endpoint, asserts that if a function `f : ℝ → E` (where `E` is a normed and complete additive commutative group) is interval integrable on `a..b` and `f` is continuous at `b`, then the function `u ↦ ∫ x in a..u, f x` has a strict derivative at `b` which is `f b`. This theorem is a cornerstone of calculus, linking the concept of an integral to the derivative of the function. It provides the rigorous foundation for the process of finding antiderivatives by integrating a function.

If a function `f : ℝ → E` is continuous at `b` and interval integrable on `a..b` (where `E` is a normed and complete additive commutative group), then the definite integral `∫ x in a..b, f x` has a strict derivative at `b` equal to `f b`.


/-- Main theorem on differentiation of measures: given a Vitali family `v` for a locally finite
measure `μ`, and another locally finite measure `ρ`, then for `μ`-almost every `x` the
ratio `ρ a / μ a` converges, when `a` shrinks to `x` along the Vitali family, towards the
Radon-Nikodym derivative of `ρ` with respect to `μ`.  -/
theorem VitaliFamily.ae_tendsto_rnDeriv :
    ∀ {α : Type u_1} [inst : MetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (v : VitaliFamily μ)
      [inst_1 : SecondCountableTopology α] [inst_2 : BorelSpace α] [inst_3 : MeasureTheory.IsLocallyFiniteMeasure μ]
      (ρ : MeasureTheory.Measure α) [inst_4 : MeasureTheory.IsLocallyFiniteMeasure ρ],
      ∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun a => ↑↑ρ a / ↑↑μ a) (VitaliFamily.filterAt v x) (nhds (ρ.rnDeriv μ x)) :=
  by sorry

This theorem states that given a Vitali family `v` for a locally finite measure `μ`, and another locally finite measure `ρ`, then for almost every point `x` with respect to the measure `μ`, the ratio of `ρ` to `μ` over sets `a` that shrink to `x` along the Vitali family, converges towards the Radon-Nikodym derivative of `ρ` with respect to `μ`. This is central to the concept of differentiation of measures. Here, convergence is described in terms of filters, with the ratio converging to the Radon-Nikodym derivative as per the filter of sets constructed from the Vitali family at `x`, and the neighborhood filter at the Radon-Nikodym derivative.

Given a Vitali family `v` for a locally finite measures `μ` and `ρ`, for almost every `x` with respect to `μ`, the ratio of `ρ` to `μ` on shrinking sets `a` converges to the Radon-Nikodym derivative of `ρ` with respect to `μ` as filters at `x` and the Radon-Nikodym derivative.


ContDiff.differentiable

/-- If a function is `C^n` with `n ≥ 1`, then it is differentiable.  -/
theorem ContDiff.differentiable :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞}, ContDiff 𝕜 n f → 1 ≤ n → Differentiable 𝕜 f :=
  by sorry

The theorem `ContDiff.differentiable` states that for any function `f` mapping from a normed space `E` to another normed space `F` over a nontrivially normed field `𝕜`, if `f` is continuously differentiable `n` times for `n` equal to or greater than 1 (`C^n` with `n ≥ 1`), then `f` is differentiable at any point. In mathematical terms, if a function is `C^n` for `n ≥ 1`, then it is differentiable everywhere.

A continuously differentiable function of class `C^n` with `n ≥ 1` from a normed space to another normed space is differentiable at every point.


theorem Sum.lex_inr_inl :
    ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {b : β} {a : α},
      ¬Sum.Lex r s (Sum.inr b) (Sum.inl a) :=
  by sorry

This theorem states that for any types `α` and `β`, any binary relations `r` on `α` and `s` on `β`, and any elements `a` of `α` and `b` of `β`, it is not possible for the lexicographical order `Sum.Lex r s` of the sum type `α ⊕ β` to order `Sum.inr b` (a value from `β`) before `Sum.inl a` (a value from `α`). In other words, values from `α` (wrapped in `Sum.inl`) will always come before values from `β` (wrapped in `Sum.inr`) in this lexicographical order.

For any binary relations r on type α and s on type β, the lexicographical order Sum.Lex r s does not order Sum.inr b before Sum.inl a for any types α, β, elements a from α, and b from β.


theorem MeasureTheory.snorm_congr_norm_ae :
    ∀ {α : Type u_1} {F : Type u_3} {G : Type u_4} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
      (∀ᵐ (x : α) ∂μ, ‖f x‖ = ‖g x‖) → MeasureTheory.snorm f p μ = MeasureTheory.snorm g p μ :=
  by sorry

The theorem `MeasureTheory.snorm_congr_norm_ae` states that for any two functions `f` and `g` from a measure space `α` to normed additive commutative groups `F` and `G` respectively, and for any extended nonnegative real number `p` and a measure `μ` on `α`, if the norm of `f(x)` is almost everywhere equal to the norm of `g(x)`, then the seminorm `ℒp` of `f` with respect to `p` and `μ` equals the seminorm `ℒp` of `g` with respect to `p` and `μ`. Here, almost everywhere means except on a set of measure zero. The seminorm `ℒp` is defined as `0` for `p=0`, `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and `essSup ‖f‖ μ` for `p = ∞`.

For measurable functions `f: α → F` and `g: α → G` from a measure space `(α, μ)` to normed additive commutative groups `F` and `G` respectively, with `p ≥ 0` an extended real number, if the norms of `f(x)` and `g(x)` are almost equal for all `x ∈ α` except a set of measure zero, then `ℒp(f) = ℒp(g)`, where `ℒp(f)` denotes the seminorm of `f` with respect to `p` and `μ`.


theorem Option.mem_unique : ∀ {α : Type u_1} {o : Option α} {a b : α}, a ∈ o → b ∈ o → a = b := by sorry

This theorem, `Option.mem_unique`, states that for any type `α`, any instance of `Option α` denoted by `o`, and any two instances of `α` denoted by `a` and `b`, if both `a` and `b` are members of `o`, then `a` must be equal to `b`. In other words, it guarantees that an Option type in Lean 4 can't contain more than one distinct value, reinforcing the concept of an Option as a container that either holds one value or none.

Given an Option type `o` of any type `α`, if `a` and `b` are two elements in `o`, then `a = b`.


theorem minpoly.isIntegrallyClosed_dvd_iff :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R]
      [inst_3 : Algebra R S] [inst_4 : IsDomain S] [inst_5 : NoZeroSMulDivisors R S] [inst_6 : IsIntegrallyClosed R]
      {s : S}, IsIntegral R s → ∀ (p : Polynomial R), (Polynomial.aeval s) p = 0 ↔ minpoly R s ∣ p :=
  by sorry

The theorem `minpoly.isIntegrallyClosed_dvd_iff` asserts that for any commutative ring `R`, commutative ring `S`, `R`-algebra structure on `S`, and a chosen element `s` from `S` which is integral over `R`, a polynomial `p` from `R` satisfies that its evaluation at `s` equals zero if and only if the minimal polynomial of `s` over `R` divides `p`. The theorem's conditions also require that `R` is an integral domain, `S` is an integral domain, `R` and `S` have no zero divisors under scalar multiplication, and `R` is integrally closed.

A polynomial in an integrally closed integrally dominated commutative ring evaluates to zero at an algebraic element if and only if it is divisible by the element's minimal polynomial.


theorem Fintype.choose_spec :
    ∀ {α : Type u_1} [inst : Fintype α] (p : α → Prop) [inst_1 : DecidablePred p] (hp : ∃! a, p a),
      p (Fintype.choose p hp) :=
  by sorry

The theorem `Fintype.choose_spec` states that for a given finite type `α`, a predicate `p` over `α`, and the proof `hp` that there exists a unique element in `α` that satisfies `p`, the element `α` produced by `Fintype.choose` using `p` and `hp` also satisfies `p`. In other words, the element chosen by `Fintype.choose` is guaranteed to satisfy the original predicate `p`.

If `α` is a finite type, `p` is a predicate on `α`, and there exists a unique element `x` in `α` such that `p(x)` holds, then `Fintype.choose x p hp` satisfies `p`.


theorem upperBounds_insert :
    ∀ {α : Type u} [inst : Preorder α] (a : α) (s : Set α), upperBounds (insert a s) = Set.Ici a ∩ upperBounds s := by
  sorry

The theorem `upperBounds_insert` states that for any type `α` that has a pre-order relation (a relation that is reflexive and transitive), for any element `a` of type `α` and any set `s` of elements of type `α`, the set of upper bounds of the set obtained by inserting `a` into `s` is equal to the intersection of the set of all elements that are greater than or equal to `a` and the set of upper bounds of `s`. In other words, an element is an upper bound of the inserted set if and only if it is an upper bound of the original set `s` and is also greater than or equal to `a`.

For any pre-order relation on type `α`, the upper bounds of an element `a` inserted into a set `s` equal the intersection of the upper bounds of `s` and elements greater than or equal to `a`.


theorem Bool.xor_true : ∀ (x : Bool), xor x true = !x := by sorry

This theorem, `Bool.xor_true`, states that for any boolean value `x`, the exclusive or (`xor`) of `x` and `true` is equal to the negation of `x`. In simpler words, if you apply 'xor' operation between any boolean and 'true', you would get the opposite of that boolean. For instance, if `x` is `true`, its 'xor' with 'true' would be 'false' and vice versa.

For any boolean value x, xor(x, true) = ∼x. (Here, xor denotes exclusive or, and ∼ denotes logical negation.)


/-- A generalization of **Sylow's first theorem**.
Every `p`-subgroup is contained in a Sylow `p`-subgroup.  -/
theorem IsPGroup.exists_le_sylow :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {P : Subgroup G}, IsPGroup p ↥P → ∃ Q, P ≤ ↑Q := by sorry

This theorem represents a generalization of Sylow's first theorem. It states that for any natural number `p` and any type `G` with a group structure, given a `p`-subgroup `P` of `G` satisfying the property of being a `p`-group, there exists a Sylow `p`-subgroup `Q` of `G` such that `P` is contained in `Q`. In mathematical terms, for every `p`-group (a group where every element has order a power of a prime `p`), it is always possible to find a Sylow `p`-subgroup that contains it.

For any prime number `p` and `p`-group `P` in a group `G`, there exists a Sylow `p`-subgroup `Q` of `G` containing `P`.


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

This theorem states that for any commutative monoid `M`, a submonoid `S` of `M`, another commutative monoid `N`, yet another commutative monoid `P`, a localization map `f` from `S` to `N`, a monoid homomorphism `j` from `N` to `P`, and an element `y` of `S`, the result of first applying the localization map `f` on `y` and then applying the monoid homomorphism `j` on the result, is a unit of the final monoid `P`. In other words, the result has a two-sided inverse in `P`. This can be expressed as `IsUnit ((MonoidHom.comp j (Submonoid.LocalizationMap.toMap f)) ↑y)`. The notation `MonoidHom.comp j (Submonoid.LocalizationMap.toMap f)` refers to the composition of the monoid homomorphism `j` and the localization map `f`.

For any commutative monoids M, N, and P, a submonoid S of M, a localization map f from S to N, a monoid homomorphism j from N to P, and any element y in S, the composite of j and the localization map f at y is a unit in P.


theorem List.nodupKeys_iff_pairwise :
    ∀ {α : Type u} {β : α → Type v} {l : List (Sigma β)},
      List.NodupKeys l ↔ List.Pairwise (fun s s' => s.fst ≠ s'.fst) l :=
  by sorry

This theorem states that for any list `l` of Sigma types, indexed by a type function `β` on a type `α`, the list has no duplicate keys if and only if for every pair of elements `s` and `s'` in the list, the first components of `s` and `s'` (usually the keys in the context of a key-value pair) are not equal. In terms of the data structure, this means that the list behaves like a map or a dictionary, where no two elements share the same key.

For any list of pairs (α × β) indexed by β, the list has no duplicate keys if and only if the projection of the first component of each pair in the list are pairwise distinct.


theorem Complex.ofReal_cos_ofReal_re : ∀ (x : ℝ), ↑(Complex.cos ↑x).re = Complex.cos ↑x := by sorry

This theorem states that for every real number `x`, the real part of the complex cosine of `x` (when `x` is considered as a complex number) is equal to the complex cosine of `x`. In other words, taking the real part doesn't change the value of the complex cosine function when it's applied to a real number. More formally, for all real numbers `x`, we have `ℝ(Complex.cos(ℂx)) = Complex.cos(ℂx)`.

The real part of the complex cosine of a real number equals the complex cosine of that real number. In Lean notation, for all real numbers x, ℝ(Complex.cos(ℂx)) = Complex.cos(ℂx).


/-- A natural number is odd iff it has residue `1` or `3` mod `4` -/
theorem Nat.odd_mod_four_iff : ∀ {n : ℕ}, n % 2 = 1 ↔ n % 4 = 1 ∨ n % 4 = 3 := by sorry

This theorem states that a natural number is odd if and only if its remainder when divided by 4 is either 1 or 3. In other words, it characterizes odd numbers in terms of their residues modulo 4.

A natural number is odd if and only if its residue modulo 4 is 1 or 3.


theorem Submonoid.LocalizationMap.mk'_self' :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (y : ↥S), Submonoid.LocalizationMap.mk' f (↑y) y = 1 :=
  by sorry

The theorem `Submonoid.LocalizationMap.mk'_self'` states that for any commutative monoid `M`, any submonoid `S` of `M`, any commutative monoid `N`, any localization map `f` from `S` to `N`, and any element `y` of `S`, if we use the localization map `f` on the pair `(y, y)`, where `y` is considered in `M` and `S` respectively, then the result is the multiplicative identity of `N`, that is, one. This is essentially checking a property of the localization map where an element and its localization to `N` are equivalent in the localization.

For any commutative monoids M, N, submonoid S of M, localization map f from S to N, and element y in S, the localization of the pair (y, y) under f equals the multiplicative identity of N.


theorem Mathlib.Data.List.Infix._auxLemma.11 : ∀ {α : Type u_1} (s t : List α), (s ∈ List.tails t) = (s <:+ t) := by
  sorry

This theorem states that for any two lists `s` and `t` of some type `α`, `s` is an element of the list of tails of `t` if and only if `s` is a suffix of `t`. In other words, the list `s` appears as the last few elements of `t` exactly when `s` is one of the terminal segments of `t`. The `<:+` operator in Lean is used to express the "is a suffix of" relation.

For any list `s` and `t` of type `α`, `s` is a suffix of `t` if and only if `s` is an element of the list of tails of `t`.


theorem tsum_eq_zero_iff :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α}, Summable f → (∑' (i : ι), f i = 0 ↔ ∀ (x : ι), f x = 0) :=
  by sorry

The theorem `tsum_eq_zero_iff` states that for any types `ι` and `α`, where `α` forms a canonically ordered additive commutative monoid with an associated topological space and the order topology is closed, if a function `f : ι → α` is summable, then the infinite sum of `f` over all `ι` being equal to zero is equivalent to the statement that the function `f` is zero at every element of `ι`. In other words, a summable function's infinite sum is zero if and only if the function is zero everywhere.

A summable function from a type `ι` to a canonically ordered, additive commutative monoid `α` with a closed order topology has the property that its infinite sum is zero if and only if the function is identically zero.


theorem Mathlib.GroupTheory.Index._auxAddLemma.12 :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), AddSubgroup.index H = AddSubgroup.relindex H ⊤ := by sorry

This theorem states that for any additive group `G` and its subgroup `H`, the index of `H` is equal to the relative index of `H` with respect to the entire group `G` (denoted by `⊤`). In other words, the number of distinct cosets of `H` in `G` is the same as the count of distinct cosets when considering `G` itself as the larger subgroup. The index returns 0 in the case of infinite number of cosets.

For any additive group `G` and its subgroup `H`, the number of cosets of `H` in `G` equals the order of `G/H`.


theorem Mathlib.Combinatorics.SetFamily.Compression.Down._auxLemma.3 :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α},
      (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) :=
  by sorry

This theorem states that for any type `α`, any decidable predicate `p` on `α`, any finite set `s` of `α`, and any element `a` of `α`, the element `a` is in the filtered set `s` under predicate `p` if and only if `a` is in the original set `s` and `a` satisfies the predicate `p`. In other words, the filtered set contains exactly those elements of the original set which satisfy the predicate.

For any type `α`, decidable predicate `p` on `α`, and finite set `s` of `α`, the filtered set `s` under `p` equals the set of elements in `s` that satisfy `p`.


theorem Multiset.nodup_iff_count_le_one :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α}, Multiset.Nodup s ↔ ∀ (a : α), Multiset.count a s ≤ 1 := by
  sorry

The theorem `Multiset.nodup_iff_count_le_one` states that for any type `α` with decidable equality and any multiset `s` of type `α`, the property that `s` has no duplicates (denoted by `Multiset.Nodup s`) is equivalent to the property that the count of any element `a` in `s` is less than or equal to one. This provides a characterization of a multiset with no duplicates in terms of the multiplicity of its elements.

For any type `α` with decidable equality and any multiset `s` of type `α`, `Multiset.Nodup s` if and only if for all `a` in `α`, the count of `a` in `s` is less than or equal to one.


Monotone.leftLim

theorem Monotone.leftLim :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f → Monotone (Function.leftLim f) :=
  by sorry

The theorem `Monotone.leftLim` states that for any types `α` and `β`, where `α` has a Linear Order, `β` has a Conditionally Complete Linear Order, a Topological Space structure, and an Order Topology, if a function `f` from `α` to `β` is Monotone (i.e., if `a ≤ b` implies `f a ≤ f b`), then the left-hand limit function `Function.leftLim f` of `f` is also Monotone.

If `f` is a monotonic function from a linearly ordered type `α` to a conditionally complete linearly ordered topological space `β`, then the left-limit function of `f` is also monotonic.


theorem ContDiffBump.support_normed_eq :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
      [inst_3 : MeasurableSpace E] {c : E} (f : ContDiffBump c) {μ : MeasureTheory.Measure E} [inst_4 : BorelSpace E]
      [inst_5 : FiniteDimensional ℝ E] [inst_6 : MeasureTheory.IsLocallyFiniteMeasure μ]
      [inst_7 : MeasureTheory.Measure.IsOpenPosMeasure μ],
      Function.support (ContDiffBump.normed f μ) = Metric.ball c f.rOut :=
  by sorry

This theorem states that for a given continuously differentiable bump function `f` centered at `c` in a finite-dimensional normed add-commutative group `E` over the real numbers, the support of the normalized version of the bump function (where the normalization is such that the integral of the function over the measure space equals one) is equal to the open ball centered at `c` with radius equal to the outer radius of the bump function. Here, the measure space is assumed to have Borel-measurable sets, to be locally finite, and to have positive measure for open sets.

For a continuously differentiable bump function `f` over a finite-dimensional normed add-commutative group `E` with center `c`, the support of the normalized version of `f` equals the open ball centered at `c` with radius equal to the outer radius of `f`, in a measure space with Borel-measurable sets, local finiteness, and positive measure for open sets.


theorem List.getD_eq_getD_get? :
    ∀ {α : Type u} (l : List α) (d : α) (n : ℕ), List.getD l n d = Option.getD (List.get? l n) d := by sorry

This theorem, `List.getD_eq_getD_get?`, states that for any given type `α`, list `l` of type `α`, default value `d` of type `α`, and natural number `n`, the result of calling the `getD` function on list `l` with index `n` and default value `d` is equal to the result of calling the `getD` function on the result of `get?` function call on the same list `l` with index `n`, using the same default value `d`. Essentially, it asserts that these two ways of retrieving an element from a list at a specific index, providing a default if the index is not valid, are equivalent.

For any type `α`, list `l` of length `n+1` over `α`, default value `d` in `α`, and natural number `n`, `getD l n d = getD (get? l n) n d`.


theorem MeasureTheory.Measure.restrict_mono_ae :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      s ≤ᶠ[MeasureTheory.Measure.ae μ] t → μ.restrict s ≤ μ.restrict t :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` over the type `α`, a measure `μ` on the measurable space, and any two sets `s` and `t` of type `α`, if the set `s` is almost everywhere less than or equal to the set `t` with respect to the measure `μ` (i.e., `s` is a subset of `t` except possibly on a set of measure zero), then the restriction of the measure `μ` to the set `s` is less than or equal to the restriction of the measure `μ` to the set `t`. In other words, the measure of the set `s` under its almost everywhere condition is less than or equal to the measure of the set `t`.

For any measurable spaces `(α, m0)` and measures `μ`, if `s ⊆ t` almost everywhere and `μ(t) < ∞`, then `μ(s) ≤ μ(t)`.


theorem Multiset.card_range : ∀ (n : ℕ), Multiset.card (Multiset.range n) = n := by sorry

This theorem states that for any natural number `n`, the cardinality of the multiset obtained by the `range` function from `n` (which represents the multiset containing numbers from 0 to `n-1`) is equal to `n`. In other words, the number of elements in the multiset `{0, 1, ..., n-1}` is `n`.

The cardinality of the multiset generated by the `range` function from a natural number equals that natural number.


theorem Int.sub_left_le_of_le_add : ∀ {a b c : ℤ}, a ≤ b + c → a - b ≤ c := by sorry

This theorem, named `Int.sub_left_le_of_le_add`, expresses a relation between integers `a`, `b`, and `c`. It states that for any integers `a`, `b`, and `c`, if `a` is less than or equal to the sum of `b` and `c` (expressed as `a ≤ b + c`), then `a` minus `b` is less than or equal to `c` (expressed as `a - b ≤ c`). This is a basic property arising from the arithmetic of integers.

If `a` is less than or equal to `b + c` for integers `a`, `b`, and `c`, then `a - b` is less than or equal to `c`.


theorem Init.SimpLemmas._auxLemma.1 : ∀ {a : Prop}, (a ∧ ¬a) = False := by sorry

This theorem, named `Init.SimpLemmas._auxLemma.1`, states that for any proposition `a`, the conjunction of `a` and its negation (i.e., `a` and `not a`) is equivalent to `False`. In other words, it is impossible for a proposition and its negation to both be true at the same time. This is a fundamental principle in classical logic known as the law of non-contradiction.

In classical logic, the conjunction of a proposition and its negation equals False.


theorem Real.arccos_cos : ∀ {x : ℝ}, 0 ≤ x → x ≤ Real.pi → Real.arccos (Real.cos x) = x := by sorry

This theorem states that for all real numbers `x` in the range from 0 to π (inclusive), the arc cosine of the cosine of `x` equals `x`. It essentially describes the property of the `arccos` function being the inverse of the `cos` function within the specified range. In mathematical terms, if 0 ≤ x ≤ π, then arccos(cos(x)) = x.

For all real numbers `x` in the range [0, π], the arc cosine of the cosine of `x` equals `x`: `arccos(cos x) = x`.


theorem CategoryTheory.NatTrans.leftDerived_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] [inst_2 : CategoryTheory.Abelian C]
      [inst_3 : CategoryTheory.HasProjectiveResolutions C] [inst_4 : CategoryTheory.Abelian D]
      {F G H : CategoryTheory.Functor C D} [inst_5 : CategoryTheory.Functor.Additive F]
      [inst_6 : CategoryTheory.Functor.Additive G] [inst_7 : CategoryTheory.Functor.Additive H] (α : F ⟶ G) (β : G ⟶ H)
      (n : ℕ),
      CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.comp α β) n =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftDerived α n)
          (CategoryTheory.NatTrans.leftDerived β n) :=
  by sorry

This theorem, `CategoryTheory.NatTrans.leftDerived_comp`, states that for any categories `C` and `D` where `C` is an Abelian category and has projective resolutions, and `D` is also an Abelian category, given three functors `F`, `G`, and `H` from `C` to `D` that are additive, along with natural transformations `α` from `F` to `G` and `β` from `G` to `H`, and a natural number `n`, the `n`-th left derived functor of the composition of `α` and `β` is equal to the composition of the `n`-th left derived functor of `α` and the `n`-th left derived functor of `β`. This is a statement about the commutativity of certain operations in the context of Category Theory and Homological Algebra.

For functors F, G, and H between Abelian categories C and D with projective resolutions, and additive natural transformations α: F ➔ G and β: G ➔ H, the n-th left derived functors of their composition agree, i.e., Lⁱ(H ∘ α) ≈ Lⁱ(α ∘ H).


theorem Subgroup.mul_mem_cancel_left :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x y : G}, x ∈ H → (x * y ∈ H ↔ y ∈ H) := by sorry

This is a theorem about groups and subgroups in the field of algebra. It states that for any group `G` and any subgroup `H` of `G`, and for any elements `x` and `y` of `G`, if `x` is an element of `H`, then the multiplication of `x` and `y` (`x * y`) is in `H` if and only if `y` is in `H`. In other words, within a group, if a member of a subgroup multiplies with any element and the result is still in the subgroup, then the other element must also be a member of the subgroup. This theorem applies to all types `G` that have a group structure.

For any group `G` and subgroup `H`, if `x ∈ H` and `y ∈ H`, then `x * y ∈ H`.


theorem Filter.HasBasis.inf_basis_neBot_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
      {s' : ι' → Set α},
      Filter.HasBasis l p s →
        Filter.HasBasis l' p' s' →
          (Filter.NeBot (l ⊓ l') ↔ ∀ ⦃i : ι⦄, p i → ∀ ⦃i' : ι'⦄, p' i' → Set.Nonempty (s i ∩ s' i')) :=
  by sorry

The theorem `Filter.HasBasis.inf_basis_neBot_iff` states that for any two types `α` and `ι`, and two sorts `ι'` and `u_5`, given any two filters `l` and `l'` over `α`, any two predicate functions `p : ι → Prop` and `p' : ι' → Prop`, and any two functions `s : ι → Set α` and `s' : ι' → Set α`, if `l` and `l'` are filter bases with respect to these functions, then the intersection of `l` and `l'` is not a bottom element (i.e., is non-empty) if and only if for all `i` in `ι` such that `p i` holds and for all `i'` in `ι'` such that `p' i'` holds, the intersection of the sets `s i` and `s' i'` is non-empty. In other words, two filter bases `l` and `l'` will have a non-empty intersection if and only if the corresponding sets of their valid basis elements also have a non-empty intersection.

Two filters over a type have a non-empty intersection as filter bases if and only if the corresponding sets of their valid basis elements intersect non-emptily for all pairs of elements valid under their respective predicate functions.


theorem FiniteDimensional.of_rank_eq_one :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
      Module.rank K V = 1 → FiniteDimensional K V :=
  by sorry

This theorem states that for any given division ring `K` and any additively commutative group `V` that is a `K`-module, if the rank of the module `V` over the ring `K` is equal to `1`, then `V` is a finite-dimensional vector space over `K`. In other words, if a `K`-module `V` can be generated by a single element, then it forms a finite-dimensional vector space.

If a one-dimensional `K`-module `V` over a division ring `K` is an additively commutative group, then `V` is a finite-dimensional vector space over `K`.


theorem MeasureTheory.ae_iff_measure_eq :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.IsFiniteMeasure μ]
      {p : α → Prop},
      MeasureTheory.NullMeasurableSet {a | p a} μ → ((∀ᵐ (a : α) ∂μ, p a) ↔ ↑↑μ {a | p a} = ↑↑μ Set.univ) :=
  by sorry

This theorem, `MeasureTheory.ae_iff_measure_eq`, states that for any type `α` with an associated measurable space `m0` and a finite measure `μ`, and any property `p` that elements of `α` might have, if the set of elements satisfying `p` is a null measurable set (i.e., a set that can be approximated by a measurable set up to a set of null measure), then the property `p` holds almost everywhere (i.e., everywhere except on a set of measure zero) if and only if the measure of the set of elements satisfying `p` is the same as the measure of the entire universal set. In other words, if we can approximate the set of elements satisfying `p` well enough, then `p` holds almost everywhere exactly when the set of elements satisfying `p` takes up the whole space in terms of measure.

For any measurable space `(α, m0)` with finite measure `μ`, a property `p` on `α` holds almost everywhere if and only if the measure of `{x : α | p x} = μ α`.


theorem Mathlib.Algebra.Order.Monoid.WithTop._auxLemma.41 :
    ∀ {α : Type u} [inst : Zero α] {a : α}, (↑a = 0) = (a = 0) := by sorry

This theorem, `Mathlib.Algebra.Order.Monoid.WithTop._auxLemma.41`, states that for any type `α` that has an instance of `Zero`, and for any element `a` of that type, the condition of `a` being equal to zero when lifted to the "with top" monoid (denoted as `↑a`) is equivalent to `a` being zero in the original type. In other words, `a` is zero in `α` if and only if its lift, `↑a`, is zero in the "with top" monoid.

For any type `α` with a `Zero` instance and any `a` in `α`, `a` is equal to zero in `α` if and only if `↑a` is zero in the "with top" monoid of `α`.


theorem Asymptotics.isBigOWith_fst_prod :
    ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} [inst : SeminormedAddCommGroup E']
      [inst_1 : SeminormedAddCommGroup F'] {f' : α → E'} {g' : α → F'} {l : Filter α},
      Asymptotics.IsBigOWith 1 l f' fun x => (f' x, g' x) :=
  by sorry

The theorem `Asymptotics.isBigOWith_fst_prod` states that for any type `α`, `E'` and `F'`, where `E'` and `F'` are semi-normed additive commutative groups, given a filter `l` on `α` and functions `f': α → E'` and `g': α → F'`, the function `f'` is bounded by the function that maps `x` to the ordered pair `(f' x, g' x)` in the sense of Big O notation with constant factor 1, under the filter `l`. In terms of Big O notation, this means `f'(x)` is O(`(f' x, g' x)`), and the ratio `‖f'‖ / ‖(f' x, g' x)‖` is eventually less than or equal to 1 for large `x`, according to the filter `l`.

For any type `α` and semi-normed additive commutative groups `E'` and `F'`, given a filter `l` on `α`, functions `f': α → E'` and `g': α → F'`, `f'` is Big O of the constant function mapping to `(f' x, g' x)` under filter `l`.


AnalyticAt.add

theorem AnalyticAt.add :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F} {x : E},
      AnalyticAt 𝕜 f x → AnalyticAt 𝕜 g x → AnalyticAt 𝕜 (f + g) x :=
  by sorry

The theorem `AnalyticAt.add` states that if `f` and `g` are two functions of type `E → F` that are analytic at a point `x`, then their sum `f + g` is also analytic at the same point `x`. Here, `𝕜` is a nontrivially normed field, `E` and `F` are normed add commutative groups over `𝕜`, and `E` and `F` are also normed spaces over `𝕜`. In the mathematical terms, it implies that the sum of two analytic functions is also an analytic function.

If `f : E -> F` and `g : E -> F` are analytic functions at a point `x in E` over a nontrivially normed field `𝕜`, then their sum `f + g` is also an analytic function at `x`.


theorem BoxIntegral.Prepartition.iUnion_restrict :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I),
      BoxIntegral.Prepartition.iUnion (BoxIntegral.Prepartition.restrict π J) =
        ↑J ∩ BoxIntegral.Prepartition.iUnion π :=
  by sorry

The theorem `BoxIntegral.Prepartition.iUnion_restrict` states that for any prepartition `π` of box `I` in the context of any indexing type `ι`, the union of all boxes within the restricted prepartition of `π` to box `J` is equivalent to the intersection of box `J` and the union of all boxes in prepartition `π`. In other words, when a prepartition `π` of a box `I` is restricted to a box `J`, the portion of `I` covered by this restriction is the same as the intersection of `J` with the portion of `I` covered by the original prepartition `π`.

For any prepartition π of a box I and indexing type ι, the restricted prepartition of π to box J equals the intersection of J with the union of boxes in π.


theorem PartialHomeomorph.map_extend_nhdsWithin :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H) {s : Set M} {y : M},
      y ∈ f.source →
        Filter.map (↑(PartialHomeomorph.extend f I)) (nhdsWithin y s) =
          nhdsWithin (↑(PartialHomeomorph.extend f I) y)
            (↑(PartialEquiv.symm (PartialHomeomorph.extend f I)) ⁻¹' s ∩ Set.range ↑I) :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, a normed add commutative group `E`, a normed space `E` over `𝕜`, and topological spaces `M` and `H`, given a partial homeomorphism `f` from `M` to `H`, a model with corners `I` from `𝕜`-based `E` to `H`, a set `s` of `M`, and an element `y` of `M` such that `y` is in the source of `f`, the map of the neighborhood filter within `s` at `y` under the extension of `f` by `I` is equal to the neighborhood filter within the preimage of `s` under the inverse of the extension of `f` by `I` and the range of `I` at the image of `y` under the extension of `f` by `I`.

In other words, extending the partial homeomorphism and then mapping the filter of neighborhoods corresponds to first mapping under the extended homeomorphism, and then taking the filter of neighborhoods within the preimage and range. This is a property relating the extension of homeomorphisms, filters, and inverse mappings in a specific topological and normed context.

For any nontrivially normed field `𝕜`, a normed add commutative group `E` over `𝕜`, and topological spaces `M` and `H`, given a partial homeomorphism `f` from `M` to `H`, a model with corners `I` from `𝕜`-based `E` to `H`, and an element `y` in `M` with image `z` in `H`, the neighborhood filters of `y` in `s` under `f` by `I` equal the neighborhood filters of `z` in `f(s)` under the inverse of `f` by `I` and the range of `I` at `z`.


theorem Set.IsPWO.image_of_monotone :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
      Set.IsPWO s → ∀ {f : α → β}, Monotone f → Set.IsPWO (f '' s) :=
  by sorry

The theorem `Set.IsPWO.image_of_monotone` states that for any types `α` and `β` with preorders, any subset `s` of `α` that is partially well-ordered, and any monotone function `f` from `α` to `β`, the image of `s` under `f` (denoted as `f '' s`) is also partially well-ordered. In other words, if a set is partially well-ordered and a function is monotone, then the set obtained by applying the function to every element of the original set is also partially well-ordered.

If `α` is a type with a preorder, `s ⊆ α` is partially well-ordered, and `f : α → β` is a monotone function, then `f '' s ⊆ β` is partially well-ordered.


theorem Real.rpow_def : ∀ (x y : ℝ), x ^ y = (↑x ^ ↑y).re := by sorry

This theorem states that for any two real numbers `x` and `y`, the expression `x ^ y` (which represents x raised to the power y) is equal to the real part of `x` and `y` cast to complex numbers (`↑x ^ ↑y`) raised to the power of each other. In other words, exponentiation in the real numbers can be defined in terms of exponentiation in the complex numbers, when we only consider the real part of the result.

For all real numbers x and y, x ^ y = ↑(xc ^ ↑y), where xc is the complex number obtained by lifting x to the complex plane.


theorem false_or_iff : ∀ (p : Prop), False ∨ p ↔ p := by sorry

This theorem states that for any proposition `p`, the logical disjunction of `False` and `p` is equivalent to `p`. In simpler terms, either something false or `p` is true if and only if `p` is true. This makes sense since a false statement cannot contribute to the truth of a disjunction.

The theorem asserts that `False \|\ p` is equivalent to `p` for any proposition `p` in Lean.


/-- Double counting argument. Considering `r` as a bipartite graph, the LHS is a lower bound on the
number of edges while the RHS is an upper bound.  -/
theorem Finset.card_mul_le_card_mul :
    ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} {m n : ℕ}
      [inst : (a : α) → (b : β) → Decidable (r a b)],
      (∀ a ∈ s, m ≤ (Finset.bipartiteAbove r t a).card) →
        (∀ b ∈ t, (Finset.bipartiteBelow r s b).card ≤ n) → s.card * m ≤ t.card * n :=
  by sorry

This theorem, known as the "Double counting argument", concerns a bipartite relation `r` between elements of two types `α` and `β`. Given finite sets `s` and `t` of these types and integers `m` and `n`, it asserts that if every element `a` in `s` is related to at least `m` elements in `t` and every element `b` in `t` is related to at most `n` elements in `s`, then the size of `s` multiplied by `m` is less than or equal to the size of `t` multiplied by `n`. In terms of graph theory, this can be conceptualized by interpreting `r` as a bipartite graph, where the left-hand side (`s.card * m`) provides a lower bound on the number of edges, and the right-hand side (`t.card * n`) provides an upper bound.

If every element in a finite set of type `α` is related to at least `m` elements in a finite set of type `β`, and every element in the set of type `β` is related to at most `n` elements in the set of type `α`, then the product of the sizes of the sets and their respective bounds on the number of relations satisfies `(size s * m) <= (size t * n)`.


theorem spectrum.scalar_eq :
    ∀ {𝕜 : Type u} {A : Type v} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] [inst_3 : Nontrivial A]
      (k : 𝕜), spectrum 𝕜 ((algebraMap 𝕜 A) k) = {k} :=
  by sorry

The theorem `spectrum.scalar_eq` states that for any field `𝕜`, a ring `A`, and given an algebra structure on `A` over `𝕜`, and assuming `A` is nontrivial (i.e., `A` contains at least two distinct elements), then the spectrum of the image under the algebra map of any scalar `k` from `𝕜` is simply the singleton set containing `k`. In other words, the only element in the field `𝕜` for which `k•1 - (algebraMap 𝕜 A k)` is not a unit in the algebra `A`, is `k` itself.

For any field `𝕜`, ring `A` with an algebra structure over `𝕜`, and non-trivial `A`, the spectrum of the algebra map of any scalar `k` from `𝕜` is a singleton set containing `k`.


theorem isLowerSet_iInter₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : LE α] {f : (i : ι) → κ i → Set α},
      (∀ (i : ι) (j : κ i), IsLowerSet (f i j)) → IsLowerSet (⋂ i, ⋂ j, f i j) :=
  by sorry

The theorem `isLowerSet_iInter₂` states that, for all types `α` and `ι`, and for each function `κ` from `ι` to some other type, if `α` has an order relation (represented by `LE α`) and `f` is a function that for each `ι` and `κ i` returns a set of `α` which is a lower set (i.e., a set where for any two elements `a` and `b` of `α`, if `b` is less than or equal to `a` and `a` is in the set, then `b` is also in the set), then the intersection over all `ι` and `κ i` of the sets `f i j` is also a lower set.

In simpler terms, if you have a family of sets of some ordered type, where each of the sets is "downwards closed" (if an element is in the set, all lesser elements are too), then the intersection of all these sets also has this "downward closure" property.

If `α` is an ordered type, and `f ι : ι → sets α` is a family of lower sets, then the intersection over all `ι` and `κ i` of the sets `f i κ` is also a lower set.


theorem List.infix_refl : ∀ {α : Type u_1} (l : List α), l <:+: l := by sorry

This theorem, `List.infix_refl`, is a statement about lists in Lean 4. The theorem asserts that for any given list `l` of any type `α`, the list `l` is an infix of itself. The notation `<:+:` denotes the infix relation. In other words, the list `l` can be found within itself exactly as it is.

For any list `l` of type `α`, `l <:+ l` holds. (Infix `<:+` denotes list concatenation or infix relation in Lean 4.)


Nonempty.congr

theorem Nonempty.congr : ∀ {α : Sort u_2} {β : Sort u_3}, (α → β) → (β → α) → (Nonempty α ↔ Nonempty β) := by sorry

This theorem, `Nonempty.congr`, states that for any two types `α` and `β`, if there exist functions from `α` to `β` and from `β` to `α`, then `α` is non-empty if and only if `β` is non-empty. In other words, if we can go back and forth between `α` and `β` via some functions, then the existence of an element in `α` is equivalent to the existence of an element in `β`.

If types `α` and `β` have mutual inverses of functions between them, then `α` and `β` have the same non-emptiness property.


theorem Mathlib.Geometry.Manifold.MFDeriv.FDeriv._auxLemma.1 :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E},
      UniqueMDiffWithinAt (modelWithCornersSelf 𝕜 E) s x = UniqueDiffWithinAt 𝕜 s x :=
  by sorry

This theorem states that for any given type `𝕜` which forms a nontrivially normed field, and any type `E` which is a normed additive commutative group and also a normed space over `𝕜`, the property of having a unique differential within a set `s` at a point `x` is equivalent in the context of the natural model with corners in `E` and the context of `𝕜`. In simpler terms, it means that the uniqueness of differentiation within a certain set at a point remains the same whether you view it in its own space or in the larger ambient space.

For any nontrivially normed field `𝕜` and a normed additive commutative group `E` over `𝕜` with the same norm as a normed space, the uniqueness of differentiation at a point `x` in `E` holds if and only if it does in `E`'s subspace structure in `𝕜`.


theorem AddMonoidAlgebra.sup_support_list_prod_le :
    ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
      [inst_3 : AddMonoid A] [inst_4 : AddMonoid B]
      [inst_5 : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_6 : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {degb : A → B},
      degb 0 ≤ 0 →
        (∀ (a b : A), degb (a + b) ≤ degb a + degb b) →
          ∀ (l : List (AddMonoidAlgebra R A)),
            Finset.sup (List.prod l).support degb ≤ List.sum (List.map (fun f => Finset.sup f.support degb) l) :=
  by sorry

This theorem states that for any semiring `R`, additive monoids `A` and `B`, and a function `degb` from `A` to `B`, if `degb` maps the zero element of `A` to a value less than or equal to zero and for all elements `a` and `b` of `A`, `degb` of their sum is less than or equal to the sum of `degb` of `a` and `degb` of `b`, then for any list of elements of the add monoid algebra of `R` and `A`, the supremum of the support of the product of the list elements under `degb` is less than or equal to the sum of the supremum of the support of each element under `degb`. This is a property related to the order and operations in the set-up monoids and semiring, particularly regarding convolutions in the monoid algebra and operations on finite sets.

For any semiring `R`, additive monoids `A` and `B`, and a degree function `degb` from `A` to `B` with `degb(0) ≤ 0` and `degb(a + b) ≤ degb(a) + degb(b)` for all `a, b` in `A`, the supremum of `degb` over the support of a product of elements in the monoid algebra of `R` and `A` is less than or equal to the sum of the supremum of `degb` over the support of each element.


theorem Mathlib.Algebra.Order.Module.Defs._auxLemma.19 :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → Preorder (α i)] {x y : (i : ι) → α i},
      (x < y) = (x ≤ y ∧ ∃ i, x i < y i) :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Module.Defs._auxLemma.19`, asserts that for any type `ι`, a function `α : ι → Type v` mapping `ι` to `Preorder`, and two instances `x` and `y` from `ι` to `α i`, `x` is less than `y` if and only if `x` is less than or equal to `y` and there exists an `i` such that `x i` is less than `y i`. Basically, it defines the "less than" relation in terms of "less than or equal to" relation and an existential quantification.

For any preorder `α : ι → Type v`, and `x` and `y` in `ι` with types `α i` and `α j` respectively, `x` is less than `y` if and only if `x` is less than or equal to `y` and there exists some `i` such that `x i` is strictly less than `y i`.


theorem Mathlib.Algebra.Order.Module.Defs._auxLemma.18 :
    ∀ {α : 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 : α}, (0 ≤ -a) = (a ≤ 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Module.Defs._auxLemma.18`, states that for any type `α` that is an additive group and has a less-than-or-equal-to (`≤`) operation, and where the sum of two elements x and x_1 in that group is less than or equal to the sum of any other two elements in the group, then for any element `a` in that group, the statement that zero is less than or equal to the negation of `a` (`0 ≤ -a`) is equivalent to the statement that `a` is less than or equal to zero (`a ≤ 0`).

For any additive group with a `≤` operation, if the sum of any two elements is less than or equal to the sum of any other two, then the negation of an element is less than or equal to zero if and only if that element is less than or equal to zero.


theorem Mathlib.Algebra.Order.Module.Defs._auxLemma.17 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, (0 < -a) = (a < 0) :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Module.Defs._auxLemma.17`, states that for all types `α` that are instances of an `AddGroup` and have a `Less Than (LT)` operation, and for which the addition operation `x + x_1` is covariant with the less than operation `x < x_1`, the statement "0 is less than the negation of `a`" is equivalent to the statement "`a` is less than 0". Here, `a` is an arbitrary element of the type `α`. This theorem connects the concepts of negation, addition, and order in the context of a mathematical structure like a group.

For an additive group type `α` with a covariant addition and a `LT` order relation, `0 < -a` if and only if `a < 0`.


theorem MeasureTheory.Measure.restrict_zero_set :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, ↑↑μ s = 0 → μ.restrict s = 0 :=
  by sorry

This theorem, named `MeasureTheory.Measure.restrict_zero_set`, states that for any given type `α`, a measurable space `m0` of type `α`, a measure `μ` in the measure theory of type `α`, and a set `s` of type `α`, if the measure `μ` of the set `s` is zero (denoted as `↑↑μ s = 0`), then the restriction of the measure `μ` to the set `s` is also zero (denoted as `μ.restrict s = 0`). In simpler terms, if a set has a measure of zero, then any measure restricted to that set is also zero.

If a measurable set has zero measure in a given measure space, then its restriction to that set has measure zero as well.


theorem cast_eq : ∀ {α : Sort u} (h : α = α) (a : α), cast h a = a := by sorry

This theorem, named `cast_eq`, states that for any type `α` and any element `a` of that type, casting `a` to the same type `α` (using an equality proof `h` that `α` equals `α`) results in the same element `a`. In other words, casting an element to its original type doesn't change the element.

For any type `α` and element `a` of type `α`, the conversion `a : α` is equal to `a`.


Function.Antiperiodic.eq

theorem Function.Antiperiodic.eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddZeroClass α] [inst_1 : Neg β],
      Function.Antiperiodic f c → f c = -f 0 :=
  by sorry

The theorem `Function.Antiperiodic.eq` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any value `c` of type `α`, given that `α` possesses a zero element with respect to addition (`AddZeroClass α`), and that `β` has a negation operation (`Neg β`), if `f` is antiperiodic with antiperiod `c` (which by definition signifies that for all `x` in `α`, `f (x + c) = -f x`), then `f c` is equal to the negation of `f` at zero, that is, `f c = -f 0`.

If `α` is an additive group and `β` has negations, an antiperiodic function `f` from `α` to `β` with antiperiod `c` satisfies `f(c) = -f(0)`.


theorem Set.Finite.absorbs_biUnion :
    ∀ {M : Type u_1} {α : Type u_2} [inst : Bornology M] [inst_1 : SMul M α] {s : Set α} {ι : Type u_3} {t : ι → Set α}
      {I : Set ι}, Set.Finite I → (Absorbs M s (⋃ i ∈ I, t i) ↔ ∀ i ∈ I, Absorbs M s (t i)) :=
  by sorry

This theorem, `Set.Finite.absorbs_biUnion`, states that for any type `M` with a Bornology structure, a type `α` with a scalar multiplication by `M`, a set `s` of type `α`, an indexing type `ι`, a function `t` from `ι` to sets of `α`, and a finite set `I` of `ι`, the set `s` absorbs the union of the sets `t i` for `i` in `I` if and only if `s` absorbs each of the sets `t i` for each `i` in `I`. Here, a set `s` is said to absorb another set `t` if `t` is contained in all scalings of `s` by all but a bounded set of elements from `M`.

For a type with a Bornology structure `M`, a scalar multiplication `α × M → α`, a set `s ⊆ α`, a family `t` of sets `ι → α`, and a finite set `I ⊆ ι`, `s` absorbs the union of `t i` for `i` in `I` if and only if it absorbs each `t i` for all `i` in `I`.


theorem ProbabilityTheory.kernel.IndepSets.indep' :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {p1 p2 : Set (Set Ω)},
      (∀ s ∈ p1, MeasurableSet s) →
        (∀ s ∈ p2, MeasurableSet s) →
          IsPiSystem p1 →
            IsPiSystem p2 →
              ProbabilityTheory.kernel.IndepSets p1 p2 κ μ →
                ProbabilityTheory.kernel.Indep (MeasurableSpace.generateFrom p1) (MeasurableSpace.generateFrom p2) κ
                  μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepSets.indep'` states that for any two sets `p1` and `p2` of subsets of a measurable space `Ω`, which are both `π-systems` (i.e., collections of subsets closed under binary intersection), and every subset within each of these sets is measurable, if these two sets are independent with respect to a `Markov kernel` `κ` and a measure `μ`, then these two sets remain independent even when they are extended to generate the smallest measure space containing them.

If two `π-systems` of measurable subsets `p1` and `p2` in a measurable space `Ω`, such that every subset in each is measurable and they are independent with respect to a Markov kernel `κ` and measure `μ`, then they remain independent when extended to generate the smallest measurable space containing them.


PSet.Equiv.euc

theorem PSet.Equiv.euc : ∀ {x : PSet} {y : PSet} {z : PSet}, PSet.Equiv x y → PSet.Equiv z y → PSet.Equiv x z := by
  sorry

The theorem `PSet.Equiv.euc` states that for any pre-sets `x`, `y`, and `z`, if `x` is extensionally equivalent to `y` and `z` is also extensionally equivalent to `y`, then `x` is extensionally equivalent to `z`. In other words, it establishes the Euclidean property for the extensional equivalence of pre-sets, which is a form of transitivity property through a common equivalent pre-set `y`.

If pre-sets `x`, `y`, and `z` are pairwise extensionally equivalent, then `x` is extensionally equivalent to `z`.


theorem Complex.cos_eq_one_iff : ∀ {x : ℂ}, Complex.cos x = 1 ↔ ∃ k, ↑k * (2 * ↑Real.pi) = x := by sorry

This theorem states that for all complex numbers 'x', the cosine of 'x' equals to one if and only if there exists an integer 'k' such that 'x' is equal to 'k' times '2π'. In other words, the cosine of a complex number equals to one precisely when that number is an integer multiple of '2π'. This theorem forms a connection between the cosine function and the multiples of '2π' in the complex number system.

The complex number x has cosine equal to 1 if and only if x = k * 2π for some integer k.


theorem PowerSeries.trunc_trunc_mul :
    ∀ {R : Type u_2} [inst : CommSemiring R] {n : ℕ} (f g : PowerSeries R),
      PowerSeries.trunc n (↑(PowerSeries.trunc n f) * g) = PowerSeries.trunc n (f * g) :=
  by sorry

The theorem `PowerSeries.trunc_trunc_mul` states that for any commutative semiring `R`, and for any natural number `n`, and for any two formal power series `f` and `g` over `R`, the `n`th truncation of the product of the `n`th truncation of `f` and `g` is equal to the `n`th truncation of the product of `f` and `g`. This essentially means that truncating a power series before multiplication gives the same result as truncating after multiplication.

For any commutative semiring R and natural numbers n, the n-th truncation of the product of the n-th truncations of formal power series f and g over R equals the n-th truncation of the product of f and g.


theorem Int.eq_negSucc_of_lt_zero : ∀ {a : ℤ}, a < 0 → ∃ n, a = Int.negSucc n := by sorry

This theorem states that for any integer `a`, if `a` is less than zero, then there exists a natural number `n` such that `a` is equal to the negative of the successor of `n` (i.e. `a = -n - 1`). In essence, it is expressing the fact that every negative integer is the negative of the successor of some natural number.

For any integer `a` less than zero, there exists a natural number `n` such that `a = -(Suc n)`, where `Suc` denotes the successor operation.


theorem MeasureTheory.OuterMeasure.isometry_comap_mkMetric :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : EMetricSpace X] [inst_1 : EMetricSpace Y] (m : ENNReal → ENNReal)
      {f : X → Y},
      Isometry f →
        Monotone m ∨ Function.Surjective f →
          (MeasureTheory.OuterMeasure.comap f) (MeasureTheory.OuterMeasure.mkMetric m) =
            MeasureTheory.OuterMeasure.mkMetric m :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.isometry_comap_mkMetric` states that for any types `X` and `Y` equipped with PseudoEMetricSpace instances, a function `m` mapping from extended nonnegative real numbers to extended nonnegative real numbers, and a function `f` from `X` to `Y`, if `f` is an isometry and either `m` is monotone or `f` is surjective, then the pullback of the maximal outer measure created by `m` under the function `f` is equal to the original maximal outer measure created by `m`. In mathematical terms, it indicates that under specific conditions, the measure of a set and its image under an isometry are the same.

If `m` is a monotone PseudoEMetricSpace value on `X` or `f` is a surjective isometry from `X` to `Y`, then the pullback of the maximal outer measure of a set in `X` under `f` is equal to the original maximal outer measure of its image in `Y`.


theorem IsUpperSet.mul_right :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] {s t : Set α}, IsUpperSet s → IsUpperSet (s * t) := by sorry

The theorem `IsUpperSet.mul_right` states that for any ordered commutative group `α` and any two sets `s` and `t` of elements of `α`, if `s` is an upper set (i.e., a set where any element greater than one of its members is also a member), then the product set `s * t` (formed by multiplying elements from `s` and `t`) is also an upper set.

If `s` is an upper set in a commutative group `α`, then the product set `s * t` is also an upper set for any set `t` in `α`.


theorem Mathlib.RingTheory.WittVector.IsPoly._auxLemma.9 : ∀ {α : Sort u_2}, (α → True) = True := by sorry

This theorem, named `Mathlib.RingTheory.WittVector.IsPoly._auxLemma.9`, states that for any type `α` (which can be any sort or kind), the statement "every element of type `α` satisfies the `True` proposition" is itself always `True`. It means the proposition that "for all elements of a certain type, a tautological statement holds" is always true regardless of the type.

The theorem asserts that the proposition `(∀ x : α) (true : bool)` is always true for any type `α`.


theorem Associates.isUnit_iff_eq_one : ∀ {α : Type u_1} [inst : CommMonoid α] (a : Associates α), IsUnit a ↔ a = 1 := by
  sorry

The theorem `Associates.isUnit_iff_eq_one` states that for any commutative monoid `α`, and for any element `a` of the associates of `α`, `a` is a unit if and only if `a` is equal to 1. Here, the associates of a monoid `α` is the quotient of `α` by the `Associated` relation, which states that two elements are associated if there exists a unit that multiplied by one of them results in the other. A unit in a monoid `M` is an element that has a two-sided inverse.

In a commutative monoid, an element is a unit if and only if it is equal to the identity element. Equivalently, elements are associates if and only if one is a unit and they are equal.


theorem MeasurableEmbedding.aestronglyMeasurable_map_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {γ : Type u_5} {mγ : MeasurableSpace γ}
      {mα : MeasurableSpace α} {f : γ → α} {μ : MeasureTheory.Measure γ},
      MeasurableEmbedding f →
        ∀ {g : α → β},
          MeasureTheory.AEStronglyMeasurable g (MeasureTheory.Measure.map f μ) ↔
            MeasureTheory.AEStronglyMeasurable (g ∘ f) μ :=
  by sorry

The theorem `MeasurableEmbedding.aestronglyMeasurable_map_iff` states that for any topological space `β`, any types `γ` and `α`, any measurable spaces `mγ` and `mα`, any function `f` from `γ` to `α`, any measure `μ` on `γ`, and any measurable embedding `f`, for any function `g` from `α` to `β`, `g` is almost everywhere strongly measurable with respect to the measure obtained by pushing forward `μ` by `f` if and only if the function composed of `g` and `f` is almost everywhere strongly measurable with respect to `μ`.

This means that the property of a function being almost everywhere strongly measurable is preserved under the operation of changing the domain via a measurable embedding and then applying the function. In terms of measure theory, it asserts a connection between the notions of measure and almost everywhere strong measurability under the operation of pushforward by a measurable embedding.

For any measurable spaces `mγ`, `mα`, `β`, type `γ` and `α`, measurable embedding `f : γ → α`, measure `μ` on `γ`, function `g : α → β`, and almost everywhere strongly measurable functions `f` and `g`, the composition `g ∘ f` is almost everywhere strongly measurable with respect to `μ` if and only if `g` is almost everywhere strongly measurable with respect to the pushforward measure `μ` _via_ `f`.


Set.EqOn.closure

/-- If two continuous maps are equal on `s`, then they are equal on the closure of `s`. See also
`Set.EqOn.of_subset_closure` for a more general version.  -/
theorem Set.EqOn.closure :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space X]
      {s : Set Y} {f g : Y → X}, Set.EqOn f g s → Continuous f → Continuous g → Set.EqOn f g (closure s) :=
  by sorry

This theorem states that if two continuous functions `f` and `g` (mapping from a set `Y` to a topological space `X`) are equal on a set `s`, then they are also equal on the closure of `s`. The closure of `s` is defined as the smallest closed set that contains `s`. This theorem applies under the condition that the topological space `X` is also a T2 space (also known as a Hausdorff space), which is a topological property that guarantees a certain level of separability of points. The theorem allows the extension of equality from a set to its closure, given that the involved functions are continuous.

If `f` and `g` are continuous functions from a set `Y` to a T2 topological space `X` and `f(y) = g(y)` for all `y` in a set `s`, then `f(y) = g(y)` for all `y` in the closure of `s`.


theorem norm_le_zero_iff' :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] [inst_1 : T0Space E] {a : E}, ‖a‖ ≤ 0 ↔ a = 0 := by sorry

This theorem states that for any type `E` that is a seminormed add group and a `T0` topological space, the norm of an element `a` of `E` is less than or equal to zero if and only if `a` is equal to zero. In mathematical terms, this theorem says that for all seminormed add groups (which are also `T0` spaces) `E` and all elements `a` of `E`, the condition `‖a‖ ≤ 0` is equivalent to `a = 0`.

In a seminormed add group and a T0 topological space, an element has zero norm if and only if it is the zero element.


theorem Mathlib.CategoryTheory.Monoidal.Category._auxLemma.2 :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [self : CategoryTheory.MonoidalCategory C]
      {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom f₁ f₂)
          (CategoryTheory.MonoidalCategory.tensorHom g₁ g₂) =
        CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.comp f₁ g₁)
          (CategoryTheory.CategoryStruct.comp f₂ g₂) :=
  by sorry

This theorem is a property of morphisms in a monoidal category. Specifically, for any given monoidal category `C`, and any objects `X₁, Y₁, Z₁, X₂, Y₂, Z₂` of `C`, it states that the tensor product of the composition of morphisms `f₁` and `f₂` from `X₁` to `Y₁` and `X₂` to `Y₂` respectively, and the composition of morphisms `g₁` and `g₂` from `Y₁` to `Z₁` and `Y₂` to `Z₂` respectively, is equal to the composition of the tensor product of `f₁` and `g₁` and the tensor product of `f₂` and `g₂`.

In more mathematical terms, it states that:
`(f₁ ⊗ f₂) ≫ (g₁ ⊗ g₂) = (f₁ ≫ g₁) ⊗ (f₂ ≫ g₂)`
where `⊗` represents the tensor product and `≫` signifies the composition of morphisms. This expresses a kind of distributivity property for the tensor product over morphism composition.

In a monoidal category, the tensor product of the composition of two morphisms is equal to the composition of their tensor products.


/-- Simplification of the integral of `sin x ^ m * cos x ^ n`, case `n` is odd.  -/
theorem integral_sin_pow_mul_cos_pow_odd :
    ∀ {a b : ℝ} (m n : ℕ),
      ∫ (x : ℝ) in a..b, Real.sin x ^ m * Real.cos x ^ (2 * n + 1) =
        ∫ (u : ℝ) in Real.sin a..Real.sin b, u ^ m * (1 - u ^ 2) ^ n :=
  by sorry

This theorem, named `integral_sin_pow_mul_cos_pow_odd`, describes a simplification of an integral involving the powers of sine and cosine functions. More specifically, for any real numbers `a` and `b`, and natural numbers `m` and `n`, the integral from `a` to `b` of `sin(x)^m * cos(x)^(2n+1)` is equal to the integral from `sin(a)` to `sin(b)` of `u^m * (1 - u^2)^n`. In other words, it transforms an integral involving both sine and cosine to an equivalent integral involving only sine, which could simplify its computation. This is particularly useful when `n` is odd.

For any real numbers `a` and `b` and natural numbers `m` and `n`, the integral from `a` to `b` of `sin(x)^m * cos(x)^(2n+1)` equals the integral from `sin(a)` to `sin(b)` of `u^m * (1 - u^2)^n`.


AddAction.bijective

theorem AddAction.bijective :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α),
      Function.Bijective fun x => g +ᵥ x :=
  by sorry

The theorem `AddAction.bijective` asserts that for any type `α` equipped with an additive group structure, and any type `β` equipped with an add action of `α`, and any element `g` from `α`, the function that adds `g` to any element of `β` (`fun x => g +ᵥ x`) is bijective. In other words, for any group and action, translating by a group element gives a bijection from the set to itself.

For any additive group `α` and any set `β` equipped with an additive action of `α`, the translation-by-element function `x ↦ g + x` is a bijection, where `g` is any element from `α`.


theorem Finset.nonempty_range_iff : ∀ {n : ℕ}, (Finset.range n).Nonempty ↔ n ≠ 0 := by sorry

This theorem states that for any natural number `n`, the range of `n` (which is defined as the set of natural numbers less than `n`) is non-empty if and only if `n` is not equal to zero. In other words, there exist natural numbers less than `n` precisely when `n` is not zero.

The set of natural numbers less than a given natural number `n` is non-empty if and only if `n` is non-zero.


theorem commProb_pi :
    ∀ {α : Type u_3} (i : α → Type u_2) [inst : Fintype α] [inst_1 : (a : α) → Mul (i a)],
      commProb ((a : α) → i a) = Finset.prod Finset.univ fun a => commProb (i a) :=
  by sorry

This theorem, `commProb_pi`, states that for every type `α` and a function `i` from `α` to some other type, given that `α` is a finite type and for each element `a` in `α` there exists a multiplication operation on `i a`, the commuting probability of the function type from `α` to `i a` is equal to the product of the commuting probabilities over each `i a` for all `a` in the universal set of `α`. In simpler terms, the theorem relates the commuting probability of a function type to the product of the commuting probabilities of its range types. The commuting probability here refers to the ratio of the number of pairs of elements that commute under multiplication to the square of the total number of elements.

Given a finite type `α` and a function `i : α → C` to a commutative monoid `C`, the commuting probability of the function type `α → C` is equal to the product of the commuting probabilities of the ranges `i a` for all `a` in `α`.


theorem PartialEquiv.prod_trans :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {η : Type u_5} {ε : Type u_6} (e : PartialEquiv α β)
      (f : PartialEquiv β γ) (e' : PartialEquiv δ η) (f' : PartialEquiv η ε),
      PartialEquiv.trans (PartialEquiv.prod e e') (PartialEquiv.prod f f') =
        PartialEquiv.prod (PartialEquiv.trans e f) (PartialEquiv.trans e' f') :=
  by sorry

The theorem `PartialEquiv.prod_trans` states that for all types α, β, γ, δ, η, ε and given partial equivalences `e` from α to β, `f` from β to γ, `e'` from δ to η, and `f'` from η to ε, the composition of the product of `e` and `e'` with the product of `f` and `f'` is equal to the product of the composition of `e` and `f` with the composition of `e'` and `f'`. That is, it shows a certain commutativity property of the operations of composition and forming the product for partial equivalences.

For all partial equivalences `e` from α to β, `f` from β to γ, `e'` from δ to η, and `f'` from η to ε, the composition of `e × e'` with `f × f'` is equal to the composition of `(e × f)` with `(e' × f')`.


theorem Matrix.kroneckerMap_smul_left :
    ∀ {R : Type u_1} {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10}
      {p : Type u_11} [inst : SMul R α] [inst_1 : SMul R γ] (f : α → β → γ) (r : R),
      (∀ (a : α) (b : β), f (r • a) b = r • f a b) →
        ∀ (A : Matrix l m α) (B : Matrix n p β), Matrix.kroneckerMap f (r • A) B = r • Matrix.kroneckerMap f A B :=
  by sorry

The given theorem, `Matrix.kroneckerMap_smul_left`, states that for all types `R`, `α`, `β`, `γ`, `l`, `m`, `n`, and `p`, where `R` is a scalar, `α` and `γ` are types involving scalar multiplication, if we have a function `f` from `α` and `β` to `γ` such that for any elements `a` in `α` and `b` in `β`, scalar multiplication of `r` to the product of `f(a, b)` is equal to the application of `f` to the scalar multiplication of `r` and `a` and `b` (i.e., `f(r * a, b) = r * f(a, b)`), then for any matrices `A` of type `α` and `B` of type `β`, applying `kroneckerMap` to the scalar multiplication of `r` and `A` and `B` is the same as scalar multiplication of `r` to the `kroneckerMap` of `f`, `A` and `B` (i.e., `kroneckerMap(f, r * A, B) = r * kroneckerMap(f, A, B)`). This theorem connects the concept of scalar multiplication and the Kronecker product operation in the context of matrices.

For any function `f` between two types involving scalar multiplication such that `r * f(a, b) = f(r * a, b)` for all scalars `r` and elements `a` and `b`, the Kronecker product of `f` with the scalar multiplication of matrices `r * A` and `B` is equal to the scalar multiplication of `r` times the Kronecker product of `f` with matrices `A` and `B`.


theorem hasFDerivWithinAt_diff_singleton :
    ∀ {𝕜 : 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 : E → F}
      {f' : E →L[𝕜] F} {x : E} {s : Set E} (y : E), HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' s x :=
  by sorry

The theorem `hasFDerivWithinAt_diff_singleton` states that for any types `𝕜` (which is a nontrivially normed field), `E` (a normed add-commutative group and normed space over `𝕜`), and `F` (another normed add-commutative group and normed space over `𝕜`), along with a function `f` from `E` to `F` and its derivative function `f'`, a point `x` in `E`, a set `s` of elements of type `E` and another point `y` in `E`, the function `f` has a Frechet derivative `f'` at point `x` within the set `s` excluding `{y}` if and only if `f` has a Frechet derivative `f'` at point `x` within the entire set `s`. In other words, the presence or absence of an individual point `y` in the set `s` does not affect whether `f` has a Frechet derivative at `x` within `s`.

The presence or absence of a single point in a set does not affect the existence of a Frechet derivative of a function at a given point within that set. (Assuming the function, its derivative, the types involved are normed add-commutative groups and normed spaces over a nontrivially normed field.)


Classical.skolem

theorem Classical.skolem :
    ∀ {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}, (∀ (x : α), ∃ y, p x y) ↔ ∃ f, ∀ (x : α), p x (f x) :=
  by sorry

This theorem, referred to as Skolem's theorem, states that for any type `α`, any type function `b` from `α` to another type, and any predicate `p` over `α` and `b x`, the assertion that for every element of type `α` there exists an element of type `b x` such that the predicate `p` holds, is equivalent to the existence of a function `f` from `α` to `b x` such that the predicate `p` holds for every `x` and `f x`. In other words, this theorem captures the idea that universal quantification over a type followed by existential quantification over another type can be switched to existential quantification over a function followed by universal quantification over the first type, provided the predicate holds. This is essentially a formal statement of the Skolem's theorem in the context of mathematical logic and first-order theories.

Skolem's theorem states that given a type `α`, a type function `b`, and a predicate `p`, the existence of a function `f` from `α` to `b` such that `p(x, f(x))` holds for all `x` in `α` is equivalent to the existence of an element in `b` for every `x` in `α` satisfying `p(x, y)`.


theorem gramSchmidt_mem_span :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι]
      [inst_5 : IsWellOrder ι fun x x_1 => x < x_1] (f : ι → E) {j i : ι},
      i ≤ j → gramSchmidt 𝕜 f i ∈ Submodule.span 𝕜 (f '' Set.Iic j) :=
  by sorry

The theorem `gramSchmidt_mem_span` states that for any type `𝕜` which behaves like a real closed field, `E` which forms a normed additive commutative group and an inner product space over `𝕜`, and an index type `ι` that has a linear order, a locally finite order at bottom and a well order, given a function `f` from `ι` to `E` and two indices `i` and `j` from `ι`, if `i` is less than or equal to `j`, then the result of applying the Gram-Schmidt process to the function `f` at index `i` is an element of the smallest submodule of `E` over `𝕜` that contains the image of the function `f` over the interval from negative infinity to `j` (inclusive). In other words, each vector obtained from the Gram-Schmidt process is in the linear span of the set of function outputs indexed by values less than or equal to `j`.

For any real closed field `𝕜`, normed additive commutative group and inner product space `E` over `𝕜`, and orderable index type `ι`, if `f` is a function from `ι` to `E`, then for all `i ≤ j` in `ι`, the vector obtained from the Gram-Schmidt process of `f` at index `i` is in the span of the first `j+1` function outputs.


/-- The iterated derivative of the sum of two functions is the sum of the iterated derivatives.
See also `iteratedFDerivWithin_add_apply'`, which uses the spelling `(fun x ↦ f x + g x)`
instead of `f + g`.  -/
theorem iteratedFDerivWithin_add_apply :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {x : E} {i : ℕ} {f g : E → F},
      ContDiffOn 𝕜 (↑i) f s →
        ContDiffOn 𝕜 (↑i) g s →
          UniqueDiffOn 𝕜 s →
            x ∈ s →
              iteratedFDerivWithin 𝕜 i (f + g) s x = iteratedFDerivWithin 𝕜 i f s x + iteratedFDerivWithin 𝕜 i g s x :=
  by sorry

The theorem `iteratedFDerivWithin_add_apply` states that, given a non-trivially normed field `𝕜`, and normed additive commutative groups `E` and `F` which are also normed `𝕜`-spaces, a set `s` of elements of `E`, an element `x` of `E`, an integer `i`, and two functions `f` and `g` from `E` to `F`, if `f` and `g` are `i`-times continuously differentiable on `s`, `s` admits a unique differential at every point, and `x` is an element of `s`, then the `i`-th derivative of the sum of `f` and `g` at `x`, taken within the set `s`, is equal to the sum of the `i`-th derivatives of `f` and `g` at `x`, each taken within the set `s`. This is essentially a generalization of the rule of derivatives which states that the derivative of the sum of two functions is the sum of the derivatives.

Given a non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F` that are also `𝕜`-spaces, if `f` and `g` are `i`-times differentiable functions from `E` to `F` over a set `s` where `s` admits unique differentials at every point and contains `x`, then the `i`-th derivative of `f + g` at `x` equals the sum of the `i`-th derivatives of `f` and `g` at `x` within `s`.


theorem CategoryTheory.Limits.piComparison_comp_π :
    ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : β → C)
      [inst_2 : CategoryTheory.Limits.HasProduct f] [inst_3 : CategoryTheory.Limits.HasProduct fun b => G.obj (f b)]
      (b : β),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.piComparison G f)
          (CategoryTheory.Limits.Pi.π (fun b => G.obj (f b)) b) =
        G.map (CategoryTheory.Limits.Pi.π f b) :=
  by sorry

The theorem `CategoryTheory.Limits.piComparison_comp_π` states that, given any type `β`, categories `C` and `D`, a functor `G` from `C` to `D`, and a function `f : β → C` for which the product exists in both `C` and `D`, for any element `b : β`, the composition of the "pi comparison" morphism associated with `G` and `f` and the `b`-th projection from the pi object over `G.obj ∘ f` is equal to the `G`-map of the `b`-th projection from the pi object over `f`. Here, the "pi comparison" morphism is a natural transformation between functors from the category of `β`-indexed families of objects in `C` to `D`, which is part of the definition of a product in a category.

Given a functor G from category C to D, a type β, and a function f : β → C such that the product exists in both C and D, for all b : β, the composition of the pi comparison morphism and the b-th projection from the pi object over G ∘ f equals the G-map of the b-th projection from the pi object over f.


MeasureTheory.HasFiniteIntegral.congr'

theorem MeasureTheory.HasFiniteIntegral.congr' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
      MeasureTheory.HasFiniteIntegral f μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → MeasureTheory.HasFiniteIntegral g μ :=
  by sorry

The theorem `MeasureTheory.HasFiniteIntegral.congr'` states that for any types `α`, `β` and `γ`, given a measurable space `α`, a measure `μ` on that space, and two functions `f : α → β` and `g : α → γ` where `β` and `γ` are normed additive commutative groups, if `f` has a finite integral with respect to `μ` and, almost everywhere with respect to `μ`, the norm of `f` at any point `a` is equal to the norm of `g` at `a`, then `g` also has a finite integral with respect to `μ`. In other words, if two functions have their norms equal almost everywhere, and one of them has a finite measure-theoretic integral, then so does the other.

If two measurable functions from a measurable space to normed additive commutative groups have equal norms almost everywhere and one of them has a finite integral with respect to a measure on the space, then the other function also has a finite integral with respect to that measure.


theorem NumberField.InfinitePlace.even_card_aut_of_not_isUnramified :
    ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
      {w : NumberField.InfinitePlace K} [inst_3 : IsGalois k K] [inst_4 : FiniteDimensional k K],
      ¬NumberField.InfinitePlace.IsUnramified k w → Even (Fintype.card (K ≃ₐ[k] K)) :=
  by sorry

This theorem states that for any number field `K` over a field `k` with a given infinite place `w`, if `K` is a Galois extension of `k` and `K` is of finite dimension over `k`, then if the infinite place `w` is not unramified in the field extension from `k` to `K`, the number of field automorphisms of `K` that fix `k` (denoted as `(K ≃ₐ[k] K)`) is an even number. In other words, if a certain form of complexity (ramification) at the infinite place happens when extending from `k` to `K`, the group of automorphisms of `K` preserving `k` must have even order.

If `K` is a finite-dimensional Galois extension of number field `k` such that `w` is an infinite place of `K` that is ramified in the extension, then the order of the group of `k`-automorphisms of `K` is even.


theorem PrimeSpectrum.zeroLocus_empty_of_one_mem :
    ∀ {R : Type u} [inst : CommSemiring R] {s : Set R}, 1 ∈ s → PrimeSpectrum.zeroLocus s = ∅ := by sorry

The theorem `PrimeSpectrum.zeroLocus_empty_of_one_mem` states that for any type `R` that has the structure of a commutative semiring, and any set `s` of elements of `R`, if the number 1 is an element of `s`, then the zero locus of `s` in the prime spectrum is empty. In other words, there are no prime ideals of `R` that vanish on all elements of `s` when 1 is included in `s`.

If `R` is a commutative semiring and `s` is a non-empty subset of `R` containing 1, then the zero locus of `s` in the prime spectrum of `R` is empty.


/-- Reflecting twice in the same subspace.  -/
theorem EuclideanGeometry.reflection_reflection :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] (s : AffineSubspace ℝ P) [inst_4 : Nonempty ↥s]
      [inst_5 : HasOrthogonalProjection (AffineSubspace.direction s)] (p : P),
      (EuclideanGeometry.reflection s) ((EuclideanGeometry.reflection s) p) = p :=
  by sorry

This theorem, titled "Reflecting twice in the same subspace," states that for any real affine subspace `s` and any point `p`, reflecting `p` twice in the subspace `s` results in the original point `p`. Here, reflection refers to the operation in Euclidean geometry where a point is mapped to another point such that if a line is drawn from the original point to its image, that line passes through the subspace and forms equal angles with it. For this theorem to hold, the subspace `s` must be nonempty and have an orthogonal projection.

For any real affine subspace and point, reflecting the point twice in the subspace results in the original point if the subspace is nonempty and has an orthogonal projection.


theorem Ordinal.le_nfpFamily :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}) (a : Ordinal.{max u u_1}),
      a ≤ Ordinal.nfpFamily f a :=
  by sorry

The theorem `Ordinal.le_nfpFamily` states that for any type `ι`, any function `f` mapping `ι` and an ordinal to an ordinal, and any ordinal `a`, the ordinal `a` is less than or equal to the next common fixed point of `f` starting from `a`. Here, "next common fixed point" refers to the supremum of all values reachable by applying finitely many functions in the family to `a`.

For any type `ι`, function `f` mapping `ι` to ordinals, and ordinal `a`, the ordinal `a` is less than or equal to the supremum of all ordinals reachable from `a` through finitely many applications of `f`.


theorem MeasureTheory.SimpleFunc.integral_congr :
    ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst_1 : NormedSpace ℝ E] {f g : MeasureTheory.SimpleFunc α E},
      MeasureTheory.Integrable (↑f) μ →
        ↑f =ᶠ[MeasureTheory.Measure.ae μ] ↑g →
          MeasureTheory.SimpleFunc.integral μ f = MeasureTheory.SimpleFunc.integral μ g :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.integral_congr` states that for any two simple functions `f` and `g` mapping from a measurable space `α` into a normed add commutative group `E`, and a measure `μ` on the measurable space `α`, if `f` is integrable with respect to `μ` and `f` equals `g` almost everywhere (i.e., except on a set of measure zero) with respect to `μ`, then the Bochner integral of `f` with respect to `μ` equals the Bochner integral of `g` with respect to `μ`. This theorem ensures that the Bochner integral is well-defined even when we change the function on a set of measure zero.

If simple functions `f` and `g` on measurable space `α` with values in a normed add commutative group `E`, and measure `μ` are such that `f` is integrable, `f = g` almost everywhere with respect to `μ`, then `∫(f dμ) = ∫(g dμ)`.


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

This theorem states that for any commutative ring `R` and any elements `x`, `y`, and `z` of `R`, if `x` and `y` are coprime, then `x` is also coprime with the element `y + x * z`. Here, two elements are said to be coprime if there exist two other elements in the ring such that their linear combination equals one, i.e., there exist `a` and `b` in `R` such that `a * x + b * y = 1`.

If `x` and `y` are coprime elements in a commutative ring `R`, then `x` is coprime with `y + x * z` for any `z` in `R`.


theorem MulAction.mem_orbit_self :
    ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] (a : α), a ∈ MulAction.orbit M a := by sorry

This theorem states that for any type `M` with a Monoid structure, any type `α` with a `MulAction` of `M`, and any element `a` of type `α`, the element `a` is always an element of its own orbit in the `MulAction`. In mathematical terms, this means that for any element `a` in a set that a monoid `M` acts on, the orbit of `a` (which is the set of all elements that can be reached from `a` by the action of elements in `M`) always includes `a` itself.

For any monoid action of a type `M` on a type `α` and any element `a` in `α`, the orbit of `a` contains `a` itself.


/-- The symbol `J(a | b)` vanishes iff `a` and `b` are not coprime (assuming `b ≠ 0`).  -/
theorem jacobiSym.eq_zero_iff_not_coprime : ∀ {a : ℤ} {b : ℕ} [inst : NeZero b], jacobiSym a b = 0 ↔ Int.gcd a ↑b ≠ 1 :=
  by sorry

This theorem states that the Jacobi symbol `J(a | b)` is equal to zero if and only if the integers `a` and `b` are not coprime, given that `b` is not equal to zero. Here, two integers are considered to be coprime if their greatest common divisor (gcd) is 1. So essentially, if the gcd of `a` and `b` is not 1, then the Jacobi symbol `J(a | b)` will be zero.

The Jacobi symbol J(a | b) equals zero if and only if a and b are not coprime.


theorem ContinuousLinearMap.opNorm_flip :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
      [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
      [inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜₃]
      [inst_6 : NormedSpace 𝕜 E] [inst_7 : NormedSpace 𝕜₂ F] [inst_8 : NormedSpace 𝕜₃ G] {σ₂₃ : 𝕜₂ →+* 𝕜₃}
      {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_9 : RingHomIsometric σ₂₃] [inst_10 : RingHomIsometric σ₁₃] (f : E →SL[σ₁₃] F →SL[σ₂₃] G),
      ‖ContinuousLinearMap.flip f‖ = ‖f‖ :=
  by sorry

The theorem `ContinuousLinearMap.opNorm_flip` states that for any continuous linear map `f`, which is a map from a normed space `E` over a nontrivially normed field `𝕜` to a continuous linear map from a normed space `F` over a nontrivially normed field `𝕜₂` to a normed space `G` over a nontrivially normed field `𝕜₃` (where the field homomorphisms from `𝕜` to `𝕜₃` and `𝕜₂` to `𝕜₃` are isometric), the operator norm of the flip of `f` is equal to the operator norm of `f`. The flip of a continuous linear map is a function that reverses the order of the two spaces the map operates on.

For any continuous linear map $f$ from a normed space $E$ over a nontrivially normed field $\mathbb{K}$ to a continuous linear map from a normed space $F$ over $\mathbb{K}$ to a normed space $G$ over $\mathbb{K}$ (with isometric field homomorphisms from $\mathbb{K}$ to the fields of $F$ and $G$), the operator norms of $f$ and its flip are equal.


theorem Set.not_mem_compl_iff : ∀ {α : Type u} {s : Set α} {x : α}, x ∉ sᶜ ↔ x ∈ s := by sorry

This theorem states that for any set `s` of elements of some type `α` and any element `x` of this type, `x` is not a member of the complement of `s` if and only if `x` is a member of `s`. In other words, an element is not in the complement of a set exactly when it is in the set itself. This is a basic property of complements in set theory.

The complement of a set is identical to its complement in the sense that an element is in the complement of a set if and only if it is not in the set.


theorem Set.prod_inter :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t₁ t₂ : Set β}, s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by sorry

This theorem, `Set.prod_inter`, states that for any two types `α` and `β`, a set `s` of type `α`, and two sets `t₁` and `t₂` of type `β`, the Cartesian product of `s` with the intersection of `t₁` and `t₂` is equal to the intersection of the Cartesian product of `s` with `t₁` and the Cartesian product of `s` with `t₂`. In more mathematical terms, for sets \(s\), \(t_1\), \(t_2\), we have \(s \times (t_1 \cap t_2) = (s \times t_1) \cap (s \times t_2)\).

For any sets `α`, `β`, `s : Set α`, and `t₁`, `t₂ : Set β`, `Set.prod_inter` asserts that `s × (t₁ ∩ t₂) = (s × t₁) ∩ (s × t₂)`.


theorem LocalRing.le_maximalIdeal :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : LocalRing R] {J : Ideal R}, J ≠ ⊤ → J ≤ LocalRing.maximalIdeal R :=
  by sorry

The theorem `LocalRing.le_maximalIdeal` states that in a commutative semiring `R` which is also a local ring, for any ideal `J` of `R`, if `J` is not the entire ring `R` (represented as `⊤`), then `J` is a subset of the maximal ideal of `R`. The maximal ideal of a local ring is defined as the set of all non-unit elements of the ring.

In a commutative semiring and local ring, an ideal that is strictly contained in the entire ring is a subset of the maximal ideal consisting of non-unit elements.


theorem PicardLindelof.tMin_le_tMax :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (v : PicardLindelof E), v.tMin ≤ v.tMax :=
  by sorry

The theorem `PicardLindelof.tMin_le_tMax` states that for all `E`, which is a type belonging to a Normed Additive Commutative Group and also a Normed Space over the real numbers ℝ, and for any `v` that is an instance of the Picard Lindelöf structure on `E`, the minimum time value `tMin` is less than or equal to the maximum time value `tMax`. This theorem is a basic property of the time interval in the Picard Lindelöf structure, which is often used in the study of ordinary differential equations.

For any Normed Additive Commutative Group and Normed Space `E` over the real numbers, and for any Picard Lindelöf structure `v` on `E`, the minimum time `tMin` is less than or equal to the maximum time `tMax`.


theorem CategoryTheory.MorphismProperty.map_mem_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C)
      (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y), P f → CategoryTheory.MorphismProperty.map P F (F.map f) :=
  by sorry

This theorem is a statement about morphism properties and functors in category theory. It says that for any category `C`, any morphism property `P` on `C`, any functor `F` from `C` to some category `D`, and any morphism `f` from `X` to `Y` in `C`, if `f` has property `P`, then the image of `f` under the functor `F` also has the property `P` when it is considered in the category `D`. In other words, if a morphism in the source category has some property, then its image under a functor into the target category also has that property, where the property is being appropriately transformed along with the morphism by the functor.

For any category `C`, functor `F` from `C` to a category `D`, morphism property `P`, and morphism `f` in `C`, if `f` has property `P`, then `F(f)` has property `P` in `D`.


/-- If a ring homomorphism `R →+* A` is injective then `A` has the same characteristic as `R`.  -/
theorem charP_of_injective_ringHom :
    ∀ {R : Type u_1} {A : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring A] {f : R →+* A},
      Function.Injective ⇑f → ∀ (p : ℕ) [inst : CharP R p], CharP A p :=
  by sorry

The theorem `charP_of_injective_ringHom` states that for any two types `R` and `A` that are both instances of a `NonAssocSemiring` (which is a particular type of mathematical structure), if there is an injective ring homomorphism `f` from `R` to `A`, then the characteristic of `A` is the same as the characteristic of `R`. Here, the characteristic of a ring is a nonnegative integer `p` (denoted `CharP R p` for `R` and `CharP A p` for `A`) that is defined such that all multiples of `p` are zero in the ring. An injective ring homomorphism is a function that preserves the ring structure and has the property that different inputs produce different outputs.

If `f` is an injective homomorphism from a NonAssocSemiring `R` to a NonAssocSemiring `A`, then `CharP A (CharP R)` holds.


theorem Set.Nontrivial.exists_ne : ∀ {α : Type u} {s : Set α}, Set.Nontrivial s → ∀ (z : α), ∃ x ∈ s, x ≠ z := by sorry

This theorem states that for any type `α` and any set `s` of that type, if the set `s` is nontrivial (that is, it has at least two distinct elements), then for any element `z` of the type `α`, there exists an element `x` in the set `s` such that `x` is not equal to `z`. In other words, in any nontrivial set, we can always find an element which is different from a given element of the same type.

If `α` is a type and `s` is a non-empty set of `α`, then for all `z` in `α`, there exists `x` in `s` such that `x ≠ z`.


theorem SemiNormedGroupCat₁.zero_apply : ∀ {V W : SemiNormedGroupCat₁} (x : ↑V), 0 x = 0 := by sorry

The theorem `SemiNormedGroupCat₁.zero_apply` states that for any two objects `V` and `W` in the category `SemiNormedGroupCat₁` (i.e., a category whose objects are seminormed add commutative groups and whose morphisms are norm non-increasing maps), and for any element `x` from the underlying set of `V`, the zero map applied to `x` results in the zero element. In other words, within the context of `SemiNormedGroupCat₁`, the zero map always sends any element to zero.

For any seminormed add commutative group `V` in `SemiNormedGroupCat₁` and any of its elements `x`, the zero map `0` applied to `x` equals the additive identity `0` of `V`.


/-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
assumes `0≤K`.  -/
theorem LipschitzWith.of_le_add_mul :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : α → ℝ} (K : NNReal),
      (∀ (x y : α), f x ≤ f y + ↑K * dist x y) → LipschitzWith K f :=
  by sorry

The theorem `LipschitzWith.of_le_add_mul` states that for any function `f` mapping from a space `α` to the real numbers `ℝ`, if for all `x` and `y` in `α` the function value at `x` is less than or equal to the function value at `y` plus a nonnegative real number `K` times the distance between `x` and `y`, then `f` is Lipschitz continuous with Lipschitz constant `K`. Here, `α` is a space equipped with a pseudo-metric, and Lipschitz continuity means that the distance between the function values at two points is less than or equal to `K` times the distance between the points.

If a function from a pseudo-metric space to the real numbers satisfies the condition that the function value at any point is less than or equal to the value at another point plus a constant times the distance between them, then the function is Lipschitz continuous with the given constant as its Lipschitz constant.


theorem DFinsupp.zero_apply : ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (i : ι), 0 i = 0 := by sorry

The theorem `DFinsupp.zero_apply` states that for any type `ι`, and a type function `β` mapping `ι` to another type, given that for all `i` in `ι`, `β i` has an associated `Zero` instance, then the application of the zero function (or object) at any index `i` equals to the zero element of the co-domain. In terms of mathematical notation, this theorem is essentially stating that for any index `i`, `0(i) = 0`, where the left-hand side zero is the zero function and the right-hand side zero is the zero element of the co-domain.

For any type `ι` and type function `β` from `ι` to a type with a Zero instance, the application of the zero function to any index `i` in `ι` equals the zero element of the co-domain `β i`.


theorem OrderHom.le_map_sSup_subset_fixedPoints :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α), ∀ A ⊆ Function.fixedPoints ⇑f, sSup A ≤ f (sSup A) := by
  sorry

The theorem `OrderHom.le_map_sSup_subset_fixedPoints` states that for any type `α` that forms a complete lattice and for any order-preserving function `f : α →o α`, if a subset `A` is contained within the set of fixed points of the function `f`, then the supremum (or least upper bound) of `A`, denoted `sSup A`, is less than or equal to the result of applying `f` to `sSup A`. In other words, `f` does not increase the supremum of any set of its fixed points.

For any complete lattice `α` and order-preserving function `f : α → α`, if `A ⊆ fixedPoints f`, then `sSup A ≤ f (sSup A)`.


theorem le_map_add_map_sub :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α]
      [inst_2 : AddCommSemigroup β] [inst_3 : LE β] [inst_4 : SubadditiveHomClass F α β] (f : F) (a b : α),
      f a ≤ f b + f (a - b) :=
  by sorry

This theorem, called `le_map_add_map_sub`, states that for any types `F`, `α`, and `β`, given certain conditions, the value of a function `f` (of type `F` which can be injected into a function from `α` to `β`) at `a` is less than or equal to the value of `f` at `b` plus the value of `f` at `a - b`. The conditions are: `F` is a `FunLike` instance from `α` to `β`, `α` is an additive group, `β` is an additive commutative semigroup, `β` has a less than or equal to (`LE`) operation, and `F` is a subadditive homomorphism class from `α` to `β`. In mathematical terms, this theorem expresses the inequality $f(a) \leq f(b) + f(a - b)$ under the given conditions.

For any additive group `α`, additive commutative semigroup `β` with an LE operation, and subadditive homomorphism class `F` from `α` to `β`, `F(a) LE F(b) + F(a - b)` for all `a, b` in `α`.