ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem ContinuousOn.integrableOn_uIcc [LinearOrder X] [CompactIccSpace X] [T2Space X]
    (hf : ContinuousOn f [[a, b]]) : IntegrableOn f [[a, b]] μ
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem inv_hom_id_tensor {V W X Y Z : C} (f : V ≅ W) (g : X ⟶ Y) (h : Y ⟶ Z) :
    (f.inv ⊗ g) ≫ (f.hom ⊗ h) = (𝟙 W ⊗ g) ≫ (𝟙 W ⊗ h)
-- Mathlib/Algebra/Ring/Defs.lean
theorem mul_two (n : α) : n * 2 = n + n
-- Mathlib/Data/NNRat/Defs.lean
lemma «exists» {p : ℚ≥0 → Prop} : (∃ q, p q) ↔ ∃ q hq, p ⟨q, hq⟩
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
/-- Apply `L(x,-)` pointwise to bilinear maps, as a continuous bilinear map -/
@[simps! apply]
def precompR (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : E →L[𝕜] (Eₗ →L[𝕜] Fₗ) →L[𝕜] Eₗ →L[𝕜] Gₗ
-- Mathlib/Topology/Instances/ENNReal.lean
theorem summable_iff_not_tendsto_nat_atTop {f : ℕ → ℝ≥0} :
    Summable f ↔ ¬Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop atTop
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem add_of (p : Set α) (q : Set β) : of (p ⊕' q) = of p + of q
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
@[simp]
theorem det_mul (M N : Matrix n n R) : det (M * N) = det M * det N
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp]
theorem preimage_cast_Iic (q : ℚ) : (↑) ⁻¹' Iic (q : K) = Iic q
-- Mathlib/RingTheory/Derivation/Basic.lean
lemma coe_restrictScalars (d : Derivation S A M) : ⇑(d.restrictScalars R) = ⇑d
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_neg_left (x y : F) : ⟪-x, y⟫ = -⟪x, y⟫
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem LieHom.lie_apply (f : M →ₗ[R] N) (x : L) (m : M) : ⁅x, f⁆ m = ⁅x, f m⁆ - f ⁅x, m⁆
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem bind₁_bind₁ {υ : Type*} (f : σ → MvPolynomial τ R) (g : τ → MvPolynomial υ R)
    (φ : MvPolynomial σ R) : (bind₁ g) (bind₁ f φ) = bind₁ (fun i => bind₁ g (f i)) φ
-- Mathlib/Data/Set/NAry.lean
lemma image_prod : (fun x : α × β ↦ f x.1 x.2) '' s ×ˢ t = image2 f s t
-- Mathlib/Analysis/Convex/PartitionOfUnity.lean
theorem PartitionOfUnity.finsum_smul_mem_convex {s : Set X} (f : PartitionOfUnity ι X s)
    {g : ι → X → E} {t : Set E} {x : X} (hx : x ∈ s) (hg : ∀ i, f i x ≠ 0 → g i x ∈ t)
    (ht : Convex ℝ t) : (∑ᶠ i, f i x • g i x) ∈ t
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
theorem closure_def' {f : E →ₗ.[R] F} (hf : ¬f.IsClosable) : f.closure = f
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem cos_add : cos (x + y) = cos x * cos y - sin x * sin y
-- Mathlib/Data/Multiset/Basic.lean
theorem add_eq_union_iff_disjoint [DecidableEq α] {s t : Multiset α} :
    s + t = s ∪ t ↔ Disjoint s t
-- Mathlib/Data/Bool/Basic.lean
theorem or_inl {a b : Bool} (H : a) : a || b
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem singleton_mul_singleton : ({a} : Set α) * {b} = {a * b}
-- Mathlib/Data/ENNReal/Inv.lean
@[simp] protected theorem div_self_le_one : a / a ≤ 1
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem disjoint_ofDual_iff [SemilatticeInf α] [OrderBot α] {a b : αᵒᵈ} :
    Disjoint (ofDual a) (ofDual b) ↔ Codisjoint a b
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma absolutelyContinuous_sum_left {μs : ι → Measure α} (hμs : ∀ i, μs i ≪ ν) :
    Measure.sum μs ≪ ν
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π / 2 < |θ.toReal|
-- Mathlib/LinearAlgebra/Reflection.lean
lemma involutive_preReflection (h : f x = 2) :
    Involutive (preReflection x f)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_sUnion (x : PSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean
theorem set_walk_length_succ_eq (u v : V) (n : ℕ) :
    {p : G.Walk u v | p.length = n.succ} =
      ⋃ (w : V) (h : G.Adj u w), Walk.cons h '' {p' : G.Walk w v | p'.length = n}
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive add_abs_nonneg] lemma one_le_mul_mabs (a : α) : 1 ≤ a * |a|ₘ
-- Mathlib/Data/TypeVec.lean
theorem drop_append1 {α : TypeVec n} {β : Type*} {i : Fin2 n} : drop (append1 α β) i = α i
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma predAbove_right_last {i : Fin (n + 1)} : predAbove i (last (n + 1)) = last n
-- Mathlib/Data/ENNReal/Basic.lean
theorem toReal_ne_zero : a.toReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range (g ^ · : ℤ → G)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive] -- Porting note (#10618): `simp` can prove this
theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem summable (hp : 0 < p.toReal) {f : ∀ i, E i} (hf : Memℓp f p) :
    Summable fun i => ‖f i‖ ^ p.toReal
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem subset_zeroLocus_iff_subset_vanishingIdeal (t : Set (PrimeSpectrum R)) (s : Set R) :
    t ⊆ zeroLocus s ↔ s ⊆ vanishingIdeal t
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
@[simp]
theorem zero_div {a : R} : 0 / a = 0
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp, norm_cast]
lemma cast_inj : (m : α) = n ↔ m = n
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem coe_sub (v w : VectorMeasure α M) : ⇑(v - w) = v - w
-- Mathlib/Data/Bool/Basic.lean
theorem or_eq_true_eq_eq_true_or_eq_true (a b : Bool) :
    ((a || b) = true) = (a = true ∨ b = true)
