ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Measure/Haar/Unique.lean
/-- **Uniqueness of left-invariant measures**:
Given two left-invariant measures which are finite
on compacts and regular, they coincide up to a multiplicative constant. -/
@[to_additive isAddLeftInvariant_eq_smul_of_regular]
lemma isMulLeftInvariant_eq_smul_of_regular [LocallyCompactSpace G]
    (μ' μ : Measure G) [IsHaarMeasure μ] [IsFiniteMeasureOnCompacts μ'] [IsMulLeftInvariant μ']
    [Regular μ] [Regular μ'] :
    μ' = haarScalarFactor μ' μ • μ
-- Mathlib/Order/CompleteLattice.lean
theorem lt_iSup_iff {f : ι → α} : a < iSup f ↔ ∃ i, a < f i
-- Mathlib/SetTheory/Game/PGame.lean
theorem lt_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- A point in the subspace is equidistant from another point and its
reflection. -/
theorem dist_reflection_eq_of_mem (s : AffineSubspace ℝ P) [Nonempty s]
    [HasOrthogonalProjection s.direction] {p₁ : P} (hp₁ : p₁ ∈ s) (p₂ : P) :
    dist p₁ (reflection s p₂) = dist p₁ p₂
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
theorem pullbackConeOfRightIso_π_app_none : (pullbackConeOfRightIso f g).π.app none = f
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma withDensity_one_sub_rnDerivAux (κ η : Kernel α γ) [IsFiniteKernel κ] [IsFiniteKernel η] :
    withDensity (κ + η) (fun a x ↦ Real.toNNReal (1 - rnDerivAux κ (κ + η) a x)) = η
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem image_sub_const_Iic : (fun x => x - a) '' Iic b = Iic (b - a)
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
/-- A closed ball in a product space is a product of closed balls. See also `closedBall_pi'`
for a version assuming `Nonempty β` instead of `0 ≤ r`. -/
lemma closedBall_pi (x : ∀ b, π b) {r : ℝ} (hr : 0 ≤ r) :
    closedBall x r = Set.pi univ fun b => closedBall (x b) r
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem DifferentiableOn.eventually_differentiableAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    ∀ᶠ y in 𝓝 x, DifferentiableAt 𝕜 f y
-- Mathlib/Algebra/Group/Center.lean
@[to_additive subset_addCenter_add_units]
theorem subset_center_units : ((↑) : Mˣ → M) ⁻¹' center M ⊆ Set.center Mˣ
-- Mathlib/Deprecated/Subring.lean
theorem isSubring_set_range {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) :
    IsSubring (Set.range f)
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
@[reassoc (attr := simp)]
lemma additiveObjIsoBiproduct_hom_π (F : Mat_ C ⥤ D) [Functor.Additive F] (M : Mat_ C) (i : M.ι) :
    (additiveObjIsoBiproduct F M).hom ≫ biproduct.π _ i =
      F.map (M.isoBiproductEmbedding.hom ≫ biproduct.π _ i)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem coe_const (b : β) : ⇑(const α b) = Function.const α b
-- Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean
/-- Composition of prelax functors. -/
@[simps]
def comp (G : PrelaxFunctor C D) : PrelaxFunctor B D
-- Mathlib/Algebra/Order/Group/Abs.lean
/-- The **triangle inequality** in `LinearOrderedAddCommGroup`s. -/
theorem abs_add (a b : α) : |a + b| ≤ |a| + |b|
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- **Cauchy–Schwarz inequality**. -/
theorem inner_mul_inner_self_le (x y : E) : ‖⟪x, y⟫‖ * ‖⟪y, x⟫‖ ≤ re ⟪x, x⟫ * re ⟪y, y⟫
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem coe_copy (S : NonUnitalSubsemiring R) (s : Set R) (hs : s = ↑S) :
    (S.copy s hs : Set R) = s
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- The Bochner integral of a real-valued function `f : α → ℝ` is the difference between the
  integral of the positive part of `f` and the integral of the negative part of `f`.  -/
theorem integral_eq_lintegral_pos_part_sub_lintegral_neg_part {f : α → ℝ} (hf : Integrable f μ) :
    ∫ a, f a ∂μ =
      ENNReal.toReal (∫⁻ a, .ofReal (f a) ∂μ) - ENNReal.toReal (∫⁻ a, .ofReal (-f a) ∂μ)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_mul_right' [GCDMonoid α] (a b c : α) :
    Associated (gcd (b * a) (c * a)) (gcd b c * a)
-- Mathlib/Order/RelIso/Basic.lean
theorem trans_apply (f : r ↪r s) (g : s ↪r t) (a : α) : (f.trans g) a = g (f a)
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
@[simp]
theorem submodule_mk'' (H : Submodule K V) (h : finrank K H = 1) : (mk'' H h).submodule = H
-- Mathlib/Logic/Equiv/Fin.lean
/-- Equivalence between `Fin (n + 1) → β` and `β × (Fin n → β)`. -/
@[simps! (config := .asFn)]
def Equiv.piFinSucc (n : ℕ) (β : Type u) : (Fin (n + 1) → β) ≃ β × (Fin n → β)
-- Mathlib/Data/Vector/Mem.lean
theorem not_mem_zero (v : Vector α 0) : a ∉ v.toList
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem setIntegral_condCDF (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (x : ℝ) {s : Set α}
    (hs : MeasurableSet s) : ∫ a in s, condCDF ρ a x ∂ρ.fst = (ρ (s ×ˢ Iic x)).toReal
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_div (a b : R) : abv (a / b) = abv a / abv b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal
-- Mathlib/Topology/Order/LeftRightLim.lean
/-- A monotone function is continuous to the right at a point if and only if its right limit
coincides with the value of the function. -/
theorem continuousWithinAt_Ioi_iff_rightLim_eq :
    ContinuousWithinAt f (Ioi x) x ↔ rightLim f x = f x
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diag_one [DecidableEq n] [Zero α] [One α] : diag (1 : Matrix n n α) = 1
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem coe_add (m₁ m₂ : OuterMeasure α) : ⇑(m₁ + m₂) = m₁ + m₂
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
lemma coe_monoidHom_symm_comp_coe_monoidHom (e : M ≃* N) :
    (e.symm : N →* M).comp e = MonoidHom.id _
-- Mathlib/Data/Nat/Bits.lean
lemma shiftLeft'_add (b m n) : ∀ k, shiftLeft' b m (n + k) = shiftLeft' b (shiftLeft' b m n) k
-- Mathlib/Algebra/Module/Bimodule.lean
/-- If `A` and `B` are also `Algebra`s over yet another set of scalars `S` then we may "base change"
from `R` to `S`. -/
@[simps!]
def baseChange (S : Type*) [CommSemiring S] [Module S M] [Algebra S A] [Algebra S B]
    [IsScalarTower S A M] [IsScalarTower S B M] (p : Submodule (A ⊗[R] B) M) :
    Submodule (A ⊗[S] B) M
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_singleton_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : s * {a} ∈ 𝓝 (b * a)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem associated_of_dvd_of_degree_eq {K} [Field K] {p q : K[X]} (hpq : p ∣ q)
    (h₁ : p.degree = q.degree) : Associated p q
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. A measurable function is smaller than its mean on a set of positive
measure. -/
theorem measure_le_setLaverage_pos (hμ : μ s ≠ 0) (hμ₁ : μ s ≠ ∞)
    (hf : AEMeasurable f (μ.restrict s)) : 0 < μ {x ∈ s | f x ≤ ⨍⁻ a in s, f a ∂μ}
-- Mathlib/Combinatorics/Additive/AP/Three/Defs.lean
@[to_additive]
theorem Set.Subsingleton.threeGPFree (hs : s.Subsingleton) : ThreeGPFree s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_add_pi (x : ℂ) : cos (x + π) = -cos x
-- Mathlib/Algebra/Module/Submodule/LinearMap.lean
@[simp]
theorem coeSubtype : (Submodule.subtype p : p → M) = Subtype.val
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. An integrable function is greater than its mean on a set of positive
measure. -/
theorem measure_setAverage_le_pos (hμ : μ s ≠ 0) (hμ₁ : μ s ≠ ∞) (hf : IntegrableOn f s μ) :
    0 < μ ({x ∈ s | ⨍ a in s, f a ∂μ ≤ f x})
-- Mathlib/Order/Monotone/Monovary.lean
theorem MonovaryOn.comp_monotoneOn_right (h : MonovaryOn f g s) (hg : MonotoneOn g' (g '' s)) :
    MonovaryOn f (g' ∘ g) s
-- Mathlib/Algebra/Order/Pointwise.lean
@[to_additive (attr := simp)]
theorem sInf_one : sInf (1 : Set α) = 1
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
/-- The two properties shown to be equivalent here are possible definitions for a Lie algebra
to be reductive.

Note that there is absolutely [no agreement](https://mathoverflow.net/questions/284713/) on what
the label 'reductive' should mean when the coefficients are not a field of characteristic zero. -/
theorem abelian_radical_iff_solvable_is_abelian [IsNoetherian R L] :
    IsLieAbelian (radical R L) ↔ ∀ I : LieIdeal R L, IsSolvable R I → IsLieAbelian I
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem mul_le_of_le_ediv {a b c : Int} (H1 : 0 < c) (H2 : a ≤ b / c) : a * c ≤ b
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/ProjectiveSeminorm.lean
theorem projectiveSeminormAux_add_le (p q : FreeAddMonoid (𝕜 × Π i, E i)) :
    projectiveSeminormAux (p + q) ≤ projectiveSeminormAux p + projectiveSeminormAux q
-- Mathlib/Logic/Relation.lean
@[simp] lemma reflTransGen_transGen : ReflTransGen (TransGen r) = ReflTransGen r
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc]
theorem Cofork.app_zero_eq_comp_π_right (s : Cofork f g) : s.ι.app zero = g ≫ s.π
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem dist_map (x y : E) : dist (f x) (f y) = dist x y
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem leadingCoeff_eq_iff {x : HahnSeries Γ R} : x.leadingCoeff = 0 ↔ x = 0
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma ciInf_eq_ite {p : Prop} [Decidable p] {f : p → α} :
    (⨅ h : p, f h) = if h : p then f h else sInf (∅ : Set α)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivWithinAt.const_add (c : F) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun y => c + f y) f' s x
-- Mathlib/CategoryTheory/Localization/Construction.lean
theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂
-- Mathlib/FieldTheory/KummerExtension.lean
lemma ne_zero_of_irreducible_X_pow_sub_C {n : ℕ} {a : K} (H : Irreducible (X ^ n - C a)) :
    n ≠ 0
-- Mathlib/Order/UpperLower/Basic.lean
@[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iSup₂ (f : ∀ i, κ i → LowerSet α) :
    (↑(⨆ (i) (j), f i j) : Set α) = ⋃ (i) (j), f i j
-- Mathlib/CategoryTheory/Bicategory/Functor/Oplax.lean
/-- The identity oplax functor. -/
@[simps]
def id (B : Type u₁) [Bicategory.{w₁, v₁} B] : OplaxFunctor B B
-- Mathlib/Algebra/Algebra/Tower.lean
theorem of_algebraMap_eq [Algebra R A]
    (h : ∀ x, algebraMap R A x = algebraMap S A (algebraMap R S x)) : IsScalarTower R S A
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_subset_Iio_self : Ioo a b ⊆ Iio b
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem MonotoneOn.map_csInf {β : Type*} [ConditionallyCompleteLattice β] {f : α → β}
    (hf : MonotoneOn f s) (hs : s.Nonempty) : f (sInf s) = sInf (f '' s)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem val_toFinset [DecidableEq α] (s : Finset α) : s.val.toFinset = s
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem basis_repr (h : IsAdjoinRootMonic S f) (x : S) (i : Fin (natDegree f)) :
    h.basis.repr x i = (h.modByMonicHom x).coeff (i : ℕ)
-- Mathlib/Algebra/Associated/Basic.lean
theorem associated_mul_unit_left {β : Type*} [Monoid β] (a u : β) (hu : IsUnit u) :
    Associated (a * u) a
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsBaseChange.of_lift_unique
    (h : ∀ (Q : Type max v₁ v₂ v₃) [AddCommMonoid Q],
      ∀ [Module R Q] [Module S Q], ∀ [IsScalarTower R S Q],
        ∀ g : M →ₗ[R] Q, ∃! g' : N →ₗ[S] Q, (g'.restrictScalars R).comp f = g) :
    IsBaseChange S f
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem tsum_mul_right : ∑' i, f i * a = (∑' i, f i) * a
-- Mathlib/CategoryTheory/ConcreteCategory/Basic.lean
theorem forget_map_eq_coe {X Y : C} (f : X ⟶ Y) : (forget C).map f = f
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem inv_last {i j} (w : NeWord G i j) : w.inv.last = w.head⁻¹
-- Mathlib/Order/Interval/Set/ProjIcc.lean
protected theorem Set.OrdConnected.IciExtend {s : Set (Ici a)} (hs : s.OrdConnected) :
    {x | IciExtend (· ∈ s) x}.OrdConnected
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
/-- A morphism of sheaves of types is locally bijective iff it is an isomorphism.
(This is generalized below as `isLocallyBijective_iff_isIso`.) -/
private lemma isLocallyBijective_iff_isIso' :
    IsLocallyInjective f ∧ IsLocallySurjective f ↔ IsIso f
-- Mathlib/CategoryTheory/Category/Cat.lean
@[simp]
lemma whiskerLeft_app {C D E : Cat} (F : C ⟶ D) {G H : D ⟶ E} (η : G ⟶ H) (X : C) :
    (F ◁ η).app X = η.app (F.obj X)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean
theorem card_eq_of_mem_parts_equitabilise :
    t ∈ (P.equitabilise h).parts → t.card = m ∨ t.card = m + 1
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
/-- An `R`-coalgebra is a comonoid object in the category of `R`-modules. -/
@[simps] def toComonObj (X : CoalgebraCat R) : Comon_ (ModuleCat R)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@[simp]
theorem adjugate_submatrix_equiv_self (e : n ≃ m) (A : Matrix m m α) :
    adjugate (A.submatrix e e) = (adjugate A).submatrix e e
-- Mathlib/Data/Finset/Sym.lean
theorem sym2_cons (a : α) (s : Finset α) (ha : a ∉ s) :
    (s.cons a ha).sym2 = ((s.cons a ha).map <| Sym2.mkEmbedding a).disjUnion s.sym2 (by
      simp [Finset.disjoint_left, ha])
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Ioo_of_le (ha : c ≤ a) : c ∉ Ioo a b
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem diam_triple :
    Metric.diam ({x, y, z} : Set α) = max (max (dist x y) (dist x z)) (dist y z)
-- Mathlib/Data/Rat/Lemmas.lean
theorem add_num_den' (q r : ℚ) :
    (q + r).num * q.den * r.den = (q.num * r.den + r.num * q.den) * (q + r).den
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
protected theorem mono (h : AEDisjoint μ s t) (hu : u ⊆ s) (hv : v ⊆ t) : AEDisjoint μ u v
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c
-- Mathlib/Algebra/Order/Ring/WithTop.lean
lemma mul_eq_bot_iff : a * b = ⊥ ↔ a ≠ 0 ∧ b = ⊥ ∨ a = ⊥ ∧ b ≠ 0
-- Mathlib/Combinatorics/Quiver/Path.lean
@[simp]
theorem comp_inj_left {p₁ p₂ : Path a b} {q : Path b c} : p₁.comp q = p₂.comp q ↔ p₁ = p₂
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioo_mem_nhdsWithin_Ici (H : b ∈ Ioo a c) : Ioo a c ∈ 𝓝[≥] b
-- Mathlib/Order/Antichain.lean
protected theorem eq' (hs : IsAntichain r s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) (h : r b a) :
    a = b
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma generateFrom_memPartition_le_succ (t : ℕ → Set α) (n : ℕ) :
    generateFrom (memPartition t n) ≤ generateFrom (memPartition t (n + 1))
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem continuousAt_inv_infDist_pt (h : x ∉ closure s) :
    ContinuousAt (fun x ↦ (infDist x s)⁻¹) x
-- Mathlib/Analysis/Normed/Order/Lattice.lean
theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖
-- Mathlib/GroupTheory/Transfer.lean
@[to_additive]
theorem diff_self : diff ϕ T T = 1
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_self : [[a, a]] = {a}
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp]
lemma hom_inv_id_apply {X Y : TopCat} (f : X ≅ Y) (x : X) : f.inv (f.hom x) = x
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem inv_def : s⁻¹ = s.image fun x => x⁻¹
-- Mathlib/Order/CompleteLattice.lean
@[gcongr]
theorem iInf_mono (h : ∀ i, f i ≤ g i) : iInf f ≤ iInf g
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
/-- If a function is integrable on a set `s`, and vanishes on `t \ s`, then it is integrable on `t`
if `t` is null-measurable. -/
theorem IntegrableOn.of_ae_diff_eq_zero (hf : IntegrableOn f s μ) (ht : NullMeasurableSet t μ)
    (h't : ∀ᵐ x ∂μ, x ∈ t \ s → f x = 0) : IntegrableOn f t μ
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem star_eq [Star R] {x : R} (hx : IsSelfAdjoint x) : star x = x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_eq_cfcₙ_iff_eqOn {f g : R → R} {a : A} (ha : p a := by cfc_tac)
    (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac) (hf0 : f 0 = 0 := by cfc_zero_tac)
    (hg : ContinuousOn g (σₙ R a) := by cfc_cont_tac) (hg0 : g 0 = 0 := by cfc_zero_tac) :
    cfcₙ f a = cfcₙ g a ↔ (σₙ R a).EqOn f g
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
/-- Applying a continuous linear map commutes with taking an (infinite) sum. -/
protected theorem ContinuousLinearMap.hasSum {f : ι → M} (φ : M →SL[σ] M₂) {x : M}
    (hf : HasSum f x) : HasSum (fun b : ι ↦ φ (f b)) (φ x)
-- Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean
lemma frontier_ball_subset_sphere : frontier (ball x ε) ⊆ sphere x ε
-- Mathlib/Data/Real/EReal.lean
lemma inv_neg (a : EReal) : (-a)⁻¹ = -a⁻¹
-- Mathlib/Tactic/NormNum/Ineq.lean
theorem isRat_lt_true [LinearOrderedRing α] [Nontrivial α] : {a b : α} → {na nb : ℤ} → {da db : ℕ} →
    IsRat a na da → IsRat b nb db → decide (na * db < nb * da) → a < b
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem trans_toPartialEquiv :
    (e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem Trivialization.smoothWithinAt_iff {f : M → TotalSpace F E} {s : Set M} {x₀ : M}
    (he : f x₀ ∈ e.source) :
    SmoothWithinAt IM (IB.prod 𝓘(𝕜, F)) f s x₀ ↔
      SmoothWithinAt IM IB (fun x => (f x).proj) s x₀ ∧
      SmoothWithinAt IM 𝓘(𝕜, F) (fun x ↦ (e (f x)).2) s x₀
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
theorem mem_support_pure_iff : a' ∈ (pure a).support ↔ a' = a
-- Mathlib/Data/Multiset/Basic.lean
@[elab_as_elim]
protected theorem induction_on {p : Multiset α → Prop} (s : Multiset α) (empty : p 0)
    (cons : ∀ (a : α) (s : Multiset α), p s → p (a ::ₘ s)) : p s
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem sup'_const (a : α) : s.sup' H (fun _ => a) = a
-- Mathlib/Data/Matrix/Block.lean
theorem fromBlocks_map (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α) (D : Matrix o m α)
    (f : α → β) : (fromBlocks A B C D).map f =
      fromBlocks (A.map f) (B.map f) (C.map f) (D.map f)
-- Mathlib/Data/Seq/Computation.lean
@[refl]
theorem Equiv.refl (s : Computation α) : s ~ s
-- Mathlib/Computability/Primrec.lean
theorem nat_mod : Primrec₂ ((· % ·) : ℕ → ℕ → ℕ)
-- Mathlib/Algebra/Lie/Abelian.lean
lemma lie_eq_self_of_isAtom_of_nonabelian {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
    (I : LieIdeal R L) (hI : IsAtom I) (h : ¬IsLieAbelian I) :
    ⁅I, I⁆ = I
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a)) :
    f.IsCoboundedUnder (· ≤ ·) u
-- Mathlib/Topology/Sets/Compacts.lean
@[ext]
protected theorem ext {s t : Compacts α} (h : (s : Set α) = t) : s = t
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem upperClosure_eq_top_iff : upperClosure s = ⊤ ↔ s = ∅
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem cos_pi_sub (x : ℝ) : cos (π - x) = -cos x
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma nonempty_rightResolution_iff_op (X₂ : C₂) :
    Nonempty (Φ.RightResolution X₂) ↔ Nonempty (Φ.op.LeftResolution (Opposite.op X₂))
-- Mathlib/Data/Fin/Basic.lean
lemma ne_last_of_lt {a b : Fin (n + 1)} (hab : a < b) : a ≠ last n
-- Mathlib/Tactic/Linarith/Lemmas.lean
theorem lt_irrefl {α : Type u} [Preorder α] {a : α} : ¬a < a
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem inr_add [AddZeroClass R] [Add A] (m₁ m₂ : A) : (↑(m₁ + m₂) : Unitization R A) = m₁ + m₂
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
lemma stabilizer_mul_eq_right [Group α] [SMulCommClass G α α] (a b : α) :
    stabilizer G (a * b) = stabilizer G b
-- Mathlib/Data/Real/Sqrt.lean
lemma sqrt_le_sqrt : sqrt x ≤ sqrt y ↔ x ≤ y
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[norm_cast] theorem ofNat_dvd {m n : Nat} : (↑m : Int) ∣ ↑n ↔ m ∣ n
-- Mathlib/MeasureTheory/Measure/Haar/Unique.lean
/-- If an invariant measure is inner regular, then it gives the same mass to measurable sets with
compact closure as any other invariant measure, up to the scalar `haarScalarFactor μ' μ`.

Auxiliary lemma in the proof of the more general
`measure_isMulInvariant_eq_smul_of_isCompact_closure`, which works for any set with
compact closure, and removes the inner regularity assumption. -/
@[to_additive measure_isAddInvariant_eq_smul_of_isCompact_closure_of_innerRegularCompactLTTop
" If an invariant measure is inner regular, then it gives the same mass to measurable sets with
compact closure as any other invariant measure, up to the scalar `addHaarScalarFactor μ' μ`.

Auxiliary lemma in the proof of the more general
`measure_isAddInvariant_eq_smul_of_isCompact_closure`, which works for any set with
compact closure, and removes the inner regularity assumption."]
lemma measure_isMulInvariant_eq_smul_of_isCompact_closure_of_innerRegularCompactLTTop
    [LocallyCompactSpace G]
    (μ' μ : Measure G) [IsHaarMeasure μ] [IsFiniteMeasureOnCompacts μ'] [IsMulLeftInvariant μ']
    [InnerRegularCompactLTTop μ]
    {s : Set G} (hs : MeasurableSet s) (h's : IsCompact (closure s)) :
    μ' s = haarScalarFactor μ' μ • μ s
-- Mathlib/Topology/Perfect.lean
/-- The **Cantor-Bendixson Theorem**: Any closed subset of a second countable space
can be written as the union of a countable set and a perfect set. -/
theorem exists_countable_union_perfect_of_isClosed [SecondCountableTopology α]
    (hclosed : IsClosed C) : ∃ V D : Set α, V.Countable ∧ Perfect D ∧ C = V ∪ D
-- Mathlib/Algebra/Order/Monoid/ToMulBot.lean
@[simp]
theorem toMulBot_coe (x : Multiplicative α) :
    toMulBot ↑x = Multiplicative.ofAdd (↑(Multiplicative.toAdd x) : WithBot α)
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- The universal morphism from any other cone to a limit cone. -/
@[simps]
def liftConeMorphism {t : Cone F} (h : IsLimit t) (s : Cone F) : s ⟶ t
-- Mathlib/Order/Filter/AtTopBot.lean
theorem frequently_atTop' [SemilatticeSup α] [Nonempty α] [NoMaxOrder α] {p : α → Prop} :
    (∃ᶠ x in atTop, p x) ↔ ∀ a, ∃ b > a, p b
-- Mathlib/Algebra/Ring/Parity.lean
lemma iterate_odd (hf : Involutive f) (hn : Odd n) : f^[n] = f
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_inl_union_inr_eq_prod (s) (t) :
    adjoin R (LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1})) =
      (adjoin R s).prod (adjoin R t)
-- Mathlib/Logic/Equiv/Basic.lean
theorem Function.Injective.swap_comp
    [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y : α) :
    Equiv.swap (f x) (f y) ∘ f = f ∘ Equiv.swap x y
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
@[simp] theorem dite_eq_left_iff {P : Prop} [Decidable P] {B : ¬ P → α} :
    dite P (fun _ => a) B = a ↔ ∀ h, B h = a
-- Mathlib/Data/DFinsupp/Basic.lean
theorem subtypeDomain_finsupp_sum {δ : γ → Type x} [DecidableEq γ] [∀ c, Zero (δ c)]
    [∀ (c) (x : δ c), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)] {p : ι → Prop} [DecidablePred p]
    {s : Π₀ c, δ c} {h : ∀ c, δ c → Π₀ i, β i} :
    (s.sum h).subtypeDomain p = s.sum fun c d => (h c d).subtypeDomain p
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- If an infinite type `β` can be expressed as a union of finite sets,
then the cardinality of the collection of those finite sets
must be at least the cardinality of `β`.
-/
theorem le_range_of_union_finset_eq_top {α β : Type*} [Infinite β] (f : α → Finset β)
    (w : ⋃ a, (f a : Set β) = ⊤) : #β ≤ #(range f)
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma zmultiplesAddHom_symm_apply (f : ℤ →+ β) : (zmultiplesAddHom β).symm f = f 1
-- Mathlib/Data/Num/Lemmas.lean
theorem to_int_inj {m n : ZNum} : (m : ℤ) = n ↔ m = n
-- Mathlib/GroupTheory/GroupAction/DomAct/Basic.lean
@[to_additive (attr := simp)]
lemma mk_one [One M] : mk (1 : M) = 1
-- Mathlib/CategoryTheory/EssentiallySmall.lean
theorem essentiallySmall_congr {C : Type u} [Category.{v} C] {D : Type u'} [Category.{v'} D]
    (e : C ≌ D) : EssentiallySmall.{w} C ↔ EssentiallySmall.{w} D
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem fp_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a = a) ↔ ∃ o, derivFamily.{u, v} f o = a