ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sup_mul_nat (o : Ordinal) : (sup fun n : ℕ => o * n) = o * ω
-- Mathlib/Data/List/Zip.lean
@[simp]
theorem zipWith3_same_right (f : α → β → β → γ) :
    ∀ (la : List α) (lb : List β), zipWith3 f la lb lb = zipWith (fun a b => f a b b) la lb
-- Mathlib/Order/PrimeIdeal.lean
protected theorem disjoint : Disjoint (IF.I : Set P) IF.F
-- Mathlib/Topology/Homotopy/Path.lean
@[simp]
theorem eval_one (F : Homotopy p₀ p₁) : F.eval 1 = p₁
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem ratio_pow (f : α →ᵈ α) (n : ℕ) : ratio (f ^ n) = ratio f ^ n
-- Mathlib/Data/Finset/Basic.lean
theorem filter_inter_filter_neg_eq (s t : Finset α) :
    (s.filter p ∩ t.filter fun a => ¬p a) = ∅
-- Mathlib/Data/Set/Card.lean
/-- Given a set `t` and a set `s` inside it, we can shrink `t` to any appropriate size, and keep `s`
    inside it. -/
@[deprecated exists_subsuperset_card_eq (since := "2024-06-24")]
theorem exists_intermediate_Set (i : ℕ) (h₁ : i + s.ncard ≤ t.ncard) (h₂ : s ⊆ t) :
    ∃ r : Set α, s ⊆ r ∧ r ⊆ t ∧ r.ncard = i + s.ncard
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem zipWith_eq_zipWith_take_min : ∀ (l₁ : List α) (l₂ : List β),
    zipWith f l₁ l₂ = zipWith f (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
-- Mathlib/Data/Set/Finite.lean
theorem Finite.exists_minimal_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/GradedAlgebra/HomogeneousLocalization.lean
@[simp] lemma mk_zero : mk (0 : NumDenSameDeg 𝒜 x) = 0
-- Mathlib/Control/Applicative.lean
theorem Applicative.map_seq_map (f : α → β → γ) (g : σ → β) (x : F α) (y : F σ) :
    f <$> x <*> g <$> y = ((· ∘ g) ∘ f) <$> x <*> y
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
protected lemma Filter.HasBasis.uniformInducing_iff {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
    (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
    UniformInducing f ↔
      (∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
        (∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j)
-- Mathlib/CategoryTheory/Skeletal.lean
theorem equiv_of_both_ways {X Y : C} (f : X ⟶ Y) (g : Y ⟶ X) : X ≈ Y
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem isometryEquiv_map_mkMetric (m : ℝ≥0∞ → ℝ≥0∞) (f : X ≃ᵢ Y) :
    map f (mkMetric m) = mkMetric m
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem filterMap_some (s : Multiset α) : filterMap some s = s
-- Mathlib/FieldTheory/Galois.lean
theorem card_fixingSubgroup_eq_finrank [DecidablePred (· ∈ IntermediateField.fixingSubgroup K)]
    [FiniteDimensional F E] [IsGalois F E] :
    Fintype.card (IntermediateField.fixingSubgroup K) = finrank K E
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- `J` commutes with any positively-oriented isometric automorphism. -/
theorem linearIsometryEquiv_comp_rightAngleRotation' (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) :
    LinearIsometryEquiv.trans J φ = φ.trans J
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem hasDerivAt_arccos {x : ℝ} (h₁ : x ≠ -1) (h₂ : x ≠ 1) :
    HasDerivAt arccos (-(1 / √(1 - x ^ 2))) x
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp]
theorem mapIso_inv_app (f g : X ⟶ Y) (h : f = g) (U : Opens Y) :
    (mapIso f g h).inv.app U = eqToHom (by rw [h])
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma Odd.pow_pos_iff (hn : Odd n) : 0 < a ^ n ↔ 0 < a
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem combo_sat' (s t : Constraint)
    (a : Int) (x : Coeffs) (b : Int) (y : Coeffs) (v : Coeffs)
    (wx : s.sat' x v) (wy : t.sat' y v) :
    (Constraint.combo a s b t).sat' (Coeffs.combo a x b y) v
-- Mathlib/GroupTheory/Coxeter/Basic.lean
@[simp]
theorem simple_mul_simple_cancel_left {w : W} (i : B) : s i * (s i * w) = w
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_finset_sum {ι : Type*} (s : Finset ι) (f : ι → MvPolynomial σ R) :
    (s.sum f).totalDegree ≤ Finset.sup s fun i => (f i).totalDegree
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Sized.node3L {l x m y r} (hl : @Sized α l) (hm : Sized m) (hr : Sized r) :
    Sized (node3L l x m y r)
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem zero_re : (0 : ℍ[R,c₁,c₂]).re = 0
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma comap_basicOpen (f : R →+* S) (x : R) :
    TopologicalSpace.Opens.comap (comap f) (basicOpen x) = basicOpen (f x)
-- Mathlib/GroupTheory/HNNExtension.lean
theorem of_smul_eq_smul (g : G) (w : NormalWord d) :
    (of g : HNNExtension G A B φ) • w = g • w
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_hasBasis {p : β → Prop} {s : β → Set α} {a : α} (h : (𝓝 a).HasBasis p s)
    (t : Set α) : (𝓝[t] a).HasBasis p fun i => s i ∩ t
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma comapOn_ground_eq : (N.comapOn E f).E = E
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
@[reassoc] theorem comul_assoc_flip :
    M.comul ≫ (M.comul ▷ M.X) = M.comul ≫ (M.X ◁ M.comul) ≫ (α_ M.X M.X M.X).inv
-- Mathlib/Order/Filter/Pi.lean
theorem tendsto_pi {β : Type*} {m : β → ∀ i, α i} {l : Filter β} :
    Tendsto m l (pi f) ↔ ∀ i, Tendsto (fun x => m x i) l (f i)
-- Mathlib/GroupTheory/Perm/Finite.lean
theorem mem_sumCongrHom_range_of_perm_mapsTo_inl {m n : Type*} [Finite m] [Finite n]
    {σ : Perm (m ⊕ n)} (h : Set.MapsTo σ (Set.range Sum.inl) (Set.range Sum.inl)) :
    σ ∈ (sumCongrHom m n).range
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_algebraic_toSubalgebra {S : Set E} (hS : ∀ x ∈ S, IsAlgebraic F x) :
    (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S
-- Mathlib/Data/Set/Basic.lean
theorem diff_diff_eq_sdiff_union (h : u ⊆ s) : s \ (t \ u) = s \ t ∪ u
-- Mathlib/Data/Multiset/Fold.lean
@[simp]
theorem fold_zero (b : α) : (0 : Multiset α).fold op b = b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]?
-- Mathlib/Order/Interval/Set/OrderIso.lean
@[simp]
theorem preimage_Ioi (e : α ≃o β) (b : β) : e ⁻¹' Ioi b = Ioi (e.symm b)
-- Mathlib/Topology/Homotopy/Path.lean
@[simp]
theorem symm_symm (F : Homotopy p₀ p₁) : F.symm.symm = F
-- Mathlib/Analysis/Complex/Angle.lean
lemma angle_div_right_eq_angle_mul_left (a x y : ℂ) : angle x (y / a) = angle (x * a) y
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem unitGroup_injective : Function.Injective (unitGroup : ValuationSubring K → Subgroup _)
-- Mathlib/RingTheory/FiniteType.lean
/-- If a set `S` generates, as algebra, `MonoidAlgebra R M`, then the image of the union of the
supports of elements of `S` generates `MonoidAlgebra R M`. -/
theorem support_gen_of_gen' {S : Set (MonoidAlgebra R M)} (hS : Algebra.adjoin R S = ⊤) :
    Algebra.adjoin R (of R M '' ⋃ f ∈ S, (f.support : Set M)) = ⊤
-- Mathlib/Data/Finset/NAry.lean
theorem card_image₂ (hf : Injective2 f) (s : Finset α) (t : Finset β) :
    (image₂ f s t).card = s.card * t.card
-- Mathlib/Data/Prod/Lex.lean
theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β)
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.indepSet_of_mem (hs : s ∈ S) (ht : t ∈ T)
    (hs_meas : MeasurableSet s) (ht_meas : MeasurableSet t)
    (μ : Measure Ω := by volume_tac) [IsProbabilityMeasure μ]
    (h_indep : IndepSets S T μ) :
    IndepSet s t μ
-- Mathlib/RingTheory/Jacobson.lean
/-- Used to bootstrap the more general `quotient_mk_comp_C_isIntegral_of_jacobson` -/
private theorem quotient_mk_comp_C_isIntegral_of_jacobson' [Nontrivial R] (hR : IsJacobson R)
    (hP' : ∀ x : R, C x ∈ P → x = 0) : ((Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem isCycleOn_support_cycleOf [DecidableEq α] [Fintype α] (f : Perm α) (x : α) :
    f.IsCycleOn (f.cycleOf x).support
-- Mathlib/Data/Set/Image.lean
theorem preimage_singleton_eq_empty {f : α → β} {y : β} : f ⁻¹' {y} = ∅ ↔ y ∉ range f
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem hasFTaylorSeriesUpTo_zero_iff :
    HasFTaylorSeriesUpTo 0 f p ↔ Continuous f ∧ ∀ x, (p x 0).uncurry0 = f x
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem card_commonNeighbors_lt_card_verts [DecidableRel G.Adj] (v w : V) :
    Fintype.card (G.commonNeighbors v w) < Fintype.card V
-- Mathlib/Analysis/Complex/RemovableSingularity.lean
/-- **Removable singularity** theorem: if a function `f : ℂ → E` is complex differentiable and
bounded on a punctured neighborhood of `c`, then `f` has a limit at `c`. -/
theorem tendsto_limUnder_of_differentiable_on_punctured_nhds_of_bounded_under {f : ℂ → E} {c : ℂ}
    (hd : ∀ᶠ z in 𝓝[≠] c, DifferentiableAt ℂ f z)
    (hb : IsBoundedUnder (· ≤ ·) (𝓝[≠] c) fun z => ‖f z - f c‖) :
    Tendsto f (𝓝[≠] c) (𝓝 <| limUnder (𝓝[≠] c) f)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.mem_ball_self (x : α) {V : Set (α × α)} (hV : V ∈ 𝓤 α) : x ∈ ball x V
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem and_eq (x y : BitVec w)                   : BitVec.and x y = x &&& y
-- Mathlib/Order/SuccPred/Basic.lean
theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : succ^[n] a = succ^[m] a)
    (h_ne : n ≠ m) : IsMax (succ^[n] a)
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
@[reassoc (attr := simp)]
theorem π_arrow (j : J) : π arrows j ≫ arrows _ = base arrows
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
@[simp] theorem smul_coeffs {lc : LinearCombo} {i : Int} : (i * lc).coeffs = i * lc.coeffs
-- Mathlib/Data/Set/Function.lean
theorem comp (hf' : LeftInvOn f' f s) (hg' : LeftInvOn g' g t) (hf : MapsTo f s t) :
    LeftInvOn (f' ∘ g') (g ∘ f) s
-- Mathlib/NumberTheory/SmoothNumbers.lean
lemma prime_of_mem_primesBelow {p n : ℕ} (h : p ∈ n.primesBelow) : p.Prime
-- Mathlib/Data/Real/Irrational.lean
theorem of_zpow : ∀ m : ℤ, Irrational (x ^ m) → Irrational x
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- For any `p`, the power of `p` in `n^k` is `k` times the power in `n` -/
@[simp]
theorem factorization_pow (n k : ℕ) : factorization (n ^ k) = k • n.factorization
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
/-- The square cylinders formed from measurable sets generate the product σ-algebra. -/
theorem generateFrom_squareCylinders [∀ i, MeasurableSpace (α i)] :
    MeasurableSpace.generateFrom (squareCylinders fun i ↦ {s : Set (α i) | MeasurableSet s}) =
      MeasurableSpace.pi
-- .lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean
@[simp] protected theorem UInt32.sizeOf (a : UInt32) : sizeOf a = a.toNat + 2
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem div_eq_zero_iff : a / b = 0 ↔ a = 0 ∨ b = 0
-- Mathlib/Data/List/Lattice.lean
@[simp]
theorem inter_reverse {xs ys : List α} : xs.inter ys.reverse = xs.inter ys
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem not_sbtw_self_right (x y : P) : ¬Sbtw R x y y
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem map_cons (f : α → β) (a s) : map f (cons a s) = cons (f a) (map f s)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma coeff_ΨSq (n : ℤ) : (W.ΨSq n).coeff (n.natAbs ^ 2 - 1) = n ^ 2
-- Mathlib/Data/Set/Image.lean
theorem forall_mem_image {f : α → β} {s : Set α} {p : β → Prop} :
    (∀ y ∈ f '' s, p y) ↔ ∀ ⦃x⦄, x ∈ s → p (f x)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem of_disjoint_iUnion_nat [T2Space M] (v : VectorMeasure α M) {f : ℕ → Set α}
    (hf₁ : ∀ i, MeasurableSet (f i)) (hf₂ : Pairwise (Disjoint on f)) :
    v (⋃ i, f i) = ∑' i, v (f i)
-- Mathlib/LinearAlgebra/Reflection.lean
/-- This rather technical-looking lemma exists because it is exactly what is needed to establish a
uniqueness result for root data. See the doc string of `Module.Dual.eq_of_preReflection_mapsTo` for
further remarks. -/
lemma Dual.eq_of_preReflection_mapsTo' [CharZero R] [NoZeroSMulDivisors R M]
    {x : M} (hx : x ≠ 0) {Φ : Set M} (hΦ₁ : Φ.Finite) (hx' : x ∈ span R Φ) {f g : Dual R M}
    (hf₁ : f x = 2) (hf₂ : MapsTo (preReflection x f) Φ Φ)
    (hg₁ : g x = 2) (hg₂ : MapsTo (preReflection x g) Φ Φ) :
    (span R Φ).subtype.dualMap f = (span R Φ).subtype.dualMap g
-- Mathlib/Order/Defs.lean
theorem lt_of_le_of_ne {a b : α} : a ≤ b → a ≠ b → a < b
-- Mathlib/SetTheory/Game/Basic.lean
/-- Any left option of `x * y` of the first kind is also a left option of `x * -(-y)` of
  the first kind. -/
lemma mulOption_neg_neg {x} (y) {i j} :
    mulOption x y i j = mulOption x (-(-y)) i (toLeftMovesNeg <| toRightMovesNeg j)
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp]
lemma range_ofENat : range ofENat = Iic ℵ₀
-- Mathlib/Order/Irreducible.lean
@[simp]
theorem supPrime_iff_supIrred : SupPrime a ↔ SupIrred a
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem le_dist_iff_le_dist_coe_center :
    r < dist z w ↔ w.im * Real.sinh r < dist (z : ℂ) (w.center r)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem smul_eq_mul : ∀ (n : ℕ) (a : Ordinal), n • a = a * n
-- Mathlib/Topology/Bases.lean
theorem IsTopologicalBasis.open_eq_sUnion {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : ∃ S ⊆ B, u = ⋃₀ S
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem HasCompactMulSupport.comp_smul {β : Type*} [One β] {f : α → β} (h : HasCompactMulSupport f)
    {c : G₀} (hc : c ≠ 0) : HasCompactMulSupport fun x => f (c • x)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem sub_le_of_le_add {a b c : Nat} (h : a ≤ c + b) : a - b ≤ c
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem continuousSMul_induced : @ContinuousSMul R M₁ _ u (t.induced f)
-- Mathlib/Algebra/Star/Module.lean
theorem skewAdjointPart_comp_subtype_skewAdjoint :
    (skewAdjointPart R).comp (skewAdjoint.submodule R A).subtype = .id
-- Mathlib/GroupTheory/GroupAction/Quotient.lean
theorem quotientCentralizerEmbedding_apply (g : G) (x : G) :
    quotientCentralizerEmbedding g x = ⟨⁅x, g⁆, x, g, rfl⟩
-- Mathlib/Logic/UnivLE.lean
theorem univLE_max : UnivLE.{u, max u v}
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_of_singleton (α : Type*) : (⋃ x, {x} : Set α) = univ
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp] lemma toFinset_Ioc (a b : α) [Fintype (Ioc a b)] : (Ioc a b).toFinset = Finset.Ioc a b
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl)
The natural transformation given by the algebra structure maps, used to construct a cocone `c` with
point `colimit (D ⋙ forget T)`.
 -/
@[simps]
def γ : (D ⋙ forget T) ⋙ ↑T ⟶ D ⋙ forget T
-- Mathlib/Order/BooleanAlgebra.lean
theorem isCompl_compl : IsCompl x xᶜ
-- Mathlib/Data/List/Range.lean
/-- See `List.ranges_join` for the version about `List.sum`. -/
lemma ranges_join' : ∀ l : List ℕ, l.ranges.join = range (Nat.sum l)
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsUpperSet.total (hs : IsUpperSet s) (ht : IsUpperSet t) : s ⊆ t ∨ t ⊆ s
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- The definition of uniform integrable in mathlib is equivalent to the definition commonly
found in literature. -/
theorem uniformIntegrable_iff [IsFiniteMeasure μ] (hp : 1 ≤ p) (hp' : p ≠ ∞) :
    UniformIntegrable f p μ ↔
      (∀ i, AEStronglyMeasurable (f i) μ) ∧
        ∀ ε : ℝ, 0 < ε → ∃ C : ℝ≥0,
          ∀ i, eLpNorm ({ x | C ≤ ‖f i x‖₊ }.indicator (f i)) p μ ≤ ENNReal.ofReal ε
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem map_mk (φ : G →g G') (v : V) :
    (G.connectedComponentMk v).map φ = G'.connectedComponentMk (φ v)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem one_add_ofNat (m : ℕ) [m.AtLeastTwo] :
    1 + (no_index (OfNat.ofNat m : Ordinal)) = Order.succ (OfNat.ofNat m : Ordinal)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem lt_iff_le_not_le : ∀ {x y : Bool}, x < y ↔ x ≤ y ∧ ¬ y ≤ x
-- Mathlib/FieldTheory/PurelyInseparable.lean
theorem IsPurelyInseparable.minpoly_eq_X_sub_C_pow (q : ℕ) [ExpChar F q] [IsPurelyInseparable F E]
    (x : E) : ∃ n : ℕ, (minpoly F x).map (algebraMap F E) = (X - C x) ^ q ^ n
-- Mathlib/CategoryTheory/EffectiveEpi/Basic.lean
@[reassoc (attr := simp)]
lemma EffectiveEpi.fac {X Y W : C} (f : Y ⟶ X) [EffectiveEpi f]
    (e : Y ⟶ W) (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e) :
    f ≫ EffectiveEpi.desc f e h = e
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp, norm_cast]
theorem coe_pow {R} [Semiring R] (s : Subsemiring R) (x : s) (n : ℕ) :
    ((x ^ n : s) : R) = (x : R) ^ n
-- Mathlib/Algebra/BigOperators/Associated.lean
theorem prod_le_prod {p q : Multiset (Associates α)} (h : p ≤ q) : p.prod ≤ q.prod
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Ioo [DenselyOrdered α] : (Ioo a b).Nonempty ↔ a < b
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem upper_le_upper (hJ : J ∈ π) : J.upper ≤ I.upper
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem HasStrictDerivAt.exp (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.exp (f x)) (Real.exp (f x) * f') x
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_union_eq_left_of_forall {f : X → E} (ht : MeasurableSet t)
    (ht_eq : ∀ x ∈ t, f x = 0) : ∫ x in s ∪ t, f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Topology/Compactness/Compact.lean
protected theorem ClosedEmbedding.noncompactSpace [NoncompactSpace X] {f : X → Y}
    (hf : ClosedEmbedding f) : NoncompactSpace Y
-- Mathlib/Data/Nat/GCD/BigOperators.lean
theorem coprime_fintype_prod_left_iff [Fintype ι] {s : ι → ℕ} {x : ℕ} :
    Coprime (∏ i, s i) x ↔ ∀ i, Coprime (s i) x
-- Mathlib/Data/Set/Lattice.lean
/-- This rather trivial consequence of `subset_iUnion₂` is convenient with `apply`, and has `i` and
`j` explicit for this purpose. -/
theorem subset_iUnion₂_of_subset {s : Set α} {t : ∀ i, κ i → Set α} (i : ι) (j : κ i)
    (h : s ⊆ t i j) : s ⊆ ⋃ (i) (j), t i j
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem const_smul (a : G) (x : β) : const (a • x) = a • const x
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp] theorem toHopfAlgebraCatIso_symm (e : X ≃ₐc[R] Y) :
    toHopfAlgebraCatIso e.symm = (toHopfAlgebraCatIso e).symm
-- Mathlib/Algebra/Polynomial/Reverse.lean
theorem revAtFun_inj {N : ℕ} : Function.Injective (revAtFun N)
-- Mathlib/Data/Nat/PartENat.lean
theorem withTopEquiv_one : withTopEquiv 1 = 1
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem nnnorm_lt_iff_of_nonempty [Nonempty α] {M : ℝ≥0} : ‖f‖₊ < M ↔ ∀ x, ‖f x‖₊ < M
-- Mathlib/Probability/Cdf.lean
lemma cdf_measure_stieltjesFunction (f : StieltjesFunction) (hf0 : Tendsto f atBot (𝓝 0))
    (hf1 : Tendsto f atTop (𝓝 1)) :
    cdf f.measure = f
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem parallelPair_obj_zero (f g : X ⟶ Y) : (parallelPair f g).obj zero = X
-- Mathlib/Data/List/AList.lean
theorem perm_erase {a : α} {s₁ s₂ : AList β} :
    s₁.entries ~ s₂.entries → (erase a s₁).entries ~ (erase a s₂).entries
-- Mathlib/Topology/Instances/ENNReal.lean
theorem continuous_sub_left {a : ℝ≥0∞} (a_ne_top : a ≠ ∞) : Continuous (a - ·)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioi_subset_Ici_iff [DenselyOrdered α] : Ioi b ⊆ Ici a ↔ a ≤ b
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem mk_ker {I : Ideal R} : ker (Quotient.mk I) = I
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arccos_eq_pi_div_two {x} : arccos x = π / 2 ↔ x = 0
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_mem (s : Set α) (w₁ : ⊥ ∈ s) (w₂ : ∀ᵉ (x ∈ s) (y ∈ s), x ⊔ y ∈ s)
    {ι : Type*} (t : Finset ι) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.sup p ∈ s
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_eq_bot {f : M →ₛₗ[τ₁₂] M₂} : ker f = ⊥ ↔ Injective f
-- Mathlib/GroupTheory/SpecificGroups/Dihedral.lean
theorem sr_mul_self (i : ZMod n) : sr i * sr i = 1
-- Mathlib/Data/List/Basic.lean
theorem nil_zipWith (f : α → β → γ) (l : List β) : zipWith f [] l = []
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_lt_of_mul_lt_of_nonneg_right [MulPosMono α] (h : a * b < c) (hle : d ≤ a) (b0 : 0 ≤ b) :
    d * b < c
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
@[simp]
theorem decomposeAux_eq_decompose :
    ⇑(decomposeAux f : R[M] →ₐ[R] ⨁ i : ι, gradeBy R f i) =
      DirectSum.decompose (gradeBy R f)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
@[simp]
theorem indexEquiv_apply_ofIsComplex_snd (w : {w : InfinitePlace K // IsComplex w}) :
    (indexEquiv K) (Sum.inr ⟨w, 1⟩) = ComplexEmbedding.conjugate w.val.embedding
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem subsingleton_iff_subsingleton : Subsingleton R[X] ↔ Subsingleton R
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_X_pow {n : ℕ} : (X ^ n).eval₂ f x = x ^ n
-- Mathlib/RingTheory/ClassGroup.lean
theorem mem_principal_ideals_iff {I : (FractionalIdeal R⁰ K)ˣ} :
    I ∈ (toPrincipalIdeal R K).range ↔ ∃ x : K, spanSingleton R⁰ x = I
-- Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean
/-- A specialization of `spectrum.map_polynomial_aeval_of_nonempty` to monic monomials for
convenience. -/
theorem map_pow_of_nonempty [IsAlgClosed 𝕜] {a : A} (ha : (σ a).Nonempty) (n : ℕ) :
    σ (a ^ n) = (· ^ n) '' σ a
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- Formula for `completedHurwitzZetaEven` as a Dirichlet series in the convergence range. -/
lemma hasSum_int_completedHurwitzZetaEven (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ Gammaℝ s / (↑|n + a| : ℂ) ^ s / 2) (completedHurwitzZetaEven a s)
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Finite.infsep_zero_iff_subsingleton (hs : s.Finite) : s.infsep = 0 ↔ s.Subsingleton
-- Mathlib/ModelTheory/Basic.lean
theorem injective_comp (h : N ≃[L] P) :
    Function.Injective (h.comp : (M ≃[L] N) →  (M ≃[L] P))
-- Mathlib/Analysis/Analytic/Meromorphic.lean
/-- With our definitions, `MeromorphicAt f x` depends only on the values of `f` on a punctured
neighbourhood of `x` (not on `f x`) -/
lemma congr {f g : 𝕜 → E} {x : 𝕜} (hf : MeromorphicAt f x) (hfg : f =ᶠ[𝓝[≠] x] g) :
    MeromorphicAt g x
-- Mathlib/Topology/Order/Hom/Esakia.lean
theorem toFun_eq_coe {f : EsakiaHom α β} : f.toFun = (f : α → β)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
/-- The main proof of the upper bound part of the Akra-Bazzi theorem. The factor
`1 - ε n` does not change the asymptotic order, but is needed for the induction step to go
through. -/
lemma T_isBigO_smoothingFn_mul_asympBound :
    T =O[atTop] (fun n => (1 - ε n) * asympBound g a b n)
-- Mathlib/Data/Nat/Factors.lean
theorem le_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ n.primeFactorsList) : p ≤ n
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem zero_div (a : Ordinal) : 0 / a = 0
-- Mathlib/Order/LiminfLimsup.lean
theorem blimsup_mono (h : ∀ x, p x → q x) : blimsup u f p ≤ blimsup u f q
-- Mathlib/SetTheory/Cardinal/ToNat.lean
@[deprecated map_prod (since := "2024-02-15")]
theorem toNat_finset_prod (s : Finset α) (f : α → Cardinal) :
    toNat (∏ i ∈ s, f i) = ∏ i ∈ s, toNat (f i)
-- Mathlib/Topology/DiscreteQuotient.lean
theorem proj_surjective : Function.Surjective S.proj
-- Mathlib/RingTheory/RingInvo.lean
@[simp]
theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x
-- Mathlib/Data/Finset/Image.lean
theorem map_eq_image (f : α ↪ β) (s : Finset α) : s.map f = s.image f
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.totallyBounded_Ico (a b : α) : TotallyBounded (Ico a b)
-- Mathlib/Analysis/Calculus/Taylor.lean
/-- **Taylor's theorem** with a polynomial bound on the remainder

We assume that `f` is `n+1`-times continuously differentiable on the closed set `Icc a b`.
There exists a constant `C` such that for all `x ∈ Icc a b` the difference of `f` and its `n`-th
Taylor polynomial can be estimated by `C * (x - a)^(n+1)`. -/
theorem exists_taylor_mean_remainder_bound {f : ℝ → E} {a b : ℝ} {n : ℕ} (hab : a ≤ b)
    (hf : ContDiffOn ℝ (n + 1) f (Icc a b)) :
    ∃ C, ∀ x ∈ Icc a b, ‖f x - taylorWithinEval f n (Icc a b) a x‖ ≤ C * (x - a) ^ (n + 1)
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dot_smul_left (xs ys : Coeffs) (i : Int) : dot (i * xs) ys = i * dot xs ys