ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- If a continuous multilinear map is constructed from a multilinear map via the constructor
`mkContinuous`, then its norm is bounded by the bound given to the constructor if it is
nonnegative. -/
theorem MultilinearMap.mkContinuous_norm_le (f : MultilinearMap 𝕜 E G) {C : ℝ} (hC : 0 ≤ C)
    (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ‖f.mkContinuous C H‖ ≤ C
-- Mathlib/CategoryTheory/Adjunction/Lifting.lean
/-- Suppose we have a commutative square of functors

      Q
    A → B
  U ↓   ↓ V
    C → D
      R

where `U` has a left adjoint, `A` has reflexive coequalizers and `V` has a left adjoint such that
each component of the counit is a regular epi.
Then `Q` has a left adjoint if `R` has a left adjoint.

See https://ncatlab.org/nlab/show/adjoint+lifting+theorem
-/
lemma adjointSquareLift (Q : A ⥤ B) (V : B ⥤ D) (U : A ⥤ C) (R : C ⥤ D)
    (comm : U ⋙ R ≅ Q ⋙ V) [U.IsRightAdjoint] [V.IsRightAdjoint] [R.IsRightAdjoint]
    [∀ X, RegularEpi ((Adjunction.ofIsRightAdjoint V).counit.app X)] [HasReflexiveCoequalizers A] :
    Q.IsRightAdjoint
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp]
theorem forget₂_algebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :
    (forget₂ (BialgebraCat R) (AlgebraCat R)).map f = (f.toBialgHom : X →ₐ[R] Y)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
protected theorem Adj.ne {H : G.Subgraph} {u v : V} (h : H.Adj u v) : u ≠ v
-- Mathlib/Topology/GDelta.lean
/-- A set is meagre iff it is contained in a countable union of nowhere dense sets. -/
lemma isMeagre_iff_countable_union_isNowhereDense {s : Set X} :
    IsMeagre s ↔ ∃ S : Set (Set X), (∀ t ∈ S, IsNowhereDense t) ∧ S.Countable ∧ s ⊆ ⋃₀ S
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem ne_of_gt {i₁ i₂ : Pos} (h : i₁ < i₂) : i₂ ≠ i₁
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- **Legendre's Theorem**

The `p`-adic valuation of `n!` is the sum of the quotients `n / p ^ i`. This sum is expressed
over the finset `Ico 1 b` where `b` is any bound greater than `log p n`. -/
theorem padicValNat_factorial {n b : ℕ} [hp : Fact p.Prime] (hnb : log p n < b) :
    padicValNat p (n !) = ∑ i ∈ Finset.Ico 1 b, n / p ^ i
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extChartAt_target (x : M) :
    (extChartAt I x).target = I.symm ⁻¹' (chartAt H x).target ∩ range I
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem coe_mk (f : C(α, β)) (h : HasCompactSupport f) : ⇑(⟨f, h⟩ : C_c(α, β)) = f
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseLeftKanExtensionAt.hasPointwiseLeftKanExtensionAt
    {Y : D} (h : E.IsPointwiseLeftKanExtensionAt Y) :
    HasPointwiseLeftKanExtensionAt L F Y
-- Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
@[simp]
theorem extend_hom_app (α : (inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) (i : ι) :
    (restrictHomEquivHom F F' h α).app (op (B i)) = α.app (op i)
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
theorem wronskian_neg_left (a b : R[X]) : wronskian (-a) b = -wronskian a b
-- Mathlib/Analysis/PSeries.lean
theorem summable_condensed_iff {f : ℕ → ℝ≥0} (hf : ∀ ⦃m n⦄, 0 < m → m ≤ n → f n ≤ f m) :
    (Summable fun k : ℕ => (2 : ℝ≥0) ^ k * f (2 ^ k)) ↔ Summable f
-- Mathlib/Topology/MetricSpace/Basic.lean
theorem SeparationQuotient.dist_mk {α : Type u} [PseudoMetricSpace α] (p q : α) :
    dist (mk p) (mk q) = dist p q
-- Mathlib/Algebra/Module/Equiv/Basic.lean
theorem arrowCongr_trans {M₁ M₂ M₃ N₁ N₂ N₃ : Sort _} [AddCommMonoid M₁] [Module R M₁]
    [AddCommMonoid M₂] [Module R M₂] [AddCommMonoid M₃] [Module R M₃] [AddCommMonoid N₁]
    [Module R N₁] [AddCommMonoid N₂] [Module R N₂] [AddCommMonoid N₃] [Module R N₃]
    (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : N₁ ≃ₗ[R] N₂) (e₃ : M₂ ≃ₗ[R] M₃) (e₄ : N₂ ≃ₗ[R] N₃) :
    (arrowCongr e₁ e₂).trans (arrowCongr e₃ e₄) = arrowCongr (e₁.trans e₃) (e₂.trans e₄)
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
protected theorem div_zero (n : ZNum) : n / 0 = 0
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma isIso_iff_of_hasLeftResolutions [Φ.HasLeftResolutions] {F G : D₂ ⥤ H} (α : F ⟶ G) :
    IsIso α ↔ ∀ (X₁ : C₁), IsIso (α.app (L₂.obj (Φ.functor.obj X₁)))
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsRelPrime.prod_right : (∀ i ∈ t, IsRelPrime x (s i)) → IsRelPrime x (∏ i ∈ t, s i)
-- Mathlib/Data/Set/NAry.lean
theorem image_subset_image2_left (hb : b ∈ t) : (fun a => f a b) '' s ⊆ image2 f s t
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem coeff_smul {S : Type*} [Semiring S] [Module R S] (n : ℕ) (φ : PowerSeries S) (a : R) :
    coeff S n (a • φ) = a • coeff S n φ
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem le_nhds_iff_adhp_of_cauchy {f : Filter α} {x : α} (hf : Cauchy f) :
    f ≤ 𝓝 x ↔ ClusterPt x f
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem or_iff_left_of_imp  (hb : b → a) : (a ∨ b) ↔ a
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem compl_union (s t : Finset α) : (s ∪ t)ᶜ = sᶜ ∩ tᶜ
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp]
theorem mk'_eq_coe {l u : ι → ℝ} : mk' l u = I ↔ l = I.lower ∧ u = I.upper
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- The function `UniformFun.filter α β : Filter (β × β) → Filter ((α →ᵤ β) × (α →ᵤ β))`
has a lower adjoint `l` (in the sense of `GaloisConnection`). The exact definition of `l` is not
interesting; we will only use that it exists (in `UniformFun.mono` and
`UniformFun.iInf_eq`) and that
`l (Filter.map (Prod.map f f) 𝓕) = Filter.map (Prod.map ((∘) f) ((∘) f)) (l 𝓕)` for each
`𝓕 : Filter (γ × γ)` and `f : γ → α` (in `UniformFun.comap_eq`). -/
protected theorem gc : GaloisConnection lowerAdjoint fun 𝓕 => UniformFun.filter α β 𝓕
-- Mathlib/Data/List/Lattice.lean
@[simp]
theorem cons_bagInter_of_pos (l₁ : List α) (h : a ∈ l₂) :
    (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
theorem prod_nat_mod (s : Multiset ℕ) (n : ℕ) : s.prod % n = (s.map (· % n)).prod % n
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumLexAssoc_symm_apply_inr_inr : (sumLexAssoc α β γ).symm (inr (inr c)) = inr c
-- Mathlib/Order/Heyting/Hom.lean
theorem toFun_eq_coe {f : CoheytingHom α β} : f.toFun = (f : α → β)
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem head_eval (v) : head.eval v = pure [v.headI]
-- Mathlib/Data/Nat/Nth.lean
theorem nth_lt_nth (hf : (setOf p).Infinite) {k n} : nth p k < nth p n ↔ k < n
-- Mathlib/Data/Vector/Defs.lean
/-- Vector of length from a list `v`
with witness that `v` has length `n` maps to `v` under `toList`.  -/
@[simp]
theorem toList_mk (v : List α) (P : List.length v = n) : toList (Subtype.mk v P) = v
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
/-- A characterization of `enumOrd`: it is the unique strict monotonic function with range `S`. -/
theorem eq_enumOrd (f : Ordinal → Ordinal) (hS : Unbounded (· < ·) S) :
    StrictMono f ∧ range f = S ↔ f = enumOrd S
-- Mathlib/Topology/Gluing.lean
theorem ι_injective (i : D.J) : Function.Injective (𝖣.ι i)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
/-- The isomorphism `S.X₂ ≅ S.X₁ ⊞ S.X₃` induced by a splitting of the short complex `S`. -/
@[simps]
noncomputable def isoBinaryBiproduct (h : Splitting S) [HasBinaryBiproduct S.X₁ S.X₃] :
    S.X₂ ≅ S.X₁ ⊞ S.X₃
-- Mathlib/Logic/Basic.lean
theorem ite_eq_iff' : ite P a b = c ↔ (P → a = c) ∧ (¬P → b = c)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_lt_one_iff' {x y : ℝ} (hx : 0 ≤ x) (hy : 0 < y) :
    x ^ y < 1 ↔ x < 1
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma hasHomology_of_epi_of_isIso_of_mono' (φ : S₁ ⟶ S₂) [HasHomology S₂]
    [Epi φ.τ₁] [IsIso φ.τ₂] [Mono φ.τ₃] : HasHomology S₁
-- Mathlib/Analysis/Complex/RemovableSingularity.lean
theorem differentiableOn_dslope {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ 𝓝 c) :
    DifferentiableOn ℂ (dslope f c) s ↔ DifferentiableOn ℂ f s
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem mem_valuationSubring_iff (x : K) : x ∈ v.valuationSubring ↔ v x ≤ 1
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[simp]
theorem cokernelIsoOfEq_trans {f g h : X ⟶ Y} [HasCokernel f] [HasCokernel g] [HasCokernel h]
    (w₁ : f = g) (w₂ : g = h) :
    cokernelIsoOfEq w₁ ≪≫ cokernelIsoOfEq w₂ = cokernelIsoOfEq (w₁.trans w₂)
-- Mathlib/Data/Finset/Sups.lean
theorem image_sup_product (s t : Finset α) : (s ×ˢ t).image (uncurry (· ⊔ ·)) = s ⊻ t
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem sumArrowLequivProdArrow_symm_apply_inl {α β} (f : α → M) (g : β → M) (a : α) :
    ((sumArrowLequivProdArrow α β R M).symm (f, g)) (Sum.inl a) = f a
-- Mathlib/Algebra/Lie/OfAssociative.lean
@[simp]
theorem toLieEquiv_apply (x : A₁) : e.toLieEquiv x = e x
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem map_one : (1 : FractionalIdeal S P).map g = 1
-- Mathlib/Data/Matroid/Map.lean
lemma comapOn_base_iff_of_surjOn (h : SurjOn f E N.E) :
    (N.comapOn E f).Base B ↔ (N.Base (f '' B) ∧ InjOn f B ∧ B ⊆ E)
-- Mathlib/Analysis/Normed/Group/Quotient.lean
theorem isGLB_quotient_norm {S : AddSubgroup M} (x : M ⧸ S) :
    IsGLB (norm '' { m | mk' S m = x }) (‖x‖)
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
@[reassoc (attr := simp)]
theorem PInfty_f_idem (n : ℕ) : (PInfty.f n : X _[n] ⟶ _) ≫ PInfty.f n = PInfty.f n
-- Mathlib/Topology/Baire/Lemmas.lean
/-- A set is residual (comeagre) if and only if it includes a dense `Gδ` set. -/
theorem mem_residual {s : Set X} : s ∈ residual X ↔ ∃ t ⊆ s, IsGδ t ∧ Dense t
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
@[simp]
theorem _root_.AffineIsometry.angle_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂]
    [InnerProductSpace ℝ V₂] [MetricSpace P₂] [NormedAddTorsor V₂ P₂]
    (f : P →ᵃⁱ[ℝ] P₂) (p₁ p₂ p₃ : P) : ∠ (f p₁) (f p₂) (f p₃) = ∠ p₁ p₂ p₃
-- Mathlib/Order/Lattice.lean
@[simp]
theorem left_eq_inf : a = a ⊓ b ↔ a ≤ b
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem differentiableOn_univ : DifferentiableOn 𝕜 f univ ↔ Differentiable 𝕜 f
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- The restriction of a regular measure to a set of finite measure is regular. -/
theorem restrict_of_measure_ne_top [R1Space α] [BorelSpace α] [Regular μ]
    {A : Set α} (h'A : μ A ≠ ∞) : Regular (μ.restrict A)
-- Mathlib/Topology/Separation.lean
theorem inseparable_iff_eq [T0Space X] {x y : X} : Inseparable x y ↔ x = y
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem unop_sSup (S : Set (Subring Rᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S)
-- Mathlib/Algebra/Associated/Basic.lean
theorem irreducible_iff_prime [DecompositionMonoid α] {a : α} : Irreducible a ↔ Prime a
-- Mathlib/Algebra/PUnitInstances/Algebra.lean
@[simp]
theorem norm_unit_eq {x : PUnit} : normUnit x = 1
-- Mathlib/Algebra/Star/StarRingHom.lean
@[ext]
theorem ext {f g : A →⋆ₙ+* B} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem vars_mul [DecidableEq σ] (φ ψ : MvPolynomial σ R) : (φ * ψ).vars ⊆ φ.vars ∪ ψ.vars
-- Mathlib/Topology/MetricSpace/Cauchy.lean
/-- A Cauchy sequence on the natural numbers is bounded. -/
theorem cauchySeq_bdd {u : ℕ → α} (hu : CauchySeq u) : ∃ R > 0, ∀ m n, dist (u m) (u n) < R
-- Mathlib/Topology/Sets/Compacts.lean
theorem carrier_eq_coe (s : NonemptyCompacts α) : s.carrier = s
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
/-- Two finite-dimensional topological vector spaces over a complete normed field are continuously
linearly equivalent if and only if they have the same (finite) dimension. -/
theorem FiniteDimensional.nonempty_continuousLinearEquiv_iff_finrank_eq :
    Nonempty (E ≃L[𝕜] F) ↔ finrank 𝕜 E = finrank 𝕜 F
-- Mathlib/CategoryTheory/Preadditive/Projective.lean
theorem iso_iff {P Q : C} (i : P ≅ Q) : Projective P ↔ Projective Q
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_mono {m₁ m₂ : ι} (hm : m₁ ≤ m₂) : hitting u s n m₁ ω ≤ hitting u s n m₂ ω
-- Mathlib/Data/Rat/Defs.lean
lemma intCast_injective : Injective (Int.cast : ℤ → ℚ)
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (p : P) :
    dualTensorHom R N P (g ⊗ₜ[R] p) ∘ₗ dualTensorHom R M N (f ⊗ₜ[R] n) =
      g n • dualTensorHom R M P (f ⊗ₜ p)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- If a monotone sequence of functions has an upper bound and the sequence of integrals of these
functions tends to the integral of the upper bound, then the sequence of functions converges
almost everywhere to the upper bound. -/
lemma tendsto_of_integral_tendsto_of_monotone {μ : Measure α} {f : ℕ → α → ℝ} {F : α → ℝ}
    (hf_int : ∀ n, Integrable (f n) μ) (hF_int : Integrable F μ)
    (hf_tendsto : Tendsto (fun i ↦ ∫ a, f i a ∂μ) atTop (𝓝 (∫ a, F a ∂μ)))
    (hf_mono : ∀ᵐ a ∂μ, Monotone (fun i ↦ f i a))
    (hf_bound : ∀ᵐ a ∂μ, ∀ i, f i a ≤ F a) :
    ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F a))
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
-- Porting note: had to add an extra coercion arrow on the right hand side.
theorem coe_quotQuotEquivQuotOfLEₐ_symm (h : I ≤ J) :
    ⇑(quotQuotEquivQuotOfLEₐ R h).symm = ⇑(quotQuotEquivQuotOfLE h).symm
-- Mathlib/CategoryTheory/Adjunction/AdjointFunctorTheorems.lean
/-- The special adjoint functor theorem: if `G : D ⥤ C` preserves limits and `D` is complete,
well-powered and has a small coseparating set, then `G` has a left adjoint.
-/
lemma isRightAdjoint_of_preservesLimits_of_isCoseparating [HasLimits D] [WellPowered D]
    {𝒢 : Set D} [Small.{v} 𝒢] (h𝒢 : IsCoseparating 𝒢) (G : D ⥤ C) [PreservesLimits G] :
    G.IsRightAdjoint
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
protected lemma comp {R₁ R₂ R₃ A : Type*} [Semifield R₁] [Field R₂] [Field R₃]
    [NonUnitalRing A] [Module R₁ A] [Module R₂ A] [Module R₃ A] [Algebra R₁ R₂] [Algebra R₂ R₃]
    [Algebra R₁ R₃] [IsScalarTower R₁ R₂ R₃] [IsScalarTower R₂ R₃ A] [IsScalarTower R₃ A A]
    [SMulCommClass R₃ A A] {a : A} {f : R₃ → R₂} {g : R₂ → R₁} {e : R₃ → R₁} (hfge : g ∘ f = e)
    (hf : QuasispectrumRestricts a f) (hg : QuasispectrumRestricts a g) :
    QuasispectrumRestricts a e
-- Mathlib/RingTheory/Trace/Basic.lean
/--
The dual basis of a powerbasis `{1, x, x²...}` under the trace form is `aᵢ / f'(x)`,
with `f` being the minimal polynomial of `x` and `f / (X - x) = ∑ aᵢxⁱ`.
-/
lemma traceForm_dualBasis_powerBasis_eq [FiniteDimensional K L] [Algebra.IsSeparable K L]
    (pb : PowerBasis K L) (i) :
    (Algebra.traceForm K L).dualBasis (traceForm_nondegenerate K L) pb.basis i =
      (minpolyDiv K pb.gen).coeff i / aeval pb.gen (derivative <| minpoly K pb.gen)
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
lemma exactAt_iff :
    K.ExactAt i ↔ (K.sc i).Exact
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `balLeft` function preserves the ordering invariants. -/
protected theorem Ordered.balLeft {l : RBNode α} {v : α} {r : RBNode α}
    (lv : l.All (cmpLT cmp · v)) (vr : r.All (cmpLT cmp v ·))
    (hl : l.Ordered cmp) (hr : r.Ordered cmp) : (balLeft l v r).Ordered cmp
-- Mathlib/CategoryTheory/Functor/OfSequence.lean
@[reassoc]
lemma map_comp (i j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k) :
    map f i k (hij.trans hjk) = map f i j hij ≫ map f j k hjk
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp] theorem congr_refl_refl : congr (.refl R M) (.refl R N) = .refl R _
-- Mathlib/RingTheory/Generators.lean
lemma Cotangent.mk_surjective : Function.Surjective (mk (P := P))
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem toLinearPMap_graph_eq (g : Submodule R (E × F))
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) :
    g.toLinearPMap.graph = g
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem opNorm_le_iff {f : E →SL[σ₁₂] F} {M : ℝ} (hMp : 0 ≤ M) :
    ‖f‖ ≤ M ↔ ∀ x, ‖f x‖ ≤ M * ‖x‖
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma norm_term_le_of_re_le_re (f : ℕ → ℂ) {s s' : ℂ} (h : s.re ≤ s'.re) (n : ℕ) :
    ‖term f s' n‖ ≤ ‖term f s n‖
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem Differentiable.dist (hf : Differentiable ℝ f) (hg : Differentiable ℝ g)
    (hne : ∀ x, f x ≠ g x) : Differentiable ℝ fun y => dist (f y) (g y)
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem not_cliqueFree_card_of_top_embedding [Fintype α] (f : (⊤ : SimpleGraph α) ↪g G) :
    ¬G.CliqueFree (card α)
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem coe_injective : Function.Injective ((↑) : (M₁ →SL[σ₁₂] M₂) → M₁ →ₛₗ[σ₁₂] M₂)
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem succ'_pred' (n) : succ' (pred' n) = n
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem deriv_eq_derivFamily (f : Ordinal → Ordinal) : deriv f = derivFamily fun _ : Unit => f
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
protected theorem HasFPowerSeriesAt.deriv (h : HasFPowerSeriesAt f p x) :
    deriv f x = p 1 fun _ => 1
