ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem unitGroup_le_unitGroup {A B : ValuationSubring K} : A.unitGroup ≤ B.unitGroup ↔ A ≤ B
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem mutuallySingular_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ⟂ᵥ μ ↔ s.totalVariation ⟂ₘ μ.ennrealToMeasure
-- Mathlib/Data/Real/Basic.lean
theorem mk_add {f g : CauSeq ℚ abs} : mk (f + g) = mk f + mk g
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem hasseDeriv_comp (k l : ℕ) :
    (@hasseDeriv R _ k).comp (hasseDeriv l) = (k + l).choose k • hasseDeriv (k + l)
-- Mathlib/Analysis/Convex/Deriv.lean
lemma antitoneOn_derivWithin (hfc : ConcaveOn ℝ S f) (hfd : DifferentiableOn ℝ f S) :
    AntitoneOn (derivWithin f S) S
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_lt_mul_of_pos' [PosMulStrictMono α] [MulPosStrictMono α]
    (h₁ : a < b) (h₂ : c < d) (c0 : 0 < c) (b0 : 0 < b) : a * c < b * d
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_add_cancel_iff_le : b - a + a = b ↔ a ≤ b
-- Mathlib/LinearAlgebra/Dual.lean
theorem eval_apply_eq_zero_iff (v : V) : (eval K V) v = 0 ↔ v = 0
-- Mathlib/Algebra/Order/Group/Action.lean
/-- A copy of `smul_mono_right` that is understood by `gcongr`. -/
@[gcongr]
theorem smul_le_smul_left [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) {a b : α} (h : a ≤ b) :
    m • a ≤ m • b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.exists_nonneg (h : IsBigOWith c l f g') :
    ∃ c' ≥ 0, IsBigOWith c' l f g'
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem associated_one_iff_isUnit [Monoid α] {a : α} : (a : α) ~ᵤ 1 ↔ IsUnit a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ_ne_0_ne_1728 (h0 : j ≠ 0) (h1728 : j ≠ 1728) : ofJ j =
    @ofJ' _ _ j (invertibleOfNonzero h0) (invertibleOfNonzero <| sub_ne_zero_of_ne h1728)
-- Mathlib/Data/Multiset/Fold.lean
@[simp]
theorem fold_cons_left : ∀ (b a : α) (s : Multiset α), (a ::ₘ s).fold op b = a * s.fold op b
-- Mathlib/Data/PNat/Interval.lean
@[simp]
theorem card_uIcc : (uIcc a b).card = (b - a : ℤ).natAbs + 1
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem fst_comp_prod (f : α →o β) (g : α →o γ) : fst.comp (f.prod g) = f
-- Mathlib/Order/Filter/Basic.lean
theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α} {f g : α → β}
    (h : ∀ᶠ x in l, f x < g x) : ∀ᶠ x in l, f x ≠ ⊤
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- If `F` has a colimit, so does any naturally isomorphic functor.
-/
theorem hasColimitOfIso {F G : J ⥤ C} [HasColimit F] (α : G ≅ F) : HasColimit G
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- Multiplying each row by a fixed `v i` multiplies the determinant by
the product of the `v`s. -/
theorem det_mul_row (v : n → R) (A : Matrix n n R) :
    det (of fun i j => v j * A i j) = (∏ i, v i) * det A
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem map_injective_of_injective {f : G →g G'} (hinj : Function.Injective f) (u v : V) :
    Function.Injective (Walk.map f : G.Walk u v → G'.Walk (f u) (f v))
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- A morphism of seminormed abelian groups is a bounded group homomorphism. -/
structure NormedAddGroupHom (V W : Type*) [SeminormedAddCommGroup V]
  [SeminormedAddCommGroup W] where
  /-- The function underlying a `NormedAddGroupHom` -/
  toFun : V → W
  /-- A `NormedAddGroupHom` is additive. -/
  map_add' : ∀ v₁ v₂, toFun (v₁ + v₂) = toFun v₁ + toFun v₂
  /-- A `NormedAddGroupHom` is bounded. -/
  bound' : ∃ C, ∀ v, ‖toFun v‖ ≤ C * ‖v‖
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
/-- If a graph is cliquefree, any graph that embeds into it is also cliquefree. -/
theorem CliqueFree.comap {H : SimpleGraph β} (f : H ↪g G) : G.CliqueFree n → H.CliqueFree n
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem add_mem_iff {a : A} {r s : R} : r + s ∈ σ a ↔ r ∈ σ (-↑ₐ s + a)
-- Mathlib/LinearAlgebra/Prod.lean
/--
Split equality of linear maps from a product into linear maps over each component, to allow `ext`
to apply lemmas specific to `M →ₗ M₃` and `M₂ →ₗ M₃`.

See note [partially-applied ext lemmas]. -/
@[ext 1100]
theorem prod_ext {f g : M × M₂ →ₗ[R] M₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
    (hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem IsCompactOperator.image_closedBall_subset_compact [ContinuousConstSMul 𝕜₂ M₂]
    {f : M₁ →ₛₗ[σ₁₂] M₂} (hf : IsCompactOperator f) (r : ℝ) :
    ∃ K : Set M₂, IsCompact K ∧ f '' Metric.closedBall 0 r ⊆ K
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
theorem trailingCoeff_eq_zero : trailingCoeff p = 0 ↔ p = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem sin_pi_div_four : sin (π / 4) = √2 / 2
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.mul_le_one_of_le_of_le [MulPosMono α] (ha : a ≤ 1) (hb : b ≤ 1) (b0 : 0 ≤ b) :
    a * b ≤ 1
-- Mathlib/Algebra/Ring/Pi.lean
theorem ringHom_injective {γ : Type w} [Nonempty I] [∀ i, NonAssocSemiring (f i)]
    [NonAssocSemiring γ] (g : ∀ i, γ →+* f i) (hg : ∀ i, Function.Injective (g i)) :
    Function.Injective (Pi.ringHom g)
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem nndist_midpoint_midpoint_le' (p₁ p₂ p₃ p₄ : P) :
    nndist (midpoint 𝕜 p₁ p₂) (midpoint 𝕜 p₃ p₄) ≤ (nndist p₁ p₃ + nndist p₂ p₄) / ‖(2 : 𝕜)‖₊
-- Mathlib/MeasureTheory/Integral/MeanInequalities.lean
theorem lintegral_rpow_add_lt_top_of_lintegral_rpow_lt_top {p : ℝ} {f g : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_top : (∫⁻ a, f a ^ p ∂μ) < ⊤) (hg_top : (∫⁻ a, g a ^ p ∂μ) < ⊤)
    (hp1 : 1 ≤ p) : (∫⁻ a, (f + g) a ^ p ∂μ) < ⊤
-- Mathlib/Tactic/NormNum/Pow.lean
theorem one_natPow : Nat.pow (nat_lit 1) b = nat_lit 1
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIdIso_inv_snd_fst :
    (pullbackDiagonalMapIdIso f g i).inv ≫ pullback.snd _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _
-- Mathlib/Data/DFinsupp/Basic.lean
theorem smul_apply [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] (b : γ)
    (v : Π₀ i, β i) (i : ι) : (b • v) i = b • v i
-- Mathlib/Order/SuccPred/Limit.lean
theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α)
-- Mathlib/GroupTheory/HNNExtension.lean
theorem unitsSMulGroup_snd (u : ℤˣ) (g : G) :
    (unitsSMulGroup φ d u g).2 = ((d.compl u).equiv g).2
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem toNat_testBit (x i : Nat) :
    (x.testBit i).toNat = x / 2 ^ i % 2
-- Mathlib/Data/Ordmap/Ordset.lean
theorem length_toList' : ∀ t : Ordnode α, (toList t).length = t.realSize
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp 1100] theorem mem_singleton {a b : α} : a ∈ [b] ↔ a = b
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast] lemma coe_pow (x : ℝ≥0) (n : ℕ) : (↑(x ^ n) : ℝ≥0∞) = x ^ n
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem finSuccEquiv_support (f : MvPolynomial (Fin (n + 1)) R) :
    (finSuccEquiv R n f).support = Finset.image (fun m : Fin (n + 1) →₀ ℕ => m 0) f.support
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem root_isInv (r : R) : of _ r * root (C r * X - 1) = 1
-- Mathlib/Order/Hom/Basic.lean
/-- Construct a bundled monotone map `α →o Π i, π i` from a family of monotone maps
`f i : α →o π i`. -/
@[simps]
def pi (f : ∀ i, α →o π i) : α →o ∀ i, π i
-- Mathlib/GroupTheory/Perm/List.lean
@[simp]
theorem formPerm_cons_cons (x y : α) (l : List α) :
    formPerm (x :: y :: l) = swap x y * formPerm (y :: l)
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set. -/
@[to_additive
"If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set."]
theorem isOpenPosMeasure_of_mulLeftInvariant_of_compact (K : Set G) (hK : IsCompact K)
    (h : μ K ≠ 0) : IsOpenPosMeasure μ
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
@[simp]
theorem stereographic_target (hv : ‖v‖ = 1) : (stereographic hv).target = Set.univ
-- Mathlib/Order/Hom/Lattice.lean
theorem copy_eq (f : LatticeHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
theorem norm_iteratedFDeriv_smul_le {f : E → 𝕜'} {g : E → F} {N : ℕ∞} (hf : ContDiff 𝕜 N f)
    (hg : ContDiff 𝕜 N g) (x : E) {n : ℕ} (hn : (n : ℕ∞) ≤ N) :
    ‖iteratedFDeriv 𝕜 n (fun y => f y • g y) x‖ ≤ ∑ i ∈ Finset.range (n + 1),
      (n.choose i : ℝ) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
-- Mathlib/CategoryTheory/IsConnected.lean
theorem Zag.of_hom {j₁ j₂ : J} (f : j₁ ⟶ j₂) : Zag j₁ j₂
-- Mathlib/Data/Set/Card.lean
theorem exists_mem_not_mem_of_ncard_lt_ncard (h : s.ncard < t.ncard)
    (hs : s.Finite := by toFinite_tac) : ∃ e, e ∈ t ∧ e ∉ s
-- Mathlib/Order/Bounds/Basic.lean
theorem isGLB_prod {s : Set (α × β)} (p : α × β) :
    IsGLB s p ↔ IsGLB (Prod.fst '' s) p.1 ∧ IsGLB (Prod.snd '' s) p.2
-- Mathlib/Data/Stream/Init.lean
theorem even_cons_cons (a₁ a₂ : α) (s : Stream' α) : even (a₁::a₂::s) = a₁::even s
-- Mathlib/CategoryTheory/Shift/ShiftSequence.lean
lemma shiftIso_add (n m a a' a'' : M) (ha' : n + a = a') (ha'' : m + a' = a'') :
    F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerRight (shiftFunctorAdd C m n) _ ≪≫ Functor.associator _ _ _ ≪≫
        isoWhiskerLeft _ (F.shiftIso n a a' ha') ≪≫ F.shiftIso m a' a'' ha''
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_inf {κ : ι → Type*} (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    (s.sup fun i => (t i).inf (f i)) = (s.pi t).inf fun g => s.attach.sup fun i => f _ <| g _ i.2
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem CuspForm.toSlashInvariantForm_coe (f : CuspForm Γ k) : ⇑f.1 = f
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem mk_zero : ⟨0⟩ = (0 : Pos)
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem degree_C {a : R} (a0 : a ≠ 0) : (C a).degree = 0
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_insert_insert_of_mem_of_not_mem {s t : Finset α} {x : α} (hxs : x ∈ s) (hxt : x ∉ t) :
    insert x (s \ insert x t) = s \ t
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem projIci_coe (x : Ici a) : projIci a x = x
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- `seminormFromConst' hf1 hc hpm 1 ≤ 1`. -/
theorem seminormFromConst_one_le : seminormFromConst' hf1 hc hpm 1 ≤ 1
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
/-- A component of a transposed form of the inverse conjugation definition. -/
theorem unit_conjugateEquiv_symm (α : R₁ ⟶ R₂) (c : C) :
    adj₁.unit.app _ ≫ α.app _ =
      adj₂.unit.app c ≫ R₂.map (((conjugateEquiv adj₁ adj₂).symm α).app _)
-- Mathlib/Data/Multiset/FinsetOps.lean
@[simp]
theorem disjoint_ndinsert_right {a : α} {s t : Multiset α} :
    Disjoint s (ndinsert a t) ↔ a ∉ s ∧ Disjoint s t
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem Int.isCoprime_iff_gcd_eq_one {m n : ℤ} : IsCoprime m n ↔ Int.gcd m n = 1
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- Two submodules `M` and `N` in an algebra `S` over `R` are linearly disjoint if the natural map
`M ⊗[R] N →ₗ[R] S` induced by multiplication in `S` is injective. -/
@[mk_iff]
protected structure LinearDisjoint : Prop where
  injective : Function.Injective (mulMap M N)
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive (attr := simp)]
protected theorem one_div_mul {r : R} {s t : S} : (1 /ₒ t) * (r /ₒ s) = r /ₒ (s * t)
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
theorem map_add_right (f : M →ₗ[A] P) (g₁ g₂ : N →ₗ[R] Q) :
    map f (g₁ + g₂) = map f g₁ + map f g₂
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem le_sup'_iff : a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma hasLeftHomology_of_iso {S₁ S₂ : ShortComplex C} (e : S₁ ≅ S₂) [HasLeftHomology S₁] :
    HasLeftHomology S₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem zero_eq_arcsin_iff {x} : 0 = arcsin x ↔ x = 0
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
theorem image_fst_divisorsAntidiagonal : (divisorsAntidiagonal n).image Prod.fst = divisors n
-- Mathlib/Analysis/Convex/Strict.lean
/-- Alternative definition of set strict convexity, using division. -/
theorem strictConvex_iff_div :
    StrictConvex 𝕜 s ↔
      s.Pairwise fun x y =>
        ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → (a / (a + b)) • x + (b / (a + b)) • y ∈ interior s
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem incMatrix_apply_mul_incMatrix_apply : G.incMatrix R a e * G.incMatrix R b e =
    (G.incidenceSet a ∩ G.incidenceSet b).indicator 1 e
-- Mathlib/Data/Nat/Squarefree.lean
theorem squarefree_of_factorization_le_one {n : ℕ} (hn : n ≠ 0) (hn' : ∀ p, n.factorization p ≤ 1) :
    Squarefree n
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem exp_eq_exp_iff_exists_int {x y : ℂ} : exp x = exp y ↔ ∃ n : ℤ, x = y + n * (2 * π * I)
-- Mathlib/Topology/Irreducible.lean
theorem Subtype.preirreducibleSpace (h : IsPreirreducible s) : PreirreducibleSpace s
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem memℒp_iff {f : α →ₛ E} (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp f p μ ↔ ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem card_interedges_finpartition_right [DecidableEq β] (s : Finset α) (P : Finpartition t) :
    (interedges r s t).card = ∑ b ∈ P.parts, (interedges r s b).card
-- Mathlib/Data/Finset/Card.lean
theorem card_ne_zero_of_mem (h : a ∈ s) : s.card ≠ 0
-- Mathlib/Data/Finsupp/Basic.lean
theorem support_extendDomain_subset (f : Subtype P →₀ M) :
    ↑(f.extendDomain).support ⊆ {x | P x}
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂
-- Mathlib/Order/LiminfLimsup.lean
/-- For nontrivial filters in linear orders, coboundedness for `≥` implies frequent boundedness
from above. -/
lemma IsCobounded.frequently_le [NeBot F] (cobdd : IsCobounded (· ≥ ·) F) :
    ∃ u, ∃ᶠ x in F, x ≤ u
-- Mathlib/Data/Set/Basic.lean
theorem subset_setOf {p : α → Prop} {s : Set α} : s ⊆ setOf p ↔ ∀ x, x ∈ s → p x
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- Reindex a categorical biproduct via an equivalence of the index types. -/
@[simps]
def biproduct.reindex {β γ : Type} [Finite β] (ε : β ≃ γ)
    (f : γ → C) [HasBiproduct f] [HasBiproduct (f ∘ ε)] : ⨁ f ∘ ε ≅ ⨁ f
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem val_sub (n : ℕ) (f g : AdicCompletion I M) : (f - g).val n = f.val n - g.val n
-- Mathlib/CategoryTheory/Elements.lean
/-- The functor out of the category of elements which forgets the element. -/
@[simps]
def π : F.Elements ⥤ C
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem inr_injective [Zero R] : Function.Injective ((↑) : A → Unitization R A)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem concat_cons (a b : α) (l : List α) : concat (a :: l) b = a :: concat l b
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofBddAugment_indep (E : Set α) Indep indep_empty indep_subset indep_aug
    indep_bdd subset_ground : (IndepMatroid.ofBddAugment
      E Indep indep_empty indep_subset indep_aug indep_bdd subset_ground).Indep = Indep
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem pNilradical_le_nilradical {R : Type*} [CommSemiring R] {p : ℕ} :
    pNilradical R p ≤ nilradical R
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem rootSet_prod [CommRing S] [IsDomain S] [Algebra R S] {ι : Type*} (f : ι → R[X])
    (s : Finset ι) (h : s.prod f ≠ 0) : (s.prod f).rootSet S = ⋃ i ∈ s, (f i).rootSet S
-- Mathlib/Data/Nat/Choose/Sum.lean
theorem Int.alternating_sum_range_choose_of_ne {n : ℕ} (h0 : n ≠ 0) :
    (∑ m ∈ range (n + 1), ((-1) ^ m * ↑(choose n m) : ℤ)) = 0
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem join_think (S : WSeq (WSeq α)) : join (think S) = think (join S)
-- Mathlib/Topology/UniformSpace/Basic.lean
@[mono, gcongr]
theorem compRel_mono {f g h k : Set (α × α)} (h₁ : f ⊆ h) (h₂ : g ⊆ k) : f ○ g ⊆ h ○ k
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem IsSubordinate.biUnionPrepartition [Fintype ι] (h : IsSubordinate π r)
    (πi : ∀ J, Prepartition J) : IsSubordinate (π.biUnionPrepartition πi) r
-- Mathlib/Data/Finset/Pointwise.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem vsub_nonempty : (s -ᵥ t : Finset α).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem baseSet_at : Z.baseSet i = (Z.localTriv i).baseSet
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
/-- `x` is in the support of `f` iff `Equiv.Perm.cycle_of f x` is a cycle. -/
theorem isCycle_cycleOf_iff (f : Perm α) [DecidableRel f.SameCycle] :
    IsCycle (cycleOf f x) ↔ f x ≠ x
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
/-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : p) : M) = 0
-- Mathlib/ModelTheory/Ultraproducts.lean
theorem funMap_cast {n : ℕ} (f : L.Functions n) (x : Fin n → ∀ a, M a) :
    (funMap f fun i => (x i : (u : Filter α).Product M)) =
      (fun a => funMap f fun i => x i a : (u : Filter α).Product M)
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem mul (hφ : IsHomogeneous φ m) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ * ψ) (m + n)
-- Mathlib/Order/Interval/Set/Image.lean
lemma Antitone.mapsTo_Ici (h : Antitone f) : MapsTo f (Ici a) (Iic (f a))
-- Mathlib/Data/PNat/Xgcd.lean
/-- Properties of division with remainder for a / b.  -/
theorem rq_eq : u.r + (u.bp + 1) * u.q = u.ap + 1
-- Mathlib/Algebra/Category/Ring/Basic.lean
lemma coe_id {X : CommSemiRingCat} : (𝟙 X : X → X) = id
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem add_min_add_right : ∀ (a b c : Nat), min (a + c) (b + c) = min a b + c
-- Mathlib/Topology/Order.lean
theorem discreteTopology_bot (α : Type*) : @DiscreteTopology α ⊥
-- Mathlib/Algebra/Order/Archimedean.lean
lemma pow_unbounded_of_one_lt [ExistsAddOfLE α] (x : α) (hy1 : 1 < y) : ∃ n : ℕ, x < y ^ n
-- Mathlib/Logic/Unique.lean
theorem unique_iff_exists_unique (α : Sort u) : Nonempty (Unique α) ↔ ∃! _ : α, True
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
theorem HasSum.op (hf : HasSum f a) : HasSum (fun a ↦ op (f a)) (op a)
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem TensorProduct.isBaseChange : IsBaseChange S (TensorProduct.mk R S M 1)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem mul_eq_zero {a b : Int} : a * b = 0 ↔ a = 0 ∨ b = 0
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_biUnion_congr {s : Set ι} {t : ι → Set α} (hc : s.Countable) :
    μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔
      ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i)
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc (attr := simp)]
lemma D₂_D₂ (i₁₂ i₁₂' i₁₂'' : I₁₂) : K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = 0
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_ceil_left_pure (n : ℤ) : Tendsto (ceil : α → ℤ) (𝓝[≤] n) (pure n)
-- Mathlib/Data/Multiset/Basic.lean
theorem map_mk_eq_map_mk_of_rel {r : α → α → Prop} {s t : Multiset α} (hst : s.Rel r t) :
    s.map (Quot.mk r) = t.map (Quot.mk r)
-- Mathlib/Data/Real/EReal.lean
/-- The product of two positive extended real numbers is positive. -/
lemma mul_pos {a b : EReal} (ha : 0 < a) (hb : 0 < b) : 0 < a * b
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essInf_eq_sSup {m : MeasurableSpace α} (μ : Measure α) (f : α → β) :
    essInf f μ = sSup { a | μ { x | f x < a } = 0 }
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
theorem ιInv_comp_map (f : M →ₗ[R] N) :
    ιInv.comp (map f).toLinearMap = f.comp ιInv
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma num_pow (q : ℚ) (n : ℕ) : (q ^ n).num = q.num ^ n
-- Mathlib/Topology/Connected/Basic.lean
theorem connectedComponentIn_eq {x y : α} {F : Set α} (h : y ∈ connectedComponentIn F x) :
    connectedComponentIn F x = connectedComponentIn F y
-- Mathlib/Topology/Algebra/InfiniteSum/Real.lean
theorem dist_le_tsum_dist_of_tendsto (h : Summable fun n ↦ dist (f n) (f n.succ))
    (ha : Tendsto f atTop (𝓝 a)) (n) : dist (f n) a ≤ ∑' m, dist (f (n + m)) (f (n + m).succ)
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_localTrivAt_baseSet (b : B) : b ∈ (Z.localTrivAt b).baseSet
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem coe_zsmul (r : ℤ) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f
-- Mathlib/Topology/DenseEmbedding.lean
theorem dense_image {s : Set α} : Dense (e '' s) ↔ Dense s
-- Mathlib/Data/Holor.lean
/-- The original holor can be recovered from its slices by multiplying with unit vectors and
summing up. -/
@[simp]
theorem sum_unitVec_mul_slice [Ring α] (x : Holor α (d :: ds)) :
    (∑ i ∈ (Finset.range d).attach,
        unitVec d i ⊗ slice x i (Nat.succ_le_of_lt (Finset.mem_range.1 i.prop))) =
      x
-- Mathlib/Topology/Semicontinuous.lean
theorem Continuous.lowerSemicontinuous {f : α → γ} (h : Continuous f) : LowerSemicontinuous f
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_of_isSMulRegular_on_submodule_on_quotient
    (h1 : IsSMulRegular N r) (h2 : IsSMulRegular (M ⧸ N) r) : IsSMulRegular M r
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem ediv_lt_iff_lt_mul {a b c : Int} (H : 0 < c) : a / c < b ↔ a < b * c
-- Mathlib/FieldTheory/Adjoin.lean
theorem gc : GaloisConnection (adjoin F : Set E → IntermediateField F E)
    (fun (x : IntermediateField F E) => (x : Set E))
-- Mathlib/FieldTheory/Minpoly/Basic.lean
theorem unique' {p : A[X]} (hm : p.Monic) (hp : Polynomial.aeval x p = 0)
    (hl : ∀ q : A[X], degree q < degree p → q = 0 ∨ Polynomial.aeval x q ≠ 0) :
    p = minpoly A x
-- Mathlib/Topology/Separation.lean
theorem t2_iff_ultrafilter :
    T2Space X ↔ ∀ {x y : X} (f : Ultrafilter X), ↑f ≤ 𝓝 x → ↑f ≤ 𝓝 y → x = y
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
theorem casesAuxOn_succ {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive (n+1)) (n) :
    Nat.casesAuxOn (n+1) zero succ = succ n
-- Mathlib/Topology/Category/Compactum.lean
theorem str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x
-- Mathlib/Data/Fintype/Card.lean
@[simp] lemma Fintype.card_multiplicative (α : Type*) [Fintype α] :
    card (Multiplicative α) = card α
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem id_comp (f : α →*₀o β) : (OrderMonoidWithZeroHom.id β).comp f = f
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- We say a quotient of `α` by `G` `HasFundamentalDomain` if there is a measurable set `s` for
  which `IsFundamentalDomain G s` holds. -/
class HasFundamentalDomain (G : Type*) (α : Type*) [One G] [SMul G α] [MeasurableSpace α]
    (ν : Measure α := by volume_tac) : Prop where
  ExistsIsFundamentalDomain : ∃ (s : Set α), IsFundamentalDomain G s ν
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- For `D : J ⥤ Algebra T`, `D ⋙ forget T` has a colimit, then `D` has a colimit provided colimits
of shape `J` are preserved by `T`.
-/
theorem forget_creates_colimits_of_monad_preserves [PreservesColimitsOfShape J (T : C ⥤ C)]
    (D : J ⥤ Algebra T) [HasColimit (D ⋙ forget T)] : HasColimit D
-- Mathlib/Order/RelSeries.lean
lemma append_apply_right (p q : RelSeries r) (connect : r p.last q.head)
    (i : Fin (q.length + 1)) :
    p.append q connect (i.natAdd p.length + 1) = q i
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem self_le_power (a : Cardinal) {b : Cardinal} (hb : 1 ≤ b) : a ≤ a ^ b
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem C_pow : C (a ^ n) = C a ^ n
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- For every family of closed sets whose intersection avoids a Lindelö set,
there exists a countable subfamily whose intersection avoids this Lindelöf set. -/
theorem IsLindelof.elim_countable_subfamily_closed {ι : Type v} (hs : IsLindelof s)
    (t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅) :
    ∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