ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
/-- A slight reformulation of `IsLocalStructomorphWithinAt` when `f` is a partial homeomorph.
  This gives us an `e` that is defined on a subset of `f.source`. -/
theorem _root_.PartialHomeomorph.isLocalStructomorphWithinAt_iff {G : StructureGroupoid H}
    [ClosedUnderRestriction G] (f : PartialHomeomorph H H) {s : Set H} {x : H}
    (hx : x ∈ f.source ∪ sᶜ) :
    G.IsLocalStructomorphWithinAt (⇑f) s x ↔
      x ∈ s → ∃ e : PartialHomeomorph H H,
      e ∈ G ∧ e.source ⊆ f.source ∧ EqOn f (⇑e) (s ∩ e.source) ∧ x ∈ e.source
-- Mathlib/Algebra/Quandle.lean
@[simp]
theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y
-- Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean
/-- The continued fraction `GenContFract.of v` terminates if and only if `v ∈ ℚ`. -/
theorem terminates_iff_rat (v : K) : (of v).Terminates ↔ ∃ q : ℚ, v = (q : K)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp]
theorem one_le_prob_iff : 1 ≤ μ s ↔ μ s = 1
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem const_isBounded (ι : Type*) [Nonempty ι] {p : Seminorm 𝕜 E} {q : ι' → Seminorm 𝕜₂ F}
    (f : E →ₛₗ[σ₁₂] F) : IsBounded (fun _ : ι => p) q f ↔ ∀ i, ∃ C : ℝ≥0, (q i).comp f ≤ C • p
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem natDegree_X : (X : R[X]).natDegree = 1
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem ediv_eq_iff_eq_mul_left {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a / b = c ↔ a = c * b
-- Mathlib/Order/Interval/Basic.lean
/-- `toDualProd` as an order embedding. -/
@[simps]
def toDualProdHom : NonemptyInterval α ↪o αᵒᵈ × α
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem sin_eq_one_iff {x : ℝ} : sin x = 1 ↔ ∃ k : ℤ, π / 2 + k * (2 * π) = x
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
@[simps]
instance tensorRight (f : a ⟶ b) (g : b ⟶ b)
    [BicategoricalCoherence (𝟙 b) g] : BicategoricalCoherence f (f ≫ g)
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.add_zsmul_eq [AddGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
    f (x + n • c) = (n.negOnePow : ℤ) • f x
-- Mathlib/RingTheory/Polynomial/Quotient.lean
/-- If `P` is a prime ideal of `R`, then `R[x]/(P)` is an integral domain. -/
theorem isDomain_map_C_quotient {P : Ideal R} (_ : IsPrime P) :
    IsDomain (R[X] ⧸ (map (C : R →+* R[X]) P : Ideal R[X]))
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem cast_mk (h : n = m) (i : Nat) (hn : i < n) : cast h ⟨i, hn⟩ = ⟨i, h ▸ hn⟩
-- Mathlib/FieldTheory/IntermediateField.lean
theorem map_injective (f : L →ₐ[K] L') :
    Function.Injective (map f)
-- Mathlib/Data/Finsupp/Basic.lean
lemma embDomain_comapDomain {f : α ↪ β} {g : β →₀ M} (hg : ↑g.support ⊆ Set.range f) :
    embDomain f (comapDomain f g f.injective.injOn) = g
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma iSup_coe_eq_top : ⨆ x, (f x : WithTop α) = ⊤ ↔ ¬BddAbove (range f)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem pairwise_map {l : List α} :
    (l.map f).Pairwise R ↔ l.Pairwise fun a b => R (f a) (f b)
-- Mathlib/MeasureTheory/Function/L1Space.lean
/-- **Hölder's inequality for integrable functions**: the scalar multiplication of an integrable
vector-valued function by a scalar function with finite essential supremum is integrable. -/
theorem Integrable.essSup_smul {𝕜 : Type*} [NormedField 𝕜] [NormedSpace 𝕜 β] {f : α → β}
    (hf : Integrable f μ) {g : α → 𝕜} (g_aestronglyMeasurable : AEStronglyMeasurable g μ)
    (ess_sup_g : essSup (fun x => (‖g x‖₊ : ℝ≥0∞)) μ ≠ ∞) :
    Integrable (fun x : α => g x • f x) μ
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_submodule_right {N : Submodule R M} :
    IsNoetherian R N ↔ ∀ s : Submodule R M, (s ⊓ N).FG
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem hasStrongEpiMonoFactorisations_imp_of_isEquivalence (F : C ⥤ D) [IsEquivalence F]
    [h : HasStrongEpiMonoFactorisations C] : HasStrongEpiMonoFactorisations D
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem smul_mem_pointwise_smul (m : A) (a : α) (S : AddSubgroup A) : m ∈ S → a • m ∈ a • S
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
private theorem cyclotomic_neg_one_pos {n : ℕ} (hn : 2 < n) {R} [LinearOrderedCommRing R] :
    0 < eval (-1 : R) (cyclotomic n R)
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem cliqueFreeOn_of_card_lt {s : Finset α} (h : s.card < n) : G.CliqueFreeOn s n
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem toLinearIsometry_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} :
    f.toLinearIsometry = g.toLinearIsometry ↔ f = g
-- Mathlib/Dynamics/Minimal.lean
/-- An action of a monoid `M` on a topological space is called *minimal* if the `M`-orbit of every
point `x : α` is dense. -/
@[to_additive]
class MulAction.IsMinimal (M α : Type*) [Monoid M] [TopologicalSpace α] [MulAction M α] :
    Prop where
  dense_orbit : ∀ x : α, Dense (MulAction.orbit M x)
-- Mathlib/CategoryTheory/Iso.lean
theorem comp_inv_eq_id (g : X ⟶ Y) [IsIso g] {f : X ⟶ Y} : f ≫ inv g = 𝟙 X ↔ f = g
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[simp]
theorem sheafifyMap_comp {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R) :
    J.sheafifyMap (η ≫ γ) = J.sheafifyMap η ≫ J.sheafifyMap γ
-- Mathlib/Algebra/Order/Hom/Ring.lean
theorem toFun_eq_coe (f : α ≃+*o β) : f.toFun = f
-- Mathlib/RingTheory/Localization/Integral.lean
theorem integerNormalization_eq_zero_iff {p : K[X]} :
    integerNormalization (nonZeroDivisors A) p = 0 ↔ p = 0
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem symm_apply_eq {x y} : e.symm x = y ↔ x = e y
-- Mathlib/Order/Filter/Subsingleton.lean
@[simp]
theorem subsingleton_pure {a : α} : Filter.Subsingleton (pure a)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem abs_cpow_le (z w : ℂ) : abs (z ^ w) ≤ abs z ^ w.re / Real.exp (arg z * im w)
-- Mathlib/Algebra/ModEq.lean
@[simp]
theorem add_modEq_right : a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p]
-- Mathlib/FieldTheory/Perfect.lean
theorem roots_X_pow_char_sub_C {y : R} :
    (X ^ p - C y).roots = p • {(frobeniusEquiv R p).symm y}
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem exists_rep {α : Sort u} {r : α → α → Prop} (q : Quot r) : Exists (fun a => (Quot.mk r a) = q)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_mul_lcm [GCDMonoid α] : ∀ a b : α, Associated (gcd a b * lcm a b) (a * b)
-- Mathlib/Init/Order/LinearOrder.lean
theorem min_eq_left {a b : α} (h : a ≤ b) : min a b = a
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_top : ((⊤ : Opens α) : Set α) = Set.univ
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.toLinAlgEquiv_one : Matrix.toLinAlgEquiv v₁ 1 = LinearMap.id
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
protected theorem hasMFDerivAt : HasMFDerivAt 𝓘(𝕜, E) 𝓘(𝕜, E') f x f
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem maxPowDiv_eq_multiplicity_get {p n : ℕ} (hp : 1 < p) (hn : 0 < n) (h : Finite p n) :
    p.maxPowDiv n = (multiplicity p n).get h
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem isBounded_Ico (a b : α) : IsBounded (Ico a b)
-- Mathlib/Condensed/Basic.lean
@[simp]
lemma comp_val {X Y Z : Condensed.{u} C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).val = f.val ≫ g.val
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp]
theorem add_snd (x y : X q) : (x + y).2 = x.2 + y.2
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
/-- The `StarSubalgebra.inclusion` of a closed star subalgebra is a `ClosedEmbedding`. -/
theorem closedEmbedding_inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂)
    (hS₁ : IsClosed (S₁ : Set A)) : ClosedEmbedding (inclusion h)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem trans_target' : (e.trans e').target = e'.target ∩ e'.symm ⁻¹' (e'.source ∩ e.target)
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
lemma Shatters.exists_inter_eq_singleton (hs : Shatters 𝒜 s) (ha : a ∈ s) : ∃ t ∈ 𝒜, s ∩ t = {a}
-- Mathlib/RingTheory/LaurentSeries.lean
theorem single_zpow (n : ℤ) :
    single (n : ℤ) (1 : F) = single (1 : ℤ) 1 ^ n
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem _root_.BoxIntegral.Prepartition.distortion_biUnionTagged (π : Prepartition I)
    (πi : ∀ J, TaggedPrepartition J) :
    (π.biUnionTagged πi).distortion = π.boxes.sup fun J => (πi J).distortion
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_singleton_eq_range {α β : Type*} (f : α → β) : ⋃ x : α, {f x} = range f
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
/-- If `s : Set 𝕜` with `RCLike 𝕜` is compact and contains `0`, then the non-unital star subalgebra
generated by the identity function in `C(s, 𝕜)₀` is dense. This can be seen as a version of the
Weierstrass approximation theorem. -/
lemma ContinuousMapZero.adjoin_id_dense {s : Set 𝕜} [Zero s] (h0 : ((0 : s) : 𝕜) = 0)
    [CompactSpace s] : Dense (adjoin 𝕜 {(.id h0 : C(s, 𝕜)₀)} : Set C(s, 𝕜)₀)
