/-- Every set open in the lower topology is a lower set.  -/
theorem Topology.IsLower.isLowerSet_of_isOpen :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsLower α] {s : Set α},
      IsOpen s → IsLowerSet s :=
  by sorry

This theorem is stating that for any type `α` that has an inherent preorder, is endowed with a topological space structure, and has a lower topology, then any set `s` of this type that is open in this topological space is also a lower set.

In more detail, if `s` is a set in a preordered type `α` that also has a topological structure and a lower topology, and if `s` is open in this topology, then `s` has the property that for any elements `a` and `b` in `α`, if `b` is less than or equal to `a` and `a` is in `s`, then `b` is also in `s`. This defines `s` as a lower set.

If `α` is a preordered type with a topological structure and lower topology, and `s` is an open set in `α`, then `s` is a lower set.


theorem AddSubmonoid.LocalizationMap.sec_spec' :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {f : AddSubmonoid.LocalizationMap S N} (z : N),
      (AddSubmonoid.LocalizationMap.toMap f) (AddSubmonoid.LocalizationMap.sec f z).1 =
        (AddSubmonoid.LocalizationMap.toMap f) ↑(AddSubmonoid.LocalizationMap.sec f z).2 + z :=
  by sorry

This theorem states that for any additive commutative monoid `M`, a submonoid `S` of `M`, an additive commutative monoid `N`, and a localization map `f` from `S` to `N`, for any element `z` in `N`, the result of applying the localization map `f` to the first element of the pair resulting from the section function `sec` applied to `z` equals the result of adding `z` to the result of applying `f` to the lifted (or referenced) second element of the pair produced by `sec` on `z`. In effect, this theorem asserts a specific property of the section of a localization map in the context of additive commutative monoids.

For any additive commutative monoids M, an additive commutative monoid N, a submonoid S of M, and a localization map f from S to N, for all elements z in N, we have f(sec z.fst) = sec z.snd + z.


theorem MeasureTheory.Measure.rnDeriv_eq_zero :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α)
      [inst : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      μ.rnDeriv ν =ᶠ[MeasureTheory.Measure.ae ν] 0 ↔ MeasureTheory.Measure.MutuallySingular μ ν :=
  by sorry

This theorem states that for any two measures `μ` and `ν` in a measurable space `α`, given that `μ` has a Lebesgue decomposition with respect to `ν`, the Radon-Nikodym derivative of `μ` with respect to `ν` is almost everywhere equal to zero if and only if `μ` and `ν` are mutually singular. In other words, `μ` and `ν` are mutually singular if there exists a measurable set such that `μ` gives it measure zero and `ν` gives its complement measure zero, and this is equivalent to the condition that the "rate of change" of `μ` with respect to `ν`, as measured by the Radon-Nikodym derivative, is zero almost everywhere.

A measure `μ` is mutually singular with respect to another measure `ν` in a measurable space if and only if the Radon-Nikodym derivative of `μ` with respect to `ν` is almost everywhere equal to zero.


theorem Int.mod_add_div : ∀ (a b : ℤ), Int.mod a b + b * Int.div a b = a := by sorry

This theorem states that for any two integers `a` and `b`, the sum of the modulus of `a` with respect to `b` and the product of `b` and the integer division of `a` by `b` is equal to `a`. In mathematical terms, it's equivalent to the equation `(a mod b) + b * (a div b) = a` for all integer `a` and `b`. This property is a fundamental aspect of the division algorithm in number theory.

For all integers `a` and `b`, the theorem asserts that `(a % b) + b * (a / b) = a`, where `%` denotes modulus and `/` denotes integer division.


theorem WithZero.coe_ne_zero : ∀ {α : Type u} {a : α}, ↑a ≠ 0 := by sorry

This theorem, `WithZero.coe_ne_zero`, states that for all types `α` and for all elements `a` of type `α`, the coercion of `a` to `WithZero α` is not equal to zero. In other words, no non-zero value from an arbitrary type `α` can become zero when lifted into the `WithZero α` type via coercion.

For all types `α` and elements `a` of type `α`, the coercion of `a` to `WithZero α` is never equal to the zero element of `WithZero α`.


theorem HomologicalComplex.zero_f :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C D : HomologicalComplex V c) (i : ι),
      0.f i = 0 :=
  by sorry

This theorem states that for any category `V` with zero morphisms and any `ComplexShape` `c`, for any two homological complexes `C` and `D` over `V` and `c`, and any object `i` in the indexing category `ι`, the morphism `f` at `i` of the zero homological complex is always equal to zero. This essentially asserts the null object property for a homological complex in a category with zero morphisms.

For any homological complex `C` and `D` over a category `V` with zero morphisms and any index `i`, the morphism from `C(i)` to `D(i)` in the zero homological complex is the zero morphism.


theorem Function.monotone_eval :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → Preorder (α i)] (i : ι), Monotone (Function.eval i) := by sorry

The theorem `Function.monotone_eval` states that for any type `ι`, any function `α` from `ι` to some type, and for any index `i` in `ι`, if each type `α i` has a preorder (i.e., an order relation that is reflexive and transitive), then the evaluation function at `i` is monotone. In other words, if `a` and `b` are elements of type `α i` and `a` is less than or equal to `b`, then the value of any function evaluated at `a` is less than or equal to the value of the function evaluated at `b`. This theorem asserts the consistency of order when applying functions under certain conditions.

If `α : Type ι → Type*, i : ι, and `α i carries a preorder, then the evaluation function `Function.eval : α i → α (succ i) → Prop` is monotone.


theorem Nat.Coprime.mul_right : ∀ {k m n : ℕ}, Nat.Coprime k m → Nat.Coprime k n → Nat.Coprime k (m * n) := by sorry

This theorem states that for any three natural numbers `k`, `m`, and `n`, if `k` is coprime with `m` and `k` is coprime with `n`, then `k` is also coprime with the product of `m` and `n`. In other words, if the greatest common divisor (gcd) of `k` and `m` is 1, and the gcd of `k` and `n` is 1, then the gcd of `k` and `m*n` is also 1.

If `k` is coprime to both `m` and `n`, then `k` is coprime to their product `m * n`.


theorem Set.insert_diff_of_mem : ∀ {α : Type u} {a : α} {t : Set α} (s : Set α), a ∈ t → insert a s \ t = s \ t := by
  sorry

The theorem `Set.insert_diff_of_mem` states that for any type `α`, any element `a` of type `α`, and any two sets `s` and `t` of type `α`, if `a` is an element of `t`, then the difference of the set resulting from inserting `a` into `s` and `t` is equal to the difference of `s` and `t`. In other words, if `a` is already in `t`, inserting `a` into `s` does not affect the relative complement of `s` in `t`.

If `a` is an element of set `t`, then `Set.insert a s = s \ t = s \ {a}`.


theorem Monotone.ge_of_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : OrderClosedTopology α]
      [inst_3 : SemilatticeSup β] {f : β → α} {a : α},
      Monotone f → Filter.Tendsto f Filter.atTop (nhds a) → ∀ (b : β), f b ≤ a :=
  by sorry

This theorem states that for all types `α` and `β` where `α` is equipped with a topological space structure, a preorder (a reflexive and transitive binary relation), and an order closed topology (a topology on a partial order where the closure of any upward-directed set with a least upper bound is that bound), and `β` is equipped with a semilattice structure (a partially ordered set that has a greatest lower bound for any two elements), given a function `f` from `β` to `α` and an element `a` in `α`, if `f` is a monotone function and the limit of `f` as `β` approaches infinity exists and is equal to `a` in the topology on `α`, then for every element `b` in `β`, the function `f` evaluated at `b` is less than or equal to `a`.

In simpler terms, if a function is increasing or non-decreasing and it tends to a certain value as its argument goes to infinity, then all function values are less than or equal to this limit.

If `f` is a monotone function from a semilattice `β` to a topological space `α` with an order-closed topology, and the limit of `f(x)` as `x` approaches the greatest element in `β` exists and equals `a` in `α`, then for all `b` in `β`, `f(b) ≤ a`.


padicValNat.mul

/-- A rewrite lemma for `padicValNat p (a * b)` with conditions `a ≠ 0`, `b ≠ 0`.  -/
theorem padicValNat.mul :
    ∀ {p a b : ℕ} [hp : Fact (Nat.Prime p)],
      a ≠ 0 → b ≠ 0 → padicValNat p (a * b) = padicValNat p a + padicValNat p b :=
  by sorry

The theorem `padicValNat.mul` states that for any prime number `p` and any natural numbers `a` and `b` that are not equal to zero, the p-adic valuation of the product of `a` and `b` is equal to the sum of the p-adic valuation of `a` and the p-adic valuation of `b`. In other words, if `p` is a prime number and `a` and `b` are non-zero natural numbers, then the largest power of `p` that divides `a*b` is equal to the sum of the largest power of `p` that divides `a` and the largest power of `p` that divides `b`.

For any prime number `p` and non-zero natural numbers `a` and `b`, the p-adic valuation of `a * b` is equal to the sum of the p-adic valuations of `a` and `b`.


