ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem toEquiv_inj {e₁ e₂ : A ≃ₐc[R] B} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂
-- Mathlib/Topology/Algebra/Ring/Basic.lean
theorem Subring.le_topologicalClosure (s : Subring α) : s ≤ s.topologicalClosure
-- Mathlib/Analysis/Complex/Basic.lean
/-- We show that the partial order and the topology on `ℂ` are compatible.
We turn this into an instance scoped to `ComplexOrder`. -/
lemma orderClosedTopology : OrderClosedTopology ℂ
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
@[simp]
lemma map_tmul (f : Hom P P') (x y) :
    CotangentSpace.map f (x ⊗ₜ .D _ _ y) = (algebraMap _ _ x) ⊗ₜ .D _ _ (f.toAlgHom y)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem borel_eq_generateFrom_Ici : borel α = MeasurableSpace.generateFrom (range Ici)
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem orderOf_dvd_card_sub_one {p : ℕ} [Fact p.Prime] {a : ZMod p} (ha : a ≠ 0) :
    orderOf a ∣ p - 1
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem tendsto_translation_number₀' :
    Tendsto (fun n : ℕ => (f ^ (n + 1) : CircleDeg1Lift) 0 / ((n : ℝ) + 1)) atTop (𝓝 <| τ f)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
protected theorem surjective (e : P₁ ≃ᵃ[k] P₂) : Surjective e
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem edist_map (x y : P) : edist (f x) (f y) = edist x y
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
/-- The span of a subspace is the subspace. -/
@[simp]
theorem span_coe (W : Subspace K V) : span ↑W = W
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem index_embedding (i : Fin c.length) (j : Fin (c.blocksFun i)) :
    c.index (c.embedding i j) = i
-- Mathlib/Order/RelSeries.lean
theorem length_ne_zero (irrefl : Irreflexive r) : s.length ≠ 0 ↔ {x | x ∈ s}.Nontrivial
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The Monge point of an (n+2)-simplex, in terms of
`pointsWithCircumcenter`. -/
theorem mongePoint_eq_affineCombination_of_pointsWithCircumcenter {n : ℕ}
    (s : Simplex ℝ P (n + 2)) :
    s.mongePoint =
      (univ : Finset (PointsWithCircumcenterIndex (n + 2))).affineCombination ℝ
        s.pointsWithCircumcenter (mongePointWeightsWithCircumcenter n)
-- Mathlib/Analysis/Subadditive.lean
theorem lim_le_div (hbdd : BddBelow (range fun n => u n / n)) {n : ℕ} (hn : n ≠ 0) :
    h.lim ≤ u n / n
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem union_apply {R S : Sieve X} {Y} (f : Y ⟶ X) : (R ⊔ S) f ↔ R f ∨ S f
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_nonneg_iff_neg_imp_nonpos [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    0 ≤ a * b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0)
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.finset_inf'_apply (hne : s.Nonempty)
    (hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x) :
    ContinuousWithinAt (fun a ↦ s.inf' hne (f · a)) t x
-- Mathlib/Data/List/Indexes.lean
theorem foldlIdx_eq_foldl_enum (f : ℕ → α → β → α) (a : α) (bs : List β) :
    foldlIdx f a bs = foldl (fun a p ↦ f p.fst a p.snd) a (enum bs)
-- Mathlib/Topology/Algebra/MulAction.lean
@[to_additive]
lemma smul_set_closure_subset (K : Set M) (L : Set X) :
    closure K • closure L ⊆ closure (K • L)
-- Mathlib/Analysis/Convex/Hull.lean
theorem LinearMap.image_convexHull (f : E →ₗ[𝕜] F) (s : Set E) :
    f '' convexHull 𝕜 s = convexHull 𝕜 (f '' s)
-- Mathlib/RingTheory/Ideal/Prod.lean
@[simp]
theorem idealProdEquiv_symm_apply (I : Ideal R) (J : Ideal S) :
    idealProdEquiv.symm ⟨I, J⟩ = prod I J
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@[simp]
lemma leftUnshift_smul {n' a : ℤ} (γ : Cochain (K⟦a⟧) L n') (n : ℤ) (hn : n + a = n') (x : R) :
    (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn
-- Mathlib/Data/Part.lean
theorem bind_toOption (f : α → Part β) (o : Part α) [Decidable o.Dom] [∀ a, Decidable (f a).Dom]
    [Decidable (o.bind f).Dom] :
    (o.bind f).toOption = o.toOption.elim Option.none fun a => (f a).toOption
-- Mathlib/Data/Set/Sups.lean
theorem sups_left_comm : s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u)
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem zero_ndunion (s : Multiset α) : ndunion 0 s = s
-- Mathlib/Data/Rel.lean
theorem image_comp (s : Rel β γ) (t : Set α) : image (r • s) t = image s (image r t)
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
/-- The explicit cofan of a family of topological spaces given by the sigma type. -/
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- Coercion of a `NormedAddGroupHom` is an `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`.  -/
@[simps]
def coeAddHom : NormedAddGroupHom V₁ V₂ →+ V₁ → V₂
-- Mathlib/Data/Complex/Order.lean
theorem lt_def {z w : ℂ} : z < w ↔ z.re < w.re ∧ z.im = w.im
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- If `f : ℂ → E` is complex differentiable on some set `s`, then it is analytic at any point `z`
such that `s ∈ 𝓝 z` (equivalently, `z ∈ interior s`). -/
protected theorem _root_.DifferentiableOn.analyticAt {s : Set ℂ} {f : ℂ → E} {z : ℂ}
    (hd : DifferentiableOn ℂ f s) (hz : s ∈ 𝓝 z) : AnalyticAt ℂ f z
-- Mathlib/Topology/Sets/Compacts.lean
/-- The type of nonempty compact sets of a topological space. -/
structure NonemptyCompacts (α : Type*) [TopologicalSpace α] extends Compacts α where
  nonempty' : carrier.Nonempty
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem coe_nnreal_lt_top (x : ℝ≥0) : ((x : ℝ≥0∞) : EReal) < ⊤
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem darts_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').darts = p.darts ++ p'.darts
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_neg (f : M →SL[σ₁₂] M₂) : (↑(-f) : M →ₛₗ[σ₁₂] M₂) = -f
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc (attr := simp)]
lemma ιTotalOrZero_map (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ ≫ (total.map φ c₁₂).f i₁₂ =
      (φ.f i₁).f i₂ ≫ L.ιTotalOrZero c₁₂ i₁ i₂ i₁₂
-- Mathlib/GroupTheory/Coxeter/Basic.lean
@[simp]
theorem lift_apply_simple {G : Type*} [Monoid G] {f : B → G} (hf : IsLiftable M f) (i : B) :
    cs.lift ⟨f, hf⟩ (s i) = f i
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem mkQ_map_self : map p.mkQ p = ⊥
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
/-- The exponent `p` associated with a particular Akra-Bazzi recurrence. -/
noncomputable irreducible_def p : ℝ
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem ker_modByMonicHom (hq : q.Monic) :
    LinearMap.ker (Polynomial.modByMonicHom q) = (Ideal.span {q}).restrictScalars R
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- Turn a limit of `F : Jᵒᵖ ⥤ Cᵒᵖ` into a colimit of `F.unop : J ⥤ C`. -/
@[simps]
def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeUnopOfCone c)
-- Mathlib/ModelTheory/Order.lean
theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoBotOrder M
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem totalVariation_neg (s : SignedMeasure α) : (-s).totalVariation = s.totalVariation
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- `-1` is a square in `ZMod p` iff `p` is not congruent to `3` mod `4`. -/
theorem exists_sq_eq_neg_one_iff : IsSquare (-1 : ZMod p) ↔ p % 4 ≠ 3
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem pure_sub_pure (a b : α) : pure a - pure b = pure (a - b)
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
/-- If `f (g y) = y` for `y` in some neighborhood of `a`, `g` is continuous at `a`, and `f` has an
invertible derivative `f'` at `g a` in the strict sense, then `g` has the derivative `f'⁻¹` at `a`
in the strict sense.

This is one of the easy parts of the inverse function theorem: it assumes that we already have an
inverse function. -/
theorem HasStrictFDerivAt.of_local_left_inverse {f : E → F} {f' : E ≃L[𝕜] F} {g : F → E} {a : F}
    (hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) (g a))
    (hfg : ∀ᶠ y in 𝓝 a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F →L[𝕜] E) a
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem vec3_dotProduct (v w : Fin 3 → α) : v ⬝ᵥ w = v 0 * w 0 + v 1 * w 1 + v 2 * w 2
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem singleton_eq_cons_iff {a b : α} (m : Multiset α) : {a} = b ::ₘ m ↔ a = b ∧ m = 0
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma exp_le_one_iff {a : EReal} : exp a ≤ 1 ↔ a ≤ 0
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem symm_comp_self (e : α ≃ β) : e.symm ∘ e = id
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem cancel_left {g : FrameHom β γ} {f₁ f₂ : FrameHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Data/Nat/Defs.lean
protected lemma add_sub_sub_cancel (h : c ≤ a) : a + b - (a - c) = b + c
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma gc_mul_ceilDiv (ha : 0 < a) : GaloisConnection (· ⌈/⌉ a) (a * ·)
-- Mathlib/Data/Finset/Card.lean
theorem card_inter_add_card_union (s t : Finset α) :
    (s ∩ t).card + (s ∪ t).card = s.card + t.card
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The `v`-adic valuation of `r/s ∈ K` is the valuation of `r` divided by the valuation of `s`. -/
theorem valuation_of_mk' {r : R} {s : nonZeroDivisors R} :
    v.valuation (IsLocalization.mk' K r s) = v.intValuation r / v.intValuation s
-- Mathlib/GroupTheory/GroupAction/Period.lean
@[to_additive]
theorem period_dvd_exponent (m : M) (a : α) : period m a ∣ Monoid.exponent M
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem insert_eq_self : insert a s = s ↔ a ∈ s
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_bool_eq {f : Bool → α} : ⨆ b : Bool, f b = f true ⊔ f false
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If ∠ABC = π then dist A B ≠ 0. -/
theorem left_dist_ne_zero_of_angle_eq_pi {p1 p2 p3 : P} (h : ∠ p1 p2 p3 = π) : dist p1 p2 ≠ 0
-- Mathlib/CategoryTheory/Sites/Over.lean
@[simp]
lemma overEquiv_symm_iff {X : C} {Y : Over X} (S : Sieve Y.left) {Z : Over X} (f : Z ⟶ Y) :
    (overEquiv Y).symm S f ↔ S f.left
-- Mathlib/Topology/CompactOpen.lean
theorem isOpen_setOf_mapsTo (hK : IsCompact K) (hU : IsOpen U) :
    IsOpen {f : C(X, Y) | MapsTo f K U}
-- Mathlib/Topology/Connected/Basic.lean
theorem Subtype.connectedSpace {s : Set α} (h : IsConnected s) : ConnectedSpace s
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_iUnion_of_directed {η : Type*} [Nonempty η] {s : η → Set A}
    (hs : Directed (· ⊆ ·) s) (h : ∀ i, AlgebraicIndependent R ((↑) : s i → A)) :
    AlgebraicIndependent R ((↑) : (⋃ i, s i) → A)
-- Mathlib/Order/Monotone/Basic.lean
/-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
`f n`, then `x` doesn't lie in the range of `f`. -/
theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ) : f a ≠ x
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_eq_top {f : M →ₛₗ[τ₁₂] M₂} : ker f = ⊤ ↔ f = 0
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
/-- The canonical isomorphism `K.cycles j ≅ K.homology j`
when the differential to `j` is zero. -/
@[simps! hom]
noncomputable def isoHomologyπ : K.cycles j ≅ K.homology j
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_add_le_add_left {a b c : Nat} (h : a + b ≤ a + c) : b ≤ c
-- Mathlib/Analysis/Convex/Extreme.lean
theorem isExtreme_sInter {F : Set (Set E)} (hF : F.Nonempty) (hAF : ∀ B ∈ F, IsExtreme 𝕜 A B) :
    IsExtreme 𝕜 A (⋂₀ F)
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.mono_of_mem {f : α → β} {s t : Set α} {x : α}
    (h : ContinuousWithinAt f t x) (hs : t ∈ 𝓝[s] x) : ContinuousWithinAt f s x
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x)
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma u₄_sq : S.u₄ ^ 2 = 1
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem const_max (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => max a (f x)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_image_image_of_subset_source {s : Set α} (h : s ⊆ e.source) : e.symm '' (e '' s) = s
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem add_apply (n : ℕ) (f g : AdicCauchySequence I M) : (f + g) n = f n + g n
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma neg_mem {x} (hx : x ∈ I) : -x ∈ I
-- Mathlib/CategoryTheory/Localization/Composition.lean
lemma comp [L₁.IsLocalization W₁] [L₂.IsLocalization W₂]
    (W₃ : MorphismProperty C₁) (hW₃ : W₃.IsInvertedBy (L₁ ⋙ L₂))
    (hW₁₃ : W₁ ≤ W₃) (hW₂₃ : W₂ ≤ W₃.map L₁) :
    (L₁ ⋙ L₂).IsLocalization W₃
-- Mathlib/NumberTheory/Cyclotomic/Three.lean
/-- We have that `x ^ 3 - 1 = (x - 1) * (x - η) * (x - η ^ 2)`. -/
lemma cube_sub_one_eq_mul : x ^ 3 - 1 = (x - 1) * (x - η) * (x - η ^ 2)
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n * c - x) = f (-x)
-- Mathlib/Data/Set/Image.lean
theorem subset_image_iff {t : Set β} :
    t ⊆ f '' s ↔ ∃ u, u ⊆ s ∧ f '' u = t
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_lt [LinearOrderedRing α] {m n : ZNum} : (m : α) < n ↔ m < n
-- Mathlib/Order/Hom/Basic.lean
/-- A version of `WithTop.map` for order embeddings. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α ↪o β) : WithTop α ↪o WithTop β
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem toNat_add_toNat_neg_eq_natAbs : ∀ n : Int, n.toNat + (-n).toNat = n.natAbs
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The `S`-rank of `M ⊗[R] M'` is `(Module.rank S M).lift * (Module.rank R M').lift`. -/
@[simp]
theorem rank_tensorProduct :
    Module.rank R (M ⊗[S] M') =
      Cardinal.lift.{v'} (Module.rank R M) * Cardinal.lift.{v} (Module.rank S M')
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
theorem dvd_total [h : ValuationRing R] (x y : R) : x ∣ y ∨ y ∣ x
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem coe_symmₗ (e : Trivialization F (π F E)) [e.IsLinear R] (b : B) :
    ⇑(e.symmₗ R b) = e.symm b
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_ofNatLt {n : Nat} (x : Nat) (lt : x < 2^n) (i : Nat) :
  getLsb (x#'lt) i = x.testBit i
-- Mathlib/Order/Filter/AtTopBot.lean
theorem comap_neg_atBot : comap (Neg.neg : β → β) atBot = atTop
-- Mathlib/Algebra/Ring/Hom/Defs.lean
protected theorem ext_iff {f g : α →+* β} : f = g ↔ ∀ x, f x = g x
-- Mathlib/Data/Matroid/Map.lean
lemma Indep.map (hI : M.Indep I) (f : α → β) (hf) : (M.map f hf).Indep (f '' I)
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem norm_le_norm_mul_of_mem {a : A} {k : 𝕜} (hk : k ∈ σ a) : ‖k‖ ≤ ‖a‖ * ‖(1 : A)‖
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_iff_right_iff_imp : ((a ∧ b) ↔ b) ↔ (b → a)
-- Mathlib/Analysis/Normed/Operator/Banach.lean
/-- First step of the proof of the Banach open mapping theorem (using completeness of `F`):
by Baire's theorem, there exists a ball in `E` whose image closure has nonempty interior.
Rescaling everything, it follows that any `y ∈ F` is arbitrarily well approached by
images of elements of norm at most `C * ‖y‖`.
For further use, we will only need such an element whose image
is within distance `‖y‖/2` of `y`, to apply an iterative process. -/
theorem exists_approx_preimage_norm_le (surj : Surjective f) :
    ∃ C ≥ 0, ∀ y, ∃ x, dist (f x) y ≤ 1 / 2 * ‖y‖ ∧ ‖x‖ ≤ C * ‖y‖
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem trans {a b c : α} (hab : a ≈ b) (hbc : b ≈ c) : a ≈ c
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem mem_target {x : B × F} : x ∈ e.target ↔ x.1 ∈ e.baseSet
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
theorem bindOnSupport_eq_zero_iff (b : β) :
    p.bindOnSupport f b = 0 ↔ ∀ (a) (ha : p a ≠ 0), f a ha b = 0
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem Antitone.mul_monotone [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Antitone f) (hg : Monotone g) (hf₀ : ∀ x, f x ≤ 0)
    (hg₀ : ∀ x, 0 ≤ g x) : Antitone (f * g)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem injOn_sin : InjOn sin (Icc (-(π / 2)) (π / 2))
-- Mathlib/Algebra/Associated/Basic.lean
theorem Irreducible.associated_of_dvd [Monoid α] {p q : α} (p_irr : Irreducible p)
    (q_irr : Irreducible q) (dvd : p ∣ q) : Associated p q
-- Mathlib/Data/PNat/Basic.lean
/-- If `n : ℕ+` is different from `1`, then it is the successor of some `k : ℕ+`. -/
theorem exists_eq_succ_of_ne_one : ∀ {n : ℕ+} (_ : n ≠ 1), ∃ k : ℕ+, n = k + 1
-- Mathlib/Algebra/Star/Order.lean
theorem star_mul_self_nonneg (r : R) : 0 ≤ star r * r
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_ceil_atBot : Tendsto (ceil : α → ℤ) atBot atBot
-- Mathlib/Data/Int/GCD.lean
theorem gcd_dvd_gcd_mul_left_right (i j k : ℤ) : gcd i j ∣ gcd i (k * j)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem edges_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').edges = p.edges ++ p'.edges
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem toList_one : toList (1 : FreeMonoid α) = []
-- Mathlib/Data/Seq/Computation.lean
theorem mem_promises {s : Computation α} {a : α} : a ∈ s → s ~> a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.toReal| = θ
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
@[simp]
theorem coe_toLinearEquiv : ⇑(e : A ≃ₗ[R] B) = e
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.zpow_apply_eq_zpow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)
    {m n : ℤ} : (f ^ m) a = (f ^ n) a ↔ m ≡ n [ZMOD s.card]
-- Mathlib/Topology/UnitInterval.lean
lemma addNSMul_zero : addNSMul h δ 0 = a
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive (attr := simp) nnnorm_eq_zero]
theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- Composing with a surjective linear map is injective. -/
theorem compLinearMap_injective (f : M₂ →ₗ[R] M) (hf : Function.Surjective f) :
    Function.Injective fun g : M [⋀^ι]→ₗ[R] N => g.compLinearMap f
-- Mathlib/Algebra/Homology/Embedding/Restriction.lean
@[simp]
lemma restrictionMap_id : restrictionMap (𝟙 K) e = 𝟙 _
-- Mathlib/Order/SupClosed.lean
lemma InfClosed.inter (hs : InfClosed s) (ht : InfClosed t) : InfClosed (s ∩ t)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive prod_top]
theorem prod_top (K : Subgroup G) : K.prod (⊤ : Subgroup N) = K.comap (MonoidHom.fst G N)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
@[trans]
theorem IsEquivalent.trans_isBigO {f g₁ : α → β} {g₂ : α → β₂} (h : f ~[l] g₁) (h₂ : g₁ =O[l] g₂) :
    f =O[l] g₂
