theorem Filter.inf_principal_eq_bot : ∀ {α : Type u} {f : Filter α} {s : Set α}, f ⊓ Filter.principal s = ⊥ ↔ sᶜ ∈ f :=
  by sorry

The theorem `Filter.inf_principal_eq_bot` states that for any type `α`, any filter `f` on `α`, and any set `s` of `α`, the infimum (i.e., the greatest lower bound) of `f` and the principal filter of `s` is the bottom element (i.e., the smallest element of the ordered set of filters) if and only if the complement of `s` is an element of `f`. The "principal filter of `s`" refers to the collection of all supersets of `s`, and the "complement of `s`" (denoted `sᶜ`) is the set of all elements not in `s`.

For any filter `f` on type `α` and set `s`, the infimum of `f` and the principal filter of `s` equals the bottom element if and only if the complement of `s` is an element of `f`.


/-- **Fermat's Theorem**: the derivative of a function at a local minimum equals zero.  -/
theorem IsLocalMin.hasDerivAt_eq_zero : ∀ {f : ℝ → ℝ} {f' a : ℝ}, IsLocalMin f a → HasDerivAt f f' a → f' = 0 := by
  sorry

**Fermat's Theorem**: This theorem states that for any real-valued function `f`, real numbers `f'` and `a`, if `a` is a local minimum of the function `f` (that is, `f(a)` is less than or equal to `f(x)` for all `x` in some neighborhood of `a`), and if the derivative of the function `f` at the point `a` exists and is equal to `f'`, then the derivative `f'` must be zero. In other words, the slope of the tangent line to the function `f` at a local minimum is zero.

If `f` is a real-valued function with local minimum `a` where the derivative `f'` exists, then `f'(a) = 0`.


/-- The inner product between a `π / 2` rotation of a vector and that vector is zero.  -/
theorem Orientation.inner_rotation_pi_div_two_left :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x : V),
      ⟪(Orientation.rotation o ↑(Real.pi / 2)) x, x⟫_ℝ = 0 :=
  by sorry

The theorem `Orientation.inner_rotation_pi_div_two_left` states that for any 2-dimensional real vector space `V` with an orientation `o` and any vector `x` in `V`, the inner product of `x` with its own image under a rotation by an angle of `π/2` (90 degrees) is zero. In mathematical terms, this implies that the rotation results in a vector that is orthogonal to the original vector `x` in the chosen orientation.

For any 2-dimensional real vector space with orientation, and any vector x, the inner product of x and its rotation by π/2 is zero.


theorem Monoid.Coprod.swap_injective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
      Function.Injective ⇑(Monoid.Coprod.swap M N) :=
  by sorry

The theorem `Monoid.Coprod.swap_injective` states that for any types `M` and `N` that are instances of the `MulOneClass` (meaning they are monoids with respect to multiplication operation that also have an identity element), the function `Monoid.Coprod.swap` that maps pairs `(M, N)` to `(N, M)` is injective. In other words, if `Monoid.Coprod.swap M N` of two pairs are equal, then those pairs must be the same. This function injectivity implies that no two different pairs in the domain map to the same pair in the codomain under the `swap` operation.

For any monoids `M` and `N` with respect to multiplication, the function `Monoid.Coprod.swap : (M, N) -> (N, M)` is an injection.


theorem circleMap_sub_center : ∀ (c : ℂ) (R θ : ℝ), circleMap c R θ - c = circleMap 0 R θ := by sorry

This theorem states that for any complex number 'c' and real numbers 'R' and 'θ', the difference between the result of applying the 'circleMap' function to 'c', 'R', and 'θ' and 'c' itself, is equal to the result of applying the 'circleMap' function to 0, 'R', and 'θ'. In other words, if we shift the center of the circular map from 'c' to the origin (0), the mapped values will also shift by the same amount 'c'. This can be thought of as a property of the shift invariance of the circular map in the complex plane.

For any complex number 'c' and real numbers 'R' and 'θ', the circular map of 'c' with radius 'R' and angle 'θ' is equal to the circular map of the origin with the same radius and angle, translated by 'c'.


theorem disjoint_assoc :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α},
      Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) :=
  by sorry

The theorem of "disjoint association" states that for any type `α` that is a semilattice with infimum operation and possesses a least element, and any three elements `a`, `b`, and `c` of this type, the property that `a` and `b` infimum is disjoint with `c` is equivalent to the property that `a` is disjoint with the infimum of `b` and `c`. In more mathematical terms, if `Disjoint (a ⊓ b) c` then `Disjoint a (b ⊓ c)` and vice versa. Here, two elements are said to be disjoint if the greatest element that is less than or equal to both of them is the bottom element of the lattice.

For any semilattice with infimum and least element `α`, the infima of any two disjoint elements are interchangeable: `Disjoint (a ⊓ b) c <-> Disjoint a (b ⊓ c)`, where `<->` denotes logical equivalence.


theorem Asymptotics.IsBigOWith.eventually_mul_div_cancel :
    ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {c : ℝ} {l : Filter α} {u v : α → 𝕜},
      Asymptotics.IsBigOWith c l u v → u / v * v =ᶠ[l] u :=
  by sorry

This theorem, named `Asymptotics.IsBigOWith.eventually_mul_div_cancel`, states that for any type `α` and `𝕜` (where `𝕜` is a normed division ring), a real number `c`, a filter `l` on `α`, and functions `u` and `v` from `α` to `𝕜`, if it is the case that the function `u` is Big-O of the function `v` with constant `c` at the filter `l` (denoted `Asymptotics.IsBigOWith c l u v`), then eventually (with respect to the filter `l`), the product of `u / v` and `v` equals `u`. In other words, if the magnitude of `u` is eventually bounded by a constant multiple of the magnitude of `v`, then multiplying the ratio of `u` to `v` by `v` will eventually yield `u` itself.

If `u` is Big-O of `v` with constant `c` at filter `l`, then eventually `u / v * v = u` at points in `l`.


IsUpperSet.vadd

theorem IsUpperSet.vadd :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] {s : Set α} {a : α}, IsUpperSet s → IsUpperSet (a +ᵥ s) := by sorry

The theorem `IsUpperSet.vadd` states that for any type `α` that forms an ordered additive commutative group and any set `s` of this type, along with any element `a` of this type, if `s` is an upper set (meaning that if any element `b` is greater than or equal to any element in `s`, then `b` is also in `s`), then the set obtained by adding `a` to every element in `s` (denoted as `a +ᵥ s`) is also an upper set.

If `α` is an ordered additive commutative group, `s` is an upper set of `α`, then `a +ᵥ s` is also an upper set of `α` for any `a` in `α`.


Set.Definable.inter

theorem Set.Definable.inter :
    ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : FirstOrder.Language.Structure L M] {α : Type u₁}
      {f g : Set (α → M)}, Set.Definable A L f → Set.Definable A L g → Set.Definable A L (f ∩ g) :=
  by sorry

The theorem `Set.Definable.inter` states that if we have two sets, `f` and `g`, which are subsets of a finite Cartesian product of a structure `M` that are definable over a set `A` with respect to a first-order language `L` (i.e., membership in both `f` and `g` can be determined by some first-order formula with parameters from `A`), then the intersection of `f` and `g` is also a set that is definable over `A` with the same first-order language `L`. This means that the set of elements common to both `f` and `g` can also be described by a first-order formula with parameters from `A`.

If `f` and `g` are definable subsets of a finite product `M` over a set `A` with respect to a first-order language `L`, then their intersection is also a definable subset of `M` over `A` using the same language `L`.


theorem isOpenMap_smul₀ :
    ∀ {α : Type u_2} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ α]
      [inst_3 : ContinuousConstSMul G₀ α] {c : G₀}, c ≠ 0 → IsOpenMap fun x => c • x :=
  by sorry

The theorem `isOpenMap_smul₀` asserts that for any types `α` and `G₀`, where `α` has a topological space structure, `G₀` is a group with zero, and `G₀` acts on `α` in a multiplicative fashion, if the constant scalar multiplication by any non-zero element `c` of `G₀` is continuous, then scalar multiplication by this non-zero element `c` is an open map. In other words, it says that multiplying every element of an open set in `α` by a non-zero constant `c` from `G₀` gives us an open set in `α`.

If `α` is a topological space, `G₀` is a group with a zero element and acts multiplicatively on `α`, and scalar multiplication by a non-zero `c` in `G₀` is continuous, then scalar multiplication by `c` is an open map on `α`.


theorem Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors :
    ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
      p ≠ 0 →
        (∀ m ≤ n, Polynomial.IsRoot ((⇑Polynomial.derivative)^[m] p) t) →
          ↑(Nat.factorial n) ∈ nonZeroDivisors R → n < Polynomial.rootMultiplicity t p :=
  by sorry

This theorem states that for any commutative ring `R`, given a non-zero polynomial `p` of type `R`, a scalar `t` of type `R`, and a natural number `n`, if `t` is a root of the `m`-th derivative of `p` for all `m` less than or equal to `n`, and the factorial of `n` is a member of the non-zero divisors of `R`, then `n` is strictly less than the root multiplicity of `t` in `p`. In other words, if a number is a root of a polynomial and its derivatives up to a certain order, then the multiplicity of that root in the polynomial is greater than that order, provided that the factorial of the order is a non-zero divisor.

If `p` is a non-zero polynomial in a commutative ring `R`, `t` is a root of the derivatives of `p` up to order `n` (`n` being a natural number), and the factorial `n!` is a non-zero divisor in `R`, then the multiplicity of `t` as a root of `p` is strictly greater than `n`.


theorem Filter.EventuallyEq.deriv_eq :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜}, f₁ =ᶠ[nhds x] f → deriv f₁ x = deriv f x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and any normed additive commutative group `F` that also forms a normed space over `𝕜`, if two functions `f` and `f₁` from `𝕜` to `F` are eventually equal at a point `x` in the neighborhood filter of `x`, then their derivatives at `x` are equal. In other words, if `f₁` and `f` differ only within an infinitesimally small neighborhood around `x`, their derivatives at `x` are identical.

If `f` and `f₁` are normed `𝕜`-valued functions on a normed additive commutative group `F` that agree in some neighborhood of a point `x`, then their derivatives at `x` are equal.


theorem List.tail_eq_of_cons_eq :
    ∀ {α : Type u_1} {h₁ : α} {t₁ : List α} {h₂ : α} {t₂ : List α}, h₁ :: t₁ = h₂ :: t₂ → t₁ = t₂ := by sorry

This theorem, `List.tail_eq_of_cons_eq`, states that for any given type `α`, if two lists `h₁ :: t₁` and `h₂ :: t₂` of type `α` are equal, where `h₁` and `h₂` are the head elements of the lists and `t₁` and `t₂` are their respective tails, then the tails `t₁` and `t₂` must be equal. In simpler terms, if two lists are equal, their tails must also be equal.

If `h₁ :: t₁` and `h₂ :: t₂` are equal lists, then `t₁` is equal to `t₂`.


theorem Filter.tendsto_inf_right :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
      Filter.Tendsto f x₂ y → Filter.Tendsto f (x₁ ⊓ x₂) y :=
  by sorry

The theorem `Filter.tendsto_inf_right` states that for any types `α` and `β`, a function `f` from `α` to `β`, and any filters `x₁`, `x₂` on `α` and a filter `y` on `β`, if `f` tends towards `y` as the input approaches `x₂`, then `f` also tends towards `y` as the input approaches the infimum (greatest lower bound) of filters `x₁` and `x₂`. This means that the limit of `f` at `x₂` is preserved even when considering the intersection of `x₁` and `x₂`.

Given filters `x₁`, `x₂` on type `α` and a filter `y` on type `β`, if function `f` from `α` to `β` tends to `y` as inputs approach the infimum of `x₁` and `x₂`, then `f` tends to `y` as inputs approach the infimum of `{x₁, x₂}`.


theorem Mathlib.Data.Set.Intervals.Pi._auxLemma.1 :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → LE (α i)] {x y : (i : ι) → α i}, (x ≤ y) = ∀ (i : ι), x i ≤ y i :=
  by sorry

This theorem states that for any type `ι`, and a function `α` that maps `ι` to another type, given any two elements `x` and `y` of type `α`, the condition 'x is less than or equal to y' is equivalent to the condition 'for all indices i of type `ι`, the ith component of x is less than or equal to the ith component of y'. In other words, the ordering between multi-dimensional objects is defined component-wise.

For any function `α : ι → Type`, and `x, y : α`, the equality `x ≤ y` holds if and only if `∀ i : ι, x i ≤ y i`.


theorem Ideal.mul_le_left : ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, I * J ≤ J := by sorry

The theorem `Ideal.mul_le_left` states that for any commutative semiring `R` and any two ideals `I` and `J` in `R`, the product of `I` and `J` (in the sense of ideal multiplication) is a subset of `J`. In other words, any element that can be written as a sum of products of elements from `I` and `J` is itself an element of `J`. This reflects one of the key properties of ideals in ring theory.

For any commutative semiring R and ideals I and J, I * J ⊆ J, where I * J denotes the ideal generated by all products x * y with x ∈ I and y ∈ J.


theorem Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.30 : ∀ {p : NNReal}, (↑p < 1) = (p < 1) := by sorry

This theorem, which is from the Mathlib library in Lean 4, states that for all non-negative real numbers `p` (denoted as `NNReal`), the inequality of `p` being less than 1 in the context of real numbers (expressed as `↑p < 1`) is equivalent to `p` being less than 1 in the context of non-negative real numbers (expressed as `p < 1`). In other words, the embedding of `p` into the real numbers does not change the truth value of the inequality `p < 1`.

For all non-negative real numbers `p`, the inequality `p < 1` in the context of non-negative real numbers is equivalent to the inequality `↑p < 1` in the context of real numbers.


theorem ascPochhammer_nat_eq_descFactorial :
    ∀ (a b : ℕ), Polynomial.eval a (ascPochhammer ℕ b) = Nat.descFactorial (a + b - 1) b := by sorry

The theorem `ascPochhammer_nat_eq_descFactorial` states that for all natural numbers `a` and `b`, the evaluation of the `ascPochhammer` polynomial at `a` is equal to the descending factorial of `a + b - 1` choose `b`. In other words, if you create a polynomial using `ascPochhammer` with `b` as the argument and then evaluate this polynomial at `a`, the result will be the same as taking the descending factorial of `a + b - 1` choose `b`. This establishes a connection between the evaluation of a certain class of polynomials and factorial operations.

For all natural numbers `a` and `b`, `ascPochhammer a b = descFactorial (a + b - 1) Choices b`.


theorem Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.31 : ∀ {r : NNReal}, (0 < ↑r) = (0 < r) := by sorry

This theorem, named `Mathlib.Analysis.SpecialFunctions.Pow.NNReal._auxLemma.31`, states that for every nonnegative real number `r`, the condition that the real part (or value) of `r` is greater than zero is equivalent to the condition that `r` itself is greater than zero. In essence, it establishes that checking whether a nonnegative real number `r` is positive is the same as checking whether the real part of `r` is positive.

For every nonnegative real number `r`, `r` is positive if and only if its real part is positive.


theorem stoneCechExtend_extends :
    ∀ {α : Type u} [inst : TopologicalSpace α] {γ : Type u} [inst_1 : TopologicalSpace γ] [inst_2 : T2Space γ]
      [inst_3 : CompactSpace γ] {f : α → γ} (hf : Continuous f), stoneCechExtend hf ∘ stoneCechUnit = f :=
  by sorry

The theorem `stoneCechExtend_extends` states that for any type `α` with a topological space structure and any compact Hausdorff space `γ`, any continuous function `f` from `α` to `γ` can be extended to the Stone-Čech compactification of `α`. More explicitly, if we have a continuous function `f` from `α` to `γ`, then the composition of the function `stoneCechExtend` applied to `f` (which creates the extended function) with the natural map `stoneCechUnit` (which embeds `α` into its Stone-Čech compactification) is equal to `f` itself. This means that the function `f` is essentially "preserved" under this extension to the Stone-Čech compactification.

For any continuous function from a topological space to a compact Hausdorff space, there exists an extension of the function to its Stone-Čech compactification that preserves the original function.


theorem Set.mapsTo_empty : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (t : Set β), Set.MapsTo f ∅ t := by sorry

The theorem `Set.mapsTo_empty` states that for any types `α` and `β`, and for any function `f` mapping `α` to `β` and any set `t` of type `β`, the function `f` maps the empty set to `t`. This is based on the definition of `Set.MapsTo`, which means that the image of every element from the first set is contained in the second set. Since the empty set has no elements, it trivially holds that all its elements (of which there are none) have their images in `t` under function `f`.

For any functions `f: α → β` and sets `t: Set β`, the empty set of `α` maps to `t` under `f`, that is, `∅.map f = {}`.


theorem PiTensorProduct.hasSMul'.proof_2 :
    ∀ {ι : Type u_2} {R : Type u_1} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] (r : R₁) (f : (i : ι) → s i), PiTensorProduct.tprodCoeff R (r • 0) f = 0 :=
  by sorry

This theorem states that for any index set `ι`, any commutative semiring `R`, any type `R₁` that forms a monoid, any scalar `r` from `R₁`, and any function `f` mapping from `ι` to a type `s i` (where each `s i` is an `R`-module and an add-commutative monoid), the tensor product of the zero scalar (scaled by `r`) and `f` is zero. This theorem essentially captures the property in tensor product that scaling the zero element results in the zero element.

For any commutative semiring R, monoid M with scalar r, and function f from an index set ι to the add-commutative R-modules s i, the tensor product of r⊤ (the scalar multiplication of r in M) and f is the zero function.


theorem PiTensorProduct.hasSMul'.proof_3 :
    ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] (r : R₁) [inst_5 : DecidableEq ι] (r' : R) (f : (i : ι) → s i) (i : ι)
      (m₁ m₂ : s i),
      PiTensorProduct.tprodCoeff R (r • r') (Function.update f i m₁) +
          PiTensorProduct.tprodCoeff R (r • r') (Function.update f i m₂) =
        PiTensorProduct.tprodCoeff R (r • r') (Function.update f i (m₁ + m₂)) :=
  by sorry

This theorem, `PiTensorProduct.hasSMul'.proof_3`, establishes a property of tensor products in the context of commutative semirings and modules.

For any index type `ι`, commutative semiring `R`, type `R₁` forming a monoid, a distributive multiplication action of `R₁` on `R`, a function `s` mapping indices `i` from `ι` to additive commutative monoids that are also `R`-modules, a scalar `r` from `R₁`, a decidable equality on `ι`, a scalar `r'` from `R`, a function `f` from `ι` to `s i`, an index `i` from `ι`, and two elements `m₁` and `m₂` from `s i`:

The theorem states that the sum of the tensor products of the scalar `r • r'` and the updated functions `f` at index `i` with `m₁` and `m₂` respectively, equals the tensor product of the scalar `r • r'` and the updated function `f` at index `i` with the sum of `m₁` and `m₂`.

For any commutative semiring `R`, index type `ι`, distributive action of `R` on additive commutative `R`-modules indexed by `ι`, scalar `r` from `R₁`, decidable equality on `ι`, and functions `s : ι -> AddMonoid R-Module`, `f : ι -> s i`, the tensor product of `r • r'` and `f i` with the sum of elements `m₁` and `m₂` from `s i` is equal to the sum of the tensor products of `r • r'` and `f i` with `m₁` and `m₂` respectively.


theorem PiTensorProduct.hasSMul'.proof_1 :
    ∀ {ι : Type u_3} {R : Type u_2} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_1}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] (r : R₁) (r' : R) (f : (i : ι) → s i) (i : ι),
      f i = 0 → (fun f => PiTensorProduct.tprodCoeff R (r • f.1) f.2) (r', f) = 0 :=
  by sorry

This theorem is stating that for any index type `ι`, any type `R` with a commutative semiring structure, any type `R₁` that is a monoid with multiplication distributing over addition on `R`, any function `s` from `ι` to a type with addition commutative monoid and module structure over `R`, given an element `r` of `R₁`, an element `r'` of `R`, a function `f` from `ι` to the type `s i` and an index `i`, if `f i` equals zero, then the tensor product of `r • f.1` and `f.2` with respect to `R` under the function `PiTensorProduct.tprodCoeff` equals zero.

For any commutative semiring `R`, monoid `R₁` with `R`-module action on `s : ι → M` where `M` is an `R`-module with commutative additive monoid structure, and `r : R₁` and `r' : R`, if `f : ι → M` satisfies `f i = 0` for some index `i`, then `r • f i ⊗ f i (using `PiTensorProduct.tprodCoeff) = 0`.


theorem PiTensorProduct.hasSMul'.proof_4 :
    ∀ {ι : Type u_2} {R : Type u_1} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] (r : R₁) (r' r'' : R) (f : (i : ι) → s i),
      PiTensorProduct.tprodCoeff R (r • r') f + PiTensorProduct.tprodCoeff R (r • r'') f =
        PiTensorProduct.tprodCoeff R (r • (r' + r'')) f :=
  by sorry

This theorem states that for all types `ι`, `R`, and `R₁`, under the conditions that `R` is a commutative semiring, each `s i` (where `s` is a function from `ι` to some type) is a module over `R`, and `R₁` is a monoid that is also a distributive multiplicative action on `R`, the scalar multiplication of `r` (from `R₁`) with `r'` (from `R`) and `r''` (also from `R`) followed by tensor producting with a function `f` from `ι` to `s i` satisfies the property of distribution over addition. In other words, if we tensor product a scalar multiple of a sum, we get the same result as if we had added the tensor products of the scalar multiples of the summands. Formulated mathematically, we have the equality:
`r * (r' + r'') * f = r * r' * f + r * r'' * f`,
where `*` represents tensor producting.

Given commutative semiring `R`, module `s` over `R` indexed by type `ι`, monoid `R₁` acting distributively and multiplicatively on `R`, the scalar multiplication distributes over tensor product addition, i.e., `r * (r' + r'') * f = r * r' * f + r * r'' * f` for all `r, r', r'' from `R` and `f` from `ι` to `s ι`.


theorem PiTensorProduct.hasSMul'.proof_5 :
    ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] [inst_5 : SMulCommClass R₁ R R] (r : R₁) [inst_6 : DecidableEq ι] (z : R)
      (f : (i : ι) → s i) (i : ι) (r' : R),
      PiTensorProduct.tprodCoeff R (r • z) (Function.update f i (r' • f i)) =
        PiTensorProduct.tprodCoeff R (r • (r' * z)) f :=
  by sorry

This theorem states that in the context of a commutative semiring `R`, an indexed collection of additively commutative monoids `s i` that are also `R`-modules, and a distributive multiply action of `R₁` on `R` where `R₁` is a monoid and the scalar multiplication is commutative, given an element `r` of `R₁`, a decidable equality on the indexing set `ι`, an element `z` of `R`, a function `f` from `ι` to `s i`, an index `i` in `ι`, and a scalar `r'` in `R`, the tensor product coefficient of the scalar multiple `r` times `z` and the function `f` updated at index `i` to be `r'` times `f i` equals the tensor product coefficient of `r` times the product of `r'` and `z` and the original function `f`. This essentially establishes a particular equality of tensor product coefficients under certain scalar multiplications and updates to the function `f`.

Given a commutative semiring `R`, an indexed collection of additively commutative `R`-modules `s i`, a distributive multiply action of a commutative monoid `R₁` on `R`, and a function `f` from `ι` to `s i`, the tensor product coefficient of `r` (an element of `R₁`) times `z` (an element of `R`) and the updated function `f` at index `i` with scalar `r'`, equals the tensor product coefficient of `r` times the product of `r'` and `z` and the original function `f`.


Inducing.continuousMul

theorem Inducing.continuousMul :
    ∀ {M : Type u_6} {N : Type u_7} {F : Type u_8} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
      [inst_3 : MulHomClass F M N] [inst_4 : TopologicalSpace M] [inst_5 : TopologicalSpace N]
      [inst_6 : ContinuousMul N] (f : F), Inducing ⇑f → ContinuousMul M :=
  by sorry

The theorem `Inducing.continuousMul` states that for any types `M`, `N`, and `F`, if `M` and `N` are equipped with multiplication operations and topological space structures, `F` is a function from `M` to `N` which behaves like a function (due to `FunLike F M N`), and `F` also behaves like a multiplication homomorphism (`MulHomClass F M N`), if multiplication on `N` is continuous (`ContinuousMul N`) and the function `f : F` induces the topology of `M` from `N` (`Inducing ⇑f`), then multiplication on `M` is also continuous (`ContinuousMul M`). In other words, if the multiplication operation is continuous in the codomain of a function that induces the topology and preserves the multiplication operation, then the multiplication operation is also continuous in the domain.

If `F : M → N` is a continuous, multiplication-preserving function between topological spaces `M` and `N` with continuous multiplication on `N`, then multiplication is continuous on `M`.


theorem lowerClosure_min :
    ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, s ⊆ t → IsLowerSet t → ↑(lowerClosure s) ⊆ t := by sorry

The theorem `lowerClosure_min` states that for any type `α` having a preorder structure and any sets `s` and `t` of this type, if `s` is a subset of `t` and `t` is a lower set (i.e., for any elements `a` and `b` in `t`, if `b` is less than or equal to `a`, then `b` is also in `t`), then the lower closure of `s` (which is the least lower set containing `s`) is also a subset of `t`. It essentially says that the smallest lower set containing `s` is contained within any lower set that contains `s`.

If `s` is a subset of a lower set `t` in a preordered type `α`, then the lower closure of `s` is included in `t`.


theorem embedding_inclusion :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X} (h : s ⊆ t), Embedding (Set.inclusion h) := by sorry

