ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
/-- If `forget C` preserves initials and `X` is initial, then `(forget C).obj X` is empty. -/
lemma empty_of_initial_of_preserves [PreservesColimit (Functor.empty.{0} C) (forget C)] (X : C)
    (h : Nonempty (IsInitial X)) : IsEmpty ((forget C).obj X)
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_of_le_castSucc (p : Fin n) (i : Fin (n + 1)) (h : i ≤ castSucc p)
    (hi := Fin.ne_of_lt $ Fin.lt_of_le_of_lt h $ castSucc_lt_last _) :
    p.predAbove i = i.castPred hi
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
@[simp]
theorem homogeneousComponent_zero : homogeneousComponent 0 φ = C (coeff 0 φ)
-- Mathlib/CategoryTheory/Abelian/EpiWithInjectiveKernel.lean
lemma epiWithInjectiveKernel_of_iso {X Y : C} (f : X ⟶ Y) [IsIso f] :
    epiWithInjectiveKernel f
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem mem_nhds_uniformity_iff_left {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ { p : α × α | p.2 = x → p.1 ∈ s } ∈ 𝓤 α
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
theorem Integrable.integral_condKernel {f : α × Ω → E} (hf_int : Integrable f ρ) :
    Integrable (fun x ↦ ∫ y, f (x, y) ∂ρ.condKernel x) ρ.fst
-- Mathlib/Analysis/LocallyConvex/Polar.lean
theorem polar_mem_iff (s : Set E) (y : F) : y ∈ B.polar s ↔ ∀ x ∈ s, ‖B x y‖ ≤ 1
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
@[simp]
theorem toWeakDualBCNN_apply (μ : ProbabilityMeasure Ω) (f : Ω →ᵇ ℝ≥0) :
    μ.toWeakDualBCNN f = (∫⁻ ω, f ω ∂(μ : Measure Ω)).toNNReal
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- When both maps `S.f` and `S.g` of a short complex `S` are zero, this is the right homology map
data (for the identity of `S`) which relates the right homology data
`RightHomologyData.ofIsLimitKernelFork` and `ofZeros` . -/
@[simps]
def compatibilityOfZerosOfIsLimitKernelFork (hf : S.f = 0) (hg : S.g = 0)
    (c : KernelFork S.g) (hc : IsLimit c) :
    RightHomologyMapData (𝟙 S)
      (RightHomologyData.ofIsLimitKernelFork S hf c hc)
      (RightHomologyData.ofZeros S hf hg)
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Ioc_bot (y : ℝ) : Real.toEReal ⁻¹' Ioc ⊥ y = Iic y
-- Mathlib/Algebra/Periodic.lean
/-- A periodic function `f : R → X` on a semiring (or, more generally, `AddZeroClass`)
of non-zero period is not injective. -/
lemma Periodic.not_injective {R X : Type*} [AddZeroClass R] {f : R → X} {c : R}
    (hf : Periodic f c) (hc : c ≠ 0) : ¬ Injective f
-- Mathlib/Order/Monotone/Basic.lean
theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
    (h : f a < f b) : b < a
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_mono_right (h : f₁ ≤ f₂) : map₂ m f₁ g ≤ map₂ m f₂ g
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem UniqueDiffOn.uniqueDiffWithinAt {s : Set E} {x} (hs : UniqueDiffOn 𝕜 s) (h : x ∈ s) :
    UniqueDiffWithinAt 𝕜 s x
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
/-- Just as `TensorProduct.ext` is marked `ext` instead of `TensorProduct.ext'`, this is
a better `ext` lemma than `TensorProduct.AlgebraTensorModule.ext` below.

See note [partially-applied ext lemmas]. -/
@[ext high]
nonrec theorem curry_injective : Function.Injective (curry : (M ⊗ N →ₗ[A] P) → M →ₗ[A] N →ₗ[R] P)
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_univ : dimH (univ : Set ℝ) = 1
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
/-- A function `f : α → ℝ` which is `K`-Lipschitz on a subset `s` admits a `K`-Lipschitz extension
to the whole space. -/
theorem LipschitzOnWith.extend_real {f : α → ℝ} {s : Set α} {K : ℝ≥0} (hf : LipschitzOnWith K f s) :
    ∃ g : α → ℝ, LipschitzWith K g ∧ EqOn f g s
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem sym_comp_unsym : (sym : α → αˢʸᵐ) ∘ unsym = id
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem set_eq_setTR : @set = @setTR
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp] theorem prod_norm_equiv_symm (f : α × β) : ‖(WithLp.equiv ⊤ _).symm f‖ = ‖f‖
-- Mathlib/Topology/Basic.lean
@[fun_prop]
theorem ContinuousAt.comp' {g : Y → Z} {x : X} (hg : ContinuousAt g (f x))
    (hf : ContinuousAt f x) : ContinuousAt (fun x => g (f x)) x
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_trans_target_eq (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedValue_sub_eq_sum' [AddCommGroup β] (hle : τ ≤ π) {N : ℕ} (hbdd : ∀ ω, π ω ≤ N) :
    stoppedValue u π - stoppedValue u τ = fun ω =>
      (∑ i ∈ Finset.range (N + 1), Set.indicator {ω | τ ω ≤ i ∧ i < π ω} (u (i + 1) - u i)) ω
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
/-- Equivalence of multiplicative ring norms is reflexive. -/
lemma equiv_refl (f : MulRingNorm R) : equiv f f
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem nsmul (n : ℕ) (x : WittVector p R) : mapFun f (n • x) = n • mapFun f x
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_le_of_le_of_le_one_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : a ≤ 1) (hb : 0 ≤ b) :
    b * a ≤ c
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem nndist_integral_add_measure_le_lintegral
    {f : α → G} (h₁ : Integrable f μ) (h₂ : Integrable f ν) :
    (nndist (∫ x, f x ∂μ) (∫ x, f x ∂(μ + ν)) : ℝ≥0∞) ≤ ∫⁻ x, ‖f x‖₊ ∂ν
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem map_eq_id {f : α → α} : Option.map f = id ↔ f = id
-- Mathlib/Data/Fin/Basic.lean
/-- Given a fixed pivot `p : Fin (n + 1)`, `p.succAbove` is injective. -/
lemma succAbove_right_inj : p.succAbove i = p.succAbove j ↔ i = j
-- Mathlib/Data/Nat/Defs.lean
lemma eq_zero_of_le_half (h : n ≤ n / 2) : n = 0
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive abs_pos_of_neg] lemma one_lt_mabs_of_lt_one (h : a < 1) : 1 < |a|ₘ
-- Mathlib/Data/Finset/Basic.lean
theorem filter_insert (a : α) (s : Finset α) :
    filter p (insert a s) = if p a then insert a (filter p s) else filter p s
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
lemma contDiffAt : ContDiffAt 𝕜 n f x
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem isLeast_opNNNorm : IsLeast {C : ℝ≥0 | ∀ m, ‖f m‖₊ ≤ C * ∏ i, ‖m i‖₊} ‖f‖₊
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_iUnion [Countable β] {s : β → Set α} (hm : ∀ i, MeasurableSet (s i))
    (hd : Pairwise (Disjoint on s)) (f : α → ℝ≥0∞) :
    ∫⁻ a in ⋃ i, s i, f a ∂μ = ∑' i, ∫⁻ a in s i, f a ∂μ
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- **Cauchy–Schwarz inequality**.
We need this for the `Core` structure to prove the triangle inequality below when
showing the core is a normed group.
-/
theorem inner_mul_inner_self_le (x y : F) : ‖⟪x, y⟫‖ * ‖⟪y, x⟫‖ ≤ re ⟪x, x⟫ * re ⟪y, y⟫
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem measure_eq_tsum_of_ac (h : IsFundamentalDomain G s μ) (hν : ν ≪ μ) (t : Set α) :
    ν t = ∑' g : G, ν (t ∩ g • s)
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.measure_stieltjesFunction_univ (a : α) :
    (hf.stieltjesFunction a).measure univ = 1
