ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- Adding a `weightedVSub` to an `affineCombination`. -/
theorem weightedVSub_vadd_affineCombination (w₁ w₂ : ι → k) (p : ι → P) :
    s.weightedVSub p w₁ +ᵥ s.affineCombination k p w₂ = s.affineCombination k p (w₁ + w₂)
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
/-- We can always derive `HasFiniteLimits C` by providing limits at an
arbitrary universe. -/
theorem hasFiniteLimits_of_hasFiniteLimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasLimitsOfShape J C) :
    HasFiniteLimits C
-- Mathlib/Data/Nat/PartENat.lean
theorem add_top (x : PartENat) : x + ⊤ = ⊤
-- Mathlib/Tactic/CategoryTheory/Monoidal.lean
theorem evalWhiskerRight_id
    {η : f ⟶ g} {η₁ : f ⟶ g ⊗ 𝟙_ C} {η₂ : f ⊗ 𝟙_ C ⟶ g ⊗ 𝟙_ C}
    (pf_η₁ : η ≫ (ρ_ _).inv = η₁) (pf_η₂ : (ρ_ _).hom ≫ η₁ = η₂) :
    η ▷ 𝟙_ C = η₂
-- Mathlib/Topology/Order/Basic.lean
theorem tendsto_nhds_top_mono [TopologicalSpace β] [Preorder β] [OrderTop β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊤)) (hg : f ≤ᶠ[l] g) : Tendsto g l (𝓝 ⊤)
-- Mathlib/SetTheory/Ordinal/Exponential.lean
@[simp]
theorem log_zero_left : ∀ b, log 0 b = 0
-- Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean
/-- Any morphism between affine schemes that is surjective on global sections is a
closed immersion. -/
lemma of_surjective_of_isAffine {X Y : Scheme} [IsAffine X] [IsAffine Y] (f : X ⟶ Y)
    (h : Function.Surjective (Scheme.Γ.map f.op)) : IsClosedImmersion f
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
/-- For rewriting in the reverse direction, see `Fin.cast_natAdd_right`. -/
theorem natAdd_cast {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n) :
    natAdd m (cast h i) = cast (congrArg _ h) (natAdd m i)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_nhdsWithin_eq (s : Set H) (x : H) : map I (𝓝[s] x) = 𝓝[I '' s] I x