The theorem `embedding_inclusion` states that for any type `X` equipped with a topological space structure, and for any two subsets `s` and `t` of `X` such that `s` is a subset of `t`, the inclusion function from `s` to `t` is an embedding. In other words, it asserts that the function that maps each element of the subset `s` to itself within the larger set `t` preserves the topological structure, implying that the subset `s` carries the subspace topology induced from `t`.

For any topological space `(X, τ)` and subsets `s ⊆ t ⊆ X`, the inclusion function `i : s → t` is a continuous function, making `s` a subspace of `t` with the subspace topology.


/-- Three points are collinear if and only if the first or third point equals the second or the
angle between them is 0 or π.  -/
theorem EuclideanGeometry.collinear_iff_eq_or_eq_or_angle_eq_zero_or_angle_eq_pi :
    ∀ {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},
      Collinear ℝ {p₁, p₂, p₃} ↔
        p₁ = p₂ ∨ p₃ = p₂ ∨ EuclideanGeometry.angle p₁ p₂ p₃ = 0 ∨ EuclideanGeometry.angle p₁ p₂ p₃ = Real.pi :=
  by sorry

This theorem states that in Euclidean Geometry, three points are said to be collinear if and only if the first or third point is the same as the second point or the undirected angle between them is either 0 or \(\pi\) radians (\(180^{\circ}\)). In other words, three points lie on the same line if either two of them coincide or the angle between the segments connecting them is either straight (0 degrees or \(\pi\) radians) or flat (180 degrees or \(\pi\) radians).

