ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- The topological Besicovitch covering theorem: there exist finitely many families of disjoint
balls covering all the centers in a package. More specifically, one can use `N` families if there
are no satellite configurations with `N+1` points. -/
theorem exist_disjoint_covering_families {N : ℕ} {τ : ℝ} (hτ : 1 < τ)
    (hN : IsEmpty (SatelliteConfig α N τ)) (q : BallPackage β α) :
    ∃ s : Fin N → Set β,
      (∀ i : Fin N, (s i).PairwiseDisjoint fun j => closedBall (q.c j) (q.r j)) ∧
        range q.c ⊆ ⋃ i : Fin N, ⋃ j ∈ s i, ball (q.c j) (q.r j)
-- Mathlib/Data/Vector/Mem.lean
@[simp]
theorem head_mem (v : Vector α (n + 1)) : v.head ∈ v.toList
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factors'_cong {a b : α} (h : a ~ᵤ b) : factors' a = factors' b
-- Mathlib/Data/Multiset/Basic.lean
theorem foldl_swap (f : β → α → β) (H : RightCommutative f) (b : β) (s : Multiset α) :
    foldl f H b s = foldr (fun x y => f y x) (fun _x _y _z => (H _ _ _).symm) b s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem_zero {l : List α} (h : 0 < l.length) : l[0] = l.head (length_pos.mp h)
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_eq : a ∆ b = a ⊓ bᶜ ⊔ b ⊓ aᶜ
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem IsCompactOperator.isCompact_closure_image_ball [ContinuousConstSMul 𝕜₂ M₂] [T2Space M₂]
    {f : M₁ →ₛₗ[σ₁₂] M₂} (hf : IsCompactOperator f) (r : ℝ) :
    IsCompact (closure <| f '' Metric.ball 0 r)
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_pos_iff [LinearOrderedRing α] (hn : n ≠ 0) :
    (0 < ∑ i ∈ range n, x ^ i) ↔ Odd n ∨ 0 < x + 1