-- Mathlib/Order/Hom/Basic.lean
/-- Restriction of `f : α →o α →o β` to the diagonal. -/
@[simps! (config := { simpRhs := true })]
def onDiag (f : α →o α →o β) : α →o β
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
theorem IsSymmetric.conj_inner_sym {T : E →ₗ[𝕜] E} (hT : IsSymmetric T) (x y : E) :
    conj ⟪T x, y⟫ = ⟪T y, x⟫
-- Mathlib/Order/Heyting/Boundary.lean
@[simp]
theorem boundary_hnot_hnot (a : α) : ∂ (￢￢a) = ∂ (￢a)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma natCast_ne_top (n : ℕ) : (n : WithTop α) ≠ ⊤
-- Mathlib/CategoryTheory/GradedObject.lean
lemma hasMap (c : ∀ j, CofanMapObjFun X p j) (hc : ∀ j, IsColimit (c j)) :
    X.HasMap p
-- Mathlib/Topology/UrysohnsLemma.lean
theorem approx_of_mem_C (c : CU P) (n : ℕ) {x : X} (hx : x ∈ c.C) : c.approx n x = 0
-- Mathlib/Data/List/Forall2.lean
theorem Forall₂.flip : ∀ {a b}, Forall₂ (flip R) b a → Forall₂ R a b
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul]
theorem ofLex_pow [Pow α β] (a : Lex α) (b : β) : ofLex (a ^ b) = ofLex a ^ b
-- Mathlib/Analysis/Convex/Gauge.lean
/-- The gauge evaluated at `0` is always zero (mathematically this requires `0` to be in the set `s`
but, the real infimum of the empty set in Lean being defined as `0`, it holds unconditionally). -/
@[simp]
theorem gauge_zero : gauge s 0 = 0
-- Mathlib/RingTheory/Congruence/Opposite.lean
lemma unop_iff {c : RingCon Rᵐᵒᵖ} {x y : R} : c.unop x y ↔ c (.op y) (.op x)
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The value of `affineCombination`, where the given points are equal. -/
@[simp]
theorem affineCombination_apply_const (w : ι → k) (p : P) (h : ∑ i ∈ s, w i = 1) :
    s.affineCombination k (fun _ => p) w = p
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem map_id (m : OuterMeasure α) : map id m = m
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
/-- An alternative statement of the Stone-Weierstrass theorem.

