ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Convolution.lean
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that the integrand has compact support and `g` is bounded on this support (note that
both properties hold if `g` is continuous with compact support). We also require that `f` is
integrable on the support of the integrand, and that both functions are strongly measurable.

This is a variant of `BddAbove.convolutionExistsAt'` in an abelian group with a left-invariant
measure. This allows us to state the boundedness and measurability of `g` in a more natural way. -/
theorem _root_.BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SFinite μ] {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => x₀ - t) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g μ) : ConvolutionExistsAt f g x₀ L μ
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- (Pseudo) metric space has discrete `UniformSpace` structure
iff the distances between distinct points are uniformly bounded away from zero. -/
protected lemma uniformSpace_eq_bot :
    ‹PseudoMetricSpace α›.toUniformSpace = ⊥ ↔
      ∃ r : ℝ, 0 < r ∧ Pairwise (r ≤ dist · · : α → α → Prop)
-- Mathlib/Topology/Algebra/Order/Field.lean
theorem tendsto_const_mul_pow_nhds_iff {n : ℕ} {c d : 𝕜} (hc : c ≠ 0) :
    Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d
-- Mathlib/Data/Set/Finite.lean
theorem Finite.exists_maximal_wrt [PartialOrder β] (f : α → β) (s : Set α) (h : s.Finite)
    (hs : s.Nonempty) : ∃ a ∈ s, ∀ a' ∈ s, f a ≤ f a' → f a = f a'
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem prime_of_factor {a : α} (x : α) (hx : x ∈ factors a) : Prime x
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
theorem smul_oreDiv_one (r : R) (x : X) : r • (x /ₒ (1 : S)) = (r • x) /ₒ (1 : S)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@[simp]
theorem adjugate_fin_two_of (a b c d : α) : adjugate !![a, b; c, d] = !![d, -b; -c, a]
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
@[simp]
theorem zero_apply {V W : SemiNormedGrp₁} (x : V) : (0 : V ⟶ W) x = 0
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem frontier_setOf_le_re_and_im_le (a b : ℝ) :
    frontier { z | a ≤ re z ∧ im z ≤ b } = { z | a ≤ re z ∧ im z = b ∨ re z = a ∧ im z ≤ b }
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem AffineEquiv.map_midpoint (f : P ≃ᵃ[R] P') (a b : P) :
    f (midpoint R a b) = midpoint R (f a) (f b)
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_countable {s : Set X} (hs : s.Countable) : dimH s = 0
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- We can pull out a product over a list in the second argument of the Jacobi symbol. -/
theorem list_prod_right {a : ℤ} {l : List ℕ} (hl : ∀ n ∈ l, n ≠ 0) :
    J(a | l.prod) = (l.map fun n => J(a | n)).prod
-- Mathlib/Data/Set/Subsingleton.lean
/-- A type with a set `s` whose `coe_sort` is a nontrivial type is nontrivial.
For the corresponding result for `Subtype`, see `Subtype.nontrivial_iff_exists_ne`. -/
theorem nontrivial_of_nontrivial_coe (hs : Nontrivial s) : Nontrivial α
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem bounded' (f : CauSeq β abv) (x : α) : ∃ r > x, ∀ i, abv (f i) < r
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma preΨ'_three : W.preΨ' 3 = W.Ψ₃
-- Mathlib/MeasureTheory/Function/UnifTight.lean
/-- A single function is tight. -/
theorem unifTight_of_subsingleton [Subsingleton ι] (hp_top : p ≠ ∞)
    {f : ι → α → β} (hf : ∀ i, Memℒp (f i) p μ) : UnifTight f p μ
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem coeff_toSubring' {n : ℕ} : (coeff (toSubring p T hp) n).1 = coeff p n
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
protected theorem eq {p p' : α × α} : Sym2.mk p = Sym2.mk p' ↔ Sym2.Rel α p p'
-- Mathlib/Order/MinMax.lean
theorem min_le_max : min a b ≤ max a b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated (since := "2024-06-12")]
theorem get_of_append_proof {l : List α}
    (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n) : n < length l
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.IsHomogeneous.iff_eq : I.IsHomogeneous 𝒜 ↔ (I.homogeneousCore 𝒜).toIdeal = I
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem toQuadraticMap_neg (B : BilinMap R M N) : (-B).toQuadraticMap = -B.toQuadraticMap
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem accept_zero : (0 : εNFA α σ).accept = ∅
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp] theorem toZeroAtInfty_apply (f : 𝓢(E, F)) (x : E) : f.toZeroAtInfty x = f x
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem zero_mem_ℓp' : Memℓp (fun i : α => (0 : E i)) p
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem eval_at_1 (n ν : ℕ) : (bernsteinPolynomial R n ν).eval 1 = if ν = n then 1 else 0
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp]
lemma rightHomologyMap_id [HasRightHomology S] :
    rightHomologyMap (𝟙 S) = 𝟙 _
