ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Bounds/Basic.lean
theorem exists_lub_Iio (i : γ) : ∃ j, IsLUB (Iio i) j
-- Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
theorem M.mk_eq (x y : Σ j, F.obj j)
    (h : ∃ (k : J) (f : x.1 ⟶ k) (g : y.1 ⟶ k), F.map f x.2 = F.map g y.2) : M.mk F x = M.mk F y
-- Mathlib/Data/Fin/Basic.lean
/-- While in many cases `finCongr` is better than `Equiv.cast`/`cast`, sometimes we want to apply
a generic theorem about `cast`. -/
lemma _root_.finCongr_eq_equivCast (h : n = m) : finCongr h = .cast (h ▸ rfl)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_le_mul_of_nonpos_left [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : b ≤ a) (hc : c ≤ 0) : c * a ≤ c * b
-- Mathlib/NumberTheory/PrimeCounting.lean
theorem monotone_primeCounting' : Monotone primeCounting'
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem measurable_of_isClosed {f : δ → γ} (hf : ∀ s, IsClosed s → MeasurableSet (f ⁻¹' s)) :
    Measurable f
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma tail_neg (a : Fin n.succ → α) : vecTail (-a) = -vecTail a
-- Mathlib/Data/Set/Finite.lean
theorem Infinite.of_image (f : α → β) {s : Set α} (hs : (f '' s).Infinite) : s.Infinite
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem cancel_left {g : BotHom β γ} {f₁ f₂ : BotHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Order/Filter/Basic.lean
theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets)
-- Mathlib/Analysis/Convolution.lean
theorem ConvolutionExistsAt.distrib_add {x : G} (hfg : ConvolutionExistsAt f g x L μ)
    (hfg' : ConvolutionExistsAt f g' x L μ) :
    (f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g) x + (f ⋆[L, μ] g') x
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive (attr := simp) MeasureTheory.mem_addFundamentalFrontier]
theorem mem_fundamentalFrontier :
    x ∈ fundamentalFrontier G s ↔ x ∈ s ∧ ∃ g : G, g ≠ 1 ∧ x ∈ g • s
-- Mathlib/Analysis/Normed/Group/Int.lean
theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem hom_desc (h : IsUniversal f) {c : C} (η : c ⟶ f.left) :
    η = h.lift (mk <| S.map η ≫ f.hom)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `vectorSpan` of the empty set is `⊥`. -/
@[simp]
theorem vectorSpan_empty : vectorSpan k (∅ : Set P) = (⊥ : Submodule k V)
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem innerContent_bot : μ.innerContent ⊥ = 0
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioi_top : Ioi (⊤ : α) = ∅
-- Mathlib/CategoryTheory/Sites/Sieves.lean
/-- Push a sieve `R` on `Y` forward along an arrow `f : Y ⟶ X`: `gf : Z ⟶ X` is in the sieve if `gf`
factors through some `g : Z ⟶ Y` which is in `R`.
-/
@[simps]
def pushforward (f : Y ⟶ X) (R : Sieve Y) : Sieve X
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upperCrossingTime_stabilize' (hnm : n ≤ m) (hn : N ≤ upperCrossingTime a b f N n ω) :
    upperCrossingTime a b f N m ω = N
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_omegaLimit (hf : ∀ t, Tendsto (t + ·) f f) : ω f ϕ (ω f ϕ s) ⊆ ω f ϕ s
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
theorem hom_eq_lift (g : X ⟶ widePullback _ _ arrows) :
    g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) (by aesop_cat)
-- .lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean
@[simp] protected theorem UInt8.sizeOf (a : UInt8) : sizeOf a = a.toNat + 2
-- Mathlib/SetTheory/Game/Basic.lean
/-- `x * 1` is equivalent to `x`. -/
theorem mul_one_equiv (x : PGame) : x * 1 ≈ x
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- For `f : α →ᵤ β`, `𝓝 f` admits the family `{g | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓤 β` as a
filter basis. -/
protected theorem hasBasis_nhds (f) :
    (𝓝 f).HasBasis (fun V => V ∈ 𝓤 β) fun V => { g | (f, g) ∈ UniformFun.gen α β V }
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Symmetric.lean
@[simp]
theorem tensor_μ_apply
    {A B C D : ModuleCat R} (x : A) (y : B) (z : C) (w : D) :
    tensor_μ _ (A, B) (C, D) ((x ⊗ₜ y) ⊗ₜ (z ⊗ₜ w)) = (x ⊗ₜ z) ⊗ₜ (y ⊗ₜ w)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp] lemma δ_zero : δ n m (0 : Cochain F G n) = 0
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
/-- `nhds` as an order embedding. -/
@[simps!]
def nhdsOrderEmbedding : PrimeSpectrum R ↪o Filter (PrimeSpectrum R)
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
theorem other_spec {a : α} {z : Sym2 α} (h : a ∈ z) : s(a, Mem.other h) = z
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumCongr_symm (e : α ≃ β) (f : γ ≃ δ) :
    (Equiv.sumCongr e f).symm = Equiv.sumCongr e.symm f.symm
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousMultilinearMap.curry_uncurryRight
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G)) :
    f.uncurryRight.curryRight = f
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
/-- The continuous function from the basic open set `D(f)` in `Proj`
to the corresponding basic open set in `Spec A⁰_f`. -/
@[simps! (config := .lemmasOnly) apply_asIdeal]
def toSpec (f : A) : (Proj.T| pbo f) ⟶ Spec.T A⁰_ f
-- Mathlib/LinearAlgebra/Ray.lean
/-- A positive multiple of a vector is in the same ray as that vector. -/
lemma sameRay_pos_smul_left (v : M) (ha : 0 < a) : SameRay R (a • v) v
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_max_le_max_abs_abs : |max a b| ≤ max |a| |b|
-- Mathlib/Data/Fintype/List.lean
@[simp]
theorem mem_lists_iff (s : Multiset α) (l : List α) : l ∈ lists s ↔ s = ⟦l⟧
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem coe_mk (z : ℂ) (hz : abs z < 1) : (mk z hz : ℂ) = z
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
/-- Let `A` be an algebraically closed field and let `x ∈ K`, with `K/F` an algebraic extension
  of fields. Then the images of `x` by the `F`-algebra morphisms from `K` to `A` are exactly
  the roots in `A` of the minimal polynomial of `x` over `F`. -/