If `A` is a subalgebra of `C(X, ℝ)` which separates points (and `X` is compact),
every real-valued continuous function on `X` is a uniform limit of elements of `A`.
-/
theorem continuousMap_mem_subalgebra_closure_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
    (w : A.SeparatesPoints) (f : C(X, ℝ)) : f ∈ A.topologicalClosure
-- Mathlib/Dynamics/Flow.lean
/-- If `τ` is a `CanonicallyOrderedAddCommMonoid` (e.g., `ℕ` or `ℝ≥0`), then the notions
`IsFwInvariant` and `IsInvariant` are equivalent. -/
theorem IsFwInvariant.isInvariant [CanonicallyOrderedAddCommMonoid τ] {ϕ : τ → α → α} {s : Set α}
    (h : IsFwInvariant ϕ s) : IsInvariant ϕ s
-- Mathlib/Algebra/Order/Archimedean.lean
theorem existsUnique_add_zsmul_mem_Ico {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b + m • a ∈ Set.Ico c (c + a)
-- .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean
theorem eraseIdx_append_of_lt_length {l : List α} {k : Nat} (hk : k < length l) (l' : List α) :
    eraseIdx (l ++ l') k = eraseIdx l k ++ l'
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma ShortExact.isIso_g_iff  {S : ShortComplex C} (hS : S.ShortExact) [Balanced C] :
    IsIso S.g ↔ IsZero S.X₁
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
/-- The inclusion of a subpresheaf to the original presheaf. -/
@[simps]
def Subpresheaf.ι : G.toPresheaf ⟶ F
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- A continuous linear map between seminormed spaces is bounded when the field is nontrivially
normed. The continuity ensures boundedness on a ball of some radius `ε`. The nontriviality of the
norm is then used to rescale any element into an element of norm in `[ε/C, ε]`, whose image has a
controlled norm. The norm control for the original element follows by rescaling. -/
theorem SemilinearMapClass.bound_of_continuous [SemilinearMapClass 𝓕 σ₁₂ E F] (f : 𝓕)
    (hf : Continuous f) : ∃ C, 0 < C ∧ ∀ x : E, ‖f x‖ ≤ C * ‖x‖
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem singleton_repr (ι R : Type*) [Unique ι] [Semiring R] (x i) :
    (Basis.singleton ι R).repr x i = x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem get?_of_mem {a} {l : List α} (h : a ∈ l) : ∃ n, l.get? n = some a
-- Mathlib/Data/Fin/Basic.lean
/-- `a < b` as natural numbers if and only if `a < b` in `Fin n`. -/
@[norm_cast, simp]
theorem val_fin_lt {n : ℕ} {a b : Fin n} : (a : ℕ) < (b : ℕ) ↔ a < b
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- To give an isomorphism between cones, it suffices to give an
  isomorphism between their vertices which commutes with the cone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat) : c ≅ c'
-- Mathlib/CategoryTheory/Functor/Flat.lean
/-- A functor `F : C ⥤ D` is representably-flat functor if the comma category `(X/F)`
is cofiltered for each `X : C`.
-/
class RepresentablyFlat (F : C ⥤ D) : Prop where
  cofiltered : ∀ X : D, IsCofiltered (StructuredArrow X F)
-- Mathlib/Topology/Basic.lean
@[continuity, fun_prop]
theorem continuous_id' : Continuous (fun (x : X) => x)
-- .lake/packages/batteries/Batteries/Data/Rat/Basic.lean
theorem add.aux (a b : Rat) {g ad bd} (hg : g = a.den.gcd b.den)
    (had : ad = a.den / g) (hbd : bd = b.den / g) :
    let den := ad * b.den; let num := a.num * bd + b.num * ad
    num.natAbs.gcd g = num.natAbs.gcd den
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
protected theorem HasFDerivAtFilter.iterate {f : E → E} {f' : E →L[𝕜] E}
    (hf : HasFDerivAtFilter f f' x L) (hL : Tendsto f L L) (hx : f x = x) (n : ℕ) :
    HasFDerivAtFilter f^[n] (f' ^ n) x L
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_smul_left (x y : F) (r : ℝ) : ⟪r • x, y⟫_ℝ = r * ⟪x, y⟫_ℝ
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem relIso_enum {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] (f : r ≃r s) (o : Ordinal) (hr : o < type r) :
    f (enum r o hr) =
      enum s o
        (by
          convert hr using 1
          apply Quotient.sound
          exact ⟨f.symm⟩)
-- Mathlib/Data/Matrix/PEquiv.lean
theorem toMatrix_injective [DecidableEq n] [MonoidWithZero α] [Nontrivial α] :
    Function.Injective (@toMatrix m n α _ _ _)
-- Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean
theorem atImInfty_mem (S : Set ℍ) : S ∈ atImInfty ↔ ∃ A : ℝ, ∀ z : ℍ, A ≤ im z → z ∈ S
-- Mathlib/GroupTheory/Nilpotent.lean
/-- The nilpotency class of an n-ary product is the sup of the nilpotency classes of the factors -/
theorem nilpotencyClass_pi [Fintype η] [∀ i, IsNilpotent (Gs i)] :
    Group.nilpotencyClass (∀ i, Gs i) = Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)
-- Mathlib/Order/Filter/Lift.lean
theorem lift'_mono' (hh : ∀ s ∈ f, h₁ s ⊆ h₂ s) : f.lift' h₁ ≤ f.lift' h₂
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Inner.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
theorem AEMeasurable.inner {m : MeasurableSpace α} [MeasurableSpace E] [OpensMeasurableSpace E]
    [SecondCountableTopology E] {μ : MeasureTheory.Measure α} {f g : α → E}
    (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : AEMeasurable (fun x => ⟪f x, g x⟫) μ
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem rTensor_refl_apply : (refl R N).rTensor M y = y
-- Mathlib/Topology/Separation.lean
lemma unique_lift {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) {g : t2Quotient X → Y} (hfg : g ∘ mk = f) :
    g = lift hf
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem pullback_self {A B : C} (f : A ⟶ B) [Mono f] : (pullback f).obj (mk f) = ⊤
-- Mathlib/Topology/Bornology/Hom.lean
/-- `LocallyBoundedMapClass F α β` states that `F` is a type of bounded maps.

You should extend this class when you extend `LocallyBoundedMap`. -/
class LocallyBoundedMapClass (F : Type*) (α β : outParam Type*) [Bornology α]
    [Bornology β] [FunLike F α β] : Prop where
  /-- The pullback of the `Bornology.cobounded` filter under the function is contained in the
  cobounded filter. Equivalently, the function maps bounded sets to bounded sets. -/
  comap_cobounded_le (f : F) : (cobounded β).comap f ≤ cobounded α
-- Mathlib/Algebra/Order/BigOperators/Group/List.lean
@[to_additive sum_nonneg]
lemma one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod
-- Mathlib/Topology/Category/Compactum.lean
theorem isClosed_cl {X : Compactum} (A : Set X) : IsClosed (cl A)
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem indep_biSup_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s μ) (hf : ∀ t, p t → tᶜ ∈ f)
    {t : Set ι} (ht : p t) :
    Indep (⨆ n ∈ t, s n) (limsup s f) μ
-- Mathlib/Order/CompleteLattice.lean
theorem sup_iSup_nat_succ (u : ℕ → α) : (u 0 ⊔ ⨆ i, u (i + 1)) = ⨆ i, u i
-- Mathlib/RingTheory/Int/Basic.lean
theorem eq_pow_of_mul_eq_pow_odd_left {a b c : ℤ} (hab : IsCoprime a b) {k : ℕ} (hk : Odd k)
    (h : a * b = c ^ k) : ∃ d, a = d ^ k
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLenAux_zero (l : List α) (f : List α → β) (r) :
    sublistsLenAux 0 l f r = f [] :: r
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a
-- Mathlib/Order/WellFounded.lean
/-- Let `r` be a well-founded relation on `α`, let `f : α → β` be a function,
let `C : β → Prop`, and let `bot : α`.
This induction principle shows that `C (f bot)` holds, given that
* some `a` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
  satisfying `r c b` and `C (f c)`. -/
theorem WellFounded.induction_bot' {α β} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
    {C : β → Prop} {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) :
    C (f a) → C (f bot)
-- Mathlib/CategoryTheory/Idempotents/Basic.lean
/-- In a preadditive category, when `p : X ⟶ X` is idempotent,
then `𝟙 X - p` is also idempotent. -/
theorem idem_of_id_sub_idem [Preadditive C] {X : C} (p : X ⟶ X) (hp : p ≫ p = p) :
    (𝟙 _ - p) ≫ (𝟙 _ - p) = 𝟙 _ - p
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem sumEquivOfFintype_symm_apply (x : AdicCompletion I (⨁ j, M j)) :
    (sumEquivOfFintype I M).symm x = sumInv I M x
-- Mathlib/NumberTheory/FLT/Basic.lean
lemma not_fermatLastTheoremFor_two : ¬ FermatLastTheoremFor 2
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_union_Ioi (h : c < max a b) : Ioo a b ∪ Ioi c = Ioi (min a c)
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem associated_unit_mul_right_iff {β : Type*} [CommMonoid β] {a b : β} {u : Units β} :
    Associated a (↑u * b) ↔ Associated a b
-- Mathlib/Order/Filter/Bases.lean
theorem antitone_seq_of_seq (s : ℕ → Set α) :
    ∃ t : ℕ → Set α, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[continuity]
theorem continuous_cos : Continuous cos
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma le_traceDual_mul_iff {I J J' : Submodule B L} :
    I ≤ (J * J')ᵛ ↔ I * J ≤ J'ᵛ
-- Mathlib/NumberTheory/Pell.lean
/-- If a fundamental solution exists, then `d` must be positive. -/
theorem d_pos {a : Solution₁ d} (h : IsFundamental a) : 0 < d
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem mem_bot {x : R} : x ∈ (⊥ : NonUnitalSubring R) ↔ x = 0
-- Mathlib/Algebra/Module/GradedModule.lean
@[simp]
theorem smul_def [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    (x : ⨁ i, A i) (y : ⨁ i, M i) :
    x • y = smulAddMonoidHom _ _ x y
-- Mathlib/Algebra/RingQuot.lean
/-- The quotient map from a ring to its quotient, as a homomorphism of rings.
-/
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r
-- Mathlib/Data/Fintype/Basic.lean
theorem map_univ_of_surjective [Fintype β] {f : β ↪ α} (hf : Surjective f) : univ.map f = univ
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem coe_sum {α : Type*} (f : α → MultilinearMap R M₁ M₂) (s : Finset α) :
    ⇑(∑ a ∈ s, f a) = ∑ a ∈ s, ⇑(f a)
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_insert_left [DecidableEq α] :
    image₂ f (insert a s) t = (t.image fun b => f a b) ∪ image₂ f s t
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- Any pair of finite measures `μ` and `ν`, `HaveLebesgueDecomposition`. That is to say,
there exist a measure `ξ` and a measurable function `f`, such that `ξ` is mutually singular
with respect to `ν` and `μ = ξ + ν.withDensity f`.

This is not an instance since this is also shown for the more general σ-finite measures with
`MeasureTheory.Measure.haveLebesgueDecomposition_of_sigmaFinite`. -/
theorem haveLebesgueDecomposition_of_finiteMeasure [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    HaveLebesgueDecomposition μ ν
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem reindex_refl : b.reindex (Equiv.refl ι) = b
-- Mathlib/Data/Set/NAry.lean
theorem image_subset_image2_right (ha : a ∈ s) : f a '' t ⊆ image2 f s t
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp]
theorem coe_of (R : Type u) [Ring R] : (RingCat.of R : Type u) = R
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem zero_re : (0 : ℂ).re = 0
-- Mathlib/RingTheory/Localization/Basic.lean
theorem algEquiv_symm_mk' (x : R) (y : M) : (algEquiv M S Q).symm (mk' Q x y) = mk' S x y
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
/-- Evaluate a polynomial `p : PolynomialModule R M` at `r : R`. -/
@[simps! (config := .lemmasOnly)]
def eval (r : R) : PolynomialModule R M →ₗ[R] M
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[simp]
theorem sum_map_singleton (s : Multiset α) : (s.map fun a => ({a} : Multiset α)).sum = s
-- Mathlib/Data/DList/Defs.lean
theorem toList_ofList (l : List α) : DList.toList (DList.ofList l) = l
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwiseDisjoint_union :
    (s ∪ t).PairwiseDisjoint f ↔
      s.PairwiseDisjoint f ∧
        t.PairwiseDisjoint f ∧ ∀ ⦃i⦄, i ∈ s → ∀ ⦃j⦄, j ∈ t → i ≠ j → Disjoint (f i) (f j)
-- Mathlib/Geometry/Manifold/DerivationBundle.lean
theorem evalAt_apply (x : M) : evalAt x X f = (X f) x
-- Mathlib/Data/Matroid/Closure.lean
@[simp] lemma closure_ground (M : Matroid α) : M.closure M.E = M.E
-- Mathlib/Data/Stream/Init.lean
theorem head_drop (a : Stream' α) (n : ℕ) : (a.drop n).head = a.get n
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean
/-- The value of the quadratic character at `-2` -/
theorem quadraticChar_neg_two [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F (-2) = χ₈' (Fintype.card F)
-- Mathlib/Data/Finset/Interval.lean
/-- Cardinality of a non-empty `Icc` of finsets. -/
theorem card_Icc_finset (h : s ⊆ t) : (Icc s t).card = 2 ^ (t.card - s.card)
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
/-- A uniform upper bound for `jacobiTheta₂'_term` on compact subsets. -/
lemma norm_jacobiTheta₂'_term_le {S T : ℝ} (hT : 0 < T) {z τ : ℂ}
    (hz : |im z| ≤ S) (hτ : T ≤ im τ) (n : ℤ) :
    ‖jacobiTheta₂'_term n z τ‖ ≤ 2 * π * |n| * rexp (-π * (T * n ^ 2 - 2 * S * |n|))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arcsin_pos {x : ℝ} : 0 < arcsin x ↔ 0 < x
-- Mathlib/Data/Quot.lean
@[elab_as_elim]
protected theorem induction_on {β : Trunc α → Prop} (q : Trunc α) (h : ∀ a, β (mk a)) : β q