In Euclidean geometry, three points are collinear if and only if they either coincide or form a straight or flat angle between them.


theorem BoundedContinuousFunction.coe_neg :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
      (f : BoundedContinuousFunction α β), ⇑(-f) = -⇑f :=
  by sorry

This theorem states that for any bounded continuous function `f` from a topological space `α` to a seminormed add commutative group `β`, the negative of `f` (denoted `-f`) operates in the same way as applying the negation to the result of `f`. In other words, negating the function and then applying it to an argument is the same as applying the function to the argument first and then negating the result.

For any bounded continuous function `f` from a topological space `α` to a seminormed add commutative group `β`, negating the function `-f` and applying it to an element `x` in `α` is equivalent to applying `f` to `-x` and negating the result.


/-- The definition of `x ≤ 0` on pre-games, in terms of `≤ 0` two moves later.  -/
theorem SetTheory.PGame.le_zero :
    ∀ {x : SetTheory.PGame},
      x ≤ 0 ↔
        ∀ (i : SetTheory.PGame.LeftMoves x), ∃ j, SetTheory.PGame.moveRight (SetTheory.PGame.moveLeft x i) j ≤ 0 :=
  by sorry

The theorem `SetTheory.PGame.le_zero` is defining what `x ≤ 0` means for pre-games in set theory. Specifically, a pre-game `x` is less than or equal to 0 if and only if, for every possible move `i` that Left can make in `x`, there exists a counter-move `j` that Right can make such that after these two moves, the resulting pre-game is less than or equal to 0. In other words, no matter what move Left makes, Right can always respond in such a way that the game state stays less than or equal to 0.

A pre-game x is less than or equal to 0 if and only if for every move i by Left, Right has a counter-move j such that the resulting pre-game is less than or equal to 0.


/-- Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`.  -/
theorem Subgroup.map_injective_of_ker_le :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) {H K : Subgroup G},
      MonoidHom.ker f ≤ H → MonoidHom.ker f ≤ K → Subgroup.map f H = Subgroup.map f K → H = K :=
  by sorry

The theorem `Subgroup.map_injective_of_ker_le` states that given two subgroups `H` and `K` of a group `G` and a group homomorphism `f` from `G` to another group `N`, if the kernel of `f` is a subset of both `H` and `K` and the image of `H` and `K` under `f` are equal, then `H` and `K` must be the same subgroup.

In other words, if two subgroups of a group map to the same subgroup in the target group under a group homomorphism, and both subgroups contain all the elements that map to the identity in the target group, then the two subgroups are identical.

If two subgroups of a group have the same image under a group homomorphism and contain all of its kernel, then they are equal.


theorem Multiset.count_ne_zero :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, Multiset.count a s ≠ 0 ↔ a ∈ s := by sorry

This theorem states that for any type `α` that has decidable equality and any `a` of type `α` and `s` which is a multiset of `α`, the count of `a` in `s` is not zero if and only if `a` is an element of `s`. In other words, an element `a` belongs to a multiset `s` precisely when its count in `s` is non-zero.

For any type `α` with decidable equality and any multiset `s` of `α` and element `a` of `α`, the count of `a` in `s` is non-zero if and only if `a` is a member of `s`.


theorem Nat.zero_shiftRight : ∀ (n : ℕ), 0 >>> n = 0 := by sorry

This theorem states that for any natural number `n`, right-shifting zero `n` places results in zero. In other words, in the context of bit manipulation, if you take the number zero and shift its bits to the right `n` times, the result will always be zero, regardless of the value of `n`.

For any natural number `n`, right-shifting the binary representation of zero `n` times results in zero.


theorem Filter.Tendsto.finset_sup'_nhds_apply :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] {ι : Type u_3} {α : Type u_4} {s : Finset ι} {f : ι → α → L}
      {l : Filter α} {g : ι → L} [inst_1 : SemilatticeSup L] [inst_2 : ContinuousSup L] (hne : s.Nonempty),
      (∀ i ∈ s, Filter.Tendsto (f i) l (nhds (g i))) →
        Filter.Tendsto (fun a => Finset.sup' s hne fun x => f x a) l (nhds (Finset.sup' s hne g)) :=
  by sorry

This theorem states that if we have a topological space `L` with a structure of a join-semilattice (a type of partially ordered set) and where the supremum operation is continuous, a nonempty finite set `s`, a filter `l` on `α`, and a function `f : ι → α → L` that tends to a function `g : ι → L` at each point of `s`, then the function `h : α → L` that maps each `α` to the supremum of the image of `s` under `f` also tends to the supremum of the image of `s` under `g` as `α` varies under the filter `l`. In other words, if each `f i` approaches `g i` for `i` in `s`, then the supremum of the `f i`'s also approaches the supremum of the `g i`'s.

If `L` is a topological space with a continuous supremum operation, `s` is a nonempty finite set, `l` is a filter on `α`, and `f : ι → α → L` tends to `g : ι → L` at each point of `s`, then the function `h(x) = sup(fi(x))_s` tends to `sup(gi(x))_s` as `x` varies under the filter `l`.


theorem Mathlib.Algebra.Algebra.Spectrum._auxLemma.5 :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
      (r ∈ resolventSet R a) = IsUnit ((algebraMap R A) r - a) :=
  by sorry

This theorem states that for any commutative semi-ring `R`, any ring `A` where `A` is an `R`-algebra, any element `r` from `R` and any element `a` from `A`, `r` is in the resolvent set of `a` if and only if the result of subtracting `a` from the image of `r` under the algebra map (which maps `R` to `A`) is a unit in the algebra `A`. In other words, `r` is in the resolvent set of `a` exactly when `r•1 - a` is invertible in the algebra `A`. The resolvent set is thus characterized by invertibility under subtraction.

For any commutative semi-ring `R`, `R-`algebra `A`, `r` in `R`, and `a` in `A`, `r` is in the resolvent set of `a` if and only if `r•1 - a` is invertible in `A`.


theorem CategoryTheory.shiftFunctorAdd'_assoc :
    ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A) (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃)
      (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃),
      CategoryTheory.shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯ ≪≫
          CategoryTheory.isoWhiskerRight (CategoryTheory.shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂)
              (CategoryTheory.shiftFunctor C a₃) ≪≫
            CategoryTheory.Functor.associator (CategoryTheory.shiftFunctor C a₁) (CategoryTheory.shiftFunctor C a₂)
              (CategoryTheory.shiftFunctor C a₃) =
        CategoryTheory.shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯ ≪≫
          CategoryTheory.isoWhiskerLeft (CategoryTheory.shiftFunctor C a₁)
            (CategoryTheory.shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃) :=
  by sorry

The theorem `CategoryTheory.shiftFunctorAdd'_assoc` states that, for any category `C` with a shift structure indexed by an additive monoid `A`, given any three elements `a₁`, `a₂` and `a₃` of `A`, and `a₁₂`, `a₂₃`, `a₁₂₃` denoting their possible sums, if the sum of `a₁` and `a₂` equals `a₁₂`, the sum of `a₂` and `a₃` equals `a₂₃`, and the sum of `a₁`, `a₂`, and `a₃` equals `a₁₂₃`, then the composition of the shift of `a₁₂` and `a₃` by `a₁₂₃`, followed by the whisker right morphism of the shift of `a₁` and `a₂` by `a₁₂` and the shift functor of `a₃`, and finally the associator of the shift functors of `a₁`, `a₂` and `a₃`, is equal to the composition of the shift of `a₁` and `a₂₃` by `a₁₂₃` followed by the whisker left morphism of the shift functor of `a₁` and the shift of `a₂` and `a₃` by `a₂₃`. This essentially captures the associativity property of the shift operation in the category.

