ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Finsupp.lean
protected theorem Submodule.finsupp_sum_mem {ι β : Type*} [Zero β] (S : Submodule R M) (f : ι →₀ β)
    (g : ι → β → M) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) : f.sum g ∈ S
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem _root_.MeasureTheory.OuterMeasure.toMeasure_top :
    (⊤ : OuterMeasure α).toMeasure (by rw [OuterMeasure.top_caratheodory]; exact le_top) =
      (⊤ : Measure α)
-- Mathlib/NumberTheory/FermatPsp.lean
private theorem b_id_helper {a b : ℕ} (ha : 2 ≤ a) (hb : 2 < b) : 2 ≤ (a ^ b + 1) / (a + 1)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem sign_neg_coe_nonpos_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    (-θ : Angle).sign ≤ 0
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem CokernelCofork.condition (s : CokernelCofork f) : f ≫ s.π = 0
-- Mathlib/NumberTheory/Padics/RingHoms.lean
@[simp]
theorem cast_toZModPow (m n : ℕ) (h : m ≤ n) (x : ℤ_[p]) :
    ZMod.cast (toZModPow n x) = toZModPow m x
-- Mathlib/Data/Vector/Mem.lean
theorem mem_cons_self (v : Vector α n) : a ∈ (a ::ᵥ v).toList
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConvexOn.sub_concaveOn (hf : StrictConvexOn 𝕜 s f) (hg : ConcaveOn 𝕜 s g) :
    StrictConvexOn 𝕜 s (f - g)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem disjoint_union_right [DecidableEq α] {s t u : Multiset α} :
    Disjoint s (t ∪ u) ↔ Disjoint s t ∧ Disjoint s u
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem destruct_cons (a : α) : ∀ s, destruct (cons a s) = some (a, s)
-- Mathlib/Topology/MetricSpace/Thickening.lean
@[simp]
theorem thickening_union (δ : ℝ) (s t : Set α) :
    thickening δ (s ∪ t) = thickening δ s ∪ thickening δ t
-- Mathlib/Data/TwoPointing.lean
@[simp]
theorem prop_fst : TwoPointing.prop.fst = False
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
lemma inl_desc (hP : IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W)
    (w : f ≫ h = g ≫ k) : inl ≫ hP.desc h k w = h
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingularLift_negMap {P : PointClass F} (hP : W.NonsingularLift P) :
    W.NonsingularLift <| W.negMap P
