ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Basic.lean
theorem mem_dite_empty_right (p : Prop) [Decidable p] (t : p → Set α) (x : α) :
    (x ∈ if h : p then t h else ∅) ↔ ∃ h : p, x ∈ t h
-- Mathlib/Data/Multiset/Dedup.lean
@[simp]
theorem dedup_zero : @dedup α _ 0 = 0
-- Mathlib/Order/KrullDimension.lean
lemma krullDim_eq_length_of_finiteDimensionalOrder [FiniteDimensionalOrder α] :
    krullDim α = (LTSeries.longestOf α).length
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem add_apply (m : ∀ i, M₁ i) : (f + f') m = f m + f' m
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive (attr := simp low, norm_cast)]
theorem coe_mul (x y : S') : (↑(x * y) : M) = ↑x * ↑y
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
/-- The canonical functor `(C ⥤ D) ⥤ (Karoubi C ⥤ Karoubi D)` -/
@[simps!]
def functorExtension₂ : (C ⥤ D) ⥤ Karoubi C ⥤ Karoubi D
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- Commutativity of actions is a symmetric relation. This lemma can't be an instance because this
would cause a loop in the instance search graph. -/
@[to_additive]
lemma SMulCommClass.symm (M N α : Type*) [SMul M α] [SMul N α] [SMulCommClass M N α] :
    SMulCommClass N M α
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[ext]
lemma hom_ext₅ {f g : ComposableArrows C 5} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
    (h₃ : app' φ 3 = app' φ' 3) (h₄ : app' φ 4 = app' φ' 4) (h₅ : app' φ 5 = app' φ' 5) :
    φ = φ'
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma AnalyticAt.meromorphicAt {f : 𝕜 → E} {x : 𝕜} (hf : AnalyticAt 𝕜 f x) :
    MeromorphicAt f x
-- Mathlib/Data/List/Lattice.lean
theorem mem_inter_of_mem_of_mem (h₁ : a ∈ l₁) (h₂ : a ∈ l₂) : a ∈ l₁ ∩ l₂
-- Mathlib/GroupTheory/CoprodI.lean
theorem of_apply {i} (m : M i) : of m = Con.mk' _ (FreeMonoid.of <| Sigma.mk i m)
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
theorem sum_right {α} (t : Finset α) (w : M) (g : α → M) :
    B w (∑ i ∈ t, g i) = ∑ i ∈ t, B w (g i)
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem MonotoneOn.Ioo (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
    AntitoneOn (fun x => Ioo (f x) (g x)) s
-- Mathlib/CategoryTheory/Limits/Constructions/BinaryProducts.lean
/-- Any category with pullbacks and terminal object has binary products. -/
theorem hasBinaryProducts_of_hasTerminal_and_pullbacks [HasTerminal C] [HasPullbacks C] :
    HasBinaryProducts C
-- Mathlib/RepresentationTheory/Basic.lean
@[simp]
theorem dual_apply (g : G) : (dual ρV) g = Module.Dual.transpose (R := k) (ρV g⁻¹)
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem uniformInducing_toContinuousMap : UniformInducing (@toContinuousMap _ _ _ v)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Icc_of_gt (hb : b < c) : c ∉ Icc a b
-- Mathlib/Data/Set/Pointwise/ListOfFn.lean
@[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.gcd_both (k l : Nat) (hmn : Coprime m n) : Coprime (gcd k m) (gcd l n)
-- Mathlib/GroupTheory/Schreier.lean
@[to_additive]
theorem card_dvd_exponent_pow_rank : Nat.card G ∣ Monoid.exponent G ^ Group.rank G
-- Mathlib/Analysis/Calculus/Deriv/Pow.lean
theorem derivWithin_pow' (hc : DifferentiableWithinAt 𝕜 c s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => c x ^ n) s x = (n : 𝕜) * c x ^ (n - 1) * derivWithin c s x
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem not_sqLe_succ (c d y) (h : 0 < c) : ¬SqLe (y + 1) c 0 d
-- Mathlib/Order/SupIndep.lean
theorem SupIndep.image [DecidableEq ι] {s : Finset ι'} {g : ι' → ι} (hs : s.SupIndep (f ∘ g)) :
    (s.image g).SupIndep f
-- Mathlib/RingTheory/WittVector/Compare.lean
/-- The following diagram commutes:
```text
          zmod (p^n) ----------------------------> zmod (p^m)
            |                                        |
            |                                        |
            v                                        v
TruncatedWittVector p n (zmod p) ----> TruncatedWittVector p m (zmod p)
```
Here the vertical arrows are `TruncatedWittVector.zmodEquivTrunc`,
the horizontal arrow at the top is `ZMod.castHom`,
and the horizontal arrow at the bottom is `TruncatedWittVector.truncate`.
-/
theorem commutes {m : ℕ} (hm : n ≤ m) :
    (truncate hm).comp (zmodEquivTrunc p m).toRingHom =
      (zmodEquivTrunc p n).toRingHom.comp (ZMod.castHom (pow_dvd_pow p hm) _)
-- Mathlib/Data/Set/Basic.lean
theorem subset_symmDiff_union_symmDiff_right (h : Disjoint t u) : s ⊆ s ∆ t ∪ s ∆ u
-- Mathlib/Data/Option/NAry.lean
theorem map₂_map_right (f : α → γ → δ) (g : β → γ) :
    map₂ f a (b.map g) = map₂ (fun a b => f a (g b)) a b
-- Mathlib/Algebra/Associated/Basic.lean
theorem irreducible_mul_iff {a b : α} :
    Irreducible (a * b) ↔ Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bodd_zero : bodd 0 = false
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem Measurable.iSup_Prop {α} [MeasurableSpace α] [ConditionallyCompleteLattice α]
    (p : Prop) {f : δ → α} (hf : Measurable f) : Measurable fun b => ⨆ _ : p, f b
-- Mathlib/Algebra/Polynomial/Div.lean
theorem X_sub_C_dvd_sub_C_eval : X - C a ∣ p - C (p.eval a)
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive (attr := simp)] theorem MonoidHom.id_commGrp_comp
    {G : Type u} [CommGroup G] {H : CommGrp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_mul_apply_aux [Mul G] (f : MonoidAlgebra k G) {r : k} {x y z : G}
    (H : ∀ a, x * a = y ↔ a = z) : (single x r * f) y = r * f z
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_apply_eq_zero {f : α → ℝ≥0∞} {s : Set α} (hf : Measurable f) :
    μ.withDensity f s = 0 ↔ μ ({ x | f x ≠ 0 } ∩ s) = 0
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem tendsto_nhds_left {f : Filter β} {u : β → α} {a : α} :
    Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem flip' (n ν : ℕ) (h : ν ≤ n) :
    bernsteinPolynomial R n ν = (bernsteinPolynomial R n (n - ν)).comp (1 - X)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν
-- Mathlib/FieldTheory/Perfect.lean
lemma PerfectRing.toPerfectField (K : Type*) (p : ℕ)
    [Field K] [ExpChar K p] [PerfectRing K p] : PerfectField K
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Ici : IsPiSystem (range Ici : Set (Set α))
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem mem_roots_sub_C {p : R[X]} {a x : R} (hp0 : 0 < degree p) :
    x ∈ (p - C a).roots ↔ p.eval x = a
-- Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
/-- Any locally constant function from a cofiltered limit of profinite sets factors through
one of the components. -/
theorem exists_locallyConstant {α : Type*} (hC : IsLimit C) (f : LocallyConstant C.pt α) :
    ∃ (j : J) (g : LocallyConstant (F.obj j) α), f = g.comap (C.π.app _)
-- Mathlib/Analysis/Normed/Lp/LpEquiv.lean
/-- When `α` is `Finite`, every `f : PreLp E p` satisfies `Memℓp f p`. -/
theorem Memℓp.all (f : ∀ i, E i) : Memℓp f p
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive (attr := simp)]
theorem coe_equivMapOfInjective_apply (f : M →ₙ* N) (hf : Function.Injective f) (x : S) :
    (equivMapOfInjective S f hf x : N) = f x
-- Mathlib/Data/Set/Image.lean
theorem preimage_coe_eq_empty {s t : Set α} : ((↑) : s → α) ⁻¹' t = ∅ ↔ s ∩ t = ∅
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- The evaluation map on automorphisms is injective for connected objects. -/
lemma evaluation_aut_injective_of_isConnected (A : C) [IsConnected A] (a : F.obj A) :
    Function.Injective (fun f : Aut A ↦ F.map (f.hom) a)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
@[continuity]
theorem continuous_transReflReparamAux : Continuous transReflReparamAux
-- Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
@[simp] theorem coe_toMeasureEquiv : (f.toMeasureEquiv : E → F) = f
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem isSubordinate_biUnionTagged [Fintype ι] {π : Prepartition I}
    {πi : ∀ J, TaggedPrepartition J} :
    IsSubordinate (π.biUnionTagged πi) r ↔ ∀ J ∈ π, (πi J).IsSubordinate r
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The kernel of `biprod.snd : X ⊞ Y ⟶ Y` is `X`. -/
@[simps!]
def kernelBiprodSndIso : kernel (biprod.snd : X ⊞ Y ⟶ Y) ≅ X
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma ofNat_lt_ofReal {n : ℕ} [n.AtLeastTwo] {r : ℝ} :
    no_index (OfNat.ofNat n) < ENNReal.ofReal r ↔ OfNat.ofNat n < r
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.left_le_of_le_inf_left (h : b ⊓ a ≤ c) (hd : Codisjoint b c) : a ≤ c
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
/-- Extending the domain of Hahn series is a ring homomorphism. -/
@[simps]
def embDomainRingHom [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ R →+* HahnSeries Γ' R
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_injective : Function.Injective <| map W f
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem coe_homothetyHom (c : P1) : ⇑(homothetyHom c : k →* _) = homothety c
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem eq_comp_toLinearMap_symm (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₃] M₃) :
    f = g.comp e₁₂.symm.toLinearMap ↔ f.comp e₁₂.toLinearMap = g
-- Mathlib/Data/Set/Basic.lean
@[simp] lemma left_eq_inter : s = s ∩ t ↔ s ⊆ t
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
lemma realContinuousMapOfNNReal_injective :
    Function.Injective (realContinuousMapOfNNReal (X := X) (A := A))
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem mapRange_smul (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) (r : R)
    (hf' : ∀ i x, f i (r • x) = r • f i x) (g : Π₀ i, β₁ i) :
    mapRange f hf (r • g) = r • mapRange f hf g
-- Mathlib/Data/List/GetD.lean
theorem getD_map {n : ℕ} (f : α → β) : (map f l).getD n (f d) = f (l.getD n d)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem le_on_closure [TopologicalSpace β] {f g : β → α} {s : Set β} (h : ∀ x ∈ s, f x ≤ g x)
    (hf : ContinuousOn f (closure s)) (hg : ContinuousOn g (closure s)) ⦃x⦄ (hx : x ∈ closure s) :
    f x ≤ g x
-- Mathlib/Tactic/CategoryTheory/Elementwise.lean
theorem forget_hom_Type (α β : Type u) (f : α ⟶ β) : DFunLike.coe f = f
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_set_mk {s : Set M} (h_mul) : (mk s h_mul : Set M) = s
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
theorem norm_of_cyclotomic_irreducible [IsDomain L] [IsCyclotomicExtension {n} K L]
    (hirr : Irreducible (cyclotomic n K)) : norm K ζ = ite (n = 2) (-1) 1
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_subset_comp {g : M → N} (hg : ∀ {x}, g x = 1 → x = 1) (f : α → M) :
    mulSupport f ⊆ mulSupport (g ∘ f)
-- Mathlib/Topology/Gluing.lean
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i)))
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean
@[simp]
lemma map_ι : (c.map G).ι = G.map c.ι
-- Mathlib/Computability/EpsilonNFA.lean
theorem pumping_lemma [Fintype σ] {x : List α} (hx : x ∈ M.accepts)
    (hlen : Fintype.card (Set σ) ≤ List.length x) :
    ∃ a b c, x = a ++ b ++ c ∧
      a.length + b.length ≤ Fintype.card (Set σ) ∧ b ≠ [] ∧ {a} * {b}∗ * {c} ≤ M.accepts
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
protected lemma IsOfFinOrder.orderOf_pos (h : IsOfFinOrder x) : 0 < orderOf x
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem not_disjoint_coe_iff_nonempty_inter :
    ¬Disjoint (I : WithBot (Box ι)) J ↔ (I ∩ J : Set (ι → ℝ)).Nonempty
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem isSuccLimit_aleph0 : IsSuccLimit ℵ₀
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem compFormalMultilinearSeries_apply' (f : F →L[𝕜] G) (p : FormalMultilinearSeries 𝕜 E F)
    (n : ℕ) (v : Fin n → E) : (f.compFormalMultilinearSeries p) n v = f (p n v)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iic_diff_right : Iic a \ {a} = Iio a
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem mem_inv_pointwise_smul_iff {a : α} {S : AddSubgroup A} {x : A} : x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/CategoryTheory/Monad/Coequalizer.lean
theorem FreeCoequalizer.condition :
    FreeCoequalizer.topMap X ≫ FreeCoequalizer.π X =
      FreeCoequalizer.bottomMap X ≫ FreeCoequalizer.π X
-- Mathlib/RingTheory/Jacobson.lean
theorem IsJacobson.out {R} [CommRing R] :
    IsJacobson R → ∀ {I : Ideal R}, I.IsRadical → I.jacobson = I
-- Mathlib/Order/Antichain.lean
protected theorem isAntichain [IsRefl α r] (h : IsStrongAntichain r s) : IsAntichain r s
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma cube_of_castHom_ne_zero {n : ZMod 9} :
    castHom (show 3 ∣ 9 by norm_num) (ZMod 3) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
/-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
`{γ}` is a neighbourhood of `γ`. -/
theorem singleton_mem_nhds_of_units (γ : Γ₀ˣ) : ({↑γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀)
-- Mathlib/Computability/NFA.lean
@[simp]
theorem evalFrom_append_singleton (S : Set σ) (x : List α) (a : α) :
    M.evalFrom S (x ++ [a]) = M.stepSet (M.evalFrom S x) a
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Two n-simplices among cospherical points in an n-dimensional
subspace have the same circumradius. -/
theorem circumradius_eq_of_cospherical_subset {s : AffineSubspace ℝ P} {ps : Set P} (h : ps ⊆ s)
    [Nonempty s] {n : ℕ} [FiniteDimensional ℝ s.direction] (hd : finrank ℝ s.direction = n)
    (hc : Cospherical ps) {sx₁ sx₂ : Simplex ℝ P n} (hsx₁ : Set.range sx₁.points ⊆ ps)
    (hsx₂ : Set.range sx₂.points ⊆ ps) : sx₁.circumradius = sx₂.circumradius
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
@[simp]
theorem ι_ne_one [Nontrivial R] (x : M) : ι R x ≠ 1
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
theorem le_lfpApprox {a : Ordinal} : x ≤ lfpApprox f x a
-- Mathlib/Order/Antichain.lean
theorem preimage_compl [BooleanAlgebra α] (hs : IsAntichain (· ≤ ·) s) :
    IsAntichain (· ≤ ·) (compl ⁻¹' s)
-- Mathlib/Logic/Lemmas.lean
theorem ite_ite_distrib_right : ite p (ite q a b) c = ite q (ite p a c) (ite p b c)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- If `f` belongs to `lpMeasSubgroup F m p μ`, then the measurable function it is almost
everywhere equal to (given by `AEMeasurable.mk`) belongs to `ℒp` for the measure `μ.trim hm`. -/
theorem memℒp_trim_of_mem_lpMeasSubgroup (hm : m ≤ m0) (f : Lp F p μ)
    (hf_meas : f ∈ lpMeasSubgroup F m p μ) :
    Memℒp (mem_lpMeasSubgroup_iff_aeStronglyMeasurable'.mp hf_meas).choose p (μ.trim hm)
-- Mathlib/Topology/Order/NhdsSet.lean
theorem nhdsSet_Ico (h : a < b) : 𝓝ˢ (Ico a b) = 𝓝 a ⊔ 𝓟 (Ioo a b)
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem append_nil : append xs nil = xs
-- Mathlib/Data/Matrix/Basic.lean
theorem neg_vecMul [Fintype m] (v : m → α) (A : Matrix m n α) : (-v) ᵥ* A = - (v ᵥ* A)
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem extend_extends {a b : X} (γ : Path a b) {t : ℝ}
    (ht : t ∈ (Icc 0 1 : Set ℝ)) : γ.extend t = γ ⟨t, ht⟩
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) :
    0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
theorem zero_mem_measureOfNegatives : (0 : ℝ) ∈ s.measureOfNegatives
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toFun_eq_coe {f : α ≃o β} : f.toFun = f
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
@[simp]
theorem toSmoothPartitionOfUnity_toPartitionOfUnity (f : BumpCovering ι M s)
    (hf : ∀ i, Smooth I 𝓘(ℝ) (f i)) :
    (f.toSmoothPartitionOfUnity hf).toPartitionOfUnity = f.toPartitionOfUnity
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem sqLe_mul {d x y z w : ℕ} :
    (SqLe x 1 y d → SqLe z 1 w d → SqLe (x * w + y * z) d (x * z + d * y * w) 1) ∧
      (SqLe x 1 y d → SqLe w d z 1 → SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
        (SqLe y d x 1 → SqLe z 1 w d → SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
          (SqLe y d x 1 → SqLe w d z 1 → SqLe (x * w + y * z) d (x * z + d * y * w) 1)
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem mem_extChartAt_source_of_eq_one {i : ι} {x : M} (h : fs i x = 1) :
    x ∈ (extChartAt I (fs.c i)).source
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csInf_Ioo [DenselyOrdered α] (h : a < b) : sInf (Ioo a b) = a
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem Ioc_eq_range' : Ioc a b = ⟨List.range' (a + 1) (b - a), List.nodup_range' _ _⟩
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If a function has a Taylor series at order at least `1` on a neighborhood of `x`, then the term
of order `1` of this series is a derivative of `f` at `x`. -/
theorem HasFTaylorSeriesUpToOn.hasFDerivAt (h : HasFTaylorSeriesUpToOn n f p s) (hn : 1 ≤ n)
    (hx : s ∈ 𝓝 x) : HasFDerivAt f (continuousMultilinearCurryFin1 𝕜 E F (p x 1)) x
-- Mathlib/RingTheory/Localization/Basic.lean
@[simp]
theorem map_id_mk' {Q : Type*} [CommSemiring Q] [Algebra R Q] [IsLocalization M Q] (x) (y : M) :
    map Q (RingHom.id R) (le_refl M) (mk' S x y) = mk' Q x y
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
@[reassoc]
lemma functorObj_comm :
    functorObjTop f πX ≫ ιFunctorObj f πX = functorObjLeft f πX ≫ ρFunctorObj f πX
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem NF.below_of_lt' : ∀ {o b}, repr o < ω ^ b → NF o → NFBelow o b
-- Mathlib/Deprecated/Subgroup.lean
/-- The normal closure of s is a normal subgroup. -/
theorem normalClosure.is_normal : IsNormalSubgroup (normalClosure s)
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc (attr := simp)]
lemma Scheme.iso_inv_val_base_hom_val_base {X Y : Scheme.{u}} (e : X ≅ Y) :
    e.inv.val.base ≫ e.hom.val.base = 𝟙 _
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem mem_compl_zeroLocus_iff_not_mem {f : A} {I : ProjectiveSpectrum 𝒜} :
    I ∈ (zeroLocus 𝒜 {f} : Set (ProjectiveSpectrum 𝒜))ᶜ ↔ f ∉ I.asHomogeneousIdeal
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem ContMDiffOn.mul (hf : ContMDiffOn I' I n f s) (hg : ContMDiffOn I' I n g s) :
    ContMDiffOn I' I n (f * g) s
-- Mathlib/Control/Traversable/Lemmas.lean
theorem traverse_map (f : β → F γ) (g : α → β) (x : t α) :
    traverse f (g <$> x) = traverse (f ∘ g) x
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_add_iff_add_lt_ne_self {a} :
    Principal (· + ·) a ↔ ∀ ⦃b c⦄, b < a → c < a → b + c ≠ a
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
/-- The identity monoidal natural transformation. -/
@[simps!]
def id (F : LaxMonoidalFunctor C D) : MonoidalNatTrans F F
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem isOpen_uniformity {s : Set α} :
    IsOpen s ↔ ∀ x ∈ s, { p : α × α | p.1 = x → p.2 ∈ s } ∈ 𝓤 α
-- .lake/packages/lean4/src/lean/Init/SizeOf.lean
@[simp] theorem Unit.sizeOf (u : Unit) : sizeOf u = 1
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma isLocalizedModule_iff_isLocalization' (R') [CommSemiring R'] [Algebra R R'] :
    IsLocalizedModule S (Algebra.ofId R R').toLinearMap ↔ IsLocalization S R'
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
theorem matPolyEquiv_eval (M : Matrix n n R[X]) (r : R) (i j : n) :
    (matPolyEquiv M).eval (scalar n r) i j = (M i j).eval r
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem takeWhile_eq_takeWhileTR : @takeWhile = @takeWhileTR
-- Mathlib/SetTheory/ZFC/Basic.lean
protected theorem equiv_empty (x : PSet) [IsEmpty x.Type] : Equiv x ∅
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.mul_lt_one_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (hb : b ≤ 1)
    (b0 : 0 < b) : a * b < 1
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem map_lift_pullbackComparison (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPullback (G.map f) (G.map g)] {W : C} {h : W ⟶ X} {k : W ⟶ Y} (w : h ≫ f = k ≫ g) :
    G.map (pullback.lift _ _ w) ≫ pullbackComparison G f g =
      pullback.lift (G.map h) (G.map k) (by simp only [← G.map_comp, w])
-- Mathlib/Order/Filter/Pointwise.lean
protected theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g)
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Finset.measurable_sup' {ι : Type*} {s : Finset ι} (hs : s.Nonempty) {f : ι → δ → α}
    (hf : ∀ n ∈ s, Measurable (f n)) : Measurable (s.sup' hs f)
-- Mathlib/CategoryTheory/Abelian/LeftDerived.lean
@[simp, reassoc]
lemma NatTrans.leftDerivedToHomotopyCategory_comp {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H)
    [F.Additive] [G.Additive] [H.Additive] :
    NatTrans.leftDerivedToHomotopyCategory (α ≫ β) =
      NatTrans.leftDerivedToHomotopyCategory α ≫
        NatTrans.leftDerivedToHomotopyCategory β
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem testBit_bitwise (f : Bool → Bool → Bool) (m n k) :
    testBit (bitwise f m n) k = f (testBit m k) (testBit n k)
-- Mathlib/Data/Real/Basic.lean
lemma ofCauchy_intCast (z : ℤ) : (⟨z⟩ : ℝ) = z
-- Mathlib/Data/List/Infix.lean
theorem dropLast_sublist (l : List α) : l.dropLast <+ l
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem coe_starAe : ⇑(starAe : ℍ[R,c₁,c₂] ≃ₐ[R] _) = op ∘ star
-- Mathlib/Data/NNReal/Basic.lean
theorem le_toNNReal_of_coe_le {x : ℝ≥0} {y : ℝ} (h : ↑x ≤ y) : x ≤ y.toNNReal
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem coe_subtype : ⇑S.subtype = Subtype.val
-- Mathlib/CategoryTheory/Comma/Basic.lean
@[simp]
theorem id_right : (𝟙 X : CommaMorphism X X).right = 𝟙 X.right
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_strictlyPositive {x : E} : x ∈ strictlyPositive 𝕜 E ↔ 0 < x
-- Mathlib/CategoryTheory/Shift/CommShift.lean
lemma map_shiftFunctorComm_hom_app [F.CommShift B] (X : C) (a b : B) :
    F.map ((shiftFunctorComm C a b).hom.app X) = (F.commShiftIso b).hom.app (X⟦a⟧) ≫
      ((F.commShiftIso a).hom.app X)⟦b⟧' ≫ (shiftFunctorComm D a b).hom.app (F.obj X) ≫
      ((F.commShiftIso b).inv.app X)⟦a⟧' ≫ (F.commShiftIso a).inv.app (X⟦b⟧)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_sum {α : Type*} [DecidableEq σ] {s : Finset α} {f : α → MvPolynomial σ R} :
    (∑ x ∈ s, f x).support ⊆ s.biUnion fun x => (f x).support
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem UniformCauchySeqOnFilter.mono_right {p'' : Filter α} (hf : UniformCauchySeqOnFilter F p p')
    (hp : p'' ≤ p') : UniformCauchySeqOnFilter F p p''
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
@[reassoc (attr := simp)]
theorem w {s t : RightLift f g} (h : s ⟶ t) :
    h.left ▷ f ≫ t.counit = s.counit
-- Mathlib/Order/WellFoundedSet.lean
theorem isPWO_sup [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO
-- Mathlib/Algebra/Group/Invertible/Defs.lean
theorem mul_right_inj_of_invertible : a * c = b * c ↔ a = b
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem preimage_smul_ball (c : G) (x : X) (r : ℝ) : (c • ·) ⁻¹' ball x r = ball (c⁻¹ • x) r
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem disjoint_def' {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1
-- Mathlib/Order/Monotone/Basic.lean
/-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
monotone function `f : ℤ → α`. -/
theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
/-- The image of a bounded set under a Lipschitz map is bounded. -/
theorem isBounded_image (hf : LipschitzWith K f) {s : Set α} (hs : IsBounded s) :
    IsBounded (f '' s)