theorem MeasureTheory.StronglyMeasurable.aeStronglyMeasurable' :
    ∀ {α : Type u_1} {β : Type u_2} {m x : MeasurableSpace α} [inst : TopologicalSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β}, MeasureTheory.StronglyMeasurable f → MeasureTheory.AEStronglyMeasurable' m f μ :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.aeStronglyMeasurable'` states that for all types `α` and `β`, with `α` being a measurable space (denoted by `m` and `x`), `β` being a topological space, and a measure `μ` on `α`, if a function `f` from `α` to `β` is strongly measurable (i.e., it can be approximated by a sequence of simple functions), then `f` is almost everywhere (`μ`-almost everywhere) equal to a function that is `m`-strongly measurable (i.e., it is strongly measurable under the measurable space `m`). This implies that a strongly measurable function can be modified on a set of measure zero to obtain a function that is strongly measurable in a potentially different measurable space structure.

If a strongly measurable function between a measurable space and a topological space can be approximated by simple functions, then it is almost everywhere equal to an `m`-strongly measurable function.


theorem tendsto_norm_cobounded_atTop :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E], Filter.Tendsto norm (Bornology.cobounded E) Filter.atTop := by sorry

The theorem `tendsto_norm_cobounded_atTop` states that for any type `E` that has a seminormed add group structure, the norm function, when applied to the cobounded sets in the bornology of `E`, tends to infinity. In simpler terms, this means that as we take larger and larger sets in the bornology (sets which are cobounded), the norm of the elements in those sets tends to infinity. This is a formal way of expressing that the norm grows without bound when considering larger sets in the bornology structure.

For any seminormed add group `E`, the norm function tends to infinity as the sets in `E`'s bornology become cobounded.


theorem Finset.disjUnion_eq_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α) (h : Disjoint s t), Finset.disjUnion s t h = s ∪ t := by
  sorry

This theorem states that, for any type `α` that has decidable equality, given two finite sets `s` and `t` of type `α`, if `s` and `t` are disjoint (in the sense that the infimum of any element that is less than or equal to both `s` and `t` is the bottom element of the order), then the disjoint union of `s` and `t` is equal to the ordinary union of `s` and `t`. In other words, when two sets are disjoint, the disjoint union operation and the standard union operation yield the same result. This theorem can be seen as a specification of the `Finset.disjUnion` operation, relating it to the standard union of sets.

For finite sets `s` and `t` of type `α` with decidable equality, if `s` and `t` are disjoint, then their disjoint union is equal to their ordinary union.


theorem EuclideanGeometry.inversion_inversion :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] (c : P) {R : ℝ},
      R ≠ 0 → ∀ (x : P), EuclideanGeometry.inversion c R (EuclideanGeometry.inversion c R x) = x :=
  by sorry

The theorem `EuclideanGeometry.inversion_inversion` states that for any point in an affine space with a Euclidean geometry, the double application of inversion in a sphere with non-zero radius returns the original point. More precisely, given a point `x` in the space, and a sphere specified by its center `c` and a non-zero radius `R`, the inversion of `x` with respect to the sphere and then another inversion of the result with respect to the same sphere gets us back to the original point `x`. This inversion operation is defined such that it maps `x` to a point `y` such that the vector from `c` to `y` is proportional to the square of the ratio of `R` to the distance from `x` to `c`, and in the same direction as the vector from `c` to `x`.

For any point `x` in an Euclidean affine space and a sphere with non-zero radius `R` and center `c`, applying two inversions of `x` with respect to `S` results in the original point `x`. In other words, inverting a point `x` twice with respect to a sphere centers at `c` and has radius `R` leaves `x` unchanged.


theorem MeasureTheory.Measure.AbsolutelyContinuous.refl :
    ∀ {α : Type u_1} {_m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α),
      MeasureTheory.Measure.AbsolutelyContinuous μ μ :=
  by sorry

This theorem states that for any measure `μ` in any measurable space `α`, `μ` is absolutely continuous with respect to itself. In other words, if a set `s` is a null set under measure `μ` (i.e., `μ(s) = 0`), then it is also a null set under the same measure `μ` (i.e., `μ(s) = 0`). This is a reflexive property of absolute continuity in the context of measure theory.

For any measure `μ` in a measurable space, the null sets under `μ` are invariant under `μ`, that is, a set is a null set if and only if its measure under `μ` is zero.


theorem Equiv.swap_apply_def :
    ∀ {α : Sort u_1} [inst : DecidableEq α] (a b x : α),
      (Equiv.swap a b) x = if x = a then b else if x = b then a else x :=
  by sorry

The theorem `Equiv.swap_apply_def` states that for any type `α` with decidable equality and any elements `a`, `b`, and `x` of type `α`, the result of applying the permutation that swaps `a` and `b` to `x` (denoted as `(Equiv.swap a b) x`), is `b` if `x` equals `a`, `a` if `x` equals `b`, and `x` otherwise. In other words, the permutation only affects `x` if it is equal to `a` or `b`.

For any type with decidable equality and elements `a`, `b`, and `x`, `Equiv.swap a b x = a if x = b else b if x = a else x`.


/-- Two morphisms out of a universal `T`-structured arrow are equal if their image under `T` are
equal after precomposing the universal arrow.  -/
theorem CategoryTheory.StructuredArrow.IsUniversal.hom_ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      {f : CategoryTheory.StructuredArrow S T},
      CategoryTheory.StructuredArrow.IsUniversal f →
        ∀ {c : C} {η η' : f.right ⟶ c},
          CategoryTheory.CategoryStruct.comp f.hom (T.map η) = CategoryTheory.CategoryStruct.comp f.hom (T.map η') →
            η = η' :=
  by sorry

This theorem in category theory states that for any category `C` with objects of type `u₁`, and a category `D` with objects of type `u₂`, given a functor `T` from `C` to `D` and a `T`-structured arrow `f` from object `S` in `D`, if `f` is universal, then for any object `c` in `C` and any two morphisms `η` and `η'` from `f.right` to `c`, if the image of `η` and `η'` under the functor `T` are equal after precomposing with the morphism `f.hom`, then `η` is equal to `η'`. Here, "precomposing with the morphism `f.hom`" refers to the operation of composing `f.hom` with the image of `η` (or `η'`) under `T`.

If in a category `C` with object type `u₁` and a category `D` with object type `u₂`, a universal `T`-structured arrow `f` from `D` to `C` and two morphisms `η` and `η'` from `f.right` to an object `c` in `C` satisfy the condition that `T(η) ∘ f.hom = T(η') ∘ f.hom`, then `η = η'`.


theorem Int.add_lt_add_of_le_of_lt : ∀ {a b c d : ℤ}, a ≤ b → c < d → a + c < b + d := by sorry

This theorem states that for any four integers `a`, `b`, `c`, and `d`, if `a` is less than or equal to `b` and `c` is strictly less than `d`, then the sum of `a` and `c` is strictly less than the sum of `b` and `d`. In mathematical terms, it can be represented as: if \(a \leq b\) and \(c < d\), then \(a + c < b + d\).

If `a` ≤ `b` and `c` < `d`, then `a + c` < `b + d`. (Or, in mathematical notation: a ≤ b ∧ c < d → a + c < b + d.)


/-- This will be a special case of `LinearMap.toMatrix_id_eq_basis_toMatrix`.  -/
theorem LinearMap.toMatrix_id :
    ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_4} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
      {M₁ : Type u_5} [inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] (v₁ : Basis n R M₁),
      (LinearMap.toMatrix v₁ v₁) LinearMap.id = 1 :=
  by sorry

This theorem states that for any commutative semiring `R`, any finite type `n`, any instance of decidable equality on `n`, any additively commutative monoid `M₁`, and any `R`-module structure on `M₁`, if `v₁` is a basis of `M₁` over `R` indexed by `n`, then the matrix representation of the identity linear map with respect to this basis is the identity matrix. In other words, when the identity map is written in terms of basis `v₁`, it corresponds to the identity matrix.

For any commutative semiring R, finite type n with decidable equality, additively commutative monoid M₁ with an R-module structure and basis v₁ indexed by n, the identity linear map from M₁ to M₁ with respect to v₁ is represented by the identity matrix.


theorem MeasureTheory.Measure.tendsto_ae_map :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β},
      AEMeasurable f μ →
        Filter.Tendsto f (MeasureTheory.Measure.ae μ) (MeasureTheory.Measure.ae (MeasureTheory.Measure.map f μ)) :=
  by sorry

This theorem, `MeasureTheory.Measure.tendsto_ae_map`, states that for any two types `α` and `β` with `α` having a measurable space structure `m0` and `β` having a measurable space instance, given any measure `μ` on `α` and any function `f` from `α` to `β`, if the function `f` is almost everywhere measurable with respect to the measure `μ`, then the function `f` tends from the "almost everywhere" filter of the measure `μ` to the "almost everywhere" filter of the pushforward of the measure `μ` under the function `f`. In other words, if a function is almost everywhere measurable, then the pre-image under that function of almost every set in the target space is almost every set in the original space.

If `μ` is a measure on `α` and `f: α → β` is almost everywhere measurable, then for every `B ⊆ β` in the "almost everywhere" filter of `β` under the measure `μ` pushed forward by `f`, there exists a set `A ⊆ α` in the "almost everywhere" filter of `α` under `μ` such that `f(A) = B`.


