ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The strong pigeonhole principle for finitely many pigeons and pigeonholes.
There is a pigeonhole with at least as many pigeons as
the ceiling of the average number of pigeons across all pigeonholes.
("The maximum is at least the mean" specialized to integers.)

More formally, given a function `f` between finite types `α` and `β` and a number `n` such that
`card β * n < card α`, there exists an element `y : β` such that its preimage has more than `n`
elements. -/
theorem exists_lt_card_fiber_of_mul_lt_card (hn : card β * n < card α) :
    ∃ y : β, n < (univ.filter fun x => f x = y).card
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
theorem hasPushout_assoc_symm [HasPushout g₁ (g₂ ≫ f₃)] : HasPushout (g₃ ≫ f₂) g₄
-- Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean
lemma lanAdjunction_counit_app (G : D ⥤ H) :
    (L.lanAdjunction H).counit.app G =
      descOfIsLeftKanExtension (L.lan.obj (L ⋙ G)) (L.lanUnit.app (L ⋙ G)) G (𝟙 (L ⋙ G))
-- Mathlib/CategoryTheory/Bicategory/Free.lean
@[simp]
theorem mk_right_unitor_hom : Quot.mk _ (Hom₂.right_unitor f) = (ρ_ f).hom
-- Mathlib/GroupTheory/Torsion.lean
/-- Subgroups of torsion-free groups are torsion-free. -/
@[to_additive "Subgroups of additive torsion-free groups are additively torsion-free."]
theorem IsTorsionFree.subgroup (tG : IsTorsionFree G) (H : Subgroup G) : IsTorsionFree H
-- Mathlib/SetTheory/Game/Basic.lean
theorem PGame.lf_iff_game_lf {x y : PGame} : PGame.LF x y ↔ ⟦x⟧ ⧏ ⟦y⟧
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
theorem LinearMap.rTensor_range :
    range (rTensor Q g) =
      range (rTensor Q (Submodule.subtype (range g)))
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1)
-- Mathlib/Algebra/Star/Order.lean
lemma StarModule.smul_lt_smul_of_pos {a b : A} {c : R} (hab : a < b) (hc : 0 < c) :
    c • a < c • b
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_nonneg [PosSMulMono α β] (ha : 0 ≤ a) (hb : 0 ≤ b₁) : 0 ≤ a • b₁
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem drop_set_of_lt (a : α) {n m : Nat} (l : List α) (h : n < m) :
    (l.set n a).drop m = l.drop m
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- A telescoping sum along `{0, ..., n-1}` of an `ℕ`-valued function
reduces to the difference of the last and first terms
when the function we are summing is monotone.
-/
theorem sum_range_tsub [CanonicallyOrderedAddCommMonoid α] [Sub α] [OrderedSub α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] {f : ℕ → α} (h : Monotone f) (n : ℕ) :
    ∑ i ∈ range n, (f (i + 1) - f i) = f n - f 0
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
/-- Lemma used to destruct perms element by element. -/
theorem perm_inv_core {a : α} {l₁ l₂ r₁ r₂ : List α} :
    l₁ ++ a :: r₁ ~ l₂ ++ a :: r₂ → l₁ ++ r₁ ~ l₂ ++ r₂
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := elab_as_elim)]
theorem induction_on {C : M ∗ N → Prop} (m : M ∗ N)
    (inl : ∀ m, C (inl m)) (inr : ∀ n, C (inr n)) (mul : ∀ x y, C x → C y → C (x * y)) : C m
-- Mathlib/Control/Traversable/Instances.lean
protected theorem id_traverse {σ α} (x : σ ⊕ α) :
    Sum.traverse (pure : α → Id α) x = x
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- The `affineSpan` of a finite affinely independent family is `⊤` iff the
family's cardinality is one more than that of the finite-dimensional space. -/
theorem AffineIndependent.affineSpan_eq_top_iff_card_eq_finrank_add_one [FiniteDimensional k V]
    [Fintype ι] {p : ι → P} (hi : AffineIndependent k p) :
    affineSpan k (Set.range p) = ⊤ ↔ Fintype.card ι = finrank k V + 1
-- Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean
/-- A predicate `C → Prop` on the objects of a category is closed under isomorphisms
if whenever `P X`, then all the objects `Y` that are isomorphic to `X` also satisfy `P Y`. -/
class ClosedUnderIsomorphisms : Prop where
  of_iso {X Y : C} (_ : X ≅ Y) (_ : P X) : P Y
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem measurable_comp_iff (hg : MeasurableEmbedding g) : Measurable (g ∘ f) ↔ Measurable f
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- The coercion from a closed subset is proper. -/
lemma isProperMap_subtype_val_of_closed {U : Set X} (hU : IsClosed U) : IsProperMap ((↑) : U → X)
-- Mathlib/Data/List/Nodup.lean
protected theorem Nodup.cons (ha : a ∉ l) (hl : Nodup l) : Nodup (a :: l)
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGreatest.nonempty (h : IsGreatest s a) : s.Nonempty
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem sub_mem_Ico_iff_right : a - b ∈ Set.Ico c d ↔ b ∈ Set.Ioc (a - d) (a - c)
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_lt_ceil_of_lt_of_pos {a b : α} (h : a < b) (h' : 0 < b) : ⌊a⌋₊ < ⌈b⌉₊
-- Mathlib/Data/Set/Finite.lean
@[nontriviality]
theorem Finite.of_subsingleton [Subsingleton α] (s : Set α) : s.Finite
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- If a function `f` is continuously polynomial on a set `s` and `g` is a continuous linear map,
then `g ∘ f` is continuously polynomial on `s`. -/
theorem ContinuousLinearMap.comp_cPolynomialOn {s : Set E} (g : F →L[𝕜] G)
    (h : CPolynomialOn 𝕜 f s) : CPolynomialOn 𝕜 (g ∘ f) s
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
theorem not_mem_adicCompletionIntegers {x : v.adicCompletion K} :
    x ∉ v.adicCompletionIntegers K ↔ 1 < (Valued.v x : ℤₘ₀)
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
lemma mapToEqualizer_eq_comp (P : Cᵒᵖ ⥤ Type*) {X B : C} (π : X ⟶ B) [HasPullback π π] :
    MapToEqualizer P π (pullback.fst π π) (pullback.snd π π) pullback.condition =
    equalizer.lift (P.map π.op) (equalizerCondition_w' P π) ≫
    (Types.equalizerIso _ _).hom
-- Mathlib/Data/List/Infix.lean
@[gcongr]
protected theorem Sublist.drop : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ n, l₁.drop n <+ l₂.drop n
-- Mathlib/ModelTheory/Substructures.lean
theorem map_closure (f : M →[L] N) (s : Set M) : (closure L s).map f = closure L (f '' s)
-- Mathlib/RepresentationTheory/Action/Basic.lean
/-- A homomorphism of `Action V G`s is a morphism between the underlying objects,
commuting with the action of `G`.
-/
@[ext]
structure Hom (M N : Action V G) where
  hom : M.V ⟶ N.V
  comm : ∀ g : G, M.ρ g ≫ hom = hom ≫ N.ρ g := by aesop_cat
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arccos_le_pi (x : ℝ) : arccos x ≤ π
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem HomogeneousIdeal.toIdeal_injective :
    Function.Injective (HomogeneousIdeal.toIdeal : HomogeneousIdeal 𝒜 → Ideal A)
-- Mathlib/CategoryTheory/GradedObject/Unitor.lean
@[reassoc]
lemma mapBifunctorLeftUnitor_inv_naturality :
    φ ≫ (mapBifunctorLeftUnitor F X e p hp Y').inv =
      (mapBifunctorLeftUnitor F X e p hp Y).inv ≫ mapBifunctorMapMap F p (𝟙 _) φ
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap_comm_of_commute (hc : ∀ (m : M) (n : N), Commute m.1 n.1) :
    mulMap N M = mulMap M N ∘ₗ TensorProduct.comm R N M
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
@[simp]
theorem edgeFinset_top [DecidableEq V] :
    (⊤ : SimpleGraph V).edgeFinset = univ.filter fun e => ¬e.IsDiag
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem wbtw_const_vsub_iff {x y z : P} (p : P) :
    Wbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Wbtw R x y z
-- Mathlib/Order/Partition/Equipartition.lean
lemma not_isEquipartition :
    ¬P.IsEquipartition ↔ ∃ a ∈ P.parts, ∃ b ∈ P.parts, b.card + 1 < a.card
-- Mathlib/CategoryTheory/Shift/ShiftSequence.lean
lemma shiftIso_zero (a : M) :
    F.shiftIso 0 a a (zero_add a) =
      isoWhiskerRight (shiftFunctorZero C M) _ ≪≫ leftUnitor _
-- Mathlib/Logic/Basic.lean
theorem by_contradiction {p : Prop} : (¬p → False) → p
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
@[simp]
theorem associatesNonZeroDivisorsEquivIsPrincipal_map_one :
    (associatesNonZeroDivisorsEquivIsPrincipal R 1 : Ideal R) = 1
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
/-- Each element of the monoid defines an additive monoid homomorphism. -/
@[simps]
def DistribMulAction.toAddMonoidEnd :
    M →* AddMonoid.End A
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·)
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma singularPart_eq_zero_iff_apply_eq_zero (κ η : Kernel α γ) [IsFiniteKernel κ]
    [IsFiniteKernel η] (a : α) :
    singularPart κ η a = 0 ↔ singularPart κ η a (mutuallySingularSetSlice κ η a) = 0
-- Mathlib/Order/Filter/Lift.lean
theorem map_lift'_eq2 {g : Set β → Set γ} {m : α → β} (hg : Monotone g) :
    (map m f).lift' g = f.lift' (g ∘ image m)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
/-- `K` and `Kᗮ` have trivial intersection. -/
theorem orthogonal_disjoint : Disjoint K Kᗮ
-- Mathlib/Analysis/Convex/Cone/Proper.lean
@[simp]
theorem mem_positive {x : E} : x ∈ positive 𝕜 E ↔ 0 ≤ x
-- Mathlib/Computability/Language.lean
theorem mem_kstar : x ∈ l∗ ↔ ∃ L : List (List α), x = L.join ∧ ∀ y ∈ L, y ∈ l
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_zero_sub_comm (a b : α) : toIocMod hp 0 (a - b) = p - toIcoMod hp 0 (b - a)
-- Mathlib/Data/Set/Function.lean
theorem insert_injOn (s : Set α) : sᶜ.InjOn fun a => insert a s
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem sum_to_range :
    Set.range (sum_to C ho) = GoodProducts (π C (ord I · < o)) ∪ MaxProducts C ho
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_of_le_sub_one (h : 0 < m) : n ≤ m - 1 → n < m
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem length_pos_of_mem {a : α} : ∀ {l : List α}, a ∈ l → 0 < length l
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem arrow_mk_iso_iff
    (P : AffineTargetMorphismProperty) [P.toProperty.RespectsIso]
    {X Y X' Y' : Scheme} {f : X ⟶ Y} {f' : X' ⟶ Y'}
    (e : Arrow.mk f ≅ Arrow.mk f') {h : IsAffine Y} :
    letI : IsAffine Y' := isAffine_of_isIso (Y := Y) e.inv.right
    P f ↔ P f'
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- All n-simplices among cospherical points in n-space have the same
circumsphere. -/
theorem exists_circumsphere_eq_of_cospherical {ps : Set P} {n : ℕ} [FiniteDimensional ℝ V]
    (hd : finrank ℝ V = n) (hc : Cospherical ps) :
    ∃ c : Sphere P, ∀ sx : Simplex ℝ P n, Set.range sx.points ⊆ ps → sx.circumsphere = c
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degreeOf_lt_iff {n : σ} {f : MvPolynomial σ R} {d : ℕ} (h : 0 < d) :
    degreeOf n f < d ↔ ∀ m : σ →₀ ℕ, m ∈ f.support → m n < d
-- Mathlib/Data/List/Cycle.lean
theorem Subsingleton.congr {s : Cycle α} (h : Subsingleton s) :
    ∀ ⦃x⦄ (_hx : x ∈ s) ⦃y⦄ (_hy : y ∈ s), x = y
-- Mathlib/Data/Complex/Basic.lean
theorem normSq_apply (z : ℂ) : normSq z = z.re * z.re + z.im * z.im
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem support_eq_empty {p : MvPolynomial σ R} : p.support = ∅ ↔ p = 0
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem add_descFactorial_eq_ascFactorial (n : ℕ) : ∀ k : ℕ,
    (n + k).descFactorial k = (n + 1).ascFactorial k
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem basis_one (h : IsAdjoinRootMonic S f) (hdeg : 1 < natDegree f) :
    h.basis ⟨1, hdeg⟩ = h.root
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[mono]
theorem restrict_mono [Preorder β] (s : Set α) {f g : α →ₛ β} (H : f ≤ g) :
    f.restrict s ≤ g.restrict s
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem T_pow' (n : ℕ) : T ^ 2 ^ n < 1
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem map_comap {β} (f : α → β) (m : OuterMeasure β) : map f (comap f m) = restrict (range f) m
-- Mathlib/Data/Nat/Factors.lean
theorem mem_primeFactorsList_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) {p : ℕ} :
    p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList
-- Mathlib/Data/List/InsertNth.lean
@[simp]
theorem insertNth_succ_nil (n : ℕ) (a : α) : insertNth (n + 1) a [] = []
-- Mathlib/Order/Filter/Basic.lean
theorem mem_map' : t ∈ map m f ↔ { x | m x ∈ t } ∈ f
-- Mathlib/MeasureTheory/Function/Jacobian.lean
theorem lintegral_abs_det_fderiv_le_addHaar_image (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) :
    (∫⁻ x in s, ENNReal.ofReal |(f' x).det| ∂μ) ≤ μ (f '' s)
-- Mathlib/Topology/Algebra/Algebra.lean
@[fun_prop]
protected theorem continuous (f : A →A[R] B) : Continuous f
-- Mathlib/FieldTheory/KummerExtension.lean
lemma Algebra.adjoin_root_eq_top_of_isSplittingField :
    Algebra.adjoin K {α} = ⊤
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.inf_le {I J P : Ideal R} (hp : IsPrime P) : I ⊓ J ≤ P ↔ I ≤ P ∨ J ≤ P
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[simp]
theorem coforkOfCokernelCofork_π (c : CokernelCofork (f - g)) :
    (coforkOfCokernelCofork c).π = c.π
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Fin.val_eq_of_eq {n} {i j : Fin n} (h : Eq i j) : Eq i.val j.val
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.exists_pow_eq' (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
    ∃ n : ℕ, (f ^ n) a = b
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp, norm_cast] lemma val_nnratCast (q : ℚ≥0) : (q : selfAdjoint R) = (q : R)
-- Mathlib/Topology/Homotopy/Basic.lean
theorem refl (f : C(X, Y)) (hf : P f) : HomotopicWith f f P
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem Matrix.isAdjointPair_equiv' [DecidableEq n] (P : Matrix n n R₃) (h : IsUnit P) :
    (Pᵀ * J * P).IsAdjointPair (Pᵀ * J * P) A A' ↔
      J.IsAdjointPair J (P * A * P⁻¹) (P * A' * P⁻¹)
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem disjoint_iff_comap_eq_bot {p q : Submodule R M} : Disjoint p q ↔ comap p.subtype q = ⊥
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp] lemma SpecΓIdentity_app : SpecΓIdentity.app R = ΓSpecIso R
-- Mathlib/RingTheory/Bialgebra/Hom.lean
theorem coe_linearMap_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₗ[R] B)
-- Mathlib/Data/Set/Lattice.lean
@[congr]
theorem iUnion_congr_Prop {p q : Prop} {f₁ : p → Set α} {f₂ : q → Set α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iUnion f₁ = iUnion f₂
-- Mathlib/Dynamics/PeriodicPts.lean
theorem mk_mem_periodicPts (hn : 0 < n) (hx : IsPeriodicPt f n x) : x ∈ periodicPts f
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mk_type (α A) : «Type» ⟨α, A⟩ = α
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem nhdsWithin_Iio_self_neBot' {b : α} (H : (Iio b).Nonempty) : NeBot (𝓝[<] b)
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
length `> i`. Version designed to rewrite from the small list to the big list. -/
theorem getElem_take' (L : List α) {j i : Nat} {h : i < (L.take j).length} :
    (L.take j)[i] =
    L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _))
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem mem_inf {x} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_map (f : M →ₗ[R'] N) (x : TrivSqZeroExt R' M) : fst (map f x) = fst x
-- Mathlib/Data/Matroid/Map.lean
lemma map_comap {f : α → β} (h_range : N.E ⊆ range f) (hf : InjOn f (f ⁻¹' N.E)) :
    (N.comap f).map f hf = N
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
@[simp]
theorem isBounded_iff_isVonNBounded {s : Set E} :
    @IsBounded _ (vonNBornology 𝕜 E) s ↔ IsVonNBounded 𝕜 s
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem range_smul (f : V →ₗ[K] V₂) (a : K) (h : a ≠ 0) : range (a • f) = range f
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma generateFrom_iUnion_countablePartition (α : Type*) [m : MeasurableSpace α]
    [CountablyGenerated α] :
    generateFrom (⋃ n, countablePartition α n) = m
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpL2_indicator_nonneg (hm : m ≤ m0) (hs : MeasurableSet s) (hμs : μ s ≠ ∞)
    [SigmaFinite (μ.trim hm)] : (0 : α → ℝ) ≤ᵐ[μ]
    condexpL2 ℝ ℝ hm (indicatorConstLp 2 hs hμs 1)
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem aemeasurable_deriv [MeasurableSpace 𝕜] [OpensMeasurableSpace 𝕜] [MeasurableSpace F]
    [BorelSpace F] (f : 𝕜 → F) (μ : Measure 𝕜) : AEMeasurable (deriv f) μ
-- Mathlib/Combinatorics/SimpleGraph/Dart.lean
theorem Dart.symm_ne (d : G.Dart) : d.symm ≠ d
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
lemma levyProkhorovEDist_le_max_measure_univ (μ ν : Measure Ω) :
    levyProkhorovEDist μ ν ≤ max (μ univ) (ν univ)
-- Mathlib/FieldTheory/IntermediateField.lean
protected theorem coe_inv (x : S) : (↑x⁻¹ : L) = (↑x)⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_lt_sub_of_lt_of_le {a b c d : Int}
  (hab : a < b) (hcd : c ≤ d) : a - d < b - c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem hasDerivAt_sinh (x : ℝ) : HasDerivAt sinh (cosh x) x
-- Mathlib/Algebra/Star/Unitary.lean
theorem _root_.IsUnit.mem_unitary_of_mul_star_self {u : R} (hu : IsUnit u)
    (h_mul : u * star u = 1) : u ∈ unitary R
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem Disjoint.cycleOf_mul_distrib [DecidableRel (f * g).SameCycle]
    [DecidableRel (g * f).SameCycle]  (h : f.Disjoint g) (x : α) :
    (f * g).cycleOf x = f.cycleOf x * g.cycleOf x
-- Mathlib/Data/PNat/Prime.lean
@[simp]
theorem not_prime_one : ¬(1 : ℕ+).Prime
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_localTrivAt_source (p : Z.TotalSpace) (b : B) :
    p ∈ (Z.localTrivAt b).source ↔ p.1 ∈ (Z.localTrivAt b).baseSet
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma whiskerLeft_mapId_hom (f : a ⟶ b) : F.map f ◁ (F.mapId b).hom =
    (F.mapComp f (𝟙 b)).inv ≫ F.map₂ (ρ_ f).hom ≫ (ρ_ (F.map f)).inv
-- Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
theorem gradedComm_algebraMap_tmul (r : R) (b : ⨁ i, ℬ i) :
    gradedComm R 𝒜 ℬ (algebraMap R _ r ⊗ₜ b) = b ⊗ₜ algebraMap R _ r
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem bind_eq_bind : bind = @Option.bind α β
-- Mathlib/Data/Set/Lattice.lean
lemma kernImage_compl {s : Set α} : kernImage f (sᶜ) = (f '' s)ᶜ
-- Mathlib/Data/Fintype/Pi.lean
@[simp]
theorem mem_piFinset {t : ∀ a, Finset (δ a)} {f : ∀ a, δ a} : f ∈ piFinset t ↔ ∀ a, f a ∈ t a
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem coe_one : ⇑(1 : CircleDeg1Lift) = id
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem exp_mul_I_antiperiodic : Function.Antiperiodic (fun x => exp (x * I)) π
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_apply₀ (ht : NullMeasurableSet t (μ.restrict s)) : μ.restrict s t = μ (t ∩ s)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem sinh_pos_iff : 0 < sinh x ↔ 0 < x
-- Mathlib/Topology/UrysohnsLemma.lean
theorem left_U_subset_right_C (c : CU P) : c.left.U ⊆ c.right.C
-- Mathlib/RingTheory/Localization/Integral.lean
theorem integerNormalization_spec (p : S[X]) :
    ∃ b : M, ∀ i, algebraMap R S ((integerNormalization M p).coeff i) = (b : R) • p.coeff i
-- Mathlib/Data/Vector/Basic.lean
/-- The `tail` of a vector made up of one element is `nil`. -/
@[simp]
theorem singleton_tail : ∀ (v : Vector α 1), v.tail = Vector.nil
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_st {x : ℝ*} (hx : st x ≠ 0) : IsSt x (st x)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem _root_.MeasureTheory.Memℒp.ofReal {f : α → ℝ} (hf : Memℒp f p μ) :
    Memℒp (fun x => (f x : K)) p μ
-- Mathlib/Algebra/DirectSum/Basic.lean
theorem mk_apply_of_mem {s : Finset ι} {f : ∀ i : (↑s : Set ι), β i.val} {n : ι} (hn : n ∈ s) :
    mk β s f n = f ⟨n, hn⟩
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_union_Ico_eq_Iio (h : a ≤ b) : Iio a ∪ Ico a b = Iio b
-- Mathlib/Algebra/Star/Subsemiring.lean
theorem toSubsemiring_inj {S U : StarSubsemiring R} : S.toSubsemiring = U.toSubsemiring ↔ S = U
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem coe_fn_mk (f : α ≃ β) (o : ∀ ⦃a b⦄, s (f a) (f b) ↔ r a b) :
    (RelIso.mk f @o : α → β) = f
-- Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean
lemma refl (γ : OneCochain G U) : OneCohomologyRelation γ γ 1
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem frobenius_nnnorm_conjTranspose [StarAddMonoid α] [NormedStarGroup α] (A : Matrix m n α) :
    ‖Aᴴ‖₊ = ‖A‖₊
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
lemma zero_pow_eq_zero [Nontrivial M₀] : (0 : M₀) ^ n = 0 ↔ n ≠ 0
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
theorem measure_preimage {f : α → β} (hf : MeasurePreserving f μa μb) {s : Set β}
    (hs : NullMeasurableSet s μb) : μa (f ⁻¹' s) = μb s
-- Mathlib/Data/Int/Order/Lemmas.lean
theorem eq_zero_of_abs_lt_dvd {m x : ℤ} (h1 : m ∣ x) (h2 : |x| < m) : x = 0
-- Mathlib/Algebra/Field/Subfield.lean
theorem map_iSup {ι : Sort*} (f : K →+* L) (s : ι → Subfield K) :
    (iSup s).map f = ⨆ i, (s i).map f
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_cases (P : A → Prop) (a : A) (f : R → R) (h₀ : P 0)
    (haf : ∀ (hf : ContinuousOn f (σₙ R a)) h0 ha, P (cfcₙHom ha ⟨⟨_, hf.restrict⟩, h0⟩)) :
    P (cfcₙ f a)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem gc_map_comap (f : R →+* S) : GaloisConnection (map f) (comap f)
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem toEuclideanLin_apply_piLp_equiv_symm (M : Matrix m n 𝕜) (v : n → 𝕜) :
    toEuclideanLin M ((WithLp.equiv 2 (n→ 𝕜)).symm v) = (WithLp.equiv 2 (m → 𝕜)).symm (M *ᵥ v)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem comp_eq_zero_iff : p.comp q = 0 ↔ p = 0 ∨ p.eval (q.coeff 0) = 0 ∧ q = C (q.coeff 0)
-- Mathlib/Data/Finset/NAry.lean
theorem Nonempty.of_image₂_right (h : (s.image₂ f t).Nonempty) : t.Nonempty
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrixAlgEquiv'_mul (f g : (n → R) →ₗ[R] n → R) :
    LinearMap.toMatrixAlgEquiv' (f * g) =
      LinearMap.toMatrixAlgEquiv' f * LinearMap.toMatrixAlgEquiv' g
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem mem_powers (n : M) : n ∈ powers n
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
theorem ContinuousMultilinearMap.uncurry0_norm (f : G[×0]→L[𝕜] G') : ‖f.uncurry0‖ = ‖f‖
-- Mathlib/Algebra/IsPrimePow.lean
theorem IsPrimePow.two_le : ∀ {n : ℕ}, IsPrimePow n → 2 ≤ n
-- Mathlib/Data/Stream/Init.lean
theorem identity (s : Stream' α) : pure id ⊛ s = s
-- Mathlib/Algebra/Algebra/Operations.lean
protected theorem mul_comm : M * N = N * M
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp]
theorem ofNat_apply (n : ℕ) [n.AtLeastTwo] (a : α) : (OfNat.ofNat n : ∀ a, π a) a = n
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem isNone_none : @isNone α none = true
-- Mathlib/Order/Atoms.lean
protected theorem eq_bot_iff [∀ i, Bot (π i)] {f : ∀ i, π i} : f = ⊥ ↔ ∀ i, f i = ⊥
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If a function is at least `C^1`, its bundled derivative (mapping `(x, v)` to `Df(x) v`) is
continuous. -/
theorem ContDiff.continuous_fderiv_apply (h : ContDiff 𝕜 n f) (hn : 1 ≤ n) :
    Continuous fun p : E × E => (fderiv 𝕜 f p.1 : E → F) p.2
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- The nonsingular inverse is the same as the general `Ring.inverse`. -/
theorem nonsing_inv_eq_ring_inverse : A⁻¹ = Ring.inverse A
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- The angle ∡ABA at a point. -/
@[simp]
theorem oangle_self_left_right (p₁ p₂ : P) : ∡ p₁ p₂ p₁ = 0
-- Mathlib/Order/Compare.lean
theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem sl_moeb (A : SL(2, ℤ)) (z : ℍ) : A • z = (A : GL(2, ℝ)⁺) • z
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Application of a `ContinuousLinearMap` to a constant commutes with `iteratedFDeriv`. -/
theorem iteratedFDeriv_clm_apply_const_apply
    {n : ℕ∞} {c : E → F →L[𝕜] G} (hc : ContDiff 𝕜 n c)
    {i : ℕ} (hi : i ≤ n) {x : E} {u : F} {m : Fin i → E} :
    (iteratedFDeriv 𝕜 i (fun y ↦ (c y) u) x) m = (iteratedFDeriv 𝕜 i c x) m u