-- Mathlib/Data/Finite/Card.lean
theorem card_le_one_iff_subsingleton [Finite α] : Nat.card α ≤ 1 ↔ Subsingleton α
-- Mathlib/Order/Lattice.lean
theorem map_sup_le [SemilatticeSup α] [SemilatticeInf β] {f : α → β} (h : Antitone f) (x y : α) :
    f (x ⊔ y) ≤ f x ⊓ f y
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ici_inter_Iic : Ici a ∩ Iic b = Icc a b
-- Mathlib/Data/Nat/ModEq.lean
lemma modEq_sub (h : b ≤ a) : a ≡ b [MOD a - b]
-- Mathlib/Tactic/FunProp/ContDiff.lean
theorem contDiffAt_id' : ContDiffAt K n (fun x : E => x) x
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem liftRel_pure_right (R : α → β → Prop) (ca : Computation α) (b : β) :
    LiftRel R ca (pure b) ↔ ∃ a, a ∈ ca ∧ R a b
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
/-- note: `ℝ≥0∞` can probably be generalized in a future version of this lemma. -/
@[measurability, fun_prop]
theorem Measurable.ennreal_tsum {ι} [Countable ι] {f : ι → α → ℝ≥0∞} (h : ∀ i, Measurable (f i)) :
    Measurable fun x => ∑' i, f i x
-- Mathlib/Analysis/Complex/Basic.lean
/-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexRingEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃+* ℂ
-- Mathlib/Topology/Order/Monotone.lean
theorem csInf_mem_closure {s : Set α} (hs : s.Nonempty) (B : BddBelow s) : sInf s ∈ closure s
-- Mathlib/Order/Minimal.lean
theorem inter_minimals_preimage_inter_eq_of_rel_iff_rel_on
    {x : Set α} (hf : ∀ ⦃a a'⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) (y : Set β) :
    x ∩ f ⁻¹' (minimals s ((f '' x) ∩ y)) = minimals r (x ∩ f ⁻¹' y)