-- Mathlib/Data/Nat/Defs.lean
protected lemma lt_sub_iff_add_lt : a < c - b ↔ a + b < c
-- Mathlib/Data/Set/Defs.lean
@[simp, mfld_simps]
theorem mem_prod : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem zero_or_succ_or_limit (o : Ordinal) : o = 0 ∨ (∃ a, o = succ a) ∨ IsLimit o
-- Mathlib/Data/Multiset/Basic.lean
lemma add_eq_union_right_of_le [DecidableEq α] {x y z : Multiset α} (h : z ≤ y) :
    x + y = x ∪ z ↔ y = z ∧ x.Disjoint y
-- Mathlib/Analysis/MeanInequalities.lean
private theorem inner_le_Lp_mul_Lp_of_norm_eq_zero (f g : ι → ℝ≥0) {p q : ℝ}
    (hpq : p.IsConjExponent q) (hf : ∑ i ∈ s, f i ^ p = 0) :
    ∑ i ∈ s, f i * g i ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) * (∑ i ∈ s, g i ^ q) ^ (1 / q)
-- Mathlib/Data/SetLike/Basic.lean
@[mono]
theorem coe_mono : Monotone (SetLike.coe : A → Set B)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem hasDerivWithinAt_inter (h : t ∈ 𝓝 x) :
    HasDerivWithinAt f f' (s ∩ t) x ↔ HasDerivWithinAt f f' s x
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_eq (p : MvPolynomial σ R) :
    p.totalDegree = p.support.sup fun m => Multiset.card (toMultiset m)
-- Mathlib/CategoryTheory/Dialectica/Monoidal.lean
theorem braiding_naturality_right (X : Dial C) {Y Z : Dial C} (f : Y ⟶ Z) :
    tensorHom (𝟙 X) f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ tensorHom f (𝟙 X)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
/-- An isomorphism of graphs induces a bijection of connected components. -/
@[simps]
def connectedComponentEquiv (φ : G ≃g G') : G.ConnectedComponent ≃ G'.ConnectedComponent
-- Mathlib/Dynamics/PeriodicPts.lean
theorem periodicOrbit_chain (r : α → α → Prop) {f : α → α} {x : α} :
    (periodicOrbit f x).Chain r ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem mem_offDiag : x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2
-- Mathlib/Topology/Basic.lean
theorem isClosed_iInter {f : ι → Set X} (h : ∀ i, IsClosed (f i)) : IsClosed (⋂ i, f i)
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem ιMulti_succ_apply {n : ℕ} (v : Fin n.succ → M) :
    ιMulti R _ v = ι R (v 0) * ιMulti R _ (Matrix.vecTail v)
-- Mathlib/Order/SupClosed.lean
@[simp] lemma supClosure_singleton : supClosure {a} = {a}
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp]
theorem star_def : (Star.star : K → K) = conj
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- If `f` belongs to `Lp` for the measure `μ.trim hm`, then it belongs to the subgroup
`lpMeasSubgroup F m p μ`. -/
theorem mem_lpMeasSubgroup_toLp_of_trim (hm : m ≤ m0) (f : Lp F p (μ.trim hm)) :
    (memℒp_of_memℒp_trim hm (Lp.memℒp f)).toLp f ∈ lpMeasSubgroup F m p μ
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_eq_single (f : α → M) (a : α) (ha : ∀ x, x ≠ a → f x = 1) :
    ∏ᶠ x, f x = f a
-- Mathlib/Data/Finset/NAry.lean
theorem card_image₂_iff :
    (image₂ f s t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × β)).InjOn fun x => f x.1 x.2
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem prod_self_lt_prod_self : s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma unop_rightUnitor (X : Cᵒᵖ) : (ρ_ X).unop = (ρ_ (unop X)).symm
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem sqrtd_im : (sqrtd : ℤ√d).im = 1
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_multiset_prod (s : Multiset (MvPolynomial σ R)) :
    s.prod.totalDegree ≤ (s.map MvPolynomial.totalDegree).sum
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[simp]
theorem toLocallyRingedSpaceHom_val : (toLocallyRingedSpaceHom Y f).val = f
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.lintegral_tendsto_of_countably_generated [l.IsCountablyGenerated] {φ : ι → Set α}
    (hφ : AECover μ l φ) {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ) :
    Tendsto (fun i => ∫⁻ x in φ i, f x ∂μ) l (𝓝 <| ∫⁻ x, f x ∂μ)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
