ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/NumberTheory/LSeries/Basic.lean
/-- The L-series of `δ` is the constant function `1`. -/
lemma LSeries_delta : LSeries δ = 1
-- Mathlib/Analysis/Convex/Cone/Proper.lean
@[ext]
theorem ext {S T : ProperCone 𝕜 E} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem AEMeasurable.edist {f g : β → α} {μ : Measure β} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g μ) : AEMeasurable (fun a => edist (f a) (g a)) μ
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma isLocallyInjective_forget_iff :
    IsLocallyInjective J (whiskerRight φ (forget D)) ↔ IsLocallyInjective J φ
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Basic.lean
theorem val_le_of_ge {n : Nat} {a b : Fin n} (h : a ≥ b) : (b : Nat) ≤ (a : Nat)
-- Mathlib/Algebra/Lie/EngelSubalgebra.lean
lemma mem_engel_iff (x y : L) :
    y ∈ engel R x ↔ ∃ n : ℕ, ((ad R L x) ^ n) y = 0
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.inter {t : Set E} (hs : Convex 𝕜 s) (ht : Convex 𝕜 t) : Convex 𝕜 (s ∩ t)
-- Mathlib/Algebra/CharZero/Lemmas.lean
theorem half_sub (a : R) : a / 2 - a = -(a / 2)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
/-- The `CstarRing.spectralOrder` on a unital C⋆-algebra is a `StarOrderedRing`. -/
lemma CstarRing.spectralOrderedRing : @StarOrderedRing A _ (CstarRing.spectralOrder A) _
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
/-- A prefunctor preserving reversal of arrows -/
class _root_.Prefunctor.MapReverse (φ : U ⥤q V) : Prop where
  /-- The image of a reverse is the reverse of the image. -/
  map_reverse' : ∀ {u v : U} (e : u ⟶ v), φ.map (reverse e) = reverse (φ.map e)
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
/-- `R` is integrally closed iff it is the integral closure of itself in its field of fractions. -/
theorem isIntegrallyClosed_iff_isIntegrallyClosedIn :
    IsIntegrallyClosed R ↔ IsIntegrallyClosedIn R K
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[simp]
theorem normalClosure_eq_self (H : Subgroup G) [H.Normal] : normalClosure ↑H = H
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem Differentiable.inner (hf : Differentiable ℝ f) (hg : Differentiable ℝ g) :
    Differentiable ℝ fun x => ⟪f x, g x⟫
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- If an antitone sequence of functions has a lower bound and the sequence of integrals of these
functions tends to the integral of the lower bound, then the sequence of functions converges
almost everywhere to the lower bound. -/
lemma tendsto_of_lintegral_tendsto_of_antitone {α : Type*} {mα : MeasurableSpace α}
    {f : ℕ → α → ℝ≥0∞} {F : α → ℝ≥0∞} {μ : Measure α}
    (hf_meas : ∀ n, AEMeasurable (f n) μ)
    (hf_tendsto : Tendsto (fun i ↦ ∫⁻ a, f i a ∂μ) atTop (𝓝 (∫⁻ a, F a ∂μ)))
    (hf_mono : ∀ᵐ a ∂μ, Antitone (fun i ↦ f i a))
    (h_bound : ∀ᵐ a ∂μ, ∀ i, F a ≤ f i a) (h0 : ∫⁻ a, f 0 a ∂μ ≠ ∞) :
    ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F a))
-- Mathlib/LinearAlgebra/Dimension/DivisionRing.lean
theorem rank_lt_rank_dual {K V : Type u} [Field K] [AddCommGroup V] [Module K V]
    (h : ℵ₀ ≤ Module.rank K V) : Module.rank K V < Module.rank K (V →ₗ[K] K)
