ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If two unoriented angles are equal, and the signs of the corresponding oriented angles are
equal, then the oriented angles are equal (even in degenerate cases). -/
theorem oangle_eq_of_angle_eq_of_sign_eq {p₁ p₂ p₃ p₄ p₅ p₆ : P} (h : ∠ p₁ p₂ p₃ = ∠ p₄ p₅ p₆)
    (hs : (∡ p₁ p₂ p₃).sign = (∡ p₄ p₅ p₆).sign) : ∡ p₁ p₂ p₃ = ∡ p₄ p₅ p₆
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem ofBool_eq_iff_eq : ∀(b b' : Bool), BitVec.ofBool b = BitVec.ofBool b' ↔ b = b'
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isNat_zpow_pos {α : Type*} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsNat (a ^ nb) ne) :
    IsNat (a ^ b) ne
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀ (μ : Measure α)
    {f : α → ℝ≥0∞} {s : Set α} (hf : AEMeasurable f (μ.restrict s)) (g : α → ℝ≥0∞)
    (hs : MeasurableSet s) (h'f : ∀ᵐ x ∂μ.restrict s, f x < ∞) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem EuclideanSpace.nndist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : nndist x y = NNReal.sqrt (∑ i, nndist (x i) (y i) ^ 2)
-- Mathlib/CategoryTheory/Linear/FunctorCategory.lean
@[simp]
theorem app_smul (X : C) (r : R) (α : F ⟶ G) : (r • α).app X = r • α.app X
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
theorem ad_ker_eq_bot_of_hasTrivialRadical [HasTrivialRadical R L] : (ad R L).ker = ⊥
-- Mathlib/Analysis/Calculus/Deriv/Inverse.lean
/-- If `f` is a partial homeomorphism defined on a neighbourhood of `f.symm a`, and `f` has a
nonzero derivative `f'` at `f.symm a`, then `f.symm` has the derivative `f'⁻¹` at `a`.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. -/
theorem PartialHomeomorph.hasDerivAt_symm (f : PartialHomeomorph 𝕜 𝕜) {a f' : 𝕜} (ha : a ∈ f.target)
    (hf' : f' ≠ 0) (htff' : HasDerivAt f f' (f.symm a)) : HasDerivAt f.symm f'⁻¹ a
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem findIdx_of_get?_eq_some {xs : List α} (w : xs.get? (xs.findIdx p) = some y) : p y
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem length_pos {l : List α} : 0 < length l ↔ l ≠ []
-- Mathlib/Order/Interval/Basic.lean
theorem pure_injective : Injective (pure : α → NonemptyInterval α)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem AEMeasurable.real_toNNReal {f : α → ℝ} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => Real.toNNReal (f x)) μ
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_pred_of_le (p i : Fin (n + 1)) (h : i ≤ p) (hi : i ≠ 0) :
    succAbove p (i.pred hi) = (i.pred hi).castSucc
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem pow_right_iff (hm : 0 < m) : IsRelPrime x (y ^ m) ↔ IsRelPrime x y
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃
      NormedAddGroupHom V₁ (f.equalizer g)
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- The Cartesian product of analytic functions is analytic. -/
lemma AnalyticAt.prod {e : E} {f : E → F} {g : E → G}
    (hf : AnalyticAt 𝕜 f e) (hg : AnalyticAt 𝕜 g e) :
    AnalyticAt 𝕜 (fun x ↦ (f x, g x)) e
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_self (ha : 0 < a) (hb : 1 < b) : a / b < a
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_iff_pair_subset : s.Nontrivial ↔ ∃ x y, x ≠ y ∧ {x, y} ⊆ s
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem oadd_mul (e₁ n₁ a₁ e₂ n₂ a₂) :
    oadd e₁ n₁ a₁ * oadd e₂ n₂ a₂ =
      if e₂ = 0 then oadd e₁ (n₁ * n₂) a₁ else oadd (e₁ + e₂) n₂ (oadd e₁ n₁ a₁ * a₂)
-- Mathlib/Order/Filter/Lift.lean
theorem comap_eq_lift' {f : Filter β} {m : α → β} : comap m f = f.lift' (preimage m)
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem recAux_zero {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) :
    Nat.recAux zero succ 0 = zero
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem mem_compPartialSumTarget_iff {m M N : ℕ} {a : Σ n, Composition n} :
    a ∈ compPartialSumTarget m M N ↔
      m ≤ a.2.length ∧ a.2.length < M ∧ ∀ j : Fin a.2.length, a.2.blocksFun j < N
-- Mathlib/Topology/Inseparable.lean
lemma IsClosedMap.specializingMap (hf : IsClosedMap f) : SpecializingMap f
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem hasFiniteIntegral_of_dominated_convergence {F : ℕ → α → β} {f : α → β} {bound : α → ℝ}
    (bound_hasFiniteIntegral : HasFiniteIntegral bound μ)
    (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) : HasFiniteIntegral f μ
-- .lake/packages/batteries/Batteries/Data/HashMap/WF.lean
theorem expand_size [Hashable α] {buckets : Buckets α β} :
    (expand sz buckets).buckets.size = buckets.size
-- Mathlib/Order/Circular.lean
theorem btw_rfl_left {a b : α} : btw a a b
-- Mathlib/Order/Filter/Basic.lean
theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_le_iff_le_toReal {a : ℝ} {b : ℝ≥0∞} (hb : b ≠ ∞) :
    ENNReal.ofReal a ≤ b ↔ a ≤ ENNReal.toReal b
-- Mathlib/Order/BoundedOrder.lean
theorem monotone_lt {x : α} : Monotone (x < ·)
-- Mathlib/GroupTheory/Subgroup/Centralizer.lean
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set G} : centralizer s = ⊤ ↔ s ⊆ center G
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_eq_pow_val {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm = (p : ℚ) ^ (-f.valuation : ℤ)
-- Mathlib/Order/SuccPred/Basic.lean
theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a
-- Mathlib/Topology/Order/MonotoneContinuity.lean
/-- If a function `f` with a densely ordered codomain is monotone on a neighborhood of `a` and the
closure of the image of this neighborhood under `f` is a neighborhood of `f a`, then `f` is
continuous at `a`. -/
theorem continuousAt_of_monotoneOn_of_closure_image_mem_nhds [DenselyOrdered β] {f : α → β}
    {s : Set α} {a : α} (h_mono : MonotoneOn f s) (hs : s ∈ 𝓝 a)
    (hfs : closure (f '' s) ∈ 𝓝 (f a)) : ContinuousAt f a
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem disjoint_closedBall_of_lt_infEdist {r : ℝ≥0∞} (h : r < infEdist x s) :
    Disjoint (closedBall x r) s
-- Mathlib/RingTheory/Polynomial/RationalRoot.lean
/-- **Rational root theorem** part 1:
if `r : f.codomain` is a root of a polynomial over the ufd `A`,
then the numerator of `r` divides the constant coefficient -/
theorem num_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) : num A r ∣ p.coeff 0
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- All points have distance to the circumcenter equal to the
circumradius. -/
@[simp]
theorem dist_circumcenter_eq_circumradius' {n : ℕ} (s : Simplex ℝ P n) :
    ∀ i, dist s.circumcenter (s.points i) = s.circumradius
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem leftLim_le_rightLim (h : x < y) : leftLim f y ≤ rightLim f x
-- Mathlib/Algebra/Ring/Basic.lean
lemma IsRightCancelMulZero.to_noZeroDivisors [NonUnitalNonAssocRing α] [IsRightCancelMulZero α] :
    NoZeroDivisors α
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem mk'_rightMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence induce the same
uniform structure on `ι`.