-- Mathlib/Analysis/Seminorm.lean
theorem bot_eq_zero : (⊥ : Seminorm 𝕜 E) = 0
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivAt.const_add (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => c + f x) f' x
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem ofReal_exp_ofReal_re (x : ℝ) : ((exp x).re : ℂ) = exp x
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_one_smul_measure {f : α → F} (c : ℝ≥0∞) :
    eLpNorm f 1 (c • μ) = c * eLpNorm f 1 μ
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiff_smul : ContDiff 𝕜 n fun p : 𝕜 × F => p.1 • p.2
-- Mathlib/Algebra/Order/Monovary.lean
lemma monovary_iff_forall_mul_nonneg : Monovary f g ↔ ∀ i j, 0 ≤ (f j - f i) * (g j - g i)
-- Mathlib/Algebra/Star/StarAlgHom.lean
/-- The first projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def fst : A × B →⋆ₐ[R] A
-- Mathlib/Data/Fintype/Option.lean
theorem univ_option (α : Type*) [Fintype α] : (univ : Finset (Option α)) = insertNone univ
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem degree_derivative_le {p : R[X]} : p.derivative.degree ≤ p.degree
-- Mathlib/Order/Atoms.lean
theorem isCoatom_iff [OrderTop α] [IsCoatomic α] [OrderTop β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (h_coatom : ∀ a : α, IsCoatom a → u (l a) = a) (b : β) :
    IsCoatom (u b) ↔ IsCoatom b
-- Mathlib/Probability/CondCount.lean
theorem condCount_inter_self (hs : s.Finite) : condCount s (s ∩ t) = condCount s t
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem add_one_le_add_one_iff {α β : Cardinal} : α + 1 ≤ β + 1 ↔ α ≤ β
-- Mathlib/LinearAlgebra/Dimension/Free.lean
/-- Tower law: if `A` is a `K`-module and `K` is an extension of `F` then
$\operatorname{rank}_F(A) = \operatorname{rank}_F(K) * \operatorname{rank}_K(A)$. -/
theorem FiniteDimensional.finrank_mul_finrank : finrank F K * finrank K A = finrank F A
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
theorem hasPushout_assoc [HasPushout (g₃ ≫ f₂) g₄] : HasPushout g₁ (g₂ ≫ f₃)
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_eq_sInf_image [CompleteLattice β] (s : Finset α) (f : α → β) :
    s.inf f = sInf (f '' s)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem adc_spec (x y : BitVec w) (c : Bool) :
    adc x y c = (carry w x y c, x + y + zeroExtend w (ofBool c))
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem normSq_neg (z : ℂ) : normSq (-z) = normSq z
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[ext]
theorem ext {f g : α →+*o β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem candidates_le_maxVar (fA : f ∈ candidates X Y) : f (x, y) ≤ maxVar X Y
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- For the equality, see `infEdist_thickening`. -/
theorem infEdist_le_infEdist_thickening_add :
    infEdist x s ≤ infEdist x (thickening δ s) + ENNReal.ofReal δ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_of_add_lt_add_left {a b c : Int} (h : a + b < a + c) : b < c
-- Mathlib/Order/SupClosed.lean
lemma infClosure_min : s ⊆ t → InfClosed t → infClosure s ⊆ t
-- Mathlib/Order/Grade.lean
theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem singletonChartedSpace_chartAt_source (h : e.source = Set.univ) {x : α} :
    (@chartAt H _ α _ (e.singletonChartedSpace h) x).source = Set.univ
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem support_one [MulZeroOneClass R] [Nontrivial R] : support (1 : HahnSeries Γ R) = {0}
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem lift_sub_val_mem_span (r : R) (n : ℕ) :
    lift f_compat r - (f n r).val ∈ (Ideal.span {(p : ℤ_[p]) ^ n})
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
theorem measure_le_inter_add_diff (μ : F) (s t : Set α) : μ s ≤ μ (s ∩ t) + μ (s \ t)
-- Mathlib/Algebra/BigOperators/Finprod.lean
theorem mul_finsum {R : Type*} [Semiring R] (f : α → R) (r : R) (h : (support f).Finite) :
    (r * ∑ᶠ a : α, f a) = ∑ᶠ a : α, r * f a
-- Mathlib/Data/Set/Basic.lean
lemma not_disjoint_iff_nonempty_inter : ¬ Disjoint s t ↔ (s ∩ t).Nonempty
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `lt_tsub_iff_right_of_le` for a weaker statement in a partial order. -/
theorem lt_tsub_iff_right : a < b - c ↔ a + c < b
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem nil_add (xs : IntList) : [] + xs = xs
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem symm_toEquiv (e : P₁ ≃ᵃL[k] P₂) : e.toEquiv.symm = e.symm.toEquiv
-- Mathlib/SetTheory/Lists.lean
theorem Subset.trans {l₁ l₂ l₃ : Lists' α true} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃) : l₁ ⊆ l₃
-- Mathlib/FieldTheory/Laurent.lean
theorem laurent_div :
    laurent r (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap _ _ (taylor r p) / algebraMap _ _ (taylor r q)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Ultrafilter.cauchy_of_totallyBounded {s : Set α} (f : Ultrafilter α) (hs : TotallyBounded s)
    (h : ↑f ≤ 𝓟 s) : Cauchy (f : Filter α)
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem Filter.EventuallyEq.fderivWithin (hs : f₁ =ᶠ[𝓝[s] x] f) :
    fderivWithin 𝕜 f₁ s =ᶠ[𝓝[s] x] fderivWithin 𝕜 f s
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem Basis.map_addHaar {ι E F : Type*} [Fintype ι] [NormedAddCommGroup E] [NormedAddCommGroup F]
    [NormedSpace ℝ E] [NormedSpace ℝ F] [MeasurableSpace E] [MeasurableSpace F] [BorelSpace E]
    [BorelSpace F] [SecondCountableTopology F] [SigmaCompactSpace F]
    (b : Basis ι ℝ E) (f : E ≃L[ℝ] F) :
    map f b.addHaar = (b.map f.toLinearEquiv).addHaar
-- Mathlib/Data/Set/Card.lean
theorem ncard_exchange {a b : α} (ha : a ∉ s) (hb : b ∈ s) : (insert a (s \ {b})).ncard = s.ncard
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Let `t i` be a nonempty directed subfamily of `𝔖`
such that every `s ∈ 𝔖` is included in some `t i`.
Let `V` bounded by `p` be a basis of entourages of `β`.

Then `UniformOnFun.gen 𝔖 (t i) (V j)` bounded by `p j` is a basis of entourages of `α →ᵤ[𝔖] β`. -/
protected theorem hasBasis_uniformity_of_covering_of_basis {ι ι' : Type*} [Nonempty ι]
    {t : ι → Set α} {p : ι' → Prop} {V : ι' → Set (β × β)} (ht : ∀ i, t i ∈ 𝔖)
    (hdir : Directed (· ⊆ ·) t) (hex : ∀ s ∈ 𝔖, ∃ i, s ⊆ t i) (hb : HasBasis (𝓤 β) p V) :
    (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun i : ι × ι' ↦ p i.2) fun i ↦
      UniformOnFun.gen 𝔖 (t i.1) (V i.2)
-- Mathlib/Algebra/Associated/Basic.lean
theorem dvdNotUnit_of_dvdNotUnit_associated [CommMonoidWithZero α] [Nontrivial α] {p q r : α}
    (h : DvdNotUnit p q) (h' : Associated q r) : DvdNotUnit p r
-- Mathlib/Data/Nat/Lattice.lean
theorem sInf_add {n : ℕ} {p : ℕ → Prop} (hn : n ≤ sInf { m | p m }) :
    sInf { m | p (m + n) } + n = sInf { m | p m }
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem symm (h : e.IsImage s t) : e.symm.IsImage t s
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem lastCases_last {n : Nat} {motive : Fin (n + 1) → Sort _} {last cast} :
    (Fin.lastCases last cast (Fin.last n) : motive (Fin.last n)) = last
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem Monotone.mul_const [MulPosMono α]
    (hf : Monotone f) (ha : 0 ≤ a) : Monotone fun x => f x * a
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem coe_eraseNone (s : Finset (Option α)) : (eraseNone s : Set α) = some ⁻¹' s
-- Mathlib/Order/Filter/AtTopBot.lean
protected theorem Tendsto.eventually_ge_atTop [Preorder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, c ≤ f x
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.comp_of_map (hg : Memℒp g p (Measure.map f μ)) (hf : AEMeasurable f μ) :
    Memℒp (g ∘ f) p μ
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_denumerable (α : Type u) [Denumerable α] : #α = ℵ₀
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
protected theorem ae_eq (hf : UnifIntegrable f p μ) (hfg : ∀ n, f n =ᵐ[μ] g n) :
    UnifIntegrable g p μ
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem det_adjugate (A : Matrix n n α) : (adjugate A).det = A.det ^ (Fintype.card n - 1)
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
theorem toFun_eq_coe : D.toFun = ⇑D
-- Mathlib/Topology/Order/OrderClosed.lean
theorem isOpen_lt_prod : IsOpen { p : α × α | p.1 < p.2 }
-- Mathlib/RingTheory/WittVector/Isocrystal.lean
@[simp]
theorem StandardOneDimIsocrystal.frobenius_apply (m : ℤ) (x : StandardOneDimIsocrystal p k m) :
    Φ(p, k) x = (p : K(p, k)) ^ m • φ(p, k) x
-- Mathlib/Order/Atoms.lean
/-- A complemented modular coatomic lattice is strongly atomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyCoatomic' [h : IsCoatomic α] : IsStronglyAtomic α
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma exterior_singleton_eq_ker_nhds (a : α) : exterior {a} = (𝓝 a).ker
-- Mathlib/Data/Int/GCD.lean
theorem gcd_dvd_gcd_of_dvd_right {i k : ℤ} (j : ℤ) (H : i ∣ k) : gcd j i ∣ gcd j k
-- Mathlib/Control/Functor/Multivariate.lean
theorem of_mem_supp {α : TypeVec n} {x : F α} {P : ∀ ⦃i⦄, α i → Prop} (h : LiftP P x) (i : Fin2 n) :
    ∀ y ∈ supp x i, P y
-- Mathlib/Order/Cover.lean
@[simp]
theorem apply_covBy_apply_iff {E : Type*} [EquivLike E α β] [OrderIsoClass E α β] (e : E) :
    e a ⋖ e b ↔ a ⋖ b
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_monomial_le (n : ℕ) (a : R) : degree (monomial n a) ≤ n
-- .lake/packages/lean4/src/lean/Init/Data/List/BasicAux.lean
theorem sizeOf_lt_of_mem [SizeOf α] {as : List α} (h : a ∈ as) : sizeOf a < sizeOf as
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem add_mul_succ {a b : Ordinal} (c) (ba : b + a = a) : (a + b) * succ c = a * succ c + b
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem lift_aequiv {U : Type*} [CommRing U] (h : IsAdjoinRoot S f) (h' : IsAdjoinRoot T f)
    (i : R →+* U) (x hx z) : h'.lift i x hx (h.aequiv h' z) = h.lift i x hx z
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem Monic.degree_pos_of_not_isUnit (hu : ¬IsUnit p) : 0 < degree p
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- `lpMeasSubgroupToLpTrim` preserves the norm. -/
theorem lpMeasSubgroupToLpTrim_norm_map [hp : Fact (1 ≤ p)] (hm : m ≤ m0)
    (f : lpMeasSubgroup F m p μ) : ‖lpMeasSubgroupToLpTrim F p μ hm f‖ = ‖f‖
-- Mathlib/Order/Concept.lean
@[ext]
theorem ext (h : c.fst = d.fst) : c = d
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem w_nonneg (D : ℝ) (x : E) : 0 ≤ w D x
-- Mathlib/Order/Filter/Basic.lean
theorem comap_const_of_not_mem {x : β} (ht : t ∈ g) (hx : x ∉ t) : comap (fun _ : α => x) g = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.denote_reverseAux (ctx : Context) (p q : Poly) : denote ctx (List.reverseAux p q) = denote ctx (p ++ q)
-- Mathlib/Topology/Order/ExtrClosure.lean
protected theorem IsExtrOn.closure (h : IsExtrOn f s a) (hc : ContinuousOn f (closure s)) :
    IsExtrOn f (closure s) a
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem nhdsWithin_basis_closed_eball :
    (𝓝[s] x).HasBasis (fun ε : ℝ≥0∞ => 0 < ε) fun ε => closedBall x ε ∩ s
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
theorem NormedAddGroupHom.completion_coe (f : NormedAddGroupHom G H) (g : G) :
    f.completion g = f g
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mfderiv_surjective {x : M} (hx : x ∈ e.source) : Function.Surjective (mfderiv I I' e x)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem translationNumber_conj_eq' (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift) :
    τ (↑f⁻¹ * g * f) = τ g
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem comap_dist_left_atTop_eq_cocompact [ProperSpace α] (x : α) :
    comap (dist x) atTop = cocompact α
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem smul_mk [DistribSMul S R] [IsScalarTower S R R] (a : S) (x : R[X]) :
    a • mk f x = mk f (a • x)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
/-- When a vector is in `Kᗮ`. -/
theorem mem_orthogonal (v : E) : v ∈ Kᗮ ↔ ∀ u ∈ K, ⟪u, v⟫ = 0
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_congr {R S : Type*} [Semiring R] [Semiring S] {f g : R →+* S} {s t : S}
    {φ ψ : R[X]} : f = g → s = t → φ = ψ → eval₂ f s φ = eval₂ g t ψ
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
@[simp] theorem id_hom' (M : Comon_ C) : (𝟙 M : Hom M M).hom = 𝟙 M.X
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem out_dvd_iff (a : α) (b : Associates α) : b.out ∣ a ↔ b ≤ Associates.mk a
-- Mathlib/RingTheory/Polynomial/Nilpotent.lean
lemma isUnit_iff' :
    IsUnit P ↔ IsUnit (eval 0 P) ∧ IsNilpotent (P /ₘ X)
-- Mathlib/CategoryTheory/Sites/Coherent/Equivalence.lean
/-- `Preregular` is preserved by equivalence of categories. -/
theorem preregular : Preregular D
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem casesOn'_some (x : β) (f : α → β) (a : α) : casesOn' (some a) x f = f a
-- Mathlib/Algebra/Module/Defs.lean
theorem AddMonoid.End.natCast_def (n : ℕ) :
    (↑n : AddMonoid.End M) = DistribMulAction.toAddMonoidEnd ℕ M n
-- Mathlib/LinearAlgebra/Basis.lean
/-- Given a basis, the `i`th element of the dual basis evaluates to 0 on the `j`th element of the
basis if `j ≠ i`. -/
theorem mk_coord_apply_ne {i j : ι} (h : j ≠ i) : (Basis.mk hli hsp).coord i (v j) = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem pi_div_four_le_arcsin {x} : π / 4 ≤ arcsin x ↔ √2 / 2 ≤ x
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciInf_subsingleton [Subsingleton ι] (i : ι) (s : ι → α) : ⨅ i, s i = s i
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem coe_mulₗᵢ : ⇑(mulₗᵢ 𝕜 𝕜') = mul 𝕜 𝕜'
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
@[simp]
theorem isSymm_compl [Zero α] [One α] (h : A.IsSymm) : A.compl.IsSymm
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem not_isReal_of_mk_isComplex {φ : K →+* ℂ} (h : IsComplex (mk φ)) :
    ¬ ComplexEmbedding.IsReal φ
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem toGerm_injective : Injective (toGerm : (α →ₘ[μ] β) → Germ (ae μ) β)
-- Mathlib/Analysis/Normed/Ring/Units.lean
/-- The function `fun t ↦ Ring.inverse (x + t) - x⁻¹ + x⁻¹ * t * x⁻¹` is `O(t ^ 2)` as `t → 0`. -/
theorem inverse_add_norm_diff_second_order (x : Rˣ) :
    (fun t : R => inverse (↑x + t) - ↑x⁻¹ + ↑x⁻¹ * t * ↑x⁻¹) =O[𝓝 0] fun t => ‖t‖ ^ 2
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_mul : ∀ x y, v (x * y) = v x * v y
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem intCoe_int (f : ArithmeticFunction ℤ) : ofInt f = f
-- Mathlib/Data/List/Infix.lean
@[simp]
theorem mem_tails : ∀ s t : List α, s ∈ tails t ↔ s <:+ t
-- Mathlib/Data/Finsupp/Lex.lean
theorem toLex_monotone : Monotone (@toLex (α →₀ N))
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma le_min_of_le_of_lt (ha : a ≤ b) (hb : a < c) : a ≤ min b c
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem finite [Module.Finite R M] {ι : Type*} {f : ι → M}
    (h : LinearIndependent R f) : Finite ι
-- Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean
@[simp]
theorem _root_.PowerBasis.ofGenMemAdjoin'_gen (B : PowerBasis R S) (hint : IsIntegral R x)
    (hx : B.gen ∈ adjoin R ({x} : Set S)) :
    (B.ofGenMemAdjoin' hint hx).gen = x
-- Mathlib/Algebra/Field/Subfield.lean
theorem mem_toSubmonoid {s : Subfield K} {x : K} : x ∈ s.toSubmonoid ↔ x ∈ s
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem _root_.MeasurableEmbedding.integrable_map_iff {f : α → δ} (hf : MeasurableEmbedding f)
    {g : δ → β} : Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ
-- Mathlib/Algebra/MvPolynomial/Basic.lean
/-- Analog of `Polynomial.induction_on`. -/
@[recursor 5]
theorem induction_on {M : MvPolynomial σ R → Prop} (p : MvPolynomial σ R) (h_C : ∀ a, M (C a))
    (h_add : ∀ p q, M p → M q → M (p + q)) (h_X : ∀ p n, M p → M (p * X n)) : M p
-- Mathlib/Algebra/Module/LocalizedModule.lean
/-- Universal property from localized module:
If `(M', f : M ⟶ M')` is a localized module then it satisfies the following universal property:
For every `R`-module `M''` which every `s : S`-scalar multiplication is invertible and for every
`R`-linear map `g : M ⟶ M''`, there is a unique `R`-linear map `l : M' ⟶ M''` such that
`l ∘ f = g`.
```
M -----f----> M'
|           /
|g       /
|     /   l
v   /
M''
```
-/
theorem is_universal :
    ∀ (g : M →ₗ[R] M'') (_ : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)),
      ∃! l : M' →ₗ[R] M'', l.comp f = g
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem volume_preserving_pi_empty {ι : Type u} (α : ι → Type v) [Fintype ι] [IsEmpty ι]
    [∀ i, MeasureSpace (α i)] :
    MeasurePreserving (MeasurableEquiv.ofUniqueOfUnique (∀ i, α i) Unit) volume volume
-- Mathlib/Data/Part.lean
theorem dom_iff_mem : ∀ {o : Part α}, o.Dom ↔ ∃ y, y ∈ o
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigOWith_bot : IsBigOWith c ⊥ f g
-- Mathlib/Data/Set/Pointwise/Finite.lean
@[to_additive (attr := simp)]
theorem infinite_smul_set : (a • s).Infinite ↔ s.Infinite
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dvd_bmod_dot_sub_dot_bmod (m : Nat) (xs ys : Coeffs) :
    (m : Int) ∣ bmod_dot_sub_dot_bmod m xs ys
-- Mathlib/Order/Cover.lean
theorem CovBy.lt (h : a ⋖ b) : a < b
-- Mathlib/Data/Part.lean
theorem eq_get_iff_mem {o : Part α} {a : α} (h : o.Dom) : a = o.get h ↔ a ∈ o
-- Mathlib/Data/Finset/Image.lean
/-- `s.subtype p` converts back to `s.filter p` with
`Embedding.subtype`. -/
@[simp]
theorem subtype_map (p : α → Prop) [DecidablePred p] {s : Finset α} :
    (s.subtype p).map (Embedding.subtype _) = s.filter p
-- Mathlib/RingTheory/Finiteness.lean
theorem finite_def {R M} [Semiring R] [AddCommMonoid M] [Module R M] :
    Finite R M ↔ (⊤ : Submodule R M).FG
-- Mathlib/Algebra/Opposites.lean
@[simp] lemma op_neg [Neg α] (x : α) : op (-x) = -op x
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
/-- `SemilinearIsometryEquivClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear
isometric equivs `E → E₂`.

See also `LinearIsometryEquivClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryEquivClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R]
  [Semiring R₂] (σ₁₂ : outParam <| R →+* R₂) {σ₂₁ : outParam <| R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [EquivLike 𝓕 E E₂]
  extends SemilinearEquivClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
-- Mathlib/Data/Finset/Sups.lean
theorem card_disjSups_le : (s ○ t).card ≤ s.card * t.card
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_shiftLeftZeroExtend (x : BitVec m) (n : Nat) :
    getLsb (shiftLeftZeroExtend x n) i = ((! decide (i < n)) && getLsb x (i - n))
-- Mathlib/Topology/Basic.lean
/-- If `g` tends to some `𝓝 x` along `f`, then it tends to `𝓝 (Filter.limUnder f g)`. We formulate
this lemma with a `[Nonempty X]` argument of `lim` derived from `h` to make it useful for types
without a `[Nonempty X]` instance. Because of the built-in proof irrelevance, Lean will unify this
instance with any other instance. -/
theorem tendsto_nhds_limUnder {f : Filter α} {g : α → X} (h : ∃ x, Tendsto g f (𝓝 x)) :
    Tendsto g f (𝓝 (@limUnder _ _ _ (nonempty_of_exists h) f g))
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- A non-constant polynomial has non-zero separable degree. -/
theorem natSepDegree_ne_zero (h : f.natDegree ≠ 0) : f.natSepDegree ≠ 0
-- Mathlib/Data/Set/Card.lean
@[simp] theorem one_le_encard_iff_nonempty : 1 ≤ s.encard ↔ s.Nonempty
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem withBotCongr_refl : (OrderIso.refl α).withBotCongr = OrderIso.refl _
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
@[measurability, fun_prop]
lemma measurable_log : Measurable log
-- Mathlib/Probability/Independence/Basic.lean
protected lemma iIndepFun.iIndep {m : ∀ i, MeasurableSpace (κ i)} {f : ∀ x : ι, Ω → κ x}
    (hf : iIndepFun m f μ) :
    iIndep (fun x ↦ (m x).comap (f x)) μ
-- Mathlib/Topology/Connected/PathConnected.lean
theorem IsPathConnected.mem_pathComponent (h : IsPathConnected F) (x_in : x ∈ F) (y_in : y ∈ F) :
    y ∈ pathComponent x
-- Mathlib/LinearAlgebra/Charpoly/Basic.lean
/-- The **Cayley-Hamilton Theorem**, that the characteristic polynomial of a linear map, applied
to the linear map itself, is zero.

See `Matrix.aeval_self_charpoly` for the equivalent statement about matrices. -/
theorem aeval_self_charpoly : aeval f f.charpoly = 0
-- Mathlib/Data/Nat/Find.lean
@[simp] lemma findGreatest_zero : Nat.findGreatest P 0 = 0
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem nonnegg_cases_right {c d} {a : ℕ} :
    ∀ {b : ℤ}, (∀ x : ℕ, b = -x → SqLe x c a d) → Nonnegg c d a b
-- Mathlib/Algebra/Module/Defs.lean
/-- `nsmul` is equal to any other module structure via a cast. -/
lemma Nat.cast_smul_eq_nsmul (n : ℕ) (b : M) : (n : R) • b = n • b
-- Mathlib/Topology/Order/ScottTopology.lean
lemma isLowerSet_of_isClosed : IsClosed s → IsLowerSet s
-- Mathlib/Data/PFun.lean
theorem mem_prodLift {f : α →. β} {g : α →. γ} {x : α} {y : β × γ} :
    y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x
-- Mathlib/Algebra/Field/Power.lean
theorem Odd.neg_one_zpow (h : Odd n) : (-1 : α) ^ n = -1
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem fstIdx_cons {i} (m : M i) (w : Word M) (hmw : w.fstIdx ≠ some i) (h1 : m ≠ 1) :
    fstIdx (cons m w hmw h1) = some i
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
@[simp]
theorem NormedAddGroupHom.extension_coe (f : NormedAddGroupHom G H) (v : G) : f.extension v = f v
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_equivSentence_symm_con [L[[α]].Structure M]
    [(L.lhomWithConstants α).IsExpansionOn M] (φ : L[[α]].Sentence) :
    ((equivSentence.symm φ).Realize fun a => (L.con a : M)) ↔ φ.Realize M
-- Mathlib/Analysis/Convex/Strong.lean
lemma UniformConcaveOn.strictConcaveOn (hf : UniformConcaveOn s φ f) (hφ : ∀ r, r ≠ 0 → 0 < φ r) :
    StrictConcaveOn ℝ s f
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp] lemma precompL_apply (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (u : Eₗ →L[𝕜] E) (f : Fₗ) (g : Eₗ) :
    precompL Eₗ L u f g = L (u g) f