-- Mathlib/Logic/Function/Basic.lean
theorem ne_iff {β : α → Sort*} {f₁ f₂ : ∀ a, β a} : f₁ ≠ f₂ ↔ ∃ a, f₁ a ≠ f₂ a
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem ofConjAct_mul (x y : ConjAct G) : ofConjAct (x * y) = ofConjAct x * ofConjAct y
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
lemma Triangle.eqToHom_hom₁ {A B : Triangle C} (h : A = B) :
    (eqToHom h).hom₁ = eqToHom (by subst h; rfl)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp]
theorem log2_zero : Nat.log2 0 = 0
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIoc_subset_uIoc_of_uIcc_subset_uIcc {a b c d : α}
    (h : [[a, b]] ⊆ [[c, d]]) : Ι a b ⊆ Ι c d
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem dualPairing_apply (v x) : dualPairing R M v x = v x
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation scales the diameter of the range by `ratio f`. -/
theorem ediam_range : EMetric.diam (range (f : α → β)) = ratio f * EMetric.diam (univ : Set α)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem isUnit_zero_iff : IsUnit (0 : M₀) ↔ (0 : M₀) = 1
-- Mathlib/Data/Fin/Basic.lean
protected theorem prop (a : Fin n) : a.val < n
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
theorem isoPullback_inv_fst (h : IsPullback fst snd f g) [HasPullback f g] :
    h.isoPullback.inv ≫ fst = pullback.fst _ _
