ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Covering.lean
protected theorem FiberBundle.isCoveringMap {F : Type*} {E : X → Type*} [TopologicalSpace F]
    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
    [FiberBundle F E] : IsCoveringMap (π F E)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem bot_eq_empty : (⊥ : Set α) = ∅
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem leadingCoeff_of_single {a : Γ} {r : R} : leadingCoeff (single a r) = r
-- Mathlib/GroupTheory/Sylow.lean
/-- If `H` is a subgroup of `G` of cardinality `p ^ n`, then the cardinality of the
  normalizer of `H` is congruent mod `p ^ (n + 1)` to the cardinality of `G`.  -/
theorem card_normalizer_modEq_card [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime] {H : Subgroup G}
    (hH : Nat.card H = p ^ n) : Nat.card (normalizer H) ≡ Nat.card G [MOD p ^ (n + 1)]
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem monotone_restrict : Monotone fun π : Prepartition I => restrict π J
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem differentiableWithinAt_inter' (ht : t ∈ 𝓝[s] x) :
    DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Analysis/Normed/Group/InfiniteSum.lean
theorem Summable.of_nnnorm {f : ι → E} (hf : Summable fun a => ‖f a‖₊) : Summable f
-- Mathlib/Algebra/MvPolynomial/Comap.lean
@[simp]
theorem comap_id_apply (x : σ → R) : comap (AlgHom.id R (MvPolynomial σ R)) x = x
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
/-- `TrivSqZeroExt.inr` as a continuous linear map. -/
@[simps]
def inrCLM [CommSemiring R] [AddCommMonoid M] [Module R M] : M →L[R] tsze R M
-- Mathlib/Algebra/MvPolynomial/PDeriv.lean
theorem pderiv_pow {i : σ} {f : MvPolynomial σ R} {n : ℕ} :
    pderiv i (f ^ n) = n * f ^ (n - 1) * pderiv i f
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem front : ∀ {s}, ValidFor l (c :: m) r s → s.front = c
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biproduct.ι_matrix (m : ∀ j k, f j ⟶ g k) (j : J) :
    biproduct.ι f j ≫ biproduct.matrix m = biproduct.lift fun k => m j k
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_iff_ker_lsmul_eq_bot :
    IsSMulRegular M r ↔ LinearMap.ker (LinearMap.lsmul R M r) = ⊥
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp]
theorem algebraMap_eq_toLaurent (f : R[X]) : algebraMap R[X] R[T;T⁻¹] f = toLaurent f
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem coeff_inv_units (u : R[X]ˣ) (n : ℕ) : ((↑u : R[X]).coeff n)⁻¹ = (↑u⁻¹ : R[X]).coeff n
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Subgroup Gᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂
-- .lake/packages/lean4/src/lean/Init/Data/String/Lemmas.lean
@[simp] protected theorem lt_irrefl (s : String) : ¬ s < s
-- Mathlib/Algebra/AddConstMap/Basic.lean
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
    Semiconj f (· + a) (· + b)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_coe_finset {α : Type u} {s : Finset α} : #s = ↑(Finset.card s)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem length_merge (s : α → α → Bool) (l r) :
    (merge s l r).length = l.length + r.length
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem roots_pow (p : R[X]) (n : ℕ) : (p ^ n).roots = n • p.roots
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Icc_mem_nhdsWithin_Ici (H : b ∈ Ico a c) : Icc a c ∈ 𝓝[≥] b
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem closure_ae_eq_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    closure s =ᵐ[μ] s
-- Mathlib/Data/Matroid/Constructions.lean
theorem eq_emptyOn [IsEmpty α] (M : Matroid α) : M = emptyOn α
-- Mathlib/GroupTheory/SpecificGroups/Quaternion.lean
@[simp]
theorem a_one_pow (k : ℕ) : (a 1 : QuaternionGroup n) ^ k = a k
-- Mathlib/Combinatorics/Quiver/Basic.lean
@[simp]
theorem id_comp {U V : Type*} [Quiver U] [Quiver V] (F : Prefunctor U V) :
    (id _).comp F = F