This is a specialization of `EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi'` to
the case where `𝔖` covers `X`. -/
lemma EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi [UniformSpace ι]
    {𝔖 : Set (Set X)} (𝔖_covers : ⋃₀ 𝔖 = univ) (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
    UniformInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
    UniformInducing F
-- Mathlib/RingTheory/WittVector/Domain.lean
theorem eq_iterate_verschiebung {x : 𝕎 R} {n : ℕ} (h : ∀ i < n, x.coeff i = 0) :
    x = verschiebung^[n] (x.shift n)
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem existsUnique (h : IsUniversal f) (g : CostructuredArrow S T) :
    ∃! η : g.left ⟶ f.left, S.map η ≫ f.hom = g.hom
-- Mathlib/Analysis/RCLike/Basic.lean
protected lemma inv_pos : 0 < z⁻¹ ↔ 0 < z
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem boundary_zero : (c.boundary ⟨0, c.card_boundaries_pos⟩ : Fin (n + 1)) = 0
-- Mathlib/Data/Finset/Pi.lean
theorem pi_subset {s : Finset α} (t₁ t₂ : ∀ a, Finset (β a)) (h : ∀ a ∈ s, t₁ a ⊆ t₂ a) :
    s.pi t₁ ⊆ s.pi t₂
-- Mathlib/RingTheory/Nilpotent/Lemmas.lean
@[simp]
theorem isNilpotent_mulLeft_iff (a : A) : IsNilpotent (mulLeft R a) ↔ IsNilpotent a
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Eigs.lean
theorem det_eq_prod_roots_charpoly [IsAlgClosed R] : A.det = (Matrix.charpoly A).roots.prod
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem mem_support_seq_iff : b ∈ (seq q p).support ↔ ∃ f ∈ q.support, b ∈ f '' p.support
-- Mathlib/LinearAlgebra/Prod.lean
theorem snd_map_fst : (Submodule.snd R M M₂).map (LinearMap.fst R M M₂) = ⊥
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma map_injective (hf : Function.Injective f) : Function.Injective <| map W f
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem piLp_equiv_toEuclideanLin_apply (M : Matrix m n 𝕜) (v : EuclideanSpace 𝕜 n) :
    WithLp.equiv 2 (m → 𝕜) (toEuclideanLin M v) = M *ᵥ WithLp.equiv 2 (n → 𝕜) v
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem cofan_inj_id (n : ℕ) : (s.cofan _).inj (IndexSet.id (op [n])) = s.ι n
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
@[simp]
theorem transvection_mul_apply_of_ne (a b : n) (ha : a ≠ i) (c : R) (M : Matrix n n R) :
    (transvection i j c * M) a b = M a b
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_mul_of_limit {a b c : Ordinal} (h : IsLimit c) : a < b * c ↔ ∃ c' < c, a < b * c'
-- Mathlib/NumberTheory/LSeries/HurwitzZeta.lean
/-- The Hurwitz zeta function is differentiable away from `s = 1`. -/
lemma differentiableAt_hurwitzZeta (a : UnitAddCircle) {s : ℂ} (hs : s ≠ 1) :
    DifferentiableAt ℂ (hurwitzZeta a) s
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem not_mem_range_coe_iff {x : OnePoint X} : x ∉ range some ↔ x = ∞
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem isBigO_pow_pow_of_le_left {r₁ r₂ : ℝ} (h₁ : 0 ≤ r₁) (h₂ : r₁ ≤ r₂) :
    (fun n : ℕ ↦ r₁ ^ n) =O[atTop] fun n ↦ r₂ ^ n
-- Mathlib/Order/Hom/Basic.lean
/-- A version of `Equiv.optionCongr` for `WithBot`. -/
@[simps! apply]
def withBotCongr (e : α ≃o β) : WithBot α ≃o WithBot β
-- Mathlib/Order/WellFoundedSet.lean
theorem fiberProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hαβ : s.IsPWO) (a : α) : {y | toLex (a, y) ∈ s}.IsPWO
-- Mathlib/Analysis/Calculus/Deriv/Pow.lean
@[simp]
theorem deriv_pow'' (hc : DifferentiableAt 𝕜 c x) :
    deriv (fun x => c x ^ n) x = (n : 𝕜) * c x ^ (n - 1) * deriv c x
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem symm_self_id (α : X ≅ Y) : α.symm ≪≫ α = Iso.refl Y
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainBotCoeff_zero_right [Nontrivial L] : chainBotCoeff α (0 : Weight K H L) = 1
-- Mathlib/Analysis/NormedSpace/Extend.lean
theorem ContinuousLinearMap.extendTo𝕜_apply (fr : RestrictScalars ℝ 𝕜 F →L[ℝ] ℝ) (x : F) :
    fr.extendTo𝕜 x = (fr x : 𝕜) - (I : 𝕜) * (fr ((I : 𝕜) • x) : 𝕜)
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma app_unitForward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : Cᵒᵖ)
    (p : YonedaCollection (restrictedYonedaObj η) X.unop) :
    η.app X (unitForward η X.unop p) = p.yonedaEquivFst
