ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
/-- Definition of `IsBigO` in terms of filters, with the constant in the lower bound. -/
theorem isBigO_iff'' {g : α → E'''} :
    f =O[l] g ↔ ∃ c > 0, ∀ᶠ x in l, c * ‖f x‖ ≤ ‖g x‖
-- Mathlib/Topology/ContinuousFunction/Compact.lean
@[simp]
theorem ContinuousLinearMap.compLeftContinuousCompact_apply (g : β →L[𝕜] γ) (f : C(X, β)) (x : X) :
    g.compLeftContinuousCompact X f x = g (f x)
-- Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean
@[fun_prop]
theorem IsBoundedBilinearMap.hasFDerivAt (h : IsBoundedBilinearMap 𝕜 b) (p : E × F) :
    HasFDerivAt b (h.deriv p) p
-- Mathlib/Order/UpperLower/Basic.lean
@[norm_cast]
theorem coe_lowerClosure (s : Set α) : ↑(lowerClosure s) = ⋃ a ∈ s, Iic a
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_sphere [Nontrivial E] (x : E) (r : ℝ) : μ (sphere x r) = 0
-- Mathlib/Data/List/Basic.lean
theorem mem_getLast?_eq_getLast : ∀ {l : List α} {x : α}, x ∈ l.getLast? → ∃ h, x = getLast l h
-- Mathlib/Data/Ordmap/Ordset.lean
theorem splitMin_eq :
    ∀ (s l) (x : α) (r), splitMin' l x r = (findMin' l x, eraseMin (node s l x r))
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
private lemma two_or_three_ne_zero : (2 : F) ≠ 0 ∨ (3 : F) ≠ 0
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma IsUpperSet.disjoint_lowerClosure_right (hs : IsUpperSet s) :
    Disjoint s (lowerClosure t) ↔ Disjoint s t
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem lim_add (f g : CauSeq β abv) : lim f + lim g = lim (f + g)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem mem_carrier_iff_of_mem_mul (hm : 0 < m)
    (q : Spec.T A⁰_ f) (a : A) {n} (hn : a ∈ 𝒜 (n * m)) :
    a ∈ carrier f_deg q ↔ (HomogeneousLocalization.mk ⟨m * n, ⟨a, mul_comm n m ▸ hn⟩,
        ⟨f ^ n, by rw [mul_comm]; mem_tac⟩, ⟨_, rfl⟩⟩ : A⁰_ f) ∈ q.asIdeal
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp]
theorem of_homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : isoOfHomeo (homeoOfIso f) = f
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem add_tprodCoeff [DecidableEq ι] (z : R) (f : Π i, s i) (i : ι) (m₁ m₂ : s i) :
    tprodCoeff R z (update f i m₁) + tprodCoeff R z (update f i m₂) =
      tprodCoeff R z (update f i (m₁ + m₂))
-- Mathlib/Combinatorics/SimpleGraph/Partition.lean
/-- Creates a partition from a coloring. -/
@[simps]
def Coloring.toPartition {α : Type v} (C : G.Coloring α) : G.Partition
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem coord_unitsSMul (e : Basis ι R₂ M) (w : ι → R₂ˣ) (i : ι) :
    (unitsSMul e w).coord i = (w i)⁻¹ • e.coord i
-- Mathlib/CategoryTheory/Limits/Shapes/RegularMono.lean
/-- A regular epimorphism is an isomorphism if it is a monomorphism. -/
theorem isIso_of_regularEpi_of_mono (f : X ⟶ Y) [RegularEpi f] [Mono f] : IsIso f
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem strictMono_x : StrictMono (xn a1)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem unique' {p q : Multiset (Associates α)} :
    (∀ a ∈ p, Irreducible a) → (∀ a ∈ q, Irreducible a) → p.prod = q.prod → p = q
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofAdd_sub [Sub α] (x y : α) : ofAdd (x - y) = ofAdd x / ofAdd y
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp] theorem Proj.mul_apply : (s * t).1 x = s.1 x * t.1 x
-- Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean
@[reassoc (attr := simp)]
theorem cofan_inj_πSummand_eq_id [HasZeroMorphisms C] {Δ : SimplexCategoryᵒᵖ} (A : IndexSet Δ) :
    (s.cofan Δ).inj A ≫ s.πSummand A = 𝟙 _
-- Mathlib/ModelTheory/FinitelyGenerated.lean
theorem fg_def : FG L M ↔ (⊤ : L.Substructure M).FG
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasStrictFDerivAt.smul (hc : HasStrictFDerivAt c c' x) (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) x
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem map_one : map (1 : M →ₗ[R] M) (1 : N →ₗ[R] N) = 1
-- Mathlib/Data/Nat/Cast/SetInterval.lean
theorem image_cast_int_Ioc (a b : ℕ) : (↑) '' Ioc a b = Ioc (a : ℤ) b
-- Mathlib/Data/String/Basic.lean
@[simp]
theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[nontriviality, measurability]
theorem aemeasurable_of_subsingleton_codomain [Subsingleton β] : AEMeasurable f μ
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem two_dvd_card_support {σ : Perm α} (hσ : σ ^ 2 = 1) : 2 ∣ σ.support.card
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfMinpoly_aeval (pb : PowerBasis A S) (pb' : PowerBasis A S')
    (h : minpoly A pb.gen = minpoly A pb'.gen) (f : A[X]) :
    pb.equivOfMinpoly pb' h (aeval pb.gen f) = aeval pb'.gen f
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
@[simp]
theorem coe_toLinear : (@toLinear n ‹_› ‹_› _ _ A : (n → R) →ₗ[R] n → R) = Matrix.mulVecLin A
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_div_rat_iff : Irrational (x / q) ↔ q ≠ 0 ∧ Irrational x
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
@[simp]
theorem equiv_symm_sub :
    (WithLp.equiv p V).symm (x' - y') = (WithLp.equiv p V).symm x' - (WithLp.equiv p V).symm y'
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
@[simp]
lemma pullback_mem_iff_of_isIso {i : X ⟶ Y} [IsIso i] {S : Sieve Y} :
    S.pullback i ∈ J _ ↔ S ∈ J _
-- Mathlib/Order/Filter/Bases.lean
/-- We say that a filter `l` has a basis `s : ι → Set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`. -/
structure HasBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- A set `t` belongs to a filter `l` iff it includes an element of the basis. -/
  mem_iff' : ∀ t : Set α, t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t
-- Mathlib/Logic/Function/Iterate.lean
theorem iterate_succ_apply (n : ℕ) (x : α) : f^[n.succ] x = f^[n] (f x)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem card_top (R) [Ring R] [Fintype R] : Fintype.card (⊤ : Subring R) = Fintype.card R
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Composition with a linear isometry on the right preserves the norm of the iterated derivative
within a set. -/
theorem LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right (g : G ≃ₗᵢ[𝕜] E) (f : E → F)
    (hs : UniqueDiffOn 𝕜 s) {x : G} (hx : g x ∈ s) (i : ℕ) :
    ‖iteratedFDerivWithin 𝕜 i (f ∘ g) (g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (g x)‖
-- Mathlib/MeasureTheory/Function/Jacobian.lean
lemma _root_.MeasurableEquiv.withDensity_ofReal_map_symm_apply_eq_integral_abs_deriv_mul'
    (f : ℝ ≃ᵐ ℝ) {s : Set ℝ} (hs : MeasurableSet s)
    {f' : ℝ → ℝ} (hf' : ∀ x, HasDerivAt f (f' x) x)
    {g : ℝ → ℝ} (hg : 0 ≤ᵐ[volume] g) (hg_int : Integrable g) :
    (volume.withDensity (fun x ↦ ENNReal.ofReal (g x))).map f.symm s
      = ENNReal.ofReal (∫ x in s, |f' x| * g (f x))
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/-- Congruence in the function part of an application: If `f = g` then `f a = g a`. -/
theorem congrFun {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : Eq f g) (a : α) : Eq (f a) (g a)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem zero_nmem_multiset_map_X_sub_C {α : Type*} (m : Multiset α) (f : α → R) :
    (0 : R[X]) ∉ m.map fun a => X - C (f a)
-- Mathlib/Algebra/Category/MonCat/FilteredColimits.lean
/-- Multiplication in the colimit is well-defined in the right argument. -/
@[to_additive "Addition in the colimit is well-defined in the right argument."]
theorem colimitMulAux_eq_of_rel_right {x y y' : Σ j, F.obj j}
    (hyy' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) y y') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x y'
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_true {s : True → Set α} : iUnion s = s trivial
-- Mathlib/RingTheory/Support.lean
lemma Module.support_of_algebra {A : Type*} [Ring A] [Algebra R A] :
    Module.support R A = PrimeSpectrum.zeroLocus (RingHom.ker (algebraMap R A))
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicatorAux_closure_eq (δ : ℝ) (E : Set α) :
    thickenedIndicatorAux δ (closure E) = thickenedIndicatorAux δ E
-- Mathlib/RingTheory/Localization/FractionRing.lean
theorem isFractionRing_iff_of_base_ringEquiv (h : R ≃+* P) :
    IsFractionRing R S ↔
      @IsFractionRing P _ S _ ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
-- Mathlib/NumberTheory/Liouville/Residual.lean
theorem setOf_liouville_eq_iInter_iUnion :
    { x | Liouville x } =
      ⋂ n : ℕ, ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b),
      ball ((a : ℝ) / b) (1 / (b : ℝ) ^ n) \ {(a : ℝ) / b}
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- The set in the definition of `Order.StrictOrder.cof` is nonempty. -/
theorem StrictOrder.cof_nonempty (r : α → α → Prop) [IsIrrefl α r] :
    { c | ∃ S : Set α, Unbounded r S ∧ #S = c }.Nonempty
-- Mathlib/Topology/IsLocalHomeomorph.lean
theorem map_nhds_eq (hf : IsLocalHomeomorph f) (x : X) : (𝓝 x).map f = 𝓝 (f x)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiff_neg : ContDiff 𝕜 n fun p : F => -p
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma isOpen_iInter (hf : ∀ i, IsOpen (f i)) : IsOpen (⋂ i, f i)
-- Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean
@[simp]
lemma lanAdjunction_unit : (L.lanAdjunction H).unit = L.lanUnit
-- Mathlib/Data/Sym/Basic.lean
theorem exists_eq_cons_of_succ (s : Sym α n.succ) : ∃ (a : α) (s' : Sym α n), s = a ::ₛ s'
-- Mathlib/Data/Real/Sqrt.lean
/-- **Cauchy-Schwarz inequality** for finsets using square roots in `ℝ≥0`. -/
lemma sum_sqrt_mul_sqrt_le (s : Finset ι) (f g : ι → ℝ≥0) :
    ∑ i ∈ s, sqrt (f i) * sqrt (g i) ≤ sqrt (∑ i ∈ s, f i) * sqrt (∑ i ∈ s, g i)
-- Mathlib/NumberTheory/GaussSum.lean
/-- When `χ` is a nontrivial quadratic character, then the square of `gaussSum χ ψ`
is `χ(-1)` times the cardinality of `R`. -/
theorem gaussSum_sq {χ : MulChar R R'} (hχ₁ : χ ≠ 1) (hχ₂ : IsQuadratic χ)
    {ψ : AddChar R R'} (hψ : IsPrimitive ψ) :
    gaussSum χ ψ ^ 2 = χ (-1) * Fintype.card R
-- Mathlib/Tactic/NormNum/Result.lean
theorem IsNat.to_raw_eq {a : α} {n : ℕ} [AddMonoidWithOne α] : IsNat (a : α) n → a = n.rawCast
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem translationNumber_le_ceil_sub (x : ℝ) : τ f ≤ ⌈f x - x⌉
-- Mathlib/Algebra/Ring/Parity.lean
lemma iterate_two_mul (hf : Involutive f) (n : ℕ) : f^[2 * n] = id
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem take_sublist (n) (l : List α) : take n l <+ l
-- Mathlib/Data/Set/Function.lean
theorem mono (hf : LeftInvOn f' f s) (ht : s₁ ⊆ s) : LeftInvOn f' f s₁
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioc_subset_Iic_self : Ioc a b ⊆ Iic b
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_unique [Unique α] (f : α → ℝ≥0∞) : ∫⁻ x, f x ∂μ = f default * μ univ
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[norm_cast]
theorem coe_fn_coe (f : A →ₑ+[φ] B) : ⇑(f : A →+ B) = f
-- Mathlib/MeasureTheory/Measure/Doubling.lean
/-- A measure `μ` is said to be a uniformly locally doubling measure if there exists a constant `C`
such that for all sufficiently small radii `ε`, and for any centre, the measure of a ball of radius
`2 * ε` is bounded by `C` times the measure of the concentric ball of radius `ε`.

Note: it is important that this definition makes a demand only for sufficiently small `ε`. For
example we want hyperbolic space to carry the instance `IsUnifLocDoublingMeasure volume` but
volumes grow exponentially in hyperbolic space. To be really explicit, consider the hyperbolic plane
of curvature -1, the area of a disc of radius `ε` is `A(ε) = 2π(cosh(ε) - 1)` so
`A(2ε)/A(ε) ~ exp(ε)`. -/
class IsUnifLocDoublingMeasure {α : Type*} [MetricSpace α] [MeasurableSpace α]
  (μ : Measure α) : Prop where
  exists_measure_closedBall_le_mul'' :
    ∃ C : ℝ≥0, ∀ᶠ ε in 𝓝[>] 0, ∀ x, μ (closedBall x (2 * ε)) ≤ C * μ (closedBall x ε)
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem insert_none_range_some (α : Type*) : insert none (range (some : α → Option α)) = univ
-- Mathlib/Data/PFun.lean
@[simp]
theorem prodMap_apply (f : α →. γ) (g : β →. δ) (x : α × β) :
    f.prodMap g x = ⟨(f x.1).Dom ∧ (g x.2).Dom, fun h => ((f x.1).get h.1, (g x.2).get h.2)⟩
-- Mathlib/Data/Finset/Option.lean
theorem card_toFinset (o : Option α) : o.toFinset.card = o.elim 0 1
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem continuous_vsub : Continuous fun x : P × P => x.1 -ᵥ x.2
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.congr {f g : α → β} (hf : HasFiniteIntegral f μ) (h : f =ᵐ[μ] g) :
    HasFiniteIntegral g μ
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
/-- A Liouville number is a Liouville number with any real exponent. -/
protected theorem liouvilleWith (hx : Liouville x) (p : ℝ) : LiouvilleWith p x
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem eq_ratNorm (q : ℚ_[p]) : ‖q‖ = ratNorm q
-- Mathlib/Analysis/BoundedVariation.lean
theorem LipschitzWith.comp_locallyBoundedVariationOn {f : E → F} {C : ℝ≥0}
    (hf : LipschitzWith C f) {g : α → E} {s : Set α} (h : LocallyBoundedVariationOn g s) :
    LocallyBoundedVariationOn (f ∘ g) s
-- Mathlib/Order/Filter/Lift.lean
theorem tendsto_lift {m : γ → β} {l : Filter γ} :
    Tendsto m l (f.lift g) ↔ ∀ s ∈ f, Tendsto m l (g s)
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_iff_not_odd : Even n ↔ ¬Odd n
-- Mathlib/Order/SupIndep.lean
/-- If the elements of a set are independent, then any element is disjoint from the `sSup` of some
subset of the rest. -/
theorem SetIndependent.disjoint_sSup {x : α} {y : Set α} (hx : x ∈ s) (hy : y ⊆ s) (hxy : x ∉ y) :
    Disjoint x (sSup y)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
lemma isNilpotent_trace_of_isNilpotent (hM : IsNilpotent M) :
    IsNilpotent (trace M)
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
lemma effectiveEpi_of_map (F : C ⥤ D) [F.ReflectsEffectiveEpis] {X Y : C} (f : X ⟶ Y)
    (h : EffectiveEpi (F.map f)) : EffectiveEpi f
-- Mathlib/Probability/Variance.lean
/-- The variance of a finite sum of pairwise independent random variables is the sum of the
variances. -/
theorem IndepFun.variance_sum [@IsProbabilityMeasure Ω _ ℙ] {ι : Type*} {X : ι → Ω → ℝ}
    {s : Finset ι} (hs : ∀ i ∈ s, @Memℒp _ _ _ (_) (X i) 2 ℙ)
    (h : Set.Pairwise ↑s fun i j => @IndepFun _ _ _ (_) _ _ (X i) (X j) ℙ) :
    Var[∑ i ∈ s, X i] = ∑ i ∈ s, Var[X i]
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem union_inter_cancel_right {s t : Finset α} : (s ∪ t) ∩ t = t
-- Mathlib/Data/Part.lean
theorem eq_some_iff {a : α} {o : Part α} : o = some a ↔ a ∈ o
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem mclosure_range_inl_union_inr :
    Submonoid.closure (range (inl : M →* M ∗ N) ∪ range (inr : N →* M ∗ N)) = ⊤
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem smul_dirac_apply (a : ℝ≥0∞) (b : α) (s : Set α) :
    (a • dirac b) s = indicator s (fun _ => a) b
-- Mathlib/Data/DFinsupp/Order.lean
@[simp, norm_cast] lemma coe_lt_coe : ⇑f < g ↔ f < g
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@[reassoc (attr := simp)]
theorem toOpen_unit_app_val_c_app' {X : Scheme.{u}} (U : Opens (PrimeSpectrum Γ(X, ⊤))) :
    toOpen Γ(X, ⊤) U ≫ (adjunction.unit.app X).app U =
      X.presheaf.map (homOfLE (by exact le_top)).op
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_insert (s t : Finset α) (x : α) : s \ insert x t = (s \ t).erase x
-- Mathlib/Algebra/Polynomial/CancelLeads.lean
@[simp]
theorem neg_cancelLeads : -p.cancelLeads q = q.cancelLeads p
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_inv_le_iff_of_neg (h : a < 0) : b₁ ≤ a⁻¹ • b₂ ↔ b₂ ≤ a • b₁
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem add_mul_div_left (x z : Nat) {y : Nat} (H : 0 < y) : (x + y * z) / y = x / y + z
-- Mathlib/Data/Int/GCD.lean
theorem gcd_pos_of_ne_zero_right (i : ℤ) {j : ℤ} (hj : j ≠ 0) : 0 < gcd i j
-- Mathlib/Data/Nat/Defs.lean
lemma rec_add_one {C : ℕ → Sort*} (h0 : C 0) (h : ∀ n, C n → C (n + 1)) (n : ℕ) :
    Nat.rec h0 h (n + 1) = h n (Nat.rec h0 h n)
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem le_pushforward_pullback (f : Y ⟶ X) (R : Sieve Y) : R ≤ (R.pushforward f).pullback f
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem isPartitionTop (I : Box ι) : IsPartition (⊤ : Prepartition I)
-- Mathlib/LinearAlgebra/Dimension/DivisionRing.lean
/-- The **Erdős-Kaplansky Theorem** over a field. -/
theorem rank_dual_eq_card_dual_of_aleph0_le_rank {K V} [Field K] [AddCommGroup V] [Module K V]
    (h : ℵ₀ ≤ Module.rank K V) : Module.rank K (V →ₗ[K] K) = #(V →ₗ[K] K)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem of_map {g : β → γ} (h : (f.map g).FinMeasSupp μ) (hg : ∀ b, g b = 0 → b = 0) :
    f.FinMeasSupp μ
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem logGammaSeq_add_one (x : ℝ) (n : ℕ) :
    logGammaSeq (x + 1) n = logGammaSeq x (n + 1) + log x - (x + 1) * (log (n + 1) - log n)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
theorem le_of_opNorm₂_le_of_le [RingHomIsometric σ₁₃] (f : E →SL[σ₁₃] F →SL[σ₂₃] G) {x : E} {y : F}
    {a b c : ℝ} (hf : ‖f‖ ≤ a) (hx : ‖x‖ ≤ b) (hy : ‖y‖ ≤ c) :
    ‖f x y‖ ≤ a * b * c
-- Mathlib/Combinatorics/Colex.lean
@[simp] lemma isInitSeg_empty : IsInitSeg (∅ : Finset (Finset α)) r
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.card_fin (n : ℕ) : Finset.card (Finset.univ : Finset (Fin n)) = n
-- Mathlib/RingTheory/WittVector/Isocrystal.lean
/-- A one-dimensional isocrystal over an algebraically closed field
admits an isomorphism to one of the standard (indexed by `m : ℤ`) one-dimensional isocrystals. -/
theorem isocrystal_classification (k : Type*) [Field k] [IsAlgClosed k] [CharP k p] (V : Type*)
    [AddCommGroup V] [Isocrystal p k V] (h_dim : finrank K(p, k) V = 1) :
    ∃ m : ℤ, Nonempty (StandardOneDimIsocrystal p k m ≃ᶠⁱ[p, k] V)
-- Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean
lemma comp (g h : L ≃+* L) : χ₀ n (g * h) =
    χ₀ n g * χ₀ n h
-- Mathlib/Order/Hom/Basic.lean
protected theorem monotone (f : α →o β) : Monotone f
-- Mathlib/Data/Fin/Basic.lean
protected theorem coe_neg (a : Fin n) : ((-a : Fin n) : ℕ) = (n - a) % n
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivWithinAt.const_sub (hf : HasFDerivWithinAt f f' s x) (c : F) :
    HasFDerivWithinAt (fun x => c - f x) (-f') s x
-- Mathlib/AlgebraicGeometry/Scheme.lean
theorem Spec_toLocallyRingedSpace (R : CommRingCat) :
    (Spec R).toLocallyRingedSpace = Spec.locallyRingedSpaceObj R
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem dropFun_from_append1_drop_last {α : TypeVec (n + 1)} :
    dropFun (@fromAppend1DropLast _ α) = id
-- Mathlib/Order/LiminfLimsup.lean
theorem bliminf_antitone_filter (h : f ≤ g) : bliminf u g p ≤ bliminf u f p
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_lt_iff [IsWellOrder ι (· < ·)] {m : ι} (i : ι) (hi : i ≤ m) :
    hitting u s n m ω < i ↔ ∃ j ∈ Set.Ico n i, u j ω ∈ s
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[norm_cast]
theorem coe_one : (↑(1 : ℚ) : ℚ_[p]) = 1
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem Step.succ (n : ℕ) : Step k (n + 1) = AdjoinMonic (Step k n)
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Iic_Iio {a : α} (b : Iic a) : Subtype.val '' Iio b = Iio b.1
-- Mathlib/Analysis/Convex/Gauge.lean
@[simp]
theorem gauge_zero' : gauge (0 : Set E) = 0
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
lemma eq_bot_iff_card : S = ⊥ ↔ card S = 1
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem prevn (h : Valid it) : ∀ n, Valid (it.prevn n)
-- Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
/-- The Euler product for Dirichlet L-series, valid for `s.re > 1`.
This version is stated in terms of `tprod`. -/
theorem dirichletLSeries_eulerProduct_tprod {N : ℕ} (χ : DirichletCharacter ℂ N)
    (hs : 1 < s.re) :
    ∏' p : Primes, (1 - χ p * (p : ℂ) ^ (-s))⁻¹ = L ↗χ s
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem Algebra.lift_algHom_comp_left [Algebra.IsPushout R S R' S'] {A : Type*} [Semiring A]
    [Algebra R A] (f : S →ₐ[R] A) (g : R' →ₐ[R] A) (H) :
    (Algebra.pushoutDesc S' f g H).comp (toAlgHom R S S') = f
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma cyclesIsoX₂_inv_hom_id (hg : S.g = 0) :
    (S.cyclesIsoX₂ hg).inv ≫ S.iCycles = 𝟙 _
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_neg_iff (h : 0 < x) : logb b x < 0 ↔ x < 1
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biproduct.isoProduct_hom {f : J → C} [HasBiproduct f] :
    (biproduct.isoProduct f).hom = Pi.lift (biproduct.π f)
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
@[simp]
theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c : M₁) * x = 0 ↔ x = 0
-- Mathlib/Data/List/Chain.lean
theorem chain_iff_get {R} : ∀ {a : α} {l : List α}, Chain R a l ↔
    (∀ h : 0 < length l, R a (get l ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < l.length - 1),
        R (get l ⟨i, by omega⟩) (get l ⟨i+1, by omega⟩)
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem Iio_succ (a : α) : Iio (succ a) = Iic a
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The vector space of functions on `Fin n` has finrank equal to `n`. -/
-- @[simp] -- Porting note (#10618): simp already proves this
theorem FiniteDimensional.finrank_fin_fun {n : ℕ} : finrank R (Fin n → R) = n
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_pow [Nontrivial R] (p : R[X]) (n : ℕ) : degree (p ^ n) = n • degree p
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_lt_of_lt_one_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (h : b ≤ c) (hb : 0 < b) :
    a * b < c
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem iSupLift_mk {i : ι} (x : K i) (hx : (x : A) ∈ T) :
    iSupLift K dir f hf T hT ⟨x, hx⟩ = f i x
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem IsLUB.csSup_eq (H : IsLUB s a) (ne : s.Nonempty) : sSup s = a
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diagonal_neg [NegZeroClass α] (d : n → α) :
    -diagonal d = diagonal fun i => -d i
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem isOpen_iff_of_mem' (h : ∞ ∈ s) :
    IsOpen s ↔ IsCompact ((↑) ⁻¹' s : Set X)ᶜ ∧ IsOpen ((↑) ⁻¹' s : Set X)
-- Mathlib/Data/Nat/Digits.lean
theorem digits_len_le_digits_len_succ (b n : ℕ) :
    (digits b n).length ≤ (digits b (n + 1)).length
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem findSome?_nil : ([] : List α).findSome? f = none
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
lemma natCast_le_rank_iff {n : ℕ} :
    n ≤ Module.rank R M ↔ ∃ f : Fin n → M, LinearIndependent R f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem mul_two (n) : n * 2 = n + n
-- Mathlib/Algebra/Regular/Pow.lean
/-- Any power of a right-regular element is right-regular. -/
theorem IsRightRegular.pow (n : ℕ) (rra : IsRightRegular a) : IsRightRegular (a ^ n)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp] theorem domCongr_refl : domCongr k A (AddEquiv.refl G) = AlgEquiv.refl
-- Mathlib/ModelTheory/Substructures.lean
theorem mem_sInf {S : Set (L.Substructure M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_union_Ioc_eq_Ioc (h₁ : a ≤ b) (h₂ : b ≤ c) : Ioc a b ∪ Ioc b c = Ioc a c
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem toList_head? {i j} (w : NeWord M i j) : w.toList.head? = Option.some ⟨i, w.head⟩
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contDiffWithinAtProp_id (x : H) : ContDiffWithinAtProp I I n id univ x
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem toLinearPMap_apply_aux {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0)
    (x : g.map (LinearMap.fst R E F)) :
    g.toLinearPMap x = valFromGraph hg x.2
-- Mathlib/Control/Functor/Multivariate.lean
theorem LiftP_def (x : F α) : LiftP' P x ↔ ∃ u : F (Subtype_ P), subtypeVal P <$$> u = x
-- Mathlib/GroupTheory/Perm/Support.lean
theorem support_swap_mul_eq (f : Perm α) (x : α) (h : f (f x) ≠ x) :
    (swap x (f x) * f).support = f.support \ {x}