-- Mathlib/Order/LiminfLimsup.lean
theorem HasBasis.liminf_eq_sSup_univ_of_empty {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) (i : ι') (hi : p i) (h'i : s i = ∅) :
    liminf f v = sSup univ
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_ringHom_id {X : SemiRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem mem_disjointed_spanningSetsIndex (μ : Measure α) [SigmaFinite μ] (x : α) :
    x ∈ disjointed (spanningSets μ) (spanningSetsIndex μ x)
-- Mathlib/LinearAlgebra/Span.lean
/-- Taking the span by a large ring of the span by the small ring is the same as taking the span
by just the large ring. -/
theorem span_span_of_tower [Semiring S] [SMul R S] [Module S M] [IsScalarTower R S M] :
    span S (span R s : Set M) = span S s
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- -
If we have particular limit cones available for `E ⋙ F` and for `F`,
we obtain a formula for `limit.pre F E`.
-/
theorem limit.pre_eq (s : LimitCone (E ⋙ F)) (t : LimitCone F) :
    limit.pre F E = (limit.isoLimitCone t).hom ≫ s.isLimit.lift (t.cone.whisker E) ≫
      (limit.isoLimitCone s).inv
-- Mathlib/Algebra/Regular/Basic.lean
/-- In a semigroup, the product of right-regular elements is right-regular. -/
@[to_additive "In an additive semigroup, the sum of add-right-regular elements is
add-right-regular."]
theorem IsRightRegular.mul (rra : IsRightRegular a) (rrb : IsRightRegular b) :
    IsRightRegular (a * b)
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR
-- Mathlib/Tactic/Ring/RingNF.lean
theorem nat_rawCast_2 [Nat.AtLeastTwo n] : (Nat.rawCast n : R) = OfNat.ofNat n
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp)]
protected lemma mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b
-- Mathlib/Algebra/Ring/CompTypeclasses.lean
/-- Class that expresses the fact that three ring homomorphisms form a composition triple. This is
used to handle composition of semilinear maps. -/
class RingHomCompTriple (σ₁₂ : R₁ →+* R₂) (σ₂₃ : R₂ →+* R₃) (σ₁₃ : outParam (R₁ →+* R₃)) :
  Prop where
  /-- The morphisms form a commutative triangle -/
  comp_eq : σ₂₃.comp σ₁₂ = σ₁₃
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeMagma β) = pure (f x)
-- Mathlib/Data/Real/ConjExponents.lean
lemma sub_one_ne_zero : p - 1 ≠ 0
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
theorem HD_below_aux1 {f : Cb X Y} (C : ℝ) {x : X} :
    BddBelow (range fun y : Y => f (inl x, inr y) + C)
-- Mathlib/RingTheory/EisensteinCriterion.lean
theorem le_natDegree_of_map_eq_mul_X_pow {n : ℕ} {P : Ideal R} (hP : P.IsPrime) {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hc0 : c.degree = 0) :
    n ≤ q.natDegree
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- `Equiv.funUnique` as an `IsometryEquiv`. -/
@[simps!]
def funUnique [Unique ι] [Fintype ι] : (ι → α) ≃ᵢ α
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem maximum?_eq_some_iff [Max α] [LE α] [anti : Antisymm ((· : α) ≤ ·)]
    (le_refl : ∀ a : α, a ≤ a)
    (max_eq_or : ∀ a b : α, max a b = a ∨ max a b = b)
    (max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) {xs : List α} :
    xs.maximum? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr₂_mapAccumr₂_right_right (f₁ : β → γ → σ₁ → σ₁ × φ) (f₂ : α → β → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ ys (mapAccumr₂ f₂ xs ys s₂).snd s₁)
    = let m := mapAccumr₂ (fun x y (s₁, s₂) =>
                let r₂ := f₂ x y s₂
                let r₁ := f₁ y r₂.snd s₁
                ((r₁.fst, r₂.fst), r₁.snd)
              )
            xs ys (s₁, s₂)
    (m.fst.fst, m.snd)
