ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Order/Group/Basic.lean
@[to_additive]
lemma zpow_le_zpow_iff (ha : 1 < a) : a ^ m ≤ a ^ n ↔ m ≤ n
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem trans_refl : e.trans (refl S M₂) = e
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_ofReal_re (x : ℝ) : (log (x : ℂ)).re = Real.log x
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
theorem bijective_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] :
    Function.Bijective ((forget C).map f)
-- Mathlib/Data/Set/Sups.lean
theorem sups_infs_subset_right : t ⊼ u ⊻ s ⊆ (t ⊻ s) ⊼ (u ⊻ s)
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.one_lt_mul_of_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (hb : 1 < b)
    (b0 : 0 ≤ b) : 1 < a * b
-- Mathlib/Data/Matroid/Basic.lean
/-- Any two sets `B₁`, `B₂` in a family with the exchange property have the same
`ℕ∞`-cardinality. -/
theorem encard_base_eq (hB₁ : Base B₁) (hB₂ : Base B₂) : B₁.encard = B₂.encard
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem Ico_succ_right_eq_insert_Ico (h : a ≤ b) : Ico a (b + 1) = insert b (Ico a b)
-- Mathlib/Data/Finset/Basic.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem insert_nonempty (a : α) (s : Finset α) : (insert a s).Nonempty
-- Mathlib/CategoryTheory/Sites/CoverLifting.lean
/-- A functor `G : (C, J) ⥤ (D, K)` between sites is called cocontinuous (SGA 4 III 2.1)
if for all covering sieves `R` in `D`, `R.pullback G` is a covering sieve in `C`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
class Functor.IsCocontinuous : Prop where
  cover_lift : ∀ {U : C} {S : Sieve (G.obj U)} (_ : S ∈ K (G.obj U)), S.functorPullback G ∈ J U
