theorem continuousWithinAt_Ioi_iff_Ici :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : PartialOrder α] [inst_2 : TopologicalSpace β]
      {a : α} {f : α → β}, ContinuousWithinAt f (Set.Ioi a) a ↔ ContinuousWithinAt f (Set.Ici a) a :=
  by sorry

The theorem `continuousWithinAt_Ioi_iff_Ici` states that for any two topological spaces `α` and `β`, where `α` is also a partial order, a function `f` from `α` to `β` is continuous at a point `a` within the right-infinite interval that is open on the left `(Set.Ioi a)` if and only if `f` is continuous at the same point `a` within the right-infinite interval that is closed on the left `(Set.Ici a)`. In other words, the continuity of `f` at `a` over the right-open or right-closed right-infinite intervals is equivalent.

For any topological spaces α and β, where α is a partial order, the function f from α to β is continuous at a point a in the right-open interval Ioi a and the right-closed interval Ici a if and only if they are equal in the sense of sets. (That is, continuity of f at a over the two types of right-infinite intervals is interchangeable.)


theorem Int.floor_natCast : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (n : ℕ), ⌊↑n⌋ = ↑n :=
  by sorry

This theorem, `Int.floor_natCast`, states that for any natural number `n` in a linear ordered ring `α` that also has a floor function, the floor of the natural number `n` when cast to `α` is equal to `n` when cast to `α`. Essentially, it shows that the floor function of a natural number, after type casting, retains the original value.

For any natural number `n` in a linear ordered ring with a floor function, `α`, the floor of `n` cast to `α` equals the cast of `n` to `α`. In Lean syntax: `(∀ (α : Type u) [LinearOrderedAddCommMonoid α] [HasFloor α], ∀ (n : ℕ), floor α (coe n) = coe n)`.


theorem convexOn_const :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} (c : β),
      Convex 𝕜 s → ConvexOn 𝕜 s fun x => c :=
  by sorry

The theorem `convexOn_const` states that for any set `s` of elements of type `E` in a scalar multiplication space `𝕜`, if `s` is convex, then the function `f` that maps each element `x` in `s` to a constant `c` of type `β` satisfies the property of being "convex on" `s`. In other words, if `s` is a convex set, then a constant function defined on this set is a convex function. This is true under the conditions that `𝕜` is an ordered semiring, `E` is an additive commutative monoid, `β` is an ordered additive commutative monoid, and `𝕜` has scalar multiplication actions on `E` and `β`.

If `𝕜` is an ordered semiring, `E` an additive commutative monoid, `β` an ordered additive commutative monoid, and `s ⊆ E` convex, then the constant function `f : s → β` defined by `f x = c` for all `x ∈ s` and some constant `c ∈ β`, is convex on `s`.


theorem Subgroup.pow_mem : ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {x : G}, x ∈ K → ∀ (n : ℕ), x ^ n ∈ K :=
  by sorry

This theorem, `Subgroup.pow_mem`, asserts that for any group `G` and any subgroup `K` of `G`, if an element `x` belongs to `K`, then `x` raised to any natural number `n` also belongs to `K`. In other words, any power of an element in a subgroup remains in the subgroup.

For any group `G` and subgroup `K`, if `x` is an element of `K`, then for all natural numbers `n`, `x^n` is also an element of `K`.


theorem GeneralizedContinuedFraction.of_terminatedAt_n_iff_succ_nth_intFractPair_stream_eq_none :
    ∀ {K : Type u_1} [inst : LinearOrderedField K] [inst_1 : FloorRing K] {v : K} {n : ℕ},
      GeneralizedContinuedFraction.TerminatedAt (GeneralizedContinuedFraction.of v) n ↔
        GeneralizedContinuedFraction.IntFractPair.stream v (n + 1) = none :=
  by sorry

This theorem states that for any type `K` which is a linear ordered field and a floor ring, and for any value `v` of type `K` and a natural number `n`, a generalized continued fraction derived from `v` terminates at position `n` if and only if the stream of integer-fraction pairs derived from `v` is `none` at position `n + 1`. In other words, the termination of the generalized continued fraction at a specific position corresponds to the absence of an integer-fraction pair at the next position in the related sequence.

A generalized continued fraction for a linear ordered field and floor ring `K` value `v` terminates at position `n` if and only if the sequence of integer-fraction pairs derived from `v` is empty at position `n+1`.


Specializes.symm

/-- In an R₀ space, the `Specializes` relation is symmetric, dot notation version.  -/
theorem Specializes.symm : ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R0Space X] {x y : X}, x ⤳ y → y ⤳ x :=
  by sorry

This theorem states that in a topological space X, which also satisfies the R0 separation axiom (R0Space), the 'Specializes' relation is symmetric when applied to any two points x and y in the space X. This means that if x specializes to y, then y also specializes to x. The 'Specializes' relation is a concept in topology that signifies that every neighbourhood of x also contains y.

In a topological space X satisfying R0 separation axiom, the 'Specializes' relation is symmetric: if x specializes to y, then y specializes to x.


/-- A version of `toNat_eq_iff` for literals  -/
theorem Cardinal.toNat_eq_ofNat :
    ∀ {c : Cardinal.{u}} {n : ℕ} [inst : Nat.AtLeastTwo n], Cardinal.toNat c = OfNat.ofNat n ↔ c = OfNat.ofNat n := by
  sorry

This theorem, `Cardinal.toNat_eq_ofNat`, asserts that for any cardinal number `c` of any type and a natural number `n` that is at least two, the cardinal's equivalence to the natural number when converted via `Cardinal.toNat` is equivalent to the cardinal's equality to the natural number translation via `OfNat.ofNat`. In simpler terms, the theorem is stating that the cardinality of a set is equal to a given natural number if and only if, when we convert that cardinality to a natural number, we get that natural number. This essentially allows us to compare cardinalities of sets with natural numbers in a meaningful way.

For any cardinal number `c` and natural number `n` with `n ≥ 2`, `Cardinal.toNat c = OfNat.ofNat n` if and only if `c = nat.fromCardinal n`.


theorem Cardinal.nat_eq_lift_iff : ∀ {n : ℕ} {a : Cardinal.{u}}, ↑n = Cardinal.lift.{v, u} a ↔ ↑n = a := by sorry

This theorem states that for any natural number `n` and any cardinal number `a` in the universe `u`, the cardinal number equivalent of `n` is equal to the universe lift of `a` (i.e., `a` moved to a potentially larger universe `v`) if and only if the cardinal number equivalent of `n` is equal to `a`. In other words, it asserts the equivalence between the two conditions: the cardinality of `n` being equal to the universe lift of `a` and the cardinality of `n` being equal to `a`.

For any natural number `n` and cardinal number `a`, the cardinality of `n` equals the universe lift of `a` if and only if the cardinality of `n` equals `a`.


theorem ne_zero_of_mem_unit_sphere :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (x : ↑(Metric.sphere 0 1)), ↑x ≠ 0 := by sorry

This theorem states that for any seminormed additive group `E`, any point `x` on the unit sphere centered at zero (i.e., the set of all points at a distance 1 from the origin) is not equal to the zero vector. In other words, there are no points on the unit sphere that are also at the origin.

The theorem asserts that that the unit sphere of a seminormed additive group `E` contains no point equal to the zero vector.


theorem Zsqrtd.norm_eq_one_iff : ∀ {d : ℤ} {x : ℤ√d}, Int.natAbs (Zsqrtd.norm x) = 1 ↔ IsUnit x := by sorry

This theorem states that for any integer `d` and any element `x` from the ring of integers adjoined with the square root of `d`, the absolute value of the norm of `x` being 1 is equivalent to `x` being a unit in that ring. In other words, an element `x` in `ℤ[√d]` is a unit if and only if the absolute value of its norm is 1. Here, a unit is an element with a multiplicative inverse.

In the ring of integers adjoined with the square root of a given integer `d`, an element `x` is a unit if and only if the absolute value of its norm is 1.


theorem Mathlib.Data.Polynomial.Coeff._auxLemma.4 :
    ∀ {R : Type u} [inst : Semiring R] (a b : AddMonoidAlgebra R ℕ),
      { toFinsupp := a } * { toFinsupp := b } = { toFinsupp := a * b } :=
  by sorry

This theorem states that for any semiring `R` and any two elements `a` and `b` of the monoid algebra over `R` generated by the additive monoid of natural numbers, the product of the two elements `a` and `b` in the monoid algebra, after being converted to `toFinsupp`, is equal to the `toFinsupp` conversion of the product of `a` and `b` in the original monoid algebra. This essentially means that the multiplication operation in the monoid algebra is compatible with the `toFinsupp` conversion.

For any semiring `R` and elements `a`, `b` in the monoid algebra over `R` generated by the additive monoid of natural numbers, the conversion of their product in the monoid algebra to `toFinsupp` is equal to the `toFinsupp` conversion of their product in the original monoid algebra.


theorem Mathlib.Algebra.Lie.Nilpotent._auxLemma.5 :
    ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True := by sorry

This theorem, from the Mathlib library in the Algebra.Lie.Nilpotent module, states that for any type `α` that has a less than or equal to (`LE`) operation and an element called `OrderTop` (representing the maximum possible value), any element `a` of type `α` is less than or equal to this maximum value. In mathematical terms, this is saying for all `a` in `α`, `a ≤ ⊤` is always true.

For any type `α` with a `LE` order and an `OrderTop` element, every `a` in `α` satisfies `a ≤ OrderTop`.


MetricSpace.ext

/-- Two metric space structures with the same distance coincide.  -/
theorem MetricSpace.ext :
    ∀ {α : Type u_3} {m m' : MetricSpace α}, PseudoMetricSpace.toDist = PseudoMetricSpace.toDist → m = m' := by sorry

This theorem states that if two metric space structures, `m` and `m'`, over the same type `α`, have the same distance function (as determined by the `PseudoMetricSpace.toDist` function), then these two metric space structures are equivalent, i.e., `m` equals `m'`. In other words, the distance function uniquely determines the structure of the metric space.

If two metric space structures over the same type have the same distance function, then they are equal.


theorem map_add_left_nhds :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G] (x y : G),
      Filter.map (fun x_1 => x + x_1) (nhds y) = nhds (x + y) :=
  by sorry

This theorem states that for any type `G` that is a topological space, an additive group, and a topological additive group, for any elements `x` and `y` of `G`, the forward map of the neighborhood filter at `y` under the addition of `x` is equal to the neighborhood filter at `x + y`. In simpler terms, it says that if we shift each element in a neighborhood of `y` by adding `x`, then the resulting set is a neighborhood of `x + y` in the given topological additive group.

For any topological additive group `G` and elements `x, y` in `G`, the forward neighborhood filters at `x` and `x + y` are equal.


/-- Uses `left` co(ntra)variant.  -/
theorem Left.one_lt_inv_iff :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a : α}, 1 < a⁻¹ ↔ a < 1 :=
  by sorry

This theorem, `Left.one_lt_inv_iff`, states that for any type `α` that forms a group with a less than (`<`) operation and satisfies a specific covariance condition, a certain element `a` of this group satisfies the inequality `1 < a⁻¹` (1 is less than the inverse of `a`) if and only if `a < 1` (a is less than 1). This theorem shows that in this mathematical structure, being less than 1 and having an inverse greater than 1 are equivalent properties for any element.

For any group `α` with a covariant `<` relation, `1 < a` if and only if `a < 1` for all elements `a` in `α`.