-- Mathlib/Probability/Independence/Kernel.lean
@[to_additive]
lemma iIndepFun.indepFun_mul_right (hf_indep : iIndepFun (fun _ ↦ m) f κ μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    IndepFun (f i) (f j * f k) κ μ
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- The `Submodule.LinearDisjoint.not_linearIndependent_pair_of_commute_of_flat_left`
for commutative rings. -/
theorem not_linearIndependent_pair_of_flat_left [Module.Flat R M]
    (a b : ↥(M ⊓ N)) : ¬LinearIndependent R ![a, b]
-- Mathlib/LinearAlgebra/Semisimple.lean
@[simp] lemma isSemisimple_neg : (-f).IsSemisimple ↔ f.IsSemisimple
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
theorem Module.rank_le_one_iff_top_isPrincipal [Module.Free K V] :
    Module.rank K V ≤ 1 ↔ (⊤ : Submodule K V).IsPrincipal
-- Mathlib/Algebra/Module/Torsion.lean
lemma Quotient.mk_smul_mk (r : R) (m : M) :
    Ideal.Quotient.mk I r •
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) m =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) (r • m)
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma NatTrans.app_homology {F G : C ⥤ D} (τ : F ⟶ G)
    (S : ShortComplex C) [S.HasHomology] [F.PreservesZeroMorphisms] [G.PreservesZeroMorphisms]
    [F.PreservesLeftHomologyOf S] [G.PreservesLeftHomologyOf S] [F.PreservesRightHomologyOf S]
    [G.PreservesRightHomologyOf S] :
    τ.app S.homology = (S.mapHomologyIso F).inv ≫
      ShortComplex.homologyMap (S.mapNatTrans τ) ≫ (S.mapHomologyIso G).hom
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem map_le {S : NonUnitalSubalgebra R A} {f : F} {U : NonUnitalSubalgebra R B} :
    map f S ≤ U ↔ S ≤ comap f U
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem pi_div_two_le_two : π / 2 ≤ 2
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma Ici_lt_top : Ici a < ⊤
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem frontier_reProdIm (s t : Set ℝ) :
    frontier (s ×ℂ t) = closure s ×ℂ frontier t ∪ frontier s ×ℂ closure t
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
@[simp]
theorem comp_id (f : C₀(γ, δ)) : f.comp (CocompactMap.id γ) = f
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- A weighted subtraction, over the image of an embedding, equals a
weighted subtraction with the same points and weights over the
original `Finset`. -/
theorem weightedVSub_map (e : ι₂ ↪ ι) (w : ι → k) (p : ι → P) :
    (s₂.map e).weightedVSub p w = s₂.weightedVSub (p ∘ e) (w ∘ e)
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[reassoc (attr := simp)]
theorem ev_coev : (A ◁ (coev A).app B) ≫ (ev A).app (A ⊗ B) = 𝟙 (A ⊗ B)
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem ne_zero_of_c_ne_zero (hc : P.c ≠ 0) : P.toPoly ≠ 0
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem subset_zeroLocus_iff_le_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) (I : Ideal A) :
    t ⊆ zeroLocus 𝒜 I ↔ I ≤ (vanishingIdeal t).toIdeal
