ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Expressing uniform convergence using `dist`. -/
theorem tendstoUniformly_iff {F : ι → β → α} {f : β → α} {p : Filter ι} :
    TendstoUniformly F f p ↔ ∀ ε > 0, ∀ᶠ n in p, ∀ x, dist (f x) (F n x) < ε
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_update_one [DecidableEq α] (f : α → M) (x : α) :
    mulSupport (update f x 1) = mulSupport f \ {x}
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_pi_eq_bot {I : Set ι} {s : ∀ i, Set (π i)} {x : ∀ i, π i} :
    𝓝[pi I s] x = ⊥ ↔ ∃ i ∈ I, 𝓝[s i] x i = ⊥
-- Mathlib/Data/Multiset/Pi.lean
theorem cons_swap {a a' : α} {b : δ a} {b' : δ a'} {m : Multiset α} {f : ∀ a ∈ m, δ a}
    (h : a ≠ a') : HEq (Pi.cons (a' ::ₘ m) a b (Pi.cons m a' b' f))
      (Pi.cons (a ::ₘ m) a' b' (Pi.cons m a b f))
-- Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean
@[reassoc (attr := simp)]
lemma hom_inv_id : hom f g ≫ inv f g = 𝟙 _
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem refl_symm : (PartialEquiv.refl α).symm = PartialEquiv.refl α
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csInf_of_not_bddBelow {s : Set α} (hs : ¬BddBelow s) : sInf s = sInf ∅
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
@[simp]
theorem bind_pure : p.bind pure = p
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
/-- A matrix is positive semidefinite if and only if it has the form `Bᴴ * B` for some `B`. -/
lemma posSemidef_iff_eq_transpose_mul_self {A : Matrix n n 𝕜} :
    PosSemidef A ↔ ∃ (B : Matrix n n 𝕜), A = Bᴴ * B
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_finset_sum' (s : Finset β) {f : β → α → ℝ≥0∞}
    (hf : ∀ b ∈ s, AEMeasurable (f b) μ) :
    ∫⁻ a, ∑ b ∈ s, f b a ∂μ = ∑ b ∈ s, ∫⁻ a, f b a ∂μ
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
theorem IsDiag.transpose [Zero α] {A : Matrix n n α} (ha : A.IsDiag) : Aᵀ.IsDiag
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_le : ∀ a : α, pred a ≤ a
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[simp]
lemma sectionsEquiv_symm_apply_val (x : c.pt) (i : I.L) :
    ((sectionsEquiv hc).symm x).val i = c.ι i x
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_diff : (↑(D \ E) : Set α) = ↑D \ ↑E
-- Mathlib/Analysis/Complex/Isometry.lean
@[simp]
theorem rotation_symm (a : circle) : (rotation a).symm = rotation a⁻¹
-- Mathlib/Probability/Kernel/Basic.lean
theorem IsFiniteKernel.bound_lt_top (κ : Kernel α β) [h : IsFiniteKernel κ] :
    IsFiniteKernel.bound κ < ∞
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem zero_imK : (0 : ℍ[R]).imK = 0
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_toLieSubmodule (x : L) : x ∈ K.toLieSubmodule ↔ x ∈ K
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
/-- The ring morphism `A →+* A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. -/
@[simps]
def includeLeftRingHom : A →+* 𝒜 ᵍ⊗[R] ℬ
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isIrreducible_iff_vanishingIdeal_isPrime {s : Set (PrimeSpectrum R)} :
    IsIrreducible s ↔ (vanishingIdeal s).IsPrime
-- Mathlib/Data/FP/Basic.lean
theorem Float.Zero.valid : ValidFinite emin 0
-- Mathlib/CategoryTheory/Monoidal/Internal/Module.lean
/-- Converting a monoid object in `ModuleCat R` to a bundled algebra.
-/
@[simps!]
def functor : Mon_ (ModuleCat.{u} R) ⥤ AlgebraCat R
-- Mathlib/Order/Radical.lean
theorem Order.radical_nongenerating [IsCoatomic α] {a : α} (h : a ⊔ radical α = ⊤) : a = ⊤
-- Mathlib/Analysis/Complex/PhragmenLindelof.lean
/-- **Phragmen-Lindelöf principle** in the right half-plane. Let `f : ℂ → E` be a function such that

* `f` is differentiable in the open right half-plane and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * (abs z) ^ c)` on the open right half-plane
  for some `c < 2`;