For any additive monoid `A` in a category `C` with a shift structure, the associativity of shift operators holds: (shift `a₁₂` by `a₁₂₃` then whisker right of shift `a₁` and `a₂` by `a₁₂` and shift `a₃`, followed by associator of shifts `a₁`, `a₂`, and `a₃`) equals (shift `a₁` by `a₁₂₃` then whisker left of shift `a₁` and `a₂` and `a₃` by `a₂₃`).


theorem Mathlib.Analysis.Complex.Circle._auxLemma.1 : ∀ {z : ℂ}, (z ∈ circle) = (Complex.abs z = 1) := by sorry

This theorem states that for every complex number `z`, `z` belongs to the unit circle (in the complex numbers) if and only if the absolute value of `z` is equal to 1. This is essentially stating that the unit circle in the complex plane is the set of all complex numbers with an absolute value of 1.

A complex number `z` lies on the unit circle if and only if |z| = 1. (The unit circle in the complex plane is the set of all complex numbers with absolute value equal to 1.)


theorem natDegree_minpolyDiv_succ :
    ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S},
      IsIntegral R x →
        ∀ [inst_3 : Nontrivial S], Polynomial.natDegree (minpolyDiv R x) + 1 = Polynomial.natDegree (minpoly R x) :=
  by sorry

The theorem `natDegree_minpolyDiv_succ` states that for any commutative rings `R` and `S`, with `S` being an `R`-algebra and `x` being an integral element over `R`, if `S` is nontrivial, then the natural degree of the polynomial obtained by dividing the minimal polynomial of `x` over `R` by `(X - C x)` (i.e., `minpolyDiv R x`), incremented by 1, is equal to the natural degree of the minimal polynomial of `x` over `R`. This theorem essentially relates the degrees of the minimal polynomial of `x` and the resulting polynomial after specific division.

For any commutative rings R and S with S an R-algebra, and an integral element x in S over R with non-trivial S, the natural degrees of `minpoly x R` and `(minpoly x R) / (X - cx)` differ by at most 1.


theorem Mathlib.Data.ENNReal.Operations._auxLemma.6 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) := by sorry

This theorem states that for any type `α` that has a partial order and a greatest element (`⊤`), the inequality `a < ⊤` is equivalent to the inequality `a ≠ ⊤` for any element `a` of type `α`. In other words, any element of such a type that is not equal to the greatest element is necessarily less than the greatest element.

For any type with a greatest element under a partial order, the inequality `a < ⊤` is equivalent to `a ≠ ⊤` for all `a` in the type.


theorem Hyperreal.IsSt.map₂ :
    ∀ {x y : ℝ*} {r s : ℝ},
      Hyperreal.IsSt x r →
        Hyperreal.IsSt y s →
          ∀ {f : ℝ → ℝ → ℝ},
            ContinuousAt (Function.uncurry f) (r, s) → Hyperreal.IsSt (Filter.Germ.map₂ f x y) (f r s) :=
  by sorry

The theorem `Hyperreal.IsSt.map₂` states that for any two extended real numbers `x` and `y`, with corresponding standard parts `r` and `s`, and any binary function `f` from real numbers to real numbers, if `f` is continuous at the point `(r, s)`, then the standard part of the mapped germ of `f` on `x` and `y` is `f(r, s)`. In other words, if `f` is a continuous binary function, the standard part of the result of applying `f` to any two hyperreal numbers `x` and `y` is the same as applying `f` to the standard parts of `x` and `y`.

For any continuous binary function f and hyperreal numbers x and y with standard parts r and s, respectively, the standard part of f(x, y) is f(r, s).


theorem List.splitWrtCompositionAux_cons :
    ∀ {α : Type u_1} (l : List α) (n : ℕ) (ns : List ℕ),
      List.splitWrtCompositionAux l (n :: ns) = List.take n l :: List.splitWrtCompositionAux (List.drop n l) ns :=
  by sorry

The theorem `List.splitWrtCompositionAux_cons` states that for all types `α`, lists of `α` (denoted as `l`), and lists of natural numbers `n` and `ns`, the operation `List.splitWrtCompositionAux` applied to the list `l` and the list of natural numbers `n :: ns` is equal to the list constructed by taking the first `n` elements from `l` and appending the result of `List.splitWrtCompositionAux` applied to the remainder of the list after dropping the first `n` elements and the list `ns`. In other words, it describes how the `List.splitWrtCompositionAux` function behaves when splitting a list into sublists: it takes a certain number of elements from the front of the list, then recursively does the same to the rest of the list.

For all types `α`, lists `l` of `α`, and lists `n :: ns` of natural numbers, `List.splitWrtCompositionAux l (n :: ns) = take n l ++ List.splitWrtCompositionAux (drop n l) ns`.


theorem Homeomorph.nhds_eq_comap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (x : X),
      nhds x = Filter.comap (⇑h) (nhds (h x)) :=
  by sorry

The theorem `Homeomorph.nhds_eq_comap` states that for any two types `X` and `Y`, each with a defined topological space structure, and a homeomorphism `h` between them, the neighborhood filter at a point `x` in `X` is equal to the filter obtained by precomposing the function `h` with the neighborhood filter at the point `h(x)` in `Y`. In other words, the concept of "neighboring" is preserved in the homeomorphism.

For any types `X` and `Y` with topological spaces structures and a homeomorphism `h` between them, the neighborhood filter of `x` in `X` is equal to the filter obtained by precomposing `h` with the neighborhood filter of `h(x)` in `Y`.


theorem StructureGroupoid.LocalInvariantProp.congr_set :
    ∀ {H : Type u_1} {H' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace H']
      {G : StructureGroupoid H} {G' : StructureGroupoid H'} {P : (H → H') → Set H → H → Prop},
      StructureGroupoid.LocalInvariantProp G G' P →
        ∀ {s t : Set H} {x : H} {f : H → H'}, s =ᶠ[nhds x] t → (P f s x ↔ P f t x) :=
  by sorry

This theorem states that for any topological spaces `H` and `H'`, structure groupoids `G` and `G'` on these spaces, and a property `P` that applies to a function from `H` to `H'`, a set in `H`, and a point in `H`, if `P` has the local invariant property under `G` and `G'`, then for any two sets `s` and `t` in `H`, a point `x` in `H`, and a function `f` from `H` to `H'`, if `s` equals `t` in the neighborhood of `x`, then `P` holds for `f`, `s`, and `x` if and only if `P` holds for `f`, `t`, and `x`.

In simpler words, under certain conditions, the property `P` is independent of the exact choice of the neighborhood around `x` - if two sets coincide in a neighborhood of `x`, then either `P` holds for both or for neither.

Given topological spaces H and H', structure groupoids G and G', and a property P satisfying local invariance under G and G', if s = t in the neighborhood of x in H, then P(f, s, x) if and only if P(f, t, x), for any function f from H to H' and point x in H.


AddGroupCat.ext

theorem AddGroupCat.ext : ∀ {X Y : AddGroupCat} {f g : X ⟶ Y}, (∀ (x : ↑X), f x = g x) → f = g := by sorry

This theorem states that for any two objects `X` and `Y` in the category of additive groups (`AddGroupCat`), if two morphisms `f` and `g` from `X` to `Y` satisfy the property that for every element `x` in `X`, the image of `x` under `f` is the same as the image of `x` under `g`, then `f` and `g` are the same morphism. In other words, two morphisms in the category of additive groups are considered equal if they map every element of the source group to the same element in the target group.

In the category of additive groups, two morphisms between objects are equal if and only if they map every group element to the same image.


theorem Function.LeftInverse.Prod_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α} {g₂ : δ → γ},
      Function.LeftInverse f₁ f₂ →
        Function.LeftInverse g₁ g₂ → Function.LeftInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂) :=
  by sorry

This theorem asserts that for any four types `α`, `β`, `γ` and `δ`, and for any functions `f₁ : α → β`, `g₁ : γ → δ`, `f₂ : β → α`, and `g₂ : δ → γ`, if `f₁` is a left inverse to `f₂` and `g₁` is a left inverse to `g₂`, then the function `Prod.map f₁ g₁` is a left inverse to the function `Prod.map f₂ g₂`. In other words, if reversing the operations of `f₁` and `g₁` with `f₂` and `g₂` respectively leads us back to the original value, then applying this to pairs of values, with `f₁` and `g₁` applied to the first and second elements of the pair respectively, will also lead us back to the original pair when the operations are reversed.

If functions `f₁ : α → β`, `g₁ : γ → δ`, `f₂ : β → α`, and `g₂ : δ → γ` satisfy `f₁ ∘ f₂ = id α` and `g₁ ∘ g₂ = id δ`, then `g₁ ∘ f₂ = id (α × γ)`. (Here, `id` denotes the identity function, and `α × γ` denotes the product type of `α` and `γ`.)


theorem Polynomial.map_monic_ne_zero :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] {f : R →+* S},
      Polynomial.Monic p → ∀ [inst_2 : Nontrivial S], Polynomial.map f p ≠ 0 :=
  by sorry

The theorem `Polynomial.map_monic_ne_zero` states that for any polynomial `p` over a semiring `R`, if `p` is a monic polynomial (i.e., its leading coefficient is 1), then mapping `p` across any ring homomorphism `f` to another semiring `S` (where `S` is nontrivial, i.e., not equal to zero) will yield a non-zero polynomial. In other words, the action of applying a ring homomorphism to a monic polynomial does not result in the zero polynomial when the target semiring is nontrivial.

If `p` is a monic polynomial over a semiring `R`, then the image of `p` under any nontrivial ring homomorphism `f` from `R` to another semiring `S` is a non-zero polynomial in `S`.


theorem IsOpenMap.mapsTo_interior :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → ∀ {s : Set X} {t : Set Y}, Set.MapsTo f s t → Set.MapsTo f (interior s) (interior t) :=
  by sorry

The theorem `IsOpenMap.mapsTo_interior` states that for any given two types `X` and `Y`, along with their respective topological structures, and a function `f` from `X` to `Y` which is an open map, if `f` maps a set `s` from `X` to a set `t` in `Y`, then `f` also maps the interior of `s` (the largest open subset of `s`) to the interior of `t` (the largest open subset of `t`). This theorem is an important property in the study of open maps in topology.

If `f: X �ึ� Y` is an open map between topological spaces `(X, τX)` and `(Y, τY)`, and `s ⊆ X` has an open interior `int(s)`, then `f(int(s)) = int(f(s))`.


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

This theorem states that for any type `α` and any given lists `l`, `l₁`, and `l₂` of type `α`, a list `l₁` is a sublist of `l₂` if and only if the list formed by appending `l` to `l₁` (i.e., `l ++ l₁`) is a sublist of the list formed by appending `l` to `l₂` (i.e., `l ++ l₂`). In simple words, appending the same list `l` to both `l₁` and `l₂` does not change the sublist relation between `l₁` and `l₂`.

For any type `α` and lists `l₁`, `l₂` of type `α`, `l₁` is a sublist of `l₂` if and only if `l ++ l₁` is a sublist of `l ++ l₂`.


theorem AdjoinRoot.mk_eq_zero :
    ∀ {R : Type u} [inst : CommRing R] {f g : Polynomial R}, (AdjoinRoot.mk f) g = 0 ↔ f ∣ g := by sorry

This theorem states that for any type `R` which forms a commutative ring, and for any two polynomials `f` and `g` over this ring, the application of the `AdjoinRoot.mk` function on `f` applied to `g` equals zero if and only if `f` divides `g`. Here, the `AdjoinRoot.mk` function is a ring homomorphism from `R[x]` to `AdjoinRoot f` that sends `X` to the `root`, and `f ∣ g` denotes that `f` divides `g` in the ring of polynomials over `R`.