-- Mathlib/Algebra/Jordan/Basic.lean
private theorem aux3 {a b c : A} :
    ⁅L a, L (b * b)⁆ + ⁅L b, L (a * a)⁆ + 2 • (⁅L a, L (a * b)⁆ + ⁅L b, L (a * b)⁆) +
    (⁅L a, L (c * c)⁆ + ⁅L c, L (a * a)⁆ + 2 • (⁅L a, L (c * a)⁆ + ⁅L c, L (c * a)⁆)) +
    (⁅L b, L (c * c)⁆ + ⁅L c, L (b * b)⁆ + 2 • (⁅L b, L (b * c)⁆ + ⁅L c, L (b * c)⁆)) +
    (2 • ⁅L a, L (b * c)⁆ + 2 • ⁅L b, L (c * a)⁆ + 2 • ⁅L c, L (a * b)⁆)
    =
    2 • ⁅L a, L (b * c)⁆ + 2 • ⁅L b, L (c * a)⁆ + 2 • ⁅L c, L (a * b)⁆
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
/-- A multiplicative ring norm satisfies `f n ≤ n` for every `n : ℕ`. -/
lemma MulRingNorm_nat_le_nat {R : Type*} [Ring R] (n : ℕ) (f : MulRingNorm R) : f n ≤ n
-- Mathlib/Data/Int/Defs.lean
protected theorem ofNat_mul_out (m n : ℕ) : ↑m * ↑n = (↑(m * n) : ℤ)
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem edgeSet_bot : (⊥ : SimpleGraph V).edgeSet = ∅
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp)]
theorem one_mul : ∀ a : M, 1 * a = a
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem smul_sphere (c : G) (x : X) (r : ℝ) : c • sphere x r = sphere (c • x) r
-- Mathlib/RingTheory/Ideal/Over.lean
theorem comap_ne_bot_of_integral_mem [Nontrivial R] [IsDomain S] {x : S} (x_ne_zero : x ≠ 0)
    (x_mem : x ∈ I) (hx : IsIntegral R x) : I.comap (algebraMap R S) ≠ ⊥
-- Mathlib/Data/List/Infix.lean
protected theorem IsPrefix.filterMap (h : l₁ <+: l₂) (f : α → Option β) :
    l₁.filterMap f <+: l₂.filterMap f
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csSup_le_iff (hb : BddAbove s) (hs : s.Nonempty) : sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem coe_comp (f : CompleteLatticeHom β γ) (g : CompleteLatticeHom α β) : ⇑(f.comp g) = f ∘ g
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
theorem torusIntegral_sub (hf : TorusIntegrable f c R) (hg : TorusIntegrable g c R) :
    (∯ x in T(c, R), f x - g x) = (∯ x in T(c, R), f x) - ∯ x in T(c, R), g x
-- Mathlib/Order/RelIso/Basic.lean
/-- A relation embedding with respect to a given pair of relations `r` and `s`
is an embedding `f : α ↪ β` such that `r a b ↔ s (f a) (f b)`. -/
structure RelEmbedding {α β : Type*} (r : α → α → Prop) (s : β → β → Prop) extends α ↪ β where
  /-- Elements are related iff they are related after apply a `RelEmbedding` -/
  map_rel_iff' : ∀ {a b}, s (toEmbedding a) (toEmbedding b) ↔ r a b
-- Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean
lemma hasDerivAt_log_sub_logTaylor (n : ℕ) {z : ℂ} (hz : 1 + z ∈ slitPlane) :
    HasDerivAt (fun z : ℂ ↦ log (1 + z) - logTaylor (n + 1) z) ((-z) ^ n * (1 + z)⁻¹) z
