ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/ZMod/Basic.lean
theorem val_unit' {n : ZMod 0} : IsUnit n ↔ n.val = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem length_replicate (n : Nat) (a : α) : (replicate n a).length = n
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- Prove equality of bitvectors in terms of nat operations. -/
theorem eq_of_toNat_eq {n} : ∀ {i j : BitVec n}, i.toNat = j.toNat → i = j
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_add_not_infiniteNeg {x y : ℝ*} :
    InfinitePos x → ¬InfiniteNeg y → InfinitePos (x + y)
-- Mathlib/Order/Interval/Set/Pi.lean
theorem pi_univ_Iio_subset [Nonempty ι]: (pi univ fun i ↦ Iio (x i)) ⊆ Iio x
-- Mathlib/Probability/Distributions/Uniform.lean
theorem mul_pdf_integrable (hcs : IsCompact s) (huX : IsUniform X s ℙ) :
    Integrable fun x : ℝ => x * (pdf X ℙ volume x).toReal
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D
-- Mathlib/Order/OrdContinuous.lean
theorem mono (hf : LeftOrdContinuous f) : Monotone f
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_neg_neg (x y : E) : ⟪-x, -y⟫ = ⟪x, y⟫
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem hasseDeriv_X (hk : 1 < k) : hasseDeriv k (X : R[X]) = 0
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_mul_top (a : ℝ≥0∞) : ENNReal.toReal (a * ∞) = 0
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `LocallyConstant.map` as a `RingHom`. -/
@[simps!]
def mapRingHom [Semiring Y] [Semiring Z] (f : Y →+* Z) :
    LocallyConstant X Y →+* LocallyConstant X Z
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem T_natAbs (n : ℤ) : T R n.natAbs = T R n
-- Mathlib/Data/DFinsupp/Basic.lean
theorem zsmul_apply [∀ i, AddGroup (β i)] (b : ℤ) (v : Π₀ i, β i) (i : ι) : (b • v) i = b • v i
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
/-- Bialgebra equivalences are transitive. -/
@[trans, simps!]
def trans (e₁₂ : A ≃ₐc[R] B) (e₂₃ : B ≃ₐc[R] C) : A ≃ₐc[R] C
-- Mathlib/Algebra/Group/TypeTags.lean
/-- Reinterpret `Multiplicative α →* β` as `α →+ Additive β`. -/
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_neg (f : M →ₗ⁅R,L⁆ N) (x : M) : f (-x) = -f x
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem quotientToQuotientRangePowQuotSucc_surjective [IsDedekindDomain S]
    (hP0 : P ≠ ⊥) [hP : P.IsPrime] {i : ℕ} (hi : i < e) {a : S} (a_mem : a ∈ P ^ i)
    (a_not_mem : a ∉ P ^ (i + 1)) :
    Function.Surjective (quotientToQuotientRangePowQuotSucc f p P a_mem)