theorem Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly [IsAlgClosed A] (x : K) :
    (Set.range fun ψ : K →ₐ[F] A ↦ ψ x) = (minpoly F x).rootSet A
-- Mathlib/SetTheory/Game/Basic.lean
/-- On `Game`, simp-normal inequalities should use as few negations as possible. -/
@[simp]
theorem not_lf : ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
protected theorem target : γ 1 = y
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
theorem type_equalizer_iff_unique :
    Nonempty (IsLimit (Fork.ofι _ w)) ↔ ∀ y : Y, g y = h y → ∃! x : X, f x = y
-- Mathlib/Data/Nat/Find.lean
lemma le_findGreatest (hmb : m ≤ n) (hm : P m) : m ≤ Nat.findGreatest P n
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
lemma injective_le_monomorphisms :
    MorphismProperty.injective C ≤ monomorphisms C
-- Mathlib/FieldTheory/NormalClosure.lean
/-- `normalClosure F K L` is a valid normal closure if `K/F` is algebraic
  and all minimal polynomials of `K/F` splits in `L/F`. -/
lemma isNormalClosure_normalClosure : IsNormalClosure F K (normalClosure F K L)
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
/-- The lower part of the second column of the snake diagram is exact. -/
lemma exact_C₂_down : (ShortComplex.mk S.v₁₂.τ₂ S.v₂₃.τ₂
    (by rw [← comp_τ₂, S.w₁₃, zero_τ₂])).Exact
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_iff_getElem? {a} {l : List α} : a ∈ l ↔ ∃ n : Nat, l[n]? = some a
-- Mathlib/Topology/StoneCech.lean
/-- The basic open sets for the topology on ultrafilters are open. -/
theorem ultrafilter_isOpen_basic (s : Set α) : IsOpen { u : Ultrafilter α | s ∈ u }
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_succ_zero (m : ℕ) : ack (m + 1) 0 = ack m 1
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
theorem IsMatching.support_eq_verts (h : M.IsMatching) : M.support = M.verts
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
@[simp]
lemma inv_add_add_mul_eq_zero (u : (PreQuasiregular R)ˣ) :
    u⁻¹.val.val + u.val.val + u.val.val * u⁻¹.val.val = 0
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem toNNReal_eq_toNNReal_iff {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    toNNReal r = toNNReal p ↔ r = p
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem emod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a % b < b
-- Mathlib/Algebra/Algebra/Bilinear.lean
theorem mulRight_injective [NoZeroDivisors A] {x : A} (hx : x ≠ 0) :
    Function.Injective (mulRight R x)
-- Mathlib/Control/Traversable/Basic.lean
theorem app_eq_coe (η : ApplicativeTransformation F G) : η.app = η
-- Mathlib/Data/List/Dedup.lean
theorem dedup_cons_of_not_mem' {a : α} {l : List α} (h : a ∉ dedup l) :
    dedup (a :: l) = a :: dedup l
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem pi_ball [∀ i, MetricSpace (α i)] (x : ∀ i, α i) {r : ℝ} (hr : 0 < r) :
    Measure.pi μ (Metric.ball x r) = ∏ i, μ i (Metric.ball (x i) r)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp] lemma Module.Dual.lie_apply (f : M →ₗ[R] R) : ⁅x, f⁆ m = - f ⁅x, m⁆
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
@[simp]
theorem evalₐ_mk (n : ℕ) (x : AdicCauchySequence I R) :
    evalₐ I n (mk I R x) = Ideal.Quotient.mk (I ^ n) (x.val n)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem sup_mul_eq_of_coprime_left (h : I ⊔ J = ⊤) : I ⊔ J * K = I ⊔ K
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
@[simp]
theorem mulMap_tmul (m : M) (n : N) : mulMap M N (m ⊗ₜ[R] n) = m.1 * n.1
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[simp] lemma id_f₀ : Hom.f₀ (𝟙 S) = 𝟙 _
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem eq_mp_eq_cast  (h : α = β) : Eq.mp  h = cast h
-- Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean
theorem isSymm_lapMatrix [AddGroupWithOne R] : (G.lapMatrix R).IsSymm
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc (attr := simp)]
lemma d₁_mapMap (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.d₁ c₁₂ i₁ i₂ i₁₂ ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ =
    (φ.f i₁).f i₂ ≫ L.d₁ c₁₂ i₁ i₂ i₁₂
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem union_compl_self (s : Set α) : s ∪ sᶜ = univ
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
/-- A commutative monoid object internal to a monoidal category.
-/
structure CommMon_ extends Mon_ C where
  mul_comm : (β_ _ _).hom ≫ mul = mul := by aesop_cat
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma jacobiTheta₂_conj (z τ : ℂ) :
    conj (jacobiTheta₂ z τ) = jacobiTheta₂ (conj z) (-conj τ)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem spanningCoe_le_of_le {H H' : Subgraph G} (h : H ≤ H') : H.spanningCoe ≤ H'.spanningCoe
-- Mathlib/Data/Complex/Exponential.lean
theorem one_le_exp {x : ℝ} (hx : 0 ≤ x) : 1 ≤ exp x
-- Mathlib/Data/Finsupp/Defs.lean
/-- `Finsupp.erase` as an `AddMonoidHom`. -/
@[simps]
def eraseAddHom (a : α) : (α →₀ M) →+ α →₀ M
-- Mathlib/Analysis/Analytic/Uniqueness.lean
/-- The *identity principle* for analytic functions: If two analytic functions coincide in a whole
neighborhood of a point `z₀`, then they coincide globally along a connected set.
For a one-dimensional version assuming only that the functions coincide at some points
arbitrarily close to `z₀`, see `eqOn_of_preconnected_of_frequently_eq`. -/
theorem eqOn_of_preconnected_of_eventuallyEq {f g : E → F} {U : Set E} (hf : AnalyticOn 𝕜 f U)
    (hg : AnalyticOn 𝕜 g U) (hU : IsPreconnected U) {z₀ : E} (h₀ : z₀ ∈ U) (hfg : f =ᶠ[𝓝 z₀] g) :
    EqOn f g U
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem eval {α : ι → Type u} [∀ i, PseudoEMetricSpace (α i)] [Fintype ι] (i : ι) :
    LipschitzWith 1 (Function.eval i : (∀ i, α i) → α i)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem eq_not_self : ∀(b : Bool), (b = (!b)) ↔ False
-- Mathlib/Algebra/Pointwise/Stabilizer.lean
@[to_additive (attr := simp)]
lemma stabilizer_empty : stabilizer G (∅ : Set α) = ⊤
-- Mathlib/Algebra/Ring/Prod.lean
@[simp]
theorem prodProdProdComm_toAddEquiv :
    (prodProdProdComm R R' S S' : _ ≃+ _) = AddEquiv.prodProdProdComm R R' S S'
-- Mathlib/Topology/DiscreteQuotient.lean
theorem map_continuous (cond : LEComap f A B) : Continuous (map f cond)
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem _root_.Finset.range_eq_Ico : range = Ico 0
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem fst_mul [Mul R] [Add A] [Mul A] [SMul R A] (x₁ x₂ : Unitization R A) :
    (x₁ * x₂).fst = x₁.fst * x₂.fst
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem PairwiseDisjoint.union (hs : s.PairwiseDisjoint f) (ht : t.PairwiseDisjoint f)
    (h : ∀ ⦃i⦄, i ∈ s → ∀ ⦃j⦄, j ∈ t → i ≠ j → Disjoint (f i) (f j)) : (s ∪ t).PairwiseDisjoint f
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem comap_iInf {ι : Sort*} (f : F) (s : ι → NonUnitalSubsemiring S) :
    (comap f (iInf s) : NonUnitalSubsemiring R) = ⨅ i, comap f (s i)
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem mem_replicate : b ∈ replicate n a ↔ n ≠ 0 ∧ b = a
-- Mathlib/Data/Nat/Totient.lean
theorem card_units_zmod_lt_sub_one {p : ℕ} (hp : 1 < p) [Fintype (ZMod p)ˣ] :
    Fintype.card (ZMod p)ˣ ≤ p - 1
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp]
theorem Proj.stalkIso'_symm_mk (x) (f) :
    (Proj.stalkIso' 𝒜 x).symm (.mk f) = (Proj.structureSheaf 𝒜).presheaf.germ
      ⟨x, mem_basicOpen_den _ x f⟩ (sectionInBasicOpen _ x f)
-- Mathlib/Data/ZMod/Basic.lean
theorem val_add_val_of_le {n : ℕ} [NeZero n] {a b : ZMod n} (h : n ≤ a.val + b.val) :
    a.val + b.val = (a + b).val + n
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem single_trans_single (a : α) (b : β) (c : γ) :
    (single a b).trans (single b c) = single a c
-- Mathlib/FieldTheory/SeparableDegree.lean
@[simp]
theorem natSepDegree_C_mul {x : F} (hx : x ≠ 0) :
    (C x * f).natSepDegree = f.natSepDegree
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_add_tsub_comm (hb : AddLECancellable b) (hd : AddLECancellable d)
    (hba : b ≤ a) (hdc : d ≤ c) : a - b + (c - d) = a + c - (b + d)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem map_smulₑ (f : A →ₑ+[φ] B) (m : M) (x : A) : f (m • x) = (φ m) • f x
-- Mathlib/SetTheory/Game/PGame.lean
/-- A new right option cannot hurt Right. -/
lemma insertRight_le (x x' : PGame) : insertRight x x' ≤ x
-- 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 LowerSemicontinuousWithinAt.add' {f g : α → γ} (hf : LowerSemicontinuousWithinAt f s x)
    (hg : LowerSemicontinuousWithinAt g s x)
    (hcont : ContinuousAt (fun p : γ × γ => p.1 + p.2) (f x, g x)) :
    LowerSemicontinuousWithinAt (fun z => f z + g z) s x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arccos_le_pi_div_four {x} : arccos x ≤ π / 4 ↔ √2 / 2 ≤ x
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_asympBound_pos : ∀ᶠ (n : ℕ) in atTop, 0 < asympBound g a b n
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem Continuous.integrableOn_uIoc [LinearOrder X] [CompactIccSpace X] [T2Space X]
    (hf : Continuous f) : IntegrableOn f (Ι a b) μ
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffAt.comp_contDiffWithinAt {n} (x : E) (hg : ContDiffAt 𝕜 n g (f x))
    (hf : ContDiffWithinAt 𝕜 n f s x) : ContDiffWithinAt 𝕜 n (g ∘ f) s x
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfpFamily_le {a b} : (∀ l, List.foldr f a l ≤ b) → nfpFamily.{u, v} f a ≤ b
-- Mathlib/Analysis/Normed/Operator/Banach.lean
/-- The Banach open mapping theorem: if a bounded linear map between Banach spaces is onto, then
any point has a preimage with controlled norm. -/
theorem exists_preimage_norm_le (surj : Surjective f) :
    ∃ C > 0, ∀ y, ∃ x, f x = y ∧ ‖x‖ ≤ C * ‖y‖
-- Mathlib/Probability/Kernel/Composition.lean
@[simp] lemma fst_prod (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsMarkovKernel η] :
    fst (κ ×ₖ η) = κ
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem Submodule.topologicalClosure_minimal (s : Submodule R M) {t : Submodule R M} (h : s ≤ t)
    (ht : IsClosed (t : Set M)) : s.topologicalClosure ≤ t
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_pow_X_add_C (r : R) (i : ℕ) : leadingCoeff ((X + C r) ^ i) = 1
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem currySum_apply (f : MultilinearMap R (fun _ : ι ⊕ ι' => M') M₂) (u : ι → M')
    (v : ι' → M') : f.currySum u v = f (Sum.elim u v)
-- Mathlib/Analysis/Asymptotics/Theta.lean
@[simp]
theorem isTheta_zero_right : (f'' =Θ[l] fun _ ↦ (0 : F')) ↔ f'' =ᶠ[l] 0
-- Mathlib/Topology/Bornology/Hom.lean
@[simp]
theorem comp_apply (f : LocallyBoundedMap β γ) (g : LocallyBoundedMap α β) (a : α) :
    f.comp g a = f (g a)
-- Mathlib/Algebra/GroupWithZero/Commute.lean
theorem inv_right₀ (h : Commute a b) : Commute a b⁻¹
-- Mathlib/Algebra/MvPolynomial/Variables.lean
/-- The variables of the product of a family of polynomials
are a subset of the union of the sets of variables of each polynomial.
-/
theorem vars_prod {ι : Type*} [DecidableEq σ] {s : Finset ι} (f : ι → MvPolynomial σ R) :
    (∏ i ∈ s, f i).vars ⊆ s.biUnion fun i => (f i).vars
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_eq_pair {s : Finset α} {a b : α} : (s : Set α) = {a, b} ↔ s = {a, b}
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- Adding an element at the beginning of a tuple and then updating it amounts to adding it
directly. -/
theorem update_snoc_last : update (snoc p x) (last n) z = snoc p z
-- Mathlib/RingTheory/SurjectiveOnStalks.lean
lemma SurjectiveOnStalks.of_comp (hg : SurjectiveOnStalks (g.comp f)) :
    SurjectiveOnStalks g
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem comap_top (f : R →+* S) : (⊤ : Subsemiring S).comap f = ⊤
-- Mathlib/Topology/ContinuousOn.lean
theorem Continuous.if_const (p : Prop) {f g : α → β} [Decidable p] (hf : Continuous f)
    (hg : Continuous g) : Continuous fun a => if p then f a else g a
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivAt_snd (x : M × M') :
    HasMFDerivAt (I.prod I') I' Prod.snd x
      (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma gaussianReal_apply_eq_integral (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (s : Set ℝ) :
    gaussianReal μ v s = ENNReal.ofReal (∫ x in s, gaussianPDFReal μ v x)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem sum_monomial_eq {A : Type*} [AddCommMonoid A] {u : σ →₀ ℕ} {r : R} {b : (σ →₀ ℕ) → R → A}
    (w : b u 0 = 0) : sum (monomial u r) b = b u r
-- Mathlib/Algebra/CharP/Defs.lean
lemma intCast_eq_intCast_mod : (a : R) = a % (p : ℤ)
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem continuousAt_coe {Y : Type*} [TopologicalSpace Y] {f : OnePoint X → Y} {x : X} :
    ContinuousAt f x ↔ ContinuousAt (f ∘ (↑)) x
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Ioo_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioo l u = S }
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
@[simp] lemma log_zero : log 0 = ⊥
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
theorem mul_def (x y : FreeAbelianGroup α) :
    x * y = lift (fun x₂ ↦ lift (fun x₁ ↦ of (x₁ * x₂)) x) y
-- Mathlib/Data/Sym/Sym2.lean
theorem map_map {g : β → γ} {f : α → β} (x : Sym2 α) : map g (map f x) = map (g ∘ f) x
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem inverse_one : inverse (1 : M₀) = 1
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma ofTensorProduct_eq :
    ofTensorProduct I (ι → R) = (piEquivOfFintype I (ι := ι) (fun _ : ι ↦ R)).symm.toLinearMap ∘ₗ
      (TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap
-- Mathlib/Order/Basic.lean
theorem not_lt_iff_eq_or_lt [LinearOrder α] {a b : α} : ¬a < b ↔ a = b ∨ b < a
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
@[simp]
theorem self_mem_ordConnectedComponent : x ∈ ordConnectedComponent s x ↔ x ∈ s
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive]
theorem comp_coprod {Q : Type*} [CommMonoid Q] (h : P →* Q) (f : M →* P) (g : N →* P) :
    h.comp (f.coprod g) = (h.comp f).coprod (h.comp g)
-- Mathlib/Order/SuccPred/Basic.lean
theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ succ^[k] x
-- Mathlib/CategoryTheory/Endomorphism.lean
@[simp] -- Porting note (#11215): TODO: use `of`/`asHom`?
theorem mul_def (xs ys : End X) : xs * ys = ys ≫ xs
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma isLocallyInjective_iff_injective :
    IsLocallyInjective φ ↔ ∀ (X : Cᵒᵖ), Function.Injective (φ.val.app X)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- For finite intervals, see: `intervalIntegral.integral_deriv_mul_eq_sub`. -/
theorem integral_Iic_deriv_mul_eq_sub
    (hu : ∀ x ∈ Iio a, HasDerivAt u (u' x) x) (hv : ∀ x ∈ Iio a, HasDerivAt v (v' x) x)
    (huv : IntegrableOn (u' * v + u * v') (Iic a))
    (h_zero : Tendsto (u * v) (𝓝[<] a) (𝓝 a')) (h_infty : Tendsto (u * v) atBot (𝓝 b')) :
    ∫ (x : ℝ) in Iic a, u' x * v x + u x * v' x = a' - b'
-- Mathlib/Algebra/SMulWithZero.lean
lemma left_ne_zero_of_smul : a • b ≠ 0 → a ≠ 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem congr_fun {f g : 𝓕} (h : f = g) (x : E) :
    f x = g x
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp, reassoc]
theorem pullbackRestrictIsoRestrict_hom_morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y)
    (U : Y.Opens) : (pullbackRestrictIsoRestrict f U).hom ≫ f ∣_ U = pullback.snd _ _
-- Mathlib/Order/GaloisConnection.lean
theorem lowerBounds_u_image (gc : GaloisConnection l u) (s : Set β) :
    lowerBounds (u '' s) = l ⁻¹' lowerBounds s
-- Mathlib/Topology/Compactness/Compact.lean
/-- Sets of subtype are compact iff the image under a coercion is. -/
theorem Subtype.isCompact_iff {p : X → Prop} {s : Set { x // p x }} :
    IsCompact s ↔ IsCompact ((↑) '' s : Set X)
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma lTensor.inverse_of_rightInverse_apply
    {h : P → N} (hgh : Function.RightInverse h g) (y : Q ⊗[R] N) :
    (lTensor.inverse_of_rightInverse Q hfg hgh) ((lTensor Q g) y) =
      Submodule.Quotient.mk (p := (LinearMap.range (lTensor Q f))) y
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
lemma add'_assoc (f₁ f₂ f₃ : L.obj X ⟶ L.obj Y) :
    add' W (add' W f₁ f₂) f₃ = add' W f₁ (add' W f₂ f₃)
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem limsup_const {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} [NeBot f]
    (b : β) : limsup (fun _ => b) f = b
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem lucas_lehmer_sufficiency (p : ℕ) (w : 1 < p) : LucasLehmerTest p → (mersenne p).Prime
-- Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean
/-- The measure of a closed set is at most the integral of any function in a decreasing
approximating sequence to the indicator of the set. -/
theorem measure_le_lintegral [MeasurableSpace X] [OpensMeasurableSpace X] (μ : Measure X) (n : ℕ) :
    μ F ≤ ∫⁻ x, (hF.apprSeq n x : ℝ≥0∞) ∂μ
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_mul_X_pow {k : ℕ} : (p * X ^ k).eval x = p.eval x * x ^ k
-- Mathlib/AlgebraicGeometry/Spec.lean
@[simp]
theorem Spec.toPresheafedSpace_obj (R : CommRingCat.{u}ᵒᵖ) :
    Spec.toPresheafedSpace.obj R = (Spec.sheafedSpaceObj (unop R)).toPresheafedSpace
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_le_one_iff_val_nonneg (x : ℚ_[p]) : ‖x‖ ≤ 1 ↔ 0 ≤ x.valuation
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem fromLocalizedModule.bij : Function.Bijective <| fromLocalizedModule S f
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp) sub_nonneg]
theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- The existence of binary biproducts implies that there is at most one preadditive structure. -/
theorem biprod.add_eq_lift_desc_id [HasBinaryBiproduct Y Y] :
    f + g = biprod.lift f g ≫ biprod.desc (𝟙 Y) (𝟙 Y)
-- Mathlib/CategoryTheory/Monad/Basic.lean
@[ext]
lemma ComonadHom.ext' {T₁ T₂ : Comonad C} (f g : T₁ ⟶ T₂) (h : f.app = g.app) : f = g