-- Mathlib/Data/Real/Archimedean.lean
protected theorem is_glb_sInf (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddBelow S) :
    IsGLB S (sInf S)
-- Mathlib/Computability/Partrec.lean
theorem fin_app {n} : Computable₂ (@id (Fin n → σ))
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If a function `f` has a power series `p` on a ball and `g` is linear, then `g ∘ f` has the
power series `g ∘ p` on the same ball. -/
theorem ContinuousLinearMap.comp_hasFPowerSeriesOnBall (g : F →L[𝕜] G)
    (h : HasFPowerSeriesOnBall f p x r) :
    HasFPowerSeriesOnBall (g ∘ f) (g.compFormalMultilinearSeries p) x r
-- Mathlib/Topology/Algebra/Monoid.lean
/-- Given a neighborhood `U` of `1` there is an open neighborhood `V` of `1`
such that `V * V ⊆ U`. -/
@[to_additive "Given an open neighborhood `U` of `0` there is an open neighborhood `V` of `0`
  such that `V + V ⊆ U`."]
theorem exists_open_nhds_one_mul_subset {U : Set M} (hU : U ∈ 𝓝 (1 : M)) :
    ∃ V : Set M, IsOpen V ∧ (1 : M) ∈ V ∧ V * V ⊆ U
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma setLIntegral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ} (hA : MeasurableSet A) :
    ∫⁻ x in A, ENNReal.ofReal (density κ ν a x s) ∂(ν a) = κ a (A ×ˢ s)
