theorem Finmap.liftOn_toFinmap :
    ∀ {α : Type u} {β : α → Type v} {γ : Type u_1} (s : AList β) (f : AList β → γ)
      (H : ∀ (a b : AList β), List.Perm a.entries b.entries → f a = f b), Finmap.liftOn (AList.toFinmap s) f H = f s :=
  by sorry

The theorem `Finmap.liftOn_toFinmap` states that for any AList `s`, function `f` from AList to some type `γ`, and a proof `H` that `f` respects permutations of the entries of ALists, the result of lifting `f` on the Finmap obtained from `s` by `AList.toFinmap` is the same as the result of applying `f` directly to `s`. In essence, it shows the consistency of `Finmap.liftOn` with `AList.toFinmap`, and thus allows us to work with well-defined functions on Finmaps derived from functions on ALists that respect permutations.

For any permutation-respecting function `f` from an AList `s` to type `γ`, `Finmap.liftOn (AList.toFinmap s) f` is equal to `f s`.


theorem SubmodulesRingBasis.toRing_subgroups_basis :
    ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      {B : ι → Submodule R A}, SubmodulesRingBasis B → RingSubgroupsBasis fun i => Submodule.toAddSubgroup (B i) :=
  by sorry

This theorem states that for any index type `ι`, and any types `R` and `A` which have the structure of commutative rings, given an `R`-algebra structure on `A`, and a family `B` of submodules of `A` (indexed by `ι`) which forms a ring basis of submodules, the corresponding family of additive subgroups obtained by reinterpreting each submodule in the family `B` as an additive subgroup, forms a ring basis of additive subgroups. Essentially, the ring basis property is preserved when we switch from the context of submodules to additive subgroups.

Given an index type `ι`, types `R` and `A` with commutative ring structures, an `R`-algebra structure on `A`, and a family `B` of `R`-submodules of `A` (indexed by `ι`) that forms a ring basis, the corresponding family of additive subgroups of `A` obtained from `B` is also a ring basis of additive subgroups.


theorem Nat.choose_succ_self : ∀ (n : ℕ), Nat.choose n (Nat.succ n) = 0 := by sorry

The theorem `Nat.choose_succ_self` states that for any natural number `n`, the binomial coefficient or "choose" operation of `n` and `n + 1`, denoted as `Nat.choose n (Nat.succ n)`, is always equal to zero. In other words, there are no ways to choose `n + 1` items from a set of `n` items, which intuitively makes sense since the set does not contain `n + 1` items.

For all natural numbers n, the binomial coefficient Nat.choose n (Nat.succ n) equals zero.


theorem induced_iInf :
    ∀ {α : Type u_1} {β : Type u_2} {g : β → α} {ι : Sort w} {t : ι → TopologicalSpace α},
      TopologicalSpace.induced g (⨅ i, t i) = ⨅ i, TopologicalSpace.induced g (t i) :=
  by sorry

This theorem states that for all types `α` and `β`, a function `g` from `β` to `α`, an index type `ι`, and a function `t` mapping each element of `ι` to a TopologicalSpace on `α`, the topology on `β` induced by the function `g` and the infimum (greatest lower bound) of the topologies `t i` (for all `i` in `ι`) is equal to the infimum of the topologies on `β` induced by the same function `g` and each of the topologies `t i`. In other words, the process of inducing a topology commutes with taking the infimum of a collection of topologies. In mathematical terms, it's saying that if $g: \beta \rightarrow \alpha$ and $\text{t} : \iota \rightarrow \text{TopologicalSpace} \ \alpha$, then $\text{TopologicalSpace.induced} \ g \ (\bigwedge_i \text{t} \ i) = \bigwedge_i \ \text{TopologicalSpace.induced} \ g \ (\text{t} \ i)$.

For all types `α`, `β`, index type `ι`, functions `g : β -> α` and `t : ι -> TopologicalSpace α`, the topology on `β` induced by `g` from the infimum of `t i` (for all `i` in `ι`) is equal to the infimum of the topologies on `β` induced by `g` and each `t i`. In other words, `TopologicalSpace.induced g (⨄ i in ι . t i) = ⨄ i in ι . TopologicalSpace.induced g (t i)`.


theorem EqvGen.is_equivalence : ∀ {α : Type u} (r : α → α → Prop), Equivalence (EqvGen r) := by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, the equivalence closure of `r` (denoted by `EqvGen r`) is an equivalence relation. In other words, for any given relation `r` on elements of a certain type, the relation that includes `r` and the smallest possible amount of additional pairs to make it reflexive, symmetric and transitive, is indeed an equivalence relation.

For any binary relation `r` on type `α`, the reflexive, symmetric, and transitive closure of `r` (denoted by `EqvGen r`) equals the equivalence relation on `α` induced by `r`.


theorem CauSeq.const_equiv :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {x y : β}, CauSeq.const abv x ≈ CauSeq.const abv y ↔ x = y :=
  by sorry

The theorem `CauSeq.const_equiv` states that for any types `α` and `β`, where `α` is a linear ordered field and `β` is a ring, and for any absolute value function `abv` from `β` to `α`, and any elements `x` and `y` of `β`, the constant Cauchy sequences with values `x` and `y` are equivalent (as defined by the equivalence relation ≈ on Cauchy sequences) if and only if `x` equals `y`. In other words, two constant Cauchy sequences are equivalent precisely when they are constant for the same value.

For any linear ordered field `α`, ring `β`, absolute value function `abv` from `β` to `α`, and elements `x, y` of `β`, the constant Cauchy sequences over `β` with values `x` and `y` are equivalent if and only if `x = y`.


theorem GeneralizedContinuedFraction.denom_eq_conts_b :
    ∀ {K : Type u_1} {g : GeneralizedContinuedFraction K} {n : ℕ} [inst : DivisionRing K],
      GeneralizedContinuedFraction.denominators g n = (GeneralizedContinuedFraction.continuants g n).b :=
  by sorry

This theorem states that for any type `K` which forms a division ring, any generalized continued fraction `g` of type `K`, and any natural number `n`, the `n`th element of the denominators of `g` is equal to the second element (denoted by `.b`) of the `n`th pair of the continuants of `g`. In simpler terms, within the context of continued fractions, this theorem says that the `n`th denominator of a generalized continued fraction is equal to the `n`th second element of the continuants of the same fraction.

For any division ring `K` and generalized continued fraction `g` of type `K`, the `n`th denominator is equal to the second element of the `n`th pair of continuants of `g`.


theorem Finset.image_subset_image_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s t : Finset α},
      Function.Injective f → (Finset.image f s ⊆ Finset.image f t ↔ s ⊆ t) :=
  by sorry

The theorem `Finset.image_subset_image_iff` states that for any two finite sets `s` and `t` of an arbitrary type `α`, and a function `f` from `α` to another arbitrary type `β`, given that `f` is injective and that equality on `β` is decidable, the preimage of `s` under `f` is a subset of the preimage of `t` under `f` if and only if `s` is a subset of `t`. In simpler terms, if `f` is a function that doesn't map different elements to the same element (injective) and we can decide whether two elements of `β` are equal, then the image of a smaller set `s` under `f` is always a subset of the image of a larger set `t` under `f`.

For injective functions between arbitrary types with decidable equality on the codomain, the preimage of a smaller set under the function is a subset of the preimage of a larger set if and only if the smaller set is a subset of the larger set.


theorem Mathlib.Order.Filter.Pi._auxLemma.12 : ∀ {α : Type u} {f : Filter α}, Filter.NeBot f = (f ≠ ⊥) := by sorry

This theorem, `Mathlib.Order.Filter.Pi._auxLemma.12`, states that for any type `α` and any filter `f` of type `α`, the filter `f` is not a bottom filter if and only if `f` is not equal to the bottom filter. Here, `Filter.NeBot f` is a predicate indicating that `f` is a non-bottom (i.e., non-empty) filter, and `⊥` denotes the bottom filter. In the context of filter theory in mathematics, a bottom filter typically represents the empty set or a least element in a partially ordered set.

A filter `f` of type `α` in Lean is not a bottom filter if and only if `f` is not equal to the bottom filter `⊥`.


theorem continuous_quot_lift :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {r : X → X → Prop} {f : X → Y}
      (hr : ∀ (a b : X), r a b → f a = f b), Continuous f → Continuous (Quot.lift f hr) :=
  by sorry

This theorem states that for any types `X` and `Y`, where `X` and `Y` are endowed with topological structures, if we have a relation `r` on `X` and a function `f` from `X` to `Y` such that `f` respects the relation `r` (i.e., `f` gives the same output for any two elements of `X` that are related by `r`), then if `f` is continuous, the 'lift' of `f` to the quotient of `X` by `r` (represented by `Quot.lift f hr`) is also continuous. In terms of mathematical language, if $X$ and $Y$ are topological spaces, $r$ is an equivalence relation on $X$, and $f: X \rightarrow Y$ is a continuous function that is constant on $r$-equivalence classes, then the induced function on the quotient space $X/r$ is also continuous.

If `X` and `Y` are topological spaces, `r` is an equivalence relation on `X`, `f: X → Y` is a continuous function that is constant on `r`-equivalence classes, then the induced function `Quot.lift f hr` on the quotient space `X/r` is continuous.


theorem WeierstrassCurve.map_b₄ :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {A : Type v} [inst_1 : CommRing A] (φ : R →+* A),
      (W.map φ).b₄ = φ W.b₄ :=
  by sorry

This theorem, named `WeierstrassCurve.map_b₄`, states that for any commutative ring `R`, any Weierstrass curve `W` defined over `R`, any type `A` with a commutative ring structure, and any morphism `φ` from `R` to `A`, the fourth coefficient `b₄` of the Weierstrass curve obtained by mapping `W` via `φ` is equal to the image under `φ` of the fourth coefficient `b₄` of `W`. In essence, this theorem shows how the fourth coefficient of a Weierstrass curve behaves under a ring homomorphism.

For any Weierstrass curve `W` over a commutative ring `R`, and any ring homomorphism `φ` from `R` to a commutative ring `A`, the fourth coefficient of the Weierstrass curve `W` mapped via `φ` equals the image under `φ` of the fourth coefficient of `W`.


theorem WeierstrassCurve.map_b₂ :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {A : Type v} [inst_1 : CommRing A] (φ : R →+* A),
      (W.map φ).b₂ = φ W.b₂ :=
  by sorry

This theorem, `WeierstrassCurve.map_b₂`, states that for any type `R` that has a commutative ring structure, any Weierstrass curve `W` defined over `R`, any other type `A` also with a commutative ring structure, and any ring homomorphism `φ` from `R` to `A`, the `b₂` coefficient of the Weierstrass curve obtained by mapping `W` using `φ` is equal to the image under `φ` of the `b₂` coefficient of `W`. In mathematical terms, if `W` is a Weierstrass curve defined over a commutative ring `R` and `φ` is a ring homomorphism from `R` to another commutative ring `A`, then the `b₂` coefficient of the Weierstrass curve in `A` obtained by mapping `W` under `φ` is `φ(W.b₂)`.

For any commutative rings R and A, any Weierstrass curve W over R, and any ring homomorphism φ from R to A, the `b₂` coefficient of the Weierstrass curve over A obtained by mapping W under φ is equal to φ(W.b₂).


theorem Associates.dvdNotUnit_iff_lt :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {a b : Associates α}, DvdNotUnit a b ↔ a < b := by sorry

The theorem `Associates.dvdNotUnit_iff_lt` states that for any type `α` that has a `CancelCommMonoidWithZero` structure, given any two elements `a` and `b` from the set of associates of `α`, `a` divides `b` strictly if and only if `a` is less than `b`.