-- Mathlib/Topology/ContinuousOn.lean
theorem tendsto_nhdsWithin_congr {f g : α → β} {s : Set α} {a : α} {l : Filter β}
    (hfg : ∀ x ∈ s, f x = g x) (hf : Tendsto f (𝓝[s] a) l) : Tendsto g (𝓝[s] a) l
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem trans_transPartialHomeomorph (e : X ≃ₜ Y) (e' : Y ≃ₜ Z) (f'' : PartialHomeomorph Z Z') :
    (e.trans e').transPartialHomeomorph f'' =
      e.transPartialHomeomorph (e'.transPartialHomeomorph f'')
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_eq_empty (h : ¬a < b) : Ico a b = ∅
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isRelPrime_mul_unit_right_right : IsRelPrime y (z * x) ↔ IsRelPrime y z
-- Mathlib/Data/Matroid/Basic.lean
theorem eq_iff_indep_iff_indep_forall {M₁ M₂ : Matroid α} :
    M₁ = M₂ ↔ (M₁.E = M₂.E) ∧ ∀ I, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, norm_cast] lemma coe_zero : ⇑(0 : α →₀ M) = 0
-- Mathlib/CategoryTheory/MorphismProperty/Factorization.lean
@[reassoc (attr := simp)]
lemma fac_app {f : Arrow C} : data.i.app f ≫ data.p.app f = f.hom
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
theorem modifyNthTR_go_eq : ∀ l n, modifyNthTR.go f l n acc = acc.data ++ modifyNth f n l
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
private theorem two_pow_succ_sub_succ_div_two : (2 ^ (n+1) - (x + 1)) / 2 = 2^n - (x/2 + 1)
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- `lift.{max v u, u}` equals `lift.{v, u}`. -/
@[simp, nolint simpNF]
theorem lift_umax' : lift.{max v u, u} = lift.{v, u}
-- Mathlib/Topology/Constructions.lean
theorem nhds_inl (x : X) : 𝓝 (inl x : X ⊕ Y) = map inl (𝓝 x)
-- Mathlib/Logic/Relation.lean
theorem _root_.Acc.of_downward_closed (dc : ∀ {a b}, rβ b (f a) → ∃ c, f c = b) (a : α)
    (ha : Acc (InvImage rβ f) a) : Acc rβ (f a)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp, norm_cast]
theorem coe_sInter {x : ZFSet.{u}} (h : x.Nonempty) : ↑(⋂₀ x : ZFSet) = ⋂₀ (x : Class.{u})
-- Mathlib/Algebra/Star/Order.lean
theorem conjugate_pos' {a : R} (ha : 0 < a) {c : R} (hc : IsRegular c) : 0 < c * a * star c
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive]
lemma smul_smul_smul_comm [SMul α β] [SMul α γ] [SMul β δ] [SMul α δ] [SMul γ δ]
    [IsScalarTower α β δ] [IsScalarTower α γ δ] [SMulCommClass β γ δ] (a : α) (b : β) (c : γ)
    (d : δ) : (a • b) • c • d = (a • c) • b • d
-- Mathlib/Data/List/Sort.lean
theorem length_split_fst_le (l : List α) : length (split l).1 ≤ length l
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem RelEmbedding.orderEmbeddingOfLTEmbedding_apply [PartialOrder α] [PartialOrder β]
    {f : ((· < ·) : α → α → Prop) ↪r ((· < ·) : β → β → Prop)} {x : α} :
    RelEmbedding.orderEmbeddingOfLTEmbedding f x = f x
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
@[reassoc (attr := simp), elementwise]
theorem prodIsoProd_inv_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).inv ≫ Limits.prod.fst = prodFst
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arcsin_inj {x y : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) (hy₁ : -1 ≤ y) (hy₂ : y ≤ 1) :
    arcsin x = arcsin y ↔ x = y
-- Mathlib/Algebra/Algebra/Spectrum.lean
/-- Without the assumption `Nontrivial A`, then `0 : A` would be invertible. -/
@[simp]
theorem zero_eq [Nontrivial A] : σ (0 : A) = {0}
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem hasFDerivAt_iff_isLittleO_nhds_zero :
    HasFDerivAt f f' x ↔ (fun h : E => f (x + h) - f x - f' h) =o[𝓝 0] fun h => h
-- Mathlib/Data/Multiset/Basic.lean
@[simp] theorem replicate_succ (a : α) (n) : replicate (n + 1) a = a ::ₘ replicate n a
-- Mathlib/Logic/Equiv/Defs.lean
/-- A `PSigma`-type is equivalent to the corresponding `Sigma`-type. -/
@[simps apply symm_apply]
def psigmaEquivSigmaPLift {α} (β : α → Sort*) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down)
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem map_U (f : R →+* S) (n : ℤ) : map f (U R n) = U S n
-- Mathlib/CategoryTheory/Idempotents/HomologicalComplex.lean
/-- The unit isomorphism of the equivalence
`Karoubi (HomologicalComplex C c) ≌ HomologicalComplex (Karoubi C) c`. -/
@[simps]
def unitIso : 𝟭 (Karoubi (HomologicalComplex C c)) ≅ functor ⋙ inverse
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma eventually_weightSpace_smul_add_eq_bot :
    ∀ᶠ (k : ℕ) in Filter.atTop, weightSpace M (k • χ₁ + χ₂) = ⊥