theorem SetTheory.PGame.ofStateAux.proof_7 :
    ∀ {S : Type u_1} [inst : SetTheory.PGame.State S] (n : ℕ) (s : S),
      SetTheory.PGame.State.turnBound s ≤ n + 1 →
        ∀ (t : { t // t ∈ SetTheory.PGame.State.l s }), SetTheory.PGame.State.turnBound ↑t ≤ n :=
  by sorry

This theorem from Set Theory in the context of Partizan Games states that for any type `S` (representing a game state) that is an instance of `SetTheory.PGame.State`, any natural number `n`, and any game state `s` of type `S`, if the turn bound of `s` is less than or equal to `n + 1`, then for any `t` that is in the state `s`'s left options (`SetTheory.PGame.State.l s`), the turn bound of `t` is less than or equal to `n`. Here, the "turn bound" of a game state is a measure of how many more moves are possible from that state, and the "left options" of a game state are the potential next states reachable by the left player's moves.

For any game state `s` of type `S` in Set Theory's `PGame.State` where `S` is an instance of `SetTheory.PGame.State`, if the turn bound of `s` is less than or equal to `n + 1`, then the turn bound of every `t` in `s.l` is less than or equal to `n`.


theorem SetTheory.PGame.ofStateAux.proof_8 :
    ∀ {S : Type u_1} [inst : SetTheory.PGame.State S] (n : ℕ) (s : S),
      SetTheory.PGame.State.turnBound s ≤ n + 1 →
        ∀ (t : { t // t ∈ SetTheory.PGame.State.r s }), SetTheory.PGame.State.turnBound ↑t ≤ n :=
  by sorry

This theorem, `SetTheory.PGame.ofStateAux.proof_8`, states that for any type `S` that has a structure of a State in game theory, any natural number `n`, and any state `s` from `S`, if the turn bound of the state `s` is less than or equal to `n + 1`, then for any state `t` from the reachable states of `s`, the turn bound of `t` is less than or equal to `n`.

The turn bound of a state gives a limit on the number of turns that can be made from that state. The reachable states of a state are the states that can be reached from that state in one move. This theorem thus suggests a form of "monotonicity" of the turn bound in relation to reachable states and their turns in the context of positional games.

For any State type `S`, natural number `n`, and states `s` and `t` in `S` with `s` reachable from `t` and turn bound of `s` less than or equal to `n+1`, the turn bound of `t` is less than or equal to `n`.


theorem mem_closure_iff_nhds :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X],
      x ∈ closure s ↔ ∀ t ∈ nhds x, Set.Nonempty (t ∩ s) :=
  by sorry

The theorem `mem_closure_iff_nhds` states that for any type `X`, any element `x` of `X`, and any set `s` of `X` in a topological space, `x` is in the closure of `s` if and only if for every set `t` in the neighborhood of `x`, the intersection of `t` and `s` is not empty. In other words, a point is in the closure of a set if and only if every neighborhood of that point intersects the set.

A point x is in the closure of a set s in a topological space if and only if for every neighborhood t of x, the intersection of t and s is non-empty.


theorem PadicInt.maximalIdeal_eq_span_p :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], LocalRing.maximalIdeal ℤ_[p] = Ideal.span {↑p} := by sorry

This theorem states that for any natural number `p` which is proven to be prime (`Nat.Prime p`), the maximal ideal of the local ring of `p`-adic integers (`LocalRing.maximalIdeal ℤ_[p]`) is equivalent to the ideal generated by the set containing `p` (`Ideal.span {↑p}`). In other words, the maximal non-unit elements in the ring of `p`-adic integers are those that can be generated by multiplication with `p`.

For any prime natural number `p`, the maximal ideal of the local ring of `p`-adic integers equals the ideal generated by `p`.


theorem AlgebraicGeometry.Scheme.ιOpens.proof_1 :
    ∀ {X : AlgebraicGeometry.Scheme} (U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace),
      OpenEmbedding ⇑(TopologicalSpace.Opens.inclusion U) :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.ιOpens.proof_1` states that for any Algebraic Geometry Scheme `X` and any open subset `U` of the underlying topological space of `X`, the inclusion map that embeds `U` into the whole space `X` is an open embedding. An open embedding is a continuous function between topological spaces that, intuitively, 'preserves' open sets in the sense that the image of any open set is open. Thus, this theorem asserts that the inclusion map preserves the openness of any set in the defined algebraic geometry scheme.

The inclusion map of an open subset into an Algebraic Geometry Scheme is an open embedding.


theorem Complex.cosh_sub_sinh : ∀ (x : ℂ), Complex.cosh x - Complex.sinh x = Complex.exp (-x) := by sorry

The theorem `Complex.cosh_sub_sinh` states that for any complex number `x`, the difference between the complex hyperbolic cosine of `x` and the complex hyperbolic sine of `x` equals the complex exponential function of the negative of `x`. In mathematical terms, this can be written as $\cosh(x) - \sinh(x) = e^{-x}$ for any complex number $x$. The complex hyperbolic cosine and sine functions are defined in terms of the complex exponential function, and this theorem represents a particular relationship between these functions.

For any complex number $x$, $\cosh(x) - \sinh(x) = e^{-x}$.


/-- Characteristic `≠ 2` and nontrivial implies that `-1 ≠ 1`.  -/
theorem Ring.neg_one_ne_one_of_char_ne_two :
    ∀ {R : Type u_2} [inst : NonAssocRing R] [inst_1 : Nontrivial R], ringChar R ≠ 2 → -1 ≠ 1 := by sorry

The theorem `Ring.neg_one_ne_one_of_char_ne_two` states that for any type `R` which has a structure of a non-associative ring and is nontrivial (i.e., it has at least two distinct elements), if the characteristic of the ring is not equal to 2, then -1 is not equal to 1 in that ring. The characteristic of a ring is a fundamental property in number theory and algebra, and refers to the smallest positive integer `n` such that `n * x = 0` for every element `x` in the ring, or zero if no such integer exists.

For any non-associative ring R with at least two distinct elements and characteristic different from 2, -1 is not equal to 1.


LocallyLipschitz.comp

/-- The composition of locally Lipschitz functions is locally Lipschitz. - -/
theorem LocallyLipschitz.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] {f : β → γ} {g : α → β},
      LocallyLipschitz f → LocallyLipschitz g → LocallyLipschitz (f ∘ g) :=
  by sorry

The theorem `LocallyLipschitz.comp` states that if we have two functions, `f` and `g`, where `f` is a function from a pseudometric space `β` to another pseudometric space `γ`, and `g` is a function from a pseudometric space `α` to `β`, and both these functions are locally Lipschitz continuous, then the composition of `f` and `g`, denoted as `(f ∘ g)`, is also locally Lipschitz continuous. In other words, for every point in the domain of the composition, there exists a neighbourhood of that point on which the composed function is Lipschitz continuous. The Lipschitz continuity ensures that the rate of change of the function is bounded by a constant `K` on the neighbourhood.

If functions `f: β -> γ` and `g: α -> β` are locally Lipschitz continuous, then their composition `f ∘ g: α -> γ` is also locally Lipschitz continuous.


theorem HasFiniteFPowerSeriesAt.toHasFPowerSeriesAt :
    ∀ {𝕜 : 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 : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E} {n : ℕ}, HasFiniteFPowerSeriesAt f p x n → HasFPowerSeriesAt f p x :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, normed additive commutative group `E` and `F`, normed space `E` over `𝕜`, normed space `F` over `𝕜`, any function `f` from `E` to `F`, any formal multilinear series `p`, any element `x` of `E`, and any natural number `n`, if the function `f` has a finite formal power series at `x` of order `n`, then `f` also has a formal power series at `x`. Essentially, this theorem connects the concept of a finite formal power series to a formal power series for a function in the context of normed spaces and fields.

If a function from a normed space to another normed space over a nontrivial normed field has a finite formal power series at some point, then it has a formal power series at that point.


theorem UpperHalfPlane.normSq_pos : ∀ (z : UpperHalfPlane), 0 < Complex.normSq ↑z := by sorry

The theorem `UpperHalfPlane.normSq_pos` states that for any point `z` in the open upper half plane, the norm squared of `z` is strictly positive. Here, the open upper half plane is defined as the set of complex numbers with a strictly positive imaginary part, while the complex norm squared is the sum of the square of the real part and the square of the imaginary part of a complex number. Hence, the theorem is essentially asserting a property about the magnitude of points in the open upper half plane in the complex plane.

The norm squared of every complex number in the open upper half plane is strictly positive.


theorem Poly.zero_apply : ∀ {α : Type u_1} (x : α → ℕ), 0 x = 0 := by sorry

This theorem, `Poly.zero_apply`, states that for all types `α` and all functions `x` from `α` to the natural numbers `ℕ`, the application of the zero polynomial to `x` is zero. In mathematical terms, if you have a function `x` mapping any type `α` to the natural numbers, applying the zero polynomial to `x` will always yield zero, regardless of what `x` or `α` are.

For all types `α` and functions `x` from `α` to the natural numbers, the zero polynomial applied to `x` equals zero.


/-- The topology of a `NormedSpace 𝕜 E` is induced by the seminorm `normSeminorm 𝕜 E`.  -/
theorem norm_withSeminorms :
    ∀ (𝕜 : Type u_10) (E : Type u_11) [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E], WithSeminorms fun x => normSeminorm 𝕜 E :=
  by sorry

The theorem `norm_withSeminorms` states that for any normed field `𝕜` and any semi-normed additive commutative group `E` that is also a normed space over `𝕜`, the topology of the normed space `E` over `𝕜` is induced by the semi-norm given by the function `normSeminorm 𝕜 E`. This function assigns to any element of the space `E` the semi-norm derived from the norm of `E` as a group with respect to addition.

The topology of a normed space over a normed field is induced by the semi-norm derived from its original norm.


theorem TopologicalSpace.NonemptyCompacts.isCompact :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.NonemptyCompacts α), IsCompact ↑s := by sorry

This theorem states that for any type `α` endowed with a topological space structure, if `s` is any non-empty compact subset of `α`, then `s` itself is compact. In mathematical terms, given a topological space `α`, for any non-empty compact subset `s` of `α`, it holds that for every nontrivial filter `f` that contains `s`, there exists an element `a` in `s` such that every set of `f` meets every neighborhood of `a`. This essentially says that the compactness property is preserved in non-empty compact subsets within a topological space.

In a topological space, any non-empty compact subset is compact.


theorem Mathlib.MeasureTheory.Measure.FiniteMeasure._auxLemma.5 : ∀ {p q : NNReal}, (p = q) = (↑p = ↑q) := by sorry

This theorem states that for any two nonnegative real numbers `p` and `q`, `p` is equal to `q` if and only if the real number part of `p` (denoted as `↑p`) is equal to the real number part of `q` (denoted as `↑q`). This is essentially saying that two nonnegative real numbers are equal if their underlying real numbers are equal.

For any nonnegative real numbers `p` and `q`, `p = q` if and only if `↑p = ↑q`.


theorem ENNReal.ofReal_eq_zero : ∀ {p : ℝ}, ENNReal.ofReal p = 0 ↔ p ≤ 0 := by sorry

The theorem `ENNReal.ofReal_eq_zero` states that for any real number `p`, the function `ENNReal.ofReal` applied to `p` equals zero if and only if `p` is less than or equal to zero. In other words, in the extended nonnegative real number system, a real number converts to zero when it is nonpositive.

For any real number `p` in the extended nonnegative real numbers system, `ENNReal.ofReal p = 0` if and only if `p` is less than or equal to zero.


theorem Set.Icc_bot : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α] {a : α}, Set.Icc ⊥ a = Set.Iic a := by
  sorry

The theorem `Set.Icc_bot` states that for any type `α` that has both an order relation (`Preorder α`) and a least element (`OrderBot α`), the interval [`⊥`, `a`] which includes all elements `x` satisfying `⊥ ≤ x ≤ a`, is equal to the interval (`-∞`, `a`] or `Set.Iic a` which includes all elements `x` satisfying `x ≤ a`. This makes sense because `⊥` is the least element in `α`, so any `x` in `α` should satisfy `⊥ ≤ x`, essentially reducing the interval [`⊥`, `a`] to (`-∞`, `a`].

For any type `α` with a preorder and a least element, the intervals `[OrderBot α, a]` and `(-\infty, a]` are equal.


theorem Submodule.prod_bot :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_9}
      [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'], Submodule.prod ⊥ ⊥ = ⊥ :=
  by sorry

This theorem states that for any semiring `R`, add-commutative monoid `M` and `M'` (which are also `R`-modules), the product of the bottom element (`⊥`, representing the zero submodule) of `M` and `M'` is equal to the bottom element of the direct product module. In other words, in the context of modules over a semiring, the product of the zero submodule with itself is again the zero submodule.

For any semiring `R`, any add-commutative `R`-modules `M` and `M'`, the bottom element of `M ⊥ M'` equals the product of the bottom element of `M` and the bottom element of `M'`.


/-- If a family of submodules is `Independent`, then a choice of nonzero vector from each submodule
forms a linearly independent family.

See also `CompleteLattice.Independent.linearIndependent'`.  -/
theorem CompleteLattice.Independent.linearIndependent :
    ∀ {ι : Type u_1} {R : Type u_2} {N : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup N] [inst_2 : Module R N]
      [inst_3 : NoZeroSMulDivisors R N] (p : ι → Submodule R N),
      CompleteLattice.Independent p →
        ∀ {v : ι → N}, (∀ (i : ι), v i ∈ p i) → (∀ (i : ι), v i ≠ 0) → LinearIndependent R v :=
  by sorry

This theorem states that given a family of submodules (indexed by a type `ι`), denoted by `p`, over a ring `R` and an additive commutative group `N` (which also forms a module over `R`), if this family of submodules is independent (i.e., every element of the direct sum of these submodules comes from at most one of the submodules), then, for any map `v` from `ι` to `N`, if every `v i` belongs to the corresponding submodule `p i` and is non-zero, the family of vectors `v` is linearly independent over `R`. In other words, in an independent family of submodules, a non-zero element chosen from each submodule will form a linearly independent set.

If a family of submodules over a ring is independent, then a non-zero vector from each submodule forms a linearly independent set.


theorem Set.indicator_mul_right :
    ∀ {α : Type u_1} {M : Type u_4} [inst : MulZeroClass M] {a : α} (s : Set α) (f g : α → M),
      Set.indicator s (fun a => f a * g a) a = f a * Set.indicator s g a :=
  by sorry

The theorem `Set.indicator_mul_right` expresses a property of the indicator function on a set with respect to multiplication. Specifically, for any set `s` of a certain type `α` and two functions `f` and `g` from `α` to another type `M` (where `M` is a type with a multiplication operation that has a zero element), the indicator of `s` applied to the product of `f` and `g` at a point `a` equals the product of `f(a)` and the indicator of `s` applied to `g` at `a`. In other words, when we have the product of two functions, we can "move" the indicator function from being applied to the whole product to being applied to just one of the functions.

For any set `s` and functions `f` and `g` from a type with a multiplication operation to another type with a zero element, `indicator_of_s (f × g) a = indicator_of_s (g a) × f a`, where `indicator_of_s` denotes the indicator function of `s`.


theorem Polynomial.degree_quadratic_le :
    ∀ {R : Type u} {a b c : R} [inst : Semiring R],
      Polynomial.degree (Polynomial.C a * Polynomial.X ^ 2 + Polynomial.C b * Polynomial.X + Polynomial.C c) ≤ 2 :=
  by sorry

This theorem states that for any semiring `R` and any elements `a`, `b`, `c` of `R`, the degree of a polynomial that is constructed as the sum of `a` times the square of the polynomial variable `X`, `b` times `X`, and a constant `c`, is less than or equal to 2. In other words, if we have a quadratic polynomial of the form `aX^2 + bX + c`, its degree won't exceed 2.

The degree of a quadratic polynomial `aX^2 + bX + c` over a semiring `R` doesn't exceed 2 for any elements `a`, `b`, `c` of `R`.


theorem isArtinian_iff_wellFounded :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      IsArtinian R M ↔ WellFounded fun x x_1 => x < x_1 :=
  by sorry

The theorem `isArtinian_iff_wellFounded` states that for any ring `R` and additively commutative group `M` which is also a module over `R`, the property of `M` being Artinian (meaning that every descending chain of submodules of `M` stabilizes) is equivalent to the property that the relation "less than" on the elements of `M` is well-founded (meaning that there's no infinite descending chain of elements).

A module over a ring is Artinian if and only if the relation "less than" on its elements is well-founded.


theorem ENNReal.sum_le_tsum :
    ∀ {α : Type u_1} {f : α → ENNReal} (s : Finset α), (Finset.sum s fun x => f x) ≤ ∑' (x : α), f x := by sorry

This theorem states that for any function `f` from an arbitrary type `α` to the extended nonnegative real numbers (`ENNReal`), and for any finite set `s` of type `α`, the sum of the function values over this finite set, denoted as `(Finset.sum s fun x => f x)`, is less than or equal to the total sum of the function values over all elements of type `α`, denoted as `∑' (x : α), f x`. In other words, the total measure of a finite subset will always be less than or equal to the total measure of the entire set.

For any function from an arbitrary type to extended nonnegative real numbers, the sum of the function values over a finite subset is less than or equal to the sum of the function values over the entire set.


theorem IsPreconnected.intermediate_value₂_eventually₁ :
    ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : OrderClosedTopology α] {s : Set X},
      IsPreconnected s →
        ∀ {a : X} {l : Filter X},
          a ∈ s →
            ∀ [inst_4 : Filter.NeBot l],
              l ≤ Filter.principal s →
                ∀ {f g : X → α}, ContinuousOn f s → ContinuousOn g s → f a ≤ g a → g ≤ᶠ[l] f → ∃ x ∈ s, f x = g x :=
  by sorry

This theorem states that for any preconnected subset 's' of a topological space 'X' and any two continuous functions 'f' and 'g' from 'X' to a linearly ordered, topologically closed space 'α', if 'f' is less than or equal to 'g' at a point 'a' in 's' and 'g' is eventually less than or equal to 'f' in a filter 'l' which is a superset of 's', then there exists a point in 's' at which 'f' equals 'g'. Note that the filter 'l' must be non-empty ('Filter.NeBot l').

If a preconnected subset 's' of a topological space 'X' and continuous functions 'f' and 'g' from 'X' to a linearly ordered, topologically closed space 'α' satisfy 'f'(a) <= 'g'(a) in 's' and 'g' is eventually less than or equal to 'f' in a non-empty filter 'l' that supersets 's', then there exists a point in 's' where 'f' equals 'g'.


theorem IsPreconnected.intermediate_value₂_eventually₂ :
    ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : OrderClosedTopology α] {s : Set X},
      IsPreconnected s →
        ∀ {l₁ l₂ : Filter X} [inst_4 : Filter.NeBot l₁] [inst_5 : Filter.NeBot l₂],
          l₁ ≤ Filter.principal s →
            l₂ ≤ Filter.principal s →
              ∀ {f g : X → α}, ContinuousOn f s → ContinuousOn g s → f ≤ᶠ[l₁] g → g ≤ᶠ[l₂] f → ∃ x ∈ s, f x = g x :=
  by sorry

This theorem states that for any topological space `X`, any linearly ordered type `α` that is also a topological space and has an order-closed topology, and any preconnected set `s` of `X`, the following is true: for any two non-bottom filters `l₁` and `l₂` which are subsets of the principal filter of `s`, and for any two functions `f` and `g` from `X` to `α` that are continuous on `s`, if `f` is less than or equal to `g` almost everywhere with respect to `l₁` and `g` is less than or equal to `f` almost everywhere with respect to `l₂`, then there exists an element `x` in `s` such that `f(x) = g(x)`.

In simpler terms, if `f` and `g` are two functions that are continuous on a preconnected set and each is not greater than the other almost everywhere with respect to some filters, then they must intersect at some point in the set. This theorem is a version of the intermediate value theorem for sets in a topological space.

Given a topological space X, a preconnected set s, and two continuous functions f and g from X to a linearly ordered topological space α with order-closed topology, if f is less than or equal to g almost everywhere with respect to some filters l₁ and g is less than or equal to f almost everywhere with respect to some filters l₂, then there exists an x in s such that f(x) = g(x).


theorem ConnectedComponents.surjective_coe :
    ∀ {α : Type u} [inst : TopologicalSpace α], Function.Surjective ConnectedComponents.mk := by sorry

This theorem states that for all types `α` equipped with a topological space structure, the function `ConnectedComponents.mk`, which maps each element of the type `α` to the set of its connected components, is surjective. In other words, for any given connected component in the topological space `α`, there exists an element in `α` which maps to that component under the function `ConnectedComponents.mk`. Thus, every connected component can be reached by this function from some element of the type `α`.

For any topological space `α`, the function `ConnectedComponents.mk` maps every connected component to some element in `α`.


theorem HomologicalComplex.single_obj_d :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      (j : ι) (A : V) (k l : ι), ((HomologicalComplex.single V c j).obj A).d k l = 0 :=
  by sorry

This theorem states that for any type `V` that is a category with zero morphisms and zero object, for any `ComplexShape c`, any object `j` of a certain type `ι`, and any `A` of type `V`, the morphism `d` between any two objects `k` and `l` in the homological complex obtained by applying the functor `HomologicalComplex.single V c j` to `A` is the zero morphism. This is assuming that the equality between objects of type `ι` is decidable.

For any type `V` that is a category with zero morphisms and zero object, the application of the functor `HomologicalComplex.single V` to any object `A` of type `V`, results in all morphisms in the obtained complex being the zero morphism, given decidable equality of objects of type `ι`.


CategoryTheory.SheafOfTypes.Hom.ext'

theorem CategoryTheory.SheafOfTypes.Hom.ext' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
      {X Y : CategoryTheory.SheafOfTypes J} (f g : X ⟶ Y), f.val = g.val → f = g :=
  by sorry

This theorem, in the context of category theory, states that for any category `C` with a Grothendieck topology `J`, and for any two sheaves of types `X` and `Y` over `J`, if there are two morphisms `f` and `g` from `X` to `Y`, and if these two morphisms have the same value, then `f` and `g` are equal. In simpler terms, it states that two morphisms between the same pair of sheaves are identical if their values are the same.

In a category with a Grothendieck topology, two morphisms between the same pair of sheaves are equal if and only if they have the same value.


theorem Derivation.leibniz_of_mul_eq_one :
    ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra R A] {M : Type u_3}
      [inst_3 : AddCommGroup M] [inst_4 : Module A M] [inst_5 : Module R M] (D : Derivation R A M) {a b : A},
      a * b = 1 → D a = -a ^ 2 • D b :=
  by sorry