In other words, in the context of the associated elements of a cancel commutative monoid with zero, an element `a` strictly dividing another element `b` is equivalent to `a` being less than `b`. Here, an element `a` strictly divides `b` (denoted as `DvdNotUnit a b`) if `a` is not zero and there exists an element `x` such that `x` is not a unit and `b = a * x`.

For any cancel commutative monoid with zero `α`, elements `a` and `b` being associates of `α` satisfy `a < b` if and only if `a` strictly divides `b` (i.e., `a ≠ 0` and `b = a * x` for some non-unit `x`).


theorem SimpleGraph.Walk.map_isPath_iff_of_injective :
    ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {f : G →g G'} {u v : V}
      {p : SimpleGraph.Walk G u v},
      Function.Injective ⇑f → (SimpleGraph.Walk.IsPath (SimpleGraph.Walk.map f p) ↔ SimpleGraph.Walk.IsPath p) :=
  by sorry

The theorem `SimpleGraph.Walk.map_isPath_iff_of_injective` states that for any types `V` and `V'`, any simple graphs `G` and `G'` on `V` and `V'` respectively, any graph homomorphism `f` from `G` to `G'`, and any vertices `u` and `v` in `V`, if a walk `p` exists from `u` to `v` in `G`, and if the function `f` is injective, then the walk `p` is a path in `G` if and only if the walk `SimpleGraph.Walk.map f p` is a path in `G'`. In other words, an injective graph homomorphism preserves the property of being a path in the graph, when applied to any walk in the original graph.

For any simple graphs G and G', injective graph homomorphisms f from G to G', and vertices u and v in the respective vertex sets, a walk from u to v in G is a path if and only if the image walk under f is a path in G'.


theorem List.prefix_cons_inj : ∀ {α : Type u_1} {l₁ l₂ : List α} (a : α), a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂ := by sorry

This theorem states that for any type `α`, any lists `l₁` and `l₂`, and any element `a` of type `α`, `l₁` is a prefix of `l₂` if and only if the list resulting from prepending `a` to `l₁` is a prefix of the list resulting from prepending `a` to `l₂`. In other words, adding the same element to the start of two lists doesn't change their prefix relation.

For any type `α`, lists `l₁` and `l₂` of type `list α`, and element `a` of type `α`, the lists `l₁` is a prefix of `l₂` if and only if the list obtained by prepending `a` to `l₁` is a prefix of the list obtained by prepending `a` to `l₂`.


/-- A subring is closed under negation.  -/
theorem Subring.neg_mem : ∀ {R : Type u} [inst : Ring R] (s : Subring R) {x : R}, x ∈ s → -x ∈ s := by sorry

This theorem states that for any given Ring `R` and a subring `s` of `R`, if an element `x` is in `s`, then its negation `-x` is also in `s`. In other words, the negation of any element in the subring is also a member of the subring. This property reflects the essence of a subring in ring theory, which is that it is closed under the ring operations, including negation.

If `s` is a subring of a ring `R`, then for all `x` in `s`, `-x` is also in `s`.


theorem bit0_lt_bit0 : ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α}, bit0 a < bit0 b ↔ a < b := by sorry

This theorem, called `bit0_lt_bit0`, states that for any type `α` that forms a linear ordered semiring, given any two elements `a` and `b` of type `α`, the bit doubling function `bit0` applied to `a` is less than `bit0` applied to `b` if and only if `a` is less than `b`. The `bit0` function is defined as `bit0 a = a + a`, meaning that it doubles its input. Therefore, this theorem essentially asserts that the relation of less than (`<`) is preserved under the operation of doubling elements in an ordered semiring.

For any linear ordered semiring type `α`, the relation `a < b` holds if and only if `bit0 a < bit0 b`, where `bit0 a = a + a`.


OreLocalization.expand

/-- A fraction `r /ₒ s` is equal to its expansion by an arbitrary factor `t` if `s * t ∈ S`.  -/
theorem OreLocalization.expand :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (r : R) (s : ↥S) (t : R)
      (hst : ↑s * t ∈ S), r /ₒ s = r * t /ₒ { val := ↑s * t, property := hst } :=
  by sorry

This theorem states that for any given type `R` that is a Monoid, a submonoid `S` of `R`, a localization of `R` at `S`, and any elements `r` and `s` of `R` and `S` respectively, and an arbitrary element `t` of `R`, if the product of `s` and `t` is an element of `S` (denoted by `hst : ↑s * t ∈ S`), then the fraction `r /ₒ s` is equal to `r * t /ₒ (s * t)`. The notation `/ₒ` represents the localized division in the ring of fractions, where `s` and `s * t` are considered as elements of `S`.

For any Monoid `R`, submonoid `S`, and elements `r` in `R`, `s` in `S`, and `t` in `R` such that `s * t` is in `S`, the localized division `r /ₒ s` equals `r * t /ₒ (s * t)`.


theorem Mathlib.Data.Finite.Card._auxLemma.4 : ∀ {α : Type u} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) := by sorry

This theorem, named `Mathlib.Data.Finite.Card._auxLemma.4`, states that for any type `α` with a less than or equal to (`≤`) operation, and for any two elements `x` and `y` of type `α`, the statement that `x` is greater than or equal to (`≥`) `y` is equivalent to the statement that `y` is less than or equal to (`≤`) `x`.

For any type `α` with a total order and any `x, y` in `α`, `x ≥ y` is equivalent to `y ≤ x`.


theorem Rat.mul_den_eq_num : ∀ {q : ℚ}, q * ↑q.den = ↑q.num := by sorry

This theorem states that for any rational number `q`, the product of `q` and the denominator of `q` (when the denominator is promoted to a rational number) is equal to the numerator of `q` (when the numerator is promoted to a rational number). In mathematical terms, for any rational number (q = p/q), the equation `q * denom(q) = num(q)` holds.

For any rational number q = p/q, the product of q and its denominator is equal to its numerator: q * denom(q) = num(q).


theorem List.map_eq_bind :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α), List.map f l = List.bind l fun x => [f x] := by sorry

This theorem states that for any two types `α` and `β`, and any function `f` from `α` to `β`, the operation of mapping `f` over a list `l` of elements of type `α` is equivalent to the operation of binding the list `l` with a function that applies `f` to each element, and wraps each result in a singleton list. In other words, `List.map f l` produces the same result as `List.bind l fun x => [f x]` for any list `l` and function `f`.

For any types `α` and `β` and function `f` from `α` to `β`, `List.map f` on a list `l` of type `α` is equivalent to `List.bind l (fun x => [x := f x])`.


theorem Nat.gcd_eq_right : ∀ {m n : ℕ}, n ∣ m → Nat.gcd m n = n := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `n` divides `m` then the greatest common divisor (gcd) of `m` and `n` is `n`. In other words, if `n` is a divisor of `m`, it's the largest possible common divisor of both `m` and `n`.

If `n` divides `m`, then the greatest common divisor of `m` and `n` equals `n`.


/-- Distance from the image of a point under inversion to the center. This formula accidentally
works for `x = c`.  -/
theorem EuclideanGeometry.dist_inversion_center :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] (c x : P) (R : ℝ),
      dist (EuclideanGeometry.inversion c R x) c = R ^ 2 / dist x c :=
  by sorry

This theorem states that in a Euclidean geometry, the distance from the image of a point under inversion to the center of inversion is equal to the square of the radius of inversion divided by the distance of the original point to the center. This inversion map is defined for every point `x` such that `y -ᵥ c = (R / dist x c) ^ 2 • (x -ᵥ c)`, where `y` is the image of the point `x` under inversion, and `c` and `R` are the center and radius of the sphere of inversion respectively. The formula also holds when the point `x` coincides with the center of inversion `c`.

In Euclidean geometry, the distance from a point to the center of inversion under an inversion transformation is equal to the square of the radius of inversion divided by the distance of the point to the center of inversion for points outside the sphere of inversion, and is equal to zero for points on the sphere.


theorem Rat.zero_mkRat : ∀ (n : ℕ), mkRat 0 n = 0 := by sorry

This theorem, `Rat.zero_mkRat`, states that for any natural number `n`, creating a rational number using `mkRat` with 0 as the numerator and `n` as the denominator yields the rational number 0. It underscores the standard mathematical principle that any fraction with a zero numerator is equal to zero, regardless of the denominator (assuming it's not zero, as the domain here is natural numbers, excluding 0).

For any natural number `n`, the rational number `mkRat 0 n` equals the rational number 0.


theorem MeasureTheory.aecover_Ioi_of_Ioi :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a : ι → α} {A : α},
      Filter.Tendsto a l (nhds A) → MeasureTheory.AECover (μ.restrict (Set.Ioi A)) l fun i => Set.Ioi (a i) :=
  by sorry

This theorem states that for any measurable space `α`, any type `ι`, a measure `μ` on the measurable space `α`, a filter `l` on `ι`, a linear order on `α`, a topological space on `α`, an order-closed topology on `α`, an open-measurable space on `α`, and a function `a` from `ι` to `α`, if the function `a` tends to the neighborhood filter at a particular `A` in `α` under the filter `l`, then almost-everywhere cover (`AECover`) holds for the restriction of the measure `μ` to the set of all `α`'s greater than `A` (denoted by `Set.Ioi A`), with respect to the filter `l` and the function that maps each `i` in `ι` to the set of all `α`'s greater than `a i` (denoted by `Set.Ioi (a i)`).

In simpler terms, it states that if we are considering a measure restricted to values greater than a certain limit `A`, and if a function `a` tends to this limit under a certain filter, then almost everywhere (except possibly on a set of measure zero) each point `i` is associated with a set of values greater than `a i`.

If `α` is a measurable space, `μ` is a measure on `α`, `l` is a filter on a type `ι`, `a : ι → α`, and `A ∈ α`, if `a` tends to the neighborhood filter of `A` under `l`, then `μ` almost-everywhere covers `Set.Ioi A` by the sets `Set.Ioi (a i)` for each `i ∈ ι` with respect to `l`.


/-- If `x ^ n = 1`, then `x ^ m` is the same as `x ^ (m % n)`  -/
theorem pow_eq_pow_mod : ∀ {M : Type u_2} [inst : Monoid M] {x : M} (m : ℕ) {n : ℕ}, x ^ n = 1 → x ^ m = x ^ (m % n) :=
  by sorry

This theorem states that in any monoid `M`, if a certain element `x` raised to the power of `n` equals `1`, then raising `x` to any power `m` is equivalent to raising `x` to the power of `m` modulo `n`. Essentially, it's expressing a property of powers in monoid structures that mirrors a similar property of integers: if an integer `x` to the power of `n` is `1`, then `x` to the power of `m` is the same as `x` to the power of `m` modulo `n`.

In any monoid `M` and for all natural numbers `n` and `m`, if `x^n = 1` then `x^m = x^m % n`.


theorem MvPowerSeries.coeff_add_mul_monomial :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (m n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R),
      (MvPowerSeries.coeff R (m + n)) (φ * (MvPowerSeries.monomial R n) a) = (MvPowerSeries.coeff R m) φ * a :=
  by sorry

This theorem states that for any semiring `R`, index set of variables `σ`, indices `m` and `n`, multivariate formal power series `φ` over the variables `σ` with coefficients from `R` and a coefficient `a` from `R`, the `m + n`th coefficient of the product of `φ` and the `n`th monomial times `a` equals the `m`th coefficient of `φ` times `a`.

Here the product is in the sense of multivariate formal power series, and the `n`th monomial is understood as a multivariate formal power series where only the `n`th coefficient is `a` and all other coefficients are zero. This theorem essentially describes how coefficients are distributed when multiplying a multivariate formal power series by a monomial.