-- Mathlib/Topology/Clopen.lean
theorem isClopen_iInter_of_finite [Finite Y] {s : Y → Set X} (h : ∀ i, IsClopen (s i)) :
    IsClopen (⋂ i, s i)
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- If `I` is a nonzero fractional ideal, then `I` is equal to the product `∏_v v^(count K v I)`. -/
theorem finprod_heightOneSpectrum_factorization' {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) :
    ∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^ (count K v I) = I
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem cospanExt_inv_app_left :
    (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.left = iX.inv
-- Mathlib/Topology/Instances/ENNReal.lean
theorem continuousOn_sub :
    ContinuousOn (fun p : ℝ≥0∞ × ℝ≥0∞ => p.fst - p.snd) { p : ℝ≥0∞ × ℝ≥0∞ | p ≠ ⟨∞, ∞⟩ }
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
@[reassoc (attr := simp)]
lemma whiskerLeft_snd (X : C) {Y₁ Y₂ : C} (g : Y₁ ⟶ Y₂) :
    (X ◁ g) ≫ snd _ _ = snd _ _ ≫ g
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive] lemma oneLePart_inf_leOnePart_eq_one (a : α) : a⁺ᵐ ⊓ a⁻ᵐ = 1
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_pair {f : β → α} {a b : β} : ⨆ x ∈ ({a, b} : Set β), f x = f a ⊔ f b
-- Mathlib/Data/Finsupp/Basic.lean
/-- `Finsupp.mapDomain` is an `AddMonoidHom`. -/
@[simps]
def mapDomain.addMonoidHom (f : α → β) : (α →₀ M) →+ β →₀ M
-- Mathlib/Analysis/Convex/Topology.lean
/-- A nonempty convex set is path connected. -/
protected theorem Convex.isPathConnected {s : Set E} (hconv : Convex ℝ s) (hne : s.Nonempty) :
    IsPathConnected s