This theorem states that for any commutative ring `R`, ring `A`, and module `M` over `A` and `R` with a derivation `D` from `A` to `M`, if the product of two elements `a` and `b` in `A` equals 1, then the derivation of `a` is equal to the negative of `a` squared scaled by the derivation of `b`. This is a version of Leibniz rule specialized for the case when the product of `a` and `b` is 1. The theorem is a manifestation of the properties of derivations in the context of algebra.

For any commutative rings `R`, ring `A`, module `M` over `A` and `R`, and derivation `D` from `A` to `M`, if `a` and `b` are elements of `A` with `a * b = 1`, then `D(a) = - a^2 * D(b)`.


theorem Nat.findGreatest_spec :
    ∀ {m : ℕ} {P : ℕ → Prop} [inst : DecidablePred P] {n : ℕ}, m ≤ n → P m → P (Nat.findGreatest P n) := by sorry

The theorem `Nat.findGreatest_spec` states that for any natural number `m`, a predicate `P` which maps natural numbers to propositions, and a decidable instance `inst` for `P`, along with another natural number `n`, if `m` is less than or equal to `n` and `P m` holds true, then `P (Nat.findGreatest P n)` also holds true. In other words, if a certain property `P` holds for a number `m` up to `n`, then the same property holds for the greatest number where `P` is true up to `n`, as found by `Nat.findGreatest`.

For any decidable predicate `P` on natural numbers, if `m` is less than or equal to `n` and `P(m)` holds, then `P(Nat.findGreatest P n)` also holds.


theorem PrimeSpectrum.le_iff_specializes :
    ∀ {R : Type u} [inst : CommSemiring R] (x y : PrimeSpectrum R), x ≤ y ↔ x ⤳ y := by sorry

This theorem states that for any commutative semiring `R` and any two elements `x` and `y` in the prime spectrum of `R`, `x` is less than or equal to `y` if and only if `x` specializes to `y`. The specialization relation, denoted `x ⤳ y`, is a binary relation often used in the theory of topological spaces, and specifically in the Zariski topology of the prime spectrum of a ring. In this context, it denotes that the prime ideal `x` is contained in the prime ideal `y` or, equivalently, that `y` is a generalization of `x`.

In the prime spectrum of a commutative semiring, two elements are order-isomorphic, i.e., one is a specialization of the other, if and only if one is contained in the other as prime ideals.


theorem UniformSpace.hasBasis_ofFun :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrderedAddCommMonoid β],
      (∃ x, 0 < x) →
        ∀ (d : α → α → β) (refl : ∀ (x : α), d x x = 0) (symm : ∀ (x y : α), d x y = d y x)
          (triangle : ∀ (x y z : α), d x z ≤ d x y + d y z) (half : ∀ ε > 0, ∃ δ > 0, ∀ x < δ, ∀ y < δ, x + y < ε),
          Filter.HasBasis (uniformity α) (fun x => 0 < x) fun ε => {x | d x.1 x.2 < ε} :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is a linearly ordered additive commutative monoid and there exists a positive element in `β`, along with a function `d` mapping two elements of `α` to `β` such that `d` is reflexive, symmetric and satisfies the triangle inequality, and for any `ε > 0`, there exists `δ > 0` such that for all `x, y < δ`, `x + y < ε`. Under these conditions, the uniformity (which is a filter on `α × α` inferred from an ambient uniform space structure on `α`) has a basis such that for all `ε > 0`, the set of pairs `(x.1, x.2)` for which `d x.1 x.2 < ε` belongs to the basis. In other words, the uniformity structure on `α` has a basis which is determined by the distances between elements being less than a certain threshold.

Given a type `α` with a linearly ordered additive commutative monoid `β` having a positive element, and a function `d` from `α × α` to `β` that is reflexive, symmetric, and satisfies the triangle inequality, there exists a basis for the uniformity on `α` determined by `d` such that for every `ε > 0`, the set of pairs `(x, y)` with `d x y < ε` belongs to the basis.


theorem edist_inv_inv :
    ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsometricSMul G G]
      [inst_3 : IsometricSMul Gᵐᵒᵖ G] (a b : G), edist a⁻¹ b⁻¹ = edist a b :=
  by sorry

This theorem states that for any type `G` that forms a Group and is a PseudoEMetricSpace, and under the conditions that scalar multiplication `IsometricSMul` is defined both for `G` and its opposite `Gᵐᵒᵖ`, the extended distance `edist` between the inverses `a⁻¹` and `b⁻¹` of any two elements `a` and `b` of `G` is equal to the extended distance between `a` and `b` themselves. This essentially means that in such a space, taking inverses doesn't affect the distance between elements.

