ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma Even.add_one (h : Even a) : Odd (a + 1)
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
theorem tensorRightHomEquiv_symm_naturality {X X' Y Y' Z : C} [ExactPairing Y Y'] (f : X ⟶ X')
    (g : X' ⟶ Z ⊗ Y') :
    (tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) =
      f ▷ Y ≫ (tensorRightHomEquiv X' Y Y' Z).symm g
-- Mathlib/Data/Real/Basic.lean
protected theorem fact_zero_lt_one : Fact ((0 : ℝ) < 1)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] protected lemma sdiff_idem (s : UpperSet α) (t : Set α) : (s.sdiff t).sdiff t = s.sdiff t
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalExtrOn.on_subset {t : Set α} (hf : IsLocalExtrOn f t a) (h : s ⊆ t) :
    IsLocalExtrOn f s a
-- Mathlib/Data/Set/Prod.lean
theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
    s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem edist_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x y : PiLp 2 β) :
    edist x y = (∑ i, edist (x i) (y i) ^ 2) ^ (1 / 2 : ℝ)
-- Mathlib/Data/Finset/Sym.lean
@[simp]
theorem sym_succ : s.sym (n + 1) = s.sup fun a ↦ (s.sym n).image <| Sym.cons a
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
@[simp, norm_cast]
theorem coe_smul (c : 𝕜) (f : Lp.simpleFunc E p μ) :
    ((c • f : Lp.simpleFunc E p μ) : Lp E p μ) = c • (f : Lp E p μ)
-- Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
lemma dualSubmodule_flip_dualSubmodule_of_basis {ι : Type*} [Finite ι]
    (hB : B.Nondegenerate) (b : Basis ι S M) :
    B.flip.dualSubmodule (B.dualSubmodule (Submodule.span R (Set.range b))) =
      Submodule.span R (Set.range b)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
If the msb is `true`, the arithmetic shift right equals negating,
then logical shifting right, then negating again.
The double negation preserves the lower bits that have been shifted,
and the outer negation ensures that the high bits are '1'. -/
theorem sshiftRight_eq_of_msb_true {x : BitVec w} {s : Nat} (h : x.msb = true) :
    (x.sshiftRight s) = ~~~((~~~x) >>> s)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] protected theorem le_refl : ∀ (x : Bool), x ≤ x