For any semiring `R`, multivariate formal power series `φ` over variables `σ` with coefficients from `R`, index `n`, and coefficient `a` from `R`, the `m + n`th coefficient of `a * (φ * ξ^n)` equals `m`th coefficient of `φ * a * ξ^n`, where `ξ` is the standard basis of the free commutative monoid over `σ`.


theorem List.length_sublists' : ∀ {α : Type u} (l : List α), List.length (List.sublists' l) = 2 ^ List.length l := by
  sorry

This theorem states that, for any list 'l' of type 'α', the length of the list of all its non-contiguous sublists generated by the function 'List.sublists'' is equal to 2 raised to the power of the length of the original list 'l'. In other words, given a list, the total number of its non-contiguous sublists is 2^n, where n is the length of the list.

The number of non-contiguous sublists of a list of length n is 2^n.


/-- If `p` is a locally injective separated map, and `A` is a connected space,
then two lifts `g₁, g₂ : A → E` of a map `f : A → X` are equal if they agree at one point.  -/
theorem IsSeparatedMap.eq_of_comp_eq :
    ∀ {X : Type u_3} {E : Type u_1} {A : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace A]
      {p : E → X},
      IsSeparatedMap p →
        IsLocallyInjective p →
          ∀ {g₁ g₂ : A → E} [inst_2 : PreconnectedSpace A],
            Continuous g₁ → Continuous g₂ → p ∘ g₁ = p ∘ g₂ → ∀ (a : A), g₁ a = g₂ a → g₁ = g₂ :=
  by sorry

The theorem `IsSeparatedMap.eq_of_comp_eq` states that for any locally injective separated map `p` from a topological space `E` to another space `X`, and given a connected space `A`, if there are two continuous functions `g₁, g₂` from `A` to `E` that both lift a map `f` from `A` to `X` (i.e., `f` is the composition of `p` with either `g₁` or `g₂`), then if `g₁` and `g₂` agree at any point in `A`, they must be equal everywhere on `A`. This is a kind of uniqueness statement for lifting problems in topology, asserting that there can't be two different solutions that agree at a point in a connected space.

If `p: E -> X` is a locally injective separated map between topological spaces, `A` is a connected space, and `g₁, g₂: A -> E` are continuous functions lifting the same map `f: A -> X` from `A` to `X`, then `g₁ = g₂` on `A`.


theorem Array.get_set_eq : ∀ {α : Type u_1} (a : Array α) (i : Fin (Array.size a)) (v : α), (Array.set a i v)[↑i] = v :=
  by sorry

This theorem states that for any array `a` of a certain type `α`, for any index `i` within the bounds of the array's size, and for any value `v` of type `α`, if we set the element at index `i` of the array `a` to the value `v`, then when we fetch the element at index `i` of the resulting array, we obtain the value `v`. In essence, it assures that the "set" operation correctly updates the specified position in the array with the given value.

For any array `a` of type `α`, and any index `i` within its bounds, setting the `i`-th element of `a` to `v` results in an array `b` such that `b![i] = v`.


theorem Mathlib.Topology.LocallyConstant.Basic._auxLemma.9 : ∀ (n : ℕ), (Nat.succ (Nat.succ n) = 1) = False := by sorry

This theorem, which is a part of the Mathlib.Topology.LocallyConstant.Basic module, states that for any natural number `n`, the statement that the successor of the successor of `n` is equal to 1 is always False. In other words, it's impossible for a natural number `n` increased by 2 to be equal to 1. This is a basic rule in natural number arithmetic and is true for any natural number `n`.

The theorem asserts that for all natural numbers `n`, `n + 2 ≠ 1`.


/-- Adjoining a single element is compact in the lattice of intermediate fields.  -/
theorem IntermediateField.adjoin_simple_isCompactElement :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (x : E),
      CompleteLattice.IsCompactElement F⟮x⟯ :=
  by sorry

The theorem `IntermediateField.adjoin_simple_isCompactElement` states that for any field `F` and `E`, where `E` is an `F`-algebra, and for any element `x` in `E`, the intermediate field adjoined by the element `x` is a compact element in the complete lattice structure of intermediate fields. Here, a compact element `k` is such that if any set has a supremum (`sSup`) above `k`, then there exists a finite subset whose supremum is also above `k`.

Given a field `F`, an `F`-algebra `E` and an element `x` in `E`, the intermediate field adjoined by `x` is a compact element in the complete lattice of intermediate fields over `F`, meaning that if this intermediate field has a supremum above it, then there exists a finite set of intermediate fields whose supremum is also above it.


theorem inner_self_ofReal_re :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x : E), ↑(RCLike.re ⟪x, x⟫_𝕜) = ⟪x, x⟫_𝕜 :=
  by sorry

This theorem states that for any type `𝕜` that behaves like a real closed field, and any normed add commutative group `E` that also has an inner product space structure over `𝕜`, the real part of the inner product of any element `x` from `E` with itself is equal to the inner product of `x` with itself. In other words, for any `x` in `E`, the real part of its self-inner product is itself. The real part is obtained using the `RCLike.re` function, and the inner product is denoted by `⟪x, x⟫_𝕜`.

For any real closed field `𝕜` and normed add commutative group `E` with an inner product space structure over `𝕜`, the real part of the inner product of any `x` in `E` with itself equals the inner product of `x` with `x`. That is, `RCLike.re (⟪x, x⟫_𝕜) = ⟪x, x⟫_𝕜`.


/-- **Alias** of the reverse direction of `Finset.coe_nonempty`. -/
theorem Finset.Nonempty.to_set : ∀ {α : Type u_1} {s : Finset α}, s.Nonempty → Set.Nonempty ↑s := by sorry

This theorem states that for any given set `s` of any type `α`, if the finset (a finite set in Lean 4) `s` is nonempty, i.e., it contains at least one element, then the coe (coercion) of `s` to a set is also nonempty. In other words, if a finset is not empty, then its equivalent set representation is also not empty. The theorem is an alias of the reverse direction of `Finset.coe_nonempty`.

If `s` is a nonempty finset in Lean 4, then its corresponding set representation is also nonempty.


theorem Nat.Subtype.lt_succ_self :
    ∀ {s : Set ℕ} [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s] (x : ↑s), x < Nat.Subtype.succ x := by
  sorry

This theorem states that for any set `s` of natural numbers which is infinite, and for any element `x` in the set `s`, `x` is strictly less than the successor of `x` in the set `s` according to the usual ordering of natural numbers. Here, the successor of `x` is computed using the function `Nat.Subtype.succ`. This result formalizes a fundamental property of natural numbers within a subset, that each number is less than its successor.

For any infinite set `s` of natural numbers and any `x` in `s`, `x` is strictly less than `Nat.Subtype.succ x` in the order of natural numbers.


theorem HahnSeries.unit_aux :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrderedAddCommGroup Γ] [inst_1 : CommRing R] [inst_2 : IsDomain R]
      (x : HahnSeries Γ R) {r : R},
      r * x.coeff (HahnSeries.order x) = 1 →
        0 < (HahnSeries.addVal Γ R) (1 - HahnSeries.C r * (HahnSeries.single (-HahnSeries.order x)) 1 * x) :=
  by sorry

The theorem `HahnSeries.unit_aux` states that for any type `Γ` which forms a linearly ordered additive commutative group, any commutative ring `R`, an instance of `R` being an integral domain, a given Hahn series `x` over `Γ` and `R`, and a real number `r`, if the product of `r` and the coefficient of `x` at the order of `x` equals 1, then the additive valuation of the difference between 1 and the product of the constant Hahn series `r`, the Hahn series which has a coefficient of 1 at `-order x` and zero elsewhere, and `x` itself is positive.

In simpler terms, if we can multiply a coefficient of our Hahn series `x` by some number `r` to get 1, then the additive valuation (which gives the smallest index with a nonzero coefficient) of a certain Hahn series related to `x` and `r` will be a positive value.

For any Hahn series `x` over a linearly ordered additive commutative group `Γ` and an integral domain `R`, if the coefficient of `x` at `-order x` multiplied by a real number `r` equals 1, then the additive valuation of `1 - r * x` is positive.


theorem Set.Ioc_eq_empty_of_le : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ≤ a → Set.Ioc a b = ∅ := by sorry

This theorem states that for any type `α` that has a preorder structure, given any two elements `a` and `b` from this type, if `b` is less than or equal to `a`, then the left-open right-closed interval from `a` to `b` is an empty set. In other words, there are no elements `x` such that `x` is greater than `a` and less than or equal to `b`.

For any preordered type `α` and elements `a` and `b` with `b ≤ a`, the interval `(a, b]` is empty.


theorem Array.get_set_ne :
    ∀ {α : Type u_1} (a : Array α) (i : Fin (Array.size a)) {j : ℕ} (v : α) (hj : j < Array.size a),
      ↑i ≠ j → (Array.set a i v)[j] = a[j] :=
  by sorry

The theorem `Array.get_set_ne` states that for any array `a` of any type `α`, given an index `i` within the range of the array's size, another natural number index `j`, and a value `v` of type `α`, if `j` is also within the range of the array's size and `j` is not equal to `i`, then setting the element at index `i` of the array to `v` does not change the value at index `j` of the array. In other words, changing the value of an element at a specific index in an array does not affect the elements at different indices in the same array.

For any array `a` of type `α`, and indices `i` and `j` within its range with `i ≠ j`, setting the `i`-th element of `a` to a value `v` does not alter the `j`-th element of `a`.


theorem Filter.Tendsto.inf_nhds' :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Inf L]
      [inst_2 : ContinuousInf L],
      Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (f ⊓ g) l (nhds (x ⊓ y)) :=
  by sorry

The theorem `Filter.Tendsto.inf_nhds'` is a statement about the limit behavior of two functions `f` and `g` in a topological space `L` equipped with an infimum operation (denoted as "⊓") and where the infimum operation is continuous. If the limit of function `f` along a filter `l` tends to a neighborhood of a point `x` and the limit of function `g` along the same filter `l` tends to a neighborhood of point `y`, then the limit of the infimum of functions `f` and `g` (i.e., `(f ⊓ g)`) also along the filter `l` tends to the neighborhood of the infimum of the points `x` and `y` (i.e., `(x ⊓ y)`). In other words, it establishes that the limit of the infimum of two functions is the infimum of their limits when those limits are in a neighborhood filter and the infimum operation is continuous.

If functions `f` and `g` have limit values `x` and `y` in a topologically complete space `L` equipped with a continuous infimum operation, then the limit of the infimum `(f ⊓ g)` along any filter `l` tends to the infimum `(x ⊓ y)` in `L`.


theorem ContDiffBump.normed_def :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
      [inst_3 : MeasurableSpace E] {c : E} (f : ContDiffBump c) {μ : MeasureTheory.Measure E} (x : E),
      ContDiffBump.normed f μ x = ↑f x / ∫ (x : E), ↑f x ∂μ :=
  by sorry

The theorem `ContDiffBump.normed_def` states that for any type `E` that forms a normed additive commutative group, is a normed space over the real numbers, and has a "bump" function that is continuously differentiable, and for any `E` that forms a measurable space, any "bump" function `f` centered at a point `c` in `E`, any measure `μ` on `E`, and any point `x` in `E`, the value of the normalized "bump" function at `x` is equal to the value of `f` at `x` divided by the integral over `E` of `f` with respect to `μ`. In other words, the normalized "bump" function at a point is the ratio of the value of the "bump" function at that point to the "total area" under the "bump" function.

