ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
theorem subset_span_trans {S T U : Set (ℙ K V)} (hST : S ⊆ span T) (hTU : T ⊆ span U) :
    S ⊆ span U
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem Measurable.comp_nullMeasurable {g : β → γ} (hg : Measurable g) (hf : NullMeasurable f μ) :
    NullMeasurable (g ∘ f) μ
-- Mathlib/Algebra/Vertex/HVertexOperator.lean
@[ext]
theorem coeff_inj : Function.Injective (coeff : HVertexOperator Γ R V W → Γ → (V →ₗ[R] W))
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem minimum_nil : minimum ([] : List α) = ⊤
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
theorem pseudoEqual_symm {P : C} : Symmetric (PseudoEqual P)
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
theorem IsCyclic.card_orderOf_eq_totient [IsCyclic α] [Fintype α] {d : ℕ}
    (hd : d ∣ Fintype.card α) : (univ.filter fun a : α => orderOf a = d).card = totient d
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
@[simp]
theorem Real.Angle.expMapCircle_zero : Real.Angle.expMapCircle 0 = 1
-- Mathlib/Logic/Basic.lean
theorem forall_true_iff' (h : ∀ a, p a ↔ True) : (∀ a, p a) ↔ True
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_univ_four [CommMonoid β] (f : Fin 4 → β) : ∏ i, f i = f 0 * f 1 * f 2 * f 3
-- Mathlib/Data/ENat/Lattice.lean
lemma iSup_coe_lt_top : ⨆ i, (f i : ℕ∞) < ⊤ ↔ BddAbove (range f)
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
/-- If `ringChar F` is odd, then `quadraticCharFun F a` can be computed in
terms of `a ^ (Fintype.card F / 2)`. -/
theorem quadraticCharFun_eq_pow_of_char_ne_two (hF : ringChar F ≠ 2) {a : F} (ha : a ≠ 0) :
    quadraticCharFun F a = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- `X` is a non-Lindelöf topological space if it is not a Lindelöf space. -/
class NonLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a non-Lindelöf space, `Set.univ` is not a Lindelöf set. -/
  nonLindelof_univ : ¬IsLindelof (univ : Set X)
-- Mathlib/Algebra/Order/Group/OrderIso.lean
/-- `x ↦ x⁻¹` as an order-reversing equivalence. -/
@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
def OrderIso.inv : α ≃o αᵒᵈ
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- A continuous function with compact support is bounded above. -/
@[to_additive " A continuous function with compact support is bounded above. "]
theorem Continuous.bddAbove_range_of_hasCompactMulSupport [ClosedIciTopology α] [One α]
    {f : β → α} (hf : Continuous f) (h : HasCompactMulSupport f) : BddAbove (range f)
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem range_cons {α : Type*} {n : ℕ} (x : α) (b : Fin n → α) :
    Set.range (Fin.cons x b : Fin n.succ → α) = insert x (Set.range b)
-- Mathlib/RingTheory/Adjoin/Basic.lean
@[simp]
theorem adjoin_span {s : Set A} : adjoin R (Submodule.span R s : Set A) = adjoin R s
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- If `R` satisfies the rank condition,
then the cardinality of any basis is bounded by the cardinality of any spanning set.
-/
theorem Basis.le_span {J : Set M} (v : Basis ι R M) (hJ : span R J = ⊤) : #(range v) ≤ #J
-- Mathlib/Data/Finset/Sups.lean
theorem infs_comm : s ⊼ t = t ⊼ s
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_union (s t : Finset α) (u : α → Set β) :
    ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma mapHomologicalComplexXIso_eq (n m : ℤ) (hnm : n + 1 = m) :
    mapHomologicalComplexXIso φ H n = mapHomologicalComplexXIso' φ H n m hnm
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem measurable_coe {s : Set α} (hs : MeasurableSet s) : Measurable fun μ : Measure α => μ s
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem image_nonempty {f : α → β} {s : Set α} : (f '' s).Nonempty ↔ s.Nonempty
-- Mathlib/Topology/Order/Basic.lean
/-- **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold eventually for the filter. -/
theorem tendsto_of_tendsto_of_tendsto_of_le_of_le' [OrderTopology α] {f g h : β → α} {b : Filter β}
    {a : α} (hg : Tendsto g b (𝓝 a)) (hh : Tendsto h b (𝓝 a)) (hgf : ∀ᶠ b in b, g b ≤ f b)
    (hfh : ∀ᶠ b in b, f b ≤ h b) : Tendsto f b (𝓝 a)