-- Mathlib/RingTheory/Ideal/Maps.lean
@[simp]
theorem liftOfRightInverseAux_comp_apply (hf : Function.RightInverse f_inv f) (g : A →+* C)
    (hg : RingHom.ker f ≤ RingHom.ker g) (a : A) :
    (f.liftOfRightInverseAux f_inv hf g hg) (f a) = g a
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extChartAt_source_mem_nhds (x : M) : (extChartAt I x).source ∈ 𝓝 x
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem cast_pow' (a : ZMod n) (k : ℕ) : (cast (a ^ k : ZMod n) : R) = (cast a : R) ^ k
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_lt_iff_degree_lt (hp : p ≠ 0) : p.natDegree < n ↔ p.degree < ↑n
-- Mathlib/Order/OrderIsoNat.lean
/-- This is the infinitary Erdős–Szekeres theorem, and an important lemma in the usual proof of
    Bolzano-Weierstrass for `ℝ`. -/
theorem exists_increasing_or_nonincreasing_subseq (r : α → α → Prop) [IsTrans α r] (f : ℕ → α) :
    ∃ g : ℕ ↪o ℕ,
      (∀ m n : ℕ, m < n → r (f (g m)) (f (g n))) ∨ ∀ m n : ℕ, m < n → ¬r (f (g m)) (f (g n))