-- Mathlib/Data/Real/Irrational.lean
@[simp] theorem not_irrational_one : ¬Irrational 1
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem natDegree_pos_of_aeval_root [Algebra R S] {p : R[X]} (hp : p ≠ 0) {z : S}
    (hz : aeval z p = 0) (inj : ∀ x : R, algebraMap R S x = 0 → x = 0) : 0 < p.natDegree
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem star_smul [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R,c₁,c₂]) :
    star (s • a) = s • star a
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_le_add {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x + y)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- A pseudometric space is second countable if, for every `ε > 0`, there is a countable set which
is `ε`-dense. -/
theorem secondCountable_of_almost_dense_set
    (H : ∀ ε > (0 : ℝ), ∃ s : Set α, s.Countable ∧ ∀ x, ∃ y ∈ s, dist x y ≤ ε) :
    SecondCountableTopology α
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem embDomain_smul (f : Γ ↪o Γ') (r : R) (x : HahnSeries Γ R) :
    embDomain f (r • x) = r • embDomain f x
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoLocallyUniformlyOn_univ :
    TendstoLocallyUniformlyOn F f p univ ↔ TendstoLocallyUniformly F f p
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem sub_eq (x y : BitVec w)                   : BitVec.sub x y = x - y
-- Mathlib/Data/List/Permutation.lean
theorem map_permutations (f : α → β) (ts : List α) :
    map (map f) (permutations ts) = permutations (map f ts)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_homothetyUnitsMulHom_apply_symm (p : P) (t : Rˣ) :
    ((homothetyUnitsMulHom p t).symm : P → P) = AffineMap.homothety p (↑t⁻¹ : R)
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem optionEquivSumPUnit_symm_inr (a) : (optionEquivSumPUnit α).symm (Sum.inr a) = none
-- Mathlib/Order/InitialSeg.lean
@[simp]
theorem ofElement_top {α : Type*} (r : α → α → Prop) (a : α) : (ofElement r a).top = a
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem dvd_of_squarefree_of_mul_dvd_mul_right (hx : Squarefree x) (h : d * d ∣ x * y) : d ∣ y
-- Mathlib/Order/Disjointed.lean
/-- `disjointed f` is the unique sequence that is pairwise disjoint and has the same partial sups
as `f`. -/
theorem disjointed_unique {f d : ℕ → α} (hdisj : Pairwise (Disjoint on d))
    (hsups : partialSups d = partialSups f) : d = disjointed f
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma setIntegral_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ}
    (hA : MeasurableSet[countableFiltration γ n] A) :
    ∫ x in A, densityProcess κ ν n a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem cocycle_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
      pullback.fst _ _ ≫ pullback.snd _ _
-- Mathlib/Data/Rat/Cast/Defs.lean
lemma cast_commute (q : ℚ≥0) (a : α) : Commute (↑q) a
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem bliminf_true (f : Filter β) (u : β → α) : (bliminf u f fun _ => True) = liminf u f
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
@[simp]
theorem log_zero : log 0 = 0
-- Mathlib/Algebra/Order/Ring/Cast.lean
lemma cast_natAbs : (n.natAbs : R) = |n|
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[simp]
theorem coe_toAddSubmonoid (p : Submodule R M) : (p.toAddSubmonoid : Set M) = p
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_one_le : cos 1 ≤ 2 / 3
-- Mathlib/Analysis/BoundedVariation.lean
theorem _root_.BoundedVariationOn.dist_le {E : Type*} [PseudoMetricSpace E] {f : α → E}
    {s : Set α} (h : BoundedVariationOn f s) {x y : α} (hx : x ∈ s) (hy : y ∈ s) :
    dist (f x) (f y) ≤ (eVariationOn f s).toReal
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_pair (s t : Set α) : ⋂₀ {s, t} = s ∩ t
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := simp)]
lemma mabs_apply (f : C(α, β)) (x : α) : |f|ₘ x = |f x|ₘ
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_const [UniformSpace β] {b : β} : UniformContinuous fun _ : α => b
-- Mathlib/LinearAlgebra/Multilinear/TensorProduct.lean
/-- When passed an `Equiv.sumCongr`, `MultilinearMap.domDomCongr` distributes over
`MultilinearMap.domCoprod`. -/
theorem domCoprod_domDomCongr_sumCongr (a : MultilinearMap R (fun _ : ι₁ => N) N₁)
    (b : MultilinearMap R (fun _ : ι₂ => N) N₂) (σa : ι₁ ≃ ι₃) (σb : ι₂ ≃ ι₄) :
    (a.domCoprod b).domDomCongr (σa.sumCongr σb) =
      (a.domDomCongr σa).domCoprod (b.domDomCongr σb)
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
/-- If `f` is almost everywhere positive, then `μ ≪ μ.withDensity f`. See also
`withDensity_absolutelyContinuous` for the reverse direction, which always holds. -/
lemma withDensity_absolutelyContinuous' {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) :
    μ ≪ μ.withDensity f
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem Monotone.Iic (hf : Monotone f) : Monotone fun x => Iic (f x)
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp, norm_cast]
theorem coe_zero : ⇑(0 : NonarchAddGroupSeminorm E) = 0
-- Mathlib/Topology/ContinuousOn.lean
theorem tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within {a : α} {l : Filter β} {s : Set α}
    (f : β → α) (h1 : Tendsto f l (𝓝 a)) (h2 : ∀ᶠ x in l, f x ∈ s) : Tendsto f l (𝓝[s] a)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- First version, with pointwise equicontinuity and range in a compact space. -/
