ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Localization/Adjunction.lean
@[simp]
lemma localization_counit_app (X₂ : C₂) :
    (adj.localization L₁ W₁ L₂ W₂ G' F').counit.app (L₂.obj X₂) =
    G'.map ((CatCommSq.iso F L₂ L₁ F').inv.app X₂) ≫
      (CatCommSq.iso G L₁ L₂ G').inv.app (F.obj X₂) ≫
      L₂.map (adj.counit.app X₂)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem lt_rootMultiplicity_of_isRoot_iterate_derivative
    [CharZero R] {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hroot : ∀ m ≤ n, (derivative^[m] p).IsRoot t) :
    n < p.rootMultiplicity t
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ⟪a, y⟫ + ω a x * ω a y = ‖a‖ ^ 2 * ⟪x, y⟫`. (See
`Orientation.inner_mul_inner_add_areaForm_mul_areaForm` for the "applied" form.)-/
theorem inner_mul_inner_add_areaForm_mul_areaForm' (a x : E) :
    ⟪a, x⟫ • innerₛₗ ℝ a + ω a x • ω a = ‖a‖ ^ 2 • innerₛₗ ℝ x
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is continuous on `ℝ`, and `f''` is strictly negative on `ℝ`,
then `f` is strictly concave on `ℝ`.
Note that we don't require twice differentiability explicitly as it is already implied by the second
derivative being strictly negative, except at at most one point. -/
theorem strictConcaveOn_univ_of_deriv2_neg {f : ℝ → ℝ} (hf : Continuous f)
    (hf'' : ∀ x, deriv^[2] f x < 0) : StrictConcaveOn ℝ univ f
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
private theorem le_sInf' {S : Set (Submodule R M)} {p} : (∀ q ∈ S, p ≤ q) → p ≤ sInf S
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_intCast_le (n : ℤ) : degree (n : R[X]) ≤ 0
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
theorem dvd_lcm {s : Multiset α} {a : α} (h : a ∈ s) : a ∣ s.lcm
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma sdiff_singleton (s : UpperSet α) (a : α) : s.sdiff {a} = s.erase a
-- Mathlib/Algebra/Homology/Homotopy.lean
/-- Compatibility of `nullHomotopicMap'` with the postcomposition by a morphism
of complexes. -/
theorem nullHomotopicMap'_comp (hom : ∀ i j, c.Rel j i → (C.X i ⟶ D.X j)) (g : D ⟶ E) :
    nullHomotopicMap' hom ≫ g = nullHomotopicMap' fun i j hij => hom i j hij ≫ g.f j
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem aestronglyMeasurable_coeFn (f : α →₁[μ] β) : AEStronglyMeasurable f μ
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- A Borel-measurable set in a Polish space is analytic. -/
theorem _root_.MeasurableSet.analyticSet {α : Type*} [t : TopologicalSpace α] [PolishSpace α]
    [MeasurableSpace α] [BorelSpace α] {s : Set α} (hs : MeasurableSet s) : AnalyticSet s
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
/-- Two bilinear forms are equal when they are equal on all basis vectors. -/
theorem ext_basis (h : ∀ i j, B (b i) (b j) = F₂ (b i) (b j)) : B = F₂
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem iterate_pred_toZ (i : ι) (hi : i < i0) : pred^[(-toZ i0 i).toNat] i0 = i
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
theorem div_self_mul_self' (a : G₀) : a / (a * a) = a⁻¹
-- Mathlib/Logic/Embedding/Set.lean
/-- Given an embedding `f : α ↪ β` and a point outside of `Set.range f`, construct an embedding
`Option α ↪ β`. -/
@[simps]
def optionElim {α β} (f : α ↪ β) (x : β) (h : x ∉ Set.range f) : Option α ↪ β
-- Mathlib/MeasureTheory/Integral/MeanInequalities.lean
theorem ae_eq_zero_of_lintegral_rpow_eq_zero {p : ℝ} (hp0 : 0 ≤ p) {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_zero : ∫⁻ a, f a ^ p ∂μ = 0) : f =ᵐ[μ] 0
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem tendsto_iff_tendstoUniformlyOn {ι : Type*} {p : Filter ι} [UniformSpace F]
    [UniformAddGroup F] (𝔖 : Set (Set E)) {a : ι → UniformConvergenceCLM σ F 𝔖}
    {a₀ : UniformConvergenceCLM σ F 𝔖} :
    Filter.Tendsto a p (𝓝 a₀) ↔ ∀ s ∈ 𝔖, TendstoUniformlyOn (a · ·) a₀ p s
-- Mathlib/Computability/Language.lean
@[simp]
theorem one_add_self_mul_kstar_eq_kstar (l : Language α) : 1 + l * l∗ = l∗
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc, simp]
theorem associator_conjugation {X X' Y Y' Z Z' : C} (f : X ⟶ X') (g : Y ⟶ Y') (h : Z ⟶ Z') :
    (f ⊗ g) ⊗ h = (α_ X Y Z).hom ≫ (f ⊗ g ⊗ h) ≫ (α_ X' Y' Z').inv
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
@[aesop safe apply]
lemma differentiableAt_one_add_smoothingFn {x : ℝ} (hx : 1 < x) :
    DifferentiableAt ℝ (fun z => 1 + ε z) x
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem untrop_inv [Neg R] (x : Tropical R) : untrop x⁻¹ = -untrop x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_pi_div_two_sub (x : ℝ) : sin (π / 2 - x) = cos x
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
lemma map_comp_mul_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g h : ι → G) :
    f ∘ (g * h⁻¹) = f ∘ g * (f ∘ h)⁻¹
