ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/ContinuousFunction/Compact.lean
/-- When `α` is compact, the bounded continuous maps `α →ᵇ β` are
equivalent to `C(α, β)`.
-/
@[simps (config := .asFn)]
def equivBoundedOfCompact : C(α, β) ≃ (α →ᵇ β)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem coe_prod (f : M [⋀^ι]→ₗ[R] N) (g : M [⋀^ι]→ₗ[R] P) :
    (f.prod g : MultilinearMap R (fun _ : ι => M) (N × P)) = MultilinearMap.prod f g
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiable.prod_mk {f : M → M'} {g : M → M''} (hf : MDifferentiable I I' f)
    (hg : MDifferentiable I I'' g) : MDifferentiable I (I'.prod I'') fun x => (f x, g x)
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
/-- `Equiv.mulRight₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulRight₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulRight₀' {a : α} (ha : a ≠ 0) : α ≃o α
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
/-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasisIndex (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) : ι
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- Any finite collection of objects in a filtered category has an object "to the right".
-/
theorem sup_objs_exists (O : Finset C) : ∃ S : C, ∀ {X}, X ∈ O → Nonempty (X ⟶ S)
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
theorem IsMatching.even_card [Fintype M.verts] (h : M.IsMatching) : Even M.verts.toFinset.card
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
theorem map_sub_le_max : f (x - y) ≤ max (f x) (f y)
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem preimage_mul_left_closedBall [IsometricSMul G G] (a b : G) (r : ℝ) :
    (a * ·) ⁻¹' closedBall b r = closedBall (a⁻¹ * b) r
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- Pull back an `I`-indexed family of objects to a `J`-indexed family, along a function `J → I`.
-/
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j))
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_self_le_mul_self_of_le_of_neg_le
    [MulPosMono α] [PosMulMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (h₁ : a ≤ b) (h₂ : -a ≤ b) : a * a ≤ b * b
-- Mathlib/Algebra/Module/Equiv/Defs.lean
protected theorem map_smulₛₗ (c : R) (x : M) : e (c • x) = (σ : R → S) c • e x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem aeval_X (s : σ) : aeval f (X s : MvPolynomial _ R) = f s
-- Mathlib/Data/Set/Basic.lean
theorem forall_mem_insert {P : α → Prop} {a : α} {s : Set α} :
    (∀ x ∈ insert a s, P x) ↔ P a ∧ ∀ x ∈ s, P x
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma predAbove_zero_of_ne_zero [NeZero n] {i : Fin (n + 1)} (hi : i ≠ 0) :
    predAbove 0 i = i.pred hi
-- Mathlib/Analysis/Complex/Isometry.lean
theorem LinearIsometry.im_apply_eq_im {f : ℂ →ₗᵢ[ℝ] ℂ} (h : f 1 = 1) (z : ℂ) :
    z + conj z = f z + conj (f z)
-- Mathlib/Computability/Encoding.lean
theorem Encoding.encode_injective {α : Type u} (e : Encoding α) : Function.Injective e.encode
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem ker_one : (1 : G →* M).ker = ⊤
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_eq_empty : (s : Set α) = ∅ ↔ s = ⊤
-- Mathlib/Data/Matroid/IndepAxioms.lean
/-- An `M : IndepMatroid α` gives a `Matroid α` whose bases are the maximal `M`-independent sets. -/
@[simps] protected def matroid (M : IndepMatroid α) : Matroid α
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[simp]
theorem R_mul {G : Type*} [Semigroup G] [TopologicalSpace G] [ChartedSpace H G] [SmoothMul I G]
    (g h : G) : 𝑹 I (g * h) = (𝑹 I h).comp (𝑹 I g)
-- Mathlib/Algebra/Group/Units/Equiv.lean
@[to_additive]
theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_X_pow_sub_one {n : ℕ} (hn : 0 < n) : (X ^ n - 1 : R[X]).leadingCoeff = 1
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- A version of the layer cake formula for bounded continuous functions and finite measures:
∫ f dμ = ∫ t in (0, ‖f‖], μ {x | f(x) ≥ t} dt. -/
lemma BoundedContinuousFunction.integral_eq_integral_meas_le
    {α : Type*} [MeasurableSpace α] [TopologicalSpace α] [OpensMeasurableSpace α]
    (f : α →ᵇ ℝ) (μ : Measure α) [IsFiniteMeasure μ] (f_nn : 0 ≤ᵐ[μ] f) :
    ∫ ω, f ω ∂μ = ∫ t in Ioc 0 ‖f‖, ENNReal.toReal (μ {a : α | t ≤ f a})
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem neg (hφ : IsHomogeneous φ n) : IsHomogeneous (-φ) n
-- Mathlib/LinearAlgebra/Pi.lean
/-- Linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → M) ≃ₗ[R] M × M
-- Mathlib/Data/NNReal/Basic.lean
@[norm_cast]
theorem coe_multiset_sum (s : Multiset ℝ≥0) : ((s.sum : ℝ≥0) : ℝ) = (s.map (↑)).sum
-- Mathlib/MeasureTheory/Measure/Content.lean
/-- The inner content of a union of sets is at most the sum of the individual inner contents.
  This is the "unbundled" version of `innerContent_iSup_nat`.
  It is required for the API of `inducedOuterMeasure`. -/
theorem innerContent_iUnion_nat [R1Space G] ⦃U : ℕ → Set G⦄
    (hU : ∀ i : ℕ, IsOpen (U i)) :
    μ.innerContent ⟨⋃ i : ℕ, U i, isOpen_iUnion hU⟩ ≤ ∑' i : ℕ, μ.innerContent ⟨U i, hU i⟩
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _
-- Mathlib/GroupTheory/Congruence/Basic.lean
@[to_additive]
theorem coe_smul {α M : Type*} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M)
    (a : α) (x : M) : (↑(a • x) : c.Quotient) = a • (x : c.Quotient)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableWithinAt.mul (ha : DifferentiableWithinAt 𝕜 a s x)
    (hb : DifferentiableWithinAt 𝕜 b s x) : DifferentiableWithinAt 𝕜 (fun y => a y * b y) s x
-- Mathlib/NumberTheory/NumberField/Norm.lean
theorem Algebra.coe_norm_int : (Algebra.norm ℤ x : ℚ) = Algebra.norm ℚ (x : K)
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_pure_pure (f : α → β) (a : α) : Tendsto f (pure a) (pure (f a))
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_eq_zero_iff_of_nonpos]
theorem prod_eq_one_iff_of_le_one' :
    (∀ i ∈ s, f i ≤ 1) → ((∏ i ∈ s, f i) = 1 ↔ ∀ i ∈ s, f i = 1)
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- Reversed version of **Fubini's Theorem** (symmetric version). -/
theorem integral_integral_symm {f : α → β → E} (hf : Integrable (uncurry f) (μ.prod ν)) :
    ∫ x, ∫ y, f x y ∂ν ∂μ = ∫ z, f z.2 z.1 ∂ν.prod μ
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem IsClosed.measurableSet (h : IsClosed s) : MeasurableSet s
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma map_iso_commute (g : M₀ →ₗ[R] M₁) : (map S f₀ f₁) g ∘ₗ (iso S f₀) =
    (iso S f₁) ∘ₗ (map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g
-- Mathlib/Algebra/Star/Pointwise.lean
@[simp]
theorem star_univ [Star α] : (univ : Set α)⋆ = univ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] protected theorem not_lt {a b : Nat} : ¬ a < b ↔ b ≤ a
-- Mathlib/Probability/CondCount.lean
theorem condCount_univ [Fintype Ω] {s : Set Ω} :
    condCount Set.univ s = Measure.count s / Fintype.card Ω
-- Mathlib/Data/Fin/Tuple/Sort.lean
/-- A permutation `σ` equals `sort f` if and only if the map `i ↦ (f (σ i), σ i)` is
strictly monotone (w.r.t. the lexicographic ordering on the target). -/
theorem eq_sort_iff' : σ = sort f ↔ StrictMono (σ.trans <| graphEquiv₁ f)
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma changeLevel_eq_cast_of_dvd {m : ℕ} (hm : n ∣ m) (a : Units (ZMod m)) :
    (changeLevel hm χ) a = χ (ZMod.cast (a : ZMod m))
-- Mathlib/Topology/CompactOpen.lean
theorem nhds_compactOpen_eq_iInf_nhds_induced (f : C(X, Y)) :
    𝓝 f = ⨅ (s) (hs : IsCompact s), (𝓝 (f.restrict s)).comap (ContinuousMap.restrict s)
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_Icc (r s : β) : StrictConvex 𝕜 (Icc r s)
-- Mathlib/Order/Bounds/Basic.lean
theorem image_lowerBounds_subset_upperBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    f '' (lowerBounds s ∩ t) ⊆ upperBounds (f '' s)
-- Mathlib/Topology/Bases.lean
protected theorem _root_.Inducing.firstCountableTopology {β : Type*}
    [TopologicalSpace β] [FirstCountableTopology β] {f : α → β} (hf : Inducing f) :
    FirstCountableTopology α
-- Mathlib/RingTheory/Binomial.lean
theorem smeval_ascPochhammer_neg_add (n : ℕ) : ∀ k : ℕ,
    smeval (ascPochhammer ℕ (n + k + 1)) (-n : ℤ) = 0
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- If the submodule generated by a set `s` is dense in the ambient module, then two continuous
linear maps equal on `s` are equal. -/
theorem ext_on [T2Space M₂] {s : Set M₁} (hs : Dense (Submodule.span R₁ s : Set M₁))
    {f g : M₁ →SL[σ₁₂] M₂} (h : Set.EqOn f g s) : f = g
-- Mathlib/Algebra/Field/Defs.lean
lemma smul_def (q : ℚ≥0) (a : α) : q • a = q * a
-- Mathlib/Data/Set/Card.lean
theorem eq_of_subset_of_ncard_le (h : s ⊆ t) (h' : t.ncard ≤ s.ncard)
    (ht : t.Finite := by toFinite_tac) : s = t
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Asymptotics.lean
theorem isBigO_sub (x : E) :
    (fun x' => f (x' - x)) =O[l] fun x' => x' - x
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem u_compact_support : HasCompactSupport (u : E → ℝ)
-- Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y)
-- Mathlib/CategoryTheory/EpiMono.lean
/-- A split mono which is epi is an iso. -/
theorem isIso_of_epi_of_isSplitMono {X Y : C} (f : X ⟶ Y) [IsSplitMono f] [Epi f] : IsIso f
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_iff_isIso_descOpcycles (φ : S₁ ⟶ S₂)
    (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (hg₂ : S₂.g = 0) :
    QuasiIso φ ↔ IsIso (S₁.descOpcycles φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero]))
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_eq_iUnion (s : Set α) (t : ∀ x ∈ s, Set β) :
    ⋃ x ∈ s, t x ‹_› = ⋃ x : s, t x x.2
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_inv {R : Type*} [DivisionRing R] (v : Valuation R Γ₀) : ∀ x, v x⁻¹ = (v x)⁻¹
-- Mathlib/NumberTheory/ModularForms/Identities.lean
theorem T_zpow_width_invariant (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (Gamma N) k) (z : ℍ) :
    f (((ModularGroup.T ^ (N * n))) • z) = f z
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma gaussianPDFReal_def (μ : ℝ) (v : ℝ≥0) :
    gaussianPDFReal μ v =
      fun x ↦ (Real.sqrt (2 * π * v))⁻¹ * rexp (- (x - μ)^2 / (2 * v))
-- Mathlib/Topology/ContinuousFunction/Ordered.lean
@[simp, norm_cast] lemma coe_sup (f g : C(α, β)) : ⇑(f ⊔ g) = ⇑f ⊔ g
-- Mathlib/Data/ENNReal/Basic.lean
theorem le_of_top_imp_top_of_toNNReal_le {a b : ℝ≥0∞} (h : a = ⊤ → b = ⊤)
    (h_nnreal : a ≠ ⊤ → b ≠ ⊤ → a.toNNReal ≤ b.toNNReal) : a ≤ b
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive] lemma isMulFreimanIso_id : IsMulFreimanIso n A A id
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive (attr := simp)]
theorem smul_apply [SMul K β] (k : K) (f : α →ₛ β) (a : α) : (k • f) a = k • f a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem add_bmod (a b : Int) (n : Nat) : (a + b).bmod n = (a.bmod n + b.bmod n).bmod n
-- Mathlib/Analysis/Matrix.lean
lemma linfty_opNorm_eq_opNorm (A : Matrix m n α) :
    ‖A‖ = ‖ContinuousLinearMap.mk (Matrix.mulVecLin A)‖
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem sign_coe_nonneg_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    0 ≤ (θ : Angle).sign
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma vecMul_fromColumns (B₁ : Matrix m n₁ R) (B₂ : Matrix m n₂ R) (v : m → R) :
    v ᵥ* fromColumns B₁ B₂ = Sum.elim (v ᵥ* B₁) (v ᵥ* B₂)
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
lemma one_le_thickenedIndicator_apply (X : Type _) [PseudoEMetricSpace X]
    {δ : ℝ} (δ_pos : 0 < δ) {F : Set X} {x : X} (hxF : x ∈ F) :
    1 ≤ thickenedIndicator δ_pos F x
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem mem_map {n : ℕ} {f : α → β} {b : β} {l : Sym α n} :
    b ∈ Sym.map f l ↔ ∃ a, a ∈ l ∧ f a = b
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := ext)]
theorem ext {f g : LocalizationMap S N} (h : ∀ x, f.toMap x = g.toMap x) : f = g
-- Mathlib/Algebra/Ring/Equiv.lean
/-- Two ring isomorphisms agree if they are defined by the
    same underlying function. -/
@[ext]
theorem ext {f g : R ≃+* S} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Data/Rel.lean
theorem image_inter (s t : Set α) : r.image (s ∩ t) ⊆ r.image s ∩ r.image t
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_of_initial_op (F : C ⥤ D) [Initial F.op] : Final F
-- Mathlib/Topology/Constructions.lean
theorem isOpen_iff {s : Set (CofiniteTopology X)} : IsOpen s ↔ s.Nonempty → sᶜ.Finite
-- Mathlib/Data/Set/Pointwise/BigOperators.lean
/-- The n-ary version of `Set.image_mul_prod`. -/
@[to_additive "The n-ary version of `Set.add_image_prod`. "]
theorem image_finset_prod_pi (l : Finset ι) (S : ι → Set α) :
    (fun f : ι → α => ∏ i ∈ l, f i) '' (l : Set ι).pi S = ∏ i ∈ l, S i
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem mapM_eq_mapM_data [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) :
    arr.mapM f = return mk (← arr.data.mapM f)
-- Mathlib/ModelTheory/Complexity.lean
theorem Formula.isAtomic_graph (f : L.Functions n) : (Formula.graph f).IsAtomic
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- An arrow of `S.pullback f` gives rise to an arrow of `S`. -/
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow
-- Mathlib/Topology/LocallyFinite.lean
/-- Let `f : ℕ → α → β` be a sequence of functions on a topological space. Suppose
that the family of sets `s n = {x | f (n + 1) x ≠ f n x}` is locally finite. Then there exists a
function `F :  α → β` such that for any `x`, for sufficiently large values of `n`, we have
`f n =ᶠ[𝓝 x] F`. -/
theorem exists_forall_eventually_atTop_eventuallyEq {f : ℕ → X → α}
    (hf : LocallyFinite fun n => { x | f (n + 1) x ≠ f n x }) :
    ∃ F : X → α, ∀ x, ∀ᶠ n : ℕ in atTop, f n =ᶠ[𝓝 x] F
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Unique.lean
theorem ae_eq_of_forall_setIntegral_eq_of_sigmaFinite' (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    {f g : α → F'} (hf_int_finite : ∀ s, MeasurableSet[m] s → μ s < ∞ → IntegrableOn f s μ)
    (hg_int_finite : ∀ s, MeasurableSet[m] s → μ s < ∞ → IntegrableOn g s μ)
    (hfg_eq : ∀ s : Set α, MeasurableSet[m] s → μ s < ∞ → ∫ x in s, f x ∂μ = ∫ x in s, g x ∂μ)
    (hfm : AEStronglyMeasurable' m f μ) (hgm : AEStronglyMeasurable' m g μ) : f =ᵐ[μ] g
-- Mathlib/NumberTheory/ClassNumber/AdmissibleCardPowDegree.lean
/-- If `x` is close to `y` and `y` is close to `z`, then `x` and `z` are at least as close. -/
theorem cardPowDegree_anti_archimedean {x y z : Fq[X]} {a : ℤ} (hxy : cardPowDegree (x - y) < a)
    (hyz : cardPowDegree (y - z) < a) : cardPowDegree (x - z) < a
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem trans_assoc (ePP₂ : P ≃ᵃⁱ[𝕜] P₂) (eP₂G : P₂ ≃ᵃⁱ[𝕜] P₃) (eGG' : P₃ ≃ᵃⁱ[𝕜] P₄) :
    ePP₂.trans (eP₂G.trans eGG') = (ePP₂.trans eP₂G).trans eGG'
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/Defs.lean
/-- Right-multiplying by `γ ∈ SL(2, ℤ)` sends `gammaSet N a` to `gammaSet N (a ᵥ* γ)`. -/
lemma vecMul_SL2_mem_gammaSet {v : Fin 2 → ℤ} (hv : v ∈ gammaSet N a) (γ : SL(2, ℤ)) :
    v ᵥ* γ ∈ gammaSet N (a ᵥ* γ)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderivWithin_const_add (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem mem_sup_right {S T : Subalgebra R A} : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T
-- Mathlib/Data/List/Intervals.lean
@[simp]
theorem length (n m : ℕ) : length (Ico n m) = m - n
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem toFinset_card {α : Type*} (s : Set α) [Fintype s] : s.toFinset.card = Fintype.card s
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Ne.symm (h : a ≠ b) : b ≠ a
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
/-- One can reformulate differentiability within a set at a point as continuity within this set at
this point, and differentiability in any chart containing that point. -/
theorem mdifferentiableWithinAt_iff_of_mem_source {x' : M} {y : M'}
    (hx : x' ∈ (chartAt H x).source) (hy : f x' ∈ (chartAt H' y).source) :
    MDifferentiableWithinAt I I' f s x' ↔
      ContinuousWithinAt f s x' ∧
        DifferentiableWithinAt 𝕜 (extChartAt I' y ∘ f ∘ (extChartAt I x).symm)
          ((extChartAt I x).symm ⁻¹' s ∩ Set.range I) ((extChartAt I x) x')
-- Mathlib/Logic/Equiv/Defs.lean
/-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
@[simps! (config := .asFn) apply symm_apply]
def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β
-- Mathlib/Order/ModularLattice.lean
theorem inf_covBy_of_covBy_sup_left : a ⋖ a ⊔ b → a ⊓ b ⋖ b
-- Mathlib/MeasureTheory/Function/L2Space.lean
theorem Memℒp.const_inner (c : E) {f : α → E} (hf : Memℒp f p μ) : Memℒp (fun a => ⟪c, f a⟫) p μ
-- Mathlib/Logic/Denumerable.lean
@[simp]
theorem ofNat_encode (a) : ofNat α (encode a) = a
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncate_truncate {n₁ n₂ n₃ : ℕ} (h1 : n₁ ≤ n₂) (h2 : n₂ ≤ n₃)
    (x : TruncatedWittVector p n₃ R) :
    (truncate h1) (truncate h2 x) = truncate (h1.trans h2) x
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem AEMeasurable.coe_nnreal_real {f : α → ℝ≥0} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : ℝ)) μ
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem MonoidHom.map_finprod {f : α → M} (g : M →* N) (hf : (mulSupport f).Finite) :
    g (∏ᶠ i, f i) = ∏ᶠ i, g (f i)
-- Mathlib/Order/Filter/Ultrafilter.lean
protected theorem NeBot.eq_pure_iff (hf : f.NeBot) {x : α} :
    f = pure x ↔ {x} ∈ f
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp]
lemma zero_comp {m : ℕ} (β : Ext Y Z m) (p : ℕ) (h : n + m = p) :
    (0 : Ext X Y n).comp β h = 0
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp)]
theorem toLex_mul [Mul α] (a b : α) : toLex (a * b) = toLex a * toLex b
-- Mathlib/Analysis/Convex/Side.lean
theorem sSameSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0
-- Mathlib/Algebra/Star/StarAlgHom.lean
lemma coe_restrictScalars (f : A →⋆ₙₐ[S] B) : (f.restrictScalars R : A →ₙ+* B) = f
-- Mathlib/Topology/Separation.lean
/-- In a locally compact regular space, given a compact set `K` inside an open set `U`, we can find
an open set `V` between these sets with compact closure: `K ⊆ V` and the closure of `V` is
inside `U`. -/
theorem exists_open_between_and_isCompact_closure [LocallyCompactSpace X] [RegularSpace X]
    {K U : Set X} (hK : IsCompact K) (hU : IsOpen U) (hKU : K ⊆ U) :
    ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V)
-- Mathlib/Probability/Independence/Kernel.lean
theorem indep_iSup_of_monotone [SemilatticeSup ι] {Ω} {m : ι → MeasurableSpace Ω}
    {m' m0 : MeasurableSpace Ω} {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ]
    (h_indep : ∀ i, Indep (m i) m' κ μ) (h_le : ∀ i, m i ≤ m0) (h_le' : m' ≤ m0)
    (hm : Monotone m) :
    Indep (⨆ i, m i) m' κ μ
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive]
theorem IsLowerSet.smul_subset (hs : IsLowerSet s) (hx : x ≤ 1) : x • s ⊆ s
-- Mathlib/Data/Finsupp/Defs.lean
theorem mapRange_sub [SubNegZeroMonoid G] [SubNegZeroMonoid H] {f : G → H} {hf : f 0 = 0}
    (hf' : ∀ x y, f (x - y) = f x - f y) (v₁ v₂ : α →₀ G) :
    mapRange f hf (v₁ - v₂) = mapRange f hf v₁ - mapRange f hf v₂
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem _root_.MeasureTheory.Integrable.hasSum_intervalIntegral (hfi : Integrable f μ) (y : ℝ) :
    HasSum (fun n : ℤ => ∫ x in y + n..y + n + 1, f x ∂μ) (∫ x, f x ∂μ)
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem min_const (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => min (f x) a
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The `LSeries` of the arithmetic function `ζ` is the same as the `LSeries` associated
to the constant sequence `1`. -/
lemma LSeries_zeta_eq : L ↗ζ = L 1
-- Mathlib/GroupTheory/Subgroup/Simple.lean
/-- A `Group` is simple when it has exactly two normal `Subgroup`s. -/
class IsSimpleGroup extends Nontrivial G : Prop where
  /-- Any normal subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : Subgroup G, H.Normal → H = ⊥ ∨ H = ⊤
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁
-- Mathlib/Topology/Algebra/Nonarchimedean/Basic.lean
/-- An open subgroup of a nonarchimedean ring contains the square of another one. -/
theorem mul_subset (U : OpenAddSubgroup R) : ∃ V : OpenAddSubgroup R, (V : Set R) * V ⊆ U
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem nhdsWithin_Iio_eq_bot_iff {a : α} : 𝓝[<] a = ⊥ ↔ IsBot a ∨ ∃ b, b ⋖ a
-- Mathlib/Algebra/Algebra/Prod.lean
theorem coe_prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : ⇑(f.prod g) = Pi.prod f g
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem mul_ciSup (hf : BddAbove (range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem foldr_eq_foldr_data (f : α → β → β) (init : β) (arr : Array α) :
    arr.foldr f init = arr.data.foldr f init
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem mem_Icc : f x ∈ Icc (0 : ℝ) 1
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.eq_biInf (h : l.HasBasis p s) : l = ⨅ (i) (_ : p i), 𝓟 (s i)
-- Mathlib/MeasureTheory/Function/AEEqFun/DomAct.lean
@[to_additive]
theorem smul_aeeqFun_aeeq (c : Mᵈᵐᵃ) (f : α →ₘ[μ] β) :
    c • f =ᵐ[μ] (f <| mk.symm c • ·)
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma monotone_defaultRatCDF : Monotone defaultRatCDF
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem colorable_of_isEmpty [IsEmpty V] (n : ℕ) : G.Colorable n
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem coe_toHomeomorph (e : M₁ ≃SL[σ₁₂] M₂) : ⇑e.toHomeomorph = e
-- Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
lemma predicateShift_LE (a n n' : ℤ) (hn' : a + n = n') :
    (PredicateShift (t.LE n) a) = t.LE n'
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma coe_map_Δ' : (E.map φ).Δ' = φ E.Δ'
-- Mathlib/Data/List/Infix.lean
theorem subset_insert (a : α) (l : List α) : l ⊆ l.insert a
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma iSup_basicOpen_eq_top_iff {ι : Type*} {f : ι → R} :
    (⨆ i : ι, PrimeSpectrum.basicOpen (f i)) = ⊤ ↔ Ideal.span (Set.range f) = ⊤
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
/-- When considering functions between manifolds, this statement shows up often. It entails
the unique differential of the pullback in extended charts of the set where the function can
be read in the charts. -/
theorem UniqueMDiffOn.uniqueDiffOn_inter_preimage (hs : UniqueMDiffOn I s) (x : M) (y : M')
    {f : M → M'} (hf : ContinuousOn f s) :
    UniqueDiffOn 𝕜
      ((extChartAt I x).target ∩ (extChartAt I x).symm ⁻¹' (s ∩ f ⁻¹' (extChartAt I' y).source))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem Real.logDeriv_sin : logDeriv (Real.sin) = Real.cot