For any normed additive commutative group `E` over the real numbers, with a continuously differentiable "bump" function `f` and a measurable space `(E, μ)`, the normalized bump function `f / ∫(f dμ)` equals the identity function at every point `x` in `E`. (Note: This statement assumes that the integral ∫(f dμ) is non-zero.)


theorem Finset.insert_val_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → (insert a s).val = a ::ₘ s.val := by sorry

The theorem `Finset.insert_val_of_not_mem` asserts that for any type `α` with decidable equality, and for any element `a` of that type and `s` being a finite set of that type, if `a` is not an element of `s`, then the value of the insertion of `a` into `s` equals to the value of `a` prepended to the value of `s`. Here `insert a s` denotes the operation of inserting `a` into the set `s`, and `a ::ₘ s.val` represents the list formed by prepending `a` to the list of elements in `s`.

If `α` has decidable equality, `a` is not an element of finite set `s` in type `α`, then `insert a s = a :: s.val`.


theorem lowerSemicontinuousWithinAt_const :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {x : α} {s : Set α} {z : β},
      LowerSemicontinuousWithinAt (fun _x => z) s x :=
  by sorry

The theorem `lowerSemicontinuousWithinAt_const` states that for any topological space `α`, any preordered set `β`, any element `x` of `α`, any set `s` of `α` and any element `z` of `β`, a function that is constant at `z` is lower semicontinuous at `x` within the set `s`. In mathematical terms, given any `y < z`, for all points `x'` sufficiently close to `x` in `s`, we have `y < z`. This is because the value of the function at any point is always `z`, regardless of where the point is located within the topological space.

For any topological space α, preordered set β, point x in α, set s in α, and constant function f(y) = z from β to ℝ, if x ∈ s then f is lower semicontinuous at x if and only if for all y < z, there exists ε > 0 such that for all x' in s with d(x, x') < ε, we have y ≤ f(x').


theorem Real.differentiableAt_rpow_const_of_ne : ∀ (p : ℝ) {x : ℝ}, x ≠ 0 → DifferentiableAt ℝ (fun x => x ^ p) x := by
  sorry

The theorem `Real.differentiableAt_rpow_const_of_ne` states that for any real number `p` and any real number `x` not equal to zero, the function `f(x) = x^p` (x raised to the power p) is differentiable at `x`. This means that there exists a derivative of the function `f` at the point `x`.

For any real number `p` and non-zero `x`, the function `x => x^p` is differentiable at `x`.


theorem isCoprime_group_smul_left :
    ∀ {R : Type u_1} {G : Type u_2} [inst : CommSemiring R] [inst_1 : Group G] [inst_2 : MulAction G R]
      [inst_3 : SMulCommClass G R R] [inst_4 : IsScalarTower G R R] (x : G) (y z : R),
      IsCoprime (x • y) z ↔ IsCoprime y z :=
  by sorry

The theorem `isCoprime_group_smul_left` states that for any types `R` and `G`, where `R` is a commutative semiring and `G` is a group, and for any scalar multiplication (`MulAction`) of `G` on `R` that commutes (`SMulCommClass`) and forms a scalar tower (`IsScalarTower`), for any elements `x` in `G` and `y`, `z` in `R`, `y` and `z` are coprime if and only if `x` times `y` (denoted as `x • y`) and `z` are coprime. This essentially states the property that the coprimality of `y` and `z` is invariant under the scaling of `y` by any element from the group `G`.

For any commutative semiring `R`, group `G`, and a commuting, scalar tower multiplication action of `G` on `R`, if `x` is an element of `G` and `y`, `z` are coprime elements of `R`, then `x • y` and `z` are coprime.


theorem UpperHalfPlane.im_pos_of_dist_center_le :
    ∀ {z : UpperHalfPlane} {r : ℝ} {w : ℂ},
      dist w ↑(UpperHalfPlane.center z r) ≤ UpperHalfPlane.im z * Real.sinh r → 0 < w.im :=
  by sorry

This theorem states that for any point `z` in the upper half plane, any real number `r`, and any complex number `w`, if the Euclidean distance between `w` and the center of the circle (in the hyperbolic metric) with center `z` and radius `r` is less than or equal to the imaginary part of `z` multiplied by the hyperbolic sine of `r`, then the imaginary part of `w` is positive. This implies that `w` also falls in the upper half plane given certain conditions on its distance from a particular circle's center in the hyperbolic metric.

If the Euclidean distance between a complex number `w` and the center `z` of a hyperbolic circle with radius `r` in the upper half plane is less than or equal to the imaginary part of `z` times the hyperbolic sine of `r`, then the imaginary part of `w` is positive.


/-- If there exists an `a` such that `b = l a`, then `a = u b` is one such element.  -/
theorem GaloisConnection.exists_eq_l :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (b : β), (∃ a, b = l a) ↔ b = l (u b) :=
  by sorry

This theorem states that given a Galois connection, defined by functions `l : α → β` and `u : β → α` between types `α` and `β` with preorder and partial order structures respectively, if there exists an element `a` in `α` such that `b` in `β` is equal to `l a`, then `a` is equal to `u b`. In other words, for any `b` in `β`, there exists an `a` in `α` such that `b` is the image of `a` under `l` if and only if `b` is the image of `u b` under `l`. This characterizes `u b` as a particular 'pre-image' of `b` under `l` in the context of a Galois connection.

In a Galois connection with functions `l : α → β` and `u : β → α`, if `l a = b` implies `a = u b`, then `l` and `u` have mutual inverse images.


theorem Complex.hasStrictDerivAt_cpow_const :
    ∀ {x c : ℂ}, x ∈ Complex.slitPlane → HasStrictDerivAt (fun z => z ^ c) (c * x ^ (c - 1)) x := by sorry

This theorem states that for any complex numbers `x` and `c`, with `x` belonging to the slit plane (the complex plane with the closed negative real axis removed), the function `f(z) = z ^ c` has a strict derivative at the point `x`. The derivative at this point is `c * x ^ (c - 1)`. In other words, the power function with a constant exponent has a strict derivative in the slit complex plane, and the derivative is computed using the standard power rule from calculus.

For complex numbers `x` in the slit complex plane and constant `c`, the function `f(z) = z ^ c` has a strict derivative `deriv f x = c * x ^ (c - 1)`.


theorem ZFSet.mem_inter : ∀ {x y z : ZFSet}, z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y := by sorry

This theorem states that for any three sets `x`, `y`, and `z` in the ZFSet (the universe of Zermelo–Fraenkel set theory), `z` is a member of the intersection of `x` and `y` if and only if `z` is a member of `x` and `z` is a member of `y`. In other words, this theorem formalizes the basic set theory concept that an element belongs to the intersection of two sets precisely when it belongs to both sets.

For any sets x, y in ZFSet, z belongs to the intersection of x and y if and only if z is an element of both x and y.


theorem Primrec.subtype_val :
    ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p] {hp : PrimrecPred p},
      Primrec Subtype.val :=
  by sorry

The theorem `Primrec.subtype_val` establishes that for any type `α` that can be encoded as a natural number (i.e., it satisfies the `Primcodable` class), any decidable predicate `p` on `α`, and under the condition that `p` is a primitive recursive predicate (`PrimrecPred p`), the function `Subtype.val` is also primitive recursive (`Primrec`). In other words, the function that retrieves the underlying element from a subtype defined by the predicate `p` is primitive recursive. This means that there exists a primitive recursive function which, given a natural number encoding of an element of the subtype, returns the natural number encoding of the underlying element of the base type `α`. The theorem asserts the computability property of the subtype extraction operation under specific settings.

The theorem `Primrec.subtype_val` asserts that for any type `α` encodable as a natural number and decidable primitive recursive predicate `p` on `α`, the function `Subtype.val` extracting the underlying element from a subtype defined by `p` is also primitive recursive.


theorem IntermediateField.rank_bot :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E], Module.rank F ↥⊥ = 1 :=
  by sorry

This theorem, named `IntermediateField.rank_bot`, states that for all fields `F` and `E`, where `E` is an algebra over `F`, the rank of the module `F` over the bottom intermediate field (`⊥`) is always equal to 1. The bottom intermediate field is the smallest possible subfield of `E` that contains `F`. The rank of a module, in this context, is a measure of the "size" or "dimensionality" of that module.

For any field extension E over F, the rank of F as a module over the bottom intermediate field is equal to 1.


/-- The empty set is a Lindelof set.  -/
theorem isLindelof_empty : ∀ {X : Type u} [inst : TopologicalSpace X], IsLindelof ∅ := by sorry

This theorem states that the empty set is a Lindelöf set. In more detail, for any type `X` and any topological space on `X`, the empty set satisfies the Lindelöf property. This means that for any nontrivial filter `f` with the countable intersection property, if `f` is included in the principal filter generated by the empty set, then there exists a cluster point in the empty set. However, since the empty set has no elements, the condition on the filter `f` is automatically unsatisfiable, and hence the empty set trivially satisfies the Lindelöf property.

The empty set is a Lindelöf set in any topological space, as its only filter satisfying the countable intersection property is the trivial filter, which has no elements.


theorem IntermediateField.finrank_fixedField_eq_card :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
      (H : Subgroup (E ≃ₐ[F] E)) [inst_3 : FiniteDimensional F E] [inst_4 : DecidablePred fun x => x ∈ H],
      FiniteDimensional.finrank (↥(IntermediateField.fixedField H)) E = Fintype.card ↥H :=
  by sorry

This theorem states that for any field `F`, any field `E` that is an algebra over `F`, and any subgroup `H` of the algebraic automorphisms of `E` over `F`, if `E` is a finite-dimensional vector space over `F` and we can decide whether an element belongs to `H`, then the rank of the intermediate field fixed by `H` as a module over `E` is equal to the number of elements in `H`.

In mathematical terms, if `F` and `E` are fields with `E` being a finite-dimensional field extension of `F`, and `H` is a subgroup of the group of `F`-automorphisms of `E`, then the dimension of the fixed field of `H` over `E` is the same as the cardinality of `H`.

For a finite-dimensional field extension `E` over `F`, the cardinality of a subgroup `H` of `F`-automorphisms of `E` equals the dimension of the fixed field of `H` within `E` as a vector space.


CategoryTheory.CommSq.op

/-- The commutative square in the opposite category associated to a commutative square.  -/
theorem CategoryTheory.CommSq.op :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
      {i : Y ⟶ Z}, CategoryTheory.CommSq f g h i → CategoryTheory.CommSq i.op h.op g.op f.op :=
  by sorry

This theorem states that given a commutative square in a category, there exists an associated commutative square in the opposite category. More specifically, for a category `C` and objects `W`, `X`, `Y`, and `Z` with morphisms `f : W ⟶ X`, `g : W ⟶ Y`, `h : X ⟶ Z`, and `i : Y ⟶ Z` that form a commutative square, the theorem asserts that if these morphisms form a commutative square (which is represented by `CategoryTheory.CommSq f g h i`), then the opposite morphisms `i.op`, `h.op`, `g.op`, and `f.op` also form a commutative square in the opposite category (`CategoryTheory.CommSq i.op h.op g.op f.op`).

Given a commutative square in a category, the opposites of its morphisms form a commutative square in the opposite category.


theorem isOpen_iInter_of_finite :
    ∀ {X : Type u} {ι : Sort w} [inst : TopologicalSpace X] [inst_1 : Finite ι] {s : ι → Set X},
      (∀ (i : ι), IsOpen (s i)) → IsOpen (⋂ i, s i) :=
  by sorry

This theorem, `isOpen_iInter_of_finite`, states that for any type `X` with a given topological space structure, and for any finite index type `ι`, if we have a family of sets `s` indexed by `ι`, then if every set `s i` in this family is open in the topological space `X`, the intersection of all these sets `⋂ i, s i` is also open in `X`. In other words, the intersection of a finite collection of open sets in a topological space is also an open set.