-- Mathlib/Algebra/Star/Pointwise.lean
protected theorem star_inv [Group α] [StarMul α] (s : Set α) : s⁻¹⋆ = s⋆⁻¹
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem ofFunction_caratheodory {m : Set α → ℝ≥0∞} {s : Set α} {h₀ : m ∅ = 0}
    (hs : ∀ t, m (t ∩ s) + m (t \ s) ≤ m t) :
    MeasurableSet[(OuterMeasure.ofFunction m h₀).caratheodory] s
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma setLIntegral_stieltjesOfMeasurableRat_rat [IsFiniteKernel κ] (hf : IsRatCondKernelCDF f κ ν)
    (a : α) (q : ℚ) {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ b in s, ENNReal.ofReal (stieltjesOfMeasurableRat f hf.measurable (a, b) q) ∂(ν a)
      = κ a (s ×ˢ Iic (q : ℝ))
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDerivWithin_univ {n : ℕ} :
    iteratedFDerivWithin 𝕜 n f univ = iteratedFDeriv 𝕜 n f
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
theorem toTrivSqZeroExt_comp_map [Module Rᵐᵒᵖ M] [IsCentralScalar R M] [Module Rᵐᵒᵖ N]
    [IsCentralScalar R N] (f : M →ₗ[R] N) :
    toTrivSqZeroExt.comp (map f) = (TrivSqZeroExt.map f).comp toTrivSqZeroExt
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem continuousAt_const_rpow' {a b : ℝ} (h : b ≠ 0) : ContinuousAt (a ^ ·) b
-- Mathlib/CategoryTheory/Monoidal/FunctorCategory.lean
@[simp]
theorem associator_hom_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).hom : (F ⊗ G) ⊗ H ⟶ F ⊗ G ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).hom
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem coe_erase [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s) :
    (s.erase a h : Multiset α) = Multiset.erase s a