For any group `G` that is a PseudoEMetricSpace with isometric scalar multiplication, the extended distance between the inverses of any two elements is equal to the extended distance between the elements themselves.


theorem Fintype.card_finset : ∀ {α : Type u_1} [inst : Fintype α], Fintype.card (Finset α) = 2 ^ Fintype.card α := by
  sorry

This theorem states that for any type `α` which is finite (represented by `[inst : Fintype α]`), the number of distinct finite subsets (or `Finset`s) of `α` is equal to 2 raised to the power of the number of elements in `α`. In mathematical terms, if `α` is a finite set with `n` elements, then the number of all possible subsets of `α` is `2^n`.

For any finite type `α` with `n` elements, the number of distinct finite subsets of `α` is `2^n`.


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

The theorem `MeasureTheory.AEStronglyMeasurable.congr` states that for any measurable space `α`, measure `μ` on `α`, and a topological space `β`, if a function `f` from `α` to `β` is Almost Everywhere (AE) Strongly Measurable with respect to `μ` and `f` is almost everywhere equal to another function `g` (i.e., `f` and `g` are equal except possibly on a set of measure zero), then `g` is also AE Strongly Measurable with respect to `μ`. In other words, the property of being AE Strongly Measurable is preserved under almost everywhere equality of functions.

If `f` is AE Strongly Measurable and almost everywhere equal to `g` on a measurable space `(α, Σ, μ)`, then `g` is also AE Strongly Measurable with respect to `(α, Σ, μ)`.


theorem PartitionOfUnity.sum_eq_one :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) {x : X},
      x ∈ s → (finsum fun i => (f i) x) = 1 :=
  by sorry

This theorem states that for any type `ι`, any topological space `X`, any set `s` of `X`, any partition of unity `f` over `ι`, `X`, and `s`, and any element `x` of `X`, if `x` is in `s`, then the finite sum of `(f i) x` over all `i` equals 1. Essentially, for any point `x` in the domain of a partition of unity, the sum of the functions at that point is equal to 1. Here, a partition of unity is a collection of continuous functions (from the space to the real numbers) that are positive, have support that is compact (i.e., closed and bounded), and the sum of which is always 1 at any point in the space.

For any topological space X, partition of unity f over X and ι, and x ∈ X belonging to the union of supports of f i, the sum ∑ i:ι (f i x) equals 1.


theorem DFinsupp.coe_nsmul :
    ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → AddMonoid (β i)] (b : ℕ) (v : Π₀ (i : ι), β i),
      ⇑(b • v) = b • ⇑v :=
  by sorry

This theorem states that for any type `ι`, any function `β` mapping elements of `ι` to another type, and for any instance which provides an addition operation for the type returned by `β`, the application of a scalar multiplication (`b • v`) over a direct sum function `v` (denoted as `Π₀ (i : ι), β i`) is equal to scalar multiplication applied to the result of function `v`. In other words, scalar multiplication can be interchanged with function application.

For any type `ι`, function `β : ι → T`, and instance of addition on `T`, the scalar multiplication `b • (Π₀ i : ι, β i)` equals the application of scalar multiplication to each component of the product `Π₀ i : ι, b • β i`.


/-- Theorem 2.5 in [Gleason, *Projective topological spaces*][gleason1958]:
in the category of compact spaces and continuous maps,
the projective spaces are precisely the extremally disconnected spaces. -/
theorem CompactT2.ExtremallyDisconnected.projective :
    ∀ {A : Type u} [inst : TopologicalSpace A] [inst_1 : ExtremallyDisconnected A] [inst_2 : CompactSpace A]
      [inst_3 : T2Space A], CompactT2.Projective A :=
  by sorry

This theorem, which is Theorem 2.5 in Gleason's "Projective topological spaces", states that in the category of compact spaces with continuous maps, a space is a projective space if and only if it is extremally disconnected. This applies to any type `A` which has a topological space structure, is extremally disconnected, is compact, and satisfies the T2 separation axiom (also known as being a Hausdorff space).

A compact, Hausdorff space is a projective space if and only if it is extremally disconnected.


theorem MeasureTheory.L1.integral_def :
    ∀ {α : Type u_5} {E : Type u_6} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] (f : ↥(MeasureTheory.Lp E 1 μ)),
      MeasureTheory.L1.integral f = MeasureTheory.L1.integralCLM f :=
  by sorry

This theorem states that for any normed additive commutative group `E`, measurable space `α`, measure `μ` on `α`, and for any function `f` in the L1 space (i.e., the space of Lebesgue-integrable functions), the Bochner integral of `f` (calculated using the `MeasureTheory.L1.integral` function) is equal to the value of `f` under the continuous linear map `MeasureTheory.L1.integralCLM`. In other words, it confirms that the Bochner integral in L1 space can be computed as a continuous linear map over the real numbers.

For any normed additive commutative group `E`, measurable space `α`, measure `μ` on `α`, and `f` in the L1 space, the Bochner integral of `f` equals the value of the continuous linear map `MeasureTheory.L1.integralCLM` applied to `f`.


/-- A function is `C^∞` if and only if it is differentiable,
and its derivative (formulated in terms of `fderiv`) is `C^∞`.  -/
theorem contDiff_top_iff_fderiv :
    ∀ {𝕜 : 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},
      ContDiff 𝕜 ⊤ f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 f y :=
  by sorry

The theorem `contDiff_top_iff_fderiv` states that a function `f` is infinitely continuously differentiable (denoted as `C^∞`) if and only if it is differentiable and its derivative, as formulated through the `fderiv` function, is also infinitely continuously differentiable.

Here, `C^∞` means the function is differentiable and all its derivatives are also differentiable. The function `f` is from a normed vector space `E` over a nontrivial normed field `𝕜` to another normed vector space `F` over `𝕜`. The derivative of `f` at a point `x` in `E`, given by `fderiv 𝕜 f x`, is a continuous linear map from `E` to `F`.

A function `f` from a normed vector space `E` to another normed vector space `F` is infinitely continuously differentiable if and only if it is differentiable and its derivative, as a continuous linear map, is infinitely differentiable.


/-- See also `Irreducible.isRelPrime_iff_not_dvd`.  -/
theorem Irreducible.coprime_iff_not_dvd :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsBezout R] {p n : R}, Irreducible p → (IsCoprime p n ↔ ¬p ∣ n) := by
  sorry

This theorem states that, for any commutative ring `R` with a Bezout identity and any elements `p` and `n` of `R`, if `p` is irreducible, then `p` and `n` are coprime (i.e., there exist `a` and `b` in `R` such that `a * p + b * n = 1`) if and only if `p` does not divide `n`. In other words, an irreducible element `p` is coprime with `n` precisely when it is not a divisor of `n`.

An irreducible element in a commutative ring with a Bezout identity is coprime with another element if and only if it doesn't divide that element.


theorem Real.rpow_le_rpow_left_iff_of_base_lt_one : ∀ {x y z : ℝ}, 0 < x → x < 1 → (x ^ y ≤ x ^ z ↔ z ≤ y) := by sorry

This theorem states that for any three real numbers `x`, `y`, and `z`, if `x` is positive and less than one, then `x` raised to the power of `y` is less than or equal to `x` raised to the power of `z` if and only if `z` is less than or equal to `y`. In mathematical terms, for all real numbers x, y, z where 0 < x < 1, it holds that x^y ≤ x^z if and only if z ≤ y.

For real numbers x, y, and z with 0 < x < 1, x^y ≤ x^z if and only if z ≤ y.


/-- The other direction does not hold because of the `s`-`s` cross terms on the RHS.  -/
theorem Set.image2_distrib_subset_left :
    ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {γ' : Type u_6} {δ : Type u_7} {ε : Type u_9}
      {s : Set α} {t : Set β} {u : Set γ} {f : α → δ → ε} {g : β → γ → δ} {f₁ : α → β → β'} {f₂ : α → γ → γ'}
      {g' : β' → γ' → ε},
      (∀ (a : α) (b : β) (c : γ), f a (g b c) = g' (f₁ a b) (f₂ a c)) →
        Set.image2 f s (Set.image2 g t u) ⊆ Set.image2 g' (Set.image2 f₁ s t) (Set.image2 f₂ s u) :=
  by sorry

This theorem establishes a rule about the manipulations of the image of multiple binary functions under certain conditions. Specifically, it states that for any sets `s`, `t`, and `u` and any binary functions `f`, `g`, `f₁`, `f₂`, and `g'`, if `f` applied to an element from `s` and the result of `g` applied to an element from `t` and `u` is equal to `g'` applied to `f₁` applied to an element from `s` and `t` and `f₂` applied to an element from `s` and `u`, then the image under `f` of `s` and the image under `g` of `t` and `u` is a subset of the image under `g'` of the image under `f₁` of `s` and `t` and the image under `f₂` of `s` and `u`. It should be noted that this subset relation does not necessarily hold in the reverse direction.

If for all x in s, y in t, and z in u, g(y, z) = f₁(x, y) * f₂(x, z) implies im f(s) ⊆ im (g' ∘ (f₁ ∘ π₁ ∘ π₂)) (s × t × u), where π₁ and π₂ are the projections onto the first two coordinates.


theorem IsClopen.eq_univ :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : PreconnectedSpace α] {s : Set α},
      IsClopen s → Set.Nonempty s → s = Set.univ :=
  by sorry

This theorem states that for any type `α` equipped with a topology and a preconnected space structure, if a set `s` of `α` is clopen (both closed and open) and nonempty, then `s` is equal to the universal set. This means that in a preconnected space, any nonempty clopen set must include all elements of the space.

In a preconnected topological space, any nonempty clopen set is equal to the universal set.


Joined.symm

theorem Joined.symm : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Joined x y → Joined y x := by sorry

The theorem `Joined.symm` states that for any topological space `X` and any two points `x` and `y` in `X`, if `x` and `y` are joined by a path (denoted as `Joined x y`), then `y` and `x` are also joined by a path (denoted as `Joined y x`). This property is also known as the symmetry of the relation "being joined by a path".

For any topological space X and points x, y in X, if Joined x y then Joined y x.


theorem measurableSet_Iio :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst : OrderClosedTopology α] {a : α}, MeasurableSet (Set.Iio a) :=
  by sorry

This theorem states that for any given type `α` equipped with a topology, a measurable space, an open measurable space, a linear order, and an order closed topology, and for any given element `a` of type `α`, the left-infinite right-open interval `Set.Iio a` (which is the set of all `x` in `α` such that `x` is less than `a`) is a measurable set (in the ambient measure space on `α`).

Given a type `α` with a topology, measurable space, an open measurable space, a linear order, and an order-closed topology, the left-infinite right-open interval `Set.Iio a` is a measurable set for any `a` in `α`.


theorem Polynomial.natDegree_sub_C :
    ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} {a : R},
      Polynomial.natDegree (p - Polynomial.C a) = Polynomial.natDegree p :=
  by sorry

The theorem `Polynomial.natDegree_sub_C` states that for any given ring `R`, any polynomial `p` over `R`, and any element `a` of `R`, the natural degree of the polynomial resulting from subtracting the constant polynomial `a` from `p` is equal to the natural degree of the original polynomial `p`. In other words, subtracting a constant from a polynomial does not change its natural degree.

The natural degree of a polynomial's difference with a constant polynomial is equal to the natural degree of the original polynomial.


theorem Fin.val_succ : ∀ {n : ℕ} (j : Fin n), ↑(Fin.succ j) = ↑j + 1 := by sorry

This theorem states that for any natural number `n` and any element `j` of the finite set `Fin n`, the value of the successor of `j` (as defined by the `Fin.succ` function) is equal to the value of `j` incremented by 1. In other words, if we take an element from a finite set of natural numbers up to `n`, apply the `Fin.succ` operation, and then take the value, we will obtain the original value plus one.

For any natural number `n` and element `j` of `Fin n`, `Fin.succ j = j + 1`.


/-- A groupoid is closed under restriction if and only if it contains the trivial restriction-closed
groupoid.  -/
theorem closedUnderRestriction_iff_id_le :
    ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H),
      ClosedUnderRestriction G ↔ idRestrGroupoid ≤ G :=
  by sorry