The intersection of a finite collection of open sets in a topological space is open.


theorem Ordinal.lsub_unique :
    ∀ {ι : Type u_4} [inst : Unique ι] (f : ι → Ordinal.{max u_5 u_4}), Ordinal.lsub f = Order.succ (f default) := by
  sorry

The theorem `Ordinal.lsub_unique` states that for any type `ι` which has a unique instance, and any function `f` that maps `ι` to an Ordinal of type `Ordinal.{max u_5 u_4}`, the least strict upper bound of the family of ordinals defined by `f` is equal to the successor of the value of `f` at the default instance of `ι`. In mathematical terms, if we have a unique element from a type `ι` and a function `f` mapping this element to an ordinal, the least strict upper bound of the set of ordinals generated by `f` is just the successor of the ordinal `f` maps the unique element to.

If `ι` has a unique instance and `f : ι → Ordinal` is a function, then the least upper bound of the image of `f` is the successor of `(f! default)`, where `default` is the default instance of `ι`.


/-- Postcomposing by a monomorphism does not change the kernel subobject.  -/
theorem CategoryTheory.Limits.kernelSubobject_comp_mono :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f]
      {Z : C} (h : Y ⟶ Z) [inst_3 : CategoryTheory.Mono h],
      CategoryTheory.Limits.kernelSubobject (CategoryTheory.CategoryStruct.comp f h) =
        CategoryTheory.Limits.kernelSubobject f :=
  by sorry

The theorem `CategoryTheory.Limits.kernelSubobject_comp_mono` states that in any category `C` that has zero morphisms, for any morphisms `f` from `X` to `Y`, and `h` from `Y` to `Z`, where `f` has a kernel and `h` is a monomorphism, the kernel subobject of the composition of `f` and `h` (denoted `f ≫ h`) is the same as the kernel subobject of `f`. In other words, post-composing by a monomorphism doesn't change the kernel subobject.

In a zero-object category with kernel subobjects, the kernel of a composition of a morphism with a monomorphism is equal to the kernel of the morphism.


theorem Cardinal.cast_toNat_of_lt_aleph0 : ∀ {c : Cardinal.{u_1}}, c < Cardinal.aleph0 → ↑(Cardinal.toNat c) = c := by
  sorry

This theorem states that for any cardinal number `c`, if `c` is less than `ℵ₀` (the smallest infinite cardinal), the natural number obtained by converting `c` using the `Cardinal.toNat` function actually equals `c` itself. In other words, the `Cardinal.toNat` function effectively acts as an identity for finite cardinal numbers less than `ℵ₀`.

For any finite cardinal number `c` less than `ℵ₀`, the function `Cardinal.toNat` maps `c` to itself.


theorem left_neg_eq_right_neg : ∀ {M : Type u} [inst : AddMonoid M] {a b c : M}, b + a = 0 → a + c = 0 → b = c := by
  sorry

This theorem states that for any type `M` which is an additive monoid and any three elements `a`, `b`, and `c` of type `M`, if the sum of `b` and `a` is zero, and the sum of `a` and `c` is also zero, then `b` must be equal to `c`. In other words, if two different pairs of elements from the monoid add up to zero and they share a common element, that common element acts as a sort of "balancer" causing the other elements in the pairs to be equal. This is a property specific to the structure of additive monoids.

In an additive monoid, if the sum of two elements is zero with a common element, then the elements are equal.


IntervalIntegrable.add

theorem IntervalIntegrable.add :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f g : ℝ → E} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b → IntervalIntegrable g μ a b → IntervalIntegrable (fun x => f x + g x) μ a b :=
  by sorry

The theorem `IntervalIntegrable.add` states that, for any normed additive commutative group `E`, if two real-valued functions `f` and `g` are both interval integrable with respect to a measure `μ` on an unordered interval from `a` to `b`, then their pointwise sum `(fun x => f x + g x)` is also interval integrable on the same interval with respect to the same measure. This means that the property of being interval integrable is closed under the operation of pointwise addition of functions.

If `f` and `g` are interval integrable functions on an unordered interval `[a, b]` with respect to a measure `μ` over a normed additive commutative group `E`, then their pointwise sum `f + g` is also interval integrable on `[a, b]` with respect to `μ`.


/-- The `atTop` filter for an open interval `Ici a` comes from the `atTop` filter in the ambient
order.  -/
theorem Filter.atTop_Ici_eq :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] (a : α), Filter.atTop = Filter.comap Subtype.val Filter.atTop := by sorry

The theorem `Filter.atTop_Ici_eq` states that for any type `α` that has a semilattice structure, and any element `a : α`, the `atTop` filter for the open interval `Ici a` (which is the set of all elements that are greater than or equal to `a`) is the same as the `atTop` filter of the whole `α` type but viewed through the mapping 'Subtype.val'. Here, `Subtype.val` is a function that takes an element from a subtype and returns its underlying element in the base type. This theorem essentially says that the "going to infinity" behavior in the subset `Ici a` mirrors the "going to infinity" behavior in the whole set, when we relate elements of the subset to elements of the whole set via the natural inclusion mapping given by `Subtype.val`.

For any semilattice type `α` and element `a : α`, the `atTop` filter of the open interval `Ici a` equals the `atTop` filter of `α` restricted to the elements greater than or equal to `a`.


theorem Profinite.NobelingProof.ord_term :
    ∀ {I : Type u} [inst : LinearOrder I] [inst_1 : IsWellOrder I fun x x_1 => x < x_1] {o : Ordinal.{u}}
      (ho : o < Ordinal.type fun x x_1 => x < x_1) (i : I),
      Profinite.NobelingProof.ord I i = o ↔ Profinite.NobelingProof.term I ho = i :=
  by sorry

The theorem `Profinite.NobelingProof.ord_term` establishes a bijective correspondence between terms of type `I` and ordinals less than the order type of `I`. Specifically, for any type `I` with a linear order and a well-order, and any ordinal `o` less than the order type of `I`, the ordinal representation `Profinite.NobelingProof.ord I i` of a term `i` of `I` is equal to `o` if and only if the term `Profinite.NobelingProof.term I ho` associated with `o` is equal to `i`. In other words, `Profinite.NobelingProof.ord` and `Profinite.NobelingProof.term` are inverse operations, and the type `I` can be bijectively mapped onto the ordinals less than its order type.

The function `Profinite.NobelingProof.ord` and its inverse `Profinite.NobelingProof.term` establish a bijective correspondence between the ordinals less than the order type of a linearly ordered and well-ordered type `I` and its terms.


theorem Polynomial.coe_aeval_eq_eval :
    ∀ {R : Type u} [inst : CommSemiring R] (r : R), ⇑(Polynomial.aeval r) = Polynomial.eval r := by sorry

This theorem states that for any given commutative semiring R and an element r of the semiring, the algebra homomorphism created by applying the polynomial `aeval` function to r is equivalent to simply evaluating the polynomial at r using the `eval` function. In more technical terms, it asserts that in the context of a commutative semiring, the map induced by the `aeval` function and the result of the `eval` function are the same.

For any commutative semiring R and element r, the homomorphism induced by the `aeval` function of polynomial evaluation equals the result of directly evaluating the polynomial at r.


theorem CategoryTheory.ShortComplex.LeftHomologyData.exact_iff_epi_f' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S]
      (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Epi (CategoryTheory.ShortComplex.LeftHomologyData.f' h) :=
  by sorry

This theorem states that for any category `C` that is preadditive and any short complex `S` in `C` that has homology, given a left homology data `h` of `S`, the short complex `S` is exact if and only if the morphism `f'` in the left homology data `h` is an epimorphism. Here, a category is preadditive if it has a binary operation that is both associative and commutative, a short complex is a certain type of diagram in the category, homology is a type of mathematical object, 'exact' is a property of such diagrams, a left homology data is a specific type of mathematical structure associated with the diagram, and an epimorphism is a type of morphism in a category.

In a preadditive category with homology, a short complex is exact if and only if the corresponding morphism in its left homology data is an epimorphism.


theorem Pi.single_op :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] {g : I → Type u_4}
      [inst_2 : (i : I) → Zero (g i)] (op : (i : I) → f i → g i),
      (∀ (i : I), op i 0 = 0) → ∀ (i : I) (x : f i), Pi.single i (op i x) = fun j => op j (Pi.single i x j) :=
  by sorry

This theorem, `Pi.single_op`, states that for any type `I`, any function `f` from `I` to a type, any function `g` from `I` to a type, under the assumption that `I` has decidable equality and each type that `f` and `g` maps to has a zero value, given an operator `op` which operates on each element of `I` and its corresponding value under `f` to produce a value of type under `g`. If this operator applied to any element of `I` and zero gives zero, then for all elements `i` of `I` and all `x` in the image of `f`, the function supported at `i` with value `op i x` there, and `0` elsewhere, equals to the function which maps each element `j` of `I` to `op j` applied to the function supported at `i` with value `x` there, and `0` elsewhere. In other words, the operator `op` can be distributed over the function supported at a single point.

If `I` is a decidably equal type, `f: I -> T`, `g: I -> U`, `op: I -> T -> U`, and for all `i` in `I` and `x` in `Imap f`, `op i x = op i 0`, then for all `i` in `I` and `x` in `Imap f`, `op i x = (op i) . (map (const x) . pointwise (const i) . f) 0`.


theorem Nat.prod_primeFactors_dvd : ∀ (n : ℕ), (Finset.prod n.primeFactors fun p => p) ∣ n := by sorry

The theorem `Nat.prod_primeFactors_dvd` states that for any natural number `n`, the product of its prime factors divides `n`. Here, `n.primeFactors` represents the set of prime factors of `n` and `Finset.prod` is used to compute the product of these factors. The statement is pretty much a formalized version of the fundamental theorem of arithmetic, which says that every integer greater than 1 can be uniquely written as a product of prime numbers.

For any natural number $n$, the product of $n$'s prime factors is a divisor of $n$.


AlgEquiv.isAlgebraic

/-- Transfer `Algebra.IsAlgebraic` across an `AlgEquiv`.  -/
theorem AlgEquiv.isAlgebraic :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u_2}
      [inst_3 : Ring B] [inst_4 : Algebra R B], (A ≃ₐ[R] B) → Algebra.IsAlgebraic R A → Algebra.IsAlgebraic R B :=
  by sorry

The theorem `AlgEquiv.isAlgebraic` states that the property of being algebraic is preserved under an algebraic equivalence. Specifically, for any types `R`, `A` and `B` where `R` is a commutative ring, `A` and `B` are rings, `A` is an `R`-algebra and `B` is an `R`-algebra, if there exists an algebraic equivalence between `A` and `B`, and if `A` is algebraic over `R`, then `B` is also algebraic over `R`. In other words, if every element of `A` is the root of some polynomial with coefficients in `R`, then under an algebraic equivalence, every element of `B` will also be the root of some polynomial with coefficients in `R`.

If `A` and `B` are `R`-algebras with an algebraic equivalence between them, and `A` is algebraic over `R`, then `B` is also algebraic over `R`.


/-- Characterizing uniformities associated to a (generalized) distance function `D`
in terms of the elements of the uniformity.  -/
theorem uniformity_dist_of_mem_uniformity :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {U : Filter (α × α)} (z : β) (D : α → α → β),
      (∀ (s : Set (α × α)), s ∈ U ↔ ∃ ε > z, ∀ {a b : α}, D a b < ε → (a, b) ∈ s) →
        U = ⨅ ε, ⨅ (_ : ε > z), Filter.principal {p | D p.1 p.2 < ε} :=
  by sorry