-- Mathlib/Data/Finset/Sups.lean
theorem card_sups_iff :
    (s ⊻ t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun x => x.1 ⊔ x.2
-- Mathlib/Algebra/Order/Pi.lean
@[to_additive] lemma extend_le_one (hg : g ≤ 1) (he : e ≤ 1) : extend f g e ≤ 1
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem card_complex_embeddings :
    card { φ : K →+* ℂ // ¬ComplexEmbedding.IsReal φ } = 2 * NrComplexPlaces K
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toDFinsupp_singleton (a : α) : toDFinsupp {a} = DFinsupp.single a 1
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem not_mem_bot : J ∉ (⊥ : Prepartition I)
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem mem_iff_find_le {x : X} {n : ℕ} : x ∈ K n ↔ K.find x ≤ n
-- Mathlib/Topology/DerivedSet.lean
lemma derivedSet_mono (A B : Set X) (h : A ⊆ B) : derivedSet A ⊆ derivedSet B
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_nonneg {f : R → R} {a : A} (h : ∀ x ∈ σₙ R a, 0 ≤ f x) :
    0 ≤ cfcₙ f a
-- Mathlib/RingTheory/Ideal/AssociatedPrime.lean
theorem LinearEquiv.AssociatedPrimes.eq (l : M ≃ₗ[R] M') :
    associatedPrimes R M = associatedPrimes R M'
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem sin_three_mul : sin (3 * x) = 3 * sin x - 4 * sin x ^ 3
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
lemma inclusion_injective (s : SubMulAction M α) :
    Function.Injective s.inclusion
-- Mathlib/Control/Traversable/Instances.lean
protected theorem naturality {α β} (f : α → F β) (x : σ ⊕ α) :
    η (Sum.traverse f x) = Sum.traverse (@η _ ∘ f) x
-- Mathlib/Data/Real/Hyperreal.lean
theorem Infinite.st_eq {x : ℝ*} (hi : Infinite x) : st x = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma φ_neg (n : ℤ) : W.φ (-n) = W.φ n
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem finInsepDegree_self : finInsepDegree F F = 1
-- Mathlib/Order/Category/Frm.lean
@[simp]
theorem coe_of (α : Type*) [Frame α] : ↥(of α) = α
-- Mathlib/Probability/Moments.lean
@[simp]
theorem cgf_zero_fun : cgf 0 μ t = log (μ Set.univ).toReal
-- Mathlib/Algebra/Homology/Opposite.lean
/-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unop (X : HomologicalComplex Vᵒᵖ c) : HomologicalComplex V c.symm
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem pow_eq_one_iff_dvd (l : ℕ) : ζ ^ l = 1 ↔ k ∣ l
-- Mathlib/Data/List/Chain.lean
theorem chain'_pair {x y} : Chain' R [x, y] ↔ R x y
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem and_nil : [].and = true
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem testAgainstNN_lipschitz (μ : ProbabilityMeasure Ω) :
    LipschitzWith 1 fun f : Ω →ᵇ ℝ≥0 => μ.toFiniteMeasure.testAgainstNN f
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem LocallyConvexSpace.ofBases {ι : Type*} (b : E → ι → Set E) (p : E → ι → Prop)
    (hbasis : ∀ x : E, (𝓝 x).HasBasis (p x) (b x)) (hconvex : ∀ x i, p x i → Convex 𝕜 (b x i)) :
    LocallyConvexSpace 𝕜 E
-- Mathlib/Data/Part.lean
theorem left_dom_of_append_dom [Append α] {a b : Part α} (hab : Dom (a ++ b)) : a.Dom
-- Mathlib/Data/Finsupp/Basic.lean
/-- A version of `sum_mapDomain_index` that takes a bundled `AddMonoidHom`,
rather than separate linearity hypotheses.
-/
@[simp]
theorem sum_mapDomain_index_addMonoidHom [AddCommMonoid N] {f : α → β} {s : α →₀ M}
    (h : β → M →+ N) : ((mapDomain f s).sum fun b m => h b m) = s.sum fun a m => h (f a) m
-- Mathlib/Algebra/Order/Kleene.lean
@[simp]
theorem pow_le_kstar : ∀ {n : ℕ}, a ^ n ≤ a∗
-- Mathlib/Algebra/Order/Monoid/TypeTags.lean
@[simp]
theorem ofMul_le {a b : α} : ofMul a ≤ ofMul b ↔ a ≤ b
-- Mathlib/Algebra/Homology/ShortComplex/Ab.lean
/-- The canonical additive morphism `S.X₁ →+ AddMonoidHom.ker S.g` induced by `S.f`. -/
@[simps!]
def abToCycles : S.X₁ →+ AddMonoidHom.ker S.g
-- Mathlib/CategoryTheory/Shift/Basic.lean
@[reassoc]
lemma assoc_inv_app (h : ShiftMkCore C A) (m₁ m₂ m₃ : A) (X : C) :
    (h.F m₃).map ((h.add m₁ m₂).inv.app X) ≫ (h.add (m₁ + m₂) m₃).inv.app X =
    (h.add m₂ m₃).inv.app ((h.F m₁).obj X) ≫ (h.add m₁ (m₂ + m₃)).inv.app X ≫
      eqToHom (by rw [add_assoc])
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem mem_map {S : Subalgebra R A} {f : A →ₐ[R] B} {y : B} : y ∈ map f S ↔ ∃ x ∈ S, f x = y
-- Mathlib/Topology/Basic.lean
theorem clusterPt_principal_iff_frequently :
    ClusterPt x (𝓟 s) ↔ ∃ᶠ y in 𝓝 x, y ∈ s
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Homomorphisms on the quotient of a monoid by a congruence relation are equal if they
    are equal on elements that are coercions from the monoid. -/
@[to_additive "Homomorphisms on the quotient of an `AddMonoid` by an additive congruence relation
are equal if they are equal on elements that are coercions from the `AddMonoid`."]
theorem lift_funext (f g : c.Quotient →* P) (h : ∀ a : M, f a = g a) : f = g
-- Mathlib/Order/Filter/ModEq.lean
/-- Infinitely many natural numbers are equal to `d` mod `n`. -/
theorem frequently_modEq {n : ℕ} (h : n ≠ 0) (d : ℕ) : ∃ᶠ m in atTop, m ≡ d [MOD n]
-- Mathlib/Order/Interval/Basic.lean
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ s ≤ t