-- Mathlib/Order/Filter/Bases.lean
theorem countable_biInf_eq_iInf_seq [CompleteLattice α] {B : Set ι} (Bcbl : B.Countable)
    (Bne : B.Nonempty) (f : ι → α) : ∃ x : ℕ → ι, ⨅ t ∈ B, f t = ⨅ i, f (x i)
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
/-- A matrix multiplied by its conjugate transpose is positive semidefinite -/
theorem posSemidef_self_mul_conjTranspose (A : Matrix m n R) : PosSemidef (A * Aᴴ)
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
/-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J
-- Mathlib/Algebra/Order/Pi.lean
@[to_additive extend_nonneg] lemma one_le_extend (hg : 1 ≤ g) (he : 1 ≤ e) : 1 ≤ extend f g e
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
protected theorem congr_fun {f g : P1 →ᵃ[k] P2} (h : f = g) (x : P1) : f x = g x
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_sup (f g : SupHom α β) : DFunLike.coe (f ⊔ g) = f ⊔ g
-- Mathlib/Order/Hom/Lattice.lean
/-- Adjoins a `⊤` to the domain and codomain of an `InfHom`. -/
@[simps]
protected def withTop (f : InfHom α β) : InfTopHom (WithTop α) (WithTop β)
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem prod_map {δ} [PseudoEMetricSpace δ] {f : α → β} {g : γ → δ} (hf : Isometry f)
    (hg : Isometry g) : Isometry (Prod.map f g)
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_image_subset (t : τ) (ht : Tendsto (· + t) f f) :
    ω f ϕ (ϕ t '' s) ⊆ ω f ϕ s
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem vars_pow (φ : MvPolynomial σ R) (n : ℕ) : (φ ^ n).vars ⊆ φ.vars
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive three'_nsmul]
lemma pow_three' (a : M) : a ^ 3 = a * a * a
-- Mathlib/Topology/Clopen.lean
theorem isClopen_biUnion_finset {s : Finset Y} {f : Y → Set X}
    (h : ∀ i ∈ s, IsClopen <| f i) : IsClopen (⋃ i ∈ s, f i)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem intCast_def' (z : ℤ) : (z : A ⊗[R] B) = (1 : A) ⊗ₜ (z : B)
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma distinguished_cocone_triangle {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    ∃ (Z : Cᵒᵖ) (g : Y ⟶ Z) (h : Z ⟶ X⟦(1 : ℤ)⟧),
      Triangle.mk f g h ∈ distinguishedTriangles C
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
/-- Auxiliary lemma used as an argument to `CliffordAlgebra.changeForm` -/
theorem changeForm.neg_proof : (-B).toQuadraticMap = Q - Q'
-- Mathlib/Algebra/Module/BigOperators.lean
lemma Finset.sum_smul_sum (s : Finset α) (t : Finset β) {f : α → R} {g : β → M} :
    (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem Nonempty.smul_zero (hs : s.Nonempty) : s • (0 : Set β) = 0
-- Mathlib/Logic/Basic.lean
protected theorem Ne.ite_eq_right_iff (h : a ≠ b) : ite P a b = b ↔ ¬P
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem mem_centralizer_iff {s : Set A} {z : A} : z ∈ centralizer R s ↔ ∀ g ∈ s, g * z = z * g
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
protected theorem lt_trans {a b c : Fin n} : a < b → b < c → a < c
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
theorem domDomCongr_trans (σ₁ : ι₁ ≃ ι₂) (σ₂ : ι₂ ≃ ι₃)
    (m : MultilinearMap R (fun _ : ι₁ => M₂) M₃) :
    m.domDomCongr (σ₁.trans σ₂) = (m.domDomCongr σ₁).domDomCongr σ₂
-- Mathlib/Data/Finset/Card.lean
lemma card_union (s t : Finset α) : (s ∪ t).card = s.card + t.card - (s ∩ t).card
-- Mathlib/Topology/Order/ScottTopology.lean
@[simp] lemma dirSupInacc_compl : DirSupInacc sᶜ ↔ DirSupClosed s
-- Mathlib/Algebra/Module/Torsion.lean
theorem mem_torsion_iff (x : M) : x ∈ torsion R M ↔ ∃ a : R⁰, a • x = 0
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- A weighted sum over `s.filter pred` equals one over `s` if all the weights at indices in `s`
not satisfying `pred` are zero. -/
theorem weightedVSubOfPoint_filter_of_ne (w : ι → k) (p : ι → P) (b : P) {pred : ι → Prop}
    [DecidablePred pred] (h : ∀ i ∈ s, w i ≠ 0 → pred i) :
    (s.filter pred).weightedVSubOfPoint p b w = s.weightedVSubOfPoint p b w
-- Mathlib/Algebra/Order/Module/Defs.lean
/-- A constructor for `SMulPosReflectLT` requiring you to prove `a₁ • b < a₂ • b → a₁ < a₂` only
when `0 < b`-/
lemma SMulPosReflectLT.of_pos (h₀ : ∀ b : β, 0 < b → ∀ a₁ a₂ : α, a₁ • b < a₂ • b → a₁ < a₂) :
    SMulPosReflectLT α β
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring R] [Archimedean R]
    (s : ℕ → Set α) : limsup s atTop = { ω | Tendsto
      (fun n ↦ ∑ k ∈ Finset.range n, (s (k + 1)).indicator (1 : α → R) ω) atTop atTop }
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Right_nil_right : map₂Right f as [] = []
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_monomial (n : ℕ) (a : R) : (monomial n a).mirror = monomial n a
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem ContDiff.rpow_const_of_le (hf : ContDiff ℝ m f) (h : ↑m ≤ p) :
    ContDiff ℝ m fun x => f x ^ p
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
/-- Infinite sums commute with scalar multiplication. Version for scalars living in a `Group`, but
  not requiring any summability hypothesis. -/
lemma tsum_const_smul' {γ : Type*} [Group γ] [DistribMulAction γ α] [ContinuousConstSMul γ α]
    [T2Space α] (g : γ) : ∑' (i : β), g • f i = g • ∑' (i : β), f i
-- Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean
/-- The equivalence `(β →+ γ) ≃ (α →+ γ)` obtained by precomposition with
an additive equivalence `e : α ≃+ β`. -/
@[simps]
def precompEquiv {α β : Type*} [AddMonoid α] [AddMonoid β] (e : α ≃+ β) (γ : Type*) [AddMonoid γ] :
    (β →+ γ) ≃ (α →+ γ)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_inter_add_diff {B : Set α} (f : α → ℝ≥0∞) (A : Set α) (hB : MeasurableSet B) :
    ∫⁻ x in A ∩ B, f x ∂μ + ∫⁻ x in A \ B, f x ∂μ = ∫⁻ x in A, f x ∂μ
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive (attr := simp)]
theorem leftInvEquiv_symm_fromLeftInv (x : S.leftInv) :
    (S.leftInvEquiv hS).symm (S.fromLeftInv x) = x
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp]
theorem eventually_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b
-- Mathlib/Algebra/Free.lean
@[to_additive]
theorem lift_of_mul (x y) : lift f (of x * y) = f x * lift f y
-- Mathlib/Analysis/Convex/Gauge.lean
theorem mem_frontier_of_gauge_eq_one (hc : Convex ℝ s) (hs₀ : 0 ∈ s) (ha : Absorbent ℝ s)
    (h : gauge s x = 1) : x ∈ frontier s
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
/-- The canonical inclusion from the completion to the product. -/
@[simps]
def incl : AdicCompletion I M →ₗ[R] (∀ n, M ⧸ (I ^ n • ⊤ : Submodule R M))
-- Mathlib/Data/Prod/Basic.lean
theorem snd_surjective [h : Nonempty α] : Function.Surjective (@snd α β)
-- Mathlib/CategoryTheory/Elements.lean
/-- The equivalence `F.elementsᵒᵖ ≌ (yoneda, F)` is compatible with the forgetful functors. -/
@[simps!]
def costructuredArrowYonedaEquivalenceInverseπ (F : Cᵒᵖ ⥤ Type v) :
    (costructuredArrowYonedaEquivalence F).inverse ⋙ (π F).leftOp ≅ CostructuredArrow.proj _ _
