ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean
lemma closedEmbedding {X Y : Scheme} (f : X ⟶ Y)
    [IsClosedImmersion f] : ClosedEmbedding f.1.base
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma variableChange_comp (C C' : WeierstrassCurve.VariableChange R) (E : EllipticCurve R) :
    E.variableChange (C.comp C') = (E.variableChange C').variableChange C
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps, norm_cast]
theorem ofReal_ratCast (n : ℚ) : ((n : ℝ) : K) = n
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
theorem smulRightₗ_apply (f : M₂ →ₗ[R] R) (x : M) (c : M₂) :
    (smulRightₗ : (M₂ →ₗ[R] R) →ₗ[R] M →ₗ[R] M₂ →ₗ[R] M) f x c = f c • x
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem isMulTwoCocycle_of_twoCocycles (f : twoCocycles (Rep.ofMulDistribMulAction G M)) :
    IsMulTwoCocycle (M := M) (Additive.toMul ∘ f.1)
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem range_projIic : range (projIic a) = univ
-- Mathlib/AlgebraicGeometry/Restrict.lean
lemma Scheme.Opens.ι_image_basicOpen (r : Γ(U, ⊤)) :
    U.ι ''ᵁ (U.toScheme.basicOpen r) = X.basicOpen r
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem eval_iterate_derivative_rootMultiplicity {p : R[X]} {t : R} :
    (derivative^[p.rootMultiplicity t] p).eval t =
      (p.rootMultiplicity t).factorial • (p /ₘ (X - C t) ^ p.rootMultiplicity t).eval t
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/BinaryProducts.lean
@[simp]
theorem PreservesLimitPair.iso_hom : (PreservesLimitPair.iso G X Y).hom = prodComparison G X Y
-- Mathlib/Order/Filter/Prod.lean
theorem prod_inf {g₁ g₂ : Filter β} : f ×ˢ (g₁ ⊓ g₂) = (f ×ˢ g₁) ⊓ (f ×ˢ g₂)
-- Mathlib/Topology/VectorBundle/Hom.lean
theorem continuousLinearMap_symm_apply' {b : B} (hb : b ∈ e₁.baseSet ∩ e₂.baseSet)
    (L : F₁ →SL[σ] F₂) :
    (continuousLinearMap σ e₁ e₂).symm b L =
      (e₂.symmL 𝕜₂ b).comp (L.comp <| e₁.continuousLinearMapAt 𝕜₁ b)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_lt_add_of_nonempty_ball_inter_closedBall (h : (ball x ε₁ ∩ closedBall y ε₂).Nonempty) :
    dist x y < ε₁ + ε₂
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `norm_nonneg`. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem hammingNorm_nonneg {x : ∀ i, β i} : 0 ≤ hammingNorm x
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableWithinAt.congr_of_eventuallyEq (h : LineDifferentiableWithinAt 𝕜 f s x v)
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) : LineDifferentiableWithinAt 𝕜 f₁ s x v
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addX_of_Z_eq_zero_right {P Q : Fin 3 → R} (hQz : Q z = 0) :
    W'.addX P Q = (-(Q x * P z)) ^ 2 * P x
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Strong.lean
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_naturality {f g : a ⟶ b} (β : f ⟶ g) (h : G.obj b ⟶ a') :
    F.map₂ β ▷ η.app b ▷ h ≫ (η.naturality g).hom ▷ h =
      (η.naturality f).hom ▷ h ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.map₂ β ▷ h ≫ (α_ _ _ _).inv
-- Mathlib/Algebra/Order/Module/Algebra.lean
lemma algebraMap_pos (ha : 0 < a) : 0 < algebraMap α β a
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem SmoothWithinAt.contMDiffWithinAt (h : SmoothWithinAt I I' f s x) :
    ContMDiffWithinAt I I' n f s x
-- Mathlib/Data/Finset/Slice.lean
protected theorem Sized.subsingleton (hA : A.Sized 0) : A.Subsingleton
-- Mathlib/Data/Real/ENatENNReal.lean
@[simp]
theorem map_coe_nnreal : WithTop.map ((↑) : ℕ → ℝ≥0) = ((↑) : ℕ∞ → ℝ≥0∞)
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp]
lemma ι_app (V) : U.ι.app V = X.presheaf.map
    (homOfLE (x := U.ι ''ᵁ U.ι ⁻¹ᵁ V) (Set.image_preimage_subset _ _)).op
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma abs_le_of_sq_le_sq (h : a ^ 2 ≤ b ^ 2) (hb : 0 ≤ b) : |a| ≤ b
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodyLT_mem {x : K} :
    mixedEmbedding K x ∈ (convexBodyLT K f) ↔ ∀ w : InfinitePlace K, w x < f w
-- Mathlib/Data/Finset/Union.lean
@[simp]
lemma disjiUnion_eq_biUnion (s : Finset α) (f : α → Finset β) (hf) :
    s.disjiUnion f hf = s.biUnion f
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem ext' {s : Submodule R E} {f g : s →ₗ[R] F} (h : f = g) : mk s f = mk s g
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_subset_uIcc_iff_le' :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.Bornology.IsCobounded.closedBall_compl_subset {s : Set α} (hs : IsCobounded s)
    (c : α) : ∃ (r : ℝ), (Metric.closedBall c r)ᶜ ⊆ s
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem aeval_zero (p : MvPolynomial σ R) :
    aeval (0 : σ → S₁) p = algebraMap _ _ (constantCoeff p)
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem contDiff_norm_sq : ContDiff ℝ n fun x : E => ‖x‖ ^ 2
-- Mathlib/Data/DFinsupp/NeLocus.lean
@[simp]
theorem neLocus_add_left [∀ a, AddLeftCancelMonoid (N a)] (f g h : Π₀ a, N a) :
    (f + g).neLocus (f + h) = g.neLocus h
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contMDiff_top : Smooth I I' f ↔ ∀ n : ℕ, ContMDiff I I' n f
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLeast.nonempty (h : IsLeast s a) : s.Nonempty
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp, norm_cast]
theorem coe_sup [Sup β] (f g : α →ₛ β) : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g
-- Mathlib/Combinatorics/Schnirelmann.lean
lemma schnirelmannDensity_congr {B : Set ℕ} [DecidablePred (· ∈ B)] (h : A = B) :
    schnirelmannDensity A = schnirelmannDensity B
