ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Combinatorics/Configuration.lean
theorem card_lines [Finite P] [Fintype L] : Fintype.card L = order P L ^ 2 + order P L + 1
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem intCast_imK (z : ℤ) : (z : ℍ[R,c₁,c₂]).imK = 0
-- Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean
@[simp]
theorem zeroProdIso_hom (X : C) : (zeroProdIso X).hom = prod.snd
-- Mathlib/Data/Rat/Lemmas.lean
theorem add_num_den (q r : ℚ) :
    q + r = (q.num * r.den + q.den * r.num : ℤ) /. (↑q.den * ↑r.den : ℤ)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
lemma top_induce_pair_connected_of_adj {u v : V} (huv : G.Adj u v) :
    ((⊤ : G.Subgraph).induce {u, v}).Connected
-- Mathlib/ModelTheory/Algebra/Field/CharP.lean
theorem charP_of_model_fieldOfChar [Field K] [CompatibleRing K]
    [h : (Theory.fieldOfChar p).Model K] : CharP K p
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem eventually_mem_set {s : Set α} {l : Filter α} : (∀ᶠ x in l, x ∈ s) ↔ s ∈ l
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_tendsto_of_tendsto_of_antitone {f : ℕ → α → ℝ≥0∞} {F : α → ℝ≥0∞}
    (hf : ∀ n, AEMeasurable (f n) μ) (h_anti : ∀ᵐ x ∂μ, Antitone fun n ↦ f n x)
    (h0 : ∫⁻ a, f 0 a ∂μ ≠ ∞)
    (h_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n ↦ f n x) atTop (𝓝 (F x))) :
    Tendsto (fun n ↦ ∫⁻ x, f n x ∂μ) atTop (𝓝 (∫⁻ x, F x ∂μ))
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ico_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ico a b ∈ 𝓝[>] a
-- Mathlib/Topology/Homeomorph.lean
theorem preimage_closure (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' closure s = closure (h ⁻¹' s)
-- Mathlib/Logic/Function/Basic.lean
theorem InvImage.equivalence {α : Sort u} {β : Sort v} (r : β → β → Prop) (f : α → β)
    (h : Equivalence r) : Equivalence (InvImage r f)
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualAnnihilator_dualAnnihilator_eq (W : Subspace K V) :
    W.dualAnnihilator.dualAnnihilator = Module.mapEvalEquiv K V W
