ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem reachable_of_edist_ne_top (h : G.edist u v ≠ ⊤) :
    G.Reachable u v
-- Mathlib/Probability/Moments.lean
theorem mgf_const (c : ℝ) [IsProbabilityMeasure μ] : mgf (fun _ => c) μ t = exp (t * c)
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = mrange (s.subtype.coprod t.subtype)
-- Mathlib/Order/Bounds/Basic.lean
theorem isLeast_Ici : IsLeast (Ici a) a
-- Mathlib/Data/Set/Basic.lean
theorem inter_assoc (a b c : Set α) : a ∩ b ∩ c = a ∩ (b ∩ c)
-- Mathlib/SetTheory/Game/PGame.lean
theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem exp_sub_pi_mul_I (z : ℂ) : exp (z - π * I) = -exp z
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma P3_comm : P3 x₁ x₂ y₁ y₂ ↔ P3 y₁ y₂ x₁ x₂
-- Mathlib/CategoryTheory/Sites/Limits.lean
/-- If `E` is a cone which is a limit on the level of presheaves,
then the limit presheaf is again a sheaf.

This is used to show that the forgetful functor from sheaves to presheaves creates limits.
-/
theorem isSheaf_of_isLimit (F : K ⥤ Sheaf J D) (E : Cone (F ⋙ sheafToPresheaf J D))
    (hE : IsLimit E) : Presheaf.IsSheaf J E.pt
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
/-- The identity pseudofunctor. -/
@[simps]
def id (B : Type u₁) [Bicategory.{w₁, v₁} B] : Pseudofunctor B B
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t)
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
theorem Cofix.ext {α : TypeVec n} (x y : Cofix F α) (h : x.dest = y.dest) : x = y
-- Mathlib/CategoryTheory/EqToHom.lean
theorem eq_conj_eqToHom {X Y : C} (f : X ⟶ Y) : f = eqToHom rfl ≫ f ≫ eqToHom rfl
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- If `f : ℂ → E` is continuous on a closed ball of positive radius and is differentiable at all
but countably many points of the corresponding open ball, then it is analytic on the open ball with
coefficients of the power series given by Cauchy integral formulas. -/
theorem hasFPowerSeriesOnBall_of_differentiable_off_countable {R : ℝ≥0} {c : ℂ} {f : ℂ → E}
    {s : Set ℂ} (hs : s.Countable) (hc : ContinuousOn f (closedBall c R))
    (hd : ∀ z ∈ ball c R \ s, DifferentiableAt ℂ f z) (hR : 0 < R) :
    HasFPowerSeriesOnBall f (cauchyPowerSeries f c R) c R
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem num_eq_zero_iff [Nontrivial R] {I : FractionalIdeal R⁰ K} : I.num = 0 ↔ I = 0
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_neg (p : FractionRing K[X]) :
    ofFractionRing (-p) = -ofFractionRing p
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal'_conjTranspose {α} [AddMonoid α] [StarAddMonoid α]
    (M : ∀ i, Matrix (m' i) (n' i) α) : (blockDiagonal' M)ᴴ = blockDiagonal' fun k => (M k)ᴴ
-- Mathlib/AlgebraicTopology/SimplicialCategory/Basic.lean
/-- The bifunctor `Cᵒᵖ ⥤ C ⥤ SSet.{v}` which sends `K : Cᵒᵖ` and `L : C` to `sHom K.unop L`. -/
@[simps]
noncomputable def sHomFunctor : Cᵒᵖ ⥤ C ⥤ SSet.{v}
-- Mathlib/Topology/Basic.lean
theorem mem_of_mem_nhds : s ∈ 𝓝 x → x ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem empty_append (s : String) : "" ++ s = s
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
lemma exists_left_transversal (H : Subgroup G) (g : G) :
    ∃ S ∈ leftTransversals (H : Set G), g ∈ S
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem toSimpleFunc_toLp (f : α →ₛ E) (hfi : Memℒp f p μ) : toSimpleFunc (toLp f hfi) =ᵐ[μ] f
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- The prelax functor from `Cat` to `Cat` defined with `WithInitial`. -/
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[simp]
lemma cyclesMap_zero : cyclesMap (0 : K ⟶ L) i = 0
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
/-- The span of a set of points contains the set of points. -/
theorem subset_span (S : Set (ℙ K V)) : S ⊆ span S
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- In a `p ^ (k + 1)`-th cyclotomic extension of `ℚ `, we have that `ζ` is not congruent to an
  integer modulo `p` if `p ≠ 2`. -/
theorem not_exists_int_prime_dvd_sub_of_prime_ne_two
    [hcycl : IsCyclotomicExtension {p ^ (k + 1)} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))) (hodd : p ≠ 2) :
    ¬(∃ n : ℤ, (p : 𝓞 K) ∣ (hζ.toInteger - n : 𝓞 K))
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.exchange_base_of_indep' (hB : M.Base B) (he : e ∈ B) (hf : f ∉ B)
    (hI : M.Indep (insert f B \ {e})) : M.Base (insert f B \ {e})
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_trim_ae (hm : m ≤ m0) {f : β → G} (hf : AEStronglyMeasurable f (μ.trim hm)) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem lift_zero : lift 0 = 0
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toMeasure_mono {s t : Set α} (hs : MeasurableSet s) (ht : MeasurableSet t)
    (h : s ∩ p.support ⊆ t) : p.toMeasure s ≤ p.toMeasure t
