ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem sphere_eq_empty_of_subsingleton [Subsingleton α] (hε : ε ≠ 0) : sphere x ε = ∅
-- Mathlib/Order/Bounds/OrderIso.lean
theorem isGLB_preimage' {s : Set β} {x : β} : IsGLB (f ⁻¹' s) (f.symm x) ↔ IsGLB s x
-- Mathlib/Order/Filter/CountableSeparatingOn.lean
theorem exists_singleton_mem_of_mem_of_forall_separating [Nonempty α] (p : Set α → Prop)
    {s : Set α} [HasCountableSeparatingOn α p s] (hs : s ∈ l) (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) :
    ∃ a, {a} ∈ l
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem filterMap_replicate_of_none {f : α → Option β} (h : f a = none) :
    (replicate n a).filterMap f = []
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem symm_trans_apply (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : γ) :
    (e₁.trans e₂).symm c = e₁.symm (e₂.symm c)
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
lemma concaveOn_negMulLog : ConcaveOn ℝ (Set.Ici (0 : ℝ)) negMulLog
-- Mathlib/RingTheory/Bialgebra/Hom.lean
theorem comp_assoc (φ₁ : C →ₐc[R] D) (φ₂ : B →ₐc[R] C) (φ₃ : A →ₐc[R] B) :
    (φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃)
-- Mathlib/Data/Set/Pairwise/Basic.lean
/-- For a nonempty set `s`, a function `f` takes pairwise equal values on `s` if and only if
for some `z` in the codomain, `f` takes value `z` on all `x ∈ s`. See also
`Set.pairwise_eq_iff_exists_eq` for a version that assumes `[Nonempty ι]` instead of
`Set.Nonempty s`. -/
theorem Nonempty.pairwise_eq_iff_exists_eq {s : Set α} (hs : s.Nonempty) {f : α → ι} :
    (s.Pairwise fun x y => f x = f y) ↔ ∃ z, ∀ x ∈ s, f x = z
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma factorsThrough_one_iff : FactorsThrough χ 1 ↔ χ = 1
-- Mathlib/Algebra/Regular/SMul.lean
/-- A unit is `M`-regular. -/
theorem IsUnit.isSMulRegular (ua : IsUnit a) : IsSMulRegular M a
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem ofReal_norm_eq_lintegral (f : α →₁[μ] β) :
    ENNReal.ofReal ‖f‖ = ∫⁻ x, (‖f x‖₊ : ℝ≥0∞) ∂μ
-- Mathlib/Order/Antichain.lean
theorem image_iso_iff [LE α] [LE β] {φ : α ≃o β} :
    IsAntichain (· ≤ ·) (φ '' s) ↔ IsAntichain (· ≤ ·) s