theorem List.lt_length_right_of_zipWith :
    ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β},
      i < List.length (List.zipWith f l l') → i < List.length l' :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, a function `f` from `α` and `β` to `γ`, a natural number `i`, and lists `l` and `l'` of types `α` and `β`, respectively, if `i` is less than the length of the list resulting from applying `zipWith` to `f`, `l`, and `l'`, then `i` is also less than the length of list `l`.

In other words, an index `i` that is valid in the list created by `zipWith` function also implies that it is a valid index in the original list `l` of type `α`.

For any functions `f` from `α × β` to `γ`, if the length of `zipWith f l1 l2` is greater than `i`, then the length of `l1` is also greater than `i`, where `l1` is a list of type `α` and `l2` is a list of type `β`.


theorem CompleteLattice.WellFounded.finite_ne_bot_of_independent :
    ∀ {α : Type u_2} [inst : CompleteLattice α],
      (WellFounded fun x x_1 => x > x_1) →
        ∀ {ι : Type u_3} {t : ι → α}, CompleteLattice.Independent t → Set.Finite {i | t i ≠ ⊥} :=
  by sorry

The theorem `CompleteLattice.WellFounded.finite_ne_bot_of_independent` states that for any type `α` with a `CompleteLattice` structure, if the greater-than relation on `α` is well-founded, then for any type `ι` and any function `t : ι → α`, if the function `t` is independent (meaning for any subset of `ι`, the join of the images under `t` equals the join of the function `t` at each element of the subset), then the set of indices `i` such that `t i` is not the bottom element of the lattice is finite. This theorem links the concepts of well-foundedness, independence, and finiteness in the context of complete lattices.

In a complete lattice with well-founded greater-than relation, the images under an independent function from a type to the lattice, excluding the bottom element, form a finite set.


theorem NNReal.coe_eq_one : ∀ {r : NNReal}, ↑r = 1 ↔ r = 1 := by sorry

This theorem states that for any nonnegative real number `r`, the coercion of `r` to a real number equals 1 if and only if `r` itself equals 1. In other words, the only nonnegative real number that, when considered as a normal real number, equals 1, is the nonnegative real number 1 itself.

For any non-negative real number `r`, `r = 1` if and only if the coercion of `r` to a real number is equal to 1.


theorem Nat.le_sub_of_add_le : ∀ {a b c : ℕ}, a + b ≤ c → a ≤ c - b := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if the sum of `a` and `b` is less than or equal to `c`, then `a` is less than or equal to the difference of `c` and `b`. In mathematical notation, this theorem can be expressed as: if $a + b \leq c$, then $a \leq c - b$.

If $a$, $b$, and $c$ are natural numbers with $a + b \leq c$, then $a \leq c - b$.


theorem max_def' : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), max a b = if b ≤ a then a else b := by sorry

This theorem states that for any type `α` that has a linear order, the maximum of two elements `a` and `b` of this type is defined as follows: If `b` is less than or equal to `a`, then `a` is the maximum; otherwise, `b` is the maximum. Essentially, it's a formal way of saying the maximum of `a` and `b` is `a` if `a` is greater than or equal to `b`, and `b` otherwise.

For any type `α` with a linear order, the maximum of `a` and `b` is `a` if `a` is greater than or equal to `b`, and `b` otherwise.


theorem MeasureTheory.snorm'_zero :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F], 0 < q → MeasureTheory.snorm' 0 q μ = 0 :=
  by sorry

The theorem `MeasureTheory.snorm'_zero` states that for any measurable space `α`, type `F` that forms a normed additively commutative group, a real number `q` such that `0 < q`, and a measure `μ` on `α`, the `snorm'` of the zero function (a function that maps every element of `α` to `0` in `F`) with respect to measure `μ` and exponent `q` is `0`. In other words, the seminorm, calculated as the `q`-th power mean of the norms of the function values (with `q` > 0), of the zero function is `0`.

For any measurable space, normed additively commutative group, real number `q` with `0 < q`, and measure, the seminorm of the zero function with respect to the measure and exponent `q` equals `0`.


theorem isLindelof_iUnion :
    ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Sort u_2} {f : ι → Set X} [inst_1 : Countable ι],
      (∀ (i : ι), IsLindelof (f i)) → IsLindelof (⋃ i, f i) :=
  by sorry

The theorem `isLindelof_iUnion` states that for any type `X` with a topological space structure, and for any countable index set `ι`, if for each index `i` in `ι`, the set `f i` (a function from `ι` to the set of `X`) is Lindelöf, then the union of all the sets `f i` (denoted by `(⋃ i, f i)`) is also Lindelöf. A Lindelöf set in this context is one where every nontrivial filter (a "description" of a point's neighborhood) that has the countable intersection property and contains the set has a cluster point (a point in the closure of every neighborhood of the filter) in the set.

If each set in a countable family of Lindelöf subsets of a topological space is Lindelöf, then their union is also a Lindelöf subset.


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

The theorem `IsOpen.subset_interior_iff` states that for any type `X` and any two sets `s` and `t` of type `X` in a given topological space, if `s` is an open set, then `s` is a subset of the interior of `t` if and only if `s` is a subset of `t`. In other words, for an open set `s`, being a subset of the interior of `t` is equivalent to being a subset of `t` itself.

An open set is a subset of the interior of another set if and only if it is a subset of that set.


theorem Finsupp.induction_linear :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] {p : (α →₀ M) → Prop} (f : α →₀ M),
      p 0 → (∀ (f g : α →₀ M), p f → p g → p (f + g)) → (∀ (a : α) (b : M), p fun₀ | a => b) → p f :=
  by sorry

This theorem is a principle of mathematical induction for finite function support (`Finsupp`) in a linear setting. Given any type `α`, another type `M` that has an additive zero class structure (meaning it has operations of addition and zero), and a property `p` that applies to functions from `α` into `M` with finite support, the theorem states that if the property holds for the zero function, and if the property is preserved under addition of such functions, and if the property holds for all 'singleton' functions that take a specific value from `α` to a specific value from `M`, then the property holds for all such functions with finite support.

Given a type `α`, a type `M` with additive zero class structure, and a property `p` on functions from `α` to `M` with finite support, if `p` holds for the zero function, is closed under addition, and holds for all singleton functions, then `p` holds for all functions with finite support.


theorem max_min_distrib_left :
    ∀ {α : Type u} [inst : LinearOrder α] (a b c : α), max a (min b c) = min (max a b) (max a c) := by sorry

This theorem states that for any type `α` that obeys the laws of linear order, and any elements `a`, `b`, and `c` of this type, the maximum of `a` and the minimum of `b` and `c` is equal to the minimum of the maximum of `a` and `b` and the maximum of `a` and `c`. This is a statement about the distributive properties of the `max` and `min` functions in a linearly ordered set.

For all linearly ordered types `α` and elements `a, b, c` of `α`, the maximum of `a` and the minimum of `b` and `c` equals the minimum of the maximum of `a` and `b`, and the maximum of `a` and `c` (distributivity of `max` and `min` in a linearly ordered set).


theorem sub_pow_char_of_commute :
    ∀ (R : Type u_1) [inst : Ring R] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP R p] (x y : R),
      Commute x y → (x - y) ^ p = x ^ p - y ^ p :=
  by sorry

The theorem `sub_pow_char_of_commute` states that for any given ring `R` and natural number `p` that is prime, and for any two elements `x` and `y` of the ring `R` that commute (i.e., `x * y = y * x`), the p-th power of the difference of `x` and `y` (i.e., `(x - y) ^ p`) is equal to the difference of the p-th power of `x` and `y` (i.e., `x ^ p - y ^ p`). This theorem makes use of the characteristic of the ring being equal to the prime number `p` (denoted by `CharP R p` in Lean).

For any commuting elements x and y in a ring of prime characteristic p, (x - y)^p = x^p - y^p.


theorem Filter.ptendsto'_def :
    ∀ {α : Type u} {β : Type v} (f : α →. β) (l₁ : Filter α) (l₂ : Filter β),
      Filter.PTendsto' f l₁ l₂ ↔ ∀ s ∈ l₂, PFun.preimage f s ∈ l₁ :=
  by sorry

The theorem `Filter.ptendsto'_def` states that for any types `α` and `β`, a partial function `f` from `α` to `β`, and filters `l₁` on `α` and `l₂` on `β`, the filter `l₁` tends to the filter `l₂` with respect to the partial function `f` (i.e., `Filter.PTendsto' f l₁ l₂`) if and only if for every set `s` that belongs to the filter `l₂`, the preimage of `s` under partial function `f`, denoted by `PFun.preimage f s`, belongs to the filter `l₁`. This theorem defines when a filter on the domain of a partial function tends to another filter on the codomain of the function.

A filter `l₁` on a type `α` tends to a filter `l₂` on a type `β` with respect to a partial function `f:` `α` → `β` if and only if for every set `s` in `l₂`, the preimage `f⁁¹(s)` is in `l₁`.


theorem mul_lowerClosure :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] (s t : Set α), s * ↑(lowerClosure t) = ↑(lowerClosure (s * t)) := by
  sorry

This theorem states that for any ordered commutative group `α` and any two sets `s` and `t` of elements from `α`, the product of `s` and the least lower set containing `t` is equal to the least lower set containing the product of `s` and `t`. In mathematical terms, given two sets `s` and `t` in an ordered commutative group, `s * lowerClosure(t) = lowerClosure(s * t)`. Here, the `lowerClosure` of a set is the set of all elements that are less than or equal to some element in the given set; and the multiplication `*` is done element-by-element.

For any ordered commutative group `α` and sets `s` and `t` in `α`, the least lower sets of `s * t` and `s` intersecting `t` are equal. (Equivalently, `s * lowerClosure(t) = lowerClosure(s * t)`.)


theorem SimpleGraph.mem_edgeFinset :
    ∀ {V : Type u_1} {G : SimpleGraph V} {e : Sym2 V} [inst : Fintype ↑(SimpleGraph.edgeSet G)],
      e ∈ SimpleGraph.edgeFinset G ↔ e ∈ SimpleGraph.edgeSet G :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, and any edge `e` represented as an unordered pair from `Sym2 V`, given that the edge set of `G` is finite, the edge `e` belongs to the `edgeFinset` of the graph `G` if and only if `e` belongs to the `edgeSet` of the graph `G`.

In other words, an edge is in the finite set representation (or `Finset`) of the edges of a simple graph `G` if and only if it is in the set of edges of `G`. This theorem bridges the gap between the set of edges and the finite set of edges in a simple graph.

For any simple graph with finite edge set `G` of type `V`, the edge set `edgeSet G` equals the finite set representation `edgeFinset G` of its edges.


/-- If a number `a` is less than or equal to the `liminf` of a function `f` at some filter
and is greater than or equal to the `limsup` of `f`, then `f` tends to `a` along this filter.  -/
theorem tendsto_of_le_liminf_of_limsup_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] {f : Filter β} {u : β → α} {a : α},
      a ≤ Filter.liminf u f →
        Filter.limsup u f ≤ a →
          autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝ →
            autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝¹ → Filter.Tendsto u f (nhds a) :=
  by sorry

This theorem states that for any types `α` and `β`, given a conditionally complete linear order on `α`, a topological space structure on `α`, and an order topology on `α`, if you have a filter `f` on `β` and a function `u` from `β` to `α`, and a number `a` of type `α`, then if `a` is less than or equal to the limit inferior (liminf) of `u` at `f` and `a` is greater than or equal to the limit superior (limsup) of `u` at `f`, then `u` tends to `a` along the filter `f`, assuming that the function `u` is eventually bounded both above and below. In mathematical terms, if you have $\liminf_{x\to f} u(x) \leq a \leq \limsup_{x\to f} u(x)$, then $\lim_{x\to f} u(x) = a$.

