ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
/-- If a function has a finite power series on a ball, then so does its derivative. -/
protected theorem HasFiniteFPowerSeriesOnBall.fderiv
    (h : HasFiniteFPowerSeriesOnBall f p x (n + 1) r) :
    HasFiniteFPowerSeriesOnBall (fderiv 𝕜 f) p.derivSeries x n r
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem hasStrictDerivAt_arsinh (x : ℝ) : HasStrictDerivAt arsinh (√(1 + x ^ 2))⁻¹ x
-- Mathlib/Algebra/Order/Archimedean.lean
theorem exists_rat_lt (x : α) : ∃ q : ℚ, (q : α) < x
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFinset_eq_empty_iff : G.cliqueFinset n = ∅ ↔ G.CliqueFree n
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
@[reassoc (attr := simp)]
theorem δ_naturality {X' X : SimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 2)) :
    X.δ i ≫ f.app (op [n]) = f.app (op [n + 1]) ≫ X'.δ i
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem preimage_emetric_closedBall (h : α ≃ᵢ β) (x : β) (r : ℝ≥0∞) :
    h ⁻¹' EMetric.closedBall x r = EMetric.closedBall (h.symm x) r
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem gcd_union (s₁ s₂ : Multiset α) : (s₁ ∪ s₂).gcd = GCDMonoid.gcd s₁.gcd s₂.gcd
-- Mathlib/Probability/Kernel/IntegralCompProd.lean
theorem integral_compProd :
    ∀ {f : β × γ → E} (_ : Integrable f ((κ ⊗ₖ η) a)),
      ∫ z, f z ∂(κ ⊗ₖ η) a = ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_comp [MeasurableSpace β] {f : β → ℝ≥0∞} {g : α → β} (hf : Measurable f)
    (hg : Measurable g) : lintegral μ (f ∘ g) = ∫⁻ a, f a ∂map g μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_pi_div_two_sub (x : ℂ) : tan (π / 2 - x) = (tan x)⁻¹
-- Mathlib/Order/SupIndep.lean
@[simp]
theorem supIndep_pair [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    ({i, j} : Finset ι).SupIndep f ↔ Disjoint (f i) (f j)
-- Mathlib/CategoryTheory/Idempotents/KaroubiKaroubi.lean
/-- The counit isomorphism of the equivalence -/
@[simps]
def counitIso : inverse C ⋙ toKaroubi (Karoubi C) ≅ 𝟭 (Karoubi (Karoubi C))
-- Mathlib/Data/Matroid/Restrict.lean
theorem Basis.basis_restrict_of_subset (hI : M.Basis I X) (hXY : X ⊆ Y) : (M ↾ Y).Basis I X
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_integral_le_of_norm_le {f : α → G} {g : α → ℝ} (hg : Integrable g μ)
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ g x) : ‖∫ x, f x ∂μ‖ ≤ ∫ x, g x ∂μ
-- Mathlib/Data/PNat/Xgcd.lean
theorem reduce_v : ∀ u : XgcdType, u.reduce.v = u.v
-- Mathlib/Order/UpperLower/Basic.lean
theorem Ici_prod (x : α × β) : Ici x = Ici x.1 ×ˢ Ici x.2
-- Mathlib/Order/Lattice.lean
@[simp]
theorem swap_inf [Inf α] [Inf β] (p q : α × β) : (p ⊓ q).swap = p.swap ⊓ q.swap
-- Mathlib/Order/Concept.lean
@[simp]
theorem sup_fst (c d : Concept α β r) : (c ⊔ d).fst = extentClosure r (c.snd ∩ d.snd)
-- Mathlib/Algebra/Star/Order.lean
lemma NonUnitalStarRingHom.map_le_map_of_map_star (f : R →⋆ₙ+* S) {x y : R} (hxy : x ≤ y) :
    f x ≤ f y
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
/-- If `f b = 1` for all `b ∈ t`, then the product of `f a` with `a ∈ s` is the same as the
product of `f a` with `a ∈ s ∖ t`. -/
@[to_additive "If `f b = 0` for all `b ∈ t`, then the sum of `f a` with `a ∈ s` is the same as the
sum of `f a` with `a ∈ s ∖ t`."]
lemma tprod_setElem_eq_tprod_setElem_diff {f : β → α} (s t : Set β)
    (hf₀ : ∀ b ∈ t, f b = 1) :
    ∏' a : s, f a = ∏' a : (s \ t : Set β), f a
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma LeftHomologyMapData.quasiIso_map_iff
    [(F.mapShortComplex.obj S₁).HasHomology]
    [(F.mapShortComplex.obj S₂).HasHomology]
    [hl₁.IsPreservedBy F] [hl₂.IsPreservedBy F] :
    QuasiIso (F.mapShortComplex.map φ) ↔ IsIso (F.map ψl.φH)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem norm_integral_le_of_norm_le_const {a b C : ℝ} {f : ℝ → E} (h : ∀ x ∈ Ι a b, ‖f x‖ ≤ C) :
    ‖∫ x in a..b, f x‖ ≤ C * |b - a|
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem sum_apply₀ (f : ι → Measure α) {s : Set α} (hs : NullMeasurableSet s (sum f)) :
    sum f s = ∑' i, f i s
-- Mathlib/GroupTheory/Perm/Basic.lean
/-- Lift a monoid homomorphism `f : G →* Function.End α` to a monoid homomorphism
`f : G →* Equiv.Perm α`. -/
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[continuity, fun_prop]
theorem Continuous.zpow₀ (hf : Continuous f) (m : ℤ) (h0 : ∀ a, f a ≠ 0 ∨ 0 ≤ m) :
    Continuous fun x => f x ^ m
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- An orthogonal family forms an independent family of subspaces; that is, any collection of
elements each from a different subspace in the family is linearly independent. In particular, the
pairwise intersections of elements of the family are 0. -/
theorem OrthogonalFamily.independent {V : ι → Submodule 𝕜 E}
    (hV : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    CompleteLattice.Independent V
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
/-- Coercing a `Matrix.SpecialLinearGroup` via `GL_pos` and `GL` is the same as coercing straight to
a matrix. -/
@[simp]
theorem coe_GLPos_coe_GL_coe_matrix (g : SpecialLinearGroup n R) :
    (↑(↑(↑g : GLPos n R) : GL n R) : Matrix n n R) = ↑g
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem bind₂_monomial (f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R) :
    bind₂ f (monomial d r) = f r * monomial d 1
-- Mathlib/Algebra/Ring/NegOnePow.lean
lemma negOnePow_eq_iff (n₁ n₂ : ℤ) :
    n₁.negOnePow = n₂.negOnePow ↔ Even (n₁ - n₂)
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a
-- Mathlib/Data/Set/Card.lean
theorem ncard_strictMono [Finite α] : @StrictMono (Set α) _ _ _ ncard
-- Mathlib/CategoryTheory/Limits/Presheaf.lean
/--
The functor taking `(E : ℰ) (c : Cᵒᵖ)` to the homset `(A.obj C ⟶ E)`. It is shown in `L_adjunction`
that this functor has a left adjoint (provided `E` has colimits) given by taking colimits over
categories of elements.
In the case where `ℰ = Cᵒᵖ ⥤ Type u` and `A = yoneda`, this functor is isomorphic to the identity.

Defined as in [MM92], Chapter I, Section 5, Theorem 2.
-/
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- If `X` is a zero object, `Y ≅ X ⊞ Y` for any `Y`. -/
@[simps]
def isoZeroBiprod {X Y : C} [HasBinaryBiproduct X Y] (hY : IsZero X) : Y ≅ X ⊞ Y
-- Mathlib/Order/WithBot.lean
@[simp]
theorem untop'_coe {α} (d x : α) : untop' d x = x
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_re_add_im {f : X → 𝕜} (hf : Integrable f μ) :
    ((∫ x, RCLike.re (f x) ∂μ : ℝ) : 𝕜) + (∫ x, RCLike.im (f x) ∂μ : ℝ) * RCLike.I =
      ∫ x, f x ∂μ
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma lift_snd :
    (Cochain.ofHom (lift φ α β eq)).comp (snd φ) (zero_add 0) = β
-- Mathlib/Data/Real/Hyperreal.lean
theorem not_infinite_of_exists_st {x : ℝ*} : (∃ r : ℝ, IsSt x r) → ¬Infinite x
-- Mathlib/GroupTheory/Nilpotent.lean
theorem upperCentralSeries_eq_top_iff_nilpotencyClass_le {n : ℕ} :
    upperCentralSeries G n = ⊤ ↔ Group.nilpotencyClass G ≤ n
-- Mathlib/Data/Matroid/Restrict.lean
theorem Basis.of_restriction (hI : N.Basis I X) (hNM : N ≤r M) : M.Basis I X
-- Mathlib/Data/Finset/Sym.lean
@[simp]
theorem diag_mem_sym2_mem_iff : (∀ b, b ∈ Sym2.diag a → b ∈ s) ↔ a ∈ s
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_mono (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁ₛ[μ] G''}
    (hfg : f ≤ g) : setToL1S T f ≤ setToL1S T g
-- Mathlib/Order/Category/Semilat.lean
@[simp]
theorem coe_of (α : Type*) [SemilatticeSup α] [OrderBot α] : ↥(of α) = α
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem map_proj_nhds (ex : x ∈ e.source) : map proj (𝓝 x) = 𝓝 (proj x)
-- Mathlib/GroupTheory/Subgroup/Center.lean
/-- For a group with zero, the center of the units is the same as the units of the center. -/
@[simps! apply_val_coe symm_apply_coe_val]
def centerUnitsEquivUnitsCenter (G₀ : Type*) [GroupWithZero G₀] :
    Subgroup.center (G₀ˣ) ≃* (Submonoid.center G₀)ˣ
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
/-- Coercion of a `MulHom` into a function is itself a `MulHom`.

See also `MulHom.eval`. -/
@[to_additive (attr := simps) "Coercion of an `AddHom` into a function is itself an `AddHom`.

See also `AddHom.eval`."]
def MulHom.coeFn (α β : Type*) [Mul α] [CommSemigroup β] :
    (α →ₙ* β) →ₙ* α → β
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem Nondegenerate.ker_eq_bot {B : BilinForm R M} (h : B.Nondegenerate) :
    LinearMap.ker B = ⊥
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma nonsingular_iff' (x y : R) : W.Nonsingular x y ↔ W.Equation x y ∧
    (W.a₁ * y - (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄) ≠ 0 ∨ 2 * y + W.a₁ * x + W.a₃ ≠ 0)
-- Mathlib/Data/Matrix/DMatrix.lean
theorem map_sub [∀ i j, AddGroup (α i j)] {β : m → n → Type w} [∀ i j, AddGroup (β i j)]
    (f : ∀ ⦃i j⦄, α i j →+ β i j) (M N : DMatrix m n α) :
    ((M - N).map fun i j => @f i j) = (M.map fun i j => @f i j) - N.map fun i j => @f i j
-- Mathlib/Data/Nat/Factorization/Basic.lean
@[to_additive sum_primeFactors_gcd_add_sum_primeFactors_mul]
theorem prod_primeFactors_gcd_mul_prod_primeFactors_mul {β : Type*} [CommMonoid β] (m n : ℕ)
    (f : ℕ → β) :
    (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f =
      m.primeFactors.prod f * n.primeFactors.prod f
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- If the affine span of a set is `⊤`, then the vector span of the same set is the `⊤`. -/
theorem vectorSpan_eq_top_of_affineSpan_eq_top {s : Set P} (h : affineSpan k s = ⊤) :
    vectorSpan k s = ⊤
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The closed ball of radius `δ` centered at a point of `E` is included in the closed
thickening of `E`. -/
theorem closedBall_subset_cthickening {α : Type*} [PseudoMetricSpace α] {x : α} {E : Set α}
    (hx : x ∈ E) (δ : ℝ) : closedBall x δ ⊆ cthickening δ E
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
theorem isZero_of_subsingleton (V : SemiNormedGrp₁) [Subsingleton V] : Limits.IsZero V
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem fderiv_cos (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x
-- Mathlib/Algebra/Star/Pointwise.lean
@[simp]
theorem image_star [InvolutiveStar α] : Star.star '' s = s⋆
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ofNat_mod (m n : Nat) : (↑(m % n) : Int) = mod m n
-- Mathlib/GroupTheory/Congruence/Basic.lean
@[to_additive (attr := simp)]
theorem coe_mk' : (c.mk' : M → c.Quotient) = ((↑) : M → c.Quotient)
-- Mathlib/Data/Int/Defs.lean
lemma natAbs_sq (x : ℤ) : (x.natAbs : ℤ) ^ 2 = x ^ 2
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_self_nonneg [IsRightCancelAdd α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α] [CovariantClass α α (· + ·) (· < ·)]
    (a : α) : 0 ≤ a * a
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
@[simp]
lemma rightHomologyMap_smul : rightHomologyMap (a • φ) = a • rightHomologyMap φ
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem toSubmonoid_injective : Function.Injective (toSubmonoid : Subgroup G → Submonoid G)
-- Mathlib/NumberTheory/Multiplicity.lean
theorem pow_prime_sub_pow_prime :
    multiplicity (↑p) (x ^ p - y ^ p) = multiplicity (↑p) (x - y) + 1
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp)]
theorem Sigma.ι_reindex_inv (b : β) :
    Sigma.ι f (ε b) ≫ (Sigma.reindex ε f).inv = Sigma.ι (f ∘ ε) b
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp] theorem interior_Iio : interior (Iio a) = Iio a
-- Mathlib/Algebra/Order/Field/Basic.lean
@[gcongr]
lemma div_lt_div_of_pos_right (h : a < b) (hc : 0 < c) : a / c < b / c
-- Mathlib/Data/ENat/Basic.lean
lemma toNat_le_of_le_coe {m : ℕ∞} {n : ℕ} (h : m ≤ n) : toNat m ≤ n
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem refl_comp (g : M ≃[L] N) : (refl L N).comp g = g
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem uniformity_basis_dist_rat :
    (𝓤 α).HasBasis (fun r : ℚ => 0 < r) fun r => { p : α × α | dist p.1 p.2 < r }
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem zeroLocus_iUnion₂ {ι : Sort*} {κ : (i : ι) → Sort*} (s : ∀ i, κ i → Set R) :
    zeroLocus (⋃ (i) (j), s i j) = ⋂ (i) (j), zeroLocus (s i j)
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem coeff_C : coeff (C a) n = ite (n = 0) a 0
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem ofList_nil : ofList [] = (nil : WSeq α)
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem toNat_strictMonoOn : StrictMonoOn toNat (Iio ℵ₀)
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem Cofork.IsColimit.existsUnique {s : Cofork f g} (hs : IsColimit s) {W : C} (k : Y ⟶ W)
    (h : f ≫ k = g ≫ k) : ∃! d : s.pt ⟶ W, Cofork.π s ≫ d = k
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem Bool.sup_eq_bor : (· ⊔ ·) = or
-- Mathlib/Data/Set/Function.lean
theorem injOn_insert {f : α → β} {s : Set α} {a : α} (has : a ∉ s) :
    Set.InjOn f (insert a s) ↔ Set.InjOn f s ∧ f a ∉ f '' s
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem comp_self : f ∘ f = id
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem AdjoinMonic.algebraMap : algebraMap k (AdjoinMonic k) = (Ideal.Quotient.mk _).comp
    (C : k →+* MvPolynomial (MonicIrreducible k) k)
-- Mathlib/Data/Finset/Basic.lean
theorem not_disjoint_iff : ¬Disjoint s t ↔ ∃ a, a ∈ s ∧ a ∈ t
-- Mathlib/Order/BoundedOrder.lean
lemma top_inf_eq (a : α) : ⊤ ⊓ a = a
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive (attr := simp)]
theorem prod_zero_index {h : α → M → N} : (0 : α →₀ M).prod h = 1
-- Mathlib/RingTheory/Norm/Basic.lean
/-- Given `pb : PowerBasis K S`, then the norm of `pb.gen` is
`(-1) ^ pb.dim * coeff (minpoly K pb.gen) 0`. -/
theorem PowerBasis.norm_gen_eq_coeff_zero_minpoly (pb : PowerBasis R S) :
    norm R pb.gen = (-1) ^ pb.dim * coeff (minpoly R pb.gen) 0
-- Mathlib/Order/Interval/Set/WithBotTop.lean
theorem image_coe_Ioc : (some : α → WithBot α) '' Ioc a b = Ioc (a : WithBot α) b
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem lintegral_coe_eq_integral (f : α → ℝ≥0) (hfi : Integrable (fun x => (f x : ℝ)) μ) :
    ∫⁻ a, f a ∂μ = ENNReal.ofReal (∫ a, f a ∂μ)
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- Same as `Polynomial.natSepDegree_eq_natDegree_of_separable`, but enables the use of
dot notation. -/
theorem Separable.natSepDegree_eq_natDegree (h : f.Separable) :
    f.natSepDegree = f.natDegree
-- Mathlib/Algebra/Algebra/Operations.lean
theorem le_pow_toAddSubmonoid {n : ℕ} : M.toAddSubmonoid ^ n ≤ (M ^ n).toAddSubmonoid
-- Mathlib/Data/Vector/Zip.lean
@[simp]
theorem zipWith_get (x : Vector α n) (y : Vector β n) (i) :
    (Vector.zipWith f x y).get i = f (x.get i) (y.get i)
-- Mathlib/CategoryTheory/Products/Bifunctor.lean
@[simp]
theorem map_comp_id (F : C × D ⥤ E) (X Y Z : C) (W : D) (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.map ((f ≫ g, 𝟙 W) : (X, W) ⟶ (Z, W)) =
      F.map ((f, 𝟙 W) : (X, W) ⟶ (Y, W)) ≫ F.map ((g, 𝟙 W) : (Y, W) ⟶ (Z, W))
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp, reassoc]
lemma Scheme.restrictRestrict_hom_restrict (X : Scheme.{u}) (U : X.Opens)
    (V : U.toScheme.Opens) :
    (X.restrictRestrict U V).hom ≫ Opens.ι _ = V.ι ≫ U.ι
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- Version of `isProperMap_iff_isCompact_preimage` in terms of `cocompact`. -/
lemma isProperMap_iff_tendsto_cocompact [T2Space Y]
    (compactlyGenerated : ∀ s : Set Y, IsClosed s ↔ ∀ ⦃K⦄, IsCompact K → IsClosed (s ∩ K)) :
    IsProperMap f ↔ Continuous f ∧ Tendsto f (cocompact X) (cocompact Y)
-- Mathlib/Topology/Baire/Lemmas.lean
/-- Baire theorem: a countable intersection of dense open sets is dense. Formulated here with
an index set which is a countable set in any type. -/
theorem dense_biInter_of_isOpen {S : Set α} {f : α → Set X} (ho : ∀ s ∈ S, IsOpen (f s))
    (hS : S.Countable) (hd : ∀ s ∈ S, Dense (f s)) : Dense (⋂ s ∈ S, f s)
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem inv_mul_integral_comp_div : (c⁻¹ * ∫ x in a..b, f (x / c)) = ∫ x in a / c..b / c, f x
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
@[simp]
theorem logb_one : logb b 1 = 0
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem frobenius_pow {p : ℕ} [Fact p.Prime] [CharP K p] {n : ℕ} (hcard : q = p ^ n) :
    frobenius K p ^ n = 1
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- A function which can be locally uniformly approximated by functions which are continuous
on a set is continuous on this set. -/
theorem continuousOn_of_locally_uniform_approx_of_continuousWithinAt
    (L : ∀ x ∈ s, ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝[s] x, ∃ F,
      ContinuousWithinAt F s x ∧ ∀ y ∈ t, (f y, F y) ∈ u) :
    ContinuousOn f s
-- Mathlib/Data/PNat/Basic.lean
@[simp]
theorem ofNat_le_ofNat {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) ≤ no_index (OfNat.ofNat n) ↔ OfNat.ofNat m ≤ OfNat.ofNat n
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.getElem_inj_iff {l : List α} (h : Nodup l)
    {i : Nat} {hi : i < l.length} {j : Nat} {hj : j < l.length} :
    l[i] = l[j] ↔ i = j
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem one_le_rpow_of_pos_of_le_one_of_neg {x : ℝ≥0∞} {z : ℝ} (hx1 : 0 < x) (hx2 : x ≤ 1)
    (hz : z < 0) : 1 ≤ x ^ z
-- Mathlib/Data/Finmap.lean
@[simp]
theorem lookup_erase (a) (s : Finmap β) : lookup a (erase a s) = none
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_xor_odd' (n : ℕ) : ∃ k, Xor' (n = 2 * k) (n = 2 * k + 1)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_eq_zero_symm {x y : E} : ⟪x, y⟫ = 0 ↔ ⟪y, x⟫ = 0
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
lemma IsLocallyFiniteMeasure.withDensity_coe {f : α → ℝ≥0} (hf : Continuous f) :
    IsLocallyFiniteMeasure (μ.withDensity fun x ↦ f x)
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.dvd_of_dvd_mul_right (H1 : Coprime k n) (H2 : k ∣ m * n) : k ∣ m
-- Mathlib/Order/Max.lean
protected theorem IsMax.eq_of_ge (ha : IsMax a) (h : a ≤ b) : b = a
-- Mathlib/Analysis/BoxIntegral/Basic.lean
@[simp]
theorem integralSum_smul (c : ℝ) (f : ℝⁿ → E) (vol : ι →ᵇᵃ E →L[ℝ] F) (π : TaggedPrepartition I) :
    integralSum (c • f) vol π = c • integralSum f vol π
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
lemma FarFromTriangleFree.lt_half (hG : G.FarFromTriangleFree ε) : ε < 2⁻¹
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem coe_zero : ⇑(0 : Derivation R A M) = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
theorem lcm_dvd {m n k : Nat} (H1 : m ∣ k) (H2 : n ∣ k) : lcm m n ∣ k
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem isBounded_of_image2_left (f : α → β → γ) {K₁ : ℝ≥0}
    (hf : ∀ b, AntilipschitzWith K₁ fun a => f a b) {s : Set α} {t : Set β}
    (hst : IsBounded (Set.image2 f s t)) : IsBounded s ∨ IsBounded t
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- Conjugation acting on fixed element of the group is continuous when both `mul` and
`inv` are continuous. -/
@[to_additive (attr := continuity)
  "Conjugation acting on fixed element of the additive group is continuous when both
    `add` and `neg` are continuous."]
theorem TopologicalGroup.continuous_conj' [ContinuousInv G] (h : G) :
    Continuous fun g : G => g * h * g⁻¹
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
@[simp]
theorem trunc_add (n) (φ ψ : R⟦X⟧) : trunc n (φ + ψ) = trunc n φ + trunc n ψ
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem leftUnitor_naturality {f g : a ⟶ b} (η : f ⟶ g) :
    𝟙 a ◁ η ≫ (λ_ g).hom = (λ_ f).hom ≫ η
-- Mathlib/Order/LiminfLimsup.lean
theorem isBoundedUnder_const [IsRefl α r] {l : Filter β} {a : α} : IsBoundedUnder r l fun _ => a
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem pi_le_borel_pi {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, MeasurableSpace (π i)] [∀ i, BorelSpace (π i)] :
      MeasurableSpace.pi ≤ borel (∀ i, π i)
-- Mathlib/RingTheory/Coprime/Basic.lean
/-- If a 2-vector `p` satisfies `IsCoprime (p 0) (p 1)`, then `p ≠ 0`. -/
theorem IsCoprime.ne_zero [Nontrivial R] {p : Fin 2 → R} (h : IsCoprime (p 0) (p 1)) : p ≠ 0
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem one_sub_mem {t : β} (ht : t ∈ Icc (0 : β) 1) : 1 - t ∈ Icc (0 : β) 1
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
/-- A bilinear map is right-separating if and only if its flip has a trivial kernel. -/
theorem separatingRight_iff_flip_ker_eq_bot {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.SeparatingRight ↔ LinearMap.ker B.flip = ⊥
-- Mathlib/Data/Real/EReal.lean
lemma coe_inv (x : ℝ) : (x⁻¹ : ℝ) = (x : EReal)⁻¹
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_iff_two_dvd : Even a ↔ 2 ∣ a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem ExprCnstr.eq_false_of_isUnsat (ctx : Context) (c : ExprCnstr) (h : c.toNormPoly.isUnsat) : c.denote ctx = False
-- Mathlib/NumberTheory/SmoothNumbers.lean
@[simp]
lemma smoothNumbers_zero : smoothNumbers 0 = {1}
-- Mathlib/Order/Max.lean
protected theorem isTop (a : α) : IsTop a
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem map_bot (f : F) : map f (⊥ : NonUnitalSubsemiring R) = (⊥ : NonUnitalSubsemiring S)
-- Mathlib/Combinatorics/HalesJewett.lean
/-- The type of lines that are only one color except possibly at their endpoints. -/
structure AlmostMono {α ι κ : Type*} (C : (ι → Option α) → κ) where
  /-- The underlying line of an almost monochromatic line, where the coordinate dimension `α` is
  extended by an additional symbol `none`, thought to be marking the endpoint of the line. -/
  line : Line (Option α) ι
  /-- The main color of an almost monochromatic line. -/
  color : κ
  /-- The proposition that the underlying line of an almost monochromatic line assumes its main
  color except possibly at the endpoints. -/
  has_color : ∀ x : α, C (line (some x)) = color
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem encode_inj [Encodable α] {a b : α} : encode a = encode b ↔ a = b
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem foldl_data_eq_bind (l : List α) (acc : Array β)
    (F : Array β → α → Array β) (G : α → List β)
    (H : ∀ acc a, (F acc a).data = acc.data ++ G a) :
    (l.foldl F acc).data = acc.data ++ l.bind G
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem u_exists :
    ∃ u : E → ℝ,
      ContDiff ℝ ⊤ u ∧ (∀ x, u x ∈ Icc (0 : ℝ) 1) ∧ support u = ball 0 1 ∧ ∀ x, u (-x) = u x
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp 1100]
lemma mk₀_comp_mk₀ (f : X ⟶ Y) (g : Y ⟶ Z) :
    (mk₀ f).comp (mk₀ g) (zero_add 0) = mk₀ (f ≫ g)
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma LSeriesSummable.LSeriesHasSum {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    LSeriesHasSum f s (LSeries f s)
-- Mathlib/Data/Multiset/Functor.lean
@[simp]
theorem map_comp_coe {α β} (h : α → β) :
    Functor.map h ∘ Coe.coe = (Coe.coe ∘ Functor.map h : List α → Multiset β)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem concat_and_concat (x y : BitVec w) (a b : Bool) :
    (concat x a) &&& (concat y b) = concat (x &&& y) (a && b)
-- Mathlib/Data/Stream/Init.lean
theorem nats_eq : nats = cons 0 (map succ nats)
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem Function.Surjective.lieModuleIsNilpotent [IsNilpotent R L M] : IsNilpotent R L₂ M₂
-- Mathlib/Data/Finset/Sups.lean
@[simp, norm_cast]
theorem coe_sups : (↑(s ⊻ t) : Set α) = ↑s ⊻ ↑t
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean
theorem card_set_walk_length_eq (u v : V) (n : ℕ) :
    Fintype.card {p : G.Walk u v | p.length = n} = (G.finsetWalkLength n u v).card
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Right'_nil_right : map₂Right' f as [] = ([], as)
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[reassoc (attr := simp)]
theorem μ_inv_hom_id (X Y : C) : (F.μIso X Y).inv ≫ F.μ X Y = 𝟙 _
-- Mathlib/Data/List/Sort.lean
theorem Sorted.le_head! [Inhabited α] [Preorder α] {a : α} {l : List α} (h : Sorted (· > ·) l)
    (ha : a ∈ l) : a ≤ l.head!
-- Mathlib/CategoryTheory/Bicategory/Adjunction.lean
@[simp]
theorem rightZigzagIso_symm : (rightZigzagIso η ε).symm = leftZigzagIso ε.symm η.symm