ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem subperm_cons_diff {a : α} {l₁ l₂ : List α} : (a :: l₁).diff l₂ <+~ a :: l₁.diff l₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pred_inj : ∀ {a b}, 0 < a → 0 < b → pred a = pred b → a = b
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_sigma {p : β → Type*} {f : Sigma p → α} : ⨆ x, f x = ⨆ (i) (j), f ⟨i, j⟩
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem ContDiffAt.csin {n} (hf : ContDiffAt ℂ n f x) :
    ContDiffAt ℂ n (fun x => Complex.sin (f x)) x
-- Mathlib/RingTheory/Adjoin/Basic.lean
@[simp]
theorem adjoin_adjoin_coe_preimage {s : Set A} : adjoin R (((↑) : adjoin R s → A) ⁻¹' s) = ⊤
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_ofReal_re (x : F) : (re ⟪x, x⟫ : 𝕜) = ⟪x, x⟫
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
-- Mathlib/Data/Real/Archimedean.lean
theorem iSup_of_not_bddAbove {α : Sort*} {f : α → ℝ} (hf : ¬BddAbove (Set.range f)) :
    ⨆ i, f i = 0
-- Mathlib/Algebra/Group/Subgroup/Actions.lean
@[to_additive (attr := simp)]
lemma mk_smul (g : G) (hg : g ∈ S) (a : α) : (⟨g, hg⟩ : S) • a = g • a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean
@[simp]
theorem contDiffAt_tan {x : ℂ} {n : ℕ∞} : ContDiffAt ℂ n tan x ↔ cos x ≠ 0
-- Mathlib/Data/Analysis/Filter.lean
/-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
-- Mathlib/NumberTheory/VonMangoldt.lean
theorem vonMangoldt_sum {n : ℕ} : ∑ i ∈ n.divisors, Λ i = Real.log n
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem inr_apply [Module R₁ M₂] (x : M₂) : inr R₁ M₁ M₂ x = (0, x)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem append_ne_nil_of_left_ne_nil (a b : List α) (h0 : a ≠ []) : a ++ b ≠ []
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem IsCompl.prod_mul_prod {s t : Finset α} (h : IsCompl s t) (f : α → β) :
    (∏ i ∈ s, f i) * ∏ i ∈ t, f i = ∏ i, f i
-- Mathlib/Dynamics/PeriodicPts.lean
theorem isPeriodicPt_iff_minimalPeriod_dvd : IsPeriodicPt f n x ↔ minimalPeriod f x ∣ n
-- Mathlib/Computability/TMToPartrec.lean
theorem tr_copy (q) : tr (Λ'.copy q) = pop' rev (branch Option.isSome
    (push' main <| push' stack <| goto fun _ => Λ'.copy q) (goto fun _ => q))
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[reassoc (attr := simp)]
theorem sheafifyMap_sheafifyLift {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R)
    (hR : Presheaf.IsSheaf J R) :
    J.sheafifyMap η ≫ J.sheafifyLift γ hR = J.sheafifyLift (η ≫ γ) hR
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem hasColimits_of_hasLimits_op [HasLimits Cᵒᵖ] : HasColimits C
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp, reassoc]
theorem limitIsoLimitCurryCompLim_hom_π_π {j} {k} :
    (limitIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k = limit.π _ (j, k)
-- Mathlib/Order/Basic.lean
theorem exists_ge_of_linear [LinearOrder α] (a b : α) : ∃ c, a ≤ c ∧ b ≤ c
-- Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean
/-- The auxiliary continuants before the squashed position stay the same. -/
theorem contsAux_eq_contsAux_squashGCF_of_le {m : ℕ} :
    m ≤ n → contsAux g m = (squashGCF g n).contsAux m
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] theorem negSucc_mul_ofNat (m n : Nat) : -[m+1] * n = -↑(succ m * n)
-- Mathlib/Data/List/Basic.lean
theorem length_eq_length_filter_add {l : List (α)} (f : α → Bool) :
    l.length = (l.filter f).length + (l.filter (! f ·)).length
-- Mathlib/Data/Set/Basic.lean
protected theorem ext_iff {s t : Set α} : s = t ↔ ∀ x, x ∈ s ↔ x ∈ t
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem prod_eq_foldr : ∀ {l : List M}, l.prod = foldr (· * ·) 1 l
-- Mathlib/Data/Set/Lattice.lean
theorem setOf_forall (p : ι → β → Prop) : { x | ∀ i, p i x } = ⋂ i, { x | p i x }
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- The circumradius of a simplex with at least two points is
positive. -/
theorem circumradius_pos {n : ℕ} (s : Simplex ℝ P (n + 1)) : 0 < s.circumradius
-- Mathlib/Order/Bounded.lean
theorem bounded_le_inter_le [LinearOrder α] (a : α) :
    Bounded (· ≤ ·) (s ∩ { b | a ≤ b }) ↔ Bounded (· ≤ ·) s
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem piCongr_apply_apply (f : ∀ a, W a) (a : α) : h₁.piCongr h₂ f (h₁ a) = h₂ a (f a)
-- Mathlib/Computability/ContextFreeGrammar.lean
/-- Add extra postfix to context-free producing. -/
lemma Produces.append_right {v w : List (Symbol T g.NT)}
    (hvw : g.Produces v w) (p : List (Symbol T g.NT)) :
    g.Produces (v ++ p) (w ++ p)
-- Mathlib/CategoryTheory/Triangulated/Functor.lean
lemma map_distinguished [F.IsTriangulated] (T : Triangle C) (hT : T ∈ distTriang C) :
    F.mapTriangle.obj T ∈ distTriang D
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
-- Mathlib/Analysis/Convolution.lean
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem _root_.BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
/-- One can bound the `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`,
in terms of integrals of iterated derivatives of `f` (of order up to `n`) multiplied by `‖v‖ ^ i`
(for `i ≤ k`).
Auxiliary version in terms of the operator norm of `fourierPowSMulRight (-L.flip) ⬝`. For a version
in terms of `|L v w| ^ n * ⬝`, see `pow_mul_norm_iteratedFDeriv_fourierIntegral_le`.
-/
theorem norm_fourierPowSMulRight_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) {w : W} :
    ‖fourierPowSMulRight (-L.flip)
      (iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w n‖ ≤
    (2 * π) ^ k * (2 * k + 2) ^ n * ‖L‖ ^ k * ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
      ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ
-- Mathlib/Data/Matrix/Kronecker.lean
theorem diagonal_kronecker [MulZeroClass α] [DecidableEq l] (a : l → α) (B : Matrix m n α) :
    diagonal a ⊗ₖ B =
      Matrix.reindex (Equiv.prodComm _ _) (Equiv.prodComm _ _) (blockDiagonal fun i => a i • B)
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem algebraMap_apply (x : ℤ_[p]) : algebraMap ℤ_[p] ℚ_[p] x = x
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_diagonal_diagonal [Zero α] [Zero β] [Zero γ] [DecidableEq m] [DecidableEq n]
    (f : α → β → γ) (hf₁ : ∀ b, f 0 b = 0) (hf₂ : ∀ a, f a 0 = 0) (a : m → α) (b : n → β) :
    kroneckerMap f (diagonal a) (diagonal b) = diagonal fun mn => f (a mn.1) (b mn.2)
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma traceForm_eq_of_le_idealizer :
    traceForm R I N = (traceForm R L M).restrict I
-- Mathlib/Analysis/RCLike/Basic.lean
@[continuity]
theorem continuous_conj : Continuous (conj : K → K)
-- Mathlib/Data/Multiset/Basic.lean
theorem count_eq_card {a : α} {s} : count a s = card s ↔ ∀ x ∈ s, a = x
-- Mathlib/Data/Fin/Basic.lean
theorem lt_succ_castPred_iff {a b : Fin (n + 1)} (ha : a ≠ last n) :
    b < succ (a.castPred ha) ↔ b ≤ a
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
@[simp]
theorem psum_zero : psum σ R 0 = Fintype.card σ
-- Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
/-- The reduction modulo `p` of the minimal polynomial of a root of unity `μ` is squarefree. -/
theorem squarefree_minpoly_mod {p : ℕ} [Fact p.Prime] (hdiv : ¬p ∣ n) :
    Squarefree (map (Int.castRingHom (ZMod p)) (minpoly ℤ μ))
-- Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean
/-- `log` is analytic away from nonpositive reals -/
theorem analyticAt_clog (m : z ∈ slitPlane) : AnalyticAt ℂ log z
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
theorem comul_tensorObj_tensorObj_right :
    Coalgebra.comul (R := R) (A := (CoalgebraCat.of R M ⊗
      (CoalgebraCat.of R N ⊗ CoalgebraCat.of R P) : CoalgebraCat R))
      = Coalgebra.comul (A := M ⊗[R] N ⊗[R] P)
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma comp_le_comp : comp a ≤ comp b ↔ b ≤ a
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isRat_pow {α} [Ring α] {f : α → ℕ → α} {a : α} {an cn : ℤ} {ad b b' cd : ℕ} :
    f = HPow.hPow → IsRat a an ad → IsNat b b' →
    Int.pow an b' = cn → Nat.pow ad b' = cd →
    IsRat (f a b) cn cd
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem StrictAnti.mul_const [MulPosStrictMono α]
    (hf : StrictAnti f) (ha : 0 < a) : StrictAnti fun x => f x * a
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_zero : fract (0 : α) = 0
-- Mathlib/CategoryTheory/Category/PartialFun.lean
/-- Constructs a partial function isomorphism between types from an equivalence between them. -/
@[simps]
def Iso.mk {α β : PartialFun.{u}} (e : α ≃ β) : α ≅ β
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem smul_of [SMul R α] (r : R) (f : m → n → α) : r • of f = of (r • f)
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem toWord_inv {x : FreeGroup α} : x⁻¹.toWord = invRev x.toWord
-- Mathlib/Analysis/Convex/Complex.lean
theorem convex_halfspace_re_gt (r : ℝ) : Convex ℝ { c : ℂ | r < c.re }
-- Mathlib/Dynamics/PeriodicPts.lean
@[simp]
theorem self_mem_periodicOrbit (hx : x ∈ periodicPts f) : x ∈ periodicOrbit f x
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem mem_inter : a ∈ s ∩ t ↔ a ∈ s ∧ a ∈ t
-- Mathlib/Probability/Process/Stopping.lean
theorem add_const_nat {f : Filtration ℕ m} {τ : Ω → ℕ} (hτ : IsStoppingTime f τ) {i : ℕ} :
    IsStoppingTime f fun ω => τ ω + i
-- Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean
/-- The resolution maps intertwine the lift of a morphism and that morphism. -/
@[reassoc (attr := simp)]
theorem lift_commutes {Y Z : C} (f : Y ⟶ Z) (P : ProjectiveResolution Y)
    (Q : ProjectiveResolution Z) : lift f P Q ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem limit.map_pre [HasLimitsOfShape K C] (E : K ⥤ J) :
    lim.map α ≫ limit.pre G E = limit.pre F E ≫ lim.map (whiskerLeft E α)
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
theorem IsColimit.descCoconeMorphism_eq_isInitial_to {F : J ⥤ C} {c : Cocone F} (hc : IsColimit c)
    (s : Cocone F) :
    hc.descCoconeMorphism s = IsInitial.to (Cocone.isColimitEquivIsInitial _ hc) _
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem map_pure (f : α →o β) (a : α) : (pure a).map f = pure (f a)
-- Mathlib/Topology/Category/Profinite/Basic.lean
theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_lt_nat {o} {n : ℕ} : card o < n ↔ o < n
-- Mathlib/RingTheory/Artinian.lean
/-- Any injective endomorphism of an Artinian module is bijective. -/
theorem bijective_of_injective_endomorphism (f : M →ₗ[R] M) (s : Injective f) : Bijective f
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma closure_eq_lowerClosure {s : Set α} : closure s = lowerClosure s
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem coe_coe (u : (𝓞 K)ˣ) : ((u : 𝓞 K) : K) = (u : K)
-- Mathlib/Topology/Order.lean
theorem le_generateFrom_iff_subset_isOpen {g : Set (Set α)} {t : TopologicalSpace α} :
    t ≤ generateFrom g ↔ g ⊆ { s | IsOpen[t] s }
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Group R] : ↑(Grp.of R) = R
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem range_comp_le_range (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C) :
    NonUnitalAlgHom.range (g.comp f) ≤ NonUnitalAlgHom.range g
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc (attr := simp)]
theorem pentagon_inv_hom_hom_hom_inv (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (i : d ⟶ e) :
    (α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i ≫ (α_ f (g ≫ h) i).hom =
      (α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv
-- Mathlib/LinearAlgebra/FreeModule/Basic.lean
/-- A variation of `of_equiv`: the assumption `Module.Free R P` here is explicit rather than an
instance. -/
theorem of_equiv' {P : Type v} [AddCommMonoid P] [Module R P] (_ : Module.Free R P)
    (e : P ≃ₗ[R] N) : Module.Free R N
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.false_and (b : Bool) : (false && b) = false
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Expr.eq_of_toNormPoly_eq (ctx : Context) (e e' : Expr) (h : e.toNormPoly == e'.toPoly) : e.denote ctx = e'.denote ctx
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt64.le_antisymm_iff {x y : UInt64} : x = y ↔ x ≤ y ∧ y ≤ x
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
theorem measure_sUnion_null_iff {S : Set (Set α)} (hS : S.Countable) :
    μ (⋃₀ S) = 0 ↔ ∀ s ∈ S, μ s = 0
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
@[simp]
theorem sphere_zero_right (n k : ℕ) : sphere (n + 1) 0 k = ∅
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
theorem eq_of_mem_ordConnectedSection_of_uIcc_subset (hx : x ∈ ordConnectedSection s)
    (hy : y ∈ ordConnectedSection s) (h : [[x, y]] ⊆ s) : x = y
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Let `f` be an `n` times continuously differentiable homeomorphism of a nontrivially normed
field.  Suppose that the derivative of `f` is never equal to zero. Then `f.symm` is `n` times
continuously differentiable.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. -/
theorem Homeomorph.contDiff_symm_deriv [CompleteSpace 𝕜] (f : 𝕜 ≃ₜ 𝕜) {f' : 𝕜 → 𝕜}
    (h₀ : ∀ x, f' x ≠ 0) (hf' : ∀ x, HasDerivAt f (f' x) x) (hf : ContDiff 𝕜 n (f : 𝕜 → 𝕜)) :
    ContDiff 𝕜 n (f.symm : 𝕜 → 𝕜)
-- Mathlib/Algebra/Quandle.lean
@[simp]
theorem self_invAct_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- The reduction formula for the integral of `cos x ^ n` for any natural `n ≥ 2`. -/
theorem integral_cos_pow :
    (∫ x in a..b, cos x ^ (n + 2)) =
      (cos b ^ (n + 1) * sin b - cos a ^ (n + 1) * sin a) / (n + 2) +
        (n + 1) / (n + 2) * ∫ x in a..b, cos x ^ n
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Reformulation of the uniform structure in terms of the extended distance -/
theorem uniformity_edist : 𝓤 γ = ⨅ ε > 0, 𝓟 { p : γ × γ | edist p.1 p.2 < ε }
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem BoundedLatticeHom.asBoolRing_id : (BoundedLatticeHom.id α).asBoolRing = RingHom.id _
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_lt_add_right {a b : Int} (h : a < b) (c : Int) : a + c < b + c
-- Mathlib/Data/Finset/NoncommProd.lean
@[to_additive]
theorem noncommProd_add (s t : Multiset α) (comm) :
    noncommProd (s + t) comm =
      noncommProd s (comm.mono <| subset_of_le <| s.le_add_right t) *
        noncommProd t (comm.mono <| subset_of_le <| t.le_add_left s)
-- Mathlib/Data/Matroid/Dual.lean
theorem ground_not_base (M : Matroid α) [h : RkPos M✶] : ¬M.Base M.E
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cocone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `colimitOfDiagramInitial` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The finrank of the direct sum is the sum of the finranks. -/
@[simp]
theorem finrank_directSum {ι : Type v} [Fintype ι] (M : ι → Type w) [∀ i : ι, AddCommGroup (M i)]
    [∀ i : ι, Module R (M i)] [∀ i : ι, Module.Free R (M i)] [∀ i : ι, Module.Finite R (M i)] :
    finrank R (⨁ i, M i) = ∑ i, finrank R (M i)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem intervalIntegrable_const_iff {c : E} :
    IntervalIntegrable (fun _ => c) μ a b ↔ c = 0 ∨ μ (Ι a b) < ∞
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem coe_mk (e h₃ h₄) : ⇑(⟨e, h₃, h₄⟩ : R ≃+* S) = e
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem continuous (F : α →𝒄 β) (C : Chain α) : F (ωSup C) = ωSup (C.map F)
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem continuousMul_sInf {ts : Set (TopologicalSpace M)}
    (h : ∀ t ∈ ts, @ContinuousMul M t _) : @ContinuousMul M (sInf ts) _
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem norm_map_eq (A : Matrix m n α) (f : α → β) (hf : ∀ a, ‖f a‖ = ‖a‖) : ‖A.map f‖ = ‖A‖
-- Mathlib/Computability/Partrec.lean
theorem list_ofFn :
    ∀ {n} {f : Fin n → α → σ},
      (∀ i, Computable (f i)) → Computable fun a => List.ofFn fun i => f i a
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem coeff_eq_zero_of_degree_lt (h : degree p < n) : coeff p n = 0
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem one_sub_nonneg (x : Icc (0 : β) 1) : 0 ≤ 1 - (x : β)
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem integral_normed : ∫ x, f.normed μ x ∂μ = 1
-- Mathlib/Order/Filter/Germ/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_pow [Pow G M] (f : α → G) (n : M) : ↑(f ^ n) = (f : Germ l G) ^ n
-- Mathlib/Data/Set/Lattice.lean
theorem sUnion_eq_compl_sInter_compl (S : Set (Set α)) : ⋃₀S = (⋂₀ (compl '' S))ᶜ
-- Mathlib/Data/List/Zip.lean
theorem lt_length_right_of_zip {i : ℕ} {l : List α} {l' : List β} (h : i < (zip l l').length) :
    i < l'.length
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- For any multiplicative function `f` and any `n > 0`,
we can evaluate `f n` by evaluating `f` at `p ^ k` over the factorization of `n` -/
nonrec  -- Porting note: added
theorem multiplicative_factorization [CommMonoidWithZero R] (f : ArithmeticFunction R)
    (hf : f.IsMultiplicative) {n : ℕ} (hn : n ≠ 0) :
    f n = n.factorization.prod fun p k => f (p ^ k)
-- Mathlib/Topology/Algebra/Algebra.lean
theorem ext_ring_iff [TopologicalSpace R] {f g : R →A[R] A} : f = g ↔ f 1 = g 1
-- Mathlib/Order/Cover.lean
theorem CovBy.ne' (h : a ⋖ b) : b ≠ a
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem union_right (ht : AEDisjoint μ s t) (hu : AEDisjoint μ s u) : AEDisjoint μ s (t ∪ u)
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem dvd_of_squarefree_of_mul_dvd_mul_left (hy : Squarefree y) (h : d * d ∣ x * y) : d ∣ x
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Name.lean
@[simp] protected theorem beq_false (m n : Name) : (m == n) = false ↔ ¬ (m = n)
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem doublingGamma_eq_Gamma {s : ℝ} (hs : 0 < s) : doublingGamma s = Gamma s
-- Mathlib/GroupTheory/Perm/Option.lean
@[simp]
theorem Equiv.optionCongr_swap {α : Type*} [DecidableEq α] (x y : α) :
    optionCongr (swap x y) = swap (some x) (some y)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma isIso_toSpec (f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    IsIso (toSpec 𝒜 f)
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Characterization of the elements of the uniformity in terms of the extended distance -/
theorem mem_uniformity_edist {s : Set (α × α)} :
    s ∈ 𝓤 α ↔ ∃ ε > 0, ∀ {a b : α}, edist a b < ε → (a, b) ∈ s
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biprod.inl_map {W X Y Z : C} [HasBinaryBiproduct W X] [HasBinaryBiproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : biprod.inl ≫ biprod.map f g = f ≫ biprod.inl
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- If Cᵒᵖ is cofiltered, then C is filtered. -/
lemma isFiltered_of_isCofiltered_op [IsCofiltered Cᵒᵖ] : IsFiltered C
-- Mathlib/Data/Bool/Basic.lean
lemma self_ne_not : ∀ b : Bool, b ≠ !b
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem zero_opow' (a : Ordinal) : 0 ^ a = 1 - a
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem integrable_add_measure {f : α → β} :
    Integrable f (μ + ν) ↔ Integrable f μ ∧ Integrable f ν
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Integration by parts**. Special case of `integral_mul_deriv_eq_deriv_mul_of_hasDeriv_right`
where the functions have a two-sided derivative in the interior of the interval. -/
theorem integral_mul_deriv_eq_deriv_mul_of_hasDerivAt {u v u' v' : ℝ → A}
    (hu : ContinuousOn u [[a, b]])
    (hv : ContinuousOn v [[a, b]])
    (huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivAt u (u' x) x)
    (hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivAt v (v' x) x)
    (hu' : IntervalIntegrable u' volume a b)
    (hv' : IntervalIntegrable v' volume a b) :
    ∫ x in a..b, u x * v' x = u b * v b - u a * v a - ∫ x in a..b, u' x * v x
-- Mathlib/NumberTheory/LSeries/Convolution.lean
@[simp]
lemma convolution_map_zero {R : Type*} [Semiring R] (f g : ℕ → R) : (f ⍟ g) 0 = 0
-- Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean
theorem is_ideal_adic_pow {J : Ideal R} (h : IsAdic J) {n : ℕ} (hn : 0 < n) : IsAdic (J ^ n)
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem lift_aux (x : L) : ∃ y : ℕ × K, i y.2 = x ^ p ^ y.1
-- Mathlib/Algebra/Category/ModuleCat/Simple.lean
/-- Any `k`-algebra module which is 1-dimensional over `k` is simple. -/
theorem simple_of_finrank_eq_one {k : Type*} [Field k] [Algebra k R] {V : ModuleCat R}
    (h : finrank k V = 1) : Simple V
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp, norm_cast]
theorem val_add (x y : s) : (↑(x + y) : R) = ↑x + ↑y
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.sup (h : f' =Θ[l] g') (h' : f' =Θ[l'] g') : f' =Θ[l ⊔ l'] g'
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
@[deprecated (since := "2024-04-26")]
theorem toLin'_apply (A : BilinForm R M) (x : M) : toLinHom (M := M) A x = A x
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
/-- The supremum of two subspaces is equal to the span of their union. -/
theorem span_union (S T : Set (ℙ K V)) : span (S ∪ T) = span S ⊔ span T
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[refl, simp] -- Porting note: added `simp`
theorem refl : IntervalIntegrable f μ a a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem cbiSup_eq_of_not_forall {p : ι → Prop} {f : Subtype p → α} (hp : ¬ (∀ i, p i)) :
    ⨆ (i) (h : p i), f ⟨i, h⟩ = iSup f ⊔ sSup ∅
-- Mathlib/Data/Real/EReal.lean
/-- See also `EReal.add_lt_add_of_lt_of_le'` for a version with weaker but less convenient
assumptions. -/
theorem add_lt_add_of_lt_of_le {x y z t : EReal} (h : x < y) (h' : z ≤ t) (hz : z ≠ ⊥)
    (ht : t ≠ ⊤) : x + z < y + t
-- Mathlib/Data/Set/NAry.lean
theorem image2_union_inter_subset_union :
    image2 f (s ∪ s') (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'
-- .lake/packages/lean4/src/lean/Init/Data/AC.lean
theorem Context.evalList_removeNeutrals (ctx : Context α) (e : List Nat) : evalList α ctx (removeNeutrals ctx e) = evalList α ctx e
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem count_cons (a b : α) (l : List α) :
    count a (b :: l) = count a l + if a = b then 1 else 0
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem isBridge_iff_adj_and_forall_walk_mem_edges {v w : V} :
    G.IsBridge s(v, w) ↔ G.Adj v w ∧ ∀ p : G.Walk v w, s(v, w) ∈ p.edges
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem apriori_edist_iterate_efixedPoint_le (hf : ContractingWith K f) {x : α}
    (hx : edist x (f x) ≠ ∞) (n : ℕ) :
    edist (f^[n] x) (efixedPoint f hf x hx) ≤ edist x (f x) * (K : ℝ≥0∞) ^ n / (1 - K)
-- Mathlib/Topology/Inseparable.lean
theorem specializes_of_eq (e : x = y) : x ⤳ y