If a conditionally complete linear order on a type `α` has an order topology, and a function from a filter on another type `β` to `α` is eventually bounded both above and below, then the limit of the function along the filter equals the value that is less than or equal to the liminf and greater than or equal to the limsup.


theorem Polynomial.adjoin_X : ∀ {R : Type u} [inst : CommSemiring R], Algebra.adjoin R {Polynomial.X} = ⊤ := by sorry

This theorem states that for any commutative semiring `R`, the minimal subalgebra of polynomials over `R` that includes the polynomial variable `X` is equal to the top element of the algebra lattice, indicating it is the largest possible subalgebra. In other words, any polynomial over `R` can be expressed in terms of the indeterminate `X` and elements from `R` itself.

For any commutative semiring `R`, the minimal subalgebra of polynomials over `R` containing the indeterminate `X` is the whole algebra.


theorem Finsupp.single_mem_supported :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {s : Set α} {a : α} (b : M), a ∈ s → (fun₀ | a => b) ∈ Finsupp.supported M R s :=
  by sorry

The theorem `Finsupp.single_mem_supported` states that for any given type `α`, a semiring `R`, an additive commutative monoid `M` which is also a module over `R`, a set `s` of type `α`, an element `a` of type `α`, and an element `b` of type `M`, if `a` belongs to the set `s`, then the function `fun₀` such that it maps `a` to `b` and all other elements to `0`, belongs to the `R`-submodule of all functions from `α` to `M` (`α →₀ M`) whose support is a subset of `s`. This is essentially saying that a function mapping a single element of `s` to a non-zero value is within the submodule of all functions whose non-zero values are contained within `s`.

If `s` is a set, `α` a type, `R` a semiring, `M` an additive commutative `R`-module, `a` an element of `α` in `s`, and `b` an element of `M`, then the function mapping `a` to `b` and all other elements to `0` belongs to the `R`-submodule of all functions from `α` to `M` with support contained in `s`.


AffineSubspace.ext

theorem AffineSubspace.ext :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {p q : AffineSubspace k P}, (∀ (x : P), x ∈ p ↔ x ∈ q) → p = q :=
  by sorry

This theorem states that for any two affine subspaces `p` and `q` in an affine space `P` over a ring `k` with an associated vector space `V`, if every point in `P` has the same membership status in `p` and `q` (i.e., each point in `P` is in `p` if and only if it is in `q`), then `p` and `q` are the same affine subspace. The vector space `V` is equipped with operations from the commutative group of addition (`AddCommGroup V`) and the module structure (`Module k V`), and the affine space `P` is related to the vector space `V` through the `AddTorsor` structure.

If two affine subspaces in an affine space over a ring have the same membership for all points, they are equal subspaces.


/-- A point in `K` with the orthogonality property (here characterized in terms of `Kᗮ`) must be the
orthogonal projection.  -/
theorem eq_orthogonalProjection_of_mem_orthogonal :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {K : Submodule 𝕜 E} [inst_3 : HasOrthogonalProjection K] {u v : E},
      v ∈ K → u - v ∈ Kᗮ → ↑((orthogonalProjection K) u) = v :=
  by sorry

This theorem states that for any two vectors `u` and `v` in a normed additive commutative group `E` over a ring `𝕜` with an inner product space structure, if `v` lies in a submodule `K` of `E` and the difference `u - v` is orthogonal to `K` (lies in the orthogonal complement of `K`), then `v` is in fact the orthogonal projection of `u` onto `K`. This provides a characterization of the orthogonal projection in terms of orthogonality properties.

If a vector `v` in a normed additive commutative group `E` over a ring `𝕜` with an inner product space structure lies in a submodule `K` and is orthogonal to the difference of any vector `u` in `E` and `v`, then `v` is the orthogonal projection of `u` onto `K`.


theorem MeasureTheory.Lp.coeFn_add :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)),
      ↑↑(f + g) =ᶠ[MeasureTheory.Measure.ae μ] ↑↑f + ↑↑g :=
  by sorry

This theorem, `MeasureTheory.Lp.coeFn_add`, states that for any measure space `α`, type `E` that forms a normed additive commutative group, an extended nonnegative real number `p`, measure `μ`, and two elements `f` and `g` of the Lp space over `E` with respect to `p` and `μ`, the function application of the sum `f + g` is almost everywhere equal to the sum of the function applications of `f` and `g`. In other words, this theorem asserts the almost everywhere pointwise additivity of elements in the Lp space.

For any measure space, normed additive commutative group, measure, and elements in the Lp space, their sum is almost everywhere equal to the pointwise sum of their functions.


/-- This is a weaker version of `inf_sSup_eq`  -/
theorem iSup_inf_le_inf_sSup :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {a : α} {s : Set α}, ⨆ b ∈ s, a ⊓ b ≤ a ⊓ sSup s := by sorry

This theorem states that for any type `α` which has a complete lattice structure, for any element `a` of `α` and any subset `s` of `α`, the supremum (i.e., least upper bound) of the set of all infimum (i.e., greatest lower bound) of `a` and elements `b` in `s` is less than or equal to the infimum of `a` and the supremum of `s`. This is a weaker version of the theorem `inf_sSup_eq`.

For any complete lattice `α` and its elements `a` and any subset `s` of `α`, the infimum of `a` and the supremum of the set of infima of `a` and elements in `s` is less than or equal to the infimum of `a` and the supremum of `s`.


theorem List.diff_eq_foldl :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (l₁ l₂ : List α),
      List.diff l₁ l₂ = List.foldl List.erase l₁ l₂ :=
  by sorry

This theorem, `List.diff_eq_foldl`, states that for any type `α` that has an equality comparison operation and adheres to the laws of equality, and for any two lists `l₁` and `l₂` of type `α`, the difference of `l₁` and `l₂`, computed by the `List.diff` function, is equal to the result of folding the list `l₂` with the `List.erase` function starting with `l₁`. Folding here means applying the `List.erase` function successively to elements of `l₂` and the current result, starting with `l₁`. The `List.diff` function computes the difference by removing each element in `l₂` from `l₁`. The `List.erase` function removes the first occurrence of a particular element from a list.

For any type `α` with an equality operation adhering to the laws of equality, `List.diff (l₁ : list α) (l₂ : list α) = foldl (fun acc x => List.erase x acc) l₁ l₂`.


theorem MeasureTheory.memℒp_indicator_const :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      {s : Set α} (p : ENNReal),
      MeasurableSet s → ∀ (c : E), c = 0 ∨ ↑↑μ s ≠ ⊤ → MeasureTheory.Memℒp (Set.indicator s fun x => c) p μ :=
  by sorry

The theorem `MeasureTheory.memℒp_indicator_const` states that for any type `α`, type `E` (where `E` is a normed add commutative group), a measurable space `m0` on `α`, a measure `μ` on `α`, a set `s` of `α`, and a constant `c` from `E`, if `s` is measurable and either `c` equals zero or the measure of `s` is not infinity, then the function that assigns `c` to each element in `s` and `0` to each element not in `s` (which is denoted by `Set.indicator s fun x => c`) is in `L^p` space with respect to the measure `μ`. In other words, this function is almost everywhere strongly measurable and its `p`-th power integral is finite if `p` is less than infinity or its essential supremum is less than infinity if `p` equals infinity.

If `s` is a measurable subset of a measurable space `(α, m0)` with finite measure `μ` or `μ(s) = 0`, then the indicator function `x ↦ χ\_s(x) := if x ∈ s then c else 0` belongs to the `L^p(μ)` space for any `p ≤ ∞`.


theorem Mathlib.Data.Set.Image._auxLemma.11 :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Set.Nonempty (f '' s) = Set.Nonempty s := by sorry

The theorem `Mathlib.Data.Set.Image._auxLemma.11` states that for any two types `α` and `β`, a function `f` from `α` to `β`, and a set `s` of type `α`, the image of the set `s` under the function `f` is nonempty if and only if the set `s` is nonempty. In other words, a function will produce a nonempty set from another set if and only if the original set has at least one element.

For any type `α`, set `s` of type `α`, and function `f` from `α` to another type `β`, the image of `s` under `f` is nonempty if and only if `s` is nonempty.


theorem Matrix.submatrix_apply :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (A : Matrix m n α) (r_reindex : l → m)
      (c_reindex : o → n) (i : l) (j : o), Matrix.submatrix A r_reindex c_reindex i j = A (r_reindex i) (c_reindex j) :=
  by sorry

The theorem `Matrix.submatrix_apply` states that for any types `l`, `m`, `n`, `o`, and `α`, and for any matrix `A` with entries in `α` indexed by `m` for rows and `n` for columns, along with any reindexing functions `r_reindex` and `c_reindex` from `l` to `m` and `o` to `n` respectively, and for any indices `i` of type `l` and `j` of type `o`, the entry of the submatrix of `A` created by `r_reindex` and `c_reindex` at position `(i,j)` is equal to the entry of `A` at the position `(r_reindex i, c_reindex j)`. In other words, the theorem defines how to get entries from a submatrix of a given matrix using reindexing functions.

For any matrix `A` with entries in type `α`, and given reindexing functions `r_reindex : l → m` and `c_reindex : o → n`, the entry of the submatrix at position `(i, j)` is equal to the entry of `A` at position `(r_reindex i, c_reindex j)`.


AddSubmonoid.LocalizationMap.surj

theorem AddSubmonoid.LocalizationMap.surj :
    ∀ {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),
      ∃ x, z + (AddSubmonoid.LocalizationMap.toMap f) ↑x.2 = (AddSubmonoid.LocalizationMap.toMap f) x.1 :=
  by sorry

This theorem, `AddSubmonoid.LocalizationMap.surj`, states that for any given types `M` and `N`, where `M` is an additive commutative monoid and `N` is also an additive commutative monoid, for any localization map `f` from a submonoid `S` of `M` to `N` and for any element `z` of `N`, there exists an element `x` such that adding `z` to the image of `x.2` under `f` equals the image of `x.1` under `f`. In other words, every element in `N` can be represented as the sum of the localization map applied to some element of `M` plus the localization map applied to an element of `S`.

For any additive commutative monoids M and N, any submonoid S of M, and any localization map f from S to N, for every element z in N, there exists an element x in S such that f(x.1 + s) = f(x.1) + z for some s in S.


theorem Fin.succAbove_castSucc_of_le : ∀ {n : ℕ} (p i : Fin n), p ≤ i → Fin.succAbove (Fin.castSucc p) i = Fin.succ i :=
  by sorry

This theorem states that for all natural numbers `n` and for any two elements `p` and `i` of the finite set of size `n` (denoted as `Fin n`), if `p` is less than or equal to `i`, then embedding `Fin n` into `Fin (n+1)` with a hole around `p` using the `succAbove` function on `p` after it is embedded into `Fin (n+1)` using the `castSucc` function, and `i`, is equivalent to directly incrementing `i` by one using the `succ` function. In simpler terms, if we have a position `p` and another position `i` in a finite set, and `p` is not greater than `i`, then moving `p` up to the next set and then putting `i` in its place is the same as directly moving `i` up to the next set.

For all natural numbers `n` and `p`, `i` in `Fin n`, if `p <= i`, then `succAbove p (castSucc i) = succ i` in `Fin (n+1)`.


theorem CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality :
    ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ)
      {X Y : Cᵒᵖ} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
          ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app Y) =
        CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app X) f :=
  by sorry