-- Mathlib/Data/Fin/Basic.lean
theorem liftFun_iff_succ {α : Type*} (r : α → α → Prop) [IsTrans α r] {f : Fin (n + 1) → α} :
    ((· < ·) ⇒ r) f f ↔ ∀ i : Fin n, r (f (castSucc i)) (f i.succ)
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem equivCongrLeft_symm (f : α ≃ β) :
    (@equivCongrLeft _ _ M _ f).symm = equivCongrLeft f.symm
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
theorem toEven_ι (m : M) : (toEven Q (ι Q m) : CliffordAlgebra (Q' Q)) = e0 Q * v Q m
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_Φ (n : ℤ) : (W.map f).Φ n = (W.Φ n).map f
-- Mathlib/CategoryTheory/Adjunction/Comma.lean
theorem isLeftAdjoint_iff_hasTerminal_costructuredArrow {F : C ⥤ D} :
    F.IsLeftAdjoint ↔ ∀ A, HasTerminal (CostructuredArrow F A)
-- Mathlib/Algebra/Order/Floor.lean
theorem fract_neg {x : α} (hx : fract x ≠ 0) : fract (-x) = 1 - fract x
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
/-- Directional derivative agrees with `HasFDeriv`. -/
theorem HasFDerivAt.lim (hf : HasFDerivAt f f' x) (v : E) {α : Type*} {c : α → 𝕜} {l : Filter α}
    (hc : Tendsto (fun n => ‖c n‖) l atTop) :
    Tendsto (fun n => c n • (f (x + (c n)⁻¹ • v) - f x)) l (𝓝 (f' v))
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem not_summable_of_ratio_test_tendsto_gt_one {α : Type*} [SeminormedAddCommGroup α]
    {f : ℕ → α} {l : ℝ} (hl : 1 < l) (h : Tendsto (fun n ↦ ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)) :
    ¬Summable f
-- Mathlib/Order/Interval/Finset/Fin.lean
@[simp, norm_cast]
theorem coe_max : ↑(max a b) = (max a b : ℕ)
-- Mathlib/Order/LiminfLimsup.lean
/-- Same as limsup_const applied to `⊤` but without the `NeBot f` assumption -/
@[simp]
theorem liminf_const_top {f : Filter β} : liminf (fun _ : β => (⊤ : α)) f = (⊤ : α)
-- Mathlib/Topology/Order/LeftRightNhds.lean
/-- If `S` is order-connected and contains two points `x < y`, then `S` is a right neighbourhood
of `x`. -/
lemma mem_nhdsWithin_Ici [NoMaxOrder α] {S : Set α} (hS : OrdConnected S)
    {x y : α} (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y) :
    S ∈ 𝓝[≥] x
-- Mathlib/GroupTheory/CoprodI.lean
theorem mem_smul_iff {i j : ι} {m₁ : M i} {m₂ : M j} {w : Word M} :
    ⟨_, m₁⟩ ∈ (of m₂ • w).toList ↔
      (¬i = j ∧ ⟨i, m₁⟩ ∈ w.toList)
      ∨ (m₁ ≠ 1 ∧ ∃ (hij : i = j),(⟨i, m₁⟩ ∈ w.toList.tail) ∨
        (∃ m', ⟨j, m'⟩ ∈ w.toList.head? ∧ m₁ = hij ▸ (m₂ * m')) ∨
        (w.fstIdx ≠ some j ∧ m₁ = hij ▸ m₂))
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
/-- The function `(f, x) ↦ update f a x : (Π a, π a) × π a → Π a, π a` is measurable. -/
theorem measurable_update'  {a : δ} [DecidableEq δ] :
    Measurable (fun p : (∀ i, π i) × π a ↦ update p.1 a p.2)
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
theorem apply_eq_iff_eq (e : P₁ ≃ᵃL[k] P₂) {p₁ p₂ : P₁} : e p₁ = e p₂ ↔ p₁ = p₂
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contMDiffOn_top : SmoothOn I I' f s ↔ ∀ n : ℕ, ContMDiffOn I I' n f s
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
theorem IsDiag.add [AddZeroClass α] {A B : Matrix n n α} (ha : A.IsDiag) (hb : B.IsDiag) :
    (A + B).IsDiag
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem const_min (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => min a (f x)
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem preimage_const_of_not_mem {b : β} {s : Set β} (h : b ∉ s) : (fun _ : α => b) ⁻¹' s = ∅
-- Mathlib/Probability/StrongLaw.lean
theorem truncation_eq_self {f : α → ℝ} {A : ℝ} {x : α} (h : |f x| < A) :
    truncation f A x = f x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem sum_C {A : Type*} [AddCommMonoid A] {b : (σ →₀ ℕ) → R → A} (w : b 0 0 = 0) :
    sum (C a) b = b 0 a
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem closure_iUnion {ι} (s : ι → Set R) : closure (⋃ i, s i) = ⨆ i, closure (s i)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.ext_iff {x y : UInt8} : x = y ↔ x.toNat = y.toNat
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMin.inf (hf : IsLocalMin f a) (hg : IsLocalMin g a) :
    IsLocalMin (fun x => f x ⊓ g x) a
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma zero_floorDiv (a : α) : (0 : β) ⌊/⌋ a = 0
-- Mathlib/Data/List/Nodup.lean
@[deprecated nodup_iff_injective_get (since := "2023-01-10")]
theorem nodup_iff_nthLe_inj {l : List α} :
    Nodup l ↔ ∀ i j h₁ h₂, nthLe l i h₁ = nthLe l j h₂ → i = j
-- Mathlib/Data/Finset/Option.lean
lemma forall_mem_eraseNone {s : Finset (Option α)} {p : Option α → Prop} :
    (∀ a ∈ eraseNone s, p a) ↔ ∀ a : α, (a : Option α) ∈ s → p a
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem coe_mul [MulZeroClass β] [ContinuousMul β] (f g : C_c(α, β)) : ⇑(f * g) = f * g
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
@[simp]
theorem dist_eq_zero_iff_eq_or_not_reachable :
    G.dist u v = 0 ↔ u = v ∨ ¬G.Reachable u v
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_int_add (x : α) (y : ℤ) : round ((y : α) + x) = y + round x
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[elab_as_elim]
protected theorem ind {β : G.ConnectedComponent → Prop}
    (h : ∀ v : V, β (G.connectedComponentMk v)) (c : G.ConnectedComponent) : β c
-- Mathlib/Order/WellFoundedSet.lean
protected theorem Subsingleton.wellFoundedOn (hs : s.Subsingleton) : s.WellFoundedOn r
-- Mathlib/Data/Bool/Basic.lean
theorem true_eq_false_eq_False : ¬true = false
-- Mathlib/Data/NNReal/Basic.lean
theorem ne_iff {x y : ℝ≥0} : (x : ℝ) ≠ (y : ℝ) ↔ x ≠ y
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[simp, fun_prop]
theorem DifferentiableAt.inv' (hf : DifferentiableAt 𝕜 h z) (hz : h z ≠ 0) :
    DifferentiableAt 𝕜 (fun x => (h x)⁻¹) z
-- Mathlib/Algebra/Opposites.lean
@[simp] lemma op_eq_one_iff [One α] {a : α} : op a = 1 ↔ a = 1
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Ico_left (b : α) : ⋃ a, Ico a b = Iio b
-- Mathlib/Data/Nat/ModEq.lean
lemma of_dvd (d : m ∣ n) (h : a ≡ b [MOD n]) : a ≡ b [MOD m]
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
lemma extendDomain_pow (n : ℕ) : (e ^ n).extendDomain f = e.extendDomain f ^ n
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Reflection is involutive. -/
@[simp]
theorem reflection_trans_reflection :
    (reflection K).trans (reflection K) = LinearIsometryEquiv.refl 𝕜 E
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem reducible_not_mem_factorSet {p : Associates α} (hp : ¬Irreducible p) (s : FactorSet α) :
    ¬p ∈ s
-- Mathlib/LinearAlgebra/Dual.lean
theorem exists_dual_map_eq_bot_of_nmem {x : M} (hx : x ∉ p) (hp' : Free R (M ⧸ p)) :
    ∃ f : Dual R M, f x ≠ 0 ∧ p.map f = ⊥
-- Mathlib/Data/DFinsupp/NeLocus.lean
@[simp]
theorem neLocus_self_sub_right : neLocus f (f - g) = g.support
-- Mathlib/Data/Finset/Interval.lean
/-- A function `f` from `Finset α` is monotone if and only if `f s ≤ f (insert a s)` for all `s` and
`a ∉ s`. -/
lemma monotone_iff_forall_le_insert : Monotone f ↔ ∀ s ⦃a⦄, a ∉ s → f s ≤ f (insert a s)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
Definition of bitvector addition as a nat.
-/
@[simp, bv_toNat] theorem toNat_add (x y : BitVec w) : (x + y).toNat = (x.toNat + y.toNat) % 2^w
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
lemma eval₂ (hφ : φ.IsHomogeneous m) (f : R →+* MvPolynomial τ S) (g : σ → MvPolynomial τ S)
    (hf : ∀ r, (f r).IsHomogeneous 0) (hg : ∀ i, (g i).IsHomogeneous n) :
    (eval₂ f g φ).IsHomogeneous (n * m)
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_eq' [TopologicalSpace ι] [OrderTopology ι]
    [FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = i}
-- Mathlib/Algebra/Order/Field/Unbundled/Basic.lean
lemma zpow_pos_of_pos [PosMulStrictMono α] (ha : 0 < a) : ∀ n : ℤ, 0 < a ^ n
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem norm_eq_zero_iff' {x : E K} (hx : x ∈ Set.range (mixedEmbedding K)) :
    mixedEmbedding.norm x = 0 ↔ x = 0
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
lemma IsStableUnderProductsOfShape.mk (J : Type*)
    [W.RespectsIso] [HasProductsOfShape J C]
    (hW : ∀ (X₁ X₂ : J → C) (f : ∀ j, X₁ j ⟶ X₂ j) (_ : ∀ (j : J), W (f j)),
      W (Pi.map f)) : W.IsStableUnderProductsOfShape J
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The span of two points that lie in an affine subspace is contained in that subspace. -/
theorem affineSpan_pair_le_of_mem_of_mem {p₁ p₂ : P} {s : AffineSubspace k P} (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) : line[k, p₁, p₂] ≤ s
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- The colimit of the constant `⊥_ C` functor is `⊥_ C`. -/
@[simps inv]
def colimitConstInitial {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C] :
    colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma one_le_sqrt : 1 ≤ √x ↔ 1 ≤ x
-- Mathlib/Geometry/Manifold/Complex.lean
/-- A holomorphic function on a compact connected complex manifold is constant. -/
theorem apply_eq_of_compactSpace [PreconnectedSpace M] {f : M → F}
    (hf : MDifferentiable I 𝓘(ℂ, F) f) (a b : M) : f a = f b
-- Mathlib/Probability/Cdf.lean
/-- The cdf is non-negative. -/
lemma cdf_nonneg (x : ℝ) : 0 ≤ cdf μ x
-- Mathlib/Data/Nat/Cast/Basic.lean
theorem eq_natCast' [AddMonoidHomClass F ℕ A] (f : F) (h1 : f 1 = 1) : ∀ n : ℕ, f n = n
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
lemma hasAntidiagonal_congr (A : Type*) [AddMonoid A]
    [H1 : HasAntidiagonal A] [H2 : HasAntidiagonal A] :
    H1.antidiagonal = H2.antidiagonal
-- Mathlib/Data/Multiset/Basic.lean
theorem replicate_right_injective {n : ℕ} (hn : n ≠ 0) : Injective (@replicate α n)
-- Mathlib/Algebra/Group/Aut.lean
theorem one_def : (1 : AddAut A) = AddEquiv.refl _
-- Mathlib/Data/Real/Irrational.lean
theorem nat_sub (h : Irrational x) (m : ℕ) : Irrational (m - x)
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
/-- A ring homomorphism f : Z[X_1, X_2, ...] → R
is determined by the evaluations f(X_1), f(X_2), ... -/
@[simp]
theorem eval₂Hom_X {R : Type u} (c : ℤ →+* S) (f : MvPolynomial R ℤ →+* S) (x : MvPolynomial R ℤ) :
    eval₂ c (f ∘ X) x = f x
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem pow_minFac {n k : ℕ} (hk : k ≠ 0) : (n ^ k).minFac = n.minFac
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem circleMap_sub_center (c : ℂ) (R : ℝ) (θ : ℝ) : circleMap c R θ - c = circleMap 0 R θ
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem uniqueDiffWithinAt_of_mem_nhds (h : s ∈ 𝓝 x) : UniqueDiffWithinAt 𝕜 s x
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma smul_absolutelyContinuous {c : ℝ≥0∞} : c • μ ≪ μ
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ico_union_Ico_eq_Ico {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) :
    Ico a b ∪ Ico b c = Ico a c
-- Mathlib/Algebra/Polynomial/DenomsClearable.lean
theorem denomsClearable_C_mul_X_pow {N : ℕ} (a : R) (bu : bi * i b = 1) {n : ℕ} (r : R)
    (nN : n ≤ N) : DenomsClearable a b N (C r * X ^ n) i
-- Mathlib/CategoryTheory/SingleObj.lean
theorem inv_as_inv {x y : SingleObj G} (f : x ⟶ y) : inv f = f⁻¹
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeries_eq_bot_iff (k : ℕ) :
    derivedSeries R I k = ⊥ ↔ derivedSeriesOfIdeal R L k I = ⊥
-- Mathlib/Data/List/Nodup.lean
theorem nodup_iff_sublist {l : List α} : Nodup l ↔ ∀ a, ¬[a, a] <+ l
-- Mathlib/SetTheory/Game/Impartial.lean
theorem impartial_iff_aux {G : PGame} : G.Impartial ↔ G.ImpartialAux
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem ofSet_symm : (ofSet s).symm = ofSet s
-- Mathlib/Data/Finite/Card.lean
/-- NB: `Nat.card` is defined to be `0` for infinite types. -/
theorem card_eq_zero_of_injective [Nonempty α] {f : α → β} (hf : Function.Injective f)
    (h : Nat.card α = 0) : Nat.card β = 0
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- If `edist (f n) (f (n+1))` is bounded by `C * r^n`, then the distance from
`f n` to the limit of `f` is bounded above by `C * r^n / (1 - r)`. -/
theorem edist_le_of_edist_le_geometric_of_tendsto {a : α} (ha : Tendsto f atTop (𝓝 a)) (n : ℕ) :
    edist (f n) a ≤ C * r ^ n / (1 - r)
-- Mathlib/GroupTheory/CoprodI.lean
theorem fstIdx_ne_iff {w : Word M} {i} :
    fstIdx w ≠ some i ↔ ∀ l ∈ w.toList.head?, i ≠ Sigma.fst l
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem eval₂_gcd_eq_zero [CommSemiring k] [DecidableEq R]
    {ϕ : R →+* k} {f g : R[X]} {α : k} (hf : f.eval₂ ϕ α = 0)
    (hg : g.eval₂ ϕ α = 0) : (EuclideanDomain.gcd f g).eval₂ ϕ α = 0
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
nonrec theorem integral_non_aestronglyMeasurable
    (hf : ¬AEStronglyMeasurable f (μ.restrict (Ι a b))) :
    ∫ x in a..b, f x ∂μ = 0
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma lt_of_smul_lt_smul_left [PosSMulReflectLT α β] (h : a • b₁ < a • b₂) (ha : 0 ≤ a) : b₁ < b₂
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma injOn_weightSpace [NoZeroSMulDivisors R M] :
    InjOn (fun (χ : L → R) ↦ weightSpace M χ) {χ | weightSpace M χ ≠ ⊥}
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem mem_intrinsicClosure :
    x ∈ intrinsicClosure 𝕜 s ↔ ∃ y, y ∈ closure ((↑) ⁻¹' s : Set <| affineSpan 𝕜 s) ∧ ↑y = x
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem fderivWithin_derivWithin : (fderivWithin 𝕜 f s x : 𝕜 → F) 1 = derivWithin f s x
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[simp]
theorem Homeomorph.smulOfNeZero_symm_apply {c : G₀} (hc : c ≠ 0) :
    ⇑(Homeomorph.smulOfNeZero c hc).symm = (c⁻¹ • · : α → α)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem le_degree_of_ne_zero (h : coeff p n ≠ 0) : (n : WithBot ℕ) ≤ degree p
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
@[simp]
theorem mem_carrier_iff (A : Subspace K V) (x : ℙ K V) : x ∈ A.carrier ↔ x ∈ A
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseLeftKanExtension.hom_ext (h : E.IsPointwiseLeftKanExtension)
    {G : LeftExtension L F} {f₁ f₂ : E ⟶ G} : f₁ = f₂
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem BinaryBicone.inlCokernelCofork_π : (BinaryBicone.inlCokernelCofork c).π = c.snd
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem and_iff_right_of_imp (h : b → a) : (a ∧ b) ↔ b
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma measurable_up : Measurable (ULift.up : α → ULift α)
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
@[simp]
theorem arsinh_eq_zero_iff : arsinh x = 0 ↔ x = 0
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem intCast_imJ (z : ℤ) : (z : ℍ[R]).imJ = 0
-- Mathlib/Data/Nat/Choose/Central.lean
theorem two_dvd_centralBinom_of_one_le {n : ℕ} (h : 0 < n) : 2 ∣ centralBinom n
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem map_eq_iff {x y : F} : f₁ x = f₁ y ↔ x = y
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem measure_iUnion_toMeasurable [Countable β] (s : β → Set α) :
    μ (⋃ b, toMeasurable μ (s b)) = μ (⋃ b, s b)
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
@[simp]
lemma decomposeAlgEquiv_symm_apply (a : ⨁ i, 𝒜 i) :
    (decomposeAlgEquiv 𝒜).symm a = (decompose 𝒜).symm a
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_pow_id (a : A) (n : ℕ) (ha : p a := by cfc_tac) : cfc (· ^ n : R → R) a = a ^ n
-- Mathlib/Probability/Independence/Basic.lean
theorem iIndep.indep
    (h_indep : iIndep m μ) {i j : ι} (hij : i ≠ j) : Indep (m i) (m j) μ
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_sub (hf : Integrable f μ) (hg : Integrable g μ) :
    μ[f - g|m] =ᵐ[μ] μ[f|m] - μ[g|m]
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
lemma dist_inf_sup_pi (x y : ι → ℝ) : dist (x ⊓ y) (x ⊔ y) = dist x y
-- Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean
@[simp]
lemma map_self : map p f φ (id_comp f).symm φ = 𝟙 a
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem measurable_join : Measurable (join : Measure (Measure α) → Measure α)
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem mem_coclosedLindelof : s ∈ coclosedLindelof X ↔
    ∃ t, IsClosed t ∧ IsLindelof t ∧ tᶜ ⊆ s
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[simp]
theorem binaryProductCone_snd (X Y : Type u) : (binaryProductCone X Y).snd = _root_.Prod.snd
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
@[simp]
theorem lanCompIsoWhisker_hom_right :
    (lanCompIsoWhisker f g h).hom.right = lanDesc ((lanLeftExtension f g).whisker h)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem mem_append {a : α} {s t : Array α} : a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma isNilRegular_iff_natTrailingDegree_charpoly_eq_nilRank :
    IsNilRegular φ x ↔ (φ x).charpoly.natTrailingDegree = nilRank φ
-- Mathlib/CategoryTheory/Functor/Category.lean
/-- The monoid of natural transformations of the identity is commutative.-/
lemma id_comm (α β : (𝟭 C) ⟶ (𝟭 C)) : α ≫ β = β ≫ α
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `f : ℝ → ℝ` be a differentiable function. If `C ≤ f'`, then `f` grows at least as fast
as `C * x`, i.e., `C * (y - x) ≤ f y - f x` whenever `x ≤ y`. -/
theorem mul_sub_le_image_sub_of_le_deriv {f : ℝ → ℝ} (hf : Differentiable ℝ f) {C}
    (hf'_ge : ∀ x, C ≤ deriv f x) ⦃x y⦄ (hxy : x ≤ y) : C * (y - x) ≤ f y - f x
-- Mathlib/Condensed/TopCatAdjunction.lean
/-- The map part of the functor `CondensedSet ⥤ TopCat`  -/
@[simps]
def toTopCatMap : X.toTopCat ⟶ Y.toTopCat
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma toRatCDF_of_isRatStieltjesPoint {a : α} (h : IsRatStieltjesPoint f a) (q : ℚ) :
    toRatCDF f a q = f a q
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem filter_apply_ne_zero_iff (a : α) : (p.filter s h) a ≠ 0 ↔ a ∈ s ∧ a ∈ p.support
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
@[ext]
theorem ext (A B : SpecialLinearGroup n R) : (∀ i j, ↑ₘA i j = ↑ₘB i j) → A = B