-- Mathlib/Order/Filter/Basic.lean
theorem NeBot.ne {f : Filter α} (hf : NeBot f) : f ≠ ⊥
-- Mathlib/Data/Seq/Computation.lean
theorem mem_map (f : α → β) {a} {s : Computation α} (m : a ∈ s) : f a ∈ map f s
-- Mathlib/Topology/Instances/ENNReal.lean
theorem nhds_top : 𝓝 ∞ = ⨅ (a) (_ : a ≠ ∞), 𝓟 (Ioi a)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_map_subset (p : MvPolynomial σ R) : (map f p).support ⊆ p.support
-- Mathlib/CategoryTheory/Sites/Over.lean
lemma over_map_compatiblePreserving {X Y : C} (f : X ⟶ Y) :
    CompatiblePreserving (J.over Y) (Over.map f)
-- Mathlib/Data/Bool/Basic.lean
lemma eq_not_iff : ∀ {a b : Bool}, a = !b ↔ a ≠ b
-- Mathlib/Analysis/Complex/AbsMax.lean
theorem norm_max_aux₁ [CompleteSpace F] {f : ℂ → F} {z w : ℂ}
    (hd : DiffContOnCl ℂ f (ball z (dist w z)))
    (hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z) : ‖f w‖ = ‖f z‖
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem coeff_natDegree : coeff p (natDegree p) = leadingCoeff p
-- Mathlib/Data/Quot.lean
theorem exists_rep (q : Trunc α) : ∃ a : α, mk a = q
-- Mathlib/Data/Real/GoldenRatio.lean
@[simp 1200]
theorem gold_sq : φ ^ 2 = φ + 1
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp] -- Porting note: requested by simpNF as toFun_eq_coe LHS simplifies
theorem toMonoidWithZeroHom_coe_eq_coe (v : Valuation R Γ₀) :
    (v.toMonoidWithZeroHom : R → Γ₀) = v