theorem arzela_ascoli₁ [CompactSpace β] (A : Set (α →ᵇ β)) (closed : IsClosed A)
    (H : Equicontinuous ((↑) : A → α → β)) : IsCompact A
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.map (h : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] : (S.map F).Exact
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_symm_zero : (decompose ℳ).symm 0 = (0 : M)
-- Mathlib/ModelTheory/Definability.lean
theorem definable_finset_biInter {ι : Type*} {f : ι → Set (α → M)}
    (hf : ∀ i, A.Definable L (f i)) (s : Finset ι) : A.Definable L (⋂ i ∈ s, f i)
-- Mathlib/Data/Subtype.lean
theorem val_injective : Injective (@val _ p)
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ioc_Ioi {a b : α} (c : Ioc a b) : Subtype.val '' Ioi c = Ioc c.1 b
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem const_apply (p : P2) (q : P1) : (const k P1 p) q = p
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
theorem Basis.addHaar_self (b : Basis ι ℝ E) : b.addHaar (_root_.parallelepiped b) = 1
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Icc_mem_nhdsWithin_Iic' (H : a < b) : Icc a b ∈ 𝓝[≤] b
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- The constant functor followed by the evaluation functor is just the identity. -/
@[simps!]
def Functor.constCompEvaluationObj (X : C) : Functor.const C ⋙ (evaluation C D).obj X ≅ 𝟭 D
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsLimit.pos {o : Ordinal} (h : IsLimit o) : 0 < o
-- Mathlib/Combinatorics/Derangements/Finite.lean
@[simp]
theorem numDerangements_one : numDerangements 1 = 0
-- Mathlib/NumberTheory/MulChar/Lemmas.lean
/-- Define the conjugation (`star`) of a multiplicative character by conjugating pointwise. -/
@[simps!]
def starComp [StarRing R'] (χ : MulChar R R') : MulChar R R'
-- Mathlib/Order/SuccPred/Relation.lean
/-- For `m ≤ n`, `(n, m)` is in the reflexive-transitive closure of `~` if `succ i ~ i`
  for all `i` between `n` and `m`. -/
theorem reflTransGen_of_succ_of_ge (r : α → α → Prop) {n m : α} (h : ∀ i ∈ Ico m n, r (succ i) i)
    (hmn : m ≤ n) : ReflTransGen r n m
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_lt_top_of_ae_bound {f : α → F} {C : ℝ} (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    eLpNormEssSup f μ < ∞
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- A subsingleton is totally bounded. -/
lemma Set.Subsingleton.totallyBounded {s : Set α} (hs : s.Subsingleton) :
    TotallyBounded s
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp]
theorem zero_lt_top [Zero α] [LT α] : (0 : WithTop α) < ⊤
-- Mathlib/Algebra/Module/Defs.lean
theorem map_intCast_smul [AddCommGroup M] [AddCommGroup M₂] {F : Type*} [FunLike F M M₂]
    [AddMonoidHomClass F M M₂] (f : F) (R S : Type*) [Ring R] [Ring S] [Module R M] [Module S M₂]
    (x : ℤ) (a : M) :
    f ((x : R) • a) = (x : S) • f a