The theorem `closedUnderRestriction_iff_id_le` states that for any type `H` equipped with a topological structure and any structure groupoid `G` on `H`, the groupoid `G` is closed under restriction if and only if the groupoid `G` contains the trivial restriction-closed groupoid, which only contains partial homeomorphisms equivalent to the restriction of the identity to the various open subsets of `H`. Here, "contains" means that every member of the trivial restriction-closed groupoid is also a member of `G`.

A topological groupoid on a type `H` is closed under restriction if and only if it contains the trivial restriction-closed groupoid of partial homeomorphisms equivalent to identity restrictions on open subsets of `H`.


/-- A binary injective function is injective when only the right argument varies.  -/
theorem Function.Injective2.right :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ},
      Function.Injective2 f → ∀ (a : α), Function.Injective (f a) :=
  by sorry

The theorem `Function.Injective2.right` states that for all types `α`, `β`, and `γ`, and for any binary function `f : α → β → γ`, if `f` is injective in both arguments (meaning that if `f a₁ b₁ = f a₂ b₂`, then `a₁ = a₂` and `b₁ = b₂`), then `f` is also injective in its second argument when the first argument is fixed. In other words, for every fixed value of `a : α`, the function `f a` is injective, which means that if `f a b₁ = f a b₂`, then `b₁ = b₂`.

If a binary function `f : α → β → γ` is injective in both arguments, then for every fixed `a : α`, the function `f a : β → γ` is injective.


theorem Stream'.WSeq.LiftRelO.imp_right :
    ∀ {α : Type u} {β : Type v} (R : α → β → Prop) {C D : Stream'.WSeq α → Stream'.WSeq β → Prop},
      (∀ (s : Stream'.WSeq α) (t : Stream'.WSeq β), C s t → D s t) →
        ∀ {o : Option (α × Stream'.WSeq α)} {p : Option (β × Stream'.WSeq β)},
          Stream'.WSeq.LiftRelO R C o p → Stream'.WSeq.LiftRelO R D o p :=
  by sorry

The theorem `Stream'.WSeq.LiftRelO.imp_right` states that for any types `α` and `β`, and any relation `R` between `α` and `β`, if for any weak sequences `s` of `α` and `t` of `β`, a relation `C` between `s` and `t` implies a relation `D` between `s` and `t`, then for any option `o` of a pair of an `α` and a weak sequence of `α`, and any option `p` of a pair of a `β` and a weak sequence of `β`, if the lifted relation `LiftRelO` with respect to `R` and `C` holds between `o` and `p`, then the lifted relation `LiftRelO` with respect to `R` and `D` also holds between `o` and `p`.

In other words, if a relation `C` between two weak sequences implies another relation `D`, then the lifted versions of these relations with respect to another relation `R` and certain optional pairs also hold the implication relationship.

If relation `C` implies relation `D` between weak sequences, then the lifted relations `LiftRelO(R, C)` and `LiftRelO(R, D)` hold the implication relationship for any type `α`, `β`, and option pairs of `α` and weak sequences of `α`, and `β` and weak sequences of `β`, with respect to relation `R`.


theorem Set.mem_vadd_set_iff_neg_vadd_mem :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {A : Set β} {a : α} {x : β},
      x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is an additive group and there is an additive action of `α` on `β`, and any set `A` of type `β`, and any elements `a` in `α` and `x` in `β`, `x` is in the translated set `a +ᵥ A` if and only if the element `-a +ᵥ x` is in the set `A`. Here, `+ᵥ` denotes the operation of translating a set or an element by adding an element of the additive group.

For any additive group `α` acting on type `β`, and any set `A` of type `β` and elements `a in α` and `x in β`, the element `x` is in the translated set `a +ᵥ A` if and only if `-a +ᵥ x` is in `A`.


theorem AlgHom.ext_iff :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] {φ₁ φ₂ : A →ₐ[R] B}, φ₁ = φ₂ ↔ ∀ (x : A), φ₁ x = φ₂ x :=
  by sorry

This theorem states that for any commutative semiring `R`, semirings `A` and `B`, with `A` and `B` being `R`-algebras, two algebra homomorphisms `φ₁` and `φ₂` from `A` to `B` are equal if and only if they map every element of `A` to the same element in `B`. In other words, two algebra homomorphisms are identical if they behave identically for every element in their domain.

Two `R`-algebra homomorphisms from a commutative semiring `A` to a commutative semiring `B` are equal if and only if they map every element of `A` to the same element in `B`.


theorem hasDerivWithinAt_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) (s : Set 𝕜) (c : F), HasDerivWithinAt (fun x => c) 0 s x :=
  by sorry

The theorem `hasDerivWithinAt_const` states that, for any non-trivially normed field `𝕜`, normed additive commutative group `F`, any point `x` in `𝕜`, any subset `s` of `𝕜`, and any constant `c` in `F`, the function `f` defined as `f(x) = c` for all `x` has a derivative of `0` at the point `x` within the subset `s`. In other words, it states that the derivative of a constant function is always `0`, regardless of the point and the subset within which we are considering.

For any non-trivially normed field 𝕜, normed additive commutative group F, constant c in F, and subset s of 𝕜, the constant function f(x) = c has derivative 0 at x in s.


theorem TopCat.GlueData.ι_injective :
    ∀ (D : TopCat.GlueData) (i : D.J), Function.Injective ⇑(CategoryTheory.GlueData.ι D.toGlueData i) := by sorry

The theorem `TopCat.GlueData.ι_injective` states that for any glued data structure `D` in the category of topological spaces (`TopCat.GlueData`), and any index `i` in the indexing set of `D`, the map `ι` from the `i`th component to the glued data (given by `CategoryTheory.GlueData.ι D.toGlueData i`) is injective. In other words, if applying this map to two different points in the `i`th component gives the same point in the glued data, then the two original points must have been the same.

For any glued data structure in the category of topological spaces, the map from the indexing set to the glued data is injective.


theorem Matrix.det_fin_two_of :
    ∀ {R : Type v} [inst : CommRing R] (a b c d : R), Matrix.det (Matrix.of ![![a, b], ![c, d]]) = a * d - b * c := by
  sorry

This theorem states that for any commutative ring `R`, the determinant of a 2x2 matrix with elements `a`, `b`, `c`, and `d` is equal to `a*d - b*c`. In mathematical terms, if we have a matrix
```
| a  b |
| c  d |
```
its determinant is computed as `a*d - b*c`. This is a specific case of the general determinant calculation for square matrices, and it aligns with the Leibniz formula for the determinant of a matrix.

The determinant of a 2x2 commutative ring matrix [a b; c d] equals a*d - b*c.


theorem Mathlib.Algebra.Group.Basic._auxLemma.17 :
    ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, (a⁻¹ = b⁻¹) = (a = b) := by sorry

This theorem, `Mathlib.Algebra.Group.Basic._auxLemma.17`, states that for any type `G` equipped with an `InvolutiveInv` (an operation that is its own inverse), and any two elements `a` and `b` of this type, the equality of their inverses (`a⁻¹ = b⁻¹`) is equivalent to the equality of the elements themselves (`a = b`). In other words, if two elements have the same inverse under this operation, they must be the same element.

For any type `G` with an `InvolutiveInv`, if `a` and `b` are elements of `G` such that `a⁻¹ = b⁻¹`, then `a = b`.


theorem Mathlib.Probability.Process.Stopping._auxLemma.12 :
    ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True := by sorry

This theorem, named `Mathlib.Probability.Process.Stopping._auxLemma.12`, states that for any type `α` in a Preorder (a mathematical structure where the relation is reflexive and transitive), any instance `a` of this type is less than or equal to itself. In other words, in any preorder, every element is less than or equal to itself, which is a property of reflexivity in preorders. The equality `(a ≤ a) = True` reflects this property.

In any preorder, every element is less than or equal to itself (reflexivity property).


theorem IsArtinian.wellFounded_submodule_lt :
    ∀ (R : Type u_5) (M : Type u_6) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : IsArtinian R M], WellFounded fun x x_1 => x < x_1 :=
  by sorry

This theorem states that for any semiring `R` and any additive commutative monoid `M` that also has a module structure over `R`, if `M` is Artinian (i.e., it satisfies the descending chain condition), then the relation "is a proper submodule of" (`x < x_1`) on the set of all submodules of `M` is a well-founded relation. A well-founded relation is one where there are no infinite descending chains, which aligns with the Artinian property.

In a semiring `R` and an additive commutative `R`-module `M` that satisfies the descending chain condition, the relation "is a proper submodule of" on the set of submodules of `M` is well-founded.


theorem Nat.mem_primeFactors : ∀ {n p : ℕ}, p ∈ n.primeFactors ↔ Nat.Prime p ∧ p ∣ n ∧ n ≠ 0 := by sorry

The theorem `Nat.mem_primeFactors` states that for any natural numbers `n` and `p`, `p` is a member of the prime factors of `n` if and only if `p` is a prime number, `p` divides `n`, and `n` is not equal to zero. In other words, a natural number `p` is a prime factor of another natural number `n` exactly when `p` is a prime number that divides `n`, and `n` is not zero. This theorem serves as a characterization of prime factors in terms of primality, divisibility, and non-zero conditions.

A natural number `p` is a prime factor of another natural number `n` if and only if `p` is a prime number that divides `n` and `n` is non-zero.


theorem CircleDeg1Lift.ext : ∀ ⦃f g : CircleDeg1Lift⦄, (∀ (x : ℝ), f x = g x) → f = g := by sorry

This theorem, named `CircleDeg1Lift.ext`, states that for any two objects `f` and `g` of type `CircleDeg1Lift`, if for all real numbers `x`, the application of `f` to `x` is equal to the application of `g` to `x`, then `f` and `g` are equal. In other words, two `CircleDeg1Lift` functions are equal if they produce the same results for all real numbers.

If two functions `f` and `g` in the type `CircleDeg1Lift` agree on all real numbers, then they are equal.


theorem Filter.extraction_of_frequently_atTop :
    ∀ {P : ℕ → Prop}, (∃ᶠ (n : ℕ) in Filter.atTop, P n) → ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n) := by sorry

The theorem `Filter.extraction_of_frequently_atTop` states that if a property `P` holds frequently at the limit towards infinity (`Filter.atTop`) for natural numbers, then there exists a strictly increasing function `φ` such that for every natural number `n`, the property `P` holds for `φ(n)`. In other words, we can extract a strictly increasing sequence of natural numbers where the property `P` is always true.

If a property holds frequently at the limit towards infinity for natural numbers, then there exists a strictly increasing function mapping every natural number to a number where the property holds.


theorem List.mem_append_right : ∀ {α : Type u_1} {a : α} (l₁ : List α) {l₂ : List α}, a ∈ l₂ → a ∈ l₁ ++ l₂ := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, any list `l₁` of type `α`, and any list `l₂` of type `α`, if `a` is an element of `l₂`, then `a` is also an element of the list formed by appending `l₁` and `l₂`. In other words, if an item is in the second list, it is also in the list which results from appending the first and second lists.

