ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Logic/Function/Iterate.lean
theorem iterate_right (h : Commute f g) (n : ℕ) : Commute f g^[n]
-- Mathlib/Algebra/Order/Monovary.lean
lemma Antivary.pow_left₀ (hf : 0 ≤ f) (hfg : Antivary f g) (n : ℕ) : Antivary (f ^ n) g
-- Mathlib/Control/EquivFunctor.lean
theorem mapEquiv.injective (f : Type u₀ → Type u₁)
    [Applicative f] [LawfulApplicative f] {α β : Type u₀}
    (h : ∀ γ, Function.Injective (pure : γ → f γ)) :
      Function.Injective (@EquivFunctor.mapEquiv f _ α β)
-- Mathlib/Topology/Irreducible.lean
theorem IsIrreducible.nonempty (h : IsIrreducible s) : s.Nonempty
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
@[simp] lemma lie_coe_lieDerivation_apply (x : L) (D : LieDerivation R L M) :
    ⁅x, (D : L →ₗ[R] M)⁆ = ⁅x, D⁆
-- Mathlib/Algebra/Algebra/Defs.lean
@[norm_cast]
theorem coe_zero : (↑(0 : R) : A) = 0
-- Mathlib/Order/FixedPoints.lean
theorem map_le_gfp {a : α} (ha : a ≤ gfp f) : f a ≤ gfp f
-- Mathlib/NumberTheory/Harmonic/Defs.lean
@[simp]
lemma harmonic_succ (n : ℕ) : harmonic (n + 1) = harmonic n + (↑(n + 1))⁻¹
-- Mathlib/Analysis/Convex/Topology.lean
/-- If `x ∈ s` and `x + y ∈ interior s`, then `x + t y ∈ interior s` for `t ∈ (0, 1]`. -/
theorem Convex.add_smul_mem_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E} (hx : x ∈ s)
    (hy : x + y ∈ interior s) {t : 𝕜} (ht : t ∈ Ioc (0 : 𝕜) 1) : x + t • y ∈ interior s
-- Mathlib/Data/List/Basic.lean
theorem mem_filter_of_mem {a : α} {l} (h₁ : a ∈ l) (h₂ : p a) : a ∈ filter p l
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem map_comp {Y₁ Y₂ Y₃ : Type*} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
    @map X _ _ _ g ∘ map f = map (g ∘ f)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem ite_le_natDegree_coeff (p : R[X]) (n : ℕ) (I : Decidable (n < 1 + natDegree p)) :
    @ite _ (n < 1 + natDegree p) I (coeff p n) 0 = coeff p n
-- Mathlib/Data/List/Basic.lean
theorem foldr_concat
    (f : α → β → β) (b : β) (x : α) (xs : List α) :
    List.foldr f b (xs ++ [x]) = (List.foldr f (f x b) xs)