-- Mathlib/Data/Fin/VecNotation.lean
theorem vecAppend_eq_ite {α : Type*} {o : ℕ} (ho : o = m + n) (u : Fin m → α) (v : Fin n → α) :
    vecAppend ho u v = fun i : Fin o =>
      if h : (i : ℕ) < m then u ⟨i, h⟩ else v ⟨(i : ℕ) - m, by omega⟩
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_mul_infiniteNeg {x y : ℝ*} :
    InfiniteNeg x → InfiniteNeg y → InfinitePos (x * y)
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Iic_mem_nhdsSet_Ioc (h : b < c) : Iic c ∈ 𝓝ˢ (Ioc a b)
-- Mathlib/Algebra/GroupWithZero/Basic.lean
/-- Multiplying `a` by itself and then dividing by itself results in `a`, whether or not `a` is
zero. -/
@[simp]
theorem mul_self_div_self (a : G₀) : a * a / a = a
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem add_one_le_succ (c : Cardinal.{u}) : c + 1 ≤ succ c
-- Mathlib/Data/Finset/Pairwise.lean
theorem pairwiseDisjoint_iff_coe_toFinset_pairwise_disjoint {α ι} [SemilatticeInf α] [OrderBot α]
    [DecidableEq ι] {l : List ι} {f : ι → α} (hn : l.Nodup) :
    (l.toFinset : Set ι).PairwiseDisjoint f ↔ l.Pairwise (_root_.Disjoint on f)