* `‖f z‖` is bounded from above by a constant on the imaginary axis;
* `f x`, `x : ℝ`, tends to zero superexponentially fast as `x → ∞`:
  for any natural `n`, `exp (n * x) * ‖f x‖` tends to zero as `x → ∞`.

Then `f` is equal to zero on the closed right half-plane. -/
theorem eq_zero_on_right_half_plane_of_superexponential_decay (hd : DiffContOnCl ℂ f {z | 0 < z.re})
    (hexp : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * abs z ^ c))
    (hre : SuperpolynomialDecay atTop expR fun x => ‖f x‖) (him : ∃ C, ∀ x : ℝ, ‖f (x * I)‖ ≤ C) :
    EqOn f 0 {z : ℂ | 0 ≤ z.re}
-- Mathlib/Data/Set/Lattice.lean
theorem inter_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s ∩ ⋃ (i) (j), t i j) = ⋃ (i) (j), s ∩ t i j
-- Mathlib/LinearAlgebra/Dual.lean
theorem transpose_apply (u : M →ₗ[R] M') (l : Dual R M') : transpose (R := R) u l = l.comp u
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive IsClosed.right_addCoset]
theorem IsClosed.rightCoset {U : Set G} (h : IsClosed U) (x : G) : IsClosed (op x • U)
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma defaultRatCDF_nonneg (q : ℚ) : 0 ≤ defaultRatCDF q
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem insertAt_boundary (i : N) {t₀ : I} {t}
    (H : (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ boundary { j // j ≠ i }) : insertAt i ⟨t₀, t⟩ ∈ boundary N
-- Mathlib/Data/Matrix/Composition.lean
/-- `Matrix.comp` as `AlgEquiv` -/
@[simps!]
def compAlgEquiv : Matrix I I (Matrix J J R) ≃ₐ[K] Matrix (I × J) (I × J) R
-- Mathlib/NumberTheory/BernoulliPolynomials.lean
@[simp]
theorem bernoulli_eval_one (n : ℕ) : (bernoulli n).eval 1 = bernoulli' n
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem measure_symmDiff_ne_top (hs : μ s ≠ ∞) (ht : μ t ≠ ∞) : μ (s ∆ t) ≠ ∞
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
private theorem inv_eq_of_mul (h : a * b = 1) : a⁻¹ = b
-- Mathlib/Topology/LocalAtTarget.lean
theorem isLocallyClosed_iff_coe_preimage_of_iSup_eq_top (s : Set β) :
    IsLocallyClosed s ↔ ∀ i, IsLocallyClosed ((↑) ⁻¹' s : Set (U i))
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
/-- The image of `(0, 2π]` under `circleMap c R` is the circle with center `c` and radius `|R|`. -/
@[simp]
theorem image_circleMap_Ioc (c : ℂ) (R : ℝ) : circleMap c R '' Ioc 0 (2 * π) = sphere c |R|
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
theorem AnalyticSet.image_of_continuous {β : Type*} [TopologicalSpace β] {s : Set α}
    (hs : AnalyticSet s) {f : α → β} (hf : Continuous f) : AnalyticSet (f '' s)
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem symm_image_image {α β} (e : α ≃ β) (s : Set α) : e.symm '' (e '' s) = s
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_integral_le_of_norm_le_const [IsFiniteMeasure μ] {f : α → G} {C : ℝ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : ‖∫ x, f x ∂μ‖ ≤ C * (μ univ).toReal
-- Mathlib/SetTheory/ZFC/Basic.lean
/-- **There is no universal set.**
This is stated as `univ ∉ univ`, meaning that `univ` (the class of all sets) is proper (does not
belong to the class of all sets). -/
theorem univ_not_mem_univ : univ ∉ univ
-- Mathlib/RingTheory/FreeCommRing.lean
@[simp, norm_cast]
protected theorem coe_sub (x y : FreeRing α) : ↑(x - y) = (x : FreeCommRing α) - y
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
/-- If `B` is a cyclotomic extension of `A` given by roots of unity of order in `T` and `S ⊆ T`,
then `adjoin A { b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1 }` is a cyclotomic extension of `B`
given by roots of unity of order in `S`. -/
theorem union_left [h : IsCyclotomicExtension T A B] (hS : S ⊆ T) :
    IsCyclotomicExtension S A (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1})
-- Mathlib/Data/Real/Pi/Bounds.lean
theorem sqrtTwoAddSeries_step_down (a b : ℕ) {c d n : ℕ} {z : ℝ}
    (hz : z ≤ sqrtTwoAddSeries (a / b) n) (hb : 0 < b) (hd : 0 < d)
    (h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2) : z ≤ sqrtTwoAddSeries (c / d) (n + 1)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getLast_mem : ∀ {l : List α} (h : l ≠ []), getLast l h ∈ l
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem iInf_IicSnd_gt (t : ℚ) {s : Set α} (hs : MeasurableSet s) [IsFiniteMeasure ρ] :
    ⨅ r : { r' : ℚ // t < r' }, ρ.IicSnd r s = ρ.IicSnd t s
-- Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean
/-- If `f` is eventually differentiable along a nontrivial filter `l : Filter ℝ` that is generated
by convex sets, the norm of `f` tends to infinity along `l`, and `f' = O(g)` along `l`, where `f'`
is the derivative of `f`, then `g` is not integrable on any interval `a..b` such that
`[a, b] ∈ l`. -/
theorem not_intervalIntegrable_of_tendsto_norm_atTop_of_deriv_isBigO_filter {f : ℝ → E} {g : ℝ → F}
    {a b : ℝ} (l : Filter ℝ) [NeBot l] [TendstoIxxClass Icc l l] (hl : [[a, b]] ∈ l)
    (hd : ∀ᶠ x in l, DifferentiableAt ℝ f x) (hf : Tendsto (fun x => ‖f x‖) l atTop)
    (hfg : deriv f =O[l] g) : ¬IntervalIntegrable g volume a b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma dblU_ne_zero_of_Y_eq {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hPz : P z ≠ 0) (hQz : Q z ≠ 0)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 = Q y * P z ^ 3)
    (hy' : P y * Q z ^ 3 = W.negY Q * P z ^ 3) : W.dblU P ≠ 0
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma GrowsPolynomially.pow (p : ℕ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualLift_of_mem {φ : Module.Dual K W} {w : V} (hw : w ∈ W) : W.dualLift φ w = φ ⟨w, hw⟩
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem le_comap_pow (n : ℕ) : K.comap f ^ n ≤ (K ^ n).comap f
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
theorem ae_mem_or_ae_nmem (hf : PreErgodic f μ) (hsm : MeasurableSet s) (hs : f ⁻¹' s = s) :
    (∀ᵐ x ∂μ, x ∈ s) ∨ ∀ᵐ x ∂μ, x ∉ s
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Post-composition by a uniform embedding is
a uniform embedding for the uniform structures of uniform convergence.

More precisely, if `f : γ → β` is a uniform embedding,
then `(f ∘ ·) : (α →ᵤ γ) → (α →ᵤ β)` is a uniform embedding. -/
protected theorem postcomp_uniformEmbedding [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f) :
    UniformEmbedding (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The product of two `C^n` functions within a set at a point is `C^n` within this set
at this point. -/
theorem ContDiffWithinAt.mul {s : Set E} {f g : E → 𝔸} (hf : ContDiffWithinAt 𝕜 n f s x)
    (hg : ContDiffWithinAt 𝕜 n g s x) : ContDiffWithinAt 𝕜 n (fun x => f x * g x) s x
-- Mathlib/RingTheory/Ideal/Norm.lean
@[simp]
theorem absNorm_top : absNorm (⊤ : Ideal S) = 1
-- Mathlib/GroupTheory/Divisible.lean
@[to_additive DivisibleBy.surjective_smul]
theorem RootableBy.surjective_pow (A α : Type*) [Monoid A] [Pow A α] [Zero α] [RootableBy A α]
    {n : α} (hn : n ≠ 0) : Function.Surjective fun a : A => a ^ n
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_le_map_iff_of_injective {S T : Submonoid M} : S.map f ≤ T.map f ↔ S ≤ T
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_lt_div (hb : 0 < b) : 1 < a / b ↔ b < a
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
@[simp]
theorem gcd_one_left (a : R) : gcd 1 a = 1
-- Mathlib/Data/Nat/Choose/Multinomial.lean
@[simp]
theorem multinomial_insert_one [DecidableEq α] (h : a ∉ s) (h₁ : f a = 1) :
    multinomial (insert a s) f = (s.sum f).succ * multinomial s f
-- Mathlib/Data/Num/Lemmas.lean
theorem add_one : ∀ n : ZNum, n + 1 = succ n
-- Mathlib/Algebra/Order/Module/OrderedSMul.lean
lemma inf_eq_half_smul_add_sub_abs_sub' (x y : β) : x ⊓ y = (2⁻¹ : α) • (x + y - |y - x|)
-- Mathlib/Control/Traversable/Instances.lean
theorem Option.traverse_eq_map_id {α β} (f : α → β) (x : Option α) :
    Option.traverse ((pure : _ → Id _) ∘ f) x = (pure : _ → Id _) (f <$> x)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem normAtPlace_eq_zero {x : E K} :
    (∀ w, normAtPlace w x = 0) ↔ x = 0
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem mk_im (z : ℂ) (h : 0 < z.im) : (mk z h).im = z.im
-- Mathlib/Data/Set/Prod.lean
theorem union_pi_inter
    (ht₁ : ∀ i ∉ s₁, t₁ i = univ) (ht₂ : ∀ i ∉ s₂, t₂ i = univ) :
    (s₁ ∪ s₂).pi (fun i ↦ t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
theorem StrongMono.of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) [h : StrongMono f] : StrongMono g
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem mem_sup_left {S T : StarSubalgebra R A} : ∀ {x : A}, x ∈ S → x ∈ S ⊔ T
-- Mathlib/Data/List/Basic.lean
@[deprecated get_cons_length (since := "2023-01-05")]
theorem nthLe_cons_length : ∀ (x : α) (xs : List α) (n : ℕ) (h : n = xs.length),
    (x :: xs).nthLe n (by simp [h]) = (x :: xs).getLast (cons_ne_nil x xs)
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_lt_lift {x : Cardinal.{v}} {m : ℕ∞} : m < lift.{u} x ↔ m < x
-- Mathlib/Data/Finset/Sups.lean
lemma diffs_subset_left : t₁ ⊆ t₂ → s \\ t₁ ⊆ s \\ t₂
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
@[simp]
lemma lift_eqToHom_comp_iff {R' R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) (h : R' = R) :
    p.IsHomLift (eqToHom h ≫ f) φ ↔ p.IsHomLift f φ
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp 1100] theorem length_singleton (a : α) : length [a] = 1
-- Mathlib/Computability/PartrecCode.lean
theorem prec_prim : Primrec₂ prec
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
theorem neg_apply (f : P →ᴬ[R] W) (x : P) : (-f) x = -f x
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
theorem natTrailingDegree_one : natTrailingDegree (1 : R[X]) = 0
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
lemma homologyMap'_congr (h : Homotopy φ₁ φ₂) (h₁ : S₁.HomologyData)
    (h₂ : S₂.HomologyData) : homologyMap' φ₁ h₁ h₂ = homologyMap' φ₂ h₁ h₂
-- Mathlib/Data/Finset/Pointwise.lean
/-- A nonempty set is scaled by zero to the singleton set containing zero. -/
@[simp] lemma zero_smul_finset {s : Finset β} (h : s.Nonempty) : (0 : α) • s = (0 : Finset β)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_multiset_count [DecidableEq α] [CommMonoid α] (s : Multiset α) :
    s.prod = ∏ m ∈ s.toFinset, m ^ s.count m
-- Mathlib/Order/Antichain.lean
theorem mono (hs : IsStrongAntichain r₁ s) (h : r₂ ≤ r₁) : IsStrongAntichain r₂ s
-- Mathlib/Analysis/Analytic/Polynomial.lean
theorem AnalyticOn.eval_polynomial {A} [NormedCommRing A] [NormedAlgebra 𝕜 A] (p : A[X]) :
    AnalyticOn 𝕜 (eval · p) Set.univ
-- Mathlib/Order/Filter/Pointwise.lean
theorem add_mul_subset : (f + g) * h ≤ f * h + g * h
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem map_smul_of_tower [CommSemiring S] [Algebra S R] [Module S M] [IsScalarTower S R M]
    [Module S N] [IsScalarTower S R N] (a : S)
    (x : M) : Q (a • x) = (a * a) • Q x
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_Ioc_eq_integral_Ioo' (hy : μ {y} = 0) :
    ∫ t in Ioc x y, f t ∂μ = ∫ t in Ioo x y, f t ∂μ
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive (attr := simp)]
theorem units_inv_left_iff : Commute (↑u⁻¹) a ↔ Commute (↑u) a
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_of_castSucc_lt (p : Fin n) (i : Fin (n + 1)) (h : castSucc p < i)
    (hi := Fin.ne_zero_of_lt h) : p.predAbove i = i.pred hi
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem PointedMap.map_pt {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') :
    f default = default
-- Mathlib/Topology/PartitionOfUnity.lean
/-- If `f` is a partition of unity on a set `s : Set X` and `g : ι → X → E` is a family of functions
such that each `g i` is continuous at every point of the topological support of `f i`, then the sum
`fun x ↦ ∑ᶠ i, f i x • g i x` is continuous on the whole space. -/
theorem continuous_finsum_smul [ContinuousAdd E] {g : ι → X → E}
    (hg : ∀ (i), ∀ x ∈ tsupport (f i), ContinuousAt (g i) x) :
    Continuous fun x => ∑ᶠ i, f i x • g i x
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem image_smul : (fun x ↦ a • x) '' t = a • t
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
theorem union_right {t'} (h : IsMetricSeparated s t) (h' : IsMetricSeparated s t') :
    IsMetricSeparated s (t ∪ t')
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma div_eq_iff (h : IsUnit b) : a / b = c ↔ a = c * b
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integrable_exp_neg_mul_sq_iff {b : ℝ} :
    (Integrable fun x : ℝ => exp (-b * x ^ 2)) ↔ 0 < b
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem hasDerivWithinAt_id : HasDerivWithinAt id 1 s x
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem ofBoolAlg_top : ofBoolAlg (⊤ : AsBoolAlg α) = 1
-- Mathlib/Algebra/Algebra/Unitization.lean
/-- The coercion from a non-unital `R`-algebra `A` to its unitization `unitization R A`
realized as a non-unital star algebra homomorphism. -/
@[simps!]
def inrNonUnitalStarAlgHom (R A : Type*) [CommSemiring R] [StarAddMonoid R]
    [NonUnitalSemiring A] [Star A] [Module R A] :
    A →⋆ₙₐ[R] Unitization R A
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_ulift : Nonempty (ULift α) ↔ Nonempty α
-- Mathlib/Data/Fintype/Basic.lean
theorem univ_nonempty_iff : (univ : Finset α).Nonempty ↔ Nonempty α
-- Mathlib/Algebra/Category/MonCat/Basic.lean
@[to_additive (attr := simp)]
lemma oneHom_apply (X Y : MonCat.{u}) (x : X) : (1 : X ⟶ Y) x = 1
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
/-- Given a family of `n` linearly independent vectors in a finite-dimensional space of
dimension `> n`, one may extend the family by another vector while retaining linear independence. -/
theorem exists_linearIndependent_snoc_of_lt_finrank {n : ℕ} {v : Fin n → M}
    (hv : LinearIndependent R v) (h : n < finrank R M) :
    ∃ (x : M), LinearIndependent R (Fin.snoc v x)
-- Mathlib/GroupTheory/SchurZassenhaus.lean
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem exists_right_complement'_of_coprime_aux' [Finite G] (hG : Nat.card G = n)
    {N : Subgroup G} [N.Normal] (hN : Nat.Coprime (Nat.card N) N.index) :
    ∃ H : Subgroup G, IsComplement' N H
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
protected theorem mdifferentiableOn : MDifferentiableOn 𝓘(𝕜, E) 𝓘(𝕜, E') f s
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem lift_comp_apply (x : K) : lift i j p (i x) = j x
-- Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean
@[reassoc]
lemma induced_shiftMap {n : M} {X Y : C} (f : X ⟶ Y⟦n⟧) (a a' : M) (h : n + a = a') :
    letI := induced e M F' e'
    F.shiftMap (L.map f ≫ (L.commShiftIso n).hom.app _) a a' h =
      (e' a).hom.app X ≫ G.shiftMap f a a' h ≫ (e' a').inv.app Y
-- Mathlib/CategoryTheory/Category/Factorisation.lean
/-- The initial object in `Factorisation f`, with the domain of `f` as its midpoint. -/
@[simps]
protected def initial : Factorisation f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffine_neg {P : Fin 3 → F} (hP : W.Nonsingular P) :
    toAffine W (W.neg P) = -toAffine W P
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasDerivAt : HasDerivAt f (f.linear 1) x
-- Mathlib/Logic/Embedding/Basic.lean
theorem embeddingCongr_apply_trans {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
    (ec : γ₁ ≃ γ₂) (f : α₁ ↪ β₁) (g : β₁ ↪ γ₁) :
    Equiv.embeddingCongr ea ec (f.trans g) =
      (Equiv.embeddingCongr ea eb f).trans (Equiv.embeddingCongr eb ec g)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem deriv_ccosh (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) * deriv f x
-- Mathlib/Data/Real/Basic.lean
theorem ofCauchy_zero : (⟨0⟩ : ℝ) = 0
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
theorem IsClosable.closure_mono {f g : E →ₗ.[R] F} (hg : g.IsClosable) (h : f ≤ g) :
    f.closure ≤ g.closure
-- Mathlib/Order/Monotone/Monovary.lean
@[simp]
theorem MonovaryOn.empty : MonovaryOn f g ∅
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
@[simp]
theorem integral_univ_inv_one_add_sq : ∫ (x : ℝ), (1 + x ^ 2)⁻¹ = π
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIso_inv_snd_fst :
    (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ pullback.snd _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_eq_top : a * b = ∞ ↔ a ≠ 0 ∧ b = ∞ ∨ a = ∞ ∧ b ≠ 0
-- Mathlib/CategoryTheory/GuitartExact/Basic.lean
lemma isConnected_rightwards_iff_downwards :
    IsConnected (w.StructuredArrowRightwards g) ↔ IsConnected (w.CostructuredArrowDownwards g)
-- Mathlib/Topology/Separation.lean
theorem tendsto_nhds_unique_of_eventuallyEq [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
    [NeBot l] (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) (hfg : f =ᶠ[l] g) : a = b
-- Mathlib/GroupTheory/Index.lean
/-- A subgroup has index two if and only if there exists `a` such that for all `b`, exactly one
of `b * a` and `b` belong to `H`. -/
@[to_additive "An additive subgroup has index two if and only if there exists `a` such that
for all `b`, exactly one of `b + a` and `b` belong to `H`."]
theorem index_eq_two_iff : H.index = 2 ↔ ∃ a, ∀ b, Xor' (b * a ∈ H) (b ∈ H)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem coe_center : ↑(center R) = Set.center R
-- Mathlib/CategoryTheory/Shift/Induced.lean
lemma Functor.commShiftIso_eq_ofInduced (a : A) :
    letI := HasShift.induced F A s i
    letI := Functor.CommShift.ofInduced F A s i
    F.commShiftIso a = (i a).symm
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma birkhoffSet_sup (a b : α) : birkhoffSet (a ⊔ b) = birkhoffSet a ∪ birkhoffSet b
-- Mathlib/Order/Filter/NAry.lean
/-- Symmetric statement to `Filter.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {m : α → β' → γ} {n : β → β'} {m' : β → α → δ} {n' : δ → γ}
    (h_right_anticomm : ∀ a b, m a (n b) = n' (m' b a)) :
    map₂ m f (g.map n) = (map₂ m' g f).map n'
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem toSimpleFunc_indicatorConst {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    toSimpleFunc (indicatorConst p hs hμs c) =ᵐ[μ]
      (SimpleFunc.const _ c).piecewise s hs (SimpleFunc.const _ 0)
-- Mathlib/Topology/Category/CompHaus/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHaus.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.snd f g = b
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem sub_comp (f : M →ₛₗ[σ₁₂] M₂) (g h : M₂ →ₛₗ[σ₂₃] N₃) :
    (g - h).comp f = g.comp f - h.comp f
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem degree_of_a_eq_zero' : (toPoly ⟨0, b, c, d⟩).degree ≤ 2
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem uniformity_eq : 𝓤 (SeparationQuotient α) = (𝓤 α).map (Prod.map mk mk)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem coe_toNonUnitalStarSubalgebra (s : NonUnitalSubalgebra R A) (h_star) :
    (s.toNonUnitalStarSubalgebra h_star : Set A) = s
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem finite_empty : (∅ : Set α).Finite
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem empty_div (s : Finset α) : ∅ / s = ∅
-- Mathlib/Analysis/BoundedVariation.lean
theorem eq_zero_iff (f : α → E) {s : Set α} :
    eVariationOn f s = 0 ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_eq_zero {m : ℕ∞} : (m : Cardinal) = 0 ↔ m = 0
-- Mathlib/Deprecated/Submonoid.lean
/-- The image of a submonoid under a monoid hom is a submonoid of the codomain. -/
@[to_additive
      "The image of an `AddSubmonoid` under an `AddMonoid` hom is an `AddSubmonoid` of the
      codomain."]
theorem IsSubmonoid.image {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) {s : Set M}
    (hs : IsSubmonoid s) : IsSubmonoid (f '' s)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem top_pow (n : ℕ) : (⊤ ^ n : Ideal R) = ⊤
-- Mathlib/Order/CompleteLattice.lean
theorem biInf_prod {f : β × γ → α} {s : Set β} {t : Set γ} :
    ⨅ x ∈ s ×ˢ t, f x = ⨅ (a ∈ s) (b ∈ t), f (a, b)
-- Mathlib/Data/Int/Defs.lean
lemma toNat_lt' {n : ℕ} (hn : n ≠ 0) : m.toNat < n ↔ m < n