ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem addVal_le_iff_dvd {a b : R} : addVal R a ≤ addVal R b ↔ a ∣ b
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem bliminf_or_le_inf_aux_right : (bliminf u f fun x => p x ∨ q x) ≤ bliminf u f q
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Pythagorean theorem, if-and-if vector inner product form using square roots. -/
theorem norm_add_eq_sqrt_iff_real_inner_eq_zero {x y : F} :
    ‖x + y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
theorem uniformSpace_eq_inf_precomp_of_cover {δ₁ δ₂ : Type*} (φ₁ : δ₁ → α) (φ₂ : δ₂ → α)
    (h_cover : range φ₁ ∪ range φ₂ = univ) :
    𝒰(α, β, _) =
      .comap (ofFun ∘ (· ∘ φ₁) ∘ toFun) 𝒰(δ₁, β, _) ⊓
      .comap (ofFun ∘ (· ∘ φ₂) ∘ toFun) 𝒰(δ₂, β, _)
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem prime_C_iff : Prime (C r : MvPolynomial σ R) ↔ Prime r
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toMultiset_lt_toMultiset : toMultiset f < toMultiset g ↔ f < g
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_inv_rpow_self {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ y) ^ (1 / y) = x
-- Mathlib/Topology/Algebra/OpenSubgroup.lean
@[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_inf : (↑(U ⊓ V) : Subgroup G) = ↑U ⊓ ↑V
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem eq_zero_of_lt {n ν : ℕ} (h : n < ν) : bernsteinPolynomial R n ν = 0
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_comm {f : ι → ι' → α} : ⨆ (i) (j), f i j = ⨆ (j) (i), f i j
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem sdiff_compl : x \ yᶜ = x ⊓ y
-- Mathlib/ModelTheory/DirectLimit.lean
/-- The direct limit of countably many countably generated structures is countably generated. -/
theorem cg {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
    {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
    (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
    Structure.CG L (DirectLimit G f)
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsLocalExtr.lineDeriv_eq_zero (h : IsLocalExtr f a) : lineDeriv ℝ f a = 0
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- The sum of two weighted homogeneous polynomials of degree `n` is weighted homogeneous of
  weighted degree `n`. -/
theorem add {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (hψ : IsWeightedHomogeneous w ψ n) :
    IsWeightedHomogeneous w (φ + ψ) n
-- Mathlib/CategoryTheory/Localization/StructuredArrow.lean
@[elab_as_elim]
lemma induction_costructuredArrow (g : CostructuredArrow L (L.obj Y)) : P g
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_le_smul' [PosSMulMono α β] [SMulPosMono α β] (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) (h₂ : 0 ≤ a₂)
    (h₁ : 0 ≤ b₁) : a₁ • b₁ ≤ a₂ • b₂
-- Mathlib/Data/SetLike/Basic.lean
theorem ext'_iff : p = q ↔ (p : Set B) = q
-- Mathlib/Topology/RestrictGenTopology.lean
/-- A sequential space is compactly generated. -/
lemma isCompact_of_seq [SequentialSpace X] : RestrictGenTopology {K : Set X | IsCompact K}
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Balls defined using the distance or the edistance coincide -/
@[simp]
theorem Metric.emetric_ball {x : α} {ε : ℝ} : EMetric.ball x (ENNReal.ofReal ε) = ball x ε
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
/-- A root system is a root pairing for which the roots span their ambient module.

Note that this is slightly more general than the usual definition in the sense that `N` is not
required to be the dual of `M`. -/
structure RootSystem extends RootPairing ι R M N :=
  span_eq_top : span R (range root) = ⊤
-- Mathlib/Topology/PartialHomeomorph.lean
theorem restr_eq_of_source_subset {e : PartialHomeomorph X Y} {s : Set X} (h : e.source ⊆ s) :
    e.restr s = e
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem tendsto_rightLim_within (x : α) : Tendsto f (𝓝[>] x) (𝓝[≤] rightLim f x)
-- Mathlib/Data/NNRat/Defs.lean
lemma add_def (q r : ℚ≥0) : q + r = divNat (q.num * r.den + r.num * q.den) (q.den * r.den)
-- Mathlib/Algebra/Group/PNatPowAssoc.lean
theorem ppow_eq_pow [Monoid M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (n : ℕ+) :
    x ^ n = x ^ (n : ℕ)
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem tendsto_exp_comp_atTop {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l atTop ↔ Tendsto f l atTop
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem dTo_eq {i j : ι} (r : c.Rel i j) : C.dTo j = (C.xPrevIso r).hom ≫ C.d i j
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffOn.congr (h : ContMDiffOn I I' n f s) (h₁ : ∀ y ∈ s, f₁ y = f y) :
    ContMDiffOn I I' n f₁ s
-- Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean
/-- You will rarely use this typeclass directly: it is implied by the combination
`[EnoughInjectives C]` and `[Abelian C]`. -/
class HasInjectiveResolutions : Prop where
  out : ∀ Z : C, HasInjectiveResolution Z
-- Mathlib/Data/Finset/Basic.lean
@[simp] lemma left_eq_union : s = s ∪ t ↔ t ⊆ s
-- Mathlib/Data/List/Rotate.lean
theorem Nodup.rotate_eq_self_iff {l : List α} (hl : l.Nodup) {n : ℕ} :
    l.rotate n = l ↔ n % l.length = 0 ∨ l = []
-- Mathlib/Data/Nat/Log.lean
theorem log_lt_of_lt_pow {b x y : ℕ} (hy : y ≠ 0) : y < b ^ x → log b y < x
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `C ≤ f'`, then
`f` grows at least as fast as `C * x` on `D`, i.e., `C * (y - x) ≤ f y - f x` whenever `x, y ∈ D`,
`x ≤ y`. -/
theorem Convex.mul_sub_le_image_sub_of_le_deriv {D : Set ℝ} (hD : Convex ℝ D) {f : ℝ → ℝ}
    (hf : ContinuousOn f D) (hf' : DifferentiableOn ℝ f (interior D)) {C}
    (hf'_ge : ∀ x ∈ interior D, C ≤ deriv f x) :
    ∀ᵉ (x ∈ D) (y ∈ D), x ≤ y → C * (y - x) ≤ f y - f x
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem map_comp_some (f : α → β) : Option.map f ∘ some = some ∘ f
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem of_d_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) (hd : P.d = 0) :
    P.toPoly = 0
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
@[simp]
theorem val_mulMap'_tmul (m : M) (n : N) : (mulMap' M N (m ⊗ₜ[R] n) : S) = m.1 * n.1
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- If `μ` is a weakly regular measure, then any open set can be approximated by a closed subset. -/
theorem _root_.IsOpen.measure_eq_iSup_isClosed ⦃U : Set α⦄ (hU : IsOpen U) (μ : Measure α)
    [WeaklyRegular μ] : μ U = ⨆ (F) (_ : F ⊆ U) (_ : IsClosed F), μ F
-- Mathlib/Algebra/Polynomial/Inductions.lean
theorem natDegree_divX_le : p.divX.natDegree ≤ p.natDegree
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem wellFoundedOn_union : (s ∪ t).WellFoundedOn r ↔ s.WellFoundedOn r ∧ t.WellFoundedOn r
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem roots_multiset_prod (m : Multiset R[X]) : (0 : R[X]) ∉ m → m.prod.roots = m.bind roots
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem lid_tmul (r : R) (a : A) : TensorProduct.lid R A (r ⊗ₜ a) = r • a
-- Mathlib/Algebra/Homology/Homotopy.lean
theorem mkCoinductiveAux₃ (i j : ℕ) (h : i + 1 = j) :
    (P.xNextIso h).inv ≫ (mkCoinductiveAux₂ e zero comm_zero one comm_one succ i).2.1 =
      (mkCoinductiveAux₂ e zero comm_zero one comm_one succ j).1 ≫ (Q.xPrevIso h).hom
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem insert_union (a : α) (s t : Finset α) : insert a s ∪ t = insert a (s ∪ t)
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_mk (f : InfHom α β) (hf) : ⇑(mk f hf) = f
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem sub_apply (f g : CentroidHom α) (a : α) : (f - g) a = f a - g a
-- Mathlib/CategoryTheory/Elements.lean
@[simp]
theorem comp_val {F : C ⥤ Type w} {p q r : F.Elements} {f : p ⟶ q} {g : q ⟶ r} :
    (f ≫ g).val = f.val ≫ g.val
-- Mathlib/Data/Array/ExtractLemmas.lean
@[simp]
theorem extract_eq_nil_of_start_eq_end {a : Array α} :
    a.extract i i = #[]
-- Mathlib/CategoryTheory/Category/ULift.lean
/-- The functorial version of `ULift.down`. -/
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C
-- Mathlib/FieldTheory/Finite/GaloisField.lean
theorem splits_zmod_X_pow_sub_X : Splits (RingHom.id (ZMod p)) (X ^ p - X)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasStrictDerivAt.ccosh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x
-- Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
@[simp]
theorem coeFn_mk (s : ∀ x, V x)
    (hs : ContMDiff I (I.prod 𝓘(𝕜, F)) n fun x => TotalSpace.mk x (s x)) :
    (mk s hs : ∀ x, V x) = s
-- Mathlib/Algebra/CharZero/Defs.lean
@[norm_cast]
theorem cast_ne_one {n : ℕ} : (n : R) ≠ 1 ↔ n ≠ 1
-- Mathlib/Data/Finset/Basic.lean
theorem insert_val_of_not_mem {a : α} {s : Finset α} (h : a ∉ s) : (insert a s).1 = a ::ₘ s.1
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem singleton_div : {a} / t = (· / ·) a '' t
-- Mathlib/Data/Prod/Basic.lean
theorem exists' {p : α → β → Prop} : (∃ x : α × β, p x.1 x.2) ↔ ∃ a b, p a b
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem getElem_setD (a : Array α) (i : Nat) (v : α) (h : i < (setD a i v).size) :
  (setD a i v)[i] = v
-- Mathlib/Order/Filter/Lift.lean
theorem tendsto_prod_self_iff {f : α × α → β} {x : Filter α} {y : Filter β} :
    Filter.Tendsto f (x ×ˢ x) y ↔ ∀ W ∈ y, ∃ U ∈ x, ∀ x x' : α, x ∈ U → x' ∈ U → f (x, x') ∈ W
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp]
theorem eq_padicNorm (q : ℚ) : ‖(q : ℚ_[p])‖ = padicNorm p q
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem exists_compact_not_null [Regular μ] : (∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem ofReal_log {x : ℝ} (hx : 0 ≤ x) : (x.log : ℂ) = log x
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem deriv_char_of_ne (h : a ≠ b) : deriv (char a) b = 0
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem Differentiable.neg (h : Differentiable 𝕜 f) : Differentiable 𝕜 fun y => -f y
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem coe_zeta_smul_apply {M} [Semiring R] [AddCommMonoid M] [Module R M]
    {f : ArithmeticFunction M} {x : ℕ} :
    ((↑ζ : ArithmeticFunction R) • f) x = ∑ i ∈ divisors x, f i
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem eq_nil_of_length_eq_zero (_ : length l = 0) : l = []
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.mul_lt_one'`. -/
@[to_additive "Assumes right covariance.
The lemma assuming left covariance is `Left.add_neg'`."]
theorem Right.mul_lt_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (ha : a < 1)
    (hb : b < 1) :
    a * b < 1
-- Mathlib/NumberTheory/NumberField/Basic.lean
theorem isIntegral (x : 𝓞 K) : IsIntegral ℤ x
-- Mathlib/Order/Interval/Set/Basic.lean
theorem _root_.IsBot.Ici_eq (h : IsBot a) : Ici a = univ
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem rank_range_of_injective (f : M →ₗ[R] M₁) (h : Injective f) :
    Module.rank R (LinearMap.range f) = Module.rank R M
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem mk_of_inl (x : M) : (mk (of (.inl x)) : M ∗ N) = inl x
-- Mathlib/Topology/Instances/Matrix.lean
@[continuity]
theorem Continuous.matrix_updateRow [DecidableEq m] (i : m) {A : X → Matrix m n R} {B : X → n → R}
    (hA : Continuous A) (hB : Continuous B) : Continuous fun x => (A x).updateRow i (B x)
-- Mathlib/Algebra/Quaternion.lean
theorem normSq_def : normSq a = (a * star a).re
-- Mathlib/Order/Directed.lean
theorem isTop_iff_isMax [IsDirected α (· ≤ ·)] : IsTop a ↔ IsMax a
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Icc_left (b : α) : ⋃ a, Icc a b = Iic b
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem isCongruenceSubgroup_trans (H K : Subgroup SL(2, ℤ)) (h : H ≤ K)
    (h2 : IsCongruenceSubgroup H) : IsCongruenceSubgroup K
-- Mathlib/Analysis/Convex/Function.lean
/-- A concave function on a segment is lower-bounded by the min of its endpoints. -/
theorem ConcaveOn.ge_on_segment' (hf : ConcaveOn 𝕜 s f) {x y : E} (hx : x ∈ s) (hy : y ∈ s)
    {a b : 𝕜} (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) : min (f x) (f y) ≤ f (a • x + b • y)
-- Mathlib/Topology/Algebra/Order/Group.lean
@[fun_prop]
protected theorem ContinuousOn.abs (h : ContinuousOn f s) : ContinuousOn (fun x => |f x|) s
-- Mathlib/Topology/Constructions.lean
theorem Continuous.quotient_lift {f : X → Y} (h : Continuous f) (hs : ∀ a b, a ≈ b → f a = f b) :
    Continuous (Quotient.lift f hs : Quotient s → Y)
-- Mathlib/RingTheory/Localization/FractionRing.lean
theorem mk'_eq_one_iff_eq {x : A} {y : nonZeroDivisors A} : mk' K x y = 1 ↔ x = y
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
theorem Ioi_add_bij : BijOn (· + d) (Ioi a) (Ioi (a + d))
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem isClosed_of_spaced_out [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {s : Set α}
    (hs : s.Pairwise fun x y => (x, y) ∉ V₀) : IsClosed s
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem toLex_natCast [NatCast α] (n : ℕ) : toLex (n : α) = n
-- Mathlib/Deprecated/Group.lean
/-- The identity is a group homomorphism. -/
@[to_additive "The identity is an additive group homomorphism."]
theorem id : IsGroupHom (@id α)
-- Mathlib/Data/List/Count.lean
@[simp]
theorem count_map_of_injective {β} [DecidableEq α] [DecidableEq β] (l : List α) (f : α → β)
    (hf : Function.Injective f) (x : α) : count (f x) (map f l) = count x l
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
@[simp]
theorem trunc_zero (n) : trunc n (0 : R⟦X⟧) = 0
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[norm_cast] -- Porting note: removed `@[simp]` because this is now structure eta
theorem coe_mk (x : M) (hx : x ∈ p) : ((⟨x, hx⟩ : p) : M) = x
-- Mathlib/Analysis/Convex/Integral.lean
theorem ConcaveOn.average_mem_hypograph [IsFiniteMeasure μ] [NeZero μ] (hg : ConcaveOn ℝ s g)
    (hgc : ContinuousOn g s) (hsc : IsClosed s) (hfs : ∀ᵐ x ∂μ, f x ∈ s)
    (hfi : Integrable f μ) (hgi : Integrable (g ∘ f) μ) :
    (⨍ x, f x ∂μ, ⨍ x, g (f x) ∂μ) ∈ {p : E × ℝ | p.1 ∈ s ∧ p.2 ≤ g p.1}
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma lie_eq_killingForm_smul_of_mem_rootSpace_of_mem_rootSpace_neg_aux
    {α : Weight K H L} {e f : L} (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (-α))
    (aux : ∀ (h : H), ⁅h, e⁆ = α h • e) :
    ⁅e, f⁆ = killingForm K L e f • (cartanEquivDual H).symm α
-- Mathlib/Data/List/Basic.lean
theorem reverse_surjective : Surjective (@reverse α)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem eventually_left_inverse {x} (hx : x ∈ e.source) :
    ∀ᶠ y in 𝓝 x, e.symm (e y) = y
-- Mathlib/Logic/Function/Basic.lean
lemma hfunext {α α' : Sort u} {β : α → Sort v} {β' : α' → Sort v} {f : ∀a, β a} {f' : ∀a, β' a}
    (hα : α = α') (h : ∀a a', HEq a a' → HEq (f a) (f' a')) : HEq f f'
-- Mathlib/Order/Filter/Bases.lean
theorem eq_iInf_principal (B : FilterBasis α) : B.filter = ⨅ s : B.sets, 𝓟 s
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem isClique_map_finset_iff :
    (G.map f).IsClique t ↔ t.card ≤ 1 ∨ ∃ (s : Finset α), G.IsClique s ∧ s.map f = t
-- Mathlib/Topology/NoetherianSpace.lean
theorem NoetherianSpace.wellFounded_closeds [NoetherianSpace α] :
    WellFounded fun s t : Closeds α => s < t
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive (attr := simp)]
lemma UniformFun.ofFun_mul [Mul β] (f g : α → β) : ofFun (f * g) = ofFun f * ofFun g
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem inclusion_right {S T : NonUnitalSubalgebra R A} (h : S ≤ T) (x : T) (m : (x : A) ∈ S) :
    inclusion h ⟨x, m⟩ = x
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem inv_id : inv (𝟙 X) = 𝟙 X
-- Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean
/-- Given two commutative rings `R S : CommRingCat` and a surjective morphism
`f : R ⟶ S`, the induced scheme morphism `specObj S ⟶ specObj R` is a
closed immersion. -/
theorem spec_of_surjective {R S : CommRingCat} (f : R ⟶ S) (h : Function.Surjective f) :
    IsClosedImmersion (Spec.map f)
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem lastFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α → last α') :
    lastFun (splitFun f g) = g
-- Mathlib/Data/Sum/Basic.lean
theorem isRight_congr (h : LiftRel r s x y) : x.isRight ↔ y.isRight
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem refl_partialEquiv : (PartialHomeomorph.refl X).toPartialEquiv = PartialEquiv.refl X
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma exp_llr_of_ac (μ ν : Measure α) [SigmaFinite μ] [Measure.HaveLebesgueDecomposition μ ν]
    (hμν : μ ≪ ν) :
    (fun x ↦ exp (llr μ ν x)) =ᵐ[μ] fun x ↦ (μ.rnDeriv ν x).toReal
-- Mathlib/RepresentationTheory/Rep.lean
theorem linearization_ε_inv_hom_apply (r : k) :
    (inv (linearization k G).ε).hom (Finsupp.single PUnit.unit r) = r
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem algebraMap_apply (a : A) : algebraMap A K a = a
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem ball_subset (h : edist x y + ε₁ ≤ ε₂) (h' : edist x y ≠ ∞) : ball x ε₁ ⊆ ball y ε₂
-- Mathlib/RingTheory/OreLocalization/Basic.lean
protected theorem smul_add (z : R[S⁻¹]) (x y : X[S⁻¹]) :
    z • (x + y) = z • x + z • y
-- Mathlib/Data/Finset/Preimage.lean
theorem map_subset_iff_subset_preimage {f : α ↪ β} {s : Finset α} {t : Finset β} :
    s.map f ⊆ t ↔ s ⊆ t.preimage f f.injective.injOn
-- Mathlib/Algebra/Order/Sub/Defs.lean
protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma coeff_ΨSq_ne_zero [NoZeroDivisors R] {n : ℤ} (h : (n : R) ≠ 0) :
    (W.ΨSq n).coeff (n.natAbs ^ 2 - 1) ≠ 0
-- Mathlib/CategoryTheory/GuitartExact/VerticalComposition.lean
/-- A 2-square stays Guitart exact if we replace the left and right functors
by isomorphic functors. See also `whiskerVertical_iff`. -/
lemma whiskerVertical [w.GuitartExact] (α : L ≅ L') (β : R ≅ R') :
    (w.whiskerVertical α.hom β.inv).GuitartExact
-- Mathlib/Data/Fin/Basic.lean
theorem val_injective : Function.Injective (@Fin.val n)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem opNorm_le_of_shell' {f : E →SL[σ₁₂] F} {ε C : ℝ} (ε_pos : 0 < ε) (hC : 0 ≤ C) {c : 𝕜}
    (hc : ‖c‖ < 1) (hf : ∀ x, ε * ‖c‖ ≤ ‖x‖ → ‖x‖ < ε → ‖f x‖ ≤ C * ‖x‖) : ‖f‖ ≤ C
-- Mathlib/LinearAlgebra/Span.lean
theorem subset_span_trans {U V W : Set M} (hUV : U ⊆ Submodule.span R V)
    (hVW : V ⊆ Submodule.span R W) : U ⊆ Submodule.span R W
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem Filter.EventuallyEq.fderivWithin' (hs : f₁ =ᶠ[𝓝[s] x] f) (ht : t ⊆ s) :
    fderivWithin 𝕜 f₁ t =ᶠ[𝓝[s] x] fderivWithin 𝕜 f t
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem comap_singleton_isClosed_of_isIntegral (f : R →+* S) (hf : f.IsIntegral)
    (x : PrimeSpectrum S) (hx : IsClosed ({x} : Set (PrimeSpectrum S))) :
    IsClosed ({comap f x} : Set (PrimeSpectrum R))
-- Mathlib/Topology/Order/LeftRight.lean
theorem nhdsWithin_Iic_neBot {a b : α} (H : a ≤ b) : NeBot (𝓝[Iic b] a)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_eq_empty_of_le (h : b ≤ a) : Ioc a b = ∅
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_union_Ico_eq_Ico (h₁ : a ≤ b) (h₂ : b < c) : Icc a b ∪ Ico b c = Ico a c
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma ite_nonneg_of_nonneg_of_pos [Preorder α] (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ ite p a b
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem compAlongComposition_apply {n : ℕ} (q : FormalMultilinearSeries 𝕜 F G)
    (p : FormalMultilinearSeries 𝕜 E F) (c : Composition n) (v : Fin n → E) :
    (q.compAlongComposition p c) v = q c.length (p.applyComposition c v)
-- Mathlib/Data/ENNReal/Inv.lean
theorem eq_top_of_forall_nnreal_le {x : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r ≤ x) : x = ∞
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- If all elements of a nonempty set `s` are less than or equal to all elements
of a nonempty set `t`, then there exists an element between these sets. -/
theorem exists_between_of_forall_le (sne : s.Nonempty) (tne : t.Nonempty)
    (hst : ∀ x ∈ s, ∀ y ∈ t, x ≤ y) : (upperBounds s ∩ lowerBounds t).Nonempty
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem norm_mkPiRing (z : G) : ‖ContinuousMultilinearMap.mkPiRing 𝕜 ι z‖ = ‖z‖
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_sub_right_of_add_lt {a b c : Int} (h : a + b < c) : a < c - b
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_iff_of_iso (e : S₁ ≅ S₂) : S₁.Exact ↔ S₂.Exact
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem sInf_toSubsemiring (S : Set (Subalgebra R A)) :
    (sInf S).toSubsemiring = sInf (Subalgebra.toSubsemiring '' S)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
lemma convolution_vonMangoldt_const_one : ↗Λ ⍟ 1 = ↗Complex.log
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma mapSetEquiv.ground (M : Matroid α) {E : Set β} (e : M.E ≃ E) :
    (M.mapSetEquiv e).E = E
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : ℝ)) : ℝ*) = OfNat.ofNat n
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
theorem inversion_involutive (c : P) {R : ℝ} (hR : R ≠ 0) : Involutive (inversion c R)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem restrict_smul {v : VectorMeasure α M} {i : Set α} (c : R) :
    (c • v).restrict i = c • v.restrict i
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem toSubring_injective {R : Type u} {A : Type v} [CommRing R] [Ring A] [Algebra R A] :
    Function.Injective (toSubring : Subalgebra R A → Subring A)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] protected theorem sub_lt_sub_right_iff (a b c : Int) :
    a - c < b - c ↔ a < b
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem mk_succ_pos (i : Nat) (h : i < n) :
    (0 : Fin (n + 1)) < ⟨i.succ, Nat.add_lt_add_right h 1⟩
-- Mathlib/Order/Filter/Basic.lean
theorem comap_neBot_iff_compl_range {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ (range m)ᶜ ∉ f
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem ae_eq_symm {f g : α → β} (h : f =ᵐ[μ] g) : g =ᵐ[μ] f
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem constr_basis (f : ι → M') (i : ι) : (constr (M' := M') b S f : M → M') (b i) = f i
-- Mathlib/Data/List/AList.lean
theorem mem_keys {a : α} {s : AList β} : a ∈ s ↔ a ∈ s.keys
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_comap {f : α → β} [u : UniformSpace β] :
    @UniformContinuous α β (UniformSpace.comap f u) u f
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp]
theorem map_apply {M : DMatrix m n α} {β : m → n → Type w} {f : ∀ ⦃i j⦄, α i j → β i j} {i : m}
    {j : n} : M.map f i j = f (M i j)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem of_eq_false (h : p = False) : ¬ p
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem self_mem_span_image [Nontrivial R] {i : ι} {s : Set ι} :
    b i ∈ span R (b '' s) ↔ i ∈ s
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem one_ne_top : 1 ≠ ∞
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem top_caratheodory : (⊤ : OuterMeasure α).caratheodory = ⊤
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
lemma descSet_inter_of_ne (x y : lc.pt) (hn : x ≠ y) : descSet hc {x} ∩ descSet hc {y} = ∅
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem measure_diff_right (h : AEDisjoint μ s t) : μ (t \ s) = μ t
-- Mathlib/Algebra/Ring/Invertible.lean
/-- A version of `inv_sub_inv'` for `invOf`. -/
theorem invOf_sub_invOf [Ring α] (a b : α) [Invertible a] [Invertible b] :
    ⅟a - ⅟b = ⅟a * (b - a) * ⅟b
-- Mathlib/LinearAlgebra/Dimension/DivisionRing.lean
/-- Key lemma towards the Erdős-Kaplansky theorem from https://mathoverflow.net/a/168624 -/
theorem max_aleph0_card_le_rank_fun_nat : max ℵ₀ #K ≤ Module.rank K (ℕ → K)