This theorem states that for any category `C` that has a shift (`CategoryTheory.HasShift C ℤ`), and for any integer `n`, the mapping of the composed morphisms using the operation of shifting functor `CategoryTheory.shiftFunctor` in the opposite category `Cᵒᵖ` is equal to the composition of the inverse of the natural transformation of the equivalence functor (`CategoryTheory.Pretriangulated.opShiftFunctorEquivalence`) and the morphism `f`. This property holds for all objects `X` and `Y` in the opposite category `Cᵒᵖ` and all morphisms `f` from `X` to `Y`. The statement captures a naturality condition under the shift functor in the context of pretriangulated categories.

For any pretriangulated category `C` with shift functor, and for all objects `X` and `Y` and morphism `f` in `Cᵒᵖ`, the shift of their composition `(CategoryTheory.shiftFunctor C (-n)).(CategoryTheory.opLim (CategoryTheory.opShiftFunctorEquivalence C).inv ∘ f)` is equal to the composition of `f` and the shift of the identity `(CategoryTheory.shiftFunctor C (-n)) (idY)`.


/-- The closed thickening of the empty set is empty.  -/
theorem Metric.cthickening_empty : ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ), Metric.cthickening δ ∅ = ∅ :=
  by sorry

The theorem `Metric.cthickening_empty` states that in any pseudo emetric space, the closed δ-thickening of an empty set is also an empty set, regardless of the value of δ. In other words, there are no points within a δ distance from an empty set.

In any pseudo metric space, the closed δ-thickening of the empty set is empty for all δ ≥ 0.


theorem ManyOneEquiv.le_congr_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}, ManyOneEquiv p q → (p ≤₀ r ↔ q ≤₀ r) :=
  by sorry

The theorem `ManyOneEquiv.le_congr_left` states that for any three types `α`, `β`, and `γ` that can be encoded as primitive recursive functions (i.e., they have `Primcodable` instance), and any properties `p` over `α`, `q` over `β`, and `r` over `γ`, if `p` and `q` are many-one equivalent (meaning each one of them can be many-one reduced to the other), then `p` is many-one reducible to `r` if and only if `q` is many-one reducible to `r`. In essence, if two properties are many-one equivalent, then any many-one reduction to another property can be substituted between them.

If properties `p` over `α` and `q` over `β` are many-one equivalent, then they have the same many-one reducibility to property `r` over `γ`.


theorem Mathlib.Order.MinMax._auxLemma.10 : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (min a b = b) = (b ≤ a) :=
  by sorry

This theorem, `Mathlib.Order.MinMax._auxLemma.10`, states that for any type `α` which has a linear order, and any two members `a` and `b` of that type, the minimum of `a` and `b` equals `b` if and only if `b` is less than or equal to `a`. In other words, `b` is the minimum of `a` and `b` when it is not greater than `a`.

For any type with a linear order, the minimum of two elements is the smaller one. (Equivalently, element `b` is the minimum of `a` and `b` if and only if `b` is less than or equal to `a`. )


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.5 :
    ∀ {α : Type u} {s t : Set α}, (s = t) = ∀ (x : α), x ∈ s ↔ x ∈ t := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any type `α`, and any two sets `s` and `t` of this type, the statement that `s` is equal to `t` is equivalent to the assertion that for every element `x` of type `α`, `x` is in `s` if and only if `x` is in `t`. In other words, two sets are equal if they contain exactly the same elements.

For any type `α` and sets `s` and `t` of type `α`, `s = t` if and only if for all `x` in `α`, `x ∈ s` if and only if `x ∈ t`.


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.3 :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {x : β},
      x ∈ e.target → (↑(PartialEquiv.symm e) x ∈ e.source) = True :=
  by sorry

The theorem `Mathlib.Logic.Equiv.PartialEquiv._auxLemma.3` states that for any types `α` and `β`, and for any partial equivalence `e` between `α` and `β`, if an element `x` of type `β` is in the target of `e`, then the inverse of `e` (denoted `PartialEquiv.symm e`) applied to `x` is in the source of `e`. In other words, if `x` is in the range of the partial equivalence, then its preimage under the inverse equivalence is in the domain of the original partial equivalence.

For any partial equivalence `e` between types `α` and `β`, if `x ∈ β` is in the image of `e`, then `PartialEquiv.symm e x ∈ α` is in the domain of `e`.


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.8 : ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the equivalence of `a ∧ b` and `a ∧ c` is the same as saying that if `a` is true, then `b` is equivalent to `c`. In other words, if the conjunction of `a` and `b` is equivalent to the conjunction of `a` and `c`, then `b` is equivalent to `c` assuming `a` is true.

The theorem asserts that `(a ∧ b) ↔ (a ∧ c)` is equivalent to `(a → (b ↔ c))`.


/-- The other direction does not hold because of the `u`-`u` cross terms on the RHS.  -/
theorem Finset.image₂_distrib_subset_right :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {δ : Type u_7} {ε : Type u_9}
      [inst : DecidableEq α'] [inst_1 : DecidableEq β'] [inst_2 : DecidableEq δ] [inst_3 : DecidableEq ε] {s : Finset α}
      {t : Finset β} {γ : Type u_14} {u : Finset γ} {f : δ → γ → ε} {g : α → β → δ} {f₁ : α → γ → α'} {f₂ : β → γ → β'}
      {g' : α' → β' → ε},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f₁ a c) (f₂ b c)) →
        Finset.image₂ f (Finset.image₂ g s t) u ⊆ Finset.image₂ g' (Finset.image₂ f₁ s u) (Finset.image₂ f₂ t u) :=
  by sorry

The theorem `Finset.image₂_distrib_subset_right` states that for any types `α`, `α'`, `β`, `β'`, `δ`, `ε`, and `γ` and any finite sets `s` of `α`, `t` of `β`, and `u` of `γ`, along with functions `f` from `δ` to `γ` to `ε`, `g` from `α` to `β` to `δ`, `f₁` from `α` to `γ` to `α'`, `f₂` from `β` to `γ` to `β'`, and `g'` from `α'` to `β'` to `ε`, if for all `a` from `α`, `b` from `β`, and `c` from `γ`, the function application `f(g(a,b),c)` equals `g'(f₁(a,c),f₂(b,c))`, then the image of the binary function `f` on the image of `g` over `s` and `t` then `u` is a subset of the image of `g'` over the image of `f₁` over `s` and `u` then the image of `f₂` over `t` and `u`.

If `f(g(s,t)) ⊆ g'(f₁(s) ∘ f₂(t)),` where `s` is a finite set of `α, t` is a finite set of `β, u` is a finite set of `γ, f` is a function from `δ` to `γ` to `ε, g` is a function from `α` to `β` to `δ, f₁` is a function from `α` to `γ` to `α', f₂` is a function from `β` to `γ` to `β',` and `g'` is a function from `α'` to `β'` to `ε,` then the image of `f` over `g(s,t)` is a subset of the image of `g'` over `f₁(s) ∘ f₂(t)`.


theorem Multiset.le_sum_of_mem :
    ∀ {α : Type u_2} [inst : CanonicallyOrderedAddCommMonoid α] {s : Multiset α} {a : α}, a ∈ s → a ≤ Multiset.sum s :=
  by sorry

This theorem states that for any type `α` which has a `CanonicallyOrderedAddCommMonoid` structure, and for any multiset `s` of type `α` and any element `a` of type `α`, if `a` is an element of `s`, then `a` is less than or equal to the sum of all the elements of `s`. This is true because in a `CanonicallyOrderedAddCommMonoid`, the sum operation is commutative, associative and has an identity element, and the order is compatible with the addition operation, i.e., if `b ≤ c` then `a + b ≤ a + c`.

For any `CanonicallyOrderedAddCommMonoid` type `α` and multiset `s` of `α`, if `a` is in `s`, then `a ≤ sum s`.


theorem inf_compl_self : ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), a ⊓ aᶜ = ⊥ := by sorry

This theorem states that for any type `α` that forms a Heyting algebra, the infimum (or greatest lower bound) of any element `a` and its complement `aᶜ` is the bottom element (`⊥`). In simple terms, the intersection of any element and its complement in a Heyting algebra is always the smallest element in the algebra.

In a Heyting algebra, the infimum of any element and its complement is the bottom element.


theorem monotone_toDual_comp_iff :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone (⇑OrderDual.toDual ∘ f) ↔ Antitone f :=
  by sorry

This theorem states that for any two types `α` and `β` with preorder relations, and any function `f` from `α` to `β`, the function `f` is monotonic (meaning, if `a` is less than or equal to `b`, then `f(a)` is less than or equal to `f(b)`) under the dual order if and only if `f` is antitone (meaning, if `a` is less than or equal to `b`, then `f(b)` is less than or equal to `f(a)`) under the original order. In other words, applying the dual order to a monotonic function makes it an antitone function, and vice versa.

For any function between two types with preorder relations, it is monotonic under the dual order if and only if it is antitone under the original order.


theorem Turing.BlankExtends.below_of_le :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] {l l₁ l₂ : List Γ},
      Turing.BlankExtends l l₁ →
        Turing.BlankExtends l l₂ → List.length l₁ ≤ List.length l₂ → Turing.BlankExtends l₁ l₂ :=
  by sorry

This theorem is saying that for any type `Γ`, given three lists `l`, `l₁`, and `l₂` of type `Γ`, if the partial order `Turing.BlankExtends` holds between `l` and `l₁` and also between `l` and `l₂`, and the length of `l₁` is less than or equal to the length of `l₂`, then `Turing.BlankExtends` also holds between `l₁` and `l₂`.

In other words, if `l₁` and `l₂` are extensions of the same list `l` where they extend `l` by adding blanks at the end and the length of `l₁` is less than or equal to the length of `l₂`, then `l₂` can be viewed as an extension of `l₁` by adding blanks at the end.

If `l`, `l₁`, and `l₂` are lists of the same type `Γ` such that `Turing.BlankExtends l l₁` and `Turing.BlankExtends l l₂`, and the length of `l₁` is less than or equal to the length of `l₂`, then `Turing.BlankExtends l₁ l₂`.


theorem integral_ofReal :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {𝕜 : Type u_5} [inst_1 : RCLike 𝕜]
      {f : X → ℝ}, ∫ (x : X), ↑(f x) ∂μ = ↑(∫ (x : X), f x ∂μ) :=
  by sorry

The theorem `integral_ofReal` states that for any measurable space `X` with measure `μ`, and any real-valued function `f` on `X`, the integral of the complex extension of `f` (denoted by `↑(f x)`) with respect to `μ` is the same as the complex extension of the integral of `f` with respect to `μ`. In other words, taking the integral and extending to complex numbers commute with each other.

For any measurable space (X, μ) and measurable real-valued function f on X, the complex integrals ∫(↑(fx) dμ) = ↑(∫(fx) dμ).


theorem MeasureTheory.setAverage_eq :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      (μ : MeasureTheory.Measure α) (f : α → E) (s : Set α),
      ⨍ (x : α) in s, f x ∂μ = (↑↑μ s).toReal⁻¹ • ∫ (x : α) in s, f x ∂μ :=
  by sorry

This theorem, named `MeasureTheory.setAverage_eq`, states that for any type `α`, any normed add commutative group `E` that is also a normed space over the real numbers, a measurable space `m0` on `α`, a measure `μ` on that measurable space, a function `f` from `α` to `E`, and a set `s` of type `α`, the integral of `f` over the set `s` with respect to the measure `μ` is equal to the inverse of the real part of the measure of `s` times the integral of `f` over the set `s` with respect to the measure `μ`. This theorem essentially gives a formula for calculating the average value of a function `f` over a set `s` with respect to a measure `μ` in a measure space.