-- Mathlib/LinearAlgebra/RootSystem/Basic.lean
private lemma coroot_eq_coreflection_of_root_eq' [CharZero R] [NoZeroSMulDivisors R M]
    (p : PerfectPairing R M N)
    (root : ι ↪ M)
    (coroot : ι ↪ N)
    (hp : ∀ i, p.toLin (root i) (coroot i) = 2)
    (hr : ∀ i, MapsTo (preReflection (root i) (p.toLin.flip (coroot i))) (range root) (range root))
    (hc : ∀ i, MapsTo (preReflection (coroot i) (p.toLin (root i))) (range coroot) (range coroot))
    {i j k : ι} (hk : root k = preReflection (root i) (p.toLin.flip (coroot i)) (root j)) :
    coroot k = preReflection (coroot i) (p.toLin (root i)) (coroot j)
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma binaryProductIso_inv_comp_fst :
    (binaryProductIso F G).inv ≫ Limits.prod.fst = prod.fst
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp]
theorem coe_inverse' (f : A →ₛₙₐ[φ] B) (g : B → A)
    (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    (inverse' f g k h₁ h₂ : B → A) = g
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem filter_apply (a : α) :
    (p.filter s h) a = s.indicator p a * (∑' a', (s.indicator p) a')⁻¹
-- Mathlib/NumberTheory/FunctionField.lean
theorem algebraMap_injective [Algebra Fq[X] F] [Algebra (RatFunc Fq) F]
    [IsScalarTower Fq[X] (RatFunc Fq) F] : Function.Injective (⇑(algebraMap Fq[X] F))
-- Mathlib/Probability/Process/Stopping.lean
protected theorem max_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
    (hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => max (τ ω) i
-- Mathlib/CategoryTheory/Sites/Sheafification.lean
@[simp]
theorem sheafificationAdjunction_unit_app (P : Cᵒᵖ ⥤ D) :
    (sheafificationAdjunction J D).unit.app P = toSheafify J P
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_eq_empty_iff : image₂ f s t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem comp_apply (f : InfTopHom β γ) (g : InfTopHom α β) (a : α) : (f.comp g) a = f (g a)
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
theorem toDualContinuousMultilinearMap_le_projectiveSeminorm (x : ⨂[𝕜] i, E i) :
    ‖toDualContinuousMultilinearMap F x‖ ≤ projectiveSeminorm x
-- Mathlib/Analysis/Convex/EGauge.lean
@[simp]
lemma egauge_zero_zero : egauge 𝕜 (0 : Set E) 0 = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem brange_const {o : Ordinal} (ho : o ≠ 0) {c : α} : (brange o fun _ _ => c) = {c}
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc (attr := simp)]
theorem triangle_assoc_comp_right_inv (f : a ⟶ b) (g : b ⟶ c) :
    (ρ_ f).inv ▷ g ≫ (α_ f (𝟙 b) g).hom = f ◁ (λ_ g).inv
-- Mathlib/Algebra/Group/Conj.lean
theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹
-- Mathlib/Data/PNat/Basic.lean
theorem dvd_antisymm {m n : ℕ+} : m ∣ n → n ∣ m → m = n
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitesimal_def {x : ℝ*} : Infinitesimal x ↔ ∀ r : ℝ, 0 < r → -(r : ℝ*) < x ∧ x < r
-- Mathlib/Algebra/Field/Defs.lean
lemma cast_def (q : ℚ≥0) : (q : α) = q.num / q.den
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem takeWhile (p : Char → Bool) : ∀ {s}, Valid s → Valid (s.takeWhile p)
-- Mathlib/Data/Complex/Exponential.lean
private theorem cos_add_aux {a b c d : ℂ} :
    (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d)
-- Mathlib/Data/List/Perm.lean
theorem Perm.bind_left (l : List α) {f g : α → List β} (h : ∀ a ∈ l, f a ~ g a) :
    l.bind f ~ l.bind g
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem inf_prod : (s₁ ⊓ s₂) ×ˢ t = s₁ ×ˢ t ⊓ s₂ ×ˢ t
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
theorem exists_ae_eq_range_subset (H : AEMeasurable f μ) {t : Set β} (ht : ∀ᵐ x ∂μ, f x ∈ t)
    (h₀ : t.Nonempty) : ∃ g, Measurable g ∧ range g ⊆ t ∧ f =ᵐ[μ] g
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_or {x y : BitVec v} : (x ||| y).getLsb i = (x.getLsb i || y.getLsb i)
-- Mathlib/Logic/Relation.lean
theorem tail' (hab : ReflTransGen r a b) (hbc : r b c) : TransGen r a c
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem not_inj : ∀ {x y : Bool}, (!x) = (!y) → x = y
-- Mathlib/Data/Finsupp/NeLocus.lean
theorem zipWith_neLocus_eq_left [DecidableEq N] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f : α →₀ M) (g₁ g₂ : α →₀ N)
    (hF : ∀ f, Function.Injective fun g => F f g) :
    (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem subtypeDomain_extendDomain (f : Subtype P →₀ M) :
    subtypeDomain P f.extendDomain = f
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_snd [GeneralizedCoheytingAlgebra α] [GeneralizedCoheytingAlgebra β]
    (a b : α × β) : (a ∆ b).2 = a.2 ∆ b.2
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- The braiding isomorphism which swaps a binary product. -/
@[simps]
def prod.braiding (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] : P ⨯ Q ≅ Q ⨯ P
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem beth_succ (o : Ordinal) : beth (succ o) = 2 ^ beth o
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_dite_of_true {p : α → Prop} {_ : DecidablePred p} (h : ∀ i ∈ s, p i) (f : ∀ i, p i → β)
    (g : ∀ i, ¬ p i → β) :
    ∏ i ∈ s, (if hi : p i then f i hi else g i hi) = ∏ i : s, f i.1 (h _ i.2)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem IsClosed.mul_right_of_isCompact (ht : IsClosed t) (hs : IsCompact s) :
    IsClosed (t * s)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem extendWith_some [∀ i, Zero (α i)] (f : Π₀ i, α (some i)) (a : α none) (i : ι) :
    f.extendWith a (some i) = f i
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma one_succAbove_succ {n : ℕ} (j : Fin n) :
    (1 : Fin (n + 2)).succAbove j.succ = j.succ.succ
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem swap_rightInverse : Function.RightInverse (@swap α β) swap
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem ofFinsupp_neg {R : Type u} [Ring R] {a} : (⟨-a⟩ : R[X]) = -⟨a⟩
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
theorem iteratedDerivWithin_univ : iteratedDerivWithin n f univ = iteratedDeriv n f
-- Mathlib/FieldTheory/SeparableClosure.lean
theorem finInsepDegree_def' : finInsepDegree F E = Cardinal.toNat (insepDegree F E)
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_iff_lt_or_fuzzy {x y : PGame} : x ⧏ y ↔ x < y ∨ x ‖ y
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp] theorem apply_le_mass (μ : FiniteMeasure Ω) (s : Set Ω) : μ s ≤ μ.mass
-- Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean
/-- The obvious functor `(J ⥤ ShortComplex C) ⥤ ShortComplex (J ⥤ C)`. -/
@[simps]
def inverse : (J ⥤ ShortComplex C) ⥤ ShortComplex (J ⥤ C)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- If the Hausdorff distance is `< r`, any point in one of the sets is at distance
`< r` of a point in the other set. -/
theorem exists_dist_lt_of_hausdorffDist_lt {r : ℝ} (h : x ∈ s) (H : hausdorffDist s t < r)
    (fin : hausdorffEdist s t ≠ ⊤) : ∃ y ∈ t, dist x y < r
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem symm_symm_eq {X Y : C} (α : X ≅ Y) : α.symm.symm = α
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem id_apply (x : M₁) : id R₁ M₁ x = x
-- Mathlib/CategoryTheory/Linear/LinearFunctor.lean
/-- An additive functor `F` is `R`-linear provided `F.map` is an `R`-module morphism. -/
class Functor.Linear {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  [Linear R C] [Linear R D] (F : C ⥤ D) [F.Additive] : Prop where
  /-- the functor induces a linear map on morphisms -/
  map_smul : ∀ {X Y : C} (f : X ⟶ Y) (r : R), F.map (r • f) = r • F.map f := by aesop_cat
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
/-- If `P u` is `False` for any set `u` that has nonempty intersection both with `s` and `t`, then
`μ (s ∪ t) = μ s + μ t`, where `μ = inducedOuterMeasure m P0 m0`.

E.g., if `α` is an (e)metric space and `P u = diam u < r`, then this lemma implies that
`μ (s ∪ t) = μ s + μ t` on any two sets such that `r ≤ edist x y` for all `x ∈ s` and `y ∈ t`. -/
theorem inducedOuterMeasure_union_of_false_of_nonempty_inter {s t : Set α}
    (h : ∀ u, (s ∩ u).Nonempty → (t ∩ u).Nonempty → ¬P u) :
    inducedOuterMeasure m P0 m0 (s ∪ t) =
      inducedOuterMeasure m P0 m0 s + inducedOuterMeasure m P0 m0 t
-- Mathlib/Order/Concept.lean
theorem ext' (h : c.snd = d.snd) : c = d
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem coe_rangeRestrict (f : R →ₙ+* S) (x : R) : (f.rangeRestrict x : S) = f x
-- Mathlib/Algebra/AddTorsor.lean
@[simp]
theorem coe_constVSub_symm (p : P) : ⇑(constVSub p).symm = fun (v : G) => -v +ᵥ p
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem comap_asIdeal (y : PrimeSpectrum S) : (comap f y).asIdeal = Ideal.comap f y.asIdeal
-- Mathlib/Order/GaloisConnection.lean
theorem l_le {a : α} {b : β} : a ≤ u b → l a ≤ b
-- Mathlib/Probability/Kernel/Basic.lean
theorem sum_apply' [Countable ι] (κ : ι → Kernel α β) (a : α) {s : Set β} (hs : MeasurableSet s) :
    Kernel.sum κ a s = ∑' n, κ n a s
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_sub {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, f a - g a ∂μ = ∫ a, f a ∂μ - ∫ a, g a ∂μ
-- Mathlib/Data/List/Chain.lean
theorem chain_of_chain_pmap {S : β → β → Prop} {p : α → Prop} (f : ∀ a, p a → β) {l : List α}
    (hl₁ : ∀ a ∈ l, p a) {a : α} (ha : p a) (hl₂ : Chain S (f a ha) (List.pmap f l hl₁))
    (H : ∀ a b ha hb, S (f a ha) (f b hb) → R a b) : Chain R a l
-- Mathlib/Order/Category/CompleteLat.lean
/-- `OrderDual` as a functor. -/
@[simps]
def dual : CompleteLat ⥤ CompleteLat
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem setLintegral_setLaverage (μ : Measure α) [IsFiniteMeasure μ] (f : α → ℝ≥0∞) (s : Set α) :
    ∫⁻ _x in s, ⨍⁻ a in s, f a ∂μ ∂μ = ∫⁻ x in s, f x ∂μ
-- Mathlib/CategoryTheory/Quotient.lean
theorem lift_unique (Φ : Quotient r ⥤ D) (hΦ : functor r ⋙ Φ = F) : Φ = lift r F H
-- Mathlib/Data/Set/Basic.lean
theorem inter_subset (a b c : Set α) : a ∩ b ⊆ c ↔ a ⊆ bᶜ ∪ c
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem apply_symm_apply (e : r ≃r s) (x : β) : e (e.symm x) = x
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem and_iff_right_iff_imp : ∀(a b : Bool), ((a && b) = b) ↔ (b → a)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[symm]
theorem adj_symm (G' : Subgraph G) {u v : V} (h : G'.Adj u v) : G'.Adj v u
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivAt_id (x : M) :
    HasMFDerivAt I I (@id M) x (ContinuousLinearMap.id 𝕜 (TangentSpace I x))
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem get!_eq_getElem? [Inhabited α] (a : Array α) (i : Nat) : a.get! i = (a.get? i).getD default
-- Mathlib/Probability/Moments.lean
@[simp]
theorem mgf_const' (c : ℝ) : mgf (fun _ => c) μ t = (μ Set.univ).toReal * exp (t * c)
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
/-- A restatement of `Types.Limit.lift_π_apply` that uses `Pi.π` and `Pi.lift`. -/
@[simp 1001]
theorem pi_lift_π_apply {β : Type v} [Small.{u} β] (f : β → Type u) {P : Type u}
    (s : ∀ b, P ⟶ f b) (b : β) (x : P) :
    (Pi.π f b : (piObj f) → f b) (@Pi.lift β _ _ f _ P s x) = s b x
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.inf f = s₂.inf g
-- Mathlib/Topology/Filter.lean
@[simp]
protected theorem closure_singleton (l : Filter α) : closure {l} = Ici l
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem ω_mul_ωb (q : ℕ+) : (ω : X q) * ωb = 1
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem coeComplex_imI (z : ℂ) : (z : ℍ).imI = z.im
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem next_nat_succ (i : ℕ) : (ComplexShape.down ℕ).next (i + 1) = i
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem unop {P X Y Z : Cᵒᵖ} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z}
    (h : IsPullback fst snd f g) : IsPushout g.unop f.unop snd.unop fst.unop
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem ofComapInfPrincipal_eq_of_map (h : m '' s ∈ g) : (ofComapInfPrincipal h).map m = g
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
theorem ContDiff.continuous_iteratedDeriv {n : ℕ∞} (m : ℕ) (h : ContDiff 𝕜 n f)
    (hmn : (m : ℕ∞) ≤ n) : Continuous (iteratedDeriv m f)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- Construct a multifork using a collection `ι` of morphisms. -/
@[simps]
def ofι (I : MulticospanIndex.{w} C) (P : C) (ι : ∀ a, P ⟶ I.left a)
    (w : ∀ b, ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b) : Multifork I
-- Mathlib/RingTheory/Localization/InvSubmonoid.lean
theorem toInvSubmonoid_surjective : Function.Surjective (toInvSubmonoid M S)
-- Mathlib/Analysis/Convex/Basic.lean
theorem Antitone.convex_ge (hf : Antitone f) (r : β) : Convex 𝕜 { x | r ≤ f x }
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_fieldRange : (f.fieldRange : Set L) = Set.range f
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma supIrred_Iic (a : α) : SupIrred (Iic a)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_pi_div_two_sub (x : ℝ) : cos (π / 2 - x) = sin x
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem monomial_zero_right (n : ℕ) : monomial n (0 : R) = 0
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
protected theorem eq_of_smul_eq_smul_left {a : ℤ} {b c : ℤ√d} (ha : a ≠ 0) (h : ↑a * b = a * c) :
    b = c
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem toTopologicalSpace_injective :
    Function.Injective (toTopologicalSpace : GroupTopology α → TopologicalSpace α)
-- Mathlib/Topology/VectorBundle/Constructions.lean
@[simp] -- Porting note: changed arguments to make `simpNF` happy: merged `hx₁` and `hx₂` into `hx`
theorem Trivialization.continuousLinearEquivAt_prod {e₁ : Trivialization F₁ (π F₁ E₁)}
    {e₂ : Trivialization F₂ (π F₂ E₂)} [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] {x : B}
    (hx : x ∈ (e₁.prod e₂).baseSet) :
    (e₁.prod e₂).continuousLinearEquivAt 𝕜 x hx =
      (e₁.continuousLinearEquivAt 𝕜 x hx.1).prod (e₂.continuousLinearEquivAt 𝕜 x hx.2)
-- Mathlib/Algebra/Lie/Weights/Chain.lean
@[simp] lemma chainTop_neg : chainTop (-α) β = chainBot α β
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem lookupAll_nil (a : α) : lookupAll a [] = @nil (β a)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp] lemma mk_smul (i : NumDenSameDeg 𝒜 x) (m : α) : mk (m • i) = m • mk i
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sup_sdiff_left_self : (a ⊔ b) \ a = b \ a
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem map_apply {M : Matrix m n α} {f : α → β} {i : m} {j : n} : M.map f i j = f (M i j)
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive addOrder_dvd_exponent]
theorem order_dvd_exponent (g : G) : orderOf g ∣ exponent G
-- Mathlib/Topology/StoneCech.lean
lemma eq_if_preStoneCechUnit_eq {a b : α} (h : preStoneCechUnit a = preStoneCechUnit b) :
    g a = g b
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsUnit.isRelPrime_right (h : IsUnit y) : IsRelPrime x y
-- Mathlib/Probability/Kernel/WithDensity.lean
nonrec lemma withDensity_mul [IsSFiniteKernel κ] {f : α → β → ℝ≥0} {g : α → β → ℝ≥0∞}
    (hf : Measurable (Function.uncurry f)) (hg : Measurable (Function.uncurry g)) :
    withDensity κ (fun a x ↦ f a x * g a x)
      = withDensity (withDensity κ fun a x ↦ f a x) g
-- Mathlib/CategoryTheory/Functor/Category.lean
theorem vcomp_app' (α : F ⟶ G) (β : G ⟶ H) (X : C) : (α ≫ β).app X = α.app X ≫ β.app X
-- Mathlib/Combinatorics/Enumerative/Composition.lean
/-- Two compositions (possibly of different integers) coincide if and only if they have the
same sequence of blocks. -/
theorem sigma_eq_iff_blocks_eq {c : Σn, Composition n} {c' : Σn, Composition n} :
    c = c' ↔ c.2.blocks = c'.2.blocks
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- Any morphism from a terminal object is split mono. -/
theorem IsTerminal.isSplitMono_from {X Y : C} (t : IsTerminal X) (f : X ⟶ Y) : IsSplitMono f
-- Mathlib/RingTheory/OreLocalization/Ring.lean
theorem subsingleton_iff :
    Subsingleton R[S⁻¹] ↔ 0 ∈ S
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
@[fun_prop]
theorem Differentiable.comp_differentiableOn {g : F → G} (hg : Differentiable 𝕜 g)
    (hf : DifferentiableOn 𝕜 f s) : DifferentiableOn 𝕜 (g ∘ f) s
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem sSup_le_iff : sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pf_zero_add (b : R) : 0 + b = b
-- Mathlib/Algebra/BigOperators/Fin.lean
/-- A product of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)`
is the product of `f 0` plus the remaining product -/
@[to_additive "A sum of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)` is the sum of
`f 0` plus the remaining product"]
theorem prod_univ_succ [CommMonoid β] {n : ℕ} (f : Fin (n + 1) → β) :
    ∏ i, f i = f 0 * ∏ i : Fin n, f i.succ
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma toCycles_i : S.toCycles ≫ S.iCycles = S.f
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
theorem coe_injective : Injective ((↑) : MultilinearMap R M₁ M₂ → (∀ i, M₁ i) → M₂)
-- Mathlib/Order/LiminfLimsup.lean
theorem gt_mem_sets_of_limsInf_gt : f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_toFinset (l : List α) : (l.toFinset : Set α) = { a | a ∈ l }
-- Mathlib/Order/Interval/Finset/Defs.lean
/-- This mixin class describes an order where all intervals bounded above are finite. This is
slightly weaker than `LocallyFiniteOrder` + `OrderBot` as it allows empty types. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem measurable_fst {_ : MeasurableSpace α} {_ : MeasurableSpace β} :
    Measurable (Prod.fst : α × β → α)
-- Mathlib/CategoryTheory/Functor/ReflectsIso.lean
/-- If `F` reflects isos and `F.map f` is an iso, then `f` is an iso. -/
theorem isIso_of_reflects_iso {A B : C} (f : A ⟶ B) (F : C ⥤ D) [IsIso (F.map f)]
    [F.ReflectsIsomorphisms] : IsIso f
-- Mathlib/Order/CompactlyGenerated/Intervals.lean
theorem isCompactElement {a : α} {b : Iic a} (h : CompleteLattice.IsCompactElement (b : α)) :
    CompleteLattice.IsCompactElement b
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem tendsto_Ioo_atTop {f : β → Ioo a b} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] b)