-- Mathlib/Order/Filter/Prod.lean
@[simp]
theorem map_snd_prod (f : Filter α) (g : Filter β) [NeBot f] : map Prod.snd (f ×ˢ g) = g
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem ω_pow_eq_one (p' : ℕ) (h : lucasLehmerResidue (p' + 2) = 0) :
    (ω : X (q (p' + 2))) ^ 2 ^ (p' + 2) = 1
-- Mathlib/Analysis/Complex/Hadamard.lean
/-- Useful rewrite for the absolute value of `invInterpStrip`-/
lemma abs_invInterpStrip {ε : ℝ} (hε : ε > 0) :
    abs (invInterpStrip f z ε) =
    (ε + sSupNormIm f 0) ^ (z.re - 1) * (ε + sSupNormIm f 1) ^ (-z.re)
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem length_mul_simple_ne (w : W) (i : B) : ℓ (w * s i) ≠ ℓ w
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
/-- The **Banach-Alaoglu theorem**: closed balls of the dual of a normed space `E` are compact in
the weak-star topology. -/
theorem isCompact_closedBall [ProperSpace 𝕜] (x' : Dual 𝕜 E) (r : ℝ) :
    IsCompact (toNormedDual ⁻¹' closedBall x' r)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem isCoprime_map [Field k] (f : R →+* k) : IsCoprime (p.map f) (q.map f) ↔ IsCoprime p q
-- Mathlib/AlgebraicGeometry/Stalk.lean
@[simp]
theorem IsAffineOpen.fromSpecStalk_eq_fromSpecStalk
    {X : Scheme} {U : X.Opens} (hU : IsAffineOpen U) {x : X} (hxU : x ∈ U) :
    hU.fromSpecStalk hxU = X.fromSpecStalk x
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
@[simp]
theorem deriv_cexp (hc : DifferentiableAt 𝕜 f x) :
    deriv (fun x => Complex.exp (f x)) x = Complex.exp (f x) * deriv f x
-- Mathlib/Data/Finset/Card.lean
@[nolint unusedHavesSuffices] -- Porting note: false positive
theorem strongDownwardInductionOn_eq {p : Finset α → Sort*} (s : Finset α)
    (H : ∀ t₁, (∀ {t₂ : Finset α}, t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) :
    s.strongDownwardInductionOn H = H s fun {t} ht _ => t.strongDownwardInductionOn H ht
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_of_le {s t : Submodule R M} [ht : IsNoetherian R t] (h : s ≤ t) :
    IsNoetherian R s
-- Mathlib/Analysis/Complex/AbsMax.lean
/-- **Maximum modulus principle** on a connected set. Let `U` be a (pre)connected open set in a
complex normed space.  Let `f : E → F` be a function that is complex differentiable on `U` and is
continuous on its closure. Suppose that `‖f x‖` takes its maximum value on `U` at `c ∈ U`. Then
`‖f x‖ = ‖f c‖` for all `x ∈ closure U`. -/
theorem norm_eqOn_closure_of_isPreconnected_of_isMaxOn {f : E → F} {U : Set E} {c : E}
    (hc : IsPreconnected U) (ho : IsOpen U) (hd : DiffContOnCl ℂ f U) (hcU : c ∈ U)
    (hm : IsMaxOn (norm ∘ f) U c) : EqOn (norm ∘ f) (const E ‖f c‖) (closure U)
-- Mathlib/Topology/LocallyConstant/Basic.lean
/-- If a composition of a function `f` followed by an injection `g` is locally
constant, then the locally constant property descends to `f`. -/
theorem desc {α β : Type*} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
    (inj : Function.Injective g) : IsLocallyConstant f
-- Mathlib/Topology/DiscreteQuotient.lean
theorem isOpen_preimage (A : Set S) : IsOpen (S.proj ⁻¹' A)
-- Mathlib/Order/Filter/Bases.lean
@[simp 1100] -- Porting note: higher priority for linter
theorem disjoint_principal_principal {s t : Set α} : Disjoint (𝓟 s) (𝓟 t) ↔ Disjoint s t
-- Mathlib/FieldTheory/Minpoly/Field.lean
/-- See also `minpoly.ker_eval` which relaxes the assumptions on `A` in exchange for
stronger assumptions on `B`. -/
@[simp]
lemma ker_aeval_eq_span_minpoly :
    RingHom.ker (Polynomial.aeval x) = A[X] ∙ minpoly A x
-- Mathlib/Data/Set/Image.lean
theorem Injective.preimage_image (hf : Injective f) (s : Set α) : f ⁻¹' (f '' s) = s
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMaxOn.neg (hf : IsLocalMaxOn f s a) : IsLocalMinOn (fun x => -f x) s a
-- Mathlib/Algebra/Polynomial/Module/FiniteDimensional.lean
theorem isTorsion_of_finiteDimensional [Field K] [Ring A] [Algebra K A]
    [AddCommGroup M] [Module A M] [Module K M] [IsScalarTower K A M] [FiniteDimensional K A] :
    IsTorsion K[X] (AEval K M a)
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
theorem gelfandTransform_map_star (a : A) :
    gelfandTransform ℂ A (star a) = star (gelfandTransform ℂ A a)
-- Mathlib/Topology/Algebra/OpenSubgroup.lean
theorem isOpen_of_isOpen_subideal {U I : Ideal R} (h : U ≤ I) (hU : IsOpen (U : Set R)) :
    IsOpen (I : Set R)
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_pi {ι : Type*} {E : ι → Type*} [∀ i, AddCommMonoid (E i)] [∀ i, SMul 𝕜 (E i)]
    {s : Set ι} {t : ∀ i, Set (E i)} (ht : ∀ ⦃i⦄, i ∈ s → Convex 𝕜 (t i)) : Convex 𝕜 (s.pi t)
-- Mathlib/Analysis/Calculus/Implicit.lean
theorem right_map_implicitFunction :
    ∀ᶠ p : F × G in 𝓝 (φ.prodFun φ.pt), φ.rightFun (φ.implicitFunction p.1 p.2) = p.2
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma Hom.id_comp (f : Hom P P') : (Hom.id P').comp f = f
-- Mathlib/GroupTheory/Subgroup/Saturated.lean
@[to_additive]
theorem saturated_iff_zpow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℤ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem zero_apply : (0 : M [⋀^ι]→ₗ[R] N) v = 0
-- Mathlib/CategoryTheory/Square.lean
@[ext]
lemma hom_ext {sq₁ sq₂ : Square C} {f g : sq₁ ⟶ sq₂}
    (h₁ : f.τ₁ = g.τ₁) (h₂ : f.τ₂ = g.τ₂)
    (h₃ : f.τ₃ = g.τ₃) (h₄ : f.τ₄ = g.τ₄) : f = g
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma natDegree_preΨ'_pos {n : ℕ} (hn : 2 < n) (h : (n : R) ≠ 0) : 0 < (W.preΨ' n).natDegree
-- Mathlib/Algebra/RingQuot.lean
theorem smul_quot [Algebra S R] {n : S} {a : R} :
    (n • ⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (n • a)⟩
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem lor_bit (a m b n) : lor (bit a m) (bit b n) = bit (a || b) (lor m n)
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected lemma _root_.IsCompact.exists_isOpen_lt_of_lt [InnerRegularCompactLTTop μ]
    [IsLocallyFiniteMeasure μ] [R1Space α] [BorelSpace α] {K : Set α}
    (hK : IsCompact K) (r : ℝ≥0∞) (hr : μ K < r) :
    ∃ U, K ⊆ U ∧ IsOpen U ∧ μ U < r
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.inl_union_inr {s : Set M} {t : Set M'}
    (hs : LinearIndependent R (fun x => x : s → M))
    (ht : LinearIndependent R (fun x => x : t → M')) :
    LinearIndependent R (fun x => x : ↥(inl R M M' '' s ∪ inr R M M' '' t) → M × M')
-- Mathlib/Data/Rat/Lemmas.lean
protected theorem «forall» {p : ℚ → Prop} : (∀ r, p r) ↔ ∀ a b : ℤ, p (a / b)
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_analytic (x : 𝔸) : AnalyticAt 𝕂 (exp 𝕂) x
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_const_on_unit_interval : ∫ _ in a..a + 1, b = b
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_linear (e : P₁ ≃ᵃ[k] P₂) : (e : P₁ →ᵃ[k] P₂).linear = e.linear
-- Mathlib/FieldTheory/IntermediateField.lean
/-- An intermediate field contains the ring's 0. -/
protected theorem zero_mem : (0 : L) ∈ S
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[reassoc (attr := simp)]
theorem pi_condition : Pi.lift K.ι ≫ I.fstPiMap = Pi.lift K.ι ≫ I.sndPiMap
-- Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean
theorem le_invariants_iterate (f : α → α) (n : ℕ) :
    invariants f ≤ invariants (f^[n])
-- Mathlib/NumberTheory/NumberField/Basic.lean
/-- The ring of integers of a number field is not a field. -/
theorem not_isField : ¬IsField (𝓞 K)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem intCoe_one [AddGroupWithOne R] : ((1 : ArithmeticFunction ℤ) :
    ArithmeticFunction R) = 1
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- The composition of `C^n` functions on domains is `C^n`. -/
theorem ContMDiffOn.comp' {t : Set M'} {g : M' → M''} (hg : ContMDiffOn I' I'' n g t)
    (hf : ContMDiffOn I I' n f s) : ContMDiffOn I I'' n (g ∘ f) (s ∩ f ⁻¹' t)
-- Mathlib/Algebra/CharP/Basic.lean
theorem add_pow_prime_eq (hp : p.Prime) (x y : R) :
    (x + y) ^ p =
      x ^ p + y ^ p + p * ∑ k ∈ Finset.Ioo 0 p, x ^ k * y ^ (p - k) * ↑(p.choose k / p)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_subtype {α} [MeasureSpace α] {s : Set α} (hs : MeasurableSet s) (f : α → G) :
    ∫ x : s, f x = ∫ x in s, f x
-- Mathlib/Topology/UnitInterval.lean
theorem mul_pos_mem_iff {a t : ℝ} (ha : 0 < a) : a * t ∈ I ↔ t ∈ Set.Icc (0 : ℝ) (1 / a)
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem covering_mem_family {p : α × Set α} (hp : p ∈ h.index) : h.covering p ∈ v.setsAt p.1
-- Mathlib/Probability/Distributions/Uniform.lean
theorem toMeasure_uniformOfFintype_apply [MeasurableSpace α] (hs : MeasurableSet s) :
    (uniformOfFintype α).toMeasure s = Fintype.card s / Fintype.card α
-- Mathlib/RingTheory/PiTensorProduct.lean
@[simp] lemma tprod_noncommProd {κ : Type*} (s : Finset κ) (x : κ → Π i, A i) (hx) :
    tprod R (s.noncommProd x hx) = s.noncommProd (fun k => tprod R (x k))
      (hx.imp fun _ _ => Commute.tprod)
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem LinearMap.toMatrixₛₗ₂'_symm :
    ((LinearMap.toMatrixₛₗ₂' R).symm : Matrix n m N₂ ≃ₗ[R] _) = Matrix.toLinearMapₛₗ₂' R σ₁ σ₂
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
theorem comp_val_base {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val.base = f.val.base ≫ g.val.base
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_succ_succ (m n : ℕ) : ack (m + 1) (n + 1) = ack m (ack (m + 1) n)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_fin (n : ℕ) : @type (Fin n) (· < ·) _ = n
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem ext_iff {A B : StructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.right = g.right
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_mul (x y : H) : (↑(x * y) : G) = ↑x * ↑y
-- Mathlib/Topology/Instances/AddCircle.lean
lemma isLocalHomeomorph_coe [DiscreteTopology (zmultiples p)] [DenselyOrdered 𝕜] :
    IsLocalHomeomorph ((↑) : 𝕜 → AddCircle p)
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem ofIsCompl_zero (h : IsCompl p q) : (ofIsCompl h 0 0 : E →ₗ[R] F) = 0
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
theorem smul_mem (r : R) (h : x ∈ p) : r • x ∈ p
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.add_smul_sub_mem (hs : StarConvex 𝕜 x s) (hy : y ∈ s) {t : 𝕜} (ht₀ : 0 ≤ t)
    (ht₁ : t ≤ 1) : x + t • (y - x) ∈ s
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem coe_neg (f : ModularForm Γ k) : ⇑(-f) = -f
-- Mathlib/Topology/PartialHomeomorph.lean
theorem iff_symm_preimage_eq : e.IsImage s t ↔ e.target ∩ e.symm ⁻¹' s = e.target ∩ t
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- We can transport limits of shape `J` along an equivalence `J ≌ J'`.
-/
theorem hasLimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasLimitsOfShape J C] : HasLimitsOfShape J' C
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp] lemma top_mul (hb : b ≠ 0) : ⊤ * b = ⊤
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem diag_union_offDiag : s.diag ∪ s.offDiag = s ×ˢ s
-- Mathlib/CategoryTheory/Limits/FinallySmall.lean
theorem initiallySmall_of_initial_of_initiallySmall [InitiallySmall.{w} K] : InitiallySmall.{w} J
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsRelPrime.of_add_mul_right_left (h : IsRelPrime (x + z * y) y) : IsRelPrime x y
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem map_smul [Module R E₂] {e : E ≃ₗᵢ[R] E₂} (c : R) (x : E) : e (c • x) = c • e x
-- Mathlib/GroupTheory/EckmannHilton.lean
/-- If a type carries two unital binary operations that distribute over each other,
then they have the same unit elements.

In fact, the two operations are the same, and give a commutative monoid structure,
see `eckmann_hilton.CommMonoid`. -/
theorem one : e₁ = e₂
-- Mathlib/Algebra/Algebra/Tower.lean
theorem algebraMap_eq : algebraMap R A = (algebraMap S A).comp (algebraMap R S)
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem iterate_frobenius_mk (n : ℕ) (x : K) :
    (frobenius (PerfectClosure K p) p)^[n] (mk K p ⟨n, x⟩) = of K p x
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem lie_zsmul (a : ℤ) : ⁅x, a • m⁆ = a • ⁅x, m⁆
-- Mathlib/Computability/Primrec.lean
theorem vector_cons {n} : Primrec₂ (@Vector.cons α n)
-- Mathlib/Topology/Constructions.lean
/-- A version of `continuous_inf_dom_right` for binary functions -/
theorem continuous_inf_dom_right₂ {X Y Z} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
    {tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z}
    (h : by haveI := ta2; haveI := tb2; exact Continuous fun p : X × Y => f p.1 p.2) : by
    haveI := ta1 ⊓ ta2; haveI := tb1 ⊓ tb2; exact Continuous fun p : X × Y => f p.1 p.2
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem apply_mk (f : α → β) (h h') (x : α) : SimpleFunc.mk f h h' x = f x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
protected theorem mul_const [Mul β] [ContinuousMul β] (hf : AEStronglyMeasurable f μ) (c : β) :
    AEStronglyMeasurable (fun x => f x * c) μ
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive exists_pos_of_sum_zero_of_exists_nonzero]
theorem exists_one_lt_of_prod_one_of_exists_ne_one' (f : ι → M) (h₁ : ∏ i ∈ s, f i = 1)
    (h₂ : ∃ i ∈ s, f i ≠ 1) : ∃ i ∈ s, 1 < f i
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
theorem volume_pi_Ioo {a b : ι → ℝ} :
    volume (pi univ fun i => Ioo (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i)
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
@[simp]
theorem appHom_valid_glue {X : D} {Y : C} (f : op X ⟶ op (G.obj Y)) :
    appHom α X ≫ ℱ'.val.map f = ℱ.map f ≫ α.app (op Y)
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- If a pair of measures `HaveLebesgueDecomposition`, then `rnDeriv` chooses the
measurable function from `HaveLebesgueDecomposition`, otherwise it returns the zero function.
For sigma-finite measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def rnDeriv (μ ν : Measure α) : α → ℝ≥0∞
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem nonempty_compl_range {ι : Type u} (f : ι → Ordinal.{max u v}) : (Set.range f)ᶜ.Nonempty
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive]
theorem disjoint_def' {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1
-- Mathlib/Probability/Process/Adapted.lean
theorem progMeasurable_const [MeasurableSpace ι] (f : Filtration ι m) (b : β) :
    ProgMeasurable f (fun _ _ => b : ι → Ω → β)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_lt_asymm : ∀{a b : Nat}, a ≤ b → ¬(b < a)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ico_subset_Ico_right (h : b₁ ≤ b₂) : Ico a b₁ ⊆ Ico a b₂
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma birkhoffSet_inf (a b : α) : birkhoffSet (a ⊓ b) = birkhoffSet a ∩ birkhoffSet b
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem symm_toPartialEquiv : e.symm.toPartialEquiv = e.toPartialEquiv.symm
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem epi_of_target_iso_zero {X Y : C} (f : X ⟶ Y) (i : Y ≅ 0) : Epi f
-- Mathlib/Order/RelClasses.lean
lemma ne_of_ssubset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → a ≠ b
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepSets.iUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (hyp : ∀ n, IndepSets (s n) s' κ μ) :
    IndepSets (⋃ n, s n) s' κ μ
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem coe_pointwise_smul (a : α) (S : AddSubgroup A) : ↑(a • S) = a • (S : Set A)
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.mul_right [CommMonoid α] {a b : α} (h : a ~ᵤ b) (c : α) : a * c ~ᵤ b * c
-- Mathlib/RingTheory/RingHomProperties.lean
theorem RespectsIso.cancel_right_isIso (hP : RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S)
    (g : S ⟶ T) [IsIso g] : P (f ≫ g) ↔ P f
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem mem_balancedCoreAux_iff : x ∈ balancedCoreAux 𝕜 s ↔ ∀ r : 𝕜, 1 ≤ ‖r‖ → x ∈ r • s
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem leadingCoeff_map_of_leadingCoeff_ne_zero (f : R →+* S) (hf : f (leadingCoeff p) ≠ 0) :
    leadingCoeff (p.map f) = f (leadingCoeff p)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast] lemma coe_nonempty : (s : Set α).Nonempty ↔ s ≠ ⊤
-- Mathlib/Data/Finmap.lean
lemma nodup_entries (f : Finmap β) : f.entries.Nodup
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[fun_prop, measurability]
theorem prod_mk {f : α → β} {g : α → γ} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun x => (f x, g x)) μ
-- Mathlib/Analysis/Analytic/Basic.lean
theorem AnalyticAt.congr (hf : AnalyticAt 𝕜 f x) (hg : f =ᶠ[𝓝 x] g) : AnalyticAt 𝕜 g x
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
lemma isLocallyFull : G.IsLocallyFull K
-- Mathlib/Data/Finset/Lattice.lean
/-- To rewrite from right to left, use `Finset.sup'_comp_eq_map`. -/
@[simp]
theorem sup'_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : (s.map f).Nonempty) :
    (s.map f).sup' hs g = s.sup' (map_nonempty.1 hs) (g ∘ f)
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem nf_repr_split {o o' m} [NF o] (h : split o = (o', m)) : NF o' ∧ repr o = repr o' + m
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem isAffine_of_isIso {X Y : Scheme} (f : X ⟶ Y) [IsIso f] [h : IsAffine Y] : IsAffine X
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem disjoint_of_disjoint_append_left_right (d : Disjoint (l₁ ++ l₂) l) : Disjoint l₂ l
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma max_eq_zero_iff : max m n = 0 ↔ m = 0 ∧ n = 0
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.convolution_integrand_bound_right (hcg : HasCompactSupport g)
    (hg : Continuous g) {x t : G} {s : Set G} (hx : x ∈ s) :
    ‖L (f t) (g (x - t))‖ ≤ (-tsupport g + s).indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem reverse_coe (l : List α) : (l : Cycle α).reverse = l.reverse
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem not_mem_of_lt_csInf {x : α} {s : Set α} (h : x < sInf s) (hs : BddBelow s) : x ∉ s
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem is_lt (a : Fin n) : (a : Nat) < n
-- Mathlib/Order/Cover.lean
theorem wcovBy_of_le_of_le (h1 : a ≤ b) (h2 : b ≤ a) : a ⩿ b
-- Mathlib/Order/Closure.lean
@[mono]
theorem monotone : Monotone (u ∘ l)
-- Mathlib/NumberTheory/NumberField/House.lean
private theorem supOfBasis_nonneg : 0 ≤ supOfBasis K
-- Mathlib/Algebra/RingQuot.lean
theorem eq_liftAlgHom_comp_mkAlgHom {s : A → A → Prop} (f : RingQuot s →ₐ[S] B) :
    f = liftAlgHom S ⟨f.comp (mkAlgHom S s), fun x y h ↦ congr_arg f (mkAlgHom_rel S h)⟩
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_eq_multiset_prod [CommMonoid β] (s : Finset α) (f : α → β) :
    ∏ x ∈ s, f x = (s.1.map f).prod
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csSup_pair (a b : α) : sSup {a, b} = a ⊔ b
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem Nonempty.subset_one_iff (h : s.Nonempty) : s ⊆ 1 ↔ s = 1
-- Mathlib/Order/Filter/AtTopBot.lean
/-- The `atTop` filter for an open interval `Ioi a` comes from the `atTop` filter in the ambient
order. -/
theorem atTop_Ioi_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ioi a → α) atTop
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem arrowCongr'_trans {α₁ α₂ β₁ β₂ α₃ β₃ : Type*}
    (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
    arrowCongr' (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr' e₁ e₁').trans (arrowCongr' e₂ e₂')
-- Mathlib/Algebra/Polynomial/Div.lean
theorem sub_dvd_eval_sub (a b : R) (p : R[X]) : a - b ∣ p.eval a - p.eval b
-- Mathlib/Topology/Separation.lean
theorem exists_open_singleton_of_finite [T0Space X] [Finite X] [Nonempty X] :
    ∃ x : X, IsOpen ({x} : Set X)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- We can transport colimits of shape `J` along an equivalence `J ≌ J'`.
-/
theorem hasColimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasColimitsOfShape J C] : HasColimitsOfShape J' C
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_nonpos_iff_neg_imp_nonneg [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)
-- Mathlib/Probability/Process/HittingTime.lean
/-- This lemma is strictly weaker than `hitting_of_le`. -/
theorem hitting_of_lt {m : ι} (h : m < n) : hitting u s n m ω = m
-- Mathlib/RingTheory/WittVector/Teichmuller.lean
private theorem teichmuller_mul_aux₁ (x y : MvPolynomial R ℚ) :
    teichmullerFun p (x * y) = teichmullerFun p x * teichmullerFun p y
-- Mathlib/Logic/Equiv/Defs.lean
theorem symm_bijective : Function.Bijective (Equiv.symm : (α ≃ β) → β ≃ α)
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Ioc_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioc l u = S }
-- Mathlib/CategoryTheory/Limits/Creates.lean
/-- If `F` creates the limit of `K` and `K ⋙ F` has a limit, then `K` has a limit. -/
theorem hasColimit_of_created (K : J ⥤ C) (F : C ⥤ D) [HasColimit (K ⋙ F)] [CreatesColimit K F] :
    HasColimit K
-- Mathlib/CategoryTheory/DiscreteCategory.lean
/-- For functors out of a discrete category,
a natural isomorphism is just a collection of isomorphisms,
as the naturality squares are trivial.
-/
@[simps!]
def natIso {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ≅ G.obj i) :
    F ≅ G
-- Mathlib/Tactic/NormNum/Result.lean
theorem IsRat.to_isNat {α} [Ring α] : ∀ {a : α} {n}, IsRat a (.ofNat n) (nat_lit 1) → IsNat a n
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_of_floor_lt (h : ⌊a⌋₊ < n) : a < n
-- Mathlib/Data/Finset/Sups.lean
lemma image_subset_infs_left : b ∈ t → s.image (· ⊓ b) ⊆ s ⊼ t