This theorem, `uniformity_dist_of_mem_uniformity`, characterizes the uniformities associated to a generalized distance function `D` in terms of the elements of the uniformity. It states that for any types `α` and `β`, where `β` is a linear order, and for any filter `U` on the product `α × α`, along with a given value `z` of type `β` and a distance function `D` mapping pairs of elements of `α` to `β`, if for every set `s` of pairs of `α`, `s` is in `U` if and only if there exists a `ε` greater than `z` such that for all pairs `(a, b)` of `α`, if `D(a, b)` is less than `ε` then `(a, b)` belongs to `s`, then `U` is equal to the infimum over all `ε` greater than `z` of the principal filter of the set of pairs `(p.1, p.2)` such that `D(p.1, p.2)` is less than `ε`. This theorem thus relates the structure of the filter `U` with the properties of the distance function `D`.

Given a filter U on the product α × α, a linear order β, a value z in β, and a distance function D from α to β, U is the infimum over all ε > z of the principal filters of pairs (p.1, p.2) with D(p.1, p.2) < ε if and only if for every set s of pairs of α, s is in U if and only if there exists an ε > z such that for all (a, b) in α × α with D(a, b) < ε, (a, b) is in s.


Filter.Tendsto.rpow

theorem Filter.Tendsto.rpow :
    ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ} {x y : ℝ},
      Filter.Tendsto f l (nhds x) →
        Filter.Tendsto g l (nhds y) → x ≠ 0 ∨ 0 < y → Filter.Tendsto (fun t => f t ^ g t) l (nhds (x ^ y)) :=
  by sorry

The theorem `Filter.Tendsto.rpow` states that for any type `α` and a filter `l` on it, along with two functions `f` and `g` from `α` to real numbers `ℝ`, and two real numbers `x` and `y`; if `f` tends to `x` according to the filter `l` and `g` tends to `y` according to the same filter, and if either `x` is not zero or `y` is positive, then the function that maps any element `t` of `α` to the real number `f(t) ^ g(t)` will also tend to `x ^ y` according to the filter `l`.

In simpler terms, this theorem deals with the limit of a function that raises one function (`f`) to the power of another function (`g`). If the individual functions `f` and `g` converge to `x` and `y` respectively, then under some conditions on `x` and `y`, the combined function will converge to `x ^ y`.

If filters `l` on `α` make functions `f : α → ℝ` and `g : α → ℝ` tend to limit values `x` and `y` respectively, and `x` is nonzero or `y` is positive, then the function `t ↦ f(t) ^ g(t)` tends to the limit `x ^ y` according to `l`.


theorem sub_lt_sub_right :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      a < b → ∀ (c : α), a - c < b - c :=
  by sorry

This theorem, `sub_lt_sub_right`, states that for all types `α` that are additive groups and have a less-than operation `<` and satisfy the covariance property with respect to addition and `<`, given any two elements `a` and `b` of the type `α` where `a` is less than `b`, for any element `c` of the type `α`, the subtraction of `c` from `a` is less than the subtraction of `c` from `b`. It basically asserts that if `a` is less than `b`, then `a - c` is less than `b - c` for all `c` in an additive group with a well-defined less-than operation satisfying certain covariance conditions.

For all additive groups with a well-defined less-than operation satisfying covariance conditions, if `a < b`, then `a - c < b - c` for all `c` in the group.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.13 :
    ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s t : Set α}, (-s ⊆ -t) = (s ⊆ t) := by sorry

This theorem states that for every type `α` that has an operation of involution through negation, given any two sets `s` and `t` of type `α`, the statement that the negated set `-s` is a subset of the negated set `-t` is equivalent to the statement that the original set `s` is a subset of the original set `t`. This holds true regardless of the specific elements within the sets `s` and `t`.

For any type `α` with negation involution, sets `s` and `t` of type `α`, the sets `-s` and `-t` are equal if and only if `s` is a subset of `t`.


/-- A group homomorphism (a bundled morphism of a type that implements `MonoidHomClass`) between
two uniform groups is uniformly continuous provided that it is continuous at one. See also
`continuous_of_continuousAt_one`.  -/
theorem uniformContinuous_of_continuousAt_one :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α]
      {hom : Type u_3} [inst_3 : UniformSpace β] [inst_4 : Group β] [inst_5 : UniformGroup β] [inst_6 : FunLike hom α β]
      [inst_7 : MonoidHomClass hom α β] (f : hom), ContinuousAt (⇑f) 1 → UniformContinuous ⇑f :=
  by sorry

The theorem `uniformContinuous_of_continuousAt_one` states that for any two uniform groups `α` and `β`, a group homomorphism between them is uniformly continuous if it is continuous at the identity element. This means that the morphism maintains a consistent distance between close elements in the domain and their images under the morphism in the target, regardless of their position in the groups, as long as the morphism is continuous at the identity element. This theorem is a concrete application of uniform continuity in the context of group theory.

A group homomorphism between uniform groups is uniformly continuous if it is continuous at the identity element.


theorem AddCommGroup.tfae_modEq :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      List.TFAE
        [a ≡ b [PMOD p], ∀ (z : ℤ), b - z • p ∉ Set.Ioo a (a + p), toIcoMod hp a b ≠ toIocMod hp a b,
          toIcoMod hp a b + p = toIocMod hp a b] :=
  by sorry

The theorem `AddCommGroup.tfae_modEq` states that for any type `α` which forms a linear ordered additive commutative group and has the Archimedean property, and given any `p` in `α` such that `p` is greater than 0, and any `a` and `b` in `α`, the following propositions are equivalent:

1. `a` is congruent to `b` modulo `p`.
2. For any integer `z`, the difference `b - z*p` is not in the open interval `(a, a + p)`.
3. The result of reducing `b` to the left-closed right-open interval `[a, a + p)` by subtracting an appropriate multiple of `p` is not equal to the result of reducing `b` to the open interval `(a, a + p]` by subtracting an appropriate multiple of `p`.
4. The result of reducing `b` to the left-closed right-open interval `[a, a + p)` by subtracting an appropriate multiple of `p` plus `p` is equal to the result of reducing `b` to the open interval `(a, a + p]` by subtracting an appropriate multiple of `p`.

For any element `p` in a linearly ordered, additively commutative group `α` with the Archimedean property, and for all `a`, `b` in `α`, the statements "`a` is congruent to `b` modulo `p`" are equivalent to "the difference `b - p*z` is not in the open interval `(a, a + p)` for any integer `z`."


theorem Cardinal.nat_mul_aleph0 : ∀ {n : ℕ}, n ≠ 0 → ↑n * Cardinal.aleph0 = Cardinal.aleph0 := by sorry

This theorem states that for any natural number `n`, as long as `n` is not equal to zero, the product of `n` and the smallest infinite cardinal number (denoted as `\aleph_0` or aleph-null) is equal to `aleph_0`. Here, `aleph_0` represents the cardinality of the set of natural numbers. This is essentially saying that multiplying any nonzero natural number with the size of an infinite set (like the set of Natural numbers) still gives an infinite set of the same size.

For any nonzero natural number `n`, the product of `n` and the cardinality of the set of natural numbers (denoted as `\aleph_0`) equals `\aleph_0`.


theorem ENNReal.sub_mul : ∀ {a b c : ENNReal}, (0 < b → b < a → c ≠ ⊤) → (a - b) * c = a * c - b * c := by sorry

This theorem states that for any three extended nonnegative real numbers `a`, `b`, and `c`, given that `b` is positive and less than `a`, and `c` is not infinity, the multiplication of the difference between `a` and `b` with `c` is equal to the difference of the product of `a` and `c` and the product of `b` and `c`. In mathematical terms, it asserts that if `0 < b < a` and `c ≠ ∞`, then `(a - b) * c = a * c - b * c`. This is akin to the property of distributivity of multiplication over subtraction, extended to include nonnegative real numbers and infinity.

For non-negative real numbers `a`, `b`, and `c` with `0 < b < a` and `c neq ∞`, we have `(a - b) * c = a * c - b * c`.


theorem MeasureTheory.measure_iUnion_null :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : Countable ι]
      {s : ι → Set α}, (∀ (i : ι), ↑↑μ (s i) = 0) → ↑↑μ (⋃ i, s i) = 0 :=
  by sorry

The theorem `MeasureTheory.measure_iUnion_null` states that for any type `α` and an indexed type `ι`, given a measurable space over `α`, a measure `μ` on that measurable space, and a countable index set `ι`, if we have a family of sets `s : ι → Set α` such that the measure of each individual set in the family is zero, then the measure of the countable union of these sets is also zero. In mathematical terms, if for all `i` in `ι`, the measure of `s(i)` is zero, then the measure of the union over all `i` in `ι` of `s(i)` is also zero.

If `(α, Σ, μ)` is a measurable space, `ι` is a countable index set, and for all `i ∈ ι`, `μ(s i) = 0`, then `μ(⋃ i ∈ ι s i) = 0`.


theorem imageToKernel'.proof_1 :
    ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      {A B C : V} (f : A ⟶ B) (g : B ⟶ C) [inst_2 : CategoryTheory.Limits.HasKernels V]
      [inst_3 : CategoryTheory.Limits.HasImages V],
      CategoryTheory.CategoryStruct.comp f g = 0 →
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f) g = 0 :=
  by sorry

This theorem states that for any category `V` that has zero morphisms, kernels, and images, given three objects `A`, `B`, and `C` in `V` and two morphisms `f: A ⟶ B` and `g: B ⟶ C`, if the composition of `f` and `g` is a zero morphism (i.e., `f ≫ g = 0`), then the composition of the inclusion of the image of `f` into `B` and `g` is also a zero morphism (i.e., `(CategoryTheory.Limits.image.ι f) ≫ g = 0`). Here, `CategoryTheory.Limits.image.ι f` represents the morphism that includes the image of `f` into `B`.

If `f: A ➔ B` and `g: B ➔ C` are morphisms in a category with zero morphisms, kernels, and images, and `f ∘ g = 0`, then `(image.ι f) ∘ g = 0`.


theorem Subgroup.characteristic_iff_comap_le :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G},
      Subgroup.Characteristic H ↔ ∀ (ϕ : G ≃* G), Subgroup.comap (MulEquiv.toMonoidHom ϕ) H ≤ H :=
  by sorry

This theorem states that for any group 'G' and subgroup 'H' of 'G', the subgroup 'H' is characteristic if and only if for every bijective multiplication-preserving function 'ϕ' from 'G' to 'G' (also known as a group automorphism), the preimage of 'H' under the group homomorphism induced by 'ϕ' is a subset of 'H'. In other words, a subgroup is characteristic if it is invariant under any automorphism of the group.

A subgroup of a group is characteristic if and only if it is mapped to itself under every group automorphism.


theorem Mathlib.Algebra.BigOperators.Intervals._auxLemma.1 :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : Fintype α] [inst_2 : LocallyFiniteOrderTop α]
      [inst_3 : LocallyFiniteOrderBot α] (a : α), {a}ᶜ = Finset.disjUnion (Finset.Ioi a) (Finset.Iio a) ⋯ :=
  by sorry

This theorem states that for any type `α` that has a linear order, is a finite type, and has locally finite orders at the top and bottom, the complement of the singleton set `{a}` (i.e., the set of all elements in `α` except `a`) is the disjoint union of the set of elements greater than `a` (`Finset.Ioi a`) and the set of elements less than `a` (`Finset.Iio a`). In other words, any element not in `{a}` is either greater than `a` or less than `a`, and these two sets do not overlap.

For any finite, locally ordered type `α` with finite orders at the top and bottom, the complement of a singleton set is the disjoint union of the elements greater than the element in the set and the elements less than it.