-- Mathlib/Order/Interval/Multiset.lean
@[simp]
theorem Ioc_eq_zero_iff : Ioc a b = 0 ↔ ¬a < b
-- Mathlib/Algebra/Ring/Prod.lean
theorem prod_comp_prodMap (f : T →ₙ+* R) (g : T →ₙ+* S) (f' : R →ₙ+* R') (g' : S →ₙ+* S') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)
-- Mathlib/CategoryTheory/Category/Preorder.lean
theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma strictAnti_smul_left (ha : a < 0) : StrictAnti ((a • ·) : β → β)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioo_of_Icc : AECover (μ.restrict <| Ioo A B) l fun i => Icc (a i) (b i)
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_set_mk (S : Subring K) (h) : ((⟨S, h⟩ : Subfield K) : Set K) = S
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.mono_left (h : a ≤ b) : Disjoint b c → Disjoint a c
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
@[simp]
theorem image_const_add_Ici : (fun x => a + x) '' Ici b = Ici (a + b)
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem expSeries_sum_eq_div (x : 𝔸) : (expSeries 𝕂 𝔸).sum x = ∑' n : ℕ, x ^ n / n !
-- Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
lemma dualSubmodule_dualSubmodule_of_basis
    {ι} [Finite ι] (hB : B.Nondegenerate) (hB' : B.IsSymm) (b : Basis ι S M) :
    B.dualSubmodule (B.dualSubmodule (Submodule.span R (Set.range b))) =
      Submodule.span R (Set.range b)
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.swap_left_iff [NoZeroSMulDivisors R V] {x y z : P} (h : Wbtw R x y z) :
    Wbtw R y x z ↔ x = y
-- Mathlib/Algebra/Lie/UniversalEnveloping.lean
@[simp]
theorem lift_symm_apply (F : UniversalEnvelopingAlgebra R L →ₐ[R] A) :
    (lift R).symm F = (F : UniversalEnvelopingAlgebra R L →ₗ⁅R⁆ A).comp (ι R)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_sub (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) : f (x - y) = f x - f y
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem rootSet_monomial [CommRing S] [IsDomain S] [Algebra R S] {n : ℕ} (hn : n ≠ 0) {a : R}
    (ha : a ≠ 0) : (monomial n a).rootSet S = {0}
-- Mathlib/Data/Complex/Module.lean
/-- The identity and the complex conjugation are the only two `ℝ`-algebra homomorphisms of `ℂ`. -/
theorem real_algHom_eq_id_or_conj (f : ℂ →ₐ[ℝ] ℂ) : f = AlgHom.id ℝ ℂ ∨ f = conjAe
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_append_right {a : α} (l₁ : List α) {l₂ : List α} (h : a ∈ l₂) : a ∈ l₁ ++ l₂
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem Cofork.π_precompose {f' g' : X ⟶ Y} {α : parallelPair f g ⟶ parallelPair f' g'}
    {c : Cofork f' g'} : Cofork.π ((Cocones.precompose α).obj c) = α.app _ ≫ c.π
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem And.symm : a ∧ b → b ∧ a
-- Mathlib/Data/Set/Basic.lean
lemma eq_of_forall_subset_iff (h : ∀ u, s ⊆ u ↔ t ⊆ u) : s = t
-- Mathlib/Algebra/DirectSum/Internal.lean
theorem coe_of_mul_apply_add [AddLeftCancelMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : A i)
    (r' : ⨁ i, A i) (j : ι) : ((of (fun i => A i) i r * r') (i + j) : R) = r * r' j
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_cons_of_mem {a b : α} {s : Multiset α} (h : a ∈ s) : a ∈ b ::ₘ s
-- Mathlib/CategoryTheory/Types.lean
@[ext] theorem types_ext {α β : Type u} (f g : α ⟶ β) (h : ∀ a : α, f a = g a) : f = g
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem support_hsum_subset {s : SummableFamily Γ R α} : s.hsum.support ⊆ ⋃ a : α, (s a).support
-- Mathlib/Data/Set/Image.lean
theorem image_subset_image_iff {f : α → β} (hf : Injective f) : f '' s ⊆ f '' t ↔ s ⊆ t
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@[reassoc (attr := simp)]
theorem adjunction_unit_naturality {X Y : Scheme.{u}} (f : X ⟶ Y) :
    f ≫ ΓSpec.adjunction.unit.app Y = ΓSpec.adjunction.unit.app X ≫ Spec.map (f.app ⊤)
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp]
theorem mul_snd (x y : X q) : (x * y).2 = x.1 * y.2 + x.2 * y.1
-- Mathlib/RingTheory/WittVector/Teichmuller.lean
@[simp]
theorem teichmuller_coeff_zero (r : R) : (teichmuller p r).coeff 0 = r
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
theorem snd_embedding_of_left_embedding {X Y S : TopCat} {f : X ⟶ S} (H : Embedding f) (g : Y ⟶ S) :
    Embedding <| ⇑(pullback.snd f g)
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_inj {f g : A →A[R] B} : (f : A →ₐ[R] B) = g ↔ f = g
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem UniqueMDiffWithinAt.mono (h : UniqueMDiffWithinAt I s x) (st : s ⊆ t) :
    UniqueMDiffWithinAt I t x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Subtracting the second vector passed to `oangle` from a multiple of the first vector negates
the sign of the angle. -/
@[simp]
theorem oangle_sign_smul_sub_right (x y : V) (r : ℝ) :
    (o.oangle x (r • x - y)).sign = -(o.oangle x y).sign