lemma LinearIndependent.eq_zero_of_pair' {x y : M} (h : LinearIndependent R ![x, y])
    {s t : R} (h' : s • x = t • y) : s = 0 ∧ t = 0
-- Mathlib/Data/Finmap.lean
@[simp]
theorem empty_union {s₁ : Finmap β} : ∅ ∪ s₁ = s₁
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
@[simp]
lemma symm_add : φ.symm.add = φ.add
-- Mathlib/Data/ENNReal/Operations.lean
/-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_coe {a : ℝ≥0} : AddLECancellable (a : ℝ≥0∞)
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[mono]
theorem toSubMulAction_mono : Monotone (toSubMulAction : Submodule R M → SubMulAction R M)
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
protected theorem All.balRight
    (hl : l.All p) (hv : p v) (hr : r.All p) : (balRight l v r).All p
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_pos : 0 < ⌈a⌉₊ ↔ 0 < a
-- Mathlib/Topology/Sheaves/Skyscraper.lean
theorem SkyscraperPresheafFunctor.map'_comp {a b c : C} (f : a ⟶ b) (g : b ⟶ c) :
    SkyscraperPresheafFunctor.map' p₀ (f ≫ g) =
      SkyscraperPresheafFunctor.map' p₀ f ≫ SkyscraperPresheafFunctor.map' p₀ g
-- Mathlib/Algebra/Order/Module/Defs.lean
/-- A constructor for `SMulPosMono` requiring you to prove `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` only when
`0 < b`-/
lemma SMulPosMono.of_pos (h₀ : ∀ b : β, 0 < b → ∀ a₁ a₂ : α, a₁ ≤ a₂ → a₁ • b ≤ a₂ • b) :
    SMulPosMono α β
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem cos_sq : cos x ^ 2 = 1 / 2 + cos (2 * x) / 2
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem coe_basisOfOrthonormalOfCardEqFinrank [Fintype ι] [Nonempty ι] {v : ι → E}
    (hv : Orthonormal 𝕜 v) (card_eq : Fintype.card ι = finrank 𝕜 E) :
    (basisOfOrthonormalOfCardEqFinrank hv card_eq : ι → E) = v
-- Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean
/-- A prime natural number is prime in `ℤ[i]` if and only if it is `3` mod `4` -/
theorem prime_iff_mod_four_eq_three_of_nat_prime (p : ℕ) [Fact p.Prime] :
    Prime (p : ℤ[i]) ↔ p % 4 = 3
-- Mathlib/Data/Finset/Union.lean
lemma biUnion_mono (h : ∀ a ∈ s, t₁ a ⊆ t₂ a) : s.biUnion t₁ ⊆ s.biUnion t₂
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_lt_iff_coeff_zero (f : R[X]) (n : ℕ) :
    degree f < n ↔ ∀ m : ℕ, n ≤ m → coeff f m = 0
-- Mathlib/Deprecated/Group.lean
/-- The inverse of a group homomorphism is a group homomorphism if the target is commutative. -/
@[to_additive
      "The negation of an additive group homomorphism is an additive group homomorphism
      if the target is commutative."]
theorem inv {α β} [Group α] [CommGroup β] {f : α → β} (hf : IsGroupHom f) :
    IsGroupHom fun a => (f a)⁻¹
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_sInf (S : Set (Subfield K)) : ((sInf S : Subfield K) : Set K) = ⋂ s ∈ S, ↑s
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- A bounded convergence theorem for a finite measure:
If a sequence of bounded continuous non-negative functions are uniformly bounded by a constant
and tend pointwise to a limit, then their integrals (`MeasureTheory.lintegral`) against the finite
measure tend to the integral of the limit.

A related result with more general assumptions is
`MeasureTheory.tendsto_lintegral_nn_filter_of_le_const`.
-/
theorem tendsto_lintegral_nn_of_le_const (μ : FiniteMeasure Ω) {fs : ℕ → Ω →ᵇ ℝ≥0} {c : ℝ≥0}
    (fs_le_const : ∀ n ω, fs n ω ≤ c) {f : Ω → ℝ≥0}
    (fs_lim : ∀ ω, Tendsto (fun n => fs n ω) atTop (𝓝 (f ω))) :
    Tendsto (fun n => ∫⁻ ω, fs n ω ∂(μ : Measure Ω)) atTop (𝓝 (∫⁻ ω, f ω ∂(μ : Measure Ω)))
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.not_coprime_iff_dvd {m n : ℕ} : ¬Coprime m n ↔ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
theorem hasColimit_of_comp_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimit (K ⋙ E)] :
    HasColimit K
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem map_contract {p : ℕ} (hp : p ≠ 0) {f : R →+* S} {q : R[X]} :
    (q.contract p).map f = (q.map f).contract p
-- Mathlib/Data/Stream/Init.lean
theorem tails_eq_iterate (s : Stream' α) : tails s = iterate tail (tail s)
-- Mathlib/FieldTheory/Normal.lean
/-- If a set of algebraic elements in a field extension `K/F` have minimal polynomials that
  split in another extension `L/F`, then all minimal polynomials in the intermediate field
  generated by the set also split in `L/F`. -/
theorem splits_of_mem_adjoin {L} [Field L] [Algebra F L] {S : Set K}
    (splits : ∀ x ∈ S, IsIntegral F x ∧ (minpoly F x).Splits (algebraMap F L)) {x : K}
    (hx : x ∈ adjoin F S) : (minpoly F x).Splits (algebraMap F L)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_map_zero_lt : f (g 0) < f 0 + g 0 + 1
-- Mathlib/FieldTheory/Adjoin.lean
/-- If `L / K` is a field extension, `S` is a finite subset of `L`, such that every element of `S`
is integral (= algebraic) over `K`, then `K(S) / K` is a finite extension.
A direct corollary of `finiteDimensional_iSup_of_finite`. -/
theorem finiteDimensional_adjoin {S : Set L} [Finite S] (hS : ∀ x ∈ S, IsIntegral K x) :
    FiniteDimensional K (adjoin K S)
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp) nsmul_bot]
theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥
-- Mathlib/Order/Lattice.lean
/-- Pointwise infimum of two monotone functions is a monotone function. -/
protected theorem inf [Preorder α] [SemilatticeInf β] {f g : α → β} {s : Set α}
    (hf : MonotoneOn f s) (hg : MonotoneOn g s) : MonotoneOn (f ⊓ g) s
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem card_add_two_mul_card_eq_rank :
    NrRealPlaces K + 2 * NrComplexPlaces K = finrank ℚ K
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGLB.of_image [Preorder α] [Preorder β] {f : α → β} (hf : ∀ {x y}, f x ≤ f y ↔ x ≤ y)
    {s : Set α} {x : α} (hx : IsGLB (f '' s) (f x)) : IsGLB s x
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem limitRecOn_succ {C} (o H₁ H₂ H₃) :
    @limitRecOn C (succ o) H₁ H₂ H₃ = H₂ o (@limitRecOn C o H₁ H₂ H₃)
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem Quiver.Hom.op_unop {X Y : Cᵒᵖ} (f : X ⟶ Y) : f.unop.op = f
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem dist_comm : G.dist u v = G.dist v u
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem transpose_row (v : m → α) : (Matrix.row ι v)ᵀ = Matrix.col ι v
-- Mathlib/CategoryTheory/Triangulated/Functor.lean
lemma isTriangulated_of_precomp_iso {H : C ⥤ E} (e : F ⋙ G ≅ H) [H.CommShift ℤ]
    [H.IsTriangulated] [F.IsTriangulated] [F.mapArrow.EssSurj] [NatTrans.CommShift e.hom ℤ] :
    G.IsTriangulated
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_pred_self (p : Fin (n + 1)) (hp : p ≠ 0) : (pred p hp).predAbove p = pred p hp
-- Mathlib/Data/Real/EReal.lean
theorem natCast_ne_iff {m n : ℕ} : (m : EReal) ≠ (n : EReal) ↔ m ≠ n
-- Mathlib/Order/Interval/Multiset.lean
theorem Ico_self : Ico a a = 0
-- Mathlib/CategoryTheory/Subobject/Limits.lean
theorem imageSubobject_arrow_comp_eq_zero [HasZeroMorphisms C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z}
    [HasImage f] [Epi (factorThruImageSubobject f)] (h : f ≫ g = 0) :
    (imageSubobject f).arrow ≫ g = 0