-- Mathlib/Data/Complex/Module.lean
@[simp]
lemma realPart_imaginaryPart {x : A} : ℜ (ℑ x : A) = ℑ x
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem cast_natAdd_right {n n' m : Nat} (i : Fin n') (h : m + n' = m + n) :
    cast h (natAdd m i) = natAdd m (cast (Nat.add_left_cancel h) i)
-- Mathlib/GroupTheory/SchurZassenhaus.lean
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem _root_.RingEquiv.map_det (f : R ≃+* S) (M : Matrix n n R) :
    f M.det = Matrix.det (f.mapMatrix M)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem _root_.Set.countable_infinite_iff_nonempty_denumerable {α : Type*} {s : Set α} :
    s.Countable ∧ s.Infinite ↔ Nonempty (Denumerable s)
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem subset_ndunion_right (s t : Multiset α) : t ⊆ ndunion s t
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toOuterMeasure_apply_eq_one_iff : p.toOuterMeasure s = 1 ↔ p.support ⊆ s
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_zero : ∫⁻ _ : α, 0 ∂μ = 0
-- Mathlib/Algebra/Star/Basic.lean
protected theorem IsRegular.star [Mul R] [StarMul R] {x : R} (hx : IsRegular x) :
    IsRegular (star x)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- `Part.bind` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def bind {β γ : Type v} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ) : α →𝒄 Part γ
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem UniformIntegrable.ae_eq {g : ι → α → β} (hf : UniformIntegrable f p μ)
    (hfg : ∀ n, f n =ᵐ[μ] g n) : UniformIntegrable g p μ
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- The isomorphism `S₁.opcycles ≅ S₂.opcycles` induced by an isomorphism
of short complexes `S₁ ≅ S₂`. -/
@[simps]
noncomputable def opcyclesMapIso (e : S₁ ≅ S₂) [S₁.HasRightHomology]
    [S₂.HasRightHomology] : S₁.opcycles ≅ S₂.opcycles
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem mem_center_iff {z : R} : z ∈ center R ↔ ∀ g, g * z = z * g
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem functorPullback_pushforward_le (R : Sieve (F.obj X)) :
    (R.functorPullback F).functorPushforward F ≤ R
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialOn.sub {s : Set E} (hf : CPolynomialOn 𝕜 f s) (hg : CPolynomialOn 𝕜 g s) :
    CPolynomialOn 𝕜 (f - g) s
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma desc' (hS : S.Exact) {A : C} (k : S.X₂ ⟶ A) (hk : S.f ≫ k = 0) [Epi S.g] :
    ∃ (l : S.X₃ ⟶ A), S.g ≫ l = k
-- Mathlib/Data/Nat/SuccPred.lean
lemma forall_ne_zero_iff (P : ℕ → Prop) :
    (∀ i, i ≠ 0 → P i) ↔ (∀ i, P (i + 1))
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[deprecated DifferentiableOn.sub_iff_right (since := "2024-07-11")]
theorem differentiableOn_const_sub_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => c - f y) s ↔ DifferentiableOn 𝕜 f s
-- Mathlib/Data/Set/Basic.lean
@[simp] lemma nonempty_compl_of_nontrivial [Nontrivial α] (x : α) : Set.Nonempty {x}ᶜ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem extractLsb_toNat (hi lo : Nat) (x : BitVec n) :
  (extractLsb hi lo x).toNat = (x.toNat >>> lo) % 2^(hi-lo+1)
-- Mathlib/GroupTheory/PushoutI.lean
@[ext high]
theorem hom_ext_nonempty [hn : Nonempty ι]
    {f g : PushoutI φ →* K}
    (h : ∀ i, f.comp (of i : G i →* _) = g.comp (of i : G i →* _)) : f = g
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
protected theorem Specializes.inv {x y : G} (h : x ⤳ y) : (x⁻¹) ⤳ (y⁻¹)
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem coe_injective : Function.Injective ((↑) : LieSubalgebra R L → Set L)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- A variant of `Matrix.det_units_conj`. -/
theorem det_conj {M : Matrix m m α} (h : IsUnit M) (N : Matrix m m α) :
    det (M * N * M⁻¹) = det N
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem RingHom.map_iterate_frobenius (n : ℕ) :
    g ((frobenius R p)^[n] x) = (frobenius S p)^[n] (g x)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- `C` has biproducts of shape `J` if we have