-- Mathlib/RingTheory/Localization/Ideal.lean
/-- `quotientMap` applied to maximal ideals of a localization is `surjective`.
  The quotient by a maximal ideal is a field, so inverses to elements already exist,
  and the localization necessarily maps the equivalence class of the inverse in the localization -/
theorem surjective_quotientMap_of_maximal_of_localization {I : Ideal S} [I.IsPrime] {J : Ideal R}
    {H : J ≤ I.comap (algebraMap R S)} (hI : (I.comap (algebraMap R S)).IsMaximal) :
    Function.Surjective (Ideal.quotientMap I (algebraMap R S) H)
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalExtrOn.inter (hf : IsLocalExtrOn f s a) (t) : IsLocalExtrOn f (s ∩ t) a
-- Mathlib/Data/Nat/SuccPred.lean
@[simp]
theorem pred_eq_pred : Order.pred = pred
-- Mathlib/Order/Cover.lean
theorem AntisymmRel.trans_wcovBy (hab : AntisymmRel (· ≤ ·) a b) (hbc : b ⩿ c) : a ⩿ c
-- Mathlib/Data/Fin/Basic.lean
theorem ne_iff_vne (a b : Fin n) : a ≠ b ↔ a.1 ≠ b.1
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem Eq.mpr_not  {p q : Prop} (h₁ : p = q) (h₂ : ¬q) : ¬p
-- Mathlib/NumberTheory/Dioph.lean
theorem ex_dioph {S : Set (α ⊕ β → ℕ)} : Dioph S → Dioph {v | ∃ x, v ⊗ x ∈ S}
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- A subsemiring is closed under multiplication. -/
protected theorem mul_mem {x y : R} : x ∈ s → y ∈ s → x * y ∈ s
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
theorem X_inv (s : σ) : (X s : MvPowerSeries σ k)⁻¹ = 0
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem isLeftDescent_iff_not_isLeftDescent_mul {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (s i * w) i
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Bounded.of_gt :
    ∀ {t o₁ o₂} {x : α}, Bounded t o₁ o₂ → Bounded nil x o₂ → All (· > x) t → Bounded t x o₂
-- Mathlib/Topology/Separation.lean
/-- If `t` is a subset of `s`, except for one point,
then `insert x s` is a neighborhood of `x` within `t`. -/
theorem insert_mem_nhdsWithin_of_subset_insert [T1Space X] {x y : X} {s t : Set X}
    (hu : t ⊆ insert y s) : insert x s ∈ 𝓝[t] x
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- A function is `C^(n + 1)` on an open domain if and only if it is
differentiable there, and its derivative (expressed with `fderiv`) is `C^n`. -/
theorem contDiffOn_succ_iff_fderiv_of_isOpen {n : ℕ} (hs : IsOpen s) :
    ContDiffOn 𝕜 (n + 1 : ℕ) f s ↔
      DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 n (fun y => fderiv 𝕜 f y) s
-- Mathlib/Order/Monotone/Basic.lean
theorem antitone_dual_iff : Antitone (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) ↔ Antitone f
-- Mathlib/Topology/Order/ScottTopology.lean
lemma dirSupInacc_iff_forall_sSup :
    DirSupInacc s ↔ ∀ ⦃d⦄, d.Nonempty → DirectedOn (· ≤ ·) d → sSup d ∈ s → (d ∩ s).Nonempty
-- Mathlib/Data/Matrix/Block.lean
/-- `Matrix.blockDiag` as an `AddMonoidHom`. -/
@[simps]
def blockDiagAddMonoidHom [AddZeroClass α] : Matrix (m × o) (n × o) α →+ o → Matrix m n α
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem iterate_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f^[n]
-- Mathlib/CategoryTheory/GradedObject/Trifunctor.lean
lemma HasGoodTrifunctor₂₃Obj.hasMap :
    HasMap ((((mapTrifunctor (bifunctorComp₂₃ F G₂₃) I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) r
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive continuous_of_continuousAt_zero₂]
theorem continuous_of_continuousAt_one₂ {H M : Type*} [CommMonoid M] [TopologicalSpace M]
    [ContinuousMul M] [Group H] [TopologicalSpace H] [TopologicalGroup H] (f : G →* H →* M)
    (hf : ContinuousAt (fun x : G × H ↦ f x.1 x.2) (1, 1))
    (hl : ∀ x, ContinuousAt (f x) 1) (hr : ∀ y, ContinuousAt (f · y) 1) :
    Continuous (fun x : G × H ↦ f x.1 x.2)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem prod_mono_left (t : Subsemiring S) : Monotone fun s : Subsemiring R => s.prod t
-- Mathlib/Analysis/Complex/Liouville.lean
/-- **Liouville's theorem**: a complex differentiable bounded function is a constant. -/
theorem exists_const_forall_eq_of_bounded {f : E → F} (hf : Differentiable ℂ f)
    (hb : IsBounded (range f)) : ∃ c, ∀ z, f z = c
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[bv_toNat] theorem lt_def (x y : BitVec n) :
  x < y ↔ x.toNat < y.toNat
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_id (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 id s x = id 𝕜 E
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_sub_const_Ici : (fun x => x - a) ⁻¹' Ici b = Ici (b + a)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem iff_def  : (a ↔ b) ↔ (a → b) ∧ (b → a)
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMinOn.sup (hf : IsLocalMinOn f s a) (hg : IsLocalMinOn g s a) :
    IsLocalMinOn (fun x => f x ⊔ g x) s a
-- Mathlib/CategoryTheory/Subobject/Basic.lean
/-- An equality of subobjects gives an isomorphism of the corresponding objects.
(One could use `underlying.mapIso (eqToIso h))` here, but this is more readable.) -/
@[simps]
def isoOfEq {B : C} (X Y : Subobject B) (h : X = Y) : (X : C) ≅ (Y : C)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Iterate.lean
theorem hIterate_eq {P : Nat → Sort _} (state : ∀(i : Nat), P i)
    {n : Nat} (f : ∀(i : Fin n), P i.val → P (i.val+1)) (s : P 0)
    (init : s = state 0)
    (step : ∀(i : Fin n), f i (state i) = state (i+1)) :
    hIterate P s f = state n
-- Mathlib/CategoryTheory/Preadditive/Yoneda/Projective.lean
theorem projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj' (P : C) :
    Projective P ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc (attr := simp)]
theorem comp_coconePointUniqueUpToIso_hom {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t)
    (j : J) : s.ι.app j ≫ (coconePointUniqueUpToIso P Q).hom = t.ι.app j
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp 1100]
theorem map_id_obj_unop (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).obj (unop U) = unop U
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
theorem support_scaleRoots_eq (p : R[X]) {s : R} (hs : s ∈ nonZeroDivisors R) :
    (scaleRoots p s).support = p.support
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp, norm_cast]
theorem coe_smul {_m : MeasurableSpace α} (c : R) (μ : Measure α) : ⇑(c • μ) = c • ⇑μ
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciSup_set_le_iff {ι : Type*} {s : Set ι} {f : ι → α} {a : α} (hs : s.Nonempty)
    (hf : BddAbove (f '' s)) : ⨆ i : s, f i ≤ a ↔ ∀ i ∈ s, f i ≤ a
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem norm_prod (s : Finset β) (f : β → α) : ‖∏ b ∈ s, f b‖ = ∏ b ∈ s, ‖f b‖
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean
@[simp] lemma tensorComm_symm (Q₁ : QuadraticForm R M₁) (Q₂ : QuadraticForm R M₂) :
    (tensorComm Q₁ Q₂).symm = tensorComm Q₂ Q₁
-- Mathlib/Algebra/DirectSum/Module.lean
/-- If a direct sum of submodules is internal then the submodules span the module. -/
theorem IsInternal.submodule_iSup_eq_top (h : IsInternal A) : iSup A = ⊤
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dot_sdiv_left (xs ys : Coeffs) {d : Int} (h : d ∣ xs.gcd) :
    dot (xs.sdiv d) ys = (dot xs ys) / d
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mem_carrier : a ∈ L.carrier ↔ a ∈ L
-- Mathlib/Data/List/Sigma.lean
theorem dlookup_kinsert_ne {a a'} {b' : β a'} {l : List (Sigma β)} (h : a ≠ a') :
    dlookup a (kinsert a' b' l) = dlookup a l
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem refl_toEquiv : (refl α).toEquiv = Equiv.refl α
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp]
theorem getElem?_set_eq' (a : α) (n) (l : List α) : (set l n a)[n]? = (fun _ => a) <$> l[n]?
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
@[simp]
theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofNat_eq_ofENat {m : ℕ} {n : ℕ∞} [m.AtLeastTwo] :
    no_index (OfNat.ofNat m) = (n : Cardinal) ↔ OfNat.ofNat m = n
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive top_prod]
theorem top_prod (s : Subsemigroup N) : (⊤ : Subsemigroup M).prod s = s.comap (MulHom.snd M N)
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem mul_def (x y : S) : x * y = ⟨x * y, S.mul_mem x.2 y.2⟩
-- Mathlib/RingTheory/WittVector/Frobenius.lean
theorem map_frobeniusPoly (n : ℕ) :
    MvPolynomial.map (Int.castRingHom ℚ) (frobeniusPoly p n) = frobeniusPolyRat p n