-- Mathlib/Topology/StoneCech.lean
lemma preStoneCechCompat {F G : Ultrafilter α} {x : α} (hF : ↑F ≤ 𝓝 x) (hG : ↑G ≤ 𝓝 x) :
    Ultrafilter.extend g F = Ultrafilter.extend g G
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sumAddHom_singleAddHom [∀ i, AddCommMonoid (β i)] :
    sumAddHom (singleAddHom β) = AddMonoidHom.id _
-- Mathlib/Order/Compare.lean
theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
    [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Compare.lean
theorem Fin.eq_of_compare {n n' : Fin m} (h : compare n n' = .eq) : n = n'
-- Mathlib/Computability/DFA.lean
@[simp]
theorem evalFrom_append_singleton (s : σ) (x : List α) (a : α) :
    M.evalFrom s (x ++ [a]) = M.step (M.evalFrom s x) a
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem smul_def (a : A) (b : B) (m : M) : a ⊗ₜ[R] b • m = a • b • m
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem map_id : s.map (RingHom.id R) = s
-- Mathlib/Data/Complex/Exponential.lean
lemma one_sub_le_exp_neg (x : ℝ) : 1 - x ≤ exp (-x)
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem id : MeasurableEmbedding (id : α → α)
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[simp]
lemma UniformOnFun.toFun_smul {M : Type*} [SMul M β] (c : M) (f : α →ᵤ[𝔖] β) :
    toFun 𝔖 (c • f) = c • toFun 𝔖 f
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem get_thinkN (n) : get (thinkN s n) = get s
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
theorem toEven_comp_ofEven : (toEven Q).comp (ofEven Q) = AlgHom.id R _
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem mem_coLindelof' : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t
-- Mathlib/Data/Fin/Basic.lean
protected theorem heq_ext_iff {k l : ℕ} (h : k = l) {i : Fin k} {j : Fin l} :
    HEq i j ↔ (i : ℕ) = (j : ℕ)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem comp_mul_right (hf : IntervalIntegrable f volume a b) (c : ℝ) :
    IntervalIntegrable (fun x => f (x * c)) volume (a / c) (b / c)
-- Mathlib/Tactic/NormNum/BigOperators.lean
lemma Multiset.range_zero' {n : ℕ} (pn : NormNum.IsNat n 0) :
    Multiset.range n = 0
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
theorem isClosed_closedBall (x' : Dual 𝕜 E) (r : ℝ) : IsClosed (toNormedDual ⁻¹' closedBall x' r)
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem comap_id : comap (@ContinuousMap.id X _) = @id (LocallyConstant X Z)
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- In a finite-dimensional space, linear maps are inverse to each other on one side if and only if
they are inverse to each other on the other side. -/
theorem comp_eq_id_comm [FiniteDimensional K V] {f g : V →ₗ[K] V} : f.comp g = id ↔ g.comp f = id
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_eq_one {x : S'} : (↑x : M₁) = 1 ↔ x = 1
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem coeIdeal_le_coeIdeal' [IsLocalization S P] (h : S ≤ nonZeroDivisors R) {I J : Ideal R} :
    (I : FractionalIdeal S P) ≤ J ↔ I ≤ J
-- Mathlib/FieldTheory/Adjoin.lean
/-- A compositum of splitting fields is a splitting field -/
theorem isSplittingField_iSup {p : ι → K[X]}
    {s : Finset ι} (h0 : ∏ i ∈ s, p i ≠ 0) (h : ∀ i ∈ s, (p i).IsSplittingField K (t i)) :
    (∏ i ∈ s, p i).IsSplittingField K (⨆ i ∈ s, t i : IntermediateField K L)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem end_mem_tail_support_of_ne {u v : V} (h : u ≠ v) (p : G.Walk u v) : v ∈ p.support.tail
-- Mathlib/Data/Nat/Defs.lean
lemma succ_ne_succ : succ m ≠ succ n ↔ m ≠ n
-- Mathlib/Topology/Constructions.lean
theorem Inducing.of_codRestrict {f : X → Y} {t : Set Y} (ht : ∀ x, f x ∈ t)
    (h : Inducing (t.codRestrict f ht)) : Inducing f
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.image [FunLike F α β] [SupHomClass F α β] (hs : SupClosed s) (f : F) :
    SupClosed (f '' s)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem whiskerLeft_comp_bimod {X Y Z : Mon_ C} (M : Bimod X Y) {N P Q : Bimod Y Z} (f : N ⟶ P)
    (g : P ⟶ Q) : whiskerLeft M (f ≫ g) = whiskerLeft M f ≫ whiskerLeft M g
-- Mathlib/Data/Fin/Basic.lean
theorem castSucc_pred_lt {a : Fin (n + 1)} (ha : a ≠ 0) :
    castSucc (a.pred ha) < a
-- Mathlib/GroupTheory/Torsion.lean
/-- The `p`-primary component is the submonoid of elements with order prime-power of `p`. -/
@[to_additive (attr := simps)
      "The `p`-primary component is the submonoid of elements with additive
      order prime-power of `p`."]
def primaryComponent : Submonoid G
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem measure_diff_biUnion : μ (s \ ⋃ p ∈ h.index, h.covering p) = 0
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_singleton {α : Type u} (x : α) : #({x} : Set α) = 1
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorComm_symm (i j : A) :
    (shiftFunctorComm C i j).symm = shiftFunctorComm C j i
-- Mathlib/FieldTheory/Adjoin.lean
theorem coe_algHomOfDvd {p q : K[X]} (hpq : q ∣ p) :
    (algHomOfDvd hpq).toFun = liftHom p (root q) (by simp only [aeval_eq, mk_eq_zero, hpq])
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem pderivCLM_eq_lineDeriv (m : E) (f : 𝓢(E, F)) (x : E) :
    pderivCLM 𝕜 m f x = lineDeriv ℝ f x m
-- Mathlib/Topology/List.lean
theorem tendsto_insertNth' {a : α} :
    ∀ {n : ℕ} {l : List α},
      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
/-- If `η_A` is an isomorphism, then `A` is in the essential image of `i`. -/
theorem mem_essImage_of_unit_isIso (A : C)
    [IsIso (h.unit.app A)] : A ∈ R.essImage
-- Mathlib/CategoryTheory/Conj.lean
theorem conjAut_pow (f : Aut X) (n : ℕ) : α.conjAut (f ^ n) = α.conjAut f ^ n
-- Mathlib/RingTheory/Kaehler/Polynomial.lean
@[simp]
lemma KaehlerDifferential.mvPolynomialBasis_apply (σ) (i) :
    mvPolynomialBasis R σ i = D R (MvPolynomial σ R) (.X i)
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean
@[simp]
theorem toPartialHomeomorph_coe (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    (hf.toPartialHomeomorph f : E → F) = f
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem adjoin_univ : adjoin R (Set.univ : Set A) = ⊤
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- The norm of the identity is at most `1`. It is in fact `1`, except when the space is trivial
where it is `0`. It means that one can not do better than an inequality in general. -/
theorem norm_id_le : ‖id 𝕜 E‖ ≤ 1
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
@[simp]
lemma pushforward_map_app_apply {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (X : Cᵒᵖ)
    (m : (ModuleCat.restrictScalars (φ.app X)).obj (M.obj (Opposite.op (F.obj X.unop)))) :
    ((pushforward φ).map α).app X m = α.app (Opposite.op (F.obj X.unop)) m
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem eq_of_eqOn_top {f g : G →* M} (h : Set.EqOn f g (⊤ : Subgroup G)) : f = g
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem Products.max_eq_eval [Inhabited I] (l : Products I) (hl : l.val ≠ [])
    (hlh : l.val.head! = term I ho) :
    Linear_CC' C hsC ho (l.eval C) = l.Tail.eval (C' C ho)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem toNNReal_apply_of_tsum_ne_top {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' i, f i ≠ ∞) (x : α) :
    (((ENNReal.toNNReal ∘ f) x : ℝ≥0) : ℝ≥0∞) = f x
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_iInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : ι → UniformSpace β} :
    UniformContinuous[u₁, iInf u₂] f ↔ ∀ i, UniformContinuous[u₁, u₂ i] f
-- Mathlib/CategoryTheory/GlueData.lean
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem symm_refl (α : Type*) [MeasurableSpace α] : (refl α).symm = refl α
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tendsto_pow_atTop_atTop_of_one_lt [LinearOrderedRing α] [Archimedean α] {r : α}
    (h : 1 < r) : Tendsto (fun n : ℕ ↦ r ^ n) atTop atTop
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem inv_mem_iff {c d : C} (f : c ⟶ d) :
    Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d
-- Mathlib/Geometry/Euclidean/Angle/Sphere.lean
/-- If two triangles have two points the same, and twice the angle at the third point the same,
they have the same circumsphere. -/
theorem circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq {t₁ t₂ : Triangle ℝ P}
    {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃)
    (h₁ : t₁.points i₁ = t₂.points i₁) (h₃ : t₁.points i₃ = t₂.points i₃)
    (h₂ : (2 : ℤ) • ∡ (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) =
      (2 : ℤ) • ∡ (t₂.points i₁) (t₂.points i₂) (t₂.points i₃)) :
    t₁.circumsphere = t₂.circumsphere
-- Mathlib/Logic/Basic.lean
@[simp] theorem eq_iff_eq_cancel_left {b c : α} : (∀ {a}, a = b ↔ a = c) ↔ b = c
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem toLp_zero (h : Memℒp (0 : α → E) p μ) : h.toLp 0 = 0
-- Mathlib/Order/Filter/ModEq.lean
theorem frequently_even : ∃ᶠ m : ℕ in atTop, Even m
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
/-- Auxiliary definition for `CategoryTheory.Mat.equivalenceSingleObj`. -/
@[simps]
def equivalenceSingleObjInverse : Mat_ (SingleObj Rᵐᵒᵖ) ⥤ Mat R
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem ofFinsupp_smul {S : Type*} [SMulZeroClass S R] (a : S) (b) :
    (⟨a • b⟩ : R[X]) = (a • ⟨b⟩ : R[X])
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive nsmul_le_nsmul_left_of_nonpos]
theorem pow_le_pow_right_of_le_one' {a : M} {n m : ℕ} (ha : a ≤ 1) (h : n ≤ m) : a ^ m ≤ a ^ n
-- Mathlib/Order/PrimeIdeal.lean
theorem compl_F_eq_I : (IF.F : Set P)ᶜ = IF.I
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioo_of_Ioo : AECover (μ.restrict <| Ioo A B) l fun i => Ioo (a i) (b i)
-- Mathlib/Data/Seq/Parallel.lean
theorem terminates_parallel.aux :
    ∀ {l : List (Computation α)} {S c},
      c ∈ l → Terminates c → Terminates (corec parallel.aux1 (l, S))
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma op_distinguished (T : Triangle C) (hT : T ∈ distTriang C) :
    ((triangleOpEquivalence C).functor.obj (Opposite.op T)) ∈ distTriang Cᵒᵖ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem eq_of_getMsb_eq {x y : BitVec w}
    (pred : ∀(i : Fin w), x.getMsb i = y.getMsb i.val) : x = y
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem limNthHom_zero : limNthHom f_compat 0 = 0
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem map_mk (f : M →ₗ[R] N) (a : AdicCauchySequence I M) :
    map I f (AdicCompletion.mk I M a) =
      AdicCompletion.mk I N (AdicCauchySequence.map I f a)
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem eval_zero : eval f a 0 = 0
-- Mathlib/Topology/Separation.lean
/-- In an R₀ space, `Specializes` is equivalent to `Inseparable`. -/
theorem specializes_iff_inseparable : x ⤳ y ↔ Inseparable x y
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