If `a` is an element of list `l₂`, then `a` is an element of the list obtained by appending `l₁` and `l₂`.


theorem ENNReal.toNNReal_eq_zero_iff : ∀ (x : ENNReal), x.toNNReal = 0 ↔ x = 0 ∨ x = ⊤ := by sorry

This theorem states that for any extended nonnegative real number `x`, the function `toNNReal` applied to `x` equals zero if and only if `x` itself equals zero or `x` equals infinity. Informally, it asserts that in the set of extended nonnegative real numbers (which includes 0, positive reals, and infinity), the only elements that map to zero in the nonnegative real numbers are 0 and infinity.

For any extended nonnegative real number `x`, `toNNReal x = 0` if and only if `x = 0` or `x = ∞`.


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

This theorem states that for any three types `F`, `G`, and `H`, along with elements `a` of type `G`, `b` of type `H`, an integer `n`, a function `f` from `F` to `G`, and `x` of type `G`, if `G` and `H` are add groups and there is a map from `F` to `G` to `H` that maps `a` to `b`, then applying the function `f` to the sum of `x` and `n` times `a` is the same as the sum of `f(x)` and `n` times `b`. In mathematical notation, this would be expressed as: `f(x + n*a) = f(x) + n*b`.

For any add groups G, H, types F, functions f from F to G to H with f(a) = b, and elements a of type F, x of type G, and integer n, we have f(x + n*a) = f(x) + n*b.


theorem Ordinal.cof_eq_sInf_lsub :
    ∀ (o : Ordinal.{u}), Ordinal.cof o = sInf {a | ∃ ι f, Ordinal.lsub f = o ∧ Cardinal.mk ι = a} := by sorry

This theorem states that for any ordinal `o`, the cofinality of `o` is equal to the infimum of the set of all cardinals `a` such that there exists an index set `ι` and a function `f` from `ι` to the ordinal numbers, where `o` is the least strict upper bound of the function `f` and `a` is the cardinality of the index set `ι`. In simpler terms, the theorem relates the cofinality of an ordinal to the least upper bound of a family of ordinals and the cardinality of the index set over which this family is defined.

The cofinality of an ordinal `o` is the smallest cardinality of an index set `ι` and the cardinality of `ι` such that there exists a function `f: ι -> On` with `o` as the least upper bound of `range(f)`.


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

The theorem `Fin.succAbove_castPred_of_lt` states that for any natural number `n` and any two elements `p` and `i` of the type `Fin (n + 1)`, if `i` is less than `p` and `i` is not the last element of `Fin (n + 1)` (with the latter condition being optional and defaults to a certain value if not given), then embedding `Fin n` into `Fin (n + 1)` with a hole around `p` after casting `i` from `Fin (n + 1)` to `Fin n` results in `i` itself. In simpler terms, if `i` is less than `p` and is not the biggest element, then inserting `i` in `Fin n` (after reducing its size by 1) into `Fin (n + 1)` at position `p` will give us `i` again.

For any natural numbers `n` and `i`, `p` in `Fin (n + 1)` with `i < p` and `i ≠ last (Fin (n + 1))`, the embedding of `i` from `Fin (n + 1)` to `Fin n` and back to `Fin (n + 1)` at position `p` yields `i`.


theorem Set.singleton_op : ∀ {α : Type u_1} (x : α), Set.op {x} = {Opposite.op x} := by sorry

The theorem `Set.singleton_op` states that for any type `α` and any element `x` of type `α`, the opposite of the singleton set containing `x` is the singleton set containing the opposite of `x`. Here, "opposite" refers to the operation defined by `Set.op` and `Opposite.op`, which involve reversing or "flipping" the elements of a set and the elements of a type, respectively.

For any type `α` and element `x` of `α`, the opposite of the singleton set `{x}` is the singleton set `{op x}`, where `op` is the opposite operation.


theorem Set.singleton_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (i : ι) (t : (i : ι) → Set (α i)), Set.pi {i} t = Function.eval i ⁻¹' t i := by
  sorry

The theorem `Set.singleton_pi` states that for any type `ι`, any function `α` mapping elements of `ι` to types, any element `i` of `ι`, and any function `t` mapping elements of `ι` to sets of the corresponding type `α`, the set of dependent functions `f` such that `f a` belongs to `t a` for each `a` in the singleton set `{i}`, is equal to the preimage of the set `t i` under the function `Function.eval i`. In other words, it's the set of functions `f` that map `i` to an element in `t i`.

For any type `ι`, function `α : ι → Type`, element `i` of `ι`, and set `t : ι → Set`, the function `{f : ι → α // ∀ a, f a ∈ t a}`, which selects functions mapping `i` to an element in `t i`, is equal to the set `{g : α | g ∈ t i ∧ ∀ a, a = i → g = f a}`.


/-- Taking the product under `h` is an additive-to-multiplicative homomorphism of finsupps,
if `h` is an additive-to-multiplicative homomorphism.
This is a more specialized version of `Finsupp.prod_add_index` with simpler hypotheses.  -/
theorem Finsupp.prod_add_index' :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : AddZeroClass M] [inst_1 : CommMonoid N] {f g : α →₀ M}
      {h : α → M → N},
      (∀ (a : α), h a 0 = 1) →
        (∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂) →
          Finsupp.prod (f + g) h = Finsupp.prod f h * Finsupp.prod g h :=
  by sorry

This theorem states that when taking the product under a function `h` across the elements of two finitely supported functions `f` and `g`, it respects the operation of addition, behaving like a homomorphism from additive to multiplicative domains, provided `h` itself is an additive-to-multiplicative homomorphism. In other words, for any finitely supported functions `f` and `g` with elements of type `M` and a function `h` that maps elements of type `α` and `M` to `N`, if `h` maps each `a` to `1` when paired with zero and satisfies the property that `h(a, b₁ + b₂)` equals `h(a, b₁) * h(a, b₂)` for any `b₁` and `b₂`, then the product of `h` over `f + g` equals the product of `f` and `g` under `h`. This is a more specialized version of `Finsupp.prod_add_index` with simpler hypotheses.

Given finitely supported functions `f` and `g` with additive domain `M` and a function `h: α × M → N` that is an additive-to-multiplicative homomorphism, the product of `h` over the sum of `f` and `g` equals the product of `h` over `f` and `g`.


theorem List.card_cons_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {as : List α}, a ∉ as → List.card (a :: as) = List.card as + 1 := by
  sorry

The theorem `List.card_cons_of_not_mem` states that for all types `α` with decidable equality, given an element `a` of type `α` and a list `as` of elements of type `α`, if `a` is not a member of `as`, then the cardinality of the list obtained by prepending `a` to `as` is equal to the cardinality of `as` plus one. In mathematical terms, if `a` is not in the set `as`, then the size of the set `{a} ∪ as` is `|as| + 1`.

If `a` is not an element of the list `as`, then the cardinality of the list `[a] ++ as` equals the cardinality of `as` + 1.


theorem Set.nonempty_compl : ∀ {α : Type u} {s : Set α}, Set.Nonempty sᶜ ↔ s ≠ Set.univ := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, the complement of the set `s` (denoted as `sᶜ`) is nonempty if and only if `s` is not the universal set. In other words, there exists at least one element not in `s` if and only if `s` does not contain all possible elements of the type `α` (i.e., `s` is not the universal set). This captures the intuitive notion that if a set doesn't contain everything, then there must be something it doesn't contain, and vice versa.

The complement of a set `s` of type `α` is nonempty if and only if `α` is not the universal set of `s`.


theorem specializes_iff_pure : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y ↔ pure x ≤ nhds y := by
  sorry

This theorem states that for any topological space `X` and any two points `x` and `y` from `X`, `x` specializes to `y` (notation: `x ⤳ y`) if and only if the filter of `x` is less than or equal to the neighborhood filter at `y` (notation: `pure x ≤ nhds y`). In other words, `x` is said to specialize to `y` when every neighborhood of `y` also contains `x`.

For any topological space X and points x, y from X, x specializes to y (x ⤳ y) if and only if the filter of x is included in the neighborhood filter at y (pure x ≤ nhds y).


theorem List.chain'_cons' :
    ∀ {α : Type u} {R : α → α → Prop} {x : α} {l : List α},
      List.Chain' R (x :: l) ↔ (∀ y ∈ List.head? l, R x y) ∧ List.Chain' R l :=
  by sorry

The theorem `List.chain'_cons'` states that for any type `α`, any binary relation `R` on `α`, any element `x` of type `α`, and any list `l` of elements of type `α`, the property that `R` holds between adjacent elements of the list `[x] concatenated with `l` (represented as `x :: l` in Lean 4) is equivalent to the conjunction of two conditions: 1) `R` holds between `x` and the first element of `l` (if `l` is not empty), and 2) `R` holds between all adjacent elements of `l`. In other words, a list starting with `x` is a chain under `R` if and only if `x` is related to the first element of the list (if it exists) under `R`, and the rest of the list is a chain under `R`.

For any type `α` and binary relation `R` on `α`, a list `[x] :: l` of elements of `α` is a chain under `R` if and only if `R` holds between `x` and the first element of `l` (if `l` is non-empty), and `R` holds between all adjacent elements of `l`.


theorem NormedAddGroupHom.coe_inj :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      {f g : NormedAddGroupHom V₁ V₂}, ⇑f = ⇑g → f = g :=
  by sorry

This theorem states that for any two normed additive group homomorphisms `f` and `g` from a seminormed additive commutative group `V₁` to another seminormed additive commutative group `V₂`, if the function application of `f` and `g` (denoted by `⇑f` and `⇑g`) are equal, then `f` and `g` themselves are also equal. Essentially, it asserts the injectivity of the coercion function from the type of normed additive group homomorphisms to the type of functions.

If two normed additive group homomorphisms between seminormed additive commutative groups have equal function applications, then they are equal.


theorem Nat.cast_pred : ∀ {R : Type u} [inst : AddGroupWithOne R] {n : ℕ}, 0 < n → ↑(n - 1) = ↑n - 1 := by sorry

This theorem states that for any natural number `n` and any type `R` that forms an additive group with one, if `n` is greater than zero, then casting (`↑`) `n - 1` to the type `R` is equal to subtracting one from the cast of `n`. In other words, for positive natural numbers, subtracting one before or after casting to the type `R` yields the same result.

For any additive group type `R` with one and natural number `n` greater than zero, casting `n - 1` to `R` is equal to subtracting one from the cast of `n`, i.e., `(↑ (n - 1)) = (↑ n) - 1` in `R`.


theorem eventually_countable_forall :
    ∀ {ι : Sort u_1} {α : Type u_2} {l : Filter α} [inst : CountableInterFilter l] [inst : Countable ι]
      {p : α → ι → Prop}, (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i :=
  by sorry

The theorem `eventually_countable_forall` states that for any type `α`, filter `l` on `α`, a countable type `ι`, and a property `p` from `α` to `ι`, the statement "For almost every `x` in the filter `l`, for all `i` in `ι`, the property `p` holds for `x` and `i`" is equivalent to the statement "For all `i` in `ι`, for almost every `x` in the filter `l`, the property `p` holds for `x` and `i`". Here, "almost every" refers to the "eventually" notation, meaning that the property holds outside of a set of `l`'s measure zero. The filter `l` is also assumed to have the property that the intersection of any countable collection of sets in `l` is also in `l`.

For any type `α`, filter `l` on `α`, countable type `ι`, and property `p` from `α` to `ι`, the properties "for almost every `x` in `l`, `p(x, i)` holds for all `i` in `ι`" and "for all `i` in `ι`, for almost every `x` in `l`, `p(x, i)` holds" are equivalent, given `l`'s countable intersection property.


theorem Nat.cast_prod :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommSemiring β] (f : α → ℕ) (s : Finset α),
      ↑(Finset.prod s fun i => f i) = Finset.prod s fun i => ↑(f i) :=
  by sorry

The theorem `Nat.cast_prod` states that for any commutative semiring `β`, any function `f` from a type `α` to the natural numbers, and any finite set `s` of elements of type `α`, the natural number cast of the product of `f x` as `x` ranges over the set `s` is equal to the product of the natural number casts of `f x` as `x` ranges over the set `s`. In other words, casting the product of a sequence of natural numbers to a commutative semiring is the same as taking the product of the casts of the individual elements of the sequence. This theorem is a formal statement of the fact that the operation of taking products commutes with the operation of casting from natural numbers to a commutative semiring.

For any commutative semiring β and function f from type α to natural numbers, the cast of the product of f x as x ranges over a finite set s equals the product of the casts of f x as x ranges over s.


theorem Set.piecewise_op₂ :
    ∀ {α : Type u_1} {δ : α → Sort u_6} (s : Set α) (f g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)]
      {δ' : α → Sort u_7} {δ'' : α → Sort u_8} (f' g' : (i : α) → δ' i) (h : (i : α) → δ i → δ' i → δ'' i),
      (Set.piecewise s (fun x => h x (f x) (f' x)) fun x => h x (g x) (g' x)) = fun x =>
        h x (Set.piecewise s f g x) (Set.piecewise s f' g' x) :=
  by sorry

The theorem `Set.piecewise_op₂` states that for any type `α`, function type `δ`, set `s` of type `α`, functions `f` and `g` from `α` to `δ`, a decidable instance for membership in `s`, and additional function types `δ'` and `δ''`, as well as functions `f'` and `g'` from `α` to `δ'`, and a function `h` from `α` and `δ` and `δ'` to `δ''`. The function `h` applied in a piecewise manner (i.e., different on the set `s` and its complement) using `f` and `f'` or `g` and `g'` is the same as the function `h` applied to the piecewise application of `f` and `g`, and separately to the piecewise application of `f'` and `g'`.