a limit and a colimit, with the same cone points,
of every function `F : J → C`.
-/
class HasBiproductsOfShape : Prop where
  has_biproduct : ∀ F : J → C, HasBiproduct F
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma d_comp_ofHoms_v (ψ : ∀ (p : ℤ), F.X p ⟶ G.X p) (p' p q : ℤ) (hpq : p + 0 = q) :
    F.d p' p ≫ (ofHoms ψ).v p q hpq = F.d p' q ≫ ψ q
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem toNat_eq_zero (b : Bool) : b.toNat = 0 ↔ b = false
-- Mathlib/Order/SuccPred/Limit.lean
@[simp]
theorem _root_.PredOrder.limitRecOn_limit (ha : IsPredLimit a) :
    PredOrder.limitRecOn a H_pred H_lim
      = H_lim a ha fun x _ ↦ PredOrder.limitRecOn x H_pred H_lim
-- Mathlib/Order/Fin/Basic.lean
@[simp] theorem rev_bot [NeZero n] : rev (⊥ : Fin n) = ⊤
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma pow (n : ℕ) : MeromorphicOn (s ^ n) U
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- A version of the **Arzela-Ascoli theorem**.

If an equicontinuous family of continuous functions is compact in the pointwise topology, then it
is compact in the compact open topology. -/
theorem ArzelaAscoli.isCompact_of_equicontinuous
    (S : Set C(X, α)) (hS1 : IsCompact (ContinuousMap.toFun '' S))
    (hS2 : Equicontinuous ((↑) : S → X → α)) : IsCompact S
-- Mathlib/Algebra/Ring/Commute.lean
@[simp]
theorem add_right [Distrib R] {a b c : R} : Commute a b → Commute a c → Commute a (b + c)
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- If `g` has a closable extension `f`, then `g` itself is closable. -/
theorem IsClosable.leIsClosable {f g : E →ₗ.[R] F} (hf : f.IsClosable) (hfg : g ≤ f) :
    g.IsClosable
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_option {α : Type u} : #(Option α) = #α + 1
-- Mathlib/Algebra/DirectSum/Basic.lean
@[simp]
theorem sigmaUncurry_apply (f : ⨁ (i) (j), δ i j) (i : ι) (j : α i) :
    sigmaUncurry f ⟨i, j⟩ = f i j
-- Mathlib/Algebra/Module/Submodule/Ker.lean
@[simp]
theorem _root_.AddMonoidHom.coe_toIntLinearMap_ker {M M₂ : Type*} [AddCommGroup M] [AddCommGroup M₂]
    (f : M →+ M₂) : LinearMap.ker f.toIntLinearMap = AddSubgroup.toIntSubmodule f.ker
-- Mathlib/RingTheory/Adjoin/Basic.lean
@[simp]
theorem adjoin_empty : adjoin R (∅ : Set A) = ⊥
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem norm_self_mul_star {x : E} : ‖x * x⋆‖ = ‖x‖ * ‖x‖
-- Mathlib/CategoryTheory/Sites/Plus.lean
@[reassoc (attr := simp)]
theorem toPlus_plusLift {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q) :
    J.toPlus P ≫ J.plusLift η hQ = η
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[simp]
theorem prod'_toFunctor : (F.prod' G).toFunctor = F.toFunctor.prod' G.toFunctor
-- Mathlib/Algebra/Group/Commute/Basic.lean
@[to_additive] lemma zpow_zpow_self : Commute (a ^ m) (a ^ n)
-- Mathlib/Topology/Order/IsLUB.lean
theorem exists_seq_tendsto_sSup {α : Type*} [ConditionallyCompleteLinearOrder α]
    [TopologicalSpace α] [OrderTopology α] [FirstCountableTopology α] {S : Set α} (hS : S.Nonempty)
    (hS' : BddAbove S) : ∃ u : ℕ → α, Monotone u ∧ Tendsto u atTop (𝓝 (sSup S)) ∧ ∀ n, u n ∈ S
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem interior_Icc [NoMinOrder α] [NoMaxOrder α] {a b : α} : interior (Icc a b) = Ioo a b
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@[simp]
theorem ker_toContinuousLinearMap (f : E →ₗ[𝕜] F') :
    ker (LinearMap.toContinuousLinearMap f) = ker f
-- Mathlib/Data/Prod/Basic.lean
/-- Composing a `Prod.map` with another `Prod.map` is equal to
a single `Prod.map` of composed functions.
-/
theorem map_comp_map {ε ζ : Type*} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) :
    Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f')
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The zeroth modified cyclotomic polyomial is `1`. -/
@[simp]
theorem cyclotomic'_zero (R : Type*) [CommRing R] [IsDomain R] : cyclotomic' 0 R = 1
-- Mathlib/Data/List/OfFn.lean
theorem forall_iff_forall_tuple {P : List α → Prop} :
    (∀ l : List α, P l) ↔ ∀ (n) (f : Fin n → α), P (List.ofFn f)
-- Mathlib/Analysis/Fourier/PoissonSummation.lean
/-- **Poisson's summation formula**, assuming that `f` decays as
`|x| ^ (-b)` for some `1 < b` and its Fourier transform is summable. -/
theorem Real.tsum_eq_tsum_fourierIntegral_of_rpow_decay_of_summable {f : ℝ → ℂ} (hc : Continuous f)
    {b : ℝ} (hb : 1 < b) (hf : IsBigO (cocompact ℝ) f fun x : ℝ => |x| ^ (-b))
    (hFf : Summable fun n : ℤ => 𝓕 f n) (x : ℝ) :
    ∑' n : ℤ, f (x + n) = ∑' n : ℤ, 𝓕 f n * fourier n (x : UnitAddCircle)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem inr_apply (y) : inr M N y = (1, y)
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
@[simp]
theorem Continuous.connectedComponentsLift_comp_coe (h : Continuous f) :
    h.connectedComponentsLift ∘ (↑) = f
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem copy_eq (K : Subgroup G) (s : Set G) (hs : s = ↑K) : K.copy s hs = K
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_image_eq (h : e.IsImage s t) : e.symm '' (e.target ∩ t) = e.source ∩ s
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem hasLimitsOfShape_of_initial [HasLimitsOfShape C E] : HasLimitsOfShape D E
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
/-- The determinant of the change-of-basis matrix between two orthonormal bases `a`, `b` has
unit length. -/
@[simp]
theorem OrthonormalBasis.det_to_matrix_orthonormalBasis : ‖a.toBasis.det b‖ = 1
-- Mathlib/Data/List/Sections.lean
theorem mem_sections_length {L : List (List α)} {f} (h : f ∈ sections L) : length f = length L
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem quotientToQuotientRangePowQuotSucc_mk {i : ℕ} {a : S} (a_mem : a ∈ P ^ i) (x : S) :
    quotientToQuotientRangePowQuotSucc f p P a_mem (Submodule.Quotient.mk x) =
      Submodule.Quotient.mk ⟨_, Ideal.mem_map_of_mem _ (Ideal.mul_mem_right x _ a_mem)⟩
-- Mathlib/Topology/UniformSpace/Equiv.lean
theorem preimage_symm (h : α ≃ᵤ β) : preimage h.symm = image h
-- Mathlib/Order/WellFoundedSet.lean
@[simp] theorem isPWO_of_finite [Finite α] : s.IsPWO
-- Mathlib/Computability/Halting.lean
protected theorem map {n f} {g : Vector ℕ (n + 1) → ℕ} (hf : @Partrec' n f)
    (hg : @Partrec' (n + 1) g) : @Partrec' n fun v => (f v).map fun a => g (a ::ᵥ v)
-- Mathlib/GroupTheory/Perm/List.lean
theorem mem_or_mem_of_zipWith_swap_prod_ne : ∀ {l l' : List α} {x : α},
    (zipWith swap l l').prod x ≠ x → x ∈ l ∨ x ∈ l'
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem closure_image (f : M →[L] N) : closure L (f '' s) = map f (closure L s)
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem lift_sub_lift {X Y : C} (a b c d : X ⟶ Y) :
    prod.lift a b - prod.lift c d = prod.lift (a - c) (b - d)
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem mem_pure' {a b : α} : a ∈ Semiquot.pure b ↔ a = b
-- Mathlib/Data/Set/Basic.lean
theorem not_not_mem : ¬a ∉ s ↔ a ∈ s
-- Mathlib/Data/List/Duplicate.lean
/-- The contrapositive of `List.nodup_iff_sublist`. -/
theorem duplicate_iff_sublist : x ∈+ l ↔ [x, x] <+ l
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.exists_insert_of_ssubset (hB : M.Base B) (hIB : I ⊂ B) (hB' : M.Base B') :
    ∃ e ∈ B' \ I, M.Indep (insert e I)
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- The separable degree of a finite extension `E / F` is smaller than the degree of `E / F`. -/
theorem finSepDegree_le_finrank [FiniteDimensional F E] :
    finSepDegree F E ≤ finrank F E
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem HeapNode.WF.rank_eq : ∀ {n} {s : HeapNode α}, s.WF le a n → s.rank = n
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[reassoc (attr := simp)]
theorem equalizerSubobject_arrow' :
    (equalizerSubobjectIso f g).inv ≫ (equalizerSubobject f g).arrow = equalizer.ι f g
-- Mathlib/Data/Complex/Abs.lean
theorem abs_im_le_abs (z : ℂ) : |z.im| ≤ Complex.abs z
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem mulLeftMap_eq_mulRightMap {S : Type*} [CommSemiring S] [Module R S] [SMulCommClass R R S]
    [SMulCommClass R S S] [IsScalarTower R S S] {M : Submodule R S} (N : Submodule R S)
    {ι : Type*} (m : ι → M) : mulLeftMap N m = mulRightMap N m
-- Mathlib/CategoryTheory/Sites/EffectiveEpimorphic.lean
theorem Sieve.effectiveEpimorphic_family {B : C} {α : Type*}
    (X : α → C) (π : (a : α) → (X a ⟶ B)) :
    (Presieve.ofArrows X π).EffectiveEpimorphic ↔ EffectiveEpiFamily X π
-- Mathlib/Analysis/Calculus/Rademacher.lean
/-- A real-valued function on a finite-dimensional space which is Lipschitz on a set is
differentiable almost everywere in this set. Superseded by
`LipschitzOnWith.ae_differentiableWithinAt_of_mem` which works for functions taking value in any
finite-dimensional space. -/
theorem ae_differentiableWithinAt_of_mem_of_real (hf : LipschitzOnWith C f s) :
    ∀ᵐ x ∂μ, x ∈ s → DifferentiableWithinAt ℝ f s x
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
@[simp]
theorem det_fromBlocks_one₁₁ (B : Matrix m n α) (C : Matrix n m α) (D : Matrix n n α) :
    (Matrix.fromBlocks 1 B C D).det = det (D - C * B)
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp]
lemma of_counit {X : Type v} [Ring X] [HopfAlgebra R X] :
    Coalgebra.counit (A := of R X) = Coalgebra.counit (R := R) (A := X)
-- Mathlib/Topology/Separation.lean
lemma Pi.isCompact_iff {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, T2Space (π i)] {s : Set (Π i, π i)} :
    IsCompact s ↔ IsClosed s ∧ ∀ i, IsCompact (eval i '' s)
-- Mathlib/Data/NNRat/Defs.lean
theorem toNNRat_mul (hp : 0 ≤ p) : toNNRat (p * q) = toNNRat p * toNNRat q
-- Mathlib/Order/SupClosed.lean
lemma supClosed_sInter (hS : ∀ s ∈ S, SupClosed s) : SupClosed (⋂₀ S)
-- Mathlib/CategoryTheory/Extensive.lean
lemma FinitaryExtensive.isPullback_initial_to [FinitaryExtensive C]
    {ι : Type*} [Finite ι] {F : Discrete ι ⥤ C}
    {c : Cocone F} (hc : IsColimit c) (i j : Discrete ι) (e : i ≠ j) :
    IsPullback (initial.to _) (initial.to _) (c.ι.app i) (c.ι.app j)
-- Mathlib/LinearAlgebra/Dual.lean
theorem eval_apply_injective : Function.Injective (eval K V)
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp] lemma coe_algebraMap_apply (x : K) : ↑(algebraMap K S x) = algebraMap K L x
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.exists_mem_add_smul_eq (h : Convex 𝕜 s) {x y : E} {p q : 𝕜} (hx : x ∈ s) (hy : y ∈ s)
    (hp : 0 ≤ p) (hq : 0 ≤ q) : ∃ z ∈ s, (p + q) • z = p • x + q • y
-- Mathlib/Geometry/Manifold/BumpFunction.lean
/-- Given a smooth bump function `f : SmoothBumpFunction I c`, the closed ball of radius `f.R` is
known to include the support of `f`. These closed balls (in the model normed space `E`) intersected
with `Set.range I` form a basis of `𝓝[range I] (extChartAt I c c)`. -/
theorem nhdsWithin_range_basis :
    (𝓝[range I] extChartAt I c c).HasBasis (fun _ : SmoothBumpFunction I c => True) fun f =>
      closedBall (extChartAt I c c) f.rOut ∩ range I
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the signs of two nondegenerate oriented angles between points are equal, the oriented
angles are equal if and only if the unoriented angles are equal. -/
theorem angle_eq_iff_oangle_eq_of_sign_eq {p₁ p₂ p₃ p₄ p₅ p₆ : P} (hp₁ : p₁ ≠ p₂) (hp₃ : p₃ ≠ p₂)
    (hp₄ : p₄ ≠ p₅) (hp₆ : p₆ ≠ p₅) (hs : (∡ p₁ p₂ p₃).sign = (∡ p₄ p₅ p₆).sign) :
    ∠ p₁ p₂ p₃ = ∠ p₄ p₅ p₆ ↔ ∡ p₁ p₂ p₃ = ∡ p₄ p₅ p₆
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciInf_le_of_le {f : ι → α} (H : BddBelow (range f)) (c : ι) (h : f c ≤ a) : iInf f ≤ a
-- Mathlib/LinearAlgebra/Orientation.lean
/-- Composing a basis with a linear equiv gives the negation of that orientation if and only if
the determinant is negative. -/
theorem orientation_comp_linearEquiv_eq_neg_iff_det_neg (e : Basis ι R M) (f : M ≃ₗ[R] M) :
    (e.map f).orientation = -e.orientation ↔ LinearMap.det (f : M →ₗ[R] M) < 0
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainTopCoeff_zero_right [Nontrivial L] :
    chainTopCoeff α (0 : Weight K H L) = 1
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- The **extreme value theorem**: if a continuous function `f` tends to infinity away from compact
sets, then it has a global minimum. -/
theorem Continuous.exists_forall_le [ClosedIicTopology α] [Nonempty β] {f : β → α}
    (hf : Continuous f) (hlim : Tendsto f (cocompact β) atTop) : ∃ x, ∀ y, f x ≤ f y
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem unop_iInf (S : ι → Subring Rᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem Fintype.univ_bool : @univ Bool _ = {true, false}
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma ψ_three : W.ψ 3 = C W.Ψ₃
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem volume_fundamentalDomain [Fintype ι] [DecidableEq ι] (b : Basis ι ℝ (ι → ℝ)) :
    volume (fundamentalDomain b) = ENNReal.ofReal |(Matrix.of b).det|
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem sign_surjective [Nontrivial α] : Function.Surjective (sign : Perm α → ℤˣ)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
@[simp]
lemma totallyBounded_singleton (a : α) : TotallyBounded {a}
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negDblY_of_Z_ne_zero {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q)
    (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 ≠ W.negY Q * P z ^ 3) : W.negDblY P / W.dblZ P ^ 3 =
    W.toAffine.negAddY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
      (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3))
-- Mathlib/Combinatorics/HalesJewett.lean
@[simp] lemma toSubspace_isMono {l : Line (η → α) ι} {C : (ι × η → α) → κ} :
    l.toSubspace.IsMono C ↔ l.IsMono fun x : ι → η → α  ↦ C fun (i, e) ↦ x i e
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem toOuterMeasure_ofMultiset_apply :
    (ofMultiset s hs).toOuterMeasure t =
      (∑' x, (s.filter (· ∈ t)).count x : ℝ≥0∞) / (Multiset.card s)
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
theorem ExactFunctor.forget_obj_of (F : C ⥤ D) [PreservesFiniteLimits F]
    [PreservesFiniteColimits F] : (ExactFunctor.forget C D).obj (ExactFunctor.of F) = F
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem cast_castSucc {n' : Nat} {h : n + 1 = n' + 1} {i : Fin n} :
    cast h (castSucc i) = castSucc (cast (Nat.succ.inj h) i)
-- Mathlib/Algebra/Star/Module.lean
@[simp]
theorem star_natCast_smul [Semiring R] [AddCommMonoid M] [Module R M] [StarAddMonoid M] (n : ℕ)
    (x : M) : star ((n : R) • x) = (n : R) • star x
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.of_append_left : Nodup (l₁ ++ l₂) → Nodup l₁
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem map_symmDiff (a b : α) : f (a ∆ b) = f a ∆ f b
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_inf_eq : ⨅ x, f x ⊓ g x = (⨅ x, f x) ⊓ ⨅ x, g x
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem AEMeasurable.inf (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun a => f a ⊓ g a) μ
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem dirac_prod (x : α) : (dirac x).prod ν = map (Prod.mk x) ν
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem lintegral_map {β} [MeasurableSpace β] (g : β →ₛ ℝ≥0∞) {f : α → β} (hf : Measurable f) :
    g.lintegral (Measure.map f μ) = (g.comp f hf).lintegral μ
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem coe_zero : ⇑(0 : ModularForm Γ k) = (0 : ℍ → ℂ)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem IntegrableOn.left_of_union (h : IntegrableOn f (s ∪ t) μ) : IntegrableOn f s μ
-- Mathlib/MeasureTheory/PiSystem.lean
theorem has_iUnion {β} [Countable β] {f : β → Set α} (hd : Pairwise (Disjoint on f))
    (h : ∀ i, d.Has (f i)) : d.Has (⋃ i, f i)
-- Mathlib/Analysis/Convex/Radon.lean
/-- **Helly's theorem** for families of compact convex sets in its classical form.

If `F` is a (possibly infinite) family of more than `d + 1` compact convex sets in a vector space of
finite dimension `d`, and any `d + 1` sets of `F` intersect nontrivially,
then all sets of `F` intersect nontrivially. -/
theorem helly_theorem_compact [TopologicalSpace E] [T2Space E] {F : ι → Set E}
    (h_card : finrank 𝕜 E + 1 ≤ PartENat.card ι)
    (h_convex : ∀ i, Convex 𝕜 (F i)) (h_compact : ∀ i, IsCompact (F i))
    (h_inter : ∀ I : Finset ι, I.card = finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) :
    (⋂ i, F i).Nonempty
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem Q_apply (v : R × R) : Q c₁ c₂ v = c₁ * (v.1 * v.1) + c₂ * (v.2 * v.2)
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
/-- Characterization of C^n functions into a smooth vector bundle. -/
theorem contMDiffAt_totalSpace (f : M → TotalSpace F E) (x₀ : M) :
    ContMDiffAt IM (IB.prod 𝓘(𝕜, F)) n f x₀ ↔
      ContMDiffAt IM IB n (fun x => (f x).proj) x₀ ∧
        ContMDiffAt IM 𝓘(𝕜, F) n (fun x => (trivializationAt F E (f x₀).proj (f x)).2) x₀
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.self_le {f} (H : IsNormal f) (a) : a ≤ f a
-- Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean
theorem lapMatrix_toLin'_apply_eq_zero_iff_forall_reachable (x : V → ℝ) :
    Matrix.toLin' (G.lapMatrix ℝ) x = 0 ↔ ∀ i j : V, G.Reachable i j → x i = x j
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem imK_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :
    (dualNumberEquiv q).snd.imK = q.imK.snd
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
@[simp]
lemma val_one : (1 : PreQuasiregular R).val = 0
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem compl_ne_eq_singleton (a : α) : ({ x | x ≠ a } : Set α)ᶜ = {a}
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- The mean value theorem on a convex set: if the derivative of a function is bounded by `C`, then
the function is `C`-Lipschitz. Version with `HasFDerivWithinAt`. -/
theorem norm_image_sub_le_of_norm_hasFDerivWithin_le
    (hf : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (bound : ∀ x ∈ s, ‖f' x‖ ≤ C) (hs : Convex ℝ s)
    (xs : x ∈ s) (ys : y ∈ s) : ‖f y - f x‖ ≤ C * ‖y - x‖