-- Mathlib/Tactic/Linarith/Lemmas.lean
theorem le_of_eq_of_le {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b ≤ 0) : a + b ≤ 0
-- Mathlib/Order/Filter/Basic.lean
@[simp]
protected theorem mem_mk {t : Set (Set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
@[simp]
theorem toFun_eq_coe (p : RingSeminorm R) : (p.toAddGroupSeminorm : R → ℝ) = p
-- Mathlib/Topology/Compactness/Compact.lean
theorem compactSpace_of_finite_subfamily_closed
    (h : ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → ⋂ i, t i = ∅ →
      ∃ u : Finset ι, ⋂ i ∈ u, t i = ∅) :
    CompactSpace X
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_multiset_prod (since := "2024-06-26")]
protected theorem map_multiset_prod (s : Multiset A) : φ s.prod = (s.map φ).prod
-- Mathlib/Algebra/Ring/Idempotents.lean
@[simp]
theorem coe_zero : ↑(0 : { p : M₀ // IsIdempotentElem p }) = (0 : M₀)
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem inducedOuterMeasure_preimage (f : α ≃ α) (Pm : ∀ s : Set α, P (f ⁻¹' s) ↔ P s)
    (mm : ∀ (s : Set α) (hs : P s), m (f ⁻¹' s) ((Pm _).mpr hs) = m s hs) {A : Set α} :
    inducedOuterMeasure m P0 m0 (f ⁻¹' A) = inducedOuterMeasure m P0 m0 A
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
/-- If `x` and `y` are two distinct vectors of norm at most `r`, then a convex combination of `x`
and `y` with positive coefficients has norm strictly less than `r`. -/
theorem norm_combo_lt_of_ne (hx : ‖x‖ ≤ r) (hy : ‖y‖ ≤ r) (hne : x ≠ y) (ha : 0 < a) (hb : 0 < b)
    (hab : a + b = 1) : ‖a • x + b • y‖ < r
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
/-- A function is a conformal map if and only if its differential is a conformal linear map-/
theorem conformalAt_iff_isConformalMap_fderiv {f : X → Y} {x : X} :
    ConformalAt f x ↔ IsConformalMap (fderiv ℝ f x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem toReal_eq_pi_iff {θ : Angle} : θ.toReal = π ↔ θ = π
-- Mathlib/Algebra/Star/StarRingHom.lean
/-- If a (unital or non-unital) star ring morphism has an inverse, it is an isomorphism of
star rings. -/
@[simps]
def ofStarRingHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆+* B
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem toSubalgebra_eq_top {S : StarSubalgebra R A} : S.toSubalgebra = ⊤ ↔ S = ⊤
-- Mathlib/Algebra/RingQuot.lean
/-- The quotient map from an `S`-algebra to its quotient, as a homomorphism of `S`-algebras.
-/
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- In this situation, `C` is also filtered, see
    `IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful`. -/
theorem Functor.final_of_exists_of_isFiltered_of_fullyFaithful [IsFilteredOrEmpty D] [F.Full]
    [F.Faithful] (h : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) : Final F
-- Mathlib/Topology/ContinuousFunction/StarOrdered.lean
lemma starOrderedRing_of_sqrt {R : Type*} [PartialOrder R] [NonUnitalRing R] [StarRing R]
    [StarOrderedRing R] [TopologicalSpace R] [ContinuousStar R] [TopologicalRing R]
    (sqrt : R → R) (h_continuousOn : ContinuousOn sqrt {x : R | 0 ≤ x})
    (h_sqrt : ∀ x, 0 ≤ x → star (sqrt x) * sqrt x = x) : StarOrderedRing C(α, R)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_sSup (S : Set (LowerSet α)) : (↑(sSup S) : Set α) = ⋃ s ∈ S, ↑s
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[ext]
theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Data/Set/Function.lean
theorem _root_.StrictMonoOn.mono (h : StrictMonoOn f s) (h' : s₂ ⊆ s) : StrictMonoOn f s₂
-- Mathlib/Data/Num/Lemmas.lean
theorem pred'_to_nat : ∀ n, (pred' n : ℕ) = Nat.pred n
-- Mathlib/Analysis/Convex/EGauge.lean
/-- If `c • x ∈ s` and `c ≠ 0`, then `egauge 𝕜 s x` is at most `((‖c‖₊⁻¹ : ℝ≥0) : ℝ≥0∞).

See also `egauge_le_of_smul_mem`. -/
lemma egauge_le_of_smul_mem_of_ne (h : c • x ∈ s) (hc : c ≠ 0) :
    egauge 𝕜 s x ≤ ↑(‖c‖₊⁻¹ : ℝ≥0)
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_inter (s₁ s₂ : Finset α) : ↑(s₁ ∩ s₂) = (s₁ ∩ s₂ : Set α)
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
/-- A smooth manifold with `0` and `Inv` such that `fun x ↦ x⁻¹` is smooth at all nonzero points.
Any complete normed (semi)field has this property. -/
class SmoothInv₀ {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Inv G] [Zero G] [TopologicalSpace G] [ChartedSpace H G] : Prop where
  /-- Inversion is smooth away from `0`. -/
  smoothAt_inv₀ : ∀ ⦃x : G⦄, x ≠ 0 → SmoothAt I I (fun y ↦ y⁻¹) x
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem eq_of_inner_right (hK : Dense (K : Set E)) (h : ∀ v : K, ⟪(v : E), x⟫ = ⟪(v : E), y⟫) :
    x = y
-- Mathlib/Data/Multiset/Basic.lean
theorem induction_on' {p : Multiset α → Prop} (S : Multiset α) (h₁ : p 0)
    (h₂ : ∀ {a s}, a ∈ S → s ⊆ S → p s → p (insert a s)) : p S
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[mono]
protected lemma Connected.mono {H H' : G.Subgraph} (hle : H ≤ H') (hv : H.verts = H'.verts)
    (h : H.Connected) : H'.Connected
-- Mathlib/NumberTheory/FermatPsp.lean
/--
This is a proof that the number produced using `psp_from_prime` is greater than the prime `p` used
to create it. The primary purpose of this lemma is to help prove `exists_infinite_pseudoprimes`.
-/
private theorem psp_from_prime_gt_p {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : p.Prime)
    (p_gt_two : 2 < p) : p < psp_from_prime b p
-- Mathlib/Data/Nat/Totient.lean
/-- Euler's product formula for the totient function. -/
theorem totient_mul_prod_primeFactors (n : ℕ) :
    (φ n * ∏ p ∈ n.primeFactors, p) = n * ∏ p ∈ n.primeFactors, (p - 1)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem _root_.LinearMap.compQuadraticMap_polar [CommSemiring S] [Algebra S R] [Module S N]
    [Module S N'] [IsScalarTower S R N] [Module S M] [IsScalarTower S R M] (f : N →ₗ[S] N')
    (Q : QuadraticMap R M N) (x y : M) : polar (f.compQuadraticMap' Q) x y = f (polar Q x y)
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem prod_finprod_comm (s : Finset α) (f : α → β → M) (h : ∀ a ∈ s, (mulSupport (f a)).Finite) :
    (∏ a ∈ s, ∏ᶠ b : β, f a b) = ∏ᶠ b : β, ∏ a ∈ s, f a b
-- Mathlib/NumberTheory/RamificationInertia.lean
/-- Since the inclusion `(P^(i + 1) / P^e) ⊂ (P^i / P^e)` has a kernel isomorphic to `P / S`,
`[P^i / P^e : R / p] = [P^(i+1) / P^e : R / p] + [P / S : R / p]` -/
theorem rank_pow_quot_aux [IsDedekindDomain S] [p.IsMaximal] [P.IsPrime] (hP0 : P ≠ ⊥)
    {i : ℕ} (hi : i < e) :
    Module.rank (R ⧸ p) (Ideal.map (Ideal.Quotient.mk (P ^ e)) (P ^ i)) =
      Module.rank (R ⧸ p) (S ⧸ P) +
        Module.rank (R ⧸ p) (Ideal.map (Ideal.Quotient.mk (P ^ e)) (P ^ (i + 1)))
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- Every point is covered by chosen balls, before `p.lastStep`. -/
theorem mem_iUnionUpTo_lastStep (x : β) : p.c x ∈ p.iUnionUpTo p.lastStep
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
/-- The set of differentiability points of a function taking values in a complete space is
Borel-measurable. -/
theorem measurableSet_of_differentiableAt : MeasurableSet { x | DifferentiableAt 𝕜 f x }
-- Mathlib/Data/List/Sigma.lean
theorem nodupKeys_singleton (s : Sigma β) : NodupKeys [s]
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
theorem Basis.card_le_card_of_le {N O : Submodule R M} (hNO : N ≤ O) [Fintype ι] (b : Basis ι R O)
    [Fintype ι'] (b' : Basis ι' R N) : Fintype.card ι' ≤ Fintype.card ι
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLen_of_length_lt {n} {l : List α} (h : l.length < n) : sublistsLen n l = []
-- Mathlib/Topology/Instances/RatLemmas.lean
theorem not_secondCountableTopology_opc : ¬SecondCountableTopology ℚ∞
-- Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean
/-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Comon_ D)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem add_succ (o₁ o₂ : Ordinal) : o₁ + succ o₂ = succ (o₁ + o₂)
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem sizeUpTo_length : c.sizeUpTo c.length = n
-- Mathlib/Data/Analysis/Filter.lean
theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
    f ≤ g ↔ ∀ b : G.σ, ∃ a : F.σ, F.F a ≤ G.F b
-- Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean
theorem exists_mem_of_not_isUnit_aeval_prod [IsDomain R] {p : R[X]} {a : A}
    (h : ¬IsUnit (aeval a (Multiset.map (fun x : R => X - C x) p.roots).prod)) :
    ∃ k : R, k ∈ σ a ∧ eval k p = 0
-- Mathlib/Algebra/Order/Hom/Basic.lean
/-- `GroupNormClass F α` states that `F` is a type of `β`-valued norms on the group `α`.

You should extend this class when you extend `GroupNorm`. -/
@[to_additive]
class GroupNormClass (F α β : Type*) [Group α] [OrderedAddCommMonoid β] [FunLike F α β]
  extends GroupSeminormClass F α β : Prop where
  /-- The argument is one if its image under the map is zero. -/
  eq_one_of_map_eq_zero (f : F) {a : α} : f a = 0 → a = 1
-- Mathlib/Order/PFilter.lean
theorem directed : DirectedOn (· ≥ ·) (F : Set P)
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulSupport_inf [SemilatticeInf M] (f g : α → M) :
    mulSupport (fun x ↦ f x ⊓ g x) ⊆ mulSupport f ∪ mulSupport g
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- The `ratio` is equal to the distance ratio for any two points
with nonzero finite distance; `nndist` version -/
theorem ratio_unique_of_nndist_ne_zero {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
    [FunLike F α β] [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (hxy : nndist x y ≠ 0)
    (hr : nndist (f x) (f y) = r * nndist x y) : r = ratio f
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_prod_mk_left {x : α} : Measurable (@Prod.mk _ β x)
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem recDiagAux_zero_left {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (n) :
    Nat.recDiagAux zero_left zero_right succ_succ 0 n = zero_left n
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma map_apply₀ {f : α → β} (hf : AEMeasurable f μ) {s : Set β}
    (hs : NullMeasurableSet s (map f μ)) : μ.map f s = μ (f ⁻¹' s)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extChartAt_nhds' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x) (𝓝 y) = 𝓝[range I] extChartAt I x y
-- Mathlib/Topology/Semicontinuous.lean
theorem UpperSemicontinuousOn.upperSemicontinuousWithinAt (h : UpperSemicontinuousOn f s)
    (hx : x ∈ s) : UpperSemicontinuousWithinAt f s x
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_group_smul : IsCoprime (x • y) (x • z) ↔ IsCoprime y z
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem mem_left_iff_eq_zero_of_disjoint {p p' : Submodule R M} (h : Disjoint p p') {x : p'} :
    (x : M) ∈ p ↔ x = 0
-- Mathlib/Topology/Instances/ENNReal.lean
theorem iInf_mul_right' {ι} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0)
    (h0 : a = 0 → Nonempty ι) : ⨅ i, f i * a = (⨅ i, f i) * a
-- Mathlib/Data/ZMod/Quotient.lean
@[to_additive (attr := simp)]
lemma infinite_zpowers : (zpowers a : Set α).Infinite ↔ ¬IsOfFinOrder a
-- Mathlib/Algebra/Group/Units.lean
@[simp]
theorem divp_self (u : αˣ) : (u : α) /ₚ u = 1
-- Mathlib/Data/Finset/Basic.lean
theorem union_inter_distrib_right (s t u : Finset α) : (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u
-- Mathlib/CategoryTheory/Preadditive/Projective.lean
/--
An object `P` is called *projective* if every morphism out of `P` factors through every epimorphism.
-/
class Projective (P : C) : Prop where
  factors : ∀ {E X : C} (f : P ⟶ X) (e : E ⟶ X) [Epi e], ∃ f', f' ≫ e = f
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp]
theorem testAgainstNN_zero (μ : FiniteMeasure Ω) : μ.testAgainstNN 0 = 0
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem «exists» {p : G.ConnectedComponent → Prop} :
    (∃ c : G.ConnectedComponent, p c) ↔ ∃ v, p (G.connectedComponentMk v)
-- Mathlib/Topology/Order/LowerUpperTopology.lean
@[simp] lemma to_WithLower_symm_eq : (@toLower α).symm = ofLower
-- Mathlib/Data/Set/Image.lean
/-- The image of a subsingleton is a subsingleton. -/
theorem Subsingleton.image (hs : s.Subsingleton) (f : α → β) : (f '' s).Subsingleton