For any measurable space `(α, m0)`, measure `μ`, normed space `(E, ||·||)` over the real numbers, measurable function `f : α → E`, and set `s ⊆ α` with finite measure, the average value of `f` over `s` with respect to `μ` is equal to the inverse of the measure of `s` times the integral of `f` over `s` with respect to `μ`.


Nat.mod.inductionOn

theorem Nat.mod.inductionOn {motive : ℕ → ℕ → Sort u} (x y : ℕ) :
    ((x y : ℕ) → 0 < y ∧ y ≤ x → motive (x - y) y → motive x y) →
      ((x y : ℕ) → ¬(0 < y ∧ y ≤ x) → motive x y) → motive x y :=
  by sorry

This theorem is a principle of induction tailored for use with the modulus operation in the natural numbers. It states that for any two natural numbers `x` and `y`, and a property `motive` of pairs of natural numbers, if the `motive` holds for `(x - y, y)` whenever `y` is positive and less than or equal to `x`, and the `motive` also holds for `(x, y)` when `y` is not positive or greater than `x`, then the `motive` holds for `(x, y)`. This allows one to prove properties about the modulus operation by considering the cases where the divisor is less than or equal to, and greater than, the dividend.

The theorem asserts that if a property `motive` holds for the pair `(x-y, y)` when `y` ranges from 1 to `x`, and also holds for `(x, y)` when `y` is not positive or greater than `x`, then the property `motive` holds for `(x, y)` for all natural numbers `x` and `y`.


theorem HasCompactSupport.tsupport_extend_zero_subset :
    ∀ {α : Type u_2} {α' : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace α']
      [inst_2 : Zero β] {f : α → β} [inst_3 : T2Space α'],
      HasCompactSupport f → ∀ {g : α → α'}, Continuous g → tsupport (Function.extend g f 0) ⊆ g '' tsupport f :=
  by sorry

This theorem states that for any two types `α` and `α'` and any type `β` with a zero element, if we have a function `f` from `α` to `β` that has compact support and another function `g` from `α` to `α'` that is continuous, then the topological support of the function resulting from extending `f` by `g` (i.e., replacing values of `f` outside its domain with zeros) is a subset of the image under `g` of the topological support of `f`. This theorem assumes that the topological spaces `α` and `α'` satisfy the T2 separation axiom, also known as the Hausdorff condition.

Given functions `f` from type `α` to `β` with compact support, `g` from `α` to `α'`, and assuming `α`, `α'` are T2 spaces, the topological support of the extended function `f ↦ 0 on α \ dom(f) ∪ {g(x) : x ∈ α}` is a subset of `g''(supp(f))`, where `g''` is the continuous function from `α'` to `β` extending `f` by zero.


theorem MeasureTheory.diff_ae_eq_self :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
      s \ t =ᶠ[MeasureTheory.Measure.ae μ] s ↔ ↑↑μ (s ∩ t) = 0 :=
  by sorry

This theorem is about measure theory in the context of sets and measurable spaces. It states that for any type `α`, with a measurable space instance, a measure `μ`, and two sets `s` and `t` of type `α`, the set difference `s \ t` is almost everywhere equal to set `s` with respect to the measure `μ` if and only if the measure of the intersection of `s` and `t` is zero. In other words, if the intersection of `s` and `t` contributes nothing to the measure of `s`, then `s` minus `t` is the same as `s` almost everywhere with respect to the measure `μ`.

For any measurable sets `s` and `t` of type `α` in a measurable space with measure `μ`, `s \ t` is almost everywhere equal to `s` if and only if the measure of `s ∩ t` is zero.


theorem Mathlib.Data.Multiset.Fintype._auxLemma.13 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {m₁ m₂ : Multiset α},
      (Multiset.toEnumFinset m₁ ⊆ Multiset.toEnumFinset m₂) = (m₁ ≤ m₂) :=
  by sorry

The theorem `Mathlib.Data.Multiset.Fintype._auxLemma.13` states that for any two multisets `m₁` and `m₂` of a type `α` (where `α` is a type with decidable equality), the property that the `Finset` obtained by enumerating the elements of `m₁` (using `Multiset.toEnumFinset`) is a subset of the `Finset` obtained from `m₂` is equivalent to the property that `m₁` is a submultiset of `m₂`. In other words, `m₁` is a submultiset of `m₂` if and only if every element of `m₁`, each associated with its count in the multiset, appears in `m₂` with a count equal to or higher.

For multisets `m₁` and `m₂` over a type `α` with decidable equality, `m₁` is a submultiset of `m₂` if and only if the finite set obtained from `m₁` equals the subset of the finite set obtained from `m₂` that includes each element of `m₁` with its corresponding multiplicity.


theorem VitaliFamily.tendsto_filterAt_iff :
    ∀ {α : Type u_1} [inst : MetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (v : VitaliFamily μ)
      {ι : Type u_2} {l : Filter ι} {f : ι → Set α} {x : α},
      Filter.Tendsto f l (VitaliFamily.filterAt v x) ↔
        (∀ᶠ (i : ι) in l, f i ∈ v.setsAt x) ∧ ∀ ε > 0, ∀ᶠ (i : ι) in l, f i ⊆ Metric.closedBall x ε :=
  by sorry

This theorem states that for any type `α` equipped with a metric space structure and a measurable space structure, any measure `μ` on `α`, any Vitali family `v` defined on `μ`, any type `ι` equipped with a filter structure `l`, any function `f` from `ι` to `Set α`, and any point `x` in `α`, the function `f` tends to the filter at `x` in the Vitali family `v` if and only if the following two conditions hold:
1) For almost every `i` in `l`, `f(i)` belongs to the sets at `x` in `v`,
2) For any positive real number `ε`, for almost every `i` in `l`, `f(i)` is contained in the closed ball with radius `ε` around `x`.
Here, "almost every" refers to the filter version of "almost everywhere", meaning that the condition holds outside a set of measures zero, and the "closed ball" refers to the set of all points whose distance to `x` is less than or equal to `ε`.

A function from a filter to a metric space tends to a point in a Vitali family with respect to a measure if and only if it lies in the sets at that point for almost every filter element and is contained in the closed ball around that point for almost every filter element with positive radius.


theorem beq_iff_eq : ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a b : α), (a == b) = true ↔ a = b := by
  sorry

The theorem `beq_iff_eq` states that for any type `α` that has a `BEq` instance and respects the laws of `BEq`, the boolean equality of two elements `a` and `b` of type `α` (`a == b`) being true is equivalent to `a` and `b` being actually equal (`a = b`). This means that the boolean equality test `==` is accurate if it returns `true`, and `a` and `b` can be deemed equal in the mathematical sense.

For any type `α` with a `BEq` instance satisfying the laws of `BEq`, `a == b` if and only if `a = b`.


theorem Mathlib.Data.Matrix.Basic._auxLemma.1 :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] {d₁ d₂ : n → α},
      (Matrix.diagonal d₁ = Matrix.diagonal d₂) = ∀ (i : n), d₁ i = d₂ i :=
  by sorry

This theorem states that for any type `n`, and any type `α` with a zero element and a decidable equality operation, and for any two functions `d₁` and `d₂` from `n` to `α`, the equality `Matrix.diagonal d₁ = Matrix.diagonal d₂` holds if and only if, for all `i` in `n`, `d₁ i = d₂ i`. In other words, two diagonal matrices are equal if and only if their corresponding diagonal elements are equal for all indices.

For any type `n`, and for diagonal matrices `M₁` and `M₂` of type `Matrix α n` over a type `α` with a zero element and decidable equality, `M₁ = M₂` if and only if `∀ i, M₁ i = M₂ i`.


theorem IsLocallyConstant.isClopen_fiber :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
      IsLocallyConstant f → ∀ (y : Y), IsClopen {x | f x = y} :=
  by sorry

The theorem `IsLocallyConstant.isClopen_fiber` states that for any topological spaces `X` and `Y`, and any function `f` from `X` to `Y`, if `f` is locally constant (meaning the preimage of any set is an open set), then for any element `y` from `Y`, the set of all elements `x` from `X` such that `f(x) = y` is a clopen set (meaning it is both closed and open). In mathematical terms, this is stating that the inverse image of a point under a locally constant function is always a clopen set.

If `f: X → Y` is a locally constant function between topological spaces, then for each `y ∈ Y`, the preimage `f⁁⁻¹{y} ⊆ X` is a clopen set.


theorem List.rotate'_rotate' :
    ∀ {α : Type u} (l : List α) (n m : ℕ), List.rotate' (List.rotate' l n) m = List.rotate' l (n + m) := by sorry

This theorem states that for any list `l` of elements of an arbitrary type `α`, and any natural numbers `n` and `m`, rotating the list `l` by `n` places using `List.rotate'` function and then rotating the result by `m` places is equivalent to rotating the list `l` by `n + m` places in a single step. This property mirrors typical rotation behavior, where consecutive rotations can be summed up into a single rotation operation.

For any list `l` of type `α` and natural numbers `n` and `m`, `List.rotate' l n >> List.rotate' _ m = List.rotate' l (n + m)`.


theorem Set.indicator_empty :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (f : α → M), Set.indicator ∅ f = fun x => 0 := by sorry

The theorem `Set.indicator_empty` states that for any function `f` mapping elements from an arbitrary type `α` to another type `M` that has a zero element, the set indicator of the empty set and `f` is equivalent to a function that always yields zero. In other words, applying the function `f` over an empty set via a set indicator always results in a zero. This makes sense, since the set indicator is defined to return the result of the function `f` applied to an element if that element is in the set, and zero otherwise. Since the empty set contains no elements, the function `f` can never be applied, and so zero is always returned.

For any function `f` from type `α` to a type `M` with a zero element, the set indicator of the empty set and `f` equals the constant function that maps to the zero element of `M`.


theorem Subgroup.Normal.eq_bot_or_eq_top :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : IsSimpleGroup G] {H : Subgroup G}, Subgroup.Normal H → H = ⊥ ∨ H = ⊤ :=
  by sorry

This theorem states that for any group `G` that is a simple group, any `H` which is a normal subgroup of `G` must be either the trivial group (denoted by `⊥`) or the entire group `G` itself (denoted by `⊤`). This is a special property of simple groups which have no non-trivial normal subgroups.

In a simple group, every normal subgroup is either the trivial group or the entire group.


theorem Polynomial.quotientSpanXSubCAlgEquivAux2.proof_2 :
    ∀ {R : Type u_1} [inst : CommRing R] (x x_1 : R), Polynomial.eval x (Polynomial.C x_1) = x_1 := by sorry

This theorem states that for any commutative ring `R` and any elements `x` and `x_1` from `R`, the evaluation of the constant polynomial `x_1` at `x` is equal to `x_1`. In mathematical language, if we have a constant polynomial `P(x) = x_1` then `P(x) = x_1` for all `x` in our commutative ring `R`.

For any commutative ring `R` and elements `x, x_1` in `R`, the constant polynomial `x_1` evaluates to `x_1` at `x`.