-- Mathlib/Algebra/MonoidAlgebra/Support.lean
theorem support_mul_single_eq_image [DecidableEq G] [Mul G] (f : MonoidAlgebra k G) {r : k}
    (hr : ∀ y, y * r = 0 ↔ y = 0) {x : G} (rx : IsRightRegular x) :
    (f * single x r).support = Finset.image (· * x) f.support
-- Mathlib/RingTheory/Artinian.lean
/-- In a module over an artinian ring, the submodule generated by finitely many vectors is
artinian. -/
theorem isArtinian_span_of_finite (R) {M} [Ring R] [AddCommGroup M] [Module R M] [IsArtinianRing R]
    {A : Set M} (hA : A.Finite) : IsArtinian R (Submodule.span R A)
-- Mathlib/GroupTheory/Sylow.lean
/-- A generalization of **Sylow's third theorem**.
  If the number of Sylow `p`-subgroups is finite, then it is congruent to `1` modulo `p`. -/
theorem card_sylow_modEq_one [Fact p.Prime] [Finite (Sylow p G)] :
    Nat.card (Sylow p G) ≡ 1 [MOD p]
-- Mathlib/Analysis/Convolution.lean
/-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
given in terms of compositions with an additional continuous map. -/
theorem continuousOn_convolution_right_with_param_comp {s : Set P} {v : P → G}
    (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k)
    (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
    (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem measurable_mk [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    (hf : AEStronglyMeasurable f μ) : Measurable (hf.mk f)
-- Mathlib/Topology/SeparatedMap.lean
theorem isSeparatedMap_iff_isClosedMap {f : X → Y} :
    IsSeparatedMap f ↔ IsClosedMap (toPullbackDiag f)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem insert_diff_eq_singleton {a : α} {s : Set α} (h : a ∉ s) : insert a s \ s = {a}
-- Mathlib/CategoryTheory/Sites/Discrete.lean
lemma isDiscrete_iff_mem_essImage (F : Sheaf J A) :
    F.IsDiscrete J ht ↔ F ∈ (constantSheaf J A).essImage
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem join_append (S T : WSeq (WSeq α)) : join (append S T) ~ʷ append (join S) (join T)
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iInf_apply {α : Type*} {β : α → Type*} {ι : Sort*} [∀ i, InfSet (β i)] {f : ι → ∀ a, β a}
    {a : α} : (⨅ i, f i) a = ⨅ i, f i a
-- Mathlib/Topology/Basic.lean
/-- If a continuous map `f` maps `s` to a closed set `t`, then it maps `closure s` to `t`. -/
theorem Set.MapsTo.closure_left {t : Set Y} (h : MapsTo f s t)
    (hc : Continuous f) (ht : IsClosed t) : MapsTo f (closure s) t
-- Mathlib/ModelTheory/LanguageMap.lean
@[simp]
theorem sumMap_comp_inl : ϕ.sumMap ψ ∘ᴸ LHom.sumInl = LHom.sumInl ∘ᴸ ϕ
-- Mathlib/Computability/Encoding.lean
theorem Encoding.card_le_card_list {α : Type u} (e : Encoding.{u, v} α) :
    Cardinal.lift.{v} #α ≤ Cardinal.lift.{u} #(List e.Γ)
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[reassoc (attr := simp 1100)]
theorem wideCoequalizer.π_desc [Nonempty J] {W : C} (k : Y ⟶ W)
    (h : ∀ j₁ j₂, f j₁ ≫ k = f j₂ ≫ k) :
    wideCoequalizer.π f ≫ wideCoequalizer.desc k h = k
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.inter (hs : StarConvex 𝕜 x s) (ht : StarConvex 𝕜 x t) : StarConvex 𝕜 x (s ∩ t)
-- Mathlib/Computability/TuringMachine.lean
theorem Reaches₀.single {σ} {f : σ → Option σ} {a b : σ} (h : b ∈ f a) : Reaches₀ f a b
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_biUnion [DecidableEq β] {s : Finset γ} (Hs : s.Nonempty) {t : γ → Finset β}
    (Ht : ∀ b, (t b).Nonempty) :
    (s.biUnion t).sup' (Hs.biUnion fun b _ => Ht b) f = s.sup' Hs (fun b => (t b).sup' (Ht b) f)
-- Mathlib/NumberTheory/LSeries/Basic.lean
/-- If `f` is bounded, then its `LSeries` is summable at `s` when `re s > 1`. -/
theorem LSeriesSummable_of_bounded_of_one_lt_re {f : ℕ → ℂ} {m : ℝ}
    (h : ∀ n ≠ 0, Complex.abs (f n) ≤ m) {s : ℂ} (hs : 1 < s.re) :
    LSeriesSummable f s
-- Mathlib/Analysis/Convex/Intrinsic.lean
theorem intrinsicFrontier_subset_intrinsicClosure : intrinsicFrontier 𝕜 s ⊆ intrinsicClosure 𝕜 s
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_eq_singleton' {f : α →₀ M} {a : α} :
    f.support = {a} ↔ ∃ b ≠ 0, f = single a b
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem arsinh_strictMono : StrictMono arsinh
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_eq_zero_iff_le : n - m = 0 ↔ n ≤ m
-- Mathlib/CategoryTheory/Sites/Sieves.lean
/-- If an arrow set contains a split epi, it generates the maximal sieve. -/
theorem generate_of_contains_isSplitEpi {R : Presieve X} (f : Y ⟶ X) [IsSplitEpi f] (hf : R f) :
    generate R = ⊤
-- Mathlib/Topology/Instances/Matrix.lean
theorem HasSum.matrix_blockDiag' {f : X → Matrix (Σi, m' i) (Σi, n' i) R}
    {a : Matrix (Σi, m' i) (Σi, n' i) R} (hf : HasSum f a) :
    HasSum (fun x => blockDiag' (f x)) (blockDiag' a)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem curry_injective : Function.Injective (curry : (M ⊗[R] N →ₗ[R] P) → M →ₗ[R] N →ₗ[R] P)
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem expand_eq_comp_X_pow {f : R[X]} : expand R p f = f.comp (X ^ p)
-- Mathlib/Topology/ContinuousOn.lean
theorem mem_nhdsWithin_subtype {s : Set α} {a : { x // x ∈ s }} {t u : Set { x // x ∈ s }} :
    t ∈ 𝓝[u] a ↔ t ∈ comap ((↑) : s → α) (𝓝[(↑) '' u] a)
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem toDual_top [Top α] : toDual (⊤ : α) = ⊥
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- Composing the zero multilinear map with a linear map in each argument. -/
@[simp]
theorem zero_compLinearMap (f : ∀ i, M₁ i →ₗ[R] M₁' i) :
    (0 : MultilinearMap R M₁' M₂).compLinearMap f = 0
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
lemma moduleCat_exact_iff_ker_sub_range :
    S.Exact ↔ LinearMap.ker S.g ≤ LinearMap.range S.f
-- Mathlib/Data/Set/Countable.lean
@[nontriviality]
theorem Countable.of_subsingleton [Subsingleton α] (s : Set α) : s.Countable
-- Mathlib/Algebra/Order/Interval/Finset.lean
@[simp] lemma map_add_right_Ico (a b c : α) :
    (Ico a b).map (addRightEmbedding c) = Ico (a + c) (b + c)
-- Mathlib/Algebra/Ring/Prod.lean
@[simp]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[ext]
theorem ext {f g : P →ᵃⁱ[𝕜] P₂} (h : ∀ x, f x = g x) : f = g
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
@[simp]
theorem withDensity_apply (f : α → ℝ≥0∞) {s : Set α} (hs : MeasurableSet s) :
    μ.withDensity f s = ∫⁻ a in s, f a ∂μ
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem exp_eq_exp_iff_exp_sub_eq_one {x y : ℂ} : exp x = exp y ↔ exp (x - y) = 1
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_X (n) : (X n).eval₂ f g = g n
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_eq_iff : toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z : ℤ, b = c + z • p
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem get?_tail (s : Seq α) (n) : get? (tail s) n = get? s (n + 1)
-- Mathlib/Order/Filter/Basic.lean
theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
    (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isInt_pow {α} [Ring α] : ∀ {f : α → ℕ → α} {a : α} {b : ℕ} {a' : ℤ} {b' : ℕ} {c : ℤ},
    f = HPow.hPow → IsInt a a' → IsNat b b' → Int.pow a' b' = c → IsInt (f a b) c
-- Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean
theorem GammaSeq_add_one_left (s : ℂ) {n : ℕ} (hn : n ≠ 0) :
    GammaSeq (s + 1) n / s = n / (n + 1 + s) * GammaSeq s n
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem preimage_setOf_dist (hf : Isometry f) (x : α) (p : ℝ → Prop) :
    f ⁻¹' { y | p (dist y (f x)) } = { y | p (dist y x) }
-- Mathlib/Algebra/Order/Group/Lattice.lean
@[to_additive]
lemma div_sup (a b c : α) : c / (a ⊔ b) = c / a ⊓ c / b
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurableSet_not_mem (a : α) : MeasurableSet {s : Set α | a ∉ s}
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem apply_dualBasis_right (B : BilinForm K V) (hB : B.Nondegenerate) (sym : B.IsSymm)
    (b : Basis ι K V) (i j) : B (b i) (B.dualBasis hB b j) = if i = j then 1 else 0
-- Mathlib/Data/Real/EReal.lean
/-- For any extended real number `x`, the sum of `⊤` and `x` is equal to `⊤`
if and only if `x` is not `⊥`. -/
theorem top_add_iff_ne_bot {x : EReal} : ⊤ + x = ⊤ ↔ x ≠ ⊥
-- Mathlib/Analysis/Convex/Combination.lean
theorem Finset.centerMass_filter_ne_zero :
    (t.filter fun i => w i ≠ 0).centerMass w z = t.centerMass w z
-- Mathlib/FieldTheory/SeparableDegree.lean
theorem natSepDegree_map : (f.map (algebraMap F E)).natSepDegree = f.natSepDegree
-- Mathlib/Order/Hom/Lattice.lean
theorem coe_comp_sup_hom (f : BoundedLatticeHom β γ) (g : BoundedLatticeHom α β) :
    (f.comp g : SupHom α γ) = (f : SupHom β γ).comp g
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem eq_zero : ∀ {x y : M}, B x y = 0 → B y x = 0
-- Mathlib/Data/Nat/Dist.lean
theorem dist_eq_max_sub_min {i j : ℕ} : dist i j = (max i j) - min i j
-- Mathlib/Order/Height.lean
theorem le_chainHeight_TFAE (n : ℕ) :
    TFAE [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, length l = n, ∃ l ∈ s.subchain, n ≤ length l]
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem exists_right_inverse_iff_isUnit : (∃ B, A * B = 1) ↔ IsUnit A
-- Mathlib/GroupTheory/HNNExtension.lean
theorem group_smul_def (g : G) (w : NormalWord d) :
    g • w = { w with head := g * w.head }
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
protected theorem le_total (a b : ℤ√d) : a ≤ b ∨ b ≤ a
-- Mathlib/Analysis/Complex/TaylorSeries.lean
/-- A function that is complex differentiable on the complex plane is given by evaluating
its Taylor series at any point `c`. -/
lemma hasSum_taylorSeries_of_entire :
    HasSum (fun n : ℕ ↦ (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c) (f z)
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem comapDomain_single (f : α → β) (a : α) (m : M)
    (hif : Set.InjOn f (f ⁻¹' (single (f a) m).support)) :
    comapDomain f (Finsupp.single (f a) m) hif = Finsupp.single a m
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem min_eq_top [OrderTop α] {a b : α} : min a b = ⊤ ↔ a = ⊤ ∧ b = ⊤
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem neg_divInt (n d) : -(n /. d) = -n /. d
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_nonpos_iff (hx : 0 < x) : logb b x ≤ 0 ↔ x ≤ 1
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem comp {g : G → E} {t : Set G} (hf : DiffContOnCl 𝕜 f s) (hg : DiffContOnCl 𝕜 g t)
    (h : MapsTo g t s) : DiffContOnCl 𝕜 (f ∘ g) t
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- If every coefficient of a polynomial is in an ideal `I`, then so is the polynomial itself -/
theorem polynomial_mem_ideal_of_coeff_mem_ideal (I : Ideal R[X]) (p : R[X])
    (hp : ∀ n : ℕ, p.coeff n ∈ I.comap (C : R →+* R[X])) : p ∈ I
-- Mathlib/Probability/Kernel/Basic.lean
@[simp]
theorem integral_deterministic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g)
    [MeasurableSingletonClass β] : ∫ x, f x ∂deterministic g hg a = f (g a)
-- Mathlib/Computability/Ackermann.lean
/-- If `f` is primitive recursive, there exists `m` such that `f n < ack m n` for all `n`. -/
theorem exists_lt_ack_of_nat_primrec {f : ℕ → ℕ} (hf : Nat.Primrec f) :
    ∃ m, ∀ n, f n < ack m n
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem aemeasurable_coeFn [MeasurableSpace β] [BorelSpace β] (f : α →₁[μ] β) : AEMeasurable f μ
-- Mathlib/SetTheory/ZFC/Ordinal.lean
theorem isTransitive_iff_mem_trans : z.IsTransitive ↔ ∀ {x y : ZFSet}, x ∈ y → y ∈ z → x ∈ z
-- Mathlib/Order/InitialSeg.lean
theorem init (f : r ≼i s) {a : α} {b : β} : s b (f a) → ∃ a', f a' = b
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[simp]
lemma smul_iso_hom (a : Units ℤ) (e : X ≅ Y) : (a • e).hom = a • e.hom
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_non_aEStronglyMeasurable (hT : DominatedFinMeasAdditive μ T C)
    (hf : ¬AEStronglyMeasurable f μ) : setToFun μ T hT f = 0
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffOn.continuousOn_fderiv_of_isOpen (h : ContDiffOn 𝕜 n f s) (hs : IsOpen s)
    (hn : 1 ≤ n) : ContinuousOn (fun x => fderiv 𝕜 f x) s
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- Rewrite in terms of the `factorThruImage` interface. -/
@[simp]
theorem as_factorThruImage : (Image.monoFactorisation f).e = factorThruImage f
-- Mathlib/Data/List/Rotate.lean
theorem rotate'_rotate' : ∀ (l : List α) (n m : ℕ), (l.rotate' n).rotate' m = l.rotate' (n + m)
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_pos (n : ℕ) (s : S) (h : 0 < s) : 0 < (ascPochhammer S n).eval s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem dvd_iff_dvd_of_dvd_add {a b c : Int} (H : a ∣ b + c) : a ∣ b ↔ a ∣ c
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
protected theorem differentiable : Differentiable 𝕜 f
-- Mathlib/RingTheory/Localization/Away/Basic.lean
theorem exists_reduced_fraction' {b : B} (hb : b ≠ 0) (hx : Irreducible x) :
    ∃ (a : R) (n : ℤ), ¬x ∣ a ∧ selfZPow x B n * algebraMap R B a = b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.of_pow {n : ℕ} {f : α → 𝕜} {g : α → R} (h : IsBigOWith c l (f ^ n) (g ^ n))
    (hn : n ≠ 0) (hc : c ≤ c' ^ n) (hc' : 0 ≤ c') : IsBigOWith c' l f g
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- If there is a primitive `n`-th root of unity in `K`, then
`cyclotomic n K = ∏ μ ∈ primitiveRoots n K, (X - C μ)`. ∈ particular,
`cyclotomic n K = cyclotomic' n K` -/
theorem cyclotomic_eq_prod_X_sub_primitiveRoots {K : Type*} [CommRing K] [IsDomain K] {ζ : K}
    {n : ℕ} (hz : IsPrimitiveRoot ζ n) : cyclotomic n K = ∏ μ ∈ primitiveRoots n K, (X - C μ)
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.dvd_of_dvd_mul_right (H1 : IsRelPrime x z) (H2 : x ∣ y * z) : x ∣ y
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem eq_top_iff' {p : Submodule R M} : p = ⊤ ↔ ∀ x, x ∈ p
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- A subsemiring contains the semiring's 0. -/
protected theorem zero_mem : (0 : R) ∈ s
-- Mathlib/Algebra/Group/Action/Units.lean
@[simp]
lemma smul_isUnit [Monoid M] [SMul M α] {m : M} (hm : IsUnit m) (a : α) : hm.unit • a = m • a
-- .lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean
@[simp] protected theorem Fin.sizeOf (a : Fin n) : sizeOf a = a.val + 1
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
@[deprecated getElem_drop' (since := "2024-06-12")]
theorem get_drop' (L : List α) {i j} :
    get (L.drop i) j = get L ⟨i + j, by
      rw [Nat.add_comm]
      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩
-- Mathlib/Order/MinMax.lean
theorem Monotone.map_min (hf : Monotone f) : f (min a b) = min (f a) (f b)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem map_apply_div_ne_zero {R F : Type*} [CommRing R] [IsDomain R]
    [FunLike F K[X] R[X]] [MonoidHomClass F K[X] R[X]]
    (φ : F) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) (p q : K[X]) (hq : q ≠ 0) :
    map φ hφ (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap _ _ (φ p) / algebraMap _ _ (φ q)
-- Mathlib/Data/Int/Defs.lean
@[simp, norm_cast] lemma natAbs_cast (n : ℕ) : natAbs ↑n = n
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProdFun_iUnion (κ : Kernel α β) (η : Kernel (α × β) γ) [IsSFiniteKernel η] (a : α)
    (f : ℕ → Set (β × γ)) (hf_meas : ∀ i, MeasurableSet (f i))
    (hf_disj : Pairwise (Disjoint on f)) :
    compProdFun κ η a (⋃ i, f i) = ∑' i, compProdFun κ η a (f i)
-- Mathlib/Probability/ConditionalProbability.lean
/-- A version of the law of total probability. -/
theorem cond_add_cond_compl_eq [IsFiniteMeasure μ] (hms : MeasurableSet s) :
    μ[t|s] * μ s + μ[t|sᶜ] * μ sᶜ = μ t
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- If `𝕜₁` is a normed field contained as subfield of a larger normed field `𝕜₂`, and if `a : A`
is an element whose `𝕜₂` spectrum restricts to `𝕜₁`, then the spectral radii over each scalar
field coincide. -/
lemma spectralRadius_eq {𝕜₁ 𝕜₂ A : Type*} [NormedField 𝕜₁] [NormedField 𝕜₂]
    [NormedRing A] [NormedAlgebra 𝕜₁ A] [NormedAlgebra 𝕜₂ A] [NormedAlgebra 𝕜₁ 𝕜₂]
    [IsScalarTower 𝕜₁ 𝕜₂ A] {f : 𝕜₂ → 𝕜₁} {a : A} (h : SpectrumRestricts a f) :
    spectralRadius 𝕜₁ a = spectralRadius 𝕜₂ a
-- Mathlib/Algebra/Algebra/Rat.lean
@[simp]
theorem map_rat_algebraMap [Semiring R] [Semiring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S)
    (r : ℚ) : f (algebraMap ℚ R r) = algebraMap ℚ S r
-- Mathlib/Geometry/RingedSpace/Basic.lean
@[simp]
theorem basicOpen_mul {U : Opens X} (f g : X.presheaf.obj (op U)) :
    X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g
-- Mathlib/Data/Multiset/Basic.lean
theorem card_add (s t : Multiset α) : card (s + t) = card s + card t
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factors_self [Nontrivial α] {p : Associates α} (hp : Irreducible p) :
    p.factors = WithTop.some {⟨p, hp⟩}
-- Mathlib/Data/Fin/VecNotation.lean
theorem range_cons_empty (x : α) (u : Fin 0 → α) : Set.range (Matrix.vecCons x u) = {x}
-- Mathlib/Probability/Kernel/MeasureCompProd.lean
lemma ae_compProd_iff [SFinite μ] [IsSFiniteKernel κ] {p : α × β → Prop}
    (hp : MeasurableSet {x | p x}) :
    (∀ᵐ x ∂(μ ⊗ₘ κ), p x) ↔ ∀ᵐ a ∂μ, ∀ᵐ b ∂(κ a), p (a, b)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem exists_rat_pow_btwn_rat (hn : n ≠ 0) {x y : ℚ} (h : x < y) (hy : 0 < y) :
    ∃ q : ℚ, 0 < q ∧ x < q ^ n ∧ q ^ n < y
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem mul_adjugate (A : Matrix n n α) : A * adjugate A = A.det • (1 : Matrix n n α)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean
lemma CstarRing.norm_or_neg_norm_mem_spectrum [Nontrivial A] {a : A}
    (ha : IsSelfAdjoint a := by cfc_tac) : ‖a‖ ∈ spectrum ℝ a ∨ -‖a‖ ∈ spectrum ℝ a
-- Mathlib/Computability/TMToPartrec.lean
theorem ret_supports {S k} (H₁ : contSupp k ⊆ S) : TM2.SupportsStmt S (tr (Λ'.ret k))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sqrtTwoAddSeries_two : sqrtTwoAddSeries 0 2 = √(2 + √2)
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] lemma FGModuleCatDual_coe : (FGModuleCatDual K V : Type u) = Module.Dual K V
-- Mathlib/LinearAlgebra/Determinant.lean
theorem Basis.det_map' (b : Basis ι R M) (f : M ≃ₗ[R] M') :
    (b.map f).det = b.det.compLinearMap f.symm