-- Mathlib/Algebra/Group/Int.lean
lemma toAdd_pow (a : Multiplicative ℤ) (b : ℕ) : toAdd (a ^ b) = toAdd a * b
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.intNorm_eq_norm [Module.Free A B] : Algebra.intNorm A B = Algebra.norm A
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem toAddSubmonoid_le : p.toAddSubmonoid ≤ q.toAddSubmonoid ↔ p ≤ q
-- Mathlib/Data/Num/Lemmas.lean
theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n
-- Mathlib/RingTheory/Multiplicity.lean
theorem finite_pow {p a : α} (hp : Prime p) : ∀ {k : ℕ} (_ : Finite p a), Finite p (a ^ k)
-- Mathlib/Order/Hom/Basic.lean
theorem apply_eq_iff_eq_symm_apply (e : α ≃o β) (x : α) (y : β) : e x = y ↔ x = e.symm y
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_self_rpow_inv {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ (1 / y)) ^ y = x
-- Mathlib/Algebra/RingQuot.lean
theorem neg_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a} :
    (-⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (-a)⟩
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mul_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a * b < ℵ₀
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem torsionBySet.mk_smul (I : Ideal R) (b : R) (x : torsionBySet R M I) :
    Ideal.Quotient.mk I b • x = b • x
-- Mathlib/Algebra/DirectSum/Ring.lean
/-- The piecewise multiplication from the `Mul` instance, as a bundled homomorphism. -/
@[simps]
def gMulHom {i j} : A i →+ A j →+ A (i + j)
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem Pairwise.imp₂ (H : ∀ a b, R a b → S a b → T a b)
    (hR : Pairwise R l) (hS : l.Pairwise S) : l.Pairwise T
-- Mathlib/FieldTheory/Minpoly/Basic.lean
theorem two_le_natDegree_iff (int : IsIntegral A x) :
    2 ≤ (minpoly A x).natDegree ↔ x ∉ (algebraMap A B).range
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem map_X : ∀ n : σ, map f (X n : MvPolynomial σ R) = X n
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem HasDerivWithinAt.sqrt (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasDerivWithinAt (fun y => √(f y)) (f' / (2 * √(f x))) s x
-- Mathlib/RingTheory/Localization/NumDen.lean
theorem num_den_reduced (x : K) : IsRelPrime (num A x) (den A x)
-- Mathlib/CategoryTheory/Preadditive/Schur.lean
theorem endomorphism_simple_eq_smul_id {X : C} [Simple X] [FiniteDimensional 𝕜 (X ⟶ X)]
    (f : X ⟶ X) : ∃ c : 𝕜, c • 𝟙 X = f
-- Mathlib/Order/Synonym.lean
@[simp]
theorem toLex_ofLex (a : Lex α) : toLex (ofLex a) = a
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getMsb_ofBoolListLE :
    (ofBoolListLE bs).getMsb i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false)
-- Mathlib/Data/List/Sublists.lean
theorem sublists_append (l₁ l₂ : List α) :
    sublists (l₁ ++ l₂) = (sublists l₂) >>= (fun x => (sublists l₁).map (· ++ x))
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_reindex_right (f : α → β → γ) (em : m ≃ m') (en : n ≃ n') (M : Matrix l l' α)
    (N : Matrix m n β) :
    kroneckerMap f M (reindex em en N) =
      reindex ((Equiv.refl _).prodCongr em) ((Equiv.refl _).prodCongr en) (kroneckerMap f M N)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem comap_embedding_atBot [Preorder β] [Preorder γ] {e : β → γ}
    (hm : ∀ b₁ b₂, e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) (hu : ∀ c, ∃ b, e b ≤ c) : comap e atBot = atBot
-- Mathlib/Data/Set/Sigma.lean
theorem sigma_insert {a : ∀ i, α i} :
    s.sigma (fun i ↦ insert (a i) (t i)) = (fun i ↦ ⟨i, a i⟩) '' s ∪ s.sigma t
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_inf_distrib_right (s : Finset ι) (f : ι → α) (a : α) :
    s.sup f ⊓ a = s.sup fun i => f i ⊓ a
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem eqId_iff_len_eq : A.EqId ↔ A.1.unop.len = Δ.unop.len
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
/-- The characteristic `p` version of `peval_polyOfInterest` -/
theorem peval_polyOfInterest' (n : ℕ) (x y : 𝕎 k) :
    peval (polyOfInterest p n) ![fun i => x.coeff i, fun i => y.coeff i] =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) -
        x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)
-- Mathlib/Analysis/Convex/Slope.lean
/-- If `f : 𝕜 → 𝕜` is strictly concave, then for any point `a` the slope of the secant line of `f`
through `a` and `b` is strictly antitone with respect to `b`. -/
theorem StrictConcaveOn.secant_strict_mono (hf : StrictConcaveOn 𝕜 s f) {a x y : 𝕜} (ha : a ∈ s)
    (hx : x ∈ s) (hy : y ∈ s) (hxa : x ≠ a) (hya : y ≠ a) (hxy : x < y) :
    (f y - f a) / (y - a) < (f x - f a) / (x - a)
-- Mathlib/Data/Seq/WSeq.lean
theorem toList'_map (l : List α) (s : WSeq α) :
    Computation.corec (fun ⟨l, s⟩ =>
      match Seq.destruct s with
      | none => Sum.inl l.reverse
      | some (none, s') => Sum.inr (l, s')
      | some (some a, s') => Sum.inr (a :: l, s')) (l, s) = (l.reverse ++ ·) <$> toList s
-- Mathlib/Topology/Homeomorph.lean
protected theorem t1Space [T1Space X] (h : X ≃ₜ Y) : T1Space Y
-- Mathlib/Algebra/Module/BigOperators.lean
theorem Finset.cast_card [CommSemiring R] (s : Finset α) : (s.card : R) = ∑ a ∈ s, 1
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem intCast_den (a : Int) : (a : Rat).den = 1
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem map_mem_map {f : P →ₐ[R] P'} (h : Function.Injective f) {x : P} {I : FractionalIdeal S P} :
    f x ∈ map f I ↔ x ∈ I
-- Mathlib/Algebra/CharP/ExpChar.lean
@[simp]
theorem iterateFrobenius_one : iterateFrobenius R p 1 = frobenius R p
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem support_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).support = p.support
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.measure_stieltjesFunction_Iic (a : α) (x : ℝ) :
    (hf.stieltjesFunction a).measure (Iic x) = ENNReal.ofReal (hf.stieltjesFunction a x)
-- Mathlib/Data/Set/Function.lean
theorem EqOn.surjOn_iff (h : EqOn f₁ f₂ s) : SurjOn f₁ s t ↔ SurjOn f₂ s t
-- Mathlib/Data/Complex/Exponential.lean
theorem tanh_eq_sinh_div_cosh : tanh x = sinh x / cosh x
-- Mathlib/RingTheory/Algebraic.lean
/-- An algebra is algebraic if and only if it is algebraic as a subalgebra. -/
theorem Algebra.isAlgebraic_iff : Algebra.IsAlgebraic R A ↔ (⊤ : Subalgebra R A).IsAlgebraic
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem min_abs_abs_le_abs_min : min |a| |b| ≤ |min a b|
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
/-- The operator norm of the second projection `E × F → F` is exactly 1 if `F` is nontrivial. -/
@[simp] lemma norm_snd [SeminormedAddCommGroup E] [NormedSpace 𝕜 E]
    [NormedAddCommGroup F] [NormedSpace 𝕜 F] [Nontrivial F]  :
    ‖snd 𝕜 E F‖ = 1
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem ofSubtype_apply_of_not_mem (f : Perm (Subtype p)) (ha : ¬p a) : ofSubtype f a = a
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem isTheta_const_smul_right [NormedSpace 𝕜 F'] {c : 𝕜} (hc : c ≠ 0) :
    (f =Θ[l] fun x ↦ c • g' x) ↔ f =Θ[l] g'
-- Mathlib/Algebra/Ring/Ext.lean
@[ext] theorem ext ⦃inst₁ inst₂ : Semiring R⦄
    (h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
    (h_mul : local_hMul[R, inst₁] = local_hMul[R, inst₂]) :
    inst₁ = inst₂
-- Mathlib/Data/Setoid/Basic.lean
@[simp]
theorem top_def : (⊤ : Setoid α).Rel = ⊤
-- Mathlib/Algebra/Group/Pi/Basic.lean
theorem surjective_pi_map {F : ∀ i, f i → g i} (hF : ∀ i, Surjective (F i)) :
    Surjective fun x : ∀ i, f i => fun i => F i (x i)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_omega {o : Ordinal} : o < ω ↔ ∃ n : ℕ, o = n
-- Mathlib/CategoryTheory/Generator.lean
theorem isDetecting_unop_iff (𝒢 : Set Cᵒᵖ) : IsDetecting 𝒢.unop ↔ IsCodetecting 𝒢
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_neg (x : s) : (↑(-x) : K) = -↑x
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- If a product of integers is `-1`, then at least one factor must be `-1`. -/
theorem neg_one_mem_of_prod_eq_neg_one {l : List ℤ} (h : l.prod = -1) : (-1 : ℤ) ∈ l
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_le : a \ b ≤ a
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pushoutCoconeOfRightIso_ι_app_right :
    (pushoutCoconeOfRightIso f g).ι.app right = inv g ≫ f
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_rank_le_of_isAlgebraic_right (L : IntermediateField F K)
    [halg : Algebra.IsAlgebraic F L] :
    Module.rank E (adjoin E (L : Set K)) ≤ Module.rank F L
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem bne_eq_false_iff_eq [BEq α] [LawfulBEq α] (a b : α) :
    (a != b) = false ↔ a = b
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem adjoin_toSubmodule (s : Set A) :
    (adjoin R s).toSubmodule = Submodule.span R (NonUnitalSubsemiring.closure s : Set A)
-- Mathlib/NumberTheory/Harmonic/GammaDeriv.lean
private lemma HasDerivAt.complex_of_real {f : ℂ → ℂ} {g : ℝ → ℝ} {g' s : ℝ}
    (hf : DifferentiableAt ℂ f s) (hg : HasDerivAt g g' s) (hfg : ∀ s : ℝ, f ↑s = ↑(g s)) :
    HasDerivAt f ↑g' s
-- Mathlib/Order/WithBot.lean
theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
    a < WithBot.ofDual b ↔ b < WithTop.toDual a
-- Mathlib/Topology/Constructions.lean
theorem isOpenMap_ofDual : IsOpenMap (ofDual : Xᵒᵈ → X)
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem mul_polyOfInterest_vars (n : ℕ) :
    ((p : 𝕄) ^ (n + 1) * polyOfInterest p n).vars ⊆ univ ×ˢ range (n + 1)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_const_const (c : E) {c' : F''} (hc' : c' ≠ 0) (l : Filter α) :
    IsBigOWith (‖c‖ / ‖c'‖) l (fun _x : α => c) fun _x => c'
-- Mathlib/Topology/Order/MonotoneContinuity.lean
/-- If a function `f` is strictly monotone on a left neighborhood of `a` and the image of this
neighborhood under `f` includes `Iio (f a)`, then `f` is continuous at `a` from the left. -/
theorem StrictMonoOn.continuousWithinAt_left_of_surjOn {f : α → β} {s : Set α} {a : α}
    (h_mono : StrictMonoOn f s) (hs : s ∈ 𝓝[≤] a) (hfs : SurjOn f s (Iio (f a))) :
    ContinuousWithinAt f (Iic a) a
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem twoBlockTriangular_det (M : Matrix m m R) (p : m → Prop) [DecidablePred p]
    (h : ∀ i, ¬p i → ∀ j, p j → M i j = 0) :
    M.det = (toSquareBlockProp M p).det * (toSquareBlockProp M fun i => ¬p i).det
-- Mathlib/Data/List/Sigma.lean
theorem sizeOf_kerase [SizeOf (Sigma β)] (x : α)
    (xs : List (Sigma β)) : SizeOf.sizeOf (List.kerase x xs) ≤ SizeOf.sizeOf xs
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
lemma rightHomologyMap_congr (h : Homotopy φ₁ φ₂) [S₁.HasRightHomology] [S₂.HasRightHomology] :
    rightHomologyMap φ₁ = rightHomologyMap φ₂
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem USize.size_eq : USize.size = 2 ^ System.Platform.numBits
-- Mathlib/Data/Finset/Sigma.lean
theorem inf_sigma [SemilatticeInf β] [OrderTop β] :
    (s.sigma t).inf f = s.inf fun i => (t i).inf fun b => f ⟨i, b⟩
-- Mathlib/Order/Minimal.lean
theorem maximals_eq_maximals_of_subset_of_forall [IsTrans α r] (hts : t ⊆ s)
    (h : ∀ x ∈ s, ∃ y ∈ t, r x y) : maximals r s = maximals r t
-- Mathlib/Topology/Sheaves/LocalPredicate.lean
/-- The `stalkToFiber` map is surjective at `x` if
every point in the fiber `T x` has an allowed section passing through it.
-/
theorem stalkToFiber_surjective (P : LocalPredicate T) (x : X)
    (w : ∀ t : T x, ∃ (U : OpenNhds x) (f : ∀ y : U.1, T y) (_ : P.pred f), f ⟨x, U.2⟩ = t) :
    Function.Surjective (stalkToFiber P x)
-- Mathlib/Probability/Independence/Conditional.lean
theorem CondIndepFun.comp {γ γ' : Type*} {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'}
    {_mγ : MeasurableSpace γ} {_mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'}
    (hfg : CondIndepFun m' hm' f g μ) (hφ : Measurable φ) (hψ : Measurable ψ) :
    CondIndepFun m' hm' (φ ∘ f) (ψ ∘ g) μ
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_coe_ne_top_iff_summable {f : β → ℝ≥0} : (∑' b, (f b : ℝ≥0∞)) ≠ ∞ ↔ Summable f
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp]
lemma Isometry.fst_comp_inr (Q₁ : QuadraticMap R M₁ P) :
    (fst M₂ Q₁).comp (inr Q₁ (0 : QuadraticMap R M₂ P)) = 0
-- Mathlib/Order/Filter/Pi.lean
@[simp]
theorem pi_inf_principal_pi_neBot [∀ i, NeBot (f i)] {I : Set ι} :
    NeBot (pi f ⊓ 𝓟 (I.pi s)) ↔ ∀ i ∈ I, NeBot (f i ⊓ 𝓟 (s i))
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem himp_iff_imp (p q : Prop) : p ⇨ q ↔ p → q
-- Mathlib/Computability/Language.lean
@[simp]
lemma reverse_iSup {ι : Sort*} (l : ι → Language α) : (⨆ i, l i).reverse = ⨆ i, (l i).reverse
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem lift_comp_inr : (lift f₁ f₂ h).comp inr = f₂
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfRoot_gen (pb : PowerBasis A S) (pb' : PowerBasis A S')
    (h₁ : aeval pb.gen (minpoly A pb'.gen) = 0) (h₂ : aeval pb'.gen (minpoly A pb.gen) = 0) :
    pb.equivOfRoot pb' h₁ h₂ pb.gen = pb'.gen
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- The morphism `m` in a factorisation `f = e ≫ m` through a monomorphism is uniquely
determined. -/
@[ext]
theorem ext {F F' : MonoFactorisation f} (hI : F.I = F'.I)
    (hm : F.m = eqToHom hI ≫ F'.m) : F = F'
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma rnDeriv_pos [HaveLebesgueDecomposition μ ν] (hμν : μ ≪ ν) :
    ∀ᵐ x ∂μ, 0 < μ.rnDeriv ν x
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma mul_div_cancel_left_of_imp (h : a = 0 → b = 0) : a * b / a = b
-- Mathlib/Algebra/Ring/NegOnePow.lean
lemma negOnePow_def (n : ℤ) : n.negOnePow = (-1 : ℤˣ) ^ n
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem linear_bijective_iff (f : P1 →ᵃ[k] P2) :
    Function.Bijective f.linear ↔ Function.Bijective f
-- Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean
/-- The integrals of thickened indicators of a closed set against a finite measure tend to the
measure of the closed set if the thickening radii tend to zero. -/
theorem tendsto_lintegral_thickenedIndicator_of_isClosed {Ω : Type*} [MeasurableSpace Ω]
    [PseudoEMetricSpace Ω] [OpensMeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ] {F : Set Ω}
    (F_closed : IsClosed F) {δs : ℕ → ℝ} (δs_pos : ∀ n, 0 < δs n)
    (δs_lim : Tendsto δs atTop (𝓝 0)) :
    Tendsto (fun n ↦ lintegral μ fun ω ↦ (thickenedIndicator (δs_pos n) F ω : ℝ≥0∞)) atTop
      (𝓝 (μ F))
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_pair_eq_toReal : ({x, y} : Set α).infsep = (edist x y).toReal
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_union :
    (s ∪ t).Pairwise r ↔
    s.Pairwise r ∧ t.Pairwise r ∧ ∀ a ∈ s, ∀ b ∈ t, a ≠ b → r a b ∧ r b a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem ediv_eq_iff_eq_mul_right {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a / b = c ↔ a = b * c
-- Mathlib/Data/Set/Finite.lean
/-- Projection of `Set.Finite` to its `Finite` instance.
This is intended to be used with dot notation.
See also `Set.Finite.Fintype` and `Set.Finite.nonempty_fintype`. -/
protected theorem Finite.to_subtype {s : Set α} (h : s.Finite) : Finite s
-- Mathlib/Order/Bounds/Basic.lean
theorem bddAbove_Icc : BddAbove (Icc a b)
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- `LinearMap.inl` as an isometry. -/
@[simps!]
def Isometry.inl (Q₁ : QuadraticMap R M₁ P) (Q₂ : QuadraticMap R M₂ P) : Q₁ →qᵢ (Q₁.prod Q₂)
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
theorem isSymmetric_zero : (0 : E →ₗ[𝕜] E).IsSymmetric
-- Mathlib/Data/Complex/Exponential.lean
theorem sin_two_mul : sin (2 * x) = 2 * sin x * cos x
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem norm_comp_le_of_le {g : NormedAddGroupHom V₂ V₃} {C₁ C₂ : ℝ} (hg : ‖g‖ ≤ C₂)
    (hf : ‖f‖ ≤ C₁) : ‖g.comp f‖ ≤ C₂ * C₁
-- Mathlib/GroupTheory/Complement.lean
theorem equiv_snd_eq_inv_mul (g : G) : ↑(hST.equiv g).snd = ((hST.equiv g).fst : G)⁻¹ * g
-- Mathlib/LinearAlgebra/Quotient.lean
/-- Two `LinearMap`s from a quotient module are equal if their compositions with
`submodule.mkQ` are equal.

See note [partially-applied ext lemmas]. -/
@[ext 1100] -- Porting note: increase priority so this applies before `LinearMap.ext`
theorem linearMap_qext ⦃f g : M ⧸ p →ₛₗ[τ₁₂] M₂⦄ (h : f.comp p.mkQ = g.comp p.mkQ) : f = g
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
theorem div_add_mod' (m k : R) : m / k * k + m % k = m
-- Mathlib/Data/ENNReal/Basic.lean
@[simp]
theorem iUnion_Ico_coe_nat : ⋃ n : ℕ, Ico a n = Ici a \ {∞}
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
protected theorem continuous (f : α →ᵇ β) : Continuous f
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem coe_mk : ⇑(γ : C(I, X)) = γ
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_comap {x : L} : x ∈ comap f J ↔ f x ∈ J
-- Mathlib/Algebra/Ring/AddAut.lean
@[simp]
theorem mulRight_apply (u : Rˣ) (x : R) : mulRight u x = x * u
-- Mathlib/Topology/Compactness/Compact.lean
theorem isCompact_iff_compactSpace : IsCompact s ↔ CompactSpace s
-- Mathlib/RingTheory/Nilpotent/Lemmas.lean
@[simp]
theorem nilradical_eq_zero (R : Type*) [CommSemiring R] [IsReduced R] : nilradical R = 0
-- Mathlib/MeasureTheory/Measure/Dirac.lean
@[simp]
theorem restrict_singleton (μ : Measure α) (a : α) : μ.restrict {a} = μ {a} • dirac a
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem liftQ_apply (f : M →ₛₗ[τ₁₂] M₂) {h} (x : M) : p.liftQ f h (Quotient.mk x) = f x
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If `𝓕 : ι → X → α` tends to `f : X → α` *pointwise* along some nontrivial filter, and if the
family `𝓕` is equicontinuous at some `x₀ : X`, then the limit is continuous at `x₀`. -/
theorem Filter.Tendsto.continuousAt_of_equicontinuousAt {l : Filter ι} [l.NeBot] {F : ι → X → α}
    {f : X → α} {x₀ : X} (h₁ : Tendsto F l (𝓝 f)) (h₂ : EquicontinuousAt F x₀) :
    ContinuousAt f x₀
-- Mathlib/Dynamics/Ergodic/Conservative.lean
/-- Poincaré recurrence theorem: given a conservative map `f` and a measurable set `s`,
almost every point `x ∈ s` returns back to `s` infinitely many times. -/
theorem ae_mem_imp_frequently_image_mem (hf : Conservative f μ) (hs : NullMeasurableSet s μ) :
    ∀ᵐ x ∂μ, x ∈ s → ∃ᶠ n in atTop, f^[n] x ∈ s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_linear (ha : a ≠ 0) : leadingCoeff (C a * X + C b) = a
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem coe_sub_interval : (↑(s - t) : Interval α) = s - t
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
@[simp]
theorem cpow_eq_zero_iff (x y : ℂ) : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
-- Mathlib/Topology/Instances/AddCircle.lean
theorem continuousAt_toIcoMod : ContinuousAt (toIcoMod hp a) x
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem bind_def {α β} (f : Filter α) (m : α → Filter β) : f >>= m = bind f m
-- Mathlib/Data/Rat/Cast/Defs.lean
lemma commute_cast (a : α) (q : ℚ≥0) : Commute a q
-- Mathlib/Algebra/Order/CompleteField.lean
theorem coe_mem_cutMap_iff [CharZero β] : (q : β) ∈ cutMap β a ↔ (q : α) < a
-- Mathlib/Analysis/Complex/Basic.lean
/-- The `abs` function on `ℂ` is proper. -/
theorem tendsto_abs_cocompact_atTop : Tendsto abs (cocompact ℂ) atTop
-- Mathlib/Topology/Semicontinuous.lean
theorem Continuous.comp_lowerSemicontinuousOn_antitone {g : γ → δ} {f : α → γ} (hg : Continuous g)
    (hf : LowerSemicontinuousOn f s) (gmon : Antitone g) : UpperSemicontinuousOn (g ∘ f) s
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem map_apply_div {R F : Type*} [CommRing R] [IsDomain R]
    [FunLike F K[X] R[X]] [MonoidWithZeroHomClass F K[X] R[X]]
    (φ : F) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) (p q : K[X]) :
    map φ hφ (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap _ _ (φ p) / algebraMap _ _ (φ q)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem fst_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
    (h : Function.RightInverse f₂ f₁) (x : M) : (equivOfRightInverse f₁ f₂ h x).1 = f₁ x
-- Mathlib/Algebra/Quaternion.lean
theorem normSq_smul (r : R) (q : ℍ[R]) : normSq (r • q) = r ^ 2 * normSq q
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffineLift_zero : toAffineLift (0 : W.Point) = 0
-- Mathlib/Data/Fintype/Order.lean
theorem Directed.finite_set_le (D : Directed r f) {s : Set γ} (hs : s.Finite) :
    ∃ z, ∀ i ∈ s, r (f i) (f z)
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
theorem finrank_strictMono [FiniteDimensional K V] :
    StrictMono fun s : Submodule K V => finrank K s
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_right_comm {m : δ → γ → ε} {n : α → β → δ} {m' : α → γ → δ'} {n' : δ' → β → ε}
    (h_right_comm : ∀ a b c, m (n a b) c = n' (m' a c) b) :
    map₂ m (map₂ n f g) h = map₂ n' (map₂ m' f h) g
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le_def (a b : Int) : a ≤ b ↔ NonNeg (b - a)
-- Mathlib/Algebra/Homology/Localization.lean
/-- The localizer morphism which expresses that `F.mapHomologicalComplex c` preserves
quasi-isomorphisms. -/
@[simps]
def mapHomologicalComplexUpToQuasiIsoLocalizerMorphism :
    LocalizerMorphism (HomologicalComplex.quasiIso C c) (HomologicalComplex.quasiIso D c)
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem trans_apply (c : M₁) : (e₁₂.trans e₂₃ : M₁ ≃ₛₗ[σ₁₃] M₃) c = e₂₃ (e₁₂ c)
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
theorem dist_of_mem_subset_mk_sphere {p c : P} {ps : Set P} {r : ℝ} (hp : p ∈ ps)
    (hps : ps ⊆ ↑(⟨c, r⟩ : Sphere P)) : dist p c = r
-- Mathlib/Data/Num/Lemmas.lean
theorem zneg_zneg (n : ZNum) : - -n = n
-- Mathlib/NumberTheory/LSeries/Convolution.lean
lemma toArithmeticFunction_congr {R : Type*} [Zero R] {f f' : ℕ → R}
    (h : ∀ {n}, n ≠ 0 → f n = f' n) :
    toArithmeticFunction f = toArithmeticFunction f'
-- Mathlib/RingTheory/WittVector/Frobenius.lean
theorem frobenius_bijective [PerfectRing R p] :
    Function.Bijective (@WittVector.frobenius p R _ _)
-- Mathlib/Algebra/Order/Module/Defs.lean
@[simp]
lemma smul_lt_smul_iff_of_pos_right [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    a₁ • b < a₂ • b ↔ a₁ < a₂