theorem Filter.eventually_smallSets_eventually :
    ∀ {α : Type u_1} {l l' : Filter α} {p : α → Prop},
      (∀ᶠ (s : Set α) in Filter.smallSets l, ∀ᶠ (x : α) in l', x ∈ s → p x) ↔ ∀ᶠ (x : α) in l ⊓ l', p x :=
  by sorry

The theorem `Filter.eventually_smallSets_eventually` states that for any two filters `l` and `l'` over some type `α`, and a property `p` of type `α → Prop`, the condition that all sets `s` eventually in the filter of small sets of `l` have the property that all elements `x` eventually in `l'` and belonging to `s` satisfy `p`, is equivalent to the condition that all elements `x` eventually in the infimum of filters `l` and `l'` satisfy `p`. In other words, it relates the eventual satisfaction of a property in a filter and its small sets filter.

For filters `l` and `l'` over type `α` and property `p`, the filter `l` has only eventually small sets with property `p` if and only if the infimum of `l` and `l'` has all its elements eventually satisfying `p`.


theorem nhds_le_nhdsSet :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {x : X}, x ∈ s → nhds x ≤ nhdsSet s := by sorry

The theorem `nhds_le_nhdsSet` states that for any type `X` equipped with a topological space structure, any set `s` of type `X`, and any element `x` of type `X`, if `x` belongs to `s`, then the neighborhood filter of `x` (`nhds x`) is less than or equal to the filter of neighborhoods of `s` (`nhdsSet s`). This essentially means that every neighborhood of `x` is also a neighborhood of the set `s`, when `x` is an element of `s`.

For any topological space (X,τ), set s ∈ X, and x ∈ s, the neighborhood filter of x (nhds x) is contained in the neighborhood filter of s (nhdsSet s).


theorem Valuation.isEquiv_iff_val_eq_one :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} {Γ'₀ : Type u_5}
      [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [inst_2 : LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀)
      (v' : Valuation K Γ'₀), Valuation.IsEquiv v v' ↔ ∀ {x : K}, v x = 1 ↔ v' x = 1 :=
  by sorry

The theorem `Valuation.isEquiv_iff_val_eq_one` states that for all division rings `K` and for all linearly ordered commutative groups with zero `Γ₀` and `Γ'₀`, a valuation `v` from `K` to `Γ₀` and a valuation `v'` from `K` to `Γ'₀` are equivalent (i.e., they induce the same preorder on `K`) if and only if for all elements `x` in `K`, the valuation `v` of `x` equals 1 if and only if the valuation `v'` of `x` also equals 1.

Two valuations from a division ring to linearly ordered commutative groups with zero are equivalent if and only if they assign value 1 to the same elements.


IsOpen.ite

theorem IsOpen.ite :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s s' t : Set α},
      IsOpen s → IsOpen s' → s ∩ frontier t = s' ∩ frontier t → IsOpen (Set.ite t s s') :=
  by sorry

The theorem `IsOpen.ite` states that for any type `α` equipped with a topology, and for any sets `s`, `s'`, and `t` of type `α`, if `s` and `s'` are open sets and the intersection of `s` with the frontier of `t` is equal to the intersection of `s'` with the frontier of `t`, then the set resulting from the `Set.ite` function applied to `t`, `s`, and `s'` is an open set. In other words, it states the openness of the set formed by taking the elements of `s` that are in `t` and the elements of `s'` that are not in `t`, given certain conditions on `s`, `s'`, and `t`.

If sets `s`, `s'`, and `t` in a topological space are open and their frontier intersections with `t` are equal, then the set obtained by applying `Set.ite` function to `t`, `s`, and `s'` is open.


theorem WithTop.coe_mul :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] (a b : α), ↑(a * b) = ↑a * ↑b := by sorry

The theorem `WithTop.coe_mul` states that for any type `α`, given that `α` has decidable equality property (`DecidableEq α`) and zero multiplication class property (`MulZeroClass α`), for all elements `a` and `b` of type `α`, the operation of multiplication of `a` and `b` then coercing the result to "WithTop α" is equivalent to the operation of coercing `a` and `b` to "WithTop α" first and then multiplying them. In other words, the order of multiplication and coercion operation doesn't affect the final result. This theorem is about the preservation of multiplication operation under the coercion to "WithTop α".

For any type `α` with decidable equality and zero multiplication, the operation of coercing `α` elements to "WithTop α" and then multiplying is equivalent to multiplying and then coercing to "WithTop α".


theorem frontier_prod_eq :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (s : Set X) (t : Set Y),
      frontier (s ×ˢ t) = closure s ×ˢ frontier t ∪ frontier s ×ˢ closure t :=
  by sorry

The theorem `frontier_prod_eq` states that for any two types `X` and `Y` equipped with topological structures, and any sets `s` of type `X` and `t` of type `Y`, the frontier (the set of points between the closure and interior) of the cartesian product of `s` and `t` is equal to the union of two sets: the cartesian product of the closure of `s` and the frontier of `t`, and the cartesian product of the frontier of `s` and the closure of `t`. In mathematical terms, this can be written as `Fr(s × t) = Cl(s) × Fr(t) ∪ Fr(s) × Cl(t)` where `Fr`, `Cl`, `×`, and `∪` represent the frontier, closure, cartesian product, and union operations respectively.

The frontier of a cartesian product of sets equals the union of the product of the closure of each set and the frontier of the other, and the product of the frontiers and closures of each set.


theorem AddMonoid.Coprod.fst_sum_snd :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N],
      AddMonoidHom.prod AddMonoid.Coprod.fst AddMonoid.Coprod.snd = AddMonoid.Coprod.toSum :=
  by sorry

This theorem states that for any two types `M` and `N` that have an `AddMonoid` structure (i.e., they are additive monoids), the add monoid homomorphism produced by combining the natural projection from the coproduct of `M` and `N` to `M` (`AddMonoid.Coprod.fst`) and to `N` (`AddMonoid.Coprod.snd`) using `AddMonoidHom.prod` is the same as the natural projection from the coproduct of `M` and `N` to the pair `(M, N)` (`AddMonoid.Coprod.toSum`). In other words, projecting to `M` and `N` separately and then pairing is the same as directly projecting to the pair `(M, N)`.

The add monoid homomorphism from the coproduct of two additive monoids `M` and `N` obtained by projecting to each summand using `AddMonoid.Coprod.fst` and `AddMonoid.Coprod.snd`, and then pairing using `AddMonoidHom.prod`, is equal to the natural projection to the pair `(M, N)` using `AddMonoid.Coprod.toSum`.


Cauchy.comap'

theorem Cauchy.comap' :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : UniformSpace β] {f : Filter β} {m : α → β},
      Cauchy f →
        Filter.comap (fun p => (m p.1, m p.2)) (uniformity β) ≤ uniformity α →
          Filter.NeBot (Filter.comap m f) → Cauchy (Filter.comap m f) :=
  by sorry

The theorem `Cauchy.comap'` states that for any two types `α` and `β` equipped with uniform space structures, a filter `f` on `β`, and a function `m` from `α` to `β`, if `f` is a Cauchy filter, the filter obtained by comapping the function that takes a pair `p` and returns a pair with the images of the components of `p` under `m` through the uniformity of `β` is less than or equal to the uniformity of `α`, and the filter obtained by comapping `m` through `f` is not bottom, then this last filter is a Cauchy filter.

In other words, this theorem provides a condition under which the image of a Cauchy filter under a mapping is still a Cauchy filter. This is important in studying the continuity and convergence properties of functions between uniform spaces.

Given uniform spaces (α, δα) and (β, δβ), a Cauchy filter f on β, and a continuous function m : α → β, if f is a Cauchy filter and the image filter of f under m through δβ is not bottom and is less than or equal to δα, then the image filter of m under f through δα is also a Cauchy filter.


theorem LinearMap.disjoint_ker :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F}
      {p : Submodule R M}, Disjoint p (LinearMap.ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0 :=
  by sorry

The theorem `LinearMap.disjoint_ker` states that for any semiring `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, and a semilinear map `τ₁₂` from `R` to `R₂`. Also, given `F` is a type such that there is a function-like mapping from `M` to `M₂`, and `f` behaves as a semilinear map under `F` and `τ₁₂`, and `p` is a submodule of `R` and `M`. Then, `p` is disjoint from the kernel of `f` if and only if for every `x` in `p`, if `f(x)` equals zero then `x` must also be zero.

In more plain terms, the kernel of a linear map (the set of elements that map to zero) is disjoint from a submodule `p` precisely when every element of that submodule which maps to zero is itself zero. This is a property about the interaction between submodules and the kernels of linear maps.

A submodule `p` of a module over a semiring is disjoint from the kernel of a semilinear map if and only if every element of `p` mapping to zero under the map is itself zero.


theorem Computation.of_results_think :
    ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ},
      Computation.Results (Computation.think s) a n → ∃ m, Computation.Results s a m ∧ n = m + 1 :=
  by sorry

The theorem `Computation.of_results_think` states that for any type `α`, any computation `s` of type `α`, any element `a` of type `α`, and any natural number `n`, if `s` returns `a` after exactly `n` steps when it is delayed for one "tick" (`Computation.Results (Computation.think s) a n`), then there exists a natural number `m` such that `s` returns `a` after exactly `m` steps without delay (`Computation.Results s a m`) and `n` is equal to `m + 1`. In other words, adding a delay "tick" to a computation increases the number of steps required to reach a result by exactly one.

For any computation `s` and natural numbers `n` and `m`, if `s` returns `a` after `n` delayed steps and `m` non-delayed steps, then `n = m + 1`.


theorem Complex.cos_sub_pi_div_two : ∀ (x : ℂ), Complex.cos (x - ↑Real.pi / 2) = Complex.sin x := by sorry

The theorem `Complex.cos_sub_pi_div_two` states that for any complex number `x`, the cosine of (`x - π/2`) is equal to the sine of `x`. Here, `π` represents the mathematical constant Pi, `-` denotes subtraction, and `↑Real.pi / 2` is the Lean 4 way of expressing "pi divided by 2". The functions `Complex.cos` and `Complex.sin` are the complex versions of the cosine and sine functions, with both functions defined via the exponential function (`exp`). The theorem essentially establishes a shift property between the complex sine and cosine functions.

The theorem asserts that for any complex number x, the cosine of (x - π/2) equals the sine of x.


theorem AddSubmonoid.map_le_iff_le_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid M} {T : AddSubmonoid N},
      AddSubmonoid.map f S ≤ T ↔ S ≤ AddSubmonoid.comap f T :=
  by sorry

This theorem establishes a key property regarding the relationship between `map` and `comap` operations on `AddSubmonoid`s under add monoid homomorphisms. Specifically, for any types `M` and `N` that are additive monoids, any function `f` from `M` to `N` that is an additive monoid homomorphism, and any `AddSubmonoid`s `S` of `M` and `T` of `N`, the image of `S` under `f` is a submonoid of `T` if and only if `S` is a submonoid of the preimage of `T` under `f`. This means that the mapping of `S` to `N` through `f` is contained in `T` exactly when `S` is contained in the set of elements in `M` that map to `T` via `f`.

For any additive monoid homomorphisms f between additive monoids M and N, and any AddSubmonoids S of M and T of N, the image of S under f is a submonoid of T if and only if S is a submonoid of the preimage of T under f.


theorem LieSubalgebra.coe_toLieSubmodule :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      (K : LieSubalgebra R L), ↑(LieSubalgebra.toLieSubmodule K) = K.toSubmodule :=
  by sorry

The theorem `LieSubalgebra.coe_toLieSubmodule` states that for any commutative ring `R` and any Lie algebra `L` over `R`, if `K` is a Lie subalgebra of `L`, then the coercion of the Lie submodule associated with `K` (obtained by viewing `L` as a `K`-module by restriction) is equal to the submodule of `L` associated with `K`. In other words, the Lie submodule of `L` that `K` naturally induces is precisely the submodule of `L` that `K` spans.

For any commutative ring R and Lie algebra L over R, the coercion of a Lie subalgebra K's associated Lie submodule in L is equal to the submodule of L spanned by K.


theorem ENNReal.eq_sub_of_add_eq : ∀ {a b c : ENNReal}, c ≠ ⊤ → a + c = b → a = b - c := by sorry

This theorem states that for every three extended nonnegative real numbers `a`, `b`, and `c`, where `c` is not positive infinity (`⊤`), if `a` added to `c` equals `b`, then `a` is equal to `b` subtracted by `c`. In other words, if `a + c = b`, then `a = b - c`. This theorem constitutes a fundamental property of addition and subtraction in the space of extended nonnegative real numbers.

For all extended nonnegative real numbers `a`, `b`, and `c` (`c ≠ ⊤`), if `a + c = b`, then `a = b - c`.


theorem WithBot.strictMono_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : WithBot α → β},
      StrictMono f ↔ (StrictMono fun a => f ↑a) ∧ ∀ (x : α), f ⊥ < f ↑x :=
  by sorry

The theorem `WithBot.strictMono_iff` states that for any two types `α` and `β` that have a preorder relation, a function `f` from `WithBot α` to `β` is strictly monotone if and only if the following two conditions hold: (1) the function `f` applied to any `a` in the domain, where `a` is lifted into `WithBot α`, is strictly monotone, and (2) for any `x` in `α`, the value of `f` at `⊥` (the bottom element in `WithBot α`) is less than the value of `f` at the lifted `x`. Essentially, strict monotonicity of `f` in the extended domain `WithBot α` is characterized by its strict monotonicity in the original domain `α` and its behavior at `⊥`.

A function from types equipped with bottom elements to another type is strictly monotone if and only if its restriction to the original types is strictly monotone and it maps the bottom element to a value less than any other image under the function.


theorem Lagrange.basisDivisor_self : ∀ {F : Type u_1} [inst : Field F] {x : F}, Lagrange.basisDivisor x x = 0 := by
  sorry

This theorem, called `Lagrange.basisDivisor_self`, states that for any field `F` and any element `x` in that field, the polynomial `Lagrange.basisDivisor x x` equals the zero polynomial. In other words, if you use the same value for both `x` and `y` in the definition of the `Lagrange.basisDivisor`, the resulting polynomial is identically zero. This is a special case of the general behavior of the `Lagrange.basisDivisor`, which is designed to equal `1` when evaluated at `x` and `0` when evaluated at `y`—clearly, if `x` and `y` are the same, it must equal `0`.

For any field `F` and element `x` in `F`, the polynomial `Lagrange.basisDivisor x x` equals the zero polynomial.


AddLECancellable.Injective

theorem AddLECancellable.Injective :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] {a : α},
      AddLECancellable a → Function.Injective fun x => a + x :=
  by sorry

The theorem `AddLECancellable.Injective` states that for any type `α` that supports addition operation and partial order, given any element `a` of type `α`, if `a` is left addition-cancellable (meaning that for all elements `b` and `c` of type `α`, `a + b ≤ a + c` implies `b ≤ c`), then the function that adds `a` to its argument is injective. An injective function is one where different inputs yield different outputs, i.e., if `f(x) = f(y)`, then `x = y`. In simpler terms, if adding `a` doesn't change the order of elements, then adding `a` to different elements will give different results.

If `α` is a type with additions and a partial order such that every left additive cancellative element `a` implies the function `x => a + x` is injective.


theorem Filter.comap_sup :
    ∀ {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β},
      Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂ :=
  by sorry

This theorem states that for any two filters `g₁` and `g₂` on a type `β` and any function `m` from a type `α` to `β`, the filter derived by mapping the sup (greatest lower bound) of `g₁` and `g₂` back to `α` through `m` is the same as the sup of the filters derived by mapping `g₁` and `g₂` separately back to `α`. In other words, the operation of "pulling back" a filter through a function commutes with taking the sup of two filters. This is a fundamental property in the theory of filters in mathematics.

For filters $g\_1$ and $g\_2$ on type $\beta$, and a function $m:\alpha \to \beta$, the pullback of the supremum of $g\_1$ and $g\_2$ through $m$ equals the supremum of the pullbacks of $g\_1$ and $g\_2$ through $m$.


theorem Function.mulSupport_one_sub :
    ∀ {α : Type u_1} {R : Type u_8} [inst : One R] [inst_1 : AddGroup R] (f : α → R),
      (Function.mulSupport fun x => 1 - f x) = Function.support f :=
  by sorry

The theorem `Function.mulSupport_one_sub` states that for any function `f` whose domain is of type `α` and codomain is of an additive group `R` that also has a unit element, the multiplicative support of the function `g(x) = 1 - f(x)` is equal to the support of `f`. Here, the multiplicative support of a function is the set of all points in the domain where the function does not output the multiplicative identity (which is `1` in this context), and the support of a function is the set of all points in the domain where the function does not output the additive identity (`0` in this context). Thus, this theorem establishes a relationship between these two different "nonzeroness-tracking" measures applied to related functions.

For a function from type `α` to an additive group with unit element, the multiplicative support equals the negation of the support of the function mapping `x` to `1 - f(x)`.


theorem Finset.union_subset_right : ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, s ∪ t ⊆ u → t ⊆ u := by
  sorry

The theorem `Finset.union_subset_right` asserts that for any type `α` with decidable equality, and for any three finite sets (`Finset`) `s`, `t`, and `u` of type `α`, if the union of `s` and `t` is a subset of `u`, then `t` is a subset of `u`.

If `s` and `t` are finite sets and `s ∪ t` is a subset of `u`, then `t` is a subset of `u`.


theorem IsUnifLocDoublingMeasure.tendsto_closedBall_filterAt :
    ∀ {α : Type u_1} [inst : MetricSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α)
      [inst_2 : IsUnifLocDoublingMeasure μ] [inst_3 : SecondCountableTopology α] [inst_4 : BorelSpace α]
      [inst_5 : MeasureTheory.IsLocallyFiniteMeasure μ] {K : ℝ} {x : α} {ι : Type u_2} {l : Filter ι} (w : ι → α)
      (δ : ι → ℝ),
      Filter.Tendsto δ l (nhdsWithin 0 (Set.Ioi 0)) →
        (∀ᶠ (j : ι) in l, x ∈ Metric.closedBall (w j) (K * δ j)) →
          Filter.Tendsto (fun j => Metric.closedBall (w j) (δ j)) l
            (VitaliFamily.filterAt (IsUnifLocDoublingMeasure.vitaliFamily μ K) x) :=
  by sorry

This theorem states that for a given uniform locally doubling measure `μ` on a metric space `α` equipped with a second countable topology, a Borel space structure, and a locally finite measure, we have the following result. Suppose we have a sequence of points `w` and radii `δ` in the space defined on a filter `l`, such that `δ` tends toward 0 within the set of positive real numbers under `l`. Additionally, suppose that most (in the sense of the filter `l`) points `x` are in the closed ball centered at `w(j)` with radius `K * δ(j)`. Then, the sequence of closed balls with radii `δ(j)` centered at `w(j)` tends toward the filter generated by the Vitali family associated with the measure `μ` at the point `x`. In layman's terms, this theorem captures the idea that, under certain conditions, the sequence of closed balls "shrinks" towards the point `x` in a manner captured by the Vitali family's filter.

Given a uniform locally doubling measure `μ` on a second countable, locally finite Borel space `α`, if most points `x` are in the closed balls with radii `δ(j)` centered at `w(j)` that shrink to 0, then the sequence of closed balls filters converges to the Vitali family filter at `x`.


theorem WithBot.none_lt_some : ∀ {α : Type u_1} [inst : LT α] (a : α), none < ↑a := by sorry

This theorem states that for any type `α` which has a less-than operation (`LT α`), any value `a` of type `α` satisfies the inequality that `none` is less than `a`. Here, `none` refers to the bottom element of the type `WithBot α` (which adds a bottom element to `α`), and `↑a` is the notation for lifting `a` into the `WithBot α` type. So, in other words, the bottom element of `WithBot α` is less than any other element of this type.

For any type `α` with a less-than relation and any element `a` of type `α`, `none` (the bottom element of `WithBot α`) is less than `a` in `WithBot α`.


theorem NormedSpace.expSeries_sum_eq :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸]
      [inst_3 : TopologicalSpace 𝔸] [inst_4 : TopologicalRing 𝔸] (x : 𝔸),
      FormalMultilinearSeries.sum (NormedSpace.expSeries 𝕂 𝔸) x = ∑' (n : ℕ), (↑(Nat.factorial n))⁻¹ • x ^ n :=
  by sorry

The theorem `NormedSpace.expSeries_sum_eq` states that for any types `𝕂` of a field and `𝔸` of a ring, with `𝔸` being a `𝕂`-algebra and both `𝕂` and `𝔸` being topological rings, the sum of the exponential series on a given element `x` from `𝔸` equals the sum of the series formed by the term `(1/n!) * x^n` for all natural numbers `n`. Here, `n!` denotes the factorial of `n` and `x^n` denotes `x` raised to the power `n`.

For any field `𝕂`, ring `𝔸` that is a `𝕂`-algebra and topological ring, the exponential series of an element `x` in `𝔸` equals the sum of the series of `(1/n!) * x^n` for all natural numbers `n`.


theorem Multiset.sup_cons :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (a : α) (s : Multiset α),
      Multiset.sup (a ::ₘ s) = a ⊔ Multiset.sup s :=
  by sorry

The theorem `Multiset.sup_cons` states that for any type `α` equipped with a semilattice structure and a least element (`OrderBot`), and for any element `a` of type `α` and multiset `s` of elements of the same type `α`, the supremum of the multiset obtained by consing `a` onto `s` (denoted `a ::ₘ s`) is equal to the supremum of `a` and the supremum of `s`. In mathematical terminology, this states that for all `a` and `s`, $\bigvee (a :: s) = a \vee \bigvee s$, where $::$ denotes consing an element to a multiset, $\bigvee$ denotes the supremum, and $\vee$ is the sup operation in the semilattice.

For any semilattice `α` with least element and multiset `s` of `α`, the supremum of `a :: s` is equal to the supremum of `a` and the supremum of `s`, i.e., $\bigvee (a :: s) = a \vee \bigvee s$.


Setoid.comm'

theorem Setoid.comm' : ∀ {α : Type u_1} (s : Setoid α) {x y : α}, Setoid.Rel s x y ↔ Setoid.Rel s y x := by sorry

This theorem states that for all types `α` and for any setoid `s` on `α`, and for any elements `x` and `y` of `α`, the relation `Setoid.Rel` is symmetric. In other words, if `x` is related to `y` under the equivalence relation defined by `s`, then `y` is also related to `x` under the same equivalence relation. This is a typical property of equivalence relations, which are reflexive, symmetric, and transitive by definition. In terms of mathematical notation, this theorem can be written as: ∀ `α`, `s`, `x`, `y`, `Setoid.Rel s x y` if and only if `Setoid.Rel s y x`.

For any equivalence relation `s` on type `α`, the relation `Setoid.Rel s` is symmetric. That is, for all `x` and `y` in `α`, `Setoid.Rel s x y` if and only if `Setoid.Rel s y x`.


theorem ENNReal.toReal_lt_toReal : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal < b.toReal ↔ a < b) := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, provided that neither `a` nor `b` are equal to positive infinity, the real number equivalent of `a` is less than the real number equivalent of `b` if and only if `a` is less than `b`. In other words, the comparison of `a` and `b` remains consistent whether we consider them as extended nonnegative real numbers or as their real number equivalents.

For any extended nonnegative real numbers `a` and `b` not equal to positive infinity, `a < b` if and only if their real number equivalents have the same comparison relation.


theorem Set.Finite.of_preimage :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β}, Set.Finite (f ⁻¹' s) → Function.Surjective f → Set.Finite s :=
  by sorry

The theorem `Set.Finite.of_preimage` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `β`, if the preimage of `s` under `f` is a finite set and `f` is a surjective function, then `s` is a finite set.

In other words, it says that if you have a map that covers all elements of the codomain and the set of elements from the domain that map to a specific set in the codomain is finite, then that specific set is also finite. This theorem establishes a relationship between the finiteness of sets and the properties of the functions that map to them.

If a function from a type to a type is surjective and its preimage of a finite set is finite, then that set is finite.


theorem map_ne_zero_of_mem_nonZeroDivisors :
    ∀ {M : Type u_2} {M' : Type u_3} {F : Type u_7} [inst : MonoidWithZero M] [inst_1 : MonoidWithZero M']
      [inst_2 : FunLike F M M'] [inst_3 : Nontrivial M] [inst_4 : ZeroHomClass F M M'] (g : F),
      Function.Injective ⇑g → ∀ {x : M}, x ∈ nonZeroDivisors M → g x ≠ 0 :=
  by sorry

The theorem `map_ne_zero_of_mem_nonZeroDivisors` states that for any types `M` and `M'` that form monoids with zero (i.e., they are monoids that also have a zero element), a function `g` of type `F` that is a function-like mapping from `M` to `M'` and is injective, if `x` is a member of the non-zero-divisors of `M`, then the result of applying `g` to `x` must not be zero. This essentially says that the action of `g` preserves the property of being a non-zero-divisor under certain conditions. This theorem is important in the field of ring theory and algebra where non-zero-divisors play a crucial role.

If `M` and `M'` are monoids with zero and `g : M -> M'` is an injective function-like mapping, then for every non-zero-divisor `x` in `M`, `g x` is non-zero in `M'`.


theorem Asymptotics.isLittleO_abs_right :
    ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
      (f =o[l] fun x => |u x|) ↔ f =o[l] u :=
  by sorry

The theorem `Asymptotics.isLittleO_abs_right` states that for any types `α` and `E`, where `E` has a norm, and for any functions `f : α → E`, `u : α → ℝ`, and a filter `l` on `α`, `f` is little o of `|u x|` with respect to `l` if and only if `f` is little o of `u` with respect to `l`. In mathematical notation, this is saying $f(x) = o(|u(x)|)$ if and only if $f(x) = o(u(x))$.

For functions `f : α → E` and `u : α → ℝ` on type `α`, where `E` has a norm, `f` is little o of `|u x|` with respect to a filter `l` if and only if `f` is little o of `u` with respect to `l`, i.e., $f(x) = o(|u(x)|)_l$ if and only if $f(x) = o(u(x))_l$.


theorem CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_hom :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      [inst_3 : CategoryTheory.Limits.HasColimit G] (w : F ≅ G) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.Limits.HasColimit.isoOfNatIso w).hom =
        CategoryTheory.CategoryStruct.comp (w.hom.app j) (CategoryTheory.Limits.colimit.ι G j) :=
  by sorry

This theorem, named `CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_hom`, states that for any two functors `F` and `G` from a category `J` to a category `C`, given that both functors have colimits and there exists a natural isomorphism `w` between `F` and `G`, the composition of the coprojection from a value of the functor `F` to the colimit object of `F` with the homomorphism of the iso associated with the natural isomorphism `w`, is equal to the composition of the application of the homomorphism of `w` to `j` with the coprojection from a value of the functor `G` to the colimit object of `G`, for any object `j` in `J`. This theorem expresses a key property of natural isomorphisms and colimits in category theory.

 For any functors F and G from a category J to C with colimits, and given a natural isomorphism w between F and G, the following diagram commutes:

F(j) ───────────────────────────── w\_j ────────────────────────────── G(j)
│ │ │
│ │ v v
│ COLIM F ───────────────────=─────────────────────────────── COLIM G
│ │ │
│ │ up_F(j) ───────────────── v ────────────────────────────── down_G(j)


theorem CategoryTheory.ShortComplex.leftRightHomologyComparison'_compatibility :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h₁ h₁' : CategoryTheory.ShortComplex.LeftHomologyData S)
      (h₂ h₂' : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂ =
        CategoryTheory.CategoryStruct.comp
          (CategoryTheory.ShortComplex.leftHomologyMap' (CategoryTheory.CategoryStruct.id S) h₁ h₁')
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁' h₂')
            (CategoryTheory.ShortComplex.rightHomologyMap' (CategoryTheory.CategoryStruct.id S) h₂' h₂)) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftRightHomologyComparison'_compatibility` states that for any category `C` with zero morphisms and any short complex `S` in `C`, given two pairs of left and right homology data `(h₁, h₂)` and `(h₁', h₂')` of `S`, the left-right homology comparison of `(h₁, h₂)` is equal to the composition of the left homology map of `(h₁, h₁')` and the composition of the left-right homology comparison of `(h₁', h₂')` and the right homology map of `(h₂', h₂)`. In other words, this theorem tells us that certain maps involving homology data in a short complex of a category are compatible with each other under composition.

For any short complex in a category with zero morphisms, the left-right homology comparison of two pairs of homology data is equal to the composition of the corresponding left and right homology maps between the two pairs.


theorem AddCommute.zsmul_add :
    ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a b : α}, AddCommute a b → ∀ (i : ℤ), i • (a + b) = i • a + i • b :=
  by sorry