-- Mathlib/Algebra/Associated/Basic.lean
theorem dvdNotUnit_iff_lt {a b : Associates α} : DvdNotUnit a b ↔ a < b
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_union_eq_right [DecidableEq α] (hs : ∀ a ∈ s₁, a ∉ s₂ → f a = 1) :
    ∏ a ∈ s₁ ∪ s₂, f a = ∏ a ∈ s₂, f a
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem decode_sum_val (n : ℕ) : (decode n : Option (α ⊕ β)) = decodeSum n
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.sup_right (h : Codisjoint a b) : Codisjoint a (b ⊔ c)
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y)
-- Mathlib/Algebra/Category/BoolRing.lean
@[simps]
instance BoolAlg.hasForgetToBoolRing : HasForget₂ BoolAlg BoolRing
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem monic_of_c_eq_one' : (toPoly ⟨0, 0, 1, d⟩).Monic
-- Mathlib/Analysis/BoundedVariation.lean
theorem _root_.BoundedVariationOn.locallyBoundedVariationOn {f : α → E} {s : Set α}
    (h : BoundedVariationOn f s) : LocallyBoundedVariationOn f s
-- Mathlib/Logic/Equiv/Basic.lean
/-- The product `Bool × α` is equivalent to `α ⊕ α`. -/
@[simps]
def boolProdEquivSum (α) : Bool × α ≃ α ⊕ α
-- Mathlib/Data/Set/Basic.lean
theorem insert_comm (a b : α) (s : Set α) : insert a (insert b s) = insert b (insert a s)
-- Mathlib/CategoryTheory/IsConnected.lean
/-- A possibly empty category for which every functor to a discrete category is constant.
-/
class IsPreconnected (J : Type u₁) [Category.{v₁} J] : Prop where
  iso_constant :
    ∀ {α : Type u₁} (F : J ⥤ Discrete α) (j : J), Nonempty (F ≅ (Functor.const J).obj (F.obj j))
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem nat_le_card {o} {n : ℕ} : (n : Cardinal) ≤ card o ↔ (n : Ordinal) ≤ o
-- Mathlib/Order/PartialSups.lean
theorem partialSups_eq_ciSup_Iic (f : ℕ → α) (n : ℕ) : partialSups f n = ⨆ i : Set.Iic n, f i
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem toLinearMap_apply (x : A₁) : e.toLinearMap x = e x
-- Mathlib/CategoryTheory/Adjunction/Reflective.lean
/-- If `η_A` is a split monomorphism, then `A` is in the reflective subcategory. -/
theorem mem_essImage_of_unit_isSplitMono [Reflective i] {A : C}
    [IsSplitMono ((reflectorAdjunction i).unit.app A)] : A ∈ i.essImage
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_nonempty : (s \ t).Nonempty ↔ ¬s ⊆ t
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp] lemma δ_units_smul (k : Rˣ) (z : Cochain F G n) : δ n m (k • z) = k • δ n m z
-- Mathlib/Order/Interval/Set/Pi.lean
theorem piecewise_mem_Icc {s : Set ι} [∀ j, Decidable (j ∈ s)] {f₁ f₂ g₁ g₂ : ∀ i, α i}
    (h₁ : ∀ i ∈ s, f₁ i ∈ Icc (g₁ i) (g₂ i)) (h₂ : ∀ i ∉ s, f₂ i ∈ Icc (g₁ i) (g₂ i)) :
    s.piecewise f₁ f₂ ∈ Icc g₁ g₂
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem cast_castAdd_left {n n' m : Nat} (i : Fin n') (h : n' + m = n + m) :
    cast h (castAdd m i) = castAdd m (cast (Nat.add_right_cancel h) i)
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
/-- A unit trinomial is irreducible if it is coprime with its mirror -/
theorem irreducible_of_isCoprime (hp : p.IsUnitTrinomial) (h : IsCoprime p p.mirror) :
    Irreducible p
-- Mathlib/Algebra/Category/Grp/Colimits.lean
lemma hasColimitsOfSize : HasColimitsOfSize.{v, u} AddCommGrp.{max u v w}
-- Mathlib/Algebra/Group/Action/Defs.lean
@[simp] lemma toMul_smul [SMul α β] (a) (b : β) : (toMul a : α) • b = a +ᵥ b
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem compl_top : (⊤ : α)ᶜ = ⊥
-- Mathlib/Topology/Semicontinuous.lean
/-- The sum of two lower semicontinuous functions is lower semicontinuous. Formulated with an
explicit continuity assumption on addition, for application to `EReal`. The unprimed version of
the lemma uses `[ContinuousAdd]`. -/
theorem LowerSemicontinuous.add' {f g : α → γ} (hf : LowerSemicontinuous f)
    (hg : LowerSemicontinuous g)
    (hcont : ∀ x, ContinuousAt (fun p : γ × γ => p.1 + p.2) (f x, g x)) :
    LowerSemicontinuous fun z => f z + g z
-- Mathlib/LinearAlgebra/Determinant.lean
/-- The determinants of a `LinearEquiv` and its inverse multiply to 1. -/
@[simp]
theorem LinearEquiv.det_mul_det_symm {A : Type*} [CommRing A] [Module A M] (f : M ≃ₗ[A] M) :
    LinearMap.det (f : M →ₗ[A] M) * LinearMap.det (f.symm : M →ₗ[A] M) = 1
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma quasiIso_shift_iff {K L : CochainComplex C ℤ} (φ : K ⟶ L) (n : ℤ) :
    QuasiIso (φ⟦n⟧') ↔ QuasiIso φ
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem norm_iteratedFDeriv_fderiv {n : ℕ} :
    ‖iteratedFDeriv 𝕜 n (fderiv 𝕜 f) x‖ = ‖iteratedFDeriv 𝕜 (n + 1) f x‖
-- Mathlib/Order/Filter/Basic.lean
/-- Either `f = ⊥` or `Filter.NeBot f`. This is a version of `eq_or_ne` that uses `Filter.NeBot`
as the second alternative, to be used as an instance. -/
theorem eq_or_neBot (f : Filter α) : f = ⊥ ∨ NeBot f
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem cast_one (h : m ∣ n) : (cast (1 : ZMod n) : R) = 1
-- Mathlib/Computability/Language.lean
theorem le_iff (l m : Language α) : l ≤ m ↔ l + m = m
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConcaveOn.dual (hf : StrictConcaveOn 𝕜 s f) : StrictConvexOn 𝕜 s (toDual ∘ f)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isLittleO_pure {x} : f'' =o[pure x] g'' ↔ f'' x = 0
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem finiteIndex_of_finite_quotient [Finite (G ⧸ H)] : FiniteIndex H
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem srange_top_iff_surjective {f : F} :
    srange f = (⊤ : NonUnitalSubsemiring S) ↔ Function.Surjective (f : R → S)
-- Mathlib/Order/MinMax.lean
theorem min_choice (a b : α) : min a b = a ∨ min a b = b
-- Mathlib/Data/W/Cardinal.lean
theorem cardinal_mk_eq_sum : #(WType β) = sum (fun a : α => #(WType β) ^ #(β a))
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem smul_sup (a : α) (S T : Submonoid M) : a • (S ⊔ T) = a • S ⊔ a • T
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem IsClosed.smul {s : Set α} (hs : IsClosed s) (c : G) : IsClosed (c • s)
-- Mathlib/Topology/StoneCech.lean
/-- The range of `pure : α → Ultrafilter α` is dense in `Ultrafilter α`. -/
theorem denseRange_pure : DenseRange (pure : α → Ultrafilter α)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extend_target : (f.extend I).target = I.symm ⁻¹' f.target ∩ range I
-- Mathlib/Order/LiminfLimsup.lean
/-- Same as limsup_const applied to `⊥` but without the `NeBot f` assumption -/
@[simp]
theorem limsup_const_bot {f : Filter β} : limsup (fun _ : β => (⊥ : α)) f = (⊥ : α)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasStrictFDerivAt.mul' {x : E} (ha : HasStrictFDerivAt a a' x)
    (hb : HasStrictFDerivAt b b' x) :
    HasStrictFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x
-- Mathlib/CategoryTheory/Sites/PreservesSheafification.lean
lemma GrothendieckTopology.preservesSheafification_iff_of_adjunctions :
    J.PreservesSheafification F ↔ ∀ (P : Cᵒᵖ ⥤ A),
      IsIso (G₂.map (whiskerRight (adj₁.unit.app P) F))
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem eq_mul_of_inv_mul_eq (h : b⁻¹ * a = c) : a = b * c
-- Mathlib/Algebra/Group/WithOne/Basic.lean
/-- A version of `Equiv.optionCongr` for `WithOne`. -/
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem lcm_add (s₁ s₂ : Multiset α) : (s₁ + s₂).lcm = GCDMonoid.lcm s₁.lcm s₂.lcm
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem coeff_algebraMap [Nontrivial S] (h : IsAdjoinRootMonic S f) (x : R) :
    h.coeff (algebraMap R S x) = Pi.single 0 x
-- Mathlib/Data/List/Basic.lean
theorem choose_mem (hp : ∃ a, a ∈ l ∧ p a) : choose p l hp ∈ l
-- Mathlib/Data/Real/Pi/Bounds.lean
theorem pi_gt_3141592 : 3.141592 < π
-- Mathlib/Deprecated/Group.lean
/-- A product of maps which preserve multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "A sum of maps which preserves addition, preserves addition when the target
      is commutative."]
theorem mul {α β} [Semigroup α] [CommSemigroup β] {f g : α → β} (hf : IsMulHom f)
    (hg : IsMulHom g) : IsMulHom fun a => f a * g a
-- Mathlib/Probability/Kernel/Basic.lean
@[ext]
theorem ext {η : Kernel α β} (h : ∀ a, κ a = η a) : κ = η
-- Mathlib/Data/ENNReal/Inv.lean
theorem coe_inv_le : (↑r⁻¹ : ℝ≥0∞) ≤ (↑r)⁻¹
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem wittStructureRat_rec_aux (Φ : MvPolynomial idx ℚ) (n : ℕ) :
    wittStructureRat p Φ n * C ((p : ℚ) ^ n) =
      bind₁ (fun b => rename (fun i => (b, i)) (W_ ℚ n)) Φ -
        ∑ i ∈ range n, C ((p : ℚ) ^ i) * wittStructureRat p Φ i ^ p ^ (n - i)
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma coe_mk (f : A → M)
    (map_zero_eq_one' : f 0 = 1) (map_add_eq_mul' : ∀ a b : A, f (a + b) = f a * f b) :
    AddChar.mk f map_zero_eq_one' map_add_eq_mul' = f
-- Mathlib/Computability/Primrec.lean
theorem vector_toList {n} : Primrec (@Vector.toList α n)
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem isMaximal_of_irreducible [CommRing R] [IsPrincipalIdealRing R] {p : R}
    (hp : Irreducible p) : Ideal.IsMaximal (span R ({p} : Set R))
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the angle between three points is `π / 2`, the first and third points are not equal. -/
theorem left_ne_right_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = (π / 2 : ℝ)) :
    p₁ ≠ p₃
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem Differentiable.arsinh (h : Differentiable ℝ f) : Differentiable ℝ fun x => arsinh (f x)
-- Mathlib/CategoryTheory/CommSq.lean
@[reassoc (attr := simp)]
theorem fac_left [hsq : HasLift sq] : i ≫ sq.lift = f
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_rightUnitor_inv_fst (X : C₁ × C₂) :
    ((ρ_ X).inv : X ⟶ X ⊗ 𝟙_ _).1 = (ρ_ X.1).inv
-- Mathlib/Data/PFun.lean
/-- If advancing one step from `a` on `f` leads to `a' : α`, then `f.fix a = f.fix a'` -/
theorem fix_fwd_eq {f : α →. β ⊕ α} {a a' : α} (ha' : Sum.inr a' ∈ f a) : f.fix a = f.fix a'
-- Mathlib/InformationTheory/Hamming.lean
@[simp, push_cast]
theorem dist_eq_hammingDist (x y : Hamming β) :
    dist x y = hammingDist (ofHamming x) (ofHamming y)
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem continuousMultilinearCurryRightEquiv_symm_apply (f : ContinuousMultilinearMap 𝕜 Ei G)
    (v : ∀ i : Fin n, Ei <| castSucc i) (x : Ei (last n)) :
    (continuousMultilinearCurryRightEquiv 𝕜 Ei G).symm f v x = f (snoc v x)
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem supDegree_mul_le [CovariantClass B B (· + ·) (· ≤ ·)]
    [CovariantClass B B (Function.swap (· + ·)) (· ≤ ·)] :
    (p * q).supDegree D ≤ p.supDegree D + q.supDegree D
-- Mathlib/Data/Nat/Find.lean
@[simp] lemma lt_find_iff (h : ∃ n : ℕ, p n) (n : ℕ) : n < Nat.find h ↔ ∀ m ≤ n, ¬ p m
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
theorem coinduced_of_isColimit {F : J ⥤ TopCat.{max v u}} (c : Cocone F) (hc : IsColimit c) :
    c.pt.str = ⨆ j, (F.obj j).str.coinduced (c.ι.app j)
-- Mathlib/Order/FixedPoints.lean
theorem le_map_sSup_subset_fixedPoints (A : Set α) (hA : A ⊆ fixedPoints f) :
    sSup A ≤ f (sSup A)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- Möbius inversion for functions to a `CommGroup`, where the equalities only hold on a
well-behaved set. -/
theorem prod_eq_iff_prod_pow_moebius_eq_on [CommGroup R] {f g : ℕ → R}
    (s : Set ℕ) (hs : ∀ m n, m ∣ n → n ∈ s → m ∈ s) :
    (∀ n > 0, n ∈ s → (∏ i ∈ n.divisors, f i) = g n) ↔
      ∀ n > 0, n ∈ s → (∏ x ∈ n.divisorsAntidiagonal, g x.snd ^ μ x.fst) = f n
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- The obvious map `PushoutCocone f g → PullbackCone f.unop g.unop` -/
@[simps!]
def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    PullbackCone f.unop g.unop
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_fiberwise_of_maps_to' {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : κ → α) :
    ∏ j ∈ t, ∏ _i ∈ s.filter fun i ↦ g i = j, f j = ∏ i ∈ s, f (g i)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem add_emod (a b n : Int) : (a + b) % n = (a % n + b % n) % n
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[simp]
theorem edgeSet_toSubgraph (p : G.Walk u v) : p.toSubgraph.edgeSet = { e | e ∈ p.edges }
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[ext] theorem ext {a b : ℍ} (h : (a : ℂ) = b) : a = b
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem range_eq_empty_of_isEmpty {β} [hα : IsEmpty α] (f : α →ₛ β) : f.range = ∅
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem IsNormal.apply_le_nfp {f} (H : IsNormal f) {a b} : f b ≤ nfp f a ↔ b ≤ nfp f a
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma sum_base_iff {M : Matroid α} {N : Matroid β} {B : Set (α ⊕ β)} :
    (M.sum N).Base B ↔ M.Base (.inl ⁻¹' B) ∧ N.Base (.inr ⁻¹' B)