-- Mathlib/Data/Quot.lean
/-- A version of `Quotient.ind₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments. -/
@[elab_as_elim]
protected theorem ind₂' {p : Quotient s₁ → Quotient s₂ → Prop}
    (h : ∀ a₁ a₂, p (Quotient.mk'' a₁) (Quotient.mk'' a₂))
    (q₁ : Quotient s₁) (q₂ : Quotient s₂) : p q₁ q₂
-- Mathlib/Order/Filter/CountableInter.lean
@[simp]
theorem Filter.mem_ofCountableUnion {l : Set (Set α)} {hunion hmono s} :
    s ∈ ofCountableUnion l hunion hmono ↔ l sᶜ
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- Given a multicofork, we may obtain a cofork over `∐ I.left ⇉ ∐ I.right`. -/
@[simps pt]
noncomputable def toSigmaCofork (K : Multicofork I) : Cofork I.fstSigmaMap I.sndSigmaMap
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem finite_co_support (s : SummableFamily Γ R α) (g : Γ) :
    (Function.support fun a => (s a).coeff g).Finite
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasDerivWithinAt.rpow_const (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0 ∨ 1 ≤ p) :
    HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) s x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_add_const (r : R) (f : R → R) (a : A)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) (ha : p a := by cfc_tac) :
    cfc (fun x => f x + r) a = cfc f a + algebraMap R A r
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Absorbs.eventually_nhds_zero (h : Absorbs 𝕜 s t) (h₀ : 0 ∈ s) :
    ∀ᶠ c : 𝕜 in 𝓝 0, MapsTo (c • ·) t s
-- Mathlib/Analysis/Convex/Independent.lean
/-- If an indexed family of points is convex independent, so is the corresponding set of points. -/
protected theorem ConvexIndependent.range {p : ι → E} (hc : ConvexIndependent 𝕜 p) :
    ConvexIndependent 𝕜 ((↑) : Set.range p → E)
-- Mathlib/Order/Filter/Partial.lean
@[simp]
theorem rmap_compose (r : Rel α β) (s : Rel β γ) : rmap s ∘ rmap r = rmap (r.comp s)
-- Mathlib/Probability/Kernel/WithDensity.lean
/-- Auxiliary lemma for `IsSFiniteKernel.withDensity`.
If a kernel `κ` is finite, then `withDensity κ f` is s-finite. -/
theorem isSFiniteKernel_withDensity_of_isFiniteKernel (κ : Kernel α β) [IsFiniteKernel κ]
    (hf_ne_top : ∀ a b, f a b ≠ ∞) : IsSFiniteKernel (withDensity κ f)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma self_mul_dual :
    I * dual A K I = dual A K 1
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem toDual_bot [Bot α] : toDual (⊥ : α) = ⊤
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodCongrLeft_apply (b : β₁) (a : α₁) : prodCongrLeft e (b, a) = (e a b, a)
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- **Cauchy integral formula**: if `f : ℂ → E` is continuous on a closed disc of radius `R` and is
complex differentiable at all but countably many points of its interior, then for any `w` in this
interior we have $\frac{1}{2πi}\oint_{|z-c|=R}(z-w)^{-1}f(z)\,dz=f(w)$.
-/
theorem two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable {R : ℝ}
    {c w : ℂ} {f : ℂ → E} {s : Set ℂ} (hs : s.Countable) (hw : w ∈ ball c R)
    (hc : ContinuousOn f (closedBall c R)) (hd : ∀ x ∈ ball c R \ s, DifferentiableAt ℂ f x) :
    ((2 * π * I : ℂ)⁻¹ • ∮ z in C(c, R), (z - w)⁻¹ • f z) = f w
-- Mathlib/Topology/Compactness/Compact.lean
theorem Set.Subsingleton.isCompact (hs : s.Subsingleton) : IsCompact s
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
theorem one_rightUnitor {M : Mon_ C} :
    ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableAt.congr_of_eventuallyEq
    (h : LineDifferentiableAt 𝕜 f x v) (hL : f₁ =ᶠ[𝓝 x] f) :
    LineDifferentiableAt 𝕜 f₁ x v
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem ofFunction_eq (s : Set α) (m_mono : ∀ ⦃t : Set α⦄, s ⊆ t → m s ≤ m t)
    (m_subadd : ∀ s : ℕ → Set α, m (⋃ i, s i) ≤ ∑' i, m (s i)) :
    OuterMeasure.ofFunction m m_empty s = m s
-- Mathlib/Algebra/Star/Basic.lean
/-- A `*`-magma is a magma `R` with an involutive operation `star`
such that `star (r * s) = star s * star r`.
-/
class StarMul (R : Type u) [Mul R] extends InvolutiveStar R where
  /-- `star` skew-distributes over multiplication. -/
  star_mul : ∀ r s : R, star (r * s) = star s * star r
-- Mathlib/Topology/LocallyConstant/Basic.lean
/-- A (bundled) locally constant function from a topological space `X` to a type `Y`. -/
structure LocallyConstant (X Y : Type*) [TopologicalSpace X] where
  /-- The underlying function. -/
  protected toFun : X → Y
  /-- The map is locally constant. -/
  protected isLocallyConstant : IsLocallyConstant toFun
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp)]
theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_imK : (x : ℍ[R,c₁,c₂]).imK = 0
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- `fderiv 𝕜 f` is smooth. -/
theorem ContDiff.fderiv_right (hf : ContDiff 𝕜 n f) (hmn : (m + 1 : ℕ∞) ≤ n) :
    ContDiff 𝕜 m (fderiv 𝕜 f)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (h : μ ≤ c • μ')
    (hT : DominatedFinMeasAdditive μ T C) (hC : 0 ≤ C) :
    DominatedFinMeasAdditive μ' T (c.toReal * C)
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_le_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z ≤ y ^ z ↔ x ≤ y
-- Mathlib/Data/Set/Lattice.lean
lemma kernImage_preimage_eq_iff {s : Set β} : kernImage f (f ⁻¹' s) = s ↔ (range f)ᶜ ⊆ s
-- Mathlib/CategoryTheory/Limits/Shapes/Countable.lean
/--
A category has all countable colimits if every functor `J ⥤ C` with a `CountableCategory J`
instance and `J : Type` has a colimit.
-/
class HasCountableColimits : Prop where
  /-- `C` has all limits over any type `J` whose objects and morphisms lie in the same universe
  and which has countably many objects and morphisms-/
  out (J : Type) [SmallCategory J] [CountableCategory J] : HasColimitsOfShape J C
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem abs_integral_le_integral_abs (hab : a ≤ b) :
    |∫ x in a..b, f x ∂μ| ≤ ∫ x in a..b, |f x| ∂μ
-- Mathlib/FieldTheory/KummerExtension.lean
/-- Also see `Polynomial.separable_X_pow_sub_C_unit` -/
theorem Polynomial.separable_X_pow_sub_C_of_irreducible : (X ^ n - C a).Separable
-- Mathlib/Order/RelClasses.lean
theorem of_eq [IsRefl α r] : ∀ {a b}, a = b → r a b
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem decomposition.decompose'_apply (φ : MvPolynomial σ R) (i : ℕ) :
    (decomposition.decompose' φ i : MvPolynomial σ R) = homogeneousComponent i φ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
@[simp] theorem gcd_self (n : Nat) : gcd n n = n
-- Mathlib/LinearAlgebra/SModEq.lean
@[trans]
nonrec theorem trans (hxy : x ≡ y [SMOD U]) (hyz : y ≡ z [SMOD U]) : x ≡ z [SMOD U]
-- Mathlib/CategoryTheory/Sites/Discrete.lean
/-- Auxiliary lemma for `sheafCompose_reflects_discrete`. -/
private lemma constantSheafAdj_counit_w :
    ((sheafifyComposeIso J U ((const Cᵒᵖ).obj (F.val.obj ⟨t⟩))).symm ≪≫
      (presheafToSheaf J B ⋙ sheafToPresheaf J B).mapIso (constComp Cᵒᵖ (F.val.obj ⟨t⟩) U)).hom ≫
        ((constantSheafAdj J B ht).counit.app ((sheafCompose J U).obj F)).val =
          ((sheafCompose J U).map ((constantSheafAdj J A ht).counit.app F)).val
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
/-- The Radon-Nikodym theorem for signed measures. -/
theorem absolutelyContinuous_iff_withDensityᵥ_rnDeriv_eq (s : SignedMeasure α) (μ : Measure α)
    [SigmaFinite μ] : s ≪ᵥ μ.toENNRealVectorMeasure ↔ μ.withDensityᵥ (s.rnDeriv μ) = s
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp]
theorem DiagramOfCocones.mkOfHasColimits_coconePoints :
    (DiagramOfCocones.mkOfHasColimits F).coconePoints = F ⋙ colim
-- Mathlib/Order/BoundedOrder.lean
theorem bot_unique (h : a ≤ ⊥) : a = ⊥
-- Mathlib/Analysis/Normed/Module/Basic.lean
/-- In a normed algebra, the inclusion of the base field in the extended field is an isometry. -/
theorem algebraMap_isometry [NormOneClass 𝕜'] : Isometry (algebraMap 𝕜 𝕜')
-- Mathlib/CategoryTheory/Limits/MonoCoprod.lean
lemma mono_of_injective_aux (hι : Function.Injective ι) (c : Cofan X) (c₁ : Cofan (X ∘ ι))
    (hc : IsColimit c) (hc₁ : IsColimit c₁)
    (c₂ : Cofan (fun (k : ((Set.range ι)ᶜ : Set I)) => X k.1))
    (hc₂ : IsColimit c₂) : Mono (Cofan.IsColimit.desc hc₁ (fun i => c.inj (ι i)))
-- Mathlib/Data/Finset/Image.lean
theorem _root_.Function.Commute.finset_map {f g : α ↪ α} (h : Function.Commute f g) :
    Function.Commute (map f) (map g)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem liftNC_single (f : k →+ R) (g : Multiplicative G → R) (a : G) (b : k) :
    liftNC f g (single a b) = f b * g (Multiplicative.ofAdd a)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem pow_right_injective {a : R} (ha0 : a ≠ 0) (ha1 : ¬IsUnit a) :
    Function.Injective (a ^ · : ℕ → R)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem alternatization_def (m : MultilinearMap R (fun _ : ι => M) N') :
    ⇑(alternatization m) = (∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ : _)
-- Mathlib/Data/Finset/Basic.lean
@[elab_as_elim]
theorem cons_induction {α : Type*} {p : Finset α → Prop} (empty : p ∅)
    (cons : ∀ (a : α) (s : Finset α) (h : a ∉ s), p s → p (cons a s h)) : ∀ s, p s
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem id_comp (f : sSupHom α β) : (sSupHom.id β).comp f = f
-- Mathlib/Data/Rel.lean
@[simp]
theorem comp_left_id (r : Rel α β) : @Eq α • r = r
-- Mathlib/Algebra/DirectSum/Basic.lean
theorem IsInternal.addSubmonoid_iSup_eq_top {M : Type*} [DecidableEq ι] [AddCommMonoid M]
    (A : ι → AddSubmonoid M) (h : IsInternal A) : iSup A = ⊤
-- Mathlib/Data/Multiset/Dedup.lean
theorem dedup_le (s : Multiset α) : dedup s ≤ s
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
lemma scaleRoots_dvd' (p q : R[X]) {r : R} (hr : IsUnit r)
    (hpq : p ∣ q) : p.scaleRoots r ∣ q.scaleRoots r
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem monic_X_pow_add_C {n : ℕ} (h : n ≠ 0) : (X ^ n + C a).Monic
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Asymptotics.lean
theorem isBigO_comp {α : Type*} (f : α → E) (l : Filter α) : (fun x' => e (f x')) =O[l] f
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem norm_eq_sup'_normAtPlace (x : E K) :
    ‖x‖ = univ.sup' univ_nonempty fun w ↦ normAtPlace w x
-- Mathlib/Data/Set/Basic.lean
theorem union_union_union_comm (s t u v : Set α) : s ∪ t ∪ (u ∪ v) = s ∪ u ∪ (t ∪ v)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_imp_of_ae_restrict {s : Set α} {p : α → Prop} (h : ∀ᵐ x ∂μ.restrict s, p x) :
    ∀ᵐ x ∂μ, x ∈ s → p x
-- Mathlib/NumberTheory/Padics/RingHoms.lean
/-- One part of the universal property of `ℤ_[p]` as a projective limit.
See also `PadicInt.lift_unique`.
-/
theorem lift_spec (n : ℕ) : (toZModPow n).comp (lift f_compat) = f n
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A nontrivially normed field is a normed field in which there is an element of norm different
from `0` and `1`. This makes it possible to bring any element arbitrarily close to `0` by
multiplication by the powers of any element, and thus to relate algebra and topology. -/
class NontriviallyNormedField (α : Type*) extends NormedField α where
  /-- The norm attains a value exceeding 1. -/
  non_trivial : ∃ x : α, 1 < ‖x‖
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Lagrange's Mean Value Theorem, `HasDerivAt` version -/
theorem exists_hasDerivAt_eq_slope : ∃ c ∈ Ioo a b, f' c = (f b - f a) / (b - a)
-- Mathlib/RingTheory/Algebraic.lean
theorem algHom_bijective [Algebra.IsAlgebraic K L] (f : L →ₐ[K] L) :
    Function.Bijective f
-- Mathlib/CategoryTheory/Adjunction/Comma.lean
theorem isRightAdjoint_iff_hasInitial_structuredArrow {G : D ⥤ C} :
    G.IsRightAdjoint ↔ ∀ A, HasInitial (StructuredArrow A G)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- `limsup (c - xᵢ) = c - liminf xᵢ`. -/
lemma limsup_const_sub (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem closedUnder_univ : ClosedUnder f (univ : Set M)
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem Differentiable.comp_diffContOnCl {g : G → E} {t : Set G} (hf : Differentiable 𝕜 f)
    (hg : DiffContOnCl 𝕜 g t) : DiffContOnCl 𝕜 (f ∘ g) t
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_subset_Ioo_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioo a₂ b₂ ↔ a₂ < a₁ ∧ b₁ < b₂
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem differentiableOn_log : DifferentiableOn ℝ log {0}ᶜ
-- Mathlib/Order/SupClosed.lean
@[simp] lemma infClosed_infClosure : InfClosed (infClosure s)
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toMeasure_injective : (toMeasure : PMF α → Measure α).Injective
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem infix_concat : l₁ <:+: l₂ → l₁ <:+: concat l₂ a
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma killingForm_apply_apply (x y : L) : killingForm R L x y = trace R L (ad R L x ∘ₗ ad R L y)
-- Mathlib/Order/Interval/Set/Image.lean
theorem image_subtype_val_Iic_subset (a : {x // p x}) :
    Subtype.val '' Iic a ⊆ Iic a.val
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- In the characteristic zero case, the centroid lies in the affine
span if the number of points is `n + 1`. -/
theorem centroid_mem_affineSpan_of_card_eq_add_one [CharZero k] {s : Finset ι} (p : ι → P) {n : ℕ}
    (h : card s = n + 1) : s.centroid k p ∈ affineSpan k (range p)
-- Mathlib/Data/Set/Basic.lean
@[simp, mfld_simps]
theorem mem_inter_iff (x : α) (a b : Set α) : x ∈ a ∩ b ↔ x ∈ a ∧ x ∈ b
-- Mathlib/Topology/ContinuousOn.lean
@[simp] lemma nhdsWithin_univ (a : α) : 𝓝[Set.univ] a = 𝓝 a
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma sdiff_lt_left : s.sdiff t < s ↔ ¬ Disjoint ↑s t
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
theorem trace_fin_zero (A : Matrix (Fin 0) (Fin 0) R) : trace A = 0
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem sup_inf_inf_compl : x ⊓ y ⊔ x ⊓ yᶜ = x
-- Mathlib/Order/Filter/Lift.lean
theorem comap_lift'_eq {m : γ → β} : comap m (f.lift' h) = f.lift' (preimage m ∘ h)
-- Mathlib/Algebra/Lie/Sl2.lean
lemma f_ne_zero (t : IsSl2Triple h e f) : f ≠ 0