-- Mathlib/RepresentationTheory/Action/Basic.lean
/-- The natural isomorphism from the composition of restrictions along homomorphisms
to the restriction along the composition of homomorphism.
-/
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g)
-- Mathlib/Topology/ContinuousOn.lean
theorem pure_le_nhdsWithin {a : α} {s : Set α} (ha : a ∈ s) : pure a ≤ 𝓝[s] a
-- Mathlib/Deprecated/Subring.lean
theorem closure.isSubring : IsSubring (closure s)
-- Mathlib/Probability/Martingale/Basic.lean
theorem sub_submartingale [Preorder E] [CovariantClass E E (· + ·) (· ≤ ·)]
    (hf : Supermartingale f ℱ μ) (hg : Submartingale g ℱ μ) : Supermartingale (f - g) ℱ μ
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
lemma smul_def (T : CentroidHom α) (a : α) : T • a = T a
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
lemma IsStableUnderLimitsOfShape.lim_map {J : Type*} [Category J]
    (hW : W.IsStableUnderLimitsOfShape J) {X Y : J ⥤ C}
    (f : X ⟶ Y) [HasLimitsOfShape J C] (hf : W.functorCategory _ f) :
    W (lim.map f)
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp]
theorem powerSeriesPart_coeff (x : LaurentSeries R) (n : ℕ) :
    PowerSeries.coeff R n x.powerSeriesPart = x.coeff (x.order + n)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffAt.congr_of_eventuallyEq (h : ContMDiffAt I I' n f x) (h₁ : f₁ =ᶠ[𝓝 x] f) :
    ContMDiffAt I I' n f₁ x
-- Mathlib/Analysis/Analytic/Composition.lean
/-- If two functions `g` and `f` are analytic respectively on `s.image f` and `s`, then `g ∘ f` is
analytic on `s`. -/
theorem AnalyticOn.comp' {s : Set E} {g : F → G} {f : E → F} (hg : AnalyticOn 𝕜 g (s.image f))
    (hf : AnalyticOn 𝕜 f s) : AnalyticOn 𝕜 (g ∘ f) s
-- Mathlib/LinearAlgebra/Basis/VectorSpace.lean
theorem LinearMap.exists_rightInverse_of_surjective (f : V →ₗ[K] V') (hf_surj : range f = ⊤) :
    ∃ g : V' →ₗ[K] V, f.comp g = LinearMap.id
-- Mathlib/Order/Heyting/Basic.lean
/-- `p → p` -/
@[simp]
theorem himp_self : a ⇨ a = ⊤
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem tail_val : ∀ v : Vector α n.succ, v.tail.val = v.val.tail
-- Mathlib/Data/List/Palindrome.lean
theorem append_reverse (l : List α) : Palindrome (l ++ reverse l)
-- Mathlib/Data/Option/Basic.lean
theorem pmap_eq_none_iff {h} : pmap f x h = none ↔ x = none
-- Mathlib/Topology/Order/LawsonTopology.lean
lemma lawsonClosed_of_lowerClosed (s : Set α) (h : IsClosed (WithLower.ofLower ⁻¹' s)) :
    IsClosed (WithLawson.ofLawson ⁻¹' s)
-- Mathlib/Analysis/Convex/Cone/Basic.lean
/-- Two `ConvexCone`s are equal if they have the same elements. -/
@[ext]
theorem ext {S T : ConvexCone 𝕜 E} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem fderivWithin_cos (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
    fderivWithin ℝ (fun x => Real.cos (f x)) s x = -Real.sin (f x) • fderivWithin ℝ f s x
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsCondKernelCDF.nonneg (hf : IsCondKernelCDF f κ ν) (p : α × β) (x : ℝ) : 0 ≤ f p x
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem norm_mul (n m : ℤ√d) : norm (n * m) = norm n * norm m
-- Mathlib/Order/Bounds/Basic.lean
theorem image_upperBounds_subset_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
/-- Bisimulation principle using `map` and `Quot.mk` to match and relate children of two trees. -/
theorem Cofix.bisim_rel {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop)
    (h : ∀ x y, r x y →
      appendFun id (Quot.mk r) <$$> Cofix.dest x = appendFun id (Quot.mk r) <$$> Cofix.dest y) :
    ∀ x y, r x y → x = y
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem eval_C {c : K} : eval f a (C c) = f c
-- Mathlib/GroupTheory/Perm/Support.lean
theorem card_support_eq_zero {f : Perm α} : f.support.card = 0 ↔ f = 1
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem not_frequently {p : α → Prop} {f : Filter α} : (¬∃ᶠ x in f, p x) ↔ ∀ᶠ x in f, ¬p x
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.lt_right_of_left_lt (hf : ConcaveOn 𝕜 s f) {x y z : E} (hx : x ∈ s) (hy : y ∈ s)
    (hz : z ∈ openSegment 𝕜 x y) (hxz : f z < f x) : f y < f z
-- Mathlib/Logic/Encodable/Basic.lean
/-- See also `nonempty_fintype`, `nonempty_denumerable`. -/
theorem nonempty_encodable (α : Type*) [Countable α] : Nonempty (Encodable α)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem not_injective_of_ordinal_of_small {α : Type v} [Small.{u} α] (f : Ordinal.{u} → α) :
    ¬Injective f
-- Mathlib/Algebra/Module/Hom.lean
theorem smul_apply (r : R) (f : A →+ B) (x : A) : (r • f) x = r • f x
-- Mathlib/Data/Multiset/Basic.lean
theorem union_le_union_right (h : s ≤ t) (u) : s ∪ u ≤ t ∪ u
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_union_mul_inter_apply (f : α → M) (s t : Set α) (a : α) :
    mulIndicator (s ∪ t) f a * mulIndicator (s ∩ t) f a
      = mulIndicator s f a * mulIndicator t f a
-- Mathlib/Data/Set/Card.lean
theorem encard_le_coe_iff {k : ℕ} : s.encard ≤ k ↔ s.Finite ∧ ∃ (n₀ : ℕ), s.encard = n₀ ∧ n₀ ≤ k
-- Mathlib/Order/Partition/Finpartition.lean
/-- A `Finpartition` constructor which does not insist on `⊥` not being a part. -/
@[simps]
def ofErase [DecidableEq α] {a : α} (parts : Finset α) (sup_indep : parts.SupIndep id)
    (sup_parts : parts.sup id = a) : Finpartition a
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem IsOrtho.le {U V : Submodule 𝕜 E} (h : U ⟂ V) : U ≤ Vᗮ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem DifferentiableOn.csinh (hc : DifferentiableOn ℂ f s) :
    DifferentiableOn ℂ (fun x => Complex.sinh (f x)) s
-- Mathlib/Order/Filter/AtTopBot.lean
protected theorem Tendsto.eventually_ne_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, f x ≠ c
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the sign of the angle between two vectors is negative, the second vector is nonzero. -/
theorem right_ne_zero_of_oangle_sign_eq_neg_one {x y : V} (h : (o.oangle x y).sign = -1) : y ≠ 0
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
/-- `AddMonoidAlgebra.gradeBy` describe an internally graded algebra. -/
theorem gradeBy.isInternal : DirectSum.IsInternal (gradeBy R f)
-- Mathlib/Deprecated/Group.lean
/-- The composition of maps which preserve multiplication, also preserves multiplication. -/
@[to_additive "The composition of addition preserving maps also preserves addition"]
theorem comp {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g) : IsMulHom (g ∘ f)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem ite_true (a b : α) : (if True then a else b) = a
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem mk_proj_snd' (ex : proj x ∈ e.baseSet) : (proj x, (e x).2) = e x
-- Mathlib/Data/Sym/Sym2.lean
theorem eq_iff {x y z w : α} : s(x, y) = s(z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z
-- Mathlib/Data/Real/Hyperreal.lean
theorem exists_st_iff_not_infinite {x : ℝ*} : (∃ r : ℝ, IsSt x r) ↔ ¬Infinite x
-- Mathlib/Data/Seq/Computation.lean
theorem results_thinkN {s : Computation α} {a m} :
    ∀ n, Results s a m → Results (thinkN s n) a (m + n)
-- Mathlib/Analysis/Normed/Ring/Units.lean
/-- In a normed ring, the coercion from `Rˣ` (equipped with the induced topology from the
embedding in `R × R`) to `R` is an open embedding. -/
theorem openEmbedding_val : OpenEmbedding (val : Rˣ → R)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem clift_apply_inr (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) (x : N) :
    clift f hM₁ hN₁ hM hN (inr x) = f (of (.inr x))
-- Mathlib/ModelTheory/Definability.lean
theorem definable_iff_exists_formula_sum :
    A.Definable L s ↔ ∃ φ : L.Formula (A ⊕ α), s = {v | φ.Realize (Sum.elim (↑) v)}
-- Mathlib/Order/Filter/Basic.lean
theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
    s ∈ bind f m ↔ { a | s ∈ m a } ∈ f
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma llr_smul_right [IsFiniteMeasure μ] [Measure.HaveLebesgueDecomposition μ ν]
    (hμν : μ ≪ ν) (c : ℝ≥0∞) (hc : c ≠ 0) (hc_ne_top : c ≠ ∞) :
    llr μ (c • ν) =ᵐ[μ] fun x ↦ llr μ ν x - log c.toReal
-- Mathlib/Data/Setoid/Basic.lean
theorem comap_rel (f : α → β) (r : Setoid β) (x y : α) : (comap f r).Rel x y ↔ r.Rel (f x) (f y)
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem uniformContinuous_vsub : UniformContinuous fun x : P × P => x.1 -ᵥ x.2
-- Mathlib/Algebra/Homology/ComplexShape.lean
lemma prev_eq_self (c : ComplexShape ι) (j : ι) (hj : ¬ c.Rel (c.prev j) j) :
    c.prev j = j
-- Mathlib/GroupTheory/SpecificGroups/KleinFour.lean
@[to_additive (attr := simp)]
lemma card_four' {G : Type*} [Group G] [Fintype G] [IsKleinFour G] :
    Fintype.card G = 4
-- Mathlib/Data/Real/Hyperreal.lean
protected theorem IsSt.lt {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) (hrs : r < s) :
    x < y
-- Mathlib/CategoryTheory/Localization/Construction.lean
/-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D)
-- Mathlib/CategoryTheory/Monoidal/Discrete.lean
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
/-- The kernel morphism of a zero morphism is an isomorphism -/
theorem kernel.ι_of_zero : IsIso (kernel.ι (0 : X ⟶ Y))
-- Mathlib/Analysis/Complex/Angle.lean
lemma angle_div_left_eq_angle_mul_right (a x y : ℂ) : angle (x / a) y = angle x (y * a)
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[simp, reassoc]
theorem app_invApp (U : Opens Y) :
    f.c.app (op U) ≫ H.invApp ((Opens.map f.base).obj U) =
      Y.presheaf.map
        ((homOfLE (Set.image_preimage_subset f.base U.1)).op :
          op U ⟶ op (opensFunctor f |>.obj ((Opens.map f.base).obj U)))
-- Mathlib/Data/Set/Defs.lean
theorem apply_rangeSplitting (f : α → β) (x : range f) : f (rangeSplitting f x) = x
-- Mathlib/Topology/Sets/Opens.lean
/-- An open set in the indiscrete topology is either empty or the whole space. -/
theorem eq_bot_or_top {α} [t : TopologicalSpace α] (h : t = ⊤) (U : Opens α) : U = ⊥ ∨ U = ⊤
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem contMdiffAt_subtype_iff {n : ℕ∞} {U : Opens M} {f : M → M'} {x : U} :
    ContMDiffAt I I' n (fun x : U ↦ f x) x ↔ ContMDiffAt I I' n f x
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofMul_zpow [DivInvMonoid α] (z : ℤ) (a : α) : ofMul (a ^ z) = z • ofMul a
-- Mathlib/Data/Setoid/Partition.lean
/-- A partition of `α` does not contain the empty set. -/
theorem nonempty_of_mem_partition {c : Set (Set α)} (hc : IsPartition c) {s} (h : s ∈ c) :
    s.Nonempty
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem map_mkQ_eq_top : map p.mkQ p' = ⊤ ↔ p ⊔ p' = ⊤