theorem QuotientAddGroup.ker_mk' :
    ∀ {G : Type u} [inst : AddGroup G] (N : AddSubgroup G) [nN : AddSubgroup.Normal N],
      AddMonoidHom.ker (QuotientAddGroup.mk' N) = N :=
  by sorry

The theorem `QuotientAddGroup.ker_mk'` states that for any additive group `G` and any normal subgroup `N` of `G`, the kernel of the additive group homomorphism from `G` to the quotient group `G/N` is equal to `N`. Here, the kernel of a homomorphism is the subgroup of elements that are mapped to the identity element (zero in the case of additive groups). This theorem is essentially saying that the elements that get mapped to zero in the quotient group are exactly the elements of the subgroup `N`.

The kernel of the additive group homomorphism from a group G to its quotient by a normal subgroup N equals N.


theorem Filter.Tendsto.atTop_zsmul_const :
    ∀ {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [inst : LinearOrderedAddCommGroup R] [inst_1 : Archimedean R]
      {f : α → ℤ}, 0 < r → Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => f x • r) l Filter.atTop :=
  by sorry

The theorem `Filter.Tendsto.atTop_zsmul_const` states that for any types `α` and `R`, a filter `l` on `α`, an integer-valued function `f` from `α` to `ℤ`, and a constant `r` in a linearly ordered additive commutative group `R` that is also Archimedean, if `r` is positive and `f` tends to infinity with respect to `l` (i.e., for any `ℤ` that is greater than a certain value, there exists an element in the filter such that `f` of that element is greater than that `ℤ`), then `f` scaled by `r` (i.e., the function `x ↦ f(x) * r`) also tends to infinity with respect to `l`. This essentially means that multiplying a function that tends to infinity by a positive constant does not change its limit behavior.

If `f` is a function from a filter `l` on type `α` to `ℤ` that tends to infinity with respect to `l`, and `r` is a positive constant in an Archimedean, additively commutative group `R`, then the function `x ↦ f(x) * r` also tends to infinity with respect to `l`.


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

The theorem `Mathlib.Algebra.BigOperators.Intervals._auxLemma.3` asserts that for any type `α`, any decidable predicate `p` on `α`, any finite set `s` of type `α`, and any element `a` of type `α`, the element `a` belongs to the set `s` filtered by the predicate `p` if and only if `a` belongs to the set `s` and `a` satisfies the predicate `p`. In other words, filtering a finite set by a predicate produces a new set of elements that originally belong to the set and satisfy the predicate.

For any type `α`, finite set `s` of `α`, decidable predicate `p` on `α`, and `a` in `s`, `a` is in the set `s` with filter `p` if and only if `a` is in `s` and satisfies `p`.


theorem EMetric.mem_ball_self :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {ε : ENNReal}, 0 < ε → x ∈ EMetric.ball x ε := by sorry

The theorem `EMetric.mem_ball_self` states that, for any pseudo extended metric space `α`, any point `x` in `α`, and any extended nonnegative real number `ε` greater than zero, `x` is an element of the ball of radius `ε` centered at `x`. In other words, it asserts that in any such metric space, each point belongs to the open ball centered at itself, provided the radius of that ball is greater than zero. This is a fundamental property of metric spaces, reflecting the idea that a ball can be thought of as including all points within a certain "distance" from its center.

For any pseudo extended metric space and any point with positive distance from itself, that point belongs to the open ball of that radius centered at itself.


theorem IntermediateField.adjoin_algebraic_toSubalgebra :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {S : Set E},
      (∀ x ∈ S, IsAlgebraic F x) → (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S :=
  by sorry

This theorem states that for any set `S` of elements from a field extension `E` over a field `F` where every element of `S` is algebraic over `F`, the subalgebra obtained by adjoining `S` to `F` using the intermediate field construction (`IntermediateField.adjoin`) is equal to the subalgebra obtained by adjoining `S` to `F` using the algebra construction (`Algebra.adjoin`). In simpler terms, this theorem asserts the equality of two different methods of extending a field by adjoining a set of algebraic elements.

For any set `S` of algebraic elements over a field `F` in a field extension `E`, the subalgebras obtained by intermediately extending `F` with `S` and by directly extending `F` with `S` using the algebra construction are equal.


theorem Rel.swap_mem_interedges_iff :
    ∀ {α : Type u_4} {r : α → α → Prop} [inst : DecidableRel r] {s t : Finset α},
      Symmetric r → ∀ {x : α × α}, Prod.swap x ∈ Rel.interedges r s t ↔ x ∈ Rel.interedges r t s :=
  by sorry

This theorem states that, for any type `α` and a decidable relation `r` on `α`, given two finite sets `s` and `t` of type `α`, if `r` is symmetric, then for any pair of elements `x` of type `α`, the pair `x` is in the set of interedges of `r` between `t` and `s` if and only if the swapped pair of `x` is in the set of interedges of `r` between `s` and `t`. Here, "interedges" refers to a set of all pairs `(a, b)` from `s` and `t` respectively such that `a` is related to `b` under the relation `r`. The "swapped" of a pair `(a, b)` is the pair `(b, a)`. The symmetry of the relation `r` is crucial for this theorem, implying that if `a` is related to `b`, then `b` is also related to `a`.

For any finite sets `s` and `t` of a type `α` with a decidable, symmetric relation `r`, the set of interedges between `s` and `t` is equal to the set of swapped interedges between `s` and `t`.


SetTheory.PGame.Subsequent.moveLeft

theorem SetTheory.PGame.Subsequent.moveLeft :
    ∀ {x : SetTheory.PGame} (i : SetTheory.PGame.LeftMoves x),
      SetTheory.PGame.Subsequent (SetTheory.PGame.moveLeft x i) x :=
  by sorry

This theorem states that for any game `x` in set theory and any allowable move `i` by the Left player in that game, the game that results after the Left player makes move `i` is 'Subsequent' to the original game `x`. In other words, the new game can be obtained from the original game `x` by playing some nonempty sequence of moves. This sequence in our case is just the single move `i` by the Left player.

For any game `x` and allowable move `i` by the Left player, the game obtained by making move `i` is a subsequence of the original game `x`. (Note: In Lean, this would be expressed as a definition or proposition stating that the relation of being a subsequence holds between the games.)


theorem OpenEmbedding.continuousAt_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      OpenEmbedding f → ∀ {x : X}, ContinuousAt (g ∘ f) x ↔ ContinuousAt g (f x) :=
  by sorry

This theorem states that for all topological spaces `X`, `Y`, and `Z`, and for all functions `f : X → Y` and `g : Y → Z`, if `f` is an open embedding, then the composition of `g` and `f` is continuous at a point `x` in `X` if and only if `g` is continuous at the point `f(x)` in `Y`. An open embedding is a function that is both injective and open, meaning that it bijectively maps open sets to open sets. Continuity of a function at a point refers to the property that the value of the function at that point is close to the values of the function at nearby points.

For all topological spaces X, Y, Z, functions f : X → Y and g : Y → Z, if f is an open embedding then g ∘ f is continuous at x ∈ X if and only if g is continuous at f(x) ∈ Y.


theorem Subgroup.characteristic_iff_comap_eq :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G},
      Subgroup.Characteristic H ↔ ∀ (ϕ : G ≃* G), Subgroup.comap (MulEquiv.toMonoidHom ϕ) H = H :=
  by sorry

This theorem states that for any group `G` and any subgroup `H` of `G`, `H` is characteristic if and only if, for every multiplicative equivalence `ϕ` from `G` to itself, the preimage of `H` under the monoid homomorphism associated with `ϕ` is equal to `H`. In other words, a subgroup `H` of a group `G` is characteristic if and only if it remains unchanged under any automorphism of `G`.

A subgroup of a group is characteristic if and only if it is mapped to itself under every automorphism of the group.


theorem MeasureTheory.isFiniteMeasure_withDensity :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      ∫⁻ (a : α), f a ∂μ ≠ ⊤ → MeasureTheory.IsFiniteMeasure (μ.withDensity f) :=
  by sorry

The theorem `MeasureTheory.isFiniteMeasure_withDensity` states that for any type `α`, any measurable space `m0` on `α`, any measure `μ` on this measurable space, and any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if the integral from minus infinity to infinity of `f(a)` with respect to `μ` is not equal to infinity, then the measure `μ` with density `f` is a finite measure. In simpler terms, if the total "weight" assigned by `f` to the elements in `α` under the measure `μ` is finite, then the measure `μ` when "reweighted" by `f` is also finite.

If a measurable function `f` from a measurable space `(α, m0)` to the extended nonnegative real numbers has finite integral with respect to a measure `μ` on `α`, then the measure `μ` with density `f` is a finite measure.


theorem aeSeq.aeSeq_eq_fun_of_mem_aeSeqSet :
    ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {f : ι → α → β} {μ : MeasureTheory.Measure α} {p : α → (ι → β) → Prop} (hf : ∀ (i : ι), AEMeasurable (f i) μ)
      {x : α}, x ∈ aeSeqSet hf p → ∀ (i : ι), aeSeq hf p i x = f i x :=
  by sorry

The theorem `aeSeq.aeSeq_eq_fun_of_mem_aeSeqSet` states that for all indices `ι`, real numbers `α`, and real numbers `β` (where `α` and `β` have defined measurable spaces), given a function `f : ι → α → β`, a measure `μ : MeasureTheory.Measure α`, and a property `p : α → (ι → β) → Prop`, if all functions `f i` are almost everywhere measurable with measure `μ`, then for all `x : α` in the set `aeSeqSet hf p`, the function `aeSeq hf p i` equals `f i` at `x`. In simpler terms, this theorem says that in a sequence of almost everywhere measurable functions that equal `f` and satisfy property `p` on a given measurable set, any function in that sequence equals `f` at every point in that set.

Given a measurable space `(α, Σ, μ)`, a function `f : ι → α → β`, and a property `p : α → (ι → β) → Prop`, if all functions `f i` are almost everywhere measurable with respect to `μ` and for all `x ∈ aeSeqSet hf p`, we have `aeSeq hf p i x = f i x`, where `hf` is a hypothesis proving `i` is almost everywhere defined by `p` with respect to `μ`.


theorem Subgroup.commutator_le_right :
    ∀ {G : Type u_1} [inst : Group G] (H₁ H₂ : Subgroup G) [h : Subgroup.Normal H₂], ⁅H₁, H₂⁆ ≤ H₂ := by sorry

This theorem states that for any given type `G` that forms a group, and given two subgroups `H₁` and `H₂` of `G`, if `H₂` is a normal subgroup of `G`, then the commutator subgroup generated by `H₁` and `H₂` is a subset of `H₂`. Here, `⁅H₁, H₂⁆` represents the commutator subgroup generated by `H₁` and `H₂`, and the sign `≤` denotes subgroup inclusion.

If `H₁` and `H₂` are subgroups of a group `G` with `H₂` normal in `G`, then `⁅H₁, H₂⁆ ≤ H₂`.


theorem CategoryTheory.MorphismProperty.inverseImage_equivalence_inverse_eq_map_functor :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D),
      CategoryTheory.MorphismProperty.RespectsIso P →
        ∀ (E : C ≌ D),
          CategoryTheory.MorphismProperty.inverseImage P E.functor = CategoryTheory.MorphismProperty.map P E.inverse :=
  by sorry

This theorem states that, for any two categories `C` and `D`, and for a property `P` that applies to morphisms in `D` and respects isomorphisms, the inverse image of the property `P` under the functor from `C` to `D` is the same as the image of the property `P` under the inverse of the equivalence from `C` to `D`. In other words, under the conditions of this theorem, taking the inverse image with respect to a functor and taking the image with respect to the inverse functor yield the same morphism property in `C`.