For any commutative ring `R`, and polynomials `f` and `g` over `R`, `AdjoinRoot.mk f (g) = 0` if and only if `f` divides `g` in `R[x]`.


/-- Taking the product under `h` is an additive homomorphism of finsupps,  if `h` is an
additive homomorphism on the support. This is a more general version of
`Finsupp.sum_add_index'`; the latter has simpler hypotheses. -/
theorem Finsupp.sum_add_index :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : DecidableEq α] [inst_1 : AddZeroClass M]
      [inst_2 : AddCommMonoid N] {f g : α →₀ M} {h : α → M → N},
      (∀ a ∈ f.support ∪ g.support, h a 0 = 0) →
        (∀ a ∈ f.support ∪ g.support, ∀ (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) →
          Finsupp.sum (f + g) h = Finsupp.sum f h + Finsupp.sum g h :=
  by sorry

The theorem `Finsupp.sum_add_index` states that for any types `α`, `M`, and `N`, given that `α` has decidable equality, `M` is an additive group with zero, and `N` is an additive commutative monoid, and for any functions `f`, `g` from `α` to `M` and function `h` from `α` and `M` to `N` such that `h` on zero is zero for all elements in the union of the support sets of `f` and `g`, and `h` preserves addition for all elements in the same support set and all elements in `M`, then the sum under `h` over the support set of the sum of `f` and `g` is equal to the sum of the sums under `h` over the support sets of `f` and `g` respectively. In other words, the operation of taking the sum under `h` is an additive homomorphism when restricted to finite support functions, provided `h` is an additive homomorphism on the union of the respective support sets. This is a generalized version of the theorem `Finsupp.sum_add_index'` which has simpler hypotheses.

For functions from a decidably equal type to an additive group with zero, and a commutative monoid, if these functions have disjoint support sets and the given function between the monoid and the group preserves addition on common supports and zero at the zero element of the group on support elements, then the sum of the function values on support sets equals the sum of the individual sums.


theorem CategoryTheory.ShortComplex.opcyclesMap'_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.ShortComplex.opcyclesMap' (CategoryTheory.CategoryStruct.id S) h h =
        CategoryTheory.CategoryStruct.id h.Q :=
  by sorry

This theorem states that for any category `C` with zero morphisms, given a short complex `S` and a right homology data `h` of `S`, applying the `opcyclesMap'` function with the identity morphism on `S` as its argument, to `h` and `h` itself, is the same as applying the identity morphism on `h.Q`. In other words, for any object in the category, applying the `opcyclesMap'` function with the identity morphism is effectively the same as applying the identity morphism on the object's homology data.

For any short complex in a category with zero morphisms and associated homology data, applying the `opcyclesMap'` function with the identity morphism to the homology data is equal to the identity morphism on the quotient object of the complex.


theorem Finsupp.prod_congr :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] {f : α →₀ M}
      {g1 g2 : α → M → N}, (∀ x ∈ f.support, g1 x (f x) = g2 x (f x)) → Finsupp.prod f g1 = Finsupp.prod f g2 :=
  by sorry

The theorem `Finsupp.prod_congr` states that for any types `α`, `M`, `N`, where `M` is a type with a zero and `N` is a commutative monoid, and for any function `f` from `α` to `M` and any two functions `g1` and `g2` from `α` and `M` to `N`, if `g1` and `g2` are equal for all elements in the support of `f`, then the product of `g1` over the support of `f` is equal to the product of `g2` over the support of `f`. Here, the `Finsupp.prod` function is defined as the product of `g a (f a)` over the support of `f`, where `f` is a function from `α` to `M` and `g` is a function from `α` and `M` to `N`.

For functions `f: α → M` with `M` being a commutative monoid, and `g1, g2: α × M → N`, if `g1 (x, m) = g2 (x, m)` for all `x ∈ supp (f)` and `m ∈ im (f)`, then `∏ x in supp (f), g1 x (f x) = ∏ x in supp (f), g2 x (f x)`.


theorem CategoryTheory.Presieve.compatible_iff_sieveCompatible :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {S : CategoryTheory.Sieve X} (x : CategoryTheory.Presieve.FamilyOfElements P S.arrows),
      CategoryTheory.Presieve.FamilyOfElements.Compatible x ↔
        CategoryTheory.Presieve.FamilyOfElements.SieveCompatible x :=
  by sorry

This theorem is stating a property in category theory, specifically dealing with functors, sieves, and presieves. It says that for any category `C`, a functor `P` from the opposite category `Cᵒᵖ` to a type `w`, an object `X` in `C`, a sieve `S` of `X`, and a family of elements `x` of `P` indexed by the arrows of `S`, the family of elements `x` is compatible (in the sense of presieves) if and only if it is sieve-compatible.

For any category C, functor P from Cⁱ to a type w, object X in C, sieve S of X, and family x of elements of P indexed by the arrows of S, the family x is a compatible presheaf if and only if it is sieve-compatible.


theorem dite_dite_distrib_right :
    ∀ {α : Sort u_1} {p q : Prop} [inst : Decidable p] [inst_1 : Decidable q] {a : p → q → α} {b : p → ¬q → α}
      {c : ¬p → α},
      dite p (fun hp => dite q (a hp) (b hp)) c =
        if hq : q then dite p (fun hp => a hp hq) c else dite p (fun hp => b hp hq) c :=
  by sorry

This theorem states that for any type `α`, propositions `p` and `q`, a function `a` from proofs of `p` and `q` to `α`, a function `b` from proofs of `p` and negation of `q` to `α`, and a function `c` from disproofs of `p` to `α`, the function that returns `a` if `p` and `q` are true, `b` if `p` is true and `q` is false, and `c` if `p` is false, is equivalent to the function that first checks `q`: if `q` is true, it behaves like `a` if `p` is true and `c` otherwise, and if `q` is false, it behaves like `b` if `p` is true and `c` otherwise. This theorem basically states that the order of checking the propositions `p` and `q` does not affect the result.

Given functions `a` from proofs of `p` and `q`, `b` from proofs of `p` and negation of `q`, `c` from disproofs of `p`, and a type `α`, the functions `a if p and q else b if p and q neg else c if not p` and `if q then a if p else b if p else c` are equivalent.


theorem CategoryTheory.μ_hom_inv_app :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} M] [inst_2 : CategoryTheory.MonoidalCategory M]
      (F : CategoryTheory.MonoidalFunctor M (CategoryTheory.Functor C C)) (i j : M) (X : C),
      CategoryTheory.CategoryStruct.comp ((F.μ i j).app X) ((CategoryTheory.MonoidalFunctor.μIso F i j).inv.app X) =
        CategoryTheory.CategoryStruct.id ((CategoryTheory.MonoidalCategory.tensorObj (F.obj i) (F.obj j)).obj X) :=
  by sorry

The theorem `CategoryTheory.μ_hom_inv_app` states that for any type `C` forming a category, another type `M` also forming a category and being a Monoidal category, and a Monoidal functor `F` mapping from `M` to the endomorphisms on `C`, then for all `i`, `j` in `M` and `X` in `C`, the composition of the application of the morphism `F.μ i j` to `X` and the application of the inverse of the morphism `CategoryTheory.MonoidalFunctor.μIso F i j` to `X` is equivalent to the identity morphism on the object resulting from the tensor product of `F.obj i` and `F.obj j` applied to `X`. Here, `F.μ i j` and `CategoryTheory.MonoidalFunctor.μIso F i j` refer to specific morphisms related to the monoidal structure of `F`.

For any monoidal functor F from a monoidal category M to the endomorphisms on a category C, the application of F.μ i j, followed by the inverse of F.μIso i j, is equivalent to the identity morphism on the tensor product of F.obj i and F.obj j in C.


theorem Mathlib.Algebra.Function.Indicator._auxAddLemma.4 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {x : α}, (x ∈ Function.support f) = (f x ≠ 0) := by
  sorry

This theorem, named `Mathlib.Algebra.Function.Indicator._auxAddLemma.4`, states that for any type `α` and `M` where `M` is a type with a zero element, and given any function `f` from `α` to `M` and any element `x` of type `α`, the statement "x is in the support of f" is equivalent to "the value of function f at x is not equal to zero". Here, the `support` of a function is defined as the set of points `x` such that `f(x) ≠ 0`.

For any type `α` and `M` with a zero element, and any function `f` from `α` to `M`, the element `x` is in the support of `f` if and only if `f(x) ≠ 0`.


theorem ProbabilityTheory.mgf_zero' :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
      ProbabilityTheory.mgf X μ 0 = (↑↑μ Set.univ).toReal :=
  by sorry

The theorem `ProbabilityTheory.mgf_zero'` states that for any type `Ω`, any measurable space `m` on `Ω`, any real-valued random variable `X` on `Ω`, and any measure `μ` on the measurable space, the moment generating function of `X` with respect to the measure `μ` evaluated at zero is equal to the real value of the total measure of the universal set. In mathematical terms, this is saying that if `X` is a real-valued random variable on a measurable space `(Ω, m)` with measure `μ`, then `M_X(0) = μ(Ω)`, where `M_X(t)` is the moment generating function of `X` and `Ω` represents the entire space.

For any measurable space (Ω, m) with measure μ, and real-valued random variable X on Ω, the moment generating function M\_X(0) equals the total measure μ(Ω).


theorem Monoid.CoprodI.Word.of_smul_def :
    ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)]
      [inst_2 : DecidableEq ι] (i : ι) (w : Monoid.CoprodI.Word M) (m : M i),
      Monoid.CoprodI.of m • w =
        Monoid.CoprodI.Word.rcons
          (let __src := (Monoid.CoprodI.Word.equivPair i) w;
          { head := m * ((Monoid.CoprodI.Word.equivPair i) w).head, tail := __src.tail, fstIdx_ne := ⋯ }) :=
  by sorry

The theorem `Monoid.CoprodI.Word.of_smul_def` states that for any type `ι`, function `M : ι → Type u_2`, where each `M i` is a monoid, and each `M i` and `ι` have decidable equality, for any `i : ι`, word `w : Monoid.CoprodI.Word M` and element `m : M i`, the operation of the inclusion of `m` into the free product acting on `w` is equal to the operation of constructing a new word by prepending `m` multiplied by the head of `w` (when `w` is viewed as a pair) to the tail of `w`, unless this product is the identity of the monoid `M i`, in which case we just return the tail of `w`. In other words, this means that the action of the inclusion of `m` into the free product on a word is defined by multiplication on the leftmost element of the word from `M i`.

For any monoid-valued family `M : ι → Type` and decidably equal types `ι` and `M i`, the operation of including an element `m : M i` into the free product of `M i` acting on a `Monoid.CoprodI.Word w : Monoid.CoprodI.Word M i` is equal to prepending the product of `m` and the head of `w`, or the tail of `w` if the product is the identity of `M i`.


theorem lowerClosure_iUnion :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : Preorder α] (f : ι → Set α),
      lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i) :=
  by sorry

This theorem states that for any type `α` with a preorder relation, and any indexed family `f` of sets of `α` indexed by `ι`, the least lower set that contains the union of sets given by `f` is equal to the supremum of the least lower sets of each set in the family `f`. In other words, the lower closure operation distributes over the union operation, which can alternatively be viewed as the supremum of the lower closures being equal to the lower closure of the unions.

For any type `α` with a preorder relation, and any indexed family `f` of subsets of `α` indexed by `ι`, the lower closure of the union of `f` is equal to the supremum of the lower closures of each set in `f`.


theorem R1Space.induced :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : R1Space X] (f : Y → X), R1Space Y := by sorry