The theorem `AddCommute.zsmul_add` states that for any type `α` that is a subtraction monoid, and for any elements `a` and `b` of type `α` that commute under addition (i.e., `a + b = b + a`), the integer scaling of the sum equals the sum of the integer scalings. More specifically, for any integer `i`, `i` times the sum of `a` and `b` equals `i` times `a` plus `i` times `b`. This generalizes the distributive property of multiplication over addition to the context of subtraction monoids and integer scalings.

For any subtraction monoid type `α` and commuting elements `a` and `b` of type `α`, the scaling of their sum with an integer `i` equals the scaling of `a` with `i` plus the scaling of `b` with `i`.


theorem multiplicity.squarefree_iff_multiplicity_le_one :
    ∀ {R : Type u_1} [inst : CommMonoid R] [inst_1 : DecidableRel Dvd.dvd] (r : R),
      Squarefree r ↔ ∀ (x : R), multiplicity x r ≤ 1 ∨ IsUnit x :=
  by sorry

The theorem `multiplicity.squarefree_iff_multiplicity_le_one` states that for any commutative monoid `R` with a decidable relation of divisibility `Dvd.dvd`, an element `r` of `R` is square-free (meaning the only squares that divide it are the squares of units) if and only if for all elements `x` of `R`, the multiplicity of `x` in `r` (the largest natural number `n` such that `x^n` divides `r`) is less than or equal to one, or `x` is a unit (an element with a two-sided inverse). In other words, an element is square-free if each of its divisors appears at most once in the factorization, unless the divisor is a unit.