-- Mathlib/Algebra/Module/Equiv/Basic.lean
/-- `g : R ≃+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma den_ofNat (n : ℕ) [n.AtLeastTwo] : den (no_index (OfNat.ofNat n)) = 1
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
/-- Let `I` be a fractional ideal of `K`. Assume that `f : InfinitePlace K → ℝ≥0` is such that
`minkowskiBound K I < volume (convexBodyLT K f)` where `convexBodyLT K f` is the set of
points `x` such that `‖x w‖ < f w` for all infinite places `w` (see `convexBodyLT_volume` for
the computation of this volume), then there exists a nonzero algebraic number `a` in `I` such
that `w a < f w` for all infinite places `w`. -/
theorem exists_ne_zero_mem_ideal_lt (h : minkowskiBound K I < volume (convexBodyLT K f)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
/-- Suppose that `p₁` and `p₂` lie in spheres `s₁` and `s₂`. Then the vector between the centers
of those spheres is orthogonal to that between `p₁` and `p₂`; this is a version of
`inner_vsub_vsub_of_dist_eq_of_dist_eq` for bundled spheres. (In two dimensions, this says that
the diagonals of a kite are orthogonal.) -/
theorem inner_vsub_vsub_of_mem_sphere_of_mem_sphere {p₁ p₂ : P} {s₁ s₂ : Sphere P} (hp₁s₁ : p₁ ∈ s₁)
    (hp₂s₁ : p₂ ∈ s₁) (hp₁s₂ : p₁ ∈ s₂) (hp₂s₂ : p₂ ∈ s₂) :
    ⟪s₂.center -ᵥ s₁.center, p₂ -ᵥ p₁⟫ = 0
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem get_replicate (a : α) (i : Fin n) : (Vector.replicate n a).get i = a
-- Mathlib/Topology/Constructions.lean
theorem nhdsWithin_subtype_eq_bot_iff {s t : Set X} {x : s} :
    𝓝[((↑) : s → X) ⁻¹' t] x = ⊥ ↔ 𝓝[t] (x : X) ⊓ 𝓟 s = ⊥
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem ClosedEmbedding.measurable {f : α → γ} (hf : ClosedEmbedding f) : Measurable f
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem of_apply (x : K) : of K p x = mk _ _ (0, x)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.div_const {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => f x / c) μ
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The vector space of functions on a `Fintype ι` has finrank equal to the cardinality of `ι`. -/
@[simp]
theorem FiniteDimensional.finrank_fintype_fun_eq_card : finrank R (η → R) = Fintype.card η
-- Mathlib/Topology/Bornology/Absorbs.lean
lemma _root_.Set.Finite.absorbs_sUnion {T : Set (Set α)} (hT : T.Finite) :
    Absorbs M s (⋃₀ T) ↔ ∀ t ∈ T, Absorbs M s t
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformlyOn.prod_map {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
    {f' : α' → β'} {p' : Filter ι'} {s' : Set α'} (h : TendstoUniformlyOn F f p s)
    (h' : TendstoUniformlyOn F' f' p' s') :
    TendstoUniformlyOn (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p')
      (s ×ˢ s')
-- Mathlib/Topology/Algebra/FilterBasis.lean
@[to_additive]
theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
    HasBasis (@nhds G B.topology x₀) (fun V : Set G ↦ V ∈ B) fun V ↦ (fun y ↦ x₀ * y) '' V
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem associated_gcd_gcd [IsDomain R] [GCDMonoid R] :
    Associated (IsBezout.gcd x y) (GCDMonoid.gcd x y)
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[aesop 90% apply]
theorem sub {x y : R} (hx : IsSelfAdjoint x) (hy : IsSelfAdjoint y) : IsSelfAdjoint (x - y)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem iff_true_right (ha : a) : (b ↔ a) ↔ b
-- Mathlib/Probability/Density.lean
theorem HasPDF.congr {X Y : Ω → E} {ℙ : Measure Ω} {μ : Measure E} (hXY : X =ᵐ[ℙ] Y)
    [hX : HasPDF X ℙ μ] : HasPDF Y ℙ μ
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Nat.not_lt_zero (n : Nat) : Not (LT.lt n 0)
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem coeFn_const (b : β) : (const α b : α →ₘ[μ] β) =ᵐ[μ] Function.const α b
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem measurePreserving_piFinSuccAbove {n : ℕ} {α : Fin (n + 1) → Type u}
    {m : ∀ i, MeasurableSpace (α i)} (μ : ∀ i, Measure (α i)) [∀ i, SigmaFinite (μ i)]
    (i : Fin (n + 1)) :
    MeasurePreserving (MeasurableEquiv.piFinSuccAbove α i) (Measure.pi μ)
      ((μ i).prod <| Measure.pi fun j => μ (i.succAbove j))
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The fundamental property of the adjoint. -/
theorem adjoint_inner_left (A : E →L[𝕜] F) (x : E) (y : F) : ⟪(A†) y, x⟫ = ⟪y, A x⟫
-- Mathlib/Algebra/Order/Ring/Abs.lean
theorem abs_dvd_self (a : α) : |a| ∣ a
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean
/-- The union of the images of the maps `ExteriorAlgebra.ιMulti R n` for `n` running through
all natural numbers spans the exterior algebra. -/
lemma ιMulti_span :
    Submodule.span R (Set.range fun x : Σ n, (Fin n → M) => ιMulti R x.1 x.2) = ⊤
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
theorem mem_nhds {s : Set R} {x : R} : s ∈ 𝓝 x ↔ ∃ γ : Γ₀ˣ, { y | (v (y - x) : Γ₀) < γ } ⊆ s
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem IsPartition.infPrepartition (h₁ : π₁.IsPartition) {π₂ : Prepartition I}
    (h₂ : π₂.IsPartition) : (π₁.infPrepartition π₂).IsPartition
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem map_neg [DecidableEq ι] (i : ι) (x : M') : g' (update v' i (-x)) = -g' (update v' i x)
-- Mathlib/Algebra/DualNumber.lean
/-- A version of `TrivSqZeroExt.snd_mul` with `*` instead of `•`. -/
@[simp]
theorem snd_mul [Semiring R] (x y : R[ε]) : snd (x * y) = fst x * snd y + snd x * fst y
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
/-- A set of points is concyclic if it is cospherical and coplanar. (Most results are stated
directly in terms of `Cospherical` instead of using `Concyclic`.) -/
structure Concyclic (ps : Set P) : Prop where
  Cospherical : Cospherical ps
  Coplanar : Coplanar ℝ ps
-- Mathlib/Topology/Semicontinuous.lean
theorem IsOpen.upperSemicontinuousAt_indicator (hs : IsOpen s) (hy : y ≤ 0) :
    UpperSemicontinuousAt (indicator s fun _x => y) x
-- Mathlib/Topology/PartialHomeomorph.lean
protected theorem symm (h : e.IsImage s t) : e.symm.IsImage t s
-- Mathlib/CategoryTheory/Shift/Predicate.lean
lemma predicateShift_predicateShift (a b c : A) (h : a + b = c) [ClosedUnderIsomorphisms P] :
    PredicateShift (PredicateShift P b) a = PredicateShift P c
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_eq_sub (a b : α) : toIcoMod hp a b = toIcoMod hp 0 (b - a) + a
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
/-- The identity morphism on a locally ringed space. -/
@[simps]
def id (X : LocallyRingedSpace.{u}) : Hom X X
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_apply (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e.symm b y = cast (congr_arg E (e.symm_coe_proj hb)) (e.toPartialEquiv.symm (b, y)).2
-- Mathlib/Data/Ordmap/Ordset.lean
theorem findMax_dual (t : Ordnode α) : findMax (dual t) = findMin t
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- For any function `f : α → ℝ≥0∞`, there exists a measurable function `g ≤ f` with the same
integral over any measurable set. -/
theorem exists_measurable_le_setLintegral_eq_of_integrable {f : α → ℝ≥0∞} (hf : ∫⁻ a, f a ∂μ ≠ ∞) :
    ∃ (g : α → ℝ≥0∞), Measurable g ∧ g ≤ f ∧ ∀ s : Set α, MeasurableSet s →
      ∫⁻ a in s, f a ∂μ = ∫⁻ a in s, g a ∂μ
-- Mathlib/Order/Interval/Set/Pi.lean
theorem image_update_Ioc (f : ∀ i, α i) (i : ι) (a b : α i) :
    update f i '' Ioc a b = Ioc (update f i a) (update f i b)
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem normalize_finite_fraction_representation (U : Opens (PrimeSpectrum.Top R))
    (s : (structureSheaf R).1.obj (op U)) {ι : Type*} (t : Finset ι) (a h : ι → R)
    (iDh : ∀ i : ι, PrimeSpectrum.basicOpen (h i) ⟶ U)
    (h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i))
    (hs :
      ∀ i : ι,
        (const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) fun y hy => hy) =
          (structureSheaf R).1.map (iDh i).op s) :
    ∃ (a' h' : ι → R) (iDh' : ∀ i : ι, PrimeSpectrum.basicOpen (h' i) ⟶ U),
      (U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i)) ∧
        (∀ (i) (_ : i ∈ t) (j) (_ : j ∈ t), a' i * h' j = h' i * a' j) ∧
          ∀ i ∈ t,
            (structureSheaf R).1.map (iDh' i).op s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) fun y hy => hy
-- Mathlib/FieldTheory/Normal.lean
theorem AlgEquiv.restrictNormalHom_surjective [Normal F K₁] [Normal F E] :
    Function.Surjective (AlgEquiv.restrictNormalHom K₁ : (E ≃ₐ[F] E) → K₁ ≃ₐ[F] K₁)
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- If the `ChartedSpace` structure on a manifold `M` is given by an open embedding `e : M → H`,
then `e` is smooth. -/
lemma contMDiff_openEmbedding :
    haveI := h.singletonChartedSpace; ContMDiff I I n e
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_eq_on_Ico' (n : ℕ) :
    ∀ a ∈ (Set.Ico n (n + 1) : Set α), (⌊a⌋₊ : α) = n
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem autToPow_spec (f : S ≃ₐ[R] S) : μ ^ (hμ.autToPow R f : ZMod n).val = f μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
@[simp] theorem gcd_one {a : Int} : gcd a 1 = 1
-- Mathlib/Order/Filter/Basic.lean
theorem NeBot.comap_of_surj {f : Filter β} {m : α → β} (hf : NeBot f) (hm : Surjective m) :
    NeBot (comap m f)
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
@[simp]
theorem zero_posPart : (0 : JordanDecomposition α).posPart = 0
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
/-- Given submodules `M ⊆ R` and `N ⊆ S = M⁻¹R`, with `f : R →+* S` the localization map, we have
`N ⁻¹ S = T = (f⁻¹ (N • f(M))) ⁻¹ R`. I.e., the localization of a localization is a localization.
-/
theorem localization_localization_isLocalization [IsLocalization N T] :
    IsLocalization (localizationLocalizationSubmodule M N) T
-- Mathlib/Data/List/Sublists.lean
@[simp]
theorem sublistsLen_length : ∀ l : List α, sublistsLen l.length l = [l]
-- .lake/packages/lean4/src/lean/Init/Core.lean
protected theorem Iff.rfl {a : Prop} : a ↔ a
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- Two non-unital subrings are equal if they have the same elements. -/
@[ext]
theorem ext {S T : NonUnitalSubring R} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem univ_filter_exists (f : α → β) [Fintype β] [DecidablePred fun y => ∃ x, f x = y]
    [DecidableEq β] : (Finset.univ.filter fun y => ∃ x, f x = y) = Finset.univ.image f
-- Mathlib/Data/Sign.lean
@[simp]
theorem pos_iff {a : SignType} : 0 < a ↔ a = 1
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
theorem integrable_inv_one_add_sq : Integrable fun (x : ℝ) ↦ (1 + x ^ 2)⁻¹
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem CompositionAsSet.toComposition_boundaries (c : CompositionAsSet n) :
    c.toComposition.boundaries = c.boundaries
-- Mathlib/Data/Fintype/Card.lean
theorem _root_.Function.LeftInverse.rightInverse_of_card_le {f : α → β} {g : β → α}
    (hfg : LeftInverse f g) (hcard : card α ≤ card β) : RightInverse f g
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem binary_cofan_inr_toCocone (c : BinaryBicone P Q) : BinaryCofan.inr c.toCocone = c.inr
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem map_update_update [DecidableEq ι] {i j : ι} (hij : i ≠ j) (m : M) :
    f (Function.update (Function.update v i m) j m) = 0
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem TopologicalGroup.ext_iff {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _) :
    t = t' ↔ @nhds G t 1 = @nhds G t' 1
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
theorem range_exp_mul_I : (Set.range fun x : ℝ => exp (x * I)) = Metric.sphere 0 1
-- Mathlib/Algebra/Ring/Parity.lean
lemma odd_iff : Odd n ↔ n % 2 = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem ext_get {l₁ l₂ : List α} (hl : length l₁ = length l₂)
    (h : ∀ n h₁ h₂, get l₁ ⟨n, h₁⟩ = get l₂ ⟨n, h₂⟩) : l₁ = l₂
-- Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean
theorem jacobson_eq_maximalIdeal (I : Ideal R) (h : I ≠ ⊤) :
    I.jacobson = LocalRing.maximalIdeal R
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem Zlattice.module_finite [IsZlattice K L] : Module.Finite ℤ L
-- Mathlib/NumberTheory/Cyclotomic/Three.lean
lemma _root_.IsPrimitiveRoot.toInteger_cube_eq_one : hζ.toInteger ^ 3 = 1
-- Mathlib/RingTheory/Valuation/Integral.lean
protected theorem integralClosure : integralClosure O R = ⊥
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
/-- A strong monomorphism that is an epimorphism is an isomorphism. -/
theorem isIso_of_epi_of_strongMono (f : P ⟶ Q) [Epi f] [StrongMono f] : IsIso f
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_hasFDerivWithinAt_iff' {f : G → E} {s : Set G} {x : G} {f' : G →L[𝕜] F} :
    HasFDerivWithinAt (iso ∘ f) f' s x ↔
      HasFDerivWithinAt f ((iso.symm : F →L[𝕜] E).comp f') s x
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_comp_right {s : Set α} (f : β → α) {g : α → M} {x : β} :
    mulIndicator (f ⁻¹' s) (g ∘ f) x = mulIndicator s g (f x)
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_option_toFinset (o : Option α) (f : α → Set β) :
    ⋃ x ∈ o.toFinset, f x = ⋃ x ∈ o, f x
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.prod {t : Set β} (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ×ˢ t)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem top_ne_coe (x : ℝ) : (⊤ : EReal) ≠ x
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem Pairwise.tail : ∀ {l : List α} (_p : Pairwise R l), Pairwise R l.tail
-- Mathlib/Dynamics/PeriodicPts.lean
theorem Commute.minimalPeriod_of_comp_eq_mul_of_coprime {g : α → α} (h : Commute f g)
    (hco : Coprime (minimalPeriod f x) (minimalPeriod g x)) :
    minimalPeriod (f ∘ g) x = minimalPeriod f x * minimalPeriod g x
-- Mathlib/Algebra/ModEq.lean
protected theorem zsmul : a ≡ b [PMOD p] → z • a ≡ z • b [PMOD z • p]
-- Mathlib/Data/Num/Lemmas.lean
theorem zneg_bit1 (n : ZNum) : -n.bit1 = (-n).bitm1
-- Mathlib/Topology/Algebra/Ring/Basic.lean
theorem Subring.topologicalClosure_minimal (s : Subring α) {t : Subring α} (h : s ≤ t)
    (ht : IsClosed (t : Set α)) : s.topologicalClosure ≤ t
-- Mathlib/Topology/Sober.lean
/-- In a T₀ space, each set has at most one generic point. -/
protected theorem eq [T0Space α] (h : IsGenericPoint x S) (h' : IsGenericPoint y S) : x = y
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂
-- Mathlib/Order/Filter/Archimedean.lean
theorem tendsto_intCast_atTop_iff [StrictOrderedRing R] [Archimedean R] {f : α → ℤ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop
-- Mathlib/Computability/DFA.lean
@[simp]
theorem eval_singleton (a : α) : M.eval [a] = M.step M.start a
-- Mathlib/Algebra/Lie/Basic.lean
theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₗ⁅R,L⁆ N) → M ≃ N)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zip_map (f : α → γ) (g : β → δ) :
    ∀ (l₁ : List α) (l₂ : List β), zip (l₁.map f) (l₂.map g) = (zip l₁ l₂).map (Prod.map f g)
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
lemma uniformInducing_iff' {f : α → β} :
    UniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem constantCoeff_smul {S : Type*} [Semiring S] [Module R S] (φ : PowerSeries S) (a : R) :
    constantCoeff S (a • φ) = a • constantCoeff S φ
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem beq_self_eq_true' [DecidableEq α] (a : α) : (a == a) = true
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
@[simp] theorem perm_nil {l₁ : List α} : l₁ ~ [] ↔ l₁ = []
-- Mathlib/Data/Real/Sign.lean
theorem sign_of_pos {r : ℝ} (hr : 0 < r) : sign r = 1
-- Mathlib/RingTheory/Multiplicity.lean
theorem Finset.prod {β : Type*} {p : α} (hp : Prime p) (s : Finset β) (f : β → α) :
    multiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, multiplicity p (f x)
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem out_empty_iff_eq_zero {o : Ordinal} : IsEmpty o.out.α ↔ o = 0
-- Mathlib/Algebra/Order/Floor.lean
theorem abs_sub_round_eq_min (x : α) : |x - round x| = min (fract x) (1 - fract x)
-- Mathlib/Data/Matroid/Closure.lean
lemma Base.closure_eq (hB : M.Base B) : M.closure B = M.E
-- Mathlib/InformationTheory/Hamming.lean
@[simp]
theorem toHamming_neg [∀ i, Neg (β i)] {x : ∀ i, β i} : toHamming (-x) = -toHamming x
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem eval_unique (φ : R[X] →ₐ[R] A) (p) : φ p = eval₂ (algebraMap R A) (φ X) p
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isInt_mul {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HMul.hMul → IsInt a a' → IsInt b b' → Int.mul a' b' = c → IsInt (a * b) c
-- Mathlib/Algebra/DirectSum/Basic.lean
@[simp]
theorem of_eq_same (i : ι) (x : β i) : (of _ i x) i = x
-- Mathlib/Algebra/Lie/Classical.lean
theorem sl_bracket [Fintype n] (A B : sl n R) : ⁅A, B⁆.val = A.val * B.val - B.val * A.val
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp)]
theorem ofLex_mul [Mul α] (a b : Lex α) : ofLex (a * b) = ofLex a * ofLex b
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
protected theorem norm_sum_single (hp : 0 < p.toReal) (f : ∀ i, E i) (s : Finset α) :
    ‖∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ∑ i ∈ s, ‖f i‖ ^ p.toReal
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
@[simp]
lemma homologyMap'_smul :
    homologyMap' (a • φ) h₁ h₂ = a • homologyMap' φ h₁ h₂
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
theorem Summable.smul_const (hf : Summable f) (a : M) : Summable fun z ↦ f z • a
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem sum_eq : (∑ i : Fin n, d * (2 * d + 1) ^ (i : ℕ)) = ((2 * d + 1) ^ n - 1) / 2
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
/-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E
-- Mathlib/CategoryTheory/Category/RelCat.lean
@[simp] theorem unopFunctor_comp_opFunctor_eq :
    Functor.comp unopFunctor opFunctor = Functor.id _