For any functors F : C -> D and G : D -> C between categories, and property P on D that is invariant under isomorphism, the inverse image of P under F is equal to the image of P under G^(-1).


theorem List.unzip_zip :
    ∀ {α : Type u} {β : Type u_1} {l₁ : List α} {l₂ : List β},
      List.length l₁ = List.length l₂ → List.unzip (List.zip l₁ l₂) = (l₁, l₂) :=
  by sorry

This theorem, `List.unzip_zip`, states that for any two lists `l₁` and `l₂` of arbitrary types `α` and `β` respectively, if `l₁` and `l₂` have the same length, then if we zip these two lists together to form a list of pairs and subsequently unzip it, we will get back the original lists `l₁` and `l₂`. In other words, the operations of zipping and unzipping are inverses of each other given the precondition that the lists being zipped have the same length.

For any lists `l₁ : List α` and `l₂ : List β` of equal length, `List.zip (List.unzip (List.zip l₁ l₂)) = (l₁, l₂)` and `List.zip (List.unzip pairs) = pairs` for some `pairs : List (α × β)`.


theorem Filter.cofinite.blimsup_set_eq :
    ∀ {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → Set α},
      Filter.blimsup s Filter.cofinite p = {x | Set.Infinite {n | p n ∧ x ∈ s n}} :=
  by sorry

The theorem `Filter.cofinite.blimsup_set_eq` states that for any types `α` and `ι`, any predicate `p` over `ι`, and any function `s` from `ι` to a set of `α`, the bounded limit superior (blimsup) of the function `s` along the cofinite filter and bounded by the predicate `p` is equal to the set of `x` such that the set of `n` for which `p n` holds and `x` is in `s n` is infinite. In other words, the theorem describes a connection between the concept of blimsup along the cofinite filter and the condition of an infinite set within the context of a predicate and a function to sets.

The theorem `Filter.cofinite.blimsup_set_eq` asserts that the bounded limit superior of a function from an index set to a type along the cofinite filter is equal to the set of elements in the image of the function for which the index set restricted to the satisfying indices forms an infinite set with respect to the given predicate.


theorem Multiset.count_eq_one_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α},
      Multiset.Nodup s → a ∈ s → Multiset.count a s = 1 :=
  by sorry

The theorem `Multiset.count_eq_one_of_mem` states that for any type `α` with decidable equality, any element `a` of type `α`, and any multiset `s` of type `α`, if the multiset `s` has no duplicates (i.e., every element appears at most once), and the element `a` is an element of `s`, then the multiplicity of `a` in `s` (i.e., the number of times `a` appears in `s`) is exactly 1. In other words, each element of a duplicate-free multiset appears exactly once.

If `α` is a type with decidable equality, `a` is an element of a multiset `s` of type `α` with no duplicates, then the multiplicity of `a` in `s` is equal to 1.


theorem Polynomial.eval_neg :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (x : R), Polynomial.eval x (-p) = -Polynomial.eval x p := by sorry

The theorem `Polynomial.eval_neg` states that for all rings `R`, for any polynomial `p` of `R`, and for any element `x` from `R`, the evaluation of the negation of the polynomial `p` at `x` is equal to the negation of the evaluation of the polynomial `p` at `x`. In mathematical terms, this can be written as \(-p(x) = -f(x)\), where \(p(x)\) is the evaluation of the polynomial function \(f\) at \(x\).

For all rings R, polynomials p of R, and elements x of R, -(p x) = -(px).


theorem Commute.div_add_div :
    ∀ {α : Type u_1} [inst : DivisionSemiring α] {a b c d : α},
      Commute b c → Commute b d → b ≠ 0 → d ≠ 0 → a / b + c / d = (a * d + b * c) / (b * d) :=
  by sorry

The theorem `Commute.div_add_div` states that for any division semiring `α` and any elements `a`, `b`, `c`, and `d` of `α`, if `b` commutes with `c` and `b` also commutes with `d`, and both `b` and `d` are non-zero, then the value of the sum `a / b + c / d` is equal to `(a * d + b * c) / (b * d)`. In mathematical terms, this says that for elements in a division semiring where multiplication is commutative for certain pairs, the sum of two fractions equals the fraction whose numerator is the sum of the cross products of the numerators and denominators of the original fractions, and whose denominator is the product of the original denominators.

For any division semiring with commutative multiation, and for non-zero elements a, b, c, and d such that b commutes with both c and d, we have a / b + c / d = (a * d + b * c) / (b * d).


theorem IntermediateField.top_toSubalgebra :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E], ⊤.toSubalgebra = ⊤ := by
  sorry

This theorem states that for any two types `F` and `E` which are fields, and where `E` is an algebra over `F`, the top-level `IntermediateField` when converted to a `Subalgebra` is still the top-level object. Essentially, this theorem ensures that the process of converting a top-level intermediate field to a subalgebra does not change its 'top-level' status in the context of algebraic structures.

Given types `F` and `E` as fields with `E` being an algebra over `F`, the conversion of `IntermediateField F E` to a `Subalgebra` results in the same top-level object.


/-- If the second of three points is weakly between the other two, and not equal to the first,
the angle at the first point is zero.  -/
theorem Wbtw.angle₂₁₃_eq_zero_of_ne :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
      Wbtw ℝ p₁ p₂ p₃ → p₂ ≠ p₁ → EuclideanGeometry.angle p₂ p₁ p₃ = 0 :=
  by sorry

This theorem states that, given three points where the second point is weakly between the other two and is not equal to the first point, the angle at the first point is zero. In other words, if you have three points where the second point is not only on the line segment between the other two but also closer to the third point, and also it is distinct from the first point, then the angle formed at the first point will be zero. This implies that the three points are collinear with the first point being the endpoint of the line segment.

Given three distinct points on a line, if the second point lies between the first and third points and is closer to the third point, then the angle at the first point is zero, implying the points are collinear.


theorem Sigma.mk.inj_iff :
    ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂},
      { fst := a₁, snd := b₁ } = { fst := a₂, snd := b₂ } ↔ a₁ = a₂ ∧ HEq b₁ b₂ :=
  by sorry

This theorem states that for any two pairs (a₁, b₁) and (a₂, b₂), where a₁ and a₂ are of some type α, and b₁ and b₂ are of type dependent on a₁ and a₂ respectively, these pairs are equal if and only if a₁ is equal to a₂ and b₁ is provably equal to b₂ under heterogeneous equality (HEq). In other words, two pairs are equal if their corresponding elements are equal, with the second element's equality being judged in the context of the first element's value.

For any type α and pairs (a₁, b₁) and (a₂, b₂) with a₁, a₂ of type α and b₁, b₂ dependent on a₁, a₁ = a₂ and HEq (b₁) (b₂) are equivalent.


theorem Nat.factorial_one : Nat.factorial 1 = 1 := by sorry

This theorem, `Nat.factorial_one`, asserts that the factorial of 1 is 1. In mathematical terms, it simply states that `1! = 1`, where "!" is the factorial operation, which multiplies a given natural number by all natural numbers less than it down to one. In this specific case, since there are no natural numbers less than one, the factorial of one is simply one itself.


theorem Ordinal.enum_lt_enum :
    ∀ {α : Type u} {r : α → α → Prop} [inst : IsWellOrder α r] {o₁ o₂ : Ordinal.{u}} (h₁ : o₁ < Ordinal.type r)
      (h₂ : o₂ < Ordinal.type r), r (Ordinal.enum r o₁ h₁) (Ordinal.enum r o₂ h₂) ↔ o₁ < o₂ :=
  by sorry

The theorem `Ordinal.enum_lt_enum` states that for any type `α` and a relation `r` on `α` that forms a well order, and for any two ordinals `o₁` and `o₂` that are less than the order type of `r`, the relation `r` orders the elements of `α` enumerated by `o₁` and `o₂` in the same way as the ordinals themselves. In other words, an element `x` of `α` that corresponds to `o₁` is less than an element `y` that corresponds to `o₂` under `r` if and only if the ordinal `o₁` is less than the ordinal `o₂`.

For any well-ordered type `(α, r)` and ordinals `o₁` and `o₂` below its order type, `r(x₁ : α) ≤ r(x₂ : α)` if and only if `o₁` is less than `o₂` in the ordinal less-than relation.


theorem isCyclic_of_orderOf_eq_card :
    ∀ {α : Type u} [inst : Group α] [inst_1 : Fintype α] (x : α), orderOf x = Fintype.card α → IsCyclic α := by sorry

The theorem `isCyclic_of_orderOf_eq_card` states that for any given type `α` that has a group structure (`Group α`) and is a finite type (`Fintype α`), if there exists an element `x` in `α` whose order (`orderOf x`) is equal to the number of elements in `α` (`Fintype.card α`), then `α` is a cyclic group (`IsCyclic α`). In simpler terms, it says that if the order of an element in a finite group equals the size of the group, then the group is cyclic.

If a finite group of order `n` has an element of order `n`, then the group is cyclic.


theorem NumberField.InfinitePlace.mult_comap_le :
    ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] (f : k →+* K) (w : NumberField.InfinitePlace K),
      NumberField.InfinitePlace.mult (NumberField.InfinitePlace.comap w f) ≤ NumberField.InfinitePlace.mult w :=
  by sorry

The theorem `NumberField.InfinitePlace.mult_comap_le` asserts that for any field `k`, any field `K`, any ring homomorphism `f` from `k` to `K`, and any infinite place `w` of `K`, the multiplicity of the infinite place obtained by the restriction of `w` along the embedding `f` (using `comap`) is less than or equal to the multiplicity of the original infinite place `w` in `K`. Here, the multiplicity of an infinite place refers to the number of distinct complex embeddings that define it.

For any field homomorphism `f` and infinite place `w` of a field `K`, the multiplicity of the image of `w` under the restriction of `w` along `f` is less than or equal to the multiplicity of `w` in `K`.


theorem Finset.image_symmDiff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] {f : α → β} (s t : Finset α),
      Function.Injective f → Finset.image f (symmDiff s t) = symmDiff (Finset.image f s) (Finset.image f t) :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of elements of type `α` and any injective function `f` from `α` to `β`, where `β` has decidable equality, the image of the symmetric difference of `s` and `t` under `f` is equal to the symmetric difference of the images of `s` and `t` under `f`. In other words, an injective function preserves the symmetric difference operation under the mapping from one finite set to another.

For injective functions `f` from finite sets `s` and `t` of type `α` to type `β` with decidable equality, `f(s ⊖ t) = f(s) ⊖ f(t)`.


theorem CategoryTheory.CommSq.fac_right :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
      {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) [hsq : CategoryTheory.CommSq.HasLift sq],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.CommSq.lift sq) p = g :=
  by sorry

This theorem states that in the context of a commutative square in a category, given objects `A`, `B`, `X`, `Y` and morphisms `f : A ⟶ X`, `i : A ⟶ B`, `p : X ⟶ Y`, `g : B ⟶ Y` which form the commutative square, and assuming that the square has a lift (an additional morphism that makes two triangles commute with the original square), the composition of the lift and the morphism `p : X ⟶ Y` equals the morphism `g : B ⟶ Y`. In mathematical terms, if the square has a lift `l : B ⟶ X`, then `l ≫ p = g`. This is essentially stating a property of the commuting of the diagram, that is, the pathway from `B` to `Y` via the lift and `p` is the same as going directly from `B` to `Y` via `g`.

Given a commutative square with lift in a category, the composition of the lift and the morphism to the right bottom vertex equals the morphism to the bottom right vertex.