ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- If the arguments are linearly dependent then the result is `0`. -/
theorem map_linearDependent {K : Type*} [Ring K] {M : Type*} [AddCommGroup M] [Module K M]
    {N : Type*} [AddCommGroup N] [Module K N] [NoZeroSMulDivisors K N] (f : M [⋀^ι]→ₗ[K] N)
    (v : ι → M) (h : ¬LinearIndependent K v) : f v = 0
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
theorem smul_map_volume_mul_right {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (· * a) volume = volume
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[norm_cast] theorem ofNat_add (n m : Nat) : (↑(n + m) : Int) = n + m
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tendsto_add_one_pow_atTop_atTop_of_pos [LinearOrderedSemiring α] [Archimedean α] {r : α}
    (h : 0 < r) : Tendsto (fun n : ℕ ↦ (r + 1) ^ n) atTop atTop
-- Mathlib/Topology/Bases.lean
/-- In a first-countable space, a cluster point `x` of a sequence
is the limit of some subsequence. -/
theorem tendsto_subseq [FirstCountableTopology α] {u : ℕ → α} {x : α}
    (hx : MapClusterPt x atTop u) : ∃ ψ : ℕ → ℕ, StrictMono ψ ∧ Tendsto (u ∘ ψ) atTop (𝓝 x)
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem Surjective.of_comp_iff (f : α → β) {g : γ → α} (hg : Surjective g) :
    Surjective (f ∘ g) ↔ Surjective f
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuous_iInf {f : ι → α → δ} (h : ∀ i, UpperSemicontinuous (f i)) :
    UpperSemicontinuous fun x' => ⨅ i, f i x'
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_filterMap_some_eq_filter_map_is_some (f : α → Option β) (l : List α) :
    (l.filterMap f).map some = (l.map f).filter fun b => b.isSome
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem min_order_le_order_add {Γ} [Zero Γ] [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x + y ≠ 0) : min x.order y.order ≤ (x + y).order
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem flip_apply (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (m : M) (n : N) : flip f n m = f m n
-- Mathlib/LinearAlgebra/Basis/Flag.lean
theorem flag_le_ker_dual (b : Basis (Fin n) R M) (k : Fin n) :
    b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
-- Mathlib/Data/Finset/Lattice.lean
theorem min_eq_inf_withTop (s : Finset α) : s.min = inf s (↑)
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
theorem fst_openEmbedding_of_right_openEmbedding {X Y S : TopCat} (f : X ⟶ S) {g : Y ⟶ S}
    (H : OpenEmbedding g) : OpenEmbedding <| ⇑(pullback.fst f g)
-- Mathlib/Topology/MetricSpace/Algebra.lean
theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
-- Mathlib/Order/WellFounded.lean
private theorem eq_strictMono_iff_eq_range_aux {f g : β → γ} (hf : StrictMono f)
    (hg : StrictMono g) (hfg : Set.range f = Set.range g) {b : β} (H : ∀ a < b, f a = g a) :
    f b ≤ g b
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
protected theorem Finset.multipliable_compl_iff (s : Finset β) :
    (Multipliable fun x : { x // x ∉ s } ↦ f x) ↔ Multipliable f
-- Mathlib/Data/Part.lean
@[simp]
theorem ofOption_dom {α} : ∀ o : Option α, (ofOption o).Dom ↔ o.isSome
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem reverse_reverse (s : Cycle α) : s.reverse.reverse = s
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem polyOfInterest_vars (n : ℕ) : (polyOfInterest p n).vars ⊆ univ ×ˢ range (n + 1)
-- Mathlib/Data/Finset/Sum.lean
@[simp]
theorem map_inl_disjUnion_map_inr :
    (s.map Embedding.inl).disjUnion (t.map Embedding.inr) (disjoint_map_inl_map_inr _ _) =
      s.disjSum t
-- Mathlib/Order/Concept.lean
@[simp]
theorem extentClosure_iUnion (f : ι → Set β) :
    extentClosure r (⋃ i, f i) = ⋂ i, extentClosure r (f i)
-- Mathlib/Analysis/Convex/Star.lean
theorem starConvex_iInter {ι : Sort*} {s : ι → Set E} (h : ∀ i, StarConvex 𝕜 x (s i)) :
    StarConvex 𝕜 x (⋂ i, s i)
-- Mathlib/CategoryTheory/Opposites.lean
/-- Given a natural transformation `α : F.leftOp ⟶ G.leftOp`, for `F G : C ⥤ Dᵒᵖ`,
taking `op` of each component gives a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeLeftOp (α : F.leftOp ⟶ G.leftOp) : G ⟶ F
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Ioo_eq : Ioo a b = (Ioo (a : α) b).subtype p
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
theorem derivativeFun_smul (r : R) (f : R⟦X⟧) : derivativeFun (r • f) = r • derivativeFun f
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
lemma chromaticNumber_eq_card_iff_forall_surjective [Fintype α] (hG : G.Colorable (card α)) :
    G.chromaticNumber = card α ↔ ∀ C : G.Coloring α, Surjective C
-- Mathlib/RingTheory/Localization/Ideal.lean
/-- If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M`.
This lemma gives the particular case for an ideal and its map,
see `le_rel_iso_of_prime` for the more general relation isomorphism, and the reverse implication -/
theorem isPrime_of_isPrime_disjoint (I : Ideal R) (hp : I.IsPrime) (hd : Disjoint (M : Set R) ↑I) :
    (Ideal.map (algebraMap R S) I).IsPrime
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
theorem nonneg (x : ℝ) : 0 ≤ smoothTransition x
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
@[simp]
theorem sum_affineCombinationLineMapWeights [DecidableEq ι] {i j : ι} (hi : i ∈ s) (hj : j ∈ s)
    (c : k) : ∑ t ∈ s, affineCombinationLineMapWeights i j c t = 1
-- Mathlib/Data/Nat/Choose/Multinomial.lean
/-- The **multinomial theorem**. -/
theorem sum_pow_of_commute [Semiring R] (x : α → R) (s : Finset α)
    (hc : (s : Set α).Pairwise fun i j => Commute (x i) (x j)) :
    ∀ n,
      s.sum x ^ n =
        ∑ k : s.sym n,
          k.1.1.multinomial *
            (k.1.1.map <| x).noncommProd
              (Multiset.map_set_pairwise <| hc.mono <| mem_sym_iff.1 k.2)
-- Mathlib/NumberTheory/Divisors.lean
lemma one_lt_of_mem_properDivisors {m n : ℕ} (h : m ∈ n.properDivisors) : 1 < n
-- Mathlib/Data/Rat/Defs.lean
lemma natCast_injective : Injective (Nat.cast : ℕ → ℚ)
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@[simp, mfld_simps]
theorem trivializationAt_target (x : M) :
    (trivializationAt E (TangentSpace I) x).target = (chartAt H x).source ×ˢ univ
-- Mathlib/Order/RelSeries.lean
@[simp] lemma head_cons (p : RelSeries r) (newHead : α) (rel : r newHead p.head) :
    (p.cons newHead rel).head = newHead
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem leadingCoeff_zero : leadingCoeff (0 : HahnSeries Γ R) = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem coe_toOrderIso_symm (f : CircleDeg1Liftˣ) :
    ⇑(toOrderIso f).symm = (f⁻¹ : CircleDeg1Liftˣ)
-- Mathlib/Analysis/Convex/Strong.lean
lemma UniformConcaveOn.mono (hψφ : ψ ≤ φ) (hf : UniformConcaveOn s φ f) : UniformConcaveOn s ψ f
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_ne_zero (h : 0 ≤ x) : √x ≠ 0 ↔ x ≠ 0
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma obj_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) : obj F X ⟨i + 1, hi⟩ = F.obj' i
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma le_algebraMap_of_spectrum_le {r : R} {a : A} (h : ∀ x ∈ spectrum R a, x ≤ r)
    (ha : p a := by cfc_tac) : a ≤ algebraMap R A r
-- Mathlib/Analysis/Convex/Combination.lean
/-- A refinement of `Finset.centerMass_mem_convexHull` when the indexed family is a `Finset` of
the space. -/
theorem Finset.centerMass_id_mem_convexHull (t : Finset E) {w : E → R} (hw₀ : ∀ i ∈ t, 0 ≤ w i)
    (hws : 0 < ∑ i ∈ t, w i) : t.centerMass w id ∈ convexHull R (t : Set E)
-- Mathlib/Algebra/Module/LocalizedModuleIntegers.lean
theorem finsetIntegerMultiple_image [DecidableEq M] (s : Finset M') :
    f '' finsetIntegerMultiple S f s = commonDenomOfFinset S f s • (s : Set M')
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_sub' (a b : α) : toIcoMod hp (a - p) b = toIcoMod hp a b - p
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
theorem prod_insert [DecidableEq α] : a ∉ s → ∏ x ∈ insert a s, f x = f a * ∏ x ∈ s, f x
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.congr_left (h : f₁ =o[l] g) (hf : ∀ x, f₁ x = f₂ x) : f₂ =o[l] g
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma Even.pow_pos (hn : Even n) (ha : a ≠ 0) : 0 < a ^ n
-- Mathlib/AlgebraicTopology/TopologicalSimplex.lean
@[simp]
theorem coe_toTopMap {x y : SimplexCategory} (f : x ⟶ y) (g : x.toTopObj) (i : y) :
    toTopMap f g i = ∑ j ∈ Finset.univ.filter (f · = i), g j
-- Mathlib/Topology/Bornology/Basic.lean
theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
    IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i)
-- Mathlib/Data/Set/Function.lean
protected theorem _root_.StrictMonoOn.strictMono (h : StrictMonoOn f s) :
    StrictMono (f ∘ Subtype.val : s → β)
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem leadingCoeff_eraseLead_eq_nextCoeff (h : f.nextCoeff ≠ 0) :
    f.eraseLead.leadingCoeff = f.nextCoeff
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem tsum_coe (p : PMF α) : ∑' a, p a = 1
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem curryFinFinset_apply {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l)
    (f : MultilinearMap R (fun _ : Fin n => M') M₂) (mk : Fin k → M') (ml : Fin l → M') :
    curryFinFinset R M₂ M' hk hl f mk ml =
      f fun i => Sum.elim mk ml ((finSumEquivOfFinset hk hl).symm i)
-- Mathlib/Data/Setoid/Basic.lean
/-- The infimum of 2 equivalence relations r and s is the same relation as the infimum
    of the underlying binary operations. -/
theorem inf_def {r s : Setoid α} : (r ⊓ s).Rel = r.Rel ⊓ s.Rel
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- Given a tower of scalar actions `M → α → β`, if we use `SMul.comp`
to pull back both of `M`'s actions by a map `g : N → M`, then we obtain a new
tower of scalar actions `N → α → β`.

This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables. -/
@[to_additive
"Given a tower of additive actions `M → α → β`, if we use `SMul.comp` to pull back both of
`M`'s actions by a map `g : N → M`, then we obtain a new tower of scalar actions `N → α → β`.

This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables."]
lemma comp.isScalarTower [SMul M β] [SMul α β] [IsScalarTower M α β] (g : N → M) : by
    haveI := comp α g; haveI := comp β g; exact IsScalarTower N α β
-- Mathlib/Algebra/BigOperators/Pi.lean
@[to_additive prod_mk_sum]
theorem prod_mk_prod {α β γ : Type*} [CommMonoid α] [CommMonoid β] (s : Finset γ) (f : γ → α)
    (g : γ → β) : (∏ x ∈ s, f x, ∏ x ∈ s, g x) = ∏ x ∈ s, (f x, g x)
-- Mathlib/SetTheory/Game/Ordinal.lean
@[simp]
theorem toPGame_lt_iff {a b : Ordinal} : a.toPGame < b.toPGame ↔ a < b
-- Mathlib/RingTheory/Localization/Basic.lean
theorem add_mk_self (a b c) : (mk a b : Localization M) + mk c b = mk (a + c) b
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_norm_eq_pos_sub_neg {f : X → ℝ} (hfi : Integrable f μ) :
    ∫ x, ‖f x‖ ∂μ = ∫ x in {x | 0 ≤ f x}, f x ∂μ - ∫ x in {x | f x ≤ 0}, f x ∂μ
-- Mathlib/Order/Max.lean
theorem NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_ge_atTop : (atTop : Filter α).IsBounded (· ≥ ·)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma baseChange_addPolynomial (x y L : A) :
    (W.baseChange B).toAffine.addPolynomial (f x) (f y) (f L) =
      ((W.baseChange A).toAffine.addPolynomial x y L).map f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem dvd_antisymm {a b : Ordinal} (h₁ : a ∣ b) (h₂ : b ∣ a) : a = b
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem HasFDerivAt.fderiv (h : HasFDerivAt f f' x) : fderiv 𝕜 f x = f'
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem lift_self_apply [PerfectRing L p] (x : L) : lift i i p x = x
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.toNat_add (x y : UInt8) : (x + y).toNat = (x.toNat + y.toNat) % UInt8.size
-- Mathlib/GroupTheory/Commutator.lean
theorem commutator_prod_prod (K₁ K₂ : Subgroup G') :
    ⁅H₁.prod K₁, H₂.prod K₂⁆ = ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
@[simp]
theorem GradedAlgebra.proj_apply (i : ι) (r : A) :
    GradedAlgebra.proj 𝒜 i r = (decompose 𝒜 r : ⨁ i, 𝒜 i) i
-- Mathlib/RingTheory/FiniteType.lean
protected theorem polynomial : FiniteType R R[X]
-- Mathlib/Order/Filter/Extr.lean
theorem isMinOn_dual_iff : IsMinOn (toDual ∘ f) s a ↔ IsMaxOn f s a
-- Mathlib/RingTheory/PrimeSpectrum.lean
@[simp]
theorem zeroLocus_singleton_one : zeroLocus ({1} : Set R) = ∅
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square with `0 : 0 ⟶ 0` on the right and `𝟙 X` on the left is a pushout square. -/
@[simp]
theorem zero_right (X : C) : IsPushout (0 : X ⟶ 0) (𝟙 X) (0 : (0 : C) ⟶ 0) (0 : X ⟶ 0)
-- Mathlib/Analysis/Fourier/RiemannLebesgueLemma.lean
/-- The Riemann-Lebesgue lemma, formulated in terms of `VectorFourier.fourierIntegral` (with the
pairing in the definition of `fourier_integral` taken to be the canonical pairing between `V` and
its dual space). -/
theorem Real.zero_at_infty_vector_fourierIntegral (μ : Measure V) [μ.IsAddHaarMeasure] :
    Tendsto (VectorFourier.fourierIntegral 𝐞 μ (topDualPairing ℝ V).flip f) (cocompact (V →L[ℝ] ℝ))
      (𝓝 0)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem atTop_finset_eq_iInf : (atTop : Filter (Finset α)) = ⨅ x : α, 𝓟 (Ici {x})
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
@[simp]
theorem flip_separatingLeft {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.flip.SeparatingLeft ↔ SeparatingRight B
-- Mathlib/Order/Iterate.lean
theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k < n, x (k + 1) ≤ f (x k))
    (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem algebraMap_exp_comm (x : 𝕂) : algebraMap 𝕂 𝔸 (exp 𝕂 x) = exp 𝕂 (algebraMap 𝕂 𝔸 x)
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem not_mem_nil : ∀ a, a ∉ @nil α
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesOnBall.mono (hf : HasFPowerSeriesOnBall f p x r) (r'_pos : 0 < r')
    (hr : r' ≤ r) : HasFPowerSeriesOnBall f p x r'
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- If an affine subspace contains a set of points, it contains the `spanPoints` of that set. -/
theorem spanPoints_subset_coe_of_subset_coe {s : Set P} {s1 : AffineSubspace k P} (h : s ⊆ s1) :
    spanPoints k s ⊆ s1
-- Mathlib/Dynamics/PeriodicPts.lean
theorem minimalPeriod_apply_iterate (hx : x ∈ periodicPts f) (n : ℕ) :
    minimalPeriod f (f^[n] x) = minimalPeriod f x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- A nonzero vector equals a rotation of that vector if and only if the angle is zero. -/
@[simp]
theorem eq_rotation_self_iff_angle_eq_zero {x : V} (hx : x ≠ 0) (θ : Real.Angle) :
    x = o.rotation θ x ↔ θ = 0
-- Mathlib/Data/List/TFAE.lean
theorem TFAE.out {l} (h : TFAE l) (n₁ n₂) {a b} (h₁ : List.get? l n₁ = some a := by rfl)
    (h₂ : List.get? l n₂ = some b := by rfl) : a ↔ b
-- Mathlib/Analysis/Convex/Deriv.lean
theorem StrictMonoOn.exists_slope_lt_deriv {x y : ℝ} {f : ℝ → ℝ} (hf : ContinuousOn f (Icc x y))
    (hxy : x < y) (hf'_mono : StrictMonoOn (deriv f) (Ioo x y)) :
    ∃ a ∈ Ioo x y, (f y - f x) / (y - x) < deriv f a
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem skeletalFunctor.coe_map {Δ₁ Δ₂ : SimplexCategory} (f : Δ₁ ⟶ Δ₂) :
    ↑(skeletalFunctor.map f) = f.toOrderHom
-- Mathlib/Order/OmegaCompletePartialOrder.lean
@[simps! ωSup_fst ωSup_snd]
instance : OmegaCompletePartialOrder (α × β)
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/--
The closure of a singleton `{a}` in the upper topology is the left-infinite right-closed interval
(-∞,a].
-/
@[simp]
theorem closure_singleton (a : α) : closure {a} = Iic a
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integrable_mul_cexp_neg_mul_sq {b : ℂ} (hb : 0 < b.re) :
    Integrable fun x : ℝ => ↑x * cexp (-b * (x : ℂ) ^ 2)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[elab_as_elim]
protected theorem inductionOn₂
    {motive : Quotient s₁ → Quotient s₂ → Prop}
    (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    (h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
    : motive q₁ q₂
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If a function is `C^n` with `1 ≤ n`, then the derivative of `f` is also a strict derivative. -/
theorem ContDiff.hasStrictDerivAt {f : 𝕂 → F'} {x : 𝕂} (hf : ContDiff 𝕂 n f) (hn : 1 ≤ n) :
    HasStrictDerivAt f (deriv f x) x
-- Mathlib/Logic/Basic.lean
theorem not_or_of_imp : (a → b) → ¬a ∨ b
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- If `K` is a complete subset, then any cauchy sequence in `K` converges to a point in `K` -/
theorem cauchySeq_tendsto_of_isComplete [Preorder β] {K : Set α} (h₁ : IsComplete K)
    {u : β → α} (h₂ : ∀ n, u n ∈ K) (h₃ : CauchySeq u) : ∃ v ∈ K, Tendsto u atTop (𝓝 v)
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem length_nil : length (@nil α) = 0
-- Mathlib/Order/Interval/Set/ProjIcc.lean
protected theorem Monotone.IciExtend {f : Ici a → β} (hf : Monotone f) : Monotone (IciExtend f)
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
/-- Distance from the center of an inversion to the image of a point under the inversion. This
formula accidentally works for `x = c`. -/
theorem dist_center_inversion (c x : P) (R : ℝ) : dist c (inversion c R x) = R ^ 2 / dist c x
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
theorem trunc_derivativeFun (f : R⟦X⟧) (n : ℕ) :
    trunc n f.derivativeFun = derivative (trunc (n + 1) f)
-- Mathlib/Data/ENNReal/Operations.lean
/-- A sum of finite numbers is still finite -/
theorem sum_lt_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ∞) : ∑ a ∈ s, f a < ∞
-- Mathlib/GroupTheory/Subgroup/Center.lean
@[to_additive]
theorem mem_center_iff {z : G} : z ∈ center G ↔ ∀ g, g * z = z * g
-- Mathlib/Data/Matroid/Basic.lean
@[aesop unsafe 30% (rule_sets := [Matroid])]
theorem Indep.subset_ground (hI : M.Indep I) : I ⊆ M.E
-- Mathlib/Topology/Basic.lean
theorem Filter.HasBasis.lift'_interior_eq_self {l : Filter X} {p : ι → Prop} {s : ι → Set X}
    (h : l.HasBasis p s) (ho : ∀ i, p i → IsOpen (s i)) : l.lift' interior = l
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_toFinset {a : α} {s : Multiset α} : a ∈ s.toFinset ↔ a ∈ s
-- Mathlib/Data/Sign.lean
theorem nonpos_iff {a : SignType} : a ≤ 0 ↔ a = -1 ∨ a = 0
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem zero_rpow_def (y : ℝ) : (0 : ℝ≥0∞) ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
nonrec theorem ContMDiffAt.prod_mk_space {f : M → E'} {g : M → F'}
    (hf : ContMDiffAt I 𝓘(𝕜, E') n f x) (hg : ContMDiffAt I 𝓘(𝕜, F') n g x) :
    ContMDiffAt I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) x
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive neg.instNeBot]
lemma inv.instNeBot [NeBot f] : NeBot f⁻¹
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean
theorem map_nhds_eq_of_surj [CompleteSpace E] [CompleteSpace F] {f : E → F} {f' : E →L[𝕜] F} {a : E}
    (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) (h : LinearMap.range f' = ⊤) :
    map f (𝓝 a) = 𝓝 (f a)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem toENNRealVectorMeasure_add (μ ν : Measure α) :
    (μ + ν).toENNRealVectorMeasure = μ.toENNRealVectorMeasure + ν.toENNRealVectorMeasure
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
/--
(Implementation). The maps given in `appIso` is inverse to each other and gives a `ℱ(X) ≅ ℱ'(X)`.
-/
@[simps]
noncomputable def appIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val)
    (X : D) : ℱ.val.obj (op X) ≅ ℱ'.val.obj (op X)
-- Mathlib/Data/List/Iterate.lean
@[simp]
theorem getElem_iterate (f : α → α) (a : α) (n : ℕ) (i : Nat) (h : i < (iterate f a n).length) :
    (iterate f a n)[i] = f^[↑i] a
-- Mathlib/Algebra/Algebra/Opposite.lean
theorem toRingEquiv_unop (f : Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) :
    (AlgEquiv.unop f).toRingEquiv = RingEquiv.unop f.toRingEquiv
-- Mathlib/Data/Matrix/RowCol.lean
@[simp] theorem col_eq_zero [Zero α] [Nonempty ι] (v : m → α) : col ι v = 0 ↔ v = 0
-- Mathlib/MeasureTheory/Constructions/HaarToSphere.lean
lemma volumeIoiPow_apply_Iio (n : ℕ) (x : Ioi (0 : ℝ)) :
    volumeIoiPow n (Iio x) = ENNReal.ofReal (x.1 ^ (n + 1) / (n + 1))
-- Mathlib/RingTheory/PowerBasis.lean
theorem mem_span_pow' {x y : S} {d : ℕ} :
    y ∈ Submodule.span R (Set.range fun i : Fin d => x ^ (i : ℕ)) ↔
      ∃ f : R[X], f.degree < d ∧ y = aeval x f
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma coe_covBy_coe : (s : Set α) ⋖ t ↔ s ⋖ t
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma weightSpace_zsmul_add_ne_bot {n : ℤ}
    (hn : -chainBotCoeff α β ≤ n) (hn' : n ≤ chainTopCoeff α β) :
      weightSpace M (n • α + β : L → R) ≠ ⊥
-- Mathlib/ModelTheory/Fraisse.lean
theorem Hereditary.is_equiv_invariant_of_fg (h : Hereditary K)
    (fg : ∀ M : Bundled.{w} L.Structure, M ∈ K → Structure.FG L M) (M N : Bundled.{w} L.Structure)
    (hn : Nonempty (M ≃[L] N)) : M ∈ K ↔ N ∈ K
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_of_mem_nhds (h : s ∈ 𝓝 x) : fderivWithin 𝕜 f s x = fderiv 𝕜 f x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] protected theorem zero_add (x : BitVec n) : 0#n + x = x
-- Mathlib/Order/RelIso/Basic.lean
/-- A relation isomorphism between equal relations on equal types. -/
@[simps! toEquiv apply]
protected def cast {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} (h₁ : α = β)
    (h₂ : HEq r s) : r ≃r s
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_self (ha : 0 ≤ a) (hb : 1 ≤ b) : a / b ≤ a
-- Mathlib/Data/Multiset/FinsetOps.lean
@[simp]
theorem ndinsert_of_not_mem {a : α} {s : Multiset α} : a ∉ s → ndinsert a s = a ::ₘ s
-- Mathlib/Data/Finset/Interval.lean
/-- A function `f` from `Finset α` is strictly monotone if and only if `f s < f (insert a s)` for
all `s` and `a ∉ s`. -/
lemma strictMono_iff_forall_lt_insert : StrictMono f ↔ ∀ s ⦃a⦄, a ∉ s → f s < f (insert a s)
-- Mathlib/Data/ENat/Lattice.lean
@[simp]
lemma iInf_eq_top_of_isEmpty [IsEmpty ι] : ⨅ i, (f i : ℕ∞) = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem length_eq_lengthTR : @List.length = @List.lengthTR
-- Mathlib/Computability/TMToPartrec.lean
theorem K'.elim_stack (a b c d) : K'.elim a b c d K'.stack = d
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
theorem den_mem (f : HomogeneousLocalization 𝒜 x) : f.den ∈ x
-- Mathlib/RingTheory/Idempotents.lean
/-- A family of orthogonal idempotents induces an surjection `R ≃+* ∏ R ⧸ ⟨1 - eᵢ⟩` -/
lemma OrthogonalIdempotents.surjective_pi {I : Type*} [Finite I] {e : I → R}
    (he : OrthogonalIdempotents e) :
    Function.Surjective (Pi.ringHom fun i ↦ Ideal.Quotient.mk (Ideal.span {1 - e i}))
-- Mathlib/Algebra/Module/Submodule/Bilinear.lean
@[simp]
theorem map₂_bot_left (f : M →ₗ[R] N →ₗ[R] P) (q : Submodule R N) : map₂ f ⊥ q = ⊥
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem rightInvOn : RightInvOn e.symm e e.target
-- Mathlib/Order/Interval/Finset/Fin.lean
@[simp]
theorem card_Ico : (Ico a b).card = b - a
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffAt.prod_map' {p : M × N} (hf : ContMDiffAt I I' n f p.1)
    (hg : ContMDiffAt J J' n g p.2) : ContMDiffAt (I.prod J) (I'.prod J') n (Prod.map f g) p
-- Mathlib/Data/Set/Function.lean
protected lemma SurjOn.extendDomain (h : SurjOn g s t) :
    SurjOn (g.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t)
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem card_roots_le [IsDomain R] [DecidableEq R] : P.roots.toFinset.card ≤ 3
-- Mathlib/Data/List/Sort.lean
/-- For an antisymmetric relation, erasing then inserting is the identity. -/
theorem orderedInsert_erase [DecidableEq α] [IsAntisymm α r] (x : α) (xs : List α) (hx : x ∈ xs)
    (hxs : Sorted r xs) :
    (xs.erase x).orderedInsert r x = xs
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem star_one [MulOneClass R] [StarMul R] : star (1 : R) = 1
-- Mathlib/Data/Int/ModEq.lean
theorem modEq_add_fac_self {a t n : ℤ} : a + n * t ≡ a [ZMOD n]
-- Mathlib/Analysis/BoxIntegral/Partition/Additive.lean
theorem coe_injective : Injective fun (f : ι →ᵇᵃ[I₀] M) x => f x