-- Mathlib/Data/Finset/Basic.lean
theorem Nonempty.exists_eq_singleton_or_nontrivial : s.Nonempty → (∃ a, s = {a}) ∨ s.Nontrivial
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem toIdeal_top : (⊤ : HomogeneousIdeal 𝒜).toIdeal = (⊤ : Ideal A)
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[ext]
lemma hom_ext {A : C} {i₁₂ : I₁₂} {f g : (K.total c₁₂).X i₁₂ ⟶ A}
    (h : ∀ (i₁ : I₁) (i₂ : I₂) (hi : ComplexShape.π c₁ c₂ c₁₂ (i₁, i₂) = i₁₂),
      K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ f = K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ g) : f = g
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc] -- Porting note (#10618): simp can prove these
theorem prod.diag_map_fst_snd {X Y : C} [HasBinaryProduct X Y] [HasBinaryProduct (X ⨯ Y) (X ⨯ Y)] :
    diag (X ⨯ Y) ≫ prod.map prod.fst prod.snd = 𝟙 (X ⨯ Y)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem toSubmodule_inj {S U : NonUnitalSubalgebra R A} : S.toSubmodule = U.toSubmodule ↔ S = U
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem conformal_const_smul {c : ℝ} (h : c ≠ 0) : Conformal fun x : X => c • x
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
@[simp]
theorem apply_one (x : R) : (1 : MulRingNorm R) x = if x = 0 then 0 else 1
-- Mathlib/Topology/Clopen.lean
theorem isClopen_range_sigmaMk {X : ι → Type*} [∀ i, TopologicalSpace (X i)] {i : ι} :
    IsClopen (Set.range (@Sigma.mk ι X i))
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map_leftInverse_iff {f : α → β} {g : β → α} :
    LeftInverse (map f) (map g) ↔ LeftInverse f g
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem uniformContinuous_dom {f : SeparationQuotient α → β} :
    UniformContinuous f ↔ UniformContinuous (f ∘ mk)
-- Mathlib/Data/List/Basic.lean
theorem takeD_eq_take : ∀ {n} {l : List α} a, n ≤ length l → takeD n l a = take n l
-- Mathlib/Data/PNat/Basic.lean
@[simp, norm_cast]
lemma val_ofNat (n : ℕ) [NeZero n] :
    ((no_index (OfNat.ofNat n) : ℕ+) : ℕ) = OfNat.ofNat n
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- If the `p`-adic norm of `q` is 0, then `q` is `0`. -/
theorem zero_of_padicNorm_eq_zero {q : ℚ} (h : padicNorm p q = 0) : q = 0
-- Mathlib/Data/ULift.lean
@[simp] lemma map_bijective : Bijective (ULift.map f : ULift.{u'} α → ULift.{v'} β) ↔ Bijective f
-- Mathlib/Data/Finsupp/Multiset.lean
/-- The order on `ι →₀ ℕ` is well-founded. -/
theorem lt_wf : WellFounded (@LT.lt (ι →₀ ℕ) _)
-- Mathlib/Logic/Hydra.lean
/-- `CutExpand` preserves leftward-closedness under a relation. -/
lemma cutExpand_closed [IsIrrefl α r] (p : α → Prop)
    (h : ∀ {a' a}, r a' a → p a → p a') :
    ∀ {s' s}, CutExpand r s' s → (∀ a ∈ s, p a) → ∀ a ∈ s', p a
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_eq_iff_mul_self_eq_of_pos (h : 0 < y) : √x = y ↔ y * y = x
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Every coequalizer of `(f, g)`, where `f = g`, is an isomorphism. -/
theorem isIso_colimit_cocone_parallelPair_of_eq (h₀ : f = g) {c : Cofork f g} (h : IsColimit c) :
    IsIso c.π
-- Mathlib/GroupTheory/SpecificGroups/Quaternion.lean
/-- If `0 < n`, then `a i` has order `(2 * n) / gcd (2 * n) i`.
-/
theorem orderOf_a [NeZero n] (i : ZMod (2 * n)) :
    orderOf (a i) = 2 * n / Nat.gcd (2 * n) i.val
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem _root_.MeasureTheory.Integrable.hasSum_intervalIntegral_comp_add_int (hfi : Integrable f) :
    HasSum (fun n : ℤ => ∫ x in (0 : ℝ)..(1 : ℝ), f (x + n)) (∫ x, f x)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.not_isBigO (h : f'' =o[l] g') (hf : ∃ᶠ x in l, f'' x ≠ 0) :
    ¬g' =O[l] f''
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem ofNat_le_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) ≤ lift.{v} a ↔ (OfNat.ofNat n : Cardinal) ≤ a
-- Mathlib/Topology/ContinuousFunction/Weierstrass.lean
/-- The special case of the Weierstrass approximation theorem for the interval `[0,1]`.
This is just a matter of unravelling definitions and using the Bernstein approximations.
-/
theorem polynomialFunctions_closure_eq_top' : (polynomialFunctions I).topologicalClosure = ⊤
-- Mathlib/Data/Set/Semiring.lean
@[simp]
theorem down_one : down (1 : SetSemiring α) = 1
-- Mathlib/Algebra/Algebra/Subalgebra/Prod.lean
@[simp]
theorem coe_prod : (prod S S₁ : Set (A × B)) = (S : Set A) ×ˢ (S₁ : Set B)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma mk_XYIdeal'_mul_mk_XYIdeal' {x₁ x₂ y₁ y₂ : F} (h₁ : W.Nonsingular x₁ y₁)
    (h₂ : W.Nonsingular x₂ y₂) (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    ClassGroup.mk (XYIdeal' h₁) * ClassGroup.mk (XYIdeal' h₂) =
      ClassGroup.mk (XYIdeal' <| nonsingular_add h₁ h₂ hxy)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem comap_inf (s t : Subsemiring S) (f : R →+* S) : (s ⊓ t).comap f = s.comap f ⊓ t.comap f