This theorem states that for any two types `X` and `Y`, where `X` is a topological space and also an `R1Space` (a space with separable points), and `f` is a function from `Y` to `X`, then `Y` is also an `R1Space`. In other words, the R1 space property (separability of points) is preserved under mapping from `Y` to `X`.

If `X` is an `R1Space` topological space and `f` is a function from an arbitrary topological space `Y` to `X`, then `Y` is an `R1Space`.


/-- If `edist (f n) (f (n+1))` is bounded by `C * r^n`, then the distance from
`f n` to the limit of `f` is bounded above by `C * r^n / (1 - r)`.  -/
theorem edist_le_of_edist_le_geometric_of_tendsto :
    ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (r C : ENNReal) {f : ℕ → α},
      (∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n) →
        ∀ {a : α}, Filter.Tendsto f Filter.atTop (nhds a) → ∀ (n : ℕ), edist (f n) a ≤ C * r ^ n / (1 - r) :=
  by sorry

This theorem states that if the extended distance (`edist`) between `f(n)` and `f(n+1)` for a sequence of points `{f(n)}` in a pseudo-emetric space is bounded by `C * r^n`, where `C` and `r` are extended nonnegative real numbers (`ENNReal`), then the extended distance between `f(n)` and the limit `a` of the sequence `{f(n)}` is bounded above by `C * r^n / (1 - r)`. This limit is approached as `n` tends to infinity (`Filter.atTop`), which is assumed by the hypothesis `Filter.Tendsto f Filter.atTop (nhds a)`. Essentially, it provides an upper bound on the distance from `f(n)` to the limit `a` of the sequence `{f(n)}` in terms of a geometric series.

If a sequence `{f(n)}` in a pseudo-metric space converges to `a` (`Filter.Tendsto f Filter.atTop (nhds a)`) and the extended distance between `f(n)` and `f(n+1)` is bounded by `C * r^n`, then the extended distance between `f(n)` and `a` is bounded above by `C * r^n / (1 - r)`.


theorem CategoryTheory.ShortComplex.opcyclesMap'_g' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂)
          (CategoryTheory.ShortComplex.RightHomologyData.g' h₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.g' h₁) φ.τ₃ :=
  by sorry

The theorem `CategoryTheory.ShortComplex.opcyclesMap'_g'` in Lean 4 is a statement about the composition of morphisms in a category theoretical context, specifically dealing with the concept of short complexes. In more natural language, it states that for any category `C` (with zero morphisms), and for any two short complexes `S₁` and `S₂` in `C` with the morphism `φ : S₁ ⟶ S₂`, the composition of `opcyclesMap'` with `g'` for `h₂` (Right Homology Data of `S₂`) is equal to the composition of `g'` for `h₁` (Right Homology Data of `S₁`) with `φ.τ₃`. In other words, it is asserting that a certain diagram in the category of short complexes commutes, which is a fundamental concept in category theory. The morphisms `g'` are determined by the cokernels in the short complexes, and `φ.τ₃` is a part of the morphism from `S₁` to `S₂`.

For any category `C` with zero morphisms, given short complexes `S₁` and `S₂` and morphism `φ : S₁ ⟶ S₂`, the diagram commutes: `opcyclesMap' (h₂) (g₂) ∘ g₁' (h₁) = g₂' (h₁) ∘ φ.τ₃`, where `g₁'` and `g₂'` are determined by the cokernels in `S₁` and `S₂`, respectively.


theorem Lagrange.interpolate_apply :
    ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] (s : Finset ι) (v r : ι → F),
      (Lagrange.interpolate s v) r = Finset.sum s fun i => Polynomial.C (r i) * Lagrange.basis s v i :=
  by sorry

The theorem `Lagrange.interpolate_apply` asserts that for any field `F`, index set `ι` with a decidable equality relation, a finite set `s` of indices, and two functions `v` and `r` mapping from `ι` to `F`, the application of the Lagrange interpolation function to `s` and `v`, evaluated at `r`, is equivalent to the sum over `s` of the product of the constant polynomial based on `r i` and the Lagrange basis polynomial for `s`, `v`, and `i`. In simpler terms, this theorem establishes the relationship between the Lagrange interpolation of a set of points and the sum of the products of their corresponding constant polynomials and basis polynomials.

The theorem asserts that the value of the Lagrange interpolation function of a set of points and their corresponding constants, evaluated at a given point, equals the sum of the products of the constants and the basis polynomials for each point.


theorem WithBot.mul_bot :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {a : WithBot α}, a ≠ 0 → a * ⊥ = ⊥ := by sorry

The theorem `WithBot.mul_bot` asserts that for any type `α` (where `α` has decidable equality and is a multiplication-zero class), and any element `a` of the type `WithBot α` (which is `α` extended with a "bottom" element), if `a` is not zero then the product of `a` and the bottom element is the bottom element. In other words, for any non-zero element in an extended type, multiplication with the added bottom element results in the bottom element. This is akin to the principle that any number except zero, when multiplied with infinity (or an undefined value), results in an undefined value or infinity.

For any type `α` with decidable equality and multiplication-zero class, and any non-zero element `a` in the extended type `WithBot α`, `a * ⊥ = ⊥`, where `⊥` denotes the bottom element.


theorem Part.some_injective : ∀ {α : Type u_1}, Function.Injective Part.some := by sorry

The theorem `Part.some_injective` states that for any type `α`, the function `Part.some` is injective. In other words, if we have two values of type `α`, say `a₁` and `a₂`, and if `Part.some a₁` equals `Part.some a₂`, then it must be the case that `a₁` equals `a₂`. This injectivity property means that `Part.some` function does not map different inputs to the same output.

For any type `α`, the function `Part.some : α option → α` is an injection.


/-- If `f` and `g` agree on the integers then they are equal `φ`.  -/
theorem MonoidWithZeroHom.ext_rat' :
    ∀ {F : Type u_1} {M₀ : Type u_5} [inst : MonoidWithZero M₀] [inst_1 : FunLike F ℚ M₀]
      [inst : MonoidWithZeroHomClass F ℚ M₀] {f g : F}, (∀ (m : ℤ), f ↑m = g ↑m) → f = g :=
  by sorry

This theorem `MonoidWithZeroHom.ext_rat'` states that for any two objects `f` and `g` of type `F`, both mapping from rational numbers to a `MonoidWithZero` type `M₀`, if `f` and `g` agree on all integer values (that is, for any integer `m`, the result of applying `f` to `m` is equal to the result of applying `g` to `m`), then `f` and `g` are the same. Here `FunLike F ℚ M₀` ensures `F` acts like a function from `ℚ` to `M₀`, and `MonoidWithZeroHomClass F ℚ M₀` ensures `F` respects the monoid with zero structure from `ℚ` to `M₀`.

If two functions from rational numbers to a `MonoidWithZero` type agree on all integers, then they are equal.


theorem nhds_left_sup_nhds_right :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] (a : α),
      nhdsWithin a (Set.Iic a) ⊔ nhdsWithin a (Set.Ici a) = nhds a :=
  by sorry

This theorem states that for any type `α` considered as a topological space and equipped with a linear order, and for any element `a` of `α`, the supremum (join in the filter lattice) of the "neighborhood within" filters at `a` over the sets of all elements less than or equal to `a` and all elements greater than or equal to `a` equals the neighborhood filter at `a`. In other words, the union of the filters that contain the neighborhoods of `a` within both the left-closed right-infinite interval and the left-infinite right-closed interval gives us the filter that contains the neighborhoods of `a` in the entire space.

For any type `α` with a linear order and any element `a` in `α`, the supremum of the neighborhood filters at `a` within the left-closed right-infinite and left-infinite right-closed intervals equals the neighborhood filter at `a`.


/-- If `M` is nondegenerate and `w * M * v = 0` for all `w`, then `v = 0`.  -/
theorem Matrix.Nondegenerate.eq_zero_of_ortho :
    ∀ {m : Type u_1} {R : Type u_2} [inst : Fintype m] [inst_1 : CommRing R] {M : Matrix m m R},
      Matrix.Nondegenerate M → ∀ {v : m → R}, (∀ (w : m → R), Matrix.dotProduct v (Matrix.mulVec M w) = 0) → v = 0 :=
  by sorry

The theorem `Matrix.Nondegenerate.eq_zero_of_ortho` states that for a given nondegenerate matrix `M` with entries in a commutative ring `R` and indexed by `m`, if for every vector `w`, the dot product of vector `v` and the matrix-vector product of `M` and `w` equals zero, then the vector `v` must be the zero vector. In other words, if `M` is nondegenerate and the dot product of `v` and `Mw` is zero for all `w`, then `v` must be zero. This theorem is crucial in linear algebra, as it provides a condition under which a vector must be the zero vector in the context of nondegenerate matrices.

If a nondegenerate matrix times any vector results in the zero vector for the dot product, then the original vector is the zero vector.


theorem sbtw_irrefl_left_right : ∀ {α : Type u_1} [inst : CircularPreorder α] {a b : α}, ¬sbtw a b a := by sorry

This theorem states that for any type `α`, which forms a circular preorder, and any elements `a` and `b` of this type, `a` cannot be strictly between `a` and `b`. In other words, in the context of a circular preorder, it is not possible for an element to be strictly between itself and another element.

In a circular preorder, no element is strictly between itself and another element.


theorem CompactT2.Projective.extremallyDisconnected :
    ∀ {X : Type u} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] [inst_2 : T2Space X],
      CompactT2.Projective X → ExtremallyDisconnected X :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure, if `X` is a compact Hausdorff space (also known as a T2 space), and if `X` is projective in the sense of the CompactT2 theory, then `X` is extremally disconnected. In topological terms, an extremally disconnected space is one where the closure of every open set is open.

If `X` is a compact Hausdorff and projective space in the sense of the CompactT2 theory, then `X` is an extremally disconnected topological space.


theorem MeasureTheory.Integrable.integrableAtFilter :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.Integrable f μ → ∀ (l : Filter α), MeasureTheory.IntegrableAtFilter f l μ :=
  by sorry

The theorem `MeasureTheory.Integrable.integrableAtFilter` states that for any given measurable space `α`, type `E` forming a Normed Additive Commutative Group, a function `f` mapping from `α` to `E`, and a measure `μ` on `α`, if the function `f` is integrable with respect to the measure `μ`, then `f` is integrable at any filter `l` on `α` with respect to the same measure `μ`. In other words, if a function is integrable over the whole space, it is also integrable over any subset of that space described by a filter.

If a measurable function is integrable with respect to a measure, then it is integrable with respect to any filter on the measurable space with respect to the same measure.


EckmannHilton.mul

/-- If a type carries two unital binary operations that distribute over each other,
then these operations are equal.

In fact, they give a commutative monoid structure, see `eckmann_hilton.CommMonoid`.  -/
theorem EckmannHilton.mul :
    ∀ {X : Type u} {m₁ m₂ : X → X → X} {e₁ e₂ : X},
      EckmannHilton.IsUnital m₁ e₁ →
        EckmannHilton.IsUnital m₂ e₂ → (∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)) → m₁ = m₂ :=
  by sorry

This theorem, named Eckmann Hilton's theorem, states that if a type has two unital binary operations that distribute over each other, then these two operations must be identical. More specifically, for a particular type `X`, if operations `m₁` and `m₂` are unital with unit elements `e₁` and `e₂` respectively, and if these operations distribute over each other for all elements `a, b, c, d` of `X` (i.e., `m₁` of (`m₂` of `a` and `b`) and (`m₂` of `c` and `d`) equals `m₂` of (`m₁` of `a` and `c`) and (`m₁` of `b` and `d`)), then `m₁` equals `m₂`. This theorem also implies that these operations give a commutative monoid structure.

If two unital binary operations `m₁` and `m₂` on a type `X` distribute over each other, then they are identical.


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