-- Mathlib/RingTheory/Derivation/Basic.lean
lemma leibniz_zpow (a : K) (n : ℤ) : D (a ^ n) = n • a ^ (n - 1) • D a
-- Mathlib/Order/Lattice.lean
theorem map_sup [SemilatticeSup β] (hf : MonotoneOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    f (x ⊔ y) = f x ⊔ f y
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_one_nat_atTop_iff {f : ℕ → E''} :
    f =O[atTop] (fun _n => 1 : ℕ → ℝ) ↔ ∃ C, ∀ n, ‖f n‖ ≤ C
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_of_mem (st : t ∈ 𝓝[s] x) (ht : UniqueDiffWithinAt 𝕜 s x)
    (h : DifferentiableWithinAt 𝕜 f t x) : fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
/-- If `CommMonoid` homs `g : M →* P, l : P →* A` induce maps of localizations, the composition
of the induced maps equals the map of localizations induced by `l ∘ g`. -/
@[to_additive
    "If `AddCommMonoid` homs `g : M →+ P, l : P →+ A` induce maps of localizations, the composition
of the induced maps equals the map of localizations induced by `l ∘ g`."]
theorem map_map {A : Type*} [CommMonoid A] {U : Submonoid A} {R} [CommMonoid R]
    (j : LocalizationMap U R) {l : P →* A} (hl : ∀ w : T, l w ∈ U) (x) :
    k.map hl j (f.map hy k x) = f.map (fun x ↦ show l.comp g x ∈ U from hl ⟨g x, hy x⟩) j x
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_le_iff_le_sinh :
    dist z w ≤ r ↔ dist (z : ℂ) w / (2 * √(z.im * w.im)) ≤ sinh (r / 2)
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousAt_iff_le_liminf {f : α → γ} :
    LowerSemicontinuousAt f x ↔ f x ≤ liminf f (𝓝 x)
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem multipliable_subtype_and_compl {s : Set β} :
    ((Multipliable fun x : s ↦ f x) ∧ Multipliable fun x : ↑sᶜ ↦ f x) ↔ Multipliable f
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- Introduction rule to prove that `b` is the supremum of `s`: it suffices to check that
1) `b` is an upper bound
2) every other upper bound `b'` satisfies `b ≤ b'`. -/
theorem csSup_eq_of_is_forall_le_of_forall_le_imp_ge (hs : s.Nonempty) (h_is_ub : ∀ a ∈ s, a ≤ b)
    (h_b_le_ub : ∀ ub, (∀ a ∈ s, a ≤ ub) → b ≤ ub) : sSup s = b
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- An affine-independent subset of a finite-dimensional affine space is finite. -/
theorem finite_set_of_fin_dim_affineIndependent [FiniteDimensional k V] {s : Set ι} {f : s → P}
    (hi : AffineIndependent k f) : s.Finite
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem prod_apply (i) :
    b.prod b' i = Sum.elim (LinearMap.inl R M M' ∘ b) (LinearMap.inr R M M' ∘ b') i
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[simp]
theorem ε_app_obj (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (F.μIso n (𝟙_ M)).inv.app X
-- Mathlib/Control/LawfulFix.lean
theorem LawfulFix.fix_eq' {α} [OmegaCompletePartialOrder α] [LawfulFix α] {f : α → α}
    (hf : Continuous' f) : Fix.fix f = f (Fix.fix f)
-- Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean
theorem contsAux_stable_of_terminated (n_lt_m : n < m) (terminatedAt_n : g.TerminatedAt n) :
    g.contsAux m = g.contsAux (n + 1)
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Removal.lean
/-- **Triangle Removal Lemma**. If there are not too many triangles (on the order of `(card α)^3`)
then they can all be removed by removing a few edges (on the order of `(card α)^2`). -/
lemma triangle_removal (hG : (G.cliqueFinset 3).card < triangleRemovalBound ε * card α ^ 3) :
    ∃ G' ≤ G, ∃ _ : DecidableRel G'.Adj,
      (G.edgeFinset.card - G'.edgeFinset.card : ℝ) < ε * (card α^2 : ℕ) ∧ G'.CliqueFree 3
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem algebraMap_mem (r : R) : algebraMap R A r ∈ S
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extend_target' : (f.extend I).target = I '' f.target
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
/-- Slightly stronger than `OuterMeasure.mono` having an intersection with `p.support`. -/
theorem toOuterMeasure_mono {s t : Set α} (h : s ∩ p.support ⊆ t) :
    p.toOuterMeasure s ≤ p.toOuterMeasure t
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem discreteTopology_of_isOpen_singleton_one (h : IsOpen ({1} : Set G)) :
    DiscreteTopology G
-- Mathlib/Data/Nat/Bitwise.lean
lemma bitwise_of_ne_zero {n m : Nat} (hn : n ≠ 0) (hm : m ≠ 0) :
    bitwise f n m = bit (f (bodd n) (bodd m)) (bitwise f (n / 2) (m / 2))
-- Mathlib/CategoryTheory/Generator.lean
theorem groupoid_of_isDetecting_empty (h : IsDetecting (∅ : Set C)) {X Y : C} (f : X ⟶ Y) :
    IsIso f
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_left_left_iff {x y z : R} : IsCoprime (y * z + x) y ↔ IsCoprime x y
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem num_zero_eq (h_inj : Function.Injective (algebraMap R P)) :
    num (0 : FractionalIdeal S P) = 0
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- The multiplicative unit of rational functions. -/
protected irreducible_def one : RatFunc K
-- Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean
theorem seqTendstoAeSeq_strictMono (hfg : TendstoInMeasure μ f atTop g) :
    StrictMono (seqTendstoAeSeq hfg)
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm of `p` is `p⁻¹` if `p > 1`.

See also `padicNorm.padicNorm_p_of_prime` for a version assuming `p` is prime. -/
theorem padicNorm_p (hp : 1 < p) : padicNorm p p = (p : ℚ)⁻¹
-- Mathlib/Data/Setoid/Partition.lean
/-- Distinct elements of a set of sets partitioning α are disjoint. -/
theorem eqv_classes_disjoint {c : Set (Set α)} (H : ∀ a, ∃! b ∈ c, a ∈ b) :
    c.PairwiseDisjoint id
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem incMatrix_mul_transpose_diag [Fintype (neighborSet G a)] :
    (G.incMatrix R * (G.incMatrix R)ᵀ) a a = G.degree a
-- Mathlib/Topology/Maps/Basic.lean
theorem isClosed_iff' (hf : Inducing f) {s : Set X} :
    IsClosed s ↔ ∀ x, f x ∈ closure (f '' s) → x ∈ s
-- Mathlib/FieldTheory/Galois.lean
theorem IsGalois.tower_top_of_isGalois [IsGalois F E] : IsGalois K E
-- Mathlib/CategoryTheory/Limits/Connected.lean
/-- (Impl).
Given a cone for (X × K -), produce a cone for K using the natural transformation `γ₂` -/
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem mem_vanishingIdeal_singleton_iff (x : σ → k) (p : MvPolynomial σ k) :
    p ∈ (vanishingIdeal {x} : Ideal (MvPolynomial σ k)) ↔ eval x p = 0
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
/-- Negation of the condition `P : Prop` in a `dite` is the same as swapping the branches. -/
@[simp] theorem dite_not [hn : Decidable (¬p)] [h : Decidable p]  (x : ¬p → α) (y : ¬¬p → α) :
    dite (¬p) x y = dite p (fun h => y (not_not_intro h)) x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem add_right_comm (a b c : Int) : a + b + c = a + c + b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem pi_le_four : π ≤ 4
-- Mathlib/Analysis/Normed/Field/Basic.lean
protected theorem List.nnnorm_prod (l : List α) : ‖l.prod‖₊ = (l.map nnnorm).prod
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@[simp]
theorem mk'_algebraMap [Algebra R A] [IsScalarTower R A B] (x : R)
    (h : IsIntegral R (algebraMap R B x) := isIntegral_algebraMap) :
    IsIntegralClosure.mk' A (algebraMap R B x) h = algebraMap R A x
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem Preconnected.map {G : SimpleGraph V} {H : SimpleGraph V'} (f : G →g H) (hf : Surjective f)
    (hG : G.Preconnected) : H.Preconnected
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
lemma support_mul_subset_left (f g : ι → M₀) : support (fun x ↦ f x * g x) ⊆ support f
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem Perm.extendDomain_symm : (e.extendDomain f).symm = Perm.extendDomain e.symm f
-- Mathlib/RingTheory/WittVector/MulP.lean
@[simp]
theorem bind₁_wittMulN_wittPolynomial (n k : ℕ) :
    bind₁ (wittMulN p n) (wittPolynomial p ℤ k) = n * wittPolynomial p ℤ k
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
/-- The cast of the successor is the successor of the cast. See `Fin.succ_cast_eq` for rewriting in
the reverse direction. -/
@[simp] theorem cast_succ_eq {n' : Nat} (i : Fin n) (h : n.succ = n'.succ) :
    cast h i.succ = (cast (Nat.succ.inj h) i).succ
-- Mathlib/Algebra/Star/StarAlgHom.lean
theorem ofBijective_apply {f : F} (hf : Function.Bijective f) (a : A) :
    (StarAlgEquiv.ofBijective f hf) a = f a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_min_mul_left (a b c : Nat) : min (a * b) (a * c) = a * min b c
-- Mathlib/Data/Finset/Basic.lean
theorem Nonempty.not_empty_toList {s : Finset α} (hs : s.Nonempty) : ¬s.toList.isEmpty
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem interior_Ioi : interior (Ioi a) = Ioi a
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpIndSMul_nonneg {E} [NormedLatticeAddCommGroup E] [NormedSpace ℝ E] [OrderedSMul ℝ E]
    [SigmaFinite (μ.trim hm)] (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : E) (hx : 0 ≤ x) :
    (0 : α → E) ≤ᵐ[μ] condexpIndSMul hm hs hμs x
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem equiv_comp_equiv_apply (x : L) :
    equiv j k p (equiv i j p x) = equiv i k p x
-- Mathlib/Data/Nat/Digits.lean
/-- an n-digit number in base b is less than b^n if b > 1 -/
theorem ofDigits_lt_base_pow_length {b : ℕ} {l : List ℕ} (hb : 1 < b) (hl : ∀ x ∈ l, x < b) :
    ofDigits b l < b ^ l.length
-- Mathlib/GroupTheory/Sylow.lean
/-- A Sylow `p`-subgroup is a maximal `p`-subgroup. -/
structure Sylow extends Subgroup G where
  isPGroup' : IsPGroup p toSubgroup
  is_maximal' : ∀ {Q : Subgroup G}, IsPGroup p Q → toSubgroup ≤ Q → Q = toSubgroup
-- Mathlib/MeasureTheory/Function/SimpleFuncDense.lean
/-- A continuous function with compact support on a product space is measurable for the product
sigma-algebra. The subtlety is that we do not assume that the spaces are separable, so the
product of the Borel sigma algebras might not contain all open sets, but still it contains enough
of them to approximate compactly supported continuous functions. -/
lemma HasCompactSupport.measurable_of_prod
    [TopologicalSpace α] [PseudoMetrizableSpace α] [MeasurableSpace α] [BorelSpace α]
    {f : X × Y → α} (hf : Continuous f) (h'f : HasCompactSupport f) :
    Measurable f
-- Mathlib/Topology/Bornology/Hom.lean
@[simp]
theorem id_apply (a : α) : LocallyBoundedMap.id α a = a
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem reindexRange_apply (x : range b) : b.reindexRange x = x
-- Mathlib/Combinatorics/SetFamily/FourFunctions.lean
/-- Special case of the **Four Functions Theorem** when `s = t = univ`. -/
lemma four_functions_theorem_univ (h₁ : 0 ≤ f₁) (h₂ : 0 ≤ f₂) (h₃ : 0 ≤ f₃) (h₄ : 0 ≤ f₄)
    (h : ∀ a b, f₁ a * f₂ b ≤ f₃ (a ⊓ b) * f₄ (a ⊔ b)) :
    (∑ a, f₁ a) * ∑ a, f₂ a ≤ (∑ a, f₃ a) * ∑ a, f₄ a
-- Mathlib/Algebra/Order/Field/Basic.lean
lemma strictMono_div_right_of_pos (ha : 0 < a) : StrictMono (· / a)
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_subset_left (ht : t₁ ⊆ t₂) : s ○ t₁ ⊆ s ○ t₂
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.mulVecLin_add [Fintype n] (M N : Matrix m n R) :
    (M + N).mulVecLin = M.mulVecLin + N.mulVecLin
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[simp]
theorem isCyclic_multiplicative_iff [AddGroup α] : IsCyclic (Multiplicative α) ↔ IsAddCyclic α
-- Mathlib/RepresentationTheory/Invariants.lean
theorem isProj_averageMap : LinearMap.IsProj ρ.invariants ρ.averageMap
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt32.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).toNat = n % UInt32.size
-- Mathlib/Analysis/Analytic/Basic.lean
theorem summable_nnnorm_mul_pow (p : FormalMultilinearSeries 𝕜 E F) {r : ℝ≥0} (h : ↑r < p.radius) :
    Summable fun n : ℕ => ‖p n‖₊ * r ^ n
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem nonpos_of_mul_nonneg_left [PosMulStrictMono α]
    (h : 0 ≤ a * b) (hb : b < 0) : a ≤ 0
-- Mathlib/Algebra/Lie/Weights/Cartan.lean
theorem mem_zeroRootSubalgebra (x : L) :
    x ∈ zeroRootSubalgebra R L H ↔ ∀ y : H, ∃ k : ℕ, (toEnd R H L y ^ k) x = 0
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma continuous_iff_continuous_dist [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ Continuous fun x : β × β => dist (f x.1) (f x.2)
-- Mathlib/RingTheory/WittVector/Frobenius.lean
/-- `WittVector.frobenius` as an equiv. -/
@[simps (config := .asFn)]
def frobeniusEquiv [PerfectRing R p] : WittVector p R ≃+* WittVector p R
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isNat_dvd_false : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.mod b' a' = Nat.succ c → ¬a ∣ b
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem toEquiv_refl : (refl k P₁).toEquiv = Equiv.refl P₁
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_toSubmonoid : (s.toSubmonoid : Set K) = s
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem lowerClosure_prod (s : Set α) (t : Set β) :
    lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biproductComparison_π (j : J) :
    biproductComparison F f ≫ biproduct.π _ j = F.map (biproduct.π f j)
-- Mathlib/Topology/IsLocalHomeomorph.lean
protected theorem comp (hg : IsLocalHomeomorphOn g t) (hf : IsLocalHomeomorphOn f s)
    (h : Set.MapsTo f s t) : IsLocalHomeomorphOn (g ∘ f) s
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem coe_map (S : NonUnitalStarSubalgebra R A) (f : F) : map f S = f '' S
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem union_ae_eq_right : (s ∪ t : Set α) =ᵐ[μ] t ↔ μ (s \ t) = 0
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_const_mul_id (r : R) (a : A) (ha : p a := by cfc_tac) : cfcₙ (r * ·) a = r • a
-- Mathlib/LinearAlgebra/Semisimple.lean
lemma isSemisimple_iff :
    f.IsSemisimple ↔ ∀ p : Submodule R M, p ≤ p.comap f → ∃ q, q ≤ q.comap f ∧ IsCompl p q
-- Mathlib/Algebra/Associated/Basic.lean
theorem map {M N : Type*} [Monoid M] [Monoid N] {F : Type*} [FunLike F M N] [MonoidHomClass F M N]
    (f : F) {x y : M} (ha : Associated x y) : Associated (f x) (f y)
-- Mathlib/Algebra/GradedMonoid.lean
@[simp]
theorem mk_zero_smul {i} (a : A 0) (b : A i) : mk _ (a • b) = mk _ a * mk _ b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_eq_cfc_iff_eqOn : cfc f a = cfc g a ↔ (spectrum R a).EqOn f g
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem IsCompact.closedBall_one_mul (hs : IsCompact s) (hδ : 0 ≤ δ) :
    closedBall 1 δ * s = cthickening δ s
-- Mathlib/Order/BoundedOrder.lean
theorem top_unique (h : ⊤ ≤ a) : a = ⊤
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma snd_zero : snd (0 : Kernel α (β × γ)) = 0
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- The preimage of the normalizer is contained in the normalizer of the preimage. -/
@[to_additive "The preimage of the normalizer is contained in the normalizer of the preimage."]
theorem le_normalizer_comap (f : N →* G) :
    H.normalizer.comap f ≤ (H.comap f).normalizer
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem deriv_sinh (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.sinh (f x)) x = Real.cosh (f x) * deriv f x
-- Mathlib/RingTheory/Filtration.lean
/-- Also see `Ideal.isIdempotentElem_iff_eq_bot_or_top` for integral domains. -/
theorem Ideal.isIdempotentElem_iff_eq_bot_or_top_of_localRing {R} [CommRing R]
    [IsNoetherianRing R] [LocalRing R] (I : Ideal R) :
    IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- Map `WithTerminal` with respect to a functor `F : C ⥤ D`. -/
@[simps]
def map {D : Type*} [Category D] (F : C ⥤ D) : WithTerminal C ⥤ WithTerminal D
-- Mathlib/Topology/Homotopy/Basic.lean
@[simp]
theorem extend_apply_coe (F : Homotopy f₀ f₁) (t : I) (x : X) : F.extend t x = F (t, x)
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- If `f` is closable, then the closure is closed. -/
theorem IsClosable.closure_isClosed {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure.IsClosed
-- Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean
/-- The inverse of an atlas member is `C^n` for any `n`. -/
theorem contMDiffOn_symm_of_mem_maximalAtlas (h : e ∈ maximalAtlas I M) :
    ContMDiffOn I I n e.symm e.target
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt32.toUInt64_toNat (x : UInt32) : x.toUInt64.toNat = x.toNat
-- Mathlib/LinearAlgebra/Ray.lean
@[simp]
theorem Module.Ray.map_apply (e : M ≃ₗ[R] N) (v : M) (hv : v ≠ 0) :
    Module.Ray.map e (rayOfNeZero _ v hv) = rayOfNeZero _ (e v) (e.map_ne_zero_iff.2 hv)
-- Mathlib/Data/Sym/Sym2/Order.lean
@[simp] theorem inf_mk [SemilatticeInf α] (a b : α) : s(a, b).inf = a ⊓ b
-- Mathlib/Analysis/Complex/Basic.lean
@[simp 1100]
theorem norm_nat (n : ℕ) : ‖(n : ℂ)‖ = n
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem coe_inf (I J : HomogeneousIdeal 𝒜) : (↑(I ⊓ J) : Set A) = ↑I ∩ ↑J
-- Mathlib/Data/Finset/Lattice.lean
/-- See also `Finset.prodMk_inf'_inf'`. -/
-- @[simp] -- TODO: Why does `Prod.map_apply` simplify the LHS?
lemma inf'_prodMap (hst : (s ×ˢ t).Nonempty) (f : ι → α) (g : κ → β) :
    inf' (s ×ˢ t) hst (Prod.map f g) = (inf' s hst.fst f, inf' t hst.snd g)
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp, norm_cast] lemma coe_one : ⇑(1 : Perm α) = id
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[fun_prop]
theorem continuousOn_cos {s : Set ℂ} : ContinuousOn cos s
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
/-- Deprecated. Use `WfDvdMonoid.max_power_factor` instead. -/
@[deprecated WfDvdMonoid.max_power_factor (since := "2024-03-01")]
theorem max_power_factor {a₀ x : R} (h : a₀ ≠ 0) (hx : Irreducible x) :
    ∃ n : ℕ, ∃ a : R, ¬x ∣ a ∧ a₀ = x ^ n * a
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_le_iInf₂ (κ : ι → Sort*) (f : ι → α) : ⨅ i, f i ≤ ⨅ (i) (_ : κ i), f i
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem HasFDerivAt.cexp (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.exp (f x)) (Complex.exp (f x) • f') x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffine_of_Z_ne_zero {P : Fin 3 → F} (hP : W.Nonsingular P) (hPz : P z ≠ 0) :
    toAffine W P = .some ((nonsingular_of_Z_ne_zero hPz).mp hP)
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem nndist_eq_nnnorm_vsub' (x y : P) : nndist x y = ‖y -ᵥ x‖₊
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast]
theorem coe_sInf {S : Set (Closeds α)} : (↑(sInf S) : Set α) = ⋂ i ∈ S, ↑i
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_prod {s : LowerSet α} {t : LowerSet β} : x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem tendsto_inv₀_cobounded : Tendsto Inv.inv (cobounded α) (𝓝 0)
-- Mathlib/Probability/Martingale/Basic.lean
/-- The converse of this lemma is `MeasureTheory.submartingale_of_setIntegral_le`. -/
theorem setIntegral_le [SigmaFiniteFiltration μ ℱ] {f : ι → Ω → ℝ} (hf : Submartingale f ℱ μ)
    {i j : ι} (hij : i ≤ j) {s : Set Ω} (hs : MeasurableSet[ℱ i] s) :
    ∫ ω in s, f i ω ∂μ ≤ ∫ ω in s, f j ω ∂μ
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem associated_pow_irreducible {x : R} (hx : x ≠ 0) {ϖ : R} (hirr : Irreducible ϖ) :
    ∃ n : ℕ, Associated x (ϖ ^ n)
-- Mathlib/Algebra/MvPolynomial/Division.lean
theorem monomial_dvd_monomial {r s : R} {i j : σ →₀ ℕ} :
    monomial i r ∣ monomial j s ↔ (s = 0 ∨ i ≤ j) ∧ r ∣ s
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_intCast (z : ℤ) : ⇑(z : CentroidHom α) = z • (CentroidHom.id α)
-- Mathlib/Data/Finset/Prod.lean
theorem offDiag_insert (has : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[reassoc]
theorem curry_natural_left (f : X ⟶ X') (g : A ⊗ X' ⟶ Y) : curry (_ ◁ f ≫ g) = f ≫ curry g
-- Mathlib/Order/Concept.lean
theorem strictAnti_snd : StrictAnti (Prod.snd ∘ toProd : Concept α β r → Set β)
-- Mathlib/Topology/LocallyClosed.lean
lemma coborder_inter_closure :
    coborder s ∩ closure s = s
-- Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean
@[simp]
theorem valuationOfNeZeroToFun_eq (x : Kˣ) :
    (v.valuationOfNeZeroToFun x : ℤₘ₀) = v.valuation (x : K)
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- If `t` has the red-red invariant, then setting the root to black yields a balanced tree. -/
protected theorem RedRed.setBlack : t.RedRed p n → ∃ n', (setBlack t).Balanced black n'
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocMod_add_right (a b : α) : toIocMod hp a (b + p) = toIocMod hp a b
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- An intermediate equivalence `A ≅ B'` whose functor is `F` and whose inverse is
`e'.inverse ⋙ eA.inverse`. -/
@[simps! functor]
def equivalence₁ : A ≌ B'
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_ne_one {x : Icc (0 : α) 1} : (x : α) ≠ 1 ↔ x ≠ 1
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem erase_singleton (a : α) : ({a} : Multiset α).erase a = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem rank_eq (h : Acc r a) :
    h.rank = Ordinal.sup.{u, u} fun b : { b // r b a } => Order.succ (h.inv b.2).rank
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem volume_preserving_piUnique (π : ι → Type*) [Unique ι] [∀ i, MeasureSpace (π i)] :
    MeasurePreserving (MeasurableEquiv.piUnique π) volume volume
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp]
theorem smul_apply (r : R) (p : AddGroupSeminorm E) (x : E) : (r • p) x = r • p x
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem aeval_mem_adjoin_singleton :
    aeval x p ∈ Algebra.adjoin R {x}
-- Mathlib/Algebra/Order/Archimedean.lean
theorem exists_int_lt (x : α) : ∃ n : ℤ, (n : α) < x
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_toOuterMeasure_caratheodory (μ : Measure α) : ms ≤ μ.toOuterMeasure.caratheodory
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
@[simp] lemma support_inv (f : ι → G₀) : support (fun a ↦ (f a)⁻¹) = support f
-- Mathlib/Algebra/Module/Injective.lean
lemma Module.ulift_injective_of_injective [Small.{v} R]
    (inj : Module.Injective R M) :
    Module.Injective R (ULift.{v'} M)