-- Mathlib/Topology/SeparatedMap.lean
lemma Function.Injective.isSeparatedMap {f : X → Y} (inj : f.Injective) : IsSeparatedMap f
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[measurability]
protected theorem MeasurableSet.insert {s : Set α} (hs : MeasurableSet s) (a : α) :
    MeasurableSet (insert a s)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem mem_Ico : x ∈ Ico a b ↔ a ≤ x ∧ x < b
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
protected lemma add_smul : smul α φ (r + r') m = smul α φ r m + smul α φ r' m
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem diam_iUnion_mem_option {ι : Type*} (o : Option ι) (s : ι → Set α) :
    diam (⋃ i ∈ o, s i) = ⨆ i ∈ o, diam (s i)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpL1CLM_lpMeas (f : lpMeas F' ℝ m 1 μ) :
    condexpL1CLM F' hm μ (f : α →₁[μ] F') = ↑f
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem length_dropLast_cons (a : α) (as : List α) : (a :: as).dropLast.length = as.length
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem List.measurable_prod (l : List (α → M)) (hl : ∀ f ∈ l, Measurable f) :
    Measurable fun x => (l.map fun f : α → M => f x).prod
-- Mathlib/Data/Set/Finite.lean
lemma Directed.exists_mem_subset_of_finset_subset_biUnion {α ι : Type*} [Nonempty ι]
    {f : ι → Set α} (h : Directed (· ⊆ ·) f) {s : Finset α} (hs : (s : Set α) ⊆ ⋃ i, f i) :
    ∃ i, (s : Set α) ⊆ f i
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem bind_assoc (s : WSeq α) (f : α → WSeq β) (g : β → WSeq γ) :
    bind (bind s f) g ~ʷ bind s fun x : α => bind (f x) g
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem sum_le_tsum {f : α → ℝ≥0∞} (s : Finset α) : ∑ x ∈ s, f x ≤ ∑' x, f x
-- Mathlib/CategoryTheory/SingleObj.lean
theorem toEnd_def (x : M) : toEnd M x = x
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- An identity partial homeomorphism belongs to the `C^n` groupoid. -/
theorem ofSet_mem_contDiffGroupoid {s : Set H} (hs : IsOpen s) :
    PartialHomeomorph.ofSet s hs ∈ contDiffGroupoid n I
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem symm_dual_comp (g : CompleteLatticeHom βᵒᵈ γᵒᵈ) (f : CompleteLatticeHom αᵒᵈ βᵒᵈ) :
    CompleteLatticeHom.dual.symm (g.comp f) =
      (CompleteLatticeHom.dual.symm g).comp (CompleteLatticeHom.dual.symm f)
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
@[simp]
theorem withDensity_eq_zero_iff {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
    μ.withDensity f = 0 ↔ f =ᵐ[μ] 0
-- Mathlib/SetTheory/Surreal/Multiplication.lean
theorem Numeric.mul_pos (hp₁ : 0 < x₁) (hp₂ : 0 < x₂) : 0 < x₁ * x₂
-- Mathlib/Data/Set/Basic.lean
@[simp]
lemma disjoint_union_left : Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem ofDual_natCast [NatCast α] (n : ℕ) : (ofDual n : α) = n
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem inv_cpow_eq_ite (x : ℂ) (n : ℂ) :
    x⁻¹ ^ n = if x.arg = π then conj (x ^ conj n)⁻¹ else (x ^ n)⁻¹
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem exists_prime_mul_pow_lt_factorial (n a c : ℕ) : ∃ p > n, p.Prime ∧ a * c ^ p < (p - 1)!
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem ofLeftInverseS_apply {g : S → R} {f : R →+* S} (h : Function.LeftInverse g f) (x : R) :
    ↑(ofLeftInverseS h x) = f x
-- Mathlib/Order/Monotone/Odd.lean
/-- An odd function on a linear ordered additive commutative group is antitone on the whole group
provided that it is monotone on `Set.Ici 0`. -/
theorem antitone_of_odd_of_monotoneOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : AntitoneOn f (Ici 0)) : Antitone f
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableWithinAt.mdifferentiableAt (h : MDifferentiableWithinAt I I' f s x)
    (hs : s ∈ 𝓝 x) : MDifferentiableAt I I' f x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem not_mem_nil (a : α) : ¬ a ∈ []
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem norm_mul_le (a b : α) : ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- Mathlib/Analysis/Convex/Complex.lean
theorem convex_halfspace_re_ge (r : ℝ) : Convex ℝ { c : ℂ | r ≤ c.re }
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
    μ ≤ ν.transpose
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem v2_coeff {p' R'} (x y : WittVector p' R') (i : Fin 2) :
    (![x, y] i).coeff = ![x.coeff, y.coeff] i
-- Mathlib/MeasureTheory/Integral/Average.lean
@[simp]
theorem laverage_const (μ : Measure α) [IsFiniteMeasure μ] [h : NeZero μ] (c : ℝ≥0∞) :
    ⨍⁻ _x, c ∂μ = c
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem chart_source_mem_nhds (x : M) : (chartAt H x).source ∈ 𝓝 x
-- Mathlib/Logic/Equiv/Basic.lean
theorem piCongr_symm_apply (f : ∀ b, Z b) :
    (h₁.piCongr h₂).symm f = fun a => (h₂ a).symm (f (h₁ a))
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le_add_one {a b : Int} (h : a ≤ b) : a ≤ b + 1
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
theorem transAssocReparamAux_mem_I (t : I) : transAssocReparamAux t ∈ I
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[simp]
theorem integral_const (c : E) : ∫ _ : α, c ∂μ = (μ univ).toReal • c
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem coeFun_mapEquiv (g : P ≃ₐ[R] P') :
    (mapEquiv g : FractionalIdeal S P → FractionalIdeal S P') = map g
-- Mathlib/RingTheory/Localization/Module.lean
@[simp]
theorem Basis.ofIsLocalizedModule_apply (i : ι) : b.ofIsLocalizedModule Rₛ S f i = f (b i)
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_neg (a : R) : abv (-a) = abv a
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_zero'_apply (f : R →+* S₂) (p : MvPolynomial σ R) :
    eval₂ f (fun _ => 0 : σ → S₂) p = f (constantCoeff p)
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
@[simp] lemma arrowCongr_symm (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) :
    (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
@[simp] lemma id_τ₁ : Hom.τ₁ (𝟙 S) = 𝟙 _
-- Mathlib/Data/Prod/Basic.lean
theorem fst_injective [Subsingleton β] : Function.Injective (@fst α β)
-- .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean
@[simp] theorem ForInStep.run_done : (ForInStep.done a).run = a
-- Mathlib/Analysis/RCLike/Basic.lean
theorem im_le_norm (z : K) : im z ≤ ‖z‖
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
lemma injective_eq_monomorphisms [(forget C).PreservesMonomorphisms] :
    MorphismProperty.injective C = monomorphisms C
-- Mathlib/Data/Int/ModEq.lean
lemma of_mul_right (m : ℤ) : a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n]
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem DeleteFar.mono (h : G.DeleteFar p r₂) (hr : r₁ ≤ r₂) : G.DeleteFar p r₁
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem contMDiffOn_proj {s : Set (TotalSpace F E)} :
    ContMDiffOn (IB.prod 𝓘(𝕜, F)) IB n (π F E) s
-- Mathlib/Control/Traversable/Equiv.lean
protected theorem id_map {α : Type u} (x : t' α) : Equiv.map eqv id x = x
-- Mathlib/Order/Heyting/Basic.lean
@[gcongr]
theorem sdiff_le_sdiff (hab : a ≤ b) (hcd : c ≤ d) : a \ d ≤ b \ c
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem snd_inr [Zero R] (m : M) : (inr m : tsze R M).snd = m
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem ofConeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cone G ≌ Cone F) {c : Cone G} (P : IsLimit c) (s) :
    ((ofConeEquiv h).symm P).lift s =
      (h.counitIso.inv.app s).hom ≫ (h.functor.map (P.liftConeMorphism (h.inverse.obj s))).hom
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- On square matrices, `mul_left_comm` applies under `det`. -/
theorem det_mul_left_comm (M N P : Matrix m m R) : det (M * (N * P)) = det (N * (M * P))
-- Mathlib/Data/Int/CardIntervalMod.lean
/-- There are `⌊(b - v) / r⌋ - ⌊(a - v) / r⌋` numbers congruent to `v` mod `r` in `(a, b]`,
if `a ≤ b`. -/
theorem Ioc_filter_modEq_card (v : ℤ) : ((Ioc a b).filter (· ≡ v [ZMOD r])).card =
    max (⌊(b - v) / (r : ℚ)⌋ - ⌊(a - v) / (r : ℚ)⌋) 0
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
lemma IsIntegralCurve.continuous (hγ : IsIntegralCurve γ v) : Continuous γ
-- Mathlib/Tactic/ComputeDegree.lean
theorem natDegree_smul_le_of_le {n : ℕ} {a : R} {f : R[X]} (hf : natDegree f ≤ n) :
    natDegree (a • f) ≤ n
-- Mathlib/Probability/Moments.lean
@[simp]
theorem cgf_const' [IsFiniteMeasure μ] (hμ : μ ≠ 0) (c : ℝ) :
    cgf (fun _ => c) μ t = log (μ Set.univ).toReal + t * c
-- Mathlib/Data/Nat/Defs.lean
lemma one_mod_of_ne_one : ∀ {n : ℕ}, n ≠ 1 → 1 % n = 1
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_add_nonpos_right (hf : Tendsto f l atBot) (hg : ∀ x, g x ≤ 0) :
    Tendsto (fun x => f x + g x) l atBot
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem length_empty : "".length = 0
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurable_set_not_mem (a : α) : Measurable fun s : Set α ↦ a ∉ s
-- Mathlib/Topology/Order/ExtrClosure.lean
protected theorem IsLocalExtrOn.closure (h : IsLocalExtrOn f s a)
    (hc : ContinuousOn f (closure s)) : IsLocalExtrOn f (closure s) a
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
theorem FarFromTriangleFree.nonpos (h₀ : G.FarFromTriangleFree ε) (h₁ : G.CliqueFree 3) :
    ε ≤ 0
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_add {f g : α →ₛ E} (hf : Integrable f μ) (hg : Integrable g μ) :
    integral μ (f + g) = integral μ f + integral μ g
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem _root_.fourierIntegral_gaussian_innerProductSpace' (hb : 0 < b.re) (x w : V) :
    𝓕 (fun v ↦ cexp (- b * ‖v‖^2 + 2 * π * Complex.I * ⟪x, v⟫)) w =
      (π / b) ^ (FiniteDimensional.finrank ℝ V / 2 : ℂ) * cexp (-π ^ 2 * ‖x - w‖ ^ 2 / b)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem coe_liftHom (h : IsAdjoinRoot S f) :
    (h.liftHom x hx' : S →+* T) = h.lift (algebraMap R T) x hx'
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
theorem starAlgHomClass_ext [T2Space B] {F : Type*} {a : A}
    [FunLike F (elementalStarAlgebra R a) B] [AlgHomClass F R _ B] [StarAlgHomClass F R _ B]
    {φ ψ : F} (hφ : Continuous φ)
    (hψ : Continuous ψ) (h : φ ⟨a, self_mem R a⟩ = ψ ⟨a, self_mem R a⟩) : φ = ψ
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem liftMonoidWithZeroHom_injective [Nontrivial R] (φ : R[X] →*₀ G₀) (hφ : Function.Injective φ)
    (hφ' : R[X]⁰ ≤ G₀⁰.comap φ := nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _ hφ) :
    Function.Injective (liftMonoidWithZeroHom φ hφ')
-- Mathlib/Algebra/Category/ModuleCat/Free.lean
/-- In a short exact sequence `0 ⟶ X₁ ⟶ X₂ ⟶ X₃ ⟶ 0`, if `X₁` and `X₃` are free,
then `X₂` is free. -/
theorem free_shortExact [Module.Free R S.X₁] [Module.Free R S.X₃] :
    Module.Free R S.X₂
-- Mathlib/Analysis/RCLike/Lemmas.lean
@[simp, rclike_simps]
theorem conjCLE_norm : ‖(@conjCLE K _ : K →L[ℝ] K)‖ = 1
-- Mathlib/NumberTheory/RamificationInertia.lean
@[simp]
theorem inertiaDeg_algebraMap [Algebra R S] [Algebra (R ⧸ p) (S ⧸ P)]
    [IsScalarTower R (R ⧸ p) (S ⧸ P)] [hp : p.IsMaximal] :
    inertiaDeg (algebraMap R S) p P = finrank (R ⧸ p) (S ⧸ P)
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem compRightAlgHom_continuous {X Y : Type*} (R A : Type*) [TopologicalSpace X]
    [CompactSpace X] [TopologicalSpace Y] [CompactSpace Y] [CommSemiring R] [Semiring A]
    [MetricSpace A] [TopologicalSemiring A] [Algebra R A] (f : C(X, Y)) :
    Continuous (compRightAlgHom R A f)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/SimplyConnected.lean
theorem simply_connected_iff_unique_homotopic (X : Type*) [TopologicalSpace X] :
    SimplyConnectedSpace X ↔
      Nonempty X ∧ ∀ x y : X, Nonempty (Unique (Path.Homotopic.Quotient x y))
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem eq_zero_of_le_zero {n : Nat} (h : n ≤ 0) : n = 0
-- Mathlib/Analysis/Calculus/Deriv/Prod.lean
theorem hasDerivAt_pi : HasDerivAt φ φ' x ↔ ∀ i, HasDerivAt (fun x => φ x i) (φ' i) x
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
private lemma infs_aux : a ∈ lowerClosure ↑(s ⊼ t) ↔ a ∈ lowerClosure s ∧ a ∈ lowerClosure t
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem one_smul' (b : ArithmeticFunction M) : (1 : ArithmeticFunction R) • b = b
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
/-- If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `J` is nonzero. -/
theorem ideal_factor_ne_zero {R} [CommRing R] {K : Type*} [Field K] [Algebra R K]
    [IsFractionRing R K] {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R} {J : Ideal R}
    (haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) : J ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasStrictFDerivAt.rpow_const (hf : HasStrictFDerivAt f f' x) (h : f x ≠ 0 ∨ 1 ≤ p) :
    HasStrictFDerivAt (fun x => f x ^ p) ((p * f x ^ (p - 1)) • f') x
-- Mathlib/Algebra/Polynomial/Div.lean
theorem natDegree_divByMonic (f : R[X]) {g : R[X]} (hg : g.Monic) :
    natDegree (f /ₘ g) = natDegree f - natDegree g
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem exists_lt_lintegral_simpleFunc_of_lt_lintegral {m : MeasurableSpace α} {μ : Measure α}
    [SigmaFinite μ] {f : α → ℝ≥0} {L : ℝ≥0∞} (hL : L < ∫⁻ x, f x ∂μ) :
    ∃ g : α →ₛ ℝ≥0, (∀ x, g x ≤ f x) ∧ ∫⁻ x, g x ∂μ < ∞ ∧ L < ∫⁻ x, g x ∂μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean
lemma cosh_eq_tsum (r : ℝ) : cosh r = ∑' n, r ^ (2 * n) / ↑(2 * n)!
-- Mathlib/Analysis/InnerProductSpace/Spectrum.lean
@[simp]
theorem apply_eigenvectorBasis (i : Fin n) :
    T (hT.eigenvectorBasis hn i) = (hT.eigenvalues hn i : 𝕜) • hT.eigenvectorBasis hn i
-- Mathlib/Data/Option/Basic.lean
theorem choice_eq_none (α : Type*) [IsEmpty α] : choice α = none
-- Mathlib/Order/Defs.lean
@[trans]
theorem lt_of_lt_of_le : ∀ {a b c : α}, a < b → b ≤ c → a < c
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem card_nthRootsFinset {ζ : R} {n : ℕ} (h : IsPrimitiveRoot ζ n) :
    (nthRootsFinset n R).card = n
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
theorem IsBoundedLinearMap.hasFDerivAtFilter (h : IsBoundedLinearMap 𝕜 f) :
    HasFDerivAtFilter f h.toContinuousLinearMap x L
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem toAffineEquiv_injective : Injective (toAffineEquiv : (P ≃ᵃⁱ[𝕜] P₂) → P ≃ᵃ[𝕜] P₂)
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem piCongrRight_refl : (piCongrRight fun j => refl R (φ j)) = refl _ _
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_C : (C a).eval₂ f x = f a
-- Mathlib/MeasureTheory/PiSystem.lean
theorem subset_generatePiSystem_self {α} (S : Set (Set α)) : S ⊆ generatePiSystem S
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
nonrec theorem ContDiffAt.pow {f : E → 𝔸} (hf : ContDiffAt 𝕜 n f x) (m : ℕ) :
    ContDiffAt 𝕜 n (fun y => f y ^ m) x
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
/-- `coeIdealHom (S : Submonoid R) P` is `(↑) : Ideal R → FractionalIdeal S P` as a ring hom -/
@[simps]
def coeIdealHom : Ideal R →+* FractionalIdeal S P
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem radical_mono (H : I ≤ J) : radical I ≤ radical J
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_updateColumn_smul' (M : Matrix n n R) (j : n) (s : R) (u : n → R) :
    det (updateColumn (s • M) j u) = s ^ (Fintype.card n - 1) * det (updateColumn M j u)
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_plift_down (f : ι → Set α) : ⋃ i, f (PLift.down i) = ⋃ i, f i
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem preimage_emetric_ball (h : α ≃ᵢ β) (x : β) (r : ℝ≥0∞) :
    h ⁻¹' EMetric.ball x r = EMetric.ball (h.symm x) r
-- Mathlib/Order/Sublattice.lean
lemma coe_inj : (L : Set α) = M ↔ L = M
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_congr {f g : α →ₛ E} (hf : Integrable f μ) (h : f =ᵐ[μ] g) :
    f.integral μ = g.integral μ
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem deriv_zero (a : α) : deriv 0 a = 0
-- Mathlib/SetTheory/Cardinal/ToNat.lean
@[simp, norm_cast] theorem toNat_natCast (n : ℕ) : toNat n = n
-- Mathlib/RingTheory/RingInvo.lean
@[norm_cast]
theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f a
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem iteratedFDeriv_neg_apply {i : ℕ} {f : E → F} :
    iteratedFDeriv 𝕜 i (-f) x = -iteratedFDeriv 𝕜 i f x
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_ker (m : M) : m ∈ f.ker ↔ f m = 0
-- Mathlib/Topology/Separation.lean
theorem isOpen_compl_singleton [T1Space X] {x : X} : IsOpen ({x}ᶜ : Set X)
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem mem_domain_of_mem_graph {f : E →ₗ.[R] F} {x : E} {y : F} (h : (x, y) ∈ f.graph) :
    x ∈ f.domain
-- Mathlib/Data/Setoid/Partition.lean
theorem card_classes_ker_le {α β : Type*} [Fintype β] (f : α → β)
    [Fintype (Setoid.ker f).classes] : Fintype.card (Setoid.ker f).classes ≤ Fintype.card β
-- Mathlib/LinearAlgebra/Basis.lean
theorem reindexRange_self (i : ι) (h := Set.mem_range_self i) : b.reindexRange ⟨b i, h⟩ = b i
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_pow_apply_get (l : List α) (h : Nodup l) (n : ℕ) (i : Fin l.length) :
    (formPerm l ^ n) (l.get i) =
      l.get ⟨((i.val + n) % l.length), (Nat.mod_lt _ (i.val.zero_le.trans_lt i.isLt))⟩
-- Mathlib/Algebra/Ring/Commute.lean
theorem neg_left : Commute a b → Commute (-a) b
-- Mathlib/Data/List/InsertNth.lean
theorem get_insertNth_self (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length)
    (hn' : n < (insertNth n x l).length := (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff])) :
    (insertNth n x l).get ⟨n, hn'⟩ = x
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast] lemma coe_zero : ((0 : ℝ≥0) : ℝ) = 0
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp] -- Porting note: removed `norm_cast` attribute
protected theorem coe_coe {F : Type*} [FunLike F α β] [ContinuousMapClass F α β] (f : F) :
    ⇑(f : C(α, β)) = f
-- Mathlib/Algebra/Ring/Int.lean
@[simp] lemma natAbs_even : Even n.natAbs ↔ Even n
-- Mathlib/Analysis/NormedSpace/Extr.lean
/-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c` and `y` is
a vector on the same ray as `f c`, then the function `fun x => ‖f x + y‖` has a local maximum
at `c`. -/
theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRay ℝ (f c) y) :
    IsLocalMax (fun x => ‖f x + y‖) c
-- Mathlib/Topology/Constructions.lean
/-- The second projection in a product of topological spaces sends open sets to open sets. -/
theorem isOpenMap_snd : IsOpenMap (@Prod.snd X Y)
-- Mathlib/Data/List/Intervals.lean
theorem chain'_succ (n m : ℕ) : Chain' (fun a b => b = succ a) (Ico n m)
-- Mathlib/Init/Data/List/Lemmas.lean
theorem not_exists_mem_nil (p : α → Prop) : ¬∃ x ∈ @nil α, p x
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagram_fstFrom (i j : D.J) : D.diagram.fstFrom ⟨i, j⟩ = i
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem units_coeff_zero_smul (c : R[X]ˣ) (p : R[X]) : (c : R[X]).coeff 0 • p = c * p
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem head?_reverse (l : List α) : l.reverse.head? = l.getLast?
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem inl_mul [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r₁ r₂ : R) :
    (inl (r₁ * r₂) : Unitization R A) = inl r₁ * inl r₂
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem iteratedFDerivWithin_const_smul_apply (hf : ContDiffOn 𝕜 i f s) (hu : UniqueDiffOn 𝕜 s)
    (hx : x ∈ s) : iteratedFDerivWithin 𝕜 i (a • f) s x = a • iteratedFDerivWithin 𝕜 i f s x
-- Mathlib/CategoryTheory/Endomorphism.lean
theorem Aut_inv_def (f : Aut X) : f⁻¹ = f.symm
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
@[simp] theorem lcm_one_left (m : Nat) : lcm 1 m = m
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem xor_right_inj : ∀ (x y z : Bool), xor x z = xor y z ↔ x = y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem ite_val {n : Nat} {c : Prop} [Decidable c] {x : c → Fin n} (y : ¬c → Fin n) :
    (if h : c then x h else y h).val = if h : c then (x h).val else (y h).val
-- Mathlib/FieldTheory/PerfectClosure.lean
private theorem mul_aux_left (x1 x2 y : ℕ × K) (H : R K p x1 x2) :
    mk K p (x1.1 + y.1, (frobenius K p)^[y.1] x1.2 * (frobenius K p)^[x1.1] y.2) =
      mk K p (x2.1 + y.1, (frobenius K p)^[y.1] x2.2 * (frobenius K p)^[x2.1] y.2)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- The odd Hurwitz zeta function is differentiable everywhere. -/
lemma differentiable_hurwitzZetaOdd (a : UnitAddCircle) :
    Differentiable ℂ (hurwitzZetaOdd a)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem equalizer_toSubmodule {φ ψ : F} :
    Subalgebra.toSubmodule (equalizer φ ψ) = LinearMap.eqLocus φ ψ
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem aeval_comp_bind₁ [Algebra R S] (f : τ → S) (g : σ → MvPolynomial τ R) :
    (aeval f).comp (bind₁ g) = aeval fun i => aeval f (g i)
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem inl_star [Star R] [AddMonoid A] [StarAddMonoid A] (r : R) :
    inl (star r) = star (inl r : Unitization R A)
-- Mathlib/AlgebraicTopology/DoldKan/EquivalencePseudoabelian.lean
@[simp]
lemma isoN₁_hom_app_f (X : SimplicialObject C) :
    (isoN₁.hom.app X).f = PInfty
-- Mathlib/Topology/Compactness/Lindelof.lean
protected theorem ClosedEmbedding.LindelofSpace [h : LindelofSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : LindelofSpace X
-- Mathlib/Probability/Kernel/Basic.lean
@[simp, norm_cast] lemma coe_nsmul (n : ℕ) (κ : Kernel α β) : ⇑(n • κ) = n • κ
-- Mathlib/FieldTheory/Laurent.lean
@[simp]
theorem laurent_C (x : R) : laurent r (C x) = C x
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem monomial_zero_eq_C_apply (a : R) : monomial R (0 : σ →₀ ℕ) a = C σ R a
-- Mathlib/Analysis/Calculus/Dslope.lean
@[simp]
theorem dslope_same (f : 𝕜 → E) (a : 𝕜) : dslope f a a = deriv f a
-- Mathlib/CategoryTheory/Adjunction/Comma.lean
/-- If each structured arrow category on `G` has an initial object, `G` is a right adjoint. -/
lemma isRightAdjointOfStructuredArrowInitials : G.IsRightAdjoint
-- Mathlib/Order/Heyting/Basic.lean
theorem Disjoint.sup_sdiff_cancel_left (h : Disjoint a b) : (a ⊔ b) \ a = b