An element in a commutative monoid is square-free if and only if the multiplicity of each non-unit divisor is at most 1.


theorem Equiv.swap_inv : ∀ {α : Type u} [inst : DecidableEq α] (x y : α), (Equiv.swap x y)⁻¹ = Equiv.swap x y := by
  sorry

The theorem `Equiv.swap_inv` states that for any type `α` with decidable equality and for any two elements `x` and `y` of this type, the inverse of the permutation that swaps `x` and `y` is the permutation that swaps `x` and `y` itself. This means that the operation of swapping two elements is its own inverse.

For any type with decidable equality, the permutation that swaps two elements is equal to its own inverse.


theorem Mathlib.MeasureTheory.Measure.Lebesgue.Basic._auxLemma.10 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem from Measure Theory in Mathlib (a library for the Lean Theorem Prover) states that for any two propositions `a` and `b`, the statement "there exists an instance where `a` is true such that `b` is also true" is equivalent to the statement "`a` is true and `b` is true". This establishes an equivalence between two different ways of expressing a joint assertion in logic.

The theorem asserts that for all propositions `a` and `b`, the existence of an instance where `a` and `b` both hold is equivalent to `a` and `b` both holding.


theorem Preorder.toLE_injective : ∀ {α : Type u_3}, Function.Injective (@Preorder.toLE α) := by sorry

This theorem states that for any type `α`, the function `Preorder.toLE` is injective. In other words, if we have two preorders on `α` such that the "less than or equal to" relation derived from them, `Preorder.toLE`, is the same for both, then the two preorders must be the same. So, no two distinct preorders can give rise to the same "less than or equal to" relation.

If two preorders on a type `α` have equal "less than or equal to" relations `Preorder.toLE`, then they are equal.


theorem NonUnitalStarAlgebra.coe_sInf :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
      [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
      [inst_7 : StarModule R A] (S : Set (NonUnitalStarSubalgebra R A)), ↑(sInf S) = ⋂ s ∈ S, ↑s :=
  by sorry

This theorem states that for any set `S` of elements of type `NonUnitalStarSubalgebra` over a commutative semiring `R` and a non-unital semiring `A` with some additional properties (like being a star ring, a module, obeying the scalar tower property, the scalar multiplication commutative property and being a star module), the underlying set of the infimum (`sInf`) of `S` is equal to the intersection of the underlying sets of all elements in `S`.

In other words, when we look at the set of all elements belonging to any non-unital star subalgebra in `S`, and take its smallest non-unital star subalgebra (if it exists), its elements are precisely the elements that belong to every non-unital star subalgebra in `S`.

For any set `S` of non-unital star subalgebras over a commutative semiring `R` with additional properties, the underlying set of their infimum equals the intersection of the underlying sets of all elements in `S`.


theorem NormedSpace.exp_units_conj :
    ∀ (𝕂 : Type u_1) {𝔸 : Type u_2} [inst : RCLike 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸]
      [inst_3 : CompleteSpace 𝔸] (y : 𝔸ˣ) (x : 𝔸),
      NormedSpace.exp 𝕂 (↑y * x * ↑y⁻¹) = ↑y * NormedSpace.exp 𝕂 x * ↑y⁻¹ :=
  by sorry

This theorem states that for any type `𝕂` that behaves like a real/closed field (RCLike), a type `𝔸` that forms a normed ring, and for `𝔸` as a normed algebra over `𝕂` in a complete space, the exponential function (`NormedSpace.exp`) applied to a value `x` of type `𝔸`, multiplied on the left by a unit `y` and on the right by the inverse of the same unit `y`, is equivalent to the exponential of `x` itself, again multiplied on the left by `y` and on the right by `y`'s inverse. In mathematical terms, it asserts that `exp(𝕂, y * x * y⁻¹) = y * exp(𝕂, x) * y⁻¹` for all `x` in `𝔸` and unit `y` in `𝔸ˣ`.

For any RCLike field `𝕂`, normed ring `𝔸`, and unit `y` in `𝔸`, the exponential function applied to `x` in `𝔸` satisfies `exp(𝕂, y * x * y⁻¹) = y * exp(𝕂, x) * y⁻¹`.


theorem Filter.singleton_mem_pure : ∀ {α : Type u} {a : α}, {a} ∈ pure a := by sorry

This theorem, named `Filter.singleton_mem_pure`, states that for any type `α` and any element `a` of type `α`, the singleton set `{a}` is an element of the filter `pure a`. In other words, if we create a filter that consists only of the element `a`, then the set containing only `a` is indeed a member of this filter. This holds for any conceivable type and element of that type.

For any type `α` and element `a` of type `α`, the singleton set `{a}` is contained in the filter `pure a`.