The theorem `ManyOneEquiv.le_congr_right` states that for all types `α`, `β`, and `γ`, which have the `Primcodable` property, and for all propositions `p` that maps from type `α` to `Prop`, `q` from `β` to `Prop`, and `r` from `γ` to `Prop`, if `q` and `r` are many-one equivalent (meaning that each one is many-one reducible to the other), then `p` is many-one reducible to `q` if and only if `p` is many-one reducible to `r`. In simple terms, if `q` and `r` are interchangeable via many-one reduction, then `p`'s reducibility to `q` is equivalent to its reducibility to `r`.

For types `α`, `β`, `γ` with `Primcodable` property and propositions `p : α → Prop`, `q : β → Prop`, `r : γ → Prop`, if `q` and `r` are many-one equivalent, then `p` is many-one reducible to `q` if and only if it is many-one reducible to `r`.


theorem ArithmeticFunction.zeta_apply_ne : ∀ {x : ℕ}, x ≠ 0 → ArithmeticFunction.zeta x = 1 := by sorry

The theorem `ArithmeticFunction.zeta_apply_ne` states that for any natural number `x`, as long as `x` is not equal to zero, the value of the function `ArithmeticFunction.zeta` at `x` is equal to one. This is a characteristic of the Dirichlet Series, also known as the Riemann `ζ` function, where the function value is `1` for any non-zero natural number.

For any natural number `x` unequal to zero, `ArithmeticFunction.zeta x = 1`.


theorem Polynomial.content_mul :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {p q : Polynomial R},
      Polynomial.content (p * q) = Polynomial.content p * Polynomial.content q :=
  by sorry

The theorem `Polynomial.content_mul` states that for any commutative ring `R` that is also a domain and a normalized GCD monoid, and any two polynomials `p` and `q` with coefficients in `R`, the content (i.e., the greatest common divisor of the coefficients) of the polynomial resulting from multiplying `p` and `q` is equal to the product of the contents of `p` and `q`.

For any commutative domain and normalized GCD monoid ring R, and polynomials p and q over R, the content of p q equals the product of the contents of p and q.


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

This theorem states that for all types `α` with a measurable space `m0` and a measure `μ`, and for any set `s` of type `α`, if the measure of the set `s` equals zero, then the set `s` is a Null Measurable Set. In mathematical terms, for a measure space (α, m0, μ) and a set s of α, if the measure of s is 0 (i.e., μ(s) = 0), then s is a null measurable set.

If the measure of a set in a measurable space is zero, then the set is a null measurable set.


/-- Two bases are equal if their basis vectors are the same.  -/
theorem Basis.eq_of_apply_eq :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {b₁ b₂ : Basis ι R M}, (∀ (i : ι), b₁ i = b₂ i) → b₁ = b₂ :=
  by sorry

This theorem states that for any two bases `b₁` and `b₂` of a module `M` over a semiring `R`, indexed over a common index set `ι`, if every basis vector of `b₁` is equal to the corresponding basis vector of `b₂`, then the bases `b₁` and `b₂` are equal.

If two bases `b₁` and `b₂` of a module `M` over a semiring `R`, indexed over a common index set `ι`, have the same basis vectors, then `b₁` and `b₂` are equal.


/-- Every point is a fixed point of `id`.  -/
theorem Function.isFixedPt_id : ∀ {α : Type u} (x : α), Function.IsFixedPt id x := by sorry

The theorem `Function.isFixedPt_id` states that for every type `α` and for every point `x` of type `α`, `x` is a fixed point of the identity function `id`. In other words, applying the identity function to any point `x` will always return `x`, which is the definition of a fixed point according to `Function.IsFixedPt`. This is a fundamental property of the identity function in mathematics, conveyed as $\forall x \in \alpha, id(x) = x$.

For all types `α` and points `x` of type `α`, the identity function `id` maps `x` to a fixed point `x`. In Lean: `Function.isFixedPt id x`.


theorem Basis.det_apply :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_4}
      [inst_3 : DecidableEq ι] [inst_4 : Fintype ι] (e : Basis ι R M) (v : ι → M),
      (Basis.det e) v = Matrix.det (Basis.toMatrix e v) :=
  by sorry

The theorem `Basis.det_apply` states that, for any commutative ring `R`, any type `M` forming an additive commutative group and an `R`-module, any finite type `ι`, any basis `e` of type `M` over `R` indexed by `ι`, and any family of vectors `v` (indexed by `ι` and of type `M`), the determinant of the vectors `v` with respect to the basis `e` is equal to the determinant of the matrix representation of the vectors `v` in the basis `e`. In other words, it asserts that the determinant computed directly from the vectors and the determinant computed from their matrix representation in a certain basis are the same.

For any commutative ring R, any additive commutative group and R-module M, finite index type ι, basis e of M over R, and family v of vectors in M indexed by ι, the determinant of the vectors v with respect to the basis e equals the determinant of the matrix representation of the vectors v in the basis e.


theorem List.forall₂_refl :
    ∀ {α : Type u_1} {Rₐ : α → α → Prop} [inst : IsRefl α Rₐ] (l : List α), List.Forall₂ Rₐ l l := by sorry

This theorem states that for any type `α` and a binary predicate `Rₐ` on `α`, given that `Rₐ` is reflexive (as specified by `IsRefl α Rₐ`), for any list `l` of type `List α`, `List.Forall₂ Rₐ l l` holds true. In other words, each element in the list `l` is in relation `Rₐ` with itself.

For any type `α` and reflexive binary relation `Rₐ` on `α`, `List.Forall₂ Rₐ l l` holds for all lists `l` of type `List α`. That is, each element in `l` is related to itself via `Rₐ`.


/-- Given a pushout square assembled from a pushout square on the top and
a commuting square on the bottom, the bottom square is a pushout square.  -/
theorem CategoryTheory.IsPushout.of_bot :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
      {h₂₁ : X₂₁ ⟶ X₂₂} {h₃₁ : X₃₁ ⟶ X₃₂} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂},
      CategoryTheory.IsPushout h₁₁ (CategoryTheory.CategoryStruct.comp v₁₁ v₂₁)
          (CategoryTheory.CategoryStruct.comp v₁₂ v₂₂) h₃₁ →
        CategoryTheory.CategoryStruct.comp h₂₁ v₂₂ = CategoryTheory.CategoryStruct.comp v₂₁ h₃₁ →
          CategoryTheory.IsPushout h₁₁ v₁₁ v₁₂ h₂₁ → CategoryTheory.IsPushout h₂₁ v₂₁ v₂₂ h₃₁ :=
  by sorry

The theorem `CategoryTheory.IsPushout.of_bot` in the Category Theory states that given a "pushout" square which is assembled from an upper pushout square and a lower commuting square, the lower square will also be a pushout square under certain conditions. In more detail, for any objects `X₁₁`, `X₁₂`, `X₂₁`, `X₂₂`, `X₃₁`, `X₃₂` and morphisms `h₁₁`, `h₂₁`, `h₃₁`, `v₁₁`, `v₁₂`, `v₂₁`, `v₂₂` in a category `C`, if the composite of `v₁₁` and `v₂₁` along with `h₁₁` forms a pushout, and the composite of `v₁₂` and `v₂₂` along with `h₃₁` forms a pushout, and the composite of `h₂₁` and `v₂₂` is equal to the composite of `v₂₁` and `h₃₁`, then if the composite of `h₁₁` and `v₁₁` along with `h₂₁` forms a pushout, it implies that the composite of `h₂₁` and `v₂₁` along with `h₃₁` also forms a pushout.

If a pushout square is obtained by assembling an upper pushout square and a commutative lower square, and the two composites in the lower square form pushouts, then the composite of the morphisms in the lower square forming the pushout in the upper square also forms a pushout.


theorem Irrational.int_mul : ∀ {x : ℝ}, Irrational x → ∀ {m : ℤ}, m ≠ 0 → Irrational (↑m * x) := by sorry

The theorem `Irrational.int_mul` states that for all real numbers `x`, if `x` is irrational (i.e., it cannot be expressed as a ratio of integers), then for all integers `m` not equal to zero, the product of `m` and `x` (with `m` cast to a real number) is also irrational. In mathematical terms, it asserts that the product of an irrational number and a nonzero integer is always an irrational number.

If `x` is an irrational real number, then for all nonzero integers `m`, the product `m * x` is also an irrational real number.


theorem Cardinal.mk_ne_zero : ∀ (α : Type u) [inst : Nonempty α], Cardinal.mk α ≠ 0 := by sorry

The theorem `Cardinal.mk_ne_zero` states that for any given type `α`, if `α` is nonempty (i.e., there exists at least one element in `α`), then the cardinality of `α` is not zero. In other words, it affirms that any nonempty type has a cardinality that is not zero.

If a type `α` is nonempty, then its cardinality is nonzero.


theorem Polynomial.coeff_expand_mul :
    ∀ {R : Type u} [inst : CommSemiring R] {p : ℕ},
      0 < p →
        ∀ (f : Polynomial R) (n : ℕ), Polynomial.coeff ((Polynomial.expand R p) f) (n * p) = Polynomial.coeff f n :=
  by sorry

This theorem states that for any commutative semiring `R`, any non-zero natural number `p`, any polynomial `f` over `R`, and any natural number `n`, if we expand the polynomial `f` by a factor of `p` to create a new polynomial, then the coefficient of `X^(n*p)` in the new expanded polynomial is the same as the coefficient of `X^n` in the original polynomial `f`. Essentially, the `Polynomial.coeff_expand_mul` theorem describes a property of polynomial expansion in the context of commutative semirings.

For any commutative semiring `R`, polynomial `f` over `R`, natural number `p`, and `n`, the coefficient of `X^(n*p)` in the expanded polynomial `p*f` is equal to the coefficient of `X^n` in `f`.


IsMaxFilter.min

theorem IsMaxFilter.min :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMaxFilter g l a → IsMaxFilter (fun x => min (f x) (g x)) l a :=
  by sorry

The theorem `IsMaxFilter.min` states that for all types `α` and `β`, where `β` has a linear order, for all functions `f` and `g` from `α` to `β`, for all elements `a` of type `α`, and for all filters `l` on `α`, if `f` has a maximum at `a` with respect to the filter `l` and `g` also has a maximum at `a` with respect to the same filter `l`, then the function that assigns to each element `x` the minimum of `f(x)` and `g(x)` also has a maximum at `a` with respect to the filter `l`. In other words, if `f` and `g` both have their maximum values (in the order of `β`) at `a` within a neighborhood defined by `l`, then the minimum of `f` and `g` at each point also achieves its maximum value at `a` within the same neighborhood.

If functions `f` and `g` have equal maximum values at `a` with respect to filter `l` on type `α`, then the function `x ↔> min (f x) (g x)` has a maximum at `a` with respect to filter `l` on type `α`, where `min` is the pointwise minimum and `↔>` is the reverse arrow denoting maximum.


SimpleGraph.Walk.reachable

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

This theorem states that for any given type `V`, any Simple Graph `G` of type `V`, and any two vertices `u` and `v` of type `V`, if there is a walk from vertex `u` to vertex `v` in the graph `G`, then the vertices `u` and `v` are reachable. In other words, the existence of a walk between two vertices in a simple graph implies that these two vertices are reachable from each other.

In a simple graph, the existence of a walk between two vertices implies their reachability.


theorem IsOpen.exists_vadd_mem :
    ∀ (M : Type u_1) {α : Type u_3} [inst : AddMonoid M] [inst_1 : TopologicalSpace α] [inst_2 : AddAction M α]
      [inst_3 : AddAction.IsMinimal M α] (x : α) {U : Set α}, IsOpen U → Set.Nonempty U → ∃ c, c +ᵥ x ∈ U :=
  by sorry