In other words, applying a function in a piecewise manner to the outputs of two other functions applied in a piecewise manner is the same as applying the function to the piecewise applications of the two other functions.

Given sets `α`, types `δ`, `δ'`, `δ''`, functions `f, g : α -> δ`, `f' : α -> δ'`, `g' : α -> δ'`, and functions `h : α x δ x δ' -> δ''` decidable `s : Set α`, the piecewise application of `h` using `f` and `f'` on `s` and its complement is equal to the separate piecewise applications of `h` on the piecewise applications of `f` and `f'`.


IsTrans.swap

theorem IsTrans.swap : ∀ {α : Type u} (r : α → α → Prop) [inst : IsTrans α r], IsTrans α (Function.swap r) := by sorry

The theorem `IsTrans.swap` states that for any type `α` and a binary relation `r` on `α`, if `r` is transitive, then the swapped variant of `r` is also transitive. Here, a relation `r` is transitive (denoted `IsTrans α r`) if for any three elements `a`, `b`, `c` of type `α`, `r a b` and `r b c` imply `r a c`. The swapped variant of `r` (denoted `Function.swap r`) is a relation that takes two inputs in the opposite order, i.e., if `r` is a relation from `α` to `β`, then `Function.swap r` is a relation from `β` to `α`.

If `r` is a transitive relation on type `α`, then the swapped relation `Function.swap r` is also transitive.


theorem MeasureTheory.Measure.InnerRegularWRT.smul :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop},
      MeasureTheory.Measure.InnerRegularWRT μ p q →
        ∀ (c : ENNReal), MeasureTheory.Measure.InnerRegularWRT (c • μ) p q :=
  by sorry

The theorem `MeasureTheory.Measure.InnerRegularWRT.smul` states that for any type `α`, measurable space `m`, measure `μ`, and predicates `p` and `q` on sets of `α`, if the measure `μ` is inner regular with respect to `p` and `q`, then for any extended nonnegative real number `c`, the measure `c • μ` (which is the scalar multiplication of `c` and `μ`) is also inner regular with respect to `p` and `q`. In other words, the property of inner regularity is preserved under scalar multiplication of the measure.

If measure `μ` is inner regular with respect to predicates `p` and `q` on measurable space `m` of type `α`, then for any extended nonnegative real number `c`, the measure `c • μ` is also inner regular with respect to `p` and `q`.


theorem Ideal.sub_mem : ∀ {α : Type u} [inst : Ring α] (I : Ideal α) {a b : α}, a ∈ I → b ∈ I → a - b ∈ I := by sorry

The theorem `Ideal.sub_mem` states that for any given type `α`, which has a ring structure, and for any ideal `I` of `α`, if `a` and `b` are elements of `I`, then the difference of `a` and `b` (that is, `a - b`) is also an element of `I`. This theorem is essentially stating one of the fundamental properties of an ideal in a ring: closure under subtraction.

If `I` is an ideal in a ring `α`, then for all `a, b ∈ I`, we have `a - b ∈ I`.


SimpleGraph.Adj.reachable

theorem SimpleGraph.Adj.reachable :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, G.Adj u v → SimpleGraph.Reachable G u v := by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, and any two vertices `u` and `v` of type `V`, if `u` and `v` are adjacent in the graph `G` (denoted by `G.Adj u v`), then `u` and `v` are reachable from each other in the graph `G`. In other words, there exists a walk in the graph `G` that starts at vertex `u` and ends at vertex `v`.

For any simple graph `G` and vertices `u` and `v` in its type `V`, if `u` is adjacent to `v` in `G` (`G.Adj u v`), then there exists a walk from `u` to `v` in `G`.


theorem Finset.sum_product :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] {s : Finset γ} {t : Finset α}
      {f : γ × α → β}, (Finset.sum (s ×ˢ t) fun x => f x) = Finset.sum s fun x => Finset.sum t fun y => f (x, y) :=
  by sorry

The theorem `Finset.sum_product` states that for any types `α`, `β`, and `γ`, and given an addition-commutative monoid structure on `β`, any finite sets `s` of type `γ` and `t` of type `α`, and any function `f` from the Cartesian product of `γ` and `α` to `β`, the sum of `f` over the Cartesian product of `s` and `t` is equal to the sum of the sums of `f` over the elements of `t` for each element of `s`. In mathematical notation, this is ∑_{(x,y) ∈ s × t} f(x,y) = ∑_{x ∈ s} ∑_{y ∈ t} f(x,y). This theorem is expressing a property of summing over a product of sets.

For any addition-commutative monoid β, given finite sets s of type γ and t of type α, and a function f from the Cartesian product s × t to β, the sum of f over the Cartesian product s × t is equal to the sum of the sums of f over the elements of t for each element of s. (i.e., ∑_{(x,y) ∈ s × t} f(x,y) = ∑_{x ∈ s} ∑_{y ∈ t} f(x,y)).


theorem mem_upperBounds : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, a ∈ upperBounds s ↔ ∀ x ∈ s, x ≤ a :=
  by sorry

This theorem establishes a membership criterion for the set of upper bounds of a given set in a preordered type. Specifically, it states that for any type `α` equipped with a preorder, a set `s : Set α`, and an element `a : α`, `a` is an upper bound of `s` if and only if for every element `x` in `s`, `x` is less than or equal to `a`. This means that `a` is an upper bound of `s` if it is greater than or equal to all elements of `s`.

For any preordered type `α`, set `s : Set α`, and element `a : α`, `a` is an upper bound of `s` if and only if `x ≤ a` for all `x ∈ s`.


theorem Set.Finite.isOpen_biInter :
    ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
      Set.Finite s → (∀ i ∈ s, IsOpen (f i)) → IsOpen (⋂ i ∈ s, f i) :=
  by sorry

This theorem states that for any type `X` with a topological space structure and any type `α`, given a finite set `s` of `α` and a function `f` that maps each element of `α` to an open set in `X`, if every set `f i` for `i` in `s` is open, then the intersection of all such sets `f i` (i.e., the set `⋂ i ∈ s, f i`) is also open. In other words, it states that the intersection of a finite number of open sets is also an open set in a topological space.

In a topological space, the intersection of finitely many open sets is open.


theorem CategoryTheory.Limits.Types.Limit.map_π_apply' :
    ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F G : CategoryTheory.Functor J (Type v)} (α : F ⟶ G)
      (j : J) (x : CategoryTheory.Limits.limit F),
      CategoryTheory.Limits.limit.π G j (CategoryTheory.Limits.limMap α x) =
        α.app j (CategoryTheory.Limits.limit.π F j x) :=
  by sorry

This theorem states that for any categories `J` and `(Type v)`, and any two functors `F` and `G` from `J` to `(Type v)`, given a natural transformation `α` from `F` to `G`, and an object `j` in `J` and `x` in the limit object of the functor `F`, applying the limit projection (`CategoryTheory.Limits.limit.π`) of functor `G` at `j` to the limit map (`CategoryTheory.Limits.limMap`) of `α` at `x`, is the same as applying `α` at `j` to the limit projection of `F` at `j` applied to `x`.

In terms of category theory, this theorem confirms the expected behavior of limit projections and limit maps under natural transformations between functors, which is fundamental to the definition and properties of limit objects in a category.

Given functors F and G from category J to Type v, a natural transformation α from F to G, an object j in J, and an object x in the limit of F, the limit projection of G at j applied to the limit map of α at x equals applying α at j to the limit projection of F at j applied to x.


DifferentiableOn.hasFDerivAt

theorem DifferentiableOn.hasFDerivAt :
    ∀ {𝕜 : 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}
      {x : E} {s : Set E}, DifferentiableOn 𝕜 f s → s ∈ nhds x → HasFDerivAt f (fderiv 𝕜 f x) x :=
  by sorry

The theorem `DifferentiableOn.hasFDerivAt` states that for any scalar field `𝕜` with a non-trivially normed field structure, and any normed additive commutative groups `E` and `F` with normed space structures over `𝕜`, if a function `f` from `E` to `F` is differentiable on a set `s` and the set `s` is a neighborhood of a point `x` in `E`, then `f` has the continuous linear map `fderiv 𝕜 f x` as its derivative at `x`. In other words, if the function is differentiable at every point in some neighborhood of `x`, then the derivative of `f` at `x` exists and is given by `fderiv 𝕜 f x`.

If a differentiable function between normed spaces is defined on a neighborhood of a point, then it has a continuous linear derivative at that point.


theorem AddSubgroup.coe_top : ∀ {G : Type u_1} [inst : AddGroup G], ↑⊤ = Set.univ := by sorry

This theorem is stating that for any type `G` that has an additive group structure, the set of all elements of the additive group (represented by `↑⊤`) is equal to the universal set of the type `G` (represented by `Set.univ`). In other words, every element of the type `G` is an element of the additive group. Here, `⊤` stands for the top element in the lattice of subgroups, i.e., the entire group itself.

For any additive group `G`, the set of all group elements is equal to the universal set of `G`. In symbols, `↑⊤ = Set.univ` for the additive group `G`.