-- Mathlib/RingTheory/FinitePresentation.lean
theorem comp_surjective {f : A →+* B} {g : B →+* C} (hf : f.FinitePresentation) (hg : Surjective g)
    (hker : g.ker.FG) : (g.comp f).FinitePresentation
-- Mathlib/RingTheory/Nilpotent/Lemmas.lean
@[simp]
lemma isNilpotent_toMatrix_iff (b : Basis ι R M) (f : M →ₗ[R] M) :
    IsNilpotent (toMatrix b b f) ↔ IsNilpotent f
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
/-- If `n % 4 = 1`, then `(-1)^(n/2) = 1`. -/
theorem neg_one_pow_div_two_of_one_mod_four {n : ℕ} (hn : n % 4 = 1) : (-1 : ℤ) ^ (n / 2) = 1
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem J_squared : J l R * J l R = -1
-- Mathlib/SetTheory/Cardinal/SchroederBernstein.lean
/-- **The Schröder-Bernstein Theorem**:
Given injections `α → β` and `β → α`, we can get a bijection `α → β`. -/
theorem schroeder_bernstein {f : α → β} {g : β → α} (hf : Function.Injective f)
    (hg : Function.Injective g) : ∃ h : α → β, Bijective h
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem ContinuousLinearMap.isBoundedBilinearMap (f : E →L[𝕜] F →L[𝕜] G) :
    IsBoundedBilinearMap 𝕜 fun x : E × F => f x.1 x.2
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem trinomial_middle_coeff (hkm : k < m) (hmn : m < n) :
    (trinomial k m n u v w).coeff m = v
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableAt.sub_const (hf : DifferentiableAt 𝕜 f x) (c : F) :
    DifferentiableAt 𝕜 (fun y => f y - c) x
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_le_one_of_one_le_of_nonpos {x : ℝ≥0} {z : ℝ} (hx : 1 ≤ x) (hz : z ≤ 0) : x ^ z ≤ 1
-- Mathlib/Algebra/Order/Archimedean.lean
theorem existsUnique_sub_zsmul_mem_Ico {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b - m • a ∈ Set.Ico c (c + a)
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem mem_compl : a ∈ sᶜ ↔ a ∉ s
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_eq_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b = a * c ↔ b = c
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem totalVariation_absolutelyContinuous_iff (s : SignedMeasure α) (μ : Measure α) :
    s.totalVariation ≪ μ ↔
      s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
theorem BinaryFan.isLimit_iff_isIso_snd {X Y : C} (h : IsTerminal X) (c : BinaryFan X Y) :
    Nonempty (IsLimit c) ↔ IsIso c.snd
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem hom_right_act_hom' :
    ((P.tensorBimod Q).tensorBimod L).actRight ≫ hom P Q L =
      (hom P Q L ▷ U.X) ≫ (P.tensorBimod (Q.tensorBimod L)).actRight
-- Mathlib/Data/Real/Hyperreal.lean
theorem st_id_real (r : ℝ) : st r = r
-- Mathlib/Data/Finsupp/Basic.lean
@[simp, norm_cast]
theorem cast_finsupp_sum [DivisionRing R] [CharZero R] (g : α → M → ℚ) :
    (↑(f.sum g) : R) = f.sum fun a b => ↑(g a b)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_le_iff_le_add {a b c : Nat} : a - b ≤ c ↔ a ≤ c + b
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_self_nonpos {x : F} : ⟪x, x⟫_ℝ ≤ 0 ↔ x = 0
-- Mathlib/Order/Filter/Basic.lean
theorem Tendsto.eventually {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
    (hf : Tendsto f l₁ l₂) (h : ∀ᶠ y in l₂, p y) : ∀ᶠ x in l₁, p (f x)
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem balancedCore_empty : balancedCore 𝕜 (∅ : Set E) = ∅
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_two_mul : cos (2 * x) = 2 * cos x ^ 2 - 1
-- Mathlib/Order/Max.lean
theorem IsMax.fst (hx : IsMax x) : IsMax x.1
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- In the specific case of continuous multilinear maps on spaces indexed by `Fin (n+1)`, where one
can build an element of `(i : Fin (n+1)) → M i` using `cons`, one can express directly the
additivity of a multilinear map along the first variable. -/
theorem cons_add (f : ContinuousMultilinearMap R M M₂) (m : ∀ i : Fin n, M i.succ) (x y : M 0) :
    f (cons (x + y) m) = f (cons x m) + f (cons y m)
-- Mathlib/Algebra/Category/Ring/Basic.lean
lemma ext {X Y : CommSemiRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g
-- Mathlib/Data/Finset/Union.lean
@[simp, nolint simpNF] lemma disjiUnion_filter_eq (s : Finset α) (t : Finset β) (f : α → β) :
    t.disjiUnion (fun a ↦ s.filter (f · = a)) pairwiseDisjoint_fibers =
      s.filter fun c ↦ f c ∈ t
-- Mathlib/Data/Finite/Defs.lean
theorem finite_or_infinite (α : Sort*) : Finite α ∨ Infinite α
-- Mathlib/Topology/Algebra/ConstMulAction.lean
nonrec theorem continuousOn_const_smul_iff (hc : IsUnit c) :
    ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s
-- Mathlib/Topology/Algebra/Monoid.lean
theorem Filter.TendstoNhdsWithinIoi.mul_const [MulPosStrictMono 𝕜] [MulPosReflectLT 𝕜]
    (h : Tendsto f l (𝓝[>] c)) : Tendsto (fun a => f a * b) l (𝓝[>] (c * b))
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoLocallyUniformlyOn_iff_forall_isCompact [LocallyCompactSpace α] (hs : IsOpen s) :
    TendstoLocallyUniformlyOn F f p s ↔ ∀ K, K ⊆ s → IsCompact K → TendstoUniformlyOn F f p K
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem toSubmonoid_injective : Function.Injective (toSubmonoid : Subsemiring R → Submonoid R)
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma gaussianPDF_def (μ : ℝ) (v : ℝ≥0) :
    gaussianPDF μ v = fun x ↦ ENNReal.ofReal (gaussianPDFReal μ v x)
-- Mathlib/Order/CompleteLattice.lean
theorem isGLB_sInf (s : Set α) : IsGLB s (sInf s)
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem norm_inv (a : α) : ‖a⁻¹‖ = ‖a‖⁻¹
-- Mathlib/Data/Nat/Nth.lean
theorem nth_mem_of_lt_card {n : ℕ} (hf : (setOf p).Finite) (hlt : n < hf.toFinset.card) :
    p (nth p n)
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- The triangles of consisting of a morphism in `H` and the maps to `sup O H` commute.
-/
theorem toSup_commutes {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y}
    (mf : (⟨X, Y, mX, mY, f⟩ : Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H) :
    f ≫ toSup O H mY = toSup O H mX
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem coe_coe_symm : (e.toPartialEquiv.symm : Y → X) = e.symm
-- Mathlib/SetTheory/Game/PGame.lean
/-- Show that the response for left provided by `leftResponse` preserves the left-player-wins
condition. -/
theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
    0 ≤ (x.moveRight j).moveLeft (leftResponse h j)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- The measurable superset `toMeasurable μ t` of `t` (which has the same measure as `t`)
satisfies, for any measurable set `s`, the equality `μ (toMeasurable μ t ∩ s) = μ (t ∩ s)`.
This only holds when `μ` is s-finite -- for example for σ-finite measures. For a version without
this assumption (but requiring that `t` has finite measure), see `measure_toMeasurable_inter`. -/
theorem measure_toMeasurable_inter_of_sFinite [SFinite μ] {s : Set α} (hs : MeasurableSet s)
    (t : Set α) : μ (toMeasurable μ t ∩ s) = μ (t ∩ s)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If twice the oriented angles between two triples of points are equal, one triple is affinely
independent if and only if the other is. -/
theorem affineIndependent_iff_of_two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ p₅ p₆ : P}
    (h : (2 : ℤ) • ∡ p₁ p₂ p₃ = (2 : ℤ) • ∡ p₄ p₅ p₆) :
    AffineIndependent ℝ ![p₁, p₂, p₃] ↔ AffineIndependent ℝ ![p₄, p₅, p₆]
-- Mathlib/Topology/NhdsSet.lean
@[simp]
theorem nhdsSet_univ : 𝓝ˢ (univ : Set X) = ⊤
-- Mathlib/Algebra/Order/Sub/WithTop.lean
@[simp] theorem sub_eq_top_iff {a b : WithTop α} : a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤
-- Mathlib/Order/Antichain.lean
theorem IsAntichain.least_iff (hs : IsAntichain (· ≤ ·) s) : IsLeast s a ↔ s = {a}
-- Mathlib/Order/CompleteLattice.lean
theorem biSup_const {ι : Sort _} {a : α} {s : Set ι} (hs : s.Nonempty) : ⨆ i ∈ s, a = a
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma setIntegral_stieltjesOfMeasurableRat [IsFiniteKernel κ] (hf : IsRatCondKernelCDF f κ ν)
    (a : α) (x : ℝ) {s : Set β} (hs : MeasurableSet s) :
    ∫ b in s, stieltjesOfMeasurableRat f hf.measurable (a, b) x ∂(ν a)
      = (κ a (s ×ˢ Iic x)).toReal
-- Mathlib/Data/DFinsupp/Basic.lean
theorem support_smul {γ : Type w} [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)]
    [∀ (i : ι) (x : β i), Decidable (x ≠ 0)] (b : γ) (v : Π₀ i, β i) :
    (b • v).support ⊆ v.support
-- Mathlib/Data/Sym/Basic.lean
theorem coe_cons (s : Sym α n) (a : α) : (a ::ₛ s : Multiset α) = a ::ₘ s
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem univ_pi_Ioc_ae_eq_Icc {f g : ∀ i, α i} :
    (pi univ fun i => Ioc (f i) (g i)) =ᵐ[Measure.pi μ] Icc f g
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem sdiff_adj (x y : SimpleGraph V) (v w : V) : (x \ y).Adj v w ↔ x.Adj v w ∧ ¬y.Adj v w
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.clm_apply {f : E → F →L[𝕜] G} {g : E → F} {n : ℕ∞} (hf : ContDiff 𝕜 n f)
    (hg : ContDiff 𝕜 n g) : ContDiff 𝕜 n fun x => (f x) (g x)
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- A σ-compact set `s` is Lindelöf-/
theorem IsSigmaCompact.isLindelof (hs : IsSigmaCompact s) :
    IsLindelof s
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- On an open set, `f : ℂ → E` is analytic iff it is differentiable -/
theorem analyticOn_iff_differentiableOn {f : ℂ → E} {s : Set ℂ} (o : IsOpen s) :
    AnalyticOn ℂ f s ↔ DifferentiableOn ℂ f s
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem lt_add_of_tsub_lt_left (h : a - b < c) : a < b + c
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem mem_Lp_iff_eLpNorm_lt_top {f : α →ₘ[μ] E} : f ∈ Lp E p μ ↔ eLpNorm f p μ < ∞
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finSumFinEquiv_apply_right (i : Fin n) :
    (finSumFinEquiv (Sum.inr i) : Fin (m + n)) = Fin.natAdd m i
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem le_or_eq_of_le_add_one {m n : Nat} (h : m ≤ n + 1) : m ≤ n ∨ m = n + 1
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[instance]
theorem punctured_nhds_neBot (x : α) : NeBot (𝓝[≠] x)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem compLinearMap_apply (g : MultilinearMap R M₁' M₂) (f : ∀ i, M₁ i →ₗ[R] M₁' i)
    (m : ∀ i, M₁ i) : g.compLinearMap f m = g fun i => f i (m i)
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem coeff_eq_zero : p.coeff n = 0 ↔ p n = 0
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] protected theorem div_neg : ∀ a b : Int, a.div (-b) = -(a.div b)
-- Mathlib/NumberTheory/FLT/Four.lean
theorem not_minimal {a b c : ℤ} (h : Minimal a b c) (ha2 : a % 2 = 1) (hc : 0 < c) : False
-- Mathlib/Algebra/Group/Invertible/Defs.lean
@[simp]
theorem invOf_inj [Monoid α] {a b : α} [Invertible a] [Invertible b] : ⅟ a = ⅟ b ↔ a = b
-- Mathlib/Analysis/RCLike/Basic.lean
theorem ofReal_injective : Function.Injective ((↑) : ℝ → K)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffWithinAt.continuousWithinAt (hf : ContMDiffWithinAt I I' n f s x) :
    ContinuousWithinAt f s x
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem intervalIntegrable_one_div (h : ∀ x : ℝ, x ∈ [[a, b]] → f x ≠ 0)
    (hf : ContinuousOn f [[a, b]]) : IntervalIntegrable (fun x => 1 / f x) μ a b
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem bot_lt_of_maximal (M : Ideal R) [hm : M.IsMaximal] (non_field : ¬IsField R) : ⊥ < M
-- Mathlib/Data/List/Sort.lean
theorem sublist_of_subperm_of_sorted [IsAntisymm α r] {l₁ l₂ : List α} (hp : l₁ <+~ l₂)
    (hs₁ : l₁.Sorted r) (hs₂ : l₂.Sorted r) : l₁ <+ l₂
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem ushiftRight_eq (x : BitVec w) (n : Nat)   : BitVec.ushiftRight x n = x >>> n
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_constVSub (p : P) : ⇑(constVSub 𝕜 p) = (p -ᵥ ·)
-- Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean
/-- The projection from a trivial fiber bundle to its base is continuous. -/
protected theorem continuous_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
    Continuous proj
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
lemma isCoprime_row (A : SL(2, R)) (i : Fin 2) : IsCoprime (A i 0) (A i 1)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem hasFiniteIntegral_iff_ofReal {f : α → ℝ} (h : 0 ≤ᵐ[μ] f) :
    HasFiniteIntegral f μ ↔ (∫⁻ a, ENNReal.ofReal (f a) ∂μ) < ∞
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_X_pow_le (n : ℕ) : degree (X ^ n : R[X]) ≤ n
-- Mathlib/CategoryTheory/Triangulated/TriangleShift.lean
@[simp]
lemma shiftFunctor_eq (n : ℤ) :
    CategoryTheory.shiftFunctor (Triangle C) n = Triangle.shiftFunctor C n
-- Mathlib/Algebra/Divisibility/Basic.lean
lemma dvd_pow (hab : a ∣ b) : ∀ {n : ℕ} (_ : n ≠ 0), a ∣ b ^ n
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem nonempty_encodable : Nonempty (Encodable α) ↔ Countable α
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp, norm_cast]
theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem factors_span_eq {p : K[X]} : factors (span {p}) = (factors p).map (fun q ↦ span {q})
-- Mathlib/Data/NNReal/Basic.lean
theorem finset_sup_div {α} {f : α → ℝ≥0} {s : Finset α} (r : ℝ≥0) :
    s.sup f / r = s.sup fun a => f a / r
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem intCast_num (a : Int) : (a : Rat).num = a
-- Mathlib/CategoryTheory/Limits/Filtered.lean
/-- `C` is cofiltered if and only if for every functor `F : J ⥤ C` from a finite category there is
    some `X : C` such that `lim Hom(X, F·)` is nonempty. -/
theorem IsCofiltered.iff_nonempty_limit : IsCofiltered C ↔
    ∀ {J : Type v} [SmallCategory J] [FinCategory J] (F : J ⥤ C),
      ∃ (X : C), Nonempty (limit (F ⋙ coyoneda.obj (op X)))
-- Mathlib/Data/Matroid/Closure.lean
lemma Indep.basis_closure (hI : M.Indep I) : M.Basis I (M.closure I)
-- Mathlib/LinearAlgebra/Determinant.lean
/-- If `M'` is a two-sided inverse for `M` (indexed differently), `det (M * N * M') = det N`.

See `Matrix.det_conj` and `Matrix.det_conj'` for the case when `M' = M⁻¹` or vice versa. -/
theorem det_conj_of_mul_eq_one [DecidableEq m] [DecidableEq n] {M : Matrix m n A}
    {M' : Matrix n m A} {N : Matrix n n A} (hMM' : M * M' = 1) (hM'M : M' * M = 1) :
    det (M * N * M') = det N
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem eventuallyEq_one_of_mem_ball (h : x ∈ ball c f.rIn) : f =ᶠ[𝓝 x] 1
-- Mathlib/Data/Multiset/Fintype.lean
theorem Multiset.mem_of_mem_toEnumFinset {p : α × ℕ} (h : p ∈ m.toEnumFinset) : p.1 ∈ m
-- Mathlib/Analysis/MeanInequalitiesPow.lean
/-- Weighted generalized mean inequality, version for sums over finite sets, with `ℝ≥0`-valued
functions and real exponents. -/
theorem arith_mean_le_rpow_mean (w z : ι → ℝ≥0) (hw' : ∑ i ∈ s, w i = 1) {p : ℝ} (hp : 1 ≤ p) :
    ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p)
-- Mathlib/RingTheory/Ideal/Operations.lean
lemma span_smul_eq
    (s : Set R) (N : Submodule R M) :
    Ideal.span s • N = s • N
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast] lemma coe_divNat (n d : ℕ) : (divNat n d : ℚ) = .divInt n d
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem coeComplex_mul (z w : ℂ) : ↑(z * w) = (z * w : ℍ)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem meas_eLpNormEssSup_lt {f : α → F} : μ { y | eLpNormEssSup f μ < ‖f y‖₊ } = 0
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_eq_of_subset_of_ae_diff_eq_zero_aux (hts : s ⊆ t)
    (h't : ∀ᵐ x ∂μ, x ∈ t \ s → f x = 0) (haux : StronglyMeasurable f)
    (h'aux : IntegrableOn f t μ) : ∫ x in t, f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem midpoint_sub_add (x y : V) : midpoint R (x - y) (x + y) = x
-- Mathlib/LinearAlgebra/DFinsupp.lean
@[simp]
theorem mapRange.linearEquiv_symm (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
    (mapRange.linearEquiv e).symm = mapRange.linearEquiv fun i => (e i).symm
-- Mathlib/Data/ZMod/Basic.lean
lemma val_one'' : ∀ {n}, n ≠ 1 → (1 : ZMod n).val = 1
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_antilipschitzWith_equiv [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    AntilipschitzWith ((2 : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (α × β))
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[simp]
lemma homologyMap_neg : homologyMap (-φ) i = -homologyMap φ i
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma coe_basis : (CoordinateRing.basis W : Fin 2 → W.CoordinateRing) = ![1, mk W Y]
-- Mathlib/Topology/GDelta.lean
/-- The union of finitely many Gδ sets is a Gδ set, `Set.sUnion` version. -/
theorem IsGδ.sUnion {S : Set (Set X)} (hS : S.Finite) (h : ∀ s ∈ S, IsGδ s) : IsGδ (⋃₀ S)
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
@[simp]
theorem iUnion_left_iff [Countable ι] {s : ι → Set α} :
    AEDisjoint μ (⋃ i, s i) t ↔ ∀ i, AEDisjoint μ (s i) t
-- Mathlib/Probability/Martingale/Basic.lean
theorem smul_nonneg {f : ι → Ω → F} {c : ℝ} (hc : 0 ≤ c) (hf : Supermartingale f ℱ μ) :
    Supermartingale (c • f) ℱ μ
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem coeFn_negPart (f : Lp ℝ p μ) : ∀ᵐ a ∂μ, negPart f a = -min (f a) 0
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem lcm_eq_nat_lcm (m n : ℕ) : lcm m n = Nat.lcm m n
-- Mathlib/Data/Sym/Sym2.lean
theorem toRel_symmetric (s : Set (Sym2 α)) : Symmetric (ToRel s)