The theorem `IsOpen.exists_vadd_mem` states that for any type `M`, and a type `α` with an `AddMonoid` structure, a `TopologicalSpace` structure, and an `AddAction.IsMinimal` structure, given any element `x` of type `α` and an open set `U` of type `α` that is non-empty, there exists an element `c` of type `M` such that the 'additive action' of `c` and `x` (represented by `c +ᵥ x`) is an element of `U`. This theorem is a key result relating additive actions to topological structures, particularly relevant in the context of topological vector spaces.

For any `M`, `α` with `AddMonoid`, `TopologicalSpace`, and `AddAction.IsMinimal` structures, given a non-empty open set `U` of `α` and an element `x` of `α`, there exists an element `c` in `M` such that `c +ᵥ x` is in `U`.


theorem Finset.card_pi :
    ∀ {α : Type u_1} [inst : DecidableEq α] {δ : α → Type u_4} (s : Finset α) (t : (a : α) → Finset (δ a)),
      (Finset.pi s t).card = Finset.prod s fun a => (t a).card :=
  by sorry

The theorem `Finset.card_pi` states that for any given finite set `s` of a type `α` with decidable equality, and any function `t` that maps each element `a` of `α` to a finite set of a type `δ a`, the cardinality of the set of all functions (defined on elements of `s` and taking values in `t a` for `a ∈ s`) is equal to the product of the cardinalities of the finite sets `t a` for each element `a` in `s`. In other words, if we have a finite set and a function mapping each element of this set to another finite set, the number of all possible functions we can define is just the product of the sizes of each of the latter sets. This is the notion of product in the context of cardinality of sets of functions.

For any finite set \(s\) of type \(\alpha\) with decidable equality and a function \(t: \alpha \rightarrow \prod\_{a:\alpha} Finset\ delta\_a\), the cardinality of \(Func(s, t)\) equals the product of the cardinalities of \(t\ a\) for all \(a \in s\).


theorem SimpleGraph.not_isDiag_of_mem_edgeSet :
    ∀ {V : Type u} (G : SimpleGraph V) {e : Sym2 V}, e ∈ SimpleGraph.edgeSet G → ¬Sym2.IsDiag e := by sorry

The theorem `SimpleGraph.not_isDiag_of_mem_edgeSet` states that for any type `V` and a simple graph `G` of that type, if `e` is an element of the edge set of the graph `G`, then `e` cannot be on the diagonal. In other words, an edge of a simple graph cannot connect a vertex to itself.

In a simple graph, no edge can connect a vertex to itself.


theorem Ideal.comap_id : ∀ {R : Type u} [inst : Semiring R] (I : Ideal R), Ideal.comap (RingHom.id R) I = I := by sorry

This theorem states that for any semiring `R` and any ideal `I` in `R`, the pre-image of `I` under the identity ring homomorphism is equal to `I` itself. In other words, when we apply the comap function with the identity ring homomorphism to an ideal, we get the same ideal back. This means that the identity ring homomorphism preserves the structure of the ideal in the ring.

For any semiring `R` and ideal `I` in `R`, the preimage of `I` under the identity ring homomorphism equals `I`.


IsMaxFilter.max

theorem IsMaxFilter.max :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMaxFilter g l a → IsMaxFilter (fun x => max (f x) (g x)) l a :=
  by sorry

The theorem `IsMaxFilter.max` states that for any two functions `f` and `g` from any type `α` to any type `β`, with `β` possessing a linear order, if `f` and `g` both satisfy the `IsMaxFilter` property at a point `a` with respect to a filter `l`, then the function which to every `x` assigns the maximum of `f(x)` and `g(x)` also satisfies the `IsMaxFilter` property at `a` with respect to `l`. In other words, if `f x ≤ f a` and `g x ≤ g a` for all `x` in some `l`-neighborhood of `a`, then `max (f x) (g x) ≤ max (f a) (g a)` for all `x` in that `l`-neighborhood.

If functions `f` and `g` from type `α` to ordered type `β` satisfy `IsMaxFilter` at point `a` with respect to filter `l`, then the function `x => max (f x) (g x)` also satisfies `IsMaxFilter` at `a` with respect to `l`.


theorem induction_on_primes :
    ∀ {P : ℕ → Prop}, P 0 → P 1 → (∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)) → ∀ (n : ℕ), P n := by sorry

The theorem `induction_on_primes` states that for any property `P`, which maps natural numbers to a proposition, if `P` holds true for `0` and `1`, and if `P` is true for a natural number `a` and a prime number `p`, then `P` continues to hold true for the product of `p` and `a`, then `P` is true for all natural numbers `n`. This is a form of mathematical induction tailored specifically for prime numbers and their multiples.

If a property holds for 0 and 1, and for any prime number p and natural number a with Pa, then Pa \* p implies Pn for all natural numbers n.


IsUpperSet.inter

theorem IsUpperSet.inter :
    ∀ {α : Type u_1} [inst : LE α] {s t : Set α}, IsUpperSet s → IsUpperSet t → IsUpperSet (s ∩ t) := by sorry

The theorem `IsUpperSet.inter` states that for any type `α` which has a less than or equal to order (`LE`) and for any two sets `s` and `t` of type `α`, if both `s` and `t` are upper sets (meaning for each of them, any element greater than or equal to one of its members is also a member), then their intersection (the set of elements common to both `s` and `t`) is also an upper set. In other words, if you have two sets where each set has the property that any element in the set that is less or equal to another element implies that the larger element is also in the set, this property is preserved in the intersection of the two sets.

If `α` is a type with a LE relation, and `s` and `t` are upper sets of `α`, then their intersection `s ∩ t` is also an upper set.


theorem AddEquivClass.map_eq_zero_iff :
    ∀ {F : Type u_1} {M : Type u_12} {N : Type u_13} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : EquivLike F M N] [inst_3 : AddEquivClass F M N] (h : F) {x : M}, h x = 0 ↔ x = 0 :=
  by sorry

The theorem `AddEquivClass.map_eq_zero_iff` states that for any types `F`, `M`, and `N`, where `M` and `N` are additive groups (i.e., they have a zero element and an addition operation), and `F` is a equivalence between `M` and `N` respecting the addition (i.e., it is an additive equivalence), then for any element `h` of type `F` and any element `x` of type `M`, `h x` equals zero if and only if `x` equals zero. In other words, additive equivalences preserve the zero element.

For any additive groups M, N, and additive equivalence F between them, h ∈ F implies h(x) = 0 if and only if x = 0.


theorem neg_pow_bit1 :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : HasDistribNeg R] (a : R) (n : ℕ), (-a) ^ bit1 n = -a ^ bit1 n := by
  sorry

This theorem states that for any type `R` which is a `Monoid` and also supports negation (`HasDistribNeg`), for any element `a` of type `R` and any natural number `n`, the negative of `a` raised to the power of `2n + 1` (denoted by `bit1 n`) is equal to the negation of `a` raised to the power of `2n + 1`. In mathematical terms, given any `a` in `R` and any natural number `n`, we have `(-a)^(2n + 1) = -(a^(2n + 1))`.

For any monoid `R` with negation (`HasDistribNeg`), and for all `a` in `R` and natural number `n`, `(-a)^(2n + 1) = -(a^(2n + 1))`.


theorem MeasureTheory.Measure.trim.proof_1 :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α),
      m ≤ m0 → m ≤ MeasureTheory.OuterMeasure.caratheodory ↑μ :=
  by sorry

This theorem in measure theory states that for any given type `α`, any two measurable spaces `m` and `m0` over `α`, and a measure `μ` on `α`, if the measurable space `m` is a subset of the measurable space `m0`, then `m` is also a subset of the Carathéodory-measurable space associated with the measure `μ`. Here, the Carathéodory-measurable space is defined such that a set `s` is measurable if for all sets `t`, the measure of `t` equals the sum of the measures of the intersection of `t` with `s` and the difference of `t` and `s`.

If `α` is a type, `μ` is a measure on `α`, and `m` is a measurable space over `α` that is a subset of another measurable space `m0` over `α`, then `m` is a subset of the Carathéodory-measurable space associated with `μ`.


theorem Order.pred_mono : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α], Monotone Order.pred := by sorry

The theorem `Order.pred_mono` states that for any type `α` that has a `Preorder` and a `PredOrder` structure, the predecessor function `Order.pred` is monotone. In other words, if `a` and `b` are elements of `α` and `a ≤ b`, then `Order.pred a ≤ Order.pred b`, where `Order.pred a` and `Order.pred b` are the greatest elements less than `a` and `b` respectively, or equal to `a` and `b` if they are minimal.

For all types `α` with `Preorder` and `PredOrder` structures, the predecessor function `Order.pred` is monotone, that is, `Order.pred a ≤ Order.pred b` whenever `a ≤ b`.


theorem Summable.trans_sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] {f g : β → α}, Summable g → (Summable fun b => f b - g b) → Summable f :=
  by sorry

The theorem `Summable.trans_sub` states that for any two functions `f` and `g` from a type `β` to a type `α`, where `α` is an additive commutative group with a topology that makes it a topological additive group, if the function `g` is summable and the function obtained by subtracting `g` from `f` is also summable, then the function `f` is summable. Here, a function is said to be summable if it has some (possibly infinite) sum. This theorem thus provides a condition under which we can be sure that a given function is summable.

If `g` is summable and `f = g + h` for some summable function `h`, then `f` is summable.


theorem PartialHomeomorph.continuousOn_extend :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H),
      ContinuousOn (↑(PartialHomeomorph.extend f I)) (PartialHomeomorph.extend f I).source :=
  by sorry

The theorem `PartialHomeomorph.continuousOn_extend` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, and topological spaces `M` and `H`, if `f` is a partial homeomorphism from `M` to `H` and `I` is a model with corners on `𝕜`, `E` and `H`, then the extension of `f` via `I` is continuous on its source set. The extension of `f` via `I` is represented by `PartialHomeomorph.extend f I`, and its source set is given by `(PartialHomeomorph.extend f I).source`. A model with corners is a generalization of the concept of a manifold with boundary in differential geometry.

Given a nontrivially normed field `𝕜`, normed additive commutative groups `E` and `H`, normed space `E` over `𝕜`, topological spaces `M` and `H`, and a partial homeomorphism `f` from `M` to `H`, the extension of `f` via a model `I` is continuous on its source set.


theorem AntilipschitzWith.isBounded_of_image2_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β]
      [inst_2 : PseudoMetricSpace γ] (f : α → β → γ) {K₁ : NNReal},
      (∀ (b : β), AntilipschitzWith K₁ fun a => f a b) →
        ∀ {s : Set α} {t : Set β},
          Bornology.IsBounded (Set.image2 f s t) → Bornology.IsBounded s ∨ Bornology.IsBounded t :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with pseudometric space structures, given a binary function `f : α → β → γ` and a nonnegative real number `K₁`, if for all `b` in `β`, the function `a => f a b` is `K₁`-Antilipschitz, then for any sets `s` of `α` and `t` of `β`, if the image of the sets `s` and `t` under the function `f` is bounded (in the sense of bornology), then either the set `s` is bounded or the set `t` is bounded. Here, a function is `K₁`-Antilipschitz if the extended distance between any two points `x` and `y` is less than or equal to `K₁` times the extended distance between `f(x)` and `f(y)`. Boundedness of a set is defined relative to the ambient bornology.

Given types `α`, `β`, and `γ` with pseudometric spaces, a `K₁`-Antilipschitz function `f : α → β → γ`, and sets `s ⊆ α` and `t ⊆ β` with bounded images under `f`, either `s` or `t` is bounded.