-- Mathlib/Dynamics/PeriodicPts.lean
protected theorem iterate (hf : IsPeriodicPt f n x) (m : ℕ) : IsPeriodicPt f^[m] n x
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
@[simp] lemma greatestFib_eq_zero : greatestFib n = 0 ↔ n = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_sub_int_mul_pi (x : ℝ) (n : ℤ) : sin (x - n * π) = (-1) ^ n * sin x
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
protected theorem continuousOn {s} : ContinuousOn e s
-- Mathlib/Analysis/Convolution.lean
/-- `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
* `φ` is a sequence of nonnegative functions with integral `1` as `i` tends to `l`;
* The support of `φ` tends to small neighborhoods around `(0 : G)` as `i` tends to `l`;
* `g i` is `mu`-a.e. strongly measurable as `i` tends to `l`;
* `g i x` tends to `z₀` as `(i, x)` tends to `l ×ˢ 𝓝 x₀`;
* `k i` tends to `x₀`.

See also `ContDiffBump.convolution_tendsto_right`.
-/
theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x₀ : G} {z₀ : E'}
    {φ : ι → G → ℝ} {k : ι → G} (hnφ : ∀ᶠ i in l, ∀ x, 0 ≤ φ i x)
    (hiφ : ∀ᶠ i in l, ∫ x, φ i x ∂μ = 1)
    -- todo: we could weaken this to "the integral tends to 1"
    (hφ : Tendsto (fun n => support (φ n)) l (𝓝 0).smallSets)
    (hmg : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))
    (hk : Tendsto k l (𝓝 x₀)) :
    Tendsto (fun i : ι => (φ i ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma differentiableAt_hurwitzZetaEven_sub_one_div (a : UnitAddCircle) :
    DifferentiableAt ℂ (fun s ↦ hurwitzZetaEven a s - 1 / (s - 1) / Gammaℝ s) 1
-- Mathlib/Data/Analysis/Topology.lean
theorem tendsto_nhds_iff {m : β → α} {f : Filter β} (F : f.Realizer) (R : Realizer α) {a : α} :
    Tendsto m f (𝓝 a) ↔ ∀ t, a ∈ R.F t → ∃ s, ∀ x ∈ F.F s, m x ∈ R.F t
-- Mathlib/Data/Set/Sigma.lean
theorem fst_image_sigma_subset (s : Set ι) (t : ∀ i, Set (α i)) : Sigma.fst '' s.sigma t ⊆ s
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma neg_of_smul_pos_right [PosSMulMono α β] [SMulPosMono α β] (h : 0 < a • b) (ha : a ≤ 0) :
    b < 0
-- Mathlib/Algebra/QuaternionBasis.lean
/-- Two `R`-algebra morphisms from a quaternion algebra are equal if they agree on `i` and `j`. -/
@[ext]
theorem hom_ext ⦃f g : ℍ[R,c₁,c₂] →ₐ[R] A⦄
    (hi : f (Basis.self R).i = g (Basis.self R).i) (hj : f (Basis.self R).j = g (Basis.self R).j) :
    f = g
-- Mathlib/Order/Filter/Cofinite.lean
lemma Nat.eventually_pos : ∀ᶠ (k : ℕ) in Filter.atTop, 0 < k
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem T_sub_two (n : ℤ) : T R (n - 2) = 2 * X * T R (n - 1) - T R n
-- Mathlib/Order/Basic.lean
lemma ltTrichotomy_self {p : P} : ltTrichotomy x y p p p = p
-- Mathlib/AlgebraicTopology/MooreComplex.lean
/-- The (normalized) Moore complex of a simplicial object `X` in an abelian category `C`.

The `n`-th object is intersection of
the kernels of `X.δ i : X.obj n ⟶ X.obj (n-1)`, for `i = 1, ..., n`.

The differentials are induced from `X.δ 0`,
which maps each of these intersections of kernels to the next.
-/
@[simps]
def normalizedMooreComplex : SimplicialObject C ⥤ ChainComplex C ℕ
-- Mathlib/Analysis/Calculus/SmoothSeries.lean
/-- Consider a series of functions `∑' n, f n x`. If the series converges at a
point, and all functions in the series are differentiable with a summable bound on the derivatives,
then the series converges everywhere. -/
theorem summable_of_summable_hasDerivAt (hu : Summable u)
    (hg : ∀ n y, HasDerivAt (g n) (g' n y) y) (hg' : ∀ n y, ‖g' n y‖ ≤ u n)
    (hg0 : Summable fun n => g n y₀) (y : 𝕜) : Summable fun n => g n y
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem commute_pow_left_of_commute
    [Semiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {σ₁₂ : R →+* R₂}
    {f : M →ₛₗ[σ₁₂] M₂} {g : Module.End R M} {g₂ : Module.End R₂ M₂}
    (h : g₂.comp f = f.comp g) (k : ℕ) : (g₂ ^ k).comp f = f.comp (g ^ k)
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuous_iff_isClosed_epigraph {f : α → γ} :
    LowerSemicontinuous f ↔ IsClosed {p : α × γ | f p.1 ≤ p.2}
-- Mathlib/Data/Matrix/Kronecker.lean
theorem one_kronecker [MulZeroOneClass α] [DecidableEq l] (B : Matrix m n α) :
    (1 : Matrix l l α) ⊗ₖ B =
      Matrix.reindex (Equiv.prodComm _ _) (Equiv.prodComm _ _) (blockDiagonal fun _ => B)
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[simp]
theorem prod'_toLaxMonoidalFunctor :
    (F.prod' G).toLaxMonoidalFunctor = F.toLaxMonoidalFunctor.prod' G.toLaxMonoidalFunctor
-- Mathlib/Order/Bounds/OrderIso.lean
@[simp]
theorem isGLB_image {s : Set α} {x : β} : IsGLB (f '' s) x ↔ IsGLB s (f.symm x)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem coe_inclusion_apply (h : S₁ ≤ S₂) (x : S₁) : (inclusion h x : P₁) = x
-- Mathlib/Data/Set/Function.lean
/-- Variant of `EqOn.image_eq`, for one function being the identity. -/
theorem EqOn.image_eq_self {f : α → α} (h : Set.EqOn f id s) : f '' s = s
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem cast_toNat_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : ↑(toNat c) = c
-- Mathlib/MeasureTheory/Function/LpOrder.lean
theorem _root_.MeasureTheory.Memℒp.inf {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    Memℒp (f ⊓ g) p μ
-- Mathlib/CategoryTheory/Limits/Opposites.lean
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] :
    (pullbackIsoUnopPushout f g).inv ≫ pullback.snd f g =
      (pushout.inr _ _ : _ ⟶ pushout f.op g.op).unop
-- Mathlib/Order/Category/FinPartOrd.lean
/-- Constructs an isomorphism of finite partial orders from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : FinPartOrd.{u}} (e : α ≃o β) : α ≅ β
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
/-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
these values using `infEdist _ E`.

`thickenedIndicator` is the (bundled) bounded continuous function with `ℝ≥0`-values.
See `thickenedIndicatorAux` for the unbundled `ℝ≥0∞`-valued function. -/
@[simps]
def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ≥0
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem nat_power_aleph0 {n : ℕ} (hn : 2 ≤ n) : (n ^ aleph0.{u} : Cardinal.{u}) = 𝔠
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem FactorSet.sup_add_inf_eq_add [DecidableEq (Associates α)] :
    ∀ a b : FactorSet α, a ⊔ b + a ⊓ b = a + b
-- Mathlib/Data/Finset/Card.lean
@[simp] lemma card_pos : 0 < s.card ↔ s.Nonempty
-- Mathlib/Data/Set/Function.lean
@[simp]
lemma graphOn_insert (f : α → β) (x : α) (s : Set α) :
    graphOn f (insert x s) = insert (x, f x) (graphOn f s)
-- Mathlib/MeasureTheory/Function/Floor.lean
theorem Int.measurable_ceil [OpensMeasurableSpace R] : Measurable (Int.ceil : R → ℤ)
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem Tape.mk'_left_right₀ {Γ} [Inhabited Γ] (T : Tape Γ) : Tape.mk' T.left T.right₀ = T
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem ucs_comap_incl (k : ℕ) :
    ((⊥ : LieSubmodule R L M).ucs k).comap N.incl = (⊥ : LieSubmodule R L N).ucs k
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Ioi [NoMaxOrder α] : (Ioi a).Nonempty
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffOn.clm_apply {f : E → F →L[𝕜] G} {g : E → F} {n : ℕ∞} (hf : ContDiffOn 𝕜 n f s)
    (hg : ContDiffOn 𝕜 n g s) : ContDiffOn 𝕜 n (fun x => (f x) (g x)) s
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem succ_nadd : succ a ♯ b = succ (a ♯ b)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
@[simp] theorem dvd_one {n : Nat} : n ∣ 1 ↔ n = 1
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
lemma preimage_mul (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t
-- Mathlib/Data/Real/Sqrt.lean
nonrec theorem ContinuousWithinAt.sqrt (h : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => √(f x)) s x
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs : s.Finite) :
    ∃ t : Finset (ι × ℝ),
      ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
-- Mathlib/Data/Finsupp/Defs.lean
@[ext]
theorem ext {f g : α →₀ M} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem range_image_pred_top_sub (n : ℕ) :
    ((Finset.range n).image fun j => n - 1 - j) = Finset.range n
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
@[simp]
theorem hom_ext_iff {P Q : Karoubi C} {f g : P ⟶ Q} : f = g ↔ f.f = g.f
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean
/-- The Law of Quadratic Reciprocity: if `p` and `q` are primes that are both congruent
to `3` mod `4`, then `(q / p) = -(p / q)`. -/
theorem quadratic_reciprocity_three_mod_four (hp : p % 4 = 3) (hq : q % 4 = 3) :
    legendreSym q p = -legendreSym p q
-- Mathlib/Data/List/AList.lean
@[simp]
theorem lookup_to_alist {a} (s : List (Sigma β)) : lookup a s.toAList = s.dlookup a
-- Mathlib/Analysis/Normed/Operator/Banach.lean
@[simp]
theorem coeFn_ofSeqClosedGraph
    (hg : ∀ (u : ℕ → E) (x y), Tendsto u atTop (𝓝 x) → Tendsto (g ∘ u) atTop (𝓝 y) → y = g x) :
    ⇑(ContinuousLinearMap.ofSeqClosedGraph hg) = g
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_eq_self {a : α} : fract a = a ↔ 0 ≤ a ∧ a < 1
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem MultilinearMap.curryRight_apply (f : MultilinearMap R M M₂)
    (m : ∀ i : Fin n, M (castSucc i)) (x : M (last n)) : f.curryRight m x = f (snoc m x)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.group_smul {G : Type*} [hG : Group G] [DistribMulAction G R]
    [DistribMulAction G M] [IsScalarTower G R M] [SMulCommClass G R M] {v : ι → M}
    (hv : LinearIndependent R v) (w : ι → G) : LinearIndependent R (w • v)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem antilipschitz : AntilipschitzWith 1 e
-- Mathlib/FieldTheory/Normal.lean
/-- Typeclass for normal field extension: `K` is a normal extension of `F` iff the minimal
polynomial of every element `x` in `K` splits in `K`, i.e. every conjugate of `x` is in `K`. -/
class Normal extends Algebra.IsAlgebraic F K : Prop where
  splits' (x : K) : Splits (algebraMap F K) (minpoly F x)
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem optionEquivSumPUnit_coe (a : α) : optionEquivSumPUnit α a = Sum.inl a
-- Mathlib/NumberTheory/Rayleigh.lean
/-- Let `r > 1` and `1/r + 1/s = 1`. Suppose there is an integer `j` where `B_r` and `B'_s` both
jump over `j` (i.e. an anti-collision). Then this leads to a contradiction. -/
private theorem no_anticollision :
    ¬∃ j k m : ℤ, k < j / r ∧ (j + 1) / r ≤ k + 1 ∧ m ≤ j / s ∧ (j + 1) / s < m + 1
-- Mathlib/Order/Filter/CountableSeparatingOn.lean
theorem of_eventually_mem_of_forall_separating_preimage (p : Set β → Prop) {s : Set β}
    [HasCountableSeparatingOn β p s] (hf : ∀ᶠ x in l, f x ∈ s) (hg : ∀ᶠ x in l, g x ∈ s)
    (h : ∀ U : Set β, p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) : f =ᶠ[l] g
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem Metric.emetric_ball_top (x : α) : EMetric.ball x ⊤ = univ
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- `x⁻¹` is analytic away from zero -/
lemma analyticOn_inv : AnalyticOn 𝕜 (fun z ↦ z⁻¹) {z : 𝕝 | z ≠ 0}
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[to_additive (attr := simp)]
theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
    (Subgroup.zpowers x).map f = Subgroup.zpowers (f x)
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
lemma closedEmbedding_toContinuousMap [T1Space R] :
    ClosedEmbedding ((↑) : C(X, R)₀ → C(X, R))
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem spanSingleton_eq_spanSingleton [NoZeroSMulDivisors R P] {x y : P} :
    spanSingleton S x = spanSingleton S y ↔ ∃ z : Rˣ, z • x = y
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_pure [PartialOrder α] [OrderTop α] (f : α → β) :
    Tendsto f atTop (pure <| f ⊤)
-- Mathlib/Algebra/Module/Card.lean
/-- The cardinality of a nontrivial module over a ring is at least the cardinality of the ring if
there are no zero divisors (for instance if the ring is a field) -/
theorem mk_le_of_module (R : Type u) (E : Type v)
    [AddCommGroup E] [Ring R] [Module R E] [Nontrivial E] [NoZeroSMulDivisors R E] :
    Cardinal.lift.{v} (#R) ≤ Cardinal.lift.{u} (#E)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_le_smul_iff_of_neg_left [PosSMulMono α β] [PosSMulReflectLE α β] (ha : a < 0) :
    a • b₁ ≤ a • b₂ ↔ b₂ ≤ b₁
-- Mathlib/Computability/Reduce.lean
theorem Equiv.Computable.trans {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ] {e₁ : α ≃ β}
    {e₂ : β ≃ γ} : e₁.Computable → e₂.Computable → (e₁.trans e₂).Computable
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive Summable.of_add_one_of_neg_add_one]
lemma Multipliable.of_add_one_of_neg_add_one {f : ℤ → M}
    (hf₁ : Multipliable fun n : ℕ ↦ f (n + 1)) (hf₂ : Multipliable fun n : ℕ ↦ f (-(n + 1))) :
    Multipliable f
-- Mathlib/Data/Real/Irrational.lean
theorem div_rat (h : Irrational x) {q : ℚ} (hq : q ≠ 0) : Irrational (x / q)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem nil_append {u v : V} (p : G.Walk u v) : nil.append p = p
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
protected theorem ennnorm {β : Type*} [SeminormedAddCommGroup β] {f : α → β}
    (hf : AEStronglyMeasurable f μ) : AEMeasurable (fun a => (‖f a‖₊ : ℝ≥0∞)) μ
-- Mathlib/Analysis/Convex/Exposed.lean
protected theorem isExtreme (hAB : IsExposed 𝕜 A B) : IsExtreme 𝕜 A B
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem start_mem_support {u v : V} (p : G.Walk u v) : u ∈ p.support
-- Mathlib/Data/Fin/Basic.lean
theorem exists_succ_eq_of_ne_zero {x : Fin (n + 1)} (h : x ≠ 0) :
    ∃ y, Fin.succ y = x
-- Mathlib/Algebra/Opposites.lean
@[to_additive (attr := simp)]
lemma op_eq_one_iff [One α] (a : α) : op a = 1 ↔ a = 1
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem singleton_mul_singleton (a b : α) : ({a} : Finset α) * {b} = {a * b}
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_injective_left (a : α) : Injective (uIcc a)
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem zpow_toGerm (f : α →ₘ[μ] γ) (n : ℤ) : (f ^ n).toGerm = f.toGerm ^ n
-- Mathlib/Topology/Separation.lean
@[symm]
theorem symm : SeparatedNhds s t → SeparatedNhds t s
-- Mathlib/Topology/Instances/ENNReal.lean
theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_sup_compl_le : aᶜ ⊔ bᶜ ≤ (a ⊓ b)ᶜ
-- Mathlib/Order/Filter/AtTopBot.lean
theorem inf_map_atTop_neBot_iff [SemilatticeSup α] [Nonempty α] {F : Filter β} {u : α → β} :
    NeBot (F ⊓ map u atTop) ↔ ∀ U ∈ F, ∀ N, ∃ n ≥ N, u n ∈ U
-- Mathlib/Data/List/EditDistance/Bounds.lean
theorem le_levenshtein_cons (xs : List α) (y ys) :
    ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys)
-- Mathlib/Order/Hom/CompleteLattice.lean
/-- The type of complete lattice homomorphisms from `α` to `β`. -/
structure CompleteLatticeHom (α β : Type*) [CompleteLattice α] [CompleteLattice β] extends
  sInfHom α β where
  /-- The proposition that complete lattice homomorphism commutes with arbitrary suprema/joins. -/
  map_sSup' (s : Set α) : toFun (sSup s) = sSup (toFun '' s)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem toReal_inj {θ ψ : Angle} : θ.toReal = ψ.toReal ↔ θ = ψ
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem reverse_injective : Injective (@reverse α)
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem single_embedding {n : ℕ} (h : 0 < n) (i : Fin n) :
    ((single n h).embedding (0 : Fin 1)) i = i
-- Mathlib/Algebra/Homology/DerivedCategory/Basic.lean
lemma mem_distTriang_iff (T : Triangle (DerivedCategory C)) :
    (T ∈ distTriang (DerivedCategory C)) ↔ ∃ (X Y : CochainComplex C ℤ) (f : X ⟶ Y),
      Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem IsLeast.csInf_mem (H : IsLeast s a) : sInf s ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem join_replicate_singleton : (replicate n [a]).join = replicate n a
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma continuousAt_jacobiTheta₂ (z : ℂ) {τ : ℂ} (hτ : 0 < im τ) :
    ContinuousAt (fun p : ℂ × ℂ ↦ jacobiTheta₂ p.1 p.2) (z, τ)
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
protected theorem hasSum_linearIsometry (f : lp G 2) :
    HasSum (fun i => V i (f i)) (hV.linearIsometry f)
-- Mathlib/NumberTheory/FLT/Three.lean
/-- Given `S' : Solution'`, then there is `S₁ : Solution` such that
`S₁.multiplicity = S'.multiplicity`. -/
lemma exists_Solution_of_Solution' : ∃ (S₁ : Solution hζ), S₁.multiplicity = S'.multiplicity
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem map_some : f <$> some a = some (f a)
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
@[deprecated disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernelBorel (κ : Kernel α (γ × Ω)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelBorel κ = κ
-- Mathlib/CategoryTheory/GlueData.lean
theorem hasColimit_mapGlueData_diagram : HasMulticoequalizer (D.mapGlueData F).diagram
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem decide_mem_cons [BEq α] [LawfulBEq α] {l : List α} :
    decide (y ∈ a :: l) = (y == a || decide (y ∈ l))
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma id (x : 𝕜) : MeromorphicAt id x
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The closure of a set equals the intersection of its open thickenings of positive radii
accumulating at zero. -/
theorem closure_eq_iInter_thickening' (E : Set α) (s : Set ℝ) (hs₀ : s ⊆ Ioi 0)
    (hs : ∀ ε, 0 < ε → (s ∩ Ioc 0 ε).Nonempty) : closure E = ⋂ δ ∈ s, thickening δ E
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Data/ENNReal/Operations.lean
@[gcongr] protected theorem add_lt_add_right : a ≠ ∞ → b < c → b + a < c + a
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_of_const [UniformSpace β] {c : α → β} (h : ∀ a b, c a = c b) :
    UniformContinuous c
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem exists_list_of_mem_closure {s : Set R} {x : R} (h : x ∈ closure s) :
    ∃ L : List (List R), (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = (-1 : R)) ∧ (L.map List.prod).sum = x
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[reassoc (attr := simp)]
theorem image.compIso_hom_comp_image_ι [HasImage f] [IsIso g] :
    (image.compIso f g).hom ≫ image.ι (f ≫ g) = image.ι f ≫ g
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem empty_vecAlt0 (α) {h} : vecAlt0 h (![] : Fin 0 → α) = ![]
-- Mathlib/Analysis/Normed/Group/Basic.lean
/-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
space structure. -/
@[to_additive]
class NormedCommGroup (E : Type*) extends Norm E, CommGroup E, MetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
-- Mathlib/Algebra/Lie/Free.lean
@[simp]
theorem lift_symm_apply (F : FreeLieAlgebra R X →ₗ⁅R⁆ L) : (lift R).symm F = F ∘ of R
-- Mathlib/Algebra/Module/CharacterModule.lean
/-- The `ℤ`-submodule spanned by a single element `a` is isomorphic to the quotient of `ℤ`
by the ideal generated by the order of `a`. -/
@[simps!] noncomputable def intSpanEquivQuotAddOrderOf (a : A) :
    (ℤ ∙ a) ≃ₗ[ℤ] ℤ ⧸ Ideal.span {(addOrderOf a : ℤ)}
-- Mathlib/Data/Matrix/Basic.lean
@[norm_cast]
theorem diagonal_intCast' [Zero α] [IntCast α] (m : ℤ) : diagonal ((m : n → α)) = m
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem erase_eq_eraseP [LawfulBEq α] (a : α) : ∀ l : List α,  l.erase a = l.eraseP (a == ·)
-- Mathlib/Order/Directed.lean
theorem Monotone.directed_le [Preorder α] [IsDirected α (· ≤ ·)] [Preorder β] {f : α → β} :
    Monotone f → Directed (· ≤ ·) f
-- Mathlib/Order/WithBot.lean
@[simp]
theorem toDual_apply_coe (a : α) : WithBot.toDual (a : WithBot α) = toDual a
-- Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
/-- The quadratic form on `Module.Dual R M × M` defined as `Q (f, x) = f x`. -/
@[simps]
def dualProd : QuadraticForm R (Module.Dual R M × M)
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem coe_icisSupHom : (icisSupHom : α → UpperSet α) = Ici
-- Mathlib/Logic/Equiv/Basic.lean
/-- Four-way commutativity of `prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm (α β γ δ : Type*) : (α × β) × γ × δ ≃ (α × γ) × β × δ
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem pointwise_smul_subset_iff {a : α} {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T
-- Mathlib/Data/Fin/Basic.lean
theorem succ_castPred_eq_castPred_succ {a : Fin (n + 1)} (ha : a ≠ last n)
    (ha' := a.succ_ne_last_iff.mpr ha) :
    (a.castPred ha).succ = (succ a).castPred ha'
-- Mathlib/Topology/Instances/RatLemmas.lean
theorem interior_compact_eq_empty (hs : IsCompact s) : interior s = ∅