-- Mathlib/Algebra/Regular/Basic.lean
/-- If an element `b` becomes right-regular after multiplying it on the right by a right-regular
element, then `b` is right-regular. -/
@[to_additive "If an element `b` becomes add-right-regular after adding to it on the right
an add-right-regular element, then `b` is add-right-regular."]
theorem IsRightRegular.of_mul (ab : IsRightRegular (b * a)) : IsRightRegular b
-- Mathlib/Algebra/Order/Field/Power.lean
lemma zpow_two_pos_of_ne_zero (ha : a ≠ 0) : 0 < a ^ (2 : ℤ)
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem of_c_eq_zero' : toPoly ⟨0, 0, 0, d⟩ = C d
-- Mathlib/Analysis/Normed/MulAction.lean
theorem nndist_smul₀ (s : α) (x y : β) : nndist (s • x) (s • y) = ‖s‖₊ * nndist x y
-- Mathlib/Topology/Bornology/Basic.lean
theorem IsBounded.insert (h : IsBounded s) (x : α) : IsBounded (insert x s)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[deprecated getElem?_set_eq' (since := "2024-06-12")]
theorem get?_set_eq (a : α) (n) (l : List α) : (set l n a).get? n = (fun _ => a) <$> l.get? n
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
lemma mem_coe_supp_of_adj {v w : V} {H : Subgraph G} {c : ConnectedComponent H.coe}
    (hv : v ∈ (↑) '' (c : Set H.verts)) (hw : w ∈ H.verts)
    (hadj : H.Adj v w) : w ∈ (↑) '' (c : Set H.verts)
-- Mathlib/Data/PNat/Basic.lean
@[simp]
theorem natPred_add_one (n : ℕ+) : n.natPred + 1 = n
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_im (x : ℂ) : x.log.im = x.arg
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is continuous on a convex set `D ⊆ ℝ` and `f''` is strictly negative on `D`,
then `f` is strictly concave on `D`.
Note that we don't require twice differentiability explicitly as it is already implied by the second
derivative being strictly negative, except at at most one point. -/
theorem strictConcaveOn_of_deriv2_neg' {D : Set ℝ} (hD : Convex ℝ D) {f : ℝ → ℝ}
    (hf : ContinuousOn f D) (hf'' : ∀ x ∈ D, deriv^[2] f x < 0) : StrictConcaveOn ℝ D f
-- Mathlib/CategoryTheory/Limits/FunctorCategory.lean
@[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_hom_π [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j =
      (limit.π F j).app k
-- Mathlib/ModelTheory/Definability.lean
@[simp] lemma Definable.himp {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t) :
    A.Definable L (s ⇨ t)
-- Mathlib/Data/Option/Basic.lean
theorem elim_comp (h : α → β) {f : γ → α} {x : α} {i : Option γ} :
    (i.elim (h x) fun j => h (f j)) = h (i.elim x f)
-- Mathlib/Data/Real/ConjExponents.lean
theorem sub_one_ne_zero : p - 1 ≠ 0
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem hom.injective {x : Subgraph G} : Function.Injective x.hom
-- Mathlib/MeasureTheory/Integral/CircleTransform.lean
theorem continuousOn_abs_circleTransformBoundingFunction {R r : ℝ} (hr : r < R) (z : ℂ) :
    ContinuousOn (abs ∘ circleTransformBoundingFunction R z) (closedBall z r ×ˢ univ)
-- Mathlib/Order/Bounded.lean
theorem bounded_lt_inter_le [LinearOrder α] (a : α) :
    Bounded (· < ·) (s ∩ { b | a ≤ b }) ↔ Bounded (· < ·) s
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.mem_nhds_iff_symm {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, SymmetricRel V ∧ ball x V ⊆ s
-- Mathlib/Order/CompleteLattice.lean
theorem Monotone.map_iInf₂_le [CompleteLattice β] {f : α → β} (hf : Monotone f) (s : ∀ i, κ i → α) :
    f (⨅ (i) (j), s i j) ≤ ⨅ (i) (j), f (s i j)
-- Mathlib/Logic/Basic.lean
theorem ite_eq_or_eq : ite P a b = a ∨ ite P a b = b
-- Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
@[simp] theorem moduleCat_of_toModuleCat (X : QuadraticModuleCat.{v} R) :
    ModuleCat.of R X.toModuleCat = X.toModuleCat
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem rename_comp_bind₁ {υ : Type*} (f : σ → MvPolynomial τ R) (g : τ → υ) :
    (rename g).comp (bind₁ f) = bind₁ fun i => rename g <| f i
-- Mathlib/RingTheory/Noetherian.lean
theorem Finite.of_injective [IsNoetherian R N] (f : M →ₗ[R] N) (hf : Function.Injective f) :
    Finite R M
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp] lemma cons_tail_eq (p : G.Walk x y) (hp : ¬ p.Nil) :
    cons (p.adj_sndOfNotNil hp) (p.tail hp) = p
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem coeff_injective (h : IsAdjoinRootMonic S f) : Function.Injective h.coeff
-- Mathlib/Algebra/Ring/Commute.lean
/-- Representation of a difference of two squares of commuting elements as a product. -/
theorem mul_self_sub_mul_self_eq [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b) :
    a * a - b * b = (a + b) * (a - b)
-- Mathlib/Data/Stream/Init.lean
@[simp] theorem take_succ_cons {a : α} (n : ℕ) (s : Stream' α) :
    take (n+1) (a::s) = a :: take n s
-- Mathlib/Analysis/Convex/Between.lean
theorem wbtw_rotate_iff [NoZeroSMulDivisors R V] (x : P) {y z : P} :
    Wbtw R x y z ∧ Wbtw R z x y ↔ x = y
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem bliminf_or_eq_inf : (bliminf u f fun x => p x ∨ q x) = bliminf u f p ⊓ bliminf u f q
-- Mathlib/Topology/Bornology/Basic.lean
theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
    IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i)
-- Mathlib/RingTheory/MvPolynomial/Tower.lean
theorem aeval_map_algebraMap (x : σ → B) (p : MvPolynomial σ R) :
    aeval x (map (algebraMap R A) p) = aeval x p
-- Mathlib/Order/Height.lean
theorem length_le_chainHeight_of_mem_subchain (hl : l ∈ s.subchain) : ↑l.length ≤ s.chainHeight
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem dirac_apply (a : α) (s : Set α) : dirac a s = indicator s (fun _ => 1) a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_int_mul_two_pi_sub (x : ℂ) (n : ℤ) : cos (n * (2 * π) - x) = cos x
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem isRegular_aleph_one : IsRegular (aleph 1)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle multiplied by the adjacent side equals
the opposite side. -/
theorem tan_oangle_left_mul_dist_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P}
    (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) : Real.Angle.tan (∡ p₃ p₁ p₂) * dist p₁ p₂ = dist p₃ p₂
-- Mathlib/GroupTheory/Commutator.lean
theorem commutator_le_inf [Normal H₁] [Normal H₂] : ⁅H₁, H₂⁆ ≤ H₁ ⊓ H₂
-- Mathlib/Algebra/Lie/Nilpotent.lean
/-- Note that this result is not quite a special case of
`LieModule.isNilpotent_range_toEnd_iff` which concerns nilpotency of the
`(ad R L).range`-module `L`, whereas this result concerns nilpotency of the `(ad R L).range`-module
`(ad R L).range`. -/
@[simp]
theorem LieAlgebra.isNilpotent_range_ad_iff : IsNilpotent R (ad R L).range ↔ IsNilpotent R L
-- Mathlib/Geometry/Manifold/ContMDiffMap.lean
theorem coe_injective ⦃f g : C^n⟮I, M; I', M'⟯⦄ (h : (f : M → M') = g) : f = g
-- Mathlib/Algebra/Group/Semiconj/Defs.lean
/-- `a` semiconjugates `x` to `a * x * a⁻¹`. -/
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
theorem conj_mk (a x : G) : SemiconjBy a x (a * x * a⁻¹)
-- Mathlib/Data/Finset/Prod.lean
theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
lemma IsPerfectMatching.induce_connectedComponent_isMatching (h : M.IsPerfectMatching)
    (c : ConnectedComponent G) : (M.induce c.supp).IsMatching
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma primitiveCharacter_isPrimitive : IsPrimitive (χ.primitiveCharacter)
-- Mathlib/Algebra/Algebra/Unitization.lean
/-- See note [partially-applied ext lemmas] -/
@[ext 1100]
theorem algHom_ext' {φ ψ : Unitization R A →ₐ[R] C}
    (h :
      φ.toNonUnitalAlgHom.comp (inrNonUnitalAlgHom R A) =
        ψ.toNonUnitalAlgHom.comp (inrNonUnitalAlgHom R A)) :
    φ = ψ
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem subset_cons (a : α) (l : List α) : l ⊆ a :: l
-- Mathlib/Deprecated/Group.lean
/-- A group homomorphism sends 1 to 1. -/
@[to_additive "An additive group homomorphism sends 0 to 0."]
theorem map_one : f 1 = 1