-- Mathlib/Data/Matrix/Block.lean
theorem blockDiagonal'_apply' (M : ∀ i, Matrix (m' i) (n' i) α) (k i k' j) :
    blockDiagonal' M ⟨k, i⟩ ⟨k', j⟩ =
      if h : k = k' then M k i (cast (congr_arg n' h.symm) j) else 0
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem sInf_coe (P : Set (Submodule R M)) : (↑(sInf P) : Set M) = ⋂ p ∈ P, ↑p
-- Mathlib/RingTheory/Localization/Away/Basic.lean
lemma away_of_isIdempotentElem {R S} [CommRing R] [CommRing S] [Algebra R S]
    {e : R} (he : IsIdempotentElem e)
    (H : RingHom.ker (algebraMap R S) = Ideal.span {1 - e})
    (H' : Function.Surjective (algebraMap R S)) :
    IsLocalization.Away e S
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem toFunLinear_mul_tmul_mul_aux_2 (k : ℕ) (a₁ a₂ : A) (p₁ p₂ : R[X]) :
    a₁ * a₂ * (algebraMap R A) ((p₁ * p₂).coeff k) =
      (Finset.antidiagonal k).sum fun x =>
        a₁ * (algebraMap R A) (coeff p₁ x.1) * (a₂ * (algebraMap R A) (coeff p₂ x.2))
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
@[simp]
theorem isHermitian_conjTranspose_iff (A : Matrix n n α) : Aᴴ.IsHermitian ↔ A.IsHermitian
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma inrCompHomotopy_hom_desc_hom (hc : ∀ j, ∃ i, c.Rel i j) (i j : ι) :
    (inrCompHomotopy φ hc).hom i j ≫ (desc φ α hα).f j = hα.hom i j
-- Mathlib/Data/Finset/Prod.lean
theorem offDiag_filter_lt_eq_filter_le {ι}
    [PartialOrder ι] [DecidableEq ι]
    [DecidableRel (LE.le (α := ι))] [DecidableRel (LT.lt (α := ι))]
    (s : Finset ι) :
    s.offDiag.filter (fun i => i.1 < i.2) = s.offDiag.filter (fun i => i.1 ≤ i.2)
-- Mathlib/Data/Stream/Init.lean
@[ext]
protected theorem ext {s₁ s₂ : Stream' α} : (∀ n, get s₁ n = get s₂ n) → s₁ = s₂
-- Mathlib/Data/Set/NAry.lean
theorem image2_union_right : image2 f s (t ∪ t') = image2 f s t ∪ image2 f s t'
-- Mathlib/LinearAlgebra/DFinsupp.lean
@[simp]
theorem mapRange.linearMap_id :
    (mapRange.linearMap fun i => (LinearMap.id : β₂ i →ₗ[R] _)) = LinearMap.id
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem USize.toNat_mul (x y : USize) : (x * y).toNat = (x.toNat * y.toNat) % USize.size
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma aeval_val_σ (s) : aeval P.val (P.σ s) = s
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem single_zero_smul_coeff {Γ} [OrderedAddCommMonoid Γ] [AddAction Γ Γ']
    [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
    {x : HahnModule Γ' R V} {a : Γ'} :
    ((of R).symm ((HahnSeries.single 0 r : HahnSeries Γ R) • x)).coeff a =
    r • ((of R).symm x).coeff a
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem AEMeasurable.nnnorm {f : β → α} {μ : Measure β} (hf : AEMeasurable f μ) :
    AEMeasurable (fun a => ‖f a‖₊) μ
-- Mathlib/Order/Filter/Cofinite.lean
theorem Filter.Tendsto.exists_within_forall_ge [LinearOrder β] {s : Set α} (hs : s.Nonempty)
    {f : α → β} (hf : Filter.Tendsto f Filter.cofinite Filter.atBot) :
    ∃ a₀ ∈ s, ∀ a ∈ s, f a ≤ f a₀
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem sizeUpTo_ofLength_le (i : ℕ) (h : c.length ≤ i) : c.sizeUpTo i = n
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma compl_subset_compl : sᶜ ⊆ tᶜ ↔ t ⊆ s
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
@[reassoc (attr := simp)]
theorem section_comp_right (f g : A ⟶ B) [IsReflexivePair f g] : commonSection f g ≫ g = 𝟙 B
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
lemma isClique_insert_of_not_mem (ha : a ∉ s) :
    G.IsClique (insert a s) ↔ G.IsClique s ∧ ∀ b ∈ s, G.Adj a b
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
@[simp]
theorem cpow_zero (x : ℂ) : x ^ (0 : ℂ) = 1
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_re_eq_norm (x : E) : re ⟪x, x⟫ = ‖⟪x, x⟫‖
-- Mathlib/Tactic/NormNum/Eq.lean
theorem isRat_eq_false [Ring α] [CharZero α] : {a b : α} → {na nb : ℤ} → {da db : ℕ} →
    IsRat a na da → IsRat b nb db →
    decide (Int.mul na (.ofNat db) = Int.mul nb (.ofNat da)) = false → ¬a = b
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem le_of_mul_le_mul_left {a b c : Int} (w : a * b ≤ a * c) (h : 0 < a) : b ≤ c
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma le_traceDual_comm {I J : Submodule B L} :
    I ≤ Jᵛ ↔ J ≤ Iᵛ
-- Mathlib/Logic/Relation.lean
theorem Reflexive.comap (h : Reflexive r) (f : α → β) : Reflexive (r on f)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigO_abs_right : (f =O[l] fun x => |u x|) ↔ f =O[l] u
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
@[simp]
theorem deriv_neg' : deriv (Neg.neg : 𝕜 → 𝕜) = fun _ => -1
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map_rightInverse_iff {f : α → β} {g : β → α} :
    RightInverse (map f) (map g) ↔ RightInverse f g
-- Mathlib/LinearAlgebra/QuadraticForm/IsometryEquiv.lean
@[refl]
theorem refl (Q : QuadraticMap R M N) : Q.Equivalent Q
-- Mathlib/Data/Option/Basic.lean
theorem bind_eq_some' {x : Option α} {f : α → Option β} {b : β} :
    x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_le_rpow_of_exponent_ge {x : ℝ≥0} {y z : ℝ} (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z
-- Mathlib/Order/Filter/Basic.lean
theorem univ_mem' (h : ∀ a, a ∈ s) : s ∈ f
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
/-- Premature version of the lemma. Prefer using `left_invariant` instead. -/
theorem left_invariant' :
    𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt (1 : G) ↑X) = Derivation.evalAt g ↑X
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem leftInvSeq_concat (ω : List B) (i : B) :
    lis (ω.concat i) = (lis ω).concat ((π ω) * (s i) * (π ω)⁻¹)
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem hasFiniteIntegral_prod_iff' ⦃f : α × β → E⦄ (h1f : AEStronglyMeasurable f (μ.prod ν)) :
    HasFiniteIntegral f (μ.prod ν) ↔
      (∀ᵐ x ∂μ, HasFiniteIntegral (fun y => f (x, y)) ν) ∧
        HasFiniteIntegral (fun x => ∫ y, ‖f (x, y)‖ ∂ν) μ