ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
lemma shiftIso_add'_inv_app (n m mn : A) (hnm : m + n = mn) (a a' a'' : A)
    (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).inv.app X =
        (F.shiftIso n a a' ha').inv.app X ≫
        ((F.shiftIso m a' a'' ha'').inv.app X)⟦n⟧' ≫
      (shiftFunctorAdd' D m n mn hnm).inv.app ((F.functor a'').obj X)
-- Mathlib/Analysis/Normed/Group/Quotient.lean
/-- The quotient norm of `0` is `0`. -/
theorem norm_mk_zero (S : AddSubgroup M) : ‖(0 : M ⧸ S)‖ = 0
-- Mathlib/Algebra/Polynomial/Splits.lean
/-- A polynomial splits if and only if it has as many roots as its degree. -/
theorem splits_iff_card_roots {p : K[X]} :
    Splits (RingHom.id K) p ↔ Multiset.card p.roots = p.natDegree
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
lemma card_le_chromaticNumber_iff_forall_surjective [Fintype α] :
    card α ≤ G.chromaticNumber ↔ ∀ C : G.Coloring α, Surjective C
-- Mathlib/Analysis/NormedSpace/ENorm.lean
/-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The position of the orthocenter in relation to the circumcenter
and centroid. -/
theorem orthocenter_eq_smul_vsub_vadd_circumcenter (t : Triangle ℝ P) :
    t.orthocenter =
      (3 : ℝ) • ((univ : Finset (Fin 3)).centroid ℝ t.points -ᵥ t.circumcenter : V) +ᵥ
        t.circumcenter
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
protected theorem LocallyIntegrableOn.add
    (hf : LocallyIntegrableOn f s μ) (hg : LocallyIntegrableOn g s μ) :
    LocallyIntegrableOn (f + g) s μ
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The inverse of `rotation` is rotation by the negation of the angle. -/
@[simp]
theorem rotation_symm (θ : Real.Angle) : (o.rotation θ).symm = o.rotation (-θ)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- Generalized eigenspaces for exponents at least `finrank K V` are equal to each other. -/
theorem genEigenspace_eq_genEigenspace_finrank_of_le [FiniteDimensional K V]
    (f : End K V) (μ : K) {k : ℕ} (hk : finrank K V ≤ k) :
    f.genEigenspace μ k = f.genEigenspace μ (finrank K V)
-- Mathlib/Computability/Halting.lean
theorem computable_iff_re_compl_re {p : α → Prop} [DecidablePred p] :
    ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a
-- Mathlib/Topology/ContinuousFunction/Units.lean
@[to_additive (attr := simp)]
lemma unitsLift_symm_apply_apply_inv' (f : C(X, M)ˣ) (x : X) :
    (ContinuousMap.unitsLift.symm f x)⁻¹ = (↑f⁻¹ : C(X, M)) x
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem mk_coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
    (he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    (b, a.coordChange he he' b v) = e' ⟨b, e.symm b v⟩
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableWithinAt_const_sub_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c - f y) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Data/Finset/Basic.lean
theorem le_iff_subset {s₁ s₂ : Finset α} : s₁ ≤ s₂ ↔ s₁ ⊆ s₂
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_congr_ae (h : f =ᵐ[μ] g) : μ[f|m] =ᵐ[μ] μ[g|m]
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive]
lemma mabs_div_sup_mul_mabs_div_inf (a b c : α) :
    |(a ⊔ c) / (b ⊔ c)|ₘ * |(a ⊓ c) / (b ⊓ c)|ₘ = |a / b|ₘ
-- Mathlib/Data/Nat/Lattice.lean
theorem nonempty_of_pos_sInf {s : Set ℕ} (h : 0 < sInf s) : s.Nonempty
-- Mathlib/Data/Real/Archimedean.lean
theorem sSup_def (S : Set ℝ) :
    sSup S = if h : S.Nonempty ∧ BddAbove S then Classical.choose (exists_isLUB h.1 h.2) else 0
-- Mathlib/Topology/Algebra/Affine.lean
theorem homothety_isOpenMap (x : F) (t : R) (ht : t ≠ 0) : IsOpenMap <| homothety x t
-- Mathlib/Algebra/Order/Monovary.lean
lemma antivary_iff_forall_smul_nonpos : Antivary f g ↔ ∀ i j, (f j - f i) • (g j - g i) ≤ 0
-- Mathlib/Topology/Basic.lean
theorem AccPt.clusterPt (x : X) (F : Filter X) (h : AccPt x F) : ClusterPt x F
-- Mathlib/NumberTheory/LSeries/Linearity.lean
lemma LSeries.term_sub (f g : ℕ → ℂ) (s : ℂ) : term (f - g) s = term f s - term g s
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma sq_lt_sq : a ^ 2 < b ^ 2 ↔ |a| < |b|
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem Sentence.realize_not {φ : L.Sentence} : M ⊨ φ.not ↔ ¬M ⊨ φ
-- Mathlib/Deprecated/Subgroup.lean
theorem Multiplicative.isSubgroup_iff {s : Set A} :
    @IsSubgroup (Multiplicative A) _ s ↔ IsAddSubgroup s
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₂ y) :
    Tendsto f (x₁ ⊓ x₂) y
-- Mathlib/Algebra/Star/Subalgebra.lean
protected theorem gc : GaloisConnection (adjoin R : Set A → StarSubalgebra R A) (↑)
-- Mathlib/AlgebraicTopology/CechNerve.lean
/-- The morphism between Čech nerves associated to a morphism of arrows. -/
@[simps]
def mapCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.cechNerve ⟶ g.cechNerve
-- Mathlib/Order/Interval/Set/Image.lean
private lemma image_subtype_val_Ixx_Iix {p q r : α → α → Prop} {a b : α} (c : {x // p a x ∧ q x b})
    (h : ∀ {x}, r x c → q x b) :
    Subtype.val '' {y : {x // p a x ∧ q x b} | r y.1 c.1} = {y : α | p a y ∧ r y c.1}
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma isPiSystem (hC : IsSetSemiring C) : IsPiSystem C
-- Mathlib/Tactic/LinearCombination.lean
theorem c_div_pf [Div α] (p : b = c) (a : α) : a / b = a / c
-- Mathlib/Data/Finset/Card.lean
/-- Specialization of `Finset.card_nbij'` that automatically fills in most arguments.

See `Fintype.card_equiv` for the version where `s` and `t` are `univ`. -/
lemma card_equiv (e : α ≃ β) (hst : ∀ i, i ∈ s ↔ e i ∈ t) : s.card = t.card
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_at_zero : p.eval₂ f 0 = f (coeff p 0)
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem conj_conj (z : 𝔻) : conj (conj z) = z
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem algebraMap_eq_inl : ⇑(algebraMap R (Unitization R A)) = inl
-- Mathlib/Data/Matroid/Basic.lean
theorem indep_of_forall_finite_subset_indep {M : Matroid α} [Finitary M] (I : Set α)
    (h : ∀ J, J ⊆ I → J.Finite → M.Indep J) : M.Indep I
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyEq.sup [Sup β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
    (hg : g =ᶠ[l] g') : (fun x => f x ⊔ g x) =ᶠ[l] fun x => f' x ⊔ g' x
-- Mathlib/Analysis/Calculus/LogDeriv.lean
@[simp] theorem logDeriv_id' (x : 𝕜) : logDeriv (·) x = 1 / x
-- Mathlib/Order/Interval/Multiset.lean
theorem Ico_add_Ico_eq_Ico {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) :
    Ico a b + Ico b c = Ico a c
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive AddCommute.zsmul_add]
protected lemma mul_zpow (h : Commute a b) : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
-- Mathlib/Order/CompleteLattice.lean
lemma sSup_prod [SupSet α] [SupSet β] {s : Set α} {t : Set β} (hs : s.Nonempty) (ht : t.Nonempty) :
    sSup (s ×ˢ t) = (sSup s, sSup t)
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.tendsto_atTop_one {f : α → ℚ → ℝ} (hf : IsMeasurableRatCDF f) (a : α) :
    Tendsto (f a) atTop (𝓝 1)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_union_Icc' (h₁ : c ≤ b) (h₂ : a ≤ d) : Icc a b ∪ Icc c d = Icc (min a c) (max b d)
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `LocallyConstant.comap` as a linear map. -/
@[simps!]
def comapₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) :
    LocallyConstant Y Z →ₗ[R] LocallyConstant X Z
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum₂_with_one (x : α) (n : ℕ) :
    ∑ i ∈ range n, x ^ i * 1 ^ (n - 1 - i) = ∑ i ∈ range n, x ^ i
-- Mathlib/Data/DFinsupp/NeLocus.lean
theorem subset_mapRange_neLocus [∀ a, DecidableEq (N a)] [∀ a, DecidableEq (M a)] (f g : Π₀ a, N a)
    {F : ∀ a, N a → M a} (F0 : ∀ a, F a 0 = 0) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) ⊆ f.neLocus g
-- Mathlib/Order/Fin/Tuple.lean
@[simp] lemma strictMono_vecCons : StrictMono (vecCons a f) ↔ a < f 0 ∧ StrictMono f
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem ofReal_tan_ofReal_re (x : ℝ) : ((tan x).re : ℂ) = tan x
-- Mathlib/Data/Nat/Cast/Prod.lean
@[simp]
theorem fst_natCast (n : ℕ) : (n : α × β).fst = n
-- Mathlib/Topology/Instances/Irrational.lean
theorem eventually_residual_irrational : ∀ᶠ x in residual ℝ, Irrational x
-- Mathlib/Order/Filter/CountableInter.lean
@[simp]
theorem Filter.mem_ofCountableInter {l : Set (Set α)}
    (hl : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l) (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l)
    {s : Set α} : s ∈ Filter.ofCountableInter l hl h_mono ↔ s ∈ l
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_group_smul_right : IsCoprime y (x • z) ↔ IsCoprime y z
-- Mathlib/Topology/Semicontinuous.lean
theorem IsClosed.lowerSemicontinuousWithinAt_indicator (hs : IsClosed s) (hy : y ≤ 0) :
    LowerSemicontinuousWithinAt (indicator s fun _x => y) t x
-- Mathlib/Algebra/Order/CauSeq/BigOperators.lean
lemma of_abv_le (n : ℕ) (hm : ∀ m, n ≤ m → abv (f m) ≤ a m) :
    IsCauSeq abs (fun n ↦ ∑ i ∈ range n, a i) → IsCauSeq abv fun n ↦ ∑ i ∈ range n, f i
-- Mathlib/Probability/Kernel/Basic.lean
theorem sum_apply [Countable ι] (κ : ι → Kernel α β) (a : α) :
    Kernel.sum κ a = Measure.sum fun n => κ n a
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma ih1 (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) : IH1 x y
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[reassoc]
lemma L₀X₂ToP_comp_pullback_snd : S.L₀X₂ToP ≫ pullback.snd _ _ = S.L₀.g
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem gcd_cons (a : α) (s : Multiset α) : (a ::ₘ s).gcd = GCDMonoid.gcd a s.gcd
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_biUnion {t : Set β} {s : β → Set α} (ht : t.Countable)
    (hm : ∀ i ∈ t, MeasurableSet (s i)) (hd : t.PairwiseDisjoint s) (f : α → ℝ≥0∞) :
    ∫⁻ a in ⋃ i ∈ t, s i, f a ∂μ = ∑' i : t, ∫⁻ a in s i, f a ∂μ
-- Mathlib/Order/Max.lean
@[simp]
theorem not_isMin_of_lt (h : b < a) : ¬IsMin a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_sSup (s : Set G.Subgraph) (v : V) :
    (sSup s).neighborSet v = ⋃ G' ∈ s, neighborSet G' v
-- Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean
@[to_additive le_sum_of_subadditive]
lemma le_prod_of_submultiplicative (f : α → β) (h_one : f 1 = 1)
    (h_mul : ∀ a b, f (a * b) ≤ f a * f b) (s : Multiset α) : f s.prod ≤ (s.map f).prod
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.fromCostructuredArrow (F : J ⥤ C) : CostructuredArrow (const J) F ⥤ Cone F
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
lemma of_isPullback {UX UY : Scheme.{u}} {iY : UY ⟶ Y} [IsOpenImmersion iY]
    {iX : UX ⟶ X} {f' : UX ⟶ UY} (h : IsPullback iX f' f iY) (H : P f) : P f'
-- Mathlib/Order/Filter/Basic.lean
@[mono, gcongr]
theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f₁ ≤ join f₂
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
lemma isoZeroCocycles_hom_comp_subtype :
    (isoZeroCocycles A).hom ≫ A.ρ.invariants.subtype =
      iCocycles A 0 ≫ (zeroCochainsLequiv A).toModuleIso.hom
-- Mathlib/Probability/Independence/Basic.lean
theorem Indep.indepSet_of_measurableSet
    (h_indep : Indep m₁ m₂ μ) {s t : Set Ω} (hs : MeasurableSet[m₁] s) (ht : MeasurableSet[m₂] t) :
    IndepSet s t μ
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem commute_sub_nat (n : ℕ) : Function.Commute f (· - n)
-- Mathlib/Order/Minimal.lean
theorem RelEmbedding.inter_preimage_maximals_eq_of_subset {y : Set β} {x : Set α}
    (f : r ↪r s) (h : y ⊆ f '' x) : x ∩ f ⁻¹' (maximals s y) = maximals r (x ∩ f ⁻¹' y)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
nonrec theorem norm_integral_le_of_norm_le {g : ℝ → ℝ} (h : ∀ᵐ t ∂μ.restrict <| Ι a b, ‖f t‖ ≤ g t)
    (hbound : IntervalIntegrable g μ a b) : ‖∫ t in a..b, f t ∂μ‖ ≤ |∫ t in a..b, g t ∂μ|
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem maybeNormalize_eq {num den g} (den_nz reduced) :
    maybeNormalize num den g den_nz reduced =
    { num := num.div g, den := den / g, den_nz, reduced }
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyEq.fun_comp {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g) (h : β → γ) :
    h ∘ f =ᶠ[l] h ∘ g
-- Mathlib/Topology/Constructions.lean
@[simp]
theorem inducing_const_prod {x : X} {f : Y → Z} : (Inducing fun x' => (x, f x')) ↔ Inducing f
-- Mathlib/RingTheory/Localization/Module.lean
theorem Basis.localizationLocalization_span {ι : Type*} (b : Basis ι R A) :
    Submodule.span R (Set.range (b.localizationLocalization Rₛ S Aₛ)) =
      LinearMap.range (IsScalarTower.toAlgHom R A Aₛ)
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem coe_mk {f} {h} : ⇑(⟨f, h⟩ : r ↪r s) = f
-- Mathlib/Data/Nat/Log.lean
@[simp] lemma log_zero_left : ∀ n, log 0 n = 0
-- Mathlib/Order/Filter/Archimedean.lean
theorem Tendsto.atTop_zsmul_neg_const {f : α → ℤ} (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atBot
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem maximum?_eq_some_iff' {xs : List Nat} :
    xs.maximum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, b ≤ a)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem exists_cons_of_length_eq_add_one :
    ∀ {l : List α}, l.length = n + 1 → ∃ h t, l = h :: t
-- Mathlib/MeasureTheory/Function/UnifTight.lean
protected theorem sub (hf : UnifTight f p μ) (hg : UnifTight g p μ)
    (hf_meas : ∀ i, AEStronglyMeasurable (f i) μ) (hg_meas : ∀ i, AEStronglyMeasurable (g i) μ) :
    UnifTight (f - g) p μ
-- Mathlib/CategoryTheory/Localization/Resolution.lean
/-- The type of morphisms in the category `Φ.LeftResolution X₂` (when `W₁` is multiplicative). -/
@[ext]
structure Hom (L L' : Φ.LeftResolution X₂) where
  /-- a morphism in the source category -/
  f : L.X₁ ⟶ L'.X₁
  hf : W₁ f
  comm : Φ.functor.map f ≫ L'.w = L.w := by aesop_cat
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_subset_singleton' {f : α →₀ M} {a : α} : f.support ⊆ {a} ↔ ∃ b, f = single a b
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_singleton_left : image2 f {a} t = f a '' t
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_le_inv_iff : 1 ≤ a⁻¹ ↔ 0 < a ∧ a ≤ 1
-- Mathlib/Data/Ordmap/Ordset.lean
theorem any_singleton {P : α → Prop} {x : α} : Any P (singleton x) ↔ P x
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
theorem Continuous.image_eq_of_connectedComponent_eq (h : Continuous f) (a b : α)
    (hab : connectedComponent a = connectedComponent b) : f a = f b
-- Mathlib/RingTheory/Ideal/Prod.lean
/-- Classification of prime ideals in product rings: the prime ideals of `R × S` are precisely the
    ideals of the form `p × S` or `R × p`, where `p` is a prime ideal of `R` or `S`. -/
theorem ideal_prod_prime (I : Ideal (R × S)) :
    I.IsPrime ↔
      (∃ p : Ideal R, p.IsPrime ∧ I = Ideal.prod p ⊤) ∨
        ∃ p : Ideal S, p.IsPrime ∧ I = Ideal.prod ⊤ p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
@[simp] theorem gcd_gcd_self_right_right (m n : Nat) : gcd m (gcd n m) = gcd n m
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem measurableCylinders.eq_cylinder (ht : t ∈ measurableCylinders α) :
    t = cylinder (measurableCylinders.finset ht) (measurableCylinders.set ht)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
@[simp]
lemma coroot_zero [Nontrivial L] : coroot (0 : Weight K H L) = 0
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma val_eq_cast (q : ℚ≥0) : q.1 = q
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem div_val (a b : Fin n) : (a / b).val = a.val / b.val
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_subtype {p : ι → Prop} {f : Subtype p → α} : iSup f = ⨆ (i) (h : p i), f ⟨i, h⟩
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem coe_finset_sum [AddCommMonoid N] (S : Finset ι) (f : ι → α →₀ N) :
    ⇑(∑ i ∈ S, f i) = ∑ i ∈ S, ⇑(f i)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
lemma cons_sndOfNotNil (q : G.Walk v w) (hadj : G.Adj u v) :
    (q.cons hadj).sndOfNotNil not_nil_cons = v
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem encode_true : encode true = 1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem not_isUnit_X : ¬IsUnit (X : R[X])
-- Mathlib/Topology/Instances/ENNReal.lean
lemma truncateToReal_le {t : ℝ≥0∞} (t_ne_top : t ≠ ∞) {x : ℝ≥0∞} :
    truncateToReal t x ≤ t.toReal
-- Mathlib/Topology/Connected/PathConnected.lean
theorem extend_zero : γ.extend 0 = x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive uniformContinuous_const_zsmul]
theorem uniformContinuous_zpow_const (n : ℤ) : UniformContinuous fun x : α => x ^ n
-- Mathlib/Computability/Partrec.lean
theorem option_some : Computable (@Option.some α)
-- Mathlib/Probability/Independence/Basic.lean
lemma iIndepSet_iff_iIndep (s : ι → Set Ω) (μ : Measure Ω) :
    iIndepSet s μ ↔ iIndep (fun i ↦ generateFrom {s i}) μ
-- Mathlib/RingTheory/Generators.lean
/-- Given families of generators `X ⊆ T`, there is a map `R[X] → S[X]`. -/
@[simps]
noncomputable
def toExtendScalars (P : Generators R T) : Hom P (P.extendScalars S)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Composition with a linear isometry equiv on the left preserves the norm of the iterated
derivative within a set. -/
theorem LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left (g : F ≃ₗᵢ[𝕜] G) (f : E → F)
    (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) (i : ℕ) :
    ‖iteratedFDerivWithin 𝕜 i (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
-- Mathlib/Algebra/Group/Int.lean
lemma ediv_two_mul_two_of_even : Even n → n / 2 * 2 = n
-- Mathlib/Data/Int/Defs.lean
@[simp, nolint simpNF] lemma natCast_eq_zero {n : ℕ} : (n : ℤ) = 0 ↔ n = 0
-- Mathlib/Algebra/Group/Center.lean
@[to_additive (attr := simp) addCentralizer_eq_univ]
lemma centralizer_eq_univ : centralizer S = univ
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem ord_ofNat (n : ℕ) [n.AtLeastTwo] : ord (no_index (OfNat.ofNat n)) = OfNat.ofNat n
-- Mathlib/Topology/LocallyFinite.lean
theorem locallyFinite_option {f : Option ι → Set X} :
    LocallyFinite f ↔ LocallyFinite (f ∘ some)
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_mul_X_pow' (p : R⟦X⟧) (n d : ℕ) :
    coeff R d (p * X ^ n) = ite (n ≤ d) (coeff R (d - n) p) 0
-- Mathlib/Algebra/Group/Defs.lean
/-- Typeclass for expressing that `-0 = 0`. -/
class NegZeroClass (G : Type*) extends Zero G, Neg G where
  protected neg_zero : -(0 : G) = 0
-- Mathlib/Data/Finset/Union.lean
lemma disjoint_biUnion_right (s : Finset β) (t : Finset α) (f : α → Finset β) :
    Disjoint s (t.biUnion f) ↔ ∀ i ∈ t, Disjoint s (f i)
-- Mathlib/Order/Filter/Prod.lean
protected lemma Frequently.uncurry {la : Filter α} {lb : Filter β} {p : α → β → Prop}
    (h : ∃ᶠ x in la, ∃ᶠ y in lb, p x y) : ∃ᶠ xy in la ×ˢ lb, p xy.1 xy.2
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem Ring.inverse_eq_inv' : (Ring.inverse : G₀ → G₀) = Inv.inv
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive ball_eq]
theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε }
-- Mathlib/Algebra/Ring/Parity.lean
lemma Odd.neg (hp : Odd a) : Odd (-a)
-- Mathlib/ModelTheory/Substructures.lean
theorem mem_iInf {ι : Sort*} {S : ι → L.Substructure M} {x : M} :
    (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem primPart_ne_zero (p : R[X]) : p.primPart ≠ 0
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem LinearIsometryEquiv.contDiff (f : E ≃ₗᵢ[𝕜] F) : ContDiff 𝕜 n f
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem mk_mul_mk (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R) :
    (mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) * mk b₁ b₂ b₃ b₄ =
      ⟨a₁ * b₁ + c₁ * a₂ * b₂ + c₂ * a₃ * b₃ - c₁ * c₂ * a₄ * b₄,
        a₁ * b₂ + a₂ * b₁ - c₂ * a₃ * b₄ + c₂ * a₄ * b₃,
        a₁ * b₃ + c₁ * a₂ * b₄ + a₃ * b₁ - c₁ * a₄ * b₂, a₁ * b₄ + a₂ * b₃ - a₃ * b₂ + a₄ * b₁⟩
-- Mathlib/Algebra/Order/AddGroupWithTop.lean
@[simp, norm_cast]
theorem coe_neg (a : α) : ((-a : α) : WithTop α) = -a
-- Mathlib/Data/Finset/Basic.lean
lemma disjoint_insert_erase (ha : a ∉ t) : Disjoint (s.erase a) (insert a t) ↔ Disjoint s t
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem extendDomain_one : extendDomain 1 f = 1
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem mul_coeff (x y : 𝕎 R) (n : ℕ) :
    (x * y).coeff n = peval (wittMul p n) ![x.coeff, y.coeff]
-- Mathlib/Data/Multiset/Dedup.lean
@[simp]
theorem nodup_dedup (s : Multiset α) : Nodup (dedup s)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_inv (e : E ≃ₗᵢ[R] E) : ⇑e⁻¹ = e.symm
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem lt_irrefl' [LT α] (lt_irrefl : ∀ x : α, ¬x < x) (l : List α) : ¬l < l
-- Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean
theorem maximal_ideal_unique : ∃! I : Ideal R, I.IsMaximal
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem trans_swap_trans_symm [DecidableEq β] (a b : β) (e : α ≃ β) :
    (e.trans (swap a b)).trans e.symm = swap (e.symm a) (e.symm b)
-- Mathlib/Data/List/Sym.lean
theorem sym_map {β : Type*} (f : α → β) (n : ℕ) (xs : List α) :
    (xs.map f).sym n = (xs.sym n).map (Sym.map f)
-- Mathlib/Order/Category/BddDistLat.lean
/-- The equivalence between `BddDistLat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : BddDistLat ≌ BddDistLat
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem parallelPair_map_left (f g : X ⟶ Y) : (parallelPair f g).map left = f
-- Mathlib/FieldTheory/Fixed.lean
/-- `MulSemiringAction.toAlgHom` is bijective. -/
theorem toAlgHom_bijective (G : Type u) (F : Type v) [Group G] [Field F] [Finite G]
    [MulSemiringAction G F] [FaithfulSMul G F] :
    Function.Bijective (MulSemiringAction.toAlgHom _ _ : G → F →ₐ[subfield G F] F)
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[simp]
lemma liftCochain_fst :
    (liftCochain φ α β h).comp (fst φ).1 h = α
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- An oriented angle is `π` if and only if the angle with the order of the points reversed is
`π`. -/
theorem oangle_eq_pi_iff_oangle_rev_eq_pi {p₁ p₂ p₃ : P} : ∡ p₁ p₂ p₃ = π ↔ ∡ p₃ p₂ p₁ = π
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_add_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (hT'' : DominatedFinMeasAdditive μ T'' C'')
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α → E) :
    setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f
-- Mathlib/Analysis/Convolution.lean
/-- Commutativity of convolution -/
theorem convolution_flip : g ⋆[L.flip, μ] f = f ⋆[L, μ] g
-- Mathlib/Order/SuccPred/IntervalSucc.lean
/-- If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `Set.Ioc (f n) (f (Order.pred n))` are pairwise disjoint. -/
theorem pairwise_disjoint_on_Ioc_pred [PredOrder α] [Preorder β] {f : α → β} (hf : Antitone f) :
    Pairwise (Disjoint on fun n => Ioc (f n) (f (pred n)))
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_diff (ht : MeasurableSet t) (hfs : IntegrableOn f s μ) (hts : t ⊆ s) :
    ∫ x in s \ t, f x ∂μ = ∫ x in s, f x ∂μ - ∫ x in t, f x ∂μ